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)