浅谈深度学习模型

深度学习数据类型

深度学习框架包括Tensorflow，Pytorch等等，自己算是Tensorflow框架的入门级菜鸟，但是课题组的师兄师姐都在使用pytorch框架，据说是因为学术需要（查文章比较容易），而tensorflow面向的则更多是工程类的问题。无奈两个月前初入课题组自学的是tensorflow框架，于是也就坚持了下来，然而实际的体验结果是tensorflow对新人来说确实不那么友好，就拿数据类型来说，按自己目前的了解来看主要分为以下三种：

1. 特征为二维图片的输入，同时标签值对应着唯一的一张图片；
2. 特征同样是二维图片的输入，然而标签值却对应着两张及以上的图片；
3. 最后最为陌生的形式，一维数据的输入，对应着一维的标签值；

Tensorflow似乎并没有特别多的案例对一维的数据去使用深度学习模型，即使使用了tensorflow也是使用了全连接神经网络。所以前期自己也是花费了很多功夫，有想过将自己的一维数据集升高维度，使得它符合tensor对象的格式要求，再去使用深度学习模型，因为按照师兄已有的经验，它们往往会将三维的图片数据压缩为二维数据去跑深度学习模型，但是操作过程却有些复杂。后文将会介绍自己最终的操作是采用了CSV文件去实现了数据的输入以及深度学习模型的搭建。

Tensorflow框架下的Mnist数据集

学习tensorflow的第一课往往是介绍了tensorflow中的图，会话等，当然图中也会包含着张量以及节点，构建好图之后，需要启动会话，使得图中的操作运行起来。整体而言，对于输入数据，会包含着二维数据，图片数据，TFRecords文件数据等，首先需要构建文件名队列，然后进行相应的读取以及解码，不同的数据类型，对应着不同的读取解码操作，接下来是构建批处理队列。对于构建神经网络而言，tensoflow中的模块足够让我们搭建想要的模型，全连接、CNN、LSTM是目前为止自己接触到的三个网络，值的一提的是在构建loss函数以及optimizer函数的时候，我们需要对我们的数据格式有着清楚的认知，这样才会明白我们到底是要使用softmax函数还是sigmoid函数或者是其他的函数。
Mnist数据集是一类初学者入门级别的数据集，因为是公共的数据集，所以已经被分割好了特征值以及标签值，训练集以及测试集的个数也已经被定义。此数据集也是上文提到的第一类数据集，我们所要考虑的只是从tensorflow中导入此数据集，并按照tensorflow数据处理流程，同时搭建神经网络去训练即可，下面的代码是在自学黑马程序员视频时总结的使用两层卷积神经网络搭建的模型，并输入了Mnist数据集进行训练。

import tensorflow as tf
import os
from tensorflows.examples.tutorials.minist import input_data

def create_weights(shape): 
   return tf.Variable(initial_value=tf.random_normal(shape=shape))

def create_model(x):
   with tf.variable_scope(“conv1”):
      input_x=tf.reshape(x,shape=[-1,28,28,1])
      conv1_weights=create_weights(shape=[5,5,1,32])
      conv1_bias=create_weights(shape=[32])
      conv1_x=tf.conv2d(input=input_x,filter=conv1_weights.strides=[1,1,1,1],padding=’SAME’)
      relu1_x=tf.nn.relu(conv1_x)
      pool1_x=tf.nn.max_pool(value=relu1_x,ksize=[1,2,2,1],strides=[1,2,2,1],padding=’SAME’)
   with tf.variable_scope(“conv2”):
      conv2_weights=create_weights(shape=[5,5,32,64])
      conv2_bias=create_weights(shape=[64])
conv2_x=tf.conv2d(input=pool1_x,filter=conv2_weights,strides=[1,1,1,1],padding=’SAME’)
      relu2_x=tf.nn.relu(conv2_x)
      pool2_x=tf.nn.max_pool(value=relu2_x,ksize=[1,2,2,1],strides=[1,2,2,1],padding=’SAME’)
   with tf.variable_scope(“full_connection”):
       x_fc=tf.reshape(pool2_x,shape=[-1,7*7*64])
       weights_fc=create_weights(shape=[7*7*64,10])
       bias_fc=create_weights(shape=[10])
       y_predict=tf.matmul(x_fc,weights_fc)+bias_fc
   return y_predict
def full_connection():
    mnist=input_data.read_data_sets(“./mnist.summary”,one_hot=True)
    with tf.Variable_scope(“mnist_data”):
    x=tf.placeholder(dtype=tf.float32,shape=[None,784])
    y_true=tf.placeholder(dtype=tf.float32,shape=[None,10])
    y_predict=create_model(x)
    with tf.Variable_scope(“sofemax_crossentropy”):
    loss=tf.reduce_mean(tf.nn.softmax_cross_entroy_with_logits(labels=y_true,logits=y_predict,name=None))
    with tf.Variable_scope(“optimizer”):
    train_op=tf.train.GradientDescentOptimizer(learnig_rate=0.01.minimize(loss))
    with tf.Variable_scope(“accuracy”):
    equal_list=tf.equal(tf.argmax(y_true,1),tf.argmax(y_predict,1))
    accuracy=tf.reduce_mean(tf.cast(equal_list,tf.float32))
    tf.summary.scalar(“losses”,loss)
    tf.summary.scalar(“acc”,accuracy)
