def _preprocess_adj(self, normalization, adj, cuda):
adj_normalizer = fetch_normalization(normalization)
r_adj = adj_normalizer(adj)
r_adj = sparse_mx_to_torch_sparse_tensor(r_adj).float()
if cuda:
r_adj = r_adj.cuda()
return r_adj
def load_reddit_data(normalization="AugNormAdj",
porting_to_torch=True,
data_path=datadir):
adj, features, y_train, y_val, y_test, train_index, val_index, test_index = loadRedditFromNPZ(
data_path)
labels = np.zeros(adj.shape[0])
labels[train_index] = y_train
labels[val_index] = y_val
labels[test_index] = y_test
adj = adj + adj.T + sp.eye(adj.shape[0])
train_adj = adj[train_index, :][:, train_index]
degree = np.sum(train_adj, axis=1)
features = torch.FloatTensor(np.array(features))
features = (features - features.mean(dim=0)) / features.std(dim=0)
train_features = torch.index_select(features, 0,
torch.LongTensor(train_index))
if not porting_to_torch:
features = features.numpy()
train_features = train_features.numpy()
adj_normalizer = fetch_normalization(normalization)
adj = adj_normalizer(adj)
train_adj = adj_normalizer(train_adj)
if porting_to_torch:
train_adj = sparse_mx_to_torch_sparse_tensor(train_adj).float()
labels = torch.LongTensor(labels)
adj = sparse_mx_to_torch_sparse_tensor(adj).float()
degree = torch.LongTensor(degree)
train_index = torch.LongTensor(train_index)
val_index = torch.LongTensor(val_index)
test_index = torch.LongTensor(test_index)
learning_type = "inductive"
return adj, train_adj, features, train_features, labels, train_index, val_index, test_index, degree, learning_type
def load_reddit_data(data_path="data/",
normalization="AugNormAdj",
cuda=True,
gamma=1.0):
adj, features, y_train, y_val, y_test, train_index, val_index, test_index = loadRedditFromNPZ(
"data/")
labels = np.zeros(adj.shape[0])
labels[train_index] = y_train
labels[val_index] = y_val
labels[test_index] = y_test
adj = adj + adj.T + sp.eye(adj.shape[0])
train_adj = adj[train_index, :][:, train_index]
features = torch.FloatTensor(np.array(features))
features = (features - features.mean(dim=0)) / features.std(dim=0)
adj_normalizer = fetch_normalization(normalization)
if "Aug" in normalization:
adj = adj_normalizer(adj, gamma)
else:
adj = adj_normalizer(adj)
adj = sparse_mx_to_torch_sparse_tensor(adj).float()
if "Aug" in normalization:
train_adj = adj_normalizer(train_adj, gamma)
else:
train_adj = adj_normalizer(train_adj)
train_adj = sparse_mx_to_torch_sparse_tensor(train_adj).float()
labels = torch.LongTensor(labels)
if cuda:
adj = adj.cuda()
train_adj = train_adj.cuda()
features = features.cuda()
labels = labels.cuda()
return adj, train_adj, features, labels, train_index, val_index, test_index
def preprocess_citation_graph(adj, features, normalization="FirstOrderGCN"):
adj_normalizer = fetch_normalization(normalization)
adj = adj_normalizer(adj)
adj2 = features * features.T
adj2 = adj_normalizer(adj2)
features = row_normalize(features)
return adj, features, adj2
def load_reddit_data(data_path="data/", normalization="AugNormAdj", cuda=True):
adj, features, y_train, y_val, y_test, train_index, val_index, test_index = loadRedditFromNPZ(
data_path)
# normalize features
features = torch.FloatTensor(features)
features = (features - features.mean(dim=0)) / features.std(dim=0)
# all labels
labels = np.zeros(adj.shape[0])
labels[train_index] = y_train
labels[val_index] = y_val
labels[test_index] = y_test
labels = torch.LongTensor(labels)
# get dense adjacency matrix
# adj = adj + adj.T + sp.eye(adj.shape[0]) # I will be added twice in normalization
adj = adj + adj.T # add T
adj_normalizer = fetch_normalization(
normalization) # normalization function
adj = adj_normalizer(adj)
adj = sparse_mx_to_torch_sparse_tensor(adj)
# move to cuda
if cuda:
adj = adj.cuda()
features = features.cuda()
labels = labels.cuda()
return adj, features, labels, train_index, val_index, test_index
def preprocess_citation_bigraph(adj, features, normalization="FirstOrderGCN"):
adj_normalizer = fetch_normalization(normalization)
adj = adj_normalizer(adj)
adj_cn = features.T
features = row_normalize(features)
adj_cn = row_normalize(adj_cn)
adj_nc = features
return adj, features, adj_nc, adj_cn
def preprocess_citation(adj, features, normalization="FirstOrderGCN", gamma=1):
adj_normalizer = fetch_normalization(normalization)
if 'Aug' in normalization:
adj = adj_normalizer(adj, gamma=gamma)
else:
adj = adj_normalizer(adj)
features = row_normalize(features)
return adj, features
def load_data(dataset_str="cora",
normalization=[],
feat_normalize=True,
cuda=False,
split="default",
random_state=None,
**kwargs):
"""
Load pickle packed datasets.
"""
with open(dataf+dataset_str+".graph", "rb") as f:
graph = pkl.load(f)
with open(dataf+dataset_str+".X", "rb") as f:
X = pkl.load(f)
with open(dataf+dataset_str+".y", "rb") as f:
y = pkl.load(f)
if split != "default":
tr_size, va_size, te_size = [float(i) for i in split.split("_")]
idx_train, idx_val, idx_test = \
train_val_test_split(np.arange(len(y)), train_size=tr_size,
val_size=va_size, test_size=te_size,
stratify=y, random_state=random_state)
else:
with open(dataf+dataset_str+".split", "rb") as f:
split = pkl.load(f)
idx_train = split['train']
idx_test = split['test']
idx_val = split['valid']
normed_adj = []
if len(normalization) > 0:
adj = nx.adj_matrix(graph)
for n in normalization:
nf = fetch_normalization(n, **kwargs)
normed_adj.append(nf(adj))
if feat_normalize:
X = row_normalize(X)
X = torch.FloatTensor(X).float()
y = torch.LongTensor(y)
normed_adj = [sparse_mx_to_torch_sparse_tensor(adj).float() \
for adj in normed_adj]
idx_train = torch.LongTensor(idx_train)
idx_val = torch.LongTensor(idx_val)
idx_test = torch.LongTensor(idx_test)
if cuda:
X = X.cuda()
normed_adj = [adj.cuda() for adj in normed_adj]
y = y.cuda()
idx_train = idx_train.cuda()
idx_val = idx_val.cuda()
idx_test = idx_test.cuda()
return graph, normed_adj, X, y, idx_train, idx_val, idx_test
def preprocess_citation(adj, features, normalization, extra=None):
adj_normalizer = fetch_normalization(normalization, extra)
adj = adj_normalizer(adj)
#row_sum = 1 / (np.sqrt(np.array(adj.sum(1))))
#row_sum = np.array(adj.sum(1))
#features = row_sum
#features = features.todense()
#features = np.concatenate([features, row_sum], axis=1)
#features = sp.lil_matrix(features)
if normalization != "":
features = row_normalize(features)
return adj, features
def load_coauthor_phy_data(normalization="AugNormAdj",
porting_to_torch=True,
data_path=datadir):
data = load_npz_to_sparse_graph(
os.path.join(data_path, 'coauthor_phy', 'ms_academic_phy.npz'))
# make labels
labels = data.labels
# make adj
adj = data.adj_matrix
adj = adj + adj.T + sp.eye(adj.shape[0])
adj.data = np.ones_like(adj.data)
all_index = shuffle(np.arange(len(labels)), random_state=42)
train_index = all_index[:20000]
val_index = all_index[20000:25000]
test_index = all_index[25000:]
train_adj = adj[train_index, :][:, train_index]
degree = np.sum(train_adj, axis=1)
# make features
features = data.attr_matrix.todense()
features = torch.FloatTensor(np.array(features))
features = features / torch.sum(features, dim=1, keepdim=True)
train_features = torch.index_select(features, 0,
torch.LongTensor(train_index))
if not porting_to_torch:
features = features.numpy()
train_features = train_features.numpy()
adj_normalizer = fetch_normalization(normalization)
adj = adj_normalizer(adj)
train_adj = adj_normalizer(train_adj)
if porting_to_torch:
train_adj = sparse_mx_to_torch_sparse_tensor(train_adj).float()
labels = torch.LongTensor(labels)
adj = sparse_mx_to_torch_sparse_tensor(adj).float()
degree = torch.LongTensor(degree)
train_index = torch.LongTensor(train_index)
val_index = torch.LongTensor(val_index)
test_index = torch.LongTensor(test_index)
learning_type = "inductive"
return adj, train_adj, features, train_features, labels, train_index, val_index, test_index, degree, learning_type
def _load_raw_graph(txt_file):
graph = {}
with open(txt_file, 'r') as f:
cur_idx = 0
for row in f:
row = row.strip().split()
adjs = []
for j in range(1, len(row)):
adjs.append(int(row[j]))
graph[cur_idx] = adjs
cur_idx += 1
adj = nx.adjacency_matrix(nx.from_dict_of_lists(graph))
normalization = "AugNormAdj"
adj_normalizer = fetch_normalization(normalization)
adj = adj_normalizer(adj)
# adj = AmazonAll._sparse_mx_to_torch_sparse_tensor(adj).float()
return adj
def train(epoch):
model.train()
if epoch == 51:
for param_group in optimizer.param_groups:
param_group['lr'] = 0.5 * param_group['lr']
loss_all = 0
for data in train_loader:
data = data.to(device)
optimizer.zero_grad()
if data.edge_attr is None:
edge_weight = torch.ones((data.edge_index.size(1), ),
dtype=torch.float32,
device=data.edge_index.device)
else:
if args.dataset == 'MUTAG':
edge_weight = data.edge_attr.argmax(1)
else:
edge_weight = data.edge_attr
adj_sp = csr_matrix((edge_weight.cpu().numpy(),
(data.edge_index[0, :].cpu().numpy(),
data.edge_index[1, :].cpu().numpy())),
shape=(data.num_nodes, data.num_nodes))
adj_normalizer = fetch_normalization("AugNormAdj")
adj_sp_nz = adj_normalizer(adj_sp)
adj = torch.sparse.FloatTensor(
torch.LongTensor(np.array([adj_sp_nz.row,
adj_sp_nz.col])).to(device),
torch.Tensor(adj_sp_nz.data).to(device),
torch.Size([data.num_nodes, data.num_nodes])) #normalized adj
adj_ori = torch.sparse.FloatTensor(
data.edge_index, edge_weight,
torch.Size([data.num_nodes, data.num_nodes])) #original adj
if data.x is None:
data.x = torch.sparse.sum(
adj_ori, [0]).to_dense().unsqueeze(1).to(device)
output = model(data.x.T, adj, data.batch)
loss = F.nll_loss(output, data.y)
loss.backward()
loss_all += loss.item() * data.num_graphs
optimizer.step()
return loss_all / len(train_dataset)
def load_reddit_data(normalization="AugNormAdj",
porting_to_torch=True,
data_path=datadir):
adj, features, labels, train_index, val_index, test_index = loadRedditFromNPZ(
data_path)
# labels = np.zeros(adj.shape[0])
# labels[train_index] = y_train
# labels[val_index] = y_val
# labels[test_index] = y_test
# the loaded data is symetric and with self-loop, so we do not need the following pre-process
# adj = adj + adj.T + sp.eye(adj.shape[0])
# sampling small set of train index because of our limited computation resources
train_index = shuffle(train_index,
random_state=42)[:int(0.1 * len(train_index))]
train_adj = adj[train_index, :][:, train_index]
degree = np.sum(train_adj, axis=1)
features = torch.FloatTensor(np.array(features))
# features[:, :2] = features[:, :2]/torch.max(features[:, :2], dim=0, keepdim=True)[0]
# features = features/torch.max(features, dim=0, keepdim=True)[0]
features = (features - features.mean(dim=0)) / features.std(dim=0)
train_features = torch.index_select(features, 0,
torch.LongTensor(train_index))
if not porting_to_torch:
features = features.numpy()
train_features = train_features.numpy()
adj_normalizer = fetch_normalization(normalization)
adj = adj_normalizer(adj)
train_adj = adj_normalizer(train_adj)
if porting_to_torch:
train_adj = sparse_mx_to_torch_sparse_tensor(train_adj).float()
labels = torch.LongTensor(labels)
adj = sparse_mx_to_torch_sparse_tensor(adj).float()
degree = torch.LongTensor(degree)
train_index = torch.LongTensor(train_index)
val_index = torch.LongTensor(val_index)
test_index = torch.LongTensor(test_index)
learning_type = "inductive"
return adj, train_adj, features, train_features, labels, train_index, val_index, test_index, degree, learning_type
def test(loader):
model.eval()
correct = 0
for data in loader:
data = data.to(device)
if data.edge_attr is None:
edge_weight = torch.ones((data.edge_index.size(1), ),
dtype=torch.float32,
device=data.edge_index.device)
else:
edge_weight = torch.ones((data.edge_index.size(1), ),
dtype=torch.float32,
device=data.edge_index.device)
adj_sp = csr_matrix((edge_weight.cpu().numpy(),
(data.edge_index[0, :].cpu().numpy(),
data.edge_index[1, :].cpu().numpy())),
shape=(data.num_nodes, data.num_nodes))
adj_sp = adj_sp + adj_sp.T
adj_normalizer = fetch_normalization("AugNormAdj")
adj_sp_nz = adj_normalizer(adj_sp)
adj = torch.sparse.FloatTensor(
torch.LongTensor(np.array([adj_sp_nz.row,
adj_sp_nz.col])).to(device),
torch.Tensor(adj_sp_nz.data).to(device),
torch.Size([data.num_nodes, data.num_nodes])) #normalized adj
adj_ori = torch.sparse.FloatTensor(
data.edge_index, edge_weight,
torch.Size([data.num_nodes, data.num_nodes])) #original adj
if data.x is None:
data.x = torch.sparse.sum(
adj_ori, [0]).to_dense().unsqueeze(1).to(device)
output = model(data.x.T, adj, data.batch)
pred = output.max(dim=1)[1]
correct += pred.eq(data.y).sum().item()
return correct / len(loader.dataset)
def process_data(data, args, normalization="AugNormAdj", usecuda=True):
# '''
# 图：
# adj,tuple-(9475,9475)
# X tweet文本？？Y是该用户所属的类
# X_train,tuple-(5685,9467)
# Y_train,tuple-(5685,)
# X_dev, tuple-(1895,9467)
# Y_dev, tuple-(1895,)
# X_test, tuple-(1895,9467)
# Y_test, tuple-(1895,)
# 用户：
# U_train, list-5685
# U_dev, list-1895
# U_test, list-1895
# 129个类的经纬度：
# classLatMedian, dict-129
# classLonMedian, dict-129
# 用户经纬度：
# userLocation,dict-9475
# '''
adj, X_train, Y_train, X_dev, Y_dev, X_test, Y_test, U_train, U_dev, U_test, \
classLatMedian, classLonMedian, userLocation, tf_idf_num = data # , tf_idf_num
'''porting to pyTorch and concat the matrix'''
adj_normalizer = fetch_normalization(normalization)
adj = adj_normalizer(adj) # 9475,9475
adj = sparse_mx_to_torch_sparse_tensor(
adj).float() # torch.Size([9475, 9475])
'''
context_features
features = np.vstack((X_train, X_dev, X_test))
if args.usenormaliza == True:
print("using feature_normalization1...")
features = feature_normalization1(features)
sum(tfidf)*context_features
features1 = np.vstack((X_train, X_dev, X_test))
features2 = tf_idf_num
if args.usenormaliza == True:
print("using feature_normalization2...")
features1 = feature_normalization2(features1)
# features1 = feature_normalization3(features1)#203.5 352.6
features1 = torch.FloatTensor(features1)
features2 = torch.FloatTensor(features2)
features= features1.view(features1.size(1), -1)*features2
features=features.view(features.size(1), -1)
'''
# tf-idf
if args.usenormaliza == True:
# X_train = X_train.todense()
# X_test = X_test.todense()
# X_dev = X_dev.todense()
print("using feature_normalization1...")
features = np.vstack((X_train, X_dev, X_test))
features = feature_normalization1(features)
features = torch.FloatTensor(features)
features = torch.FloatTensor(features)
print("features:", features.shape)
'''get labels'''
labels = torch.LongTensor(np.hstack((Y_train, Y_dev, Y_test))) # 一维9475
'''get index of train val and test'''
len_train = int(X_train.shape[0]) # 5685
len_val = int(X_dev.shape[0]) # 1895
len_test = int(X_test.shape[0]) # 1895
# 构建label tensor
idx_train = torch.LongTensor(range(len_train)) # torch.Size([5685])
idx_val = torch.LongTensor(
range(
len_train,
len_train +
len_val)) # [5685……7579]
idx_test = torch.LongTensor(
range(
len_train +
len_val,
len_train +
len_val +
len_test)) # [7580……9474]
'''convert to cuda'''
if usecuda:
print("converting data to CUDA format...")
adj = adj.cuda()
features = features.cuda()
labels = labels.cuda()
idx_train = idx_train.cuda()
idx_val = idx_val.cuda()
idx_test = idx_test.cuda()
data = (adj, features, labels, idx_train, idx_val, idx_test, U_train, U_dev,
U_test, classLatMedian, classLonMedian, userLocation)
return data
def load_facebook_page_data(normalization, porting_to_torch, data_path=None):
edges = pd.read_csv(os.path.join(data_path, 'facebook_page',
'musae_facebook_edges.csv'),
header=0,
sep=',')
raw_feats = json.load(
open(
os.path.join(data_path, 'facebook_page',
'musae_facebook_features.json'), 'r'))
# make adj
adj = sp.coo_matrix(
(np.ones(len(edges)), (edges.values[:, 0], edges.values[:, 1])),
shape=[len(raw_feats), len(raw_feats)])
adj = adj.tocsr()
adj = adj + adj.T + sp.eye(adj.shape[0])
adj.data = np.ones_like(adj.data)
adj = adj + adj.T + sp.eye(adj.shape[0])
train_adj = adj # transductive setting
degree = np.sum(train_adj, axis=1)
# make features
feat_set = set()
for k in raw_feats:
feat_set = feat_set | set(raw_feats[k])
feat_dim = len(list(feat_set))
features = np.zeros(shape=[adj.shape[0], feat_dim])
for k in raw_feats:
features[int(k), :][raw_feats[k]] = 1.0
# make labels
raw_label_data = pd.read_csv(os.path.join(data_path, 'facebook_page',
'musae_facebook_target.csv'),
header=0,
sep=',')
raw_labels = raw_label_data['page_type'].unique()
label_map = pd.Series(data=range(len(raw_labels)), index=raw_labels)
raw_label_data['label'] = label_map[
raw_label_data['page_type'].values].values
labels = raw_label_data['label'].values
# split data
if not os.path.exists(
os.path.join(data_path, 'facebook_page', 'train_index.npy')):
print('make split data.......')
train_index = []
val_index = []
test_index = []
for l in range(labels.max() + 1):
tmp_index = np.where(labels == l)[0]
tmp_index = shuffle(tmp_index, random_state=42)
tmp_train = tmp_index[:20]
tmp_val = tmp_index[20:50]
tmp_test = tmp_index[50:]
train_index.append(tmp_train)
val_index.append(tmp_val)
test_index.append(tmp_test)
train_index = shuffle(np.concatenate(train_index), random_state=42)
val_index = shuffle(np.concatenate(val_index), random_state=42)
test_index = shuffle(np.concatenate(test_index), random_state=42)
np.save(os.path.join(data_path, 'facebook_page', 'train_index.npy'),
train_index)
np.save(os.path.join(data_path, 'facebook_page', 'val_index.npy'),
val_index)
np.save(os.path.join(data_path, 'facebook_page', 'test_index.npy'),
test_index)
else:
print('load split data......')
train_index = np.load(
os.path.join(data_path, 'facebook_page', 'train_index.npy'))
val_index = np.load(
os.path.join(data_path, 'facebook_page', 'val_index.npy'))
test_index = np.load(
os.path.join(data_path, 'facebook_page', 'test_index.npy'))
# process data
features = torch.FloatTensor(features)
features = features / torch.sum(features, dim=1, keepdim=True)
train_features = features
if not porting_to_torch:
features = features.numpy()
train_features = train_features.numpy()
adj_normalizer = fetch_normalization(normalization)
adj = adj_normalizer(adj)
train_adj = adj_normalizer(train_adj)
if porting_to_torch:
train_adj = sparse_mx_to_torch_sparse_tensor(train_adj).float()
labels = torch.LongTensor(labels)
adj = sparse_mx_to_torch_sparse_tensor(adj).float()
degree = torch.LongTensor(degree)
train_index = torch.LongTensor(train_index)
val_index = torch.LongTensor(val_index)
test_index = torch.LongTensor(test_index)
learning_type = "transductive"
return adj, train_adj, features, train_features, labels, train_index, val_index, test_index, degree, learning_type
def load_cora_full_data(normalization="AugNormAdj",
porting_to_torch=True,
data_path=datadir):
data = load_npz_to_sparse_graph(
os.path.join(data_path, 'cora_full', 'cora_full.npz'))
# delete labeled nodes less than 50
adj = data.adj_matrix
features = data.attr_matrix.todense()
labels = data.labels
mask = []
count_dict = {}
for l in labels:
tmp_index = np.where(labels == l)[0]
if l not in count_dict:
count_dict[l] = len(tmp_index)
if len(tmp_index) > 55:
mask.append(True)
else:
mask.append(False)
mask = np.array(mask)
adj = adj[mask, :][:, mask]
features = features[mask]
labels = labels[mask]
# re-assign labels
label_map = pd.Series(index=np.unique(labels),
data=np.arange(len(np.unique(labels))))
labels = label_map[labels].values
# make adj
adj = adj + adj.T + sp.eye(adj.shape[0])
adj.data = np.ones_like(adj.data)
train_adj = adj
degree = np.sum(train_adj, axis=1)
# make features
features = torch.FloatTensor(features)
# features = features / torch.sum(features, dim=1, keepdim=True)
train_features = features # transductive setting
if not porting_to_torch:
features = features.numpy()
train_features = train_features.numpy()
# split data
if not os.path.exists(
os.path.join(data_path, 'cora_full', 'train_index.npy')):
print('make split data......')
train_index = []
val_index = []
test_index = []
for l in range(labels.max() + 1):
tmp_index = np.where(labels == l)[0]
tmp_index = shuffle(tmp_index, random_state=42)
tmp_train = tmp_index[:20]
tmp_val = tmp_index[20:50]
tmp_test = tmp_index[50:]
train_index.append(tmp_train)
val_index.append(tmp_val)
test_index.append(tmp_test)
train_index = shuffle(np.concatenate(train_index), random_state=42)
val_index = shuffle(np.concatenate(val_index), random_state=42)
test_index = shuffle(np.concatenate(test_index), random_state=42)
np.save(os.path.join(data_path, 'cora_full', 'train_index.npy'),
train_index)
np.save(os.path.join(data_path, 'cora_full', 'val_index.npy'),
val_index)
np.save(os.path.join(data_path, 'cora_full', 'test_index.npy'),
test_index)
else:
print('load split data......')
train_index = np.load(
os.path.join(data_path, 'cora_full', 'train_index.npy'))
val_index = np.load(
os.path.join(data_path, 'cora_full', 'val_index.npy'))
test_index = np.load(
os.path.join(data_path, 'cora_full', 'test_index.npy'))
adj_normalizer = fetch_normalization(normalization)
adj = adj_normalizer(adj)
train_adj = adj_normalizer(train_adj)
if porting_to_torch:
train_adj = sparse_mx_to_torch_sparse_tensor(train_adj).float()
labels = torch.LongTensor(labels)
adj = sparse_mx_to_torch_sparse_tensor(adj).float()
degree = torch.LongTensor(degree)
train_index = torch.LongTensor(train_index)
val_index = torch.LongTensor(val_index)
test_index = torch.LongTensor(test_index)
learning_type = "transductive"
return adj, train_adj, features, train_features, labels, train_index, val_index, test_index, degree, learning_type
def preprocess_synthetic(adj, features, normalization, extra=None):
adj_normalizer = fetch_normalization(normalization, extra)
adj = adj_normalizer(adj)
return adj, features
def load_amazon_photo_data(normalization="AugNormAdj",
porting_to_torch=True,
data_path=datadir):
data = load_npz_to_sparse_graph(
os.path.join(data_path, 'amazon_photo',
'amazon_electronics_photo.npz'))
# make adj
adj = data.adj_matrix
adj = adj + adj.T + sp.eye(adj.shape[0])
adj.data = np.ones_like(adj.data)
train_adj = adj
degree = np.sum(train_adj, axis=1)
# make features
features = data.attr_matrix.todense()
features = torch.FloatTensor(features)
features = features / torch.sum(features, dim=1, keepdim=True)
train_features = features # transductive setting
if not porting_to_torch:
features = features.numpy()
train_features = train_features.numpy()
# make labels
labels = data.labels
# split data
if not os.path.exists(
os.path.join(data_path, 'amazon_photo', 'train_index.npy')):
print('make split data......')
train_index = []
val_index = []
test_index = []
for l in range(labels.max() + 1):
tmp_index = np.where(labels == l)[0]
tmp_index = shuffle(tmp_index, random_state=42)
tmp_train = tmp_index[:20]
tmp_val = tmp_index[20:50]
tmp_test = tmp_index[50:]
train_index.append(tmp_train)
val_index.append(tmp_val)
test_index.append(tmp_test)
train_index = shuffle(np.concatenate(train_index), random_state=42)
val_index = shuffle(np.concatenate(val_index), random_state=42)
test_index = shuffle(np.concatenate(test_index), random_state=42)
np.save(os.path.join(data_path, 'amazon_photo', 'train_index.npy'),
train_index)
np.save(os.path.join(data_path, 'amazon_photo', 'val_index.npy'),
val_index)
np.save(os.path.join(data_path, 'amazon_photo', 'test_index.npy'),
test_index)
else:
print('load split data......')
train_index = np.load(
os.path.join(data_path, 'amazon_photo', 'train_index.npy'))
val_index = np.load(
os.path.join(data_path, 'amazon_photo', 'val_index.npy'))
test_index = np.load(
os.path.join(data_path, 'amazon_photo', 'test_index.npy'))
adj_normalizer = fetch_normalization(normalization)
adj = adj_normalizer(adj)
train_adj = adj_normalizer(train_adj)
if porting_to_torch:
train_adj = sparse_mx_to_torch_sparse_tensor(train_adj).float()
labels = torch.LongTensor(labels)
adj = sparse_mx_to_torch_sparse_tensor(adj).float()
degree = torch.LongTensor(degree)
train_index = torch.LongTensor(train_index)
val_index = torch.LongTensor(val_index)
test_index = torch.LongTensor(test_index)
learning_type = "transductive"
return adj, train_adj, features, train_features, labels, train_index, val_index, test_index, degree, learning_type
def preprocess_citation(adj, features, normalization='AugNormAdj'):
adj_normalizer = fetch_normalization(normalization)
adj = adj_normalizer(adj)
features = row_normalize(features)
return adj, features
def preprocess_citation(adj, features, normalization='FIrstOrderGCN'):
adj_normalizer = fetch_normalization(normalization)
adj = adj_normalizer(adj)
features = row_normalize(features)
return adj, features
def preprocess_adj(adj, normalization="AugNormAdj"):
adj_normalizer = fetch_normalization(normalization)
adj = adj_normalizer(adj)
return adj
def preprocess_citation(adj, features, normalization="FirstOrderGCN"):
adj_normalizer = fetch_normalization(normalization)
#features, Droot = row_normalize(features,adj)
features = row_normalize(features)
adj = adj_normalizer(adj)
return adj, features
