精华内容
下载资源
问答
  • lightgbm回归模型分类模型基本框架

    千次阅读 2019-07-30 17:57:34
    lightgbm as lgb from sklearn import metrics from sklearn . model_selection import StratifiedKFold , KFold , RepeatedKFold import xgboost as xgb """ GridSearchCV 用法 param_grid =...
    #https://www.kaggle.com/kernels/scriptcontent/16357888/download
    import numpy as np
    import pandas as pd
    import time
    import matplotlib.pyplot as plt
    import seaborn as sns
    from tqdm import tqdm_notebook
    import lightgbm as lgb
    from sklearn import metrics
    from sklearn.model_selection import StratifiedKFold, KFold, RepeatedKFold
    import xgboost as xgb
    
    
    
    
    """
    GridSearchCV 用法
    param_grid = {
        'learning_rate': [0.01, 0.1, 1],
        'n_estimators': [20, 40]
    }
    gbm = GridSearchCV(estimator, param_grid)
    gbm.fit(X_train, y_train)
    print('Best parameters found by grid search are:', gbm.best_params_)
    """
    
    def fast_auc(y_true, y_prob):
        """
        fast roc_auc computation: https://www.kaggle.com/c/microsoft-malware-prediction/discussion/76013
        """
        y_true = np.asarray(y_true)
        y_true = y_true[np.argsort(y_prob)]
        nfalse = 0
        auc = 0
        n = len(y_true)
        for i in range(n):
            y_i = y_true[i]
            nfalse += (1 - y_i)
            auc += y_i * nfalse
        auc /= (nfalse * (n - nfalse))
        return auc
    
    def eval_auc(y_true, y_pred):
        """
        Fast auc eval function for lgb.
        """
        return 'auc', fast_auc(y_true, y_pred), True
    
    def group_mean_log_mae(y_true, y_pred, types, floor=1e-9):
        """
        Fast metric computation for this competition: https://www.kaggle.com/c/champs-scalar-coupling
        Code is from this kernel: https://www.kaggle.com/uberkinder/efficient-metric
        """
        maes = (y_true -y_pred).abs().groupby(types).mean()
        return np.log(maes.map(lambda x: max(x, floor))).mean()
    
    def train_model_regression(X, X_test, y, params, folds, model_type='lgb', eval_metric='mae', columns=None, plot_feature_importance=False, model=None,
                               verbose=10000, early_stopping_rounds=200, n_estimators=50000):
        """
        A function to train a variety of regression models.
        Returns dictionary with oof predictions, test predictions, scores and, if necessary, feature importances.
    
        :params: X - training data, can be pd.DataFrame or np.ndarray (after normalizing)
        :params: X_test - test data, can be pd.DataFrame or np.ndarray (after normalizing)
        :params: y - target
        :params: folds - folds to split data
        :params: model_type - type of model to use
        :params: eval_metric - metric to use
        :params: columns - columns to use. If None - use all columns
        :params: plot_feature_importance - whether to plot feature importance of LGB
        :params: model - sklearn model, works only for "sklearn" model type
    
        """
        columns = X.columns if columns is None else columns
        X_test = X_test[columns]
    
        # to set up scoring parameters
        metrics_dict = {'mae': {'lgb_metric_name': 'mae',
                                'catboost_metric_name': 'MAE',
                                'sklearn_scoring_function': metrics.mean_absolute_error},
                        'group_mae': {'lgb_metric_name': 'mae',
                                      'catboost_metric_name': 'MAE',
                                      'scoring_function': group_mean_log_mae},
                        'mse': {'lgb_metric_name': 'mse',
                                'catboost_metric_name': 'MSE',
                                'sklearn_scoring_function': metrics.mean_squared_error}
                        }
    
    
        result_dict = {}
    
        # out-of-fold predictions on train data
        oof = np.zeros(len(X))
    
        # averaged predictions on train data
        prediction = np.zeros(len(X_test))
    
        # list of scores on folds
        scores = []
        feature_importance = pd.DataFrame()
    
        # split and train on folds
        for fold_n, (train_index, valid_index) in enumerate(folds.split(X)):
            print(f'Fold {fold_n + 1} started at {time.ctime()}')
            if type(X) == np.ndarray:
                X_train, X_valid = X[columns][train_index], X[columns][valid_index]
                y_train, y_valid = y[train_index], y[valid_index]
            else:
                X_train, X_valid = X[columns].iloc[train_index], X[columns].iloc[valid_index]
                y_train, y_valid = y.iloc[train_index], y.iloc[valid_index]
    
            if model_type == 'lgb':
                model = lgb.LGBMRegressor(**params, n_estimators = n_estimators, n_jobs = -1)
                model.fit(X_train, y_train,
                          eval_set=[(X_train, y_train), (X_valid, y_valid)], eval_metric=metrics_dict[eval_metric]['lgb_metric_name'],
                          verbose=verbose, early_stopping_rounds=early_stopping_rounds)
    
                y_pred_valid = model.predict(X_valid)
                y_pred = model.predict(X_test, num_iteration=model.best_iteration_)
    
            if model_type == 'xgb':
                train_data = xgb.DMatrix(data=X_train, label=y_train, feature_names=X.columns)
                valid_data = xgb.DMatrix(data=X_valid, label=y_valid, feature_names=X.columns)
    
                watchlist = [(train_data, 'train'), (valid_data, 'valid_data')]
                model = xgb.train(dtrain=train_data, num_boost_round=20000, evals=watchlist, early_stopping_rounds=200, verbose_eval=verbose, params=params)
                y_pred_valid = model.predict(xgb.DMatrix(X_valid, feature_names=X.columns), ntree_limit=model.best_ntree_limit)
                y_pred = model.predict(xgb.DMatrix(X_test, feature_names=X.columns), ntree_limit=model.best_ntree_limit)
    
            if model_type == 'sklearn':
                model = model
                model.fit(X_train, y_train)
    
                y_pred_valid = model.predict(X_valid).reshape(-1 ,)
                score = metrics_dict[eval_metric]['sklearn_scoring_function'](y_valid, y_pred_valid)
                print(f'Fold {fold_n}. {eval_metric}: {score:.4f}.')
                print('')
    
                y_pred = model.predict(X_test).reshape(-1 ,)
    
            oof[valid_index] = y_pred_valid.reshape(-1 ,)
            if eval_metric != 'group_mae':
                scores.append(metrics_dict[eval_metric]['sklearn_scoring_function'](y_valid, y_pred_valid))
            else:
                scores.append(metrics_dict[eval_metric]['scoring_function'](y_valid, y_pred_valid, X_valid['type']))
    
            prediction += y_pred
    
            if model_type == 'lgb' and plot_feature_importance:
                # feature importance
                fold_importance = pd.DataFrame()
                fold_importance["feature"] = columns
                fold_importance["importance"] = model.feature_importances_
                fold_importance["fold"] = fold_n + 1
                feature_importance = pd.concat([feature_importance, fold_importance], axis=0)
    
        prediction /= folds.n_splits
    
        print('CV mean score: {0:.4f}, std: {1:.4f}.'.format(np.mean(scores), np.std(scores)))
    
        result_dict['oof'] = oof
        result_dict['prediction'] = prediction
        result_dict['scores'] = scores
    
        if model_type == 'lgb':
            if plot_feature_importance:
                feature_importance["importance"] /= folds.n_splits
                cols = feature_importance[["feature", "importance"]].groupby("feature").mean().sort_values(
                    by="importance", ascending=False)[:50].index
    
                best_features = feature_importance.loc[feature_importance.feature.isin(cols)]
    
                plt.figure(figsize=(16, 12))
                sns.barplot(x="importance", y="feature", data=best_features.sort_values(by="importance", ascending=False));
                plt.title('LGB Features (avg over folds)')
                plt.savefig('feature_importance.png')
    
                result_dict['feature_importance'] = feature_importance
    
        return result_dict
    
    def train_model_classification(X, X_test, y, params, folds, model_type='lgb', eval_metric='auc', columns=None,
                                   plot_feature_importance=False, model=None,
                                   verbose=10000, early_stopping_rounds=200, n_estimators=50000):
        """
        A function to train a variety of classification models.
        Returns dictionary with oof predictions, test predictions, scores and, if necessary, feature importances.
    
        :params: X - training data, can be pd.DataFrame or np.ndarray (after normalizing)
        :params: X_test - test data, can be pd.DataFrame or np.ndarray (after normalizing)
        :params: y - target
        :params: folds - folds to split data
        :params: model_type - type of model to use
        :params: eval_metric - metric to use
        :params: columns - columns to use. If None - use all columns
        :params: plot_feature_importance - whether to plot feature importance of LGB
        :params: model - sklearn model, works only for "sklearn" model type
        :params: verbose - parameters for gradient boosting models
        :params: early_stopping_rounds - parameters for gradient boosting models
        :params: n_estimators - parameters for gradient boosting models
    
        """
        columns = X.columns if columns == None else columns
        X_test = X_test[columns]
    
        # to set up scoring parameters
        metrics_dict = {'auc': {'lgb_metric_name': eval_auc,
                                'catboost_metric_name': 'AUC',
                                'sklearn_scoring_function': metrics.roc_auc_score},
                        }
    
        result_dict = {}
    
        # out-of-fold predictions on train data
        oof = np.zeros((len(X), len(set(y.values))))
    
        # averaged predictions on train data
        prediction = np.zeros((len(X_test), oof.shape[1]))
    
        # list of scores on folds
        scores = []
        feature_importance = pd.DataFrame()
    
        # split and train on folds
        for fold_n, (train_index, valid_index) in enumerate(folds.split(X)):
            print(f'Fold {fold_n + 1} started at {time.ctime()}')
            if type(X) == np.ndarray:
                X_train, X_valid = X[columns][train_index], X[columns][valid_index]
                y_train, y_valid = y[train_index], y[valid_index]
            else:
                X_train, X_valid = X[columns].iloc[train_index], X[columns].iloc[valid_index]
                y_train, y_valid = y.iloc[train_index], y.iloc[valid_index]
    
            if model_type == 'lgb':
                model = lgb.LGBMClassifier(**params, n_estimators=n_estimators, n_jobs=-1)
                model.fit(X_train, y_train,
                          eval_set=[(X_train, y_train), (X_valid, y_valid)],
                          eval_metric=metrics_dict[eval_metric]['lgb_metric_name'],
                          verbose=verbose, early_stopping_rounds=early_stopping_rounds)
    
                y_pred_valid = model.predict_proba(X_valid)
                y_pred = model.predict_proba(X_test, num_iteration=model.best_iteration_)
    
            if model_type == 'xgb':
                train_data = xgb.DMatrix(data=X_train, label=y_train, feature_names=X.columns)
                valid_data = xgb.DMatrix(data=X_valid, label=y_valid, feature_names=X.columns)
    
                watchlist = [(train_data, 'train'), (valid_data, 'valid_data')]
                model = xgb.train(dtrain=train_data, num_boost_round=n_estimators, evals=watchlist,
                                  early_stopping_rounds=early_stopping_rounds, verbose_eval=verbose, params=params)
                y_pred_valid = model.predict(xgb.DMatrix(X_valid, feature_names=X.columns),
                                             ntree_limit=model.best_ntree_limit)
                y_pred = model.predict(xgb.DMatrix(X_test, feature_names=X.columns), ntree_limit=model.best_ntree_limit)
    
            if model_type == 'sklearn':
                model = model
                model.fit(X_train, y_train)
    
                y_pred_valid = model.predict(X_valid).reshape(-1, )
                score = metrics_dict[eval_metric]['sklearn_scoring_function'](y_valid, y_pred_valid)
                print(f'Fold {fold_n}. {eval_metric}: {score:.4f}.')
                print('')
                y_pred = model.predict_proba(X_test)
    
            oof[valid_index] = y_pred_valid
            scores.append(metrics_dict[eval_metric]['sklearn_scoring_function'](y_valid, y_pred_valid[:, 1]))
    
            prediction += y_pred
    
            if model_type == 'lgb' and plot_feature_importance:
                # feature importance
                fold_importance = pd.DataFrame()
                fold_importance["feature"] = columns
                fold_importance["importance"] = model.feature_importances_
                fold_importance["fold"] = fold_n + 1
                feature_importance = pd.concat([feature_importance, fold_importance], axis=0)
    
        prediction /= folds.n_splits
    
        print('CV mean score: {0:.4f}, std: {1:.4f}.'.format(np.mean(scores), np.std(scores)))
    
        result_dict['oof'] = oof
        result_dict['prediction'] = prediction
        result_dict['scores'] = scores
    
        if model_type == 'lgb':
            if plot_feature_importance:
                feature_importance["importance"] /= folds.n_splits
                cols = feature_importance[["feature", "importance"]].groupby("feature").mean().sort_values(
                    by="importance", ascending=False)[:50].index
    
                best_features = feature_importance.loc[feature_importance.feature.isin(cols)]
    
                plt.figure(figsize=(16, 12))
                sns.barplot(x="importance", y="feature", data=best_features.sort_values(by="importance", ascending=False));
                plt.title('LGB Features (avg over folds)')
                plt.savefig('feature_importance.png')
    
                result_dict['feature_importance'] = feature_importance
    
        return result_dict
    
    
    def plot_oof_preds(ctype, llim, ulim, true, pred):
        plt.figure(figsize=(6, 6))
        sns.scatterplot(x=true, y=pred)
        plt.xlim((llim, ulim))
        plt.ylim((llim, ulim))
        plt.plot([llim, ulim], [llim, ulim])
        plt.xlabel('true')
        plt.ylabel('predicted')
        plt.title(f'{ctype}', fontsize=18)
        plt.savefig(f'{ctype}' + '.png')
    
    
    params = {'num_leaves': 128,
              'min_child_samples': 79,
              'objective': 'regression',
              'max_depth': 9,
              'learning_rate': 0.2,
              "boosting_type": "gbdt",
              "subsample_freq": 1,
              "subsample": 0.9,
              "bagging_seed": 11,
              "metric": 'mae',
              "verbosity": -1,
              'reg_alpha': 0.1,
              'reg_lambda': 0.3,
              'colsample_bytree': 1.0
             }
    
    
    X = pd.DataFrame()
    X_test = pd.DataFrame()
    y = pd.DataFrame()['true']
    
    n_fold = 3
    folds = KFold(n_splits=n_fold, shuffle=True, random_state=11)
    result_dict_lgb = train_model_regression(X=X, X_test=X_test, y=y, params=params, folds=folds, model_type='lgb', eval_metric='group_mae', plot_feature_importance=True,
                                                          verbose=500, early_stopping_rounds=200, n_estimators=5000)
    X_test['pred'] = result_dict_lgb['prediction']
    X_test.to_csv('submission.csv',index=False)
    X['oof'] = result_dict_lgb['oof']
    X.to_csv('oof.csv',index=False)
    plot_oof_preds('oof',llim=0,ulim=200,true=y,pred=result_dict_lgb['oof'])
    
    
    展开全文
  • 1.安装包:pip install lightgbm 2.整理好你的输数据 就拿我最近打的kaggle MLB来说数据整理成pandas格式的数据,如下图所示:(对kaggle有兴趣的可以加qq群一起交流:829909036) 输入特征 要预测的结果 3.整理...

    lgbm.LGBMRegressor使用方法

    1.安装包:pip install lightgbm

    2.整理好你的输数据

    就拿我最近打的kaggle MLB来说数据整理成pandas格式的数据,如下图所示:(对kaggle有兴趣的可以加qq群一起交流:829909036)
    输入特征
    在这里插入图片描述
    要预测的结果
    在这里插入图片描述

    3.整理模型

    def fit_lgbm(x_train, y_train, x_valid, y_valid,num, params: dict=None, verbose=100):
    	#判断是否有训练好的模型,如果有的话直接加载,否则重新训练
        if os.path.isfile(f'../input/mlb-models/model_{num}.pkl'):
            with open(f'../input/mlb-models/model_{num}.pkl', 'rb') as fin:
                model = pickle.load(fin)
        else:
            oof_pred = np.zeros(len(y_valid), dtype=np.float32)
            model = lgbm.LGBMRegressor(**params)
            model.fit(x_train, y_train, 
                eval_set=[(x_valid, y_valid)],  
                early_stopping_rounds=verbose, 
                verbose=verbose)
            #保存训练好的模型
            with open(f'model_{num}.pkl', 'wb') as handle:
                pickle.dump(model, handle, protocol=pickle.HIGHEST_PROTOCOL)
        oof_pred = model.predict(x_valid) #对验证集进行预测
        score = mean_absolute_error(oof_pred, y_valid)#将预测结果与真是结果进行比较
        print('mae:', score)
        return oof_pred, model, score
    
    #lightgbm训练的参数:注意,上面的(**params)中的**必须写
    params = {
    'boosting_type': 'gbdt',
    'objective':'mae',
    'n_jobs':8,
    'subsample': 0.5,
    'subsample_freq': 1,
    'learning_rate': 0.01,
    'num_leaves': 2**11-1,
    'min_data_in_leaf': 2**12-1,
    'feature_fraction': 0.5,
    'max_bin': 100,
    'n_estimators': 2500,
    'boost_from_average': False,
    "random_seed":1,
    }
    
    

    4.调用模型进行训练

    #将第一步整理的输入数据塞入模型即可
    oof1, model1, score1 = fit_lgbm(
        x_train1, y_train1['target1'],
        x_valid1, y_valid1['target1'],1,
        params
     )
    

    模型的参数选择:

    建议上官网:https://lightgbm.cn/

    在此处只给出粗略的解释:
    boosting_type:用于指定弱学习器的类型,默认值为 ‘gbdt’,表示使用基于树的模型进行计算。还可以选择为 ‘gblinear’ 表示使用线性模型作为弱学习器。
    其他的参数可以选择:
    ‘gbdt’,使用梯度提升树
    ‘rf’,使用随机森林
    ‘dart’,不太了解,官方解释为 Dropouts meet Multiple Additive Regression Trees
    ‘goss’,使用单边梯度抽样算法,速度很快,但是可能欠拟合。
    推荐设置为 'gbdt’

    objective:指定目标可选参数如下:
    “regression”,使用L2正则项的回归模型(默认值)。
    “regression_l1”,使用L1正则项的回归模型。
    “mape”,平均绝对百分比误差。
    “binary”,二分类。
    “multiclass”,多分类。
    num_class用于设置多分类问题的类别个数。

    min_child_samples:叶节点样本的最少数量,默认值20,用于防止过拟合。

    learning_rate / eta:LightGBM 不完全信任每个弱学习器学到的残差值,为此需要给每个弱学习器拟合的残差值都乘上取值范围在(0, 1] 的 eta,设置较小的 eta 就可以多学习几个弱学习器来弥补不足的残差。推荐的候选值为:[0.01, 0.015, 0.025, 0.05, 0.1]

    max_depth:指定树的最大深度,默认值为-1,表示不做限制,合理的设置可以防止过拟合。
    推荐的数值为:[3, 5, 6, 7, 9, 12, 15, 17, 25]。

    num_leaves:指定叶子的个数。

    feature_fraction / colsample_bytree:构建弱学习器时,对特征随机采样的比例,默认值为1。推荐的候选值为:[0.6, 0.7, 0.8, 0.9, 1]

    bagging_fraction / subsample:默认值1,指定采样出 subsample * n_samples 个样本用于训练弱学习器。注意这里的子采样和随机森林不一样,随机森林使用的是放回抽样,而这里是不放回抽样。 取值在(0, 1)之间,设置为1表示使用所有数据训练弱学习器。如果取值小于1,则只有一部分样本会去做GBDT的决策树拟合。选择小于1的比例可以减少方差,即防止过拟合,但是会增加样本拟合的偏差,因此取值不能太低。注意: bagging_freq 设置为非0值时才生效。推荐的候选值为:[0.6, 0.7, 0.8, 0.9, 1]

    bagging_freq / subsample_freq:数值型,默认值0,表示禁用样本采样。

    lambda_l1:L1正则化权重项,增加此值将使模型更加保守。推荐的候选值为:[0, 0.01~0.1, 1]

    lambda_l2:L2正则化权重项,增加此值将使模型更加保守。推荐的候选值为:[0, 0.1, 0.5, 1]

    min_gain_to_split / min_split_gain:指定叶节点进行分支所需的损失减少的最小值,默认值为0。设置的值越大,模型就越保守。推荐的候选值为:[0, 0.05 ~ 0.1, 0.3, 0.5, 0.7, 0.9, 1]

    min_sum_hessian_in_leaf / min_child_weight:指定子节点中最小的样本权重和,如果一个叶子节点的样本权重和小于min_child_weight则拆分过程结束,默认值为1。推荐的候选值为:[1, 3, 5, 7]

    metric
    用于指定评估指标,可以传递各种评估方法组成的list。常用的评估指标如下:
    ‘mae’,用于回归任务,效果与 ‘mean_absolute_error’, ‘l1’ 相同。
    ‘mse’,用于回归任务,效果与 ‘mean_squared_error’, ‘l2’ 相同。
    ‘rmse’,用于回归任务,效果与 ‘root_mean_squared_error’, ‘l2_root’ 相同。
    ‘auc’,用于二分类任务。
    ‘binary’,用于二分类任务。
    ‘binary_logloss’,用于二分类任务。
    ‘binary_error’,用于二分类任务。
    ‘multiclass’,用于多分类。
    ‘multi_logloss’, 用于多分类。
    ‘multi_error’, 用于多分类。
    seed / random_state 指定随机数种子。

    展开全文
  • JPMML-LightGBM Java库和命令行应用程序,用于将模型转换为PMML。 ...使用软件包为示例波士顿住房数据集训练回归模型: from sklearn . datasets import load_boston boston = load_boston () fr
  • You can find the full article here 来看一个比较特殊的Survival分析建模的案例,利用的是半参模型:Poisson Regression 具体可以看文章:Survival Analysis with LightGBM plus Poisson Regression ...

    You can find the full article here

    来看一个比较特殊的Survival分析建模的案例,利用的是半参模型:Poisson Regression
    具体参考文章:Survival Analysis with LightGBM plus Poisson Regression
    里面的建模思路非常有意思,不适合工业落地,不过咨询公司的data scientist看过来~


    1 Poisson Regression

    1.1 松泊分布与泊松回归

    参考:什么是松泊分布?泊松回归可以用来做什么?

    试想一下,你现在就站在一个人流密集的马路旁,打算收集闯红灯的人群情况(?)。
    首先,利用秒表和计数器,一分钟过去了,有5个人闯红灯;
    第二分钟有4个人;而下一分钟有4个人。
    持续记录下去,你就可以得到一个模型,这便是“泊松分布”的原型。

    除此以外,现实生活中还有很多情况是服从泊松分布的:

    • 10分钟内从ATM中取钱的人数
    • 一天中发生车祸的次数
    • 每100万人中患癌症的人数
    • 单位面积土地内昆虫的数目

    Poisson模型(泊松回归模型)是用于描述单位时间、单位面积或者单位容积内某事件发现的频数分布情况,
    通常用于描述稀有事件(即小概率)事件发生数的分布。

    上述例子中都明显的一个特点:
    低概率性,以及单位时间(或面积、体积)内的数量。
    通常情况下,满足以下三个条件时,可认为数据满足Poisson分布:

    • (1) 平稳性:发生频数的大小,只与单位大小有关系(比如1万为单位,或者100万为单位时患癌症人数不同);
    • (2) 独立性:发生频数的大小,各个数之间没有影响关系,即频数数值彼此独立没有关联关系;
      比如前1小时闯红灯的人多了,第2小时闯红灯人数并不会受影响;
    • (3) 普通性:发生频数足够小,即低概率性。

    如果数据符合这类特征时,而又想研究X对于Y的影响(Y呈现出Poisson分布);
    此时则需要使用Poisson回归,而不是使用常规的线性回归等。

    1.2 LightGBM 实现泊松回归的案例

    参考来源:https://github.com/Microsoft/LightGBM/issues/807

    import lightgbm as lgb
    import numpy as np
    import pandas as pd
    
    n=100000
    lam = .01
    X = np.floor(np.random.lognormal(size=(n,2))).astype(int)
    y = np.maximum(X[:,0],X[:,1])+np.random.poisson(lam=lam, size=n)
    
    train_inds = np.arange(int(n/3))
    val_inds =   np.arange(int(n/3), int(2*n/3))
    test_inds =   np.arange(int(2*n/3), int(n))
    
    X_test, y_test = X[test_inds,:], y[test_inds]
    
    ds = lgb.Dataset(X,y, categorical_feature=[1])
    
    ds_train = ds.subset(train_inds)
    ds_val = ds.subset(val_inds)
    
    params = {'objective':'poisson',
             'metric':'rmse',
             'learning_rate':.1
             }
    gbm = lgb.train(params, ds_train, num_boost_round=300, early_stopping_rounds=20, valid_sets=[ds_val, ds_train], 
                    verbose_eval=100, categorical_feature=[1])
    
    yhat = gbm.predict(X_test)
    print('neg obs:', len(yhat[yhat<0]))
    

    y是需要服从poisson分布的

    2 数据解读

    2.1 数据样式

    数据集解释:美国Washington, D.C.的一个共享单车公司
    数据来源:bike-sharing-dataset
    数据集的中文字段解释:
    参考:Capital Bikeshare (美国Washington, D.C.的一个共享单车公司)提供的自行车数据上进行回归分析
    具体实现 + 代码:Survival_LGBM-github

    # 字段说明Instant 记录号
    
    Dteday:日期
    Season:季节
        1=春天
        2=夏天
        3=秋天
        4=冬天
    yr:年份,(0: 2011, 1:2012)
    mnth:月份( 1 to 12)
    hr:小时 (0 to 23) (只在 hour.csv 有,作业忽略此字段)
    holiday:是否是节假日
    weekday:星期中的哪天,取值为 0~6
    workingday:是否工作日
        1=工作日 (非周末和节假日)
        0=周末
    weathersit:天气
    1:晴天,多云
    2:雾天,阴天
    3:小雪,小雨
    4:大雨,大雪,大雾
    temp:气温摄氏度
    atemp:体感温度
    hum:湿度
    windspeed:风速
    
    y值
    -   casual:非注册用户个数
    -  registered:注册用户个数
    -  cnt:给定日期(天)时间(每小时)总租车人数,响应变量 y
    

    在这里插入图片描述

    现在数据变成:
    在这里插入图片描述

    也就是把第一行数据,拆分成330行,新增了两列:

    • count_so_far就是人员计数从[0,1,2,3,4,6,…,330],
    • stop,就是人数终止计数

    这样构造的一个特殊的数据结构,造就了该模型object的独特,原文自评:

    We solve a not classical survival problem where we have not to estimate the probability of surviving past time, but we estimate the probability that a specific event occurs at the end of the day. This is a simple example but it shows how to applicate survival modeling techniques, with classical instruments, in a not common scenario where our duty is to estimate a probability density function.

    这里就把问题变成了,2011/1/1 这天,
    在casual users = 0的时候,不会停止增长;在casual users = 1,不会停止增长;…;在casual users = 330,停止增长
    最后,如何来预测临时用户的人数?
    用的是一个“可能在什么数量上停止”的曲线,这里是把 hazard = 临时用户的增长量,会拟合一个达到预测数值的可能性趋势。

    在这里插入图片描述

    这里跟生存分析 以及常规回归的差异:

    • 常规回归模型,y~x1+x2… 根据特征直接预测临时用户人数,点估计;这里的Poisson有点类似加强版区间估计,就叫趋势估计?
    • 生存分析,
      • 生存函数使用的是KM曲线,计算不同生存时间区间下的存活率;
      • 风险函数,计算不同生存时间区间下的风险值

    2.2 衡量模型指标

    2.2.1 CRPS

    我们对结果的评价是用这种任务的标准分数来进行的。连续排序概率评分(Continuous ranking Probability Score, CRPS)将MAE推广到概率预测的情况。
    在这里插入图片描述

    在涉及概率预测的情况下,CPRS是应用最广泛的精度指标之一。它需要对所涉及的整个概率函数进行评估,因此需要对每个每日样本的整个生存曲线进行估计。

    PDF / CDF

    • 概率密度函数probability density function(pdf)

    在这里插入图片描述

    • 累积分布函数(Cumulative Distribution Function),又叫分布函数
      在这里插入图片描述

    2.2 训练与解读

    数据的延展:

    ### EXPAND TRAIN DATA ###
    
    X_train['count_so_far'] = X_train.apply(lambda x: np.arange(x.casual), axis=1)
    X_train['stop'] = X_train.apply(lambda x: np.append(np.zeros(x.casual-1), 1), axis=1)
    X_train = X_train.apply(pd.Series.explode)   # 数据扩充的方式
    
    X_train['count_so_far'] = X_train.count_so_far.astype(int)
    X_train['stop'] = X_train.stop.astype(int)
    
    y_train = X_train['stop']
    X_train = X_train[columns+['count_so_far']]
    
    print(X_train.shape)
    X_train
    
    ### EXPAND VALID DATA FOR PREDICTION ###
    
    X_val_surv = df[(df.dteday >= datetime(year=2012, month=1, day=1))&(df.dteday < datetime(year=2012, month=5, day=1))].copy()
    
    X_val_surv['count_so_far'] = X_val_surv.apply(lambda x: np.arange(max_count), axis=1)
    X_val_surv['stop'] = X_val_surv.apply(lambda x:np.append(np.zeros(x.casual), np.ones(max_count-x.casual)), axis=1)
    X_val_surv = X_val_surv.apply(pd.Series.explode)
    
    X_val_surv['count_so_far'] = X_val_surv.count_so_far.astype(int)
    X_val_surv['stop'] = X_val_surv.stop.astype(int)
    
    y_val_surv = X_val_surv['stop']
    X_val_surv = X_val_surv[columns+['count_so_far']]
    
    print(X_val_surv.shape)
    
    

    具体的已经在2.1 描述过了;这里要额外来看一下max_count,这个在train数据集中不会出现,
    也就是今天有多少临时用户,就是多少X_train.apply(lambda x: np.arange(x.casual), axis=1)
    但你会看到,X_val_surv是X_val_surv.apply(lambda x: np.arange(max_count), axis=1),这里就是临时用户的最大值设定为4000,这个值根据临时用户max值来取的,就是临时用户上线。

    params = {
             'objective':'poisson',
             'num_leaves':30, 
             'learning_rate': 0.001,
             'feature_fraction': 0.8,
             'bagging_fraction': 0.9,
             'bagging_seed': 33,
             'poisson_max_delta_step': 0.8,
             'metric': 'poisson'
             }
    
    ### FIT LGBM WITH POISSON LOSS ### 
    
    trn_data = lgb.Dataset(X_train, label=y_train)
    val_data = lgb.Dataset(X_val, label=y_val)
    
    model = lgb.train(params, trn_data, num_boost_round=1000,
                      valid_sets = [trn_data, val_data],
                      verbose_eval=50, early_stopping_rounds=150)
    

    这里X_train的shape为:(247252, 13),那么可以知道训练集是非常大的;
    需要重置数据,可到:

    ### PREDICT HAZARD FUNCTION ON VALIDATION DATA AND TRANSFORM TO SURVIVAL ###
    
    p_val_hz = model.predict(X_val_surv).reshape(-1,max_count)
    p_val = 1-np.exp(-np.cumsum(p_val_hz, axis=1))
    X_val_surv.shape
    >>> (484000, 12)
    p_val.shape
    >>> (121, 4000)
    

    p_val就回归正常,代表着每一天,不同人群数量的概率,直接上图:
    在这里插入图片描述
    这天在500左右,达到峰值了,那么这天临时用户的预测值就在500左右了。

    简单的模型检验:

    ### CRPS ON VALIDATION DATA ###
    crps(t_val, p_val)
    >>> 0.17425293919055515
    ### CRPS ON VALIDATION DATA WITH BASELINE MODEL ###
    crps(t_val, np.repeat(cdf, len(t_val)).reshape(-1,max_count))
    

    3 同等lightGBM分类测试

    https://blog.csdn.net/wang263334857/article/details/81836578

    来看一下同一份数据测试出来的结果如何,后续不贴太多,只贴一下我测试的代码,放在了之前的一个项目下面:Survival_Poisson_Regression

    展开全文
  • LightGBM

    2021-09-30 20:54:27
    wise决策树生长策略(二)直方图算法(三)GOSS算法(四)EFB算法(五)并行学习三、LightGBM算法的简单代码实现(一)安装LightGBM(二)演示LightGBM分类模型和回归模型(三)案例1、模型搭建2、参数调优 ...


    前言

    LightGBM是由微软公司开发的,属于Boosting算法的一种,官方文档地址是: https://lightgbm.readthedocs.io.
    LightGBM是XGBoost升级版本,用于许多商业实战中,例如客户违约预测模型,广告收益回归预测模型等。

    一、LightGBM算法的设计理念

    LightGBM采用分布式的GBDT,选择了基本直方图的决策树算法

    项目XGBoostLightGBM
    训练速度
    内存消耗
    预测精度相当相当
    分类特征不支持类别特征,需要OneHot编码处理直接支持类别特征

    相比于XGBoost的优势:

    • 降低计算每次拆分增益的成本
    • 使用减法直方图进一步加速
    • 降低内存使用
    • 降低并行学习的通信成本

    二、LightGBM算法的数学原理概述

    LightGBM = XGBoost + Histogram + GOSS + EFB

    • Histogram算法:直方图算法(减少候选分类点数量)
    • GOSS算法:基于梯度的单边采样算法(作用是减少样本的数量)
    • EFB算法:互斥特征捆绑算法(作用是减少特征数量)

    通过以上3个算法的引入,LightGBM生成一片叶子需要的复杂度大大降低了,从而极大的节约了计算成本,同时Histogram算法还将特征由浮点数转换成0~255位的整数进行存储。从而极大的节约了内存存储。

    (一)基于leaf-wise决策树生长策略

    对于大部分决策树算法使用的是level-wise生长策略,即同一层的叶子节点每次都一起分裂,但实际上一些叶子节点的分裂增益较低,这样分裂会增加不少开销,如图所示:
    在这里插入图片描述
    LightGBM是使用leaf-wise策略,每一次在当前叶子节点中,找出分列增益最大的叶子节点进行分裂,而不是所有节点都进行分裂,这样可以提高精度,如下图所示:
    在这里插入图片描述

    (二)直方图算法

    直方图算法是代替XGBoost的预排序(pre-sorted)算法的。
    首先需要了解直方图的基本概念:直方图分为频数直方图和频率直方图,横坐标为相关数据,纵坐标是该数据出现的频数或频率,通过 hist() 函数绘制直方图。

    直方图算法,也叫作histogram算法,简单来说,就是先对特征值进行装箱处理,把连续的浮点特征值离散化成k个整数,形成一个一个的箱体(bins),同时构造一个宽度为k的直方图,在遍历数据的时候,根据离散化后的值作为索引在直方图中累积统计量(因此这里是频数直方图),当遍历一次数据后,直方图累积了需要的统计量,然后根据直方图的离散值,遍历寻找最优的分割点。

    对于连续特征来说,装箱处理就是特征工程中的离散化:如[0,10)区间的值都可以赋值为0,[10,20)区间的值都可以赋值为1等,这样就可以把众多的数值划分到有限的分箱中,在Lightgbm中默认的分箱数(bins)为256(该数也可以设置)。

    例子:
    现在有10000个客户,也就有10000个身高,将身高分箱为256份后(例如180cm-180.2cm的所有客户都分箱为数字200),就变为256个数字,这时再统计每个数值对应的频数(例如180cm-180.2cm的客户为100人,那数字200对应的频数就是100)。这样在节点分裂的时候,对于每个特征都计算10000遍(所有的样本数量)了,而是只需要计算256遍(分箱数),这样就大大加快了训练速度。

    (三)GOSS算法

    单边梯度采样GOSS算法(Gradient-based One-Side Sampling):通过对样本采样的方法来减少计算目标函数增益时候的复杂度。

    GOSS算法中,梯度更大的样本点在计算信息增益时会占有更重要的作用,当我们对样本进行下采样的时候保留这些梯度较大的样本点,并随机去掉梯度小的样本。

    怎样保证信息损失降到最低:
    首先把样本按照梯度排序,选出梯度最大的a%个样本,然后在剩下小梯度数据中随机选取b%个样本,在计算信息增益的时候,将选出来的b%小梯度样本的信息增益扩大1-a/b的倍数。

    (四)EFB算法

    EFB算法(Exclusive Feature Bundling),即互斥特征绑定算法。

    • EFB算法则将互斥特征绑在一起以减少特征维度
    • EFB算法可以有效减少用于构建直方图的特征数量,从而降低计算复杂度,尤其是特征中包含大量稀疏特征的时候

    LightGBM可以直接将每个类别取值和一个bin关联,从而自动地处理它们,而无需预处理成onehot编码

    (五)并行学习

    LightGBM支持特征并行数据并行两种。传统的特征并行主要思想是在并行化决策树中寻找最佳切分点,在数据量大时难以加速,同时需要对切分结果进行通信整合。

    LightGBM则是使用分散规约(Reduce scatter),它将直方图合并的任务分给不同的机器,降低通信和计算的开销,并利用直方图做加速训练,进一步成少开销。

    三、LightGBM算法的简单代码实现

    (一)安装LightGBM

    LightGBM模型的安装办法可以采取PIP安装法,以Windows操作系统为例,Win+R快捷键调出运行框,输入cmd后,在弹出界面中输入代码后Enter键回车运行即可:pip install lightgbm

    如在Jupyter Notebook编辑器中,运行下列代码!pip install lightgbm

    (二)演示LightGBM分类模型和回归模型

    X = [[1,2],[3,4],[5,6],[7,8],[9,10]]
    y = [1,2,3,4,5]
    from lightgbm import LGBMClassifier
    model = LGBMClassifier() #分类模型
    
    from lightgbm import LGBMRegressor
    model = LGBMRegressor() #回归模型
    
    model.fit(X,y)
    

    (三)案例

    案例背景:智能风控、大数据风控
    银行等金融机构经常会根据客户的个人资料、财产等情况,来预测借款客户是否会违约,从而进行贷前审核,贷中管理,贷后违约处理等工作。金融处理的就是风险,需要在风险和收益间寻求到一个平衡点,现代金融某种程度上便是一个风险定价的过程,通过个人的海量数据,从而对其进行风险评估并进行合适的借款利率定价,这便是一个典型的风险定价过程,这也被称之为大数据风控。

    1、模型搭建

    1. 读取数据
    2. 提取特征变量和目标变量
    3. 划分训练集和测试集
    4. 模型训练和搭建
    5. 模型预测及评估
    #1、读取数据
    import pandas as pd
    df = pd.read_excel('客户信息及违约表现.xlsx')
    
    #2、提取特征变量和目标变量
    X = df.drop(columns='是否违约')
    Y = df['是否违约']
    
    #3、划分训练集和测试集
    from sklearn.model_selection import train_test_split
    X_train,X_test,y_train,y_test = train_test_split(X,Y,test_size=0.2,random_state=123)
    
    #4、模型训练和搭建
    from lightgbm import LGBMClassifier
    model = LGBMClassifier() #分类模型
    model.fit(X_train,y_train)
    
    #5、模型预测及评估
    y_pred = model.predict(X_test)
    a = pd.DataFrame()#创建一个空的DataFrame
    a['预测值'] = list(y_pred)
    a['实际值'] = list(y_test)
    from sklean.metrics import accuracy_score
    score = accuracy_score(y_pred,y_test)
    model.score(X_test,y_test)#模型准确度评分
    #绘制ROC曲线来评估模型预测效果
    y_pred_proba = model.predict_proba(X_test)
    from sklean.metrics import roc_curve
    fpr,tpr,thres = roc_curve(y_test,y_pred_proba[:,1])
    import matplotlib.pyplot as plt
    plt.plot(fpr,tpr)
    plt.show()
    #求AUC值
    from sklean.metrics import roc_auc_score
    score = roc_auc_score(y_test.values,y_pred_proba[:,1])
    
    features = X.columns#获取特征名称
    importances = model.feature_importances_#获取特征重要性
    #通过二维表格显示
    importances_df = pd,DataFrame()
    importances_df['特征名称'] = features
    importances_df['特征重要性'] = importances
    importances_df.sort_values('特征重要性',ascending=False)
    
    

    2、参数调优

    了解了基本的参数后,我们需要对参数进行调优,使用网格搜索交叉验证的方法进行参数调优

    from sklearn.model_selection import GridSearchCV 
    parameters = ['num_leaves':[10,15,31],'n_estimators':[10,20,30],'learning_rate':[0.05,0.1,0.2]}
    model = LGBMCLassifier()
    grid_search = GridSearchCV(model,parameters,scoring='roc_auc',cv=5)
    grid_search.fit(X_train,y_train)#传入数据
    grid_search.best_params_#输出参数的最优值
    #结果{'Learning-rate':0.1,'n-estimators':20,'num-leaves':15]
    
    展开全文
  • 学习笔记(四)xgboost和lightgbm模型建立 数据是金融数据,我们要做的是预测贷款用户是否会逾期,表格中,status是标签:0表示未逾期,1表示逾期。构建xgboost和lightgbm进行预测(在构建部分数据需要进行缺失值...
  • 1. 简介 内心一直想把自己前一...我将从三个部分介绍数据挖掘类比赛中常用的一些方法,分别是lightgbm、xgboost和keras实现的mlp模型,分别介绍他们实现的二分类任务、多分类任务和回归任务,并给出完整的开源pytho...
  • lightgbm做二分类,多分类以及回归任务(含python源码) 1. 简介 内心一直想把自己前一段时间写的代码整理一下,梳理一下知识点,方便以后查看,同时也方便和大家交流。希望我的分享能帮助到一些小白用户快速前进,...
  • LightGBM原生接口----分类模型 import lightgbm as lgb from sklearn.metrics import accuracy_score from sklearn.datasets import load_iris from sklearn.model_selection import train_test_split import numpy ...
  • 机器学习之lightGBM模型

    千次阅读 2020-09-03 09:25:53
    一、lightGBM模型介绍 1. lightGBM模型简介 lightGBM模型是一个梯度提升决策树(GBDT)的实现,其本质原理就是利用基分类器(决策树)训练集成,得到最优的模型。相同的模型还有XGBoost,但因为XGBoost模型在多维度的...
  • LightGBM算法总结

    万次阅读 多人点赞 2018-08-21 18:39:47
    1 LightGBM原理 1.1 GBDT和 LightGBM对比 ​ GBDT (Gradient Boosting Decision Tree) 是机器学习中一个长盛不衰的模型,其主要思想是利用弱分类器(决策树)迭代训练以得到最优模型,该模型具有训练效果好、...
  • LightGBM使用pdf

    2020-10-19 09:51:32
    LightGBM使用pdf
  • LightGBM参数

    2021-08-05 11:54:07
    参考:...LightGBM的优点 lightgbm是xgboost的加强升级版. LightGBM=XGBoost+Histogram+GOSS+EFB 其中,Histogram算法是直方图算法,作用:减少后选分类点的算法 GOSS是基于梯度的单边采样算法
  • lightgbm

    2021-04-03 14:08:57
    GBDT模型的另一个进化版本:LightGBM。LigthGBM是boosting集合模型中的新进成员,由微软提供,它和XGBoost一样是对GBDT的高效实现,原理上它和GBDT及XGBoost类似,都采用损失函数的负梯度作为当前决策树的残差近似值...
  • 三、LightGBM参数解释 1.核心参数 2.学习控制参数 3.度量函数 四、LightGBM调参示例 五、XGBoost和LightGBM调参核心 调参方向:处理过拟合(过拟合和准确率往往相反) 调参范围 六、RandomForest参数解释 1...
  • python|LightGBM模型

    千次阅读 2020-06-15 15:36:49
    # -*- coding: utf-8 -*- """ Created on Fri Jun 12 16:20...import lightgbm as lgb from sklearn.model_selection import train_test_split from sklearn.metrics import * from sklearn.datasets import load_iri.
  • Lightgbm基本原理介绍

    万次阅读 多人点赞 2018-09-22 22:52:58
    一、 前言 最近在做Kaggle比赛的...所以就对Lightgbm的原理探了个究竟,这里就对Lightgbm论文的理解以及对官网上对Lightgbm的介绍做一个学习笔记。 传统的boosting算法(如GBDT和XGBoost)已经有相当好的效率,...
  • 数据竞赛-“达观杯”文本智能处理-Day5:LightGBM模型1.理论学习2.实践 【Task3.2】LightGBM模型 构建LightGBM模型(包括:模型构建&调参&性能评估),学习理论并用Task2的特征实践 要求:理论+代码+截图...
  • 今日表情 ????Spark-scala 可以使用LightGBM模型,既可以进行分布式训练,也可以进行分布式预测,支持各种参数设置。支持模型保存,并且保存后的模型和Python等语...
  • LightGBM学习

    2021-03-29 17:33:52
    LightGBM模型介绍数学原理概述 BUPT_RZK 模型介绍 它的出现是为了解决一般损失函数的优化问题,方法是用损失函数的负梯度在当前模型的值来模拟回归问题中残差的近似值。 简单的说,lightGBM 不需要通过所有的样本...
  • LightGBM评分卡

    2021-03-20 17:29:47
    lightGBM跨时间交叉验证.选择比较重要的特征,这些特征是禁得起跨时间交叉验证 逻辑回归/xgboost/lightgbm,线上跑lr模型,线下xgboost/lightgbm,上线之后需要监控不同信用分段的人群分布情况
  • LightGBM是2017年初Microsoft开源的高效快速、分布式学习的梯度提升树算法,可以用于分类、回归和排序。相对比陈天奇开发的XGBoost算法,更加快速、内存消耗少。 将分几个部分来介绍: 监督学习基础 梯度提升树算法...
  • python LightGBM分类 代码

    2021-10-22 22:35:29
    python LightGBM分类 代码 安装lightgbm包 pip install lightgbm LightGBM分类代码 #LightGBM分类 import pandas as pd from lightgbm.sklearn import LGBMClassifier # 导入LGBMClassifier函数 from sklearn....
  • python 实现lightgbm 训练及模型预测

    千次阅读 2020-11-27 19:56:23
    使用训练好的lightgbm对测试集打分,并保留预测结果。 # coding:utf-8 import pandas as pd import lightgbm as lgb import sys THRESHOLD = 0.28 # 设定截断阈值 data_input_path = sys.argv[1] # 数据输入路径 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,939
精华内容 1,575
关键字:

lightgbm回归模型