一、前文摘要

? ? ? ? 在前文(1条消息) 基于MNIST数据集的卷积神经网络编程_8月5日星期4的博客-CSDN博客中，对卷积神经网络的基础知识和相应的代码及注释做了介绍，本文主要对前文还未解决的问题做解释，即在检测测试集预测正确率，并且，选择keep_prob=1时，dropout层的输出全部为nan，这个问题在下面的程序中已经解决，初步猜测是由于本人用的是tensorflow2.0版本，而所模仿的文章都是基于tensorflow1.0版本，所以会出现这种问题

二、代码及注释部分

# -*- coding: utf-8 -*-
"""
Created on Mon Aug  2 16:58:18 2021

@author: 赵迪
"""
'''
import tensorflow as tf
from matplotlib import pyplot as plt
import numpy as np
mnist=tf.keras.datasets.mnist
(x_train,label_train),(x_test,label_test)=mnist.load_data()
plt.imshow(x_train[0],'binary')
plt.imshow(x_train[5])
#权重函数
def weight(shape):
    return np.random.random(shape)
#偏置函数
def bias(shape):
    return np.random.random(shape)
'''
'''
import tensorflow as tf
import numpy as np
import matplotlib
import matplotlib.pyplot as plt

mnist=tf.keras.datasets.mnist
(x_train,label_train),(x_test,label_test)=mnist.load_data()
tf.compat.v1.disable_eager_execution()
x=tf.compat.v1.placeholder(tf.float32,[None,784])
y_=tf.compat.v1.placeholder(tf.float32,[None,10])

#权重生成函数，生成的是元素在（-1，1）范围内的随机数
def weight(shape):
    initial=tf.compat.v1.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)
#偏置生成函数，生成初始元素为1e-2的初始偏置矩阵
def bias(shape):
    initial=tf.constant(1e-2,shape=shape)
    return tf.Variable(initial)
#卷积函数
def conv(x,W):
    result=tf.nn.conv2d(x,W,strides=[1,1,1,1], padding='SAME')
    return result
def pooling(x):
    result=tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')#在池化中，padding=‘same’和padding=‘valid’输出结果一样
    return result
#第一个卷积曾
W1_conv=weight([5,5,1,32])#第一卷积层卷积核数目为32
b1_conv=bias([32])
x_image=tf.reshape(x,[-1,28,28,1])
result1_conv=conv(x_image,W1_conv)
h1_conv=tf.nn.relu(result1_conv+b1_conv)
#第一个池化层
result1_pooling=pooling(h1_conv)
#第二个卷积层
W2_conv=weight([5,5,32,64])
b2_conv=bias([64])
result2_conv=conv(result1_pooling,W2_conv)
h2_conv=tf.nn.relu(result2_conv+b2_conv) 
#第二个池化层
result2_pooling=pooling(h2_conv)

W3_full_connect=weight([7*7*64,1024])
b3_full_connect=bias([1024])
result2_pooling_flat=tf.reshape(result2_pooling,[-1,7*7*64])
result3_full_connect=tf.matmul(result2_pooling_flat,W3_full_connect)+b3_full_connect
h3_full_connect=tf.nn.relu(result3_full_connect)

keep_prob=tf.compat.v1.placeholder("float")
h_fc1_drop=tf.nn.dropout(h3_full_connect, keep_prob)
W4_full_connect=weight([1024,10])
b4_full_connect=bias([10])
result4_fc=tf.matmul(h_fc1_drop,W4_full_connect)
y_fc=tf.nn.softmax(result4_fc+b4_full_connect)
cost=-tf.reduce_sum(y_*tf.compat.v1.log(y_fc))
train_step=tf.compat.v1.train.AdamOptimizer(1e-4).minimize(cost)
correct_prediction=tf.equal(tf.argmax(y_fc,1), tf.argmax(y_,1))
correct_prediction=tf.cast(correct_prediction,"float")
accuracy=tf.reduce_mean(correct_prediction)
saver=tf.compat.v1.train.Saver()
with tf.compat.v1.Session() as sess:
    sess.run(tf.compat.v1.global_variables_initializer())
    for i in range(20000):
        batch=mnist.train.next_batch(50)
        if i%100==0:
            train_accuracy=accuracy.eval(feed_dict={x:batch[0],y_:batch[1],keep_prob:1})
            print('step %d,training accuracy:%g'%(i,train_accuracy))
        train_step.run(feed_dict={x:batch[0],y_:batch[1],keep_prob:0.5})
    saver.save(sess,'WModel/model.ckpt')
    print('test accuracy %g '%accuracy.eval(feed_dict={x:mnist.test.images,y_:mnist.test.labels,keep_prob:1}))
'''
'''测试tf.Variable()的代码
import tensorflow as tf
tf.compat.v1.disable_eager_execution()
sess = tf.compat.v1.Session()
v1=tf.Variable(tf.random.normal(shape=[4,3],mean=0,stddev=1),name='v1')
v2=tf.Variable(tf.constant(2),name='v2')
v3=tf.Variable(tf.ones([4,3]),name='v3')
alpha=tf.Variable(10)
sess.run(tf.compat.v1.global_variables_initializer())
print(sess.run(v1))
print(sess.run(v2))
print(sess.run(v3))
print(sess.run(alpha))
'''
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from random import sample
from tensorflow.python.keras.utils.np_utils import to_categorical
import random
global b_szie
b_size=100
tf.compat.v1.disable_eager_execution()
mnist=tf.keras.datasets.mnist
(x_train,y_train),(x_test,y_test)=mnist.load_data()
'''
x_train=np.reshape(x_train,[-1,28*28])
x_test=np.reshape(x_test,[-1,28*28])
'''
x_train=x_train/255
x_test=x_test/255
y_train=to_categorical(y_train, num_classes=None)
y_test=to_categorical(y_test, num_classes=None)
'''
def batch_read(data1,data2,batch_size):
    #x_result=np.zeros([None,28,28])
    #y_result=np.zeros(10)
    x_result=np.zeros([batch_size,28,28])
    y_result=np.zeros([batch_size,10])
    for i in range(batch_size):
        index=random.randint(0,60000-1)
        x_result[i]=data1[index]
        y_result[i]=data2[index]
    
    return x_result,y_result
    #return x_result,y_result
'''
'''测试代码
def batch_read(data1,data2,batch_size):
    x_result=np.zeros(784)
    y_result=np.zeros(784)
    for i in range(50):
        index=random.randint(0,60000)
        if i==0:
            x_result=x_train[index]
            y_result=y_train[index]
        else:
            x_result=np.stack((x_result,x_train[index]))
            y_result=np.stack((y_result,y_train[index]))
            
    return x_result,y_result
'''
'''测试代码
def batch_read(data1,data2,batch_size):
    x_result=np.zeros(784)
    y_result=np.zeros(784)
    for i in range(batch_size):
        index=random.randint(0,60000)
        if i==0:
            x_result=data1[index]
            y_result=data2[index]
        else:
            x_result=np.vstack((x_result,data1[index]))
            y_result=np.vstack((y_result,data2[index]))
            
    return x_result,y_result
c=batch_read(x_train,y_train,20)

'''
'''测试代码
def check(data):
    for i in range(len(data)):
        temp=data[i]
        temp1=np.zeros(10)
        for j in range(10):
            if j==temp:
                temp1[j]=1
        data[i]=temp1
    return data
c1=check(c[1])
'''
def batch_read(data1,data2):
    global b_size
    x=np.zeros([b_size,28,28])
    y=np.zeros([b_size,10])
    for i in range(b_size):
        index=random.randint(0,60000-1)
        x[i]=data1[index]
        y[i]=data2[index]
    return x,y 
