【集成学习】lightgbm入门及模板

最新推荐文章于 2023-10-26 10:06:56 发布
最新推荐文章于 2023-10-26 10:06:56 发布
阅读量1.7k 收藏 29
点赞数 5
分类专栏： 机器学习和自然语言处理相关 文章标签： lgb 集成学习 算法比赛 杀器

转载自：https://www.cnblogs.com/wanglei5205/
以后会补充自己的东西的～

安装LGB

pip install lightgbm

验证是否安装成功：

import lightgbm as lgb

使用案例

#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Sat Mar 31 21:19:09 2018

@author: hello4720
"""
import numpy as np
import pandas as pd
import lightgbm as lgb
from sklearn import metrics
from sklearn.model_selection import train_test_split

### 读取数据
print("载入数据")
dataset1 = pd.read_csv('G:/ML/ML_match/IJCAI/data3.22/3.22ICJAI/data/7_train_data1.csv')
dataset2 = pd.read_csv('G:/ML/ML_match/IJCAI/data3.22/3.22ICJAI/data/7_train_data2.csv')
dataset3 = pd.read_csv('G:/ML/ML_match/IJCAI/data3.22/3.22ICJAI/data/7_train_data3.csv')
dataset4 = pd.read_csv('G:/ML/ML_match/IJCAI/data3.22/3.22ICJAI/data/7_train_data4.csv')
dataset5 = pd.read_csv('G:/ML/ML_match/IJCAI/data3.22/3.22ICJAI/data/7_train_data5.csv')

dataset1.drop_duplicates(inplace=True)
dataset2.drop_duplicates(inplace=True)
dataset3.drop_duplicates(inplace=True)
dataset4.drop_duplicates(inplace=True)
dataset5.drop_duplicates(inplace=True)

### 数据合并
print("数据合并")
trains = pd.concat([dataset1,dataset2],axis=0)
trains = pd.concat([trains,dataset3],axis=0)
trains = pd.concat([trains,dataset4],axis=0)

online_test = dataset5

### 数据拆分
print("数据拆分")
train_xy,offline_test = train_test_split(trains, test_size = 0.2,random_state=21)
train,val = train_test_split(train_xy, test_size = 0.2,random_state=21)

print("训练集")
y = train.is_trade                                                  # 训练集标签
X = train.drop(['instance_id','is_trade'],axis=1)                   # 训练集特征矩阵

print("验证集")
val_y = val.is_trade                                                # 验证集标签
val_X = val.drop(['instance_id','is_trade'],axis=1)                 # 验证集特征矩阵

print("测试集")
offline_test_X=offline_test.drop(['instance_id','is_trade'],axis=1) # 线下测试特征矩阵
online_test_X=online_test.drop(['instance_id'],axis=1)              # 线上测试特征矩阵

### 数据转换
lgb_train = lgb.Dataset(X, y, free_raw_data=False)
lgb_eval = lgb.Dataset(val_X, val_y, reference=lgb_train,free_raw_data=False)

### 开始训练
print('设置参数')
params = {
            'boosting_type': 'gbdt',
            'boosting': 'dart',
            'objective': 'binary',
            'metric': 'binary_logloss',

            'learning_rate': 0.01,
            'num_leaves':25,
            'max_depth':3,

            'max_bin':10,
            'min_data_in_leaf':8,

            'feature_fraction': 0.6,
            'bagging_fraction': 1,
            'bagging_freq':0,

            'lambda_l1': 0,
            'lambda_l2': 0,
            'min_split_gain': 0
}

print("开始训练")
gbm = lgb.train(params,                     # 参数字典
                lgb_train,                  # 训练集
                num_boost_round=2000,       # 迭代次数
                valid_sets=lgb_eval,        # 验证集
                early_stopping_rounds=30)   # 早停系数
### 线下预测
print ("线下预测")
preds_offline = gbm.predict(offline_test_X, num_iteration=gbm.best_iteration) # 输出概率
offline=offline_test[['instance_id','is_trade']]
offline['preds']=preds_offline
offline.is_trade = offline['is_trade'].astype(np.float64)
print('log_loss', metrics.log_loss(offline.is_trade, offline.preds))

### 线上预测
print("线上预测")
preds_online =  gbm.predict(online_test_X, num_iteration=gbm.best_iteration)  # 输出概率
online=online_test[['instance_id']]
online['preds']=preds_online
online.rename(columns={'preds':'predicted_score'},inplace=True)
online.to_csv("./data/20180405.txt",index=None,sep=' ')

### 保存模型
from sklearn.externals import joblib
joblib.dump(gbm,'gbm.pkl')

### 特征选择
df = pd.DataFrame(X.columns.tolist(), columns=['feature'])
df['importance']=list(gbm.feature_importance())
df = df.sort_values(by='importance',ascending=False)
df.to_csv("./data/feature_score_20180405.csv",index=None,encoding='gbk')

lightgbm参数介绍（sklearn）

在这里插入图片描述

lightgbm调参案例

# -*- coding: utf-8 -*-
"""
# 作者：wanglei5205
# 邮箱：wanglei5205@126.com
# 博客：http://cnblogs.com/wanglei5205
# github：http://github.com/wanglei5205
"""
### 导入模块
import numpy as np
import pandas as pd
import lightgbm as lgb
from sklearn import metrics

### 载入数据
print('载入数据')
dataset1 = pd.read_csv('G:/ML/ML_match/IJCAI/data3.22/3.22ICJAI/data/7_train_data1.csv')
dataset2 = pd.read_csv('G:/ML/ML_match/IJCAI/data3.22/3.22ICJAI/data/7_train_data2.csv')
dataset3 = pd.read_csv('G:/ML/ML_match/IJCAI/data3.22/3.22ICJAI/data/7_train_data3.csv')
dataset4 = pd.read_csv('G:/ML/ML_match/IJCAI/data3.22/3.22ICJAI/data/7_train_data4.csv')
dataset5 = pd.read_csv('G:/ML/ML_match/IJCAI/data3.22/3.22ICJAI/data/7_train_data5.csv')

print('数据去重')
dataset1.drop_duplicates(inplace=True)
dataset2.drop_duplicates(inplace=True)
dataset3.drop_duplicates(inplace=True)
dataset4.drop_duplicates(inplace=True)
dataset5.drop_duplicates(inplace=True)

print('数据合并')
trains = pd.concat([dataset1,dataset2],axis=0)
trains = pd.concat([trains,dataset3],axis=0)
trains = pd.concat([trains,dataset4],axis=0)

online_test = dataset5

### 数据拆分(训练集+验证集+测试集)
print('数据拆分')
from sklearn.model_selection import train_test_split
train_xy,offline_test = train_test_split(trains,test_size = 0.2,random_state=21)
train,val = train_test_split(train_xy,test_size = 0.2,random_state=21)

# 训练集
y_train = train.is_trade                                               # 训练集标签
X_train = train.drop(['instance_id','is_trade'],axis=1)                # 训练集特征矩阵

# 验证集
y_val = val.is_trade                                                   # 验证集标签
X_val = val.drop(['instance_id','is_trade'],axis=1)                    # 验证集特征矩阵

# 测试集
offline_test_X = offline_test.drop(['instance_id','is_trade'],axis=1)  # 线下测试特征矩阵
online_test_X  = online_test.drop(['instance_id'],axis=1)              # 线上测试特征矩阵

### 数据转换
print('数据转换')
lgb_train = lgb.Dataset(X_train, y_train, free_raw_data=False)
lgb_eval = lgb.Dataset(X_val, y_val, reference=lgb_train,free_raw_data=False)

### 设置初始参数--不含交叉验证参数
print('设置参数')
params = {
          'boosting_type': 'gbdt',
          'objective': 'binary',
          'metric': 'binary_logloss',
          }

### 交叉验证(调参)
print('交叉验证')
min_merror = float('Inf')
best_params = {}

# 准确率
print("调参1：提高准确率")
for num_leaves in range(20,200,5):
    for max_depth in range(3,8,1):
        params['num_leaves'] = num_leaves
        params['max_depth'] = max_depth

        cv_results = lgb.cv(
                            params,
                            lgb_train,
                            seed=2018,
                            nfold=3,
                            metrics=['binary_error'],
                            early_stopping_rounds=10,
                            verbose_eval=True
                            )

        mean_merror = pd.Series(cv_results['binary_error-mean']).min()
        boost_rounds = pd.Series(cv_results['binary_error-mean']).argmin()

        if mean_merror < min_merror:
            min_merror = mean_merror
            best_params['num_leaves'] = num_leaves
            best_params['max_depth'] = max_depth

params['num_leaves'] = best_params['num_leaves']
params['max_depth'] = best_params['max_depth']

# 过拟合
print("调参2：降低过拟合")
for max_bin in range(1,255,5):
    for min_data_in_leaf in range(10,200,5):
            params['max_bin'] = max_bin
            params['min_data_in_leaf'] = min_data_in_leaf

            cv_results = lgb.cv(
                                params,
                                lgb_train,
                                seed=42,
                                nfold=3,
                                metrics=['binary_error'],
                                early_stopping_rounds=3,
                                verbose_eval=True
                                )

            mean_merror = pd.Series(cv_results['binary_error-mean']).min()
            boost_rounds = pd.Series(cv_results['binary_error-mean']).argmin()

            if mean_merror < min_merror:
                min_merror = mean_merror
                best_params['max_bin']= max_bin
                best_params['min_data_in_leaf'] = min_data_in_leaf

params['min_data_in_leaf'] = best_params['min_data_in_leaf']
params['max_bin'] = best_params['max_bin']

print("调参3：降低过拟合")
for feature_fraction in [0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]:
    for bagging_fraction in [0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]:
        for bagging_freq in range(0,50,5):
            params['feature_fraction'] = feature_fraction
            params['bagging_fraction'] = bagging_fraction
            params['bagging_freq'] = bagging_freq

            cv_results = lgb.cv(
                                params,
                                lgb_train,
                                seed=42,
                                nfold=3,
                                metrics=['binary_error'],
                                early_stopping_rounds=3,
                                verbose_eval=True
                                )

            mean_merror = pd.Series(cv_results['binary_error-mean']).min()
            boost_rounds = pd.Series(cv_results['binary_error-mean']).argmin()

            if mean_merror < min_merror:
                min_merror = mean_merror
                best_params['feature_fraction'] = feature_fraction
                best_params['bagging_fraction'] = bagging_fraction
                best_params['bagging_freq'] = bagging_freq

params['feature_fraction'] = best_params['feature_fraction']
params['bagging_fraction'] = best_params['bagging_fraction']
params['bagging_freq'] = best_params['bagging_freq']

print("调参4：降低过拟合")
for lambda_l1 in [0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]:
    for lambda_l2 in [0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]:
        for min_split_gain in [0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]:
            params['lambda_l1'] = lambda_l1
            params['lambda_l2'] = lambda_l2
            params['min_split_gain'] = min_split_gain

            cv_results = lgb.cv(
                                params,
                                lgb_train,
                                seed=42,
                                nfold=3,
                                metrics=['binary_error'],
                                early_stopping_rounds=3,
                                verbose_eval=True
                                )

            mean_merror = pd.Series(cv_results['binary_error-mean']).min()
            boost_rounds = pd.Series(cv_results['binary_error-mean']).argmin()

            if mean_merror < min_merror:
                min_merror = mean_merror
                best_params['lambda_l1'] = lambda_l1
                best_params['lambda_l2'] = lambda_l2
                best_params['min_split_gain'] = min_split_gain

params['lambda_l1'] = best_params['lambda_l1']
params['lambda_l2'] = best_params['lambda_l2']
params['min_split_gain'] = best_params['min_split_gain']


print(best_params)

### 训练
params['learning_rate']=0.01
lgb.train(
          params,                     # 参数字典
          lgb_train,                  # 训练集
          valid_sets=lgb_eval,        # 验证集
          num_boost_round=2000,       # 迭代次数
          early_stopping_rounds=50    # 早停次数
          )

### 线下预测
print ("线下预测")
preds_offline = lgb.predict(offline_test_X, num_iteration=lgb.best_iteration) # 输出概率
offline=offline_test[['instance_id','is_trade']]
offline['preds']=preds_offline
offline.is_trade = offline['is_trade'].astype(np.float64)
print('log_loss', metrics.log_loss(offline.is_trade, offline.preds))

### 线上预测
print("线上预测")
preds_online =  lgb.predict(online_test_X, num_iteration=lgb.best_iteration)  # 输出概率
online=online_test[['instance_id']]
online['preds']=preds_online
online.rename(columns={'preds':'predicted_score'},inplace=True)           # 更改列名
online.to_csv("./data/20180405.txt",index=None,sep=' ')                   # 保存结果

### 保存模型
from sklearn.externals import joblib
joblib.dump(lgb,'lgb.pkl')

### 特征选择
df = pd.DataFrame(X_train.columns.tolist(), columns=['feature'])
df['importance']=list(lgb.feature_importance())                           # 特征分数
df = df.sort_values(by='importance',ascending=False)                      # 特征排序
df.to_csv("./data/feature_score_20180331.csv",index=None,encoding='gbk')  # 保存分数
alicelmx
关注
  • 5
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
基于深度LightGBM集成学习模型的谷歌商店顾客购买力预测.pdf
08-18
基于深度LightGBM集成学习模型的谷歌商店顾客购买力预测.pdf
基于sklearn的集成学习实战
FavoriteStar的博客
11-25 834
本文主要跟随Datawhale的学习路线以及内容教程，详细介绍了集成学习常见的多个算法的基于sklearn的实现过程，同时还有两个案例，内容丰富。
LGB 的 .feature_importance() 函数
雨化于画
07-29 1万+
对于机器学习训练来说，每一种特征对于机器学习训练的模型的重要性可能是不一样的，此时，这个函数就起到了作用。 feature_importance(importance_type='split', iteration=None) Get feature importances. Parameters: importance_type (string, optional (default=“s...
python中的lightgbm入门
最新发布
抓饭不吃皮牙子
10-26 783
本文介绍了在Python中使用LightGBM进行模型训练和预测的基本流程。通过安装LightGBM库、准备数据、创建模型和进行训练预测，可以快速上手使用LightGBM进行机器学习任务。此外，我们还提到了模型评估的重要性，可以通过使用各种评估指标来衡量模型的性能。希望本文能够帮助读者入门LightGBM，并在实际项目中应用。LightGBM是一个强大的机器学习算法，但也有一些缺点。下面详细介绍LightGBM的缺点以及与之类似的算法。
lgbm查看特征重要性
qq_39321513的博客
11-14 1035
lgbm查看特征重要性
LightGBM 实现基于内容的个性化推荐
m0_59596937的博客
12-01 639
大家好，本文中，我将和大家一起学习如何训练 LightGBM 模型来估计电子商务广告的点击率的推荐系统的例子。将在Criteo数据集上训练一个基于LightGBM的模型。LightGBM是一个基于树的梯度提升学习算法框架。是基于分布式框架设计的，因而非常高效，具有以下优点:训练速度快，效率高。低内存的使用。伟大的准确性。支持并行和GPU学习。能够处理大规模数据。LightGBM梯度提升树算法，推荐原理是基于内容的过滤，用于在基于内容的问题中进行快速训练和低内存使用。
LightGBM模型架构实现
weixin_51047199的博客
04-27 571
本文用来记录如何初步实现lgb模型，但尚未对信息进行具体的细化，供各位初学者参考。 目录1. 加载数据2. 划分数据集3. 将数据转换为Dataset格式4. 参数设置5. 模型训练6. 模型预测7. 预测结果保存 1. 加载数据 首先需要导入我们的训练数据 import pandas as pd train_data = pd.read_table('./data/train.txt') # 这里是导入训练数据，我采用的是相对路径查看文件 2. 划分数据集 机器学习模型中对于训练模型需要训练集和测试.
python入门什么是集成学习
09-30
python入门
基于机器学习LightGBM和异质集成学习方法的新闻分类.pdf
09-24
基于机器学习LightGBM和异质集成学习方法的新闻分类.pdf
lightGBM论文
04-23
微软开源的最新集成学习平台lightGBM，号称性能比XGBoost还要好，可以读读论文
LightGBM中的GBDT实现
07-20
LightGBM中的GBDT实现
XGboost Lightgbm 参数1
08-08
2.Parallel Processing（并行处理）:如果大家看过我前面分享的一篇集成学习的文章： 集成学习之bagging、boosting及AdaBoos
机器学习常用模板—（LGB）
热门推荐
天上掉下两毛钱
06-03 2万+
LightGBM是个快速的、分布式的、高性能的基于决策树算法的梯度提升框架。可用于排序、分类、回归以及很多其他的机器学习任务中。模板：import lightgbm as lgb print("LGB test") clf = lgb.LGBMClassifier( boosting_type='gbdt', num_leaves=55, reg_alpha=0.0, reg_la...
LightGBM使用教程
weixin_43217641的博客
09-13 3079
详细的介绍了关于lightgbm的使用教程，展示了lightgbm中的分类与回归问题的可视化。
LGBM函数及参数详解
weixin_38267719的博客
04-02 2万+
LGBM Python API Dataset class lightgbm.Dataset(data, label=None, max_bin=None, reference=None, weight=None, group=None, init_score=None, silent=False, feature_name='auto', categorical_feature='auto'...
lightGBM----学习笔记整理
weixin_34280060的博客
03-21 1548
1、前序 1.1、lightGBM演进过程 c3.0(信息增益，信息增益率)—> CART(Gini) —> 提升树（AdaBoost) —> GBDT —> XGBoost —> lightGBM 1.2、AdaBoost算法 AdaBoost是一种提升树的方法，和三个臭皮匠，赛过诸葛亮的道理一样。 AdaBoost两个问题 1、如何改变训练数据的权重或概率分布 ​ 提高前一轮被弱分类器错误分类的样本权重，降低前一轮被分对的权重 2、如何将弱分类器组合成一个强分类器，
图解机器学习算法(11) | LightGBM模型详解（机器学习通关指南·完结）
ShowMeAI研究中心
03-10 2万+
LightGBM是GBDT的进化版本，在效率、内存、准确率方面表现优秀。本文讲解LightGBM的动机、优缺点及优化点、决策树算法及生长策略、类别性特征支持、并行支持与优化等重要知识点。
第三章：集成机器学习
01-03
本章介绍集成机器学习相关知识，并通过实例介绍随机森林,XGBoost、LightGBM等模型使用。
机器学习实战 | LightGBM建模应用详解
ShowMeAI研究中心
03-21 2万+
本篇详细讲解LightGBM的工程应用方法。LightGBM是微软开发的boosting集成模型，和XGBoost一样是对GBDT的优化和高效实现，但它很多方面比XGBoost有着更为优秀的表现。
lightgbm算法机器学习
09-27
LightGBM算法是一种集成算法，它是在XGBoost的基础上进行了优化。与XGBoost相比，LightGBM具有以下几个特点和优势： 1. 优化速度和内存使用：通过基于直方图算法的优化，使数据存储更加方便、运算更快、鲁棒性更强、模型更加稳定。同时，引入了单边梯度采样算法，减少计算每个分割增益的成本，提高算法的运行效率。此外，LightGBM还减少了内存使用和并行学习的计算成本。 2. 精度优化：LightGBM采用以叶子数为导向的决策树建立算法，相比于传统的按层生长的策略，可以降低误差，获得更好的精度。此外，LightGBM还对分类特征的编码方式进行了优化，提出了互斥特征捆绑算法，可以减少特征的维度并避免信息的丢失。 3. 稀疏优化：LightGBM使用离散的bin替换连续的特征值，可以减小存储空间，并采用无需存储其他信息即可对特征数值进行预排序的方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值