统计学习知识大全-算法篇（2）

import numpy as np

class Perceptron:
    def __init__(self, learning_rate=0.01, n_iters=1000):
        self.learning_rate = learning_rate
        self.n_iters = n_iters
        self.weights = None
        self.bias = None

    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.weights = np.zeros(n_features)
        self.bias = 0

        y_ = np.array([1 if i > 0 else -1 for i in y])

        for _ in range(self.n_iters):
            for idx, x_i in enumerate(X):
                linear_output = np.dot(x_i, self.weights) + self.bias
                y_predicted = self._sign(linear_output)

                if y_[idx] * y_predicted <= 0:
                    self.weights += self.learning_rate * y_[idx] * x_i
                    self.bias += self.learning_rate * y_[idx]

    def predict(self, X):
        linear_output = np.dot(X, self.weights) + self.bias
        return self._sign(linear_output)

    def _sign(self, x):
        return np.where(x >= 0, 1, -1)

# 测试感知机算法
if __name__ == "__main__":
    # 生成简单的二分类数据
    X = np.array([[1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [1, 0], [0, 1], [0, 0], [1, -1], [-1, 1]])
    y = np.array([1, 1, 1, 1, 1, -1, -1, -1, -1, -1])

    # 创建感知机模型
    p = Perceptron(learning_rate=0.1, n_iters=10)
    p.fit(X, y)

    # 预测新样本
    print(p.predict(np.array([[2, 3], [0, 0], [5, 5]])))  # 输出: [1, -1, 1]

代码解读

Perceptron类：这个类实现了感知机算法，包括训练方法fit和预测方法predict。
训练过程：在fit方法中，模型通过多个迭代对权重和偏置进行更新，直到模型收敛或达到最大迭代次数。
预测过程：predict方法使用训练好的模型对新数据进行预测。
测试数据：在主程序中，我们生成了一些简单的二分类数据并进行训练和预测，验证模型的正确性。

结果解释

程序运行后，将输出预测的类别。感知机能够将样本分类为两类，模型的准确性依赖于数据的线性可分性。如果数据是线性不可分的，感知机将无法正确分类所有样本。

总结

感知机是神经网络的基础模型，尽管它只能处理线性可分的数据，但为更复杂的模型（如多层感知机和深度神经网络）奠定了基础。通过上述代码示例，你可以理解感知机的基本原理和实现方法。

二朴素贝叶斯算法

朴素贝叶斯算法是一种基于贝叶斯定理的概率分类方法。该算法“朴素”的部分在于假设所有特征之间是相互独立的。这一假设简化了计算，使得算法在大多数情况下都表现出色，尽管实际中特征往往存在依赖关系。

核心思想

朴素贝叶斯算法利用贝叶斯定理来计算样本属于每个类别的概率，然后选择具有最高概率的类别作为分类结果。贝叶斯定理如下：

对于每个类别 C，计算其后验概率 P(C∣X)，然后选择概率最大的类别作为最终分类结果。

朴素贝叶斯的“朴素”假设

在计算 P(X∣C)时，朴素贝叶斯假设特征 x1,x2,…,xnx_1, x_2, \ldots, x_nx1,x2,…,xn 是条件独立的，即：

这个假设使得计算量大大减少，因为现在我们只需要计算每个特征在给定类别下的概率，而不需要考虑特征之间的联合概率。

朴素贝叶斯算法步骤

计算先验概率 P(C)：根据训练数据，计算每个类别 C的先验概率。
计算似然概率 P(X∣C)：对于每个类别 C 和每个特征 xi，计算 P(xi∣C)。
计算后验概率 P(C∣X)：使用贝叶斯定理计算每个类别的后验概率。
分类：选择后验概率最大的类别作为预测结果。

代码实例

以下是一个简单的代码实例，使用Python的scikit-learn库实现朴素贝叶斯分类器。我们将使用一个经典的鸢尾花数据集（Iris dataset）。

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, classification_report

# 加载鸢尾花数据集
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.3, random_state=42)

# 使用高斯朴素贝叶斯分类器
model = GaussianNB()

# 训练模型
model.fit(X_train, y_train)

# 进行预测
y_pred = model.predict(X_test)

