class FM(torch.nn.Module):
"""Factorization Machines"""
def __init__(self, opt):
super(FM, self).__init__()
self.use_cuda = opt.get('use_cuda')
self.latent_dim = opt['latent_dim']
self.field_dims = opt['field_dims']
self.feature_num = sum(self.field_dims)
self.embedding = PEPEmbedding(opt)
self.linear = FeaturesLinear(self.field_dims) # linear part
self.fm = FactorizationMachine(reduce_sum=True)
print("BackBone Embedding Parameters: ", self.feature_num * self.latent_dim)
def forward(self, x):
linear_score = self.linear.forward(x)
xv = self.embedding(x)
fm_score = self.fm.forward(xv)
score = linear_score + fm_score
return score.squeeze(1)
def l2_penalty(self, x, lamb):
xv = self.embedding(x)
xv_sq = xv.pow(2)
xv_penalty = xv_sq * lamb
xv_penalty = xv_penalty.sum()
return xv_penalty
def calc_sparsity(self):
base = self.feature_num * self.latent_dim
non_zero_values = torch.nonzero(self.embedding.sparse_v).size(0)
percentage = 1 - (non_zero_values / base)
return percentage, non_zero_values
def get_threshold(self):
return self.embedding.g(self.embedding.s)
def get_embedding(self):
return self.embedding.sparse_v.detach().cpu().numpy()
class LR(torch.nn.Module):
def __init__(self, opt):
super(LR, self).__init__()
self.use_cuda = opt.get('use_cuda')
self.field_dims = opt['field_dims']
self.linear = FeaturesLinear(self.field_dims) # linear part
def forward(self, x):
"""Compute Score"""
score = self.linear.forward(x)
return score.squeeze(1)
def l2_penalty(self, x, lamb):
return 0
def calc_sparsity(self):
return 0, 0
def get_threshold(self):
return 0
def get_embedding(self):
return np.zeros(1)