# 📚 3-2-1 文本数据处理导论

---

# 🎯 本章学习目标

| 目标 | 内容 |
|------|------|
| **理解** | 什么是文本数据，以及计算机如何读取文本 |
| **掌握** | 为什么文本不能直接用于计算机计算 |
| **理解** | 向量、相似度的基本概念（零基础讲解） |
| **掌握** | 文本向量化的核心思想与数学原理 |
| **了解** | 从 BoW → TF-IDF → Embedding 的演进逻辑 |

---

# 📖 第一部分：什么是文本数据？

## 1.1 文本数据的定义

**文本数据**是由文字、符号组成的序列信息，是人类语言在计算机中的表示形式。

### 文本数据的例子

```
一句话："今天天气真好"
一篇文章：一篇新闻报道
一条评论："这家餐厅的菜太好吃了！"
一段对话："你好，请问这本书多少钱？"
一首诗："床前明月光，疑是地上霜"
```

### 文本数据的特征

| 特征 | 说明 | 示例 |
|------|------|------|
| **离散符号** | 由离散的字符/词组成 | "hello" 由 h,e,l,l,o 这5个字符组成 |
| **序列性** | 符号按特定顺序排列 | "我爱你" ≠ "你爱我" |
| **语义丰富** | 同样的词不同场景意思不同 | "苹果"可以是水果或手机品牌 |
| **上下文相关** | 词的意思依赖上下文 | "他打了猫，猫跑了" 中两个"猫"意思相同 |

## 1.2 计算机如何"读取"文本？

### 对比：图像 vs 文本

**图像数据的读取：**

```
图像文件（.jpg/.png）
    ↓
计算机读取像素值
    ↓
存储为3维矩阵 [高度, 宽度, 通道]
    ↓
一张 1920×1080 的彩色图 = 1920 × 1080 × 3 = 6,220,800 个数字
```

**文本数据的读取：**

```
文本文件（.txt/.md）
    ↓
计算机读取字符编码（ASCII/UTF-8）
    ↓
存储为字符序列（每个字符是一个数字编码）
    ↓
"Python" → [80, 121, 116, 104, 111]（ASCII编码）
```

### 字符编码：用数字表示字符

计算机并不能直接"认识"字符，它只认识数字。所以需要一种**映射规则**把字符变成数字：

```
ASCII编码（英文）：
'A' → 65, 'B' → 66, ..., 'Z' → 90
'a' → 97, 'b' → 98, ..., 'z' → 122
'0' → 48, '1' → 49, ..., '9' → 57

UTF-8编码（支持中文）：
'中' → 20013, '文' → 25991, 'P' → 80, 'y' → 121
```

### 文本的"存储形式"

```python
# 文本在计算机中的存储方式
text = "Hello"

# 如果我们看它的"数字形式"：
print([ord(c) for c in text])
# 输出: [72, 101, 108, 108, 111]
# 72='H', 101='e', 108='l', 111='o'

# 中文例子
text_cn = "你好"
print([ord(c) for c in text_cn])
# 输出: [20320, 22909]
# 20320='你', 22909='好'
```

## 1.3 计算机擅长什么？不擅长什么？

### 计算机擅长的任务

```
✅ 数字计算：1 + 2 = 3
✅ 逻辑判断：if (a > b) then ...
✅ 矩阵运算：图像卷积、矩阵乘法
✅ 精确匹配：字符串完全相同比较
✅ 模式识别：符合规则的数据查找
```

### 计算机不擅长的任务

```
❌ 语义理解：计算机不知道"今天天气真好"是好心情还是讽刺
❌ 情感判断：计算机不知道"真是绝了"是夸人还是骂人
❌ 模糊推理："大概"、"也许"、"差不多"无法精确处理
❌ 创意创作：写诗、写小说、编笑话
❌ 常识理解："水往低处流"这种常识计算机不懂
```

### 为什么计算机不擅长理解文本？

**原因一：文本是"符号"，不是"数值"**

