def __setstate__(self, state):
self.layers = []
for idx, param in enumerate(state["layer_params"]):
layer = create_layer(param)
self.layers.append(layer)
self.cost = create_cost(state["cost"])
def __init__(self, layer_params, cost_param):
self.layers = []
for idx, param in enumerate(layer_params):
layer = create_layer(param)
self.layers.append(layer)
if idx > 0:
assert layer.input_dim() == self.layers[idx-1].output_dim(), \
"The layer chain is broken at %d-th layer"%idx
self.cost = create_cost(cost_param)
X = theano.tensor.matrix("X")
layer_out = X
for layer in self.layers:
layer_out = layer.output(layer_out)
self.__predict_func = theano.function([X],
outputs=layer_out)
def __init__(self, problem_character = None,
nn_architecture = None, trans_mat_prior = None):
# x shape: [mini-batch size, feature-dim].
# In this problem [mini-batch feature-dim]
if ( problem_character is None or nn_architecture is None):
raise Exception("both problem and architecture must be provided")
word_num = problem_character['word_num']
POS_type_num = problem_character['POS_type_num']
dist_to_verb_num = problem_character['dist_to_verb_num']
dist_to_word_num = problem_character['dist_to_word_num']
# 1,word vector
# output shape: (batch size,sentence_len, word_feature_num)
self.word_embedding_layer = LookupTableLayer(
table_size = word_num,
feature_num = nn_architecture.word_feature_dim
)
# 3,word POS tag vector
# output shape: (batch size,sentence_len, POS_feature_num)
self.pos_embedding_layer = LookupTableLayer(
table_size = POS_type_num,
feature_num = nn_architecture.pos_feature_dim,
)
# self.loc_embedding_layer = LookupTableLayer(
# table_size = loc_type_num,
# feature_num = nn_architecture.dist_feature_dim,
# )
# 5,distance tag vector
# output shape: (batch size,sentence_len, POS_feature_num)
self.locdiff_word_embedding_layer = LookupTableLayer(
table_size = dist_to_word_num,
feature_num = nn_architecture.dist_feature_dim,
)
self.locdiff_verb_embedding_layer = LookupTableLayer(
table_size = dist_to_verb_num,
feature_num = nn_architecture.dist_feature_dim,
)
conv_input_dim = nn_architecture.word_feature_dim * 3 + \
nn_architecture.pos_feature_dim * 3 + \
nn_architecture.dist_feature_dim * 4
conv_shape = (nn_architecture.conv_output_dim,
1,
nn_architecture.conv_window_height,
conv_input_dim)
self.conv_layer = Conv1DMaxPoolLayer(
activator_type="sigmoid",
tensor_shape = conv_shape)
self.embedding_conv_layers = [self.word_embedding_layer,
self.pos_embedding_layer,
self.locdiff_word_embedding_layer,
self.locdiff_verb_embedding_layer,
self.conv_layer]
input_dim = nn_architecture.conv_output_dim
self.perception_layers = []
for idx, output_dim in enumerate(nn_architecture.hidden_layer_output_dims):
hidden_layer = PerceptionLayer(
input_dim = input_dim,
output_dim = output_dim,
activator_type = "sigmoid")
self.perception_layers.append(hidden_layer)
input_dim = output_dim
out_layer = PerceptionLayer(
input_dim = input_dim,
output_dim = problem_character["SRL_type_num"],
activator_type = "softmax")
self.perception_layers.append(out_layer)
self.cost = create_cost({"type": "cross_entropy"})
# self.output_layer = PathTransitionLayer('output',
# class_num=SRL_type_num,
# trans_mat_prior= trans_mat_prior)
# self.output_layer = SoftMaxLayer(n_in= nn_architecture.hidden_layer_output_dims[-1],
# n_out = SRL_type_num,)
X = theano.tensor.matrix("X")
self.__output_func = theano.function([X],
outputs = self.__output(X))
self.__predict_expr = theano.tensor.argmax(self.__output(X), axis = 1)
self.__predict_func = theano.function([X],
outputs = self.__predict_expr)
