精华内容
下载资源
问答
  • CTR

    2012-12-09 23:31:18
    http://baike.baidu.com/view/1084259.htm Click through rate  Click through rate 广告点阅率,由在 SERP 中被点击的次数比上... 英文同义:CTR  Ad Clicks与Ad Views之比是判断广告是否可以吸

    http://baike.baidu.com/view/1084259.htm

    Click through rate

      Click through rate 广告点阅率,由在 SERP 中被点击的次数比上展示的总数计算的。
      中文同义:广告点通率、点进率
      英文同义:CTR
      Ad Clicks与Ad Views之比是判断广告是否可以吸引访客点阅的参考指针之一。
      CTR在PPC和SEO中都有应用。PPC中,Google在决定广告的最低点击价格和广告排名时都会考虑CTR。在SEO中,也就是左侧排名中,Google会考虑网站的CTR和用户停留时间,来决定网站的排名。

    展开全文
  • cTR

    2011-10-24 16:49:00
    cTR类: 功能:创建一个TR HTML标签 构造函数: cTR(self,width='',height='',align='',bgcolor='',background='',sclass='',onclick='',id='',onDblClick='') 功能:初始化TR的样式 参数说明:请参考TR标签的...

    cTR类:

    功能:创建一个TR HTML标签

    构造函数:

    cTR(self,width='',height='',align='',bgcolor='',background='',sclass='',οnclick='',id='',onDblClick='')

    功能:初始化TR的样式

    参数说明:请参考TR标签的样式。

    方法:

    add(tdHTML)

    功能:在TR标签内加入TD标签

    参数说明:
          tdHTML td标签

    getHTML()

    功能:获取TR 的HTML

    示例:

    tr=cTR() #创建一个默认样式的TR标签 
    print tr.getHTML()   #打印结果为:<TR></TR>
    table1.add('<td></td>') #打印结果为:<TR></TR><td></td></TR>
    

      

        

    转载于:https://www.cnblogs.com/JiangHuakey/archive/2011/10/24/2222830.html

    展开全文
  • CTR预估算法之FM, FFM, DeepFM及实践

    万次阅读 多人点赞 2017-12-29 16:55:36
    CTR预估综述 Factorization Machines(FM) 算法原理 代码实现 Field-aware Factorization Machines(FFM) 算法原理 代码实现 Deep FM 算法原理 代码实现 参考文献 CTR预估综述 点击率(Click ...

    目录

    CTR预估综述

    点击率(Click through rate)是点击特定链接的用户与查看页面,电子邮件或广告的总用户数量之比。 它通常用于衡量某个网站的在线广告活动是否成功,以及电子邮件活动的有效性。
    点击率是广告点击次数除以总展示次数(广告投放次数)

    此处输入图片的描述

    目前,CTR的数值平均接近0.2%0.2\%0.3%0.3\%,超过2%2\%被认为是非常成功的。

    常用的CTR预估算法有FM, FFM, DeepFM。

    Factorization Machines(FM)

    FM的paper地址如下:https://www.csie.ntu.edu.tw/~b97053/paper/Rendle2010FM.pdf
    FM主要目标是:解决数据稀疏的情况下,特征怎样组合的问题
    根据paper的描述,FM有一下三个优点:

    1. 可以在非常稀疏的数据中进行合理的参数估计
    2. FM模型的时间复杂度是线性的
    3. FM是一个通用模型,它可以用于任何特征为实值的情况

    算法原理

    在一般的线性模型中,是各个特征独立考虑的,没有考虑到特征与特征之间的相互关系。但实际上,大量的特征之间是有关联的。
    一般的线性模型为:

    y=w0+i=1nwixiy = w_0 + \sum_{i=1}^nw_ix_i

    从上面的式子中看出,一般的线性模型没有考虑特征之间的关联。为了表述特征间的相关性,我们采用多项式模型。在多项式模型中,特征xix_ixjx_j的组合用xixjx_ix_j表示。为了简单起见,我们讨论二阶多项式模型。

    y=w0+i=1nwixi+i=1nj=i+1nwijxixjy = w_0 + \sum_{i=1}^nw_ix_i + \sum_{i=1}^{n}\sum_{j=i+1}^nw_{ij}x_ix_j

    该多项是模型与线性模型相比,多了特征组合的部分,特征组合部分的参数有n(n1)2\frac{n(n-1)}{2}个。如果特征非常稀疏且维度很高的话,时间复杂度将大大增加。
    为了降低时间复杂度,对每一个特征,引入辅助向量lantent vector Vi=[vi1,vi2,...,vik]TV_i=[v_{i1},v_{i2},...,v_{ik}]^T, 模型修改如下:

    y=w0+i=1nwixi+i=1nj=i+1n<Vi,Vj>xixjy = w_0 + \sum_{i=1}^nw_ix_i + \sum_{i=1}^{n}\sum_{j=i+1}^n<V_i,V_j> x_ix_j

    以上就是FM模型的表达式kk是超参数,即lantent vector的维度,一般取30或40,也可以取其他数 具体情况具体分析。上式如果要计算的话,时间复杂度是O(kn2)O(kn^2), 可以通过如下方式化简。对于FM的交叉项

    i=1nj=i+1n<Vi,Vj>xixj\sum_{i=1}^{n}\sum_{j=i+1}^n<V_i,V_j> x_ix_j

    =12i=1nj=1n<Vi,Vj>xixj12i=1n<Vi,Vi>xixi=\frac{1}{2}\sum_{i=1}^{n}\sum_{j=1}^n<V_i,V_j> x_ix_j -\frac{1}{2}\sum_{i=1}^n<V_i,V_i>x_ix_i

    =12(i=1nj=1nf=1kvifvjfxixji=1nf=1kvifvifxixi)=\frac{1}{2}(\sum_{i=1}^n\sum_{j=1}^{n}\sum_{f=1}^kv_{if}v_{jf}x_ix_j - \sum_{i=1}^{n}\sum_{f=1}^kv_{if}v_{if}x_ix_i)

    =12f=1k((i=1nvifxi)(j=1nvjfxj)i=1nvif2xi2)=\frac{1}{2}\sum_{f=1}^{k}((\sum_{i=1}^nv_{if}x_i)(\sum_{j=1}^nv_{jf}x_j) - \sum_{i=1}^nv_{if}^2x_i^2)

    =12f=1k((i=1nvifxi)2i=1nvif2xi2))=\frac{1}{2}\sum_{f=1}^{k}((\sum_{i=1}^nv_{if}x_i)^2 - \sum_{i=1}^nv_{if}^2x_i^2))

    通过对每个特征引入lantent vector ViV_i, 并对表达式进行化简,可以把时间复杂度降低到O(kn)O(kn)

    代码实现

    我们利用kaggle上的CTR预测比赛中数据测试了算法,由于代码过于冗长,此处仅给出FM类的代码,包括add palceholders, inference等模块。详细代码参考github,https://github.com/Johnson0722/CTR_Prediction/tree/master

    class FM(object):
        """
        Factorization Machine with FTRL optimization
        """
        def __init__(self, config):
            """
            :param config: configuration of hyperparameters
            type of dict
            """
            # number of latent factors
            self.k = config['k']
            self.lr = config['lr']
            self.batch_size = config['batch_size']
            self.reg_l1 = config['reg_l1']
            self.reg_l2 = config['reg_l2']
            # num of features
            self.p = feature_length
    
        def add_placeholders(self):
            self.X = tf.sparse_placeholder('float32', [None, self.p])
            self.y = tf.placeholder('int64', [None,])
            self.keep_prob = tf.placeholder('float32')
    
        def inference(self):
            """
            forward propagation
            :return: labels for each sample
            """
            with tf.variable_scope('linear_layer'):
                b = tf.get_variable('bias', shape=[2],
                                    initializer=tf.zeros_initializer())
                w1 = tf.get_variable('w1', shape=[self.p, 2],
                                     initializer=tf.truncated_normal_initializer(mean=0,stddev=1e-2))
                # shape of [None, 2]
                self.linear_terms = tf.add(tf.sparse_tensor_dense_matmul  (self.X, w1), b)
    
            with tf.variable_scope('interaction_layer'):
                v = tf.get_variable('v', shape=[self.p, self.k],
                                    initializer=tf.truncated_normal_initializer(mean=0, stddev=0.01))
                # shape of [None, 1]
                self.interaction_terms = tf.multiply(0.5,
                                                     tf.reduce_mean(
                                                         tf.subtract(
                                                             tf.pow(tf.sparse_tensor_dense_matmul(self.X, v), 2),
                                                             tf.sparse_tensor_dense_matmul(tf.pow(self.X, 2), tf.pow(v, 2))),
                                                         1, keep_dims=True))
            # shape of [None, 2]
            self.y_out = tf.add(self.linear_terms, self.interaction_terms)
            self.y_out_prob = tf.nn.softmax(self.y_out)
    
        def add_loss(self):
            cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.y, logits=self.y_out)
            mean_loss = tf.reduce_mean(cross_entropy)
            self.loss = mean_loss
            tf.summary.scalar('loss', self.loss)
    
        def add_accuracy(self):
            # accuracy
            self.correct_prediction = tf.equal(tf.cast(tf.argmax(model.y_out,1), tf.int64), model.y)
            self.accuracy = tf.reduce_mean(tf.cast(self.correct_prediction, tf.float32))
            # add summary to accuracy
            tf.summary.scalar('accuracy', self.accuracy)
    
        def train(self):
            # Applies exponential decay to learning rate
            self.global_step = tf.Variable(0, trainable=False)
            # define optimizer
            optimizer = tf.train.FtrlOptimizer(self.lr, l1_regularization_strength=self.reg_l1,
                                               l2_regularization_strength=self.reg_l2)
            extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
            with tf.control_dependencies(extra_update_ops):
                self.train_op = optimizer.minimize(self.loss, global_step=self.global_step)
    
        def build_graph(self):
            """build graph for model"""
            self.add_placeholders()
            self.inference()
            self.add_loss()
            self.add_accuracy()
            self.train()
    
    

    Field-aware Factorization Machines(FFM)

    FFM的论文地址:https://www.csie.ntu.edu.tw/~cjlin/papers/ffm.pdf
    FFM(Field-aware Factorization Machine)最初的概念来自Yu-Chin Juan(阮毓钦,毕业于中国台湾大学,现在美国Criteo工作)与其比赛队员,提出了FM的升级版模型。通过引入field的概念3,FFM把相同性质的特征归于同一个field。
    在FFM中,每一维特征 xix_i,针对其它特征的每一种field fjf_j,都会学习一个隐向量Vi,fjV_{i,f_j}。因此,隐向量不仅与特征相关,也与field相关。这也是FFM中“Field-aware”的由来。

    算法原理

    设样本一共有nn个特征, ff 个field,那么FFM的二次项有nfnf个隐向量。而在FM模型中,每一维特征的隐向量只有一个。FM可以看作FFM的特例,是把所有特征都归属到一个field时的FFM模型。根据FFM的field敏感特性,可以导出其模型方程。

    y=w0+i=1nwixi+i=1nj=i+1n<Vi,fj,Vj,fi>xixjy = w_0 + \sum_{i=1}^nw_ix_i+\sum_{i=1}^n\sum_{j=i+1}^n<V_{i,f_j},V_{j,f_i}>x_ix_j

    其中,fjf_j是第jj的特征所属的字段。如果隐向量的长度为 kk,那么FFM的二次参数有 nfknfk 个,远多于FM模型的 nknk 个。此外,由于隐向量与field相关,FFM二次项并不能够化简,时间复杂度是 O(kn2)O(kn^2)
    需要注意的是由于FFM中的latent vector只需要学习特定的field,所以通常:

    KFFM<<KFMK_{FFM}<<K_{FM}

    下面以一个例子简单说明FFM的特征组合方式[9]。输入记录如下

    Clicked Publisher§ Advertiser(A) Gender(G)
    Yes ESPN Nike Male

    对于FM模型来说,其交叉项为:

    ϕFMV,x=<VESPN,VNike>+<VESPN,VMale>+<VNike,VMale>\phi_{FM}(V,x) = <V_{ESPN},V_{Nike}>+<V_{ESPN},V_{Male}>+<V_{Nike},V_{Male}>,

    因为在FM中,每个特征只有一个latent vecotr,这个latent可以用来学习和其他特征之间的关系。
    但是在FFM中,每一个特征有好几个latent vector,取决于其他特征的字段。在这个例子中,FFM的特征交叉项

    ϕFFMV,x=<VESPN,A,VNike,P>+<VESPN,G,VMale,P>+<VNike,G,VMale,A>\phi_{FFM}(V,x) = <V_{ESPN,A},V_{Nike,P}>+<V_{ESPN,G},V_{Male,P}>+<V_{Nike,G},V_{Male,A}>

    简单来讲,就是说在做latent vector的inner product的时候,必须考虑到其他特征所属的字段。例如
    <VESPN,A,VNike,P><V_{ESPN,A},V_{Nike,P}>中,因为NikeNike在字段A中,所以ESPNESPN的这个特征必须考虑到字段AA,以区分其他字段。<VESPN,G,VMale,P><V_{ESPN,G},V_{Male,P}>中因为其交叉的特征MaleMale属于字段GG,所以使用了VESPN,GV_{ESPN,G}这个latent vector。这样,每个特征都有ff个latent vector

    代码实现

    同样的,这里只给出FFM类的代码,详细代码见github,https://github.com/Johnson0722/CTR_Prediction/tree/master

    class FFM(object):
        """
        Field-aware Factorization Machine
        """
        def __init__(self, config):
            """
            :param config: configuration of hyperparameters
            type of dict
            """
            # number of latent factors
            self.k = config['k']
            # num of fields
            self.f = config['f']
            # num of features
            self.p = feature_length
            self.lr = config['lr']
            self.batch_size = config['batch_size']
            self.reg_l1 = config['reg_l1']
            self.reg_l2 = config['reg_l2']
            self.feature2field = config['feature2field']
    
        def add_placeholders(self):
            self.X = tf.placeholder('float32', [self.batch_size, self.p])
            self.y = tf.placeholder('int64', [None,])
            self.keep_prob = tf.placeholder('float32')
    
        def inference(self):
            """
            forward propagation
            :return: labels for each sample
            """
            with tf.variable_scope('linear_layer'):
                b = tf.get_variable('bias', shape=[2],
                                    initializer=tf.zeros_initializer())
                w1 = tf.get_variable('w1', shape=[self.p, 2],
                                     initializer=tf.truncated_normal_initializer(mean=0,stddev=1e-2))
                # shape of [None, 2]
                self.linear_terms = tf.add(tf.matmul(self.X, w1), b)
    
            with tf.variable_scope('field_aware_interaction_layer'):
                v = tf.get_variable('v', shape=[self.p, self.f, self.k], dtype='float32',
                                    initializer=tf.truncated_normal_initializer(mean=0, stddev=0.01))
                # shape of [None, 1]
                self.field_aware_interaction_terms = tf.constant(0, dtype='float32')
                # build dict to find f, key of feature,value of field
                for i in range(self.p):
                    for j in range(i+1,self.p):
                        self.field_aware_interaction_terms += tf.multiply(
                            tf.reduce_sum(tf.multiply(v[i,self.feature2field[i]], v[j,self.feature2field[j]])),
                            tf.multiply(self.X[:,i], self.X[:,j])
                        )
            # shape of [None, 2]
            self.y_out = tf.add(self.linear_terms, self.field_aware_interaction_terms)
            self.y_out_prob = tf.nn.softmax(self.y_out)
    
        def add_loss(self):
                cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.y, logits=self.y_out)
                mean_loss = tf.reduce_mean(cross_entropy)
                self.loss = mean_loss
                tf.summary.scalar('loss', self.loss)
    
        def add_accuracy(self):
            # accuracy
            self.correct_prediction = tf.equal(tf.cast(tf.argmax(model.y_out,1), tf.int64), model.y)
            self.accuracy = tf.reduce_mean(tf.cast(self.correct_prediction, tf.float32))
            # add summary to accuracy
            tf.summary.scalar('accuracy', self.accuracy)
    
        def train(self):
            # Applies exponential decay to learning rate
            self.global_step = tf.Variable(0, trainable=False)
            # define optimizer
            optimizer = tf.train.AdagradDAOptimizer(self.lr, global_step=self.global_step)
            extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
            with tf.control_dependencies(extra_update_ops):
                self.train_op = optimizer.minimize(self.loss, global_step=self.global_step)
    
        def build_graph(self):
            """build graph for model"""
            self.add_placeholders()
            self.inference()
            self.add_loss()
            self.add_accuracy()
            self.train()
    
    

    Deep FM

    论文地址:https://arxiv.org/pdf/1703.04247.pdf

    对于一个基于CTR预估的推荐系统,最重要的是学习到用户点击行为背后隐含的特征组合。在不同的推荐场景中,低阶组合特征或者高阶组合特征可能都会对最终的CTR产生影响5
    人工方式的特征工程,通常有两个问题:一个是特征爆炸。以通常使用的Poly-2模型为例,该模型采用直接对2阶特征组合建模来学习它们的权重,这种方式构造的特征数量跟特征个数乘积相关,例如:加入某类特征有1万个可能的取值(如APP),另一类特征也有1万个可能的取值(如用户),那么理论上这两个特征组合就会产生1亿个可能的特征项,引起特征爆炸的问题;如果要考虑更高阶的特征,如3阶特征,则会引入更高的特征维度,比如第三个特征也有1万个(如用户最近一次下载记录),则三个特征的组合可能产生10000亿个可能的特征项,这样高阶特征基本上无法有效学习。另一个问题是大量重要的特征组合都隐藏在数据中,无法被专家识别和设计 (关于这个的一个有名的例子是啤酒和尿片的故事)。依赖人工方式进行特征设计,存在大量有效的特征组合无法被专家识别的问题。实现特征的自动组合的挖掘,就成为推荐系统技术的一个热点研究方向,深度学习作为一种先进的非线性模型技术在特征组合挖掘方面具有很大的优势。
    针对上述两个问题,广度模型深度模型提供了不同的解决思路。其中广度模型包括FM/FFM等大规模低秩(Low-Rank)模型,FM/FFM通过对特征的低秩展开,为每个特征构建隐式向量,并通过隐式向量的点乘结果来建模两个特征的组合关系实现对二阶特征组合的自动学习。作为另外一种模型,Poly-2模型则直接对2阶特征组合建模来学习它们的权重。FM/FFM相比于Poly-2模型,优势为以下两点。第一,FM/FFM模型所需要的参数个数远少于Poly-2模型:FM/FFM模型为每个特征构建一个隐式向量,所需要的参数个数为O(km),其中k为隐式向量维度,m为特征个数;Poly-2模型为每个2阶特征组合设定一个参数来表示这个2阶特征组合的权重,所需要的参数个数为O(m^2)。第二,相比于Poly-2模型,FM/FFM模型能更有效地学习参数:当一个2阶特征组合没有出现在训练集时,Poly-2模型则无法学习该特征组合的权重;但是FM/FFM却依然可以学习,因为该特征组合的权重是由这2个特征的隐式向量点乘得到的,而这2个特征的隐式向量可以由别的特征组合学习得到。总体来说,FM/FFM是一种非常有效地对二阶特征组合进行自动学习的模型。
    深度学习是通过神经网络结构和非线性激活函数,自动学习特征之间复杂的组合关系。目前在APP推荐领域中比较流行的深度模型有FNN/PNN/Wide&Deep;FNN模型是用FM模型来对Embedding层进行初始化的全连接神经网络。PNN模型则是在Embedding层和全连接层之间引入了内积/外积层,来学习特征之间的交互关系。Wide&Deep模型由谷歌提出,将LR和DNN联合训练,在Google Play取得了线上效果的提升。
    但目前的广度模型和深度模型都有各自的局限。广度模型(LR/FM/FFM)一般只能学习1阶和2阶特征组合;而深度模型(FNN/PNN)一般学习的是高阶特征组合。在之前的举例中可以看到无论是低阶特征组合还是高阶特征组合,对推荐效果都是非常重要的。Wide&Deep模型依然需要人工特征工程来为Wide模型选取输入特征。
    DeepFM模型结合了广度和深度模型的有点,联合训练FM模型和DNN模型,来同时学习低阶特征组合和高阶特征组合。此外,DeepFM模型的Deep component和FM component从Embedding层共享数据输入,这样做的好处是Embedding层的隐式向量在(残差反向传播)训练时可以同时接受到Deep component和FM component的信息,从而使Embedding层的信息表达更加准确而最终提升推荐效果。DeepFM相对于现有的广度模型、深度模型以及Wide&Deep; DeepFM模型的优势在于:

    • DeepFM模型同时对低阶特征组合和高阶特征组合建模,从而能够学习到各阶特征之间的组合关系
    • DeepFM模型是一个端到端的模型,不需要任何的人工特征工程

    算法原理

    首先给出DeepFM的系统框图
    此处输入图片的描述

    DeepFM包含两部分,左边的FM部分和右边的DNN部分。这两部分共享相同的输入。对于给定的特征ii, wiw_i用于表示一阶特征的重要性,特征ii的隐向量(latent vector)ViV_i用户表示和其他特征的相互影响。在FM部分,ViV_i用于表征二阶特征,同时在神经网络部分用于构建高阶特征。对于当前模型,所有的参数共同参与训练。DeepFM的预测结果可以写为

    y=sigmoid(yFM+yDNN)y = sigmoid(y_{FM}+y_{DNN})

    y(0,1)y\in(0,1)是预测的CTR,yFMy_{FM}是FM部分得到的结果,yDNNDNNy_{DNN}是DNN部分的结果
    对于FM部分, 其计算公式和模型如下。详细可以看第一节,这里不在赘述

    yFM=w0+i=1nwixi+i=1nj=i+1n<Vi,Vj>xixjy_{FM} = w_0 + \sum_{i=1}^nw_ix_i + \sum_{i=1}^{n}\sum_{j=i+1}^n<V_i,V_j> x_ix_j

    此处输入图片的描述

    对于神经网络DNN部分,其模型如下所示:

    此处输入图片的描述

    深度部分是一个前馈神经网络,可以学习高阶的特征组合。需要注意的是原始的输入的数据是很多个字段的高维稀疏数据。因此引入一个embedding layer将输入向量压缩到低维稠密向量。
    embedding layer的结构如下图所示,
    此处输入图片的描述

    embedding layer有两个有趣的特性:

    • 输入数据的每个字段的特征经过embedding之后,都为kk维(lantent vector的维度),所以embedding后的特征维度是 ×k字段数×k
    • 在FM里得到的隐变量VV现在作为了嵌入层网络的权重,FM模型作为整个模型的一部分与其他深度学习模型一起参与整体的学习, 实现端到端的训练。

    将embedding layer表征如下:

    a(0)=[e1,e2,...,em]a^{(0)}=[e_1,e_2,...,e_m]

    eie_i是第ii个字段的embedding,mm是字段的个数。a(0)a^{(0)}是输入神经网络的向量,然后通过如下方式前向传播:

    al+1=σ(W(l)a(l)+b(l))a^{l+1} = \sigma(W^{(l)}a^{(l)} + b^{(l)})

    需要指出的是,FM部分与深度部分共享相同的embedding带来了两个好处:

    • 从原始数据中同时学习到了低维与高维特征
    • 不再需要特征工程。而Wide&Deep Model需要

    关于DNN网络结构的设计,文中给出的结果是,对于hidden layer, 使用三层200-200-200的结构设计。使用relu函数作为激活函数,增加了dropout。当然,关于超参数的调试,这个还要具体情况具体分析,只有手动取调试才知道哪些参数组合更好

    代码实现

    同样的,这里只给出FFM类的代码,详细代码见github,https://github.com/Johnson0722/CTR_Prediction/tree/master

    class DeepFM(object):
        """
        Deep FM with FTRL optimization
        """
        def __init__(self, config):
            """
            :param config: configuration of hyperparameters
            type of dict
            """
            # number of latent factors
            self.k = config['k']
            self.lr = config['lr']
            self.batch_size = config['batch_size']
            self.reg_l1 = config['reg_l1']
            self.reg_l2 = config['reg_l2']
            # num of features
            self.p = feature_length
            # num of fields
            self.field_cnt = field_cnt
    
        def add_placeholders(self):
            self.X = tf.placeholder('float32', [None, self.p])
            self.y = tf.placeholder('int64', [None,])
            # index of none-zero features
            self.feature_inds = tf.placeholder('int64', [None,field_cnt])
            self.keep_prob = tf.placeholder('float32')
    
        def inference(self):
            """
            forward propagation
            :return: labels for each sample
            """
            v = tf.Variable(tf.truncated_normal(shape=[self.p, self.k], mean=0, stddev=0.01),dtype='float32')
    
            # Factorization Machine
            with tf.variable_scope('FM'):
                b = tf.get_variable('bias', shape=[2],
                                    initializer=tf.zeros_initializer())
                w1 = tf.get_variable('w1', shape=[self.p, 2],
                                     initializer=tf.truncated_normal_initializer(mean=0,stddev=1e-2))
                # shape of [None, 2]
                self.linear_terms = tf.add(tf.matmul(self.X, w1), b)
    
                # shape of [None, 1]
                self.interaction_terms = tf.multiply(0.5,
                                                     tf.reduce_mean(
                                                         tf.subtract(
                                                             tf.pow(tf.matmul(self.X, v), 2),
                                                             tf.matmul(tf.pow(self.X, 2), tf.pow(v, 2))),
                                                         1, keep_dims=True))
                # shape of [None, 2]
                self.y_fm = tf.add(self.linear_terms, self.interaction_terms)
    
            # three-hidden-layer neural network, network shape of (200-200-200)
            with tf.variable_scope('DNN',reuse=False):
                # embedding layer
                y_embedding_input = tf.reshape(tf.gather(v, self.feature_inds), [-1, self.field_cnt*self.k])
                # first hidden layer
                w1 = tf.get_variable('w1_dnn', shape=[self.field_cnt*self.k, 200],
                                     initializer=tf.truncated_normal_initializer(mean=0,stddev=1e-2))
                b1 = tf.get_variable('b1_dnn', shape=[200],
                                     initializer=tf.constant_initializer(0.001))
                y_hidden_l1 = tf.nn.relu(tf.matmul(y_embedding_input, w1) + b1)
                # second hidden layer
                w2 = tf.get_variable('w2', shape=[200, 200],
                                     initializer=tf.truncated_normal_initializer(mean=0,stddev=1e-2))
                b2 = tf.get_variable('b2', shape=[200],
                                     initializer=tf.constant_initializer(0.001))
                y_hidden_l2 = tf.nn.relu(tf.matmul(y_hidden_l1, w2) + b2)
                # third hidden layer
                w3 = tf.get_variable('w1', shape=[200, 200],
                                     initializer=tf.truncated_normal_initializer(mean=0,stddev=1e-2))
                b3 = tf.get_variable('b1', shape=[200],
                                     initializer=tf.constant_initializer(0.001))
                y_hidden_l3 = tf.nn.relu(tf.matmul(y_hidden_l2, w3) + b3)
                # output layer
                w_out = tf.get_variable('w_out', shape=[200, 2],
                                     initializer=tf.truncated_normal_initializer(mean=0,stddev=1e-2))
                b_out = tf.get_variable('b_out', shape=[2],
                                     initializer=tf.constant_initializer(0.001))
                self.y_dnn = tf.nn.relu(tf.matmul(y_hidden_l3, w_out) + b_out)
            # add FM output and DNN output
            self.y_out = tf.add(self.y_fm, self.y_dnn)
            self.y_out_prob = tf.nn.softmax(self.y_out)
    
        def add_loss(self):
            cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.y, logits=self.y_out)
            mean_loss = tf.reduce_mean(cross_entropy)
            self.loss = mean_loss
            tf.summary.scalar('loss', self.loss)
    
        def add_accuracy(self):
            # accuracy
            self.correct_prediction = tf.equal(tf.cast(tf.argmax(model.y_out,1), tf.int64), model.y)
            self.accuracy = tf.reduce_mean(tf.cast(self.correct_prediction, tf.float32))
            # add summary to accuracy# CTR预估算法之FM, FFM, DeepFM及实践# CTR预估算法之FM, FFM, DeepFM及实践c
    
       tf.summary.scalar('accuracy', self.accuracy)
    
        def train(self):
            # Applies exponential decay to learning rate
            self.global_step = tf.Variable(0, trainable=False)
            # define optimizer
            optimizer = tf.train.FtrlOptimizer(self.lr, l1_regularization_strength=self.reg_l1,
                                               l2_regularization_strength=self.reg_l2)
            extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
            with tf.control_dependencies(extra_update_ops):
                self.train_op = optimizer.minimize(self.loss, global_step=self.global_step)
    
        def build_graph(self):
            """build graph for model"""
            self.add_placeholders()
            self.inference()
            self.add_loss()
            self.add_accuracy()
            self.train()
    
    

    参考文献

    1.https://en.wikipedia.org/wiki/Click-through_rate
    2.http://blog.csdn.net/g11d111/article/details/77430095
    3.https://tech.meituan.com/deep-understanding-of-ffm-principles-and-practices.html
    4.http://www.csie.ntu.edu.tw/~r01922136/slides/ffm.pdf
    5.http://baijiahao.baidu.com/s?id=1579855367208283187&wfr=spider&for=pc

    展开全文
  • CTR mode

    2020-12-25 16:49:34
    <div><p>CTR mode that can be used for implementing QUIC packet number encryption. <pre><code> // setup ptls_cipher_context_t *pn_enc = ptls_cipher_new(aead->ctr_cipher, pn_key); // encrypt or ...
  • ctr 平滑_ctr平滑

    2020-12-24 03:01:11
    在广告系统中,一个重要的指标是CTRctr=点击(Click)/曝光(Impression)。如果一个广告只有5次曝光,没有点击,是否表示它的ctr为0?如果一个广告曝光了4次,却有3次点击,它的ctr是否就为75%?直觉上肯定是不对的。一...

    在广告系统中,一个重要的指标是CTR。ctr=点击(Click)/曝光(Impression)。

    如果一个广告只有5次曝光,没有点击,是否表示它的ctr为0?

    如果一个广告曝光了4次,却有3次点击,它的ctr是否就为75%?

    直觉上肯定是不对的。

    一个广告的每次展示,相当于概率试验里的投硬币。客户点击/不点击广告,是一个泊努利试验(Bernoulli Trial)。多个客户点击/不点击广告,可以看成是进行一串Bernoulli试验,即二项试验(Binomial Experiment),服从二项分布。

    假设我们尝试了n次试验(有n个客户),每个客户点击该广告的概率为p(平均ctr)。该试验服从二项分布:B(n,p)。在n次试验中,观察到有k次点击的概率为:

    \[B(k,n,p)=C^{n}_{k}p^k(1-p)^{n-k}\]

    例如,如果有100个visitors,该广告的点击率为10%,点击次数的概率分布(PMF)为:

    即上面公式中:n=100, 横轴为k,纵轴为p。

    import numpy as np

    import matplotlib.pyplot as plt

    from scipy.stats import binom

    n, p = 4, 0.1

    x = np.arange(1,100)

    fig, ax = plt.subplots(1, 1)

    ax.plot(x, binom.pmf(x, n, p), 'bo', ms=8, label='binom pmf')

    plt.show()

    我们可得到类似这样的曲线:

    当CTR接近10%时,有相当高的机会看到8次-12次左右的点击。如果观察的次数越少,噪声也会越多。当只有4次观测(observation)时,有65%的机会看到没有点击,30%的机会看到一次点击,5%的机会看到2次点击。

    from scipy.misc import comb

    n = 4

    k = 0

    r = 0.1

    p0 = comb(n,k)* (r)**k * (1-r)**(n-k)

    ### p1接近0.65

    k = 1

    p1 = comb(n,k)* (r)**k * (1-r)**(n-k)

    ### p2接近0.30

    k=2

    p2 = comb(n,k)* (r)**k * (1-r)**(n-k)

    ### p3接近0.05

    2.CTR的Beta分布

    假如,我们只有少量观测,是否可以去估计CTR呢?是否可以设计一个算法去模仿相应的模型数据?

    为了在一个广告上模仿点击,我们首先使用一些分布上的CTR的值,接着使用它们作为在二项分布上的点击概率。这意味着我们需要两个随机变量。首先,是一个在[0,1]范围内的CTR的连续分布。第二个,是使用该CTR作为参数的二项分布。

    什么样的分布是合理的?我们首先想到的是:正态分布。但它有负数,负的CTR显然没意义。另外,它是对称的,没有理由将模型限制在对称分布上。最好的分布是:Beta分布。它在[0,1]区间内是连续的,并且有各种形状。它的两个参数为:α(alpha) 和 β(beta)。

    有两种方式来从数据中估计α和β的值,其中有一种方法特别有用:“均值和样本量”参数化(“Mean and Sample Size” parametrization)。

    假设我们从一个很大的样本中抽取的10次曝光和2次点击来估计它的分布。假设 ν为样本量。 ν=10,μ为CTR均值。我们有2次点击和10次曝光:μ=2/10=0.2。Beta分布的参数化为:

    α=μν,β=(1–μ)ν

    在该例中:

    α=0.2⋅10=2, β=(1–0.2)⋅10=0.8⋅10=8

    beta分布的概率计算公式:

    \[f(x;\alpha,\beta)=\frac{\Gamma(\alpha+\beta)}{\Gamma(\alpha)\Gamma(\beta)}x^{\alpha-1}(1-x)^{\beta-1}\]

    其中的f(x;a,β)就是实际概率,而x就是这里我们的点击率。

    绘制出对应的Beta曲线:

    import numpy as np

    import matplotlib.pyplot as plt

    from scipy.stats import beta

    a,b=2,8

    x = np.arange(0,1,0.01)

    fig, ax = plt.subplots(1, 1)

    ax.plot(x, beta.pdf(x, a, b), 'r-', lw=5, alpha=0.6, label='beta pdf')

    plt.show()

    可以得到类似的图:

    从10次观测中的不确定性,通过该分布的扩展可以很容易解释。同理,我们可以尝试计算参数化,如果我们具有1000个观测以及200次点击。你可以注意到它将高度集中围绕在20%的CTR中。

    将Beta分布与Binomial分布结合在一起,称为Beta-Binomial分布。

    3.贝叶斯推断(Bayesian inference)

    3.1

    在参考文献一中,提出的方法是直接使用先验CTR:

    通常,我们实际展示多个广告。计算观测时,当存在不确定性时,我们会生成一个CTR的估计值。一些广告可能具有成千上万的曝光和点击,而另一些可能只有很少的点击。这时候,可以引入贝叶斯推断(Bayesian inference)。我们使用一个先验的CTR,当新观测被记录时,我们不断更新它。先验CTR有很多方式确定。如果时间足够,我们可以使用基于Mean和sample size的参数化方法。如果我们没有足够信息,我们可以使用事先分配的先验CTR(non-informative prior),比如β(0.5,0.5):

    一旦我们定义好先验CTR后,我们需要指定似然函数(likelihood function)。在我们的案例中,在结定参数集(CTR)下的观测的似然(likelihood)由二项分布给出。二项分布似然加上Beta先验,允许我们使用联合先验概率来获取一个后验分布。在我们的先验β(a,b)下,经过N次曝光观测到x次点击,得到的后验是这样一个Beta分布:β(a+x,b+N–x)。

    还是使用之前的观测:4次曝光,1次点击,我们得到这样的后验:

    贝叶斯模型可以后验的总结、或者通过随机抽样(均值、中位数、标准差等)进行分析。例如,在上面的贝叶斯推断步骤后,我们希望看到:一个广告在10000次曝光下,具有0.35的CPC(Cost-per-Click)

    import numpy as np

    import matplotlib.pyplot as plt

    from scipy.stats import beta

    cpc = 0.35

    priorA = 0.5

    priorB = 0.5

    clicks = 1

    impressions = 4

    #rvs:生成随机数plt.hist(beta.rvs(priorA + clicks, priorB + impressions - clicks, size=10000) * 10000 * cpc, 20, facecolor='green')

    plt.xlabel('Cost')

    plt.ylabel('Frequency')

    plt.grid(True)

    plt.show()

    3.2 数据连续性

    在参考文献二中提到,在许多情况下,我们更关心CTR的趋势,而非某个绝对值快照。对于罕见的(page/ad) pair,任何时间点,CTR的估计都是很大噪声的。根据某种数据连续性,我们可以将impression/click看做是重复测量的离散集合,并在这些测量上采用了一种指数平滑(exponential smoothing),最后我们得到一个平滑的CTR。

    对于一个(page/ad) pair,我们具有连续M天的测量:impressions(I1,I2,I3,…Im)和clicks(C1,C2,…,Cm),然后我们希望估计在第M天的CTR。

    $ \hat{I} $和 $ \hat{C} $各自表示平滑后的impressions和clicks。平滑后的CTR就等于$ \frac{\hat{C}}{\hat{I}} $。

    \[\hat{C_j}=C_j j=1\]

    \[\hat{C_j}=\gammaC_j+(1-\gamma)\hat{C_{j-1}} j=2,...,M\]

    其中γ为平滑因子,它0

    (未完待续)

    参考

    Updated on August 25, 2015

    d0evi1

    展开全文
  • Ctr32

    2020-12-09 09:50:53
    <p>Notably right now the only other <code>ctr</code> type, <code>Ctr128, is specialized to a 128-bit <em>block</em> size. This actually seems ok to me, as it seems rather unusual to use a 128-bit ...
  • Ctr drbg

    2021-01-07 07:04:54
    <p>Add error codes to the cryptographic operations in <code>ctr_drbg</code></p> <h2>Status <p><strong>READY</strong></p> <h2>Requires Backporting <p>NO <h2>Additional comments <p>In HW operations ...
  • CTR预估

    2018-07-30 16:42:30
    CTR CTR又称广告点击率,英文名(click through rate) Ref CTR预估基本知识
  • ctr校准,是说在ctr模型预估值的基础之上进行微调,使得预估值更准的方法。引起ctr预估不准的原因大致有这样几种:1、新素材曝光机会少,导致样本得不到充分训练2、有些模型因素导致预估有偏,比如svm等算法,会使...
  • 基于深度学习的CTR预估,从FM推演各深度学习CTR预估模型
  • CTR模型

    千次阅读 2018-12-17 12:16:22
    ctr ctr(广告点击率)与cvr(广告转化率)是在推荐系统中的重要概念。CTR预估正样本为站内点击的用户-商品记录,负样本为展现但未点击的记录;CVR正样本为站内支付(发生转化)的用户-商品记录,负样本为点击但未...
  • Cyber​​CTR Cyber​​CTR的源代码存储库 在[MPL 2.0]下发布的源代码( ) -了解有关Cyber​​CTR的更多信息 -报告错误 它能做什么: Cyber​​CTR添加了与Classic Theme Restorer相同或相似的功能,但有一些...
  • CTR学习笔记 运行:python main.py --model DeepFM-步进火车-数据集普查--clear_model 1 要求:张量流1.15 已完成模型列表[支持数据集] FM [普查] 实况调查团[人口普查] 嵌入+ MLP [普查] 广泛[深度] FNN [普查] ...
  • CTR校准

    2018-09-19 16:46:00
    通常我们在做CTR预估的时候,预估值会与真是的CTR有偏差,这种偏差可能来自于负采样,可能是因为模型的问题。 CTR预估值与真实值有偏差,并不会影响AUC指标和排序,但是实际使用中往往需要CTR的预估值不仅仅是做到...
  • CTR估计

    2019-05-11 11:01:22
    CTR 点击率预估 应该用到FM和DeepFM框架 先贴一篇讲DeepFM比较系统的文章 计算广告CTR预估系列(一)–DeepFM理论 - 轻春 - CSDN博客 https://blog.csdn.net/u010352603/article/details/80201033 ...
  • 亚马逊广告ctr多少才算合格,如何提升亚马逊CTR很多亚马逊卖家并不重视点击率,其实点击率和转化率是同样重要的。好的点击率可以提升产品listing的流量,间接影响转化,促进销量。一般来说亚马逊点击率多少算正常呢...
  • 在广告和推荐系统当中,一个重要的衡量指标就是点击率,也即是CTR(Click Through Rate)。计算公式: CTR = 点击数 / 曝光数也有一种衡量指标是 uvCTR。 uvCTR = 点击uv数 / 曝光uv数。考虑 CTR = 点击数 / 曝光数 这...
  • 原标题:根据样本数进行点击率CTR的修正 - Wilson CTR在广告和推荐系统当中,一个重要的衡量指标就是点击率,也即是CTR(Click Through Rate)。计算公式: CTR = 点击数 / 曝光数也有一种衡量指标是 uvCTR。 uvCTR = ...
  • AES - CTR

    2021-01-08 14:25:45
    <div><p>I know there was a time where RNCryptor used AES - CTR encryption. Now it's CBC and I think I got the point that it's just more secure since it's not that easy to mess up its ...
  • 广告点击率CTR修正-Wilson CTR

    千次阅读 2018-11-29 16:55:29
    CTR是广告推荐系统中,一项重要的衡量算法好坏的指标。 计算公式: CTR = 点击数 / 曝光数 由于原始CTR计算方式只考虑了相对值,没有考虑绝对值。即,没有考虑曝光的数值大小,因为,曝光少的情况下,计算出的CTR...
  • CTR预估模型讲义pdf

    2020-10-18 22:29:01
    CTR预估模型讲义pdf
  • <div><p>After https://github.com/containerd/cri/pull/865 is in, <code>cri...<p>And then we should start deprecating <code>ctr cri load</code>.</p><p>该提问来源于开源项目:containerd/cri</p></div>
  • AES+CTR+NoPadding

    2021-01-06 18:07:22
    选择AES算法进行对称加密,密钥长度为128位及以上位数,分组密码模式使用CTR模式,CTR模式不需要填充,初始化向量在应用内设定。 说明: (1)对称加密主要应用于普通的数据块(如字符串、字节流等)加解密。 (2)...
  • 在计算广告和推荐系统中,CTR预估一直是一个核心问题。无论在工业界还是学术界都是一个热点研究问题,近年来也有若干相关的算法竞赛。本文介绍一个基于深度学习的CTR模型包De...
  • test_ctr.zip

    2020-05-29 19:28:50
    贝叶斯平滑机制计算ctr更能反映物品的点击率,用矩估计估计出来的参数alpha和beta,再把相应的给ctr计算做平滑,实验证明,使用该平滑机制计算的ctr更能反应物品的热度。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,797
精华内容 4,718
关键字:

ctr