开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 人工智能 -> 【机器学习&深度学习】06 数据处理（一） -> 正文阅读

[人工智能]【机器学习&深度学习】06 数据处理（一）

1. 去除重复值

1.1 drop_dumplicates()

使用 pandas 工具库中的 drop_duplicates() 函数完成。

函数格式：仅能对 DataFrame 格式的数据起效。

DataFrame.drop_duplicates(subset=None, keep='first', inplace=False)

参数说明：

subset：该参数决定了我们根据哪些列进行去重，默认使用所有列。
keep：可选项为 'first', 'last' 和 False，默认为 'first'。默认情况下相同数据将保留第一条。keep = 'last' 时，相同数据保留最后一条。keep = False 时所有相同数据都不会被保留。
inplace：该参数决定了是否直接在原数据上进行修改，默认为 False。inplace = True 时将直接在原数据上进行原地修改，否则将返回一个修改后的副本。

1.2 【练习】根据指定属性完成数据去重

题目描述：

method, number, orbital_period, mass, distance, year 均为属性。在本题中我们规定使用 method 和 year 两个属性进行筛选，当某些样本的这两个属性对应的值相同时则认为这些样本是重复数据。对重复数据我们将仅保留第一个样本，其余的样本需要被删除。

将以下数据保存为一个csv文件，以便于读取

method,number,orbital_period,mass,distance,year
Radial Velocity,1,269.3,7.1,77.4,2006
Radial Velocity,1,874.774,2.21,56.95,2008
Radial Velocity,1,763,2.6,19.84,2011
Radial Velocity,1,326.030,19.40,110.62,2007
Radial Velocity,1,516.220,10.50,119.47,2009
Radial Velocity,1,185.840,4.8,76.39,2008
Radial Velocity,1,1773.400,4.64,18.15,2002
Radial Velocity,1,798.500,None,21.41,1996
Radial Velocity,1,993.300,10.30,73.10,2008
Radial Velocity,2,452.800,1.99,94.79,2010

运行以下代码

# 去重复值练习
import pandas as pd

input_data = pd.read_csv("1_2.csv")
print("原始数据\n", input_data.to_string())
output = input_data.drop_duplicates(subset=['method', 'year'], keep='first', inplace=False)
print("去重后的数据\n", output)

运行结果：

原始数据
             method  number  orbital_period   mass  distance  year
0  Radial Velocity       1         269.300    7.1     77.40  2006
1  Radial Velocity       1         874.774   2.21     56.95  2008
2  Radial Velocity       1         763.000    2.6     19.84  2011
3  Radial Velocity       1         326.030  19.40    110.62  2007
4  Radial Velocity       1         516.220  10.50    119.47  2009
5  Radial Velocity       1         185.840    4.8     76.39  2008
6  Radial Velocity       1        1773.400   4.64     18.15  2002
7  Radial Velocity       1         798.500   None     21.41  1996
8  Radial Velocity       1         993.300  10.30     73.10  2008
9  Radial Velocity       2         452.800   1.99     94.79  2010
去重后的数据
             method  number  orbital_period   mass  distance  year
0  Radial Velocity       1         269.300    7.1     77.40  2006
1  Radial Velocity       1         874.774   2.21     56.95  2008
2  Radial Velocity       1         763.000    2.6     19.84  2011
3  Radial Velocity       1         326.030  19.40    110.62  2007
4  Radial Velocity       1         516.220  10.50    119.47  2009
6  Radial Velocity       1        1773.400   4.64     18.15  2002
7  Radial Velocity       1         798.500   None     21.41  1996
9  Radial Velocity       2         452.800   1.99     94.79  2010

2. 数据标准化

2.1 数据标准化处理的介绍

数据的标准化处理：使各指标的数值都处于同一个数量级别上，从而便于不同单位或数量级的指标能够进行综合分析和比较。（为了统一比较的标准，保证结果的可靠性，我们在分析数据之前，需要对原始变量进行一定的处理）

标准化处理的原因：将原始数据转化为无量纲、无数量级差异的标准化数值，消除不同指标之间因属性不同而带来的影响，从而使结果更具有可比性。

2.2 数据标准化处理的类型

2.2.1 指标一致化处理

