机器学习

0. 前言

机器学习是人工智能的重要技术基础，涉及的内容十分广泛。本文章涵盖了机器学习的基础知识，主要包括机器学习的概述、 回归、分类、聚类、神经网络、文本分析、图像分析、深度学习等经典的机器学习基础知识，还包括深度学习入门等拔高内容。

1. 机器学习概述

介绍机器学习的基础概念和知识，包括机器学习简史、主要流派、与人工智能、数据挖掘的关系、应用领域、算法、一般流程等。

1.1机器学习简介

1.1.1机器学习背景

伴随着计算机计算能力的不断提升以及大数据时代的迅发展人工智能也取得了前所未有的进步。

很多企业均开始使用机器学习的相关技术于大部分行业中，以此获得更为强大的洞察力，也为企业的日常生活和企业运营带来了很大的帮助，从而提高了整个产品的服务质量。

机器学习的典型应用领域有：搜索引擎、自动驾驶、量化投资、计算机视觉、信用卡欺诈检测、游戏、数据挖掘、电子商务、图像识别、自然语言处理、医学诊断、证券金融市场分析以及机器人等相关领域，故在一定程度上，机器学习相关技术的进步也提升了人工智能领域发展的速度。

1.1.2机器学习简介

机器学习(MachineLearning)，作为计算机科学的子领域，是人工智能领域的重要分支和实现方式。

机器学习的思想：计算机程序随着经验的积累，能够实现性能的提高。对于某一类任务T及其性能度量P，若一个计算机程序在T上以P衡量的性能随着经验E而自我完善，那么就称这个计算机程序在从经验E学习。

主要的基础理论：数理统计，数学分析，概率论，线性代数，优化理论，数值逼近、计算复杂性理论。

机器学习的核心元素：算法、数据以及模型。

1.1.3机器学习简史

作为一门不断发展的学科，机器学习尽管在最近几年才发展成为一门独立的学科。

起源于20世纪50年代以来人工智能的逻辑推理、启发式搜索、专家系统、符号演算、自动机模型、模糊数学以及神经网络的反向传播BP算法等。如今作为机器学习重要的基础理论。

机器学习简史

在1950年代，已经有了机器学习的相关研究。代表工作主要是F.Rosenblatt基于神经感觉科学提出的计算机神经网络，即感知器。随后十年，用于浅层学习的神经网络风靡一时，尤其是MarvinMinsky提出了著名的XOR问题和感知器线性度不可分割的问题。

局限：由于计算机的计算能力有限，因此很难训练多层网络。通常使用仅具有一个隐藏层的浅层模型。尽管已经陆续提出了各种浅层机器学习模型，但理论分析和应用方面都已产生。但是，理论分析和训练方法的难度要求大量的经验和技能。而随着最近邻算法和其他算法的相继提出，在模型理解，准确性和模型训练方面已经超越了浅层模型。机器学习的发展几乎停滞不前。

在2006年，希尔顿（Hinton）发表了一篇关于深度信念网络的论文，Bengio等人发表了关于“深度网络的贪婪分层明智训练”的论文，而LeCun团队发表了基于能量模型的“稀疏表示的有效学习”。

这些事件标志着人工智能正式进入深度网络的实践阶段。同时，云计算和GPU并行计算为深度学习的发展提供了基本保证，尤其是近年来，机器学习它在各个领域都实现了快速发展。新的机器学习算法面临的主要问题更加复杂。机器学习的应用领域已从广度发展到深度，这对模型的训练和应用提出了更高的要求。

随着人工智能的发展，冯·诺依曼有限状态机的理论基础变得越来越难以满足当前神经网络中层数的要求。这些都给机器学习带来了挑战。

1.1.4 机器学习主要流派

在人工智能的发展中，随着人们对智能的理解和对实际问题的解决方案的发展，机器学习大致出现了符号主义、贝叶斯、联结主义、进化主义、行为类推主义五大流派。

符号主义起源于逻辑和哲学，其实现方法是利用符号来表达知识并使用规则进行逻辑推理。专家系统和知识工程是该理论的代表。符号主义学派认为，知识是信息符号的表示，是人工智能的基础。这些符号被输入到计算机中进行仿真和推理，以实现人工智能。

贝叶斯定理是概率论中的一个定理，其中P（A|B）是事件B发生时事件A发生的概率（条件概率）。贝叶斯学习已被应用于许多领域。例如，自然语言中的情感分类，自动驾驶和垃圾邮件过滤。

联结主义起源于神经科学，主要算法是神经网络，它由一定结构中的大量神经元组成。神经元是一种看起来像树的细胞，它由细胞主体和细胞突起组成，长轴突被鞘覆盖以形成神经纤维，在其末端的小分支称为神经末梢。每个神经元可以具有一个或多个树突，这些树突可以接受刺激并将兴奋转移到细胞体内。每个神经元只有一个轴突，它可以将兴奋从细胞体传递到另一个神经元或其他组织，神经元相互连接，从而形成一个大型的神经网络，人类所学到的几乎所有知识都存在其中，如下图所示： 联结主义

在神经网络中，将n个连接的神经元的输出用作当前神经元的输入，进行加权计算，并添加一个偏置值（Bias）以通过激活函数实现变换，激活功能的功能是在一定范围内输出控制。以Sigmoid函数为例，输入是从负无穷大到正无穷大，并在激活后映射到（0，1）间隔。

人工神经网络是分层(Layer)组织的，每层包含多个神经元，这些层通过某种结构连接，神经网络训练的目的是找到网络中的每个突触连接的权重和偏差值。作为一种监督学习算法，神经网络的训练过程是通过不断反馈当前网络计算结果与训练数据之间的误差来校正网络权重，使得误差足够小，这就是反向传播算法。

1850年，达尔文提出进化论。进化过程是适者生存的过程，个体生物在其中适应环境。智能需要适应不断变化的环境，并通过对进化过程进行建模来生成智能行为。

进化算法（EA）是基于“自然选择，适者生存”和迭代优化的原理，在计算机上模拟进化过程，直到找到最佳结果。进化算法包括基本操作，例如基因编码，群体初始化和交叉变异算子。它是一种相对成熟的全局优化方法，具有广泛的适用性。它具有自组织，自适应和自学习的特征，可以有效地处理传统优化。用算法难以解决的复杂问题（例如NP硬优化问题）。

遗传算法的优化应根据具体情况选择算法，也可以与其他算法结合进行补充。对于动态数据，可能难以使用遗传算法来找到最佳解，并且种群可能会过早收敛。

根据约束条件优化功能，行为类比主义者倾向于通过类比推理获得知识和理论，并在未知情况和已知情况之间建立相应的关系。在实际应用中，是计算它们之间的相似度，然后定义关联关系。

1.2 机器学习、人工智能和数据挖掘

机器学习与其他领域之间的关系如下图所示：

数据挖掘：通过处理各种数据来促进人们的决策

机器学习：使机器模仿人类的学习来获取知识

人工智能：使用机器学习和推理来最终形成特定的智能行为

机器学习与其他领域的关系

1.2.1 什么是人工智能