# 评估模型
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")
print("Classification Report:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

代码解读

数据集加载：我们使用load_iris函数加载鸢尾花数据集，数据集包含四个特征：花萼长度、花萼宽度、花瓣长度、花瓣宽度，以及三个类别：Setosa, Versicolor, Virginica。
数据集划分：使用train_test_split函数将数据集分为训练集和测试集，测试集占比为30%。
模型训练：使用GaussianNB（适用于连续数据的高斯朴素贝叶斯）训练模型。
预测：模型训练完成后，对测试集数据进行预测。
评估模型：计算预测的准确率，并输出分类报告。

结果解释

输出的准确率表示模型在测试集上的性能，而分类报告显示了每个类别的精确率（Precision）、召回率（Recall）和F1得分。这些指标帮助我们评估模型在不同类别上的表现。

总结

朴素贝叶斯算法因其简单高效，尤其在文本分类等高维数据场景中，广泛应用。尽管“朴素”假设特征独立，但实际应用中常取得良好效果。

三决策树算法

决策树是一种常见的机器学习算法，主要用于分类和回归任务。它通过递归地将数据集划分为更小的子集，直到每个子集中的数据点属于同一类或满足一定条件。决策树的结构类似于树，包含节点和分支：

节点：表示数据集中的一个特征或属性，用于决策。
分支：表示某一特征的一个可能值或一个条件。
叶节点：最终的决策或结果，通常是一个类标签或一个数值。

决策树的构建过程

选择最优特征：在所有特征中选择一个能够最好地划分数据集的特征。通常使用的标准包括信息增益、基尼指数或方差减少等。
划分数据集：根据选择的特征，将数据集划分成若干子集，每个子集对应特征的一个可能值或条件。
递归构建子树：对每个子集，重复上述步骤，直到满足停止条件（如所有样本属于同一类别，或达到树的最大深度）。
终止条件：当所有样本属于同一类别，或者没有更多特征可以用于划分时，算法停止，并将当前节点设为叶节点。

算法实例

假设我们有一个数据集，其中包含一些关于天气的数据，并希望预测是否适合出去玩。

数据集如下：

天气	温度	湿度	风	是否适合出去玩
晴朗	高温	高湿	无风	否
晴朗	高温	高湿	有风	否
阴天	高温	高湿	无风	是
阴天	低温	正常	有风	是
雨天	低温	正常	无风	是
雨天	低温	正常	有风	否
雨天	中温	高湿	无风	是

构建决策树

计算信息增益：选择最优特征。在这里，可能使用“天气”作为第一个分裂特征，因为它可以最有效地将数据分成几类。
划分数据集：
- 如果天气是“晴朗”，结果为“否”。
- 如果天气是“阴天”，结果为“是”。
- 如果天气是“雨天”，继续根据“风”特征进行划分。
进一步分裂：
- 对于“雨天”：
  - 如果有风，结果为“否”。
  - 如果无风，结果为“是”。

最终得到的决策树如下：

       天气
      / | \
  晴朗  阴天  雨天
   否    是    风
               / \
             有风 无风
              否   是

应用实例

给定新的一天，天气是“雨天”，没有风。根据决策树：

天气是“雨天”，所以检查“风”。
没有风，所以推荐出去玩。

决策树算法的优点是直观且易于解释，缺点是可能会过拟合数据，尤其是在树结构非常深或复杂的时候。

代码实例

# 导入必要的库
from sklearn.tree import DecisionTreeClassifier
from sklearn import tree
import pandas as pd

# 构建数据集
data = {
    'Weather': ['Sunny', 'Sunny', 'Overcast', 'Overcast', 'Rainy', 'Rainy', 'Rainy'],
    'Temperature': ['Hot', 'Hot', 'Hot', 'Cool', 'Cool', 'Cool', 'Mild'],
    'Humidity': ['High', 'High', 'High', 'Normal', 'Normal', 'Normal', 'High'],
    'Wind': ['Weak', 'Strong', 'Weak', 'Strong', 'Weak', 'Strong', 'Weak'],
    'PlayTennis': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes']
}

# 创建DataFrame
df = pd.DataFrame(data)

# 特征和标签
X = df[['Weather', 'Temperature', 'Humidity', 'Wind']]
y = df['PlayTennis']

# 将类别数据转换为数值编码
X = pd.get_dummies(X)

# 创建决策树分类器
clf = DecisionTreeClassifier(criterion='entropy', random_state=0)

# 训练模型
clf.fit(X, y)

# 可视化决策树
import matplotlib.pyplot as plt

plt.figure(figsize=(12, 8))
tree.plot_tree(clf, feature_names=X.columns, class_names=['No', 'Yes'], filled=True)
plt.show()

# 测试模型
test_data = pd.DataFrame({
    'Weather': ['Rainy'],
    'Temperature': ['Mild'],
    'Humidity': ['High'],
    'Wind': ['Weak']
})

# 转换测试数据
test_data = pd.get_dummies(test_data)
test_data = test_data.reindex(columns=X.columns, fill_value=0)

# 预测
prediction = clf.predict(test_data)
print("Prediction:", prediction[0])

代码解释

数据集构建：使用字典定义了天气、温度、湿度、风的特征以及是否适合出去玩的标签。
数据转换：将类别数据转换为数值型数据，这里使用了pd.get_dummies方法，将类别特征转换为独热编码（one-hot encoding）。
创建和训练模型：使用DecisionTreeClassifier创建一个基于信息增益（entropy）作为标准的决策树分类器，并用训练数据进行模型训练。
可视化决策树：使用plot_tree方法将训练好的决策树进行可视化，显示特征名称和类别名称。
测试模型：定义一个新的测试样本（天气是雨天，温度为适中，湿度高且无风），转换为模型可识别的格式，并进行预测。

运行结果

可视化图形展示了决策树的结构，print语句输出模型对新数据的预测结果。例如，如果输入的天气条件是Rainy且没有风，模型可能会预测Yes，表示适合出去玩。

这种决策树模型可以被扩展到更复杂的数据集和更广泛的应用领域，例如金融预测、医疗诊断等

四逻辑回归模型

逻辑回归模型概述

逻辑回归（Logistic Regression）是一种用于二分类问题的统计模型。尽管名称中有“回归”一词，但逻辑回归主要用于分类任务。它通过拟合一个逻辑函数（sigmoid函数）来估计样本属于某一类别的概率。

逻辑回归的工作原理

线性组合：首先，逻辑回归对输入特征进行线性组合，即计算 z = w_1 * x_1 + w_2 * x_2 + ... + w_n * x_n + b，其中 w_i 是特征 x_i 的权重，b 是偏置项。
逻辑函数：然后，将线性组合 z 通过逻辑函数（sigmoid函数）进行映射，得到一个介于0和1之间的概率值。逻辑函数的公式为：

这个值表示样本属于正类的概率。
预测类别：最终，使用一个阈值（通常为0.5）将概率值转化为类别。如果概率大于等于0.5，则预测为正类，否则为负类。

逻辑回归的损失函数

逻辑回归使用对数损失（Log-Loss）来优化模型参数。对数损失的公式为：

Python 代码实例

下面是一个使用Python和Scikit-Learn库实现逻辑回归的示例。我们将使用一个简单的二分类数据集，来预测某个用户是否会购买某商品。

# 导入必要的库
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

# 构建数据集
data = {
    'Age': [22, 25, 47, 52, 46, 56, 55, 60, 62, 61],
    'EstimatedSalary': [15000, 29000, 84000, 150000, 90000, 125000, 100000, 130000, 110000, 120000],
    'Purchased': [0, 0, 1, 1, 1, 1, 1, 1, 1, 1]
}

# 创建DataFrame
df = pd.DataFrame(data)

# 特征和标签
X = df[['Age', 'EstimatedSalary']]
y = df['Purchased']

# 拆分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)

# 创建逻辑回归模型
model = LogisticRegression()

# 训练模型
model.fit(X_train, y_train)

# 预测
y_pred = model.predict(X_test)

# 模型评估
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)
class_report = classification_report(y_test, y_pred)

