介紹一些常見的資料處理操作及程式碼實現

內容包括：
資料記憶體縮小
重複值處理
缺失值處理
異常值處理
標準化
特徵二值化
多項式特徵構建
類別特徵編碼

1.資料轉存，縮小記憶體

def reduce_mem_usage(df):
    """ iterate through all the columns of a dataframe and modify the data type
        to reduce memory usage.        
    """
    start_mem = df.memory_usage().sum() 
    print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))
    for col in df.columns:
        col_type = df[col].dtype
        
        if col_type != object:
            c_min = df[col].min()
            c_max = df[col].max()
            if str(col_type)[:3] == 'int':
                if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
                    df[col] = df[col].astype(np.int8)
                elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
                    df[col] = df[col].astype(np.int16)
                elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
                    df[col] = df[col].astype(np.int32)
                elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:
                    df[col] = df[col].astype(np.int64)  
            else:
                if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:
                    df[col] = df[col].astype(np.float16)
                elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
                    df[col] = df[col].astype(np.float32)
                else:
                    df[col] = df[col].astype(np.float64)
        else:
            df[col] = df[col].astype('category')
	end_mem = df.memory_usage().sum() 
    	print('Memory usage after optimization is: {:.2f} MB'.format(end_mem))
    	print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem))
    	return df
    
 sample_feature = reduce_mem_usage(pd.read_csv('data_for_tree.csv'))

# 資料清洗常用操作
# 重複值處理
print('存在' if any(train_data.duplicated()) else '不存在', '重複觀測值')
train_data.drop_duplicates()
#缺失值處理
print('存在' if any(train_data.isnull()) else '不存在', '缺失值')
train_data.dropna()  # 直接刪除記錄
train_data.fillna(method='ffill')  # 前向填充
train_data.fillna(method='bfill')  # 後向填充
train_data.fillna(value=2)  # 值填充
train_data.fillna(value={'sepal length (cm)':train_data['sepal length (cm)'].mean()})  # 統計值填充
train_data['Fare'] = train_data[['Fare']].fillna(train_data.groupby('Pclass').transform(np.mean))#使用其他特徵groupby後的均值進行填充
# 缺失值插補
x = [[np.nan, '1', '3'], [np.nan, '3', '5']]
imputer = preprocessing.Imputer(missing_values='NaN', strategy='mean', axis=1)
y = imputer.fit_transform(x)


# 異常值處理
data1 = train_data['sepal length (cm)']
# 標準差監測
xmean = data1.mean()
xstd = data1.std()
print('存在' if any(data1>xmean+2*xstd) else '不存在', '上限異常值')
print('存在' if any(data1<xmean-2*xstd) else '不存在', '下限異常值')
# 箱線圖監測
q1 = data1.quantile(0.25)
q3 = data1.quantile(0.75)
up = q3+1.5*(q3-q1)
dw = q1-1.5*(q3-q1)
print('存在' if any(data1> up) else '不存在', '上限異常值')
print('存在' if any(data1< dw) else '不存在', '下限異常值')
data1[data1>up] = data1[data1<up].max()
data1[data1<dw] = data1[data1>dw].min()


標準化
# 0-1標準化
X_train_minmax = preprocessing.minmax_scale(train_data, feature_range=(0, 1), axis=0, copy=True)  # 直接用標準化函式
min_max_scaler = preprocessing.MinMaxScaler()  # 也可以用標準化類，然後呼叫方法
X_train_minmax2 = min_max_scaler.fit_transform(train_data)
# z-score標準化
X_train_zs = preprocessing.scale(train_data, axis=0, with_mean=True, with_std=True, copy=True)  # 直接用標準化函式
zs_scaler = preprocessing.StandardScaler()  # 也可以用標準化類，然後呼叫方法
X_train_zs2 = zs_scaler.fit_transform(train_data)
# 歸一化處理
X_train_norm = preprocessing.normalize(train_data, norm='l2', axis=1)  # 直接用標準化函式
normalizer = preprocessing.Normalizer()  # 也可以用標準化類，然後呼叫方法
X_train_norm2 = normalizer.fit_transform(train_data)


# 資料的縮放比例為絕對值最大值，並保留正負號，即在區間[-1, 1]內。
#唯一可用於稀疏資料scipy.sparse的標準化
X_train_ma = preprocessing.maxabs_scale(X, axis=0, copy=True)
# 通過 Interquartile Range(IQR) 標準化資料，即四分之一和四分之三分位點之間
X_train_rb = preprocessing.robust_scale(train_data, axis=0,
                                        with_centering=True, with_scaling=True, copy=True)
# 二值化
# 按照閾值threshold將資料轉換成成0-1,小於等於threshold為 0
X_train_binary = preprocessing.binarize(train_data, threshold=0, copy=True) 

特徵二值化，
給定特徵將特徵轉化為0/1

binarizer = sklearn.preprocessing.Binarizer(threshold=1.1)
binarizer.transform(X)

多項式特徵構建：

poly = sklearn.preprocessing.PolynomialFeatures(2)
poly.fit_transform(X)

對於類別特徵需要進行編碼
常見編碼方式有LabelEncoder、OneHotEncoder，以及針對高數量類別特徵編碼-- 均值編碼

其中：LabelEncoder能夠接收不規則的特徵列，並將其轉化為從到的整數值（假設一共有種不同的類別）；OneHotEncoder則能通過啞編碼，製作出一個m*n的稀疏矩陣（假設資料一共有m行，具體的輸出矩陣格式是否稀疏可以由sparse引數控制）
還有針對高數量類別特徵編碼-- 均值編碼

from sklearn.preprocessing import OneHotEncoder, LabelEncoder
import numpy as np
import pandas as pd
le = LabelEncoder()
data_df['street_address'] = le.fit_transform(data_df['street_address'])

ohe = OneHotEncoder(n_values='auto', categorical_features='all',dtype=np.float64, sparse=True, handle_unknown='error')
one_hot_matrix = ohe.fit_transform(data_df['street_address'])

對於均值編碼實現，可參考https://blog.csdn.net/juzexia/article/details/78581462

參考：
https://blog.csdn.net/Trisyp/article/details/89371094
https://blog.csdn.net/RivenDong/article/details/100120333?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task