def _build_high_layers(self, args):
# RS
# [batch_size]
# self.scores = tf.reduce_sum(self.user_embeddings * self.item_embeddings, axis=1)
# self.scores_normalized = tf.nn.sigmoid(self.scores)
#
# # KGE
# # [batch_size, dim * 2]
# self.head_relation_concat = tf.concat([self.head_embeddings, self.relation_embeddings], axis=1)
# for _ in range(args.H):
# self.kge_mlp = MLP(input_dim=args.dim * 2, output_dim=args.dim * 2)
# [batch_size, dim]
# self.head_relation_concat = kge_mlp(self.head_relation_concat)
# self.vars_kge.extend(kge_mlp.vars)
for _ in range(self.args.H - 1):
self.kge_mlp.append(MLP(input_dim=self.args.dim * 2, output_dim=self.args.dim * 2))
self.kge_pred_mlp = MLP(input_dim=args.dim * 2, output_dim=args.dim)
for i in range(self.n_iter):
# print(i)
if i == self.n_iter - 1:
aggregator = self.aggregator_class(self.batch_size, self.dim, act=tf.nn.tanh)
else:
aggregator = self.aggregator_class(self.batch_size, self.dim)
self.aggregates.append(aggregator)
def __init__(self, din, dtreat, y_scaler, args):
super().__init__(args)
self.repnet = ConvNet(din=din, dout=args.hidden_rep, C=[
args.c_rep[0], args.c_rep[1]])
self.outnet = MLP(din=3 * args.hidden_rep + dtreat,
dout=1, C=[args.c_out[0], args.c_out[1]])
self.params = list(self.repnet.parameters()) + \
list(self.outnet.parameters())
self.optimizer = optim.Adam(
params=self.params, lr=args.lr, weight_decay=args.wd)
self.scheduler = StepLR(self.optimizer, step_size=50, gamma=0.1)
self.y_scaler = y_scaler
def _build_low_layers(self, args):
# self.user_emb_matrix = tf.Variable(tf.random.truncated_normal([self.n_user, args.dim]))
self.user_emb_matrix=tf.keras.layers.Embedding(self.n_user, args.dim)
# self.item_emb_matrix = tf.Variable(tf.random.truncated_normal([self.n_item, args.dim]))
self.item_emb_matrix = tf.keras.layers.Embedding(self.n_item, args.dim)
# self.entity_emb_matrix = tf.Variable(tf.random.truncated_normal([self.n_entity, args.dim]))
self.entity_emb_matrix = tf.keras.layers.Embedding(self.n_entity, args.dim)
# self.relation_emb_matrix = tf.Variable(tf.random.truncated_normal([self.n_relation, args.dim]))
self.relation_emb_matrix = tf.keras.layers.Embedding(self.n_relation, args.dim)
# self.user_embeddings = tf.nn.embedding_lookup(self.user_emb_matrix, self.user_indices)
# self.item_embeddings = tf.nn.embedding_lookup(self.item_emb_matrix, self.item_indices)
# self.head_embeddings = tf.nn.embedding_lookup(self.entity_emb_matrix, self.head_indices)
# self.relation_embeddings = tf.nn.embedding_lookup(self.relation_emb_matrix, self.relation_indices)
# self.tail_embeddings = tf.nn.embedding_lookup(self.entity_emb_matrix, self.tail_indices)
for _ in range(args.L):
self.user_mlp.append(MLP(input_dim=args.dim, output_dim=args.dim))
self.tail_mlp.append(MLP(input_dim=args.dim, output_dim=args.dim))
self.cc_unit.append(CrossCompressUnit(args.dim))
class CFRConv(Base):
def __init__(self, din, dtreat, y_scaler, args):
super().__init__(args)
self.repnet = ConvNet(din=din, dout=args.hidden_rep, C=[
args.c_rep[0], args.c_rep[1]])
self.outnet = MLP(din=3 * args.hidden_rep + dtreat,
dout=1, C=[args.c_out[0], args.c_out[1]])
self.params = list(self.repnet.parameters()) + \
list(self.outnet.parameters())
self.optimizer = optim.Adam(
params=self.params, lr=args.lr, weight_decay=args.wd)
self.scheduler = StepLR(self.optimizer, step_size=50, gamma=0.1)
self.y_scaler = y_scaler
def forward(self, x, z):
with torch.no_grad():
_, x_rep_stack = self.repnet(x)
x_rep = x_rep_stack[2]
y_hat = self.outnet(torch.cat((x_rep, z), 1))
y_hat = self.y_scaler.inverse_transform(
y_hat.detach().cpu().numpy())
return y_hat
class DMLShared(Base):
def __init__(self, din, dtreat, y_scaler, args):
super().__init__(args)
self.xnet = DMLLinear(din=3 * args.hidden_rep)
self.repnet = ConvNet(din=din,
dout=args.hidden_rep,
C=[args.c_rep[0], args.c_rep[1]])
self.outnet = MLP(din=3 * args.hidden_rep + dtreat,
dout=1,
C=[args.c_out[0], args.c_out[1]])
self.params = list(self.repnet.parameters()) + \
list(self.outnet.parameters())
self.optimizer = optim.Adam(params=self.params,
lr=args.lr,
weight_decay=args.wd)
self.scheduler = StepLR(self.optimizer, step_size=args.step, gamma=0.1)
self.y_scaler = y_scaler
def forward(self, x, z):
_, x_rep_stack = self.repnet(x)
x_rep = x_rep_stack[2]
y_hat_x = self.xnet(x_rep)
_, x_rep_stack = self.repnet(x)
x_rep = x_rep_stack[2]
y_hat = self.outnet(torch.cat((x_rep, z), 1))
return y_hat_x + y_hat
def fit(self, dataloader, x_train, M_train, Z_train, x_test, M_test,
Z_test, target_outcome):
losses = []
print(' within sample, out of sample')
print(' [Train MSE], [RMSE, PEHE, ATE], [RMSE, PEHE, ATE]')
for epoch in range(self.args.epoch):
epoch_loss = 0
n = 0
for (x, y, z) in dataloader:
x = x.to(device=self.args.device)
y = y.to(device=self.args.device)
z = z.to(device=self.args.device)
self.optimizer.zero_grad()
y_hat = self.forward(x, z)
loss = self.criterion(y_hat, y.reshape([-1, 1]))
loss.backward()
mse = self.mse(
self.y_scaler.inverse_transform(
y_hat.detach().cpu().numpy()),
self.y_scaler.inverse_transform(
y.reshape([-1, 1]).detach().cpu().numpy()))
self.optimizer.step()
epoch_loss += mse * y.shape[0]
n += y.shape[0]
self.scheduler.step()
epoch_loss = epoch_loss / n
losses.append(epoch_loss)
if epoch % 10 == 0:
with torch.no_grad():
# ATE, sqrt(pehe), cmse
within_pm = self.get_score(self, x_train, M_train, Z_train,
target_outcome)
outof_pm = self.get_score(self, x_test, M_test, Z_test,
target_outcome)
print(
'[Epoch: %d] [%.3f], [%.3f, %.3f, %.3f], [%.3f, %.3f, %.3f] '
% (epoch, epoch_loss, within_pm['RMSE'], within_pm['PEHE'],
within_pm['ATE'], outof_pm['RMSE'], outof_pm['PEHE'],
outof_pm['ATE']))
return within_pm, outof_pm, losses
eps=RMSprop_list[2])
elif optimizer_flag == 'AdaDelta':
optimizer = AdaDelta(p=Adadelta_list[0], eps=Adadelta_list[1])
elif optimizer_flag == 'Adam':
optimizer = Adam(lr=Adam_list[0],
p1=Adam_list[1],
p2=Adam_list[2],
eps=Adam_list[3])
elif optimizer_flag == 'RMSpropGraves':
optimizer = RMSpropGraves(lr=RMSpropGraves_list[0],
p=RMSpropGraves_list[1],
eps=RMSpropGraves_list[2])
elif optimizer_flag == 'SMORMS3':
optimizer = SMORMS3(lr=SMORMS3_list[0], eps=SMORSM3_list[1])
model = MLP(model_list)
#optimizerの設定
optimizer.setup(model)
#n_epochとbatchsizeを変更可能
train_loss_list, train_acc_list, test_loss_list, test_acc_list = learning(
model, optimizer, n_epoch, batchsize)
if gpu:
#cpuへの変換
train_loss_list = np.asnumpy(train_loss_list)
train_acc_list = np.asnumpy(train_acc_list)
test_loss_list = np.asnumpy(test_loss_list)
test_acc_list = np.asnumpy(test_acc_list)
import numpy as np # for plot