1、绪论

辨析：直方图和条形图

• 左边是 直方图 (Histogram)：展示连续数据（身高）的分布情况，柱子是连在一起的。
• 右边是 条形图 (Bar Chart)：展示离散类别（运动爱好）的数量对比，柱子是分开的。

数据集的组成

文件csv

为什么不用Mysql?

• 性能瓶颈，读取速度慢
• 格式不太符合机器学习的数据要求

用pandas读取工具，pandas基于numpy，一个数据读取非常方便以及基本的处理格式的工具

sklearn：对于特征的处理提供了强大的接口

结构：特征值+目标值

dataFrame有行索引和列索引

处理缺失值，数据的转换，重复值去重

特征工程：将原始数据转换为更好地代表预测模型的潜在问题的特征的过程，从而提高了对未知数据的预测的准确性

2、特征抽取

字典特征数据抽取

1. 什么是特征抽取？

from sklearn.feature_extraction.text import CountVectorizer

# 实例化CountVectorizer
vector = CountVectorizer()

# 调用fit_transform输入并转换数据
res = vector.fit_transform(["life is short,i like python", "life is too long,i dislike python"])

# 打印结果，使用get_feature_names_out()替代get_feature_names()
print(vector.get_feature_names_out())
print(res.toarray())

输出：
['dislike' 'is' 'life' 'like' 'long' 'python' 'short' 'too']
[[0 1 1 1 0 1 1 0]
 [1 1 1 0 1 1 0 1]]

特征抽取对文本等数据进行特征值化,让计算机更好的理解数据

sklearn特征抽取API叫sklearn.feature_extraction

2. 关于字典特征抽取

即对字典数据进行特征值化

类：sklearn.feature_extraction.DictVectorizer

举个例子：

# 1.实例化类DictVectorizer
# 2.调用fit_transform方法输入数据并转换  注意返回格式
from sklearn.feature_extraction import DictVectorizer
def dictvec():
    """
    字典数据抽取
    :return:None
    """
    dict=DictVectorizer(sparse=False)
    data=dict.fit_transform([{'city':'北京','temperature':100},{'city':'上海','temperature':70},{'city':'深圳','temperature':30}])
    print(data)  #矩阵
    # get_feature_names_out的作用
    print(dict.get_feature_names_out())
    # 转换回你之前的数据
    print(dict.inverse_transform(data))
    return None
    
if __name__=="__main__":
    dictvec()



输出：
[[  0.   1.   0. 100.]
 [  1.   0.   0.  70.]
 [  0.   0.   1.  30.]]
['city=上海' 'city=北京' 'city=深圳' 'temperature']
[{'city=北京': np.float64(1.0), 'temperature': np.float64(100.0)}, {'city=上海': np.float64(1.0), 'temperature': np.float64(70.0)}, {'city=深圳': np.float64(1.0), 'temperature': np.float64(30.0)}]

这是没设置sparse=False返回的原始格式

设置了之后返回的是矩阵格式，即ndarray二维数组

在经过字典数据抽取即dict.get_feature_names_out()之后：

字典数据抽取就是把字典中一些类别数据，分别进行转换成特征

文本特征抽取以及中文问题

1. 对文本数据进行特征值化

类：sklearn.feature_extraction.text.CountVectorizer

from sklearn.feature_extraction.text import CountVectorizer 
def countvec():
    """
    对文本进行特征值化
    :return : None
    """
    cv=CountVectorizer()
    data = cv.fit_transform(["life is short,i like python", "life is too long,i dislike python"])
    print(data)
    print(data.toarray())
    print(cv.get_feature_names_out())
    
    return None
if __name__=="__main__":
    countvec()

也就是词的列表，长度为8，所以文章中出现了八个不同的词

！！！单个字母/汉字（如“i”）不统计。因为没有情感趋向也没有分类依据

用于文本分类，情感分析，

中文默认不支持文本特征抽取，举个例子：

from sklearn.feature_extraction.text import CountVectorizer 
def countvec():
    """
    对文本进行特征值化
    :return : None
    """
    cv=CountVectorizer()
    # data = cv.fit_transform(["life is short,i like python", "life is too long,i dislike python"])
    data = cv.fit_transform(["人生苦短，我喜欢python", "人生漫长，不用python"])
    # print(data)
    print(data.toarray())
    print(cv.get_feature_names_out())

    data = cv.fit_transform(["人生 苦短，我 喜欢 python", "人生漫长，不用 python"])
    print(data.toarray())
    print(cv.get_feature_names_out())
    
    
    return None
