问鼎娱乐电子游戏 gbdt回归数例子

GBDT算法

import numpy as np
from collections import Counter
from sklearn.ensemble import GradientBoostingRegressor
import copy
# gbdt回归数例子
data = np.array([[5, 20, 1.1],
                 [7, 30, 1.3],
                 [21, 70, 1.7],
                 [30, 60, 1.8]
                 ])
# 计算损失函数
def calc_mse(data):
    if len(data) == 0:
        return 0
    label = data[:, -1]
    return np.var(label) * len(label)
# 切分分类数据
def split_data(data, feat, val, data_type='classifier'):
    if data_type == 'classifier':
        arr1 = data[np.nonzero(data[:, feat] == val)]
        arr2 = data[np.nonzero(data[:, feat] != val)]
    else:
        arr1 = data[np.nonzero(data[:, feat].astype(float) < val)]
        arr2 = data[np.nonzero(data[:, feat].astype(float) >= val)]
    return arr1, arr2
# 连续变量的切分点处理
def continuity_params_process(arr, feat):
    c = arr[:, feat].astype(float)
    c_sort = sorted(set(c))
    new_c = []
    for i in range(len(c_sort) - 1):
        val = (c_sort[i] + c_sort[i + 1]) / 2
        new_c.append(val)
    return new_c
# 选择最好的切分点
# 满足基尼系数减少最快的方向
def select_split(data):
    min_gini = np.inf
    best_feat = None
    best_val = None
    left = None
    right = None
    data_type = 'continuity'
    for i in range(data.shape[1] - 1):
        c_set = set(data[:, i])
        for val in c_set:
            arr1, arr2 = split_data(data, i, val, data_type)
            g1 = calc_mse(arr1)
            g2 = calc_mse(arr2)
            # g = len(arr1) / len(data) * g1 + len(arr2) / len(data) * g2
            g = g1 + g2  # 获取剩下最小的均方误差
            # print(i,val,g)
            if min_gini > g:
                min_gini = g
                best_feat = i
                best_val = val
                left = arr1
                right = arr2
    return best_feat, best_val, left, right
# 构建递归树
def create_tree(data):
    tree = {}
    if len(set(data[:, -1])) <= 1:
        return data[:, -1][0]
    # 如果数据的特征一模一样，则无法进一步切分
    # 返回
    dd = data[:, :-1].tolist()
    ddd = list(map(tuple, dd))
    cc = Counter(ddd)
    if len(cc) == 1:
        return np.mean(data[:, -1])
    best_feat, best_val, left, right = select_split(data)
    tree[(best_feat, best_val, 'left')] = create_tree(left)
    tree[(best_feat, best_val, 'right')] = create_tree(right)
    return tree
# 构建gbdt回归树
def create_gbdt(dataset, n_estimators, lr):
    '''
    :param data: 输入数据
    :param n_estimators: 弱分类器的个数
    :param lr: 学习率，也叫残差学习率
    :return:
    '''
    data = copy.copy(dataset)
    tree_list = []
    tree_list.append(np.mean(data[:, -1]))
    y = dataset[:, -1]
    data[:, -1] = np.mean(data[:, -1])
    for i in range(n_estimators):
        data[:, -1] = data[:, -1] + lr * (y - data[:, -1])
    tree = create_tree(data)
    return tree
# 预测单颗树
def predict(tree, X):
    if type(tree) != dict:
        return tree
    for key in tree:
        if X[key[0]] < key[1]:
            r = tree[(key[0], key[1], 'left')]
        else:
            r = tree[(key[0], key[1], 'right')]
        return predict(r, X)
n_estimators = 3  # 估计数
gbdt_tree = create_gbdt(data, n_estimators, 0.1)
print("create gbdt:", predict(gbdt_tree, data[0, :-1]))
gbdt = GradientBoostingRegressor(n_estimators=n_estimators, learning_rate=0.1, max_depth=2)
gbdt.fit(data[:, :-1], data[:, -1])
print("GBDT:", gbdt.predict([data[0, :-1]]))

1。请参阅有关GBDT回归树原理的博客文章，但是如果您想深入了解该算法的原理，则应自己实施整个过程。本文主要使用Python简单地实施GBDT回归，并推断每种学习的残差与以前的迭代之间的关系。

2。构建测试数据并进行简单的线性回归

def create_data（）：

x = []

对于我的范围（100）：

x = 2 * i

y = 3 * i

z = i

l = x + y + z + np.random.rand（） * 10

X.Append（[X，Y问鼎娱乐app苹果下载，Z，L]）

返回NP.Array（X）

data = create_data（）

3。建造一个购物车回归树。该代码与基本相同，但会略有更改。一个损失功能改用均方根错误。第二个是在切片数据后使用最小平方误差。

