Skr-Eric的机器学习课堂（一）-- 概述和数据预处理-CSDN博客

本文链接：https://blog.csdn.net/Skr_Eric/article/details/104250435

一、概述

1.什么是机器学习？

人工智能：通过人工的方法，模拟某些人类的智能行为。

机器学习：通过人工的方法，模拟某些人类的学习行为。

自适应，自完善，自发展系统。

定义：一个计算机程序在完成任务T之后，获得经验E，其表现效果为P，如果任务T的性能表现，也就是用以衡量的P，可以随之E的增加而增加，那么这样的程序就可以被称为机器学习系统。

2.为什么需要机器学习？

1)具有机器学习能力的系统具备更好的可维护性。

2)机器学习可以解决那些算法过于复杂甚至没有的算法的问题。

3)利用机器学习发现隐藏在数据中的潜在规则。

3.机器学习的种类

1)有监督学习、无监督学习、半监督学习和强化学习

有监督学习：训练数据中包含已知的输出

无监督学习：训练数据中没有已知的输出，从输入数据自身的特征中识别某种模式

半监督学习：先用无监督学习的方法做类别划分，在通过有监督学习的方法按照标签识别。

强化学习：利用智能体根据奖惩进行取舍，按照趋利避害的原则自我完善。

2)批量学习和在线学习

批量学习：一次性训练，使用中不再继续完善。

在线学习：不断地训练，使用的同时继续完善。

3)基于实例的学习和基于模型的学习

基于实例的学习：历史的可重复性，凭经验。

基于模型的学习：从历史经验中抽象出规则。

4.机器学习的一般流程

获取数据

划分训练集和测试集

选择模型(算法)

验证模型

训练模型

测试模型

使用模型

维护模型

二、数据预处理

一行一样本，一列一特征。

姓名学号年龄身高体重

张三 1 20 1.7 50

李四 2 22 1.75 60

...

1.标准化：将样本矩阵中各列的平均值和标准差统一为0和1。

[a b c]

m=(a+b+c)/3

s=sqrt(((a-m)^2+(b-m)^2+(c-m)^2)/3)

a'=a-m

b'=b-m

c'=c-m

[a' b' c']

m' = (a'+b'+c')/3 = (a+b+c)/3 - m = 0

s' = sqrt((a'^2+b'^2+c'^2)/3) = s

a" = a'/s

b" = b'/s

c" = c'/s

[a" b" c"]

s"=sqrt((a"^2+b"^2+c"^2)/3)

= sqrt((a'^2+b'^2+c'^2)/(3s^2))

= 1

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
import sklearn.preprocessing as sp
raw_samples = np.array([
    [3, -1.5, 2, -5.4],
    [0, 4, -0.3, 2.1],
    [1, 3.3, -1.9, -4.3]])
print(raw_samples)
print(raw_samples.mean(axis=0))
print(raw_samples.std(axis=0))
std_samples = raw_samples.copy()
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))
std_samples = sp.scale(raw_samples)
print(std_samples)
print(std_samples.mean(axis=0))
print(std_samples.std(axis=0))

import sklearn.preprocessing as sp

sp.scale(原始样本矩阵)->标准化样本矩阵

2.范围缩放：是样本矩阵中每一列的最大值和最小值为某个给定值([0, 1])，其它元素线性缩放。

A B C

max min

Ak+b->A' max 1

Bk+b->B'

Ck+b->C' min 0

[A B C] - min

---------------

max - min

mms = sp.MinMaxScaler(feature_range=(0, 1))

mms.fit_transform(原始样本矩阵)->范围缩放后的样本矩阵

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
import sklearn.preprocessing as sp
raw_samples = np.array([
    [3, -1.5, 2, -5.4],
    [0, 4, -0.3, 2.1],
    [1, 3.3, -1.9, -4.3]])
print(raw_samples)
print(raw_samples.min(axis=0))
print(raw_samples.max(axis=0))
mms_samples = raw_samples.copy()
for col in mms_samples.T:
    col -= col.min()
    col /= col.max()
