def __init__(self, params): self.num_factors = params.num_factors self.num_users = params.num_users self.num_items = params.num_items self.num_doms = params.num_doms self.reg_lam = params.reg_lam self.reg_w = params.reg_w self.reg_b = params.reg_b self.initializer = params.initializer self.params = params self.num_nodes = params.num_nodes self.feature_dim = params.feature_dim self.social_attr_dim = params.social_attr_dim print('feature dim, social_attr_dim: ', self.feature_dim, self.social_attr_dim) self.model = SpGAT() self.biases = process.preprocess_adj_bias(params.adjacency_matrix) self.user_item_features = params.user_item_embed_mat #[np.newaxis] self.social_features = params.social_embed_mat #[np.newaxis] self.out_size = params.num_factors self.hid_units = params.hid_units self.n_heads = params.n_heads self.attn_keep = params.attn_keep self.ffd_keep = params.ffd_keep self.proj_keep = params.proj_keep self.residual = False self.nonlinearity = tf.nn.elu
def main(): modelcuda = SpGAT(nfeat=1433, nhid=8, nclass=7, dropout=0.6, nheads=8, alpha=0.2) modelcuda.cuda() modelcpu = SpGAT(nfeat=1433, nhid=8, nclass=7, dropout=0.6, nheads=8, alpha=0.2) for density in [0.001, 0.002, 0.003, 0.004, 0.005, 0.006]: print("###########\ndensity", density) tscuda = [] # debug = density==0.003 time_densities(density, modelcuda, ts=tscuda) time_densities(density, modelcuda, ts=tscuda) time_densities(density, modelcuda, ts=tscuda) tscuda = np.array(tscuda) # tscuda = tscuda.min(0) # tscuda = tscuda.min(0)[1:].sum() print("tscuda", tscuda) totcuda = tscuda[-1][0] # print("CPU turn") tscpu = [] time_densities(density, modelcpu, ts=tscpu, dv="cpu") time_densities(density, modelcpu, ts=tscpu, dv="cpu") time_densities(density, modelcpu, ts=tscpu, dv="cpu") tscpu = np.array(tscpu) # tscpu = tscpu.min(0)[1:].sum() # tscpu = tscpu.min(0) # pdb.set_trace() print("tscpu", tscpu) totcpu = tscpu[-1][0] print("-----speedup ", totcpu / totcuda)
def named(): modelcuda = SpGAT(nfeat=100, nhid=8, nclass=7, dropout=0.6, nheads=8, alpha=0.2) modelcuda.cuda() modelcpu = SpGAT(nfeat=100, nhid=8, nclass=7, dropout=0.6, nheads=8, alpha=0.2) for density in ["0.9", "protein", "spheres", "webbase"]: print("###########\nname", density) tscuda = [] # debug = density==0.003 time_named(density, modelcuda, ts=tscuda) time_named(density, modelcuda, ts=tscuda) time_named(density, modelcuda, ts=tscuda) tscuda = np.array(tscuda) # tscuda = tscuda.min(0) # tscuda = tscuda.min(0)[1:].sum() print("tscuda", tscuda) totcuda = tscuda[-1][0] # print("CPU turn") tscpu = [] time_named(density, modelcpu, ts=tscpu, dv="cpu") time_named(density, modelcpu, ts=tscpu, dv="cpu") time_named(density, modelcpu, ts=tscpu, dv="cpu") tscpu = np.array(tscpu) totcpu = tscpu[-1][0] # tscpu = tscpu.min(0)[1:].sum() # tscpu = tscpu.min(0) # pdb.set_trace() print("tscpu", tscpu) print("-----speedup ", totcpu / totcuda)
def timecora(): print("reading data...") with open("cora.pk", "rb") as f: (adj, features, labels, idx_train, idx_val, idx_test) = pk.load(f) print("done reading.") print("numnodes : ", features.shape) modelcuda = SpGAT(nfeat=1433, nhid=8, nclass=7, dropout=0.6, nheads=8, alpha=0.2) # modelcuda.load_state_dict(torch.load('1092.pkl')) modelcuda.cuda() modelcpu = SpGAT(nfeat=1433, nhid=8, nclass=7, dropout=0.6, nheads=8, alpha=0.2) # modelcpu.load_state_dict(torch.load('1092.pkl')) tscuda = [] compute_test(modelcuda, adj, features, labels, idx_test, ts=tscuda) compute_test(modelcuda, adj, features, labels, idx_test, ts=tscuda) compute_test(modelcuda, adj, features, labels, idx_test, ts=tscuda) tscuda = np.array(tscuda) # tscuda = tscuda.min(0)[1:].sum() print("tscuda", tscuda) # print("CPU turn") tscpu = [] compute_test(modelcpu, adj, features, labels, idx_test, ts=tscpu, dv="cpu") compute_test(modelcpu, adj, features, labels, idx_test, ts=tscpu, dv="cpu") compute_test(modelcpu, adj, features, labels, idx_test, ts=tscpu, dv="cpu") tscpu = np.array(tscpu) # tscpu = tscpu.min(0)[1:].sum() print("tscpu", tscpu)
args.cuda = not args.no_cuda and torch.cuda.is_available() random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) if args.cuda: torch.cuda.manual_seed(args.seed) # Load data adj, features, labels, idx_train, idx_val, idx_test = load_data() # Model and optimizer if args.sparse: model = SpGAT(nfeat=features.shape[1], nhid=args.hidden, nclass=int(labels.max()) + 1, dropout=args.dropout, nheads=args.nb_heads, alpha=args.alpha) else: model = GAT(nfeat=features.shape[1], nhid=args.hidden, nclass=int(labels.max()) + 1, dropout=args.dropout, nheads=args.nb_heads, alpha=args.alpha) optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) if args.cuda: model.cuda()
random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) if args.cuda: torch.cuda.manual_seed(args.seed) # Load data adj, features, labels, idx_train, idx_val, idx_test, neighbor_genes = load_joshi_data( args.gene) # Model and optimizer if args.sparse: model = SpGAT( nfeat=features.shape[1], nhid=args.hidden, nclass=1, # regression dropout=args.dropout, nheads=args.nb_heads, alpha=args.alpha) else: model = GAT( ncells=features.shape[0], #features is cells x gene x gene features ngenes=features.shape[1], nfeat=features.shape[2], nhid=args.hidden, nclass=1, # regression dropout=args.dropout, nheads=args.nb_heads, alpha=args.alpha) optimizer = optim.Adam(model.parameters(), lr=args.lr) #, #weight_decay=args.weight_decay)
def train_pipeline(self, adj, features, labels, idx_train, idx_val, idx_test, *args): adj = normalize_adj(adj + sp.eye(adj.shape[0])) if sp.issparse(adj): adj = adj.todense() if sp.issparse(features): features = features.todense() # With networkx, we no longer need to convert from one-hot encoding... # labels = np.where(labels)[1] adj = torch.FloatTensor(adj) features = torch.FloatTensor(features) labels = torch.LongTensor(labels) idx_train = torch.LongTensor(idx_train) idx_val = torch.LongTensor(idx_val) idx_test = torch.LongTensor(idx_test) random.seed(self.args.seed) np.random.seed(self.args.seed) torch.manual_seed(self.args.seed) if self.args.cuda: torch.cuda.manual_seed(self.args.seed) # Model and optimizer if self.args.sparse: model = SpGAT( nfeat=features.shape[1], nhid=self.args.hidden, nclass=int(labels.max()) + 1, dropout=self.args.dropout, nheads=self.args.nb_heads, alpha=self.args.alpha, ) else: model = GAT( nfeat=features.shape[1], nhid=self.args.hidden, nclass=int(labels.max()) + 1, dropout=self.args.dropout, nheads=self.args.nb_heads, alpha=self.args.alpha, ) optimizer = optim.Adam(model.parameters(), lr=self.args.lr, weight_decay=self.args.weight_decay) if self.args.cuda: model.cuda() features = features.cuda() adj = adj.cuda() labels = labels.cuda() idx_train = idx_train.cuda() idx_val = idx_val.cuda() idx_test = idx_test.cuda() features, adj, labels = Variable(features), Variable(adj), Variable( labels) # TODO: Test if these lines could be written below line 41. self.adj = adj self.features = features self.labels = labels self.idx_train = idx_train self.idx_val = idx_val self.idx_test = idx_test def train(epoch): t = time.time() model.train() optimizer.zero_grad() output = model(features, adj) loss_train = F.nll_loss(output[idx_train], labels[idx_train]) acc_train = accuracy(output[idx_train], labels[idx_train]) loss_train.backward() optimizer.step() if not self.args.fastmode: # Evaluate validation set performance separately, # deactivates dropout during validation run. model.eval() output = model(features, adj) loss_val = F.nll_loss(output[idx_val], labels[idx_val]) acc_val = accuracy(output[idx_val], labels[idx_val]) print( "Epoch: {:04d}".format(epoch + 1), "loss_train: {:.4f}".format(loss_train.data.item()), "acc_train: {:.4f}".format(acc_train.data.item()), "loss_val: {:.4f}".format(loss_val.data.item()), "acc_val: {:.4f}".format(acc_val.data.item()), "time: {:.4f}s".format(time.time() - t), ) return loss_val.data.item() # Train model t_total = time.time() loss_values = [] bad_counter = 0 best = self.args.epochs + 1 best_epoch = 0 for epoch in range(self.args.epochs): loss_values.append(train(epoch)) torch.save(model.state_dict(), "{}.pkl".format(epoch)) if loss_values[-1] < best: best = loss_values[-1] best_epoch = epoch bad_counter = 0 else: bad_counter += 1 if bad_counter == self.args.patience: break files = glob.glob("*.pkl") for file in files: epoch_nb = int(file.split(".")[0]) if epoch_nb < best_epoch: os.remove(file) files = glob.glob("*.pkl") for file in files: epoch_nb = int(file.split(".")[0]) if epoch_nb > best_epoch: os.remove(file) print("Optimization Finished!") print("Total time elapsed: {:.4f}s".format(time.time() - t_total)) # Restore best model print("Loading {}th epoch".format(best_epoch)) model.load_state_dict(torch.load("{}.pkl".format(best_epoch))) self.model = model return model
class SoRecGAT(object): def __init__(self, params): self.num_factors = params.num_factors self.num_users = params.num_users self.num_items = params.num_items self.num_doms = params.num_doms self.reg_lam = params.reg_lam self.reg_w = params.reg_w self.reg_b = params.reg_b self.initializer = params.initializer self.params = params self.num_nodes = params.num_nodes self.feature_dim = params.feature_dim self.social_attr_dim = params.social_attr_dim print('feature dim, social_attr_dim: ', self.feature_dim, self.social_attr_dim) self.model = SpGAT() self.biases = process.preprocess_adj_bias(params.adjacency_matrix) self.user_item_features = params.user_item_embed_mat #[np.newaxis] self.social_features = params.social_embed_mat #[np.newaxis] self.out_size = params.num_factors self.hid_units = params.hid_units self.n_heads = params.n_heads self.attn_keep = params.attn_keep self.ffd_keep = params.ffd_keep self.proj_keep = params.proj_keep self.residual = False self.nonlinearity = tf.nn.elu def define_model(self, user_indices, item_indices, dom_indices, true_rating, keep_prob, batch_siz, valid_clip): self.user_indices = user_indices self.item_indices = item_indices self.dom_indices = dom_indices self.true_rating = true_rating self.keep_prob = keep_prob self.valid_clip = valid_clip self.is_training = tf.equal(0.0, valid_clip) self.X_features_user_item = tf.Variable(self.user_item_features, trainable=False, dtype=tf.float32, name='X_features_user_item') self.X_features_social = tf.Variable(self.social_features, trainable=False, dtype=tf.float32, name='X_features_social') self.weight_proj_social = tf.Variable( self.initializer(shape=[self.social_attr_dim, self.feature_dim]), dtype=tf.float32, name='weight_proj') self.b_proj_social = tf.Variable( self.initializer(shape=[1, self.feature_dim]), dtype=tf.float32, name='weight_proj') self.X_features_social = tf.matmul( self.X_features_social, self.weight_proj_social) + self.b_proj_social self.X_features_social = tf.nn.dropout( self.X_features_social, self.valid_clip + (1 - self.valid_clip) * self.proj_keep) self.X_features = tf.expand_dims( tf.concat([self.X_features_user_item, self.X_features_social], axis=0), 0) self.bias_in = tf.SparseTensor(indices=self.biases[0], values=self.biases[1], dense_shape=self.biases[2]) self.logits = self.model.inference( self.X_features, self.out_size, nb_nodes=self.num_nodes, training=self.is_training, attn_drop=(1 - self.attn_keep) * (1 - self.valid_clip), ffd_drop=(1 - self.ffd_keep) * (1 - self.valid_clip), bias_mat=self.bias_in, hid_units=self.hid_units, n_heads=self.n_heads, residual=self.residual, activation=self.nonlinearity) self.user_item_embeddings = tf.reshape( self.logits, [-1, self.n_heads[-1] * self.out_size]) self.user_embeds = tf.nn.embedding_lookup(self.user_item_embeddings, self.user_indices) self.item_embeds = tf.nn.embedding_lookup( self.user_item_embeddings, self.num_users + self.item_indices) self.multiplied_output1 = tf.multiply(self.user_embeds, self.item_embeds) self.multiplied_output1 = tf.nn.dropout(self.multiplied_output1, self.keep_prob) self.mult_cat = tf.concat([self.multiplied_output1], axis=1) self.w = tf.Variable( self.initializer(shape=[self.n_heads[-1] * self.out_size, 1]), dtype=tf.float32, name='w') self.pred_rating = tf.reshape( (tf.nn.sigmoid(tf.matmul(self.mult_cat, self.w))), shape=[-1]) def define_loss(self, loss_type='all'): #self.regularization_loss = tf.constant(0.0) self.regularization_loss = self.reg_w * (tf.nn.l2_loss( self.w) + tf.nn.l2_loss(self.weight_proj_social)) + self.reg_b * ( tf.nn.l2_loss(self.b_proj_social))
def main(): args.data_dir = os.path.join(args.data_dir, args.dataset) args.output_dir = os.path.join(args.output_dir, args.dataset) if os.path.exists(args.output_dir) and os.listdir(args.output_dir): print("Output directory ({}) already exists and is not empty.".format( args.output_dir)) else: os.makedirs(args.output_dir, exist_ok=True) random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) if CUDA: args.use_cuda = CUDA torch.cuda.manual_seed_all(args.seed) torch.backends.cudnn.deterministic = True print("args = ", args) ori_model = 'None' ori_load = True for idx in range(args.N): data_idx = idx # Load data adj, features, labels, idx_train, idx_val, idx_test, test_sub_idx, ori_adj, ori_idx_train, ori_idx_valid = \ load_data(args, data_idx, base_path=args.data_dir, dataset=args.dataset) file_name = "model_name_" + str(args.model_name) + "_lr_" + str( args.lr) + "_epochs_" + str(args.epochs) + "_k_factors_" + str( args.k_factors) + "_up_bound_" + str( args.up_bound) + "_top_n_" + str( args.top_n) + "_att_lr_" + str( args.att_lr) + "_hidden_" + str( args.hidden) + "_w1_" + str(args.w1) if args.all_data: model_path = os.path.join(args.output_dir, file_name) else: model_path = os.path.join(args.output_dir, str(data_idx), file_name) if not os.path.exists(model_path): os.makedirs(model_path) # Model and optimizer if args.model_name == "SpGAT": model = SpGAT(nfeat=features.shape[1], nhid=args.hidden, nclass=int(labels.max()) + 1, dropout=args.dropout, nheads=args.nb_heads, alpha=args.alpha) elif args.model_name == "SpGAT_2": model = SpGAT_2(nfeat=features.shape[1], nclass=int(labels.max()) + 1, config=args) elif args.model_name == "SpGAT2": model = SpGAT_2(nfeat=features.shape[1], nclass=int(labels.max()) + 1, config=args) else: model = GAT(nfeat=features.shape[1], nhid=args.hidden, nclass=int(labels.max()) + 1, dropout=args.dropout, nheads=args.nb_heads, alpha=args.alpha) print("load path", args.load) if args.load != 'None' and ori_load: model = load_model(model, args.load) print("model loaded") ori_load = False if ori_model != 'None': model = copy.deepcopy(ori_model) print("load model from", idx - 1) print(model.state_dict().keys()) if CUDA: model.cuda() features = Variable(features.cuda()) adj = Variable(adj.cuda()) labels = Variable(labels.cuda()) idx_train = idx_train.cuda() idx_val = idx_val.cuda() idx_test = idx_test.cuda() if "_" in args.model_name and not args.all_data and data_idx > 0 and ori_adj is not None: ori_adj = Variable(ori_adj.cuda()) ori_idx_train = ori_idx_train.cuda() ori_idx_valid = ori_idx_valid.cuda() loader = Corpus(features, adj, labels, idx_train, idx_val, idx_test, ori_adj, ori_idx_train, ori_idx_valid) for name, param in model.named_parameters(): if param.requires_grad == False: print("False", name) param.requires_grad = True best_epoch = 0 if args.evaluate == 0: best_epoch = train(model, model_path, loader, data_idx) ori_model = copy.deepcopy(model) evaluate(model, model_path, loader, data_idx, best_epoch=best_epoch, test_sub_idx=test_sub_idx) evaluate(model, model_path, loader, data_idx, best_epoch=best_epoch, test_sub_idx=test_sub_idx, best_or_final='final') args.load = os.path.join(model_path, 'trained_final.pth')
# np.random.seed(args.seed) # torch.manual_seed(args.seed) # if args.cuda: # torch.cuda.manual_seed(args.seed) # Load data # adj, features, labels, idx_train, idx_val, idx_test = load_data() adj, features, labels, idx_train, idx_val, idx_test = load_data_ssl_image( args.data_dir, args.dataset) # Model and optimizer if args.sparse: model = SpGAT(nfeat=features.shape[1], nhid=args.hidden, nclass=int(labels.max()) + 1, dropout=args.dropout, nheads=args.nb_heads, alpha=args.alpha) else: model = GAT(nfeat=features.shape[1], nhid=args.hidden, nclass=int(labels.max()) + 1, dropout=args.dropout, nheads=args.nb_heads, alpha=args.alpha) optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) if args.cuda: model.cuda()
def train_pipeline(self, *args, custom_function=True, function=None): random.seed(self.args.seed) np.random.seed(self.args.seed) torch.manual_seed(self.args.seed) if self.args.cuda: torch.cuda.manual_seed(self.args.seed) # Load data adj, features, labels, idx_train, idx_val, idx_test = new_load_data( *args, custom_function=custom_function, function=function) # Model and optimizer if self.args.sparse: model = SpGAT(nfeat=features.shape[1], nhid=self.args.hidden, nclass=int(labels.max()) + 1, dropout=self.args.dropout, nheads=self.args.nb_heads, alpha=self.args.alpha) else: model = GAT(nfeat=features.shape[1], nhid=self.args.hidden, nclass=int(labels.max()) + 1, dropout=self.args.dropout, nheads=self.args.nb_heads, alpha=self.args.alpha) optimizer = optim.Adam(model.parameters(), lr=self.args.lr, weight_decay=self.args.weight_decay) if self.args.cuda: model.cuda() features = features.cuda() adj = adj.cuda() labels = labels.cuda() idx_train = idx_train.cuda() idx_val = idx_val.cuda() idx_test = idx_test.cuda() features, adj, labels = Variable(features), Variable(adj), Variable( labels) # TODO: Test if these lines could be written below line 41. self.adj = adj self.features = features self.labels = labels self.idx_train = idx_train self.idx_val = idx_val self.idx_test = idx_test def train(epoch): t = time.time() model.train() optimizer.zero_grad() output = model(features, adj) loss_train = F.nll_loss(output[idx_train], labels[idx_train]) acc_train = accuracy(output[idx_train], labels[idx_train]) loss_train.backward() optimizer.step() if not self.args.fastmode: # Evaluate validation set performance separately, # deactivates dropout during validation run. model.eval() output = model(features, adj) loss_val = F.nll_loss(output[idx_val], labels[idx_val]) acc_val = accuracy(output[idx_val], labels[idx_val]) print('Epoch: {:04d}'.format(epoch + 1), 'loss_train: {:.4f}'.format(loss_train.data.item()), 'acc_train: {:.4f}'.format(acc_train.data.item()), 'loss_val: {:.4f}'.format(loss_val.data.item()), 'acc_val: {:.4f}'.format(acc_val.data.item()), 'time: {:.4f}s'.format(time.time() - t)) return loss_val.data.item() # Train model t_total = time.time() loss_values = [] bad_counter = 0 best = self.args.epochs + 1 best_epoch = 0 for epoch in range(self.args.epochs): loss_values.append(train(epoch)) torch.save(model.state_dict(), '{}.pkl'.format(epoch)) if loss_values[-1] < best: best = loss_values[-1] best_epoch = epoch bad_counter = 0 else: bad_counter += 1 if bad_counter == self.args.patience: break files = glob.glob('*.pkl') for file in files: epoch_nb = int(file.split('.')[0]) if epoch_nb < best_epoch: os.remove(file) files = glob.glob('*.pkl') for file in files: epoch_nb = int(file.split('.')[0]) if epoch_nb > best_epoch: os.remove(file) print("Optimization Finished!") print("Total time elapsed: {:.4f}s".format(time.time() - t_total)) # Restore best model print('Loading {}th epoch'.format(best_epoch)) model.load_state_dict(torch.load('{}.pkl'.format(best_epoch))) self.model = model return model
def __init__(self,params): self.num_factors = params.num_factors self.num_users = params.num_users self.num_items = params.num_items self.num_doms = params.num_doms self.attr_dim = params.attn_head_size self.reg_lam = params.reg_lam self.reg_w = params.reg_w self.reg_b = params.reg_b self.initializer = params.initializer self.num_views = params.num_views self.num_attn_heads = params.num_attn_heads self.num_memory_heads = params.num_memory_heads self.attn_head_size = params.attn_head_size self.memory_head_size = params.memory_head_size self.proj_keep = params.proj_keep self.attention_keep = params.attention_keep self.params = params # list initializtion ==================================== self.memnet = [None] * self.num_views self.mult_views = [None] * self.num_views self.item_view_embeds = [None] * self.num_views self.item_attr_mat = [None] * self.num_views self.user_embeds_view = [None] * self.num_views self.proj_item_view = [None] * self.num_views self.mhead_item_view_output = [None] * self.num_views self.m3_item_view_output = [None] * self.num_views # gat ==== self.model = [None] * self.num_views self.biases = [None] * self.num_views self.num_nodes = [None] * self.num_views self.X_features_view = [None] * self.num_views self.bias_in = [None] * self.num_views self.logits = [None] * self.num_views self.item_view_embeddings = [None] * self.num_views self.item_view_embeds = [None] * self.num_views self.X_features_item_entity_view = [None] * self.num_views # ===================================================== self.adjacency_view_matrix = params.adjacency_view_matrix for view in range(self.num_views): self.model[view] = SpGAT() self.biases[view] = process.preprocess_adj_bias(params.adjacency_view_matrix[view]) self.num_nodes[view] = params.adjacency_view_matrix[view].shape[0] self.out_size = params.num_factors self.hid_units = params.hid_units self.n_heads = params.n_heads self.attn_keep = params.attn_keep self.ffd_keep = params.ffd_keep self.proj_keep = params.proj_keep self.residual = False self.nonlinearity = tf.nn.elu self.dense = tf.keras.layers.Dense(self.attn_head_size,use_bias=True,activation='elu') self.dense_attn = tf.keras.layers.Dense(self.attn_head_size/2,use_bias=True,activation='elu') self.dense_w = tf.keras.layers.Dense(1,use_bias=False,activation='sigmoid')
def __init__(self,graph,sparse = False,epochs = 200,learning_rate = 0.005, weight_decay = 5e-4,hidden = 8,nb_heads = 8,drop_out = 0.6, alpha = 0.2 ,patience = 100,train = 1500,val = 2000,test = 3100): self.graph = graph self.sparse = sparse self.epochs = epochs self.learning_rate = learning_rate self.weight_decay = weight_decay self.hidden = hidden self.nb_heads = nb_heads self.drop_out = drop_out self.alpha = alpha self.patience = patience self.train = train self.val = val self.test = test idx_train,idx_val , idx_test = self.load_data() random.seed(random_seed) np.random.seed(random_seed) torch.manual_seed(random_seed) if self.sparse: model = SpGAT(nfeat=self.features.shape[1], nhid=self.hidden, nclass=int(self.labels.max()) + 1, dropout=self.drop_out, nheads=self.nb_heads, alpha=self.alpha) else: model = GAT(nfeat=self.features.shape[1], nhid=self.hidden, nclass=int(self.labels.max()) + 1, dropout=self.drop_out, nheads=self.nb_heads, alpha=self.alpha) optimizer = optim.Adam(model.parameters(), lr=self.learning_rate, weight_decay=self.weight_decay) #利用GPU # device = torch.device("cuda:0") # torch.cuda.empty_cache() # model.to(device) # self.features = self.features.to(device) # self.adj = self.adj.to(device) # self.labels = self.labels.to(device) # idx_train = idx_train.to(device) # idx_val = idx_val.to(device) # idx_test = idx_test.to(device) features, adj, labels = Variable(self.features), Variable(self.adj), Variable(self.labels) t_total = time.time() loss_values = [] bad_counter = 0 best = self.epochs + 1 best_epoch = 0 for epoch in range(self.epochs): t = time.time() model.train() optimizer.zero_grad() output = model(features, adj) loss_train = F.nll_loss(output[idx_train], labels[idx_train]) acc_train = accuracy(output[idx_train], labels[idx_train]) loss_train.backward() optimizer.step() model.eval() output = model(features, adj) loss_val = F.nll_loss(output[idx_val], labels[idx_val]) acc_val = accuracy(output[idx_val], labels[idx_val]) print('Epoch: {:04d}'.format(epoch + 1), 'loss_train: {:.4f}'.format(loss_train.data), 'acc_train: {:.4f}'.format(acc_train.data), 'loss_val: {:.4f}'.format(loss_val.data), 'acc_val: {:.4f}'.format(acc_val.data), 'time: {:.4f}s'.format(time.time() - t)) loss_values.append(loss_val.data) torch.save(model.state_dict(), '{}.pkl'.format(epoch)) if loss_values[-1] < best: best = loss_values[-1] best_epoch = epoch bad_counter = 0 else: bad_counter += 1 if bad_counter == self.patience: break files = glob.glob('*.pkl') for file in files: epoch_nb = int(file.split('.')[0]) if epoch_nb < best_epoch: os.remove(file) print("Optimization Finished!") print("Total time elapsed: {:.4f}s".format(time.time() - t_total)) print('Loading {}th epoch'.format(best_epoch)) model.load_state_dict(torch.load('{}.pkl'.format(best_epoch))) model.eval() output = model(features, adj) loss_test = F.nll_loss(output[idx_test], labels[idx_test]) acc_test = accuracy(output[idx_test], labels[idx_test]) print("Test set results:", "loss= {:.4f}".format(loss_test.data), "accuracy= {:.4f}".format(acc_test.data))
'recall_bg: {:.6f}'.format(recall_bg.data.item()), 'recall_nobg: {:.6f}'.format(recall_nobg.data.item()), 'precision_bg: {:.6f}'.format(precision_bg.data.item()), 'precision_nobg: {:.6f}'.format(precision_nobg.data.item())) if __name__ == '__main__': args = MyParser() # Model and optimizer feat_dim = 4251-4-151 label_dim = 151 if args.sparse: model = SpGAT(nfeat=feat_dim, # nfeat=features.shape[1], nhid=args.hidden, # nclass=int(labels.max()) + 1, <<<<<<< HEAD nclass=label_dim, ======= nclass=151, >>>>>>> origin/master dropout=args.dropout, nheads=args.nb_heads, alpha=args.alpha) else: model = GAT(nfeat=feat_dim, # nfeat=features.shape[1], nhid=args.hidden, # nclass=int(labels.max()) + 1,