2011年7月26日,星期二

日志TF

我使用一种编码来解决文本分类问题,该编码在经验上有助于在使用线性分类器(例如 Vowpal兔子 与名义上编码的令牌。换句话说,如果您要输入这样的输入
1 |男孩会男孩
-1 |我来了,我看到了我被征服了
对于Vowpal来说,希望构建一个二进制分类器,您可以做得更好。

在使用logistic损失的情况下,一个是用unigram进行logistic回归,这形成了 生成辨别对 与多项朴素的贝叶斯。因此,如果编码有助于改善朴素的贝叶斯,那么它也可以改善与字母组合的逻辑回归。 伦尼(Rennie)等。等 提出了多项多项式朴素贝叶斯改进,包括对数项频率(TF)编码。为了获得动力,请考虑朴素贝叶斯背后的生成模型,该模型说,以类标签为条件,文档的可能性由\ [
p(D | \ theta)\ propto \ prod_ {w \ in V} \ theta_w ^ {c_w(D)},
\]其中$ V $是词汇量,$ \ theta $是特定于标记的类标签分布,而$ c_w(D)$是文档中标记$ w $的计数。伦尼(Rennie)等。等声称此生成模型的问题在于,相对于凭经验观察到的结果而言,它低估了文档中重复标记的可能性(我同意,已经看到包含由标记``HA''组成的推文重复了11次)。这个问题类似于高斯分布,在最小二乘回归中,离群值的可能性不足。 一种解决方法 用诸如t分布之类的较重的分布代替。他们特别建议\ [
p(D | \ theta)\ propto \ prod_ {w \ in V} \ theta_w ^ {\ log_2(1 + c_w(D))},
\]在结构上是相同的,但使用了计数这一术语。在实践中,我喜欢保留双字扩展的字序,因此我将$ \ log_2(1 + c_w(D))/ c_w(D)$权重分配给输入中每个令牌实例,从而得到
1 |男孩:0.792将会:1是:1男孩:0.792
-1 |我:0.666来了:1我:0.666看到了:1我:0.666被征服了:1
实际上,这可以可靠地提高文本分类性能。他们在该论文中提到的其他一些技巧可以解决某些问题,而不是其他一些问题,因此通常都值得尝试,但是以我的经验,这确实是有帮助的。

日志TF LDA

现在可以进行更多投机活动了。考虑LDA的生成模型,确定每个职位的所有主题分配的条件,然后查看共享相同主题分配的那些职位上单词的分布:这是多项式分布。但是,等等,我们已经确定多项式低估了文档中标记重复的可能性;理所当然地,LDA也遭受同样的问题。我建议只做上面概述的log TF转换;尽管从数学上讲这可能没有意义(结果的可能性与Dirichlet不共轭),但在操作上没有特别的困难。对于变体方法,文档通过单词计数进行汇总,分数计数没有根本问题。对于Gibbs抽样,可以维护对主题的单词分配的各种计数以及每个文档的总数,这仍然可以是分数。

怎么知道最终的模型更好?我认为查看困惑不会有所帮助,因为通过更改令牌计数,可以更改困惑的定义。因此,我将看一下使用LDA的端到端上下文。例如,使用LDA作为监督分类系统的深度学习特征提取器,我将研究log TF LDA是否产生更好的整体分类性能。

2011年7月20日,星期三

推荐多样性

在推荐系统中,仅使用总体平均评分,每个用户的平均评分和每个项目的平均评分的预测变量形成了强大的基线,令人惊讶地难以超越(就原始预测准确性而言)。当我向查尔斯·埃尔坎(Charles Elkan)询问此事时,他提到有已发表的论文,其报告的结果未能超过该基线。尽管这很有趣,但他指出(释义)``这不仅与准确性有关;没有人喜欢线性基线,因为它向所有人提出了相同的建议。''

我决定使用 电影镜头10m 数据集。首先,对于每个用户,我随机保留其两个评分,然后将其余评分添加到训练集中。我使用 分析重要性感知更新,用于分位数损失。然后,我在测试集中计算了评级MAE。我还计算了每个用户的AUC,如果模型正确地订购了两个保留的等级,则定义为1,否则定义为0;将整个用户的平均数量得出的结果称为``用户AUC''。当然,如果要针对AUC进行优化,则应简化为成对分类,并使用铰链损耗,而不要使用分位数损耗。但是我也很感兴趣,我在MAE中看到的适度收益是否会导致AUC收益更大。结果如下:\ [
\ begin {array} {| c | c | c |}
\ mbox {模型}&\ mbox {MAE(测试集)}&\ mbox {用户AUC(测试集)} \\ \ hline
\ mbox {最佳常数}&\ mbox {0.420}&\ mbox {0.5} \\
\ mbox {线性}&\ mbox {0.356}&\ mbox {0.680} \\
\ mbox {Dyadic $ k = 1 $}&\ mbox {0.349}&\ mbox {0.692} \\
\ mbox {Dyadic $ k = 5 $}&\ mbox {0.338}&\ mbox {0.706} \\
\ mbox {Dyadic $ k = 10 $}&\ mbox {0.335}&\ mbox {0.709}
\ end {array}
\]如前所述,预测升幅(针对两个指标)的最大份额来自线性基线,即$ \ alpha_ {user} + \ beta_ {movie} + c $形式的模型。添加具有潜在维度$ k $的形式为$ a_ {user} ^ \ top b_ {movie} $的附加二项项会稍微提高准确性(尽管我没有进行交叉验证,将User AUC视为二项式意味着$ 0.004 $的标准误,这表明用户AUC的二元提升几乎没有意义)。

接下来,我介绍了推荐多样性。我从用户中随机抽取了一个子样本(结果大小为11597),详尽估计了数据集中每个电影的排名,然后为每个用户计算了前三部电影。在每种尺寸$ n = \ {1,2,3 \} $下,我查看了建议该尺寸的最受欢迎电影集的发布频率($ \ max p_n $),并且还计算了推荐的电影(集合,而不是列表:如果一个用户有推荐$ a,b,c $,而另一个用户有推荐$ c,b,a $,则认为它们相同)。 \ [
\ begin {array} {| c | c | c | c | c | c | c |}
\ mbox {模型}&\ max p_1&\ mbox {独特的1组}&\ max p_2&\ mbox {独特的2组}&\ max p_3&\ mbox {独特的3组} \\ \ hline
\ mbox {线性}&\ mbox {1}&\ mbox {1}&\ mbox {1}&\ mbox {1}&\ mbox {1}&\ mbox {1} \\
\ mbox {Dyadic $ k = 1 $}&\ mbox {0.478}&\ mbox {6}&\ mbox {0.389}&\ mbox {10}&\ mbox {0.218}&\ mbox {18} \\
\ mbox {Dyadic $ k = 5 $}&\ mbox {0.170}&\ mbox {112}&\ mbox {0.120}&\ mbox {614}&\ mbox {0.069}&\ mbox {1458} \\
\ mbox {Dyadic $ k = 10 $}&\ mbox {0.193}&\ mbox {220}&\ mbox {0.102}&\ mbox {1409}&\ mbox {0.035}&\ mbox {3390}
\ end {array}
\]正如预期的那样,线性模型中没有推荐的多样性。然而,有趣的是,即使准确性指标没有显着提高,分集也会随着潜在维数的增加而爆炸。对于$ k = 10 $,前3个建议集中的多样性是巨大的:共享相同前3个建议的最大用户组仅占用户群的3.5%。 ($ k = 10 $和$ \ max p_1 $的0.193结果不是错别字;即使有更多推荐的独特电影被推荐为用户的顶级电影,$ k = 10的最受欢迎的#1电影与$ k = 5 $相比,选择$的频率更高。不确定发生了什么。)

如果您要去产品经理那里说:“我有两个推荐模型,它们具有相同的准确性,但是一个向所有人提出相同的建议,而另一个向不同的人提出不同的建议,您想要哪个?”您可以打赌产品经理会说第二个。实际上,为了达到推荐多样性而牺牲一些准确性可能是可以接受的。考虑到二元模型可以提高准确性和多样性,因此是双赢的。

2011年7月17日,星期日

快速近似兰伯特W

毕竟,这只是个人用途的问题, 兰伯特的W 功能 一旦 在机器学习上下文中,它以$ W(\ exp(x))-x $出现,最好直接近似。尽管如此,生成这些快速的近似函数使娱乐变得有趣,并且与例如进一步发展我的计算机游戏能力相比,对某处某人有用的可能性要高得多。

无分支的生活方式

Lambert W在一个方面是典型的函数:有一个很好的渐近逼近可以用来初始化一个 户主法,但仅适用于部分域。特别是对于大$ x $,\ [
W(x)\ approx \ log(x)-\ log \ log(x)+ \ frac {\ log \ log(x)} {\ log(x)},
\]很棒,因为 对数便宜。不幸的是,对于$ x \ leq 1 $,无法评估,对于$ 1< x <2 $它给出了非常差的结果。一种自然的处理方式是为$ x使用不同的初始化策略< 2$.
if (x < 2)
  { 
    // alternate initialization
  }
else
  {
    // use asymptotic approximation
  }

// householder steps here
这种简单的方法存在两个问题。在标量上下文中,这可以 挫败流水线架构 现代CPU。在向量上下文中,这甚至更成问题,因为组件可能会落入条件的不同分支中。

该怎么办?事实证明像这样
a = (x < 2) ? b : c
看起来像有条件的,但不是必须的,因为它们可以重写为
a = f (x < 2) * b + (1 - f (x < 2)) * c
$ f $是一个指示符函数,根据参数的真值返回0或1。 SSE指令集包含以下指标功能 比较测试,当与 ``浮点数和'' 指令最终计算出无分支三元运算符。

底线是,如果计算条件的两个分支,则可以使确定性执行具有确定性,并且在足够简单的情况下,可以直接硬件支持快速执行此操作。

无分支兰伯特W

因此,这里的主要思想是为Householderer步骤进行另一种初始化,以便可以对无输入方式进行计算,因为对于大的输入使用渐近逼近。因此,我寻找\\形式的近似值
W(x)\大约a + \ log(c x + d)-\ log \ log(c x + d)+ \ frac {\ log \ log(c x + d)} {\ log(c x + d)},
\]对于大$ x $,$ a = 0 $,$ c = 1 $和$ d = 0 $。我通过Mathematica找到了$ a $,$ c $,$ d $的值和$ x $的临界值。 (好奇的可以查看 Mathematica笔记本)。矢量版本最终看起来像
// WARNING: this code has been updated.  Do not use this version.
// Instead get the latest version from http://code.google.com/p/fastapprox

static inline v4sf
vfastlambertw (v4sf x)
{
  static const v4sf threshold = v4sfl (2.26445f);

  v4sf under = _mm_cmplt_ps (x, threshold);
  v4sf c = _mm_or_ps (_mm_and_ps (under, v4sfl (1.546865557f)),
                      _mm_andnot_ps (under, v4sfl (1.0f)));
  v4sf d = _mm_and_ps (under, v4sfl (2.250366841f));
  v4sf a = _mm_and_ps (under, v4sfl (-0.737769969f));

  v4sf logterm = vfastlog (c * x + d);
  v4sf loglogterm = vfastlog (logterm);

  v4sf w = a + logterm - loglogterm + loglogterm / logterm;
  v4sf expw = vfastexp (w);
  v4sf z = w * expw;
  v4sf p = x + z;

  return (v4sfl (2.0f) * x + w * (v4sfl (4.0f) * x + w * p)) /
         (v4sfl (2.0f) * expw + p * (v4sfl (2.0f) + w));
}
您可以从 快速约 项目。

时间和准确性

时序测试是通过编译完成的 -O3 -finline功能-fast-math,在运行64位Ubuntu Lucid(所以 gcc 4:4.4.3-1ubuntu1libc 2.11.1-0ubuntu7.6)。我还测量了以$(\ frac {1} {2} U(-1 / e,1)+ \ frac {1} {2} U(0,100))$分布的$ x $的平均相对准确度,即,从两个均匀分布中抽取50-50。将精度与牛顿方法的20次迭代进行比较,当$ x时,初始点为0<5 $,否则渐近逼近。我还测试了 gsl实施 精度更高,但速度明显慢得多。
Fastlambertw average relative error = 5.26867e-05
fastlambertw max relative error (at 2.48955e-06) = 0.0631815
fasterlambertw average relative error = 0.00798678
fasterlambertw max relative error (at -0.00122776) = 0.926378
vfastlambertw average relative error = 5.42952e-05
vfastlambertw max relative error (at -2.78399e-06) = 0.0661513
vfasterlambertw average relative error = 0.00783347
vfasterlambertw max relative error (at -0.00125244) = 0.926431
gsl_sf_lambert_W0 average relative error = 5.90309e-09
gsl_sf_lambert_W0 max relative error (at -0.36782) = 6.67586e-07
fastlambertw million calls per second = 21.2236
fasterlambertw million calls per second = 53.4428
vfastlambertw million calls per second = 21.6723
vfasterlambertw million calls per second = 56.0154
gsl_sf_lambert_W0 million calls per second = 2.7433
这些平均精度在最小域中隐藏了相对较差的性能。就在$ x = -e ^ {-1} $,这是该域的最小值, Fastlambertw 近似差(-0.938,而正确答案是-1;因此相对误差为$ 6 \%$);但是在$ x = -e ^ {-1} + \ frac {1} {100} $时,相对误差降为$ 2 \乘以10 ^ {-4} $。

2011年7月13日,星期三

更多重要的更新

重要性感知更新

在重要性加权回归或分类中,每个示例损失是按比例缩放的规范损失,\ [
L (w) = E_{x \sim D} \left[ \epsilon (x) 长(x; w)\right],
\]通过随机梯度下降优化,
w_ {n + 1} = w_n-\ eta \ epsilon(x_n)\ frac {\ partial L(x_n; w)} {\ partial w} \ biggr | _ {w = w_n},
\]其中$ \ eta $是学习率。实际上,当重要性权重$ \ epsilon(x_n)$过大(相对于$ \ eta $)时,此更新变得不稳定。不稳定比说更新不会减少总损失要糟糕得多。很容易发生损失 在这个例子中 我认为这就是为什么物流损失如此流行的原因,因为它从本质上防止了这种情况,因此不会因更新而减少。但是当使用铰链损耗,平方损耗或分位数损耗时,凭经验很难遇到这种不稳定性。

