正文

利用 pandas 进行数据的预处理——离散数据哑编码、连续数据标准化

IP云
IP云V管理员/10 阅读
07/24
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

数据的标准化

数据标准化就是将不同取值范围的数据，在保留各自数据相对大小顺序不变的情况下，整体映射到一个固定的区间中。根据具体的实现方法不同，有的时候会映射到 [ 0 ,1 ]，有时映射到 0 附近的一个较小区间内。

这样做的目的是消除数据不同取值范围带来的干扰。

数据标准化的方法，我在这里介绍两种

  • min-max标准化

min-man 标准化会把结果映射到 0 与 1 之间，下面是映射的公式。

min 是整个样本的最小值，max是整个样本的最大值

  • Z-score标准化

Z-score会把结果映射到 0 附近，并服从标准正态分布（平均值为 0，标准差为1），下面是映射的公式

μ 是样本的平均值，σ 是样本的标准差，这些在python中都有函数支持，不用担心计算的问题。

数据的哑编码

哑编码是处理离散型数据的手段。离散型数据的取值范围是有限的（严格在数学上的定义中，无限但可数也就是 countably infinite 的取值空间也属于离散型，但在实际问题中不会碰到，这里不作考虑），比如说星期几就是一个离散型数据，因为一周只有七天，也就只有七种可能的取值。在处理这样的数据的时候，哑编码会把一列数据转换成多列，有多少中可能的取值就转换成多少列。在刚刚提到的星期几的例子中，哑编码会把这一列数据转换成七列数据。

那具体是如何转换的呢？

还是从星期几的例子开始讲

编号星期几
0星期二
1星期一
2星期五
3星期日
4星期三
5星期六
6星期四
7星期日
8星期二
9星期四

假设我们有这样的十条数据，现在数据除了编号以外只有一个字段——“星期几”。

哑编码会讲这一个字段扩展成七个字段，也就是七列，每一个新的字段代表原来字段的一种取值，现在表格变成了

编号星期几星期一星期二星期三星期四星期五星期六星期日
0星期二       
1星期一       
2星期五       
3星期日       
4星期三       
5星期六       
6星期四       
7星期日       
8星期二       
9星期四       

那如何表示原来的数据呢？很简单，如果编号0的数据是星期一，那么在星期一这个字段上的数值是1，在其他所有字段上都是0，现在数据变成了这样

编号星期一星期二星期三星期四星期五星期六星期日
00 0 00 00
1 00 00 00
20 000  00
30 000 0 0
40 0 00 00
50 00 00 0
60 00 0 00
700 0 00 0
80 10 00 00
90 00 0 00

最后再删去原来的字段，大功告成！

pandas

我们一会儿会用python里的pandas来处理数据，所以这里先简单介绍一下我们一会儿会用到的知识。

  • dataframe

简单的理解，dataframe就是一张二维表，和上面例子中关于星期几的表格完全一样。

我们可以通过行号和列明的方式定位表中的某一个元素，dataframe也是这样。

假设我们有一个变量叫df，它是一个dataframe

df[0] # 访问第0行元素
df['column_name'] # 访问列名为 column_name 的一列数据
df.loc[0,'column_name'] # 访问第0行列名为 column_name 的元素

  • dtype

dtype是 dataframe中每一列的数据类型，常用的有 float32 float64 int32 int16 等等

可以通过 dtypes 或 dtype 访问数据类型

df.dtypes # 所有列的数据类型
df['column_name'].dtype # 列名为 column_name 的数据类型

数据类型可以通过 astype 函数更改

df["column_name"] = df["column_name"].astype(np.int16) # 讲列名为 column_name 的列的数据类型改为 np.int16

数据标准化的代码实现

下面就是代码实现部分了，我会把我写整个代码的思路一点点的剖析开

首先当然是将要用到的包导入了

import pandas as pd
import numpy as np

上面提到了两种实现方式，但为了便于使用，我不想写两个函数，我希望只暴露给用户一个函数，将这两种实现方法融合在一起。

具体来说，就是用一个参数来确定用户本次调用的到底是哪种实现方式，并可以通过给出参数默认值的方式给出默认实现方式。

def normalize(data, columns, function='min-max'):
if function == 'min-max':
return min_max_scalar(data, columns)
elif function == 'standard':
return standard_scalar(data, columns)
else:
raise ValueError("invalid parameter: function must be 'min-max' or 'standard'.")def min_max_scalar(data, columns):
passdef standard_scalar(data, columns):
pass

  • data ： 代表需要处理的数据表格，类型是 dataframe
  • columns ：代表需要处理的列的列明的集合，类型是 list，其中每个元素应该是字符串或是可以转换成字符串
  • function ：具体指定实现方式，默认为 min-max 标准化

整体的思路就是判断一下function的数值，然后调用相应的函数

现在整个函数的框架搭起来了，接下来的就是具体实现 min_max_scalar(data, columns) 和 standard_scalar(data, columns) 两个函数了

先来实现 min_max_scalar(data, columns)

def min_max_scalar(data, columns):
for column in columns:
maxi = max(data[column])
mini = min(data[column])
if maxi == mini:
raise ValueError("invalid parameter value: maximum element equals to minimum element in the '" + column + "' column.")
else:
diff = maxi - mini
data[column] = ( data[column] - mini ) / diff
return data

很简单吧？不过一定要随时记得处理异常，在这种实现方式中，如果数据的最大值最小值相同，就会造成 ZeroDivisionError 这个异常，所以我们单独判断，处理了一下这种情况。

然后我们实现 standard_scalar(data, columns)

