import numpy as np

import tensorflow as tf

import os

import glob

import cv2

from sklearn.utils import shuffle

def load_image(file_path, image_size, classes):

    num_classes = len(classes)

    images = []

    labels = []

    names = []

    cls = []

    # 第三步：循环标签，将路径和标签名进行拼接，获得图片文件路径，使用glob.glob获得图片路径

    for filed in classes:

        index = classes.index(filed)

        path = os.path.join(file_path, filed, '*g')

        files = glob.glob(path)

        # 第四步：循环图片路径，进行图片的读取

        for file in files:

            # cv2.imread图片的读取

            image = cv2.imread(file)

            # cv2.resize进行图片维度的重构

            image = cv2.resize(image, (image_size, image_size), 0, 0, cv2.INTER_LINEAR)

            # .astype进行图片的数据类型的变换

            image = image.astype('float32')

            # 使用np.multipy进行图片的归一化操作

            image = np.multiply(image, 1.0/255.0)

            # 将图片添加到列表中

            images.append(image)

            # 标签零值初始化

            label = np.zeros(num_classes)

            # 对于类别位置与标签位置对应，即设置为1

            label[index] = 1

            # 将标签进行添加

            labels.append(label)

            # 获得图片的名字，使用os.path.basename

            name = os.path.basename(file)

            # 将名字进行添加

            names.append(name)

            # 将类别名进行添加

            cls.append(filed)

    # 第五步: 将图片和标签名都转换为array格式， 并返回图片，标签，名字和类别

    images = np.array(images)

    labels = np.array(labels)

    return images, labels, names, cls

class DataSet(object):

    def __init__(self, images, labels, names, cls):

        self._num_image = images.shape[0]

        self._images = images

        self._labels = labels

        self._names = names

        self._cls = cls

        self._epoch_index = 0

    # 私有属性，返回实际的函数值

    @property

    def images(self):

        return self._images

    @property

    def labels(self):

        return self._labels

    @property

    def names(self):

        return self._names

    @property

    def cls(self):

        return self._cls

    @property

    def num_image(self):

        return self._num_image

    # next_batch函数，使用self._epoch_index用来创建初始索引和结束索引，返回batch图像，标签，名字和类别

    def next_batch(self, batch_size):

        start = self._epoch_index

        self._epoch_index += batch_size

        if self._epoch_index > self._num_image:

            start = 0

            self._epoch_index = batch_size

            assert batch_size < self._num_image

        end = self._epoch_index

        return self._images[start:end], self._labels[start:end], self._names[start:end], self._cls[start:end]

# 第一步：输入文件名，图片大小，标签，验证集的比例

def read_train_data(file_path, image_size, classes, val_size):

    # 第二步：构造类，实例化dataset用于存储训练集和验证集

     class DataSets(object):

         pass

     dataset = DataSets()

     # 第三步：载入图片，标签， 名字，类别名

     images, labels, names, cls = load_image(file_path, image_size, classes)

     # 第六步：对图片，标签，名字和类别名进行清洗

     images, labels, names, cls = shuffle(images, labels, names, cls)

     # 第七步：使用val_size 对训练集和验证集图片进行分开

     val_num = int(images.shape[0] * val_size)

     val_images = images[0:val_num]

     val_labels = labels[0:val_num]

     val_names = names[0:val_num]

     val_cls = cls[0:val_num]

     train_images = images[val_num:]

     train_labels = labels[val_num:]

     train_names = names[val_num:]

     train_cls = cls[val_num:]

     # 第八步：创建类别DataSet，实例化train和val数据集，并创建next_batch

     dataset.train = DataSet(train_images, train_labels, train_names, train_cls)

     dataset.val = DataSet(val_images, val_labels, val_names, val_cls)

     return dataset

import numpy as np

import tensorflow as tf

import matplotlib.pyplot as plt

import dataset

from numpy.random import  seed

seed(0)

from tensorflow import  set_random_seed

set_random_seed(20)

image_size = 60

val_size = 0.2

file_path = 'training_data'

classes = ['cats', 'dogs']

num_channel = 3

num_classes = len(classes)

# 第一部分数据的载入

data = dataset.read_train_data(file_path, image_size, classes, val_size)

