# test.py

import sys

print(sys.argv[1:])

a = {'a':1, 'b':2}

np.save('a.npy', a)

c = np.load('a.npy', encoding='bytes').item()

print(c)

a = {'a':1, 'b':2}

np.save('a.npy', a)

c = np.load('a.npy', encoding='bytes').item()

print(c)

with tf.variable_scope('a'):

    w = tf.get_variable('w', shape=[1], initializer=tf.constant_initializer(10))

with tf.variable_scope('b'):

    w = tf.get_variable('w', shape=[1], initializer=tf.constant_initializer(20))

with tf.Session() as sess:

    for name in c:

        x = np.reshape(c[name], w.shape)

        with tf.variable_scope(name, reuse=True):

            w = tf.get_variable('w', trainable=False).assign(x)

            print(sess.run(w))

import argparse

import cv2

import numpy as np

import tensorflow as tf

import sys

import os

import alexnet

import caffe_classes

import urllib.request

# 第一步：使用argparse构建输入参数

parser = argparse.ArgumentParser(description='classify some picture')

# 是够是本地路径

parser.add_argument('images', choices=['folder', 'url'], default='folder')

# 添加路径

parser.add_argument('path', help='the image path')

# 用于获得除了testAlex.py的其他参数

args = parser.parse_args(sys.argv[1:])

# 第二步：根据路径读图片数据

# 本地路径

if args.images == 'folder':

    # 使用lambda做路径的组合函数

    withPath = lambda f:'{}/{}'.format(args.path, f)

    # 使用os.listdir()遍历文件路径，获得图片名，判断组合路径下的文件是够是文件，如果是，就使用cv2.imread读取组合路径下的图片

    testImg = dict((f, cv2.imread(withPath(f))) for f in os.listdir(args.path) if os.path.isfile(withPath(f)))

# 网上图片的路径

elif args.images == 'url':

    # 根据url定义读取的文件

    def url2img(url):

        """url to image"""

        # 打开url

        resp = urllib.request.urlopen(url)

        # 将读取的文件转换为二进制类型

        image = np.asarray(bytearray(resp.read()))

        # 对图片进行解码操作，转换为utf-8

        image = cv2.imdecode(image, cv2.IMREAD_COLOR)

        return image

    # 将读取的图片转换为字典的格式

    testImg = {args.path : url2img(args.path)}

# 第三步:如果存在testImg,进行参数设置

if testImg.values():

    # 用于dropout参数层

    dropout = 1

    # 用于判断哪些参数不需要进行加载

    skip = []

    # 分类的类别数

    numClass = 1000

    # 使用tf.placeholder进行x的输入参数初始化

    x = tf.placeholder(tf.float32, [1, 227, 227, 3])

    # 图片的imgMean，原始图片训练的时候也是使用这个值的

    imgMean = np.array([104, 117, 124], dtype=np.float32)

    # 第四步：对模型进行实例化操作

    model = alexnet.AlexNet(x, dropout, numClass, skip)

    # 第五步：使用model.fc8获得模型的score得分

    score = model.fc8

    # 第六步：使用tf.nn.softmax获得模型的概率值

    prob = tf.nn.softmax(score)

    # 第七步：使用with tf.Session() as sess构造执行函数

    with tf.Session() as sess:

        # 第八步：使用model中的load_model函数加载模型的参数，并将参数赋值给定义好的参数

        model.load_model(sess)

        # 第九步：对读入的图片进行预测类别的操作

        for image in testImg.values():

            # 进行图像的维度变换，变为227,227，同时去除均值

            resized = cv2.resize(image.astype(np.float32), (227, 227)) - imgMean

            # sess.run获得prob值，再使用np.argmax获得最大值的索引值

            mmax = np.argmax(sess.run(prob, feed_dict={x:[resized]}))

            # 获得索引值对应的标签名

            res = caffe_classes.class_names[mmax]

            # 第十步：进行作图操作

            # 字体

            font = cv2.FONT_HERSHEY_SIMPLEX

            # 将文字添加到图片中

            cv2.putText(image, res, (int(image.shape[0]/3), int(image.shape[1]/3)), font, 1, (0, 0, 255), 3)

            # 图片的展示

            cv2.imshow('image', image)

            # 按任意键退出

            cv2.waitKey(0)

