一、思路
二、進程
三、參考
1.denny的學習專欄
這位大佬的博客里有關於tensorflow的很多內容，並且有花卉識別項目的源代碼和介紹，很有參考價值。為了內容丟失，已裝在到博客里。
2.Plain and Simple Estimators
這個小視頻https://zhuanlan.zhihu.com/p/30722498簡單介紹了該項目，並簡單講解了代碼，github已follow.
四、成功案列
（1）
前言
本文為一個利用卷積神經網絡實現花卉分類的項目，因此不會過多介紹卷積神經網絡的基本知識。此項目建立在了解卷積神經網絡進行圖像分類的原理上進行的。
項目簡介
本項目為一個圖像識別項目，基於tensorflow，利用CNN網絡實現識別四種花的種類。
使用tensorflow進行一個完整的圖像識別。項目包括對數據集的處理，從硬盤讀取數據，CNN網絡的定義，訓練過程以及利用實際測試數據對訓練好的模型結果進行測試功能。
准備訓練數據。
訓練數據存放路徑為: ‘D:/ML/flower/input_data’
訓練模型存儲路徑為:'D:/ML/flower/save/‘
測試樣本路徑及文件名為:'D:/ML/flower/flower_photos/roses/**.jpg‘
測試用圖片文件從訓練數據中任意拷貝一張即可。
訓練數據如圖
以roses種類的訓練數據為例，文件夾內部均為該種類花的圖像文件
模塊組成
示例代碼主要由四個模塊組成：
input_data.py——圖像特征提取模塊，模塊生成四種花的品類圖片路徑及對應標簽的List
model.py——模型模塊，構建完整的CNN模型
train.py——訓練模塊，訓練模型，並保存訓練模型結果
test.py——測試模塊，測試模型對圖片識別的准確度
項目模塊執行順序
- 運行train.py開始訓練。
- 訓練完成后- 運行test.py，查看實際測試結果
input_data.py——圖像特征提取模塊，模塊生成四種花的品類圖片路徑及對應標簽的List
import os import math import numpy as np import tensorflow as tf import matplotlib.pyplot as plt # -----------------生成圖片路徑和標簽的List------------------------------------ train_dir = 'D:/ML/flower/input_data' roses = [] label_roses = [] tulips = [] label_tulips = [] dandelion = [] label_dandelion = [] sunflowers = [] label_sunflowers = []
定義函數get_files,獲取圖片列表及標簽列表
# step1：獲取所有的圖片路徑名，存放到 # 對應的列表中，同時貼上標簽，存放到label列表中。 def get_files(file_dir, ratio): for file in os.listdir(file_dir + '/roses'): roses.append(file_dir + '/roses' + '/' + file) label_roses.append(0) for file in os.listdir(file_dir + '/tulips'): tulips.append(file_dir + '/tulips' + '/' + file) label_tulips.append(1) for file in os.listdir(file_dir + '/dandelion'): dandelion.append(file_dir + '/dandelion' + '/' + file) label_dandelion.append(2) for file in os.listdir(file_dir + '/sunflowers'): sunflowers.append(file_dir + '/sunflowers' + '/' + file) label_sunflowers.append(3) # step2：對生成的圖片路徑和標簽List做打亂處理 image_list = np.hstack((roses, tulips, dandelion, sunflowers)) label_list = np.hstack((label_roses, label_tulips, label_dandelion, label_sunflowers)) # 利用shuffle打亂順序 temp = np.array([image_list, label_list]) temp = temp.transpose() np.random.shuffle(temp) # 將所有的img和lab轉換成list all_image_list = list(temp[:, 0]) all_label_list = list(temp[:, 1]) # 將所得List分為兩部分，一部分用來訓練tra，一部分用來測試val # ratio是測試集的比例 n_sample = len(all_label_list) n_val = int(math.ceil(n_sample * ratio)) # 測試樣本數 n_train = n_sample - n_val # 訓練樣本數 tra_images = all_image_list[0:n_train] tra_labels = all_label_list[0:n_train] tra_labels = [int(float(i)) for i in tra_labels] val_images = all_image_list[n_train:-1] val_labels = all_label_list[n_train:-1] val_labels = [int(float(i)) for i in val_labels] return tra_images, tra_labels, val_images, val_labels
定義函數get_batch,生成訓練批次數據
# --------------------生成Batch---------------------------------------------- # step1：將上面生成的List傳入get_batch() ，轉換類型，產生一個輸入隊列queue，因為img和lab # 是分開的，所以使用tf.train.slice_input_producer()，然后用tf.read_file()從隊列中讀取圖像 # image_W, image_H, ：設置好固定的圖像高度和寬度 # 設置batch_size：每個batch要放多少張圖片 # capacity：一個隊列最大多少 定義函數get_batch,生成訓練批次數據 def get_batch(image, label, image_W, image_H, batch_size, capacity): # 轉換類型 image = tf.cast(image, tf.string) label = tf.cast(label, tf.int32) # make an input queue input_queue = tf.train.slice_input_producer([image, label]) label = input_queue[1] image_contents = tf.read_file(input_queue[0]) # read img from a queue # step2：將圖像解碼，不同類型的圖像不能混在一起，要么只用jpeg，要么只用png等。 image = tf.image.decode_jpeg(image_contents, channels=3) # step3：數據預處理，對圖像進行旋轉、縮放、裁剪、歸一化等操作，讓計算出的模型更健壯。 image = tf.image.resize_image_with_crop_or_pad(image, image_W, image_H) image = tf.image.per_image_standardization(image) # step4：生成batch # image_batch: 4D tensor [batch_size, width, height, 3],dtype=tf.float32 # label_batch: 1D tensor [batch_size], dtype=tf.int32 image_batch, label_batch = tf.train.batch([image, label], batch_size=batch_size, num_threads=32, capacity=capacity) # 重新排列label，行數為[batch_size] label_batch = tf.reshape(label_batch, [batch_size]) image_batch = tf.cast(image_batch, tf.float32) return image_batch, label_batch
model.py——CN模型構建
import tensorflow as tf #定義函數infence，定義CNN網絡結構 #卷積神經網絡，卷積加池化*2，全連接*2，softmax分類 #卷積層1 def inference(images, batch_size, n_classes): with tf.variable_scope('conv1') as scope: weights = tf.Variable(tf.truncated_normal(shape=[3,3,3,64],stddev=1.0,dtype=tf.float32), name = 'weights',dtype=tf.float32) biases = tf.Variable(tf.constant(value=0.1, dtype=tf.float32, shape=[64]), name='biases', dtype=tf.float32) conv = tf.nn.conv2d(images, weights, strides=[1, 1, 1, 1], padding='SAME') pre_activation = tf.nn.bias_add(conv, biases) conv1 = tf.nn.relu(pre_activation, name=scope.name) # 池化層1 # 3x3最大池化，步長strides為2，池化后執行lrn()操作，局部響應歸一化，對訓練有利。 with tf.variable_scope('pooling1_lrn') as scope: pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1], padding='SAME', name='pooling1') norm1 = tf.nn.lrn(pool1, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm1') # 卷積層2 # 16個3x3的卷積核（16通道），padding=’SAME’，表示padding后卷積的圖與原圖尺寸一致，激活函數relu() with tf.variable_scope('conv2') as scope: weights = tf.Variable(tf.truncated_normal(shape=[3, 3, 64, 16], stddev=0.1, dtype=tf.float32), name='weights', dtype=tf.float32) biases = tf.Variable(tf.constant(value=0.1, dtype=tf.float32, shape=[16]), name='biases', dtype=tf.float32) conv = tf.nn.conv2d(norm1, weights, strides=[1, 1, 1, 1], padding='SAME') pre_activation = tf.nn.bias_add(conv, biases) conv2 = tf.nn.relu(pre_activation, name='conv2') # 池化層2 # 3x3最大池化，步長strides為2，池化后執行lrn()操作， # pool2 and norm2 with tf.variable_scope('pooling2_lrn') as scope: norm2 = tf.nn.lrn(conv2, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm2') pool2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1], strides=[1, 1, 1, 1], padding='SAME', name='pooling2') # 全連接層3 # 128個神經元，將之前pool層的輸出reshape成一行，激活函數relu() with tf.variable_scope('local3') as scope: reshape = tf.reshape(pool2, shape=[batch_size, -1]) dim = reshape.get_shape()[1].value weights = tf.Variable(tf.truncated_normal(shape=[dim, 128], stddev=0.005, dtype=tf.float32), name='weights', dtype=tf.float32) biases = tf.Variable(tf.constant(value=0.1, dtype=tf.float32, shape=[128]), name='biases', dtype=tf.float32) local3 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name) # 全連接層4 # 128個神經元，激活函數relu() with tf.variable_scope('local4') as scope: weights = tf.Variable(tf.truncated_normal(shape=[128, 128], stddev=0.005, dtype=tf.float32), name='weights', dtype=tf.float32) biases = tf.Variable(tf.constant(value=0.1, dtype=tf.float32, shape=[128]), name='biases', dtype=tf.float32) local4 = tf.nn.relu(tf.matmul(local3, weights) + biases, name='local4') # dropout層 # with tf.variable_scope('dropout') as scope: # drop_out = tf.nn.dropout(local4, 0.8) # Softmax回歸層 # 將前面的FC層輸出，做一個線性回歸，計算出每一類的得分 with tf.variable_scope('softmax_linear') as scope: weights = tf.Variable(tf.truncated_normal(shape=[128, n_classes], stddev=0.005, dtype=tf.float32), name='softmax_linear', dtype=tf.float32) biases = tf.Variable(tf.constant(value=0.1, dtype=tf.float32, shape=[n_classes]), name='biases', dtype=tf.float32) softmax_linear = tf.add(tf.matmul(local4, weights), biases, name='softmax_linear') return softmax_linear # ----------------------------------------------------------------------------- # loss計算 # 傳入參數：logits，網絡計算輸出值。labels，真實值，在這里是0或者1 # 返回參數：loss，損失值 def losses(logits, labels): with tf.variable_scope('loss') as scope: cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=labels, name='xentropy_per_example') loss = tf.reduce_mean(cross_entropy, name='loss') tf.summary.scalar(scope.name + '/loss', loss) return loss # -------------------------------------------------------------------------- # loss損失值優化 # 輸入參數：loss。learning_rate，學習速率。 # 返回參數：train_op，訓練op，這個參數要輸入sess.run中讓模型去訓練。 def trainning(loss, learning_rate): with tf.name_scope('optimizer'): optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) global_step = tf.Variable(0, name='global_step', trainable=False) train_op = optimizer.minimize(loss, global_step=global_step) return train_op # ----------------------------------------------------------------------- # 評價/准確率計算 # 輸入參數：logits，網絡計算值。labels，標簽，也就是真實值，在這里是0或者1。 # 返回參數：accuracy，當前step的平均准確率，也就是在這些batch中多少張圖片被正確分類了。 def evaluation(logits, labels): with tf.variable_scope('accuracy') as scope: correct = tf.nn.in_top_k(logits, labels, 1) correct = tf.cast(correct, tf.float16) accuracy = tf.reduce_mean(correct) tf.summary.scalar(scope.name + '/accuracy', accuracy) return accuracy
train.py——利用D:/ML/flower/input_data/路徑下的訓練數據，對CNN模型進行訓練
import input_data import model # 變量聲明 N_CLASSES = 4 # 四種花類型 IMG_W = 64 # resize圖像，太大的話訓練時間久 IMG_H = 64 BATCH_SIZE = 20 CAPACITY = 200 MAX_STEP = 2000 # 一般大於10K learning_rate = 0.0001 # 一般小於0.0001 # 獲取批次batch train_dir = 'F:/input_data' # 訓練樣本的讀入路徑 logs_train_dir = 'F:/save' # logs存儲路徑 # train, train_label = input_data.get_files(train_dir) train, train_label, val, val_label = input_data.get_files(train_dir, 0.3) # 訓練數據及標簽 train_batch, train_label_batch = input_data.get_batch(train, train_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) # 測試數據及標簽 val_batch, val_label_batch = input_data.get_batch(val, val_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) # 訓練操作定義 train_logits = model.inference(train_batch, BATCH_SIZE, N_CLASSES) train_loss = model.losses(train_logits, train_label_batch) train_op = model.trainning(train_loss, learning_rate) train_acc = model.evaluation(train_logits, train_label_batch) # 測試操作定義 test_logits = model.inference(val_batch, BATCH_SIZE, N_CLASSES) test_loss = model.losses(test_logits, val_label_batch) test_acc = model.evaluation(test_logits, val_label_batch) # 這個是log匯總記錄 summary_op = tf.summary.merge_all() # 產生一個會話 sess = tf.Session() # 產生一個writer來寫log文件 train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph) # val_writer = tf.summary.FileWriter(logs_test_dir, sess.graph) # 產生一個saver來存儲訓練好的模型 saver = tf.train.Saver() # 所有節點初始化 sess.run(tf.global_variables_initializer()) # 隊列監控 coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) # 進行batch的訓練 try: # 執行MAX_STEP步的訓練，一步一個batch for step in np.arange(MAX_STEP): if coord.should_stop(): break _, tra_loss, tra_acc = sess.run([train_op, train_loss, train_acc]) # 每隔50步打印一次當前的loss以及acc，同時記錄log，寫入writer if step % 10 == 0: print('Step %d, train loss = %.2f, train accuracy = %.2f%%' % (step, tra_loss, tra_acc * 100.0)) summary_str = sess.run(summary_op) train_writer.add_summary(summary_str, step) # 每隔100步，保存一次訓練好的模型 if (step + 1) == MAX_STEP: checkpoint_path = os.path.join(logs_train_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop()
test.py——利用D:/ML/flower/flower_photos/roses路徑下的測試數據，查看識別效果
import matplotlib.pyplot as plt import model from input_data import get_files # 獲取一張圖片 def get_one_image(train): # 輸入參數：train,訓練圖片的路徑 # 返回參數：image，從訓練圖片中隨機抽取一張圖片 n = len(train) ind = np.random.randint(0, n) img_dir = train[ind] # 隨機選擇測試的圖片 img = Image.open(img_dir) plt.imshow(img) plt.show() image = np.array(img) return image # 測試圖片 def evaluate_one_image(image_array): with tf.Graph().as_default(): BATCH_SIZE = 1 N_CLASSES = 4 image = tf.cast(image_array, tf.float32) image = tf.image.per_image_standardization(image) image = tf.reshape(image, [1, 64, 64, 3]) logit = model.inference(image, BATCH_SIZE, N_CLASSES) logit = tf.nn.softmax(logit) x = tf.placeholder(tf.float32, shape=[64, 64, 3]) # you need to change the directories to yours. logs_train_dir = 'F:/save/' saver = tf.train.Saver() with tf.Session() as sess: print("Reading checkpoints...") ckpt = tf.train.get_checkpoint_state(logs_train_dir) if ckpt and ckpt.model_checkpoint_path: global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1] saver.restore(sess, ckpt.model_checkpoint_path) print('Loading success, global_step is %s' % global_step) else: print('No checkpoint file found') prediction = sess.run(logit, feed_dict={x: image_array}) max_index = np.argmax(prediction) if max_index == 0: result = ('這是玫瑰花的可能性為： %.6f' % prediction[:, 0]) elif max_index == 1: result = ('這是郁金香的可能性為： %.6f' % prediction[:, 1]) elif max_index == 2: result = ('這是蒲公英的可能性為： %.6f' % prediction[:, 2]) else: result = ('這是這是向日葵的可能性為： %.6f' % prediction[:, 3]) return result # ------------------------------------------------------------------------ if __name__ == '__main__': img = Image.open('F:/input_data/dandelion/1451samples2.jpg') plt.imshow(img) plt.show() imag = img.resize([64, 64]) image = np.array(imag) print(evaluate_one_image(image))
項目執行結果：
1.執行train模塊，結果如下：
同時，訓練結束后，在電腦指定的訓練模型存儲路徑可看到保存的訓練好的模型數據。
2.執行test模塊，結果如下：
顯示一張測試用的圖片
關閉顯示的測試圖片后，console查看測試結果如下：
至此我們對整個項目流程做一個總結：
圖片預處理模塊：對獲得的花卉圖片訓練數據，進行預處理，構造訓練用數據結構
訓練模塊：利用Tensorflow實現CNN（神經網絡算法）模型，經過兩層卷積-池化處理，並使用梯度下降算法作為優化器、Softmax算法作為分類器、平方損失函數（最小二乘法, Ordinary Least Squares）作為優化器，構建訓練模型,利用訓練數據對模型進行訓練，最終得到訓練后的模型數據，並以文件形式存儲至本機。
分類准確度驗證模塊：利用Tensorflow的reduce_mean方法作為評估模型，對構建的花卉分類模型分類准確性進行驗證。
模型測試模塊：使用測試集數據，對構建並訓練后的分類模型進行測試，驗證實際數據的測試准確度。
具體代碼以及附件可在我的個人GitHub上下載
我的githubworkspace
原文地址：https://blog.csdn.net/CrimsonK/article/details/100190807
二、https://www.cnblogs.com/lijitao/protected/articles/12173520.html