LightGBM超参数实验

最新推荐文章于 2024-05-09 15:27:14 发布
最新推荐文章于 2024-05-09 15:27:14 发布
阅读量642 收藏 4
点赞数 1
分类专栏： Data Science with Python 文章标签： 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mart_inn/article/details/127485268
版权

文章目录

数据集

数据集：威斯康星州乳腺癌数据

代码

import numpy as np 
import pandas as pd 
import seaborn as sns
import matplotlib.pyplot as plt
from scipy import stats
import json
import sklearn
%matplotlib inline

#sklearn library
# 1.model_selection
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import cross_val_score, KFold
from sklearn.model_selection import StratifiedKFold

# 2.preprocessing
from sklearn.preprocessing import OrdinalEncoder
from sklearn.preprocessing import MinMaxScaler

# 3.metrics
from sklearn.metrics import roc_auc_score
from sklearn.metrics import mean_squared_error
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix

# 4.model
import lightgbm as lgb
from bayes_opt import BayesianOptimization

# 5.plot
import scikitplot as skplt

import warnings
warnings.filterwarnings('ignore')


font = {'family':'Helvetica, Ariel',
        'weight':'normal',
        'size':12}
plt.rc('font', **font)
sns.set_context('notebook')
sns.set_style("ticks")
FIG_FONT = dict(family="Helvetica, Ariel", weight="bold", color="#7f7f7f")
sns.set_palette("Spectral")


df = pd.read_csv('../input/breast-cancer-wisconsin-data/data.csv')
df

df.diagnosis=[1 if i =='M' else 0 for i in df.diagnosis.values]
df.drop(['Unnamed: 32','id'],axis=1,inplace=True)

fig,ax = plt.subplots(figsize=(18, 18))
axes = sns.heatmap(df.corr(), annot=True, linewidths=.5, fmt= '.1f',ax=ax)

#Simply select the features with a correlation>0.5 with diagnosis
features = list(df.corr()[df.corr()['diagnosis']>0.5].index)
X=df[features]

fig, axes = plt.subplots(4,4,figsize=(20,20))

cnt = 0
for i in range(4):
    for j in range(4):
        feature_element = features[cnt]
        cnt+=1
        plt.sca(axes[i,j])
        sns.kdeplot(df[df.diagnosis==1][feature_element],shade=True,alpha=0.2,legend=True,label='diagnosis:M')
        sns.kdeplot(df[df.diagnosis==0][feature_element],shade=True,alpha=0.2,legend=True,label='diagnosis:B')
        plt.legend()

def process_df(df):    
    #1、Handling null values 
    df=df.dropna()
    
    #2、create y value by using "diagnosis", convert to int type 
    target=df.diagnosis
    df=df[features]
                                                 
    #3、Create the training and test datasets
    X_train, X_test, y_train, y_test = train_test_split(df, target, test_size = 0.2, 
                                                    random_state=100,stratify=target)
    
    #4、Obtaining continuous variable 
    numaric_columns=list(df.select_dtypes(include=np.number).columns)
    print("Numaric columns ("+str(len(numaric_columns))+") :",", ".join(numaric_columns))
    
    #5、Obtaining discrete variables 
    cat_columns=df.select_dtypes(include=['object']).columns.tolist()
    print("Categorical columns ("+str(len(cat_columns))+") :",", ".join(cat_columns))
    
    
    #6、Using continuous variable training data 
    X_train_n=X_train[numaric_columns].copy()
    X_test_n=X_test[numaric_columns].copy()
    scaler = MinMaxScaler()
    X_train_n_index = X_train_n.index
    X_test_n_index = X_test_n.index
    
    X_train_n = scaler.fit_transform(X_train_n)
    X_train_n = pd.DataFrame(X_train_n,index=X_train_n_index,columns = numaric_columns)
    
    X_test_n = scaler.transform(X_test_n)
    X_test_n = pd.DataFrame(X_test_n,index=X_test_n_index,columns = numaric_columns)

    #7、Using discrete variable training data 
    X_train_c=X_train[cat_columns]
    X_test_c=X_test[cat_columns]
                               
    #8、Ordinal label processing for discrete variables 
    encoder=OrdinalEncoder()
    X_train_c = encoder.fit_transform(X_train_c)
    
    X_train_c=pd.DataFrame(X_train_c,index=X_train_n.index)
    X_test_c = encoder.transform(X_test_c)
    X_test_c=pd.DataFrame(X_test_c,index=X_test_n.index)
    
    #9、Merge together
    for i,column in enumerate(X_train_c.columns):
        X_train_n["cat_"+str(i+1)]=X_train_c[column]
        X_test_n["cat_"+str(i+1)]=X_test_c[column]

    return X_train_n, X_test_n, y_train, y_test

