def set_dataset(self, path_dataset, num_examples_train, num_examples_test, N_train, N_test): self.gen = Generator(path_dataset, args.path_tsp) self.gen.num_examples_train = num_examples_train self.gen.num_examples_test = num_examples_test self.gen.N_train = N_train self.gen.N_test = N_test self.gen.load_dataset()
def create_gen(path_dataset, num_examples_test, num): gen = Generator(path_dataset, args.path_tsp) gen.num_examples_train = 1 gen.num_examples_test = num_examples_test gen.N_train = 10 gen.N_test = num gen.load_dataset() return gen
def setup(): logger = Logger(args.path_logger) logger.write_settings(args) config = make_config(args) model = base_model.BaseModel(config) siamese_gnn = siamese.Siamese(model).to(device) gen = Generator() gen.set_args(vars(args)) if not args.real_world_dataset: gen.load_dataset() return siamese_gnn, logger, gen
def make_cv_predictions(model_id, config, dataset_dir, eval_protocol, n_folds=5): function = getattr(data_generator, config['preprocess_fn']) preprocess_fn = partial(function, **config['preprocess']) generator = Generator(path=dataset_dir, IDs=eval_protocol.path.tolist(), preprocessing_fn=preprocess_fn, shuffle=False, batch_size=128, **config['generator']) preds = [] for i in range(n_folds): model = load_model(os.path.join( MODELS_PATH, 'model_{}_{}.h5'.format(model_id, i))) preds.append(model.predict_generator( generator, use_multiprocessing=True, workers=6, verbose=0)) return np.array(preds).mean(axis=0)
def run(model_id): """Run experiment.""" config = configs[model_id] logger.info('\n\n\ntrain model {}'.format(model_id)) # prepare data if config['preprocess_fn'] is not None: function = getattr(data_generator, config['preprocess_fn']) preprocess_fn = partial(function, **config['preprocess']) else: preprocess_fn = None generator = Generator(path=PATH_TRAIN, IDs=meta_train.index.tolist(), labels=meta_train[['target']], preprocessing_fn=preprocess_fn, shuffle=False, batch_size=64, **config['generator']) X, y = generate_train_data(generator, meta_train) logger.info('X shape: {}, y shape: {}'.format(X.shape, y.shape)) # define model model_function = getattr(models, config['model_name']) nn_model = partial(model_function, input_shape=(X.shape[1:]), **config['model_params']) nn_model().summary(print_fn=logger.info) model = KerasModel(nn_model, logger=logger, **config['train']) # train and save model cross_val = CrossValidation(X=X, y=y, Xtest=X[:100], logger=logger, **config['cv']) pred, pred_test, metrics, trained_models = cross_val.run_cv(model) for i, model in enumerate(trained_models): path = os.path.join(MODELS_PATH, 'model_{}_{}.h5'.format(model_id, i)) model.save(path)
def train(args): if os.path.exists(args.out_model_dir): shutil.rmtree(args.out_model_dir) create_folder(args.out_model_dir) num_classes = cfg.num_classes # Load training & testing data (tr_x, tr_y, tr_na_list) = load_hdf5(args.tr_hdf5_path, verbose=1) (te_x, te_y, te_na_list) = load_hdf5(args.te_hdf5_path, verbose=1) print("") # Scale data tr_x = do_scale(tr_x, args.scaler_path, verbose=1) te_x = do_scale(te_x, args.scaler_path, verbose=1) # Build model (_, n_time, n_freq) = tr_x.shape #pdb.set_trace() input = Input(shape=(n_time, n_freq), name='input_layer') input_ = Reshape((n_time, n_freq, 1))(input) ''' block1 = Conv_BN(input_, 8, (3, 3), act="relu") block1 = Conv_BN(block1, 32, (3, 3), act="relu") block1 = Conv_BN(block1, 64, (3, 3), act="relu") block1 = block_a(input_, 8) block1 = block_a(block1, 32) block1 = block_a(block1, 64) ''' block1 = block_b(input_, 8) block1 = block_b(block1, 32) block1 = block_b(block1, 64) block1 = MaxPooling2D(pool_size=(1, 2))(block1) block2 = block_c(block1, 64) block2 = MaxPooling2D(pool_size=(1, 2))(block2) block3 = block_c(block2, 64) block3 = MaxPooling2D(pool_size=(1, 2))(block3) block4 = block_c(block3, 64) block4 = MaxPooling2D(pool_size=(1, 2))(block4) cnnout = Conv_BN(block4, 128, (1, 1), act="relu", bias=True) cnnout = MaxPooling2D(pool_size=(1, 2))(cnnout) cnnout = Reshape((240, 256))(cnnout) rnn = Bidirectional( GRU(128, activation='relu', return_sequences=True, kernel_regularizer=regularizers.l2(0.01), recurrent_regularizer=regularizers.l2(0.01)))(cnnout) out = TimeDistributed(Dense( num_classes, activation='softmax', kernel_regularizer=regularizers.l2(0.0), ), name='output_layer')(rnn) model = Model(input, out) model.summary() # Compile model adam = optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, decay=0.009) sgd = optimizers.SGD(lr=0.01, momentum=0.9, decay=0.0) model.compile(loss=focal_loss(alpha=[1, 1, 1, 1], gamma=1), optimizer="adam", metrics=[myacc(threshold=0.5)]) # Save model callback filepath = os.path.join( args.out_model_dir, "aed-batchsize_50-lr_0.01-{epoch:04d}-{val_Acc:.4f}.hdf5") save_model = ModelCheckpoint(filepath=filepath, monitor='val_Acc', verbose=0, save_best_only=False, save_weights_only=False, mode='auto', period=1) # Train ''' history=model.fit( x=tr_x, y=tr_y, batch_size=50, epochs=200, verbose=1, shuffle=True, class_weight="auto", callbacks=[save_model], validation_data=(te_x,te_y) ) ''' # Data generator gen = Generator(batch_size=50, type='train') history = model.fit_generator( generator=gen.generate([tr_x], [tr_y]), steps_per_epoch=300, # 100 iters is called an 'epoch' epochs=100, # Maximum 'epoch' to train verbose=1, class_weight="auto", callbacks=[save_model], validation_data=(te_x, te_y)) with open('src/log.py', 'w') as f: f.write("history=") f.write(str(history.history))
if model_type == '512': img_height, img_width = 512, 512 prior_box_configs = prior_box_configs_512 variances = [0.1, 0.1, 0.2, 0.2] prior_boxes = get_prior_boxes(img_width, img_height, prior_box_configs, variances) #pickle.dump(prior_boxes, open('default_prior_boxes_{}x{}.pkl'.format(img_height, img_width), 'wb')) bbox_util = BBoxUtility(num_classes, prior_boxes, use_tf=True) data = pickle.load(open(data_file, 'rb')) keys = data.keys() num_train = int(round(0.8 * len(keys))) train_keys, val_keys = keys[:num_train], keys[num_train:] data_gen = Generator(data, bbox_util, 1, path_prefix, train_keys, val_keys, (img_height, img_width)) model = SSD300((img_height, img_width, 3), num_classes=num_classes) if model_type == '512': model = SSD512((img_height, img_width, 3), num_classes=num_classes) model.compile(optimizer=Adam(lr=3e-4), loss=MultiboxLoss(num_classes, neg_pos_ratio=3.0).compute_loss) model.summary() nb_epochs = 120 callbacks = [ ModelCheckpoint('checkpoints/weights.{epoch:02d}-{val_loss:.2f}.hdf5', save_weights_only=True), ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=5, verbose=1) ] history = model.fit_generator(data_gen.generate(True),
loss_single, acc_single = test_single(gnn, gen, n_classes, it) loss_lst[it] = loss_single acc_lst[it] = acc_single torch.cuda.empty_cache() print('Avg test loss', np.mean(loss_lst)) print('Avg test acc', np.mean(acc_lst)) print('Std test acc', np.std(acc_lst)) def count_parameters(model): return sum(p.numel() for p in model.parameters() if p.requires_grad) if __name__ == '__main__': gen = Generator() gen.N_train = args.N_train gen.N_test = args.N_test gen.edge_density = args.edge_density gen.p_SBM = args.p_SBM gen.q_SBM = args.q_SBM gen.random_noise = args.random_noise gen.noise = args.noise gen.noise_model = args.noise_model gen.generative_model = args.generative_model gen.n_classes = args.n_classes torch.backends.cudnn.enabled = False if (args.mode == 'test'): print('In testing mode')
def __init__(self, batch = 64, Class = 2, box_num = [5,4,4,4,4,4], lr = 0.001, load_pretrain = False, model = 1, aug = False, lr_updata = False, uda = False ): if model == 1: self.model = Model(Class = Class, box_num = box_num) self.m = 1 elif model == 2: self.model = Inception(5) self.m = 2 self.batch = batch self.Class = Class self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') if torch.cuda.device_count() > 1: print('Lets use', torch.cuda.device_count(), 'GPUs!') self.model = nn.DataParallel(self.model) self.uda = uda self.UDA_model = UDA().to(self.device) self.UDA_img = self.get_test_img() self.model = self.model.to(self.device) self.load_pretrain = load_pretrain self.optimizer = Adam(self.model.parameters(), lr = lr, weight_decay = 0.0005) self.optimizer1 = Adam(self.UDA_model.parameters(), lr = lr, weight_decay = 0.0005) self.lambda1 = lambda epoch : 0.95**epoch self.lambda2 = lambda epoch : 0.99**epoch self.scheduler = lr_scheduler.LambdaLR(self.optimizer, lr_lambda = self.lambda1) self.scheduler1 = lr_scheduler.LambdaLR(self.optimizer1, lr_lambda = self.lambda2) if self.load_pretrain == True: if lr_updata==True: load_model(self.model, m=self.m) else: load_model(self.model, self.optimizer, self.scheduler, self.m) self.train_loss = ['train_loss'] self.train_acc = ['train_acc'] self.verify_loss = ['verify_loss'] self.verify_acc = ['verify_acc'] self.lr = ['learning rate'] data = pd.read_csv('./train_data'+str(self.m)+'.csv') self.train_loss.extend(data['train_loss'].tolist()) self.train_acc.extend(data['train_acc'].tolist()) self.verify_loss.extend(data['verify_loss'].tolist()) self.verify_acc.extend(data['verify_acc'].tolist()) self.lr.extend(data['learning rate'].tolist()) else: self.train_loss = ['train_loss'] self.train_acc = ['train_acc'] self.verify_loss = ['verify_loss'] self.verify_acc = ['verify_acc'] self.lr = ['learning rate'] for i in self.model.parameters(): if len(i.shape)>=2: xavier_normal_(i) self.train_generator = Generator(batch = batch, mode = 'train',aug=aug) self.train_generator2 = Generator(batch = batch, mode = 'val',aug=aug) self.test_generator = Generator(batch = batch, mode = 'val')
if __name__ == '__main__': logger = Logger(args.path) logger.write_settings(args) DCN = DivideAndConquerNetwork(input_size, args.batch_size, args.num_units_merge, args.rnn_layers, args.grad_clip_merge, args.num_units_split, args.split_layers, args.grad_clip_split, beta=args.beta) if args.load_split is not None: DCN.load_split(args.load_split) if args.load_merge is not None: DCN.load_merge(args.load_merge) if torch.cuda.is_available(): DCN.cuda() gen = Generator(args.num_examples_train, args.num_examples_test, args.path_dataset, args.batch_size) gen.load_dataset() DCN.batch_size = args.batch_size DCN.merge.batch_size = args.batch_size DCN.split.batch_size = args.batch_size if args.mode == 'train': train(DCN, logger, gen) elif args.mode == 'test': test(DCN, gen)
plt.plot(iters, self.cost_test, 'b') print('COST ORACLE', self.cost_test_oracle[-1]) plt.plot(iters, self.cost_test_oracle, 'r') plt.xlabel('iterations') plt.ylabel('Mean cost') plt.title('Mean cost Testing with beam_size : {}'.format(beam_size)) plt.tight_layout(pad=0.8, w_pad=0.5, h_pad=2.0) path = os.path.join(self.path_dir, 'testing.png') plt.savefig(path) if __name__ == '__main__': path_dataset = '/data/anowak/TSP/' path_logger = '/home/anowak/tmp/TSP1/' path_tsp = '/home/anowak/QAP_pt/src/tsp/LKH/' gen = Generator(path_dataset, path_tsp, mode='CEIL_2D') gen.num_examples_train = 200 gen.num_examples_test = 40 gen.J = 4 gen.load_dataset() sample = gen.sample_batch(2, cuda=torch.cuda.is_available()) W = sample[0][0][:, :, :, 1] # weighted adjacency matrix WTSP = sample[1][0] # hamiltonian cycle adjacency matrix pred = sample[1][0] perm = sample[1][1] optimal_costs = sample[2] ########################## test compute accuracy ########################## labels = torch.topk(WTSP, 2, dim=2)[1] accuracy = utils.compute_accuracy(WTSP, labels) print('accuracy', accuracy) ########################## test compute_hamcycle ##########################
def main(): args = read_args_commandline() logger = Logger(args.path_logger) logger.write_settings(args) gen = Generator(args) torch.backends.cudnn.enabled = False if (args.mode == 'test'): print('In testing mode') # filename = 'gnn_J' + str(args.J) + '_lyr' + str(args.num_layers) + '_Ntr' + str(gen.N_test) + '_it' + str(args.iterations) filename = args.filename_existing_gnn path_plus_name = os.path.join(args.path_gnn, filename) if ((filename != '') and (os.path.exists(path_plus_name))): print('Loading gnn ' + filename) gnn = torch.load(path_plus_name) if torch.cuda.is_available(): gnn.cuda() acc, z, inb, label = test(gnn, logger, gen, args, iters=None) res = {'acc': acc, 'nacc': z, 'inb': inb, 'label': label} path_plus_name = os.path.join(args.path_output, args.filename_test_segm) print('Saving acc, nacc, inb...' + args.filename_test_segm) with open(path_plus_name, 'wb') as f: pickle.dump(res, f, pickle.HIGHEST_PROTOCOL) else: print('No such a gnn exists; please first create one') elif (args.mode == 'train'): print('Creating the gnn ...') if args.loss_method == 'policy': filename = 'lgnn_' + str(args.problem) + str( args.problem0) + '_plc' + str(args.num_ysampling) + '_N' + str( args.num_nodes) + '_p' + str( args.edge_density) + '_J' + str(args.J) + '_lyr' + str( args.num_layers) + '_ftr' + str( args.num_features) + '_Lbd' + str( args.Lambda) + '_LbdR' + str( args.LambdaIncRate) + '_lr' + str( args.lr) else: filename = 'lgnn_' + str(args.problem) + str( args.problem0) + '_N' + str(args.num_nodes) + '_p' + str( args.edge_density) + '_J' + str(args.J) + '_lyr' + str( args.num_layers) + '_ftr' + str( args.num_features) + '_Lbd' + str( args.Lambda) + '_LbdR' + str( args.LambdaIncRate) + '_lr' + str(args.lr) path_plus_name = os.path.join(args.path_gnn, filename) gnn = lGNN_multiclass(args.num_features, args.num_layers, args.J + 2, args.num_classes) if torch.cuda.is_available(): gnn.cuda() print('Training begins') train(gnn, logger, gen, args, iters=None) print('Saving gnn ' + filename) if torch.cuda.is_available(): torch.save(gnn.cpu(), path_plus_name) gnn.cuda() else: torch.save(gnn, path_plus_name)
model1 = model1.eval() model2 = model2.eval() model3 = model3.eval() true_labels = ['true_label'] pre_labels1 = ['AlexNet pre_label'] pre_labels2 = ['InceptionV4 pre_label'] pre_labels3 = ['YOLOV3 pre_label'] pre_labels4 = ['Sum pre_label'] acc1 = 0.0 acc2 = 0.0 acc3 = 0.0 acc4 = 0.0 with torch.no_grad(): for i in range(30): a = Generator(32, mode='test') images, labels = next(a) images = images.to('cpu') labels = labels.to('cpu') logits1 = model1(images) logits2 = model2(images) logits3 = model3(images) logits4 = (logits1 + logits2 + logits3) / 3. acc1 += accuracy(logits1, labels) acc2 += accuracy(logits2, labels) acc3 += accuracy(logits3, labels) acc4 += accuracy(logits4, labels) for t in labels: true_labels.append(lab[int(t)]) for p1 in logits1.argmax(1): pre_labels1.append(lab[int(p1)])
""" Regression problem conversion between Celcius to Farenheight :complete: """ import tensorflow as tf import numpy as np import sklearn.metrics from data_generator import Generator n = 100 tempGen = Generator(n) tempCelc, tempFaren = tempGen.getData() features = np.array(tempCelc) labels = np.array(tempFaren) # check examples assert features.shape == labels.shape == (n, ) # parameters to adjust learning_rate = 1 dense_layer = tf.keras.layers.Dense(units=1, input_shape=[1], activation='relu') # build model, single dense layer model = tf.keras.Sequential([ dense_layer,
for i in range(1, word_target.shape[1]): y_pred, hidden = model(word_one_hot, hidden, images) word_one_hot = word_target[:, i, :] loss += loss_function(word_target[:, i, :], y_pred) batch_loss = loss / int(word_target.shape[1]) variables = model.trainable_variables gradients = tape.gradient(loss, variables) optimizer.apply_gradients(zip(gradients, variables)) return batch_loss if __name__ == '__main__': generator_training = Generator(folder_image='train', folder_label='train.txt') # generator_valid = Generator(folder_image='train', # folder_label='train.txt') # if args['finetune']: # model.load_weights('model.h5') print('data train: ', len(generator_training.examples)) # print(len(generator_valid.examples)) step_per_epoch_training = len(generator_training.examples) // BATCH_SIZE for epoch in range(EPOCHS): start = time.time() total_loss = 0
clusters = args.clusters clip_grad_norm = args.clip_grad_norm batch_size = args.batch_size num_features = args.num_features num_layers = args.num_layers sigma2 = args.sigma2 reg_factor = args.reg_factor K = args.K k_step = args.k_step n_samples = args.n_samples normalize = args.normalize last = args.last baseline = args.baseline if args.dataset == 'GM': gen = Generator('/data/anowak/dataset/', num_examples_train, num_examples_test, N, clusters, dim) elif args.dataset == "CIFAR": gen = GeneratorCIFAR('/data/anowak/dataset/', num_examples_train, num_examples_test, N, clusters, dim) dim = 27 gen.load_dataset() num_iterations = 100000 if not baseline: gnn = Split_GNN(num_features, num_layers, 5, dim_input=dim) else: gnn = Split_BaselineGNN(num_features, num_layers, 5, K, dim_input=dim) if args.load_file != '': gnn = load_model(args.load_file, gnn) optimizer = optim.RMSprop(gnn.parameters(), lr=1e-3) # optimizer = optim.Adam(gnn.parameters())
args.noise, args.generative_model, elapsed] print(template1.format(*info)) print(template2.format(*out)) # test(siamese_gnn, logger, gen) if it % logger.args['save_freq'] == 0: logger.save_model(siamese_gnn) logger.save_results() print('Optimization finished.') if __name__ == '__main__': logger = Logger(args.path_logger) logger.write_settings(args) siamese_gnn = Siamese_GNN(args.num_features, args.num_layers, args.J + 2) if torch.cuda.is_available(): siamese_gnn.cuda() gen = Generator(args.path_dataset) # generator setup gen.num_examples_train = args.num_examples_train gen.num_examples_test = args.num_examples_test gen.J = args.J gen.edge_density = args.edge_density gen.random_noise = args.random_noise gen.noise = args.noise gen.noise_model = args.noise_model gen.generative_model = args.generative_model # load dataset # print(gen.random_noise) gen.load_dataset() if args.mode == 'train': train(siamese_gnn, logger, gen) # elif args.mode == 'test':
or not param[2].isdigit() or not param[3].isdigit(): print("Usage:\n" "\tprocess number\n" "\torder number\n " "\torder per second\n" "example: \./data_sender.py 3 200 20") exit() sender_num = int(param[1]) order_num = int(param[2]) ops = int(param[3]) # requests.post(URL, json={"user":"******"}, headers={'Connection':'close'}) # sender_num = 1 # order_num = 20 # ops = 10 # s = '{"user_id": 1,"initiator": "EUR","time": 1562416385042,"items": [{"id": "2","number": 1},{"id": "2","number": 1},{"id": "2","number": 1},{"id": "3","number": 3}]}' # json_obj = json.loads(s) # ret = requests.post(URL, json=json_obj,\ # headers={'Connection':'close'}) # print(ret) # print(ret.content) # generate test data files filenames = ["test-" + str(i) + ".data" for i in range(sender_num)] for i in filenames: Generator.generate_to_file(order_num, i) s = Sender(filenames, sender_num, ops) ret = s.run() print(ret)
if not last and it % 100 == 0: loss = loss.data.cpu().numpy()[0] out = [ '---', it, loss, logger.accuracy_test_aux[-1], logger.cost_test_aux[-1], args.beam_size, elapsed ] print(template_test1.format(*info_test)) print(template_test2.format(*out)) print('TEST COST: {} | TEST ACCURACY {}\n'.format( logger.cost_test[-1], logger.accuracy_test[-1])) if __name__ == '__main__': logger = Logger(args.path_logger) logger.write_settings(args) gen = Generator(args.path_dataset, args.path_tsp) # generator setup gen.num_examples_train = args.num_examples_train gen.num_examples_test = args.num_examples_test gen.J = args.J gen.N = args.N gen.dual = args.dual # load dataset gen.load_dataset() # initialize model siamese_gnn = Siamese_GNN(args.num_features, args.num_layers, gen.N, args.J + 2, dim_input=3, dual=args.dual)
clip_grad_norm = 40.0 batch_size = 500 num_features = 32 num_layers = 5 n_samples = 20 scales = args.splits + 1 if N >= 200: num_examples_test = 100 batch_size = 100 test = args.test gen = Generator(args.dataset_path, args.solver_path, num_examples_train, num_examples_test, N, C_min, C_max, test=test) gen.load_dataset() num_iterations = 100000 Knap = Split_GNN(num_features, num_layers, 3, dim_input=3) if args.load_file_path != '': Knap = load_model(args.load_file_path, Knap) optimizer = optim.Adamax(Knap.parameters(), lr=1e-3) log = Logger() log2 = Logger() path_train_plot = os.path.join(args.logs_path, 'training.png')
def __init__(self, batch=16, lr=0.01, load_pretrain=False, model=1, aug=False, mixup=False): if model == 1: ''' AlexNet+DSC 5层卷积全变为深度可分离卷积层 ''' self.model = Net1() self.m = 1 elif model == 2: self.model = Inception_FPN(5) self.m = 2 elif model == 3: self.m = 3 self.model = Classifier() self.device = torch.device( 'cuda' if torch.cuda.is_available() else 'cpu') if torch.cuda.device_count() > 1: print('Lets use', torch.cuda.device_count(), 'GPUs!') self.model = nn.DataParallel(self.model) self.model = self.model.to(self.device) self.load_pretrain = load_pretrain self.optimizer = Adam(self.model.parameters(), lr=lr, weight_decay=0.001) self.lambda1 = lambda epoch: 0.95**(epoch - 20) self.lambda2 = lambda epoch: epoch / 20 self.scheduler = lr_scheduler.LambdaLR(self.optimizer, lr_lambda=self.lambda2) if self.load_pretrain == True: load_model(self.model, self.optimizer, self.scheduler, self.m) self.train_loss = ['train_loss'] self.train_acc = ['train_acc'] self.verify_loss = ['verify_loss'] self.verify_acc = ['verify_acc'] self.lr = ['learning rate'] data = pd.read_csv('./train_data' + str(self.m) + '.csv') self.train_loss.extend(data['train_loss'].tolist()) self.train_acc.extend(data['train_acc'].tolist()) self.verify_loss.extend(data['verify_loss'].tolist()) self.verify_acc.extend(data['verify_acc'].tolist()) self.lr.extend(data['learning rate'].tolist()) else: self.train_loss = ['train_loss'] self.train_acc = ['train_acc'] self.verify_loss = ['verify_loss'] self.verify_acc = ['verify_acc'] self.lr = ['learning rate'] for i in self.model.parameters(): if len(i.shape) >= 2: xavier_normal_(i) if self.m == 3: for i in self.model.named_modules(): if isinstance(i[1], CBLR): constant_(i[1].BatchNorm2d.weight, 0) self.mixup = mixup self.train_generator = Generator(batch=batch, mode='train', aug=aug) self.test_generator = Generator(batch=batch, mode='verify')
clusters = args.clusters clip_grad_norm = args.clip_grad_norm batch_size = args.batch_size num_features = args.num_features num_layers = args.num_layers sigma2 = args.sigma2 reg_factor = args.reg_factor K = args.K k_step = args.k_step n_samples = args.n_samples normalize = args.normalize last = args.last baseline = args.baseline if args.dataset == 'GM': gen = Generator('./data/kmeans/', num_examples_train, num_examples_test, N, clusters, dim) elif args.dataset == "CIFAR": gen = GeneratorCIFAR('./data/kmeans/', num_examples_train, num_examples_test, N, clusters, dim) dim = 27 gen.load_dataset() num_iterations = 100000 if not baseline: gnn = Split_GNN(num_features, num_layers, 5, dim_input=dim) else: gnn = Split_BaselineGNN(num_features, num_layers, 5, K, dim_input=dim) if args.load_file != '': gnn = load_model(args.load_file, gnn) optimizer = optim.RMSprop(gnn.parameters(), lr=1e-3) # optimizer = optim.Adam(gnn.parameters())
accuracy = 1 - frob_norm accuracy = accuracy.mean(0).squeeze() return accuracy.data.cpu().numpy()[0] def compute_variance(probs): N = probs.size(1) mean = probs.sum(1) / N dif = probs - mean.unsqueeze(1).expand_as(probs) variance = ((dif * dif).sum(1).sum(0)) / (N * probs.size(0)) return variance if __name__ == '__main__': path_dataset = './dataset/broma/' gen = Generator(path_dataset, './LKH/') N = 20 gen.num_examples_train = 200 gen.num_examples_test = 10 gen.N = N gen.load_dataset() clip_grad = 40.0 iterations = 5000 batch_size = 20 num_features = 10 num_layers = 5 J = 4 rf = 10.0 # regularization factor Split = Split_GNN(batch_size, num_features, num_layers, J + 2, dim_input=3)