tensorflow搭建数字图像分类nmist(单层和双层网络全连接)

柔情只为你懂 2023-03-14 05:25 90阅读 0赞

### 文章目录 ###

*  一、数据
 *   *  1、数据
     *  2、普通神经网络单层 0-9分类预测
     *  3、普通神经网络双层 0-9分类预测
     *   *  修改参数后的结果

值得学习的地方是：**框架**

# 一、数据 #

## 1、数据 ##

import tensorflow as tf
    from tensorflow.examples.tutorials.mnist import input_data
    # 这里tensorflow自带下载， 如果本地没有， 自动下载并解析
    #载入数据集
    mnist = input_data.read_data_sets("../data/mnist_data",
                                      one_hot=True,
                                      reshape=True,) # 28, 28, 1 如果是true, 则为28*28 1
    print(mnist.train.num_examples)
    print(mnist.test.num_examples)
    print(mnist.train.images[0].shape)
    print(mnist.train.num_examples) # 样本个数
    print(mnist.train.images.shape) # 样本形状

Extracting ../data/mnist_data\train-images-idx3-ubyte.gz
    Extracting ../data/mnist_data\train-labels-idx1-ubyte.gz
    Extracting ../data/mnist_data\t10k-images-idx3-ubyte.gz
    Extracting ../data/mnist_data\t10k-labels-idx1-ubyte.gz
    55000
    10000
    (784,)
    55000
    (55000, 784)

[首先交叉熵的计算函数][Link 1]

## 2、普通神经网络单层 0-9分类预测 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70]

