<jupyter_start><jupyter_text>欢迎来到线性回归项目若项目中的题目有困难没完成也没关系，我们鼓励你带着问题提交项目，评审人会给予你诸多帮助。所有选做题都可以不做，不影响项目通过。如果你做了，那么项目评审会帮你批改，也会因为选做部分做错而判定为不通过。其中非代码题可以提交手写后扫描的 pdf 文件，或使用 Latex 在文档中直接回答。  1 矩阵运算 1.1 创建一个 4*4 的单位矩阵<jupyter_code># 这个项目设计来帮你熟悉 python list 和线性代数
# 你不能调用任何NumPy以及相关的科学计算库来完成作业


# 本项目要求矩阵统一使用二维列表表示，如下：
A = [[1,2,3], 
     [2,3,3], 
     [1,2,5]]

B = [[1,2,3,5], 
     [2,3,3,5], 
     [1,2,5,1]]

# 向量也用二维列表表示
C = [[1],
     [2],
     [3]]

#TODO 创建一个 4*4 单位矩阵
I = [[1,0,0,0], 
     [0,1,0,0], 
     [0,0,1,0],
     [0,0,0,1]]<jupyter_output><empty_output><jupyter_text>1.2 返回矩阵的行数和列数<jupyter_code># TODO 返回矩阵的行数和列数
def shape(M):
    return len(M),len(M[0])
# 运行以下代码测试你的 shape 函数
%run -i -e test.py LinearRegressionTestCase.test_shape<jupyter_output>.
----------------------------------------------------------------------
Ran 1 test in 0.006s

OK<jupyter_text>1.3 每个元素四舍五入到特定小数数位<jupyter_code># TODO 每个元素四舍五入到特定小数数位
# 直接修改参数矩阵，无返回值
def matxRound(M, decPts=4):
    if decPts < 0 :
        return
    #遍历出每个元素然后进行round处理
    for i in range(len(M)):
        for j in range(len(M[i])):
            M[i][j] = round(M[i][j],decPts)
    pass
# 运行以下代码测试你的 matxRound 函数
%run -i -e test.py LinearRegressionTestCase.test_matxRound<jupyter_output>.
----------------------------------------------------------------------
Ran 1 test in 0.141s

OK<jupyter_text>1.4 计算矩阵的转置<jupyter_code># TODO 计算矩阵的转置
def transpose(M):
    MT = [list(x) for x in zip(*M) ]
#     print MT
    return MT
# 运行以下代码测试你的 transpose 函数
%run -i -e test.py LinearRegressionTestCase.test_transpose<jupyter_output>.
----------------------------------------------------------------------
Ran 1 test in 0.019s

OK<jupyter_text>1.5 计算矩阵乘法 AB<jupyter_code># TODO 计算矩阵乘法 AB，如果无法相乘则raise ValueError
def matxMultiply(A, B):
    #A的行数与B的列数不等则不能相乘
    if len(A[0])!=len(B):
        raise ValueError
#     res = [[0] for i in range(len(A))]
#     print len(A),len(B[0])
#     for i in range(len(A)):
#         print i
#         for j in range(len(B[0])):
#             print j
#             for k in range(len(B)):
#                 res[i][j] += A[i][k] * B[k][j]
    return [[sum(a * b for a, b in zip(a, b)) for b in zip(*B)] for a in A]

matxMultiply(A,B)
# 运行以下代码测试你的 matxMultiply 函数
%run -i -e test.py LinearRegressionTestCase.test_matxMultiply<jupyter_output>.
----------------------------------------------------------------------
Ran 1 test in 0.228s