人工智能是为了使机器的行为看起来像人类所表现出的智能行为。麻省理工学院的约翰·麦卡锡（JohnMcCarthy）于1956年在达特茅斯会议上提出。

人工智能的先驱者希望机器具有与人类相似的功能：感知，语言，思维，学习，动作等。

近年来，人们发现机器在感知（图像识别）和学习方面具有某些功能，所以人工智能在世界范围内开始普及。

人工智能的现阶段仍处于“弱人工智能”(NarrowAI)阶段

人类不需要大量的数据来进行反复的迭代学习以获取知识和进行推理。他们只需要看一下自行车的照片就可以粗略地区分各种自行车。即目前对人脑中信息的存储和处理尚未得到清晰的研究，与当前主流的深度学习理论有很大的基本差异。

因此，人工智能距离“强人工智能”(GeneralAI)阶段还有很长的路要走。

典型的人工智能系统包括以下方面：

（1）博弈游戏（如深蓝、AlphaGo、AlphaZero等）。

（2）机器人相关控制理论（运动规划、控制机器人行走等）。

（3）机器翻译。

（4）语音识别。

（5）计算机视觉系统。

（6）自然语言处理（自动程序）。

1.2.2 什么是数据挖掘

数据挖掘使用诸如机器学习，统计和数据库之类的方法来发现相对大量的数据集中的模式和知识，涉及数据预处理，模型和推理，可视化等。

数据挖掘包括以下类型的常见任务：

  1. 异常检测(anomalydetection)：识别不符合预期模式的样本和事件。异常也称为离群值，偏差和异常。异常检测通常用于入侵检测，银行欺诈，疾病检测，故障检测等。
  2. 关联规则学习(Associationrulelearning)：发现数据库中变量之间的关系（强规则）。例如，在购物篮分析中，发现规则{面包，牛奶}→{酸奶}表示如果客户同时购买面包和牛奶，他们很有可能也会购买酸奶，这些规则可以用于市场营销。
  3. 聚类：一种探索性分析，在数据结构未知的情况下，根据相似度将样本划分为不同的群集或子集，不同聚类的样本有很大的差异，以便发现数据的类别和结构。
  4. 分类：根据已知样本的某些特征确定新样本所属的类别。通过特征选择和学习，建立判别函数以对样本进行分类。
  5. 回归：一种统计分析方法，用于了解两个或多个变量之间的相关性，回归的目标是找到误差最小的拟合函数作为模型，并使用特定的自变量来预测因变量的值。

随着数据存储（非关系NoSQL数据库），分布式数据计算（Hadoop/Spark等），数据可视化和其他技术的发展，数据挖掘具有越来越多的了解事务的能力，但相对也增加了算法的要求。因此，一方面，数据挖掘必须获取尽可能多，更有价值和更全面的数据，另一方面要从这些数据中提取价值。

数据挖掘在商业智能中有许多应用，特别是在决策辅助、流程优化和精确营销中。例如：

广告公司可以使用用户的浏览历史记录、访问记录、点击记录和购买信息来准确地宣传广告。采用舆论分析，尤其是情感分析，可以提取舆论来驱动市场决策。例如，在电影宣传期间监视社会评论，寻找与目标观众产生共鸣的元素，然后调整媒体宣传策略以迎合观众的口味并吸引更多人。

1.2.3 机器学习、人工智能

数据挖掘是从大量业务数据中挖掘隐藏的、有用的以及正确的知识，以促进决策的执行。

数据挖掘的许多算法都来自机器学习和统计。机器学习中的某些算法利用统计理论，并在实际应用中对其进行优化以实现数据挖掘的目标。

近年来，机器学习的演化计算深度学习等方法也逐渐跳出实验室，从实际数据中学习模式并解决实际问题。数据挖掘与机器学习的交集越来越大，机器学习已成为数据挖掘的重要支撑技术。

机器学习是人工智能的一个分支，作为人工智能的核心技术和实现方法，机器学习方法被用来解决人工智能面临的问题。机器学习是使用一些算法，这些算法允许计算机自动“学习”，分析数据并从中获取规则，然后使用这些规则来预测新样本。

机器学习是人工智能的重要支持技术，而深度学习就是其中一个重要分支。深度学习的典型应用是选择数据来训练模型，然后使用该模型进行预测。例如，博弈游戏系统（DeepBlue）专注于探索和优化未来的解决方案空间（SolutionSpace），而深度学习则为开发游戏算法（例如AlphaGo）付出了艰辛的努力，并已享誉全球成就。 ### 1.3 典型机器学习应用领域

机器学习可以显著提高企业的智能水平并增强其竞争力，对各个行业的影响越来越大。

机器学习应用程序的典型领域包括：

网络安全，搜索引擎，产品推荐，自动驾驶，图像识别，语音识别，量化投资，自然语言处理等。

随着海量数据的积累和硬件计算能力的提高，机器学习的应用领域仍在迅速扩展中。

1.4 机器学习算法分类

算法定义：自动分析数据并从中获取模式（规律），之后使用模式预测未知数据的方法。

算法分类：监督学习，非监督学习和半监督学习。

1.4.1 监督学习

  • 监督学习是从标记的训练数据中学习并建立模型，然后基于该模型预测未知的样本。其中，模型的输入是某个样本数据的特征，而函数的输出是与该样本相对应的标签。
  • 常见的监督学习算法：回归分析、统计分析和分类。
  • 监督学习分类：分类：包括逻辑回归，决策树，KNN，随机森林，支持向量机，朴素贝叶斯等机器学习算法；预测：包括线性回归，KNN，GradientBoosting和AdaBoost等机器学习算法。机器学习算法分类---监督学习

1.4.2 非监督学习

  • 非监督学习也称为无监督学习，该类算法的输入样本不需要标记，而是自动地从样本中学习这种特征以实现预测。
  • 常见的无（非）监督学习算法：聚类和关联分析
  • 在人工神经网络中，自组织映射（SOM）和适应性共振理论（ART）是最常见的无监督学习算法。

1.4.3 半监督学习

  • 半监督学习只有少量的标记数据，完全靠这些不完全标记的数据不可能训练好一个模型，依靠大量的无监督数据来提高算法性能。因此，只有选择半监督学习来使数据的价值达到最大化，使机器学习模型能够从庞大的数据集中挖掘出其隐藏规律。
  • 经过研究人员的不懈努力和长期坚持，半监督学习的发展取得了一定的成效，提出了不少半监督学习方法，也应用到了不少实际领域当中。
  • 半监督学习的研究仍然存在许多待解决的问题，未来的研究大门正等着大家去开启。

机器学习可以分为三种常见的机器学习任务：回归，分类和聚类。

某些机器学习算法可能同时属于不同的类别，例如，某些深度学习算法可能存在于监督学习中，也可能存在于半监督学习中。在具体的实践过程中，可以根据实际需要进行具体地选择。

2. 机器学习的Python常用库

2.1 Numpy简介及基本使用

2.1.1 如何创建

  1. 导入Numpy库，并命名为np
1
import numpy as np
  1. 查看版本
1
np._vision_

创建数组

