Paper：《A Few Useful Things to Know About Machine Learning》翻译与解读

分手后的思念是犯贱 2022-12-31 02:29 164阅读 0赞

Paper：《A Few Useful  Things to  Know About  Machine  Learning》翻译与解读

**目录**

《A Few Useful  Things to  Know About  Machine  Learning》翻译与解读了解机器学习的一些有用的东西

key insights 重要见解

Learning = Representation +  Evaluation + Optimization 学习=表示+评估+优化

It’s Generalization that Counts  重要的是概括

Data Alone Is Not Enough  仅数据不足

Intuition Fails in High Dimensions  高维直觉失败

Theoretical Guarantees  Are Not What They Seem 理论上的保证不是他们所看到的

Feature Engineering Is The Key  特征工程是关键

More Data Beats  a Cleverer Algorithm  智慧算法带来更多数据优势

Learn Many Models, Not Just One  学习多种模型，而不仅仅是一种

Simplicity Does Not  Imply Accuracy  简易性不准确

Representable Does Not  Imply Learnable  有代表性的不容易学习

Correlation Does Not  Imply Causation  关联不表示因果关系

Conclusion  结论

--------------------

**原文地址**：[https://homes.cs.washington.edu/~pedrod/papers/cacm12.pdf][https_homes.cs.washington.edu_pedrod_papers_cacm12.pdf]  
2012年10月

# 《A Few Useful  Things to  Know About  Machine  Learning》翻译与解读   了解机器学习的一些有用的东西 #

<table> 
 <tbody> 
  <tr> 
   <td style="width:689px;">Machine learning systems automatically learn &nbsp;programs from data. This is often a very attractive &nbsp;alternative to manually constructing them, and in the &nbsp;last decade the use of machine learning has spread &nbsp;rapidly throughout computer science and beyond. &nbsp;Machine learning is used in Web search, spam filters, &nbsp;recommender systems, ad placement, credit scoring, &nbsp;fraud detection, stock trading, drug design, and many &nbsp;other applications. A recent report from the McKinsey &nbsp;Global Institute asserts that machine learning (a.k.a. &nbsp;data mining or predictive analytics) will be the driver &nbsp;of the next big wave of innovation.15 Several fine &nbsp;textbooks are available to interested practitioners and &nbsp;researchers (for example, Mitchell16 and Witten et &nbsp;al.24). However, much of the “folk knowledge” that is needed to successfully develop &nbsp;machine learning applications is not &nbsp;readily available in them. As a result, &nbsp;many machine learning projects take &nbsp;much longer than necessary or wind &nbsp;up producing less-than-ideal results. &nbsp;Yet much of this folk knowledge is &nbsp;fairly easy to communicate. This is &nbsp;the purpose of this article.</td> 
   <td style="width:510px;">机器学习系统会自动从数据中学习程序。这通常是<span style="color:#f33b45;">手动构建它们的一种非常有吸引力的替代方法</span>，并且在过去的十年中，机器学习的使用已迅速遍及整个计算机科学及其他领域。机器学习用于Web搜索，垃圾邮件过滤器，推荐系统，广告排名，信用评分，欺诈检测，股票交易，药物设计以及许多其他应用程序中。麦肯锡全球研究院最近的一份报告断言，<span style="color:#f33b45;">机器学习（又名数据挖掘或预测分析）将成为下一波创新浪潮的驱动力</span>.15有兴趣的从业者和研究人员可以使用几本精美的教科书（例如Mitchell16和Witten等24）。但是，成功开发机器学习应用程序所需的许多``民间知识''尚不容易获得。结果，<span style="color:#f33b45;">许多机器学习项目花费的时间比必要的时间长得多，或者结束时产生的结果不理想。然而，许多民间知识非常容易交流。这就是本文的目的</span>。</td> 
  </tr> 
 </tbody> 
</table>

##  key insights 重要见解 ##

<table> 
 <tbody> 
  <tr> 
   <td>Machine learning algorithms can figure &nbsp;out how to perform important tasks &nbsp;by generalizing from examples. This is &nbsp;often feasible and cost-effective where &nbsp;manual programming is not. As more &nbsp;data becomes available, more ambitious &nbsp;problems can be tackled. &nbsp;<br> Machine learning is widely used in &nbsp;computer science and other fields. &nbsp;However, developing successful &nbsp;machine learning applications requires a &nbsp;substantial amount of “black art” that is &nbsp;difficult to find in textbooks. &nbsp;<br> This article summarizes 12 key lessons &nbsp;that machine learning researchers and &nbsp;practitioners have learned. These include &nbsp;pitfalls to avoid, important issues to focus &nbsp;on, and answers to common questions.</td> 
   <td style="width:479px;">机器学习算法可以通过示例总结来弄清楚如何执行重要任务。在没有手动编程的情况下，这通常是可行且具有成本效益的。随着越来越多的数据可用，可以解决更多雄心勃勃的问题。机器学习广泛应用于计算机科学和其他领域。但是，开发成功的机器学习应用程序需要大量的``妖术''，这在教科书中很难找到。本文总结了机器学习研究人员和从业人员所学的12项关键课程。这些包括要避免的陷阱，需要重点关注的重要问题以及常见问题的答案。</td> 
  </tr> 
  <tr> 
   <td>Many different types of machine &nbsp;learning exist, but for illustration &nbsp;purposes I will focus on the most &nbsp;mature and widely used one: classification. &nbsp;Nevertheless, the issues I &nbsp;will discuss apply across all of machine &nbsp;learning. A classifier is a system &nbsp;that inputs (typically) a vector &nbsp;of discrete and/or continuous feature &nbsp;values and outputs a single discrete &nbsp;value, the class. For example, &nbsp;a spam filter classifies email messages &nbsp;into “spam” or “not spam,” &nbsp;and its input may be a Boolean vector &nbsp;x = (x1,…,xj,…,xd), where xj = 1 if &nbsp;the j &nbsp;th word in the dictionary appears &nbsp;in the email and xj = 0 otherwise. A &nbsp;learner inputs a training set of examples &nbsp;(xi, yi), where xi = (xi,1 , . . . , &nbsp;xi,d) is an observed input and yi is the &nbsp;corresponding output, and outputs &nbsp;a classifier. The test of the learner is &nbsp;whether this classifier produces the &nbsp;correct output yt for future examples &nbsp;xt (for example, whether the spam &nbsp;filter correctly classifies previously &nbsp;unseen email messages as spam or &nbsp;not spam).</td> 
   <td style="width:479px;">存在许多不同类型的机器学习，但出于说明目的，我将重点介绍最成熟且使用最广泛的一种：分类。尽管如此，我将讨论的问题适用于所有机器学习。分类器是一个系统，通常输入离散和/或连续特征值的向量并输出单个离散值的类。例如，垃圾邮件过滤器将电子邮件分类为“垃圾邮件”或“非垃圾邮件”，其输入可能是布尔向量x =（x1，...，xj，...，xd），如果第j个单词的话xj = 1字典中出现在电子邮件中，否则xj = 0。学习者输入一组训练示例（xi，yi），其中xi =（xi，1，。。。xi，d）是观察到的输入，yi是相应的输出，并输出分类器。学习者的考验是此分类器是否为将来的示例xt生成正确的输出yt（例如，垃圾邮件过滤器是否将先前未见过的电子邮件正确分类为垃圾邮件或非垃圾邮件）。</td> 
  </tr> 
 </tbody> 
</table>

## Learning = Representation +  Evaluation + Optimization 学习=表示+评估+优化 ##

<table> 
 <tbody> 
  <tr> 
   <td style="width:655px;"> <p>&nbsp;Suppose you have an application that &nbsp;you think machine learning might be &nbsp;good for. The first problem facing you &nbsp;is the bewildering variety of learning algorithms &nbsp;available. Which one to use? &nbsp;There are literally thousands available, &nbsp;and hundreds more are published each &nbsp;year. The key to not getting lost in this &nbsp;huge space is to realize that it consists &nbsp;of combinations of just three components. &nbsp;The components are: &nbsp;</p> <p><strong>Representation</strong>. A classifier must &nbsp;be represented in some formal language &nbsp;that the computer can handle. &nbsp;Conversely, choosing a representation &nbsp;for a learner is tantamount to &nbsp;choosing the set of classifiers that it &nbsp;can possibly learn. This set is called &nbsp;the hypothesis space of the learner. &nbsp;If a classifier is not in the hypothesis &nbsp;space, it cannot be learned. A related &nbsp;question, that I address later, is how &nbsp;to represent the input, in other words, &nbsp;what features to use.<br><strong>Evaluation</strong>. An evaluation function &nbsp;(also called objective function or scoring function) is needed to distinguish &nbsp;good classifiers from bad &nbsp;ones. The evaluation function used &nbsp;internally by the algorithm may differ &nbsp;from the external one that we want &nbsp;the classifier to optimize, for ease of &nbsp;optimization and due to the issues I &nbsp;will discuss.&nbsp;</p> <p><strong>Optimization</strong>. Finally, we need &nbsp;a method to search among the classifiers &nbsp;in the language for the highest-scoring &nbsp;one. The choice of optimization &nbsp;technique is key to the &nbsp;efficiency of the learner, and also &nbsp;helps determine the classifier produced &nbsp;if the evaluation function has &nbsp;more than one optimum. It is common &nbsp;for new learners to start out using &nbsp;off-the-shelf optimizers, which are later &nbsp;replaced by custom-designed ones.</p> </td> 
   <td style="width:543px;"> <p>假设您有一个您认为机器学习可能很适合的应用程序。您面临的第一个问题是可用的学习算法种类繁多。使用哪一个？实际上有数千种可用，每年都会发布数百种。在这个巨大空间中不迷路的关键是要认识到它仅由三个组成部分组成。这些组件是：</p> <p>表示。分类器必须以计算机可以处理的某种正式语言表示。相反，为学习者选择表示形式等同于选择其可能学习的分类器集合。该集合称为学习者的假设空间。如果分类器不在假设空间中，则无法学习。我稍后将解决的一个相关问题是如何表示输入，换句话说，要使用的功能。<br> 评估。需要评估函数（也称为目标函数或评分函数）以区分良好的分类器和不良的分类器。该算法在内部使用的评估函数可能与我们希望分类器优化的外部评估函数有所不同，这是为了简化优化以及由于我将要讨论的问题。</p> <p>优化。最后，我们需要一种在语言中的分类器中搜索得分最高的方法。优化技术的选择是学习者效率的关键，并且如果评估函数具有多个最优值，则有助于确定所生成的分类器。对于新学习者来说，通常首先使用现成的优化器，然后由定制设计的优化器代替。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:655px;">The accompanying table shows &nbsp;common examples of each of these &nbsp;three components. For example, knearest &nbsp;neighbor classifies a test example &nbsp;by finding the k most similar &nbsp;training examples and predicting the &nbsp;majority class among them. HyperI &nbsp;plane-based methods form a linear combination of the features per class &nbsp;and predict the class with the highest-valued &nbsp;combination. Decision &nbsp;trees test one feature at each internal &nbsp;node, with one branch for each feature &nbsp;value, and have class predictions &nbsp;at the leaves. Algorithm 1 (above) &nbsp;shows a bare-bones decision tree &nbsp;learner for Boolean domains, using &nbsp;information gain and greedy search.20 &nbsp;InfoGain(xj, y) is the mutual information &nbsp;between feature xj and the class y. &nbsp;MakeNode(x,c0,c1) returns a node that &nbsp;tests feature x and has c0 as the child &nbsp;for x = 0 and c1 as the child for x = 1. &nbsp;<br> Of course, not all combinations of &nbsp;one component from each column of &nbsp;the table make equal sense. For example, &nbsp;discrete representations naturally &nbsp;go with combinatorial optimization, &nbsp;and continuous ones with continuous &nbsp;optimization. Nevertheless, many &nbsp;learners have both discrete and continuous &nbsp;components, and in fact the&nbsp;day may not be far when every single &nbsp;possible combination has appeared in &nbsp;some learner! &nbsp;<br> Most textbooks are organized by &nbsp;representation, and it is easy to overlook &nbsp;the fact that the other components &nbsp;are equally important. There is &nbsp;no simple recipe for choosing each &nbsp;component, but I will touch on some &nbsp;of the key issues here. As we will see, &nbsp;some choices in a machine learning &nbsp;project may be even more important &nbsp;than the choice of learner.</td> 
   <td style="width:543px;">下表显示了这三个组件中每个组件的通用示例。例如，knearest邻居通过找到k个最相似的训练示例并预测其中的大多数类别来对测试示例进行分类。基于HyperI的基于平面的方法形成每个类别的特征的线性组合，并以最高价值的组合来预测类别。决策树在每个内部节点上测试一个功能，每个功能值具有一个分支，并在树叶上进行类预测。上面的算法1显示了使用信息增益和贪婪搜索的布尔域的基本决策树学习器.20 InfoGain（xj，y）是特征xj和类别y之间的互信息。 MakeNode（x，c0，c1）返回一个测试特征x的节点，对于x = 0，将c0作为子节点，对于x = 1，将c1作为其子节点。<br> 当然，并非表中每一列的一个组件的所有组合都具有同等意义。例如，离散表示自然会进行组合优化，而连续表示则会进行连续优化。尽管如此，许多学习者具有离散和连续的组成部分，实际上，当每个单独的可能组合出现在某个学习者中的日子可能并不遥远！<br> 大多数教科书都是按代表形式组织的，很容易忽略其他组成部分同等重要的事实。没有选择每个组件的简单方法，但是我将在这里介绍一些关键问题。正如我们将看到的那样，机器学习项目中的某些选择可能比学习者的选择更为重要。</td> 
  </tr> 
 </tbody> 
</table>

## It’s Generalization that Counts  重要的是概括 ##

<table> 
 <tbody> 
  <tr> 
   <td style="width:589px;">The fundamental goal of machine &nbsp;learning is to generalize beyond the &nbsp;examples in the training set. This is &nbsp;because, no matter how much data &nbsp;we have, it is very unlikely that we will &nbsp;see those exact examples again at test &nbsp;time. (Notice that, if there are 100,000 &nbsp;words in the dictionary, the spam filter &nbsp;described above has 2100,000 possible different inputs.) Doing well on &nbsp;the training set is easy (just memorize &nbsp;the examples). The most common &nbsp;mistake among machine learning beginners &nbsp;is to test on the training data &nbsp;and have the illusion of success. If the &nbsp;chosen classifier is then tested on new &nbsp;data, it is often no better than random &nbsp;guessing. So, if you hire someone &nbsp;to build a classifier, be sure to keep &nbsp;some of the data to yourself and test &nbsp;the classifier they give you on it. Conversely, &nbsp;if you have been hired to build &nbsp;a classifier, set some of the data aside &nbsp;from the beginning, and only use it to &nbsp;test your chosen classifier at the very &nbsp;end, followed by learning your final &nbsp;classifier on the whole data.</td> 
   <td style="width:610px;">机器学习的基本目标是超越训练集中的示例进行概括。这是因为，无论我们拥有多少数据，我们都不太可能在测试时再次看到这些确切的例子。 （请注意，如果字典中有100,000个单词，则上述垃圾邮件过滤器可能有2100,000个不同的输入。）在训练集上做得很好很容易（请记住示例）。机器学习初学者中最常见的错误是对训练数据进行测试并产生成功的幻觉。如果选择的分类器随后在新数据上进行测试，则通常不会比随机猜测更好。因此，如果您雇用某人来构建分类器，请确保将一些数据保留给自己并测试他们在其中提供给您的分类器。相反，如果您被雇用来构建分类器，请从一开始就保留一些数据，并仅在最后使用它来测试所选的分类器，然后再对整个数据学习最终的分类器。</td> 
  </tr> 
  <tr> 
   <td style="width:589px;"> <p>Contamination of your classifier by &nbsp;test data can occur in insidious ways, &nbsp;for example, if you use test data to &nbsp;tune parameters and do a lot of tuning. &nbsp;(Machine learning algorithms &nbsp;have lots of knobs, and success often &nbsp;comes from twiddling them a lot, &nbsp;so this is a real concern.) Of course, &nbsp;holding out data reduces the amount &nbsp;available for training. This can be mitigated &nbsp;by doing cross-validation: randomly &nbsp;dividing your training data into &nbsp;(say) 10 subsets, holding out each one &nbsp;while training on the rest, testing each &nbsp;learned classifier on the examples it &nbsp;did not see, and averaging the results &nbsp;to see how well the particular parameter &nbsp;setting does. &nbsp;</p> <p>In the early days of machine learning, &nbsp;the need to keep training and test &nbsp;data separate was not widely appreciated. &nbsp;This was partly because, if the &nbsp;learner has a very limited representation &nbsp;(for example, hyperplanes), the &nbsp;difference between training and test &nbsp;error may not be large. But with very &nbsp;flexible classifiers (for example, decision &nbsp;trees), or even with linear classifiers &nbsp;with a lot of features, strict separation &nbsp;is mandatory.</p> </td> 
   <td style="width:610px;"> <p>测试数据对分类器的污染可能以阴险的方式发生，例如，如果您使用测试数据来调整参数并进行大量调整。 （机器学习算法有很多旋钮，而成功往往来自于大量的纠缠，因此这是一个真正的问题。）当然，保留数据会减少可用于训练的数量。可以通过交叉验证来缓解这种情况：将您的训练数据随机分为10个子集（例如10个子集），在其余部分进行训练时坚持每个子集，在未看到的示例上测试每个学习的分类器，然后平均结果以查看特定参数设置的效果如何。</p> <p>在机器学习的早期，对训练和测试数据保持分开的需求并未得到广泛认可。这部分是因为，如果学习者的表示形式非常有限（例如，超平面），则训练与测试错误之间的差异可能不会很大。但是对于非常灵活的分类器（例如决策树），甚至对于具有很多功能的线性分类器来说，严格的分隔是强制性的。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:589px;">Notice that generalization being &nbsp;the goal has an interesting consequence &nbsp;for machine learning. Unlike &nbsp;in most other optimization problems, &nbsp;we do not have access to the function &nbsp;we want to optimize! We have to use &nbsp;training error as a surrogate for test &nbsp;error, and this is fraught with danger. &nbsp;(How to deal with it is addressed &nbsp;later.) On the positive side, since the &nbsp;objective function is only a proxy for &nbsp;the true goal, we may not need to fully optimize it; in fact, a local optimum &nbsp;returned by simple greedy search may &nbsp;be better than the global optimum.</td> 
   <td style="width:610px;">请注意，泛化是机器学习的目标产生了有趣的结果。 与大多数其他优化问题不同，我们无权访问我们要优化的功能！ 我们必须使用训练错误作为测试错误的替代品，这充满了危险。 从积极的方面来看，由于目标函数只是真实目标的代理，因此我们可能不需要完全优化它; 实际上，通过简单的贪婪搜索返回的局部最优值可能要好于全局最优值。</td> 
  </tr> 
 </tbody> 
</table>

## Data Alone Is Not Enough  仅数据不足 ##

<table> 
 <tbody> 
  <tr> 
   <td style="width:691px;"> <p>Generalization being the goal has another &nbsp;major consequence: Data alone &nbsp;is not enough, no matter how much &nbsp;of it you have. Consider learning a &nbsp;Boolean function of (say) 100 variables &nbsp;from a million examples. There &nbsp;are 2100 − 106 &nbsp; examples whose classes &nbsp;you do not know. How do you figure &nbsp;out what those classes are? In the absence &nbsp;of further information, there is &nbsp;just no way to do this that beats flipping &nbsp;a coin. This observation was first &nbsp;made (in somewhat different form) by &nbsp;the philosopher David Hume over 200 &nbsp;years ago, but even today many mistakes &nbsp;in machine learning stem from &nbsp;failing to appreciate it. Every learner &nbsp;must embody some knowledge or assumptions &nbsp;beyond the data it is given &nbsp;in order to generalize beyond it. This &nbsp;notion was formalized by Wolpert in &nbsp;his famous “no free lunch” theorems, &nbsp;according to which no learner can &nbsp;beat random guessing over all possible &nbsp;functions to be learned.25.</p> <p>This seems like rather depressing &nbsp;news. How then can we ever hope to &nbsp;learn anything? Luckily, the functions &nbsp;we want to learn in the real world are &nbsp;not drawn uniformly from the set of all &nbsp;mathematically possible functions! In &nbsp;fact, very general assumptions—like &nbsp;smoothness, similar examples having &nbsp;similar classes, limited dependences, &nbsp;or limited complexity—are &nbsp;often enough to do very well, and this &nbsp;is a large part of why machine learning &nbsp;has been so successful. Like deduction, &nbsp;induction (what learners do) &nbsp;is a knowledge lever: it turns a small &nbsp;amount of input knowledge into a &nbsp;large amount of output knowledge. &nbsp;Induction is a vastly more powerful &nbsp;lever than deduction, requiring much &nbsp;less input knowledge to produce useful &nbsp;results, but it still needs more than &nbsp;zero input knowledge to work. And, as &nbsp;with any lever, the more we put in, the &nbsp;more we can get out.</p> </td> 
   <td style="width:507px;"> <p>泛化是目标的另一个主要后果：数据量不够，无论您拥有多少数据。考虑从一百万个示例中学习一个（布尔）100个变量的布尔函数。有2100 − 106个您不知道其类的示例。您如何弄清楚这些类是什么？在没有更多信息的情况下，根本没有办法像抛硬币一样做到这一点。这种观察是200多年前哲学家戴维·休（（David Hume）首次提出的（形式有所不同），但直到今天，机器学习中的许多错误仍然源于对它的欣赏。每个学习者都必须在给出的数据之外体现一些知识或假设，以便对其进行概括。 Wolpert在他著名的“免费午餐”定理中正式化了这个概念，根据该定理，任何学习者都无法对将要学习的所有可能功能进行随机猜测。25。</p> <p>这似乎令人沮丧。那我们怎么能希望学到什么呢？幸运的是，我们要在现实世界中学习的功能并不是从所有数学上可能的功能集中统一得出的！实际上，非常平滑的假设（例如平滑度，具有相似类，有限依赖项或有限复杂性的类似示例）通常足以很好地完成工作，这是机器学习如此成功的很大一部分。就像演绎一样，归纳（学习者的工作）是一种知识杠杆：它将少量的输入知识变成大量的输出知识。归纳比推论具有更强大的杠杆作用，需要更少的输入知识才能产生有用的结果，但它仍然需要超过零的输入知识才能起作用。而且，就像使用任何杠杆一样，我们投入的越多，我们越能脱身。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:691px;">A corollary of this is that one of the &nbsp;key criteria for choosing a representation &nbsp;is which kinds of knowledge are &nbsp;easily expressed in it. For example, if &nbsp;we have a lot of knowledge about what &nbsp;makes examples similar in our domain, instance-based methods may &nbsp;be a good choice. If we have knowledge &nbsp;about probabilistic dependencies, &nbsp;graphical models are a good fit. &nbsp;And if we have knowledge about what &nbsp;kinds of preconditions are required by &nbsp;each class, “IF . . . THEN . . .” rules may &nbsp;be the best option. The most useful &nbsp;learners in this regard are those that &nbsp;do not just have assumptions hardwired &nbsp;into them, but allow us to state &nbsp;them explicitly, vary them widely, and &nbsp;incorporate them automatically into &nbsp;the learning (for example, using firstorder &nbsp;logic21 or grammars6 &nbsp;).<br> In retrospect, the need for knowledge &nbsp;in learning should not be surprising. &nbsp;Machine learning is not &nbsp;magic; it cannot get something from &nbsp;nothing. What it does is get more &nbsp;from less. Programming, like all engineering, &nbsp;is a lot of work: we have to &nbsp;build everything from scratch. Learning &nbsp;is more like farming, which lets &nbsp;nature do most of the work. Farmers &nbsp;combine seeds with nutrients to grow &nbsp;crops. Learners combine knowledge &nbsp;with data to grow programs.</td> 
   <td style="width:507px;">一个必然的推论是选择一种表示形式的关键标准之一就是在其中容易表达哪种知识。例如，如果我们对使示例在我们的领域中变得相似有很多了解，那么基于实例的方法可能是一个不错的选择。如果我们了解有关概率依赖性的知识，则图形模型非常适合。如果我们了解每个类都需要哪些先决条件，则“ IF。 。 。然后 。 。 。”规则可能是最佳选择。在这方面最有用的学习者是那些不仅将假设硬性地扎入其中的假设，而且使我们能够明确地陈述它们，进行广泛的变化并将它们自动地纳入学习中（例如使用一阶logic21或grammars6）。<br> 回想起来，学习中知识的需求不足为奇。机器学习不是魔术;它一无所获。它所做的就是从更少获得更多。像所有工程学一样，编程工作量很大：我们必须从头开始构建所有内容。学习更像是耕种，让自然完成大部分工作。农民将种子与养分结合起来种植农作物。学习者将知识与数据相结合以开发程序。</td> 
  </tr> 
  <tr> 
   <td style="width:691px;">Overfitting Has Many Faces &nbsp;What if the knowledge and data we &nbsp;have are not sufficient to completely &nbsp;determine the correct classifier? Then &nbsp;we run the risk of just hallucinating &nbsp;a classifier (or parts of it) that is not &nbsp;grounded in reality, and is simply encoding &nbsp;random quirks in the data. &nbsp;This problem is called overfitting, and &nbsp;is the bugbear of machine learning. &nbsp;When your learner outputs a classifier &nbsp;that is 100% accurate on the training &nbsp;data but only 50% accurate on test &nbsp;data, when in fact it could have output one that is 75% accurate on both, it &nbsp;has overfit. &nbsp;<br> Everyone in machine learning &nbsp;knows about overfitting, but it comes &nbsp;in many forms that are not immediately &nbsp;obvious. One way to understand &nbsp;overfitting is by decomposing generalization &nbsp;error into bias and variance. &nbsp;9 &nbsp;Bias is a learner’s tendency to consistently &nbsp;learn the same wrong thing. &nbsp;Variance is the tendency to learn random &nbsp;things irrespective of the real signal. &nbsp;Figure 1 illustrates this by an analogy &nbsp;with throwing darts at a board. A &nbsp;linear learner has high bias, because &nbsp;when the frontier between two classes &nbsp;is not a hyperplane the learner is unable &nbsp;to induce it. Decision trees do not &nbsp;have this problem because they can &nbsp;represent any Boolean function, but &nbsp;on the other hand they can suffer from &nbsp;high variance: decision trees learned &nbsp;on different training sets generated by &nbsp;the same phenomenon are often very &nbsp;different, when in fact they should be the same. Similar reasoning applies &nbsp;to the choice of optimization method: &nbsp;beam search has lower bias than &nbsp;greedy search, but higher variance, because &nbsp;it tries more hypotheses. Thus, &nbsp;contrary to intuition, a more powerful &nbsp;learner is not necessarily better than a &nbsp;less powerful one. &nbsp;<br> Figure 2 illustrates this.a &nbsp; Even &nbsp;though the true classifier is a set of &nbsp;rules, with up to 1,000 examples naive &nbsp;Bayes is more accurate than a &nbsp;rule learner. This happens despite &nbsp;naive Bayes’s false assumption that &nbsp;the frontier is linear! Situations like &nbsp;this are common in machine learning: &nbsp;strong false assumptions can be &nbsp;better than weak true ones, because &nbsp;a learner with the latter needs more &nbsp;data to avoid overfitting.</td> 
   <td style="width:507px;">过度拟合有很多面孔如果我们所掌握的知识和数据不足以完全确定正确的分类器怎么办？然后，我们冒着使幻化一个分类器（或部分分类器）的风险，而这个分类器（或部分分类器）实际上并没有扎根，只是在数据中编码了随机的怪癖。这个问题称为过拟合，是机器学习的负担。当您的学习者输出的分类数据在训练数据上准确度为100％但在测试数据上仅准确度为50％时，实际上它可能在两个数据上都输出准确度为75％的分类器，这是过拟合的。<br> 机器学习中的每个人都知道过拟合，但是它以许多形式出现，但并不是立即显而易见的。一种理解过度拟合的方法是将泛化误差分解为偏差和方差。 9偏见是学习者始终如一地学习同一错误事物的倾向。方差是学习随机事物的趋势，与真实信号无关。图1通过在板上扔飞镖的类比说明了这一点。线性学习者具有较高的偏见，因为当两类之间的边界不是超平面时，学习者无法诱导它。决策树没有这个问题，因为它们可以表示任何布尔函数，但是另一方面，它们可能遭受高方差：在相同现象产生的不同训练集上学习的决策树通常非常不同，而实际上它们应该是相同。类似的推理适用于优化方法的选择：光束搜索比贪婪搜索具有更低的偏差，但方差更高，因为它会尝试更多的假设。因此，与直觉相反，更强大的学习者不一定比不那么强大的学习者更好。<br> 图2对此进行了说明。a尽管真正的分类器是一组规则，但多达1000个示例的朴素贝叶斯比一个规则学习者更准确。尽管天真贝叶斯错误地认为边界是线性的，但仍会发生这种情况！像这样的情况在机器学习中很常见：强错误的假设可能比弱真实的假设更好，因为拥有后者的学习者需要更多数据来避免过拟合。</td> 
  </tr> 
  <tr> 
   <td style="width:691px;">Cross-validation can help to combat &nbsp;overfitting, for example by using it &nbsp;to choose the best size of decision tree &nbsp;to learn. But it is no panacea, since if &nbsp;we use it to make too many parameter &nbsp;choices it can itself start to overfit.17 &nbsp;<br> Besides cross-validation, there &nbsp;are many methods to combat overfitting. &nbsp;The most popular one is adding &nbsp;a regularization term to the evaluation &nbsp;function. This can, for example, penalize &nbsp;classifiers with more structure, &nbsp;thereby favoring smaller ones with &nbsp;less room to overfit. Another option &nbsp;is to perform a statistical significance &nbsp;test like chi-square before adding new &nbsp;structure, to decide whether the distribution &nbsp;of the class really is different &nbsp;with and without this structure. &nbsp;These techniques are particularly useful &nbsp;when data is very scarce. Nevertheless, &nbsp;you should be skeptical of claims &nbsp;that a particular technique “solves” &nbsp;the overfitting problem. It is easy to &nbsp;avoid overfitting (variance) by falling &nbsp;into the opposite error of underfitting &nbsp;(bias). Simultaneously avoiding both &nbsp;requires learning a perfect classifier, &nbsp;and short of knowing it in advance &nbsp;there is no single technique that will &nbsp;always do best (no free lunch). &nbsp;<br> A common misconception about &nbsp;overfitting is that it is caused by noise,like training examples labeled with &nbsp;the wrong class. This can indeed aggravate &nbsp;overfitting, by making the &nbsp;learner draw a capricious frontier to &nbsp;keep those examples on what it thinks &nbsp;is the right side. But severe overfitting &nbsp;can occur even in the absence of noise. &nbsp;For instance, suppose we learn a Boolean &nbsp;classifier that is just the disjunction &nbsp;of the examples labeled “true” &nbsp;in the training set. (In other words, &nbsp;the classifier is a Boolean formula in &nbsp;disjunctive normal form, where each &nbsp;term is the conjunction of the feature &nbsp;values of one specific training example.) &nbsp;This classifier gets all the training &nbsp;examples right and every positive test &nbsp;example wrong, regardless of whether &nbsp;the training data is noisy or not. &nbsp;<br> The problem of multiple testing13 is &nbsp;closely related to overfitting. Standard &nbsp;statistical tests assume that only one &nbsp;hypothesis is being tested, but modern &nbsp;learners can easily test millions &nbsp;before they are done. As a result what &nbsp;looks significant may in fact not be. &nbsp;For example, a mutual fund that beats &nbsp;the market 10 years in a row looks very &nbsp;impressive, until you realize that, if &nbsp;there are 1,000 funds and each has a &nbsp;50% chance of beating the market on &nbsp;any given year, it is quite likely that &nbsp;one will succeed all 10 times just by &nbsp;luck. This problem can be combatted &nbsp;by correcting the significance tests to &nbsp;take the number of hypotheses into &nbsp;account, but this can also lead to underfitting. &nbsp;A better approach is to control &nbsp;the fraction of falsely accepted &nbsp;non-null hypotheses, known as the &nbsp;false discovery rate. &nbsp;3</td> 
   <td style="width:507px;">交叉验证可以帮助克服过度拟合，例如通过使用交叉验证来选择要学习的最佳决策树大小。但这不是万能药，因为如果我们使用它进行过多的参数选择，它本身可能会开始过度适应.17<br> 除了交叉验证外，还有许多方法可以防止过度拟合。最受欢迎的一种是在评估函数中添加正则化项。例如，这可能会惩罚具有更多结构的分类器，从而偏向于具有较小空间以适合过度的较小分类器。另一种选择是在添加新结构之前执行卡方检验等统计显着性检验，以判断使用和不使用此结构时类的分布是否确实不同。当数据非常稀缺时，这些技术特别有用。尽管如此，您应该对特定技术可以``解决''过拟合问题的说法持怀疑态度。通过陷入欠拟合（bias）的相反误差很容易避免过拟合（variance）。同时避免同时需要学习一个完美的分类器和既不事先知道它又没有一种技术会永远做到最好（没有免费的午餐）。<br> 关于过度拟合的一个常见误解是它是由噪声引起的，例如带有错误课程的训练示例。通过使学习者画出一个反复无常的疆界以使那些例子保持正确的观点，确实可以加剧过度拟合。但是即使没有噪音也会发生严重的过拟合。例如，假设我们学习了一个布尔分类器，它只是训练集中标注为``true''的示例的分离。 （换句话说，分类器是布尔正则形式的布尔公式，其中每个术语是一个特定训练示例的特征值的合取）。该分类器获得正确的所有训练示例，每个阳性检验示例都正确，无论训练数据是否嘈杂。<br> 多次测试的问题13与过度拟合密切相关。标准统计测试假设仅对一种假设进行了测试，但是现代学习者可以在完成之前轻松地测试数百万个假设。因此，看似重要的事实实际上可能并非如此。例如，一个连续十年击败市场的共同基金看起来非常令人印象深刻，直到您意识到，如果有1,000只基金，并且每种都有在任何给定年份击败市场的50％的机会，那么很可能仅靠运气，一个人就能成功十次。可以通过校正显着性检验以将假设的数量纳入考虑范围来解决此问题，但这也可能导致拟合不足。更好的方法是控制被错误接受的非零假设的比例，即错误发现率。 3</td> 
  </tr> 
 </tbody> 
</table>

## Intuition Fails in High Dimensions  高维直觉失败 ##

<table> 
 <tbody> 
  <tr> 
   <td>After overfitting, the biggest problem &nbsp;in machine learning is the curse of &nbsp;dimensionality. This expression was &nbsp;coined by Bellman in 1961 to refer &nbsp;to the fact that many algorithms that &nbsp;work fine in low dimensions become &nbsp;intractable when the input is highdimensional. &nbsp;But in machine learning &nbsp;it refers to much more. Generalizing &nbsp;correctly becomes exponentially &nbsp;harder as the dimensionality (number &nbsp;of features) of the examples grows, because &nbsp;a fixed-size training set covers a &nbsp;dwindling fraction of the input space. &nbsp;Even with a moderate dimension of &nbsp;100 and a huge training set of a trillion &nbsp;examples, the latter covers only a fraction of about 10−18 of the input space. &nbsp;This is what makes machine learning &nbsp;both necessary and hard. &nbsp;<br> More seriously, the similaritybased &nbsp;reasoning that machine learning &nbsp;algorithms depend on (explicitly &nbsp;or implicitly) breaks down in high dimensions. &nbsp;Consider a nearest neighbor &nbsp;classifier with Hamming distance &nbsp;as the similarity measure, and suppose &nbsp;the class is just x1 ∧ x2. If there &nbsp;are no other features, this is an easy &nbsp;problem. But if there are 98 irrelevant &nbsp;features x3,..., x100, the noise from &nbsp;them completely swamps the signal in &nbsp;x1 and x2, and nearest neighbor effectively &nbsp;makes random predictions. &nbsp;<br> Even more disturbing is that nearest &nbsp;neighbor still has a problem even &nbsp;if all 100 features are relevant! This &nbsp;is because in high dimensions all &nbsp;examples look alike. Suppose, for &nbsp;instance, that examples are laid out &nbsp;on a regular grid, and consider a test &nbsp;example xt. If the grid is d-dimensional, &nbsp;xt’s 2d nearest examples are &nbsp;all at the same distance from it. So as &nbsp;the dimensionality increases, more &nbsp;and more examples become nearest &nbsp;neighbors of xt, until the choice of &nbsp;nearest neighbor (and therefore of &nbsp;class) is effectively random. &nbsp;</td> 
   <td style="width:491px;">经过过度拟合后，机器学习中最大的问题就是维度的诅咒。该表达式由Bellman于1961年创造，是指在输入为高维输入时许多在低维运行良好的算法变得棘手的事实。但是在机器学习中，它涉及的更多。随着示例维数（特征数量）的增长，正确地进行概括变得越来越困难，因为固定大小的训练集覆盖了输入空间的缩小部分。即使具有100的适度范围和数以万亿计的示例的庞大训练集，后者仅覆盖了约10-18的输入空间的一小部分。这就是使机器学习既必要又困难的原因。<br> 更严重的是，机器学习算法所依赖的基于相似度的原因（明确或隐含地）在高维度上被分解。考虑具有汉明距离的最近邻居分类器作为相似性度量，并假设该类仅为x1∧x2。如果没有其他功能，这是一个简单的问题。但是，如果x3，...，x100有98个不相关的功能，则来自它们的噪声会完全淹没x1和x2中的信号，并且最近的邻居会有效地进行随机预测。<br> 更令人不安的是，即使所有100个功能都相关，最近的邻居仍然有问题！这是因为在高维度上所有示例看起来都是相似的。例如，假设示例被放置在规则的网格上，并考虑一个测试示例xt。如果网格是d维的，则xt的2d最接近的示例都与网格距离相同。因此，随着维数的增加，越来越多的示例成为xt的最接近邻居，直到最近邻居（以及类别）的选择实际上是随机的。</td> 
  </tr> 
  <tr> 
   <td>This is only one instance of a more &nbsp;general problem with high dimensions: &nbsp;our intuitions, which come &nbsp;from a three-dimensional world, often &nbsp;do not apply in high-dimensional &nbsp;ones. In high dimensions, most of the &nbsp;mass of a multivariate Gaussian distribution &nbsp;is not near the mean, but in &nbsp;an increasingly distant “shell” around &nbsp;it; and most of the volume of a highdimensional &nbsp;orange is in the skin, not &nbsp;the pulp. If a constant number of examples &nbsp;is distributed uniformly in a &nbsp;high-dimensional hypercube, beyond &nbsp;some dimensionality most examples &nbsp;are closer to a face of the hypercube &nbsp;than to their nearest neighbor. And if &nbsp;we approximate a hypersphere by inscribing &nbsp;it in a hypercube, in high dimensions &nbsp;almost all the volume of the &nbsp;hypercube is outside the hypersphere. &nbsp;This is bad news for machine learning, &nbsp;where shapes of one type are often approximated &nbsp;by shapes of another. &nbsp;<br> Building a classifier in two or three &nbsp;dimensions is easy; we can find a reasonable &nbsp;frontier between examples &nbsp;of different classes just by visual inspection. (It has even been said that if &nbsp;people could see in high dimensions &nbsp;machine learning would not be necessary.) &nbsp;But in high dimensions it is difficult &nbsp;to understand what is happening. &nbsp;This in turn makes it difficult to &nbsp;design a good classifier. Naively, one &nbsp;might think that gathering more features &nbsp;never hurts, since at worst they &nbsp;provide no new information about the &nbsp;class. But in fact their benefits may &nbsp;be outweighed by the curse of dimensionality.&nbsp;<br> &nbsp;Fortunately, there is an effect that &nbsp;partly counteracts the curse, which &nbsp;might be called the “blessing of nonuniformity.” &nbsp;In most applications &nbsp;examples are not spread uniformly &nbsp;throughout the instance space, but &nbsp;are concentrated on or near a lowerdimensional &nbsp;manifold. For example, &nbsp;k-nearest neighbor works quite well &nbsp;for handwritten digit recognition &nbsp;even though images of digits have &nbsp;one dimension per pixel, because the &nbsp;space of digit images is much smaller &nbsp;than the space of all possible images. &nbsp;Learners can implicitly take advantage &nbsp;of this lower effective dimension, &nbsp;or algorithms for explicitly reducing &nbsp;the dimensionality can be used (for &nbsp;example, Tenenbaum22).</td> 
   <td style="width:491px;">这只是一个更高维度的一般性问题的一个例子：我们的直觉来自三维世界，通常不适用于高维度的直觉。在高维中，多元高斯分布的大部分质量都不在均值附近，而是在其周围越来越远的``壳''中;高维橙的大部分体积在皮肤中，而不是果肉中。如果恒定数量的示例均匀分布在一个高维超立方体中，则除了某些维之外，大多数示例比其最近的邻居更靠近超立方体的一面。并且，如果我们通过将其记录在超立方体中来近似超球面，则在高维中，几乎所有超立方体的体积都在超球面之外。这对于机器学习来说是个坏消息，其中一种类型的形状通常被另一种形状的形状近似。<br> 在两个或三个维度中建立分类器很容易;我们可以通过目视检查在不同类别的示例之间找到合理的边界。 （甚至有人说，如果人们可以在高维度上看到机器学习是没有必要的。）但是在高维度上，很难理解正在发生的事情。反过来，这使得设计好的分类器变得困难。天真的，一个人可能认为收集更多功能永远不会有害，因为在最坏的情况下，它们不提供有关该类的新信息。但是实际上，它们的好处可能会因维数的诅咒而被抵消。<br> 幸运的是，有一种效果可以部分抵消这种诅咒，这种诅咒可能被称为“不均匀的祝福”。在大多数应用程序中，示例并非均匀分布在整个实例空间中，而是集中在低维流形上或附近。例如，即使数字图像每像素具有一维尺寸，k近邻也能很好地用于手写数字识别，因为数字图像的空间比所有可能图像的空间小得多。学习者可以隐式地利用此较低的有效维度，或者可以使用显式降低维度的算法（例如Tenenbaum22）。</td> 
  </tr> 
 </tbody> 
</table>

## Theoretical Guarantees  Are Not What They Seem 理论上的保证不是他们所看到的 ##

<table> 
 <tbody> 
  <tr> 
   <td style="width:692px;">One of the major &nbsp;developments of &nbsp;recent decades has &nbsp;been the realization &nbsp;that we can have &nbsp;guarantees on the &nbsp;results of induction, &nbsp;particularly if we &nbsp;are willing to settle &nbsp;for probabilistic &nbsp;guarantees.</td> 
   <td style="width:506px;"> <p>近几十年来的主要发展之一是认识到我们可以对归纳结果进行保证，特别是如果我们愿意为概率保证定居的话。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:692px;">Machine learning papers are full of &nbsp;theoretical guarantees. The most common &nbsp;type is a bound on the number of &nbsp;examples needed to ensure good generalization. &nbsp;What should you make of &nbsp;these guarantees? First of all, it is remarkable &nbsp;that they are even possible. &nbsp;Induction is traditionally contrasted &nbsp;with deduction: in deduction you can &nbsp;guarantee that the conclusions are &nbsp;correct; in induction all bets are off. &nbsp;Or such was the conventional wisdom &nbsp;for many centuries. One of the major &nbsp;developments of recent decades has &nbsp;been the realization that in fact we can &nbsp;have guarantees on the results of induction, &nbsp;particularly if we are willing &nbsp;to settle for probabilistic guarantees. &nbsp;<br> The basic argument is remarkably &nbsp;simple.5 &nbsp; Let’s say a classifier is bad &nbsp;if its true error rate is greater than ε. &nbsp;Then the probability that a bad classifier &nbsp;is consistent with n random, independent &nbsp;training examples is less &nbsp;than (1 − ε) &nbsp;n &nbsp;. Let b be the number of bad classifiers in the learner’s hypothesis &nbsp;space H. The probability that at &nbsp;least one of them is consistent is less &nbsp;than b(1 − ε) &nbsp;n &nbsp;, by the union bound. Assuming &nbsp;the learner always returns a &nbsp;consistent classifier, the probability &nbsp;that this classifier is bad is then less &nbsp;than |H|(1 − ε) &nbsp;n &nbsp;, where we have used &nbsp;the fact that b ≤ |H|. So if we want this &nbsp;probability to be less than δ, it suffices &nbsp;to make n &gt; ln(δ/|H|)/ ln(1 − ε) ≥ 1/ε (ln &nbsp;|H| + ln 1/δ). &nbsp;</td> 
   <td style="width:506px;"> <p>机器学习论文充满了理论上的保证。最常见的类型是确保良好泛化所需的示例数量的界限。这些保证应怎么做？首先，令人惊讶的是它们甚至是可能的。传统上将归纳法与推论进行对比：在推论中，您可以保证结论是正确的;归纳所有赌注都关闭了。或多个世纪以来的传统智慧就是如此。认识到实际上我们可以对归纳的结果提供保证，这是近几十年来的主要发展之一，特别是如果我们愿意解决概率保证的话。<br> 基本参数非常简单.5如果分类器的真实错误率大于ε，则它是错误的。然后，不良分类器与n个随机，独立的训练示例一致的概率小于（1-ε）n。令b为学习者假设空间H中的不良分类器的数量。其中至少一个是一致的概率受联合界限的约束小于b（1-ε）n。假设学习者总是返回一致的分类器，则该分类器不良的可能性小于| H |（1 −ε）n，其中我们使用了b≤| H |的事实。因此，如果我们希望此概率小于δ，则足以使n&gt; ln（δ/ | H |）/ ln（1-ε）≥1 /ε（ln | H | + ln 1 /δ）。</p> <p>&nbsp;</p> </td> 
  </tr> 
  <tr> 
   <td style="width:692px;">Unfortunately, guarantees of this &nbsp;type have to be taken with a large grain &nbsp;of salt. This is because the bounds obtained &nbsp;in this way are usually extremely &nbsp;loose. The wonderful feature of the &nbsp;bound above is that the required number &nbsp;of examples only grows logarithmically &nbsp;with |H| and 1/δ. Unfortunately, &nbsp;most interesting hypothesis spaces &nbsp;are doubly exponential in the number &nbsp;of features d, which still leaves us &nbsp;needing a number of examples exponential &nbsp;in d. For example, consider &nbsp;the space of Boolean functions of d &nbsp;Boolean variables. If there are e possible &nbsp;different examples, there are &nbsp;2e &nbsp; possible different functions, so &nbsp;since there are 2d &nbsp; possible examples, &nbsp;the total number of functions is 22d &nbsp;. &nbsp;And even for hypothesis spaces that &nbsp;are “merely” exponential, the bound &nbsp;is still very loose, because the union &nbsp;bound is very pessimistic. For example, &nbsp;if there are 100 Boolean features &nbsp;and the hypothesis space is decision &nbsp;trees with up to 10 levels, to guarantee &nbsp;δ = ε = 1% in the bound above we need &nbsp;half a million examples. But in practice &nbsp;a small fraction of this suffices for &nbsp;accurate learning. &nbsp;<br> Further, we have to be careful &nbsp;about what a bound like this means. &nbsp;For instance, it does not say that, if &nbsp;your learner returned a hypothesis &nbsp;consistent with a particular training &nbsp;set, then this hypothesis probably &nbsp;generalizes well. What it says is that, &nbsp;given a large enough training set, with &nbsp;high probability your learner will either &nbsp;return a hypothesis that generalizes &nbsp;well or be unable to find a consistent &nbsp;hypothesis. The bound also says &nbsp;nothing about how to select a good &nbsp;hypothesis space. It only tells us that, &nbsp;if the hypothesis space contains the &nbsp;true classifier, then the probability &nbsp;that the learner outputs a bad classifier &nbsp;decreases with training set size.If we shrink the hypothesis space, the &nbsp;bound improves, but the chances that &nbsp;it contains the true classifier shrink &nbsp;also. (There are bounds for the case &nbsp;where the true classifier is not in the &nbsp;hypothesis space, but similar considerations &nbsp;apply to them.)<br> Another common type of theoretical &nbsp;guarantee is asymptotic: given infinite &nbsp;data, the learner is guaranteed &nbsp;to output the correct classifier. This &nbsp;is reassuring, but it would be rash to &nbsp;choose one learner over another because &nbsp;of its asymptotic guarantees. In &nbsp;practice, we are seldom in the asymptotic &nbsp;regime (also known as “asymptopia”). &nbsp;And, because of the bias-variance &nbsp;trade-off I discussed earlier, if &nbsp;learner A is better than learner B given &nbsp;infinite data, B is often better than A &nbsp;given finite data. &nbsp;<br> The main role of theoretical guarantees &nbsp;in machine learning is not as &nbsp;a criterion for practical decisions, &nbsp;but as a source of understanding and &nbsp;driving force for algorithm design. In &nbsp;this capacity, they are quite useful; indeed, &nbsp;the close interplay of theory and &nbsp;practice is one of the main reasons &nbsp;machine learning has made so much &nbsp;progress over the years. But caveat &nbsp;emptor: learning is a complex phenomenon, &nbsp;and just because a learner &nbsp;has a theoretical justification and &nbsp;works in practice does not mean the &nbsp;former is the reason for the latter.</td> 
   <td style="width:506px;">不幸的是，这种类型的保证必须与大颗粒的盐一起使用。这是因为以这种方式获得的边界通常非常松散。上面绑定的一个奇妙功能是，所需的示例数仅与| H |成对数增长。和1 /δ。不幸的是，最有趣的假设空间在特征d的数量上是双倍的，这仍然使我们在d中需要大量的指数实例。例如，考虑d布尔变量的布尔函数的空间。如果有可能的不同示例，则可能有2e种不同的功能，因此，因为有2d种可能的示例，所以功能总数为22d。即使对于“仅”指数空间的假设空间，界限仍然非常宽松，因为联合界限非常悲观。例如，如果有100个布尔特征，并且假设空间是具有最多10个级别的决策树，为保证δ=ε= 1％在上面的范围内，我们需要半百万个示例。但是实际上，一小部分就足以进行准确的学习。<br> 此外，我们必须注意这种限制的含义。例如，它并不表示，如果您的学习者返回了与特定训练集一致的假设，那么该假设可能会很好地概括。它的意思是，给定足够大的训练集，您的学习者很有可能会返回一个可以很好地推广的假设，或者无法找到一致的假设。边界也没有说明如何选择一个好的假设空间。它只告诉我们，如果假设空间包含真实分类器，则学习者输出不良分类器的概率会随着训练集大小的减小而减少。如果我们缩小假设空间，边界会有所改善，但是包含真实分类器的机会会有所增加。分类器收缩也。 （对于真正的分类器不在假设空间中，但适用于它们的类似考虑因素有一定的局限性。）<br> 理论保证的另一种常见类型是渐进的：给定无限数据，可以保证学习者输出正确的分类器。这令人放心，但是由于其渐近保证，选择一个学习者而不是另一个学习者会很轻率。在实践中，我们很少采用渐近体制（也称为“渐近”）。并且，由于我之前讨论过偏差偏差的折衷，如果给定无限数据，学习者A优于学习者B，那么在有限数据下，学习者B通常优于学习者B.<br> 理论保证在机器学习中的主要作用不是作为实际决策的标准，而是作为算法设计的理解和推动力的来源。以这种身份，它们非常有用;确实，理论和实践之间的紧密相互作用是机器学习多年来取得如此巨大进步的主要原因之一。但是需要警告的是：学习者是一个复杂的现象，仅因为学习者具有理论上的依据并且在实践中起作用并不意味着前者是后者的原因。</td> 
  </tr> 
 </tbody> 
</table>

## Feature Engineering Is The Key  特征工程是关键 ##

<table> 
 <tbody> 
  <tr> 
   <td style="width:665px;">A dumb algorithm &nbsp;with lots and lots &nbsp;of data beats &nbsp;a clever one &nbsp;with modest &nbsp;amounts of it.</td> 
   <td style="width:533px;">具有大量数据的愚蠢算法击败了数量适中的聪明算法。</td> 
  </tr> 
  <tr> 
   <td style="width:665px;"> <p>At the end of the day, some machine &nbsp;learning projects succeed and some &nbsp;fail. What makes the difference? Easily &nbsp;the most important factor is the &nbsp;features used. Learning is easy if you &nbsp;have many independent features that &nbsp;each correlate well with the class. On &nbsp;the other hand, if the class is a very &nbsp;complex function of the features, you &nbsp;may not be able to learn it. Often, the &nbsp;raw data is not in a form that is amenable &nbsp;to learning, but you can construct &nbsp;features from it that are. This &nbsp;is typically where most of the effort in &nbsp;a machine learning project goes. It is &nbsp;often also one of the most interesting &nbsp;parts, where intuition, creativity and &nbsp;“black art” are as important as the &nbsp;technical stuff. &nbsp;</p> <p>First-timers are often surprised by &nbsp;how little time in a machine learning &nbsp;project is spent actually doing machine learning. But it makes sense if &nbsp;you consider how time-consuming it &nbsp;is to gather data, integrate it, clean it &nbsp;and preprocess it, and how much trial &nbsp;and error can go into feature design. &nbsp;Also, machine learning is not a oneshot &nbsp;process of building a dataset and &nbsp;running a learner, but rather an iterative &nbsp;process of running the learner, &nbsp;analyzing the results, modifying the &nbsp;data and/or the learner, and repeating. &nbsp;Learning is often the quickest &nbsp;part of this, but that is because we &nbsp;have already mastered it pretty well! &nbsp;Feature engineering is more difficult &nbsp;because it is domain-specific, &nbsp;while learners can be largely general &nbsp;purpose. However, there is no sharp &nbsp;frontier between the two, and this is &nbsp;another reason the most useful learners &nbsp;are those that facilitate incorporating &nbsp;knowledge. &nbsp;</p> <p>Of course, one of the holy grails &nbsp;of machine learning is to automate &nbsp;more and more of the feature engineering &nbsp;process. One way this is often &nbsp;done today is by automatically generating &nbsp;large numbers of candidate features &nbsp;and selecting the best by (say) &nbsp;their information gain with respect &nbsp;to the class. But bear in mind that &nbsp;features that look irrelevant in isolation &nbsp;may be relevant in combination. &nbsp;For example, if the class is an XOR of &nbsp;k input features, each of them by itself &nbsp;carries no information about the &nbsp;class. (If you want to annoy machine &nbsp;learners, bring up XOR.) On the other &nbsp;hand, running a learner with a very &nbsp;large number of features to find out &nbsp;which ones are useful in combination &nbsp;may be too time-consuming, or cause &nbsp;overfitting. So there is ultimately no &nbsp;replacement for the smarts you put &nbsp;into feature engineering.</p> </td> 
   <td style="width:533px;">最终，一些机器学习项目成功了而有些失败了。有什么区别？最重要的因素很容易就是所使用的功能。如果您具有许多与班级紧密相关的独立功能，则学习将很容易。另一方面，如果该类是功能的非常复杂的功能，则您可能无法学习它。通常，原始数据的形式不适合学习，但您可以从中构造特征。这通常是机器学习项目中大部分工作的去向。它通常也是最有趣的部分之一，直觉，创造力和“妖术”与技术同样重要。初学者通常会对机器学习项目中实际用于机器学习的时间很少感到惊讶。但是，如果您考虑收集数据，集成，清理和预处理数据要花多长时间，以及可以在功能设计中进行多少试验和错误，这是有道理的。此外，机器学习不是构建数据集和运行学习者的一站式过程，而是运行学习者，分析结果，修改数据和/或学习者并重复的迭代过程。学习通常是其中最快的部分，但这是因为我们已经很好地掌握了它！特征工程更加困难，因为它是特定于领域的，而学习者在很大程度上可能是通用的。但是，两者之间没有敏锐的疆界，这是最有用的学习者是那些有助于整合知识的学习者的另一个原因。当然，机器学习的圣地之一是使越来越多的特征工程过程自动化。今天通常这样做的一种方式是通过自动生成大量候选特征并通过（比如说）它们相对于类的信息增益来选择最佳特征。但是请记住，孤立地看起来无关紧要的功能可能会组合在一起使用。例如，如果类别是k个输入要素的XOR，则每个类别本身都不携带有关类别的信息。 （如果要惹恼机器学习者，请调出XOR。）另一方面，运行具有大量功能的学习器以找出哪些功能组合在一起可能会非常耗时，或导致过度拟合。因此，您投入功能工程的智能最终无法替代。</td> 
  </tr> 
 </tbody> 
</table>

## More Data Beats  a Cleverer Algorithm  智慧算法带来更多数据优势 ##

<table> 
 <tbody> 
  <tr> 
   <td style="width:692px;">Suppose you have constructed the &nbsp;best set of features you can, but the &nbsp;classifiers you receive are still not accurate &nbsp;enough. What can you do now? &nbsp;There are two main choices: design a &nbsp;better learning algorithm, or gather &nbsp;more data (more examples, and possibly &nbsp;more raw features, subject to &nbsp;the curse of dimensionality). Machine &nbsp;learning researchers are mainly concerned &nbsp;with the former, but pragmatically &nbsp;the quickest path to success is often to just get more data. As a rule &nbsp;of thumb, a dumb algorithm with lots &nbsp;and lots of data beats a clever one with &nbsp;modest amounts of it. (After all, machine &nbsp;learning is all about letting data &nbsp;do the heavy lifting.) &nbsp;This does bring up another problem, &nbsp;however: scalability. In most of &nbsp;computer science, the two main limited &nbsp;resources are time and memory. &nbsp;In machine learning, there is a third &nbsp;one: training data. Which one is the &nbsp;bottleneck has changed from decade &nbsp;to decade. In the 1980s it tended to &nbsp;be data. Today it is often time. Enormous &nbsp;mountains of data are available, &nbsp;but there is not enough time &nbsp;to process it, so it goes unused. This &nbsp;leads to a paradox: even though in &nbsp;principle more data means that more &nbsp;complex classifiers can be learned, in &nbsp;practice simpler classifiers wind up &nbsp;being used, because complex ones &nbsp;take too long to learn. Part of the answer &nbsp;is to come up with fast ways to &nbsp;learn complex classifiers, and indeed &nbsp;there has been remarkable progress &nbsp;in this direction (for example, Hulten &nbsp;and Domingos11). &nbsp;<br> Part of the reason using cleverer &nbsp;algorithms has a smaller payoff than &nbsp;you might expect is that, to a first approximation, &nbsp;they all do the same. &nbsp;This is surprising when you consider &nbsp;representations as different as, say, &nbsp;sets of rules and neural networks. But &nbsp;in fact propositional rules are readily &nbsp;encoded as neural networks, and similar &nbsp;relationships hold between other &nbsp;representations. All learners essentially &nbsp;work by grouping nearby examples &nbsp;into the same class; the key difference &nbsp;is in the meaning of “nearby.” &nbsp;With nonuniformly distributed data, &nbsp;learners can produce widely different &nbsp;frontiers while still making the same &nbsp;predictions in the regions that matter &nbsp;(those with a substantial number of &nbsp;training examples, and therefore also &nbsp;where most test examples are likely to &nbsp;appear). This also helps explain why &nbsp;powerful learners can be unstable but &nbsp;still accurate. Figure 3 illustrates this &nbsp;in 2D; the effect is much stronger in &nbsp;high dimensions. &nbsp;</td> 
   <td style="width:507px;"> <p>假设您已经构建了最好的功能集，但是收到的分类器仍然不够准确。你现在可以做什么？有两个主要选择：设计更好的学习算法，或收集更多数据（更多示例，可能还有更多原始特征，这取决于维度的诅咒）。机器学习研究人员主要与前者有关，但务实地，成功的最快途径通常是获取更多数据。根据经验，具有大量数据的愚蠢算法要击败数量适中的聪明算法。 （毕竟，机器学习只不过是让数据繁重而已。）但这确实带来了另一个问题：可伸缩性。在大多数计算机科学中，两个主要的有限资源是时间和内存。在机器学习中，有三分之一是训练数据。哪个瓶颈已经从十年改变到了十年。在1980年代，它倾向于成为数据。今天是时候了。有大量的数据可用，但是没有足够的时间来处理它，因此它没有被使用。这导致了一个悖论：尽管在原则上更多的数据意味着可以学习更多的复杂分类器，但在实践中却使用了更简单的分类器，因为复杂的分类器学习时间太长。答案的一部分是想出一种快速的方法来学习复杂的分类器，实际上在这个方向上已经取得了显着的进展（例如Hulten和Domingos11）。<br> 使用更聪明算法的部分原因是收益比您预期的要小，这是一个近似值。当您认为表示形式与规则集和神经网络不同时，这令人惊讶。但是实际上命题规则很容易被编码为神经网络，并且其他表示之间也存在类似的关系。本质上，所有学习者都通过将附近的示例分组到同一个班级中来工作;关键区别在于“附近”的含义。使用非均匀分布的数据，学习者可以产生非常不同的边界，同时仍可以在重要区域做出相同的预测（那些区域具有大量的训练示例，因此也有可能出现大多数测试示例）。这也有助于解释为什么强大的学习者可能不稳定但仍然准确。图3以2D形式说明了这一点;在高尺寸时效果更强。</p> <p>&nbsp;</p> </td> 
  </tr> 
  <tr> 
   <td style="width:692px;">As a rule, it pays to try the simplest &nbsp;learners first (for example, naïve Bayes &nbsp;before logistic regression, k-nearest &nbsp;neighbor before support vector machines). &nbsp;More sophisticated learn ers are seductive, but they are usually &nbsp;harder to use, because they have more &nbsp;knobs you need to turn to get good results, &nbsp;and because their internals are &nbsp;more opaque. &nbsp;<br> Learners can be divided into two &nbsp;major types: those whose representation &nbsp;has a fixed size, like linear classifiers, &nbsp;and those whose representation &nbsp;can grow with the data, like decision &nbsp;trees. (The latter are sometimes called &nbsp;nonparametric learners, but this is &nbsp;somewhat unfortunate, since they &nbsp;usually wind up learning many more &nbsp;parameters than parametric ones.) &nbsp;Fixed-size learners can only take advantage &nbsp;of so much data. (Notice how &nbsp;the accuracy of naive Bayes asymptotes &nbsp;at around 70% in Figure 2.) Variablesize &nbsp;learners can in principle learn any &nbsp;function given sufficient data, but in &nbsp;practice they may not, because of limitations &nbsp;of the algorithm (for example, &nbsp;greedy search falls into local optima) &nbsp;or computational cost. Also, because &nbsp;of the curse of dimensionality, no existing &nbsp;amount of data may be enough. &nbsp;For these reasons, clever algorithms— &nbsp;those that make the most of the data &nbsp;and computing resources available— &nbsp;often pay off in the end, provided you &nbsp;are willing to put in the effort. There &nbsp;is no sharp frontier between designing &nbsp;learners and learning classifiers; &nbsp;rather, any given piece of knowledge &nbsp;could be encoded in the learner or &nbsp;learned from data. So machine learning &nbsp;projects often wind up having a &nbsp;significant component of learner design, &nbsp;and practitioners need to have &nbsp;some expertise in it.12<br> In the end, the biggest bottleneck is not data or CPU cycles, but human cycles. In research papers, learners &nbsp;are typically compared on measures &nbsp;of accuracy and computational cost. &nbsp;But human effort saved and insight &nbsp;gained, although harder to measure, &nbsp;are often more important. This favors &nbsp;learners that produce human-understandable &nbsp;output (for example, rule &nbsp;sets). And the organizations that make &nbsp;the most of machine learning are &nbsp;those that have in place an infrastructure &nbsp;that makes experimenting with &nbsp;many different learners, data sources, &nbsp;and learning problems easy and efficient, &nbsp;and where there is a close collaboration &nbsp;between machine learning &nbsp;experts and application domain ones.</td> 
   <td style="width:507px;">通常，首先尝试最简单的学习者是值得的（例如，逻辑回归之前的朴素贝叶斯，支持向量机之前的k近邻）。经验丰富的学习者很诱人，但它们通常更难使用，因为它们具有更多的旋钮，您需要转向以获得良好的效果，并且它们的内部更加不透明。<br> 学习者可以分为两种主要类型：那些具有固定大小的表示形式（如线性分类器）和那些随着数据增长的表示形式（如决策树）。 （后者有时被称为非参数学习者，但这有点不幸，因为他们通常要比参数学习更多的参数。）固定大小的学习者只能利用这么多数据。 （请注意，图2中朴素的贝叶斯渐近线的准确度约为70％）。可变大小的学习者原则上可以在给定足够数据的情况下学习任何函数，但由于算法的限制，实际上它们可能无法学习任何函数（例如，贪婪搜索下降转化为局部最优值）或计算成本。同样，由于维数的诅咒，现有的数据量可能不足。由于这些原因，只要您愿意付出努力，聪明的算法-那些可以充分利用可用数据和计算资源的算法通常会最终获得回报。设计学习者和学习分类器之间没有前沿的界限;相反，任何给定的知识都可以在学习者中进行编码或从数据中学习。因此，机器学习项目通常会包含学习者设计的重要组成部分，并且从业者需要在其中拥有一些专业知识.12<br> 最后，最大的瓶颈不是数据或CPU周期，而是人员周期。在研究论文中，通常会比较学习者的准确性和计算成本。但是，尽管难以衡量，但节省了人力并获得见识通常更重要。这有利于产生人类可理解的输出（例如规则集）的学习者。充分利用机器学习的组织是那些拥有适当基础设施的组织，这些基础设施使对许多不同的学习者，数据源和学习问题的实验变得容易而高效，并且机器学习专家和应用程序领域之间存在密切的协作那些。</td> 
  </tr> 
 </tbody> 
</table>

## Learn Many Models, Not Just One  学习多种模型，而不仅仅是一种 ##

<table> 
 <tbody> 
  <tr> 
   <td style="width:642px;">In the early days of machine learning, &nbsp;everyone had a favorite learner, &nbsp;together with some a priori reasons &nbsp;to believe in its superiority. Most effort &nbsp;went into trying many variations &nbsp;of it and selecting the best one. Then &nbsp;systematic empirical comparisons &nbsp;showed that the best learner varies &nbsp;from application to application, and &nbsp;systems containing many different &nbsp;learners started to appear. Effort now &nbsp;went into trying many variations of &nbsp;many learners, and still selecting just &nbsp;the best one. But then researchers &nbsp;noticed that, if instead of selecting &nbsp;the best variation found, we combine &nbsp;many variations, the results are better—often &nbsp;much better—and at little &nbsp;extra effort for the user. &nbsp;<br> Creating such model ensembles is &nbsp;now standard.1 &nbsp; In the simplest technique, &nbsp;called bagging, we simply generate &nbsp;random variations of the training &nbsp;set by resampling, learn a classifier &nbsp;on each, and combine the results by &nbsp;voting. This works because it greatly &nbsp;reduces variance while only slightly &nbsp;increasing bias. In boosting, training &nbsp;examples have weights, and these are &nbsp;varied so that each new classifier focuses &nbsp;on the examples the previous &nbsp;ones tended to get wrong. In stacking, &nbsp;the outputs of individual classifiers &nbsp;become the inputs of a “higher-level” &nbsp;learner that figures out how best to &nbsp;combine them.&nbsp;</td> 
   <td style="width:556px;">在机器学习的早期，每个人都有一个喜欢的学习者，加上一些先验的理由相信它的优越性。最努力的尝试是尝试它的多种变体并选择最佳的一种。然后系统的经验比较表明，最佳学习者因应用程序而异，并且包含许多不同学习者的系统开始出现。现在，我们努力尝试许多学习者的许多变体，但仍然只选择最好的一个。但是随后研究人员注意到，如果我们不选择发现的最佳变体，而是结合许多变体，则结果会更好-通常更好得多-并且对用户来说几乎没有额外的精力。<br> 创建这样的模型集成现在是标准的.1。在最简单的技术（称为装袋）中，我们只需通过重新采样就可以生成训练集的随机变化，在每个学习一个分类器，然后通过投票合并结果。之所以行之有效，是因为它大大减少了方差，而偏差却稍有增加。在增强方面，训练示例具有权重，并且这些权重是可变的，因此每个新分类器都将重点放在示例上，而先前的那些往往会出错。在堆叠中，单个分类器的输出成为一个``高级''学习器的输入，该学习器找出了如何最好地组合它们。</td> 
  </tr> 
  <tr> 
   <td style="width:642px;">Many other techniques exist, and &nbsp;the trend is toward larger and larger &nbsp;ensembles. In the Netflix prize, teams &nbsp;from all over the world competed to &nbsp;build the best video recommender system (http://netflixprize.com). As &nbsp;the competition progressed, teams &nbsp;found they obtained the best results &nbsp;by combining their learners with other &nbsp;teams’, and merged into larger and &nbsp;larger teams. The winner and runnerup &nbsp;were both stacked ensembles of &nbsp;over 100 learners, and combining the &nbsp;two ensembles further improved the &nbsp;results. Doubtless we will see even &nbsp;larger ones in the future. &nbsp;<br> Model ensembles should not be &nbsp;confused with Bayesian model averaging &nbsp;(BMA)—the theoretically &nbsp;optimal approach to learning.4 &nbsp; In &nbsp;BMA, predictions on new examples &nbsp;are made by averaging the individual &nbsp;predictions of all classifiers in the &nbsp;hypothesis space, weighted by how &nbsp;well the classifiers explain the training &nbsp;data and how much we believe &nbsp;in them a priori. Despite their superficial &nbsp;similarities, ensembles and &nbsp;BMA are very different. Ensembles &nbsp;change the hypothesis space (for example, &nbsp;from single decision trees to &nbsp;linear combinations of them), and &nbsp;can take a wide variety of forms. BMA &nbsp;assigns weights to the hypotheses in &nbsp;the original space according to a fixed &nbsp;formula. BMA weights are extremely &nbsp;different from those produced by &nbsp;(say) bagging or boosting: the latter &nbsp;are fairly even, while the former are &nbsp;extremely skewed, to the point where &nbsp;the single highest-weight classifier &nbsp;usually dominates, making BMA effectively &nbsp;equivalent to just selecting &nbsp;it.8 &nbsp; A practical consequence of this is &nbsp;that, while model ensembles are a key &nbsp;part of the machine learning toolkit, &nbsp;BMA is seldom worth the trouble.</td> 
   <td style="width:556px;">存在许多其他技术，并且趋势正在越来越大。在Netflix奖项中，来自世界各地的团队竞争建立了最佳的视频推荐系统（http://netflixprize.com）。随着比赛的进行，团队发现他们通过将学习者与其他``团队''结合在一起而获得了最佳成绩，并合并为越来越大的团队。获胜者和亚军都是超过100名学习者的堆叠乐团，并且将这两个乐团结合起来可以进一步改善结果。毫无疑问，我们将来会看到更大的机型。<br> 模型集合不应与贝叶斯模型平均（BMA）混淆-理论上的最佳学习方法.4在BMA中，对新示例的预测是通过对假设空间中所有分类器的各个预测取平均，并通过对分类器加权的方式得出的解释训练数据以及我们对它们有先验的信任度。尽管它们在表面上有相似之处，但合奏和BMA却有很大不同。集合更改假设空间（例如，从单个决策树更改为它们的线性组合），并且可以采用多种形式。 BMA根据固定公式将权重分配给原始空间中的假设。 BMA权重与（例如）装袋或提升产生的权重极为不同：后者相当均匀，而前者则极为偏斜，以至于单个最高权重的分类器通常占主导地位，这使得BMA有效地等同于仅选择它.8的实际结果是，虽然模型集成是机器学习工具包的关键部分，但BMA很少值得为此烦恼。</td> 
  </tr> 
 </tbody> 
</table>

## Simplicity Does Not  Imply Accuracy  简易性不准确 ##

<table> 
 <tbody> 
  <tr> 
   <td>Just because &nbsp;a function can &nbsp;be represented &nbsp;does not mean &nbsp;it can be learned.</td> 
   <td style="width:491px;">仅仅因为可以表示一个函数并不意味着可以学习它。</td> 
  </tr> 
  <tr> 
   <td>Occam’s razor famously states that &nbsp;entities should not be multiplied beyond &nbsp;necessity. In machine learning, &nbsp;this is often taken to mean that, given &nbsp;two classifiers with the same training &nbsp;error, the simpler of the two will likely &nbsp;have the lowest test error. Purported &nbsp;proofs of this claim appear regularly &nbsp;in the literature, but in fact there are &nbsp;many counterexamples to it, and the &nbsp;“no free lunch” theorems imply it cannot &nbsp;be true. &nbsp;We saw one counterexample previously: &nbsp;model ensembles. The generalization &nbsp;error of a boosted ensemble continues to improve by adding classifiers &nbsp;even after the training error has &nbsp;reached zero. Another counterexample &nbsp;is support vector machines, which &nbsp;can effectively have an infinite number &nbsp;of parameters without overfitting. &nbsp;Conversely, the function sign(sin(ax)) &nbsp;can discriminate an arbitrarily large, &nbsp;arbitrarily labeled set of points on the &nbsp;x axis, even though it has only one parameter.23 &nbsp;Thus, contrary to intuition, &nbsp;there is no necessary connection between &nbsp;the number of parameters of a &nbsp;model and its tendency to overfit. &nbsp;</td> 
   <td style="width:491px;">奥卡姆（Occam）的剃刀著名地指出，实体不应超出必需的数量。在机器学习中，这通常是指给定两个具有相同训练误差的分类器，两个简单的分类器可能具有最低的测试误差。据称该主张的证据在文献中经常出现，但实际上有很多反例，并且``无免费午餐''定理表明它不成立。之前我们看到了一个反例：模型集成。甚至在训练误差达到零之后，通过添加分类器，仍可以提高增强的合奏的泛化误差。另一个反例是支持向量机，它可以有效地具有无限数量的参数而不会过度拟合。相反，功能符号（sin（ax））可以区分x轴上任意大的，带有标签的点集，尽管它只有一个参数.23因此，与直觉相反，数字之间没有必要的联系模型的参数及其过度拟合的趋势。</td> 
  </tr> 
  <tr> 
   <td>A more sophisticated view instead &nbsp;equates complexity with the size of &nbsp;the hypothesis space, on the basis that &nbsp;smaller spaces allow hypotheses to be &nbsp;represented by shorter codes. Bounds &nbsp;like the one in the section on theoretical &nbsp;guarantees might then be viewed &nbsp;as implying that shorter hypotheses &nbsp;generalize better. This can be further &nbsp;refined by assigning shorter codes to &nbsp;the hypotheses in the space we have &nbsp;some a priori preference for. But &nbsp;viewing this as “proof” of a trade-off &nbsp;between accuracy and simplicity is &nbsp;circular reasoning: we made the hypotheses &nbsp;we prefer simpler by design, &nbsp;and if they are accurate it is because &nbsp;our preferences are accurate, not because &nbsp;the hypotheses are “simple” in &nbsp;the representation we chose. &nbsp;<br> A further complication arises from &nbsp;the fact that few learners search their &nbsp;hypothesis space exhaustively. A &nbsp;learner with a larger hypothesis space &nbsp;that tries fewer hypotheses from it &nbsp;is less likely to overfit than one that &nbsp;tries more hypotheses from a smaller &nbsp;space. As Pearl18 points out, the size of &nbsp;the hypothesis space is only a rough &nbsp;guide to what really matters for relating &nbsp;training and test error: the procedure &nbsp;by which a hypothesis is chosen. &nbsp;<br> Domingos7 &nbsp; surveys the main arguments &nbsp;and evidence on the issue of &nbsp;Occam’s razor in machine learning. &nbsp;The conclusion is that simpler hypotheses &nbsp;should be preferred because &nbsp;simplicity is a virtue in its own right, &nbsp;not because of a hypothetical connection &nbsp;with accuracy. This is probably &nbsp;what Occam meant in the first place.</td> 
   <td style="width:491px;"> <p>相反，一个更复杂的视图将复杂度与假设空间的大小等同起来，其依据是较小的空间允许用较短的代码表示假设。像理论保证一节中所述的界限可能会被认为暗示着较短的假设通常会更好。可以通过为我们具有某些先验偏好的空间中的假设分配较短的代码来进一步完善。但是，将其视为在准确性和简单性之间进行权衡的``证明''是循环推理：我们通过设计使假设变得更简单，如果假设是准确的，那是因为我们的偏好是准确的，而不是因为假设是``简单的''在我们选择的表示形式中。</p> <p>更为复杂的是由于几乎没有学习者详尽地搜索其假设空间这一事实。拥有较大假设空间的学习者从中尝试较少的假设的可能性比从较小空间尝试更多假设的学习者的过拟合可能性小。正如Pearl18所指出的那样，假设空间的大小仅是对与训练和测试误差有关的真正重要性的粗略指导：选择假设的过程。 Domingos7调查了有关机器学习中Occam剃刀问题的主要论点和证据。结论是，应采用更简单的假设，因为简单性本身就是一种美德，而不是因为假设与准确性之间的联系。这可能是Occam首先的意思。</p> </td> 
  </tr> 
 </tbody> 
</table>

## Representable Does Not  Imply Learnable  有代表性的不容易学习 ##

<table> 
 <tbody> 
  <tr> 
   <td> <p>Essentially all representations used in &nbsp;variable-size learners have associated theorems of the form “Every function &nbsp;can be represented, or approximated &nbsp;arbitrarily closely, using this representation.” &nbsp;Reassured by this, fans of &nbsp;the representation often proceed to &nbsp;ignore all others. However, just because &nbsp;a function can be represented &nbsp;does not mean it can be learned. For &nbsp;example, standard decision tree learners &nbsp;cannot learn trees with more leaves &nbsp;than there are training examples. In &nbsp;continuous spaces, representing even &nbsp;simple functions using a fixed set of &nbsp;primitives often requires an infinite &nbsp;number of components. Further, if &nbsp;the hypothesis space has many local &nbsp;optima of the evaluation function, as &nbsp;is often the case, the learner may not &nbsp;find the true function even if it is representable. &nbsp;Given finite data, time and &nbsp;memory, standard learners can learn &nbsp;only a tiny subset of all possible functions, &nbsp;and these subsets are different &nbsp;for learners with different representations. &nbsp;Therefore the key question is &nbsp;not “Can it be represented?” to which &nbsp;the answer is often trivial, but “Can it &nbsp;be learned?” And it pays to try different &nbsp;learners (and possibly combine them). &nbsp;</p> <p>Some representations are exponentially &nbsp;more compact than others for &nbsp;some functions. As a result, they may &nbsp;also require exponentially less data to &nbsp;learn those functions. Many learners &nbsp;work by forming linear combinations &nbsp;of simple basis functions. For example, &nbsp;support vector machines form &nbsp;combinations of kernels centered at &nbsp;some of the training examples (the &nbsp;support vectors). Representing parity &nbsp;of n bits in this way requires 2n &nbsp; basis &nbsp;functions. But using a representation &nbsp;with more layers (that is, more steps &nbsp;between input and output), parity can &nbsp;be encoded in a linear-size classifier. &nbsp;Finding methods to learn these deeper &nbsp;representations is one of the major research &nbsp;frontiers in machine learning.2</p> </td> 
   <td style="width:482px;"> <p>基本上，可变大小学习器中使用的所有表示形式都有相关的定理，形式为``可以使用该表示形式来表示或任意近似地逼近每个函数''。对此感到放心的是，代表制的支持者经常会忽略其他所有人。但是，仅仅因为可以表示一个函数并不意味着可以学习它。例如，标准决策树学习者无法学习叶子多于训练实例的树。在连续空间中，使用一组固定的基元表示甚至简单的函数通常需要无限数量的组件。此外，如果假设空间具有很多评估函数的局部最优值（通常是这样），则学习者即使可以表示，也可能找不到真正的函数。给定有限的数据，时间和内存，标准学习者只能学习所有可能功能的一小部分，而对于具有不同表示形式的学习者来说，这些子集是不同的。因此，关键问题不是“能否代表？”答案通常是微不足道的，但是“可以学习吗？”尝试不同的学习者（并可能将他们合并）是值得的。</p> <p>对于某些功能，某些表示形式比其他表示形式更紧凑。结果，他们可能还需要以指数形式减少的数据来学习这些功能。许多学习者通过形成简单基函数的线性组合来工作。例如，支持向量机形成了以一些训练示例（支持向量）为中心的内核组合。以这种方式表示n位的奇偶校验需要2n个基函数。但是使用具有更多层的表示（即输入和输出之间的更多步骤），可以将奇偶校验编码为线性大小的分类器。寻找学习这些更深层表示的方法是机器学习的主要研究领域之一.2</p> </td> 
  </tr> 
 </tbody> 
</table>

## Correlation Does Not  Imply Causation  关联不表示因果关系 ##

<table> 
 <tbody> 
  <tr> 
   <td style="width:691px;">The point that correlation does not &nbsp;imply causation is made so often that &nbsp;it is perhaps not worth belaboring. &nbsp;But, even though learners of the kind &nbsp;we have been discussing can only &nbsp;learn correlations, their results are &nbsp;often treated as representing causal &nbsp;relations. Isn’t this wrong? If so, then &nbsp;why do people do it?<br> More often than not, the goal &nbsp;of learning predictive models is to &nbsp;use them as guides to action. If we &nbsp;find that beer and diapers are often &nbsp;bought together at the supermarket, &nbsp;then perhaps putting beer next &nbsp;to the diaper section will increase &nbsp;sales. (This is a famous example in &nbsp;the world of data mining.) But short &nbsp;of actually doing the experiment it is &nbsp;difficult to tell. Machine learning is &nbsp;usually applied to observational data, &nbsp;where the predictive variables are not &nbsp;under the control of the learner, as &nbsp;opposed to experimental data, where &nbsp;they are. Some learning algorithms &nbsp;can potentially extract causal information &nbsp;from observational data, but &nbsp;their applicability is rather restricted.19 &nbsp;On the other hand, correlation &nbsp;is a sign of a potential causal connection, &nbsp;and we can use it as a guide to &nbsp;further investigation (for example, &nbsp;trying to understand what the causal &nbsp;chain might be). &nbsp;</td> 
   <td style="width:507px;"><span style="color:#f33b45;">关联并不意味着因果关系如此频繁</span>，这一点也许值得我们去研究。但是，即使我们一直在讨论的那种学习者只能学习相关性，他们的结果也经常被视为代表因果关系。这不是错吗？如果是这样，那么人们为什么这样做？<br> 通常，学习预测模型的目的是将其用作行动指南。如果我们发现啤酒和尿布经常是在超市一起买的，那么也许把啤酒放在尿布下面会增加销量。 （这是数据挖掘世界中的一个著名示例。）但是实际上很难进行实验，很难说清楚。机器学习通常应用于观测数据，而预测变量不在学习者的控制之下，而与实验数据相反。一些学习算法可能会从观测数据中提取因果信息，但其适用性受到限制.19另一方面，相关性是潜在因果关系的标志，我们可以将其用作进一步调查的指南（例如，试图了解原因链可能是什么）。</td> 
  </tr> 
  <tr> 
   <td style="width:691px;">Many researchers believe that causality &nbsp;is only a convenient fiction. For &nbsp;example, there is no notion of causality &nbsp;in physical laws. Whether or not &nbsp;causality really exists is a deep philosophical &nbsp;question with no definitive &nbsp;answer in sight, but there are two &nbsp;practical points for machine learners. &nbsp;First, whether or not we call them &nbsp;“causal,” we would like to predict the &nbsp;effects of our actions, not just correlations &nbsp;between observable variables. &nbsp;Second, if you can obtain experimental &nbsp;data (for example by randomly assigning &nbsp;visitors to different versions of &nbsp;a Web site), then by all means do so.14 &nbsp;</td> 
   <td style="width:507px;">许多研究人员认为因果关系只是一种方便的小说。 例如，物理定律中没有因果关系的概念。<strong><span style="color:#f33b45;"> 因果关系是否真的存在是一个深刻的哲学问题，没有明确的答案</span></strong>，但是对于机器学习者来说有两个实践点。 首先，无论我们是否称其为``因果关系''，我们都希望预测行为的影响，而不仅仅是可观察变量之间的相关性。 其次，如果您可以获得实验数据（例如通过将访问者随机分配给网站的不同版本），则一定要这样做.14</td> 
  </tr> 
 </tbody> 
</table>

## Conclusion  结论 ##

<table> 
 <tbody> 
  <tr> 
   <td style="width:700px;">Like any discipline, machine learning &nbsp;has a lot of “folk wisdom” that can &nbsp;be difficult to come by, but is crucial &nbsp;for success. This article summarized &nbsp;some of the most salient items. Of &nbsp;course, it is only a complement to the &nbsp;more conventional study of machine &nbsp;learning. Check out http://www. &nbsp;cs.washington.edu/homes/pedrod/ &nbsp;class for a complete online machine &nbsp;learning course that combines formal &nbsp;and informal aspects. There is also a &nbsp;treasure trove of machine learning &nbsp;lectures at http://www.videolectures. &nbsp;net. A good open source machine &nbsp;learning toolkit is Weka.24 &nbsp;<br> Happy learning！</td> 
   <td style="width:499px;"><span style="color:#f33b45;">像任何学科一样，机器学习具有许多难以获得的``民间智慧''，但对于成功至关重要</span>。 本文总结了一些最突出的项目。 当然，它只是对机器学习的更常规研究的补充。 查看http：// www。 cs.washington.edu/homes/pedrod/上一堂完整的在线机器学习课程，该课程结合了正式和非正式方面。 在http：//www.videolectures上还有一个机器学习宝库。 净。 一个很好的开源机器学习工具包是Weka.24祝您学习愉快！</td> 
  </tr> 
 </tbody> 
</table>

[https_homes.cs.washington.edu_pedrod_papers_cacm12.pdf]: https://homes.cs.washington.edu/~pedrod/papers/cacm12.pdf