if __name__=="__main__":
    countvec()

输出：
[[0 0 1 1]
 [1 1 0 0]]
['不用python' '人生漫长' '人生苦短' '我喜欢python']
[[1 0 1 0 1 1]
 [1 1 0 1 0 0]]
['python' '不用' '人生' '人生漫长' '喜欢' '苦短']

2. 文本特征抽取的第一种方式—分析工具jieba

下载：pip install jieba

使用:import jieba jieba.cut(“我是一个好程序员”)

返回值：词语生长器

from sklearn.feature_extraction.text import CountVectorizer 
import jieba
def cutword():
    con1=jieba.cut("今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。")
    con2=jieba.cut("星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。")
    con3=jieba.cut("如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。")
    # 转换成列表
    content1=list(con1)
    content2=list(con2)
    content3=list(con3)
    # 把列表转换成字符串
    c1=' '.join(content1)
    c2=' '.join(content2)
    c3=' '.join(content3)
    return c1,c2,c3
def hanzivec():
    """
    中文特征值化
    :return: None
    """
    # 1.准备句子，用jieba,cut进行分词
    c1,c2,c3=cutword()
    print(c1,c2,c3)
    # 2.实例化CountVectorizer
    cv=CountVectorizer()
    # 3.将分词结果变成字符串当作fit_transform的输入值
    data = cv.fit_transform([c1,c2,c3])
    print(data.toarray())
    print(cv.get_feature_names_out())
    return None
if __name__=="__main__":
    hanzivec()

tf-df分析问题

用词语辨析文章类型

tf:term frequency-----词的频率

idf:inverse document frequency逆文档频率 log(总文档数量/该词出现的文档数)

log(数值)：输入的数值越小，结果越小

tf-idf=tf*idf

主要思想：如果某个词或短语在一篇文章中出现的概率很高，并且在其他文章很少出现，则认为此词或短语具有很好的类别区分能力，适合用来分类

TF-IDF的作用：用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度

类：sklearn.feature_extraction.text.TfidfVectorizer

from sklearn.feature_extraction.text import CountVectorizer,TfidfVectorizer
import jieba
def cutword():
    con1=jieba.cut("今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。")
    con2=jieba.cut("星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。")
    con3=jieba.cut("如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。")
    # 转换成列表
    content1=list(con1)
    content2=list(con2)
    content3=list(con3)
    # 把列表转换成字符串
    c1=' '.join(content1)
    c2=' '.join(content2)
    c3=' '.join(content3)
    return c1,c2,c3
def tfidfvec():
    """
    中文特征值化
    :return: None
    """
    # 1.准备句子，用jieba,cut进行分词
    c1,c2,c3=cutword()
    print(c1,c2,c3)
    # 2.实例化CountVectorizer
    tf=TfidfVectorizer()
    # 3.将分词结果变成字符串当作fit_transform的输入值
    data = tf.fit_transform([c1,c2,c3])
    print(data.toarray())
    print(tf.get_feature_names_out())
    return None
if __name__=="__main__":
    tfidfvec()

这是一个 3×36 的矩阵（3 行对应 3 段文本，36 列对应 36 个不重复的特征词），矩阵中的数值表示每个词语在对应文本中的 TF-IDF 权重：

• 第一行：对应第一段关于 “今天、明天、后天” 的文本
• 第二行：对应第二段关于 “星系、宇宙” 的文本
• 第三行：对应第三段关于 “了解事物” 的文本

3、特征预处理

特征预处理-归一化

特征的预处理：对数据进行处理 ，通过特定的统计方法（数学方法）将数据转换成算法要求的数据

举个例子：

sklearn特征处理API：sklearn.preprocessing

归一化：把不同量纲、不同范围的特征数据，映射到相同的数值范围（通常是 [0,1] 或 [-1,1]），让各个特征在模型训练时能够“公平”地发挥作用

1. **Min-Max 归一化 **

归一化到 区间：

归一化到任意区间 ：

• ：原始数据
• ：样本数据的最小值
• ：样本数据的最大值
• ：目标区间下界
• ：目标区间上界