```
计算机大脑 = 计算器（专门处理数字）
文本 = 一堆符号（对计算机来说就像乱码）

数字：1, 2, 3, 100.5, -7  → 计算机直接能算
文本："好"、"bad"、"hello" → 计算机不知道啥意思
```

**原因二：语义不是显式表达的**

```
文本："他今天心情不太好，因为下雨了"

计算机看到：[他, 今天, 心情, 不, 好, 因为, 下雨, 了]
          ↓
人类理解：他在不开心，因为外面下雨了（影响心情）
          ↓
计算机：？？？不理解下雨和心情的因果关系
```

**原因三：同样的符号，不同的语境，不同的意思**

```
"苹果真好吃"
→ 说的是水果

"苹果手机真贵"
→ 说的是手机品牌

计算机怎么知道？因为有上下文！
但计算机理解上下文的能力很弱
```

---

# 📖 第二部分：向量基础入门（零基础科普）

## 2.1 什么是向量？

### 向量的直观理解

**向量 = 有方向的量**

```
在日常生活中：
・速度：每小时60公里，向北走
・力：10牛顿，向右推
・风向：东南风，每秒5米

这些都是有"方向"和"大小"的量，就是向量！
```

### 向量在数学中的表示

**一维向量（数轴上的点）：**

```
     ←———————————|———————————→
   -3    -2    -1     0     1     2     3

   点A在位置 2  →  向量A = [2]
   点B在位置 -3 →  向量B = [-3]
```

**二维向量（平面上的点）：**

```
        y
        ↑
        |
    3   |    * A(2,3)
        |
    2   |
        |
    1   |         * B(4,1)
        |
    0---+—————————————→ x
        0  1  2  3  4  5
       
   向量A = [2, 3]  （横坐标2，纵坐标3）
   向量B = [4, 1]
```

**三维向量（立体空间）：**

```
        z
        ↑    * C(1,2,3)
        |   /
        |  /
        | /
        |/__________→ y
       /
      /
     /_________→ x
    (0,0,0)
    
   向量C = [1, 2, 3]
```

### Python中创建向量

```python
import numpy as np

# 一维向量
v1 = np.array([3])          # 只有1个数字
print(f"v1 = {v1}")

# 二维向量
v2 = np.array([2, 3])       # 2个数字，表示平面上的一个点
print(f"v2 = {v2}")

# 三维向量
v3 = np.array([1, 2, 3])    # 3个数字，表示立体空间的一个点
print(f"v3 = {v3}")

# 更多维向量（机器学习中常用）
v100 = np.array([0.1, 0.5, -0.3, 0.8, ...])  # 100维！
print(f"v100有 {len(v100)} 个元素")
```

## 2.2 向量的基本运算

### 加法和减法

```python
import numpy as np

# 向量加法：对应位置相加
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = a + b  # [1+4, 2+5, 3+6] = [5, 7, 9]

print(f"a + b = {c}")  # [5, 7, 9]

# 直观理解：
# a = [1, 2, 3] 从原点出发走1步、再走2步、再走3步
# b = [4, 5, 6] 从原点出发走4步、再走5步、再走6步
# a + b = 从原点走完a再走b = [5, 7, 9]
```

### 数乘（标量乘法）

```python
# 向量乘以一个数字（标量）
v = np.array([1, 2, 3])
result = v * 2  # [1*2, 2*2, 3*2] = [2, 4, 6]

print(f"v * 2 = {result}")  # [2, 4, 6]

# 直观理解：
# v = [1, 2, 3] 表示"方向"
# v * 2 = [2, 4, 6] 方向不变，长度变成2倍
```

### 向量的长度（模/范数）

```python
# 向量的长度 = 从原点到终点的距离
v = np.array([3, 4])

# 用勾股定理：3² + 4² = 25，√25 = 5
length = np.linalg.norm(v)
print(f"向量 [3, 4] 的长度 = {length}")  # 5.0

# 另一个例子
v2 = np.array([1, 1])
length2 = np.linalg.norm(v2)
print(f"向量 [1, 1] 的长度 = {length2:.2f}")  # 1.41
```

