def plot_loss_landscape(models, device, init, save_path=None, verbose=True): """Plotting the loss landscape and creating a file for replotting""" train_loader, test_loader = load_data('mnist', path='../data') criterion = nn.CrossEntropyLoss() xv, yv, loss, directions, x_coord, y_coord = loss_landscape_pca_2d( models, test_loader, criterion, device, verbose=verbose) # fig, ax = plt.subplots() # CS = ax.contour(xv, yv, loss, levels=20) # ax.clabel(CS, inline=1, fontsize=10) # ax.set_title('Loss Landscape (with PCA)') # ax.plot(x_coord, y_coord, marker='.') if save_path != None: print("Saving plot information in {}init_{}.npz\n".format( save_path, init)) # np.savez('{}.npz'.format(save_path[:-4]), xv=xv, yv=yv, loss=loss, xdir=np.asarray(directions[0]), ydir=np.asarray(directions[1]), x=x_coord, y=y_coord) np.savez('{}init_{}.npz'.format(save_path, init), xv=xv, yv=yv, loss=loss, x=x_coord, y=y_coord)
processor = Sst2Processor() label_list = processor.get_labels() logging.info("Predict with {} labels: {}".format(len(label_list), label_list)) tokenizer = BertTokenizer.from_pretrained( Config.PRE_TRAINED_MODEL_BERT_BASE_UNCASED, do_lower_case=Config.DO_LOWER_CASE) test_examples = processor.get_dev_examples(Config.DATA_DIR) logging.info( "loaded {} test examples (take care: we use the evaluation-data here as no labels for test are " "available!)".format(len(test_examples))) test_data_loader = load_data(test_examples, label_list, tokenizer, Config.MAX_SEQ_LENGTH, Config.EVAL_BATCH_SIZE, DataType.TEST) model = load_saved_model(Config.TRAINED_MODEL_FOR_PREDICTION, Config.MODEL_OUTPUT_DIR, len(label_list)) model.to(device) prediction = predict(test_examples, test_data_loader, model, device) print("Prediction done! Result-Shape: {}".format(prediction.shape)) print(prediction[:10]) print( classification_report(list(prediction['true_label']), list(prediction['predicted_label'])))
model = get_pretrained_model(Config.PRE_TRAINED_MODEL_BERT_BASE_UNCASED, len(label_list), Config.PRE_TRAINED_MODEL_CACHE_DIR) model.to(device) logging.info("initialized BERT-model") num_train_steps = int( len(train_examples) / Config.TRAIN_BATCH_SIZE) * Config.NUM_EPOCHS optimizer = build_optimizer(model, num_train_steps, Config.LEARNING_RATE, Config.WARMUP_PROPORTION, Config.WEIGHT_DECAY) logging.info("Built optimizer: {}".format(optimizer)) eval_examples = processor.get_dev_examples(Config.DATA_DIR) evaluation_data_loader = load_data(eval_examples, label_list, tokenizer, Config.MAX_SEQ_LENGTH, Config.EVAL_BATCH_SIZE, DataType.EVALUATION) evaluation = Evaluation(evaluation_data_loader, exp_name, Config.MODEL_OUTPUT_DIR) logging.info("loaded and initialized evaluation examples {}".format( len(eval_examples))) training = Training() training_data_loader = load_data(train_examples, label_list, tokenizer, Config.MAX_SEQ_LENGTH, Config.TRAIN_BATCH_SIZE, DataType.TRAINING) training.fit(device, training_data_loader, model, optimizer, evaluation, Config.NUM_EPOCHS)
def main(): # saving path save_dir = 'results/aexcov' if not os.path.exists(save_dir): os.makedirs(save_dir) # parse parameters parser = argparse.ArgumentParser(description='AE-XCov') parser.add_argument('--img_sz', type=int, default=64, help='Image size (images have to be squared)') parser.add_argument('--batch_size', type=int, default=128, help='Batch size') parser.add_argument("--attr_size", type=int, default=40, help='Attribute vector size') parser.add_argument("--latent_size", type=int, default=1000, help='Latent vector size') parser.add_argument('--n_epochs', type=int, default=25, help='Total number of epochs') parser.add_argument('--n_train', type=int, default=162770, help='The number of training samples') parser.add_argument('--n_valid', type=int, default=19867, help='The number of validation samples') parser.add_argument('--n_test', type=int, default=19962, help='The number of test samples') parser.add_argument('--lr_encoder', type=float, default=1e-4, help='Learning rate for encoder') parser.add_argument('--lr_decoder', type=float, default=1e-4, help='Learning rate for decoder') parser.add_argument('--lambda_class', type=float, default=1, help='Image classification coefficient for encoder') parser.add_argument('--lambda_decorr', type=float, default=1, help='Decorrelation regularization coefficient') parser.add_argument('--lambda_recons', type=float, default=1, help='Feature reconstruction coefficient for decoder') parser.add_argument('--decay_lr', type=float, default=0.75, help='Learning rate decay') parser.add_argument('--seed', type=int, default=1, help='Random seed') params = parser.parse_args() # use GPUs use_cuda = torch.cuda.is_available() if use_cuda: device = torch.device('cuda:0') else: device = torch.device('cpu') # fix the random seed random.seed(params.seed) torch.manual_seed(params.seed) torch.cuda.manual_seed_all(params.seed) # split data train_index = params.n_train valid_index = params.n_train + params.n_valid test_index = params.n_train + params.n_valid + params.n_test indices_all_imgs = np.arange(test_index) train_indices = indices_all_imgs[:train_index] valid_indices = indices_all_imgs[train_index:valid_index] test_indices = indices_all_imgs[valid_index:test_index] attrs_dir = 'D:/Projects/dataset/CelebA/data_imgs_attrs_64_64_clip/attrs_all.csv' resized_imgs_dir = 'D:/Projects/dataset/CelebA/data_imgs_attrs_64_64_clip/imgs/' train_loader, valid_loader, test_loader = load_data( attrs_dir, resized_imgs_dir, params.batch_size, train_indices, valid_indices, test_indices, use_cuda) # build the model encoder = Encoder(channel_in=3, attr_size=params.attr_size, latent_size=params.latent_size) decoder = Decoder(z_size=params.attr_size + params.latent_size, size=256) encoder.apply(weights_init) decoder.apply(weights_init) encoder = encoder.to(device) decoder = decoder.to(device) # define the optimizers optim_encoder = optim.RMSprop(encoder.parameters(), lr=params.lr_encoder, alpha=0.9) optim_decoder = optim.RMSprop(decoder.parameters(), lr=params.lr_decoder, alpha=0.9) # schedule learning rate Steps = [10000, 20000] lr_scheduler_encoder = MultiStepLR(optim_encoder, milestones=Steps, gamma=params.decay_lr) lr_scheduler_decoder = MultiStepLR(optim_decoder, milestones=Steps, gamma=params.decay_lr) # define several loss functions attrs_class = nn.BCEWithLogitsLoss().to(device) # attribute classification decorr_regul = XCov().to(device) # decorrelation regularization # decorr_regul = dCov2().to(device) # train the whole model count_update_step = training(params, encoder, decoder, optim_encoder, optim_decoder, lr_scheduler_encoder, lr_scheduler_decoder, device, attrs_class, decorr_regul, train_loader, valid_loader, save_dir) visual_recons(encoder, decoder, device, test_loader) # save the settings and results with open(os.path.join(save_dir, 'summary.txt'), 'w') as f: f.write('Settings and Results:\n') f.write('------------------------------\n') f.write('Random seed = ' + str(params.seed) + '\n') f.write('Image size = ' + str(params.img_sz) + '\n') f.write('Attribute vector size = ' + str(params.attr_size) + '\n') f.write('Latent vector size = ' + str(params.latent_size) + '\n') f.write('Batch size = ' + str(params.batch_size) + '\n') f.write('------------------------------\n') f.write('Learning rate of Encoder = ' + str(params.lr_encoder) + '\n') f.write('Learning rate of Decoder = ' + str(params.lr_decoder) + '\n') f.write('Learning rate decay = ' + str(params.decay_lr) + '\n') f.write('------------------------------\n') f.write('Regularization parameter of the classification term = ' + str(params.lambda_class) + '\n') f.write('Regularization parameter of the decorrelation term = ' + str(params.lambda_decorr) + '\n') f.write( 'Regularization parameter of the reconstruction term in decoder = ' + str(params.lambda_recons) + '\n') f.write('------------------------------\n') f.write('Training samples = ' + str(params.n_train) + '\n') f.write('Validation samples = ' + str(params.n_valid) + '\n') f.write('Test samples = ' + str(params.n_test) + '\n') f.write('------------------------------\n') f.write('Max epoch = ' + str(params.n_epochs) + '\n') f.write('Total update steps = ' + str(count_update_step) + '\n')
def run(args, both_cases=False): if args.flush_history == 1: objects = os.listdir(args.log_path) for f in objects: if os.path.isdir(args.log_path + f): shutil.rmtree(args.log_path + f) now = datetime.now() logdir = args.log_path + now.strftime("%Y%m%d-%H%M%S") + "/" os.makedirs(logdir) log_file = logdir + 'log.txt' writer = SummaryWriter(logdir) batch_size = args.batch_size training_params = { "batch_size": batch_size, "shuffle": True, "num_workers": args.workers, "drop_last": True } validation_params = { "batch_size": batch_size, "shuffle": False, "num_workers": args.workers, "drop_last": True } texts, labels, number_of_classes, sample_weights = load_data(args) class_names = sorted(list(set(labels))) class_names = [str(class_name) for class_name in class_names] train_texts, val_texts, train_labels, val_labels, train_sample_weights, _ = train_test_split( texts, labels, sample_weights, test_size=args.validation_split, random_state=42, stratify=labels) training_set = MyDataset(train_texts, train_labels, args) validation_set = MyDataset(val_texts, val_labels, args) if bool(args.use_sampler): train_sample_weights = torch.from_numpy(train_sample_weights) sampler = WeightedRandomSampler( train_sample_weights.type('torch.DoubleTensor'), len(train_sample_weights)) training_params['sampler'] = sampler training_params['shuffle'] = False training_generator = DataLoader(training_set, **training_params) validation_generator = DataLoader(validation_set, **validation_params) model = CharacterLevelCNN(args, number_of_classes) if torch.cuda.is_available(): model.cuda() if not bool(args.focal_loss): if bool(args.class_weights): class_counts = dict(Counter(train_labels)) m = max(class_counts.values()) for c in class_counts: class_counts[c] = m / class_counts[c] weights = [] for k in sorted(class_counts.keys()): weights.append(class_counts[k]) weights = torch.Tensor(weights) if torch.cuda.is_available(): weights = weights.cuda() print(f'passing weights to CrossEntropyLoss : {weights}') criterion = nn.CrossEntropyLoss(weight=weights) else: criterion = nn.CrossEntropyLoss() else: if args.alpha is None: criterion = FocalLoss(gamma=args.gamma, alpha=None) else: criterion = FocalLoss(gamma=args.gamma, alpha=[args.alpha] * number_of_classes) if args.optimizer == 'sgd': if args.scheduler == 'clr': optimizer = torch.optim.SGD(model.parameters(), lr=1, momentum=0.9, weight_decay=0.00001) else: optimizer = torch.optim.SGD(model.parameters(), lr=args.learning_rate, momentum=0.9) elif args.optimizer == 'adam': optimizer = torch.optim.Adam(model.parameters(), lr=args.learning_rate) best_f1 = 0 best_epoch = 0 if args.scheduler == 'clr': stepsize = int(args.stepsize * len(training_generator)) clr = utils.cyclical_lr(stepsize, args.min_lr, args.max_lr) scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, [clr]) else: scheduler = None for epoch in range(args.epochs): training_loss, training_accuracy, train_f1 = train( model, training_generator, optimizer, criterion, epoch, writer, log_file, scheduler, class_names, args, args.log_every) validation_loss, validation_accuracy, validation_f1 = evaluate( model, validation_generator, criterion, epoch, writer, log_file, args.log_every) print( '[Epoch: {} / {}]\ttrain_loss: {:.4f} \ttrain_acc: {:.4f} \tval_loss: {:.4f} \tval_acc: {:.4f}' .format(epoch + 1, args.epochs, training_loss, training_accuracy, validation_loss, validation_accuracy)) print("=" * 50) # learning rate scheduling if args.scheduler == 'step': if args.optimizer == 'sgd' and ((epoch + 1) % 3 == 0) and epoch > 0: current_lr = optimizer.state_dict()['param_groups'][0]['lr'] current_lr /= 2 print('Decreasing learning rate to {0}'.format(current_lr)) for param_group in optimizer.param_groups: param_group['lr'] = current_lr # model checkpoint if validation_f1 > best_f1: best_f1 = validation_f1 best_epoch = epoch if args.checkpoint == 1: torch.save( model.state_dict(), args.output + 'model_{}_epoch_{}_maxlen_{}_lr_{}_loss_{}_acc_{}_f1_{}.pth' .format(args.model_name, epoch, args.max_length, optimizer.state_dict()['param_groups'][0]['lr'], round(validation_loss, 4), round(validation_accuracy, 4), round(validation_f1, 4))) if bool(args.early_stopping): if epoch - best_epoch > args.patience > 0: print( "Stop training at epoch {}. The lowest loss achieved is {} at epoch {}" .format(epoch, validation_loss, best_epoch)) break
experiment_results_directory = os.path.abspath( os.path.join(plotting_dir, dataset, noise_type_str, noise_level_str, hyperparam_index, init_index)) os.makedirs(experiment_results_directory, exist_ok=True) model_states_dir = os.path.join(model_dir, noise_type_str, noise_level_str, hyperparam_index) run_train, start_epoch, model_to_load = get_train_and_start_epoch( experiment_results_directory, model_states_dir, epochs, experiment_name) if run_train: # Load data train_loader, test_loader = load_data(dataset, batch_size=batch_size, path=os.path.join( base_path, '../data')) if start_epoch == 0: print("results directory is empty, starting test from beginning") # create network torch.manual_seed(seed) n_in, n_out = get_data_dimensions(dataset) net = Net(n_in, n_hidden, n_out, n_layer, act=act, noise_type=noise_type, noise_level=noise_level,
args.trained_model_for_prediction)) else: tokenizer = BertTokenizer.from_pretrained( args.model_name_or_path, do_lower_case=args.do_lower_case) logging.info( "Loaded pretrained model from {} but no fine-tuned tokenizer found, therefore use the standard tokenizer." .format(args.trained_model_for_prediction)) if args.data_processor == "QqpProcessor": processor = QqpProcessor() else: # this is the default as it works for all data sets of the deepmatcher project. processor = DeepMatcherProcessor() test_examples = processor.get_test_examples(args.data_path) logging.info("loaded {} test examples".format(len(test_examples))) test_data_loader = load_data(test_examples, processor.get_labels(), tokenizer, args.max_seq_length, args.test_batch_size, DataType.TEST) simple_accuracy, f1, classification_report, predictions = predict( model, device, test_data_loader) logging.info( "Prediction done for {} examples.F1: {}, Simple Accuracy: {}".format( len(test_data_loader), f1, simple_accuracy)) logging.info(classification_report) logging.info(predictions)
else: device = torch.device('cpu') net = VaeGan(device=device, z_size=z_size, recon_level=recon_level).to(device) # DATASET train_index = n_train valid_index = n_train + n_valid test_index = n_train + n_valid + n_test indices_all_imgs = np.arange(test_index) train_indices = indices_all_imgs[:train_index] valid_indices = indices_all_imgs[train_index:valid_index] test_indices = indices_all_imgs[valid_index:test_index] attrs_dir = 'D:/Projects/dataset/CelebA/data_imgs_attrs_64_64_clip/attrs_all.csv' resized_imgs_dir = 'D:/Projects/dataset/CelebA/data_imgs_attrs_64_64_clip/imgs/' dataloader, dataloader_valid, dataloader_test = load_data(attrs_dir, resized_imgs_dir, batch_size, train_indices, valid_indices, test_indices, args) # margin and equilibirum margin = 0.35 equilibrium = 0.68 # OPTIM-LOSS optimizer_encoder = optim.RMSprop(params=net.encoder.parameters(), lr=lr, alpha=0.9, eps=1e-8, weight_decay=0, momentum=0, centered=False) optimizer_decoder = optim.RMSprop(params=net.decoder.parameters(), lr=lr, alpha=0.9, eps=1e-8, weight_decay=0, momentum=0, centered=False) optimizer_discriminator = optim.RMSprop(params=net.discriminator.parameters(), lr=lr, alpha=0.9, eps=1e-8, weight_decay=0, momentum=0, centered=False) Steps = [1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000] lr_encoder = MultiStepLR(optimizer_encoder, milestones=Steps, gamma=decay_lr)
new.save(file_path) def clear(self): self.image.fill(Qt.white) self.update() def guess(self): # Obtener imagen image = self.image.scaled(28, 28) # Scale image n = loader.qimage_to_ndarray(image) drawing, percentage = self.network.evaluate_drawing(n) message = ("I'm %s%% sure it's a %s!" % (int(percentage[0]), loader.image_classifier(int(drawing)))) QMessageBox.about(self, "Result", message) if __name__ == '__main__': # Load Data train, cv, test = loader.load_data(11000) # Create neural network net = network.Network([784, 100, 10]) # training_data, test, cv epochs, batch_size, learning, lambda net.train(train, test, cv, 8, 20, 0.4, 10) app = QApplication(sys.argv) window = Window(net) window.show() app.exec()
logging.info("training with {} labels: {}".format(len(label_list), label_list)) config_class, model_class, tokenizer_class = Config.MODEL_CLASSES[args.model_type] config = config_class.from_pretrained(args.model_name_or_path) tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path, do_lower_case=args.do_lower_case) model = model_class.from_pretrained(args.model_name_or_path, config=config) model.to(device) logging.info("initialized {}-model".format(args.model_type)) train_examples = processor.get_train_examples(args.data_path) training_data_loader = load_data(train_examples, label_list, tokenizer, args.max_seq_length, args.train_batch_size, DataType.TRAINING, args.model_type) logging.info("loaded {} training examples".format(len(train_examples))) num_train_steps = len(training_data_loader) * args.num_epochs optimizer, scheduler = build_optimizer(model, num_train_steps, args.learning_rate, args.adam_eps, args.warmup_steps, args.weight_decay) logging.info("Built optimizer: {}".format(optimizer)) eval_examples = processor.get_test_examples(args.data_path)
def get_sensitivity_data_loader(dataset, classes, data_path, num_interpolations, re_generate=False): if not isinstance(classes, list): raise ValueError("Classes must be a list of integers") elif not isinstance(classes[0], int): raise ValueError("Classes must be a list of integers") train_loader, _ = load_data(dataset, path=data_path, batch_size=None) data = None lables = None # put code in here to calculate means and store all sorted classes? for batch, target in train_loader: image_shape = batch.shape[1:] data = batch.view(batch.shape[0], -1) labels = target if re_generate: print("regenerate data") sorted_data = {i: data[labels == i] for i in range(10)} means = {i: sorted_data[i].mean(dim=0) for i in range(10)} ############################################################################ # dist = np.linalg.norm((data[:, :, np.newaxis] - means), axis=1) ############################################################################ for i in range(10): # find data point for each class that is closest to the mean (order them?) images = sorted_data[i] mean = means[i].unsqueeze(0) difference = images - mean distances = torch.norm(difference, dim=-1) order = np.argsort(distances) sorted_data[i] = sorted_data[i][order] data_points = [ sorted_data[_class][0].numpy() for index, _class in enumerate(classes) ] else: data_points = None # plot_means_data_points([means[c] for c in classes], data_points, image_shape) st = SensitivityTest(root=data_path, data_points=data_points, classes=classes, re_generate=re_generate, num_interpolations=num_interpolations, transform=transforms.ToTensor(), image_shape=image_shape) # plot_targets(st.targets, classes) return torch.utils.data.DataLoader(dataset=st, batch_size=1, shuffle=False)
if __name__ == '__main__': # use GPU if available use_cuda = torch.cuda.is_available() device = torch.device("cuda" if use_cuda else "cpu") print(device) # set seed seed = 1 torch.manual_seed(seed) # set hyperparameters n_in = 784 n_hidden = 100 n_out = 10 n_layer = 10 n_epochs = 20 train_loader, test_loader = load_data('mnist') eval_epochs = np.arange(0, n_epochs) eval_epochs = [0, 3, 8, 13, 19] n_iterations = 5 Y1 = get_score(n_iterations, 2, 'init_2', n_epochs, eval_epochs, train_loader, test_loader, device) Y2 = get_score(n_iterations, 1, 'init_1', n_epochs, eval_epochs, train_loader, test_loader, device) X = np.array(eval_epochs) plot_average(X, [Y1, Y2], ['Optimal Init', 'Suboptimal Init'], ['g', 'r'])
import os import sys import torch.nn as nn import numpy as np # custom import sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')) from src.data_loader import load_data from src.utils import get_experiment_dicts, test_models, load_model_results # Load MNIST data train_loader, test_loader = load_data('mnist', path='../data') # Load models result_path = '../results' model_dicts = get_experiment_dicts(result_path) # Test models dump_path = '../plotting' criterion = nn.CrossEntropyLoss() test_models(model_dicts, criterion, train_loader, test_loader, result_path=result_path, dump_path=dump_path, quiet=True)
def run(args): batch_size = args.batch_size training_params = {"batch_size": batch_size, "shuffle": True, "num_workers": args.workers} texts, labels, number_of_classes, sample_weights = load_data(args) train_texts, _, train_labels, _, _, _ = train_test_split(texts, labels, sample_weights, test_size=args.validation_split, random_state=42, stratify=labels) training_set = MyDataset(train_texts, train_labels, args) training_generator = DataLoader(training_set, **training_params) model = CharacterLevelCNN(args, number_of_classes) if torch.cuda.is_available(): model.cuda() model.train() criterion = nn.CrossEntropyLoss() if args.optimizer == 'sgd': optimizer = torch.optim.SGD( model.parameters(), lr=args.start_lr, momentum=0.9 ) elif args.optimizer == 'adam': optimizer = torch.optim.Adam( model.parameters(), lr=args.start_lr ) start_lr = args.start_lr end_lr = args.end_lr lr_find_epochs = args.epochs smoothing = args.smoothing def lr_lambda(x): return math.exp( x * math.log(end_lr / start_lr) / (lr_find_epochs * len(training_generator))) scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda) losses = [] learning_rates = [] for epoch in range(lr_find_epochs): print(f'[epoch {epoch + 1} / {lr_find_epochs}]') progress_bar = tqdm(enumerate(training_generator), total=len(training_generator)) for iter, batch in progress_bar: features, labels = batch if torch.cuda.is_available(): features = features.cuda() labels = labels.cuda() optimizer.zero_grad() predictions = model(features) loss = criterion(predictions, labels) loss.backward() optimizer.step() scheduler.step() lr = optimizer.state_dict()["param_groups"][0]["lr"] learning_rates.append(lr) if iter == 0: losses.append(loss.item()) else: loss = smoothing * loss.item() + (1 - smoothing) * losses[-1] losses.append(loss) plt.semilogx(learning_rates, losses) plt.savefig('./plots/losses_vs_lr.png')
from src.data_loader import load_data from src.model2 import Network from tqdm import tqdm import random def random_combination(iterable, r): "Random selection from itertools.combinations(iterable, r)" pool = tuple(iterable) n = len(pool) indices = sorted(random.sample(range(n), r)) return tuple(pool[i] for i in indices) if __name__ == '__main__': num_works, num_shifts, min_num_shifts, shifts = load_data(filename='r1') n = Network(num_works, num_shifts, shifts) n.create_init_solution(use_heuristic=True) it = 0 clusters_id = [i for i in range(len(n.clusters))] while True: # for i in range(1): # random_order = random_combination(clusters_id, len(clusters_id)) # for i in random_order: # n.repair(updated_cluster_id=i) # n.clusters[i].repair() for i in range(len(n.clusters)): # n.repair(updated_cluster_id=i)
random.seed(params.seed) torch.manual_seed(params.seed) torch.cuda.manual_seed_all(params.seed) # split data train_index = params.n_train valid_index = params.n_train + params.n_valid test_index = params.n_train + params.n_valid + params.n_test indices_all_imgs = np.arange(test_index) train_indices = indices_all_imgs[:train_index] valid_indices = indices_all_imgs[train_index:valid_index] test_indices = indices_all_imgs[valid_index:test_index] attrs_dir = 'D:/Projects/dataset/CelebA/data_imgs_attrs_64_64_clip/attrs_all.csv' resized_imgs_dir = 'D:/Projects/dataset/CelebA/data_imgs_attrs_64_64_clip/imgs/' train_loader, valid_loader, test_loader = load_data( attrs_dir, resized_imgs_dir, params.batch_size, train_indices, valid_indices, test_indices, use_cuda) # build the model cgan = cGAN(params, device) encoder_z = EncoderZ(params.input_channel_dis, params.dim_z) encoder_y = EncoderY(params.input_channel_dis, params.class_num) cgan.apply(weights_init) encoder_z.apply(weights_init) encoder_y.apply(weights_init) cgan = cgan.to(device) encoder_z = encoder_z.to(device) encoder_y = encoder_y.to(device) # define optimizers optim_gen = optim.Adam(cgan.Gen.parameters(),
parser.add_argument('--n_epoch', type=int, default=10, help='the number of epochs') parser.add_argument('--n_memory', type=int, default=32, help='size of ripple set for each hop') parser.add_argument('--item_update_mode', type=str, default='plus_transform', help='how to update item at the end of each hop') parser.add_argument('--using_all_hops', type=bool, default=True, help='whether using outputs of all hops or just the last hop when making prediction') ''' # default settings for Book-Crossing parser = argparse.ArgumentParser() parser.add_argument('--dataset', type=str, default='book', help='which dataset to use') parser.add_argument('--dim', type=int, default=4, help='dimension of entity and relation embeddings') parser.add_argument('--n_hop', type=int, default=2, help='maximum hops') parser.add_argument('--kge_weight', type=float, default=1e-2, help='weight of the KGE term') parser.add_argument('--l2_weight', type=float, default=1e-5, help='weight of the l2 regularization term') parser.add_argument('--lr', type=float, default=1e-3, help='learning rate') parser.add_argument('--batch_size', type=int, default=1024, help='batch size') parser.add_argument('--n_epoch', type=int, default=10, help='the number of epochs') parser.add_argument('--n_memory', type=int, default=32, help='size of ripple set for each hop') parser.add_argument('--item_update_mode', type=str, default='plus_transform', help='how to update item at the end of each hop') parser.add_argument('--using_all_hops', type=bool, default=True, help='whether using outputs of all hops or just the last hop when making prediction') ''' args = parser.parse_args() show_loss = False data_info = load_data(args) train(args, data_info, show_loss)