pandas数据的归一化¶

归一化方法有两种形式，一种是把数变为（0，1）之间的小数，一种是把有量纲表达式变为无量纲表达式。主要是为了数据处理方便提出来的，把数据映射到0～1范围之内处理。

常见归一化算法

1、min-max标准化（Min-Max Normalization）¶

也称为离差标准化，是对原始数据的线性变换，使结果值映射到[0 - 1]之间。转换函数如下： \( \hat{x} = \frac{x −x_{min}}{x_{max} − x_{min}} \)

其中max为样本数据的最大值，min为样本数据的最小值。这种方法有个缺陷就是当有新数据加入时，可能导致max和min的变化，需要重新定义。

2、Z-score标准化方法¶

这种方法给予原始数据的均值（mean）和标准差（standard deviation）进行数据的标准化。经过处理的数据符合标准正态分布，即均值为0，标准差为1。
转化函数为： \( \hat{x} = \frac{x-\mu}{\sigma} \)

其中 μ 为所有样本数据的均值， \( \sigma \) 为所有样本数据的标准差。该种归一化方式要求原始数据的分布可以近似为高斯分布，否则处理的效果会变差。

pandas归一化方法¶

1、min-max标准化¶

import numpy as np
import pandas as pd

np.random.seed(1)
df = pd.DataFrame(np.random.randn(4, 4) * 4 + 3)
print(df)
"""
          0         1         2         3
0  9.497381  0.552974  0.887313 -1.291874
1  6.461631 -6.206155  9.979247 -0.044828
2  4.276156  2.002518  8.848432 -5.240563
3  1.710331  1.463783  7.535078 -1.399565
"""
df_norm = (df - df.min()) / (df.max() - df.min())
print(df_norm)
"""
          0         1         2         3
0  1.000000  0.823413  0.000000  0.759986
1  0.610154  0.000000  1.000000  1.000000
2  0.329499  1.000000  0.875624  0.000000
3  0.000000  0.934370  0.731172  0.739260
"""
df_norm2=df.apply(lambda x: (x - np.min(x)) / (np.max(x) - np.min(x)))
print(df_norm2)
"""
          0         1         2         3
0  1.000000  0.823413  0.000000  0.759986
1  0.610154  0.000000  1.000000  1.000000
2  0.329499  1.000000  0.875624  0.000000
3  0.000000  0.934370  0.731172  0.739260
"""

2、Z-score标准化方法¶

import numpy as np
import pandas as pd

np.random.seed(1)
df = pd.DataFrame(np.random.randn(4, 4) * 4 + 3)
print(df)
"""
          0         1         2         3
0  9.497381  0.552974  0.887313 -1.291874
1  6.461631 -6.206155  9.979247 -0.044828
2  4.276156  2.002518  8.848432 -5.240563
3  1.710331  1.463783  7.535078 -1.399565
"""
df_norm = (df - df.mean()) / (df.std())
print(df_norm)
"""
          0         1         2         3
0  1.213741  0.287871 -1.454237  0.312166
1  0.295115 -1.481492  0.777218  0.866440
2 -0.366215  0.667324  0.499679 -1.442906
3 -1.142640  0.526297  0.177340  0.264301
"""

df_norm2 = df.apply(lambda x: (x - np.mean(x)) / (np.std(x)))
print(df_norm2)
"""
         0         1         2         3
0  1.401507  0.332405 -1.679208  0.360458
1  0.340769 -1.710680  0.897454  1.000479
2 -0.422869  0.770560  0.576980 -1.666125
3 -1.319407  0.607716  0.204774  0.305188
"""

比较好奇为啥上面df.std()和np.std()算出来的值不一样，估计哪里有点不一样的地方，还需要研究研究。下面做了一个简单的实验，不知道df.std()具体是怎么算的。

import numpy as np
import pandas as pd

data = [(1, 2), (3, 4)]
df = pd.DataFrame(data)
print(df)
"""
   0  1
0  1  2
1  3  4
"""
df_std1 = df.std(axis=0)
print(df_std1)
"""
0    1.414214
1    1.414214
"""
df_std2 = df.apply(lambda x: np.std(x), axis=0)
print(df_std2)
"""
0    1.0
1    1.0
"""