的见识 Karampatziakis和Langford 将上述更新视为方程\ [的一阶Euler积分器
w ^ \ prime(h)=-\ eta \ epsilon(x_n)\ frac {\ partial L(x_n; w)} {\ partial w} \ biggr | _ {w = w(h)},
\]在这种情况下 GLM 针对实际中常用的损失函数提供了一种解析解决方案。这是因为对于GLM,损失函数采用$ L(x_n; w)= l(w ^ \ top x_n)$的形式,其梯度始终是$ x_n $的缩放版本。因此,存在一个\ [
宽(高)= w - s (h) x_n,
\]其中\ [
s ^ \ prime(h)= \ eta \ epsilon(x_n)\ frac {\ partial l} {\ partial p} \ biggr | _ {p =(w-s(h)x_n)^ \ top x_n},
\]是一维ODE,具有用于$ l $的许多常见选择(例如,铰链,平方,对数等)的分析解决方案。

尽管最初是由主动学习(它会产生很大的动态范围的重要性权重)激励,但是重要性感知更新甚至对于非重要性加权问题也很有用,因为它提供了关于学习率规范的鲁棒性。我已经沉迷于重要性感知更新在实际数据上凭经验表现出的健壮性,因此,当我遇到新情况时,我总是在寻找重要性感知更新。我对此做了一些调查 二元模型 以前,但是还有其他两种情况。在这两种情况下,由于减少,损失函数一次要在多个输入上进行评估。