第一条公式是把数据压缩到 ** 区间**。
第二条公式是把数据映射到 **任意区间 **，前一个公式是它的特例。

把数据映射到 [0,1]。
缺点：对异常值敏感，因为异常点对最大值or最小值影响很大。所以这种方法鲁棒性很差，只适合传统精确小数据场景

鲁棒性：一个模型、算法或者系统在遇到异常情况、噪声、干扰、环境变化时，依然能保持稳定和可靠的性能

2. Z-score 标准化（标准化 Standardization）

处理后数据均值为 0，方差为 1。
优点：对异常值更鲁棒，常用于深度学习。

3. L2 范数归一化

把一个样本的特征向量缩放到长度为 1。
常用于文本处理（TF-IDF 向量化后）。

归一化以及标准化对比

1. sklearn归一化API：sklearn.preprocessing.MinMaxScaler

# 1.实例化MinMaxScaler
# 2.通过fit_transform转换
from sklearn.preprocessing import MinMaxScaler
def mm():
    """
    归一化处理
    :return  NOne
    """
    # 默认区间范围[0,1]，可指定
    mm=MinMaxScaler(feature_range=(2,3))
    data=mm.fit_transform([[90,2,10,40],[60,4,15,45],[75,3,13,46]])
    print(data)
    return None
if __name__=="__main__":
    mm()

输出：
[[3.         2.         2.         2.        ]
 [2.         3.         3.         2.83333333]
 [2.5        2.5        2.6        3.        ]]

举个例子：n个特征同等重要的时候需要归一化

import numpy as np
from sklearn.preprocessing import MinMaxScaler

# 三个特征：里程数、冰淇淋公升数、游戏耗时比
data = np.array([
    [14488, 7.153469, 1.673904],
    [26052, 1.441871, 0.805124],
    [75136, 13.147394, 0.428964],
    [38344, 1.669788, 0.134296],
    [72993, 10.141740, 1.032955],
    [35948, 6.830792, 1.213192],
    [42666, 13.276369, 0.543880],
    [67497, 8.631577, 0.749278],
    [35483, 12.273169, 1.508053],
    [50242, 3.723498, 0.831917]
])

# 使用 MinMaxScaler 将数据缩放到 [0,1]
scaler = MinMaxScaler()
data_norm = scaler.fit_transform(data)

print("归一化后的数据：\n", data_norm)

2. 标准化

由于归一化鲁棒性差，我们用标准化。如果出现异常点，由于一定的数据量，少量异常点对于平均值的影响并不大，从而方差改变较小

目的：使得某一个特征不会对结果有太大的影响

特点：通过对原始数据进行变换，把数据变换到 均值为 0，方差为 1 的范围内。

• mean 为平均值，σ 为标准差

说明：

• 作用于每一列（即每个特征）。
• 方差公式：

• 标准差公式：

其中：方差用于 考量数据的稳定性

标准化的API：scikit-learn.preprocessing.StandardScaler

from sklearn.preprocessing import StandardScaler
def stand():
    """
    标准化缩放
    :return:
    """
    std=StandardScaler()
    data=std.fit_transform([[1.,-1.,3.],[2.,4.,2.],[4.,6.,-1.]])
    print(data)
    return None
if __name__=="__main__":
    stand()

输出：
[[-1.06904497 -1.35873244  0.98058068]
 [-0.26726124  0.33968311  0.39223227]
 [ 1.33630621  1.01904933 -1.37281295]]

结果每一列加起来等于0，也就是均值为0；同理方差为1

标准化总结以及缺失值处理

处理缺失值：

• 删除：如果每列或者每行数据缺失值达到一定比例，建议放弃整行或整列
• 插补：通过缺失值每行或每列的平均值，中位数来填充

sklearn缺失值API:sklearn.preprocessing.Imputer

数据中缺失值格式：np.nan

# 1.初始化Imputer,指定”缺失值“，指定填补策略。指定行或列，axis=0代表按列操作
# 注：缺失值也可以是别的指定的要替换的值
# 2.调用fit_transform
import numpy as np
from sklearn.impute import SimpleImputer

def im():
    """
    缺失值处理
    """
    # 标记缺失值为 np.nan，用均值填补（默认按列）
    imputer = SimpleImputer(missing_values=np.nan, strategy='mean')

    data = imputer.fit_transform([[1, 2],
                                  [np.nan, 3],
                                  [7, 6]])
    print(data)

