def model_train(self):
print('Model Training')
self.model.train()
mini_batch_s = self.args.mini_batch_s
embed_d = self.args.embed_d
for iter_i in range(self.args.train_iter_n):
# print('iteration ' + str(iter_i) + ' ...')
start_time = time.time()
triple_list = self.input_data.sample_het_walk_triple()
min_len = 1e10
for ii in range(len(triple_list)):
if len(triple_list[ii]) < min_len:
min_len = len(triple_list[ii])
batch_n = int(min_len / mini_batch_s)
loss_list = []
for k in range(batch_n):
c_out = torch.zeros([len(triple_list), mini_batch_s, embed_d])
p_out = torch.zeros([len(triple_list), mini_batch_s, embed_d])
n_out = torch.zeros([len(triple_list), mini_batch_s, embed_d])
for triple_index in range(len(triple_list)):
triple_list_temp = triple_list[triple_index]
triple_list_batch = triple_list_temp[k *
mini_batch_s:(k + 1) *
mini_batch_s] #batch
c_out_temp, p_out_temp, n_out_temp = self.model(
triple_list_batch, triple_index)
c_out[triple_index] = c_out_temp
p_out[triple_index] = p_out_temp
n_out[triple_index] = n_out_temp
loss = tools.cross_entropy_loss(c_out, p_out, n_out, embed_d)
self.optim.zero_grad()
loss.backward()
self.optim.step()
# if (k+1) % 600 == 0:
# print("loss: " + str(loss))
loss_list.append(loss)
train_loss = sum(loss_list) / len(loss_list)
if (iter_i + 1) % args.save_model_freq == 0:
model_save_path = 'model_save/'
if not os.path.isdir(model_save_path):
os.mkdir(model_save_path)
save_path = model_save_path + "SIHDGNN_" + str(iter_i) + ".pt"
torch.save(self.model.state_dict(), save_path)
print('Model saved at {}'.format(save_path))
triple_index = 9
_1, _2, _3 = self.model([], triple_index)
print('Iteration: {} \t Train_Loss: {:.3f} \t Time: {:.3f}s' \
.format(iter_i, train_loss, time.time() - start_time))
def model_train(self):
#开始训练
print('model training ...')
if self.args.checkpoint != '':
self.model.load_state_dict(torch.load(self.args.checkpoint))
self.model.train() #模型调到训练模式
mini_batch_s = self.args.mini_batch_s #batch
embed_d = self.args.embed_d #嵌入维度
for iter_i in range(self.args.train_iter_n): #迭代次数
print('iteration ' + str(iter_i) + ' ...')
triple_list = self.input_data.sample_het_walk_triple(
) #异构三元组（含正例 负例）采样
min_len = 1e10
for ii in range(len(triple_list)):
if len(triple_list[ii]) < min_len:
min_len = len(triple_list[ii])
batch_n = int(min_len / mini_batch_s)
print(batch_n)
for k in range(batch_n):
c_out = torch.zeros([len(triple_list), mini_batch_s, embed_d])
p_out = torch.zeros([len(triple_list), mini_batch_s,
embed_d]) #pos，正例
n_out = torch.zeros([len(triple_list), mini_batch_s,
embed_d]) #neg，负例
for triple_index in range(len(triple_list)):
triple_list_temp = triple_list[triple_index]
triple_list_batch = triple_list_temp[k *
mini_batch_s:(k + 1) *
mini_batch_s]
#得到模型的预测结果
c_out_temp, p_out_temp, n_out_temp = self.model(
triple_list_batch, triple_index)
c_out[triple_index] = c_out_temp
p_out[triple_index] = p_out_temp
n_out[triple_index] = n_out_temp
loss = tools.cross_entropy_loss(c_out, p_out, n_out,
embed_d) #计算三元组交叉熵
self.optim.zero_grad() #梯度清零
loss.backward() #反向传播
self.optim.step() #参数更新
if k % 100 == 0: #打印结果
print("loss: " + str(loss))
if iter_i % self.args.save_model_freq == 0:
torch.save(
self.model.state_dict(),
self.args.model_path + "HetGNN_" + str(iter_i) + ".pt")
#存储参数用于评估
triple_index = 9 #一共有9种case，在tools文件中定义
a_out, p_out, v_out = self.model([], triple_index)
print('iteration ' + str(iter_i) + ' finish.')
def model_train(self):
print ('model training ...')
if self.args.checkpoint != '':
#self.model.load_state_dict(torch.load(self.args.checkpoint))
self.model.load_state_dict(torch.load(self.args.model_path + self.args.checkpoint))
self.model.train()
mini_batch_s = self.args.mini_batch_s
embed_d = self.args.embed_d
writer = SummaryWriter(log_dir='scalar')
for iter_i in range(self.args.train_iter_n):
print ('iteration ' + str(iter_i) + ' ...')
triple_list = self.input_data.sample_het_walk_triple()
min_len = 1e10
for ii in range(len(triple_list)):
if len(triple_list[ii]) < min_len:
min_len = len(triple_list[ii])
batch_n = int(min_len / mini_batch_s)
print (batch_n)
for k in range(batch_n):
c_out = torch.zeros([len(triple_list), mini_batch_s, embed_d])
p_out = torch.zeros([len(triple_list), mini_batch_s, embed_d])
n_out = torch.zeros([len(triple_list), mini_batch_s, embed_d])
for triple_index in range(len(triple_list)):
triple_list_temp = triple_list[triple_index]
triple_list_batch = triple_list_temp[k * mini_batch_s : (k + 1) * mini_batch_s]
c_out_temp, p_out_temp, n_out_temp = self.model(triple_list_batch, triple_index)
c_out[triple_index] = c_out_temp
p_out[triple_index] = p_out_temp
n_out[triple_index] = n_out_temp
loss = tools.cross_entropy_loss(c_out, p_out, n_out, embed_d)
self.optim.zero_grad()
loss.backward()
self.optim.step()
if k % 100 == 0:
print ("loss: " + str(loss))
if k == 0:
writer.add_scalar('loss', loss, iter_i)
if iter_i % self.args.save_model_freq == 0:
torch.save(self.model.state_dict(), self.args.model_path + "HetGNN_" + str(iter_i) + ".pt")
# save embeddings for evaluation
triple_index = 9
a_out, p_out, v_out = self.model([], triple_index)
print ('iteration ' + str(iter_i) + ' finish.')
writer.close()
def train(config):
"""
训练
:param config: 参数配置
:return:
"""
# training parameters
max_iterations = int(config['TRAINING']['max_iterations'])
training_batch = int(config['TRAINING']['training_batch'])
learning_rate = float(config['TRAINING']['learning_rate'])
validation_ratio = float(config['TRAINING']['validation_ratio'])
x_data = _read_data(config['BASE']['x_train_path'])
y_data = _read_data(config['BASE']['y_train_path'])
# pre_processing
x_train, y_train, x_validation, y_validation = _pre_processing(x_data, y_data, validation_ratio)
# 初始化参数
dim = x_train.shape[1]
train_size = x_train.shape[0]
validation_size = x_validation.shape[0]
w = np.zeros([dim, 1])
b = np.zeros([1, 1])
adagrad = 0.0
esp = 0.0000000001
# 保存准确率和loss
train_loss = []
validation_loss = []
train_acc = []
validation_acc = []
# training start
for iterator in range(max_iterations):
# 每一轮训练迭代前先随机打乱
x_random, y_random = tools.shuffle(x_train, y_train)
# 再从随机打乱的数据，分批次训练并更新w,b
for batch in range(int(x_train.shape[0] / training_batch)):
x_batch = x_random[training_batch * batch: training_batch * (batch + 1)]
y_batch = y_random[training_batch * batch: training_batch * (batch + 1)]
# 计算梯度
w_gradient, b_gradient = _gradient(x_batch, y_batch, w, b)
adagrad += b_gradient ** 2
# 更新w,b
w = w - learning_rate / np.sqrt(adagrad + esp) * w_gradient.reshape(-1, 1)
b = b - learning_rate / np.sqrt(adagrad + esp) * b_gradient
# 一轮结束，计算训练集和验证集的准确率和loss
y_random_predict = _logistic_regression(x_random, w, b)
train_acc.append(tools.accuracy(np.round(_logistic_regression(x_random, w, b)), y_random))
train_loss.append(tools.cross_entropy_loss(y_random.T, y_random_predict)[0][0] / train_size)
y_validation_predict = _logistic_regression(x_validation, w, b)
validation_acc.append(tools.accuracy(np.round(_logistic_regression(x_validation, w, b)), y_validation))
validation_loss.append(tools.cross_entropy_loss(y_validation.T, y_validation_predict)[0][0] / validation_size)
# plot
drawer.plot_two_dimensions("acc", [train_acc, validation_acc], ["train", "validation"], True)
drawer.plot_two_dimensions("loss", [train_loss, validation_loss], ["train", "validation"], True)