机械学习基础


郑捷《机器学习算法原理与编制程序实践》学习笔记(第1章 机器学习基础)


机械学习对象是指包括一组特征的行向量,也叫做特征向量

相似而言,3个对象应视为完全的民用,代表切实中有意义的事物,不可能随便拆分。

对此文本类数据集,需求首先生成词袋列表,再将各样词出现的词频数值化。

例如:

  1. My dog ate my homework.
  2. My cat ate the sandwich.
  3. A dolphin ate the homework.

生成词袋列表:
s = [a, ate, dolphin, dog, homework, my, sandwich, the],该列表记录了上述文件中冒出的每一种不另行的词。
各段文字依据变化的词袋列表转化为指标,其维度正是词袋列表的长短。向量化后的文件称为词向量。其中\(0\)表示词袋中对应的词未现身在文书中;
\(1\)表示该词出现在文书中一回;假如数次面世,则拉长。

import copy

text1 = 'My dog ate my homework'
text2 = 'My cat ate the sandwich'
text3 = 'A dolphin ate the homework'
t1 = text1.split(' ')
t2 = text2.split(' ')
t3 = text3.split(' ')
d = list(set(t1 + t2 + t3))

def f(t):
    c = copy.deepcopy(d)
    for x in range(len(c)):
        if c[x] in t:
            c[x] = 1
        else:
            c[x] = 0
    return c

c1 = f(t1)
c2 = f(t2)
c3 = f(t3)

上面的c1、c2、c3 正是咱们须要的词向量。

c1

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

c2

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

c3

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

矩阵

import numpy as  np

a = np.array([1, 2, 34, 5])
b = copy.deepcopy(a)    # 深复制

b[0] = 9
b

array([ 9,  2, 34,  5])

a

array([ 1,  2, 34,  5])

c = a           # 浅复制
c[0] = 9
c

array([ 9,  2, 34,  5])

a

array([ 9,  2, 34,  5])

机器学习中的对象是被特征化的客观事物,而表是包容这个目的的容器。换言之,对象是表中的要素,表是对象的集合。但这一个集合有点特殊,即表中的每种对象都有同样的特色和维度,对象对于每一种特征都有必然的取值。

  1. 矩阵是颇具同样特征和维度的目的的集结,表现为一张二维数据表;
  2. 二个对象表示为矩阵中的一行,三个特色表示为矩阵中的一列,各样特征都有数值型取值。
  3. 天性相同、取值相异的指标集合所构成的矩阵,使得对象时期既相互独立,又彼此关联。
  4. 由特征列的取值范围有所结成的矩阵空间应具备完整性,即能够反映出事物的长空格局或转移。

至于第壹点:比如动物的种属和植物的种属是互为独立的,不过只要放置一张表中,大家利用一种特征向量来度量它们,比如种属、重量、颜色等,那样便给双方建立了关系。

分类聚类能够当作依据目的特征的相似性与差别性,对矩阵空间的一种划分。

预测回归能够看做依据指标在某种种类(时间)上的相关性,表现为特征取值变化的一种倾向。

分拣、聚类和回归是机械学习最基本的核心。通过矩阵,可以营造客观事物的多维度数学模型,并经过规范可能率分布、梯度、神经网络、协方差等运算格局,多角度地认识和分析事物。矩阵的用途首要有\(3\)点:

  1. 解线性方程组,比如二维矩阵能够清楚为3个平面直角坐标系内的点集,通过计算点与点时期的离开,实现聚类、分类和预测,类似的演算能够扩充到多维;
  2. 方程降次,也正是行使矩阵的2次型,通过升维将线性不可分的数据集映射到高维中,转化为线性可分的意况,那是援救向量机的基本原理之一。
  3. 变换,通过特征值和特征向量达成维度约简,简化类似图片那种高维数据集的演算,主成分分析利用的正是那几个规律。

矢量化编制程序和GPU计算

根据矩阵的算法都以针对向量的,那里也号称矢量。处理依照矩阵的主题运算,正是矢量化编制程序。
矢量化编制程序的八个主要特色是足以一贯将数学公式转化为对应的程序代码,相当的大地惠及了程序的阅读和调节,使得复杂数学公式的兑现变得不难和惠及。

mylist = [1, 2, 3, 4, 5]
a = 10
mymatrix = np.mat(mylist)
a * mymatrix

matrix([[10, 20, 30, 40, 50]])

矩阵的初阶化