通过成对分类排名

为了优化AUC,有一个 归结为成对分类 混合标签实例。在使用SGD进行训练时,这意味着将成对的示例$(x_ +,x _-)$提供给分类器,其中$ x _ + $的排名高于$ x _- $。如果所需结果是线性计分函数$ f(x; w)= w ^ \ top x $,则目标为$ 1_ {w ^ \ top(x_ +-x_-)>0} $,将其放宽到以下每个示例对的凸损失\ [
\ begin {aligned}
L(x_ +,x_-; w)&= \ epsilon(x_ +,x_-)l \ left(w ^ \ top(x_ +-x_-),1 \ right),\\
w ^ \素数(h)&= -\eta \epsilon (x_+, x_-) \frac{\partial L (x_+, x_-;w)} {\ partial w} \ biggr | _ {w = w(h)} \\
&=-\ eta \ epsilon(x_ +,x_-)\ frac {\ partial l} {\ partial p} \ biggr | _ {p = w(h)^ \ top(x_ +-x_-)}(x_ +-x_-)。
\ end {aligned}
\]再次将所有梯度指向同一方向,因此寻找形式为$ w(h)= w-s(h)(x_ +-x _-)$,[[
\ begin {aligned}
s ^ \ prime(h)&=-\ eta \ epsilon(x_ +,x_-)\ frac {\ partial l} {\ partial p} \ biggr | _ {p =(w-s(h)(x_ + -x _-))^ \ top(x_ +-x_-)}。
\ end {aligned}
\]可能不足为奇的是,重要性感知更新与分类相同,只是它是使用差异向量计算的。换一种说法,
  1. 接收具有重要权重$ \ epsilon(x_ +,x _-)$的示例对$(x_ +,x _-)$。
  2. 使用$ \ Delta x = x_ +-x _- $作为输入,$ y = 1 $作为目标,计算标准重要性更新$ s(h)$。
    • 如果您总是将目标设为1似乎很奇怪,请考虑在以后的时间出现相同的输入转置。
    • 注意$ \ Delta x $不包含常量功能。
  3. 使用$ s(h)\ Delta x $更新权重。
重要提示:此过程与依次训练带有标签1的$ x _ + $和随后带有标签0的$ x _- $的训练不同;具有平方损失的过程对应于在平衡的训练集上学习回归变量,尽管该序列一致,但与成对分类的减少相比,其后悔约束更糟。您无法使用 Vowpal兔子 作为一个黑盒子(由于具有常数功能):您必须将其打开并修改代码。 (也许对Vowpal的一个很好的补丁就是让它接受一个命令行标志来抑制常量功能)。

布法尼等等 讨论减少 DCG 和NDCG的损失函数具有与上面相同的形式(该论文中的公式6),因此对它们的损失进行重要性感知的SGD将导致类似的更新。

评分筛选树

得分 过滤树 是从成本敏感的多类别分类减少到重要性加权二元分类。以前我已经讨论过了 从概念上讲 并且还提供了 实作 通过perl脚本包装器在Vowpal Wabbit之上。 (我随后编写了一个C ++实现,速度大约快10倍)。

用于训练的(某种)松弛(但仍不是凸的)目标函数是\ [
\ begin {aligned}
长(x; w)&= \sum_{\nu \in T} \left| c_{\lambda (\nu;x,w)}-c _ {\ rho(\ nu; x,w)} \ right | l \ left(w ^ \ top(x _ {\ lambda(\ nu; x,w)}-x _ {\ rho(\ nu; x,w)}),1_ {c _ {\ lambda(\ nu; x, w)}>c _ {\ rho(\ nu; x,w)}} \ right)。
\ end {aligned}
\]这里$ \ lambda(\ nu; x,w)$和$ \ rho(\ nu; x,w)$是节点$ \ nu $的左右输入的标识。这看起来真的很讨厌:通常,每个输入向量在树中出现多次,并且输入到节点的传播也以非凸的方式取决于$ w $(即函数$ \ lambda $和$ \ rho $不凸)。

仅考虑树的单个级别$ k $,\ [
\ begin {aligned}
L_k(x; w)&= \sum_{\nu \in T_k} \left| c_{\lambda (\nu;x,w)}-c _ {\ rho(\ nu; x,w)} \ right | l \ left(w ^ \ top(x _ {\ lambda(\ nu; x,w)}-x _ {\ rho(\ nu; x,w)}),1_ {c _ {\ lambda(\ nu; x, w)}>c _ {\ rho(\ nu; x,w)}} \ right),
\ end {aligned}
\]在这种情况下可以取得一些进展,因为$ x $是正交的,每个$ x $最多出现一次。忽略$ \ lambda $和$ \ rho $对$ w $的依赖性,寻找形式为[[
\ begin {aligned}
宽(高)&= w - \sum_{\nu \in T_k} s_\nu (h) (x_{\lambda (\nu;x,w)}-x _ {\ rho(\ nu; x,w)}),
\ end {aligned}
\]产生\ [
s ^ \ prime_ \ nu(h)=-\ eta \ left | c _ {\ lambda(\ nu; x,w)}-c _ {\ rho(\ nu; x,w)} \ right | \ frac {\ partial l} {\ partial p} \ biggr | _ {p =(w-s_ \ nu(h)(x _ {\ lambda(\ nu; x,w)}}-x _ {\ rho(\ nu ; x,w)}))^ \ top(x _ {\ lambda(\ nu; x,w)}-x _ {\ rho(\ nu; x,w)})}}。
\]本质上是树的$ k $级每个节点的排名更新。

