def __init__(self, args, emb=None):
super(AdvSeqLabel, self).__init__(args)
vocab_size = args["vocab_size"]
word_emb_dim = args["word_emb_dim"]
hidden_dim = args["rnn_hidden_units"]
num_classes = args["num_classes"]
dropout = args['dropout']
self.Embedding = encoder.embedding.Embedding(vocab_size,
word_emb_dim,
init_emb=emb)
self.norm1 = torch.nn.LayerNorm(word_emb_dim)
# self.Rnn = encoder.lstm.LSTM(word_emb_dim, hidden_dim, num_layers=2, dropout=dropout, bidirectional=True)
self.Rnn = torch.nn.LSTM(input_size=word_emb_dim,
hidden_size=hidden_dim,
num_layers=2,
dropout=dropout,
bidirectional=True,
batch_first=True)
self.Linear1 = encoder.Linear(hidden_dim * 2, hidden_dim * 2 // 3)
self.norm2 = torch.nn.LayerNorm(hidden_dim * 2 // 3)
# self.batch_norm = torch.nn.BatchNorm1d(hidden_dim * 2 // 3)
self.relu = torch.nn.LeakyReLU()
self.drop = torch.nn.Dropout(dropout)
self.Linear2 = encoder.Linear(hidden_dim * 2 // 3, num_classes)
self.Crf = decoder.CRF.ConditionalRandomField(
num_classes, include_start_end_trans=False)
def __init__(self, args,emb=None):
super(Trigger_extraction,self).__init__(args)
vocab_size = args["vocab_size"]
word_emb_dim = args["word_emb_dim"]
hidden_dim = args["rnn_hidden_units"]
num_classes = args["num_classes"]
self.Embedding = encoder.embedding.Embedding(vocab_size, word_emb_dim, init_emb=emb)
self.Rnn = encoder.lstm.Lstm(word_emb_dim, hidden_dim, num_layers=1, dropout=0.2, bidirectional=True)
self.Linear1 = encoder.Linear(hidden_dim * 2, hidden_dim)
self.batch_norm = torch.nn.BatchNorm1d(hidden_dim)
self.relu = torch.nn.ReLU()
self.drop = torch.nn.Dropout(0.5)
self.Linear2 = encoder.Linear(hidden_dim, num_classes)
self.Crf = decoder.CRF.ConditionalRandomField(num_classes)
def __init__(self, **kwargs):
super(ESIM, self).__init__()
self.vocab_size = kwargs["vocab_size"]
self.embed_dim = kwargs["embed_dim"]
self.hidden_size = kwargs["hidden_size"]
self.batch_first = kwargs["batch_first"]
self.dropout = kwargs["dropout"]
self.n_labels = kwargs["num_classes"]
self.gpu = kwargs["gpu"] and torch.cuda.is_available()
self.drop = nn.Dropout(self.dropout)
self.embedding = Encoder.Embedding(
self.vocab_size,
self.embed_dim,
dropout=self.dropout,
init_emb=kwargs["init_embedding"]
if "inin_embedding" in kwargs.keys() else None,
)
self.embedding_layer = Encoder.Linear(self.embed_dim, self.hidden_size)
self.encoder = Encoder.LSTM(input_size=self.embed_dim,
hidden_size=self.hidden_size,
num_layers=1,
bias=True,
batch_first=self.batch_first,
bidirectional=True)
self.bi_attention = Aggregator.Bi_Attention()
self.mean_pooling = Aggregator.MeanPoolWithMask()
self.max_pooling = Aggregator.MaxPoolWithMask()
self.inference_layer = Encoder.Linear(self.hidden_size * 4,
self.hidden_size)
self.decoder = Encoder.LSTM(input_size=self.hidden_size,
hidden_size=self.hidden_size,
num_layers=1,
bias=True,
batch_first=self.batch_first,
bidirectional=True)
self.output = Decoder.MLP(
[4 * self.hidden_size, self.hidden_size, self.n_labels],
'tanh',
dropout=self.dropout)
def __init__(self, args,emb=None):
super(Argument_extraction,self).__init__()
vocab_size = args["vocab_size"]
word_emb_dim = args["word_emb_dim"]
hidden_dim = args["rnn_hidden_units"]
num_classes = args["num_classes"]
self.Embedding = encoder.embedding.Embedding(vocab_size, word_emb_dim, init_emb=emb)
self.Rnn = encoder.lstm.Lstm(word_emb_dim, hidden_dim, num_layers=1, dropout=0.2, bidirectional=True)
self.Linear1 = encoder.Linear(hidden_dim * 4, hidden_dim)
self.batch_norm = torch.nn.BatchNorm1d(hidden_dim)
self.relu = torch.nn.ReLU()
self.drop = torch.nn.Dropout(0.5)
self.Linear2 = encoder.Linear(hidden_dim, num_classes)
self.CrossEn= torch.nn.CrossEntropyLoss(reduce=False)
def __init__(self,
src_vocab_size,
src_max_seq_len,
tgt_vocab_size,
tgt_max_seq_len,
num_layers=6,
model_dim=512,
num_heads=8,
dropout=0.5):
super(Transformer, self).__init__()
# no support for pre-trained embedding currently
"""
self.embed = encoder.Embedding(embed_num, embed_dim)
self.conv_pool = encoder.ConvMaxpool(
in_channels=embed_dim,
out_channels=kernel_nums,
kernel_sizes=kernel_sizes,
padding=padding)
"""
self.src_max_seq_len = src_max_seq_len
self.tgt_max_seq_len = tgt_max_seq_len
self.src_seq_embedding = nn.Embedding(src_vocab_size + 1,
model_dim,
padding_idx=0)
self.src_pos_embedding = PositionalEncoding(model_dim, src_max_seq_len)
self.tgt_seq_embedding = nn.Embedding(tgt_vocab_size + 1,
model_dim,
padding_idx=0)
self.tgt_pos_embedding = PositionalEncoding(model_dim, tgt_max_seq_len)
self.src_dropout = nn.Dropout(dropout)
self.tgt_dropout = nn.Dropout(dropout)
self.enc = encoder.TransformerEncoder(
num_layers=num_layers,
input_size=model_dim,
output_size=model_dim,
key_size=int(model_dim / num_heads),
value_size=int(model_dim / num_heads),
num_atte=num_heads)
self.dec = decoder.TransformerDecoder(
num_layers=num_layers,
input_size=model_dim,
output_size=model_dim,
key_size=int(model_dim / num_heads),
value_size=int(model_dim / num_heads),
num_atte=num_heads)
self.linear = encoder.Linear(model_dim, tgt_vocab_size)
self.softmax = nn.Softmax(dim=1)
def __init__(self, args, init_embedding=None):
super(SNLI, self).__init__()
self.vocab_size = args["vocab_size"]
self.embed_dim = args["embed_dim"]
self.hidden_size = args["hidden_size"]
self.batch_first = args["batch_first"]
self.dropout = args["dropout"]
self.n_labels = args["num_classes"]
self.gpu = args["gpu"] and torch.cuda.is_available()
self.embedding = Encoder.embedding.Embedding(self.vocab_size,
self.embed_dim,
init_emb=init_embedding,
dropout=self.dropout)
self.embedding_layer = Encoder.Linear(self.embed_dim, self.hidden_size)
self.encoder = Encoder.LSTM(input_size=self.embed_dim,
hidden_size=self.hidden_size,
num_layers=1,
bias=True,
batch_first=self.batch_first,
bidirectional=True)
self.inference_layer = Encoder.Linear(self.hidden_size * 4,
self.hidden_size)
self.decoder = Encoder.LSTM(input_size=self.hidden_size,
hidden_size=self.hidden_size,
num_layers=1,
bias=True,
batch_first=self.batch_first,
bidirectional=True)
self.output = Decoder.MLP(
[4 * self.hidden_size, self.hidden_size, self.n_labels], 'tanh')
def __init__(self,
embed_num,
embed_dim,
num_classes,
kernel_nums=(3, 4, 5),
kernel_sizes=(3, 4, 5),
padding=0,
dropout=0.5):
super(CNNText, self).__init__()
# no support for pre-trained embedding currently
self.embed = encoder.Embedding(embed_num, embed_dim)
self.conv_pool = encoder.ConvMaxpool(in_channels=embed_dim,
out_channels=kernel_nums,
kernel_sizes=kernel_sizes,
padding=padding)
self.dropout = nn.Dropout(dropout)
self.fc = encoder.Linear(sum(kernel_nums), num_classes)
def __init__(self, args):
super(SeqLabelingForSLSTM, self).__init__()
vocab_size = args["vocab_size"]
word_emb_dim = args["word_emb_dim"]
hidden_dim = args["rnn_hidden_units"]
num_classes = args["num_classes"]
init_emb = args["init_embedding"]
print("num_classes:%d" % num_classes)
#self.Embedding = encoder.Embedding(vocab_size, word_emb_dim)
#self.Rnn = encoder.LSTM(word_emb_dim, hidden_dim)
self.Rnn = SLSTM(word_emb_dim,
hidden_dim,
num_layer=1,
Tar_emb=init_emb,
return_all=False)
self.Linear = encoder.Linear(hidden_dim, num_classes)
self.Crf = decoder.CRF.ConditionalRandomField(num_classes)
self.mask = None
