def __init__(self,
attn_model,
embedding,
hidden_size,
output_size,
n_layers=1,
dropout=0.1):
super(LuongAttnDecoderRNN, self).__init__()
# Keep for reference
self.attn_model = attn_model
self.hidden_size = hidden_size
self.output_size = output_size
self.n_layers = n_layers
self.dropout = dropout
# Define layers
self.embedding = embedding
self.embedding_dropout = nn.Dropout(dropout)
self.gru = nn.GRU(hidden_size,
hidden_size,
n_layers,
dropout=(0 if n_layers == 1 else dropout))
self.concat = nn.Linear(hidden_size * 2, hidden_size)
self.out = nn.Linear(hidden_size, output_size)
# attention layer
self.attn = Attn(attn_model, hidden_size)
def __init__(self, rnn_type, attn_model, embedding_dim, hidden_dim, output_size, n_layers=1, dropout=0.5):
super(LuongAttnDecoderRNN, self).__init__()
# Keep for reference
self.rnn_type = rnn_type
self.attn_model = attn_model
self.hidden_dim = hidden_dim
self.output_size = output_size
self.vocab_size = output_size
self.n_layers = n_layers
self.dropout = dropout
self.embedding_dim = embedding_dim
# Define layers
self.embeddings = nn.Embedding(output_size, embedding_dim)
self.embedding_dropout = nn.Dropout(dropout)
if self.rnn_type in ['LSTM', 'GRU']:
self.rnn = getattr(nn, self.rnn_type)(embedding_dim, hidden_dim, n_layers, dropout=dropout)
self.concat = nn.Linear(hidden_dim * 2, hidden_dim)
self.out = nn.Linear(hidden_dim, output_size)
# Choose attention model
print(attn_model)
if attn_model != 'none':
self.attn = Attn(attn_model, hidden_dim)
def __init__(self,
rnn_type,
embedding_dim,
hidden_dim,
vocab_size,
max_seq_len,
n_layers=1,
dropout=0.1,
word_dropout=None):
super(CustomAttnDecoderRNN, self).__init__()
self.hidden_dim = hidden_dim # same hidden dim
self.embedding_dim = embedding_dim # same emb dim
self.max_seq_len = max_seq_len
self.vocab_size = vocab_size
self.rnn_type = rnn_type
self.n_layers = n_layers
if self.rnn_type in ['CustomLSTM', 'CustomGRU']:
#self.rnn = getattr(nn, rnn_type)(embedding_dim, hidden_dim, n_layers, dropout=dropout)
if self.rnn_type == 'CustomGRU':
#cell = CustomGRUCell(embedding_dim, hidden_dim)
self.rnn = CustomGRU(CustomGRUCell,
embedding_dim,
hidden_dim,
n_layers,
dropout=dropout)
else:
raise
self.attn = Attn('concat', hidden_dim)
##self.attn = Attn('concat', hidden_dim, max_seq_len)
self.rnn2out = nn.Linear(hidden_dim, vocab_size)
self.drop = nn.Dropout(dropout)
self.dropout = dropout
self.word_dropout = word_dropout
def __init__(self, hidden_size, output_size, dropout_p=0.1):
super(AttnDecoder, self).__init__()
self.attn_model = Attn('general', 64)
self.hidden_size = hidden_size
self.output_size = output_size
self.dropout_p = dropout_p
self.embedding = nn.Embedding(output_size, hidden_size)
self.dropout = nn.Dropout(dropout_p)
self.attn = Attn('concat', hidden_size)
self.lstm = nn.LSTM(input_size=hidden_size,
hidden_size=hidden_size,
num_layers=1,
dropout=dropout_p)
self.out = nn.Linear(hidden_size, output_size)
self.softmax = nn.LogSoftmax()
def __init__(self, hidden_size, output_size, method, num_layers=1):
super(Decoder, self).__init__()
self.hidden_size = hidden_size
self.output_size = output_size
self.num_layers = num_layers
self.method = method
self.embedding = nn.Embedding(output_size, hidden_size)
self.lstm = nn.LSTM(input_size=hidden_size,
hidden_size=hidden_size,
num_layers=num_layers,
batch_first=True)
self.lstm = self.lstm.to(device)
self.attn = Attn(method, hidden_size)
self.concat = nn.Linear(hidden_size * 2, hidden_size)
self.tanh = nn.Tanh()
self.out = nn.Linear(hidden_size, output_size)
self.softmax = nn.LogSoftmax(dim=1)
def __init__(self,
attn_model,
embedding_dim,
hidden_size,
output_size,
unit='gru',
n_layers=1,
dropout=0.1,
embedding=None,
latent_dim=300,
bidirectional=True):
super(DecoderRNN, self).__init__()
self.unit = unit
self.softmax = F.softmax
self.n_layers = n_layers
self.attn_model = attn_model
self.latent_dim = latent_dim
self.hidden_size = hidden_size
self.output_size = output_size
self.bidirectional = bidirectional
self.embedding_dropout = nn.Dropout(dropout)
self.dropout = (0 if n_layers == 1 else dropout)
self.out = nn.Linear(self.hidden_size, self.output_size)
if embedding:
self.embedding = embedding
if unit == 'gru':
self.rnn = nn.GRU(embedding_dim,
hidden_size,
n_layers,
dropout=self.dropout)
else:
self.rnn = nn.LSTM(embedding_dim,
hidden_size,
n_layers,
dropout=self.dropout)
self.concat = nn.Linear(hidden_size * 2, hidden_size)
if attn_model:
self.attn = Attn(attn_model, hidden_size)
def __init__(self, rnn_type, embedding_dim, hidden_dim, output_size, n_layers=1, dropout=0.1):
super(BahdanauAttnDecoderRNN, self).__init__()
# Define parameters
self.rnn_type = rnn_type
self.hidden_size = hidden_dim
self.output_size = output_size
self.vocab_size = output_size
self.n_layers = n_layers
self.dropout = dropout
self.embedding_dim = embedding_dim
# Define layers
self.embeddings = nn.Embedding(output_size, embedding_dim)
self.embedding_dropout = nn.Dropout(dropout)
self.attn = Attn('concat', hidden_dim)
#self.gru = nn.GRU(hidden_size, hidden_size, n_layers, dropout=dropout_p)
if self.rnn_type in ['LSTM', 'GRU']:
#self.rnn = getattr(nn, rnn_type)(embedding_dim, hidden_dim, n_layers, dropout=dropout)
self.rnn = getattr(nn, self.rnn_type)(embedding_dim+hidden_dim, hidden_dim, n_layers, dropout=dropout)
#self.out = nn.Linear(hidden_dim, output_size)
self.out = nn.Linear(hidden_dim*2, output_size)
def __init__(self,
input_size,
hidden_size,
batch_size,
learning_rate,
method,
num_layers=1):
dataset = Seq2SeqDataset()
self.data_loader = DataLoader(dataset=dataset,
batch_size=batch_size,
shuffle=True)
self.vocab = dataset.vocab
self.output_size = len(self.vocab)
self.char2index, self.index2char = self.data_index()
self.input_size = input_size
self.hidden_size = hidden_size
self.batch_size = batch_size
self.learning_rate = learning_rate
self.num_layers = 1
self.method = method
self.device = 'cuda:0' if torch.cuda.is_available() else 'cpu'
self.attn = Attn(method, hidden_size)
self.encoder = Encoder(input_size, hidden_size, self.output_size,
self.num_layers)
self.decoder = Decoder(hidden_size, self.output_size, method,
self.num_layers)
self.attn = self.attn.to(self.device)
self.encoder = self.encoder.to(self.device)
self.decoder = self.decoder.to(self.device)
self.loss_function = NLLLoss()
self.encoder_optim = torch.optim.Adam(self.encoder.parameters(),
lr=self.learning_rate)
self.decoder_optim = torch.optim.Adam(self.decoder.parameters(),
lr=self.learning_rate)
return loss.data[0], decoder_outputs
def train(self):
for j in range(self.num_epoch):
for i, (x_data, y_data) in enumerate(self.data_loader):
loss, result = self.step(x_data, y_data)
_, x = self.step(['Be fair.'], ['Sois équitable !'])
print('Epoch' , j)
print(x)
print('-------> ', self.convert2ind('Sois équitable !').cpu().numpy()[0])
trans = Translate()
encoder_input = trans.convert2ind('Lâche')
encoder_output, (hidden_state, cell_state) = trans.encoder(encoder_input)
attn = Attn('general', trans.hidden_size)
energy = attn(hidden_state, encoder_output)
print(energy)
print(energy.size())