Tensorflow之softmax应用实例

痛定思痛。 2023-06-30 02:23 28阅读 0赞

语言：python3.6

框架:   tensorflow

数据集：mnist数据集（图片格式）

1、准备数据集

下载地址：[http://yann.lecun.com/exdb/mnist/][http_yann.lecun.com_exdb_mnist]

用以下的代码将minist数据集转化为图片(也可以通过from tensorflow.examples.tutorials.mnist import input\_data获得二进格式的数据)

"""
    将MNIST数据集由二进制文件转为图片形式，保存于指定文件夹下
    """
    import os
    import struct
    import numpy as np
    import matplotlib.pyplot as plt
    
    # 读MNIST数据集的图片数据
    def mnist_load_img(img_path):
        with open(img_path, "rb") as fp:
            # >是以大端模式读取，i是整型模式，读取前四位的标志位，
            # unpack()函数：是将4个字节联合后再解析成一个数，(读取后指针自动后移)
            msb = struct.unpack('>i', fp.read(4))[0]
            # 标志位为2051，后存图像数据；标志位为2049，后存图像标签
            if msb == 2051:
                # 读取样本个数60000，存入cnt
                cnt = struct.unpack('>i', fp.read(4))[0]
                # rows：行数28；cols：列数28
                rows = struct.unpack('>i', fp.read(4))[0]
                cols = struct.unpack('>i', fp.read(4))[0]
                imgs = np.empty((cnt, rows, cols), dtype="int")
                for i in range(0, cnt):
                    for j in range(0, rows):
                        for k in range(0, cols):
                            # 16进制转10进制
                            pxl = int(hex(fp.read(1)[0]), 16)
                            imgs[i][j][k] = pxl
                return imgs
            else:
                return np.empty(1)
    
    # 读MNIST数据集的图片标签
    def mnist_load_label(label_path):
        with open(label_path, "rb") as fp:
            msb = struct.unpack('>i', fp.read(4))[0];
            if msb == 2049:
                cnt = struct.unpack('>i', fp.read(4))[0];
                labels = np.empty(cnt, dtype="int");
                for i in range(0, cnt):
                    label = int(hex(fp.read(1)[0]), 16);
                    labels[i] = label;
                return labels;
            else:
                return np.empty(1);
    
    # 分割训练、测试集的图片数据与图片标签
    def mnist_load_data(train_img_path, train_label_path, test_img_path, test_label_path):
        x_train = mnist_load_img(train_img_path);
        y_train = mnist_load_label(train_label_path);
        x_test = mnist_load_img(test_img_path);
        y_test = mnist_load_label(test_label_path);
        return (x_train, y_train), (x_test, y_test);
    
    # 输出打印图片
    def mnist_plot_img(img):
        (rows, cols) = img.shape;
        plt.figure();
        plt.gray();
        plt.imshow(img);
        plt.show();
    
    # 按指定位置保存图片
    def mnist_save_img(img, path, name):
        if not os.path.exists(path):
            os.mkdir(path)
        (rows, cols) = img.shape
        fig = plt.figure()
        plt.gray()
        plt.imshow(img)
        # 在既定路径里保存图片
        fig.savefig(path + name)
    
    
    
    # [start]
    x_train = mnist_load_img("train-images.idx3-ubyte")
    y_train = mnist_load_label("train-labels.idx1-ubyte")
    
    # 将打印出的MNIST数据集中所有的图片存入一个data文件夹下
    # for i in range(0, 10):
    #     path = "../CNN+Kreas框架+MNIST/data/data_a/"
    #     name = str(i) + ".png"
    #     mnist_save_img(x_train[i], path, name)
    
    # 按图片标签的不同，打印MNIST数据集的图片存入不同文件夹下
    for i in range(0, len(x_train)):
        path = "./data/" + str(y_train[i]) +"/"
        name = str(i)+".png"
        mnist_save_img(x_train[i], path, name)
    
    
    
    #mnist_plot_img(x_train[0, :, :])
    """
    x_test = mnist_load_img("t10k-images.idx3-ubyte")
    y_test = mnist_load_label("t10k-labels.idx1-ubyte")
    """

代码转自（[https://blog.csdn.net/zzZ\_CMing/article/details/81063977][https_blog.csdn.net_zzZ_CMing_article_details_81063977]）

就会在所指定的目录下发现0~9文件夹，里面存放图片形式的minist数据集，接下来制作训练集（也可以用上面代码中的mnist\_load\_data方法）

2、制作训练集

将图片和相应标签对应起来，用以下代码实现。

如果分类的类别数不为10时需要修改

label_list = tf.one_hot(label_list, depth=10, on_value=1, axis=1)中的depth(输出通道)和

labels_batch = tf.reshape(label_batch, [batch_size, 10])中的10(输出通道)

3、设计网络

with tf.name_scope('Input'):
            X = tf.placeholder(dtype=tf.float32, shape=[None, 784], name='X_placeholder')
            Y = tf.placeholder(dtype=tf.int32, shape=[None, 10], name='Y_placeholder')
    
        # 2、前向网络设计
        with tf.name_scope('Inference'):
            # batch:20 输入：784，通道：1，输出：10
            W = tf.Variable(initial_value=tf.random_normal(shape=[784, 10], stddev=0.01), name='Weights')
            b = tf.Variable(initial_value=tf.zeros(shape=[10]), name='bias')
            print(W)
            logits = tf.matmul(X, W) + b
            Y_pred = tf.nn.softmax(logits=logits)
        # 3、损失函数设计
        with tf.name_scope('Loss'):
            # 求交叉熵损失
            cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=logits, name='cross_entropy')
            # cross_entropy=tf.nn.sparse_softmax_cross_entropy_with_logits(labels=Y, logits=logits, name='cross_entropy')
            # 求平均
            loss = tf.reduce_mean(cross_entropy, name='loss')
    
        # 4、参数学习算法设计
        with tf.name_scope('Optimization'):
            learn_rate=0.001
            optimizer = tf.train.GradientDescentOptimizer(learn_rate).minimize(loss)
    
        # 5、评估节点设计
        with tf.name_scope('Evaluate'):
            # 返回验证集/测试集预测正确或错误的布尔值
            correct_prediction = tf.equal(tf.argmax(Y_pred, 1), tf.argmax(Y, 1))
            # 将布尔值转换为浮点数后，求平均准确率
            accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

用一个全连接网络+softmax网络实现简单分类这里将minist的单张图片展开为\[1,28\*28\]，目的是将图片的每个像素当作其特征放入全连接网络，提取浅层特征，损失函数用交叉熵损失函数(常用于分类网络)

至此主要的工作都以做完了，加下来就是训练了，我把全部训练代码放在这里。

def main(argv=None):
        # 0、准备训练/验证/测试数据集
        log_dir='./'
        batch_size=50
        batch_image, batch_label=Dataset(data_path,50,100).get_batch()
    
        batch_num = Dataset(data_path,50,100).num_batch()
    
    
        # 1、数据输入设计：使用 placeholder 将数据送入网络，None 表示张量的第一个维度可以是任意长度的
        with tf.name_scope('Input'):
            X = tf.placeholder(dtype=tf.float32, shape=[None, 784], name='X_placeholder')
            Y = tf.placeholder(dtype=tf.int32, shape=[None, 10], name='Y_placeholder')
    
        # 2、前向网络设计
        with tf.name_scope('Inference'):
            # batch:20 输入：784，通道：1，输出：10
            W = tf.Variable(initial_value=tf.random_normal(shape=[784, 10], stddev=0.01), name='Weights')
            b = tf.Variable(initial_value=tf.zeros(shape=[10]), name='bias')
            print(W)
            logits = tf.matmul(X, W) + b
            Y_pred = tf.nn.softmax(logits=logits)
        # 3、损失函数设计
        with tf.name_scope('Loss'):
            # 求交叉熵损失
            cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=logits, name='cross_entropy')
            # cross_entropy=tf.nn.sparse_softmax_cross_entropy_with_logits(labels=Y, logits=logits, name='cross_entropy')
            # 求平均
            loss = tf.reduce_mean(cross_entropy, name='loss')
    
        # 4、参数学习算法设计
        with tf.name_scope('Optimization'):
            learn_rate=0.001
            optimizer = tf.train.GradientDescentOptimizer(learn_rate).minimize(loss)
    
        # 5、评估节点设计
        with tf.name_scope('Evaluate'):
            # 返回验证集/测试集预测正确或错误的布尔值
            correct_prediction = tf.equal(tf.argmax(Y_pred, 1), tf.argmax(Y, 1))
            # 将布尔值转换为浮点数后，求平均准确率
            accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
            # correct_prediction=tf.nn.in_top_k(Y_pred, Y, 1)
    
        print('~~~~~~~~~~~开始执行计算图~~~~~~~~~~~~~~')
    
        saver = tf.train.Saver(tf.global_variables(), max_to_keep=10)
        with tf.Session() as sess:
            counter = 0
            summary_writer = tf.summary.FileWriter(logdir=log_dir, graph=sess.graph)
            # 初始化所有变量
            sess.run(tf.global_variables_initializer())
            train_epoch_loss = []
            test_epoch_loss = []
            test_val_acc = []
    
            coord = tf.train.Coordinator()
            threads = tf.train.start_queue_runners(sess=sess, coord=coord)
            try:
                while not coord.should_stop():
                    counter += 1
                    epoch_num = batch_num
                    # 训练
                    while epoch_num >= 0:
                        epoch_num -= 1
                        image_batch_v, label_batch_v = sess.run([batch_image, batch_label])
    
                        _, loss_batch, = sess.run([optimizer, loss], feed_dict={X: image_batch_v, Y: label_batch_v})
                        train_epoch_loss.append(loss_batch)
    
                    # 验证
                    while epoch_num <= batch_num:
                        epoch_num += 1
                        image_batch_v, label_batch_v = sess.run([batch_image, batch_label])
                        test_loss, acc = sess.run([loss, accuracy], feed_dict={X: image_batch_v, Y: label_batch_v})
    
                        test_epoch_loss.append(test_loss)
                        test_val_acc.append(acc)
    
                    mean_train_loss = round(np.mean(np.array(train_epoch_loss)), 3)
                    mean_test_loss = round(np.mean(np.array(test_epoch_loss)), 3)
                    mean_val_acc = round(np.mean(np.array(test_val_acc)), 3)
    
                    print('{} times val_acc is {}, train_loss: {},test_loss:{}'.format(counter, mean_val_acc, mean_train_loss,
                                                                                     mean_test_loss))
    
                    if counter % 300 == 0:
    
                        base_dir = './checkpoint'
                        ckpt_file = base_dir + "/batch_test_loss=%.4f.ckpt" % mean_train_loss
                        print('Save ckpt file to {}'.format(ckpt_file))
                        if os.path.exists(base_dir) == False:
                            os.makedirs(base_dir)
                        saver.save(sess, ckpt_file, global_step=counter)
                    if counter > 1000:
                        break
    
    
            except tf.errors.OutOfRangeError:
                print('Done!')
            finally:
                coord.request_stop()
    
            coord.join(threads)
            summary_writer.close()