print("Accuracy:", accuracy)
print("Confusion Matrix:\n", conf_matrix)
print("Classification Report:\n", class_report)

# 预测新数据
new_data = np.array([[30, 87000]])
prediction = model.predict(new_data)
print("Prediction for new data:", prediction[0])

代码解释

数据集构建：这里使用了一个包含用户年龄和估计收入的数据集，Purchased 是目标变量，表示用户是否购买了某商品（1表示购买，0表示未购买）。
拆分数据集：使用 train_test_split 将数据集分成训练集和测试集，比例为7:3。
训练模型：使用 LogisticRegression 创建逻辑回归模型，并在训练集上进行训练。
预测与评估：在测试集上进行预测，并使用准确率、混淆矩阵和分类报告来评估模型性能。
预测新数据：给定一组新的数据（例如年龄为30，收入为87000），预测用户是否会购买商品。

运行结果

Accuracy: 模型在测试集上的准确率。
Confusion Matrix: 混淆矩阵展示了模型在不同分类上的表现。
Classification Report: 提供了精确率、召回率、F1-score等评估指标。

新数据预测: 如果输入的新数据，模型输出1表示预测用户会购买商品，0表示不会购买。

五最大熵

最大熵模型概述

最大熵模型（Maximum Entropy Model），也称为最大熵分类器，是一种概率模型，主要用于分类问题。它基于最大熵原理，即在所有可能的概率分布中，选择熵最大的那个分布，来确保在已知约束条件下不引入额外的假设。

