精华内容
下载资源
问答
  • wide的用法
    2021-07-01 04:38:09

    having great (or a certain) extent from one side to the other;

    "wide roads"

    "a wide necktie"

    "wide margins"

    "three feet wide"

    "a river two miles broad"

    "broad shoulders"

    "a broad river"

    broad in scope or content;

    "across-the-board pay increases"

    "an all-embracing definition"

    "blanket sanctions against human-rights violators"

    "an invention with broad applications"

    "a panoptic study of Soviet nationality"

    "granted him wide powers"

    (used of eyes) fully open or extended;

    "stared with wide eyes"

    very large in expanse or scope;

    "a broad lawn"

    "the wide plains"

    "a spacious view"

    "spacious skies"

    great in degree;

    "won by a wide margin"

    having ample fabric;

    "the current taste for wide trousers"

    "a full skirt"

    not on target;

    "the kick was wide"

    "the arrow was wide of the mark"

    "a claim that was wide of the truth"

    更多相关内容
  • # 多输入,使用函数式方法 input_wide = keras.layers.Input(shape=[5]) #取前5个feature做为wide模型的输入 input_deep = keras.layers.Input(shape=[6]) ##取后6个feature做为wide模型的输入 hidden1 = keras....
  • 可以通过导入wide_residial_network脚本并使用create_wide_residual_network()方法使用它。 可以更改几个参数以增加网络的深度或宽度。 请注意,可以通过以下公式计算层数: nb_layers = 4 + 6 * N 因此,N可以...
  • 推荐系统(五)wide&deep 推荐系统系列博客: 推荐系统(一)推荐系统整体概览 推荐系统(二)GBDT+LR模型 推荐系统(三)Factorization Machines(FM) 推荐系统(四)Field-aware Factorization Machines...

    推荐系统(五)wide&deep模型

    推荐系统系列博客:

    1. 推荐系统(一)推荐系统整体概览
    2. 推荐系统(二)GBDT+LR模型
    3. 推荐系统(三)Factorization Machines(FM)
    4. 推荐系统(四)Field-aware Factorization Machines(FFM)

    这篇博客主要介绍谷歌于2016年发表在RecSys上的一篇文章,俗话说:谷歌家出品,必属精品。这篇文章提出的模型wide&deep着实对推荐系统领域有着非常大的影响,启发了后面几年推荐系统领域的一些工作,比如:deep&cross,deepFM等。这篇文章也是秉承着G家文章一贯的风格【大道至简,非常关注工程实践】,不像国内某互联网公司某团队的paper简直是概念的堆砌,如果没有概念就造概念,让人看的眼花缭乱,明显是冲着发论文去的。这篇博客主要以下几个点来介绍下wide&deep模型。

    一、提出wide&deep的动机

    在这篇论文之前,工业界推荐系统主流的模型基本是LR或者普通的DNN(当然也有像FM和树模型及其变种),通常而言,线性模型比如LR比较擅长记忆,而DNN则比较擅长泛化。这里来解释下何为记忆,何为泛化。

    • 记忆: 其实就是模型直接学到样本中一些强特征,比如,尿布&瓶酒的例子,如果样本中频繁出现了买了尿布的人同时买了啤酒,也就是说尿布&啤酒共现的频率很高,那么模型可以直接记住这种共现,当做推荐的时候,如果一个人买了尿布,那么应该给他推荐啤酒。
    • 泛化: 泛化则是学习特征的传递能力,比如某个训练集为树叶,label为判断输入的东西是否是一个树叶,样本中的树叶基本都是绿色的锯齿状树叶,那么我们希望模型能够有泛化能力,当输入一个泛黄的圆形树叶,模型也能判断出这是个树叶。

    因此,为了结合这两种能力,提出了wide&deep模型,wide侧为一个LR模型,负责记忆,deep部分为一个多层全连接网络,负责泛化。

    二、wide&deep模型结构

    wide&deep

    wide&deep模型结构(图片来自谷歌原始论文)

    从上图能够非常清晰的看到wide&deep模型包含两个部分,wide部分和deep部分。wide部分为一个线性模型LR,deep部分为一个三层隐藏层[1024,512,256]的DNN。模型网络结构虽然简直直白,但有几个细节需要关注下:

    1. 训练方式: wide部分和deep部分使用logistics loss连接在一起,通过bp联合训练,而不是单独训练然后做ensemble。
    2. 优化算法: wide部分采用G家出产的FTRL优化算法(关于FTRL后面会单独写一篇博客),deep部分采用AdaGrad(关于AdaGrad参见本人的博客:深度学习中优化方法——momentum、Nesterov Momentum、AdaGrad、Adadelta、RMSprop、Adam)那么随之而来的2个问题:(a)两个不同的优化算法放在一起怎么优化?(b)为什么LR部分采用ftrl,而deep部分采用AdaGrad。 这两个问题留到博客最后的【一些思考】里再介绍。
    3. 特征: 在Google play的场景下主要分为连续值特征和类别特征,在这篇论文中,连续值特征被归一化到[0,1]范围内,类别特征则做了embedding,然后直接做了concate,输入到deep网络中。wide部分主要输入的是一些交叉特征,用于记忆。
    4. 模型训练: 采用热启的方式训练模型,上一次(天级别或者小时级)的模型embedding向量和权重初始化下一个时间的模型(ented a warm-starting system which initializes a new model with the embeddings and the linear model weights from the previous model.)。这一点和我厂的abacus保持一致。这样做的好处显而易见,lifetime learning + Fine Tune。
    5. 模型更新校验: 每次更新到线上之前要做一次校验,校验待更新的模型是否正常,防止把有问题的模型更新到线上,发生问题。这一点透露着浓浓的工业风,也是一个工业系统必备的环节。

    三、一些思考

    问题1: wide部分和deep采用联合训练,但wide部分采用FTRL优化算法,deep部分采用AdaGrad优化算法,这个该怎么训练?
    这个问题直接看TensorFlow官方代码:https://github.com/tensorflow/tensorflow/blob/r1.11/tensorflow/python/estimator/canned/dnn_linear_combined.py
    deep侧:

    # deep侧
    with variable_scope.variable_scope(
            dnn_parent_scope,
            values=tuple(six.itervalues(features)),
            partitioner=dnn_partitioner) as scope:
          dnn_absolute_scope = scope.name
          dnn_logit_fn = dnn._dnn_logit_fn_builder(  # pylint: disable=protected-access
              units=head.logits_dimension,
              hidden_units=dnn_hidden_units,
              feature_columns=dnn_feature_columns,
              activation_fn=dnn_activation_fn,
              dropout=dnn_dropout,
              input_layer_partitioner=input_layer_partitioner,
              batch_norm=batch_norm)
          dnn_logits = dnn_logit_fn(features=features, mode=mode)
    
    

    wide侧:

    # wide侧
        with variable_scope.variable_scope(
            linear_parent_scope,
            values=tuple(six.itervalues(features)),
            partitioner=input_layer_partitioner) as scope:
          linear_absolute_scope = scope.name
          logit_fn = linear._linear_logit_fn_builder(  # pylint: disable=protected-access
              units=head.logits_dimension,
              feature_columns=linear_feature_columns,
              sparse_combiner=linear_sparse_combiner)
          linear_logits = logit_fn(features=features)
    

    loss直接把wide部分的loss和deep部分的loss相加

    # loss函数
     if n_classes == 2:
          head = head_lib._binary_logistic_head_with_sigmoid_cross_entropy_loss(  # pylint: disable=protected-access
              weight_column=weight_column,
              label_vocabulary=label_vocabulary,
              loss_reduction=loss_reduction)
        else:
          head = head_lib._multi_class_head_with_softmax_cross_entropy_loss(  # pylint: disable=protected-access
              n_classes,
              weight_column=weight_column,
              label_vocabulary=label_vocabulary,
              loss_reduction=loss_reduction)
              
      # Combine logits and build full model.
      if dnn_logits is not None and linear_logits is not None:
        logits = dnn_logits + linear_logits
      elif dnn_logits is not None:
        logits = dnn_logits
      else:
        logits = linear_logits
    

    *BP时,采用不用的优化器优化wide侧和deep侧,这里核心语句在于:train_op = control_flow_ops.group(train_ops),从而做到了可以用不同的优化器来优化两侧。

      def _train_op_fn(loss):
        """Returns the op to optimize the loss."""
        train_ops = []
        global_step = training_util.get_global_step()
        if dnn_logits is not None:
          train_ops.append(
              dnn_optimizer.minimize(
                  loss,
                  var_list=ops.get_collection(
                      ops.GraphKeys.TRAINABLE_VARIABLES,
                      scope=dnn_absolute_scope)))
        if linear_logits is not None:
          train_ops.append(
              linear_optimizer.minimize(
                  loss,
                  var_list=ops.get_collection(
                      ops.GraphKeys.TRAINABLE_VARIABLES,
                      scope=linear_absolute_scope)))
    	# 核心语句,采用group函数
        train_op = control_flow_ops.group(*train_ops)
        with ops.control_dependencies([train_op]):
          return state_ops.assign_add(global_step, 1).op
    
      return head.create_estimator_spec(
          features=features,
          mode=mode,
          labels=labels,
          train_op_fn=_train_op_fn,
          logits=logits)
    

    问题2: 为什么wide侧采用FTRL,而deep侧采用AdaGrad?
    我个人觉得在wide侧采用FTRL,一方面是为了产生稀疏解,毕竟在论文中能够看到wide部分的交叉特征是两个id特征的交叉,这样可以大大缩小模型体积,利于线上部署。另外一方面,由于联合训练,必然会出现wide部分收敛速度远远快于deep部分,应该是谷歌大佬们为了缓解这种情况,因为ftrl和adagrad都是随着梯度的累计,学习率会变小,并且ftrl结合了L1正则和L2正则,使得ftrl收敛速度慢。
    注:这一点只是个人理解,如果有大佬有更好的理解,欢迎留言交流。







    参考文献

    [1]: Wide & Deep Learning for Recommender Systems

    展开全文
  • Wide&Deep模型实现

    2022-07-14 10:51:11
    Wide&Deep模型——研究Google论文后的复现

    1.综述:在DNN模型基础上增加一个线性模型来辅助记忆某些关键的特征,如Google play中的例子为用户安装的app名称和曝光app的名称。模型上边的 Wide 部分,可以容纳大规模系数特征,并且对一些特定的信息(比如 ID)有一定的记忆能力; 而模型下边的 Deep 部分,能够学习特征间的隐含关系,在相同数量的特征下有更好的学习和推导能力。

    2.模型代码思路概述:我们认为Wide部分可以进行将全部类别特征转坏为multihot然后再和数值特征结合再训练的方法,Wide部分处理稀疏性特征的优势也就能够体现出来。Deep部分则是和DNN模型处理相同,我们对类别特征需要进行3层神经网络的Dense,然后再与数值特征进行结合输出。

     3.模型代码:

    import gzip
    import matplotlib.pyplot as plt
    import numpy as np
    import sklearn
    import pandas as pd 
    import os
    import sys
    import tensorflow as tf
    from tensorflow import keras 
    import random
    
    # tf.config.run_functions_eagerly(True)
    
    # numerical特征可以直接输入,但category特征需要进行multi_hot_embedding转换再和numerical进行组合进行wide部分输出
    # Deep部分则是直接对category特征进行dense embedding然后再和numerical特征组合进行deep部分输出
    
    class Wide_layer(keras.layers.Layer):
        def __init__(self):
            super(Wide_layer, self).__init__()
            # multi_hot_emb中的num_tokens是总共分类数,也就是describe中unique部分
            # self.num_tokens=category_feature.astype('object').describe().loc['unique'].sum()
            self.num_tokens=1000
            self.multi_hot_emb = tf.keras.layers.CategoryEncoding(num_tokens=self.num_tokens, output_mode='multi_hot', sparse=False)
    
        def Wide_layer(self,numerical_feature,category_feature,training= False):
            category_feature_hot=self.multi_hot_emb(category_feature)
            wide_colunms=tf.concat([numerical_feature, category_feature_hot],axis=1)
            return wide_colunms
    
    # one_hot特征和numerical特征二者concat进入deep模型得到logit
    class Deep_layer(keras.layers.Layer):
        """
        Dnn模型中的layer输入,3层输入,激活函数为RELU
        其中的total_cat_size应当是describe()中unique整行的sum
        total_cat_emb_dim是embedding的维度数
        input_cat_num是输入的cat类特征的全部取值维度(shape的第二个取值)
        """
        def __init__(self):
            super(Deep_layer, self).__init__()
            self.total_cat_size=1000
            self.total_cat_emb_dim=128
            self.embedding=tf.keras.layers.Embedding(self.total_cat_size,self.total_cat_emb_dim,name="deep_emb")
            self.dense1=tf.keras.layers.Dense(units=1024,activation="relu",name="deep_dense1")
            self.dense2=tf.keras.layers.Dense(units=512,activation="relu",name="deep_dense2")                
            self.dense3=tf.keras.layers.Dense(units=256,activation="relu",name="deep_dense3")
            self.dropout=tf.keras.layers.Dropout(0.1)
        def call(self,numerical_feature,category_feature,training= False):
            # 需要自己分析
            # 简化后直接自己定义,在特征工程时处理即可
            deep_category_feature_emb=self.embedding(category_feature)
            # print(f"deep_category_feature_emb:{deep_category_feature_emb}")
            # print(f"deep_category_feature_emb shape:{deep_category_feature_emb.shape}")
            # input("wait...")
            input_cat_num=np.shape(category_feature)[1]
            deep_category_feature_emb=tf.reshape(deep_category_feature_emb,shape=[-1,self.total_cat_emb_dim*input_cat_num])
            deep_columns=tf.concat([numerical_feature, deep_category_feature_emb],axis=1)
            deep_columns=self.dense1(deep_columns)
            deep_columns=self.dense2(deep_columns)
            deep_columns=self.dense3(deep_columns)
            if training:
                deep_columns=self.dropout(deep_columns)
            return deep_columns
    
    class WideDeepModel(keras.models.Model):
        """
        Wide&Deep模型整体代码
        wide_w, deep_w:最后输入
        activation:激活函数使用sigmoid因为可以利用sigmoid函数将输出压缩至(0,1)之中
        self.wide不使用是因为可以省略,因为wide_features直接输出即可
        """
        def __init__(self):
            super(WideDeepModel, self).__init__()
            self.wide_w=tf.keras.layers.Dense(1,activation=None, use_bias=False, name="wide_w")
            self.deep_w=tf.keras.layers.Dense(1,activation=None, use_bias=False, name="deep_w")
            self.bias=tf.Variable([np.random.randn()], name="deep_bias", trainable=True)
            self.activation=tf.keras.layers.Activation("sigmoid")
            self.deep=Deep_layer()
            self.wide=Wide_layer()
        
        # @tf.function
        def call(self,features,training=False):
            # 注意必须要四个部分输入,因为wide_out和deep_out两个冲突。同时也直接分类,num1和cat1可以直接输出wide部分
            # 而num2和cat2可以直接输出deep部分
            deep_features = features
            wide_features = features
            numerical_feature1=wide_features[0]
            category_feature1=wide_features[1]
            numerical_feature2=deep_features[0]
            category_feature2=deep_features[1]
            wide_out=self.wide(numerical_feature1,category_feature1,training)
            # print(wide_out)
            deep_out=self.deep(numerical_feature2,category_feature2,training)
            # print(deep_out)
            logits = self.wide_w(wide_out) +self.deep_w(deep_out)+self.bias # output_bias
            # print(logits)
            logits=self.activation(logits)
            return logits
        
    
    
    @tf.function
    def train_one_step(input,label, model, optimizer):
        with tf.GradientTape() as tape:
            logits = model(input)
            loss = tf.reduce_mean(tf.keras.losses.binary_crossentropy(label,logits), axis=0)
            grads = tape.gradient(loss, model.trainable_weights)
            optimizer.apply_gradients(zip(grads, model.trainable_weights))
        # # wide部分参数优化(ftrl+l1正则)
        # wide_op=tf.keras.optimizers.Ftrl(learning_rate=0.001,l1_regularization_strength=0.01)
        # wide_ops=wide_op.apply_gradients(zip(grads, model.trainable_weights))
        # deep部分参数优化(Adam)
        # tf.group(wide_ops,deep_ops)
        return loss
    
    
    # 循环训练
    def train():
        batch_size=64
        epochs=2
        # 初始化模型及调优参数
        model = WideDeepModel()
        optimizer = keras.optimizers.Adam(learning_rate=1e-5)
    
        # 测试数据
        category_feature=pd.DataFrame(np.random.randint(0,1000,(10000,50)))
        numerical_feature=pd.DataFrame(np.random.normal(0,10,(10000,50)))
    
        pos_labels = np.ones((5000,1))
        neg_labels = np.zeros((5000, 1))
        labels = np.concatenate([pos_labels, neg_labels], axis=0)
        np.random.shuffle(labels)
    
        # step -> Total Data
        step = numerical_feature.shape[0]
    
        for epoch in range(epochs):
            print('\nStart of epoch %d'%(epoch+1,))
            for i in range(0, step, batch_size):
                batch_numerical_features = numerical_feature[i:i+batch_size, :]
                batch_categorical_fratures = category_feature[i:i+batch_size, :]
                batch_labels = labels[i:i+batch_size, :]
                inputs=[batch_numerical_features,batch_categorical_fratures]
    
                # 打印结果
                if i % (batch_size * 10) == 0:
                    print('step: %s'%(i))
                    print('batch: %s'%(i/64))
                    print('loss is %s'%(float(train_one_step(inputs,batch_labels, model, optimizer))))
                else:
                    train_one_step(inputs,batch_labels, model, optimizer)
    
    train()

    展开全文
  • Wide&Deep模型

    2021-11-02 14:20:25
    一:wide&deep 正如其名字一样,模型是由单层的wide部分和多层的Deep部分组成的混合模型,其中wide部分主要作用是让模型具有较强的记忆能力,deep部分主要是让模型具有较强的泛化能力。这样的结构特点,使模型...

    一:wide&deep

    正如其名字一样,模型是由单层的wide部分和多层的Deep部分组成的混合模型,其中wide部分主要作用是让模型具有较强的记忆能力,deep部分主要是让模型具有较强的泛化能力。这样的结构特点,使模型同时具有了逻辑回归和Dnn的优点–能够快速处理并记忆大量历史行为特征,并具有强大的表达能力。模型的结构如下:
    在这里插入图片描述

    二:记忆能力与泛化能力

    (1)记忆能力
    记忆能力可以被理解为模型直接学习并利用历史数据中物品或特征的 ‘共现频率’的能力。例如逻辑回归和系统过滤等模型就具体较强的记忆能力。由于这类模型结构简单,原始数据往往可以直接影响推荐结果,产生类似于“如果点击过A,就推荐B”的强规则推荐,就相当于模型记住了历史数据的分布特点,并利用这些记忆进行推荐。相反,对于多层神经网络来说,特征会被多层处理,不断与其他特征进行交叉,因此模型对某个强特征的记忆能力反而没这么好。
    (2)泛化能力:
    泛化能力可以理解为模型传递特征的相关性,发掘稀疏甚至从未出现过的稀有特征与最终标签相关性的能力 。两个例子:矩阵分解之所以比协同过滤泛化能力强,因为矩阵分解隐向量这样的结构,使得数据稀疏的用户或物品也能生成隐向量,从而获得有数据支撑的推荐得分。二:深度神经网络通过特征的多次自动组合,能够深度发掘数据中的潜在的模式,甚至是非常稀疏的特征向量输入,也能得到较为稳定平滑的概率,这就是简单模型所缺乏的泛化能力。模型的详细结构:

    在这里插入图片描述

    三:Wide&Deep模型结构

    模型的直接动机就是将wide 和deep融合。模型把单输入层的wide部分与embedding 层和多隐层组成的Deep部分链接起来,一起输入最终的输出层。单层的wide部分善于处理大量的稀疏的id类特征,deep部分利用神经网络表达能力强的特点,进行深层的特征交叉,挖掘藏在特征背后的数据模式,最终利用逻辑回归模型,将wide部分和deep部分结合起来,形成统一的模型。
    Wide&Deep Learning
    1,Wide部分
    Wide部分就是基础的线性模型,表示为y=WX+b。X特征部分包括基础特征和交叉特征。交叉特征在wide部分很重要,可以捕捉到特征间的交互,起到添加非线性的作用。交叉特征可表示为:
    在这里插入图片描述
    Cki是一个布尔变量,如果第i个特征是第k个变换的一部分则为1,反之为0.对于二值特征,一个组合特征当原特征都为0的时候才会0(例如“性别=女”且“语言=英语”时,AND(性别=女,语言=英语)=1,其他情况均为0)。这捕获了二元特征之间的相互作用,并为广义线性模型增加了非线性。
    2,deep部分
    Deep部分就是个前馈网络模型。特征首先转换为低维稠密向量,维度通常O(10)-O(100)。向量随机初始化,经过最小化随时函数训练模型。激活函数采用Relu。前馈部分表示如下:
    在这里插入图片描述
    3,Wide&Deep联合训练
    在联合模型中,Wide和Deep部分的输出通过加权方式合并到一起,并通过logistic loss function进行最终输出。对Wide&Deep模型的联合训练通过同时对输出向模型的wide和deep两部分进行梯度的反向传播(back propagating)来实现的,这其中应用了小批量随机优化(mini-batch stochastic optimization)的技术。在实验中,使用了FTRL(Follow-the-regularized-leader)算法以及使用L1正则化来优化wide部分的模型,并使用AdaGrad优化deep部分。

    在这里插入图片描述
    联合训练和模型集成要进行区分,他们有着以下两点区别:

    1,训练方式。 集成模型的子模型部分是独立训练,只在inference阶段合并预测。而联合训练模型是同时训练同时产出的。
    2,模型规模。集成模型独立训练,模型规模要大一些才能达到可接受的效果。而联合训练模型中,Wide部分只需补充Deep模型的缺点,即记忆能力,这部分主要通过小规模的交叉特征实现。因此联合训练模型的Wide部分的模型特征较小。
    补充:为什么wide部分使用FTRL+L1正则化来训练。
    这里简要介绍一下,你可以把FTRL当作一个稀疏性很好,精度又不错的随机梯度下降方法。由于是随机梯度下降,当然可以做到来一个样本就训练一次,进而实现模型的在线更新。所以在四五年前,大部分公司还是线性模型为主的时代,FTRL凭借非常好的在线学习能力成为主流。

    说完了FTRL,再说L1正则化,参加过算法岗面试的同学可能都碰到过那个经典面试题“为什么L1正则化比L2正则化更容易产生稀疏解?”。问题的答案现在当然已经是显学了,但这里“稀疏”这个性质又冒出来了。也就是说FTRL with L1非常注重模型的稀疏性。这也就是问题的答案,W&D采用L1 FTRL是想让Wide部分变得更加稀疏。

    再白话一点就是,L1 FTRL会让Wide部分的大部分权重都为0,我们准备特征的时候就不用准备那么多0权重的特征了,这大大压缩了模型权重,也压缩了特征向量的维度。

    稀疏性不见得一直是一个好东西,它不管怎样都会让模型的精度有一定的损伤。肯定是特征向量维度过高导致“稀疏性”成为了关键的考量。这就涉及到Google Wide部分的特征选取了,在wide部分,Google团队选取了两个id类特征的乘积,这两个id类特征是:User Installed App 和 Impression App
    但是两个id类特征向量进行组合,在维度爆炸的同时,会让原本已经非常稀疏的multihot特征向量,变得更加稀疏。正因如此,wide部分的权重数量其实是海量的。为了不把数量如此之巨的权重都搬到线上进行model serving,采用FTRL过滤掉哪些稀疏特征无疑是非常好的工程经验。
    在这里插入图片描述

    为什么Deep部分不特别考虑稀疏性的问题?

    大家注意观察可以发现Deep部分的输入,要么是Age,#App Installs这些数值类特征,要么是已经降维并稠密化的Embedding向量,工程师们不会也不敢把过度稀疏的特征向量直接输入到Deep网络中。所以Deep部分不存在严重的特征稀疏问题,自然可以使用精度更好,更适用于深度学习训练的AdaGrad去训练。

    四:wide & deep模型的进化–deep$cross模型

    在这里插入图片描述

    模型设计的主要思路是使用corss网络代替原来的wide部分。设计cross网络的主要目的是增加特征之间的交互能力,使用多层交叉层(cross layer)对输入向量进行特征交叉,交叉网络由多个交叉层组成,假设第l层交叉层的输出向量为Xl,那么对于第L+1层交叉层输出向量X l+1为:
    在这里插入图片描述
    可视化结果如下:
    在这里插入图片描述
    可以看到,交叉层操作的二阶部分非常类似于PNN的外积操作,再次基础上增加了外积操作的权重向量wl,以及原输入向量xl和偏置向量bl,但交叉层在增加参数方面是比较克制,每一个仅增加了一个n维权重向量wl,并且在每一层均保留了输入向量,因此输入与输出的变化不会特别明显。cross网络在wide部分的基础之上进行特征的自动化交叉,避免了更多基于业务理解的人工特征组合。

    六:wide & deep模型的优缺点

    优势:
    1,抓住了业务的本质特点,能够融合传统模型的记忆能力和深度神经网络的泛化能力
    2,模型结构不复杂,比较容易在工程上实现训练和上线。
    局限:wide & deep 部分特征还是需要人工进行特征赛选。cross网络的复杂度又较高。

    展开全文
  • 宽行示例 ...注意:这将删除键空间“datastax_widerow_demo”并创建一个新的。 所有现有数据都将丢失。 要指定接触点,请使用contactPoints 命令行参数,例如'-DcontactPoints=192.168.25.100,192.
  • Wide & Deep与Deep

    2020-12-21 17:52:29
    实验结果也表明,Wide & Deep方法要显著的优于wide-only和deep-only方法。下面来看看Wide & Deep内部细节。 推荐系统与搜索排序面临的一大共同挑战就是:如何让模型的结果具有更好的memorization 和 generalization...
  • 推荐系统进入深度学习领域以来,一共讲解了四个使用深度学习的模型了,今天来讲一下Wide&Deep模型,也是具有着里程碑意义的,前面讲解的AutoRec和Deep Crossing模型是在神经网络的复杂度和层数方面进行的进化,...
  • 文章目录摘要简介推荐系统概述Wide & Deep原理Wide部分Deep部分Wide & Deep合并系统实现数据生产模型训练模型服务模型结果App 获取量服务性能代码实现 今天我们剖析的也是推荐领域的经典论文,叫做 Wide &...
  • Wide & Deep模型

    万次阅读 2019-09-11 14:51:00
    Wide&Deep的右边就是DNN部分,左边的FM Function用的是线性回归,其特征组合需要人去设计。 Wide&Deep模型。它混合了一个线性模型(Wide part)和Deep模型(Deep part)。这两部分模型需要不同的输入,而Wide...
  • Wide&Deep简介(二)

    千次阅读 2022-01-17 19:40:54
    1. wide端对应的是线性模型,输入特征可以是连续特征,也可以是稀疏的离散特征,离散特征之间进行交叉后可以构成更高维的离散特征。线性模型训练中通过L1正则化,能够很快收敛到有效的特征组合中。 2. deep端对应的...
  • 推荐系统中的常用算法——Wide & Deep

    万次阅读 2017-10-07 20:10:16
    Deep Learning for Recommender Systems》后的总结,该文章中提出结合Wide模型和Deep模型的组合方法,对于提升推荐系统(Recommendation System)的性能有很重要的作用。 1、背景 本文提出Wide & Deep...
  • wide & deep 特征区别

    千次阅读 2020-11-23 17:01:13
    wide 主要用作学习样本中特征的共现性,产生的结果是和用户有过直接行为的 item,通过少量的交叉特征转换来补充 deep 的弱点 wide侧的输入可以包含了一些交叉特征、离散特征及部分连续特征 其中基φk(x)是0/1布尔...
  • Wide & Deep算法

    2021-08-01 17:16:30
    一、模型介绍 推荐系统的挑战是 memorization与generalization memorization,记忆能力,学习items或者features之间的相关频率,在...1、Wide推荐: 系统通过获得用户的购物日志数据,包括用户点击哪些商品,购...
  • Wide and Deep

    2022-05-06 22:38:40
    文章目录W and D一、点击率预估二、为什么提出三、 Wide & Deep模型的“记忆能力”与“泛化能力”四、操作流程五、优缺点对比 一、点击率预估 点击率预估是对每次广告点击情况作出预测,可以输出点击或者不点击...
  • :video_game: 用法 从这里下载二进制文件。 ./worldwide " ***.gb " # or ***.gbc :bug: HTTP服务器 worldwide包含一个 HTTP 服务器,用户可以通过 HTTP 请求给它各种指令。 请阅读服务器文档。 :hammer: 建造 ...
  • Wide & Deep作为一篇推荐领域的经典论文,不仅具有很高的研读价值,而且在推荐和广告领域得到了极大的推广和应用。该论文的思想归结起来就是两个词:Wide & Deep。Wide模型用来从训练数据中学得出现频率高的...
  • Wide & Deep Learning模型介绍

    千次阅读 2018-04-21 12:58:52
    Wide & Deep Learning3 The Wide Component(Wide 组件) The Deep Component (Deep组件) Wide & Deep模型的联合训练 Wide & Deep Learning 是由Google Inc发表的paper:Wide &...
  • Wide& Deep

    千次阅读 2018-08-12 18:26:49
    排序系统的发展: LR-->GBDT+LR FM-->FFM-->GBDT+FM|FFM FTRL-->GBDT+FTRL Wide&DeepModel Deep Neural Networks for YouTube ... Wide an...
  • Wide and Deep 理解

    千次阅读 2020-03-30 16:57:12
    wide&deep 模型的核心思想是结合线性模型的记忆能力(memorization)和DNN 模型的泛化能力(generalization),在训练过程中同时优化两个模型的参数,从而达到整体模型的预测能力最优。 联合训练是指同时训练...
  • 问题描述:解决方法:出现这种状况的时候是xshell窗口放大情况下出现的。把窗口缩小既可以解决这个问题。再使用vi编辑文本就可以了。
  • 无法启动world wide web publishing service服务的解决方法 电脑遇到Windows无法启动world wide web publishing service服务依赖服务或组无法启动怎么办最近有用户在使用IIS站点时遇到
  • 文章目录学习总结一、tensorflow2.0的安装二、数据集的加载三、模型的搭建四、模型训练和测试五、模型搭建的比较六、经典wide&deep模型(tf2.0版)6.0 模型提出的背景6.1 Retrieval和Ranking6.2 训练的方法:6.3...
  • 如果屏幕仍然不够宽,您将有一种简单的方法来滚动并读取广泛的文本。此外,修复了一些情况,其中一些元素被切断在几个GitHub屏幕中。描述:你发现自己从60年代初开始使用过时的惯例吗? “历史上从冲压卡中解除了”...
  • 局域网中的串行DMG通信 RaspberryPi支持 调试器 HQ2x模式 本地网络中的串行CGB通信 与全球网络的串行通信 SuperGameBoy支持 :video_game: 用法从下载world.exe。./worldwide.exe " ***.gb " # or ***.gbc :bug: 除错...
  • 作者说: 对于wide部分训练时候使用的优化器是带正则的FTRL算法(Follow-the-regularized-leader),我们可以把FTRL当作一个稀疏性很好,精度又不错的随机梯度下降方法, 该算法是非常注重模型稀疏性质的,也就是说W&...
  • 推荐系统入门(四):Wide&Deep(附代码) 目录推荐系统入门(四):Wide&Deep(附代码)引言点击率预估简介FM它不香吗1.Wide&Deep模型2. “记忆能力”与“泛化能力”3. 操作流程4.实战5.深度学习推荐...
  • {wide}^{T}[\mathbf{x},\phi (\mathbf{x})]+\mathbf{w}_{deep}^{T}a^{lf}+b) P(Y=1∣x)=σ(wwideT​[x,ϕ(x)]+wdeepT​alf+b) 在论文实验中,训练部分,Wide使用Follow-the-regularized-learder(FTRL)+L1正则, Deep...
  • Wide&Deep论文翻译

    2022-09-06 17:17:11
      Jointly training一个wide&deep模型是可以通过从模型输出到wide组件和deep组件反向传播梯度利用mini-batch的随机梯度的方法优化完成。在Google的实验中,对于wide组件是通过带L1正则项的ftrl优化,对于deep组件...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 65,944
精华内容 26,377
关键字:

wide的用法