ConvE：Convolutional 2D Knowledge Graph Embeddings

论文：Convolutional 2D Knowledge Graph Embeddings

1 介绍

1.1 提出原因

之前提出的模型如disMult，Trans系列模型，成为浅层模型，虽然比较简单，参数较少、训练模型速度较快，但是这些模型相比于深的模型，更少能够抓到复杂的信息。因此，提出模型ConvE模型，利用卷积的方式进行知识图谱补全，能够适用于更加复杂的图。

在浅层模型中增加特征数量的唯一方法，就是增加embedding的维度，但是随之而来存在一个问题，不能扩展到更大的知识图谱，因为嵌入参数的总数与图中实体和关系的数量成正比。此外，以往的多层知识图嵌入体系结构都是全连接的，容易出现过拟合问题。

1.2ConvE优势

ConvE采取卷积的形式，由于高度优化的GPU实现，它的参数效率和计算速度快。由于其的普遍使用，在训练多层卷积网络时，已经建立了鲁棒方法来控制过拟合。在本文中，我们引入了ConvE模型，该模型使用二维卷积在嵌入上预测知识图中的缺失环节。ConvE是用于链接预测的最简单的多层卷积体系结构:它由单个卷积层、嵌入维数的投影层和内积层定义。相比于GCN框架仅限于无向图，而知识图自然是有向的，并且可能受到限制的内存需求的影响。

1.3 贡献

• 介绍了一个简单的，有竞争力的2D卷积链路预测模型，ConvE。
• 开发一个1-N的评分程序，加速三倍的训练和300倍的评估。
• 系统地研究了在常用的链接预测数据集中报告的逆关系测试集泄漏，在必要时引入数据集的鲁棒版本，使其无法用简单的基于规则的模型来解决。

2 模型

2.1 1D vs 2D Convolutions

1D Convolutions
([a a a] ; [b b b]) = [a a a b b b]
若采用filter， 其 size k = 3， 结果为维度$1\times 4$

2D Convolutions
$\left(\begin{array}{c}\left[\begin{array}{ccc}a& a& a\\ a& a& a\end{array}\right];\left[\begin{array}{ccc}b& b& b\\ b& b& b\end{array}\right]\end{array}\right)=\left[\begin{array}{ccc}a& a& a\\ a& a& a\\ b& b& b\\ b& b& b\end{array}\right]$
若采用filter， 其 size k = 3$\times 3$， 结果为维度$2\times 1$
二维卷积运算能够模拟a和b之间更多的交互作用(与m, n, k成比例的动作)。因此，与一维卷积相比，二维卷积能够提取两个嵌入之间更多的特征交互作用

2.2 模型图

模型讲解：

• 头实体和关系的one-hot编码进行embedding，维度为k
• 将头实体和关系的embeding 进行reshape,并拼接
• 进行卷积操作
• 全连接操作，映射维度为k
• 将全连接的结果乘以所有embedding结果，即实现1-N的评分方法，也就是说结果乘所有实体。

2.3 评分函数

其中${\mathbf{r}}_r\in {\mathbb{R}}_k,{\overline{e}}_s,{\overline{r}}_r分别代表e_s,r_r,2D进行reshape结果。e_s,r_r\in {\mathbb{R}}_k,{\overline{e}}_s,{\overline{r}}_r\in {\mathbb{R}}^{k_w\times k_h},其中k=k_w\times k_h$

2.4 损失函数

2.5 正则化

我们通过在几个阶段使用drop out来规范我们的模型，防止过拟合。 特别地，我们在嵌入、卷积后的feature map以及全连通层后的hidden units上使用了dropout。此外，我们BatchNorm进行归一化，在卷积输入之前，卷积输入之后，
feature map之后进行BatchNorm归一化。

3 代码

论文原作代码使用一个框架难以理解，找到替代的一个代码。
参考代码：点我
模型代码

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import  Parameter
class ConvE(nn.Module):
    def __init__(self, config):
        super(ConvE, self).__init__()
        self.config = config
        self.ent_embs = nn.Embedding(self.config.ent_num, self.config.dim)
        self.rel_embs = nn.Embedding(self.config.rel_num, self.config.dim)
        self.input_drop = nn.Dropout(config.inputDrop)
        self.hide_drop = nn.Dropout(config.hideDrop)
        self.feature_drop = nn.Dropout2d(config.featureDrop)
        self.conv = nn.Conv2d(1, 32, (3, 3), bias=True)
        self.bn0 = nn.BatchNorm2d(1)
        self.bn1 = nn.BatchNorm2d(32)
        self.bn2 = nn.BatchNorm1d(config.dim)
        self.fc = nn.Linear(config.hide_size, config.dim)
        self.dim = config.dim #dim = 200
        self.dim1 = config.dim1  #dim1 = 20
        self.dim2 = self.dim // self.dim1 # dim2 = 10
        self.loss = nn.BCELoss()
        self.register_parameter('b',Parameter(torch.zeros(config.ent_num)))
        self.init()
        
    def init(self):
        nn.init.xavier_normal_(self.ent_embs.weight.data)
        nn.init.xavier_normal_(self.rel_embs.weight.data)
    def forward(self, e1, rel):
        e1_emb = self.ent_embs(e1).view(-1, 1, self.dim1, self.dim2)#el_emb; batch*1*20*10
        rel_emb = self.rel_embs(rel).view(-1, 1 ,self.dim1, self.dim2)
        
        conv_input = torch.cat([e1_emb, rel_emb], dim = 2)#con_input: bath*1*40*10
        conv_input = self.bn0(conv_input)
        x = self.input_drop(conv_input)
        x = self.conv(conv_input)
        x = self.bn1(x)
        x = F.relu(x)
        x = self.feature_drop(x)
        x = x.view(x.shape[0], -1)#bacth*hide_size(38*8*32 = 9728)
        x = self.fc(x)
        x = self.hide_drop(x)
        x = self.bn2(x)
        x = F.relu(x)#batch*dim          ent_ems.weight   dim*ent_num
        #print(x.shape, self.ent_embs.weight.shape)
        x = torch.mm(x, self.ent_embs.weight.transpose(1, 0))
        x += self.b.expand_as(x)
        pred = torch.sigmoid(x)
        return pred