def split_preprocess_Data(degree1, degree2, strength1, strength2, percentage =1): # 1. load the data x_original_train, train_target, x_original_test, val_target = assign2_utils.load_dataset() #train_pairs, val_pairs = transform_dataset(x_original_train, x_original_test, 30, 0.15) # 2. split the datset. x_original_train = x_original_train.astype('float32') x_original_test = x_original_test.astype('float32') normaliseValue = 255 x_original_train /= normaliseValue # normalized the entries between 0 and 1 x_original_test /= normaliseValue x_original_train1, x_original_train2, train_target1, train_target2 = split_Data(x_original_train,train_target, percentage) #x_original_test1, x_original_test2 , val_target1, val_target2 = split_Data(x_original_test,val_target, percentage) # 3. transform the dataset. warped_pairs1 = np.array([assign2_utils.random_deform(x, degree1, strength1) for x in x_original_train1]) warped_pairs2 = np.array([assign2_utils.random_deform(x, degree2, strength2) for x in x_original_train2]) # train_pairs2 = np.array([assign2_utils.random_deform(x, degree2, strength2) for x in x_original_train2] digit_indicesTrain1 = [np.where(train_target[train_target1] == i)[0] for i in range(NumberOfClass)] train_pairs1, train_y1 = create_pairs(warped_pairs1, digit_indicesTrain1, percentage) digit_indicesTrain2 = [np.where(train_target[train_target2] == i)[0] for i in range(NumberOfClass)] train_pairs2, train_y2 = create_pairs(warped_pairs2, digit_indicesTrain2, percentage) # 4. reshape the pairs for 2D convolutional layer train_twin1_input1, train_twin2_input1 = reshape_input(image_width, image_height, num_channels, train_pairs1) train_twin1_input2, train_twin2_input2 = reshape_input(image_width, image_height, num_channels, train_pairs2) return train_twin1_input1, train_twin2_input1, train_twin1_input2, train_twin2_input2, train_y1, train_y2
def transform_dataset(train_dataset, test_dataset, degree, strength): ''' Data preprocessing Transform the original data set @param dataset: The source dataset that will be transformed degree: The max degree of the transformation strength: The strength of the transformation @return x_Transformed_train: x_Transformed_test: ''' ''' 3.2 larger transfomred datasets ''' x_Transformed_train = np.array([ assign2_utils.random_deform(x, degree, strength) for x in train_dataset ]) x_Transformed_test = np.array([ assign2_utils.random_deform(x, degree, strength) for x in test_dataset ]) return x_Transformed_train, x_Transformed_test '''
def transform_dataset(train_dataset, test_dataset, degree, strength): ''' Data preprocessing: Transform the original data set @param dataset: The source dataset that will be transformed degree: The max degree of the transformation strength: The strength of the transformation @return x_Transformed_train: x_Transformed_test: ''' x_Transformed_train = np.array([assign2_utils.random_deform(x,degree,strength) for x in train_dataset]) x_Transformed_test = np.array([assign2_utils.random_deform(x,degree,strength) for x in test_dataset]) return x_Transformed_train, x_Transformed_test
def warp_original_data(): with np.load('mnist_dataset.npz') as npzfile: x_train = npzfile['x_train'] y_train = npzfile['y_train'] x_test = npzfile['x_test'] y_test = npzfile['y_test'] warped_x_train = np.zeros(x_train.shape) warped_x_test = np.zeros(x_test.shape) for i in range(x_train.shape[0]): warped_x_train[i] = assign2_utils.random_deform( x_train[i] / 255, 45, 0.3) for i in range(x_test.shape[0]): warped_x_test[i] = assign2_utils.random_deform(x_test[i] / 255, 45, 0.3) np.savez('mnist_warped_dataset.npz', x_train=warped_x_train, y_train=y_train, x_test=warped_x_test, y_test=y_test)
def generate_testset(original_file_name, number, rotation, variation): x_train, y_train, x_test, y_test = load_original_data(original_file_name) x_te = np.zeros((number, x_test.shape[1], x_test.shape[2])) y_te = np.zeros((number)) for i in range(number): index = np.random.randint(0, x_test.shape[0]) x_te[i] = assign2_utils.random_deform(x_test[index], rotation, variation) y_te[i] = y_train[index] np.savez('test_dataset.npz', x_test=x_te, y_test=y_te) print('Generated test with training shape: {0}'.format(x_te.shape))
def warped_images(x_train, x_test, degree, strength): """ warped dataset with degree and strength. @param: expanded x_train,x_test. degree: warped degree strength: warped strength @return: warped x_train, x_test """ print("This time is warped data with {} degree and {} strength".format( degree, strength)) for i in range(len(x_train)): x_train[i] = assign2_utils.random_deform(x_train[i], degree, strength) for i in range(len(x_test)): x_test[i] = assign2_utils.random_deform(x_test[i], degree, strength) return x_train, x_test
def generate_warped_dataset(original_file_name, file_name, number, rotation, variation): ''' Need comment ''' x_train, y_train, x_test, y_test = load_original_data(original_file_name) warped_x_train = np.zeros((number, x_train.shape[1], x_train.shape[2])) warped_y_train = np.zeros((number)) for i in range(number): index = np.random.randint(0, x_train.shape[0]) warped_x_train[i] = assign2_utils.random_deform( x_train[index], #[index]/255, rotation, variation) warped_y_train[i] = y_train[index] np.savez(file_name, x_train=warped_x_train, y_train=warped_y_train) print('Generated file {0} with training shape: {1}'.format( file_name, warped_x_train.shape))
def create_warped_dataset(input_array,input_lables, rotation, warp_strength, output_size = 100000, return_y = True): ''' Create an array of warped images of size output_size @param input_array : Nnumpy array of image inputs input_labels : Numpy array of lables where input_labels[i] is The label for input_array[i] rotation : Maximum rotation value warp_strength : Maximum intensity of the warp output_size : Size of the output dataset (100K images by default) return_y : determines if the function should return labels with the dataset @return if return_y is true warped_array warped version of input_array else warped_array ''' # create an output array with the same shape as input_array but of size output_size warped_array = np.zeros((output_size, len(input_array[1]), len(input_array[2]))) output_labels = np.zeros((output_size,),dtype=input_lables.dtype) print('Warping images...') # randomly warp images from input_array by rotation and warp_strenth and insert them into warped_array for i in range(output_size): warped_array[i] = assign2_utils.random_deform(input_array[i % len(input_array)], rotation, warp_strength) output_labels[i] = int(input_lables[i% len(input_lables)]) # # Return Warped Dataset # if len(input_array) != output_size: # return warped_array, output_labels #, warped_array[split_range:],output_labels[split_range:] # else: if not return_y: return warped_array else: return warped_array, output_labels
def generate_warped_dataset(dataset): ''' Generate warped dataset based on parameter from SETTINGS. This will generate images randomly from x_train of mnist dataset and generate test images randomly from x_test of mnist dataset Args: dataset['warped_dataset_records']: total warped images will be generated dataset['hard_pair']: proportion of significant deformation of images in the dataset for example, dataset['hard_pair'] = 0.6 means 60% of warped images in the dataset are deformed significantly dataset['test_set']: proportion of test set. for example, dataset['test_set'] = 0.1 means the number of test images will be 10% of warped images. dataset['test_set'] = 0.1 and dataset['warped_dataset_records']= 100000 There are 10000 test images and 100000 warped images Total is 110000 images ''' x_train, y_train, x_test, y_test = load_original_data() # hard_pair is percentage of H dataset in total warped dataset hard_pair_records = int(dataset['hard_pair'] * dataset['warped_dataset_records']) easy_pair_records = int( (1 - dataset['hard_pair']) * dataset['warped_dataset_records']) test_records = int(dataset['test_set'] * dataset['warped_dataset_records']) print('Warped images: ' + str(dataset['warped_dataset_records'])) h_x_train = np.zeros( (hard_pair_records, x_train.shape[1], x_train.shape[2])) h_y_train = np.zeros((hard_pair_records)) h_x_test = np.zeros((int(dataset['hard_pair'] * test_records), x_train.shape[1], x_train.shape[2])) h_y_test = np.zeros((int(dataset['hard_pair'] * test_records))) for i in range(hard_pair_records): index = np.random.randint(0, x_train.shape[0]) h_x_train[i] = assign2_utils.random_deform( x_train[index], # x_train[index]/255 dataset['hard_pair_rotation'], dataset['hard_pair_variation']) h_y_train[i] = y_train[index] for i in range(int(dataset['hard_pair'] * test_records)): index = np.random.randint(0, x_test.shape[0]) h_x_test[i] = assign2_utils.random_deform( x_test[index], # x_test[index]/255 dataset['hard_pair_rotation'], dataset['hard_pair_variation']) h_y_test[i] = y_test[index] print('Hard (H) dataset: ' + str(h_x_train.shape)) e_x_train = np.zeros( (easy_pair_records, x_train.shape[1], x_train.shape[2])) e_y_train = np.zeros((easy_pair_records)) e_x_test = np.zeros((int((1 - dataset['hard_pair']) * test_records), x_train.shape[1], x_train.shape[2])) e_y_test = np.zeros((int((1 - dataset['hard_pair']) * test_records))) for i in range(easy_pair_records): index = np.random.randint(0, x_train.shape[0]) e_x_train[i] = assign2_utils.random_deform( x_train[index], # x_train[index]/255 dataset['easy_pair_rotation'], dataset['easy_pair_variation']) e_y_train[i] = y_train[i] for i in range(int((1 - dataset['hard_pair']) * test_records)): index = np.random.randint(0, x_test.shape[0]) e_x_test[i] = assign2_utils.random_deform( x_test[index], # x_test[index]/255 dataset['easy_pair_rotation'], dataset['easy_pair_variation']) e_y_test[i] = y_test[i] print('Easy (E) dataset: ' + str(e_x_train.shape)) warped_x_train = np.concatenate((h_x_train, e_x_train), axis=0) warped_y_train = np.concatenate((h_y_train, e_y_train), axis=0) warped_x_test = np.concatenate((h_x_test, e_x_test), axis=0) warped_y_test = np.concatenate((h_y_test, e_y_test), axis=0) print('Test dataset: ' + str(warped_x_test.shape)) np.savez('mnist_warped_dataset.npz', x_train=warped_x_train, y_train=warped_y_train, x_test=warped_x_test, y_test=warped_y_test)
def generate_warped_dataset(dataset): ''' Generate warped dataset based on parameters from SETTINGS. This will generate images randomly from x_train of mnist dataset and generate test images randomly from x_test of mnist dataset Args: dataset['warped_dataset_records']: total warped images will be generated dataset['hard_pair']: proportion of significant deformation of images in the dataset for example, dataset['hard_pair'] = 0.6 means 60% of warped images in the dataset are deformed significantly dataset['test_set']: proportion of test set. for example, dataset['test_set'] = 0.1 means the number of test images will be 10% of warped images. dataset['test_set'] = 0.1 and dataset['warped_dataset_records']= 100000 There are 10000 test images and 100000 warped images Total is 110000 images ''' x_train, y_train, x_test, y_test = load_original_data() # hard_pair is percentage of H dataset in total warped dataset hard_pair_records = int(dataset['hard_pair'] * dataset['warped_dataset_records']) easy_pair_records = int((1 - dataset['hard_pair']) * dataset['warped_dataset_records']) test_records = int(dataset['test_set'] * dataset['warped_dataset_records']) print('Warped images: ' + str(dataset['warped_dataset_records'])) if network_configs['train_dataset'] == 'EH' h_x_train = np.zeros((hard_pair_records, x_train.shape[1], x_train.shape[2])) h_y_train = np.zeros((hard_pair_records)) h_x_test = np.zeros((int(dataset['hard_pair'] * test_records), x_train.shape[1], x_train.shape[2])) h_y_test = np.zeros((int(dataset['hard_pair'] * test_records))) for i in range(hard_pair_records): index = np.random.randint(0, x_train.shape[0]) h_x_train[i] = assign2_utils.random_deform(#x_train[index], x_train[index]/255, dataset['hard_pair_rotation'], dataset['hard_pair_variation']) h_y_train[i] = y_train[index] for i in range(int(dataset['hard_pair'] * test_records)): index = np.random.randint(0, x_test.shape[0]) h_x_test[i] = assign2_utils.random_deform(#x_test[index], x_test[index]/255, dataset['hard_pair_rotation'], dataset['hard_pair_variation']) h_y_test[i] = y_test[index] print('Hard (H) dataset: ' + str(h_x_train.shape)) e_x_train = np.zeros((easy_pair_records, x_train.shape[1], x_train.shape[2])) e_y_train = np.zeros((easy_pair_records)) e_x_test = np.zeros((int((1 - dataset['hard_pair']) * test_records), x_train.shape[1], x_train.shape[2])) e_y_test = np.zeros((int((1 - dataset['hard_pair']) * test_records))) for i in range(easy_pair_records): index = np.random.randint(0, x_train.shape[0]) e_x_train[i] = assign2_utils.random_deform(#x_train[index], # x_train[index]/255, dataset['easy_pair_rotation'], dataset['easy_pair_variation']) e_y_train[i] = y_train[i] for i in range(int((1 - dataset['hard_pair']) * test_records)): index = np.random.randint(0, x_test.shape[0]) e_x_test[i] = assign2_utils.random_deform(#x_test[index], # x_test[index]/255, dataset['easy_pair_rotation'], dataset['easy_pair_variation']) e_y_test[i] = y_test[i] elif network_configs['train_dataset'] == 'H' #Warp the daataset with H setting same size of E+H print('Easy (E) dataset: ' + str(e_x_train.shape)) warped_x_train = np.concatenate((h_x_train, e_x_train), axis=0) warped_y_train = np.concatenate((h_y_train, e_y_train), axis=0) warped_x_test = np.concatenate((h_x_test, e_x_test), axis=0) warped_y_test = np.concatenate((h_y_test, e_y_test), axis=0) print('Test dataset: ' + str(warped_x_test.shape)) np.savez('mnist_warped_dataset.npz', x_train=warped_x_train, y_train=warped_y_train, x_test=warped_x_test, y_test=warped_y_test) def load_original_data(): ''' Load the dataset, shuffled and split between train and test sets and return the numpy arrays x_train, y_train, x_test, y_test in original dataset The dtype of all returned array is uint8 ''' assert os.path.isfile('./mnist_dataset.npz') with np.load('mnist_dataset.npz') as npzfile: # x_train = npzfile['x_train']/255 x_train = npzfile['x_train'] y_train = npzfile['y_train'] # x_test = npzfile['x_test']/255 x_test = npzfile['x_test'] y_test = npzfile['y_test'] return x_train, y_train, x_test, y_test def load_warped_dataset(dataset_type): ''' Load the dataset, shuffled and split between train and test sets and return the numpy arrays x_train, y_train, x_test, y_test in warped dataset The dtype of all returned array is uint8 ''' if dataset_type == 'E' assert os.path.isfile('./mnist_easy_warped_dataset.npz') datasetname = './mnist_easy_warped_dataset.npz' if dataset_type == 'H' assert os.path.isfile('./mnist_partialhard_warped_dataset.npz') datasetname = './mnist_partialhard_warped_dataset.npz' if dataset_type == 'HH' assert os.path.isfile('./mnist_fullhard_warped_dataset.npz') datasetname = './mnist_fullhard_warped_dataset.npz' with np.load(datasetname) as npzfile: warped_x_train = npzfile['x_train'] warped_y_train = npzfile['y_train'] warped_x_test = npzfile['x_test'] warped_y_test = npzfile['y_test'] return warped_x_train, warped_y_train, warped_x_test, warped_y_test #------------------------------------------------------------------------------ # CONFIGURATION AND SETTING SETTINGS = { 'dataset_generation': { 'create_original_dataset': False, # Donwload the dataset and save to the file named # mnist_dataset.npz. By doing this, we don't have # to download the dataset every run the experiment 'create_warped_dataset': True, # Using mnist_dataset.npz, we generate warped dataset # and save the dataset to mnist_warped_dataset.npz # When we want to generate warped dataset again, # we just need to set it to True. 'warped_dataset_records': 100000, # number of records in warped dataset (D dataset) 'hard_pair': 0.8, # in percentage from 0 to 1. for example, # if hard_pair=0.6 and warped_dataset_records=100000, # the hard pairs will be 60% of warped_dataset_records which is # 60000 and the easy_pair will be 40000 'test_set': 0.1, # proportion of test dataset. # test_set = 0.2 means extra 20% of the warped # images in the dataset will be used for test dataset 'hard_pair_rotation': 45, # rotation of deformed the dataset (H dataset) 'hard_pair_variation': 0.3, # rotation of deformed the dataset (H dataset) 'easy_pair_rotation': 5, # rotation of deformed the dataset (E dataset) 'easy_pair_variation': 0.01, # variation of deformed the dataset (E dataset) }, 'network_configs': { # experiment on original dataset 'epochs': 2, 'train_dataset': 'O' # original_dataset can take values from ['O', 'H', 'EH', A]. # O: Using original dataset # H: Using Hard dataset equal to the size of E+H # EH: Using Easy and then Hard dataset # to train the network } } #------------------------------------------------------------------------------ if __name__=='__main__': SiameseExperiment.run_experiments(**SETTINGS)
''' A short script to illustrate the warping functions of 'assign2_utils' ''' #import numpy as np import matplotlib.pyplot as plt from tensorflow.contrib import keras #from tensorflow.contrib.keras import backend as K import assign2_utils (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data() im1 = x_train[20] plt.imshow(im1, cmap='gray') im2 = assign2_utils.random_deform(im1, 45, 0.3) plt.figure() plt.imshow(im2, cmap='gray') plt.show()
im2: A wraped image the maximum degree: 45 strength: 0.3 ''' ''' 3.1 Orignal datasets. ''' #x_original_train, y_train, x_original_test, y_test = assign2_utils.load_dataset() ''' 3.2 larger transfomred datasets ''' x_largeTransformed_train = np.array( [assign2_utils.random_deform(x, 45, 0.3) for x in x_original_train]) x_largeTransformed_test = np.array( [assign2_utils.random_deform(x, 45, 0.3) for x in x_original_test]) ''' 3.3 smaller transformed datasets. ''' #x_smallTransformed_train = np.array([assign2_utils.random_deform(x,30,0.2) for x in x_original_train]) #x_smallTransformed_test = np.array([assign2_utils.random_deform(x,30,0.2) for x in x_original_test]) ''' 4. Reshape the datasets and nomalised them. (the total number of pairs, one pair(2 numbers) in the same or not same classification, 28*28 ) ''' x_train = x_original_train.reshape(60000, 784) x_test = x_original_test.reshape(10000, 784) x_train = x_train.astype('float32')
import matplotlib.pyplot as plt from tensorflow.contrib import keras #from tensorflow.contrib.keras import backend as K import assign2_utils (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data() #ims = x_train[0] #plt.imshow(ims,cmap='gray') #ims2 = x_test for i in range(10): plt.figure() # print("Train "+str(i)) plt.imshow(x_train[i], cmap='gray') plt.figure() g = assign2_utils.random_deform(x_train[i], 20, 0.1) # print("Test "+str(i)) plt.imshow(g, cmap='gray') # # #im2 = assign2_utils.random_deform(im1,45,0.3) # #plt.figure() # #plt.imshow(im2,cmap='gray') # #plt.show()
''' x_original_train, train_target, x_original_test, val_target = assign2_utils.load_dataset() #train_pairs, val_pairs = transform_dataset(x_original_train, x_original_test, 30, 0.15) # 2. split the datset. x_original_train = x_original_train.astype('float32') x_original_test = x_original_test.astype('float32') normaliseValue = 255 x_original_train /= normaliseValue # normalized the entries between 0 and 1 x_original_test /= normaliseValue x_original_train1, x_original_train2, train_target1, train_target2 = split_Data(x_original_train,train_target, 0.4) #x_original_test1, x_original_test2 , val_target1, val_target2 = split_Data(x_original_test,val_target, percentage) # 3. transform the dataset. warped_pairs1 = np.array([assign2_utils.random_deform(x, 15, 0.1) for x in x_original_train1]) warped_pairs2 = np.array([assign2_utils.random_deform(x, 45, 0.3) for x in x_original_train2]) # train_pairs2 = np.array([assign2_utils.random_deform(x, degree2, strength2) for x in x_original_train2] digit_indicesTrain1 = [np.where(train_target[train_target1] == i)[0] for i in range(NumberOfClass)] train_pairs1, train_y1 = create_pairs(warped_pairs1, digit_indicesTrain1, 0.4) digit_indicesTrain2 = [np.where(train_target[train_target2] == i)[0] for i in range(NumberOfClass)] train_pairs2, train_y2 = create_pairs( warped_pairs2, digit_indicesTrain2, 0.6) # 4. reshape the pairs for 2D convolutional layer train_twin1_input1, train_twin2_input1 = reshape_input(image_width, image_height, num_channels, train_pairs1) train_twin1_input2, train_twin2_input2 = reshape_input(image_width, image_height, num_channels, train_pairs2)
def generate_warped_dataset(dataset): ''' Generate warped dataset based on parameter from SETTINGS. This will generate images randomly from x_train of mnist dataset and generate test images randomly from x_test of mnist dataset Args: dataset['warped_dataset_records']: total warped images will be generated dataset['hard_pair']: proportion of significant deformation of images in the dataset for example, dataset['hard_pair'] = 0.6 means 60% of warped images in the dataset are deformed significantly dataset['test_set']: proportion of test set. for example, dataset['test_set'] = 0.1 means the number of test images will be 10% of warped images. dataset['test_set'] = 0.1 and dataset['warped_dataset_records']= 100000 There are 10000 test images and 100000 warped images Total is 110000 images ''' x_train, y_train, x_test, y_test = load_original_data() # hard_pair is percentage of H dataset in total warped dataset test_records = int(dataset['test_set'] * dataset['warped_dataset_records']) if dataset['train_dataset'] == 'H' and dataset['retrain']: w_pair_records = int(dataset['hard_pair'] * dataset['warped_dataset_records']) w_test_records = int(dataset['hard_pair'] * test_records) w_rotation = dataset['hard_pair_rotation'] w_variation = dataset['hard_pair_variation'] elif dataset['train_dataset'] == 'H' and not dataset['retrain']: w_pair_records = int(dataset['warped_dataset_records']) w_test_records = test_records w_rotation = dataset['hard_pair_rotation'] w_variation = dataset['hard_pair_variation'] else: w_pair_records = int((1 - dataset['hard_pair']) * dataset['warped_dataset_records']) w_test_records = int((1 - dataset['hard_pair']) * test_records) w_rotation = dataset['easy_pair_rotation'] w_variation = dataset['easy_pair_variation'] print('Warped images: ' + str(dataset['warped_dataset_records'])) w_x_train = np.zeros((w_pair_records, x_train.shape[1], x_train.shape[2])) w_y_train = np.zeros((w_pair_records)) w_x_test = np.zeros((w_test_records, x_train.shape[1], x_train.shape[2])) w_y_test = np.zeros((w_test_records)) for i in range(w_pair_records): index = np.random.randint(0, x_train.shape[0]) w_x_train[i] = assign2_utils.random_deform(x_train[index], # x_train[index]/255 w_rotation, w_variation) w_y_train[i] = y_train[index] for i in range(w_test_records): index = np.random.randint(0, x_test.shape[0]) w_x_test[i] = assign2_utils.random_deform(x_test[index], # x_test[index]/255 w_rotation, w_variation) w_y_test[i] = y_test[index] print('Test dataset: ' + str(w_x_test.shape)) np.savez('mnist_warped_dataset.npz', x_train=w_x_train, y_train=w_y_train, x_test=w_x_test, y_test=w_y_test)
def stage_learning(): """ stage learning training the first 20% easy warped images first, then training the 80% hard warped images test all images predict the accuracy """ #expand x_train,y_train into a new x_train and y_train array with 100,000 x_train, y_train, x_test, y_test = assign2_utils.load_dataset() a = x_train[0:40000, :, :] x_train = np.concatenate((a, x_train), axis=0) b = y_train[0:40000] y_train = np.concatenate((b, y_train), axis=0) img_row = x_train.shape[1] img_col = x_train.shape[2] # normalized the input image x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_train /= 255 x_test /= 255 #reshape data x_train = x_train.reshape(x_train.shape[0], img_row, img_col, 1) x_test = x_test.reshape(x_test.shape[0], img_row, img_col, 1) input_dim = (img_row, img_col, 1) epochs = 10 x_train_easy = x_train x_train_hard = x_train x_test_easy = x_test x_test_hard = x_test #warped images with with easy strength and easy degree for i in range(100000): x_train_easy[i] = assign2_utils.random_deform(x_train[i], 15, 0.1) for i in range(100000): x_train_hard[i] = assign2_utils.random_deform(x_train[i], 45, 0.3) #warped images with with hard strength and hard degree for i in range(10000): x_test_easy[i] = assign2_utils.random_deform(x_test[i], 15, 0.1) for i in range(10000): x_test_hard[i] = assign2_utils.random_deform(x_test[i], 45, 0.3) # create training+test positive and negative pairs digit_indices = [np.where(y_train == i)[0] for i in range(10)] tr_pairs_easy, tr_y_easy = create_pairs(x_train_easy, digit_indices) digit_indices = [np.where(y_train == i)[0] for i in range(10)] tr_pairs_hard, tr_y_hard = create_pairs(x_train_hard, digit_indices) digit_indices = [np.where(y_test == i)[0] for i in range(10)] te_pairs, te_y = create_pairs(x_test, digit_indices) # network definition base_network = create_simplistic_base_network(input_dim) input_a = keras.layers.Input(shape=input_dim) input_b = keras.layers.Input(shape=input_dim) # because we re-use the same instance `base_network`, # the weights of the network will be shared across the two branches processed_a = base_network(input_a) processed_b = base_network(input_b) # node to compute the distance between the two vectors # processed_a and processed_a distance = keras.layers.Lambda(euclidean_distance)( [processed_a, processed_b]) # Our model take as input a pair of images input_a and input_b # and output the Euclidian distance of the mapped inputs #model to fit the first 20% easy warped images model = keras.models.Model([input_a, input_b], distance) rms = keras.optimizers.RMSprop() model.compile(loss=contrastive_loss, optimizer=rms) model.fit([tr_pairs_easy[0:36096, 0], tr_pairs_easy[0:36096, 1]], tr_y_easy[0:36096], batch_size=128, epochs=epochs, validation_data=([te_pairs[0:3564, 0], te_pairs[0:3564, 1]], te_y[0:3564])) #model.save_weights("easy_warped.h5") #model to fit the last 80% hard warped images model2 = keras.models.Model([input_a, input_b], distance) rms = keras.optimizers.RMSprop() model2.compile(loss=contrastive_loss, optimizer=rms) #model2.load_weights("easy_warped.h5") model2.fit([tr_pairs_hard[36096:, 0], tr_pairs_hard[36096:, 1]], tr_y_hard[36096:], batch_size=128, epochs=epochs, validation_data=([te_pairs[3564:, 0], te_pairs[3564:, 1]], te_y[3564:])) #merge two tr_pairs dataset together tr_pairs = np.concatenate((tr_pairs_hard[36096:], tr_pairs_easy[0:36096]), axis=0) tr_y = np.concatenate((tr_y_hard[36096:], tr_y_easy[0:36096])) pred = model.predict([tr_pairs[:, 0], tr_pairs[:, 1]]) tr_acc = compute_accuracy(pred, tr_y) pred = model.predict([te_pairs[:, 0], te_pairs[:, 1]]) te_acc = compute_accuracy(pred, te_y) print('when epochs is {}'.format(epochs)) print('* Accuracy on training set: %0.2f%%' % (100 * tr_acc)) print('* Accuracy on test set: %0.2f%% \n\n' % (100 * te_acc))