最大熵模型的基本思想

最大熵原理的核心思想是，在没有足够信息的情况下，选择最均匀的概率分布。在分类任务中，最大熵模型通过学习每个特征对分类结果的贡献来预测类别标签。

最大熵模型的数学表达

假设我们有一个输入特征向量 xxx，我们希望预测其类别 yyy。最大熵模型使用以下形式的概率分布来建模：

实际上，最大熵模型和逻辑回归非常相似，逻辑回归也可以看作是一种最大熵模型。二者的主要区别在于逻辑回归模型是由逻辑函数得到的，而最大熵模型是通过最大化熵来推导的。

Python代码示例

Scikit-Learn库中的LogisticRegression类实际上实现了最大熵模型，因为它通过最大化对数似然（log-likelihood），也就是最大熵，来求解模型参数。这里，我们使用Scikit-Learn库来实现一个最大熵分类器的实例。

# 导入必要的库
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

# 构建数据集
data = {
    'Feature1': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
    'Feature2': [1, 1, 1, 1, 0, 0, 0, 0, 1, 1],
    'Class': [0, 0, 0, 1, 0, 1, 1, 1, 0, 1]
}

# 创建DataFrame
df = pd.DataFrame(data)

# 特征和标签
X = df[['Feature1', 'Feature2']]
y = df['Class']

# 拆分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建最大熵模型（实际上是逻辑回归模型）
model = LogisticRegression(max_iter=1000)

# 训练模型
model.fit(X_train, y_train)

# 预测
y_pred = model.predict(X_test)

# 模型评估
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)
class_report = classification_report(y_test, y_pred)

print("Accuracy:", accuracy)
print("Confusion Matrix:\n", conf_matrix)
print("Classification Report:\n", class_report)

# 预测新数据
new_data = np.array([[7, 0]])
prediction = model.predict(new_data)
print("Prediction for new data:", prediction[0])

代码解释

数据集构建：创建一个简单的数据集，其中包含两个特征 Feature1 和 Feature2，以及二分类标签 Class。
数据拆分：使用 train_test_split 将数据集分为训练集和测试集，比例为7:3。
创建最大熵模型：这里使用 LogisticRegression 来实现最大熵模型，并设置最大迭代次数为1000，以确保模型收敛。
模型训练：在训练集上训练模型，学习特征与类别之间的关系。
预测与评估：在测试集上进行预测，并使用准确率、混淆矩阵和分类报告来评估模型性能。
预测新数据：输入新数据，模型输出预测结果。

运行结果

Accuracy: 模型在测试集上的准确率。
Confusion Matrix: 显示模型在不同分类上的表现。
Classification Report: 提供精确率、召回率、F1-score等评估指标。

新数据预测: 给定新数据，模型输出预测类别。

结论

通过最大熵模型，我们可以在分类任务中最大化模型的不确定性，在给定已知特征的情况下，尽量避免引入不必要的假设。最大熵模型在文本分类、信息检索等领域有广泛应用。