作用：解决数据性质不一致的问题
俩概念：
- 正指标：某一类指标，数值越大越好，例如上文提到的年收入、不动产数目等
- 逆指标：另有一类指标，数值越小越好，例如违约还款次数等
一致化原因：如果同时评价这两类指标的综合作用，由于作用方向不同，将不同性质的指标作用直接相加，并不能正确反映不同作用方向产生的综合结果。此时需要对逆指标进行一致化处理，改变逆指标的性质和作用方向，使所有指标作用方向一致化。
针对逆指标一致化处理的方法主要有两种：
- 倒数一致化，即对原始数据取倒数
  $X' = X 1 ? (X > 0)$
- 减法一致化，即利用该指标允许范围内的一个上界值（M），依次减去每一个原始数据
  $X' = M ? X$
注意：倒数一致化常常会改变原始数据的分散程度，这种改变会夸大或缩小原始数据的实际差异。而减法一致化则不改变数据的分散程度，因此结果一致化会更加稳定。

2.2.2 无量纲化处理

对量纲的解释：?量纲化，也称为数据的规范化，是指不同指标之间由于存在量纲不同致其不具可?性，故?先需将指标进??量纲化，消除量纲影响后再进行接下来的分析。

从几何角度来说可以分为：直线型、折线型、曲线形无量纲化方法。

一、直线型无量纲化方法：又包括阈值法、指数法、标准化方法、比重法

二、折线型无量纲化方法：凸折线型法、凹折线型法、三折线型法

三、曲线型无量纲化方法

作用：解决数据之间可比性的问题

常用的直线型无量纲化数据处理方法主要有如下几种：

① min-max 标准化（归一化）

适用情况：当某个指标有最大值最小值时

极差标准化法： 消除变量量纲和变异范围影响

规定：把最大值归为1，最小值归为0或-1，其他值在其中分布。

解释：对于每个属性，设 minA 和 maxA分别为属性A的最小值和最大值，将A的一个原始值 X 通过 min-max 标准化映射成在区间[0,1]中的值 X′，其公式为：
$\frac{x-x_{min}}{x_{max}-x_{min}}$
实现代码：

def Normalization(data):
	data = [(float(i)-min(x))/float(max(x)-min(x)) for i in data]
	return data

【练习】使用 min-max 标准化对数据进行标准化

# 使用 min-max 标准化对数据进行标准化
from numpy import ndarray
import numpy as np


def min_max(data: ndarray) -> ndarray:
    """
    :featurn: A set of characteristics of the sample set
    :return: Return the dataset after standardization
    """
    # -- write your code here --
    a = min(data)
    b = max(data)
    data = [(float(i)-a)/float(b-a) for i in data]
    return data


data1 = np.array([5.1, 4.9, 4.7, 4.6, 5., 6.3, 6.5, 6.2, 5.9])
a = min_max(data1)
print(a)


运行结果：
[0.26315789473684204, 0.15789473684210562, 0.05263157894736869, 0.0, 0.21052631578947384, 0.894736842105263, 1.0, 0.8421052631578949, 0.6842105263157897]

② z-score标准化（规范化）

适用情况：当遇到某个指标的最大值和最小值未知的情况时，或者有超出取值范围的离群数值的时候。即极差标准化法不适用的时候。

标准差标准化法：基于原始数据的均值（mean）和标准差（standard deviation）进行数据的标准化。

规定：一般把均值归一化为0，方差归一化1。

解释：计算该指标的均值和标准差 σ，然后用该变量的每一个观察值 x 减去均值，再除以标准差 σ 即：
$X′=\frac{x-\overline{x}}{\sigma}$
实现代码：

def Z_Score(data):
    lenth = len(data)
    total = sum(data)
    ave = float(total)/lenth
    tempsum = sum([pow(data[i] - ave,2) for i in range(lenth)])
    tempsum = pow(float(tempsum)/lenth,0.5)
    for i in range(lenth):
        data[i] = (data[i] - ave)/tempsum
    return data

Z-Score的优缺点

优点	缺点
简单	有风险
容易计算,仅仅凭借最简单的数学公式就能够计算出Z-Score并进行比较	平均值与方差的数据很难得到，大多数情况要是用样本的均值和标准差替代。Z-Score对于数据的分布有一定的要求，正态分布是最有利于Z-Score计算的。
能够应用于数值型的数据，并且不受数据量级的影响，因为它本身的作用就是消除量级给分析带来的不便。	结果只能用于比较数据间的结果，数据的真实意义还需要还原原值。

