精华内容
下载资源
问答
  • LightGBM模型

    2021-07-03 11:13:24
    LightGBM与XGBoost对比: 模型精度:两个模型相当 训练速度:LightGBM训练速度更快 => 1/10 内存消耗:LightGBM占用内存更小 => 1/6 特征缺失值:两个模型都可以自动处理特征缺失值 分类特征:XGBoost不支持...
    LightGBM与XGBoost对比:
    • 模型精度:两个模型相当
    • 训练速度:LightGBM训练速度更快 => 1/10
    • 内存消耗:LightGBM占用内存更小 => 1/6
    • 特征缺失值:两个模型都可以自动处理特征缺失值
    • 分类特征:XGBoost不支持类别特征,需要对其进行OneHot编码,而LightGBM支持分类特征

    在这里插入图片描述

    XGBoost模型的复杂度:

    • 模型复杂度 = 树的棵数 X 每棵树的叶子数量 X 每片叶子生成复杂度
    • 每片叶子生成复杂度 = 特征数量 X 候选分裂点数量 X 样本的数量

    LightGBM针对XGBoost的优化:

    • Histogram算法,直方图算法 => 减少候选分裂点数量
    • GOSS算法,基于梯度的单边采样算法 => 减少样本的数量
    • EFB算法,互斥特征捆绑算法 => 减少特征的数量
    • LightGBM = XGBoost + Histogram + GOSS + EFB

    Histogram算法-减少分类算法

    • 替代XGBoost的预排序算法
    • 思想是先连续的浮点特征值离散化成k个整数,同时构造一个宽度为k的直方图,即将连续特征值离散化到k个bins上(比如k=255)
    • 当遍历一次数据后,直方图累积了需要的统计量,然后根据直方图的离散值,遍历寻找最优的分割点
    • XGBoost需要遍历所有离散化的值,LightGBM只要遍历k个直方图的值
    • 候选分裂点数量 = k-1

    在这里插入图片描述

    GOSS算法-减少样本数量:

    • Gradient-based One-Side Sampling,基于梯度的单边采样算法
    • 思想是通过样本采样,减少目标函数增益Gain的计算复杂度
    • 单边采样,只对梯度绝对值较小的样本按照一定比例进行采样,而保留了梯度绝对值较大的样本
    • 因为目标函数增益主要来自于梯度绝对值较大的样本 => GOSS算法在性能和精度之间进行了很好的trade off
      在这里插入图片描述

    EFB算法-减少特征数量:

    • Exclusive Feature Bundling,互斥特征绑定算法
    • 思想是特征中包含大量稀疏特征的时候,减少构建直方图的特征数量,从而降低计算复杂度
    • 数据集中通常会有大量的稀疏特征(大部分为0,少量为非0)我们认为这些稀疏特征是互斥的,即不会同时取非零值
    • EFB算法可以通过对某些特征的取值重新编码,将多个这样互斥的特征绑定为一个新的特征
    • 类别特征可以转换成onehot编码,这些多个特征的onehot编码是互斥的,可以使用EFB将他们绑定为一个特征
    • 在LightGBM中,可以直接将每个类别取值和一个bin关联,从而自动地处理它们,也就无需预处理成onehot编码

    在这里插入图片描述
    具体可参考:https://zhuanlan.zhihu.com/p/99069186

    展开全文
  • lightgbm_pmml_demo 从python导出的受过训练的lightgbm模型,以供Java调用
  • lightGBM需要安装在64位系统上,如果是32位的系统,则无法解析lightGBM模型,因此有必要写一个函数可以直接解析lightGBM模型,方法是利用light.train的模型的dump_model方法产生json模型,然后利用上他,如前这个...

    lightGBM需要安装在64位系统上,如果是32位的系统,则无法解析lightGBM模型,因此有必要写一个函数可以直接解析lightGBM模型,方法是利用light.train的模型的dump_model方法产生json模型,然后利用上他,如前这个dump_model有些小bug,dump后feature_names会有些小差别,因此对齐进行替换保证feature_name一致。

    1. 导入模块

    from sklearn.datasets import make_classification
    import lightgbm as lgb
    import pandas as pd
    import numpy as np
    import json

    2.创建用于解析模型的类

    # 
    class InferenceLightGBM(object):
        '''
        用于lightGBM dump_model产生的模型进行推断,以实现在没有安装lightGBM的电脑上进行解析模型
        '''
        def __init__(self,model_file=None,category_file=None):
            
            with open(model_file,'r') as json_file:
                self.model_json = json.load(json_file)
                # 模型json 字典
            with open(category_file,'r') as json_file:
                # 分类特征序号
                self.categories = json.load(json_file)
    #             print(self.categories)
                
            self.feature_names = self.model_json['feature_names']
            
        def predict(self,X):
            '''
            预测样本
            '''
            try:
                columns = list(X.columns)
            except :
                print('{} should be a pandas.DataFrame'.format(X))
            
            if self.model_json['feature_names'] == columns:
                y = self._predict(X)
                return y
            else:
                raise Exception("columns should be {}".format(self.feature_names),)
        
        def _sigmoid(self,z):
    
            return 1.0/(1+np.exp(-z))
    
        def _predict(self,X):
            '''
            对模型树字典进行解析
            '''
            feat_names = self.feature_names
            results = pd.Series(index=X.index)
            trees = self.model_json['tree_info']
            for idx in X.index:
                X_sample = X.loc[idx:idx,:]
                leaf_values = 0.0
                # 对不同的树进行循环
                for tree in trees:
                    tree_structure = tree['tree_structure']
                    leaf_value = self._walkthrough_tree(tree_structure,X_sample)
                    leaf_values += leaf_value
                results[idx] = self._sigmoid(leaf_values)
            return results
                    
        def _walkthrough_tree(self,tree_structure,X_sample):
            '''
            递归式对树进行遍历,返回最后叶子节点数值
            '''
            if 'leaf_index' in tree_structure.keys():
                # 此时已到达叶子节点
                return tree_structure['leaf_value']
            else:
                # 依然处于分裂点
                split_feature = X_sample.iloc[0,tree_structure['split_feature']]
                decision_type = tree_structure['decision_type']
                threshold = tree_structure['threshold']
    
                # 类别特征
                if decision_type == '==':
                    feat_name = self.feature_names[tree_structure['split_feature']]
                    categories = self.categories[feat_name]
                    category = categories[str(split_feature)]
                    category = str(category)
                    threshold = threshold.split('||')
                    if category in threshold:
                        tree_structure = tree_structure['left_child']
                    else:
                        tree_structure = tree_structure['right_child']
                    return self._walkthrough_tree(tree_structure,X_sample)
                # 数值特征
                elif decision_type == '<=':
                    if split_feature <= threshold:
                            tree_structure = tree_structure['left_child']
                    else:
                        tree_structure = tree_structure['right_child']
    
                    return self._walkthrough_tree(tree_structure,X_sample)
                else:
                    print(tree_structure)
                    print('decision_type: {} is not == or <='.format(decision_type))
                    return None
     

    3.创建分类样本及训练模型

    X,y = make_classification(n_classes=2,n_samples=200,random_state=100,n_features=10)
    sex_list = ['Male','Female']
    age_list = ['Youth','Adult','Elder']
    X = pd.DataFrame(X,columns=['Col_{}'.format(i) for i in range(10)])
    for i in range(200):
        X.loc[i,'Sex'] = np.random.choice(sex_list)
    for i in range(200):
        X.loc[i,'Age'] = np.random.choice(age_list)
    X['Sex'] = X['Sex'].astype('category')
    X['Age'] = X['Age'].astype('category')
    dtrain = lgb.Dataset(X,y,feature_name='auto',categorical_feature='auto',free_raw_data=False)
    booster_params = {
        'boosting_type': 'gbdt',
        'objective':'binary',
        'learning_rate':0.1,
        'num_leaves': 31,
        'feature_fraction':0.8, 
        'bagging_fraction':0.8,  
    }
    evals_result = {}
    gbm = lgb.train(booster_params,
                    num_boost_round=200,
                    train_set=dtrain,
                    valid_sets=[dtrain],
                    valid_names=['tr'],
                    evals_result=evals_result,
                    verbose_eval=50,
                    early_stopping_rounds=10,
                   )
    model_json = gbm.dump_model()
    model_json['feature_names'] = list(dtrain.data.columns)
    
    with open("sample_model.json",'w') as json_file:
        json.dump(model_json,json_file,ensure_ascii=False)
    
    cat_features = [column for column in dtrain.data.columns if hasattr(dtrain.data[column],'cat')]
    category_dict = dict()
    for cat_feature in cat_features:
        category_dict[cat_feature] = {v:k for k,v in enumerate(list(dtrain.data[cat_feature].cat.categories))}
    
    with open("category_feature_map.json",'w') as json_file:
        json.dump(category_dict,json_file,ensure_ascii=False)

    4.测试对比

    inf_lgb = InferenceLightGBM("sample_model.json","category_feature_map.json")
    sample = dtrain.data
    result_json = inf_lgb.predict(sample)
    result_gbm = gbm.predict(sample )
    
    diffrence = result_json.values - result_gbm
    diffrence
    结果如下,可以发现,两者预测结果保证了一致






























    展开全文
  • 一、lightGBM模型介绍 1. lightGBM模型简介 lightGBM模型是一个梯度提升决策树(GBDT)的实现,其本质原理就是利用基分类器(决策树)训练集成,得到最优的模型。相同的模型还有XGBoost,但因为XGBoost模型在多维度的...
    一、lightGBM模型介绍
    1. lightGBM模型简介

    lightGBM模型是一个梯度提升决策树(GBDT)的实现,其本质原理就是利用基分类器(决策树)训练集成,得到最优的模型。相同的模型还有XGBoost,但因为XGBoost模型在多维度的大数据集下,计算效率较差和可扩展性较低(主要原因是对于每个特征,它们都要扫描所有的数据样本来评估所有可能分枝点的信息增益),lightGBM模型为了解决这个问题,提出了两个技术:单边梯度采样算法(Gradient-based One-Side Sampling,GOSS)和互斥特征捆绑算法(Exclusive Feature Bundling,EFB)。

    2. lightGBM模型基本原理
    1. 直方图算法
      梯度提升决策树(GBDT)训练时最大的消耗就是寻找最好的分枝点。预排序算法是寻找分枝点最流行的算法之一,它在预排序的特征值中遍历所有可能的分枝点。这个方法非常简单并且可以找到最佳分枝点,但是却非常耗时和占内存。另一个常见的寻找最佳分枝点的算法是直方图算法。直方图算法将特征的连续值分割正离散的bins(箱),在训练的过程中使用bins构造特征直方图。lightGBM模型在直方图算法上还做了加速。一个叶子的直方图可以由它的父亲节点的直方图与它兄弟的直方图做差得到,在速度上可以提升一倍。通常构造直方图时,需要遍历该叶子上的所有数据,但直方图做差仅需遍历直方图的k个桶。在实际构建树的过程中,LightGBM还可以先计算直方图小的叶子节点,然后利用直方图做差来获得直方图大的叶子节点,这样就可以用非常微小的代价得到它兄弟叶子的直方图。
      直方图算法伪代码:
      在这里插入图片描述

    2. 带深度限制的 Leaf-wise 算法
      在Histogram算法之上,lightGBM模型对树的增长策略也做了优化,首先它抛弃了大多数GBDT工具使用的按层生长 (level-wise) 的决策树生长策略,而使用了带有深度限制的按叶子生长 (leaf-wise) 算法。同Level-wise相比,Leaf-wise的优点是:在分裂次数相同的情况下,Leaf-wise可以降低更多的误差,得到更好的精度;Leaf-wise的缺点是:可能会长出比较深的决策树,产生过拟合。因此LightGBM会在Leaf-wise之上增加了一个最大深度的限制,在保证高效率的同时防止过拟合。

    3. 单边梯度采样算法
      在梯度提升决策树(GBDT)中,数据样本一开始并没有初始权重。而在计算信息增益时,不同梯度的样本其重要程度也不一样,根据信息增益的定义,梯度越大,计算信息增益时贡献越大。因此lightGBM模型在训练时计算信息增益会保留梯度大的样本并随机采样一些梯度小的样本(这样做能保持原来数据的分布)。这样做比使用同一采样比例随机采样有更精确的评估。

    为了减少采样对数据分布的影响,GOSS为小梯度数据样本引入了一个常数乘法器,具体操作就是首先对样本按梯度的绝对值大小排序,然后选取前a个样本,再从剩下的样本中随机采用b个样本。之后在计算信息增益时用常数1-a/b来放大小梯度的采样样本。

    单边梯度采样算法伪代码:
    在这里插入图片描述

    1. 互斥特征捆绑算法
      高维度数据常常是稀疏的,特征空间的稀疏性为设计无损的方式减少特征数量提供了可能性。具体来说,在稀疏特征空间中,许多特征是互斥的(即它们不会同时取非零值)。因此,我们可以安全的将互斥的特征捆绑起来。通过设置特征扫描算法,我们可以用捆绑的特征和用单个特征构建一样的直方图。而构建直方图的复杂度从O(#data*#feature)降低到O(#data*#bundle)。

    如何决定将哪些特征捆绑在一起
    找到最优的捆绑策略是一个NP-hard问题。这意味着我们不能在有限的时间内找到最优解。因此为了寻找近似最优解我们将最优捆绑问题转换成图着色问题,将每个特征作为结点,将不互斥的结点用边连起来。然后使用贪婪算法进行求解。然而我们发现很多特征即使不是100%互斥,也很少同时取非零值。如果算法运行小部分特征冲突,便能得到更少的特征捆绑数,计算效率更高。这样方法对精度的影响也很小。
    算法的伪代码:
    在这里插入图片描述
    如何捆绑
    为了降低相应的训练复杂度,我们需要一个好的方法来将这些特征合并到同一个bundle中。关键是确保原始特性的值可以从合并的bundle中标识出来。因为直方图算法是用离散的bins替代特征的连续值。我们让互斥的特征分布到不同的bins中构建捆绑。这可以通过在特征值中加一个偏置常量来解决。比如,我们在bundle中绑定了两个特征A和B,A特征的原始取值为区间[0,10),B特征的原始取值为区间[0,20),我们可以在B特征的取值上加一个偏置常量10,将其取值范围变为[10,30),绑定后的特征取值范围为 [0, 30),这样就可以放心的融合特征A和B了。
    算法伪代码:
    在这里插入图片描述

    二、lightGBM模型优缺点

    优点:

    1. 训练时采用了直方图算法寻找最佳分枝点,提升了训练速度。
    2. 采用单边梯度采样算法,减少了计算量。
    3. 使用leaf-wise算法的增长策略构建决策树,减少了不必要的计算。
    4. 降低了内存消耗。

    缺点:

    1. 使用leaf-wise算法可能形成较深的决策树,产生过拟合。
    三、lightGBM模型参数

    lightGBM模型的参数特别多,这里只介绍部分核心参数,详情见官网

    参数描述
    objective模型应用的类型,有回归、二分类、多分类、交叉熵、排序等,其参数值可以是"regression"、“binary”、“multiclass”、“cross_entropy”、"lambdarank"等
    boosting森林的构建策略,参数值可以是"gbdt":传统的梯度提升决策树;“rf”:随机森林;“dart”:带dropout的梯度提升决策树;“goss”:单边梯度采样策略
    data(train_data)训练数据
    valid(valid_data)验证数据
    num_iterationsboosting的迭代次数
    learning_rate学习率
    num_leaves树的叶子节点数
    max_depth树的最大深度,可以控制过拟合
    min_data_in_leaf一个叶子节点中最小的样本数,通常用来处理过拟合
    feature_fractionlightGBM模型训练时每次迭代选择特征的比例,默认是1表示每次迭代选择全部的特征,设置为0.8表示随机选择特征中的80%个特征进行训练
    is_unbalance样本标签是否分布均匀
    四、lightGBM模型应用
    import numpy as np
    import pandas as pd
    import lightgbm as lgb
    
    # 获取数据
    train_data = pd.read_csv(r'./train_data.csv', index_col=0)
    X = train_data.iloc[:, 1:]
    y = train_data.iloc[:, 0]
    # 划分训练集和测试集
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=420)
    # 转换为Dataset数据格式
    train_set = lgb.Dataset(X_train, label=y_train)
    vali_set = lgb.Dataset(X_test, label=y_test)
    # 参数 
    params = {
        'learning_rate': 0.03,
        'num_leaves': 512,  # 叶子节点数
        'metric': {'l2', 'auc'},  # 评估函数
        'objective': 'regression',  # 目标函数
        'boosting': 'dart',   #  rf:随机森林  dart:带dropout 的gbdt
        'scale_pos_weight': 96,
        'bagging_fraction': 0.8,
        'bagging_freq': 5,
        'min_data_in_leaf': 100
    }
    # 模型训练
    gbm = lgb.train(params, train_set, valid_sets=[vali_set], num_boost_round=250)
    # 预测数据集
    y_pred = gbm.predict(X_test, num_iteration=gbm.best_iteration)
    # 模型保存
    gbm.save_model(r"./model.txt")
    
    展开全文
  • Lightgbm模型测试

    千次阅读 2019-02-13 10:43:55
    一.数据预处理 1.现在运用随机抽取曝光和点击的... 关键抽取代码如下: ...#lightgbm模型 def lightgbm_too(): x_train = pd.read_csv(r'C:\Users\MeetYou\PycharmProjects\untitled1\data7.csv') x_train=x_t...

    一.数据预处理

    1.现在运用随机抽取曝光和点击的数据各600000条,500000条:

    关键抽取代码如下:

    #lightgbm模型
    def lightgbm_too():
        x_train = pd.read_csv(r'C:\Users\MeetYou\PycharmProjects\untitled1\data7.csv')
        x_train=x_train.dropna()
        #下采样
        # x_train=downSample(x_train,1)
        y_train = x_train.dropna().label
        #所有的label减1
        y_train=y_train[:]-1
        x_train=x_train.drop(labels="label",axis=1)
        x_train, x_test, y_train, y_test = train_test_split(x_train, y_train, test_size=0.2,
                                                              random_state=1)  # 分训练集和验证集
        train_x, valid_x, train_y, valid_y = train_test_split(x_train, y_train, test_size=0.1,
                                                              random_state=1)  # 分训练集和验证集
    
        # train_x, train_y = smote1(x_train, y_train)
        train = lgb.Dataset(train_x, train_y, free_raw_data=False)
        eval = lgb.Dataset(valid_x, valid_y, free_raw_data=False)
    
        params = {
            'boosting_type': 'gbdt',
            'boosting': 'dart',
            'learning_rate': 0.3,
            'num_leaves': 25,
            'max_depth': 15,
            'min_data_in_leaf': 25,
            'feature_fraction': 0.8,
            'bagging_fraction': 1,
            'bagging_freq': 1,
            'lambda_l1': 1,
            'lambda_l2': 1,
            'min_split_gain':0.5,
            'objective': 'binary',
            'metric': 'auc',
            'is_unbalance':True
        }
        model = lgb.train(params,  # 参数字典
                          train,  # 训练集
                          num_boost_round=10000,  # 迭代次数
                          valid_sets=[eval, train],  # 验证集
                          early_stopping_rounds=4500)  # 早停系数
        # xgboost保存模型
        model.save_model(r'C:\Users\MeetYou\PycharmProjects\untitled1\test.model')
        y_pred = model.predict(x_test)
        plot_auc(y_test,y_pred)
        y_pred_0 = 0
        y_pred_1 = 0
        for i in range(0, len(y_pred)):
            if y_pred[i] > 0.5:
                y_pred[i] = 1
                y_pred_1 += 1
            else:
                y_pred[i] = 0
                y_pred_0 += 1
        print("y_pred_0:", y_pred_0)
        print("y_pred_1:", y_pred_1)
        do_metrics(y_test,y_pred)
        plot_importance(model)
        plt.show()
    展开全文
  • 使用LightGBM训练模型。 将模型保存到本地文件系统中的文本文件中。 使用JPMML-LightGBM命令行转换器应用程序将此文本文件转换为PMML文件。 LightGBM操作方面 使用软件包为示例波士顿住房数据集训练回归模型: ...
  • 本文讲一下利用tornado框架简单部署lightgbm模型服务的demo,具体步骤如下: 首先,准备好线下训练好的lightgbm模型文件,本文使用iris数据集训练得到。 然后,部署代码deploy.py如下: import tornado.ioloop ...
  • 之前的文章(pyspark lightGBM1和pyspark lightGBM2)介绍了pyspark下lightGBM算法的实现,本文将重点介绍下如何保存训练好的模型,直接上代码: from pyspark.sql import SparkSession from pyspark.ml.feature ...
  • 使用hyperopt(Bayesian optimization)为lightGBM模型挑选最优参数进行模型构建、by Cross Validation.pdf
  • 今日表情 ????Spark-scala 可以使用LightGBM模型,既可以进行分布式训练,也可以进行分布式预测,支持各种参数设置。支持模型保存,并且保存后的模型和Python等语...
  • xgboost与lightgbm模型融合做天池比赛二手车价格预测总结 前言 什么是AI? The theory and development of computer systems able to perform tasks normally requiring human intelligence.(–Oxford Dictionary) ...
  • Lightgbm模型两种保存方式

    千次阅读 2019-12-17 11:36:15
    一、原生形式使用lightgbm(import lightgbm as lgb) # 模型训练 gbm = lgb.train(params, lgb_train, num_boost_round=20, valid_sets=lgb_eval, early_stopping_rounds=5) # 模型保存 gbm.save_model('model.txt...
  • 数据竞赛-“达观杯”文本智能处理-Day5:LightGBM模型1.理论学习2.实践 【Task3.2】LightGBM模型 构建LightGBM的模型(包括:模型构建&调参&性能评估),学习理论并用Task2的特征实践 要求:理论+代码+截图...
  • 使用hyperopt为lightGBM模型挑选最优参数进行模型构建
  • lightgbm模型是微软开源的一个模型,比xgboost快个10倍左右,原始训练使用的是c++,也提供了python接口,晚上摸索了下lightgbm在python中训练,转化为pmml语言,在java中调用,过程碰到不少坑,记录下,首先是 git ...
  • 银行客户交易行为预测:LightGBM模型

    千次阅读 2019-03-30 11:41:03
    这是“银行客户交易行为预测”的第三篇文章,我们将建立LightGBM模型预测客户交易行为。结果的交叉验证分数显示,该模型预测效果比较理想。 准备工作 加载包 import gc import os import logging import datetime ...
  • LightGBM模型_相关资料整理

    千次阅读 2018-08-15 18:36:16
    LightGBM 的中文文档 比XGBOOST更快–LightGBM介绍
  • 一、模型预测Pipeline 1. model_pipeline.sh hive表拉取预测数据 预测数据切分 模型打分 打分数据整合 数据上传 # 1.从hive表中拉去预测数据到本地(模型工程目录) /app/hadoop/hive/bin/hive -e " use db_...
  • LightGBM模型文件保存pmml形式

    千次阅读 2020-11-04 21:19:33
    LightGBM保存pmml形式 1.先保存成txt文件 from sklearn2pmml import PMMLPipeline gbm.save_model("c:\\data_set\\lightgbm.txt") 2.再用 jpmml-lightgbm-executable-1.3-SNAPSHOT.jar 文件编译成pmml文件。进入...
  • 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.
  • # 模型训练 gbm = lgb.train(params, lgb_train, num_boost_round=20, valid_sets=lgb_eval, early_stopping_rounds=5) # 模型保存 gbm.save_model('model.txt') # 模型加载 gbm = ...
  • lightgbm模型实例

    千次阅读 2018-05-16 14:07:13
    df_train_X, df_train_Y = data_process(train_n) train_data = lgb.Dataset(df_train_X, label=df_train_Y) param = {'num_leaves': 10, 'num_trees': 50, 'objective': 'regression'... gbm=lgb.train(param, tr...
  • lightgbm模型处理类别型特征

    千次阅读 2021-01-16 20:39:32
    本文主要想说的是直接将字符串值传到lightgbm中训练。注意:xgboost模型也需要提前one-hot编码转换才能入模。 下面是代码: a = [i for i in range(1000)] b = ["tag","bga","efd","rfh","esg","tyh"] c = [b...
  • lightgbm是微软开源的一款gbdt模型库,支持二分类,多分类,lambdarank等各种不同的机器学习任务,有着训练快,支持分布式训练等等诸多优点。但lightgbm在java方面的支持不如xgboost,没有封装好的java driver供...
  • 1.打包conda虚拟环境 (1)cd到conda虚拟环境目录 cd /home/work/.conda/envs (2)把虚拟环境打包 zip -r -q lgb.zip light_gbm/ ...os.environ['PYSPARK_PYTHON'] = './light_gbm/light_gbm/bin/python' from pys
  • lightGBM模型训练完之后,Dataset的数据就会被清空,虽然在变量中它还存在,但实际已经被清空了,所以要再使用的话,需要重新生成! 二、补充知识点: lightGBM 模型训练时,输入的数据类型是 Dataset 格式...
  • Article directoryLightBGM理论Histogram算法带深度限制的Leaf-wise的叶子生长策略LightGBM实践自己设定参数GridSearchCV调参 LightBGM理论 LightGBM 是一个轻量级梯度 boosting 框架,使用基于学习算法的决策树。它...
  • 最近入迷研究各种股票分析的指标,一想不如用熟悉的Python帮忙搞一搞,顺便做了一个二分类预测模型,供大家参考学习,也欢迎有量化分析兴趣的朋友沟通交流! Python中使用akshare这个第三方库来获取股票市场的数据...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,154
精华内容 2,861
关键字:

lightgbm模型