NumPy 的主要对象是多维数组 Ndarray。在 NumPy 中维度 Dimensions 叫做轴 Axes，轴的个数叫做秩 Rank。注意，numpy.array 和 Python 标准库 array.array 并不相同，前者更为强大，这也就是我们学习 NumPy 的重要原因之一。

  1. 通过列表创建一维数组
1
np.array([1, 2, 3])

上方数组是一个秩为 1 的数组，因为它只有一个轴，而轴的长度为 3。

  1. 通过列表创建二维数组
1
np.array([(1, 2, 3), (4, 5, 6)])
  1. 创建全为0的二维数组
1
np.zeros((3, 4))

array([[0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0., 0., 0.]])

  1. 创建全为1的三维数组
1
np.ones((2, 3, 4))

array([[[1., 1., 1., 1.], [1., 1., 1., 1.], [1., 1., 1., 1.]], [[1., 1., 1., 1.], [1., 1., 1., 1.], [1., 1., 1., 1.]]])

full函数，创建任意大小的数组并填充任意数字

1
np.full((3, 4), 2)
  1. 创建一维等差数组
1
np.arrange(5)

array([0, 1, 2, 3, 4])

  1. 创建二维等差数组
1
np.arange(6).reshape(2, 3)
  1. 创建单位矩阵(二维数组)
1
np.eye(3)

array([[1., 0., 0.],    [0., 1., 0.],    [0., 0., 1.]])

  1. 创建二位随机数组
1
np.random.rand(2, 3)

array([[0.38257919, 0.63590106, 0.64884528],    [0.09064574, 0.32850939, 0.94661844]])

  1. 创建二维数组整数数组(数值小于5)
1
np.random.randint(5, size = (2, 3))

array([[2, 3, 4],    [3, 2, 4]])

2.1.2 数组运算

1
2
3
a = np.array([10, 20, 30, 40, 50])
b = np.arange(1, 6)
a, b

(array([10, 20, 30, 40, 50]), array([1, 2, 3, 4, 5]))

  1. sum
1
2
3
a = np.array([[1, 2],
              [3, 4]])
np.sum(a)

10

1
np.sum(a, axis=0) # axis=0 表示对每一列求和

array([4, 6])

1
np.sum(a, axis=1) # axis=0 表示对每一行求和

array([3, 7])

  1. mean
1
np.mean(a) # 求取平均值

2.5

  1. tile
1
a

array([[1, 2],
   [3, 4]])

1
np.tile(a, (1, 2)) # 将数组a变成一行俩列

array([[1, 2, 1, 2],
   [3, 4, 3, 4]])

1
np.tile(a, (2, 1))

array([[1, 2],
   [3, 4],
   [1, 2],
   [3, 4]])

  1. argsort
1
2
3
a = np.array([[3, 6, 4, 11],
              [5, 10, 1, 3]])
a.argsort() # 将元素按照行从小到大排序，返回对应位置元素的下标

array([[0, 2, 1, 3],
   [2, 3, 0, 1]], dtype=int64)

1
2
# 按照列排序
a.argsort(axis=0)

array([[0, 0, 1, 1],
   [1, 1, 0, 0]], dtype=int64)

  1. 一维数组加法运算
1
a + b

array([11, 22, 33, 44, 55])

  1. 一维数组减法运算
1
a - b

array([ 9, 18, 27, 36, 45])

  1. 一维数组乘法运算
1
a * b

array([ 10, 40, 90, 160, 250])

  1. 一维数组除法运算
1
a / b

array([10., 10., 10., 10., 10.])

  1. 二维数组的运算，相应位置上＋， -， *， /
1
2
3
4
5
A = np.array([[1, 2],
              [3, 4]])
B = np.array([[5, 6],
              [7, 8]])
A * B

array([[ 5, 12],
   [21, 32]])

  1. 矩阵乘法运算
1
np.dot(A, B)

array([[19, 22],
   [43, 50]])

  1. 如果使用np.mat将二维数组准确定义为矩阵，就可以直接使用 * 完成矩阵乘法运算
1
np.mat(A) * np.mat(B)

matrix([[19, 22],
   [43, 50]])

广播

1
2
3
4
a = np.array([[1, 2, 3],
             [4, 5, 6],
             [7, 8, 9]])
b = np.array([1, 2, 3])
1
2
# 在a的每一行都加上b
a + np.tile(b, (3, 1))

array([[ 2, 4, 6],
   [ 5, 7, 9],
   [ 8, 10, 12]])

1
2
 # 可直接简写为a+ b, numpy自动实现广播功能，当参与运算的操作数的维度不一样时
a + b

array([[ 2, 4, 6],
   [ 5, 7, 9],
   [ 8, 10, 12]])

2.1.3 索引的作用

1
2
3
a = np.array([[1, 2, 3, 4],
             [5, 6, 7, 8],
             [9, 10, 11, 12]])
  1. 取出某个确定的值
1
2
# 表示第二行，第三列的数， 逗号前表示一维，逗号后表示二维，以此类推
a[1, 2]

7

  1. 取出某个范围的值
1
2
3
# 冒号表示所取的范围，跟列表的索引用法一样，
# 逗号用来区分每个维度，下面的代码表示[取倒数第二行到最后一行, 第二列到第三列
a[-2:, 1:3]

array([[ 6, 7],    [10, 11]])

  1. 给某个范围的数进行运算
1
2
3
# 给a数组的第二列上的每个数加上10
a[np.arange(3), 1] += 10
a

array([[ 1, 12, 3, 4],    [ 5, 16, 7, 8],    [ 9, 20, 11, 12]])

1
np.arange(10) # 从0开始生成10个数

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

1
np.arange(3, 7) # 还可以生成特定范围的数

array([3, 4, 5, 6])

1
2
3
# 还可以这样写, 相当于，一个行对应一个列
a[[0, 1, 2], [1, 1, 1]] += 10
a

array([[ 1, 22, 3, 4],
   [ 5, 26, 7, 8],
   [ 9, 30, 11, 12]])

  1. 获取数组中大于或小于某个确定值的数值
1
2
result_index = a > 10
result_index

array([[False, False, False, False],
   [False, False, False, False],
   [False, False, True, True]])

1
a[result_index]

array([11, 12])

1
2
# 这样写即可
a[a > 10]

array([11, 12])

2.1.4 元素数据类型

  1. 使用dtype函数查看数组的数据类型
1
a = np.array([1, 2,  3])
1
a.dtype

dtype('int32')

1
2
a = np.array([1.1, 2.2])
a.dtype

dtype('float64')

1
2
a = np.array([1, 1.2])
a.dtype

dtype('float64')

1
2
a = np.array([1.1, 2.2], dtype = np.int64) # 将数据类型转换为整数，直接去掉小数部分
a

array([1, 2], dtype=int64)

1
a.dtype

dtype('int64')

  1. 使用astype转换数据类型
1
2
a = np.array(['1.2', '1.3', '1.4'], dtype = np.string_)
a

array([b'1.2', b'1.3', b'1.4'], dtype='|S3')

1
a.astype(np.float)

array([1.2, 1.3, 1.4])

2.2 Pandas库

2.2.1 什么是Pandas库

Pandas是基于Numpy的专业数据分析工具, 可以灵活高效的处理各种数据集

它提供了的数据结构有DataFrame和Series等