'''
b=batch_read(x_train,y_train)
print(b[0].shape)
'''
def acc_compute(x_test,y_test):
    global prediction
    y_pre=sess.run(prediction,feed_dict={x:x_test,keep_prob:0.8})
   
    correct_pred=sess.run(tf.equal(np.argmax(y_pre,1),np.argmax(y_test,1)))
    #此处要注意，暂时不知道y_pre的输出shape是多少，暂时axis=1
    accuracy=sess.run(tf.reduce_mean(tf.cast(correct_pred,tf.float32)))
    #result=sess.run(accuracy,feed_dict={x:x_test,y:y_test})
    return accuracy
def weight(shape):
    initial=tf.compat.v1.truncated_normal(shape,mean=0,stddev=0.1)
    return tf.Variable(initial)
def bias(shape):
    initial=tf.constant(0.1,dtype=tf.float32,shape=shape)
    return tf.Variable(initial)
def conv(x,W):
    #strides=[1,x_movement,y_movement,1]
    return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
def max_pool_2x2(x):
    return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
x=tf.compat.v1.placeholder(tf.float32,[None,28,28])
y=tf.compat.v1.placeholder(tf.float32,[None,10])
keep_prob=tf.compat.v1.placeholder(tf.float32)
x_image=tf.reshape(x,[-1,28,28,1])
# [-1, reshape_height, reshape_weight, imagine layers]

