def add_pretrain(self, vocabulary, vocabulary_inv):
print 'model_variaton:', self.model_variation
if self.model_variation == 'pretrain':
embedding_weights = load_word2vec(self.pretrain_type,
vocabulary_inv,
self.embedding_dim)
elif self.model_variation == 'random':
embedding_weights = None
else:
raise ValueError('Unknown model variation')
self.embedding_weights = embedding_weights
self.vocab_size = len(vocabulary)
def eval(fold_ix=1):
test_data = data.Data(
fold=fold_ix, is_test_data=True
) # the dataset merges self.real_U_file and self.fake_U_file
test_data_loader = DataLoader(test_data,
batch_size=50,
shuffle=True,
num_workers=8)
# self.discriminator(validation_data_loader)
X_trn, Y_trn, Y_trn_o, X_tst, Y_tst, Y_tst_o, vocabulary, vocabulary_inv = data_helpers.load_data(
fold=fold_ix)
X_trn = X_trn.astype(np.int32)
X_tst = X_tst.astype(np.int32)
Y_trn = Y_trn.astype(np.int32)
Y_tst = Y_tst.astype(np.int32)
args.num_classes = Y_trn.shape[1]
embedding_weights = load_word2vec('glove',
vocabulary_inv,
num_features=300)
capsule_net = CapsNet_Text(args, embedding_weights)
path = 'save/model/fold' + str(fold_ix) + '/nlp-capsule50.pth'
capsule_net.load_state_dict(torch.load(path))
# discriminator.eval()
with torch.no_grad():
for _, (input, labels) in enumerate(test_data_loader):
# input, labels = input, labels
_, preds = capsule_net(
input, labels) # (None, vocab_size, sequence_len+1)
# print('preds without round: ' , preds.squeeze(2))
preds = preds.round().squeeze(2)
# print('input : ', input)
# print('preds squeeze 2 : ', preds)
# print('labels: ', labels)
# print('preds 0: ' , preds.shape[0])
# print('preds 1: ' , preds.shape[1])
# print('labels 0: ', labels.shape[0])
# print('labels 1: ', labels.shape[1])
report = metrics.classification_report(labels, preds)
print('report on fold ' + str(fold_ix) + ': ')
print(report)
def add_pretrain(self, vocabulary, vocabulary_inv):
print('model_variaton:', self.model_variation)
if self.model_variation == 'pretrain':
embedding_weights = load_word2vec(self.pretrain_type,
vocabulary_inv,
self.embedding_dim)
elif self.model_variation == 'random':
embedding_weights = None
else:
raise ValueError('Unknown model variation')
self.embedding_weights = embedding_weights
self.vocab_size = len(vocabulary)
self.embedding = nn.Embedding(num_embeddings=self.vocab_size,
embedding_dim=self.embedding_dim)
if self.model_variation == "pretrain":
self.embedding.weight.data.copy_(
torch.from_numpy(embedding_weights).type(torch.FloatTensor))
self.embedding.weight.requires_grad = False
elif self.model_variation != 'random':
raise NotImplementedError('Unknown model_variation')
# train_one_step(model_shared, model_PDN, PDN_Trloader, args, device, optimizer, current_lr, criterion_bce, "bce")
# test_loss_minPDN, Accs = test_one_step_multilabel(model_shared, model_PDN, PDN_Teloader, args, device, test_loss_minPDN, criterion_bce)
# if test_loss_min<test_loss_flag:
# final = Accs
# test_loss_flag = test_loss_min
# return final, test_loss_flag
if __name__ == "__main__":
print("==== Loading Data ...")
# train_set, test_set, dict_word, dict_word_reverse, seq_length_words, vocab_size = load_data(args)
Sent_Train, Sent_Test, PND_Train, PND_Test, dict_word, dict_word_reverse, vocab_size = load_data(
args)
embedding_weights = load_word2vec('glove', dict_word, args.embedding_dim)
# fw_res = open("res.txt","w")
device = torch.device("cuda")
model_input = MTL_Input(args, device, vocab_size, embedding_weights)
model_shared = SoGMTL(args, device)
# model_shared = CNN_base(args, device, vocab_size, embedding_weights)
model_Sent = Sent_NN(args, output_dim=6)
model_PDN = PDN_NN(args, output_dim=5)
model_parameters = []
model_parameters_input = filter(lambda p: p.requires_grad,
model_input.parameters())
model_parameters_shared = filter(lambda p: p.requires_grad,
model_shared.parameters())
model_parameters_Sent = filter(lambda p: p.requires_grad,
Epochs=list(range(1, num_epochs+1))
Loss_data = {'Epochs': Epochs, 'Loss': Loss}
df = pd.DataFrame(Loss_data, columns = ['Epochs', 'Loss'])
df.to_csv(path)
X_trn, Y_trn, X_tst, Y_tst, vocabulary, vocabulary_inv = datasets.get_cross_domain_doctor_doctor()
X_trn = X_trn.astype(np.int32)
X_tst = X_tst.astype(np.int32)
Y_trn = Y_trn.astype(np.int32)
Y_tst = Y_tst.astype(np.int32)
args.num_classes = Y_trn.shape[1]
embedding_weights = load_word2vec('glove', vocabulary_inv, num_features=300)
capsule_net = CapsNet_Text(args, embedding_weights)
current_lr = args.learning_rate
optimizer = Adam(capsule_net.parameters(), lr=current_lr)
# capsule_net = nn.DataParallel(capsule_net).cuda()
losses = []
for epoch in range(args.num_epochs):
# torch.cuda.empty_cache()
nr_trn_num = X_trn.shape[0]
nr_batches = int(np.ceil(nr_trn_num / float(args.tr_batch_size)))
if epoch > args.learning_rate_decay_start and args.learning_rate_decay_start >= 0:
args = parser.parse_args()
params = vars(args)
print(json.dumps(params, indent = 2))
X_trn, Y_trn, Y_trn_o, X_tst, Y_tst, Y_tst_o, vocabulary, vocabulary_inv = data_helpers.load_data(args.dataset,
max_length=args.sequence_length,
vocab_size=args.vocab_size)
Y_trn = Y_trn.toarray()
Y_tst = Y_tst.toarray()
X_trn = X_trn.astype(np.int32)
X_tst = X_tst.astype(np.int32)
Y_trn = Y_trn.astype(np.int32)
Y_tst = Y_tst.astype(np.int32)
embedding_weights = load_word2vec('glove', vocabulary_inv, args.vec_size)
args.num_classes = Y_trn.shape[1]
capsule_net = CapsNet_Text(args, embedding_weights)
capsule_net = nn.DataParallel(capsule_net).cuda()
def transformLabels(labels):
label_index = list(set([l for _ in labels for l in _]))
label_index.sort()
variable_num_classes = len(label_index)
target = []
for _ in labels:
tmp = np.zeros([variable_num_classes], dtype=np.float32)
