从锅炉工到AI专家(8)

#这个程序相当于一个库，不会直接执行，
#所以开始没有用于脚本模式的标志
# -*- coding=UTF-8 -*-

import tensorflow as tf
import numpy as np
import scipy.io as sio

netmat_path = 'data/imagenet-vgg-verydeep-19.mat'

    

##定义卷积层
def _conv_layer(input, weight, bias):
    conv = tf.nn.conv2d(input, tf.constant(weight), strides=(1, 1, 1, 1), padding='SAME')
    return tf.nn.bias_add(conv, bias)


##定义池化层
def _pool_layer(input):
    return tf.nn.max_pool(input, ksize=(1, 2, 2, 1), strides=(1, 2, 2, 1), padding='SAME')


##定义全链接层
def _fc_layer(input, weights, bias):
    shape = input.get_shape().as_list()
    dim = 1
    for d in shape[1:]:
        dim *= d
    x = tf.reshape(input, [-1, dim])
    fc = tf.nn.bias_add(tf.matmul(x, weights), bias)
    return fc


##定义softmax分类输出层
def _softmax_preds(input):
    preds = tf.nn.softmax(input, name='prediction')
    return preds


##图片处里前减去均值（归一化的部分工作）
def _preprocess(image, mean_pixel):
    return image - mean_pixel


##加均值，用于还原可显示图片
def _unprocess(image, mean_pixel):
    return image + mean_pixel

##构建cnn前向传播网络
def net(data, input_image):
    #根据vgg19的标准定义深层卷积网络
    layers = (
        'conv1_1', 'relu1_1', 'conv1_2', 'relu1_2', 'pool1',

        'conv2_1', 'relu2_1', 'conv2_2', 'relu2_2', 'pool2',

        'conv3_1', 'relu3_1', 'conv3_2', 'relu3_2',
        'conv3_3', 'relu3_3', 'conv3_4', 'relu3_4', 'pool3',

        'conv4_1', 'relu4_1', 'conv4_2', 'relu4_2',
        'conv4_3', 'relu4_3', 'conv4_4', 'relu4_4', 'pool4',

        'conv5_1', 'relu5_1', 'conv5_2', 'relu5_2',
        'conv5_3', 'relu5_3', 'conv5_4', 'relu5_4', 'pool5',

        'fc6', 'relu6',
        'fc7', 'relu7',
        'fc8', 'softmax'
    )

    weights = data['layers'][0]
    net = {}
    current = input_image
    #枚举所有的层
    for i, name in enumerate(layers):
        #取名字的前4个字母作为本层的类型
        kind = name[:4]
        #根据conv/relu/pool/soft这几种情况，调用对应函数定义相应层
        #每次定义层以上一层的输出为输入，将整个网络连接起来
        if kind == 'conv':
            kernels, bias = weights[i][0][0][0][0]
            kernels = np.transpose(kernels, (1, 0, 2, 3))
            bias = bias.reshape(-1)
            current = _conv_layer(current, kernels, bias)
        elif kind == 'relu':
            current = tf.nn.relu(current)
        elif kind == 'pool':
            current = _pool_layer(current)
        elif kind == 'soft':
            current = _softmax_preds(current)

        #处理最后的全连接层
        kind2 = name[:2]
        if kind2 == 'fc':
            kernels1, bias1 = weights[i][0][0][0][0]

            kernels1 = kernels1.reshape(-1, kernels1.shape[-1])
            bias1 = bias1.reshape(-1)
            current = _fc_layer(current, kernels1, bias1)

        net[name] = current
    assert len(net) == len(layers)
    return net, layers

def predict(image):
    global data,mean_pixel
    #统一减去均值
    image_pre = _preprocess(image, mean_pixel)
    #拉成数组
    image_pre = np.expand_dims(image_pre, axis=0)

    #转成浮点矩阵
    image_preTensor = tf.to_float(tf.convert_to_tensor(image_pre))

    #定义深度VGG19神经网络及载入图片数据用于预测
    nets, layers = net(data, image_preTensor)

    #取分类层数据
    preds = nets['softmax']

    #从分类转成整数的索引，
	#实际上.eval才是真正开始tensorFlow计算，以前那么多工作都是在建模型
    predsSortIndex = np.argsort(-preds[0].eval())

    #返回预测数据
    return predsSortIndex,preds

#载入训练好的矩阵文件，
#loadmat是载入matlab的数据数据文件
data = sio.loadmat(netmat_path)
mean = data['normalization'][0][0][0]
#获取图片像素均值用于图片的归一化
mean_pixel = np.mean(mean, axis=(0, 1))

#!/usr/bin/env python
# -*- coding=UTF-8 -*-

import vgg
import os,sys
import numpy as np
import scipy.misc
import tensorflow as tf
import argparse

FLAGS = None

##读取图片并把图片尺寸归一化
def _get_img(src, img_size=False):
    img = scipy.misc.imread(src, mode='RGB')
    if not (len(img.shape) == 3 and img.shape[2] == 3):
        img = np.dstack((img, img, img))
    if img_size != False:
        img = scipy.misc.imresize(img, img_size)
    return img.astype(np.float32)

##获取路径中文件列表
def list_files(in_path):
    files = []
    for (dirpath, dirnames, filenames) in os.walk(in_path):
        files.extend(filenames)
        break
    return files

##获取文件路径列表dir+filename
def _get_files(img_dir):
    files = list_files(img_dir)
    return [os.path.join(img_dir, x) for x in files]

##获得图片的分类标签值
def _get_allClassificationName(file_path):
    f = open(file_path, 'r')
    lines = f.readlines()
    f.close()
    return lines

def main(_):
    ##加载ImageNet mat标签
    lines = _get_allClassificationName('data/synset_words.txt')

    images = _get_files(FLAGS.image_dir)  ##获取图片路径中文件列表
    with tf.Session() as sess:
        for i, imgPath in enumerate(images):
            ##加载图片并压缩到标准格式=>224x224x3色
            image = _get_img(imgPath, (224, 224, 3))
            predsSortIndex,preds = vgg.predict(image)

            print('#####%s#######' % imgPath)
            for i in range(3):   ##输出前3种分类
                nIndex = predsSortIndex
                classificationName = lines[nIndex[i]] ##分类名称
                problity = preds[0][nIndex[i]]   ##某一类型概率

                print('%d.ClassificationName=%s  Problity=%f' % ((i + 1), classificationName, problity.eval()))
        sess.close()
		
if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('-i','--image_dir', type=str, default='images/',
                      help='Pic files folder path')
    FLAGS, unparsed = parser.parse_known_args()
    tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)