def __init__(self):
self.device = torch.device(
'cuda' if torch.cuda.is_available() else 'cpu')
self.use_cuda = torch.cuda.is_available()
self.net = model.Net().cuda() if self.use_cuda else model.Net()
self.optimizer = None
self.train_accuracies = []
self.test_accuracies = []
self.start_epoch = 1
def build_net(self):
'''build network based on arguments input'''
self.net = model.Net(self.state_size, self.hidden_size, self.action_size, \
self.n_layers, output_activation=self.output_activation, discrete=self.discrete)
self.net_optimizer = optim.Adam(self.net.parameters(), lr=self.lr)
if self.nn_baseline:
self.critic = model.Net(self.state_size, self.hidden_size, 1, self.n_layers, \
output_activation=None, discrete=self.discrete)
self.base_optimizer = optim.Adam(self.critic.parameters(),
lr=self.lr)
def index(request):
if request.method == "POST":
# Write the binary string representing the image to a file,
# and use PIL's from-file image loader to make the PIL image "img" variable.
# Transform to a tensor to pass into the model.
with open("image_temp", "wb") as f:
f.write(request.body)
with open("image_temp", "rb") as f:
img = Image.open(f)
image_tensor = transforms.ToTensor()(img)
os.remove("image_temp")
# Loading the trained model
PATH = os.path.join(os.getcwd(), '..',
'backend/wildlifeTrainer/wild_net.pth')
net = model.Net()
net.load_state_dict(torch.load(PATH))
# Transform the input and retrieve model prediction
transform = transforms.Compose(
[transforms.Resize(size=(96, 96)),
transforms.ToTensor()])
input_img = torch.unsqueeze(transform(img), 0)
probabilities = torch.nn.Softmax(dim=1)(net(input_img))
# Return the probabilities in Python list form (converted to a JS array in the HTTP response)
return JsonResponse({
'data':
getTopFiveProbabilities(
zipProbabilityAndClassNames(
torch.squeeze(probabilities).tolist(),
model.getClassNames()))
})
else:
return HttpResponse()
def main():
dataset_name = 'vqa1'
target_name = os.path.join('logs', '{}_test.pth'.format(dataset_name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
test_loader = data.get_loader(test=True)
checkpoint = torch.load('logs/2017-08-04_00:55:19.pth')
tokens = len(checkpoint['vocab']['question']) + 1
net = torch.nn.DataParallel(model.Net(tokens))
net.load_state_dict(checkpoint['weights'])
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = []
tracker.load_state_dict(checkpoint['tracker'])
config.load_state_dict(checkpoint['config'])
t = run_test(net, test_loader, optimizer, tracker, prefix='test', epoch=1)
results = {
'name': dataset_name,
'tracker': tracker.to_dict(),
'weights': net.state_dict(),
'eval': {
'answers': t[0],
'accuracies': t[1],
'idx': t[2],
def train(args):
kwargs = {'num_workers': 2, 'pin_memory': True} if args.cuda else {}
train_loader = data.DataLoader(
datasets.MNIST('./data', train=True, download=True,
transform=transforms.ToTensor()),
batch_size=args.batch_size, shuffle=True, **kwargs)
test_loader = data.DataLoader(
datasets.MNIST('./data', train=False,
transform=transforms.ToTensor()),
batch_size=args.test_batch_size, shuffle=True, **kwargs)
if args.binary == 'connect':
net = model.BinaryConnect(args.in_features, args.out_features)
elif args.binary == 'bnn':
net = model.BinaryNet(args.in_features, args.out_features)
elif args.binary == 'nn':
net = model.Net(args.in_features, args.out_features)
# net = nn.DataParallel(net)
print(net)
if args.cuda:
net.cuda()
if args.optimizer == 'Adam':
optimizer = optim.Adam(net.parameters(), lr=args.lr)
elif args.optimizer == 'LBFGS':
if args.line_search_fn is None:
optimizer = optim.LBFGS(net.parameters(), lr=args.lr)
elif args.line_search_fn == 'strong_wolfe':
optimizer = optim.LBFGS(net.parameters(), lr=args.lr, line_search_fn='strong_wolfe')
criterion = nn.NLLLoss()
for epoch in range(1, args.epochs+1):
train_epoch(epoch, net, criterion, optimizer, train_loader, args)
test_epoch(net, criterion, test_loader, args)
def test():
#model1
net = model.Net(num=10)
#model2
#net = model.FinetuneNet(num=10) #如果用resnet152，就得将图像size设置成为224x224，用my_transform2
net.load_state_dict(torch.load('./checkpoints/dnn_model_00_0420.pkl'))
batch_size = 20
test_data = tv.datasets.CIFAR10(root="./cifar/",
train=False,
download=True,
transform=my_transform)
test_dataloader = torch.utils.data.DataLoader(dataset=test_data, \
shuffle=True, \
batch_size=batch_size)
dataiter = iter(test_dataloader)
for i in range(10):
imgs, labels = next(dataiter)
y_head = net(imgs)
y_head = y_head.data.max(1, keepdim=True)[1].view(batch_size)
diff = y_head - labels
#print y_head, labels, diff
error_cnt = int(torch.nonzero(diff).shape[0])
right_rate = (batch_size - error_cnt) * 100.0 / batch_size
print right_rate, "%"
def __init__(self, model_path, save_path, kernel, scale, conf, method_num,
num_of_adaptation):
methods = ['direct', 'direct', 'bicubic', 'direct']
self.save_results = True
self.max_iters = num_of_adaptation
self.display_iter = 1
self.upscale_method = 'cubic'
self.noise_level = 0.0
self.back_projection = False
self.back_projection_iters = 4
self.model_path = model_path
self.save_path = save_path
self.method_num = method_num
self.ds_method = methods[self.method_num]
self.kernel = kernel
self.scale = scale
self.scale_factors = [self.scale, self.scale]
self.mse, self.mse_rec, self.interp_mse, self.interp_rec_mse, self.mse_steps = [], [], [], [], []
self.psnr = []
self.iter = 0
self.device = torch.device(
"cuda" if torch.cuda.is_available() else "cpu")
self.model = model.Net()
self.learning_rate = 0.02
self.loss_fn = torch.nn.L1Loss()
self.opt = torch.optim.SGD(self.model.parameters(),
lr=self.learning_rate)
def testModel():
# Load the data
_, testloader = model.getTrainAndTestLoaders()
dataiter = iter(testloader)
# Load our trained model
PATH = 'wild_net.pth'
net = model.Net()
net.load_state_dict(torch.load(PATH))
'''
# Test some sample images
images, labels = dataiter.next()
outputs = net(images)
print(outputs)
_, predicted = torch.max(outputs, 1)
print('Predicted: ', ' '.join('%5s' % model.getClassNames()[predicted[j]]
for j in range(4)))
'''
# Let's see how it tests on the whole data set
correct = 0
total = 0
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print(
'Accuracy of the network on the {0:.0f} test images: {1:.2f}%'.format(
len(testloader), 100 * correct / total))
def __init__(self, trial, step, size, scale_list, meta_batch_size, meta_lr,
meta_iter, task_batch_size, task_lr, task_iter,
data_generator, checkpoint_dir):
print('[*] Initialize Training')
self.trial = trial
self.step = step
self.HEIGHT = size[0]
self.WIDTH = size[1]
self.CHANNEL = size[2]
self.scale_list = scale_list
self.META_BATCH_SIZE = meta_batch_size
self.META_LR = meta_lr
self.META_ITER = meta_iter
self.TASK_BATCH_SIZE = task_batch_size
self.TASK_LR = task_lr
self.TASK_ITER = task_iter
# self.data_generator=data_generator
self.checkpoint_dir = checkpoint_dir
self.device = torch.device(
"cuda" if torch.cuda.is_available() else "cpu")
'''model'''
self.model = model.Net()
checkpoint = torch.load(self.checkpoint_dir)
self.model.load_state_dict(checkpoint)
self.model = self.model.to(self.device)
'''loss'''
self.loss_fn = nn.L1Loss()
'''Optimizers'''
self.pretrain_op = optim.Adam(self.model.parameters(), lr=self.META_LR)
self.opt = optim.Adam(self.model.parameters(), lr=self.META_LR)
def model_func(wrapped_import, inputs):
if wrapped_import:
model = wrapped_import("model")
else:
import model
net = model.Net()
net = net.eval() # disable dropout
return net(inputs)
def main():
# Load the parameters from json file
args = parser.parse_args()
image_dir = args.image_dir
label_dir = args.label_dir
cp_dir = args.checkpoints_dir
logging.basicConfig(filename='train.log', level=logging.INFO)
logging.info('Started')
json_path = os.path.join(args.model_dir, 'params.json')
assert os.path.isfile(json_path), "No json configuration file found at {}".format(json_path)
params = utils.Params(json_path)
#split data
train_image, train_label, dev_image, dev_label, test_image, test_label = data_split(image_dir, label_dir)
#load data
train_dataset = EMDataset(train_image, train_label)
dev_dataset = EMDataset(dev_image, dev_label)
test_dataset = EMDataset(test_image, test_label)
train_dataloader = DataLoader(train_dataset,
batch_size=params.batch_size, shuffle=True)
dev_dataloader = DataLoader(dev_dataset,
batch_size=params.batch_size, shuffle=True)
test_dataloader = DataLoader(test_dataset,
batch_size=params.batch_size, shuffle=True)
#use GPU
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
net = model.Net(1,6)
if torch.cuda.device_count() > 1:
net = nn.DataParallel(net)
net.to(device)
# define loss
class_weights = torch.FloatTensor(params.class_weights)
criterion = nn.CrossEntropyLoss(weight=class_weights).cuda()
#initialize optimiser
optimizer = optim.Adam(net.parameters(), lr=params.learning_rate)
#training and evaluate
epoch_train_loss= []
epoch_test_loss = []
for epoch in range(params.num_epochs):
net.train()
logging.info('epoch'+ str(epoch+1)+' start!')
f_train_acc = [[] for i in range(6)]
f_test_acc = [[] for i in range(6)]
train(net, train_dataloader, device, optimizer, criterion, epoch, epoch_train_loss,f_train_acc)
logging.info('epoch' + str(epoch + 1) + ' train_loss: ' + str(epoch_train_loss))
logging.info('epoch' + str(epoch + 1) + ' train_acc: ' + str(f_train_acc))
#save model
torch.save(net.state_dict(), os.path.join(cp_dir, 'cp{}.pth'.format(epoch + 1)))
#evaluate the model on test set.
test(net, test_dataloader, device, criterion, epoch, epoch_test_loss, f_test_acc)
logging.info('epoch' + str(epoch + 1) + ' test_loss: ' + str(epoch_test_loss))
logging.info('epoch' + str(epoch + 1) + ' test_acc: ' + str(f_test_acc))
logging.info('epoch'+ str(epoch+1)+' end!')
def main():
if len(sys.argv) > 1:
name = ' '.join(sys.argv[1:])
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
# train_loader = data.get_loader(config.train_path, train=True)
test_loader = data.get_loader(config.test_path, test=True)
cap_vcb = test_loader.dataset.token_to_index
hash_vcb = test_loader.dataset.answer_to_index
inv_hash_dict = {v: k for k, v in hash_vcb.items()}
inv_cap_dict = {v: k for k, v in cap_vcb.items()}
net = model.Net(test_loader.dataset.num_tokens[0],
test_loader.dataset.num_tokens[1], [], []).to(device)
# net = model.Net(train_loader.dataset.num_tokens[0],train_loader.dataset.num_tokens[1]).to(device)
# optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
# print(torch.load('logs/' + args.model_path)['weights'])
net.load_state_dict(torch.load('logs/' + args.model_path)['weights'])
tracker = utils.Tracker()
# for k,v in vars(config).items():
# print(k)
# sdfsd
#BRING THIS BACK
# criterion = nn.CrossEntropyLoss(ignore_index = PAD_IDX)
criterion = nn.CrossEntropyLoss(
ignore_index=test_loader.dataset.answer_to_index['<pad>'])
config_as_dict = {
k: v
for k, v in vars(config).items()
if not k.startswith('__') and not k.startswith('os')
and not k.startswith('expanduser') and not k.startswith('platform')
}
r = run(net,
test_loader,
tracker,
criterion,
cap_vcb,
hash_vcb,
train=False,
prefix='test',
epoch=0)
with open('output/hashtags.csv', 'w') as f:
for key in r[0].keys():
f.write("%s,%s\n" % (key, r[0][key]))
with open('output/captions.csv', 'w') as f:
for key in r[1].keys():
f.write("%s,%s\n" % (key, r[1][key]))
with open('output/predictions.csv', 'w') as f:
for key in r[2].keys():
f.write("%s,%s\n" % (key, r[2][key]))
def main(objects, **kwargs):
nets = [
model.Net(objects).cuda(),
model.Baseline(objects).cuda(),
]
loader = get_loader(objects, **kwargs)
plins = run(nets, loader, 1000, train=True)
accs = run(nets, loader, 200, train=False)
return {'plins': plins, 'accs': accs}
def main():
if len(sys.argv) > 1:
name = ' '.join(sys.argv[1:])
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
with open('embedding/word_embedding.p', "rb") as f:
embedding_model = cPickle.load(f)
net = model.Net(embedding_model).to(device)
# net = model.Net(train_loader.dataset.num_tokens).to(device)
net = nn.DataParallel(net)
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = utils.Tracker()
config_as_dict = {
k: v
for k, v in vars(config).items()
if (not k.startswith('__')) and (type(v) is not ModuleType)
}
for i in range(config.epochs):
_ = run(net,
train_loader,
optimizer,
tracker,
train=True,
prefix='train',
epoch=i)
r = run(net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=i)
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
def main():
if len(sys.argv) > 1: # 外界获得的参数列表：['/home/users2/xcm09/VQA/train.py']
name = ' '.join(sys.argv[1:])
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
print('模型 will save to {}'.format(target_name))
cudnn.benchmark = True
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
net = model.Net(train_loader.dataset.num_tokens).cuda() # 15193
# net = nn.DataParallel(model.Net(train_loader.dataset.num_tokens), device_ids=config.device_ids).cuda()
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = utils.Tracker()
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
for i in range(config.epochs):
a = time()
_ = run(net,
train_loader,
optimizer,
tracker,
train=True,
prefix='train',
epoch=i)
r = run(net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=i)
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
b = time() - a
print('该epoch耗时%d:%d' % (b // 60, b % 60))
def main(**hp):
# add hyper parameters
hp['drng'] = (-hp['drng'], hp['drng'])
#hp['drng'] = (0, 12)
hp['trng'] = 1.0
hp['views'] = 9
hp['pad'] = 12
hp['uncrt'] = True
hp['rgw'] = 1.0
hp['rgl1'] = False
hp['cll1'] = False
hp['tri'] = False
hp['mine'] = False
dataset = hci4d.HCI4D(hp['dset'], nviews=(hp['views'], hp['views']),
cache=False)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=1,
shuffle=False, num_workers=1)
# create output directory
if not os.path.exists(hp['out']):
os.makedirs(hp['out'])
# 1st device for all parameters
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# create net and load parameters
net = model.Net(hp)
dl_utils.load_model_params(net, hp['prms'])
for p in net.parameters():
p.requires_grad = False
net.eval()
# parallelize for multiple gpus
if hp['gpus'] > 1:
net = torch.nn.DataParallel(net, list(range(hp['gpus'])))
net.to(device)
# loop over the dataset
for j, data in enumerate(dataloader):
print(f'Processing Scene {j}...')
# process scene
proc = process.Process(net, device, hp)
disp, uncert, pred, loss, runtime = proc(data)
# save results
dataset.save_batch(hp['out'], data[-1], disp.cpu().numpy(),
uncert.cpu().numpy(), runtime)
return 0
def main():
if len(sys.argv) > 1:
name = ' '.join(sys.argv[1:])
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
model_name = os.path.join('logs', '{}_model.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
net = nn.DataParallel(model.Net(train_loader.dataset.num_tokens)).cuda()
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = utils.Tracker()
config_as_dict = {k: v for k, v in vars(config).items() if not k.startswith('__')}
for i in range(config.epochs):
_ = run(net, train_loader, optimizer, tracker, train=True, prefix='train', epoch=i)
r = run(net, val_loader, optimizer, tracker, train=False, prefix='val', epoch=i)
results = {
'name': name,
'epoch': i,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'optimizer' : optimizer.state_dict(),
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
# save best model so far
val_acc = torch.FloatTensor(tracker.to_dict()['val_acc'])
val_acc = val_acc.mean(dim=1).numpy()
is_best = True
for j in range(len(val_acc) - 1):
if val_acc[-1] <= val_acc[j]:
is_best = False
if is_best:
save_model = {
'epoch': i,
'weights': net.state_dict()
}
torch.save(save_model, model_name)
def main(args):
start_time = time.time()
if args.edit_set:
print('evaluating on edited VQA')
else:
print('evaluating original VQA')
cudnn.benchmark = True
output_qids_answers = []
if args.split == 'train2014':
_, val_loader = data.get_loader(train=True) #val=True) ## data shuffled only in train
elif args.split == 'val2014':
_, val_loader = data.get_loader(val=True)
elif args.split == 'test2015':
_, val_loader = data.get_loader(test=True)
#test_loader = data.get_loader(test=True)
if args.model_type == 'no_attn':
net = nn.DataParallel(model2.Net(val_loader.dataset.num_tokens)).cuda()
model_path = os.path.join(config.model_path_no_attn)
results_file = os.path.join(config.results_no_attn_pth)
res_pkl = os.path.join(config.results_no_attn_pkl)
MODEL_name = 'CNN_LSTM'
elif args.model_type == 'with_attn':
net = nn.DataParallel(model.Net(val_loader.dataset.num_tokens)).cuda()
model_path = os.path.join(config.model_path_show_ask_attend_answer)
results_file = os.path.join(config.results_with_attn_pth)
res_pkl = os.path.join(config.results_with_attn_pkl)
MODEL_name = 'SAAA'
print('loading model from', model_path)
net.load_state_dict(torch.load(model_path)["weights"]) ### so here you load the weights, essentially the model
print(net)
net.eval()
r = run(net, val_loader, args.edit_set, MODEL_name)
print('saving results to '+ res_pkl )
if args.edit_set:
output_qids_answers += [
{ 'ans_id': p.item(), 'img_id': id,'ques_id':qid.item(),'ss_vc': np.float16(softmax_vector.tolist())} #np.float32(softmax_vector).tolist()
for p,id,qid, softmax_vector in zip(r[0],r[1], r[2], r[3])]
else:
output_qids_answers += [
{ 'ans_id': p.item(), 'img_id': id.item(),'ques_id':qid.item(),'ss_vc': np.float16(softmax_vector.tolist())}
for p,id,qid, softmax_vector in zip(r[0],r[1], r[2], r[3])]
with open(res_pkl, 'wb') as f:
pickle.dump(output_qids_answers,f, pickle.HIGHEST_PROTOCOL)
print('saving pkl complete')
print('time_taken:', time.time() - start_time)
def main():
path = 'logs/'
files = []
file = '2020-02-05_00:29:21.pth'
results = torch.load(f=path+file, map_location='cpu')
train_loader = data.get_loader(train=True)
test_loader = data.get_loader(test=True)
net = model.Net(train_loader.dataset.num_tokens).cuda()
net.load_state_dict(results['weights'])
print(net)
def __init__(self, batch_size=64, download=True, epochs=10):
self.net = model.Net()
self.transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])
self.batch_size = batch_size
self.download = download
self.device = 'cpu'
self.epochs = epochs
self._create_loader()
self._create_op()
def train():
learning_rate = 0.0001
net = model.Net()
loss_fn = nn.L1Loss()
optimizer = optim.Adam(net.parameters(), lr=learning_rate)
'''data'''
datapath = ''
predataset = dataset.preTrainDataset(datapath)
dataloader = DataLoder(predataset,
batch_size=64,
num_workers=1,
shuffle=True,
drop_last=True)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
step = 0
with tqdm.tqdm(total=100000, miniters=1, mininterval=0) as progress:
while True:
for inputs in dataloader:
net.train()
hr, lr = inputs[-1][0], inputs[-1][1]
hr = hr.to(device)
lr = lr.to(device)
out = net(lr)
loss = loss_fn(hr, out)
progress.set_description("Iteration: {iter} Loss: {loss}, Learning Rate: {lr}".format( \
iter=step, loss=loss.item(), lr=learning_rate))
progress.update()
if step > 0 and step % 30000 == 0:
learning_rate = learning_rate / 10
adjust_learning_rate(optimizer, new_lr=learning_rate)
print("Learning rate reduced to {lr}".format(
lr=learning_rate))
optimizer.zero_grad()
loss.backward()
nn.utils.clip_grad_norm_(net.parameters(), 10)
optimizer.step()
step += 1
if step > 100000:
print('Done training.')
break
save_path = os.path.join('./checkpoint', 'Pretrain.pth')
torch.save(net.state_dict(), save_path)
print("Model is saved !")
def main():
path = sys.argv[1]
test_loader = data.get_loader(test=True)
log = torch.load(path)
tokens = len(log['vocab']['question']) + 1
net = torch.nn.DataParallel(model.Net(tokens)).cuda()
net.load_state_dict(log['weights'])
r = run(net, test_loader)
print('answers', r[0], 'accuracies', r[1], 'idx', r[2])
def main():
start_time = datetime.datetime.now()
start_time_str = start_time.strftime("%Y-%m-%d_%H-%M-%S")
progress_file = start_time_str + '_progress.csv'
cudnn.benchmark = True
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
net = nn.DataParallel(model.Net(train_loader.dataset.num_tokens)).cuda()
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = utils.Tracker()
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
train_loss_list = []
train_acc_list = []
val_loss_list = []
val_acc_list = []
max_acc = 0
for i in range(config.epochs):
print('epoch %d' % i)
print('train')
train_loss, train_acc = run(net,
train_loader,
optimizer,
tracker,
train=True,
prefix='train',
epoch=i)
print('validation')
val_loss, val_acc = run(net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=i)
train_loss_list.append(train_loss)
train_acc_list.append(train_acc)
val_loss_list.append(val_loss)
val_acc_list.append(val_acc)
write_progress(train_acc_list, train_loss_list, val_acc_list,
val_loss_list, progress_file)
if val_acc > max_acc and val_acc > 0.45:
print('model saved')
torch.save(net.state_dict(), start_time_str + '_best_model.pkl')
max_acc = val_acc
def train():
net = model.Net()
weights_file = 'networks/network_7'
# net.load_state_dict(torch.load('networks/network_7'))
net.to(dtype=dtype, device=device)
data = torch.load('../data/train.bin')
val_data = torch.load('../data/validation.bin')
epochs = 5
batch_size = 16
lr = 1e-5
alpha, beta = 0.9,0.99
regulirizer = 0.00001
optimizer = optim.SGD(net.parameters(), lr=lr)#, betas = (alpha,beta))
num_batches = 512
f= open(weights_file+".txt","w+")
f.write("lr : "+str(lr))
f.write("\nbatch_size : "+str(batch_size))
f.write("\nalpha : "+str(alpha))
f.write("\nbeta : "+str(beta))
f.write("\nnum_batches : "+str(num_batches))
# training loop
for epoch in range(epochs):
t=time.time()
for i in range(num_batches):
input, target = readBatch(batch_size,data)
optimizer.zero_grad()
output = net(input)
criterion = nn.MSELoss()
l2_reg = 0
for param in net.parameters():
l2_reg += torch.norm(param)
loss = criterion(output, target) + regulirizer * l2_reg
if (i+1)%num_batches==0:
t = time.time()-t
print(epoch,loss)
f.write("\nepoch "+str(epoch))
f.write("\n"+str(loss))
f.write("\ntime elapsed:"+str(t))
print("time elapsed:",t)
t = time.time()
loss.backward() # Does Backpropogation
optimizer.step() # Does the update
if((epoch+1)%1==0):
for pp in optimizer.param_groups:
pp['lr'] /= 4
torch.save(net.state_dict(), weights_file)
print(list((net.parameters()))[-2])
f.close()
torch.save(net.state_dict(), weights_file)
def main():
trainset, testset = dataloader.get_datasets()
trainloader, testloader = dataloader.get_loader()
net = model.Net()
criterion = functions.get_criterion()
optimizer = functions.get_optimizer(net, 0.001, 0.9)
writer = set_tensorboard_writer('runs/fashion_mnist_experiment_2')
show_image_tensorboard(writer, trainloader)
show_model_tensorboard(writer, net, trainloader)
show_projector_tensorboard(writer, trainset)
train(trainloader, net, optimizer, criterion, writer)
test(testloader, net, writer)
close_tensorboard_writer(writer)
def populate_network(network, path):
net=model.Net()
#net.load_state_dict(torch.load(path))
dicts=torch.load(path)
input_tensor = network.add_input(name=ModelData.INPUT_NAME, dtype=ModelData.DTYPE, shape=ModelData.INPUT_SHAPE)
tensor=input_tensor
dict={k: v for k, v in dicts.items()}
list_keys=list(dict.keys())
print('all keys are',list_keys)
for name,module in net.named_modules():
print('current layer is ',name)
if isinstance(module,nn.Conv2d):
w = module.weight.data.cpu().numpy()
b=module.bias.data.cpu().numpy()
shape=w.shape
print(shape)
if name in list_keys[0]:
conv=network.add_convolution(input=input_tensor,
num_output_maps=shape[0], kernel_shape=(shape[2], shape[3]), kernel=w,bias=b)
else:
conv = network.add_convolution(input=tensor.get_output(0),
num_output_maps=shape[0], kernel_shape=(shape[2], shape[3]), kernel=w,
bias=b)
conv.stride = (1, 1)
pool = network.add_pooling(input=conv.get_output(0), type=trt.PoolingType.MAX, window_size=(2, 2))
pool.stride = (2, 2)
tensor=pool
elif isinstance(module,nn.MaxPool2d):
pool = network.add_pooling(input=tensor.get_output(0), type=trt.PoolingType.MAX, window_size=(2, 2))
pool.stride = (2, 2)
pool.get_output(0).name = name
tensor=pool
elif isinstance(module,nn.Linear):
w = module.weight.data.cpu().numpy()
b = module.bias.data.cpu().numpy()
shape = w.shape
print(shape)
ipt=tensor.get_output(0)
fc = network.add_fully_connected(input=ipt, num_outputs=shape[0], kernel=w, bias=b)
fc.get_output(0).name = name
tensor=fc
elif isinstance(module,nn.ReLU):
relu= network.add_activation(input=tensor.get_output(0), type=trt.ActivationType.RELU)
relu.get_output(0).name=name
tensor=relu
tensor.get_output(0).name = ModelData.OUTPUT_NAME
network.mark_output(tensor=tensor.get_output(0))
def graph(self):
self.left = tf.placeholder(tf.uint8)
self.right = tf.placeholder(tf.uint8)
self.gt = tf.placeholder(tf.string)
limg = tf.expand_dims(tf.to_float(self.left)/255.0,0)
rimg = tf.expand_dims(tf.to_float(self.right)/255.0,0)
cv,lrl = lowrescv(limg,rimg)
lrl = 2.0*lrl-1.0
limg = 2.0*limg-1.0
self.net = model.Net()
dout = self.net.predict(limg,cv,lrl)
self.dout = tf.squeeze(dout,0)
def prediction(img_bytes):
tensor = transform_image(img_bytes)
device = torch.device("cpu")
m = model.Net()
m.load_state_dict(
torch.load("mnist_cnn.pt", map_location=torch.device('cpu')))
m.eval()
with torch.no_grad():
tensor = tensor.to(device)
outputs = m.forward(tensor)
# print(outputs)
y_hat = outputs.argmax(dim=1, keepdim=True)
return y_hat.item()
def train(self, model, embedding_dim, lstm_hidden, fc_input, fc_hidden, epochs, lr, freeze=True, test_path=None):
"""
Train all the models in committee.
:param model: Type of model, must be one of [bilstm/hybrid-cat/hybrid-add/cnn/bow].
:param embedding_dim: Length of reserved vocabulary, used to build embedding layer.
:param lstm_hidden: Dimension of lstm hidden state, used to build bilstm model.
:param fc_input: Dimension of input full connect layer.
:param fc_hidden: Dimension of hidden full connect layer.
:param epochs: How many epochs it trains.
:param lr: Learning rate.
:param freeze: Freezing embedding layer or not. if True, weight in embedding layer will not be changed during training.
:param test_path: Test file path, use to validate the model after every epoch.
"""
self.model = model
test_set = None
loaders = []
criterion = []
optimizers = []
if test_path is not None:
test_set = md.QuestionSet(test_path, self.vocabulary_path, self.labels_path, self.stop_words_path,
self.pre_train_path, self.k)
for i in range(0, len(self.subsets)):
loaders.append(DataLoader(self.subsets[i]))
net = md.Net(model, self.subsets[i].vocab_size(), embedding_dim, lstm_hidden, fc_input, fc_hidden,
self.subsets[i].label_size(), pre_train_weight=self.subsets[i].get_pre_train_weight(),
freeze=freeze)
self.classifiers.append(net)
criterion.append(torch.nn.CrossEntropyLoss())
optimizers.append(torch.optim.SGD(net.parameters(), lr=lr))
for e in range(0, epochs):
for i in range(0, len(self.subsets)):
for t, (cla, train) in enumerate(loaders[i]):
if self.model == 'cnn':
train = self.normalize(train)
self.classifiers[i].train()
optimizers[i].zero_grad()
cla_pred = self.classifiers[i](train)
loss = criterion[i](cla_pred, cla)
loss.backward()
optimizers[i].step()
if test_set is not None:
acc, acc_rate = self.test(test_set)
print('ensemble: %d, model: %s, epoch: %d, stop_words: %s, pre_train_embedding: %s, k: %d, freeze: %s,'
' train_set: %s, test_set: %s, acc: %d, acc rate: %f' %
(len(self.subsets), self.model, e + 1, self.stop_words_path, self.pre_train_path, self.k, freeze,
self.data_path, test_path, acc, acc_rate))
def main(args):
dataset = data.Dataset(args.data_dir)
criterion = nn.CrossEntropyLoss()
net = model.Net(data.VOCAB_SIZE)
if os.path.isfile(args.model_filename):
checkpoint = (torch.load(args.model_filename) if
(torch.cuda.is_available()) else torch.load(
filename, map_location=lambda storage, loc: storage))
net.load_state_dict(checkpoint['state_dict'])
if (torch.cuda.is_available()):
net.cuda()
print('\nRunning test')
epoch_end = False
total_loss = []
test_step = 0
num_correct = 0
test_size = len(dataset.dataset['test'])
while epoch_end == False:
test_step += 1
minibatch, epoch_end = dataset.get_next_minibatch('test', 1)
batch_tensor = Variable(minibatch[0])
labels_tensor = Variable(minibatch[1])
if (torch.cuda.is_available()):
batch_tensor = batch_tensor.cuda()
labels_tensor = labels_tensor.cuda()
output = net.forward(batch_tensor)
label_index = torch.max(labels_tensor, 1)[1]
output_index = torch.max(output, 1)[1]
num_correct += (label_index == output_index).sum().type(
torch.LongTensor)
loss = criterion(output, label_index)
total_loss.append(loss.data)
sys.stdout.write('Test step %i/%i\r' % (test_step, test_size))
sys.stdout.flush()
total_loss = float(sum(total_loss)[0]) / float(len(total_loss))
print('\nTest loss: %f' % total_loss)
print('\nAccuracy: %f%%' % ((float(num_correct) / float(test_size)) * 100))