## 2.3 点积（Dot Product）— 最重要的运算

### 什么是点积？

**点积 = 对应位置相乘，再求和**

```python
# 两个向量对应位置相乘，然后加起来
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 点积计算过程：
# 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32

dot = np.dot(a, b)
print(f"点积 = {dot}")  # 32

# 或者用 @ 运算符
print(f"a @ b = {a @ b}")  # 32
```

### 点积的直观理解

```
点积 = a的长度 × b的长度 × cos(夹角)

如果 a 和 b 方向相同：夹角 = 0°，cos(0) = 1，点积 = |a|×|b|（最大）
如果 a 和 b 垂直：   夹角 = 90°，cos(90) = 0，点积 = 0（最小）
如果 a 和 b 相反：   夹角 = 180°，cos(180) = -1，点积 = -|a|×|b|（负最大）
```

## 2.4 余弦相似度 — 用点积判断"像不像"

### 什么是相似度？

**相似度 = 两个向量有多"像"**

```
相似度高的例子：
・"猫"和"狗"：都是动物，都四只脚，都会叫
・"红色"和"黄色"：都是颜色，都是暖色调
・"跑步"和"游泳"：都是运动

相似度低的例子：
・"猫"和"石头"：一个是动物，一个不是
・"热"和"冷"：意思相反
・"太阳"和"细菌"：几乎没有共同点
```

### 余弦相似度公式

```
            A · B
cos(θ) = ──────────
          |A| × |B|

・A · B = 向量A和B的点积
・|A| = 向量A的长度
・|B| = 向量B的长度
・cos(θ) = 相似度，范围是 [-1, 1]
```

### 余弦相似度的值代表什么？

| cos(θ) 值 | 夹角 θ | 相似程度 | 示例 |
|----------|--------|---------|------|
| 1.0 | 0° | 完全相同 | 同一向量 |
| 0.8~0.99 | 0~37° | 非常相似 | "猫" vs "狗" |
| 0.5~0.8 | 0~60° | 比较相似 | "跑步" vs "运动" |
| 0.3~0.5 | 60~72° | 有些相似 | "苹果" vs "水果" |
| 0 | 90° | 毫不相关 | "猫" vs "石头" |
| -1.0 | 180° | 完全相反 | "高" vs "矮" |

### Python计算余弦相似度

```python
import numpy as np

def cosine_similarity(a, b):
    """计算余弦相似度"""
    dot = np.dot(a, b)           # 点积
    norm_a = np.linalg.norm(a)  # 向量a的长度
    norm_b = np.linalg.norm(b)  # 向量b的长度
    return dot / (norm_a * norm_b)

# 例子1：方向完全相同的向量
a = np.array([1, 2, 3])
b = np.array([2, 4, 6])  # b是a的两倍，方向完全相同
print(f"相似度 = {cosine_similarity(a, b):.3f}")  # 1.000

# 例子2：方向完全相反的向量
a = np.array([1, 2, 3])
b = np.array([-1, -2, -3])  # b是a的相反方向
print(f"相似度 = {cosine_similarity(a, b):.3f}")  # -1.000

# 例子3：垂直的向量
a = np.array([1, 0])
b = np.array([0, 1])
print(f"相似度 = {cosine_similarity(a, b):.3f}")  # 0.000

# 例子4：日常生活中的"相似"
print("\n=== 语义相似度示例 ===")
# 假设这些是词的"意义向量"（简化版）
# 维度：[是否是动物, 是否有生命, 是否能移动]
cat = np.array([0.9, 0.9, 0.8])   # 猫：动物，有生命，能移动
dog = np.array([0.8, 0.9, 0.8])   # 狗：动物，有生命，能移动
apple = np.array([0.1, 0.3, 0.0]) # 苹果：植物，略有生命，不能移动

print(f"猫 vs 狗: {cosine_similarity(cat, dog):.3f}")    # 非常接近1
print(f"猫 vs 苹果: {cosine_similarity(cat, apple):.3f}") # 接近0
```

