def train(): # load the data dataset_path = "D://_Dataset//MNIST//mnist.pkl" # Load the dataset f = open(dataset_path, 'rb') train_set, valid_set, test_set = pickle.load(f) f.close() del f img_dim = 28 net = NeuralNet( layers=[ ('input', layers.InputLayer), ('conv1', Conv2DLayer), ('pool1', MaxPool2DLayer), ('dropout1', layers.DropoutLayer), ('conv2', Conv2DLayer), ('pool2', MaxPool2DLayer), ('dropout2', layers.DropoutLayer), ('conv3', Conv2DLayer), ('pool3', MaxPool2DLayer), ('dropout3', layers.DropoutLayer), ('hidden4', layers.DenseLayer), ('dropout4', layers.DropoutLayer), ('hidden5', layers.DenseLayer), ('output', layers.DenseLayer), ], input_shape=(None, 1, img_dim, img_dim), conv1_num_filters=32, conv1_filter_size=(3, 3), pool1_pool_size=(2, 2), dropout1_p=0.1, conv2_num_filters=64, conv2_filter_size=(2, 2), pool2_pool_size=(2, 2), dropout2_p=0.2, conv3_num_filters=128, conv3_filter_size=(2, 2), pool3_pool_size=(2, 2), dropout3_p=0.3, hidden4_num_units=1000, dropout4_p=0.5, hidden5_num_units=1000, output_num_units=1, output_nonlinearity=None, update_learning_rate=theano.shared(float32(0.03)), update_momentum=theano.shared(float32(0.9)), regression=True, batch_iterator_train=BatchIterator(batch_size=128), on_epoch_finished=[ AdjustVariable('update_learning_rate', start=0.03, stop=0.0001), AdjustVariable('update_momentum', start=0.9, stop=0.999), EarlyStopping(patience=200), ], max_epochs=3000, verbose=1, ) net net.get_all_layers()
new_im = Image.new('L', new_size) new_im.paste(original_image, (0, 0)) rec_image = Image.fromarray(get_picture_array(X_pred, index)) new_im.paste(rec_image, (original_image.size[0], 0)) new_im.save('data/test.png', format="PNG") get_random_images() IPImage('data/test.png') # <codecell> ## we find the encode layer from our ae, and use it to define an encoding function encode_layer_index = map(lambda pair: pair[0], ae.layers).index('encode_layer') encode_layer = ae.get_all_layers()[encode_layer_index] def get_output_from_nn(last_layer, X): indices = np.arange(128, X.shape[0], 128) sys.stdout.flush() # not splitting into batches can cause a memory error X_batches = np.split(X, indices) out = [] for count, X_batch in enumerate(X_batches): out.append(layers.helper.get_output(last_layer, X_batch).eval()) sys.stdout.flush() return np.vstack(out)
new_size = (original_image.size[0] * 2, original_image.size[1]) new_im = Image.new('L', new_size) new_im.paste(original_image, (0,0)) rec_image = Image.fromarray(get_picture_array(X_pred, index)) new_im.paste(rec_image, (original_image.size[0],0)) new_im.save('data/test.png', format="PNG") get_random_images() IPImage('data/test.png') ## we find the encode layer from our ae, and use it to define an encoding function encode_layer_index = map(lambda pair : pair[0], ae.layers).index('encode_layer') encode_layer = ae.get_all_layers()[encode_layer_index] def get_output_from_nn(last_layer, X): indices = np.arange(128, X.shape[0], 128) sys.stdout.flush() # not splitting into batches can cause a memory error X_batches = np.split(X, indices) out = [] for count, X_batch in enumerate(X_batches): #out.append(last_layer.get_output_for (X_batch).eval()) out.append(lasagne.layers.get_output(last_layer, X_batch).eval()) sys.stdout.flush() return np.vstack(out)
def main(): # load data set fname = 'mnist/mnist.pkl.gz' if not os.path.isfile(fname): testfile = urllib.URLopener() testfile.retrieve("http://deeplearning.net/data/mnist/mnist.pkl.gz", fname) f = gzip.open(fname, 'rb') train_set, valid_set, test_set = cPickle.load(f) f.close() X, y = train_set X = np.rint(X * 256).astype(np.int).reshape((-1, 1, 28, 28)) # convert to (0,255) int range (we'll do our own scaling) mu, sigma = np.mean(X.flatten()), np.std(X.flatten()) X_train = X.astype(np.float64) X_train = (X_train - mu) / sigma X_train = X_train.astype(np.float32) # we need our target to be 1 dimensional X_out = X_train.reshape((X_train.shape[0], -1)) conv_filters = 32 deconv_filters = 32 filter_size = 7 epochs = 20 encode_size = 40 layerParam= [ (layers.InputLayer, {'name': 'input_layer', 'shape': (None, 1, 28, 28)}), (layers.Conv2DLayer, {'name': 'conv', 'num_filters': conv_filters, 'filter_size': (filter_size, filter_size), 'nonlinearity': None}), (layers.MaxPool2DLayer, {'name': 'pool', 'pool_size': (2, 2)}), (layers.ReshapeLayer, {'name': 'flatten', 'shape': (([0], -1))}), (layers.DenseLayer, {'name': 'encode_layer', 'num_units': encode_size}), (layers.DenseLayer, {'name': 'hidden', 'num_units': deconv_filters * (28 +filter_size - 1)**2 /4}), (layers.ReshapeLayer, {'name': 'unflatten', 'shape': (([0], deconv_filters, (28 + filter_size - 1) / 2, (28 + filter_size - 1) / 2 ))}), (Unpool2DLayer, {'name': 'unpool', 'ds': (2, 2)}), (layers.Conv2DLayer, {'name': 'deconv', 'num_filters': 1, 'filter_size': (filter_size, filter_size), 'nonlinearity': None}), (layers.ReshapeLayer, {'name': 'output_layer', 'shape': (([0], -1))}) ] ae = NeuralNet( layers=layerParam, update_learning_rate = 0.01, update_momentum = 0.975, batch_iterator_train=FlipBatchIterator(batch_size=128), regression=True, max_epochs= epochs, verbose=1, ) ae.fit(X_train, X_out) print '---------------train end' print ### expect training / val error of about 0.087 with these parameters ### if your GPU not fast enough, reduce the number of filters in the conv/deconv step # handle the default limitation of pickle sys.setrecursionlimit(10000) pickle.dump(ae, open('mnist/conv_ae.pkl','w')) # ae = pickle.load(open('mnist/conv_ae.pkl','r')) ae.save_params_to('mnist/conv_ae.np') X_train_pred = ae.predict(X_train).reshape(-1, 28, 28) * sigma + mu X_pred = np.rint(X_train_pred).astype(int) X_pred = np.clip(X_pred, a_min = 0, a_max = 255) X_pred = X_pred.astype('uint8') print X_pred.shape , X.shape ### show random inputs / outputs side by side for i in range(0, 10): get_random_images(X, X_pred, i) return ## we find the encode layer from our ae, and use it to define an encoding function encode_layer_index = map(lambda pair : pair[0], ae.layers).index('encode_layer') print '----------encode_layer_index:', encode_layer_index encode_layer = ae.get_all_layers()[encode_layer_index] def get_output_from_nn(last_layer, X): indices = np.arange(128, X.shape[0], 128) sys.stdout.flush() # not splitting into batches can cause a memory error X_batches = np.split(X, indices) out = [] for count, X_batch in enumerate(X_batches): out.append(layers.get_output(last_layer, X_batch).eval()) sys.stdout.flush() return np.vstack(out) def encode_input(X): return get_output_from_nn(encode_layer, X) X_encoded = encode_input(X_train) next_layer = ae.get_all_layers()[encode_layer_index + 1] final_layer = ae.get_all_layers()[-1] new_layer = layers.InputLayer(shape = (None, encode_layer.num_units)) # N.B after we do this, we won't be able to use the original autoencoder , as the layers are broken up next_layer.input_layer = new_layer def decode_encoded_input(X): return get_output_from_nn(final_layer, X) X_decoded = decode_encoded_input(X_encoded) * sigma + mu X_decoded = np.rint(X_decoded ).astype(int) X_decoded = np.clip(X_decoded, a_min = 0, a_max = 255) X_decoded = X_decoded.astype('uint8') print X_decoded.shape ### check it worked : for i in range(10): pic_array = get_picture_array(X_decoded, np.random.randint(len(X_decoded))) image = Image.fromarray(pic_array) image.save('data/t_' + str(i) + '.png', format="PNG") return
class ConvAE(): """ A convolutional autoencoder (CAE) constructor inputs ====== X_in: np.ndarray The sample matrix, whose size is (s,d,r,c). s: number of samples, d: dimensions r: rows, c: cols X_out: np.ndarray It usually equals to X_in. kernel_size: list Box sizes of the kernels in each ConvLayer kernel_num: list Number of kernels in each ConvLayer pool_flag: list of bool values Flags of pooling layer w.r.t. to the ConvLayer fc_nodes: list The dense layers after the full connected layer of last ConvLayer or pooling layer. encode_nodes: int Number of nodes in the final encoded layer methods ======= gen_layers: construct the layers gen_encoder: generate the encoder gen_decoder: generate the decoder cae_build: build the cae network cae_train: train the cae network cae_eval: evaluate the cae network cae_save: save the network """ def __init__(self, X_in, X_out, kernel_size=[3, 5, 3], kernel_num=[12, 12, 24], pool_flag=[True, True, True], fc_nodes=[128], encode_nodes=16, droprate=0.5, dropflag=True): """ The initializer """ self.X_in = X_in self.X_out = X_out self.kernel_size = kernel_size self.kernel_num = kernel_num self.pool_flag = pool_flag self.pool_size = 2 self.fc_nodes = fc_nodes self.encode_nodes = encode_nodes self.droprate = droprate self.dropflag = dropflag def gen_BatchIterator(self, batch_size=100): """Generate the batch iterator""" B = BatchIterator(batch_size=batch_size, shuffle=True) return B def gen_layers(self): """Construct the layers""" # Init <TODO> pad_in = 'valid' pad_out = 'full' self.layers = [] # input layer l_input = (InputLayer, { 'shape': (None, self.X_in.shape[1], self.X_in.shape[2], self.X_in.shape[3]) }) self.layers.append(l_input) # Encoder: Conv and pool layers rows, cols = self.X_in.shape[2:] for i in range(len(self.kernel_size)): # conv l_en_conv = (Conv2DLayer, { 'num_filters': self.kernel_num[i], 'filter_size': self.kernel_size[i], 'nonlinearity': lasagne.nonlinearities.rectify, 'W': lasagne.init.GlorotUniform(), 'b': lasagne.init.Constant(0.), 'pad': pad_in }) self.layers.append(l_en_conv) rows = rows - self.kernel_size[i] + 1 cols = cols - self.kernel_size[i] + 1 # pool if self.pool_flag[i]: l_en_pool = (MaxPool2DLayer, {'pool_size': self.pool_size}) self.layers.append(l_en_pool) rows = rows // 2 cols = cols // 2 # drop if not self.dropflag: self.droprate = 0 l_drop = (DropoutLayer, {'p': self.droprate}) # full connected layer num_en_fc = rows * cols * self.kernel_num[-1] l_en_fc = (ReshapeLayer, {'shape': (([0], -1))}) self.layers.append(l_en_fc) self.layers.append(l_drop) # dense for i in range(len(self.fc_nodes)): l_en_dense = (DenseLayer, { 'num_units': self.fc_nodes[i], 'nonlinearity': lasagne.nonlinearities.rectify, 'W': lasagne.init.GlorotUniform(), 'b': lasagne.init.Constant(0.) }) self.layers.append(l_en_dense) self.layers.append(l_drop) # encoder layer l_en = (DenseLayer, { 'name': 'encode', 'num_units': self.encode_nodes, 'nonlinearity': lasagne.nonlinearities.rectify, 'W': lasagne.init.GlorotUniform(), 'b': lasagne.init.Constant(0.) }) self.layers.append(l_en) self.layers.append(l_drop) # Decoder: reverse # dense for i in range(len(self.fc_nodes) - 1, -1, -1): l_de_dense = (DenseLayer, { 'num_units': self.fc_nodes[i], 'nonlinearity': lasagne.nonlinearities.rectify, 'W': lasagne.init.GlorotUniform(), 'b': lasagne.init.Constant(0.) }) self.layers.append(l_de_dense) self.layers.append(l_drop) # fc l_de_fc = (DenseLayer, { 'num_units': num_en_fc, 'nonlinearity': lasagne.nonlinearities.rectify, 'W': lasagne.init.GlorotUniform(), 'b': lasagne.init.Constant(0.) }) self.layers.append(l_de_fc) self.layers.append(l_drop) # fc to kernels l_de_fc_m = (ReshapeLayer, { 'shape': (([0], self.kernel_num[-1], rows, cols)) }) self.layers.append(l_de_fc_m) # Conv and pool for i in range(len(self.kernel_size) - 1, -1, -1): # pool if self.pool_flag[i]: l_de_pool = (Upscale2DLayer, {'scale_factor': self.pool_size}) self.layers.append(l_de_pool) # conv if i > 0: l_de_conv = (Conv2DLayer, { 'num_filters': self.kernel_num[i], 'filter_size': self.kernel_size[i], 'nonlinearity': lasagne.nonlinearities.rectify, 'W': lasagne.init.GlorotUniform(), 'b': lasagne.init.Constant(0.), 'pad': pad_out }) else: l_de_conv = (Conv2DLayer, { 'num_filters': 1, 'filter_size': self.kernel_size[i], 'nonlinearity': lasagne.nonlinearities.rectify, 'W': lasagne.init.GlorotUniform(), 'b': lasagne.init.Constant(0.), 'pad': pad_out }) self.layers.append(l_de_conv) # output self.layers.append((ReshapeLayer, {'shape': (([0], -1))})) def cae_build(self, max_epochs=20, batch_size=100, learning_rate=0.001, momentum=0.9, verbose=1): """Build the network""" if batch_size is None: self.cae = NeuralNet(layers=self.layers, max_epochs=max_epochs, update=lasagne.updates.nesterov_momentum, update_learning_rate=learning_rate, update_momentum=momentum, regression=True, verbose=verbose) else: # batch iterator batch_iterator = self.gen_BatchIterator(batch_size=batch_size) self.cae = NeuralNet(layers=self.layers, batch_iterator_train=batch_iterator, max_epochs=max_epochs, update=lasagne.updates.nesterov_momentum, update_learning_rate=learning_rate, update_momentum=momentum, regression=True, verbose=verbose) def cae_train(self): """Train the cae net""" print("Training the network...") self.cae.fit(self.X_in, self.X_out) print("Training done.") def cae_eval(self): """Draw evaluation lines <TODO> """ from nolearn.lasagne.visualize import plot_loss plot_loss(self.cae) def cae_predict(self, img): """ Predict the output of the input image input ===== img: np.ndarray The image matrix, (r,c) output ====== img_pred: np.ndarray The predicted image matrix """ if len(img.shape) == 4: rows = img.shape[2] cols = img.shape[3] elif len(img.shape) == 3: rows = img.shape[1] cols = img.shape[2] img = img.reshape(img.shape[0], 1, rows, cols) elif len(img.shape) == 2: rows, cols = img.shape img = img.reshape(1, 1, rows, cols) else: print("The shape of image should be 2 or 3 d") img_pred = self.cae.precidt(img).reshape(-1, rows, cols) return img_pred def get_encode(self, img): """Encode or compress on the sample input ===== img: np.ndarray The sample matrix output ====== img_en: np.ndarray The encoded matrix """ if len(img.shape) == 4: rows = img.shape[2] cols = img.shape[3] elif len(img.shape) == 3: rows = img.shape[1] cols = img.shape[2] img = img.reshape(img.shape[0], 1, rows, cols) elif len(img.shape) == 2: rows, cols = img.shape img = img.reshape(1, 1, rows, cols) else: print("The shape of image should be 2 or 3 d") def get_layer_by_name(net, name): for i, layer in enumerate(net.get_all_layers()): if layer.name == name: return layer, i return None, None encode_layer, encode_layer_index = get_layer_by_name( self.cae, 'encode') img_en = get_output(encode_layer, inputs=img).eval() return img_en def get_decode(self, img_en): """Decode to output the recovered image input ===== img_en: np.ndarray The encoded matrix output ====== img_de: np.ndarray The recovered or predicted image matrix """ def get_layer_by_name(net, name): for i, layer in enumerate(net.get_all_layers()): if layer.name == name: return layer, i return None, None encode_layer, encode_layer_index = get_layer_by_name( self.cae, 'encode') # decoder new_input = InputLayer(shape=(None, encode_layer.num_units)) layer_de_input = self.cae.get_all_layers()[encode_layer_index + 1] layer_de_input.input_layer = new_input layer_de_output = self.cae.get_all_layers()[-1] img_en = get_output(layer_de_output, img_en).eval() return img_en def cae_save(self, savepath='cae.pkl'): """Save the trained network input ===== savepath: str Path of the net to be saved """ import pickle try: fp = open(savepath, 'wb') except FileNotFoundError: import os os.system("touch %s" % savepath) fp = open(savepath, 'wb') # write pickle.dump(self.cae, fp) fp.close()
def createSAE(input_height, input_width, X_train, X_out): encode_size = 200 cnn1 = NeuralNet(layers=[ ('input', layers.InputLayer), ('hidden', layers.DenseLayer), ('hiddenOut', layers.DenseLayer), ('output_layer', ReshapeLayer), ], input_shape=(None, 1, input_width, input_height), hidden_num_units= 10000, hiddenOut_num_units= 42000, output_layer_shape = (([0], -1)), update_learning_rate=learning_rate, update_momentum=update_momentum, update=nesterov_momentum, train_split=TrainSplit(eval_size=train_valid_split), # batch_iterator_train=BatchIterator(batch_size=batch_size), batch_iterator_train=FlipBatchIterator(batch_size=batch_size), regression=True, max_epochs=epochs, verbose=1, hiddenLayer_to_output=-3) cnn1.fit(X_train, X_out) trian_last_hiddenLayer = cnn1.output_hiddenLayer(X_train) test_last_hiddenLayer = cnn1.output_hiddenLayer(test_x) cnn2 = NeuralNet(layers=[ ('input', layers.InputLayer), ('hidden', layers.DenseLayer), ('output_layer', layers.DenseLayer), ], input_shape=(None,10000), hidden_num_units= 3000, output_layer_num_units = 10000, update_learning_rate=learning_rate, update_momentum=update_momentum, update=nesterov_momentum, train_split=TrainSplit(eval_size=train_valid_split), batch_iterator_train=BatchIterator(batch_size=batch_size), # batch_iterator_train=FlipBatchIterator(batch_size=batch_size), regression=True, max_epochs=epochs, verbose=1, hiddenLayer_to_output=-2) trian_last_hiddenLayer = trian_last_hiddenLayer.astype(np.float32) cnn2.fit(trian_last_hiddenLayer, trian_last_hiddenLayer) trian_last_hiddenLayer = cnn2.output_hiddenLayer(trian_last_hiddenLayer) test_last_hiddenLayer = cnn2.output_hiddenLayer(test_last_hiddenLayer) cnn3 = NeuralNet(layers=[ ('input', layers.InputLayer), ('hidden', layers.DenseLayer), ('output_layer', layers.DenseLayer), ], input_shape=(None,3000), hidden_num_units= 1000, output_layer_num_units = 3000, update_learning_rate=learning_rate, update_momentum=update_momentum, update=nesterov_momentum, train_split=TrainSplit(eval_size=train_valid_split), batch_iterator_train=BatchIterator(batch_size=batch_size), # batch_iterator_train=FlipBatchIterator(batch_size=batch_size), regression=True, max_epochs=epochs, verbose=1, hiddenLayer_to_output=-2) trian_last_hiddenLayer = trian_last_hiddenLayer.astype(np.float32) cnn3.fit(trian_last_hiddenLayer, trian_last_hiddenLayer) trian_last_hiddenLayer = cnn3.output_hiddenLayer(trian_last_hiddenLayer) test_last_hiddenLayer = cnn3.output_hiddenLayer(test_last_hiddenLayer) cnn4 = NeuralNet(layers=[ ('input', layers.InputLayer), ('hidden', layers.DenseLayer), ('output_layer', layers.DenseLayer), ], input_shape=(None,1000), hidden_num_units= 300, output_layer_num_units = 1000, update_learning_rate=learning_rate, update_momentum=update_momentum, update=nesterov_momentum, train_split=TrainSplit(eval_size=train_valid_split), batch_iterator_train=BatchIterator(batch_size=batch_size), # batch_iterator_train=FlipBatchIterator(batch_size=batch_size), regression=True, max_epochs=epochs, verbose=1, hiddenLayer_to_output=-2) trian_last_hiddenLayer = trian_last_hiddenLayer.astype(np.float32) cnn4.fit(trian_last_hiddenLayer, trian_last_hiddenLayer) trian_last_hiddenLayer = cnn4.output_hiddenLayer(trian_last_hiddenLayer) test_last_hiddenLayer = cnn4.output_hiddenLayer(test_last_hiddenLayer) input_layer = cnn1.get_all_layers()[0] hidden1_layer = cnn1.get_all_layers()[1] hidden1_layer.input_layer = input_layer hidden2_layer = cnn2.get_all_layers()[1] hidden2_layer.input_layer = hidden1_layer hidden3_layer = cnn3.get_all_layers()[1] hidden3_layer.input_layer = hidden2_layer final_layer = cnn4.get_all_layers()[1] final_layer.input_layer = hidden3_layer # out_train = final_layer.get_output(x_train).eval() # out_test = final_layer.get_output(test_x).eval() f = gzip.open(folder_path + "output.pkl.gz",'wb') cPickle.dump((trian_last_hiddenLayer, test_last_hiddenLayer), f, protocol=2) f.close() # f = gzip.open("pickled_images/tmp.pkl.gz", 'rb') # trian_last_hiddenLayer, test_last_hiddenLayer = cPickle.load(f) # f.close() return cnn1
class ConvNet(): """ A convolutional neural network (CNN) constructor inputs ====== X_in: np.ndarray The sample matrix, whose size is (s,d,r,c). s: number of samples, d: dimensions r: rows, c: cols X_out: np.ndarray The corresponding label (category) of the X_in. kernel_size: list Box sizes of the kernels in each ConvLayer kernel_num: list Number of kernels in each ConvLayer pool_flag: list of bool values Flags of pooling layer w.r.t. to the ConvLayer fc_nodes: list The dense layers after the full connected layer of last ConvLayer or pooling layer. methods ======= gen_layers: construct the layers cnn_build: build the cnn network cnn_train: train the cnn network cnn_eval: evaluate the cnn network cnn_save: save the network """ def __init__(self, X_in=None, X_out=None, numclass=3, stride=(1, 1), pad='valid', kernel_size=[2, 3, 4], kernel_num=[15, 15, 15], pool_flag=[False, False, False], fc_nodes=None, droprate=0.5, dropflag=True): """ The initializer """ self.X_in = X_in self.X_out = X_out self.numclass = numclass self.stride = stride self.pad = pad self.kernel_size = kernel_size self.kernel_num = kernel_num self.pool_flag = pool_flag self.pool_size = 2 self.fc_nodes = fc_nodes self.droprate = droprate self.dropflag = dropflag def gen_BatchIterator(self, batch_size=100, shuffle=True): """Generate the batch iterator""" B = BatchIterator(batch_size=batch_size, shuffle=shuffle) return B def gen_layers(self): """Construct the layers""" # Init <TODO> self.layers = [] # input layer l_input = (InputLayer, { 'shape': (None, self.X_in.shape[1], self.X_in.shape[2], self.X_in.shape[3]) }) self.layers.append(l_input) # Conv and pool layers rows, cols = self.X_in.shape[2:] for i in range(len(self.kernel_size)): # conv l_conv = ( Conv2DLayer, { 'num_filters': self.kernel_num[i], 'filter_size': self.kernel_size[i], 'stride': self.stride, 'nonlinearity': lasagne.nonlinearities.rectify, 'W': lasagne.init.GlorotUniform(), #'b': lasagne.init.Constant(0.), 'pad': self.pad }) self.layers.append(l_conv) if self.pad == 'valid': rows = (rows - self.kernel_size[i] + 1) // self.stride[0] cols = (cols - self.kernel_size[i] + 1) // self.stride[1] elif self.pad == 'same': rows = rows // self.stride[0] cols = cols // self.stride[1] elif self.pad == 'full': rows = (rows + self.kernel_size[i] - 1) // self.stride[0] cols = (cols + self.kernel_size[i] - 1) // self.stride[1] print(rows) print(cols) # pool if self.pool_flag[i]: l_pool = (MaxPool2DLayer, {'pool_size': self.pool_size}) self.layers.append(l_pool) rows = rows // 2 cols = cols // 2 # print(rows) # print(cols) # dropout if not self.dropflag: self.droprate = 0 l_drop = (DropoutLayer, {'p': self.droprate}) # self.layers.append(l_drop) # full connected layer num_fc = rows * cols * self.kernel_num[-1] l_fc = (DenseLayer, { 'num_units': num_fc, 'nonlinearity': lasagne.nonlinearities.rectify, 'W': lasagne.init.GlorotUniform(), 'b': lasagne.init.Constant(0.) }) self.layers.append(l_fc) # dense if not self.fc_nodes is None: for i in range(len(self.fc_nodes)): self.layers.append(l_drop) l_dense = (DenseLayer, {'num_units': self.fc_nodes[i]}) self.layers.append(l_dense) # output layer self.layers.append(l_drop) l_out = (DenseLayer, { 'name': 'output', 'num_units': self.numclass, 'nonlinearity': lasagne.nonlinearities.softmax }) self.layers.append(l_out) def cnn_build(self, max_epochs=20, batch_size=100, learning_rate=0.001, momentum=None, verbose=1, loss="adam"): """Build the network""" if loss == "adam": update = lasagne.updates.adam else: update = lasagne.updates.nesterov_momentum if batch_size is None: self.net = NeuralNet( layers=self.layers, max_epochs=max_epochs, update=update, # update_momentum=momentum, update_learning_rate=learning_rate, regression=False, verbose=verbose) else: # batch iterator batch_iterator = self.gen_BatchIterator(batch_size=batch_size) self.net = NeuralNet( layers=self.layers, batch_iterator_train=batch_iterator, max_epochs=max_epochs, update=update, # update_momentum=momentum, update_learning_rate=learning_rate, regression=False, verbose=verbose) def cnn_train(self): """Train the cae net""" print("Training the network...") self.net.fit(self.X_in, self.X_out) print("Training done.") def cnn_eval(self): """Draw evaluation lines <TODO> """ from nolearn.lasagne.visualize import plot_loss plot_loss(self.net) def cnn_predict(self, img): """ Predict the output of the input image input ===== img: np.ndarray The image matrix, (r,c) output ====== label_pred: np.ndarray The predicted image matrix """ if len(img.shape) == 4: rows = img.shape[2] cols = img.shape[3] elif len(img.shape) == 3: rows = img.shape[1] cols = img.shape[2] img = img.reshape(img.shape[0], 1, rows, cols) elif len(img.shape) == 2: rows, cols = img.shape img = img.reshape(1, 1, rows, cols) else: print("The shape of image should be 2 or 3 d") self.dropflag = False label_pred = self.net.predict(img) return label_pred def cnn_encode(self, img): """ Generate the code of the input image input ===== img: np.ndarray The image matrix, (r,c) output ====== code: np.ndarray The code of the img """ if len(img.shape) == 4: rows = img.shape[2] cols = img.shape[3] elif len(img.shape) == 3: rows = img.shape[1] cols = img.shape[2] img = img.reshape(img.shape[0], 1, rows, cols) elif len(img.shape) == 2: rows, cols = img.shape img = img.reshape(1, 1, rows, cols) else: print("The shape of image should be 2 or 3 d") self.dropflag = False encode_layer = self.net.get_all_layers()[-3] code = get_output(encode_layer, inputs=img).eval() return code def cnn_save(self, savepath='cnn.pkl'): """Save the trained network input ===== savepath: str Path of the net to be saved """ import sys sys.setrecursionlimit(1000000) import pickle fp = open(savepath, 'wb') # write pickle.dump(self.net, fp) fp.close()