X_train, X_test, y_train, y_test = process_df(df)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)

from bayes_opt import BayesianOptimization
from sklearn.model_selection import StratifiedKFold


target = 'diagnosis'
predictors = train_df.columns.values.tolist()[1:]
bayesian_tr_index, bayesian_val_index = list(StratifiedKFold(n_splits=2,
                                                             shuffle=True, random_state=1).split(train_df, train_df.diagnosis.values))[0]

def LGB_bayesian(
#     num_boost_round,
    num_leaves, 
    min_data_in_leaf, 
    learning_rate,
    min_sum_hessian_in_leaf, 
    feature_fraction,
    lambda_l1,
    lambda_l2,
    min_gain_to_split,
    max_depth,
#     early_stopping_rounds
):
    
    # LightGBM expects next three parameters need to be integer. So we make them integer
    num_leaves = int(num_leaves)
    min_data_in_leaf = int(min_data_in_leaf)
    max_depth = int(max_depth)
    
    # setting by experience
    num_boost_round = 1000
    early_stopping_rounds = 50
    
    param = {
        'num_boost_round':num_boost_round,
        'num_leaves': num_leaves,
#         'max_bin': 63,
        'min_data_in_leaf': min_data_in_leaf,
        'learning_rate': learning_rate,
        'min_sum_hessian_in_leaf': min_sum_hessian_in_leaf,
        'bagging_fraction': 1.0,
        'bagging_freq': 5,
        'feature_fraction': feature_fraction,
        'lambda_l1': lambda_l1,
        'lambda_l2': lambda_l2,
        'min_gain_to_split': min_gain_to_split,
        'max_depth': max_depth,
        'save_binary': True,
        'seed': 123,
        'objective': 'binary',
        'boosting_type': 'gbdt',
        #'verbose': 1,
        'verbosity': -1,
        'metric': 'auc',
        'is_unbalance': True,
        'boost_from_average': False,
#         'early_stopping_rounds': 50
    }
    xg_train = lgb.Dataset(train_df.iloc[bayesian_tr_index].values,
                           label=train_df.iloc[bayesian_tr_index][target].values,
                           feature_name=predictors,
                           free_raw_data = False)
    xg_valid = lgb.Dataset(train_df.iloc[bayesian_val_index].values,
                           label=train_df.iloc[bayesian_val_index][target].values,
                           feature_name=predictors,
                           free_raw_data = False)

    clf = lgb.train(param, 
                    num_boost_round = num_boost_round,
                    early_stopping_rounds = early_stopping_rounds,
                    train_set = xg_train,
                    valid_sets = [xg_valid],
                    verbose_eval=250)
    predictions = clf.predict(train_df.iloc[bayesian_val_index].values, num_iteration=clf.best_iteration)
    score = metrics.roc_auc_score(train_df.iloc[bayesian_val_index][target].values, predictions)
    return score

X_train = X_train[predictors]
X_test = X_test[predictors]

bounds_LGB = {
#     'num_boost_round':(100,5000),
    'num_leaves': (5, 20),
    'min_data_in_leaf': (5, 20),
    'learning_rate': (0.01, 0.3),
    'min_sum_hessian_in_leaf': (0.00001, 0.01),
    'feature_fraction': (0.05, 0.5),
    'lambda_l1': (0, 5.0),
    'lambda_l2': (0, 5.0),
    'min_gain_to_split': (0, 1.0),
    'max_depth':(2,6),
#     'early_stopping_rounds':(50,200)
}

