一、概述
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的编程课堂