TensorFlow迁移学习的识别花试验

最近学习了TensorFlow，发现一个模型叫vgg16，然后搭建环境跑了一下，觉得十分神奇，而且准确率十分的高。又上了一节选修课，关于人工智能，老师让做一个关于人工智能的试验，于是觉得vgg16很不错，可以直接用。

但发现vgg16是训练好的模型，拿来直接用太没水平，于是网上发现说可以用vgg16进行迁移学习。

我理解的迁移学习：

迁移学习符合人们学习的过程，如果要学习一样新东西，我们肯定会运用或是借鉴之前的学习经验，这样能够快速的把握要点，能够快速的学习。迁移学习也是如此。

vgg16模型是前人训练出的能够识别1000种物品的模型，而且识别率很高，它的模型如图：

可以数出绿色的模块一共有16层，通过多层的卷积和池化，会提取图片特征值，然后把图片压缩成一个一维数组输入到全连接层中，图中有三层全连接层fc1，fc2，fc3，再经过softmax输出概率分布的预测结果。

进过试验，这个模型能够很好的识别花，但是如果要在此基础上识别多种花，还需要在此基础上进行训练，但是训练的过程将简化很多。接下来通过代码来讲解

项目：

Transfer_learning:

  --checkpoint    #用来保存模型

      --   #自动生成的四个文件

  --flower_photos   #图片

       --daisy

　　--dandeline

　　--roses

　　--sunflowers

　　--tulips

        #vgg16模型

  --utils.py

 --vgg16.npy

 --vgg16.py

  --app.py

  --ftrain.py

  --get_features.py

  --transfer_test.py

  --transfer_train.py

  --codes.npy #存储图片特征值

  --labels #存储图片的标签

  --1.jpg  #检测图片

  --.......

第一步获取图片的特征，对于vgg16模型，fc1层之前所做的就是提取图片特征，我们无需再费事去训练模型去提取图片的特征，而是直接使用它提供的完善的模型去提取特征，并且它能够很好的把握图片的特征，然后它这些特征存储起来，用于下面的训练。

get_features.py

#coding=utf-8
import os
import numpy as np
import tensorflow as tf
import vgg16
import utils


#接下来我们将 flower_photos 文件夹中的花朵图片都载入到进来，并且用图片所在的子文件夹作为标签值。
data_dir = 'flower_photos/'
contents = os.listdir(data_dir)
classes = [each for each in contents if os.path.isdir(data_dir + each)]

#利用vgg16计算得到特征值
# 首先设置计算batch的值，如果运算平台的内存越大，这个值可以设置得越高
batch_size = 10
# 用codes_list来存储特征值
codes_list = []
# 用labels来存储花的类别
labels = []
# batch数组用来临时存储图片数据
batch = []

codes = None


with tf.Session() as sess:
    # 构建VGG16模型对象
    vgg = vgg16.Vgg16()
    input_ = tf.placeholder(tf.float32, [None, 224, 224, 3])
    with tf.name_scope("content_vgg"):
        # 载入VGG16模型
        vgg.build(input_)
    
    # 对每个不同种类的花分别用VGG16计算特征值
    for each in classes:
        print ("Starting {} images".format(each))
        class_path = data_dir + each
        files = os.listdir(class_path)
        for ii, file in enumerate(files, 1):
            # 载入图片并放入batch数组中
            img = utils.load_image(os.path.join(class_path, file))
            batch.append(img.reshape((1, 224, 224, 3)))
            labels.append(each)
            
            # 如果图片数量到了batch_size则开始具体的运算
            if ii % batch_size == 0 or ii == len(files):
                images = np.concatenate(batch)

                feed_dict = {input_: images}
                # 计算特征值
                codes_batch = sess.run(vgg.relu6, feed_dict=feed_dict)
                
                # 将结果放入到codes数组中
                if codes is None:
                    codes = codes_batch
                else:
                    codes = np.concatenate((codes, codes_batch))
                
                # 清空数组准备下一个batch的计算
                batch = []
                print ('{} images processed'.format(ii))