---

# 📖 第三部分：文本向量化的核心思想

## 3.1 核心目标：把所有文本变成"向量"

```
文本（符号） → 数值向量 → 计算机可以计算 → AI模型处理
```

**为什么必须是向量？**

```
因为计算机擅长：
・向量加减：v1 + v2 = ?
・向量点积：v1 · v2 = ?
・向量距离：||v1 - v2|| = ?
・余弦相似度：cos(θ) = ?

但计算机不擅长：
・字符串比较："Python" == "Java" ?
・词语推理："猫" 类似于 "狗" ?
```

**文本向量化的意义：**

```
"猫"和"狗"在文本中可能完全不相关
但如果我们知道它们都是"动物"，向量就会接近
计算机就能"理解"它们的相似性了！
```

## 3.2 向量化示例：从"词"到"数"

### 简单例子：把词变成向量（位置编码）

```python
# 假设我们有一个很小的词汇表（只有5个词）
vocab = ["猫", "狗", "鱼", "苹果", "香蕉"]

# 位置编码：每个词对应一个位置
# "猫" → [1, 0, 0, 0, 0]  # 第1个位置是1，其他是0
# "狗" → [0, 1, 0, 0, 0]  # 第2个位置是1，其他是0
# "苹果" → [0, 0, 0, 1, 0]  # 第4个位置是1，其他是0
```

**问题**：这只是"位置编码"，没有语义信息！

```
"猫" = [1, 0, 0, 0, 0]
"狗" = [0, 1, 0, 0, 0]

余弦相似度 = 0  （完全不相似）

但实际上"猫"和"狗"都是动物，应该很相似！
```

### 更智能的例子：语义向量

```python
# 语义编码：每个词用"含义"来表示
# 维度：[动物性, 植物性, 可食用性, 宠物性]

cat = np.array([0.9, 0.1, 0.7, 0.9])   # 猫：动物性高，可食用（猫肉？），是宠物
dog = np.array([0.8, 0.2, 0.6, 0.9])   # 狗：动物性高，可食用（狗肉？），是宠物
apple = np.array([0.1, 0.9, 0.9, 0.0]) # 苹果：植物性高，可食用，不是宠物

# 计算相似度
print(f"猫 vs 狗: {cosine_similarity(cat, dog):.3f}")    # ≈ 0.97（很相似！）
print(f"猫 vs 苹果: {cosine_similarity(cat, apple):.3f}") # ≈ 0.15（不太相似）
```

**这就是文本向量化的威力：把"语义"变成"可计算的数值"！**

## 3.3 向量化方法演进

### 演进概览

```
文本向量化的三种主要方法：

[BoW] ───→ [TF-IDF] ───→ [Word Embedding]
(词袋模型)   (词频权重)    (词向量嵌入)

简单粗暴    加入词重要性    蕴含语义信息
无语义     部分语义        深度语义
```

### BoW（词袋模型）—— 最简单的方法

**原理**：把文本看成"一袋词"，不考虑顺序，只管词出现了几次。

```
文本1: "Python 是 编程 语言"
文本2: "Java  是 编程 语言"

词表: [Python, Java, 是, 编程, 语言]
```

**向量化：**

```python
from sklearn.feature_extraction.text import CountVectorizer

# 文档集合
docs = [
    "Python 是 编程 语言",
    "Java  是 编程 语言",
]

# BoW 向量化
vectorizer = CountVectorizer()
bow_matrix = vectorizer.fit_transform(docs)

print("词表:", vectorizer.get_feature_names_out())
# 输出: ['Python', 'Java', '是', '编程', '语言']

print("BoW矩阵:")
print(bow_matrix.toarray())
# 输出:
# [[1 0 1 1 1]   # Python文档: Python=1, Java=0, 是=1, 编程=1, 语言=1
#  [0 1 1 1 1]]  # Java文档:  Python=0, Java=1, 是=1, 编程=1, 语言=1
```

### BoW 的优缺点

