机器学习—数据清洗总结

需要清洗数据的主要类型：¶

残缺数据、错误数据、重复数据

数据清洗方法：¶

(1)不完整数据：经验推导，平均最大最下，甚至概率估计，或建立回归模型，插值法等 (2)错误值检测，异常点检测，偏差分析，规则库等 (3)重复值，将重复记录合并、清楚

数据清洗的评价标准¶

(1)可信性,可信性包括精确性、完整性、一致性、有效性、唯一性等指标。¶

(1)精确性：描述数据是否与其对应的客观实体的特征相一致。 (2)完整性：描述数据是否存在缺失记录或缺失字段。 (3)一致性：描述同一实体的同一属性的值在不同的系统是否一致。 (4)有效性：描述数据是否满足用户定义的条件或在一定的域值范围内。 (5)唯一性：描述数据是否存在重复记录。

(2) 数据的可用性¶

数据的可用性考察指标主要包括时间性和稳定性。 (1)时间性：描述数据是当前数据还是历史数据。 (2)稳定性：描述数据是否是稳定的，是否在其有效期内。

常见的数据清洗算法（属性清洗算法）空缺值的清洗对于空缺值的清洗可以采取忽略元组，人工填写空缺值，使用一个全局变量填充空缺值，使用属性的平均值、中问值、最大值、最小值或更为复杂的概率统计函数值来填充空缺值。

噪声数据的清洗分箱(Binning)，通过考察属性值的周围值来平滑属性的值。属性值被分布到一些等深或等宽的“箱”中，用箱中属性值的平均值或中值来替换“箱”中的属性值；计算机和人工检查相结合，计算机检测可疑数据，然后对它们进行人工判断；使用简单规则库检测和修正错误；使用不同属性间的约束检测和修正错误；使用外部数据源检测和修正错误。

不一致数据的清洗对于有些事务，所记录的数据可能存在不一致。有些数据不一致，可以使用其他材料人工加以更正。例如，数据输入时的错误可以使用纸上的记录加以更正。知识工程工具

也可以用来检测违反限制的数据。例如，知道属性间的函数依赖，可以查找违反函数依赖的值。此外，数据集成也可能产生数据不一致。

重复数据的清洗目前消除重复记录的基本思想是“排序和合并”，先将数据库中的记录排序，然后通过比较邻近记录是否相似来检测记录是否重复。

消除重复记录的算法主要有：优先队列算法，近邻排序算法(Sorted—Neighborhood Method)，多趟近邻排序(Multi—Pass Sorted—Neighborhood)。

Series对象-类似于数组的对象¶

In [46]:

import pandas as pd
object=pd.Series([2,5,8,9])
print(object)
#结果中包含一列数据和一列标签
print(object.values) #对应的数据值
print(object.index)#标签或索引值
#按自己的想法构建标签
object=pd.Series([2,5,8,9],index=['a','b','c','d'])
print(object)#对序进行运算,保留满足要求的数据
print(object[object>5])
#把Series当成一个字典，使用in进行判断
print('a' in object)
print('8' in object)

0    2
1    5
2    8
3    9
dtype: int64
[2 5 8 9]
RangeIndex(start=0, stop=4, step=1)
a    2
b    5
c    8
d    9
dtype: int64
c    8
d    9
dtype: int64
True
False

In [52]:

#DataFrame数据框，一种数据结构
data={'year':[2000,2001,2002,2003],'income':[3000,3500,4500,6000]}
data=pd.DataFrame(data)
print(data)
#标签重置
data1=pd.DataFrame(data,columns=['year','income','outcome'],index=['a','b','c','d'])
print(data1)

   year  income
0  2000    3000
1  2001    3500
2  2002    4500
3  2003    6000year  income  outcome
a   NaN     NaN      NaN
b   NaN     NaN      NaN
c   NaN     NaN      NaN
d   NaN     NaN      NaN

In [61]:

data1['money']=np.arange(4)
print(data1)
#重建索引
data2=data1.reindex(['a','b','c','d','e'])
print(data2)
#索引删除以及过滤的方法
print(data1.drop(['a']))
print(data1[data1['money']>2])#对DataFrame进行排序data=pd.DataFrame(np.arange(10).reshape((2,5)),index=['c','a'],columns=['one','four','two','three','five'])
print(data)
#默认对行进行排序
print(data.sort_index())#默认对列进行排序
print(data.sort_index(axis=1))

   year  income  outcome  money
a   NaN     NaN      NaN      0
b   NaN     NaN      NaN      1
c   NaN     NaN      NaN      2
d   NaN     NaN      NaN      3year  income  outcome  money
a   NaN     NaN      NaN    0.0
b   NaN     NaN      NaN    1.0
c   NaN     NaN      NaN    2.0
d   NaN     NaN      NaN    3.0
e   NaN     NaN      NaN    NaNyear  income  outcome  money
b   NaN     NaN      NaN      1
c   NaN     NaN      NaN      2
d   NaN     NaN      NaN      3year  income  outcome  money
d   NaN     NaN      NaN      3one  four  two  three  five
c    0     1    2      3     4
a    5     6    7      8     9one  four  two  three  five
a    5     6    7      8     9
c    0     1    2      3     4five  four  one  three  two
c     4     1    0      3    2
a     9     6    5      8    7

汇总及统计描述¶

In [69]:

data=pd.DataFrame(np.arange(10).reshape((2,5)),index=['c','a'],
columns=['one','four','two','three','five'])
print(data)
#统计描述
print("一次性输出多个描述性指标")
print(data.describe())
#对各个指标下的数据求和
print(data.sum())
#对个索引求和
print(data.sum(axis=1))#求各个指标的
print("各指标最小值")
print(data.min())
print("各指标方差var")
print(data.var())
print("各指标或各维度的众数")
print(data.mode())
print("非空元素计算")
print(data.count())

   one  four  two  three  five
