def __init__(self, args): self.dataset = args.dataset self.device = torch.device(f'cuda:{args.cuda_num}' if args.cuda else 'cpu') if self.dataset in ["Cora", "Citeseer", "Pubmed", 'CoauthorCS']: self.data = load_data(self.dataset) self.loss_fn = torch.nn.functional.nll_loss else: raise Exception(f'the dataset of {self.dataset} has not been implemented') self.miss_rate = args.miss_rate if self.miss_rate > 0.: self.data.x = remove_feature(self.data, self.miss_rate) self.type_model = args.type_model self.epochs = args.epochs self.grad_clip = args.grad_clip self.weight_decay = args.weight_decay if self.type_model == 'GCN': self.model = GCN(args) elif self.type_model == 'simpleGCN': self.model = simpleGCN(args) elif self.type_model == 'GAT': self.model = GAT(args) else: raise Exception(f'the model of {self.type_model} has not been implemented') self.data.to(self.device) self.model.to(self.device) self.optimizer = torch.optim.Adam(self.model.parameters(), lr=args.lr, weight_decay=args.weight_decay) self.seed = args.random_seed self.type_norm = args.type_norm self.skip_weight = args.skip_weight
def __init__(self, input_dim, hidden, output_dim): super(SpatialBlock, self).__init__() self.input_dim = input_dim self.output_dim = output_dim self.homogeneousGAT = GAT(output_dim, hidden, output_dim, nheads=3, conv=False) self.residual = nn.Linear(input_dim, output_dim)
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.model == 'GCN': model = GCN(nfeat=features.shape[1], nhid=args.hidden, nclass=labels.max().item() + 1, dropout=args.dropout) else: model = GAT(nfeat=features.shape[1], nhid=args.hidden, nclass=labels.max().item()+1, dropout=args.dropout, num_head=args.num_head) optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) if 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()
def choose_model(conf): if conf['model_name'] == 'GCN': model = GCN(g=G, in_feats=features.shape[1], n_hidden=conf['hidden'], n_classes=labels.max().item() + 1, n_layers=1, activation=F.relu, dropout=conf['dropout']).to(conf['device']) elif conf['model_name'] in ['GAT', 'SGAT']: if conf['model_name'] == 'GAT': num_heads = 8 else: num_heads = 1 num_layers = 1 num_out_heads = 1 heads = ([num_heads] * num_layers) + [num_out_heads] model = GAT( g=G, num_layers=num_layers, in_dim=features.shape[1], num_hidden=8, num_classes=labels.max().item() + 1, heads=heads, activation=F.relu, feat_drop=0.6, attn_drop=0.6, negative_slope=0.2, # negative slope of leaky relu residual=False).to(conf['device']) elif conf['model_name'] == 'GraphSAGE': model = GraphSAGE(in_feats=features.shape[1], n_hidden=conf['embed_dim'], n_classes=labels.max().item() + 1, n_layers=2, activation=F.relu, dropout=0.5, aggregator_type=conf['agg_type']).to(conf['device']) elif conf['model_name'] == 'APPNP': model = APPNP(g=G, in_feats=features.shape[1], hiddens=[64], n_classes=labels.max().item() + 1, activation=F.relu, feat_drop=0.5, edge_drop=0.5, alpha=0.1, k=10).to(conf['device']) elif conf['model_name'] == 'MoNet': model = MoNet(g=G, in_feats=features.shape[1], n_hidden=64, out_feats=labels.max().item() + 1, n_layers=1, dim=2, n_kernels=3, dropout=0.7).to(conf['device']) elif conf['model_name'] == 'SGC': model = SGConv(in_feats=features.shape[1], out_feats=labels.max().item() + 1, k=2, cached=True, bias=False).to(conf['device']) elif conf['model_name'] == 'GCNII': if conf['dataset'] == 'citeseer': conf['layer'] = 32 conf['hidden'] = 256 conf['lamda'] = 0.6 conf['dropout'] = 0.7 elif conf['dataset'] == 'pubmed': conf['hidden'] = 256 conf['lamda'] = 0.4 conf['dropout'] = 0.5 model = GCNII(nfeat=features.shape[1], nlayers=conf['layer'], nhidden=conf['hidden'], nclass=labels.max().item() + 1, dropout=conf['dropout'], lamda=conf['lamda'], alpha=conf['alpha'], variant=False).to(conf['device']) return model
def choose_model(conf, G, features, labels, byte_idx_train, labels_one_hot): if conf['model_name'] == 'GCN': model = GCN(g=G, in_feats=features.shape[1], n_hidden=conf['hidden'], n_classes=labels.max().item() + 1, n_layers=1, activation=F.relu, dropout=conf['dropout']).to(conf['device']) elif conf['model_name'] == 'GAT': num_heads = 8 num_layers = 1 num_out_heads = 1 heads = ([num_heads] * num_layers) + [num_out_heads] model = GAT( g=G, num_layers=num_layers, in_dim=G.ndata['feat'].shape[1], num_hidden=8, num_classes=labels.max().item() + 1, heads=heads, activation=F.relu, feat_drop=0.6, attn_drop=0.6, negative_slope=0.2, # negative slope of leaky relu residual=False).to(conf['device']) elif conf['model_name'] == 'PLP': model = PLP(g=G, num_layers=conf['num_layers'], in_dim=G.ndata['feat'].shape[1], emb_dim=conf['emb_dim'], num_classes=labels.max().item() + 1, activation=F.relu, feat_drop=conf['feat_drop'], attn_drop=conf['attn_drop'], residual=False, byte_idx_train=byte_idx_train, labels_one_hot=labels_one_hot, ptype=conf['ptype'], mlp_layers=conf['mlp_layers']).to(conf['device']) elif conf['model_name'] == 'GraphSAGE': model = GraphSAGE(in_feats=G.ndata['feat'].shape[1], n_hidden=16, n_classes=labels.max().item() + 1, n_layers=1, activation=F.relu, dropout=0.5, aggregator_type=conf['agg_type']).to(conf['device']) elif conf['model_name'] == 'APPNP': model = APPNP(g=G, in_feats=G.ndata['feat'].shape[1], hiddens=[64], n_classes=labels.max().item() + 1, activation=F.relu, feat_drop=0.5, edge_drop=0.5, alpha=0.1, k=10).to(conf['device']) elif conf['model_name'] == 'LogReg': model = MLP(num_layers=1, input_dim=G.ndata['feat'].shape[1], hidden_dim=None, output_dim=labels.max().item() + 1, dropout=0).to(conf['device']) elif conf['model_name'] == 'MLP': model = MLP(num_layers=2, input_dim=G.ndata['feat'].shape[1], hidden_dim=conf['hidden'], output_dim=labels.max().item() + 1, dropout=conf['dropout']).to(conf['device']) else: raise ValueError(f'Undefined Model.') return model
# Build graph classification model if model_name == 'GCN': model = GCN(n_feat=datareader.data['features_dim'], n_class=datareader.data['n_classes'], n_layer=args.n_agg_layer, agg_hidden=args.agg_hidden, fc_hidden=args.fc_hidden, dropout=args.dropout, readout=readout_name, device=device).to(device) elif model_name == 'GAT': model = GAT(n_feat=datareader.data['features_dim'], n_class=datareader.data['n_classes'], n_layer=args.n_agg_layer, agg_hidden=args.agg_hidden, fc_hidden=args.fc_hidden, dropout=args.dropout, readout=readout_name, device=device).to(device) # elif model_name == 'GraphWaveletNet': # model = GraphWaveletNet(n_feat=datareader.data['features_dim'], # n_class=datareader.data['n_classes'], # n_layer=args.n_agg_layer, # agg_hidden=args.agg_hidden, # fc_hidden=args.fc_hidden, # dropout=args.dropout, # readout=readout_name, # device=device, # n_node=datareader.data['N_nodes_max']).to(device) elif model_name == 'GraphSAGE': model = GraphUNet(n_feat=datareader.data['features_dim'],
def __init__(self, args): self.dataset = args.dataset self.device = torch.device( f"cuda:{args.cuda_num}" if args.cuda else "cpu") if self.dataset in ["Cora", "Citeseer", "Pubmed", "CoauthorCS"]: if args.ptb: self.data = load_perterbued_data(self.dataset, args.ptb_rate, args.ptb_type) self.loss_fn = torch.nn.functional.nll_loss else: self.data = load_data(self.dataset) self.loss_fn = torch.nn.functional.nll_loss elif self.dataset in ["PPI"]: self.data = load_ppi_data() self.loss_fn = torch.nn.BCEWithLogitsLoss() else: raise Exception( f"the dataset of {self.dataset} has not been implemented") self.entropy_loss = torch.nn.functional.binary_cross_entropy_with_logits self.type_model = args.type_model self.epochs = args.epochs self.weight_decay = args.weight_decay self.alpha = args.alpha self.gamma = args.gamma self.beta = args.beta self.lamb = args.lamb self.num_classes = args.num_classes self.ptb_rate = args.ptb_rate self.ptb_type = args.ptb_type self.metric = args.metric self.num_layers = args.num_layers if self.type_model == "GCN": self.model = GCN(args) elif self.type_model == "GAT": self.model = GAT(args) elif self.type_model == "NLGCN": self.model = NLGCN(args) elif self.type_model == "g_U_Net": self.model = gunet(args) elif self.type_model == "JKNet": self.model = JKNetMaxpool(args) elif self.type_model == "SGC": self.model = simpleGCN(args) elif self.type_model == "APPNP": self.model = APPNP(args) else: raise Exception( f"the model of {self.type_model} has not been implemented") if self.dataset in ["Cora", "Citeseer", "Pubmed", "CoauthorCS"]: if args.ptb: self.data.edge_index, self.data.x, self.data.y = utils.preprocess( self.data.edge_index, self.data.x, self.data.y, preprocess_adj=False, sparse=False, device=self.device) else: self.data.to(self.device) self.model.to(self.device) self.optimizer = torch.optim.Adam(self.model.parameters(), lr=args.lr, weight_decay=args.weight_decay) wandb.init(project="Gref", config=args) wandb.watch(self.model)
num_workers=3, batch_size=BATCH_SIZE) # # g = datasets.GraphDataset(load_cora_data(args.e)) with open("test_data.pkl", 'rb') as f: # pickle.dump(g, f) g = pickle.load(f) test_loader = DataLoader(g, collate_fn=datasets.graph_collate, shuffle=True, num_workers=3, batch_size=BATCH_SIZE) net = GAT(133, 14).to(dev) print("TOTAL PARMS", sum(p.numel() for p in net.parameters() if p.requires_grad)) # create optimizer optimizer = torch.optim.Adam(net.parameters(), lr=1e-3) dur = [] lossf = F.mse_loss second_lossf = torch.nn.MSELoss(reduction='none') for epoch in range(50): net.train() train_avg = Avg() train2_avg = Avg() # if epoch < 10: