精神分裂症患者GAF评分的可视化分析|使用集成学习模型 LightGBM

一、集成学习的知识点

1. 集成学习（Ensemble Learning）

集成学习是机器学习中通过组合多个模型（称为基学习器 ）的预测结果来提升整体性能的方法。其主要思想是 "集体智慧"，多个简单模型的组合通常比单个模型更强大、更稳健。

集成学习主要有两种策略：

Bagging（Bootstrap Aggregating） ：例如 随机森林（Random Forest），通过训练多个独立的模型并对其结果进行平均（回归任务）或投票（分类任务），来降低方差并避免过拟合。
Boosting ：例如 Gradient Boosting 和 LightGBM，逐步训练模型，每个新模型都试图纠正前一个模型的错误，减少偏差并提高准确度。

2. LightGBM（Light Gradient Boosting Machine）

LightGBM 是微软开发的一个 梯度提升决策树 （GBDT）框架，基于 Boosting 方法。它通过多颗决策树的组合来优化模型性能，并且比传统的 GBDT 方法更高效。LightGBM 具有以下特点：

高效性：使用了基于直方图的决策树学习方法，大大减少了计算量。
处理大数据：能够处理大规模数据集，适用于大数据场景。
支持分类特征：能够直接处理类别特征，不需要额外的预处理。
并行与分布式训练：支持多线程并行计算，能够加速训练过程。

3. 集成学习中 LightGBM 的工作原理

3.1 Boosting（提升方法）

Boosting 是通过逐步构建模型并加权组合多个基学习器（通常是决策树）。每个模型都基于前一个模型的错误进行修正。这个过程反复进行，直到模型达到预定的停止条件。

3.2 工作流程

初始化模型：首先，训练一个基础的决策树模型。
计算残差：计算当前模型的预测与真实值之间的误差（残差）。
训练下一个模型：根据残差训练新的决策树模型，使其在之前模型的基础上进行改进。
模型加权：将每个模型的预测结果根据一定的权重进行组合，得到最终预测。

Boosting 的工作原理

初始模型 -> 残差计算 -> 新模型 -> 残差计算 -> 新模型 -> ... -> 最终组合

3.3 LightGBM 特性：

基于决策树的模型：每个基学习器是一个决策树，通过合并多个树的预测结果来提高模型的准确度。
使用直方图优化：通过将连续特征值分桶，减少计算开销，从而提高训练效率。
支持类别特征：LightGBM 能够直接处理类别特征，无需进行独热编码（One-Hot Encoding）。
并行训练：LightGBM 支持基于数据并行和特征并行的训练方式，有效提升大数据的训练速度。

4. LightGBM 与传统 GBDT 的比较

特性	LightGBM	传统 GBDT
数据处理方式	使用直方图算法，减少内存占用	不使用直方图，内存占用较高
训练速度	较快，尤其在大数据集上	相对较慢，尤其在大数据集上
内存占用	较低，适合大规模数据	较高，需要更多的内存
支持类别特征	直接支持，不需要额外的预处理	需要手动进行类别特征的转换（如独热编码）
处理缺失值	内置处理缺失值的机制	需要预处理缺失值

5. LightGBM 的训练过程

在 LightGBM 中，模型通过训练多颗决策树来提高准确性。每颗决策树都通过 Boosting 方法逐步优化，最终的预测是所有决策树预测的加权平均。

LightGBM 训练过程

初始模型 (决策树)  
  ↓
计算残差
  ↓
训练下一个决策树，优化残差
  ↓
逐步增加决策树并加权组合
  ↓
最终模型预测

二、数据可视化分析

精神分裂症数据集，是一个包含精神分裂症人口统计和临床数据的综合数据集，它是研究人员、医生和数据科学家的宝贵资源。该数据集包括患者的诊断状态、症状评分、治疗史和社会因素。

这里将对数据集进行精神分裂症患者GAF评分的重要性可视化分析。

代码目标：通过对精神分裂症数据集进行GAF评分，并进行可视化分析，能够了解患者功能状态的分布和变化，探索不同特征对 GAF_Score 的影响，可以进行精神分裂症患者 GAF 评分的预测。

我的环境：

操作系统：windows10
语言环境：Python3.9
编译器：Jupyter notebook
环境：scikit-learn==1.5.1

第一步：导入库

python 复制代码

import os
import numpy as np
import pandas as pd
import random
import matplotlib.pyplot as plt
import seaborn as sns

from contextlib import contextmanager
from time import time
from tqdm import tqdm
import lightgbm as lgbm
import category_encoders as ce

from tensorflow.keras.utils import to_categorical
from sklearn.metrics import classification_report, log_loss, accuracy_score
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import KFold

第二步：数据读取和预处理

读取CSV文件

python 复制代码

data0 = pd.read_csv("schizophrenia_dataset.csv")     #调用 pandas 库的 read_csv 方法，从当前工作目录中读取名为 schizophrenia_dataset.csv 的文件
data0[0:2].T     #查看前两行并转置

代码输出：

| | 0 | 1 |
| Hasta_ID | 1 | 2 |
| Yaş | 72 | 49 |
| Cinsiyet | 1 | 1 |
| Eğitim_Seviyesi | 4 | 5 |
| Medeni_Durum | 2 | 2 |
| Meslek | 0 | 2 |
| Gelir_Düzeyi | 2 | 1 |
| Yaşadığı_Yer | 1 | 0 |
| Tanı | 0 | 1 |
| Hastalık_Süresi | 0 | 35 |
| Hastaneye_Yatış_Sayısı | 0 | 1 |
| Ailede_Şizofreni_Öyküsü | 0 | 1 |
| Madde_Kullanımı | 0 | 1 |
| İntihar_Girişimi | 0 | 1 |
| Pozitif_Semptom_Skoru | 32 | 51 |
| Negatif_Semptom_Skoru | 48 | 63 |
| GAF_Skoru | 72 | 40 |
| Sosyal_Destek | 0 | 2 |
| Stres_Faktörleri | 2 | 2 |

İlaç_Uyumu	2	0

pd.read_csv()：调用 pandas 库的 read_csv 方法，从当前工作目录中读取名为 schizophrenia_dataset.csv 的文件。

将文件内容解析为一个 DataFrame 对象，并赋值给变量 data0。

关键参数说明：
"schizophrenia_dataset.csv"：
文件路径（相对路径或绝对路径），默认从代码所在目录查找文件。如果文件不在当前目录，需指定完整路径（如C:/data/schizophrenia_dataset.csv）。
其他可选参数：
encoding: 指定文件编码（如 encoding='utf-8'）。
header: 指定标题行（默认 header=0，即第一行为列名）。
na_values: 定义缺失值标记（如 na_values=['NA', '?']）。

data0[0:2].T：

data0[0:2]：使用切片语法 [0:2] 选取 data0 的前两行（索引为0和1的行）。返回一个新的DataFrame，仅包含前两行数据。
.T：对结果进行转置（Transpose），将行和列交换。原数据中的行（患者记录）变为列，列（字段名）变为行。

python 复制代码

data0.columns.tolist()       #将数据框（DataFrame）的列名转换为 Python 列表（List）

代码输出：

['Hasta_ID',
 'Yaş',
 'Cinsiyet',
 'Eğitim_Seviyesi',
 'Medeni_Durum',
 'Meslek',
 'Gelir_Düzeyi',
 'Yaşadığı_Yer',
 'Tanı',
 'Hastalık_Süresi',
 'Hastaneye_Yatış_Sayısı',
 'Ailede_Şizofreni_Öyküsü',
 'Madde_Kullanımı',
 'İntihar_Girişimi',
 'Pozitif_Semptom_Skoru',
 'Negatif_Semptom_Skoru',
 'GAF_Skoru',
 'Sosyal_Destek',
 'Stres_Faktörleri',
 'İlaç_Uyumu']

python 复制代码

data1=data0.copy()    #深拷贝（Deep Copy），创建一个与 data0 完全独立的副本 data1，包括所有数据、索引和列名
data1

代码输出：

| | Hasta_ID | Yaş | Cinsiyet | Eğitim_Seviyesi | Medeni_Durum | Meslek | Gelir_Düzeyi | Yaşadığı_Yer | Tanı | Hastalık_Süresi | Hastaneye_Yatış_Sayısı | Ailede_Şizofreni_Öyküsü | Madde_Kullanımı | İntihar_Girişimi | Pozitif_Semptom_Skoru | Negatif_Semptom_Skoru | GAF_Skoru | Sosyal_Destek | Stres_Faktörleri | İlaç_Uyumu |
| 0 | 1 | 72 | 1 | 4 | 2 | 0 | 2 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 32 | 48 | 72 | 0 | 2 | 2 |
| 1 | 2 | 49 | 1 | 5 | 2 | 2 | 1 | 0 | 1 | 35 | 1 | 1 | 1 | 1 | 51 | 63 | 40 | 2 | 2 | 0 |
| 2 | 3 | 53 | 1 | 5 | 3 | 2 | 1 | 0 | 1 | 32 | 0 | 1 | 0 | 0 | 72 | 85 | 51 | 0 | 1 | 1 |
| 3 | 4 | 67 | 1 | 3 | 2 | 0 | 2 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 10 | 21 | 74 | 1 | 1 | 2 |
| 4 | 5 | 54 | 0 | 1 | 2 | 0 | 2 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 4 | 27 | 98 | 0 | 1 | 0 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
| 9995 | 9996 | 72 | 0 | 2 | 3 | 3 | 0 | 1 | 1 | 18 | 1 | 1 | 0 | 1 | 84 | 74 | 54 | 1 | 1 | 1 |
| 9996 | 9997 | 27 | 0 | 3 | 3 | 3 | 0 | 0 | 1 | 6 | 6 | 0 | 0 | 0 | 99 | 50 | 53 | 2 | 2 | 0 |
| 9997 | 9998 | 31 | 1 | 3 | 2 | 0 | 0 | 0 | 1 | 29 | 9 | 1 | 1 | 0 | 65 | 65 | 60 | 1 | 1 | 1 |
| 9998 | 9999 | 56 | 1 | 4 | 1 | 1 | 2 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 38 | 10 | 74 | 0 | 1 | 2 |

9999	10000	53	0	1	3	1	0	1	0	0	0	0	0	0	24	21	87	1	2	0

10000 rows × 20 columns

data.copy(deep=True):

参数：
deep=True（默认）：深拷贝所有数据。
deep=False：浅拷贝（仅复制索引和列名，不复制底层数据，极少使用）。

深拷贝（Deep Copy）：

创建一个与 data0 完全独立的副本 data1，包括所有数据、索引和列名。
对 data1 的后续修改不会影响原始数据 data0。
若直接赋值 data1 = data0，两者将共享同一内存地址（浅拷贝），修改任一变量会影响另一个。
使用 .copy()可避免数据操作中的意外污染原始数据。

第三步：设置目标变量与特征

定义模型预测的目标变量，如分类任务中的疾病诊断标签或回归任务中的症状评分。

python 复制代码

target= 'GAF_Skoru'                 # 定义目标变量列名 'GAF_Skoru'
datay=data1[target]                 #移除目标列后的特征数据（自变量），生成 datax
datax=data1.drop(target,axis=1)     # 提取特征变量数据

python 复制代码

train=np.array(datax)                 #将 datax 转换为 NumPy数组，以便输入到机器学习模型
trainy=np.array(datay)                # 将目标变量 datay 转换为 NumPy数组

df_columns = list(datax.columns)      #将 datax 的列名保存为列表 df_columns，用于后续列名恢复
print(df_columns)

代码输出：

['Hasta_ID', 'Yaş', 'Cinsiyet', 'Eğitim_Seviyesi', 'Medeni_Durum', 'Meslek', 'Gelir_Düzeyi', 'Yaşadığı_Yer', 'Tanı', 'Hastalık_Süresi', 'Hastaneye_Yatış_Sayısı', 'Ailede_Şizofreni_Öyküsü', 'Madde_Kullanımı', 'İntihar_Girişimi', 'Pozitif_Semptom_Skoru', 'Negatif_Semptom_Skoru', 'Sosyal_Destek', 'Stres_Faktörleri', 'İlaç_Uyumu']

python 复制代码

train_df=pd.DataFrame(train)       #将 NumPy 数组 train 转换为 DataFrame train_df

train_df.columns=df_columns

python 复制代码

#定义一个名为 create_numeric_feature 的函数，接收一个 DataFrame 参数 input_df，特征创建和处理
def create_numeric_feature(input_df):
    use_columns = df_columns 
    return input_df[use_columns].copy()    #从输入的 DataFrame input_df 中筛选 use_columns 指定的列，生成一个独立的副本,并返回筛选后的数据

python 复制代码

from contextlib import contextmanager
from time import time

