def get_rnn_classifer(bptt, max_seq, n_class, n_tok, emb_sz, n_hid, n_layers, pad_token, layers, drops, bidir=False, dropouth=0.3, dropouti=0.5, dropoute=0.1, wdrop=0.5): rnn_enc = MultiBatchRNN(bptt, max_seq, n_tok, emb_sz, n_hid, n_layers, pad_token=pad_token, bidir=bidir, dropouth=dropouth, dropouti=dropouti, dropoute=dropoute, wdrop=wdrop) s2s_dec = DecoderRNN() return SequentialRNN(rnn_enc, s2s_dec)
plot_loss_total += loss if iter % print_every == 0: print_loss_avg = print_loss_total / print_every print_loss_total = 0 print('%s (Batch_no: %d %d%%) %.4f' % (timeSince( start, iter / 5), n_iters / 5, iter / 5 * 100, print_loss_avg)) loss_all += print_loss_avg plot_loss_avg = plot_loss_total / plot_every plot_loss_total = 0 hidden_size = 2046 encoder1 = EncoderRNN(2046, hidden_size) attn_decoder1 = DecoderRNN(hidden_size, caption_list.n_words) if use_cuda: encoder1 = encoder1.cuda() attn_decoder1 = attn_decoder1.cuda() # encoder1.load_state_dict(torch.load('encoder.pt')) # attn_decoder1.load_state_dict(torch.load('decoder.pt')) def evaluate(encoder, decoder, vid_ID, max_length=MAX_LENGTH): input_variable, empty = variableFromId(vid_ID) input_length = len(input_variable) encoder_hidden = encoder.initHidden() # encoder_outputs = Variable(torch.zeros(max_length, encoder.hidden_size))
from torch import optim import torch.nn.functional as F from preprocess import get_dataset from utils.transformer import * import argparse from seq2seq import EncoderRNN, DecoderRNN , Linear device = 'cpu' #*********************** #*******IMPORTANT******* #*********************** #PLEASE NOTE THE VALUE = 2 or 1 for input_size GIVEN BELOW IS JUST FOR TESTING PURPOSES. PLEASE DO NOT HARDCODE ANY VALUES IN YOUR seq2seq.py file torch.manual_seed(0) encoder = EncoderRNN(hidden_size = 1, input_size = 1, batch_size = 1) decoder = DecoderRNN(hidden_size = 1, output_size = 2, batch_size = 1) dense = Linear(bidirectional = False, hidden_size_encoder = 1 , hidden_size_decoder = 1) dense2 = Linear(bidirectional = False, hidden_size_encoder = 2 , hidden_size_decoder = 1) layers = [encoder, decoder , dense] layers_individual = [] for layer in layers: for name,module in layer.named_modules(): if(name==''): continue else: layers_individual.append([name,module])
output_words = evaluate(encoder, decoder, pair[0]) output_sentence = ' '.join(output_words) print('<', output_sentence) score, b2, b3, b4 = BLEU_score(pair[1], output_sentence[:-6]) print(score) print(b2) print(b3) print(b4) total += score print('') print('Avg. score is:') print(total / 50) hidden_size = 2046 encoder1 = EncoderRNN(2046, hidden_size) attn_decoder1 = DecoderRNN(hidden_size, caption_list.n_words) if use_cuda: encoder1 = encoder1.cuda() attn_decoder1 = attn_decoder1.cuda() encoder1.load_state_dict(torch.load('encoder.pt')) attn_decoder1.load_state_dict(torch.load('decoder.pt')) ###################################################################### # evaluateRandomly(encoder1, attn_decoder1) print('Done')
vocab = build_vocab(cleaned_news, cleaned_summaries, min_freq=3) # 生成 dataset 是DataTensor 格式 news_dataset = build_dataset(vocab, cleaned_news, config['max_len_news'], type='news') summaries_dataset = build_dataset(vocab, cleaned_summaries, config['max_len_summaries'], type='summaries') # 合并在一起 dataset = TensorDataset(news_dataset, summaries_dataset) # 加载预训练的word2vec模型(使用搜狗新闻训练得到的word2vec),维度是300 pre_embeddings = get_pretrained_embedding(config['pretrained_vector_path'], vocab, vector_dim=300).to(device) # 构建模型,选择隐状态和词向量维度相同,都是300 vocab_size = len(vocab) # encoder 使用的是单层双向gru encoder = EncoderRNN(vocab_size, 300, 300, n_layers=1, pre_embeddings=pre_embeddings) # decoder 使用双层单项gru decoder = DecoderRNN(vocab_size, 300, 300, n_layers=2, pre_embeddings=pre_embeddings) # 迁移到cuda上,training 要用 encoder.to(device) decoder.to(device) # 训练模型 training(encoder, decoder, dataset, vocab, config['lr'], config['batch_size'], config['epochs'])
def build_model(self): class MLP(nn.Module): def __init__(self, dims): super(MLP, self).__init__() self.hidden = nn.ModuleList() for k in range(len(dims) - 1): self.hidden.append(nn.Linear(dims[k], dims[k + 1])) def forward(self, x): for layer in self.hidden[:-1]: x = F.relu(layer(x)) output = self.hidden[-1](x.float()) return output # A2V aud_input_MLP = MLP([self.feat_dim, self.hidden_dim, self.hidden_dim]) phn_encoder = EncoderRNN(self.hidden_dim, self.seq_len, self.hidden_dim, input_dropout_p=self.dropout_rate, dropout_p=self.dropout_rate, n_layers=self.enc_num_layers, bidirectional=True, rnn_cell='gru', variable_lengths=True) spk_encoder = EncoderRNN(self.hidden_dim, self.seq_len, self.hidden_dim, input_dropout_p=self.dropout_rate, dropout_p=self.dropout_rate, n_layers=self.enc_num_layers, bidirectional=True, rnn_cell='gru', variable_lengths=True) aud_decoder = DecoderRNN(self.hidden_dim * 4, self.seq_len, self.hidden_dim * 4, n_layers=self.dec_num_layers, rnn_cell='gru', bidirectional=True, input_dropout_p=self.dropout_rate, dropout_p=self.dropout_rate) aud_output_MLP = MLP( [self.hidden_dim * 4, self.hidden_dim, self.feat_dim]) # a2v = A2VwD(input_MLP, phn_encoder, spk_encoder, decoder, output_MLP, self.dec_num_layers) # T2V if self.unit_type == 'char': txt_feat_dim = 27 else: txt_feat_dim = 60 txt_input_MLP = MLP([txt_feat_dim, self.hidden_dim]) txt_encoder = EncoderRNN(self.hidden_dim, self.seq_len, self.hidden_dim, n_layers=1, bidirectional=True, rnn_cell='gru', variable_lengths=True) txt_decoder = DecoderRNN(self.hidden_dim * 2, self.seq_len, self.hidden_dim * 2, n_layers=1, rnn_cell='gru', bidirectional=True) txt_output_MLP = MLP([self.hidden_dim * 2, txt_feat_dim]) # t2v = A2V(txt_input_MLP, txt_encoder, txt_decoder, txt_output_MLP, 1) # size of discriminator input = num_directions * p_hidden_dim # discriminator = FCDiscriminator(2*self.hidden_dim, self.hidden_dim, self.D_num_layers) # the whole model if self.weight_x == 0.: if_x = False else: if_x = True self.model = Model(aud_input_MLP, phn_encoder, spk_encoder, aud_decoder, aud_output_MLP, self.dec_num_layers, txt_input_MLP, txt_encoder, txt_decoder, txt_output_MLP, 1, if_x, self.neg_num) self.model.to(device)
bidirectional = config.getboolean("bidirectional") trainset, source_vocab, target_vocab = get_dataset( types="train", batch_size=int(config["batch_size"]), shuffle=True, num_workers=int(config["num_workers"]), pin_memory=False, drop_last=True) encoder1 = EncoderRNN(int(config["hidden_size_encoder"]), len(source_vocab) + 2, int(config["batch_size"]), num_layers=int(config["num_layer_encoder"]), bidirectional=bidirectional).to(device) bridge = Linear(bidirectional, int(config["hidden_size_encoder"]), int(config["hidden_size_decoder"])).to(device) decoder1 = DecoderRNN(int(config["hidden_size_decoder"]), len(target_vocab) + 2, int(config["batch_size"]), num_layers=int(config["num_layer_decoder"])).to(device) trainIters(trainset, encoder1, decoder1, bridge, num_epochs=int(config["num_epoch"]), batch_size=int(config["batch_size"]), print_every=10, device=device) torch.save(encoder1, "encoder.pt") torch.save(decoder1, "decoder.pt") torch.save(bridge, "bridge.pt")
seen_aux = 0 for word in sent: if seen_aux: if word in ["do", "does", "don't", "doesn't"]: return word else: if word in ["do", "does", "don't", "doesn't"]: seen_aux = 1 # Where the actual running of the code happens hidden_size = int(sys.argv[6]) # Default 128 encoder1 = EncoderRNN(input_lang.n_words, hidden_size, recurrent_unit) decoder1 = DecoderRNN(hidden_size, output_lang.n_words, recurrent_unit, attn=attention, n_layers=1, dropout_p=0.1) if use_cuda: encoder1 = encoder1.cuda() decoder1 = decoder1.cuda() counter = 0 direcs_to_process = 1 lines = open(testFile, encoding='utf-8').read().strip().split('\n') test_pairs = [[normalizeString(s) for s in l.split('\t')] for l in lines] length_sorted_pairs_dict = {} for i in range(30): length_sorted_pairs_dict[i] = []