#code is a two-dimensional array including features of all pictures
#这样我们就可以得到一个 codes 数组，和一个 labels 数组，分别存储了所有花朵的特征值和类别。
#可以用如下的代码将这两个数组保存到硬盘上：        
#with open('codes', 'w') as f:
np.save("codes.npy",codes)
    #codes.tofile(f)
    #not good size of file is too big
    #pickle.dump(codes,f)
    
import csv
with open('labels', 'w') as f:
    writer = csv.writer(f, delimiter='
')
    writer.writerow(labels)
    #pickle.dump(labels,f)
    

进过上面代码我们已经得到了图片的特征值和标签，接下来，我们需要设置一个全连接层来训练，下面代码中增加了一层256个节点和5个节点的全连接层。

ftrain.py

#coding=utf-8
import os
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from sklearn.preprocessing import LabelBinarizer
import vgg16
import utils
from sklearn.model_selection import StratifiedShuffleSplit

#模型保存的路径和名称
MODEL_SAVE_PATH="./checkpoints/"
MODEL_NAME="flowers.ckpt"
LABELS = "labels"
CODES = "codes.npy"
codes = None
label = []
labels = []

if CODES:
    codes = np.load(CODES)
else:
    print ("No such file,please run get_feature.py first")

if LABELS:
    with open(LABELS,"r") as f: 
        label = f.readlines()
        for line in label:
            line = line.strip()
            labels.append(line)
else:
    print ("No such file,please run get_feature.py first")
#准备训练集，验证集和测试集
#首先我把 labels 数组中的分类标签用 One Hot Encode 的方式替换
lb = LabelBinarizer()
lb.fit(labels)
labels_vecs = lb.transform(labels)
#return codes,labels,labels_vecs

'''
接下来就是抽取数据，因为不同类型的花的数据数量并不是完全一样的，
而且 labels 数组中的数据也还没有被打乱，
所以最合适的方法是使用 StratifiedShuffleSplit 方法来进行分层随机划分。
假设我们使用训练集：验证集：测试集 = 8:1:1，那么代码如下：
'''
ss = StratifiedShuffleSplit(n_splits=1, test_size=0.2)

train_idx, val_idx = next(ss.split(codes, labels))

half_val_len = int(len(val_idx)/2)
val_idx, test_idx = val_idx[:half_val_len], val_idx[half_val_len:]

train_x, train_y = codes[train_idx], labels_vecs[train_idx]
val_x, val_y = codes[val_idx], labels_vecs[val_idx]
test_x, test_y = codes[test_idx], labels_vecs[test_idx]

print ("Train shapes (x, y):", train_x.shape, train_y.shape)
print ("Validation shapes (x, y):", val_x.shape, val_y.shape)
print ("Test shapes (x, y):", test_x.shape, test_y.shape)

#训练网络
'''
分好了数据集之后，就可以开始对数据集进行训练了，
假设我们使用一个 256 维的全连接层，
一个 5 维的全连接层（因为我们要分类五种不同类的花朵），
和一个 softmax 层。当然，这里的网络结构可以任意修改，
你可以不断尝试其他的结构以找到合适的结构。
'''
# 输入数据的维度

# 标签数据的维度
labels_ = tf.placeholder(tf.int64, shape=[None, labels_vecs.shape[1]])
inputs_ = tf.placeholder(tf.float32, shape=[None, codes.shape[1]])
# 加入一个256维的全连接的层

fc = tf.contrib.layers.fully_connected(inputs_, 256)

# 加入一个5维的全连接层
logits = tf.contrib.layers.fully_connected(fc, labels_vecs.shape[1], activation_fn=None)

# 得到最后的预测分布
predicted = tf.nn.softmax(logits)

# 计算cross entropy值
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=labels_, logits=logits)

# 计算损失函数
cost = tf.reduce_mean(cross_entropy)

