def test_mnist_noisy_10_split_20(self): batch_size = 128 train_set, _, _ = data_loader.load_dataset('mnist', './data', batch_size=batch_size, shuffle=False, split_seed=42, split=0.2) train_noisy, _, _ = data_loader.load_dataset('mnist', './data', batch_size=batch_size, shuffle=False, noise=0.1, split_seed=42, split=0.2) noisy_labels = train_noisy.dataset.targets clean_labels = train_set.dataset.targets diff = (np.array(clean_labels) != np.array(noisy_labels)).sum() / (len(clean_labels) * 0.8) assert diff > 0.09
def test_mnist_noisy_0(self): batch_size = 128 train_set, _, _ = data_loader.load_dataset('mnist', './data', batch_size=batch_size, shuffle=False) train_noisy, _, _ = data_loader.load_dataset('mnist', './data', batch_size=batch_size, shuffle=False, noise=0.) noisy_labels = train_noisy.dataset.targets clean_labels = train_set.dataset.targets diff = (np.array(clean_labels) != np.array(noisy_labels)).sum() assert diff == 0.
def test_cifar10_noisy_10(self): batch_size = 128 train_set, _, _ = data_loader.load_dataset('cifar10', './data', batch_size=batch_size, shuffle=False) train_noisy, _, _ = data_loader.load_dataset('cifar10', './data', batch_size=batch_size, shuffle=False, noise=0.1) noisy_labels = train_noisy.dataset.targets clean_labels = train_set.dataset.targets diff = (np.array(clean_labels) != np.array(noisy_labels)).sum() / len(clean_labels) assert diff > 0.09
def model_test(net, batch_size=2): x_tensor, y_tensor, m_tensor = load_dataset(mode='test', resize=True, resize_shape=(256, 256)) num_samples = x_tensor.shape[0] print("[+] ====== Start test... ======") num_iters = int(np.ceil(num_samples / batch_size)) for ite in range(num_iters): print("[*] predicting on the {}th batch".format(ite + 1)) if not ite == num_iters - 1: start_id, end_id = ite * batch_size, (ite + 1) * batch_size bat_img = torch.Tensor(x_tensor[start_id : end_id, :, :, :]) bat_label = torch.Tensor(y_tensor[start_id : end_id, 0: 1, :, :]) #bat_mask_2ch = torch.Tensor(m_tensor[start_id : end_id, :, :, :]) bat_mask = torch.Tensor(m_tensor[start_id : end_id, 0: 1, :, :]) else: start_id = ite * batch_size bat_img = torch.Tensor(x_tensor[start_id : , :, :, :]) bat_label = torch.Tensor(y_tensor[start_id : , 0: 1, :, :]) #bat_mask_2ch = torch.Tensor(m_tensor[start_id : end_id, :, :, :]) bat_mask = torch.Tensor(m_tensor[start_id : , 0: 1, :, :]) bat_pred = net(bat_img) bat_pred_class = (bat_pred > 0.5).float() * bat_mask eval_print_metrics(bat_label, bat_pred, bat_mask) # plt.imshow(bat_pred[0,0,:,:].detach().numpy(), cmap='jet')#, vmin=0, vmax=1) # plt.colorbar() # plt.show() #bat_pred_class = bat_pred.detach() * bat_mask paste_and_save(bat_img, bat_label, bat_pred_class, batch_size, ite + 1) return
def main(): train_data, val_data, train_label, val_label, tokenizer = load_dataset( 'train', FLAGS.dev_sample_percentage, FLAGS.max_len, ) if FLAGS.optimizer == 'adam': optimizer = tf.keras.optimizers.Adam() elif FLAGS.optimizer == 'sgd': optimizer = tf.keras.optimizers.SGD() # char_cnn = CharCNN(tokenizer, len(train_label[0]), FLAGS.dropout_prob) char_cnn = create_model(tokenizer, len(train_label[0]), FLAGS.dropout_prob, FLAGS.max_len) char_cnn.compile(optimizer=optimizer, loss=tf.keras.losses.categorical_crossentropy, metrics=['accuracy']) char_cnn.summary() callbacks_list = [save()] char_cnn.fit(train_data, train_label, batch_size=FLAGS.batch_size, epochs=FLAGS.num_epochs, validation_data=(val_data, val_label), callbacks=callbacks_list)
def search_learning_rates(): learning_rates = [0.01, 0.001, 0.0001] models = {} train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = data_loader.load_dataset( ) train_set_x, test_set_x = data_loader.preprocess_dataset( train_set_x_orig, test_set_x_orig) for i in learning_rates: print("learning rate is: " + str(i)) models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations=1500, learning_rate=i, print_cost=False) print('\n' + "-------------------------------------------------------" + '\n') for i in learning_rates: pyplot.plot(numpy.squeeze(models[str(i)]["costs"]), label=str(models[str(i)]["learning_rate"])) pyplot.ylabel('cost') pyplot.xlabel('iterations (hundreds)') legend = pyplot.legend(loc='upper center', shadow=True) frame = legend.get_frame() frame.set_facecolor('0.90') pyplot.show()
def main(): if not torch.cuda.is_available(): logger.info("no gpu device available") sys.exit(1) logger.info("*** Begin {} ***".format(config.stage)) # set default gpu device torch.cuda.set_device(config.gpus[0]) # set random seed np.random.seed(config.seed) torch.manual_seed(config.seed) torch.cuda.manual_seed_all(config.seed) torch.backends.cudnn.benchmark = True # get data with meta info logger.info("preparing data...") input_size, channels_in, num_classes, train_data, valid_data = \ load_dataset(dataset=config.dataset, data_dir=config.data_dir, cutout_length=0, validation=True, auto_aug=config.auto_aug) train_loader = torch.utils.data.DataLoader( dataset=train_data, batch_size=config.batch_size, sampler=torch.utils.data.sampler.SubsetRandomSampler( list(range(config.total_samples))), num_workers=config.num_workers, pin_memory=True) valid_loader = torch.utils.data.DataLoader( dataset=valid_data, batch_size=config.batch_size, sampler=torch.utils.data.sampler.SubsetRandomSampler( list(range(config.total_samples))), num_workers=config.num_workers, pin_memory=True) logger.info("loading model...") model = utils.load_checkpoint(config.model_dir) model = model.to(device) model.eval() config.num_cells = len(model._cells) config.num_nodes = len(model._cells[0]._dag) logger.info("start computing...") #compute_offline(train_loader, model, config.feature_dir) compute_online(train_loader, model, config.feature_dir) logger.info("*** Finish {} ***".format(config.stage))
def search_from_path(self, query_path, verification=True): # 3.1 inference query images to descriptors (infer_image_to_des) self.query_image_paths, self.query_image_labels = load_dataset( query_path, no_label=True) self.query_result = self.infer_image_to_des( self.query_image_paths, self.query_image_labels ) # result['locations'], result['descriptors'] query_des_np = np.concatenate(np.asarray( self.query_result['descriptors']), axis=0) # index table for query set self.query_des_from_img, self.query_img_from_des = make_index_table( self.query_result['descriptors']) query_img_idx = list(self.query_des_from_img.keys()) # 3.2 pq search k = 60 # k nearest neighber _, query_des2desList = self.pq.search(query_des_np, k) # 3.3 find similar image list by frequency score (get_similar_img(mode='frequency', searched_des)) query_des2imgList = {} # travel query images' inferenced descriptors for img_i, des_list in enumerate(query_des2desList): # map inferenced descirptors to their parents' image index query_des2imgList[img_i] = [ self.img_from_des[des_i] for des_i in des_list ] """ query_des2imgList = { image_index: [list of image index of each descriptor]} """ query_img2imgFreq = self.get_similar_img(query_des2imgList) self.result = query_img2imgFreq # 3.4 verification by ransac (rerank) if verification: query_inlier_rank = self.get_ransac_result(query_img2imgFreq) self.result = query_inlier_rank # # 3.5 index to image path for query_i in self.result: top_k_img_i_list = self.result[query_i]['index'] top_k_img_path = [ self.db_image_paths[img_i] for img_i in top_k_img_i_list ] self.result[query_i]['path'] = top_k_img_path self.result = query_img2imgFreq return self.result
def main(): if not torch.cuda.is_available(): logger.info("no gpu device available") sys.exit(1) logger.info("*** Begin {} ***".format(config.stage)) # set default gpu device torch.cuda.set_device(config.gpus[0]) # set random seed np.random.seed(config.seed) torch.manual_seed(config.seed) torch.cuda.manual_seed_all(config.seed) torch.backends.cudnn.benchmark = True # get data with meta info logger.info("preparing data...") input_size, channels_in, num_classes, train_data, valid_data = \ load_dataset(dataset=config.dataset, data_dir=config.data_dir, cutout_length=config.cutout_length, validation=True, auto_aug=config.auto_aug) valid_loader = torch.utils.data.DataLoader(dataset=valid_data, batch_size=config.batch_size, shuffle=False, num_workers=config.num_workers, pin_memory=True) logger.info("loading model...") if config.load_model_dir is not None: model = torch.load(config.load_model_dir) else: model = utils.load_checkpoint(config.model_dir) model = model.to(device) model_size = utils.param_size(model) logger.info("model_size: {:.3f} MB".format(model_size)) if config.label_smooth > 0: criterion = utils.CrossEntropyLabelSmooth(num_classes, config.label_smooth) else: criterion = nn.CrossEntropyLoss() criterion = criterion.to(device) logger.info("start testing...") best_top1 = test(valid_loader, model, criterion) logger.info("Final Prec@1: {:.4%}".format(best_top1)) logger.info("*** Finish {} ***".format(config.stage))
def main(dataset_path, seed): expert_user_trajectory = load_dataset(dataset_path) torch.manual_seed(seed) torch.cuda.manual_seed(seed) model = GANModel(expert_user_trajectory) Reward = model.train() with open("./hyper_batch_256_D1r_0.0005_5000.json", "w") as f: json.dump(Reward, f)
def main(args): # Create model directory if not os.path.exists(args.model_path): os.makedirs(args.model_path) # Build data loader dataset, targets = load_dataset() # Build the models mlp = MLP(args.input_size, args.output_size) load_model = True if load_model: mlp.load_state_dict(torch.load('../models/cae_encoder.pkl')) if torch.cuda.is_available(): mlp.cuda() # Loss and Optimizer criterion = nn.MSELoss() optimizer = torch.optim.Adagrad(mlp.parameters()) # Train the Models total_loss = [] print(len(dataset)) print(len(targets)) sm = 10 # start saving models after 100 epochs for epoch in range(args.num_epochs): print("epoch" + str(epoch)) avg_loss = 0 for i in range(0, len(dataset), args.batch_size): # Forward, Backward and Optimize mlp.zero_grad() bi, bt = get_input(i, dataset, targets, args.batch_size) bi = to_var(bi) bt = to_var(bt) bo = mlp(bi) loss = criterion(bo, bt) avg_loss = avg_loss + loss.data.item() loss.backward() optimizer.step() print("--average loss:") print(avg_loss / (len(dataset) / args.batch_size)) total_loss.append(avg_loss / (len(dataset) / args.batch_size)) # Save the models if epoch == sm: model_path = 'mlp_100_4000_PReLU_ae_dd' + str(sm) + '.pkl' torch.save(mlp.state_dict(), os.path.join(args.model_path, model_path)) sm = sm + 50 # save model after every 50 epochs from 100 epoch ownwards torch.save(total_loss, 'total_loss.dat') model_path = 'mlp_100_4000_PReLU_ae_dd_final.pkl' torch.save(mlp.state_dict(), os.path.join(args.model_path, model_path))
def main(config): # ensure reproducibility torch.manual_seed(config.random_seed) kwargs = {} if config.cuda: torch.cuda.manual_seed(config.random_seed) kwargs = {'num_workers': 1, 'pin_memory': True} scores = [] # instantiate data loaders count = 0 times = [] for i in [1, 2, 3]: start = time.time() count = i train_data, test_data = load_dataset(config.data_dir, str(count)) # instantiate data loaders data_loader = get_train_valid_loader(train_data, config.batch_size, config.random_seed, config.valid_size, config.shuffle, config.show_sample, **kwargs) test_loader = get_test_loader(test_data, config.batch_size, **kwargs) # instantiate trainer trainer = Trainer(config, count, data_loader, test_loader) trainer.train() result = trainer.test() scores.append(result) elapsed = time.time() - start times.append(elapsed) scores = np.array(scores) times = np.array(times) print('>>> scores:', scores) print('aver time', times.mean()) # print('avg\tacc\tf1\tprec\trec\tauc') print('acc:', scores.mean(axis=0)[0], '\nf1', scores.mean(axis=0)[1], '\nprec', scores.mean(axis=0)[2], '\nrec', scores.mean(axis=0)[3]) print('>>> std') print('acc:', scores.std(axis=0)[0], '\nf1', scores.std(axis=0)[1], '\nprec', scores.std(axis=0)[2], '\nrec', scores.std(axis=0)[3])
def test_mnist_shuffle_split_0(self): batch_size = 100 train_loader, test_loader, val_loader = data_loader.load_dataset( 'mnist', './data', batch_size=batch_size, shuffle=True, augmentation=False, noise=0., split_seed=42, split=0.) assert val_loader is None assert len(train_loader) == 600
def test_cifar10_shuffle_split_99(self): batch_size = 100 train_loader, test_loader, val_loader = data_loader.load_dataset( 'cifar10', './data', batch_size=batch_size, shuffle=True, augmentation=False, noise=0., split_seed=42, split=0.99) assert len(val_loader) == 495 assert len(train_loader) == 5
def test_mnist_split_40(self): batch_size = 100 train_loader, test_loader, val_loader = data_loader.load_dataset( 'mnist', './data', batch_size=batch_size, shuffle=False, augmentation=False, noise=0., split_seed=42, split=0.4) assert len(val_loader) == 240 assert len(train_loader) == 360
def main(): train_data, val_data, train_label, val_label, tokenizer = load_dataset() print('train_data[0]', len(train_label[0])) char_cnn = CharCNN(tokenizer, len(train_label[0])) inputs = Input(shape=(1014,), name='input') outputs = char_cnn(inputs) model = Model(inputs=inputs, outputs=outputs) model.compile(optimizer=tf.keras.optimizers.Adam(), loss=tf.keras.losses.categorical_crossentropy, metrics=['accuracy']) model.fit(train_data, train_label, batch_size=256, epochs=5, validation_data=(val_data,val_label))
def main(load_embedding=False, max_runs=5, batch_size=1): sents, labels, n_classes = utils.load_imdb_dataset() # sents, labels, n_classes = utils.load_rotten_tomatoes_dataset() print(f'distribution of classes: {Counter(labels)}') tokenized_sents = utils.tokenize(sents) tokenized_sents, labels = utils.remove_empty_tokenizedsents( tokenized_sents, labels) if load_embedding: embeddings, word_id_map = utils.load_glove_embedding_map( torch_flag=True) print(f'loaded pretrained embedding of shape: ', embeddings.shape) else: print(f'NO pretrained embedding loaded') word_id_map = utils.get_word_id_map(enrich_vocab=True) embeddings = None sents_as_ids = utils.convert_word_to_id(tokenized_sents, word_id_map) # sents_as_ids = [utils.pad_token_ids(s,word_id_map['PAD'],max_len=30) for s in sents_as_ids] accs = [] f_scores = [] for run in range(1, max_runs + 1): train_sent_ids, test_sent_ids, y_train, y_test = train_test_split( sents_as_ids, labels, test_size=0.3, random_state=randint(1, 100)) dataset = data_loader.load_dataset(train_sent_ids, y_train, device) train_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=0) print( f'sample lengths - train: {len(y_train)} and test: {len(y_test)}') model = train(train_loader, embeddings, n_epochs=20, vocab_size=len(word_id_map), lr=0.05, use_pretrained_wv=load_embedding, n_classes=n_classes) try: a, f = test_batch(model, test_sent_ids, y_test) except: a, f = test_stochastic(model, test_sent_ids, y_test) accs.append(a) f_scores.append(f) print(f'run: {run}, acc: {a}, f1: {f}') print( f'average of {max_runs} runs acc: {sum(accs)/len(accs)}, f1: {sum(f_scores)/len(f_scores)}' )
def subtype_select(subtype): """ this function returns Features (X) and labels (y) representing subtype. """ X = data_loader.load_dataset() y = data_loader.load_target() X = X.subtract(X.mean()) subtypes = ['HER2+', 'HR+', 'Triple Neg'] subtypes.remove(subtype) y = y.replace(subtype, 1) y = y.replace(subtypes, 0) return X, y
def select_subtype(subtype): """ this function returns Features (X) and labels (y) representing subtype. """ X = data_loader.load_dataset() y = data_loader.load_target() # apply mean centering to for each region X = X.subtract(X.mean()) # all subtypes subtypes = ['HER2+', 'HR+', 'Triple Neg'] # remove the current subtype from the whole subtype set subtypes.remove(subtype) # re-coding the subtypes to 0 and 1 y = y.replace(subtype, 1) y = y.replace(subtypes, 0) return X, y
def attach_db_from_path(self, db_path, ignore_cache=False, cache_path='result_cache_hub.joblib', filename_path='filename_path.joblib'): # 2.1 self.db_image_paths, self.db_image_labels = load_dataset(db_path) # ignore cache loading & execute inference if ignore_cache or not os.path.exists(cache_path): self.db_result = self.infer_image_to_des( self.db_image_paths, self.db_image_labels ) # result['locations'], result['descriptors'] # cache save with open(cache_path, 'wb') as f: joblib.dump(self.db_result, f) # with open(filename_path, 'wb') as f: # joblib.dump(self.db_image_paths, f) # exist cache file else: print("no inference on db") with open(cache_path, 'rb') as f: self.db_result = joblib.load(f) # with open(filename_path, 'rb') as f: # self.db_image_paths = joblib.load(f) # for i in range(20): # print('{}th descriptors num: {}'.format(i, self.db_result['descriptors'][i].shape)) # 2.2 self.des_from_img, self.img_from_des = make_index_table( self.db_result['descriptors']) # 2.3 descriptors_np = np.concatenate(np.asarray( self.db_result['descriptors']), axis=0) if not self.pq.is_trained: self.pq.train(descriptors_np) self.pq.add(descriptors_np)
def test(): if FLAGS.optimizer == 'adam': optimizer = tf.keras.optimizers.Adam() elif FLAGS.optimizer == 'sgd': optimizer = tf.keras.optimizers.SGD() test_data, test_label, tokenizer = load_dataset('test', max_len=MAX_LEN) char_cnn = create_model(tokenizer, len(test_label[0]), 0, max_len=MAX_LEN) if os.path.isfile(FLAGS.weights_path): #char_cnn = load_model(FLAGS.weights_path) char_cnn.load_weights(FLAGS.weights_path) char_cnn.compile(optimizer=optimizer, loss=tf.keras.losses.categorical_crossentropy, metrics=['accuracy']) output = char_cnn.evaluate(test_data, test_label) print(output)
def get_cluster_index(function_name, dataset_name): """ Get a cluster evaluation function for a specific dataset. Parameters ---------- function_name: string dataset_name: string Returns ------- eval_func: 1d function Index for evaluating a clustering final partition. task: 'min' or 'max' Type of problem (minimization or maximization) """ X, y = data_loader.load_dataset(dataset_name) if function_name == 'davies_bouldin': return davies_bouldin(X, y), 'min' else: return xie_beni(X, y), 'min'
def main(config): # ensure reproducibility torch.manual_seed(config.random_seed) scores = [] # instantiate data loaders count = 0 times = [] for i in range(1, 4): start = time.time() count = i train_data, test_data = load_dataset(config.data_dir, str(count)) # instantiate data loaders data_loader = get_train_loader(train_data, config.batch_size, config.random_seed, config.shuffle) test_loader = get_test_loader(test_data, config.batch_size) # instantiate trainer trainer = Trainer(config, count, data_loader, test_loader) trainer.train() result = trainer.test() scores.append(result) elapsed = time.time() - start times.append(elapsed) scores = np.array(scores) times = np.array(times) print('aver time', times.mean()) # print('avg\tacc\tf1\tprec\trec\tauc') print('acc:', scores.mean(axis=0)[0], '\nf1', scores.mean(axis=0)[1], '\nprec', scores.mean(axis=0)[2], '\nrec', scores.mean(axis=0)[3])
def train(dataset_path, dim_seed, batch_size, lr_g, lr_d, alpha, beta, seed): """ Train GAN for generating real user features """ dim_user = 70 dim_seed = dim_seed expert_user_features = load_dataset(dataset_path) torch.manual_seed(seed) torch.cuda.manual_seed(seed) model = GanModel(dim_user, dim_seed, lr_g, lr_d, expert_user_features, batch_size=batch_size, alpha=alpha, beta=beta).to(device) WL = model.train() model.save_model() state = {"WL": WL} torch.save(state, "./hyper_batch_256_G1r_0.0005_Dlr_0.0001.pth")
# parser.add_argument("--batch_size", type=int, default=64, help="Batch Size") # parser.add_argument("--num_epochs", type=int, default=50, help="Number of training epochs") # parser.add_argument("--evaluate_every", type=int, default=2, help="Evaluate model on dev set after this many steps (default: 50)") # parser.add_argument("--moving_average", type=bool, default=True, help="Enable usage of Exponential Moving Average") # args = parser.parse_args() # # try: # # args = parser.parse_args() # # print(args) # # except: # # return 1 # In[4]: #Loading Data train_data, train_label, test_data, test_label, bgr_mean = data_loader.load_dataset( face_dataset, 1) bgr_mean = [round(x, 4) for x in bgr_mean] # In[5]: acc_list = [0] loss_train_list = [0] loss_test_list = [0] sess = tf.Session() # In[6]: bgr_mean = [93.5940, 104.7624, 129.1863] cnn = VGGFace(bgr_mean, vgg_weights, num_classes=8, weight_decay=5e-4) vgg_known_acc_max = [0.65, 0.51, 0.59, 0.49, 0.59]
from data_loader import load_dataset from attacks import create_attack from configs import path_fig, epsilon, eps_step, path from utils import get_acc_preds, plot_attacks_acc, plot_compare_acc, __resize_array_images from models.models import medical_vgg_model from tensorflow.keras.optimizers import SGD from sklearn.metrics import accuracy_score, roc_auc_score # query user for dataset dataset = input( 'Enter dataset to be used (brain_mri, mnist, cifar, ddsm, lidc)\n') # load in dataset # lidc, ddsm augment if dataset == 'ddsm' or dataset == 'lidc': x_train, y_train, x_test, y_test = load_dataset(dataset, path, aug=True) else: x_train, y_train, x_test, y_test = load_dataset(dataset, path, aug=False) # query user for adversarial attack to use for generating adversarial test set attack_type = input('Enter attack to be used (fgsm, pgd, bim)\n') if (attack_type != 'fgsm') & (attack_type != 'pgd') & ( attack_type != 'bim') & (attack_type != 'jsma'): print('attack type not supported\n') exit(0) # verify that x_train, y_train, x_test, y_test have the correct dimensions print('x_train shape: ', x_train.shape) print('y_train.shape', y_train.shape) print('x_test.shape', x_test.shape) print('y_test.shape', y_test.shape)
def train(): print("Loading training data...") # Get sentences to tensors input_tensor, target_tensor, inp_lang, targ_lang = load_dataset( PATH_TO_FILE, num_examples=None) # NNConfig vocab_inp_size = len(inp_lang.word_index) + 1 vocab_targ_size = len(targ_lang.word_index) + 1 config = NNConfig(vocab_inp_size, vocab_targ_size) # Save i2w file for test and translate save_index2word(inp_lang, "./dataset/input_dict.txt") save_index2word(targ_lang, "./dataset/target_dict.txt") save_max_length(input_tensor, target_tensor, vocab_inp_size, vocab_targ_size, "./dataset/max_len.txt") # Setup the trainning data batch BUFFER_SIZE = len(input_tensor) steps_per_epoch = len(input_tensor) // config.BATCH_SIZE dataset = tf.data.Dataset.from_tensor_slices( (input_tensor, target_tensor)).shuffle(BUFFER_SIZE) dataset = dataset.batch(config.BATCH_SIZE, drop_remainder=True) print("Setting Seq2Seq model...") # Setup the NN Structure encoder = Encoder(config.VOCAB_INP_SIZE, config.EMBEDDING_DIM, config.UNITS, config.BATCH_SIZE) decoder = Decoder(config.VOCAB_TARG_SIZE, config.EMBEDDING_DIM, config.UNITS, config.BATCH_SIZE) # Setup optimizer optimizer = tf.keras.optimizers.Adam() loss_object = tf.keras.losses.SparseCategoricalCrossentropy( from_logits=True, reduction='none') # Setup Checkpoint checkpoint = tf.train.Checkpoint(optimizer=optimizer, encoder=encoder, decoder=decoder) def loss_function(real, pred): mask = tf.math.logical_not(tf.math.equal(real, 0)) loss_ = loss_object(real, pred) mask = tf.cast(mask, dtype=loss_.dtype) loss_ *= mask return tf.reduce_mean(loss_) @tf.function def train_step(inp, targ, enc_hidden, optimizer): loss = 0 with tf.GradientTape() as tape: enc_output, enc_hidden = encoder(inp, enc_hidden) dec_hidden = enc_hidden dec_input = tf.expand_dims([targ_lang.word_index['<start>']] * config.BATCH_SIZE, 1) # Teacher forcing - feeding the target as the next input for t in range(1, targ.shape[1]): # passing enc_output to the decoder predictions, dec_hidden, _ = decoder(dec_input, dec_hidden, enc_output) loss += loss_function(targ[:, t], predictions) # using teacher forcing dec_input = tf.expand_dims(targ[:, t], 1) batch_loss = (loss / int(targ.shape[1])) variables = encoder.trainable_variables + decoder.trainable_variables gradients = tape.gradient(loss, variables) optimizer.apply_gradients(zip(gradients, variables)) return batch_loss print("Start training ...") for epoch in range(config.EPOCHS): start = time.time() enc_hidden = encoder.initialize_hidden_state() total_loss = 0 for (batch, (inp, targ)) in enumerate(dataset.take(steps_per_epoch)): batch_loss = train_step(inp, targ, enc_hidden, optimizer) total_loss += batch_loss if batch % 100 == 0: print('Epoch {} Batch {} Loss {:.4f}'.format( epoch + 1, batch, batch_loss.numpy())) # saving (checkpoint) the model every 2 epochs if (epoch + 1) % 2 == 0: checkpoint.save(file_prefix=SAVE_PATH) print('Epoch {} Loss {:.4f}'.format(epoch + 1, total_loss / steps_per_epoch)) print('Time taken for 1 epoch {} sec\n'.format(time.time() - start))
def compute_predictions(): RMSE = np.zeros((len(datasets), len(training_schemes), num_trials)) NLL = np.zeros((len(datasets), len(training_schemes), num_trials)) df_pred_uci = pd.DataFrame( columns=["Dataset", "Method", "Target", "Mu", "Sigma"]) for di, dataset in enumerate(datasets): for ti, trainer_obj in enumerate(training_schemes): for n in range(num_trials): (x_train, y_train), (x_test, y_test), y_scale = data_loader.load_dataset( dataset, return_as_tensor=False) batch_size = h_params[dataset]["batch_size"] num_iterations = num_epochs * x_train.shape[0] // batch_size print("Num of iterations :", num_iterations) done = False while not done: with tf.device(dev): model_generator = models.get_correct_model( dataset="toy", trainer=trainer_obj) model, opts = model_generator.create( input_shape=x_train.shape[1:]) if method_names[ ti] == "Laplace": #training scheme is likelihood; as its 2nd in list print("Trainienr lalpace likelihood") trainer = trainer_obj( model, opts, "laplace", dataset, learning_rate=h_params[dataset] ["learning_rate"]) elif method_names[ti] == "Gaussian": print("Trainienr Gaussian likelihood") trainer = trainer_obj( model, opts, "gaussian", dataset, learning_rate=h_params[dataset] ["learning_rate"]) else: trainer = trainer_obj( model, opts, dataset, learning_rate=h_params[dataset] ["learning_rate"]) model, rmse, nll = trainer.train(x_train, y_train, x_test, y_test, y_scale, iters=num_iterations, batch_size=batch_size, verbose=True) #Compute on validation data and save predictions summary_to_add = get_prediction_summary( dataset, method_names[ti], model, x_test, y_test) df_pred_uci = df_pred_uci.append(summary_to_add, ignore_index=True) del model tf.keras.backend.clear_session() done = False if np.isinf(nll) or np.isnan( nll) else True print("saving {} {}".format(rmse, nll)) RMSE[di, ti, n] = rmse NLL[di, ti, n] = nll RESULTS = np.hstack((RMSE, NLL)) mu = RESULTS.mean(axis=-1) error = np.std(RESULTS, axis=-1) print("==========================") print("[{}]: {} pm {}".format(dataset, mu, error)) print("==========================") print("TRAINERS: {}\nDATASETS: {}".format( [trainer.__name__ for trainer in training_schemes], datasets)) print("MEAN: \n{}".format(mu)) print("ERROR: \n{}".format(error)) return df_pred_uci
import os import time import data_loader import itertools from torchtext import data import torch import torch.nn as nn import torch.nn.functional as F from torch.autograd import Variable import torch.optim as optim import numpy as np from sklearn.metrics import confusion_matrix, accuracy_score, precision_score, recall_score, f1_score import matplotlib.pyplot as plt from lstm import LSTMClassifier TEXT, LABEL, label_size, vocab_size, word_embeddings, train_iter, valid_iter, test_iter = data_loader.load_dataset( ) def clip_gradient(model, clip_value): params = list(filter(lambda p: p.grad is not None, model.parameters())) for p in params: p.grad.data.clamp_(-clip_value, clip_value) def plot_confusion_matrix(cm, classes, normalize=False, title='Confusion matrix', cmap=plt.cm.Blues): """ This function prints and plots the confusion matrix.
if __name__ == '__main__': import numpy as np import pandas as pd import time from sklearn.model_selection import train_test_split from sklearn.linear_model import LinearRegression from sklearn.tree import DecisionTreeClassifier from private_tree.tree import DP_Random_Forest from private_tree.dp_datagen import (generate_data, generate_partition) from data_loader import (load_dataset, allocate_data_to_agents) from evaluations.eval_utils import (plot_results, save_data, eval, as_dataframe) data, x, y, p, c = load_dataset('census', 'education-num') data = data[0:10] ## todo: just avoid counts < 5 or so (prune branch) print(data) mdl = DP_Random_Forest(train=data.values, categs=[], num_trees=1, max_tree_depth=10, seed=1) mdl.fit(train=data.values, eps=1.0) mdl.predict(test=data.values) # Agent Generate private (unlabeled) data partition = generate_partition(mdl._trees[0], data, x) for p in partition: print(p)