def __init__(self, input_size=[]):
cov3_core_sizes = [[3, 5, 5]] * 6
cov3_core_sizes.extend([[4, 5, 5]] * 9)
cov3_core_sizes.extend([[6, 5, 5]])
cov3_mapcombindex = [[0,1,2],[1,2,3],[2,3,4],[3,4,5],[4,5,0],[5,0,1],\
[0,1,2,3],[1,2,3,4],[2,3,4,5],[3,4,5,0],[4,5,0,1],[5,0,1,2],[0,1,3,4],[1,2,4,5],[0,2,3,5],[0,1,2,3,4,5]]
self.convlay1 = ConvLayer([[28, 28]] * 6, [[1, 5, 5]] * 6)
self.poollay2 = PoolingLayer([[14, 14]] * 6, [[2, 2]] * 6)
self.convlay3 = ConvLayer([[10, 10]] * 16, cov3_core_sizes,
cov3_mapcombindex)
self.poollay4 = PoolingLayer([[5, 5]] * 16, [[2, 2]] * 16)
self.convlay5 = ConvLayer([[1, 1]] * 120, [[16, 5, 5]] * 120)
self.fclayer6 = FCLayer(84, 120)
self.output7 = OutputLayer(10, 84)
def __init__(self, input_shape, filter_shapes, strides, n_hidden, n_out):
'''
Initialize a NeuralNet
@param input_shape: tuple or list of length 4 , (batch size, num input feature maps,
image height, image width)
@param filter_shapes: list of 2 (for each conv layer) * 4 values (number of filters, num input feature maps,
filter height,filter width)
@param strides: list of size 2, stride values for each hidden layer
@param n_hidden: int, number of neurons in the all-to-all connected hidden layer
@param n_out: int, number od nudes in output layer
'''
#create theano variables corresponding to input_batch (x) and output of the network (y)
x = T.ftensor4('x')
y = T.fmatrix('y')
#first hidden layer is convolutional:
self.layer_hidden_conv1 = ConvolutionalLayer(x, filter_shapes[0],
input_shape, strides[0])
#second convolutional hidden layer: the size of input depends on the size of output from first layer
#it is defined as (num_batches, num_input_feature_maps, height_of_input_maps, width_of_input_maps)
second_conv_input_shape = [
input_shape[0], filter_shapes[0][0],
self.layer_hidden_conv1.feature_map_size,
self.layer_hidden_conv1.feature_map_size
]
self.layer_hidden_conv2 = ConvolutionalLayer(
self.layer_hidden_conv1.output,
filter_shapes[1],
image_shape=second_conv_input_shape,
stride=2) # Drops use of strides
#output from convolutional layer is 4D, but normal hidden layer expects 2D. Because of all to all connections
# 3rd hidden layer does not care from which feature map or from which position the input comes from
flattened_input = self.layer_hidden_conv2.output.flatten(2)
#create third hidden layer
self.layer_hidden3 = HiddenLayer(flattened_input,
self.layer_hidden_conv2.fan_out,
n_hidden)
#create output layer
self.layer_output = OutputLayer(self.layer_hidden3.output, n_hidden,
n_out)
#define the ensemble of parameters of the whole network
self.params = self.layer_hidden_conv1.params + self.layer_hidden_conv2.params \
+ self.layer_hidden3.params + self.layer_output.params
#discount factor
self.gamma = 0.95
#: define regularization terms, for some reason we only take in count the weights, not biases)
# linear regularization term, useful for having many weights zero
self.l1 = abs(self.layer_hidden_conv1.W).sum() \
+ abs(self.layer_hidden_conv2.W).sum() \
+ abs(self.layer_hidden3.W).sum() \
+ abs(self.layer_output.W).sum()
#: square regularization term, useful for forcing small weights
self.l2_sqr = (self.layer_hidden_conv1.W ** 2).sum() \
+ (self.layer_hidden_conv2.W ** 2).sum() \
+ (self.layer_hidden3.W ** 2).sum() \
+ (self.layer_output.W ** 2).sum()
#: define the cost function
self.cost = 0.0 * self.l1 + 0.0 * self.l2_sqr + self.layer_output.errors(
y)
self.cost_function = theano.function([x, y], [self.cost])
#: define gradient calculation
self.grads = T.grad(self.cost, self.params)
#: Define how much we need to change the parameter values
self.learning_rate = T.scalar('lr')
self.updates = []
for param_i, gparam_i in zip(self.params, self.grads):
self.updates.append(
(param_i, param_i - self.learning_rate * gparam_i))
self.x = x
self.y = y
#: we need another set of theano variables (other than x and y) to use in train and predict functions
temp_x = T.ftensor4('temp_x')
temp_y = T.fmatrix('temp_y')
#: define the training operation as applying the updates calculated given temp_x and temp_y
self.train_model = theano.function(inputs=[
temp_x, temp_y,
theano.Param(self.learning_rate, default=0.00001)
],
outputs=[self.cost],
updates=self.updates,
givens={
x: temp_x,
y: temp_y
},
name='train_model')
self.cost_clone = theano.clone(self.cost, replace=self.updates)
self.line_function = theano.function([x, y, self.learning_rate],
[self.cost_clone])
self.predict_rewards = theano.function(
inputs=[temp_x],
outputs=[self.layer_output.output],
givens={x: temp_x},
name='predict_rewards')
self.predict_rewards_and_cost = theano.function(
inputs=[temp_x, temp_y],
outputs=[self.layer_output.output, self.cost],
givens={
x: temp_x,
y: temp_y
},
name='predict_rewards_and_cost')
def __init__(self, input_shape, filter_shapes, strides, n_hidden, n_out):
x = T.dtensor4('x')
y = T.dmatrix('y')
self.layer_hidden_conv1 = ConvolutionalLayer(x, filter_shapes[0],
input_shape, strides[0])
second_conv_input_shape = [
input_shape[0], filter_shapes[0][0],
self.layer_hidden_conv1.feature_map_size,
self.layer_hidden_conv1.feature_map_size
]
self.layer_hidden_conv2 = ConvolutionalLayer(
self.layer_hidden_conv1.output,
filter_shapes[1],
image_shape=second_conv_input_shape,
stride=2)
flattened_input = self.layer_hidden_conv2.output.flatten(2)
self.layer_hidden3 = HiddenLayer(flattened_input,
self.layer_hidden_conv2.fan_out,
n_hidden)
self.layer_output = OutputLayer(self.layer_hidden3.output, n_hidden,
n_out)
self.params = self.layer_hidden_conv1.params + self.layer_hidden_conv2.params \
+ self.layer_hidden3.params + self.layer_output.params
self.gamma = 0.95
self.L1 = abs(self.layer_hidden_conv1.W).sum() \
+ abs(self.layer_hidden_conv2.W).sum() \
+ abs(self.layer_hidden3.W).sum() \
+ abs(self.layer_output.W).sum()
# square of L2 norm ; one regularization option is to enforce
# square of L2 norm to be small
self.L2_sqr = (self.layer_hidden_conv1.W ** 2).sum() \
+ (self.layer_hidden_conv2.W ** 2).sum() \
+ (self.layer_hidden3.W ** 2).sum() \
+ (self.layer_output.W ** 2).sum()
cost = 0.0 * self.L1 + 0.0 * self.L2_sqr + self.layer_output.errors(y)
grads = T.grad(cost, self.params)
# Define how much we need to change the parameter values
learning_rate = 0.01
updates = []
for param_i, gparam_i in zip(self.params, grads):
updates.append((param_i, param_i - learning_rate * gparam_i))
temp1 = T.dtensor4('temp1')
temp2 = T.dmatrix('temp2')
self.train_model = theano.function(inputs=[temp1, temp2],
outputs=[cost],
updates=updates,
givens={
x: temp1,
y: temp2
})
#self.shared_q = theano.shared(np.zeros((32,4)))
#self.shared_s = theano.shared(np.zeros((32,4,84,84)))
#self.train_model_shared = theano.function(inputs=[], outputs=[cost],
# updates=updates,
# givens={
# x: self.shared_s,
# y: self.shared_q
# })
self.predict_rewards = theano.function(
inputs=[temp1],
outputs=[self.layer_output.output],
givens={x: temp1})
self.predict_rewards_and_cost = theano.function(
inputs=[temp1, temp2],
outputs=[self.layer_output.output, cost],
givens={
x: temp1,
y: temp2
})
def create_output_layer(self):
output_layer = OutputLayer.OutputLayer(self.class_num)
return output_layer