我们可以简单粗的把DataFrame理解为Excel里面的一张表，而Series就是表中的某一列

2.2.2 DataFrame创建和存储

  1. 函数
函数 作用
DataFrame(data = 数据， index = 行标题， columns = 列标题, copy = 是否深拷贝) 创建DataFrame对象
read_csv(filepath_or_buffer = 文件路径, delimiter = 分隔符, header = 是否第一行为列标题, engine = 引擎, encoding = 编码) 读取.csv文件创建DataFrame对象
read_excel(路径, header = 指定哪一行为标题, names = 指定列标题) 读取.xlsx文件创建DataFrame对象
.to_csv(路径) 保存为.csv文件
.to_excel(路径) 保存为.xlsx文件
  1. 使用DataFrame构造函数
函数 作用
DataFrame(data = 数据, index = 行标题, columns = 列标题, dtype = 类型, copy = 是否深拷贝) 创建DataFrame对象

创建时不指定index，系统会自动生成从0开始的索引, 即行标题从0开始

  1. 使用列表创建
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pandas

dataFrame = pandas.DataFrame(
	data = [
        [60, 78, 92, 85],
        [70, 68, 95, 76],
        [88, 98, 83, 87]
    ],
	index = ['小明','小红','小强'], # 指定每行的索引
    columns = ['语文', '数学', '英语', '化学'], # 指定每列的索引
    dtype = float, # 指定数据类型为`float`,即成绩将以浮点数的形式存储
    copy = True 
    # `pandas`会创建数据的副本，即使原始数据被修改，数据框中的数据也不会受到影响。
    # 如果是`false`,如果数据来源是可变的（例如列表或其他数组），并且你在创建 DataFrame 后修改了原始数据
    # 那么这些修改可能会影响到 DataFrame 中的数据。
)
print(dataFrame)
  1. 使用字典创建
1
2
3
4
5
6
7
8
9
10
11
12
13
import pandas

dataFrame = pandas.DataFrame(
	data = {
        '语文': [60, 78, 92, 85],
        '数学': [70, 68, 95, 76],
        '英语': [88, 98, 83, 87],
    },
	index = ['小明', '小红', '小强', '小美'],
	dtype = float,
	copy = True
)
print(dataFrame)

结果

1
2
3
4
5
      语文    数学    英语
小明  60.0  70.0  88.0
小红  78.0  68.0  98.0
小强  92.0  95.0  83.0
小美  85.0  76.0  87.0

列名称是字典中键的名称, 字典中的元素是该列的值

index是每一条记录的名称, index的长度与字典中某一个键值对的值的长度一样

  1. 从另一个DataFrame对象创建
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import pandas

dataFrame = pandas.DataFrame(
	data = [
        [60, 78, 92, 85],
        [70, 68, 95, 76],
        [88, 98, 83, 87]
    ],
	index = ['小明', '小红', '小强'],
	columns = ['语文', '数学', '英语', '化学'],
	dtype = float,
	copy = False
)

dataFrame2 = pandas.DataFrame(dataFrame, copy = False)
print(dataFrame2)
dataFrame2['语文'] = [0, 0, 0]
print(dataFrame)

输出

1
2
3
4
5
6
7
8
      语文    数学    英语    化学
小明  60.0  78.0  92.0  85.0
小红  70.0  68.0  95.0  76.0
小强  88.0  98.0  83.0  87.0
    语文    数学    英语    化学
小明   0  78.0  92.0  85.0
小红   0  68.0  95.0  76.0
小强   0  98.0  83.0  87.0

从已有的DataFrame创建, copy参数可以指定深拷贝还是浅拷贝。

当copy = False是浅拷贝

  1. 从文件读取
函数 作用
read_csv(filepath_or_buffer = 文件路径, delimiter = 分隔符, header = 是否第一行为列标题, engine = 引擎, encoding = 编码) 读取.csv文件创建DataFrame对象
read_excel(路径, header = 指定哪一行为标题, names = 指定列标题) 读取.xlsx文件创建DataFrame对象
  1. 从.csv文件读取
1
2
3
4
import pandas

dataFrame = pandas.read_csv('../数据/test.csv')
print(dataFrame)

输出

1
2
3
   姓名    语文    数学     英语
0  小明  62.0  66.0   86.0
1  小红  86.0  97.5  100.0

默认分隔符以","逗号分割, 可以指定分割类型

1
2
3
4
5
6
7
import pandas

dataFrame = pandas.read_csv(
    '../数据/test.csv',
    delimiter = '|'
)
print(dataFrame)

输出

1
2
3
   姓名    语文    数学     英语
0  小明  62.0  66.0   86.0
1  小红  86.0  97.5  100.0

默认以第一行作为列标题, 可以不知道列标题, 这样第一行也变成了数据

1
2
3
4
5
6
7
8
9
10
import pandas

dataFrame = pandas.read_csv(
    filepath_or_buffer = '../数据/test.csv',
    delimiter = '|',
    header = None,
    engine = 'python',
    encoding = 'utf-8'
)
print(dataFrame)

输出

1
2
3
4
    0    1     2     3
0  姓名   语文    数学    英语
1  小明  62.   66.   86.
2  小红  86.  97.5  100.

engine是使用的分析引擎，读取csv文件一般指定python避免中文和编码造成的报错

encoding是编码格式

  1. 从excel文件读取
1
2
3
4
5
6
7
import pandas

dataFrame = pandas.read_excel(
    '../数据/test.XLSX',
    header = None
)
print(dataFrame)

输出

1
2
3
4
    0     1     2
0  姓名    语文    数学
1  小明  66.5    86
2  小红    89  99.5
  1. 存储
函数 作用
.to_csv(路径) 保存为.csv文件
.to_excel(路径) 保存为.xlsx文件

2.2.3 DataFrame 查看数据

函数

函数 作用
.head(n = 5) 查看数据前n行
.tail(n = 5) 查看数据后n行
.info() 查看数据信息
.describe() 查看数据统计信息
  1. 查看前几行
1
2
3
4
5
6
import pandas
from sklearn import datasets

itis = datasets.load_iris()
dataFrame = pandas.DataFrame(iris.data)
print(dataFrame.head(10))

输出

1
2
3
4
5
6
7
8
9
10
11
     0    1    2    3
0  5.1  3.5  1.4  0.2
1  4.9  3.0  1.4  0.2
2  4.7  3.2  1.3  0.2
3  4.6  3.1  1.5  0.2
4  5.0  3.6  1.4  0.2
5  5.4  3.9  1.7  0.4
6  4.6  3.4  1.4  0.3
7  5.0  3.4  1.5  0.2
8  4.4  2.9  1.4  0.2
9  4.9  3.1  1.5  0.1
  1. 查看后几行
1
2
3
4
5
6
import pandas
from sklearn import datasets

iris = datasets.load_iris()
dataFrame = pandas.DataFrame(iris.data)
print(dataFrame.tail())

输出

1
2
3
4
5
6
       0    1    2    3
145  6.7  3.0  5.2  2.3
146  6.3  2.5  5.0  1.9
147  6.5  3.0  5.2  2.0
148  6.2  3.4  5.4  2.3
149  5.9  3.0  5.1  1.8
  1. 格式查看