myZero = np.zeros([3, 5])       # 全0矩阵
myZero

array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])

myOnes = np.ones([3, 5])      # 全1矩阵
myOnes

array([[ 1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.]])

myRand = np.random.rand(3, 4)   # 0~1 随机数矩阵
myRand

array([[ 0.59393901,  0.49917793,  0.85212989,  0.58955052],
       [ 0.01495929,  0.77227977,  0.36688307,  0.02204415],
       [ 0.92013148,  0.38079991,  0.36128693,  0.22103762]])

myEye = np.eye(3)  # 单位阵
myEye

array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])

矩阵的因素运算

在要素级别的演算。

  • \((A + B)_{i, j} = (A)_{i,j} +
    (B)_{i,j}\)

    myOnes = np.ones([3, 3])
    myEye = np.eye(3)
    myEye + myOnes

    array([[ 2., 1., 1.],

       [ 1.,  2.,  1.],
       [ 1.,  1.,  2.]])
    

    myEye – myOnes

    array([[ 0., -1., -1.],

       [-1.,  0., -1.],
       [-1., -1.,  0.]])
    
  • 矩阵数乘
    \((cA)_{i,j} = c \cdot A_{i,
    j}\)

    mymatrix = np.mat([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    a = 10
    a * mymatrix

    matrix([[10, 20, 30],

        [40, 50, 60],
        [70, 80, 90]])
    
  • 矩阵全部因素求和
    \(sum(A) = \sum_{i=1}^{m}
    \sum_{j=1}^{n} {A_{i,j}}\)

    mymatrix = np.mat([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    np.sum(mymatrix)

    45

  • 矩阵各因素的积
    \((A\times B)_{i,j} = A_{i,j} \times
    B_{i,j}\)

    A =np.mat([[1, 2, 3], [4, 5, 6], [6, 7, 9]])
    B = 1.5 * np.ones([3, 3])
    np.multiply(A, B)

    matrix([[ 1.5, 3. , 4.5],

        [  6. ,   7.5,   9. ],
        [  9. ,  10.5,  13.5]])
    
  • 矩阵各要素的\(n\)次幂
    \(A_{i,j}^2 = A_{i,j} \times
    A_{i,j}\)

    A = np.mat([[1, 2, 3], [4, 5, 6], [6, 7, 9]])
    np.power(A, 2)

    matrix([[ 1, 4, 9],

        [16, 25, 36],
        [36, 49, 81]], dtype=int32)
    

矩阵的乘法

\([A, B]_{i,j} = \sum_{r=1}^{n}{A_{i,r}
B_{r, j}}\)

A = np.mat([[1, 2, 3], [4, 5, 6], [6, 7, 9]])
B = np.mat([[1], [2], [3]])

A * B

matrix([[14],
        [32],
        [47]])

矩阵的转置
\((A)^{T}_{i,j} = A_{j,i}\)

A = np.mat([[1, 2, 3], [4, 5, 6], [6, 7, 9]])
A.T

matrix([[1, 4, 6],
        [2, 5, 7],
        [3, 6, 9]])

A.transpose()

matrix([[1, 4, 6],
        [2, 5, 7],
        [3, 6, 9]])

行列数、切片、复制、比较

A = np.mat([[1, 2, 3], [4, 5, 6], [6, 7, 9]])
[m, n] = np.shape(A) # 矩阵的行列数
m, n

(3, 3)

a = A[0] # 按行切片
a

matrix([[1, 2, 3]])

b = A.T[0] # 按列切片
b

matrix([[1, 4, 6]])

b1 = A[:, 0] # 按列切片
b1

matrix([[1],
        [4],
        [6]])

C = A.copy()   # 复制
C

matrix([[1, 2, 3],
        [4, 5, 6],
        [6, 7, 9]])

A < A.T  # 比较

matrix([[False,  True,  True],
        [False, False,  True],
        [False, False, False]], dtype=bool)

Linalg线性代数库

  • 行列式

    A = np.mat([[1, 2, 4, 5, 7],

           [9, 12, 11, 8, 2],
           [6, 4, 3, 2, 1],
           [9, 1, 3, 4, 5],
           [0, 2, 3, 4, 1]])
    

    np.linalg.det(A)

    -811.99999999999932

  • 求逆

    np.linalg.inv(A)

    matrix([[-0.07142857, -0.01231527, 0.05295567, 0.09605911, -0.00862069],

        [ 0.21428571, -0.37684729,  1.22044335, -0.46059113,  0.3362069 ],
        [-0.21428571,  0.82512315, -2.04802956,  0.56403941, -0.92241379],
        [ 0.        , -0.4137931 ,  0.87931034, -0.17241379,  0.81034483],
        [ 0.21428571, -0.06650246,  0.18596059, -0.08128079, -0.14655172]])
    
  • 矩阵的相辅相成

    AT = A.T # 矩阵的相反相成A * AT

    matrix([[ 95, 131, 43, 78, 43],

        [131, 414, 153, 168,  91],
        [ 43, 153,  66,  80,  26],
        [ 78, 168,  80, 132,  32],
        [ 43,  91,  26,  32,  30]])
    
  • 矩阵的秩

    np.linalg.matrix_rank(A)

    5

  • 线性方程组

    b = [1, 0, 1, 0, 1]

    s = np.linalg.solve(A, b)
    s

    array([-0.0270936 , 1.77093596, -3.18472906, 1.68965517, 0.25369458])

机械学习的数学基础

数学商量的是合理世界的空间方式与数据性质,即事物在时间和空间中普遍存在与移动的规律。
现代数学三大基础:

  1. 可能率论:表达事物也许会是什么样;
  2. 数值分析:揭发为何如此,以及哪些成为那样;
  3. 线性代数:事物一向都不唯有3个楷模,须求严格的观望。

    import scipy.spatial.distance as dist # 导入 SciPy 距离公式

  4. 相似性衡量


多个向量之间的相距(作为\(n\)坐标系的点)称为样本之间的相似性度量(Similarity
Measurement)。它展示为某类事物在距离上接近或远离的水平。

A = np.mat([8, 1, 6])
# 手工计算
modA = np.sqrt(np.sum(np.power(A, 2)))
modA

10.04987562112089

# 库函数
normA = np.linalg.norm(A)
normA

10.04987562112089

闵科夫斯基距离(Minkowski Distance)

\(p\)范数: \(||x – y||_p\)

  1. \(p=1\):曼哈顿相距(Manhattan
    Distance)
  2. \(p=2\):欧式距离(Euclidean
    Distance)
  3. \(p=
    \infty\):切比雪夫距离(Chebyshev Distance)

    v1 = np.mat([1, 2, 3])
    v2 = np.mat([4, 5, 6])

    np.sqrt((v1 – v2) * (v1 – v2).T) # 欧式距离

    matrix([[ 5.19615242]])

    np.sum(np.abs(v1 – v2)) # 曼哈顿距离

    9

    np.abs(v1 – v2).max() # # 切比雪夫距离

    3

夹角余弦(Cosine)

夹角余弦可用来衡量五个向量方向的不同。

cosV12 = np.dot(v1, v2.T)/(np.linalg.norm(v1) * np.linalg.norm(v2))
cosV12

matrix([[ 0.97463185]])

1 - dist.cosine(v1, v2.T)

0.9746318461970761

汉明距离(Hamming Distance)

汉明距离:五个等长字符串\(s1\)与\(s2\)之间的汉明距离定义为将个中多少个化为另叁个所急需的纤维替换次数。

等价于\(||x||_{0}\)

matV = np.mat([[1, 1, 0, 1, 0, 1, 0, 0, 1], [0, 1, 1, 0, 0, 0, 1, 1, 1]])   
smstr = np.nonzero(matV[0] - matV[1])
smstr

(array([0, 0, 0, 0, 0, 0], dtype=int64),
 array([0, 2, 3, 5, 6, 7], dtype=int64))

np.shape(smstr[0])[0] # 汉明距离

6

x = np.array([[1,0,0], [0,2,0], [1,1,0]])
x

array([[1, 0, 0],
       [0, 2, 0],
       [1, 1, 0]])

np.nonzero(x)

(array([0, 1, 2, 2], dtype=int64), array([0, 1, 0, 1], dtype=int64))

x[np.nonzero(x)]

array([1, 2, 1, 1])

np.transpose(np.nonzero(x))

array([[0, 0],
       [1, 1],
       [2, 0],
       [2, 1]], dtype=int64)

杰卡德相似周到(Jaccard Similarty Coefficient)

衡量八个集聚的相似度:\[J(A,B) =
\frac{\mid A \bigcap B\mid}{\mid A \bigcup B \mid}\]

杰Card距离

度量七个聚众的区分度:\(J_{\delta}(A,B) = 1

  • J(A,B)\)

设样本 \(A\) 和 \(B\) 是两个 \(n\) 维向量,取值为 \(0\) 或 \(1\) 。大家将样本看成多个汇集,\(1\) 表示集合包涵该因素,\(0\) 表示集合不包罗该因素。

  1. p:样本 \(A\) 和 \(B\) 都是 \(1\) 的维度的个数。
  2. q:样本 \(A\) 是 \(1\)、样本\(B\)是 \(0\) 的维度的个数。
  3. r:样本 \(A\) 是 \(0\)、样本\(B\)是 \(1\) 的维度的个数。
  4. s:样本 \(A\) 和\(B\)都是 \(0\) 维度的个数。

如此样本 \(A\) 和 \(B\) 的杰卡德相似周密可代表为:
\[J = \frac{p}{p + q + r}\]

matV = np.mat([[1, 1, 0, 1, 0, 1, 0, 0, 1], [0, 1, 1, 0, 0, 0, 1, 1, 1]])
dist.pdist(matV, 'jaccard')         # 杰卡德

array([ 0.75])

精通随机性

我们接下去从总体上考察矩阵(集合)中目标分布与矩阵全部的涉及。

想要真正掌握可能率,须要弄清楚三个难题:

  1. 鲜明与随机性
  2. 计算规律

洛伦兹重力学方程描绘出的活动轨迹像二个开始展览了翅膀的胡蝶,所以又称为蝴蝶效应。分明性与随机性被合并了:一方面,运动的轨道必然落在“蝴蝶”上,决不会远离它们而去,那是鲜明的展现,注解系统今后的拥有移动都被限定在一个显著的限制之内;另一方面,运动轨迹变化缠绕的条条框框却是随机性的,任几时候你都无法准确判断下3遍活动的轨道将落在“蝴蝶”的哪一侧翅膀上哪一点上。也正是说,那一个系统活动大的限制是鲜明的、可测的,不过运动的细节是专擅的、不可预测的。

从总计学角度去看,蝴蝶效应说明了:

  1. 样本总体(特征向量)的取值范围一般是分明的,全部样本对象(包涵已经存在的和未出现的)的取值都放在此空间范围中;
  2. 无论收集再多的范本对象,也不能使那种随机性下落或没有。

于是,随机性是事物的一种根本的、内在的、不能够廓清的特性,也是总体育赛事物(可能率)的本质属性。

世界上海高校部分的法则都出自总结学。

概率论

对事物运动那种不显著(随机性)的心路正是概率论。
权衡事物运动的随机性,必须从总体而不是局地来回味事物,因为从各种局地,事物可能看起来都以见仁见智的(或雷同的)。

  • 样本(样本点):原指随机试验的几个结出,能够知晓为矩阵中的三个指标(特征向量)
  • 样本空间:原指随机试验全体结果的联谊,能够领略为矩阵的保有目的,引申为对象特征的取值范围
  • 随机事件:是指样本空间的3个子集,能够通晓为某些分类,它其实指向一种可能率分布
  • 随机变量:能够清楚为指向某些事件的二个变量
  • 随机变量的概率分布:给定随机变量的取值范围,导致某种自由事件出现的只怕性。从机械学习角度来看,正是切合随机变量取值范围的有些对象属于有些项目或坚守某种趋势的可能。

可能率论的妙处在于,由于随机性的存在,有时候不可能间接研究随机变量如何从样本空间映射到事件空间,因为随机变量的取值范围允许它映射到事件空间的任一事件。此时唯有经过钻研随机变量映射为种种事件的也许性,也便是说某些对象属于某些项指标恐怕,才能做出合理的判定。

体系总计基础

矩阵是颇具同样特征和维度的靶子的成团,在这之中各类对象,也叫做行向量,都富有1个以上的特色。假使每一种特征都用1个随机变量来代表,那么从可能率论的角度,一个对象就足以表示为
\(n\) 个随机变量的完全,当中 \(X = (X_{1}, X_{2}, \cdots, X_{n})\)
为 \(n\)
维随机变量也许专擅向量。每一个对象便是任意向量的一组取值,矩阵中的全体指标构成了随便向量的一路和边缘可能率分布。

以身作则:水果联合可能率分布

\(\text{红色}\) \(\text{黄色}\) \(\text{绿色}\) $\text{颜色} $
苹果(1) 0.4 0.1 0 0.5
李子(2) 0 0.45 0.05 0.5
水果 0.4 0.55 0.05 1.0

随机向量的联合署名和边缘可能率分布描述了对象特征之间的可能率关系。在机械学习中,对象及对象构成的矩阵都以恒河沙数数据,由此,全体与可能率相关的算法都是目的的一起和边缘可能率分布为根基。

特点间的相关性

  • 对矩阵行向量的细分,即分类进程;
  • 而对矩阵特征列的探究首要利用于猜度活动,抽象点说,便是在三个时光系列上观望两列数据里面包车型大巴相关性。
  • 期望:度量样本有个别特征列取值范围的平均值。
  • 方差:度量样本有些特征列取值范围的离散程度。
  • 协方差矩阵和相关周密:度量样本特征列之间线性相关性。

相关周全(Correlation Coefficient)与连锁距离(Correlation Distance)

相关全面:
\[\rho_{XY} = \frac{Cov(X,
Y)}{\sqrt{D(X)} \sqrt{D(Y)}} = \frac{E((X – EX)(Y –
EY))}{\sqrt{D(X)} \sqrt{D(Y)}}\]
相关周详是度量七个特征列之间相关程度的,其取值范围是\([-1,
1]\)。相关周密的相对值越大,评释四个特征列之间相关程度越高。当它们线性相关时,相关全面取值为
\(1\)(正线性相关)或 \(-1\)(负线性相关)。

连锁距离:
\[D_{XY} = 1 – \rho_{XY}\]

相关周到矩阵:(以下边包车型大巴事例来说)若把第①个特征列作为参照数据(自个儿的连带程度为1),则与第②个与首个的连锁程度为
\(97\%\)。

featuremat = np.mat([[88.5, 96.8, 104.1, 111.3, 117.7, 124.0, 
                      130.0, 135.4, 140.2, 145.3, 151.9, 159.5, 
                      165.9, 169.8, 171.6, 172.3, 172.7],
                    [12.54, 14.65, 16.64, 18.98, 21.26, 24.06, 
                     27.33, 30.46, 33.09, 37.9, 42.3, 48.4, 
                     54.1, 57.2, 59.06, 60.4, 67.3]])

# 计算均值
mv1 = np.mean(featuremat[0])  # 第一列的均值
mv2 = np.mean(featuremat[1])  # 第二列的均值

# 计算标准差
dv1 = np.std(featuremat[0])
dv2 = np.std(featuremat[1])

corref = np.mean(np.multiply(featuremat[0] - mv1, featuremat[1] - mv2)) / (dv1 * dv2)
corref

0.97484719582346291

# 相关系数矩阵
np.corrcoef(featuremat)

array([[ 1.       ,  0.9748472],
       [ 0.9748472,  1.       ]])

马氏距离(Mahalanobis Distance)

lehu娱乐手机平台网站,定义:有\(m\)个样本向量 \(X_1 \dots X_m\),协方差矩阵记为 \(S\),均值记为向量 \(\mu\),则当中样本向量 \(X\) 到 \(\mu\) 的马氏距离为:
\[D(X) = \sqrt{(X – \mu)^{T} S^{-1} (X –
\mu)}\]

其中 \(X_i\) 与 \(X_j\) 之间的马氏距离为:
\[D(X_i, X_j) = \sqrt{(X_i – X_j)^{T}
S^{-1} (X_i – X_j)}\]

优点:与量纲毫无干系,排除变量之间的相关性困扰。

featuremat = np.mat([[88.5, 96.8, 104.1, 111.3, 117.7, 124.0, 
                      130.0, 135.4, 140.2, 145.3, 151.9, 159.5, 
                      165.9, 169.8, 171.6, 172.3, 172.7],
                    [12.54, 14.65, 16.64, 18.98, 21.26, 24.06, 
                     27.33, 30.46, 33.09, 37.9, 42.3, 48.4, 
                     54.1, 57.2, 59.06, 60.4, 67.3]])

convinv = np.linalg.inv(np.cov(featuremat))
tp = featuremat.T[0] - featuremat.T[1]
distma = np.sqrt(np.dot(np.dot(tp, convinv), tp.T))
distma

matrix([[ 0.81929564]])

矩阵——空间更换

由特征列的取值范围所结合的矩阵空间应该拥有完整性,即能够展示事物的上空方式或变化规律。

在机器学习中,训练集构成的矩阵为了能够反映事物的规律日常须求包罗多量的范本,或因为建立模型的急需。矩阵中的向量具有一点都不小的维度,正是我们所说的完整性。即使理论上,矩阵空间能够包含Infiniti多少个向量,然则大家无能为力形成也从不须求那么做。由此,大家目的在于达成两点:

  • 向量之间,以及向量与矩阵之间的运算到底有怎么着含义;为啥向量和矩阵运算能够发表出事物的空间情势。
  • 矩阵能还是不可能通过运算抽取出事物最本质的特色,通过那些特色就能反映出指标集合表达的花样和公理。

至于向量 & 矩阵

向量 \(\overrightarrow{x}\)
是有方向和尺寸的量。其尺寸为 \(\overrightarrow{x}\)
到原点的相距,方向为 \(\overrightarrow{x}\)
与各样维度的坐标轴的夹角。即向量表示贰个通过原点的有向线段。

基底向量对应于坐标系的坐标轴。

  • 向量的加法满足平行四边形法则,数乘是向量的伸缩。
  • 向量与矩阵的乘法 \(xA\):就是1个向量从一个线性空间(坐标系),通过接纳2个新的基底,变换成这几个新的基底构成的另八个线性空间的长河。
  • 矩阵乘法 \(AB\):\(A\) 表示向量组对应的坐标,\(B\)
    表示坐标系对应的矩阵。即向量组中的向量发生了旋转和伸缩变换。

特征值与特征向量

若向量在线性变换下只产生伸缩变换,而从未转动的效用,则称此向量为特征向量(也叫线性不变量)。
\[vA = v\lambda\]

A = np.mat([[8, 1, 6], [3, 5, 7], [4, 9, 2]])
evals, evecs = np.linalg.eig(A)
print('特征值:',evals, '\n特征向量:', evecs)

特征值: [ 15.           4.89897949  -4.89897949] 
特征向量: [[-0.57735027 -0.81305253 -0.34164801]
 [-0.57735027  0.47140452 -0.47140452]
 [-0.57735027  0.34164801  0.81305253]]

复原出原矩阵

\[A = Q \Sigma Q^{-1}\]
\(A\) 是原矩阵,\(Q\) 是特征向量,\(\Sigma\) 特征值构成的对角阵。

sigma = evals * np.eye(m)
sigma

array([[ 15.        ,   0.        ,  -0.        ],
       [  0.        ,   4.89897949,  -0.        ],
       [  0.        ,   0.        ,  -4.89897949]])

sigma = np.diag(evals)
sigma 

array([[ 15.        ,   0.        ,   0.        ],
       [  0.        ,   4.89897949,   0.        ],
       [  0.        ,   0.        ,  -4.89897949]])

evecs * sigma * np.linalg.inv(evecs)    # 原矩阵

matrix([[ 8.,  1.,  6.],
        [ 3.,  5.,  7.],
        [ 4.,  9.,  2.]])

数量归一化

归一化是一种简化总计的艺术,将有量纲的表明式,经过变换,转换为无量纲的表明式,称为标量

归一化是机械学习的一项基础工作。有三种样式:

  1. 把数成为 \((0, 1)\) 之间的小数;
  2. 把有量纲表达式变为无量纲表达式。

在计算学中,归一化的有血有肉效率是汇总统一样本的总结分布性。归一化在 \((0, 1)\) 之间是总括的可能率分布,在 \((-1, +1)\) 之间是总括的坐标分布。

从集合的角度来看,能够做维度的归一,即抽象化归一,把不根本的、不具可比性的集纳中的成分的习性去掉,保留人们关怀的这个属性,那样,本来不具可比性的东西或对象就归为一类,然后就能够比较了。

数码标准(Data 诺玛lization Method)

数据标准是归一化的一种方式,本质上也是解除量纲的差距,比较认识。

首要方法:按百分比缩放,使之落入多少个较小的特定区间。
\[X^{*} = \frac{X –
\mu}{\Sigma}\]

vectormat = np.mat([[1, 2, 3], [4, 5, 6]])
v12 = vectormat[0] - vectormat[1]
np.sqrt(v12 * v12.T)

matrix([[ 5.19615242]])

# norm
varmat = np.std(vectormat.T, axis = 0)
normvmat = (vectormat - np.mean(vectormat)) / varmat.T
normv12 = normvmat[0] - normvmat[1]
np.sqrt(normv12 * normv12.T)

matrix([[ 6.36396103]])
You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图