def loadModel(imageArray,validSet, learning_rate=0.1, n_epochs=1000, nkerns=[16, 512, 20],
batch_size=200, verbose=True):
rng = numpy.random.RandomState(23455)
#datasets = loadData(shared=False)
#train_set_x, train_set_y = datasets[0]
valid_set_x, valid_set_y = validSet
#test_set_x, test_set_y = datasets[2]
valid_set_x[0] = imageArray
valid_set_x, valid_set_y = shared_dataset([valid_set_x, valid_set_y])
# compute number of minibatches for training, validation and testing
n_valid_batches = valid_set_x.get_value(borrow=True).shape[0]
# allocate symbolic variables for the data
index = T.lscalar() # index to a [mini]batch
x = T.matrix('x') # the data is presented as rasterized images
y = T.ivector('y') # the labels are presented as 1D vector of
# [int] labels
######################
# BUILD ACTUAL MODEL #
######################
#Make learning rate a theano shared variable
# Reshape matrix of rasterized images of shape (batch_size, 1 * 48 * 48)
# to a 4D tensor, compatible with our LeNetConvPoolLayer
layer0_input = x.reshape((batch_size, 1, 48, 48))
# TODO: Construct the first convolutional pooling layer:
layer0 = LeNetConvPoolLayer(
rng,
input=layer0_input,
image_shape= (batch_size, 1, 48, 48),
filter_shape= (nkerns[0],1,3,3),
poolsize= (2,2)
)
# TODO: Construct the second convolutional pooling layer
layer1 = LeNetConvPoolLayer(
rng,
input=layer0.output,
image_shape= (batch_size, nkerns[0], 23, 23) ,
filter_shape= (nkerns[1],nkerns[0],4,4),
poolsize= (2,2)
)
# TODO: Construct the third convolutional pooling layer
layer2 = LeNetConvPoolLayer(
rng,
input=layer1.output,
image_shape= (batch_size,nkerns[1],10,10),
filter_shape= (nkerns[2],nkerns[1],3,3),
poolsize= (2,2)
)
# the HiddenLayer being fully-connected, it operates on 2D matrices of
# shape (batch_size, num_pixels) (i.e matrix of rasterized images).
# This will generate a matrix of shape (batch_size, nkerns[2] * 1 * 1).
layer3_input = layer2.output.flatten(2)
# construct a fully-connected sigmoidal layer
layer3 = HiddenLayer(
rng,
input=layer3_input,
n_in=nkerns[2] * 4 * 4,
n_out= batch_size,
activation=T.tanh
)
# classify the values of the fully-connected sigmoidal layer
layer4 = LogisticRegression(input=layer3.output,
n_in= batch_size,
n_out=7)
getPofYGivenX = theano.function(
[index],
layer4.pOfYGivenX(),
givens={
x: valid_set_x[index * batch_size: (index + 1) * batch_size],
y: valid_set_y[index * batch_size: (index + 1) * batch_size]
},
on_unused_input='ignore'
)
#Load the saved parameters
f = open('layer0.W','rb')
layer0.W.set_value(cPickle.load(f))
f.close()
f = open('layer0.b','rb')
layer0.b.set_value(cPickle.load(f))
f.close()
f = open('layer1.W','rb')
layer1.W.set_value(cPickle.load(f))
f.close()
f = open('layer1.b','rb')
layer1.b.set_value(cPickle.load(f))
f.close()
f = open('layer2.W','rb')
layer2.W.set_value(cPickle.load(f))
f.close()
f = open('layer2.b','rb')
layer2.b.set_value(cPickle.load(f))
f.close()
f = open('layer3.W','rb')
layer3.W.set_value(cPickle.load(f))
f.close()
f = open('layer3.b','rb')
layer3.b.set_value(cPickle.load(f))
f.close()
f = open('layer4.W','rb')
layer4.W.set_value(cPickle.load(f))
f.close()
f = open('layer4.b','rb')
layer4.b.set_value(cPickle.load(f))
f.close()
predictedList = getPofYGivenX(0)
predictedMoods = predictedList[0].tolist()
return [predictedMoods.index(max(predictedMoods)),max(predictedMoods)]
def test_emotionTraining(learning_rate=0.1, n_epochs=1000, nkerns=[16, 512, 20],
batch_size=200, verbose=True):
"""
Wrapper function for testing Multi-Stage ConvNet on SVHN dataset
:type learning_rate: float
:param learning_rate: learning rate used (factor for the stochastic
gradient)
:type n_epochs: int
:param n_epochs: maximal number of epochs to run the optimizer
:type nkerns: list of ints
:param nkerns: number of kernels on each layer
:type batch_size: int
:param batch_szie: number of examples in minibatch.
:type verbose: boolean
:param verbose: to print out epoch summary or not to.
"""
rng = numpy.random.RandomState(23455)
datasets = loadData()
train_set_x, train_set_y = datasets[0]
valid_set_x, valid_set_y = datasets[1]
test_set_x, test_set_y = datasets[2]
# compute number of minibatches for training, validation and testing
n_train_batches = train_set_x.get_value(borrow=True).shape[0]
n_valid_batches = valid_set_x.get_value(borrow=True).shape[0]
n_test_batches = test_set_x.get_value(borrow=True).shape[0]
n_train_batches //= batch_size
n_valid_batches //= batch_size
n_test_batches //= batch_size
# allocate symbolic variables for the data
index = T.lscalar() # index to a [mini]batch
x = T.matrix('x') # the data is presented as rasterized images
y = T.ivector('y') # the labels are presented as 1D vector of
# [int] labels
######################
# BUILD ACTUAL MODEL #
######################
#Make learning rate a theano shared variable
learning_rate = theano.shared(learning_rate)
print('... building the model')
# Reshape matrix of rasterized images of shape (batch_size, 1 * 48 * 48)
# to a 4D tensor, compatible with our LeNetConvPoolLayer
layer0_input = x.reshape((batch_size, 1, 48, 48))
# TODO: Construct the first convolutional pooling layer:
layer0 = LeNetConvPoolLayer(
rng,
input=layer0_input,
image_shape= (batch_size, 1, 48, 48),
filter_shape= (nkerns[0],1,3,3),
poolsize= (2,2)
)
# TODO: Construct the second convolutional pooling layer
layer1 = LeNetConvPoolLayer(
rng,
input=layer0.output,
image_shape= (batch_size, nkerns[0], 23, 23) ,
filter_shape= (nkerns[1],nkerns[0],4,4),
poolsize= (2,2)
)
# TODO: Construct the third convolutional pooling layer
layer2 = LeNetConvPoolLayer(
rng,
input=layer1.output,
image_shape= (batch_size,nkerns[1],10,10),
filter_shape= (nkerns[2],nkerns[1],3,3),
poolsize= (2,2)
)
# the HiddenLayer being fully-connected, it operates on 2D matrices of
# shape (batch_size, num_pixels) (i.e matrix of rasterized images).
# This will generate a matrix of shape (batch_size, nkerns[2] * 1 * 1).
layer3_input = layer2.output.flatten(2)
# construct a fully-connected sigmoidal layer
layer3 = HiddenLayer(
rng,
input=layer3_input,
n_in=nkerns[2] * 4 * 4,
n_out= batch_size,
activation=T.tanh
)
# classify the values of the fully-connected sigmoidal layer
layer4 = LogisticRegression(input=layer3.output,
n_in= batch_size,
n_out=7)
# the cost we minimize during training is the NLL of the model
cost = layer4.negative_log_likelihood(y)
# create a function to compute the mistakes that are made by the model
test_model = theano.function(
[index],
layer4.errors(y),
givens={
x: test_set_x[index * batch_size: (index + 1) * batch_size],
y: test_set_y[index * batch_size: (index + 1) * batch_size]
}
)
validate_model = theano.function(
[index],
layer4.errors(y),
givens={
x: valid_set_x[index * batch_size: (index + 1) * batch_size],
y: valid_set_y[index * batch_size: (index + 1) * batch_size]
}
)
# TODO: create a list of all model parameters to be fit by gradient descent
params = layer0.params + layer1.params + layer2.params + layer3.params + layer4.params
# create a list of gradients for all model parameters
grads = T.grad(cost, params)
# train_model is a function that updates the model parameters by
# SGD Since this model has many parameters, it would be tedious to
# manually create an update rule for each model parameter. We thus
# create the updates list by automatically looping over all
# (params[i], grads[i]) pairs.
updates = [
(param_i, param_i - learning_rate.get_value().item() * grad_i)
for param_i, grad_i in zip(params, grads)
]
train_model = theano.function(
[index],
cost,
updates=updates,
givens={
x: train_set_x[index * batch_size: (index + 1) * batch_size],
y: train_set_y[index * batch_size: (index + 1) * batch_size]
}
)
getPofYGivenX = theano.function(
[index],
layer4.pOfYGivenX(),
givens={
x: valid_set_x[index * batch_size: (index + 1) * batch_size],
y: valid_set_y[index * batch_size: (index + 1) * batch_size]
},
on_unused_input='ignore'
)
###############
# TRAIN MODEL #
###############
print('... training')
train_nn(train_model, validate_model, test_model,
n_train_batches, n_valid_batches, n_test_batches, n_epochs, learning_rate, verbose)
print('Training the model complete')
f1 = open('layer0.W', 'wb')
cPickle.dump(layer0.W.get_value(), f1, protocol=cPickle.HIGHEST_PROTOCOL)
f1.close()
f1 = open('layer0.b', 'wb')
cPickle.dump(layer0.b.get_value(), f1, protocol=cPickle.HIGHEST_PROTOCOL)
f1.close()
f1 = open('layer1.W', 'wb')
cPickle.dump(layer1.W.get_value(), f1, protocol=cPickle.HIGHEST_PROTOCOL)
f1.close()
f1 = open('layer1.b', 'wb')
cPickle.dump(layer1.b.get_value(), f1, protocol=cPickle.HIGHEST_PROTOCOL)
f1.close()
f1 = open('layer2.W', 'wb')
cPickle.dump(layer2.W.get_value(), f1, protocol=cPickle.HIGHEST_PROTOCOL)
f1.close()
f1 = open('layer2.b', 'wb')
cPickle.dump(layer2.b.get_value(), f1, protocol=cPickle.HIGHEST_PROTOCOL)
f1.close()
f1 = open('layer3.W', 'wb')
cPickle.dump(layer3.W.get_value(), f1, protocol=cPickle.HIGHEST_PROTOCOL)
f1.close()
f1 = open('layer3.b', 'wb')
cPickle.dump(layer3.b.get_value(), f1, protocol=cPickle.HIGHEST_PROTOCOL)
f1.close()
f1 = open('layer4.W', 'wb')
cPickle.dump(layer4.W.get_value(), f1, protocol=cPickle.HIGHEST_PROTOCOL)
f1.close()
f1 = open('layer4.b', 'wb')
cPickle.dump(layer4.b.get_value(), f1, protocol=cPickle.HIGHEST_PROTOCOL)
f1.close()
print("Saving the model complete")
predictedList = getPofYGivenX(1)
print("List of probabilities predicted = " + str(predictedList))
