机器学习算法实现解析——libFM之libFM的训练过程之Adaptive Regularization
机器学习算法实现解析——libFM之libFM的训练过程之Adaptive Regularization
felixzhao
发布于 2018-03-20 16:16:56
发布于 2018-03-20 16:16:56
文章被收录于专栏：null的专栏
本节主要介绍的是libFM源码分析的第五部分之二——libFM的训练过程之Adaptive Regularization的方法。
5.3、Adaptive Regularization的训练方法
5.3.1、SGD的优劣
在“机器学习算法实现解析——libFM之libFM的训练过程之SGD的方法”中已经介绍了基于SGD的FM模型的训练方法，SGD的方法的最大优点是其训练过程很简单，只需在计算的过程中求解损失函数对每一个参数的偏导数，从而实现对模型参数的修改。
我们都知道，FM模型对正则化参数的选择比较敏感，在SGD的训练方法中，正则化参数是通过事先指定的，选择的优劣直接影响到训练的最终效果，那么，是否存在一种方法，能够自动选择正则化参数呢？此时，可以使用Adaptive Regularization的参数训练方法。
5.3.2、Adaptive Regularization方法的理论
对于SGD的方法，在学习的过程中，将损失函数ll分别对常数项的参数w0，一次项的参数wi以及交叉项的参数wiw_i求偏导，并利用梯度下降法更新模型中的对应参数，值得注意的是，这里的正则化参数是事先指定的，如常数项的正则化参数为λ0，一次项的正则化参数为λw以及交叉项的正则化参数为λf。基于SGD的训练过程如下所示：
那么，对于Adaptive Regularization的具体过程如下所示：
5.3.3、Adaptive Regularization方法的实现
Adaptive Regularization方法也是一种基于梯度的方法，因此其实现类fm_learn_sgd_element_adapt_reg类也继承自fm_learn_sgd类，其类之间的关系如下图所示：
Adaptive Regularization方法的实现在文件fm_learn_sgd_element_adapt_reg.h中，文件fm_learn_sgd_element_adapt_reg.h中实现了fm_learn_sgd_element_adapt_reg类，该类继承自fm_learn_sgd类，在fm_learn_sgd_element_adapt_reg类中，最重要的函数为learn函数，用于训练FM模型。函数的具体代码如下所示：
// self-adaptive-regularization 的训练
virtual void learn(Data& train, Data& test) {
fm_learn_sgd::learn(train, test);// 输出一些训练信息，继承自fm_learn_sgd类中的方法
std::cout << "Training using self-adaptive-regularization SGD."<< std::endl << "DON'T FORGET TO SHUFFLE THE ROWS IN TRAINING AND VALIDATION DATA TO GET THE BEST RESULTS." << std::endl;
// make sure that fm-parameters are initialized correctly (no other side effects)
// 确保初始化的过程
fm->w.init(0);
fm->reg0 = 0;
fm->regw = 0;
fm->regv = 0;
// start with no regularization
// 正则化参数的初始化，全部初始化为0
reg_w.init(0.0);
reg_v.init(0.0);
// 打印输出信息，包括训练样本点的条数和验证样本的条数
std::cout << "Using " << train.data->getNumRows() << " rows for training model parameters and " << validation->data->getNumRows() << " for training shrinkage." << std::endl;
// 基于梯度的训练过程
for (int i = 0; i < num_iter; i++) {// 开始每一轮的迭代
double iteration_time = getusertime();
// SGD-based learning: both lambda and theta are learned
// 分为lambda step和theta step
update_means();// 计算均值和方差
validation->data->begin();// 将验证集的指针指向开始位置
for (train.data->begin(); !train.data->end(); train.data->next()) {
// 计算theta相关，更新theta中的参数
// 利用训练集训练和更新模型的参数，此时模型中的正则化参数是固定的
sgd_theta_step(train.data->getRow(), train.target(train.data->getRowIndex()));
// 当i=0时，不需要更新lambda
if (i > 0) { // make no lambda steps in the first iteration, because some of the gradients (grad_theta) might not be initialized.
// 每次只使用validation中的一条样本
if (validation->data->end()) {
update_means();// 计算均值和方差
validation->data->begin();// 将验证集的指针指向开始位置
}
// 计算lambda相关，更新lambda中的参数
// 利用验证集更新正则化参数，此时模型中的参数是固定的
sgd_lambda_step(validation->data->getRow(), validation->target(validation->data->getRowIndex()));
validation->data->next();// 将验证集的指针指向下一条样本
}
}
// (3) Evaluation
iteration_time = (getusertime() - iteration_time);
// 评价函数
double rmse_val = evaluate(*validation);// 对验证集进行评测
double rmse_train = evaluate(train);// 对训练集进行评测
double rmse_test = evaluate(test);// 对测试集进行评测
// 打印输出模型的评估结果
std::cout << "#Iter=" << std::setw(3) << i << "\tTrain=" << rmse_train << "\tTest=" << rmse_test << std::endl;
// 日志输出
if (log != NULL) {
// log 输出均值和方差
log->log("wmean", mean_w);
log->log("wvar", var_w);
for (int f = 0; f < fm->num_factor; f++) {
{
std::ostringstream ss;
ss << "vmean" << f;
log->log(ss.str(), mean_v(f));
}
{
std::ostringstream ss;
ss << "vvar" << f;
log->log(ss.str(), var_v(f));
}
}
// log 输出正则化参数
for (uint g = 0; g < meta->num_attr_groups; g++) {
{
std::ostringstream ss;
ss << "regw[" << g << "]";
log->log(ss.str(), reg_w(g));
}
for (int f = 0; f < fm->num_factor; f++) {
{
std::ostringstream ss;
ss << "regv[" << g << "," << f << "]";
log->log(ss.str(), reg_v(g,f));
}
}
}
// log输出训练时间和评估效果
log->log("time_learn", iteration_time);
log->log("rmse_train", rmse_train);
log->log("rmse_val", rmse_val);
log->newLine();
}
}
}根据上面的理论分析，Adaptive Regularization方法的学习过程分为两步：
- 固定正则化参数，利用训练集学习更新FM模型中的参数；
- 固定FM模型的参数，利用验证集学习更新正则化参数。
这两个过程可由下图表示：
在代码的实现过程中，sgd_theta_step函数负责对FM模型中的参数进行学习和更新；sgd_lambda_step函数负责对正则化参数进行学习和更新。sgd_theta_step函数的具体代码如下所示：
// 计算theta相关，更新theta中的参数
void sgd_theta_step(sparse_row<FM_FLOAT>& x, const DATA_FLOAT target) {
double p = fm->predict(x, sum, sum_sqr);// 得到样本的预测值，在fm_model中
double mult = 0;
// 区分分类问题还是回归问题
if (task == 0) {
p = std::min(max_target, p);
p = std::max(min_target, p);
mult = 2 * (p - target);// 梯度值的一部分
} else if (task == 1) {
mult = target * ( (1.0/(1.0+exp(-target*p))) - 1.0 );// 梯度值的一部分
}
// make the update with my regularization constants:
// 更新每一部分的参数
// 1、更新常数项的权重
if (fm->k0) {
double& w0 = fm->w0;// 常数项的权重
double grad_0 = mult;// 梯度值
w0 -= learn_rate * (grad_0 + 2 * reg_0 * w0);// 更新常数项的权重
}
// 2、更新一次项的权重
if (fm->k1) {
for (uint i = 0; i < x.size; i++) {
uint g = meta->attr_group(x.data[i].id);// 取得参数对应的分组的编号
double& w = fm->w(x.data[i].id);// 得到模型的对应一次项的参数
grad_w(x.data[i].id) = mult * x.data[i].value;// 一次项的梯度值
w -= learn_rate * (grad_w(x.data[i].id) + 2 * reg_w(g) * w);// 更新一次项的权重值
}
}
// 3、更新交叉项的权重
for (int f = 0; f < fm->num_factor; f++) {
for (uint i = 0; i < x.size; i++) {
uint g = meta->attr_group(x.data[i].id);// 取得参数对应的分组的编号
double& v = fm->v(f,x.data[i].id);// 取得模型的对应交叉项的参数
grad_v(f,x.data[i].id) = mult * (x.data[i].value * (sum(f) - v * x.data[i].value)); // grad_v_if = (y(x)-y) * [ x_i*(\sum_j x_j v_jf) - v_if*x^2 ] // 交叉项的梯度值
v -= learn_rate * (grad_v(f,x.data[i].id) + 2 * reg_v(g,f) * v);// 更新交叉项的权重值
}
}
}
在libFM的实现过程中，对正则化参数进行了分组，分组的概念如下图所示：
假设有77个参数，标号分别为{0,1,2,3,4,5,6,7}\left { 0,1,2,3,4,5,6,7 \right }，假设将00和11划分到一个分组中，如下图中的22标号，同理，将22，66划分到一个分组，将33，44，55划分到一个分组中，对于同一个分组，其拥有一个单独的正则化参数。这样就能够减少正则化参数的个数。
第二个重要的部分是sgd_lambda_step函数，其具体的代码如下所示：
// 计算lambda相关，更新lambda中的参数
void sgd_lambda_step(sparse_row<FM_FLOAT>& x, const DATA_FLOAT target) {
double p = predict_scaled(x);// 扩展后的预测值
double grad_loss = 0;
// 区分两类问题：回归问题和分类问题
if (task == 0) {// 回归问题
p = std::min(max_target, p);
p = std::max(min_target, p);
grad_loss = 2 * (p - target);
} else if (task == 1) {// 分类问题
grad_loss = target * ( (1.0/(1.0+exp(-target*p))) - 1.0);
}
// 1、更新一次项的正则化参数
if (fm->k1) {
lambda_w_grad.init(0.0);// 初始化
// 将累加和分配到每一个分组中
for (uint i = 0; i < x.size; i++) {
uint g = meta->attr_group(x.data[i].id);// 取得当前特征对应的正则化参数的索引
lambda_w_grad(g) += x.data[i].value * fm->w(x.data[i].id);// 在对应的分组中计算累加和
}
// 修改每一个分组内的正则化参数
for (uint g = 0; g < meta->num_attr_groups; g++) {
lambda_w_grad(g) = -2 * learn_rate * lambda_w_grad(g);
reg_w(g) -= learn_rate * grad_loss * lambda_w_grad(g);
reg_w(g) = std::max(0.0, reg_w(g));// 对修改后的正则化参数容错，防止其小于0
}
}
// 2、更新交叉项的正则化参数
for (int f = 0; f < fm->num_factor; f++) {
// grad_lambdafg = (grad l(y(x),y)) * (-2 * alpha * (\sum_{l} x_l * v'_lf) * (\sum_{l \in group(g)} x_l * v_lf) - \sum_{l \in group(g)} x^2_l * v_lf * v'_lf)
// sum_f_dash := \sum_{l} x_l * v'_lf, this is independent of the groups
// sum_f(g) := \sum_{l \in group(g)} x_l * v_lf
// sum_f_dash_f(g) := \sum_{l \in group(g)} x^2_l * v_lf * v'_lf
double sum_f_dash = 0.0;
sum_f.init(0.0);
sum_f_dash_f.init(0.0);
for (uint i = 0; i < x.size; i++) {
// v_if' = [ v_if * (1-alpha*lambda_v_f) - alpha * grad_v_if]
uint g = meta->attr_group(x.data[i].id);// 取得当前特征对应的正则化参数的索引
double& v = fm->v(f,x.data[i].id);// 取得模型的对应交叉项的参数
double v_dash = v - learn_rate * (grad_v(f,x.data[i].id) + 2 * reg_v(g,f) * v);
// 更新公式中的三项
sum_f_dash += v_dash * x.data[i].value;
sum_f(g) += v * x.data[i].value;
sum_f_dash_f(g) += v_dash * x.data[i].value * v * x.data[i].value;
}
// 对每一个分组中的正则化参数更新
for (uint g = 0; g < meta->num_attr_groups; g++) {
double lambda_v_grad = -2 * learn_rate * (sum_f_dash * sum_f(g) - sum_f_dash_f(g));
reg_v(g,f) -= learn_rate * grad_loss * lambda_v_grad;
reg_v(g,f) = std::max(0.0, reg_v(g,f));// 对修改后的正则化参数容错，防止其小于0
}
}
}
其具体的计算过程如predict_scaled函数所示：
// 扩展后的预测值，是指在模型的预测值中增加了正则项
double predict_scaled(sparse_row<FM_FLOAT>& x) {
double p = 0.0;// 最终的预测值
// 1、常数项
if (fm->k0) {
p += fm->w0;// 常数项，注意这边并没有对常数项增加正则
}
// 2、一次项
if (fm->k1) {
// 累加每一维特征项
for (uint i = 0; i < x.size; i++) {
assert(x.data[i].id < fm->num_attribute);// 特征的维度的容错
uint g = meta->attr_group(x.data[i].id);// 取得当前特征对应的正则化参数的索引
double& w = fm->w(x.data[i].id);// 取得当前的权重
double w_dash = w - learn_rate * (grad_w(x.data[i].id) + 2 * reg_w(g) * w);// 更新权重
p += w_dash * x.data[i].value; // 累加计算
}
}
// 3、交叉项
for (int f = 0; f < fm->num_factor; f++) {
// sum和sum_sqr分别对应着交叉项计算中的两项
sum(f) = 0.0;
sum_sqr(f) = 0.0;
for (uint i = 0; i < x.size; i++) {
uint g = meta->attr_group(x.data[i].id);// 取得当前特征对应的正则化参数的索引
double& v = fm->v(f,x.data[i].id);// 取得模型的对应交叉项的参数
double v_dash = v - learn_rate * (grad_v(f,x.data[i].id) + 2 * reg_v(g,f) * v);// 更新交叉项的参数
double d = v_dash * x.data[i].value;
sum(f) += d;
sum_sqr(f) += d*d;
}
p += 0.5 * (sum(f)*sum(f) - sum_sqr(f));
}
return p;
}注意：在libFM的实现中，并没有对模型的常数项增加正则项，因此在更新正则项参数时也不需要更新常数项的正则化参数。
对预测值的计算，可以参见“机器学习算法实现解析——libFM之libFM的模型处理部分”。
计算完扩展的预测值后，便开始计算损失函数对正则化参数的梯度，并对其进行更新，更新的详细步骤参见“5.3.2、Adaptive Regularization方法的理论”中的讲解。
除了上述的重要的过程外，在fm_learn_sgd_element_adapt_reg类中还提供了如下的几个函数：
- 初始化
init函数
// 初始化函数，比SGD中初始化更多的参数
virtual void init() {
fm_learn_sgd::init();
reg_0 = 0;// 常数项的正则化参数的初始化
reg_w.setSize(meta->num_attr_groups);// 一次项的正则化参数
reg_v.setSize(meta->num_attr_groups, fm->num_factor);// 交叉项的正则化参数
// 交叉项的均值和方差
mean_v.setSize(fm->num_factor);
var_v.setSize(fm->num_factor);
// 一次项的梯度的初始化
grad_w.setSize(fm->num_attribute);
// 交叉项的梯度的初始化
grad_v.setSize(fm->num_factor, fm->num_attribute);
grad_w.init(0.0);
grad_v.init(0.0);
lambda_w_grad.setSize(meta->num_attr_groups);// 正则化参数的梯度
// 更新lambda时使用到的变量
sum_f.setSize(meta->num_attr_groups);
sum_f_dash_f.setSize(meta->num_attr_groups);
// 日志文件
if (log != NULL) {
log->addField("rmse_train", std::numeric_limits<double>::quiet_NaN());
log->addField("rmse_val", std::numeric_limits<double>::quiet_NaN());
log->addField("wmean", std::numeric_limits<double>::quiet_NaN());
log->addField("wvar", std::numeric_limits<double>::quiet_NaN());
for (int f = 0; f < fm->num_factor; f++) {
{
std::ostringstream ss;
ss << "vmean" << f;
log->addField(ss.str(), std::numeric_limits<double>::quiet_NaN());
}
{
std::ostringstream ss;
ss << "vvar" << f;
log->addField(ss.str(), std::numeric_limits<double>::quiet_NaN());
}
}
for (uint g = 0; g < meta->num_attr_groups; g++) {
{
std::ostringstream ss;
ss << "regw[" << g << "]";
log->addField(ss.str(), std::numeric_limits<double>::quiet_NaN());
}
for (int f = 0; f < fm->num_factor; f++) {
{
std::ostringstream ss;
ss << "regv[" << g << "," << f << "]";
log->addField(ss.str(), std::numeric_limits<double>::quiet_NaN());
}
}
}
}
}init函数主要用于对一些变量的初始化。
update_means函数
// 初始化相关
void update_means() {
// 均值和方差
mean_w = 0;
mean_v.init(0);
var_w = 0;
var_v.init(0);
// 1、计算w的均值和方差
for (uint j = 0; j < fm->num_attribute; j++) {
mean_w += fm->w(j);
var_w += fm->w(j)*fm->w(j);
for (int f = 0; f < fm->num_factor; f++) {
mean_v(f) += fm->v(f,j);
var_v(f) += fm->v(f,j)*fm->v(f,j);
}
}
mean_w /= (double) fm->num_attribute;// 计算均值
var_w = var_w/fm->num_attribute - mean_w*mean_w;// 计算方差
// 2、计算v的均值和方差
for (int f = 0; f < fm->num_factor; f++) {
mean_v(f) /= fm->num_attribute;
var_v(f) = var_v(f)/fm->num_attribute - mean_v(f)*mean_v(f);
}
// 3、重新置均值为0
mean_w = 0;
for (int f = 0; f < fm->num_factor; f++) {
mean_v(f) = 0;
}
}update_means函数用于对模型的参数求方差，这整个训练过程中并不起作用，只是为了log输出作为参考。
debug函数
// debug打印输出
void debug() {
std::cout << "method=sgda" << std::endl;
fm_learn_sgd::debug();
}参考文献
- Rendle S. Factorization MachinesC// IEEE International Conference on Data Mining. IEEE Computer Society, 2010:995-1000.
- Rendle S. Factorization Machines with libFMM. ACM, 2012.
- Rendle S. Learning recommender systems with adaptive regularizationC// ACM International Conference on Web Search and Data Mining. ACM, 2012:133-142.
本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录
腾讯云开发者