| 优点 | 缺点 |
|------|------|
| 简单直观 | 忽略词序 |
| 容易实现 | "我爱你"和"你爱我"向量完全相同 |
| 计算速度快 | 所有词同等重要 |
| 适合基线模型 | 无法捕捉语义 |

### TF-IDF —— 加入词的重要性

**问题**：BoW 中"Python"和"的"权重相同，这不合理！

**TF-IDF = 词频(TF) × 逆文档频率(IDF)**

```
TF = 这个词在本文中出现了多少次
IDF = 这个词在所有文档中多不多（越多越不重要）

TF-IDF = TF × IDF
```

**为什么有效？**

```
・高频出现 ≠ 重要
  "的"在所有文章都出现 → TF高, IDF低 → TF-IDF低 ❌ 停用词

・罕见词 ≠ 不重要
  "TensorFlow"只在AI文章出现 → TF低, IDF高 → TF-IDF高 ✅ 重要词

・既高频又独特 = 真正重要的词
```

**TF-IDF 示例：**

```python
from sklearn.feature_extraction.text import TfidfVectorizer

docs = [
    "Python 编程 语言",
    "Python Python Python",  # Python出现3次
    "Java  编程 语言",
]

tfidf_vectorizer = TfidfVectorizer()
tfidf_matrix = tfidf_vectorizer.fit_transform(docs)

print("词表:", tfidf_vectorizer.get_feature_names_out())
print("\nTF-IDF矩阵:")
print(tfidf_matrix.toarray())

# 观察：Python在第2篇文档中出现3次，但TF-IDF值不是最高的
# 因为"Python"在所有文档都出现了，IDF值较低
```

### Word Embedding（词嵌入）—— 蕴含语义

**BoW 和 TF-IDF 的根本问题**

```
"猫" → [1, 0, 0, ...]   # 只是"位置编码"
"狗" → [0, 1, 0, ...]   # 猫和狗的位置不同
"小猫" → [0, 0, 1, ...] # 但它们语义相近，向量却正交！
```

**问题**：无法表达语义相似性！

**Embedding 的思想**

```
不再用"位置"表示词，而是用"语义空间"表示词

语义空间中的位置：
    ↑
  动物                                        植物
    |      ↑ 猫      ↑ 狗                      ↑ 苹果
    |     ↗         ↗                          ↑
    |   ↗         ↗            ← 语义相近的词距离近 →
    | ↗         ↗                    →
    |——————————————————————————————————————→
  0           抽象                            具体
```

**词嵌入的效果**

```python
# 假设我们用预训练模型得到了词的语义向量
# 实际中向量通常是 50/100/300 维，这里用3维举例

word_vectors = {
    "猫": [0.9, 0.1, 0.2],    # 动物属性高
    "狗": [0.8, 0.3, 0.1],    # 动物属性高
    "苹果": [0.1, 0.2, 0.9],   # 水果属性高
    "Python": [0.1, 0.0, 0.9],  # 编程属性高
    "Java": [0.1, 0.0, 0.85],   # 编程属性高
}

print("=== 语义相似度 ===")
print(f"猫 vs 狗: {cosine_similarity(word_vectors['猫'], word_vectors['狗']):.3f}")
# 输出: 猫 vs 狗: 0.972（非常相似！都是动物）

print(f"猫 vs 苹果: {cosine_similarity(word_vectors['猫'], word_vectors['苹果']):.3f}")
# 输出: 猫 vs 苹果: 0.149（不太相似！）

print(f"Python vs Java: {cosine_similarity(word_vectors['Python'], word_vectors['Java']):.3f}")
# 输出: Python vs Java: 0.998（非常相似！都是编程语言）
```

---

# 📖 第四部分：文本处理的完整流程

## 4.1 流程图