# 采用用得最广泛的AdamOptimizer优化器
optimizer = tf.train.AdamOptimizer().minimize(cost)
correct_pred = tf.equal(tf.argmax(predicted, 1), tf.argmax(labels_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))


#为了方便把数据分成一个个 batch 以降低内存的使用，还可以再用一个函数专门用来生成 batch。
def get_batches(x, y, n_batches=10):
    """ 这是一个生成器函数，按照n_batches的大小将数据划分了小块 """
    batch_size = len(x)//n_batches
    
    for ii in range(0, n_batches*batch_size, batch_size):
        # 如果不是最后一个batch，那么这个batch中应该有batch_size个数据
        if ii != (n_batches-1)*batch_size:
            X, Y = x[ii: ii+batch_size], y[ii: ii+batch_size] 
        # 否则的话，那剩余的不够batch_size的数据都凑入到一个batch中
        else:
            X, Y = x[ii:], y[ii:]
        # 生成器语法，返回X和Y
        yield X, Y

经过上面的代码，已经把图片集分成三部分，而且也设置好全连接成，接下来需要把图片特征喂入，开始训练模型。

transfer_train.py

import os
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
import vgg16
import utils
import ftrain


#运行
# 运行多少轮次
epochs = 20
# 统计训练效果的频率
iteration = 0
# 保存模型的保存器
saver = tf.train.Saver()

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    coord = tf.train.Coordinator()#4
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)#5
    
    for e in range(epochs):
        for x, y in ftrain.get_batches(ftrain.train_x, ftrain.train_y):
            feed = {ftrain.inputs_: x,
                    ftrain.labels_: y}
            # 训练模型
            
            loss, _ = sess.run([ftrain.cost, ftrain.optimizer], feed_dict=feed)
            print ("Epoch: {}/{}".format(e+1, epochs),
                "Iteration: {}".format(iteration),
                "Training loss: {:.5f}".format(loss))
            iteration += 1
            
            if iteration % 5 == 0:
                feed = {ftrain.inputs_: ftrain.val_x,
                        ftrain.labels_: ftrain.val_y}
                
                val_acc = sess.run(ftrain.accuracy, feed_dict=feed)
                # 输出用验证机验证训练进度
                print ("Epoch: {}/{}".format(e, epochs),
                    "Iteration: {}".format(iteration),
                    "Validation Acc: {:.4f}".format(val_acc))
        # 保存模型
    saver.save(sess, os.path.join(ftrain.MODEL_SAVE_PATH, ftrain.MODEL_NAME))

在控制台的输出结果中，我们可以看到随着迭代次数的增加，损失值在不断的降低，精确性也在提高。把训练好的模型保存起来，接下来用测试集来测试模型。

transfer_test.py

#coding=utf-8
import os
import numpy as np
import tensorflow as tf
import ftrain
import vgg16
import utils


#用测试集来测试模型效果
saver = tf.train.Saver()
with tf.Session() as sess:
    saver.restore(sess,tf.train.latest_checkpoint(ftrain.MODEL_SAVE_PATH))
    feed = {ftrain.inputs_: ftrain.test_x,
            ftrain.labels_: ftrain.test_y}  
    test_acc = sess.run(ftrain.accuracy,feed_dict=feed)
    print ("Test accuracy: {:.4f}".format(test_acc))

测试代码，加载训练好的模型，然后把测试集代码喂入，计算精确度，控制台可以看到结果，我的结果达到90%以上

然后可以应用这个模型，来识别图片了，这个模型可以识别5中话，可以自己增加。

app.py

#coding=utf-8
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
import vgg16
import utils
import ftrain

def per_picture():
    #deal with picture
    testPicArr = []
    img_path = input('Input the path and image name:')
    img_ready = utils.load_image(img_path) 
    testPicArr.append(img_ready.reshape((1,224,224,3)))
    images = np.concatenate(testPicArr)
    return images


