精华内容
下载资源
问答
  • python源码集锦-随机森林预测宽带客户续网
  • 利用随机森林模型进行回归预测python程序
  • python中实现随机森林Random forest is a highly versatile machine learning method with numerous applications ranging from marketing to healthcare and insurance. It can be used to model the impact of ...

    python中实现随机森林

    Random forest is a highly versatile machine learning method with numerous applications ranging from marketing to healthcare and insurance. It can be used to model the impact of marketing on customer acquisition, retention, and churn or to predict disease risk and susceptibility in patients.

    随机森林是一种用途广泛的机器学习方法,具有从营销到医疗保健和保险的众多应用。 它可用于建模营销对客户获取,保留和流失的影响,预测患者的疾病风险和易感性

    Random forest is capable of regression and classification. It can handle a large number of features, and it’s helpful for estimating which of your variables are important in the underlying data being modeled.

    随机森林具有回归和分类的能力。 它可以处理大量功能,并且有助于估计哪些变量在要建模的基础数据中很重要。

    This is a post about random forests using Python.

    这是一篇有关使用Python的随机森林的文章。

    什么是随机森林? (What is a Random Forest?)

    Random forest is solid choice for nearly any prediction problem (even non-linear ones). It’s a relatively new machine learning strategy (it came out of Bell Labs in the 90s) and it can be used for just about anything. It belongs to a larger class of machine learning algorithms called ensemble methods.

    随机森林是几乎所有预测问题(甚至是非线性问题)的可靠选择。 这是一种相对较新的机器学习策略(它是90年代来自贝尔实验室的),几乎可以用于任何事物。 它属于一类称为集成方法的较大机器学习算法。

    合奏学习 (Ensemble Learning)

    Ensemble learning involves the combination of several models to solve a single prediction problem. It works by generating multiple classifiers/models which learn and make predictions independently. Those predictions are then combined into a single (mega) prediction that should be as good or better than the prediction made by any one classifer.

    集成学习涉及多个模型的组合以解决单个预测问题。 它通过生成多个独立学习和做出预测的分类器/模型来工作。 然后将这些预测合并为单个(大型)预测,该预测应该比任何一个分类器的预测都好或更好。

    Random forest is a brand of ensemble learning, as it relies on an ensemble of decision trees. More on ensemble learning in Python here: Scikit-Learn docs.

    随机森林是集成学习的品牌,因为它依赖于决策树的集成。 有关Python合奏学习的更多信息,请参见: Scikit-Learn docs

    随机决策树 (Randomized Decision Trees)

    So we know that random forest is an aggregation of other models, but what types of models is it aggregating? As you might have guessed from its name, random forest aggregates Classification (or Regression) Trees. A decision tree is composed of a series of decisions that can be used to classify an observation in a dataset.

    因此,我们知道随机森林是其他模型的集合,但是它将聚集什么类型的模型? 正如您可能已经从其名称中猜到的那样,随机森林聚集了分类(或回归)树 。 决策树由一系列决策组成,可用于对数据集中的观察进行分类。

    随机森林 (Random Forest)

    The algorithm to induce a random forest will create a bunch of random decision trees automatically. Since the trees are generated at random, most won’t be all that meaningful to learning your classification/regression problem (maybe 99.9% of trees).

    诱导随机森林的算法将自动创建一堆随机决策树。 由于树是随机生成的,因此对于学习分类/回归问题(可能是99.9%的树)而言,大多数树都没有那么有意义。

    If an observation has a length of 45, blue eyes, and 2 legs, it’s going to be classified as red.

    如果观察结果的长度为45,蓝眼睛,两条腿,则将其分类为红色

    树木投票 (Arboreal Voting)

    So what good are 10000 (probably) bad models? Well it turns out that they really aren’t that helpful. But what is helpful are the few really good decision trees that you also generated along with the bad ones.

    那么10000个(可能)坏模型有什么用呢? 事实证明,它们确实没有帮助。 但是有用的是,您还会生成一些与坏决策一起真正好的决策树。

    When you make a prediction, the new observation gets pushed down each decision tree and assigned a predicted value/label. Once each of the trees in the forest have reported its predicted value/label, the predictions are tallied up and the mode vote of all trees is returned as the final prediction.

    进行预测时,新观察值将推入每个决策树并分配一个预测值/标签。 一旦森林中的每棵树都报告了其预测值/标签,就对这些预测进行汇总,并返回所有树木的模式投票作为最终预测。

    Simply, the 99.9% of trees that are irrelevant make predictions that are all over the map and cancel each another out. The predictions of the minority of trees that are good top that noise and yield a good prediction.

    简而言之,不相关的99.9%的树木做出的预测遍布整个地图,并且彼此抵消。 少数树木的预测结果好于噪声并产生良好的预测。

    我为什么要使用它? (Why you should I use it?)

    这很容易 (It’s Easy)

    Random forest is the Leatherman of learning methods. You can throw pretty much anything at it and it’ll do a serviceable job. It does a particularly good job of estimating inferred transformations, and, as a result, doesn’t require much tuning like SVM (i.e. it’s good for folks with tight deadlines).

    随机森林是莱瑟曼的学习方法。 您可以将几乎任何东西扔给它,它将做有用的工作。 它在估计推断的转换方面做得特别好,因此,不需要像SVM这样的大量调整(即,对于期限紧迫的人们来说非常有用)。

    转换实例 (An Example Transformation)

    Random forest is capable of learning without carefully crafted data transformations. Take the the f(x) = log(x) function for example.

    随机森林无需经过精心设计的数据转换即可学习。 以f(x) = log(x)函数为例。

    Alright let’s write some code. We’ll be writing our Python code in Yhat’s very own interactive environment built for analyzing data, Rodeo. You can download Rodeo for Mac, Windows or Linux [here](https://www.yhat.com/products/rodeo).

    好吧,让我们写一些代码。 我们将在Yhat专门用于分析数据的互动环境Rodeo中编写Python代码。 您可以在[此处](https://www.yhat.com/products/rodeo)下载Mac,Windows或Linux的Rodeo。

    First, create some fake data and add a little noise.

    首先,创建一些虚假数据并添加一些干扰。

    
    import numpy as np
    import pylab as pl
    
    x = np.random.uniform(1, 100, 1000)
    y = np.log(x) + np.random.normal(0, .3, 1000)
    
    pl.scatter(x, y, s=1, label="log(x) with noise")
    pl.plot(np.arange(1, 100), np.log(np.arange(1, 100)), c="b", label="log(x) true function")
    pl.xlabel("x")
    pl.ylabel("f(x) = log(x)")
    pl.legend(loc="best")
    pl.title("A Basic Log Function")
    pl.show() 
    
    

    Check out the gist here

    在这里查看要点

    Following along in Rodeo? Here’s what you should see.

    跟随牛仔竞技表演吗? 这是您应该看到的。

    Let’s take a closer look at that plot.

    让我们仔细看看那个情节。

    If we try and build a basic linear model to predict y using x we wind up with a straight line that sort of bisects the log(x) function. Whereas if we use a random forest, it does a much better job of approximating the log(x) curve and we get something that looks much more like the true function.

    如果我们尝试建立一个基本的线性模型来使用x预测y我们将得出一条将log(x)函数一分为二的直线。 而如果我们使用随机森林,则在逼近log(x)曲线方面做得更好,我们得到的东西看起来更像真实函数。

    You could argue that the random forest overfits the log(x) function a little bit. Either way, I think this does a nice job of illustrating how the random forest isn’t bound by linear constraints.

    您可能会说随机森林稍微有点超出了log(x)函数。 无论哪种方式,我认为这都能很好地说明随机森林如何不受线性约束的约束。

    用途 (Uses)

    变量选择 (Variable Selection)

    One of the best use cases for random forest is feature selection. One of the byproducts of trying lots of decision tree variations is that you can examine which variables are working best/worst in each tree.

    特征选择是随机森林的最佳用例之一。 尝试大量决策树变体的副产品之一是,您可以检查哪些变量在每棵树中效果最佳/最差。

    When a certain tree uses one variable and another doesn’t, you can compare the value lost or gained from the inclusion/exclusion of that variable. The good random forest implementations are going to do that for you, so all you need to do is know which method or variable to look at.

    当某棵树使用一个变量而另一棵树不使用时,您可以比较包含或排除该变量所损失或获得的价值。 好的随机森林实现将为您做到这一点,因此您所需要做的就是知道要查看哪种方法或变量。

    In the following examples, we’re trying to figure out which variables are most important for classifying a wine as being red or white.

    在以下示例中,我们试图找出哪些变量对于将葡萄酒分类为红色或白色最重要。

    分类 (Classification)

    Random forest is also great for classification. It can be used to make predictions for categories with multiple possible values and it can be calibrated to output probabilities as well. One thing you do need to watch out for is overfitting. Random forest can be prone to overfitting, especially when working with relatively small datasets. You should be suspicious if your model is making “too good” of predictions on our test set.

    随机森林也很适合分类。 它可以用于对具有多个可能值的类别进行预测,也可以将其校准为输出概率。 您需要注意的一件事是过度拟合 。 随机森林可能易于过度拟合,尤其是在使用相对较小的数据集时。 如果您的模型对我们的测试集做出的预测“太好”,您应该会感到怀疑。

    One way to overfitting is to only use really relevant features in your model. While this isn’t always cut and dry, using a feature selection technique (like the one mentioned previously) can make it a lot easier.

    过度拟合的一种方法是仅在模型中使用真正相关的功能。 尽管这并不总是可以轻松完成的,但是使用一种功能选择技术(如前面提到的那种)可以使它变得容易得多。

    回归 (Regression)

    Yep. It does regression too.

    是的 它也进行回归。

    I’ve found that random forest–unlike other algorithms–does really well learning on categorical variables or a mixture of categorical and real variables. Categorical variables with high cardinality (# of possible values) can be tricky, so having something like this in your back pocket can come in quite useful.

    我发现,与其他算法不同,随机森林在分类变量或分类变量与实变量的混合中学习得很好。 具有高基数的分类变量(可能值的数量)可能很棘手,因此在后兜里放这样的东西会很有用。

    一个简短的Python示例 (A Short Python Example)

    Scikit-Learn is a great way to get started with random forest. The scikit-learn API is extremely consistent across algorithms, so you horse race and switch between models very easily. A lot of times I start with something simple and then move to random forest.

    Scikit-Learn是入门随机森林的好方法。 scikit-learn API在各个算法之间是极其一致的,因此您可以轻松进行比赛并在模型之间进行切换。 很多时候,我从简单的事情开始,然后转到随机森林。

    One of the best features of the random forest implementation in scikit-learn is the n_jobs parameter. This will automatically parallelize fitting your random forest based on the number of cores you want to use. Here’s a great presentation by scikit-learn contributor Olivier Grisel where he talks about training a random forest on a 20 node EC2 cluster.

    scikit-learn中随机森林实现的最佳功能之一是n_jobs参数。 这将根据您要使用的核心数自动并行化拟合您的随机森林。 这是 scikit-learn的贡献者Olivier Grisel 的精彩演讲 ,他谈到了如何在20节点EC2集群上训练随机森林。

    
    from sklearn.datasets import load_iris
    from sklearn.ensemble import RandomForestClassifier
    import pandas as pd
    import numpy as np
    
    iris = load_iris()
    df = pd.DataFrame(iris.data, columns=iris.feature_names)
    df['is_train'] = np.random.uniform(0, 1, len(df)) <= .75
    df['species'] = pd.Categorical.from_codes(iris.target, iris.target_names)
    df.head()
    
    train, test = df[df['is_train']==True], df[df['is_train']==False]
    
    features = df.columns[:4]
    clf = RandomForestClassifier(n_jobs=2)
    y, _ = pd.factorize(train['species'])
    clf.fit(train[features], y)
    
    preds = iris.target_names[clf.predict(test[features])]
    pd.crosstab(test['species'], preds, rownames=['actual'], colnames=['preds'])
    
    

    Following along? Here’s what you should see(ish). We’re using *randomly* selected data, so your exact values will differ each time.

    跟着呢? 这是您应该看到的。 我们使用的是*随机*的选定数据,因此每次的确切值都会有所不同。

    preds Preds sertosa 塞尔托萨 versicolor 杂色 virginica 维吉尼卡
    actual 实际
    sertosa 塞尔托萨 6 6 0 0 0 0
    versicolor 杂色 0 0 16 16 1 1个
    virginica 维吉尼卡 0 0 0 0 12 12

    最后的想法 (Final Thoughts)

    翻译自: https://www.pybloggers.com/2016/11/random-forests-in-python/

    python中实现随机森林

    展开全文
  • 随机森林python

    千次阅读 2018-05-19 16:11:29
    阅读目录 ... 7 随机森林Python实现 8 参考内容 回到顶部 1 什么是随机森林?  作为新兴起的、高度灵活的一种机器学习算法,随机森林(Random Forest,简称RF)拥有广泛的应用前景,从市场营销...

    阅读目录

    • 1 什么是随机森林?
    • 2 随机森林的特点
    • 3 随机森林的相关基础知识
    • 4 随机森林的生成
    • 5 袋外错误率(oob error)
    • 6 随机森林工作原理解释的一个简单例子
    • 7 随机森林的Python实现
    • 8 参考内容

    回到顶部

    1 什么是随机森林?

      作为新兴起的、高度灵活的一种机器学习算法,随机森林(Random Forest,简称RF)拥有广泛的应用前景,从市场营销到医疗保健保险,既可以用来做市场营销模拟的建模,统计客户来源,保留和流失,也可用来预测疾病的风险和病患者的易感性。最初,我是在参加校外竞赛时接触到随机森林算法的。最近几年的国内外大赛,包括2013年百度校园电影推荐系统大赛、2014年阿里巴巴天池大数据竞赛以及Kaggle数据科学竞赛,参赛者对随机森林的使用占有相当高的比例。此外,据我的个人了解来看,一大部分成功进入答辩的队伍也都选择了Random Forest 或者 GBDT 算法。所以可以看出,Random Forest在准确率方面还是相当有优势的。

      那说了这么多,那随机森林到底是怎样的一种算法呢?

      如果读者接触过决策树(Decision Tree)的话,那么会很容易理解什么是随机森林。随机森林就是通过集成学习的思想将多棵树集成的一种算法,它的基本单元是决策树,而它的本质属于机器学习的一大分支——集成学习(Ensemble Learning)方法。随机森林的名称中有两个关键词,一个是“随机”,一个就是“森林”。“森林”我们很好理解,一棵叫做树,那么成百上千棵就可以叫做森林了,这样的比喻还是很贴切的,其实这也是随机森林的主要思想--集成思想的体现。“随机”的含义我们会在下边部分讲到。

      其实从直观角度来解释,每棵决策树都是一个分类器(假设现在针对的是分类问题),那么对于一个输入样本,N棵树会有N个分类结果。而随机森林集成了所有的分类投票结果,将投票次数最多的类别指定为最终的输出,这就是一种最简单的 Bagging 思想。

    回到顶部

    2 随机森林的特点

      我们前边提到,随机森林是一种很灵活实用的方法,它有如下几个特点:

    • 在当前所有算法中,具有极好的准确率/It is unexcelled in accuracy among current algorithms;
    • 能够有效地运行在大数据集上/It runs efficiently on large data bases;
    • 能够处理具有高维特征的输入样本,而且不需要降维/It can handle thousands of input variables without variable deletion;
    • 能够评估各个特征在分类问题上的重要性/It gives estimates of what variables are important in the classification;
    • 在生成过程中,能够获取到内部生成误差的一种无偏估计/It generates an internal unbiased estimate of the generalization error as the forest building progresses;
    • 对于缺省值问题也能够获得很好得结果/It has an effective method for estimating missing data and maintains accuracy when a large proportion of the data are missing
    • ... ...

      实际上,随机森林的特点不只有这六点,它就相当于机器学习领域的Leatherman(多面手),你几乎可以把任何东西扔进去,它基本上都是可供使用的。在估计推断映射方面特别好用,以致都不需要像SVM那样做很多参数的调试。具体的随机森林介绍可以参见随机森林主页:Random Forest

    回到顶部

    3 随机森林的相关基础知识

      随机森林看起来是很好理解,但是要完全搞明白它的工作原理,需要很多机器学习方面相关的基础知识。在本文中,我们简单谈一下,而不逐一进行赘述,如果有同学不太了解相关的知识,可以参阅其他博友的一些相关博文或者文献。

      1)信息、熵以及信息增益的概念

      这三个基本概念是决策树的根本,是决策树利用特征来分类时,确定特征选取顺序的依据。理解了它们,决策树你也就了解了大概。

      引用香农的话来说,信息是用来消除随机不确定性的东西。当然这句话虽然经典,但是还是很难去搞明白这种东西到底是个什么样,可能在不同的地方来说,指的东西又不一样。对于机器学习中的决策树而言,如果带分类的事物集合可以划分为多个类别当中,则某个类(xi)的信息可以定义如下:

      I(x)用来表示随机变量的信息,p(xi)指是当xi发生时的概率。

      熵是用来度量不确定性的,当熵越大,X=xi的不确定性越大,反之越小。对于机器学习中的分类问题而言,熵越大即这个类别的不确定性更大,反之越小。

      信息增益在决策树算法中是用来选择特征的指标,信息增益越大,则这个特征的选择性越好。

      这方面的内容不再细述,感兴趣的同学可以看 信息&熵&信息增益 这篇博文。

      2)决策树

      决策树是一种树形结构,其中每个内部节点表示一个属性上的测试,每个分支代表一个测试输出,每个叶节点代表一种类别。常见的决策树算法有C4.5、ID3和CART。

      3)集成学习 

      集成学习通过建立几个模型组合的来解决单一预测问题。它的工作原理是生成多个分类器/模型,各自独立地学习和作出预测。这些预测最后结合成单预测,因此优于任何一个单分类的做出预测。

      随机森林是集成学习的一个子类,它依靠于决策树的投票选择来决定最后的分类结果。你可以在这找到用python实现集成学习的文档:Scikit 学习文档

    回到顶部

    4 随机森林的生成

      前面提到,随机森林中有许多的分类树。我们要将一个输入样本进行分类,我们需要将输入样本输入到每棵树中进行分类。打个形象的比喻:森林中召开会议,讨论某个动物到底是老鼠还是松鼠,每棵树都要独立地发表自己对这个问题的看法,也就是每棵树都要投票。该动物到底是老鼠还是松鼠,要依据投票情况来确定,获得票数最多的类别就是森林的分类结果。森林中的每棵树都是独立的,99.9%不相关的树做出的预测结果涵盖所有的情况,这些预测结果将会彼此抵消。少数优秀的树的预测结果将会超脱于芸芸“噪音”,做出一个好的预测。将若干个弱分类器的分类结果进行投票选择,从而组成一个强分类器,这就是随机森林bagging的思想(关于bagging的一个有必要提及的问题:bagging的代价是不用单棵决策树来做预测,具体哪个变量起到重要作用变得未知,所以bagging改进了预测准确率但损失了解释性。)。下图可以形象地描述这个情况:

     

      有了树我们就可以分类了,但是森林中的每棵树是怎么生成的呢?

      每棵树的按照如下规则生成:

      1)如果训练集大小为N,对于每棵树而言,随机且有放回地从训练集中的抽取N个训练样本(这种采样方式称为bootstrap sample方法),作为该树的训练集;

      从这里我们可以知道:每棵树的训练集都是不同的,而且里面包含重复的训练样本(理解这点很重要)。

      为什么要随机抽样训练集?(add @2016.05.28)

      如果不进行随机抽样,每棵树的训练集都一样,那么最终训练出的树分类结果也是完全一样的,这样的话完全没有bagging的必要;

      为什么要有放回地抽样?(add @2016.05.28)

      我理解的是这样的:如果不是有放回的抽样,那么每棵树的训练样本都是不同的,都是没有交集的,这样每棵树都是"有偏的",都是绝对"片面的"(当然这样说可能不对),也就是说每棵树训练出来都是有很大的差异的;而随机森林最后分类取决于多棵树(弱分类器)的投票表决,这种表决应该是"求同",因此使用完全不同的训练集来训练每棵树这样对最终分类结果是没有帮助的,这样无异于是"盲人摸象"。

      2)如果每个样本的特征维度为M,指定一个常数m<<M随机地从M个特征中选取m个特征子集,每次树进行分裂时,从这m个特征中选择最优的;

      3)每棵树都尽最大程度的生长,并且没有剪枝过程

      一开始我们提到的随机森林中的“随机”就是指的这里的两个随机性。两个随机性的引入对随机森林的分类性能至关重要。由于它们的引入,使得随机森林不容易陷入过拟合,并且具有很好得抗噪能力(比如:对缺省值不敏感)。

      随机森林分类效果(错误率)与两个因素有关:

    • 森林中任意两棵树的相关性:相关性越大,错误率越大;
    • 森林中每棵树的分类能力:每棵树的分类能力越强,整个森林的错误率越低。

      减小特征选择个数m,树的相关性和分类能力也会相应的降低;增大m,两者也会随之增大。所以关键问题是如何选择最优的m(或者是范围),这也是随机森林唯一的一个参数。

    回到顶部

    5 袋外错误率(oob error)

      上面我们提到,构建随机森林的关键问题就是如何选择最优的m,要解决这个问题主要依据计算袋外错误率oob error(out-of-bag error)。

      随机森林有一个重要的优点就是,没有必要对它进行交叉验证或者用一个独立的测试集来获得误差的一个无偏估计。它可以在内部进行评估,也就是说在生成的过程中就可以对误差建立一个无偏估计。

      我们知道,在构建每棵树时,我们对训练集使用了不同的bootstrap sample(随机且有放回地抽取)。所以对于每棵树而言(假设对于第k棵树),大约有1/3的训练实例没有参与第k棵树的生成,它们称为第k棵树的oob样本。

      而这样的采样特点就允许我们进行oob估计,它的计算方式如下:

      (note:以样本为单位)

      1)对每个样本,计算它作为oob样本的树对它的分类情况(约1/3的树);

      2)然后以简单多数投票作为该样本的分类结果;

      3)最后用误分个数占样本总数的比率作为随机森林的oob误分率。

      (文献原文:Put each case left out in the construction of the kth tree down the kth tree to get a classification. In this way, a test set classification is obtained for each case in about one-third of the trees. At the end of the run, take j to be the class that got most of the votes every time case n was oob. The proportion of times that j is not equal to the true class of n averaged over all cases is the oob error estimate. This has proven to be unbiased in many tests.)

      oob误分率是随机森林泛化误差的一个无偏估计,它的结果近似于需要大量计算的k折交叉验证。

    回到顶部

    6 随机森林工作原理解释的一个简单例子

      描述:根据已有的训练集已经生成了对应的随机森林,随机森林如何利用某一个人的年龄(Age)、性别(Gender)、教育情况(Highest Educational Qualification)、工作领域(Industry)以及住宅地(Residence)共5个字段来预测他的收入层次。

      收入层次 :

        Band 1 : Below $40,000

        Band 2: $40,000 – 150,000

        Band 3: More than $150,000

      随机森林中每一棵树都可以看做是一棵CART(分类回归树),这里假设森林中有5棵CART树,总特征个数N=5,我们取m=1(这里假设每个CART树对应一个不同的特征)。

      CART 1 : Variable Age

      rf1

      CART 2 : Variable Gender

      rf2

      CART 3 : Variable Education

      rf3

      CART 4 : Variable Residence

      rf4

      CART 5 : Variable Industry

      rf5

      我们要预测的某个人的信息如下:

      1. Age : 35 years ; 2. Gender : Male ; 3. Highest Educational Qualification : Diploma holder; 4. Industry : Manufacturing; 5. Residence : Metro.

      根据这五棵CART树的分类结果,我们可以针对这个人的信息建立收入层次的分布情况:

      DF

      最后,我们得出结论,这个人的收入层次70%是一等,大约24%为二等,6%为三等,所以最终认定该人属于一等收入层次(小于$40,000)。

    回到顶部

    7 随机森林的Python实现

      利用Python的两个模块,分别为pandas和scikit-learn来实现随机森林。

     新版本这里有一个问题(Factor    应该为    Categorical.from_codes)

    复制代码

    from sklearn.datasets import load_iris
    from sklearn.ensemble import RandomForestClassifier
    import pandas as pd
    import numpy as np
    
    iris = load_iris()
    df = pd.DataFrame(iris.data, columns=iris.feature_names)
    df['is_train'] = np.random.uniform(0, 1, len(df)) <= .75
    df['species'] = pd.Factor(iris.target, iris.target_names)
    df.head()
    
    train, test = df[df['is_train']==True], df[df['is_train']==False]
    
    features = df.columns[:4]
    clf = RandomForestClassifier(n_jobs=2)
    y, _ = pd.factorize(train['species'])
    clf.fit(train[features], y)
    
    preds = iris.target_names[clf.predict(test[features])]
    pd.crosstab(test['species'], preds, rownames=['actual'], colnames=['preds'])

    复制代码

     

      分类结果:

      

      与其他机器学习分类算法进行对比:

    复制代码

    import numpy as np
    import matplotlib.pyplot as plt
    from matplotlib.colors import ListedColormap
    from sklearn.cross_validation import train_test_split
    from sklearn.preprocessing import StandardScaler
    from sklearn.datasets import make_moons, make_circles, make_classification
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.svm import SVC
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
    from sklearn.naive_bayes import GaussianNB
    from sklearn.lda import LDA
    from sklearn.qda import QDA
    
    h = .02  # step size in the mesh
    
    names = ["Nearest Neighbors", "Linear SVM", "RBF SVM", "Decision Tree",
             "Random Forest", "AdaBoost", "Naive Bayes", "LDA", "QDA"]
    classifiers = [
        KNeighborsClassifier(3),
        SVC(kernel="linear", C=0.025),
        SVC(gamma=2, C=1),
        DecisionTreeClassifier(max_depth=5),
        RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),
        AdaBoostClassifier(),
        GaussianNB(),
        LDA(),
        QDA()]
    
    X, y = make_classification(n_features=2, n_redundant=0, n_informative=2,
                               random_state=1, n_clusters_per_class=1)
    rng = np.random.RandomState(2)
    X += 2 * rng.uniform(size=X.shape)
    linearly_separable = (X, y)
    
    datasets = [make_moons(noise=0.3, random_state=0),
                make_circles(noise=0.2, factor=0.5, random_state=1),
                linearly_separable
                ]
    
    figure = plt.figure(figsize=(27, 9))
    i = 1
    # iterate over datasets
    for ds in datasets:
        # preprocess dataset, split into training and test part
        X, y = ds
        X = StandardScaler().fit_transform(X)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4)
    
        x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
        y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
        xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                             np.arange(y_min, y_max, h))
    
        # just plot the dataset first
        cm = plt.cm.RdBu
        cm_bright = ListedColormap(['#FF0000', '#0000FF'])
        ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
        # Plot the training points
        ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright)
        # and testing points
        ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6)
        ax.set_xlim(xx.min(), xx.max())
        ax.set_ylim(yy.min(), yy.max())
        ax.set_xticks(())
        ax.set_yticks(())
        i += 1
    
        # iterate over classifiers
        for name, clf in zip(names, classifiers):
            ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
            clf.fit(X_train, y_train)
            score = clf.score(X_test, y_test)
    
            # Plot the decision boundary. For that, we will assign a color to each
            # point in the mesh [x_min, m_max]x[y_min, y_max].
            if hasattr(clf, "decision_function"):
                Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
            else:
                Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
    
            # Put the result into a color plot
            Z = Z.reshape(xx.shape)
            ax.contourf(xx, yy, Z, cmap=cm, alpha=.8)
    
            # Plot also the training points
            ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright)
            # and testing points
            ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright,
                       alpha=0.6)
    
            ax.set_xlim(xx.min(), xx.max())
            ax.set_ylim(yy.min(), yy.max())
            ax.set_xticks(())
            ax.set_yticks(())
            ax.set_title(name)
            ax.text(xx.max() - .3, yy.min() + .3, ('%.2f' % score).lstrip('0'),
                    size=15, horizontalalignment='right')
            i += 1
    
    figure.subplots_adjust(left=.02, right=.98)
    plt.show()

    复制代码

      这里随机生成了三个样本集,分割面近似为月形、圆形和线形的。我们可以重点对比一下决策树和随机森林对样本空间的分割:

      1)从准确率上可以看出,随机森林在这三个测试集上都要优于单棵决策树,90%>85%,82%>80%,95%=95%;

      2)从特征空间上直观地可以看出,随机森林比决策树拥有更强的分割能力(非线性拟合能力)。

      更多有关随机森林的代码:

      1)Fortran版本

      2)OpenCV版本

      3)Matlab版本

      4)R版本

    回到顶部

    8 参考内容

      [1] Random Forest's homepage (by Leo Breiman and Adele Cutler)

      [2] Introduction to Random forest - Simplified

      [3] Comparing a Random Forest to a CART model (Part 2)

      [4] Introduction to Random forest (博主:爱67)

      [5] Python实现随机森林

      [6] 随机森林之oob error估计

      [7] 随机森林

      [8] Wikipedia-Random Forest

      [9] Ensemble methods

    转载地址:这里

    展开全文
  • import pandas as pd import numpy as np from sklearn.ensemble import RandomForestClassifier import matplotlib.pyplot as plt
  • 定量输出称为回归,或者说是连续变量预测; 定性输出称为分类,或者说是离散变量预测。 举个例子: 预测明天的气温是多少度,这是一个回归任务; 预测明天是阴、晴还是雨,就是一个分类任务; 决策树三种算法...

    首先明确一下回归与分类的区别:

    分类和回归的区别在于输出变量的类型。
    定量输出称为回归,或者说是连续变量预测;
    定性输出称为分类,或者说是离散变量预测。
    举个例子:

    预测明天的气温是多少度,这是一个回归任务;
    预测明天是阴、晴还是雨,就是一个分类任务;

    决策树三种算法特性对比:

    ID3特点:

    (1)节点优先选取采用信息增益作为标准。

    (2)容易造成过度拟合(倾向于选择分类多的节点)
    (3)容易处理标称型数据(主要用于分类),但是很难处理连续型     数据(主要用于回归)。
    4.5特点:
    (1)既能处理标称型数据,又能连续型数据。为了处理连续型数据,该算法在相应的节点使用一个属性的阈值,利用阈值将样本划分成两部分。
    (2)能处理缺失了一些属性的数据。该算法允许属性值缺失时被标记为?,属性值缺失的样本在计算熵增益时被忽略。
    (3)构造完成后可以剪枝。合并相邻的无法产生大量信息增益的叶节点,消除过渡匹配问题。
    Cart特点:
     (1)CART称为分类决策树,classification and regression tree,既能处理分类问题,又能处理回归问题。
     (2)与ID3不能直接处理连续型特征不同的是,CART使用二元切分,即使用一个属性阈值对样本数据进行划分。划分的标准除了使用熵增益外,还有基尼纯净度(Gini impurity)和方差缩减(variance reduction)(用于回归)。

    集成学习(Boosting,Bagging和随机森林)

    集成学习分为2类:

    (1)个体学习器间存在强大依赖关系、必须串行生成的序列化方法,代表算法:Boosting;

    (2)个体学习器间不存在依赖关系、可同时生成的并行化方法,代表算法Bagging和“随机森林”RF。

    1.Boosting是一族可以将若学习器提升为强学习器的算法,代表算法为AdaBoost。

    该算法的工作机制:先从初始训练集训练出一个基学习器,再根据基学习器的表现对训练样本分布进行调整,使得先前基学习器做错的训练样本在后续受到更多关注,然后基于调整后的样本分布来训练下一个基学习器。如此反复进行,直至学习器数目达到事先指定的值T,最终将这T个基学习器进行加权结合。
    2.Bagging是并行式集成学习代表方法。

    基于“自助采样法”(bootstrap sampling)。自助采样法机制:给定包含m个样本的数据集,我们先随机取出一个样本放入采样集中,再把该样本放回初始数据集,使得下一次采样时该样本还会被采到。这样,经过m次样本采集,我们得到包含m个样本的采样集。采样集中,有的样本出现过很多次,有的没有出现过。Bagging机制:我们采样出T个含m个样本的采样集。然后基于每个采样集训练出一个学习器,再将学习器进行结合。对分类任务使用投票法,对回归任务采用平均值法。
    3.随机森林RF:

    以决策树为基学习器构建Bagging集成,进一步在决策树的训练过程中引入随机属性选择。传统决策树在选择划分属性的时候是在当前节点所有的属性集合中选出一个左右属性进行划分;而在RF中,对基决策树的每个节点,先从该节点的属性集合中随机选择一个包含k个属性的子集,然后再从这个子集中选择一个最优属性用于划分。这里的参数k控制了随机性的引入程度。如果k=d(全部属性集),则基决策树的构建=传统决策树构建。如果k=1,基决策树每个节点随机选择一个属性进行划分。一般推荐k=log2d。

    4.AdaBoost VS Bagging:AdaBoost只适用于二分类任务,Bagging适用于多分类、回归等任务。
    5.Bagging VS 随机森林:Bagging中基学习器的“多样性”通过样本扰动(对初始训练集采样)而获得;随机森林中基学习器的“多样性”不仅来自于样本扰动,而且还可以通过随机属性扰动来获得。这使得随机森立的泛化性能可通过个体学习器之间差异程度的增加而进一步提升。随机森林的使其性能很差,但随着学习器的增加,性能很快就会变好,且强于Bagging。

    回归树:

    回归树的算法:
    1. 回归树的生成:基于训练数据集生成决策树,尽量大点。 
    2. 回归树剪枝:用验证数据集对已生成的树进行剪枝并选择最优子树,这时用损失函数最小作为剪枝的标准。 

    回归是为了处理预测值是连续分布的情景,其返回值应该是一个具体预测值。回归树的叶子是一个个具体的值,从预测值连续这个意义上严格来说,回归树不能称之为“回归算法”。因为回归树返回的是“一团”数据的均值,而不是具体的、连续的预测值(即训练数据的标签值虽然是连续的,但回归树的预测值却只能是离散的).

    随机森林概念:

        森林的一个通俗解释就是:由一组决策树构建的复合分类器,它的特点是每个决策树在样本域里使用随机的特征属性进行分类划分。最后分类时投票每棵分类树的结论取最高票为最终分类结论。

    随机森林预测代码:

    import numpy as np
    from numpy import *
    from sklearn.tree import DecisionTreeRegressor
    import matplotlib.pyplot as plt
    from sklearn.ensemble import RandomForestRegressor
    from sklearn.model_selection import cross_val_score, ShuffleSplit
    import pandas as pd
    
    origin_data = pd.read_excel(r"C:\Users\***\Desktop\31天测试数据.xlsx")
    data_frame=origin_data
    
    rf=RandomForestRegressor()
    rf.fit(data_frame.ix[0:49,0:29],data_frame.ix[:,29:30])
    res=rf.predict(data_frame.ix[:,1:30])
    
    #计算平均误差构造矩阵
    minus=array(res)-array(origin_data[[30]])
    mape=mean(abs(minus))/mean(array(origin_data[[30]]))
    #作图图
    plt1=plt.plot(range(0,48),res,'r',label='predict data mape={0:0.2f}%'.format(mape*100))
    plt2=plt.plot(range(0,48),origin_data[[30]],'b',label='real data')
    plt.xlabel("dimension(total 48 dimensions)")
    plt.ylabel("value")
    plt.legend(loc="lower right")
    plt.show()

    展开全文
  • 随机森林回归python实现

    千次阅读 2019-10-25 18:38:34
    随机回归森林是由多个完全独立的回归决策树voting完成的,单个决策树的训练采用的是bagging,是集成学习中比较经典,效果较好的方法,可以作为baseline. from sklearn.datasets import load_iris import numpy as ...

    随机回归森林是由多个完全独立的回归决策树voting完成的,单个决策树的训练采用的是bagging,是集成学习中比较经典,效果较好的方法,可以作为baseline.

    from sklearn.datasets import load_iris
    import numpy as np
    
    class DecisionTree:
        feature_names = None
        
        def __init__(self):
            pass
        
        #选择每一特征的划分阈值
        def featureChosen(self, X_train, y_train):
            #遍历一列(特征)
            threshold_list = []
            threshold_var_list = []
            for i in range(X_train.shape[1]):
                #取出第i列的所有数值,去除重复项,并递增排序
                col_values = X_train[:, i]
                col_values_uni = list(set(X_train[:, i]))
                col_values_uni.sort()
                
                #遍历第i列中所有不重复的值,依次使其为阈值,用于划分连续的数值,选择方差最小的数值划分
                min_var = np.inf
                min_threshold = 0
                for k in col_values_uni:
                    D1_index = np.where(col_values < k) #获取第i个特征中,数值小于k的样本索引
                    D1_y = y_train[D1_index]
                    D2_index = np.where(col_values >= k) #获取第i个特征中,数值大于等于k的样本索引
                    D2_y = y_train[D2_index]
                    
                    #计算划分后的数据集的方差,并加权平均
                    D1_variance = np.var(D1_y)
                    D2_variance = np.var(D2_y)
                    splited_var = D1_variance * len(D1_y)/(len(D1_y)+len(D2_y)) \
                                 + D2_variance * len(D2_y)/(len(D1_y)+len(D2_y))
                                 
                    #记录最小方差和对应的划分阈值
                    if splited_var < min_var:
                        min_var = splited_var
                        min_threshold = k
                threshold_list.append(min_threshold)
                threshold_var_list.append(min_var)
            
            #计算 最优特征、划分该特征的最优阈值、划分前样本方差、划分后样本最小方差
            best_feature_index = threshold_var_list.index(min(threshold_var_list))
            best_threshold = threshold_list[best_feature_index]
            before_var = np.var(y_train)
            min_splited_var = min(threshold_var_list)
                
            #print('最优特征:', best_feature_index)
            #print('划分该特征的最优阈值:', best_threshold)
            #print('划分前样本方差:', before_var)
            #print('划分后样本最小方差:', min_splited_var)    
            return best_feature_index, best_threshold # 返回最优特征索引和最优特征的划分阈值
        
        # 根据 最优特征索引和最优特征的划分阈值 对数据集进行切分,分成两份
        def splitData(self, X_train, y_train, best_feature_index, best_threshold):
            #获取第i个特征中,数值小于k的样本索引
            D1_index = np.where(X_train[:, best_feature_index] < best_threshold)
            D1_X = X_train[D1_index]
            D1_y = y_train[D1_index]
            
            #获取第i个特征中,数值大于等于k的样本索引
            D2_index = np.where(X_train[:, best_feature_index] >= best_threshold)
            D2_X = X_train[D2_index]
            D2_y = y_train[D2_index]
            
            #删除划分后数据集的最优特征
            new_D1_X = np.array([])
            for j in range(D1_X.shape[1]):
                if j != best_feature_index:
                    new_D1_X = np.hstack((new_D1_X, D1_X[:, j]))
            new_D1_X = new_D1_X.reshape(D1_X.shape[0], D1_X.shape[1]-1)
            
            new_D2_X = np.array([])
            for j in range(D2_X.shape[1]):
                if j != best_feature_index:
                    new_D2_X = np.hstack((new_D2_X, D2_X[:, j]))
            new_D2_X = new_D2_X.reshape(D2_X.shape[0], D2_X.shape[1]-1)
            
            #删除划分后数据集的最优特征名
            self.feature_names = self.feature_names[0:best_feature_index] + self.feature_names[best_feature_index+1:]
            
            return new_D1_X, D1_y, new_D2_X, D2_y #返回划分后的数据集和特征名
                    
        #决策树建立
        def createDT(self, X_train, y_train):
            #样本标签全部相同则返回
            if len(set(y_train)) == 1:
                return np.mean(y_train)
            
            #样本特征划分完了则返回
            if len(self.feature_names) == 0:
                return np.mean(y_train)
            
            #首先选择最优的特征和划分阈值
            best_feature_index, best_threshold = self.featureChosen(X_train, y_train)
            best_feature_name = self.feature_names[best_feature_index]
            
            #对当前数据集按最优特征和划分阈值进行切分
            new_D1_X, D1_y, new_D2_X, D2_y = self.splitData(X_train, y_train, 
                                                            best_feature_index,
                                                            best_threshold)
            
            #以字典的形式存储决策树,左孩子表示比当前阈值小,右孩子则大于等于当前阈值
            DT_dict = {}
            DT_dict[best_feature_name] = {
                'best_threshold' : best_threshold,
                'lchild' : self.createDT(new_D1_X, D1_y),
                'rchild' : self.createDT(new_D2_X, D2_y),
            }
            
            return DT_dict
        
        #回归预测
        def predict(self, DT_dict, X_test, feature_names):
            #获取当前遍历的节点特征名和特征划分阈值
            best_feature_name = list(DT_dict.keys())[0]
            best_threshold = DT_dict[best_feature_name]['best_threshold']
            
            #判断测试数据在当前特征下的值是否小于划分阈值
            if X_test[feature_names.index(best_feature_name)] < best_threshold:
                #获取当前节点的左孩子
                lchild = DT_dict[best_feature_name]['lchild']
                
                #判断左孩子是否是叶子节点,非叶子节点则是字典类型,就继续遍历
                if not isinstance(lchild, dict):
                    return lchild #直接返回叶子节点值
                else:
                    return self.predict(lchild, X_test, feature_names)
                
            #判断测试数据在当前特征下的值是否大于等于划分阈值
            else:
                rchild = DT_dict[best_feature_name]['rchild']
                if not isinstance(rchild, dict):
                    return rchild
                else:
                    return self.predict(rchild, X_test, feature_names)
        
        #误差函数
        def lossFun(self, y_test, y_pred):
            return np.mean((y_test - y_pred)**2)
                
            
        
    class RandomForest:
        forest = [] #元素是每个独立的决策树
        DT_num = None #决策树个数
        test_rate = None #测试样本比例
        X_train = None #训练集
        y_train = None #训练集标签
        
        def __init__(self, DT_num, test_rate, X_train, y_train):
            self.DT_num = DT_num
            self.test_rate = test_rate
            self.X_train = X_train
            self.y_train = y_train
            
        def bagging(self):
            p = np.random.permutation(range(self.X_train.shape[0])) #打乱样本顺序
            test_split = int(self.X_train.shape[0] * self.test_rate) #设置数据集的划分索引值
            
            X_train_new, y_train_new = self.X_train[p[test_split:]], self.y_train[p[test_split:]]
            X_test_new, y_test_new = self.X_train[p[0:test_split]], self.y_train[p[0:test_split]]
            
            #自定义特征名
            feature_names = ['a'+str(i) for i in range(self.X_train.shape[1])]
            
            return X_train_new, y_train_new, X_test_new, y_test_new, feature_names
        
        def createForest(self):
            for _ in range(self.DT_num):
                self.forest.append(DecisionTree())
                
        def voting(self):
            # 遍历森林中每一个决策树
            for dt in self.forest:
                # bagging
                X_train, y_train, X_test, y_test, dt.feature_names = self.bagging()
                
                # 训练决策树
                DT_dict = dt.createDT(X_train, y_train)
                print(DT_dict)
                
            #y_pred_list保存voting后的回归结果
            y_pred_list = []
            
            #对每个测试样本
            for i in range(len(y_test)):
                y_pred = []
                
                #每个决策树进行回归预测
                for dt in self.forest:
                    feature_names = ['a'+str(i) for i in range(self.X_train.shape[1])]
                    y_pred.append(dt.predict(DT_dict, X_test[i], feature_names))
                    
                #计算所有决策树计算结果的平均值(voting)
                y_pred_list.append(np.mean(y_pred))
            print('每个决策树的预测结果:', y_pred_list)
            
            #计算总测试误差
            total_loss = dt.lossFun(y_test, y_pred_list)
            print('总误差:', total_loss)
        
    if __name__ == '__main__':
        iris = load_iris()
        
        my_RF = RandomForest(10, 0.3, iris['data'], iris['target'])
        my_RF.createForest()
        my_RF.voting()
    
    展开全文
  • 本文件包括随机森林的代码实现和相应的数据集,以及详尽的中文注释,已调试通过。代码有两份,一份是在网上下载的,另一份是自己整理后编写的。编程环境为Python2.7。因为只是用来学习随机森林算法,所以在调参方法...
  • 随机森林 kaggle 数据挖掘 categories: 数据挖掘 mathjax: true 文章目录前言:1 数据预处理1.1 读入数据1.2 训练集与数据集1.2.1 查看数据完整性1.2.2 查看训练数据描述信息1.3.1 年龄数据简化分组2 数据可视化2.1...
  • 随机森林python版)

    千次阅读 多人点赞 2017-08-21 11:22:44
    随机森林 随机森林使用背景 1 随机森林定义 2 随机森林优点 3 随机森林应用范围 随机森林方法理论介绍 ...5预测结果随机森林1. 随机森林使用背景1.1 随机森林定义随机森林是一种比较新的机器学习模型。经典
  • 回归树和随机森林Python 实现。 参见 Breiman 等人的“分类和回归树”。 (1984)。 Regression_tree_cart.py 模块包含在给定一些训练数据的情况下增长和使用回归树的函数。 Football_parserf.py 是regression_...
  • 使用随机森林回归数据,给出数据的重要性和预测
  • 随机森林随机回归预测Why do we try to predict happiness? Being able to predict happiness means that we are able to manipulate or try to improve certain components in order to increase our own happiness...
  • 一个分类器的分类准确率在60%-80%,即:比随机预测略好,但准确率却不太高,我们可以称之为“弱分类器”,比如CART(classificationandregressiontree分类与回归树)。反之,如果分类精度90%以上,则是强分类器。...
  • 示例说明这个博客深入到决策树和随机森林的基础上,以便更好地解释它们。 在过去的几年中,随机森林是一种新兴的机器学习技术。它是一种基于非线性树的模型,可以提供精确的结果。然而,大多是黑箱,通常很难解释...
  • 随机森林python上的实现

    千次阅读 2018-09-30 16:14:05
    ",metrics.recall_score(y,y_pred)) print("F测度:",metrics.f1_score(y, y_pred)) joblib.dump(rf0, "rfTrainModel.m")#保存模型 预测阶段 import pandas as pd from sklearn.externals import joblib x= pd.read_...
  • 随机森林 python

    千次阅读 2017-01-10 10:40:15
    都可以首先随机森林来进行预测,同时得到的结果也不会太差。在这篇文章里我首先会向大家推荐几篇写的比较好的博客。接着会将我觉得比较好的例子使用python+scikit-learn包来实现出来。 首先推荐的就是:随机
  • 本文是Python商业数据挖掘实战的第3篇1 - 基于不平衡数据的反欺诈模型实战2 - Apriori算法实现智能推荐3- 随机森林预测宽带客户离网前言 组合算法也叫集成学习,在金融行...
  • 随机森林random forest及python实现

    万次阅读 多人点赞 2017-12-18 15:20:51
    引言想通过随机森林来获取数据的主要特征1、理论 根据个体学习器的生成方式,目前的集成学习方法大致可分为两大类,即个体学习器之间存在强依赖关系,必须串行生成的序列化方法,以及个体学习器间不存在强依赖关系...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,948
精华内容 5,579
关键字:

随机森林预测python

python 订阅