机器学习初探---数据预处理

机器学习中对于数的预处理都在sklearn的preprocessing中下面整理了基本的数据预处理方法

均值移除

为了统一样本中不同特征的基准值和分散度，
可以将各个特征的平均值调整为0,标准差调整为1，这个过程为均值移除
实现过程
import sklearn.preprocessing as sp
均值移除后样本 = sp.scale(原始样本)

import sklearn.preprocessing as sp
import numpy as np


def old_operate():
    '''
    采用手动的方法进行均值移除
    :return:
    '''
    raw_smples = np.array([
        [3,-1.5,2,-5.4],
        [0,4,-0.3,2.1],
        [1,3.3,-1.9,-4.3]
    ])
    print(raw_smples)
    print(raw_smples.mean(axis=0))
    print(raw_smples.std(axis= 0))

    std_samples = raw_smples.copy()
    #numpy数组为行有限数组
    for col in std_samples.T:
        col_mean = col.mean()
        col_std = col.std()
        col -= col_mean
        col /= col_std


    print(std_samples)
    print(std_samples.mean(axis=0))
    print(std_samples.std(axis= 0))

def new_opeater():
    '''
    采用接口进行均值移除
    :return:
    '''
    raw_smples = np.array([
        [3,-1.5,2,-5.4],
        [0,4,-0.3,2.1],
        [1,3.3,-1.9,-4.3]
    ])
    #均值移除处理
    std_samples = sp.scale(raw_smples)
    print(std_samples)

if __name__ =="__main__":
    old_operate()
    new_opeater()

范围缩放

目的：统一样本矩阵中不同特征的最大值和最小值范围
实现：
生成缩放器
sklearn.preprocessing.MinMaxScaler(feature_range = 期望最小和最大值)
数据处理
缩放器.fit_transform(原始样本)

def new_opeater():
    '''
    采用接口进行范围缩放
    :return:
    '''
    raw_smples = np.array([
        [3, -1.5, 2, -5.4],
        [0, 4, -0.3, 2.1],
        [1, 3.3, -1.9, -4.3]
    ])
    # 范围缩放处理

    mms = sp.MinMaxScaler(feature_range=(0,1))
    mms_samples = mms.fit_transform(raw_smples)
    print(mms_samples)

if __name__=='__main__':
    old_operate()
    new_opeater()

归一化

目的：
为了用占比表示特征，用每个样本的特征值除以该样本的特征值绝对值之和，
以使每个样本的特征值绝对值之和为1
实现过程
sklearn.preprocessing.normalize(原始样本矩阵,norm='l1')->归一化后的样本矩阵
l1表示l1范数：表示矢量中各元素绝对值之和

import numpy as np
import sklearn.preprocessing as sp


def old_operate():
    '''
    采用手动的方法进行归一化
    :return:
    '''
    raw_smples = np.array([
        [3, -1.5, 2, -5.4],
        [0, 4, -0.3, 2.1],
        [1, 3.3, -1.9, -4.3]
    ])


    nor_samples = raw_smples.copy()
    # numpy数组为行有限数组
    for row in nor_samples:
        row_abs = abs(row).sum()
        row /= row_abs


    print(nor_samples)



def new_opeater():
    '''
    采用接口进行归一化
    :return:
    '''
    raw_smples = np.array([
        [3, -1.5, 2, -5.4],
        [0, 4, -0.3, 2.1],
        [1, 3.3, -1.9, -4.3]
    ])
    # 范围缩放处理
    nor_samples = sp.normalize(raw_smples,norm='l1')
    print(nor_samples)

if __name__=='__main__':
    old_operate()
    new_opeater()

二值化

目的：
用0,1来表示样本矩阵中对于某个给定阈值高于
或者低于它的元素,二值转化不可逆
实现过程
Binarizer(threshold = 阈值)-->生成一个二值化器
transform(原始样本)--->用生成的二值化器来二值化样本矩阵

import numpy as np
import sklearn.preprocessing as sp


