def load_models(settings):
device = torch.device(
"cuda") if torch.cuda.is_available() else torch.device("cpu")
model_class = ClassifierNet(settings).to(device)
model_emb = EmbeddingNet(settings).to(device)
model_emb, model_class = load_parameters_model(settings, model_emb,
model_class)
model_emb.eval()
model_class.eval()
return model_emb, model_class
def load_model(saved_model, grid_type, model_params):
#loading trained model
embedding_net = EmbeddingNet(
in_channels=grid_input_channels_dict[grid_type], **model_params)
model = TripletNet(embedding_net)
cuda = torch.cuda.is_available()
# cuda = False
if cuda:
model.cuda()
map_location = None
else:
map_location = torch.device('cpu')
state_dict = torch.load(saved_model, map_location=map_location)
new_state_dict = OrderedDict()
for k, v in state_dict.items():
name = k.replace('module.', '') # removing ‘moldule.’ from key
new_state_dict[name] = v
model.load_state_dict(new_state_dict)
model.eval()
return model
# Output demo:
# print (type(train_dataset.train_data[5]))
# print (train_dataset.train_data[5].size())
# print (train_dataset.train_data[5])
# print (type(train_dataset.train_labels[5]))
# print (train_dataset.train_labels[5].size())
# print (train_dataset.train_labels[5])
siamese_train_dataset = SiameseMNIST(train_dataset)
siamese_test_dataset = SiameseMNIST(test_dataset)
# set up data loaders
batch_size = 128
kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {}
train_loader = torch.utils.data.DataLoader(siamese_train_dataset, batch_size=batch_size, shuffle=True, **kwargs)
test_loader = torch.utils.data.DataLoader(siamese_test_dataset, batch_size=batch_size, shuffle=False, **kwargs)
margin = 1
embedding_net = EmbeddingNet()
model = SiameseNet(embedding_net)
if cuda:
model.cuda()
loss_fn = ContrastiveLoss(margin)
lr = 1e-3
optimizer = optim.Adam(model.parameters(), lr=lr)
scheduler = lr_scheduler.StepLR(optimizer, 8, gamma=0.1, last_epoch=-1)
n_epochs = 1
log_interval = 100
fit(train_loader, test_loader, model, loss_fn, optimizer, scheduler, n_epochs, cuda, log_interval)
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, SiameseNet
from losses import ContrastiveLoss
from metrics import AccumulatedAccuracyMetric
embedding_net = EmbeddingNet(embed_dim)
margin = 1.
model = SiameseNet(embedding_net)
if cuda:
if torch.cuda.device_count() > 1:
print("Let's use", torch.cuda.device_count(), "GPUs!")
# dim = 0 [30, xxx] -> [10, ...], [10, ...], [10, ...] on 3 GPUs
model = nn.DataParallel(model)
model.cuda()
model.load_state_dict(torch.load(trained_weight_file))
# from torch.utils.tensorboard import SummaryWriter
from tensorboardX import SummaryWriter
def main(args):
PATH = os.path.dirname(os.path.realpath(__file__))
PATH_TRAIN = args.path_train
FILE_NAME = f'{args.train_file}_{args.random_state}'
global MODEL_NAME
MODEL_NAME = args.model_name
training_log = PATH + f'/training_log/{args.model_name}_training_{args.log}.log'
with open(training_log, 'a') as f:
message = f'Training log {args.log} of {args.model_name} \n\n'
message += f'Starts at {datetime.datetime.now()}\n'
message += 'Arguments are: \n'
message += f'{str(args)}\n\n'
f.write(message)
f.flush()
cuda = torch.cuda.is_available()
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
message = f'Training on {torch.cuda.device_count()} {torch.cuda.get_device_name()}\n'
with open(training_log, 'a') as f:
f.write(message + '\n')
f.flush()
model_params = args.model_params
# initialize the model
embedding_net = EmbeddingNet(
in_channels=grid_input_channels_dict[args.grid_type], **model_params)
model = TripletNet(embedding_net)
start_epoch = 0
message = f'Initialize the model architecture\n'
# load saved model
if args.continue_training:
if args.saved_model is None:
message = f'Missing saved model name\n'
with open(training_log, 'a') as f:
f.write(message)
f.flush()
raise ValueError(message)
message += f'Read saved model {args.saved_model}\n'
start_epoch = int(re.search(r'Epoch(\d+)', args.saved_model).group(1))
if cuda:
map_location = None
else:
map_location = torch.device('cpu')
state_dict = torch.load(f'{PATH}/saved_model/{args.saved_model}',
map_location=map_location)
new_state_dict = OrderedDict()
for k, v in state_dict.items():
name = k.replace('module.', '') # removing ‘moldule.’ from key
new_state_dict[name] = v
model.load_state_dict(new_state_dict)
def model_initialization_method(method):
if method == 'xavier_normal':
def weights_init(m):
if isinstance(m, nn.Conv3d):
nn.init.xavier_normal_(m.weight.data)
if m.bias is not None:
torch.nn.init.zeros_(m.bias)
return weights_init
if method == 'xavier_uniform':
def weights_init(m):
if isinstance(m, nn.Conv3d):
nn.init.xavier_uniform_(m.weight.data)
if m.bias is not None:
torch.nn.init.zeros_(m.bias)
return weights_init
if args.model_init != 'default':
model.apply(model_initialization_method(args.model_init))
message += f'Model initialization method:{args.model_init}\n'
pytorch_total_params = sum(p.numel() for p in model.parameters()
if p.requires_grad)
# print total number of trainable parameters and model architecture
with open(training_log, 'a') as f:
message += f'Model architecture:\n{str(model)}\n'
message += f'Total number of trainable parameters is {pytorch_total_params}\n'
message += f'Training starts at : {datetime.datetime.now()}\n'
f.write(message)
f.flush()
# multi gpu
if torch.cuda.device_count() > 1:
model = nn.DataParallel(model)
model.to(device)
def dataset_class(data_type):
if data_type == 'molcoord':
return MolCoordDataset, TripletMolCoord
if data_type == 'grid':
return SingleGridDataset, TripletSingleGrid
DS, TripletDS = dataset_class(args.data_type)
if args.data_type == 'molcoord':
t0 = datetime.datetime.now()
df = pd.read_pickle(f'{PATH_TRAIN}{FILE_NAME}.pkl')
train_index, test_index = train_test_index(
df.shape[0], random_state=args.random_state)
# MolCoordDataset
molcoords = df.mol.apply(
lambda x: MolCoord.from_sdf(Chem.MolToMolBlock(x))).tolist()
# coordination rotation randomly
if args.grid_rotation == 1:
np.random.seed(args.random_state)
axis = np.random.rand(df.shape[0], 3) * 2 - 1
theta = np.random.rand(df.shape[0]) * np.pi * 2
for i in range(len(molcoords)):
matrix = torch.Tensor(matrix_from_axis_angel(
axis[i], theta[i]))
molcoords[i].coord_rotation_(matrix)
train_dataset = DS([molcoords[index] for index in train_index],
np.zeros(len(train_index), dtype=int),
grid_type=args.grid_type,
train=True)
test_dataset = DS([molcoords[index] for index in test_index],
np.zeros(len(test_index), dtype=int),
grid_type=args.grid_type,
train=False)
with open(training_log, 'a') as f:
message = f'Preparing dataset costs {datetime.datetime.now() - t0}'
f.write(message)
f.flush()
#release unreferenced memory
gc.collect()
del df
if args.data_type == 'grid':
grid_path = f'{args.path_train}/grids/grid_{args.grid_type}'
if args.grid_rotation == 1:
grid_path += '_rot'
grid_path += f'/{args.train_file}/{args.train_file}_{args.random_state}_grids'
num_data = int(
re.search(r'^.+training_(\d+)$', args.train_file).group(1))
test_size = 0.2
num_testdata = int(num_data * test_size)
num_traindata = num_data - num_testdata
t0 = datetime.datetime.now()
# GridDataset
train_dataset = SingleGridDataset(grid_path,
np.zeros(num_traindata),
train=True)
test_dataset = SingleGridDataset(grid_path,
np.zeros(num_testdata),
train=False)
with open(training_log, 'a') as f:
message = f'Preparing dataset costs {datetime.datetime.now() - t0}'
f.write(message + '\n')
f.flush()
batch_size = args.batch_size * torch.cuda.device_count()
margin = args.margin
loss_fn = WeightedTripletLoss(margin)
lr = args.learning_rate
optimizer = optim.Adam(model.parameters(), lr=lr)
scheduler = lr_scheduler.StepLR(optimizer,
step_size=8,
gamma=0.1,
last_epoch=-1)
n_epochs = args.n_epochs
log_interval = args.log_interval
metrics = []
es = EarlyStopping(patience=args.es_patience, min_delta=args.es_min_delta)
min_val_loss = np.inf
early_stopping_counter = 0
es_indicator = False
ckpt_interval = 3
# save the model after initialization
if start_epoch == 0:
with open(training_log, 'a') as f:
save(model, 'completed', start_epoch, f, args.log)
for epoch in range(0, start_epoch):
scheduler.step()
for epoch in range(start_epoch, n_epochs):
optimizer.step()
scheduler.step()
t_epoch_start = datetime.datetime.now()
message = f'Epoch {epoch + 1} starts at {t_epoch_start}'
with open(training_log, 'a') as f:
f.write(message + '\n')
f.flush()
t0 = datetime.datetime.now()
# clustering embedding vectors to get labels
if torch.cuda.device_count() > 1:
embedding_net = model.module.embedding_net
embedding_net = nn.DataParallel(embedding_net)
else:
embedding_net = model.embedding_net
embedding_net.eval()
embedding = []
for batch_index in divide_batches(list(range(num_traindata)),
batch_size):
with torch.no_grad():
embedding.append(
embedding_net(
train_dataset[batch_index]['grid'].cuda()).cpu())
for batch_index in divide_batches(list(range(num_testdata)),
batch_size):
with torch.no_grad():
embedding.append(
embedding_net(
test_dataset[batch_index]['grid'].cuda()).cpu())
embedding = torch.cat(embedding)
message = f'Epoch {epoch + 1} embedding computation costs {datetime.datetime.now() - t0}'
with open(training_log, 'a') as f:
f.write(message + '\n')
f.flush()
min_counts_labels = 1
cls_counter = 1
random_state = args.random_state
while min_counts_labels < 2:
t0 = datetime.datetime.now()
message = f'Epoch {epoch + 1} clustering {cls_counter} starts at {t0}\n'
with open(training_log, 'a') as f:
f.write(message)
f.flush()
random.seed(random_state)
random_state = int(random.random() * 1e6)
kwargs = {'verbose': 1}
cls = clustering_method(args.clustering_method, args.num_clusters,
random_state, **kwargs)
cls.fit(embedding)
labels = cls.predict(embedding)
train_labels = labels[:num_traindata]
test_labels = labels[num_traindata:]
# unique_labels, counts_labels = np.unique(labels, return_counts=True)
unique_labels_train, counts_labels_train = np.unique(
train_labels, return_counts=True)
unique_labels_test, counts_labels_test = np.unique(
test_labels, return_counts=True)
min_counts_labels = min(min(counts_labels_train),
min(counts_labels_test))
message = f'Epoch {epoch + 1} clustering {cls_counter} ends at {datetime.datetime.now()}\n'
message += f'Epoch {epoch + 1} clustering {cls_counter} costs {datetime.datetime.now() - t0}\n'
message += f'{len(unique_labels_train)} clusters for train in total\n'
message += f'The minimum number of samples in a cluster for train is {min(counts_labels_train)}\n'
message += f'The maximum number of samples in a cluster for train is {max(counts_labels_train)}\n'
message += f'{len(unique_labels_test)} clusters for test in total\n'
message += f'The minimum number of samples in a cluster for test is {min(counts_labels_test)}\n'
message += f'The maximum number of samples in a cluster for test is {max(counts_labels_test)}\n'
with open(training_log, 'a') as f:
f.write(message + '\n')
f.flush()
cls_counter += 1
if cls_counter > 10:
break
if min_counts_labels < 2:
with open(training_log, 'a') as f:
message = f'Cannot get good clustering results. Stop training.\n'
f.write(message + '\n')
f.flush()
break
if args.weighted_loss:
loss_weights_train = dict(
zip(
unique_labels_train, 1 / counts_labels_train *
len(train_labels) / len(unique_labels_train)))
loss_weights_test = dict(
zip(
unique_labels_test, 1 / counts_labels_test *
len(test_labels) / len(unique_labels_test)))
else:
loss_weights_train = dict(
zip(unique_labels_train, np.ones(len(unique_labels_train))))
loss_weights_test = dict(
zip(unique_labels_test, np.ones(len(unique_labels_test))))
train_dataset.labels = train_labels
test_dataset.labels = test_labels
t0 = datetime.datetime.now()
kwargs = {'num_workers': 0, 'pin_memory': True} if cuda else {}
train_loader = torch.utils.data.DataLoader(TripletDS(
train_dataset, grid_rotation=args.grid_rotation),
batch_size=batch_size,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(TripletDS(
test_dataset, grid_rotation=args.grid_rotation),
batch_size=batch_size,
shuffle=False,
**kwargs)
message = f'Epoch {epoch + 1} dataloader preparation costs {datetime.datetime.now() - t0}'
with open(training_log, 'a') as f:
f.write(message + '\n')
f.flush()
# Train stage
train_loss, metrics = train_epoch(
train_loader,
model,
loss_fn,
loss_weights_train,
optimizer,
cuda,
log_interval,
training_log,
metrics,
epoch,
ckpt_interval,
)
message = f'Epoch: {epoch + 1}/{n_epochs}. Train set: Average loss: {train_loss:.4f}'
for metric in metrics:
message += f'\t{metric.name()}: {metric.value()}'
val_loss, metrics = test_epoch(test_loader, model, loss_fn,
loss_weights_test, cuda, metrics, epoch)
val_loss /= len(test_loader)
message += f'\nEpoch: {epoch + 1}/{n_epochs}. Validation set: Average loss: {val_loss:.4f}'
for metric in metrics:
message += f'\t{metric.name()}: {metric.value()}\n'
message += f'\nEpoch {epoch + 1} costs: {str(datetime.datetime.now() - t_epoch_start)}\n'
print(message)
with open(training_log, 'a') as f:
f.write(message + '\n')
f.flush()
# output train loss and validation loss
with open(
re.search(r'(.+)\.log', training_log).group(1) + '_loss.csv',
'a') as f_loss:
message = f'{epoch + 1},{train_loss},{val_loss}\n'
f_loss.write(message)
f_loss.flush()
min_val_loss, early_stopping_counter, es_indicator = es(
val_loss, min_val_loss, early_stopping_counter)
# save models with improvement on test loss
if early_stopping_counter == 0:
with open(training_log, 'a') as f:
save(model, 'completed', epoch + 1, f, args.log)
# save models with no improvement on test loss
else:
with open(training_log, 'a') as f:
save(model, 'completed', epoch + 1, f, args.log)
message = f'min_val_loss: {min_val_loss:.4f}, # of epochs with no improvement: {early_stopping_counter}\n'
print(message)
f.write(message + '\n')
f.flush()
if es_indicator:
message = f'min_val_loss: {min_val_loss:.4f}, # of epochs with no improvement: {early_stopping_counter}\n'
message += f'Early Stopping after epoch {epoch + 1}\n'
print(message)
with open(training_log, 'a') as f:
f.write(message + '\n')
f.flush()
break
else:
message = f'min_val_loss: {min_val_loss:.4f}, # of epochs with no improvement: {early_stopping_counter}\n'
message += 'Training continued.\n'
print(message)
with open(training_log, 'a') as f:
f.write(message + '\n')
f.flush()
from networks import textEmbedding
from losses import InterTripletLoss
from networks import InterTripletNet
batch_size = 256
kwargs = {'num_workers': 32, 'pin_memory': True} if cuda else {}
i_triplet_train_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, sampler=train_sampler, **kwargs)
i_triplet_val_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, sampler=validation_sampler, **kwargs)
# Set up the network and training parameters
from networks import EmbeddingNet, TripletNet
from losses import TripletLoss
margin = 1.
text_embedding_net = textEmbedding()
image_embedding_net = EmbeddingNet()
model = InterTripletNet(image_embedding_net, text_embedding_net)
if cuda:
model.cuda()
loss_fn = InterTripletLoss(1.0)
lr = 1e-3
optimizer = optim.Adam(model.parameters(), lr=lr)
scheduler = lr_scheduler.StepLR(optimizer, 8, gamma=0.1, last_epoch=-1)
n_epochs = 20
log_interval = 100
fit(i_triplet_train_loader, i_triplet_val_loader, model, loss_fn, optimizer, scheduler, n_epochs, cuda, log_interval, text_dictionary, NUS_WIDE_classes,
tag_matrix, concept_matrix)
pickle.dump(model, open('entire_nuswide_model.p', 'wb'))
id_counts = train_full.Id.value_counts()
bbox_df = pd.read_csv("bounding_boxes.csv")
RESIZE_H = 224
RESIZE_W = 224
data_transforms_test = albumentations.Compose([
albumentations.Resize(RESIZE_H, RESIZE_W),
albumentations.Normalize(),
AT.ToTensor()
])
# load the best model and initialize EmbeddingNet
siamese_net = torch.load("best_net.pth")
state_dict = siamese_net.state_dict()
embed_net = EmbeddingNet()
temp_dict = {}
for key in state_dict.keys():
if key.startswith("embedding_net"):
temp_dict[key[14:len(key)]] = state_dict[key]
embed_net.load_state_dict(temp_dict)
# function to generate embedding
def getEmbedding(file_path, x):
file_name = os.path.join(file_path, x)
bbox = bbox_df.loc[bbox_df.Image == x, :].values[0, 1:]
img_pil = Image.open(file_name).crop(bbox).convert('RGB')
img = np.array(img_pil)
image = data_transforms_test(image=img)['image'].unsqueeze(0)
vector = embed_net(image)
embeddings = np.zeros((len(dataloader.dataset), 2))
labels = np.zeros(len(dataloader.dataset))
k = 0
for images, target in dataloader:
if cuda:
images = images.cuda()
embeddings[k:k + len(images)] = model.get_embedding(
images).data.cpu().numpy()
labels[k:k + len(images)] = target.numpy()
k += len(images)
return embeddings, labels
# In[4]:
model = EmbeddingNet()
model.load_state_dict(torch.load('./saved_model/titi'))
model.eval()
# In[5]:
final_test_epoch('/Users/ayush/projects/my_pytorch/probe',
'/Users/ayush/projects/my_pytorch/gallery',
'/Users/ayush/projects/my_pytorch/fp_output_txt',
model,
metrics=[AverageNonzeroTripletsMetric()],
transform=transforms.Compose([transforms.ToTensor()]))
# In[7]:
get_ipython().system('rm /Users/ayush/projects/my_pytorch/probe/.DS_Store')
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')
def train_and_visualize(train_dataset,
test_dataset,
dataset_wraper,
projection_layers,
model,
loss_fn,
n_epochs=10,
n_classes=10,
use_bn=False):
# Set up data loaders
batch_size = 256
kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {}
if dataset_wraper is not None:
vis_train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True,
**kwargs)
vis_test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=batch_size,
shuffle=False,
**kwargs)
train_dataset = dataset_wraper(train_dataset)
test_dataset = dataset_wraper(test_dataset)
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)
if dataset_wraper is None:
vis_train_loader, vis_test_loader = train_loader, test_loader
embedding_net = EmbeddingNet(projection_layers=projection_layers,
use_bn=use_bn)
if model == ClassificationNet:
model = model(embedding_net, n_classes=n_classes)
else:
model = model(embedding_net)
print(model)
if cuda:
model.cuda()
lr = 1e-2
optimizer = optim.Adam(model.parameters(), lr=lr)
scheduler = lr_scheduler.StepLR(optimizer, 8, gamma=0.1, last_epoch=-1)
log_interval = 50
metrics = []
if type(model) is ClassificationNet:
metrics = [AccumulatedAccuracyMetric()]
stats = fit(train_loader,
test_loader,
model,
loss_fn,
optimizer,
scheduler,
n_epochs,
cuda,
log_interval,
metrics=metrics)
plot_learning_curves(stats)
train_embeddings_baseline, train_labels_baseline, train_variances = extract_embeddings(
vis_train_loader, model)
val_embeddings_baseline, val_labels_baseline, val_variances = extract_embeddings(
vis_test_loader, model)
titles = [
'train (variances explained: {})'.format(train_variances),
'valid (variances explained: {})'.format(val_variances)
]
plot_embeddings([train_embeddings_baseline, val_embeddings_baseline],
[train_labels_baseline, val_labels_baseline],
titles=titles)
def visualize_evolution(train_dataset,
test_dataset,
dataset_wraper,
projection_layers,
model,
loss_fn,
n_epochs=10,
n_classes=10):
# Set up data loaders
batch_size = 256
kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {}
if dataset_wraper is not None:
vis_train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True,
**kwargs)
vis_test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=batch_size,
shuffle=False,
**kwargs)
train_dataset = dataset_wraper(train_dataset)
test_dataset = dataset_wraper(test_dataset)
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)
if dataset_wraper is None:
vis_train_loader, vis_test_loader = train_loader, test_loader
embedding_net = EmbeddingNet(projection_layers=projection_layers)
if model == ClassificationNet:
model = model(embedding_net, n_classes=n_classes)
else:
model = model(embedding_net)
if cuda:
model.cuda()
lr = 1e-2
optimizer = optim.Adam(model.parameters(), lr=lr)
scheduler = lr_scheduler.StepLR(optimizer, 8, gamma=0.1, last_epoch=-1)
log_interval = 50
metrics = []
if type(model) is ClassificationNet:
metrics = [AccumulatedAccuracyMetric()]
embeddings, labels, titles = [], [], []
for step in range(n_epochs):
val_embeddings_baseline, val_labels_baseline, val_variances = extract_embeddings(
vis_test_loader, model)
embeddings.append(val_embeddings_baseline)
labels.append(val_labels_baseline)
title = 'step {}: train'.format(step)
if val_variances is not None:
title += ' (variances explained: {})'.format(val_variances)
titles.append(title)
stats = fit(train_loader,
test_loader,
model,
loss_fn,
optimizer,
scheduler,
1,
cuda,
log_interval,
metrics=metrics)
plot_embeddings(embeddings,
labels,
titles=titles,
subplot_rows=math.ceil(n_epochs / 2),
subplot_cols=2,
figsize=[40, 10 * n_epochs])
def run_net(params, transforms):
if params["fixed_seed"] is not None:
torch.backends.cudnn.deterministic = True
random.seed(1)
torch.manual_seed(1)
torch.cuda.manual_seed(1)
np.random.seed(1)
if params["gpu_id"] is not None:
device = torch.device("cuda:{}".format(params["gpu_id"]))
else:
device = torch.device('cpu')
if params["dset"] == "CIFAR10":
concatenated = torch.utils.data.ConcatDataset([
CIFAR10(root='./data', train=True, download=True, transform=None),
CIFAR10(root='./data', train=False, download=True, transform=None)
])
elif params["dset"] == "MNIST":
concatenated = torch.utils.data.ConcatDataset([
MNIST(root='./data', train=True, download=True, transform=None),
MNIST(root='./data', train=False, download=True, transform=None)
])
elif params["dset"] == "FASHIONMNIST":
concatenated = torch.utils.data.ConcatDataset([
FashionMNIST(root='./data',
train=True,
download=True,
transform=None),
FashionMNIST(root='./data',
train=False,
download=True,
transform=None)
])
triplet_test = RandomTripletMiningDataset(concatenated,
train=False,
trans=transforms,
device=None,
params=params)
# Initialize model
if params["dset"] == "CIFAR10":
embedding_net = EmbeddingNet(
in_channels=3,
adjusting_constant=5) # Change this to VGG for CIFAR10
elif params["dset"] == "MNIST" or params["dset"] == "FASHIONMNIST":
embedding_net = EmbeddingNet()
model = TripletNet(embedding_net).to(device)
# Sets the datetime string to use as an identifier for the future
if params["run_id"] is None:
params["run_id"] = '_'.join(
(str(datetime.datetime.now()).split('.')[0].split()))
params["embedding_net_path"] = "arches/embedding_net_{}".format(
params["run_id"])
# Train our model
if params["do_learn"]:
# Initialize loss functions
train_loss = TripletLoss(margin=params["margin"])
test_loader = torch.utils.data.DataLoader(
triplet_test, batch_size=params["batch_size"], shuffle=True
) # Test data is the same as train data but test data is not preshuffled
writer = SummaryWriter(comment="triplet_{0}_{1}_{2}".format(
params["dset"], params["num_pairs"], params["rtm_index"]))
optimizer = optim.Adam(model.parameters(),
lr=params["starting_lr"],
weight_decay=params["weight_decay"])
test(model,
device,
test_loader,
writer,
record_histograms=False,
params=params)
for epoch in range(params["num_epochs"]):
params["curr_epoch"] = epoch
torch.save(model.embedding_net.state_dict(),
params["embedding_net_path"])
triplet_train = RandomTripletMiningDataset(concatenated,
train=True,
trans=transforms,
device=device,
params=params)
train_loader = torch.utils.data.DataLoader(
triplet_train, batch_size=params["batch_size"], shuffle=True)
sample_loader = torch.utils.data.DataLoader(
triplet_train,
batch_size=len(triplet_train) // 100,
shuffle=True
) # Sample our data to get a reference point after every so often
sample_data, sample_targets = next(iter(sample_loader))
if params["show_plots"]:
show_datasets(sample_data)
similar_pair_accuracy = np.round(
len(np.where(sample_targets[0] == sample_targets[1])[0]) /
len(sample_targets[0]), 3)
different_pair_accuracy = np.round(
len(np.where(sample_targets[0] != sample_targets[2])[0]) /
len(sample_targets[0]), 3)
print("Similar pair accuracy:", similar_pair_accuracy)
print("Different pair accuracy:", different_pair_accuracy)
params["different_random_pair_accuracy"] = different_pair_accuracy
params["similar_random_pair_accuracy"] = similar_pair_accuracy
train(model,
device,
train_loader,
train_loss,
epoch,
optimizer,
sample_data,
params=params)
embeddings, targets, indices = test(model,
device,
test_loader,
writer,
epoch=epoch,
params=params)
write_to_tensorboard(
params, writer,
epoch) # Writes to tensorboard at the end of the epoch
writer.export_scalars_to_json(".all_scalars.json")
writer.close()
curr_date = datetime.datetime.now()
date_str = curr_date.strftime("./models/%m_%d_%Y_%H_%M_model_cifar")
print("Saving the full model to: %s" % str(date_str))
torch.save(model, date_str)
print("Model was saved successfully")
def init_models(args):
device = torch.device(
"cuda") if torch.cuda.is_available() else torch.device("cpu")
EmbeddingModel = EmbeddingNet(args).to(device)
ClassifierModel = ClassifierNet(args).to(device)
return EmbeddingModel, ClassifierModel
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')
train_dataset = SiameseDataset(datafolder="train/",
df=train_df, bbox_df=bbox_df, datatype='train', transform = data_transforms)
valid_dataset = SiameseDataset(datafolder="train/",
df=valid_df, bbox_df=bbox_df, datatype='train', transform = data_transforms)
train_dataloader = DataLoader(train_dataset,
shuffle=True,
num_workers=0,
batch_size=64)
valid_dataloader = DataLoader(train_dataset,
shuffle=False,
num_workers=0,
batch_size=32)
embed = EmbeddingNet().cuda()
net = SiameseNet(embed).cuda()
#embed = EmbeddingNet()
#net = SiameseNet(embed)
criterion = ContrastiveLoss(margin=0.2)
optimizer = optim.Adam(net.parameters(),lr = 0.0005 )
counter = []
loss_history = []
iteration_number= 0
epoch_num = 50
loss = 0
tol_loss = [10]
from utils import AllTripletSelector, HardestNegativeTripletSelector, RandomNegativeTripletSelector, SemihardNegativeTripletSelector # Strategies for selecting triplets within a minibatch
from metrics import AverageNonzeroTripletsMetric
transform = transforms.Compose([
Scale(96),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])
cuda = torch.cuda.is_available()
kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {}
train_path = './data/train'
test_path = './data/val'
batch_size = 8
embedding_size = 16
margin = 1.
embedding_net = EmbeddingNet(embedding_size=embedding_size)
model = embedding_net
if cuda:
model.cuda()
loss_fn = OnlineTripletLoss(margin, RandomNegativeTripletSelector(margin))
lr = 1e-3
optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=1e-4)
scheduler = lr_scheduler.StepLR(optimizer, 8, gamma=0.1, last_epoch=-1)
n_epochs = 5
log_interval = 25
log_dir = './log'
optimizer_name = 'Adam'
LOG_DIR = log_dir + '/run-optim{}-lr{}-embbeding_size{}'.format(
optimizer_name, lr, embedding_size)
logger = Logger(LOG_DIR)