OK<jupyter_text>--- 2 Gaussign Jordan 消元法 2.1 构造增广矩阵$ A = \begin{bmatrix}    a_{11}    & a_{12} & ... & a_{1n}\\    a_{21}    & a_{22} & ... & a_{2n}\\    a_{31}    & a_{22} & ... & a_{3n}\\    ...    & ... & ... & ...\\    a_{n1}    & a_{n2} & ... & a_{nn}\\\end{bmatrix} , b = \begin{bmatrix}    b_{1}  \\    b_{2}  \\    b_{3}  \\    ...    \\    b_{n}  \\\end{bmatrix}$返回 $ Ab = \begin{bmatrix}    a_{11}    & a_{12} & ... & a_{1n} & b_{1}\\    a_{21}    & a_{22} & ... & a_{2n} & b_{2}\\    a_{31}    & a_{22} & ... & a_{3n} & b_{3}\\    ...    & ... & ... & ...& ...\\    a_{n1}    & a_{n2} & ... & a_{nn} & b_{n} \end{bmatrix}$<jupyter_code># TODO 构造增广矩阵，假设A，b行数相同
def augmentMatrix(A, b):
    return [ra+rb for ra,rb in zip(A,b)]
# 运行以下代码测试你的 augmentMatrix 函数
%run -i -e test.py LinearRegressionTestCase.test_augmentMatrix<jupyter_output>.
----------------------------------------------------------------------
Ran 1 test in 0.012s

OK<jupyter_text>2.2 初等行变换- 交换两行- 把某行乘以一个非零常数- 把某行加上另一行的若干倍：<jupyter_code># TODO r1 <---> r2
# 直接修改参数矩阵，无返回值
def swapRows(M, r1, r2):
    M[r1],M[r2] = M[r2],M[r1]
    pass
# 运行以下代码测试你的 swapRows 函数
%run -i -e test.py LinearRegressionTestCase.test_swapRows
# TODO r1 <--- r1 * scale
# scale为0是非法输入，要求 raise ValueError
# 直接修改参数矩阵，无返回值
def scaleRow(M, r, scale):
    if scale == 0:
        raise ValueError
    for i in range(len(M[r])):
            M[r][i] *= scale
    pass
# 运行以下代码测试你的 scaleRow 函数
%run -i -e test.py LinearRegressionTestCase.test_scaleRow
# TODO r1 <--- r1 + r2*scale
# 直接修改参数矩阵，无返回值
def addScaledRow(M, r1, r2, scale):
     M[r1] = [i+j*scale for i,j in zip(M[r1],M[r2])]
#     pass
# 运行以下代码测试你的 addScaledRow 函数
%run -i -e test.py LinearRegressionTestCase.test_addScaledRow<jupyter_output>.
----------------------------------------------------------------------
Ran 1 test in 0.003s

