Personalized Ranking Metric Embedding for Nest New POI Recommendation

最新推荐文章于 2024-09-26 16:45:16 发布
最新推荐文章于 2024-09-26 16:45:16 发布
阅读量2.5k 收藏 3
点赞数
文章标签： 推荐算法 预测 poi
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zdwccc/article/details/78385420
版权

介绍(Introduction):

本篇论文主要利用距离嵌入(Metric Embedding)将每个POI映射到一个低维的欧拉空间当中，有效地利用马尔科夫链模型预测POI的变化，用两个POI的欧拉距离衡量两者的序列关系，并且进一步提出了成对排序(pair-wise ranking)的距离嵌入，可以对空间中潜在的POI进行排序，最后提出了个性化的距离嵌入排名(PRME)算法，综合考虑序列信息和个人喜好，因为人们都倾向于拜访距离他们位置比较近的POI，所以考虑空间因素，将模型拓展为PRME-G模型。

论文原理：

论文使用了两个数据集，FourSquare在新加坡内的数据和Gowalla在加利福尼亚和内华达的数据，在使用前对数据集进行预处理，将访问少于10个POI的用户删除，以及将少于10个用户访问的POI删去。通过对数据的统计可以得到以下三个结论：

  1. 用户有探索新POI的倾向
  2. 时间局部性，用户访问两个POI的时间间隔不会很长
  3. 空间局部性，用户连续访问的两个POI的距离不会很远
    这里写图片描述

当在短时间内发生两个check-in时，可以相信存在马尔科夫链的属性，也就是下一个POI很大程度上受当前POI的影响。基于这种短时间内的马尔科夫属性和人们探索新POI的倾向，我们可以定义本论文涉及推荐问题：给定一个用户u和他当前所处的位置l，从用户u没有访问过的POI中选择一个新的推荐给用户u。如果只是推荐一个POI，那么推荐用户u访问最频繁的POI就可能得到较高的正确率，但是我们要推荐新的POI，所以这种方法并不适用，它要使用更稀疏的历史数据推测转移概率，所以下一个新POI的推荐要比下一个POI推荐更难。

我们首先介绍使用成对排名的距离嵌入算法来对位置变换进行建模。距离嵌入模型适用于处理稀疏的数据和未观测到的数据。我们用高维空间的一个点表示现实世界的POI，用两个POI在高维空间中的欧拉距离表示两个POI转换的概率，距离越小，概率越大，把所有的POI嵌入到高维隐空间，我们的模型可以推测位置转换的概率，并且也可以用来给没有观测到的转换赋予有意义的概率。在距离嵌入模型中，每个POI在K维空间中用一个K维向量表示位置，我们的任务，就是通过访问序列来推测出表示POI的K维向量，转换概率如下所示：
这里写图片描述

上述式子只能表示已经观测到的POI转换关系，因为被观测到的数据非常稀疏，为了让学习到的向量关系符合POI转换的概率关系，我们需要充分利用没有观测到的数据，我们假设观测到的下一个POI和当前的POI更有关系，没有观测到POI影响更小，所以能够观测到的POI的排名应该比没有观测到的POI排名高，以此作为排名推测的依据。

POI推荐的目标就是提供对所有POI的排名，推荐排名最高的一项。我们可以进一步简化上面的概率表示：
这里写图片描述

接下来介绍个性化排名距离嵌入算法，下一个POI推荐不仅与当前位置有关，而且与用户的喜好有关，我们引入一个新的高维空间，将用户和POI嵌入到这个高维空间，用户u和位置l在空间中的欧拉距离表示u对l的喜爱程度，距离越近，喜爱程度越高，去的可能越大，综合考虑序列信息和个人喜好，用户将l作为下一个访问的POI的概率可以表示为：
这里写图片描述

根据之前提到的，马尔科夫链属性在两次短时间访问时才能凸显，所以当下一次访问和当前访问时间差距比较大时，可以不考虑序列信息，只考虑用户的喜好，所以可以改善表示为：
这里写图片描述

