机器学习——回归问题(2020最新版)

我会带着你远行 2023-03-02 05:22 62阅读 0赞

**一、回归的由来**

![20200727233540976.png][]

**二、房价预测问题**

![20200727233613892.png][]![20200727233652585.png][]

![20200727233708635.png][]

**三、一元线性回归定义**

![20200727233736637.png][]

**四、代价函数(cost func)/损失函数(loss func)**

![20200727233808189.png][]

(1) 为什么要使用平方？因为如果使用绝对值来计算误差，不方便计算；平方更准确的计算和衡量。

(2) 代价函数最小，该回归线的拟合效果越好。

(3) 为什么要乘一个1/2? 为了求解的时候更加方便更加好看，其实可以不用乘；比如对该函数求导时，可以和平方的2抵消。

![20200727233854746.png][]

![20200727233906496.png][]

![20200727233927497.png][]

(4) 每一个@1对于一个代价函数值，这里可以看出当@1取1时，代价函数最小。即确定出@1、@0的值了。

![20200727234010737.png][]

(5) 最里面的等高线，代价函数的值最小。

**五、相关系数**

![20200727234114809.png][]

(1) 左图点的分布更加接近直线，相关系数更高。

(2) 当相关系数大于零，正相关；当相关系数小于零，负相关。

**六、决定系数**

![20200727234207403.png][]

(1) 决定系数越接近1，说明他们之间的关系越接近于线性关系；越接近于0，说明他们之间的关系越不接近于线性关系。

**七、梯度下降法**

**7.1 梯度下降法优化过程**

![20200727234302942.png][]

如果是二维的话，同时更新@1和@0，来进行梯度下降。

![2020072723432841.png][]

如果是一维的，也是不断通过梯度下降来改变@1的值从而再来进行梯度下降

![20200727234348438.png][]

![2020072723435749.png][]

(1) 关于学习率，需要一定的经验来选择，不是固定的，且在0~1之间。

(2) 同样有可能陷入局部最小值(at local optima)。

![202007272344368.png][]

**使用梯度下降法来求解线性回归：**

![20200727234450392.png][]

以@0为例，对@0求导：

![20200727234538832.png][]

同样对@1进行求导，多了一个x：

![20200727234554462.png][]

相应结果：

![20200727234608569.png][]

此外，线性回归的代价函数是凸函数

![20200727234631728.png][]

因为使用梯度下降法，总会找到全局最小值(都能走到最低点，即凸函数)

![20200727234655853.png][]

(3) 所以对于，这种非凸函数，只能找到局部极小值，所以无法使用梯度下降法进行优化。

**7.2 使用梯度下降法完成一元线性回归(python)**

import numpy as np
    import matplotlib.pyplot as plt
    
    """
    @desc 使用data.csv数据+梯度下降法进行一元线性回归
    """
    # 载入数据
    data = np.genfromtxt("data.csv", delimiter=",")
    x_data = data[:, 0]
    y_data = data[:, 1]
    plt.scatter(x_data, y_data)
    
    # 学习率(learning rate)
    lr = 0.0001
    # 截距
    b = 0
    # 斜率
    k = 0
    # 最大迭代次数
    epochs = 50
    
    
    # 最小二乘法（计算cost func）
    def compute_error(b, k, x_data, y_data):
        totalError = 0
        for i in range(0, len(x_data)):
            totalError += (y_data[i] - (k * x_data[i] + b)) ** 2
        return totalError / float(len(x_data)) / 2
    
    
    # 梯度下降法
    def gradient_descent_method(x_data, y_data, b, k, lr, epochs):
        # 计算总数据量
        m = float(len(x_data))
        # 循环epochs次
        for i in range(0, len(x_data)):
            b_grad = 0
            k_grad = 0
            # 先求平均再求和
            for j in range(0, len(x_data)):
                b_grad += (1 / m) * (((k * x_data[j]) + b) - y_data[j])
                k_grad += (1 / m) * (((k * x_data[j]) + b) - y_data[j]) * x_data[j]
            # 更新b和k
            b = b - (lr * b_grad)
            k = k - (lr * k_grad)
    
            # 每次迭代5次，输出一次图像,可以更好的看清这个梯度下降的优化过程
            # if i % 5 == 0:
            #     print("epochs:", i)
            #     plt.plot(x_data, y_data, "b.")
            #     plt.plot(x_data, k * x_data + b, "r")
            #     plt.show()
        return b, k
    
    
    print("Starting b={0}, k={1}, error={2}".format(b, k, compute_error(b, k, x_data, y_data)))
    print("Running...")
    b, k = gradient_descent_method(x_data, y_data, b, k, lr, epochs)
    print("After {0}, iterations b={1}, k={2}, error={3}".format(epochs, b, k, compute_error(b, k, x_data, y_data)))
    
    #画图
    #b. b表示blue，颜色是blue;.表示用点的形式画出来，也叫散点图
    plt.plot(x_data, y_data, "b.")
    #默认是线图，红色
    plt.plot(x_data, k*x_data+b, "r")
    plt.show()