受上述推理的启发,使用以下每个示例过程对过滤树进行评分,获得了非常好的结果:
  1. 确定比赛的总冠军,以估计损失。
  2. 对于树的每个级别,从下到上
    1. 确定每个父节点$ \ lambda(\ nu; x,w)$和$ \ rho(\ nu; x,w)$的输入,即谁在锦标赛中晋级。
    2. 使用上面的公式,为树的此级别上的每个节点计算$ s_ \ nu(h)$,并更新模型。
    3. 可选的速度改善:如果所有剩余成本向量条目都相同(即,所有剩余可能的重要权重均为零),则短路。
    4. 重新计算$ w ^ \ top x _ {\ lambda(\ nu; x,w)} $和$ w ^ \ top x _ {\ rho(\ nu; x,w)} $的值,分别用于比赛。
此过程的动机是需要二元模型,以绝对排除过度使用标签的可能性。我发现它也给非二元问题带来了更好的损失。足以补偿步行时树的重新计算量的降低。 (这种放慢的速度甚至比听起来还糟,因为树的每个级别在并发估计线程之间引入了同步屏障。请耐心等待。)

2011年7月8日,星期五

集成电路 2011著名人物

以下是我标记为要跟进的一些论文,不分先后顺序:
  • 最小概率流 (强积金)。通过避免计算分区函数,可以更快地训练各种概率模型。既然我迷恋速度,这引起了我的注意:我基本上忽略了很多技术,因为我认为它们太慢了。也许这是改变游戏规则的人?我必须尝试尝试确定的东西。
  • 文本的稀疏加性生成模型 (智者)。我猜想作者最初对稀疏的LDA感兴趣,但是发现多项式令牌发射规范不利于这种操纵。无论如何,我的总结是:用LDA的令牌排放模型中的对数概率替换概率,并将排放相对于背景(令牌频率)居中。有两个主要好处:1)最终的按主题的说明可以非常稀疏,因为它们仅建模与背景的差异。 2)可以通过(日志)加法而不是(概率)乘法来处理其他潜在参数。不幸的是,更新中埋有一个分区术语,它是$ O(| V |)$,其中$ V $是词汇。也许SAGE的作者应该和MPF的作者交谈:)
  • 通过保留订单损失和标准化监督来学习评分功能。本文的目的是弄清何时对目标函数进行排序会降低对具有得分函数的回归或成对分类的影响。公式6具有在Vowpal Wabbit中实施的正确结构,并且有一致的方法可以减少 DCG 和NDCG埋在这里,如果我能弄清楚的话:)
  • 自适应学习人群内核。的概括 MDS 使用基于三元组的相对相似性而不是绝对相似性。这真是太棒了,因为很难从人们那里获得绝对相似性的判断,而基于三重态的相对相似性(``对象$ a $更类似于$ b $或$ c $吗?'')是很自然的。
