transform=train_transform)
dataset_val = VGG10Dataset('data', 'vgg10vallist.txt', train=False)
loss_fn = nn.CrossEntropyLoss()
train_loader = DataLoader(dataset_tr,
batch_size=batch_size,
shuffle=True,
**kwargs)
val_loader = DataLoader(dataset_val,
batch_size=batch_size,
shuffle=False,
**kwargs)
embedding_net = EmbeddingNet()
model = ClassificationNet(embedding_net, nclasses)
if cuda:
model = nn.DataParallel(model).cuda()
optimizer = optim.SGD(model.parameters(),
lr=lr,
nesterov=True,
momentum=0.9,
weight_decay=1e-4)
scheduler = lr_scheduler.CosineAnnealingLR(optimizer,
20,
eta_min=1e-5,
last_epoch=-1)
fit(train_loader,
val_loader,
kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {}
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=batch_size,
shuffle=False,
**kwargs)
# Set up the network and training parameters
from networks import EmbeddingNet, ClassificationNet
from metrics import AccumulatedAccuracyMetric
embedding_net = EmbeddingNet()
model = ClassificationNet(embedding_net, n_classes=n_classes)
if cuda:
model.cuda()
loss_fn = torch.nn.NLLLoss()
lr = 1e-2
optimizer = optim.Adam(model.parameters(), lr=lr)
scheduler = lr_scheduler.StepLR(optimizer, 8, gamma=0.1, last_epoch=-1)
n_epochs = 20
log_interval = 50
fit(train_loader,
test_loader,
model,
loss_fn,
optimizer,
scheduler,
train_transform = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(hue=0.1),
transforms.RandomGrayscale(p=0.1)
]) # we dont add ToTensor as it is done using from_numpy in the dataset class
dataset_tr = VGG10Dataset('data',
'vgg10trainlist.txt',
transform=train_transform)
dataset_val = VGG10Dataset('data', 'vgg10vallist.txt', train=False)
loss_fn = DopplegangerLoss()
embedding_net = EmbeddingNet()
model = ClassificationNet(embedding_net, nclasses)
if cuda:
model = nn.DataParallel(model).cuda()
loss_fn = loss_fn.cuda()
optimizer = optim.SGD([{
'params': model.parameters()
}, {
'params': loss_fn.parameters()
}],
lr=lr,
nesterov=True,
momentum=0.9,
weight_decay=1e-4)
scheduler = lr_scheduler.CosineAnnealingLR(optimizer,
20,
accuracy = []
thd = []
folds = KFold(n=6000, n_folds=10)
thresholds = np.arange(-1.0, 1.0, 0.005)
#predicts = np.array(map(lambda line: line.strip('\n').split(), predicts))
predicts = np.array(predicts)
for idx, (train, test) in enumerate(folds):
best_thresh = find_best_threshold(thresholds, predicts[train])
accuracy.append(eval_acc(best_thresh, predicts[test]))
thd.append(best_thresh)
print('LFWACC={:.4f} std={:.4f} thd={:.4f}'.format(np.mean(accuracy),
np.std(accuracy),
np.mean(thd)))
return np.mean(accuracy), predicts
if __name__ == '__main__':
#breakpoint()
mining_tech = 'RandomSampling_l2_parametrized'
model_eval = nn.DataParallel(ClassificationNet(EmbeddingNet(),
854)).to('cuda')
_, result = eval(model_eval,
model_path=os.path.join('checkpoints', mining_tech,
'best_model.pth'))
np.savetxt(os.path.join('results', mining_tech, 'result.txt'), result,
'%s')
# Set up data loaders
batch_size = 64
kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {}
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, **kwargs)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False, **kwargs)
# Set up the network and training parameters
from networks import EmbeddingNet, ClassificationNet
from metrics import AccumulatedAccuracyMetric
n_items = 7981
embed_dim = 2
embedding_net = EmbeddingNet(embed_dim)
model = ClassificationNet(embedding_net, n_classes=n_items)
if cuda:
model.cuda()
loss_fn = torch.nn.NLLLoss()
lr = 1e-2
optimizer = optim.Adam(model.parameters(), lr=lr)
scheduler = lr_scheduler.StepLR(optimizer, 8, gamma=0.1, last_epoch=-1)
# n_epochs = 20
n_epochs = 20
log_interval = 1
if not resume_from_pth:
record_history = fit(train_loader, test_loader, model, loss_fn, optimizer, scheduler, n_epochs, cuda, log_interval, metrics=[AccumulatedAccuracyMetric()])
plot_history(experiment_folder, record_history)
torch.save(model.state_dict(), trained_weight_file)
kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {}
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=batch_size,
shuffle=False,
**kwargs)
# Set up the network and training parameters
from networks import EmbeddingNet, ClassificationNet, EmbeddingResnet
from metrics import AccumulatedAccuracyMetric
embedding_net = EmbeddingResnet()
model = ClassificationNet(embedding_net, n_classes=n_classes)
if cuda:
model.cuda()
loss_fn = nn.NLLLoss()
lr = 1e-2
#optimizer = optim.Adam(model.parameters(), lr=lr)
optimizer = optim.SGD(model.parameters(),
lr=lr,
momentum=0.9,
weight_decay=0.0005)
scheduler = lr_scheduler.StepLR(optimizer, 8, gamma=0.1, last_epoch=-1)
n_epochs = 25
log_interval = 50
fit(train_loader,
test_loader,
shuffle=True,
num_workers=4)
test_loader = DataLoader(test_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=4)
no_of_training_batches = len(train_loader) / batch_size
no_of_test_batches = len(test_loader) / batch_size
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
n_classes = 10
epochs = 20
embeddingNet = EmbeddingNet()
classificationNet = ClassificationNet(embeddingNet, n_classes)
optimizer = optim.Adam(classificationNet.parameters(),
lr=0.001,
betas=(0.9, 0.999),
weight_decay=0.0005)
def visualize_tensor(x):
x = x.squeeze(0)
x = x.squeeze(0)
x = x.numpy()
plt.imshow(x, cmap='gray')
plt.show()
def main():
"""main function"""
writer = SummaryWriter(log_dir='runs/' + args.log_dir) # tensorboard
# hyper parameters setting
lr = args.lr
k = args.K
amount = args.amount
n_epochs = args.n_epochs
log_interval = 100
batch_size = args.batch_size
pretrained = args.pretrained
method = args.method
n_K = args.n_K
margin = args.margin
shuffle_interval = args.shuffle_interval
opt = args.optimizer
step_size = args.step_size
global_loss = args.global_loss
triplet_loss_p = args.triplet_loss_p
network = args.network
embedding_len = args.embedding_len
batch_n_classes = args.batch_n_classes
batch_n_num = args.batch_n_num
use_sampler = args.use_sampler
rm_zero = args.rm_zero
center_sigma = args.center_sigma
gamma = args.gamma
weight_decay = args.weight_decay
data_augmentation = args.data_augmentation
save_model_path = args.save_model_path
log_dir = args.log_dir
freeze_parameter = args.freeze_parameter
use_cross_entropy = args.use_cross_entropy
# load data
dataset = SpecificDataset(args.dataset, data_augmentation)
n_classes = dataset.n_classes
classes = dataset.classes
channels = dataset.channels
width, height = dataset.width, dataset.height
gap = dataset.gap
train_dataset = SampledDataset(dataset.train_dataset, channels, amount)
print('Train data has {}'.format(len(train_dataset)))
test_dataset = dataset.test_dataset
print('Validation data has {}'.format(len(test_dataset)))
test_dataset_fc = dataset.test_dataset_fc if dataset.test_dataset_fc is not None else None
kwargs = {'num_workers': 8, 'pin_memory': False}
# tarin_shuffle = True if shuffle_interval == 0 else False
tarin_shuffle = (shuffle_interval == 0)
batch_sampler = BatchSampler(train_dataset, n_classes=batch_n_classes, n_num=batch_n_num)
sampler_train_loader = torch.utils.data.DataLoader(train_dataset,
batch_sampler=batch_sampler, **kwargs)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size, shuffle=tarin_shuffle, **kwargs)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=batch_size, shuffle=False, **kwargs)
test_fc_loader = torch.utils.data.DataLoader(test_dataset_fc,
batch_size=batch_size, shuffle=False,
**kwargs) if test_dataset_fc is not None else None
embedding_net = EmbeddingNet(network=network, pretrained=pretrained,
embedding_len=embedding_len, gap=gap, freeze_parameter=freeze_parameter)
if method == 'classification':
# model = resnet.resnet32().cuda()
model = ClassificationNet(embedding_net, n_classes=n_classes, embedding_len=embedding_len).cuda()
elif method in ['kTriplet', 'batchHardTriplet', 'batchAllTriplet', 'batchSemiHardTriplet']:
model = embedding_net.cuda()
else:
print('method must provide')
sys.exit(-1)
optimizer = get_optimizer(opt, model, lr, weight_decay)
if opt == 'SGD':
#if args.dataset == 'SD198':
#scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[200, 500, 950], gamma=0.5, last_epoch=-1)
#else:
scheduler = lr_scheduler.StepLR(optimizer, step_size, gamma=0.5, last_epoch=-1)
else:
scheduler = None
# add model graph into tensorboard
#dummy_input = torch.zeros(size=(batch_size, channels, height, width)).cuda()
#writer.add_graph(model, dummy_input)
#del dummy_input
if method == 'classification':
loss_fn = nn.CrossEntropyLoss().cuda()
fit_classification(train_loader, test_loader, test_fc_loader, model, loss_fn, optimizer, scheduler, n_epochs,
writer=writer, n_classes=n_classes, data_augmentation=data_augmentation)
elif method in ['kTriplet', 'batchHardTriplet', 'batchAllTriplet', 'batchSemiHardTriplet']:
loss_fn = nn.TripletMarginLoss(margin=margin, p=triplet_loss_p, reduction='none').cuda()
fit(train_loader, sampler_train_loader, test_loader, test_fc_loader, model, loss_fn, optimizer, scheduler,
n_epochs, k, n_K, log_interval, shuffle_interval, global_loss=global_loss, writer=writer,
n_classes=n_classes, gamma=gamma, center_sigma=center_sigma, use_sampler=use_sampler, rm_zero=rm_zero,
method=method, data_augmentation=data_augmentation, freeze_parameter=freeze_parameter, use_cross_entropy=use_cross_entropy)
# save model
save_model_path = os.path.join(save_model_path, log_dir)
torch.save(model.state_dict(), save_model_path)
print('save model in {}'.format(save_model_path))
# plot tensor in tensorboard
train_embeddings_tl, train_labels_tl = extract_embeddings(train_loader, model, embedding_len)
plot_embeddings(train_embeddings_tl, train_labels_tl, classes, writer, tag='train_embeddings')
val_embeddings_tl, val_labels_tl = extract_embeddings(test_loader, model, embedding_len)
plot_embeddings(val_embeddings_tl, val_labels_tl, classes, writer, tag='val_embeddings')
mnist_classes = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf']
batch_size = 4096
train_loader = DataLoader(train_dataset, batch_size = batch_size, shuffle = True, num_workers = 4)
test_loader = DataLoader(test_dataset, batch_size = batch_size, shuffle = True, num_workers = 4)
no_of_training_batches = len(train_loader)/batch_size
no_of_test_batches = len(test_loader)/batch_size
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
n_classes = 10
embeddingNet = EmbeddingNet()
classificationNet = ClassificationNet(embeddingNet, n_classes)
model = classificationNet
model.to(device)
checkpoint = torch.load(checkpoints_path)
model_parameters = checkpoint['state_dict']
model.load_state_dict(model_parameters)
model.eval()
def plot_embeddings(embeddings, targets):
for i in range(10):
inds = np.where(targets == i)[0]
x = embeddings[inds, 0]
y = embeddings[inds, 1]
plt.scatter(x, y, alpha = 0.5, color = colors[i])