最后将地理因素考虑进模型，我们用当前POI的位置和下一次访问的位置之间的距离计算地理因素系数w，位置越近越近，w越小，可能性越大，同样，当两次时间差过大时，不考虑当前POI对下一次访问的影响，地理因子同样不需要考虑，所以最终的概率表示为：
这里写图片描述

该模型的最优化标准参考贝叶斯个性化推荐(BPR)的方法，最大化后验概率来推测参数，使用logistic函数表示条件概率，对参数使用高斯前验，最后加正则化参数，防止过拟合，损失函数为：
这里写图片描述
这里写图片描述

算法实现：

如果直接对上面的表达式利用梯度下降计算最值时的参数，计算量比较大，所以采用之前提到的排名原则，对用户u，当前位置lc，观测到的下一访问li，随机选择一个没有观测到过的位置lj，用户u在位置lc访问观测到的li的概率应该大于没有观测到的lj的概率，所以我们最小化的目标变为
这里写图片描述
当z最小时，前一项最小，概率大，后一项最大，概率小，符合预期，所以梯度下降算法用下列方式进行参数更新：
这里写图片描述

在算法实现过程中，首先获得数据元组，包括用户，当前位置，下一观测到的位置，随机选择一个没有观测到的位置，然后用期望为0，方差为0.01的正态分布随机初始化用户和POI在高维空间中向量位置，一个表示序列关系的空间，一个表示用户喜好的空间，然后用上面的参数更新方法更新参数，直到收敛，即损失函数最小，收敛后返回用户和POI在两个空间中的高维坐标。

在测试时，如果要推测用户u下一刻要访问哪一个POI，需要对所有未观测到的POI利用之前训练出的两个空间中的坐标计算出D，按D值进行排序，将D值最小的POI推荐给用户。

需要的数据集可以从http://www.ntu.edu.sg/home/gaocong/data/poidata.zip下载，代码如下所示：

import os
import numpy as np
from math import radians, cos, sin, asin, sqrt, pow, log

def getUser():
    fr=open("user.txt",'r')
    user=[]
    for line in fr.readlines():
        user.append(line.strip())
    fr.close()
    return user

def getShop():
    fr=open("shop.txt",'r')
    shop=[]
    for line in fr.readlines():
        shop.append(line.strip())
    fr.close()
    return shop

def getTrainTuple(fileName):
    data=[]
    observedPOI={}
    exUser=''
    exShop=''
    exTime=''
    fr=open(fileName)
    for line in fr.readlines():
        lineArr=line.strip().split('\t')
        user=lineArr[0]
        shop=lineArr[1]
        time=float(lineArr[4])*24+float(lineArr[3].split(':')[0])+float(lineArr[3].split(':')[1])/60.0
        if user==exUser:
            newTuple=[user,exShop,shop,exTime,time]
            data.append(newTuple)
            if user not in observedPOI.keys():
                observedPOI[user]={}
            if exShop not in observedPOI[user].keys():
                observedPOI[user][exShop]=[]
            observedPOI[user][exShop].append(shop)
            exShop=shop
            exTime=time
        else:
            exUser=user
            exShop=shop
            exTime=time
    fr.close()
    return data,observedPOI

def getTestTuple(fileName):
    data=[]
    exUser=''
    exShop=''
    exTime=''
    fr=open(fileName)
    for line in fr.readlines():
        lineArr=line.strip().split('\t')
        user=lineArr[0]
        shop=lineArr[1]
        time=float(lineArr[4])*24+float(lineArr[3].split(':')[0])+float(lineArr[3].split(':')[1])/60.0 
        if user==exUser:
            newTuple=[user,exShop,shop,exTime,time]
            data.append(newTuple)
            exShop=shop
            exTime=time
        else:
            exUser=user
            exShop=shop
            exTime=time
    fr.close()
    return data

