LGB+LR的实践

最新推荐文章于 2022-02-14 09:50:41 发布
最新推荐文章于 2022-02-14 09:50:41 发布
阅读量3.3k 收藏 14
点赞数 3
分类专栏： 机器学习 Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27782503/article/details/109016913
版权

文章目录

1 背景

相信大名鼎鼎的GBDT+LR组合很多小伙伴都听过，这种组合模型的预测效果要比单模型要好，但之前一直没有亲自实践过，最近刚好公司一个项目用到了，故抓紧时间总结一波~

2 原理

简单来说就是首先用树模型（GBDT、Xgboost、Lightgbm）来预测样本结果，然后将树模型的结果转为标准的变量形式放入LR中，最终进行预测~

  • 具有stacking思想的二分类器模型，GBDT用来对训练集提取特征作为新的训练输入数据，LR作为新训练输入数据的分类器。
  • GBDT算法的特点正好可以用来发掘有区分度的特征、特征组合，减少特征工程中人力成本。而LR则可以快速实现算法

具体的一个demo例子见下方，根据树模型的结果转为标准变量形式并放入模型~

在这里插入图片描述

下面就拿一个具体数据来看看GBDT+LR的效果，以及与其余模型的比较

3 数据的准备

3.1 读入数据

import pandas as pd
import warnings
warnings.filterwarnings('ignore')

# 读入数据
df = pd.read_csv('telecom_churn.csv')
df['churn'] = df['churn'].map(str)
churn_dic = {'True':1, 'False':0}
df['churn'] = df['churn'].map(churn_dic)
print(df.shape)
df.head()

(3333, 21)
stateaccount lengtharea codephone numberinternational planvoice mail plannumber vmail messagestotal day minutestotal day callstotal day charge...total eve callstotal eve chargetotal night minutestotal night callstotal night chargetotal intl minutestotal intl callstotal intl chargecustomer service callschurn
0KS128415382-4657noyes25265.111045.07...9916.78244.79111.0110.032.7010
1OH107415371-7191noyes26161.612327.47...10316.62254.410311.4513.733.7010
2NJ137415358-1921nono0243.411441.38...11010.30162.61047.3212.253.2900
3OH84408375-9999yesno0299.47150.90...885.26196.9898.866.671.7820
4OK75415330-6626yesno0166.711328.34...12212.61186.91218.4110.132.7330

5 rows × 21 columns

df['churn'].value_counts()

0    2850
1     483
Name: churn, dtype: int64

3.2 切分训练集测试集

X = df[['total day calls', 'total night charge', 'number vmail messages', 'total intl charge', 'total eve calls']]
y = df['churn'].values

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3,
                                                    random_state = 23)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)

(2333, 5) (1000, 5) (2333,) (1000,)

4 LR

from sklearn.linear_model import LogisticRegression
from sklearn import metrics

# 初始建模
lr = LogisticRegression(random_state = 23)
print(lr)
lr.fit(X_train, y_train)

# 计算AUC
scores = lr.predict_proba(X_test)[:,1]
LR_auc = metrics.roc_auc_score(y_test, scores) # y_test真实标签 scores为预测为1的概率
LR_auc

LogisticRegression(random_state=23)





0.5834069949026194

5 LGB

import lightgbm as lgb
from lightgbm.sklearn import LGBMClassifier # 是lightgbm的sklearn包。这个包允许我们像GBM一样使用Grid Search 和并行处理。

# 搭建模型
model_lgb = lgb.LGBMClassifier(
                                 boosting_type='gbdt',
                                 objective = 'binary',
                                 metric = 'auc',
                                 verbose = 0,
                                 learning_rate = 0.01,
                                 num_leaves = 35,
                                 feature_fraction=0.8,
                                 bagging_fraction= 0.9,
                                 bagging_freq= 8,
                                 lambda_l1= 0.6,
                                 lambda_l2= 0
                               )

#  拟合模型
model_lgb.fit(X_train, y_train)

# 计算AUC
scores = model_lgb.predict_proba(X_test)[:,1]
LGB_auc = metrics.roc_auc_score(y_test, scores) # y_test真实标签 scores为预测为1的概率
LGB_auc

