机器学习绪论

机器学习概念

机器学习

• 有监督学习
  • 如：回归，分类
• 无监督学习
  • 如：聚类，降维

什么是机器学习

• 程序通过不断的学习达到一定的性能，可以完成指定的任务

• 定义

  • （1）机器学习是一门人工智能的科学，该领域的主要研究对象是人工智能，特别是如何在经验 学习中改善具体算法的性能。

    （2）机器学习是对能通过经验自动改进的计算机算法的研究。

    （3）机器学习是用数据或以往的经验，以此优化计算机程序的性能标准

• 机器学习的三个要素

  • 模型（model）：模型在未进行训练前，其可能的参数是多个甚至无穷的，故可能的模型也是多个甚至无穷的，这些模型构成的集合就是假设空间。
  • 策略（strategy）：即从假设空间中挑选出参数最优的模型的准则。模型的分类或预测结果与实际情况的误差（损失函数）越小，模型就越好。那么策略就是误差最小。
  • 算法（algorithm）：即从假设空间中挑选模型的方法（等同于求解最佳的模型参数）。机器学习的参数求解通常都会转化为最优化问题，故学习算法通常是最优化算法，例如最速梯度下降法、牛顿法以及拟牛顿法等

机器学习算法

• 监督学习 ：房价预测 ( 回归 )
  • 监督学习
    • 正确价格
  • 回归问题
    • 预测价格
• 监督学习 ：垃圾邮件分类 ( 分类 )
  • 监督学习
    • \(y\in\lbrace 0,1\rbrace\) 0表示负向类 1表示正向类
  • 分类问题
    • 对邮件的好坏进行区分
• 无监督学习 **：聚类 **
  • 如：邮件分类 没有指定哪些是正向类，哪些是负向类，无监督学习可以将它们分为不同的簇，这就是聚类
  • 如新闻分类，同一个新闻主题的多个报道网页都放到同一个簇别中一起展示，这就是聚类算法的应用
• 总结
  • 监督学习：所用训练数据都是被标记过的
  • 无监督学习：训练集中的所有数据都没有标记

补充

矩阵

​ 由 m × n 个数\(A_ij\)排成的m行n列的数表称为m行n列的矩阵，简称m × n矩阵。记作：

​ 这种 \(m\times n\) 个数称为矩阵 \(A\) 的元素 \(A_{ij} = i,j\) 代表 \(i 行,j列\)

向量

´ 向量:在数学中，向量（也称为欧几里得向量、几何向量、矢量），指具有大小和方向的量。与向量对应的只有大小，没有方向的量叫做数量（物理学中称标量）

​ 是一行或一列的特殊矩形，通常情况下，向量指列向量

​ 向量：一个 \(n\times 1\) 矩阵

矩阵运算

• 举例

• 矩阵加法，减法

  • 满足交换律 ： A+B = B+A , A - B = B - A
    \[A+B =\left[ \begin{array}\\ a1 + b1 & a2+b2 \\ a3+b3&a4+b4 \\ \end{array} \right] \]

    减法相同

• 矩阵乘法

  • 乘法条件：两个矩阵相乘，需要满足A的列数等于**B的行数*

  • A矩阵的行元素 ，乘以 B 的每一列然后相加

    \[A * B =\left[ \begin{array}\\ a1*b1+a2*b3&a1*b2+a2*b4\\ a3*b1+a4*b3&a3*b2+a4*b4 \end{array} \right] \]

  • 乘法不满足交换律,但满足分配率和结合率

    • AB \(\neq\) BA
    • (AB)C=A(BC)
    • (A+B)C=AC+BC
    • C(A+B)=CA+CB

• 逆矩阵

  • **逆矩阵 ** : 如果 A 是一个m x m 矩阵, 并且如果它有逆矩阵。

    矩阵与其逆阵的乘积等于单位阵：

    $AA^{-1} = A^{-1}A = I $

  • 不是所有的矩阵都有逆矩阵

    没有逆矩阵的矩阵称为“奇异矩阵” 或“退化矩阵”。

• 矩阵转置

  • 例如:
    \[A =\left[ \begin{array}\\ 1 & 2 &3\\ 4 & 5 &6\\ \end{array} \right] A^T =\left[ \begin{array}\\ 1 &4\\ 2&5\\ 3&6\\ \end{array} \right] \]

• 线性方程

  \[\begin{cases} a_{11}x_1+a_{12}x_2+a_{13}x_3=y1 \\ a_{21}x_1+a_{22}x_2+a_{23}x_3=y2 \\ a_{31}x_1+a_{32}x_2+a_{33}x_3=y3 \\ \end{cases} \]
  \[若y = \left[ \begin{array}\\ y1\\ y2\\ y3 \end{array} \right] , A = \left[ \begin{array}\\ a_{11} &a_{12}&a_{13}\\ a_{21}&a_{22}&a_{32}\\ a_{31}&a_{32}&a_{33}\\ \end{array} \right] , x = \left[ \begin{array}\\ x_1\\ x_2\\ x_3\\ \end{array} \right] 所以 \left[ \begin{array}\\ y1\\ y2\\ y3 \end{array} \right] = \left[ \begin{array}\\ a_{11} &a_{12}&a_{13}\\ a_{21}&a_{22}&a_{32}\\ a_{31}&a_{32}&a_{33}\\ \end{array} \right] \left[ \begin{array}\\ x_1\\ x_2\\ x_3\\ \end{array} \right] \]

