def __init__(self, n_vocab, n_char, n_tag, args): feature_dim = args[ 'word_embedding_dim'] + 2 * args['char_embedding_dim'] super(ModelBase, self).__init__(char_embed=L.EmbedID(n_char, args['char_embedding_dim'], ignore_label=-1), bi_char=L.NStepBiLSTM(1, args['char_embedding_dim'], args['char_embedding_dim'], 0), word_embed=L.EmbedID(n_vocab, args['word_embedding_dim'], ignore_label=-1), bi_word=L.NStepBiLSTM(1, feature_dim, int(feature_dim / 2), 0), l=L.Linear(feature_dim, n_tag), crf=L.CRF1d(n_tag)) # Initialize value for hyper parameters self.char_embedding_dim = args['char_embedding_dim'] self.tag_embedding_dim = args['tag_embedding_dim'] self.dropout_ratio = args['dropout_ratio'] self.lr_param = args['lr_param'] self.threshold = args['threshold'] self.decay_rate = args['decay_rate'] self.batch_size = args['batch_size'] if args['mode'] == 'train': for w in self.bi_char: w.b1.data[:] = 1.0 w.b5.data[:] = 1.0 for w in self.bi_word: w.b1.data[:] = 1.0 w.b5.data[:] = 1.0
def __init__( self, n_speakers=4, dropout=0.25, in_size=513, hidden_size=256, n_layers=1, embedding_layers=1, embedding_size=20, dc_loss_ratio=0.5, ): """ BLSTM-based diarization model. Args: n_speakers (int): Number of speakers in recording dropout (float): dropout ratio in_size (int): Dimension of input feature vector hidden_size (int): Number of hidden units in LSTM n_layers (int): Number of LSTM layers after embedding embedding_layers (int): Number of LSTM layers for embedding embedding_size (int): Dimension of embedding vector dc_loss_ratio (float): mixing parameter for DPCL loss """ super(BLSTMDiarization, self).__init__() with self.init_scope(): self.bi_lstm1 = L.NStepBiLSTM(n_layers, hidden_size * 2, hidden_size, dropout) self.bi_lstm_emb = L.NStepBiLSTM(embedding_layers, in_size, hidden_size, dropout) self.linear1 = L.Linear(hidden_size * 2, n_speakers) self.linear2 = L.Linear(hidden_size * 2, embedding_size) self.dc_loss_ratio = dc_loss_ratio self.n_speakers = n_speakers
def __init__(self, n_cell, size_hidden, rate_dropout): super(ONT_BiLSTM, self).__init__() self.rate_dropout = rate_dropout with self.init_scope(): self.rnn_a = L.NStepBiLSTM(n_cell, 300, size_hidden, rate_dropout) self.rnn_b = L.NStepBiLSTM(n_cell, 300, size_hidden, rate_dropout) self.l1 = L.Linear(size_hidden * 4, size_hidden * 4) self.l2 = L.Linear(size_hidden * 4, 4)
def __init__(self, hidden_dim): super(InferenceCompositionLayer, self).__init__() with self.init_scope(): self.hypo_encoder = L.NStepBiLSTM(1, hidden_dim, int(hidden_dim / 8), dropout=0.3) self.premise_encoder = L.NStepBiLSTM(1, hidden_dim, int(hidden_dim / 8), dropout=0.3)
def __init__(self, n_vocab, embed_dim, hidden_dim): super(InputEncodingLayer, self).__init__() with self.init_scope(): self.embed_mat = L.EmbedID(n_vocab, embed_dim) self.hypo_encoder = L.NStepBiLSTM(1, hidden_dim, int(hidden_dim / 2), dropout=0.3) self.premise_encoder = L.NStepBiLSTM(1, hidden_dim, int(hidden_dim / 2), dropout=0.3)
def __init__(self, n_layers=1, n_inputs=3, n_outputs=3, linear_num=786, cell_num=128, atten1=64, atten2=1, hidden1=64, dropout_rate=0.1): self.dropout_rate = dropout_rate super(SER, self).__init__() with self.init_scope(): self.c1 = L.Convolution2D(n_inputs, 128, ksize=(5, 3), stride=(1, 1), pad=(2, 1)) self.c2 = L.Convolution2D(128, 512, ksize=(5, 3), stride=(1, 1), pad=(2, 1)) self.b1 = L.BatchNormalization(128) self.b2 = L.BatchNormalization(512) self.cl = L.Linear(None, linear_num) self.lstm = L.NStepBiLSTM(n_layers, linear_num, cell_num, dropout_rate) self.a1 = L.Linear(cell_num * 2, atten1) self.a2 = L.Linear(atten1, atten2) self.l3 = L.Linear(cell_num * 2, hidden1) self.b3 = L.BatchNormalization(hidden1) self.l4 = L.Linear(hidden1, n_outputs) self.af = F.leaky_relu
def __init__(self, n_layers, insize, outsize, initialW=None, use_bi_lstm=False): super(EdgeRNN, self).__init__() self.n_layer = n_layers self.outsize = outsize if use_bi_lstm: assert outsize % 2 == 0, outsize if not initialW: initialW = initializers.HeNormal() with self.init_scope(): self.fc1 = L.Linear(insize, 256, initialW=initialW) self.fc2 = L.Linear(256, 256, initialW=initialW) if use_bi_lstm: self.lstm3 = L.NStepBiLSTM(self.n_layer, 256, outsize // 2, initialW=initialW, dropout=0.1) #dropout = 0.0 else: self.lstm3 = L.NStepLSTM(self.n_layer, 256, outsize, initialW=initialW, dropout=0.1)
def __init__(self, n_layers, insize, outsize, initialW=None, use_bi_lstm=False): super(ConnLabelRNN, self).__init__() if not initialW: initialW = initializers.HeNormal() self.n_layer = n_layers with self.init_scope(): if use_bi_lstm: self.lstm1 = L.NStepBiLSTM(self.n_layer, insize, 512, initialW=initialW, dropout=0.1) else: self.lstm1 = L.NStepLSTM(self.n_layer, insize, 1024, initialW=initialW, dropout=0.1) self.fc2 = L.Linear(1024, 512) self.fc3 = L.Linear(512, outsize)
def __init__(self, n_layers, insize, outsize, initialW=None, use_bi_lstm=False): super(NodeRNN, self).__init__() if not initialW: initialW = initializers.HeNormal() self.n_layer = n_layers with self.init_scope(): if use_bi_lstm: self.lstm = L.NStepBiLSTM(self.n_layer, 1024, outsize // 2, initialW=initialW, dropout=0.1) #dropout = 0.0 else: self.lstm = L.NStepLSTM(self.n_layer, 1024, outsize, initialW=initialW, dropout=0.1) self.fc1 = L.Linear(insize, 1024, initialW=initialW) self.fc2 = L.Linear(1024, 1024, initialW=initialW)
def __init__(self, n_word_types, n_trig_types, n_role_types, n_entity_types, params): super(SearchBasedModel, self).__init__() with self.init_scope(): self.dim_embed = params['dim_embed'] self.dim_bilstm = params['dim_bilstm'] self.dim_role_type = params['dim_role_type'] self.dim_arg_type = params['dim_arg_type'] self.dropout = params['dropout'] self.threshold = params['threshold'] self.n_best = params['n_best'] self.margin = params['margin'] self.action_dim = params['dim_action'] self.max_pos = params['max_pos'] self.dim_pos = params['dim_pos'] self.arg_type_and_word_dim = self.dim_arg_type + (self.dim_bilstm * 2) + self.dim_pos self.relation_dim = self.arg_type_and_word_dim + self.dim_role_type + self.arg_type_and_word_dim self.hidden_dim = int(self.arg_type_and_word_dim / 2) embed_init = chainer.initializers.Normal() self.embed_positiontype = L.EmbedID(self.max_pos, self.dim_pos, initialW=embed_init, ignore_label=-1) self.embed_wordtype = L.EmbedID(n_word_types, self.dim_embed, initialW=embed_init, ignore_label=-1) self.embed_trigtype = L.EmbedID(n_trig_types, self.dim_arg_type, initialW=embed_init, ignore_label=-1) self.embed_roletype = L.EmbedID(n_role_types, self.dim_role_type, initialW=embed_init, ignore_label=-1) self.embed_enttype = L.EmbedID(n_entity_types, self.dim_arg_type, initialW=embed_init, ignore_label=-1) self.embed_action = L.EmbedID(self.action_dim, self.action_dim, initialW=embed_init, ignore_label=-1) self.bilstm = L.NStepBiLSTM(1, self.dim_embed, self.dim_bilstm, 0) self.linear_structure = L.Linear( None, self.relation_dim + self.action_dim) self.linear_buffer = L.Linear(None, self.relation_dim + self.action_dim) self.state_representation = L.Linear(None, self.arg_type_and_word_dim) self.linear1 = L.Linear(None, self.hidden_dim) self.linear2 = L.Linear(None, self.hidden_dim) self.linear = L.Linear(None, 1)
def __init__(self, vocab_size: int, word_size: int, hidden_size: int, dropout: float = 0.5, **kwargs): """Initialize the Relevant Sentences Detector model. Parameters ---------- vocab_size : int The number of items in the vocabulary of the input. word_size : int The number of dimensions used to represent the vocabulary. hidden_size : int The number of dimensions used to represent the hidden state of the LSTM. dropout : float, optional The dropout used for the LSTM (default: 0.5). kwargs Optional keyword arguments passed to the super class. """ super().__init__(**kwargs) with self.init_scope(): self.embed = links.EmbedID(vocab_size, word_size) self.rnn = links.NStepBiLSTM(1, word_size, hidden_size, dropout) self.l_out = links.Linear(2)
def __init__(self, inputDim, outDimPdf, outDimPho): super(LSTM, self).__init__() with self.init_scope(): global args self.nl = L.NStepBiLSTM(args.layer, inputDim, args.hiddenNode, args.dropout) self.bn = L.BatchNormalization(args.hiddenNode * 2, 0.95) #for param in self.params(): # param.array[...] = np.random.uniform(-0.1, 0.1, param.shape) initializerW = None #chainer.initializers.HeNormal() initializerBias = None #chainer.initializers.Zero() self.ln1 = L.Linear(None, outDimPdf, initialW=initializerW, initial_bias=initializerBias) self.ln2 = L.Linear(None, outDimPho, initialW=initializerW, initial_bias=initializerBias)
def __init__(self, database, n_layers:int, in_size:int, out_size:int, initialW=None, spatial_edge_model: SpatialEdgeMode = SpatialEdgeMode.all_edge, recurrent_block_type: RecurrentType = RecurrentType.rnn, attn_heads=8, bi_lstm=False): super(SpaceTimeRNN, self).__init__() self.neg_pos_ratio = 3 self.database = database self.spatial_edge_mode = spatial_edge_model self.out_size = out_size self.in_size = in_size self.frame_node_num = config.BOX_NUM[self.database] self.mid_size = 1024 NodeRecurrentModule = AttentionBlock if recurrent_block_type == RecurrentType.attention_block else TemporalRNN if recurrent_block_type == RecurrentType.no_temporal: NodeRecurrentModule = PositionwiseFeedForwardLayer with self.init_scope(): if not initialW: initialW = initializers.HeNormal() self.top = dict() for i in range(self.frame_node_num): if recurrent_block_type == RecurrentType.rnn: self.add_link("Node_{}".format(i), TemporalRNN(n_layers, self.in_size, self.mid_size, use_bi_lstm=bi_lstm)) else: self.add_link("Node_{}".format(i), NodeRecurrentModule(n_layers, self.in_size, self.mid_size)) self.top[str(i)] = getattr(self, "Node_{}".format(i)) fc_in_len = self.mid_size if spatial_edge_model != SpatialEdgeMode.no_edge: self.space_lstm = L.NStepBiLSTM(n_layers, self.in_size, self.mid_size//2, dropout=0.1, initialW=initialW) fc_in_len = self.mid_size * 2 self.fc = L.Linear(fc_in_len, self.out_size, initialW=initialW)
def __init__(self, idim, elayers, cdim, hdim, subsample, dropout, typ="lstm"): super(BRNNP, self).__init__() with self.init_scope(): for i in six.moves.range(elayers): if i == 0: inputdim = idim else: inputdim = hdim setattr( self, "birnn%d" % i, L.NStepBiLSTM(1, inputdim, cdim, dropout) if typ == "lstm" else L.NStepBiGRU(1, inputdim, cdim, dropout)) # bottleneck layer to merge setattr(self, "bt%d" % i, L.Linear(2 * cdim, hdim)) self.elayers = elayers self.cdim = cdim self.subsample = subsample self.typ = typ
def setUp(self): shape = (self.n_layer * 2, len(self.lengths), self.out_size) if self.hidden_none: self.h = self.c = numpy.zeros(shape, 'f') else: self.h = numpy.random.uniform(-1, 1, shape).astype('f') self.c = numpy.random.uniform(-1, 1, shape).astype('f') self.xs = [ numpy.random.uniform(-1, 1, (l, self.in_size)).astype('f') for l in self.lengths ] self.gh = numpy.random.uniform(-1, 1, shape).astype('f') self.gc = numpy.random.uniform(-1, 1, shape).astype('f') self.gys = [ numpy.random.uniform(-1, 1, (l, self.out_size * 2)).astype('f') for l in self.lengths ] self.rnn = links.NStepBiLSTM(self.n_layer, self.in_size, self.out_size, self.dropout) for layer in self.rnn: for p in layer.params(): p.array[...] = numpy.random.uniform(-1, 1, p.shape) self.rnn.cleargrads()
def __init__(self, n_vocab, embed, hidden, dropout, initialW): n_layers = 1 super(WordEncoder, self).__init__() with self.init_scope(): self.embed = L.EmbedID(n_vocab, embed, initialW=initialW) self.Nlstm = L.NStepBiLSTM(n_layers, embed, hidden, dropout) self.hidden = hidden
def __init__(self, n_layers=consts.LAYERS, n_in=consts.IN * 2, n_units=consts.UNITS * 2, n_tag=9, dropout=consts.DROPOUT): super(RNN_TOP, self).__init__() # パラメータを持つ層の登録 with self.init_scope(): self.xh = L.NStepBiLSTM(n_layers, n_in, n_units, dropout) self.h_100_self = L.Linear(n_units * 2, 100 * 2) self.h_1_self = L.Linear(100 * 2, 1) self.h_100_qyn = L.Linear(n_units * 2, 100 * 2) self.h_1_qyn = L.Linear(100 * 2, 1) self.h_100_qw = L.Linear(n_units * 2, 100 * 2) self.h_1_qw = L.Linear(100 * 2, 1) self.h_100_ayn = L.Linear(n_units * 2, 100 * 2) self.h_1_ayn = L.Linear(100 * 2, 1) self.h_100_aw = L.Linear(n_units * 2, 100 * 2) self.h_1_aw = L.Linear(100 * 2, 1) self.h_100_res = L.Linear(n_units * 2, 100 * 2) self.h_1_res = L.Linear(100 * 2, 1) self.h_100_fil = L.Linear(n_units * 2, 100 * 2) self.h_1_fil = L.Linear(100 * 2, 1) self.h_100_con = L.Linear(n_units * 2, 100 * 2) self.h_1_con = L.Linear(100 * 2, 1) self.h_100_req = L.Linear(n_units * 2, 100 * 2) self.h_1_req = L.Linear(100 * 2, 1)
def __init__(self, num_classes): super(Model, self).__init__() with self.init_scope(): self.conv1 = L.ConvolutionND(ndim=1, in_channels=3, out_channels=48, ksize=5, stride=1, pad=2) self.batch2 = L.BatchNormalization(48) self.conv2 = L.ConvolutionND(ndim=1, in_channels=48, out_channels=64, ksize=5, stride=1, pad=2) self.batch3 = L.BatchNormalization(64) self.conv3 = L.ConvolutionND(ndim=1, in_channels=64, out_channels=96, ksize=3, stride=1, pad=1) self.lstm = L.NStepBiLSTM(n_layers=3, in_size=96, out_size=128, dropout=0.3) self.fc = L.Linear(in_size=256, out_size=num_classes)
def __init__(self, n_vocab=None, emb_dim=100, hidden_dim=200, init_emb=None, add_dim=0, use_dropout=0.33, n_layers=1, pos_dim=0, n_pos=0): feature_dim = emb_dim + add_dim + pos_dim super(FastBiLSTM, self).__init__(word_embed=L.EmbedID(n_vocab, emb_dim, ignore_label=-1), bi_lstm=L.NStepBiLSTM(n_layers=n_layers, in_size=feature_dim, out_size=hidden_dim, dropout=use_dropout, use_cudnn=True)) if n_pos: pos_embed = L.EmbedID(n_pos, pos_dim, ignore_label=-1) self.add_link('pos_embed', pos_embed) self.n_pos = n_pos self.hidden_dim = hidden_dim self.train = True self.use_dropout = use_dropout self.n_layers = n_layers # Forget gate bias => 1.0 # MEMO: Values 1 and 5 reference the forget gate. for w in self.bi_lstm: w.b1.data[:] = 1.0 w.b5.data[:] = 1.0
def __init__(self, n_layers=consts.LAYERS, n_in=consts.IN * 2, n_units=consts.UNITS * 2, dropout=consts.DROPOUT): super(RNN_CONNECT_AT, self).__init__() with self.init_scope(): self.xh = L.NStepBiLSTM(n_layers, n_in, n_units, dropout) self.hy1 = L.Linear(n_units * 2, 100 * 2) self.h_100_self = L.Linear(n_units * 2, 100 * 2) self.h_100_qyn = L.Linear(n_units * 2, 100 * 2) self.h_100_qw = L.Linear(n_units * 2, 100 * 2) self.h_100_ayn = L.Linear(n_units * 2, 100 * 2) self.h_100_aw = L.Linear(n_units * 2, 100 * 2) self.h_100_res = L.Linear(n_units * 2, 100 * 2) self.h_100_fil = L.Linear(n_units * 2, 100 * 2) self.h_100_con = L.Linear(n_units * 2, 100 * 2) self.h_100_req = L.Linear(n_units * 2, 100 * 2) self.at = L.Linear(100 * 2, 1) # self.at1 = L.Linear(100*2, 100) # 200->100->1じゃなくて200->1でもいいかも # self.at2 = L.Linear(100, 1) self.out = L.Linear(100 * 2, 9) # 200->9じゃなくて200->100->9でもいいかも
def __init__(self, n_layers, n_source_vocab, trans_data, n_units, v_eos_src, n_maxsize): super(Seq2Tree_Flatten, self).__init__() # for each nodetype, for each move, the result array. self.trans_data = trans_data self.embed_idx = [] ns = 0 def inc(): nonlocal ns ns += 1 return ns - 1 self.embed_idx = [[[inc() for v in vs] for vs in moves] for moves in self.trans_data] self.embed_root_idx = ns self.embed_y_size = ns + 1 self.choicerange = [] self.choice_idx = [] self.is_trivial = [] s = 0 for d in self.trans_data: ist = len(d) <= 1 self.is_trivial.append(ist) #if ist: # self.choicerange.append(None) # self.choice_idx.append([0]) # continue b = s s += len(d) self.choicerange.append((b, s)) self.choice_idx.append(list(range(b, s))) #self.choice_num_sum = sum(list(map(lambda d: len(d),self.trans_data))) self.type_size = len(self.embed_idx) self.n_all_choice = sum(map(lambda x: len(x), self.trans_data)) with self.init_scope(): self.embed_x = L.EmbedID(n_source_vocab, n_units) #self.embed_y = L.EmbedID(self.embed_y_size, n_units) # maybe mergable self.embed_y_0 = L.EmbedID(self.embed_y_size, n_units) # maybe mergable self.embed_y_1 = L.EmbedID(self.type_size, n_units) # maybe mergable self.encoder = L.NStepBiLSTM(n_layers, n_units, n_units, 0.1) self.decoder = L.NStepLSTM(n_layers, n_units * 2, n_units * 2, 0.1) self.Wc = L.Linear(n_units * 4, n_units) self.Ws = L.Linear(n_units, self.n_all_choice) #self.att = Attention(n_units) self.att = GlobalGeneralAttention(n_units) self.n_layers = n_layers self.n_units = n_units self.v_eos_src = v_eos_src self.n_maxsize = n_maxsize self.rootidx = len(trans_data) - 1
def __init__(self, ch): super(Link_NStepBiLSTM, self).__init__(L.NStepBiLSTM(1, 1, 1, 0)) # code.InteractiveConsole({'ch': ch}).interact() hd = ch.children().__next__() if not (hd.w0 is None): self.n_in = hd.w0.shape[1] else: self.n_in = None self.out_size = ch.out_size self.n_layers = ch.n_layers self.dropout = ch.dropout self.ws = [] self.bs = [] for i in range(self.n_layers * 2): ws = [] bs = [] for j in range(8): ws.append( helper.make_tensor_value_info(('/%d/w%d' % (i, j)), TensorProto.FLOAT, ["TODO"])) bs.append( helper.make_tensor_value_info(('/%d/b%d' % (i, j)), TensorProto.FLOAT, ["TODO"])) self.ws.append(ws) self.bs.append(bs)
def __init__(self, n_layers=consts.LAYERS, n_in=consts.IN*2, n_units=consts.UNITS*2, n_tag=9, dropout=consts.DROPOUT): super(RNN_FINETUNING, self).__init__() # パラメータを持つ層の登録 with self.init_scope(): self.xh = L.NStepBiLSTM(n_layers, n_in, n_units, dropout) self.hy1 = L.Linear(n_units*2, 100*2) self.hy2 = L.Linear(100*2, n_tag)
def __init__(self, n_vocab=30000, n_units=200, n_layers=2, dropout=0.5): super(SentRepRNN, self).__init__() with self.init_scope(): self.embed = L.EmbedID(n_vocab, n_units) # word embedding(入力は単一のリスト) self.encoder = L.NStepBiLSTM( n_layers, n_units, n_units, dropout) # (embed時と異なり、)ラベル内の各文ごとに文ベクトルを作成
def __init__(self, vocab_size, embed_size, hidden_size, dropout): n_layers = 1 super(Encoder, self).__init__() with self.init_scope(): self.embed = L.EmbedID(vocab_size, embed_size) self.Nlstm = L.NStepBiLSTM(n_layers, embed_size, hidden_size, dropout) self.hidden_size = hidden_size
def __init__(self, input_size, hidden_size, num_layers, num_classes): super(BiRNN, self).__init__() self.hidden_size = hidden_size self.num_layers = num_layers with self.init_scope(): self.nsteplstm = L.NStepBiLSTM(num_layers, input_size, hidden_size, dropout=0) # chainer.Links.NStepLSTM and torch.nn.LSTM are alike. self.fc = L.Linear(2 * hidden_size, num_classes)
def __init__(self, vocab_size): super(LSTMChain, self).__init__() with self.init_scope(): self.embed = L.EmbedID(vocab_size, 200) self.bi_lstm = L.NStepBiLSTM(1, 200, 300, 0.2) self.mid = L.Linear(600, 200) self.out = L.Linear(200, 11) self.dropout = 0.2
def __init__(self, n_word_types, n_trig_types, n_role_types, n_entity_types, trigger_type2id, entity_type2id, DIM_EMBED, DIM_EVENT, DIM_BILSTM, DIM_TRIG_TYPE, DIM_ROLE_TYPE, DIM_ARG_TYPE, DIM_IO, DROPOUT, REPLACE_TYPE, GENERALISATION, THRESHOLD): super(Loader, self).__init__() with self.init_scope(): self.DIM_EMBED = DIM_EMBED self.DIM_EVENT = DIM_EVENT self.DIM_BILSTM = DIM_BILSTM self.DIM_TRIG_TYPE = DIM_TRIG_TYPE self.DIM_ROLE_TYPE = DIM_ROLE_TYPE self.DIM_ARG_TYPE = DIM_ARG_TYPE self.DIM_IO = DIM_IO self.DROPOUT = DROPOUT self.THRESHOLD = THRESHOLD self.GENERALISATION = GENERALISATION self.REPLACE_TYPE = REPLACE_TYPE self.DROPOUT = DROPOUT self.DIM_TREE_LSTM_INPUT = self.DIM_TRIG_TYPE + ( self.DIM_BILSTM * 2) + self.DIM_ROLE_TYPE + self.DIM_TRIG_TYPE + ( self.DIM_BILSTM * 2) + self.DIM_IO self.DIM_ARG = self.DIM_TRIG_TYPE + (self.DIM_BILSTM * 2) self.id2triggertype = {v: k for k, v in trigger_type2id.items()} self.id2entitytype = {v: k for k, v in entity_type2id.items()} self.embed = L.EmbedID(n_word_types, self.DIM_EMBED, ignore_label=-1) self.bilstm = L.NStepBiLSTM(1, self.DIM_EMBED, self.DIM_BILSTM, 0) self.embed_trigtype = L.EmbedID(n_trig_types, self.DIM_TRIG_TYPE, ignore_label=-1) self.embed_roletype = L.EmbedID(n_role_types, self.DIM_ROLE_TYPE, ignore_label=-1) self.embed_argtype = L.EmbedID(n_entity_types, self.DIM_ARG_TYPE, ignore_label=-1) self.embed_io = L.EmbedID(2, self.DIM_IO, ignore_label=-1) self.treelstm = L.ChildSumTreeLSTM(self.DIM_TREE_LSTM_INPUT, self.DIM_EVENT) self.l1 = L.Linear(None, self.DIM_EVENT) self.y = L.Linear(None, self.DIM_EVENT) self.final = L.Linear(None, 1) # event or non-event self.reducedEvent = L.Linear(None, self.DIM_ARG) self.len_type_and_arg = self.DIM_TRIG_TYPE + (self.DIM_BILSTM * 2) self.len_relation = self.DIM_TRIG_TYPE + (self.DIM_BILSTM * 2) + self.DIM_ROLE_TYPE + self.DIM_ARG_TYPE + \ (self.DIM_BILSTM * 2) + self.DIM_IO self.trigger_type2id = trigger_type2id self.entity_type2id = entity_type2id
def __init__(self, inSize, hidSize, outSize): # out size is usually class size super().__init__() bilstm = L.NStepBiLSTM(1, inSize, hidSize, dropout=0.3) linear = L.Linear(hidSize * 2, outSize) self.add_link('bilstm', bilstm) self.add_link('linear', linear)
def __init__(self, train=True): self.train = train super(Mynet, self).__init__() with self.init_scope(): self.h = L.NStepBiLSTM(n_layers=1, in_size=num_classes, out_size=128, dropout=0) self.out = L.Linear(None, num_classes)