[LightGBM] [Warning] feature_fraction is set=0.8, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.8
[LightGBM] [Warning] lambda_l1 is set=0.6, reg_alpha=0.0 will be ignored. Current value: lambda_l1=0.6
[LightGBM] [Warning] bagging_fraction is set=0.9, subsample=1.0 will be ignored. Current value: bagging_fraction=0.9
[LightGBM] [Warning] lambda_l2 is set=0, reg_lambda=0.0 will be ignored. Current value: lambda_l2=0
[LightGBM] [Warning] bagging_freq is set=8, subsample_freq=0 will be ignored. Current value: bagging_freq=8
[LightGBM] [Warning] Find whitespaces in feature_names, replace with underlines
[LightGBM] [Warning] feature_fraction is set=0.8, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.8
[LightGBM] [Warning] lambda_l1 is set=0.6, reg_alpha=0.0 will be ignored. Current value: lambda_l1=0.6
[LightGBM] [Warning] bagging_fraction is set=0.9, subsample=1.0 will be ignored. Current value: bagging_fraction=0.9
[LightGBM] [Warning] lambda_l2 is set=0, reg_lambda=0.0 will be ignored. Current value: lambda_l2=0
[LightGBM] [Warning] bagging_freq is set=8, subsample_freq=0 will be ignored. Current value: bagging_freq=8
[LightGBM] [Warning] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000353 seconds.
You can set `force_col_wise=true` to remove the overhead.





0.601792922596423

6 LGB+LR

6.1 LGB实现

import lightgbm as lgb
from lightgbm.sklearn import LGBMClassifier # 是lightgbm的sklearn包。这个包允许我们像GBM一样使用Grid Search 和并行处理。

# 搭建模型
lgb_param = {'boosting_type':'gbdt',
                                 'objective' : 'binary',
                                 'metric' : 'auc',
                                 'verbose' : 0,
                                 'learning_rate' : 0.01,
                                 'num_leaves' : 4,
                                 'feature_fraction':0.8,
                                 'bagging_fraction': 0.9,
                                 'bagging_freq': 8,
                                 'lambda_l1': 0.6,
                                 'lambda_l2': 0,
            'n_estimators' : 200}

'''
num_leaves:代表的是一棵树上的叶子数
n_estimators:代表的是多少棵树！
- 每棵树4个叶子，然后默认是100棵树！！！！本场景选择200！
'''

model = lgb.LGBMClassifier(
                                 boosting_type='gbdt',
                                 objective = 'binary',
                                 metric = 'auc',
                                 verbose = 0,
                                 learning_rate = 0.01,
                                 num_leaves = 4,
                                 feature_fraction=0.8,
                                 bagging_fraction= 0.9,
                                 bagging_freq= 8,
                                 lambda_l1= 0.6,
                                 lambda_l2= 0,
                                n_estimators = 200
                               )

#  拟合模型
model.fit(X_train, y_train)

[LightGBM] [Warning] feature_fraction is set=0.8, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.8
[LightGBM] [Warning] lambda_l1 is set=0.6, reg_alpha=0.0 will be ignored. Current value: lambda_l1=0.6
[LightGBM] [Warning] bagging_fraction is set=0.9, subsample=1.0 will be ignored. Current value: bagging_fraction=0.9
[LightGBM] [Warning] lambda_l2 is set=0, reg_lambda=0.0 will be ignored. Current value: lambda_l2=0
[LightGBM] [Warning] bagging_freq is set=8, subsample_freq=0 will be ignored. Current value: bagging_freq=8
[LightGBM] [Warning] Find whitespaces in feature_names, replace with underlines
[LightGBM] [Warning] feature_fraction is set=0.8, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.8
[LightGBM] [Warning] lambda_l1 is set=0.6, reg_alpha=0.0 will be ignored. Current value: lambda_l1=0.6
[LightGBM] [Warning] bagging_fraction is set=0.9, subsample=1.0 will be ignored. Current value: bagging_fraction=0.9
[LightGBM] [Warning] lambda_l2 is set=0, reg_lambda=0.0 will be ignored. Current value: lambda_l2=0
[LightGBM] [Warning] bagging_freq is set=8, subsample_freq=0 will be ignored. Current value: bagging_freq=8
[LightGBM] [Warning] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000282 seconds.
You can set `force_col_wise=true` to remove the overhead.