【练习】使用z-score对数据进行标准化

from numpy import ndarray
import numpy as np
import time


def z_score1(data: ndarray) -> ndarray:
    lenth = len(data)
    total = sum(data)
    ave = float(total) / lenth
    tempsum = sum([pow(data[i] - ave, 2) for i in range(lenth)])
    tempsum = pow(float(tempsum) / lenth, 0.5)
    for i in range(lenth):
        data[i] = (data[i] - ave) / tempsum
    return data


start1 = time.time()
data1 = np.array([5.1, 4.9, 4.7, 4.6, 5., 6.3, 6.5, 6.2, 5.9])
a = z_score1(data1)
print(a)
end1 = time.time()
print("第一个运行的时间:\n", end1 - start1)


运行结果：
[-0.51854497 -0.80138769 -1.0842304  -1.22565175 -0.65996633  1.1785113
  1.46135401  1.03708995  0.61282588]
第一个运行的时间:
 0.0009996891021728516

from numpy import ndarray
import numpy as np
import time

stat = time.time()


def z_score(data: ndarray) -> ndarray:
    len = data.size
    avg = sum(data)/len  # 均值
    fc = 0  # 方差
    for x in data:
        fc += pow(x-avg, 2)
    fc /= len
    sd = pow(fc, 0.5)  # 标准差，是方差的平方根
    for i in range(len):
        data[i] = (data[i] - avg) / sd
    return data


data1 = np.array([5.1, 4.9, 4.7, 4.6, 5., 6.3, 6.5, 6.2, 5.9])
a = z_score(data1)
print(a)
end = time.time()
print('运行时间：\n', stat-end)


运行结果：
[-0.51854497 -0.80138769 -1.0842304  -1.22565175 -0.65996633  1.1785113
  1.46135401  1.03708995  0.61282588]
运行时间：
 -0.0010037422180175781

3. 缺失值处理

之前在Pandas章节中有介绍过缺失值数据处理/数据清洗，但是仅适用于DataFrame类型。

以下内容借鉴此文章：参考文章

3.1 缺失值的分类

完全随机缺失：数据的缺失是完全随机的；
随机缺失：数据的缺失不是完全随机的，和完全变量有关；
完全不随机缺失：数据的缺失与不完全变量自身的取值相关；缺失值会使得系统丢失了大量的有用信息，系统所表现出来的不确定性更加显著，系统中蕴含的确定性成分更难把握，包含空值的不完全变量会使得挖掘过程陷入混乱。

3.2 删除缺失值

适用环境：

在遇到某列数据（标签或指标等）大量丢失时，常用的方法是将该含有过多空值的行/列删除

DataFrame.dropna函数介绍：

DataFrame.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)

参数说明：

axis: axis=0 表示 index 行, axis=1 表示 columns 列，默认为0
how: “all” 表示这一行或列中的元素全部缺失，才删除这一行或列，“any” 表示这一行或列中只要有元素缺失，就删除这一行或列
thresh: axis 中至少有 thresh 个非缺失值，否则删除。
subset: 在某些列的子集中选择出现了缺失值的列删除，不在子集中的含有缺失值得列或行不会删除。
inplace: 刷选过缺失值得新数据是存为副本还是直接在原数据上进行修改。默认是 False，即创建新的对象进行修改，原对象不变，和深复制和浅复制有些类似。

3.3 缺失值处理

3.3.1 均值插补

根据空值属性：

数值属性：取平均数

非数值属性：直接取众数

根据模块：

Pandas中，使用fillna()函数

函数构成：
DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs)
参数说明：

value: 需要用什么值去填充缺失值
axis: 确定填充维度，从行开始或是从列开始
method: ffill: 用缺失值前面的一个值代替缺失值，如果 axis =1，那么就是横向的前面的值替换后面的缺失值，如果 axis=0，那么则是上面的值替换下面的缺失值。backfill/bfill，缺失值后面的一个值代替前面的缺失值。注意这个参数不能与value同时出现
limit: 确定填充的个数，如果 limit=2，则只填充两个缺失值。

sklearn 中，一般使用 impute.SimpleImputer 类

导入的包：
from sklearn.impute import SimpleImputer
函数构成：
sklearn.impute.SimpleImputer (missing_values=nan, strategy=’mean’, fill_value=None, verbose=0,copy=True)
参数说明：

