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))
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()
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,