LGB_BO = BayesianOptimization(LGB_bayesian, bounds_LGB, random_state=123)
print(LGB_BO.space.keys)

import warnings
from sklearn import metrics
init_points = 5
n_iter = 5
print('-' * 130)
LGB_BO.maximize(init_points=init_points, n_iter=n_iter, acq='ucb', xi=0.0, alpha=1e-6)
with warnings.catch_warnings():
    warnings.filterwarnings('ignore')


# setting by LGB_BO.max['params']
param = {'boosting_type':'gbdt','objective':'binary','metric':'binary_logloss',
    'num_boost_round':1000,
    'feature_fraction': 0.36341113351903775,
    'lambda_l1': 1.4306966747518972,
    'lambda_l2': 1.1342572678210154,
    'learning_rate': 0.16988128303403846,
    'max_depth':int( 4.877875879142252),
    'min_data_in_leaf': int( 11.346596901866913 ),
    'min_gain_to_split': 0.9807641983846155,
    'min_sum_hessian_in_leaf': 0.006851449088462784,
    'num_leaves': int( 12.213978522265414 ),
#     'num_class': 2,
    'early_stopping_rounds':50,
    'verbose': -1}

evals_result = {}  


train_data = lgb.Dataset(X_train, label = y_train)  
test_data = lgb.Dataset(X_test, label = y_test,reference=train_data)

model = lgb.train(param,      
                  train_data,      
                  valid_sets=[train_data,test_data],
                  evals_result=evals_result, # Record the calculated value of loss function in each round     
                  #verbose_eval=False) # How many rounds to output a training result,True/False/number      
                  verbose_eval=50)  
# print(params)  
# Draw the loss curve with the recorded loss function value  
lgb.plot_metric(evals_result, metric='binary_logloss') # The metric value corresponds to the previous params  
plt.show()    

from sklearn import metrics
model=lgb.LGBMClassifier(
    boosting_type='gbdt',objective='binary',metrics='logloss',
    feature_fraction = 0.36341113351903775 ,
    lambda_l1 = 1.4306966747518972 ,
    lambda_l2 = 1.1342572678210154 ,
    learning_rate = 0.16988128303403846 ,
    max_depth =int( 4.877875879142252 ),
    min_data_in_leaf =int( 11.346596901866913 ),
    min_gain_to_split = 0.9807641983846155 ,
    min_sum_hessian_in_leaf = 0.006851449088462784 ,
    num_leaves =int( 12.213978522265414 ),
    num_class = 1)
model.fit(X_train,y_train)
y_train_pred = model.predict(X_train)
y_test_pred = model.predict(X_test)
print("acc:",metrics.accuracy_score(y_test,y_test_pred))
print("auc:",metrics.roc_auc_score(y_test,y_test_pred))

skplt.metrics.plot_confusion_matrix(y_train_pred,y_train,figsize=(5,5), cmap= 'YlGnBu',title='train data confusion matrix')
skplt.metrics.plot_confusion_matrix(y_test_pred,y_test,figsize=(5,5), cmap= 'YlGnBu',title='test data confusion matrix')

y_train_pred_prob = model.predict_proba(X_train)[:, 1]
y_test_pred_prob = model.predict_proba(X_test)[:, 1]

fpr_train, tpr_train, thresholds = metrics.roc_curve(y_train, y_train_pred_prob)
fpr_test, tpr_test, thresholds = metrics.roc_curve(y_test, y_test_pred_prob)

fig,axes = plt.subplots(1,2,figsize=(12,5))

plt.sca(axes[0])
plt.plot(fpr_train, tpr_train, linewidth=2, color= 'teal')
plt.plot([0,1], [0,1], 'r--' )
plt.title('ROC Curve of train data')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')

plt.sca(axes[1])
plt.plot(fpr_test, tpr_test, linewidth=2, color= 'teal')
plt.plot([0,1], [0,1], 'r--' )
plt.title('ROC Curve of test data')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')

plt.show()

plt.figure(figsize=(12,6))
lgb.plot_importance(model, max_num_features=10)
plt.title("Featurertances")
plt.show()

结果

1、参数：

