#dataset, std, mean = load_locomotion(rng)
dataset, std, mean = load_terrain(rng)
#train_motion_input_dataset = dataset[0][0][300:320]
train_motion_input_dataset = dataset[0][0][1500:1520]
train_motion_input_dataset = train_motion_input_dataset.swapaxes(0, 1)[:-3]
train_motion_input_dataset = train_motion_input_dataset.swapaxes(0, 1)
print "motion input dataset shape = ", train_motion_input_dataset.shape
M_I = shared(train_motion_input_dataset)
BATCH_SIZE = 20
H_SIZE = 128
encoder = HiddenLayer(rng, (128, H_SIZE))
encode_igate = HiddenLayer(rng, (128, H_SIZE))
encode_fgate = HiddenLayer(rng, (128, H_SIZE))
recoder = HiddenLayer(rng, (H_SIZE, H_SIZE))
recode_igate = HiddenLayer(rng, (H_SIZE, H_SIZE))
recode_fgate = HiddenLayer(rng, (H_SIZE, H_SIZE))
activation = ActivationLayer(rng, f='elu')
dropout = DropoutLayer(rng, 0.2)
encoder_network = Network(
Conv1DLayer(rng, (64, 63, 25), (BATCH_SIZE, 63, 240)),
Pool1DLayer(rng, (2, ), (BATCH_SIZE, 64, 240)),
ActivationLayer(rng, f='elu'),
Conv1DLayer(rng, (256, 64, 25), (BATCH_SIZE, 64, 120)),
train_set_x, train_set_y = map(shared, datasets[0])
valid_set_x, valid_set_y = map(shared, datasets[1])
test_set_x, test_set_y = map(shared, datasets[2])
batchsize = 100
train_set_x = train_set_x.reshape((50000, 1, 28, 28))
valid_set_x = valid_set_x.reshape((10000, 1, 28, 28))
test_set_x = test_set_x.reshape((10000, 1, 28, 28))
network = Network(Conv2DLayer(rng, (4, 1, 5, 5), (batchsize, 1, 28, 28)),
BatchNormLayer(rng, (batchsize, 4, 28, 28), axes=(0, 2, 3)),
ActivationLayer(rng, f='ReLU'),
Pool2DLayer(rng, (batchsize, 4, 28, 28)),
ReshapeLayer(rng, (batchsize, 4 * 14 * 14)),
HiddenLayer(rng, (4 * 14 * 14, 10)),
ActivationLayer(rng, f='softmax'))
trainer = AdamTrainer(rng=rng,
batchsize=batchsize,
epochs=15,
alpha=0.0001,
cost='cross_entropy')
trainer.train(network=network,
train_input=train_set_x,
train_output=train_set_y,
valid_input=valid_set_x,
valid_output=valid_set_y,
test_input=test_set_x,
test_output=test_set_y,
filename=None)
from nn.AdamTrainer import AdamTrainer
from utils import load_data
rng = np.random.RandomState(23455)
dataset = '../data/mnist/mnist.pkl.gz'
datasets = load_data(dataset)
shared = lambda d: theano.shared(d)
train_set_x, train_set_y = map(shared, datasets[0])
valid_set_x, valid_set_y = map(shared, datasets[1])
test_set_x, test_set_y = map(shared, datasets[2])
network = Network(HiddenLayer(rng, (784, 500)), BatchNormLayer((784, 500)),
ActivationLayer(rng, f='ReLU'), HiddenLayer(rng, (500, 10)),
BatchNormLayer((500, 10)), ActivationLayer(rng, f='softmax'))
trainer = AdamTrainer(rng=rng,
batchsize=2,
epochs=1,
alpha=0.00001,
cost='cross_entropy')
trainer.train(network=network,
train_input=train_set_x,
train_output=train_set_y,
valid_input=valid_set_x,
valid_output=valid_set_y,
test_input=test_set_x,
test_output=test_set_y,
from nn.BatchNormLayer import BatchNormLayer
from nn.HiddenLayer import HiddenLayer
from nn.Network import Network
from nn.AdamTrainer import AdamTrainer
from utils import load_data
rng = np.random.RandomState(23455)
dataset = '../data/mnist/mnist.pkl.gz'
datasets = load_data(dataset)
train_set_x, train_set_y = datasets[0]
valid_set_x, valid_set_y = datasets[1]
test_set_x, test_set_y = datasets[2]
network = Network(
HiddenLayer(rng, (784, 500)),
BatchNormLayer((784, 500)),
ActivationLayer(rng, f='ReLU'),
HiddenLayer(rng, (500, 10)),
BatchNormLayer((500, 10)),
ActivationLayer(rng, f='softmax')
)
trainer = AdamTrainer(rng=rng, batchsize=100, epochs=1, alpha=0.00001, cost='cross_entropy')
trainer.train(network=network, train_input=train_set_x, train_output=train_set_y,
valid_input=valid_set_x, valid_output=valid_set_y,
test_input=test_set_x, test_output=test_set_y, filename=None)
encoderNetwork = Network(
Conv1DLayer(rng, (64, 66, 25), (BATCH_SIZE, 66, 240)),
BatchNormLayer(rng, (BATCH_SIZE, 64, 240)),
ActivationLayer(rng, f='elu'),
Pool1DLayer(rng, (2,), (BATCH_SIZE, 64, 240)),
DropoutLayer(rng, 0.25),
Conv1DLayer(rng, (128, 64, 25), (BATCH_SIZE, 64, 120)),
BatchNormLayer(rng, (BATCH_SIZE, 128, 120)),
ActivationLayer(rng, f='elu'),
Pool1DLayer(rng, (2,), (BATCH_SIZE, 128, 120)),
ReshapeLayer(rng, (BATCH_SIZE, 128*60)),
DropoutLayer(rng, 0.25),
HiddenLayer(rng, (128*60, FC_SIZE)),
BatchNormLayer(rng, (128*60, FC_SIZE)),
ActivationLayer(rng, f='elu'),
)
variationalNetwork = Network(
VariationalLayer(rng),
)
decoderNetwork = Network(
HiddenLayer(rng, (FC_SIZE/2, 64*30)),
BatchNormLayer(rng, (FC_SIZE/2, 64*30)),
ActivationLayer(rng, f='elu'),
ReshapeLayer(rng, (BATCH_SIZE, 64, 30)),
InverseNetwork(Pool1DLayer(rng, (2,), (BATCH_SIZE, 64, 60))),
0,
2,
)),
ActivationLayer(rng, f='ReLU'),
Pool1DLayer(rng, (2, ), (batchsize, 128, 120)),
Conv1DLayer(rng, (256, 128, 25), (batchsize, 128, 60)),
BatchNormLayer(rng, (batchsize, 256, 60), axes=(
0,
2,
)),
ActivationLayer(rng, f='ReLU'),
Pool1DLayer(rng, (2, ), (batchsize, 256, 60)),
# 256*60 = 7680
ReshapeLayer(rng, (batchsize, 7680)),
HiddenLayer(rng, (np.prod([256, 30]), 8)),
ActivationLayer(rng, f='softmax'),
)
# Load the pre-trained conv-layers
network.load([
'../models/conv_ae/layer_0.npz', None, None,
'../models/conv_ae/layer_1.npz', None, None,
'../models/conv_ae/layer_2.npz', None, None, None, None, None
])
trainer = AdamTrainer(rng=rng,
batchsize=batchsize,
epochs=10,
alpha=0.00001,
cost='cross_entropy')
from nn.AnimationPlotLines import animation_plot
from tools.utils import load_locomotion
rng = np.random.RandomState(23455)
shared = lambda d: theano.shared(d, borrow=True)
dataset, std, mean = load_locomotion(rng)
E = shared(dataset[0][0])
BATCH_SIZE = 40
generatorNetwork = Network(
DropoutLayer(rng, 0.15),
HiddenLayer(rng, (800, 64 * 30)),
BatchNormLayer(rng, (800, 64 * 30)),
ActivationLayer(rng, f='elu'),
ReshapeLayer(rng, (BATCH_SIZE, 64, 30)),
InverseNetwork(Pool1DLayer(rng, (2, ), (BATCH_SIZE, 64, 60))),
DropoutLayer(rng, 0.15),
Conv1DLayer(rng, (64, 64, 25), (BATCH_SIZE, 64, 60)),
ActivationLayer(rng, f='elu'),
InverseNetwork(Pool1DLayer(rng, (2, ), (BATCH_SIZE, 64, 120))),
DropoutLayer(rng, 0.25),
Conv1DLayer(rng, (64, 64, 25), (BATCH_SIZE, 64, 120)),
ActivationLayer(rng, f='elu'),
InverseNetwork(Pool1DLayer(rng, (2, ), (BATCH_SIZE, 64, 240))),
DropoutLayer(rng, 0.25),
Conv1DLayer(rng, (66, 64, 25), (BATCH_SIZE, 64, 240)),
ActivationLayer(rng, f='elu'),