def __init__(self, options, train_sentences=None):
self.model = dn.Model()
self.statistics = Statistics.from_sentences(train_sentences)
self.container = nn.Container(self.model)
self.network = EdgeEvaluationNetwork(self.container, self.statistics, options)
self.optimizer = nn.get_optimizer(self.model, options)
self.decoder = decoders[options.decoder]
self.label_decoder = label_decoders[options.label_decoder]
self.labelsFlag = options.labelsFlag
self.options = options
if "func" in options:
del options.func
def __init__(self,
options,
train_sentences=None,
restore_file=None,
statistics=None):
self.model = dn.Model()
random.seed(1)
self.trainer = dn.AdamTrainer(self.model)
self.activation = activations[options.activation]
# self.decoder = decoders[options.decoder]
self.labelsFlag = options.labelsFlag
self.costaugFlag = options.cost_augment
self.options = options
if "func" in options:
del options.func
if restore_file:
self.container, = dn.load(restore_file, self.model)
networks = list(self.container.components)
self.network = networks.pop(0)
self.statistics = statistics
self.has_emptys = len(statistics.emptys) > 0
if self.has_emptys:
self.network_for_emptys = networks.pop(0)
if self.options.use_2nd:
self.network3 = networks.pop(0)
if self.has_emptys:
self.network3_for_emptys_mid = networks.pop(0)
self.network3_for_emptys_out = networks.pop(0)
assert not networks
else:
self.container = nn.Container(self.model)
self.statistics = statistics = StatisticsWithEmpty.from_sentences(
train_sentences)
self.has_emptys = len(statistics.emptys) > 0
self.network = EdgeEvaluationNetwork(self.container, statistics,
options)
if self.has_emptys:
self.network_for_emptys = EdgeEvaluation(
self.container, options)
if options.use_2nd:
self.network3 = EdgeSiblingEvaluation(self.container, options)
if self.has_emptys:
self.network3_for_emptys_mid = EdgeSiblingEvaluation(
self.container, options)
self.network3_for_emptys_out = EdgeSiblingEvaluation(
self.container, options)
def __init__(self, options, data_train):
self.model = dn.Model()
self.optimizer = nn.trainers[options.optimizer](
*((self.model, options.learning_rate)
if options.learning_rate is not None else (self.model,)))
self.options = options
self.statistics = Statistics.from_sentences(data_train)
logger.info(str(self.statistics))
self.container = nn.Container(self.model)
self.sent_embeddings = SentenceEmbeddings(self.container, self.statistics, options)
self.tag_classification = POSTagClassification(self.container, self.statistics.supertags, options)
self.tag_dict = self.statistics.supertags
self.viterbi_decoder = ViterbiDecoder(self.container, self.statistics.supertags, self.options)
def __init__(self,
options,
train_trees=None,
restored_model_and_network=None):
self.options = options
self.decode_type = decoder_types[self.options.decoder]
if "func" in options:
del options.func
if restored_model_and_network:
self.model, self.container = restored_model_and_network
self.span_ebd_network, self.span_eval_network, self.label_eval_network = self.container.components
else:
self.model = dn.Model()
self.statistics = statistics = ConstTreeStatistics.from_sentences(
train_trees)
logger.info(statistics)
self.int_to_label = statistics.labels.int_to_word
self.label_to_int = statistics.labels.word_to_int
self.container = nn.Container(self.model)
self.span_ebd_network = SpanEmbeddings(self.container, statistics,
options)
self.span_eval_network = SpanEvaluation(self.container,
self.options)
self.label_eval_network = LabelEvaluation(self.container,
statistics.labels,
self.options)
self.create_decoders()
if train_trees is not None:
# when training, pre-convert tree to sentence to construct LSTM input
for tree in train_trees:
tree.extra["Sentence"] = tree.to_sentence()
self.optimizer = nn.trainers[options.optimizer](self.model)
if self.options.leaftag_model is not None:
self.leaf_tagger = POSTagParser.load(self.options.leaftag_model,
None)
self.tagger_trained = True
else:
self.leaf_tagger = None
def __init__(self,
options,
train_sentences=None,
restore_file=None,
statistics=None):
self.model = dn.Model()
random.seed(1)
self.optimizer = nn.get_optimizer(self.model, options)
self.activation = activations[options.activation]
# self.decoder = decoders[options.decoder]
self.labelsFlag = options.labelsFlag
self.costaugFlag = options.cost_augment
self.options = options
if "func" in options:
del options.func
self.container = nn.Container(self.model)
self.statistics = statistics = StatisticsWithEmpty.from_sentences(
train_sentences)
self.has_emptys = len(statistics.emptys) > 0
self.network = EdgeEvaluationNetwork(self.container, statistics,
options)
if self.has_emptys:
self.network_for_emptys = EdgeEvaluation(self.container, options)
self.label_network_for_emptys = ToEmptyLabelEvaluation(
self.container, self.statistics.emptys, options)
if options.use_2nd:
self.network3 = EdgeSiblingEvaluation(self.container, options)
if self.has_emptys:
self.network3_for_emptys_mid = EdgeSiblingEvaluation(
self.container, options)
self.network3_for_emptys_out = EdgeSiblingEvaluation(
self.container, options)
def __init__(self, options, train_sentences=None, restore_file=None):
self.model = dn.Model()
random.seed(1)
self.trainer = dn.AdamTrainer(self.model)
self.activation = activations[options.activation]
self.decoder = decoders[options.decoder]
self.labelsFlag = options.labelsFlag
self.costaugFlag = options.cost_augment
self.options = options
if "func" in options:
del options.func
if restore_file:
self.container, = dn.load(restore_file, self.model)
self.network, self.network3 = self.container.components
else:
self.container = nn.Container(self.model)
statistics = Statistics.from_sentences(train_sentences)
self.network = EdgeEvaluationNetwork(self.container, statistics,
options)
self.network3 = EdgeSiblingEvaluation(self.container, options)
import nn network = nn.Container() network.add(nn.Reshape((1, 784))) network.add(nn.Linear(784, 100)) network.add(nn.Sigmoid()) network.add(nn.Linear(100, 10)) network.add(nn.Sigmoid()) network.add(nn.MSE(), cost=True) network.make()
def __init__(self, model, statistics, options):
super(SentenceEmbeddings, self).__init__(model)
self.options = options
self.ldims = options.lstm_dims
if options.ext_embedding is not None:
self.ext_embedding = nn.ExternalEmbedding(self, options.ext_embedding)
e_dim = self.ext_embedding.dim
logger.info('Load external embedding. Vector dimensions %d', self.ext_embedding.dim)
else:
self.ext_embedding = None
e_dim = 0
self.total_dims = options.wembedding_dims + options.pembedding_dims + options.supertag_embedding + e_dim
rnn_dims = [self.total_dims] + [self.ldims * 2] * options.lstm_layers
if self.options.highway_layers <= 0:
self.rnn = nn.recurrents[options.rnn_type](self, rnn_dims)
else:
self.rnn = nn.HighWayRecurrentWrapper(self, rnn_dims,
self.options.highway_layers,
nn.recurrent_builders[options.rnn_type])
if options.label_lstm_dims is not None:
label_rnn_dims = [self.total_dims] + [options.label_lstm_dims * 2] * \
(options.label_lstm_layers or options.lstm_layers)
self.label_rnn = nn.recurrents[options.rnn_type](self, label_rnn_dims)
if options.cembedding_dims > 0 and options.word_threshold > 1:
self.char_embedding = nn.Embedding(self, list(statistics.characters), options.cembedding_dims)
if self.options.cembedding_type == "rnn":
self.c_lstm = nn.recurrents[options.crnn_type](
self, [options.cembedding_dims] + [options.wembedding_dims] * options.lstm_layers)
else:
self.c_conv_W = nn.Container(self)
cembedding_filter_count = options.wembedding_dims / len(options.cembedding_filters)
for filter_size in options.cembedding_filters:
self.c_conv_W.components.append(self.c_conv_W.add_parameters(
(filter_size, options.cembedding_dims, 1,
cembedding_filter_count)))
self.freq_words = set(word for word, count in statistics.words.items()
if count >= options.word_threshold)
logger.info("Word embedding size: {}".format(len(self.freq_words)))
self.word_embedding = nn.Embedding(self, self.freq_words, options.wembedding_dims)
else:
self.word_embedding = nn.Embedding(self, list(statistics.words), options.wembedding_dims)
if options.pembedding_dims > 0:
self.pos_embedding = nn.Embedding(self, list(statistics.postags), options.pembedding_dims)
else:
self.pos_embedding = None
if options.supertag_embedding > 0:
self.supertag_embedding = nn.EmbeddingFromDictionary(
self, statistics.supertags, options.supertag_embedding,
external_init=options.ext_supertag_embedding)
else:
self.supertag_embedding = None
self.rel_embedding = nn.Embedding(self, list(statistics.labels), options.pembedding_dims, ())
self.random = random.Random(168)