def run(self): print threading.current_thread() while True: if self.queue.qsize() < 100 and not self.queue.full(): if self.is_train: batch_x, batch_y = load_data(sex=sex, img_size=img_size, batch_size=batch_size, augment_times=7) if DEBUG_MODEL: print "%s ask lock" % threading.current_thread() train_lock.acquire() if DEBUG_MODEL: print "%s acquire" % threading.current_thread() self.queue.put({"x": batch_x, "y": batch_y}) train_lock.release() if DEBUG_MODEL: print "%s release" % threading.current_thread() else: batch_x, batch_y = load_data(sex=sex, img_size=img_size, batch_size=batch_size, augment_times=0) test_lock.acquire() self.queue.put({"x": batch_x, "y": batch_y}) test_lock.release()
def train(): path = '../dataset/usage_train.csv' df = load_data(path) df['weekofyear'] = df.ds.apply(lambda x: x.weekofyear) samples_week = 2 * 24 * 7 results_train = pd.DataFrame(data=None, index=df.id.unique(), columns=[50, 60, 70, 80, 90]) results_test = results_train.copy() final_models = {} final_errors = {'train': {}, 'test': {}} for house_id in df.id.unique(): df_house = df[df.id == house_id] print('*********************') print('INFO: {}'.format(house_id)) print('*********************') results_train, results_test = error_estimation_cross_validation( df_house, house_id, samples_week, results_train, results_test) model, error_train, error_test = fit_final_model( df_house, samples_week) final_models[house_id] = model final_errors['train'][house_id] = error_train final_errors['test'][house_id] = error_test pickle.dump(final_models, open('./model/models.pickle', 'wb')) pickle.dump(final_errors, open('./model/final_errors.pickle', 'wb')) results_train.to_csv('./results/performance_metrics_train.csv') results_test.to_csv('./results/performance_metrics_test.csv')
def predict(): path_data = '../dataset/usage_test.csv' path_model = './model/models.pickle' df = load_data(path_data) models = pickle.load(open(path_model, 'rb')) # do predictions predictions = pd.DataFrame(data=None) for house_id in df.id.unique(): print('*********************') print('INFO: {}'.format(house_id)) print('*********************') df_house = df[df.id == house_id] pred = predict_a_week_ahead(models[house_id], df_house) df_house = df_house.merge(pred[['ds', 'yhat']]) predictions = predictions.append(df_house) save_predictions(predictions)
epochs = 4 else: epochs = 4 """ 1、先构建网络,定义一些变量 2、构建损失函数 3、构建循环网络 4、筛选保留集样本 5、先实现残差网络 再实现增量学习 6、实现简单的残差网络 """ # Create neural network model print('Run {0} starting ...'.format(itera)) print("Building model and compiling functions...") image_train, label_train, image_test, label_test = utils_data.load_data( Cifar_train_file, Cifar_test_file) #next batch image_batch, label_batch_0, file_protoset_batch = utils_data.Prepare_train_data_batch( image_train, label_train, files_protoset, itera, order, nb_cl, batch_size) label_batch = tf.one_hot(label_batch_0, 100) #初次训练 if itera == 0: #不需要蒸馏 variables_graph, variables_graph2, scores, scores_stored = utils_cifar.prepareNetwork( gpu, image_batch, itera) with tf.device('/gpu:0'): scores = tf.concat(scores, 0) l2_reg = wght_decay * tf.reduce_sum( tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES, scope='ResNet34'))
features_extractor = utils_models.build_features_extractor( features_extractor_name, data_shape) for task_id, dataset in enumerate(datasets): if task_id == 0: open_mode = 'w' else: open_mode = 'a' utils.write_on_file(result_filename, open_mode, "[%s] Starting new task..." % dataset.upper()) '''X_train, y_train, X_valid, y_valid = utils_data.load_data(data_dir=data_dir, dataset=dataset, data_size=data_size, phase='train_valid', valid_split=valid_split, seed=seed)''' X_train, y_train, X_valid, y_valid, _, _ = utils_data.load_data( data_dir=data_dir, dataset=dataset, data_size=data_size, valid_split=valid_split, test_split=test_split, seed=seed) ############################################ TRAINING ############################################ utils.write_on_file( result_filename, 'a', "[%s] Starting autoencoder's cross-validation..." % dataset.upper()) autoencoder = utils.autoencoder_cross_validation( features_extractor, batch_size, X_train, X_valid, features_mean, features_std, autoencoder_hidden_layer_sizes, autoencoder_weight_decays, autoencoder_learning_rates, autoencoder_epsilons, autoencoder_epochs, autoencoder_objective_loss, dataset) trained_autoencoders.append(autoencoder)
parser.add_argument('--weight_decay_layer_one', type=float) parser.add_argument('--weight_decay_layer_two', type=float) parser.add_argument('--num_epochs_patience', type=int, default=100) parser.add_argument('--num_epochs_max', type=int, default=5000) parser.add_argument('--run_id', type=str) parser.add_argument('--dataset_split', type=str) parser.add_argument('--learning_rate_decay_patience', type=int, default=50) parser.add_argument('--learning_rate_decay_factor', type=float, default=0.8) args = parser.parse_args() vars(args)['model'] = 'GeomGCN_TwoLayers_ExperimentTwoAll' t1 = time.time() if args.dataset_split == 'jknet': g, features, labels, train_mask, val_mask, test_mask, num_features, num_labels = utils_data.load_data( args.dataset, None, 0.6, 0.2, 'ExperimentTwoAll') else: g, features, labels, train_mask, val_mask, test_mask, num_features, num_labels = utils_data.load_data( args.dataset, args.dataset_split, None, None, 'ExperimentTwoAll') print(time.time() - t1) g.set_n_initializer(dgl.init.zero_initializer) g.set_e_initializer(dgl.init.zero_initializer) net = GeomGCNNet(g=g, num_input_features=num_features, num_output_classes=num_labels, num_hidden=args.num_hidden, num_divisions=25, dropout_rate=args.dropout_rate, num_heads_layer_one=args.num_heads_layer_one,
# Working station train_path = 'F:/Dataset/ILSVRC2012/cifar-100-python/train' test_path = 'F:/Dataset/ILSVRC2012/cifar-100-python/test' save_path = './model/' ########################### str_settings_resnet = str(nb_cl) + 'settings_resnet.pickle' # with open(str_settings_resnet, 'rb') as fp: # order = cPickle.load(fp) # files_valid = cPickle.load(fp) # files_train = cPickle.load(fp) order = np.load('./order.npy', encoding='latin1') image_train, label_train, image_test, label_test = utils_data.load_data( train_path, test_path) for nb_cl in [2]: #, 5, 10, 20, 50]: # 不同类别数量/批次 nb_groups = int(100 / nb_cl) acc_list = np.zeros((nb_groups, 1)) for itera in range(nb_groups): # 增量学习的次数(迭代产生的模型数量) # next batch image_batch, label_batch_0, file_protoset_batch = utils_data.Prepare_test_data_batch( image_test, label_test, itera, order, nb_cl, batch_size) label_batch = tf.one_hot(label_batch_0, 100) # Initialization print("Processing network after {} increments\t".format(itera)) # Evaluation on cumul(累加) of classes or original classes if is_cumul == 'cumul':
def train(n_epoch=N_TRAINING_EPOCH, img_size=299, sex=0, batch_size=16, num_gpu=1, start_layer=-1, start_epoch=0): assert start_layer in [ -1, XCEPTION_EXIT_START, XCEPTION_MID_START, XCEPTION_ENTRY_START, 0 ] assert sex in [0, 1, 2] # model file path if start_layer != -1: model_file = model_out_dir + "/model.h5" else: model_file = None # learning rate if start_layer == -1: learning_rate = 1E-2 elif start_layer == XCEPTION_EXIT_START: learning_rate = 1E-3 elif start_layer == XCEPTION_MID_START: learning_rate = 5E-4 elif start_layer == XCEPTION_ENTRY_START: learning_rate = 1E-4 else: learning_rate = 5E-5 model = _build_regressor(img_size, num_gpu, start_layer, model_file, learning_rate) best_mae = np.inf tolerance = 0 data_ids = load_sex_ids(sex) for epoch in tqdm(range(start_epoch + 1, start_epoch + n_epoch + 1)): print "[x] epoch {} -------------------------------------------".format( epoch) for mini_batch in range(len(data_ids) // batch_size): batch_x, batch_y = load_data(sex=sex, img_size=img_size, batch_size=batch_size, augment_times=7) loss = model.train_on_batch(x=batch_x, y=batch_y) if mini_batch % 50 == 0: print "--epoch {}, mini_batch {}, loss {}".format( epoch, mini_batch, loss) # test print "[x] test in epoch {}".format(epoch) losses = 0.0 for mini_batch in range(int(0.2 * len(data_ids) // batch_size)): batch_x, batch_y = load_data(sex=sex, img_size=img_size, batch_size=batch_size, augment_times=0) loss = model.test_on_batch(batch_x, batch_y) losses += loss losses = losses / (int(0.3 * len(data_ids) // batch_size)) print "== epoch {}, test loss {}".format(epoch, losses) # test and metric print "[x] predict in epoch {}".format(epoch) y_true = [] y_pred = [] for mini_batch in range(int(0.2 * len(data_ids) // batch_size)): batch_x, batch_y = load_data(sex=sex, img_size=img_size, batch_size=batch_size, augment_times=0) pred_y = model.predict_on_batch(batch_x) for i in range(batch_size): y_true.append(batch_y[i] * SCALE) y_pred.append(pred_y[i] * SCALE) evs, mae, mse, meae, r2s, ccc = regression_metric( np.array(y_true), np.array(y_pred)) save_obj( { "evs": evs, "mae": mae, "mse": mse, "meae": meae, "r2s": r2s, "ccc": ccc, "loss": losses }, name=metric_out_dir + "/epoch_{}.pkl".format(epoch)) if mae < best_mae: best_mae = mae tolerance = 0 model.save_weights(model_out_dir + "/model.h5") else: tolerance += 1 print "[x] epoch {}, evs {}, mae {}, mse {}, meae {}, r2s {}, ccc {}".format( epoch, evs, mae, mse, meae, r2s, ccc) if tolerance > TOLERANCE: break
def gae_for(args): print("Using {} dataset".format(args.dataset_str)) # adj, features, y_test, tx, ty, test_maks, true_labels = load_data('cora') # print(true_labels) # adj, features, y_test, test_maks, true_labels=load_npz('amazon_electronics_photo') # print(true_labels) # adj=preprocess_high_order_adj( adj, 2, 0.01 ) # print(adj) # if args.dataset_split == 'jknet': g, features, true_labels, train_mask, val_mask, test_mask, num_features, num_labels = utils_data.load_data( args.dataset_str, None, 0.6, 0.2) adj = g.adj(scipy_fmt='coo') true_labels = true_labels.detach().numpy() # print(true_labels) # else: # g, features, labels, train_mask, val_mask, test_mask, num_features, num_labels = utils_data.load_data( # args.dataset_str, args.dataset_split) args.n_clusters = true_labels.max() + 1 print(args.n_clusters, "ssssssss") # Store original adjacency matrix (without diagonal entries) for later adj_orig = adj adj_orig = adj_orig - sp.dia_matrix( (adj_orig.diagonal()[np.newaxis, :], [0]), shape=adj_orig.shape) adj_orig.eliminate_zeros() adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false = mask_test_edges( adj) # adj = adj_train # Some preprocessing adj_norm = preprocess_graph(adj) # adj_norm = torch.sparse.FloatTensor(sp.coo_matrix(adj)) # adj_norm=torch.tensor(adj.todense(),dtype=torch.float) # print(adj_norm) adj_label = adj_train + sp.eye(adj_train.shape[0]) # adj_label = sparse_to_tuple(adj_label) adj_label = torch.FloatTensor(adj_label.toarray()) pos_weight = float(adj.shape[0] * adj.shape[0] - adj.sum()) / adj.sum() norm = adj.shape[0] * adj.shape[0] / float( (adj.shape[0] * adj.shape[0] - adj.sum()) * 2) z_x = torch.zeros(features.shape[0], args.hidden1) z_w = torch.zeros(features.shape[0], args.hidden2) z_shuffle = torch.cat((features, z_x, z_w), axis=1) n_nodes, feat_dim = z_shuffle.shape model = GCNModelVAE(feat_dim, args.hidden1, args.hidden2, args.dropout, args.n_clusters) optimizer = optim.Adam(model.parameters(), lr=args.lr) z_x, mu_x, _, z_w, mu_w, _, _, logvar_px, qz = model(z_shuffle, adj_norm) z_shuffle = torch.cat((features, z_x.detach_(), z_w.detach_()), axis=1) hidden_emb = None for epoch in tqdm(range(args.epochs)): t = time.time() model.train() optimizer.zero_grad() # z_shuffle=torch.cat((features,z_x.detach_(),z_w.detach_()),axis=1) z_x, mu_x, logvar_x, z_w, mu_w, logvar_w, mu_px, logvar_px, qz = model( z_shuffle, adj_norm) # print(z_x.shape,"z_x.shape") # After back-propagating gae loss, now do the deepWalk regularization # mu_x = mu_x.unsqueeze(-1) # mu_x = mu_x.expand(-1, args.hidden2) logvar_x1 = logvar_x.unsqueeze(-1) logvar_x1 = logvar_x1.expand(-1, args.hidden2, args.n_clusters) mu_x1 = mu_x.unsqueeze(-1) mu_x1 = mu_x1.expand(-1, args.hidden2, args.n_clusters) if torch.cuda.is_available(): mu_x1 = mu_x1.cuda() logvar_x1 = logvar_x1.cuda() # KLD_W = -0.5 / n_nodes* torch.sum(1 + logvar_w - mu_w.pow(2) - logvar_w.exp()) # KLD_Z = -torch.sum(qz * torch.log(qz + 1e-10))/n_nodes KLD_Z = -0.5 / n_nodes * torch.mean( torch.sum(1 + qz * torch.log(qz + 1e-10), 1)) # print(KLD_Z,"klz") # qz = qz.unsqueeze(-1) # qz = qz.expand(-1, 1) # print(logvar_px.shape,logvar_x1.shape,"hhhhi") # KLD_QX_PX = 0.5 / n_nodes* (((logvar_px - logvar_x) + ((logvar_x.exp() + (mu_x - mu_px).pow(2))/logvar_px.exp())) - 1) # # print(KLD_QX_PX.shape,qz.shape,"hhhhi") # KLD_QX_PX = KLD_QX_PX.unsqueeze(1) # qz = qz.unsqueeze(-1) # print(KLD_QX_PX.shape,qz.shape,"hhhhi") # KLD_QX_PX = KLD_QX_PX.expand(2708, 1, args.hidden2) KLD_QX_PX = loss_function(preds=model.dc(z_x), labels=adj_label, mu=(mu_x1 - mu_px), logvar=(logvar_px - logvar_x1), n_nodes=n_nodes, norm=norm, pos_weight=pos_weight) KLD_QX_PX = KLD_QX_PX = KLD_QX_PX.expand(n_nodes, 1, args.hidden2) E_KLD_QX_PX = torch.sum( torch.bmm(KLD_QX_PX, qz.unsqueeze(-1) / n_nodes)) # print(E_KLD_QX_PX) # print(model.dc(z_x).shape,adj_label.shape,"hdhhhhhhd") model.train() optimizer.zero_grad() lbl_1 = torch.ones(n_nodes) lbl_2 = torch.zeros(n_nodes) lbl = torch.cat((lbl_1, lbl_2)) idx = np.random.permutation(n_nodes) # print(features.shape,z_x.shape,adj_norm.shape) shuf_fts = z_shuffle[idx, :] # FeatHL=torch.cat((features,shuf_fts),axis=1) # _, featHL_dim = FeatHL.shape # modelHL = GCNModelVAE(featHL_dim, args.hidden1, args.hidden2, args.dropout,2) n_nodes1, feat_dim1 = z_shuffle.shape # model1 = GCNModelVAE(feat_dim1, args.hidden1, args.hidden2, args.dropout,args.n_clusters) # z_xL1, mu_xL1, logvar_xL1,z_wL1, mu_wL1, logvar_wL1,mu_pxL1, logvar_pxL1,_ = model1(z_shuffle, adj_norm) z_xL2, mu_xL2, logvar_xL2, z_wL2, mu_wL2, logvar_wL2, mu_pxL2, logvar_pxL2, qz2 = model( shuf_fts, adj_norm) KLD_Z2 = 0.5 / n_nodes * torch.mean( torch.sum(1 + qz2 * torch.log(qz2 + 1e-10), 1)) KLD_QX_PX2 = loss_function(preds=model.dc(z_wL2), labels=adj_label, mu=mu_wL2, logvar=logvar_wL2, n_nodes=n_nodes, norm=norm, pos_weight=pos_weight) KLD_QX_PX2 = KLD_QX_PX2.expand(n_nodes, 1, args.hidden2) E_KLD_QX_PX2 = torch.sum( torch.bmm(KLD_QX_PX2, qz2.unsqueeze(-1) / n_nodes)) lossF = (1.0/loss_function(preds=model.dc(z_xL2), labels=adj_label, mu=mu_xL2, logvar=logvar_xL2, n_nodes=n_nodes, norm=norm, pos_weight=pos_weight))+\ (1.0/E_KLD_QX_PX2)+KLD_Z2 # z_xL2, mu_xL2, logvar_xL2,z_wL2, mu_wL2, logvar_wL2,mu_pxL2, logvar_pxL2,qz2 = model(shuf_fts, adj_norm) # lossF = (1.0/loss_function(preds=model.dc(z_xL2), labels=adj_label, # mu=mu_xL2, logvar=logvar_xL2, n_nodes=n_nodes, # norm=norm, pos_weight=pos_weight))+\ # (1.0/E_KLD_QX_PX2)+ KLD_Z2+lossF # lossF = loss_functionShuffle(preds=model.dc(z_xL2), labels=adj_label, # mu=mu_xL2, logvar=logvar_xL2, n_nodes=n_nodes, # norm=norm, pos_weight=pos_weight)+\ # loss_functionShuffle(preds=model.dc(z_wL2), labels=adj_label, # mu=mu_wL2, logvar=logvar_wL2, n_nodes=n_nodes, # norm=norm, pos_weight=pos_weight) # LossF=Variable(torch.tensor(lossF).type(torch.FloatTensor),requires_grad=True) # lossF.backward() loss = loss_function( preds=model.dc(z_x), labels=adj_label, mu=mu_x, logvar=logvar_x, n_nodes=n_nodes, norm=norm, pos_weight=pos_weight) + loss_function( preds=model.dc(z_w), labels=adj_label, mu=mu_w, logvar=logvar_w, n_nodes=n_nodes, norm=norm, pos_weight=pos_weight) + lossF + KLD_Z + E_KLD_QX_PX # if lossF<0.02: # break # lossF.backward() # HL=np.concatenate((mu_xL1.data.numpy(),mu_wL1.data.numpy()),axis=1) # HL2=np.concatenate((mu_xL2.data.numpy(),mu_wL2.data.numpy()),axis=1) # kmeans = KMeans(n_clusters=2, random_state=0).fit(HL) # kmeans2 = KMeans(n_clusters=2, random_state=0).fit(HL2) # predict_labels = kmeans.predict(HL) # predict_labels2 = kmeans.predict(HL2) # pr=np.amax(kmeans.fit_transform(HL), axis=1) # pr2=np.amax(kmeans.fit_transform(HL2), axis=1) # pr=torch.cat((torch.tensor(pr), torch.tensor(pr2))) # b_xent = nn.BCEWithLogitsLoss() # lossF = b_xent(torch.FloatTensor(pr),torch.FloatTensor(lbl)) # print(lossF) # print(loss, lossF) loss.backward(retain_graph=True) cur_loss = loss.item() optimizer.step() hidden_emb = np.concatenate((mu_x.data.numpy(), mu_w.data.numpy()), axis=1) # hidden_emb=mu_x.data.numpy() # print(hidden_emb.shape) # roc_curr, ap_curr = get_roc_score(hidden_emb, adj_orig, val_edges, val_edges_false) # if args.dw == 1: # tqdm.write("Epoch: {}, train_loss_gae={:.5f}, train_loss_dw={:.5f}, val_ap={:.5f}, time={:.5f}".format( # epoch + 1, cur_loss, cur_dw_loss, # ap_curr, time.time() - t)) # else: # tqdm.write("Epoch: {}, train_loss_gae={:.5f}, val_ap={:.5f}, time={:.5f}".format( # epoch + 1, cur_loss, # ap_curr, time.time() - t)) roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges, test_edges_false) # # tqdm.write('ROC: {}, AP: {}'.format(roc_score, ap_score)) wandb.log({"roc_score1": roc_score}) wandb.log({"ap_score1": ap_score}) if (epoch + 1) % 10 == 0: tqdm.write("Evaluating intermediate results...") kmeans = KMeans(n_clusters=args.n_clusters, random_state=0).fit(hidden_emb) predict_labels = kmeans.predict(hidden_emb) # print(np.argmax(kmeans.fit_transform(hidden_emb), axis=1).shape) pr = np.amax(kmeans.fit_transform(hidden_emb), axis=1) b_xent = nn.BCEWithLogitsLoss() print(loss, lossF) # lossF = b_xent(torch.FloatTensor(pr),torch.FloatTensor(true_labels)) cm = clustering_metrics(true_labels, predict_labels) cm.evaluationClusterModelFromLabel(tqdm) roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges, test_edges_false) tqdm.write('ROC: {}, AP: {}'.format(roc_score, ap_score)) # np.save('logs/emb_epoch_{}.npy'.format(epoch + 1), hidden_emb) print(loss, lossF) print("Kmeans ACC", purity_score(true_labels, predict_labels)) # roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges, test_edges_false) # tqdm.write('Test ROC score: ' + str(roc_score)) # tqdm.write('Test AP score: ' + str(ap_score)) tqdm.write("Optimization Finished!") roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges, test_edges_false) tqdm.write('Test ROC score: ' + str(roc_score)) tqdm.write('Test AP score: ' + str(ap_score)) kmeans = KMeans(n_clusters=args.n_clusters, random_state=0).fit(hidden_emb) predict_labels = kmeans.predict(hidden_emb) cm = clustering_metrics(true_labels, predict_labels) cm.evaluationClusterModelFromLabel(tqdm) print("Kmeans ACC", purity_score(true_labels, predict_labels)) if args.plot == 1: cm.plotClusters(tqdm, hidden_emb, true_labels)
parser.add_argument('--dropout_rate', type=float, default=0.2) parser.add_argument('--learning_rate', type=float, default=0.01) parser.add_argument('--weight_decay_layer_one', type=float, default=5e-4) parser.add_argument('--weight_decay_layer_two', type=float, default=5e-4) parser.add_argument('--num_epochs_patience', type=int, default=200) parser.add_argument('--num_epochs_max', type=int, default=1000) parser.add_argument('--run_id', type=str) parser.add_argument('--dataset_split', type=str) parser.add_argument('--learning_rate_decay_patience', type=int, default=50) parser.add_argument('--learning_rate_decay_factor', type=float, default=0.8) args = parser.parse_args() if args.dataset_split == 'jknet': g, features, labels, train_mask, val_mask, test_mask, num_features, num_labels = utils_data.load_data( args.dataset, None, 0.6, 0.2) else: g, features, labels, train_mask, val_mask, test_mask, num_features, num_labels = utils_data.load_data( args.dataset, args.dataset_split) acc = [] for seed in range(args.iter): setup_seed(seed * 10) g.set_n_initializer(dgl.init.zero_initializer) g.set_e_initializer(dgl.init.zero_initializer) if args.model == 'GCN': net = GCN(num_features, args.num_hidden, num_labels) if args.model == 'GAT': net = GAT(num_features, args.num_hidden, num_labels) if args.model == 'GIN': net = GIN(num_features, args.num_hidden, num_labels)
parser.add_argument('--weight_decay_layer_one', type=float) parser.add_argument('--weight_decay_layer_two', type=float) parser.add_argument('--num_epochs_patience', type=int, default=100) parser.add_argument('--num_epochs_max', type=int, default=5000) parser.add_argument('--run_id', type=str) parser.add_argument('--dataset_split', type=str) parser.add_argument('--learning_rate_decay_patience', type=int, default=50) parser.add_argument('--learning_rate_decay_factor', type=float, default=0.8) args = parser.parse_args() vars(args)['model'] = 'GeomGCN_TwoLayers' t1 = time.time() if args.dataset_split == 'jknet': g, features, labels, train_mask, val_mask, test_mask, num_features, num_labels = utils_data.load_data( args.dataset, None, 0.6, 0.2, 'GeomGCN', args.dataset_embedding) else: g, features, labels, train_mask, val_mask, test_mask, num_features, num_labels = utils_data.load_data( args.dataset, args.dataset_split, None, None, 'GeomGCN', args.dataset_embedding) print(time.time() - t1) g.set_n_initializer(dgl.init.zero_initializer) g.set_e_initializer(dgl.init.zero_initializer) net = GeomGCNNet(g=g, num_input_features=num_features, num_output_classes=num_labels, num_hidden=args.num_hidden, num_divisions=9, dropout_rate=args.dropout_rate,