参数含义&输入
missing_values 告诉 SimpleImputer，数据中的缺失值长什么样，默认空值 np.nan
strategy 我们填补缺失值的策略，默认均值。输入 ”mean“ 使用均值填补（仅对数值型特征可用）；输入 ”median“ 用中值填补（仅对数值型特征可用）；输入 “most_frequent" 用众数填补（对数值型和字符型特征都可用）；输入 ”constant“ 表示请参考参数 ”fill_value“ 中的值（对数值型和字符型特征都可用）
fill_value 当参数 startegy 为 ”constant“ 的时候可用，可输入字符串或数字表示要填充的值，常用0
copy 默认为 True，将创建特征矩阵的副本，反之则会将缺失值填补到原来的特征矩阵中去

【实操练习】文件读取+数据处理+分析

准备一个csv文件：

method,number,orbital_period,mass,distance,year
Radial Velocity,1,269.3,7.1,77.4,2006
Radial Velocity,1,874.774,2.21,56.95,2008
Radial Velocity,1,763,2.6,19.84,2011
Radial Velocity,1,326.030,19.40,110.62,2007
Radial Velocity,1,516.220,10.50,119.47,2009
Radial Velocity,1,185.840,4.8,76.39,2008
Radial Velocity,1,1773.400,4.64,18.15,2002
Radial Velocity,1,798.500,NaN,21.41,1996
Radial Velocity,1,993.300,10.30,73.10,2008
Radial Velocity,2,452.800,1.99,94.79,2010

执行以下代码：

# 对sklearn插补
from sklearn.impute import SimpleImputer
import pandas as pd
import numpy as np

file = '3_1.csv'
df = pd.read_csv(file, header=0)
print("未处理前读取的数据：\n", type(df), '\n', df)
print('-'*50)
imp = SimpleImputer(missing_values=np.nan, strategy='constant', fill_value=0)
imp.fit(df)
df = imp.transform(df)
print("处理后读取的数据：\n", type(df), '\n', df)

运行结果：

未处理前读取的数据：
 <class 'pandas.core.frame.DataFrame'> 
             method  number  orbital_period   mass  distance  year
0  Radial Velocity       1         269.300   7.10     77.40  2006
1  Radial Velocity       1         874.774   2.21     56.95  2008
2  Radial Velocity       1         763.000   2.60     19.84  2011
3  Radial Velocity       1         326.030  19.40    110.62  2007
4  Radial Velocity       1         516.220  10.50    119.47  2009
5  Radial Velocity       1         185.840   4.80     76.39  2008
6  Radial Velocity       1        1773.400   4.64     18.15  2002
7  Radial Velocity       1         798.500    NaN     21.41  1996
8  Radial Velocity       1         993.300  10.30     73.10  2008
9  Radial Velocity       2         452.800   1.99     94.79  2010
--------------------------------------------------
处理后读取的数据：
 <class 'numpy.ndarray'> 
 [['Radial Velocity' 1 269.3 7.1 77.4 2006]
 ['Radial Velocity' 1 874.774 2.21 56.95 2008]
 ['Radial Velocity' 1 763.0 2.6 19.84 2011]
 ['Radial Velocity' 1 326.03 19.4 110.62 2007]
 ['Radial Velocity' 1 516.22 10.5 119.47 2009]
 ['Radial Velocity' 1 185.84 4.8 76.39 2008]
 ['Radial Velocity' 1 1773.4 4.64 18.15 2002]
 ['Radial Velocity' 1 798.5 0 21.41 1996]
 ['Radial Velocity' 1 993.3 10.3 73.1 2008]
 ['Radial Velocity' 2 452.8 1.99 94.79 2010]]

结果分析：数据从dataframe类型转变为ndarray类型，其中的一个空值填充为0。

3.3.2 同类均值插补

这种插补方式同均值插补的方法都属于单值插补，在该方法中，用于求平均的值并不是从数据集的所有对象中取，而是从与该对象具有相同决策属性值的对象中取得。这两种数据的补齐方法，其基本的出发点都是一样的，以最大概率可能的取值来补充缺失的属性值，只是在具体方法上有一点不同。