LGBMClassifier(bagging_fraction=0.9, bagging_freq=8, feature_fraction=0.8,
               lambda_l1=0.6, lambda_l2=0, learning_rate=0.01, metric='auc',
               n_estimators=200, num_leaves=4, objective='binary', verbose=0)

model.get_params()

{'boosting_type': 'gbdt',
 'class_weight': None,
 'colsample_bytree': 1.0,
 'importance_type': 'split',
 'learning_rate': 0.01,
 'max_depth': -1,
 'min_child_samples': 20,
 'min_child_weight': 0.001,
 'min_split_gain': 0.0,
 'n_estimators': 200,
 'n_jobs': -1,
 'num_leaves': 4,
 'objective': 'binary',
 'random_state': None,
 'reg_alpha': 0.0,
 'reg_lambda': 0.0,
 'silent': True,
 'subsample': 1.0,
 'subsample_for_bin': 200000,
 'subsample_freq': 0,
 'metric': 'auc',
 'verbose': 0,
 'feature_fraction': 0.8,
 'bagging_fraction': 0.9,
 'bagging_freq': 8,
 'lambda_l1': 0.6,
 'lambda_l2': 0}

6.2 LGB的vector导出来！

6.2.1 训练集

import numpy as np

y_pred = model.predict(X_train,pred_leaf=True) 
#  预测结果为该样本最终落在树的哪一个节点上！如果'num_leaves': 4,则可能落在 0 1 2 3 这四个位置上！
train_matrix = np.zeros([len(y_pred), len(y_pred[0])*lgb_param['num_leaves']],dtype=np.int64)
print(train_matrix.shape) # 1000行 800列 因为是1000个样本点，同时200棵树，每棵树4个节点，则800个变量
train_matrix

(2333, 800)





array([[0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       ...,
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0]], dtype=int64)

for i in range(len(y_pred)):
    # 对每一个样本点做循环！然后卡一个点，每隔4个设一个关卡！
    temp = np.arange(len(y_pred[0]))*lgb_param['num_leaves'] + np.array(y_pred[i])
    train_matrix[i][temp] += 1

lgb_output_vec_train = pd.DataFrame(train_matrix)
lgb_output_vec_train.columns = ['leaf_' + str(i) for i in lgb_output_vec_train.columns]
lgb_output_vec_train
leaf_0leaf_1leaf_2leaf_3leaf_4leaf_5leaf_6leaf_7leaf_8leaf_9...leaf_790leaf_791leaf_792leaf_793leaf_794leaf_795leaf_796leaf_797leaf_798leaf_799
01000001000...1000100010
11000001000...1000010010
21000100010...1000100010
31000100010...1000100010
41000100010...0000100100
..................................................................
23281000100010...1000010010
23291000100010...1000010010
23301000001000...1000100010
23311000001000...1000100010
23321000001000...0000010100

2333 rows × 800 columns

6.2.2 测试集

import numpy as np

y_pred = model.predict(X_test,pred_leaf=True) 
#  预测结果为该样本最终落在树的哪一个节点上！如果'num_leaves': 4,则可能落在 0 1 2 3 这四个位置上！
test_matrix = np.zeros([len(y_pred), len(y_pred[0])*lgb_param['num_leaves']],dtype=np.int64)
print(test_matrix.shape) # 1000行 800列 因为是1000个样本点，同时200棵树，每棵树4个节点，则800个变量
test_matrix

(1000, 800)





array([[0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       ...,
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0]], dtype=int64)

for i in range(len(y_pred)):
    # 对每一个样本点做循环！然后卡一个点，每隔4个设一个关卡！
    temp = np.arange(len(y_pred[0]))*lgb_param['num_leaves'] + np.array(y_pred[i])
    test_matrix[i][temp] += 1

