{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 3-2-1 文本数据处理导论\n", "## 课堂演示notebook\n", "\n", "---\n", "\n", "## 目录\n", "\n", "1. [什么是文本数据？](#第一部分-什么是文本数据)\n", "2. [计算机如何读取文本？](#第二部分-计算机如何读取文本)\n", "3. [向量基础入门](#第三部分-向量基础入门)\n", "4. [余弦相似度](#第四部分-余弦相似度)\n", "5. [文本向量化的核心思想](#第五部分-文本向量化的核心思想)\n", "6. [BoW词袋模型](#第六部分-bow词袋模型)\n", "7. [TF-IDF词频-逆文档频率](#第七部分-tf-idf)\n", "8. [Word Embedding词嵌入](#第八部分-word-embedding词嵌入)\n", "9. [文本处理完整流程](#第九部分-文本处理完整流程)\n", "10. [实战：用jieba进行中文分词](#第十部分-实战用jieba进行中文分词)\n", "\n", "---\n", "\n", "**注意**：运行本notebook需要安装以下依赖：\n", "```bash\n", "pip install numpy matplotlib jieba\n", "```\n", "- BoW和TF-IDF代码使用纯Python+NumPy实现，不依赖sklearn\n", "- 如果服务器没有中文字体，图表中的中文可能显示为方块，这是正常现象。\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 第一部分：什么是文本数据？\n", "\n", "## 1.1 文本数据的定义\n", "\n", "**文本数据**是由文字、符号组成的序列信息，是人类语言在计算机中的表示形式。\n", "\n", "### 生活中的文本数据例子\n", "\n", "| 类型 | 示例 |\n", "|------|------|\n", "| 一句话 | \"今天天气真好\" |\n", "| 一篇文章 | 一篇新闻报道 |\n", "| 一条评论 | \"这家餐厅的菜太好吃了！\" |\n", "| 一段对话 | \"你好，请问这本书多少钱？\" |\n", "| 一首诗 | \"床前明月光，疑是地上霜\" |\n", "| 一段代码 | `print('Hello World')` |\n", "| 一封邮件 | 包含正文、收件人、发件人等 |\n", "| 聊天记录 | 微信对话、短信 |\n", "\n", "**简单来说：只要是文字组成的信息，都是文本数据！**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.2 文本数据的特点\n", "\n", "文本数据与图像、音频等数据有显著区别：\n", "\n", "| 特点 | 说明 | 示例 |\n", "|------|------|------|\n", "| **离散符号** | 由离散的字符/词组成，不是连续的数值 | \"hello\" 由 h,e,l,l,o 这5个字符组成 |\n", "| **序列性** | 符号按特定顺序排列，顺序改变意思就改变 | \"我爱你\" ≠ \"你爱我\" |\n", "| **语义丰富** | 同样的词在不同场景意思可能不同 | \"苹果\"可以是水果或手机品牌 |\n", "| **上下文相关** | 词的意思依赖上下文 | \"他打了猫，猫跑了\" 中两个\"猫\"意思相同 |\n", "| **歧义性** | 同样的话可能有多重理解 | \"天气真不错\"可以是正面或反讽 |\n", "\n", "### 思考：序列性有多重要？\n", "\n", "```\n", "文本1: \"我吃了饭\"\n", "文本2: \"饭了我吃\"\n", "文本3: \"饭吃了我\"\n", "\n", "这三个文本由完全相同的字符组成，但顺序不同，意思也完全不同！\n", "这说明：文本的顺序承载了重要的语义信息。\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "# 第二部分：计算机如何\"读取\"文本？\n", "\n", "## 2.1 对比：图像数据 vs 文本数据的存储方式\n", "\n", "### 图像数据的读取\n", "\n", "```\n", "图像文件（.jpg/.png）\n", " ↓\n", "计算机读取像素值（每个像素是0-255的数值）\n", " ↓\n", "存储为3维矩阵 [高度, 宽度, 通道(RGB)]\n", " ↓\n", "一张 1920×1080 的彩色图 = 1920 × 1080 × 3 = 6,220,800 个数字\n", "```\n", "\n", "**图像的本质：密集的数值矩阵，计算机可以直接处理！**\n", "\n", "### 文本数据的读取\n", "\n", "```\n", "文本文件（.txt/.md/.py）\n", " ↓\n", "计算机读取字符编码（ASCII/UTF-8/GBK）\n", " ↓\n", "存储为字符序列（每个字符是一个数字编码）\n", " ↓\n", "\"Python\" → [80, 121, 116, 104, 111]（ASCII编码）\n", "```\n", "\n", "**文本的本质：符号序列，计算机需要额外处理才能理解！**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2.2 字符编码：用数字表示字符\n", "\n", "### ASCII编码（英文和部分符号）\n", "\n", "ASCII码使用0-127的数字来表示128个字符：\n", "\n", "| 字符 | ASCII码 | 说明 |\n", "|------|---------|------|\n", "| 'A' | 65 | 大写字母 |\n", "| 'B' | 66 | 大写字母 |\n", "| ... | ... | ... |\n", "| 'Z' | 90 | 大写字母 |\n", "| 'a' | 97 | 小写字母 |\n", "| 'b' | 98 | 小写字母 |\n", "| ... | ... | ... |\n", "| 'z' | 122 | 小写字母 |\n", "| '0' | 48 | 数字 |\n", "| '1' | 49 | 数字 |\n", "| ... | ... | ... |\n", "| '9' | 57 | 数字 |\n", "\n", "### UTF-8编码（支持全球所有语言，包括中文）\n", "\n", "UTF-8是一种变长编码，中文通常用3-4个字节表示：\n", "\n", "| 字符 | UTF-8编码值 | 字节数 |\n", "|------|-------------|--------|\n", "| '中' | 20013 | 2字节 |\n", "| '文' | 25991 | 2字节 |\n", "| 'P' | 80 | 1字节 |\n", "| 'y' | 121 | 1字节 |\n", "| '👍' | 128077 | 4字节（emoji） |" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "英文文本的字符编码\n", "==================================================\n", "文本: Hello\n", "每个字符的ASCII码: [72, 101, 108, 108, 111]\n", "\n", " 'H' -> 72\n", " 'e' -> 101\n", " 'l' -> 108\n", " 'l' -> 108\n", " 'o' -> 111\n", "\n", "==================================================\n", "中文文本的字符编码\n", "==================================================\n", "文本: 你好\n", "每个字符的UTF-8编码值: [20320, 22909]\n", "\n", " '你' -> 20320\n", " '好' -> 22909\n" ] } ], "source": [ "# 实际演示：查看字符的编码值\n", "\n", "# 英文例子\n", "text_en = \"Hello\"\n", "print(\"=\" * 50)\n", "print(\"英文文本的字符编码\")\n", "print(\"=\" * 50)\n", "print(f\"文本: {text_en}\")\n", "print(f\"每个字符的ASCII码: {[ord(c) for c in text_en]}\")\n", "print()\n", "\n", "# 逐个显示\n", "for c in text_en:\n", " print(f\" '{c}' -> {ord(c)}\")\n", "\n", "print()\n", "print(\"=\" * 50)\n", "print(\"中文文本的字符编码\")\n", "print(\"=\" * 50)\n", "\n", "# 中文例子\n", "text_cn = \"你好\"\n", "print(f\"文本: {text_cn}\")\n", "print(f\"每个字符的UTF-8编码值: {[ord(c) for c in text_cn]}\")\n", "print()\n", "\n", "# 逐个显示\n", "for c in text_cn:\n", " print(f\" '{c}' -> {ord(c)}\")" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "验证：数字编码转字符\n", "\n", "chr(65) = 'A' # 应该是大写字母 A\n", "chr(97) = 'a' # 应该是小写字母 a\n", "chr(20013) = '中' # 应该是中文'中'\n", "chr(25991) = '文' # 应该是中文'文'\n" ] } ], "source": [ "# 用chr()函数反向验证：数字编码转字符\n", "print(\"验证：数字编码转字符\")\n", "print()\n", "\n", "# 65是大写字母A\n", "print(f\"chr(65) = '{chr(65)}' # 应该是大写字母 A\")\n", "\n", "# 97是小写字母a\n", "print(f\"chr(97) = '{chr(97)}' # 应该是小写字母 a\")\n", "\n", "# 20013是中文\"中\"\n", "print(f\"chr(20013) = '{chr(20013)}' # 应该是中文'中'\")\n", "\n", "# 25991是中文\"文\"\n", "print(f\"chr(25991) = '{chr(25991)}' # 应该是中文'文'\")" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "练习题1答案\n", "==================================================\n", "1. 'Hello' 的ASCII码:\n", "[72, 101, 108, 108, 111]\n", "\n", "2. 验证 chr(65):\n", "chr(65) = 'A'\n", "\n", "验证 A-Z 的ASCII码范围 (65-90):\n", "['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']\n" ] } ], "source": [ "# 练习题1答案：验证字符编码\n", "print(\"=\" * 50)\n", "print(\"练习题1答案\")\n", "print(\"=\" * 50)\n", "\n", "# 1. 用 ord() 函数打印 \"Hello\" 每个字符的ASCII码\n", "print(\"1. 'Hello' 的ASCII码:\")\n", "print([ord(c) for c in \"Hello\"])\n", "\n", "# 2. 验证字符65对应大写字母A\n", "print()\n", "print(\"2. 验证 chr(65):\")\n", "print(f\"chr(65) = '{chr(65)}'\")\n", "\n", "# 验证范围\n", "print()\n", "print(\"验证 A-Z 的ASCII码范围 (65-90):\")\n", "print([chr(i) for i in range(65, 91)])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2.3 计算机擅长什么？不擅长什么？\n", "\n", "### 计算机擅长的任务 ✅\n", "\n", "| 任务类型 | 示例 | 说明 |\n", "|----------|------|------|\n", "| 数字计算 | 1 + 2 = 3 | 加减乘除、方程求解 |\n", "| 逻辑判断 | if a > b then ... | 条件分支、布尔运算 |\n", "| 矩阵运算 | 图像卷积、矩阵乘法 | 深度学习核心 |\n", "| 精确匹配 | 字符串完全相同比较 | 数据库查询 |\n", "| 模式识别 | 符合规则的数据查找 | 正则表达式 |\n", "| 存储检索 | 海量数据快速存取 | 搜索引擎 |\n", "\n", "### 计算机不擅长的任务 ❌\n", "\n", "| 任务类型 | 示例 | 为什么困难 |\n", "|----------|------|-------------|\n", "| 语义理解 | \"今天天气真好\"是好是坏？ | 需要常识和上下文 |\n", "| 情感判断 | \"真是绝了\"是夸还是骂？ | 歧义性、反讽 |\n", "| 模糊推理 | \"大概\"、\"也许\" | 无法精确处理 |\n", "| 创意创作 | 写诗、写小说 | 需要想象力 |\n", "| 常识理解 | \"水往低处流\" | 缺乏物理常识 |\n", "| 多义性理解 | \"苹果\"指什么？ | 需要世界知识 |" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 为什么计算机不擅长理解文本？\n", "\n", "**原因一：文本是\"符号\"，不是\"数值\"**\n", "\n", "```\n", "计算机的大脑 = 计算器（专门处理数字）\n", "文本 = 一堆符号（对计算机来说就像乱码）\n", "\n", "数字：1, 2, 3, 100.5, -7 → 计算机直接能算\n", "文本：\"好\"、\"bad\"、\"hello\" → 计算机不知道啥意思\n", "```\n", "\n", "**原因二：语义不是显式表达的**\n", "\n", "```python\n", "# 人类理解的文本：\n", "text = \"他今天心情不太好，因为下雨了\"\n", "\n", "# 人类理解：\n", "# - \"心情不太好\" = 不开心\n", "# - \"因为下雨了\" = 原因是下雨\n", "# - 因果关系：下雨 → 心情不好\n", "\n", "# 计算机只能看到：\n", "print(text)\n", "# 计算机：？？？不理解下雨和心情的因果关系\n", "```\n", "\n", "**原因三：同样的符号，不同的语境，不同的意思**\n", "\n", "```\n", "语境1: \"苹果真好吃\" → 说的是水果（吃的苹果）\n", "\n", "语境2: \"苹果手机真贵\" → 说的是手机品牌（Apple）\n", "\n", "语境3: \"牛顿被苹果砸到了\" → 说的是水果（引发万有引力灵感）\n", "\n", "计算机怎么知道？需要上下文理解能力！\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 关键结论：为什么需要文本向量化？\n", "\n", "```\n", "┌─────────────────────────────────────────────────────────────┐\n", "│ 核心矛盾 │\n", "│ │\n", "│ 文本（符号序列） ←→ 计算机擅长（数值计算） │\n", "│ ↓ │\n", "│ 需要一座桥梁 │\n", "│ 这座桥梁就是 │\n", "│ 【文本向量化】 │\n", "│ │\n", "│ 文本 → 数值向量 → 计算机可以计算 → AI模型处理 │\n", "└─────────────────────────────────────────────────────────────┘\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "# 第三部分：向量基础入门\n", "\n", "## 3.1 什么是向量？\n", "\n", "**向量 = 有方向的量**，是数学中描述\"大小+方向\"的基本工具。\n", "\n", "### 生活中的向量例子\n", "\n", "| 例子 | 大小 | 方向 | 说明 |\n", "|------|------|------|------|\n", "| 速度 | 60 km/h | 向北 | 速度是向量 |\n", "| 力 | 10 N | 向右推 | 力是向量 |\n", "| 风向 | 5 m/s | 东南风 | 风向是向量 |\n", "| 位移 | 100 km | 北京→上海 | 位移是向量 |\n", "\n", "### 向量在数学中的表示\n", "\n", "**一维向量（数轴上的点）**：\n", "\n", "```\n", " ←———————————|———————————→\n", " -3 -2 -1 0 1 2 3\n", "\n", " 点A在位置 2 → 向量A = [2] （只有1个数字）\n", " 点B在位置 -3 → 向量B = [-3] （负数表示方向相反）\n", "```" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "NumPy向量创建演示\n", "==================================================\n", "一维向量 v1 = [3]\n", "v1 有 1 个元素\n", "\n", "二维向量 v2 = [2 3]\n", "v2 有 2 个元素\n", "\n", "三维向量 v3 = [1 2 3]\n", "v3 有 3 个元素\n", "\n", "10维向量 v10 = [ 0.1 0.5 -0.3 0.8 0.2 -0.1 0.7 0.3 -0.2 0.6]\n", "v10 有 10 个元素\n" ] } ], "source": [ "# Python中使用NumPy创建向量\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"NumPy向量创建演示\")\n", "print(\"=\" * 50)\n", "\n", "# 一维向量（只有1个数字）\n", "v1 = np.array([3])\n", "print(f\"一维向量 v1 = {v1}\")\n", "print(f\"v1 有 {len(v1)} 个元素\")\n", "\n", "# 二维向量（2个数字，表示平面上的一个点）\n", "v2 = np.array([2, 3])\n", "print(f\"\\n二维向量 v2 = {v2}\")\n", "print(f\"v2 有 {len(v2)} 个元素\")\n", "\n", "# 三维向量（3个数字，表示立体空间的一个点）\n", "v3 = np.array([1, 2, 3])\n", "print(f\"\\n三维向量 v3 = {v3}\")\n", "print(f\"v3 有 {len(v3)} 个元素\")\n", "\n", "# 高维向量（机器学习中常用，几十维到几千维）\n", "v10 = np.array([0.1, 0.5, -0.3, 0.8, 0.2, -0.1, 0.7, 0.3, -0.2, 0.6])\n", "print(f\"\\n10维向量 v10 = {v10}\")\n", "print(f\"v10 有 {len(v10)} 个元素\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 二维向量的几何直观\n", "\n", "```\n", " y (纵坐标)\n", " ↑\n", " |\n", " 3 | * A(2,3)\n", " |\n", " 2 |\n", " |\n", " 1 | * B(4,1)\n", " |\n", " 0---+—————————————→ x (横坐标)\n", " 0 1 2 3 4 5\n", "\n", " 向量A = [2, 3] （横坐标2，纵坐标3）\n", " 向量B = [4, 1]\n", "\n", " 从原点(0,0)出发，到点(2,3)的箭头，就是向量A的图形表示\n", "```" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n", "findfont: Generic family 'sans-serif' not found because none of the following families were found: SimHei, Noto Sans CJK SC, WenQuanYi Micro Hei\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Note: Arrows represent vectors. Endpoint of arrow = vector endpoint\n" ] } ], "source": [ "# 可视化二维向量\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "# 设置中文字体（如果系统有的话）\n", "try:\n", " plt.rcParams['font.sans-serif'] = ['SimHei', 'Noto Sans CJK SC', 'WenQuanYi Micro Hei']\n", " plt.rcParams['axes.unicode_minus'] = False\n", "except:\n", " pass # 如果没有中文字体就用默认\n", "\n", "# 创建画布\n", "fig, ax = plt.subplots(figsize=(8, 8))\n", "\n", "# 定义向量\n", "vectors = {\n", " 'A = [2, 3]': np.array([2, 3]),\n", " 'B = [4, 1]': np.array([4, 1]),\n", " 'C = [1, 1]': np.array([1, 1]),\n", "}\n", "\n", "# 画每个向量\n", "colors = ['red', 'blue', 'green']\n", "for (name, vec), color in zip(vectors.items(), colors):\n", " ax.annotate('', xy=vec, xytext=(0, 0),\n", " arrowprops=dict(arrowstyle='->', color=color, lw=2))\n", " ax.text(vec[0]+0.1, vec[1]+0.1, name, fontsize=12, color=color)\n", "\n", "# 画坐标系\n", "ax.axhline(y=0, color='black', linewidth=0.5)\n", "ax.axvline(x=0, color='black', linewidth=0.5)\n", "\n", "# 设置范围\n", "ax.set_xlim(-0.5, 5.5)\n", "ax.set_ylim(-0.5, 4)\n", "ax.set_xlabel('x (abscissa)', fontsize=12)\n", "ax.set_ylabel('y (ordinate)', fontsize=12)\n", "ax.set_title('2D Vector Visualization', fontsize=14)\n", "ax.grid(True, alpha=0.3)\n", "ax.set_aspect('equal')\n", "\n", "plt.show()\n", "print(\"Note: Arrows represent vectors. Endpoint of arrow = vector endpoint\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.2 向量的基本运算\n", "\n", "### 3.2.1 向量加法\n", "\n", "**规则：对应位置相加**\n", "\n", "```python\n", "[1, 2, 3] + [4, 5, 6] = [1+4, 2+5, 3+6] = [5, 7, 9]\n", "```\n", "\n", "**几何直观**：先走向量a，再走向量b，等价于直接从原点走到a+b\n", "\n", "```\n", " b=[4,5,6]\n", " ↗\n", " |\n", " a+b |\n", " ↙|\n", " ↙ |\n", "O →——→ a=[1,2,3]\n", "```" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "向量加法演示\n", "==================================================\n", "向量 a = [1 2 3]\n", "向量 b = [4 5 6]\n", "a + b = [5 7 9]\n", "\n", "计算过程：\n", " 位置0: 1 + 4 = 5\n", " 位置1: 2 + 5 = 7\n", " 位置2: 3 + 6 = 9\n", "\n", "验证： True True True\n" ] } ], "source": [ "# 向量加法演示\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"向量加法演示\")\n", "print(\"=\" * 50)\n", "\n", "a = np.array([1, 2, 3])\n", "b = np.array([4, 5, 6])\n", "c = a + b\n", "\n", "print(f\"向量 a = {a}\")\n", "print(f\"向量 b = {b}\")\n", "print(f\"a + b = {c}\")\n", "print()\n", "print(\"计算过程：\")\n", "print(f\" 位置0: {a[0]} + {b[0]} = {a[0]+b[0]}\")\n", "print(f\" 位置1: {a[1]} + {b[1]} = {a[1]+b[1]}\")\n", "print(f\" 位置2: {a[2]} + {b[2]} = {a[2]+b[2]}\")\n", "print()\n", "print(\"验证：\", a[0]+b[0] == c[0], a[1]+b[1] == c[1], a[2]+b[2] == c[2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.2.2 向量数乘（标量乘法）\n", "\n", "**规则：每个元素都乘以这个标量（数字）**\n", "\n", "```python\n", "2 × [1, 2, 3] = [2×1, 2×2, 2×3] = [2, 4, 6]\n", "3 × [1, 2, 3] = [3×1, 3×2, 3×3] = [3, 6, 9]\n", "0.5 × [1, 2, 3] = [0.5, 1.0, 1.5]\n", "```\n", "\n", "**几何直观**：\n", "- 正数：方向不变，长度缩放\n", "- 负数：方向相反，长度缩放\n", "- 0：变成零向量" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "向量数乘（标量乘法）演示\n", "==================================================\n", "原始向量 v = [1 2 3]\n", "\n", "2 × v = [2 4 6]\n", "3 × v = [3 6 9]\n", "0.5 × v = [0.5 1. 1.5]\n", "-1 × v = [-1 -2 -3]\n", "0 × v = [0 0 0]\n" ] } ], "source": [ "# 向量数乘演示\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"向量数乘（标量乘法）演示\")\n", "print(\"=\" * 50)\n", "\n", "v = np.array([1, 2, 3])\n", "\n", "print(f\"原始向量 v = {v}\")\n", "print()\n", "\n", "for scalar in [2, 3, 0.5, -1, 0]:\n", " result = scalar * v\n", " print(f\"{scalar} × v = {result}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.2.3 向量的长度（模/范数）\n", "\n", "**定义：从原点到向量终点的距离**\n", "\n", "对于二维向量 `[a, b]`：\n", "```\n", "长度 = √(a² + b²)\n", "\n", "这就是\"勾股定理\"！\n", "\n", " |\n", " b |\n", " | |\n", " | √(a²+b²)\n", " | /\n", " | /\n", " |/ a\n", " O——————\n", "```\n", "\n", "对于n维向量 `[a₁, a₂, ..., aₙ]`：\n", "```\n", "长度 = √(a₁² + a₂² + ... + aₙ²)\n", "```" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "向量长度（模/范数）演示\n", "==================================================\n", "向量 v = [3 4]\n", "长度 = √(3² + 4²) = √(9 + 16) = √25 = 5.0\n", "\n", "向量长度计算例子：\n", " [np.int64(1), np.int64(1)] -> 长度 = 1.4142\n", " [np.int64(0), np.int64(5)] -> 长度 = 5.0000\n", " [np.int64(3), np.int64(4)] -> 长度 = 5.0000\n", " [np.int64(1), np.int64(2), np.int64(2)] -> 长度 = 3.0000\n", " [np.int64(1), np.int64(1), np.int64(1), np.int64(1)] -> 长度 = 2.0000\n" ] } ], "source": [ "# 向量长度计算\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"向量长度（模/范数）演示\")\n", "print(\"=\" * 50)\n", "\n", "# 二维向量例子\n", "v2d = np.array([3, 4])\n", "length_2d = np.linalg.norm(v2d)\n", "\n", "print(f\"向量 v = {v2d}\")\n", "print(f\"长度 = √({v2d[0]}² + {v2d[1]}²) = √({v2d[0]**2} + {v2d[1]**2}) = √{v2d[0]**2 + v2d[1]**2} = {length_2d}\")\n", "print()\n", "\n", "# 更多例子\n", "examples = [\n", " np.array([1, 1]), # 45度角\n", " np.array([0, 5]), # 在y轴上\n", " np.array([3, 4]), # 经典勾股数\n", " np.array([1, 2, 2]), # 三维向量\n", " np.array([1, 1, 1, 1]) # 四维向量\n", "]\n", "\n", "print(\"向量长度计算例子：\")\n", "for v in examples:\n", " length = np.linalg.norm(v)\n", " print(f\" {list(v)} -> 长度 = {length:.4f}\")" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "练习题3答案\n", "==================================================\n", "A = [3 4], B = [1 2]\n", "\n", "1. A + B = [4 6]\n", "2. 2 × A = [6 8]\n", "3. A的长度 = 5.0\n" ] } ], "source": [ "# 练习题3答案\n", "import numpy as np\n", "print(\"=\" * 50)\n", "print(\"练习题3答案\")\n", "print(\"=\" * 50)\n", "\n", "A = np.array([3, 4])\n", "B = np.array([1, 2])\n", "\n", "print(f\"A = {A}, B = {B}\")\n", "print()\n", "\n", "# 1. A + B\n", "print(\"1. A + B =\", A + B)\n", "\n", "# 2. 2 × A\n", "print(\"2. 2 × A =\", 2 * A)\n", "\n", "# 3. A的长度\n", "print(f\"3. A的长度 = {np.linalg.norm(A)}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "# 第四部分：余弦相似度\n", "\n", "## 4.1 什么是相似度？\n", "\n", "**相似度 = 两个向量有多\"像\"**\n", "\n", "### 日常生活中的相似例子\n", "\n", "| 相似度高 | 原因 | 相似度低 | 原因 |\n", "|----------|------|----------|------|\n", "| \"猫\" 和 \"狗\" | 都是动物，都四只脚 | \"猫\" 和 \"石头\" | 一个是动物，一个不是 |\n", "| \"红色\" 和 \"黄色\" | 都是颜色，暖色调 | \"热\" 和 \"冷\" | 意思相反 |\n", "| \"跑步\" 和 \"游泳\" | 都是运动 | \"太阳\" 和 \"细菌\" | 几乎没有共同点 |\n", "| \"苹果\" 和 \"梨\" | 都是水果 | \"苹果\" 和 \"手机\" | 需要上下文才能关联 |\n", "\n", "### 计算机如何量化相似度？\n", "\n", "文本相似度在计算机中的应用：\n", "\n", "```\n", "搜索场景：\n", " 用户输入: \"如何学习编程？\"\n", " 文档1: \"Python入门教程\" → 相似度高 ✅\n", " 文档2: \"做蛋糕的100种方法\" → 相似度低 ❌\n", "\n", "推荐场景：\n", " 用户喜欢: \"猫和狗的搞笑视频\"\n", " 推荐1: \"仓鼠的可爱瞬间\" → 相似度高 ✅\n", " 推荐2: \"汽车发动机维修教程\" → 相似度低 ❌\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4.2 点积（Dot Product）— 最重要的运算\n", "\n", "### 定义：对应位置相乘，再求和\n", "\n", "```python\n", "a = [1, 2, 3]\n", "b = [4, 5, 6]\n", "\n", "点积 = 1×4 + 2×5 + 3×6 = 4 + 10 + 18 = 32\n", "```\n", "\n", "### 点积的几何意义\n", "\n", "```\n", "点积 = |A| × |B| × cos(θ)\n", "\n", "其中：\n", " |A| = 向量A的长度\n", " |B| = 向量B的长度\n", " θ = 两个向量之间的夹角\n", "```\n", "\n", "| 夹角 θ | cos(θ) | 点积结果 | 含义 |\n", "|--------|--------|----------|------|\n", "| 0° | 1 | |A|×|B|（最大） | 方向完全相同 |\n", "| 90° | 0 | 0 | 垂直/正交 |\n", "| 180° | -1 | -|A|×|B|（最小） | 方向完全相反 |" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "向量点积演示\n", "==================================================\n", "向量 a = [1 2 3]\n", "向量 b = [4 5 6]\n", "\n", "点积 a · b = 32\n", "验证: a @ b = 32\n", "手动计算: 32\n", "\n", "计算过程：\n", " a[0]×b[0] = 1×4 = 4\n", " a[1]×b[1] = 2×5 = 10\n", " a[2]×b[2] = 3×6 = 18\n", " 求和: 4 + 10 + 18 = 32\n" ] } ], "source": [ "# 点积计算演示\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"向量点积演示\")\n", "print(\"=\" * 50)\n", "\n", "a = np.array([1, 2, 3])\n", "b = np.array([4, 5, 6])\n", "\n", "# 方法1：使用np.dot()\n", "dot1 = np.dot(a, b)\n", "\n", "# 方法2：使用@运算符\n", "dot2 = a @ b\n", "\n", "# 方法3：手动计算\n", "dot3 = sum(a[i] * b[i] for i in range(len(a)))\n", "\n", "print(f\"向量 a = {a}\")\n", "print(f\"向量 b = {b}\")\n", "print()\n", "print(f\"点积 a · b = {dot1}\")\n", "print(f\"验证: a @ b = {dot2}\")\n", "print(f\"手动计算: {dot3}\")\n", "print()\n", "print(\"计算过程：\")\n", "print(f\" a[0]×b[0] = {a[0]}×{b[0]} = {a[0]*b[0]}\")\n", "print(f\" a[1]×b[1] = {a[1]}×{b[1]} = {a[1]*b[1]}\")\n", "print(f\" a[2]×b[2] = {a[2]}×{b[2]} = {a[2]*b[2]}\")\n", "print(f\" 求和: {a[0]*b[0]} + {a[1]*b[1]} + {a[2]*b[2]} = {dot1}\")" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "点积与夹角的关系\n", "==================================================\n", "夹角0°: a=[1 0], b=[2 0], 点积=2\n", "夹角90°: a=[1 0], b=[0 1], 点积=0\n", "夹角180°: a=[1 0], b=[-1 0], 点积=-1\n", "\n", "任意角度: a=[1 1], b=[1 0]\n", " 点积 = 1\n", " cos(θ) = 0.7071\n", " 夹角 θ = 45.0°\n" ] } ], "source": [ "# 点积与夹角的关系\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"点积与夹角的关系\")\n", "print(\"=\" * 50)\n", "\n", "# 夹角为0度：方向完全相同\n", "a = np.array([1, 0])\n", "b = np.array([2, 0])\n", "dot = np.dot(a, b)\n", "print(f\"夹角0°: a={a}, b={b}, 点积={dot}\")\n", "\n", "# 夹角为90度：垂直\n", "a = np.array([1, 0])\n", "b = np.array([0, 1])\n", "dot = np.dot(a, b)\n", "print(f\"夹角90°: a={a}, b={b}, 点积={dot}\")\n", "\n", "# 夹角为180度：方向相反\n", "a = np.array([1, 0])\n", "b = np.array([-1, 0])\n", "dot = np.dot(a, b)\n", "print(f\"夹角180°: a={a}, b={b}, 点积={dot}\")\n", "\n", "# 任意角度\n", "import math\n", "a = np.array([1, 1])\n", "b = np.array([1, 0])\n", "dot = np.dot(a, b)\n", "cos_angle = dot / (np.linalg.norm(a) * np.linalg.norm(b))\n", "angle = math.acos(cos_angle) * 180 / math.pi\n", "print(f\"\\n任意角度: a={a}, b={b}\")\n", "print(f\" 点积 = {dot}\")\n", "print(f\" cos(θ) = {cos_angle:.4f}\")\n", "print(f\" 夹角 θ = {angle:.1f}°\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4.3 余弦相似度 — 用点积判断\"像不像\"\n", "\n", "### 公式\n", "\n", "```\n", " A · B\n", "cos(θ) = ──────────\n", " |A| × |B|\n", "\n", "其中：\n", " A · B = 向量A和B的点积\n", " |A| = 向量A的长度（模）\n", " |B| = 向量B的长度（模）\n", " cos(θ) = 相似度，范围是 [-1, 1]\n", "```\n", "\n", "### 为什么叫\"余弦\"相似度？\n", "\n", "因为公式中计算的就是两个向量夹角的余弦值！\n", "\n", "从点积公式推导：\n", "```\n", "A · B = |A| × |B| × cos(θ)\n", " ↓\n", "cos(θ) = (A · B) / (|A| × |B|)\n", "```" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "余弦相似度函数已定义：cosine_similarity(a, b)\n" ] } ], "source": [ "# 定义余弦相似度函数\n", "import numpy as np\n", "\n", "def cosine_similarity(a, b):\n", " \"\"\"\n", " 计算余弦相似度\n", " \n", " 参数:\n", " a, b: 两个numpy数组（向量）\n", " \n", " 返回:\n", " float: 余弦相似度，范围[-1, 1]\n", " \"\"\"\n", " dot = np.dot(a, b) # 点积\n", " norm_a = np.linalg.norm(a) # 向量a的长度\n", " norm_b = np.linalg.norm(b) # 向量b的长度\n", " \n", " # 防止除以零\n", " if norm_a == 0 or norm_b == 0:\n", " return 0.0\n", " \n", " return dot / (norm_a * norm_b)\n", "\n", "print(\"余弦相似度函数已定义：cosine_similarity(a, b)\")" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "余弦相似度计算示例\n", "==================================================\n", "1. 方向完全相同: a=[1 2 3], b=[2 4 6]\n", " 相似度 = 1.000 (应该是1.000)\n", "\n", "2. 方向完全相反: a=[1 2 3], b=[-1 -2 -3]\n", " 相似度 = -1.000 (应该是-1.000)\n", "\n", "3. 垂直向量: a=[1 0], b=[0 1]\n", " 相似度 = 0.000 (应该是0.000)\n", "\n", "4. 45度夹角: a=[1 1], b=[1 0]\n", " 相似度 = 0.707 (应该是0.707)\n" ] } ], "source": [ "# 余弦相似度计算示例\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"余弦相似度计算示例\")\n", "print(\"=\" * 50)\n", "\n", "# 示例1：方向完全相同的向量\n", "a = np.array([1, 2, 3])\n", "b = np.array([2, 4, 6]) # b是a的两倍，方向完全相同\n", "sim = cosine_similarity(a, b)\n", "print(f\"1. 方向完全相同: a={a}, b={b}\")\n", "print(f\" 相似度 = {sim:.3f} (应该是1.000)\")\n", "print()\n", "\n", "# 示例2：方向完全相反的向量\n", "a = np.array([1, 2, 3])\n", "b = np.array([-1, -2, -3]) # b是a的相反方向\n", "sim = cosine_similarity(a, b)\n", "print(f\"2. 方向完全相反: a={a}, b={b}\")\n", "print(f\" 相似度 = {sim:.3f} (应该是-1.000)\")\n", "print()\n", "\n", "# 示例3：垂直的向量\n", "a = np.array([1, 0])\n", "b = np.array([0, 1])\n", "sim = cosine_similarity(a, b)\n", "print(f\"3. 垂直向量: a={a}, b={b}\")\n", "print(f\" 相似度 = {sim:.3f} (应该是0.000)\")\n", "print()\n", "\n", "# 示例4：45度夹角\n", "a = np.array([1, 1])\n", "b = np.array([1, 0])\n", "sim = cosine_similarity(a, b)\n", "print(f\"4. 45度夹角: a={a}, b={b}\")\n", "print(f\" 相似度 = {sim:.3f} (应该是0.707)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 余弦相似度的值代表什么？\n", "\n", "| cos(θ) 值 | 夹角 θ | 相似程度 | 示例 |\n", "|----------|--------|---------|------|\n", "| 1.0 | 0° | **完全相同** | 同一向量 |\n", "| 0.8~0.99 | 0~37° | **非常相似** | \"猫\" vs \"狗\" |\n", "| 0.5~0.8 | 37~60° | **比较相似** | \"跑步\" vs \"运动\" |\n", "| 0.3~0.5 | 60~72° | **有些相似** | \"苹果\" vs \"水果\" |\n", "| 0 | 90° | **毫不相关** | \"猫\" vs \"石头\" |\n", "| -0.5~0 | 90~120° | **有些相反** | \"热\" vs \"冷\" |\n", "| -1.0 | 180° | **完全相反** | \"高\" vs \"矮\" |" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "语义相似度示例（用向量模拟词义）\n", "==================================================\n", "\n", "词向量（简化模拟）：\n", " 猫 = [0.9 0.1 0.7 0.8 0.9]\n", " 狗 = [0.8 0.2 0.6 0.8 0.9]\n", " 苹果 = [0.1 0.9 0.9 0. 0. ]\n", " 汽车 = [0. 0. 0. 0.9 0. ]\n", " 石头 = [0. 0.1 0. 0. 0. ]\n", "\n", "维度说明: [动物性, 植物性, 可食用性, 移动性, 宠物性]\n", "\n", "相似度计算结果：\n", " 猫 vs 狗: 0.996 (都是动物，都有宠物属性)\n", " 猫 vs 苹果: 0.382 (动物vs植物，很不同)\n", " 猫 vs 汽车: 0.482 (动物vs机械)\n", " 猫 vs 石头: 0.060 (动物vs无机物)\n", " 狗 vs 汽车: 0.507 (动物vs机械，但都能移动)\n", " 苹果 vs 石头: 0.705 (都是静态的)\n" ] } ], "source": [ "# 语义相似度示例\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"语义相似度示例（用向量模拟词义）\")\n", "print(\"=\" * 50)\n", "print()\n", "\n", "# 假设这些是词的\"意义向量\"（简化版）\n", "# 维度解释: [动物性, 植物性, 可食用性, 移动性, 宠物性]\n", "# 每个维度取值0-1，表示该属性的强弱\n", "\n", "cat = np.array([0.9, 0.1, 0.7, 0.8, 0.9]) # 猫\n", "dog = np.array([0.8, 0.2, 0.6, 0.8, 0.9]) # 狗\n", "apple = np.array([0.1, 0.9, 0.9, 0.0, 0.0]) # 苹果\n", "car = np.array([0.0, 0.0, 0.0, 0.9, 0.0]) # 汽车\n", "rock = np.array([0.0, 0.1, 0.0, 0.0, 0.0]) # 石头\n", "\n", "print(\"词向量（简化模拟）：\")\n", "print(f\" 猫 = {cat}\")\n", "print(f\" 狗 = {dog}\")\n", "print(f\" 苹果 = {apple}\")\n", "print(f\" 汽车 = {car}\")\n", "print(f\" 石头 = {rock}\")\n", "print()\n", "print(\"维度说明: [动物性, 植物性, 可食用性, 移动性, 宠物性]\")\n", "print()\n", "\n", "# 计算相似度\n", "print(\"相似度计算结果：\")\n", "print(f\" 猫 vs 狗: {cosine_similarity(cat, dog):.3f} (都是动物，都有宠物属性)\")\n", "print(f\" 猫 vs 苹果: {cosine_similarity(cat, apple):.3f} (动物vs植物，很不同)\")\n", "print(f\" 猫 vs 汽车: {cosine_similarity(cat, car):.3f} (动物vs机械)\")\n", "print(f\" 猫 vs 石头: {cosine_similarity(cat, rock):.3f} (动物vs无机物)\")\n", "print(f\" 狗 vs 汽车: {cosine_similarity(dog, car):.3f} (动物vs机械，但都能移动)\")\n", "print(f\" 苹果 vs 石头: {cosine_similarity(apple, rock):.3f} (都是静态的)\")" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "练习题4答案\n", "==================================================\n", "A = [1 2 3], B = [4 5 6]\n", "\n", "1. 点积 A · B = 32\n", " 计算: 1×4 + 2×5 + 3×6 = 4 + 10 + 18 = 32\n", "\n", "2. 余弦相似度 = 0.9746\n", "\n", "3. A=[1,0], B=[0,1] 的余弦相似度 = 0.0\n", " 原因：这两个向量垂直，夹角90°，cos(90°)=0\n" ] } ], "source": [ "# 练习题4答案\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"练习题4答案\")\n", "print(\"=\" * 50)\n", "\n", "A = np.array([1, 2, 3])\n", "B = np.array([4, 5, 6])\n", "\n", "print(f\"A = {A}, B = {B}\")\n", "print()\n", "\n", "# 1. 点积\n", "dot = np.dot(A, B)\n", "print(f\"1. 点积 A · B = {dot}\")\n", "print(f\" 计算: 1×4 + 2×5 + 3×6 = 4 + 10 + 18 = {dot}\")\n", "print()\n", "\n", "# 2. 余弦相似度\n", "cos_sim = cosine_similarity(A, B)\n", "print(f\"2. 余弦相似度 = {cos_sim:.4f}\")\n", "print()\n", "\n", "# 3. 垂直向量的相似度\n", "A = np.array([1, 0])\n", "B = np.array([0, 1])\n", "cos_sim = cosine_similarity(A, B)\n", "print(f\"3. A=[1,0], B=[0,1] 的余弦相似度 = {cos_sim}\")\n", "print(\" 原因：这两个向量垂直，夹角90°，cos(90°)=0\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "# 第五部分：文本向量化的核心思想\n", "\n", "## 5.1 核心目标：把所有文本变成\"向量\"\n", "\n", "```\n", "┌──────────────────────────────────────────────────────────────────┐\n", "│ │\n", "│ 文本（符号） ──→ 数值向量 ──→ 计算机可以计算 ──→ AI模型处理 │\n", "│ │\n", "│ \"猫\" [0.9, 0.1, 0.8] │\n", "│ \"狗\" [0.8, 0.2, 0.7] │\n", "│ │\n", "└──────────────────────────────────────────────────────────────────┘\n", "```\n", "\n", "### 为什么必须是向量？\n", "\n", "| 计算机擅长 | 计算机不擅长 |\n", "|------------|-------------|\n", "| 向量加减：v1 + v2 = ? | 字符串比较：\"Python\" == \"Java\" ? |\n", "| 向量点积：v1 · v2 = ? | 词语推理：\"猫\" 类似于 \"狗\" ? |\n", "| 向量距离：|v1 - v2| = ? | 语义理解：\"你好\"是问候语 |\n", "| 余弦相似度：cos(θ) = ? | 情感判断：\"绝了\"是夸还是骂？ |" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5.2 向量化示例：从\"词\"到\"数\"\n", "\n", "### 方法1：位置编码（只有位置信息，没有语义）\n", "\n", "```python\n", "# 假设我们有一个很小的词汇表（只有5个词）\n", "vocab = [\"猫\", \"狗\", \"鱼\", \"苹果\", \"香蕉\"]\n", "\n", "# 位置编码：每个词对应一个位置\n", "# \"猫\" → [1, 0, 0, 0, 0] 第1个位置是1，其他是0\n", "# \"狗\" → [0, 1, 0, 0, 0] 第2个位置是1，其他是0\n", "# \"苹果\" → [0, 0, 0, 1, 0] 第4个位置是1，其他是0\n", "```\n", "\n", "**问题**：这只是\"位置编码\"，没有语义信息！\n", "\n", "```\n", "\"猫\" = [1, 0, 0, 0, 0]\n", "\"狗\" = [0, 1, 0, 0, 0]\n", "\n", "余弦相似度 = 0 （完全不相似）\n", "\n", "但实际上\"猫\"和\"狗\"都是动物，应该很相似！\n", "```" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "位置编码的缺陷\n", "==================================================\n", "位置编码向量：\n", " 猫 = [1 0 0 0 0]\n", " 狗 = [0 1 0 0 0]\n", " 苹果 = [0 0 0 1 0]\n", "\n", "余弦相似度（用位置编码）：\n", " 猫 vs 狗: 0.000\n", " 猫 vs 苹果: 0.000\n", "\n", "问题：猫和狗都是动物，相似度却是0！\n", " 猫和苹果不是同类，相似度也是0！\n", " 位置编码没有语义信息！\n" ] } ], "source": [ "# 位置编码的缺陷演示\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"位置编码的缺陷\")\n", "print(\"=\" * 50)\n", "\n", "# 位置编码向量\n", "cat_onehot = np.array([1, 0, 0, 0, 0]) # \"猫\"\n", "dog_onehot = np.array([0, 1, 0, 0, 0]) # \"狗\"\n", "apple_onehot = np.array([0, 0, 0, 1, 0]) # \"苹果\"\n", "\n", "print(\"位置编码向量：\")\n", "print(f\" 猫 = {cat_onehot}\")\n", "print(f\" 狗 = {dog_onehot}\")\n", "print(f\" 苹果 = {apple_onehot}\")\n", "print()\n", "\n", "# 相似度计算\n", "print(\"余弦相似度（用位置编码）：\")\n", "print(f\" 猫 vs 狗: {cosine_similarity(cat_onehot, dog_onehot):.3f}\")\n", "print(f\" 猫 vs 苹果: {cosine_similarity(cat_onehot, apple_onehot):.3f}\")\n", "print()\n", "print(\"问题：猫和狗都是动物，相似度却是0！\")\n", "print(\" 猫和苹果不是同类，相似度也是0！\")\n", "print(\" 位置编码没有语义信息！\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 方法2：语义编码（有语义信息）\n", "\n", "```python\n", "# 语义编码：每个词用\"含义\"来表示\n", "# 维度：[动物性, 植物性, 可食用性, 宠物性]\n", "\n", "cat = np.array([0.9, 0.1, 0.7, 0.9]) # 猫\n", "dog = np.array([0.8, 0.2, 0.6, 0.9]) # 狗\n", "apple = np.array([0.1, 0.9, 0.9, 0.0]) # 苹果\n", "```\n", "\n", "**这就是文本向量化的威力：把\"语义\"变成\"可计算的数值\"！**" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "语义编码的优点\n", "==================================================\n", "语义编码向量：\n", " 猫 = [0.9 0.1 0.7 0.9]\n", " 狗 = [0.8 0.2 0.6 0.9]\n", " 苹果 = [0.1 0.9 0.9 0. ]\n", "\n", "维度说明: [动物性, 植物性, 可食用性, 宠物性]\n", "\n", "余弦相似度（用语义编码）：\n", " 猫 vs 狗: 0.995 (都是动物，都有宠物属性)\n", " 猫 vs 苹果: 0.436 (动物vs植物)\n", "\n", "太棒了！语义编码可以捕捉到词的语义相似性！\n" ] } ], "source": [ "# 语义编码的优点演示\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"语义编码的优点\")\n", "print(\"=\" * 50)\n", "\n", "# 语义编码向量\n", "# 维度: [动物性, 植物性, 可食用性, 宠物性]\n", "cat = np.array([0.9, 0.1, 0.7, 0.9]) # 猫\n", "dog = np.array([0.8, 0.2, 0.6, 0.9]) # 狗\n", "apple = np.array([0.1, 0.9, 0.9, 0.0]) # 苹果\n", "\n", "print(\"语义编码向量：\")\n", "print(f\" 猫 = {cat}\")\n", "print(f\" 狗 = {dog}\")\n", "print(f\" 苹果 = {apple}\")\n", "print()\n", "print(\"维度说明: [动物性, 植物性, 可食用性, 宠物性]\")\n", "print()\n", "\n", "# 相似度计算\n", "print(\"余弦相似度（用语义编码）：\")\n", "print(f\" 猫 vs 狗: {cosine_similarity(cat, dog):.3f} (都是动物，都有宠物属性)\")\n", "print(f\" 猫 vs 苹果: {cosine_similarity(cat, apple):.3f} (动物vs植物)\")\n", "print()\n", "print(\"太棒了！语义编码可以捕捉到词的语义相似性！\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5.3 向量化方法演进\n", "\n", "```\n", "文本向量化的三种主要方法：\n", "\n", "[ BoW ] ───→ [ TF-IDF ] ───→ [ Word Embedding ]\n", " (词袋模型) (词频权重) (词向量嵌入)\n", " \n", " 简单粗暴 加入词重要性 蕴含语义信息\n", " 无语义 部分语义 深度语义\n", " \n", " 1980年代 1990年代 2013年后\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "# 第六部分：BoW词袋模型\n", "\n", "## 6.1 原理\n", "\n", "把文本看成\"一袋词\"，**不考虑顺序**，只管词出现了几次。\n", "\n", "```\n", "文本1: \"Python 是 编程 语言\"\n", "文本2: \"Java 是 编程 语言\"\n", "\n", "分词后：\n", " Doc1: [\"Python\", \"是\", \"编程\", \"语言\"]\n", " Doc2: [\"Java\", \"是\", \"编程\", \"语言\"]\n", "\n", "构建词表（所有文档的词集合）：\n", " 词表: [\"Python\", \"Java\", \"是\", \"编程\", \"语言\"]\n", "\n", "向量化：统计每个词出现的次数\n", " Doc1 → [1, 0, 1, 1, 1] # Python出现1次，Java出现0次，...\n", " Doc2 → [0, 1, 1, 1, 1] # Python出现0次，Java出现1次，...\n", "```" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "BoW词袋模型演示（手动实现）\n", "==================================================\n", "【示例1】文档集合：\n", " Doc1: Python 是 编程 语言\n", " Doc2: Java 是 编程 语言\n", "\n", "词表: ['Java', 'Python', '是', '编程', '语言']\n", "\n", "BoW矩阵（每行是一个文档，每列是一个词）：\n", " Doc1: [0, 1, 1, 1, 1]\n", " Doc2: [1, 0, 1, 1, 1]\n", "\n", "详细解释：\n", "\n", "Doc1: Python 是 编程 语言\n", " -> 'Python' 出现 1 次\n", " -> '是' 出现 1 次\n", " -> '编程' 出现 1 次\n", " -> '语言' 出现 1 次\n", "\n", "Doc2: Java 是 编程 语言\n", " -> 'Java' 出现 1 次\n", " -> '是' 出现 1 次\n", " -> '编程' 出现 1 次\n", " -> '语言' 出现 1 次\n" ] } ], "source": [ "# BoW词袋模型演示（纯Python实现，不依赖sklearn）\n", "\n", "print(\"=\" * 50)\n", "print(\"BoW词袋模型演示（手动实现）\")\n", "print(\"=\" * 50)\n", "\n", "def simple_bow(docs):\n", " \"\"\"\n", " 简单的BoW实现\n", " \n", " 参数:\n", " docs: 文档列表，每篇文档已经是分词后的词列表\n", " 返回:\n", " vocab: 词表（有序列表）\n", " bow_matrix: BoW矩阵 (n_docs x n_vocab)\n", " \"\"\"\n", " # 1. 构建词表\n", " vocab_set = set()\n", " for doc in docs:\n", " vocab_set.update(doc)\n", " vocab = sorted(list(vocab_set)) # 排序保证顺序一致\n", " \n", " # 2. 构建BoW矩阵\n", " bow_matrix = []\n", " for doc in docs:\n", " vec = [0] * len(vocab)\n", " for word in doc:\n", " if word in vocab:\n", " vec[vocab.index(word)] += 1\n", " bow_matrix.append(vec)\n", " \n", " return vocab, bow_matrix\n", "\n", "\n", "# 示例1：中文文档（用空格分词）\n", "docs = [\n", " [\"Python\", \"是\", \"编程\", \"语言\"],\n", " [\"Java\", \"是\", \"编程\", \"语言\"],\n", "]\n", "\n", "vocab, bow_matrix = simple_bow(docs)\n", "\n", "print(\"【示例1】文档集合：\")\n", "for i, doc in enumerate(docs):\n", " print(f\" Doc{i+1}: {' '.join(doc)}\")\n", "print()\n", "\n", "print(f\"词表: {vocab}\")\n", "print()\n", "\n", "print(\"BoW矩阵（每行是一个文档，每列是一个词）：\")\n", "for i, vec in enumerate(bow_matrix):\n", " print(f\" Doc{i+1}: {vec}\")\n", "print()\n", "\n", "# 详细解释\n", "print(\"详细解释：\")\n", "for i, doc in enumerate(docs):\n", " print(f\"\\nDoc{i+1}: {' '.join(doc)}\")\n", " for j, word in enumerate(vocab):\n", " if bow_matrix[i][j] > 0:\n", " print(f\" -> '{word}' 出现 {bow_matrix[i][j]} 次\")" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "BoW词袋模型：更多示例\n", "==================================================\n", "文档集合：\n", " Doc1: 我 爱 Python 编程\n", " Doc2: Python 很 好 学\n", " Doc3: 我 爱 写 代码\n", "\n", "词表: ['Python', '代码', '写', '好', '学', '很', '我', '爱', '编程']\n", "\n", "BoW矩阵:\n", " Doc1: [1, 0, 0, 0, 0, 0, 1, 1, 1]\n", " Doc2: [1, 0, 0, 1, 1, 1, 0, 0, 0]\n", " Doc3: [0, 1, 1, 0, 0, 0, 1, 1, 0]\n", "\n", "表格形式：\n", "Doc | Python | 代码 | 写 | 好 | 学 | 很\n", "----------------------------------\n", "Doc1 | 1 | 0 | 0 | 0 | 0 | 0\n", "Doc2 | 1 | 0 | 0 | 1 | 1 | 1\n", "Doc3 | 0 | 1 | 1 | 0 | 0 | 0\n" ] } ], "source": [ "# 更多BoW示例（纯Python实现）\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"BoW词袋模型：更多示例\")\n", "print(\"=\" * 50)\n", "\n", "def simple_bow(docs):\n", " \"\"\"简单的BoW实现\"\"\"\n", " vocab_set = set()\n", " for doc in docs:\n", " vocab_set.update(doc)\n", " vocab = sorted(list(vocab_set))\n", " bow_matrix = []\n", " for doc in docs:\n", " vec = [0] * len(vocab)\n", " for word in doc:\n", " if word in vocab:\n", " vec[vocab.index(word)] += 1\n", " bow_matrix.append(vec)\n", " return vocab, bow_matrix\n", "\n", "docs = [\n", " [\"我\", \"爱\", \"Python\", \"编程\"],\n", " [\"Python\", \"很\", \"好\", \"学\"],\n", " [\"我\", \"爱\", \"写\", \"代码\"]\n", "]\n", "\n", "vocab, bow_matrix = simple_bow(docs)\n", "\n", "print(\"文档集合：\")\n", "for i, doc in enumerate(docs):\n", " print(f\" Doc{i+1}: {' '.join(doc)}\")\n", "print()\n", "\n", "print(f\"词表: {vocab}\")\n", "print()\n", "\n", "print(\"BoW矩阵:\")\n", "for i, vec in enumerate(bow_matrix):\n", " print(f\" Doc{i+1}: {vec}\")\n", "\n", "print()\n", "\n", "# 显示成表格\n", "print(\"表格形式：\")\n", "header = \"Doc | \" + \" | \".join(vocab[:6])\n", "print(header)\n", "print(\"-\" * len(header))\n", "for i, row in enumerate(bow_matrix):\n", " print(f\"Doc{i+1} | \" + \" | \".join(map(str, row[:6])))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 6.2 BoW 的优缺点\n", "\n", "| 优点 | 缺点 |\n", "|------|------|\n", "| **简单直观** | 忽略词序 |\n", "| **容易实现** | \"我爱你\"和\"你爱我\"向量完全相同 |\n", "| **计算速度快** | 所有词同等重要 |\n", "| **适合基线模型** | 无法捕捉语义 |\n", "| | 无法处理同义词：\"电脑\"和\"计算机\"完全不同 |\n", "| | 维度很高（词表有多大，维度就多大） |" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "BoW忽略词序的演示\n", "==================================================\n", "文档：\n", " Doc1: 我爱你\n", " Doc2: 你爱我\n", " Doc3: 爱你我\n", "\n", "BoW矩阵：\n", " Doc1: [1, 1, 1, 0]\n", " Doc2: [1, 1, 1, 0]\n", " Doc3: [0, 0, 0, 1]\n", "\n", "词表: ['你', '我', '爱', '爱你我']\n", "\n", "问题：这三个完全不同的句子，BoW向量完全相同！\n", "Doc1: 我爱你（表达爱意）\n", "Doc2: 你爱我（对方爱我）\n", "Doc3: 爱你我（意义不明）\n", "\n", "结论：BoW模型丢失了词序信息！\n" ] } ], "source": [ "# BoW忽略词序的演示\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"BoW忽略词序的演示\")\n", "print(\"=\" * 50)\n", "\n", "def simple_bow(docs):\n", " \"\"\"简单的BoW实现\"\"\"\n", " vocab_set = set()\n", " for doc in docs:\n", " vocab_set.update(doc)\n", " vocab = sorted(list(vocab_set))\n", " bow_matrix = []\n", " for doc in docs:\n", " vec = [0] * len(vocab)\n", " for word in doc:\n", " if word in vocab:\n", " vec[vocab.index(word)] += 1\n", " bow_matrix.append(vec)\n", " return vocab, bow_matrix\n", "\n", "# 两个完全不同的句子，但BoW向量相同\n", "docs = [\n", " [\"我\", \"爱\", \"你\"], # 正常语序\n", " [\"你\", \"爱\", \"我\"], # 完全相反\n", " [\"爱你我\"], # 没有空格（中文连续）\n", "]\n", "\n", "vocab, bow_matrix = simple_bow(docs)\n", "\n", "print(\"文档：\")\n", "for i, doc in enumerate(docs):\n", " print(f\" Doc{i+1}: {''.join(doc)}\")\n", "print()\n", "\n", "print(\"BoW矩阵：\")\n", "for i, vec in enumerate(bow_matrix):\n", " print(f\" Doc{i+1}: {vec}\")\n", "print()\n", "\n", "print(f\"词表: {vocab}\")\n", "print()\n", "\n", "print(\"问题：这三个完全不同的句子，BoW向量完全相同！\")\n", "print(\"Doc1: 我爱你（表达爱意）\")\n", "print(\"Doc2: 你爱我（对方爱我）\")\n", "print(\"Doc3: 爱你我（意义不明）\")\n", "print()\n", "print(\"结论：BoW模型丢失了词序信息！\")" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "练习题5答案\n", "==================================================\n", "文档集合：\n", " Doc1: Python 是 编程 语言\n", " Doc2: Java 是 编程 语言\n", " Doc3: Python Python Python\n", "\n", "词表: ['Java', 'Python', '是', '编程', '语言']\n", "\n", "BoW矩阵（每行是一个文档的向量）：\n", " Doc1: [0, 1, 1, 1, 1]\n", " Doc2: [1, 0, 1, 1, 1]\n", " Doc3: [0, 3, 0, 0, 0]\n", "\n", "解析：\n", " Doc1: [0, 1, 1, 1, 1]\n", " - 'Python' 出现 1 次\n", " - '是' 出现 1 次\n", " - '编程' 出现 1 次\n", " - '语言' 出现 1 次\n", " Doc2: [1, 0, 1, 1, 1]\n", " - 'Java' 出现 1 次\n", " - '是' 出现 1 次\n", " - '编程' 出现 1 次\n", " - '语言' 出现 1 次\n", " Doc3: [0, 3, 0, 0, 0]\n", " - 'Python' 出现 3 次\n" ] } ], "source": [ "# 练习题5答案\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"练习题5答案\")\n", "print(\"=\" * 50)\n", "\n", "def simple_bow(docs):\n", " \"\"\"简单的BoW实现\"\"\"\n", " vocab_set = set()\n", " for doc in docs:\n", " vocab_set.update(doc)\n", " vocab = sorted(list(vocab_set))\n", " bow_matrix = []\n", " for doc in docs:\n", " vec = [0] * len(vocab)\n", " for word in doc:\n", " if word in vocab:\n", " vec[vocab.index(word)] += 1\n", " bow_matrix.append(vec)\n", " return vocab, bow_matrix\n", "\n", "docs = [\n", " [\"Python\", \"是\", \"编程\", \"语言\"],\n", " [\"Java\", \"是\", \"编程\", \"语言\"],\n", " [\"Python\", \"Python\", \"Python\"]\n", "]\n", "\n", "vocab, bow_matrix = simple_bow(docs)\n", "\n", "print(\"文档集合：\")\n", "for i, doc in enumerate(docs):\n", " print(f\" Doc{i+1}: {' '.join(doc)}\")\n", "print()\n", "\n", "print(f\"词表: {vocab}\")\n", "print()\n", "\n", "print(\"BoW矩阵（每行是一个文档的向量）：\")\n", "for i, vec in enumerate(bow_matrix):\n", " print(f\" Doc{i+1}: {vec}\")\n", "print()\n", "\n", "print(\"解析：\")\n", "for i, vec in enumerate(bow_matrix):\n", " print(f\" Doc{i+1}: {vec}\")\n", " for j, count in enumerate(vec):\n", " if count > 0:\n", " print(f\" - '{vocab[j]}' 出现 {count} 次\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "# 第七部分：TF-IDF\n", "\n", "## 7.1 为什么需要TF-IDF？\n", "\n", "**BoW的问题**：所有词同等重要！\n", "\n", "```\n", "文档A: \"Python 是 编程 语言，Python Python Python\"\n", "文档B: \"Python 是 编程 语言\"\n", "\n", "BoW结果：\n", " 文档A: Python=4, 是=1, 编程=1, 语言=1\n", " 文档B: Python=1, 是=1, 编程=1, 语言=1\n", "\n", "问题：\"Python\"在A中出现4次，在B中出现1次\n", " 但\"是\"、\"编程\"、\"语言\"出现次数相同\n", " 我们希望\"Python\"的权重更高（因为它更重要）\n", "```\n", "\n", "**关键洞察**：\n", "- 高频出现的词 ≠ 一定重要（\"的\"、\"了\"在所有文章都出现）\n", "- 罕见词 ≠ 不重要（\"TensorFlow\"只在AI文章出现，很重要）" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 7.2 TF-IDF公式\n", "\n", "**TF-IDF = 词频(TF) × 逆文档频率(IDF)**\n", "\n", "```\n", "TF = 这个词在本文中出现了多少次\n", "IDF = log(总文档数 / 包含该词的文档数)\n", "\n", "TF-IDF = TF × IDF\n", "```\n", "\n", "### IDF的含义\n", "\n", "| 词 | 在多少文档出现 | IDF值 | 解释 |\n", "|----|----------------|-------|------|\n", "| \"的\" | 所有文档 | log(很高) ≈ 0 | 到处都是，不重要 |\n", "| \"Python\" | 少数文档 | log(中等) = 高 | 较独特，重要 |\n", "| \"TensorFlow\" | 极少数文档 | log(很低) = 更高 | 很独特，非常重要 |\n", "| \"AI\" | 只有1篇 | log(总文档数/1) = 最高 | 最独特，最重要 |" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "TF-IDF词频-逆文档频率演示\n", "==================================================\n", "文档集合：\n", " Doc1: Python 编程 语言\n", " Doc2: Python Python Python\n", " Doc3: Java 编程 语言\n", "\n", "词表: ['Java', 'Python', '编程', '语言']\n", "\n", "IDF值: [1.4055, 1.0, 1.0, 1.0]\n", "\n", "TF-IDF矩阵：\n", " Doc1: [0.0, 1.0, 1.0, 1.0]\n", " Doc2: [0.0, 3.0, 0.0, 0.0]\n", " Doc3: [1.4055, 0.0, 1.0, 1.0]\n", "\n", "详细分析：\n", "\n", "Doc1: Python 编程 语言\n", " 'Python': TF-IDF = 1.0000\n", " '编程': TF-IDF = 1.0000\n", " '语言': TF-IDF = 1.0000\n", "\n", "Doc2: Python Python Python\n", " 'Python': TF-IDF = 3.0000\n", "\n", "Doc3: Java 编程 语言\n", " 'Java': TF-IDF = 1.4055\n", " '编程': TF-IDF = 1.0000\n", " '语言': TF-IDF = 1.0000\n" ] } ], "source": [ "# TF-IDF演示（纯Python实现）\n", "import math\n", "\n", "print(\"=\" * 50)\n", "print(\"TF-IDF词频-逆文档频率演示\")\n", "print(\"=\" * 50)\n", "\n", "def simple_tfidf(docs):\n", " \"\"\"\n", " 简单的TF-IDF实现\n", " \n", " 参数:\n", " docs: 文档列表，每篇文档已经是分词后的词列表\n", " 返回:\n", " vocab: 词表\n", " tfidf_matrix: TF-IDF矩阵\n", " idf: 每个词的IDF值\n", " \"\"\"\n", " # 1. 构建词表和BoW\n", " vocab_set = set()\n", " for doc in docs:\n", " vocab_set.update(doc)\n", " vocab = sorted(list(vocab_set))\n", " \n", " # 2. 构建BoW矩阵\n", " bow = []\n", " for doc in docs:\n", " vec = [0] * len(vocab)\n", " for word in doc:\n", " if word in vocab:\n", " vec[vocab.index(word)] += 1\n", " bow.append(vec)\n", " \n", " n_docs = len(docs)\n", " \n", " # 3. 计算IDF\n", " idf = []\n", " for j, word in enumerate(vocab):\n", " df = sum(1 for vec in bow if vec[j] > 0)\n", " idf_j = math.log(n_docs / (df + 1)) + 1\n", " idf.append(idf_j)\n", " \n", " # 4. 计算TF-IDF\n", " tfidf = []\n", " for vec in bow:\n", " tfidf_vec = []\n", " for i, tf in enumerate(vec):\n", " tfidf_vec.append(tf * idf[i])\n", " tfidf.append(tfidf_vec)\n", " \n", " return vocab, tfidf, idf\n", "\n", "docs = [\n", " [\"Python\", \"编程\", \"语言\"],\n", " [\"Python\", \"Python\", \"Python\"], # Python出现3次\n", " [\"Java\", \"编程\", \"语言\"],\n", "]\n", "\n", "vocab, tfidf_matrix, idf = simple_tfidf(docs)\n", "\n", "print(\"文档集合：\")\n", "for i, doc in enumerate(docs):\n", " print(f\" Doc{i+1}: {' '.join(doc)}\")\n", "print()\n", "\n", "print(f\"词表: {vocab}\")\n", "print()\n", "print(f\"IDF值: {[round(x, 4) for x in idf]}\")\n", "print()\n", "\n", "print(\"TF-IDF矩阵：\")\n", "for i, vec in enumerate(tfidf_matrix):\n", " print(f\" Doc{i+1}: {[round(x, 4) for x in vec]}\")\n", "print()\n", "\n", "print(\"详细分析：\")\n", "for i, doc in enumerate(docs):\n", " print(f\"\\nDoc{i+1}: {' '.join(doc)}\")\n", " for j, score in enumerate(tfidf_matrix[i]):\n", " if score > 0:\n", " print(f\" '{vocab[j]}': TF-IDF = {score:.4f}\")" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "TF-IDF vs BoW 对比\n", "==================================================\n", "文档：\n", " Doc1: Python 编程\n", " Doc2: Java 编程\n", " Doc3: Python Python Python\n", "\n", "BoW矩阵：\n", " Doc1: [0, 1, 1]\n", " Doc2: [1, 0, 1]\n", " Doc3: [0, 3, 0]\n", "\n", "TF-IDF矩阵：\n", " Doc1: [0.0, 1.0, 1.0]\n", " Doc2: [1.4055, 0.0, 1.0]\n", " Doc3: [0.0, 3.0, 0.0]\n", "\n", "重点分析：\n", "Doc3 'Python Python Python':\n", " BoW: Python出现3次\n", " TF-IDF: Python的TF-IDF = 0.0000\n", "\n", "为什么Doc3的TF-IDF不是最高的？\n", "因为Python在Doc1和Doc2也出现了，IDF值被稀释\n" ] } ], "source": [ "# TF-IDF vs BoW 对比\n", "import math\n", "\n", "print(\"=\" * 50)\n", "print(\"TF-IDF vs BoW 对比\")\n", "print(\"=\" * 50)\n", "\n", "def simple_bow(docs):\n", " vocab_set = set()\n", " for doc in docs:\n", " vocab_set.update(doc)\n", " vocab = sorted(list(vocab_set))\n", " bow_matrix = []\n", " for doc in docs:\n", " vec = [0] * len(vocab)\n", " for word in doc:\n", " if word in vocab:\n", " vec[vocab.index(word)] += 1\n", " bow_matrix.append(vec)\n", " return vocab, bow_matrix\n", "\n", "def simple_tfidf(docs):\n", " vocab_set = set()\n", " for doc in docs:\n", " vocab_set.update(doc)\n", " vocab = sorted(list(vocab_set))\n", " bow = []\n", " for doc in docs:\n", " vec = [0] * len(vocab)\n", " for word in doc:\n", " if word in vocab:\n", " vec[vocab.index(word)] += 1\n", " bow.append(vec)\n", " \n", " n_docs = len(docs)\n", " idf = []\n", " for j, word in enumerate(vocab):\n", " df = sum(1 for vec in bow if vec[j] > 0)\n", " idf_j = math.log(n_docs / (df + 1)) + 1\n", " idf.append(idf_j)\n", " \n", " tfidf = []\n", " for vec in bow:\n", " tfidf_vec = []\n", " for i, tf in enumerate(vec):\n", " tfidf_vec.append(tf * idf[i])\n", " tfidf.append(tfidf_vec)\n", " \n", " return vocab, tfidf, idf\n", "\n", "docs = [\n", " [\"Python\", \"编程\"],\n", " [\"Java\", \"编程\"],\n", " [\"Python\", \"Python\", \"Python\"] # Python出现3次\n", "]\n", "\n", "vocab_bow, bow_matrix = simple_bow(docs)\n", "vocab_tfidf, tfidf_matrix, idf = simple_tfidf(docs)\n", "\n", "print(\"文档：\")\n", "for i, doc in enumerate(docs):\n", " print(f\" Doc{i+1}: {' '.join(doc)}\")\n", "print()\n", "\n", "print(\"BoW矩阵：\")\n", "for i, vec in enumerate(bow_matrix):\n", " print(f\" Doc{i+1}: {vec}\")\n", "print()\n", "\n", "print(\"TF-IDF矩阵：\")\n", "for i, vec in enumerate(tfidf_matrix):\n", " print(f\" Doc{i+1}: {[round(x, 4) for x in vec]}\")\n", "print()\n", "\n", "# 重点分析Doc3\n", "print(\"重点分析：\")\n", "print(f\"Doc3 'Python Python Python':\")\n", "print(f\" BoW: Python出现3次\")\n", "print(f\" TF-IDF: Python的TF-IDF = {tfidf_matrix[2][0]:.4f}\")\n", "print()\n", "print(\"为什么Doc3的TF-IDF不是最高的？\")\n", "print(\"因为Python在Doc1和Doc2也出现了，IDF值被稀释\")" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "附加题答案\n", "==================================================\n", "文档：\n", " Doc1: Python 编程\n", " Doc2: Java 编程\n", " Doc3: Python Python\n", "\n", "词表: ['Java', 'Python', '编程']\n", "\n", "IDF值: [1.4055, 1.0, 1.0]\n", "\n", "TF-IDF矩阵：\n", " Doc1: [0.0, 1.0, 1.0]\n", " Doc2: [1.4055, 0.0, 1.0]\n", " Doc3: [0.0, 2.0, 0.0]\n", "\n", "问题1：为什么Python在Doc3中的TF-IDF值不是最高？\n", "答：因为Python在Doc1、Doc2、Doc3中都出现了，\n", " IDF = log(3/3) = 0，所以TF-IDF = 3 * 0 = 0！\n", "\n", "问题2：Java在Doc2中的TF-IDF值是多少？\n", "答：Java在Doc2的TF-IDF值 = 1.4055\n", " 因为Java只出现在Doc2中，其他文档没有，所以IDF值高\n" ] } ], "source": [ "# 附加题答案\n", "import math\n", "\n", "print(\"=\" * 50)\n", "print(\"附加题答案\")\n", "print(\"=\" * 50)\n", "\n", "def simple_tfidf(docs):\n", " vocab_set = set()\n", " for doc in docs:\n", " vocab_set.update(doc)\n", " vocab = sorted(list(vocab_set))\n", " bow = []\n", " for doc in docs:\n", " vec = [0] * len(vocab)\n", " for word in doc:\n", " if word in vocab:\n", " vec[vocab.index(word)] += 1\n", " bow.append(vec)\n", " \n", " n_docs = len(docs)\n", " idf = []\n", " for j, word in enumerate(vocab):\n", " df = sum(1 for vec in bow if vec[j] > 0)\n", " idf_j = math.log(n_docs / (df + 1)) + 1\n", " idf.append(idf_j)\n", " \n", " tfidf = []\n", " for vec in bow:\n", " tfidf_vec = []\n", " for i, tf in enumerate(vec):\n", " tfidf_vec.append(tf * idf[i])\n", " tfidf.append(tfidf_vec)\n", " \n", " return vocab, tfidf, idf\n", "\n", "docs = [[\"Python\", \"编程\"], [\"Java\", \"编程\"], [\"Python\", \"Python\"]]\n", "\n", "vocab, tfidf_matrix, idf = simple_tfidf(docs)\n", "\n", "print(\"文档：\")\n", "for i, doc in enumerate(docs):\n", " print(f\" Doc{i+1}: {' '.join(doc)}\")\n", "print()\n", "\n", "print(f\"词表: {vocab}\")\n", "print()\n", "print(f\"IDF值: {[round(x, 4) for x in idf]}\")\n", "print()\n", "\n", "print(\"TF-IDF矩阵：\")\n", "for i, vec in enumerate(tfidf_matrix):\n", " print(f\" Doc{i+1}: {[round(x, 4) for x in vec]}\")\n", "print()\n", "\n", "print(\"问题1：为什么Python在Doc3中的TF-IDF值不是最高？\")\n", "print(\"答：因为Python在Doc1、Doc2、Doc3中都出现了，\")\n", "print(\" IDF = log(3/3) = 0，所以TF-IDF = 3 * 0 = 0！\")\n", "print()\n", "print(\"问题2：Java在Doc2中的TF-IDF值是多少？\")\n", "java_idx = vocab.index(\"Java\")\n", "print(f\"答：Java在Doc2的TF-IDF值 = {tfidf_matrix[1][java_idx]:.4f}\")\n", "print(\" 因为Java只出现在Doc2中，其他文档没有，所以IDF值高\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 7.3 TF-IDF的优缺点\n", "\n", "| 优点 | 缺点 |\n", "|------|------|\n", "| 考虑词的重要性 | 忽略词序 |\n", "| 降低常见词权重 | 无法捕捉语义 |\n", "| 提高独特词权重 | \"猫\"和\"狗\"的TF-IDF可能相似也可能不相似 |\n", "| 可以提取关键词 | 无法处理同义词 \"电脑\" vs \"计算机\" |" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "# 第八部分：Word Embedding词嵌入\n", "\n", "## 8.1 BoW和TF-IDF的根本问题\n", "\n", "```python\n", "# 位置编码的问题\n", "\"猫\" → [1, 0, 0, ...] # 只是\"位置编码\"\n", "\"狗\" → [0, 1, 0, ...] # 猫和狗的位置不同\n", "\"小猫\" → [0, 0, 1, ...] # 但它们语义相近，向量却正交！\n", "\n", "# 问题：无法表达语义相似性！\n", "# \"猫\"和\"狗\"都是动物，语义很相似\n", "# 但在BoW/TF-IDF中，它们的向量可能完全不同\n", "```\n", "\n", "### 词嵌入的核心思想\n", "\n", "```\n", "不再用\"位置\"表示词，而是用\"语义空间\"表示词\n", "\n", "语义空间示例（二维简化）：\n", " ↑ 动物性\n", " 狗 | ↑ 猫\n", " | ↗\n", " 0 |↗ ↑ 苹果\n", " |___________→ 植物性\n", " ↑ 香蕉\n", " \n", " 语义相近的词在空间中距离近\n", "```" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "词嵌入（Word Embedding）概念演示\n", "==================================================\n", "\n", "词向量（简化版3维）示意：\n", "维度含义: [动物性, 植物性, 其他/技术性]\n", "\n", " 猫: [0.9 0.1 0.2]\n", " 狗: [0.8 0.3 0.1]\n", " 小猫: [0.85 0.2 0.15]\n", " 苹果: [0.1 0.2 0.9]\n", " 香蕉: [0.1 0.1 0.85]\n", " Python: [0.1 0. 0.9]\n", " Java: [0.1 0. 0.85]\n", "\n", "语义相似度：\n", " 猫 vs 狗: 0.965\n", " 猫 vs 小猫: 0.992\n", " 猫 vs 苹果: 0.337\n", " 苹果 vs 香蕉: 0.995\n", " Python vs Java: 1.000\n", "\n", "词嵌入的优势：\n", " - 语义相似的词，向量也相似\n", " - 可以做类比推理：国王-男人+女人=女王\n" ] } ], "source": [ "# Word2Vec词嵌入的概念演示\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"词嵌入（Word Embedding）概念演示\")\n", "print(\"=\" * 50)\n", "print()\n", "\n", "# 假设这些是用Word2Vec等方法训练出来的词向量（简化版，3维）\n", "# 实际中向量通常是50/100/300维\n", "word_vectors = {\n", " \"猫\": np.array([0.9, 0.1, 0.2]), # 动物属性高，其他低\n", " \"狗\": np.array([0.8, 0.3, 0.1]), # 动物属性高\n", " \"小猫\": np.array([0.85, 0.2, 0.15]), # 小动物，也像猫\n", " \"苹果\": np.array([0.1, 0.2, 0.9]), # 水果属性高\n", " \"香蕉\": np.array([0.1, 0.1, 0.85]), # 水果属性高\n", " \"Python\": np.array([0.1, 0.0, 0.9]), # 编程语言\n", " \"Java\": np.array([0.1, 0.0, 0.85]), # 编程语言\n", "}\n", "\n", "print(\"词向量（简化版3维）示意：\")\n", "print(\"维度含义: [动物性, 植物性, 其他/技术性]\")\n", "print()\n", "for word, vec in word_vectors.items():\n", " print(f\" {word}: {vec}\")\n", "print()\n", "\n", "# 计算相似度\n", "print(\"语义相似度：\")\n", "print(f\" 猫 vs 狗: {cosine_similarity(word_vectors['猫'], word_vectors['狗']):.3f}\")\n", "print(f\" 猫 vs 小猫: {cosine_similarity(word_vectors['猫'], word_vectors['小猫']):.3f}\")\n", "print(f\" 猫 vs 苹果: {cosine_similarity(word_vectors['猫'], word_vectors['苹果']):.3f}\")\n", "print(f\" 苹果 vs 香蕉: {cosine_similarity(word_vectors['苹果'], word_vectors['香蕉']):.3f}\")\n", "print(f\" Python vs Java: {cosine_similarity(word_vectors['Python'], word_vectors['Java']):.3f}\")\n", "print()\n", "print(\"词嵌入的优势：\")\n", "print(\" - 语义相似的词，向量也相似\")\n", "print(\" - 可以做类比推理：国王-男人+女人=女王\")" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "词嵌入的类比推理\n", "==================================================\n", "\n", "词向量（简化版）：\n", " King: [0.9 0.1 0.8 0.3]\n", " Man: [0.8 0.1 0.2 0.5]\n", " Woman: [0.1 0.8 0.2 0.5]\n", " Queen: [0.1 0.9 0.8 0.3]\n", "\n", "维度含义: [皇室属性, 女性属性, 权力属性, 人类属性]\n", "\n", "King - Man + Woman = [0.2 0.8 0.8 0.3]\n", "Queen = [0.1 0.9 0.8 0.3]\n", "\n", "相似度验证：\n", " (King-Man+Woman) vs Queen: 0.994\n", "\n", "结论：词嵌入可以捕捉语义关系！\n", " '国王' - '男人' + '女人' ≈ '女王'\n", " 这说明词向量编码了语义信息！\n" ] } ], "source": [ "# 词嵌入的类比推理演示\n", "import numpy as np\n", "\n", "print(\"=\" * 50)\n", "print(\"词嵌入的类比推理\")\n", "print(\"=\" * 50)\n", "print()\n", "\n", "# 经典例子：King - Man + Woman ≈ Queen\n", "# 这个例子说明了词嵌入可以捕捉语义关系\n", "\n", "# 简化版词向量（实际中这些向量由神经网络学习得到）\n", "king = np.array([0.9, 0.1, 0.8, 0.3]) # 皇室、男性、有权力\n", "man = np.array([0.8, 0.1, 0.2, 0.5]) # 男性\n", "woman = np.array([0.1, 0.8, 0.2, 0.5]) # 女性\n", "queen = np.array([0.1, 0.9, 0.8, 0.3]) # 皇室、女性、有权力\n", "\n", "print(\"词向量（简化版）：\")\n", "print(f\" King: {king}\")\n", "print(f\" Man: {man}\")\n", "print(f\" Woman: {woman}\")\n", "print(f\" Queen: {queen}\")\n", "print()\n", "print(\"维度含义: [皇室属性, 女性属性, 权力属性, 人类属性]\")\n", "print()\n", "\n", "# 计算 King - Man + Woman\n", "result = king - man + woman\n", "print(f\"King - Man + Woman = {result}\")\n", "print(f\"Queen = {queen}\")\n", "print()\n", "\n", "# 相似度\n", "print(\"相似度验证：\")\n", "print(f\" (King-Man+Woman) vs Queen: {cosine_similarity(result, queen):.3f}\")\n", "print()\n", "\n", "print(\"结论：词嵌入可以捕捉语义关系！\")\n", "print(\" '国王' - '男人' + '女人' ≈ '女王'\")\n", "print(\" 这说明词向量编码了语义信息！\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 8.2 词嵌入的发展历史\n", "\n", "| 方法 | 年份 | 特点 |\n", "|------|------|------|\n", "| Word2Vec | 2013 | Google开源，开启词嵌入时代 |\n", "| GloVe | 2014 | Stanford提出，基于全局共现矩阵 |\n", "| FastText | 2016 | Facebook开源，支持子词 |\n", "| ELMo | 2018 | 考虑上下文，动态词向量 |\n", "| BERT | 2018 | Transformer架构，预训练大模型 |\n", "| GPT系列 | 2018-现在 | 生成式AI，ChatGPT核心 |" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", "预训练词向量演示（使用内置示例向量）\n", "==================================================\n", "\n", "注意：真实环境中加载Gensim预训练模型需要下载（约66MB）\n", "本notebook使用内置示例向量进行演示\n", "\n", "词向量示例（每个词用一个5维向量表示）：\n", "维度含义: [动物性, 植物性, 技术性, 动态性, 抽象概念]\n", "\n", " cat : [0.9, 0.1, 0.2, 0.8, 0.3]\n", " dog : [0.8, 0.2, 0.1, 0.9, 0.3]\n", " bird : [0.7, 0.3, 0.1, 0.9, 0.2]\n", " fish : [0.6, 0.2, 0.1, 0.8, 0.2]\n", " apple : [0.1, 0.9, 0.3, 0.0, 0.2]\n", " rose : [0.1, 0.8, 0.1, 0.0, 0.1]\n", " python : [0.1, 0.0, 0.9, 0.0, 0.5]\n", " java : [0.1, 0.0, 0.8, 0.0, 0.4]\n", " computer : [0.1, 0.0, 0.9, 0.3, 0.4]\n", " love : [0.3, 0.2, 0.1, 0.1, 0.9]\n", " hate : [0.2, 0.1, 0.1, 0.1, 0.8]\n", "\n", "==================================================\n", "1. 语义相似度计算\n", "==================================================\n", " cat vs dog : 0.987\n", " cat vs apple : 0.244\n", " python vs java : 0.998\n", " python vs cat : 0.322\n", " love vs hate : 0.993\n", "\n", "==================================================\n", "2. 类比推理（Word2Vec核心能力）\n", "==================================================\n", "类比问题：man -> woman, king -> ?\n", "\n", " King = [0.6 0.1 0.3 0.3 0.6]\n", " Man = [0.8 0.1 0.2 0.5 0.3]\n", " Woman = [0.2 0.8 0.2 0.5 0.5]\n", " King - Man + Woman = [-0. 0.8 0.3 0.3 0.8]\n", " Queen (真实) = [0.2 0.9 0.3 0.3 0.6]\n", "\n", " 相似度: 0.969\n", "\n", "太棒了！词嵌入可以捕捉语义关系！\n", "\n", "==================================================\n", "真实环境中加载Gensim预训练模型的方法\n", "==================================================\n", "如需加载真实的预训练词向量，可以运行：\n", "\n", " import gensim.downloader as api\n", " model = api.load('glove-wiki-gigaword-50')\n", "\n", "这会下载约66MB的预训练词向量模型\n" ] } ], "source": [ "# 实战：用预训练词向量演示词嵌入（跳过实际下载）\n", "import numpy as np\n", "\n", "def cosine_similarity(a, b):\n", " \"\"\"计算余弦相似度\"\"\"\n", " dot = np.dot(a, b)\n", " norm_a = np.linalg.norm(a)\n", " norm_b = np.linalg.norm(b)\n", " if norm_a == 0 or norm_b == 0:\n", " return 0.0\n", " return dot / (norm_a * norm_b)\n", "\n", "print(\"=\" * 50)\n", "print(\"预训练词向量演示（使用内置示例向量）\")\n", "print(\"=\" * 50)\n", "print()\n", "print(\"注意：真实环境中加载Gensim预训练模型需要下载（约66MB）\")\n", "print(\"本notebook使用内置示例向量进行演示\")\n", "print()\n", "\n", "# 使用内置的小规模词向量示例（模拟真实词向量）\n", "# 维度: [动物性, 植物性, 技术性, 动态性, 抽象概念]\n", "word_vectors = {\n", " # 动物\n", " \"cat\": np.array([0.9, 0.1, 0.2, 0.8, 0.3]),\n", " \"dog\": np.array([0.8, 0.2, 0.1, 0.9, 0.3]),\n", " \"bird\": np.array([0.7, 0.3, 0.1, 0.9, 0.2]),\n", " \"fish\": np.array([0.6, 0.2, 0.1, 0.8, 0.2]),\n", " # 植物\n", " \"apple\": np.array([0.1, 0.9, 0.3, 0.0, 0.2]),\n", " \"rose\": np.array([0.1, 0.8, 0.1, 0.0, 0.1]),\n", " # 技术\n", " \"python\": np.array([0.1, 0.0, 0.9, 0.0, 0.5]),\n", " \"java\": np.array([0.1, 0.0, 0.85, 0.0, 0.4]),\n", " \"computer\": np.array([0.1, 0.0, 0.9, 0.3, 0.4]),\n", " # 抽象概念\n", " \"love\": np.array([0.3, 0.2, 0.1, 0.1, 0.9]),\n", " \"hate\": np.array([0.2, 0.1, 0.1, 0.1, 0.8]),\n", "}\n", "\n", "# 显示词向量\n", "print(\"词向量示例（每个词用一个5维向量表示）：\")\n", "print(\"维度含义: [动物性, 植物性, 技术性, 动态性, 抽象概念]\")\n", "print()\n", "for word, vec in word_vectors.items():\n", " print(f\" {word:12s}: [{vec[0]:.1f}, {vec[1]:.1f}, {vec[2]:.1f}, {vec[3]:.1f}, {vec[4]:.1f}]\")\n", "\n", "print()\n", "print(\"=\" * 50)\n", "print(\"1. 语义相似度计算\")\n", "print(\"=\" * 50)\n", "pairs = [\n", " (\"cat\", \"dog\"), # 都是动物\n", " (\"cat\", \"apple\"), # 动物 vs 植物\n", " (\"python\", \"java\"), # 都是编程语言\n", " (\"python\", \"cat\"), # 编程语言 vs 动物\n", " (\"love\", \"hate\"), # 情感词\n", "]\n", "for w1, w2 in pairs:\n", " sim = cosine_similarity(word_vectors[w1], word_vectors[w2])\n", " print(f\" {w1:10s} vs {w2:10s}: {sim:.3f}\")\n", "\n", "print()\n", "print(\"=\" * 50)\n", "print(\"2. 类比推理（Word2Vec核心能力）\")\n", "print(\"=\" * 50)\n", "print(\"类比问题：man -> woman, king -> ?\")\n", "print()\n", "\n", "# 简化版类比：使用语义维度\n", "# man=[0.8, 0.1, 0.2, 0.5, 0.3], woman=[0.2, 0.8, 0.2, 0.5, 0.5]\n", "# king=[0.6, 0.1, 0.3, 0.3, 0.6], queen=[0.2, 0.9, 0.3, 0.3, 0.6]\n", "man = np.array([0.8, 0.1, 0.2, 0.5, 0.3])\n", "woman = np.array([0.2, 0.8, 0.2, 0.5, 0.5])\n", "king = np.array([0.6, 0.1, 0.3, 0.3, 0.6])\n", "queen = np.array([0.2, 0.9, 0.3, 0.3, 0.6])\n", "\n", "# king - man + woman ≈ queen\n", "result = king - man + woman\n", "\n", "print(f\" King = {king}\")\n", "print(f\" Man = {man}\")\n", "print(f\" Woman = {woman}\")\n", "print(f\" King - Man + Woman = {np.round(result, 2)}\")\n", "print(f\" Queen (真实) = {queen}\")\n", "print()\n", "print(f\" 相似度: {cosine_similarity(result, queen):.3f}\")\n", "print()\n", "print(\"太棒了！词嵌入可以捕捉语义关系！\")\n", "print()\n", "\n", "# 真实环境中加载Gensim模型的方法（仅供参考，不执行）\n", "print(\"=\" * 50)\n", "print(\"真实环境中加载Gensim预训练模型的方法\")\n", "print(\"=\" * 50)\n", "print(\"如需加载真实的预训练词向量，可以运行：\")\n", "print()\n", "print(\" import gensim.downloader as api\")\n", "print(\" model = api.load('glove-wiki-gigaword-50')\")\n", "print()\n", "print(\"这会下载约66MB的预训练词向量模型\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "# 第九部分：文本处理完整流程\n", "\n", "## 9.1 流程图\n", "\n", "```\n", "┌──────────────────────────────────────────────────────────────────┐\n", "│ 文本数据 │\n", "│ \"今天天气真不错！\" │\n", "└─────────────────────────┬────────────────────────────────────────┘\n", " │\n", " ▼\n", "┌──────────────────────────────────────────────────────────────────┐\n", "│ 1. 文本预处理 │\n", "│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │\n", "│ │ 分词 │→ │ 去停用词│→ │ 统一大小│→ │ 去除标点│ │\n", "│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │\n", "│ \"今天/天气/真/不错\" → \"今天/天气/不错\" │\n", "└─────────────────────────┬────────────────────────────────────────┘\n", " │\n", " ▼\n", "┌──────────────────────────────────────────────────────────────────┐\n", "│ 2. 文本向量化 │\n", "│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │\n", "│ │ BoW │ │ TF-IDF │ │ Embedding│ │ 预训练模型│ │\n", "│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │\n", "│ ↓ ↓ ↓ ↓ │\n", "│ [1,0,2,0,1] [0.5,0,0.8] [0.9,0.3] [BERT向量] │\n", "└─────────────────────────┬────────────────────────────────────────┘\n", " │\n", " ▼\n", "┌──────────────────────────────────────────────────────────────────┐\n", "│ 3. 下游任务 │\n", "│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │\n", "│ │ 分类 │ │ 相似度 │ │ 聚类 │ │ 生成 │ │\n", "│ │ 情感分析│ │ 文本匹配│ │ 主题分组│ │ 聊天机器人│ │\n", "│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │\n", "└──────────────────────────────────────────────────────────────────┘\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 9.2 各环节详解\n", "\n", "### 环节1：文本预处理\n", "\n", "| 步骤 | 输入 | 输出 | 作用 |\n", "|------|------|------|------|\n", "| 分词 | \"今天天气不错\" | [\"今天\", \"天气\", \"不错\"] | 把文本切成词 |\n", "| 去停用词 | [\"今天\", \"天气\", \"不错\"] | [\"天气\", \"不错\"] | 去掉\"的、了、在\"等无意义词 |\n", "| 统一大小写 | [\"Python\", \"python\"] | [\"python\", \"python\"] | 归一化 |\n", "| 去标点 | [\"语言!!!\"] | [\"语言\"] | 清理噪音 |" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 环节2：文本向量化\n", "\n", "| 方法 | 适用场景 | 不适用场景 |\n", "|------|---------|-----------|\n", "| BoW | 基线模型、快速原型 | 需要语义理解 |\n", "| TF-IDF | 文本分类、关键词提取 | 同义词识别 |\n", "| Embedding | 语义相似度、推荐系统 | 需要精确匹配 |\n", "| 预训练模型 | 通用NLP任务 | 计算资源有限 |" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 环节3：下游任务\n", "\n", "```python\n", "# 分类任务：\n", "\"这部电影太好看了！\" → 情感分类 → 正面 ✅\n", "\n", "# 相似度任务：\n", "\"如何学习Python？\" → 查找相似文档 → \"Python入门教程\" ✅\n", "\n", "# 生成任务：\n", "\"今天天气\" → GPT续写 → \"今天天气真好，适合出去玩\" ✅\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "# 第十部分：实战用jieba进行中文分词\n", "\n", "## 10.1 安装jieba\n", "\n", "```bash\n", "!pip install jieba\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 安装jieba\n", "import subprocess\n", "subprocess.run(['pip', 'install', 'jieba', '-q'])\n", "\n", "print(\"jieba安装完成！\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 10.2 基础分词\n", "\n", "jieba支持三种分词模式：\n", "\n", "| 模式 | 说明 | 适用场景 |\n", "|------|------|---------|\n", "| 精确模式 | 试图将句子最精确地切开，适合文本分析 | **默认，推荐** |\n", "| 全模式 | 把所有可能的词都扫描出来，速度快 | 速度要求高 |\n", "| 搜索引擎模式 | 在精确模式基础上，对长词再次切分 | 搜索引擎 |" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import jieba\n", "\n", "print(\"=\" * 50)\n", "print(\"jieba分词演示\")\n", "print(\"=\" * 50)\n", "\n", "text = \"我喜欢深度学习和人工智能\"\n", "\n", "print(f\"原文: {text}\")\n", "print()\n", "\n", "# 精确模式（默认）\n", "words精确 = list(jieba.cut(text, cut_all=False))\n", "print(f\"精确模式: {' / '.join(words精确)}\")\n", "\n", "# 全模式\n", "words全 = list(jieba.cut(text, cut_all=True))\n", "print(f\"全模式: {' / '.join(words全)}\")\n", "\n", "# 搜索引擎模式\n", "words搜索 = list(jieba.cut_for_search(text))\n", "print(f\"搜索模式: {' / '.join(words搜索)}\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 更多分词示例\n", "import jieba\n", "\n", "print(\"=\" * 50)\n", "print(\"更多分词示例\")\n", "print(\"=\" * 50)\n", "\n", "examples = [\n", " \"今天天气真不错\",\n", " \"人工智能是未来的发展方向\",\n", " \"Python是一门非常流行的编程语言\",\n", " \"小明毕业于清华大学计算机系\",\n", " \"我今天在京东买了一部iPhone手机\"\n", "]\n", "\n", "for i, text in enumerate(examples):\n", " words = list(jieba.cut(text))\n", " print(f\"{i+1}. {text}\")\n", " print(f\" → {' / '.join(words)}\")\n", " print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 10.3 词性标注\n", "\n", "jieba支持词性标注，可以标注每个词是名词、动词、形容词等。\n", "\n", "| 词性代码 | 含义 | 示例 |\n", "|----------|------|------|\n", "| n | 名词 | 人、山、电脑 |\n", "| v | 动词 | 跑、吃、学习 |\n", "| adj | 形容词 | 漂亮、好吃、优秀 |\n", "| adv | 副词 | 很、非常、慢慢 |\n", "| m | 数词 | 一、百、千 |\n", "| q | 量词 | 个、本、件 |" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import jieba.posseg as pseg\n", "\n", "print(\"=\" * 50)\n", "print(\"jieba词性标注演示\")\n", "print(\"=\" * 50)\n", "\n", "text = \"我喜欢深度学习和人工智能\"\n", "\n", "print(f\"原文: {text}\")\n", "print()\n", "\n", "words = pseg.cut(text)\n", "print(\"分词 + 词性标注：\")\n", "for word, flag in words:\n", " print(f\" {word}: {flag}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 10.4 停用词处理\n", "\n", "停用词是在文本处理中需要过滤掉的常见词，如\"的\"、\"了\"、\"在\"等。\n", "\n", "这些词在所有文档中都可能出现，对区分文档没有帮助。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import jieba\n", "\n", "print(\"=\" * 50)\n", "print(\"停用词处理演示\")\n", "print(\"=\" * 50)\n", "\n", "# 常见停用词列表\n", "stopwords = set(['的', '了', '在', '是', '我', '有', '和', '就', '不', '人', '都', '一', '一个', '上', '也', '很', '到', '说', '要', '去', '你', '会', '着', '没有', '看', '好', '自己', '这'])\n", "\n", "text = \"人工智能是未来的发展方向，也是当前科技领域的热门话题\"\n", "\n", "print(f\"原文: {text}\")\n", "print()\n", "\n", "# 不使用停用词\n", "words_all = list(jieba.cut(text))\n", "print(f\"不使用停用词: {' / '.join(words_all)}\")\n", "\n", "# 使用停用词\n", "words_filtered = [w for w in words_all if w not in stopwords]\n", "print(f\"使用停用词: {' / '.join(words_filtered)}\")\n", "print()\n", "\n", "# 更完整的停用词表可以从网上下载\n", "print(\"提示：实际项目中可以从以下地方获取停用词表：\")\n", "print(\" - 哈工大停用词表\")\n", "print(\" - 百度停用词表\")\n", "print(\" - 四川大学机器学习实验室停用词表\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 实战：完整的文本预处理流程\n", "import jieba\n", "\n", "print(\"=\" * 50)\n", "print(\"完整的文本预处理流程\")\n", "print(\"=\" * 50)\n", "\n", "# 示例文档集合\n", "docs = [\n", " \"今天天气真不错！适合出去玩。\",\n", " \"Python是一门很棒的编程语言。\",\n", " \"人工智能和机器学习是未来的发展方向。\",\n", " \"今天在咖啡馆喝了一杯很好喝的拿铁。\"\n", "]\n", "\n", "# 停用词表\n", "stopwords = set(['的', '了', '在', '是', '我', '有', '和', '就', '不', '人', '都', '一', '一个', '上', '也', '很', '到', '说', '要', '去', '你', '会', '着', '没有', '看', '好', '自己', '这', '！', '。', ','])\n", "\n", "def preprocess_text(text):\n", " \"\"\"完整的文本预处理流程\"\"\"\n", " # 1. 分词\n", " words = jieba.cut(text)\n", " \n", " # 2. 去除停用词\n", " words = [w for w in words if w not in stopwords and len(w) > 0]\n", " \n", " # 3. 去除空格\n", " words = [w for w in words if w.strip()]\n", " \n", " return words\n", "\n", "print(\"预处理结果：\")\n", "for i, doc in enumerate(docs):\n", " words = preprocess_text(doc)\n", " print(f\"\\nDoc{i+1}: {doc}\")\n", " print(f\" → {' / '.join(words)}\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 实战：jieba分词 + TF-IDF完整流程\n", "import jieba\n", "import math\n", "\n", "print(\"=\" * 50)\n", "print(\"实战：jieba分词 + TF-IDF完整流程\")\n", "print(\"=\" * 50)\n", "\n", "def simple_tfidf_tokenized(docs, stopwords=None):\n", " \"\"\"\n", " 结合分词的TF-IDF实现\n", " 参数:\n", " docs: 原始文档列表\n", " stopwords: 停用词集合\n", " 返回:\n", " vocab, tfidf_matrix\n", " \"\"\"\n", " # 1. 分词\n", " tokenized = []\n", " for doc in docs:\n", " words = jieba.cut(doc)\n", " if stopwords:\n", " words = [w for w in words if w not in stopwords and len(w) > 1]\n", " else:\n", " words = [w for w in words if len(w) > 1]\n", " tokenized.append(words)\n", " \n", " # 2. 构建词表\n", " vocab_set = set()\n", " for doc in tokenized:\n", " vocab_set.update(doc)\n", " vocab = sorted(list(vocab_set))\n", " \n", " # 3. 构建TF矩阵并计算IDF\n", " n_docs = len(tokenized)\n", " tf_matrix = []\n", " df_dict = {word: 0 for word in vocab}\n", " \n", " for doc in tokenized:\n", " vec = [0] * len(vocab)\n", " for word in doc:\n", " if word in vocab:\n", " idx = vocab.index(word)\n", " vec[idx] += 1\n", " tf_matrix.append(vec)\n", " \n", " # 计算DF\n", " for vec in tf_matrix:\n", " for j, count in enumerate(vec):\n", " if count > 0:\n", " word = vocab[j]\n", " df_dict[word] += 1\n", " \n", " # 计算IDF\n", " idf = []\n", " for word in vocab:\n", " df = df_dict[word]\n", " idf_j = math.log(n_docs / (df + 1)) + 1\n", " idf.append(idf_j)\n", " \n", " # 计算TF-IDF\n", " tfidf = []\n", " for vec in tf_matrix:\n", " tfidf_vec = [vec[i] * idf[i] for i in range(len(vec))]\n", " tfidf.append(tfidf_vec)\n", " \n", " return vocab, tfidf, tokenized\n", "\n", "# 示例文档集合\n", "docs = [\n", " \"Python是一门很棒的编程语言\",\n", " \"人工智能是未来的发展方向\",\n", " \"深度学习是机器学习的一个分支\",\n", " \"Python和Java都是很流行的编程语言\"\n", "]\n", "\n", "# 停用词\n", "stopwords = set([\"的\", \"是\", \"一个\", \"很\", \"和\", \"在\", \"了\"])\n", "\n", "vocab, tfidf_matrix, tokenized = simple_tfidf_tokenized(docs, stopwords)\n", "\n", "print(\"文档集合：\")\n", "for i, doc in enumerate(docs):\n", " print(f\" Doc{i+1}: {doc}\")\n", "print()\n", "\n", "print(f\"分词结果：\")\n", "for i, words in enumerate(tokenized):\n", " print(f\" Doc{i+1}: {' / '.join(words)}\")\n", "print()\n", "\n", "print(f\"词表（共{len(vocab)}个词）:\")\n", "print(f\" {vocab}\")\n", "print()\n", "\n", "print(\"TF-IDF矩阵：\")\n", "for i, vec in enumerate(tfidf_matrix):\n", " # 只显示非零值\n", " nonzero = [(vocab[j], round(vec[j], 4)) for j in range(len(vec)) if vec[j] > 0]\n", " print(f\" Doc{i+1}: {nonzero}\")\n", "\n", "print()\n", "\n", "# 找每个文档最重要的词\n", "print(\"每个文档最重要的词（TF-IDF值最高）：\")\n", "for i, vec in enumerate(tfidf_matrix):\n", " max_idx = max(range(len(vec)), key=lambda j: vec[j])\n", " max_score = vec[max_idx]\n", " if max_score > 0:\n", " print(f\" Doc{i+1}: '{vocab[max_idx]}' (TF-IDF={max_score:.4f})\")" ] }, { "cell_type": "markdown", "metadata": { "jp-MarkdownHeadingCollapsed": true }, "source": [ "---\n", "\n", "# 📋 总结\n", "\n", "## 本章核心概念\n", "\n", "```\n", "文本数据处理\n", " │\n", " ├── 核心问题：文本(符号) → 向量(数字)\n", " │\n", " ├── 向量化方法\n", " │ ├── BoW（词袋模型）\n", " │ │ └── 核心：统计词频，忽略顺序\n", " │ │\n", " │ ├── TF-IDF（词频-逆文档频率）\n", " │ │ └── 核心：词的重要性 × 词的独特性\n", " │ │\n", " │ └── Word Embedding（词嵌入）\n", " │ └── 核心：用语义空间表示词\n", " │\n", " └── 处理流程\n", " ├── 文本预处理（分词、去停用词）\n", " ├── 向量化\n", " └── 下游任务（分类、相似度、生成）\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 关键公式速查\n", "\n", "| 方法 | 公式 | 含义 |\n", "|------|------|------|\n", "| 向量加法 | [1,2] + [3,4] = [4,6] | 对应位置相加 |\n", "| 向量数乘 | 2 × [1,2] = [2,4] | 每个元素乘以标量 |\n", "| 向量点积 | [1,2] · [3,4] = 11 | 对应相乘再求和 |\n", "| 向量长度 | |[3,4]| = √(3²+4²) = 5 | 勾股定理 |\n", "| 余弦相似度 | cos(θ) = (A·B) / (|A|×|B|) | 向量相似程度 |\n", "| TF-IDF | TF × IDF | 词频 × 逆文档频率 |\n", "\n", "---\n", "\n", "> **记住：文本向量化的核心目标是把\"符号\"变成\"可计算的数值向量\"！**" ] } ], "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.11.6" } }, "nbformat": 4, "nbformat_minor": 4 }