valid_set.append(data_set[v])
for t in np.random.randint(0, 450, 30):
test_set.append(data_set[t])
sequence_length = 401
input_size = 3
hidden_size = 16
num_layers = 1
batch_size = 1
num_epochs = 2
learning_rate = 0.0001
for ktr in range(1):
rnn = BiLSTM(input_size, hidden_size, num_layers, 1)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(rnn.parameters(), lr=learning_rate)
losses = []
ktr_in = 0
for epoch in range(num_epochs):
for img, lb in train_set:
img = np.array([
img,
], dtype=np.float)
img = torch.FloatTensor(img)
img = Variable(img) # .cuda()
# Forward + Backward + Optimize
optimizer.zero_grad()
output = rnn(img)
loss = criterion(
output, torch.FloatTensor(np.array([
train = True,
transform = torchvision.transforms.ToTensor(),
download = DOWNLOAD_MNIST,
)
test_data = dsets.MNIST(root='../LSTM/mnist', train=False)
train_loader = Data.DataLoader(dataset=train_data, \
batch_size=BATCH_SIZE, shuffle=True)
with torch.no_grad():
test_x = Variable(torch.unsqueeze(test_data.data, dim=1)).type(torch.FloatTensor)/255
test_y = test_data.targets
lstm = BiLSTM(INPUT_SIZE, HIDDEN_SIZE, NUM_LAYERS, 10).to(device)
optimizer = torch.optim.Adam(lstm.parameters(), lr=LR)
loss_func = nn.CrossEntropyLoss()
for epoch in range(EPOCH):
for step, (x, y) in enumerate(train_loader):
b_x = Variable(x.view(-1, TIME_STEP, INPUT_SIZE).to(device))
b_y = Variable(y.to(device))
output = lstm(b_x)
loss = loss_func(output, b_y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if step%50 == 0:
test_output = lstm(test_x.view(-1, TIME_STEP, INPUT_SIZE).to(device))
def main(config):
trainDataPath = config['data']['trainDataPath']
validDataPath = config['data']['validDataPath']
testDataPath = config['data']['testDataPath']
modelName = config['modelName']
batchSize = config['model']['batchSize']
epochNum = config['model']['epochNum']
earlyStop = config['model']['earlyStop']
learningRate = config['model']['learningRate']
modelSavePath = config['model']['modelSavePath']
#GPU/CPU
DEVICE = config['DEVICE']
trianDataset = NERDataset(trainDataPath, config)
validDataset = NERDataset(validDataPath, config)
testDataset = NERDataset(testDataPath, config)
trainIter = data.DataLoader(dataset=trianDataset,
batch_size=batchSize,
shuffle=True,
num_workers=4,
collate_fn=pad)
validIter = data.DataLoader(dataset=validDataset,
batch_size=batchSize,
shuffle=False,
num_workers=4,
collate_fn=pad)
testIter = data.DataLoader(dataset=testDataset,
batch_size=batchSize,
shuffle=False,
num_workers=4,
collate_fn=pad)
if modelName == 'bilstm':
net = BiLSTM(config)
train = bilstmTrain
eval = bilstmEval
if torch.cuda.device_count() > 1:
net = nn.DataParallel(net)
if modelName == 'bilstm_crf':
net = BiLSTM_CRF(config)
train = bilstmCRFTrain
eval = bilstmCRFEval
if modelName == 'transformer_crf':
net = Transformer_CRF(config)
train = transformerCRFTrain
eval = transformerCRFEval
if modelName == 'cnn':
net = CNN(config)
train = cnnTrain
eval = cnnEval
net = net.to(DEVICE)
lossFunction = nn.NLLLoss()
optimizer = optim.Adam(net.parameters(),
lr=learningRate,
betas=(0.9, 0.999),
eps=1e-08)
earlyNumber, beforeLoss, maxScore = 0, sys.maxsize, -1
#开始训练
for epoch in range(epochNum):
print('第%d次迭代: ' % epoch)
totalLoss = train(net,
trainIter,
optimizer=optimizer,
criterion=lossFunction,
DEVICE=DEVICE)
print('训练损失为: %f' % totalLoss)
totalLoss, f1Score = eval(net,
validIter,
criterion=lossFunction,
DEVICE=DEVICE)
if f1Score > maxScore:
maxScore = f1Score
torch.save(net.state_dict(), modelSavePath)
print('验证损失为:%f f1Score:%f / %f' % (totalLoss, f1Score, maxScore))
if f1Score < maxScore:
earlyNumber += 1
print('earyStop: %d/%d' % (earlyNumber, earlyStop))
else:
earlyNumber = 0
if earlyNumber >= earlyStop: break
print('\n')
#加载最优模型
net.load_state_dict(torch.load(modelSavePath))
totalLoss, f1Score = eval(net,
testIter,
criterion=lossFunction,
DEVICE=DEVICE)
print('测试损失为: %f, f1Score: %f' % (totalLoss, f1Score))
try:
for Ques_train, Ques_test in kf.split(Dataset):
count += 1
print("Fold ", count)
if count == 2:
#writeContentEmbeddings(model)
break
# define model
model = BiLSTM(embedding_dim=EMBEDDING_DIM, hidden_dim=HIDDEN_DIM, vocab_size=len(text_field.vocab), label_size=len(label_field.vocab)-1,\
use_gpu=USE_GPU, batch_size=BATCH_SIZE)
if USE_GPU:
model = model.to(DEVICE)
model.embeddings.weight.data.copy_(
torch.from_numpy(pretrained_embeddings))
optimizer = optim.Adam(model.parameters(), lr=1e-3)
trainset = torch.utils.data.TensorDataset(
torch.LongTensor(Dataset[Ques_train]),
torch.torch.LongTensor(Dataset[Ques_train]))
testset = torch.utils.data.TensorDataset(
torch.LongTensor(Dataset[Ques_test]),
torch.torch.LongTensor(Dataset[Ques_test]))
train_loader = torch.utils.data.DataLoader(dataset=trainset,
batch_size=64)
test_loader = torch.utils.data.DataLoader(dataset=testset,
batch_size=BATCH_SIZE,
shuffle=False)