def old_operate():
    '''
    采用手动的方法进行二值化处理
    :return:
    '''
    raw_smples = np.array([
        [3, -1.5, 2, -5.4],
        [0, 4, -0.3, 2.1],
        [1, 3.3, -1.9, -4.3]
    ])

    #二值化处理
    bin_samples = raw_smples.copy()
    bin_samples[bin_samples <= 1.4] = 0
    bin_samples[bin_samples > 1.4] = 1
    print(bin_samples)



def new_opeater():
    '''
    采用接口进行二值化处理
    :return:
    '''
    raw_smples = np.array([
        [3, -1.5, 2, -5.4],
        [0, 4, -0.3, 2.1],
        [1, 3.3, -1.9, -4.3]
    ])
    # 二值化处理
    bin_fiter =sp.Binarizer(threshold= 1.4)
    bin_samples = bin_fiter.transform(raw_smples)
    print(bin_samples)

if __name__=='__main__':
    old_operate()
    new_opeater()

独热编码

目的：对于每列特征的特征值进行二进制编码，
编码使得一组二进制数表示本类特征的一种值
实现：
 sp.OneHotEncoder(sparse=)
 sparse:表示是否采用压缩格式，缺省默认值为true,表示采用压缩格式
 dtype = 元素类型
 返回：独热编码器
  fit_transform(原始样本矩阵)－－－>返回独热编码后的样本,同时在内部构建编码表,
  transform(原始样本矩阵)----->使用原来编码器中的编码表，返回独热编码后的样本

import numpy as np
import sklearn.preprocessing as sp


def old_operate():
    '''
    采用手动的方法进行独热处理
    :return:
    '''
    raw_smples = np.array([
        [1, 3, 2],
        [7, 5, 4],
        [1, 8, 6],
        [7, 3, 9]
    ])

    #创建独热字典了列表
    code_tables = []
    #将每列的特征值统计为独热字典的键值
    for col in raw_smples.T:
        code_table = {} #每列的独热字典
        for val in col:
            code_table[val] = None
        code_tables.append(code_table)
    #给每个特征的独热字典填充编码值
    for code_table in code_tables:
        size = len(code_table)
        for one,key in enumerate(sorted(code_table.keys())):
            code_table[key]=np.zeros(shape=size,dtype=int)
            code_table[key][one] = 1
    ohe_samples = []
    #拼接生成新的独热矩阵样本
    for raw_smple in raw_smples:
        ohe_sample = np.array([],dtype=int)
        for i,key in enumerate(raw_smple):
           ohe_sample =  np.hstack((ohe_sample,code_tables[i][key]))
        ohe_samples.append(ohe_sample)
    ohe_samples = np.array(ohe_samples)



    print(ohe_samples)



def new_opeater():
    '''
    采用接口进行独热处理
    :return:
    '''
    raw_smples = np.array([
        [1, 3, 2],
        [7, 5, 4],
        [1, 8, 6],
        [7, 3, 9]
    ])
    # 独热处理
    ohe = sp.OneHotEncoder(sparse= False,dtype=int)
    ohe_samples = ohe.fit_transform(raw_smples)
    #添加新的样本，对新样本进行性编码
    #注：sklearn中含有fit的函数一般有重新训练的意思
    new_sample = np.array([1,5,6])
    ohe_sample = ohe.transform([new_sample])
    print(ohe_samples)

if __name__=='__main__':
    old_operate()
    new_opeater()

标签编码

目的：将字符形式的特征值映射为整数
实现：
fit_transform(原始样本矩阵)---->编码样本矩阵，构建编码字典
transform(原始样本矩阵)---->编码样本矩阵，使用编码字典
inverse_transform(编码样本矩阵)

from __future__ import unicode_literals
import numpy as np
import sklearn.preprocessing as sp
raw_samples = np.array([
    'audi', 'ford', 'audi', 'toyota', 'ford',
    'bmw', 'toyota', 'ford', 'audi'])
print(raw_samples)
lbe = sp.LabelEncoder()
lbe_samples = lbe.fit_transform(raw_samples)
print(lbe_samples)
raw_samples = lbe.inverse_transform(lbe_samples)
print(raw_samples)