深度學習推薦系統(tǒng)(四)Wide&Deep模型及其在Criteo數(shù)據(jù)集上的應(yīng)用

在2016年， 隨著微軟的Deep Crossing， 谷歌的Wide&Deep以及FNN、PNN等一大批優(yōu)秀的深度學習模型被提出， 推薦系統(tǒng)全面進入了深度學習時代， 時至今日， 依然是主流。 推薦模型主要有下面兩個進展：

• 與傳統(tǒng)的機器學習模型相比， 深度學習模型的表達能力更強， 能夠挖掘更多數(shù)據(jù)中隱藏的模式

• 深度學習模型結(jié)構(gòu)非常靈活， 能夠根據(jù)業(yè)務(wù)場景和數(shù)據(jù)特點， 靈活調(diào)整模型結(jié)構(gòu)， 使模型與應(yīng)用場景完美契合

深度學習推薦模型，以多層感知機(MLP)為核心， 通過改變神經(jīng)網(wǎng)絡(luò)結(jié)構(gòu)進行演化。

1 Wide&Deep模型原理

1.1 Wide&Deep模型提出的背景

• 簡單的模型， 比如協(xié)同過濾， 邏輯回歸等，能夠從歷史數(shù)據(jù)中學習到高頻共現(xiàn)的特征組合能力， 但是泛化能力不足