```
┌──────────────────────────────────────────────────────────────────┐
│                        文本数据                                    │
│                   "今天天气真不错！"                                │
└─────────────────────────┬────────────────────────────────────────┘
                          │
                          ▼
┌──────────────────────────────────────────────────────────────────┐
│                     1. 文本预处理                                  │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐               │
│  │ 分词    │→ │ 去停用词│→ │ 统一大小│→ │ 去除标点│               │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘               │
│  "今天/天气/真/不错"   →   "今天/天气/不错"                        │
└─────────────────────────┬────────────────────────────────────────┘
                          │
                          ▼
┌──────────────────────────────────────────────────────────────────┐
│                     2. 文本向量化                                  │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐               │
│  │ BoW    │  │ TF-IDF  │  │ Embedding│  │ 预训练模型│              │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘               │
│       ↓            ↓            ↓            ↓                     │
│   [1,0,2,0,1]  [0.5,0,0.8]  [0.9,0.3]   [BERT向量]              │
└─────────────────────────┬────────────────────────────────────────┘
                          │
                          ▼
┌──────────────────────────────────────────────────────────────────┐
│                     3. 下游任务                                    │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐             │
│  │ 分类    │  │ 相似度  │  │ 聚类    │  │ 生成    │             │
│  │ 情感分析│  │ 文本匹配│  │ 主题分组│  │ 聊天机器人│            │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘             │
└──────────────────────────────────────────────────────────────────┘
```

## 4.2 各环节详解

### 环节1：文本预处理

**为什么需要预处理？**

```
原始文本：
"今天天气真不错！！Python是一门很棒的语言，python也很重要！！！"

预处理后：
["今天", "天气", "不错", "Python", "语言"]
```

**预处理步骤：**

| 步骤 | 输入 | 输出 | 作用 |
|------|------|------|------|
| 分词 | "今天天气不错" | ["今天", "天气", "不错"] | 把文本切成词 |
| 去停用词 | ["今天", "天气", "不错"] | ["天气", "不错"] | 去掉"的、了、在"等无意义词 |
| 统一大小写 | ["Python", "python"] | ["python", "python"] | 归一化 |
| 去标点 | ["语言!!!"] | ["语言"] | 清理噪音 |

### 环节2：文本向量化

**选择向量化方法的原则：**

| 方法 | 适用场景 | 不适用场景 |
|------|---------|-----------|
| BoW | 基线模型、快速原型 | 需要语义理解 |
| TF-IDF | 文本分类、关键词提取 | 同义词识别 |
| Embedding | 语义相似度、推荐系统 | 需要精确匹配 |
| 预训练模型 | 通用NLP任务 | 计算资源有限 |

### 环节3：下游任务

```
分类任务：
"这部电影太好看了！" → [正面, 0.95] → 正面情感 ✅

相似度任务：
"如何学习Python？" → 找到相似的："Python入门教程" ✅

生成任务：
"今天天气" → 续写："今天天气真好，适合出去玩" ✅
```

---

# 📖 第五部分：工具生态概览

## 5.1 Python NLP 工具箱

```
┌─────────────────────────────────────────────────────────┐
│                    中文分词工具                          │
├─────────────────────────────────────────────────────────┤
│  jieba（结巴）    ・最流行的中文分词库                     │
│                   ・支持精确/全/搜索引擎模式               │
│                   ・pip install jieba                    │
├─────────────────────────────────────────────────────────┤
│  HanLP           ・功能强大，支持词性标注、命名实体识别     │
│  SnowNLP         ・简单好用，专注文本处理                  │
│  LTP             ・哈工大出品，准确率高                    │
└─────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────┐
│                    英文NLP工具                           │
├─────────────────────────────────────────────────────────┤
│  NLTK             ・经典NLP库，教学首选                   │
│  spaCy            ・速度快，工业级                        │
│  Stanford NLP     ・学术标准，准确性高                   │
└─────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────┐
│                  文本向量化工具                          │
├─────────────────────────────────────────────────────────┤
│  scikit-learn    ・BoW、TF-IDF 实现                      │
│  Gensim           ・Word2Vec、Doc2Vec                   │
│  TensorFlow/PyTorch ・深度学习文本处理                   │
│  transformers     ・BERT、GPT 等预训练模型                │
└─────────────────────────────────────────────────────────┘
```

## 5.2 本课程使用的工具