[‘feature_fraction’, ‘lambda_l1’, ‘lambda_l2’, ‘learning_rate’, ‘max_depth’, ‘min_data_in_leaf’, ‘min_gain_to_split’, ‘min_sum_hessian_in_leaf’, ‘num_leaves’]

| iter | target | featur… | lambda_l1 | lambda_l2 | learni… | max_depth | min_da… | min_ga… | min_su… | num_le… |

Training until validation scores don’t improve for 50 rounds
Early stopping, best iteration is:
[16] valid_0’s auc: 0.985315
| 1 | 0.9853 | 0.3634 | 1.431 | 1.134 | 0.1699 | 4.878 | 11.35 | 0.9808 | 0.006851 | 12.21 |
Training until validation scores don’t improve for 50 rounds
Early stopping, best iteration is:
[17] valid_0’s auc: 0.982435
| 2 | 0.9824 | 0.2265 | 1.716 | 3.645 | 0.1372 | 2.239 | 10.97 | 0.738 | 0.001833 | 7.632 |
Training until validation scores don’t improve for 50 rounds
Early stopping, best iteration is:
[21] valid_0’s auc: 0.982188
| 3 | 0.9817 | 0.2892 | 2.659 | 3.172 | 0.2563 | 4.898 | 14.17 | 0.7224 | 0.003236 | 10.43 |
Training until validation scores don’t improve for 50 rounds
Early stopping, best iteration is:
[13] valid_0’s auc: 0.984286
| 4 | 0.9843 | 0.1527 | 1.469 | 3.155 | 0.03671 | 3.735 | 11.46 | 0.4937 | 0.004264 | 9.684 |
Training until validation scores don’t improve for 50 rounds
Early stopping, best iteration is:
[43] valid_0’s auc: 0.983258
| 5 | 0.9832 | 0.2419 | 4.467 | 4.721 | 0.1555 | 4.496 | 6.734 | 0.3173 | 0.004154 | 17.99 |
Training until validation scores don’t improve for 50 rounds
Early stopping, best iteration is:
[80] valid_0’s auc: 0.982517
| 6 | 0.9824 | 0.07136 | 3.439 | 3.961 | 0.1393 | 4.233 | 19.54 | 0.2745 | 0.007645 | 15.59 |
Training until validation scores don’t improve for 50 rounds
Early stopping, best iteration is:
[39] valid_0’s auc: 0.982641
| 7 | 0.9826 | 0.2101 | 4.409 | 1.451 | 0.1027 | 5.407 | 10.72 | 0.8557 | 0.007457 | 14.96 |
Training until validation scores don’t improve for 50 rounds
Early stopping, best iteration is:
[38] valid_0’s auc: 0.984039
| 8 | 0.984 | 0.2504 | 0.3357 | 3.339 | 0.2317 | 3.387 | 13.39 | 0.4548 | 0.004129 | 11.27 |
Training until validation scores don’t improve for 50 rounds
Early stopping, best iteration is:
[80] valid_0’s auc: 0.982065
| 9 | 0.9818 | 0.0529 | 2.981 | 4.219 | 0.1354 | 5.139 | 9.462 | 0.2836 | 0.004768 | 13.83 |
Training until validation scores don’t improve for 50 rounds
Early stopping, best iteration is:
[13] valid_0’s auc: 0.985027
| 10 | 0.985 | 0.12 | 0.9549 | 4.175 | 0.01831 | 3.623 | 11.3 | 0.08429 | 0.007413 | 8.412 |

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

混淆矩阵

在这里插入图片描述

