def __init__(self,
rnn_type,
bidirectional,
num_layers,
hidden_size,
dropout=0.0,
embeddings=None,
use_bridge=False):
super(RNNEncoder, self).__init__()
assert embeddings is not None
num_directions = 2 if bidirectional else 1
assert hidden_size % num_directions == 0
hidden_size = hidden_size // num_directions
self.embeddings = embeddings
self.rnn, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=bidirectional)
self.auxi_lstm, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=bidirectional)
# Initialize the bridge layer
self.use_bridge = use_bridge
if self.use_bridge:
self._initialize_bridge(rnn_type, hidden_size, num_layers)
def __init__(self, cnn_kernel_width, rnn_type, enc_layers, dec_layers,
enc_rnn_size, dec_rnn_size, enc_pooling, dropout,
sample_rate, window_size):
super(CRNNEncoder, self).__init__()
self.cnn = ResNet(
BasicBlock, cnn_kernel_width, num_classes=enc_rnn_size
)
self.enc_layers = enc_layers
self.rnn_type = rnn_type
self.dec_layers = dec_layers
num_directions = 2
self.num_directions = num_directions
assert enc_rnn_size % num_directions == 0
enc_rnn_size_real = enc_rnn_size // num_directions
assert dec_rnn_size % num_directions == 0
self.dec_rnn_size = dec_rnn_size
dec_rnn_size_real = dec_rnn_size // num_directions
self.dec_rnn_size_real = dec_rnn_size_real
self.dec_rnn_size = dec_rnn_size
# input_size = int(math.floor((sample_rate * window_size) / 2) + 1)
# input_size = 1
enc_pooling = enc_pooling.split(',')
assert len(enc_pooling) == enc_layers or len(enc_pooling) == 1
if len(enc_pooling) == 1:
enc_pooling = enc_pooling * enc_layers
enc_pooling = [int(p) for p in enc_pooling]
self.enc_pooling = enc_pooling
if dropout > 0:
self.dropout = nn.Dropout(dropout)
else:
self.dropout = None
self.W = nn.Linear(enc_rnn_size, dec_rnn_size, bias=False)
self.batchnorm_0 = nn.BatchNorm1d(enc_rnn_size, affine=True)
self.rnn_0, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=enc_rnn_size,
hidden_size=enc_rnn_size_real,
num_layers=1,
dropout=dropout,
bidirectional=True)
self.pool_0 = nn.MaxPool1d(enc_pooling[0])
for l in range(enc_layers - 1):
batchnorm = nn.BatchNorm1d(enc_rnn_size, affine=True)
rnn, _ = \
rnn_factory(rnn_type,
input_size=enc_rnn_size,
hidden_size=enc_rnn_size_real,
num_layers=1,
dropout=dropout,
bidirectional=True)
setattr(self, 'rnn_%d' % (l + 1), rnn)
setattr(self, 'pool_%d' % (l + 1),
nn.MaxPool1d(enc_pooling[l + 1]))
setattr(self, 'batchnorm_%d' % (l + 1), batchnorm)
def __init__(self, rnn_type, enc_layers, dec_layers, brnn, enc_rnn_size,
dec_rnn_size, enc_pooling, dropout, sample_rate, window_size,
enc_input_size):
super(AudioEncoder, self).__init__()
self.enc_layers = enc_layers
self.rnn_type = rnn_type
self.dec_layers = dec_layers
num_directions = 2 if brnn else 1
self.num_directions = num_directions
assert enc_rnn_size % num_directions == 0
enc_rnn_size_real = enc_rnn_size // num_directions
assert dec_rnn_size % num_directions == 0
self.dec_rnn_size = dec_rnn_size
dec_rnn_size_real = dec_rnn_size // num_directions
self.dec_rnn_size_real = dec_rnn_size_real
self.dec_rnn_size = dec_rnn_size
input_size = enc_input_size
enc_pooling = enc_pooling.split(',')
assert len(enc_pooling) == enc_layers or len(enc_pooling) == 1
if len(enc_pooling) == 1:
enc_pooling = enc_pooling * enc_layers
enc_pooling = [int(p) for p in enc_pooling]
self.enc_pooling = enc_pooling
if type(dropout) is not list:
dropout = [dropout]
if max(dropout) > 0:
self.dropout = nn.Dropout(dropout[0])
else:
self.dropout = None
self.W = nn.Linear(enc_rnn_size, dec_rnn_size, bias=False)
self.batchnorm_0 = nn.BatchNorm1d(enc_rnn_size, affine=True)
self.rnn_0, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=input_size,
hidden_size=enc_rnn_size_real,
num_layers=1,
dropout=dropout[0],
bidirectional=brnn)
self.pool_0 = nn.MaxPool1d(enc_pooling[0])
for l in range(enc_layers - 1):
batchnorm = nn.BatchNorm1d(enc_rnn_size, affine=True)
rnn, _ = \
rnn_factory(rnn_type,
input_size=enc_rnn_size,
hidden_size=enc_rnn_size_real,
num_layers=1,
dropout=dropout[0],
bidirectional=brnn)
setattr(self, 'rnn_%d' % (l + 1), rnn)
setattr(self, 'pool_%d' % (l + 1),
nn.MaxPool1d(enc_pooling[l + 1]))
setattr(self, 'batchnorm_%d' % (l + 1), batchnorm)
def __init__(self, rnn_type, enc_layers, dec_layers, brnn,
enc_rnn_size, dec_rnn_size, enc_pooling, dropout,
sample_rate, window_size):
super(AudioEncoder, self).__init__()
self.enc_layers = enc_layers
self.rnn_type = rnn_type
self.dec_layers = dec_layers
num_directions = 2 if brnn else 1
self.num_directions = num_directions
assert enc_rnn_size % num_directions == 0
enc_rnn_size_real = enc_rnn_size // num_directions
assert dec_rnn_size % num_directions == 0
self.dec_rnn_size = dec_rnn_size
dec_rnn_size_real = dec_rnn_size // num_directions
self.dec_rnn_size_real = dec_rnn_size_real
self.dec_rnn_size = dec_rnn_size
input_size = int(math.floor((sample_rate * window_size) / 2) + 1)
enc_pooling = enc_pooling.split(',')
assert len(enc_pooling) == enc_layers or len(enc_pooling) == 1
if len(enc_pooling) == 1:
enc_pooling = enc_pooling * enc_layers
enc_pooling = [int(p) for p in enc_pooling]
self.enc_pooling = enc_pooling
if dropout > 0:
self.dropout = nn.Dropout(dropout)
else:
self.dropout = None
self.W = nn.Linear(enc_rnn_size, dec_rnn_size, bias=False)
self.batchnorm_0 = nn.BatchNorm1d(enc_rnn_size, affine=True)
self.rnn_0, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=input_size,
hidden_size=enc_rnn_size_real,
num_layers=1,
dropout=dropout,
bidirectional=brnn)
self.pool_0 = nn.MaxPool1d(enc_pooling[0])
for l in range(enc_layers - 1):
batchnorm = nn.BatchNorm1d(enc_rnn_size, affine=True)
rnn, _ = \
rnn_factory(rnn_type,
input_size=enc_rnn_size,
hidden_size=enc_rnn_size_real,
num_layers=1,
dropout=dropout,
bidirectional=brnn)
setattr(self, 'rnn_%d' % (l + 1), rnn)
setattr(self, 'pool_%d' % (l + 1),
nn.MaxPool1d(enc_pooling[l + 1]))
setattr(self, 'batchnorm_%d' % (l + 1), batchnorm)
def __init__(self,
rnn_type,
num_layers,
hidden_size,
dropout=0.0,
gnmt=False,
embeddings=None):
super(ResidualEncoder, self).__init__()
assert embeddings is not None
assert num_layers > 1
self.embeddings = embeddings
self.gnmt = gnmt
self.num_layers = num_layers
self.enc_reshape = True
self.layers = nn.ModuleList()
self.dropout = nn.Dropout(dropout)
bottom_layers = 1
if gnmt:
bi_rnn, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=1,
bidirectional=True)
rnn, _ = \
rnn_factory(rnn_type,
input_size=hidden_size*2,
hidden_size=hidden_size,
num_layers=1,
bidirectional=False)
self.layers.append(bi_rnn)
self.layers.append(rnn)
bottom_layers = 2
else:
rnn, self.no_pack_padded_seq=\
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=1,
bidirectional=False)
self.layers.append(rnn)
for i in range(num_layers - bottom_layers):
rnn, _= \
rnn_factory(rnn_type,
input_size=hidden_size,
hidden_size=hidden_size,
num_layers=1,
bidirectional=False)
self.layers.append(rnn)
def __init__(self,
rnn_type,
bidirectional,
num_layers,
hidden_size,
dropout=0.0,
embeddings=None,
use_bridge=False,
device="cpu"):
super(ConfnetEncoder, self).__init__()
assert embeddings is not None
self.embeddings = embeddings
self.thetav = nn.Linear(in_features=self.embeddings.embedding_size,
out_features=self.embeddings.embedding_size)
self.v_bar = nn.Linear(in_features=self.embeddings.embedding_size,
out_features=1)
num_directions = 2 if bidirectional else 1
assert hidden_size % num_directions == 0
hidden_size = hidden_size // num_directions
self.device = device
self.rnn, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=bidirectional)
# Initialize the bridge layer
self.use_bridge = use_bridge
if self.use_bridge:
self._initialize_bridge(rnn_type, hidden_size, num_layers)
def __init__(self,
rnn_type,
bidirectional,
num_layers,
hidden_size,
dropout=0.0,
embeddings=None,
use_bridge=False):
super(RNNEncoder, self).__init__()
assert embeddings is not None
num_directions = 2 if bidirectional else 1
assert hidden_size % num_directions == 0
hidden_size = hidden_size // num_directions
self.embeddings = embeddings
self.rnn, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=bidirectional)
self.linear = nn.Linear(hidden_size * 4 * num_directions, 2)
self.layer_norm = nn.LayerNorm(hidden_size * 4 * num_directions)
self.batch_norm = nn.BatchNorm1d(hidden_size * 4 * num_directions)
# Initialize the bridge layer
self.use_bridge = use_bridge
if self.use_bridge:
self._initialize_bridge(rnn_type, hidden_size, num_layers)
def __init__(self,
rnn_type,
bidirectional,
num_layers,
hidden_size,
dropout=0.0,
embeddings=None,
use_bridge=False):
super(TreeEncoder, self).__init__()
assert embeddings is not None
num_directions = 2 if bidirectional else 1
assert hidden_size % num_directions == 0
self.hidden_size = hidden_size // num_directions
self.input_size = embeddings.embedding_size
self.embeddings = embeddings
self.rnn, self.no_pack_padded_seq = rnn_factory(
rnn_type,
input_size=self.input_size,
hidden_size=self.hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=bidirectional)
self.treelstm = ChildSumTreeLSTM(rnn_type,
self.input_size,
self.hidden_size,
bias=True)
# Initialize the bridge layer
self.use_bridge = use_bridge
if self.use_bridge:
self._initialize_bridge(rnn_type, self.hidden_size, num_layers)
def __init__(self,
rnn_type,
bidirectional,
num_layers,
hidden_size,
dropout=0.0,
embeddings=None,
use_bridge=False,
output_word_final=False):
super(SeqHREncoder, self).__init__()
assert embeddings is not None
num_directions = 2 if bidirectional else 1
assert hidden_size % num_directions == 0
hidden_size = hidden_size // num_directions
self.embeddings = embeddings
self.word_rnn, self.word_no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=bidirectional)
assert not self.word_no_pack_padded_seq
self.sent_rnn, self.sent_no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=hidden_size * num_directions,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=bidirectional)
assert not self.sent_no_pack_padded_seq
# add by wchen
self.hidden_size = hidden_size
self.num_layers = num_layers
self.num_directions = num_directions
self.output_word_final = output_word_final
self.dropout = nn.Dropout(dropout)
# Initialize the bridge layer
self.use_bridge = use_bridge
if self.use_bridge:
self._initialize_bridge(rnn_type, hidden_size, num_layers)
def __init__(self,
wals_model,
rnn_type,
bidirectional,
num_layers,
hidden_size,
wals_size,
dropout=0.0,
embeddings=None,
use_bridge=False):
super(RNNEncoder, self).__init__()
assert embeddings is not None
num_directions = 2 if bidirectional else 1
assert hidden_size % num_directions == 0
hidden_size = hidden_size // num_directions
self.embeddings = embeddings
self.wals_model = wals_model
self.num_layers = num_layers
self.wals_size = wals_size
self.rnn, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=bidirectional)
if self.wals_model == 'WalstoSource_Target' or self.wals_model == 'WalstoSource_Both':
self.rnn_wals, self.no_pack_padded_seq_wals = \
rnn_factory(rnn_type,
input_size=hidden_size+2*self.wals_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=bidirectional)
# Initialize the bridge layer
self.use_bridge = use_bridge
if self.use_bridge:
self._initialize_bridge(rnn_type, hidden_size, num_layers)
def __init__(self,
rnn_type,
bidirectional,
num_layers,
hidden_size,
dropout=0.0,
embeddings=None,
use_bridge=False,
separate_layers=False):
super(RNNEncoder, self).__init__()
assert embeddings is not None
num_directions = 2 if bidirectional else 1
assert hidden_size % num_directions == 0
hidden_size = hidden_size // num_directions
self.embeddings = embeddings
self.separate_layers = separate_layers
if separate_layers:
layers = []
for n in range(num_layers):
layer_n, self.no_pack_padded_seq = rnn_factory(rnn_type,
input_size=(embeddings.embedding_size if n == 0 else \
hidden_size * (2 if bidirectional else 1)),
hidden_size=hidden_size,
num_layers=1,
dropout=dropout,
bidirectional=bidirectional)
layers.append(layer_n)
self.layers = nn.ModuleList(layers)
self.dropout = nn.Dropout(dropout)
else:
self.rnn, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=bidirectional)
# Initialize the bridge layer
self.use_bridge = use_bridge
if self.use_bridge:
self._initialize_bridge(rnn_type, hidden_size, num_layers)
def __init__(self, rnn_type, hidden_size, dropout=0.0, filed=None):
super(SpeakerGenerator, self).__init__()
num_directions = 2
assert hidden_size % num_directions == 0
hidden_size = hidden_size // num_directions
self.rnn, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=hidden_size*num_directions,
hidden_size=hidden_size,
num_layers=1,
dropout=dropout,
bidirectional=True)
self.out = nn.Bilinear(hidden_size, hidden_size, len(filed))
self.gen = nn.Sequential(Cast(torch.float32), nn.LogSoftmax(dim=-1))
def __init__(self, rnn_type, bidirectional, num_layers,
hidden_size, dropout=0.0, emb_size=300):
super(RNNEncoder, self).__init__()
num_directions = 2 if bidirectional else 1
assert hidden_size % num_directions == 0
hidden_size = hidden_size // num_directions
self.rnn, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=emb_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=bidirectional)
def __init__(self, rnn_type, bidirectional, num_layers,
hidden_size, single_enc_double_dec_layers, dropout=0.0, embeddings=None):
super(RNNEncoder, self).__init__()
assert embeddings is not None
num_directions = 2 if bidirectional else 1
if single_enc_double_dec_layers == False:
assert hidden_size % num_directions == 0
hidden_size = hidden_size // num_directions
self.enc_reshape = not single_enc_double_dec_layers
self.embeddings = embeddings
self.hidden_size=hidden_size
self.rnn, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=bidirectional)
def __init__(self, rnn_type, bidirectional, num_layers,
hidden_size, dropout=0.0, embeddings=None,
use_bridge=False, bidir_treelstm=False):
super(TreeLSTMEncoder, self).__init__()
assert embeddings is not None
num_directions = 2 if bidirectional else 1
assert hidden_size % num_directions == 0
hidden_size = hidden_size // num_directions
self.embeddings = embeddings
use_rnn = bidirectional
self.rnn = None
if use_rnn:
self.rnn, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=bidirectional)
self.bidir_treelstm = bidir_treelstm
if self.bidir_treelstm:
self.childsumtreelstm = ChildSumTreeLSTM(
embeddings.embedding_size,
embeddings.embedding_size//2)
self.topdown = TopDownTreeLSTM(
embeddings.embedding_size//2,
embeddings.embedding_size//2)
else:
self.childsumtreelstm = ChildSumTreeLSTM(
embeddings.embedding_size,
embeddings.embedding_size)
# Initialize the bridge layer
self.use_bridge = use_bridge
if self.use_bridge:
self._initialize_bridge(rnn_type,
hidden_size,
num_layers)
def __init__(self, rnn_type, bidirectional, num_layers,
hidden_size, dropout=0.0, embeddings=None, sel_classifier='simple_fc', detach_sel_probs=False):
super(RNNSelector, self).__init__()
assert embeddings is not None
assert bidirectional
num_directions = 2 if bidirectional else 1
assert hidden_size % num_directions == 0
hidden_size = hidden_size // num_directions
self.hidden_size = hidden_size
self.embeddings = embeddings
self.detach_sel_probs = detach_sel_probs
self.rnn, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout if num_layers > 1 else 0.0,
bidirectional=bidirectional)
# add a simplest classifier first to build the whole framework
# activation function: sigmoid
self.sel_classifier = sel_classifier
if sel_classifier == 'simple_fc':
self.word_feats_linear = nn.Linear(2 * hidden_size, hidden_size)
self.simple_classifier = nn.Linear(hidden_size, 1)
else:
# for complex_Nallapati classifier, refer to https://arxiv.org/pdf/1611.04230.pdf
self.word_feats_linear = nn.Linear(2 * hidden_size, hidden_size)
self.art_feats_linear = nn.Linear(2 * hidden_size, hidden_size)
self.w_content = nn.Linear(hidden_size, 1)
self.w_salience = nn.Linear(hidden_size, hidden_size, bias=False)
self.w_novelty = nn.Linear(hidden_size, hidden_size, bias=False)
self.dropout_m = nn.Dropout(p=dropout)
self.tanh = nn.Tanh()
self.sigmoid = nn.Sigmoid()
def __init__(self,
rnn_type,
bidirectional,
num_layers,
hidden_size,
input_size,
dropout=0.0):
super(FusionEncoder, self).__init__()
self.sort_data = True
num_directions = 2 if bidirectional else 1
assert hidden_size % num_directions == 0
hidden_size = hidden_size // num_directions
self.rnn, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=input_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=bidirectional)
def __init__(self, rnn_type, bidirectional, num_layers,
hidden_size, dropout=0.0, embeddings=None,
use_bridge=False, gcn_dropout=0.0,
gcn_edge_dropout=0.0, n_gcn_layers=1, activation='',
highway=''):
super(GCNEncoder, self).__init__()
assert embeddings is not None
num_directions = 2 if bidirectional else 1
assert hidden_size % num_directions == 0
hidden_size = hidden_size // num_directions
self.embeddings = embeddings
use_rnn = bidirectional
self.rnn = None
if use_rnn:
self.rnn, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=bidirectional)
self.gcn = GraphConvolution(embeddings.embedding_size,
embeddings.embedding_size,
gcn_dropout,
gcn_edge_dropout,
n_gcn_layers,
activation,
highway)
# Initialize the bridge layer
self.use_bridge = use_bridge
if self.use_bridge:
self._initialize_bridge(rnn_type,
hidden_size,
num_layers)
def __init__(self,
rnn_type,
bidirectional,
num_layers,
hidden_size,
dropout=0.0,
embeddings=None,
use_bridge=False):
super(RNNEncoder, self).__init__()
assert embeddings is not None
num_directions = 2 if bidirectional else 1
assert hidden_size % num_directions == 0
hidden_size = hidden_size // num_directions
self.embeddings = embeddings
self.rnn, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=num_layers, # this is 1.
dropout=dropout,
bidirectional=bidirectional)
# self.rnn is a LSTM(128, 256, bidirectional=True) # input dim; output dim;
# init another sentence-level layer: this is shared by all the sentences, why 4?
self.sent_rnn = nn.LSTM(4 * embeddings.embedding_size,
hidden_size,
num_layers=1,
dropout=dropout,
bidirectional=True)
# (512,256)
# import pdb;pdb.set_trace()
# Initialize the bridge layer
self.use_bridge = use_bridge
if self.use_bridge:
self._initialize_bridge(rnn_type, hidden_size, num_layers)
def _build_rnn(self, rnn_type, **kwargs):
rnn, _ = rnn_factory(rnn_type, **kwargs)
return rnn
def __init__(self, rnn_type, enc_layers, dec_layers, brnn, input_size,
enc_rnn_size, dec_rnn_size, enc_pooling, dropout, ctc_ratio,
tgt_vocab_size, sample_rate, window_size, ctc_out_layer):
super(AudioEncoder, self).__init__()
self.enc_layers = enc_layers
self.rnn_type = rnn_type
self.dec_layers = dec_layers
if ctc_out_layer == -1:
ctc_out_layer = enc_layers - 1
self.ctc_out_layer = ctc_out_layer
num_directions = 2 if brnn else 1
self.num_directions = num_directions
assert enc_rnn_size % num_directions == 0
enc_rnn_size_real = enc_rnn_size // num_directions
assert dec_rnn_size % num_directions == 0
self.dec_rnn_size = dec_rnn_size
dec_rnn_size_real = dec_rnn_size // num_directions
self.dec_rnn_size_real = dec_rnn_size_real
self.dec_rnn_size = dec_rnn_size
enc_pooling = enc_pooling.split(',')
assert len(enc_pooling) == enc_layers or len(enc_pooling) == 1
if len(enc_pooling) == 1:
enc_pooling = enc_pooling * enc_layers
enc_pooling = [int(p) for p in enc_pooling]
self.enc_pooling = enc_pooling
if dropout > 0:
self.dropout = nn.Dropout(dropout)
else:
self.dropout = None
self.W = nn.Linear(enc_rnn_size, dec_rnn_size, bias=False)
self.batchnorm_0 = nn.BatchNorm1d(enc_rnn_size, affine=True)
self.pyramid = False
enc_rnn_size_real_0 = enc_rnn_size_real
if self.pyramid:
enc_rnn_size_real_0 = enc_rnn_size_real / enc_pooling[0]
self.rnn_0, self.no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=input_size,
hidden_size=enc_rnn_size_real_0,
num_layers=1,
dropout=dropout,
bidirectional=brnn)
self.pool_0 = nn.MaxPool1d(enc_pooling[0])
for l in range(enc_layers - 1):
enc_rnn_size_real_l = enc_rnn_size_real
if self.pyramid:
enc_rnn_size_real_l = enc_rnn_size_real / enc_pooling[l]
batchnorm = nn.BatchNorm1d(enc_rnn_size, affine=True)
rnn, _ = \
rnn_factory(rnn_type,
input_size=enc_rnn_size,
hidden_size=enc_rnn_size_real_l,
num_layers=1,
dropout=dropout,
bidirectional=brnn)
setattr(self, 'rnn_%d' % (l + 1), rnn)
setattr(self, 'pool_%d' % (l + 1),
nn.MaxPool1d(enc_pooling[l + 1]))
setattr(self, 'batchnorm_%d' % (l + 1), batchnorm)
if ctc_ratio > 0:
gen_func = nn.LogSoftmax(dim=-1)
self.ctc_gen = nn.Sequential(
nn.Linear(enc_rnn_size, tgt_vocab_size), gen_func)
def _build_rnn(self, rnn_type, **kwargs):
rnn, _ = rnn_factory(rnn_type, **kwargs)
return rnn
def __init__(self, rnn_type, bidirectional, num_layers, hidden_size,
dropout, embeddings):
super(TGEncoder, self).__init__()
assert bidirectional
# In current version, only one BiGRU layer for context encoding, one BiGRU layer for title encoding
# one BiGRU layer for merging.
# We regard num_layers as 2 since context encoding and title encoding are at the same level.
assert num_layers == 2
self.rnn_type = rnn_type
hidden_size = hidden_size // 2
self.real_hidden_size = hidden_size
# self.no_pack_padded_seq = False
self.bidirectional = bidirectional
# TODO: set res_ratio as an argument
self.res_ratio = 0.5
self.embeddings = embeddings
# One BiGRU layer for context encoding
self.src_rnn, self.src_no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=1,
bidirectional=bidirectional)
# self.src_rnn = getattr(nn, rnn_type)(
# input_size=embeddings.embedding_size,
# hidden_size=hidden_size,
# num_layers=1,
# bidirectional=self.bidirectional)
# One BiGRU layer for title encoding
self.query_rnn, self.query_no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=embeddings.embedding_size,
hidden_size=hidden_size,
num_layers=1,
bidirectional=bidirectional)
# self.query_rnn = getattr(nn, rnn_type)(
# input_size=embeddings.embedding_size,
# hidden_size=hidden_size,
# num_layers=1,
# bidirectional=self.bidirectional)
# One BiGRU layer for merging
self.merge_rnn, self.merge_no_pack_padded_seq = \
rnn_factory(rnn_type,
input_size=4 * hidden_size,
hidden_size=hidden_size,
num_layers=1,
bidirectional=bidirectional)
# self.merge_rnn = getattr(nn, rnn_type)(
# input_size=4 * hidden_size,
# hidden_size=hidden_size,
# num_layers=1,
# bidirectional=self.bidirectional)
self.match_fc = nn.Linear(2 * hidden_size, 2 * hidden_size, bias=False)
self.dropout = nn.Dropout(p=dropout)