diff --git a/Book4_Ch01_Python_Codes/Streamlit_Bk4_Ch01_01.py b/Book4_Ch01_Python_Codes/Streamlit_Bk4_Ch01_01.py new file mode 100644 index 0000000..5f760ce --- /dev/null +++ b/Book4_Ch01_Python_Codes/Streamlit_Bk4_Ch01_01.py @@ -0,0 +1,60 @@ + +############### +# Authored by Weisheng Jiang +# Book 4 | From Basic Arithmetic to Machine Learning +# Published and copyrighted by Tsinghua University Press +# Beijing, China, 2025 +############### + +## 导入必要的库 +import streamlit as st # 引入Streamlit库，用于创建交互式Web应用 +import plotly.express as px # 引入Plotly Express库，用于绘图 + +## 加载鸢尾花数据 +df = px.data.iris() # 使用Plotly自带的数据集加载鸢尾花数据 + +features = df.columns.to_list()[:-2] # 获取数据集中特征列的名称（排除最后两列） +with st.sidebar: # 创建侧边栏 + st.write('2D scatter plot') # 显示文本“2D散点图” + x_feature = st.radio('Horizontal axis', # 创建单选按钮，选择X轴的特征 + features) # 单选按钮的选项为特征列名称 + y_feature = st.radio('Vertical axis', # 创建单选按钮，选择Y轴的特征 + features) # 单选按钮的选项为特征列名称 + +## 原始数据展示 +with st.expander('Original data'): # 创建可展开的部分，标题为“原始数据” + st.write(df) # 显示数据框df的内容 + +## 热力图展示 +with st.expander('Heatmap'): # 创建可展开的部分，标题为“热力图” + fig_1 = px.imshow(df.iloc[:, 0:4], # 使用前四列数据绘制热力图 + color_continuous_scale='RdYlBu_r') # 选择颜色映射为红黄蓝反转 + st.plotly_chart(fig_1) # 在Streamlit中显示热力图 + +## 二维散点图展示 +with st.expander('2D scatter plot'): # 创建可展开的部分，标题为“二维散点图” + fig_2 = px.scatter(df, x=x_feature, y=y_feature, color="species") # 根据用户选择的特征绘制二维散点图，按种类着色 + st.plotly_chart(fig_2) # 在Streamlit中显示散点图 + +## 三维散点图展示 +with st.expander('3D scatter plot'): # 创建可展开的部分，标题为“三维散点图” + fig_3 = px.scatter_3d(df, # 绘制三维散点图 + x='sepal_length', # X轴为花萼长度 + y='sepal_width', # Y轴为花萼宽度 + z='petal_width', # Z轴为花瓣宽度 + color='species') # 按种类着色 + st.plotly_chart(fig_3) # 在Streamlit中显示三维散点图 + +## 配对散点图展示 +with st.expander('Pairwise scatter plot'): # 创建可展开的部分，标题为“配对散点图” + fig_4 = px.scatter_matrix(df, # 绘制配对散点图 + dimensions=["sepal_width", + "sepal_length", + "petal_width", + "petal_length"], # 指定绘图的维度 + color="species") # 按种类着色 + st.plotly_chart(fig_4) # 在Streamlit中显示配对散点图 + + + + diff --git a/Book4_Ch02_Python_Codes/Bk4_Ch02_01.ipynb b/Book4_Ch02_Python_Codes/Bk4_Ch02_01.ipynb new file mode 100644 index 0000000..856c258 --- /dev/null +++ b/Book4_Ch02_Python_Codes/Bk4_Ch02_01.ipynb @@ -0,0 +1,160 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 02\n", + "\n", + "# 平面向量\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "41d40a38-db14-4162-bbb4-ade44a0fc01e", + "metadata": {}, + "source": [ + "这段代码的目的是在二维平面上绘制两个向量。通过 `draw_vector` 函数，代码接受一个向量和其对应的颜色值，将向量从原点（$[0, 0]$）绘制到指定的终点位置。代码分别绘制了两个向量：第一个向量 $\\vec{v_1} = [4, 3]$ 和第二个向量 $\\vec{v_2} = [-3, 4]$。这两个向量的颜色分别为蓝色和红色，绘制在坐标轴上。\n", + "\n", + "### 代码描述\n", + "代码先导入了所需的库 `numpy` 和 `matplotlib.pyplot`，其中 `numpy` 用于处理向量的数组格式，`matplotlib.pyplot` 用于绘图。在 `draw_vector` 函数中，代码通过 `np.array` 函数构造了一个包含向量起点和终点的数组 $\\text{array} = [[0, 0, x_1, x_2]]$，其中 $\\vec{v} = [x_1, x_2]$ 表示向量的坐标。此数组被拆分成起点和终点，接着调用 `plt.quiver` 绘制从起点 $(0, 0)$ 出发、指向终点 $(x_1, x_2)$ 的向量。\n", + "\n", + "代码中的向量分量表达为 $\\vec{v_1} = [4, 3]$ 和 $\\vec{v_2} = [-3, 4]$，其在坐标系中的位置可分别表示为：\n", + "$$\n", + "\\vec{v_1} = 4 \\hat{i} + 3 \\hat{j}\n", + "$$\n", + "和\n", + "$$\n", + "\\vec{v_2} = -3 \\hat{i} + 4 \\hat{j}\n", + "$$\n", + "这里 $\\hat{i}$ 和 $\\hat{j}$ 分别表示二维坐标系中的单位向量。\n", + "\n", + "最后，代码设置坐标轴的标签 $x_1$ 和 $x_2$，对坐标范围进行了限定 $[-5, 5]$，并加上网格线来辅助观察向量的方向和位置。最终的绘制效果展示了二维空间中两个不同方向和颜色的向量。" + ] + }, + { + "cell_type": "markdown", + "id": "a5aa4dec-32a4-4a62-a821-650c735b35bd", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1ea42b69-5170-4c31-ad2c-dcabaf01cf14", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算\n", + "import matplotlib.pyplot as plt # 导入Matplotlib库，用于绘图" + ] + }, + { + "cell_type": "markdown", + "id": "30cf6c0b-1aef-4d8c-af7f-83ca7b0e2584", + "metadata": {}, + "source": [ + "## 定义绘制向量的函数" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "dbc715a5-295c-4944-9c66-f34212fdaa05", + "metadata": {}, + "outputs": [], + "source": [ + "def draw_vector(vector, RBG): # 定义函数，用于绘制向量并设置颜色\n", + " array = np.array([[0, 0, vector[0], vector[1]]]) # 创建二维数组，包含向量的起点和终点\n", + " X, Y, U, V = zip(*array) # 解包数组，得到向量的起点坐标和分量\n", + " plt.quiver(X, Y, U, V, angles='xy', scale_units='xy', scale=1, color=RBG) # 使用quiver函数绘制向量" + ] + }, + { + "cell_type": "markdown", + "id": "4c0a93fa-27a2-4395-94d4-0513aa910a9a", + "metadata": {}, + "source": [ + "## 绘图设置" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4c6006e3-510b-4cea-954c-872c12191475", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots() # 创建画布和坐标轴对象\n", + "\n", + "# 绘制向量[4,3]并设置颜色为蓝色\n", + "draw_vector([4, 3], np.array([0, 112, 192]) / 255) \n", + "\n", + "# 绘制向量[-3,4]并设置颜色为红色\n", + "draw_vector([-3, 4], np.array([255, 0, 0]) / 255)\n", + "\n", + "## 图形显示设置\n", + "plt.ylabel('$x_2$') # 设置y轴标签为x_2\n", + "plt.xlabel('$x_1$') # 设置x轴标签为x_1\n", + "plt.axis('scaled') # 设置坐标轴比例\n", + "ax.set_xlim([-5, 5]) # 设置x轴显示范围\n", + "ax.set_ylim([-5, 5]) # 设置y轴显示范围\n", + "ax.grid(linestyle='--', linewidth=0.25, color=[0.5, 0.5, 0.5]) # 添加网格线，设置样式\n", + "\n", + "plt.show() # 显示图形" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch02_Python_Codes/Bk4_Ch02_02.ipynb b/Book4_Ch02_Python_Codes/Bk4_Ch02_02.ipynb new file mode 100644 index 0000000..7d0d8aa --- /dev/null +++ b/Book4_Ch02_Python_Codes/Bk4_Ch02_02.ipynb @@ -0,0 +1,198 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 02\n", + "\n", + "# L2范数\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "ab88dee3-1a2e-4357-b6b5-136abf3073c5", + "metadata": {}, + "source": [ + "此代码定义了两个二维列向量 `a` 和 `b`，并计算它们的L2范数。L2范数也称为欧几里得范数，用于测量向量的长度。公式如下：\n", + "\n", + "$$\n", + "\\| a \\|_2 = \\sqrt{a_1^2 + a_2^2}\n", + "$$ \n", + "\n", + "对于向量 `a` 和 `b`，L2范数分别为：\n", + "\n", + "$$\n", + "\\| a \\|_2 = \\sqrt{4^2 + 3^2} = 5\n", + "$$\n", + "\n", + "$$\n", + "\\| b \\|_2 = \\sqrt{(-3)^2 + 4^2} = 5\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "2a36cd49-a4e6-4321-a7e8-7f9a34c6aaef", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "01a128eb-3998-4172-bd8a-ec95a23bbc83", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "8ad8b4b0-856b-47a7-adb8-b020180d0c30", + "metadata": {}, + "source": [ + "## 定义两个列向量" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "212d3a51-f2c6-4785-8c9a-40fa93ae0566", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[4],\n", + " [3]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = np.array([[4], [3]]) # 定义向量a，值为[4, 3]\n", + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8d5f6350-fddc-4633-946e-f21797b6f5e8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-3],\n", + " [ 4]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b = np.array([[-3], [4]]) # 定义向量b，值为[-3, 4]\n", + "b" + ] + }, + { + "cell_type": "markdown", + "id": "a3ba8142-26a8-43d6-b777-685207499ca9", + "metadata": {}, + "source": [ + "## 计算L2范数" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1954434f-cb3e-44d3-b985-45b73af8a815", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.0" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_L2_norm = np.linalg.norm(a) # 计算向量a的L2范数\n", + "a_L2_norm" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8110a0d6-c941-4825-bf60-bc989324f592", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.0" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b_L2_norm = np.linalg.norm(b) # 计算向量b的L2范数\n", + "b_L2_norm" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch02_Python_Codes/Bk4_Ch02_03.ipynb b/Book4_Ch02_Python_Codes/Bk4_Ch02_03.ipynb new file mode 100644 index 0000000..2c922e8 --- /dev/null +++ b/Book4_Ch02_Python_Codes/Bk4_Ch02_03.ipynb @@ -0,0 +1,185 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 03\n", + "\n", + "# 向量L2范数等高线\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "fde1b2f9-88e2-4131-b2ef-845b45314910", + "metadata": {}, + "source": [ + "这段代码用于绘制二维平面上 $L_p$ 范数的等高线图。首先定义了变量 $x_1$ 和 $x_2$ 的范围，并生成一个以 $x_1$ 和 $x_2$ 为轴的二维网格 `xx1` 和 `xx2`，方便计算每个点上的 $L_p$ 范数。代码中 $p=2$，即绘制的是 $L_2$ 范数的等高线图，对应欧几里得距离。$L_p$ 范数的一般公式为：\n", + "\n", + "$$\n", + "\\| x \\|_p = \\left( |x_1|^p + |x_2|^p \\right)^{\\frac{1}{p}}\n", + "$$\n", + "\n", + "在代码中，设置 $p=2$，将公式展开得到：\n", + "\n", + "$$\n", + "\\| x \\|_2 = \\left( |x_1|^2 + |x_2|^2 \\right)^{\\frac{1}{2}}\n", + "$$\n", + "\n", + "接着，代码使用 `contour` 函数绘制从 0 到 10 的等高线图，这些等高线表示从原点出发的不同距离。在图中，$L_2$ 范数的等高线为同心圆，反映了欧几里得距离的等距性。坐标轴上加入了网格线、标记，以及调整后的坐标范围，展示了 $L_2$ 范数在二维平面上的分布特点。" + ] + }, + { + "cell_type": "markdown", + "id": "1a44a418-db0d-4679-acec-d805c393ba68", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "741e32c5-d7d8-444b-aabe-b1be7f7312bc", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt # 导入Matplotlib库，用于绘图\n", + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "0da91339-94fc-4dcd-9c59-a631291c983c", + "metadata": {}, + "source": [ + "## 定义坐标范围" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3c7c6569-a961-4d28-ab55-ff444109d888", + "metadata": {}, + "outputs": [], + "source": [ + "x1 = np.linspace(-10, 10, num=201) # 定义x1的范围，从-10到10，共201个点\n", + "x2 = x1 # 定义x2的范围与x1相同" + ] + }, + { + "cell_type": "markdown", + "id": "0ee274b3-4c63-4cec-99f6-c789be3e1959", + "metadata": {}, + "source": [ + "## 生成网格" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "965c4751-be4e-4742-96c2-b337f0c2661b", + "metadata": {}, + "outputs": [], + "source": [ + "xx1, xx2 = np.meshgrid(x1, x2) # 生成网格，用于二维坐标" + ] + }, + { + "cell_type": "markdown", + "id": "e50f4ba8-4430-45ac-b28e-ca2c493b5576", + "metadata": {}, + "source": [ + "## 计算Lp范数" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dbc4c47b-c21b-4e31-b462-20f45672bdfd", + "metadata": {}, + "outputs": [], + "source": [ + "p = 2 # 设置Lp范数中的p值，此处为2\n", + "zz = ((np.abs((xx1))**p) + (np.abs((xx2))**p))**(1./p) # 计算Lp范数的值" + ] + }, + { + "cell_type": "markdown", + "id": "44482ed9-5658-42fc-ae0e-f510334bd5f7", + "metadata": {}, + "source": [ + "## 创建绘图" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fb8e647b-822d-4b7d-a0cc-47fbaef6ab5f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 8)) # 创建画布和坐标轴，设置大小为12x12\n", + "\n", + "## 绘制等高线\n", + "ax.contour(xx1, xx2, zz, levels=np.arange(11), cmap='RdYlBu_r') # 绘制等高线，颜色映射为RdYlBu_r\n", + "\n", + "## 绘制坐标轴和边框设置\n", + "ax.axhline(y=0, color='k', linewidth=0.25) # 绘制y轴\n", + "ax.axvline(x=0, color='k', linewidth=0.25) # 绘制x轴\n", + "ax.set_xlim(-12, 12) # 设置x轴范围为-12到12\n", + "ax.set_ylim(-12, 12) # 设置y轴范围为-12到12\n", + "ax.spines['top'].set_visible(False) # 隐藏顶部边框\n", + "ax.spines['right'].set_visible(False) # 隐藏右侧边框\n", + "ax.spines['bottom'].set_visible(False) # 隐藏底部边框\n", + "ax.spines['left'].set_visible(False) # 隐藏左侧边框\n", + "ax.set_xlabel('$x_1$') # 设置x轴标签\n", + "ax.set_ylabel('$x_2$') # 设置y轴标签\n", + "ax.set_aspect('equal', adjustable='box') # 设置坐标轴比例为相等\n", + "plt.show() # 显示绘图" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch02_Python_Codes/Bk4_Ch02_04.ipynb b/Book4_Ch02_Python_Codes/Bk4_Ch02_04.ipynb new file mode 100644 index 0000000..91ca8fc --- /dev/null +++ b/Book4_Ch02_Python_Codes/Bk4_Ch02_04.ipynb @@ -0,0 +1,314 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 02\n", + "\n", + "# 向量加减法\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "5727cda1-e9bd-4483-b50f-9b9ef36574ae", + "metadata": {}, + "source": [ + "这段代码定义了两个二维列向量 $a$ 和 $b$，并计算了它们的加法与减法。具体来说，向量 $a$ 定义为：\n", + "\n", + "$$\n", + "a = \\begin{bmatrix} -2 \\\\ 5 \\end{bmatrix}\n", + "$$\n", + "\n", + "向量 $b$ 定义为：\n", + "\n", + "$$\n", + "b = \\begin{bmatrix} 5 \\\\ -1 \\end{bmatrix}\n", + "$$\n", + "\n", + "代码首先计算了 $a$ 和 $b$ 的向量加法，得到结果向量 $a + b$，其计算过程为：\n", + "\n", + "$$\n", + "a + b = \\begin{bmatrix} -2 \\\\ 5 \\end{bmatrix} + \\begin{bmatrix} 5 \\\\ -1 \\end{bmatrix} = \\begin{bmatrix} 3 \\\\ 4 \\end{bmatrix}\n", + "$$\n", + "\n", + "此外，代码还展示了向量减法 $a - b$ 和 $b - a$，分别为：\n", + "\n", + "$$\n", + "a - b = \\begin{bmatrix} -2 \\\\ 5 \\end{bmatrix} - \\begin{bmatrix} 5 \\\\ -1 \\end{bmatrix} = \\begin{bmatrix} -7 \\\\ 6 \\end{bmatrix}\n", + "$$\n", + "\n", + "$$\n", + "b - a = \\begin{bmatrix} 5 \\\\ -1 \\end{bmatrix} - \\begin{bmatrix} -2 \\\\ 5 \\end{bmatrix} = \\begin{bmatrix} 7 \\\\ -6 \\end{bmatrix}\n", + "$$\n", + "\n", + "代码中分别使用了直接运算（如 `a + b`）和 `NumPy` 函数 `np.add` 与 `np.subtract` 来完成加法和减法操作。这种处理方式展示了向量的基本线性代数操作。" + ] + }, + { + "cell_type": "markdown", + "id": "88825576-ff58-4b2e-8a6b-770f593c57bb", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "61e4349a-f354-4e33-a9a0-0b43ab26eb3b", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "ea419dfa-5bf7-4c35-b465-8ff0416ce120", + "metadata": {}, + "source": [ + "## 定义两个列向量" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ee8dadac-372a-43a9-8a21-f2e54d27b4c6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-2],\n", + " [ 5]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = np.array([[-2], [5]]) # 定义向量a，值为[-2, 5]\n", + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1749cae5-c1ac-491b-ba00-0e93066130ac", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 5],\n", + " [-1]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b = np.array([[5], [-1]]) # 定义向量b，值为[5, -1]\n", + "b" + ] + }, + { + "cell_type": "markdown", + "id": "68440eab-d48e-450b-ad71-43adcc4c30b3", + "metadata": {}, + "source": [ + "## 计算向量加法" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7c6885fd-59eb-457b-967f-fbeebee26a96", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[3],\n", + " [4]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_plus_b = a + b # 使用直接加法计算a和b的和\n", + "a_plus_b" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2bbd2e21-91c4-43b5-b18d-597011c73214", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[3],\n", + " [4]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_plus_b_2 = np.add(a, b) # 使用np.add函数计算a和b的和\n", + "a_plus_b_2" + ] + }, + { + "cell_type": "markdown", + "id": "54f2167f-edeb-48f4-81e4-89e27e459fd8", + "metadata": {}, + "source": [ + "## 计算向量减法" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f6e97112-bfc4-44e9-9a9d-d168d4ba030e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-7],\n", + " [ 6]])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_minus_b = a - b # 计算a减去b的差\n", + "a_minus_b" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a1b483cd-6bfc-450c-a883-d86a89ea897b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-7],\n", + " [ 6]])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_minus_b_2 = np.subtract(a, b) # 使用np.subtract函数计算a减去b的差\n", + "a_minus_b_2" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b1b4beab-4cab-48b1-b90d-065ee5971e9e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 7],\n", + " [-6]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b_minus_a = b - a # 计算b减去a的差\n", + "b_minus_a" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2a010763-e0f1-457f-acf9-e8e0182d271d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 7],\n", + " [-6]])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b_minus_a_2 = np.subtract(b, a) # 使用np.subtract函数计算b减去a的差\n", + "b_minus_a_2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch02_Python_Codes/Bk4_Ch02_05.ipynb b/Book4_Ch02_Python_Codes/Bk4_Ch02_05.ipynb new file mode 100644 index 0000000..be730e9 --- /dev/null +++ b/Book4_Ch02_Python_Codes/Bk4_Ch02_05.ipynb @@ -0,0 +1,183 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 02\n", + "\n", + "# 标量乘法\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "9fcf085a-8ecf-4003-b0b1-76f2e95c1063", + "metadata": {}, + "source": [ + "\n", + "\n", + "此代码定义了一个二维列向量 $a$，其值为：\n", + "\n", + "$$\n", + "a = \\begin{bmatrix} 2 \\\\ 2 \\end{bmatrix}\n", + "$$\n", + "\n", + "接下来，代码通过数乘操作生成两个新向量 $b$ 和 $c$。具体而言，$b$ 是 $a$ 的 2 倍：\n", + "\n", + "$$\n", + "b = 2 \\times a = 2 \\times \\begin{bmatrix} 2 \\\\ 2 \\end{bmatrix} = \\begin{bmatrix} 4 \\\\ 4 \\end{bmatrix}\n", + "$$\n", + "\n", + "$c$ 是 $a$ 的 $-1.5$ 倍：\n", + "\n", + "$$\n", + "c = -1.5 \\times a = -1.5 \\times \\begin{bmatrix} 2 \\\\ 2 \\end{bmatrix} = \\begin{bmatrix} -3 \\\\ -3 \\end{bmatrix}\n", + "$$\n", + "\n", + "此过程展示了向量的数乘操作，通过将标量与向量相乘来改变向量的大小和方向。" + ] + }, + { + "cell_type": "markdown", + "id": "7f2b0f70-8b54-49c7-a58c-736dd1838f39", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "457dd7c5-1ef8-4272-9608-01802512d831", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "a2882d5b-db0c-4d22-96ba-76123168e589", + "metadata": {}, + "source": [ + "## 定义一个列向量" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "dc48b150-34ed-4cc8-a5c3-ae59f58fbcdf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2],\n", + " [2]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = np.array([[2], [2]]) # 定义向量a，值为[2, 2]\n", + "a" + ] + }, + { + "cell_type": "markdown", + "id": "0e89b43f-c8e1-4af6-a3aa-eb966479608b", + "metadata": {}, + "source": [ + "## 进行向量的数乘" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "352700c8-fc4c-4b7c-8f8b-2ee1a5905878", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[4],\n", + " [4]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b = 2 * a # 计算b，为向量a的2倍\n", + "b" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a7e94dac-9695-4bcc-b09b-3dc7e823fe3b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-3.],\n", + " [-3.]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c = -1.5 * a # 计算c，为向量a的-1.5倍\n", + "c" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch02_Python_Codes/Bk4_Ch02_06.ipynb b/Book4_Ch02_Python_Codes/Bk4_Ch02_06.ipynb new file mode 100644 index 0000000..e9d50bd --- /dev/null +++ b/Book4_Ch02_Python_Codes/Bk4_Ch02_06.ipynb @@ -0,0 +1,213 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 02\n", + "\n", + "# 向量内积\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "90d57742-54b5-4967-9de6-2b97f3ff13ce", + "metadata": {}, + "source": [ + "该代码定义了两个二维向量 $a$ 和 $b$，并计算它们的内积。向量 $a$ 和 $b$ 的定义分别为：\n", + "\n", + "$$\n", + "a = \\begin{bmatrix} 4 & 3 \\end{bmatrix}, \\quad b = \\begin{bmatrix} 5 & -2 \\end{bmatrix}\n", + "$$\n", + "\n", + "代码首先通过 `np.inner` 函数计算行向量的内积，其计算公式为：\n", + "\n", + "$$\n", + "a \\cdot b = 4 \\cdot 5 + 3 \\cdot (-2) = 20 - 6 = 14\n", + "$$\n", + "\n", + "接着，代码将 $a$ 和 $b$ 定义为列向量形式 $a_2$ 和 $b_2$，并通过矩阵转置与矩阵乘法计算内积：\n", + "\n", + "$$\n", + "a_2^T \\cdot b_2 = \\begin{bmatrix} 4 & 3 \\end{bmatrix} \\cdot \\begin{bmatrix} 5 \\\\ -2 \\end{bmatrix} = 14\n", + "$$\n", + "\n", + "该过程展示了内积计算的不同实现方式，包括使用 `np.inner` 和转置矩阵乘法。" + ] + }, + { + "cell_type": "markdown", + "id": "a869bcd3-b5b0-48a6-8473-e1af9efa124c", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "52854f8c-f415-452c-8b0f-ba216cedb4a3", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "a895dedd-943b-4b5e-a9d8-6c958e1ec18e", + "metadata": {}, + "source": [ + "## 定义两个行向量" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "13d6cc5a-824f-4537-8d80-5e4a0c6146a7", + "metadata": {}, + "outputs": [], + "source": [ + "a = np.array([[4, 3]]) # 定义向量a，值为[4, 3]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "89d1799e-2c61-4410-83fd-401db971b8fd", + "metadata": {}, + "outputs": [], + "source": [ + "b = np.array([[5, -2]]) # 定义向量b，值为[5, -2]" + ] + }, + { + "cell_type": "markdown", + "id": "3277e077-e975-4354-b79a-5bc9e77d5666", + "metadata": {}, + "source": [ + "## 计算内积" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e4008c0e-94ff-4cb5-8139-432ed0048692", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[14]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_dot_b = np.inner(a, b) # 使用np.inner计算a和b的内积\n", + "a_dot_b" + ] + }, + { + "cell_type": "markdown", + "id": "b6a1c7e0-b5e4-4303-b2a8-19e7a0d72cbb", + "metadata": {}, + "source": [ + "## 定义两个列向量" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c30e546b-1f82-43c7-b4d5-163394f406c3", + "metadata": {}, + "outputs": [], + "source": [ + "a_2 = np.array([[4], [3]]) # 定义列向量a_2，值为[4, 3]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "41ee49f6-1d62-4f0e-895e-671ae32ad301", + "metadata": {}, + "outputs": [], + "source": [ + "b_2 = np.array([[5], [-2]]) # 定义列向量b_2，值为[5, -2]" + ] + }, + { + "cell_type": "markdown", + "id": "d6a74fd1-5de1-486c-98fb-ff21a16d5158", + "metadata": {}, + "source": [ + "## 计算转置后内积" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ce1247f9-be4e-40aa-be27-9b9b4d8f9b03", + "metadata": {}, + "outputs": [], + "source": [ + "a_dot_b_2 = a_2.T @ b_2 # 使用矩阵乘法计算a_2转置和b_2的内积" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[14]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_dot_b_2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch02_Python_Codes/Bk4_Ch02_07.ipynb b/Book4_Ch02_Python_Codes/Bk4_Ch02_07.ipynb new file mode 100644 index 0000000..cc0c6f7 --- /dev/null +++ b/Book4_Ch02_Python_Codes/Bk4_Ch02_07.ipynb @@ -0,0 +1,166 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 02\n", + "\n", + "# 矩阵乘积\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "98f9659f-671c-40ba-bf01-26b02f299f65", + "metadata": {}, + "source": [ + "\n", + "\n", + "此代码定义了两个 $2 \\times 2$ 的矩阵 $A$ 和 $B$，并计算它们的矩阵乘积。矩阵 $A$ 和 $B$ 的定义分别为：\n", + "\n", + "$$\n", + "A = \\begin{bmatrix} 2 & 3 \\\\ 3 & 4 \\end{bmatrix}, \\quad B = \\begin{bmatrix} 3 & 4 \\\\ 5 & 6 \\end{bmatrix}\n", + "$$\n", + "\n", + "矩阵乘积 $A @ B$ 的计算公式是：\n", + "\n", + "$$\n", + "A @ B = \\begin{bmatrix} 2 \\cdot 3 + 3 \\cdot 5 & 2 \\cdot 4 + 3 \\cdot 6 \\\\ 3 \\cdot 3 + 4 \\cdot 5 & 3 \\cdot 4 + 4 \\cdot 6 \\end{bmatrix} = \\begin{bmatrix} 21 & 26 \\\\ 29 & 38 \\end{bmatrix}\n", + "$$\n" + ] + }, + { + "cell_type": "markdown", + "id": "b7d099d5-b19e-4dc1-bcbc-c6f27ff10d63", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "fe40fe29-6b65-47eb-a82d-c9739d4f17b1", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "972ceb2f-dfc9-406b-aa4d-759d8a3c5ceb", + "metadata": {}, + "source": [ + "## 定义两个矩阵" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "022dfa07-a9e4-4ba6-9456-f7dd6b861bcd", + "metadata": {}, + "outputs": [], + "source": [ + "A = np.array([[2, 3], # 定义矩阵A\n", + " [3, 4]])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "eba046cd-9051-403b-86a4-5586226e9c86", + "metadata": {}, + "outputs": [], + "source": [ + "B = np.array([[3, 4], # 定义矩阵B\n", + " [5, 6]])" + ] + }, + { + "cell_type": "markdown", + "id": "97150b17-9793-47aa-b9c1-aa61baf34bde", + "metadata": {}, + "source": [ + "## 计算矩阵点积" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dec0b7d8-6d24-4d13-8bf2-0786a4d1e8e6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[21, 26],\n", + " [29, 36]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_dot_B = np.dot(A, B) # 使用np.dot计算A和B的矩阵乘积\n", + "A_dot_B" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[21, 26],\n", + " [29, 36]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 可以直接用A @ B作为矩阵乘法的简写\n", + "A @ B" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch02_Python_Codes/Bk4_Ch02_08.ipynb b/Book4_Ch02_Python_Codes/Bk4_Ch02_08.ipynb new file mode 100644 index 0000000..54c0b7c --- /dev/null +++ b/Book4_Ch02_Python_Codes/Bk4_Ch02_08.ipynb @@ -0,0 +1,153 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 02\n", + "\n", + "# 向量化内积\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "6f5b0126-e220-42a5-9c76-10b5c77dd35c", + "metadata": {}, + "source": [ + "此代码定义了两个 $2 \\times 2$ 的矩阵 $A$ 和 $B$，并使用 `np.vdot` 计算它们的向量化内积。`np.vdot` 会将矩阵元素展平成一维向量，然后执行逐元素的内积计算。\n", + "\n", + "矩阵 $A$ 和 $B$ 展开后为：\n", + "\n", + "$$\n", + "A = \\begin{bmatrix} 1 & 2 & 3 & 4 \\end{bmatrix}, \\quad B = \\begin{bmatrix} 3 & 4 & 5 & 6 \\end{bmatrix}\n", + "$$\n", + "\n", + "因此，内积的计算为：\n", + "\n", + "$$\n", + "1 \\cdot 3 + 2 \\cdot 4 + 3 \\cdot 5 + 4 \\cdot 6 = 3 + 8 + 15 + 24 = 50\n", + "$$\n", + "\n", + "代码使用 `np.vdot` 执行此向量化的内积计算，而不仅是逐元素矩阵乘法。" + ] + }, + { + "cell_type": "markdown", + "id": "004f7421-698b-4eb3-9d22-1517683ab9bc", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f0b0c3a1-f413-487e-9f5f-9d8a1a37248f", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "f3ab1198-85f2-47d5-9425-46145141e92e", + "metadata": {}, + "source": [ + "## 定义两个矩阵" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "138d24b7-39e5-4ccc-9d5c-f554db5c2eb9", + "metadata": {}, + "outputs": [], + "source": [ + "A = np.array([[1, 2], # 定义矩阵A\n", + " [3, 4]])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c79531e6-89d7-4c4c-91ae-afe500cec8bb", + "metadata": {}, + "outputs": [], + "source": [ + "B = np.array([[3, 4], # 定义矩阵B\n", + " [5, 6]])" + ] + }, + { + "cell_type": "markdown", + "id": "438b8825-fda5-4905-890a-6f690b7c11dd", + "metadata": {}, + "source": [ + "## 计算矩阵的向量内积" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8505b1bc-d105-424b-a163-25205e0f5e94", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "50" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_dot_B = np.vdot(A, B) # 使用np.vdot计算A和B的向量内积\n", + "A_dot_B\n", + "# [1,2,3,4]*[3,4,5,6].T # 向量化的点积计算" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch02_Python_Codes/Bk4_Ch02_09.ipynb b/Book4_Ch02_Python_Codes/Bk4_Ch02_09.ipynb new file mode 100644 index 0000000..e6a21bf --- /dev/null +++ b/Book4_Ch02_Python_Codes/Bk4_Ch02_09.ipynb @@ -0,0 +1,215 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 02\n", + "\n", + "# 向量夹角\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "8bb390c4-26af-44db-bf6a-d0edb2d14b1e", + "metadata": {}, + "source": [ + "该代码定义了两个二维列向量 $a$ 和 $b$，并计算了它们之间夹角的余弦值、弧度和度数。\n", + "\n", + "### 计算公式\n", + "\n", + "向量 $a$ 和 $b$ 分别为：\n", + "\n", + "$$\n", + "a = \\begin{bmatrix} 4 \\\\ 3 \\end{bmatrix}, \\quad b = \\begin{bmatrix} 5 \\\\ -2 \\end{bmatrix}\n", + "$$\n", + "\n", + "余弦夹角公式为：\n", + "\n", + "$$\n", + "\\cos \\theta = \\frac{a \\cdot b}{\\|a\\|_2 \\|b\\|_2} = \\frac{a^T b}{\\|a\\|_2 \\|b\\|_2}\n", + "$$\n", + "\n", + "接着，使用反余弦函数计算角度的弧度值：\n", + "\n", + "$$\n", + "\\theta = \\arccos(\\cos \\theta)\n", + "$$\n", + "\n", + "最后将弧度值转换为角度：\n", + "\n", + "$$\n", + "\\theta_{\\text{degree}} = \\theta \\times \\frac{180}{\\pi}\n", + "$$\n", + "\n", + "代码中的运算展示了向量间夹角的计算方法，包括余弦、弧度和度数转换。" + ] + }, + { + "cell_type": "markdown", + "id": "01c7be45-8810-4f12-aca9-ecc099054269", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "53d8013b-3c6e-40da-bc98-e5787ed25f79", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "6c657ddd-c8a1-4ddc-825f-e9e82bcade44", + "metadata": {}, + "source": [ + "## 定义两个列向量" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8e262906-50d0-44ee-b31b-4d6569b1b5b9", + "metadata": {}, + "outputs": [], + "source": [ + "a, b = np.array([[4], [3]]), np.array([[5], [-2]]) # 定义向量a和b" + ] + }, + { + "cell_type": "markdown", + "id": "ff9561ac-02f3-4b67-82e7-be3dddfb4460", + "metadata": {}, + "source": [ + "## 计算余弦值" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "50fba935-3aa3-41f7-8aed-f29544822233", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.51994695]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cos_theta = (a.T @ b) / (np.linalg.norm(a, 2) * np.linalg.norm(b, 2)) \n", + "# 计算向量a和b之间夹角的余弦值\n", + "cos_theta" + ] + }, + { + "cell_type": "markdown", + "id": "d65329e6-0d9e-4005-b6b0-a8c46fdb2c04", + "metadata": {}, + "source": [ + "## 计算夹角的弧度值" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a94cfe3e-0338-4fb4-99d2-0b2e5e08d198", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1.02400749]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cos_radian = np.arccos(cos_theta) # 计算余弦值对应的弧度\n", + "cos_radian" + ] + }, + { + "cell_type": "markdown", + "id": "56bc6d0e-831a-4f2f-ab59-9ff9fd558a41", + "metadata": {}, + "source": [ + "## 将弧度转换为度数" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f018e489-013e-4f38-bdb4-291023e46179", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[58.67130713]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cos_degree = cos_radian * (180 / np.pi) # 将弧度转换为度数\n", + "cos_degree" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch02_Python_Codes/Bk4_Ch02_10.ipynb b/Book4_Ch02_Python_Codes/Bk4_Ch02_10.ipynb new file mode 100644 index 0000000..5f4372e --- /dev/null +++ b/Book4_Ch02_Python_Codes/Bk4_Ch02_10.ipynb @@ -0,0 +1,411 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 02\n", + "\n", + "# 余弦距离\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "a4d2d126-5db0-4038-a1dc-9a83708d2220", + "metadata": {}, + "source": [ + "此代码加载了鸢尾花数据集，并提取了数据集中的几个特定数据点以计算它们之间的余弦距离和夹角余弦值。选取的特征包含所有特征，而数据点分别为第1、2、51、101个观测。\n", + "\n", + "### 计算公式\n", + "代码使用余弦距离和余弦相似度来度量两个向量之间的相似性。\n", + "\n", + "1. 余弦距离公式：\n", + "\n", + "$$\n", + "\\text{cosine\\_distance} = 1 - \\frac{x_1 \\cdot x_2}{\\|x_1\\| \\|x_2\\|}\n", + "$$\n", + "\n", + "2. 向量间夹角的余弦值：\n", + "\n", + "$$\n", + "\\cos \\theta = \\frac{x_1 \\cdot x_2}{\\|x_1\\| \\|x_2\\|}\n", + "$$\n", + "\n", + "余弦距离反映了两个向量间的角度差异，而夹角余弦值则用于计算向量的相似性。" + ] + }, + { + "cell_type": "markdown", + "id": "6aec7dfe-a3d4-4cb9-b921-b3a137455aca", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "83ff9c7b-6adb-4fe1-91ef-4325850851b2", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.spatial import distance # 导入SciPy库，用于计算向量间的距离\n", + "from sklearn import datasets # 导入sklearn数据集模块\n", + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "4723d4a7-92b7-4c8d-8dcc-e678a7daded0", + "metadata": {}, + "source": [ + "## 导入鸢尾花数据集" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f4654f70-41cf-40b9-ad1d-5e39c337a40a", + "metadata": {}, + "outputs": [], + "source": [ + "iris = datasets.load_iris() # 加载鸢尾花数据集" + ] + }, + { + "cell_type": "markdown", + "id": "a7d90350-e6b8-4f35-a30f-f17e3042bbfa", + "metadata": {}, + "source": [ + "## 使用前两个特征：萼片长度和萼片宽度" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "111624e1-5071-43b5-ad7f-f91c1ea86f1f", + "metadata": {}, + "outputs": [], + "source": [ + "X = iris.data[:, :] # 提取所有特征数据" + ] + }, + { + "cell_type": "markdown", + "id": "08b685c0-3e21-4c99-8f19-d15fc50ba309", + "metadata": {}, + "source": [ + "## 提取4个数据点" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "af961fce-c345-4d97-a8d8-dc1fd27f75e6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([5.1, 3.5, 1.4, 0.2])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x1_data = X[0, :] # 第一个数据点\n", + "x1_data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "98593e09-12b0-43a1-81c0-97751c3f44cf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([4.9, 3. , 1.4, 0.2])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x2_data = X[1, :] # 第二个数据点\n", + "x2_data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "261efd1f-06bc-4361-996b-62a2f621234a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([7. , 3.2, 4.7, 1.4])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x51_data = X[50, :] # 第51个数据点\n", + "x51_data" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "637692dd-8df7-472c-97e5-c1be1475c891", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([6.3, 3.3, 6. , 2.5])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x101_data = X[100, :] # 第101个数据点\n", + "x101_data" + ] + }, + { + "cell_type": "markdown", + "id": "a14578f6-7866-4fea-8354-2633c0a50df7", + "metadata": {}, + "source": [ + "## 计算余弦距离和夹角余弦值" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d73204a7-6235-4449-a3ea-90d677c04fe6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0014208364959781283" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x1_x2_cos_dist = distance.cosine(x1_data, x2_data) \n", + "# 计算x1和x2的余弦距离\n", + "x1_x2_cos_dist" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1b3df27e-df51-4564-a192-b3d0544fd820", + "metadata": {}, + "outputs": [], + "source": [ + "x1_norm = np.linalg.norm(x1_data) # 计算x1的L2范数" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "efb9a6c3-ccfa-4000-8135-677fdd68c81d", + "metadata": {}, + "outputs": [], + "source": [ + "x2_norm = np.linalg.norm(x2_data) # 计算x2的L2范数" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "06c48d91-451f-404c-8e11-6006943c4a38", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "37.489999999999995" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x1_dot_x2 = x1_data.T @ x2_data # 计算x1和x2的点积\n", + "x1_dot_x2" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "5818da3f-985c-4c48-8fc9-159ec8067f2e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9985791635040218" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x1_x2_cos = x1_dot_x2 / x1_norm / x2_norm # 计算x1和x2的夹角余弦值\n", + "x1_x2_cos" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f3e0969d-ffbf-4c10-95ee-69898c57dc0c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0014208364959782394" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1 - x1_x2_cos" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "62c0e4a9-c455-4290-9389-a2ee56c2adc1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0014208364959781283" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x1_x2_cos_dist = distance.cosine(x1_data, x2_data) # 计算x1和x2的余弦距离\n", + "x1_x2_cos_dist" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "46e0f1db-9989-4908-89de-ffe0f0a8f431", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.07161964128508791" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x1_x51_cos_dist = distance.cosine(x1_data, x51_data) # 计算x1和x51的余弦距离\n", + "x1_x51_cos_dist" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "0f516143-46a8-42ba-8e31-fe4b08d428de", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.1399186683412712" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x1_x101_cos_dist = distance.cosine(x1_data, x101_data) # 计算x1和x101的余弦距离\n", + "x1_x101_cos_dist" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch02_Python_Codes/Bk4_Ch02_11.ipynb b/Book4_Ch02_Python_Codes/Bk4_Ch02_11.ipynb new file mode 100644 index 0000000..4b68b8a --- /dev/null +++ b/Book4_Ch02_Python_Codes/Bk4_Ch02_11.ipynb @@ -0,0 +1,193 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 02\n", + "\n", + "# 向量积\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "873da06f-c90c-4a2a-abd3-7f8711feca02", + "metadata": {}, + "source": [ + "此代码定义了两个三维向量 $a$ 和 $b$，并计算了它们的叉积（向量积）。首先定义了行向量形式的 $a$ 和 $b$，然后分别计算了行向量和列向量的叉积。\n", + "\n", + "### 叉积公式\n", + "对于三维向量 $a = \\begin{bmatrix} a_1 \\\\ a_2 \\\\ a_3 \\end{bmatrix}$ 和 $b = \\begin{bmatrix} b_1 \\\\ b_2 \\\\ b_3 \\end{bmatrix}$，叉积定义为：\n", + "\n", + "$$\n", + "a \\times b = \\begin{bmatrix} a_2 b_3 - a_3 b_2 \\\\ a_3 b_1 - a_1 b_3 \\\\ a_1 b_2 - a_2 b_1 \\end{bmatrix}\n", + "$$\n", + "\n", + "代码中计算了行向量和列向量形式的叉积。结果表示两个向量的垂直方向，并可用于三维空间中的法向量计算。" + ] + }, + { + "cell_type": "markdown", + "id": "4e369506-697f-450e-a731-76945415ed9c", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "dbb6f14c-fcb4-499f-9618-d6ca9c8b36ab", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "5d9fa082-6e75-4a30-9ff1-b119c73a3a25", + "metadata": {}, + "source": [ + "## 定义两个行向量" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "081b4fe5-be16-4854-914b-5c795f937fa8", + "metadata": {}, + "outputs": [], + "source": [ + "a = np.array([-2, 1, 1]) # 定义向量a" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9a902aa8-799a-4461-a5c0-459f2550272a", + "metadata": {}, + "outputs": [], + "source": [ + "b = np.array([1, -2, -1]) # 定义向量b" + ] + }, + { + "cell_type": "markdown", + "id": "b04a2e40-0ae4-44f1-a6bd-e691ee781d18", + "metadata": {}, + "source": [ + "## 计算行向量的叉积" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "95ea922a-d94c-42c3-8459-d8fc755b8df3", + "metadata": {}, + "outputs": [], + "source": [ + "a_cross_b = np.cross(a, b) # 计算a和b的叉积" + ] + }, + { + "cell_type": "markdown", + "id": "6de6f635-f9e9-4667-a12a-884ccaeb26f3", + "metadata": {}, + "source": [ + "## 定义两个列向量" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0d9f2b40-f6a0-4ca6-a70b-3910b69a9706", + "metadata": {}, + "outputs": [], + "source": [ + "a_col = np.array([[-2], [1], [1]]) # 定义列向量a_col" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "66e48d3a-7fa8-41a8-bf8b-61cfdf250200", + "metadata": {}, + "outputs": [], + "source": [ + "b_col = np.array([[1], [-2], [-1]]) # 定义列向量b_col" + ] + }, + { + "cell_type": "markdown", + "id": "c19ed8a3-f8e7-4c42-b6f7-bac01f31e016", + "metadata": {}, + "source": [ + "## 计算列向量的叉积" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9c019178-15f5-41f6-93d5-ceea5505684f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1],\n", + " [-1],\n", + " [ 3]])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_cross_b_col = np.cross(a_col, b_col, axis=0) # 计算a_col和b_col的叉积，沿axis=0进行计算\n", + "a_cross_b_col" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch02_Python_Codes/Bk4_Ch02_12.ipynb b/Book4_Ch02_Python_Codes/Bk4_Ch02_12.ipynb new file mode 100644 index 0000000..906445c --- /dev/null +++ b/Book4_Ch02_Python_Codes/Bk4_Ch02_12.ipynb @@ -0,0 +1,252 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 02\n", + "\n", + "# 逐项积\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "ce4a4893-3f8c-402f-92c3-79d73b81d380", + "metadata": {}, + "source": [ + "\n", + "此代码定义了两个三维向量 $a$ 和 $b$，并计算了它们的逐元素积（即对应元素相乘）。代码中既使用了行向量形式也使用了列向量形式的 $a$ 和 $b$ 来演示逐元素乘法的计算。\n", + "\n", + "### 逐元素乘法公式\n", + "对于两个向量 $a = \\begin{bmatrix} a_1 \\\\ a_2 \\\\ a_3 \\end{bmatrix}$ 和 $b = \\begin{bmatrix} b_1 \\\\ b_2 \\\\ b_3 \\end{bmatrix}$，逐元素积定义为：\n", + "\n", + "$$\n", + "a \\odot b = \\begin{bmatrix} a_1 \\cdot b_1 \\\\ a_2 \\cdot b_2 \\\\ a_3 \\cdot b_3 \\end{bmatrix}\n", + "$$\n", + "\n", + "代码中的计算展示了逐元素乘法的两种实现方式：使用 `np.multiply` 函数和直接使用 `*` 操作符。结果得到一个新向量，其中每个元素为对应元素相乘的值。" + ] + }, + { + "cell_type": "markdown", + "id": "370c070f-d704-40b0-90c9-ef2e2bee22ce", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b92befcd-0d09-4301-aecc-cb3172ce2cd9", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "25572211-3dd7-487d-ab16-d62682d66f56", + "metadata": {}, + "source": [ + "## 定义两个行向量" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "04b0208a-df81-48a4-8e85-f2ef347708c1", + "metadata": {}, + "outputs": [], + "source": [ + "a = np.array([-2, 1, 1]) # 定义向量a" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "557a8b24-f13d-4995-9bc2-c8bc3fa19389", + "metadata": {}, + "outputs": [], + "source": [ + "b = np.array([1, -2, -1]) # 定义向量b" + ] + }, + { + "cell_type": "markdown", + "id": "4a95a30f-b3fc-4e2f-b2e7-ccd49cc48ed1", + "metadata": {}, + "source": [ + "## 计算行向量的逐元素积" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "29eca8ec-ed59-4e60-90bf-8405a4a084e3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-2, -2, -1])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_times_b = np.multiply(a, b) # 计算a和b的逐元素积\n", + "a_times_b" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "91a581bf-ca56-44b2-8d21-8ae4a19ee309", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-2, -2, -1])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_times_b_2 = a * b # 使用*操作符计算a和b的逐元素积\n", + "a_times_b_2" + ] + }, + { + "cell_type": "markdown", + "id": "65964628-e9f9-4626-9a49-adc10d2f4ecf", + "metadata": {}, + "source": [ + "## 定义两个列向量" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "42eec7be-ccdc-4a9a-be68-0e074793c2a4", + "metadata": {}, + "outputs": [], + "source": [ + "a_col = np.array([[-2], [1], [1]]) # 定义列向量a_col" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b8757d8c-776a-400c-be13-0b7cac7ffdac", + "metadata": {}, + "outputs": [], + "source": [ + "b_col = np.array([[1], [-2], [-1]]) # 定义列向量b_col" + ] + }, + { + "cell_type": "markdown", + "id": "2269b17d-2fc2-47dc-b7eb-4f4ec992502f", + "metadata": {}, + "source": [ + "## 计算列向量的逐元素积" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c9f74e22-8432-4c40-bb9b-36f0a2d5e064", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-2],\n", + " [-2],\n", + " [-1]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_times_b_col = np.multiply(a_col, b_col) # 计算a_col和b_col的逐元素积\n", + "a_times_b_col" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7cd5c6c6-b2e3-4027-8eaa-7656594db66b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-2],\n", + " [-2],\n", + " [-1]])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_times_b_col_2 = a_col * b_col # 使用*操作符计算a_col和b_col的逐元素积\n", + "a_times_b_col_2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch02_Python_Codes/Bk4_Ch02_13.ipynb b/Book4_Ch02_Python_Codes/Bk4_Ch02_13.ipynb new file mode 100644 index 0000000..73ff5c9 --- /dev/null +++ b/Book4_Ch02_Python_Codes/Bk4_Ch02_13.ipynb @@ -0,0 +1,359 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 02\n", + "\n", + "# 向量外积\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "b25793e2-ad3d-4cf0-905e-16a6bdc78525", + "metadata": {}, + "source": [ + "\n", + "该代码定义了两个列向量 $a$ 和 $b$，并计算了它们之间的外积矩阵（Kronecker积），即 $a \\otimes b$、$a \\otimes a$ 和 $b \\otimes b$。通过 `plot_heatmap` 函数，代码将这些向量和外积矩阵的结果以热图的形式可视化，帮助理解矩阵的结构和分布。\n", + "\n", + "### 外积公式\n", + "对于两个向量 $a$ 和 $b$，外积 $a \\otimes b$ 的定义为：\n", + "\n", + "$$\n", + "a \\otimes b = \\begin{bmatrix} a_1 \\cdot b_1 & a_1 \\cdot b_2 & \\dots & a_1 \\cdot b_n \\\\ a_2 \\cdot b_1 & a_2 \\cdot b_2 & \\dots & a_2 \\cdot b_n \\\\ \\vdots & \\vdots & \\ddots & \\vdots \\\\ a_m \\cdot b_1 & a_m \\cdot b_2 & \\dots & a_m \\cdot b_n \\end{bmatrix}\n", + "$$\n", + "\n", + "代码使用 `np.outer` 计算外积，利用热图展示矩阵中每个元素的值及其相对大小和位置。" + ] + }, + { + "cell_type": "markdown", + "id": "513a8f57-7fc3-40c4-b649-fb91b1750030", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "976925c4-df40-46fc-b5c1-3611b50e241e", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt # 导入Matplotlib库，用于绘图\n", + "import numpy as np # 导入NumPy库，用于数值计算\n", + "import seaborn as sns # 导入Seaborn库，用于绘制热图" + ] + }, + { + "cell_type": "markdown", + "id": "f8fa7316-ab54-4f53-8bcd-4a4fd85ab127", + "metadata": {}, + "source": [ + "## 定义绘制热图的函数" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cb837eab-6167-43d3-8884-6e500abb0275", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_heatmap(x, title): # 定义函数plot_heatmap，用于绘制矩阵x的热图\n", + " fig, ax = plt.subplots() # 创建画布和坐标轴对象\n", + " ax = sns.heatmap(x, # 使用Seaborn绘制热图\n", + " cmap='RdYlBu_r', # 设置热图的颜色映射\n", + " cbar_kws={\"orientation\": \"horizontal\"}, \n", + " vmin=-1, vmax=1) # 设置颜色条的范围和方向\n", + " ax.set_aspect(\"equal\") # 设置坐标轴的比例为相等\n", + " plt.title(title) # 设置热图标题" + ] + }, + { + "cell_type": "markdown", + "id": "fa6eebb2-d883-4611-a396-73c13d9e7c9a", + "metadata": {}, + "source": [ + "## 定义向量" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7f8ca200-5e75-451c-b1db-fce05f846591", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.5 ],\n", + " [-0.7 ],\n", + " [ 1. ],\n", + " [ 0.25],\n", + " [-0.6 ],\n", + " [-1. ]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = np.array([[0.5], [-0.7], [1], [0.25], [-0.6], [-1]]) # 定义列向量a\n", + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e8238d10-51fa-42eb-8c76-25a373587486", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.8],\n", + " [ 0.5],\n", + " [-0.6],\n", + " [ 0.9]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b = np.array([[-0.8], [0.5], [-0.6], [0.9]]) # 定义列向量b\n", + "b" + ] + }, + { + "cell_type": "markdown", + "id": "966c4967-6679-4d62-b0be-cabb9c40ec23", + "metadata": {}, + "source": [ + "## 计算外积" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d4ff573b-0f49-4234-8528-ed2f1c2be2e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.4 , 0.25 , -0.3 , 0.45 ],\n", + " [ 0.56 , -0.35 , 0.42 , -0.63 ],\n", + " [-0.8 , 0.5 , -0.6 , 0.9 ],\n", + " [-0.2 , 0.125, -0.15 , 0.225],\n", + " [ 0.48 , -0.3 , 0.36 , -0.54 ],\n", + " [ 0.8 , -0.5 , 0.6 , -0.9 ]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_outer_b = np.outer(a, b) # 计算a和b的外积\n", + "a_outer_b" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5424b4ab-f3c7-45ca-8459-d755814f7fee", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.25 , -0.35 , 0.5 , 0.125 , -0.3 , -0.5 ],\n", + " [-0.35 , 0.49 , -0.7 , -0.175 , 0.42 , 0.7 ],\n", + " [ 0.5 , -0.7 , 1. , 0.25 , -0.6 , -1. ],\n", + " [ 0.125 , -0.175 , 0.25 , 0.0625, -0.15 , -0.25 ],\n", + " [-0.3 , 0.42 , -0.6 , -0.15 , 0.36 , 0.6 ],\n", + " [-0.5 , 0.7 , -1. , -0.25 , 0.6 , 1. ]])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_outer_a = np.outer(a, a) # 计算a和a的外积\n", + "a_outer_a" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "38b22c1e-4444-4d0d-bdb6-5c72f462795d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.64, -0.4 , 0.48, -0.72],\n", + " [-0.4 , 0.25, -0.3 , 0.45],\n", + " [ 0.48, -0.3 , 0.36, -0.54],\n", + " [-0.72, 0.45, -0.54, 0.81]])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b_outer_b = np.outer(b, b) # 计算b和b的外积\n", + "b_outer_b" + ] + }, + { + "cell_type": "markdown", + "id": "94c224ca-8f86-462f-b53a-a75c9df4de72", + "metadata": {}, + "source": [ + "## 可视化" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bd275fa7-0bf4-433d-8580-ae23eca9378e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_heatmap(a, 'a') # 绘制向量a的热图" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d12a9cdc-eea9-453e-bdc2-ffd010b3c397", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_heatmap(b, 'b') # 绘制向量b的热图" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "bfb6efee-8c65-4720-aea8-32a4aee2f975", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_heatmap(a_outer_b, 'a outer b') # 绘制a和b的外积的热图" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c8c56a1d-4211-43b8-97b7-95000a5d08a4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_heatmap(a_outer_a, 'a outer a') # 绘制a和a的外积的热图" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0c85e833-c666-4f88-9027-0129e100677b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_heatmap(b_outer_b, 'b outer b') # 绘制b和b的外积的热图" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch02_Python_Codes/Streamlit_Bk4_Ch02_13.py b/Book4_Ch02_Python_Codes/Streamlit_Bk4_Ch02_13.py new file mode 100644 index 0000000..bdf4889 --- /dev/null +++ b/Book4_Ch02_Python_Codes/Streamlit_Bk4_Ch02_13.py @@ -0,0 +1,100 @@ + +############### +# Authored by Weisheng Jiang +# Book 4 | From Basic Arithmetic to Machine Learning +# Published and copyrighted by Tsinghua University Press +# Beijing, China, 2025 +############### + + +## 导入必要的库 +import streamlit as st # 引入Streamlit库，用于创建交互式Web应用 +import numpy as np # 引入Numpy库，用于数值计算 +from plotly.subplots import make_subplots # 引入Plotly的子图模块，用于创建复杂布局 +import plotly.graph_objects as go # 引入Plotly的图形对象模块，用于绘图 +import plotly.express as px # 引入Plotly Express模块，用于快速绘图 + +## 定义自定义函数 bmatrix +# 该函数将一个numpy数组转换为LaTeX格式的bmatrix矩阵 +def bmatrix(a): + """返回一个LaTeX格式的bmatrix矩阵表示形式 + + :a: numpy数组 + :returns: 返回字符串形式的LaTeX bmatrix矩阵 + """ + if len(a.shape) > 2: # 如果数组维度大于2，抛出异常 + raise ValueError('bmatrix最多只能展示二维数据') + lines = str(a).replace('[', '').replace(']', '').splitlines() # 移除括号并分行 + rv = [r'\begin{bmatrix}'] # LaTeX矩阵开始标记 + rv += [' ' + ' & '.join(l.split()) + r'\\' for l in lines] # 拼接矩阵中的元素 + rv += [r'\end{bmatrix}'] # LaTeX矩阵结束标记 + return '\n'.join(rv) # 返回完整的LaTeX矩阵字符串 + +## 侧边栏设置 +with st.sidebar: # 创建侧边栏 + # 创建滑块以选择a的行数，范围为3到6，默认值为3 + num_a = st.slider('Number of rows, a:', 3, 6, step=1) + # 创建滑块以选择b的行数，范围为3到6，默认值为3 + num_b = st.slider('Number of rows, b:', 3, 6, step=1) + +# 随机生成矩阵a，值在0到1之间，形状为(num_a, 1) +a = np.random.uniform(0, 1, num_a).reshape((-1, 1)) +a = np.round(a, 1) # 将矩阵a的值保留一位小数 +# 随机生成矩阵b，值在0到1之间，形状为(num_b, 1) +b = np.random.uniform(0, 1, num_b).reshape((-1, 1)) +b = np.round(b, 1) # 将矩阵b的值保留一位小数 + +show_number = False # 初始化显示数值的变量为False +with st.sidebar: # 在侧边栏中添加复选框 + # 创建复选框用于控制是否显示矩阵数值 + show_number = st.checkbox('Display values') + +# 计算a与b转置的张量积 +tensor_a_b = a @ b.T + +## 数据可视化部分 +# 在Streamlit中以LaTeX格式展示矩阵a +st.latex('a = ' + bmatrix(a)) +# 在Streamlit中以LaTeX格式展示矩阵b +st.latex('b = ' + bmatrix(b)) +# 展示张量积公式 +st.latex('a \\otimes b = ab^{T}') +# 展示矩阵a与b的张量积计算结果 +st.latex(bmatrix(a) + '@' + bmatrix(b.T) + ' = ' + bmatrix(tensor_a_b)) + +# 创建三个列布局 +col1, col2, col3 = st.columns(3) + +# 在第一列展示矩阵a的热图 +with col1: + fig_a = px.imshow(a, text_auto=show_number, # 绘制热图，并根据show_number显示数值 + color_continuous_scale='viridis', # 设置颜色映射 + aspect='equal') # 设置宽高比为1:1 + fig_a.update_layout(height=400, width=300) # 设置图形大小 + fig_a.layout.coloraxis.showscale = False # 隐藏颜色条 + st.plotly_chart(fig_a) # 在Streamlit中显示图形 + +# 在第二列展示矩阵b的热图 +with col2: + fig_b = px.imshow(b, text_auto=show_number, # 绘制热图，并根据show_number显示数值 + color_continuous_scale='viridis', # 设置颜色映射 + aspect='equal') # 设置宽高比为1:1 + fig_b.update_layout(height=400, width=300) # 设置图形大小 + fig_b.layout.coloraxis.showscale = False # 隐藏颜色条 + st.plotly_chart(fig_b) # 在Streamlit中显示图形 + +# 在第三列展示张量积矩阵的热图 +with col3: + fig_ab = px.imshow(tensor_a_b, text_auto=show_number, # 绘制热图，并根据show_number显示数值 + color_continuous_scale='viridis', # 设置颜色映射 + aspect='equal') # 设置宽高比为1:1 + fig_ab.update_layout(height=400, width=400) # 设置图形大小 + fig_ab.layout.coloraxis.showscale = False # 隐藏颜色条 + st.plotly_chart(fig_ab) # 在Streamlit中显示图形 + + + + + + + diff --git a/Book4_Ch03_Python_Codes/Bk4_Ch03_01.ipynb b/Book4_Ch03_Python_Codes/Bk4_Ch03_01.ipynb new file mode 100644 index 0000000..b98a7ff --- /dev/null +++ b/Book4_Ch03_Python_Codes/Bk4_Ch03_01.ipynb @@ -0,0 +1,200 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 03\n", + "\n", + "# 向量范数等高线\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "bfe060c3-1f87-4555-942f-91819dedbdef", + "metadata": {}, + "source": [ + "\n", + "该代码绘制了不同 $L_p$ 范数的等高线图，使用 $p$ 的不同值展示 $L_p$ 范数的变化，包括 $L_{\\infty}$ 范数（$p = \\infty$）。$L_p$ 范数的定义为：\n", + "\n", + "$$\n", + "\\| x \\|_p = \\left( |x_1|^p + |x_2|^p \\right)^{\\frac{1}{p}}\n", + "$$\n", + "\n", + "当 $p = \\infty$ 时，$L_{\\infty}$ 范数定义为：\n", + "\n", + "$$\n", + "\\| x \\|_{\\infty} = \\max(|x_1|, |x_2|)\n", + "$$\n", + "\n", + "代码通过 `contourf` 绘制 $L_p$ 范数的等高线图，并在每个子图中使用黑色等高线标记 $L_p = 1$ 的轮廓。结果展示了 $p$ 不同取值下 $L_p$ 范数的几何形状，包括常见的曼哈顿距离（$p=1$）、欧几里得距离（$p=2$）、极值距离（$p=\\infty$）等。\n", + "注意，只有 $p >= 1$ 时，$L_p$ 才是范数。" + ] + }, + { + "cell_type": "markdown", + "id": "fba95b79-06c5-4ce2-9a60-ad86e6688bea", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a8030be8-a689-4793-9d41-a6ced817a09c", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt # 导入Matplotlib库，用于绘图\n", + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "9e25548a-d3eb-4006-a4d2-42702bc4b9ae", + "metadata": {}, + "source": [ + "## 定义p值列表" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3944440f-2896-4d70-832f-2e416060a078", + "metadata": {}, + "outputs": [], + "source": [ + "p_values = [0.05, 0.2, 0.5, 1, 1.5, 2, 4, 8, np.inf] # 定义不同的p值" + ] + }, + { + "cell_type": "markdown", + "id": "de436abc-f816-412c-bf1a-e81b4065d93a", + "metadata": {}, + "source": [ + "## 设置x1和x2的范围" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "560d0437-2b43-466d-a718-b752c8d4924e", + "metadata": {}, + "outputs": [], + "source": [ + "x1 = np.linspace(-2.5, 2.5, num=101) # 定义x1的范围\n", + "x2 = x1 # 设置x2的范围与x1相同" + ] + }, + { + "cell_type": "markdown", + "id": "8227f96c-85a1-4d7c-a313-35b9f6d73b09", + "metadata": {}, + "source": [ + "## 创建网格" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e88b12e6-8c34-4215-bb60-627d38460cd9", + "metadata": {}, + "outputs": [], + "source": [ + "xx1, xx2 = np.meshgrid(x1, x2) # 生成x1和x2的网格" + ] + }, + { + "cell_type": "markdown", + "id": "90e3739c-9d38-4880-a458-fe37b300b0cd", + "metadata": {}, + "source": [ + "## 创建绘图画布" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0c0504fd-b4c1-478c-abe1-009857482db9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(ncols=3, nrows=3, figsize=(12, 12)) # 创建3x3子图\n", + "\n", + "## 遍历p值并绘制Lp范数的等高线图\n", + "for p, ax in zip(p_values, axes.flat): # 遍历每个p值和子图轴\n", + " \n", + " if np.isinf(p): # 检查p是否为无穷大\n", + " zz = np.maximum(np.abs(xx1), np.abs(xx2)) # L∞范数计算\n", + " else:\n", + " zz = ((np.abs((xx1))**p) + (np.abs((xx2))**p))**(1./p) # Lp范数计算\n", + " \n", + " ## 绘制Lp的等高线图\n", + " ax.contourf(xx1, xx2, zz, 20, cmap='RdYlBu_r') # 使用填充的等高线图展示Lp范数\n", + " \n", + " ## 绘制Lp=1的等高线\n", + " ax.contour(xx1, xx2, zz, [1], colors='k', linewidths=2) # 绘制Lp=1的等高线，颜色为黑色\n", + " \n", + " ## 图形装饰\n", + " ax.axhline(y=0, color='k', linewidth=0.25) # 绘制y=0的水平线\n", + " ax.axvline(x=0, color='k', linewidth=0.25) # 绘制x=0的垂直线\n", + " ax.set_xlim(-2.5, 2.5) # 设置x轴范围\n", + " ax.set_ylim(-2.5, 2.5) # 设置y轴范围\n", + " ax.spines['top'].set_visible(False) # 隐藏顶部边框\n", + " ax.spines['right'].set_visible(False) # 隐藏右侧边框\n", + " ax.spines['bottom'].set_visible(False) # 隐藏底部边框\n", + " ax.spines['left'].set_visible(False) # 隐藏左侧边框\n", + " ax.set_xlabel('$x_1$') # 设置x轴标签\n", + " ax.set_ylabel('$x_2$') # 设置y轴标签\n", + " ax.set_title('p = ' + str(p)) # 设置子图标题，显示当前的p值\n", + " ax.set_aspect('equal', adjustable='box') # 设置坐标轴比例为相等\n", + "\n", + "plt.tight_layout()\n", + "plt.show() # 显示图形" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch03_Python_Codes/Bk4_Ch03_02.ipynb b/Book4_Ch03_Python_Codes/Bk4_Ch03_02.ipynb new file mode 100644 index 0000000..2286a54 --- /dev/null +++ b/Book4_Ch03_Python_Codes/Bk4_Ch03_02.ipynb @@ -0,0 +1,277 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 03\n", + "\n", + "# 向量L2范数\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "5de35728-d92e-4001-b0cf-042b170a09bf", + "metadata": {}, + "source": [ + "这段代码在二维平面上绘制了三个向量 $\\vec{u}$、$\\vec{v}$ 和 $\\vec{w}$，并用标签标注了向量模长。首先定义向量 $\\vec{u} = [4, 3]$ 和 $\\vec{v} = [-2, 4]$，并将 $\\vec{u} + \\vec{v} = [2, 7]$ 存入 $\\vec{w}$。这些向量用 `plt.quiver` 在图上绘制，以便可视化不同方向与长度的向量关系。\n", + "\n", + "模长（$L_2$ 范数）公式为：\n", + "\n", + "$$\n", + "\\|\\vec{u}\\|_2 = \\sqrt{u_1^2 + u_2^2}\n", + "$$\n", + "\n", + "对于向量 $\\vec{u} = [4, 3]$ 和 $\\vec{v} = [-2, 4]$，各自的模长分别为：\n", + "\n", + "$$\n", + "\\|\\vec{u}\\|_2 = \\sqrt{4^2 + 3^2} = 5\n", + "$$\n", + "\n", + "$$\n", + "\\|\\vec{v}\\|_2 = \\sqrt{(-2)^2 + 4^2} = \\sqrt{20} \\approx 4.47\n", + "$$\n", + "\n", + "并且 $\\vec{u} + \\vec{v}$ 的模长为：\n", + "\n", + "$$\n", + "\\|\\vec{u} + \\vec{v}\\|_2 = \\sqrt{2^2 + 7^2} = \\sqrt{53} \\approx 7.28\n", + "$$\n", + "\n", + "代码最终生成带有坐标轴和网格的平面图，展示不同向量模长在同一图中的可视化效果。" + ] + }, + { + "cell_type": "markdown", + "id": "aba40400-b1f9-4ebd-94e7-7aa28002a559", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "084c8a2b-02e8-4cc1-9243-84502efce78a", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算\n", + "from matplotlib import pyplot as plt # 导入Matplotlib库，用于绘图\n", + "import seaborn as sns # 导入Seaborn库，用于调色" + ] + }, + { + "cell_type": "markdown", + "id": "7a578343-5a67-4f79-85d6-60c1fe976f09", + "metadata": {}, + "source": [ + "## 定义自定义函数，用于绘制向量及标注" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4087477b-9463-4e7f-968b-3be248d53c46", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_vectors(vectors, labels, ax_limits=(-2, 8), grid=True):\n", + " \"\"\"\n", + " 绘制二维向量及其模长标注\n", + "\n", + " 参数:\n", + " vectors (list): 每个向量的起点和终点，格式为[[x1, y1, dx, dy], ...]\n", + " labels (list): 每个向量的标注，格式为[(x_pos, y_pos, text, color_index), ...]\n", + " ax_limits (tuple): 坐标轴的范围，格式为(min, max)\n", + " grid (bool): 是否显示网格\n", + " \"\"\"\n", + " # 创建绘图画布\n", + " fig, ax = plt.subplots()\n", + "\n", + " # 分解向量起点和分量，用于绘图\n", + " x_coords = [v[0] for v in vectors] # 向量的x起点\n", + " y_coords = [v[1] for v in vectors] # 向量的y起点\n", + " dx_coords = [v[2] for v in vectors] # 向量的x分量\n", + " dy_coords = [v[3] for v in vectors] # 向量的y分量\n", + "\n", + " # 绘制向量\n", + " plt.quiver(x_coords, y_coords, dx_coords, dy_coords,\n", + " angles='xy', scale_units='xy', scale=1, \n", + " color=sns.color_palette())\n", + "\n", + " # 绘制坐标轴\n", + " plt.axvline(x=0, color='grey') # y轴\n", + " plt.axhline(y=0, color='grey') # x轴\n", + "\n", + " # 标注向量模长\n", + " for x_pos, y_pos, text, color_index in labels:\n", + " plt.text(x_pos, y_pos, text, \n", + " color=sns.color_palette()[color_index], size=12, \n", + " ha='center', va='center')\n", + "\n", + " # 设置图形细节\n", + " plt.ylabel('$x_2$') # y轴标签\n", + " plt.xlabel('$x_1$') # x轴标签\n", + " plt.axis('scaled') # 坐标轴比例相等\n", + " ax.set_xticks(np.arange(ax_limits[0], ax_limits[1] + 1)) # 设置x轴刻度\n", + " ax.set_yticks(np.arange(ax_limits[0], ax_limits[1] + 1)) # 设置y轴刻度\n", + " ax.set_xlim(ax_limits[0], ax_limits[1]) # 设置x轴范围\n", + " ax.set_ylim(ax_limits[0], ax_limits[1]) # 设置y轴范围\n", + "\n", + " if grid:\n", + " ax.grid(linestyle='--', linewidth=0.25, color=[0.5, 0.5, 0.5]) # 网格\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "17bd337a-d684-4bb7-9b57-054105665e5a", + "metadata": {}, + "source": [ + "## 定义向量" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "080c77e1-cab4-47cc-b722-8bc3fbe5a51a", + "metadata": {}, + "outputs": [], + "source": [ + "u = [0, 0, 4, 3] # 向量u的起点和分量" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "985922c6-9d7f-4a2f-9d45-a2df2d21f0a8", + "metadata": {}, + "outputs": [], + "source": [ + "v = [0, 0, -2, 4] # 向量v的起点和分量" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "61aae2a9-665b-4cf2-bd2e-e8a4bdbb75d1", + "metadata": {}, + "outputs": [], + "source": [ + "u_bis = [4, 3, v[2], v[3]] # u和v的组合向量" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f3ce312e-bcb1-440b-b29a-335212853107", + "metadata": {}, + "outputs": [], + "source": [ + "w = [0, 0, 2, 7] # 向量w的起点和分量" + ] + }, + { + "cell_type": "markdown", + "id": "a52a3b62-fd8b-4302-8da0-2ac962ebd09a", + "metadata": {}, + "source": [ + "## 定义向量列表" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e48cb395-a074-44e8-a053-347f55e2b4d7", + "metadata": {}, + "outputs": [], + "source": [ + "vectors = [u, u_bis, w] # 所有向量" + ] + }, + { + "cell_type": "markdown", + "id": "1c68bd01-79a2-47c7-b785-28c8198bf67c", + "metadata": {}, + "source": [ + "## 定义标注列表" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e2c78180-546e-4ffc-9ac2-1385806034cc", + "metadata": {}, + "outputs": [], + "source": [ + "labels = [\n", + " (3, 1, r'$||\\vec{u}||_2$', 0), # 向量u的模长标注\n", + " (3, 6, r'$||\\vec{v}||_2$', 1), # 向量v的模长标注\n", + " (0, 4, r'$||\\vec{u}+\\vec{v}||_2$', 2) # 向量u+v的模长标注\n", + "]" + ] + }, + { + "cell_type": "markdown", + "id": "e41b2a77-b526-4a96-8e49-a602120b3df1", + "metadata": {}, + "source": [ + "## 调用自定义函数绘制图形" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "66d5a6c2-7dfa-4ba0-b092-55d9666bace7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_vectors(vectors, labels)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch03_Python_Codes/Streamlit_Bk4_Ch03_01.py b/Book4_Ch03_Python_Codes/Streamlit_Bk4_Ch03_01.py new file mode 100644 index 0000000..a4ad6f4 --- /dev/null +++ b/Book4_Ch03_Python_Codes/Streamlit_Bk4_Ch03_01.py @@ -0,0 +1,61 @@ + +############### +# Authored by Weisheng Jiang +# Book 4 | From Basic Arithmetic to Machine Learning +# Published and copyrighted by Tsinghua University Press +# Beijing, China, 2025 +############### + +## 导入必要的库 +import streamlit as st # 引入Streamlit库，用于创建交互式Web应用 +import plotly.graph_objects as go # 引入Plotly图形对象模块，用于绘图 +import numpy as np # 引入NumPy库，用于数值计算 + +## 定义网格数据 +x1 = np.linspace(-2.5, 2.5, num=101) # 生成x1的线性等间距数组，范围为-2.5到2.5，共101个点 +x2 = x1 # 定义x2与x1相同 +xx1, xx2 = np.meshgrid(x1, x2) # 使用meshgrid生成二维网格数据 + +## 创建侧边栏以选择参数p +with st.sidebar: # 在侧边栏中设置参数 + st.write('Note: Lp norm, p >= 1') # 显示提示信息：Lp范数，p >= 1 + p = st.slider('p', # 创建滑块选择p值 + min_value=-20.0, # p值的最小值为-20.0 + max_value=20.0, # p值的最大值为20.0 + step=0.2) # p值的步长为0.2 + +## 计算Lp范数的二维数据 +zz = ((np.abs((xx1))**p) + (np.abs((xx2))**p))**(1. / p) # 根据Lp范数公式计算二维数据zz + +## 创建二维等高线图 +fig_1 = go.Figure(data= + go.Contour(z=zz, # 设置z轴数据为zz + x=x1, # 设置x轴数据为x1 + y=x2, # 设置y轴数据为x2 + colorscale='RdYlBu_r')) # 设置颜色映射为红黄蓝反转 + +fig_1.update_layout( # 更新图形布局 + autosize=False, # 关闭自动调整大小 + width=500, # 设置图形宽度为500 + height=500, # 设置图形高度为500 + margin=dict( # 设置图形边距 + l=50, # 左边距为50 + r=50, # 右边距为50 + b=50, # 底边距为50 + t=50)) # 顶边距为50 + +## 创建三维表面图 +fig_2 = go.Figure( + go.Surface( + x=x1, # 设置x轴数据为x1 + y=x2, # 设置y轴数据为x2 + z=zz, # 设置z轴数据为zz + colorscale='RdYlBu_r')) # 设置颜色映射为红黄蓝反转 + +## 展示二维等高线图 +with st.expander('2D contour'): # 创建可展开部分，标题为“2D contour” + st.plotly_chart(fig_1) # 在Streamlit中显示二维等高线图 + +## 展示三维表面图 +with st.expander('3D surface'): # 创建可展开部分，标题为“3D surface” + st.plotly_chart(fig_2) # 在Streamlit中显示三维表面图 diff --git a/Book4_Ch03_Python_Codes/Streamlit_Bk4_Ch03_03.py b/Book4_Ch03_Python_Codes/Streamlit_Bk4_Ch03_03.py new file mode 100644 index 0000000..2dc70d6 --- /dev/null +++ b/Book4_Ch03_Python_Codes/Streamlit_Bk4_Ch03_03.py @@ -0,0 +1,104 @@ + +############### +# Authored by Weisheng Jiang +# Book 4 | From Basic Arithmetic to Machine Learning +# Published and copyrighted by Tsinghua University Press +# Beijing, China, 2025 +############### + +## 导入必要的库 +import plotly.graph_objects as go # 引入Plotly库，用于绘图 +import streamlit as st # 引入Streamlit库，用于创建交互式Web应用 +import numpy as np # 引入NumPy库，用于数值计算 +import plotly.express as px # 引入Plotly Express库，用于快速绘图 +import pandas as pd # 引入Pandas库，用于数据操作 +import sympy # 引入Sympy库，用于符号计算 +from scipy.spatial import distance # 引入SciPy库中的距离模块 + +## 定义距离计算函数 +# 定义计算Minkowski距离的函数 +# 如果设置Chebychev为True，则计算Chebychev距离，否则根据参数p计算Minkowski距离 +def fcn_Minkowski(xx, yy, mu, p=2, Chebychev=False): + if Chebychev: # 如果选择Chebychev距离 + zz = np.maximum(np.abs(xx - mu[0]), np.abs(yy - mu[1])) # 计算Chebychev距离 + else: # 否则计算Minkowski距离 + zz = ((np.abs((xx - mu[0]))**p) + (np.abs((yy - mu[1]))**p))**(1. / p) # 计算公式 + return zz # 返回计算结果 + +# 定义计算Mahalanobis距离的函数 +# 可以选择是否标准化Sigma矩阵 + +def fcn_mahal(xx, yy, mu, Sigma, standardized=False): + if standardized: # 如果选择标准化 + D = np.diag(np.diag(Sigma)) # 提取对角线元素 + Sigma_inv = np.linalg.inv(D) # 计算逆矩阵 + else: # 否则直接计算Sigma的逆矩阵 + Sigma_inv = np.linalg.inv(Sigma) + xy_ = np.stack((xx.flatten(), yy.flatten())).T # 将输入数组展平并堆叠 + zz = np.diag(np.sqrt(np.dot(np.dot((xy_ - mu), Sigma_inv), (xy_ - mu).T))) # 计算Mahalanobis距离 + zz = np.reshape(zz, xx.shape) # 重塑计算结果为网格形状 + return zz # 返回计算结果 + +## 加载数据集 +# 使用Plotly自带的鸢尾花数据集 + +df = px.data.iris() + +## 创建侧边栏 +with st.sidebar: # 定义侧边栏区域 + dist_type = st.radio('Choose a type of distance: ', # 添加单选按钮选择距离类型 + options=['Euclidean', 'City block', 'Minkowski', 'Chebychev', 'Mahalanobis', 'Standardized Euclidean']) + if dist_type == 'Minkowski': # 如果选择Minkowski距离 + with st.sidebar: # 添加滑块以选择p值 + p = st.slider('Specify a p value:', 1.0, 20.0, step=0.5) + +## 计算距离 +X = df[['sepal_length', 'petal_length']] # 提取鸢尾花数据集中感兴趣的特征 +mu = X.mean().to_numpy() # 计算特征的均值 +Sigma = X.cov().to_numpy() # 计算特征的协方差矩阵 +x_array = np.linspace(0, 10, 101) # 定义x轴网格点 +y_array = np.linspace(0, 10, 101) # 定义y轴网格点 +xx, yy = np.meshgrid(x_array, y_array) # 创建二维网格 + +if dist_type == 'Minkowski': # 如果选择Minkowski距离 + zz = fcn_Minkowski(xx, yy, mu, p) # 计算Minkowski距离 +elif dist_type == 'Euclidean': # 如果选择欧几里得距离 + zz = fcn_Minkowski(xx, yy, mu, 2) # 使用p=2计算Minkowski距离 +elif dist_type == 'Chebychev': # 如果选择Chebychev距离 + zz = fcn_Minkowski(xx, yy, mu, Chebychev=True) # 调用函数计算Chebychev距离 +elif dist_type == 'Mahalanobis': # 如果选择Mahalanobis距离 + zz = fcn_mahal(xx, yy, mu, Sigma) # 调用函数计算Mahalanobis距离 +elif dist_type == 'City block': # 如果选择曼哈顿距离 + zz = fcn_Minkowski(xx, yy, mu, 1) # 使用p=1计算Minkowski距离 +elif dist_type == 'Standardized Euclidean': # 如果选择标准化欧几里得距离 + zz = fcn_mahal(xx, yy, mu, Sigma, True) # 调用函数计算标准化欧几里得距离 + +## 数据可视化 +st.title(dist_type + ' distance') # 设置标题 +fig_2 = px.scatter(df, x='sepal_length', y='petal_length') # 绘制散点图 +fig_2.add_trace(go.Contour( # 添加等高线 + x=x_array, # 设置x轴网格点 + y=y_array, # 设置y轴网格点 + z=zz, # 设置计算的距离数据 + contours_coloring='lines', # 等高线的样式 + showscale=False)) # 不显示颜色条 +fig_2.add_traces( + px.scatter(X.mean().to_frame().T, # 绘制均值点 + x='sepal_length', # x轴为花萼长度 + y='petal_length').update_traces( + marker_size=20, # 设置标记大小 + marker_color="red", # 设置标记颜色 + marker_symbol='x').data) +fig_2.update_layout(yaxis_range=[0, 10]) # 设置y轴范围 +fig_2.update_layout(xaxis_range=[0, 10]) # 设置x轴范围 +fig_2.add_hline(y=mu[1]) # 添加水平线 +fig_2.add_vline(x=mu[0]) # 添加垂直线 +fig_2.update_yaxes( + scaleratio=1, # 设置y轴比例 +) +fig_2.update_layout(width=600, height=600) # 设置图形尺寸 +st.plotly_chart(fig_2) # 在Streamlit中显示图形 + + + + \ No newline at end of file diff --git a/Book4_Ch04_Python_Codes/Bk4_Ch04_01.ipynb b/Book4_Ch04_Python_Codes/Bk4_Ch04_01.ipynb new file mode 100644 index 0000000..5161dfb --- /dev/null +++ b/Book4_Ch04_Python_Codes/Bk4_Ch04_01.ipynb @@ -0,0 +1,406 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 04\n", + "\n", + "# NumPy数组\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "e8ae51ee-958b-484b-8ddc-fa7aad6bd2a5", + "metadata": {}, + "source": [ + "这段代码演示了如何在 NumPy 中定义不同维度的数组和矩阵，并输出每种数据结构的形状和类型。首先定义一个 $2 \\times 2$ 的二维矩阵 $A_{\\text{matrix}}$：\n", + "\n", + "$$\n", + "A_{\\text{matrix}} = \\begin{bmatrix} 2 & 4 \\\\ 6 & 8 \\end{bmatrix}\n", + "$$\n", + "\n", + "其类型为 `np.matrix`，形状为 $(2, 2)$。\n", + "\n", + "接下来，定义了一维数组 $A_{\\text{1d}} = [2, 4]$，其形状为 $(2,)$，类型为 `np.ndarray`。然后定义一个二维数组 $A_{\\text{2d}}$，与 $A_{\\text{matrix}}$ 具有相同的数据内容和形状 $(2, 2)$，类型为 `np.ndarray`：\n", + "\n", + "$$\n", + "A_{\\text{2d}} = \\begin{bmatrix} 2 & 4 \\\\ 6 & 8 \\end{bmatrix}\n", + "$$\n", + "\n", + "最后，通过三个 $2 \\times 2$ 数组 $A1$、$A2$ 和 $A3$ 构建了一个三维数组 $A_{\\text{3d}}$：\n", + "\n", + "$$\n", + "A_{\\text{3d}} = \\begin{bmatrix} \\begin{bmatrix} 2 & 4 \\\\ 6 & 8 \\end{bmatrix}, \\begin{bmatrix} 1 & 3 \\\\ 5 & 7 \\end{bmatrix}, \\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix} \\end{bmatrix}\n", + "$$\n", + "\n", + "三维数组的形状为 $(3, 2, 2)$，类型为 `np.ndarray`。这些定义展示了 NumPy 中矩阵和数组在一维、二维和三维空间的不同表示方式及其对应的形状信息。" + ] + }, + { + "cell_type": "markdown", + "id": "361fb77e-857e-4843-bfed-2b91753d3173", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "99f7bc75-95de-4ac9-8641-2f2d6446d5de", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "3dad65f7-ba8f-4402-bbfc-379396517927", + "metadata": {}, + "source": [ + "## 定义二维矩阵" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ce746ee1-6041-49c9-964c-4ebc513ceda0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[2, 4],\n", + " [6, 8]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_matrix = np.matrix([[2, 4], # 定义矩阵A_matrix\n", + " [6, 8]])\n", + "A_matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5eb2aa30-3537-48b7-9cd8-375b126ece82", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 2)\n" + ] + } + ], + "source": [ + "print(A_matrix.shape) # 输出矩阵的形状" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "28d1ad2b-e3e0-47c3-9e45-e47eaebf38e7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(A_matrix)) # 输出矩阵的类型" + ] + }, + { + "cell_type": "markdown", + "id": "8c571ccc-746f-4da0-9a4e-1b9868033465", + "metadata": {}, + "source": [ + "## 定义一维数组" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "96121e32-ab22-4c8e-882e-698348bdd152", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2, 4])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_1d = np.array([2, 4]) # 定义一维数组A_1d\n", + "A_1d" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "730a99d6-1623-4078-8cf2-90b22f28d966", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2,)\n" + ] + } + ], + "source": [ + "print(A_1d.shape) # 输出数组的形状" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "56457d26-1eca-4cec-b29b-7896f99ec064", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(A_1d)) # 输出数组的类型" + ] + }, + { + "cell_type": "markdown", + "id": "367612cb-9b72-405f-a55e-2fb950889246", + "metadata": {}, + "source": [ + "## 定义二维数组" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3196ea94-71bd-44a6-8079-812dd3c3757c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2, 4],\n", + " [6, 8]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_2d = np.array([[2, 4], # 定义二维数组A_2d\n", + " [6, 8]])\n", + "A_2d" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b61ac04b-4060-44fb-ad4d-a171536b5411", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 2)\n" + ] + } + ], + "source": [ + "print(A_2d.shape) # 输出数组的形状" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3a011d02-b22c-42a5-97e7-b652bc543ec0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(A_2d)) # 输出数组的类型" + ] + }, + { + "cell_type": "markdown", + "id": "3bd3a633-c4f6-46cb-a325-fe0d9b28cf92", + "metadata": {}, + "source": [ + "## 定义三维数组" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "16daa0c8-c544-46ba-be31-eaa40ba2dbe4", + "metadata": {}, + "outputs": [], + "source": [ + "A1 = [[2, 4], # 定义第一个二维数组A1\n", + " [6, 8]]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "fc2603f8-e6e9-4f81-9918-fbbe49bf3127", + "metadata": {}, + "outputs": [], + "source": [ + "A2 = [[1, 3], # 定义第二个二维数组A2\n", + " [5, 7]]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "51c45098-6ebd-44ea-8360-190b70b9ce41", + "metadata": {}, + "outputs": [], + "source": [ + "A3 = [[1, 0], # 定义第三个二维数组A3\n", + " [0, 1]]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ba92b36b-bd5c-4df2-a829-982b292f0368", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[2, 4],\n", + " [6, 8]],\n", + "\n", + " [[1, 3],\n", + " [5, 7]],\n", + "\n", + " [[1, 0],\n", + " [0, 1]]])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_3d = np.array([A1, A2, A3]) # 将A1、A2和A3组合为三维数组A_3d\n", + "A_3d" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8687bb73-81ac-4ad4-9722-1bbbdc29fd28", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3, 2, 2)\n" + ] + } + ], + "source": [ + "print(A_3d.shape) # 输出三维数组的形状" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "6e36a674-efa1-4584-8037-2b117ceece6f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(A_3d)) # 输出数组的类型" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch04_Python_Codes/Bk4_Ch04_02.ipynb b/Book4_Ch04_Python_Codes/Bk4_Ch04_02.ipynb new file mode 100644 index 0000000..bdc2497 --- /dev/null +++ b/Book4_Ch04_Python_Codes/Bk4_Ch04_02.ipynb @@ -0,0 +1,188 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 04\n", + "\n", + "# diag() 函数\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "53c03812-0303-4691-9961-f87c9059705c", + "metadata": {}, + "source": [ + "\n", + "\n", + "该代码首先定义了一个 $3 \\times 3$ 的矩阵 $A$：\n", + "\n", + "$$\n", + "A = \\begin{bmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\\\ 7 & 8 & 9 \\end{bmatrix}\n", + "$$\n", + "\n", + "然后，代码使用 `np.diag` 提取矩阵 $A$ 的对角元素，得到向量 $a = [1, 5, 9]$。接下来，通过向量 $a$ 构建了一个新的对角矩阵 $A_{\\text{diag}}$，其形式为：\n", + "\n", + "$$\n", + "A_{\\text{diag}} = \\begin{bmatrix} 1 & 0 & 0 \\\\ 0 & 5 & 0 \\\\ 0 & 0 & 9 \\end{bmatrix}\n", + "$$\n", + "\n", + "此过程展示了从一个矩阵中提取对角线元素并利用这些元素构造新的对角矩阵的操作。" + ] + }, + { + "cell_type": "markdown", + "id": "ccb1e0a3-d0ed-4996-9880-b08ba4918993", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e1227d8c-7f70-48b9-af13-a17776aa8152", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "49b8f8e3-3955-48f6-ab9c-de1db5afbe2a", + "metadata": {}, + "source": [ + "## 定义矩阵" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c6358766-e0e7-480c-814e-c1ccfbae8e24", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[1, 2, 3],\n", + " [4, 5, 6],\n", + " [7, 8, 9]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A = np.matrix([[1, 2, 3], # 定义矩阵A\n", + " [4, 5, 6],\n", + " [7, 8, 9]])\n", + "A " + ] + }, + { + "cell_type": "markdown", + "id": "3a682155-7c02-4961-acb9-ab7a3c1b17e8", + "metadata": {}, + "source": [ + "## 提取对角元素" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7b2ea9e5-48fa-4b8f-ad4c-6b040817a15d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 5, 9])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = np.diag(A) # 提取矩阵A的对角元素\n", + "a" + ] + }, + { + "cell_type": "markdown", + "id": "f4e2f66a-370e-410a-ab12-c1f071662dc9", + "metadata": {}, + "source": [ + "## 构造对角矩阵" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "eea76f59-4071-47b4-b852-740f3df7045c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 0, 0],\n", + " [0, 5, 0],\n", + " [0, 0, 9]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_diag = np.diag(a) # 使用对角元素a构造对角矩阵A_diag\n", + "A_diag" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch04_Python_Codes/Bk4_Ch04_03.ipynb b/Book4_Ch04_Python_Codes/Bk4_Ch04_03.ipynb new file mode 100644 index 0000000..a78bb27 --- /dev/null +++ b/Book4_Ch04_Python_Codes/Bk4_Ch04_03.ipynb @@ -0,0 +1,260 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 04\n", + "\n", + "# 矩阵加减法\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "a8042cab-e99c-4d94-a9be-96175baa837e", + "metadata": {}, + "source": [ + "该代码定义了两个 $2 \\times 2$ 矩阵 $A$ 和 $B$，分别为：\n", + "\n", + "$$\n", + "A = \\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\end{bmatrix}, \\quad B = \\begin{bmatrix} 2 & 6 \\\\ 4 & 8 \\end{bmatrix}\n", + "$$\n", + "\n", + "代码随后计算了矩阵 $A$ 和 $B$ 的加法与减法。矩阵加法 $A + B$ 的结果为：\n", + "\n", + "$$\n", + "A + B = \\begin{bmatrix} 1+2 & 2+6 \\\\ 3+4 & 4+8 \\end{bmatrix} = \\begin{bmatrix} 3 & 8 \\\\ 7 & 12 \\end{bmatrix}\n", + "$$\n", + "\n", + "矩阵减法 $A - B$ 的结果为：\n", + "\n", + "$$\n", + "A - B = \\begin{bmatrix} 1-2 & 2-6 \\\\ 3-4 & 4-8 \\end{bmatrix} = \\begin{bmatrix} -1 & -4 \\\\ -1 & -4 \\end{bmatrix}\n", + "$$\n", + "\n", + "代码展示了使用 `np.add` 和 `np.subtract` 函数以及直接使用操作符完成矩阵加减法的两种实现方式。" + ] + }, + { + "cell_type": "markdown", + "id": "05fbf711-6eee-49a5-a5a5-a00c9726e60e", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ced7d4cd-a41e-4a61-b8eb-a5221ac81fcf", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "f2afe209-4fad-4614-9697-2c8dcee0ac98", + "metadata": {}, + "source": [ + "## 定义矩阵" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7c955d5b-6e3b-4ae8-b162-16e5b739b31a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[1, 2],\n", + " [3, 4]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A = np.matrix([[1, 2], \n", + " [3, 4]]) # 定义矩阵A\n", + "A" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7d16a094-2bae-46e1-b98c-35e1a1cbabba", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[2, 6],\n", + " [4, 8]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "B = np.matrix([[2, 6], \n", + " [4, 8]]) # 定义矩阵B\n", + "B" + ] + }, + { + "cell_type": "markdown", + "id": "83b0d359-e7e0-45ed-9241-b5643ec9a631", + "metadata": {}, + "source": [ + "## 矩阵加法" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "476f434f-f285-47f2-b444-240bf970142d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[ 3, 8],\n", + " [ 7, 12]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_plus_B = np.add(A, B) # 使用np.add函数计算矩阵A和B的和\n", + "A_plus_B" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "dbeb5ab0-70f7-4c11-9ba4-86fceeade833", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[ 3, 8],\n", + " [ 7, 12]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_plus_B_2 = A + B # 使用加法操作符计算矩阵A和B的和\n", + "A_plus_B_2" + ] + }, + { + "cell_type": "markdown", + "id": "8d40792e-8cd1-4d9a-a372-38bf758f6f6e", + "metadata": {}, + "source": [ + "## 矩阵减法" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d1535c49-e64c-4503-8655-405263614ae6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[-1, -4],\n", + " [-1, -4]])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_minus_B = np.subtract(A, B) # 使用np.subtract函数计算矩阵A和B的差\n", + "A_minus_B" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "32372955-1f18-4c2f-bcb7-fc734e608328", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[-1, -4],\n", + " [-1, -4]])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_minus_B_2 = A - B # 使用减法操作符计算矩阵A和B的差\n", + "A_minus_B_2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch04_Python_Codes/Bk4_Ch04_04.ipynb b/Book4_Ch04_Python_Codes/Bk4_Ch04_04.ipynb new file mode 100644 index 0000000..39b617d --- /dev/null +++ b/Book4_Ch04_Python_Codes/Bk4_Ch04_04.ipynb @@ -0,0 +1,173 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 04\n", + "\n", + "# 矩阵标量乘法\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "0cf4bb7f-f36d-486a-9187-a6f4f7ec18ba", + "metadata": {}, + "source": [ + "该代码定义了一个标量 $k = 2$ 和一个 $2 \\times 2$ 矩阵 $X$：\n", + "\n", + "$$\n", + "X = \\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\end{bmatrix}\n", + "$$\n", + "\n", + "代码随后计算了标量 $k$ 与矩阵 $X$ 的乘积，得到的结果矩阵 $k \\times X$ 为：\n", + "\n", + "$$\n", + "k \\times X = 2 \\times \\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\end{bmatrix} = \\begin{bmatrix} 2 & 4 \\\\ 6 & 8 \\end{bmatrix}\n", + "$$\n", + "\n", + "代码展示了使用 `np.dot` 函数和直接标量乘法来实现标量与矩阵乘积的两种方法。" + ] + }, + { + "cell_type": "markdown", + "id": "9b646351-bc61-4c43-96ed-a265eb25eaac", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "9a74e2ab-fc70-43a4-85f6-3ddeeacfc5ab", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "6bf76475-2000-4adb-82bf-33664ee781da", + "metadata": {}, + "source": [ + "## 定义标量和矩阵" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e74e9afd-6c86-4ccd-bd9e-4382bfe0c31f", + "metadata": {}, + "outputs": [], + "source": [ + "k = 2 # 定义标量k" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "db0ca529-60e7-4093-8942-8976a5bc8b29", + "metadata": {}, + "outputs": [], + "source": [ + "X = [[1, 2], \n", + " [3, 4]] # 定义矩阵X" + ] + }, + { + "cell_type": "markdown", + "id": "8a306144-ae4b-4b29-9b1a-9a4282ef2f21", + "metadata": {}, + "source": [ + "## 标量与矩阵的乘法" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "33380485-bdda-4392-8ace-7e11690f111b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2, 4],\n", + " [6, 8]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "k_times_X = np.dot(k, X) # 使用np.dot计算k和X的标量乘法\n", + "k_times_X" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "be39b596-ea34-4108-9447-e3a46d21f91c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[2, 4],\n", + " [6, 8]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "k_times_X_2 = k * np.matrix(X) # 使用*操作符计算k和X的标量乘法\n", + "k_times_X_2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch04_Python_Codes/Bk4_Ch04_05.ipynb b/Book4_Ch04_Python_Codes/Bk4_Ch04_05.ipynb new file mode 100644 index 0000000..b36e643 --- /dev/null +++ b/Book4_Ch04_Python_Codes/Bk4_Ch04_05.ipynb @@ -0,0 +1,362 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 04\n", + "\n", + "# 广播机制\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "61a42cc1-9923-4983-973d-b03b59d6acc1", + "metadata": {}, + "source": [ + "这段代码展示了 NumPy 的广播机制，通过定义矩阵、标量、列向量和行向量进行一系列加法操作。代码首先定义了一个 $3 \\times 2$ 的矩阵 $A$、一个标量 $k$、一个列向量 $c$ 和一个行向量 $r$。它们的具体定义如下：\n", + "\n", + "$$\n", + "A = \\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\\\ 5 & 6 \\end{bmatrix}, \\quad k = 2, \\quad c = \\begin{bmatrix} 3 \\\\ 2 \\\\ 1 \\end{bmatrix}, \\quad r = \\begin{bmatrix} 2 & 1 \\end{bmatrix}\n", + "$$\n", + "\n", + "代码使用 NumPy 广播机制，分别计算以下几种加法操作：\n", + "\n", + "1. **矩阵 $A$ 与标量 $k$ 相加**：标量 $k$ 会广播到矩阵 $A$ 的每个元素，即每个元素都加上 $k$ 值。这种情况下，运算结果为：\n", + "\n", + " $$\n", + " A + k = \\begin{bmatrix} 1+2 & 2+2 \\\\ 3+2 & 4+2 \\\\ 5+2 & 6+2 \\end{bmatrix} = \\begin{bmatrix} 3 & 4 \\\\ 5 & 6 \\\\ 7 & 8 \\end{bmatrix}\n", + " $$\n", + "\n", + "2. **矩阵 $A$ 与列向量 $c$ 相加**：列向量 $c$ 被广播到矩阵 $A$ 的每一列，使得 $c$ 的每个元素与 $A$ 相同行的每个元素相加，得到：\n", + "\n", + " $$\n", + " A + c = \\begin{bmatrix} 1+3 & 2+3 \\\\ 3+2 & 4+2 \\\\ 5+1 & 6+1 \\end{bmatrix} = \\begin{bmatrix} 4 & 5 \\\\ 5 & 6 \\\\ 6 & 7 \\end{bmatrix}\n", + " $$\n", + "\n", + "3. **矩阵 $A$ 与行向量 $r$ 相加**：行向量 $r$ 被广播到矩阵 $A$ 的每一行，使得 $r$ 的每个元素与 $A$ 相同行的每个元素相加，结果为：\n", + "\n", + " $$\n", + " A + r = \\begin{bmatrix} 1+2 & 2+1 \\\\ 3+2 & 4+1 \\\\ 5+2 & 6+1 \\end{bmatrix} = \\begin{bmatrix} 3 & 3 \\\\ 5 & 5 \\\\ 7 & 7 \\end{bmatrix}\n", + " $$\n", + "\n", + "4. **列向量 $c$ 与行向量 $r$ 相加**：通过广播，$c$ 和 $r$ 组合成一个 $3 \\times 2$ 的矩阵。每个 $c$ 的元素加到每一行的 $r$ 上，得到：\n", + "\n", + " $$\n", + " c + r = \\begin{bmatrix} 3+2 & 3+1 \\\\ 2+2 & 2+1 \\\\ 1+2 & 1+1 \\end{bmatrix} = \\begin{bmatrix} 5 & 4 \\\\ 4 & 3 \\\\ 3 & 2 \\end{bmatrix}\n", + " $$\n", + "\n", + "该代码展示了 NumPy 广播机制的灵活性，使得矩阵、向量和标量间的加法运算在不同维度下可以直接进行。" + ] + }, + { + "cell_type": "markdown", + "id": "dbbb9e8f-480a-4b84-be1c-10299faa79c3", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2da2788b-62a1-4402-bcc8-7c4448392cb3", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "371997be-719d-416d-9e23-6c0c9ae9bc96", + "metadata": {}, + "source": [ + "## 定义矩阵" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7acefee2-ddb0-4ec5-924e-b15c468f3bda", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[1, 2],\n", + " [3, 4],\n", + " [5, 6]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A = np.matrix([[1, 2], # 定义矩阵A\n", + " [3, 4],\n", + " [5, 6]])\n", + "A" + ] + }, + { + "cell_type": "markdown", + "id": "6a695575-9a76-41e6-bb17-6d77d1dbca49", + "metadata": {}, + "source": [ + "## 定义标量" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7b44157d-b5c4-450c-b5a9-8c17ec1fb9fc", + "metadata": {}, + "outputs": [], + "source": [ + "k = 2 # 定义标量k" + ] + }, + { + "cell_type": "markdown", + "id": "950972dd-22ff-4a81-9793-2172ba4cc752", + "metadata": {}, + "source": [ + "## 定义列向量" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f59ea6bd-d607-48cf-8a7f-80eb5aac438c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[3],\n", + " [2],\n", + " [1]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c = np.array([[3], # 定义列向量c\n", + " [2],\n", + " [1]])\n", + "c" + ] + }, + { + "cell_type": "markdown", + "id": "1a4a65e0-ce82-414a-990b-64713bca3913", + "metadata": {}, + "source": [ + "## 定义行向量" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c571bb39-d6b7-44ea-b5d7-2b197223eb5f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2, 1]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r = np.array([[2, 1]]) # 定义行向量r\n", + "r" + ] + }, + { + "cell_type": "markdown", + "id": "7a7d2094-3824-4efa-a099-40781551d1ff", + "metadata": {}, + "source": [ + "## 广播原则" + ] + }, + { + "cell_type": "markdown", + "id": "82e777a0-142f-4a7d-b3e1-2e38af1fe399", + "metadata": {}, + "source": [ + "## 矩阵A加标量k" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c7c158d0-9576-471c-953f-8767f19d9473", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[3, 4],\n", + " [5, 6],\n", + " [7, 8]])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_plus_k = A + k # 矩阵A与标量k相加\n", + "A_plus_k" + ] + }, + { + "cell_type": "markdown", + "id": "07c8aa0c-d857-4267-a1b7-99c7fc856f6d", + "metadata": {}, + "source": [ + "## 矩阵A加列向量c" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "919ef4b1-d43d-4c1e-933c-f9c8fde768f1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[4, 5],\n", + " [5, 6],\n", + " [6, 7]])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_plus_c = A + c # 矩阵A与列向量c相加\n", + "A_plus_c" + ] + }, + { + "cell_type": "markdown", + "id": "07bd091a-0642-400a-8fd2-57ea4588875a", + "metadata": {}, + "source": [ + "## 矩阵A加行向量r" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3a18f414-460e-452e-808e-47fd9d339345", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[3, 3],\n", + " [5, 5],\n", + " [7, 7]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_plus_r = A + r # 矩阵A与行向量r相加\n", + "A_plus_r" + ] + }, + { + "cell_type": "markdown", + "id": "5fd72975-156a-46c3-abce-170467f5d416", + "metadata": {}, + "source": [ + "## 列向量c加行向量r" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e5ad12d3-b203-4a4e-90c4-20b693dfa4a2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[5, 4],\n", + " [4, 3],\n", + " [3, 2]])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c_plus_r = c + r # 列向量c与行向量r相加\n", + "c_plus_r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch04_Python_Codes/Bk4_Ch04_06.ipynb b/Book4_Ch04_Python_Codes/Bk4_Ch04_06.ipynb new file mode 100644 index 0000000..873706c --- /dev/null +++ b/Book4_Ch04_Python_Codes/Bk4_Ch04_06.ipynb @@ -0,0 +1,202 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 04\n", + "\n", + "# 矩阵乘法\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "f78179ac-736d-417f-964f-a079c966931d", + "metadata": {}, + "source": [ + "\n", + "\n", + "该代码定义了两个 $2 \\times 2$ 的矩阵 $A$ 和 $B$，并计算了它们的矩阵乘积。矩阵 $A$ 和 $B$ 分别为：\n", + "\n", + "$$\n", + "A = \\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\end{bmatrix}, \\quad B = \\begin{bmatrix} 2 & 4 \\\\ 1 & 3 \\end{bmatrix}\n", + "$$\n", + "\n", + "矩阵乘积 $A @ B$ 的计算结果为：\n", + "\n", + "$$\n", + "A @ B = \\begin{bmatrix} 1 \\cdot 2 + 2 \\cdot 1 & 1 \\cdot 4 + 2 \\cdot 3 \\\\ 3 \\cdot 2 + 4 \\cdot 1 & 3 \\cdot 4 + 4 \\cdot 3 \\end{bmatrix} = \\begin{bmatrix} 4 & 10 \\\\ 10 & 24 \\end{bmatrix}\n", + "$$\n", + "\n", + "代码中，矩阵乘法操作使用了 `np.matmul` 函数和 `@` 运算符两种方式。这展示了 NumPy 中进行矩阵乘法的两种等效方法。" + ] + }, + { + "cell_type": "markdown", + "id": "cc4e525d-60d4-4447-a29e-2e1ead9aa96e", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "80885172-f546-4973-add9-496ddb779de5", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "bef4a295-b3fe-493c-9baf-04b2a95d913e", + "metadata": {}, + "source": [ + "## 定义两个矩阵" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8abe8f8d-6398-4bb6-ac14-a1b1139873fd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 2],\n", + " [3, 4]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A = np.array([[1, 2], # 定义矩阵A\n", + " [3, 4]])\n", + "A" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "dbb8337a-f940-4337-9a98-65692ff3e854", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2, 4],\n", + " [1, 3]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "B = np.array([[2, 4], # 定义矩阵B\n", + " [1, 3]])\n", + "B" + ] + }, + { + "cell_type": "markdown", + "id": "fd37527e-b082-4899-a2fe-6b04c8db9fea", + "metadata": {}, + "source": [ + "## 矩阵乘法" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "313d8fec-6e35-4e36-900f-efa4bd5c6adc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 4, 10],\n", + " [10, 24]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_times_B = np.matmul(A, B) # 使用np.matmul计算矩阵A和B的乘积\n", + "A_times_B" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3efab8d4-012b-4f28-b515-d9047d180a89", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 4, 10],\n", + " [10, 24]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_times_B_2 = A @ B # 使用@操作符计算矩阵A和B的乘积\n", + "A_times_B_2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch04_Python_Codes/Bk4_Ch04_07.ipynb b/Book4_Ch04_Python_Codes/Bk4_Ch04_07.ipynb new file mode 100644 index 0000000..3970160 --- /dev/null +++ b/Book4_Ch04_Python_Codes/Bk4_Ch04_07.ipynb @@ -0,0 +1,249 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 04\n", + "\n", + "# 矩阵乘法操作\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "d134e1be-222a-4fec-b5d9-78dfd4fcb3cc", + "metadata": {}, + "source": [ + "该代码演示了 NumPy 中数组和矩阵的乘法操作，分别展示了逐元素乘法和矩阵乘法的不同结果。\n", + "\n", + "1. **逐元素乘法**：在第一个操作中，$A$ 和 $B$ 都是 `np.array` 类型。按逐元素方式进行乘法时，$A$ 将被广播到与 $B$ 形状相匹配，结果为：\n", + "\n", + " $$\n", + " A \\odot B = \\begin{bmatrix} 1 \\times 5 & 2 \\times 6 \\\\ 1 \\times 8 & 2 \\times 9 \\end{bmatrix} = \\begin{bmatrix} 5 & 12 \\\\ 8 & 18 \\end{bmatrix}\n", + " $$\n", + "\n", + "2. **矩阵乘法**：在第二个操作中，$A$ 为 `np.array` 类型，而 $B$ 为 `np.matrix` 类型。此时 `*` 操作符按矩阵乘法执行，计算结果为：\n", + "\n", + " $$\n", + " A \\times B = \\begin{bmatrix} 1 \\times 5 + 2 \\times 8 & 1 \\times 6 + 2 \\times 9 \\end{bmatrix} = \\begin{bmatrix} 21 & 24 \\end{bmatrix}\n", + " $$\n", + "\n", + "3. **矩阵乘法**：在第三个操作中，$A$ 和 $B$ 都是 `np.matrix` 类型，再次执行矩阵乘法，结果与第二个操作相同：\n", + "\n", + " $$\n", + " A \\times B = \\begin{bmatrix} 21 & 24 \\end{bmatrix}\n", + " $$\n", + "\n", + "此代码展示了在 NumPy 中 `np.array` 和 `np.matrix` 类型的不同行为及 `*` 操作符在逐元素和矩阵乘法间的区别。" + ] + }, + { + "cell_type": "markdown", + "id": "e694f73c-5da9-404b-930b-1b15c38c149e", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "04dd0c40-af12-47f6-8f60-1bba1b377b51", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "9dab05d3-2be2-47c9-97a5-e1b779132a1f", + "metadata": {}, + "source": [ + "## 定义数组A和B并进行逐元素乘法" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "87bb0d5c-67d8-4a10-95c8-c407a32932ad", + "metadata": {}, + "outputs": [], + "source": [ + "A = np.array([[1, 2]]) # 定义数组A" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8b9a1b34-090e-4432-a096-d45934e8c0aa", + "metadata": {}, + "outputs": [], + "source": [ + "B = np.array([[5, 6], # 定义数组B\n", + " [8, 9]])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ef365f07-ebfe-432e-9ea3-bc45cecc0335", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 5, 12],\n", + " [ 8, 18]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A * B # 打印A和B的逐元素乘法结果" + ] + }, + { + "cell_type": "markdown", + "id": "00486c88-927e-4c24-b2be-d6f9e8672e0f", + "metadata": {}, + "source": [ + "## 定义数组A和矩阵B并进行矩阵乘法" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "82d3c241-4790-40c4-aa1f-3a383250ba74", + "metadata": {}, + "outputs": [], + "source": [ + "A = np.array([[1, 2]]) # 定义数组A" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e6298ff4-cf44-4851-a835-d22563bd4d1d", + "metadata": {}, + "outputs": [], + "source": [ + "B = np.matrix([[5, 6], # 定义矩阵B\n", + " [8, 9]])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c036b953-8d3d-443e-87eb-1fe46fcd6014", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[21, 24]])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A * B # 打印A和B的矩阵乘法结果" + ] + }, + { + "cell_type": "markdown", + "id": "ab903f71-3eb5-4290-a835-ae58622e69a4", + "metadata": {}, + "source": [ + "## 定义矩阵A和矩阵B并进行矩阵乘法" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ab60983c-0ad3-4263-ad82-84986df908d0", + "metadata": {}, + "outputs": [], + "source": [ + "A = np.matrix([[1, 2]]) # 定义矩阵A" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6ccade11-529f-4962-8eab-139e08a62592", + "metadata": {}, + "outputs": [], + "source": [ + "B = np.matrix([[5, 6], # 定义矩阵B\n", + " [8, 9]])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e60a1889-600c-4982-9b61-3001d9fbd32f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[21, 24]])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A * B # 打印A和B的矩阵乘法结果" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch04_Python_Codes/Bk4_Ch04_08.ipynb b/Book4_Ch04_Python_Codes/Bk4_Ch04_08.ipynb new file mode 100644 index 0000000..0dea556 --- /dev/null +++ b/Book4_Ch04_Python_Codes/Bk4_Ch04_08.ipynb @@ -0,0 +1,202 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 04\n", + "\n", + "# 矩阵幂\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "82179f04-01ef-4824-a7ec-80be438ed9fd", + "metadata": {}, + "source": [ + "该代码演示了在 NumPy 中如何计算矩阵的三次幂与逐元素三次方的区别：\n", + "\n", + "1. **矩阵的三次幂**：通过 `matrix_power` 或连续的矩阵乘法 `A @ A @ A` 计算矩阵 $A$ 的三次幂。给定矩阵：\n", + "\n", + " $$\n", + " A = \\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\end{bmatrix}\n", + " $$\n", + "\n", + " 其三次幂 $A^3$ 计算为：\n", + "\n", + " $$\n", + " A^3 = A @ A @ A = \\begin{bmatrix} 37 & 54 \\\\ 81 & 118 \\end{bmatrix}\n", + " $$\n", + "\n", + "2. **逐元素三次方**：`A ** 3` 计算的是矩阵 $A$ 每个元素的三次方，结果为：\n", + "\n", + " $$\n", + " A \\odot A \\odot A = \\begin{bmatrix} 1^3 & 2^3 \\\\ 3^3 & 4^3 \\end{bmatrix} = \\begin{bmatrix} 1 & 8 \\\\ 27 & 64 \\end{bmatrix}\n", + " $$\n", + "\n", + "代码展示了矩阵幂运算（整体矩阵相乘）和逐元素幂运算（每个元素单独运算）的区别。" + ] + }, + { + "cell_type": "markdown", + "id": "5a569286-52c7-4d2b-a1c1-57f1b89ba147", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "826fccd1-ad68-46f8-8229-75da1e8ddec8", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from numpy.linalg import matrix_power as pw # 导入矩阵幂函数" + ] + }, + { + "cell_type": "markdown", + "id": "f0390858-5fb8-4db6-8139-a9c6e98b48ec", + "metadata": {}, + "source": [ + "## 定义矩阵" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b358aa8f-44ad-4366-8fd5-9890ab983691", + "metadata": {}, + "outputs": [], + "source": [ + "A = np.array([[1., 2.], # 定义矩阵A\n", + " [3., 4.]])" + ] + }, + { + "cell_type": "markdown", + "id": "1ee41f87-83e0-417e-8429-5650e71574c9", + "metadata": {}, + "source": [ + "## 计算矩阵的三次幂" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "dcff939d-82f9-4098-ada3-81a6bf29e76d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 37., 54.],\n", + " [ 81., 118.]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_3 = pw(A, 3) # 使用matrix_power计算矩阵A的三次幂\n", + "A_3" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fa89d52c-7726-4d10-b170-ddf0274aa160", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 37., 54.],\n", + " [ 81., 118.]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A @ A @ A # 使用矩阵乘法逐步计算A的三次幂" + ] + }, + { + "cell_type": "markdown", + "id": "3290bcd6-38f4-449f-8dd0-4e51a00a7067", + "metadata": {}, + "source": [ + "## 元素逐次三次方" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9cf3a84f-d907-4e8e-b3e9-c0637c68bd97", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1., 8.],\n", + " [27., 64.]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_3_piecewise = A ** 3 # 计算矩阵A的每个元素的三次方\n", + "A_3_piecewise" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch04_Python_Codes/Bk4_Ch04_09.ipynb b/Book4_Ch04_Python_Codes/Bk4_Ch04_09.ipynb new file mode 100644 index 0000000..87bf84c --- /dev/null +++ b/Book4_Ch04_Python_Codes/Bk4_Ch04_09.ipynb @@ -0,0 +1,181 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 04\n", + "\n", + "# 矩阵乘幂比较\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "f7cb8538-a1e9-4d16-9e49-6772327912c0", + "metadata": {}, + "source": [ + "\n", + "该代码展示了 `np.matrix` 和 `np.array` 在平方操作中的不同行为。\n", + "\n", + "1. **矩阵平方（`np.matrix` 类型）**：当 $A$ 是 `np.matrix` 类型时，`A**2` 计算的是矩阵乘法，即 $A @ A$。对于矩阵：\n", + "\n", + " $$\n", + " A = \\begin{bmatrix} 1 & 3 \\\\ 2 & 4 \\end{bmatrix}\n", + " $$\n", + "\n", + " 其平方 $A^2$ 计算为：\n", + "\n", + " $$\n", + " A^2 = \\begin{bmatrix} 1 & 3 \\\\ 2 & 4 \\end{bmatrix} @ \\begin{bmatrix} 1 & 3 \\\\ 2 & 4 \\end{bmatrix} = \\begin{bmatrix} 7 & 15 \\\\ 10 & 22 \\end{bmatrix}\n", + " $$\n", + "\n", + "2. **逐元素平方（`np.array` 类型）**：当 $B$ 是 `np.array` 类型时，`B**2` 计算的是逐元素平方，即每个元素单独平方。对于数组：\n", + "\n", + " $$\n", + " B = \\begin{bmatrix} 1 & 3 \\\\ 2 & 4 \\end{bmatrix}\n", + " $$\n", + "\n", + " 逐元素平方的结果为：\n", + "\n", + " $$\n", + " B\\odot B = \\begin{bmatrix} 1^2 & 3^2 \\\\ 2^2 & 4^2 \\end{bmatrix} = \\begin{bmatrix} 1 & 9 \\\\ 4 & 16 \\end{bmatrix}\n", + " $$\n", + "\n", + "此代码展示了 `np.matrix` 和 `np.array` 在平方操作上的关键差异：一个执行矩阵乘法，另一个进行逐元素运算。" + ] + }, + { + "cell_type": "markdown", + "id": "9734eeec-2b37-40f9-add5-c4ccd409546a", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4b42a3b3-504c-45eb-8c6b-2830e6a11be8", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "79f50411-80c3-487e-b20d-e42867cea09a", + "metadata": {}, + "source": [ + "## 定义矩阵A并计算其矩阵平方" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5879a711-cd82-4352-a41f-c9b950865d71", + "metadata": {}, + "outputs": [], + "source": [ + "A = np.matrix([[1, 3], # 定义为np.matrix类型的矩阵A\n", + " [2, 4]])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "02a0e4c0-e50d-4955-8e72-351468e22d57", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 7 15]\n", + " [10 22]]\n" + ] + } + ], + "source": [ + "print(A**2) # 打印矩阵A的矩阵平方结果" + ] + }, + { + "cell_type": "markdown", + "id": "8dee9c28-b297-4f4d-9f0b-b0c8880d792e", + "metadata": {}, + "source": [ + "## 定义数组B并计算其逐元素平方" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7ab6ed46-fca3-46de-aa69-8d1a16b67d24", + "metadata": {}, + "outputs": [], + "source": [ + "B = np.array([[1, 3], # 定义为np.array类型的数组B\n", + " [2, 4]])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8e1194bb-59fa-40a2-b0a2-e2c85b7cc667", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1 9]\n", + " [ 4 16]]\n" + ] + } + ], + "source": [ + "print(B**2) # 打印数组B的逐元素平方结果" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch04_Python_Codes/Bk4_Ch04_10.ipynb b/Book4_Ch04_Python_Codes/Bk4_Ch04_10.ipynb new file mode 100644 index 0000000..55a4990 --- /dev/null +++ b/Book4_Ch04_Python_Codes/Bk4_Ch04_10.ipynb @@ -0,0 +1,178 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 04\n", + "\n", + "# 转置\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "34fd7eb5-f8ae-40eb-832c-23f93d07cfeb", + "metadata": {}, + "source": [ + "该代码定义了一个 $3 \\times 2$ 矩阵 $A$，并计算其转置矩阵。矩阵 $A$ 定义为：\n", + "\n", + "$$\n", + "A = \\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\\\ 5 & 6 \\end{bmatrix}\n", + "$$\n", + "\n", + "矩阵的转置 $A^T$ 将行变为列，结果为一个 $2 \\times 3$ 的矩阵：\n", + "\n", + "$$\n", + "A^T = \\begin{bmatrix} 1 & 3 & 5 \\\\ 2 & 4 & 6 \\end{bmatrix}\n", + "$$\n", + "\n", + "代码使用了两种方法来计算转置矩阵：`A.transpose()` 方法和 `A.T` 属性，二者等效。这段代码展示了如何在 NumPy 中对矩阵进行转置操作。" + ] + }, + { + "cell_type": "markdown", + "id": "4562dc5f-106d-458a-9c21-058f45dc7750", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "492fc116-d1e3-404a-92fc-92bf126234a5", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "58efb734-2fce-475e-a954-2ff78a1bf71f", + "metadata": {}, + "source": [ + "## 定义矩阵A" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1581437b-c937-42fc-b1f1-c176a48b0a33", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 2],\n", + " [3, 4],\n", + " [5, 6]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A = np.array([[1, 2], # 定义矩阵A\n", + " [3, 4],\n", + " [5, 6]])\n", + "A" + ] + }, + { + "cell_type": "markdown", + "id": "13eeb291-b311-4823-a983-c9749695b2e2", + "metadata": {}, + "source": [ + "## 计算矩阵的转置" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d34daecc-75e6-4f6f-9af7-d506d9d73eb9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 3, 5],\n", + " [2, 4, 6]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_T = A.transpose() # 使用transpose方法计算A的转置\n", + "A_T" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5ac7a53b-8e59-40ee-a2d8-dafe251f386d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 3, 5],\n", + " [2, 4, 6]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_T_2 = A.T # 使用.T属性计算A的转置\n", + "A_T_2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch04_Python_Codes/Bk4_Ch04_11.ipynb b/Book4_Ch04_Python_Codes/Bk4_Ch04_11.ipynb new file mode 100644 index 0000000..f81dde2 --- /dev/null +++ b/Book4_Ch04_Python_Codes/Bk4_Ch04_11.ipynb @@ -0,0 +1,183 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 04\n", + "\n", + "# 矩阵逆\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "17664ff7-4c6b-4539-80c1-07f98b6ef2c2", + "metadata": {}, + "source": [ + "该代码定义了一个 $2 \\times 2$ 矩阵 $A$，并计算其逆矩阵 $A^{-1}$。矩阵 $A$ 为：\n", + "\n", + "$$\n", + "A = \\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\end{bmatrix}\n", + "$$\n", + "\n", + "通过求逆操作得到 $A$ 的逆矩阵：\n", + "\n", + "$$\n", + "A^{-1} = \\begin{bmatrix} -2 & 1 \\\\ 1.5 & -0.5 \\end{bmatrix}\n", + "$$\n", + "\n", + "接下来，代码计算矩阵 $A$ 与其逆矩阵 $A^{-1}$ 的乘积，理论上应得到单位矩阵：\n", + "\n", + "$$\n", + "A @ A^{-1} = \\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix}\n", + "$$\n", + "\n", + "这段代码展示了如何使用 `inv` 函数计算矩阵的逆，并验证矩阵与其逆矩阵的乘积结果。" + ] + }, + { + "cell_type": "markdown", + "id": "1feaec35-bb29-42b9-a011-ad9135b0c638", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5d2a42fe-89e9-4736-b847-a7433aece846", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from numpy.linalg import inv # 导入矩阵求逆函数" + ] + }, + { + "cell_type": "markdown", + "id": "8ed902be-675e-4438-b550-dbbbf9cf6a66", + "metadata": {}, + "source": [ + "## 定义矩阵A" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d8339162-83a4-47b2-9d41-2203ab292820", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 2.],\n", + " [3., 4.]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A = np.array([[1., 2.], # 定义矩阵A\n", + " [3., 4.]])\n", + "A" + ] + }, + { + "cell_type": "markdown", + "id": "fb5a51d4-624e-48fb-b792-54c433bb0df9", + "metadata": {}, + "source": [ + "## 计算矩阵的逆" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dee6461e-cf77-4d73-b4a2-552c0bbe4fa7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-2. , 1. ],\n", + " [ 1.5, -0.5]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_inverse = inv(A) # 计算矩阵A的逆\n", + "A_inverse" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ff4c814d-c6e7-416a-b027-0a2a28ef8ba1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1.00000000e+00, 1.11022302e-16],\n", + " [0.00000000e+00, 1.00000000e+00]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_times_A_inv = A @ A_inverse # 计算矩阵A与其逆矩阵的乘积\n", + "A_times_A_inv" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch04_Python_Codes/Bk4_Ch04_12.ipynb b/Book4_Ch04_Python_Codes/Bk4_Ch04_12.ipynb new file mode 100644 index 0000000..b182d4f --- /dev/null +++ b/Book4_Ch04_Python_Codes/Bk4_Ch04_12.ipynb @@ -0,0 +1,171 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 04\n", + "\n", + "# 矩阵逆\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "c83af894-1177-41f1-9e0c-5df36a5e4755", + "metadata": {}, + "source": [ + "该代码演示了 `np.matrix` 和 `np.array` 在计算矩阵逆时的区别。矩阵 $A$ 被定义为 `np.matrix` 类型，直接使用 `.I` 属性即可求逆；而矩阵 $B$ 被定义为 `np.array` 类型，不支持 `.I` 属性，因此会报错。\n", + "\n", + "矩阵 $A$ 的定义为：\n", + "\n", + "$$\n", + "A = \\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\end{bmatrix}\n", + "$$\n", + "\n", + "其逆矩阵为：\n", + "\n", + "$$\n", + "A^{-1} = \\begin{bmatrix} -2 & 1 \\\\ 1.5 & -0.5 \\end{bmatrix}\n", + "$$\n", + "\n", + "`np.matrix` 类型允许直接调用 `.I` 属性计算逆矩阵，而 `np.array` 类型则需使用 `numpy.linalg.inv` 函数求逆。" + ] + }, + { + "cell_type": "markdown", + "id": "a7654b39-8ea4-480f-9b62-949c3e52bbfe", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e3ba8f7c-9319-46f3-a52c-9eeef1ed5ae5", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "b11501ac-e96b-45ab-9563-63977efe46f7", + "metadata": {}, + "source": [ + "## 定义矩阵A并计算其逆" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "368c1708-7217-4844-9b32-3e9398c15358", + "metadata": {}, + "outputs": [], + "source": [ + "A = np.matrix([[1, 2], # 定义为np.matrix类型的矩阵A\n", + " [3, 4]])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "56017ddb-fe6d-4d98-ba7a-963a3b854428", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-2. 1. ]\n", + " [ 1.5 -0.5]]\n" + ] + } + ], + "source": [ + "print(A.I) # 打印矩阵A的逆矩阵" + ] + }, + { + "cell_type": "markdown", + "id": "fb72cfe6-f62d-42a2-ac12-3a551854f4cb", + "metadata": {}, + "source": [ + "## 定义数组B并尝试计算其逆" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "abc5a48d-5499-41e4-b826-a9b63acfd8ba", + "metadata": {}, + "outputs": [], + "source": [ + "B = np.array([[1, 2], # 定义为np.array类型的数组B\n", + " [3, 4]])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "afd919b3-7d56-4543-b1fb-a78bca4bbc26", + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'numpy.ndarray' object has no attribute 'I'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[6], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(B\u001b[38;5;241m.\u001b[39mI)\n", + "\u001b[1;31mAttributeError\u001b[0m: 'numpy.ndarray' object has no attribute 'I'" + ] + } + ], + "source": [ + "print(B.I) # 尝试打印数组B的逆，会报错" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch04_Python_Codes/Bk4_Ch04_13.ipynb b/Book4_Ch04_Python_Codes/Bk4_Ch04_13.ipynb new file mode 100644 index 0000000..323971d --- /dev/null +++ b/Book4_Ch04_Python_Codes/Bk4_Ch04_13.ipynb @@ -0,0 +1,160 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 04\n", + "\n", + "# 迹\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "8cc1d765-91db-4530-81ad-0220895c1e85", + "metadata": {}, + "source": [ + "该代码定义了一个 $3 \\times 3$ 矩阵 $A$，并计算其迹（trace）。矩阵 $A$ 的定义为：\n", + "\n", + "$$\n", + "A = \\begin{bmatrix} 1 & -1 & 0 \\\\ 3 & 2 & 4 \\\\ -2 & 0 & 3 \\end{bmatrix}\n", + "$$\n", + "\n", + "矩阵的迹是其主对角线元素之和，公式为：\n", + "\n", + "$$\n", + "\\text{tr}(A) = A_{11} + A_{22} + A_{33}\n", + "$$\n", + "\n", + "因此，矩阵 $A$ 的迹为：\n", + "\n", + "$$\n", + "\\text{tr}(A) = 1 + 2 + 3 = 6\n", + "$$\n", + "\n", + "此代码展示了如何使用 `np.trace` 函数计算矩阵的迹。" + ] + }, + { + "cell_type": "markdown", + "id": "ba8dee01-3887-4a76-93a9-274b079171a1", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "650779c1-a190-44cc-a778-127b2c189962", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "5ff0a2c5-dcea-4891-84d4-7a72436e6772", + "metadata": {}, + "source": [ + "## 定义矩阵A" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a1a28546-6d6c-4f65-a94f-c8cb27e5ead5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1, -1, 0],\n", + " [ 3, 2, 4],\n", + " [-2, 0, 3]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A = np.array([[1, -1, 0], # 定义矩阵A\n", + " [3, 2, 4],\n", + " [-2, 0, 3]])\n", + "A" + ] + }, + { + "cell_type": "markdown", + "id": "7b8f3355-005a-4b5f-be18-41ada700fc7b", + "metadata": {}, + "source": [ + "## 计算矩阵A的迹" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9e5b87ef-8278-4900-b60c-6e96a60e5eef", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tr_A = np.trace(A) # 计算矩阵A的迹\n", + "tr_A" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch04_Python_Codes/Bk4_Ch04_14.ipynb b/Book4_Ch04_Python_Codes/Bk4_Ch04_14.ipynb new file mode 100644 index 0000000..d369d34 --- /dev/null +++ b/Book4_Ch04_Python_Codes/Bk4_Ch04_14.ipynb @@ -0,0 +1,175 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 04\n", + "\n", + "# 矩阵逐项积\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "cb498579-9952-45fc-93e8-50479104f8f2", + "metadata": {}, + "source": [ + "\n", + "该代码定义了两个 $2 \\times 2$ 矩阵 $A$ 和 $B$，并计算它们的 Hadamard 积（逐元素乘积）。矩阵 $A$ 和 $B$ 分别为：\n", + "\n", + "$$\n", + "A = \\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\end{bmatrix}, \\quad B = \\begin{bmatrix} 5 & 6 \\\\ 7 & 8 \\end{bmatrix}\n", + "$$\n", + "\n", + "Hadamard 积（逐元素乘积）的结果为每个对应元素相乘，计算公式为：\n", + "\n", + "$$\n", + "A \\odot B = \\begin{bmatrix} 1 \\cdot 5 & 2 \\cdot 6 \\\\ 3 \\cdot 7 & 4 \\cdot 8 \\end{bmatrix} = \\begin{bmatrix} 5 & 12 \\\\ 21 & 32 \\end{bmatrix}\n", + "$$\n", + "\n", + "代码使用 `np.multiply` 函数和 `*` 操作符两种方式来计算逐元素乘积，二者等效。该操作用于生成对应元素相乘的矩阵。" + ] + }, + { + "cell_type": "markdown", + "id": "46ade452-7ec0-45e9-959c-1276be6d4724", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c90949ae-66bd-4373-ac80-42341574da7c", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "9b8e04f7-6950-42d1-9981-81ee65208cce", + "metadata": {}, + "source": [ + "## 定义矩阵A和B" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bab49ebe-1142-4a6b-9662-ccc569aaf590", + "metadata": {}, + "outputs": [], + "source": [ + "A = np.array([[1, 2], # 定义矩阵A\n", + " [3, 4]])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c63f1c20-b2b9-4688-ab7d-800ed8510add", + "metadata": {}, + "outputs": [], + "source": [ + "B = np.array([[5, 6], # 定义矩阵B\n", + " [7, 8]])" + ] + }, + { + "cell_type": "markdown", + "id": "861a16bd-2946-438e-8aed-1b974e7d99d6", + "metadata": {}, + "source": [ + "## 计算Hadamard积（逐元素乘积）" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f0947846-bc63-482d-a5ac-a6e891794832", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 5, 12],\n", + " [21, 32]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_times_B_piecewise = np.multiply(A, B) # 使用np.multiply计算A和B的逐元素乘积\n", + "A_times_B_piecewise" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7e81c46d-d82b-45fa-b22b-5f99b812f2e4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 5, 12],\n", + " [21, 32]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_times_B_piecewise_V2 = A * B # 使用*操作符计算A和B的逐元素乘积\n", + "A_times_B_piecewise_V2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch04_Python_Codes/Bk4_Ch04_15.ipynb b/Book4_Ch04_Python_Codes/Bk4_Ch04_15.ipynb new file mode 100644 index 0000000..f5f9213 --- /dev/null +++ b/Book4_Ch04_Python_Codes/Bk4_Ch04_15.ipynb @@ -0,0 +1,133 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 04\n", + "\n", + "# 行列式\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "167f6933-14ac-44fb-83e3-24d28b21a894", + "metadata": {}, + "source": [ + "该代码定义了一个 $2 \\times 2$ 矩阵 $A$，并计算其行列式。矩阵 $A$ 的定义为：\n", + "\n", + "$$\n", + "A = \\begin{bmatrix} 4 & 2 \\\\ 1 & 3 \\end{bmatrix}\n", + "$$\n", + "\n", + "行列式计算公式为：\n", + "\n", + "$$\n", + "\\det(A) = A_{11} A_{22} - A_{12} A_{21}\n", + "$$\n", + "\n", + "具体计算得：\n", + "\n", + "$$\n", + "\\det(A) = 4 \\cdot 3 - 2 \\cdot 1 = 12 - 2 = 10\n", + "$$\n", + "\n", + "该代码使用 `np.linalg.det` 函数来计算行列式的值。" + ] + }, + { + "cell_type": "markdown", + "id": "38e823dc-d626-4fba-8ac6-3fc7d73e9486", + "metadata": {}, + "source": [ + "## 导入所需库" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1c1d325e-6981-4885-a9c1-d59bdbe0a194", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入NumPy库，用于数值计算" + ] + }, + { + "cell_type": "markdown", + "id": "cd7164de-4737-4076-89d3-3f7b8e5b988b", + "metadata": {}, + "source": [ + "## 定义矩阵A" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "194dc241-67d8-4ca1-a752-e6c7d2237c94", + "metadata": {}, + "outputs": [], + "source": [ + "A = np.array([[4, 2], # 定义矩阵A\n", + " [1, 3]])" + ] + }, + { + "cell_type": "markdown", + "id": "8bf849ff-6000-4d22-8e57-8d15debbb248", + "metadata": {}, + "source": [ + "## 计算矩阵A的行列式" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d910437e-4d72-4c09-8618-a809968077a9", + "metadata": {}, + "outputs": [], + "source": [ + "det_A = np.linalg.det(A) # 计算矩阵A的行列式" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch04_Python_Codes/Streamlit_Bk4_Ch04_16.py b/Book4_Ch04_Python_Codes/Streamlit_Bk4_Ch04_16.py new file mode 100644 index 0000000..d9267ef --- /dev/null +++ b/Book4_Ch04_Python_Codes/Streamlit_Bk4_Ch04_16.py @@ -0,0 +1,109 @@ + +############### +# Authored by Weisheng Jiang +# Book 4 | From Basic Arithmetic to Machine Learning +# Published and copyrighted by Tsinghua University Press +# Beijing, China, 2025 +############### + +## 导入必要的库 +import plotly.graph_objects as go # 用于创建绘图对象 +import numpy as np # 用于数值计算 +from plotly.subplots import make_subplots # 用于创建子图 +import streamlit as st # 用于构建交互式Web应用 + +## 定义一个函数，将NumPy数组格式化为LaTeX矩阵 +def bmatrix(a): + """返回一个LaTeX bmatrix格式的字符串 + :param a: 输入的NumPy数组 + :return: 返回LaTeX矩阵的字符串表示 + """ + if len(a.shape) > 2: # 检查数组是否为二维 + raise ValueError('bmatrix最多只能展示二维数组') # 如果不是二维数组，抛出异常 + lines = str(a).replace('[', '').replace(']', '').splitlines() # 去掉数组表示中的方括号并分行 + rv = [r'\begin{bmatrix}'] # 添加LaTeX矩阵的起始标签 + rv += [' ' + ' & '.join(l.split()) + r'\\' for l in lines] # 将每行元素用&连接并加上换行符 + rv += [r'\end{bmatrix}'] # 添加LaTeX矩阵的结束标签 + return '\n'.join(rv) # 返回拼接后的字符串 + +## 初始化网格范围 +n = m = 20 # 定义网格的横纵坐标范围 + +## 创建子图 +fig = make_subplots(rows=1, cols=2, horizontal_spacing=0.035) # 创建一个包含两列的子图 + +## 绘制垂直线的坐标 +xv = [] # 存储垂直线的x坐标 +yv = [] # 存储垂直线的y坐标 +for k in range(-n, n + 1): # 遍历网格范围 + xv.extend([k, k, np.nan]) # 每条垂直线的起始和结束x坐标 + yv.extend([-m, m, np.nan]) # 每条垂直线的起始和结束y坐标 + +## 绘制垂直线 +lw = 1 # 定义线条宽度 +fig.add_trace(go.Scatter(x=xv, y=yv, mode="lines", line_width=lw, line_color='red'), 1, 1) # 添加垂直线到第一个子图 + +## 绘制水平线的坐标 +xh = [] # 存储水平线的x坐标 +yh = [] # 存储水平线的y坐标 +for k in range(-m, m + 1): # 遍历网格范围 + xh.extend([-m, m, np.nan]) # 每条水平线的起始和结束x坐标 + yh.extend([k, k, np.nan]) # 每条水平线的起始和结束y坐标 + fig.add_trace(go.Scatter(x=xh, y=yh, mode="lines", line_width=lw, line_color='blue'), 1, 1) # 添加水平线到第一个子图 + +## 创建交互式侧边栏 +with st.sidebar: # 定义侧边栏 + st.latex(r''' + A = \begin{bmatrix} + a & b\\ + c & d + \end{bmatrix}''') # 显示矩阵A的LaTeX格式 + a = st.slider('a', -2.0, 2.0, step=0.1, value=1.0) # 创建滑块选择矩阵A的元素a + b = st.slider('b', -2.0, 2.0, step=0.1, value=0.0) # 创建滑块选择矩阵A的元素b + c = st.slider('c', -2.0, 2.0, step=0.1, value=0.0) # 创建滑块选择矩阵A的元素c + d = st.slider('c', -2.0, 2.0, step=0.1, value=1.0) # 创建滑块选择矩阵A的元素d + +## 定义矩阵变换 +theta = np.pi / 6 # 定义角度theta +A = np.array([[a, b], [c, d]], dtype=float) # 根据用户输入定义矩阵A + +## 应用矩阵变换到垂直线 +X = np.array(xv) # 垂直线的x坐标 +Y = np.array(yv) # 垂直线的y坐标 +Txvyv = A @ np.stack((X, Y)) # 对垂直线应用矩阵A的变换 + +## 应用矩阵变换到水平线 +X = np.array(xh) # 水平线的x坐标 +Y = np.array(yh) # 水平线的y坐标 +Txhyh = A @ np.stack((X, Y)) # 对水平线应用矩阵A的变换 + +## 显示矩阵及其计算结果 +st.latex(r'A = ' + bmatrix(A)) # 显示矩阵A的LaTeX格式 +a1 = A[:, 0].reshape((-1, 1)) # 提取矩阵A的第一列 +a2 = A[:, 1].reshape((-1, 1)) # 提取矩阵A的第二列 + +st.latex(r''' + a_1 = Ae_1 = ''' + bmatrix(A) + 'e_1 = ' + bmatrix(a1)) # 显示第一列向量的计算 +st.latex(r''' + a_2 = Ae_2 = ''' + bmatrix(A) + 'e_2 = ' + bmatrix(a2)) # 显示第二列向量的计算 +st.latex(r'\begin{vmatrix} A \end{vmatrix} = ' + str(np.linalg.det(A))) # 显示矩阵A的行列式 + +## 定义一个正方形并应用矩阵变换 +square_x = np.array([0, 1, 1, 0]) # 定义正方形的x坐标 +square_y = np.array([0, 0, 1, 1]) # 定义正方形的y坐标 +square_array = np.stack((square_x, square_y)) # 将正方形的坐标堆叠为二维数组 + +fig.add_trace(go.Scatter(x=square_x, y=square_y, fill="toself", line_color='orange'), 1, 1) # 在第一个子图中绘制原始正方形 +A_times_square_array = A @ square_array # 将正方形应用矩阵A的变换 + +fig.add_trace(go.Scatter(x=A_times_square_array[0, :], y=A_times_square_array[1, :], fill="toself", line_color='orange'), 1, 2) # 绘制变换后的正方形 +fig.add_trace(go.Scatter(x=Txvyv[0], y=Txvyv[1], mode="lines", line_width=lw, line_color='red'), 1, 2) # 绘制变换后的垂直线 +fig.add_trace(go.Scatter(x=Txhyh[0], y=Txhyh[1], mode="lines", line_width=lw, line_color='blue'), 1, 2) # 绘制变换后的水平线 + +## 更新图形布局 +fig.update_xaxes(range=[-4, 4]) # 设置x轴范围 +fig.update_yaxes(range=[-4, 4]) # 设置y轴范围 +fig.update_layout(width=800, height=500, showlegend=False, template="none", plot_bgcolor="white", yaxis2_showgrid=False, xaxis2_showgrid=False) # 设置图形布局 + +## 在Streamlit中显示图形 +st.plotly_chart(fig) # 显示绘图 diff --git a/Book4_Ch05_Python_Codes/Bk4_Ch05_01.ipynb b/Book4_Ch05_Python_Codes/Bk4_Ch05_01.ipynb new file mode 100644 index 0000000..db56753 --- /dev/null +++ b/Book4_Ch05_Python_Codes/Bk4_Ch05_01.ipynb @@ -0,0 +1,692 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 05\n", + "\n", + "# 爱因斯坦求和约定\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "05612796-d376-409c-bb07-3da0f851fa29", + "metadata": {}, + "source": [ + "这段代码使用 `numpy` 库的 `einsum` 函数进行各种矩阵和向量的运算。`einsum` 函数的主要优势在于其高效的索引处理方式，使得许多复杂的矩阵和向量操作可以用简单的字符串表达式来实现。这段代码包括以下几个主要部分：\n", + "\n", + "1. **定义向量与矩阵**： \n", + " 定义了两个列向量\n", + "\n", + " $$ a = \\begin{bmatrix} 1 \\\\ 2 \\\\ 3 \\end{bmatrix} $$\n", + " $$ b = \\begin{bmatrix} -4 \\\\ -5 \\\\ -6 \\end{bmatrix} $$\n", + "\n", + " 以及它们对应的一维向量形式 \\( a_{1D} = [1, 2, 3] \\) 和 \\( b_{1D} = [-4, -5, -6] \\)。\n", + "\n", + "3. **向量和矩阵的求和**： \n", + " 使用 `einsum('ij->', a)` 计算 \\( a \\) 中所有元素的和，即 \\( \\sum_{i,j} a_{ij} \\)。 \n", + " 同样地，`einsum('i->', a_{1D})` 计算 \\( a_{1D} \\) 的元素和，即 \\( \\sum_i a_{i} \\)。\n", + "\n", + "4. **逐元素乘积**： \n", + " 使用 `einsum('ij,ij->ij', a, b)` 计算 \\( a \\) 和 \\( b \\) 的逐元素乘积，其结果为一个矩阵，其中每个元素 \\( (i,j) \\) 对应 \\( a_{ij} \\times b_{ij} \\)。 \n", + " 对一维向量 `a_1D` 和 `b_1D` 的逐元素乘积，则通过 `einsum('i,i->i', a_{1D}, b_{1D})` 实现，得到 \\( [a_1 \\times b_1, a_2 \\times b_2, a_3 \\times b_3] \\)。\n", + "\n", + "5. **向量的内积**： \n", + " 使用 `einsum('ij,ij->', a, b)` 计算 \\( a \\) 和 \\( b \\) 的内积，即 \\( \\sum_{i,j} a_{ij} \\cdot b_{ij} \\)。 \n", + " 类似地，对于一维向量的内积，通过 `einsum('i,i->', a_{1D}, b_{1D})` 计算，公式为 \\( \\sum_i a_i \\cdot b_i \\)。\n", + "\n", + "6. **向量的外积**： \n", + " `einsum('ij,ji->ij', a, a)` 计算向量 \\( a \\) 自身的外积，生成一个矩阵，每个元素为 \\( a_{ij} \\cdot a_{ji} \\)。 \n", + " 而 `einsum('i,j->ij', a_{1D}, a_{1D})` 计算 \\( a_{1D} \\) 的外积，得到一个 \\( 3 \\times 3 \\) 矩阵，其元素为 \\( a_i \\cdot a_j \\)。\n", + "\n", + "7. **矩阵的定义及运算**： \n", + " 定义了两个 \\( 3 \\times 3 \\) 的矩阵 \\( A \\) 和 \\( B \\)。矩阵 \\( A \\) 和 \\( B \\) 之间的运算包括以下内容： \n", + " \n", + " - **转置**： `einsum('ji', A)` 计算 \\( A \\) 的转置。\n", + " \n", + " - **矩阵求和**： `einsum('ij->', A)` 计算矩阵 \\( A \\) 所有元素的和。 \n", + " \n", + " - **按行和按列求和**： \n", + " 使用 `einsum('ij->j', A)` 计算每列的和，结果为一个一维数组，形式为 \\( \\sum_i A_{ij} \\)。 \n", + " `einsum('ij->i', A)` 计算每行的和，结果形式为 \\( \\sum_j A_{ij} \\)。\n", + "\n", + " - **提取主对角线和计算迹**： \n", + " `einsum('ii->i', A)` 提取 \\( A \\) 的主对角线元素，结果为 \\( [A_{11}, A_{22}, A_{33}] \\)。 \n", + " `einsum('ii->', A)` 计算矩阵 \\( A \\) 的迹 \\( \\text{tr}(A) = \\sum_i A_{ii} \\)。\n", + "\n", + " - **矩阵乘法和结果求和**： \n", + " `einsum('ij,jk->ik', A, B)` 计算 \\( A \\) 和 \\( B \\) 的矩阵乘积 \\( C = A \\times B \\)，即 \\( C_{ik} = \\sum_j A_{ij} \\cdot B_{jk} \\)。 \n", + " `einsum('ij,jk->', A, B)` 计算 \\( A \\times B \\) 的所有元素和。 \n", + " `einsum('ij,jk->ki', A, B)` 先进行矩阵乘法，再对结果转置。\n", + "\n", + " - **逐元素乘积**： \n", + " `einsum('ij,ij->ij', A, B)` 计算 \\( A \\) 和 \\( B \\) 的逐元素乘积，结果为矩阵 \\( D \\)，其中 \\( D_{ij} = A_{ij} \\cdot B_{ij} \\)。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "97fcb029-de43-4a4b-ba5f-ad331b7a78eb", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "4a4e312b-9e45-4be6-afcc-83060d1798ee", + "metadata": {}, + "source": [ + "## 定义矩阵和向量" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b8e03123-64d1-4387-8fc7-6e7464e5a529", + "metadata": {}, + "outputs": [], + "source": [ + "a = np.array([[1],\n", + " [2],\n", + " [3]]) # 定义列向量 a" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c691db9b-31d1-4661-ac0b-17f39e31bddb", + "metadata": {}, + "outputs": [], + "source": [ + "a_1D = np.array([1,2,3]) # 定义一维向量 a_1D" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6f95f355-f84a-4476-a424-89279c00eab2", + "metadata": {}, + "outputs": [], + "source": [ + "b = np.array([[-4],\n", + " [-5],\n", + " [-6]]) # 定义列向量 b" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9868ad35-72ff-4e73-b364-02186f82ddde", + "metadata": {}, + "outputs": [], + "source": [ + "b_1D = np.array([-4,-5,-6]) # 定义一维向量 b_1D" + ] + }, + { + "cell_type": "markdown", + "id": "da290670-c5b3-45fb-90b9-d2260356cb7f", + "metadata": {}, + "source": [ + "## 计算向量 a 的元素和" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ce155c35-ebdc-4fb7-9036-b64a5e7c51c5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + } + ], + "source": [ + "print(np.einsum('ij->',a)) # 计算矩阵 a 所有元素的和" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fc84a3f0-61a5-4a06-af67-dc92507acf20", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + } + ], + "source": [ + "print(np.einsum('i->',a_1D)) # 计算向量 a_1D 所有元素的和" + ] + }, + { + "cell_type": "markdown", + "id": "3fe87ea0-03ac-4f71-8571-8ae0ed8a5269", + "metadata": {}, + "source": [ + "## 向量 a 和 b 的逐元素乘积" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bc000421-7392-4603-8fe8-aa6608e1c1cb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ -4]\n", + " [-10]\n", + " [-18]]\n" + ] + } + ], + "source": [ + "print(np.einsum('ij,ij->ij',a,b)) # 计算矩阵 a 和 b 的逐元素乘积" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "bb28fdab-b2b0-4d28-8f62-1453d77bfbb4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ -4 -10 -18]\n" + ] + } + ], + "source": [ + "print(np.einsum('i,i->i',a_1D,b_1D)) # 计算向量 a_1D 和 b_1D 的逐元素乘积" + ] + }, + { + "cell_type": "markdown", + "id": "aee84a7c-d65b-440a-967b-ac45f0c28acd", + "metadata": {}, + "source": [ + "## 向量 a 和 b 的内积" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "34d92cbc-b818-409d-ab86-d075c27236cd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-32\n" + ] + } + ], + "source": [ + "print(np.einsum('ij,ij->',a,b)) # 计算矩阵 a 和 b 的内积" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3142feb7-5501-49de-9576-a3c010cbb4be", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-32\n" + ] + } + ], + "source": [ + "print(np.einsum('i,i->',a_1D,b_1D)) # 计算向量 a_1D 和 b_1D 的内积" + ] + }, + { + "cell_type": "markdown", + "id": "f19a1dbf-204b-4d08-bb7f-89fe08a5a40f", + "metadata": {}, + "source": [ + "## 向量 a 自身的外积" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e46e5895-d71d-4eed-a6ae-4c6875da71bb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2 3]\n", + " [2 4 6]\n", + " [3 6 9]]\n" + ] + } + ], + "source": [ + "print(np.einsum('ij,ji->ij',a,a)) # 计算矩阵 a 和自身的外积" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "1568a79b-9345-474a-aa5a-a977ef5ead8f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2 3]\n", + " [2 4 6]\n", + " [3 6 9]]\n" + ] + } + ], + "source": [ + "print(np.einsum('i,j->ij',a_1D,a_1D)) # 计算向量 a_1D 和自身的外积" + ] + }, + { + "cell_type": "markdown", + "id": "b8cf3e0c-da91-4cb8-885e-145cc69b2bb3", + "metadata": {}, + "source": [ + "## 向量 a 和 b 的外积" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "442d8342-ac8e-4b31-8dd7-ab0c8704c3ff", + "metadata": {}, + "outputs": [], + "source": [ + "print(np.einsum('ij,ji->ij',a,b)) # 计算矩阵 a 和 b 的外积" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "81954884-d255-4524-b09b-2848891ef7e7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ -4 -5 -6]\n", + " [ -8 -10 -12]\n", + " [-12 -15 -18]]\n", + "[[ -4 -5 -6]\n", + " [ -8 -10 -12]\n", + " [-12 -15 -18]]\n" + ] + } + ], + "source": [ + "print(np.einsum('i,j->ij',a_1D,b_1D)) # 计算向量 a_1D 和 b_1D 的外积" + ] + }, + { + "cell_type": "markdown", + "id": "9f897baa-6fca-4bf5-9613-9379363878b8", + "metadata": {}, + "source": [ + "## 定义方阵 A 和 B" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "31dd6b69-fc1a-4613-a3bc-f5cb51988014", + "metadata": {}, + "outputs": [], + "source": [ + "A = np.array([[1,2,3],\n", + " [4,5,6],\n", + " [7,8,9]]) # 定义方阵 A" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "08d16cb0-a5cb-4b32-8f2e-fc8cf5f2a206", + "metadata": {}, + "outputs": [], + "source": [ + "B = np.array([[-1,-4,-7],\n", + " [-2,-5,-8],\n", + " [-3,-6,-9]]) # 定义方阵 B" + ] + }, + { + "cell_type": "markdown", + "id": "ccad52d1-dc84-4b3c-a097-3380f3ec90a6", + "metadata": {}, + "source": [ + "## A 的转置" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "12e193cf-71e4-48b0-8cbb-cbcf3ccdbc6c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 4 7]\n", + " [2 5 8]\n", + " [3 6 9]]\n" + ] + } + ], + "source": [ + "print(np.einsum('ji',A)) # 计算矩阵 A 的转置" + ] + }, + { + "cell_type": "markdown", + "id": "1528a603-b271-4274-9f83-045fe64a99db", + "metadata": {}, + "source": [ + "## A 的元素和" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "2d6b2be7-e73a-46b1-9415-944930809770", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "45\n" + ] + } + ], + "source": [ + "print(np.einsum('ij->',A)) # 计算矩阵 A 所有元素的和" + ] + }, + { + "cell_type": "markdown", + "id": "257c86ae-4793-4f91-9bfc-6128b1c9aa01", + "metadata": {}, + "source": [ + "## 按行求和" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "7cef1bf8-aed8-4f0a-b97b-8758d33075da", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[12 15 18]\n" + ] + } + ], + "source": [ + "print(np.einsum('ij->j',A)) # 计算矩阵 A 的每列的和" + ] + }, + { + "cell_type": "markdown", + "id": "58267372-554b-4284-92c1-cee2453df11e", + "metadata": {}, + "source": [ + "## 按列求和" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "595287a8-6e24-408e-8552-aa7ecc6fc55f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 6 15 24]\n" + ] + } + ], + "source": [ + "print(np.einsum('ij->i',A)) # 计算矩阵 A 的每行的和" + ] + }, + { + "cell_type": "markdown", + "id": "d64a84cf-72a0-408d-b896-c3b88087dbf7", + "metadata": {}, + "source": [ + "## 提取主对角线" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "200ca6b1-c240-4d6d-a8c2-f3fd64763bea", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1 5 9]\n" + ] + } + ], + "source": [ + "print(np.einsum('ii->i',A)) # 提取矩阵 A 的主对角线元素" + ] + }, + { + "cell_type": "markdown", + "id": "2b786c9a-5864-451f-906c-0f14253e5aad", + "metadata": {}, + "source": [ + "## 计算矩阵 A 的迹" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "9e3a19a5-0f54-4dfe-829c-be92fd12aa7b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "15\n" + ] + } + ], + "source": [ + "print(np.einsum('ii->',A)) # 计算矩阵 A 的迹（主对角线元素的和）" + ] + }, + { + "cell_type": "markdown", + "id": "05751e89-a555-438c-898a-bf925c4f66b4", + "metadata": {}, + "source": [ + "## 矩阵 A 和 B 的乘积" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "64413023-b87d-4a78-b275-cfd84e257fc4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ -14 -32 -50]\n", + " [ -32 -77 -122]\n", + " [ -50 -122 -194]]\n" + ] + } + ], + "source": [ + "print(np.einsum('ij,jk->ik', A, B)) # 计算矩阵 A 和 B 的矩阵乘法" + ] + }, + { + "cell_type": "markdown", + "id": "3af4c95f-aa69-49cb-a2ce-aab8772b09c4", + "metadata": {}, + "source": [ + "## A 和 B 的矩阵乘积的所有元素和" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "7c47a0c5-20af-4bb1-96e8-56c601115c6a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-693\n" + ] + } + ], + "source": [ + "print(np.einsum('ij,jk->', A, B)) # 计算矩阵 A 和 B 的乘积矩阵的所有元素的和" + ] + }, + { + "cell_type": "markdown", + "id": "a85f940b-b6bd-483e-8ddb-9cab6ee24ce0", + "metadata": {}, + "source": [ + "## 矩阵相乘后转置" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "56598ed4-fd7a-4f82-ab5b-573f72f966a2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ -14 -32 -50]\n", + " [ -32 -77 -122]\n", + " [ -50 -122 -194]]\n" + ] + } + ], + "source": [ + "print(np.einsum('ij,jk->ki', A, B)) # 计算矩阵 A 和 B 的乘积后对结果转置" + ] + }, + { + "cell_type": "markdown", + "id": "3ade29c2-f09c-420a-a4e4-ef3aba2aac18", + "metadata": {}, + "source": [ + "## A 和 B 的逐元素乘积" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "d5e5fe17-96cd-4c6d-8326-da9f6df6ac1f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ -1 -8 -21]\n", + " [ -8 -25 -48]\n", + " [-21 -48 -81]]\n" + ] + } + ], + "source": [ + "print(np.einsum('ij,ij->ij', A, B)) # 计算矩阵 A 和 B 的逐元素乘积" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch06_Python_Codes/Bk4_Ch06_01.ipynb b/Book4_Ch06_Python_Codes/Bk4_Ch06_01.ipynb new file mode 100644 index 0000000..2a743d8 --- /dev/null +++ b/Book4_Ch06_Python_Codes/Bk4_Ch06_01.ipynb @@ -0,0 +1,291 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 06\n", + "\n", + "# 分块矩阵\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "25999c8b-f570-4ca4-b9d4-6e8c9537b859", + "metadata": {}, + "source": [ + "这段代码演示了如何对矩阵进行分块和重组操作。首先定义了一个 \\(4 \\times 5\\) 矩阵 \\( A \\)：\n", + "\n", + "$$\n", + "A = \\begin{bmatrix}\n", + "1 & 2 & 3 & 0 & 0 \\\\\n", + "4 & 5 & 6 & 0 & 0 \\\\\n", + "0 & 0 & 0 & -1 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 1 \\\\\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "然后使用 NumPy 的切片方法，将矩阵 \\( A \\) 分割为 4 个子矩阵（即 \\(2 \\times 2\\) 的块矩阵结构）：\n", + "\n", + "1. \\( A_{1,1} = A[0:2, 0:3] \\)，即前两行和前三列的子矩阵：\n", + " $$\n", + " A_{1,1} = \\begin{bmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{bmatrix}\n", + " $$\n", + " \n", + "2. \\( A_{1,2} = A[0:2, 3:] \\)，即前两行和最后两列的子矩阵：\n", + " $$\n", + " A_{1,2} = \\begin{bmatrix} 0 & 0 \\\\ 0 & 0 \\end{bmatrix}\n", + " $$\n", + "\n", + "3. \\( A_{2,1} = A[2:, 0:3] \\)，即后两行和前三列的子矩阵：\n", + " $$\n", + " A_{2,1} = \\begin{bmatrix} 0 & 0 & 0 \\\\ 0 & 0 & 0 \\end{bmatrix}\n", + " $$\n", + "\n", + "4. \\( A_{2,2} = A[2:, 3:] \\)，即后两行和最后两列的子矩阵：\n", + " $$\n", + " A_{2,2} = \\begin{bmatrix} -1 & 0 \\\\ 0 & 1 \\end{bmatrix}\n", + " $$\n", + "\n", + "最后使用 `np.block` 函数将这些子矩阵重新组合为一个新的矩阵 \\( A' \\)，其结构与原矩阵 \\( A \\) 相同：\n", + "\n", + "$$\n", + "A' = \\begin{bmatrix} \n", + "A_{1,1} & A_{1,2} \\\\ \n", + "A_{2,1} & A_{2,2} \n", + "\\end{bmatrix} = \n", + "\\begin{bmatrix} \n", + "1 & 2 & 3 & 0 & 0 \\\\ \n", + "4 & 5 & 6 & 0 & 0 \\\\ \n", + "0 & 0 & 0 & -1 & 0 \\\\ \n", + "0 & 0 & 0 & 0 & 1 \n", + "\\end{bmatrix}\n", + "$$ \n", + "\n", + "通过这种方法，可以方便地在分块矩阵操作中对矩阵进行重新组合，实现了矩阵的分解与重构。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "da9bd893-e25f-4193-b12b-e5cac674f64b", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "67b49f8e-b6d5-49d4-b4a4-190ecd915450", + "metadata": {}, + "source": [ + "## 定义矩阵 A" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e00b27dd-c721-42e1-8f65-fa2937b460ad", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1, 2, 3, 0, 0],\n", + " [ 4, 5, 6, 0, 0],\n", + " [ 0, 0, 0, -1, 0],\n", + " [ 0, 0, 0, 0, 1]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A = np.array([[1, 2, 3, 0, 0], # 定义矩阵 A 的元素\n", + " [4, 5, 6, 0, 0],\n", + " [0, 0, 0, -1, 0],\n", + " [0, 0 ,0, 0, 1]])\n", + "A" + ] + }, + { + "cell_type": "markdown", + "id": "5a878c1b-238b-4f8d-a033-db66fb2aa0fa", + "metadata": {}, + "source": [ + "## NumPy 数组切片操作" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "440560e5-ed77-4bbc-8fa7-d2c09285e3c7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 2, 3],\n", + " [4, 5, 6]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_1_1 = A[0:2,0:3] # 提取矩阵 A 的前两行和前三列作为子矩阵 A_1_1\n", + "A_1_1" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "29344301-cbb7-4fbd-b64b-d23aced6823e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 0],\n", + " [0, 0]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_1_2 = A[0:2,3:] # 提取矩阵 A 的前两行和最后两列作为子矩阵 A_1_2\n", + "A_1_2\n", + "# A_1_2 = A[0:2,-2:] # 或者用负索引方式提取前两行和最后两列（注释部分）" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b24013dd-a04e-44f6-9c89-67b2a0027bff", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 0, 0],\n", + " [0, 0, 0]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_2_1 = A[2:,0:3] # 提取矩阵 A 的后两行和前三列作为子矩阵 A_2_1\n", + "A_2_1\n", + "# A_2_1 = A[-2:,0:3] # 或者用负索引方式提取后两行和前三列（注释部分）" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2aa41d01-ef5a-450d-b912-d0cf9134f16f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-1, 0],\n", + " [ 0, 1]])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_2_2 = A[2:,3:] # 提取矩阵 A 的后两行和最后两列作为子矩阵 A_2_2\n", + "A_2_2\n", + "# A_2_2 = A[-2:,-2:] # 或者用负索引方式提取后两行和最后两列（注释部分）" + ] + }, + { + "cell_type": "markdown", + "id": "f618ccce-d822-417d-8ce1-6cb6d3f90999", + "metadata": {}, + "source": [ + "## 使用嵌套列表中的块组装矩阵" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4dc81f48-c1a3-42e0-82df-b76c62601926", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1, 2, 3, 0, 0],\n", + " [ 4, 5, 6, 0, 0],\n", + " [ 0, 0, 0, -1, 0],\n", + " [ 0, 0, 0, 0, 1]])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_ = np.block([[A_1_1, A_1_2], # 通过 np.block 函数将子矩阵 A_1_1、A_1_2、A_2_1 和 A_2_2 组合成新的矩阵 A_\n", + " [A_2_1, A_2_2]])\n", + "A_" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch06_Python_Codes/Bk4_Ch06_02.ipynb b/Book4_Ch06_Python_Codes/Bk4_Ch06_02.ipynb new file mode 100644 index 0000000..f2735f0 --- /dev/null +++ b/Book4_Ch06_Python_Codes/Bk4_Ch06_02.ipynb @@ -0,0 +1,345 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 06\n", + "\n", + "# 矩阵乘法第二视角\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "2adcfe9c-3a08-4440-b790-302b7d659727", + "metadata": {}, + "source": [ + "这段代码演示了如何通过矩阵分块的方式，使用矩阵的列与行的外积来重建矩阵乘积。具体步骤如下：\n", + "\n", + "1. **定义绘制函数**：`plot_heatmap`函数用于可视化矩阵，通过`seaborn`的`heatmap`绘制热图，用色彩表示矩阵元素的值。\n", + "\n", + "2. **生成随机矩阵 \\( A \\) 和 \\( B \\)**：首先，生成尺寸为 \\(6 \\times 4\\) 的矩阵 \\( A \\) 和 \\(4 \\times 3\\) 的矩阵 \\( B \\)。通过缩放，使矩阵元素的取值范围在 \\([-1, 1]\\) 之间。\n", + "\n", + "3. **矩阵乘积 \\( C \\)**：计算矩阵乘积 \\( C = A \\times B \\)，其中 \\( C \\) 的每个元素 \\( C_{ij} \\) 定义为\n", + " $$\n", + " C_{ij} = \\sum_{k=1}^4 A_{ik} \\cdot B_{kj}\n", + " $$\n", + " 这产生了一个新的 \\(6 \\times 3\\) 的矩阵 \\( C \\)，并对其进行可视化。\n", + "\n", + "4. **逐步分块重建矩阵 \\( C \\)**：定义一个与 \\( C \\) 形状相同的零矩阵 \\( C_{\\text{rep}} \\)，逐步累加矩阵分块的乘积来重建 \\( C \\)：\n", + " \n", + " - 对于每列索引 \\( i \\) (从 0 到 3)，计算 \\( A \\) 的第 \\(i\\) 列和 \\( B \\) 的第 \\(i\\) 行的外积，即：\n", + " $$\n", + " C_i = A[:, i] \\times B[i, :]\n", + " $$\n", + " 这给出了矩阵 \\( C \\) 中只涉及 \\( A \\) 的第 \\(i\\) 列和 \\( B \\) 的第 \\(i\\) 行的部分贡献矩阵 \\( C_i \\)，即\n", + " $$\n", + " C_i = \\begin{bmatrix} A_{11} \\cdot B_{i1} & A_{12} \\cdot B_{i2} & \\dots \\end{bmatrix}\n", + " $$\n", + "\n", + " - 将 \\( C_i \\) 累加到 \\( C_{\\text{rep}} \\) 中，以逐步重建 \\( C \\)。此累加过程可以用公式表示为\n", + " $$\n", + " C_{\\text{rep}} = \\sum_{i=1}^4 C_i\n", + " $$\n", + " \n", + "5. **可视化重建的矩阵**：最终，通过绘制 \\( C_{\\text{rep}} \\) 验证重建的矩阵是否与 \\( C \\) 相同。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "665a896c-02e8-4bb9-bf81-f27234519a06", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt # 导入绘图库\n", + "import numpy as np # 导入数值计算库\n", + "import seaborn as sns # 导入热图绘制库" + ] + }, + { + "cell_type": "markdown", + "id": "303cd501-c30b-454f-9f9a-c9ea59beeceb", + "metadata": {}, + "source": [ + "## 定义函数：绘制热图" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b85640bf-d669-4673-a1b4-211acca1c267", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_heatmap(x, title): # 定义热图绘制函数\n", + " fig, ax = plt.subplots() # 创建子图\n", + " ax = sns.heatmap(x, # 绘制热图\n", + " cmap='RdYlBu_r', # 选择颜色映射\n", + " cbar_kws={\"orientation\": \"horizontal\"}, vmin=-1, vmax=1) # 设置颜色条方向和取值范围\n", + " ax.set_aspect(\"equal\") # 设置坐标轴比例\n", + " plt.title(title) # 设置标题" + ] + }, + { + "cell_type": "markdown", + "id": "66a24219-f8b2-4712-950a-7aa677fdd9e5", + "metadata": {}, + "source": [ + "## 生成矩阵 A 和 B" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "baa441d7-ffd2-43b7-ab0d-815d0f2a6333", + "metadata": {}, + "outputs": [], + "source": [ + "A = np.random.randint(0, 40 + 1, size=(6, 4)) # 生成 6x4 矩阵 A，元素为 0 到 40 的随机整数\n", + "A = A / 20 - 1 # 将矩阵 A 的元素缩放到 -1 到 1 范围内" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4f2a95ec-161d-43a6-826c-3b1314a9314d", + "metadata": {}, + "outputs": [], + "source": [ + "B = np.random.randint(0, 40 + 1, size=(4, 3)) # 生成 4x3 矩阵 B，元素为 0 到 40 的随机整数\n", + "B = B / 20 - 1 # 将矩阵 B 的元素缩放到 -1 到 1 范围内" + ] + }, + { + "cell_type": "markdown", + "id": "f9494786-223b-4765-b89d-6afdeced536c", + "metadata": {}, + "source": [ + "## 可视化矩阵 A 和 B" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "69c8c895-6752-473c-b29d-2337e75c663f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_heatmap(A, 'A') # 可视化矩阵 A" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1e9eeae0-98a7-45c2-b056-e05b9f02afb9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_heatmap(B, 'B') # 可视化矩阵 B" + ] + }, + { + "cell_type": "markdown", + "id": "803b707c-3404-4b9b-bcb7-5dfb072dd1f8", + "metadata": {}, + "source": [ + "## 可视化矩阵乘积 C = AB" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "272817b2-c04f-4dbc-b4c6-183ae204510b", + "metadata": {}, + "outputs": [], + "source": [ + "C = A @ B # 计算矩阵 C 为 A 和 B 的乘积" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2b9a7a76-8c91-41e7-a196-2c7bef04875a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_heatmap(C, 'C = AB') # 可视化矩阵 C" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4bc72b08-ffad-43b2-97a7-ae390aa508f9", + "metadata": {}, + "outputs": [], + "source": [ + "C_rep = np.zeros_like(C) # 创建与 C 形状相同的零矩阵，用于存储逐步计算的结果" + ] + }, + { + "cell_type": "markdown", + "id": "d78c5bb3-fdb6-4831-97e4-e87eb90818fc", + "metadata": {}, + "source": [ + "## 逐元素重建矩阵 C" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a622e1fd-5c85-4a3e-80c3-5c5b38618b0d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGTCAYAAAAC6OmuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAh4ElEQVR4nO3deXRU9f3/8ddkm7AOYkIIIktd2EIpCcqiENkiniNIWwtawEiVIyAWpFrhZ78FzqkGrBWtCgoqYFuEY1nUQ6XFkqCYgBgiS9k1slQiYCEgyiQkn98fwugwk2QmEO4nmefjnDnD/dzP/eT98ZMbXt57J7iMMUYAAAAWiXK6AAAAgAsRUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAFTb1q1bNXr0aLVt21bx8fFq2LChUlNT9dRTT+l///ufJGn9+vW6//77lZaWJrfbLZfLpc8//9zZwgFYL8bpAgDUTvPnz9f48ePVrl07Pfroo+rYsaNKS0v18ccf66WXXlJeXp5WrFihf//733rvvffUtWtXNW7cWDk5OU6XDqAWcPFv8QAIV15ennr37q2BAwdq5cqVcrvdfvtLSkq0evVqDRkyROXl5YqK+u5i7dNPP61HH31UhYWFatOmjQOVA6gtuMUDIGxPPvmkXC6X5s2bFxBOJCkuLk5DhgyRJF84AYBw8JMDQFjKysq0du1apaWl6eqrr3a6HAB1FAEFQFiOHTumb775Rm3btnW6FAB1GAEFAABYh4ACICwJCQmqX7++CgsLnS4FQB1GQAEQlujoaPXv31/5+fk6dOiQ0+UAqKMIKADCNnXqVBljNGbMGJWUlATsLy0t1TvvvONAZQDqCn5RG4Cw9ezZU3PnztX48eOVlpamcePGqVOnTiotLVVBQYHmzZunlJQUDR48WEePHtW6deskSdu2bZMkvfvuu0pMTFRiYqLS09OdnAoAS/GL2gBU25YtWzR79mxlZ2erqKhIsbGxuv766zV48GBNmDBBiYmJysnJUd++fYMen56ezm+WBRAUAQUAAFiHZ1AAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANbhN8kCNeSP2XudLiFk17dq4nQJIZv95DqnSwhZzqt3Ol0CUGtxBQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsE+N0AYDTDh06pLlz5yo3N1dFRUVyuVxKSkpSr169NHbsWF199dVOlwgAEYcrKIho69evV4cOHbRixQp16dJF99xzj0aOHKkuXbpo5cqV6tSpkz788EOnywSAiMMVFES0hx9+WPfff79mz55d4f5JkyZp06ZNlY7j9Xrl9Xr92s6WlCgmLu6S1QoAkYQrKIho27dv19ixYyvc/8ADD2j79u1VjpOVlSWPx+P3Wrv4pUtZKgBEFAIKIlpycrJyc3Mr3J+Xl6fk5OQqx5k6daqKi4v9Xv1+WXHwAQBUjls8iGiPPPKIxo4dq/z8fA0cOFBJSUlyuVwqKirSmjVr9Morr+jZZ5+tchy32y232+3Xxu0dAKg+Agoi2vjx43XllVdq9uzZevnll1VWViZJio6OVlpaml5//XUNGzbM4SoBIPIQUBDxhg8fruHDh6u0tFTHjh2TJCUkJCg2NtbhygAgchFQgHNiY2NDet4EAFDzeEgWAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB2XMcY4XQRQF50q3el0CSGLcZU4XULIvj7bzOkSQpYYn+x0CUCtxRUUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAlTi4MGD+tWvfuV0GQAQcVzGGON0EYCttmzZotTUVJWVlVXaz+v1yuv1+rWVRBXK7Y6ryfIumRhXidMlhOzrs82cLiFkifHJTpcA1FoxThcAOOntt9+udP9nn30W0jhZWVmaMWOGX9uU343X//v9hGrXBgCRjCsoiGhRUVFyuVyq7DRwuVxcQbEIV1CAyMAzKIhoycnJWrZsmcrLy4O+Nm/eHNI4brdbjRs39nvVlnACADYioCCipaWlVRpCqrq6AgCoGTyDgoj26KOP6vTp0xXuv/baa5WdnX0ZKwIASDyDAtSYU6U7nS4hZDyDUjN4BgWoPm7xAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANaJcboAoK5quHWJ0yWELqGp0xWELPbfG50uIXS/Wux0BUCtxRUUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAgoj37bffav369dqxY0fAvjNnzuj111+vcgyv16uTJ0/6vbwlZ2uiXACICAQURLQ9e/aoQ4cO6tOnjzp37qxbbrlFhw8f9u0vLi7W6NGjqxwnKytLHo/H75W1YH1Nlg4AdRoBBRHtscceU+fOnXXkyBHt3r1bjRs31k033aQDBw6ENc7UqVNVXFzs95o6+uYaqhoA6r4YpwsAnJSbm6v33ntPCQkJSkhI0Ntvv60HH3xQvXv3VnZ2tho0aBDSOG63W26326/NxHF6AUB18RMUEe3bb79VTIz/afDiiy8qKipK6enpWrx4sUOVAUBkI6AgorVv314ff/yxOnTo4Nf+/PPPyxijIUOGOFQZAEQ2nkFBRPvpT3+qN954I+i+F154QXfffbeMMZe5KgCAy/DTF6gRJn+a0yWELqGp0xWErOzfG50uIWQxv+IWIVBdXEEBAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWMdljDFOFwHURV98c8LpEkLmjj7ldAkh23/yCqdLCFlqYkOnSwBqLa6gAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoxThcAOG3nzp3asGGDevbsqfbt22vXrl167rnn5PV6NXLkSPXr16/KMbxer7xer39bmVdut7umygaAOo0rKIhoq1ev1k9+8hM98sgj6tq1q1avXq0+ffpo3759OnDggG699VatXbu2ynGysrLk8Xj8Xi88PfsyzAAA6iaXMcY4XQTglF69eqlfv376wx/+oCVLlmj8+PEaN26cnnjiCUnS448/rk2bNulf//pXpeMEu4LyVdm3teYKijv6lNMlhGz/ySucLiFkqYkNnS4BqLUIKIhoHo9H+fn5uvbaa1VeXi63262NGzcqNTVVkrR9+3YNGDBARUVFYY/9xTcnLnG1NYeAUjMIKED1cYsHOCcqKkrx8fFq0qSJr61Ro0YqLi52rigAiFAEFES0Nm3aaN++fb7tvLw8tWrVyrd98OBBJScnO1EaAEQ0PsWDiDZu3DiVlZX5tlNSUvz2v/vuuyF9igcAcGnxDApQQ3gGpWbwDAoQGbjFAwAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALCOyxhjnC4CqJNMttMVwGmuvk5XANRaXEEBAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAEEYY5wuAQAiGgEFCMLtdmvnzp1OlwEAESvG6QIAJ02ePDloe1lZmWbOnKkrr7xSkvTMM89UOo7X65XX6/Vrc8eVyO2OuzSFAkCEIaAgoj377LPq0qWLmjRp4tdujNHOnTvVoEEDuVyuKsfJysrSjBkz/Nqm/f4eTZ9+7yWsFgAih8twsx0RLCsrS/Pnz9crr7yifv36+dpjY2O1ZcsWdezYMaRxgl9ByeMKSqRz9XW6AqDWIqAg4m3atEkjR47U4MGDlZWVpdjY2LADSlAm+9IVidqJgAJUGw/JIuLdcMMNys/P19GjR9WtWzdt27YtpNs6AICawzMogKSGDRtq0aJFWrJkiQYOHKiysjKnSwKAiMYtHuAChw4dUn5+vgYMGKAGDRpUfyBu8YBbPEC1EVCAmkJAAQEFqDaeQQEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYx2WMMU4XAdRFJbN/7nQJIYvpkOR0CSHb+du1TpcQsk5bdzldAlBrcQUFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1olxugDAJsePH9eiRYu0d+9eJScnKzMzU1dffXWVx3m9Xnm9Xr8219kyuWOia6pUAKjTuIKCiNaiRQt99dVXkqTCwkJ17NhRs2bN0t69e/Xyyy+rc+fO2rVrV5XjZGVlyePx+L2eem93TZcPAHWWyxhjnC4CcEpUVJSKiorUrFkz3X333SoqKtKqVatUv359eb1e3XnnnYqPj9ebb75Z6ThBr6C8fE+tuYIS0yHJ6RJCtvO3a50uIWSdtlYdbgEExy0e4JyNGzfqlVdeUf369SVJbrdbv/vd73TnnXdWeazb7Zbb7fZrK6kl4QQAbMQtHkQ8l8sl6burIElJ/lcSkpKSdPToUSfKAoCIxhUURLz+/fsrJiZGJ0+e1J49e9SpUyffvgMHDighIcHB6gAgMhFQENGmTZvmt33+9s5577zzjnr37n05SwIAiIdkgRpTMvvnTpcQMh6SrRk8JAtUH8+gAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKzjMsYYp4sAUDWv16usrCxNnTpVbrfb6XIqRa0ALhYBBaglTp48KY/Ho+LiYjVu3NjpcipFrQAuFrd4AACAdQgoAADAOgQUAABgHQIKUEu43W5NmzatVjzISa0ALhYPyQIAAOtwBQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUIBaYs6cOWrbtq3i4+OVlpamDz74wOmSArz//vsaPHiwWrRoIZfLpZUrVzpdUoWysrJ0ww03qFGjRmrWrJmGDh2q3bt3O10WgHMIKEAtsHTpUk2aNEmPP/64CgoK1Lt3b9122206cOCA06X5OX36tLp06aIXXnjB6VKqtG7dOj344IPasGGD1qxZo7NnzyojI0OnT592ujQA4mPGQK3QvXt3paamau7cub62Dh06aOjQocrKynKwsoq5XC6tWLFCQ4cOdbqUkBw9elTNmjXTunXr1KdPH6fLASIeV1AAy5WUlCg/P18ZGRl+7RkZGcrNzXWoqrqnuLhYktS0aVOHKwEgEVAA6x07dkxlZWVKSkrya09KSlJRUZFDVdUtxhhNnjxZN998s1JSUpwuB4CkGKcLABAal8vlt22MCWhD9UyYMEFbt27V+vXrnS4FwDkEFMByCQkJio6ODrhacuTIkYCrKgjfQw89pLffflvvv/++WrZs6XQ5AM7hFg9gubi4OKWlpWnNmjV+7WvWrFGvXr0cqqr2M8ZowoQJWr58udauXau2bds6XRKAH+AKClALTJ48WaNGjVK3bt3Us2dPzZs3TwcOHNDYsWOdLs3P119/rX379vm2CwsL9cknn6hp06Zq1aqVg5UFevDBB7V48WK99dZbatSoke8KlcfjUb169RyuDgAfMwZqiTlz5uipp57S4cOHlZKSotmzZ1v3cdicnBz17ds3oD0zM1MLFy68/AVVoqLndxYsWKB777338hYDIAABBQAAWIdnUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdWKc/OKp3edIklxRru/eo797V1SU33a4+89vKzrKt13lWCGMUfnXjDo3nMvv3RXtCmj7/v3cMdEXHFNR/+jgxwf0/0G/gHoq+JoB7y7/7egq9n//fu4/myvIvCs4JrrKMauoKeC4H7SdX2bXBX3PL2+I/UIdL8rlCugTXc2xXSr/7t313XuUyvy2g+2vaJ/r3LFRVez/fqzwx7lwDJf57l0B78Z/u7yifhfuN0H3G1MeZIzgfSv+Wqby/eUVvZtK9gXpG6TdVPg1gvf3ew/zGFNm/Pud2zYXbKusPHj7uW1T9oN5VzjGhe0hjOlXW/D+ptz4+p7fV37BtrlgvuaCr+E7roL2wP7fj1flsVWMVe47XsHfK1nCUL/VjKnia1TjW/XCPr80u1XTuIICAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAADYxzjkzJkzZtq0aebMmTNOleAI5s28IwHzZt6RgHnX7LxdxhjjRDA6efKkPB6PiouL1bhxYydKcATzZt6RgHkz70jAvGt23tziAQAA1iGgAAAA6xBQAACAdRwLKG63W9OmTZPb7XaqBEcwb+YdCZg3844EzLtm5+3YQ7IAAAAV4RYPAACwDgEFAABYh4ACAACsQ0ABAADWqdGA8sQTT6hXr16qX7++mjRpEtIxxhhNnz5dLVq0UL169XTLLbfoP//5j18fr9erhx56SAkJCWrQoIGGDBmiQ4cO1cAMquf48eMaNWqUPB6PPB6PRo0apRMnTlR6jMvlCvr64x//6Otzyy23BOy/6667ang2oavOvO+9996AOfXo0cOvT11b79LSUj322GPq3LmzGjRooBYtWuiee+7RF1984dfPtvWeM2eO2rZtq/j4eKWlpemDDz6otP+6deuUlpam+Ph4/ehHP9JLL70U0GfZsmXq2LGj3G63OnbsqBUrVtRU+dUWzryXL1+ugQMHKjExUY0bN1bPnj31z3/+06/PwoULg57rZ86cqemphCWceefk5ASd065du/z61bX1Dvbzy+VyqVOnTr4+tq/3+++/r8GDB6tFixZyuVxauXJllcdctnO7Jn+P/u9//3vzzDPPmMmTJxuPxxPSMTNnzjSNGjUyy5YtM9u2bTPDhw83ycnJ5uTJk74+Y8eONVdddZVZs2aN2bx5s+nbt6/p0qWLOXv2bA3NJDyDBg0yKSkpJjc31+Tm5pqUlBRz++23V3rM4cOH/V6vvfaacblc5tNPP/X1SU9PN2PGjPHrd+LEiZqeTsiqM+/MzEwzaNAgvzl99dVXfn3q2nqfOHHCDBgwwCxdutTs2rXL5OXlme7du5u0tDS/fjat95IlS0xsbKyZP3++2bFjh5k4caJp0KCB2b9/f9D+n332malfv76ZOHGi2bFjh5k/f76JjY01f//73319cnNzTXR0tHnyySfNzp07zZNPPmliYmLMhg0bLte0qhTuvCdOnGhmzZplPvroI7Nnzx4zdepUExsbazZv3uzrs2DBAtO4ceOAc94m4c47OzvbSDK7d+/2m9MPz9G6uN4nTpzwm+/BgwdN06ZNzbRp03x9bF/vf/zjH+bxxx83y5YtM5LMihUrKu1/Oc/ty/KPBS5YsCCkgFJeXm6aN29uZs6c6Ws7c+aM8Xg85qWXXjLGfPcNERsba5YsWeLr89///tdERUWZ1atXX/Law7Vjxw4jyW8h8vLyjCSza9eukMe54447TL9+/fza0tPTzcSJEy9VqZdUdeedmZlp7rjjjgr3R8p6f/TRR0aS3w9Cm9b7xhtvNGPHjvVra9++vZkyZUrQ/r/97W9N+/bt/doeeOAB06NHD9/2sGHDzKBBg/z63Hrrreauu+66RFVfvHDnHUzHjh3NjBkzfNuh/jx0UrjzPh9Qjh8/XuGYkbDeK1asMC6Xy3z++ee+ttqw3ueFElAu57lt1TMohYWFKioqUkZGhq/N7XYrPT1dubm5kqT8/HyVlpb69WnRooVSUlJ8fZyUl5cnj8ej7t27+9p69Oghj8cTcn1ffvmlVq1apfvuuy9g39/+9jclJCSoU6dOeuSRR3Tq1KlLVvvFuJh55+TkqFmzZrr++us1ZswYHTlyxLcvEtZbkoqLi+VyuQJuhdqw3iUlJcrPz/dbA0nKyMiocI55eXkB/W+99VZ9/PHHKi0trbSPDesqVW/eFyovL9epU6fUtGlTv/avv/5arVu3VsuWLXX77beroKDgktV9sS5m3l27dlVycrL69++v7Oxsv32RsN6vvvqqBgwYoNatW/u127ze4bqc53bMxZV6aRUVFUmSkpKS/NqTkpK0f/9+X5+4uDhdccUVAX3OH++koqIiNWvWLKC9WbNmIde3aNEiNWrUSD/72c/82keMGKG2bduqefPm2r59u6ZOnaotW7ZozZo1l6T2i1Hded922236xS9+odatW6uwsFD/93//p379+ik/P19utzsi1vvMmTOaMmWKfvnLX/r9y6C2rPexY8dUVlYW9LysaI5FRUVB+589e1bHjh1TcnJyhX1sWFepevO+0J/+9CedPn1aw4YN87W1b99eCxcuVOfOnXXy5Ek999xzuummm7RlyxZdd911l3QO1VGdeScnJ2vevHlKS0uT1+vVX/7yF/Xv3185OTnq06ePpIq/J+rKeh8+fFjvvvuuFi9e7Ndu+3qH63Ke22EHlOnTp2vGjBmV9tm0aZO6desW7tA+LpfLb9sYE9B2oVD6XIxQ5y0F1i+FV99rr72mESNGKD4+3q99zJgxvj+npKTouuuuU7du3bR582alpqaGNHa4anrew4cP9/05JSVF3bp1U+vWrbVq1aqAgBbOuBfrcq13aWmp7rrrLpWXl2vOnDl++5xY78qEe14G639he3XO9cutujW+8cYbmj59ut566y2/ENujRw+/B8Fvuukmpaam6vnnn9ef//znS1f4RQpn3u3atVO7du182z179tTBgwf19NNP+wJKuGM6pbo1Lly4UE2aNNHQoUP92mvLeofjcp3bYQeUCRMmVPlJgjZt2oQ7rCSpefPmkr5LaMnJyb72I0eO+NJY8+bNVVJSouPHj/v9X/WRI0fUq1evan3dUIQ6761bt+rLL78M2Hf06NGARBnMBx98oN27d2vp0qVV9k1NTVVsbKz27t1bY39hXa55n5ecnKzWrVtr7969kur2epeWlmrYsGEqLCzU2rVr/a6eBHM51juYhIQERUdHB/zfzw/Pyws1b948aP+YmBhdeeWVlfYJ5/ulJlVn3uctXbpU9913n958800NGDCg0r5RUVG64YYbfN/zTruYef9Qjx499Ne//tW3XZfX2xij1157TaNGjVJcXFylfW1b73Bd1nM7rCdWqinch2RnzZrla/N6vUEfkl26dKmvzxdffGHdQ5MbN270tW3YsCHkhyYzMzMDPs1RkW3bthlJZt26ddWu91K52Hmfd+zYMeN2u82iRYuMMXV3vUtKSszQoUNNp06dzJEjR0L6Wk6u94033mjGjRvn19ahQ4dKH5Lt0KGDX9vYsWMDHqS77bbb/PoMGjTIuocmw5m3McYsXrzYxMfHV/mw4Xnl5eWmW7duZvTo0RdT6iVVnXlf6Oc//7np27evb7uurrcx3z8kvG3btiq/ho3rfZ5CfEj2cp3bNRpQ9u/fbwoKCsyMGTNMw4YNTUFBgSkoKDCnTp3y9WnXrp1Zvny5b3vmzJnG4/GY5cuXm23btpm777476MeMW7Zsad577z2zefNm069fP+s+dvrjH//Y5OXlmby8PNO5c+eAj51eOG9jjCkuLjb169c3c+fODRhz3759ZsaMGWbTpk2msLDQrFq1yrRv39507dq11s771KlT5je/+Y3Jzc01hYWFJjs72/Ts2dNcddVVdXq9S0tLzZAhQ0zLli3NJ5984vfRQ6/Xa4yxb73Pf/zy1VdfNTt27DCTJk0yDRo08H1aYcqUKWbUqFG+/uc/ivjwww+bHTt2mFdffTXgo4gffvihiY6ONjNnzjQ7d+40M2fOtPZjp6HOe/HixSYmJsa8+OKLFX48fPr06Wb16tXm008/NQUFBWb06NEmJibGL+Q6Ldx5z54926xYscLs2bPHbN++3UyZMsVIMsuWLfP1qYvrfd7IkSNN9+7dg45p+3qfOnXK93ezJPPMM8+YgoIC3ycKnTy3azSgZGZmGkkBr+zs7O8LkMyCBQt82+Xl5WbatGmmefPmxu12mz59+gSk0m+//dZMmDDBNG3a1NSrV8/cfvvt5sCBAzU5lbB89dVXZsSIEaZRo0amUaNGZsSIEQEfv7tw3sYY8/LLL5t69eoF/V0XBw4cMH369DFNmzY1cXFx5pprrjG//vWvA35niJPCnfc333xjMjIyTGJioomNjTWtWrUymZmZAWtZ19a7sLAw6Hnxw3PDxvV+8cUXTevWrU1cXJxJTU31u5KTmZlp0tPT/frn5OSYrl27mri4ONOmTZugwfvNN9807dq1M7GxsaZ9+/Z+f6HZIpx5p6enB13XzMxMX59JkyaZVq1ambi4OJOYmGgyMjJMbm7uZZxRaMKZ96xZs8w111xj4uPjzRVXXGFuvvlms2rVqoAx69p6G/PdVd569eqZefPmBR3P9vU+f/Wnou9ZJ89tlzHnnm4BAACwhFW/BwUAAEAioAAAAAsRUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOv8fUVbch8ia6oUAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGTCAYAAAAC6OmuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAiiklEQVR4nO3deXBUVd7/8U9n60BMghgIQQQZF0IIw0BQFmVfxKcAmdFhx8g4FFFhQB4XUo4D+CtN0BlxRQFlcRSlHBa1GJnCx4BLgkqILLJrxqASWYSAKE1Izu8PoaXJ1h1I7kn6/arqau655558jyc3fLj3dnQZY4wAAAAsEuJ0AQAAAOcjoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAKi2LVu2aPz48WrdurUiIyN1ySWXqFOnTnr88cf1ww8/SJKeeeYZde3aVXFxcXK73WrZsqVGjhypL774wuHqAdjMxa+6B1AdCxYs0N133602bdro7rvvVlJSkoqLi7Vx40YtWLBAHTp00MqVKzVjxgyFhISoQ4cOuvTSS/XVV18pMzNT3377rXJzc9WmTRunpwLAQgQUAAHLyclRjx49NGDAAK1atUput9tn/6lTp7RmzRoNHTq03ON37NihpKQkPfzww3rkkUdqo2QAdQy3eAAE7LHHHpPL5dL8+fPLhBNJioiIqDCcSFKTJk0kSWFhYTVWI4C6jSsoAAJSUlKimJgYtW/fXhs2bAjouNOnTys/P1/Tp09XTk6ONm7cqCuuuKIGqwVQV/HPFwABOXTokH766Se1bt06oOOioqLk8XgkSddee63WrVtHOAFQIW7xAKgV2dnZysnJ0auvvqro6Gj16dOHT/IAqBC3eAAEpLq3eM51/PhxXX311erataveeuuti1whgPqAKygAAhIaGqp+/fopNzdX33zzTbXGiI6OVmJionbv3n2RqwNQXxBQAAQsPT1dxhhNmDBBp06dKrO/uLhY77zzToXHHzp0SFu3btXVV19dk2UCqMO4xQOgWs7+orbExETdddddateunYqLi5WXl6f58+crOTlZixcv1oABAzR69Ghdc801atCggXbv3q2nn35aBQUFWr9+vTp37uz0VABYiIACoNo2b96sOXPmKCsrS4WFhQoPD9e1116rIUOGaNKkSYqJidGkSZP08ccfa9++fTp58qSaNWum3r17Kz09XUlJSU5PAYClCCgAAMA6PIMCAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALBOmNMFAPXV6YWjnS7Bb+OOTHS6BL+91map0yX4LWTwPKdLAOosrqAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdcKcLgBw2jfffKMXXnhB2dnZKiwslMvlUnx8vLp37660tDRdccUVTpcIAEGHKygIah999JHatm2rlStXqkOHDrr99ts1duxYdejQQatWrVK7du308ccfO10mAAQdrqAgqN17773685//rDlz5lS4f+rUqfrss88qHcfj8cjj8fi0hRaXyB0eetFqBYBgwhUUBLVt27YpLS2twv0TJ07Utm3bqhwnIyNDsbGxPq/Z/95+MUsFgKBCQEFQS0hIUHZ2doX7c3JylJCQUOU46enpKioq8nk9+D9JF7NUAAgq3OJBULvvvvuUlpam3NxcDRgwQPHx8XK5XCosLNTatWv10ksv6amnnqpyHLfbLbfb7dN2mts7AFBtBBQEtbvvvluXXXaZ5syZo3nz5qmkpESSFBoaqpSUFL3yyisaPny4w1UCQPAhoCDojRgxQiNGjFBxcbEOHTokSYqLi1N4eLjDlQFA8CKgAGeEh4f79bwJAKDm8ZAsAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDouY4xxugigPvrH+r1Ol+C3QZMHO12C3/KWZjldgt/GJic4XQJQZ3EFBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoACV2Ldvn/70pz85XQYABB0CClCJH374QUuWLKmyn8fj0bFjx3xep095aqFCAKifwpwuAHDS22+/Xen+r776yq9xMjIyNGvWLJ+2AamTddP4v1S7NgAIZi5jjHG6CMApISEhcrlcquw0cLlcKikpqXQcj8cjj8f3iskLn+xTWIT7otRZ0wZNHux0CX7LW5rldAl+G5uc4HQJQJ3FLR4EtYSEBC1fvlylpaXlvjZt2uTXOG63WzExMT6vuhJOAMBGBBQEtZSUlEpDSFVXVwAANYNnUBDU7r//fp04caLC/VdffbWysurOLQUAqC8IKAhqPXr0qHR/VFSUevXqVUvVAADO4hYPAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB2XMcY4XQRQH51eONrpEvw27shEp0vw22ttljpdgt9CBs9zugSgzuIKCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQEHQ+/nnn/XRRx9p+/btZfadPHlSr7zySpVjeDweHTt2zOflKS6piXIBICgQUBDUdu/erbZt26pnz55q3769evfurf3793v3FxUVafz48VWOk5GRodjYWJ/X7H+XDTwAAP8QUBDUHnzwQbVv314HDhzQrl27FBMToxtuuEEFBQUBjZOenq6ioiKf14P/k1RDVQNA/RfmdAGAk7Kzs/Xee+8pLi5OcXFxevvtt3XPPfeoR48eysrKUlRUlF/juN1uud1un7bT4aE1UTIABAUCCoLazz//rLAw39Pg+eefV0hIiHr16qWlS5c6VBkABDcCCoJaYmKiNm7cqLZt2/q0P/vsszLGaOjQoQ5VBgDBjWdQENR+//vf6/XXXy9333PPPadRo0bJGFPLVQEAXIafvkCNOL1wtNMl+G3ckYlOl+C319rUndtuIYPnOV0CUGdxBQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHZcxxjhdBFAf/WP9XqdL8NugyYOdLsFveUuznC7Bb2OTE5wuAaizuIICAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA64Q5XQDgtB07dmjDhg3q1q2bEhMTtXPnTj399NPyeDwaO3as+vbtW+UYHo9HHo/Hp+30KY/CItw1VTYA1GtcQUFQW7NmjX73u9/pvvvuU8eOHbVmzRr17NlTe/fuVUFBgW666Sa9//77VY6TkZGh2NhYn9f/vTavFmYAAPUTAQVB7ZFHHtH999+vw4cPa9GiRRo9erQmTJigtWvX6r333tMDDzygzMzMKsdJT09XUVGRz6vfmIm1MAMAqJ8IKAhqX3zxhe644w5J0vDhw3X8+HHdeuut3v2jRo3Sli1bqhzH7XYrJibG58XtHQCoPgIKcEZISIgiIyPVqFEjb1t0dLSKioqcKwoAghQBBUHtyiuv1N69e73bOTk5atmypXd73759SkhIcKI0AAhqfIoHQe2uu+5SSUmJdzs5Odln/7vvvuvXp3gAABcXAQVBLS0trdL9jz76aC1VAgA4F7d4AACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANZxGWOM00UA9VHphnSnS/Db/JA0p0vw28QG/3S6BL+52v/V6RKAOosrKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBSgHMYYp0sAgKBGQAHK4Xa7tWPHDqfLAICgFeZ0AYCTpk2bVm57SUmJMjMzddlll0mSnnzyyUrH8Xg88ng8Pm3hp07LHcEpBgDVwU9PBLWnnnpKHTp0UKNGjXzajTHasWOHoqKi5HK5qhwnIyNDs2bN8mn72503aMafe1zMcgEgaLgMN9sRxDIyMrRgwQK99NJL6tu3r7c9PDxcmzdvVlJSkl/jlHsF5fP/V2euoMwPSXO6BL9NbPBPp0vwm6v9X50uAaiz6sZPT6CGpKenq3///ho7dqyGDBmijIwMhYeHBzyO2+2W2+32aSutI+EEAGzEQ7IIetddd51yc3N18OBBde7cWVu3bvXrtg4AoObwTzxA0iWXXKIlS5bojTfe0IABA1RSUuJ0SQAQ1AgowDlGjhypG2+8Ubm5uWrVqpXT5QBA0CKgAOdp0aKFWrRo4XQZABDUeAYFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYJ0wpwsA6qs5njudLsFvgybf5HQJfnttaZbTJfhtrNMFAHUYV1AAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgnTCnCwBscuTIES1ZskR79uxRQkKCUlNTdcUVV1R5nMfjkcfj8Wk7fcqjsAh3TZUKAPUaV1AQ1Jo3b67Dhw9LkvLz85WUlKTZs2drz549mjdvntq3b6+dO3dWOU5GRoZiY2N9Xv/32ryaLh8A6i2XMcY4XQTglJCQEBUWFqpp06YaNWqUCgsLtXr1ajVs2FAej0e33XabIiMj9eabb1Y6TnlXUF74ZF+duYIyaPJgp0vwW97SLKdL8NvY5ASnSwDqLG7xAGd88skneumll9SwYUNJktvt1l//+lfddtttVR7rdrvldvuGkboSTgDARtziQdBzuVySfrkKEh8f77MvPj5eBw8edKIsAAhqXEFB0OvXr5/CwsJ07Ngx7d69W+3atfPuKygoUFxcnIPVAUBwIqAgqM2YMcNn++ztnbPeeecd9ejRozZLAgCIgIIgd35AOd8TTzxRS5UAAM7FMygAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA67iMMcbpIgBUzePxKCMjQ+np6XK73U6XUylqBXChCChAHXHs2DHFxsaqqKhIMTExTpdTKWoFcKG4xQMAAKxDQAEAANYhoAAAAOsQUIA6wu12a8aMGXXiQU5qBXCheEgWAABYhysoAADAOgQUAABgHQIKAACwDgEFAABYh4AC1BFz585V69atFRkZqZSUFH344YdOl1TGBx98oCFDhqh58+ZyuVxatWqV0yVVKCMjQ9ddd52io6PVtGlTDRs2TLt27XK6LABnEFCAOmDZsmWaOnWqHnroIeXl5alHjx66+eabVVBQ4HRpPk6cOKEOHTroueeec7qUKq1fv1733HOPNmzYoLVr1+r06dMaOHCgTpw44XRpAMTHjIE6oUuXLurUqZNeeOEFb1vbtm01bNgwZWRkOFhZxVwul1auXKlhw4Y5XYpfDh48qKZNm2r9+vXq2bOn0+UAQY8rKIDlTp06pdzcXA0cONCnfeDAgcrOznaoqvqnqKhIktS4cWOHKwEgEVAA6x06dEglJSWKj4/3aY+Pj1dhYaFDVdUvxhhNmzZNN954o5KTk50uB4CkMKcLAOAfl8vls22MKdOG6pk0aZK2bNmijz76yOlSAJxBQAEsFxcXp9DQ0DJXSw4cOFDmqgoCN3nyZL399tv64IMP1KJFC6fLAXAGt3gAy0VERCglJUVr1671aV+7dq26d+/uUFV1nzFGkyZN0ooVK/T++++rdevWTpcE4BxcQQHqgGnTpmncuHHq3LmzunXrpvnz56ugoEBpaWlOl+bjxx9/1N69e73b+fn5+vzzz9W4cWO1bNnSwcrKuueee7R06VK99dZbio6O9l6hio2NVYMGDRyuDgAfMwbqiLlz5+rxxx/X/v37lZycrDlz5lj3cdh169apT58+ZdpTU1O1ePHi2i+oEhU9v7No0SLdcccdtVsMgDIIKAAAwDo8gwIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArBPm5Bfv1GWuJMkV4vrlPfSXd4WE+GwHuv/stkJDvNtVjuXHGJV/zZAzw7l83l2hrjJtv76fOSb0vGMq6h9a/vFl+p/Tr0w9FXzNMu8u3+3QKvb/+n7mP5urnHlXcExolWNWUVOZ485pO7vMrvP6nl1eP/v5O16Iy1WmT2g1x3ap9Jd31y/vISrx2S5vf0X7XGeODali/69jBT7O+WO4zC/vKvNufLdLK+p3/n5T7n5jSssZo/y+FX8tU/n+0oreTSX7yulbTrup8GuU39/nPcBjTInx7Xdm25y3rZLS8tvPbJuSc+Zd4Rjnt/sxpk9t5fc3pcbb9+y+0vO2zXnzNed9De9xFbSX7f/reFUeW8VYpd7jVf57JUvo77eaMVV8jWp8q57fZ7TZpZrGFRQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA+xiEnT540M2bMMCdPnnSqBEcwb+YdDJg38w4GzLtm5+0yxhgngtGxY8cUGxuroqIixcTEOFGCI5g38w4GzJt5BwPmXbPz5hYPAACwDgEFAABYh4ACAACs41hAcbvdmjFjhtxut1MlOIJ5M+9gwLyZdzBg3jU7b8cekgUAAKgIt3gAAIB1CCgAAMA6BBQAAGAdAgoAALBOjQaURx99VN27d1fDhg3VqFEjv44xxmjmzJlq3ry5GjRooN69e+uLL77w6ePxeDR58mTFxcUpKipKQ4cO1TfffFMDM6ieI0eOaNy4cYqNjVVsbKzGjRuno0ePVnqMy+Uq9/XEE094+/Tu3bvM/pEjR9bwbPxXnXnfcccdZebUtWtXnz71bb2Li4v14IMPqn379oqKilLz5s11++2367vvvvPpZ9t6z507V61bt1ZkZKRSUlL04YcfVtp//fr1SklJUWRkpH7zm9/oxRdfLNNn+fLlSkpKktvtVlJSklauXFlT5VdbIPNesWKFBgwYoCZNmigmJkbdunXTf/7zH58+ixcvLvdcP3nyZE1PJSCBzHvdunXlzmnnzp0+/erbepf388vlcqldu3bePrav9wcffKAhQ4aoefPmcrlcWrVqVZXH1Nq5XZO/R/9vf/ubefLJJ820adNMbGysX8dkZmaa6Ohos3z5crN161YzYsQIk5CQYI4dO+btk5aWZi6//HKzdu1as2nTJtOnTx/ToUMHc/r06RqaSWAGDRpkkpOTTXZ2tsnOzjbJyclm8ODBlR6zf/9+n9fChQuNy+UyX375pbdPr169zIQJE3z6HT16tKan47fqzDs1NdUMGjTIZ06HDx/26VPf1vvo0aOmf//+ZtmyZWbnzp0mJyfHdOnSxaSkpPj0s2m933jjDRMeHm4WLFhgtm/fbqZMmWKioqLM119/XW7/r776yjRs2NBMmTLFbN++3SxYsMCEh4ebf/3rX94+2dnZJjQ01Dz22GNmx44d5rHHHjNhYWFmw4YNtTWtKgU67ylTppjZs2ebTz/91Ozevdukp6eb8PBws2nTJm+fRYsWmZiYmDLnvE0CnXdWVpaRZHbt2uUzp3PP0fq43kePHvWZ7759+0zjxo3NjBkzvH1sX+9///vf5qGHHjLLly83kszKlSsr7V+b53at/M8CFy1a5FdAKS0tNc2aNTOZmZnetpMnT5rY2Fjz4osvGmN++YYIDw83b7zxhrfPt99+a0JCQsyaNWsueu2B2r59u5HksxA5OTlGktm5c6ff49xyyy2mb9++Pm29evUyU6ZMuVilXlTVnXdqaqq55ZZbKtwfLOv96aefGkk+PwhtWu/rr7/epKWl+bQlJiaa6dOnl9v/gQceMImJiT5tEydONF27dvVuDx8+3AwaNMinz0033WRGjhx5kaq+cIHOuzxJSUlm1qxZ3m1/fx46KdB5nw0oR44cqXDMYFjvlStXGpfLZf773/962+rCep/lT0CpzXPbqmdQ8vPzVVhYqIEDB3rb3G63evXqpezsbElSbm6uiouLffo0b95cycnJ3j5OysnJUWxsrLp06eJt69q1q2JjY/2u7/vvv9fq1at15513ltn32muvKS4uTu3atdN9992n48ePX7TaL8SFzHvdunVq2rSprr32Wk2YMEEHDhzw7guG9ZakoqIiuVyuMrdCbVjvU6dOKTc312cNJGngwIEVzjEnJ6dM/5tuukkbN25UcXFxpX1sWFepevM+X2lpqY4fP67GjRv7tP/4449q1aqVWrRoocGDBysvL++i1X2hLmTeHTt2VEJCgvr166esrCyffcGw3i+//LL69++vVq1a+bTbvN6Bqs1zO+zCSr24CgsLJUnx8fE+7fHx8fr666+9fSIiInTppZeW6XP2eCcVFhaqadOmZdqbNm3qd31LlixRdHS0/vCHP/i0jxkzRq1bt1azZs20bds2paena/PmzVq7du1Fqf1CVHfeN998s/74xz+qVatWys/P18MPP6y+ffsqNzdXbrc7KNb75MmTmj59ukaPHu3zfwa1Zb0PHTqkkpKScs/LiuZYWFhYbv/Tp0/r0KFDSkhIqLCPDesqVW/e5/vHP/6hEydOaPjw4d62xMRELV68WO3bt9exY8f09NNP64YbbtDmzZt1zTXXXNQ5VEd15p2QkKD58+crJSVFHo9H//znP9WvXz+tW7dOPXv2lFTx90R9We/9+/fr3Xff1dKlS33abV/vQNXmuR1wQJk5c6ZmzZpVaZ/PPvtMnTt3DnRoL5fL5bNtjCnTdj5/+lwIf+ctla1fCqy+hQsXasyYMYqMjPRpnzBhgvfPycnJuuaaa9S5c2dt2rRJnTp18mvsQNX0vEeMGOH9c3Jysjp37qxWrVpp9erVZQJaIONeqNpa7+LiYo0cOVKlpaWaO3euzz4n1rsygZ6X5fU/v70653ptq26Nr7/+umbOnKm33nrLJ8R27drV50HwG264QZ06ddKzzz6rZ5555uIVfoECmXebNm3Upk0b73a3bt20b98+/f3vf/cGlEDHdEp1a1y8eLEaNWqkYcOG+bTXlfUORG2d2wEHlEmTJlX5SYIrr7wy0GElSc2aNZP0S0JLSEjwth84cMCbxpo1a6ZTp07pyJEjPv+qPnDggLp3716tr+sPf+e9ZcsWff/992X2HTx4sEyiLM+HH36oXbt2admyZVX27dSpk8LDw7Vnz54a+wurtuZ9VkJCglq1aqU9e/ZIqt/rXVxcrOHDhys/P1/vv/++z9WT8tTGepcnLi5OoaGhZf71c+55eb5mzZqV2z8sLEyXXXZZpX0C+X6pSdWZ91nLli3TnXfeqTfffFP9+/evtG9ISIiuu+467/e80y5k3ufq2rWrXn31Ve92fV5vY4wWLlyocePGKSIiotK+tq13oGr13A7oiZVqCvQh2dmzZ3vbPB5PuQ/JLlu2zNvnu+++s+6hyU8++cTbtmHDBr8fmkxNTS3zaY6KbN261Ugy69evr3a9F8uFzvusQ4cOGbfbbZYsWWKMqb/rferUKTNs2DDTrl07c+DAAb++lpPrff3115u77rrLp61t27aVPiTbtm1bn7a0tLQyD9LdfPPNPn0GDRpk3UOTgczbGGOWLl1qIiMjq3zY8KzS0lLTuXNnM378+Asp9aKqzrzPd+utt5o+ffp4t+vrehvz60PCW7durfJr2LjeZ8nPh2Rr69yu0YDy9ddfm7y8PDNr1ixzySWXmLy8PJOXl2eOHz/u7dOmTRuzYsUK73ZmZqaJjY01K1asMFu3bjWjRo0q92PGLVq0MO+9957ZtGmT6du3r3UfO/3tb39rcnJyTE5Ojmnfvn2Zj52eP29jjCkqKjINGzY0L7zwQpkx9+7da2bNmmU+++wzk5+fb1avXm0SExNNx44d6+y8jx8/bv73f//XZGdnm/z8fJOVlWW6detmLr/88nq93sXFxWbo0KGmRYsW5vPPP/f56KHH4zHG2LfeZz9++fLLL5vt27ebqVOnmqioKO+nFaZPn27GjRvn7X/2o4j33nuv2b59u3n55ZfLfBTx448/NqGhoSYzM9Ps2LHDZGZmWvuxU3/nvXTpUhMWFmaef/75Cj8ePnPmTLNmzRrz5Zdfmry8PDN+/HgTFhbmE3KdFui858yZY1auXGl2795ttm3bZqZPn24kmeXLl3v71Mf1Pmvs2LGmS5cu5Y5p+3ofP37c+3ezJPPkk0+avLw87ycKnTy3azSgpKamGkllXllZWb8WIJlFixZ5t0tLS82MGTNMs2bNjNvtNj179iyTSn/++WczadIk07hxY9OgQQMzePBgU1BQUJNTCcjhw4fNmDFjTHR0tImOjjZjxowp8/G78+dtjDHz5s0zDRo0KPd3XRQUFJiePXuaxo0bm4iICHPVVVeZv/zlL2V+Z4iTAp33Tz/9ZAYOHGiaNGliwsPDTcuWLU1qamqZtaxv652fn1/ueXHuuWHjej///POmVatWJiIiwnTq1MnnSk5qaqrp1auXT/9169aZjh07moiICHPllVeWG7zffPNN06ZNGxMeHm4SExN9/kKzRSDz7tWrV7nrmpqa6u0zdepU07JlSxMREWGaNGliBg4caLKzs2txRv4JZN6zZ882V111lYmMjDSXXnqpufHGG83q1avLjFnf1tuYX67yNmjQwMyfP7/c8Wxf77NXfyr6nnXy3HYZc+bpFgAAAEtY9XtQAAAAJAIKAACwEAEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKzz/wHHU/b7nK6E4wAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for i in np.arange(4): # 遍历矩阵 A 和 B 的列\n", + " C_i = A[:, [i]] @ B[[i], :] # 计算 A 的第 i 列和 B 的第 i 行的外积\n", + " title = 'C' + str(i + 1) # 设置子矩阵标题\n", + " plot_heatmap(C_i, title) # 可视化子矩阵 C_i\n", + " C_rep = C_rep + C_i # 将 C_i 加到 C_rep 中" + ] + }, + { + "cell_type": "markdown", + "id": "06f5ff56-7974-4f77-9a24-45825b1299c7", + "metadata": {}, + "source": [ + "## 可视化重建后的矩阵 C" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "baa2247b-6687-4e8b-8f78-6c7578f01045", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_heatmap(C_rep, 'C reproduced') # 可视化重建的矩阵 C_rep" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch07_Python_Codes/Streamlit_Bk4_Ch07_01.py b/Book4_Ch07_Python_Codes/Streamlit_Bk4_Ch07_01.py new file mode 100644 index 0000000..1414775 --- /dev/null +++ b/Book4_Ch07_Python_Codes/Streamlit_Bk4_Ch07_01.py @@ -0,0 +1,131 @@ + +############### +# Authored by Weisheng Jiang +# Book 4 | From Basic Arithmetic to Machine Learning +# Published and copyrighted by Tsinghua University Press +# Beijing, China, 2025 +############### + +import plotly.graph_objects as go +import numpy as np +from plotly.subplots import make_subplots +import streamlit as st + +# 定义一个函数，用于返回LaTeX格式的bmatrix +def bmatrix(a): + """返回LaTeX bmatrix + :a: numpy数组 + :returns: 作为字符串的LaTeX bmatrix + """ + if len(a.shape) > 2: + raise ValueError('bmatrix最多只能显示二维数组') + lines = str(a).replace('[', '').replace(']', '').splitlines() + rv = [r'\begin{bmatrix}'] + rv += [' ' + ' & '.join(l.split()) + r'\\' for l in lines] + rv += [r'\end{bmatrix}'] + return '\n'.join(rv) + +# 设置网格的范围 +n = m = 20 + +# 创建一个具有两个子图的图表 +fig = make_subplots(rows=1, cols=2, horizontal_spacing=0.035) + +# 初始化垂直线的x和y坐标列表 +xv = [] +yv = [] + +# 添加垂直线的坐标 +for k in range(-n, n + 1): + xv.extend([k, k, np.nan]) + yv.extend([-m, m, np.nan]) + +# 设置线宽 +lw = 1 +# 添加垂直线到图表 +fig.add_trace(go.Scatter(x=xv, y=yv, mode="lines", line_width=lw, + line_color='red'), 1, 1) + +# 初始化水平线的x和y坐标列表 +xh = [] +yh = [] +# 添加水平线的坐标 +for k in range(-m, m + 1): + xh.extend([-m, m, np.nan]) + yh.extend([k, k, np.nan]) + fig.add_trace(go.Scatter(x=xh, y=yh, mode="lines", line_width=lw, + line_color='blue'), 1, 1) + +# 在侧边栏中添加滑块控件 +with st.sidebar: + # 显示LaTeX矩阵 + st.latex(r''' + A = \begin{bmatrix} + a & b\\ + c & d + \end{bmatrix}''') + + # 添加矩阵A的参数滑块 + a = st.slider('a', -2.0, 2.0, step=0.1, value=1.0) + b = st.slider('b', -2.0, 2.0, step=0.1, value=0.0) + c = st.slider('c', -2.0, 2.0, step=0.1, value=0.0) + d = st.slider('d', -2.0, 2.0, step=0.1, value=1.0) + +# 定义旋转角度 +theta = np.pi / 6 +# 定义矩阵A +A = np.array([[a, b], + [c, d]], dtype=float) + +# 将垂直线的坐标转换为NumPy数组 +X = np.array(xv) +Y = np.array(yv) + +# 通过矩阵A变换垂直线的坐标 +Txvyv = A @ np.stack((X, Y)) + +# 将水平线的坐标转换为NumPy数组 +X = np.array(xh) +Y = np.array(yh) + +# 通过矩阵A变换水平线的坐标 +Txhyh = A @ np.stack((X, Y)) + +# 显示矩阵A的LaTeX格式 +st.latex(bmatrix(A)) + +# 提取矩阵A的列向量 +a1 = A[:, 0].reshape((-1, 1)) +a2 = A[:, 1].reshape((-1, 1)) + +# 显示列向量的LaTeX表达式 +st.latex(r''' + a_1 = Ae_1 = ''' + bmatrix(A) + + 'e_1 = ' + bmatrix(a1) + ) + +st.latex(r''' + a_2 = Ae_2 = ''' + bmatrix(A) + + 'e_2 = ' + bmatrix(a2) + ) + +# 添加变换后的垂直线到图表 +fig.add_trace(go.Scatter(x=Txvyv[0], y=Txvyv[1], + mode="lines", line_width=lw, + line_color='red'), 1, 2) + +# 添加变换后的水平线到图表 +fig.add_trace(go.Scatter(x=Txhyh[0], y=Txhyh[1], + mode="lines", line_width=lw, + line_color='blue'), 1, 2) + +# 设置x轴和y轴的范围 +fig.update_xaxes(range=[-4, 4]) +fig.update_yaxes(range=[-4, 4]) + +# 设置图表的布局和样式 +fig.update_layout(width=800, height=500, showlegend=False, template="none", + plot_bgcolor="white", yaxis2_showgrid=False, xaxis2_showgrid=False) + +# 在Streamlit应用中显示图表 +st.plotly_chart(fig) diff --git a/Book4_Ch07_Python_Codes/Streamlit_Bk4_Ch07_02.py b/Book4_Ch07_Python_Codes/Streamlit_Bk4_Ch07_02.py new file mode 100644 index 0000000..f7cd4bc --- /dev/null +++ b/Book4_Ch07_Python_Codes/Streamlit_Bk4_Ch07_02.py @@ -0,0 +1,74 @@ + +############### +# Authored by Weisheng Jiang +# Book 4 | From Basic Arithmetic to Machine Learning +# Published and copyrighted by Tsinghua University Press +# Beijing, China, 2025 +############### + +import pandas as pd +import plotly.graph_objs as go +import streamlit as st +import numpy as np + +# 使用 Streamlit 的侧边栏设置滑块，用于选择每个维度的数据点数量 +with st.sidebar: + num = st.slider('Number of points for each dimension', # 滑块标题 + max_value=20, # 最大值为20 + min_value=10, # 最小值为10 + step=1) # 步长为1 + +# 生成从0到1均匀分布的线性空间数据点 +x1 = np.linspace(0, 1, num) +x2 = x1 # x2 和 x1 相同 +x3 = x1 # x3 和 x1 相同 + +# 生成三维网格，用于三维坐标的组合 +xx1, xx2, xx3 = np.meshgrid(x1, x2, x3) + +# 将网格展开为一维数组 +x1_ = xx1.ravel() +x2_ = xx2.ravel() +x3_ = xx3.ravel() + +# 创建一个 Pandas DataFrame，存储三维坐标和对应的RGB颜色分量 +df = pd.DataFrame({'X': x1_, # x 坐标 + 'Y': x2_, # y 坐标 + 'Z': x3_, # z 坐标 + 'R': (x1_ * 256).round(), # R 通道值 + 'G': (x2_ * 256).round(), # G 通道值 + 'B': (x3_ * 256).round()}) # B 通道值 + +# 创建 3D 散点图的跟踪对象 +trace = go.Scatter3d( + x=df.X, # x 轴数据 + y=df.Y, # y 轴数据 + z=df.Z, # z 轴数据 + mode='markers', # 数据点的显示模式为散点 + marker=dict( + size=3, # 数据点的大小 + color=['rgb({},{},{})'.format(r, g, b) # 将 RGB 分量转换为颜色字符串 + for r, g, b in zip(df.R.values, df.G.values, df.B.values)], + opacity=0.9, # 数据点的不透明度 + ) +) + +# 将散点图添加到数据列表中 +data = [trace] + +# 定义 3D 图的布局，包括坐标轴和边距 +layout = go.Layout( + margin=dict(l=0, r=0, b=0, t=0), # 图形边距设置为0 + scene=dict( + xaxis=dict(title='e_1'), # x 轴标题 + yaxis=dict(title='e_2'), # y 轴标题 + zaxis=dict(title='e_3'), # z 轴标题 + ), +) + +# 创建包含数据和布局的图表对象 +fig = go.Figure(data=data, layout=layout) + +# 使用 Streamlit 显示图表 +st.plotly_chart(fig) + diff --git a/Book4_Ch08_Python_Codes/Bk4_Ch08_01.ipynb b/Book4_Ch08_Python_Codes/Bk4_Ch08_01.ipynb new file mode 100644 index 0000000..869ed9e --- /dev/null +++ b/Book4_Ch08_Python_Codes/Bk4_Ch08_01.ipynb @@ -0,0 +1,477 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d7cd1786-3bfc-4453-94e2-f3be3b2355ab", + "metadata": {}, + "source": [ + "Chapter 08\n", + "\n", + "# 平面几何变换\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "86455193-3d75-4c6b-8a72-7cf30e680f7d", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2677c0fd-a1e5-46f8-bb9c-6cca75329d63", + "metadata": {}, + "outputs": [], + "source": [ + "def lighten_color(rgb, percentage):\n", + " \"\"\"\n", + " 让给定的 RGB 颜色变浅指定百分比。\n", + " \n", + " 参数：\n", + " rgb (tuple): 原始 RGB 颜色，每个值在 [0, 1] 之间。\n", + " percentage (float): 变浅的比例，取值在 [0, 1] 之间。\n", + " \n", + " 返回：\n", + " tuple: 变浅后的 RGB 颜色。\n", + " \"\"\"\n", + " # 确保输入的 RGB 值和百分比在合法范围\n", + " if not all(0 <= c <= 1 for c in rgb):\n", + " raise ValueError(\"RGB 值必须在 (0, 1) 范围内。\")\n", + " if not (0 <= percentage <= 1):\n", + " raise ValueError(\"百分比必须在 [0, 1] 范围内。\")\n", + " \n", + " # 计算新的 RGB 值\n", + " return tuple(c + (1 - c) * percentage for c in rgb)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ac46222e-1d6d-457e-b644-d2e88cb6dc72", + "metadata": {}, + "outputs": [], + "source": [ + "## 定义可视化函数\n", + "def visualize(X_square_original,\n", + " X_grid, X_shape, title_txt):\n", + " fig, ax = plt.subplots() # 创建绘图窗口\n", + " \n", + " # 绘制变换后的网格\n", + " for i in range(X_grid.shape[0]):\n", + " plt.plot(X_grid[i, :, 0], X_grid[i, :, 1], 'k-', linewidth=0.5) # 绘制网格行\n", + " for j in range(X_grid.shape[1]):\n", + " plt.plot(X_grid[:, j, 0], X_grid[:, j, 1], 'k-', linewidth=0.5) # 绘制网格列\n", + " \n", + " # 绘制变换后的散点，并用HSV色彩渲染\n", + " colors = plt.cm.hsv(np.linspace(0, 1, X_shape.shape[0])) # HSV 色彩映射\n", + " for i in range(X_shape.shape[0]):\n", + " plt.plot(X_shape[i, 0], X_shape[i, 1], 'o', color=colors[i], markersize=4, zorder=1000) # 绘制散点\n", + " plt.plot(X_square_original[i, 0], X_square_original[i, 1], 'o', color=lighten_color(colors[i], 0.78), markersize=4)\n", + " plt.plot((X_shape[i, 0],X_square_original[i, 0]),\n", + " (X_shape[i, 1],X_square_original[i, 1]), lw = 0.25, color = lighten_color(colors[i], 0.78), zorder=1)\n", + " \n", + " # 绘制变换后的坐标轴方向向量\n", + " # plt.quiver(0, 0, X_vec[0, 0], X_vec[1, 0], angles='xy', scale_units='xy', scale=1, color=[0, 0.4392, 0.7529]) # 绘制第一个向量\n", + " # plt.quiver(0, 0, X_vec[0, 1], X_vec[1, 1], angles='xy', scale_units='xy', scale=1, color=[1, 0, 0]) # 绘制第二个向量\n", + " \n", + " # 绘制 x 和 y 轴\n", + " plt.axvline(x=0, color='k', zorder=0) # 绘制 x 轴\n", + " plt.axhline(y=0, color='k', zorder=0) # 绘制 y 轴\n", + " \n", + " # 设置标签和网格\n", + " # plt.ylabel('$x_2$') # y轴标签\n", + " # plt.xlabel('$x_1$') # x轴标签\n", + " # 移除 x 和 y 轴的刻度\n", + " ax.tick_params(axis='both', which='both', length=0, labelbottom=False, labelleft=False)\n", + " \n", + " # 移除 x 和 y 轴标签\n", + " ax.set_xlabel(\"\")\n", + " ax.set_ylabel(\"\")\n", + " ax.set_aspect(1) # 设置坐标轴比例\n", + " ax.set_xlim([-3, 3]) # x轴范围\n", + " ax.set_ylim([-3, 3]) # y轴范围\n", + " ax.grid(linestyle='--', linewidth=0.15, color=[0.8, 0.8, 0.8]) # 添加网格\n", + " plt.title(title_txt) # 设置图标题\n", + " # plt.savefig(title_txt + '.svg')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7d3b4625-97b8-4c08-afb8-52e7dd276592", + "metadata": {}, + "outputs": [], + "source": [ + "def generate_square_border_scatter(n):\n", + " \"\"\"\n", + " 生成平面上正方形边框均匀排布的散点坐标，按顺时针顺序排列。\n", + "\n", + " 参数：\n", + " n (int): 每条边上的散点数。\n", + "\n", + " 返回：\n", + " np.ndarray: 一个二维数组，每行代表一个点，\n", + " 第一列为 x1 坐标，第二列为 x2 坐标。\n", + " \"\"\"\n", + " # 创建边框上的散点坐标\n", + " x = np.linspace(-1, 1, n) # 边框坐标范围\n", + "\n", + " # 上边框的点（从左到右）\n", + " top = np.column_stack((x, np.full_like(x, 1)))\n", + " # 右边框的点（从上到下）\n", + " right = np.column_stack((np.full_like(x, 1), np.flip(x)))\n", + " # 下边框的点（从右到左）\n", + " bottom = np.column_stack((np.flip(x), np.full_like(x, -1)))\n", + " # 左边框的点（从下到上）\n", + " left = np.column_stack((np.full_like(x, -1), x))\n", + "\n", + " # 按顺时针顺序合并所有边框点\n", + " points = np.vstack((top, right, bottom, left))\n", + "\n", + " return points" + ] + }, + { + "cell_type": "markdown", + "id": "07b85ccf-0b79-47e4-bf63-d8c483ae2bbf", + "metadata": {}, + "source": [ + "## 准备数据" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "169be63b-b643-44b4-89ac-3246a234278a", + "metadata": {}, + "outputs": [], + "source": [ + "## 创建一个包含足够大的1x1网格区域\n", + "x_vals = np.arange(-10,10+1) # x轴网格点\n", + "y_vals = np.arange(-10,10+1) # y轴网格点\n", + "X1, X2 = np.meshgrid(x_vals, y_vals) # 生成网格\n", + "X_grid = np.stack([X1, X2], axis=2) # 将网格堆叠为3维数组" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ad500d0a-9564-4216-9551-5ce14346c1e7", + "metadata": {}, + "outputs": [], + "source": [ + "X_vec = np.array([[1, 0],\n", + " [0, 1]]) # 初始坐标轴向量" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "07326b71-0007-4b2b-9e21-c823370db86d", + "metadata": {}, + "outputs": [], + "source": [ + "X_square = generate_square_border_scatter(20)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6a177455-baea-4428-817d-2442d501848d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## 绘制原始网格、散点和坐标轴向量\n", + "visualize(X_square,\n", + " X_grid, \n", + " X_square, \n", + " 'Original Grid and Points') # 绘制原始图像" + ] + }, + { + "cell_type": "markdown", + "id": "06ea5549-88af-4511-9ee5-9d374f346dea", + "metadata": {}, + "source": [ + "## 平移" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f7dd6e01-f084-4169-a98e-af8b14103b95", + "metadata": {}, + "outputs": [], + "source": [ + "t1 = np.array([[-1.5],\n", + " [1]])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4b9e92ca-27d4-467a-8382-6474396807c8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGZCAYAAABmNy2oAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABpmUlEQVR4nO29eZxkVXn//z63bq29V/d0z9LQMyw9CEyPGtwX4KuCAiLMuIJs6u+n0SQqZviFaAJDjEZI8tW4RBMXojExRAoBcUENmCgKJEYcBRkYWWbtnt636tru+f1xq6prubemZ6i6VfR93q9Xv6rr3PPce0/dqvvczznPeY7SWmsEQRAEATCafQKCIAhC6yBOQRAEQSgiTkEQBEEoIk5BEARBKCJOQRAEQSgiTkEQBEEoIk5BEARBKCJOQRAEQSgiTkEQBEEoIk5BOCruu+8+rr/+eqanp5t9KjW5+eabUUrx5JNPHrVtrTaeddZZnHXWWc/4/I6WxcVFrr/+eu69996qbXNzc1xzzTWcc845rFmzBqUU119/vefnKKwOxCkIR8V9993Hzp07W94pPBNqtfFzn/scn/vc5zw/p8XFRXbu3OnoFCYmJviHf/gHUqkUF110kefnJqwuzGafgLB6SSaTRKPRZp9GXTn11FObfQpVDA0NMTU1hVKK8fFxvvjFLzb7lIRnMaIUhBVz/fXXs2PHDgA2bdqEUgqlFPfeey8bN27kggsuIJFI8LznPY9IJMLOnTsB+OxnP8srX/lK+vv7aWtrY8uWLdx4441kMpmy/Z911lmcfvrpPPjgg7ziFa8gFotxwgkn8Fd/9VdYllWsZ1kWH/3oR9m8eTPRaJTu7m5GRkb41Kc+VfP8f/CDH/CGN7yBwcFBIpEIJ510Eu9+97sZHx9fURsL51jZfTQ5Ocl73/teNmzYQCgU4oQTTuDDH/4wqVSqrJ5Sij/4gz/ga1/7Gs95znOIxWJs3bqVb3/72zXP+8knn2TNmjUA7Ny5s3hOV155ZXG/Sqma+xCElSJKQVgx73rXu5icnOTTn/40iUSCdevWActPz7/4xS945JFH+MhHPsKmTZtoa2sDYM+ePVxyySVs2rSJUCjEQw89xF/+5V/y29/+li9/+ctlxzh06BCXXnopH/rQh7juuuu47bbbuPbaa1m/fj2XX345ADfeeCPXX389H/nIR3jlK19JJpPht7/97RG7tPbs2cNLXvIS3vWud9HV1cWTTz7J3/7t3/Lyl7+cXbt2EQwGj9jGSpaWljj77LPZs2cPO3fuZGRkhP/6r//i4x//OL/85S+56667yurfddddPPjgg9xwww20t7dz4403cvHFF/Poo49ywgknOB5j3bp1fO973+O1r30t73znO3nXu94FUHQUglBXtCAcBTfddJMG9BNPPFFWPjQ0pAOBgH700Udr2udyOZ3JZPRXv/pVHQgE9OTkZHHbmWeeqQF9//33l9mceuqp+txzzy2+v+CCC/Rzn/vcmsf5yle+4nieBSzL0plMRj/11FMa0LfffvsR21g4xzPPPLP4/vOf/7wG9C233FJW7xOf+IQG9N13310sA/TAwICenZ0tlh06dEgbhqE//vGP12zP4cOHNaCvu+66utQTBDek+0ioGyMjIwwPD1eV/+///i8XXnghvb29BAIBgsEgl19+Oblcjt27d5fVXbt2LS984Qur9vvUU08V37/whS/koYce4r3vfS/f//73mZ2dXdH5jY2N8Z73vIfjjjsO0zQJBoMMDQ0B8MgjjxxtcwH4j//4D9ra2njjG99YVl7o2vnRj35UVn722WfT0dFRfD8wMEB/f39Z+wShmUj3kVA3Cl0tpTz99NO84hWvYPPmzXzqU59i48aNRCIRHnjgAd73vveRTCbL6vf29lbtIxwOl9W79tpraWtr45//+Z/5/Oc/TyAQ4JWvfCWf+MQnOOOMMxzPzbIszjnnHA4cOMCf/dmfsWXLFtra2rAsixe/+MVV57FSJiYmWLt2bVWffn9/P6ZpMjExcdTtE4RmIk5BqBtOg53f+ta3WFhYIJFIFJ/KAX75y18e83FM0+Tqq6/m6quvZnp6mh/+8If86Z/+Keeeey579+4lFotV2fz617/moYce4uabb+aKK64olj/++OPHfB5g3+Tvv/9+tNZl7R8bGyObzdLX1/eM9i8IXiPdR8JREQ6HAVb8ZFu4URbsALTW/OM//mNdzqe7u5s3vvGNvO9972NyctJ1sprTeQB84QtfqKp7NG181atexfz8PN/61rfKyr/61a8Wt9eDo/3cBeFYEaUgHBVbtmwB4FOf+hRXXHEFwWCQzZs3u9Z/zWteQygU4m1vexvXXHMNS0tL/P3f/z1TU1PHfA6vf/3rOf300znjjDNYs2YNTz31FJ/85CcZGhri5JNPdrQ55ZRTOPHEE/mTP/kTtNbE43HuvPNOfvCDH6y4jaVjAQUuv/xyPvvZz3LFFVfw5JNPsmXLFn7yk5/wsY99jPPOO49Xv/rVx9RGpRRnnnlmMRS2o6ODoaEhbr/9dl71qlcRj8fp6+tj48aNAHz3u99lYWGBubk5AB5++GG++c1vAnDeeec5qidBcKTJA93Cs5Brr71Wr1+/XhuGoQF9zz336KGhIX3++ec71r/zzjv11q1bdSQS0Rs2bNA7duzQ3/3ud4u2Bc4880x92mmnVdlfccUVemhoqPj+b/7mb/RLX/pS3dfXp0OhkD7++OP1O9/5Tv3kk08W6zhFHz388MP6Na95je7o6NA9PT36TW96k3766acdo3Wc2lg4x9LoI621npiY0O95z3v0unXrtGmaemhoSF977bV6aWmprB6g3/e+91W1b2hoSF9xxRXF93NzcxrQb33rW8vq/fCHP9TPe97zdDgc1kCZzdDQkAYc/9wisATBCaW11s1wRoIgOPOd73yHCy64gIceeqioWgTBK2RMQRBajHvuuYe3vvWt4hCEpiBKQRAEQSgiSkEQBEEoIk5BEARBKCJOQRAEQSiyonkKlmVx4MABOjo6JEWvIAjCsxCtNXNzc6xfvx7DcNcDK3IKBw4c4LjjjqvbyQmCIAjNYe/evQwODrpuX5FTKMzk3Lt3L52dnfU5s6PgLW95C//2b//m+XGz2Sxg59rxGj+2GZrT7oWFheKs7EcffbS4DoSXNKPdfrzW4N92T05OsmnTJseZ+aWs6FMpdBl1dnY2xSkEg8GmHLeZXx4/thma0+5AIFCU052dnU1xCs1otx+vNUi7jzQEIAPNgiAIQhFJiCcI2INwgiCIUxAE4MiSWhD8gnQfCYIgCEVEKdTAj10Kfmwz+FMp+PVaS7trI0pBEARBKCJKoQZ+fHr0Y5vBn0+Pfr3W0u7aiFIQBEEQiohSEAT8qRQEwQlxCoKAf7sUBKES6T4SBEEQiohSEASk+0gQCohTEASk+0gQCkj3kSAIglBElEIN/Nil4Mc2gz+Vgl+vtbS7NqIUBEEQhCLiFARBEIQi0n1UAz92KfixzeDPLgW/Xmtpd23EKQgC/nQKguCEOAVBwL9Pj4JQiYwpCIIgCEVEKQgC0n0kCAXEKQgC0n0kCAWk+0gQBEEoIk5BEARBKCLdRzXwYz+zH9sM/uw+8uu1lnbXRpSCIAiCUEScgiAIglBEuo9q4McuBT+2GcCyrGafguf49VpLu2sjTkEQ8O+NQhAqke4jQRAEoYgoBUHAvxEpglCJOAVBQLqPBKGAdB8JgiAIRUQpCALSfSQIBcQp1MCPNwo/thnAMPwnmv16raXdtfHfL0EQBEFwRZyCIAiCUES6j2rgx4gUP7YZ/Nml4NdrLe2ujSgFQRAEoYg4BUEQBKGIdB8JAv7sPhIEJ8QpCAL+7WcWhEqk+0gQBEEoIkpBEJDuI0EoIE5BEJDuI0EoIE6hBn58evRjm8GfTsGv11raXRsZUxAEQRCKiFMQBEEQikj3UQ382KXgxzaDP7sU/Hqtpd21EaUgCIIgFBGlIAj4UykIghPiFAQB/3YpCEIl0n0kCIIgFBGlIAhI95EgFBCnIAhI95EgFGjt7qNr/hyig9x+5wMQHbTfA9yZgFduhfVR+/XOxLLN9xNw/lY4NWq/fj+/7Z4EXLIVXh61X+8psflJAn5/K7w+ar/+xN6m/uc2Atc/H/6fKHxkK/x3ic2vEnDTVtgRtV9/ld/2SAK+sBU+FrVfHymx2ZOAb2yFz0ft1z35bfsT8IOtkIjar/tLbMYScP9WuDdqv47lt00n4Ldb4aGo/TpdYrOYgANb4amo/bpob9PZBLnkVnKLUXLJrejssk2WBItsJRVoJx14PlnsbYskOMRW9hLlEFtZZNlmhgS72cououxmKzP5baMkuI+t/JAo97GV0RKbvST4Llu5hSjfZSt789t+zDXcRJQX3X4nNxHlx1zj/r0QBKFhKL0C3Tw7O0tXVxczMzN0dnZ6cV62A7jpHwENqOXX7WfCPf8GSoHWy6833woh4H3bq7e9dwd846bq8k/cCkHgow42l+6AH92EVgpVWv4H+eN8ZXv5eaHh3B3w4E3V5W/M23zPwebFO+CJapuP33sG1/75tfBrB5sTd8CUw3E25o9zuNpGr9mBRbWNEbqVnAkpSmy0AqWx2MG0g00vt5IBnqL6OB3s4DEHm63cShr4qYNNG2/gV9xe9RV4OTs4kxuP7ftzFCwsLDA4OAjAvn37aGtra/gxK7nwwgu54447PD1mJpMBIBgMenrcAs1oM/i33RMTE/T19R3xPn5UTmF8fJzOzs4jSu3SXdaqW6teoGMjLGVRLJdrNJg56Jqwb9SFcqXg1C3QoWH3r6u39YXBSlWV6xO3oDo1POVgszYMONhsyNsc/DWKCpt4GHSqvBwF/VugU8Pkrx22hUFV2zwx2c6mrRthwcGmOwyGw3Ei+c8gW21j9YTRpoMNW0hFNfBrUCVfBa2YIUyOVFW5yRZm0aQcbCYIk3GwaWcLM2hmHGyeArJoKP0KaAgR4YO5uRV/n+DYvnuLi4uMjIwAsGvXLmKx2DHts7Tu0Z7nxRdfzG233baiuivd55GOn81mgSPfHI+1TUeqW2hzPdu0kroFp2CaZt3btJK6F110UfFaN+L4bvUmJiZYu3ZtfZ3COeecQzAY9MQp3PHtB8scQtEGjYqPVpWnlQE9ENJWtU2P/aBfZYMBcQjhYDPgYqMN6IaQcRTHsfLnFnCw6Xe2WcqA0WsQMo/iOJn8cYLVNtk+F5u0wVIMQqFqm8nCw3wFmbTBFBB0sDnkYpPN2wQcbPa42KDh5xde0HCnkMvluPfeewE4++yzCQQCx7TP0rpHe54PPvggL3jBC1ZUd6X7PJrjr6RuvfdZaLPXbWr053Skug888EDxWnt5ndLpNHfffXd9nYKn3UfRQVjKUvX4mFcKlJ62UvCcLdAJ7N5VvS2vFKrKT9wCXcCTDjZrw+gKpYBSsCFvc2CXfT6l2/JKoay8oBS6gIldDttspVBZ/rvJdk7YugkWHGzySqGqPJL/DDLVNrl4GAIONmoLqShoqm2KSqGiPMgWZoElB5uiUqgot5UCzDjYFJVCBSEi7CBZVV5vFhYW2LBhAwD79+/3TfdRQSmYZnPiTZrVjeLXdk9OTtLb23vE+3jrDjT/4TtY7nuGYh/0q1+83PcPJX39fwzvuNp52wXvcC5/+4dgm4vNy96B0truFiotf92H4Myr7fOp3DbyjuXztDfY71/8Idj6IedtxzvbfOOXJ8Jxf+xs0+1ynP6rodPZxlDvdCxXwQ8S1BU2ujA+4GzTzgdZww7Hbce72AzxQU7lGsdtp3AuTmzlMhYZc9xWb7TWEpYqCLSyU7jxBnjDuaBM2y0oEy56Hdx1O/zNP8DJp0A4AqeOwD8l4C2XwYVvg499EYZPh1AENo/A5xLwp5+BP78ZNp1ql580Ap9IwHmXw1lvgw98ETaeDsEIbBqBP0vAOz9D7qovw7pT7fLBEfjDBLzscnjeW+HNX4S1W8CMwLoRuCoBr/8MvP5mWHMaBCIwMAJvSsDWy+HkN8NZX4TeLfa23hF4XQJe+Bl4/leg8zQwItA1Ai9J8PN9x8HAG2HzF6Fti72tfQS2JGDTZ2DwKxA+DVQEIiOwMQHxKyD2Ruj5IgS3ABEIjsCaBKrt0xjml0GdZperEYxQAsO8EpPthPSXUHoL6DCKLYRJ0M7f0cuXCWLbBBmhlwTtXEkXF3McXyLCFhQRIowwRIIT+DtO58u0cxoGEdoZYSsJNnAlg1zEi/gSXWzBIEI3I7ycBBdyF8fzWiZQHNIwgWITF3EO/wDANI9jkW3o100pJWGpgkArdx8lfgDbP7D8FF54vfWTsO01sLAA+w/CQD90lZyT1jAzDZYFPfHyjvRMGqYnoasHQuFym7kp+/+O5Q77bDYLmRRmcg464hAMldssTNp1YxWd/NklSE5DLA6BCpvkJCgDIt3VNulpiPSCEVyWmFpDesJ2iqHu8s8ol4TsDAT7wDDLj5ObABWEQFe5jbUIeg6MXnufRRMLmCCbDaBUZ5m01iwCc0AvitJyC4sJFGEMyr8XFgtYzBOgD0WgzCbDOAZRTDoA+CUJvuQQlfRObuW5bMMiyyxPEqKTGP3UG+k+8lc3il/b/ezvPtr5uWVHAMuO4Ya/t9+3tcFJJ8DsHDz5tO0EwK7T3QMdHXB4FFKp5X0GQ9A3AMkF2zkU9q0UdMYh2g6To5AptQlDzwAk52Guwqa9F0JtMDsK2fSyjRmB9gFYmoPFqXKbWC8Eo7AwCrlMuU10AFIzkJpeLlcKwn0QCMPSIbBKbAJRCA1AdhoyFTZmH6gQZA6BLnnKNmJg9IM1BdZMiYmBUmuAIFofRpfYKGLAGmAKzWxJuUGANUCAHKNocsuHoY0Aa8gxQY65MpsQ/SgM0nmb77IzH1Sw3FWoUHyPG/L7MunmJKBxqkG6jwTBpnWdwu4nywd/wX7/6BPL7w0DjtsAa3rh8d/BzPINi2AI1gxAchEmJ8pvzF1xaGuH8VFIVziNeN5pzDo4jUgbTI3aiqNoE4bOvANYqLBp64VQFOZHIVfhNNoGIDULyQqnEe2zu5dyqWoHEB6AzIytKAooBaE+MMKQOgRWqQOIgjkAuWnIzZTbBGwHQG60zGkoFQV6gSm0LnEaGCjWACaaUXTJjdmgDYM1WExiVTgNM+8AshVOI0AbQdaQYYIxHrXDjUvQaEb5bZlNjH462cgsT9Z9rEG6jwTBpnWdwvDG6hhKpWDzpuq6jVINU2PNUw2BcIuohtGGq4Z+TqY8ygwUigFOIcUEmRIbL1SDIPiZ1nUK173XOSpoxzuc6zdANejuNejkYnNUAyyrhkUHB9Ag1aCtbEm8c4kDaKBqeB07KXQZ2XUVGs3ZXE2YNSgUS4w1VDX4USn4tcvMz+1eCa3rFLa9xh5UHhkmbSgYGYbEp+CiV8HoBORyznb1Vg0d3f4aa9DTYJU8zXugGp7LNt7JraxnBCttsI7n8E6+ye/xVuYYBYKE6RPVIAge0LpOAYAQ6A6g237VQWiLwpo4TM7A7Lyz2WoYa8hlnMcaGq0ajF7AdBhraKxqyAAzaKaBWUySzAIpOhggzQKLTHmmGgTBz7SuU0j8GLZ/GHb9jpAF7Pqd/T7xYzCU7RgCgYaqBjU7vdzT7XWEkhFoimpQSqEC3o413M9X+RTb2ccuVMhiH7v4LO/gf7iTDGNE6SJMR0NVgx+7FPzYZQb+bvdKaF2nsPPLLiGpX1mu02jVEGuDicPNUQ3KOHKEkodjDY1UDbfzyeI4AtiRRwrF7dxYjFBqtGrwo1MQBCda1yns3usSkvp0eVmjVUPvGp/Naxh1HmtooGo4xG7HkNSDPFo2r6GRqsGvT4+CUEnrOoXh41xCUo93rr/axhpKs72uZF5D3VRDv60YPFQNaxmuyoirUKxleLk5JfMaZKxBEBpH6zqF61yS2P3RmyCZcrbxaKzBE9VgZZuoGno9nddwEe8vdhnZ2+yupHN5DwuMltk0SjVI95Eg2LSuU9h2Juy4DMIRu2MhHIFrLod3nA+pDIzPVHcvFaiXalhKwtRkc1RDIHTss6GfZWMNL+RKXs37WCDEpIYFwryGaziL38cgwBSPkWP5M2iEapDuI0GwaV2nkLgPbroLUjEUcUjF4MZv2+Xd7dDVBqNTjVUNXd3Q3t581eDpWEOFA/BgNvR9fItb+Cwp0qAgRYp/40Z+SoIofXSxiVn2eqYaBMHPtK5T2PkNl+ijf7PfB01YG/dONXg91lDgmeZQOmrVEILUqKeq4V/yCfEqo4/+pSQhXg8neqYaBMHPtK5T2L3fJfpoX3lZA1WDzuXsfuZmjDVkUk1RDdqIoINrPM2htM8lId6+ioR4jVINi6G9dHV3+K77yK/jKH5u90poXacwvMEl+miwum6jVMMTT8Hc8o3EU9UQDNc/82qLjjVs4GTH6KNBTqma19AI1RBJr2PHDf8vb3jLaxAEv9O6TuG6tzpHH/3xxe429VYNm4ZgbqE5EUrQpLGGEgfgUebVS9npGH10MR/EoA+n2dD1Vg1/9v6/BWzVIGMNgp9pXaew7aVw65/AyEbSBjCyERLXwvaXwOg0ZF1u5nVUDSoQQG1Y11pjDQ1WDSo7i8qUtNMD1fAytvFhbmUjI5A22Mhz+DD/zllcwjSjZAk4zoaup2qwLIvb/vX7RNLrfDPW4NeIKz+3eyW0rlMAlhPi9SwnxIuGob8LphdgZsHd1KsIpUaphmzGeayh4aqh1w6H9Xi9hjR2QrxJYAaTNHMESNLDWtIkmWOyYarBMhaLNwqJUBL8Tus6hcR/w/bPwK79hCwFu/bb7xP/bd+I+johZHqmGjyPUDICTVcNXo013MvXuJbt7GEXhCz2sItreQf3cheaUdroIEZXw1QDwJsuPZdIZHk9bYlQEvxK6zqFnd9yCUm9fbnOalYNhvEsmddQYXMMquFL6pMoXR2S+mU+QaGrqZGqQWuTb93yI86/+CwsY3H5lEU1CD6kdZ3C7lGXkNRD5WWNVA1zLo6mFec11E01jHquGp5mN1pVh6Q+lU+IVzqvoRGqIWss8YpzX8St/3o3gMxrEHxN6zqF4QGXkNS1zvUbohoMGJtsjmoo7As8ng3dbzsND1XD8U4J8bTieH3y8vuSeQ31Vg2hXDsPPfAwb7rqArQ2ZTa04Gta1ylcd5FzSOr7XwOLaWebequGWBT6epoz1mDlmqgaej0da3hnziEhntK8ld9nXh9YNmmQatDmNMcdN8AtX76TrLEks6EFX9O6TmHbGbDjQgiH8wnxwnDNG+CqV0ImB4fn3G/mdVINWmu0ojljDWawKTmUirM9PRxrONu4ijfm3sesDjGqYZYwb+QaLlC/T4AIE/oxsnppeXd1Vg1GNk42k+Vtl59HKNfumxxKfp7Z69d2r4TWdQqJX8NN90OqC8UApLrgxp/b5V1R6InB2Kx3qqEVI5QaoRqWZlzGGhqnGr6nbuOzgc+SzCfES+oUn+VGvkeCqIrTwybmONBQ1fCbXXu47ZYfoc1pJIeS4Gda1yns/AEoKKbE0eSjj35ovzcDMNDlmWoAvI1QKuB55tUILB72NELpU4WEePnBZq00Siv+rpAQT5n0qBMarhrS6QxGNi6ZVwVf07pOYff4skMooDU8eri8rIGqQeEyC9AL1ZBONUU1KDOCauv3dF7DE9ohIZ7S/E7/tqyrqVGqYTG0l3hfV1Fe+yXzqp9n9vq13SuhdZ3CcB9UtkEp2Lymum6jVMPYdPNUQyi8StdrqLAx+9jEyShdEX2E4gROqZrX0AjVEE2v4w//9ArefMX5JfuS9RoEf9K6TuG61yx3GcFy9NEfv9Ldpt6qYaAH0tnmjDVAa401NFA1vF/tLHYZAcWEeO9QH0QH+nCaDV1P1aAwuf6Dn2J+Zp7F0F5Zr0HwNa3rFLadDrdeBiNrSRsWjKyFxGXwxi1waM5WBU7UWzV0tbXWWEOjVUNqHpLTnqqG17KNv+dWTlEjqLTBKdZz+Lz+dy7iUiYYY8lQjrOh66katNbcddu9RNPrZJU3wde0rlMAIAi6E4jbrzoIkSAMtMPMEkwn3U2f7RFKmXRzIpRicXuw2WPVkAam8wnxppVJyprHzC3QxwBp0kyqiYapBmUsFPuZlazyJvic1nUKiUdh+7dg12FClgG7DtvvE4/mb+ZtEDG9VQ1eRigFzOarBo/GGu7I/TOXsZ2H2YUOWTysdnFZ4CruUN+BzCE6dRuddDdMNWgMLr3sdcRikaKNrA0t+JXWdQo7f+oQkgrccN9yndWsGgzj2TGvoQ6q4a+C/9cxId4njE8UI5Qaqhq0wb/9692cd8HLUcbyQ4GsDS34kdZ1CrsnHUJSgUcnyssaqRpmF53rQOvNa6iXapgb81w1PO6SEO8xHq2a19AI1ZAx0px5/su49d9/hMZo+CpvohqEVqZ1ncJw3CEkFdgcd67fANWggwH02ExzVEOm5Gbh4Wxo3b4GvTTvqWo4ySUh3sklCfFK5zXUWzVEczF+8dNfcfGV55PVRsNXeYPWUA1+Tvfg13avhNZ1Cte9bLnLCJa7kt5/BixknG3qrRoiIejraM5YQzbbPNXQ1uPpWMOfpP/IMSHe+6z3MpPdX27TANUQMGc55eTjuO3mu8gY6Yau8uamGjIsiGoQWoLWdQrbNsOOl0I4lE+IF4JrXgpXjUDOgrFFsNxu5qtgrCEaeXbnUDoK1XBh8B28L/tHWLqDRR3GooM/4E+4JPAeQirGWGY3WWv5Zl5v1ZDL9jAzM8/ll59HNBdr6CpvbqrBJCZjDUJL0LpOIfEE3PRbSLWjiEOqHW78rV3eGYbeCBxebKhqKJsO34oRSg1QDWpherkjx6MIpdvU7dxk/gNLZEAplnSGG/kkt/EtooEe1pgnMWMdbKhqePjhJ/jnf/4uAXPWs7WhS1WDQnk+1uDndA9+bfdKaF2nsPMXLtFHv7DfBwwYaPOHavAy82o4BtNjnqqGv+AvHRPifZSP5U0Mes1NDVcNuZxFLttDI1d5ezaMNQj+pnWdwu4Zl+ijmfIyj1RDGatdNXT3ezqvYbd+zDEh3qN6d1lXU6NUw0LoafrX9RYH4hq5ypubaihVBhKhJDST1nUKw10u0Udd1XUbpRoOz/lbNXg01jDMSY4J8TYzXDWvoRGqIZYe5N1XX8Jl776o5PiNXxu6XDXI2tBCa9C6TuG65ztHH31oxP3GWm/V0N9p3+yboRpS6dZQDR7Mhv4z9RHHhHjvV3+IFY47zoaup2pQGPzFjk+zf+8YC6GnG7rKm7tqMGReg9AStK5T2LYJbn01jMRJGzkYiUPi1fDmE2A0CWmXG2a9VUNnk8YaQqHmqIalRZib8lQ1XMxF3MK/skWdjpE22JI7hX+3vs4lXMI44ywGtONs6HqqBq01//Gd+4ilBxu+ypuTarDIyViD0BK0rlMAIAS6C+ixX3UIwgEYiMJcBqZS3qkGr8caFM0Za+josR2A12tDEyRLG1k6yBpdWJkUZmqOfvrJkuWwmmiYajDUfElCPMOTVd4qVUMAU2ZDCy1B6zqFxH7Y/nPYNUPIMmHXjP0+sd/+sfdGIGZ6qxokQqkhqiGRvZXtvINd+hGskGaXeoTt4Q+QMO+BxUN0WlF66GmYatDa5IrLzqezs71o4tXa0AXVYJFGIpSEVqB1ncLOR1xCUh9ZrtNg1eA4HX6VRyhpy7Lb7OFYw87wF+yEeIWQ1Pzs5hsCny5GKDVSNaQUfP1fv8+5r3khhlp2vF6tDa0wMAh7nkPJz+ke/NruldC6TmH3nEtI6lx5WSNVw+yScx1Yvaph8nCFAmi8atjNHseEeI/yeNW8hkaohozKctZFryTxrR+jtdnQVd5kXoPQ6rSuUxjucAlJ7XCu3wDVoMImamyhOWMNOcu5ToNVg+rtRy0tehqhNKxPdEyIN6xPKLdpkGpos6L8/AcPcN7bX0tK0fBV3qA1Mq/6eWavX9u9ElrXKVz3HOeQ1A+cBPMuX/pGqIb+tuaMNVhW81RDZ4+nYw3XLb3TMSHeh7JXMZXa7zobul6qIcAczzv9JO78p7vIqGxDV3lzUw0ZFkQ1CC1B6zqFbRtgx6kVCfFOgys32s5hLOV+M18NEUpBs6XGGhqpGrZFLmVH+t2EdR/obsL0cQ0f5PLgFUQDHRxK7SGTS5bZ1FM15OjmwMFxrnz7ebRZ0Yau8uamGuyEeLJeg9B8WtcpJMbhpglI9aAYgFQP3Dhul3eY0BeC8bS3qsEPEUpTk85jDQ1UDQn1A24K3UKKHChFSue4kZtJcDcRs5OB8AnMZg83VDXs+d0+vvov3yPAnGdrQ5eqBoWSsQahJWhdp7DzaZfoo732e0NBf9gfqsHLCKX2dhgf81Q17OSzjgnxbtCfzZsY9IaPb7hqsCyLHN3HnENptYw1CP6mdZ3C7qRL9FHFEpmiGsqph2ro6/d0XsNu/YRzQjyeKJvX0CjVMBN4mg3HrV0O2WvgKm9uqkFXJMQT1SA0C7PZJ+DKcBR2LZY7BgVsjlXXLaiGuaytGvpCdlklBdUwmQIjC90h+4ZSSWcY2iwYnYf2IHQ6fEwF1bCUsVVDbwyCgep6BdUwk7RVQ1+78zGjYXult4k55/0U6G63l+ocnbLVQzTs/HmsicNC0lYNfd22gqikoBr2H4SpaQACo4ftm61S0N8L2Qx09cDiAhzYB0tJiERsp9DWYdcd3Q+pJISjdjfU5Kg9WL24AGP7IJ2EUIXN+P58eZTh449jV+B3ZWGpSis2Z9bB3EGIdoK2YGY/KpOkNxgl3RHnkN5Db3ADwXQSZvZBNmkrh/QSZrSbfm2Sm38UnU2DGUHF+sFaglAvZOcguY9oLkmIEDd89H381/2/ImDNwNwesJK2cwitAStJp9lHLjdFLv0LAjqLUhEwF8GMg85Bbh+GTtKjoqQCASaMx+jSHQQYA5JAFNR6UFMECNNNiBwPY5FBEeHFL3kOuXwOpBwHgSQBonSwjln2EqKdMEEy7EOTRBEF+rBYxMRgif3M8hiKCBEGSTFBgCgWGZLsI5ffX44A0zyOIsBCYKw4wN/GWroYcv/eCb6hdZ3CdcfD9t8udyEVXq9ev3zTqqTDhLaArRpiAWh3uZn3RiCVs1VDPAwhhxtmwID+GMylbNXQF3V2NJEgDJgwsQimAd1R5/Z0RW0VMDYLHVGIhZzPra/T7iJKZez6psO5FVTD9DwsLEFvp/Pn0Ra1V3CbmLIH6ktm7BYpqIbH98D4NBSigLS2Hcq6NZAehUPLT78kk/Zffw4mS548lxZh7xMwdDJMHILxg8vbUkn7z8rBTIlNapHrDr2O7YOfKU5gK7z++eSFsHDQfiJfOLxsk1kkNLnIQN9JzKefJjg7tbwtm4T5JJCDpcMUPj2dTcLsU9B1MiT3Q+rQ8kdAiu2veAHWfJKI9fRy0Ju1CEtPQfRkSO8jkF220TqJyiQBC3TJuelFwtlFguYASj1ZEkC3CPpxYBitFoCnijJdk+Taa9+ERRKL5WPAIhZ76GKYJWZJ88TyYVgky9MYrCVVYqNZIsnjRDmZLLMssre4LcciORZRdJFk3C5U9pyQeexrJY5BOCqnkMlkyGQyR4x3LZ05V6tuzXoXdqNuGcb46D4yv57FPL0T6yMb0Od3ow4koduEsHPvl+4xYD6LOpiCXhfVEAAdN+3uH0OhuqpVQyaTgYgBsQD60Cy0hSBmOrepOwxLGfT+KYjHwDSc6/W22ZPiZhfR8VjxmGV1gwF0MEB2YtZWDZ2x5Vz/pfXaI7ZqODgOHTGIhp0/055OWEzCwTGIdxVVQ2ldc2KaokOwre0unUOHoc3Ml5R8xmBPdHMo14f2oQI428xU21w8dwbfPHQ1fxG/lUfNA2zOrOW6qYu4eOH3bJuFced9Te+nPVAeuVzctlRuU3imyM4/RSBooCq25SyL17/6xY770kvV7SkOd1njoKptFGNVzy5aA3ovOv+1LWxT2OMZljrk+KFl9d7yA5dsSxXGHSrKF3kSC+eLkGTGsXyBQ7TlNlCJ43fPgZX+7gt1Lcs64v3kaPe5krqZTKZYv95tWkndQrvruc/Sum71Csc8EkflFC655BKCwaA3TgF4ycHTeNsTr2ad1ctTT0zwL391Cz/7p1/b3+Vs3tZUVTfz5cVSgLSGgLLruR1fg8pYEDTKHIiVH4Q1DMOum7P/VMhwfjIv7DNjR9GoWt1AWqPTOVtdGNWTaR787//m4nddbo9vZHPokOn6OQG2c9CgS45ZVVdru56hwDTLPv87P3x9VX2FQluazNwcoaBZsQ20thxsIDM/ByZHZZNb0lhWD5BD04smfESbdHIOAkd3HL20SDanCYWCZdsChoFhBh3nS2ZS+faEHI6DVT3xDrBwOL6CdHoObVTvyzAMck43KQXpzBxZqm1sQVd9HBRk0kmyVLcz/+FUf38VWNri4osvppJGOYUHH3yQiy++2HOnUPhdr2QSWyOOX2h3PfdZWtetXqo0eKQGSq8gIcbs7CxdXV3MzMzQ2dm5oh0/YxKzsH1fdffRrYOwLX8OaQsms9DjrhoAe6whmXMfawD7hzKZsrfnxxoKnjUYLPlh5SwYT0J7CNqCzvsCe6xhesl9rKHATBLS2aqxhgsvvJA77rhj+dwKYw1dbe77ymRhYtZ9rKHAQhLmF8vHGu7/n/yjbMXjo1L2uEpysXo/ZvF5uZxIDAJAysEmUG2T6Pg12wf/GaVBK4qvtx56O9sWTgdT5fu+KwjG7FCJbPlxdP7clNO5mTEIgs4tlu0vZ1mksxki0XDVU79lhAkEAqCd26NV9blpM9+Qin3lCGEYARTlAQqWZWEZgarPBuwopix2l1Hl/rI4XwODGDnsLqNK3JK3KBTreZHL1vpT9h33EMfftYc0q90TExP09fUd8T7eutFHOw+7hKSW9N+GDBgIwkIOJjPuETnHGKHk+CSxWiOU1vZT7DICih/42n5YP+i8nzVrncvXDkK/i0282mZn3w/z4wj5Iyt7oPmGnh/ZBe1rq7uHALoHoav6OApYinU5H799EKKDVV+tgGHwha/c7qgUspF1zIRcnHHA5dyobqcCTHU8i1T/IA3DIFBhU9hXgEGCOLfTpNfxtCIMEnWwAYjSXXmyALQ5nPNqRNJc1KZ1ncLutEtIasWNUymIB6E9AKMZSNXIGXS08xqmfTSvYXA9dHdB8flaQU8XDB0HPXE4cRii+TGQaMx+v2EINg7bykAp+3XjMHTH7fDV4yq2HT8MA0OwYRjC+fJwjN3hieqEeErzaOgwDAxD7xCsGbaVAQqCUabXrGMhFoFoHHpLt8Wgd5ho5ymkuzeRMUO2xjBj0D0MkTiE4tA+jArYNlkV4hNf/RY3/PXNLBnHg5HflxGD2DDh4Fo6zROYC68lZ4SXt4WHITgE5jCovI2KMmv2kwr0gxoG8uXEQA2jVB8dbCLDEFny50aMj3/smwQYwmQ4P79BYRAjw3rmsQjQQ6hkmyJGiGHaOIkoJwGhok2MYYLECROnnWECxf1FCbCGTjYRopsMkNGQAUJ0yyCzALRy9NFwCHalqkNShx2idmBZNUxlbeXQYzr3+x9NhNJCCsaSsMZwj1AaaIPZBkQouSXEK41QGp2G3o76RCg9td92NpjLT75TCzA5DfFu2zH0xKvtu+P2n2N78s6hks64/ZdnmOPYRflcBYViWB0P7fl6sbj9h/016AbmWGCMSfqi3RjR6uOEIgPoSD+TTGEQoIcS9RDKOwcgvbDAJ//6q5x7yWtZCISJxEaq9qVQdJgbSZoDzDFDnD7Mws8nELf/8ufWCcwyw6Ky6FFbqsYcAMKsQzPANBMECXH/z3cDYBDHYLktQSBLhmlGaaObKNXnFqKPEH2kWGCJeQIl7QznnUMBjWaKp1lgutAwABaYJsYkbbhcS8E3tK5SuG5NeVhJQe9/MA5zLk/cjVAN/U2aDW1pb1XDnL2PqtvXvtGq6vXmOq6sToiH5kO8hUnmqia2FeigjV66GGeKBYe+88K+eokTJcIhxsjgfH2S84t892vfIadyHGYcC+fvTpQoaxhghmlmCjdWBzrpWp4NjXP3ocKghzWYBMmQIucy49gkWJwNPcu46+cRpo1O1jDPBMmSmc3lx1TO0UfANPtc2yP4h9Z1Cts6YccAhM18QjwTrhmAK3vsm9ho1o4GcqLBYw2O1HusIRjwdqzBzWG4ldeRbbySHVxOmF7QPYTp5Rou53LOpY0Io0yRdrmZBwjQTy8WmjEmXW/mEcIMsIZZ5pgq3BRLKCy80ma1Lc+Grulo+ggRZoxDZF1v5ubybOgaN/MIMYKEmGWKeYdzK9BOT3E2dNpluFhh0Ek/BgYzjGJR/Z3IuDgpt3LBX7SuU0gswU0ZSHWiiEOqE27M2OVtBqwJwETOW9WwmnMouUUr1YpiqhMJfs5NfJtUPtopheZGvk2CnxMmyAA9zJNsqGooHXw0CSznUPJINYAqqoZJRhuqGoI4d1+6lQv+onWdws55l+ijfLSMoaDf9Idq8CJCaXAAcAhuHGx8RMpO/q3YZWSfQ345Tm4B7Jt5nE7PVEOBTjqbohp6WNNQ1dBdiEqqOIVul2glwV+0rlPYnXWJPqr40YlqKOdYVUO8G4aH7FnRSkEsAsMb7RnQDWY3B6oT4qF5lP1lZY1SDRPmFN193Y71mqEaSscaGqEa2oizhmFbGWhFkBhrGJZBZgFoZacwbFaPeipgs0O0UINUg55Io32lGhT2rDMz/+pNLPcw6x1mBSs2U51yoRGqIZ7tZuvLnssLX+0+cWs1qoYskAVyOE5BXLUUxo/8xkrb3LpO4bp25+ijq9tqTMqqs2roCzVPNaSy3qoGy4LH9kEyjdIaFlOwey9Mzrrb1YnreItj9NEHuMD1Zl5v1fCfd/yYvY/vZcKcco1QaqRqcBoQts+t/qrBIMAoe+yBZaVJs8ghdjPPpOu5Cv6hdZ3Ctgjc2g0jJmkjAyMmJLrhbREYtWDJ5UZYb9XQHmjOWEPY9FY1HJqwq1eW72t8/v1tvJhbuYYRhjDSmhGGSHANl3MW48wx59rNUl/VcOipg8Sz3U0Za7CwPFMNUxwonGQZkxKSKtDKTgHQmOR0Gzk6yOk2tDYhqGBtAJIaJqyGqoZiREozxhrA27GGpItTcSuvO0E0HUAPmg40QQwM+ulCoRhjpqGqwbIsLMta8byGeqsGk6BnYw1+D0mVNBe1aVmnoBNZrO1p2KUJWSHYpbG2p9GJ/A+hx4BO5a1qWM0RSlGXmeJu5XUkwf+wnc+xi/1YIcUu9rOdz5HgfwBoJ0IfHQ1VDZU3itUcoSQhqUItWtYpWDszjiGp1g0lP3YPVUOR1RqhNNgPOIWk9jvvo47s5A6XkNQ7i3UaqRqShtvgbHNUQ6MjlOIuIalxCUkVaGGnwG7tEpLq8CNvlGqY8pFq6GyDdX2g8gnxlLLfxxufKn03h1xCUg9W1W2UanjNW1+LaTqnAlttqiFEjC7WkUOR1ZBD0cU62iUkVaCVncKwcg5JHXbpF2uEamgLwFiTVEPNhHgNUA37xuHgNOgAChN0wH4/6ZxDp54Ms9YxJHXYJZVzvVVDmxXlP2+/h1e95VxfqIYZxpjgoP15KNsBT3CQOYk+Emhhp2BcF3QMSVUfDKJna8Tb1ls19DdprEHjrWqYtZ9sq6OPJtz3XSeu40LHkNQ/5lwmmHe9mddTNaSSKb7/9buaNhs6Rcoz1TBfkSG1wLhEHwm0sFNQ20xyO0LkwnZ3Ri6syF0TwrjSBBP0qEZnXW6Yq2GswTS8HWtIuhzDg+ijbfweO3i9neJZ9xAmzjVcyGW8lA4ijDJLyuVmXi/VsJwQL1q3zKtHoxrChD1TDWkXW7dywV+0rFNIJ2DhJpOFVJQ5YiykoizcaJJOgIopWANM0VDVUDbzcbVHKEVdlib0JPpoFzfx04qEeD8hwS5CmAzQySLphqoGwzAwDPvn0IwcSoBnYw0hlygjt/LVhsxork3LOoXkThyjj5ZusN8qQ6HWKH+oBi8ilAb7AKfoI+flHuvJTn7gcKkVN/ADyP/fQ5tnqqFAPddraKWxhj6X6KM+iT4SaGGnYO3GMfoo92h5UUNVg9vNfDWqhngHDK9HR0P5hHhhGF5vlzeY3Rx2uNSaRzlcVtYo1TBpztM70OdYbzVmXu0gzgaGCekoSivCxNjAMB0SfSTQwk7BGMYx+iiwubpuo1SDmrRQCzWigBqpGtxoqGpQKAJQ/PMqId4ah0ut2MyaqrqNUA3xbDubf+9UXnzuy3yjGrLkyCmKSfFcvr2rEpnRXJuWdQrR63CMPgp/0P1eXnfVsKaJs6FTOW9VAxoeG4VkBqWx1cPuUZicd7erE9fxmmKXESxHH72fV5BzuV3VWzX89K4f89ivdjNpzjdlvYaca0K8+quGAAH2s4cUSbTSpFhkL7uZkZBUgRZ2CqFt0HYrBEYgbaQJjEBbAkKXgh4D7XKPq7tqiDVprCEc8Has4aB986oOSZ1yrl9HtrGFW7mcEdZipC1GWEuCy7mCM5hkkVnXdND1VQ3jB8aIZ9ubMtag0Z6phjGXhHiHJSRVoIWdAkAamNEwlX9Na1AmGAOgU2CNe6gavM6hBN6ONbiGpNZI2FdXImh6gQE0vWgiGCjW0E4Ag1HmGqoaChEpzVrlzcT0bKzBLfQ0JSGpAi3sFOYTMLod0rsgaIVI77Lfzyfs7UY3qG6PVcNqjlByDUl1Ka8jCR5jO3ewi3GsUIBdjLOdO0jwGABthFhDe0NVQ2U/82qOUHILPQ37JCRVqE3LOoUpl5DUqRuW6/hGNXgRoTTYAziFpPY476OO7OQ+p0vNDfysWKeRqmHRcJ6gt1rXhu53CUntl5BUgRZ2ChmXkNTMo9V1G6YaJn2kGjqisK67IiFeD8Tbne3ryG6mnHMfOgx8NkI1AJxz6esJhpxV0WpTDWGixPMJ8TLaTogXZx2dEpIq0MJOIegSkhocdq7fENXQoWCsSarBzWk1SjXsn4GDC6BNFEHQJhych0n3Gbj1Ypgex9yHJ+OsUuqtGmJWiHv+/Xucvf21vlANk4wzykGsfEI8C80oB5mW6COBFnYKPS4hqV1XQ879N1RX1aBN0P1Gc8YawFvVMGvPjaiOPqrxYdeJ63ip06XmGl7AOEn37KZ1VA3ZTJYffOPbAE2ZDZ0i5ZlqmGGqcAJlHPRJ9JGkuahNyzqF9m3QvgOssD271QpD+zXQeQWoEGRHQbt1wa+GsQZTeTvW0MToo22czA5eSpge0N2E6eEaXsrbOZUuwoyyyJLL028jVEOjV3mrJEKYMGHPVINblJFEHwnQwk5hKgF7b4KZFEyjmEnB3hvtciMKgX6wpr1TDas+Qqmp0UdPchOPkIJ8Qjy4kUdI8CRBDNbSxhJZz1RDM3IoAZ6NNbhFGUUk+kighZ3CAZfoowOFhHgKAn2NVQ2O0+FXa4TSoD3gWh191OW8nzqyk/91iT76ZbFON5GGqganLgUv1oauxIuxhnUu0UdrfRJ9JGkuatOyTmHJJfpoqSL6SFRDBceqGuIxGO6DqIlWQCxov4/HnO3ryG5mXaKPyi9oo1TDpJmkf4M3q7y1QoRSN3E2MUwEOyFehBibGKZboo8EWtgpRFyijyJOCfEapRqmQc81aazBjYaqBrAT4Zl4mxCv0zH6aDPOKqXeqiGejbLptJN46flne7LKW2uohlwxGV4OfyXEE2rTsk5hvUv00cAH3G/mdVcNfQoCTVINKctb1aCAx6chmcsnxMvC7imYbPzg43U8zzH66P2cStbldlVv1XD/3T/h4QceYtJMNmWsoXZCvPqqBpMgT7CHpXxCvCSL7GE3kxKSKtDCTqFnG5x4K0RHIGOkiY7AiQnofTtkxyDnMl7nxViD8wnXWTWEDW/HGg7a2VCrQ1LnnOvXkW1s5Fb+DyPEMdI5RoiT4P9wJSczRZoZ3JcEradqmD48STwbbfgqb6UUVIMGz1TDAfYXTrKi3B8hqUJtWtYpgHtCvOAA6AxkDnuoGrweawBvxxqSLk7FrbzuhNB0Aj1oOtGEUCjWECGIwSjJhqqG0oR4zYhQMgl4Ntbglj3VrVzwFy3rFEYT8NB2mN8FphVifpf9fjSfEM/sArPHJ6rBiwilqOls41ZeRxIcYDsPsItZrJDJLmbZzgMk8imeY5j0E2moaqiMSPFqbehSvBprcAs9lZBUAVrYKexxCUndU5EQzxeqwYsIpUF72c3qkNTGL8e5k9+6hKT+tlinkaphwXC+SbfyvIZnohrWu4SkbvBJSKpQm5Z1CosuIamLDgnxGqUachMay+XGuupUQ3sI1rVXJMRrh3jjnx53M+8Sklq96lsjVIOB4rzLtxNrcw6/XW2qIUKEAdajCWBphSbAAOvp8UlIqqS5qE3LOoWYS0hqrEZCvLqrhi7Q401SDbUS4jVCNRxchINLoAMoTNAB+/2kc8ROPRmm3SUhnnOG1nqrhqhl8oNv3MnLXv+qpqkGNxqhGiaZ4iCH7M9D2UufHuSQRB8JQAs7hRNdQlKHrobMlLtdPVWDYSoC/ao5Yw0Kb1XDjP3UXR191PgsqddxiktCvJMZJ+Wep6iOqiGTTvODb9yJgWr4Km8FSlVDioxnqqF486+42PsLUUmrHJnRXJuWdQoD22B9RUK89dfAhivsp/3UIbDckn6uhrGGgPJ2rCHpcgwPoo+2sZ4dnJpPiNeTT4h3Km/nOLoJMkaKZI04/nqrhmbkUAoT9GysYcmlXUmXcsFftKxTeCoBv7jJvoeNohhLwS9utMsDEQgNQHbGO9Ww6iOUogFnG0+ij8a5iUOkUPmEeIobOUSCcUwMBoiQxmqoaijtZ/ZybehSvBpriBBxtIm6lAv+omWdwq9coo9+VZIQL9TnE9XgRYTSYBvgFH3U5ryfOrKTp1yij54q1uki2FDV4NSl8GzPvOqmGgbZYFeoij7a4LgfwV+0rFOYcYk+mqmIPhLVUMGxqoZ4BNbFKqKPYhAPu593ndjNokv0UfmFapRqmDQzrN94nGOdZqiGRkcoxYmzlnVAAK0NIMBa1hH3SfSRUJuWdQpdLtFHXS4J8RqiGmYgN+t+jg1VDW40SjU8sQAH0xXRR2mYdL+p1othYi4J8ZxDROutGnqzIdZtOo5XvOHcVbteQ6lq2MOTHGSs6Pw1cJAxJqnxVCX4hpZ1CiMu0UfP+QBol3tc3VVDL6hgk1RDSnurGmbtG1h19JEXCfGGHKOP/ogNZFxumPVWDf9zz3089J/3M2lmPFvlrVQ1ZGs4t3qrhnkWCjsvYx8HHW0Ef9GyTmFoG5x5K/SMQM5I0zMCZyXgxMtg6TBkF5ztVs1YQ1h5O9aw5FLuFpVUR7bRx62cyghtGOksI7SR4FSuYoAZcky73KShvqphdmqa3myoKau84aFqWLLXuKtCoo8EaGGnAJABZrWdEG9W5xPiBSA6YKuFpbHGqoZikjQ/jDW4Rh+5lNedMJo40I8mjiaMQtFHkDCKQ6QbqhpKB5obvcqbWxu8GmtwizLyS/SRzGiuTcs6hccTcNd2GN8FASvE+C77/eP5hHjBDgj3+kQ1eBGhNGins6iOPmp8mosEc2znALtIY4WC7CLNdg6QyM/0jRJggKCnqmE1rw09yDr7nwqzYrnga1rWKdzvEpJ6f2lCPA9VQ/GYq1U1xEMw3I6OGvnlOAMw3G6XN5idjLuEpE4U6zRSNcwb7l1kzVANjY5QitPDMCcQ1RGUVsSIMswJxOlx/RwE/9CyTmHKJSR1yiEhXqNUQ3ZC4TD0CqxW1aDsyCOC2EtyepMKYDcZl5DU6oHhRqgGUyvOu/wtRNud52SsTtWg7Kcqj5debQUkzUVtWtYp9LiEpPa4JcRrhGrohux4c1RDjftdY1TDoTTsXoKkzi/Hadnva60XXSeGCbokxAs61q+3aohog+9+7RZedM7ZTVMNbjRCNUwzx26eIkkKrTSLLLGbp5hk2vU8BP/Qsk7hRS4hqc/7ECxNut9Y664a1jRprEF5rBpm7G3VIamNn6dwHX2OIan/H70cJofllqeojqrBsizuufVOTK2aMtaQIuOZapgo3PyrQlJHHesL/qJlncJJ22DtG+wHZo0mi/3+1Mvhf38AV58Gl0TgQ1vh/sSy3X8l4N3Ph20b4fdfDP/xFVs1/CgBb9kKL47arz8qyaF019fh3NNhcxReuxW+l9/f7bcpXvL8AH1r4aWvgsRXllVD4nZ43ksg1me/3naHrRpuuwdG/g9ET4Kt50Diu8vnlvghPPet0HY+PPcS+GbCvpcn/hO2vgOi59ivif/EVvRrIHEPbP1jTfQy2HoNJB7I7+t/YetfQvQ6g61/r0jcu6waEr+BrZ+G6HX2a+IRWzUknlRs/ZIm+knN1n+CxGMl53bYYOveGNHftbN1b4zEvJ3zKDFtsPW/IPo92PpfkDhUYjMJW38F0fvt10Q++WZiDrY+CdHH7NdESWboRAa2zkF0xn5NZGAbHbyBDcBG0CcCG7mIDVxKJ3EMDpNjweVG2AjV0OhV3ioJYRIm6NlYQ9I1JNW5XPAXSq8gTml2dpauri4OHDhAZ2enF+fFDz8S5BefDNl5aVDF1/UXZPjht4MopdFaFV//4OtLZIC/ujRSte38d2f52hfMqvKPfn2JNPABB5vLPpDmrz8Zqir/ypdSWBhc9v7qc/ijP0zzya9V23z975YgBJdeW32cD7w5yyd/WH1uzw//JR/68Ie49HMONhek+eR9oZJPxX791zemwIS3fT9cte0DL0vzyUeqbb5+zhJE4NIHIlXb/rg3xV9b1fv6+qn59jxdbfOBtWk+mXY4TnwJwnCpVW1zQSjJt6Mh20MqVXz9QDrJRzP24+yCAWlD0Z3Vrr3fGs1MQBNA0ZFz7z/NoZk2Ldpyiog2WFhY4OSTTwbgscceo63NHltYUhYLgRzdWZNAjT73uUCWHJqunIlyqWehmTFThKwAbVZ1t9ib3/xmbrnlFjIqx2wgRUcuTEi7hwMvGmmWjAzd2RiGyzE1mtlAEgV05KLFc3ss8jRLRrpcKWiIWCFOXjre9Zj1ptBmr8nlbLUYCHgVbl1Os9o9NTXFcccdx8zMTM37+FE5ha6uLpRSJfH79req9H8oH9CwLMuxntYaw1gWKqWnobXm92cPESJS9iOzFYNmN6DKRI7FYvBRpnI5otapZds0ObKkmSMMFeVp42FmURgVNmCRIcVkhQ3kUMbD5NoDZK1TqrZhpLE6wqDK9xXUvyXXnsMKnla+Tds29FQcR+dg4dcY/QZWR6WNBSpl21Tsy5h+GLMnSLp7uHyblQPSdh4jo3xf5uFHsOIaa8OpZTYKTTgASx26al/G3oehS2FtPLV8f1YOrDT0havKjccfhl6FdYqDTQDoyDuE4rlpWFqga91Q8TsTbWvjzIsv5OH//gVPPfLbfLXq796GEzby3Fe+jHtvu5P56ZmqeoXv3nNf8RJ6+vu4N/Ft2tvtBX1mZmbK6gUCAc7afgETB0f51U8fKH5PK/fXFe/hFW84l1/++OccePJp13onnn4Km59/Gj9OfI/kYrJYvrCwUHRGWmtefO4rMUMmP/32Pa6/JzNo8n/e+DqeenQPv/2f37j+nnrXreElr305933nP5k4NM7LL3wlf/a1j2LlLIyAUXzdeemH+dldP6k679Lzd2pTZb1C+ZHuEfPz87S3tx/zPaLSpvL4bvU6OztRSjE7O1v3Njldp0qbxcXF4vetXm0qPb5bvY6ODvbv319fpxAIBDwbtb82m3Z86tJoHnEot1hiCjAcJuBoNFOONkmmUCgXmzHH4yfJtClQzja62+Hz0UvQg6MNaIg72FhJGFB2H9dKbbJJ6FFgHo3NEgwAQRebHgebdP444aM4TioJ/QoiLjZdDl0rWmOGqudJdPR0E45GmTh4yHVCjlKK+Np+spksM+MTjnUAzGCQ3rX9LMzOsbSwSDbr3BUUa2+jo6eb8YOj5FzqAHT3xQmYJhOHxlzrKKXoW9/P0uISc1O208rlclVPrsFQiPjaPqYPT5JKus82bu/qINoRY+LgYayce96s+EAvWmumxiZ5z8fezxv/4BJCkTDppSW++Zl/4fN/+neuto3Aqc1eYJomSikymcYHUTjRrHYHAgFSqVR9nYKX3Uc39sbQKaqUQk7BY4DWpR5aM3i6xYylePphVbXNCMN4qtrmhNMsZoDHfmM42hx0sDn1dItMFH7zSLVNKApL4Wqb0zdb6DbFb56oPrdwBFKxapt2nmDo94b4zf7q44RDkGqD0o4UpTSnr7XQnfCbMaN8G3mbdqrKT++10D3wm3kHmwCkOh1s2ix0F/xmycHGdLExLXQv/IZqGwyNbreqlEKEHOOLzjfgHDBjKqI5TbTGNzilNPMBTVdWYbp0sywsLPDmd15JT38fn//4X9Pe5hyaqtFMB3IEtaLdcv9RZ7GYMbO050zC2n3YLmlkSRpZurJh3vbmtzh2KWg0c4E0Gk1nLlyze2raXCRiBYlZ7nNL0irLWHCGqeD8ciBH/vX4pTV05ZyTEDaCZnWjFBy/aTZ+rRAnmtXuyclJjj/++CM6haP6VNra2ooSt9G88I/ggZsqv7eKDa+C3T8s63pGa8Xrrw6gg/Cxt1dve+074WufrS6/9D0BdBt88KrqbW9+J3zys5T059vlf/TBAMF2ePs7qm3edQl8+pvV5R98V4BIB1zyJw422+Ez36kuP8n4BjvO/1Mu+YKDzavhMz8rPbf8WMOrAsTa4G23VNu8e6vFp/YYpfcAewzgjACxdnjbT6nq6//D7gw3WcFqmxMCtEXhrY9Tte3/GYBPJ6vLP9AboD0Kb3HYdl44y3eUUVaKUlyGhrYYbS43wk5gFotFNL0Yjn3rbUAPmolwFo2i2+Ur/9BPfkZ7Vyeprgid4QhRnG/67cAiWebI0EsY0yVWowuYZokkmt6KbtDSc7PQTIQX0AHl+ttqB9JkmWSBHmKEXUJ1O2hnniUWSNFHB4bDubUBTzNuvymcUv51PDLLetY47rsRBAIBz+4npRQUQjDo/Dk2mma1e2lpZbmtWjb66Pwb4YU7wIjYT0tGBF50Dbz7u/Duz8DgqXaPx/Ej8McJOPtKeMmFsOPLsGkLBMMw9Bz481vg/Z+C678EJ54OoQicPAJ/nYCL3geveh3c9FnYvMXuDTllBD6fgI9+Cj7/j1lOPc1+mj/tVPj6V+Hyq+D8c+HLn4Mtp0EkbL9+8+vwNx+Hm3fC6Sfb5SPPgcQ/wFVvgfNeAV/eCSMnQyQEWzbBrX8N//dq+NIOOH2TXT5yAiT+Agbbf84Fz4GvXgZbjoNIEEaOh8TV8LeXwBcvgdPXKSKmZqQfbn275h0vhdeeDF/ZBiMDEDHt18QlcNNrFV99SY7TezWRAIysgcSFcNVpcO5a+ObaFCMhTURpRkKaxECKG7uzfLM9xekdEDFgpAMSz4erBuE1XXDzJhiJQUTZr4lhuGkDfHENbAnly0OQWAdXdcKrA3BzBEYMiGC/JmKQCAb5fStHRFt5hWBxDTk+T5jDaPZiuYaldmLULUJpfmaW3myg4au8lVKIUFLg2WzoJZdzTtZoi+Afjqr76Eiyo1FceOGF3HHHHWVl82OQmoXujRAoefizcjA3AeEYhNvsOQ1KQbgHkvN2d3hnX/lYZzYN009BpAfa+5bLM5kMC3OQywXp6QWdhuw0BHtBK5iYgPYOiFUo7pmDkEva51Z2nCxMTEFHO0QjYE0AQQh0wcwcZLLQ222fb6HN2RTM77fnXkS7yo8zvQBZC3rbsecrzAG9kFWKiQXojtrOpJS5UQty0L5WoYySgbGHllDJ6sgeHVNMb45gYWe8KO3hSVv23LaeIIRLx681TOWnA/QEym1S+W3xAITKe4uYBN7+hgv5zu13lNnMoBnFYgOGq2oAWzWkaqgGsB8wJshilqiGhYUFBgcHAdi3bx9tbW1ksZggTSdBV9UAK1MNYKuGbA3VcOGFF/KtO25nggXCmHTWSE63EtUAMM8Siw6q4VfsYdEh/DRGmBFOdN1fvXH6XXtBs5VCs9o9MTFBX1/fEe/jLasUjkR7v33TnX7SdhAFjAB09ds3mdnDtjMItsHiKITD0NkLM4chWTKxzQxB38m2Q5nYA7n8Q51SivZORXccJg9DKrc8G9qag/4B+0Y/fhiskge8rnXQsR6mfgcLJbOmTRMG1tg3//FJMHqXZ0N3RqG7A8YmoXRM0QxD9wn2GPLM0+XH6W6DrhiMzsCSqYqzoc0FzdpOWMrA+Dxl89o6BgwiccXsXovUwvIG47jlbiJKXtVgkJ4wdARhdMn+DAqEDBgI5VMopZePoxTETXve3GjGdh4FwgoGAjBvwWSu3KZX2YFIo9rOiFv8PFGchNFQ1WBZFlbJh+vV2tCleJVDabDQRVRhNuhh11EzkTQXtXnWOgWwFULvSfb/E48v38wBoh3Q0Qtz45DJQGwA0nOQnoHufjuyc3qs/CbbOQBdx8HUEzA/XnKcAPQN2E5jchzM+PJs6PYo9PTYjmGxJB1GMGKfW3YJJn9X4TQ6oKcLxsZhieXZ0GoBBnohnbH/ym7ma6FtAGafhORMyXECsLYbUhmYWFDQp4o5lLpCmq4ojM7ZDmL53BRdQwHS85q5Axba0vaj+3AIorYKykYU6RNDdjl5BxCBxSxMpCocQBDaTRhNlydeDeczaMxbMJmtsAnknUau3AEY2EFXc8CUXrYxUGzEoBPF41gsuNwIAygGMMnBimdDzwWc12iG1Zl5NU4nwwwSJZRPiBdmmEHieN8LILQez2qnUKBRqmHyiXJH096JZ6ohaDZDNSjs2AMTUwVI5xQTyfKbuZeqIYY3qiFkwflXXkpHd5djvdWpGpavtd8S4gm1WRVOARqjGjo3wPTTzVENZJdVw/hU41WDNWrB7hwkQWlQSWh/MkfnvMXoIiyVfJ6NVA2lt76w8kY1hLXiO//0Lzz/7FcwF3AfYmukanCjEaphliS7OUiSdD4hXprdHGSSOUc7wV+sGqdQoN6qofeE6rEGaLxqwPB2rCE6bxUDQksJHswxEINkFk9UQ043RzVorfnxbd8mZNHwVd5KKaiGFDnPVMMEs/Y/FRd7X8n6FYJ/WXVOAVbHWIOF81hDw1RD0qUDIZl3ABHoCNFw1RBUzmMNXqqGZqzyFibg2VhD0kVJuJUL/mJVOoUCz1Q1LJXczN0ilKAxqsHSHkcoOURAasAqKQ8F8FQ1eDnWULpur5drQ5fi1VhD1CWMNUrjV9kTWp9V7RTgmakGK6eZOaybohqC5pEjlOqpGqZ77Sij0tuaAhYHAkwsVjiABqqG4rFrRCjVWzVowDCMsuRrsHrXhh6k165QFZIad23jaqL0AcBPrLTNq94pFDhW1dAeX/m8BvA2QqmeqqFn0CC5xl6fWWOHpep1Bu1rDTrDMDpf4QAapBpSlveqYcpUbDz1OY51VqNq6KGddcRRmKADKEzWESdOh+v5CP7BN04BjkE1zENmtjljDaVOfSXzGp6xavidReSwAm0AAbQOwEGFntS2TQckMzRcNYSNo5vXUA/VEM9q2js7eNWbt7vUWl2q4Xcc5iCz9t6UQgMHmWUSl6UKBV/hK6dQYMWqoVsRjKljmg0Nz0w1ZBY9Vg35aMRCCobi7OZ9yzeinigNVw3QnLGGXT+7n/vu+h5TpvJslbdS1eC2L6i/apgvpLioij6aqjZYhciM5tr40inAylTD/IR9E25GhFKo7dhnQx+LatAOD5gK0MmKeQ0eqoajnQ39TFXD4vw88aw+qtnQ9VINBt6tDe3mWCT6SAAfO4UCtVRD55r65FCC1h9rIFI17giAijrPa2iUashYrRuhVPa51Fk1BFCejTW4Rx81J0Gc0Fr43inAEVRD+7NjXsMzVQ3qOJXvMqoMSVF0x3CeDd0A1RBQzVENlREpx5JD6dky1jBIj/1PVfRRj+v5C/5BnEIJXmRehZWphnTaW9Wg4gqGVT4hniYThvQJyi4n7wBcZkPXUzUYyvt5DYeCAdd+5maohkZHKMVpY5gBogRRGmKEGGaAON4v/CK0HuIUKihVDZO/a95s6GDQe9WgUVgYWBgYAYN0VjE+V27jpWrwaqyhPWdx7T9+geM3b67+QrBaVYPC/vkH8q/+G3gVnBGn4EJ7P3Qdbz9JN0M16Ky3Yw3WOFi77YFltIJFiD4NXUt2hFKy5IG1karBKtmXV7Oh2y3NX/2/7+HcS97GoWCgKWMNbjRCNcyTYjeHSZLNX+oMuznMJIuOdoK/EKdQg4AJ8RPs/73OoaQC3o41hPNOrHJVMHVwOULJC9WQ081RDVpr/vG662nPWXVfr2ElqiGF5ZlqGKd4scvYx7TreQr+QZxCDQqDj80Ya7C0xxFKbtmb8+Wl8xoaqRqChvc5lDKo4phCu6WbEqEUxvBsrMHvCfEkzUVtxCmskGOZDZ1+BrOhtfY2QslpSWBNeUK80nkNq2msYdEweNE55xTLG7nKWyuMNUhIqlALcQpHycpnQ0MwduyqwTS9ndcw123XLb15KCC1BsZnKhxAA1VD8djPMIfS0aiGLivHEw8/zAVXvYNMSZ9KK89reCaqYZBue2NVSGq3634E/yBOoQZuYYpeqwYv5jX0DEGqN58ID41WQN7JdLfD2BQkS8ZDG6UaUrnmqIbRvXu588tfYtEwPFsbulmqoYco6+hGEQQdRBFkHd3Eibmez2pC0lzURpzCM6CRqqH0JuvFbOj07yAwYY9l5FBkNWQPQm4SzAAMxPMOoMGqIRxownoNJde0y8o962ZDH61q+B0zHGQRjconxFMcZJHJGsuCCv5BnMIzpFGqIbPorWrQc4Ut5QnxsvuWbbrbG68awPuxhkll0tPfXxyI82qVt1LVkHHNz1p/1bBQGFCuij6adz0HwT+IU6gT9VYNoTZvcyhZLgnxrGTFvAYPVYNXq7zFdZbn/N4LeMm5ryvemr3OoWTg3drQSdeEeO7dWYJ/EKdQR5oy1nC4hmoocTSVqiFXcjPt6gDlkhDPiDrPa2iUakjnnMcaGqoagPu+exd7frOLSWU2ZW1ou543Yw1RTEc7t3LBX4hTaADPWDWUqPjSsYZxJ9XQW0M15OCwi2qYfgIWJpfLg8cVuozKb1rmoO00HGdDN0A1mEZzVIPWmrF9+4jr7KrJvOqmGgZpzze6vP6grLwmIE6hYTwj1aAhk6pWDd3HoBritVRDalk1BOIQHLZTZaM0uRBYG+1yyHc1ucyGrqdqMJT38xpm9HJCPIV3a0M3K0IpTpRhuokSyCfEMxmmh7jTZBXBd4hTaDDHqhrMkPeqQQM5IAsoEzI5ODxRfjP3UjV4NdYQw+KCy66ib+3aos1qW6+hWjUUkuGZ+Vf/hWgKzohTqEG9psMfi2rQ2WXV4DTWUHfVMAVLJQnxrEUI7IVOy45QWiyJVmykaihtp1ezoYNKc9c/38zw1uczowOerQ1dqhrcvmWNUA2LZNnNLEmsfEK8HLuZZbJGYr7VhKS5qI04BQ85GtWgAt6ONQSLjqL8iTF3cDlCyQvVkNPNUQ0AP7v7u8SwGM16v8pbGu2ZajhcWHCnKiR1obqy4DvEKdSgETMfV6oatOU81tAo1WC5zFsqlJfOa2ikaggGvM+hlNaq+PQYVJoB09u1oQMowijPxhrclIRb+WpDZjTXRpxCkziiasDbCCXlkhCPcMlxTG9Vg1djDUva4KXnnF8sL4tQaoJqaPRYQ5SAo41bueAvxCk0kVqqIWAeOUKpnqphqRiNuHzzUECuDw6Pu8+GrrdqKMWrzKudRo5H/vdBzr/0StJ6+WkqbNAU1dDoCKXBwrKbVSGpba77EfyDOIUWoBXmNfSeALlesFhOiGeug65B6Om2HUNpCo1GqYZUpjmqYerwGHd9/WaWtOE+r2GVqIYeQqwjhiIA2kARYB0x4qWyUPAt4hRahErVUHrzW8m8hmeqGhb3ABP5NRRQWBpSByEzmXcA/XkH0GDVEA42b70GsFWD67yGVaIanmCBg6TsvSmFBg6SYrJGMj3BP4hTaDEKqiGz6K1qyBXtlrtPNLC0d9mmq9Nb1eDVWMNkzqRv7fpiyN6KZkPXWTUk0Z6phvnCgHJV9JFkSRXEKbQkAdNOiAfHNhv6WFRDziUhXm6pfF6Dl6rBq1Xe4oEsJ55yOi8/9/Urnw1dZ9Vgeqga/B59JNRGnEIL4+VYQ8AlIV4g6jIbukGqIZ1pjmq4/967efh/H2AyZx59DqU6qIYgeDbWINFHQi3EKdSgFWY+PtMcSitVDRGXhHiRQejsdJ4N3QjVEDSboxqUUkyPHyYeyB59DqVn2VjDIFH7n6roo6jjflYbrfC7bgYyo3mV0WjVEIxDbBiMqAalsUIQON4uB9s5ueZQqqNqUMr7sYaZzPIT8jPOvHqMqqH0Wb7REUpxQgzTTlQb+YR4AYZpJ07IcR+CvxCn8Cyi0arBAjIo0oA2IWfBRKWNh6rBq7GGWCDHBW+5iv71xxVtjjnz6jGqhixeqwZl51KRhHhCBeIUatCq0+EboRoyszC7O5/WQityi5DeBzFlRyiVOoBGqoZcyb68ilAKGnDnN77M0EmbmcmUJ8TzSjWE8G5eQ5Icu0mSzM9HWcRiN0kmyTjarTZa9XfdaCTNxSqn3qpBO4SkAiQPLkcoeaEaLKs5qkFrzf333k0skKvfeg0tOtZw2HWNZn9kSRVqI07hWU69VEPOJUS9UF46r6GRqiFoej+vIZ1TxafHoNGgVd6OoBoKeDEbOumiJNzKBX8hTmEVUA/VEHBZdMsoyXxQOq9hNY01LOUMXnnOhUV53ZBV3o6gGlLaO9UQdfnZu5UL/kK+BauIZ6IatENCPABzDUxWOIBGqoZSvJoN3RnK8dCDP+G8N15BOrfcp9KwtaEdVENYeZdDabCQ46gqJFVyHwniFFYdx6oa4pvA7LXvExoNCiLroGsDdPXC9GFIljqABqmGVLo5qmFmapK7/v1mlnJG49eGdlAN4N1YQzcm64igCIIOogiyjghxgo72gr8Qp7BKOVrVMPM7WJqw12jOochqmD8IyUnbAcQH7Jt4o1VDONTcHEqdoZxna0M3K/Pqk2Q4iIVG5RPiKQ5iMSlpLgTEKaxqjkY1ZFyij+ZLEuK1dXirGrwaa5hMmqwb3FhuU8f1GlaiGjLaeayhEaphvrCtKvrIPcOq4B/EKdRgtUyHX4lqyDokxAO7vHReg5eqwavMq72xLIPHn8CZ51zU8FXe3FRDAO9UQ9LFYbiVrzZWy+/6aJE0F0IZR1INpkv0kRl1ntfQKNWQTjdHNfz3z+7hof/+CZNJ07O1oUtVg6G8m9cQdZm97FYu+AtxCj7DTTW0FzM8lN9AOgYh1uE8G7oRqiEYbJ5qmJmaoDeW9Wxt6GaNNQxi2hWqoo9MBEGcQg1W63R4J9UQjUP3sJ0qG6VRIWg7HiL5hHhGAHoGGq8alPJ+rGE6GUBrjZU/mFdrQ5eqBqtUATR4NnScAMMEyV9qYiiGCRL3Sers1fq7PhIrbbM8GviY9n7bGUw/CeFOyCQhvWTfUFQGUgswMwYdfbAwDRP77DrBCCzN2+MRmTSM74N0EkJR28EkF6C7D+amYWwfpJIQisDiPPQOQDoFB/Pl4ShkM7CwCL29sHnzS9j1K1hKQjgC83MwMABLS7DvgK0GohHbASwsQl8cpqZh30H7ph8Jw+w8rFtjv983ar9Gw7ZNNAK9nTA1B/sO20ohZAb5o//vb/nm1z/NTDLAnnH7xh8N2oPw0TD0tsHUIuybslVBxITpCGzohsU07Ju1bSImpGPQlk84un/erh81YaDNVg09IVjIwr5FSOYgEoCTn/8SWzUA+5cgaUHUgIGwrQDieZWwL21viyhIBaEjYF+v/TlIaojmFcWoAXFgHthnQRJFBIO9hqZNaXLAEiE0kMR2JnHvv4JCCyJOwecUVMPYI5CesW9KCoXWkJqwtx9egJnRZZt00v6zcjBTMuEstWj/rTsRDj5pdykVtyXtPysHkyU2S4v239CJ8NST8Kbt15LMdx0tJe2/TBYmp5dtFpOwuB9O3ARPPA1jJftLLtl/2SxMzpXYLNl/Jx4HTxyEsZL9pTIG573hHbR3dPP01PLgymIaFifhhAH43TgcLuk6S2bsv6wFUyUKJJmF5Cz0t8NYSXfWYhaemIGTu2E0CQdKtiVz8JY/vJbpNIyVqIxFC55IwskxOJix/4o22nZouSCMlSiGRQ1PZOFkEw4acLBkWxJF0lJkjRzzygB0PiRVcxAFWAxJ54HvOSqnkMlkyGQyR5QhpaPcteoeTb1MJrOiuqX7fabnmc1mV1z3aOsdqa7W2vH49frsK+umZ82iQ4DlBXcWxyBTvE+W7k8zP+lcPnFAkyuWlW+bdbEZPQAZwLI0hmGUbZuZKlQvtzlwEJZ7PMq3Tc2Q7xytsBlzslFYVo4Xvfw8Cm6x1ObgpIaAc3umFwv7Ky8/vOBcvm+Okl/d8jbLsjicUs42S+7HP5wp7K/CJltynNLvgdbMWwYYuqRcgdYcAjaURiAUTRrz3bMs64j3k3r9nkop/K601g37PdWqW2h3PfdZWtetXun9pBZKryBOaXZ2lq6uLs455xyCwaDnTuHBBx/kjDPOWFHd0v0+0/Ms3Y/XTuHBBx/kBS94geO5HOs+a9X9+w/f6foZzOYyBM3qBVi01lgONplsmiy42uRq2JguNtp0cNqZNATADDrbqKCLjVnDJnQMNg7HOeLxQ0dxzuljtAm62KDtpRQc9vWxC9/gWA71/+4VvuNeO4VG7PNo6j7wwAPF37aXTiGdTnP33XczMzNDZ2en636OyikcaWeN4sILL+SOO+7w/LgFz2qa3veyed3mfffnxxJKyjT2w2Q2CulFByMFOYdvTzhmz4xecrHJOthEY7ZSWJi3KpQCKANyDt/zWBQw7G6hqsMYoB16QmIRIACLFVmiLStHJpMm3B6hclZXLJS3cVhuQCnQDjdYt/KYCZiwWDF52LIsAgHD2cbI2zgkMVWAdvh6xlTepnoToCFQrYgU8CIPu4/8+LuG5rV7cnKS3t7eI97HpQNRAKBt7XKXESx3orSthd5BZ5vutc7lfYPQ72LT62KzdhA2DFLlEMAeaHZicAMMrnPZ3xoXmwEYrNqmMYwA3/r3L1A1zRcY7IXBHpfjuPy21ra7HL8DBmPV5YZhsNZlrshgBAZdVspc61I+aMKgy6+7x8hf3eLzoP3e5dIIPkOcQg38NPOxZwja1uWfcNEoZb/vGYKOOKwbhlDM3h6K2e/7h2DDsK0MlLJfNwxDZxy64nD8METy2yIx+/36IdhUUb5pGLrjEI/Dv9/6caL5bdEYnDQMxw/B8Im2MlDKfh0+yQ5pjffA8KaKbSfA0AYYHrKVgVL26/AQxLsg3gnDgxAL588haPEX176dm/9+J8f3LBEL5W1CMLwO4u0Qb4Phfsq39cNQHIZ7IRa03UksaL8f6obhblsZKOzX4R6IRyAehuEOiAXy2wLwzc98jKE2GI7ZykBhvw7HIB6y5y8MRyq2RWAoBMNBWxko7NfhoB2tFFcwbNhzGBT267ABm5XBurwyQNuv69C+GWT20++6lJW2WaKPhCI9Q9C+3pbWwWB5xsyOuP1XSWfc/nOiK+8cKumO239OPProz9gyUl0ezzsNJwrOoaq8y/5ztOm0/wAWFpa47z/vss85mmN9n4tNm/1XVR6z/6rKo/af477C9l+B3b/4uV0esv8cbUz7r6o8YP852ijnbUMYrM/a/WGV11rwN/54NBAEQRBWhCiFGsisR//gx+4Ev15raXdtRCkIgiAIRcQpCIIgCEWk+0gQ8Gf3kSA4IU5BEPBvP7MgVCLdR4IgCEIRUQqCgHQfCUIBcQqCgHQfCUIBcQo18OPTox/bDP50Cn691tLu2siYgiAIglBEnIIgCIJQRLqPauDHLgU/thn82aXg12st7a6NKAVBEAShiCgFQcCfSkEQnBCnIAj4t0tBECqR7iNBEAShiCgFQUC6jwShgDgFQUC6jwShgHQfCYIgCEVEKdTAj10Kfmwz+FMp+PVaS7trI0pBEARBKCJKoQZ+fHr0Y5vBn0+Pfr3W0u7aiFIQBEEQiohSEAT8qRQEwQlxCoKAf7sUBKES6T4SBEEQiohSEASk+0gQCohTEASk+0gQCkj3kSAIglBElEIN/Nil4Mc2gz+Vgl+vtbS7NqIUBEEQhCLiFARBEIQi0n1UAz92KfixzeDPLgW/Xmtpd23EKQgC/nQKguCEOAVBwL9Pj4JQiYwpCIIgCEVEKQgC0n0kCAXEKQgC0n0kCAWk+0gQBEEoIk5BEARBKCLdRzXwYz+zH9sM/uw+8uu1lnbXRpSCIAiCUEScgiAIglBEuo9q4McuBT+2GcCyrGafguf49VpLu2sjTkEQ8O+NQhAqke4jQRAEoYgoBUHAvxEpglCJOAVBQLqPBKGAdB8JgiAIRUQpCALSfSQIBcQp1MCPNwo/thnAMPwnmv16raXdtfHfL0EQBEFwRZyCIAiCUES6j2rgx4gUP7YZ/Nml4NdrLe2uzVE5hUwmQyaTOeLOS39gteoeTb1MJrOiuqX7fabnmc1mj+lcj/Y8nepqrR2PX6/P3q1u6THrtc8j1S2tV9nuRh2/tF42m6WzsxOAXC5Xl+Mf7Xk6tftoj3+055nL5WrWqdxvva+9ZVlHvJ804toXPmetdcN/T04U2l3PfZbWdavn9v2qROkVPCLNzs7S1dXFOeecQzAY9NwpPPjgg5xxxhkrqlu632d6nqX78dopPPjgg7zgBS9wPJdj3edK6rrdqJ/JPo9Ut7ReZbsbdfzSerlcjnvvvReAs88+m0Ag8IyPf7Tn6dTuoz2+l9epHvsstNnrNjX6czpS3QceeKB4rb28Tul0mrvvvpuZmZniQ5Dbjo7IzMyMBvTMzMxKqted17/+9U05biaT0ZlMpinH9mObtW5Ou+fn53VnZ6fu7OzU8/Pznh9f6+a024/XWmv/tntiYmJF93EZUxAE/NvPLAiVSPSRIAiCUESUgiDgz+gjQXBCnIIgIN1HglBAnEIN/Pj06Mc2gz+dgl+vtbS7NjKmIAiCIBQRpyAIgiAUke6jGvixS8GPbQZ/din49VpLu2sjSkEQBEEoIkpBEPCnUhAEJ8QpCAL+7VIQhEqk+0gQBEEoIkpBEJDuI0EoIE5BEJDuI0EoIN1HgiAIQhFRCjXwY5eCH9sM/lQKfr3W0u7aiFIQBEEQiohSqIEfnx792Gbw59OjX6+1tLs2ohQEQRCEIqIUBAF/KgVBcEKcgiDg3y4FQahEuo8EQRCEIqIUBAHpPhKEAuIUBAHpPhKEAtJ9JAiCIBQRpVADP3Yp+LHN4E+l4NdrLe2ujSgFQRAEoYg4BUEQBKGIdB/VwI9dCn5sM/izS8Gv11raXRtxCoKAP52CIDghTkEQ8O/ToyBUImMKgiAIQhFRCoKAdB8JQgFxCoKAdB8JQgHpPhIEQRCKiFMQBEEQikj3UQ382M/sxzaDP7uP/Hqtpd21EaUgCIIgFBGnIAiCIBSR7qMa+LFLwY9tBrAsq9mn4Dl+vdbS7tqIUxAE/HujEIRKpPtIEARBKCJKQRDwb0SKIFQiTkEQkO4jQSgg3UeCIAhCEVEKgoB0HwlCAXEKNfDjjcKPbQYwDP+JZr9ea2l3bfz3SxAEQRBcEacgCIIgFJHuoxr4MSLFj20Gf3Yp+PVaS7trI0pBEARBKCJOQRAEQSgi3UeCgD+7jwTBCXEKgoB/+5kFoRLpPhIEQRCKiFIQBKT7SBAKiFMQBKT7SBAKiFOogR+fHv3YZvCnU/DrtZZ210bGFARBEIQiK1IKBQ8zOTlJJpM54lNVqUeqVXel9dLpNBMTEyuqW7rfZ3qemUwGgGAwWPc2HaluOp1mcnKyqm69Pnu3uqVtrtc+j1S3tF5luxt1/NJ6i4uLtLe3AzA1NUUqlXrGxz/a83Rq99Ee/2jPM5vNAuXXutZ+633tU6kUExMTnvyeSil8x03TbPjvyYlCu+u5z9K6bvWmpqaq9umE0ivQFPv27eO44447UjVBEAShxdm7dy+Dg4Ou21fkFCzL4sCBA3R0dPiy71UQBOHZjtaaubk51q9fXzNV/IqcgiAIguAPZKBZEARBKCJOQRAEQSgiTkEQBEEoIk5BEARBKCJOQRAEQSgiTkEQBEEoIk5BEARBKPL/A4VZrQyOBtPlAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## 绘制原始网格、散点和坐标轴向量\n", + "visualize(X_square,\n", + " X_grid + t1.T, \n", + " X_square + t1.T, \n", + " 'translation,t1') # 绘制原始图像" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d9fb9a16-bcbc-4e4a-aa8a-23e4f6728d1d", + "metadata": {}, + "outputs": [], + "source": [ + "t2 = -t1" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "6c57d87b-2917-48fc-8d25-d681032020d3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## 绘制原始网格、散点和坐标轴向量\n", + "visualize(X_square,\n", + " X_grid + t2.T, \n", + " X_square + t2.T, \n", + " 'translation,t2') # 绘制原始图像" + ] + }, + { + "cell_type": "markdown", + "id": "049c2ff1-f74c-4776-b130-04bf6996c8bd", + "metadata": {}, + "source": [ + "## 等比例缩放" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "af36d763-d169-4770-9698-896602d9905b", + "metadata": {}, + "outputs": [], + "source": [ + "S_up = np.array([[2,0],\n", + " [0,2]])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "10f5229a-b93d-4d8d-a9e7-b40071e4383e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## 绘制原始网格、散点和坐标轴向量\n", + "visualize(X_square,\n", + " X_grid @ S_up.T, \n", + " X_square @ S_up.T, \n", + " 'uniform scaling up') # 绘制原始图像" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8bdb29fd-f15b-419b-9f24-9d98c21b3eed", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.5, 0. ],\n", + " [0. , 0.5]])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "S_down = np.linalg.inv(S_up)\n", + "S_down" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "1e0c5131-7d8f-46ce-ba43-d4711b6a4d60", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## 绘制原始网格、散点和坐标轴向量\n", + "visualize(X_square,\n", + " X_grid @ S_down.T, \n", + " X_square @ S_down.T, \n", + " 'uniform scaling down') # 绘制原始图像" + ] + }, + { + "cell_type": "markdown", + "id": "9bb14571-c12d-4b1b-a62e-f71deb04a5df", + "metadata": {}, + "source": [ + "## 旋转" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b8317818-a923-4307-8c3a-e0215707ee9e", + "metadata": {}, + "outputs": [], + "source": [ + "# 定义一个函数，用于生成二维平面的旋转矩阵\n", + "def rotation_matrix(theta):\n", + " \"\"\"\n", + " 生成二维旋转矩阵\n", + " :param theta: 旋转角度（单位：弧度）\n", + " :return: 2x2旋转矩阵\n", + " \"\"\"\n", + " return np.array([[np.cos(theta), -np.sin(theta)], # 第一行：[cos(theta), -sin(theta)]\n", + " [np.sin(theta), np.cos(theta)]]) # 第二行：[sin(theta), cos(theta)]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "be130c15-ebbb-4e04-ae8d-70c952a7261d", + "metadata": {}, + "outputs": [], + "source": [ + "# 定义要旋转的角度（以弧度为单位）\n", + "angle = 2* np.pi / 3 # 45度对应的弧度值\n", + "\n", + "# 调用函数生成对应的旋转矩阵\n", + "R = rotation_matrix(angle) # 计算45度旋转矩阵" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "340fe432-d1bd-41e5-b4f1-21d1bb077382", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "t_1 = np.array([[1],\n", + " [1]])\n", + "\n", + "## 绘制原始网格、散点和坐标轴向量\n", + "visualize(X_square + t_1.T,\n", + " (X_grid + t_1.T) @ R.T, \n", + " (X_square + t_1.T) @ R.T, \n", + " 'first translate, then rotate 120 deg') # 绘制原始图像" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9ac5cc49-9b6c-4cbd-b654-9362b45d5fae", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch08_Python_Codes/Streamlit_Bk4_Ch08_02.py b/Book4_Ch08_Python_Codes/Streamlit_Bk4_Ch08_02.py new file mode 100644 index 0000000..f24817b --- /dev/null +++ b/Book4_Ch08_Python_Codes/Streamlit_Bk4_Ch08_02.py @@ -0,0 +1,130 @@ + +############### +# Authored by Weisheng Jiang +# Book 4 | From Basic Arithmetic to Machine Learning +# Published and copyrighted by Tsinghua University Press +# Beijing, China, 2025 +############### + +import plotly.graph_objects as go +import numpy as np +from plotly.subplots import make_subplots +import streamlit as st + +# 定义一个函数，用于将矩阵转换为LaTeX格式的bmatrix +def bmatrix(a): + """返回LaTeX bmatrix + + :a: numpy数组 + :returns: 作为字符串的LaTeX bmatrix + """ + if len(a.shape) > 2: + raise ValueError('bmatrix最多支持显示二维矩阵') # 确保输入矩阵是二维的 + lines = str(a).replace('[', '').replace(']', '').splitlines() # 格式化矩阵为字符串 + rv = [r'\begin{bmatrix}'] # LaTeX矩阵的开始部分 + rv += [' ' + ' & '.join(l.split()) + r'\\' for l in lines] # 添加每一行数据 + rv += [r'\end{bmatrix}'] # LaTeX矩阵的结束部分 + return '\n'.join(rv) + +# 设置网格大小 +n = m = 20 + +# 创建带两个子图的图表 +fig = make_subplots(rows=1, cols=2, horizontal_spacing=0.035) + +# 初始化垂直线的x和y坐标列表 +xv = [] +yv = [] + +# 添加垂直线的坐标 +for k in range(-n, n + 1): + xv.extend([k, k, np.nan]) # 添加x坐标并在每条线后加入NaN以断开 + yv.extend([-m, m, np.nan]) # 添加y坐标并在每条线后加入NaN以断开 +# 设置线宽 +lw = 1 # line_width +# 将垂直线添加到第一个子图 +fig.add_trace(go.Scatter(x=xv, y=yv, mode="lines", line_width=lw, + line_color='red'), 1, 1) + +# 初始化水平线的x和y坐标列表 +xh = [] +yh = [] +# 添加水平线的坐标 +for k in range(-m, m + 1): + xh.extend([-m, m, np.nan]) # 添加x坐标并在每条线后加入NaN以断开 + yh.extend([k, k, np.nan]) # 添加y坐标并在每条线后加入NaN以断开 +# 将水平线添加到第一个子图 +fig.add_trace(go.Scatter(x=xh, y=yh, mode="lines", line_width=lw, + line_color='blue'), 1, 1) + +# 在Streamlit侧边栏中定义滑块和显示LaTeX公式 +with st.sidebar: + # 显示旋转矩阵的公式 + st.latex(r''' + R = \begin{bmatrix} + \cos(\theta) & -\sin(\theta)\\ + \sin(\theta) & \cos(\theta) + \end{bmatrix}''') + + # 添加滑块，用于选择旋转角度theta + theta = st.slider('Theta degree: ', -180, 180, step=5, value=0) # 滑块范围为-180到180度 + theta = theta / 180 * np.pi # 将角度转换为弧度 + +# 定义旋转矩阵R +R = np.array([[np.cos(theta), -np.sin(theta)], + [np.sin(theta), np.cos(theta)]], dtype=float) + +# 将垂直线的坐标转换为NumPy数组 +X = np.array(xv) +Y = np.array(yv) + +# 使用旋转矩阵R变换垂直线的坐标 +Txvyv = R @ np.stack((X, Y)) # 对每个坐标点应用旋转变换 + +# 将水平线的坐标转换为NumPy数组 +X = np.array(xh) +Y = np.array(yh) + +# 使用旋转矩阵R变换水平线的坐标 +Txhyh = R @ np.stack((X, Y)) # 对每个坐标点应用旋转变换 + +# 显示旋转矩阵的LaTeX表达式 +st.latex(r'R = ' + bmatrix(R)) + +# 提取旋转矩阵的列向量 +r1 = R[:, 0].reshape((-1, 1)) # 第一列向量 +r2 = R[:, 1].reshape((-1, 1)) # 第二列向量 + +# 显示列向量的LaTeX公式 +st.latex(r''' + r_1 = R e_1 = ''' + bmatrix(R) + + 'e_1 = ' + bmatrix(r1) + ) +st.latex(r''' + r_2 = R e_2 = ''' + bmatrix(R) + + 'e_2 = ' + bmatrix(r2) + ) + +# 显示旋转矩阵的行列式值 +st.latex(r'\begin{vmatrix} R \end{vmatrix} = ' + str(np.linalg.det(R))) + +# 将变换后的垂直线添加到第二个子图 +fig.add_trace(go.Scatter(x=Txvyv[0], y=Txvyv[1], + mode="lines", line_width=lw, + line_color='red'), 1, 2) + +# 将变换后的水平线添加到第二个子图 +fig.add_trace(go.Scatter(x=Txhyh[0], y=Txhyh[1], + mode="lines", line_width=lw, + line_color='blue'), 1, 2) + +# 设置x轴和y轴的范围 +fig.update_xaxes(range=[-4, 4]) +fig.update_yaxes(range=[-4, 4]) + +# 设置图表的布局和样式 +fig.update_layout(width=800, height=500, showlegend=False, template="none", + plot_bgcolor="white", yaxis2_showgrid=False, xaxis2_showgrid=False) + +# 在Streamlit应用中显示图表 +st.plotly_chart(fig) diff --git a/Book4_Ch08_Python_Codes/Streamlit_Bk4_Ch08_03.py b/Book4_Ch08_Python_Codes/Streamlit_Bk4_Ch08_03.py new file mode 100644 index 0000000..c713f50 --- /dev/null +++ b/Book4_Ch08_Python_Codes/Streamlit_Bk4_Ch08_03.py @@ -0,0 +1,154 @@ + +############### +# Authored by Weisheng Jiang +# Book 4 | From Basic Arithmetic to Machine Learning +# Published and copyrighted by Tsinghua University Press +# Beijing, China, 2025 +############### + +import plotly.graph_objects as go +import numpy as np +from plotly.subplots import make_subplots +import streamlit as st + +# 定义一个函数，用于生成LaTeX格式的矩阵表示 +def bmatrix(a): + """返回LaTeX bmatrix + :a: numpy数组 + :returns: LaTeX bmatrix格式的字符串 + """ + if len(a.shape) > 2: # 检查矩阵维度是否超过2 + raise ValueError('bmatrix最多支持二维矩阵') + lines = str(a).replace('[', '').replace(']', '').splitlines() # 格式化矩阵为字符串 + rv = [r'\begin{bmatrix}'] # 开始LaTeX矩阵表示 + rv += [' ' + ' & '.join(l.split()) + r'\\' for l in lines] # 添加每一行 + rv += [r'\end{bmatrix}'] # 结束LaTeX矩阵表示 + return '\n'.join(rv) + +# 设置网格大小 +n = m = 20 + +# 创建具有两个子图的图表 +fig = make_subplots(rows=1, cols=2, horizontal_spacing=0.035) + +# 初始化垂直线的x和y坐标列表 +xv = [] +yv = [] + +# 添加垂直线的坐标 +for k in range(-n, n + 1): + xv.extend([k, k, np.nan]) # 添加垂直线的x坐标并在每条线后加入NaN以断开 + yv.extend([-m, m, np.nan]) # 添加垂直线的y坐标并在每条线后加入NaN以断开 + +# 设置线宽 +lw = 1 # 线宽 +# 将垂直线添加到图表的第一个子图 +fig.add_trace(go.Scatter(x=xv, y=yv, mode="lines", line_width=lw, + line_color='red'), 1, 1) + +# 初始化水平线的x和y坐标列表 +xh = [] +yh = [] + +# 添加水平线的坐标 +for k in range(-m, m + 1): + xh.extend([-m, m, np.nan]) # 添加水平线的x坐标并在每条线后加入NaN以断开 + yh.extend([k, k, np.nan]) # 添加水平线的y坐标并在每条线后加入NaN以断开 + +# 将水平线添加到图表的第一个子图 +fig.add_trace(go.Scatter(x=xh, y=yh, mode="lines", line_width=lw, + line_color='blue'), 1, 1) + +# 使用Streamlit的侧边栏显示滑块和LaTeX矩阵公式 +with st.sidebar: + st.latex(r''' + A = \begin{bmatrix} + a & b\\ + c & d + \end{bmatrix}''') # 显示矩阵A的LaTeX公式 + + # 添加滑块控件，供用户调整矩阵A的元素值 + a = st.slider('a', -2.0, 2.0, step=0.1, value=1.0) + b = st.slider('b', -2.0, 2.0, step=0.1, value=0.0) + c = st.slider('c', -2.0, 2.0, step=0.1, value=0.0) + d = st.slider('d', -2.0, 2.0, step=0.1, value=1.0) + +# 定义一个固定的角度值 +theta = np.pi / 6 + +# 创建矩阵A +A = np.array([[a, b], + [c, d]], dtype=float) + +# 获取垂直线的坐标并转换为NumPy数组 +X = np.array(xv) +Y = np.array(yv) + +# 使用矩阵A变换垂直线的坐标 +Txvyv = A @ np.stack((X, Y)) # 对坐标点应用线性变换 + +# 获取水平线的坐标并转换为NumPy数组 +X = np.array(xh) +Y = np.array(yh) + +# 使用矩阵A变换水平线的坐标 +Txhyh = A @ np.stack((X, Y)) # 对坐标点应用线性变换 + +# 显示矩阵A的LaTeX格式 +st.latex(r'A = ' + bmatrix(A)) + +# 提取矩阵A的列向量 +a1 = A[:, 0].reshape((-1, 1)) # 第一列 +a2 = A[:, 1].reshape((-1, 1)) # 第二列 + +# 显示矩阵列向量的LaTeX公式 +st.latex(r''' + a_1 = Ae_1 = ''' + bmatrix(A) + + 'e_1 = ' + bmatrix(a1) + ) +st.latex(r''' + a_2 = Ae_2 = ''' + bmatrix(A) + + 'e_2 = ' + bmatrix(a2) + ) + +# 显示矩阵A的行列式值 +st.latex(r'\begin{vmatrix} A \end{vmatrix} = ' + str(np.linalg.det(A))) + +# 生成一个单位圆的坐标 +theta_array = np.linspace(0, 2 * np.pi, 101) # 定义角度数组 +circle_x = np.cos(theta_array) # 单位圆x坐标 +circle_y = np.sin(theta_array) # 单位圆y坐标 +circle_array = np.stack((circle_x, circle_y)) # 将x和y坐标堆叠为二维数组 + +# 将单位圆添加到第一个子图 +fig.add_trace(go.Scatter(x=circle_x, y=circle_y, + fill="toself", line_color='orange'), 1, 1) + +# 使用矩阵A变换单位圆的坐标 +A_times_circle_array = A @ circle_array + +# 将变换后的单位圆添加到第二个子图 +fig.add_trace(go.Scatter(x=A_times_circle_array[0, :], + y=A_times_circle_array[1, :], + fill="toself", line_color='orange'), 1, 2) + +# 将变换后的垂直线添加到第二个子图 +fig.add_trace(go.Scatter(x=Txvyv[0], y=Txvyv[1], + mode="lines", line_width=lw, + line_color='blue'), 1, 2) + +# 将变换后的水平线添加到第二个子图 +fig.add_trace(go.Scatter(x=Txhyh[0], y=Txhyh[1], + mode="lines", line_width=lw, + line_color='red'), 1, 2) + +# 设置x轴和y轴的范围 +fig.update_xaxes(range=[-4, 4]) +fig.update_yaxes(range=[-4, 4]) + +# 设置图表的布局和样式 +fig.update_layout(width=800, height=500, showlegend=False, template="none", + plot_bgcolor="white", yaxis2_showgrid=False, xaxis2_showgrid=False) + +# 在Streamlit应用中显示图表 +st.plotly_chart(fig) diff --git a/Book4_Ch09_Python_Codes/Bk4_Ch09_01.ipynb b/Book4_Ch09_Python_Codes/Bk4_Ch09_01.ipynb new file mode 100644 index 0000000..841c8b6 --- /dev/null +++ b/Book4_Ch09_Python_Codes/Bk4_Ch09_01.ipynb @@ -0,0 +1,205 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 09\n", + "\n", + "# 正交投影\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "5cf69650-7deb-4770-a8ff-af8a2b7c34a3", + "metadata": {}, + "source": [ + "这段代码展示了一个二维向量 $$x = \\begin{bmatrix} 4 \\\\ 3 \\end{bmatrix}$$\n", + "在不同方向上投影的效果。首先，定义了从 0 到 \\( \\pi \\) 的 25 个角度构成的数组 `thetas`。对每个角度 \\(\\theta\\)，代码构造一个单位向量 \\( v(\\theta) \\)：\n", + "\n", + "$$\n", + "v(\\theta) = \\begin{bmatrix} \\cos(\\theta) \\\\ \\sin(\\theta) \\end{bmatrix}\n", + "$$\n", + "\n", + "该单位向量表示在平面上旋转的不同方向。然后，通过计算 \\( x \\) 在 \\( v \\) 上的投影：\n", + "\n", + "$$\n", + "\\text{proj} = v^T \\cdot x\n", + "$$\n", + "\n", + "得出 \\( x \\) 在每个 \\( v \\) 方向上的投影长度。代码将此投影结果可视化：首先绘制 \\( v \\) 方向的直线以指示投影方向，然后绘制从 \\( x \\) 到其投影点的线段，直观地展示出 \\( x \\) 在该方向上的投影点。最终效果展示了 \\( x \\) 随不同方向投影的变化，通过一个红色“x”标记出原始向量 \\( x \\) 的位置，并在各个方向上绘制投影，给出了 \\( x \\) 在旋转方向上不同投影的几何图形。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4e72ef2c-b83d-48cb-b550-ca78fcdf48df", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import numpy as np # 导入数值计算库\n", + "import matplotlib.pyplot as plt # 导入绘图库\n", + "from matplotlib.colors import hsv_to_rgb # 导入HSV到RGB颜色转换函数" + ] + }, + { + "cell_type": "markdown", + "id": "d5067145-7b42-4557-a522-8d57feb204de", + "metadata": { + "tags": [] + }, + "source": [ + "## 定义角度序列" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "125df454-8366-4a70-b8de-fa48dd40a0a7", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "thetas = np.linspace(0, np.pi, 25) # 生成从 0 到 π 的 25 个角度" + ] + }, + { + "cell_type": "markdown", + "id": "27fc5f7d-99ff-4588-b592-647b0d196402", + "metadata": { + "tags": [] + }, + "source": [ + "## 定义向量 x" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "84a7bf67-08d5-4516-bb23-3d6b794e2aa9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "x = np.array([4, 3]) # 定义二维向量 x" + ] + }, + { + "cell_type": "markdown", + "id": "500a0713-6fce-4265-a213-682d3502fe1b", + "metadata": { + "tags": [] + }, + "source": [ + "## 创建绘图子图" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "04cc39a7-fcc8-4abc-9b27-4f6558eb8d4f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(-6.6, 6.6, -6.6, 6.6)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots() # 创建绘图子图\n", + "\n", + "## 投影计算和绘图\n", + "for i, theta in enumerate(thetas): # 遍历每个角度 theta\n", + " v = np.array([np.cos(theta), np.sin(theta)]) # 计算单位向量 v\n", + " \n", + " proj = np.dot(v, x) # 计算 x 在 v 上的投影长度\n", + "\n", + " # 根据角度映射颜色 (HSV 色谱)\n", + " hue = theta / np.pi # 将角度归一化到 [0, 1]\n", + " color = hsv_to_rgb([hue, 1, 1]) # 转换为 RGB 颜色\n", + "\n", + " # 绘制投影方向上的直线\n", + " ax.plot([-v[0]*6, v[0]*6], [-v[1]*6, v[1]*6], color=color)\n", + " \n", + " # 绘制 x 到投影点的线段\n", + " proj_point = proj * v # 投影点坐标\n", + " ax.plot([x[0], proj_point[0]], [x[1], proj_point[1]], color=color, linestyle='-')\n", + " \n", + " # 绘制投影点\n", + " ax.plot(proj_point[0], proj_point[1], color=color, marker='x')\n", + "\n", + " # 绘制单位向量 v\n", + " ax.quiver(0, 0, v[0], v[1], angles='xy', scale_units='xy', scale=1, color=color)\n", + "\n", + "## 绘制向量 x 的位置\n", + "ax.plot(x[0], x[1], marker='x', color='r', label='Vector x') # 绘制向量 x 的起点\n", + "ax.axhline(y = 0, color = 'k')\n", + "ax.axvline(x = 0, color = 'k')\n", + "## 设置坐标轴比例\n", + "ax.set_aspect('equal', 'box')\n", + "ax.axis(False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a80909-2aac-49ed-bb7a-f8cc6b80ee7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch09_Python_Codes/Bk4_Ch09_02.ipynb b/Book4_Ch09_Python_Codes/Bk4_Ch09_02.ipynb new file mode 100644 index 0000000..e348d4f --- /dev/null +++ b/Book4_Ch09_Python_Codes/Bk4_Ch09_02.ipynb @@ -0,0 +1,183 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 09\n", + "\n", + "# 朝不同正交坐标系投影\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "feafc415-166c-4266-abeb-626bb0b3ab00", + "metadata": {}, + "source": [ + "这段代码展示了二维向量 $$x = \\begin{bmatrix} 4 \\\\ 3 \\end{bmatrix}$$在不同方向上的投影，生成了9个子图展示每个角度的投影效果。首先定义角度列表 `thetas`，包括从0到135度的多个角度。对于每个角度 $\\theta$，计算两个单位向量 $v_1$ 和 $v_2$：\n", + "\n", + "$$\n", + "v_1(\\theta) = \\begin{bmatrix} \\cos(\\theta) \\\\ \\sin(\\theta) \\end{bmatrix}\n", + "$$\n", + "\n", + "和与 $v_1$垂直的单位向量\n", + "\n", + "$$\n", + "v_2(\\theta) = \\begin{bmatrix} -\\sin(\\theta) \\\\ \\cos(\\theta) \\end{bmatrix}\n", + "$$\n", + "\n", + "代码分别计算向量$x$在 $v_1$ 和 $v_2$ 方向上的投影，得到投影长度为\n", + "\n", + "$$\n", + "\\text{proj}_{v_1} = v_1^T \\cdot x\n", + "$$\n", + "\n", + "和\n", + "\n", + "$$\n", + "\\text{proj}_{v_2} = v_2^T \\cdot x\n", + "$$\n", + "\n", + "在每个子图中，代码绘制 $x$ 在 $v_1$ 和 $v_2$ 上的投影线段及投影点，并显示向量 $v_1$ 和 $v_2$ 的方向，同时将向量 $x$ 和坐标轴也一并展示。通过不同角度的展示，可以直观地观察到 $x$ 在各个方向的投影变化及几何关系。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "aa00506d-3ba1-4f0b-b665-e8a6f6c27a93", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # 导入数值计算库\n", + "import matplotlib.pyplot as plt # 导入绘图库" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0a88b8a3-04ca-4ff5-ade5-63538d49958f", + "metadata": {}, + "outputs": [], + "source": [ + "p = plt.rcParams # 获取默认绘图参数\n", + "p[\"font.sans-serif\"] = [\"Roboto\"] # 设置无衬线字体为 Roboto\n", + "p[\"font.weight\"] = \"light\" # 设置字体粗细为 light\n", + "p[\"ytick.minor.visible\"] = True # 显示 y 轴的小刻度\n", + "p[\"xtick.minor.visible\"] = True # 显示 x 轴的小刻度\n", + "p[\"axes.grid\"] = True # 启用坐标轴网格\n", + "p[\"grid.color\"] = \"0.5\" # 设置网格颜色为灰色\n", + "p[\"grid.linewidth\"] = 0.5 # 设置网格线宽度" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d9b2def9-7b6d-4cfc-bc57-7a35a47bffc4", + "metadata": {}, + "outputs": [], + "source": [ + "# 定义角度数组\n", + "thetas = np.array([0, 15, 30, 45, 60, 75, 90, 120, 135]) # 定义角度列表" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "303244d5-3e11-472b-ac4e-6a0feadab71e", + "metadata": {}, + "outputs": [], + "source": [ + "# 定义向量 x\n", + "x = np.array([[4], [3]]) # 定义二维向量 x" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5591d179-9c62-4056-9501-776e6b60f560", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 创建绘图\n", + "i = 1 # 子图计数器\n", + "fig = plt.figure(figsize = (12,12)) # 创建绘图\n", + "\n", + "# 计算不同角度下的投影\n", + "for theta in thetas: # 遍历角度列表\n", + " \n", + " theta = theta / 180 * np.pi # 将角度转换为弧度\n", + " ax = fig.add_subplot(3, 3, i) # 添加3x3子图布局中的第 i 个子图\n", + "\n", + " # 定义 v1 向量并计算 x 在 v1 上的投影\n", + " v1 = np.array([[np.cos(theta)], [np.sin(theta)]]) # 计算旋转角度方向的单位向量 v1\n", + " proj = v1.T @ x # 计算向量 x 在 v1 上的投影\n", + " # print(proj) # 输出投影长度\n", + " plt.plot([-v1[0, 0]*6, v1[0, 0]*6], [-v1[1, 0]*6, v1[1, 0]*6]) # 绘制 v1 的投影轴\n", + " plt.plot([x[0, 0], v1[0, 0]*proj[0, 0]], [x[1, 0], v1[1, 0]*proj[0, 0]], color='k', linestyle='--') # 绘制 x 到投影点的虚线\n", + " plt.plot(v1[0, 0]*proj[0, 0], v1[1, 0]*proj[0, 0], color='k', marker='x') # 标记投影点\n", + "\n", + " plt.quiver(0, 0, v1[0, 0], v1[1, 0], angles='xy', scale_units='xy', scale=1, color='b') # 绘制单位向量 v1\n", + "\n", + " # 定义 v2 向量并计算 x 在 v2 上的投影\n", + " v2 = np.array([[-np.sin(theta)], [np.cos(theta)]]) # 计算与 v1 垂直的单位向量 v2\n", + " proj = v2.T @ x # 计算向量 x 在 v2 上的投影\n", + " # print(proj) # 输出投影长度\n", + " plt.plot([-v2[0, 0]*6, v2[0, 0]*6], [-v2[1, 0]*6, v2[1, 0]*6]) # 绘制 v2 的投影轴\n", + " plt.plot([x[0, 0], v2[0, 0]*proj[0, 0]], [x[1, 0], v2[1, 0]*proj[0, 0]], color='k', linestyle='--') # 绘制 x 到投影点的虚线\n", + " plt.plot(v2[0, 0]*proj[0, 0], v2[1, 0]*proj[0, 0], color='k', marker='x') # 标记投影点\n", + "\n", + " plt.quiver(0, 0, v2[0, 0], v2[1, 0], angles='xy', scale_units='xy', scale=1, color='r') # 绘制单位向量 v2\n", + "\n", + " # 绘制坐标轴和向量 x\n", + " plt.axhline(y=0, color='k') # 绘制 x 轴\n", + " plt.axvline(x=0, color='k') # 绘制 y 轴\n", + " plt.plot(x[0, 0], x[1, 0], marker='x', color='r') # 标记向量 x 的起点\n", + " plt.quiver(0, 0, x[0, 0], x[1, 0], angles='xy', scale_units='xy', scale=1, color='k') # 绘制向量 x\n", + "\n", + " # 设置坐标轴和网格\n", + " plt.axis('scaled') # 使坐标轴比例相等\n", + " ax.grid(linestyle='--', linewidth=0.25, color=[0.75, 0.75, 0.75]) # 设置网格样式\n", + " plt.xlim([-6, 6]) # 设置 x 轴范围\n", + " plt.ylim([-6, 6]) # 设置 y 轴范围\n", + " plt.xticks(np.linspace(-6, 6, 13)) # 设置 x 轴刻度\n", + " plt.yticks(np.linspace(-6, 6, 13)) # 设置 y 轴刻度\n", + " \n", + " i = i + 1 # 增加子图计数器" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch10_Python_Codes/Bk4_Ch10_01.ipynb b/Book4_Ch10_Python_Codes/Bk4_Ch10_01.ipynb new file mode 100644 index 0000000..29a13a8 --- /dev/null +++ b/Book4_Ch10_Python_Codes/Bk4_Ch10_01.ipynb @@ -0,0 +1,499 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "73bd968b-d970-4a05-94ef-4e7abf990827", + "metadata": {}, + "source": [ + "Chapter 10\n", + "\n", + "# 数据正交投影\n", + "Book_4《矩阵力量》 | 鸢尾花书：从加减乘除到机器学习 (第二版)" + ] + }, + { + "cell_type": "markdown", + "id": "23cd38cd-efb3-4836-81ea-9043eee65da6", + "metadata": {}, + "source": [ + "这段代码从 `sklearn` 的 `load_iris` 数据集中提取了鸢尾花数据，计算其 Gram 矩阵和特征向量，并通过一系列矩阵操作和热图可视化了数据与特征向量的关系。具体步骤如下：\n", + "\n", + "1. **Gram 矩阵计算**：首先定义了四个特征：萼片长度 \\( x_1 \\)、萼片宽度 \\( x_2 \\)、花瓣长度 \\( x_3 \\) 和花瓣宽度 \\( x_4 \\)，将原始数据矩阵 \\( X \\) 计算为矩阵的列。然后计算 Gram 矩阵 \\( G = X^T X \\) 和其特征值与特征向量：\n", + "\n", + " $$\n", + " G = X^T X\n", + " $$\n", + "\n", + " 其中，\\( G \\) 为 \\( 4 \\times 4 \\) 的对称矩阵，表示数据的相似度。\n", + "\n", + "2. **特征向量的矩阵操作**：对于每个特征向量 \\( v_j \\)，定义以下几组计算：\n", + "\n", + " - **组 1**：将 \\( X \\) 投影到 \\( v_j \\) 上得到 \\( z_j \\)，即：\n", + " \n", + " $$\n", + " z_j = X v_j\n", + " $$\n", + " \n", + " 通过热图展示 \\( X \\)、\\( v_j \\) 和 \\( z_j \\) 的结果。\n", + "\n", + " - **组 2**：使用 \\( z_j \\) 和 \\( v_j^T \\) 的乘积重建矩阵 \\( X_j \\)，即：\n", + " \n", + " $$\n", + " X_j = z_j v_j^T\n", + " $$\n", + " \n", + " 展示 \\( z_j \\)、\\( v_j^T \\) 和 \\( X_j \\) 的结构。\n", + "\n", + " - **组 3**：构造矩阵 \\( T_j \\) 为 \\( v_j v_j^T \\)，这是一个投影矩阵，使任何向量在 \\( v_j \\) 上投影，满足 \\( T_j T_j = T_j \\) 的幂等性：\n", + "\n", + " $$\n", + " T_j = v_j v_j^T\n", + " $$\n", + "\n", + " - **组 4**：计算 \\( X T_j \\) 用于近似原始数据矩阵 \\( X \\) 中与 \\( v_j \\) 对应的部分：\n", + "\n", + " $$\n", + " X_j = X T_j\n", + " $$\n", + "\n", + "3. **可视化**：通过 `seaborn` 绘制热图展示原始矩阵和计算过程中的中间矩阵，使矩阵乘法和特征向量投影的过程更直观可见。这种可视化方法帮助展示数据和特征向量之间的关系，以及 Gram 矩阵的正交基的构成和投影。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "29baf153-c8f4-41f3-8d7c-1dc0e96d8b4d", + "metadata": {}, + "outputs": [], + "source": [ + "import seaborn as sns # 导入数据可视化库\n", + "import numpy as np # 导入数值计算库\n", + "import matplotlib.pyplot as plt # 导入绘图库\n", + "import pandas as pd # 导入数据处理库\n", + "from sklearn.datasets import load_iris # 导入鸢尾花数据集加载器" + ] + }, + { + "cell_type": "markdown", + "id": "ca8aaa4f-9031-464c-9edd-2f3c6398b485", + "metadata": {}, + "source": [ + "## 加载数据并定义特征名称" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "99dc5f8a-0d29-4b10-ac40-da9109162750", + "metadata": {}, + "outputs": [], + "source": [ + "iris = load_iris()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a247144e-b675-4522-8e8a-cebe5db1324c", + "metadata": {}, + "outputs": [], + "source": [ + "X = iris.data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "eea5b1a3-4438-49c3-98dd-c930855eed40", + "metadata": {}, + "outputs": [], + "source": [ + "y = iris.target" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "71c7e6e1-6e48-4483-844e-bb4990ece919", + "metadata": {}, + "outputs": [], + "source": [ + "feature_names = ['Sepal length, x1', 'Sepal width, x2', 'Petal length, x3', 'Petal width, x4']\n", + "X_df = pd.DataFrame(X, columns=feature_names) # 将 X 转换为数据框" + ] + }, + { + "cell_type": "markdown", + "id": "13acec3e-02db-483e-a39e-2f508c7ffc8f", + "metadata": {}, + "source": [ + "## 提取数据和计算 Gram 矩阵" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "832d3c4f-c3fd-4fc0-bde8-c9f1b8dcfc5c", + "metadata": {}, + "outputs": [], + "source": [ + "X = X_df.to_numpy() # 将数据框转换为数组" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "144b0f7b-9f67-4646-ac5a-e5389360cee2", + "metadata": {}, + "outputs": [], + "source": [ + "G = X.T @ X # 计算 Gram 矩阵" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ecea30ff-724d-4a11-a9cc-7d2e8ddf0e10", + "metadata": {}, + "outputs": [], + "source": [ + "D, V = np.linalg.eig(G) # 计算特征值和特征向量" + ] + }, + { + "cell_type": "markdown", + "id": "e2f0d594-50f3-40c4-bbaa-e2e4459c6afe", + "metadata": {}, + "source": [ + "## 定义函数：绘制热图" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6faae63d-6d93-4614-bd88-741e783b8020", + "metadata": {}, + "outputs": [], + "source": [ + "def heatmap(Matrices, Titles, Ranges, Equal_tags):\n", + " M1, M2, M3 = Matrices # 提取矩阵\n", + " Title_1, Title_2, Title_3 = Titles # 提取标题\n", + " \n", + " fig, axs = plt.subplots(1, 5, figsize=(12, 3)) # 创建子图\n", + " \n", + " plt.sca(axs[0])\n", + " ax = sns.heatmap(M1, cmap='RdYlBu_r', vmin=Ranges[0][0], vmax=Ranges[0][1],\n", + " cbar=False, xticklabels=False, yticklabels=False)\n", + " if Equal_tags[0]:\n", + " ax.set_aspect(\"equal\")\n", + " plt.title(Title_1)\n", + " \n", + " plt.sca(axs[1])\n", + " plt.title('=')\n", + " plt.axis('off')\n", + " \n", + " plt.sca(axs[2])\n", + " ax = sns.heatmap(M2, cmap='RdYlBu_r', vmin=Ranges[1][0], vmax=Ranges[1][1],\n", + " cbar=False, xticklabels=False, yticklabels=False)\n", + " if Equal_tags[1]:\n", + " ax.set_aspect(\"equal\")\n", + " plt.title(Title_2)\n", + " \n", + " plt.sca(axs[3])\n", + " plt.title('@')\n", + " plt.axis('off')\n", + " \n", + " plt.sca(axs[4])\n", + " ax = sns.heatmap(M3, cmap='RdYlBu_r', vmin=Ranges[2][0], vmax=Ranges[2][1],\n", + " cbar=False, xticklabels=False, yticklabels=False)\n", + " if Equal_tags[2]:\n", + " ax.set_aspect(\"equal\")\n", + " plt.title(Title_3)" + ] + }, + { + "cell_type": "markdown", + "id": "37e9c69d-0e86-4c66-b1cc-69587eb17495", + "metadata": {}, + "source": [ + "## 定义函数：绘制四组图形" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6a8dd604-782f-4594-ac6e-d23c7c1917cb", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_four_figs(X, v_j, idx):\n", + " z_j = X @ v_j # 计算投影 z_j\n", + " Titles = ['$X$', '$v_' + str(idx) + '$', '$z_' + str(idx) + '$']\n", + " Ranges = [[-2, 11], [-1, 1], [-2, 11]]\n", + " Equal_tags = [False, True, False]\n", + " heatmap([X, v_j, z_j], Titles, Ranges, Equal_tags) # 绘制第一个图形组\n", + "\n", + " X_j = z_j @ v_j.T # 计算 X_j\n", + " Titles = ['$z_' + str(idx) + '$', '$v_' + str(idx) + '^T$', '$X_' + str(idx) + '$']\n", + " heatmap([z_j, v_j.T, X_j], Titles, Ranges, Equal_tags) # 绘制第二个图形组\n", + "\n", + " T_j = v_j @ v_j.T # 计算 T_j\n", + " Titles = ['$v_' + str(idx) + '$', '$v_' + str(idx) + '^T$', '$T_' + str(idx) + '$']\n", + " Ranges = [[-1, 1], [-1, 1], [-1, 1]]\n", + " Equal_tags = [True, True, True]\n", + " heatmap([v_j, v_j.T, T_j], Titles, Ranges, Equal_tags) # 绘制第三个图形组\n", + "\n", + " T_j = X @ T_j # 计算 X @ T_j\n", + " Titles = ['$X$', '$T_' + str(idx) + '$', '$X_' + str(idx) + '$']\n", + " Ranges = [[-2, 11], [-1, 1], [-2, 11]]\n", + " Equal_tags = [False, True, False]\n", + " heatmap([X, T_j, X_j], Titles, Ranges, Equal_tags) # 绘制第四个图形组" + ] + }, + { + "cell_type": "markdown", + "id": "267c4166-760c-4997-bd78-c12caf25dd59", + "metadata": {}, + "source": [ + "## 绘制四个特征向量的图形" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e82cce96-cb42-40d3-928e-a4980f008d0f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "v1 = V[:, 0].reshape((-1, 1))\n", + "plot_four_figs(X, v1, 1) # 第一个基向量" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c99bc669-7cfb-453f-82c1-53dd2b87c98b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "v2 = V[:, 1].reshape((-1, 1))\n", + "plot_four_figs(X, v2, 2) # 第二个基向量" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "90d32098-7fc6-4334-aa24-e55fb98584d2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "v3 = V[:, 2].reshape((-1, 1))\n", + "plot_four_figs(X, v3, 3) # 第三个基向量" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a4e23db9-f3c4-4078-b3bc-1e5bf9c3512c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7YAAAERCAYAAABPfDvnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAZd0lEQVR4nO3da4ydZdU38NU9p07PLygH8YBW1Ci2RKGiNSTGBPJAomiRBCJnjH5AKY3QQAoYhIqClAZiQDwxTUwNRjBETZR4fCKoASMFiY1YE/yACKWHGaZz2vN+8H2a9AVnLp7Ze+617/37JSTMzP6w9sz+0P+91rWuBdPT09MBAAAAHapRdQEAAAAwF4ItAAAAHU2wBQAAoKMJtgAAAHQ0wRYAAICOJtgCAADQ0QRbAAAAOppgCwAAQEcTbAEAAOhogi0AAAAdTbAFAACgowm2AAAA/0ubN2+OBQsWxB//+MeX/ez888+P3t7e+NGPflRBZd1FsAUAoGUmJydjaGgozjjjjDjiiCOit7c3jjzyyDj11FNjaGgopqamqi4RWuqyyy6LFStWxObNmw/5/nXXXRfbtm2LO+64I84444yKquseC6anp6erLgIAgM63Y8eOOPvss+Of//xnXHTRRXHiiSfGG97whti7d2888sgjMTQ0FK997Wvje9/7XqxcubLqcqFlrrvuurjpppviySefjHe84x3x7W9/Oy6++OK46qqr4stf/nLV5XUFwbaFnnrqqXjnO9/5ij9btmxZ7NmzJxYsWDDPVQEAtN+TTz4ZH/jAB+Lcc8+NW2+9NRYvXvyy14yOjsYVV1wRP/nJT+K3v/1tHHPMMRVUCq23e/fueNOb3hQf//jH47zzzovTTz89Pvaxj8X27dv9+3+eCLYttHfv3njqqacO+d5DDz0U1157baxfvz62bNlSUWUwf6anp4vHzHp7e9tcDQDzYWpqKlatWhWnnXZa3Hbbba/4munp6Wg2m9HT0xPnn39+vPjii/Hggw/Oc6XQPldddVVs2bIlFi1aFKtWrYqHHnooBgYGqi6razhj20LLly+Pk08++eB/zz77bNx4443x+c9//pBQ+/DDD0ej0Ygbb7yxwmqhPX71q19FX19f0X9///vfqy4XgBbYvn17jIyMxM033xwREc1mM2644YY45phjYnBwMNatWxe33nprfPjDH46IiC1btsRDDz0Uf/3rX6ssG1rqnHPOicnJyViyZEn88Ic/nDHUygOtp13SJtu2bYuLL744rr/++ti0adPB7zebzVi/fn2sWbOmwuqgfd773vfGH/7wh6LXvu51r2tzNQDMhwceeCAuvPDC6O/vj4iIO++8M77yla/E5s2b493vfnfcf//9ce2118bJJ58cERGHH354vP/9749f/OIX8da3vrXK0qEl9u3bFxdddFFERDz//PPx0ksvxWGHHfaKr5UH2kOwbYM777wz1q9fH7fffntcdtllh/zs7rvvjrVr18bu3bsrqg7aa8mSJXHCCScUvdYoMkA97Ny5M84555yDX999991x9dVXx+c+97mIiPjQhz4UTzzxRDSbzYOvOfLII+Nf//rXvNcKrTYxMRHr1q2Lv/3tb/HAAw/EWWedFbfcckts3br1FV8vD7SHUeQWu+mmm+KKK66Ib33rWy8LtS+88EJs3bo1rr/++oqqg/YzigzQfSYmJmLhwoUHv961a1e85z3vOeQ1J5100iFf/+Mf/4jXvOY181IftNOll14av/zlL+O+++6Lj370o/HJT34y7rnnnnjuuede9lp5oH20S1royiuvjDvuuCPuu+++OPPMM1/286uvvjo2bNgQy5cvn//iYJ4YRQboPm984xtj586dcfrpp0fEv7ux///Dy127dh38/507d8bvf//7uPfee+ezTGi5TZs2xdDQUHzjG9+I0047LSIirrnmmti2bVts2bIlvvSlLx3yenmgfQTbFlm/fn1s3bo1vvjFL8ZRRx0VjzzyyMGfHX300fH888/HY489FnfddVeFVUL7LV26NE488cSqywBgHp166qmxffv2WL9+fUREnH322bF58+Y4/vjjY9WqVfHggw/G/fffHyeffHL87Gc/i09/+tNx2WWXxVve8pZqC4c5+PrXvx433XRTbNq0KS655JKD3z/uuOPiE5/4RHzta1+LjRs3xooVKyIi4tFHH5UH2sh1Py0wPT0dK1asiH379r3iz/9nI/I111wTixYtioiI4eHh6OnpiXXr1sXQ0NC81QoA0Gp79uyJlStXxm233RYXXHBBDA8Px3nnnRcPPPBARPz7H/pnnnlm3HLLLXHkkUfGlVdeGRs2bHC/Jx3rxz/+cXzkIx+Jc845J7Zt2/aynz/xxBOxatWq+MIXvhDXXXddRETcfvvt8kAbCbbzZHh4OPbs2XPw6w0bNsSxxx4bGzdujMMPP7y6wgAAWuD73/9+nHfeeXHvvffG2WefHRERzz33XOzevTve/va3x4svvhh79uyJN7/5zQItXUkeaC+jyPNkyZIlsWTJkoNfL1q0KJYtW+ZDDADUwllnnRUHDhyICy+8MIaGhuJTn/pUrFmzJo499th49tlnD56p3b9/f/z0pz8Vbuk68kB76dgCANAyu3btis2bN8cPfvCDQ64zOfroo+Pcc8+Nq666Ko444ogKKwTqSLAFAKDlms1mPPPMM7F379447LDD4vWvf33VJQE1JtgCAADQ0RpVFwAAAABzIdgCAADQ0QRbAAAAOlrxdT8X3Pnf7awDZnTvZR+sugQAgK4kB1Cl0hygYwsAAEBHK+7Y9vb2tLMOAAAgoUZjQdUlzGhyoll1CR2tt68evc7iYDs5OdXOOgAAgISazdy3gzZ6cgfv7LL/fUvVI54DAADQtco7tlr8AADQdZpTuTt62Tu2RrnnR3Gwzf4HAQAAWi97cMyuLqO+2RlFBgAAoKMVd2wBAACol7p05AVbAACALpX9DHUpo8gAAAB0NMEWAACAjibYAgAA0NEEWwAAADqaYAsAAEBHK96KXJc10AAAAPxbXXKeji0AAAAdrbhjOz421c46AACAhLLfc9rbp1c3F3XJecXBtn+gp511AAAACWUfVW02cwfv7OryYKAe7wIAAICuVdyxzT6CAAAAQHfSsQUAAKCjFXdsBwb72lkHAACQUKOR+4zt5ESz6hJmlP0M8MKa5LziYDsxPtnOOgAAgISyB7Psy62y1zc5WY+tyEaRAQAA6GjFHdu+/uKXAgAANWEUeW6yd7y7bhR5qiYtagAAoFz2YJZd9gcDzWbuBwOljCIDAADQ0cwXAwAAHSv7cqbs6tKRLw622WfXAQCA1mtO5Q4+gu3cZP/7ljKKDAAAQEcr7th6EgIAAN1HDqi3uvx9y4Nt8m1eAAAA2WQf9e3tq8cQbz3eBQAAAF2ruGNbl21ZAAAA8yX7qG9dcl5xsO3rdzMQAAB0m+xHErPf3pI9OC4c7Ku6hJYwigwAAEBHK27D7nn+pXbWAQAAJDQ+NlV1CTPK3nFckLzjve/F0apLaAkdWwAAADpaccd26YqBdtYBAAAklP06mMnJ3B3l7AYX5+54l7IRCgAAoE3cYzs/6vEuAAAA6FrusQUAAGgT99jOj+Jgm/3+KgAAoPtkH/XNzigyAAAAJFDcsT0wOtnOOgAAgISyd0Tr0nGsSvZ7iksVB9veXh8YAAAgl7qcEa1KXY6cSqsAAAB0tOKO7eDi/nbWAQAAJJR91Lcuo7RVqUvOKw62u58baWcdAABAQtmD48LBvqpLmNGC5KO+w3sPVF1CS+R+/AIAAACzKO7YDgwWvxQAAKiJ7MuFJidzd5Sz//76+nuqLqElyrciJ5+tBwAAWq/RkzuYZZd9a3Nd/r7SKgAAAB2tuGPb128UGQAAuk32UdrJiWbVJcwoe8c2+/KtUtIqAABAl8q+tbmUUWQAAAA6WnHHdmT/WDvrAAAAEso+6mvJ7dzUJef5FAAAANDRiju2/QP1uN8IAAAol/06mOzLmbKrS87TsQUAAKCjCbYAAAB0tOJR5N7eerSoAQCA+mhOGUWei7os3yoOtgODrrwFAIBuk73BdWBiouoSZpT9DPDiZQNVl9AS9YjnAAAAdK3iNuze3aPtrAMAAEhofGyy6hJmlH2UttHIvVV6ZF897rEtDraDi/vbWQcAAJBQ9uA4OdGsuoQZZa9v4WBf1SW0RO5PKQAAAMyiuGM7vPdAO+sAAAASyt5xzN5RbjRy1/fSyHjVJbREcbBdsnxhO+sAAAASyh4cswfviNz1LarJkdPcn1IAAACYhVFkAADgP8reEc3eUTaKPD+Kg21ff+6LmQEgs29+85tx+eWXR0TE+Ph4TE9Px8DAQERErFmzJn7+859XWR5Ax2o2p6suYUbN5lTVJcyotzd38C5Vj3cBAMldcsklMTw8HMPDw3HhhRfGZz/72YNfC7UAMDfFHVsAoDUef/zx+MxnPlN1GQBFGj0Lqi4BZlUcbLPPrgNAJ5ieno4nnngiVq1aVXUpAFCbBxfSKgDMo6effjrGxsbiXe96V9WlAEBtFHdssx/KBoBO8Kc//Sne9ra3HVwcBQDMnY4tAMzRGWecEStXrnzZ96enp+Okk06KtWvXHvze448/bgwZAFpMsAWAOTrhhBNi165dMTw8fMj3h4aG4tFHH42tW7ce/J5gCwCtJ9gCwBytXr06pqen48knnzz4vZGRkbjmmmviggsuiBNPPPHg9wVbAGg91/0AwBytXr06IiJ27NgR73vf+yIi4uabb459+/bF5s2bD3nt008/Pe/1AUDdlV/309vTzjoAoGMdd9xxsWjRotixY0dERDzzzDPx1a9+Na699to4+uijD3ntww8/HGvXro0bbrghNm3aVEW5ALXSnLLkdi7qcq2rji0AzFGj0Yjjjz/+YLDduHFjHHXUUbFhw4ZDXtdsNmP9+vWxZs2aKsoE+F9pNHLfcyrYzk2jIdgCAP/P6tWr4/77749HHnkktm/fHvfdd9/LrvS5++67Y+3atbF79+6KqgSAeioOtvv3HmhnHQDQ0VavXh333HNPXHzxxXHKKafEunXrDvn5Cy+8EFu3bo3f/e53cfnll1dUJcCrNz42VXUJM+ofyH1kMntHdGT/WNUltERxsO3rz/2BAYAq/c8Cqb/85S/x3e9+92U/v/rqq2PDhg2xfPny+S4NYE7SjyI3s48iN6suYEZ1yXlGkQGgBT74wQ/G9PQr/+Pq0Ucfjcceeyzuuuuuea4KALpDcbDN/qQGALL6zW9+E3/+85/jiCOOiIiI4eHh6OnpiZ07d8bQ0FDF1QHMrNEjB8xF9o5yXf6+OrYA0GaXXnppnHXWWQe/3rBhQxx77LGxcePGCqsCgPpslRZsAaDNlixZEkuWLDn49aJFi2LZsmVx+OGHV1gVANRH+ShyTVrUAFC173znO1WXAAARUZ+c54wtAAAAHS33pUoAAAAwC2dsAQAA2iT7cqbevnr0OgVbAGbV/PXnqy5hRv+9clPVJcxoxzN7qi5hRv911UeqLmFGb/n141WXAEBy9YjnAAAAdK3iju2B0cl21gEAACRklHZusi/hrUvOy/0pAAAAgFkUd2wXLe5vZx0AAEBC2TuikxPNqkvoaHXJeZZHAQAAdKlmsx4PBnI/fgEAAIBZFHdsR/aPtbMOAAAgoeyjvtlHpRuN3PW9NDJedQktkfu3DAAAALMQbAEAAOhoxaPIK16zqJ11AAAACWUf9R0fm6q6hBk1m7nviV26fGHVJbRE+Rnbfc7YAgBAt2k2p6suYUbZg3d2o87YAgAAQPWKO7bZn9QAAACt15zKnQMaPQuqLmFGjUbu+rL/fUsVB9uFg33trAMAAEgo+6hv9uuIsgfH/oHiSJha7k8pAAAAzKI4nk9O5t42BgAAtF72I4nZR5Gzq0vOexVbkeuxLQsAACiXfdQ3+5HJBcnP2A7vPVB1CS1hFBkAAICOVtyxXbpioJ11AAAACaVfHpV8lDb78qjBxbk73qVyf0oBAABgFsUd20ZDBgYAgG6T/R7W7GeAmR/FwbbZ9IEBAIBuYytyvWX/+5bShgUAAKCjFXdsAQAAssm+nCm77MvBShUHW7PrAABANkaR56YuOa8e8RwAAICuVdyxrUuLGgAAqA+jyHNTl5z3KrYi+8AAAAC5GEWem7rkvHrEcwAAALpWecdWix8AAICEnLEFAACgo0mrAAAAdLTiju3oyEQ76wAAABLKfiQx+2Rpo5G7vpdGxqsuoSVsRQYAAP4jOaDepmvy9839+AAAAABmUdyx7evvaWcdAABAQo2Ge2LnotlsVl3CjHp669HrLA62/QOCLQAAdJtGT+5ga1R6brKfUS5Vj3cBAABA1yru2Pb06tgCAEC3yT6KPDmRe9Q3e0d54WBf1SW0hI4tAAAAHa24Yzuyf6yddQCQWOOUW6suYUanVF3ALE45ZkXVJczs149XXQGQWPaOaF3OiFblwOhE1SW0hOVRAADAf2R5VL3V5cFAPd4FAAAAXau4Yzs6Uo8WNQAAUC77KHJdlh9VpS5HTl/FVmTNXQAA6DbZtyI3m7mDd3Z1yXn1eBcAAAB0LcujAACA/8jyqHqry/Ko4mCbfQQBAACA7lSPeA4AAEDXKu7Yjo9NtbMOAAAgoeZU7lHfuozSVqUuOa842E6M1+MNAwAA5ZxhnZtGI3fwnpqsx7WuuX/LAAAAMAv32AIAAP+RJbJzk/2e3brkvOJg21uTNwwAAJRz3U+91eWMcj3eBQAAAF2ruGM7uLi/nXUAAAAJZR9FrstW36rUJecVB9vRkfF21gEAACSUfdS3LqO0VRkbtRUZAAAAKifYAgAA0NEEWwAAADpa8Rnb7Gu+AQAAeHXqkvPKg23ybWgAAED3aU7lXm6VXV2Wb9XjXQAAANC1iju2I/td9wMAAN1mcqJZdQkz6h/oqbqEGTUauXuJI/vHqi6hJYqD7eDivnbWAQAAJJR9VDX7PbvN5lTVJcxoYLA4EqaW+1MKAAAAsyiO59lHEAAAgNbLvpwpe0c5u/Gx3B3lUj4FAAAAdDTBFgAAgI5WPIo8MV6PFjUAAFAu+3Km7LJvRZ6anKi6hJYoDrZ9/bnXaAMAAK3XaCyouoQZ5Q/euXcV1SXn5X58AAAAALMo7tguHHSPLQAAdJvsW4ez396Sfat0/4B7bAEAAKBygi0AAAAdrbjv3GzmbvEDAACtl385E3NRl5xXHGx7euuxLQsAACiXfity8jOs2R8MZL+OqFQ93gUAAABdqx4rsAAAABLK3vGuCx1bAAAAOlpxx7Z/wBlbAADoNtnPYDabU1WXMKPsZ2wXL6tHzisOttkvPgYAAFov+9Zco75zU5ecl/vxCwAAAMyiuGO7f++BdtYBAAAklL2j19unVzcXoyPjVZfQEsXBdmIs9+w6AADQetnPiGY/A7wg+aj0xP56BNvcnwIAAACYRXHHdumKgXbWAQAAJJR91HdyMvdkaXMqd8d78dL+qktoCVuRAQAA2qTRk3sUuS45L/fjFwAAAJhFccd2cHE9WtQAAEC57PfEZu84Zl++VZecV74VeXyynXUAAAAJZQ9m2Ud9s5tKfka5lFFkAAAAOlpxx/bAqI4tAAB0m+xbfbNvbc4+yj0+Vo+ObXGwXbzUdT8AANBtsgdHZ2znZuFgX9UltETuTykAAADMorhjOzY60c46AACAhLJ3HLMvj8pe3/hYPY6c6tgCAADQ0co7tgfqkeQBAIBy2c+w9g/0VF3CjBqN3L3EkdGxqktoieJgu+z/DLazDgAAIKHswTF78G42c28drsuS4NyPDwAAAGAWxR3biXGjyAAA0G0sj5qb7PVNTubuKJcqDrbZLxYGAADIpjmV+8FA9nuKS9XjXQAAANC1iju2I/vH21kHAACQUPblTNmXW/X25q7vpZF65LziYDu4uK+ddQAAAAllH1XNfgY4+1bk7A8GSuX+lAIAAMAsiju2oyMT7awDAABIyCjy3DQauXuJI/vHqi6hJYqD7dLlC9tZBwAAkFD24Jg9eEfkrm/x0oGqS2iJ3I8PAAAAYBavYityPVrUAABAuewd0ezLrbKPInfdVuRhwRYAALrO5GTuYDswmPv2luzBe/S5egTb3L9lAAAAmEVxx/aNKw9rZx0AAEBCixb3V13CjEaTj9Jmv2f3qDcsr7qElngV1/3k/sAAAACtNzk5VXUJM8o+6tucyh1sx0brca1r7k8BAAAAzOJVdGzrkeQBAIBy2bciZ79nt7c3d3112YqsYwsAAEBHK+7YDgwWvxQAAKiJ9GdYky9najZzn1HO3vEuVR5sF+a+HwoAAGi9RmNB1SXMKPuodPbgPZh863Wp3I9fAAAAYBbFHdtGT+4nNQAAQOs1Grl7YdlHfbN3bLN35EsVB9u6tKgBAIByC5IHn+zBcWoy96h0Xc7Y5n78AgAAALMo7tjufm64nXUAAAAJTYxPVl3CjNJ3HJPXt3/vgapLaInyM7bJRxAAAACyaU7lHpXOfp1TqXq8CwAAALpW+T22g+6xBQCAbpN9cnN8LPdW5Ox6enOPSpcqDrb9/fV4wwAAQLnswac5mvsM8HTyrc3pzygXMooMAABARyvu2I6Pa/EDAEC3mZrMnQOyj0rnvsU2YnIie4VlioNtXd4wAABQH9mDbfb6pibrkfOMIgMAANDRiju22UcQAACA1msmX37U6MndEc1+j22zWY+ObXGwPZB82xgAANB62YNZb1/uIdTso8h1uS4p96cAAAAAZrFgeno69yMYAAAAmIGOLQAAAB1NsAUAAKCjCbYAAAB0NMEWAACAjibYAgAA0NEEWwAAADqaYAsAAEBHE2wBAADoaIItAAAAHe3/AsmNL/FAMM+fAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4IAAAEPCAYAAAAXuHpOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAQG0lEQVR4nO3dXYjcd73H8W8m261ux01Po3kwKmljI2LMxppuotGVWixqQAopAcspiW1FL7TEQbsnwRKQsARN1QXBLCq0c6EpFVPwoqCimLYmWDbBbFLaxbiBeOFT1k07IdU2O+eiOLCndROO2flt5/t6wUL///ldfG5y8e5/HhY0m81mAAAAkEal9AAAAADaSwgCAAAkIwQBAACSEYIAAADJCEEAAIBkhCAAAEAyQhAAACAZIQgAAJCMEAQAAEhGCAIAACQjBAEACnv55ZejXq/H5s2bY8mSJdHV1RVLly6N2267Ler1ely8eLH0RKDDLGg2m83SIwAAshobG4utW7fGn//85/jMZz4T69evj7e//e1x7ty5OHLkSNTr9XjLW94SjzzySKxatar0XKBDFA/BzZs3x7PPPhunTp2acb/ZbEZ/f390d3fHU089VWgdAMDcOXnyZHzwgx+MO++8M/bt2xfXXHPNq85cuHAhvvSlL8Xjjz8ev/nNb2LFihUFlgKdpvhbQ9etWxcTExPRaDRm3K/X6zE6OhrDw8OFlkH7NJvNePnlly/rD4DOcPHixdi6dWvcc8898d3vfvc1I7DZbEZ3d3fs378/PvKRj8TnP//5AkuBTlQ8BPv6+qLZbMbJkydb986fPx+7du2Kbdu2xfr161v3Dx8+HJVKJfbs2VNiKsyZX//613HVVVdd1t/p06dLzwXgCjhw4ECcP38+9u7dGxER09PT8bWvfS1WrFgRb3zjG2PLli2xb9++uPXWWyMi4lvf+lb84he/iN///vclZwMdoqv0gL6+voh45f3xGzZsiIiIvXv3xvPPPx9DQ0Otc9PT07Fjx47o7+8vshPm0vvf//54+umnL+vsW9/61jleA0A7PPbYY7F9+/bo7u6OiIjvfOc78fWvfz2Ghobive99bxw8eDAeeOCB2LhxY0RELF68OD7wgQ/Er371q3jnO99ZcjrQAYqH4I033hg9PT0xNjYWERFnzpyJBx98MB544IFYvnx569zIyEhs2rQpJicnS02FOVOtVmPdunWXdbarq/g/WwCugPHx8fj0pz/duh4ZGYmdO3fGfffdFxERt9xyS5w4cSKmp6dbZ5YuXRp//etf274V6DzF3xpaqVRizZo1rRAcHByMZcuWRa1Wa505e/ZsDA8Px+7du0vNhDnlraEA+bz00kvxhje8oXU9MTERN91004wzN99884zrP/7xj/HmN7+5LfuAzjYvHi309fXFwYMH48iRI3HgwIF49NFH4+qrr269vnPnzqjVarFo0aKCK2HueGsoQD7veMc7Ynx8PD75yU9GxCtP+/7v/+ybmJho/ff4+Hj89re/jYcffridM4EONW9C8Hvf+17cfffdMTAwEFu2bGm9Njo6GkePHo39+/cXXAhz601vetOML0YCoPPddtttceDAgdixY0dERGzdujWGhoZizZo1sXbt2vjpT38aBw8ejI0bN8bPf/7z+NznPhdf+MIX4oYbbig7HOgIxX9HMCLiySefjA9/+MNRqVRidHR0xmelvv3tb8euXbuip6cnIiIajUYsXLgwtmzZEvV6vdBiAID/zNTUVKxatSq++c1vxrZt26LRaMRdd90Vjz32WES88j0Kt99+e3zjG9+IpUuXxle+8pWo1WqxYMGCssOBjjAvQnA2jUYjpqamWte1Wi1WrlwZg4ODsXjx4nLDAAD+Qz/+8Y/jrrvuiocffji2bt0aERF/+ctfYnJyMt71rnfF3//+95iamorrr79eAAJX1Lx4a+hsqtVqVKvV1nVPT0/09vaKQADgde+OO+6IF198MbZv3x71ej0++9nPRn9/f6xcuTL+9Kc/tT4T+MILL8TPfvYzMQhcMfP+iSAAQKebmJiIoaGh+MlPfjLjp7KWL18ed955Z9x///2xZMmSgguBTiMEAQDmienp6Thz5kycO3currvuunjb295WehLQoYQgAABAMsV/UB4AAID2EoIAAADJCEEAAIBkLvvnI6YPfXkud8wblYF9pScAAADMKU8EAQAAkhGCAAAAyQhBAACAZIQgAABAMkIQAAAgGSEIAACQjBAEAABIRggCAAAkIwQBAACSEYIAAADJCEEAAIBkhCAAAEAyQhAAACAZIQgAAJCMEAQAANrm9OnTsWDBgsv6e+6550rP7VhdpQcAAAB5XHfddXH48OHWdaPRiI997GNx++23x+Dg4Iyzq1evbve8NIQgAADQNr29vbFx48bW9VNPPRUREbfeeuuM+8wtbw0FAACKOXr0aERE3HTTTYWX5CIEAQCAYo4dOxaVSiX6+vpKT0lFCAIAAMUcO3YsVq9eHddcc82/PXP48OGoVCqxZ8+eNi7rbEIQAAAo4p///GecPHly1reFTk9Px44dO6K/v7+NyzqfL4sBAACKOHHiRLz00kuzhuDIyEhs2rQpJicn27is83kiCAAAFHHs2LGI+PdfFHP27NkYHh6O3bt3t3NWCkIQAAAo4l/fGPq+973vNV/fuXNn1Gq1WLRoUTtnpSAEAQCAIo4dOxbXX399XHvtta96bXR0NI4ePRr33ntv+4cl4DOCAABA201PT8fx48fj4x//+Gu+/sQTT8QzzzwTS5YsiYiIRqMRCxcujPHx8ajX6+2c2pEWNJvN5uUcnD705bneMi9UBvaVngAAAOk1Go2YmppqXddqtVi5cmUMDg7G4sWLyw3rEJ4IAgAA8061Wo1qtdq67unpid7eXhF4hQhBAABg3nvooYdKT+goviwGAAAgGSEIAACQjBAEAABIRggCAAAkIwQBAACS8a2hAABwBTWnflR6wqzO9WwoPeGSXrzYW3rCrJae/n7pCbNa8O7/ueQZTwQBAACSEYIAAADJCEEAAIBkhCAAAEAyQhAAACAZIQgAAJCMEAQAAEhGCAIAACQjBAEAAJIRggAAAMkIQQAAgGSEIAAAQDJCEAAAIBkhCAAAkIwQBAAASEYIAgAAJCMEAQAAkhGCAAAAyQhBAACAZIQgAABAMkIQAAAgGSEIAACQTNflHnxy1Vfncse8MVB6AAAAwBzzRBAAACAZIQgAAJCMEAQAAEhGCAIAACQjBAEAAJIRggAAAMkIQQAAgGSEIAAAQDJCEAAAIBkhCAAAkIwQBAAASEYIAgAAJCMEAQAAkhGCAMxLP/jBD6JarUa1Wo3u7u646qqrWtcf/ehHS88DgNc1IQjAvHTPPfdEo9GIRqMR27dvjy9+8Yut61/+8pel5wHA65oQBGDeO378eKxdu7b0DADoGF2lBwDAbJrNZpw4cUIIAq8b53o2lJ4wq2svPF16wiU1L7xQesKsnl12X+kJs3r3ZZzxRBCAee3UqVPxj3/8I97znveUngIAHUMIAjCv/e53v4vVq1fH1VdfXXoKAHQMIQhA223evDlWrVr1qvvNZjNuvvnm2LRpU+uezwcCwJUnBAFou3Xr1sXExEQ0Go0Z9+v1eoyOjsbw8HDrnhAEgCtPCALQdn19fdFsNuPkyZOte+fPn49du3bFtm3bYv369a37QhAArjzfGgpA2/X19UVExNjYWGzY8Mq36+3duzeef/75GBoamnH21KlTbd8HAJ3OE0EA2u7GG2+Mnp6eGBsbi4iIM2fOxIMPPhi7du2K5cuXzzh7+PDhqFQqsWfPnhJTAaAjCUEA2q5SqcSaNWtaITg4OBjLli2LWq0249z09HTs2LEj+vv7S8wEgI7lraEAFNHX1xcHDx6MI0eOxIEDB+LRRx991U9EjIyMxKZNm2JycrLQSgDoTJ4IAlBEX19f/O1vf4u77747BgYGYsuWLTNeP3v2bAwPD8fu3bsLLQSAzuWJIABF/OsLY5577rn44Q9/+KrXd+7cGbVaLRYtWtTuaQDQ8YQgAEV86EMfimaz+ZqvjY6OxtGjR2P//v1tXgUAOQhBAOadJ554Ip555plYsmRJREQ0Go1YuHBhjI+PR71eL7wOAF7/hCAA8869994bd9xxR+u6VqvFypUrY3BwsOAqAOgcQhCAeadarUa1Wm1d9/T0RG9vbyxevLjgKgDoHEIQgHnvoYceKj0BADqKn48AAABIRggCAAAkIwQBAACS8RlBgDkyfejLpSfM6slVXy09YVZjZ6ZKT5jVJ+7/VOkJs7rh0PHSEwCYxzwRBAAASEYIAgAAJCMEAQAAkhGCAAAAyQhBAACAZIQgAABAMkIQAAAgGSEIAACQjBAEAABIRggCAAAkIwQBAACSEYIAAADJCEEAAIBkhCAAAEAyQhAAACAZIQgAAJCMEAQAAEhGCAIAACQjBAEAAJIRggAAAMl0Xe7BsTNTczhj/hhYcW3pCQAAvI69eLG39IRZNS+8UHrCpZ2bLL1gVn/ovlB6wqze/V89lzzjiSAAAEAyQhAAACAZIQgAAJCMEAQAAEhGCAIAACQjBAEAAJIRggAAAMkIQQAAgGSEIAAAQDJCEAAAIBkhCAAAkIwQBAAASEYIAgAAJCMEAQAAkhGCAAAAyQhBAACAZIQgAABAMkIQAAAgGSEIAACQTFfpAQCdqjKwr/SEWQ2UHnAJAyuuLT1hdoeOl14AAP9vnggCAAAkIwQBAACSEYIAAADJCEEAAIBkhCAAAEAyQhAAACAZIQgAAJCMEAQAAEhGCAIAACQjBAEAAJIRggAAAMkIQQAAgGSEIAAAQDJCEAAAIBkhCAAAkIwQBAAASEYIAgAAJCMEAQAAkhGCAAAAyXSVHgAAAJ1k6envl54wq2eX3Vd6wiX9oftC6QmzumXkv0tPmN3exy95xBNBAACAZIQgAABAMkIQAAAgGSEIAACQjBAEAABIRggCAAAkIwQBAACSEYIAAADJCEEAAIBkhCAAAEAyQhAAACAZIQgAAJCMEAQAAEhGCAIAACQjBAEAAJIRggAAAMl0Xe7BT9z/qbncMX8cOl56AQAAwJzyRBAAACAZIQgAAJCMEAQAAEhGCAIAACQjBAEAAJIRggAAAMkIQQAAgGSEIAAAQDJCEAAAIBkhCAAAkIwQBAAASEYIAgAAJCMEAQAAkhGCAAAAyQhBAACAZIQgAABAMkIQAAAgGSEIAACQjBAEAABIRggCAAAkIwQBAACSEYIAAADJLGg2m83LOfiHgbVzvWVeuOHQ8dITAAAA5pQnggAAAMkIQQAAgGSEIAAAQDJCEAAAIBkhCAAAkIwQBAAASEYIAgAAJCMEAQAAkhGCAAAAyQhBAACAZIQgAABAMkIQAAAgGSEIAACQjBAEAABIRggCAAAkIwQBAACSEYIAAADJCEEAAIBkhCAAAEAyQhAAACAZIQgAAJCMEAQAAEhGCAIAACQjBAEAAJIRggAAAMkIQQAAgGSEIAAAQDJCEAAAIBkhCAAAkIwQBAAASEYIAgAAJCMEAQAAkhGCAAAAyQhBAACAZBY0m81m6REAAAC0jyeCAAAAyQhBAACAZIQgAABAMkIQAAAgGSEIAACQjBAEAABIRggCAAAkIwQBAACSEYIAAADJ/C+kTSkxPmwXzQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "v4 = V[:, 3].reshape((-1, 1))\n", + "plot_four_figs(X, v4, 4) # 第四个基向量" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecd322f4-f919-4be2-adc3-69d28ef25e69", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Book4_Ch10_Python_Codes/Streamlit_Bk4_Ch10_01.py b/Book4_Ch10_Python_Codes/Streamlit_Bk4_Ch10_01.py new file mode 100644 index 0000000..d923b9b --- /dev/null +++ b/Book4_Ch10_Python_Codes/Streamlit_Bk4_Ch10_01.py @@ -0,0 +1,111 @@ + +############### +# Authored by Weisheng Jiang +# Book 4 | From Basic Arithmetic to Machine Learning +# Published and copyrighted by Tsinghua University Press +# Beijing, China, 2025 +############### + +## 导入必要的库 +import streamlit as st # 导入 Streamlit，用于创建交互式 Web 应用 +import plotly.express as px # 导入 Plotly Express，用于绘图 + +import seaborn as sns # 导入 Seaborn，用于数据可视化 +import numpy as np # 导入 NumPy，用于数值计算 +import matplotlib.pyplot as plt # 导入 Matplotlib，用于绘图 +import pandas as pd # 导入 Pandas，用于数据处理 +from sklearn.datasets import load_iris # 从 scikit-learn 导入 Iris 数据集 + +## 定义函数 bmatrix，用于生成 LaTeX 矩阵 +def bmatrix(a): + """返回一个 LaTeX 矩阵""" + if len(a.shape) > 2: # 检查输入是否为二维数组 + raise ValueError('bmatrix 函数最多显示二维矩阵') # 如果不是二维，抛出异常 + lines = str(a).replace('[', '').replace(']', '').splitlines() # 将数组转为字符串并去除括号 + rv = [r'\begin{bmatrix}'] # 开始 LaTeX 矩阵的格式 + rv += [' ' + ' & '.join(l.split()) + r'\\' for l in lines] # 为每一行添加 LaTeX 格式 + rv += [r'\end{bmatrix}'] # 结束 LaTeX 矩阵的格式 + return '\n'.join(rv) # 将所有行连接为字符串并返回 + +## 加载 Iris 数据集 +iris = load_iris() # 加载 Iris 数据集 +X = iris.data # 提取特征数据 +y = iris.target # 提取目标标签 + +## 定义特征名称 +feature_names = ['Sepal length, x1', 'Sepal width, x2', + 'Petal length, x3', 'Petal width, x4'] # 定义特征名称 + +## 将特征数据转换为 DataFrame +X_df = pd.DataFrame(X, columns=feature_names) # 创建 DataFrame，列名为特征名称 + +## 原始数据 X +X = X_df.to_numpy() # 将 DataFrame 转换为 NumPy 数组 + +## 计算 Gram 矩阵和正交基 +G = X.T @ X # 计算 Gram 矩阵 G +D, V = np.linalg.eig(G) # 对 Gram 矩阵求特征值和特征向量 +np.set_printoptions(suppress=True) # 设置 NumPy 打印选项，抑制科学记数法 +D = np.diag(D) # 将特征值转换为对角矩阵 + +## 在 Streamlit 应用中展示计算结果 +st.latex(r'G = X^T X = ' + bmatrix(G)) # 展示 Gram 矩阵 G 的 LaTeX 表示 +st.latex(r'G = V \Lambda V^T') # 展示特征分解公式 +st.latex(r'G = ' + + bmatrix(np.round(V, 2)) + '@' + + bmatrix(np.round(D, 2)) + '@' + + bmatrix(np.round(V.T, 2))) # 展示分解结果 +st.write('Mapped data:') # 显示映射数据标题 +st.latex('Z = XV') # 显示 Z 的 LaTeX 表示 + +## 映射数据 Z +Z = X @ V # 计算映射数据 Z + +## 创建映射数据的 DataFrame +df = pd.DataFrame(Z, columns=['PC1', 'PC2', 'PC3', 'PC4']) # 创建 DataFrame，列名为主成分 +mapping_rule = {0: 'setosa', 1: 'versicolor', 2: 'virginica'} # 定义类别映射规则 +df.insert(4, "species", y) # 插入类别列 +df['species'] = df['species'].map(mapping_rule) # 应用类别映射 + +## 提取特征列名称 +features = df.columns.to_list()[:-1] # 提取特征列名称，不包括类别列 + +## 映射数据表格 +with st.expander('Mapped data'): # 创建可展开区域，标题为 "Mapped data" + st.write(df) # 显示映射数据的 DataFrame + +## 热力图 +with st.expander('Heatmap'): # 创建可展开区域，标题为 "Heatmap" + fig_1 = px.imshow(df.iloc[:, 0:4], # 绘制热力图，仅包含特征列 + color_continuous_scale='RdYlBu_r') # 使用指定的颜色映射 + st.plotly_chart(fig_1) # 显示热力图 + +## 2D 散点图 +with st.sidebar: # 创建侧边栏 + st.write('2D scatter plot') # 显示标题 "2D scatter plot" + x_feature = st.radio('Horizontal axis', features) # 在侧边栏中选择横轴特征 + y_feature = st.radio('Vertical axis', features) # 在侧边栏中选择纵轴特征 + +with st.expander('2D scatter plot'): # 创建可展开区域，标题为 "2D scatter plot" + fig_2 = px.scatter(df, x=x_feature, y=y_feature, color="species") # 绘制 2D 散点图 + st.plotly_chart(fig_2) # 显示 2D 散点图 + +## 3D 散点图 +with st.expander('3D scatter plot'): # 创建可展开区域，标题为 "3D scatter plot" + fig_3 = px.scatter_3d(df, # 绘制 3D 散点图 + x='PC1', + y='PC2', + z='PC3', + color='species') # 按类别着色 + st.plotly_chart(fig_3) # 显示 3D 散点图 + +## 成对散点图 +with st.expander('Pairwise scatter plot'): # 创建可展开区域，标题为 "Pairwise scatter plot" + fig_4 = px.scatter_matrix(df, # 绘制成对散点图 + dimensions=["PC1", "PC2", "PC3", "PC4"], # 指定维度 + color="species") # 按类别着色 + st.plotly_chart(fig_4) # 显示成对散点图 + + + +