lgb_output_vec = pd.DataFrame(test_matrix)
lgb_output_vec.columns = ['leaf_' + str(i) for i in lgb_output_vec.columns]
lgb_output_vec
leaf_0leaf_1leaf_2leaf_3leaf_4leaf_5leaf_6leaf_7leaf_8leaf_9...leaf_790leaf_791leaf_792leaf_793leaf_794leaf_795leaf_796leaf_797leaf_798leaf_799
01000100010...1000010010
10100010001...0100100001
21000001000...1000100010
31000100010...1000010010
41000001000...1000100010
..................................................................
9951000100010...1000100010
9961000100010...0010001000
9971000100010...1000010010
9980001010001...0100100001
9991000100010...1000010010

1000 rows × 800 columns

y_pred[0] # 第一个样本点在100棵树上分别落的位置！

array([0, 0, 0, 3, 3, 0, 3, 0, 3, 3, 0, 3, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 3, 0, 0, 3, 3, 3, 2, 0, 3, 0, 2, 2, 2, 3, 0, 2, 0, 2, 0,
       0, 0, 0, 3, 3, 3, 0, 3, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
       3, 3, 0, 3, 3, 0, 2, 0, 2, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0,
       3, 3, 3, 3, 1, 3, 3, 3, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 2, 0, 0, 3,
       0, 2, 2, 2, 3, 2, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0,
       3, 3, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 3, 0, 3, 3, 0, 3, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 3, 2, 2, 2,
       3, 2])

len(y_pred) # 表示1000个样本点！

1000

len(y_pred[0]) # 表示200棵树

200

6.3 LR+LGB

from sklearn.linear_model import LogisticRegression
from sklearn import metrics

# 初始建模
lr = LogisticRegression(random_state = 23)
print(lr)
lr.fit(lgb_output_vec_train, y_train)

# 计算AUC
scores = lr.predict_proba(lgb_output_vec)[:,1]
LR_LGB_auc = metrics.roc_auc_score(y_test, scores) # y_test真实标签 scores为预测为1的概率
LR_LGB_auc

LogisticRegression(random_state=23)





0.58792613217832

7 结果对比

df = pd.DataFrame({'model':['LR', 'LGB', 'LGB+LR'], 'AUC':[LR_auc, LGB_auc, LR_LGB_auc]})
df
modelAUC
0LR0.583407
1LGB0.601793
2LGB+LR0.587926

结论：就本案例而言，LGB+LR的效果没有LGB好，所以并不能绝对说某一个模型效果如何好，应该根据不同数据场景选择最优的模型。一般而言，在CTR预估场景下LGB+LR效果还是不错的
写代码的阿呆
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
lgb_python_特征提取_lgb预测_
10-01
lgb实现预测，包括提取特征，数据处理等pandas基础操作，可以学习
lgb
qq_43640749的博客
04-13 1452
实践 在这里插入import pandas as pd from sklearn.model_selection import train_test_split from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.linear_model import LogisticRegression from sk...
lightgbm简易评分卡制作
lc434699300的博客
04-16 2054
 　LightGBM的意思是轻量级(light)的梯度提升机(GBM)，其相对Xgboost具有训练速度快、内存占用低的特点。关于lgb针对xgb做的优化，后面想写一篇文章复习一下。本篇文章主要讲解如何利用lgb建立一张评分卡，不涉及公式推导。关于lgb的基础使用教程，由于和xgb有许多相似之处，这里放一篇基础教程的链接。 LightGBM使用简单介绍：https://mathpretty.com...