import tensorflow as tf

import numpy as np

# 卷积层，输入参数x, 卷积核的宽和长，步长的大小，卷积的数目，输出层的名字，是否补零，以及分层的数目

def convLayer(x, Kheight, Kwidth, strideX, strideY, numfilter, name, padding='SAME', groups=1):

    # 获得图片的通道数

    channels = int(x.get_shape()[-1])

    # 使用lambda构造卷积的函数

    conv = lambda a, b:tf.nn.conv2d(a, b, strides=[1, strideY, strideX, 1], padding=padding)

    # 在名字为name的环境下，进行卷积操作

    with tf.variable_scope(name) as scope:

        # 使用tf.get_variable初始化w

        w = tf.get_variable('w', shape=[Kheight, Kwidth, channels/groups, numfilter])

        # 初始化b

        b = tf.get_variable('b', shape=[numfilter])

        # 根据group的大小，如果group等于2，那么第三个维度就切分成两个数据

        # X的切分

        Xnew = tf.split(value=x, num_or_size_splits=groups, axis=3)

        # w的切分

        Wnew = tf.split(value=w, num_or_size_splits=groups, axis=3)

        # 对于各自的X,w进行分别的卷积操作

        featureMap = [conv(t1, t2) for t1, t2 in zip(Xnew, Wnew)]

        # 将各自卷积后的结果进行拼接，方便后续的池化和归一化操作

        mergeMap = tf.concat(featureMap, axis=3)

        # 添加偏置项

        out = tf.nn.bias_add(mergeMap, b)

        # 添加激活层函数， 名字为scope.name

        out = tf.nn.relu(out, name=scope.name)

        return out

# 最大值池化，输入参数为x，卷积的宽和长，卷积的步长，结果的名字，以及补零

def MaxPool(x, Kheight, Kwidth, strideX, strideY, name, padding='SAME'):

    # tf.nn.max_pool的参数，输入x, ksize表示卷积大小，strides表示步长，name表示返回值的名字，padding补零的方式

    return tf.nn.max_pool(x, ksize=[1, Kheight, Kwidth, 1], strides=[1, strideY, strideX, 1], name=name, padding=padding)

# 局部响应归一化

def LRN(x, R, alpha, beta, name, bias=1.0):

    # 在不同的filter上进行各个像素的归一化操作

    return tf.nn.lrn(x, depth_radius=R, alpha=alpha, beta=beta, name=name, bias=bias)

# 全连接操作，输入x, inputS表示输入层w的大小，outputS表示输出层w的大小，relu_flag表示是否卷积，name表示名字

def fcLayer(x, inputS, outputS, relu_flag, name):

   # 在name的范围下进行操作

    with tf.variable_scope(name) as scope:

        # 设置w的维度

        w = tf.get_variable('w', shape=[inputS, outputS])

        # 设置b的维度

        b = tf.get_variable('b', shape=[outputS])

        # 进行点乘在进行加偏置项操作

        out = tf.nn.xw_plus_b(x, w, b, name=scope.name)

        # 如果进行relu

        if relu_flag:

            # 使用tf.nn.relu进行relu操作

            return tf.nn.relu(out)

        else:

            return out

# 进行dropout，输入x，保留的大小,keep_prob,name表示名字

def dropout(x, keep_prob, name):

    return tf.nn.dropout(x, keep_prob=keep_prob, name=name)