print(mms_samples)
print(mms_samples.min(axis=0))
print(mms_samples.max(axis=0))
mms = sp.MinMaxScaler(feature_range=(0, 1))
mms_samples = mms.fit_transform(raw_samples)
print(mms_samples)
print(mms_samples.min(axis=0))
print(mms_samples.max(axis=0))

3.归一化

Python Java PHP

2016 10 30 10

2017 20 30 5

2018 5 1 0

用样本中的各个特征除以该样本所有特征的绝对值之和，使得处理后的样本矩阵中各行所有列中元素的绝对值之和为1。

sp.normalize(原始样本矩阵, norm='l1')->归一化样本矩阵

l1：l1范数，矢量中各元素绝对值的1次方之和

l2：l2范数，矢量中各元素绝对值的2次方之和

...

lk：lk范数，矢量中各元素绝对值的k次方之和

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
import sklearn.preprocessing as sp
raw_samples = np.array([
    [3, -1.5, 2, -5.4],
    [0, 4, -0.3, 2.1],
    [1, 3.3, -1.9, -4.3]])
print(raw_samples)
print(np.abs(raw_samples).sum(axis=1))
nor_samples = raw_samples.copy()
for row in nor_samples:
    row /= np.abs(row).sum()
print(nor_samples)
print(np.abs(nor_samples).sum(axis=1))
nor_samples = sp.normalize(raw_samples, norm='l1')
print(nor_samples)
print(np.abs(nor_samples).sum(axis=1))

4.二值化

根据一个事先设定的阈值，将样本矩阵中不大于阈值的元素设定为0，大于阈值的元素设定为1。

bin = sp.Binarizer(threshold=阈值)

bin.transform(原始样本矩阵)->二值化样本矩阵

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
import sklearn.preprocessing as sp
raw_samples = np.array([
    [3, -1.5, 2, -5.4],
    [0, 4, -0.3, 2.1],
    [1, 3.3, -1.9, -4.3]])
print(raw_samples)
bin_samples = raw_samples.copy()
bin_samples[bin_samples <= 1.4] = 0
bin_samples[bin_samples > 1.4] = 1
print(bin_samples)
bin = sp.Binarizer(threshold=1.4)
bin_samples = bin.transform(raw_samples)
print(bin_samples)

5.独热编码

1 3 2

7 5 4

1 8 6

7 3 9

1-10 3-100 2-1000

7-01 5-010 4-0100

8-001 6-0010

9-0001

101001000

010100100

100010010

011000001

ohe = sp.OneHotEncoder(sparse=紧缩格式(默认True),

dtype=目标类型)

ohe.fit_transform(原始样本矩阵)->独热编码样本矩阵

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
import sklearn.preprocessing as sp
raw_samples = np.array([
    [1, 3, 2],
    [7, 5, 4],
    [1, 8, 6],
    [7, 3, 9]])
print(raw_samples)
code_tables = []
for col in raw_samples.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_sample in raw_samples:
    ohe_sample = np.array([], dtype=int)
    for i, key in enumerate(raw_sample):
        ohe_sample = np.hstack(
            (ohe_sample, code_tables[i][key]))
    ohe_samples.append(ohe_sample)
ohe_samples = np.array(ohe_samples)
print(ohe_samples)
ohe = sp.OneHotEncoder(sparse=False, dtype=int)
ohe_samples = ohe.fit_transform(raw_samples)
print(ohe_samples)

6.标签编码

将一列字符串形式的特征值，按照字典排序，用每个字符在排序序列中的索引号表示该字符。

lbe = sp.LabelEncoder()

lbe.fit_transform(原始样本矩阵)->标签编码样本矩阵

lbe.inverse_transform(标签编码样本矩阵)->原始样本矩阵

# -*- coding: utf-8 -*-
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', 'audi'])
lbe = sp.LabelEncoder()
lbe_samples = lbe.fit_transform(raw_samples)
print(lbe_samples)
raw_samples = lbe.inverse_transform(lbe_samples)
print(raw_samples)

想要看更多的课程请微信关注SkrEric的编程课堂