Mart_inn
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
调研lightgbm超参 与 increment learning
using namespace 数学工具构造器;
07-30 475
参考资料 "lightgbm": { "n_estimators": 2000, "boosting_type": "gbdt", "num_leaves": {"_type": "int_quniform", "_value": [10,150],"_default": 31}, "max_depth": {"_type": "int_quniform", "_value": [1,100],"_default": 31}, "learning_rate": {"_type": "
超参数的调优（lightgbm)
weixin_43615654的博客
11-25 7346
参考 原文 超参数的优化过程：通过自动化 目的：使用带有策略的启发式搜索（informed search）在更短的时间内找到最优超参数，除了初始设置之外，并不需要额外的手动操作。 实践部分 贝叶斯优化问题有四个组成部分： 目标函数：我们想要最小化的对象，这里指带超参数的机器学习模型的验证误差 域空间：待搜索的超参数值 优化算法：构造代理模型和选择接下来要评估的超参数值的方法 结果的...
LightGBM超参数优化-贝叶斯，网格
最新发布
weixin_45271076的博客
05-09 250
choice里的参数是独立的，如果用了randint模型会推测参数之间的大小，不太好对调参。针对上面的升级改造：训练模式和测试模式两套放在一起，根据最优秀的参数来实例化一个模型。超参数调完之后如何有更好的效果，–单独模型的交叉训练-非常有bagging的原理。二、基于网格搜索的超参数优化—枚举原理，TPE是根据迭代次数猜的，不会穷尽参数。超参数结果不如原始模型，最好是迭代次数的增加。取5次预测结果的均值作为最终的预测结果。–不一定有效果，但是可以试一下的。
python识别简单训练模型_python训练模型调参神器hyperopt
weixin_39945523的博客
11-23 292
一、安装pip installhyperopt二、说明Hyperopt提供了一个优化接口，这个接口接受一个评估函数和参数空间，能计算出参数空间内的一个点的损失函数值。用户还要指定空间内参数的分布情况。Hyheropt四个重要的因素：指定需要最小化的函数，搜索的空间，采样的数据集(trailsdatabase)（可选），搜索的算法（可选）。首先，定义一个目标函数,接受一个变量,计算后返回一个函数的损...
最详细的LightGBM参数介绍与深入分析
晚来天欲雪，能饮一杯无？
11-10 2122
lightgbm的主要参数是什么如何使用 feval 函数创建自定义指标主要参数的默认值是多少看到了如何调整 lightgbm 参数以提高模型性能的示例。
LightGBM高级教程：自动调参与超参数优化
Echo_Wish的博客
02-28 1527
通过这篇博客教程，您可以详细了解如何在Python中使用不同的技术进行LightGBM的自动调参和超参数优化。您可以根据自己的需求选择适合的方法来优化LightGBM模型的性能。Random Search是另一种常用的参数搜索方法，它通过在参数空间中随机采样来搜索最优的参数组合。Hyperopt是一种基于贝叶斯优化的超参数优化工具，它可以在较少的迭代次数下找到较好的参数组合。Grid Search是一种常用的参数搜索方法，它通过指定一组参数的候选值来搜索最优的参数组合。
lightgbm算法原理.pptx
05-14
* LightGBM 的缺点是需要调整参数，需要选择合适的学习率和迭代次数等。 GBDT 与 LightGBM 对比 GBDT 是一种常用的梯度升级算法，但是它存在一些缺点，如训练速度慢、内存占用高、不支持类别特征等。LightGBM 是一...
lightgbm2.11
05-04
lightgbm2.11,lgb的2.11版本，windows下安装，适合Python2和python3
lightgbm的231版本安装包
03-22
lightgbm的231版本安装包
lightGBM预测notebook代码
10-07
1）lightGBM预测波士顿房价代码 2）特征重要性可视化 3）模型保存 4）模型加载
LightGBM.LightGBM.LightGBM
02-26
LightGBM.LightGBM.
Lightgbm的重要参数
weixin_44245188的博客
04-10 406
​如果你设置的深度很深，但又无法向下分裂，LGBM就会提示warning，无法找到可以分裂的了，说明数据质量已经达到了极限了。lambda_l1 和 lambda_l2 对应着 L1 和 L2 正则化，和 XGBoost 的 reg_lambda 和 reg_alpha 是一样的，对叶子节点数和叶子节点权重的惩罚，值越高惩罚越大。一般的搜索范围可以在 (0, 100)。下面是参数的设置，Optuna比较常见的方式suggest_categorical，suggest_int，suggest_float。
大数据分析案例-基于LightGBM算法构建乳腺癌分类预测模型
m0_64336780的博客
07-23 8431
本项目旨在利用LightGBM算法构建乳腺癌分类预测模型，结合医学影像数据和患者临床数据，对乳腺癌患者进行准确的分类和预测。提高乳腺癌早期检测的准确性：利用机器学习算法对医学影像数据进行分析，帮助医生及早发现乳腺癌病变，提高早期诊断的准确性。改善乳腺癌患者治疗策略：通过对患者临床数据的综合分析，预测乳腺癌患者的病情和预后，为医生制定个性化治疗方案提供依据。辅助医生决策：将构建的预测模型作为辅助工具，为医生在乳腺癌诊断和治疗过程中提供科学客观的参考意见。
基于GFS进行威斯康星州乳腺癌（诊断）数据分析（Matlab代码实现）
weixin_46039719的博客
11-17 944
开发一个准确的系统来分析乳腺癌图像数据可以让医生在评估患者时获得额外的信心，并可用于扫描诊所数据库中的所有过去扫描，以了解是否有任何患者处于危险之中。模糊逻辑系统非常适合构建知识库和规则库，这些知识库和规则库可以准确地近似人类专家知识，例如常规诊断患者乳腺癌的医生。遗传算法通过使用数据的子集来学习模糊逻辑系统的最佳隶属函数和规则库，从而提高模糊逻辑系统的能力，特别是当给定系统的代表性数据集时。这两种技术的结合可用于开发高度准确的癌症诊断近似器。博客内容尽量做到思维缜密，逻辑清晰，为了方便读者。
机器学习实验之肿瘤分类与预测（SVM）
Gettler的博客
05-27 1万+
肿瘤分类与预测（SVM） 【实验内容】 采用SVM方法，对美国威斯康星州的乳腺癌诊断数据集进行分类，实现针对乳腺癌检测的分类器，以判断一个患者的肿瘤是良性还是恶性。 【实验要求】 参考实现步骤：（具体实现可以不同） 1.加载data文件夹里的数据集：威斯康星乳腺肿瘤数据集（数据集路径：data/data74924/data.csv）。 2.查看样本特征和特征值，查看样本特征值的描述信息。 3.进行数据清洗（如删除无用列，将诊断结果的字符标识B、M替换为数值0、1等）。 4.进行特征选取（方便后续的模
LightGBM 重要参数、方法、函数理解及调参思路、网格搜索（附例子）
热门推荐
VariableX的博客
07-10 6万+
文章目录一、LightGBM 原生接口重要参数训练参数预测方法绘制特征重要性分类例子回归例子二、LightGBM 的 sklearn 风格接口LGBMClassifier基本使用例子LGBMRegressor基本使用例子三、LightGBM 调参思路四、参数网格搜索 与 xgboost 类似，LightGBM包含原生接口和 sklearn 风格接口两种，并且二者都实现了分类和回归的功能。如果想了解一些理论性的内容，可以看看之前的文章：LightGBM 相关知识理解 一、LightGBM 原生接口 重要参数
基于Python的特征自动化选择：两行代码完成特征工程
fengdu78的博客
10-28 844
本文介绍一个特征选择神器：特征选择器是用于减少机器学习数据集的维数的工具，可以傻瓜式地进行特征选择，两行代码即可搞定！！来源：Will Koehrsen代码整理及注释翻译：黄海广代码和数...
XGBoost、LightGBM的详细对比介绍
Mr_HHH的博客
03-20 1905
sklearn集成方法集成方法的目的是结合一些基于某些算法训练得到的基学习器来改进其泛化能力和鲁棒性(相对单个的基学习器而言)主流的两种做法分别是：bagging基本思想独立的训练一些基学习器(一般倾向于强大而复杂的模型比如完全生长的决策树)，然后综合他们的预测结果，通常集成模型的效果会优于基学习器，因为模型的方差有所降低。常见变体(按照样本采样方式的不同划分)Pasting:直接从样本集里随机抽...
LightGBM模型超参数
07-28
以下是一些常用的LightGBM模型的超参数： 1. `num_leaves`：树上的最大叶子节点数。较高的值可以提高模型的复杂度，但也容易过拟合。 2. `max_depth`：树的最大深度。与`num_leaves`类似，较高的值增加了模型的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值