4、验证

我们用单张图片进行验证，注意，输入的label和图片维度与训练的维度要一致。验证代码如下：

def prediect2(image):
        labels=np.array([0,1,2,3,4,5,6,7,8,9]).reshape([1,10])#单张时为[1,10],n张时为[n,10]
        trans2np=np.array(image).reshape([1,784])
        with tf.name_scope('Input'):
           x = tf.placeholder(dtype=tf.float32, shape=[None, 784], name='X_placeholder')
           y = tf.placeholder(dtype=tf.int32, shape=[None,10], name='Y_placeholder')
    
        # 2、前向网络设计
        with tf.name_scope('Inference'):
            # batch:20 输入：784，通道：1，输出：10
            W = tf.Variable(initial_value=tf.random_normal(shape=[784,10], stddev=0.01), name='Weights')
            b = tf.Variable(initial_value=tf.zeros(shape=[10]), name='bias')
            print(W)
            logits = tf.matmul(x, W) + b
            pred = tf.nn.softmax(logits=logits)
    
        saver=tf.train.Saver()
    
        with tf.Session() as sess:
            sess.run(tf.global_variables_initializer())
    
            saver.restore(sess, save_path=  './checkpoint/batch_test_loss=0.5550.ckpt-300')
    
            correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
            accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
            print('accuracy: ', accuracy.eval({x:trans2np,y:labels}))
    
            output = tf.argmax(pred, 1)
            outputval,pre = sess.run([output,pred], feed_dict={x: trans2np, y: labels})
            print(outputval)
            print('p:',pre)

