对象、矩阵与矢量化编程

对象是指含有一组特征的行向量

对象的维度就是行向量的列数

表是行向量的集合

矩阵是具有相同特征和维度的对象集合

矩阵是具有相同特征和维度的对象集合，表现为一张二维数据表

一个对象表示为矩阵中的一行，一个特征表示为矩阵中的一列，每个特征都有数值型的取值

特征相同、取值相异的对象集合所构成的矩阵，使对象之间既相互独立，又相互联系

由特征列的取值范围所构成的矩阵空间应该具有完整性，即使能够反映出事物的空间形式或变化

预测或回归可以看作根据对象在某种序列上的相关性，表现为特征取值变化的一种趋势

分类、聚类和回归是机器学习最基本的主题

矢量化编程

# coding: utf-8

import numpy as np

// 一般矩阵的数乘
mylist =  [1,2,3,4,5]
length = len(mylist)
a = 10
for indx in xrange(length):
    mylist[indx] = a*mylist[indx]
print mylist

// 优化 使用numpy计算数乘
mymatrix = np.mat(mylist)
print a*mymatrix

矩阵初始化

创建一个3x5的全0矩阵和全1矩阵

# 创建一个3x5的全0矩阵和全1矩阵
myZero = np.zeros([3,5])
print myZero
myOnes = np.ones([3,5])
print myOnes

生成随机矩阵

myRand = np.random.rand(3,4) # 3行4列随机矩阵
print myRand

单位阵

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

矩阵的运算

导入包

from numpy import *

元素加减

条件：矩阵的行数和列数必须相同

数学公式： $(A±B)_{i,j} = A_{i,j} ± B_{i,j}$

myOnes = ones([3,3])
myEye = eye(3)
print myOnes - myEye
print myOnes + myEye

矩阵数乘

数学公式： $(cA)_{i,j} = c·A_{i,j}$

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

矩阵所有元素求和

数学公式： $sum(A) = \sum^m_{i=1}\sum^n_{j=1}A_{i,j}$ 其中1

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

矩阵各元素的积

矩阵的点乘同纬度对应元素的相乘。当矩阵的纬度不同时，会根据一定的广播规则将维数扩充到一致的形式

数学公式： $(A*B)_{i,j} = A_{i,j}*B_{i,j}$

mymatrix = mat([[1,2,3],[4,5,6],[7,8,9]])
mymatrix2 = 1.5*ones([3,3])
print multiply(mymatrix,mymatrix2)

输出结果：

[[ 1.5  3.   4.5]
 [ 6.   7.5  9. ]
 [10.5 12.  13.5]]

矩阵各元素的n次幂：n=2

数学公式： $A_{i,j}^2 = A_{i,j}*A_{i,j}$

mylist = mat([[1,2,3],[4,5,6],[7,8,9]])
print power(mylist,2)

输出结果：

[[ 1  4  9]
 [16 25 36]
 [49 64 81]]

矩阵的乘法：矩阵乘矩阵

数学公式： $[A,B]_{i,j} = A_{i,1}B_{1,j}+A_{i,2}B_{2,j}+···+A_{i,n}B_{n,j} = \sum^n_{r=1}A_{i,r}B_{r,j}$

# 矩阵的乘法：矩阵乘矩阵
from numpy import *

mymatrix = mat([[1,2,3],[4,5,6],[7,8,9]])
mymatrix2 = mat([[1],[2],[3]])
print mymatrix*mymatrix2

输出结果：

[[14]
 [32]
 [50]]

矩阵的转置

数学公式： $(A^T)_{i,j} = A_{j,i}$

from numpy import *

mymatrix = mat([[1,2,3],[4,5,6],[7,8,9]])
print mymatrix.T     # 矩阵的转置
mymatrix.transpose() # 矩阵的转置
print mymatrix

输出结果

[[1 4 7]
 [2 5 8]
 [3 6 9]]
[[1 2 3]
 [4 5 6]
 [7 8 9]]

矩阵的其他操作：行列数、切片、复制、比较

from numpy import *
mymatrix = mat([[1,2,3],[4,5,6],[7,8,9]])
[m,n] = shape(mymatrix) # 矩阵的行列数
print "矩阵的行数和列数：",m,n

myscl1 = mymatrix[0]    # 按行切片
print "按行切片：",myscl1

myscl2 = mymatrix.T[0]
print "按列切片：",myscl2

mycpmat = mymatrix.copy() # 矩阵的复制
print "复制矩阵:\n",mycpmat

# 比较
print "矩阵元素的比较：\n",mymatrix < mymatrix.T

输出结果：

矩阵的行数和列数： 3 3
按行切片： [[1 2 3]]
按列切片： [[1 4 7]]
复制矩阵:
[[1 2 3]
 [4 5 6]
 [7 8 9]]
矩阵元素的比较：
[[False  True  True]
 [False False  True]
 [False False False]]

Linalg线性代数库

1. 矩阵的行列式

# 矩阵的行列式
from numpy import *

# n阶方阵的行列式运算
A = 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]])
print "det(A):",linalg.det(A);  # 方阵的行列式

输出结果：

det(A): -811.9999999999993

2. 矩阵的逆

from numpy import *

A = 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]])
invA = linalg.inv(A) # 矩阵的逆
print "invA:",invA

输出结果：

invA: [[-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]]

3. 矩阵的对称

from numpy import *

A = 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]])
AT = A.T  # 矩阵的对称
print A*AT

输出结果：

[[ 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]]

4. 矩阵的秩

from numpy import *

A = 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]])
print linalg.matrix_rank(A)  # 矩阵的秩

输出结果：

5. 可逆矩阵求解

from numpy import *

A = 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]])
b = [1,0,1,0,1]
s = linalg.solve(A,b)
print s

输出结果：

[-0.0270936   1.77093596 -3.18472906  1.68965517  0.25369458]