在稀疏的、独热编码编码数据上构建自动编码器微信
自1986年[1]问世以来，在过去的30年里，通用自动编码器神经网络已经渗透到现代机器学习的大多数主要领域的研究中。在嵌入复杂数据方面，自动编码器已经被证实是很是有效的，它提供了简单的方法来将复杂的非线性依赖编码为平凡的向量表示。可是，尽管它们的有效性已经在许多方面获得了证实，但它们在重现稀疏数据方面经常存在不足，特别是当列像一个热编码那样相互关联时。
网络
在本文中，我将简要地讨论一种热编码(OHE)数据和通常的自动编码器。而后，我将介绍使用在一个热门编码数据上受过训练的自动编码器所带来的问题的用例。最后，我将深刻讨论稀疏OHE数据重构的问题，而后介绍我发如今这些条件下运行良好的3个损失函数:app
CosineEmbeddingLossdom
Sorenson-Dice Coefficient Loss机器学习
Multi-Task Learning Losses of Individual OHE Componentside
-解决了上述挑战，包括在PyTorch中实现它们的代码。函数
热编码数据
热编码数据是一种最简单的，但在通常机器学习场景中常常被误解的数据预处理技术。该过程将具备“N”不一样类别的分类数据二值化为二进制0和1的N列。第N个类别中出现1表示该观察属于该类别。这个过程在Python中很简单，使用Scikit-Learn OneHotEncoder模块:学习
from sklearn.preprocessing import OneHotEncoder
import numpy as np# Instantiate a column of 10 random integers from 5 classes
x = np.random.randint(5, size=10).reshape(-1,1)print(x)
>>> [[2][3][2][2][1][1][4][1][0][4]]# Instantiate OHE() + Fit/Transform the data
ohe_encoder = OneHotEncoder(categories="auto")
encoded = ohe_encoder.fit_transform(x).todense()print(encoded)
>>> matrix([[0., 1., 0., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 1., 0., 0.],
[1., 0., 0., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 0., 0., 1.]])print(list(ohe_encoder.get_feature_names()))
>>> ["x0_0", "x0_1", "x0_2", "x0_3", "x0_4"]
可是，尽管这个技巧很简单，但若是不当心，它可能很快就会失效。它能够很容易地为数据添加多余的复杂性，并改变数据上某些分类方法的有效性。例如，转换成OHE向量的列如今是相互依赖的，这种交互使得在某些类型的分类器中有效地表示数据方面变得困难。例如，若是您有一个包含15个不一样类别的列，那么就须要一个深度为15的决策树来处理该热编码列中的if-then模式（固然树形模型的数据处理是不须要进行独热编码的，这里只是举例）。相似地，因为列是相互依赖的，若是使用bagging (Bootstrap聚合)的分类策略并执行特性采样，则可能会彻底错过单次编码的列，或者只考虑它的部分组件类。编码
Autoencoders
自动编码器是一种无监督的神经网络，其工做是将数据嵌入到一种有效的压缩格式。它利用编码和解码过程将数据编码为更小的格式，而后再将更小的格式解码为原始的输入表示。利用模型重构(译码)与原始数据之间的损失对模型进行训练。url
实际上，用代码表示这个网络也很容易。咱们从两个函数开始:编码器模型和解码器模型。这两个“模型”都被封装在一个叫作Network的类中，它将包含咱们的培训和评估的整个系统。最后，咱们定义了一个Forward函数，PyTorch将它用做进入网络的入口，用于包装数据的编码和解码。
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optimclass Network(nn.Module):
def __init__(self, input_shape: int):
super().__init__()
self.encode1 = nn.Linear(input_shape, 500)
self.encode2 = nn.Linear(500, 250)
self.encode3 = nn.Linear(250, 50)
self.decode1 = nn.Linear(50, 250)
self.decode2 = nn.Linear(250, 500)
self.decode3 = nn.Linear(500, input_shape) def encode(self, x: torch.Tensor):
x = F.relu(self.encode1(x))
x = F.relu(self.encode2(x))
x = F.relu(self.encode3(x))
return x def decode(self, x: torch.Tensor):
x = F.relu(self.decode1(x))
x = F.relu(self.decode2(x))
x = F.relu(self.decode3(x))
return x def forward(self, x: torch.Tensor):
x = encode(x)
x = decode(x)
return x
def train_model(data: pd.DataFrame):
net = Network()
optimizer = optim.Adagrad(net.parameters(), lr=1e-3, weight_decay=1e-4)
losses = [] for epoch in range(250):
for batch in get_batches(data)
net.zero_grad()
# Pass batch through
output = net(batch)
# Get Loss + Backprop
loss = loss_fn(output, batch).sum() #
losses.append(loss)
loss.backward()
optimizer.step()
return net, losses
正如咱们在上面看到的，咱们有一个编码函数，它从输入数据的形状开始，而后随着它向下传播到形状为50而下降它的维数。从那里，解码层接受嵌入，而后将其扩展回原来的形状。在训练中，咱们从译码器中取出重构的结果，并取出重构与原始输入的损失。
损失函数的问题
因此如今咱们已经讨论了自动编码器的结构和一个热编码过程，咱们终于能够讨论与使用一个热编码在自动编码器相关的问题，以及如何解决这个问题。当一个自动编码器比较重建到原始输入数据，必须有一些估值之间的距离提出重建和真实的价值。一般，在输出值被认为互不相干的状况下，将使用交叉熵损失或MSE损失。但在咱们的一个热编码的状况下，有几个问题，使系统更复杂:
一列出现1意味着对应的OHE列必须有一个0。即列不是不相交的
OHE向量输入的稀疏性会致使系统选择简单地将大多数列返回0以减小偏差
这些问题结合起来致使上述两个损失(MSE，交叉熵)在重构稀疏OHE数据时无效。下面我将介绍三种损失，它们提供了一个解决方案，或上述问题，并在PyTorch实现它们的代码:
余弦嵌入损失
余弦距离是一种经典的向量距离度量，经常使用于NLP问题中比较字包表示。经过求两个向量之间的余弦来计算距离，计算方法为:
因为该方法可以考虑到各列中二进制值的误差来评估两个向量之间的距离，所以在稀疏嵌入重构中，该方法可以很好地量化偏差。这种损失是迄今为止在PyTorch中最容易实现的，由于它在 Torch.nn.CosineEmbeddingLoss中有一个预先构建的解决方案
loss_function = torch.nn.CosineEmbeddingLoss(reduction='none')# . . . Then during training . . . loss = loss_function(reconstructed, input_data).sum()
loss.backward()
Dice Loss
Dice Loss是一个实现Sørensen-Dice系数[2],这是很是受欢迎的计算机视觉领域的分割任务。简单地说，它是两个集合之间重叠的度量，而且与两个向量之间的Jaccard距离有关。骰子系数对向量中列值的差别高度敏感，利用这种敏感性有效地区分图像中像素的边缘，所以在图像分割中很是流行。Dice Loss为:
PyTorch没有内部实现的Dice Loss。可是在Kaggle上能够在其丢失函数库- Keras & PyTorch[3]中找到一个很好的实现:
class DiceLoss(nn.Module):
def __init__(self, weight=None, size_average=True):
super(DiceLoss, self).__init__()
def forward(self, inputs, targets, smooth=1):
#comment out if your model contains a sigmoid acitvation
inputs = F.sigmoid(inputs)
#flatten label and prediction tensors
inputs = inputs.view(-1)
targets = targets.view(-1)
intersection = (inputs * targets).sum()
dice = (2.*intersection + smooth)/
(inputs.sum() + targets.sum() + smooth)
return 1 - dice
不一样OHE列的单个损失函数
最后，您能够将每一个热编码列视为其自身的分类问题，并承担每一个分类的损失。这是一个多任务学习问题的用例，其中autoencoder正在解决重构输入向量的各个份量的问题。当你有几个/全部的列在你的输入数据时，这个工做最好。例如，若是您有一个编码列，前7列是7个类别:您能够将其视为一个多类分类问题，并将损失做为子问题的交叉熵损失。而后，您能够将子问题的损失合并在一块儿，并将其做为整个批的损失向后传递。
下面您将看到这个过程的示例，其中示例有三个热编码的列，每一个列有50个类别。
from torch.nn.modules import _Loss
from torch import argmaxclass CustomLoss(_Loss):
def __init__(self):
super(CustomLoss, self).__init__() def forward(self, input, target):
""" loss function called at runtime """
# Class 1 - Indices [0:50]
class_1_loss = F.nll_loss(
F.log_softmax(input[:, 0:50], dim=1),
argmax(target[:, 0:50])
) # Class 2 - Indices [50:100]
class_2_loss = F.nll_loss(
F.log_softmax(input[:, 50:100], dim=1),
argmax(target[:, 50:100])
) # Class 3 - Indices [100:150]
class_3_loss = F.nll_loss(
F.log_softmax(input[:, 100:150], dim=1),
argmax(target[:, 100:150])
) return class_1_loss + class_2_loss + class_3_loss
在上面的代码中，您能够看到重构输出的子集是如何承受个体损失的，而后在最后将其合并为一个总和。这里咱们使用了一个负对数似然损失(nll_loss)，它是一个很好的损失函数用于多类分类方案，并与交叉熵损失有关。
总结
在本文中，咱们浏览了一个独热编码分类变量的概念，以及自动编码器的通常结构和目标。咱们讨论了一个热编码向量的缺点，以及在尝试训练稀疏的、一个独热编码数据的自编码器模型时的主要问题。最后，咱们讨论了解决稀疏一热编码问题的3个损失函数。训练这些网络并无更好或更坏的损失，在我所介绍的功能中，没有办法知道哪一个是适合您的用例的，除非您尝试它们!
下面我提供了一些深刻讨论上述主题的资源，以及一些我提供的关于丢失函数的资源。
资源
D.E. Rumelhart, G.E. Hinton, and R.J. Williams, “Learning internal representations by error propagation.” Parallel Distributed Processing. Vol 1: Foundations. MIT Press, Cambridge, MA, 1986.
Sørensen, T. (1948). “A method of establishing groups of equal amplitude in plant sociology based on similarity of species and its application to analyses of the vegetation on Danish commons”. Kongelige Danske Videnskabernes Selskab. 5 (4): 1–34. *AND* Dice, Lee R. (1945). “Measures of the Amount of Ecologic Association Between Species”. Ecology. 26 (3): 297–302.
Kaggle's Loss Function Library: https://www.kaggle.com/bigironsphere/loss-function-library-keras-pytorch
做者:Nick Hespe
deephub翻译组
本文分享自微信公众号 - DeepHub IMBA（deephub-imba）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。