六提升树

提升树（Boosting Trees）概述

提升树是一种集成学习方法，通过将多个弱分类器（通常是决策树）组合起来形成一个强分类器来提高模型的性能。提升树的基本思想是通过反复训练新的模型来纠正前一轮模型的错误预测，从而逐步提高整体模型的准确性。

提升树的主要算法

AdaBoost（Adaptive Boosting）：
- 首先训练一个弱分类器，计算它的错误率。
- 根据错误率调整样本的权重，让后续的弱分类器更关注那些被前一轮错误分类的样本。
- 将多个弱分类器加权组合，形成最终的强分类器。
梯度提升树（Gradient Boosting Trees, GBT）：
- 逐步添加新的决策树模型，使得每一步的模型都在最小化前一步模型的损失函数。
- 每棵新树都是在前面所有树的残差上训练的，从而逐渐降低整体的误差。
XGBoost：
- 是梯度提升树的优化版本，具有更高的效率和性能，常用于比赛和工业应用中。

梯度提升树的基本步骤

初始化模型：从一个简单的模型开始，比如将所有样本预测为相同的值。
计算残差：计算当前模型的残差，即模型预测值与真实值之间的差异。
训练新树：在当前残差上训练一个新的决策树，试图去拟合这些残差。
更新模型：将新树加入到现有模型中，形成一个更好的模型。
重复：重复上述步骤，直到达到指定的树的数量或损失函数不再显著降低。

Python代码示例：梯度提升树

以下是使用Scikit-Learn库实现梯度提升树（Gradient Boosting Trees）的示例。我们将使用一个简单的二分类数据集，来演示如何应用梯度提升树。

# 导入必要的库
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

# 构建数据集
data = {
    'Feature1': [5, 10, 15, 20, 25, 30, 35, 40, 45, 50],
    'Feature2': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'Class': [0, 0, 0, 1, 0, 1, 1, 1, 0, 1]
}

# 创建DataFrame
df = pd.DataFrame(data)

# 特征和标签
X = df[['Feature1', 'Feature2']]
y = df['Class']

# 拆分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建梯度提升树模型
model = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42)

# 训练模型
model.fit(X_train, y_train)

# 预测
y_pred = model.predict(X_test)

# 模型评估
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)
class_report = classification_report(y_test, y_pred)

print("Accuracy:", accuracy)
print("Confusion Matrix:\n", conf_matrix)
print("Classification Report:\n", class_report)

# 预测新数据
new_data = np.array([[25, 7]])
prediction = model.predict(new_data)
print("Prediction for new data:", prediction[0])

代码解释

数据集构建：这里创建了一个简单的二分类数据集，其中包含两个特征 Feature1 和 Feature2，以及标签 Class。
数据拆分：使用 train_test_split 将数据集分为训练集和测试集，比例为7:3。
创建梯度提升树模型：使用 GradientBoostingClassifier 来创建模型，设置参数如 n_estimators=100（即100棵树）、learning_rate=0.1（学习率）、max_depth=3（每棵树的最大深度）。
模型训练：在训练集上训练模型。
预测与评估：在测试集上进行预测，并使用准确率、混淆矩阵和分类报告来评估模型性能。
预测新数据：给定一组新的数据（如 [25, 7]），模型输出预测类别。

运行结果

Accuracy: 模型在测试集上的准确率。
Confusion Matrix: 显示模型在不同分类上的表现。
Classification Report: 提供精确率、召回率、F1-score等评估指标。

新数据预测: 给定新数据，模型输出预测类别。

结论

提升树是一种非常强大的集成学习方法，通过多次迭代逐步改进模型的性能。梯度提升树作为提升树的一种变体，通过在每一轮中最小化损失函数，可以显著提高分类和回归任务的效果。

七 XgBoost

XGBoost 概述

XGBoost（extreme Gradient Boosting）是一种高效、灵活的梯度提升（Gradient Boosting）算法的实现。XGBoost以其高性能、速度和准确性而著称，广泛应用于数据科学和机器学习领域，尤其是在Kaggle等数据科学竞赛中。

XGBoost 的特点