def standard_scalar(data, columns):
for column in columns:
std = np.std(data[column])
if std == 0:
raise ValueError("invalid parameter: standard deviation is 0 in the '" + column + "' column.")
else:
mean = sum(data[column]) / len(data[column])
data[column] = ( data[column] - mean ) / std
return data

这里处理了一下标准差为零的异常情况

图省事的同学就可以往下看哑编码部分的代码了，不过，如果你想让你的函数更加 robust，我们还得加入大量的异常处理代码

我们需要做哪些异常处理？

  • 判断 data 的数据类型是否是 dataframe？
  • columns 的数据类型是否是list，或者是否能转换成list？
  • columns 中每个元素是不是字符串，或者是否能转换成字符串？
  • columns 中每个元素代表的列是否真的存在？
  • 如果存在，这个列的数据是数值类型的数据么？
  • function 是一个字符串么？
  • 如果是，那这个字符串是否是 ‘min-max’ 或 ‘standard’ 二者之一么？

直接看代码吧

def normalize(data, columns, function='min-max'):
if type(data) != pd.core.frame.DataFrame:
raise TypeError("invalid parameter: data must be a dataframe.") try:
columns = list(columns)
except TypeError:
raise TypeError("invalid parameter: columns must be a list or can be converted to a list.") try:
for counter in range(len(columns)):
columns[counter] = str(columns[counter])
except TypeError:
raise TypeError("invalid parameter: each column element in columns should be a string or can be converted to a string.") for column in columns:
if column not in data.columns:
raise ValueError("invalid parameter: column '" + column + "' doesn't exist.") is_int = data[column].dtype == np.int8 or data[column].dtype == np.int16 or data[column].dtype == np.int32 or data[column].dtype == np.int64
is_uint = data[column].dtype == np.uint8 or data[column].dtype == np.uint16 or data[column].dtype == np.uint32 or data[column].dtype == np.uint64
is_float = data[column].dtype == np.float16 or data[column].dtype == np.float32 or data[column].dtype == np.float64
if is_int or is_uint or is_float:
data[column] = data[column].astype(np.float64)
else:
raise TypeError("invalid parameter: values in column '" + column + "' should be numbers ") try:
function = str(function)
except TypeError:
raise TypeError("invalid parameter: function must be a string or can be converted to a string.") if function == 'min-max':
return min_max_scalar(data, columns)
elif function == 'standard':
return standard_scalar(data, columns)
else:
raise ValueError("invalid parameter: function must be 'min-max' or 'standard'.")

是不是懵逼了？这异常处理代码写出来比主程序还长 orz~

数据哑编码的代码实现

还是先把大致的框架搭起来

def one_hot_encoder(data, columns):
# 异常处理
pass
# 处理数据

data 和 columns 的含义与上文相同，不再赘述。

这次我们先来处理异常，我们需要考虑

  • 判断 data 的数据类型是否是 dataframe？
  • columns 的数据类型是否是list，或者是否能转换成list？
  • columns 中每个元素是不是字符串，或者是否能转换成字符串？
  • columns 中有没有重复的元素？
  • columns 中每个元素代表的列是否真的存在？
  • columns 中每个元素代表的列的数据是否是字符串，或者是否能转换成字符串？

下面看代码~

def one_hot_encoder(data, columns):
# 异常处理
if type(data) != pd.core.frame.DataFrame:
raise TypeError("invalid parameter: data must be a dataframe.") try:
columns = list(columns)
except TypeError:
raise TypeError("invalid parameter: columns must be a list or can be converted to a list.") try:
for counter in range(len(columns)):
columns[counter] = str(columns[counter])
except TypeError:
raise TypeError("invalid parameter: each element in columns should be a string or can be converted to a string.")
columns = np.unique(columns) # rule out duplicate column name to avoid error for column in columns:
if column not in data.columns:
raise ValueError("invalid parameter: column '" + column + "' doesn't exist.")
try:
data[column] =data[column].astype(str)
except Exception:
raise TypeError("invalid parameter: value in '" + column + "' must be a string or can be converted to a string.") # 处理数据
return help_encoder(data, columns)

我把处理数据的部分写到  help_encoder(data, columns) 函数中了，这里只做调用

接下来就剩下下最后一步，处理数据了，相比于数据标准化，这块的代码稍微复杂一点，需要细心点看。

def help_encoder(data, columns):
for column in columns:
unique_values = np.unique(data[column])
sub_column_names = []
for unique_value in unique_values:
sub_column_names.append(column + '_' + unique_value)
# insert new columns
for sub_column_counter in range(len(sub_column_names)):
data[sub_column_names[sub_column_counter]] = -1
for data_counter in range(len(data)):
data.loc[data_counter, sub_column_names[sub_column_counter]] = int(data[column][data_counter] == unique_values[sub_column_counter])
# remove old columns
del data[column] return data

最后我们测试一下哑编码部分的代码

data = pd.DataFrame([['A'], ['B'], ['C'], ['D'], ['A'], ['E']] ,columns=list('A')) # 创建 dataframe
print('哑编码之前')
print(data)
one_hot_encoder(data, ['A']) #进行哑编码处理
print('哑编码之后')
print(data)

运行结果

哑编码之前
A
0 A
1 B
2 C
3 D
4 A
5 E
哑编码之后
A_A A_B A_C A_D A_E
0 1 0 0 0 0
1 0 1 0 0 0
2 0 0 1 0 0
3 0 0 0 1 0
4 1 0 0 0 0
5 0 0 0 0 1
[Finished in 1.5s]

大功告成！