image_num = data.train.images.shape[0]

# 第二部分：数据的实际训练

# 第一步参数设置，卷积层的维度和filter的个数

# 第一层卷积大小

filter1_size = 3

filter1_num = 32

# 第二层卷积大小

filter2_size = 3

filter2_num = 32

# 第三层卷积大小

filter3_size = 3

filter3_num = 64

# 隐含层大小

fc1_num = 1024

# 第二步：使用tf.placeholder设置初始输入参数

# 输入参数大小, [图片的数目，图片的宽度, 图片的长度， 图片的通道数]

x = tf.placeholder(tf.float32, [None, image_size, image_size, num_channel], name='x')

# 输入图片标签值，大小为[N, num_classes] 这里为N*2

y_true = tf.placeholder(tf.float32, [None, num_classes], name='y_true')

#真实类别对应的索引值，即1所在的位置

y_true_cls = tf.argmax(y_true, 1)

# 第三步：生成卷积过程中所需要的函数

def create_weight(shape):

    # 生成正态分布的初始值

    return tf.Variable(tf.truncated_normal(shape, stddev=0.05))

def create_bias(size):

    # 生成常数分布的初始值

    return tf.Variable(tf.constant(0.05, shape=[size]))

# 第四步：构造进行卷积的函数

def create_convolution_layers(input, input_channel, filter_size, filter_num):

    # 生成卷积使用的W，[3， 3， 3， 32]第一层卷积核大小

    W = create_weight([filter_size, filter_size, input_channel, filter_num])

    # 生成偏置项b [32]

    b = create_bias(filter_num)

    # 进行卷积操作

    conv_layer = tf.nn.conv2d(input, W, strides=[1, 1, 1, 1], padding='SAME') + b

    # 进行激活操作

    conv_layer = tf.nn.relu(conv_layer)

    # 使用tf.nn.max_pool进行池化操作

    max_pool = tf.nn.max_pool(conv_layer, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

    # 返回池化的结果

    return max_pool

# 第五步：构造图像变换的函数

def create_flatten_conv(input):

    # 获得图片的后3个维度的大小

    input_shape = input.get_shape()[1:4].num_elements()

    # 对图像进行维度的变化，即[-1, input_shape] 以便用于后续的全连接操作

    out = tf.reshape(input, shape=[-1, input_shape])

    return out

# 第六步：构造进行全连接变化的函数

def create_fc_layer(input, num_input, fc1_num, relu_true = True):

    # 构造全连接的函数，即后三个维度的大小和第一个全连接的大小

    W = create_weight([num_input, fc1_num])

    # 构造偏置项b

    b = create_bias(fc1_num)

    # 构造线性变化，即x * w + b

    layer = tf.matmul(input, W) + b

    # 对全连接层进行dropout变化

    layer = tf.nn.dropout(layer, keep_prob=0.7)

    # 如果需要进行激活层

    if relu_true:

        # 就进行激活变化

        layer = tf.nn.relu(layer)

    # 返回结果

    return layer

# 第七步：进行正式的卷积过程

# 第一层卷积，输入为x， 通道数，卷积核的大小，卷积的个数

conv_h1 = create_convolution_layers(x, num_channel, filter1_size, filter1_num)

# 第二层卷积

conv_h2 = create_convolution_layers(conv_h1, filter1_num, filter2_size, filter2_num)

# 第三层卷积

conv_h3 = create_convolution_layers(conv_h2, filter2_num, filter3_size, filter3_num)

# 获得第三层卷积后的后3个维度的大小

flatten_shape = conv_h3.get_shape()[1:4].num_elements()

# 对图像进行维度变化

flatten_conv = create_flatten_conv(conv_h3)

# 进行全连接操作，输入的是变换后的图像，全连接的第一个维度和第二个维度

fc_h1 = create_fc_layer(flatten_conv, flatten_shape, fc1_num)

# 进行第二次全连接，输出预测的得分值

out = create_fc_layer(fc_h1, fc1_num, num_classes, relu_true=False)

# 第八步：使用tf.nn.softmax获得输入得分的概率值

y_pred = tf.nn.softmax(out, name='y_pred')

# 使用tf.agrmax获得对应的最大索引的大小

y_pred_cls = tf.argmax(y_pred, 1)

# 第九步：使用tf.reduce_mean获得softmax的损失值

cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true, logits=out))

