def main(): args = arg() model = SiameseNetwork() if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() optimizer = chainer.optimizers.Adam() optimizer.setup(model) train, test = chainer.datasets.get_mnist(ndim=3) train_iter = chainer.iterators.SerialIterator(train, args.batch) test_iter = chainer.iterators.SerialIterator(test, args.batch, repeat=False, shuffle=False) updater = SiameseUpdater(train_iter, optimizer, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend(extensions.LogReport()) trainer.extend(extensions.PrintReport( ['epoch', 'elapsed_time', 'main/loss'])) trainer.extend(extensions.ProgressBar()) trainer.extend(plot_testdata(model, test, args.batch), trigger=(1, 'epoch')) trainer.run()
def main(): dataset_path = 'gen_simulated_data' use_augmentation = False learning_rate = 10e-4 batch_size = 32 # Learning Rate multipliers for each layer learning_rate_multipliers = {} learning_rate_multipliers['Conv1'] = 1 learning_rate_multipliers['Conv2'] = 1 learning_rate_multipliers['Conv3'] = 1 learning_rate_multipliers['Conv4'] = 1 #learning_rate_multipliers['Conv5'] = 1 learning_rate_multipliers['Dense1'] = 1 # l2-regularization penalization for each layer l2_penalization = {} l2_penalization['Conv1'] = 1e-2 l2_penalization['Conv2'] = 1e-2 l2_penalization['Conv3'] = 1e-2 l2_penalization['Conv4'] = 1e-2 #l2_penalization['Conv5'] = 1e-2 l2_penalization['Dense1'] = 1e-4 # Path where the logs will be saved tensorboard_log_path = './logs/siamese_net_lr10e-4' siamese_network = SiameseNetwork( dataset_path=dataset_path, learning_rate=learning_rate, batch_size=batch_size, use_augmentation=use_augmentation, learning_rate_multipliers=learning_rate_multipliers, l2_regularization_penalization=l2_penalization, tensorboard_log_path=tensorboard_log_path) # Final layer-wise momentum (mu_j in the paper) momentum = 0.9 # linear epoch slope evolution momentum_slope = 0.01 # support_set指支持一次"图像验证"的图像集合,即1:N image evaluation的N support_set_size = 20 # evaluation时需要进行验证的图像数目 number_of_tasks_per_bucket = 20 evaluate_each = 500 number_of_train_iterations = 1000000 validation_accuracy = siamese_network.train_siamese_network( number_of_iterations=number_of_train_iterations, support_set_size=support_set_size, final_momentum=momentum, momentum_slope=momentum_slope, evaluate_each=evaluate_each, model_name='siamese_net_lr10e-4') if validation_accuracy == 0: evaluation_accuracy = 0 else: # Load the weights with best validation accuracy siamese_network.model.load_weights('.models/siamese_net_lr10e-4.h5') evaluation_accuracy = siamese_network.chars_loader.one_shot_test( siamese_network.model, support_set_size, number_of_tasks_per_bucket, False) print('Final Evaluation Accuracy = ' + str(evaluation_accuracy))
def __init__(self): self.siamese_network = SiameseNetwork() self.input_shape = self.INPUT_SHAPE self.triplet_model = self.siamese_network.model self.train_siamese_network() self.model = self.trained_model() self.save_model_weights()
def main(): dataset_path = 'Omniglot Dataset' use_augmentation = True learning_rate = 10e-4 #batch_size = 128 batch_size = 256 # Learning Rate multipliers for each layer learning_rate_multipliers = {} learning_rate_multipliers['Conv1'] = 1 learning_rate_multipliers['Conv2'] = 1 learning_rate_multipliers['Conv3'] = 1 learning_rate_multipliers['Conv4'] = 1 learning_rate_multipliers['Dense1'] = 1 # l2-regularization penalization for each layer l2_penalization = {} l2_penalization['Conv1'] = 1e-2 l2_penalization['Conv2'] = 1e-2 l2_penalization['Conv3'] = 1e-2 l2_penalization['Conv4'] = 1e-2 l2_penalization['Dense1'] = 1e-4 # Path where the logs will be saved tensorboard_log_path = './logs/siamese_net_lr10e-4' siamese_network = SiameseNetwork( dataset_path=dataset_path, learning_rate=learning_rate, batch_size=batch_size, use_augmentation=use_augmentation, learning_rate_multipliers=learning_rate_multipliers, l2_regularization_penalization=l2_penalization, tensorboard_log_path=tensorboard_log_path) # Final layer-wise momentum (mu_j in the paper) momentum = 0.9 # linear epoch slope evolution momentum_slope = 0.01 support_set_size = 20 evaluate_each = 1000 #number_of_train_iterations = 250000 number_of_train_iterations = 125000 validation_accuracy = siamese_network.train_siamese_network( number_of_iterations=number_of_train_iterations, support_set_size=support_set_size, final_momentum=momentum, momentum_slope=momentum_slope, evaluate_each=evaluate_each, model_name='siamese_net_lr10e-4') if validation_accuracy == 0: evaluation_accuracy = 0 else: # Load the weights with best validation accuracy siamese_network.model.load_weights('./models/siamese_net_lr10e-4.h5') evaluation_accuracy = siamese_network.omniglot_loader.one_shot_test( siamese_network.model, 20, 40, False) print('Final Evaluation Accuracy = ' + str(evaluation_accuracy))
def main(): learning_rate = 10e-4 batch_size = 32 epochs = 15 height = 256 width = 256 # Learning Rate multipliers for each layer learning_rate_multipliers = {} learning_rate_multipliers['Conv1'] = 1 learning_rate_multipliers['Conv2'] = 1 learning_rate_multipliers['Conv3'] = 1 learning_rate_multipliers['Conv4'] = 1 learning_rate_multipliers['Dense1'] = 1 # l2-regularization penalization for each layer l2_penalization = {} l2_penalization['Conv1'] = 1e-2 l2_penalization['Conv2'] = 1e-2 l2_penalization['Conv3'] = 1e-2 l2_penalization['Conv4'] = 1e-2 l2_penalization['Dense1'] = 1e-4 # Path where the logs will be saved tensorboard_log_path = './logs/siamese_net_lr10e-4' siamese_network = SiameseNetwork( learning_rate=learning_rate, batch_size=batch_size, epochs=epochs, learning_rate_multipliers=learning_rate_multipliers, l2_regularization_penalization=l2_penalization, tensorboard_log_path=tensorboard_log_path) # Data os.chdir("/data8t/ljq/whale_data/whale_data/siamese_networks/") train_data_temp = np.load('training_data.npy') train_data = [train_data_temp[0]] train_data.append(train_data_temp[1]) train_label = np.load('training_label.npy') val_data_temp = np.load('validation_data.npy') val_data = [val_data_temp[0]] val_data.append(val_data_temp[1]) val_label = np.load('validation_label.npy') # train_base_num = 1000 # train_data = [np.zeros((train_base_num * 6, height, width, 3)) for j in range(2)] # train_label = np.zeros((train_base_num * 6, 1)) # val_data = [np.ones((train_base_num * 2, height, width, 3)) for j in range(2)] # val_label = np.ones((train_base_num * 2, 1)) siamese_network.train_siamese_network(model_name='siamese_net_whale', train_data=train_data, train_label=train_label, val_data=val_data, val_label=val_label)
def main(): # test = Image.open("./data/1.pgm") # test.show() # print (test) print("Training starts...") folder_dataset = dset.ImageFolder(root=Config.training_dir) siamese_dataset = Contrastive_Dataset(imageFolderDataset=folder_dataset, transform=transforms.Compose([ transforms.Resize((100, 100)), transforms.ToTensor() ]), should_invert=False) train_dataloader = DataLoader(siamese_dataset, shuffle=True, num_workers=8, batch_size=Config.train_batch_size) net = SiameseNetwork() criterion = ContrastiveLoss() optimizer = optim.Adam(net.parameters(), lr=0.0005) counter = [] loss_history = [] iteration_number = 0 for epoch in range(0, Config.train_number_epochs): for i, data in enumerate(train_dataloader, 0): img0, img1, label = data img0, img1, label = Variable(img0), Variable(img1), Variable(label) output1, output2 = net(img0, img1) optimizer.zero_grad() loss_contrastive = criterion(output1, output2, label) loss_contrastive.backward() optimizer.step() if i % 10 == 0: print("Epoch number {}\n Current loss {}\n".format( epoch, loss_contrastive.data[0])) iteration_number += 10 counter.append(iteration_number) loss_history.append(loss_contrastive.data[0]) torch.save(net.state_dict(), "trained_weights.pt") # save_checkpoint({ # 'epoch': epoch + 1, # }) show_plot(counter, loss_history)
def main(): dataset_path = 'data/split_dataset_NOMASK/train' model_name = 'model_train_NOMASK' use_augmentation = True learning_rate = 1e-2 batch_size = 16 # Learning Rate multipliers for each layer learning_rate_multipliers = {'Conv1': 1, 'Conv2': 1, 'Conv3': 1, 'Conv4': 1, 'Dense1': 1} # l2-regularization penalization for each layer l2_penalization = {'Conv1': 1e-2, 'Conv2': 1e-2, 'Conv3': 1e-2, 'Conv4': 1e-2, 'Dense1': 1e-4} # Path where the logs will be saved tensorboard_log_path = f'./logs/{model_name}' siamese_network = SiameseNetwork( dataset_path=dataset_path, learning_rate=learning_rate, batch_size=batch_size, use_augmentation=use_augmentation, learning_rate_multipliers=learning_rate_multipliers, l2_regularization_penalization=l2_penalization, tensorboard_log_path=tensorboard_log_path ) # Final layer-wise momentum (mu_j in the paper) momentum = 0.9 # linear epoch slope evolution momentum_slope = 0.01 support_set_size = 20 evaluate_each = 500 number_of_train_iterations = 30000 validation_accuracy = siamese_network.train_siamese_network(number_of_iterations=number_of_train_iterations, support_set_size=support_set_size, final_momentum=momentum, momentum_slope=momentum_slope, evaluate_each=evaluate_each, model_name=model_name) if validation_accuracy == 0: evaluation_accuracy = 0 else: # Load the weights with best validation accuracy siamese_network.model.load_weights(f'./models/{model_name}.h5') evaluation_accuracy = siamese_network.omniglot_loader.one_shot_test(siamese_network.model, 20, 40, False) print('Final Evaluation Accuracy = ' + str(evaluation_accuracy))
def test(model_path, data_path, target_tag, pair_num, save_result=False): model = SiameseNetwork() model.load_state_dict( torch.load(model_path, map_location='cpu')['model_state_dict']) result = [] for i in range(0, pair_num): im1, im2, is_same, first_image, second_image = random_data_generator( data_path, target_tag) predict = model(im1.unsqueeze(0), im2.unsqueeze(0)).item() result.append((first_image, second_image, predict, is_same)) if save_result: plt.figure(figsize=(4, 12), dpi=300) plt.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=None, hspace=1.5) for i, item in enumerate(result): first_image, second_image, predict, is_same = item[0], item[ 1], item[2], item[3] img1 = Image.open(first_image) img2 = Image.open(second_image) img1 = img1.convert('RGB') img2 = img2.convert('RGB') plt.subplot(pair_num, 2, 2 * i + 1) plt.axis('off') plt.title('Label=%s, Prediction=%s' % (str(is_same), str(predict)), fontsize=4) plt.imshow(img1) plt.subplot(pair_num, 2, 2 * i + 2) plt.axis('off') plt.title('Real Label=%s' % second_image.split('/')[-2], fontsize=4) plt.imshow(img2) plt.savefig('./result.png', dpi=300) return result
def run_combination(l, bs, ep, pat, md, seed, train_path, test_path): """ This function gets the parameters and run the experiment. :return: loss - loss on the testing set, accuracy - accuracy on the testing set """ # file types model_save_type = 'h5' # files paths initialize_seed(seed) parameters_name = f'seed_{seed}_lr_{l}_bs_{bs}_ep_{ep}_val_{validation_size}_' \ f'es_{early_stopping}_pa_{pat}_md_{md}' print(f'Running combination with {parameters_name}') # A path for the weights load_weights_path = os.path.join( data_path, 'weights', f'weights_{parameters_name}.{model_save_type}') siamese = SiameseNetwork(seed=seed, width=WIDTH, height=HEIGHT, cells=CEELS, loss=loss_type, metrics=['accuracy'], optimizer=Adam(lr=l), dropout_rate=0.4) siamese.fit(weights_file=load_weights_path, train_path=train_path, validation_size=validation_size, batch_size=bs, epochs=ep, early_stopping=early_stopping, patience=pat, min_delta=md) loss, accuracy = siamese.evaluate(test_file=test_path, batch_size=bs, analyze=True) print(f'Loss on Testing set: {loss}') print(f'Accuracy on Testing set: {accuracy}') # predict_pairs(model) return loss, accuracy
def main(): parser = argparse.ArgumentParser() parser.add_argument('-img', type=str, default='test.jpg') # parser.add_argument('-ques', type=str, default='What vechile is in the picture?') args = parser.parse_args() img = args.img folder_dataset_test = dset.ImageFolder(root=Config.testing_dir) siamese_dataset = SiameseNetworkDataset( imageFolderDataset=folder_dataset_test, transform=transforms.Compose( [transforms.Resize((100, 100)), transforms.ToTensor()]), should_invert=False) img = Image.open(img) img = img.convert("L") transform = transforms.Compose( [transforms.Resize((100, 100)), transforms.ToTensor()]) img = transform(img) # Add a dimension to image to make padding possible. img = img[None, :, :, :] test_dataloader = DataLoader(siamese_dataset, num_workers=3, batch_size=1) dataiter = iter(test_dataloader) net = SiameseNetwork() net.load_state_dict(torch.load("trained_weights.pt")) for i in range(4): _, x1, label2 = next(dataiter) concatenated = torch.cat((img, x1), 0) output1, output2 = net(Variable(img), Variable(x1)) euclidean_distance = F.pairwise_distance(output1, output2) imshow( torchvision.utils.make_grid(concatenated), 'Dissimilarity: \ {:.2f}'.format(euclidean_distance.data.numpy()[0][0]))
class TrainModel(): def __init__(self): self.siamese_network = SiameseNetwork() self.input_shape = self.INPUT_SHAPE self.triplet_model = self.siamese_network.model self.train_siamese_network() self.model = self.trained_model() self.save_model_weights() def train_siamese_network(self, batchsize=32, no_of_epochs=20): triplet_pairs = self.siamese_network.get_data() call_backs = siamese_network.get_callback() self.triplet_model.fit(x=[ triplet_pairs[:, 0, :], triplet_pairs[:, 1, :], triplet_pairs[:, 2, :] ], y=np.zeros(shape=(triplet_pairs.shape[0], 12288)), batch_size=batchsize, callbacks=call_backs, epochs=no_of_epochs, shuffle=True, validation_split=0.14) def trained_model(self): triplet_model_required_layers = self.triplet_model.layers[-2] anchor_input = Input(self.input_shape, name='anchor_input') encoded_anchor = triplet_model_required_layers(anchor_input) return Model(anchor_input, encoded_anchor) def save_model_weights(self): # serialize model to JSON model_json = self.model.to_json() with open(MODEL_WEIGHT_PATH + "model.json", "w") as json_file: json_file.write(model_json) # serialize weights to HDF5 self.model.save_weights(MODEL_WEIGHT_PATH + "model.h5") print("Saved model to disk")
import matplotlib.pyplot as plt import numpy as np import scikitplot as skplt import sklearn from omniglot_loader import OmniglotLoader from siamese_network import SiameseNetwork model_wo_tf = './trained_models/wo_transform/model.h5' model_w_tf = './trained_models/w_transform/model.h5' if __name__ == '__main__': # First test case, training without transformations, testing without transformations omg = OmniglotLoader(use_transformations=False) network = SiameseNetwork(model_location=model_wo_tf) y_pred, te_y = network.get_predictions(omg) y_pred = np.array(y_pred) te_y = np.array(te_y) fpr, tpr, _ = skplt.metrics.roc_curve(te_y.flatten(), y_pred.flatten()) auc = sklearn.metrics.roc_auc_score(te_y.flatten(), y_pred.flatten()) # Second test case, training without transformations, testing with transformations omg = OmniglotLoader(use_transformations=True) y_pred, te_y = network.get_predictions(omg) y_pred = np.array(y_pred) te_y = np.array(te_y) fpr_te_tf, tpr_te_tf, _ = skplt.metrics.roc_curve(te_y.flatten(), y_pred.flatten()) auc_te_tf = sklearn.metrics.roc_auc_score(te_y.flatten(), y_pred.flatten())
from torchvision import transforms from siamese_dataset import SiameseNetworkDataset from siamese_network import SiameseNetwork from helpers import imshow from torchvision.datasets import ImageFolder from torch.utils.data import DataLoader from torch.autograd import Variable import torch.nn.functional as F class Config(): testing_dir = "/home/wingman2/datasets/personas/test/" # testing_dir = "/home/wingman2/code/Facial-Similarity-with-Siamese-Networks-in-Pytorch/data/faces/testing/" model = SiameseNetwork().cuda() model.load_state_dict(torch.load('/home/wingman2/models/siamese-faces-160.pt')) model.eval() data_transforms_test = transforms.Compose( [transforms.Resize((100, 100)), transforms.ToTensor()]) folder_dataset_test = ImageFolder(root=Config.testing_dir) siamese_dataset = SiameseNetworkDataset(imageFolderDataset=folder_dataset_test, transform=data_transforms_test, should_invert=False) test_dataloader = DataLoader(siamese_dataset, num_workers=8, batch_size=1, shuffle=True)
def bayesian_optimization_function(x): dataset_path = 'Omniglot Dataset' current_learning_rate = float(x[:, 0]) current_momentum = float(x[:, 1]) current_momentum_slope = float(x[:, 2]) current_conv1_multiplier = float(x[:, 3]) current_conv2_multiplier = float(x[:, 4]) current_conv3_multiplier = float(x[:, 5]) current_conv4_multiplier = float(x[:, 6]) current_dense1_multiplier = float(x[:, 7]) current_conv1_penalization = float(x[:, 8]) current_conv2_penalization = float(x[:, 9]) current_conv3_penalization = float(x[:, 10]) current_conv4_penalization = float(x[:, 11]) current_dense1_penalization = float(x[:, 12]) model_name = 'siamese_net_lr_' + str(current_learning_rate) + \ 'momentum_' + str(current_momentum) + '_slope_' + \ str(current_momentum_slope) global current_model_number current_model_number += 1 tensorboard_log_path = './logs/' + str(current_model_number) # Learning Rate multipliers for each layer learning_rate_multipliers = {} learning_rate_multipliers['Conv1'] = current_conv1_multiplier learning_rate_multipliers['Conv2'] = current_conv2_multiplier learning_rate_multipliers['Conv3'] = current_conv3_multiplier learning_rate_multipliers['Conv4'] = current_conv4_multiplier learning_rate_multipliers['Dense1'] = current_dense1_multiplier # l2-regularization penalization for each layer l2_penalization = {} l2_penalization['Conv1'] = current_conv1_penalization l2_penalization['Conv2'] = current_conv2_penalization l2_penalization['Conv3'] = current_conv3_penalization l2_penalization['Conv4'] = current_conv4_penalization l2_penalization['Dense1'] = current_dense1_penalization K.clear_session() siamese_network = SiameseNetwork( dataset_path=dataset_path, learning_rate=current_learning_rate, batch_size=32, use_augmentation=True, learning_rate_multipliers=learning_rate_multipliers, l2_regularization_penalization=l2_penalization, tensorboard_log_path=tensorboard_log_path) current_model_number += 1 support_set_size = 20 evaluate_each = 500 number_of_train_iterations = 100000 validation_accuracy = siamese_network.train_siamese_network( number_of_iterations=number_of_train_iterations, support_set_size=support_set_size, final_momentum=current_momentum, momentum_slope=current_momentum_slope, evaluate_each=evaluate_each, model_name=model_name) if validation_accuracy == 0: evaluation_accuracy = 0 else: # Load the weights with best validation accuracy siamese_network.model.load_weights('models/' + model_name + '.h5') evaluation_accuracy = siamese_network.data_loader.one_shot_test( siamese_network.model, 20, 40, False) print("Model: " + model_name + ' | Accuracy: ' + str(evaluation_accuracy)) K.clear_session() return 1 - evaluation_accuracy
#测试集 siamese_dataset_test = SiameseNetworkDataset(sample_path=Config.sample_test_path, transform=transforms.Compose([transforms.ToTensor()]) ,should_invert=False) print("len(siamese_dataset_test) = ", siamese_dataset_test.__len__()) test_dataloader = DataLoader(siamese_dataset_test, shuffle=False,#siamese_dataset 重排后再取数据 num_workers=5, batch_size=360) #模型训练 net = SiameseNetwork() #网络结构 criterion = ContrastiveLoss() #损失函数 optimizer = optim.Adam(net.parameters(),lr = 0.0005) #参数优化函数 train_loss_history = [] test_loss_history = [] for epoch in range(0, Config.train_number_epochs):#整个样本集的迭代 list_loss_epoch_c = [] for i, data in enumerate(train_dataloader,0):#batch迭代 img0, img1, label = data optimizer.zero_grad() #模型参数梯度设为0 output1,output2 = net(img0,img1) loss_contrastive = criterion(output1,output2,label) loss_contrastive.backward() #反向传播