它用层次聚类模型预测缺失变量的类型，再以该类型的均值插补。假设 X=(X1,X2…Xp) 为信息完全的变量，Y 为存在缺失值的变量，那么首先对 X 或其子集行聚类，然后按缺失个案所属类来插补不同类的均值。如果在以后统计分析中还需以引入的解释变量和 Y 做分析，那么这种插补方法将在模型中引入自相关，给分析造成障碍。

3.3.3 极大似然估计

极大似然法(the method of maximum likelihood)：在参数θ的可能取值范围内，选取使*L(θ)*达到最大的参数值θ，作为参数θ的估计值。模型已定，参数未知。

通俗讲：利用已知的样本结果信息，反推最具有可能（最大概率）导致这些样本结果出现的模型参数值

求极大似然函数估计值的一般步骤：

（1）写出似然函数；
（2）对似然函数取对数，并整理；
（3）求导数；
（4）解似然方程。
$L(Θ)=L(x_1?,x_2?...x_n?;Θ)=\prod_{n-1}^{n}?f(x_i?;Θ)$
在缺失类型为随机缺失的条件下，假设模型对于完整的样本是正确的，那么通过观测数据的边际分布可以对未知参数进行极大似然估计（Little and Rubin）。这种方法也被称为忽略缺失值的极大似然估计，对于极大似然的参数估计实际中常采用的计算方法是期望值最大化（Expectation Maximization，EM）。该方法比删除个案和单值插补更有吸引力，它一个重要前提：适用于大样本。有效样本的数量足够以保证极大似然估计值是渐近无偏的并服从正态分布。但是这种方法可能会陷入局部极值，收敛速度也不是很快，并且计算很复杂。

3.3.4 多重插补

多值插补的思想来源于贝叶斯估计，认为待插补的值是随机的，它的值来自于已观测到的值。具体实践上通常是估计出待插补的值，然后再加上不同的噪声，形成多组可选插补值。根据某种选择依据，选取最合适的插补值。

对于拟合插补和均值替换等处理缺失值的方法都是单一的插补方法，而多重插补弥补了单一插补的缺陷，它并没有试图去通过模拟值去估计每个缺失值，而是提出缺失数据值的一个随机样本（这些样本可以是不同的模型拟合结果的组合）。这种程序的实施恰当地反映了由于缺失值引起的不确定性，使得统计推断有效。

它是一种基于重复模拟的用于处理缺失值的方法，它从一个包含缺失值的数据集中生成一组数据完整的数据集（即不包含缺失值的数据集，通常是3-10个）。每个完整数据集都是通过对原始数据中的缺失数据进行插补而生成的。在每个完整的数据集上引用标准的统计方法，最后，把这些单独的分析结果整合为一组结果。

多重插补方法分为三个步骤：

（1）为每个空值产生一套可能的插补值，这些值反映了无响应模型的不确定性；每个值都可以被用来插补数据集中的缺失值，产生若干个完整数据集合。

（2）每个插补数据集合都用针对完整数据集的统计方法进行统计分析。

（3）对来自各个插补数据集的结果，根据评分函数进行选择，产生最终的插补值。

在处理缺失值时，可以通过链式方程的多重插补（MICE，Multiple Imputation by Chained Equations）估算缺失值，从技术上讲，任何能够推理的预测模型都可以用于 MICE

3.3.5 插值法

插值法：从已知点近似计算未知点的近似计算方法，即构造一个多项式函数，使其通过所有已知点，然后用求得的函数预测位置点。

我们常用的几种插值法:

线性插值
对一直的值求出线性方程，通过接触的线性方程得到缺失值。
多项式插值
多项式插值是利用已知的数据拟合出一个多项式，使得现有的数据满足这个多项式，再利用多项式求解缺失值。常见多项式插值有拉格朗日插值和牛顿插值。
样条插值
以可变样条做出一条进过一系列点的光滑曲线的插值方法。插值样条由一些多项式组成，每个多项式都由相邻两个数据点决定，这样可以保证两个相邻多项式及其倒数在连接处连续。

我们这里具体解释与实现一下线性插值:

通过两点（x0，y0）,（x1，y1）估计中间点的值，假设 y=f(x) 是一条直线，通过已知的两点来计算函数f(x),然后只要知道x就能求出y，以此方法来估计缺失值。当然我们也可以假设 f(x) 不是直线，而是其他函数。

