机器学习

1.概述

1. 什么是机器学习？
   人工智能 : 通过人工的方法，模拟某些人类的智能行为。
   机器学习 : 通过人工的方法，模拟某些人类的学习行为。
   它是自适应，自完善，自发展系统。
   我们可以这样定义：一个计算机程序在完成任务T之后，获得经验E，其表现效果为P，如果任务T的性能表现，也就是用以衡量的P，可以随着E的增加而增加，那么这样的程序就可以被称之为机器学习系统。

2. 为什么需要机器学习？
   1）具有极其学习能力的系统具备更好的可维护性。
   2）机器学习可以解决那些算法过于复杂甚至没有的算法问题。
   3）利用机器学习发现隐藏在数据中的潜在规则。

3. 机器学习的种类
   1）有监督学习、无监督学习、半监督学习和强化学习
   有监督学习：训练数据中包含已知的输出。
   无监督学习：训练数据中没有已知的输出，从输入数据自身的特征中识别某种模式。
   半监督学习：先用无监督学习的方法做类别的划分，再通过有监督学习的方法按照标签识别。
   强化学习：利用智能体根据奖惩进行取舍，按照趋利避害的原则自我完善。
   2）批量学习和在线学习
   批量学习：一次性训练，使用中不再继续完善。
   在线学习：不断地训练，使用的同时继续完善。
   3）基于实例的学习和基于模型的学习
   基于实例的学习：历史的可重复性，凭经验。
   基于模型的学习：从历史经验中抽象出规则。

4. 机器学习的一般流程
   获取数据
   划分训练集和测试集
   选择模型(算法)
   验证模型
   训练模型
   测试模型
   使用模型
   维护模型

2.数据预处理

1. 标准化
   标准化：将样本矩阵中各列的平均值和标准差统一为0和1。
   假设现有数组[a b c]
   平均值为m
   m = (a + b + c) / 3
   标准差为s
   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’
   m’ = (a’ + b’ + c’) / 3 = (a + b + c) / 3 - m = 0
   标准差为s’
   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) / (3 * s ^ 2))
   = 1
   代码中我们怎么表示呢？

import sklearn.preprocessing as sp

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

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))     # 看标准差是否为1
#以上为手动数学计算
#以下使用sklearn
std_samples = sp.scale(raw_samples)
print(std_samples)
print(std_samples.mean(axis=0))    # 看平均值是否为零
print(std_samples.std(axis=0))     # 看标准差是否为1

[[ 1.33630621 -1.40451644  1.29110641 -0.86687558]
 [-1.06904497  0.84543708 -0.14577008  1.40111286]
 [-0.26726124  0.55907936 -1.14533633 -0.53423728]]
[ 5.55111512e-17 -1.11022302e-16 -7.40148683e-17 -7.40148683e-17]
[1. 1. 1. 1.]

2. 范围缩减
   范围缩放：是样本矩阵中每一列的最大值和最小值为某个给定值([0, 1])，其它元素线性缩放。
   现有[A B C]
   假设A为max
   C为min
   Ak + b -> A’ 为max 1
   Bk + b -> B’
   Ck + b -> C’ 为min 0
   [A B C] - min / max - min
   -> [1, B-min/max-min,0]

# -*- 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.fit_transform(原始样本矩阵)->范围缩放后的样本矩阵

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))

[[1.         0.         1.         0.        ]
 [0.         1.         0.41025641 1.        ]
 [0.33333333 0.87272727 0.         0.14666667]]
这是新数组列最小值： [0. 0. 0. 0.]
这是新数组列最大值： [1. 1. 1. 1.]

3. 归一化
   归一化：用样本中的各个特征除以该样本所有特征的绝对值之和，使得处理后的样本矩阵中各行所有列中元素的绝对值之和为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(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))	#各行绝对值之和

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

nor_samples = sp.normalize(raw_samples, norm='l1')
print(nor_samples)
print(np.abs(nor_samples).sum(axis=1))	#各行绝对值之和

[[ 0.25210084 -0.12605042  0.16806723 -0.45378151]
 [ 0.          0.625      -0.046875    0.328125  ]
 [ 0.0952381   0.31428571 -0.18095238 -0.40952381]]
[1. 1. 1.]

4. 二值化
   二值化：根据一个事先设定的阈值，将样本矩阵中不大于阈值的元素设定为0，大于阈值的元素设定为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)
bin_samples = raw_samples.copy()
bin_samples[bin_samples <= 1.4] = 0		#设置数组小于1.4的值为0
bin_samples[bin_samples > 1.4] = 1		#设置数组大于1.4的值为1
print(bin_samples)

bin = sp.Binarizer(threshold=阈值)
bin.transform(原始样本矩阵)->二值化样本矩阵

bin = sp.Binarizer(threshold=1.4)
bin_samples = bin.transform(raw_samples)
print(bin_samples)

[[1. 0. 1. 0.]
 [0. 1. 0. 1.]
 [0. 1. 0. 0.]]

5. 独热编码

1 3 2
7 5 4
1 8 6
7 3 9
第一列有两个元素 1,7
我们可以用10来表示1
01来表示7即
1 ----> 10
7 ----> 01

第二列有三个元素 3, 5, 8
我们可以用100来表示3
010来表示5
001来表示8即
3 ----> 100
5 ----> 010
5 ----> 001

第三列有四个元素 2, 4, 6, 9
我们可以用1000来表示2
0100来表示4
0010来表示6
0001来表示9即
2 ----> 1000
4 ----> 0100
6 ----> 0010
9 ----> 0001

我们可以这样表示源数组

101001000
010100100
100010010
011000001

# -*- 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=紧缩格式(默认True),dtype=目标类型)
ohe.fit_transform(原始样本矩阵)->独热编码样本矩阵

ohe = sp.OneHotEncoder(sparse=False, dtype=int)
ohe_samples = ohe.fit_transform(raw_samples)
print(ohe_samples)

[[1 0 1 0 0 1 0 0 0]
 [0 1 0 1 0 0 1 0 0]
 [1 0 0 0 1 0 0 1 0]
 [0 1 1 0 0 0 0 0 1]]

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)

[0 2 0 3 2 1 3 0]
['audi' 'ford' 'audi' 'toyota' 'ford' 'bmw' 'toyota' 'audi']

最后

以上就是轻松衬衫为你收集整理的机器学习的全部内容，希望文章能够帮你解决机器学习所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。