经过后续学习这篇帖子找到了答案：
different-std-in-pandas-vs-numpy

import numpy as np
import pandas as pd

data = [(1, 2), (3, 4)]
df = pd.DataFrame(data)
print(df)
"""
   0  1
0  1  2
1  3  4
"""
df_std1 = df.std(axis=0)
print(df_std1)
"""
0    1.414214
1    1.414214
"""
df_std2 = df.apply(lambda x: np.std(x，ddof=1), axis=0)
print(df_std2)
"""
0    1.414214
1    1.414214
"""

ddof : int, optional
Means Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. By default ddof is zero.
这个是numpy对ddof的解释。

简单点说np.std(）计算的是标准差，df.std()计算的是标准差的无偏估计

pandas 数据归一化以及行删除例程的方法¶

再添加一个归一化和删除例程序的方法

#coding:utf8
import pandas as pd
import numpy as np
from pandas import Series,DataFrame

# 如果有id列，则需先删除id列再进行对应操作，最后再补上
# 统计的时候不需要用到id列,删除的时候需要考虑
# delete row
def row_del(df, num_percent, label_len = 0):
    #print list(df.count(axis=1))
    col_num = len(list(list(df.values)[1])) - label_len # -1为考虑带标签
    if col_num<0:
        print 'Error'
    #print int(col_num*num_percent)
    return df.dropna(axis=0, how='any', thresh=int(col_num*num_percent))

# 如果有字符串类型，则报错
# data normalization -1 to 1
# label_col: 不需考虑的类标，可以为字符串或字符串列表
# 数值类型统一到float64
def data_normalization(df, label_col = []):
    lab_len = len(label_col)
    print label_col
    if lab_len>0:
        df_temp = df.drop(label_col, axis = 1)
        df_lab = df[label_col]
        print df_lab
    else:
        df_temp = df
    max_val = list(df_temp.max(axis=0))
    min_val = list(df_temp.min(axis=0))
    mean_val = list((df_temp.max(axis=0) + df_temp.min(axis=0)) / 2)
    nan_values = df_temp.isnull().values
    row_num = len(list(df_temp.values))
    col_num = len(list(df_temp.values)[1])
    for rn in range(row_num):
        #data_values_r = list(data_values[rn])
        nan_values_r = list(nan_values[rn])
        for cn in range(col_num):
            if nan_values_r[cn] == False:
                df_temp.values[rn][cn] = 2 * (df_temp.values[rn][cn] - mean_val[cn])/(max_val[cn] - min_val[cn])
            else:
                print 'Wrong'
    for index,lab in enumerate(label_col):
        df_temp.insert(index, lab, df_lab[lab])
    return df_temp


# 创建一个带有缺失值的数据框：
df = pd.DataFrame(np.random.randn(5,3), index=list('abcde'), columns=['one','two','three'])
df.ix[1,:-1]=np.nan
df.ix[1:-1,2]=np.nan
df.ix[0,0]=int(1)
df.ix[2,2]='abc'

# 查看一下数据内容：
print '\ndf1'
print df

print row_del(df, 0.8)

print '-------------------------'

df = data_normalization(df, ['two', 'three'])
print df

print df.dtypes

print (type(df.ix[2,2]))

参考资料:
1、https://stackoverflow.com/questions/12525722/normalize-data-in-pandas
2、https://stackoverflow.com/questions/26414913/normalize-columns-of-pandas-data-frame
3、https://en.wikipedia.org/wiki/Unbiased_estimation_of_standard_deviation

凡本网注明"来源：XXX "的文/图/视频等稿件，本网转载出于传递更多信息之目的，并不意味着赞同其观点或证实其内容的真实性。如涉及作品内容、版权和其它问题，请与本网联系，我们将在第一时间删除内容！
作者: 程序员学编程, 夜月xl
来源: https://blog.csdn.net/hjxzb/article/details/78610961 , https://www.jb51.net/article/150521.htm