def initVec():
    userP={}
    shopP={}
    shopS={}
    user=getUser()
    shop=getShop()
    for item in user:
        userP[item]=np.random.normal(0,0.01,60)
    for item in shop:
        shopP[item]=np.random.normal(0,0.01,60)
        shopS[item]=np.random.normal(0,0.01,60)
    return userP,shopP,shopS

def loadFileWithDic(fileName):
    fr=open(fileName,'r')
    data={}
    i=0
    arr=[]
    key=''
    for line in fr.readlines():
        if i==0:
            key=line.strip().split('\t')[0]
            temp=line.strip().split('\t')[1][1:].split(' ')
            for item in temp:
                if item!='':
                    arr.append(float(item))
            i=1
        else:
            temp=line.strip().split(' ')
            for item in temp:
                if item!='' and item!=']':
                    if item[-1]==']':
                        arr.append(float(item[:-1]))
                    else:
                        arr.append(float(item))
            if len(arr)==60:
                i=0
                data[key]=np.array(arr)
                arr=[]
    fr.close()
    return data

def getVisited(fileName):
    fr=open(fileName,'r')
    visited={}
    for line in fr.readlines():
        lineArr=line.strip().split('\t')
        user=lineArr[0]
        shop=lineArr[1]
        if user not in visited.keys():
            visited[user]=[]
        if shop not in visited[user]:
            visited[user].append(shop)
    fr.close()
    return visited

def sigmoid(x):
    return 1.0/(1.0+np.exp(float(-x)))

def Edis(a,b):
    sum=0.0
    for i in range(len(a)):
        sum=sum+(a[i]-b[i])*(a[i]-b[i])
    return sum

def train():
    userP,shopP,shopS=initVec()
    data,observedPOI=getTrainTuple('train.txt')
    shop=getShop()
    for i in range(500):
        print("The "+str(i+1)+" is done!")
        for item in data:
            (user,exShop,Cshop,exTime,time)=item
            shopJ=shop[int(np.random.uniform(len(shop)))]
            while shopJ==exShop or shopJ in observedPOI[user][exShop]:
                shopJ=shop[int(np.random.uniform(len(shop)))]
            if time-exTime<6:
                z=0.2*(Edis(userP[user],shopP[shopJ])-Edis(userP[user],shopP[Cshop]))+0.8*(Edis(shopS[exShop],shopS[shopJ])-Edis(shopS[exShop],shopS[Cshop]))
                d=1-sigmoid(z)
                userP[user]=userP[user]+0.005*(d*0.4*(shopP[Cshop]-shopP[shopJ])-0.006*userP[user])
                shopP[Cshop]=shopP[Cshop]+0.005*(d*0.4*(userP[user]-shopP[Cshop])-0.006*shopP[Cshop])
                shopP[shopJ]=shopP[shopJ]+0.005*(d*0.4*(shopP[shopJ]-userP[user])-0.006*shopP[shopJ])
                shopS[exShop]=shopS[exShop]+0.005*(d*1.6*(shopS[Cshop]-shopS[shopJ])-0.006*shopS[exShop])
                shopS[Cshop]=shopS[Cshop]+0.005*(d*1.6*(shopS[exShop])-shopS[Cshop]-0.006*shopS[Cshop])
                shopS[shopJ]=shopS[shopJ]+0.005*(d*1.6*(shopS[shopJ]-shopS[exShop])-0.006*shopS[shopJ])
            else:
                z=Edis(userP[user],shopP[shopJ])-Edis(userP[user],shopP[Cshop])
                d=1-sigmoid(z)
                userP[user]=userP[user]+0.005*(d*2*(shopP[Cshop]-shopP[shopJ])-0.006*userP[user])
                shopP[Cshop]=shopP[Cshop]+0.005*(d*2*(userP[user]-shopP[Cshop])-0.006*shopP[Cshop])
                shopP[shopJ]=shopP[shopJ]+0.005*(d*2*(shopP[shopJ]-userP[user])-0.006*shopP[shopJ])
    fr=open('userP1000.txt','w')
    for key in userP.keys():
        fr.write(str(key)+'\t'+str(userP[key])+'\n')
    fr.close()
    fr=open('shopP1000.txt','w')
    for key in shopP.keys():
        fr.write(str(key)+'\t'+str(shopP[key])+'\n')
    fr.close()
    fr=open('shopS1000.txt','w')
    for key in shopS.keys():
        fr.write(str(key)+'\t'+str(shopS[key])+'\n')
    fr.close()
    return userP,shopP,shopS