最后可以看到答应出了类别对应的ID。

在代码中用了

tf.nn.softmax_cross_entropy_with_logits(logits, labels, name=None)求交叉损失，该方法：

除去name参数用以指定该操作的name，与方法有关的一共两个参数`：`

`第一个参数logits：就是神经网络最后一层的输出，如果有batch的话，它的大小就是[batchsize，num_classes]，单样本的话，大小就是num_classes`

`第二个参数labels：实际的标签，shape必须和logits相同。`

`除了用softmax_cross_entropy_with_logits方法以外还可以用`tf.nn.sparse\_softmax\_cross\_entropy\_with\_logits(labels, logits, name=None)该方法用法比softmax\_cross\_entropy\_with\_logits简单，不用见label转化为one\_hot编码就可以使用。见如下代码：

class Dataset(object):
        def __init__(self,file_path,batch_size,capacity):
            self.file_path=file_path#路径文件
            self.batch_size=batch_size#batch_size
            self.capacity=capacity#队列容量
            self.image_size=28
    
    
    
        def num_batch(self):
            image, label = self.get_files(self.file_path)
            return len(label)//self.batch_size#一批样本中的batch个数
    
    
        def get_batch(self):
            image, label = self.get_files(self.file_path)
            batch_image, batch_label=self.get_batches(image,label,self.image_size,self.image_size,self.batch_size,self.capacity)
            return batch_image,batch_label
    
    
        def get_files(self,file_path):
            class_train = []
            label_train = []
            for train_class in os.listdir(file_path):
                for pic_name in os.listdir(file_path + train_class):
                    class_train.append(file_path + train_class + '/' + pic_name)
                    label_train.append(train_class)
            temp = np.array([class_train, label_train])
            temp = temp.transpose()
            np.random.shuffle(temp)
    
            image_list = list(temp[:, 0])
            label_list = list(temp[:, 1])
            # class is 1 2 3 4 5
            label_list = [int(i) for i in label_list]
    
            return image_list, label_list
    
        def get_batches(self,image, label, resize_w, resize_h, batch_size, capacity):
            image = tf.cast(image, tf.string)
            label = tf.cast(label, tf.int64)
            queue = tf.train.slice_input_producer([image, label])
            label = queue[1]
            image_temp = tf.read_file(queue[0])
            image = tf.image.decode_jpeg(image_temp, channels=1)
    
            # resize image
            # image = tf.image.resize_image_with_crop_or_pad(image, resize_w, resize_h)
            image = tf.image.resize_images(image, [resize_w, resize_h], method=0)
    
            image = tf.image.per_image_standardization(image)
    
            image_batch, label_batch = tf.train.batch([image, label], batch_size=batch_size,
                                                      num_threads=64,
                                                      capacity=capacity)
            # 1：一个batch batch_size:总共划分的batch数，784，展开为1列
            image_batch = tf.reshape(image_batch, [batch_size, resize_w * resize_w])
            images_batch = tf.cast(image_batch, tf.float32)
    
    
    
            labels_batch = tf.reshape(label_batch, [batch_size])
    
    
            return images_batch, labels_batch
    
    def main(argv=None):
        # 0、准备训练/验证/测试数据集
        log_dir='./'
        batch_size=50
        batch_image, batch_label=Dataset(data_path,batch_size,100).get_batch()
    
        batch_num = Dataset(data_path,50,100).num_batch()
    
    
        # 1、数据输入设计：使用 placeholder 将数据送入网络，None 表示张量的第一个维度可以是任意长度的
        with tf.name_scope('Input'):
            X = tf.placeholder(dtype=tf.float32, shape=[None, 784], name='X_placeholder')
            Y = tf.placeholder(dtype=tf.int32, shape=[None], name='Y_placeholder')
    
        # 2、前向网络设计
        with tf.name_scope('Inference'):
            # batch:20 输入：784，通道：1，输出：10
            W = tf.Variable(initial_value=tf.random_normal(shape=[784, 10], stddev=0.01), name='Weights')
            b = tf.Variable(initial_value=tf.zeros(shape=[10]), name='bias')
            print(W)
            logits = tf.matmul(X, W) + b
            Y_pred = tf.nn.softmax(logits=logits)
        # 3、损失函数设计
        with tf.name_scope('Loss'):
            # 求交叉熵损失
            # cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=logits, name='cross_entropy')
            cross_entropy=tf.nn.sparse_softmax_cross_entropy_with_logits(labels=Y, logits=logits, name='cross_entropy')
            # 求平均
            loss = tf.reduce_mean(cross_entropy, name='loss')
    
        # 4、参数学习算法设计
        with tf.name_scope('Optimization'):
            learn_rate=0.001
            optimizer = tf.train.GradientDescentOptimizer(learn_rate).minimize(loss)
    
        # 5、评估节点设计
        with tf.name_scope('Evaluate'):
            # 返回验证集/测试集预测正确或错误的布尔值
            # correct_prediction = tf.equal(tf.argmax(Y_pred, 1), tf.argmax(Y, 1))
            # 将布尔值转换为浮点数后，求平均准确率
            correct_prediction = tf.nn.in_top_k(Y_pred, Y, 1)
            accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    
    
        print('~~~~~~~~~~~开始执行计算图~~~~~~~~~~~~~~')
    
        saver = tf.train.Saver(tf.global_variables(), max_to_keep=10)
        with tf.Session() as sess:
            counter = 0
            summary_writer = tf.summary.FileWriter(logdir=log_dir, graph=sess.graph)
            # 初始化所有变量
            sess.run(tf.global_variables_initializer())
            train_epoch_loss = []
            test_epoch_loss = []
            test_val_acc = []
    
            coord = tf.train.Coordinator()
            threads = tf.train.start_queue_runners(sess=sess, coord=coord)
            try:
                while not coord.should_stop():
                    counter += 1
                    epoch_num = batch_num
                    # 训练
                    while epoch_num >= 0:
                        epoch_num -= 1
                        image_batch_v, label_batch_v = sess.run([batch_image, batch_label])
    
                        _, loss_batch, = sess.run([optimizer, loss], feed_dict={X: image_batch_v, Y: label_batch_v})
                        train_epoch_loss.append(loss_batch)
    
                    # 验证
                    while epoch_num <= batch_num:
                        epoch_num += 1
                        image_batch_v, label_batch_v = sess.run([batch_image, batch_label])
                        test_loss, acc = sess.run([loss, accuracy], feed_dict={X: image_batch_v, Y: label_batch_v})
    
                        test_epoch_loss.append(test_loss)
                        test_val_acc.append(acc)
    
                    mean_train_loss = round(np.mean(np.array(train_epoch_loss)), 3)
                    mean_test_loss = round(np.mean(np.array(test_epoch_loss)), 3)
                    mean_val_acc = round(np.mean(np.array(test_val_acc)), 3)
    
                    print('{} times val_acc is {}, train_loss: {},test_loss:{}'.format(counter, mean_val_acc, mean_train_loss,
                                                                                     mean_test_loss))
    
                    if counter % 300 == 0:
    
                        base_dir = './checkpoint'
                        ckpt_file = base_dir + "/batch_test_loss=%.4f.ckpt" % mean_train_loss
                        print('Save ckpt file to {}'.format(ckpt_file))
                        if os.path.exists(base_dir) == False:
                            os.makedirs(base_dir)
                        saver.save(sess, ckpt_file, global_step=counter)
                    if counter > 1000:
                        break
    
    
            except tf.errors.OutOfRangeError:
                print('Done!')
            finally:
                coord.request_stop()
    
            coord.join(threads)
            summary_writer.close()

