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 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()
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()