def test():
    userP,shopP,shopS=train()
    #userP=loadFileWithDic('userP.txt')
    #shopS=loadFileWithDic('shopS.txt')
    #shopP=loadFileWithDic('shopP.txt')
    data=getTestTuple("test.txt")
    visited=getVisited("train.txt")
    user=getUser()
    shop=getShop()
    allNum=0
    corNum=0
    count=0
    for item in data:
        (Cuser,exShop,Cshop,exTime,time)=item
        if Cuser not in user or exShop not in shop or Cshop not in shop or Cshop in visited[Cuser] or Cshop==exShop:
            continue
        allNum=allNum+1
        if exShop not in visited[Cuser]:
            visited[Cuser].append(exShop)
        poss={}
        count=count+1
        for pShop in shop:
            if pShop in visited[Cuser] or pShop==exShop:
                continue
            if (time-exTime)<6:
                poss[pShop]=0.2*Edis(userP[Cuser],shopP[pShop])+0.8*Edis(shopS[exShop],shopS[pShop])
            else:
                poss[pShop]=Edis(userP[Cuser],shopP[pShop])
        ans=min(poss.items(), key=lambda x: x[1])[0]
        if ans==Cshop:
            corNum=corNum+1
            print(str(corNum)+" : "+str(count))
    print("The currect rate is "+str((100.0*float(corNum))/float(allNum))+"%.")

def haversine(lon1, lat1, lon2, lat2): 
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])  

    dlon = lon2 - lon1   
    dlat = lat2 - lat1   
    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2  
    c = 2 * asin(sqrt(a))   
    r = 6371 
    return c * r

def getPosition():
    fileList=['New/FourSquare/train.txt','New/FourSquare/test.txt','New/FourSquare/tune.txt']
    position={}
    for fileName in fileList:
        fr=open(fileName,'r')
        for line in fr.readlines():
            shop=line.strip().split('\t')[1]
            if shop not in position.keys():
                lat=float(line.strip().split('\t')[2].split(',')[0])
                lon=float(line.strip().split('\t')[2].split(',')[1])
                position[shop]={'lat':lat,'lon':lon}
        fr.close()
    return position

