# 📚 3-1-2 衔接与拓展：从图像矩阵到文本向量 --- # 🎯 本章小结：图像处理的完整流程 在3-1-2中，我们学习了图像数据的本质和基本操作。让我来详细回顾一下： ## 图像的表示：为什么图像可以表示为矩阵？ 当我们用相机拍摄一张照片时，图像是如何在计算机中存储的？ ``` ←——— 宽度（W）———→ ┌─────────────────────────────────┐ ┐ │ 像素点(0,0) 像素点(0,1) ... │ │ │ 像素点(1,0) 像素点(1,1) ... │ │ 高度（H） │ ... ... ... │ │ │ 像素点(H-1,0) ... ... │ │ └─────────────────────────────────┘ ┘ ``` **关键点：** - 图像由**像素点**组成，每个像素点有一个位置 (x, y) - 每个像素点的**亮度**（灰度图）或**颜色**（彩色图）可以用数字表示 - 因此，整张图像可以用一个**数字矩阵**来表示 ### 灰度图像 → 二维矩阵 ```python import numpy as np # 假设一张 4x4 的灰度图像 image = np.array([ [255, 200, 150, 100], [180, 140, 110, 80], [120, 90, 60, 40], [50, 30, 20, 10] ]) # 255 = 最亮（白），0 = 最暗（黑） ``` **图像属性：** - 形状：(H, W) = (4, 4) - 每个元素：0~255 的整数（uint8类型） - 本质：一个二维数组/矩阵 ### 彩色图像 → 三维矩阵 彩色图像用RGB三个通道表示颜色： ```python # 彩色图像：高度 x 宽度 x 3（红、绿、蓝三通道） color_image = np.array([ [[255, 0, 0], [0, 255, 0], [0, 0, 255]], # 第1行像素：红、绿、蓝 [[255, 255, 0], [0, 255, 255], [255, 0, 255]], # 第2行像素：黄、青、紫 [[128, 128, 128],[100, 100, 100],[50, 50, 50]] # 第3行像素：灰度 ]) ``` **图像属性：** - 形状：(H, W, 3) = (3, 3, 3) - 每个位置有3个数值，分别代表R、G、B的分量 - 本质：一个三维数组/矩阵 --- # 📘 NumPy 快速入门 NumPy是Python中用于数值计算的核心库，专门处理数组和矩阵。我们的图像处理和文本向量化都离不开它。 ## 安装与导入 ```bash pip install numpy ``` ```python import numpy as np ``` ## 创建数组 ### 从列表创建 ```python # 一维数组（向量） vec = np.array([1, 2, 3, 4, 5]) print(vec) # [1 2 3 4 5] # 二维数组（矩阵） mat = np.array([ [1, 2, 3], [4, 5, 6] ]) print(mat) # [[1 2 3] # [4 5 6]] ``` ### 快速创建特殊数组 ```python # 全0数组 - 常用于初始化 zeros = np.zeros((3, 4)) # 3行4列的全0矩阵 print(zeros) # [[0. 0. 0. 0.] # [0. 0. 0. 0.] # [0. 0. 0. 0.]] # 全1数组 ones = np.ones((2, 3)) # [[1. 1. 1.] # [1. 1. 1.]] # 指定范围内的数组 arr = np.arange(0, 10, 2) # 0到10，步长2 print(arr) # [0 2 4 6 8] # 等差数组 lin = np.linspace(0, 1, 5) # 0到1之间均匀取5个数 print(lin) # [0. 0.25 0.5 0.75 1. ] ``` ## 查看数组属性 ```python a = np.array([[1, 2, 3], [4, 5, 6]]) print(a.ndim) # 维度数量 = 2（是二维数组/矩阵） print(a.shape) # 形状 = (2, 3) 2行3列 print(a.size) # 总元素数 = 6 print(a.dtype) # 数据类型 = int64 # 对于图像数据，常用 uint8（无符号8位整数，0-255） image = np.array([[255, 128], [64, 0]], dtype=np.uint8) print(image.dtype) # uint8 ``` ## 数组索引和切片 ### 基本索引 ```python a = np.array([10, 20, 30, 40, 50]) print(a[0]) # 第一个元素 = 10 print(a[-1]) # 最后一个元素 = 50 print(a[1:3]) # 第2到第3个元素 = [20, 30] print(a[:3]) # 前3个元素 = [10, 20, 30] print(a[2:]) # 第3个到最后 = [30, 40, 50] ``` ### 二维数组索引 ```python mat = np.array([ [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12] ]) # 获取特定元素 print(mat[0, 0]) # 第1行第1列 = 1 print(mat[1, 2]) # 第2行第3列 = 7 print(mat[2, -1]) # 第3行最后一列 = 12 # 切片：[行, 列] print(mat[0, :]) # 第1行所有列 = [1, 2, 3, 4] print(mat[:, 1]) # 所有行第2列 = [2, 6, 10] print(mat[0:2, 0:2]) # 取前2行前2列 # [[1 2] # [5 6]] # 负索引 print(mat[-1, :]) # 最后一行 = [9, 10, 11, 12] ``` ## 数组运算 ### 基础数学运算 ```python a = np.array([1, 2, 3]) b = np.array([4, 5, 6]) # 加减乘除（对应元素运算） print(a + b) # [5 7 9] print(a - b) # [-3 -3 -3] print(a * b) # [4 10 18] 注意：这是元素乘法，不是矩阵乘法 print(a / b) # [0.25 0.4 0.5] # 标量运算（广播） print(a * 2) # [2 4 6] print(a + 10) # [11 12 13] print(a ** 2) # [1 4 9] 平方 ``` ### 矩阵乘法（重要！） ```python A = np.array([[1, 2], [3, 4]]) B = np.array([[5, 6], [7, 8]]) # 使用 @ 运算符 或 np.dot() C = A @ B print(C) # [[19 22] # [41 46]] # 或者 C = np.dot(A, B) print(C) ``` ### 常用统计函数 ```python a = np.array([1, 2, 3, 4, 5]) print(np.sum(a)) # 求和 = 15 print(np.mean(a)) # 平均值 = 3.0 print(np.max(a)) # 最大值 = 5 print(np.min(a)) # 最小值 = 1 print(np.std(a)) # 标准差 print(np.argmax(a)) # 最大值的索引 = 4 print(np.argmin(a)) # 最小值的索引 = 0 # 对于二维数组，可以指定轴 mat = np.array([[1, 2, 3], [4, 5, 6]]) print(np.sum(mat, axis=0)) # 按列求和 = [5 7 9] print(np.sum(mat, axis=1)) # 按行求和 = [6 15] ``` ## 数组变形 ```python a = np.array([1, 2, 3, 4, 5, 6]) # 展平（flatten）: 多维变一维 print(a.flatten()) # [1 2 3 4 5 6] # 改变形状（reshape） b = a.reshape(2, 3) # 变成2行3列 print(b) # [[1 2 3] # [4 5 6]] # 转置（transpose）: 行变列 print(b.T) # [[1 4] # [2 5] # [3 6]] # 翻转 c = np.array([[1, 2, 3], [4, 5, 6]]) print(np.fliplr(c)) # 左右翻转 # [[3 2 1] # [6 5 4]] print(np.flipud(c)) # 上下翻转 # [[4 5 6] # [1 2 3]] ``` ## 条件筛选 ```python a = np.array([10, 20, 30, 40, 50]) # 找出满足条件的元素 print(a > 25) # [False False False True True] print(a[a > 25]) # [30 40 50] 只保留大于25的值 # 统计满足条件的数量 print(np.sum(a > 25)) # 3 # 替换值 b = np.where(a > 25, a, 0) # 大于25保留，否则改成0 print(b) # [0 0 30 40 50] ``` ## 范数与点积 ```python a = np.array([3, 4]) # L2范数（欧几里得距离） norm = np.linalg.norm(a) print(norm) # 5.0 (因为 3² + 4² = 25, √25 = 5) # 点积（dot product） b = np.array([1, 2]) dot = np.dot(a, b) print(dot) # 3*1 + 4*2 = 11 # 余弦相似度 def cosine_similarity(a, b): return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)) v1 = np.array([1, 0, 1]) v2 = np.array([1, 1, 0]) print(cosine_similarity(v1, v2)) # 约 0.707 ``` ## 复制与引用（重要概念） ```python a = np.array([1, 2, 3]) b = a # 这是引用，不是复制！ b[0] = 100 print(a[0]) # 100，a也跟着变了 # 如果想复制，应该用 c = a.copy() c[0] = 999 print(a[0]) # 100，a不变 ``` --- ## 图像处理的本质：矩阵运算 当我们对图像进行处理时，实际上是在对矩阵做运算： ### 1. 亮度和对比度调整 ```python # 亮度调整：所有像素值加一个常数 brighter = image + 30 # 变亮 darker = image - 30 # 变暗 # 对比度调整：像素值乘以一个系数 contrasted = image * 1.5 # 对比度增强 ``` ### 2. 裁剪和旋转（矩阵切片与变换） ```python # 裁剪：取矩阵的一部分 top_left = image[0:2, 0:2] # 取左上角2x2区域 # 旋转：矩阵转置和翻转 rotated = np.transpose(image) # 转置 flipped = np.fliplr(image) # 左右翻转 ``` ### 3. 模糊和锐化（卷积核） ```python # 平均模糊：用一个3x3的"均值滤波器" blur_kernel = np.array([ [1/9, 1/9, 1/9], [1/9, 1/9, 1/9], [1/9, 1/9, 1/9] ]) # 用这个kernel"扫过"整张图像，求局部平均值 # 锐化：增强边缘 sharpen_kernel = np.array([ [0, -1, 0], [-1, 5, -1], [0, -1, 0] ]) ``` --- ## 图像特征提取：从矩阵到向量 ### 边缘检测 - 找出图像中的"突变" ```python # 简单的边缘检测：检测相邻像素的亮度变化 sobel_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]) sobel_y = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]]) # 应用卷积核后的结果就是边缘图 # 边缘就是亮度发生突变的地方 ``` ### 从特征图到特征向量 ```python # 假设我们提取了边缘特征，得到一个特征图 feature_map = np.array([ [255, 200, 0, 50], [180, 0, 100, 30], [0, 90, 150, 0], [50, 0, 30, 10] ]) # 把特征图"展平"成一个向量 feature_vector = feature_map.flatten() # 结果: [255, 200, 0, 50, 180, 0, 100, 30, 0, 90, 150, 0, 50, 0, 30, 10] # 这个向量就是这张图像的"特征表示" # 可以用来比较两张图像是否相似 ``` --- ## 📊 图像数据的特点总结 | 特性 | 描述 | 示例 | |------|------|------| | **结构化** | 有固定的空间位置关系 | 像素(0,0)紧邻像素(0,1) | | **局部性** | 相邻像素通常相关 | 同一物体的像素值相近 | | **维度固定** | H×W×C，维度明确 | 1920×1080×3 | | **连续空间** | 像素间有物理意义 | 距离、角度、边缘 | | **视觉直观** | 人眼可直接理解 | 看到图片就知道是什么 | ``` 图像数据的本质： ↓ 📐 空间结构化数据 ↓ 矩阵表示 (H × W × C) ↓ 空间关系很重要（邻居关系定义了边缘、纹理） ``` --- --- # 🚀 转折：如果数据不是图像呢？ 我们来看一个实际的AI应用场景： ## 案例：智能新闻推荐系统 假设你是一个新闻App的AI工程师，需要做一个"相似文章推荐"功能： ``` 用户点击了一篇文章《Python入门指南》 系统需要找到与它最相似的其他文章 ``` **问题来了：文章是文字，不是像素，怎么处理？** ``` 文字 → ??? → 向量 → 计算相似度 → 推荐结果 ``` --- # 📖 从图像到文本：两种截然不同的数据 ## 图像 vs 文本：数据结构对比 让我们来仔细对比一下图像和文本的本质区别： ### 图像数据的结构 ``` 图像：一幅画 ┌─────────────────────────────────┐ │ ████████████████████████████ │ │ ████████████████████████████ │ │ ████████ 主体 ██████████████ │ │ ████████████████████████████ │ │ ████████████████████████████ │ └─────────────────────────────────┘ ↓ 表示为矩阵 ↓ [ [255, 255, 200, 180, ...], # 第1行像素 [255, 255, 190, 170, ...], # 第2行像素 [200, 190, 150, 140, ...], # 第3行像素（主体部分） ... ] ``` **特点：** - 每个像素有明确的位置 (x, y) - 位置本身就携带信息（空间关系） - 连续分布，相邻像素高度相关 - 可以用坐标直接访问：`pixel = image[100, 200]` ### 文本数据的结构 ``` 文本：一篇文章 "Python是一门广泛使用的高级编程语言" ↓ 表示为词语序列 ↓ ["Python", "是", "一门", "广泛", "使用", "的", "高级", "编程", "语言"] ``` **特点：** - 由离散的符号（字、词）组成 - 顺序重要，但位置是逻辑顺序而非空间位置 - 词语之间通过语法和语义关联，而非物理邻近 - 无法用坐标直接访问：`word = text[3]` 只是第3个词 --- ## ⚠️ 文本和图像的本质区别（重点！） 这是理解文本数据处理的关键，请仔细阅读： ### 区别一：表示方式不同 | 维度 | 图像 | 文本 | |------|------|------| | **基本单位** | 像素 | 词语/字符 | | **排列方式** | 二维空间网格 | 一维线性序列 | | **位置意义** | 空间坐标 (x, y) 有物理含义 | 序列位置 (index) 是逻辑顺序 | | **相邻关系** | 物理上相邻的像素通常相关 | 相邻的词可能在语法上无关 | ```python # 图像：你可以说"pixel[10, 20]的邻居是[10,19], [10,21], [9,20], [11,20]" # 这些邻居在空间上确实紧邻 # 文本：你可以说"第5个词的邻居是第4个和第6个词" # 但这种"邻居"关系远不如图像的像素邻居那么紧密 ``` ### 区别二：语义组织方式不同 **图像：** 语义通过空间结构体现 ``` 一只猫在沙发上 ┌─────────────────────┐ │ 猫（位置固定） │ ← 猫的空间位置+形状+颜色 = 猫的概念 │ ████ │ │ ██████ 沙发 │ │ ████████████████████│ └─────────────────────┘ ``` **文本：** 语义通过符号组合体现 ``` "一只猫坐在沙发上" ["一只", "猫", "坐", "在", "沙发", "上"] ↓ ↓ ↓ ↓ ↓ ↓ 数量 主体 动作 位置 地点 方向 ``` **关键洞察：** - 图像中，"猫"这个概念是通过**像素的空间排列**直接体现的 - 文本中，"猫"这个概念是通过**符号"猫"**来代表的 - 文本必须经过"符号→含义"的映射，才能理解语义 ### 区别三：维度特性不同 ``` 图像的维度： - 固定且明确：H × W × C - 连续空间，维度代表物理尺寸 文本的维度： - 不固定：可以任意长度的句子/文章 - 离散的符号序列 - "维度"通常指词汇表大小，而不是"长度" ``` ### 区别四：相似性判断方式不同 **图像相似度：** 通常基于视觉特征 ```python # 两张猫的图片相似 # → 像素级别的特征相似（颜色分布、边缘形状、纹理） # → 在特征空间中距离近 ``` **文本相似度：** 基于语义内容 ```python # 两篇关于"猫"的新闻相似 # → 都包含"猫"这个词 # → 讨论的主题相关 # → 即使词语不同，含义可能相近 ``` --- ## 📝 文本数据处理的挑战 正因为文本和图像有这些本质区别，文本处理面临独特的挑战： ### 挑战1：如何把符号变成数字？ 图像天然就是数字（像素值），但文本是符号： ``` "Python" → ??? → [?, ?, ?, ...] ``` ### 挑战2：如何处理"一词多义"？ ``` "苹果" 可以指： - 一种水果（营养丰富） - 一家公司（Apple Inc.） - 手机品牌（苹果手机） ``` 同一个词，不同上下文，意思完全不同。 ### 挑战3：如何处理语法和语义？ ``` "我爱你" vs "你爱我" - 词语完全相同，只是顺序不同 - 意思完全相反 ``` ### 挑战4：如何处理省略和指代？ ``` "小明喜欢编程。他觉得代码很有趣。" - "他"指的是谁？ → 需要理解指代关系 - "代码"是什么？ → 需要理解上下文 ``` --- ## 🔑 核心：从符号到向量 无论挑战有多少，文本数据处理的核心目标只有一个： ``` 文本（符号序列）→ 数值向量 → 可计算 → AI模型处理 ``` 这就是**文本向量化**，它是文本数据处理的第一步，也是最关键的一步。 --- # 📖 3-2 预告：文本数据处理 ## 文本向量化的简单例子 假设我们有一个很小的词汇表（实际中有上万个词）： ```python # 词汇表 vocab = ["Python", "学习", "入门", "指南", "人工智能", "数据"] # 两篇文章 doc1 = "Python学习入门指南" doc2 = "Python人工智能数据" doc3 = "数据数据分析" ``` **用词频（BoW）方法把文本变成向量：** ```python import numpy as np def text_to_vector(text, vocab): """把文本转换为词频向量""" words = text.split() vector = np.zeros(len(vocab)) for i, word in enumerate(vocab): vector[i] = words.count(word) return vector # 词汇表 vocab = ["Python", "学习", "入门", "指南", "人工智能", "数据"] # 三篇文章的向量 v1 = text_to_vector("Python学习入门指南", vocab) v2 = text_to_vector("Python人工智能数据", vocab) v3 = text_to_vector("数据数据分析", vocab) print("doc1向量:", v1) # [1, 1, 1, 1, 0, 0] print("doc2向量:", v2) # [1, 0, 0, 0, 1, 1] print("doc3向量:", v3) # [0, 0, 0, 0, 0, 2] # 计算相似度（余弦相似度） def cosine_similarity(a, b): return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)) print("\n=== 相似度计算 ===") print(f"doc1 vs doc2: {cosine_similarity(v1, v2):.3f}") # 应该较低 print(f"doc1 vs doc1: {cosine_similarity(v1, v1):.3f}") # = 1.0（自己和自己） ``` **运行结果：** ``` doc1向量: [1. 1. 1. 1. 0. 0.] doc2向量: [1. 0. 0. 0. 1. 1.] doc3向量: [0. 0. 0. 0. 0. 2.] === 相似度计算 === doc1 vs doc2: 0.200 doc1 vs doc1: 1.000 ``` **结论：** - doc1和doc1完全相似（当然） - doc1和doc2有一点点相似（都有"Python"） - 这说明向量相似度可以反映文本的内容相似度 --- ## 图像与文本的本质统一 尽管图像和文本有很大区别，但**最终的表示是统一的**： ``` ┌──────────────────────────────────────┐ │ 原始数据 │ │ (图像：像素 / 文本：字符/词语) │ └─────────────────┬────────────────────┘ │ ▼ ┌──────────────────────────────────────┐ │ 数值化/向量化 │ │ 图像：矩阵 (H×W×C) │ │ 文本：向量 (N维) │ └─────────────────┬────────────────────┘ │ ▼ ┌──────────────────────────────────────┐ │ 预处理 │ │ 图像：调整亮度/对比度/裁剪 │ │ 文本：分词/去停用词/标准化 │ └─────────────────┬────────────────────┘ │ ▼ ┌──────────────────────────────────────┐ │ 特征提取 │ │ 图像：卷积核提取边缘/纹理/形状 │ │ 文本：Embedding提取语义特征 │ └─────────────────┬────────────────────┘ │ ▼ ┌──────────────────────────────────────┐ │ 特征向量 │ │ (统一的数值表示) │ └──────────────────────────────────────┘ ``` > **核心思想：** > - 图像是"**空间结构化**"的数据 → 矩阵 > - 文本是"**序列符号化**"的数据 → 向量 > - **最终都被转化为数值向量，供AI模型处理** > - 这就是深度学习的强大之处：**统一的表示，统一的处理** --- ## 📋 3-2 你将学到什么 | 知识点 | 内容 | 与图像的类比 | |-------|------|-------------| | **分词** | 把句子切成词语 | 就像图像分割，把整图切成区域 | | **停用词过滤** | 去掉"的、了、在"等无用词 | 就像图像去噪，去掉干扰信息 | | **词性标注** | 标出名词、动词、形容词... | 就像边缘检测，标记重要特征 | | **实体识别** | 识别人名、地名、机构名 | 就像目标检测，定位关键元素 | | **文本向量化** | 把文本变成数值向量 | **核心：和图像一样，最终都是向量！** | | **相似度计算** | 用向量距离判断相似程度 | 就像特征匹配 | --- # 📝 预习任务 在3-2开始之前，请思考以下问题： 1. **文字如何转成数字？** - 一段文字"Python很有趣"如何在计算机中表示？ 2. **词语如何切割？** - 英文 "I love Python" 很好分词 - 中文 "我喜欢Python" 怎么分？ 3. **哪些词是"噪音"？** - "的"、"了"、"在"这些词有多重要？ - 和图像去噪类比，文本需要"去"哪些词？ 4. **文本和图像最大的区别是什么？**（思考题） - 提示：从"结构"和"语义"两个角度思考 --- ## 📝 课堂练习 学完了图像数据处理，现在来动手写代码吧！ ### 练习1：图像矩阵操作 假设有一张 3×3 的灰度图像，用 NumPy 表示： ```python import numpy as np image = np.array([ [100, 150, 200], [80, 120, 180], [60, 90, 140] ], dtype=np.uint8) print("原图：") print(image) ``` **请完成以下操作（写出代码并运行）：** 1. **变暗20**：让图像每个像素值减20 2. **裁剪左上角**：只保留 `image[0:2, 0:2]`（2×2区域） 3. **水平翻转**：使用 `np.fliplr()` --- ### 练习2：看图写代码 以下代码定义了一个 4×4 的"图像矩阵"： ```python import numpy as np img = np.array([ [255, 255, 0, 0 ], [255, 255, 0, 0 ], [0, 0, 255, 255], [0, 0, 255, 255] ], dtype=np.uint8) ``` **请写出代码完成：** 1. 统计图像中白色像素（255）有多少个？黑色像素（0）有多少个？ 2. 将图像水平翻转后打印出来 3. 将图像逆时针旋转90度（提示：使用转置和翻转） --- ### 练习3：特征向量计算 以下代码创建了两张小型"特征图"： ```python import numpy as np # 假设这是从图像中提取的2个特征图 feature_map1 = np.array([[1, 0, 1], [0, 1, 0], [1, 0, 1]]) feature_map2 = np.array([[1, 1, 1], [1, 0, 0], [1, 0, 0]]) # 补全代码：将特征图展平为向量 vector1 = feature_map1.flatten() # 展平 vector2 = feature_map2.flatten() # 展平 print("vector1:", vector1) print("vector2:", vector2) ``` **请补全代码并运行：** 1. 计算 `vector1` 和 `vector2` 的欧几里得距离 2. 计算 `vector1` 和 `vector2` 的余弦相似度（公式：`cos = np.dot(a,b) / (np.linalg.norm(a) * np.linalg.norm(b))`） --- ### 练习4：文本向量化（预习挑战） 下面是一个简单的文本向量化示例（用词频表示文本）： ```python import numpy as np # 词汇表 vocab = ["Python", "学习", "数据", "人工智能", "编程"] # 两句话 doc1 = "Python学习编程" doc2 = "Python人工智能数据" def text_to_vector(text, vocab): words = text.split() vector = np.zeros(len(vocab)) for i, word in enumerate(vocab): vector[i] = words.count(word) return vector v1 = text_to_vector(doc1, vocab) v2 = text_to_vector(doc2, vocab) print("doc1向量:", v1) print("doc2向量:", v2) ``` **请运行代码并回答：** 1. `doc1` 和 `doc2` 的向量分别是什么？ 2. 补全代码：计算 `v1` 和 `v2` 的余弦相似度 3. 修改 `vocab`，加入词 `"机器"`，然后用 `doc3 = "机器学习"` 测试，看看向量是什么 --- ### 🌟 附加题 运行以下代码，理解为什么相似度不是1.0： ```python import numpy as np def cosine_similarity(a, b): return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)) v1 = np.array([1, 0, 1, 0]) v2 = np.array([2, 0, 0, 0]) print("v1:", v1) print("v2:", v2) print("相似度:", cosine_similarity(v1, v2)) # 思考：如何修改v2让相似度变成1.0？ # 提示：长度要一样 ``` **选做：** - 尝试用 `v2 = v1 * 2` 看看结果 - 再试试用 `v2 = v1 / np.linalg.norm(v1) * np.linalg.norm(v2)` 归一化后比较 ---