📚 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

文本的"存储形式"

# 文本在计算机中的存储方式
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中创建向量

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 向量的基本运算

加法和减法

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]

数乘（标量乘法）

# 向量乘以一个数字（标量）
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倍

向量的长度（模/范数）

# 向量的长度 = 从原点到终点的距离
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）— 最重要的运算

什么是点积？

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

# 两个向量对应位置相乘，然后加起来
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计算余弦相似度

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 向量化示例：从"词"到"数"

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

# 假设我们有一个很小的词汇表（只有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  （完全不相似）

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

更智能的例子：语义向量

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

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, 是, 编程, 语言]

向量化：

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 示例：

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           抽象                            具体

词嵌入的效果

# 假设我们用预训练模型得到了词的语义向量
# 实际中向量通常是 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]
余弦相似度	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的工作原理：

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 进行中文分词
• 停用词的作用与过滤方法
• 代码实战：清洗豆瓣评论数据

---

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