# 第十步：使用自适应梯度下降，进行损失值的下降

train_op = tf.train.AdamOptimizer(0.0001).minimize(cost)

# 第十一步：使用tf.equal表示类别是否相同

correct_pred = tf.equal(y_true_cls, y_pred_cls)

accur = tf.reduce_mean(tf.cast(correct_pred, 'float'))

# 构造session函数

session = tf.Session()

# 构造存储函数

saver = tf.train.Saver()

# 进行初始化操作

session.run(tf.global_variables_initializer())

batch_size = 32

def show_progress(data, lost, epoch, i):

    tr_image_batch, tr_label_batch = data.train.next_batch(batch_size)[0:2]

    val_image_batch, val_label_batch = data.val.next_batch(batch_size)[0:2]

    # 输出训练样本的准确率

    tr_accur = session.run(accur, feed_dict={x:tr_image_batch, y_true:tr_label_batch})

    # 输出验证样本的准确率

    val_accur = session.run(accur, feed_dict={x:val_image_batch, y_true:val_label_batch})

    # 打印epoch值，训练集和验证集准确率，训练的损失值，迭代的次数

    content = ('train_epoch {0} tr_accur {1:>6.1%} val_accur {2:6.1%} train_loss {3:.3f} iteration_num {4}')

    print(content.format(epoch, tr_accur, val_accur, lost, i))

def train(num_iteration):

    start_epoch = 0

    for i in range(num_iteration):

        # 第十二步：构造函数进行参数的实际代入，使用data.train.next_batch获得模型的训练样本和验证集样本，进行模型训练

        batch_image, batch_labels, batch_nams, batch_cls = data.train.next_batch(batch_size)

        session.run(train_op, feed_dict={x:batch_image, y_true:batch_labels})

        #第十三步：每一个epoch进行模型的准确率的输出

        if i % int(data.train.num_image / batch_size) == 0:

            # 计算模型的损失值

            loss = session.run(cost, feed_dict={x:batch_image, y_true:batch_labels})

            # 展示模型的训练集和验证集的准确率

            show_progress(data, loss, start_epoch, i)

            start_epoch += 1

            # 第十四步：使用saver.save(session, './dog-cats-model/dog-cat.ckpt', global_step)进行模型的参数保存

            saver.save(session, './dog-cats-model/dog-cat.ckpt', global_step=i)

train(8000)

import tensorflow as tf

import numpy as np

import cv2

# 第一步图片的载入

image_size = 60

# 图片的文件名

path = 'cat.4.jpg'

# 读取图片

image = cv2.imread(path)

# 改变图片的大小

image = cv2.resize(image, (image_size, image_size), 0, 0, cv2.INTER_LINEAR)

# 图片类型的转换

image = image.astype('float32')

# 进行图像的归一化

image = np.multiply(image, 1.0/255.0)

# 对图像进行维度的变化

x_batch = image.reshape(1, image_size, image_size, 3)

# 加载模型，对图片进行预测

# 初始化sess

sess = tf.Session()

# 载入saver，获得模型的结果saver

saver = tf.train.import_meta_graph('./dog-cats-model/dog-cat.ckpt-3700.meta')

# 使用saver加载sess

saver.restore(sess, './dog-cats-model/dog-cat.ckpt-3700')

# 获得模型的结构图

graph = tf.get_default_graph()

# 使用结构图获得模型参数y_pred

y_pred = graph.get_tensor_by_name('y_pred:0')

# 获得模型参数x

x = graph.get_tensor_by_name('x:0')

# 获得模型参数y_true

y_true = graph.get_tensor_by_name('y_true:0')

# 构造真实的标签值，初始化

y_test_images = np.zeros((1, 2))

# 输入的样本参数

feed_dict_testing = {x:x_batch, y_pred:y_test_images}

# 获得模型的预测结果，使用sess.run

result = sess.run(y_pred, feed_dict=feed_dict_testing)

# 根据预测得分，获得最大值的标签索引做为标签索引，获得最终的预测结果

res_label = ['cat', 'dog']

print(res_label[result.argmax()])