#***********************conv1***************************
shape1=[5,5,1,32]
w1=weight(shape1)
b1=bias([32])
f1=conv(x_image,w1)
h1=tf.nn.relu(f1+b1)
#*********************max_pooling1**********************
p1=max_pool_2x2(h1)
#********************conv2******************************
shape2=[5,5,32,64]
w2=weight(shape2)
b2=bias([64])
f2=conv(p1,w2)
h2=tf.nn.relu(f2+b2)
#********************max_pooling2***********************
p2=max_pool_2x2(h2)
#**********************full_connect1********************
shape3=[7*7*64,1024]
w3=weight(shape3)
b3=bias([1024])
## reshape the image from 7,7,64 into a flat (7*7*64)
p2_flat=tf.reshape(p2,[-1,7*7*64])
f3=tf.nn.relu(tf.matmul(p2_flat,w3)+b3)
h3=tf.compat.v1.nn.dropout(f3,keep_prob)
#*********************full_connect2*********************
shape4=[1024,10]
w4=weight(shape4)
b4=bias([10])
pro=tf.matmul(tf.compat.v1.nn.dropout(f3,keep_prob),w4)+b4
prediction=tf.nn.softmax(pro)
#h4=tf.nn.dropout(f4,keep_prob)
#********************网络训练部分************************
cost=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=prediction))
#cost=-tf.reduce_sum(y*tf.compat.v1.log(tf.clip_by_value(prediction,1e-3,1)),1)
#cost=tf.nn.softmax_cross_entropy_with_logits(y,prediction,axis=-1)
#cost=(-tf.reduce_sum(y*tf.compat.v1.log(prediction),1))
#cost=(-tf.reduce_sum(y*tf.compat.v1.log(prediction)+(1-y)*tf.compat.v1.log(1-prediction),1))
train_step=tf.compat.v1.train.AdamOptimizer(1e-3).minimize(cost)
with tf.compat.v1.Session() as sess:
    sess.run(tf.compat.v1.global_variables_initializer())
    for i in range(1000):
        b=batch_read(x_train,y_train)
        sess.run(train_step,feed_dict={x:b[0],y:b[1],keep_prob:0.5})
        #测试集正确率
    print(acc_compute(x_test[:1000],y_test[:1000]))
        #训练集正确率
          #  print(acc_compute(x_train[:10],y_train[:10]))
    #y_pre=sess.run(prediction,feed_dict={x:x_test,keep_prob:0.8})
    #correct_pred=sess.run(tf.equal(tf.argmax(y_pre,1),tf.argmax(y_test,1)))
    #accuracy=sess.run(tf.reduce_mean(tf.cast(correct_pred,tf.float32)))
    #print(accuracy)
                  
        
'''测试代码
def ad(a,b):
    return a,b
a=np.ones([2,2])
b=np.random.random([3,3])
c,d=ad(a,b)

'''
'''测试代码
def f(x_train):
    b=100
    x=np.zeros([b,28,28])
    for i in range(b):
        index=random.randint(0,60000-1)
        x[i]=x_train[index]
    #print(x.shape)
    return x
b=f(x_train)
print(b.shape)
'''
'''
        batch_x=np.zeros([b_size,28,28])
        batch_y=np.zeros([b_size,10])
        for i in range(b_size):
            index=random.randint(0,60000-1)
            batch_x[i]=x_train[index]
            batch_y[i]=y_train[index]
'''
'''测试代码
with tf.compat.v1.Session() as sess:
    sess.run(tf.compat.v1.global_variables_initializer())
    for i in range(1000):
        b=batch_read(x_train,y_train)
        sess.run(train_step,feed_dict={x:b[0],y:b[1],keep_prob:0.5})
    pro=tf.matmul(tf.compat.v1.nn.dropout(f3,keep_prob),w4)+b4
    y_pre=sess.run(tf.nn.softmax(pro),feed_dict={x:x_test[:100],keep_prob:1})
    correct_pred=sess.run(tf.equal(tf.argmax(y_pre,1),tf.argmax(y_test[:100],1)))
    #print(y_pre[0:3])
    print(correct_pred)
   
    
'''
'''测试代码
sess.close()
sess=tf.compat.v1.Session()
sess.run(tf.compat.v1.global_variables_initializer())
for i in range(1000):
    b=batch_read(x_train,y_train)
    sess.run(train_step,feed_dict={x:b[0],y:b[1],keep_prob:0.5})
y_pre=sess.run(tf.nn.softmax(tf.matmul(h3,w4)+b4),feed_dict={x:x_test[:10000],keep_prob:0.8})
correct_pred=sess.run(tf.equal(tf.argmax(y_pre,1),tf.argmax(y_test[:10000],1)))
print(y_pre[0:3])
print('***********************************************************')
print(y_test[:3])
print('***********************************************************')
print(correct_pred)
print('***********************************************************')
accuracy=sess.run(tf.reduce_mean(tf.cast(correct_pred,tf.float32)))
print(accuracy)
sess.close()
'''
'''测试代码
sess.close()
sess=tf.compat.v1.Session()
sess.run(tf.compat.v1.global_variables_initializer())
for i in range(1000):
    b=batch_read(x_train,y_train)
    sess.run(train_step,feed_dict={x:b[0],y:b[1],keep_prob:0.5})
y_pre=sess.run(prediction,feed_dict={x:x_test,keep_prob:1})
correct_pred=sess.run(tf.equal(tf.argmax(y_pre,1),tf.argmax(y_test,1)))
print(y_pre[0:3])
print('***********************************************************')
print(y_test[:3])
print('***********************************************************')
print(correct_pred)
print('***********************************************************')
accuracy=sess.run(tf.reduce_mean(tf.cast(correct_pred,tf.float32)))
print(accuracy)
sess.close()
'''