def initialize_model(opt, src, tgt, train): # build vocabulary src.build_vocab(train.dataset, max_size=opt.src_vocab) tgt.build_vocab(train.dataset, max_size=opt.tgt_vocab) input_vocab = src.vocab output_vocab = tgt.vocab # Initialize model hidden_size = opt.hidden_size decoder_hidden_size = hidden_size * 2 if opt.bidirectional else hidden_size encoder = EncoderRNN(len(src.vocab), opt.max_len, hidden_size, opt.embedding_size, dropout_p=opt.dropout_p_encoder, n_layers=opt.n_layers, bidirectional=opt.bidirectional, rnn_cell=opt.rnn_cell, variable_lengths=True) decoder = DecoderRNN( len(tgt.vocab), opt.max_len, decoder_hidden_size, dropout_p=opt.dropout_p_decoder, n_layers=opt.n_layers, use_attention=opt.attention, attention_method=opt.attention_method, use_positional_attention=opt.positional_attention, bidirectional=opt.bidirectional, rnn_cell=opt.rnn_cell, eos_id=tgt.eos_id, sos_id=tgt.sos_id, positioning_generator_size=opt.positioning_generator_size, attention_mixer=opt.attention_mixer) # initialize weights using uniform distribution def uniform_weights_init(m): if isinstance(m, nn.LSTM): for name, param in m.named_parameters(): if 'bias' in name: nn.init.constant_(param, 0.0) elif 'weight' in name: nn.init.uniform_(param, -opt.param_init, opt.param_init) if isinstance(m, nn.Linear) or isinstance(m, nn.Embedding): nn.init.uniform_(m.weight, -opt.param_init, opt.param_init) if opt.param_init > 0.0: encoder.apply(uniform_weights_init) decoder.apply(uniform_weights_init) seq2seq = Seq2seq(encoder, decoder) if torch.cuda.device_count() > 1: logging.info("Using {} GPUs".format(torch.cuda.device_count())) seq2seq = nn.DataParallel(seq2seq) # xavier initialization if flag if opt.param_init_glorot: for p in seq2seq.parameters(): if p.dim() > 1: nn.init.xavier_uniform_(p) seq2seq.to(device) return seq2seq, input_vocab, output_vocab
test_size = test_df.shape[0] y_true = [] y_pred = [] for iter in range(0, test_size + 1): sentence = test_df.iloc[iter - 1]["description"] sentence = normalizeString(sentence) input_tensor = embeddedTensorFromSentence(sentence, device, word_emb, N_word) target_class = test_df.iloc[iter - 1]["department_new"] class_index = [] target_index = class_dict[target_class] #print(target_index) y_true.append(target_index) output = evaluate(encoder, decoder, input_tensor, max_length, device) topv, topi = output.topk(1) y_pred.append(topi.numpy()[0][0]) cnf_matrix = confusion_matrix(y_true, y_pred) print("Accuarcy") print(accuracy_score(y_true, y_pred)) print(cnf_matrix) encoder = EncoderRNN(N_word, hidden_size).to(device) encoder.apply(init_weights) decoder = DecoderRNN(hidden_size, CLASS_size).to(device) decoder.apply(init_weights) n_iterations = train_df.shape[0] trainIters(encoder, decoder, n_iterations, print_every=50, plot_every=10) print(classes_) evaluateTest(encoder, decoder)