if __name__ == "__main__":
    im()

输出：
[[1. 2.]
 [4. 3.]
 [7. 6.]]

第一列 [1, nan, 7] → 均值 (1+7)/2 = 4

4、数据的降维

数据降维方式：

• 特征选择
• 主成分分析

特征选择

原因：

• 冗余：部分特征相关度高，容易消耗计算性能
• 噪声：部分特征对预测结果有影响

特征选择即从原始特征中挑选出对预测任务最有用的那部分特征，去掉冗余的、无关的、噪声大的特征。详细来讲就是：单纯从提取到的所有特征中选择部分特征作为训练集特征，特征在选择前和选择后可以改变值，也可以不改变值，但选择后的特征维数肯定比选择前小，毕竟只选择了一部分

特征选择API：sklearn.feature_selection.VarianceThreshold

Variance是方差的意思，方差为0意味着这列数据都一样，毫无价值

from sklearn.feature_selection import VarianceThreshold
def var():
    """
    特征选择---删除低方差的特征
    :return: None
    """
    var=VarianceThreshold(threshold=0.0)
    data=var.fit_transform([[0,2,0,3],[0,1,4,3],[0,1,1,3]])
    print(data)
    return None
if __name__=="__main__":
    var()
输出：
[[2 0]
 [1 4]
 [1 1]]

结果把第一列000和第四列333都删除了

主成分分析

主成分分析API：sklearn.decomposition

PCA是一种分析，简化数据集的技术

举个例子：从二维到一维

特征数量达到上百

目的：压缩数据维度，尽可能降低原数据的维数（复杂度），损失少量信息。 也就是通过线性变换，把高维数据映射到新的低维空间，同时尽可能保留原始数据中的主要信息。

作用：可以削减回归分析或者聚类分析中特征的数量

高纬度数据容易出现的问题：特征之间通常是相关的

1. PCA(n_components=None)

• n_components：表示要降到多少维度。
  • None：默认不降维，只是做主成分分析（得到所有主成分）。
  • 整数 k：表示降到 k 维。
  • 小数（0-1之间）：表示保留的方差比例，比如 0.95 表示保留 95% 的信息量。
• 功能：把数据从高维空间映射到较低维的空间里（减少特征数量，同时尽量保留主要信息）。

2. PCA.fit_transform(X)

• X：输入数据（numpy array 格式），形状是 [n_samples, n_features]
  • n_samples：样本数量
  • n_features：原始特征数量
• 返回值：降维后的新数据矩阵，形状 [n_samples, n_components]
  • 每个样本就用更少的维度来表示（信息更集中）。

# 1.初始化PCA，指定减少后的维度
# 2.调用fit_transform
from sklearn.decomposition import PCA
def pca():
    """"
    主成分分析进行特征降维
    :return:None
    """
    pca=PCA(n_components=0.9)
    data=pca.fit_transform([[2,8,4,5],[6,3,0,8],[5,4,9,1]])
    print(data)
    return None
if __name__=="__main__":
    pca()

输出：
[[-3.13587302e-16  3.82970843e+00]
 [-5.74456265e+00 -1.91485422e+00]
 [ 5.74456265e+00 -1.91485422e+00]]

结果：

• 含义：保留累计贡献率 ≥ 90% 的主成分。
• 结果：从 4 维数据降到 2 维（所以输出里每行有 2 个数）。

1. [-3.13587302e-16, 3.82970843e+00]
   • 第一个数 -3.13587302e-16 ≈ 0，只是浮点数运算导致的近似零。
   • 第二个数 3.8297 → 代表在新坐标轴（第2个主成分方向）上的投影。
   • 表示第一个原始的样本的坐标是(0,3.8)
2. [-5.74456265, -1.91485422]
   • 表示原始第2个样本（[6,3,0,8]）在两个主成分方向上的坐标。
3. [5.74456265, -1.91485422]
   • 表示原始第3个样本（[5,4,9,1]）在两个主成分方向上的坐标。

PCA 做了两件事：

1. 找到原始数据变化最大的方向（主成分1、主成分2）。
2. 把 4 维数据投影到这两个方向上，得到新的坐标（二维）。

所以：

• 原始 4 维 → 现在 2 维。
• 每一行是样本的新坐标。
• 数值的正负、大小反映了样本在主成分轴上的分布关系。

