精华内容
下载资源
问答
  • Stacking (Stacked generalization) 1.概念 指训练一个模型用于组合(combine)其他各个模型。即首先我们先训练多个不同的模型,然后再以之前训练的各个模型的输出为输入来训练一个模型,以得到一个最终的输出。...

    Stacking (Stacked generalization)

    1.概念

    指训练一个模型用于组合(combine)其他各个模型。即首先我们先训练多个不同的模型,然后再以之前训练的各个模型的输出为输入来训练一个模型,以得到一个最终的输出。

    理论上,Stacking可以表示上面提到的各种Ensemble方法。然而,实际中,我们通常使用单层logistic回归作为组合模型。

    先在整个训练数据集上通过bootstrapped抽样得到各个训练集合,得到一系列分类模型,称之为Tier 1分类器, 然后将输出用于训练Tier 2 分类器

    潜在的一个思想是希望训练数据都得被正确的学习到了

    比如某个分类器错误的学习到了特征空间里某个特定区域,因此错误分类就会来自这个区域,但是Tier 2分类器可能根据其他的分类器学习到正确的分类。交叉验证也通常用于训练Tier 1分类器:把这个训练集合分成T个块,Tier 1中的每个分类器根据各自余下的T-1块进行训练,并在T块(该块数据并未用于训练)上测试。之后将这些分类器的输出作为输入,在整个训练集合上训练Tier 2分类器。(这里未提及测试集,测试集是指不在任何训练过程中出现的数据)。

    这里写图片描述

    Stacking 方法比任何单一模型的效果都要好,而且不仅成功应用在了监督式学习中,也成功应用在了非监督式(概率密度估计)学习中。甚至应用于估计bagging模型的错误率

    2.kaggle,Titanic中的Stacking应用:

    数据的行数:train.csv有890行,也就是890个人,test.csv有418行(418个人)。

    而数据的列数就看你保留了多少个feature了。

    这里写图片描述

    STEP1:

    Train Data有890行。(请对应图中的上层部分)每1次的fold,都会生成 713行 小train, 178行 小test。我们用Model 1来训练 713行的小train,然后预测 178行 小test。预测的结果是长度为 178 的预测值。这样的动作走5次! 长度为178 的预测值 X 5 = 890 预测值,刚好和Train data长度吻合。这个890预测值是Model 1产生的,我们先存着,因为,一会让它将是第二层模型的训练来源。

    这一步产生的预测值我们可以转成 890 X 1 (890 行,1列),记作 P1 (大写P)

    STEP2:

    接着说 Test Data 有 418 行。(请对应图中的下层部分,对对对,绿绿的那些框框)每1次的fold,713行 小train训练出来的Model 1要去预测我们全部的Test Data(全部!因为Test Data没有加入5-fold,所以每次都是全部!)。此时,Model 1的预测结果是长度为418的预测值。这样的动作走5次!我们可以得到一个 5 X 418 的预测值矩阵。然后我们根据行来就平均值,最后得到一个 1 X 418 的平均预测值。

    这一步产生的预测值我们可以转成 418 X 1 (418行,1列),记作 p1 (小写p)

    这是第一层的model1,假设你第一层有3个模型,这样你就会得到:来自5-fold的预测值矩阵 890 X 3,(P1,P2, P3) 和 来自Test Data预测值矩阵 418 X 3, (p1, p2, p3)。

    STEP3:

    第二层:来自5-fold的预测值矩阵 890 X 3 作为你的Train Data,训练第二层的模型

    来自Test Data预测值矩阵 418 X 3 就是你的Test Data,用训练好的模型来预测他们吧

    代码:

    这里写图片描述

    展开全文
  • 【翻译自 : Stacking ... Stacking或Stacked Generalization是一种集成的机器学习算法。 它使用元学习算法来学习如何最佳地组合来自两个或多个基础机器学习算法的预测。 堆叠的好处在于,它可以利用分类或回...

          【翻译自 : Stacking Ensemble Machine Learning With Python

          【说明:Jason Brownlee PhD大神的文章个人很喜欢,所以闲暇时间里会做一点翻译和学习实践的工作,这里是相应工作的实践记录,希望能帮到有需要的人!】

          Stacking或Stacked Generalization是一种集成的机器学习算法。 它使用元学习算法来学习如何最佳地组合来自两个或多个基础机器学习算法的预测。 堆叠的好处在于,它可以利用分类或回归任务上一系列性能良好的模型的功能,并做出比集合中的任何单个模型都有更好性能的预测。

          在本教程中,您将发现堆叠的泛型集成或Python中的堆叠。 完成本教程后,您将知道:

    堆叠是一种集成的机器学习算法,可学习如何最佳地组合来自多个性能良好的机器学习模型的预测。 
    
    scikit-learn库提供了Python中堆栈集成的标准实现。
    
    如何使用堆叠集成进行回归和分类预测建模。 

    教程概述

          本教程分为四个部分。 他们是:

    堆叠概括
    堆叠Scikit-Learn API
    堆叠分类
    堆叠回归

    堆叠概括

          堆叠通用化或简称“堆叠”是一种集成的机器学习算法。它涉及在同一数据集上组合来自多个机器学习模型的预测,例如装袋和提升。堆叠解决了这个问题:给定多个熟练解决问题的机器学习模型,但是以不同的方式,您如何选择要使用的模型(信任)?解决此问题的方法是使用另一个机器学习模型,该模型学习何时使用或信任集合中的每个模型。

    与Bagging不同,在堆叠中,模型通常是不同的(例如,并非所有决策树)并且适合于同一数据集(例如,而不是训练数据集的样本)。
    与Boosting不同,在堆叠中,使用单个模型来学习如何最佳地组合来自贡献模型的预测(例如,而不是校正先前模型的预测的一系列模型)。

            堆栈模型的体系结构涉及两个或多个基本模型(通常称为0级模型)和一个将基本模型的预测结合在一起的元模型(称为1级模型)。

    0级模型(基本模型):模型适合训练数据,并会编译其预测。
    1级模型(元模型):学习如何最好地组合基础模型的预测的模型。

          元模型是根据基本模型对样本外数据所做的预测进行训练的。也就是说,将不用于训练基本模型的数据馈送到基本模型,进行预测,并且这些预测与预期输出一起提供用于拟合元模型的训练数据集的输入和输出对。来自基本模型的输出(用作元模型的输入)在回归的情况下可以是真实值,而在概率分类的情况下,概率值,类似概率的值或类别标签可以是真实值。为元模型准备训练数据集的最常见方法是通过基本模型的k折交叉验证,其中不合时宜的预测用作元模型训练数据集的基础。
           元模型的训练数据还可以包括基本模型的输入,例如基本模型的输入。训练数据的输入元素。这可以向元模型提供关于如何最佳地组合来自元模型的预测的附加上下文。一旦为元模型准备了训练数据集,就可以在该数据集上单独训练元模型,并且可以在整个原始训练数据集上训练基本模型。
           当多个不同的机器学习模型在数据集上具有技能但以不同的方式具有技能时,堆叠是合适的。另一种说法是,模型做出的预测或模型做出的预测中的误差不相关或具有较低的相关性。基本模型通常是复杂而多样的。因此,通常最好使用一系列关于如何解决预测建模任务的不同假设的模型,例如线性模型,决策树,支持向量机,神经网络等。其他集成算法也可以用作基本模型,例如随机森林。基本模型:使用各种模型,这些模型对预测任务有不同的假设。元模型通常很简单,可以对基本模型做出的预测进行平滑的解释。这样,线性模型通常用作元模型,例如用于回归任务的线性回归(预测数值)和用于分类任务的逻辑回归(预测类标签)。尽管这很普遍,但这不是必需的。

    回归元模型:线性回归。
    分类元模型:逻辑回归。

          使用简单的线性模型作为元模型通常会堆叠口语名称“ blending”。与预测中一样,是基础模型所做的预测的加权平均或混合。超级学习者可以被认为是一种特殊的堆叠方式。堆栈旨在提高建模性能,尽管不能保证在所有情况下都能改进。实现性能上的改进取决于问题的复杂性,以及培训数据是否足够好地表示问题以及是否足够复杂,以至于可以通过组合预测来学习更多。它还取决于基本模型的选择以及它们在预测(或错误)方面是否足够熟练和足够不相关。如果基本模型的性能优于或优于堆叠集成,则应使用基本模型,因为它的复杂度较低(例如,描述,训练和维护更简单)。

    堆叠Scikit-Learn API

         堆叠可以从头开始实现,尽管这对初学者可能具有挑战性。有关在Python中从头开始实现堆栈的示例,请参见教程:

                                                                                                          如何从头开始使用Python实现堆栈泛化(Stacking
            有关从头开始实现堆栈以进行深度学习的示例,请参见教程:

                                                                                                        如何使用Python开发深度学习神经网络的堆栈集成
           scikit-learn Python机器学习库提供了用于机器学习的堆栈实现。它在库的0.22版和更高版本中可用。首先,通过运行以下脚本来确认您正在使用现代版本的库:

    # check scikit-learn version
    import sklearn
    print(sklearn.__version__)

             运行脚本将打印您的scikit-learn版本。 您的版本应该相同或更高。 如果不是,则必须升级scikit-learn库的版本。

    0.22.1

             堆栈是通过StackingRegressor和StackingClassifier类提供的。 两种模型以相同的方式操作并采用相同的参数。 使用模型要求您指定一个估算器列表(0级模型)和一个最终估算器(1级或元模型)。 级别0模型或基本模型的列表通过“ estimators”参数提供。 这是一个Python列表,其中列表中的每个元素都是一个具有模型名称和配置的模型实例的元组。 例如,下面定义了两个0级模型:

    models = [('lr',LogisticRegression()),('svm',SVC())
    stacking = StackingClassifier(estimators=models)

           列表中的每个模型也可以是管道,包括在将模型拟合到训练数据集之前模型所需的任何数据准备。 例如:

    models = [('lr',LogisticRegression()),('svm',make_pipeline(StandardScaler(),SVC()))
    stacking = StackingClassifier(estimators=models)

            通过“ final_estimator”参数提供1级模型或元模型。 默认情况下,将其设置为用于回归的LinearRegression和用于分类的LogisticRegression,并且这些是您可能不希望更改的明智的默认值。 使用交叉验证准备元模型的数据集。 默认情况下,使用5折交叉验证,尽管可以通过“ cv”自变量进行更改,并将其设置为数字(例如10折交叉验证为10)或交叉验证对象(例如StratifiedKFold) 。 有时,如果为元模型准备的数据集还包含0级模型的输入(例如, 输入的训练数据。 这可以通过将“ passthrough”参数设置为True来实现,并且默认情况下未启用。 现在,我们已经熟悉了scikit-learn中的stacking API,下面让我们来看一些可行的示例。

    堆叠分类

          在本节中,我们将研究使用堆叠解决分类问题。 首先,我们可以使用make_classification()函数创建具有1,000个示例和20个输入功能的综合二进制分类问题。 下面列出了完整的示例。

    # test classification dataset
    from sklearn.datasets import make_classification
    # define dataset
    X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
    # summarize the dataset
    print(X.shape, y.shape)

           运行示例将创建数据集并总结输入和输出组件的形状。

    (1000, 20) (1000,)

          接下来,我们可以在数据集上评估一套不同的机器学习模型。

          具体来说,我们将评估以下五种算法:

    逻辑回归。
    k最近邻居。
    决策树。
    支持向量机。
    天真贝叶斯。

           每种算法将使用默认模型超参数进行评估。 下面的函数get_models()创建我们要评估的模型。

    # get a list of models to evaluate
    def get_models():
    	models = dict()
    	models['lr'] = LogisticRegression()
    	models['knn'] = KNeighborsClassifier()
    	models['cart'] = DecisionTreeClassifier()
    	models['svm'] = SVC()
    	models['bayes'] = GaussianNB()
    	return models

          每个模型将使用重复的k倍交叉验证进行评估。 下面的valuate_model()函数采用一个模型实例,并从分层的10倍交叉验证的三个重复中返回分数列表。

    # evaluate a given model using cross-validation
    def evaluate_model(model, X, y):
    	cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
    	scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
    	return scores

           然后,我们可以报告每种算法的平均性能,还可以创建箱形图和晶须图,以比较每种算法的准确性得分的分布。 结合在一起,下面列出了完整的示例。

    # compare standalone models for binary classification
    from numpy import mean
    from numpy import std
    from sklearn.datasets import make_classification
    from sklearn.model_selection import cross_val_score
    from sklearn.model_selection import RepeatedStratifiedKFold
    from sklearn.linear_model import LogisticRegression
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.svm import SVC
    from sklearn.naive_bayes import GaussianNB
    from matplotlib import pyplot
    
    # get the dataset
    def get_dataset():
    	X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
    	return X, y
    
    # get a list of models to evaluate
    def get_models():
    	models = dict()
    	models['lr'] = LogisticRegression()
    	models['knn'] = KNeighborsClassifier()
    	models['cart'] = DecisionTreeClassifier()
    	models['svm'] = SVC()
    	models['bayes'] = GaussianNB()
    	return models
    
    # evaluate a given model using cross-validation
    def evaluate_model(model, X, y):
    	cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
    	scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
    	return scores
    
    # define dataset
    X, y = get_dataset()
    # get the models to evaluate
    models = get_models()
    # evaluate the models and store results
    results, names = list(), list()
    for name, model in models.items():
    	scores = evaluate_model(model, X, y)
    	results.append(scores)
    	names.append(name)
    	print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
    # plot model performance for comparison
    pyplot.boxplot(results, labels=names, showmeans=True)
    pyplot.show()

          首先运行示例将报告每个模型的均值和标准差准确性。 注意:由于算法或评估程序的随机性,或者数值精度的差异,您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。 我们可以看到,在这种情况下,SVM以约95.7%的平均准确度表现最佳。

    >lr 0.866 (0.029)
    >knn 0.931 (0.025)
    >cart 0.821 (0.050)
    >svm 0.957 (0.020)
    >bayes 0.833 (0.031)

         首先运行示例将报告每个模型的均值和标准差准确性。 注意:由于算法或评估程序的随机性,或者数值精度的差异,您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。 我们可以看到,在这种情况下,SVM以约95.7%的平均准确度表现最佳。

           在这里,我们有五种不同的算法运行良好,大概在此数据集上的表现方式不同。 接下来,我们可以尝试使用堆栈将这五个模型合并为一个整体模型。 我们可以使用逻辑回归模型来学习如何最好地结合来自五个单独模型的预测。 下面的get_stacking()函数通过首先为五个基本模型定义一个元组列表,然后定义逻辑回归元模型以使用5倍交叉验证组合来自基本模型的预测来定义StackingClassifier模型。

    # get a stacking ensemble of models
    def get_stacking():
    	# define the base models
    	level0 = list()
    	level0.append(('lr', LogisticRegression()))
    	level0.append(('knn', KNeighborsClassifier()))
    	level0.append(('cart', DecisionTreeClassifier()))
    	level0.append(('svm', SVC()))
    	level0.append(('bayes', GaussianNB()))
    	# define meta learner model
    	level1 = LogisticRegression()
    	# define the stacking ensemble
    	model = StackingClassifier(estimators=level0, final_estimator=level1, cv=5)
    	return model

            我们可以将堆栈集成与独立模型一起包括在要评估的模型列表中。

    # get a list of models to evaluate
    def get_models():
    	models = dict()
    	models['lr'] = LogisticRegression()
    	models['knn'] = KNeighborsClassifier()
    	models['cart'] = DecisionTreeClassifier()
    	models['svm'] = SVC()
    	models['bayes'] = GaussianNB()
    	models['stacking'] = get_stacking()
    	return models

           我们的期望是,堆叠集成的性能将优于任何单个基本模型。 并非总是如此,如果不是这种情况,则应使用基础模型,以支持集成模型。 下面列出了评估堆叠集成模型和独立模型的完整示例。

    # compare ensemble to each baseline classifier
    from numpy import mean
    from numpy import std
    from sklearn.datasets import make_classification
    from sklearn.model_selection import cross_val_score
    from sklearn.model_selection import RepeatedStratifiedKFold
    from sklearn.linear_model import LogisticRegression
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.svm import SVC
    from sklearn.naive_bayes import GaussianNB
    from sklearn.ensemble import StackingClassifier
    from matplotlib import pyplot
    
    # get the dataset
    def get_dataset():
    	X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
    	return X, y
    
    # get a stacking ensemble of models
    def get_stacking():
    	# define the base models
    	level0 = list()
    	level0.append(('lr', LogisticRegression()))
    	level0.append(('knn', KNeighborsClassifier()))
    	level0.append(('cart', DecisionTreeClassifier()))
    	level0.append(('svm', SVC()))
    	level0.append(('bayes', GaussianNB()))
    	# define meta learner model
    	level1 = LogisticRegression()
    	# define the stacking ensemble
    	model = StackingClassifier(estimators=level0, final_estimator=level1, cv=5)
    	return model
    
    # get a list of models to evaluate
    def get_models():
    	models = dict()
    	models['lr'] = LogisticRegression()
    	models['knn'] = KNeighborsClassifier()
    	models['cart'] = DecisionTreeClassifier()
    	models['svm'] = SVC()
    	models['bayes'] = GaussianNB()
    	models['stacking'] = get_stacking()
    	return models
    
    # evaluate a give model using cross-validation
    def evaluate_model(model, X, y):
    	cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
    	scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
    	return scores
    
    # define dataset
    X, y = get_dataset()
    # get the models to evaluate
    models = get_models()
    # evaluate the models and store results
    results, names = list(), list()
    for name, model in models.items():
    	scores = evaluate_model(model, X, y)
    	results.append(scores)
    	names.append(name)
    	print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
    # plot model performance for comparison
    pyplot.boxplot(results, labels=names, showmeans=True)
    pyplot.show()

          首先运行示例将报告每个模型的性能。 这包括每个基本模型的性能,然后是堆叠合奏。

          注意:由于算法或评估程序的随机性,或者数值精度的差异,您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。 在这种情况下,我们可以看到堆叠集成的平均性能似乎比任何单个模型都要好,达到了约96.4%的精度。

    >lr 0.866 (0.029)
    >knn 0.931 (0.025)
    >cart 0.820 (0.044)
    >svm 0.957 (0.020)
    >bayes 0.833 (0.031)
    >stacking 0.964 (0.019)

           将创建一个箱形图,以显示模型分类精度的分布。 在这里,我们可以看到堆叠模型的均值和中值准确性比SVM模型要高一些。

           如果我们选择堆叠集成作为最终模型,则可以像其他任何模型一样拟合并使用它对新数据进行预测。 首先,将堆栈集合适合所有可用数据,然后可以调用predict()函数对新数据进行预测。 下面的示例在我们的二进制分类数据集中展示了这一点。

    # make a prediction with a stacking ensemble
    from sklearn.datasets import make_classification
    from sklearn.ensemble import StackingClassifier
    from sklearn.linear_model import LogisticRegression
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.svm import SVC
    from sklearn.naive_bayes import GaussianNB
    # define dataset
    X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
    # define the base models
    level0 = list()
    level0.append(('lr', LogisticRegression()))
    level0.append(('knn', KNeighborsClassifier()))
    level0.append(('cart', DecisionTreeClassifier()))
    level0.append(('svm', SVC()))
    level0.append(('bayes', GaussianNB()))
    # define meta learner model
    level1 = LogisticRegression()
    # define the stacking ensemble
    model = StackingClassifier(estimators=level0, final_estimator=level1, cv=5)
    # fit the model on all available data
    model.fit(X, y)
    # make a prediction for one example
    data = [[2.47475454,0.40165523,1.68081787,2.88940715,0.91704519,-3.07950644,4.39961206,0.72464273,-4.86563631,-6.06338084,-1.22209949,-0.4699618,1.01222748,-0.6899355,-0.53000581,6.86966784,-3.27211075,-6.59044146,-2.21290585,-3.139579]]
    yhat = model.predict(data)
    print('Predicted Class: %d' % (yhat))

             运行示例适合整个数据集上的堆叠集成模型,然后像在应用程序中使用模型一样,将其用于对新数据行进行预测。

    Predicted Class: 0

    堆叠回归

          在本节中,我们将研究如何使用堆叠来解决回归问题。 首先,我们可以使用make_regression()函数创建具有1000个示例和20个输入要素的综合回归问题。 下面列出了完整的示例。

    # test regression dataset
    from sklearn.datasets import make_regression
    # define dataset
    X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=1)
    # summarize the dataset
    print(X.shape, y.shape)

          运行示例将创建数据集并总结输入和输出组件的形状。

    (1000, 20) (1000,)

          接下来,我们可以在数据集上评估一套不同的机器学习模型。

         具体来说,我们将评估以下三种算法:

    k近邻
    决策树
    支持向量回归

           注意:可以使用线性回归模型对测试数据集进行简单求解,因为该数据集是在封面下使用线性模型创建的。 因此,我们将把该模型放在示例之外,以便我们可以证明堆叠集成方法的好处。

          每种算法将使用默认的模型超参数进行评估。 下面的函数get_models()创建我们要评估的模型。

    # get a list of models to evaluate
    def get_models():
    	models = dict()
    	models['knn'] = KNeighborsRegressor()
    	models['cart'] = DecisionTreeRegressor()
    	models['svm'] = SVR()
    	return models

              每个模型将使用重复的k倍交叉验证进行评估。 下面的valuate_model()函数采用一个模型实例,并从三个重复的10倍交叉验证中返回分数列表。

    # evaluate a given model using cross-validation
    def evaluate_model(model, X, y):
    	cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
    	scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
    	return scores

            然后,我们可以报告每种算法的平均性能,还可以创建箱形图和晶须图,以比较每种算法的准确性得分的分布。 在这种情况下,将使用平均绝对误差(MAE)报告模型性能。 scikit-learn库会将此错误的符号反转以使其最大化,从-infinity到0以获取最佳分数。 结合在一起,下面列出了完整的示例。

    # compare machine learning models for regression
    from numpy import mean
    from numpy import std
    from sklearn.datasets import make_regression
    from sklearn.model_selection import cross_val_score
    from sklearn.model_selection import RepeatedKFold
    from sklearn.linear_model import LinearRegression
    from sklearn.neighbors import KNeighborsRegressor
    from sklearn.tree import DecisionTreeRegressor
    from sklearn.svm import SVR
    from matplotlib import pyplot
    
    # get the dataset
    def get_dataset():
    	X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=1)
    	return X, y
    
    # get a list of models to evaluate
    def get_models():
    	models = dict()
    	models['knn'] = KNeighborsRegressor()
    	models['cart'] = DecisionTreeRegressor()
    	models['svm'] = SVR()
    	return models
    
    # evaluate a given model using cross-validation
    def evaluate_model(model, X, y):
    	cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
    	scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
    	return scores
    
    # define dataset
    X, y = get_dataset()
    # get the models to evaluate
    models = get_models()
    # evaluate the models and store results
    results, names = list(), list()
    for name, model in models.items():
    	scores = evaluate_model(model, X, y)
    	results.append(scores)
    	names.append(name)
    	print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
    # plot model performance for comparison
    pyplot.boxplot(results, labels=names, showmeans=True)
    pyplot.show()

           首先运行示例,报告每个模型的均值和标准差MAE。 注意:由于算法或评估程序的随机性,或者数值精度的差异,您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。 我们可以看到,在这种情况下,KNN的最佳表现为平均负MAE约为-100。

    >knn -101.019 (7.161)
    >cart -148.100 (11.039)
    >svm -162.419 (12.565)

           然后创建箱须图,比较每个模型的分布负MAE得分。

          在这里,我们有三种不同的算法可以很好地运行,大概在此数据集上以不同的方式运行。

           接下来,我们可以尝试使用堆栈将这三个模型合并为一个整体模型。

           我们可以使用线性回归模型来学习如何最佳地组合来自三个模型的预测。

          下面的get_stacking()函数通过首先为三个基本模型定义一个元组列表,然后定义线性回归元模型以使用5倍交叉验证组合来自基本模型的预测来定义StackingRegressor模型。

    # get a stacking ensemble of models
    def get_stacking():
    	# define the base models
    	level0 = list()
    	level0.append(('knn', KNeighborsRegressor()))
    	level0.append(('cart', DecisionTreeRegressor()))
    	level0.append(('svm', SVR()))
    	# define meta learner model
    	level1 = LinearRegression()
    	# define the stacking ensemble
    	model = StackingRegressor(estimators=level0, final_estimator=level1, cv=5)
    	return model

           我们可以将堆栈集成与独立模型一起包括在要评估的模型列表中

    # get a list of models to evaluate
    def get_models():
    	models = dict()
    	models['knn'] = KNeighborsRegressor()
    	models['cart'] = DecisionTreeRegressor()
    	models['svm'] = SVR()
    	models['stacking'] = get_stacking()
    	return models

             我们的期望是,堆叠集成的性能将优于任何单个基本模型。 情况并非总是如此,如果不是这种情况,则应使用基础模型以支持集成模型。 下面列出了评估堆叠集成模型和独立模型的完整示例。

    # compare ensemble to each standalone models for regression
    from numpy import mean
    from numpy import std
    from sklearn.datasets import make_regression
    from sklearn.model_selection import cross_val_score
    from sklearn.model_selection import RepeatedKFold
    from sklearn.linear_model import LinearRegression
    from sklearn.neighbors import KNeighborsRegressor
    from sklearn.tree import DecisionTreeRegressor
    from sklearn.svm import SVR
    from sklearn.ensemble import StackingRegressor
    from matplotlib import pyplot
    
    # get the dataset
    def get_dataset():
    	X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=1)
    	return X, y
    
    # get a stacking ensemble of models
    def get_stacking():
    	# define the base models
    	level0 = list()
    	level0.append(('knn', KNeighborsRegressor()))
    	level0.append(('cart', DecisionTreeRegressor()))
    	level0.append(('svm', SVR()))
    	# define meta learner model
    	level1 = LinearRegression()
    	# define the stacking ensemble
    	model = StackingRegressor(estimators=level0, final_estimator=level1, cv=5)
    	return model
    
    # get a list of models to evaluate
    def get_models():
    	models = dict()
    	models['knn'] = KNeighborsRegressor()
    	models['cart'] = DecisionTreeRegressor()
    	models['svm'] = SVR()
    	models['stacking'] = get_stacking()
    	return models
    
    # evaluate a given model using cross-validation
    def evaluate_model(model, X, y):
    	cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
    	scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
    	return scores
    
    # define dataset
    X, y = get_dataset()
    # get the models to evaluate
    models = get_models()
    # evaluate the models and store results
    results, names = list(), list()
    for name, model in models.items():
    	scores = evaluate_model(model, X, y)
    	results.append(scores)
    	names.append(name)
    	print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
    # plot model performance for comparison
    pyplot.boxplot(results, labels=names, showmeans=True)
    pyplot.show()

           首先运行示例将报告每个模型的性能。 这包括每个基本模型的性能,然后是堆叠合奏。 注意:由于算法或评估程序的随机性,或者数值精度的差异,您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。 在这种情况下,我们可以看到堆叠集成的平均表现要好于任何单个模型,平均负MAE约为-56。

    >knn -101.019 (7.161)
    >cart -148.017 (10.635)
    >svm -162.419 (12.565)
    >stacking -56.893 (5.253)

          将创建一个箱形图,以显示模型错误分数的分布。 在这里,我们可以看到堆叠模型的平均得分和中位数得分远高于任何单个模型。

          如果我们选择堆叠集成作为最终模型,则可以像其他任何模型一样拟合并使用它对新数据进行预测。 首先,将堆栈集合适合所有可用数据,然后可以调用predict()函数对新数据进行预测。 下面的示例在我们的回归数据集中展示了这一点。

    # make a prediction with a stacking ensemble
    from sklearn.datasets import make_regression
    from sklearn.linear_model import LinearRegression
    from sklearn.neighbors import KNeighborsRegressor
    from sklearn.tree import DecisionTreeRegressor
    from sklearn.svm import SVR
    from sklearn.ensemble import StackingRegressor
    # define dataset
    X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=1)
    # define the base models
    level0 = list()
    level0.append(('knn', KNeighborsRegressor()))
    level0.append(('cart', DecisionTreeRegressor()))
    level0.append(('svm', SVR()))
    # define meta learner model
    level1 = LinearRegression()
    # define the stacking ensemble
    model = StackingRegressor(estimators=level0, final_estimator=level1, cv=5)
    # fit the model on all available data
    model.fit(X, y)
    # make a prediction for one example
    data = [[0.59332206,-0.56637507,1.34808718,-0.57054047,-0.72480487,1.05648449,0.77744852,0.07361796,0.88398267,2.02843157,1.01902732,0.11227799,0.94218853,0.26741783,0.91458143,-0.72759572,1.08842814,-0.61450942,-0.69387293,1.69169009]]
    yhat = model.predict(data)
    print('Predicted Value: %.3f' % (yhat))

           运行示例适合整个数据集上的堆叠集成模型,然后像在应用程序中使用模型一样,将其用于对新数据行进行预测。

    Predicted Value: 556.264

     

    相关教程

    如何使用Python从头开始实现堆栈泛化(Stacking)
    如何使用Keras开发Python深度学习神经网络的堆栈集成
    如何用Python开发超级学习者集成
    如何在机器学习中使用不合时宜的预测
    K折叠交叉验证的简要介绍

     

     

     

    展开全文
  • Stacked Hourglass Networks...pipeline ,一个典型的机器学习构建包含若干个过程 1、源数据ETL 2、数据预处理 3、特征选取 4、模型训练与验证 以上四个步骤可以抽象为一个包括多个步骤的流水线式工作,从数据收...

    Stacked Hourglass Networks for Human Pose Estimation的论文学习

    名词解析

    由于是第一次看相关论文,对自己不太熟悉的专用术语作一个记录:

    1. pipeline ,一个典型的机器学习构建包含若干个过程

      1、源数据ETL
      
      2、数据预处理
      
      3、特征选取
      
      4、模型训练与验证
      

      以上四个步骤可以抽象为一个包括多个步骤的流水线式工作,从数据收集开始至输出我们需要的最终结果。因此,对以上多个步骤、进行抽象建模,简化为流水线式工作流程则存在着可行性,对利用spark进行机器学习的用户来说,流水线式机器学习比单个步骤独立建模更加高效、易用。

      管道机制在机器学习算法中得以应用的根源在于,参数集在新数据集(比如测试集)上的重复使用。

      管道机制实现了对全部步骤的流式化封装和管理(streaming workflows with pipelines)。注意:管道机制更像是编程技巧的创新,而非算法的创新。
      https://www.imooc.com/article/35451

    2. convolutional neural networks:CNN,ConvNets ,卷积神经网络。它的人工神经元可以响应一部分覆盖范围内的周围单元,对于大型图像处理有出色表现。 它包括卷积层(convolutional layer)和池化层(pooling layer)。
      https://blog.csdn.net/weixin_42451919/article/details/81381294

    3. 池化层(pooling layer):除了卷积层,卷积网络也经常使用池化层来缩减模型的大小,提高计算速度,同时提高所提取特征的鲁棒性。
      https://www.jianshu.com/p/b742c8c92b26

    4. hand-crafted features :顾名思义人为设计的特征,即直接设计特征本身,根据仿照人类视觉的特点对什么样的特征敏感,什么样的特征不敏感提取图像中有区分能力的特征,因此提取出来的特征每一维往往都有具体的物理含义。
      hand-crafted rules实现的人工智能,其本质就是通过许多if判断语句去实现,然而并不能完成比较复杂的任务,由于需要编写大量的if语句,工作量非常大不说还会经常出现一些可笑的错误,早期的一些所谓智能聊天机器人,基本都是用这种技术。

    5. stacked hourglass: 堆积沙漏模型,即本文讲述的重点。
      动机:捕捉不同尺度下图片所包含的信息.
      局部信息,对于比如脸部、手部等等特征很有必要,而最终的姿态估计需要对整体人体一致理解. 不同尺度下,可能包含了很多有用信息,比如人体的方位、肢体的动作、相邻关节点的关系等等.
      在这里插入图片描述
      图 - 单个hourglass模块示例. 图中个方框分别对应一个residual模块. 整个hourglass中,特征数是一致的.
      hourglass设置:
      首先Conv层和Max Pooling层用于将特征缩放到很小的分辨率;
      每一个Max Pooling(降采样)处,网络进行分叉,并对原来pre-pooled分辨率的特征进行卷积;
      得到最低分辨率特征后,网络开始进行upsampling,并逐渐结合不同尺度的特征信息. 这里对较低分辨率采用的是最近邻上采样(nearest neighbor upsampling)方式,将两个不同的特征集进行逐元素相加.
      整个hourglass是对称的,获取低分辨率特征过程中每有一个网络层,则在上采样的过程中相应低就会有一个对应网络层.
      得到hourglass网络模块输出后,再采用两个连续的 1×1 Conv层进行处理,得到最终的网络输出.
      Stacked Hourglass Networks输出heatmaps的集合,每一个heatmap表征了关节点在每个像素点存在的概率.
      Residual模块提取了较高层次的特征(卷积路),同时保留了原有层次的信息(跳级路)。不改变数据尺寸,只改变数据深度。可以把它看做一个保尺寸的高级“卷积”层。
      https://www.cnblogs.com/z1141000271/p/9962464.html

    6. ground truth:在有监督学习中,数据是有标注的,以(x, t)的形式出现,其中x是输入数据,t是标注。正确的t标注是ground truth, 错误的标记则不是。(也有人将所有标注数据都叫做ground truth),如果标注数据不是ground truth,那么loss的计算将会产生误差,从而影响到模型质量。
      https://blog.csdn.net/wuruiaoxue/article/details/78761498

    7. RMSProp :RMSProp算法的全称叫 Root Mean Square Prop,是Geoffrey E. Hinton在Coursera课程中提出的一种优化算法。在上面的Momentum优化算法中,虽然初步解决了优化中摆动幅度大的问题,所谓的摆动幅度就是在优化中经过更新之后参数的变化范围,如下图所示,蓝色的为Momentum优化算法所走的路线,绿色的为RMSProp优化算法所走的路线。 蓝色的为Momentum优化算法所走的路线,绿色的为RMSProp优化算法所走的路线。 RMSProp算法对梯度计算了微分平方加权平均数。这种做法有利于消除了摆动幅度大的方向,用来修正摆动幅度,使得各个维度的摆动幅度都较小。另一方面也使得网络函数收敛更快。
      https://blog.csdn.net/willduan1/article/details/78070086

    8. MSE: Mean Squared Error :均方误差是指参数估计值与参数真值之差平方的期望值;
      作用:可以评价数据的变化程度,MSE的值越小,说明预测模型描述实验数据具有更好的精确度。
      在这里插入图片描述这里的y是测试集上的。用 真实值-预测值 然后平方之后求和平均。
      猛着看一下这个公式是不是觉得眼熟,这不就是线性回归的L2损失函数嘛!!! 对,在线性回归的时候我们的目的就是让这个损失函数最小。那么模型做出来了,我们把损失函数丢到测试集上去看看损失值不就好了嘛。简单直观暴力!

    9. Ablation Experiments:消融实验,在机器学习,特别是复杂的深度神经网络的背景下,已经采用“消融研究”来描述去除网络的某些部分的过程,以便更好地理解网络的行为。消融研究对于深度学习研究至关重要 。理解系统中的因果关系是产生可靠知识的最直接方式(任何研究的目标)。
      消融是一种非常省力的方式来研究因果关系。如果您采用任何复杂的深度学习实验设置,您可能会删除一些模块(或用随机的模块替换一些训练有素的功能)而不会降低性能。消除研究过程中的噪音:进行消融研究。
      第二种解释:你朋友说你今天的样子很帅,你想知道发型、上衣和裤子分别起了多大的作用,于是你换了几个发型,你朋友说还是挺帅的,你又换了件上衣,你朋友说不帅了,看来这件衣服还挺重要的。
      https://blog.csdn.net/FJY_sunshine/article/details/82732914

    10. 中继监督优化(intermediate supervision)在这里插入图片描述Hourglass网络输出heatmaps集合(蓝色方框部分),与真值进行误差计算。 其中利用1×1的Conv层对heatmaps进行处理并将其添加回特征空间中,作为下一个hourglass model的输入特征。每一个Hourglass网络都添加Loss层.Intermediate Supervision的作用在一篇论文中提到:如果直接对整个网络进行梯度下降,输出层的误差经过多层反向传播会大幅减小,即发生vanishing gradients现象。
      为解决此问题,这篇论文在每个阶段的输出上都计算损失。这种方法称为intermediate supervision,可以保证底层参数正常更新。
      https://www.cnblogs.com/z1141000271/p/9962464.html

    总结

    本文使用全卷积网络解决人体姿态分析问题,截至2016年5月,在MPII姿态分析竞赛中暂列榜首,PCKh(误差小于一半头高的样本比例)达到89.4%。与排名第二的CPM(Convolutiona Pose Machine)1方法相比,思路更明晰,网络更简洁。该论文体现了从模块到网络再到完整网络的设计思想。

    使用的初级模块称为Residual Module,得名于其中的旁路相加结构。
    在这里插入图片描述

    作用:Residual模块提取了较高层次的特征(卷积路),同时保留了原有层次的信息(跳级路)。不改变数据尺寸,只改变数据深度。可以把它看做一个保尺寸的高级“卷积”层。
    在这里插入图片描述

    上下两个半路都包含若干Residual模块(浅绿),逐步提取更深层次特征。但上半路在原尺度进行,下半路经历了先降采样(红色/2)再升采样(红色*2)的过程。

    降采样使用max pooling,升采样使用最近邻插值。n阶Hourglass子网络提取了从原始尺度到1/2 n 1/2n1/2^n尺度的特征。不改变数据尺寸,只改变数据深度。

    在这里插入图片描述

    以一个Hourglass(深绿色)为中心,可以从彩色图像预测K个人体部件的响应图。原始图像经过一次降采样(橙色),输入到Hourglass子网络中。Hourglass的输出结果经过两个线性模块(灰色),得到最终响应图。期间使用Residual模块(浅绿)和卷积层(白色)逐步提取特征。而本文用的是以两个Hourglass(深绿色)为中心的二级网络。二级网络重复了一级网络的后半结构。第二个Hourglass的输入包含三路: 第一个Hourglass的输入数据 ,第一个Hourglass的输出数据 ,第一级预测结果 。这三路数据通过串接(concat)和相加进行融合,它们的尺度不同,体现了当下流行的跳级结构思想。如下图所示:

    在这里插入图片描述
    总结起来SHN的方法值得学习的地方有四点:使用模块进行网络设计 ,先降采样,再升采样的全卷积结构 , 跳级结构辅助升采样 ,中继监督训练。

    评测数据集:在FLIC数据集上的PCK@0.2分别elbows(99%),elbows(97%)

    https://blog.csdn.net/qq_38522972/article/details/82958077

    展开全文
  • Stacking或Stacked Generalization是一种集成的机器学习算法。它使用元学习算法来学习如何最佳地组合来自两个或多个基础机器学习算法的预测。堆叠的好处在于,它可以利...

    Stacking或Stacked Generalization是一种集成的机器学习算法。它使用元学习算法来学习如何最佳地组合来自两个或多个基础机器学习算法的预测。堆叠的好处在于,它可以利用分类或回归任务上一系列性能良好的模型的功能,并做出比集合中的任何单个模型都有更好性能的预测。

    在本教程中,您将发现堆叠的泛型集成或Python中的堆叠。完成本教程后,您将知道:

    • 堆叠是一种集成的机器学习算法,可学习如何最佳地组合来自多个性能良好的机器学习模型的预测。

    • scikit-learn库提供了Python中堆栈集成的标准实现。

    • 如何使用堆叠集成进行回归和分类预测建模。

    教程概述

    本教程分为四个部分。他们是:

    • 堆叠概括

    • 堆叠Scikit-Learn API

    • 堆叠分类

    • 堆叠回归

    堆叠概括

    堆叠通用化或简称“堆叠”是一种集成的机器学习算法。它涉及在同一数据集上组合来自多个机器学习模型的预测,例如装袋和提升。堆叠解决了这个问题:给定多个熟练解决问题的机器学习模型,但是以不同的方式,您如何选择要使用的模型(信任)?解决此问题的方法是使用另一个机器学习模型,该模型学习何时使用或信任集合中的每个模型。

    • 与Bagging不同,在堆叠中,模型通常是不同的(例如,并非所有决策树)并且适合于同一数据集(例如,而不是训练数据集的样本)。

    • 与Boosting不同,在堆叠中,使用单个模型来学习如何最佳地组合来自贡献模型的预测(例如,而不是校正先前模型的预测的一系列模型)。

    堆栈模型的体系结构涉及两个或多个基本模型(通常称为0级模型)和一个将基本模型的预测结合在一起的元模型(称为1级模型)。

    • 0级模型(基本模型):模型适合训练数据,并会编译其预测。

    • 1级模型(元模型):学习如何最好地组合基础模型的预测的模型。

    元模型是根据基本模型对样本外数据所做的预测进行训练的。也就是说,将不用于训练基本模型的数据馈送到基本模型,进行预测,并且这些预测与预期输出一起提供用于拟合元模型的训练数据集的输入和输出对。来自基本模型的输出(用作元模型的输入)在回归的情况下可以是真实值,而在概率分类的情况下,概率值,类似概率的值或类别标签可以是真实值。为元模型准备训练数据集的最常见方法是通过基本模型的k折交叉验证,其中不合时宜的预测用作元模型训练数据集的基础。

    元模型的训练数据还可以包括基本模型的输入,例如基本模型的输入。训练数据的输入元素。这可以向元模型提供关于如何最佳地组合来自元模型的预测的附加上下文。一旦为元模型准备了训练数据集,就可以在该数据集上单独训练元模型,并且可以在整个原始训练数据集上训练基本模型。

    当多个不同的机器学习模型在数据集上具有技能但以不同的方式具有技能时,堆叠是合适的。另一种说法是,模型做出的预测或模型做出的预测中的误差不相关或具有较低的相关性。基本模型通常是复杂而多样的。因此,通常最好使用一系列关于如何解决预测建模任务的不同假设的模型,例如线性模型,决策树,支持向量机,神经网络等。其他集成算法也可以用作基本模型,例如随机森林。基本模型:使用各种模型,这些模型对预测任务有不同的假设。元模型通常很简单,可以对基本模型做出的预测进行平滑的解释。这样,线性模型通常用作元模型,例如用于回归任务的线性回归(预测数值)和用于分类任务的逻辑回归(预测类标签)。尽管这很普遍,但这不是必需的。

    • 回归元模型:线性回归。

    • 分类元模型:逻辑回归。

    使用简单的线性模型作为元模型通常会堆叠口语名称“ blending”。与预测中一样,是基础模型所做的预测的加权平均或混合。超级学习者可以被认为是一种特殊的堆叠方式。堆栈旨在提高建模性能,尽管不能保证在所有情况下都能改进。实现性能上的改进取决于问题的复杂性,以及培训数据是否足够好地表示问题以及是否足够复杂,以至于可以通过组合预测来学习更多。它还取决于基本模型的选择以及它们在预测(或错误)方面是否足够熟练和足够不相关。如果基本模型的性能优于或优于堆叠集成,则应使用基本模型,因为它的复杂度较低(例如,描述,训练和维护更简单)。

    堆叠Scikit-Learn API

    堆叠可以从头开始实现,尽管这对初学者可能具有挑战性。scikit-learn Python机器学习库提供了用于机器学习的堆栈实现。它在库的0.22版和更高版本中可用。首先,通过运行以下脚本来确认您正在使用现代版本的库:

    # check scikit-learn version
    import sklearn
    print(sklearn.__version__)
    

    运行脚本将打印您的scikit-learn版本。您的版本应该相同或更高。如果不是,则必须升级scikit-learn库的版本。

    0.22.1
    

    堆栈是通过StackingRegressor和StackingClassifier类提供的。两种模型以相同的方式操作并采用相同的参数。使用模型要求您指定一个估算器列表(0级模型)和一个最终估算器(1级或元模型)。级别0模型或基本模型的列表通过“ estimators”参数提供。这是一个Python列表,其中列表中的每个元素都是一个具有模型名称和配置的模型实例的元组。例如,下面定义了两个0级模型:

    models = [('lr',LogisticRegression()),('svm',SVC())
    stacking = StackingClassifier(estimators=models)
    

    列表中的每个模型也可以是管道,包括在将模型拟合到训练数据集之前模型所需的任何数据准备。例如:

    models = [('lr',LogisticRegression()),('svm',make_pipeline(StandardScaler(),SVC()))
    stacking = StackingClassifier(estimators=models)
    

    通过“ final_estimator”参数提供1级模型或元模型。默认情况下,将其设置为用于回归的LinearRegression和用于分类的LogisticRegression,并且这些是您可能不希望更改的明智的默认值。使用交叉验证准备元模型的数据集。默认情况下,使用5折交叉验证,尽管可以通过“ cv”自变量进行更改,并将其设置为数字(例如10折交叉验证为10)或交叉验证对象(例如StratifiedKFold) 。有时,如果为元模型准备的数据集还包含0级模型的输入(例如, 输入的训练数据。这可以通过将“ passthrough”参数设置为True来实现,并且默认情况下未启用。现在,我们已经熟悉了scikit-learn中的stacking API,下面让我们来看一些可行的示例。

    堆叠分类

    在本节中,我们将研究使用堆叠解决分类问题。首先,我们可以使用make_classification()函数创建具有1,000个示例和20个输入功能的综合二进制分类问题。下面列出了完整的示例。

    # test classification dataset
    from sklearn.datasets import make_classification
    # define dataset
    X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
    # summarize the dataset
    print(X.shape, y.shape)
    

    运行示例将创建数据集并总结输入和输出组件的形状。

    (1000, 20) (1000,)
    

    接下来,我们可以在数据集上评估一套不同的机器学习模型。

    具体来说,我们将评估以下五种算法:

    • 逻辑回归。

    • k最近邻居。

    • 决策树。

    • 支持向量机。

    • 天真贝叶斯。

    每种算法将使用默认模型超参数进行评估。下面的函数get_models()创建我们要评估的模型。

    # get a list of models to evaluate
    def get_models():
     models = dict()
     models['lr'] = LogisticRegression()
     models['knn'] = KNeighborsClassifier()
     models['cart'] = DecisionTreeClassifier()
     models['svm'] = SVC()
     models['bayes'] = GaussianNB()
     return models
    

    每个模型将使用重复的k倍交叉验证进行评估。下面的valuate_model()函数采用一个模型实例,并从分层的10倍交叉验证的三个重复中返回分数列表。

    # evaluate a given model using cross-validation
    def evaluate_model(model, X, y):
     cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
     scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
     return scores
    

    然后,我们可以报告每种算法的平均性能,还可以创建箱形图和晶须图,以比较每种算法的准确性得分的分布。结合在一起,下面列出了完整的示例。

    # compare standalone models for binary classification
    from numpy import mean
    from numpy import std
    from sklearn.datasets import make_classification
    from sklearn.model_selection import cross_val_score
    from sklearn.model_selection import RepeatedStratifiedKFold
    from sklearn.linear_model import LogisticRegression
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.svm import SVC
    from sklearn.naive_bayes import GaussianNB
    from matplotlib import pyplot
     
    # get the dataset
    def get_dataset():
     X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
     return X, y
     
    # get a list of models to evaluate
    def get_models():
     models = dict()
     models['lr'] = LogisticRegression()
     models['knn'] = KNeighborsClassifier()
     models['cart'] = DecisionTreeClassifier()
     models['svm'] = SVC()
     models['bayes'] = GaussianNB()
     return models
     
    # evaluate a given model using cross-validation
    def evaluate_model(model, X, y):
     cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
     scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
     return scores
     
    # define dataset
    X, y = get_dataset()
    # get the models to evaluate
    models = get_models()
    # evaluate the models and store results
    results, names = list(), list()
    for name, model in models.items():
     scores = evaluate_model(model, X, y)
     results.append(scores)
     names.append(name)
     print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
    # plot model performance for comparison
    pyplot.boxplot(results, labels=names, showmeans=True)
    pyplot.show()
    

    首先运行示例将报告每个模型的均值和标准差准确性。注意:由于算法或评估程序的随机性,或者数值精度的差异,您的结果可能会有所不同。考虑运行该示例几次并比较平均结果。我们可以看到,在这种情况下,SVM以约95.7%的平均准确度表现最佳。

    >lr 0.866 (0.029)
    >knn 0.931 (0.025)
    >cart 0.821 (0.050)
    >svm 0.957 (0.020)
    >bayes 0.833 (0.031)
    

    首先运行示例将报告每个模型的均值和标准差准确性。注意:由于算法或评估程序的随机性,或者数值精度的差异,您的结果可能会有所不同。考虑运行该示例几次并比较平均结果。我们可以看到,在这种情况下,SVM以约95.7%的平均准确度表现最佳。

    在这里,我们有五种不同的算法运行良好,大概在此数据集上的表现方式不同。接下来,我们可以尝试使用堆栈将这五个模型合并为一个整体模型。我们可以使用逻辑回归模型来学习如何最好地结合来自五个单独模型的预测。下面的get_stacking()函数通过首先为五个基本模型定义一个元组列表,然后定义逻辑回归元模型以使用5倍交叉验证组合来自基本模型的预测来定义StackingClassifier模型。

    # get a stacking ensemble of models
    def get_stacking():
     # define the base models
     level0 = list()
     level0.append(('lr', LogisticRegression()))
     level0.append(('knn', KNeighborsClassifier()))
     level0.append(('cart', DecisionTreeClassifier()))
     level0.append(('svm', SVC()))
     level0.append(('bayes', GaussianNB()))
     # define meta learner model
     level1 = LogisticRegression()
     # define the stacking ensemble
     model = StackingClassifier(estimators=level0, final_estimator=level1, cv=5)
     return model
    

    我们可以将堆栈集成与独立模型一起包括在要评估的模型列表中。

    # get a list of models to evaluate
    def get_models():
     models = dict()
     models['lr'] = LogisticRegression()
     models['knn'] = KNeighborsClassifier()
     models['cart'] = DecisionTreeClassifier()
     models['svm'] = SVC()
     models['bayes'] = GaussianNB()
     models['stacking'] = get_stacking()
     return models
    

    我们的期望是,堆叠集成的性能将优于任何单个基本模型。并非总是如此,如果不是这种情况,则应使用基础模型,以支持集成模型。下面列出了评估堆叠集成模型和独立模型的完整示例。

    # compare ensemble to each baseline classifier
    from numpy import mean
    from numpy import std
    from sklearn.datasets import make_classification
    from sklearn.model_selection import cross_val_score
    from sklearn.model_selection import RepeatedStratifiedKFold
    from sklearn.linear_model import LogisticRegression
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.svm import SVC
    from sklearn.naive_bayes import GaussianNB
    from sklearn.ensemble import StackingClassifier
    from matplotlib import pyplot
     
    # get the dataset
    def get_dataset():
     X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
     return X, y
     
    # get a stacking ensemble of models
    def get_stacking():
     # define the base models
     level0 = list()
     level0.append(('lr', LogisticRegression()))
     level0.append(('knn', KNeighborsClassifier()))
     level0.append(('cart', DecisionTreeClassifier()))
     level0.append(('svm', SVC()))
     level0.append(('bayes', GaussianNB()))
     # define meta learner model
     level1 = LogisticRegression()
     # define the stacking ensemble
     model = StackingClassifier(estimators=level0, final_estimator=level1, cv=5)
     return model
     
    # get a list of models to evaluate
    def get_models():
     models = dict()
     models['lr'] = LogisticRegression()
     models['knn'] = KNeighborsClassifier()
     models['cart'] = DecisionTreeClassifier()
     models['svm'] = SVC()
     models['bayes'] = GaussianNB()
     models['stacking'] = get_stacking()
     return models
     
    # evaluate a give model using cross-validation
    def evaluate_model(model, X, y):
     cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
     scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
     return scores
     
    # define dataset
    X, y = get_dataset()
    # get the models to evaluate
    models = get_models()
    # evaluate the models and store results
    results, names = list(), list()
    for name, model in models.items():
     scores = evaluate_model(model, X, y)
     results.append(scores)
     names.append(name)
     print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
    # plot model performance for comparison
    pyplot.boxplot(results, labels=names, showmeans=True)
    pyplot.show()
    

    首先运行示例将报告每个模型的性能。这包括每个基本模型的性能,然后是堆叠合奏。

    注意:由于算法或评估程序的随机性,或者数值精度的差异,您的结果可能会有所不同。考虑运行该示例几次并比较平均结果。在这种情况下,我们可以看到堆叠集成的平均性能似乎比任何单个模型都要好,达到了约96.4%的精度。

    >lr 0.866 (0.029)
    >knn 0.931 (0.025)
    >cart 0.820 (0.044)
    >svm 0.957 (0.020)
    >bayes 0.833 (0.031)
    >stacking 0.964 (0.019)
    

    将创建一个箱形图,以显示模型分类精度的分布。在这里,我们可以看到堆叠模型的均值和中值准确性比SVM模型要高一些。

    如果我们选择堆叠集成作为最终模型,则可以像其他任何模型一样拟合并使用它对新数据进行预测。首先,将堆栈集合适合所有可用数据,然后可以调用predict()函数对新数据进行预测。下面的示例在我们的二进制分类数据集中展示了这一点。

    # make a prediction with a stacking ensemble
    from sklearn.datasets import make_classification
    from sklearn.ensemble import StackingClassifier
    from sklearn.linear_model import LogisticRegression
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.svm import SVC
    from sklearn.naive_bayes import GaussianNB
    # define dataset
    X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
    # define the base models
    level0 = list()
    level0.append(('lr', LogisticRegression()))
    level0.append(('knn', KNeighborsClassifier()))
    level0.append(('cart', DecisionTreeClassifier()))
    level0.append(('svm', SVC()))
    level0.append(('bayes', GaussianNB()))
    # define meta learner model
    level1 = LogisticRegression()
    # define the stacking ensemble
    model = StackingClassifier(estimators=level0, final_estimator=level1, cv=5)
    # fit the model on all available data
    model.fit(X, y)
    # make a prediction for one example
    data = [[2.47475454,0.40165523,1.68081787,2.88940715,0.91704519,-3.07950644,4.39961206,0.72464273,-4.86563631,-6.06338084,-1.22209949,-0.4699618,1.01222748,-0.6899355,-0.53000581,6.86966784,-3.27211075,-6.59044146,-2.21290585,-3.139579]]
    yhat = model.predict(data)
    print('Predicted Class: %d' % (yhat))
    

    运行示例适合整个数据集上的堆叠集成模型,然后像在应用程序中使用模型一样,将其用于对新数据行进行预测。

    Predicted Class: 0
    

    堆叠回归

    在本节中,我们将研究如何使用堆叠来解决回归问题。首先,我们可以使用make_regression()函数创建具有1000个示例和20个输入要素的综合回归问题。下面列出了完整的示例。

    # test regression dataset
    from sklearn.datasets import make_regression
    # define dataset
    X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=1)
    # summarize the dataset
    print(X.shape, y.shape)
    

    运行示例将创建数据集并总结输入和输出组件的形状。

    (1000, 20) (1000,)
    

    接下来,我们可以在数据集上评估一套不同的机器学习模型。

    具体来说,我们将评估以下三种算法:

    • k近邻

    • 决策树

    • 支持向量回归

    注意:可以使用线性回归模型对测试数据集进行简单求解,因为该数据集是在封面下使用线性模型创建的。因此,我们将把该模型放在示例之外,以便我们可以证明堆叠集成方法的好处。

    每种算法将使用默认的模型超参数进行评估。下面的函数get_models()创建我们要评估的模型。

    # get a list of models to evaluate
    def get_models():
     models = dict()
     models['knn'] = KNeighborsRegressor()
     models['cart'] = DecisionTreeRegressor()
     models['svm'] = SVR()
     return models
    

    每个模型将使用重复的k倍交叉验证进行评估。下面的valuate_model()函数采用一个模型实例,并从三个重复的10倍交叉验证中返回分数列表。

    # evaluate a given model using cross-validation
    def evaluate_model(model, X, y):
     cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
     scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
     return scores
    

    然后,我们可以报告每种算法的平均性能,还可以创建箱形图和晶须图,以比较每种算法的准确性得分的分布。在这种情况下,将使用平均绝对误差(MAE)报告模型性能。scikit-learn库会将此错误的符号反转以使其最大化,从-infinity到0以获取最佳分数。结合在一起,下面列出了完整的示例。

    # compare machine learning models for regression
    from numpy import mean
    from numpy import std
    from sklearn.datasets import make_regression
    from sklearn.model_selection import cross_val_score
    from sklearn.model_selection import RepeatedKFold
    from sklearn.linear_model import LinearRegression
    from sklearn.neighbors import KNeighborsRegressor
    from sklearn.tree import DecisionTreeRegressor
    from sklearn.svm import SVR
    from matplotlib import pyplot
     
    # get the dataset
    def get_dataset():
     X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=1)
     return X, y
     
    # get a list of models to evaluate
    def get_models():
     models = dict()
     models['knn'] = KNeighborsRegressor()
     models['cart'] = DecisionTreeRegressor()
     models['svm'] = SVR()
     return models
     
    # evaluate a given model using cross-validation
    def evaluate_model(model, X, y):
     cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
     scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
     return scores
     
    # define dataset
    X, y = get_dataset()
    # get the models to evaluate
    models = get_models()
    # evaluate the models and store results
    results, names = list(), list()
    for name, model in models.items():
     scores = evaluate_model(model, X, y)
     results.append(scores)
     names.append(name)
     print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
    # plot model performance for comparison
    pyplot.boxplot(results, labels=names, showmeans=True)
    pyplot.show()
    

    首先运行示例,报告每个模型的均值和标准差MAE。注意:由于算法或评估程序的随机性,或者数值精度的差异,您的结果可能会有所不同。考虑运行该示例几次并比较平均结果。我们可以看到,在这种情况下,KNN的最佳表现为平均负MAE约为-100。

    >knn -101.019 (7.161)
    >cart -148.100 (11.039)
    >svm -162.419 (12.565)
    

    然后创建箱型图,比较每个模型的分布负MAE得分。

    在这里,我们有三种不同的算法可以很好地运行,大概在此数据集上以不同的方式运行。

    接下来,我们可以尝试使用堆栈将这三个模型合并为一个整体模型。

    我们可以使用线性回归模型来学习如何最佳地组合来自三个模型的预测。

    下面的get_stacking()函数通过首先为三个基本模型定义一个元组列表,然后定义线性回归元模型以使用5倍交叉验证组合来自基本模型的预测来定义StackingRegressor模型。

    # get a stacking ensemble of models
    def get_stacking():
     # define the base models
     level0 = list()
     level0.append(('knn', KNeighborsRegressor()))
     level0.append(('cart', DecisionTreeRegressor()))
     level0.append(('svm', SVR()))
     # define meta learner model
     level1 = LinearRegression()
     # define the stacking ensemble
     model = StackingRegressor(estimators=level0, final_estimator=level1, cv=5)
     return model
    

    我们可以将堆栈集成与独立模型一起包括在要评估的模型列表中

    # get a list of models to evaluate
    def get_models():
     models = dict()
     models['knn'] = KNeighborsRegressor()
     models['cart'] = DecisionTreeRegressor()
     models['svm'] = SVR()
     models['stacking'] = get_stacking()
     return models
    

    我们的期望是,堆叠集成的性能将优于任何单个基本模型。情况并非总是如此,如果不是这种情况,则应使用基础模型以支持集成模型。下面列出了评估堆叠集成模型和独立模型的完整示例。

    # compare ensemble to each standalone models for regression
    from numpy import mean
    from numpy import std
    from sklearn.datasets import make_regression
    from sklearn.model_selection import cross_val_score
    from sklearn.model_selection import RepeatedKFold
    from sklearn.linear_model import LinearRegression
    from sklearn.neighbors import KNeighborsRegressor
    from sklearn.tree import DecisionTreeRegressor
    from sklearn.svm import SVR
    from sklearn.ensemble import StackingRegressor
    from matplotlib import pyplot
     
    # get the dataset
    def get_dataset():
     X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=1)
     return X, y
     
    # get a stacking ensemble of models
    def get_stacking():
     # define the base models
     level0 = list()
     level0.append(('knn', KNeighborsRegressor()))
     level0.append(('cart', DecisionTreeRegressor()))
     level0.append(('svm', SVR()))
     # define meta learner model
     level1 = LinearRegression()
     # define the stacking ensemble
     model = StackingRegressor(estimators=level0, final_estimator=level1, cv=5)
     return model
     
    # get a list of models to evaluate
    def get_models():
     models = dict()
     models['knn'] = KNeighborsRegressor()
     models['cart'] = DecisionTreeRegressor()
     models['svm'] = SVR()
     models['stacking'] = get_stacking()
     return models
     
    # evaluate a given model using cross-validation
    def evaluate_model(model, X, y):
     cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
     scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
     return scores
     
    # define dataset
    X, y = get_dataset()
    # get the models to evaluate
    models = get_models()
    # evaluate the models and store results
    results, names = list(), list()
    for name, model in models.items():
     scores = evaluate_model(model, X, y)
     results.append(scores)
     names.append(name)
     print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
    # plot model performance for comparison
    pyplot.boxplot(results, labels=names, showmeans=True)
    pyplot.show()
    

    首先运行示例将报告每个模型的性能。这包括每个基本模型的性能,然后是堆叠合奏。注意:由于算法或评估程序的随机性,或者数值精度的差异,您的结果可能会有所不同。考虑运行该示例几次并比较平均结果。在这种情况下,我们可以看到堆叠集成的平均表现要好于任何单个模型,平均负MAE约为-56。

    >knn -101.019 (7.161)
    >cart -148.017 (10.635)
    >svm -162.419 (12.565)
    >stacking -56.893 (5.253)
    

    将创建一个箱形图,以显示模型错误分数的分布。在这里,我们可以看到堆叠模型的平均得分和中位数得分远高于任何单个模型。

    如果我们选择堆叠集成作为最终模型,则可以像其他任何模型一样拟合并使用它对新数据进行预测。首先,将堆栈集合适合所有可用数据,然后可以调用predict()函数对新数据进行预测。下面的示例在我们的回归数据集中展示了这一点。

    # make a prediction with a stacking ensemble
    from sklearn.datasets import make_regression
    from sklearn.linear_model import LinearRegression
    from sklearn.neighbors import KNeighborsRegressor
    from sklearn.tree import DecisionTreeRegressor
    from sklearn.svm import SVR
    from sklearn.ensemble import StackingRegressor
    # define dataset
    X, y = make_regression(n_samples=1000, n_features=20, n_informative=15, noise=0.1, random_state=1)
    # define the base models
    level0 = list()
    level0.append(('knn', KNeighborsRegressor()))
    level0.append(('cart', DecisionTreeRegressor()))
    level0.append(('svm', SVR()))
    # define meta learner model
    level1 = LinearRegression()
    # define the stacking ensemble
    model = StackingRegressor(estimators=level0, final_estimator=level1, cv=5)
    # fit the model on all available data
    model.fit(X, y)
    # make a prediction for one example
    data = [[0.59332206,-0.56637507,1.34808718,-0.57054047,-0.72480487,1.05648449,0.77744852,0.07361796,0.88398267,2.02843157,1.01902732,0.11227799,0.94218853,0.26741783,0.91458143,-0.72759572,1.08842814,-0.61450942,-0.69387293,1.69169009]]
    yhat = model.predict(data)
    print('Predicted Value: %.3f' % (yhat))
    

    运行示例适合整个数据集上的堆叠集成模型,然后像在应用程序中使用模型一样,将其用于对新数据行进行预测。

    Predicted Value: 556.264
    

    作者:沂水寒城,CSDN博客专家,个人研究方向:机器学习、深度学习、NLP、CV

    Blog: http://yishuihancheng.blog.csdn.net

    赞 赏 作 者

    更多阅读

    [视频]GitHub趋势榜(2021年1月上旬)

    特别推荐


    点击下方阅读原文加入社区会员

    展开全文
  • 机器学习之Stacking原理与实战

    千次阅读 2019-02-23 11:14:46
    学习过机器学习相关基础的童鞋应该知道,从基学习器的类型可将集成学习分为两大类: 同质集成(homogeneous) Boosting:Adaboost、GBDT、XGboost、lightGBM等 Bagging:RandomForest 异质集成(heterogenous) ...
  • 机器学习】集成学习之stacking

    千次阅读 2018-08-02 20:46:40
    stacking方法也是集成学习的一个作弊一样的方法。 比bagging,boosting内容要少一点。 简介 Stacking(有时候也称之为stacked generalization)是指训练一个模型用于组合(combine)其他各个模型。即首先我们先训练多...
  • Stacking或Stacked Generalization是一种集成的机器学习算法。它使用元学习算法来学习如何最佳地组合来自两个或多个基础机器学习算法的预测。堆叠的好处在于,它可以利用分类或回归任务上一系列性能良好的模型的功能...
  • 1.关于堆栈泛化Stacked Generalization(SG) 作为一个在kaggle比赛中高分选手常用的技术,SG在部分情况下,甚至可以让错误率相比当前最好的方法进一步降低30%之多。 以下图为例,简单介绍什么是SG: ① 将训练集...
  • Stacking是用新的模型(次学习器)去学习怎么组合那些基学习器,它的思想源自于Stacked Generalization这篇论文。如果把Bagging看作是多个基分类器的线性组合,那么Stacking就是多个基分类器的非线性组合。Stacking...
  • 原标题:用机器学习来预测股价(代码+文档)——2018年iNTUtion决赛大作!本期作者:Roman Moser本期翻译:deigozhao未经授权,严禁转载机器学习和深度学习在时间序列数据的预测上具有很高的准确率,在金融机构中获得...
  • Stacking(有时候也称之为stacked generalization)是指训练一个模型用于组合(combine)其他各个模型。即首先我们先训练多个不同的模型,然后再以之前训练的各个模型的输出为输入来训练一个模型,以得到一个最终的输出....
  • 作者:Gray 编译:1+1=61前言金融市场大多是随机的。然而,它们并不是完全随机的。市场中存在着许多小的低效和模式,它们可以被识别出来,并被用来...在本文中,我们将给各位读者提供一个框架Stacked Generalizatio...
  • 介绍在将机器学习算法推向新的高度时,利用堆栈(堆栈泛化)是一个非常热门的话题。最初由David Wolpert 在1992年论文《Stacked Generalization》中介绍,他们的主要目的是减少泛化错误。根据Wolpert的说法,他们可以...
  • Booststrap aggregating (有些...而Boosting在维基中被定义为一种主要用来减少偏差(Bias)和同时也可降低方差(Variance)的机器学习元算法,是一个将弱学习器转化为强学习器的机器学习算法族。最初由Kearns 和 Va...
  • 使用H2O进行集成学习

    千次阅读 2017-03-02 21:37:21
    使用H2O进行集成学习介绍集成学习就是组合多个机器学习算法,从而得到更好的预测性能。许多流行的现代机器学习算法实际上就是集成。比如说随机森林 和 Gradient Boosting Machine (GBM)都是2个集成学习器。Bagging...
  • 【翻译自 : How to Implement Stacked Generalization ... 集成方法是提高机器学习问题的预测性能的绝佳方法。堆叠概括或堆叠是一种集成技术,它使用新模型来学习如何最佳地组合来自数据集上训练的两个或多个模...
  • 1. AutoEncoder介绍 2. Applications of AutoEncoder in NLP 3. Recursive Autoencoder(递归自动编码器) ...大多数机器学习需要大量的人工筛选的特征作为输入,通常特征筛选需要对数据的意义有深入的...
  • 机器学习机器学习是计算机科学的一个子领域,在人工智能领域,机器学习逐渐发展成模式识别和计算科学理论的研究。通俗的讲机器学习是一种能够赋予机器学习的能力,可以让它完成直接编程无法完成的功能的方法。但从...
  • Additional Python Machine Learning Tools 通过掌握Python中的尖端机器学习技术来解决具有挑战性的数据科学问题 关于这本书 解决复杂的机器学习问题,探索深入学习 学习使用Python代码来实现一系列机器学习算法和...
  • 深度学习是机器学习的一个分支。可以理解为具有多层结构的模型。 二、基本模型: 给大家总结一下深度学习里面的基本模型。我将这些模型大致分为了这几类:多层感知机模型;深度神经网络模型和递归神经网络模型。...
  • 目录: 第一章 深度学习概述 第二章 无监督学习GAN 第三章 图像风格跨域转换...第六章 将机器学习带入生产环境 4.1 StackGAN介绍 StackGAN:Text to Photo realistic Image Synthesis with Stacked Generati...
  • 针对传统机器学习方法不能有效地提取恶意代码的潜在特征,提出了基于栈式自编码(stacked auto encoder,SAE)的恶意代码分类算法。其次从大量训练样本中学习并提取恶意代码纹理图像特征、指令语句中的隐含特征;在...
  • 针对临床分类诊断中普遍存在的样本不均衡、错分代价不同、大量无标签样本和测量误差等特点,引入了机器学习中较新的研究成果——多层降噪自编码(stacked denoising autoencoders,SDA)神经网络,并与欠采样局部...
  • 药物透血脑屏障是新药研发的一个重要因素。在传统栈式降噪自编码(stacked denoising autoencoder,SDAE)基础...实验表明,与传统的SDAE及浅层机器学习模型SVM相比,改进后的模型对药物透血脑屏障具有更好的预测效果。
  • PyBrain(Python-Based Reinforcement Learning, Artificial Intelligence and Neural Network)是Python的一个机器学习模块,它的目标是为机器学习任务提供灵活、易应、强大的机器学习算法。(这名字很霸气) ...
  • 基于上述观点,本文通过机器学习的方法,自动发现用户(项目)对于各种方法的适应程度,并进行局部模型融合。实验结果表明,局部融合模型比全局融合模型具有更高的推荐精度。 还原 【Abstract】 The fast development of ...

空空如也

空空如也

1 2
收藏数 28
精华内容 11
关键字:

机器学习stacked