def main():
args = get_args()
processed_img = process_image(args.input)
model, optimizer = network.load_model(args.checkpoint)
probs, classes = predict(processed_img, model, args.top_k, args.category_names, args.gpu)
print(f"Top {args.top_k} predictions: {list(zip(classes, probs))}")
def train(args):
## tensorboardX
tflog_path = osp.join(args.output_path, "tflog")
if os.path.exists(tflog_path):
shutil.rmtree(tflog_path)
writer = SummaryWriter(logdir=tflog_path)
## prepare data
train_transform = prep.image_train(resize_size=256, crop_size=224)
train_set = ImageDataset(args.train_path, transform=train_transform)
train_loader = util_data.DataLoader(train_set, batch_size=args.batch_size, shuffle=True, num_workers=4)
device = "cuda" if torch.cuda.is_available() else "cpu"
## set base network
model = load_model(args.net, args.bit)
writer.add_graph(model, input_to_model=(torch.rand(2, 3, 224, 224),))
model.to(device)
if device == 'cuda':
cudnn.benchmark = True
model.train()
## set optimizer and scheduler
parameter_list = [{"params":model.feature_layers.parameters(), "lr":args.lr}, \
{"params":model.hash_layer.parameters(), "lr":args.lr*10}]
optimizer = optim.SGD(parameter_list, lr=args.lr, momentum=0.9, weight_decay=0.005, nesterov=True)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=3000, gamma=0.5)
## train
for i in range(args.num_iter):
scheduler.step()
optimizer.zero_grad()
if i % (len(train_loader)-1) == 0:
train_iter = iter(train_loader)
inputs, labels = train_iter.next()
inputs, labels = inputs.to(device), labels.to(device)
outputs = model(inputs)
s_loss = loss.pairwise_loss(outputs, labels, alpha=args.alpha, class_num=args.class_num)
q_loss = loss.quantization_loss(outputs)
total_loss = s_loss + 0.01 * q_loss
total_loss.backward()
optimizer.step()
writer.add_scalar('similarity loss', s_loss, i)
writer.add_scalar('quantization loss', q_loss, i)
writer.add_scalar('lr', optimizer.param_groups[0]['lr'], i)
if i % 10 == 0:
print("{} #train# Iter: {:05d}, loss: {:.3f} quantizaion loss: {:.3f}".format(
datetime.now(), i, s_loss.item(), q_loss.item()))
writer.close()
torch.save(model, osp.join(args.output_path, "model.pth"))
def init_axes(ax, title):
ax.cla()
ax.set_xlim(0, 28)
ax.set_ylim(28, 0)
ax.set_title(title)
return ax
fig = plt.figure()
ax = plt.subplot(221)
init_axes(ax, "write a digit")
ax2 = plt.subplot(222)
init_axes(ax2, "preprocessed image")
net = network.load_model()
x, y = [], []
a = np.zeros((28, 28))
prepared = a.copy()
# create empty plot
points, = ax.plot([], [], 'o')
# ax.grid(True)
# cache the background
background = fig.canvas.copy_from_bbox(ax.bbox)
is_released = True
class btaction:
default=100)
args = parser.parse_args()
cuda = torch.cuda.is_available()
set_seed(seed=1, cuda=cuda)
# Data
train_loader, train_dataset, test_loader, test_dataset = get_data_loaders(
batch_size=args.batch_size)
# Model
model, loss_fn, optimizer = get_model(
num_classes=args.num_classes,
learning_rate=args.learning_rate,
cuda=cuda)
start_epoch, best_accuracy = load_model(model, cuda)
for epoch in range(start_epoch, args.epochs):
train_model(model=model,
optimizer=optimizer,
train_loader=train_loader,
train_dataset=train_dataset,
loss_fn=loss_fn,
num_epochs=args.epochs,
epoch=epoch,
batch_size=args.batch_size,
notify=args.notify,
cuda=cuda)
accuracy = eval_model(model=model, test_loader=test_loader, cuda=cuda)
accuracy = 100. * accuracy / len(test_loader.dataset)