OK<jupyter_text>2.3  Gaussian Jordan 消元法求解 Ax = b  2.3.1 算法步骤1 检查A，b是否行数相同步骤2 构造增广矩阵Ab步骤3 逐列转换Ab为化简行阶梯形矩阵 [中文维基链接](https://zh.wikipedia.org/wiki/%E9%98%B6%E6%A2%AF%E5%BD%A2%E7%9F%A9%E9%98%B5.E5.8C.96.E7.AE.80.E5.90.8E.E7.9A.84-.7Bzh-hans:.E8.A1.8C.3B_zh-hant:.E5.88.97.3B.7D-.E9.98.B6.E6.A2.AF.E5.BD.A2.E7.9F.A9.E9.98.B5)        对于Ab的每一列（最后一列除外）        当前列为列c        寻找列c中 对角线以及对角线以下所有元素（行 c~N）的绝对值的最大值        如果绝对值最大值为0            那么A为奇异矩阵，返回None (你可以在选做问题2.4中证明为什么这里A一定是奇异矩阵)        否则            使用第一个行变换，将绝对值最大值所在行交换到对角线元素所在行（行c）             使用第二个行变换，将列c的对角线元素缩放为1            多次使用第三个行变换，将列c的其他元素消为0            步骤4 返回Ab的最后一列**注：** 我们并没有按照常规方法先把矩阵转化为行阶梯形矩阵，再转换为化简行阶梯形矩阵，而是一步到位。如果你熟悉常规方法的话，可以思考一下两者的等价性。  2.3.2 算法推演为了充分了解Gaussian Jordan消元法的计算流程，请根据Gaussian Jordan消元法，分别手动推演矩阵A为***可逆矩阵***，矩阵A为***奇异矩阵***两种情况。<jupyter_code># 不要修改这里！
from helper import *

A = generateMatrix(4,seed,singular=False)
b = np.ones(shape=(4,1)) # it doesn't matter
Ab = augmentMatrix(A.tolist(),b.tolist()) # please make sure you already correct implement augmentMatrix
printInMatrixFormat(Ab,padding=4,truncating=0)<jupyter_output>7,   5,   3,  -5 ||  1  
  -4,   6,   2,  -2 ||  1  
  -9,   4,  -5,   9 ||  1  
  -9, -10,   5,  -4 ||  1<jupyter_text>请按照算法的步骤3，逐步推演***可逆矩阵***的变换。在下面列出每一次循环体执行之后的增广矩阵。要求：1. 做分数运算2. 使用`\frac{n}{m}`来渲染分数，如下： - $\frac{n}{m}$ - $-\frac{a}{b}$增广矩阵$ Ab = \begin{bmatrix}    7 & 5 & 3 & -5 & 1\\    -4 & 6 & 2 & -2 & 1\\    -9 & 4 & -5 & 9 & 1\\    -9 & -10 & 5 & -4 & 1\end{bmatrix}$    第一次初等变换$ --> \begin{bmatrix}  -9 & 4 & -5 & 9 & 1\\    -4 & 6 & 2 & -2 & 1\\    7 & 5 & 3 & -5 & 1\\    -9 & -10 & 5 & -4 & 1\end{bmatrix}$    $ --> \begin{bmatrix}    1 & -\frac{4}{9} & \frac{5}{9} & -1 & -\frac{1}{9}\\     -4 & 6 & 2 & -2 & 1\\    7 & 5 & 3 & -5 & 1\\    -9 & -10 & 5 & -4 & 1\end{bmatrix}$    $ --> \begin{bmatrix}    1 & -\frac{4}{9} & \frac{5}{9} & -1 & -\frac{1}{9}\\    0 & \frac{38}{9} & \frac{38}{9} & -6 & \frac{5}{9}\\    0 & \frac{73}{9} & -\frac{8}{9} & 2 & \frac{16}{9}\\    0 & -14 & 10 & -13 & 0\end{bmatrix}$    第二次变换$ --> \begin{bmatrix}    1 & -\frac{4}{9} & \frac{5}{9} & -1 & -\frac{1}{9}\\    0 & -14 & 10 & -13 & 0\\    0 & \frac{73}{9} & -\frac{8}{9} & 2 & \frac{16}{9}\\     0 & \frac{38}{9} & \frac{38}{9} & -6 & \frac{5}{9}\end{bmatrix}$ $ --> \begin{bmatrix}    1 & -\frac{4}{9} & \frac{5}{9} & -1 & -\frac{1}{9}\\    0 & 1 & -\frac{5}{7} & \frac{13}{14} & 0\\    0 & \frac{73}{9} & -\frac{8}{9} & 2 & \frac{16}{9}\\     0 & \frac{38}{9} & \frac{38}{9} & -6 & \frac{5}{9}\end{bmatrix}$     $ --> \begin{bmatrix}    1 & 0 & -\frac{5}{21} & -\frac{37}{63} & -\frac{1}{9}\\    0 & 1 & -\frac{5}{7} & \frac{13}{14} & 0\\    0 & 0 & \frac{103}{21} & -\frac{697}{126} & \frac{16}{9}\\     0 & 0 & \frac{152}{21} & -\frac{625}{63} & \frac{5}{9}\end{bmatrix}$     第三步变换$ --> \begin{bmatrix}    1 & 0 & -\frac{5}{21} & -\frac{37}{63} & -\frac{1}{9}\\    0 & 1 & -\frac{5}{7} & \frac{13}{14} & 0\\    0 & 0 & 1 & -\frac{152}{21} & \frac{625}{63}\\     0 & 0 & \frac{103}{21} & -\frac{697}{126} & \frac{16}{9}\end{bmatrix}$    $ --> \begin{bmatrix}    1 & 0 & 0 & -\frac{119}{456} & -\frac{59}{456}\\    0 & 1 & 0 & \frac{23}{456} & \frac{25}{456}\\    0 & 0 & 1 & -\frac{625}{456} & \frac{35}{456}\\     0 & 0 & 0 & \frac{181}{152} & \frac{213}{152}\end{bmatrix}$         第四步变换$ --> \begin{bmatrix}    1 & 0 & 0 & -\frac{119}{456} & -\frac{59}{456}\\    0 & 1 & 0 & \frac{23}{456} & \frac{25}{456}\\    0 & 0 & 1 & -\frac{625}{456} & \frac{35}{456}\\     0 & 0 & 0 & \1 & \frac{213}{181}\end{bmatrix}$$ --> \begin{bmatrix}    1 & 0 & 0 & 0 & \frac{193}{1086}\\    0 & 1 & 0 & 0 & \frac{62}{543}\\    0 & 0 & 1 & 0 & \frac{1835}{1086}\\     0 & 0 & 0 & 1 & \frac{213}{181}\end{bmatrix}$     所以X = $[\frac{193}{1086},\frac{62}{543},\frac{1835}{1086},\frac{213}{181}]$    $...$<jupyter_code># 不要修改这里！
A = generateMatrix(4,seed,singular=True)
b = np.ones(shape=(4,1)) # it doesn't matter
Ab = augmentMatrix(A.tolist(),b.tolist()) # please make sure you already correct implement augmentMatrix
printInMatrixFormat(Ab,padding=4,truncating=0)<jupyter_output>-7,  -3,   1,  -9 ||  1  
   0,   0,   0,   0 ||  1  
  -2,   7,   7,  -3 ||  1  
   8,  -5,  -6,   3 ||  1<jupyter_text>请按照算法的步骤3，逐步推演***奇异矩阵***的变换。在下面列出每一次循环体执行之后的增广矩阵。要求：1. 做分数运算2. 使用`\frac{n}{m}`来渲染分数，如下： - $\frac{n}{m}$ - $-\frac{a}{b}$增广矩阵$ Ab = \begin{bmatrix}    -7 & -3 & 1 & -9 & 1\\    0 & 0 & 0 & 0 & 1\\    -2 & 7 & 7 & -3 & 1\\    8 & -5 & -6 & 3 & 1\end{bmatrix}$$ --> \begin{bmatrix}     1 & -\frac{5}{8} & -\frac{6}{8} & \frac{3}{8} & \frac{1}{8}\\    0 & 0 & 0 & 0 & 1\\    0 & \frac{23}{4} & \frac{11}{2} & -\frac{9}{4}& \frac{5}{4}\\    0 & \frac{11}{8} & \frac{25}{4} & -\frac{93}{8} & \frac{1}{8}\end{bmatrix}$    $ --> \begin{bmatrix}     1 & 0 & -\frac{7}{46} & \frac{3}{23} & \frac{6}{23}\\    0 & 1 & \frac{22}{23} & -\frac{9}{23} & \frac{5}{23}\\    0 & 0 & \frac{227}{46} & -\frac{255}{23}& -\frac{4}{23}\\    0 & 0 & 0 & 0 & 1\end{bmatrix}$    $ --> \begin{bmatrix}     1 & 0 & 0 & -\frac{48}{227} & \frac{58}{227}\\    0 & 1 & 0 & \frac{399}{227} & \frac{57}{227}\\    0 & 0 & 1 & -\frac{510}{227}& -\frac{8}{227}\\    0 & 0 & 0 & 0 & 1\end{bmatrix}$        bmatrix[4][4]=0,所以为奇异矩阵    $...$  2.3.3 实现 Gaussian Jordan 消元法<jupyter_code># TODO 实现 Gaussain Jordan 方法求解 Ax = b

""" Gaussian Jordan 方法求解 Ax = b.
    参数
        A: 方阵 
        b: 列向量
        decPts: 四舍五入位数，默认为4
        epsilon: 判读是否为0的阈值，默认 1.0e-16
        
    返回列向量 x 使得 Ax = b 
    返回None，如果 A，b 高度不同
    返回None，如果 A 为奇异矩阵
"""

def gj_Solve(A, b, decPts=4, epsilon = 1.0e-16):
#     1、 检查A，b行数是否相同
    if len(A) != len(b):
        return None
        
#     2、构造增广矩阵Ab
    Ab = augmentMatrix(A,b)
    """
   3、逐列转换Ab为化简行阶梯形矩阵
 对于Ab的每一列（最后一列除外）
        当前列为列c
        寻找列c中 对角线以及对角线以下所有元素（行 c~N）的绝对值的最大值
        如果绝对值最大值为0
            那么A为奇异矩阵，返回None (你可以在选做问题2.4中证明为什么这里A一定是奇异矩阵)
        否则
            使用第一个行变换，将绝对值最大值所在行交换到对角线元素所在行（行c） 
            使用第二个行变换，将列c的对角线元素缩放为1
            多次使用第三个行变换，将列c的其他元素消为0
     """
    shapeA = shape(Ab)#return 行数，列数
    #获得行列
    row = shapeA[0]
    column = shapeA[1]-1
    
    for columnIndex in range(column):
        currentIndex = columnIndex
        maxValue = 0
        rowForMaxValue = currentIndex
        for rowIndex in range(currentIndex,row):
            #取对角线下最大值
            value = abs(Ab[rowIndex][currentIndex])
            if value > maxValue:
                maxValue = value
                rowForMaxValue = rowIndex
                
        #对最大值进行比较
        if maxValue < epsilon:
            return None
        #否则进行行变换
        swapRows(Ab,currentIndex,rowForMaxValue)
        scaleRow(Ab,currentIndex,1.0/Ab[currentIndex][columnIndex])
        
        for rowIndex in range(row):
            if rowIndex == currentIndex:
                continue
            addScaledRow(Ab, rowIndex, currentIndex, -Ab[rowIndex][columnIndex])
    #4 返回Ab的最后一列
    
    return [[Ab[i][len(Ab[0])-1]] for i in range(len(Ab))] 


gj_Solve(A,b)
# 运行以下代码测试你的 gj_Solve 函数
%run -i -e test.py LinearRegressionTestCase.test_gj_Solve<jupyter_output><empty_output><jupyter_text>(选做) 2.4 算法正确判断了奇异矩阵：在算法的步骤3 中，如果发现某一列对角线和对角线以下所有元素都为0，那么则断定这个矩阵为奇异矩阵。我们用正式的语言描述这个命题，并证明为真。证明下面的命题：**如果方阵 A 可以被分为4个部分: ** $ A = \begin{bmatrix}    I    & X \\    Z    & Y \\\end{bmatrix} , \text{其中 I 为单位矩阵，Z 为全0矩阵，Y 的第一列全0}$，**那么A为奇异矩阵。**提示：从多种角度都可以完成证明- 考虑矩阵 Y 和 矩阵 A 的秩- 考虑矩阵 Y 和 矩阵 A 的行列式- 考虑矩阵 A 的某一列是其他列的线性组合 TODO 证明：  3  线性回归  3.1 随机生成样本点<jupyter_code># 不要修改这里！
# 运行一次就够了！
from helper import *
from matplotlib import pyplot as plt
%matplotlib inline

X,Y = generatePoints(seed,num=100)

## 可视化
plt.xlim((-5,5))
plt.xlabel('x',fontsize=18)
plt.ylabel('y',fontsize=18)
plt.scatter(X,Y,c='b')
plt.show()<jupyter_output><empty_output><jupyter_text>3.2 拟合一条直线 3.2.1 猜测一条直线<jupyter_code>#TODO 请选择最适合的直线 y = mx + b
m = 3.25
b = 6.6

# 不要修改这里！
plt.xlim((-5,5))
x_vals = plt.axes().get_xlim()
y_vals = [m*x+b for x in x_vals]
plt.plot(x_vals, y_vals, '-', color='r')

plt.xlabel('x',fontsize=18)
plt.ylabel('y',fontsize=18)
plt.scatter(X,Y,c='b')

plt.show()<jupyter_output>/usr/local/lib/python2.7/site-packages/matplotlib/cbook/deprecation.py:106: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.
  warnings.warn(message, mplDeprecation, stacklevel=1)<jupyter_text>3.2.2 计算平均平方误差 (MSE) 我们要编程计算所选直线的平均平方误差(MSE), 即数据集中每个点到直线的Y方向距离的平方的平均数，表达式如下：$$MSE = \frac{1}{n}\sum_{i=1}^{n}{(y_i - mx_i - b)^2}$$<jupyter_code># TODO 实现以下函数并输出所选直线的MSE

def calculateMSE(X,Y,m,b):
    MSE = 0 ;
    for i in range(len(X)):
        MSE +=(Y[i]-m*X[i]-b)*(Y[i]-m*X[i]-b)
    
    return MSE/len(X)

print(calculateMSE(X,Y,m,b))<jupyter_output>1.71051514231<jupyter_text>3.2.3 调整参数 $m, b$ 来获得最小的平方平均误差你可以调整3.2.1中的参数 $m,b$ 让蓝点均匀覆盖在红线周围，然后微调 $m, b$ 让MSE最小。  3.3 (选做) 找到参数 $m, b$ 使得平方平均误差最小**这一部分需要简单的微积分知识(  $ (x^2)' = 2x $ )。因为这是一个线性代数项目，所以设为选做。**刚刚我们手动调节参数，尝试找到最小的平方平均误差。下面我们要精确得求解 $m, b$ 使得平方平均误差最小。定义目标函数 $E$ 为$$E = \frac{1}{2}\sum_{i=1}^{n}{(y_i - mx_i - b)^2}$$因为 $E = \frac{n}{2}MSE$, 所以 $E$ 取到最小值时，$MSE$ 也取到最小值。要找到 $E$ 的最小值，即要找到 $m, b$ 使得 $E$ 相对于 $m$, $E$ 相对于 $b$ 的偏导数等于0. 因此我们要解下面的方程组。$$\begin{cases}\displaystyle\frac{\partial E}{\partial m} =0 \\\\\displaystyle\frac{\partial E}{\partial b} =0 \\\end{cases}$$ 3.3.1 计算目标函数相对于参数的导数首先我们计算两个式子左边的值证明/计算：$$\frac{\partial E}{\partial m} = \sum_{i=1}^{n}{-x_i(y_i - mx_i - b)}$$$$\frac{\partial E}{\partial b} = \sum_{i=1}^{n}{-(y_i - mx_i - b)}$$ TODO 证明:  3.3.2 实例推演现在我们有了一个二元二次方程组$$\begin{cases}\displaystyle\sum_{i=1}^{n}{-x_i(y_i - mx_i - b)} =0 \\\\\displaystyle\sum_{i=1}^{n}{-(y_i - mx_i - b)} =0 \\\end{cases}$$为了加强理解，我们用一个实际例子演练。我们要用三个点 $(1,1), (2,2), (3,2)$ 来拟合一条直线 y = m*x + b, 请写出- 目标函数 $E$, - 二元二次方程组，- 并求解最优参数 $m, b$ TODO 写出目标函数，方程组和最优参数  3.3.3 将方程组写成矩阵形式我们的二元二次方程组可以用更简洁的矩阵形式表达，将方程组写成矩阵形式更有利于我们使用 Gaussian Jordan 消元法求解。请证明 $$\begin{bmatrix}    \frac{\partial E}{\partial m} \\    \frac{\partial E}{\partial b} \end{bmatrix} = X^TXh - X^TY$$其中向量 $Y$, 矩阵 $X$ 和 向量 $h$ 分别为 :$$Y =  \begin{bmatrix}    y_1 \\    y_2 \\    ... \\    y_n\end{bmatrix},X =  \begin{bmatrix}    x_1 & 1 \\    x_2 & 1\\    ... & ...\\    x_n & 1 \\\end{bmatrix},h =  \begin{bmatrix}    m \\    b \\\end{bmatrix}$$ TODO 证明: 至此我们知道，通过求解方程 $X^TXh = X^TY$ 来找到最优参数。这个方程十分重要，他有一个名字叫做 **Normal Equation**，也有直观的几何意义。你可以在 [子空间投影](http://open.163.com/movie/2010/11/J/U/M6V0BQC4M_M6V2AJLJU.html) 和 [投影矩阵与最小二乘](http://open.163.com/movie/2010/11/P/U/M6V0BQC4M_M6V2AOJPU.html) 看到更多关于这个方程的内容。  3.4 求解 $X^TXh = X^TY$ 在3.3 中，我们知道线性回归问题等价于求解 $X^TXh = X^TY$ (如果你选择不做3.3，就勇敢的相信吧，哈哈)<jupyter_code># TODO 实现线性回归
'''
参数：X, Y
返回：m，b
'''
def linearRegression(X,Y):
    X = [[X[i]] for i in range(len(X))]
    Y = [[Y[i]] for i in range(len(Y))]

    #单位向量
    E = [[1] for j in range(len(X))]
    X1 = []
    #矩阵X1
    for i in range(len(X)):
        X1.append(X[i]+E[i])
        
#     print X1
    #X1 转置
    XT =  transpose(X1) 
#     print XT

#     print XT
#     print Y
#     matxMultiply(XT,Y)
    #XT*X
    A = matxMultiply(XT,X1)
    #XT*Y
    B =matxMultiply(XT,Y)
    #根据Gaussian Jordan 消元法
    h = gj_Solve(A,B)
    print h
    return h[0][0],h[1][0]

m,b = linearRegression(X,Y)<jupyter_output>[[3.237908973342472], [7.1898874152941294]]<jupyter_text>你求得的回归结果是什么？请使用运行以下代码将它画出来。<jupyter_code># 请不要修改下面的代码
x1,x2 = -5,5
y1,y2 = x1*m+b, x2*m+b

plt.xlim((-5,5))
plt.xlabel('x',fontsize=18)
plt.ylabel('y',fontsize=18)
plt.scatter(X,Y,c='b')
plt.plot((x1,x2),(y1,y2),'r')
plt.text(1,2,'y = {m}x + {b}'.format(m=m,b=b))
plt.show()<jupyter_output><empty_output><jupyter_text>你求得的回归结果对当前数据集的MSE是多少？<jupyter_code>print(calculateMSE(X,Y,m,b))<jupyter_output>1.35491977754
{'fraction_non_alphanumeric': 0.22702702702702704, 'fraction_numerical': 0.07039453246349799, 'mean_word_length': 2.585653820449989, 'pattern_counts': {'":': 0, '<': 58, '<?xml version=': 0, '>': 68, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 1, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 8, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '16', 'dir': 'jupyter-structured-clean-dedup', 'id': '275660', 'license': 'Apache-2.0', 'n_tokens_mistral': 8954, 'n_tokens_neox': 8957, 'n_words': 1329, 'path': 'linear_regression_project.ipynb', 'repo_name': 'lujianshun/linear_algebra-master', 'size': '16095'}