最终的优化效果如下：

![20200727234825604.png][]

![20200727234838412.png][]

**7.3 使用sklearn进行一元线性回归(python)**

from sklearn.linear_model import LinearRegression
    import numpy as np
    import matplotlib.pyplot as plt
    
    #载入数据
    data = np.genfromtxt("data.csv", delimiter=",")
    x_data = data[:, 0]
    y_data = data[:, 1]
    plt.scatter(x_data, y_data)
    # plt.show()
    # print(x_data.shape)
    
    x_data = data[:, 0, np.newaxis]
    #当使用np.newaxis加一维，变成二维数组后，这里的x_data相当于1行， 100列的二维数组；
    #之所以要这么做，是因为后面fit函数要求数据类型是这样
    y_data = data[:, 1, np.newaxis]
    #创建并拟合模型
    model = LinearRegression()
    model.fit(x_data, y_data)
    
    #画图
    plt.plot(x_data, y_data, "b.")
    plt.plot(x_data, model.predict(x_data), "r")
    plt.show()

最终的优化效果如下(比上面效果可能还好一些),使用封装包更加简单：

![202007272349445.png][]

**八、矩阵**

![20200727235013852.png][]

![2020072723502371.png][]

**九、多元线性回归**

**9.1 多元线性回归定义**

比如不仅仅只使用房子的面积来判断房子的价格，而使用多个特征：

![20200727235113845.png][]

![20200727235122635.png][]

**9.2 快递送货的实战**

9.2.1 使用梯度下降法实现多元线性回归(python)

![20200727235152486.png][]

# -*- coding: utf-8 -*- #
    """
    -------------------------------------------------------------------------------
      FileName:    gradient_descent_method
      Author:      newlinfeng
      Date:        2020/7/22 0022  11:23
      Description: 使用Delivery.csv数据+梯度下降法进行多元线性回归
    -------------------------------------------------------------------------------
    """
    import numpy as np
    from numpy import genfromtxt
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import Axes3D
    
    # 读入数据
    data = genfromtxt(r"Delivery.csv", delimiter=",")
    print(data)
    
    # 切分数据
    x_data = data[:, :-1]
    y_data = data[:, -1]
    print(x_data)
    print(y_data)
    
    # 学习率learning rate
    lr = 0.0001
    # 参数
    theta0 = 0
    theta1 = 0
    theta2 = 0
    # 最大迭代次数
    epochs = 1000
    
    
    # 最小二乘法
    def compute_error(theta0, theta1, theta2, x_data, y_data):
        totalError = 0
        for i in range(0, len(x_data)):
            totalError += (y_data[i] - (theta1 * x_data[i, 0] + theta2 * x_data[i, 1] + theta0)) ** 2
        return totalError / float(len(x_data))
    
    #cost func
    def gradient_descent_runner(x_data, y_data, theta1, theta2, theta0, lr, epochs):
        # 计算总量数据
        m = float(len(x_data))
        # 循环epochs次
        for i in range(epochs):
            theta0_grad = 0
            theta1_grad = 0
            theta2_grad = 0
            # 计算梯度的总和再求平均
            for j in range(0, len(x_data)):
                theta0_grad += -(1 / m) * (y_data[j] - (theta1 * x_data[j, 0] + theta2 * x_data[j, 1] + theta0))
                theta1_grad += -(1 / m) * (y_data[j] - (theta1 * x_data[j, 0] + theta2 * x_data[j, 1] + theta0)) * x_data[
                    j, 0]
                theta2_grad += -(1 / m) * (y_data[j] - (theta1 * x_data[j, 0] + theta2 * x_data[j, 1] + theta0)) * x_data[
                    j, 1]
            #更新theta0,theta1,theta2
            theta0 -= lr*theta0_grad
            theta1 -= lr*theta1_grad
            theta2 -= lr*theta2_grad
    
        return theta0, theta1, theta2
    
    print("Starting theta0 = {0}, theta1 = {1}, theta2 = {2}, error = {3}"
          .format(theta0, theta1, theta2, compute_error(theta0, theta1, theta2, x_data, y_data)))
    print("Running...")
    theta0, theta1, theta2 = gradient_descent_runner(x_data, y_data, theta1, theta2, theta0, lr, epochs)
    print("After {0} iterations theta0 = {1}, theta1 = {2}, theta2 = {3}, error = {4}".format(
        epochs, theta0, theta1, theta2, compute_error(theta0, theta1, theta2, x_data, y_data)
    ))
    
    #3D图展示
    ax = plt.figure().add_subplot(111, projection = '3d')
    ax.scatter(x_data[:, 0], x_data[:, 1], y_data, c = 'r', marker = 'o', s = 100)
    x0 = x_data[:, 0]
    x1 = x_data[:, 1]
    #生成网格矩阵
    x0, x1 = np.meshgrid(x0, x1)
    z = theta0 + theta1*x0+theta2*x1
    #画3D图
    ax.plot_surface(x0, x1, z)
    #设置坐标轴
    ax.set_xlabel("Mills")
    ax.set_ylabel("Num of Deliveries")
    ax.set_zlabel("Time")
    #显示图像
    plt.show()