labels_vecs = ['daisy','dandelion','roses','sunflower','tulips']
labels_vecs = np.array(labels_vecs)
fig=plt.figure(u"Top-5 预测结果") 

saver = tf.train.Saver()
with tf.Session() as sess:
            #图片预处理
    images = per_picture()
            #输入vgg16中计算特征值
    vgg = vgg16.Vgg16()
    input_ = tf.placeholder(tf.float32, [None, 224, 224, 3])
    with tf.name_scope("content_vgg"):
    # 载入VGG16模型
        vgg.build(input_)
    feed_dict = {input_: images}
    # 计算特征值
    codes_batch = sess.run(vgg.relu6, feed_dict=feed_dict)
    #返回y矩阵中最大值的下标，如果是二维的加1
    preValue = tf.argmax(ftrain.predicted, 1)   
    #加载训练好的新模型
    saver.restore(sess, tf.train.latest_checkpoint(ftrain.MODEL_SAVE_PATH))
    #计算预测值
    preValue = sess.run(preValue, feed_dict={ftrain.inputs_:codes_batch})
    print ("The prediction flower is:", labels_vecs[preValue])
    probability = sess.run(ftrain.predicted, feed_dict={ftrain.inputs_:codes_batch})
    top5 = np.argsort(probability[0])
    print ("top5:",top5)
    values = []
    bar_label = []
    for n, i in enumerate(top5): 
        print ("n:",n)
        print ("i:",i)
        values.append(probability[0][i]) 
        bar_label.append(labels_vecs[i]) 
        print (i, ":", labels_vecs[i], "----", utils.percent(probability[0][i])) 
    ax = fig.add_subplot(111) 
    ax.bar(range(len(values)), values, tick_label=bar_label, width=0.5, fc='g')
    ax.set_ylabel(u'probabilityit') 
    ax.set_title(u'Top-5') 
    for a,b in zip(range(len(values)), values):
        ax.text(a, b+0.0005, utils.percent(b), ha='center', va = 'bottom', fontsize=7)   
    plt.show() 

上面代码过程是，首先要通过vgg16提取该图片的特征值，然后进行图片预处理，加载训练好的模型，输入进去，获得结果。

结果展示如下：

       

可以看到准确率很高，我每种图片只训练了144张，数据集有800多张。

以上代码可以在windows 下python3的环境运行。

代码和数据集参考自：https://cosx.org/2017/10/transfer-learning/

对于实现以上过程遇到的问题：

 （1）首先对迁移学习的理解

　　对于这个简单的试验，迁移学习主要体现在使用训练好的vgg16模型（存储在vgg16.npy中）提取图片的特征值，然后再对这些特征值训练。

（2）模型的保存和加载

　　为了避免反复的去提取图片特征值（这个很耗时间），把特征值保存在codes.npy，把图片的标签存储在labels中。还有就是存储训练模型，这里因为对TensorFlow模型不太了解，所以出一个问题

存储模型后，在另一个文件中加载模型发现训练的模型和没训练的模型一样

　　原因是因为在另一个文件中使用的不是同一个saver，我又对saver进行了初始化，导致使用了一个崭新的模型。

（3）模型保存优化部分：

　　如果你不给tf.train.Saver()传入任何参数，那么saver将处理graph中的所有变量。其中每一个变量都以变量创建时传入的名称被保存。

有时候在检查点文件中明确定义变量的名称很有用。举个例子，你也许已经训练得到了一个模型，其中有个变量命名为"weights"，你想把它的值恢复到一个新的变量"params"中。

有时候仅保存和恢复模型的一部分变量很有用。再举个例子，你也许训练得到了一个5层神经网络，现在想训练一个6层的新模型，可以将之前5层模型的参数导入到新模型的前5层中。

你可以通过给tf.train.Saver()构造函数传入Python字典，很容易地定义需要保持的变量及对应名称：键对应使用的名称，值对应被管理的变量。

增加：

对于代码中数据集增加，代码会报错，这里有同学发现了解决办法