c    0     1    2      3     4
a    5     6    7      8     9
一次性输出多个描述性指标one      four       two     three      five
count  2.000000  2.000000  2.000000  2.000000  2.000000
mean   2.500000  3.500000  4.500000  5.500000  6.500000
std    3.535534  3.535534  3.535534  3.535534  3.535534
min    0.000000  1.000000  2.000000  3.000000  4.000000
25%    1.250000  2.250000  3.250000  4.250000  5.250000
50%    2.500000  3.500000  4.500000  5.500000  6.500000
75%    3.750000  4.750000  5.750000  6.750000  7.750000
max    5.000000  6.000000  7.000000  8.000000  9.000000
one       5
four      7
two       9
three    11
five     13
dtype: int64
c    10
a    35
dtype: int64
各指标最小值
one      0
four     1
two      2
three    3
five     4
dtype: int32
各指标方差var
one      12.5
four     12.5
two      12.5
three    12.5
five     12.5
dtype: float64
各指标或各维度的众数one  four  two  three  five
0    0     1    2      3     4
1    5     6    7      8     9
非空元素计算
one      2
four     2
two      2
three    2
five     2
dtype: int64

成员信息统计相关¶

In [79]:

data=pd.Series(['a','a','b','b','b','c','d','d'])
#
print(data.unique())
print(data.isin(['b']))
print(pd.value_counts(data.values,sort=False))#缺失值处理
data=pd.Series(['a','a','b',np.nan,'b','c',np.nan,'d'])
print(data.isnull())
#根据标签对缺失值进行过滤
print(data.dropna())
#用指定的方法填充缺失值
print(data.ffill())
#用0进行填充
print(data.fillna(0))

['a' 'b' 'c' 'd']
0    False
1    False
2     True
3     True
4     True
5    False
6    False
7    False
dtype: bool
c    1
d    2
a    2
b    3
dtype: int64
0    False
1    False
2    False
3     True
4    False
5    False
6     True
7    False
dtype: bool
0    a
1    a
2    b
4    b
5    c
7    d
dtype: object
0    a
1    a
2    b
3    b
4    b
5    c
6    c
7    d
dtype: object
0    a
1    a
2    b
3    0
4    b
5    c
6    0
7    d
dtype: object

数据合并¶

In [17]:

import numpy as np
import pandas as pd
import pandas as pd
import numpy as np
df1 = pd.DataFrame({'key':['b','b','a','c','a','a','b'],'data1': range(7)})
df1

Out[17]:

	key	data1
0	b	0
1	b	1
2	a	2
3	c	3
4	a	4
5	a	5
6	b	6

In [18]:

df2 = pd.DataFrame({'key':['a','b','d'],'data2':range(3)})
df2

Out[18]:

	key	data2
0	a	0
1	b	1
2	d	2

In [16]:

pd.merge(df1,df2)

Out[16]:

	key	data1	data2
0	b	0	1
1	b	1	1
2	b	6	1
3	a	2	0
4	a	4	0
5	a	5	0

In [20]:

#重叠数据合并
data3=pd.DataFrame({'level':['a','b','c','d'],'number':[1,3,5,np.nan]})
data4=pd.DataFrame({'level':['a','b','c','e'],'number2':[2,np.nan,6,10]})
print(data3.combine_first(data4))

  level  number  number2
0     a     1.0      2.0
1     b     3.0      NaN
2     c     5.0      6.0
3     d     NaN     10.0

数据重塑和轴向旋转¶

数据重塑主要使用reshape函数，旋转主要使用unstack和stack两个函数

In [21]:

data=pd.DataFrame(np.arange(12).reshape(3,4),columns=['a','b','c','d'],index=['wang','li','zhang'])
print(data)

       a  b   c   d
wang   0  1   2   3
li     4  5   6   7
zhang  8  9  10  11

In [22]:

#数据旋转
print(data.unstack())

a  wang      0li        4zhang     8
b  wang      1li        5zhang     9
c  wang      2li        6zhang    10
d  wang      3li        7zhang    11
dtype: int32

数据转换¶

In [28]:

#删除重复行数据
data=pd.DataFrame({'a':[1,3,3,4],'b':[1,3,3,5]})
print(data)
print("重复行检测:")
print(data.duplicated())
print("用drop_duplicates去除重复行")
print(data.drop_duplicates())
print("数据替换结果")
print(data.replace(1,2))#第一行全部替换成了2

   a  b
0  1  1
1  3  3
2  3  3
3  4  5
重复行检测:
0    False
1    False
2     True
3    False
dtype: bool
用drop_duplicates去除重复行a  b
0  1  1
1  3  3
3  4  5
数据替换结果a  b
0  2  2
1  3  3
2  3  3
3  4  5

数据分段¶

In [34]:

data=[11,15,18,120,25,26,27,24]
bins=[15,20,25]
print(data)
print(pd.cut(data,bins)) #bins相邻数据给出了段的描述

[11, 15, 18, 120, 25, 26, 27, 24]
[NaN, NaN, (15, 20], NaN, (20, 25], NaN, NaN, (20, 25]]
Categories (2, interval[int64]): [(15, 20] < (20, 25]]

排列和采样¶

In [37]:

data=np.random.permutation(5)
print(data)#5以内的数，随机排序
#对数据进行采样
df=pd.DataFrame(np.arange(12).reshape(4,3))
samp=np.random.permutation(3)
print(df)
print(samp)

[2 0 3 4 1]0   1   2
0  0   1   2
1  3   4   5
2  6   7   8
3  9  10  11
[1 2 0]