其余python包中基本就模型、损失函数（MarginLoss等）、NegativeSampling以及Trainer几处与算法相关。由于是torch写的，所以很易懂，就不展开讲了

    1. import torch
    2. import torch.nn as nn
    3. import torch.nn.functional as F
    4. from .Model import Model
    6. class TransE(Model):
    8.     def __init__(self, ent_tot, rel_tot, dim = 100, p_norm = 1, norm_flag = True, margin = None, epsilon = None):
    9.         super(TransE, self).__init__(ent_tot, rel_tot)
    11.         self.dim = dim  # 即嵌入向量的维度
    12.         self.margin = margin
    13.         self.epsilon = epsilon
    14.         self.norm_flag = norm_flag
    15.         self.p_norm = p_norm
    17.         # ent_tot指的是实体的数量
    18.         self.ent_embeddings = nn.Embedding(self.ent_tot, self.dim)
    19.         # rel_tot指的是关系的数量
    20.         self.rel_embeddings = nn.Embedding(self.rel_tot, self.dim)
    22.         # 默认情况下，直接对嵌入向量进行哈维尔初始化
    23.         if margin == None or epsilon == None:
    24.             nn.init.xavier_uniform_(self.ent_embeddings.weight.data)
    25.             nn.init.xavier_uniform_(self.rel_embeddings.weight.data)
    26.         else:
    27.             self.embedding_range = nn.Parameter(
    28.                 torch.Tensor([(self.margin + self.epsilon) / self.dim]), requires_grad=False
    29.             )
    30.             nn.init.uniform_(
    31.                 tensor = self.ent_embeddings.weight.data, 
    32.                 a = -self.embedding_range.item(), 
    33.                 b = self.embedding_range.item()
    34.             )
    35.             nn.init.uniform_(
    36.                 tensor = self.rel_embeddings.weight.data, 
    37.                 a= -self.embedding_range.item(), 
    38.                 b= self.embedding_range.item()
    39.             )
    41.         # 定义margin，在使用SigmoidLoss的时候会拍上用场，使用MarginLoss不需要定义，因为Margin已经在损失函数中设置好了
    42.         if margin != None:
    43.             self.margin = nn.Parameter(torch.Tensor([margin]))
    44.             self.margin.requires_grad = False
    45.             self.margin_flag = True
    46.         else:
    47.             self.margin_flag = False
    50.     def _calc(self, h, t, r, mode):
    51.         if self.norm_flag:
    52.             # 对嵌入向量进行正态化操作，2指的是平方范数
    53.             h = F.normalize(h, 2, -1)
    54.             r = F.normalize(r, 2, -1)
    55.             t = F.normalize(t, 2, -1)
    56.         if mode != 'normal':
    57.             # 这里要变换形状是因为当模式为头部负采样时或尾部负采样时h或t会有很多负样例，形状不同导致不能运算，所以作一下变换
    58.             h = h.view(-1, r.shape[0], h.shape[-1])
    59.             t = t.view(-1, r.shape[0], t.shape[-1])
    60.             r = r.view(-1, r.shape[0], r.shape[-1])
    61.         if mode == 'head_batch':
    62.             score = h + (r - t)
    63.         else:
    64.             score = (h + r) - t
    65.         # 这个计算得到的score实际上就是(h + r) - t这个向量的模
    66.         score = torch.norm(score, self.p_norm, -1).flatten()
    67.         return score
    69.     def forward(self, data):
    70.         batch_h = data['batch_h']
    71.         batch_t = data['batch_t']
    72.         batch_r = data['batch_r']
    73.         mode = data['mode']
    75.         # 获取实体以及关系batch的全部嵌入向量（即返回一个嵌入矩阵）
    76.         h = self.ent_embeddings(batch_h)
    77.         t = self.ent_embeddings(batch_t)
    78.         r = self.rel_embeddings(batch_r)
    79.         score = self._calc(h ,t, r, mode)
    80.         if self.margin_flag:
    81.             return self.margin - score
    82.         else:
    83.             return score
    85.     def regularization(self, data):
    86.         batch_h = data['batch_h']
    87.         batch_t = data['batch_t']
    88.         batch_r = data['batch_r']
    89.         h = self.ent_embeddings(batch_h)
    90.         t = self.ent_embeddings(batch_t)
    91.         r = self.rel_embeddings(batch_r)
    92.         regul = (torch.mean(h ** 2) + 
    93.                  torch.mean(t ** 2) + 
    94.                  torch.mean(r ** 2)) / 3
    95.         return regul
    97.     def predict(self, data):
    98.         score = self.forward(data)
    99.         if self.margin_flag:
    100.             score = self.margin - score
    101.             return score.cpu().data.numpy()
    102.         else:
    103.             return score.cpu().data.numpy()