5、机器学习算法分类以及开发流程

算法是核心，数据和计算是基础

开发流程

模型就是算法+数据

机器学习步骤：

1. 建立模型（根据数据类型划分模型种类，明确做什么）
2. 数据的基本处理：pd去处理数据（缺失值，合并表）-----特征工程
3. 特征工程（特征进行处理）
4. 找到合适的算法去进行预测
5. 模型的评估，判定效果（上线使用，以API形式提供）。没及格就换算法/参数，继续特征工程，也就是回到了第二步

6、数据的划分与介绍

1. 介绍数据集

数据集分为训练集和数据集，按一定的比例去划分，训练集用于训练，构建模型，测试集用于评估模型是否有效

数据集划分API:sklearn.model_selection.train_test_split

获取数据集返回的类型：

sklearn分类数据集

from sklearn.datasets import load_iris
li=load_iris()
print("获取特征值")
print(li.data)
print("目标值")
print(li.target)
print(li.DESCR)

显然，特征值是二维数组，共150个

2. 分割数据集

from sklearn.model_selection import train_test_split
li=load_iris()
# 获取特征值，获取目标值，指定测试集大小
# 注意返回值包含了训练集和测试集
# x_train表示训练集里的特征值,y_train表示目标值
x_train,x_test,y_train,y_test=train_test_split(li.data,li.target,test_size=0.25)
print("训练集特征值和目标值",x_train,y_train)
print("测试集特征值和目标值",x_test,y_test)

可以看出训练集占百分之75，测试集占百分之25

3. 用于分类的大数据集

from sklearn.datasets import fetch_20newsgroups

news = fetch_20newsgroups(subset='all')

# 只查看前几个样本，而不是全部
print("数据集大小:", len(news.data))
print("\n前3个文档的内容:")
for i in range(3):
    print(f"\n=== 文档 {i+1} ===")
    print(news.data[i][:200] + "...")  # 只显示前200个字符

print("\n前10个文档的标签:")
print(news.target[:10])

print("\n所有类别名称:")
print(news.target_names)

4. 用于回归的数据集

from sklearn.datasets import fetch_california_housing, load_diabetes
# load_boston() 在最新版本的 scikit-learn (1.2+）中已经被移除了。
# 使用加州房价数据集（推荐替代）
housing = fetch_california_housing()
print("获取特征值")
print(housing.data)
print("目标值")
print(housing.target)
print(housing.DESCR)

print(f"特征名称: {housing.feature_names}")
print(f"数据集形状: {housing.data.shape}")

7、转换器与估计器

转换器

想一下之前做特征工程的步骤：

1. 实例化：实例化的是一个转换器类（Transformer）
2. 调用fit_transform(对于文档建立分类词频矩阵，不能同时调用)

fit_transform:输入数据直接转换

fit():输入数据,但不做事情

transform():进行数据的转换

验证二者是否效果一致：

# 标准化：使每列均值为0，标准差为1
from sklearn.preprocessing import StandardScaler
s=StandardScaler()
s.fit_transform([[1,2,3],[4,5,6]])

from sklearn.preprocessing import StandardScaler
ss=StandardScaler()
ss.fit([[1,2,3],[4,5,6]])
ss.transform([[1,2,3],[4,5,6]])

最后结果输出一致

估计器

估计器实现了每个算法的API

1. 估计器的核心功能

估计器主要有两个核心功能：

• 拟合（fit）：从数据中学习。即根据训练数据，估计器会调整其内部参数（例如，线性回归的权重或支持向量机的分隔超平面）。
• 预测（predict）：基于学到的模型参数，对新的数据进行预测。

2. 估计器的常见类型

估计器通常可以分为以下几种类型：

• 监督学习（Supervised Learning）：
  估计器学习有标签的训练数据，然后根据学到的模式对新数据进行预测。常见的估计器包括：
  • 回归（Regression）：例如，线性回归（Linear Regression）、岭回归（Ridge Regression）。
  • 分类（Classification）：例如，支持向量机（SVM）、逻辑回归（Logistic Regression）、K近邻（KNN）、决策树（Decision Tree）等。
• 无监督学习（Unsupervised Learning）：
  估计器没有标签数据，而是从数据中学习隐藏的模式或结构。常见的无监督学习估计器包括：
  • 聚类（Clustering）：例如，K均值（K-Means）、层次聚类（Hierarchical Clustering）。
  • 降维（Dimensionality Reduction）：例如，主成分分析（PCA）、t-SNE。

