def main(): model = Resnet18(5).to(device) optimizer = optim.Adam(model.parameters(), lr=lr) criten = nn.CrossEntropyLoss() best_acc, best_epoch = 0, 0 global_step = 0 viz.line([0], [-1], win='loss', opts=dict(title='loss')) viz.line([0], [-1], win='val_acc', opts=dict(title='val_acc')) for epoch in range(epochs): for step, (x, y) in enumerate(train_loader): x, y = x.to(device), y.to(device) logits = model(x) loss = criten(logits, y) optimizer.zero_grad() loss.backward() optimizer.step() viz.line([loss.item()], [global_step], win='loss', update='append') global_step += 1 if epoch % 1 == 0: val_acc = evalute(model, val_loader) if val_acc > best_acc: best_epoch = epoch best_acc = val_acc torch.save(model.state_dict(), 'best.mdl') viz.line([val_acc], [global_step], win='val_acc', update='append') print('best acc:', best_acc, 'best epoch:', best_epoch) model.load_state_dict(torch.load('best.mdl')) print('loaded from ckpt') test_acc = evalute(model, test_loader) print('test acc:', test_acc)
def __init__(self, *args, **kwargs): super(ContextPath, self).__init__() self.resnet = Resnet18() self.arm16 = AttentionRefinementModule(256, 128) self.arm32 = AttentionRefinementModule(512, 128) self.conv_head32 = ConvBNReLU(128, 128, ks=3, stride=1, padding=1) self.conv_head16 = ConvBNReLU(128, 128, ks=3, stride=1, padding=1) self.conv_avg = ConvBNReLU(512, 128, ks=1, stride=1, padding=0) self.init_weight()
def __init__(self, *args, **kwargs): super(ContextPath, self).__init__() self.resnet = Resnet18() self.arm16 = AttentionEnhancementModule(256, 128) self.arm32 = AttentionEnhancementModule(512, 128) self.conv_head32 = ConvBNReLU(128, 128, ks=3, stride=1, padding=1) self.conv_head16 = ConvBNReLU(128, 128, ks=3, stride=1, padding=1) self.conv_avg = ConvBNReLU(512, 128, ks=1, stride=1, padding=0) self.up32 = nn.Upsample(scale_factor=2.) self.up16 = nn.Upsample(scale_factor=2.) self.init_weight()
def __init__(self, n_classes, *args, **kwargs): super(ShelfNet, self).__init__() self.backbone = Resnet18() self.decoder = Decoder(planes=64,layers=3,kernel=3) self.ladder = LadderBlock(planes=64,layers=3, kernel=3) self.conv_out = NetOutput(64, 64, n_classes) self.conv_out16 = NetOutput(128, 64, n_classes) self.conv_out32 = NetOutput(256, 64, n_classes) self.trans1 = ConvBNReLU(128,64,ks=1,stride=1,padding=0) self.trans2 = ConvBNReLU(256, 128, ks=1, stride=1, padding=0) self.trans3 = ConvBNReLU(512, 256, ks=1, stride=1, padding=0)
model_weights_temp = pickle.load(open(PKL_PATH, "rb")) # Transpose conv and fc weights model_weights = {} for k, v in model_weights_temp.items(): if len(v.shape) == 4: model_weights[k] = np.transpose(v, (2, 3, 1, 0)) elif len(v.shape) == 2: model_weights[k] = np.transpose(v) else: model_weights[k] = v # Build ResNet-18 models and save parameters # Build models print("Build ResNet-18 models") model = Resnet18(mode="train", batch_size=32) with model.graph.as_default(): model.preload() with tf.Session(graph=model.graph) as sess: init = tf.global_variables_initializer() sess.run(init) # Set variables values print('Set variables to loaded weights') all_vars = tf.global_variables() for v in all_vars: if v.op.name == 'global_step': continue if v.op.name.startswith('dense'): continue
def main(unused_argv): loader = Loader(base_path=None, path="/data") datasets = loader.CUB(ratio=0.2, total_ratio=total_ratio) model = Resnet18(batch_size=FLAGS.batch_size) with model.graph.as_default(): model.preload() vars = [ var for var in tf.global_variables() if var.name.startswith("conv") ] global_step = tf.Variable(0, name='global_step', trainable=False) learning_rate = tf.train.exponential_decay( 1e-3, global_step=global_step, decay_steps=5 * int(len(datasets["train"]) / FLAGS.batch_size), decay_rate=0.1, staircase=True) update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(update_ops): opt = tf.train.AdamOptimizer(learning_rate=learning_rate) grad_and_vars = opt.compute_gradients(loss=model.loss) for index, (grad, var) in enumerate(grad_and_vars): if FLAGS.fine_tune: if var.op.name.startswith( "dense") or var.op.name.startswith("conv5"): grad_and_vars[index] = (grad * 10.0, var) elif FLAGS.freeze: if var.op.name.startswith( "conv1") or var.op.name.startswith("conv2"): grad_and_vars[index] = (grad * 1e-3, var) train_op = opt.apply_gradients(grad_and_vars, global_step=global_step) # train_op = tf.train.AdamOptimizer(learning_rate=learning_rate)\ # .minimize(loss=model.loss, global_step=global_step) rest_vars = list( set([var for var in tf.global_variables()]) - set(vars)) init_rest_vars = tf.variables_initializer(rest_vars) # writer = tf.summary.FileWriter("logs/", model.graph) # writer.flush() # writer.close() # vars = [var.name for var in vars] # print('\n'.join(vars)) # import sys # sys.exit(0) with tf.Session(graph=model.graph) as sess: if os.path.exists(utils.path("models/trained")): tf.train.Saver().restore( sess, tf.train.latest_checkpoint(utils.path("models/trained/"))) else: init_rest_vars.run() tf.train.Saver(vars).restore(sess, utils.path("models/init/models.ckpt")) from BatchLoader import BatchLoader LOG = utils.Log() for epoch in range(FLAGS.num_epochs): for phase in ('train', 'test'): dataset = datasets[phase] accs = utils.AverageMeter() losses = utils.AverageMeter() start_time = time.time() bar = progressbar.ProgressBar() for features, boxes, im_sizes in bar( BatchLoader(dataset, batch_size=FLAGS.batch_size, pre_fetch=FLAGS.pre_fetch, shuffle=(phase == 'train'), op_fn=CUB_Dataset.list_to_tuple)): boxes = utils.crop_boxes(boxes, im_sizes) boxes = utils.box_transform(boxes, im_sizes) if phase == 'train': _, loss, outputs = sess.run( [train_op, model.loss, model.fc], feed_dict={ 'features:0': features, 'boxes:0': boxes, 'training:0': phase == 'train', }) else: loss, outputs = sess.run( [model.loss, model.fc], feed_dict={ 'features:0': features, 'boxes:0': boxes, 'training:0': phase == 'train', }) acc = utils.compute_acc(outputs, boxes, im_sizes) nsample = model.batch_size accs.update(acc, nsample) losses.update(loss, nsample) LOG.add(phase, {"accu": float(acc), "loss": float(loss)}) elapsed_time = time.time() - start_time print( '[{}]\tEpoch: {}/{}\tLoss: {:.4f}\tAcc: {:.2%}\tTime: {:.3f}' .format(phase, epoch, FLAGS.num_epochs, losses.avg, accs.avg, elapsed_time)) tf.train.Saver().save(sess, utils.path("models/trained/resnet18.ckpt"), global_step=global_step) if FLAGS.log_path is not None: LOG.dump(FLAGS.log_path)
def main(): #load batchsz = 128 cifar_train = datasets.CIFAR10( 'cifar', True, transform=transforms.Compose([ transforms.Resize((32, 32)), transforms.ToTensor(), #transforms.Normalize(mean=[0.485,0.456,0.406], # std=[0.229, 0.224, 0.225]) ]), download=True) cifar_train = DataLoader(cifar_train, batch_size=batchsz, shuffle=True) cifar_test = datasets.CIFAR10('cifar', False, transform=transforms.Compose([ transforms.Resize((32, 32)), transforms.ToTensor() ]), download=True) cifar_test = DataLoader(cifar_test, batch_size=batchsz, shuffle=True) #x, lable = iter(cifar_train).next() #print('x:', x.shape, 'lable:', lable.shape) device = torch.device('cuda:0') model = Resnet18().to(device) criteon = nn.CrossEntropyLoss().to(device) optimizer = optim.Adam(model.parameters(), lr=1e-3) #train for epoch in range(1000): model.train() for batchsz, (x, lable) in enumerate(cifar_train): x, lable = x.to(device), lable.to(device) logits = model(x) #logits [b,10] #lable [b] #loss: tensor scalar loss = criteon(logits, lable) #backprop optimizer.zero_grad() loss.backward() optimizer.step() print(epoch, 'loss:', loss.item()) model.eval() with torch.no_grad(): #test total_correct = 0 total_num = 0 for x, lable in cifar_test: x, lable = x.to(device), lable.to(device) logits = model(x) pred = logits.argmax(dim=1) # total_correct += torch.eq(pred, lable).float().sum().item() total_num += x.size(0) acc = total_correct / total_num print(epoch, 'test acc:', acc)
for tag in tags: sub_id = sub_id + 1 sub = fig.add_subplot(sub_lines, 1, sub_id) sub.plot(range(len(log[phase][tag])), log[phase][tag], label=(phase + '_' + tag)) sub.set_title(phase + ': ' + tag) fig.tight_layout() plt.show() # Visualize predicting result if FLAGS.demo_only: figs_x, figs_y = (5, 5) loader = Loader(base_path=None, path="/data") datasets = loader.CUB(ratio=0.2, total_ratio=1.0) model = Resnet18(batch_size=figs_x * figs_y) with model.graph.as_default(): model.preload() with tf.Session(graph=model.graph) as sess: tf.train.Saver().restore( sess, tf.train.latest_checkpoint( utils.path("models/" + FLAGS.model + "/"))) data_loader = BatchLoader(datasets['test'], batch_size=figs_x * figs_y, pre_fetch=1, shuffle=True, op_fn=CUB_Dataset.list_to_tuple) fig = plt.figure(figsize=(6 * figs_x, 2 * figs_y))