filter_shape=( layer3_filters, layer2_filters, 2, 2),
poolsize=(2, 1),
dim2 = 1
)
layer4 = LeNetConvPoolLayer(
rng,
input=layer3.output,
image_shape=(minibatch_size, layer3_filters, 25, 60),
filter_shape=( layer4_filters, layer3_filters, 2, 2),
poolsize=(1, 1),
dim2 = 1
)
layer4.reverseConv(layer4.output,(minibatch_size,layer4_filters,25,60),(layer3_filters,layer4_filters,2,2))
layer3.reverseConv(layer4.reverseOutput,(minibatch_size,layer3_filters,50,60),(layer2_filters,layer3_filters,2,2))
layer2.reverseConv(layer3.reverseOutput,(minibatch_size,layer2_filters,100,60),(layer1_filters,layer2_filters,2,2))
layer1.reverseConv(layer2.reverseOutput,(minibatch_size,layer1_filters,200,60),(layer0_filters,layer1_filters,2,2))
layer0.reverseConv(layer1.reverseOutput,(minibatch_size,layer0_filters,1000,60),(1,layer0_filters,5,5)) #filter flipped on first two axes
reconstructed = layer0.reverseOutput
cost = T.mean( (layer0_input-reconstructed) **2 )
###########################################################
###########################################################
poolsize=(2, 1),
dim2=1,
)
layer4 = LeNetConvPoolLayer(
rng,
input=layer3.output,
image_shape=(minibatch_size, layer3_filters, 125, 15),
filter_shape=(layer4_filters, layer3_filters, 2, 2),
poolsize=(1, 1),
dim2=1,
)
# need log_reg and decovariate layers
layer4.reverseConv(layer4.output, (1, layer4_filters, 125, 15), (layer3_filters, layer4_filters, 2, 2))
layer3.reverseConv(layer4.reverseOutput, (1, layer3_filters, 250, 15), (layer2_filters, layer3_filters, 2, 2))
layer2.reverseConv(layer3.reverseOutput, (1, layer2_filters, 500, 15), (layer1_filters, layer2_filters, 2, 2))
layer1.reverseConv(layer2.reverseOutput, (1, layer1_filters, 1000, 30), (layer0_filters, layer1_filters, 2, 2))
layer0.reverseConv(
layer1.reverseOutput, (1, layer0_filters, 2000, 60), (1, layer0_filters, 3, 3)
) # filter flipped on first two axes
reconstructed = layer0.reverseOutput
cost = T.mean((x - reconstructed) ** 2)
60),
filter_shape=(layer3_filters, layer2_filters, 2,
2),
poolsize=(2, 1),
dim2=1)
layer4 = LeNetConvPoolLayer(rng,
input=layer3.output,
image_shape=(minibatch_size, layer3_filters, 25,
60),
filter_shape=(layer4_filters, layer3_filters, 2,
2),
poolsize=(1, 1),
dim2=1)
layer4.reverseConv(layer4.output, (minibatch_size, layer4_filters, 25, 60),
(layer3_filters, layer4_filters, 2, 2))
layer3.reverseConv(layer4.reverseOutput,
(minibatch_size, layer3_filters, 50, 60),
(layer2_filters, layer3_filters, 2, 2))
layer2.reverseConv(layer3.reverseOutput,
(minibatch_size, layer2_filters, 100, 60),
(layer1_filters, layer2_filters, 2, 2))
layer1.reverseConv(layer2.reverseOutput,
(minibatch_size, layer1_filters, 200, 60),
(layer0_filters, layer1_filters, 2, 2))
layer0.reverseConv(
layer1.reverseOutput, (minibatch_size, layer0_filters, 1000, 60),
2),
poolsize=(2, 1),
dim2=1)
layer4 = LeNetConvPoolLayer(rng,
input=layer3.output,
image_shape=(minibatch_size, layer3_filters, 125,
15),
filter_shape=(layer4_filters, layer3_filters, 2,
2),
poolsize=(1, 1),
dim2=1)
#need log_reg and decovariate layers
layer4.reverseConv(layer4.output, (1, layer4_filters, 125, 15),
(layer3_filters, layer4_filters, 2, 2))
layer3.reverseConv(layer4.reverseOutput, (1, layer3_filters, 250, 15),
(layer2_filters, layer3_filters, 2, 2))
layer2.reverseConv(layer3.reverseOutput, (1, layer2_filters, 500, 15),
(layer1_filters, layer2_filters, 2, 2))
layer1.reverseConv(layer2.reverseOutput, (1, layer1_filters, 1000, 30),
(layer0_filters, layer1_filters, 2, 2))
layer0.reverseConv(layer1.reverseOutput, (1, layer0_filters, 2000, 60), (
1,
layer0_filters,
3,
3,
image_shape=(1, 1, song_size-1, 60),
filter_shape=( filter_number, 1, 1, 10),
poolsize=(1, 3),
dim2 = 1
)
lstm_input = layer0.output.reshape((song_size-1,20 * filter_number))
#May be worth splitting to different LSTMs...would require smaller filter size
lstm_1 = LSTM(rng, lstm_input, n_in=20 * filter_number, n_out=n_hidden)
#output = LinearRegression(input=lstm_1.output, n_in=n_hidden, n_out=data_set_x.get_value(borrow=True).shape[1])
lstm_output = lstm_1.output.reshape((1,filter_number,song_size-1,20))
layer0.reverseConv(lstm_output,(1,filter_number,song_size-1,60),(1,filter_number,1,10)) #filter flipped on first two axes
reconstructed = layer0.reverseOutput.reshape((song_size-1,60))
################################
# Objective function and GD
################################
print 'defining cost, parameters, and learning function...'
# the cost we minimize during training is the negative log likelihood of
# the model
cost = T.mean((y-reconstructed) **2)
#Defining params
params = lstm_1.params + layer0.params
filter_shape=( filter_number_2, filter_number_1, 1, 2),
poolsize=(1, 2),
dim2 = 1
)
lstm_input = layer1.output.reshape((song_size-1,10 * filter_number_2))
#May be worth splitting to different LSTMs...would require smaller filter size
lstm_1 = LSTM(rng, lstm_input, n_in=10 * filter_number_2, n_out=n_hidden)
#output = LinearRegression(input=lstm_1.output, n_in=n_hidden, n_out=data_set_x.get_value(borrow=True).shape[1])
dnn = HiddenLayer(rng, lstm_1.output, n_in=n_hidden, n_out= 10 * filter_number_2)
dnn_output = dnn.output.reshape((1,filter_number_2,song_size-1,10))
layer1.reverseConv(dnn_output,(1,filter_number_2,song_size-1,20),(filter_number_1,filter_number_2,1,2)) #filter flipped on first two axes
layer0.reverseConv(layer1.reverseOutput,(1,filter_number_1,song_size-1,60),(1,filter_number_1,1,3)) #filter flipped on first two axes
reconstructed = layer0.reverseOutput.reshape((song_size-1,60))
################################
# Objective function and GD
################################
print 'defining cost, parameters, and learning function...'
# the cost we minimize during training is the negative log likelihood of
# the model
cost = T.mean((y-reconstructed) **2)
lin_reg = LinearRegressionRandom(reg_input,15*15*layer3_filters,2,True) log_input = log_reg.p_y_given_x lin_input = lin_reg.E_y_given_x log_reg.reconstruct(log_input) lin_reg.reconstruct(lin_input) reconstructed_regressions = T.concatenate([log_reg.reconstructed_x,lin_reg.reconstructed_x],axis=1) reverse_layer = LinearRegression(reconstructed_regressions, 2*15*15*layer3_filters, 15*15*layer3_filters,False) reconstruct = reverse_layer.E_y_given_x.reshape((minibatch_size,layer3_filters,15,15)) layer3.reverseConv(reconstruct,(minibatch_size,layer3_filters,15,15),(layer2_filters,layer3_filters,2,2)) layer2.reverseConv(layer3.reverseOutput,(minibatch_size,layer2_filters,15,15),(layer1_filters,layer2_filters,2,2)) layer1.reverseConv(layer2.reverseOutput,(minibatch_size,layer1_filters,30,30),(layer0_filters,layer1_filters,2,2)) layer0.reverseConv(layer1.reverseOutput,(minibatch_size,layer0_filters,60,60),(1,layer0_filters,3,3,)) difference = (layer0_input-layer0.reverseOutput) ** 2 encoder_cost = T.mean( difference ) cross_entropy_cost = T.mean(log_reg.cross_entropy_binary(y)) y_hat_mean = T.mean(log_reg.p_y_given_x,axis=0)
lin_input = lin_reg.E_y_given_x
log_reg.reconstruct(log_input)
lin_reg.reconstruct(lin_input)
reconstructed_regressions = T.concatenate(
[log_reg.reconstructed_x, lin_reg.reconstructed_x], axis=1)
reverse_layer = LinearRegression(reconstructed_regressions,
2 * 15 * 15 * layer3_filters,
15 * 15 * layer3_filters, False)
reconstruct = reverse_layer.E_y_given_x.reshape(
(minibatch_size, layer3_filters, 15, 15))
layer3.reverseConv(reconstruct, (minibatch_size, layer3_filters, 15, 15),
(layer2_filters, layer3_filters, 2, 2))
layer2.reverseConv(layer3.reverseOutput,
(minibatch_size, layer2_filters, 15, 15),
(layer1_filters, layer2_filters, 2, 2))
layer1.reverseConv(layer2.reverseOutput,
(minibatch_size, layer1_filters, 30, 30),
(layer0_filters, layer1_filters, 2, 2))
layer0.reverseConv(layer1.reverseOutput,
(minibatch_size, layer0_filters, 60, 60), (
1,
layer0_filters,
3,
3,
lstm_input = layer1.output.reshape((song_size - 1, 10 * filter_number_2))
#May be worth splitting to different LSTMs...would require smaller filter size
lstm_1 = LSTM(rng, lstm_input, n_in=10 * filter_number_2, n_out=n_hidden)
#output = LinearRegression(input=lstm_1.output, n_in=n_hidden, n_out=data_set_x.get_value(borrow=True).shape[1])
dnn = HiddenLayer(rng,
lstm_1.output,
n_in=n_hidden,
n_out=10 * filter_number_2)
dnn_output = dnn.output.reshape((1, filter_number_2, song_size - 1, 10))
layer1.reverseConv(dnn_output, (1, filter_number_2, song_size - 1, 20),
(filter_number_1, filter_number_2, 1,
2)) #filter flipped on first two axes
layer0.reverseConv(
layer1.reverseOutput, (1, filter_number_1, song_size - 1, 60),
(1, filter_number_1, 1, 3)) #filter flipped on first two axes
reconstructed = layer0.reverseOutput.reshape((song_size - 1, 60))
################################
# Objective function and GD
################################
print 'defining cost, parameters, and learning function...'
# the cost we minimize during training is the negative log likelihood of
lin_reg = LinearRegressionRandom(reg_input,7*7*layer3_filters,2,True) log_input = log_reg.p_y_given_x lin_input = lin_reg.E_y_given_x log_reg.reconstruct(log_input) lin_reg.reconstruct(lin_input) reconstructed_regressions = T.concatenate([log_reg.reconstructed_x,lin_reg.reconstructed_x],axis=1) reverse_layer = LinearRegression(reconstructed_regressions, 2*7*7*layer3_filters, 7*7*layer3_filters,False) reconstruct = reverse_layer.E_y_given_x.reshape((minibatch_size,layer3_filters,7,7)) layer3.reverseConv(reconstruct,(minibatch_size,layer3_filters,7,7),(layer2_filters,layer3_filters,2,2)) layer2.reverseConv(layer3.reverseOutput,(minibatch_size,layer2_filters,7,7),(layer1_filters,layer2_filters,2,2)) layer1.reverseConv(layer2.reverseOutput,(minibatch_size,layer1_filters,14,14),(layer0_filters,layer1_filters,2,2)) layer0.reverseConv(layer1.reverseOutput,(minibatch_size,layer0_filters,28,28),(1,layer0_filters,3,3,)) difference = (layer0_input-layer0.reverseOutput) ** 2 encoder_cost = T.mean( difference ) cross_entropy_cost = T.mean(log_reg.cross_entropy_binary(y)) y_hat_mean = T.mean(log_reg.p_y_given_x,axis=0)