| 工具 | 用途 | 安装命令 |
|------|------|---------|
| jieba | 中文分词 | `pip install jieba` |
| sklearn | TF-IDF、向量化 | `pip install scikit-learn` |
| numpy | 数值计算 | `pip install numpy` |
| matplotlib | 可视化 | `pip install matplotlib` |

---

# 📖 第六部分：本章知识地图

## 6.1 核心概念

```
文本数据处理
    │
    ├── 核心问题：文本(符号) → 向量(数字)
    │
    ├── 向量化方法
    │     ├── BoW（词袋模型）
    │     │     └── 核心：统计词频，忽略顺序
    │     │
    │     ├── TF-IDF（词频-逆文档频率）
    │     │     └── 核心：词的重要性 × 词的独特性
    │     │
    │     └── Word Embedding（词嵌入）
    │           └── 核心：用语义空间表示词
    │
    └── 处理流程
          ├── 文本预处理（分词、去停用词）
          ├── 向量化
          └── 下游任务（分类、相似度、生成）
```

## 6.2 数学公式速查

| 方法 | 公式 | 含义 |
|------|------|------|
| 向量加法 | [1,2] + [3,4] = [4,6] | 对应位置相加 |
| 向量数乘 | 2 × [1,2] = [2,4] | 每个元素乘以标量 |
| 向量点积 | [1,2] · [3,4] = 11 | 对应相乘再求和 |
| 向量长度 | |[3,4]| = 5 | √(3²+4²) |
| 余弦相似度 | cos(θ) = (A·B) / (\|A\|×\|B\|) | 向量相似程度 |

---

# 📝 课后作业

## 第一部分：文本数据基础（1-2道）

### 题目1
在Python中，用两种方式表示"Hello"：
1. 用 `ord()` 函数打印每个字符的ASCII码
2. 用 `chr()` 函数验证：字符65对应的是大写字母A

### 题目2
思考题：为什么计算机擅长处理图像矩阵，却不擅长处理文本？请从"数据的表示形式"和"语义理解"两个角度说明原因。

---

## 第二部分：向量基础（1-2道）

### 题目3
已知向量 A = [3, 4]，B = [1, 2]：
1. 计算 A + B 的结果
2. 计算 2 × A 的结果
3. 计算 A 的长度（模）

### 题目4
有两个向量：A = [1, 2, 3]，B = [4, 5, 6]
1. 计算它们的点积 A · B
2. 计算它们的余弦相似度
3. 如果 A = [1, 0]，B = [0, 1]，它们的余弦相似度是多少？为什么？

---

## 第三部分：文本向量化（1-2道）

### 题目5
假设有以下3个文档：
- Doc1: "Python 是 编程 语言"
- Doc2: "Java 是 编程 语言"
- Doc3: "Python Python Python"

使用BoW模型，词表是什么？每个文档的向量表示是什么？

### 题目6
思考题：BoW模型有哪些缺点？请至少列出2个，并说明为什么这些缺点在某些场景下会成为问题。

---

## 附加题（选做）

### 题目7
阅读以下代码，理解TF-IDF的工作原理：

```python
from sklearn.feature_extraction.text import TfidfVectorizer

docs = ["Python 编程", "Java 编程", "Python Python"]
tfidf = TfidfVectorizer()
matrix = tfidf.fit_transform(docs)

print("词表:", tfidf.get_feature_names_out())
print("TF-IDF矩阵:")
print(matrix.toarray())
```

运行代码并回答：
1. 为什么"Python"在Doc3中的TF-IDF值不是最高（假设Doc1和Doc2的值更小）？
2. "Java"在Doc2中的TF-IDF值是多少？解释原因。

---

# 🚀 下节预告

下一节我们将进入 **3-2-2：分词与文本清洗**，
学习：
- 如何用 jieba 进行中文分词
- 停用词的作用与过滤方法
- 代码实战：清洗豆瓣评论数据

---

> 🎯 **记住：文本向量化的核心目标是把"符号"变成"可计算的数值向量"！**