吴裕雄 python 神经网络——TensorFlow 卷积神经网络水果图片识别

#-*- coding:utf- -*-

import time
import keras
import skimage
import numpy as np
import tensorflow as tf
import matplotlib.image as img

from scipy import ndimage
from skimage import color, data, transform

%matplotlib inline

#设置文件目录
Training = r'F:\\data\\fruits-360\\Training'
Test = r'F:\\data\\fruits-360\\Test' 

import os
from natsort import natsorted

#获取每类水果中的第五张图像
def load_print_img(root):
    print_img = []
    print_label = []
    #遍历水果种类目录
    for i in range(len(os.listdir(root))):
        child1 = os.listdir(root)[i]
        child2 = os.listdir(os.path.join(root, child1))
        #对第二层目录进行自然数排序，os.listder默认为str排序
        child2 = natsorted(child2)
        #取出每类的第五张图像
        path = os.path.join(root, child1, child2[])
        if(path.endswith('.jpg')):
            print_img.append(skimage.data.imread(path))
            print_label.append(child1)
    return print_img, print_label

print_img, print_label = load_print_img(Test)
print(np.shape(print_img))
print(np.shape(print_label))
print(print_label)
print(print_img)

import matplotlib.pyplot as plt
from IPython.core.pylabtools import figsize

#打印每类水果的第五张图像
def print_fruit(print_img, print_label, size) :
    plt.figure(figsize(size, size))
    for i in range(len(print_img)):
        #图像输出格式为11行10列
        plt.subplot(, ,(i+))
        #打印图像
        plt.imshow(print_img[i])
        #打印水果种类
        plt.title(format(print_label[i]))
        plt.axis('off')
    plt.show()

print_img, print_label = load_print_img(Test)
#打印水果
print_fruit(print_img, print_label, )

import random

#随机获取水果种类
def get_random_fruits(root, n_classes):
    #创建一个1到水果种类总数的list
    fruits = []
    for i in range(len(os.listdir(root))):
        fruits.append(i)
    #随机获取n_classes个随机不重复的水果种类
    random_fruits = random.sample(fruits, n_classes)
    return random_fruits

#获取随机抽取的10类水果的图像
def load(root, random_fruits):
    #存放图像
    image_data = []
    #存放标签
    image_label = []
    #存放图像标签码
    num_label = []
    #遍历水果类型
    for i in range(len(random_fruits)):
        #第一层子目录（水果种类）
        child1 = os.listdir(root)[i]
        #第二层子目录（水果图像）
        child2 = os.listdir(os.path.join(root, child1))
        #对第二层目录进行自然数排序，os.listder默认为str排序
        child2 = natsorted(child2)
        #遍历水果图像
        for j in range(len(child2)):
            #结合第一二层子目录
            path = os.path.join(root, child1, child2[j])
            #只读取'.jpg'文件（文件后缀是否为'.jpg'）
            if(path.endswith('.jpg')):
                #把文件读取为图像存入image_data
                image_data.append(skimage.data.imread(path))
                #储存第一层子目录文件名（即水果名）
                image_label.append(child1)
                #把第一层子目录文件名的下标作为水果类型的编码
                num_label.append(i)
                #把水果类型编码转换为one_hot编码
    num_label = keras.utils.to_categorical(num_label, len(random_fruits))
    #print("图片数:{0}, 标签数:{1}".format(len(image_data), len(os.listdir(root))) #输出图片和标签数
    return image_data, image_label, num_label

#裁剪图像
def crop(image_data):
    crop_data = []
    for i in image_data:
        #把图像转换成32*32的格式
        I_crop = skimage.transform.resize(i, (, ))
        #把转换后的图像放入Icrop_data
        crop_data.append(I_crop)
    return crop_data

def fruits_type(random_fruits):
    print('fruits_type:')
    for i in random_fruits:
        print(os.listdir(Training)[i])

#定义水果种类数
n_classes =
#batch_size =  #定义块的大小
#batch_num = int(np.array(crop_img).shape[]/batch_size) #计算取块的次数
#申请四维占位符,数据类型为float32
x = tf.placeholder(tf.float32,[None, , , ])
#申请二维占位符,数据累型为float32
y = tf.placeholder(tf.float32,[None, n_classes])
#申请一维占位符，数据类型为float32
keep_prob = tf.placeholder(tf.float32)
#epochs= #训练次数
#每个神经元保留的概率
dropout=0.75
#卷积核大小
k_size =  