设函数 y=f(x) 在两点（x0,x1）上的值分别为（y0,y1），求多项式
$y=\varphi(x)=a_0+a_1x$
使满足
$\varphi_1(x_0)=y_0,\varphi_2(x_1)=y_1$
由解析几何可知
$y=\varphi_1(x)=y_0+\frac{y_1-y_0}{x_1-x_0}(x-x_0)$
称
$\frac{f(x_j)-f(x_i)}{x_j-x_i}$
为 f(x) 在 (xi,xj) 处的一阶均差，记以 f(xi,xj)。于是，得
$\varphi_1(x)=f(x_0)+f(x_0,x_1)(x-x_0)$
如果按照 y0,y1y_0,y_1y0,y1 整理，则
$\varphi_1(x)=\frac{x-x_1}{x_0-x_1}y_0+\frac{x-x_0}{x_1-x_0}y_1$
pandas 其实自带一个很强大的插值函数：interpolate。

可以用在 DataFrame 对象上，也可以用在 Series 对象上。

函数构成：

DataFrame.interpolate(method=‘linear’, axis=0, limit=None, inplace=False, limit_direction=None, limit_area=None, downcast=None, **kwargs)

参数说明：

method ： str，默认为 ‘linear’ 使用插值方法。可用的插值方法：
‘linear‘： 忽略索引，线性等距插值。这是 MultiIndexes 支持的唯一方法。
‘time’: 在以天或者更高频率的数据上插入给定的时间间隔长度数据。
‘index’, ‘values’: 使用索引的实际数值。
‘pad’: 使用现有值填写 NaN。
‘nearest’, ‘zero’, ‘slinear’, ‘quadratic’, ‘cubic’, ‘spline’, ‘barycentric’, ‘polynomial’: 传递给 scipy.interpolate.interp1d。这些方法使用索引的数值。‘polynomial’ 和 ‘spline’ 都要求您还指定一个顺序（int），例如，df.interpolate(method=‘polynomial’, order=5)
‘krogh’，‘piecewise_polynomial’，‘spline’，‘pchip’，‘akima’: 包括类似名称的SciPy 插值方法。
‘from_derivatives’: 指 scipy.interpolate.BPoly.from_derivatives, 它替换了 scipy 0.18中的 ’piecewise_polynomial’ 插值方法。
axis ： {0或’index’，1或’columns’，None}，默认为 None；沿轴进行 interpolate。
limit： int；要填充的连续 NaN 的最大数量。必须大于0。
inplace ： bool，默认为 False；如果可以，更新现有数据。
limit_direction ： {‘forward’，‘backward’，‘both’}，默认为 ’forward’；如果指定了限制，则将沿该方向填充连续的 NaN。
limit_area ： {None, ‘inside’, ‘outside’}, 默认为 None；如果指定了限制，则连续的NaN 将填充此限制。'None': 无填充限制。
‘inside’: 仅填充有效值包围的 NaN。
‘outside’: 仅在有效值之外填充 NaN。

【练习】使用interpolate()线性方法填充缺失值

# 使用interpolate()线性方法填充缺失值
import pandas as pd
import numpy as np
data = np.array(
        [[1.231350, 0.550559, 2.200651],
        [np.nan, np.nan, np.nan],
        [0.751952, 2.058747, np.nan],
        [1.317950, 1.353098, np.nan],
        [0.729729, 0.965534, 0.770969]]
)
print("原始数据：")
df = pd.DataFrame(data=data, index=list('01234'), columns=list('ABC'))
print(df)
print("填充缺失值后的数据：")
df1 = df.interpolate()
print(df1)

运行结果

原始数据：
          A         B         C
0  1.231350  0.550559  2.200651
1       NaN       NaN       NaN
2  0.751952  2.058747       NaN
3  1.317950  1.353098       NaN
4  0.729729  0.965534  0.770969
填充缺失值后的数据：
          A         B         C
0  1.231350  0.550559  2.200651
1  0.991651  1.304653  1.843231
2  0.751952  2.058747  1.485810
3  1.317950  1.353098  1.128389
4  0.729729  0.965534  0.770969

3.3.6 模型填充

【练习】使用随机森林回归 RandomForestRegressor填补缺失值

训练的数据：最后一列有四个值需要使用随机森林回归训练出来