机器学习中的数据清洗与特征处理综述
baidu_18891025的博客
09-12 713
1、采样： 分类问题：选取正例，负例，比例确定。 回归问题：评测样本的大致分布，根据目标制定采样规则；采样的方法包括随机采样，固定比例采样等方法 2、数据清洗 结合业务情况进行数据的过滤 去除crawler抓取，spam，作弊等数据 3、特征分类 根据不同的分类方法，可以将特征分为(1)Low level特征和High level特征。(2)稳定特征与动态特征。(3)二值特征、连续特征、枚举特征。 Low level特征是较低级别的特征，主要是原始特征，不需要或者需要非常少的人工处理和干预，例如文
消除LightGBM训练过程中出现的[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
热门推荐
qq_41904729的博客
05-23 2万+
1.总结一下Github上面有关这个问题的解释： 这意味着当前迭代中树的学习应该停止，因为不能再分裂了。 "min_data_in_leaf"的设定值太大导致的，应该设一个小一点的。 这不是一个bug或者error，而是一个特性，可以忽略掉(但是本人看着很不爽)。输出消息是警告用户您的参数可能错误，或者您的数据集不容易学习。 2.消除办法： 把"min_data_in_leaf"改小一点。 在参数字典中增加参数"verbose:-1"（新参数与前面的参数之间记得加逗号） 本人采用第二种办法，.
[机器学习] 模型融合GBDT(xgb/lgbm/rf)+LR 的原理及实践
摩登都市天空---专栏
01-23 1万+
目录 一、原理 GBDT + LR 是什么,用在哪 二、说明 GBDT + LR 的结构 RF + LR ? Xgb + LR? GBDT + LR 模型提升 三、实践 1 如何获得样本落在哪个叶子节点 2 举例 2.2.1 训练集准备 2.2.2 RF+LR 2.2.3 GBDT+LR 2.2.4 Xgboost+LR 2.2.5 单独使用RF, GBDT和Xgbo...
2019腾讯广告大赛总结
weixin_30564785的博客
07-20 112
总结比赛的整个心情: 想找个比赛好好实践一下, 结果碰到了腾讯广告大赛, 所以直接找队友参加了. 因为开始比赛时间较晚, 组队太晚, 队友信心不足中途跑票, 经历了几次换队友之后才算是正式进入状态, 开始一路艰难前进到复赛的过程, 不过有点遗憾, 最后比赛数据太大, 加一波新特征需要1-2天的时间, 方案和想法陷入瓶颈, 所以最终比赛结果也只到复赛为止了. 没能有更好的成绩有点遗憾, ...
ctr项目
Yasin的博客
05-26 2128
腾讯2017社交广告比赛 https://jiayi797.github.io/2017/06/07/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E5%AE%9E%E8%B7%B5-CVR-Tencent_CVR%E9%A2%84%E4%BC%B0%E5%88%9D%E8%B5%9B&%E5%A4%8D%E8%B5%9B%E6%80%9D%E8%B7%AF%...
逻辑回归构建评分卡
缘 源 园
03-22 721
身份特质 稳定性 ：所在公司，职业类型，消费稳定度，近一年内使用手机号码数，手机号码稳定天数，地址稳定天数 履约能力：是否有车，是否有房，近一个月流动资产日均值，近三个月流动资产日均值，近六个月流动资产日均值，近一年流动资产日均值，近一个月理财产品总收益，近三个月理财产品总收益，近六个月理财产品总收益，近一年理财产品总收益，历史理财产品总收益，近一个月支付总金额，近三个月支付总金额，近六个月支付总金额，近一个月消费总金额，近三个月消费总金额，近六个月消费总金额， 信用历史：近一个月主动查询金融机构次数，
人工智能-项目实践-售卖房型预测-基于lgb的用户预订售卖房型概率预测--top1
05-04
人工智能-项目实践-售卖房型预测-基于lgb的用户预订售卖房型概率预测--top1 比赛地址和数据：https://www.kesci.com/apps/home/#!/competition/58dba69775722d38fa2dfcf6/content/0 通过分析，我们发现数据集是...
LGB 20E系统
09-21
LGB 20E 手机的系统 用于更新手机的软件版本！
LGB_Cluster_Algorithm.rar_LGB多分类算法_cluster_lgb的matlab实现_lgb算法_lg
07-14
LGB聚类算法的详细实现代码,做语音识别，说话人识别，人声检测的朋友可能需要。
基于机器学习 LGB knn 预测 完整代码+数据.rar
03-19
基于机器学习 LGB knn 预测 完整代码+数据.rar
机器学习 | 特征重要性判断
RUC_Lee的博客
05-12 1万+
聊聊feature_importances_1 背景2 原理3 Python实现3.1 解决mac下用jupyter绘图不显示中文的问题3.2 一个神奇的函数：np.argsort 1 背景 在运用树模型建模的时候，常用的一个sklearn的子库就是看特征重要性，也就是feature_importances_，下面将从原理和Python代码实现两个角度来聊一聊！ 2 原理 待补充 3 Python...
KL散度及Python实现
RUC_Lee的博客
12-09 1万+
KL散度及Python实现1 KL散度1.1 定义1.2 公式1.3 几个结论1.4 应用1.4.1 应用1：机器学习领域1.4.2 应用2：用户画像2 Python实现求解2.1 生成分布2.2 计算方法12.3 计算方法23 参考 1 KL散度 在很多场合，经常会遇到KL散度这个概念，那么它到底是什么含义呢？如何定义的？又有哪些应用场景？最后如何用Python进行计算呢？ 1.1 定义 KL散度（Kullback-Leibler divergence，简称KLD）: 在信息系统中称为相对熵（relat
Python | KS检验以及其余非参数检验的实现
RUC_Lee的博客
10-26 1万+
Python | KS检验以及其余非参数检验的实现1 什么是KS检验2 KS检验分类？3 KS检验的Python实现3.1 检验指定的数列是否服从正态分布3.2 检验指定的两个数列是否服从相同分布4 其余的非参数检验4.1 Wilcoxon符号秩检验（t检验的非参数版本）4.2 Kruskal-Wallis H检验（方差分析的非参数版本）4.3 Mann-Whitney秩检验5 参考 1 什么是KS检验 定义：检验一个分布f(x)与理论分布g(x)【比如正态分布】是否一致，或两个观测值分布是否有显著差异的检
Python | 统计每个文件夹各类图片个数
RUC_Lee的博客
04-20 1万+
统计每个文件夹各类图片个数1 背景2 整体思路3 读入所有文件夹4 读每个文件夹下面图片4.1 判断空文件夹有多少个5 看每个文件夹平均有多少张图片6 数据筛选6.1 筛选出big_num为0的 然后去检查一下6.2 筛选出rec_num为0的 然后去检查一下7 结论 1 背景 现在已经通过爬虫将所有商家首页的图片下载ok，但给导师汇报总的有个基本的结论吧，也就是说，多少文件夹没有图片，分为big...
游程检验和随机性检验
RUC_Lee的博客
02-14 1万+
游程检验和随机性检验1 游程检验的含义2 应用1：两总体分布一致性检验2.1 定义及解决的问题2.2 原理2.2.1 Step1：提出假设2.2.2 Step2：计算检验统计量2.2.3 Step3：决策2.3 Python实现3 应用2：样本随机性检验（单总体）3.1 定义及解决的问题3.2 原理3.2.1 Step1：提出假设3.2.2 Step2：计算检验统计量3.2.3 Step3:决策3.3 Python实现 1 游程检验的含义 什么叫游程检验（Runs test）呢？ 游程检验的定义：亦称“连贯
Python | 图片转文字
RUC_Lee的博客
04-01 9485
目录 1  背景2  数据概况3  需求4  利用Python进行转换4.1  导入相应的库4.2  设置百度云的API相关参数4.2.1  如何获取上述API的相关关键参数？4.3  定义读取图片函数4.4  单独转换...
python lgb
最新发布
10-09
你好！关于 "python lgb"，我猜测你可能在问 LightGBM（LGB）在 Python 中的使用方法。 要在 Python 中使用 LightGBM，首先需要安装 LightGBM 库。可以通过以下命令使用 pip 进行安装： ``` pip install lightgbm ``` 安装完成后，可以在 Python 脚本中导入 LightGBM 并使用它进行机器学习任务。以下是一个简单的示例代码，演示了如何使用 LightGBM 进行二分类任务： ```python import lightgbm as lgb import numpy as np import pandas as pd from sklearn.model_selection import train_test_split # 加载数据 data = pd.read_csv('data.csv') X = data.drop('target', axis=1) y = data['target'] # 划分训练集和测试集 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # 创建 LightGBM 数据集 train_data = lgb.Dataset(X_train, label=y_train) # 设置模型参数 params = { 'objective': 'binary', 'metric': 'binary_logloss', 'boosting_type': 'gbdt', 'num_leaves': 31, 'learning_rate': 0.05, 'feature_fraction': 0.9 } # 训练模型 model = lgb.train(params, train_data, num_boost_round=100) # 预测 y_pred = model.predict(X_test) # 输出预测结果 print(y_pred) # 相关问题:

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值