计算均方误差

def calc_mse（数据）：

如果len（data）== 0：

返回0

label = data [： - 1]

返回NP.VAR（LABEL） * LEN（LABEL）

找到最好的切片点

def select_split（数据）：

min_gini = np.inf

best_feat =无

best_val =无

左=无

正确=无

data_type ='连续性'

对于我的范围（data.shape [1] -1）：

c_set = set（data [：，i]）

对于C_SET中的Val：

arr1，arr2 = split_data（数据，i，val，data_type）

g1 = calc_mse（arr1）

g2 = calc_mse（arr2）

＃g = len（arr1） / len（data） * g1 + len（arr2） / len（data） * g2 #gini用于分类

g = g1 + g2＃获取剩下的最小均方误差

＃print（i，val，g）

如果min_gini> g：

min_gini = g

best_feat = i

best_val = val

左= arr1

正确= arr2

返回best_feat，best_val，左，右

4。建造GBDT回归树

def create_gbdt（数据集，n_estimators，lr）：

'''

：参数数据：输入数据

：param n_estimators：弱分类器的数量

：param LR：学习率，也称为剩余学习率

：返回：

'''

data = copy.copy（数据集）

tree_list = []

tree_list.append（np.mean（data [：，-1]）））

data [：，，1] = data [：，-1] -np.mean（data [：，-1]）

tree_list.append（create_tree（data））

对于我的范围（1，n_estimators）：

data [：， - 1] =（1-lr） * data [：， - 1]＃剩余残留

tree_list.append（create_tree（data））

返回tree_list

XGBoost算法

# ================基于XGBoost原生接口的分类=============
from sklearn.datasets import load_iris
import xgboost as xgb
from xgboost import plot_importance
from matplotlib import pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score   # 准确率
# 加载样本数据集
iris = load_iris()
X,y = iris.data,iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234565) # 数据集分割
 
# 算法参数
params = {
    'booster': 'gbtree',
    'objective': 'multi:softmax',
    'num_class': 3,
    'gamma': 0.1,
    'max_depth': 6,
    'lambda': 2,
    'subsample': 0.7,
    'colsample_bytree': 0.7,
    'min_child_weight': 3,
    'silent': 1,
    'eta': 0.1,
    'seed': 1000,
    'nthread': 4,
}
 
plst = params.items()
 
 
dtrain = xgb.DMatrix(X_train, y_train) # 生成数据集格式
num_rounds = 500
model = xgb.train(plst, dtrain, num_rounds) # xgboost模型训练
 
# 对测试集进行预测
dtest = xgb.DMatrix(X_test)
y_pred = model.predict(dtest)
 
# 计算准确率
accuracy = accuracy_score(y_test,y_pred)
print("accuarcy: %.2f%%" % (accuracy*100.0))
 
# 显示重要特征
plot_importance(model)
plt.show()

xgboost基本方法和默认参数xgboost参数详细说明

在运行XGBoost之前，必须设置三种类型的成熟度：一般参数，助推器参数和任务参数：

一般参数：此参数控制在增强过程中使用哪种助推器。常见的助推器包括树模型和线性模型。

助推器参数：这取决于使用了哪个助推器。

学习目标参数：控制学习方案，例如，在回归问题中，将使用不同的参数来控制分类。

一般参数

Booster [default = gbtree]：有两种模型可以选择gbtree和gblinear。 GBTREE使用基于树的模型来增强计算，Gblinear使用线性模型来增强计算。默认值是gbtree

静音[Default = 0]：当获取0时，这意味着打印运行时信息，并且当采集1时，这意味着它正在默默运行，并且未打印运行时信息。默认值为0

nthread：XGBoost运行时的线程数。默认值是当前系统可以获得的最大线程数。

NUM_PBUFFER：预测缓冲区大小，通常设置为训练实例的数量。缓冲区用于保存促销最后一步的预测结果，而无需手动设置。

num_feature：提升过程中使用的功能维度，将其设置为功能数量。 XGBOOST将自动设置，而无需手动设置。

树木助推器参数

ETA [Default = 0.3]：为防止过度拟合，更新过程中使用的收缩步长大小。每次增加计算后，算法将直接获得新功能的重量。 ETA通过减少特征的重量来使增强计算过程更加保守。默认值为0.3

值范围是：[0,1]。典型值为0.01-0.2。

伽马[Default = 0]：当节点拆分时，仅当损耗函数的值下降时，节点才会拆分。伽马指定节点分割所需的最小损耗函数降低值。

该参数的值越大，算法越保守。该参数的值与损耗函数密切相关，因此需要调整它。

值范围是：[0，inf]

max_depth [default = 6]：数字的最大深度。默认值为6。值范围为：[1，∞]。调音需要简历功能。典型值：3-10