# 2 函数用于清除默认图形堆栈并重置全局默认图形
    tf.reset_default_graph()
    
    # 输入
    x = tf.placeholder(tf.float32, [None, 784])
    y = tf.placeholder(tf.float32, [None, 10])
    
    # 参数
    W1 = tf.Variable(tf.random_normal([784,10], seed=180))
    b1 = tf.Variable(tf.zeros(10))
    
    # 正向
    out1 = tf.matmul(x, W1)+b1
    pred2 = tf.nn.softmax(out1)
    
    # 反向 
    # 交叉熵运算, 然后在取平均值
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels = y,logits = out1)  # 这里一定要注意， 是输出层前面的输出
    # loss = tf.reduce_mean(-tf.reduce_sum(y*tf.log(pred2), reduction_indices=1)) # 正经的交叉熵计算公式， 
                          
    # 优化器, 最小损失函数
    learning_rate=0.01 
    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
    
    #通过当前结果计算精度
    correct_prediction = tf.equal(tf.argmax(pred2,1),tf.argmax(y,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float32"))
    
    epochs=25
    batch_size=100
    # sess = tf.Session()
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        total_batch = int(mnist.train.num_examples/batch_size)
        print("总共有batch",total_batch,)
    
        for epoch in range(epochs): # 循环总次数
            avg_loss = 0
            for batch in range(total_batch):
                batch_input, batch_labels = mnist.train.next_batch(batch_size) #每次训练的批数
                # 优化器优化
                _,train_loss = sess.run([optimizer,loss],feed_dict={ x:batch_input,
                                                                    y:batch_labels})
                # 计算loss值
                avg_loss += (train_loss/total_batch)
    
                # 显示训练数据
                # if i%total_batch == 0:
            train_accuracy = accuracy.eval(session=sess,feed_dict={ x:batch_input,y:batch_labels})
            test_accuracy = accuracy.eval(session=sess,feed_dict={ x: mnist.test.images, y: mnist.test.labels})
            print(f"epoch={epoch} , training accuracy={train_accuracy:0.3f},avg_loss={avg_loss:0.3f}, test_accuracy={test_accuracy:0.3f}")

总共有batch 550
    epoch=0 , training accuracy=0.220,avg_loss=8.379, test_accuracy=0.268
    epoch=1 , training accuracy=0.440,avg_loss=4.287, test_accuracy=0.463
    epoch=2 , training accuracy=0.630,avg_loss=2.905, test_accuracy=0.573
    epoch=3 , training accuracy=0.630,avg_loss=2.294, test_accuracy=0.633
    epoch=4 , training accuracy=0.570,avg_loss=1.954, test_accuracy=0.674
    epoch=5 , training accuracy=0.730,avg_loss=1.735, test_accuracy=0.700
    epoch=6 , training accuracy=0.710,avg_loss=1.582, test_accuracy=0.722
    epoch=7 , training accuracy=0.740,avg_loss=1.467, test_accuracy=0.738
    epoch=8 , training accuracy=0.780,avg_loss=1.378, test_accuracy=0.750
    epoch=9 , training accuracy=0.760,avg_loss=1.306, test_accuracy=0.760
    epoch=10 , training accuracy=0.770,avg_loss=1.246, test_accuracy=0.770
    epoch=11 , training accuracy=0.740,avg_loss=1.195, test_accuracy=0.776
    epoch=12 , training accuracy=0.850,avg_loss=1.151, test_accuracy=0.784
    epoch=13 , training accuracy=0.760,avg_loss=1.113, test_accuracy=0.790
    epoch=14 , training accuracy=0.860,avg_loss=1.079, test_accuracy=0.796
    epoch=15 , training accuracy=0.840,avg_loss=1.049, test_accuracy=0.801
    epoch=16 , training accuracy=0.780,avg_loss=1.022, test_accuracy=0.806
    epoch=17 , training accuracy=0.810,avg_loss=0.998, test_accuracy=0.809
    epoch=18 , training accuracy=0.780,avg_loss=0.975, test_accuracy=0.812
    epoch=19 , training accuracy=0.850,avg_loss=0.955, test_accuracy=0.816
    epoch=20 , training accuracy=0.810,avg_loss=0.936, test_accuracy=0.819
    epoch=21 , training accuracy=0.790,avg_loss=0.918, test_accuracy=0.820
    epoch=22 , training accuracy=0.780,avg_loss=0.902, test_accuracy=0.823
    epoch=23 , training accuracy=0.770,avg_loss=0.887, test_accuracy=0.826
    epoch=24 , training accuracy=0.860,avg_loss=0.872, test_accuracy=0.827

## 3、普通神经网络双层 0-9分类预测 ##

# 输入
    x = tf.placeholder(tf.float32, [None, 784])
    y = tf.placeholder(tf.float32, [None, 10])
    
    # 参数
    W1 = tf.Variable(tf.random_normal([784,50]))
    b1 = tf.Variable(tf.zeros(50, tf.float32))
    W2 = tf.Variable(tf.random_normal([50,10]))
    b2 = tf.Variable(tf.zeros(10, tf.float32))
    
    # 正向
    z1    = tf.nn.relu(tf.matmul(x, W1)+b1)
    # pred2 = tf.nn.softmax(tf.matmul(z1, W2)+b2)
    pred2 = (tf.matmul(z1, W2)+b2)
    # 反向 
    #损失值。指定tf.nn.softmax_cross_entropy_with_logits模块下交叉熵损失函数，labels为数据中的真实值，logits为预测值
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels = y,
                                                                  logits = pred2))
    # 优化器, 最小损失函数
    learning_rate=0.01 
    optimizer = tf.train.AdamOptimizer(learning_rate).minimize(loss)
    
    #通过当前结果计算精度
    correct_prediction = tf.equal(tf.argmax(pred2,1),tf.argmax(y,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float32"))
    
    epochs=25
    batch_size=100
    # sess = tf.Session()
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        total_batch = int(mnist.train.num_examples/batch_size)
        print("总共有batch",total_batch,)
    
        for epoch in range(epochs): # 循环总次数
            avg_loss = 0
            for batch in range(total_batch):
                batch_input, batch_labels = mnist.train.next_batch(batch_size) #每次训练的批数
                # 优化器优化
                _,train_loss = sess.run([optimizer,loss],feed_dict={ x:batch_input,
                                                                    y:batch_labels})
                # 计算loss值
                avg_loss += (train_loss/total_batch)
    
                # 显示训练数据
                # if i%total_batch == 0:
            train_accuracy = accuracy.eval(session=sess,feed_dict={ x:batch_input,y:batch_labels})
            test_accuracy = accuracy.eval(session=sess,feed_dict={ x: mnist.test.images, y: mnist.test.labels})
            print(f"epoch={epoch} , training accuracy={train_accuracy:0.3f},avg_loss={avg_loss:0.3f}, test_accuracy={test_accuracy:0.3f}")

epoch=23 , training accuracy=0.960,avg_loss=0.063, test_accuracy=0.954
    epoch=24 , training accuracy=0.990,avg_loss=0.061, test_accuracy=0.960

### 修改参数后的结果 ###

学习率 0.001  
relu,无:0.942,  
relu,softmax:0.854  
sigmod, softmax:0.855

学习率 0.01  
relu,无:0.960  
relu,softmax:0.868  
sigmod, softmax:0.964

[Link 1]: https://blog.csdn.net/qq_35203425/article/details/79773459
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70]: /images/20230312/d2a4f4dd2aa54f4dafd74247d8a08842.png