最终拟合的结果如下：

![20200727235248764.png][]

9.2.2 使用梯度下降法实现多元线性回归(python)

# -*- coding: utf-8 -*- #
    """
    -------------------------------------------------------------------------------
      FileName:    sklearn_method_mult
      Author:      newlinfeng
      Date:        2020/7/22 0022  15:04
      Description: 使用Delivery.csv数据+sklearn法进行多元线性回归
    -------------------------------------------------------------------------------
    """
    
    import numpy as np
    from numpy import genfromtxt
    from sklearn import linear_model
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import Axes3D
    
    #读入数据
    data = np.genfromtxt("Delivery.csv", delimiter=",")
    print(data)
    
    #切分数据
    x_data = data[:, :-1]
    y_data = data[:, -1]
    print(x_data)
    print(y_data)
    
    #创建模型
    model = linear_model.LinearRegression()
    model.fit(x_data, y_data)
    
    #系数
    print("coefficients:", model.coef_)
    #截距
    print("intercept:", model.intercept_)
    #测试
    x_test = [[102, 4]]
    predict = model.predict(x_test)
    print("predict:", predict)
    
    #3D图展示
    ax = plt.figure().add_subplot(111, projection = '3d')
    ax.scatter(x_data[:, 0], x_data[:, 1], y_data, c = 'r', marker = 'o', s = 100)
    x0 = x_data[:, 0]
    x1 = x_data[:, 1]
    #生成网格矩阵
    x0, x1 = np.meshgrid(x0, x1)
    z = model.intercept_ + model.coef_[0]*x0+model.coef_[1]*x1
    #画3D图
    ax.plot_surface(x0, x1, z)
    #设置坐标轴
    ax.set_xlabel("Mills")
    ax.set_ylabel("Num of Deliveries")
    ax.set_zlabel("Time")
    #显示图像
    plt.show()

最终拟合的结果如下，效果和梯度下降类似：

![20200727235347386.png][]

**九、多项式回归**

![20200727235418673.png][]

![2020072723543029.png][]

![20200727235438235.png][]

**十、标准方程法(直接求解出这个cost func的最小值，之前的梯度下降是使用一种不断逼近的方法来找到最小值)**

(1) 标准方程法是解决线性回归的另一种方法(上面提到是都是梯度下降法)；

![20200727235517537.png][]

例如，同样是房子的价格和面积、卧室数量、层数、已使用年数等数据的关系，如下表：

![20200727235533711.png][]

X：样本的特征    w：权值参数，类似上面的a,b    y：结果：

![2020072723554998.png][]

**10.1 这里还有两个概念：分子布局、分母布局**

