class Predictor:
def __init__(self, ckpt_path):
super().__init__()
self.transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize(256),
transforms.ToTensor()
])
self.checkpoint = torch.load(ckpt_path)
self.model = CNN()
self.model.load_state_dict(state_dict=self.checkpoint['state_dict'])
self.use_cuda = False
self.model.eval()
if torch.cuda.is_available():
self.model.cuda()
self.use_cuda = True
def run(self, path):
img = self.transform(io.imread(path))
img.unsqueeze_(0)
if self.use_cuda:
img = img.cuda()
with torch.no_grad():
pred = self.model(img)
return pred.item()
def bilstm_train(self, numEpochs, batch_size, save_file, lr):
print('training .....')
# set up loss function -- 'SVM Loss' a.k.a ''Cross-Entropy Loss
loss_func = nn.CrossEntropyLoss()
net = CNN(embed_dim=100)
# net.load_state_dict(torch.load('model_50.pth'))
# SGD used for optimization, momentum update used as parameter update
optimization = torch.optim.SGD(net.parameters(), lr=lr, momentum=0.9)
net.cuda()
loss_func.cuda()
train_losses = []
test_losses = []
for epoch in range(0,numEpochs):
# training set -- perform model training
epoch_training_loss = 0.0
num_batches = 0
pbar = tqdm(range(0, len(self.train_seqs), batch_size))
for batch_num in pbar: # 'enumerate' is a super helpful function
# split training data into inputs and labels
if batch_num+batch_size>len(self.train_seqs):
end = len(self.action_seqs)
else:
end = batch_num+batch_size
raw_inputs, labels_ = self.train_seqs[batch_num:end], self.train_labels[batch_num:end] # 'training_batch' is a list
inputs_ = self.get_embedding(raw_inputs)
inputs = torch.from_numpy(inputs_).float().cuda()
labels = torch.from_numpy(labels_).cuda()
# wrap data in 'Variable'
inputs, labels = torch.autograd.Variable(inputs), torch.autograd.Variable(labels)
# Make gradients zero for parameters 'W', 'b'
optimization.zero_grad()
# forward, backward pass with parameter update
forward_output = net(inputs)
loss = loss_func(forward_output, labels)
loss.backward()
optimization.step()
# calculating loss
epoch_training_loss += loss.data.item()
num_batches += 1
# print(loss.data.item())
pbar.set_description("processing batch %s" % str(batch_num))
print("epoch: ", epoch, ", loss: ", epoch_training_loss / num_batches)
# train_loss = self.test(net, batch_size=256, test_data=self.train_seqs, test_label=self.train_labels)
test_loss = self.test(net, batch_size=256, test_data=self.test_seqs, test_label=self.test_labels)
# train_losses.append(train_loss)
test_losses.append(test_loss)
# if epoch%10 == 0:
# save_path = save_file+'model3_' +str(epoch)+'.pth'
# torch.save(net.state_dict(), save_path)
# with open('train_loss_1.p','wb') as fin:
# pickle.dump(train_losses,fin)
# fin.close()
with open('test_loss_1.p','wb') as fin:
pickle.dump(test_losses,fin)
fin.close()
def predict(img_dir='./data/test'):
transforms = Compose([Resize(height, weight), ToTensor()])
dataset = CaptchaData(img_dir, transform=transforms)
cnn = CNN()
if torch.cuda.is_available():
cnn = cnn.cuda()
cnn.eval()
cnn.load_state_dict(torch.load(model_path))
for k, (img, target) in enumerate(dataset):
img = img.view(1, 3, height, weight).cuda()
target = target.view(1, 4 * 36).cuda()
output = cnn(img)
output = output.view(-1, 36)
target = target.view(-1, 36)
output = nn.functional.softmax(output, dim=1)
output = torch.argmax(output, dim=1)
target = torch.argmax(target, dim=1)
output = output.view(-1, 4)[0]
target = target.view(-1, 4)[0]
print('pred: ' + ''.join([alphabet[i] for i in output.cpu().numpy()]))
print('true: ' + ''.join([alphabet[i] for i in target.cpu().numpy()]))
plot.imshow(img.permute((0, 2, 3, 1))[0].cpu().numpy())
plot.show()
if k >= 10: break
def post_predict():
text = "failure"
if request.method == 'POST':
file = request.get_data()
img = Image.open(BytesIO(file)).convert('RGB')
print('宽：%d,高：%d' % (img.size[0], img.size[1]))
width = img.size[0]
height = img.size[1]
transform = Compose([Resize(height, width), ToTensor()])
img = transform(img)
cnn = CNN()
if torch.cuda.is_available():
cnn = cnn.cuda()
cnn.eval()
cnn.load_state_dict(torch.load(model_path, map_location='cpu'))
img = img.view(1, 3, height, width).cuda()
output = cnn(img)
output = output.view(-1, 36)
output = nn.functional.softmax(output, dim=1)
output = torch.argmax(output, dim=1)
output = output.view(-1, 4)[0]
text = ''.join([alphabet[i] for i in output.cpu().numpy()])
# print('pred: '+text)
# plot.imshow(img.permute((0, 2, 3, 1))[0].cpu().numpy())
# plot.show()
return text
def load_net():
global model_net
model_net = CNN(num_class=len(alphabet),
num_char=int(numchar),
width=width,
height=height)
if use_gpu:
model_net = model_net.cuda()
model_net.eval()
model_net.load_state_dict(torch.load(model_path))
else:
model_net.eval()
model_net.load_state_dict(torch.load(model_path, map_location='cpu'))
def predict(img_dir=Path('./captcha')):
transforms = Compose([ToTensor()])
for i in img_dir.glob("*png"):
print(i.name)
img = img_loader('./captcha/%s' % i.name)
img = transforms(img)
cnn = CNN()
if torch.cuda.is_available():
cnn = cnn.cuda()
cnn.load_state_dict(torch.load(model_path))
img = img.view(1, 3, 36, 120).cuda()
output = cnn(img)
output = output.view(-1, 36)
output = nn.functional.softmax(output, dim=1)
output = torch.argmax(output, dim=1)
output = output.view(-1, num_class)[0]
pred = ''.join([alphabet[i] for i in output.cpu().numpy()])
print(pred)
def init_model(nfm=32,
res_blocks=1,
in_frames=2,
batch_size=2,
epoch_to_load=None):
resnet = ResNet(nfm*2, res_blocks)
if torch.cuda.is_available(): resnet=resnet.cuda()
my_unet = U_Net(nfm, resnet, 1, 1)
discriminator = CNN((in_frames+1)*3, nfm, 512)
if epoch_to_load != None:
my_unet = torch.load('unet_epoch_{}'.format(epoch_to_load))
discriminator = torch.load('D_epoch_{}'.format(epoch_to_load))
if torch.cuda.is_available(): my_unet, discriminator = my_unet.cuda(), discriminator.cuda()
Unet_optim = torch.optim.Adam(my_unet.parameters(), lr=0.002)
D_optim = torch.optim.Adam(discriminator.parameters(), lr=0.002)
return {'Unet': my_unet, 'Discriminator': discriminator, 'Unet_optimizer': Unet_optim, 'Discriminator_optimizer': D_optim}
batch_size = 100
writer.add_scalar("Batch_Size", batch_size)
num_epochs = 2
writer.add_scalar("Number_of_Epochs", num_epochs)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
batch_size=batch_size,
shuffle=False)
model = CNN()
if torch.cuda.is_available():
model.cuda()
criterion = nn.CrossEntropyLoss()
learning_rate = 0.1
writer.add_scalar("Learning_Rate", learning_rate)
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
train(train_loader, test_loader, model, optimizer, criterion)
# torch.save(model, "./CNN.pt")
# model2 = torch.load("./CNN.pt")
# torch.save(model.state_dict(), "./CNN_State.pt")
# model2 = CNN()
# model2.load_state_dict(torch.load("./CNN_State.pt"))
# torch.save({
def main(args):
# hyperparameters
batch_size = args.batch_size
num_workers = 1
# Image Preprocessing
transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
])
# load COCOs dataset
IMAGES_PATH = 'data/train2014'
CAPTION_FILE_PATH = 'data/annotations/captions_train2014.json'
vocab = load_vocab()
train_loader = get_coco_data_loader(path=IMAGES_PATH,
json=CAPTION_FILE_PATH,
vocab=vocab,
transform=transform,
batch_size=batch_size,
shuffle=True,
num_workers=num_workers)
IMAGES_PATH = 'data/val2014'
CAPTION_FILE_PATH = 'data/annotations/captions_val2014.json'
val_loader = get_coco_data_loader(path=IMAGES_PATH,
json=CAPTION_FILE_PATH,
vocab=vocab,
transform=transform,
batch_size=batch_size,
shuffle=True,
num_workers=num_workers)
losses_val = []
losses_train = []
# Build the models
ngpu = 1
initial_step = initial_epoch = 0
embed_size = args.embed_size
num_hiddens = args.num_hidden
learning_rate = 1e-3
num_epochs = 3
log_step = args.log_step
save_step = 500
checkpoint_dir = args.checkpoint_dir
encoder = CNN(embed_size)
decoder = RNN(embed_size,
num_hiddens,
len(vocab),
1,
rec_unit=args.rec_unit)
# Loss
criterion = nn.CrossEntropyLoss()
if args.checkpoint_file:
encoder_state_dict, decoder_state_dict, optimizer, *meta = utils.load_models(
args.checkpoint_file, args.sample)
initial_step, initial_epoch, losses_train, losses_val = meta
encoder.load_state_dict(encoder_state_dict)
decoder.load_state_dict(decoder_state_dict)
else:
params = list(decoder.parameters()) + list(
encoder.linear.parameters()) + list(encoder.batchnorm.parameters())
optimizer = torch.optim.Adam(params, lr=learning_rate)
if torch.cuda.is_available():
encoder.cuda()
decoder.cuda()
if args.sample:
return utils.sample(encoder, decoder, vocab, val_loader)
# Train the Models
total_step = len(train_loader)
try:
for epoch in range(initial_epoch, num_epochs):
for step, (images, captions,
lengths) in enumerate(train_loader, start=initial_step):
# Set mini-batch dataset
images = utils.to_var(images, volatile=True)
captions = utils.to_var(captions)
targets = pack_padded_sequence(captions,
lengths,
batch_first=True)[0]
# Forward, Backward and Optimize
decoder.zero_grad()
encoder.zero_grad()
if ngpu > 1:
# run on multiple GPU
features = nn.parallel.data_parallel(
encoder, images, range(ngpu))
outputs = nn.parallel.data_parallel(
decoder, features, range(ngpu))
else:
# run on single GPU
features = encoder(images)
outputs = decoder(features, captions, lengths)
train_loss = criterion(outputs, targets)
losses_train.append(train_loss.data[0])
train_loss.backward()
optimizer.step()
# Run validation set and predict
if step % log_step == 0:
encoder.batchnorm.eval()
# run validation set
batch_loss_val = []
for val_step, (images, captions,
lengths) in enumerate(val_loader):
images = utils.to_var(images, volatile=True)
captions = utils.to_var(captions, volatile=True)
targets = pack_padded_sequence(captions,
lengths,
batch_first=True)[0]
features = encoder(images)
outputs = decoder(features, captions, lengths)
val_loss = criterion(outputs, targets)
batch_loss_val.append(val_loss.data[0])
losses_val.append(np.mean(batch_loss_val))
# predict
sampled_ids = decoder.sample(features)
sampled_ids = sampled_ids.cpu().data.numpy()[0]
sentence = utils.convert_back_to_text(sampled_ids, vocab)
print('Sample:', sentence)
true_ids = captions.cpu().data.numpy()[0]
sentence = utils.convert_back_to_text(true_ids, vocab)
print('Target:', sentence)
print(
'Epoch: {} - Step: {} - Train Loss: {} - Eval Loss: {}'
.format(epoch, step, losses_train[-1], losses_val[-1]))
encoder.batchnorm.train()
# Save the models
if (step + 1) % save_step == 0:
utils.save_models(encoder, decoder, optimizer, step, epoch,
losses_train, losses_val, checkpoint_dir)
utils.dump_losses(
losses_train, losses_val,
os.path.join(checkpoint_dir, 'losses.pkl'))
except KeyboardInterrupt:
pass
finally:
# Do final save
utils.save_models(encoder, decoder, optimizer, step, epoch,
losses_train, losses_val, checkpoint_dir)
utils.dump_losses(losses_train, losses_val,
os.path.join(checkpoint_dir, 'losses.pkl'))
def train():
transforms = Compose([Resize((height, width)), ToTensor()])
train_dataset = CaptchaData(train_data_path, num_class=len(alphabet), num_char=int(numchar), transform=transforms, alphabet=alphabet)
train_data_loader = DataLoader(train_dataset, batch_size=batch_size, num_workers=num_workers,
shuffle=True, drop_last=True)
test_data = CaptchaData(test_data_path, num_class=len(alphabet), num_char=int(numchar), transform=transforms, alphabet=alphabet)
test_data_loader = DataLoader(test_data, batch_size=batch_size,
num_workers=num_workers, shuffle=True, drop_last=True)
cnn = CNN(num_class=len(alphabet), num_char=int(numchar), width=width, height=height)
if use_gpu:
cnn.cuda()
optimizer = torch.optim.Adam(cnn.parameters(), lr=base_lr)
criterion = nn.MultiLabelSoftMarginLoss()
for epoch in range(max_epoch):
start_ = time.time()
loss_history = []
acc_history = []
cnn.train()
for img, target in train_data_loader:
img = Variable(img)
target = Variable(target)
if use_gpu:
img = img.cuda()
target = target.cuda()
output = cnn(img)
loss = criterion(output, target)
optimizer.zero_grad()
loss.backward()
optimizer.step()
acc = calculat_acc(output, target)
acc_history.append(float(acc))
loss_history.append(float(loss))
print('epoch:{},train_loss: {:.4}|train_acc: {:.4}'.format(
epoch,
torch.mean(torch.Tensor(loss_history)),
torch.mean(torch.Tensor(acc_history)),
))
loss_history = []
acc_history = []
cnn.eval()
for img, target in test_data_loader:
img = Variable(img)
target = Variable(target)
if torch.cuda.is_available():
img = img.cuda()
target = target.cuda()
output = cnn(img)
acc = calculat_acc(output, target)
acc_history.append(float(acc))
loss_history.append(float(loss))
print('test_loss: {:.4}|test_acc: {:.4}'.format(
torch.mean(torch.Tensor(loss_history)),
torch.mean(torch.Tensor(acc_history)),
))
print('epoch: {}|time: {:.4f}'.format(epoch, time.time() - start_))
torch.save(cnn.state_dict(), os.path.join(model_path, "model_{}.path".format(epoch)))
def main(args):
# hyperparameters
batch_size = args.batch_size
num_workers = 2
# Image Preprocessing
transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
])
vocab = load_vocab()
loader = get_basic_loader(dir_path=os.path.join(args.image_path),
transform=transform,
batch_size=batch_size,
shuffle=False,
num_workers=num_workers)
# Build the models
embed_size = args.embed_size
num_hiddens = args.num_hidden
checkpoint_path = 'checkpoints'
encoder = CNN(embed_size)
decoder = RNN(embed_size,
num_hiddens,
len(vocab),
1,
rec_unit=args.rec_unit)
encoder_state_dict, decoder_state_dict, optimizer, *meta = utils.load_models(
args.checkpoint_file)
encoder.load_state_dict(encoder_state_dict)
decoder.load_state_dict(decoder_state_dict)
if torch.cuda.is_available():
encoder.cuda()
decoder.cuda()
# Train the Models
try:
results = []
with torch.no_grad():
for step, (images, image_ids) in enumerate(tqdm(loader)):
images = utils.to_var(images)
features = encoder(images)
captions = beam_sample(decoder, features)
# captions = decoder.sample(features)
captions = captions.cpu().data.numpy()
captions = [
utils.convert_back_to_text(cap, vocab) for cap in captions
]
captions_formatted = [{
'image_id': int(img_id),
'caption': cap
} for img_id, cap in zip(image_ids, captions)]
results.extend(captions_formatted)
print('Sample:', captions_formatted[0])
except KeyboardInterrupt:
print('Ok bye!')
finally:
import json
file_name = 'captions_model.json'
with open(file_name, 'w') as f:
json.dump(results, f)
from models import CNN
from datasets import img_loader
from torchvision.transforms import Compose, ToTensor
from train import num_class
from pathlib import Path
model_path = './checkpoints/model.pth'
source = [str(i) for i in range(0, 10)]
source += [chr(i) for i in range(97, 97 + 26)]
alphabet = ''.join(source)
transforms = Compose([ToTensor()])
img = img_loader('captcha_test/captcha_crop.png')
img = transforms(img)
cnn = CNN()
if torch.cuda.is_available():
cnn = cnn.cuda()
cnn.load_state_dict(torch.load(model_path))
print("---------")
img = img.view(1, 3, 36, 120).cuda()
output = cnn(img)
output = output.view(-1, 36)
output = nn.functional.softmax(output, dim=1)
output = torch.argmax(output, dim=1)
output = output.view(-1, num_class)[0]
pred = ''.join([alphabet[i] for i in output.cpu().numpy()])
print(pred)
# =============================================================================
# SET TRAINING PARAMETER
# =============================================================================
n_epochs = 5000
batch_size_train = 32
batch_size_test = 1000
learning_rate = 0.01
momentum = 0.5
weight_decay = .001
random_seed = 1
torch.backends.cudnn.enabled = True
torch.manual_seed(random_seed)
network = CNN()
network.cuda()
gpu_available = "GPU available?: " + str(torch.cuda.is_available())
using_cuda = "Network using cuda?: " + str(next(network.parameters()).is_cuda)
print(gpu_available)
print(using_cuda)
logging.info("\n\n------------------------------------------------------")
logging.info(gpu_available)
logging.info(using_cuda)
logging.info(\
f"""\n\nNetwork Details:
n_epochs = {n_epochs}
batch_size_train = {batch_size_train}
fname = "models/gsCNN_" + args.data + str(args.kernelg) + "_" + str(
args.kernels) + "_" + str(args.num_filters) + "_" + str(
args.batch_size) + "_" + str(args.rate) + ".model"
elif args.model == "gmsCNN":
model = gmsCNN(kernelg=args.kernelg,
kernels=args.kernels,
kernel=args.kernel,
num_filters=args.num_filters,
rate=args.rate)
fname = "models/gmsCNN_" + args.data + str(args.kernel) + "_" + str(
args.kernelg) + "_" + str(args.kernels) + "_" + str(
args.num_filters) + "_" + str(args.batch_size) + "_" + str(
args.rate) + ".model"
if args.gpu:
model = model.cuda()
# Training setup
L = t.nn.CrossEntropyLoss()
optimizer = t.optim.Adam(model.parameters(), lr=args.learn_rate)
if not os.path.exists("models"):
os.makedirs("models")
# load to continue with pre-existing model
if os.path.exists(fname):
model.load_state_dict(t.load(fname))
print("Successfully loaded previous model " + str(fname))
# start with a model defined on 0
# train_mix, test, train_data, train_labels = dataFetch()
params = {'LR': LR, 'VOCAB_SIZE': VOCAB_SIZE, 'NO_WORD_EMBEDDINGS': NO_WORD_EMBEDDINGS, 'HIDDEN_SIZE': HIDDEN_SIZE,
'BATCH_SIZE': BATCH_SIZE, 'NUM_LAYERS': NUM_LAYERS, 'train_imagepaths_and_captions': train_imagepaths_and_captions,
'val_imagepaths_and_captions': val_imagepaths_and_captions, 'pretrained_cnn_dir': pretrained_cnn_dir,
'pretrained_word_embeddings_file': pretrained_word_embeddings_file, 'transform_train': transform_train,
'transform_val': transform_val, 'WEIGHT_DECAY': WEIGHT_DECAY, 'ADAM_FLAG': ADAM_FLAG, 'RNN_DROPOUT':RNN_DROPOUT,
'CNN_DROPOUT': CNN_DROPOUT, 'GRAD_CLIP': GRAD_CLIP}
print('Initializing models...')
encoder = CNN(NO_WORD_EMBEDDINGS, pretrained_cnn_dir, freeze=True, dropout_prob=CNN_DROPOUT, model_name='resnet152')
decoder = RNN(VOCAB_SIZE, NO_WORD_EMBEDDINGS, hidden_size=HIDDEN_SIZE, num_layers=NUM_LAYERS,
pre_trained_file=pretrained_word_embeddings_file, freeze=False, dropout_prob=RNN_DROPOUT)
params['encoder'] = encoder
params['decoder'] = decoder
encoder.cuda()
decoder.cuda()
print('Initializing optimizer...')
model_paras = list(encoder.parameters()) + list(decoder.parameters())
optimizer = optim.Adam(model_paras, lr=LR, weight_decay=WEIGHT_DECAY)
params['optimizer'] = optimizer
pickle.dump(params, open(init_params_file, 'wb'))
# initialize accumulators.
current_epoch = 1
batch_step_count = 1
time_used_global = 0.0
def train():
transforms = Compose([ToTensor()])
train_dataset = CaptchaData('./data/train', transform=transforms)
train_data_loader = DataLoader(train_dataset,
batch_size=batch_size,
num_workers=0,
shuffle=True,
drop_last=True)
test_data = CaptchaData('./data/test', transform=transforms)
test_data_loader = DataLoader(test_data,
batch_size=batch_size,
num_workers=0,
shuffle=True,
drop_last=True)
cnn = CNN()
if torch.cuda.is_available():
cnn.cuda()
if restor:
cnn.load_state_dict(torch.load(model_path))
# freezing_layers = list(cnn.named_parameters())[:10]
# for param in freezing_layers:
# param[1].requires_grad = False
# print('freezing layer:', param[0])
optimizer = torch.optim.Adam(cnn.parameters(), lr=base_lr)
criterion = nn.MultiLabelSoftMarginLoss()
for epoch in range(max_epoch):
start_ = time.time()
loss_history = []
acc_history = []
cnn.train()
for img, target in train_data_loader:
img = Variable(img)
target = Variable(target)
if torch.cuda.is_available():
img = img.cuda()
target = target.cuda()
output = cnn(img)
loss = criterion(output, target)
optimizer.zero_grad()
loss.backward()
optimizer.step()
acc = calculat_acc(output, target)
acc_history.append(acc)
loss_history.append(loss)
print('train_loss: {:.4}|train_acc: {:.4}'.format(
torch.mean(torch.Tensor(loss_history)),
torch.mean(torch.Tensor(acc_history)),
))
loss_history = []
acc_history = []
cnn.eval()
for img, target in test_data_loader:
img = Variable(img)
target = Variable(target)
if torch.cuda.is_available():
img = img.cuda()
target = target.cuda()
output = cnn(img)
acc = calculat_acc(output, target)
acc_history.append(acc)
loss_history.append(float(loss))
print('test_loss: {:.4}|test_acc: {:.4}'.format(
torch.mean(torch.Tensor(loss_history)),
torch.mean(torch.Tensor(acc_history)),
))
print('epoch: {}|time: {:.4f}'.format(epoch, time.time() - start_))
torch.save(cnn.state_dict(), model_path)
class TextClassifier:
def __init__(self,
paths,
batch_size=6,
iterations=50,
initial_lr=0.003,
hidden_size=256,
dropout=0.2,
kernel_sz=3):
self.use_cuda = torch.cuda.is_available()
self.device = torch.device('cuda:0' if self.use_cuda else 'cpu')
self.data = DataReader(paths)
self.data.set_training_data(batch_size,
('cuda:0' if self.use_cuda else 'cpu'))
self.train_batch_loader = BatchGenerator(self.data.train_data,
'Sentence', 'Label')
self.val_batch_loader = BatchGenerator(self.data.val_data, 'Sentence',
'Label')
self.test_batch_loader = BatchGenerator(self.data.test_data,
'Sentence', 'Label')
# Store hyperparameters
self.batch_size = batch_size
self.iterations = iterations
self.initial_lr = initial_lr
self.kernel_sz = kernel_sz
# Create Model
emb_size, emb_dim = self.data.TEXT.vocab.vectors.size()
self.cnn_model = CNN(emb_size=emb_size,
emb_dimension=emb_dim,
n_out=len(self.data.LABEL.vocab),
dropout=dropout,
kernel_sz=kernel_sz,
stride=1,
padding=0,
out_filters=hidden_size,
pretrained_emb=self.data.TEXT.vocab.vectors)
if self.use_cuda:
self.cnn_model.cuda()
def train(self):
train_loss_hist = []
val_loss_hist = []
train_acc_hist = []
val_acc_hist = []
test_acc_hist = []
loss = 0.0
best_model = 0.0
for itr in range(self.iterations):
print("\nIteration: " + str(itr + 1))
optimizer = optim.SGD(self.cnn_model.parameters(),
lr=self.initial_lr)
self.cnn_model.train()
total_loss = 0.0
total_acc = 0.0
steps = 0
data_iter = iter(self.train_batch_loader)
# For some reason using for loop on iterator (next) is missing the target variable (y)
# Have to loop over the length and retrieve the batch_data inside the loop
for i in range(len(self.train_batch_loader)):
((x_batch, x_len_batch), y_batch) = next(data_iter)
# if torch.min(x_len_batch) > self.kernel_sz:
optimizer.zero_grad()
loss, logits = self.cnn_model.forward(x_batch, y_batch)
acc = torch.sum(torch.argmax(logits, dim=1) == y_batch)
total_loss += loss.item()
total_acc += acc.item()
steps += 1
loss.backward()
optimizer.step()
train_loss_hist.append(total_loss / steps)
train_acc_hist.append(total_acc / len(self.data.trainds))
val_loss, val_acc = self.eval_model(self.val_batch_loader,
len(self.data.valds))
val_loss_hist.append(val_loss)
val_acc_hist.append(val_acc)
if best_model < val_acc:
best_model = val_acc
test_loss, test_acc = self.eval_model(self.test_batch_loader,
len(self.data.testds))
print("Train: {Loss: " + str(total_loss / steps) + ", Acc: " +
str(total_acc / len(self.data.trainds)) + " }")
print("Val: {Loss: " + str(val_loss) + ", Acc: " + str(val_acc) +
" }")
# test_loss, test_acc = self.eval_model(self.test_batch_loader, len(self.data.testds) )
test_acc_hist.append(test_acc)
return train_loss_hist, train_acc_hist, val_loss_hist, val_acc_hist, test_acc
def eval_model(self, batch_loader, N):
self.cnn_model.eval()
total_loss = 0.0
total_acc = 0.0
steps = 0
batch_iter = iter(batch_loader)
with torch.no_grad():
for i in range(len(batch_loader)):
((x_batch, x_len_batch), y_batch) = next(batch_iter)
loss, logits = self.cnn_model(x_batch, y_batch)
acc = torch.sum(torch.argmax(logits, dim=1) == y_batch)
total_loss += loss.item()
total_acc += acc.item()
steps += 1
return (total_loss / steps), (total_acc / N)