min_child_weight [default = 1]：子节点中最小的样本权重总和。如果叶节点的样品重量小于min_child_weight，则分裂过程结束。在当前的回归模型中，此参数是指建立每个模型所需的最小样本数量。此参数用于避免过度拟合。当它的价值很大时，可以从学习本地特殊样本中避免模型。

但是问鼎app官方下载，如果此值太高，则会导致不足。需要使用简历调整此参数。值范围是：[0，∞]

max_delta_step [default = 0]：我们允许估算每个树的重量的值。如果其值设置为0，则意味着没有约束；如果将其设置为正值，则可以使更新步骤更加保守。通常，此参数是不必要的，但是如果类在逻辑回归中极为不平衡，则可能会有所帮助。将其设置为1-10之间的范围可能使您可以控制更新。值范围是：[0，∞]

子样本[Default = 1]：用于将模型训练为整个样本集的子样本的比例。如果设置为0.5，则意味着XGBoost将从整个样品集中随机提取50％的子样本以构建树型，从而防止过度拟合。值范围是：（0,1]

colsample_bytree [Default = 1]：创建树时特征样本的比率。默认值为1。值范围是：（0,1]

线性助推器参数

lambda [默认= 0]：L2常规惩罚系数

alpha [default = 0]：L1常规处罚系数

lambda_bias：l2偏见规律性。默认值为0（L1上没有偏差术语的规律性，因为偏差在L1上并不重要）

学习目标参数

目标[默认值= reg：linear]：定义学习任务和相应的学习目标。可选目标功能如下：

“ reg：线性” - 线性回归。

“ reg：logistic” - 逻辑回归。

“二进制：逻辑” - 二进制分类的逻辑回归问题，输出是概率。

“二进制：logitraw” - 二进制分类的逻辑回归问题，输出结果为WTX。

“计数：泊松” - 计数问题的泊松回归，输出结果是泊松分布。在泊松回归中，max_delta_step的默认值为0.7。 （用于保护优化）

“ Multi：SoftMax” - 令XGBoost使用SoftMax目标函数来处理多分类问题，同时，您需要设置参数NUM_CLASS（类别数）

“ Multi：SoftProb” - 与SoftMax相同，但输出了NDATA * NCLASS的向量，可以将其重塑为NDATA ROW NCLASS列的矩阵。没有行数据表明样本属于每个类别的概率。

“等级：成对” - 通过最小化成对损失来完成排名任务

base_score [默认值= 0.5]

所有情况的初始化预测分数，全球偏见；

当有足够的迭代术时，更改此值将不会产生太大影响。

eval_metric [根据目标默认]

验证数据所需的评估指标。不同的目标函数将具有默认评估指标（回归的RMSE，分类错误，平均排名平均精度） -

用户可以添加多个评估指标。对于Python用户，他们应该将参数对传递到列表中的程序，而不是MAP参数列表参数不会覆盖“ eval_metric”

种子[默认值= 0]：随机数的种子。默认值为0

xgboost基本方法和默认参数

功能原型：

XGBOOST.TRAIN（params，dtrain，num_boost_round = 10，evals =（），obj = none，feval = none，最大化，forese = false，forath_stopping_rounds = none，none，evals_result = none，none，verbose_eval = none，verbose_eval = true，

参数：这是一个字典，包含参数关键字和训练中的相应值，形式params = {'booster'：'gbtree'，'eta'：0.1}

DTRAIN：培训数据

num_boost_round：这是指改善迭代次数的迭代次数

EVALS：这是用于评估培训期间列表中元素的列表。形式为evals = [（dtrain，'train'），（dval，'val'）]或evals = [（dtrain，'train'）]。对于第一种情况，它使我们能够观察培训期间验证集的效果。

OBJ：自定义目的功能

FEVAL：自定义评估功能

最大值：是否最大化评估功能

早期_STOPPING_ROUNDS：假设是100，验证集的误差迭代不能在100次之内进一步减少，因此请停止迭代。这要求Evals中至少有一个元素。如果有多个元素，请在最后一个元素执行。返回的是最后的迭代次数（不是最好的）。如果存在早期_STOPPING_ROUNDS问鼎娱乐，则该模型将生成三个属性，BST.BEST_SCORE，BST.BEST_ITERATION和BST.BEST_NTREE_LIMIT

evals_result：词典，存储在监视列表中的元素的评估结果。

verbose_eval（可以输入布尔值或数字）：它还要求在evals中至少有一个元素。如果为true，则将在结果中输出EVAL中元素的评估结果；如果输入一个数字，则假设它是5，则每5次迭代将输出一次。

Learning_rates：每次增加的学习率列表，

XGB_MODEL：用于在训练之前加载的XGB模型。