def test_pretrained_vgg(): print("Running process to load and test a pre-trained VGG model:") batch_size = 16 model_class = cifar100vgg(train=False) model = model_class.model print('Start Test') X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR100_color() #test_prediction = model.predict(X_test, batch_size=batch_size, verbose=2) test_prediction = model_class.predict_c(X_test, batch_size=batch_size) score = log_loss(y_test, test_prediction) print('Test Score log_loss: ', score) score_test2 = accuracy_score(y_test, np.argmax(test_prediction, axis=1)) print('Test Score accuracy: ', score_test2) weights_step1 = model.get_weights() conv_weights = weights_step1[0] print("Saving conv weights into file...") now = datetime.datetime.now() filename_weights_step1 = "weights/conv_weights_pretrained_" + str( now.strftime("%Y-%m-%d-%H-%M")) + ".npy" np.save(filename_weights_step1, conv_weights) print("Done.") return filename_weights_step1, score, score_test2
def run_test_loading_models(filename_model, filename_conv_weights=None): print("Running process to load and test a model:") batch_size = 16 print('Loading weights from {}'.format(filename_model)) model_class = cifar100vgg(train=False) model = model_class.model model.load_weights(filename_model) if filename_conv_weights: conv_bias = model.layers[0].get_weights()[1] print('Loading conv weights from {}'.format(filename_conv_weights)) conv_kernel = np.load(filename_conv_weights) model.layers[0].set_weights([conv_kernel, conv_bias]) model_class.model = model print('Start Test') X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR100_color() #test_prediction = model.predict(X_test, batch_size=batch_size, verbose=2) test_prediction = model_class.predict_c(X_test, batch_size=batch_size) score = log_loss(y_test, test_prediction) print('Test Score log_loss: ', score) score_test2 = accuracy_score(y_test, np.argmax(test_prediction, axis=1)) print('Test Score accuracy: ', score_test2) return score, score_test2
def main(dataset_name="cifar100", model_name="cifar100"): if dataset_name == "cifar100": dataset = keras.datasets.cifar100 labels = CIFAR100_LABELS elif dataset_name == "cifar10": dataset = keras.datasets.cifar10 labels = CIFAR10_LABELS else: raise ValueError(dataset_name) print("Loaded dataset={}".format(dataset_name)) if model_name == "cifar100": model = cifar100vgg(train=False) elif model_name == "cifar10": model = cifar10vgg(train=False) else: raise ValueError(model_name) print("Loaded model={}".format(model_name)) (x_train, y_train), (x_test, y_test) = dataset.load_data() x_train_norm = model.normalize_production(x_train.astype('float32')) if dataset_name == model_name: print("Check validation error:") check_validation(dataset_name, x_test, y_test, model) print("evaluating first flat layer using dataset...") inter_model = keras.Model( inputs=model.model.input, outputs=model.model.get_layer("flatten_1").output) X = x_train Y = y_train X_processed = inter_model.predict(x_train_norm) data = (X, X_processed, Y) print("done.") print("saving processed images...") filename = "{}_{}_processed.p".format(dataset_name, model_name) with open(filename, "wb") as f: pickle.dump(data, f) print("saved results to {}".format(filename)) print("saving a separated version of the data...") # dataset is a map (label_str => (X, X_processed)) dataset = {} for i, label in enumerate(labels): ii = (Y.flatten() == i) imgs = X[ii] imgs_processed = X_processed[ii] dataset[label] = (imgs, imgs_processed) filename = "{}_{}_separated.p".format(dataset_name, model_name) with open(filename, "wb") as f: pickle.dump(dataset, f) print("saved results to {}".format(filename)) # Finally, clear the session. keras.backend.clear_session()
def run_load_finetune_models(filename_model, filename_conv_weights): print("Running process to load and finetune a model:") batch_size = 16 #nb_epoch = 50 print('Loading model from {}'.format(filename_model)) model_class = cifar100vgg(train=False) model = model_class.model model.load_weights(filename_model) conv_bias = model.layers[0].get_weights()[1] print('Loading conv weights from {}'.format(filename_conv_weights)) conv_kernel = np.load(filename_conv_weights) model.layers[0].set_weights([conv_kernel, conv_bias]) model.layers[0].trainable = False #model.compile(optimizer = Adam(lr=5.0e-4), loss = 'sparse_categorical_crossentropy', metrics = ['accuracy']) X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR100_color() #callbacks = [EarlyStopping(monitor='val_loss', patience=15, verbose=0)] print("Fine-tuning model...") #model.fit(X_train, y_train, batch_size=batch_size, epochs=nb_epoch, # shuffle=True, verbose=1, validation_data=(X_val, y_val), # callbacks=callbacks) model_class.model = model model = model_class.train(model) print('Saving weights of model...') now = datetime.datetime.now() filename_model_step3 = "weights/model_finetuned_" + str( now.strftime("%Y-%m-%d-%H-%M")) + ".h5" model.save_weights(filename_model_step3) print("Done.") #print('Making predictions for model') #predictions_valid = model.predict(X_val, batch_size=batch_size, verbose=2) #score = log_loss(y_val, predictions_valid) #print('Score log_loss: ', score) #print("Log_loss train: ", score) #info_string = 'loss_' + str(score) + '_ep_' + str(nb_epoch) #print(info_string) model_class.model = model print('Start Test:') #test_prediction = model.predict(X_test, batch_size=batch_size, verbose=2) test_prediction = model_class.predict_c(X_test, batch_size=batch_size) score_test = log_loss(y_test, test_prediction) print('Test Score log_loss: ', score_test) score_test2 = accuracy_score(y_test, np.argmax(test_prediction, axis=1)) print('Test Score accuracy: ', score_test2) return filename_model_step3, score_test, score_test2
def main(): np.random.seed(42) tf.set_random_seed(42) x_train, y_train, x_test, y_test = load_data() source_model = cifar100vgg(train=False) x_train = source_model.normalize_production(x_train) x_test = source_model.normalize_production(x_test) fine_tuning_tests((x_train, y_train, x_test, y_test), source_model) embedding_logistic_regression((x_train, y_train, x_test, y_test), source_model) embedding_tests((x_train, y_train, x_test, y_test), source_model) fine_tuning_tests((x_train, y_train, x_test, y_test), source_model, True, 25, True)
def run_end_to_end_models(filename_model, filename_phases): X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR100_color() print( "Starting end-to-end co-training of phase profile and suffix layers..." ) print("Training dataset shape: ", X_train.shape) print("Training label shape:", y_train.shape) print('Loading model from {}'.format(filename_model)) model_class = cifar100vgg(train=False) model = model_class.model model.load_weights(filename_model) X_train, X_test = model_class.normalize(X_train, X_test) EPOCHS = 25 BS = 64 INIT_LR = 5e-4 opt = Adam(lr=INIT_LR) PhaseLR = 5e-6 print('Loading phase profile from {}'.format(filename_phases)) phi_in = np.load(filename_phases) phase2Kernel = Phase2Kernels(phi_in) def step(X, y): # get the weights weights = phase2Kernel.forward() conv_bias = model.layers[0].get_weights()[1] model.layers[0].set_weights([weights, conv_bias]) # keep track of our gradients with tf.GradientTape() as tape: # make a prediction using the model and then calculate the # loss pred = model(X) print("Pred shape:", pred.shape) loss = sparse_categorical_crossentropy(y, pred) accuracy = accuracy_score(y, np.argmax(pred, axis=1)) print("loss", tf.math.reduce_mean(loss)) print("accuracy:", accuracy) grads = tape.gradient(loss, model.trainable_variables) print("gradients shapes: ", grads[0].shape, grads[1].shape) final_grad = phase2Kernel.backward(grads[0]) phase2Kernel.phi -= PhaseLR * cp.asnumpy(final_grad) opt.apply_gradients(zip(grads, model.trainable_variables)) # print(PhaseLR * cp.asnumpy(final_grad)) # time.sleep(1) numUpdates = int(X_train.shape[0] / BS) # loop over the number of epochs for epoch in range(0, EPOCHS): # show the current epoch number print("[INFO] starting epoch {}/{}...".format(epoch + 1, EPOCHS)) X_train, y_train = shuffle(X_train, y_train, random_state=0) sys.stdout.flush() epochStart = time.time() # loop over the data in batch size increments for i in range(0, numUpdates): # determine starting and ending slice indexes for the current # batch print("starting batch: ", i) start = i * BS end = start + BS # take a step step(X_train[start:end], y_train[start:end]) # show timing information for the epoch epochEnd = time.time() elapsed = (epochEnd - epochStart) / 60.0 print("took {:.4} minutes".format(elapsed)) print("Saving co-trained phases and network parameters...") now = datetime.datetime.now() filename_model_step4 = "weights/model_co-trained_" + str( now.strftime("%Y-%m-%d-%H-%M")) + ".h5" model.save_weights(filename_model_step4) filename_phases_step4 = "phases/phases_co-trained" + str( now.strftime("%Y-%m-%d-%H-%M")) + ".npy" np.save(filename_phases_step4, np.asarray(phase2Kernel.phi)) print("Done.") print("Co-training finished!") print('Start Test:') test_prediction = model.predict(X_test, batch_size=BS, verbose=2) score_test = log_loss(y_test, test_prediction) print('Test Score log_loss: ', score_test) score_test2 = accuracy_score(y_test, np.argmax(test_prediction, axis=1)) print('Test Score accuracy: ', score_test2) print("Measuring metrics using Class' predict() method:") model_class.model = model print('Start Test:') #test_prediction = model.predict(X_test, batch_size=batch_size, verbose=2) test_prediction = model_class.predict_c(X_test, normalize=False, batch_size=BS) score_test3 = log_loss(y_test, test_prediction) print('Test Score log_loss: ', score_test3) score_test4 = accuracy_score(y_test, np.argmax(test_prediction, axis=1)) print('Test Score accuracy: ', score_test4) return filename_model_step4, filename_phases_step4, score_test, score_test2, score_test3, score_test4
def create_classifier(): model_class = cifar100vgg(train=False) model = model_class.model return model