12,   10000 ,  50,  2.0
34,   10000 ,  43 , 4.0
23,    5000,   34,  7.0
45 ,   5002  , 40,  4.0
34,   40000 ,  25 , 5.0
23,   50000   ,25 ,NaN
12 ,   8000  , 45 ,NaN
2   , 5000  , 32  ,NaN
3    ,3000,   12  ,NaN

运行以下代码：

# 使用随机森林回归填补缺失值
import pandas as pd
from sklearn.ensemble import RandomForestRegressor  # 导入随机森林模块
file = "3_3.csv"
df = pd.read_csv(file, header=0, names=("Country", "Income", "Age", "填充列"))
print("未处理前读取的数据：\n", type(df), '\n', df)
df_full = df.drop(labels="填充列", axis=1)
# 数据分类
print("不含缺失值的其他列:\n", df_full)
df_nan = df.loc[:, "填充列"]
print("含缺失值的列：\n", df_nan)

print('-'*50)
# 将数据分成两部分：测试集和训练集进行训练
print("区别测试集与训练集：\n不含缺失值的行作为训练集\n含缺失值的行作为测试集")
print("-"*50)
y_train = df_nan[df_nan.notnull()]  # 含缺失值的列中不是空值的行
y_test = df_nan[df_nan.isnull()]  # 含空值的列中是空值的行
x_train = df_full.iloc[y_train.index, :]  # 不含缺失值的其他列中与
x_test = df_full.iloc[y_test.index, :]
print("含缺失值的列中的训练集\n", y_train)
print("含缺失值的列中的测试集\n", y_test)
print("不含缺失值的列中的训练集\n", x_train)
print("不含缺失值的列中的测试集\n", x_test)
print("实例化，用随机森林回归来填补缺失值：")
rfc = RandomForestRegressor(n_estimators=100)
rfc = rfc.fit(x_train, y_train)
y_predict = rfc.predict(x_test)
print(y_predict)
print("将结果填补到我们原来的数据表中：")
df_nan[df_nan.isnull()] = y_predict
print(df_nan)
print("填充后的数据：")
print(df)

运行结果

未处理前读取的数据：
 <class 'pandas.core.frame.DataFrame'> 
    Country  Income  Age  填充列
0       12   10000   50  2.0
1       34   10000   43  4.0
2       23    5000   34  7.0
3       45    5002   40  4.0
4       34   40000   25  5.0
5       23   50000   25  NaN
6       12    8000   45  NaN
7        2    5000   32  NaN
8        3    3000   12  NaN
不含缺失值的其他列:
    Country  Income  Age
0       12   10000   50
1       34   10000   43
2       23    5000   34
3       45    5002   40
4       34   40000   25
5       23   50000   25
6       12    8000   45
7        2    5000   32
8        3    3000   12
含缺失值的列：
0    2.0
1    4.0
2    7.0
3    4.0
4    5.0
5    NaN
6    NaN
7    NaN
8    NaN
Name: 填充列, dtype: float64
--------------------------------------------------
区别测试集与训练集：
不含缺失值的行作为训练集
含缺失值的行作为测试集
--------------------------------------------------
含缺失值的列中的训练集
 0    2.0
1    4.0
2    7.0
3    4.0
4    5.0
Name: 填充列, dtype: float64
含缺失值的列中的测试集
 5   NaN
6   NaN
7   NaN
8   NaN
Name: 填充列, dtype: float64
不含缺失值的列中的训练集
    Country  Income  Age
0       12   10000   50
1       34   10000   43
2       23    5000   34
3       45    5002   40
4       34   40000   25
不含缺失值的列中的测试集
    Country  Income  Age
5       23   50000   25
6       12    8000   45
7        2    5000   32
8        3    3000   12
实例化，用随机森林回归来填补缺失值：
[5.02 3.6  5.85 5.71]
将结果填补到我们原来的数据表中：
0    2.00
1    4.00
2    7.00
3    4.00
4    5.00
5    5.02
6    3.60
7    5.85
8    5.71
Name: 填充列, dtype: float64
填充后的数据：
   Country  Income  Age   填充列
0       12   10000   50  2.00
1       34   10000   43  4.00
2       23    5000   34  7.00
3       45    5002   40  4.00
4       34   40000   25  5.00
5       23   50000   25  5.02
6       12    8000   45  3.60
7        2    5000   32  5.85
8        3    3000   12  5.71