1
2
3
4
5
6
import pandas
from sklearn import datasets

iris = datasets.load_iris()
dataFrame = pandas.DataFrame(iris.data)
print(dataFrame.info())

输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 对象的类型
<class 'pandas.core.frame.DataFrame'>
# 数据范围, 一共150个, 从0 - 149
RangeIndex: 150 entries, 0 to 149
# 数据一共4列
Data columns (total 4 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   0       150 non-null    float64
 1   1       150 non-null    float64
 2   2       150 non-null    float64
 3   3       150 non-null    float64
dtypes: float64(4)
memory usage: 4.8 KB
None
  1. 查看统计信息
1
2
3
4
5
6
import pandas
from sklearn import datasets

iris = datasets.load_iris()
dataFrame = pandas.DataFrame(iris.data)
print(dataFrame.describe())

输出

1
2
3
4
5
6
7
8
9
                0           1           2           3
count  150.000000  150.000000  150.000000  150.000000
mean     5.843333    3.057333    3.758000    1.199333
std      0.828066    0.435866    1.765298    0.762238
min      4.300000    2.000000    1.000000    0.100000
25%      5.100000    2.800000    1.600000    0.300000
50%      5.800000    3.000000    4.350000    1.300000
75%      6.400000    3.300000    5.100000    1.800000
max      7.900000    4.400000    6.900000    2.500000

2.2.4 DataFrame 列操作

函数

函数

函数 作用
.drop(列名, axis = 1, inplace = True) 查看数据前n行
  1. 增加列

增加一列，用dataFrame[‘新列名’] = 新列值的形式, 在原数据基础上赋值即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import pandas

dataFrame = pandas.DataFrame(
    data=[
        [60, 78, 92, 85],
        [70, 68, 95, 76],
        [88, 98, 83, 87]
    ],
    index = ['小明', '小红', '小强', ],
    columns = ['语文', '数学', '英语', '化学'],
    dtype = float
)
print(dataFrame)
dataFrame['生物'] = [96, 86, 88]
print(dataFrame)

输出

1
2
3
4
5
6
7
8
      语文    数学    英语    化学
小明  60.0  78.0  92.0  85.0
小红  70.0  68.0  95.0  76.0
小强  88.0  98.0  83.0  87.0
      语文    数学    英语    化学  生物
小明  60.0  78.0  92.0  85.0  96
小红  70.0  68.0  95.0  76.0  86
小强  88.0  98.0  83.0  87.0  88

将其他的数据列增加过来, 即横向合并

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import pandas

dataFrame1 = pandas.DataFrame(
    data=[
        ['一级', '读书', 21, 176],
        ['二级', '游泳', 22, 178],
        ['三级', '游泳', 21, 185],
        ['二级', '游泳', 19, 182],
    ],
    columns=['等级', '爱好', '年龄', '身高'],
    index = ['小明', '小红', '小强', '小于']
)
print(dataFrame1)
dataFrame2 = pandas.DataFrame(
    data=[
        ['学士', 'O'],
        ['学士', 'A'],
        ['博士', 'A'],
        ['院士', 'B'],
    ],
    columns=['学位', '血型'],
    index = ['小明', '小红', '小强', '小于']
)
print(dataFrame2)
r = pandas.merge(
    left = dataFrame1,
    right = dataFrame2,
    left_index = True,
    right_index = True,
    how = 'inner'
)
print(r)

输出

1
2
3
4
5
6
7
8
9
10
    等级  爱好  年龄   身高
小明  一级  读书  21  176
小红  二级  游泳  22  178
小强  三级  游泳  21  185
小于  二级  游泳  19  182
    学位 血型
小明  学士  O
小红  学士  A
小强  博士  A
小于  院士  B
  1. 删除列

使用, axis = 0表示对行操作, axis = 1表示针对列的操作, inplace为True, 则直接在源数据上进行修改, 否则源数据会保持原样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import pandas

dataFrame = pandas.DataFrame(
    data=[
        [60, 78, 92, 85],
        [70, 68, 95, 76],
        [88, 98, 83, 87]
    ],
    index = ['小明', '小红', '小强', ],
    columns = ['语文', '数学', '英语', '化学'],
    dtype = float
)
dataFrame['生物'] = [96, 86, 88]
print(dataFrame)
dataFrame.drop('化学', axis = 1, inplace = True)
print(dataFrame)

输出

1
2
3
4
5
6
7
8
      语文    数学    英语    化学  生物
小明  60.0  78.0  92.0  85.0  96
小红  70.0  68.0  95.0  76.0  86
小强  88.0  98.0  83.0  87.0  88
      语文    数学    英语  生物
小明  60.0  78.0  92.0  96
小红  70.0  68.0  95.0  86
小强  88.0  98.0  83.0  88
  1. 选择列
1
2
3
4
5
6
7
8
9
10
11
12
13
import pandas
dataFrame = pandas.DataFrame(
    data=[
        [60, 78, 92, 85],
        [70, 68, 95, 76],
        [88, 98, 83, 87]
    ],
    index=['小明', '小红', '小强', ],
    columns=['语文', '数学', '英语', '化学'],
    dtype=float
)
print(dataFrame['语文'])
print(dataFrame[['语文', '化学']])

输出

1
2
3
4
5
6
7
8
小明    60.0
小红    70.0
小强    88.0
Name: 语文, dtype: float64
      语文    化学
小明  60.0  85.0
小红  70.0  76.0
小强  88.0  87.0
  1. 修改列

全部修改为同一个值

指定修改的列的内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import pandas
dataFrame = pandas.DataFrame(
    data=[
        [60, 78, 92, 85],
        [70, 68, 95, 76],
        [88, 98, 83, 87]
    ],
    index=['小明', '小红', '小强', ],
    columns=['语文', '数学', '英语', '化学'],
    dtype=float
)
dataFrame['语文'] = 1
dataFrame['化学'] = [100, 100, 100.0]
print(dataFrame)

输出

1
2
3
4
    语文    数学    英语     化学
小明   1  78.0  92.0  100.0
小红   1  68.0  95.0  100.0
小强   1  98.0  83.0  100.0

2.2.5 DataFrame索引

属性 作用
iloc[ , ] 对数据操作，允许整数，整数的列表，切片，布尔数组
loc[ , ] 对数据操作，允许标签和布尔
isin(数据列表) 处于数据列表
  1. 数字索引

dataFrame[行索引, 列索引]

取出数据中 3×3的零

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import pandas

dataFrame = pandas.DataFrame(
    data=[
        [60, 78, 92, 85],
        [70, 68, 95, 76],
        [88, 98, 83, 87],
        [60, 78, 92, 85],
        [70, 0, 0, 0],
        [88, 0, 0, 0],
        [60, 0, 0, 0],
        [70, 68, 95, 76],
        [88, 98, 83, 87]
    ],
    dtype = float,
    columns = ['语文', '数学', '英语', '化学']
)
a = dataFrame.iloc[4:7, 1:]
print(a)

输出

1
2
3
4
    数学   英语   化学
4  0.0  0.0  0.0
5  0.0  0.0  0.0
6  0.0  0.0  0.0

取出数据中 2 × 2的零

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import pandas

dataFrame = pandas.DataFrame(
    data=[
        [60, 78, 92, 85],
        [70, 68, 95, 76],
        [88, 98, 83, 87],
        [60, 78, 92, 85],
        [70, 0, 92, 0],
        [60, 78, 92, 85],
        [60, 0, 92, 0],
        [70, 68, 95, 76],
        [88, 98, 83, 87]
    ],
    dtype = float,
    columns = ['语文', '数学', '英语', '化学']
)
a = dataFrame.iloc[4:7:2, 1:4:2]
print(a)
  1. 布尔索引

dataFrame[行索引, 列索引]

行索引和列索引可以是布尔数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import pandas

dataFrame = pandas.DataFrame(
    data=[
        ['一级', '读书', 21, 176],
        ['二级', '游泳', 22, 178],
        ['三级', '游泳', 21, 185],
        ['二级', '游泳', 19, 182],
    ],
    columns = ['等级', '爱好', '年龄', '身高']
)
b = [True, False, False, True]
a = dataFrame.iloc[b, :]
print(a)

输出

1
2
3
   等级  爱好  年龄   身高
0  一级  读书  21  176
3  二级  游泳  19  182

iloc()函数参数允许:

  • 整数

  • 整数的列表

  • 切片

  • 布尔数组

  1. 标签索引
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pandas

dataFrame = pandas.DataFrame(
    data=[
        ['一级', '读书', 21, 176],
        ['二级', '游泳', 22, 178],
        ['三级', '游泳', 21, 185],
        ['二级', '游泳', 19, 182],
    ],
    columns=['等级', '爱好', '年龄', '身高']
)
# 找出等级为一的全部数据
b = (dataFrame['等级'] == '一级') & (dataFrame['年龄'] == 21)
r = dataFrame.loc[b, :]
print(r)
r = dataFrame.loc[:, ['年龄']]
print(r)

输出

1
2
3
4
5
6
7
   等级  爱好  年龄   身高
0  一级  读书  21  176
   年龄
0  21
1  22
2  21
3  19

找出等级在是二和三的数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import pandas

dataFrame = pandas.DataFrame(
    data=[
        ['一级', '读书', 21, 176],
        ['二级', '游泳', 22, 178],
        ['三级', '游泳', 21, 185],
        ['二级', '游泳', 19, 182],
    ],
    columns=['等级', '爱好', '年龄', '身高']
)
b = dataFrame['等级'].isin(['二级', '三级'])
r = dataFrame.loc[b, :]
print(r)

输出

1
2
3
4
   等级  爱好  年龄   身高
1  二级  游泳  22  178
2  三级  游泳  21  185
3  二级  游泳  19  182

2.2.6 DataFrame操作

函数 作用
concat(dataFrame列表) 将这些dataFrame的数据纵向叠加
merge()(left = 左表, right = 右表, left_index, right_index, how = 连接方式) 按照指定连接方式将两个表合并
.dropna(subset = 列名列表) 只要一行中任意一个字段为空，就会被删除
.isnull() 返回布尔DataFrame对象
.fillna(值) 用值填充空填
dropduplicates(subset = 列名列表, keep = 'first' 或 'last') 删除完全重复行，可指定某字段重复时删除，默认保留第一个，后面重复的会删掉
.sort_value(by = 列名, ascending = 是否升降) 对指定列排序
.groupby('列名') 对指定列分组，就是把该列值一样的分成一组
cut(x = 切分数据, bins = 切分方式, right = 是否包含右区间, labels = 分割后每段的名字列表) 对一个数组进行分段
  1. 纵向合并
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import pandas

dataFrame1 = pandas.DataFrame(
    data=[
        ['一级', '读书', 21, 176],
        ['二级', '游泳', 22, 178],
        ['三级', '游泳', 21, 185],
        ['二级', '游泳', 19, 182],
    ],
    columns=['等级', '爱好', '年龄', '身高'],
    index = ['小明', '小红', '小强', '小于']
)
r = pandas.concat([dataFrame1, dataFrame1])
print(r)

输出

1
2
3
4
5
6
7
8
9
    等级  爱好  年龄   身高
小明  一级  读书  21  176
小红  二级  游泳  22  178
小强  三级  游泳  21  185
小于  二级  游泳  19  182
小明  一级  读书  21  176
小红  二级  游泳  22  178
小强  三级  游泳  21  185
小于  二级  游泳  19  182
  1. 横向合并
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import pandas

dataFrame1 = pandas.DataFrame(
    data=[
        ['一级', '读书', 21, 176],
        ['二级', '游泳', 22, 178],
        ['三级', '游泳', 21, 185],
        ['二级', '游泳', 19, 182],
    ],
    columns=['等级', '爱好', '年龄', '身高'],
    index=['小明', '小红', '小强', '小于']
)
print(dataFrame1)
dataFrame2 = pandas.DataFrame(
    data=[
        ['学士', 'O'],
        ['学士', 'A'],
        ['博士', 'A'],
        ['院士', 'B'],
    ],
    columns=['学位', '血型'],
    index=['小明', '小红', '小强', '小于']
)
print(dataFrame2)
r = pandas.merge(
    left=dataFrame1,
    right=dataFrame2,
    left_index=True,
    right_index=True,
    how='inner'
)
print(r)

输出

1
2
3
4
5
6
7
8
9
    等级  爱好  年龄   身高
小明  一级  读书  21  176
小红  二级  游泳  22  178
小强  三级  游泳  21  185
小于  二级  游泳  19  182
小明  一级  读书  21  176
小红  二级  游泳  22  178
小强  三级  游泳  21  185
小于  二级  游泳  19  182
参数 作用
left 左表名
right 右表名
left_index 左表按照索引连接
right_index 右表按照索引连接
how 连接方式, inner, left, right, outer

左连接左表数据不改变, 连接时没有的字段为空

右连接右表数据不改变, 连接时没有的字段为空

外连接是两个表的数据都不变, 没有的字段为空

  1. 空值处理
函数 作用
.dropna(subset = 列名列表) 只要一行中任意一个字段为空，就会被删除
.isnull() 返回布尔DataFrame对象
  1. 判断空值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import pandas

dataFrame = pandas.DataFrame(
    data=[
        ['一级', None, 21, 176],
        ['二级', '游泳', None, 178],
        ['三级', '游泳', 21, 185],
        [None, '游泳', 19, None],
    ],
    columns=['等级', '爱好', '年龄', '身高'],
    index=['小明', '小红', '小强', '小于']
)
print(dataFrame)
print(dataFrame.isnull())
print(dataFrame['等级'].isnull())

输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
      等级    爱好    年龄     身高
小明    一级  None  21.0  176.0
小红    二级    游泳   NaN  178.0
小强    三级    游泳  21.0  185.0
小于  None    游泳  19.0    NaN
       等级     爱好     年龄     身高
小明  False   True  False  False
小红  False  False   True  False
小强  False  False  False  False
小于   True  False  False   True
小明    False
小红    False
小强    False
小于     True
Name: 等级, dtype: bool
  1. 计算空值个数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import pandas

dataFrame = pandas.DataFrame(
    data=[
        ['一级', None, 21, 176],
        ['二级', '游泳', None, 178],
        ['三级', '游泳', 21, 185],
        [None, '游泳', 19, None],
    ],
    columns=['等级', '爱好', '年龄', '身高'],
    index=['小明', '小红', '小强', '小于']
)
print(dataFrame)
print(dataFrame.isnull().sum())

输出

1
2
3
4
5
6
7
8
9
10
      等级    爱好    年龄     身高
小明    一级  None  21.0  176.0
小红    二级    游泳   NaN  178.0
小强    三级    游泳  21.0  185.0
小于  None    游泳  19.0    NaN
等级    1
爱好    1
年龄    1
身高    1
dtype: int64
  1. 删除空值

dropna()函数, 只要一行中任意一个字段为空，就会被删除

dropna(subset = [‘列名’]), 指定当某列出现空值才删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import pandas

dataFrame = pandas.DataFrame(
    data=[
        ['一级', None, 21, 176],
        ['二级', '游泳', None, 178],
        ['三级', '游泳', 21, 185],
        [None, '游泳', 19, None],
    ],
    columns=['等级', '爱好', '年龄', '身高'],
    index=['小明', '小红', '小强', '小于']
)
print(dataFrame)
print(dataFrame.dropna())

输出

1
2
3
4
5
6
7
      等级    爱好    年龄     身高
小明    一级  None  21.0  176.0
小红    二级    游泳   NaN  178.0
小强    三级    游泳  21.0  185.0
小于  None    游泳  19.0    NaN
    等级  爱好    年龄     身高
小强  三级  游泳  21.0  185.0
  1. 填充空值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import pandas

dataFrame = pandas.DataFrame(
    data=[
        ['一级', None, 21, 176],
        ['二级', '游泳', None, 178],
        ['三级', '游泳', 21, 185],
        [None, '游泳', 19, None],
    ],
    columns=['等级', '爱好', '年龄', '身高'],
    index=['小明', '小红', '小强', '小于']
)
print(dataFrame)
dataFrame['年龄'] = dataFrame['年龄'].fillna(20)
print(dataFrame)

输出

1
2
3
4
5
6
7
8
9
小明    一级  None  21.0  176.0
小红    二级    游泳   NaN  178.0
小强    三级    游泳  21.0  185.0
小于  None    游泳  19.0    NaN
      等级    爱好    年龄     身高
小明    一级  None  21.0  176.0
小红    二级    游泳  20.0  178.0
小强    三级    游泳  21.0  185.0
小于  None    游泳  19.0    NaN
  1. 去重
函数 作用
.dropduplicates(subset = 列名列表, keep = 'first' 或 'last') 删除完全重复行, 可指定某字段重复时删除, 默认保留第一个, 后面重复的会删掉 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import pandas

dataFrame = pandas.DataFrame(
    data=[
        ['一级', None, 21, 176],
        ['二级', '游泳', None, 178],
        ['三级', '游泳', 21, 185],
        [None, '游泳', 19, None],
    ],
    columns=['等级', '爱好', '年龄', '身高'],
    index=['小明', '小红', '小强', '小于']
)
print(dataFrame)
print(dataFrame.drop_duplicates(subset = ['爱好'], keep = 'first'))

输出

1
2
3
4
5
6
7
8
      等级    爱好    年龄     身高
小明    一级  None  21.0  176.0
小红    二级    游泳   NaN  178.0
小强    三级    游泳  21.0  185.0
小于  None    游泳  19.0    NaN
    等级    爱好    年龄     身高
小明  一级  None  21.0  176.0
小红  二级    游泳   NaN  178.0
  1. 排序
函数 作用
.sort_values(by = 列名, ascending = 是否升序) 对某列排序 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import pandas

dataFrame = pandas.DataFrame(
    data=[
        ['一级', None, 21, 176],
        ['二级', '游泳', None, 178],
        ['三级', '游泳', 21, 185],
        [None, '游泳', 19, None],
    ],
    columns=['等级', '爱好', '年龄', '身高'],
    index=['小明', '小红', '小强', '小于']
)
print(dataFrame)
dataFrame = dataFrame.sort_values(by = '等级', ascending = True)
print(dataFrame)

输出

1
2
3
4
5
6
7
8
9
10
      等级    爱好    年龄     身高
小明    一级  None  21.0  176.0
小红    二级    游泳   NaN  178.0
小强    三级    游泳  21.0  185.0
小于  None    游泳  19.0    NaN
      等级    爱好    年龄     身高
小明    一级  None  21.0  176.0
小强    三级    游泳  21.0  185.0
小红    二级    游泳   NaN  178.0
小于  None    游泳  19.0    NaN
  1. 分组
函数 作用
.groupby('列名') 对指定列分组, 就是把该列值一样的分成一组
计算值函数 作用
sum() 组内求和
max() 组内求最大值
min() 组内求最小值
std() 组内求标准差
mean() 组内求平均数 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import pandas

dataFrame = pandas.DataFrame(
    data=[
        ['一级', '读书', 21, 176],
        ['二级', '游泳', 20, 178],
        ['三级', '游泳', 21, 185],
        ['四级', '游泳', 19, 177],
    ],
    columns=['等级', '爱好', '年龄', '身高'],
    index=['小明', '小红', '小强', '小于']
)
print(dataFrame)
groupData = dataFrame.groupby('年龄')
print(groupData)
print(groupData.sum())
print(groupData.max())
print(groupData.min())
print(groupData.std())
print(groupData.mean())

输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
    等级  爱好  年龄   身高
小明  一级  读书  21  176
小红  二级  游泳  20  178
小强  三级  游泳  21  185
小于  四级  游泳  19  177
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x000001E4FB3E4730>
     身高
年龄     
19  177
20  178
21  361
    等级  爱好   身高
年龄             
19  四级  游泳  177
20  二级  游泳  178
21  三级  读书  185
    等级  爱好   身高
年龄             
19  四级  游泳  177
20  二级  游泳  178
21  一级  游泳  176
          身高
年龄          
19       NaN
20       NaN
21  6.363961
       身高
年龄       
19  177.0
20  178.0
21  180.5

可以指定分组后的数据的列进行操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
dataFrame = pandas.DataFrame(
    data=[
        ['一级', '读书', 21, 176],
        ['二级', '游泳', 20, 178],
        ['三级', '游泳', 21, 185],
        ['四级', '游泳', 19, 177],
        ['四级', '读书', 19, 165],
        ['四级', '读书', 19, 190],
    ],
    columns=['等级', '爱好', '年龄', '身高'],
    index=['小明', '小红', '小强', '小于', '小兰', '小智']
)
print(dataFrame)
groupData = dataFrame.groupby('年龄')
groupData = groupData['身高']
print(groupData.sum())

输出

1
2
3
4
5
6
7
8
9
10
11
12
    等级  爱好  年龄   身高
小明  一级  读书  21  176
小红  二级  游泳  20  178
小强  三级  游泳  21  185
小于  四级  游泳  19  177
小兰  四级  读书  19  165
小智  四级  读书  19  190
年龄
19    532
20    178
21    361
Name: 身高, dtype: int64
  1. 分段
函数 作用
cut(x = 切分数据, bins = 切分方式, right = 是否包含右区间, labels = 分割后每段的名字列表) 对一个数组进行分段 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import pandas

dataFrame = pandas.DataFrame(
    data=[
        ['一级', '读书', 21, 176],
        ['二级', '游泳', 20, 178],
        ['三级', '游泳', 21, 185],
        ['四级', '游泳', 19, 177],
        ['四级', '读书', 19, 165],
        ['四级', '读书', 19, 190],
    ],
    columns=['等级', '爱好', '年龄', '身高'],
    index=['小明', '小红', '小强', '小于', '小兰', '小智']
)
r = pandas.cut(x = dataFrame['身高'], bins = [160, 170, 180, 190, 200], right = False, labels = ['中等身高', '身高较高', '身高很高', '身高太高'])
print(r, end = '\n')
r = pandas.cut(x=dataFrame['身高'], bins = 4, right=False, labels=['中等身高', '身高较高', '身高很高', '身高太高'])
print(r)

输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
小明    身高较高
小红    身高较高
小强    身高很高
小于    身高较高
小兰    中等身高
小智    身高太高
Name: 身高, dtype: category
Categories (4, object): ['中等身高' < '身高较高' < '身高很高' < '身高太高']
小明    身高较高
小红    身高很高
小强    身高太高
小于    身高较高
小兰    中等身高
小智    身高太高
Name: 身高, dtype: category
Categories (4, object): ['中等身高' < '身高较高' < '身高很高' < '身高太高']

3. 回归算法与应用

3.1 回归分析

回归分析（regression analysis）是确定两种或两种以上变量间相互依赖定量关系的一种统计分析方法，是应用极其广泛的数据分析方法之一。作为一种预测模型，它基于观测数据建立变量间适当的依赖关系，以分析数据内在规律，并用于预测、控制等问题。

例1:假设我们想要一个能够预测二手车价格的系统。

系统输入：品牌、年龄、发动机性能、里程等我们认为会影响车价的属性信息。

输出：车的价格。

这种输出为数值的问题是回归问题。

现假设x表示车的属性，y表示车的价格。我们通过调查以往的交易情况，能够收集训练数据。而机器学习中的线性回归方法能够构造出一个函数来拟合这些数据，从而得到关于x的函数y。如下图所示，其中w和w0为待拟合的参数值，拟合函数具有如下表达式：

y=wx+w0

例2：移动机器人的导航。如自动汽车导航。

输出：每次转动的角度，使得汽车前进而不会撞到障碍物或偏离车道

输入的数值：由汽车上的传感器（如视频相机、GPS等）提供。训练数据可以通过监视和记录驾驶员的动作收集。

例3:假设要制造一个焙炒咖啡的机器。

输入数值为各种温度、时间、咖啡豆种类等配置。针对不同的输入配置进行大量实验，并检测咖啡的品质。

例如，可根据消费者的满意度测量咖啡的品质。

为寻求最优配置，我们可以先拟合一个回归模型，并在当前模型的最优样本附近选择一些新的点，来检测咖啡的品质，再将他们加入训练数据，并拟合新的模型。

预测问题可以划分为回归和分类这两大类，前者的输出为连续值，后者的输出为离散值。由于这两类问题具有不同的特点，需要使用不同的分析方法。本节将对回归问题进行讨论。

3.2 常见数据集

1、波士顿房价数据集

波士顿房价数据集（BostonHousePriceDataset）包含对房价的预测，以千美元计，给定的条件是房屋及其相邻房屋的详细信息。该数据集是一个回归问题。每个类的观察值数量是均等的，共有506个观察值，13个输入变量和1个输出变量。部分变量名如下：

CRIM：表示城镇人均犯罪率；

ZN：表示住宅用地超过25000英寸的比例；

INDUS：表示城镇中非商业用地的所占比例；

CHAS：表示查尔斯河虚拟变量，用于回归分析；

NOX：表示环保指数；

RM：表示每栋住宅平均房间数；

AGE：表示1940年以前建成的自住单位的比例；

DIS：表示距离五个波士顿就业中心的加权距离；

RAD：表示辐射性公路的接近指数；

TAX：表示每一万美元的不动产税率。

2、温室气体观测网络数据集

该数据集根据天气模型模拟给出的综合观测值和示踪剂的时间序列，来监测加利福尼亚的温室气体（GHG）排放得到。该数据集包含使用化学方法对天气研究和预报模型（WRF-Chem）模拟创建的加利福尼亚州2921个网格单元的温室气体（GHG）浓度的时间序列。

利用这些数据：

（1）使用逆方法来确定与合成观测值最匹配的15个示踪剂的加权总和中的权重的最佳值；

（2）使用优化方法来确定要观测的最佳位置。

数据集中的每个文件都标记为ghg.gid.siteWXYZ.dat，其中WXYZ是网格单元的位置ID。每个网格单元文件中（GHG浓度以万亿分之一为单位）：

第1-15行：从区域1-15排放的示踪剂的温室气体浓度第16行：综合观测值的温室气体浓度第1-327列：自2010年5月10日至2010年7月31日，每6个小时的温室气体浓度。

数据集下载

3、葡萄酒质量数据集

包括来自葡萄牙北部的两个与红色和白色vinhoverde葡萄酒样品有关的数据集。目标是根据理化测试对葡萄酒质量进行建模。这两个数据集与葡萄牙“VinhoVerde”葡萄酒的红色和白色变体有关。由于隐私和物流问题，只有理化变量特征是可以进行使用的（例如，数据集中没有关于葡萄品种、葡萄酒品牌、葡萄酒销售价格等的数据）。此数据集可以视为分类或回归任务。本数据集有4898个观察值，11个输入变量和一个输出变量。变量名如下：

输入变量（基于理化测试）：

1-固定酸度；2-挥发性酸度；3-柠檬酸；

4-残留糖；5-氯化物；6-游离二氧化硫；

7-总二氧化硫；8-密度；9-pH；

10-硫酸盐；11-醇；

输出变量（基于感官数据）：

12-质量（得分在0到10之间）。

数据集下载

3.3 线性回归

原理与应用场景

当两个或多个变量间存在线性相关关系时，常常希望在变量间建立定量关系，相关变量间的定量关系的表达即是线性回归。

给定由d个属性描述的示例x=(x1,x2,⋯,xd)，其中xi是x在第i个属性上的取值，线性模型就是通过属性的线性组合构造预测的函数，即

\(f(x) = w^1 \times x_1+ w^2 \times x^2 + ... + w^d \ times x^d + b\)

一般用向量形式写成：

\(f(x) = w^Tx + b\)

其中w=(w1,w2,⋯,wd)。得到参数w和b之后，模型就得以确定，即线性回归模型。

特点：

形式简单、易于建模，但蕴含着机器学习中一些重要的基本思想，许多功能更为强大的非线性模型可在线性模型的基础上通过引入层级结构或高维映射获得。此外，由于푤直观表达了各属性在预测中的重要性，因此线性模型有很好的解释性。

#ai #机器学习
机器学习
http://crazythursdayv50tome.cn/2024/08/07/MachineLearning/
Author
John Doe
Posted on
August 7, 2024
Licensed under