`  注意：用`tf.nn.sparse\_softmax\_cross\_entropy\_with\_logits方法时在Dataset中用labels\_batch = tf.reshape(label\_batch, \[batch\_size\])替换以下两句:

labels_onehot_batch = tf.one_hot(label_batch, depth=10, on_value=1, axis=1)
    labels_batch = tf.reshape(labels_onehot_batch, [batch_size, 10])
    ,同时计算accuracy时也要将tf.equal替换为：tf.nn.in_top_k。

验证代码也要做相应的改变，主要是将label改为一维数据。

labels=[0,1,2,3,4,5,6,7,8,9]
    def prediect2(image):
        trans2np=np.array(image).reshape([1,784])
        with tf.name_scope('Input'):
           x = tf.placeholder(dtype=tf.float32, shape=[None, 784], name='X_placeholder')
           y = tf.placeholder(dtype=tf.int32, shape=[None], name='Y_placeholder')
    
        # 2、前向网络设计
        with tf.name_scope('Inference'):
            # batch:20 输入：784，通道：1，输出：10
            W = tf.Variable(initial_value=tf.random_normal(shape=[784,10], stddev=0.01), name='Weights')
            b = tf.Variable(initial_value=tf.zeros(shape=[10]), name='bias')
            print(W)
            logits = tf.matmul(x, W) + b
            pred = tf.nn.softmax(logits=logits)
    
        saver=tf.train.Saver()
    
        with tf.Session() as sess:
            sess.run(tf.global_variables_initializer())
    
            saver.restore(sess, save_path=  './checkpoint/batch_test_loss=0.5550.ckpt-300')
    
            # correct_prediction = tf.nn.in_top_k(pred, y, 1)
            # accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
            # 
            # 
            # 
            # 
            # print('accuracy: ', accuracy.eval({x:trans2np,y:labels}))
    
            output = tf.argmax(pred, 1)
            outputval,pre = sess.run([output,pred], feed_dict={x: trans2np, y: labels})
            print(outputval)
            print('p:',pre)

[http_yann.lecun.com_exdb_mnist]: http://yann.lecun.com/exdb/mnist/
[https_blog.csdn.net_zzZ_CMing_article_details_81063977]: https://blog.csdn.net/zzZ_CMing/article/details/81063977