#实现一个可通过 with 语句自动计时的工具类 Timer，支持日志输出和格式自定义
class Timer:
    def __init__(self, logger=None, format_str='{:.3f}[s]', prefix=None, suffix=None, sep=' '):

        if prefix: format_str = str(prefix) + sep + format_str
        if suffix: format_str = format_str + sep + str(suffix)
        self.format_str = format_str
        self.logger = logger
        self.start = None
        self.end = None

    @property
    def duration(self):
        if self.end is None:
            return 0
        return self.end - self.start

    def __enter__(self):
        self.start = time()

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.end = time()
        out_str = self.format_str.format(self.duration)
        if self.logger:
            self.logger.info(out_str)
        else:
            print(out_str)

python 复制代码

from tqdm import tqdm     #导入进度条库

#将原始数据 input_df 转换为特征数据
def to_feature(input_df):

    processors = [
        create_numeric_feature,               #定义一组特征处理函数（processors），此处仅包含 create_numeric_feature
    ]
    
    out_df = pd.DataFrame()                   #创建一个空的 DataFrame，用于逐步合并各处理函数的输出结果

    # 遍历处理函数并执行
    for func in tqdm(processors, total=len(processors)):
        with Timer(prefix='create' + func.__name__ + ' '):           #Timer 记录每个处理函数的执行时间
            _df = func(input_df)                                     #调用 func(input_df) 对输入数据应用当前处理逻辑，生成临时结果 _df

        assert len(_df) == len(input_df), func.__name__              #验证处理后的数据 _df 的样本数（行数）与原始数据 input_df 一致
        out_df = pd.concat([out_df, _df], axis=1)                    #将临时结果 _df 按列（axis=1）合并到 out_df 中
        
    return out_df         #返回最终特征数据

python 复制代码

# 将原始训练数据 train_df 转换为适合机器学习模型训练的特征数据 train_feat_df
#训练数据的预处理和特征处理
train_feat_df = to_feature(train_df)

代码输出：

100%|███████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 155.28it/s]

createcreate_numeric_feature  0.004[s]

tqdm（from tqdm import tqdm）：进度条显示，在循环或长时间任务中实时显示进度，提升用户体验。

第四步：模型训练

python 复制代码

import lightgbm as lgbm                             #用于训练 LightGBM 回归模型
from sklearn.metrics import mean_squared_error      #计算均方误差（MSE），进而得到 RMSE

#定义函数 fit_lgbm，用于训练 LightGBM 回归模型并进行交叉验证，输出每个折叠（fold）的验证结果和整体性能指标（RMSE），并返回所有训练好的模型和交叉验证的预测结果
def fit_lgbm(X, y, cv, 
             params: dict=None, 
             verbose: int=50):

    if params is None:
        params = {}

    models = []            #保存每个折叠训练出的 LightGBM 模型
    oof_pred = np.zeros_like(y, dtype=float)           #存储交叉验证的"袋外预测"，用于计算整体验证误差


    #遍历交叉验证折叠
    for i, (idx_train, idx_valid) in enumerate(cv): 
        x_train, y_train = X[idx_train], y[idx_train]
        x_valid, y_valid = X[idx_valid], y[idx_valid]

        clf = lgbm.LGBMRegressor(**params)              #创建 LightGBM 回归器实例，应用传入的超参数 params

        #训练模型并计时
        with Timer(prefix='fit fold={} '.format(i)):
            clf.fit(x_train, y_train, 
                    eval_set=[(x_valid, y_valid)])

        #预测验证集并保存结果
        pred_i = clf.predict(x_valid)           #对当前验证集的预测结果
        oof_pred[idx_valid] = pred_i            #将预测值按索引填入对应位置，最终拼接完整预测结果
        models.append(clf)                      #保存当前折叠的模型

        #输出当前折叠性能
        print(f'Fold {i} RMSLE: {mean_squared_error(y_valid, pred_i) ** .5:.4f}')    #通过均方误差的平方根衡量模型性能
        print()

    #计算整体性能并返回结果
    score = mean_squared_error(y, oof_pred) ** .5
    print('-' * 50)
    print('FINISHED | Whole RMSLE: {:.4f}'.format(score))
    return oof_pred, models

lightgbm（import lightgbm as lgbm ）：高效梯度提升框架，支持快速训练大规模数据，内置并行化和直方图优化，适用于分类/回归任务，用于构建机器学习模型。

功能：
主要用于构建决策树模型，支持分类、回归任务。
训练速度快，内存消耗低，适合大数据集。
常见用途：
训练模型：lgbm.LGBMClassifier()、lgbm.LGBMRegressor()。
模型训练：model.fit()。