此外,受邀的演讲者都很棒,星期四下午受邀的交叉会议特别有趣。

2011年7月6日,星期三

快速逼近集合

我将各种快速(矢量化)近似值捆绑在一起 在Google代码上进行项目.

CISC的复仇

因此,就像我们现在所听到的那样,我的童年Commodore 64时钟速度的千倍增长已不再重复。像其他科学计算社区一样,机器学习社区正认真地拥抱多核和集群计算,以便进一步扩展,这是一件好事。

但是,这项练习告诉我的是,计算机的速度越来越快:不是以时钟速度而言,而是每个时钟滴答完成了多少工作。芯片设计人员不仅会发布新的令人敬畏的指令,而且还会与每个芯片版本一起使用,以提高其效率(例如,更少的延迟,停顿)。如果您使用的是最新版本的编译器,例如gcc 4,则某些收益会自动累积 自动向量化 但是gcc 3没有。这就是为什么我``仅''看到与之相比又增加了20%的原因之一 LDA实现的向量化 在Vowpal Wabbit中:编译器已经对明显的东西进行了矢量化处理(例如,点积,循环累加计数器),但还不足以识别我的digamma,lgamma和指数近似值也可以进行矢量化处理。如果您使用gcc 3编译Vowpal Wabbit,则可能要付出速度损失。

好吧,那又如何呢?要达到PB级,还是需要一个集群,对吗?那么,存在很多问题,在笔记本电脑上拥有几GB的样本数据对于快速实验很有用。因此,它有助于以最快的速度实现在笔记本电脑上运行的学习算法。要快速实现,请注意指令集!