Linear Algebra(1):向量

线性代数

Introduction

线性代数是我们高等教育理工科学生必学的数学，毫不夸张的说线性代数是近现代科学发展过程中最重要的基础数学之一.为什么线性代数这么重要？

我们在初等教育中即小学中学这个阶段，代数更多的是在研究一个一个的数，比如对数进行具体的分类为 $N Q R$ 即自然数、有理数、实数，进而在代数领域一个非常重要的研究课题是函数 $f (x)$ ，函数可以理解为将一个数传入一个规则中得到另外一个结果.这些代数中主要研究的对象是一个一个的数.

高等教育阶段的线性代数对这个概念进行了拓展，简单来说线性代数在研究"一组数"，即向量. 线性代数研究的是所谓的空间 $N^{n}$ , $Q^{n}$ , $R^{n}$ ,同样线性代数领域也要研究很多的函数 $T (v)$ ，这个函数作用的对象通常是一个向量，线性代数中的矩阵就可以理解为对向量进行变化的函数.

初等代数我们研究的是一个一个的数，高等教育线性代数研究的是一个一个的向量(一组数):

x \to x = (x_{1} x_{2} ... x_{n})

为什么要研究一组数呢？背后原因也很简单，真实世界是多维度的，单变量不足描述真实世界，用单变量描述真实世界是不方便的。而线性代数将研究对象拓展到向量维度，可以对多维数据进行统一的研究进而演化出一套计算的方法和工具，可以更加方便非常契合应用到真实世界中。因此近乎所有的理工科教材都充斥着线性代数的公式或符号。

向量

什么是向量

线性代数的学习从向量开始。上面提到了线性代数据之所非常重要，是其从研究一个数拓展到研究一组数。这样对于表达我们的多维世界来说非常方便。那么究竟怎样表达一组数呢？

一组数的基本表示方法就是向量（vector）,向量也是线性代数研究的基本元素。一组数有什么用？向量概念的产生最基本的出发点就是为了表示方向，一组数可以更好的表示方向这个概念，也是“向”的来源。比如下面的二维平面中，我们从一点出发到另外一点，假设从起点到终止点的距离是5km,从同样一个起始点出发，很可能会达到一个不同的终止点，只使用5这个数字表示最终走到哪里是远远不够的。此时向量就有了意义，比如（4，3）和（4.6，1）两个数字才能准确表达位置的不同。

这是一个物理学中位移概念的例子，同样像速度、加速度、力等概念都具有方向的概念。那么我们研究过程中只考虑方向吗？起始点重要吗？从（0，0）到（4，3）和从（-1，-1）到（3，2）其实是一样的，它们的区别只在于坐标系不同。向量只表征从一个点到另一个点响应的结果而不区分这一过程是从哪个起始点出发的，所以为了研究方便这个起始点统一都理解成从原点开始。

但是向量的顺序是重要的！（4，3）和（3，4）是截然不同的，即向量也是一组有序的数。如果只是表示物理世界的方向，最多三个维度就够了，因为我们的世界在人类感知中是一个三维的空间. 但是为了扩大研究范围同时也增强向量这个数学概念的能力，可以用抽像的n维向量描述n维世界. 我们无法直接感知4维空间和5空间它是什么样子的，看不见也画不出来，只能抽象的理解它。

举一个用高维空间表达事物的例子，比如刻画一个房子：

面积	卧室	卫生间	最近地铁站	价格（万）
108	3	2	1	320

每一个数字都是一个维度，不同的房子每一个数字可能不同，所以每一个房子都可以使用（108，3，2，1，320）这样的5个数字来表示，即5维向量，此时向量就是一组数，这组数的含义由使用者定义。

向量都是一组有序的数字，可以用两个视角来看待它。一个视角可以将其看作一个方向，另外一个视角看作一个有序的数字，可以理解为高维空间的一个数据点。这两个视角可以互相转换，一个方向就是一个点，空间中的任何一点都可以看做从原点指向这个点的一个方向。实际使用线性代数过程中，更倾向于第二个视角把每个向量看做空间中的一个点，但在学习向量性质时使用方向的视角会更加形象直观。这两个视角一个是一个有向线段，一个是空间的点。

向量的术语和表示法