class AlexNet(object):

    def __init__(self, x, keep_prob, numClass, skip, pathmodel='bvlc_alexnet.npy'):

        # 将输入的参数进行self操作

        self.x = x

        self.keep_prob = keep_prob

        self.numClass = numClass

        self.skip = skip

        # 参数的路径

        self.pathmodel = pathmodel

        # 进行模型框架的构建

        self.bulidModel()

    def bulidModel(self):

        # 进行第一层的卷积操作，卷积核的大小为11*11，步长为4*4, num_filter=96,name='conv1', padding='VALID'

        conv1 = convLayer(self.x, 11, 11, 4, 4, 96, 'conv1', 'VALID')

        # 进行第一层的最大值池化操作

        pool1 = MaxPool(conv1, 3, 3, 2, 2, 'pool1', 'VALID')

        # 进行局部响应归一化操作

        lrn1 = LRN(pool1, 2, 2e-5, 0.75, 'norm1')

        # 进行第二次的卷积操作，卷积核大小5*5，步长1，num_filter=256, 名字'conv2'，进行分层卷积操作

        conv2 = convLayer(lrn1, 5, 5, 1, 1, 256, 'conv2', groups=2)

        # 进行第二层的最大值池化操作

        pool2 = MaxPool(conv2, 3, 3, 2, 2, 'pool2', 'VALID')

        # 进行局部响应归一化操作

        lrn2 = LRN(pool2, 2, 2e-5, 0.75, 'norm2')

        # 进行第三层的卷积操作，卷积核的大小为3*3， 步长为1*1，num_filter=384,name='conv3'

        conv3 = convLayer(lrn2, 3, 3, 1, 1, 384, 'conv3')

        # 进行第四层卷积操作，卷积核的大小为3*3,1*1，num_filter=384，进行分层操作

        conv4 = convLayer(conv3, 3, 3, 1, 1, 384, 'conv4', groups=2)

        # 进行第五层卷积操作，卷积核大小为3*3,步长为1*1,num_filter=256, name='conv5'进行分层操作

        conv5 = convLayer(conv4, 3, 3, 1, 1, 256, 'conv5', groups=2)

        # 进行第五层的池化操作

        pool5 = MaxPool(conv5, 3, 3, 2, 2, 'pool5', 'VALID')

        # 对于池化后的数据，进行维度的变换，将4维数据，转换为二维数据，以便进行后续的全连接操作

        fcIn = tf.reshape(pool5, [-1, 6*6*256])

        # 进行全连接操作，输入参数，输入层w的维度，输出层w的维度，是够进行relu操作，name='fc6'

        fc6 = fcLayer(fcIn, 6*6*256, 4096, True, 'fc6')

        # 进行dropout操作

        dropout1 = dropout(fc6, self.keep_prob, 'dropout1')

        # 进行第七层的全连接操作，输入，4096表示输入层w的维度，4096输出层w的维度

        fc7 = fcLayer(dropout1, 4096, 4096, True, 'fc7')

        # 进行dropout操作

        dropout2 = dropout(fc7, self.keep_prob, 'dropout2')

        # 最后一层进行类别预测得分的层，使用self.fc8为了score可以被外部调用

        self.fc8 = fcLayer(dropout2, 4096, self.numClass, True, 'fc8')

    # 将加载的参数根据层的名字，赋值给w和b参数

    def load_model(self, sess):

        # 进行npy文件的读取，使用.item()获得实际的值，这里的表示方式是列表，键为层数名，值为w和b

        dict_W = np.load(self.pathmodel, encoding='bytes').item()

        # 循环层数名

        for name in dict_W:

            # 如果层数名不在去除的名单里，这个可以用来进行参数的初始化，一部分参数不进行初始化，比如最后一层的finetune操作

            if name not in self.skip:

                # 在当前层的名字下，对参数进行复用

                with tf.variable_scope(name, reuse=True):

                    # 循环键中的参数值

                    for p in dict_W[name]:

                        # 如果参数的维度大于1，即为w

                        if len(p.shape) > 1:

                            # 使用tf.get_variable()获得值，使用trainable对参数实行冻结，.assign将读取的参数赋值给w

                            sess.run(tf.get_variable('w', trainable=False).assign(p))

                        else:

                            # 使用tf.get_variable获得参数，使用trainable对参数进行冻结，assign将读入数据赋值给b

                            sess.run(tf.get_variable('b', trainable=False).assign(p))