Weights = {
"conv_w1" : tf.Variable(tf.random_normal([k_size, k_size, , ]), name = 'conv_w1'),
"conv_w2" : tf.Variable(tf.random_normal([k_size, k_size, , ]), name = 'conv_w2'),
#"conv_w3" : tf.Variable(tf.random_normal([k_size, k_size, , ]), name = 'conv_w3'), \
"den_w1" : tf.Variable(tf.random_normal([int(*//*), ]), name = 'dev_w1'),
"den_w2" : tf.Variable(tf.random_normal([, ]), name = 'den_w2'),
"den_w3" : tf.Variable(tf.random_normal([, n_classes]), name = 'den_w3')
}

bias = {
"conv_b1" : tf.Variable(tf.random_normal([]), name = 'conv_b1'),
"conv_b2" : tf.Variable(tf.random_normal([]), name = 'conv_b2'),
#"conv_b3" : tf.Variable(tf.random_normal([]), name = 'conv_b3'), \
"den_b1" : tf.Variable(tf.random_normal([]), name = 'den_b1'),
"den_b2" : tf.Variable(tf.random_normal([]), name = 'den_b2'),
"den_b3" : tf.Variable(tf.random_normal([n_classes]), name = 'den_b3')
}

def conv2d(x,W,b,stride=):
    x=tf.nn.conv2d(x,W,strides=[,stride,stride,],padding="SAME")
    x=tf.nn.bias_add(x,b)
    return tf.nn.relu(x)

def maxpool2d(x,stride=):
    return tf.nn.max_pool(x,ksize=[,stride,stride,],strides=[,stride,stride,],padding="SAME")

def conv_net(inputs, W, b, dropout):
    ## convolution layer
    ## 输入32**3的数据，输出16**64的数据
    conv1 = conv2d(x, W["conv_w1"], b["conv_b1"])
    conv1 = maxpool2d(conv1, )
    tf.summary.histogram('ConvLayer1/Weights', W["conv_w1"])
    tf.summary.histogram('ConvLayer1/bias', b["conv_b1"])
    ## convolution layer2
    ## 输入16**64的数据，输出8**128的数据
    conv2 = conv2d(conv1, W["conv_w2"], b["conv_b2"])
    conv2 = maxpool2d(conv2, )
    tf.summary.histogram('ConvLayer2/Weights', W["conv_w2"])
    tf.summary.histogram('ConvLayer2/bias', b["conv_b2"])
    ## convolution layer3
    #conv3 = conv2d(conv2, W["conv_w3"], b["conv_b3"])
    #conv3 = maxpool2d(conv3, )
    #tf.summary.histogram('ConvLayer3/Weights', W["conv_w3"])
    #tf.summary.histogram('ConvLayer3/bias', b["conv_b3"])
    ## flatten
    ## 把数据拉伸为长度为8**128的一维数据
    flatten = tf.reshape(conv2,[-, W["den_w1"].get_shape().as_list()[]])
    ## dense layer1
    ## 输入8192*1的数据，输出1024*1的数据
    den1 = tf.add(tf.matmul(flatten, W["den_w1"]), b["den_b1"])
    den1 = tf.nn.relu(den1)
    den1 = tf.nn.dropout(den1, dropout)
    tf.summary.histogram('DenLayer1/Weights', W["den_w1"])
    tf.summary.histogram('DenLayer1/bias', b["den_b1"])
    ## dense layer2
    ## *1的数据，输出512*1的数据
    den2 = tf.add(tf.matmul(den1, W["den_w2"]), b["den_b2"])
    den2 = tf.nn.relu(den2)
    den2 = tf.nn.dropout(den2, dropout)
    tf.summary.histogram('DenLayer2/Weights', W["den_w2"])
    tf.summary.histogram('DenLayer2/bias', b["den_b2"])
    ## out
    ## *1的数据，输出n_classes*1的数据
    out = tf.add(tf.matmul(den2, W["den_w3"]), b["den_b3"])
    tf.summary.histogram('DenLayer3/Weights', W["den_w3"])
    tf.summary.histogram('DenLayer3/bias', b["den_b3"])
    return out

pred=conv_net(x,Weights,bias,keep_prob)
cost=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred,labels=y))
tf.summary.histogram('loss', cost)
optimizer=tf.train.AdamOptimizer(0.01).minimize(cost)
correct_pred=tf.equal(tf.argmax(pred,),tf.argmax(y,))
accuracy=tf.reduce_mean(tf.cast(correct_pred,tf.float32))
merged=tf.summary.merge_all()

def train_and_test(train_x, train_y, test_x, test_y, epochs, batch_size, times = ) :
    # 初始化全局变量
    init=tf.global_variables_initializer()
    start_time = time.time()
    with tf.Session() as sess:
        sess.run(init)
        # 把需要可视化的参数写入可视化文件
        writer=tf.summary.FileWriter('F:\\data\\fruits-360\\tensorboard\\Fruit_graph' + str(times), sess.graph)
        for i in range(epochs):
            batch_num = int(np.array(train_x).shape[]/batch_size)
            sum_cost =
            sum_acc =
            for j in range(batch_num):
                batch_x = get_data(train_x, batch_size, j)
                batch_y = get_data(train_y, batch_size, j)
                sess.run(optimizer, feed_dict={x:batch_x,y:batch_y,keep_prob:0.75})
                loss,acc = sess.run([cost,accuracy],feed_dict={x:batch_x,y:batch_y,keep_prob: .})
                sum_cost += loss
                sum_acc += acc
                result=sess.run(merged,feed_dict={x:batch_x, y:batch_y, keep_prob:0.75})
                writer.add_summary(result, i)
            arg_cost = sum_cost/batch_num
            arg_acc = sum_acc/batch_num
            print("Epoch:", '%04d' % (i+),"cost=", "{:.9f}".format(arg_cost),"Training accuracy","{:.5f}".format(arg_acc))
        end_time = time.time()
        print('Optimization Completed')
        print('Testing Accuracy:',sess.run(accuracy,feed_dict={x:test_x, y:test_y,keep_prob: }))
        print('Total processing time:',end_time - start_time)

for i in range():
    random_fruits = get_random_fruits(Training, n_classes)
    img_data, img_label, num_label = load(Training, random_fruits)
    crop_img = crop(img_data)
    test_data, test_label, test_num_label = load(Test, random_fruits)
    crop_test = crop(test_data)
    print("TIMES"+str(i+))
    fruits_type(random_fruits)
    print("\n")
    train_and_test(crop_img, num_label, crop_test, test_num_label, , , (i+))
    print("\n\n\n")