和向量相对应的一个数字，称为标量。我们学的代数，用符号代表数。和标量相区别的是，向量的符号画箭头： $v$ .个别情况下，尤其是几何学中，像我们高中做的向量几何题目，我们会考虑向量的起始点，比如 $O A$ ，假如O(0,0),A(4，3)，B(-1,-1),C(3，2）,此时的 $O A$ 和 $BC$ 是不一样的，因为几何学这两个线段不同。但是从线性代数角度出发这两个向量是同样的向量，不考虑起点。

向量也分为行向量和列向量。比如（3，4）一组数写成一行就是行向量，而 $(3 ， 4)^{T}$ 写成一列就是列向量。现阶段行向量和列向量没有区别，并且通常教材论文提到向量通常指列向量。

代码实现：

class Vector:

    def __init__(self, lst):
        self._values = lst
    
    def __len__(self):
        '''返回向量长度'''
        return len(self._values)

    def __getitem__(self, idx):
         '''返回指定索引元素'''
        return self._values[idx]

    def __repr__(self):
        return "Vector({})".format(self._values)
    
    def __str__(self):
        return "({})".format(", ".join(str(e) for e in self._values))

如上图所示，其中__repr__方法是系统调用的，而__str__ 是用户调用的. __repr__方法表示的是类的对象对应的构造方法应该写成什么样子，而__str__方法就是从用户角度来看这个对象是什么样子的。

向量的两个基本运算

向量的基本运算主要包括两种运算：

向量加法 (两个向量之间)

(5, 2)^{T} + (2, 5)^{T} = (7 ， 7)^{T} (a, b)^{T} + (c, d)^{T} = (a + b ， c + d)^{T} a b c + d e f = a + d b + e c + f v_{1} v_{2} ... v_{n} + u_{1} u_{2} ... u_{n} = v_{1} + u_{1} v_{2} + u_{2} ... u_{n} + v_{n}

数量乘法(一个标量和一个向量)

2 \times (5, 2)^{T} = (10, 4)^{T} k \times (a, b)^{T} = (ka, kb)^{T} k v_{1} v_{2} ... v_{n} = k . v_{1} k . v_{2} ... k . v_{n}

代码实现：

class Vector:

    def __init__(self, lst):
        self._values = list(lst) # immutable
    
    def __add__(self, another):
        assert len(self) == len(another), \
        "length of vectors must be same"

        return Vector([a + b for a, b in zip(self, another)])
    
    def __sub__(self, another):
        assert len(self) == len(another), \
        "length of vectors must be same"

        return Vector([a - b for a, b in zip(self, another)])

    def __mul__(self, k):
        '''返回数量乘法结果 self*k'''
        return Vector([k*e for e in self])      
    
    def __rmul__(self, k):
        '''返回数量乘法结果 k*self'''
        return self*k

    def __pos__(self):
        '''返回向量取正的结果向量'''
        return 1*self

    def __neg__(self):
        '''返回向量取负的结果向量'''
        return -1*self    

    def __iter__(self):
        '''返回向量迭代器''' # pythonic
        return self._values.__iter__()
    
    def __len__(self):
        '''返回向量长度'''
        return len(self._values)

    def __getitem__(self, idx):
        return self._values[idx]

    def __repr__(self):
        return "Vector({})".format(self._values)
    
    def __str__(self):
        return "({})".format(", ".join(str(e) for e in self._values))

测试代码

from LA.Vector import Vector

if __name__ == "__main__":

    vec = Vector([5, 2, 0])
    print(vec)
    print(len(vec))
    print("vec[0]:{} vec[1]:{} vec[2]:{}".format(vec[0], vec[1], vec[2]))

    vec2 = Vector([1, 2, 3])
    print("{} + {} = {}".format(vec, vec2, vec+vec2))
    print("{} - {} = {}".format(vec, vec2, vec-vec2))

    print("{} * {} = {}".format(vec, 3, vec*3))
    print("{} * {} = {}".format(3, vec, 3*vec))

    print("+{} = {}".format( vec, +vec))
    print("-{} = {}".format( vec, -vec))

向量运算的基本性质

交换律： $u + v = v + u$
结合律： $(u + v) + w = u + (v + w)$
数乘分配律： $k (u + v) = k u + k v$ ， $(k + c) u = k u + c u$ ， $(k c) u = k (c u)$ ， $1 u = u$

证明举例:

P ro f . k (u + v) = k u + k v k (u + v) = k (u_{1} u_{2} ... u_{n} + v_{1} v_{2} ... v_{n}) = k u_{1} + v_{1} u_{2} + v_{2} ... u_{n} + v_{n} = k u_{1} + k v_{1} k u_{2} + k v_{2} ... k u_{n} + k v_{n} k u + k v = k u_{1} u_{2} ... u_{n} + k v_{1} v_{2} ... v_{n} = k u_{1} k u_{2} ... k u_{n} + k v_{1} k v_{2} ... k v_{n} = k u_{1} + k v_{1} k u_{2} + k v_{2} ... k u_{n} + k v_{n}

零向量

向量的世界里既然定义好了加法，那么相应的和数的世界一样，我们一样可以定义一个零。所谓的零向量也是各个维度都是零的向量，我们不定义什么是零向量，我们从推导一个性质出发，而这个性质和数字世界中0的这个数字的性质非常像.

对于任意一个向量 $u$ ,都存在一个向量 $O$ ，满足 $u + O = u$ .

假设存在这样一个向量 $O$ ,证明其存在性

u = u_{1} u_{2} ... u_{n} O = o_{1} o_{2} ... o_{n} u + O = u_{1} u_{2} ... u_{n} + o_{1} o_{2} ... o_{n} = u_{1} + o_{1} u_{2} + o_{2} ... u_{n} + 0_{n} = u_{1} u_{2} ... u_{n} ⎩ ⎨ ⎧ u_{1} + o_{1} = u_{1} u_{2} + o_{2} = u_{2} ... u_{n} + o_{n} = u_{n} ⎩ ⎨ ⎧ o_{1} = 0 o_{2} = 0 ... o_{n} = 0 \to O = 00 ... 0

我们称这个向量为零向量.注意：这个 $O$ 是没有箭头的.有了零向量，我们相应可以定义负这个概念。

对于任意一个向量 $u$ ,都存在一个向量 $- u$ ，满足 $u + - u = O$ .

零向量实现：在上面的Vector类中假如下面类方法

1
2
3

@classmethod
def zero(cls, dim):
    return cls([0]*dim)

向量的长度和单位向量

看待向量有两种方式，其中一种是把向量看成一个有向的线段，它是从原点一直指向空间中的某一个点这样一个方向。既然是有向线段那么除了方向也有大小.比如二维向量 $u = (3, 4)$ 的大小可以根据勾股定理求出为5. 在线性代数数学表示上，我们会使用 $∣∣ u ∣∣$ 用它来表示向量的长度大小，即向量的模。

对于n维向量 $u = (u_{1}, u_{2}, \dots, u_{n})^{T}$ ，那么 $u$ 的模：

∣∣ u ∣∣ = u_{1}^{2} + u_{2}^{2} + ... + u_{n}^{2}

知道如何求向量的长度后，就可以引入一个新的概念单位向量(unit vector).所谓单位向量即其长度固定为1个单位，每一个向量都对应着一个单位向量 $\overset{u}{^}$ 。

\overset{u}{^} = \frac{1}{∣∣ u ∣∣} . u = (\frac{u _{1}}{∣∣ u ∣∣}, \frac{u _{2}}{∣∣ u ∣∣}, ..., \frac{u _{n}}{∣∣ u ∣∣}) ∣∣ \overset{u}{^} ∣∣ = 1 只表示方向

根据 $u$ 求出 $\overset{u}{^}$ 的过程有时称为归一化，规范化(normalize).

单位向量有无数个，比如二维平面的以原点为圆心半径为1的圆上的向量都是一个单位向量。不过二维空间有两个很特殊的单位向量即和二维平面两个轴重合的单位向量 $e_{1} = (1, 0), e_{2} = (0, 1) .$ 为什么表示为小e呢？因为这两个单位向量只由0，1组成，叫做标准单位向量(Standard Unit Vector).标准单位向量指向坐标轴正方向.

三维空间就有三个标准单位向量 $e_{1} = (1, 0, 0), e_{2} = (0, 1, 0) . e_{3} = (0, 0, 1) .$

n维空间就有n个标准单位向量 $e_{1} = (1, 0, \dots, 0), e_{2} = (0, 1, \dots, 0) . e_{3} = (0, 0, \dots, 1) .$

标准单位向量是很重要的一组向量，整个空间坐标系是由标准单位向量所组建的。

代码实现求向量的模：（放到Vector类中）

def norm(self):
    '''求向量的模'''
    return math.sqrt(sum(e**2 for e in self._values))

def normalize(self):
    '''求改向量的单位向量'''
    if self.norm() < EPSILON:
        raise ZeroDivisionError("norm is zero")
    return Vector(self._values)/self.norm()

def __truediv__(self, k):
    '''返回数量除法'''
    return (1/k)*self

这里实现__truediv__ 方法来使得我们的Vector能够除以一个数，考虑到零向量求方向向量会抛出除0异常，同时normalize方法捕捉异常.

向量的点乘

前面定义了向量的两个基本运算，其中加法是两个向量的运算，数量乘法是一个向量和一个标量的运算. 但是对于两个向量相乘这样的运算并没有定义.

两个向量相乘可能比较自然的想法就是：

u . v = u_{1} u_{2} ... u_{n} . v_{1} v_{2} ... v_{n} = u_{1} . v_{1} u_{2} . v_{2} ... u_{n} . v_{n}

跟加法一样对应元素相乘组合成一个向量，实际上对于两个向量相乘的运算并不是这样定义的!（上面是错的）为什么不这么定义？后续分晓…

线性代数中真正两个向量相乘的定义是这样的：

u . v = u_{1} u_{2} ... u_{n} . v_{1} v_{2} ... v_{n} = s u m (u_{1} . v_{1} u_{2} . v_{2} ... u_{n} . v_{n}) = u_{1} . v_{1} + u_{2} . v_{2} + ... + u_{n} . v_{n} = ∣∣ u ∣∣.∣∣ v ∣∣. cos θ

可以看出来两个向量“相乘”后的结果是一个数(标量)，而不是一个向量.这种向量的乘法叫做向量的点乘或者内积.为什么这么定义？后续揭晓.同时这样定义点乘后，上面的结果在几何上同时还等于 $∣∣ u ∣∣.∣∣ v ∣∣. cos θ$ .

证明一下这个结论：

u . v = u_{1} . v_{1} + u_{2} . v_{2} + ... + u_{n} . v_{n} = ∣∣ u ∣∣.∣∣ v ∣∣. cos θ

二维空间中：

u . v = x_{1} . x_{2} + y_{1} . y_{2} = ∣∣ u ∣∣.∣∣ v ∣∣. cos θ

如上图所示,采用余弦定理得证. 同理可以拓展到n维空间，得证上式.

代码实现向量点乘操作：

def dot(self, another):
    '''向量点乘, 返回标量结果'''    
    assert len(self) == len(another), \
    "Error in dot product.Length of vectors must be same"

    return sum(a*b  for a, b in zip(self, another))

有些数学库会将 $u * v$ 定义为逐元素相乘的向量，即：

u * v = u_{1} u_{2} ... u_{n} . v_{1} v_{2} ... v_{n} = u_{1} . v_{1} u_{2} . v_{2} ... u_{n} . v_{n}

称为element-wise multiplication.由于这个计算不具备数学含义，在我们的现实中不取.

向量点乘的应用意义

向量点乘定义：

u . v = u_{1} . v_{1} + u_{2} . v_{2} + ... + u_{n} . v_{n} = ∣∣ u ∣∣.∣∣ v ∣∣. cos θ

从数学计算上其等于每一个向量的分量相乘再相加，几何意义上等于两个向量的模再乘以两个向量的夹角cos.

这个式子最简单的一个应用就是非常容易的求出两个向量的夹角：

cos θ = \frac{u . v}{∣∣ u ∣∣.∣∣ v ∣∣}

特别的如果 $θ = 9 0^{\circ}, u . v = 0$ . 反之如果 $u . v = 0$ ,两个向量垂直. 如果 $u . v > 0$ ,两个向量夹角为锐角;如果 $u . v < 0$ ,两个向量夹角为钝角.

因此首先一个应用就是判断两个向量的相似程度(推荐系统)：

另一个应用就是几何计算:

Numpy中向量的基本使用

最后附上业界经常使用的线性代数库Numpy的基本使用方法，很多框架比如机器学习框架scikit-learn中的数据都是要以numpy所定义的矩阵类相应的对象传进机器学习算法中.

import numpy as np

if __name__ == "__main__":

    print(np.__version__)

    # np.array 基础
    lst = [1, 2, 3]
    lst[0] = "Linear Algebra"
    print(lst)

    vec = np.array([1, 2, 3])
    print(vec)
    # vec[0] = "Linear Algebra"
    # vec[0] = 666
    # print(vec)

    # np.array的创建
    print(np.zeros(5))
    print(np.ones(5))
    print(np.full(5, 666))

    # np.array的基本属性
    print(vec)
    print("size =", vec.size)
    print("size =", len(vec))
    print(vec[0])
    print(vec[-1])
    print(vec[0: 2])
    print(type(vec[0: 2]))

    # np.array的基本运算
    vec2 = np.array([4, 5, 6])
    print("{} + {} = {}".format(vec, vec2, vec + vec2))
    print("{} - {} = {}".format(vec, vec2, vec - vec2))
    print("{} * {} = {}".format(2, vec, 2 * vec))
    print("{} * {} = {}".format(vec, vec2, vec * vec2))
    print("{}.dot({}) = {}".format(vec, vec2, vec.dot(vec2)))

    print(np.linalg.norm(vec))
    print(vec / np.linalg.norm(vec))
    print(np.linalg.norm(vec / np.linalg.norm(vec)))

    # zero3 = np.zeros(3)
    # print(zero3 / np.linalg.norm(zero3))