from blocks.bricks import MLP, Rectifier, Linear, Sigmoid, Identity, Softmax
from blocks.bricks.lookup import LookupTable
from blocks.filter import VariableFilter
from blocks.graph import ComputationGraph, apply_dropout
import numpy
import theano
from theano import tensor
import data
import error
class Model(object):
def __init__(self, config):
# The input and the targets
x_firstk_latitude = (tensor.matrix('first_k_latitude') - data.train_gps_mean[0]) / data.train_gps_std[0]
x_firstk_longitude = (tensor.matrix('first_k_longitude') - data.train_gps_mean[1]) / data.train_gps_std[1]
x_lastk_latitude = (tensor.matrix('last_k_latitude') - data.train_gps_mean[0]) / data.train_gps_std[0]
x_lastk_longitude = (tensor.matrix('last_k_longitude') - data.train_gps_mean[1]) / data.train_gps_std[1]
x_input_time = tensor.lvector('input_time')
input_list = [x_firstk_latitude, x_firstk_longitude, x_lastk_latitude, x_lastk_longitude]
embed_tables = []
self.require_inputs = ['first_k_latitude', 'first_k_longitude', 'last_k_latitude', 'last_k_longitude', 'input_time']
for (varname, num, dim) in config.dim_embeddings:
self.require_inputs.append(varname)
vardata = tensor.lvector(varname)
tbl = LookupTable(length=num, dim=dim, name='%s_lookup'%varname)
embed_tables.append(tbl)
input_list.append(tbl.apply(vardata))
y_dest = tensor.concatenate((tensor.vector('destination_latitude')[:, None],
tensor.vector('destination_longitude')[:, None]), axis=1)
y_time = tensor.lvector('travel_time')
# Define the model
common_mlp = MLP(activations=[Rectifier() for _ in config.dim_hidden],
dims=[config.dim_input] + config.dim_hidden)
dest_mlp = MLP(activations=[Rectifier() for _ in config.dim_hidden_dest] + [Softmax()],
dims=[config.dim_hidden[-1]] + config.dim_hidden_dest + [config.dim_output_dest],
name='dest_mlp')
dest_classes = theano.shared(numpy.array(config.dest_tgtcls, dtype=theano.config.floatX), name='dest_classes')
time_mlp = MLP(activations=[Rectifier() for _ in config.dim_hidden_time] + [Softmax()],
dims=[config.dim_hidden[-1]] + config.dim_hidden_time + [config.dim_output_time],
name='time_mlp')
time_classes = theano.shared(numpy.array(config.time_tgtcls, dtype=theano.config.floatX), name='time_classes')
# Create the Theano variables
inputs = tensor.concatenate(input_list, axis=1)
# inputs = theano.printing.Print("inputs")(inputs)
hidden = common_mlp.apply(inputs)
dest_cls_probas = dest_mlp.apply(hidden)
# dest_cls_probas = theano.printing.Print("dest_cls_probas")(dest_cls_probas)
dest_outputs = tensor.dot(dest_cls_probas, dest_classes)
dest_outputs.name = 'dest_outputs'
time_cls_probas = time_mlp.apply(hidden)
# time_cls_probas = theano.printing.Print("time_cls_probas")(time_cls_probas)
time_outputs = tensor.dot(time_cls_probas, time_classes) + x_input_time
time_outputs.name = 'time_outputs'
# Calculate the cost
dest_cost = error.erdist(dest_outputs, y_dest).mean()
dest_cost.name = 'dest_cost'
dest_hcost = error.hdist(dest_outputs, y_dest).mean()
dest_hcost.name = 'dest_hcost'
time_cost = error.rmsle(time_outputs.flatten(), y_time.flatten())
time_cost.name = 'time_cost'
time_scost = config.time_cost_factor * time_cost
time_scost.name = 'time_scost'
cost = dest_cost + time_scost
if hasattr(config, 'dropout_p'):
cg = ComputationGraph(cost)
dropout_inputs = VariableFilter(
bricks=[b for b in list(common_mlp.children) +
list(dest_mlp.children) +
list(time_mlp.children)
if isinstance(b, Rectifier)],
name='output')(cg)
cg = apply_dropout(cg, dropout_inputs, config.dropout_p)
cost = cg.outputs[0]
cost.name = 'cost'
# Initialization
for tbl in embed_tables:
tbl.weights_init = config.embed_weights_init
tbl.initialize()
for mlp in [common_mlp, dest_mlp, time_mlp]:
mlp.weights_init = config.mlp_weights_init
mlp.biases_init = config.mlp_biases_init
mlp.initialize()
self.cost = cost
self.monitor = [cost, dest_cost, dest_hcost, time_cost, time_scost]
self.outputs = tensor.concatenate([dest_outputs, time_outputs[:, None]], axis=1)
self.outputs.name = 'outputs'
self.pred_vars = ['destination_longitude', 'destination_latitude', 'travel_time']