• 线性组合

  • 代码实现转置

    y = w.T.dot(x)
    

• np.array 的使用

  from numpy import *
  import numpy as np
  
  # 使用np.array创建矩阵:
  np.array([[1,4],[3,5]])
  
  # 使用mat创建矩阵:   
  mat(‘[1 2;3 4]’)   # 用;隔开，用‘ ’括上;也可以mat([1,2],[3,4])
  
  # 创建3*3的零矩阵:
  np.zeros((3,3))  
  
  # 创建2*4的1矩阵 :
  np.ones((2,4))   #默认是浮点型的数据  
  
  # 创建2*2的单位矩阵：
  np.eye(2,2,dtype=int) #注意没有多余的()
  
  # 创建对角矩阵：
  np.diag([1, 2, 3])
  
  # 创建有序矩阵：
  np.arange(2,12,2)
  
  np.sum(): 按列或行求和，A.sum(axis=0); sum(A,1); sum(A[2:5], 0)
  np.max(): 按列或行求最大值，A.max(axis=0); A.max(1); max(A[2:5],0)
  np.min(): 按列或行求最小值，A.min(0); A.min(1); min(A[2:5],1)
  np.argmax(): 列或行最大值的索引，A.argmax(axis=0); argmax(A[2:5],1)  
  np.argmin(): 列或行求最大值的索引，A.argmin(0); argmin(A[2:5],0)
  
  (参数
  axis=0， 按列
  axis=1，按行
  )
  

• slice切片

  A[ 起始位：终止位：步长 ]      
  
  1.每个元素可用正向下标(从0开始)或反向下标(从-1开始)表示，
  2.步长默认=1，可省略
  
  A=np.array([1,2,3,4,5,6]):    正向下标：0 ~ 5    反向下标：-1~-6
  # A[1:5]->[2,3,4,5]   (正向，默认步长=1)
  # A[2:] ->[3,4,5,6]     (正向，默认步长=1)
  # A[:5] ->[1,2,3,4,5]  (正向，默认步长=1)
  # A[::2]->[1,3,5]   (正向，步长=2)
  # A[1:5:2]->[2,4]   (正向，步长=2)
  # A[-1:-4:-1]->[6,5,4]  (反向，步长=-1)
  # A[-1::-1]->[6,5,4,3,2,1]  (反向，步长=-1)
  # A[-2:-5:-2]->[5,3]  (反向，步长=-2)
  # A[1:-2]->[2,3,4]  (正向，默认步长=1)
  # A[-1:2:-1]->[6,5,4]  (反向，步长=-1)
  

• vstack , hstack 的使用

  from numpy import *
  import numpy as np
  
  # 创建2行2列的全1矩阵
  a=np.ones((2,2))
  
  # 创建2行2列的全零矩阵
  b=np.eye(2,2)
  
  # 按列方向合并两个矩阵，列数不变，行数相加
  vstack((a,b))
  
  [[1, 1]
  [1, 1]
  [1, 0]
  [0, 1]]
  
  # 按行方向合并两个矩阵， 行数不变，列数相加
  hstack((a,b))
  
  [[1, 1, 1, 0]
  [1, 1, 0, 1]]
  

• **np.c_ ** np.r _ 的使用

  from numpy import *
  import numpy as np
  # np.c_ : 按列连接两个矩阵
  # np.r_: 按行连接两个矩阵
  
  1.
  a = np.array([1, 2, 3]);  b = np.array([4, 5, 6])
  
  c = np.c_[a,b] ->[[1, 4 ], [2, 5], [3 6]]
  c = np.c_[c,a] -> [[1, 4, 1], [2, 5, 2], [3, 6, 3]]
  c = np.r_[a,b] -> [1, 2, 3, 4, 5, 6]
  
  2.
  a = np.array([[1, 2, 3],[1,1,1]]);    b = np.array([[4, 5, 6],[7,8,9]])
  c =np.c_[a,b]->[[1, 2, 3, 4, 5, 6], [1, 1, 1, 7, 8, 9]]
  c = np.r_[a,b] -> [[1, 2, 3], [1, 1, 1], [4, 5, 6], [7, 8, 9]]
  
  
  

• 画图 matplotlib

  import numpy as np
  import matplotlib.pyplot as plt
  import matplotlib
  
  matplotlib.rcParams["font.sans-serif"] = ["SimHei"]  #在画布中显示中文
  matplotlib.rcParams['axes.unicode_minus']=False      #画布中显示负号 
  
  x=[1.5,0.8,2.6,1.0,0.6,2.8,1.2,0.9,0.4,1.3,1.2,2.0,1.6,1.8,2.2]
  y=[3.1,1.9,4.2,2.3,1.6,4.9,2.8,2.1,1.4,2.4,2.4,3.8,3.0,3.4,4.0]
  
  #创建画布
  plt.figure("散点图")
  #画图
  plt.scatter(x,y)
  
  #线性回归公式
  w = 1.5
  b = 0.8
  
  x_min=min(x)
  x_max=max(x)
  
  y_min = w*x_min + b
  y_max = w*x_max + b
  
  #画出回归方程
  plt.plot([x_min,x_max],[y_min,y_max],'r')
  plt.show()
  

总结

• 通过上图我们可以知道，不断的更换 w 和 b 可以让直线拟合散点图
• 所以 在机器学习中线性回归模型，就是在不断的更新 w 和 b 找到 w 和 b 的最优解