正则化：XGBoost在目标函数中加入了正则化项，可以有效防止过拟合，提高模型的泛化能力。
自动处理缺失值：XGBoost能够自动处理缺失值，在训练过程中能高效地找到缺失值的最佳分裂点。
并行化：XGBoost支持并行计算，可以充分利用多核处理器，大幅提升训练速度。
树的剪枝：XGBoost使用了基于最大深度的剪枝技术，在每次树分裂时计算损失，从而避免过度生长。
二阶导数优化：XGBoost使用了二阶泰勒展开（近似二阶导数）来优化目标函数，从而提高模型的精度。

XGBoost 的基本步骤

初始化模型：从一个简单的模型开始，如预测所有样本的平均值。
计算残差：计算当前模型的残差，即模型预测值与真实值之间的差异。
训练新树：在当前残差上训练一个新的决策树，试图拟合这些残差。
更新模型：将新树加入到现有模型中，逐步改善整体模型。
重复：重复上述步骤，直到达到指定的树的数量或模型的误差不再显著降低。

Python 代码示例：使用 XGBoost 进行分类

以下是一个使用 XGBoost 进行二分类的代码示例。使用Scikit-Learn库中自带的乳腺癌数据集来演示如何应用XGBoost。

# 导入必要的库
import xgboost as xgb
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

# 加载数据集
data = load_breast_cancer()
X = data.data
y = data.target

# 拆分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建XGBoost分类器
model = xgb.XGBClassifier(
    max_depth=3,
    n_estimators=100,
    learning_rate=0.1,
    objective='binary:logistic',
    use_label_encoder=False,
    eval_metric='logloss'
)

# 训练模型
model.fit(X_train, y_train)

# 预测
y_pred = model.predict(X_test)

# 模型评估
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)
class_report = classification_report(y_test, y_pred)

print("Accuracy:", accuracy)
print("Confusion Matrix:\n", conf_matrix)
print("Classification Report:\n", class_report)

# 预测新数据
new_data = X_test[0].reshape(1, -1)
prediction = model.predict(new_data)
print("Prediction for new data:", prediction[0])

代码解释

加载数据集：我们使用的是Scikit-Learn中的乳腺癌数据集，这个数据集包含特征（X）和目标变量（y）。
数据拆分：使用 train_test_split 将数据集分为训练集和测试集，比例为7:3。
创建XGBoost分类器：使用 XGBClassifier 创建一个XGBoost模型，并设置相关参数：
- max_depth=3：树的最大深度。
- n_estimators=100：迭代次数（即树的数量）。
- learning_rate=0.1：学习率。
- objective='binary:logistic'：目标函数为二分类的逻辑回归。
- use_label_encoder=False：避免使用标签编码器。
- eval_metric='logloss'：评估指标为对数损失。
训练模型：在训练集上训练模型。
预测与评估：在测试集上进行预测，并使用准确率、混淆矩阵和分类报告来评估模型性能。
预测新数据：给定一组新的数据，模型输出预测类别。

运行结果

Accuracy: 模型在测试集上的准确率。
Confusion Matrix: 显示模型在不同分类上的表现。
Classification Report: 提供精确率、召回率、F1-score等评估指标。

新数据预测: 给定新数据，模型输出预测类别。

结论

XGBoost是一种强大的机器学习算法，具有较高的精度和效率。在数据科学竞赛和实际应用中，XGBoost常常表现优异，特别是在处理大型数据集和复杂的分类任务时。

我不是四火

关注

22
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
统计学习知识大全-算法篇（2）

感知机是神经网络的基础模型，尽管它只能处理线性可分的数据，但为更复杂的模型（如多层感知机和深度神经网络）奠定了基础。通过上述代码示例，你可以理解感知机的基本原理和实现方法。朴素贝叶斯算法因其简单高效，尤其在文本分类等高维数据场景中，广泛应用。尽管“朴素”假设特征独立，但实际应用中常取得良好效果。逻辑回归（Logistic Regression）是一种用于二分类问题的统计模型。尽管名称中有“回归”一词，但逻辑回归主要用于分类任务。它通过拟合一个逻辑函数（sigmoid函数）来估计样本属于某一类别的概率。
复制链接

扫一扫