def trainModel(model,
EPOCH,
train_data,
test_data,
criterion,
optimizer,
RESULTS_PATH,
scheduler=None,
MODEL_PATH=None):
total = int(ceil(len(train_data) / BATCH_SIZE))
# print(total)
for epoch in range(EPOCH):
losses = []
model.train()
for i, batch in enumerate(getBatch(train_data, BATCH_SIZE)):
view_bar(i, total, epoch + 1)
sents, target = list(zip(*batch))
inputs = torch.cat([prepare_seq(sent, word2idx) for sent in sents])
targets = torch.cat([prepare_tag(tag, tag2idx) for tag in target])
# print(inputs.shape, targets.shape)
model.zero_grad()
preds = model(inputs, is_training=True)
loss = criterion(preds, targets)
losses.append(loss.data.tolist())
loss.backward()
optimizer.step()
if scheduler:
scheduler.step()
print("\t mean_loss : %0.2f" % np.mean(losses), end='')
losses = []
testModel(test_data)
def trainModel(model, train_data, valid_data, BATCH_SIZE, SEQ_LENGTH, EPOCH):
model.train()
for epoch in range(EPOCH):
losses = []
total = ceil((train_data.size(1) - SEQ_LENGTH) / SEQ_LENGTH)
hidden = model.hidden_init(BATCH_SIZE)
for i, batch in enumerate(getBatch(train_data, SEQ_LENGTH)):
view_bar(i, total, epoch + 1, EPOCH)
inputs, targets = batch
hidden = model.detach_hidden(hidden)
model.zero_grad()
preds, hidden = model(inputs, hidden, True)
loss = criterion(preds, targets.reshape(-1))
losses.append(loss.data)
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
optimizer.step()
print("\tmean loss : %0.2f" % np.mean(losses), end='\t')
losses = []
testModel(model, valid_data, BATCH_SIZE, SEQ_LENGTH)
def testModel(testSet):
model.eval()
hidden = model.init_hidden(BATCH_SIZE // 2)
with torch.no_grad():
losses = []
for i, batch in enumerate(getBatch(trainSet, SEQ_LENGTH)):
inputs, targets = batch
hidden = model.detach_hidden(hidden)
model.zero_grad()
preds, hidden = model(inputs, hidden)
loss = inputs.size(1) * criterion(preds, targets.view(-1)).data
losses.append(loss)
print("\ttest_loss : %0.2f" % np.mean(losses))
losses = []
def testModel(model, test_data, BATCH_SIZE, SEQ_LENGTH):
model.eval()
with torch.no_grad():
hidden = model.hidden_init(BATCH_SIZE)
criterion = nn.CrossEntropyLoss()
losses = []
for i, batch in getBatch(test_data, SEQ_LENGTH):
inputs, targets = batch
hidden = model.detach_hidden(hidden)
model.zero_grad()
preds, hidden = model(test_data, hidden)
loss = criterion(preds, targets.reshape(-1))
losses.append(loss.data)
print("test loss : %0.2f" % np.mean(losses))
def trainModel(train_data):
losses = []
for epoch in range(EPOCH):
for i, batch in enumerate(getBatch(train_data, BATCH_SIZE)):
inputs, targets, coocs, weights = zip(*batch)
inputs = torch.cat(inputs)
targets = torch.cat(targets)
coocs = torch.cat(coocs)
weights = torch.cat(weights)
model.zero_grad()
loss = model(inputs, targets, coocs, weights)
loss.backward()
optimizer.step()
losses.append(loss.data.tolist())
if epoch % 10 == 0:
print("Epoch : %d, mean_loss : %.02f" % (epoch, np.mean(losses)))
losses = []
vocab = creatVocab(corpus)
word2idx, idx2word = word2index(vocab)
train_data = creatTrainData(corpus)
unigram_table = creatUnigramable(corpus, vocab)
losses = []
model = Skipgram(len(word2idx), EMBEDDING_SIZE).to(device)
optimizer = optim.Adam(model.parameters(), lr = learning_rate)
start_time = time.clock()
for epoch in range(EPOCH):
for i, batch in enumerate(getBatch(train_data, BATCH_SIZE)):
inputs, targets = zip(*batch)
inputs = torch.cat(inputs) # B X 1
targets = torch.cat(targets) # B X 1
if negativeSample:
vocabs = negative_sample(targets, unigram_table, word2idx, negSampleNum)
else:
vocabs = prepare_sequence(list(vocab), word2idx).expand(len(inputs), len(vocab))
model.zero_grad()
loss = model(inputs, targets, vocabs)