def trainG():
    userP,shopP,shopS=initVec()
    data,observedPOI=getTrainTuple('train.txt')
    position=getPosition()
    shop=getShop()
    for i in range(500):
        print("The "+str(i+1)+" is done!")
        for item in data:
            (user,exShop,Cshop,exTime,time)=item
            shopJ=shop[int(np.random.uniform(len(shop)))]
            while shopJ==exShop or shopJ in observedPOI[user][exShop]:
                shopJ=shop[int(np.random.uniform(len(shop)))]
            if time-exTime<6:
                d1=haversine(position[exShop]['lat'],position[exShop]['lon'],position[Cshop]['lat'],position[Cshop]['lon'])
                d2=haversine(position[exShop]['lat'],position[exShop]['lon'],position[shopJ]['lat'],position[shopJ]['lon'])
                w1=pow(1+d1,0.25)
                w2=pow(1+d2,0.25)
                z=0.2*(w2*Edis(userP[user],shopP[shopJ])-w1*Edis(userP[user],shopP[Cshop]))+0.8*(w2*Edis(shopS[exShop],shopS[shopJ])-w1*Edis(shopS[exShop],shopS[Cshop]))
                d=1-sigmoid(z)
                userP[user]=userP[user]+0.005*(d*0.4*(w1*shopP[Cshop]-w2*shopP[shopJ])-0.006*userP[user])
                shopP[Cshop]=shopP[Cshop]+0.005*(d*0.4*w1*(userP[user]-shopP[Cshop])-0.006*shopP[Cshop])
                shopP[shopJ]=shopP[shopJ]+0.005*(d*0.4*w2*(shopP[shopJ]-userP[user])-0.006*shopP[shopJ])
                shopS[exShop]=shopS[exShop]+0.005*(d*1.6*(w1*shopS[Cshop]-w2*shopS[shopJ])-0.006*shopS[exShop])
                shopS[Cshop]=shopS[Cshop]+0.005*(d*1.6*w1*(shopS[exShop])-shopS[Cshop]-0.006*shopS[Cshop])
                shopS[shopJ]=shopS[shopJ]+0.005*(d*1.6*w2*(shopS[shopJ]-shopS[exShop])-0.006*shopS[shopJ])
            else:
                z=Edis(userP[user],shopP[shopJ])-Edis(userP[user],shopP[Cshop])
                d=1-sigmoid(z)
                userP[user]=userP[user]+0.005*(d*2*(shopP[Cshop]-shopP[shopJ])-0.006*userP[user])
                shopP[Cshop]=shopP[Cshop]+0.005*(d*2*(userP[user]-shopP[Cshop])-0.006*shopP[Cshop])
                shopP[shopJ]=shopP[shopJ]+0.005*(d*2*(shopP[shopJ]-userP[user])-0.006*shopP[shopJ])
    fr=open('userP.txt','w')
    for key in userP.keys():
        fr.write(str(key)+'\t'+str(userP[key])+'\n')
    fr.close()
    fr=open('shopP.txt','w')
    for key in shopP.keys():
        fr.write(str(key)+'\t'+str(shopP[key])+'\n')
    fr.close()
    fr=open('shopS.txt','w')
    for key in shopS.keys():
        fr.write(str(key)+'\t'+str(shopS[key])+'\n')
    fr.close()
    return userP,shopP,shopS

def testG():
    userP,shopP,shopS=trainG()
    #userP=loadFileWithDic('userP.txt')
    #shopS=loadFileWithDic('shopS.txt')
    #shopP=loadFileWithDic('shopP.txt')
    data=getTestTuple("test.txt")
    visited=getVisited("train.txt")
    user=getUser()
    shop=getShop()
    allNum=0
    corNum=0
    count=0
    for item in data:
        (Cuser,exShop,Cshop,exTime,time)=item
        if Cuser not in user or exShop not in shop or Cshop not in shop or Cshop in visited[Cuser] or Cshop==exShop:
            continue
        allNum=allNum+1
        if exShop not in visited[Cuser]:
            visited[Cuser].append(exShop)
        poss={}
        count=count+1
        for pShop in shop:
            if pShop in visited[Cuser] or pShop==exShop:
                continue
            if (time-exTime)<6:
                d=haversine(position[exShop]['lat'],position[exShop]['lon'],position[pshop]['lat'],position[pshop]['lon'])
                w=pow(1+d1,0.25)
                poss[pShop]=w*(0.2*Edis(userP[Cuser],shopP[pShop])+0.8*Edis(shopS[exShop],shopS[pShop]))
            else:
                poss[pShop]=Edis(userP[Cuser],shopP[pShop])
        ans=min(poss.items(), key=lambda x: x[1])[0]
        if ans==Cshop:
            corNum=corNum+1
            print(str(corNum)+" : "+str(count))
    print("The currect rate is "+str((100.0*float(corNum))/float(allNum))+"%.")

代码如有问题，欢迎指正。