mean_squared_error（from sklearn.metrics import mean_squared_error ）：均方误差（MSE）计算，回归任务中预测值与真实值差异的平方均值，衡量模型预测偏差。

功能：
用于评估回归模型的预测精度。
常见用途：
评估模型：mean_squared_error(y_true, y_pred)。

python 复制代码

# LightGBM 参数字典
params = {
    'objective': 'rmse', 
    'learning_rate': .1,
    'reg_lambda': 1.,
    'reg_alpha': .1,
    'max_depth': 5, 
    'n_estimators': 1000, 
    'colsample_bytree': .5, 
    'min_child_samples': 10,
    'subsample_freq': 3,
    'subsample': .9,
    'importance_type': 'gain', 
    'random_state': 71,
    'num_leaves': 62
}

python 复制代码

#提取目标变量并转为DataFrame
y = trainy             #将训练集目标变量赋值给 y
ydf=pd.DataFrame(y)    #转换为 DataFrame

python 复制代码

from sklearn.model_selection import KFold       #导入KFold交叉验证工具

#交叉验证
for i in range(1):
    fold = KFold(n_splits=5, shuffle=True, random_state=71)     #初始化KFold交叉验证器
    ydfi=ydf.iloc[:,i]      #提取第 i 列目标变量
    y=np.array(ydfi)        #转换为 NumPy 数组，适配模型输入格式
    cv = list(fold.split(train_feat_df, y))     #生成训练集和验证集的索引对，并将迭代器转换为列表
    oof, models = fit_lgbm(train_feat_df.values, y, cv, params=params)     #调用函数训练模型并获取交叉验证结果

    #绘制真实值与预测值的散点图
    fig,ax = plt.subplots(figsize=(6,6))
    ax.set_title(target,fontsize=20)
    ax.set_xlabel('true',fontsize=12)
    ax.set_ylabel('pred',fontsize=12)
    ax.scatter(y,oof,alpha=0.3)

代码输出：

[LightGBM] [Info] Auto-choosing row-wise multi-threading, the overhead of testing was 0.000533 seconds.
You can set `force_row_wise=true` to remove the overhead.
And if memory is not enough, you can set `force_col_wise=true`.
[LightGBM] [Info] Total Bins 611
[LightGBM] [Info] Number of data points in the train set: 8000, number of used features: 19
[LightGBM] [Info] Start training from score 67.125750
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
  ......
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
fit fold=4  1.644[s]
Fold 4 RMSLE: 13.4798
--------------------------------------------------
FINISHED | Whole RMSLE: 13.7042

KFold（from sklearn.model_selection import KFold ）：交叉验证（Cross Validation）的一种方法，用于评估机器学习模型的性能，用于将数据集划分为 K 个子集（也称为折），然后进行 K 次模型训练和验证，每次使用不同的子集作为验证集，其余的作为训练集。每次迭代后，模型会在不同的验证集上评估其性能，这样可以减少模型的评估偏差（因为数据集划分的方式不会影响结果）。

例如，如果 K=5，数据会被分成 5 个子集，然后模型会进行 5 次训练，每次训练都使用 4 个子集作为训练集，剩下的 1 个子集作为验证集。最终，所有折叠的模型评估结果将会进行合并，得到一个更稳定、更可靠的性能度量。

常用参数：

n_splits：指定将数据集划分为多少个折叠（默认值为 5）。例如，n_splits=5 将数据集分成 5 个子集，每个子集轮流作为验证集。
shuffle：是否对数据进行随机打乱（默认值为 False）。如果为 True，则在划分折叠之前会打乱数据集，以避免数据的顺序影响交叉验证的结果。
random_state：控制随机数生成器的种子，确保每次执行时划分的折叠是一样的。如果设置为 None，则每次运行时划分会是不同的；如果指定为一个整数（例如 random_state=42），则每次运行时数据划分都会相同。
verbose：设置为 True 时，可以输出详细的日志信息，帮助调试。

工作流程：

将数据集按照 n_splits 指定的折数划分成相应数量的子集。
对于每一折：
选择一个子集作为验证集。
其他 n_splits-1 个子集作为训练集。
使用训练集训练模型，使用验证集评估模型性能。
交叉验证完成后，通常会计算 K 次训练的平均性能指标，以得到更加稳定的模型评估结果。

第五步：特征重要性可视化

python 复制代码