(1) 查询矩阵计算(求导方法)：[https://en.wikipedia.org/wiki/Matrix\_calculus\#Scalar-by-vector\_identities][https_en.wikipedia.org_wiki_Matrix_calculus_Scalar-by-vector_identities]

![20200727235642229.png][]

![20200727235652369.png][]

其中：

![20200727235714711.png][]

然后再整理得到，即得出最后的w矩阵的值：

![20200727235727406.png][]

**10.2 矩阵不可逆的情况**

下面这两种情况，标准方程法无法使用：

![20200727235802584.png][]

**十一、梯度下降法 VS 标准方程法**

![20200727235834511.png][]

(1) sklearn使用的是标准方程法进行的封装，而不是梯度下降法

**11.1 使用标准方程法实现一元线性回归**

# -*- coding: utf-8 -*- #
    """
    -------------------------------------------------------------------------------
      FileName:    sem_univariate_method
      Author:      newlinfeng
      Date:        2020/7/22 0022  23:04
      Description: 使用标准方程法来进行一元线性回归
    -------------------------------------------------------------------------------
    """
    import numpy as np
    from numpy import genfromtxt
    import matplotlib.pyplot as plt
    
    #载入数据
    data = np.genfromtxt("data.csv", delimiter=",")
    x_data = data[:, 0, np.newaxis]
    y_data = data[:, 1, np.newaxis]
    plt.scatter(x_data, y_data)
    plt.show()
    
    print(np.mat(x_data).shape)
    print(np.mat(y_data).shape)
    #给样本添加偏执项
    X_data = np.concatenate((np.ones((100, 1)), x_data), axis=1)
    print(X_data.shape)
    
    print(X_data[:3])
    
    #标准方程法求解回归参数
    def weights(xArr, yArr):
        xMat = np.mat(xArr)
        yMat = np.mat(yArr)
        xTx = xMat.T*xMat #矩阵乘法, .T是转置矩阵的意思
        #计算矩阵对应的行列式的值，如果值为0，说明该矩阵没有逆矩阵
        if np.linalg.det(xTx) == 0.0:
            print("This matrix cannot do inverse")
            return
        # xTx,T为XTx的可逆矩阵
        ws = xTx.I*xMat.T*yMat
        return ws
    
    
    ws = weights(X_data, y_data)
    print(ws)
    
    
    #画图
    x_test = np.array([[20], [80]])
    y_test = ws[0] +x_test*ws[1]
    plt.plot(x_data, y_data, 'b.')
    plt.plot(x_test, y_test, 'r')
    plt.show()

![20200727235925656.png][]

**十二、特征缩放、交叉验证法**

**12.1 特征缩放**

![20200728000016506.png][]

![20200728000025730.png][]

由于特征的不太一致，使用梯度下降法花费时间长，所以要进行预处理

**12.2 进行预处理的方式有两种：数据归一化、均值标准化**

**方法1：数据归一化**

![20200728000121123.png][]

**方法2：均值标准化**

![2020072800014438.png][]

**12.3 交叉验证法**

当数据量很小的时候可以采用这种方式，使用每个部分都作为测试集，其余作为验证集，再求平均得到相应的结果。

![20200728000218924.png][]

**十三、过拟合(Overfitting)、正则化(Regularized)**

**13.1 过拟合(Overfitting)**

回归的情况：

![20200728081538791.png][]

分类的情况：

![2020072808155883.png][]

防止过拟合的方式：

*  减少特征（有些特征可能没有特别大的用处或者直接是噪声）
 *  增加数据量
 *  正则化(Regularized)

**13.2 正则化(Regularized)**

![20200728081657552.png][]

**十四、岭回归(Ridge Regression)**

![20200728081735413.png][]

下面是岭回归的代价函数：

![20200728081752983.png][]

![20200728081807909.png][]

![20200728081816821.png][]

**14.1 使用python实现岭回归**

使用的数据集：Longley数据集：

![20200728081852960.png][]

使用sklearn实现岭回归：

# -*- coding: utf-8 -*- #
    """
    -------------------------------------------------------------------------------
      FileName:    rid_sklearn_method
      Author:      newlinfeng
      Date:        2020/7/26 0026  11:28
      Description: 使用sklearn算法实现岭回归
    -------------------------------------------------------------------------------
    """
    import numpy as np
    from numpy import genfromtxt
    from sklearn import linear_model
    import matplotlib.pyplot as plt
    
    #读入数据
    data = genfromtxt(r"longley.csv", delimiter=",")
    
    #切分数据
    x_data = data[1:, 2:]
    y_data = data[1:, 1]
    
    #创建模型
    #生成50个值
    alphas_to_test = np.linspace(0.001, 1)
    #创建模型，保存误差值
    model = linear_model.RidgeCV(alphas=alphas_to_test, store_cv_values=True)
    model.fit(x_data, y_data)
    
    #岭系数
    print(model.alpha_)
    #loss值
    print(model.cv_values_.shape)
    
    #画图
    #岭系数跟loss值的关系
    plt.plot(alphas_to_test, model.cv_values_.mean(axis=0))
    #选取的岭系数值的位置
    plt.plot(model.alpha_, min(model.cv_values_.mean(axis=0)), "ro")
    plt.show()
    
    model.predict(x_data[2, np.newaxis])

![20200728081931502.png][]

使用方程法实现岭回归：

使用该公式求解：

![20200728081953788.png][]

# -*- coding: utf-8 -*- #
    """
    -------------------------------------------------------------------------------
      FileName:    rid_standard_equation_method
      Author:      newlinfeng
      Date:        2020/7/27 0027  17:15
      Description: 使用标准方程法实现岭回归
    -------------------------------------------------------------------------------
    """
    import numpy as np
    from numpy import genfromtxt
    import matplotlib.pyplot as plt
    
    # 读入数据
    data = genfromtxt(r"longley.csv", delimiter=",")
    
    # 切分数据
    x_data = data[1:, 2:]
    y_data = data[1:, 1, np.newaxis]
    
    # 给样本x_data添加一行偏置值
    X_data = np.concatenate((np.ones((16, 1)), x_data), axis=1)
    
    
    # 标准方程法求解回归系数
    def weights(xArr, yArr, lam=0.2):
        x_Mat = np.mat(xArr)
        y_Mat = np.mat(yArr)
        xTx = x_Mat.T * x_Mat
        # eye()：用来生成单位矩阵，传入i的化就生成i*i的单位矩阵，这个shape[1]的值是7
        # 为什么是7？ 因为xTx是7*7列
        rxTx = xTx + np.eye(x_Mat.shape[1]) * lam
        # 计算矩阵的值，如果值为0，说明该矩阵没有逆矩阵
        if np.linalg.det(rxTx) == 0.0:
            print("This matrix cannot do inverse")
            return
        # xTx.I为xTx的逆矩阵
        ws = rxTx.I * x_Mat.T * y_Mat
        return ws
    
    ws = weights(X_data, y_data)
    
    #计算预测值
    results = np.mat(X_data)*np.mat(ws)
    print(results)

最终得到的预测结果与实际的结果差别很小：

![20200728082046726.png][]

**15.LASSO(The Least Absolute Shrinkage and Selectionator operator)**

Lasso:最小绝对收缩与选择算子：

![20200728082135943.png][]

![20200728082147354.png][]

(1) 这里就很明显的看出，岭回归使用的是L2正则化，LASSO使用的是L1正则化。

![20200728082221940.png][]

(2) 由上图可以看出，Lasso很容易使得某个参数取值为0(左图@1就已经取值为0了)，而岭回归则很难。

![20200728082250904.png][]

**15.1 使用python实现Lasso回归**

使用sklearn实现LASSO回归：

# -*- coding: utf-8 -*- #
    """
    -------------------------------------------------------------------------------
      FileName:    las_sklearn_mathod
      Author:      newlinfeng
      Date:        2020/7/27 0027  22:21
      Description: 使用sklearn实现LASSO回归
    -------------------------------------------------------------------------------
    """
    import numpy as np
    from numpy import genfromtxt
    from sklearn import linear_model
    
    #读入数据
    data = genfromtxt(r"longley.csv", delimiter=",")
    
    #切分数据
    x_data = data[1:, 2:]
    y_data = data[1:, 1]
    
    #创建模型
    model = linear_model.LassoCV()
    model.fit(x_data, y_data)
    
    #LASSON系数
    print(model.alpha_)
    #系数
    print(model.coef_)
    
    model.predict(x_data[-2, np.newaxis])

![20200728082342869.png][]

**十六、弹性网(Elastic Net)**

![20200728082408627.png][]

![20200728082436761.png][]

(1) 所以从该公式出发，既然集合了岭回归和LASSO，那么应该表现出更好的效果。

使用sklearn实现弹性网络：

# -*- coding: utf-8 -*- #
    """
    -------------------------------------------------------------------------------
      FileName:    elas_sklearn_method
      Author:      newlinfeng
      Date:        2020/7/27 0027  22:55
      Description: 使用sklearn实现elastic net（弹性网络）
    -------------------------------------------------------------------------------
    """
    import numpy as np
    from numpy import genfromtxt
    from sklearn import linear_model
    
    #读入数据
    data = genfromtxt(r"longley.csv", delimiter=",")
    
    #切分数据
    x_data = data[1:, 2:]
    y_data = data[1:, 1]
    
    #创建模型
    model = linear_model.ElasticNetCV()
    model.fit(x_data, y_data)
    
    #elastic net系数
    print(model.alpha_)
    #每个特征系数
    print(model.coef_)
    
    #取x_data的-2行数据进行预测
    model.predict(x_data[-2, np.newaxis])

![2020072808252869.png][]

**到这里回归问题基本结束，接下来的逻辑回归实际上属于分类问题。**

**2020-07-28更新**

[20200727233540976.png]: /images/20230208/0c23b15fc77c4070bf12d9831af7109a.png
[20200727233613892.png]: https://img-blog.csdnimg.cn/20200727233613892.png
[20200727233652585.png]: /images/20230208/3b30c60cabd04204ac28f84003dcd742.png
[20200727233708635.png]: /images/20230208/11ab8027ac5b410b9ba35fc866f44a6d.png
[20200727233736637.png]: /images/20230208/7912e576aa904bb289d5c276959c0a31.png
[20200727233808189.png]: /images/20230208/79a18a9dfc0b487681bc292a37062f02.png
[20200727233854746.png]: /images/20230208/59584252f4224df79fae1431640af5bb.png
[20200727233906496.png]: /images/20230208/6bb746cf80034b449ea7a79701f74349.png
[20200727233927497.png]: /images/20230208/28e72c90cc5e4da4a48af32e31a77977.png
[20200727234010737.png]: /images/20230208/2f5e0fbae4fe48d6a72c93f1da18176f.png
[20200727234114809.png]: /images/20230208/babd652a2d434b7cbadda337caeb3e4a.png
[20200727234207403.png]: /images/20230208/ccd5f8c07f5d49ab99021de0e97a0b09.png
[20200727234302942.png]: /images/20230208/fb0b278f5dfc488da16fd1d0b41f295f.png
[2020072723432841.png]: /images/20230208/ff2bdb2b833f46848cfee47c8fab1bdd.png
[20200727234348438.png]: /images/20230208/49c0c260a60840d9bd4030a3479ab19e.png
[2020072723435749.png]: /images/20230208/a400476931d84f308a915fe7e8bc5361.png
[202007272344368.png]: /images/20230208/3a55aaec9e8c44a4bb852dba458e9c00.png
[20200727234450392.png]: /images/20230208/e21c3113c8124b418812647dbab6bab5.png
[20200727234538832.png]: /images/20230208/c8f501ed6d8d4928a4ca806d094eb336.png
[20200727234554462.png]: /images/20230208/d4f75c2a0dfd44b4882c48bfe05670a6.png
[20200727234608569.png]: /images/20230208/2b5dc74e8a6f49fc9e999ed546e7e650.png
[20200727234631728.png]: /images/20230208/3e8355a3efca405ba4d65a1f371a38b2.png
[20200727234655853.png]: /images/20230208/6448b73742b74a888636171418afa736.png
[20200727234825604.png]: /images/20230208/2407b268225641b3afdcc3e2f0ae05ad.png
[20200727234838412.png]: /images/20230208/51a159323a4c48cc949d0fed70d4018f.png
[202007272349445.png]: /images/20230208/4a2da7c43fe44e5695a59344c6ab5afc.png
[20200727235013852.png]: /images/20230208/96914bb3b0314c0384fed30e16010282.png
[2020072723502371.png]: /images/20230208/6d08ec1f5d524c96818b86363b5e0c9d.png
[20200727235113845.png]: /images/20230208/233be9f5b7b444ce928ba880936f1864.png
[20200727235122635.png]: /images/20230208/1d98be58d2fd42b68f6f677150343359.png
[20200727235152486.png]: /images/20230208/2b227019ebf14cbfba887112b8e98c50.png
[20200727235248764.png]: /images/20230208/ec1969605e6943b18a0835b95af7d7e4.png
[20200727235347386.png]: /images/20230208/a40a2df2277a44ff91f443aac9714016.png
[20200727235418673.png]: /images/20230208/e229446b2c3d41c9ab1b32089c0ce44e.png
[2020072723543029.png]: /images/20230208/184e44bee6d1469b9c3fde749ae9894c.png
[20200727235438235.png]: /images/20230208/c5a5b8d5bf044df992d8ca83e63d0d66.png
[20200727235517537.png]: /images/20230208/ecf2700b5a8e4ab281d81329ec82fad7.png
[20200727235533711.png]: /images/20230208/d04ff53a3eaf4b58b5cba81d77353bc2.png
[2020072723554998.png]: /images/20230208/ba691a252061478baee305bb58532c0e.png
[https_en.wikipedia.org_wiki_Matrix_calculus_Scalar-by-vector_identities]: https://en.wikipedia.org/wiki/Matrix_calculus#Scalar-by-vector_identities
[20200727235642229.png]: /images/20230208/9e37ffc846494509b14eae0fb3b7fe5c.png
[20200727235652369.png]: /images/20230208/1160639d74854ca79d5a8bd0a7c42a69.png
[20200727235714711.png]: /images/20230208/eb09dab9048a419cb0527ab2055478d7.png
[20200727235727406.png]: /images/20230208/36c3446041014af99d3545350e7e898f.png
[20200727235802584.png]: /images/20230208/ca1b47359e7a4d11a12a6e0e02330a92.png
[20200727235834511.png]: /images/20230208/7d3fc85fa69641439080807933c51350.png
[20200727235925656.png]: /images/20230208/1a8089fafd0549938df8abbde520d437.png
[20200728000016506.png]: /images/20230208/74d9343ed77142dd8703fca3d60a766c.png
[20200728000025730.png]: /images/20230208/56bed704720949aead7c7e0f55de912c.png
[20200728000121123.png]: /images/20230208/84ad18e84d76443facc444808f91a6f8.png
[2020072800014438.png]: /images/20230208/e3be9f6d7412417384d073f625b52e6b.png
[20200728000218924.png]: /images/20230208/c26032fa423649b08933de175eee9e3a.png
[20200728081538791.png]: /images/20230208/f3ab4e56d61e4fe88105ee5b604f82f3.png
[2020072808155883.png]: /images/20230208/b3563a62767940fa86d90fb6cca4274a.png
[20200728081657552.png]: /images/20230208/d785a3ef120e47aaa037b0719193342b.png
[20200728081735413.png]: /images/20230208/cf4b340b0ce046c29b0e9e53f8e8d73d.png
[20200728081752983.png]: /images/20230208/34d18e11ff604945b94bd45f6d5c1304.png
[20200728081807909.png]: /images/20230208/0ff84b44f8794ecc80d72690b3fd9f9d.png
[20200728081816821.png]: /images/20230208/c489a67ffc694bb088cef25fe82b0ff5.png
[20200728081852960.png]: /images/20230208/860087fa4d9d4950b01a1d3348762b5f.png
[20200728081931502.png]: /images/20230208/7dd5dca3ed2f408a9676bee10e21840d.png
[20200728081953788.png]: /images/20230208/13db57e364294a2bbc7e075813e9f0d8.png
[20200728082046726.png]: /images/20230208/d6916d641d044f73a29371add6646ec0.png
[20200728082135943.png]: /images/20230208/86c983664e0f400099e755ae39244742.png
[20200728082147354.png]: /images/20230208/12c966de89564516ac4db9646facb8f0.png
[20200728082221940.png]: /images/20230208/ae218a6fa0ac434a91b0f08cab4f0ca1.png
[20200728082250904.png]: /images/20230208/074c8ced541445fbb12e2998dfc4dddf.png
[20200728082342869.png]: /images/20230208/138eed3b8ced49c0b2c4f7ceb49fbdc5.png
[20200728082408627.png]: /images/20230208/250b666289294dc487996a7b7fc30768.png
[20200728082436761.png]: /images/20230208/6b36f6f64dcd41ff831e4b8438039109.png
[2020072808252869.png]: /images/20230208/5085529556c24cb6a62e8e57c5b67491.png