1 # 导入工具包
2 import math
3 import time
4 import numpy as np
5 import h5py
6 import matplotlib.pyplot as plt
7 from scipy import ndimage
8 from PIL import Image
9 import tensorflow as tf
10 from tensorflow.python.framework import ops
11
12 %matplotlib inline
13 %pylab
14 np.random.seed(1)
15 conv_layers = {}
16
17 #独热编码
18 def convert_to_one_hot(Y,C):
19 """
20 Y:需要编码的输入
21 C:编码位数
22 """
23 Y = np.eye(C)[Y.reshape(-1)].T
24 return Y
25
26 #图片显示
27 def show_image(X,Y,index):
28 plt.imshow(X[index])
29 print("y = "+str(np.squeeze(Y[:,index]))) #squeeze 压缩成数字
30 plt.show()
31
32 #MINI-BATCH函数
33 def random_mini_batch(X,Y,mini_batch_size=64,seed=0):
34 """
35 X:输入数据，(m,Hi,Wi,Ci)
36 Y:直值(m.n_y)
37 mini_batch_size:mini_batch的数量，整数
38 return:
39 mini_batches:(mini_batch_X,mini_batch_Y)
40 """
41 m = X.shape[0] #训练数据的数量
42 mini_batches = []
43 np.random.seed(seed)
44
45 nums = m//mini_batch_size
46
47 #将(X,Y)洗牌 _permulation 用来打乱
48 permutation = list(np.random.permutation(m))
49 Shuffled_X = X[permutation,:,:,:]
50 Shuffled_Y = Y[permutation,:]
51
52 for k in range(0,nums):
53 mini_batch_X = Shuffled_X[k*mini_batch_size:(k+1)*mini_batch_size,:,:,:]
54 mini_batch_Y = Shuffled_Y[k*mini_batch_size:(k+1)*mini_batch_size,:]
55 mini_batch = (mini_batch_X,mini_batch_Y)
56 mini_batches.append(mini_batch)
57
58 if m%mini_batch_size != 0 :
59 mini_batch_X = Shuffled_X[nums*mini_batch_size:m,:,:,:]
60 mini_batch_Y = Shuffled_Y[nums*mini_batch_size:m,:]
61 mini_batch = (mini_batch_X,mini_batch_Y)
62 mini_batches.append(mini_batch)
63
64 return mini_batches
65
66 #数据导入
67 def load_dataset():
68 #训练集
69 train_dataset = h5py.File('datasets/train_signs.h5',"r") #html 5
70 train_set_x_orig = np.array(train_dataset["train_set_x"][:])
71 train_set_y_orig = np.array(train_dataset["train_set_y"][:])
72 #测试集
73 test_dataset = h5py.File('datasets/test_signs.h5','r')
74 test_set_x_orig = np.array(test_dataset["test_set_x"][:])
75 test_set_y_orig = np.array(test_dataset["test_set_y"][:])
76 #类别
77 classes = np.array(test_dataset["list_classes"][:])
78 #打印维度
79 print("Original Training datasets' dimensions:：X:{0},Y:{1}".format(train_set_x_orig.shape,
80 train_set_y_orig.shape))
81 print("Original Testing datasets' dimensions：X:{0},Y:{1}".format(test_set_x_orig.shape,
82 test_set_y_orig.shape))
83 #将y转换成列向量
84 train_set_y_orig = train_set_y_orig.reshape((1,train_set_y_orig.shape[0]))
85 test_set_y_orig = test_set_y_orig.reshape((1,test_set_y_orig.shape[0]))
86 Y_train = train_set_y_orig
87 Y_test = test_set_y_orig
88 #归一化
89 X_train = train_set_x_orig/255
90 X_test = test_set_x_orig/255
91 #将Y进行独热编码 0-100000 1-010000...并且转换为横向量
92 Y_train_1hot = convert_to_one_hot(Y_train,6).T
93 Y_test_1hot = convert_to_one_hot(Y_test,6).T
94 #打印其余数据维度
95 print ("number of training examples = " + str(X_train.shape[0]))
96 print ("number of test examples = " + str(X_test.shape[0]))
97 print ("X_train shape: " + str(X_train.shape))
98 print ("Y_train shape: " + str(Y_train_1hot.shape))
99 print ("X_test shape: " + str(X_test.shape))
100 print ("Y_test shape: " + str(Y_test_1hot.shape))
101
102 return train_set_x_orig,test_set_x_orig,Y_train,Y_test,\
103 X_train,X_test,Y_train_1hot,Y_test_1hot,classes
104
105 #编写占位符函数
106 def create_placeholders(n_H0,n_W0,n_C0,n_y):
107 """
108 n_H0:标量，图片高 height
109 n_W0:标量，图片宽 weight
110 n_c0:标量，图片输入的通道数 channels
111 n_y:标量，分类数
112 """
113 X = tf.placeholder(tf.float32,shape=(None,n_H0,n_W0,n_C0))
114 Y = tf.placeholder(tf.float32,shape=(None,n_y))
115 return X,Y
116
117 #参数初始化函数
118 def initialize_parameters():
119 """
120 初始化权重参数W1,W2
121 只需要初始化conv2d函数的权重(filters)
122 对于FC层，Tensorflow会自动初始化
123 """
124 tf.set_random_seed(1)
125 W1 = tf.get_variable("W1",[4,4,3,8],
126 initializer=tf.contrib.layers.xavier_initializer(seed=0))
127 W2 = tf.get_variable("W2",[2,2,8,16],
128 initializer=tf.contrib.layers.xavier_initializer(seed=0))
129 parameters={"W1":W1,
130 "W2":W2}
131 return parameters
132
133 #前向传播
134 def forward_propagation(X,parameters):
135 #取回参数
136 W1 = parameters['W1']
137 W2 = parameters['W2']
138 #CONV2D
139 Z1 = tf.nn.conv2d(X,W1,strides=[1,1,1,1],padding='SAME')
140 #RELU
141 A1 = tf.nn.relu(Z1)
142 #MAXPOOL:WINDOW_8X8; STRIDE_8; PADDING_SAME;
143 P1 = tf.nn.max_pool(A1,ksize=[1,8,8,1],strides=[1,8,8,1],padding='SAME')
144 #CONV2D
145 Z2 = tf.nn.conv2d(P1,W2,strides = [1,1,1,1],padding='SAME')
146 #RELU
147 A2 = tf.nn.relu(Z2)
148 #MAXPOOL
149 P2 = tf.nn.max_pool(A2,ksize=[1,4,4,1],strides=[1,4,4,1],padding='SAME')
150 #FALTTEN
151 P2 = tf.contrib.layers.flatten(P2)
152 #FC全连接层，暂时不用进行非线性激活，不调用softmax，最后连接到6个神经元做 softmax
153 Z3 = tf.contrib.layers.fully_connected(P2,num_outputs=6,activation_fn=None)
154 return Z3
155
156 #计算损失
157 def compute_cost(Z3,Y):
158 cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=Z3,
159 labels=Y))
160 return cost
161
162 #模型
163 def model(X_train,Y_train,X_test,Y_test,learning_rate=0.009,num_epochs=100,
164 mini_batch_size = 64,print_cost = True):
165 #可以不需要重新写入来重复运行这个模型
166 ops.reset_default_graph()
167 tf.set_random_seed(1)
168 seed = 3
169 (m,n_H0,n_W0,n_C0) = X_train.shape
170 n_y = Y_train.shape[1]
171 costs = [] #用于绘图
172 #建立占位符
173 X,Y = create_placeholders(n_H0,n_W0,n_C0,n_y)
174 #初始化参数
175 parameters = initialize_parameters()
176 #前向传播
177 Z3 = forward_propagation(X,parameters)
178 #计算损失
179 cost = compute_cost(Z3,Y)
180 #反向传播，定义tensorflow优化器，使用Adam优化器来最小化cost
181 optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
182 #初始化全局变量
183 init = tf.global_variables_initializer()
184 #开始进行tensorflow计算
185 with tf.Session() as sess:
186 #初始化
187 sess.run(init)
188 #循环训练
189 for epoch in range(num_epochs):
190 minibatch_cost = 0
191 # seed = seed+1
192 nums = m//mini_batch_size
193 minibatches=random_mini_batch(X_train,Y_train,mini_batch_size,seed)
194 for minibatch in minibatches:
195 #选择一组minibatch
196 (minibatch_X,minibatch_Y) = minibatch
197 _,temp_cost = sess.run([optimizer,cost],
198 feed_dict = {X:minibatch_X,Y:minibatch_Y})
199 minibatch_cost += temp_cost/nums
200 #打印损失
201 if print_cost == True and epoch%5 == 0:
202 print("第{0}次迭代，当前cost:{1}".format(epoch,minibatch_cost))
203 if print_cost == True and epoch%1 == 0:
204 costs.append(minibatch_cost)
205 #绘出损失图
206 plt.plot(np.squeeze(costs))
207 plt.plot(np.squeeze(costs))
208 plt.grid(True)
209 plt.ylabel('cost')
210 plt.xlabel('iterations (per tens)')
211 plt.title("Learning rate =" + str(learning_rate))
212 plt.show()
213 #计算正确预测
214 #返回最大的索引
215 predict_op = tf.argmax(Z3,1)
216 #判断是否相同 返回布尔值
217 correct_prediction = tf.equal(predict_op,tf.argmax(Y,1))
218
219 #计算测试集精度 #转换为数字了 tf.cast
220 accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float"))
221 print(accuracy)
222
223 train_accuracy = accuracy.eval({X:X_train,Y:Y_train})
224 test_accuracy = accuracy.eval({X:X_test,Y:Y_test})
225 print("Train Accuracy:", train_accuracy)
226 print("Test Accuracy:", test_accuracy)
227
228 return train_accuracy, test_accuracy, parameters
229
230 #数据导入：
231 X_orig_train,X_orig_test,Y_orig_train,Y_orig_test,\
232 X_train,X_test,Y_train,Y_test,classes = load_dataset()
233
234 #运行模型
235 _,_,parameters = model(X_train,Y_train,X_test,Y_test)
测试代码：
1 #测试代码
2 #显示其中一张图片
3 show_image(X_train,Y_orig_train,0)
4 #占位符测试
5 X,Y = create_placeholder(100,100,3,6)
6 print(str(X))
7 print(str(Y))
8 #filters初始化测试
9 tf.reset_default_graph()
10 with tf.Session() as sess_test:
11 parameters = initialize_parameters()
12 init = tf.global_variables_initializer()
13 sess_test.run(init)
14 print("W1="+str(parameters["W1"].eval().shape))
15 print("W2="+str(parameters["W2"].eval().shape))
16 #前向传播测试
17 tf.reset_default_graph()
18 with tf.Session() as sess:
19 np.random.seed(1)
20 X,Y = create_placeholders(64,64,3,6)
21 parameters = initialize_parameters()
22 Z3 = forward_propagation(X,parameters)
23 init = tf.global_variables_initializer()
24 sess.run(init)
25 a = sess.run(Z3,{X:np.random.randn(4,64,64,3),Y:np.random.randn(4,6)})
26 print("Z3="+str(a))
27 #损失值测试
28 tf.reset_default_graph()
29 with tf.Session() as sess:
30 np.random.seed(1)
31 X, Y = create_placeholders(64, 64, 3, 6)
32 parameters = initialize_parameters()
33 Z3 = forward_propagation(X, parameters)
34 cost = compute_cost(Z3, Y)
35 init = tf.global_variables_initializer()
36 sess.run(init)
37 a = sess.run(cost, {X: np.random.randn(4,64,64,3), Y: np.random.randn(4,6)})
38 print("cost = " + str(a))
39 #mini_batches测试
40 X = np.random.randn(660,10,10,3)
41 Y = np.random.randn(660,6)
42 mini_batches = random_mini_batch(X,Y,mini_batch_size=5,seed=0)
43 # print(mini_batches[1:10])