#定义可视化函数，接收两个参数
def visualize_importance(models, feat_train_df):

    feature_importance_df = pd.DataFrame()         #初始化存储特征重要性数据的 DataFrame

    #遍历模型，提取每个模型的特征重要性
    for i, model in enumerate(models):            #对传入的模型列表 models 中的每个模型进行遍历
        _df = pd.DataFrame()
        _df['feature_importance'] = model.feature_importances_   #获取当前模型的特征重要性
        _df['column'] = feat_train_df.columns       #存储特征的名称
        _df['fold'] = i + 1     #表示该特征重要性来自第几个模型（折数）
        feature_importance_df = pd.concat([feature_importance_df, _df], 
                                          axis=0, ignore_index=True)      #将每个模型的特征重要性数据合并

    ##按特征（column）分组，并对特征重要性求和，并按特征重要性降序排列，获取排名前 50 的特征名称
    order = feature_importance_df.groupby('column')\
        .sum()[['feature_importance']]\
        .sort_values('feature_importance', ascending=False).index[:50]     

	#创建一个图形，并设置其尺寸。图的高度根据所选的前 50 个特征的数量动态调整
    fig, ax = plt.subplots(figsize=(8, max(6, len(order) * .25)))     

    # 绘制增强箱型图（Boxenplot）
    sns.boxenplot(data=feature_importance_df, 
                  x='feature_importance', 
                  y='column', 
                  order=order, 
                  ax=ax, 
                  palette='viridis', 
                  orient='h')
    
    #设置图表样式
    ax.tick_params(axis='x', rotation=0)
    #ax.set_title('Importance')
    ax.grid()
    fig.tight_layout()
    
    return fig,ax    #返回图形和坐标轴

定义函数 visualize_importance，可视化多个模型的特征重要性，通过绘制一个增强箱型图（Boxenplot）来展示每个特征在多个模型中的重要性。

python 复制代码

for i in range(1):
    fold = KFold(n_splits=5, shuffle=True, random_state=71)      #初始化 KFold 交叉验证器，将数据集分成 5 个折叠
    ydfi=ydf.iloc[:,i]       #从目标变量 ydf 中提取第 i 列
    y=np.array(ydfi)         #转换为 NumPy 数组，适配模型输入格式
    cv = list(fold.split(train_feat_df, y))      #生成训练集和验证集的索引对，并将生成器转换为列表

	#训练 LightGBM 模型并获得交叉验证结果，
    oof, models = fit_lgbm(train_feat_df.values, y, cv, params=params, verbose=500)      #将特征数据转换为 NumPy 数组

上面的代码实现 K折交叉验证，并使用 LightGBM 模型进行训练，并返回交叉验证结果。

oof： Out-Of-Fold 预测结果，即在交叉验证过程中，验证集上的模型预测结果。

models：包含训练过程中生成的每个模型（每一折的模型）。

代码输出：

bash 复制代码

[LightGBM] [Info] Auto-choosing row-wise multi-threading, the overhead of testing was 0.000633 seconds.
You can set `force_row_wise=true` to remove the overhead.
And if memory is not enough, you can set `force_col_wise=true`.
[LightGBM] [Info] Total Bins 611
[LightGBM] [Info] Number of data points in the train set: 8000, number of used features: 19
[LightGBM] [Info] Start training from score 67.125750
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
......
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
fit fold=4  1.644[s]
Fold 4 RMSLE: 13.4798

--------------------------------------------------
FINISHED | Whole RMSLE: 13.7042

python 复制代码

# 生成图形，并通过增强箱型图可视化每个特征的重要性
fig, ax = visualize_importance(models, train_feat_df)
#设置图表标题
ax.set_title(target+' Imortance',fontsize=20)

python 复制代码

#在图表中添加文本，用于设置图表的标题
Text(0.5, 1.0, 'GAF_Skoru Imortance')

代码输出：

精神分裂症患者GAF评分的可视化分析|使用集成学习模型 LightGBM

一、 集成学习的知识点

1. 集成学习（Ensemble Learning）

2. LightGBM（Light Gradient Boosting Machine）

3. 集成学习中 LightGBM 的工作原理

3.1 Boosting（提升方法）

3.2 工作流程

3.3 LightGBM 特性：

4. LightGBM 与传统 GBDT 的比较

5. LightGBM 的训练过程

二、数据可视化分析

第一步：导入库

第二步：数据读取和预处理

第三步：设置目标变量与特征

第四步：模型训练

第五步：特征重要性可视化

一、集成学习的知识点