精华内容
下载资源
问答
  • 模型融合stacking代码

    2020-12-27 16:27:28
    https://blog.csdn.net/WxyangID/article/details/80205075 https://www.jianshu.com/p/719fc024c0ec https://blog.csdn.net/shine19930820/article/details/75209021
    展开全文
  • 模型融合Stacking

    2020-04-04 19:54:37
    模型融合模型融合代码 模型融合 要想使得使得机器学习模型进一步提升,必须使用到模型融合的技巧,常用的模型融合方法有Stacking与Blending。Stacking实际上就是把Blending组合起来,Blending只有一层,而Stacking有...

    模型融合

    要想使得使得机器学习模型进一步提升,必须使用到模型融合的技巧,常用的模型融合方法有Stacking与Blending。Stacking实际上就是把Blending组合起来,Blending只有一层,而Stacking有多层,它把各个基学习器的预测结果作为下一层新的训练集,来学习一个新的学习器。通过元分类器或元回归聚合多个分类或回归模型。基础层次模型(level model)基于完整的训练集进行训练,然后第二层次模型基于基础层次模型的输出进行训练。
    关于Stacking原理可以参考Stacking详解

    代码

    将XGB,LGB以及随机森林作为基础模型,线性回归或Lasso作为第二层次模型。

    ### 第一层模型
    base_models = [xgb.XGBRegressor(),lgb.LGBMRegressor(),RandomForestRegressor()]
    
    # 设置训练数据
    row_train = len(labeled) #数据量(长度)
    col_train = len(base_models) #所用模型数量
    stacking_train_dataset1 = np.zeros(shape = (row_train, col_train))
    stacking_train_dataset = pd.DataFrame(data= stacking_train_dataset1)
    
    # 设置测试数据
    row_test = len(test_label)
    col_test = len(base_models)
    stacking_test_dataset1 = np.zeros(shape = (row_test, col_test))
    stacking_test_dataset = pd.DataFrame(data = stacking_test_dataset1)
    
    #k折训练
    sk=StratifiedKFold(n_splits=3,shuffle=True,random_state=3)
    for i,base in enumerate(base_models):
        counter = randint(0, 3)
        inner_counter = 0
        for trainix, testix in sk.split(X,Y):
            if inner_counter == counter:
                x_train = X.iloc[trainix]
                y_train = Y.iloc[trainix] 
                model = base
                print('training : %s'%(type(model)))
                model.fit(x_train, y_train)
    	    stacking_train_dataset[i] = model.predict(X)
                stacking_test_dataset[i] = model.predict(test_label)
            inner_counter += 1
    

    上面实现了基础模型的训练,并且获得新的训练集给第二层次模型训练。

    #选择lasso作为第二层次模型
    ensemble_model =Lasso()
    
    #训练
    stacking_train_dataset['Ensemble'] = ensemble_model.fit(stacking_train_dataset, Y).predict(stacking_train_dataset)
    
    #预测
    pred = ensemble_model.predict(stacking_test_dataset)

    总结

    Stacking集成模型后,模型的性能有了提升,但是Stacking基础层的模型性能一定要强(类似简单的线性回归模型,效果就差强人意),第二层则可以选择一些简单的模型。当然由于它的基础模型复杂度过高,也容易造成过拟合。

    参考

    Stacking基本思想及代码实现

    展开全文
  • 模型调优和模型融合

    2019-04-16 11:18:35
    #模型调优和模型融合 模型调优的基本方法 模型融合 代码实践 模型调优 模型调优,主要是寻找超参数,使得模型有更好的robust。 网格搜索 GridSearchCV,它存在的意义就是自动调参,只要把参数输进去,就能给出...

    #模型调优和模型融合

    • 模型调优的基本方法
    • 模型融合
    • 代码实践

    模型调优

     模型调优,主要是寻找超参数,使得模型有更好的robust。
    
    • 网格搜索
      GridSearchCV,它存在的意义就是自动调参,只要把参数输进去,就能给出最优化的结果和参数。但是这个方法适合于小数据集,一旦数据的量级上去了,很难得出结果。这个时候就是需要动脑筋了。数据量比较大的时候可以使用一个快速调优的方法——坐标下降。它其实是一种贪心算法:拿当前对模型影响最大的参数调优,直到最优化;再拿下一个影响最大的参数调优,如此下去,直到所有的参数调整完毕。这个方法的缺点就是可能会调到局部最优而不是全局最优,但是省时间省力,巨大的优势面前,还是试一试吧,后续可以再拿bagging再优化。
    • 随机采样
      数据规模大,精确的结果难以在一定时间计算出。
      结果的些许的不精确能够被接受。
      求取的结果是最优化(optimization)问题,有一个成本计算模型。
    • 贝叶斯超参数优化
      在贝叶斯调参过程中,假设参数组合是X,最终的评估结果为Y,通过什么样的X可以取得最优的Y,这个函数F(X)我们是不知道的,Y=F(X)。
      于是可以假设这个寻找最优化参数的过程是一个高斯过程。高斯过程有个特点,就是当随机遍历一定的数据点并拿到结果之后,可以大致绘制出整个数据的分布曲线。
      其基础理论就是不断通过先验点去预测后验知识

    模型融合和代码实践

    from sklearn.model_selection import  GridSearchCV
    params={'penalty':['l2','l1'],'C':[1,50,100,150]}
    lr=LogisticRegression(C=120,dual=False)
    lrsearch=GridSearchCV(estimator=lr,param_grid=params,scoring='f1_macro',n_jobs=1,cv=5,verbose=3)
    lrsearch.fit(x_train,y_train)
    print("the best parameters:",lrsearch.best_params_)
    print("the best score:",lrsearch.best_score_)
    print("the validation score:",lrsearch.score(x_validation,y_validation))
    
    

    在这里插入图片描述

    params={'C':[1,10,50,100]}
    svm=LinearSVC(dual=True)
    svmseach=GridSearchCV(estimator=svm,param_grid=params,scoring='f1_macro',n_jobs=1,cv=5,verbose=3)
    svmseach.fit(x_train,y_train)
    print("the best parameters:",svmseach.best_params_)
    print("the best score:",svmseach.best_score_)
    print("the validation score:",svmseach.score(x_validation,y_validation))
    

    在这里插入图片描述

    logis=LogisticRegression(C=150,dual=True)
    svm=LinearSVC(C=10,dual=True)
    algorithms = [logis,svm]
    full_predictions = []
    for alg in algorithms:
        alg.fit(x_train, y_train)
        predictions = alg.predict_proba(x_validation)
        full_predictions.append(predictions)
    
    y_prediction = (full_predictions[0] + full_predictions[1]) / 2
    y_prediction = np.argmax(y_prediction, axis=1) + 1
    f1 = f1_score(y_validation, y_prediction,  average='micro')
    print('The F1 Score: %.2f'  % f1)
    

    The F1 Score: 0.72

    展开全文
  • DALEC模型模型数据融合代码用于生成“通过并置观测和数据同化获得的典型中国森林参考碳循环数据集”的同化数据。 用fortan编写的DALEC模型(常绿和落叶版本)由Williams Mathew教授()首次在REFLEX项目主持人中...
  • XGBOOST + LR 模型融合 python 代码

    万次阅读 多人点赞 2018-01-08 18:16:11
    先留个广告,最近做一个数据挖掘的比赛,主要用的就是 xgboost,等比赛完后年前好好整理代码开源,到时候代码会比下面整份完整。 XGBOOST + LR 是 CTR 常用的一种方式。下面是实现 XGBOOST + LR 的代码,具体的原理...
    
    
    

    先留个广告,最近做一个数据挖掘的比赛,主要用的就是 xgboost,等比赛完后年前好好整理代码开源,到时候代码会比下面整份完整。

    XGBOOST + LR 是 CTR 常用的一种方式。下面是实现 XGBOOST + LR 的代码,具体的原理不做细说。有了下面的代码框架,你可以对 xgboost 进行参数优化搜索,同时可以利用 xgboost 把数值型特征转为 one-hot 特征给 LR 进行训练。

    在 xgboost 直接调用 sklearn 的 grid search 函数时,没有办法使用 early stop。使用 early stop 很有帮助,一方面能够避免过拟合,另一方面能够节省不少时间,所以可以直接写个函数替代 grid search。下面代码中实现是逐个参数搜寻,逐个找到最优参数,实际上没有 grid search, 但是效果一般不会太差,而且省下很多时间。后面的代码将按照下面的4个部分进行展开。

    • 1.分开数值特征与类别特征
    • 2.自定义 xgb_grid_search 函数
    • 3.利用最优的 xgb 模型把数值特征转为类别特征
    • 4.将新特征和原始的类别特征一块训练 LR 模型进行最后的预测

    最重要的有几个点:
    - 怎样自定义 xgboost 的 grid_search_cv 函数,使得能够使用 early_stop
    - 怎样根据训练好的 xgboost 模型,把数值特征转为 one-hot 特征(就是得到叶子结点的 one-hot 编码)

    # -*- coding:utf-8 -*-
    from __future__ import print_function
    from __future__ import division
    
    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt 
    from sklearn.model_selection import GridSearchCV 
    
    import xgboost as xgb
    from xgboost.sklearn import XGBClassifier
    from sklearn.ensemble import GradientBoostingClassifier
    from sklearn.linear_model import LogisticRegression
    
    from sklearn.model_selection import train_test_split, cross_val_score
    from sklearn.datasets import load_svmlight_file
    from sklearn.preprocessing import OneHotEncoder
    import sys 
    sys.path.append('../..')
    import time
    import my_utils

    1.导入数据

    我的数据格式是 libsvm 格式的,如果其他格式的数据需要自己修改一下就行了。

    # 特征名
    column_names = ['0', '1', '2', '3', '4',
                    '5', '6', '7','8', '9', 
                    '10', '11', '12', '13',
                    '14', '15', '16', '17', 
                   ]
    
    data = load_svmlight_file('your_libsvm_data')
    features = data[0].toarray()
    labels = data[1]
    print('features.shape=%s' % str(features.shape))
    print('labels.shape=%s' % str(labels.shape))
    features.shape=(73600, 18)
    labels.shape=(73600,)
    

    分开类别特征和数值特征

    首先把数值特征和类别特征分开,我只把数值特征输入 xgboost 中进行训练,当然也可以把类别特征一块输进去训练。

    df_data = pd.DataFrame(features, columns=column_names)
    # 类别特征
    col_no_id = ['0','1', '2', '3', 
                 '4', '5', '6', '7', 
                '8', '9', '10', '11', '12']
    col_is_id = list(set.difference(set(column_names), set(col_no_id)))
    
    features_no_id = df_data.loc[:, col_no_id].values
    features_is_id = list()
    for col in col_is_id:
        features_is_id.append(pd.get_dummies(df_data[col].values).values)
    features_is_id = np.hstack(features_is_id)
    print('features_no_id.shape=%s' % str(features_no_id.shape))
    print('features_is_id.shape=%s' % str(features_is_id.shape))
    
    features = np.hstack([features_no_id, features_is_id])
    n_no_id = len(col_no_id)
    
    X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.2, random_state=3)
    
    # 取数值型特征构建训练集
    dtrain = xgb.DMatrix(X_train[:, :n_no_id], y_train, feature_names=col_no_id)
    dtest = xgb.DMatrix(X_test[:, :n_no_id], y_test, feature_names=col_no_id)
    features_no_id.shape=(73600, 13)
    features_is_id.shape=(73600, 21)
    

    2. 自定义xgboost 参数搜索函数

    def model_fit(params, dtrain, max_round=300, cv_folds=5, n_stop_round=50):
        """对一组参数进行交叉验证,并返回最优迭代次数和最优的结果。
        Args:
            params: dict, xgb 模型参数。
            见 xgb_grid_search_cv 函数
    
        Returns: 
            n_round: 最优迭代次数
            mean_auc: 最优的结果
        """
        cv_result = xgb.cv(params, dtrain, max_round, nfold=cv_folds,
            metrics='auc', early_stopping_rounds=n_stop_round, show_stdv=False)
        n_round = cv_result.shape[0]  # 最优模型,最优迭代次数
        mean_auc = cv_result['test-auc-mean'].values[-1]  # 最好的  AUC
        return n_round, mean_auc
    
    
    def xgb_grid_search_cv(params, key, search_params, dtrain, max_round=300, cv_folds=5, 
                           n_stop_round=50, return_best_model=True, verbose=True):
        """自定义 grid_search_cv for xgboost 函数。
        Args: 
            params: dict, xgb 模型参数。
            key: 待搜寻的参数。
            search_params:list, 待搜寻的参数list。
            dtrain: 训练数据
            max_round: 最多迭代次数
            cv_folds: 交叉验证的折数
            early_stopping_rounds: 迭代多少次没有提高则停止。
            return_best_model: if True, 在整个训练集上使用最优的参数训练模型。
            verbose:if True, 打印训练过程。
    
        Returns:
            cv_results: dict,所有参数组交叉验证的结果。
                - mean_aucs: 每组参数对应的结果。
                - n_rounds: 每组参数最优迭代轮数。
                - list_params: 搜寻的每一组参数。
                - best_mean_auc: 最优的结果。
                - best_round: 最优迭代轮数。
                - best_params: 最优的一组参数。
            best_model: XGBoostClassifer() 
        """  
        import time
        mean_aucs = list()
        n_rounds = list()
        list_params = list()
        print('Searching parameters: %s %s' % (key, str(values)))
        tic = time.time()
        for search_param in search_params:
            params[key] = search_param
            list_params.append(params.copy())
            n_round, mean_auc = model_fit(params, dtrain, max_round, cv_folds, n_stop_round)
            if verbose:
                print('%s=%s: n_round=%d, mean_auc=%g. Time cost %gs' % (key, str(search_param), n_round, mean_auc, time.time() - tic))
            mean_aucs.append(mean_auc)
            n_rounds.append(n_round)
        best_mean_auc = max(mean_aucs)
        best_index = mean_aucs.index(best_mean_auc)  # 最优的一组
        best_round = n_rounds[best_index]
        best_params = list_params[best_index]
        cv_result = {'mean_aucs': mean_aucs, 'n_rounds': n_rounds, 'list_params': list_params, 
                    'best_mean_auc': best_mean_auc, 'best_round': best_round, 'best_params': best_params}
        if return_best_model:       
            best_model = xgb.train(best_params, dtrain, num_boost_round=best_round)
        else:
            best_model = None
        if verbose:
            print('best_mean_auc = %g' % best_mean_auc)
            print('best_round = %d' % best_round)
            print('best_params = %s' % str(best_params))
        return cv_result, best_model

    首先提供一组比较正常的参数,每次固定其他参数,只对一个参数进行搜索,在得到这个参数的最优值以后,以同样的方式来调整下一个参数。当然,有了上面的函数,你可以很容易地改成和 grid search 一样的方式进行参数搜索。

    params = {'booster': 'gbtree',
              'objective': 'binary:logistic',
              'learning_rate': 0.1,
              'subsample': 0.8,
              'colsample_bytree': 0.8,
              'eta': 0.1,
              'max_depth': 5,
              'min_child_weight': 1,
              'gamma': 0.0,
              'silent': 1,
              'seed': 0,
              'eval_metric': 'auc',
              'njob':8
              }
    key = 'learning_rate'
    values = [0.05, 0.1]
    cv_result, best_model = xgb_grid_search_cv(params, key, values, dtrain)
    print('%s: %s' % (key, str(values)))
    print('n_round = %s' % str(cv_result['n_rounds']))
    print('mean_aucs = %s' % str(cv_result['mean_aucs']))
    Searching parameters: learning_rate [0.05, 0.1]
    learning_rate=0.05: n_round=52, mean_auc=0.534587. Time cost 78.1885s
    learning_rate=0.1: n_round=43, mean_auc=0.539724. Time cost 161.781s
    best_mean_auc = 0.539724
    best_round = 43
    best_params = {'colsample_bytree': 0.8, 'silent': 1, 'eval_metric': 'auc', 'eta': 0.1, 'learning_rate': 0.1, 'njob': 8, 'min_child_weight': 1, 'subsample': 0.8, 'seed': 0, 'objective': 'binary:logistic', 'max_depth': 5, 'gamma': 0.0, 'booster': 'gbtree'}
    learning_rate: [0.05, 0.1]
    n_round = [52, 43]
    mean_aucs = [0.53458660000000002, 0.53972360000000008]
    

    在上一个参数最优的基础上,寻找其他参数的最优值.虽然这样并没有完全进行 grid search,但是一般来说,结果不会太差,更重要的是节省时间。

    params = cv_result['best_params']
    key = 'max_depth'
    values = [3, 4, 5]
    cv_result, best_model = xgb_grid_search_cv(params, key, values, dtrain)
    print('%s: %s' % (key, str(values)))
    print('n_round = %s' % str(cv_result['n_rounds']))
    print('mean_aucs = %s' % str(cv_result['mean_aucs']))
    Searching parameters: max_depth [3, 4, 5]
    max_depth=3: n_round=42, mean_auc=0.537475. Time cost 68.5076s
    max_depth=4: n_round=43, mean_auc=0.537731. Time cost 159.202s
    max_depth=5: n_round=43, mean_auc=0.539724. Time cost 242.507s
    best_mean_auc = 0.539724
    best_round = 43
    best_params = {'colsample_bytree': 0.8, 'silent': 1, 'eval_metric': 'auc', 'learning_rate': 0.1, 'njob': 8, 'min_child_weight': 1, 'subsample': 0.8, 'eta': 0.1, 'objective': 'binary:logistic', 'seed': 0, 'max_depth': 5, 'gamma': 0.0, 'booster': 'gbtree'}
    max_depth: [3, 4, 5]
    n_round = [42, 43, 43]
    mean_aucs = [0.53747460000000002, 0.53773139999999997, 0.53972360000000008]
    
    # 使用 xgb_model.predict() 返回每个样本分为 正类 1 的概率
    y_pred_prob = best_model.predict(dtest)
    print(X_test.shape, y_pred_prob.shape)
    print(y_pred_prob[0])
    # 设置 pred_leaf=True, 返回每个样本在每棵树上的叶子的 ID
    y_pred_prob = best_model.predict(dtest, pred_leaf=True)
    print(X_test.shape, y_pred_prob.shape)
    print(y_pred_prob[0])
    (14720, 34) (14720,)
    0.0124127
    (14720, 34) (14720, 43)
    [ 0  0  0  0  0  0  0  0  0  0  0  1  1  3  3  3  3  7  7  3  3  8  1  7  3
      1 19  7 15 23 31 37 37 27 19 15 29 25 25 23 31 28 25]
    

    3. 将所有的数值特征转为 one-hot 类型,和原始的类别型特征进行拼接

    # 编码成 one-hot 类型的数据
    grd_enc = OneHotEncoder()
    # LR 分类器
    grd_lm = LogisticRegression()
    # 每棵树的叶子编码
    dall = xgb.DMatrix(features[:, :n_no_id], feature_names=col_no_id)
    all_leafs = best_model.predict(dall, pred_leaf=True)
    train_leafs = best_model.predict(dtrain, pred_leaf=True)
    test_leafs = best_model.predict(dtest, pred_leaf=True)
    
    # 使用所有特征确定编码规则
    grd_enc.fit(all_leafs)
    # one-hot 编码
    oh_train = grd_enc.transform(train_leafs).toarray()
    oh_test = grd_enc.transform(test_leafs).toarray()
    # 所有特征
    X_train_oh = np.hstack([oh_train, X_train[:, n_no_id:]])
    X_test_oh = np.hstack([oh_test, X_test[:, n_no_id:]])
    print('X_train_oh.shape=%s' % str(X_train_oh.shape))
    print('X_test_oh.shape=%s' % str(X_test_oh.shape))
    X_train_oh.shape=(58880, 492)
    X_test_oh.shape=(14720, 492)
    

    使用 LR 进行训练

    # 使用 LR 进行训练
    C_params = np.linspace(0.001, 0.05, 10)  # 线性划分参数,0.001--5 ,划分20等分  # 0.015  最好
    
    LR_aucs = []  # 存储cv值
    print(C_params)
    tic = time.time()
    for C_param in C_params:
        model = LogisticRegression(C = C_param, penalty='l2', max_iter=300)
        scores = cross_val_score(model, X_train_oh, y_train, cv=5, scoring='roc_auc')
        LR_aucs.append(scores.mean())
        print('C=%g, mean_auc = %g. Time passed %gs' % (C_param, scores.mean(), time.time() - tic))
    print("mean_aucs,", LR_aucs)
    print("参数,", params)
    best_index = LR_aucs.index(max(LR_aucs))
    print("最好的参数:", C_params[best_index])
    print("best_auc = %g" %  max(LR_aucs))
    
    # 使用最好的参数训练最后的模型
    LR = LogisticRegression(C=C_params[best_index], penalty='l2', max_iter=100)
    LR.fit(X_train_oh, y_train)
    [ 0.001       0.00644444  0.01188889  0.01733333  0.02277778  0.02822222
      0.03366667  0.03911111  0.04455556  0.05      ]
    C=0.001, mean_auc = 0.553148. Time passed 2.44328s
    C=0.00644444, mean_auc = 0.602253. Time passed 5.5303s
    C=0.0118889, mean_auc = 0.612432. Time passed 9.12239s
    C=0.0173333, mean_auc = 0.617869. Time passed 12.936s
    C=0.0227778, mean_auc = 0.62137. Time passed 16.7762s
    C=0.0282222, mean_auc = 0.62381. Time passed 20.8325s
    C=0.0336667, mean_auc = 0.626271. Time passed 24.9229s
    C=0.0391111, mean_auc = 0.627935. Time passed 29.262s
    C=0.0445556, mean_auc = 0.629926. Time passed 33.1962s
    C=0.05, mean_auc = 0.631066. Time passed 36.6805s
    mean_aucs, [0.55314761462526785, 0.60225338755439206, 0.61243187424031753, 0.61786885529608182, 0.62137038918338783, 0.62381028779844427, 0.62627065614627997, 0.62793456864639041, 0.62992609163644286, 0.63106630566612487]
    参数, {'colsample_bytree': 0.8, 'silent': 1, 'eval_metric': 'auc', 'eta': 0.1, 'learning_rate': 0.1, 'njob': 8, 'min_child_weight': 1, 'subsample': 0.8, 'seed': 0, 'objective': 'binary:logistic', 'max_depth': 5, 'gamma': 0.0, 'booster': 'gbtree'}
    最好的参数: 0.05
    best_auc = 0.631066
    
    
    
    
    
    LogisticRegression(C=0.050000000000000003, class_weight=None, dual=False,
              fit_intercept=True, intercept_scaling=1, max_iter=100,
              multi_class='ovr', n_jobs=1, penalty='l2', random_state=None,
              solver='liblinear', tol=0.0001, verbose=0, warm_start=False)
    

    最后进行预测

    下面 的 my_utils.get_auc() 函数请在我的另一篇博客中找到:二分类结果分析工具函数

    # 预测
    y_pred_prob = LR.predict_proba(X_test_oh)[:, 1]
    print(y_pred_prob[:10])
    # 绘制 ROC 曲线,计算 AUC
    roc_auc, fpr, tpr, thresholds = my_utils.get_auc(y_test, y_pred_prob, plot_ROC=True)
    [ 0.00334971  0.00522246  0.00536675  0.00698756  0.00590602  0.0045314
      0.00749942  0.00565166  0.0058966   0.00505731]
    

    这里写图片描述

    利用 GBDT+LR 融合的方案有很多好处,利用 GDBT 主要是发掘有区分度的 特征和特征组合
    - LR 模型无法实现特征组合,但是模型中特征组合很关键,依靠人工经验非常耗时而且不一定能有好的效果。利用 GBDT 可以自动发现有效的特征、特征组合。GBDT 每次迭代都是在减少残差的梯度方向上面新建一棵决策树,GBDT 的每个叶子结点对应一个路径,也就是一种组合方式。
    - 由于树的每条路径都是最小化均方误差等方法算出来的,得到的路径(特征组合)具有区分度不亚于人工经验

    参考:
    - 【总结】CTR预估中GBDT与LR融合方案

    展开全文
  • 模型融合

    2020-09-27 23:08:48
    模型融合1. 内容介绍1.1 stacking\blending详解2 代码示例2.1 平均:2.2 投票2.3 Stacking:2.4 blending总结 1. 内容介绍 将之前建模调参的结果进行模型融合。(模型融合一般用于A榜比赛的尾声和B榜比赛的全程)。 ...
  • 这是本人对模型融合代码合集,环境是python3,只要复制过去就可以用了,非常方便。 目录 1.交叉验证 1.1 原理 1.2 GridSearchCV 2.绘制学习曲线 3.stacking 3.1 stacking原理 3.2 代码实现不同版本的...
  • 先贴上一张经典的模型融合stack1的图: 网上关于模型融合stack的讲解已经很多了,这里推荐一些讲的很不错的资料,相信一看就懂: https://zhuanlan.zhihu.com/p/42229791 https://zhuanlan.zhihu.com/p/40693176 ...
  • 话不多说,直接上代码 1 def stacking_first(train, train_y, test): 2 savepath = './stack_op{}_dt{}_tfidf{}/'.format(args.option, args.data_type, args.tfidf) 3 os.makedirs(savepath, exist_ok=True...
  • 模型融合之stacking&blending原理及代码

    千次阅读 2018-09-07 16:29:45
    目录 ...模型融合的基本思想就是通过对多个单模型融合以提升整体性能。平常自己一般都使用最简单的方法,比如说对分类问题,采用voting,对回归问题,采用加权averaging。 今天简单介绍下stack...
  • Task5 模型融合

    2020-04-03 08:19:01
    模型融合1 模型融合1.1 模型融合目标1.2 内容介绍1.3 Stacking相关理论介绍1.3.1 什么是stacking1.3.2 如何进行 stacking1.3.3 Stacking的方法讲解2 代码示例回归\分类概率-融合:三级目录 1 模型融合 了解各种模型...
  • 这篇文章主要介绍模型融合及参数调优相关内容,以及《百面机器学习》上关于模型评估、集成相关内容,最后还有相关案例代码。 先放一张大家都比较熟悉的图: 这是模型选择的一个流程图,可以作为相关的参考。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 993
精华内容 397
关键字:

模型融合代码