• 而像矩陣分解， embedding再加上深度學習網(wǎng)絡(luò)， 能夠利用相關(guān)性的傳遞性去探索歷史數(shù)據(jù)中未出現(xiàn)的特征組合， 挖掘數(shù)據(jù)潛在的關(guān)聯(lián)模式， 但是對于某些特定的場景(數(shù)據(jù)分布長尾， 共現(xiàn)矩陣稀疏高秩）很難有效學習低緯度的表示， 造成推薦的過渡泛化。

因此，在2016年，Google提出Wide&Deep模型，將線性模型與DNN很好的結(jié)合起來，在提高模型泛化能力的同時，兼顧模型的記憶性。Wide&Deep這種線性模型與DNN的并行連接模式，后來成為推薦領(lǐng)域的經(jīng)典模式， 奠定了后面深度學習模型的基礎(chǔ)，是一個里程碑式的改變。

1.2 模型的記憶能力和泛化能力

1.2.1 記憶能力的理解

記憶能力可以被理解為模型直接學習并利用歷史數(shù)據(jù)中物品和特征的共現(xiàn)頻率的能力。

一般來說， 協(xié)同過濾、邏輯回歸這種都具有較強的“記憶能力”, 由于這類模型比較簡單， 原始數(shù)據(jù)往往可以直接影響推薦結(jié)果， 產(chǎn)生類似于如果點擊A， 就推薦B這類規(guī)則的推薦， 相當于模型直接記住了歷史數(shù)據(jù)的分布特點， 并利用這些記憶進行推薦。

以谷歌APP推薦場景為例理解一下：

假設(shè)在Google Play推薦模型訓練過程中，設(shè)置如下組合特征：AND(user_installed_app=netflix,
impression_app=pandora)，它代表了用戶安裝了netflix這款應(yīng)用，而且曾在應(yīng)用商店中看到過pandora這款應(yīng)用。

如果以“最終是否安裝pandora”為標簽，可以輕而易舉的統(tǒng)計netfilx&pandora這個特征與安裝pandora標簽之間的共現(xiàn)頻率。比如二者的共現(xiàn)頻率高達10%，那么在設(shè)計模型的時候，就希望模型只要發(fā)現(xiàn)這一特征，就推薦pandora這款應(yīng)用(像一個深刻記憶點一樣印在腦海)，這就是所謂的“記憶能力”。

像邏輯回歸這樣的模型，發(fā)現(xiàn)這樣的強特，就會加大權(quán)重，對這種特征直接記憶。
但是對于神經(jīng)網(wǎng)絡(luò)這樣的模型來說，特征會被多層處理，不斷與其他特征進行交叉，因此模型這個強特記憶反而沒有簡單模型的深刻。

1.2.2 泛化能力的理解

泛化能力可以被理解為模型傳遞特征的相關(guān)性， 以及發(fā)掘稀疏甚至從未出現(xiàn)過的稀有特征與最終標簽相關(guān)性的能力。

比如矩陣分解， embedding等， 使得數(shù)據(jù)稀少的用戶或者物品也能生成隱向量， 從而獲得由數(shù)據(jù)支撐的推薦得分， 將全局數(shù)據(jù)傳遞到了稀疏物品上， 提高泛化能力。

再比如神經(jīng)網(wǎng)絡(luò)， 通過特征自動組合， 可以深度發(fā)掘數(shù)據(jù)中的潛在模式，提高泛化等。

所以， Wide&Deep模型的直接動機就是將兩者進行融合， 使得模型既有了簡單模型的這種“記憶能力”， 也有了神經(jīng)網(wǎng)絡(luò)的這種“泛化能力”, 這也是記憶與泛化結(jié)合的偉大模式的初始嘗試。

1.3 Wide&Deep的模型結(jié)構(gòu)

經(jīng)典的W&D的模型如圖所示:

• 左邊的是wide部分， 也就是一個簡單的線性模型， 右邊是deep部分， 一個經(jīng)典的DNN模型

• W&D模型把單輸入層的Wide部分和Embedding+多層的全連接的部分(deep部分)連接起來， 一起輸入最終的輸出層得到預(yù)測結(jié)果

• 單層的wide層善于處理大量的稀疏的id類特征， Deep部分利用深層的特征交叉， 挖掘在特征背后的數(shù)據(jù)模式。 最終， 利用邏輯回歸， 輸出層部分和Deep組合起來， 形成統(tǒng)一的模型。

1.3.1 Wide部分

• 對于wide部分訓練時候使用的優(yōu)化器是帶正則的FTRL算法(Follow-the-regularized-leader)，可以把FTRL當作一個稀疏性很好，精度又不錯的隨機梯度下降方法， 該算法是非常注重模型稀疏性質(zhì)的。

• 也就是說W&D模型采用L1 FTRL是想讓Wide部分變得更加的稀疏，即Wide部分的大部分參數(shù)都為0，這就大大壓縮了模型權(quán)重及特征向量的維度。

• Wide部分模型訓練完之后留下來的特征都是非常重要的，模型的“記憶能力”可以理解為發(fā)現(xiàn)"直接的"，“暴力的”，“顯然的”關(guān)聯(lián)規(guī)則的能力。

1.3.2 Deep部分

• Deep部分主要是一個Embedding+MLP的神經(jīng)網(wǎng)絡(luò)模型。

• 大規(guī)模稀疏特征通過embedding轉(zhuǎn)化為低維密集型特征。然后特征進行拼接輸入到MLP中，挖掘藏在特征背后的數(shù)據(jù)模式。

• 輸入的特征有兩類， 一類是數(shù)值型特征， 一類是類別型特征(經(jīng)過embedding)。

• DNN模型隨著層數(shù)的增加，中間的特征就越抽象，也就提高了模型的泛化能力。

• 對于Deep部分的DNN模型作者使用了深度學習常用的優(yōu)化器AdaGrad，這也是為了使得模型可以得到更精確的解。

1.3.3 Wide&Deep的模型詳細結(jié)構(gòu)

從上圖我們可以詳細地了解Google Play推薦團隊設(shè)計的 Wide&Deep 模型到底將哪些特征作為 Deep 部分的輸入，將哪些特征作為 Wide 部分的輸入。

• Wide 部分的輸入僅僅是已安裝應(yīng)用和曝光應(yīng)用兩類特征，其中已安裝應(yīng)用代表用戶的歷史行為，而曝光應(yīng)用代表當前的待推薦應(yīng)用。選擇這兩類特征的原因是充分發(fā)揮 Wide部分記憶能力強的優(yōu)勢。

• Deep 部分的輸入是全量的特征向量，包括用戶年齡 (Age )、已安裝應(yīng)用數(shù)量(#App Installs )、設(shè)備類型(Device Class )、已安裝應(yīng)用(User Installed App)、曝光應(yīng)用(Impression App)等特征。已安裝應(yīng)用、曝光應(yīng)用等類別型特征，需要經(jīng)過 Embedding 層輸人連接層(Concatenated Embedding)，拼接成1200維的再依次經(jīng)過3層ReLU全連接層，最終輸入 LogLoss 輸出層Embedding向量。

1.4 Wide&Deep模型代碼

import torch.nn as nn
import torch.nn.functional as F
import torchclass Linear(nn.Module):"""Linear part"""def __init__(self, input_dim):super(Linear, self).__init__()self.linear = nn.Linear(in_features=input_dim, out_features=1)def forward(self, x):return self.linear(x)class Dnn(nn.Module):"""Dnn part"""def __init__(self, hidden_units, dropout=0.5):"""hidden_units: 列表， 每個元素表示每一層的神經(jīng)單元個數(shù)， 比如[256, 128, 64], 兩層網(wǎng)絡(luò)， 第一層神經(jīng)單元128， 第二層64， 第一個維度是輸入維度dropout: 失活率"""super(Dnn, self).__init__()self.dnn_network = nn.ModuleList([nn.Linear(layer[0], layer[1]) for layer in list(zip(hidden_units[:-1], hidden_units[1:]))])self.dropout = nn.Dropout(p=dropout)def forward(self, x):for linear in self.dnn_network:x = linear(x)x = F.relu(x)x = self.dropout(x)return x'''
WideDeep模型：主要包括Wide部分和Deep部分
'''
class WideDeep(nn.Module):def __init__(self, feature_info, hidden_units, embed_dim=8):"""DeepCrossing：feature_info: 特征信息（數(shù)值特征， 類別特征， 類別特征embedding映射)hidden_units: 列表， 隱藏單元dropout: Dropout層的失活比例embed_dim: embedding維度"""super(WideDeep, self).__init__()self.dense_features, self.sparse_features, self.sparse_features_map = feature_info# embedding層， 這里需要一個列表的形式， 因為每個類別特征都需要embeddingself.embed_layers = nn.ModuleDict({'embed_' + str(key): nn.Embedding(num_embeddings=val, embedding_dim=embed_dim)for key, val in self.sparse_features_map.items()})# 統(tǒng)計embedding_dim的總維度# 一個離散型(類別型)變量 通過embedding層變?yōu)?緯embed_dim_sum = sum([embed_dim] * len(self.sparse_features))# 總維度 = 數(shù)值型特征的緯度 + 離散型變量經(jīng)過embedding后的緯度dim_sum = len(self.dense_features) + embed_dim_sumhidden_units.insert(0, dim_sum)# dnn網(wǎng)絡(luò)self.dnn_network = Dnn(hidden_units)# 線性層self.linear = Linear(input_dim=len(self.dense_features))# 最終的線性層self.final_linear = nn.Linear(hidden_units[-1], 1)def forward(self, x):# 1、先把輸入向量x分成兩部分處理、因為數(shù)值型和類別型的處理方式不一樣dense_input, sparse_inputs = x[:, :len(self.dense_features)], x[:, len(self.dense_features):]# 2、轉(zhuǎn)換為long形sparse_inputs = sparse_inputs.long()# 2、不同的類別特征分別embeddingsparse_embeds = [self.embed_layers['embed_' + key](sparse_inputs[:, i]) for key, i inzip(self.sparse_features_map.keys(), range(sparse_inputs.shape[1]))]# 3、把類別型特征進行拼接,即emdedding后，由3行轉(zhuǎn)換為1行sparse_embeds = torch.cat(sparse_embeds, axis=-1)# 4、數(shù)值型和類別型特征進行拼接dnn_input = torch.cat([sparse_embeds, dense_input], axis=-1)# Wide部分，使用的特征為數(shù)值型類型wide_out = self.linear(dense_input)# Deep部分，使用全部特征deep_out = self.dnn_network(dnn_input)deep_out = self.final_linear(deep_out)# out  將Wide部分的輸出和Deep部分的輸出進行合并outputs = F.sigmoid(0.5 * (wide_out + deep_out))return outputsif __name__ == '__main__':x = torch.rand(size=(1, 5), dtype=torch.float32)feature_info = [['I1', 'I2'],  # 連續(xù)性特征['C1', 'C2', 'C3'],  # 離散型特征{'C1': 20,'C2': 20,'C3': 20}]# 建立模型hidden_units = [256, 128, 64]net = WideDeep(feature_info, hidden_units)print(net)print(net(x))

WideDeep((embed_layers): ModuleDict((embed_C1): Embedding(20, 8)(embed_C2): Embedding(20, 8)(embed_C3): Embedding(20, 8))(dnn_network): Dnn((dnn_network): ModuleList((0): Linear(in_features=26, out_features=256, bias=True)(1): Linear(in_features=256, out_features=128, bias=True)(2): Linear(in_features=128, out_features=64, bias=True))(dropout): Dropout(p=0.5, inplace=False))(linear): Linear((linear): Linear(in_features=2, out_features=1, bias=True))(final_linear): Linear(in_features=64, out_features=1, bias=True)
)
tensor([[0.6531]], grad_fn=<SigmoidBackward0>)

2 Wide&Deep模型在Criteo數(shù)據(jù)集的應(yīng)用

數(shù)據(jù)的預(yù)處理及一些函數(shù)或類可以參考：

深度學習推薦系統(tǒng)(二)Deep Crossing及其在Criteo數(shù)據(jù)集上的應(yīng)用

2.1 準備訓練數(shù)據(jù)

import pandas as pdimport torch
from torch.utils.data import TensorDataset, Dataset, DataLoaderimport torch.nn as nn
from sklearn.metrics import auc, roc_auc_score, roc_curveimport warnings
warnings.filterwarnings('ignore')

# 封裝為函數(shù)
def prepared_data(file_path):# 讀入訓練集，驗證集和測試集train_set = pd.read_csv(file_path + 'train_set.csv')val_set = pd.read_csv(file_path + 'val_set.csv')test_set = pd.read_csv(file_path + 'test.csv')# 這里需要把特征分成數(shù)值型和離散型# 因為后面的模型里面離散型的特征需要embedding， 而數(shù)值型的特征直接進入了stacking層， 處理方式會不一樣data_df = pd.concat((train_set, val_set, test_set))# 數(shù)值型特征直接放入stacking層dense_features = ['I' + str(i) for i in range(1, 14)]# 離散型特征需要需要進行embedding處理sparse_features = ['C' + str(i) for i in range(1, 27)]# 定義一個稀疏特征的embedding映射， 字典{key: value},# key表示每個稀疏特征， value表示數(shù)據(jù)集data_df對應(yīng)列的不同取值個數(shù)， 作為embedding輸入維度sparse_feas_map = {}for key in sparse_features:sparse_feas_map[key] = data_df[key].nunique()feature_info = [dense_features, sparse_features, sparse_feas_map]  # 這里把特征信息進行封裝， 建立模型的時候作為參數(shù)傳入# 把數(shù)據(jù)構(gòu)建成數(shù)據(jù)管道dl_train_dataset = TensorDataset(# 特征信息torch.tensor(train_set.drop(columns='Label').values).float(),# 標簽信息torch.tensor(train_set['Label'].values).float())dl_val_dataset = TensorDataset(# 特征信息torch.tensor(val_set.drop(columns='Label').values).float(),# 標簽信息torch.tensor(val_set['Label'].values).float())dl_train = DataLoader(dl_train_dataset, shuffle=True, batch_size=16)dl_vaild = DataLoader(dl_val_dataset, shuffle=True, batch_size=16)return feature_info,dl_train,dl_vaild,test_set

file_path = './preprocessed_data/'feature_info,dl_train,dl_vaild,test_set = prepared_data(file_path)

2.2 建立Wide&Deep模型

from _01_wide_deep import WideDeephidden_units = [256, 128, 64]
net = WideDeep(feature_info, hidden_units)

2.3 模型的訓練

from AnimatorClass import Animator
from TimerClass import Timer# 模型的相關(guān)設(shè)置
def metric_func(y_pred, y_true):pred = y_pred.datay = y_true.datareturn roc_auc_score(y, pred)def try_gpu(i=0):if torch.cuda.device_count() >= i + 1:return torch.device(f'cuda:{i}')return torch.device('cpu')def train_ch(net, dl_train, dl_vaild, num_epochs, lr, device):"""?GPU訓練模型"""print('training on', device)net.to(device)# 二值交叉熵損失loss_func = nn.BCELoss()# 注意：這里沒有使用原理提到的優(yōu)化器optimizer = torch.optim.Adam(params=net.parameters(), lr=lr)animator = Animator(xlabel='epoch', xlim=[1, num_epochs],legend=['train loss', 'train auc', 'val loss', 'val auc'],figsize=(8.0, 6.0))timer, num_batches = Timer(), len(dl_train)log_step_freq = 10for epoch in range(1, num_epochs + 1):# 訓練階段net.train()loss_sum = 0.0metric_sum = 0.0for step, (features, labels) in enumerate(dl_train, 1):timer.start()# 梯度清零optimizer.zero_grad()# 正向傳播predictions = net(features)loss = loss_func(predictions, labels.unsqueeze(1) )try:          # 這里就是如果當前批次里面的y只有一個類別， 跳過去metric = metric_func(predictions, labels)except ValueError:pass# 反向傳播求梯度loss.backward()optimizer.step()timer.stop()# 打印batch級別日志loss_sum += loss.item()metric_sum += metric.item()if step % log_step_freq == 0:animator.add(epoch + step / num_batches,(loss_sum/step, metric_sum/step, None, None))# 驗證階段net.eval()val_loss_sum = 0.0val_metric_sum = 0.0for val_step, (features, labels) in enumerate(dl_vaild, 1):with torch.no_grad():predictions = net(features)val_loss = loss_func(predictions, labels.unsqueeze(1))try:val_metric = metric_func(predictions, labels)except ValueError:passval_loss_sum += val_loss.item()val_metric_sum += val_metric.item()if val_step % log_step_freq == 0:animator.add(epoch + val_step / num_batches, (None,None,val_loss_sum / val_step , val_metric_sum / val_step))print(f'final: loss {loss_sum/len(dl_train):.3f}, auc {metric_sum/len(dl_train):.3f},'f' val loss {val_loss_sum/len(dl_vaild):.3f}, val auc {val_metric_sum/len(dl_vaild):.3f}')print(f'{num_batches * num_epochs / timer.sum():.1f} examples/sec on {str(device)}')

lr, num_epochs = 0.001, 10
# 其實發(fā)生了過擬合
train_ch(net, dl_train, dl_vaild, num_epochs, lr, try_gpu())

2.4 模型的預(yù)測

y_pred_probs = net(torch.tensor(test_set.values).float())
y_pred = torch.where(y_pred_probs>0.5,torch.ones_like(y_pred_probs),torch.zeros_like(y_pred_probs)
)
y_pred.data[:10]