Poke_Z
关注
Adversarial Personalized Ranking for Recommendation(个人笔记)
qq_29717841的博客
04-11 1609
上周总结了一篇关于CPR_loss的文章，指导老师提出CPR_loss在采集正负样本标的标准和生成对抗网络方面有一些相似处，所以这周我就找到这一篇文章并加以总结。有趣的是，这一篇文章也是何向南老师组于2018年发表于SIGIR，下文我们简称为APR。 论文链接：https://arxiv.org/abs/1808.03908 代码链接：GitHub - hexiangnan/adversarial_personalized_ranking: Adversarial Learning, Matrix Fa
论文阅读:Billion-scale Commodity Embedding for E-commerce Recommendation in Alibaba
RecDay2018's Blog
01-01 7418
本文是阿里发表在KDD 2018，基于Graph Embedding实现淘宝首页推荐召回。主要通过用户点击的行为历史构建item图，学习图上所有item的embedding。同时为了解决可扩展性（scalability）、稀疏性（sparsity）、冷启动问题（cold start），在Item图的基础上，增加 item 的额外信息（例如category, brand, price等）丰富ite...
A Survey of Point-of-Interest Recommendation POI推荐综述
06-21
POI推荐综述，非常好的文章，内容很全面，讲解也很通俗易懂
Personalized Re-ranking for Recommendation
qq_41786778的博客
11-24 1003
https://www.jianshu.com/p/caecd082e48f
BERT模型
最新发布
qq_44250808的博客
09-26 965
BERT全称BidirectionalEncoder Representations from Transformer(基于Transformer的双向编码器）。BERT模型利用大规模无标注的预料训练，获得包含文本语义信息的表示。输入BERT的向量是融合三个部分的向量，分别是，最后将这三个向量加和输入到BERT模型中。
【论文解读 KDD 2018 | PME】PME: Projected Metric Embedding on Heterogeneous Networks for Link Prediction
byn12345的博客
03-07 3100
论文链接：http://net.pku.edu.cn/daim/hongzhi.yin/papers/KDD18-Hongxu.pdf 代码链接：https://sites.google.com/view/hongxuchen 会议：KDD 2018 目录 1 摘要 1.1 挑战 1.2 为解决上述挑战，作者提出 2 介绍 2.1 现有的方法 2.2 动机 2.3 启发 ...
The LambdaLoss Framework for Ranking Metric Optimization
1066196847的博客
04-04 1651
论文地址:https://storage.googleapis.com/pub-tools-public-publication-data/pdf/1e34e05e5e4bf2d12f41eb9ff29ac3da9fdb4de3.pdf 如何优化排名指标，例如标准化折扣累积增益（NDCG）是一个重要但具有挑战性的问题，因为排名指标在任何地方都是平坦的或不连续的，这使得它们很难直接优化。在现有的方法，LambdaRank 是一种新颖的算法，它在loss计算上结合了Metric排序指标，一般来说loss是尽.
rank_metric_with_spearman
龙行天下的博客
10-18 201
import pickle as pkl import numpy as np import os import cv2 import pandas as pd def calc_iou(mask_a, mask_b): intersection = (mask_a + mask_b >= 2).astype(np.float32).sum() iou = inters...
Personalized Ranking Recommendation via Integrating Multiple Feedbacks
02-22
个性化排序推荐系统是一种通过利用与用户和物品相关的用户-物品交互信息和/或内容信息来帮助用户找到感兴趣物品的系统。用户和物品之间的交互信息（即反馈）被广泛用于构建推荐模型。在推荐系统中，反馈数据通常以...
Ordinal Distance Metric Learning for Image Ranking
02-10
Recently, distance metric learning (DML) has attracted much attention in image retrieval, but most previous methods only work for image classification and clustering tasks. In this brief, we focus on ...
A Double-Ranking Strategy for Long-Tail Product Recommendation
02-09
本文主要探讨了一种用于长尾产品推荐的双排序策略。长尾产品通常指在传统市场销售中不常见或不受欢迎的商品，但在互联网环境下，它们由于较低的存储与销售成本，能够吸引到特定小众市场用户，从而占据市场销售的很大...
Graph-based POI Embedding
qifeiyang112358的博客
09-21 838
依然是POI推荐问题，这里作者将POI推荐的向量学习抽象为异构的网络，从而融合了序列因素、地理影响、时序变化影响和语义影响，利用图嵌入技术将这些信息降到低维空间中。如图： POI-POI，POI-region，POI-time，POI-Word 分别被看作双向图处理，依次获取序列、地理位置、时间和语义信息。图1，权重如GME-s，在时间片中的共现次数；图2，存在置为1；图3，根据频次设置权重；...
BERT模型的详细介绍
热门推荐
IT之一小佬的博客
04-01 11万+
BERT模型的详细介绍 1.BERT 的基本原理是什么？ BERT 来自 Google 的论文Pre-training of Deep Bidirectional Transformers for Language Understanding，BERT 是“Bidirectional Encoder Representations from Transformers”的首字母缩写，整体是一个自编码语言模型（Autoencoder LM），并且其设计了两个任务来预训练该模型。 第一个任务是采用 Ma
深度学习：BERT模型
皮皮blog
12-18 4万+
BERT出自的全称是Bidirectional Encoder Representation from Transformers，即双向Transformer的Encoder。作为一个Word2Vec的替代者，其在NLP领域的11个方向大幅刷新了精度，可以说是近年来自残差网络最优突破性的一项技术了。模型的主要创新点都在pre-train方法上，即用了Masked LM和Next Sentence Prediction两种方法分别捕捉词语和句子级别的representation。
一文读懂BERT模型
yihong23的博客
05-07 9552
语言表示模型 BERT 详解 摘要：在自然语言处理（NLP）领域，BERT（Bidirectional Encoder Representations from Transformers）是近几年出现的、影响深远的创新模型之一。自 2018 年由谷歌团队发布以来，BERT 为众多 NLP 任务设定了新的基准。BERT旨在通过在所有层中对左右上下文进行联合条件反射，从未标记的文本中预训练深度双向表示。因此，预训练的BERT模型可以通过一个额外的输出层进行微调，从而为广泛的任务(如问答和语言推理)创建最先进的
详细介绍BERT模型
zag666的博客
11-16 1万+
BERT通过在所有层中联合调节左右语境，从未标记的文本中预训练深度双向表征。因此，预训练的BERT模型可以通过一个额外的输出层进行微调，以创建最先进的模型，用于更广泛的任务，而无需对特定任务的架构进行大量修改。
【理论篇】是时候彻底弄懂BERT模型了(收藏)
日积月累，天道酬勤
09-09 5万+
看完本篇文章后，你就真的理解BERT模型的理论知识了。
Bert 模型学习
IT__learning的博客
10-15 2万+
一、Bert 模型 BERT 模型的全称是 BidirectionalEncoder Representations from Transformer，基于 Transformer 的双向编码器表示，是一个预训练的语言表征模型，它强调了不再像以往一样采用传统的单向语言模型或者把两个单向语言模型进行浅层拼接的方法进行预训练，而是采用新的 masked language model（MLM），以致能生成深度的双向语言表征。BERT 模型的目标是利用大规模无标注语料训练、获得文本的包含丰富语义信息的 Repres
图解BERT模型
qq_38343151的博客
02-04 8827
1. 模型的输入/输出 BERT模型的全称是：BidirectionalEncoder Representations from Transformer。从名字中可以看出，BERT模型的目标是利用大规模无标注语料训练、获得文本的包含丰富语义信息的Representation，即：文本的语义表示，然后将文本的语义表示在特定NLP任务中作微调，最终应用于该NLP任务。煮个栗子，BERT模型训练文本语...
隐式反馈下的社会信任感知推荐方法
基于这一假设，他们将社会信任融入了贝叶斯个性化排名模型（Bayesian Personalized Ranking, BPR），使得模型能够理解用户之间信任关系对其选择行为的潜在影响。 然后，为了更深入地挖掘用户多方面的信任关系，作者...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值