3. 估计器的工作原理

估计器的工作流程一般可以分为三个步骤：

• 拟合（Fit）：通过调用 fit() 方法，估计器会根据训练数据来学习模型。学习过程通常会调整模型的参数，使得模型能够最优地拟合数据。
• 预测（Predict）：通过调用 predict() 方法，估计器会使用学到的模型来对新的数据进行预测。
• 评估（Evaluate）：有些估计器还包括评估模型效果的方法，例如 score() 方法，可以返回模型的精度、准确率等指标。
• 工作流程示意图：
• 

4. 估计器的示例

1. 线性回归（Linear Regression）

线性回归是一种常见的回归估计器，用于预测数值型输出。

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression

# 创建一个示例回归数据集
X, y = make_regression(n_samples=100, n_features=2, noise=0.1)

# 将数据集分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建线性回归模型
model = LinearRegression()

# 使用训练集拟合模型
model.fit(X_train, y_train)

# 使用模型对测试集进行预测
predictions = model.predict(X_test)

# 打印预测结果
print(predictions)

2. 逻辑回归（Logistic Regression）

逻辑回归是一种常见的分类估计器，适用于二分类问题。

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris

# 加载一个经典的数据集，这里使用的是鸢尾花数据集（Iris Dataset）
data = load_iris()
X = data.data  # 特征数据
y = data.target  # 目标变量（标签）

# 将数据集分割为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建一个逻辑回归模型（估计器）
model = LogisticRegression(max_iter=200)

# 使用训练数据拟合模型
model.fit(X_train, y_train)

# 用训练好的模型对测试数据进行预测
predictions = model.predict(X_test)

# 打印预测结果
print(predictions)

# 如果你想查看模型的准确率，可以用 score 方法
accuracy = model.score(X_test, y_test)
print(f"Accuracy: {accuracy:.2f}")

3. 支持向量机（SVM）

支持向量机（SVM）是一种强大的分类算法，也可以用来做回归。

from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.datasets import load_iris

# 加载经典的鸢尾花数据集（Iris Dataset）
data = load_iris()
X = data.data  # 特征数据
y = data.target  # 目标变量（标签）

# 将数据集分割为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建一个支持向量机分类器（估计器）
model = SVC()

# 使用训练数据拟合模型
model.fit(X_train, y_train)

# 用训练好的模型对测试数据进行预测
predictions = model.predict(X_test)

# 打印预测结果
print(predictions)

# 如果你想查看模型的准确率，可以用 score 方法
accuracy = model.score(X_test, y_test)
print(f"Accuracy: {accuracy:.2f}")

4. 决策树（Decision Tree）

决策树是一种经典的分类和回归模型，它通过树形结构进行决策。

from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris

# 加载经典的鸢尾花数据集（Iris Dataset）
data = load_iris()
X = data.data  # 特征数据
y = data.target  # 目标变量（标签）

# 将数据集分割为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建一个决策树分类器（估计器）
model = DecisionTreeClassifier()

# 使用训练数据拟合模型
model.fit(X_train, y_train)

# 用训练好的模型对测试数据进行预测
predictions = model.predict(X_test)

# 打印预测结果
print(predictions)

# 如果你想查看模型的准确率，可以用 score 方法
accuracy = model.score(X_test, y_test)
print(f"Accuracy: {accuracy:.2f}")

5. 估计器的评估

评估估计器的好坏是机器学习中的重要任务。根据任务类型的不同（回归、分类），评估标准也不同：

• 回归任务：常用评估指标有均方误差（MSE）、均方根误差（RMSE）、决定系数（R²）等。

from sklearn.metrics import mean_squared_error, r2_score
mse = mean_squared_error(y_test, predictions)
r2 = r2_score(y_test, predictions)

• 分类任务：常用评估指标有准确率（accuracy）、精确度（precision）、召回率（recall）、F1分数等。

from sklearn.metrics import accuracy_score
accuracy = accuracy_score(y_test, predictions)

6. 估计器与转换器的区别

• 估计器：主要用来学习数据并进行预测。它有 fit() 和 predict() 方法。
• 转换器：用于数据转换，例如标准化、降维等。它有 fit() 和 transform() 方法，转换器一般不直接进行预测。