代碼：
1 #urllib is used to download the utils file from deeplearning.net
2 import urllib.request
3 response = urllib.request.urlopen('http://deeplearning.net/tutorial/code/utils.py')
4 content = response.read()
5 target = open('utils.py', 'wb+')
6 target.write(content)
7 target.close()
8 #Import the math function for calculations
9 import math
10 #Tensorflow library. Used to implement machine learning models
11 import tensorflow as tf
12 #Numpy contains helpful functions for efficient mathematical calculations
13 import numpy as np
14 #Image library for image manipulation
15 from PIL import Image
16 #import Image
17 #Utils file
18 import os
19
20 def create():
21 cwd = './data/'
22
23 '''
24 此處我加載的資料目錄如下：
25 0 -- img1.jpg
26 img2.jpg
27 img3.jpg
28 ...
29 1 -- img1.jpg
30 img2.jpg
31 ...
32 2 -- ...
33 這裡的0， 1， 2...就是類别，也就是下文中的classes
34 classes是我根據自己資料類型定義的一個清單，大家可以根據自己的資料情況靈活運用
35 ...
36 '''
37
38 writer = tf.python_io.TFRecordWriter("train.tfrecords")
39 classes= ['1','2']
40 print(classes)
41 class_path_img='./data/1/'
42 class_path_label = './data/2/'
43 for img_name in os.listdir(class_path_img):
44 img_path = class_path_img + img_name
45 print(img_path)
46 img = Image.open(img_path)
47 img = img.resize((125, 125))
48 img_raw = img.tobytes() # 将圖檔轉化為原生bytes
49
50 img_label_path=class_path_label+img_name
51 img_label=Image.open(img_label_path)
52 img_label=img_label.resize((125, 125))
53 img_label_raw=img_label.tobytes()
54 example = tf.train.Example(features=tf.train.Features(feature={
55 "label": tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_label_raw])),
56 'img_raw': tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw]))
57 }))
58 writer.write(example.SerializeToString()) # 序列化為字元串
59 writer.close()
60
61 def read_and_decode(filename):
62 #根據檔案名生成一個隊列
63 filename_queue = tf.train.string_input_producer([filename])
64
65 reader = tf.TFRecordReader()
66 _, serialized_example = reader.read(filename_queue) #傳回檔案名和檔案
67 features = tf.parse_single_example(serialized_example,
68 features={
69 'label': tf.FixedLenFeature([], tf.string),
70 'img_raw' : tf.FixedLenFeature([], tf.string),
71 })
72
73 img = tf.decode_raw(features['img_raw'], tf.uint8)
74 img = tf.reshape(img, [125, 125, 3])
75 img = tf.cast(img, tf.float32) * (1. / 255) - 0.5
76
77 label = tf.decode_raw(features['label'], tf.uint8)
78 label = tf.reshape(label, [125, 125, 3])
79 label = tf.cast(label, tf.float32) * (1. / 255) - 0.5
80
81 return img, label
82 img, label = read_and_decode("train.tfrecords")
83 img_batch, label_batch = tf.train.shuffle_batch([img, label],
84 batch_size=3, capacity=2000,
85 min_after_dequeue=1000)
86 print(img)
87 init = tf.initialize_all_variables()
88 print(img_batch)
89 with tf.Session() as sess:
90 sess.run(init)
91 threads = tf.train.start_queue_runners(sess=sess)
92 for i in range(1):
93 val, lab = sess.run([img_batch, label_batch])
94 # 我們也可以根據需要對val， l進行處理
95 #l = to_categorical(l, 12)
96 val = val.reshape((-1, (125 * 125 * 3)))
97 lab = lab.reshape((-1, (125 * 125 * 3)))
98 trX=val
99 trY=lab
100
101 '''
102 #導入MNIST資料
103
104 #Getting the MNIST data provided by Tensorflow
105 old_v = tf.compat.v1.logging.get_verbosity()
106 tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
107 from tensorflow.examples.tutorials.mnist import input_data
108
109 #Loading in the mnist data
110 mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
111 tf.compat.v1.logging.set_verbosity(old_v)
112 trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images,
113 mnist.test.labels
114
115
116 '''
117
118
119
120 #建構RBM層
121
122 #Class that defines the behavior of the RBM
123 class RBM(object):
124
125 def __init__(self, input_size, output_size):
126 #Defining the hyperparameters
127 self._input_size = input_size #Size of input
128 self._output_size = output_size #Size of output
129 self.epochs = 5 #Amount of training iterations
130 self.learning_rate = 1.0 #The step used in gradient descent
131 self.batchsize = 100 #The size of how much data will be used for training per sub iteration
132
133 #Initializing weights and biases as matrices full of zeroes
134 self.w = np.zeros([input_size, output_size], np.float32) #Creates and initializes the weights with 0
135 self.hb = np.zeros([output_size], np.float32) #Creates and initializes the hidden biases with 0
136 self.vb = np.zeros([input_size], np.float32) #Creates and initializes the visible biases with 0
137
138
139 #Fits the result from the weighted visible layer plus the bias into a sigmoid curve
140 def prob_h_given_v(self, visible, w, hb):
141 #Sigmoid
142 return tf.nn.sigmoid(tf.matmul(visible, w) + hb)
143
144 #Fits the result from the weighted hidden layer plus the bias into a sigmoid curve
145 def prob_v_given_h(self, hidden, w, vb):
146 return tf.nn.sigmoid(tf.matmul(hidden, tf.transpose(w)) + vb)
147
148 #Generate the sample probability
149 def sample_prob(self, probs):
150 return tf.nn.relu(tf.sign(probs - tf.random_uniform(tf.shape(probs))))
151
152 #Training method for the model
153 def train(self, X):
154 #Create the placeholders for our parameters
155 _w = tf.placeholder("float", [self._input_size, self._output_size])
156 _hb = tf.placeholder("float", [self._output_size])
157 _vb = tf.placeholder("float", [self._input_size])
158
159 prv_w = np.zeros([self._input_size, self._output_size], np.float32) #Creates and initializes the weights with 0
160 prv_hb = np.zeros([self._output_size], np.float32) #Creates and initializes the hidden biases with 0
161 prv_vb = np.zeros([self._input_size], np.float32) #Creates and initializes the visible biases with 0
162
163 print("_w",_w.shape)
164 print("_hb",_hb.shape)
165 print("_vb",_vb.shape)
166 print("prv_w", prv_w.shape)
167 print("prv_hb", prv_hb.shape)
168 print("prv_vb", prv_vb.shape)
169
170
171 cur_w = np.zeros([self._input_size, self._output_size], np.float32)
172 cur_hb = np.zeros([self._output_size], np.float32)
173 cur_vb = np.zeros([self._input_size], np.float32)
174 v0 = tf.placeholder("float", [None, self._input_size])
175
176 #Initialize with sample probabilities
177 h0 = self.sample_prob(self.prob_h_given_v(v0, _w, _hb))
178 v1 = self.sample_prob(self.prob_v_given_h(h0, _w, _vb))
179 h1 = self.prob_h_given_v(v1, _w, _hb)
180
181 #Create the Gradients
182 positive_grad = tf.matmul(tf.transpose(v0), h0)
183 negative_grad = tf.matmul(tf.transpose(v1), h1)
184
185 #Update learning rates for the layers
186 update_w = _w + self.learning_rate *(positive_grad - negative_grad) / tf.to_float(tf.shape(v0)[0])
187 update_vb = _vb + self.learning_rate * tf.reduce_mean(v0 - v1, 0)
188 update_hb = _hb + self.learning_rate * tf.reduce_mean(h0 - h1, 0)
189
190 #Find the error rate
191 err = tf.reduce_mean(tf.square(v0 - v1))
192
193 #Training loop
194 with tf.Session() as sess:
195 sess.run(tf.initialize_all_variables())
196 #For each epoch
197 for epoch in range(self.epochs):
198 #For each step/batch
199 for start, end in zip(range(0, len(X), self.batchsize),range(self.batchsize,len(X), self.batchsize)):
200 batch = X[start:end]
201
202 #Update the rates
203 cur_w = sess.run(update_w, feed_dict={v0: batch, _w: prv_w, _hb: prv_hb, _vb: prv_vb})
204 cur_hb = sess.run(update_hb, feed_dict={v0: batch, _w: prv_w, _hb: prv_hb, _vb: prv_vb})
205 cur_vb = sess.run(update_vb, feed_dict={v0: batch, _w: prv_w, _hb: prv_hb, _vb: prv_vb})
206 prv_w = cur_w
207 prv_hb = cur_hb
208 prv_vb = cur_vb
209 error=sess.run(err, feed_dict={v0: X, _w: cur_w, _vb: cur_vb, _hb: cur_hb})
210 print('Epoch: %d' % epoch,'reconstruction error: %f' % error)
211 self.w = prv_w
212 self.hb = prv_hb
213 self.vb = prv_vb
214
215 #Create expected output for our DBN
216 def rbm_outpt(self, X):
217 input_X = tf.constant(X)
218 _w = tf.constant(self.w)
219 _hb = tf.constant(self.hb)
220 out = tf.nn.sigmoid(tf.matmul(input_X, _w) + _hb)
221 with tf.Session() as sess:
222 sess.run(tf.global_variables_initializer())
223 return sess.run(out)
224
225 #建立DBN
226
227 RBM_hidden_sizes = [500, 200 , 50 ] #create 2 layers of RBM with size 400 and 100
228
229 #Since we are training, set input as training data
230 inpX = trX
231
232 #Create list to hold our RBMs
233 rbm_list = []
234
235 #Size of inputs is the number of inputs in the training set
236 print("AAAA")
237 print(inpX.shape)
238 input_size = inpX.shape[1]
239
240 #For each RBM we want to generate
241 for i, size in enumerate(RBM_hidden_sizes):
242 print('RBM: ',i,' ',input_size,'->', size)
243 rbm_list.append(RBM(input_size, size))
244 input_size = size
245
246
247
248
249 #神經網絡
250
251 class NN(object):
252
253 def __init__(self, sizes, X, Y):
254 #Initialize hyperparameters
255 self._sizes = sizes
256 self._X = X
257 self._Y = Y
258 self.w_list = []
259 self.b_list = []
260 self._learning_rate = 1.0
261 self._momentum = 0.0
262 self._epoches = 10
263 self._batchsize = 100
264 input_size = X.shape[1]
265
266 #initialization loop
267 for size in self._sizes + [Y.shape[1]]:
268 #Define upper limit for the uniform distribution range
269 max_range = 4 * math.sqrt(6. / (input_size + size))
270
271 #Initialize weights through a random uniform distribution
272 self.w_list.append(
273 np.random.uniform( -max_range, max_range, [input_size, size]).astype(np.float32))
274
275 #Initialize bias as zeroes
276 self.b_list.append(np.zeros([size], np.float32))
277 input_size = size
278
279 #load data from rbm
280 def load_from_rbms(self, dbn_sizes,rbm_list):
281 #Check if expected sizes are correct
282 assert len(dbn_sizes) == len(self._sizes)
283
284 for i in range(len(self._sizes)):
285 #Check if for each RBN the expected sizes are correct
286 assert dbn_sizes[i] == self._sizes[i]
287
288 #If everything is correct, bring over the weights and biases
289 for i in range(len(self._sizes)):
290 self.w_list[i] = rbm_list[i].w
291 self.b_list[i] = rbm_list[i].hb
292
293 #Training method
294 def train(self):
295 #Create placeholders for input, weights, biases, output
296 _a = [None] * (len(self._sizes) + 2)
297 _w = [None] * (len(self._sizes) + 1)
298 _b = [None] * (len(self._sizes) + 1)
299 _a[0] = tf.placeholder("float", [None, self._X.shape[1]])
300 y = tf.placeholder("float", [None, self._Y.shape[1]])
301 print("AAAAAA")
302 print(self._X.shape[1])
303 print(self._Y.shape[1])
304 #Define variables and activation functoin
305 for i in range(len(self._sizes) + 1):
306 _w[i] = tf.Variable(self.w_list[i])
307 _b[i] = tf.Variable(self.b_list[i])
308 for i in range(1, len(self._sizes) + 2):
309 _a[i] = tf.nn.sigmoid(tf.matmul(_a[i - 1], _w[i - 1]) + _b[i - 1])
310
311 #Define the cost function
312 cost = tf.reduce_mean(tf.square(_a[-1] - y))
313
314 #Define the training operation (Momentum Optimizer minimizing the Cost function)
315 train_op = tf.train.MomentumOptimizer(
316 self._learning_rate, self._momentum).minimize(cost)
317
318 #Prediction operation
319 predict_op = tf.argmax(_a[-1], 1)
320
321 #Training Loop
322 with tf.Session() as sess:
323 #Initialize Variables
324 sess.run(tf.global_variables_initializer())
325
326 #For each epoch
327 for i in range(self._epoches):
328
329 #For each step
330 for start, end in zip(
331 range(0, len(self._X), self._batchsize), range(self._batchsize, len(self._X), self._batchsize)):
332
333 #Run the training operation on the input data
334 sess.run(train_op, feed_dict={
335 _a[0]: self._X[start:end], y: self._Y[start:end]})
336 for j in range(len(self._sizes) + 1):
337 #Retrieve weights and biases
338 self.w_list[j] = sess.run(_w[j])
339 self.b_list[j] = sess.run(_b[j])
340
341 print("Accuracy rating for epoch " + str(i) + ": " + str(np.mean(np.argmax(self._Y, axis=1) ==
342 sess.run(predict_op, feed_dict={_a[0]: self._X, y: self._Y}))))
343
344
345 if __name__ =='__main__':
346 ##訓練資料集
347 # For each RBM in our list
348 for rbm in rbm_list:
349 print('New RBM:')
350 # Train a new one
351 rbm.train(inpX)
352 # Return the output layer
353 inpX = rbm.rbm_outpt(inpX)
354
355 print("正在訓練。。。。。。")
356 nNet = NN(RBM_hidden_sizes, trX, trY)
357 nNet.load_from_rbms(RBM_hidden_sizes, rbm_list)
358 nNet.train()