init_op=tf.global_variables_initializer()
merged=tf.summary.merge_all()
with tf.Session() as sess:
    sess.run(init_op)
    #创建事件文件
    file_writer=tf.summary.FileWriter(‘./temp/summary’,graph=sess.graph)
    if FLAGS.is_train==1:    #循环步数去训练
    for i in range(3000):   #获取数据，实时提供，每步提供50个样本训练
      mnist_x,mnist_y=mnist.train.next_batch(50)
      sess.run(train_op,feed_dict={x:mnist_x,y_true:mnist_y})        
      print(‘第%d次训练的准确率为:%f,损失为:%f’%(i+1,sess.run(accuracy,feed_dict={x;mnits_x,y:mnist_y}),sess.run(loss,feed_dict={x;mnits_x,y:mnist_y}))
      #运行合并变量操作
      summary=sess.run(merged,feed_dict={x:mnist_x,y:mnist_y})
      #将summary对象写入事件文件
      file_writer.add_summary(summary,i)
    else:
    #如果不是训练，我们就去进行相应的测试数据
    for i in range(100):
      mnist_x,mnist_y=mnist.test.naxt_batch(1)
      print(“第%d个样本的真实值为:%d,预测值为:%d”%(i+1,tf.argmax(sess.run(y_true,feed_dict={x:mnist_x,y:mnist_y}),tf.argmax(sess.run(y_predict,feed_dict={x:mnist_x,y:mnist_y})))))
if __name==”__main__”:
    full_connection()

Tensorflow框架下自定义二维数据集处理

与Mnist数据集截然不同，自定义的数据集因为存在特征值和标签值尚未一一对应，训练集以及测试集尚未明确的情况，所以在输入神经网络之前需要做大量的工作。
首先，针对黑马程序员视频所提供的数据而言，第一步我们需要将此图片数据进行读取，接下来，我们需要解析标签值csv文件，将标签值文件中字母对应的数字集合转换出来，接下来就是对特征值以及标签值之间的匹配（在输入tensorflow后，默认文件的顺序是被打乱的）。最重要的一点是，我们需要对标签值中已经转换为数字的列表进行转换，使其变为one-hot编码的形式，最终的结果是以4*26的矩阵格式展现出来的。
之后便是对于神经网络的搭建，值得注意的是，我们需要明确数据的输入维度及格式，如果尚不明确，我们需要print出相应的tensor对象观察其维度，因为tensorflow对于tensor对象的格式有着严格的要求。
最后在定义损失函数以及优化函数的时候，便使用了上文中提到的思想，依据具体的数据形式去做决定，具体到本例中是使用了sigmoid函数，而非一贯以为的softmax函数。

import tensorflow as tf
import glob
import numpy as np
import pandas as pd   #用于文件的处理
def read_and_decode():
    file_list=glob.glob(“./burry/*.jpg”)
    file_queue=tf.train.string_input_producer(file_list,shuffle=True)
    reader=tf.WholeFileReader()
    key,value=reader.read(file_queue)
    decoded=tf.image.decode_jpeg(value)
    #更新图片形状，将图片形状确定下来
    decoded.set_shape([20,80,3])      #形状确定才可以进行批处理
    #更新图片类型
    value_cast=tf.cast(decoded,tf.float32)
    key_batch,value_batch=tf.train.batch([key,value_cast],batch_size=100,num_threads=1,capacity=100)
    return key_batch,value_batch 
#此阶段使用jupyter观察
def parse_csv():
    csv_data=pd.read_csv(“./student/labels.csv”,names=[“file_num”,”chars”],index_csv=”file_num”)
    #根据字母生成对应的数字
    labels=[]
    for label in csv_data[“chars”]:
       letter=[]
       for word in label:
          letter.append(ord(word)-ord(“A”))
          label.append(letter)
       csv_data[“labels”]=labels
       return csv_data
def filename2label(key_news,csv_data): 
#抽取文件名之中的数字
     labels=[]
     for filename in key_news:
         file_num=“”.join(list(filter(str.isdigit,str(filename))))
         target=csv_data.loc[int(file_num),”labels”]
         labels.append(target)
     return np.array(labels)
def create_weights(shape): 
   return tf.Variable(initial_value=tf.random_normal(shape=shape))
if __name__==”__main__”:
    key_news,value_news=read_and_decode()
    csv_data=parse_csv()
    x=tf.placeholder(shape=[None,20,80,3])
    y_true=tf.placeholder(shape=[None,4*26])
    y_predict=create_model(x)
def create_model(x):
   with tf.variable_scope(“conv1”):
      conv1_weights=create_weights(shape=[5,5,3,32])
      conv1_bias=create_weights(shape=[32])
      conv1_x=tf.conv2d(input=x,filter=conv1_weights,strides=[1,1,1,1],padding=’SAME’)
      relu1_x=tf.nn.relu(conv1_x)
      pool1_x=tf.nn.max_pool(value=relu1_x,ksize=[1,2,2,1],strides=[1,2,2,1],padding=’SAME’)
   with tf.variable_scope(“conv2”):
      conv2_weights=create_weights(shape=[5,5,32,64])
      conv2_bias=create_weights(shape=[64])
      conv2_x=tf.conv2d(input=pool1_x,filter=conv2_weights,strides=[1,1,1,1],padding=’SAME’)
      relu2_x=tf.nn.relu(conv2_x)
      pool2_x=tf.nn.max_pool(value=relu2_x,ksize=[1,2,2,1],strides=[1,2,2,1],padding=’SAME’)
   with tf.variable_scope(“full_connection”):
       x_fc=tf.reshape(pool2_x,shape=[-1,5*20*64])
       weights_fc=create_weights(shape=[5*20*64,4*26])
       bias_fc=create_weights(shape=[4*26])
       y_predict=tf.matmul(x_fc,weights_fc)+bias_fc
       loss_list=tf.nn.sigmoid_cross_entropy_with_logits(labels=y_true,logits=y_predict)
       loss=tf.reduce_mean(loss_list) 
       optimizer=tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(loss)
       equal_list=tf.reduce_all(tf.equal(tf.argmax(tf.reshape(y_predict,shape=[-1,4,26]),axis=2),tf.argmax(tf.reshape(y_true,shape=[-1,4,26]),axis=2)),axis=1)
       accuracy=tf.recue_mean(tf.cast(equal_list,tf.float32))
init=tf.global_variables_initializer()
with tf.Session() as sess：
    sess.run(init)
    #开启线程
    #线程协调员
    coord=tf.train.Coordinator() 
    threads=tf.train.start_queue_runners(sess=sess,coord=coord)
    for i in range(1000):
        key_news,value_news=sess.run([key_news,value_news])
        labels=filename2label(key_news,csv_data)
        labels_value=tf.reshape(tf.one_hot(labels,depth=26),[-1,4*26]).eval()
        _,error,accuracy_value=sess.run([optimizer,loss,accuracy],feed_dict={x:value_news,y:labels_value})
    print(“第%d次训练，损失为：%f，准确率为：%f” (i+1,error,accuracy_value))
#回收线程
coord.request_stop()
coord.join(threads)

Tensorflow框架下自定义一维数据集处理

这里便是自己花费了很久做出来的针对于一维数据的处理方式，我将自己的数据集整理成为了csv文件保存，其中包含有特征值以及标签值，然后使用python slice的方式对其中的数据进行分割，前几列为特征值，最后一列为标签值，使用tensorflow中的read_csv函数对此数据集读入。当然，现在还有一种思路：将自己的数据集各自一个一个保存为csv文件，总的labels则作为一个整体的csv文件保存，训练之前，只需要通过文件名将特征值及对应的标签值做一一对应。但目前只是一种想法，还未去实践。

import tensorflow as tf
import os
os.chdir("./TensorFlow-burrydata-master")
print(os.getcwd())
def read_data(file_queue):
    reader = tf.TextLineReader(skip_header_lines=1)
    key, value = reader.read(file_queue)
    defaults = [[''], [0.], [0.], [0.], [0.],[0.],]
    ~= tf.decode_csv(value, defaults)
    preprocess_op = tf.case({
        tf.equal(grade, tf.constant('great')): lambda: tf.constant(0),
        tf.equal(grade, tf.constant('good')): lambda: tf.constant(1),
        tf.equal(grade, tf.constant('bad')): lambda: tf.constant(2),
    }, lambda: tf.constant(-1), exclusive=True)
    return tf.stack([]), preprocess_op

def create_pipeline(filename, batch_size, num_epochs=None):
    file_queue = tf.train.string_input_producer([filename], num_epochs=num_epochs)
    example, label = read_data(file_queue)
    min_after_dequeue = 100
    capacity = min_after_dequeue + batch_size
    example_batch, label_batch = tf.train.shuffle_batch(
        [example, label], batch_size=batch_size, capacity=capacity,
        min_after_dequeue=min_after_dequeue
    )
    return example_batch, label_batch

x_train_batch, y_train_batch = create_pipeline('burry-train.csv', 20, num_epochs=100)
x_test, y_test = create_pipeline('burry-test.csv', 20)
global_step = tf.Variable(0, trainable=False)
learning_rate = 0.1

以上便是自己对于tensorflow目前为止的认知，写此文章的目的也是为了得到大家的指点以及批正，毕竟自己现在还只是出于入门阶段，如果文章出现了错误，也希望得到大家的指正，如果有更好的想法，也欢迎随时与我交流，大家一起进步！