【读书笔记】推荐系统算法实践（一）

这里重点是做了协同过滤算法的阅读，以及对我比较重要的一些知识。

还有之前的pytorch里的一些函数介绍。。

 

---

损失函数

均方损失

最小二乘法：线性回归方法。拟合曲线应该使所有点到回归直线的距离和最小。

一般用欧几里得距离度量。

$L(Y|f(X)) = sumlimits_{N}(Y-f(X))^{2}$

log对数损失函数：逻辑回归的损失函数就是对数损失函数。

假设样本服从伯努利分布，然后求似然函数，再用对数求极值。

$L(Y|f(X)) = -logP(Y|X)$

指数损失函数：AdaBoost就是指数损失函数。

$L(Y|f(X)) = exp[-yf(x)]$

CODE

import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F

sample = Variable(torch.ones(2,2))
a=torch.Tensor(2,2)
a[0,0]=0
a[0,1]=1
a[1,0]=2
a[1,1]=3
target = Variable (a)
#sample: [[1,1],[1,1]]
#target: [[0,1],[2,3]]


#基本用法
criterion = LossCriterion() #构造函数有自己的参数
loss = criterion(x, y)      #调用标准时也有参数
#计算出来的结果已经对mini-batch取了平均


#L1Loss
#预测值和真实值的绝对误差的平均数
criterion = nn.L1Loss()
loss = criterion(sample, target)
#1


#SmoothL1Loss
#HuberLoss,误差在（-1，1）平方损失，其他L1损失
criterion = nn.SmoothL1Loss()
loss = criterion(sample, target)
#0.625


#MSELoss
#平方损失，预测值和真实值之间的平方和的平均数
criterion = nn.MSELoss()
loss = criterion(sample, target)
#1.5


#nn.NLLLoss
#负对数似然损失函数
#loss(x,class) = -x[class]
#loss(x,class) = −weights[class]∗x[class]   weights被指定

m = nn.LogSoftmax()
loss = nn.NLLLoss()
# input is of size nBatch x nClasses = 3 x 5
input = torch.autograd.Variable(torch.randn(3, 5), requires_grad=True)
# each element in target has to have 0 <= value < nclasses
target = torch.autograd.Variable(torch.LongTensor([1, 0, 4]))
output = loss(m(input), target)
output.backward()

---

优化方法

SGD：随机梯度下降。

每次迭代计算小批量的梯度，使用于数据量比较大的数据集

Momentum：使用动量的SGD。

通过积累动量来作为梯度使用。

AdaGrad：对学习率进行约束。

适合处理稀疏梯度，对全局学习率参数比较敏感。

Adam：通过梯度对一阶矩和二阶据估计动态调整每个参数学习率。

经过偏置校正后，每一次迭代学习率有确定范围，使参数值比较平稳。

内存要求小，适用于大数据集和高维空间，也适用于大多数非凸优化。

CODE

import torch.optim

#使用
optimizer = optim.SGD(model.parameters(), lr = 0.01, momentum=0.9)
optimizer = optim.Adam([var1, var2], lr = 0.0001)

#基类
torch.optim.Optimizer(params, defaults)
#params: Variable或者dict的iterable，指定什么参数应当被优化
#defaults: 包含了优化选项默认值的字典

#方法：
load_state_dict(state_dict) #加载optimizer状态
state_dict()                #state:保存优化状态的dict，param_groups:包含全部参数组
zero_grad()                 #清空被优化的Variable的梯度
optimizer.step()            #单次优化
optimizer.step(closure)     #重复多次计算函数，传入闭包，闭包需要清空。
for input,target in dataset:
    def closure():
        optimizer.zero_grad()
        output = model(input)
        loss = loss_fn(output,target)
        loss.backward()
        return loss
    optimizer.step(closure)



#SGD
torch.optim.SGD(params,lr=0.01,momentum=0,dampening=0,weight_decay=0,nesterov=False)
#params: 待优化参数
#lr(float): 学习率
#momentum (float, 可选): 动量因子（默认为0）
#dampening (float, 可选): 动量的抑制因子（默认为0）
#weight_decay (float, 可选): 权重衰减（L2惩罚）（默认为0）
#nesterov (bool, 可选): 使用Nesterov动量（默认为False）

#Adagrad
torch.optim.Adagrad(params, lr=0.01, lr_decay=0, weight_decay=0)
#lr_decay (float, 可选): 学习率衰减（默认为0）

#Adam
torch.optim.Adam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)
#betas (Tuple[float, float], 可选): 用于计算梯度以及梯度平方的运行平均值的系数（默认：0.9，0.999）
#eps (float, 可选): 为了增加数值计算的稳定性而加到分母里的项（默认：1e-8）