printsdf's Blog

大模型 1/?

Sat, 24 Jan 2026 07:28:00 GMT

我们向 GPT 输入的文字是如何被它处理的？#

众所周知，计算机是不理解人类的自然语言，所以需要做一些适配计算机的处理。例如下方的图片，我们输入“The cat sat ___”，它会经历下面几个流程：

首先是分词，计算机的单位是 Token（词元）而不是单词，我们会使用一个分词算法 BPE 将单词划分为 Token。
之后这些 Token （包括位置编码）便会进入到 Embedding Matrix，这个矩阵的作用是将刚才我们输入的自然语言转换为这个 Token 的特征向量。
经过 Transformer 层之后我们选取最后一列作为 GPT 的预测特征向量，通过 Unembedding Matrix 将特征向量又转换为 Token，从而实现了自然语言的输入与输出过程。

而这其实就是所谓的“Embedding”，即将自然语言转换为计算机能够理解的数字向量，这些向量并不是随机的数字组合，它们其实是带有语义信息的。

经典案例：国王与王后的数学逻辑#

在高质量的 Embedding 模型中，你会发现以下有趣的现象：

Vector(“国王”)−Vector(“男人”)+Vector(“女人”)≈Vector(“王后”)Vector(\text{“国王”}) - Vector(\text{“男人”}) + Vector(\text{“女人”}) \approx Vector(\text{“王后”}) Vector(“国王”)−Vector(“男人”)+Vector(“女人”)≈Vector(“王后”)

这个公式背后的逻辑是：

提取特征：当“国王”减去“男人”，模型实际上在语义层面去掉了“男性”这个维度，剩下了“皇室/统治者”的核心含义。
赋予特征：再加上“女人”，模型将“皇室/统治者”与“女性”特征结合，最终指向了空间中距离“王后”最近的坐标点。

Note

除了加减法，Embedding 的强大之处还在于距离。在计算机的向量空间里，意思相近的词，其坐标位置也非常接近。

例如：

“苹果”和“梨”的距离，会比“苹果”和“自行车”的距离近得多。
“开心”和“愉悦”在多维空间中几乎是重叠的，而“开心”和“愤怒”则会处于截然相反的方向。

这种特性让计算机不再只是进行简单的“字符串匹配”，而是真正开始“理解”内容。即使你搜索“好吃的红果子”，Embedding 也能让搜索引擎联想到“苹果”或“草莓”，因为它知道这些词在语义空间里是邻居。

Note

Embedding 的本质：高维特征映射

如果把每一个词看作一个多维度的“身份标签”，Embedding 就像是在给每个词打分。一个 512 维的向量，意味着计算机从 512 个不同的角度（虽然这些角度对人类来说可能难以直接描述）去审视这个词：

维度	维度描述 (假设)	“猫” 的数值	“狗” 的数值	“手机” 的数值
Dim 1	是否为生物	0.98	0.99	0.02
Dim 2	是否有毛发	0.95	0.92	0.01
Dim 3	是否为电子产品	0.01	0.02	0.97

通过这种方式，自然语言的模糊性被转化为了数学的精确性。

获取 Outlook Refresh Token

Thu, 16 Apr 2026 00:00:00 GMT

在使用 Outlook（Microsoft 365 / Hotmail）进行邮件自动化、IMAP/SMTP 登录或开发项目时，经常需要获取 Refresh Token。但很多在线工具容易出现 different client id 或 invalid_scope 等问题。

本文提供一个 纯浏览器 + curl 的稳定方法，无需注册应用、无需安装复杂工具，适合 macOS 用户。

适用场景#

需要长期使用 Outlook IMAP / SMTP
自动化收发邮件、获取验证码等
不想自己注册 Azure App

使用到的 Client ID#

我们使用 Thunderbird 的公开 Client ID（社区最常用、最稳定）：

Client ID: 9e5f94bc-e8a4-4e73-b8be-63364c29d753

详细操作步骤#

步骤 1：获取授权码（Authorization Code）#

打开 Safari 或 Chrome 浏览器。
完整复制下面这个链接并粘贴到地址栏打开：

1
https://login.microsoftonline.com/common/oauth2/v2.0/authorize?client_id=9e5f94bc-e8a4-4e73-b8be-63364c29d753&response_type=code&redirect_uri=https://localhost&response_mode=query&scope=offline_access%20https://outlook.office.com/IMAP.AccessAsUser.All%20https://outlook.office.com/POP.AccessAsUser.All%20https://outlook.office.com/SMTP.Send

使用你的 Outlook / Hotmail 账号登录。
点击接受或同意所有请求的权限。
页面会跳转失败（显示无法连接 localhost，这是正常现象）。
立即在地址栏找到 code= 后面的那一长串字符，完整复制（从 code= 开始，直到下一个 & 符号之前）。

⚠️ 注意：授权码有效期很短（约 5-10 分钟），请尽快进行下一步。

步骤 2：用授权码换取 Refresh Token#

打开 Mac 的终端（Terminal）。
复制下面整条命令：

Terminal window

1
curl -X POST https://login.microsoftonline.com/common/oauth2/v2.0/token \
2
  -d 'client_id=9e5f94bc-e8a4-4e73-b8be-63364c29d753' \
3
  -d 'scope=offline_access https://outlook.office.com/IMAP.AccessAsUser.All https://outlook.office.com/POP.AccessAsUser.All https://outlook.office.com/SMTP.Send' \
4
  -d 'code=你的授权码' \
5
  -d 'grant_type=authorization_code' \
6
  -d 'redirect_uri=https://localhost'

把上面命令中的 你的授权码 替换为你刚刚复制的那一长串 code（注意不要加空格或额外引号）。
按回车执行。

步骤 3：查看返回结果#

如果操作成功，你会看到类似下面的 JSON 返回：

1
{
2
  "token_type": "Bearer",
3
  "scope": "...",
4
  "expires_in": 3600,
5
  "access_token": "EwAw...",
6
  "refresh_token": "0.AwAxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
7
  ...
8
}

重点复制：

refresh_token 的值（以 0.AwA 开头的那一长串）
client_id：9e5f94bc-e8a4-4e73-b8be-63364c29d753

常见问题与解决#

zsh: event not found

解决：确保所有 -d '内容' 都用单引号 ' 包裹。
The code has expired

解决：授权码过期了，重新执行步骤 1 获取新的 code，然后立即执行步骤 2。
invalid_scope

解决：确认 scope 只使用了 outlook.office.com 系列，不要和 graph.microsoft.com 混用。
invalid_grant: different client id

解决：必须使用上面固定的 Client ID，不能和在线工具混用。

后续使用建议#

将 client_id 和 refresh_token 安全保存。
Refresh Token 有效期通常为 90 天左右，建议定期刷新。
在代码中使用时，推荐用 refresh_token 定期换取新的 access_token。

CS336 2/？

Fri, 27 Mar 2026 00:00:00 GMT

从零实现 BPE Tokenizer：CS336 实战总结#

在斯坦福 CS336（大模型基础）课程中，有一个经典的动手作业：从头实现一个 BPE（Byte Pair Encoding）Tokenizer。这篇文章记录了完整的实现思路、核心数据结构，以及那些真实踩过的坑。

什么是 BPE Tokenizer？#

BPE Tokenizer 的核心职责很简单：

encode：把一段文本转换成 token ID 序列
decode：把 token ID 序列还原回文本

看起来简单，但实现细节充满陷阱。

核心数据结构#

1
vocab: dict[int, bytes]        # ID → bytes
2
merges: list[tuple[bytes, bytes]]  # 按创建顺序排列的合并规则
3
reverse_vocab: dict[bytes, int]    # bytes → ID（初始化时构建）

三个结构各司其职：

vocab 是主索引，给 decode 用
merges 记录了 BPE 训练出的所有合并规则，顺序至关重要
reverse_vocab 是 vocab 的反向查找表，初始化时一次性构建，encode 时高频使用

encode 流程#

encode 分两个阶段处理：special tokens 和普通文本。

第一步：用 special tokens 切分文本#

1
# 构建正则，special tokens 按长度降序排列
2
sorted_specials = sorted(self.special_tokens, key=len, reverse=True)
3
pattern = "(" + "|".join(re.escape(s) for s in sorted_specials) + ")"
4
parts = regex.split(pattern, text)

关键点 1：用捕获组 (...) 而不是非捕获组 (?:...)

regex.split 如果用非捕获组，分隔符本身会从结果中消失——special token 就丢了。用捕获组才能让 special token 出现在 split 结果里。

关键点 2：special tokens 必须按长度降序排列

如果有 <|im_start|> 和 <|im|> 两个 special token，短的不能优先匹配，否则长的永远匹配不到。排序后构建正则，优先尝试最长匹配。

关键点 3：用排序后的变量构建正则

这听起来是废话，但实际上很容易写成：

1
# 错误写法：忘了用排序后的变量
2
pattern = "(" + "|".join(re.escape(s) for s in self.special_tokens) + ")"

必须用 sorted_specials，不能用原始的 self.special_tokens。

第二步：分别处理每个片段#

1
for part in parts:
2
    if part in self.special_tokens:
3
        ids.append(self.reverse_vocab[part.encode('utf-8')])
4
    else:
5
        ids.extend(self._encode_chunk(part))

special token 片段：直接查 reverse_vocab
普通文本片段：走 _encode_chunk

`_encode_chunk`：BPE 合并的核心#

1
def _encode_chunk(self, text: str) -> list[int]:
2
    # 1. 预分词（用 GPT-2 / tiktoken 风格的 regex）
3
    words = pretokenize(text)
4

5
    ids = []
6
    for word in words:
7
        # 2. UTF-8 编码，转成 tuple[bytes, ...]
8
        tokens = tuple(bytes([b]) for b in word.encode('utf-8'))
9

10
        # 3. 按顺序应用所有 merges
11
        for pair in self.merges:
12
            tokens = apply_merge(tokens, pair)
13

14
        # 4. 查 reverse_vocab 得到 ID
15
        ids.extend(self.reverse_vocab[t] for t in tokens)
16

17
    return ids

显示更多显示更少

关键点：字节迭代的陷阱

Python 中，对 bytes 对象直接迭代得到的是整数，不是单字节 bytes：

1
for b in "hello".encode('utf-8'):
2
    print(type(b))  # <class 'int'>，不是 bytes！

所以必须用：

1
tuple(bytes([b]) for b in word.encode('utf-8'))

而不是：

1
tuple(word.encode('utf-8'))  # 得到整数 tuple，查 reverse_vocab 会 KeyError

decode 流程#

decode 相对简单：

1
def decode(self, ids: list[int]) -> str:
2
    return b''.join(self.vocab[i] for i in ids).decode('utf-8', errors='replace')

先把每个 ID 映射回 bytes，拼接后统一做 UTF-8 解码。用 errors='replace' 处理边界处可能出现的不完整 UTF-8 序列。

踩坑总结#

坑	原因	解法
special token 从 split 结果消失	用了非捕获组 `(?:...)`	改成捕获组 `(...)`
长 special token 匹配失败	正则未排序，短 token 优先	按长度降序排列后构建正则
正则排序没生效	用了原始 `self.special_tokens`	用排序后的 `sorted_specials`
`reverse_vocab` 查找 KeyError	字节迭代得到整数而非 bytes	用 `bytes([b])` 包装每个字节

小结#

BPE Tokenizer 的实现不难，但细节密集。最容易出问题的地方集中在两处：

正则切分 special tokens — 捕获组 vs 非捕获组，以及排序问题
Python 的字节类型行为 — bytes 迭代出整数这个反直觉的特性

把这些细节搞清楚之后，整个 tokenizer 的逻辑其实非常清晰。理解了这些，再去读 tiktoken 或 HuggingFace tokenizers 的源码，会有一种豁然开朗的感觉。

CS336 1/？

Sun, 22 Mar 2026 00:00:00 GMT

BPE 算法实现笔记#

从零实现 Byte Pair Encoding，记录踩坑与核心洞察。

什么是 BPE？#

Byte Pair Encoding（字节对编码）是构建 LLM 词表的核心算法。

核心思想只有一句话：

反复找出语料中最频繁的相邻 token 对，将其合并为新 token，直到词表大小达到目标。

它解决了一个平衡问题：

粒度	优点	缺点
纯字符级	词表小	序列太长，语义弱
纯词级	语义强	词表爆炸，OOV 问题
BPE	两者平衡	—

第一步：预分词（Pretokenization）#

BPE 训练之前，需要先把文本切成「词」单元。

为什么需要这一步？#

如果不预分词，BPE 会跨越词边界合并，产生没有语言意义的 token：

"end\nthe" 里的 d\n 会被合并 → 无意义
" the"（带空格）和 "the" 语义不同，却可能被当作同一单元处理

GPT-2 的预分词 Pattern#

⚠️ 必须用 tiktoken 实际使用的 pattern，而不是网上流传的版本——两者对换行符处理不同，会导致 merge 顺序偏差。

1
import regex
2

3
GPT2_PAT = r"""'(?:[sdmt]|ll|ve|re)| ?\p{L}++| ?\p{N}++| ?[^\s\p{L}\p{N}]++|\s++$|\s+(?!\S)|\s"""
4
pat = regex.compile(GPT2_PAT)

必须用 regex 库（非标准库 re），因为需要 \p{L}、\p{N} 等 Unicode 属性支持。

关键规则：空格属于后面那个词，" the" 是一个完整单元。

处理 Special Tokens#

Special tokens（如 <|endoftext|>）不参与 BPE 训练，需要先切分文本：

1
# 长的先匹配，防止短的截断长的
2
special_tokens = sorted(special_tokens, key=len, reverse=True)
3

4
# regex.escape 防止 <| 等字符被解释为正则元字符
5
split_pat = "|".join(f"(?:{regex.escape(st)})" for st in special_tokens)
6
chunks = regex.split(split_pat, text)

顺序：文本 → 按 special tokens 切分 → 对每个 chunk 预分词 → word_freqs

第二步：数据结构#

1
# 每个预分词单元（字节 tuple）的出现频次
2
word_freqs: dict[tuple[bytes, ...], int]
3

4
# 所有相邻 pair 的总频次
5
from collections import Counter
6
pair_counts: Counter  # (bytes, bytes) -> int

初始化 vocab#

BPE 从最小单位出发——所有可能的单字节（256 个）：

1
vocab = {i: bytes([i]) for i in range(256)}
2
for st in special_tokens:
3
    vocab[len(vocab)] = st.encode("utf-8")

初始化 pair_counts#

1
for word, freq in word_freqs.items():
2
    for i in range(len(word) - 1):
3
        pair_counts[(word[i], word[i + 1])] += freq

第三步：主循环#

1
重复 (vocab_size - 初始vocab大小) 次：
2
  1. 找最频繁的 pair
3
  2. 记录到 merges
4
  3. 加入 vocab
5
  4. 更新 word_freqs 和 pair_counts

Tiebreak 规则#

频次相同时，选字典序更大的 pair：

1
best_pair = max(
2
    (p for p in pair_counts if pair_counts[p] > 0),
3
    key=lambda p: (pair_counts[p], p)
4
)

核心优化：增量更新 pair_counts#

朴素做法（慢）#

每次 merge 后重新扫描全部词，重建 Counter → O(n) per merge → 太慢。

高效做法#

每次 merge 之后，只有被合并 token 的邻居 pair 会变化，其余不变。

当把 (a, b) 合并成 ab 时，对词 ... x a b y ...：

1
合并前：... x  a  b  y ...
2
合并后：... x  ab    y ...

操作	pair	原因
减少	`(x, a)`	`x` 的右邻居从 `a` 变成了 `ab`
减少	`(b, y)`	`y` 的左邻居从 `b` 变成了 `ab`
增加	`(x, ab)`	新搭档出现
增加	`(ab, y)`	新搭档出现

边界条件：x 不存在（a 在词首）或 y 不存在（b 在词尾）时跳过对应更新。

1
if i > 0:
2
    pair_counts[(new_word[-1], a)] -= freq   # 用 new_word[-1] 取左邻居！
3
    pair_counts[(new_word[-1], merged)] += freq
4

5
new_word.append(merged)
6

7
if i + 2 < len(word):
8
    pair_counts[(b, word[i + 2])] -= freq
9
    pair_counts[(merged, word[i + 2])] += freq

⚠️ 踩坑：左邻居索引#

取左邻居时必须用 new_word[-1]，不能用 word[i-1]。

原因：词 (a, b, a, b) 中，第二个 (a, b) 的左邻居已经是 merged，而不是原词里的 b。用 word[i-1] 会指向错误的 token。

⚠️ 踩坑：`(a, b)` 自身计数#

merge 后要立即清除 (a, b) 的计数，否则下次循环可能重复选同一个 pair：

1
a, b = best_pair
2
del pair_counts[best_pair]  # 在更新 word_freqs 之前

⚠️ 踩坑：迭代时修改字典#

不能在遍历 word_freqs.items() 的同时修改它，用 to_update 收集变化，循环后统一更新：

1
to_update = {}
2
for word, freq in word_freqs.items():
3
    # ... 构建 new_word ...
4
    to_update[word] = (tuple(new_word), freq)
5

6
for old_word, (new_word, freq) in to_update.items():
7
    del word_freqs[old_word]
8
    word_freqs[new_word] = word_freqs.get(new_word, 0) + freq
9
    # 用 .get(..., 0) 防止 new_word 原先就存在

完整流程图#

1
输入文本
2
  │
3
  ▼
4
按 special tokens 切分 → chunks
5
  │
6
  ▼
7
GPT-2 regex 预分词 → word_freqs
8
  │
9
  ▼
10
初始化 vocab（256字节 + special tokens）
11
初始化 pair_counts
12
  │
13
  ▼
14
┌─────────────────────────────┐
15
│  找最频繁 pair (tiebreak:大) │
16
│  → 加入 merges, vocab       │
17
│  → 增量更新 pair_counts     │
18
│  → 更新 word_freqs          │
19
└──────────────┬──────────────┘
20
               │ 重复直到 vocab_size
21
               ▼
22
          (vocab, merges)

显示更多显示更少

测试要求#

corpus.en，vocab_size=500：< 1.5 秒完成
merges 顺序必须与 GPT-2 参考实现完全一致
special tokens 不出现在任何 BPE merge 结果中

docker镜像更新

Fri, 06 Mar 2026 00:00:00 GMT

1. 拉取最新镜像#

首先，你需要从镜像仓库（如 Docker Hub）获取最新版本的镜像。这一步不会影响当前正在运行的服务。

1
docker compose --env-file .env pull

2. 重新启动服务#

运行 up -d 命令。Docker Compose 会自动检测镜像是否发生变化：

如果镜像有更新，它会停止旧容器并启动新容器。
如果镜像没有变化，它会保持现状。

1
docker compose --env-file .env up -d

3. 清理旧镜像（可选）#

升级完成后，旧的镜像会变成“悬空”状态（无标签），占用磁盘空间。你可以通过以下命令清理：

1
docker image prune -f

💡 核心注意事项#

数据持久化：

确保你的数据存储在 volumes 中，而不是容器内部。只要挂载了宿主机目录或命名卷，升级容器不会导致数据丢失。
版本标签 (Tags)：
- 如果你在 yaml 文件中使用的是 :latest 标签，直接执行上述步骤即可。
- 如果你使用的是固定版本号（如 :1.2.1），你需要先修改 docker-compose.yml 或 .env 文件中的版本号，再执行 up -d。
配置生效：

由于你指定了 --env-file .env，如果你在升级前修改了 .env 文件中的环境变量，执行 up -d 时 Docker Compose 也会检测到配置变更并自动重启受影响的容器。

大模型 3/？

Wed, 04 Feb 2026 00:00:00 GMT

这里是讲解Transformer 的博客，但是笔者暂时不想讲，先放一张图

Question

TODO 暂定 2.6 之后，再沉淀一下

大模型 2/？

Mon, 02 Feb 2026 00:00:00 GMT

上一讲大模型 1/？我们讲解了 Embedding，这是 AI 理解自然语言的基础。但是 Embedding 存在一个致命问题。

Embedding 的局限#

Embedding 只解决了”词长什么样”，但没解决”词在当前句子里该怎么用”。

同一个 Token 在不同句子中，Embedding 是完全一样的，但语义却不同。

举个例子：

“他打了个电话给我”
“他打了我一拳”
“我们去打球吧”

这三个”打”的 Embedding 完全相同，但在不同上下文中意思完全不同：打电话、打人、打球。

Tip

问题不是词义，而是上下文依赖。

Embedding 只解决了”词长什么样”，但没解决”词在当前句子里该怎么用”。

这就要引出大名鼎鼎的注意力机制了。

Attention#

Attention 要解决什么问题#

Attention（注意力机制）的目标不是生成新词，而是：

Note

让每个 Token 决定，在理解当前语义时，应该关注句子中的哪些 Token，以及关注多少。

通过 Attention，同一个 Token 会因为上下文不同，得到完全不同的表示。这一步，语言才第一次变成”句子级理解”。

接下来我们一步步来解释它是如何做到的。

Attention 的整体框架#

首先，我们先把注意力机制当做一个黑盒，看看它的输入和输出：

输入： Attention 并没有引入新的输入，它仍然只基于 Embedding 得到的矩阵 XXX

输出： 一个融合了上下文信息的新矩阵，代表每个 Token 在当前句子中的语义表示

Q / K / V 是什么#

Attention 的计算需要三个东西：Q（Query）、K（Key）、V（Value）。

它们都是由同一个 Embedding 矩阵 XXX 通过不同的线性变换得到的：

Q=XWqK=XWkV=XWvQ = XW_q \\ K = XW_k \\ V = XW_vQ=XWqK=XWkV=XWv

其中 Wq,Wk,WvW_q, W_k, W_vWq,Wk,Wv 是模型在训练过程中自动学习出来的参数，不需要我们自己定义。

为什么不能直接用 X？#

你可能会问：既然都是从 XXX 来的，为什么不直接用 XXTXX^TXXT 来计算相关性呢？

答案是：如果直接用 XXTXX^TXXT，会陷入”自恋”状态。

任何一个 Token 和自己的相似度一定是最大的（ X1⋅X1TX_1 \cdot X_1^TX1⋅X1T 最大）
模型会过度关注自己，忽略上下文
Attention 会退化成”什么都不看”

Note

通过引入不同的 W_q 和 W_k，模型可以打破这种对称性，学会从其他 Token 中汲取更有用的信息。

Q / K / V 的角色#

有了这三个不同的表示，它们分别扮演什么角色呢？看着是不是很像查哈希表：

Q（Query）：代表”我想找什么”，即当前 Token 的诉求
K（Key）：代表”我有什么”，即每个 Token 能提供的标签
V（Value）：代表”我的具体内容是什么”，即每个 Token 携带的实际语义

Attention 的计算流程#

Attention 的计算可以拆成三步：

计算”我和谁相关” —— QKTQK^TQKT
把相关性变成权重 —— softmax(QKTdk)softmax(\frac{QK^T}{\sqrt{d_k}})softmax(dkQKT)
按权重汇总信息 —— 乘以 VVV

完整的公式为：

Attention=softmax(QKTdk)VAttention = softmax(\frac{QK^T}{\sqrt{d_k}})VAttention=softmax(dkQKT)V

第一步：计算相关性 QKTQK^TQKT#

我们先以单个 Token 的视角来看： Q1⋅KkTQ_1 \cdot K_k^TQ1⋅KkT

假设我们 Embedding 的维度为 dkd_kdk，那么：

X1X_1X1 的 shape 为 (1,dk)(1, d_k)(1,dk)
Wq=Wk=(dk,dk)W_q = W_k = (d_k, d_k)Wq=Wk=(dk,dk)
最终 Q1Q_1Q1 的 shape 为 (1,dk)(1, d_k)(1,dk)， KkK_kKk 的 shape 为 (1,dk)(1, d_k)(1,dk)

Q1⋅KkTQ_1 \cdot K_k^TQ1⋅KkT 代表的就是当前 Token 想要寻找的信息与其他 Token 可提供信息的相关性。

为什么用内积？

向量内积如果值越大，说明两个向量的空间距离就越小。根据我们上一节 Embedding 学习到的知识，这其实也就说明两个 Token 的语义越接近。

第二步：归一化为权重#

现在我们有了相关性分数，但这些分数的数值范围不确定，需要转换为”注意力权重”。

为什么要除以 dk\sqrt{d_k}dk？

因为内积的数值会随着维度增大而增大，而 softmaxsoftmaxsoftmax 对数值尺度非常敏感。如果不缩放，容易出现非 0 即 1 的极端情况。

除以 dk\sqrt{d_k}dk 可以让内积保持在合理范围内。

softmax 做了什么？

softmaxsoftmaxsoftmax 将相关性分数归一化到 0-1 之间，且所有权重之和为 1，形成一个概率分布。

经过 softmaxsoftmaxsoftmax 后， Q1Q_1Q1 对每个 KkK_kKk 的分数就代表着 Token1Token_1Token1 对 TokenkToken_kTokenk 的注意力权重。

第三步：加权求和#

最后，用注意力权重对每个 Token 的实际信息（ VVV）进行加权求和。

每个 Token 最终得到的表示 = 根据注意力权重，从所有 Token 的 VVV 中汇总信息。

Tip

注意力机制的本质：根据 Q 和 K 的匹配度，决定从对应的 V 中抽取多少信息

从 Token 到句子#

上面我们讲的是单个 Token 的计算过程。对于整个句子：

假设句子有 nnn 个 Token，那么：

XXX 的 shape 为 (n,dk)(n, d_k)(n,dk)
Q,K,VQ, K, VQ,K,V 的 shape 都为 (n,dk)(n, d_k)(n,dk)
QKTQK^TQKT 的 shape 为 (n,n)(n, n)(n,n) —— 这是一个注意力矩阵，第 iii 行第 jjj 列表示第 iii 个 Token 对第 jjj 个 Token 的注意力
最终输出的 shape 为 (n,dk)(n, d_k)(n,dk) —— 每个 Token 都得到了融合上下文信息后的新表示

总结#

通过 Attention，我们解决了 Embedding 的局限：

Embedding 给了每个词一个固定的表示
Attention 让每个词根据上下文动态调整表示

同一个 Token 在不同句子中，虽然 Embedding 相同，但经过 Attention 后会得到完全不同的表示。

这就是 Attention 的魔力所在。

hf 空间不足

Sun, 25 Jan 2026 09:31:00 GMT

Terminal window

1
export HF_DATASETS_CACHE="/tmp/hf_cache"
2
export HF_HOME="/tmp/hf_cache"

将 tmp 换为空闲路径即可

复习02

Sun, 13 Jul 2025 00:00:00 GMT

操作系统#

并发和并行有什么区别？#

并发：多个事件在同一时间间隔内发生
并行：多个事件在同一时刻同时发生

什么是异步、同步？#

同步：当前任务必须等待前一个任务完成后才能继续
异步：任务无需等待，可并发执行

计算机网络#

解释C/S、B/S、P2P#

C/S是指客户和服务器模式，是由客户发送请求，而服务器负责处理客户端发送的请求并返回响应
B/S(Browse/Server)是C/S架构中的一种特殊的实现形式
P2P是指网络中的每个节点都可以作为客户端和服务器，也是C/S的一种特殊形式

什么是DNS#

DNS全称是域名系统，用于将域名转换为IP地址

复习03

Sun, 13 Jul 2025 00:00:00 GMT

计算机网络#

简述DNS解析过程#

浏览器先检查自身缓存、主机本地文件中有没有对应的记录，如果有直接返回结果
向本地域名服务器发送域名解析请求，如果本地域名服务器缓存了该域名的IP地址，就直接返回
否则就向根域名服务器发送解析请求，根域名服务器返回顶级域名服务器的IP地址
本地域名服务器向TLD发送请求，顶级域名服务器返回权限域名服务器的IP地址
本地域名服务器向权限域名服务器发送请求，权限域名服务器返回该域名对应的IP地址给本地域名服务器
本地域名服务器将IP地址缓存，并且将其返回给应用层

什么是DHCP协议#

DHCP协议是动态主机配置协议，用于为主机自动分配IP地址、子网掩码、默认网关等网络配置参数

操作系统#

什么是内核态和用户态？为什么要分两个态？#

内核态：操作系统拥有对系统硬件和资源的完全控制权，可以执行特权指令和访问受限资源
用户态：应用程序只能执行受限的指令集，无法直接访问底层硬件和系统资源

用户态和内核态是如何切换的？#

系统调用：用户态进程主动要求切换到内核态
中断
异常

复习04

Sun, 13 Jul 2025 00:00:00 GMT

操作系统#

复习00

Sat, 12 Jul 2025 00:00:00 GMT

说一下TCP和UDP的区别#

TCP是可靠的连接协议，UDP是不可靠的连接协议
TCP需要经过四握手三挥手才能建立连接，而UDP是尽最大努力交付

说一下线程和进程之间的区别#

线程是进程的组成，一个进程中可以有多个线程
进程是操作系统资源分配的基本单位，而线程是CPU调度的基本单位
进程有自己独立的内存空间和系统资源，而线程与同一进程内的其他线程共享该进程的全部资源

说一下你知道的排序算法及其时间复杂度#

冒泡排序，O(n2)O(n^2)O(n2)
选择排序，O(n2)O(n^2)O(n2)
插入排序，O(n2)O(n^2)O(n2)
合并排序，O(nlogn)O(nlogn)O(nlogn)
快速排序，O(nlogn)O(nlogn)O(nlogn)，不稳定
堆排序，(nlogn)(nlogn)(nlogn)

复习01

Sat, 12 Jul 2025 00:00:00 GMT

操作系统#

什么是操作系统？有什么特点？#

操作是一个运行在计算机上的软件程序，是管理和控制计算机系统软件和硬件资源的管理者。
操作系统把一些硬件功能封装成简单易用的服务，使用户无需关注底层原理。
特点：并发、共享、虚拟、异步

操作系统有哪些功能#

处理机管理
文件管理
磁盘管理
设备管理

计算机网络#

简述计算机网络的五层协议体系结构#

五层协议体系结构从下往上分别是物理层、数据链路层、网络层、运输层、应用层。

物理层：在连接各种计算机的传输媒体上传输数据比特流
数据链路层：两台主机间传送数据，是在一段一段链路上传送的。数据链路层协议负责在相邻节点之间传输数据
网络层：负责路由选择和转发，将传输层提供的数据包通过不同路径传输到目的地
运输层：为进程间通信提供了通用（多种应用可以使用同一个运输服务）的数据传输服务。
应用层：定义了应用进程之间通信和交互的规则

计算机网络为什么要分层？有什么优点？#

计算机网络是一个复杂的系统，分层可以将庞大复杂的问题转化成若干个较小的局部问题
各层之间是独立的，不用关心其他层次的内容
灵活性好，任何一层发生变化不影响上下层

数据挖掘期末指南

Wed, 18 Jun 2025 00:00:00 GMT

数据挖掘复习指南#

第一部分：概述与核心概念#

1. 数据挖掘的定义与目标#

基本定义#

数据挖掘：从大量数据中发现潜在的、有用的模式、信息、知识、规律和模型的过程

与KDD的关系#

KDD是指从数据中发现有用知识的整个过程，而数据挖掘是特定算法的应用，用于从数据中提取模式。
KDD（知识发现）：数据挖掘是KDD过程中的一个关键步骤
KDD是更广泛的概念，包括：数据选择、预处理、变换、数据挖掘和评估等

核心任务#

数据挖掘能做什么：

预测 (Prediction)：通过分类或估值模型对未知变量进行预测
- 分类 (Classification)：输出离散类别
- 估值/回归 (Estimation/Regression)：输出连续值
聚类 (Clustering)：无监督分类，将数据对象分组，组内相似度高，组间相似度低
关联分析 (Association Analysis)：发现数据项之间的关联规则（如购物篮分析）
异常分析 (Anomaly Detection)：识别数据中不寻常的模式或离群点

跨学科特性#

相关领域：机器学习、统计学、OLAP、专家系统、模式识别、数据库技术、人工智能、可视化技术、并行计算等

数据挖掘流程#

主要阶段：数据预处理 → 特征提取 → 选择模型（模型训练）→ 评估与优化 → 测试

第二部分：数据类型与属性#

1. 属性与属性值#

基本概念#

属性 (Attribute)：指数据的特征或维度
- 例如：身高、眼球颜色
属性值 (Attribute Value)：该属性具体可取的量
- 例如：170cm、蓝色

重要区别#

相同的属性可映射到不同值域
不同属性可映射到同一组值，但性质不同
- 例如：ID无上限，年龄有最大最小值

2. 属性的类型 (Measurement Scale)#

标称属性 (Nominal Attribute)#

特点：值仅是不同名字，提供区分对象的信息（=, ≠），无序
例子：邮政编码、雇员ID号、眼球颜色、性别
可用操作：众数、熵、列联相关、χ² 检验

序数属性 (Ordinal Attribute)#

特点：值提供确定对象顺序的信息（<, >）
例子：矿石硬度、{好，较好，最好}、成绩、街道号码
可用操作：中值、百分位、秩相关、游程检验、符号检验

区间属性 (Interval Attribute)#

特点：值之间的差有意义，存在测量单位（+, -），无绝对零点
例子：日历日期、摄氏或华氏温度
可用操作：均值、标准差、皮尔逊相关、t和F检验

比率属性 (Ratio Attribute)#

特点：差和比率都有意义（*, /），有绝对零点
例子：绝对温度、货币量、计数、年龄、质量、长度、电流
可用操作：几何平均、调和平均、百分比变差

属性分类总结#

分类属性 (Qualitative)：标称和序数
数值属性 (Quantitative)：区间和比率
属性值的性质：相异性（=, ≠）、序（<, >）、加法（+, -）、乘法（*, /）

3. 离散与连续属性#

离散属性 (Discrete Attribute)#

特点：有限或无限可数个值，常表示为整数变量
特例：二元属性
例子：邮政编码、计数、文档集的词

连续属性 (Continuous Attribute)#

特点：属性值为实数，一般用浮点变量表示
例子：温度、高度、重量

第三部分：数据集特性与类型#

1. 数据集的重要特性#

维度相关特性#

维度 (Dimensionality)：数据集中对象具有的属性数目
维灾难 (Curse of Dimensionality)：
- 随着数据维度增加，数据在空间中越来越稀疏
- 许多数据分析变得困难
- 导致分类准确率降低，聚类质量下降

其他重要特性#

稀疏性 (Sparsity)：
- 具有非对称特征的数据集
- 一个对象的大部分属性上的值都为0
- 只存储和处理非零值
分辨率 (Resolution)：模式依赖于度量尺度

2. 数据集类型#

记录数据 (Record Data)#

数据矩阵 (Data Matrix)
- 对象具有相同的固定数值属性集
- 表示为 m×n 矩阵
文档数据 (Document Data)
- 每个文档视为一个向量
- 值是对应术语出现次数
事务数据 (Transaction Data)
- 每条记录（事务）涉及一组项目
- 例如：购物清单

有序数据 (Ordered Data)#

时间序列数据 (Time Series Data)
- 一段时间的测量序列
- 具有时间自相关性
空间数据 (Spatial Data)
- 具有空间属性
- 具有空间自相关性
序列数据 (Sequential Data)
- 时间次序重要但具体时间不重要
- 例如：基因序列

基于图的数据 (Graph-based Data)#

特点：对象之间有联系或对象具有结构
例子：分子结构

第四部分：数据质量与预处理#

1. 数据质量问题#

常见数据质量问题#

离群点 (Outliers)
- 与数据集中其他大部分数据对象特征不同的对象
遗漏值 (Missing Values)
- 信息未收集全或属性不适用
- 处理策略：
  - 删除数据对象
  - 估计遗漏值
  - 分析时忽略
  - 用所有可能值替换
不一致值
- 矛盾或不匹配的值（如邮政编码与城市不符）
- 纠正需附加信息
重复数据 (Duplicate Data)
- 冗余或几乎冗余的数据对象
- 合并异构数据源时的主要问题

数据质量问题的根源#

测量误差和数据收集错误：导致数据质量问题

数据清理 (Data Cleaning)#

主要任务：
- 格式标准化
- 异常数据清除
- 错误纠正
- 重复数据清除

应用层面的问题#

时效性 (Timeliness)：数据过时导致模型过时
相关性 (Relevance)：数据必须包含应用所需信息

2. 数据预处理方法#

聚集 (Aggregation)#

定义：组合属性或对象
目的：数据规约、范围转换、数据更稳定

抽样 (Sampling)#

定义：选择数据对象子集，目的在于数据规约
基本原则：代表性（保留原数据集性质）
抽样方法：
- 简单随机抽样（无放回、有放回）
- 分层抽样（按个数或比例）
样本大小：足够大才能保留数据集结构
渐进抽样 (Progressive Sampling)：从小样本开始，逐渐增加容量直到模型准确率稳定

维归约 (Dimensionality Reduction)#

定义：减少属性数目
目的：
- 避免维度灾难
- 降低算法开销
- 便于可视化
- 减少不相关特征或噪音
主要技术：
- 主成分分析 (PCA)：找到原有属性线性组合，相互正交，捕获最大变差
- 奇异值分解 (SVD)

特征子集选择 (Feature Subset Selection)#

定义：识别并移除不相关或冗余特征
特征类型：
- 冗余特征：重复信息
- 不相关特征：对任务无用的信息
选择方法：
- 嵌入方法：结合数据挖掘算法（如决策树）
- 过滤方法：独立于算法
- 包装方法：算法作为黑盒评估性能
- 穷举方法

特征构造 (Feature Creation)#

定义：创建更能体现对象本质的新特征
方法类型：
- 特征提取：领域相关或映射到新空间（如傅里叶变换、小波变换）
- 特征构造：一个或多个原始特征构造新特征（如密度=质量/体积）

离散化与二元化 (Discretization and Binarization)#

目的：
- 减少属性值个数
- 便于挖掘
- 产生概念分层结构
- 适应算法要求
离散化类型：
- 非监督离散化：不使用类信息
  - 等宽、等频、K-均值离散化
- 监督离散化：使用类信息
  - 基于熵的方法：极大化区间纯度（最小化熵）
二元化方法：
- 映射到整数再二进制化（不适合非对称属性）
- 对每个值建立二元变量

属性变换 (Attribute Transformation)#

定义：将属性值集映射到新值集
变换类型：
- 简单变换：x^k, log(x), e^x, |x|, 1/x 等函数
- 标准化/规范化：使值集具有特定性质（如均值0，标准差1）

第五部分：相似性和相异性的度量#

1. 基本概念#

核心定义#

相似性 (Similarity)：数值度量相似程度，值越高越相似
相异性 (Dissimilarity)：数值度量差异程度，值越低越相似，最小为0
邻近性 (Proximity)：指相似或不同之处

2. 距离度量#

欧氏距离 (Euclidean Distance)#

定义：两点之间直线距离，最常见
公式：d(x,y) = √(Σ(xₖ - yₖ)²)

闵可夫斯基距离 (Minkowski Distance)#

定义：欧氏距离的推广
特殊情况：
- r=1：城市街区距离 (Manhattan, L1范数)，如汉明距离
- r=2：欧氏距离
- r→∞：上确界距离 (L∞范数)，最大差异

距离的性质 (度量 Metric)#

非负性：d(x,y) ≥ 0，且 d(x,y)=0 当且仅当 x=y
对称性：d(x,y) = d(y,x)
三角不等式：d(x,z) ≤ d(x,y) + d(y,z)

非度量的相异度#

不满足一个或多个度量性质（如集合差、时间）

3. 数据对象间的相似度#

常用相似度度量#

简单匹配系数 (SMC)
- 匹配属性个数 / 总属性个数
Jaccard系数
- 不涉及0-0匹配的属性个数
余弦相似度 (Cosine Similarity)
- 衡量向量方向的相似性
- 公式：cos(x,y) = (x·y) / (||x|| × ||y||)
相关性 (Correlation)
- 对象属性之间线性联系的度量
- 范围：-1到1

4. 邻近度计算的实际问题#

主要挑战#

标准化和相关性
- 属性值域不同时需变换到相同值域
- 属性相关时使用Mahalanobis距离
组合异种属性的相似度
- 对不同类型属性分别计算并加权求和
属性权重问题
- 使用权值加权的相似度或闵可夫斯基距离

第六部分：分类算法#

1. 分类模型评估基础#

混淆矩阵 (Confusion Matrix)#

定义：总结分类模型性能的表格
基本概念：
- TP (True Positive)：真正例，实际为正预测为正
- FN (False Negative)：假反例，实际为正预测为负
- FP (False Positive)：假正例，实际为负预测为正
- TN (True Negative)：真反例，实际为负预测为负

评估指标#

准确率 (Accuracy)
- 公式：(TP + TN) / (TP + FN + FP + TN)
- 局限性：类别不平衡时可能误导
其他重要度量
- 真正率 (TPR) / 灵敏度 (Sensitivity)
- 真负率 (TNR) / 特异度 (Specificity)
- 假正率 (FPR)
- 假负率 (FNR)
- 召回率 (Recall)
- 精度 (Precision)
- F1度量
ROC曲线
- 定义：绘制TPR vs FPR
- 用途：评估分类器性能
- AUC：曲线下面积，重要指标

2. K-近邻分类 (K-Nearest Neighbors, KNN)#

基本原理#

定义：记录x的K近邻是与x距离最近的k个数据点
判断过程：
1. 计算已知样本与未知样本的距离
2. 找到k个最近样本
3. 通过多数表决（或距离加权表决）确定类别

K值选择的影响#

K太小：
- 对噪声敏感
- 模型复杂
- 易过拟合
K太大：
- 邻域可能包含其他类点
- 模型简单

算法特点#

优点：
- 基于实例的学习（惰性学习）
- 非参数估计
- 生成任意形状的决策边界
缺点：
- 需要邻近性度量
- 分类开销大
- 无显式学习过程
- 需要数据预处理

3. 贝叶斯分类器#

贝叶斯定理#

公式：P(Y=yⱼ|X) = P(X|Y=yⱼ)P(Y=yⱼ) / P(X)
MAP (最大后验假设)：将X指派到具有最大后验概率P(yⱼ|X)的类yⱼ
先验概率P(yⱼ)：由训练集中类yⱼ的样本数nⱼ与总样本数n的比值nⱼ/n估计

朴素贝叶斯分类器 (NBC)#

核心假设：条件独立假设
- 给定样本的类标号，假定属性值条件地相互独立
概率估计：
- P(X|Y=yⱼ) = ∏P(xᵢ|yⱼ)
- 离散属性：用频率估计
- 连续属性：假设服从高斯分布

NBC的优缺点#

优点：
- 对孤立噪声点有鲁棒性
- 能处理属性值缺失
- 对无关属性有鲁棒性
缺点：
- 条件独立假设可能不成立

贝叶斯信念网络 (BBN)#

改进：允许在变量子集间定义类条件独立性
结构：因果关系图模型
- 节点表示随机变量
- 边表示依赖关系
- 图中无环
特点：
- 用图形模型捕获先验知识
- 编码因果依赖关系
- 构造费时但添加新变量容易
- 适合处理不完整数据
- 对过拟合鲁棒

4. 决策树分类器#

基本原理#

算法特性：贪心算法，自上而下分而治之，递归分割
属性选择：基于启发式或统计度量
停止条件：
- 节点数据都属同一类别
- 没有属性可再用于分割

不纯性度量 (Impurity Measure)#

目的：衡量节点内数据类别分布的均匀性（越均匀越不纯）
主要度量：
- 熵 (Entropy)：衡量系统无序程度，熵越大越无序
- 基尼系数 (Gini Index)：衡量随机抽取两样本类别不一致的概率
- 分类误差 (Classification Error)

划分增益#

目的：衡量划分后不纯度的降低，增益越大越有利于分类
主要指标：
- 信息增益 (Information Gain)：当不纯度用熵度量时的增益
- 增益率 (Gain Ratio)：解决熵和基尼系数倾向于多值属性的问题

最佳划分策略#

过程：
1. 对每个属性确定最佳划分（不纯度最低）
2. 选择增益最大的属性
连续属性处理：排序后取相邻不同类值中点作为划分点

决策树特点#

基本性质：
- 非参数方法
- 贪心算法
- NP完全问题
- 决策边界是直线（平面），平行于坐标轴
优点：
- 快速建立模型和分类
- 分类准确率高
- 适合固定属性记录数据
- 相对容易解释
- 对噪声鲁棒
- 可避免过拟合
- 自动选择最好属性
缺点：
- 数据碎片问题
- 子树可能重复
- 平行于坐标轴的边界限制能力

5. 模型的过拟合与剪枝#

误差类型#

训练误差 (Training Error)
- 模型在训练集上的误分类比例
泛化误差 (Generalization Error)
- 模型在未知记录上的期望误差
- 通常在检验集上估计

拟合问题#

欠拟合 (Underfitting)
- 训练和检验误差都很大
- 原因：模型假设空间太小或偏离
过拟合 (Overfitting)
- 训练误差小，但检验误差大
- 原因：模型过度拟合训练数据，巨大的模型假设空间与稀疏数据矛盾
- 具体原因：噪声、缺乏代表性样本

剪枝 (Pruning)#

目的：降低决策树复杂度，解决过拟合

评估方法#

在训练集上估计
- 训练误差结合模型复杂度
- 悲观误差评估
- 最小描述长度(MDL)
使用确认集 (Validation Set)
- 将训练数据分为训练子集和确认集
- 确认集用于估计泛化误差

剪枝策略#

预剪枝 (Pre-pruning)
- 提前停止树的构造
后剪枝 (Post-pruning)
- 先构造完整的树
- 再剪掉不必要的分支

6. 分类模型评估方法#

基本评估方法#

保持 (Holdout) 方法
- 划分：2/3训练，1/3检验
- 局限性：训练样本少，模型高度依赖数据集构成
随机二次抽样 (Random Subsampling)
- 重复保持方法k次，取平均准确率
交叉验证 (Cross-validation)
- K折交叉验证：
  - 数据集划分为k个不相交子集
  - k-1份训练，1份测试，重复k次
- 留一法 (Leave-one-out)：
  - k=n，每个样本单独作为测试集

统计评估#

准确率的置信区间
- 提供区间估计，衡量测量结果的可信程度
模型性能比较
- 通过比较误差率的差值是否统计显著
- 使用t-分布计算置信区间

7. 集成学习 (Ensemble Learning)#

基本思想#

聚集多个分类器的预测以提高分类准确率

主要算法#

Adaboost
- 迭代训练基分类器
- 每次调整训练样本权重
- 对误分类样本赋予更高权重
- 后续分类器更关注这些样本
- 最终通过基分类器的加权投票产生预测
随机森林 (Random Forest)
- 多棵CART树的组合
- 每棵树的训练集有放回采样
- 训练节点时特征随机无放回抽取
Rotation Forest
- 使用整个训练集建立多个基分类器
- 通过不同特征变换将数据变换到不同新特征空间

特殊问题处理#

代价敏感学习 (Cost-sensitive Learning)
- 考虑不同类型错误（如漏报、假警告）的代价
不平衡数据问题 (Imbalanced Data)
- 基于抽样：
  - 欠抽样 (Undersampling)：可能丢失有用样本
  - 过抽样 (Oversampling)：可能导致过拟合噪声样本
  - 组合方法：Undersampling + Oversampling
- 两阶段学习：分阶段学习规则，如PN-Rules

第七部分：聚类分析 (无监督学习)#

1. 聚类概述#

学习类型对比#

有监督学习：有标记，学习假设函数确定决策分界
无监督学习：无标记，算法对同一类的进行划分

基本概念#

簇 (Cluster)：一个数据对象的集合，簇内对象相似性高，簇间相异性高
聚类分析：将给定数据对象集合分成不同的簇，是一种无监督分类法

好的聚类方法标准#

高质量聚类结果（高簇内相似性、低簇间相似性）
能发现隐含模式

聚类算法要求#

可伸缩性
发现任意形状簇
无需特定领域知识确定输入参数
处理噪声和异常
对输入数据顺序不敏感
处理高维数据
产生满足用户约束的可解释结果

聚类类型#

按结构分类：
- 划分聚类 (Partitioning Clustering)：数据对象划分为不重叠的k个簇
- 层次聚类 (Hierarchical Clustering)：簇具有子簇
按覆盖方式分类：
- 互斥、重叠与模糊
- 完全聚类、部分聚类

2. 主要聚类方法分类#

按算法原理分类#

划分算法：构建数据的k个划分
层次算法：对数据对象集合进行层次分解
基于密度算法：基于连通性和密度函数聚类
基于网格算法：对象空间量化为网格，操作在网格中进行
基于模型算法：为每个簇假定一个模型

3. 划分聚类算法#

K-均值 (K-means)#

地位：最广泛使用的聚类算法

算法流程#

随机选择k个初始簇中心
将每个对象赋给最近的簇
重新计算每个簇的平均值
重复直到准则函数收敛

优缺点分析#

优点：
- 简单、快速
- 对大数据集可伸缩
- 高效，当簇密集时效果好
缺点：
- 需事先给定k
- 对初值敏感
- 不适合非凸面或大小差别很大的簇
- 对噪声和孤立点敏感

算法变形#

改进方向：
- 初始K个平均值的选择
- 相异度计算
- 簇均值策略
处理分类属性：
- K-modes
- K-原型

K-中心点 (K-medoids) / PAM#

特点：每个簇用接近聚类中心的一个中心点表示

4. 层次聚类方法#

基本定义#

对给定数据集进行层次分解

层次聚类类型#

凝聚的层次聚类 (AGNES)
- 策略：自底向上，每个对象一个簇，逐步合并
- 缺点：
  - 合并处理不能撤销，可能导致低质量聚类
  - 可伸缩性差，复杂度高O(n²)
分裂的层次聚类 (DIANA)
- 策略：自顶向下，所有对象一个簇，逐渐细分

簇间距离度量方法#

最小距离 (Single Linkage)
最大距离 (Complete Linkage)
平均值距离 (Centroid Linkage)
平均距离 (Average Linkage)

5. 基于密度的方法 (DBSCAN)#

核心概念#

距离函数：度量样本点间关系
Epsilon (ε)：距离阈值，定义邻域
minPoints：邻域内的最小样本数

样本分类#

核心样本 (Core Point)
- ε邻域内样本数 ≥ minPoints
边界样本 (Border Points)
- ε邻域内样本数 < minPoints
- 且在某个核心样本的邻域内
噪声样本 (Noise Points)
- 不属于任何核心样本的邻域

密度连接概念#

密度直达：样本X在核心样本Y的邻域内
密度可达：通过一系列核心样本的密度直达关系连接
密度相连：两个样本X和Y都可以从同一个核心样本O密度可达

聚类过程#

随机寻找核心样本点
推导其密度相连的点
赋予簇编号
重复直到所有核心样本点都有对应类别

DBSCAN优缺点#

优点：
- 能发现K-means不能发现的任意形状簇
- 对噪声有鲁棒性
缺点：
- 对高维数据处理能力不足
- 簇密度变化较大时有问题

第八部分：关联分析#

1. 基本概念#

核心定义#

关联规则 (Association Rules)：发现数据项之间有趣的关联关系，形如 X → Y
频繁项集 (Frequent Itemsets)：出现频率（支持度）高于最小支持度阈值的项集

重要度量#

支持度 (Support)
- 项集在总事务中出现的百分比
- 衡量项集的普遍性
置信度 (Confidence)
- 关联规则 X → Y 的置信度：P(Y|X) = Support(X∪Y) / Support(X)
- 衡量规则的可靠性或强度

规则产生#

从频繁项集中提取关联规则

2. Apriori算法#

核心思想#

逐层算法
- 从频繁1-项集到最长的频繁项集
- 每次遍历项集格中的一层
产生-测试策略
- 产生新的候选项集
- 对每个候选的支持度进行计数和比较

Apriori性质 (先验原理)#

正向性质：如果一个项集是频繁的，它的所有非空子集也必须是频繁的
反单调性：如果一个项集是非频繁的，则它的所有超集也一定是非频繁的

算法步骤#

候选项集的产生与剪枝
- 从频繁(k-1)-项集通过自连接产生k-项集
- 利用Apriori性质剪掉非频繁候选项集
支持度计数
- 确定每个候选项集出现的频繁程度
规则产生
- 忽略前件或后件为空的规则
- 每个频繁k-项集能产生多达 2^k-2 个关联规则
- 利用置信度的反单调性进行剪枝：
  - 如果规则 X → Y-X 不满足置信度阈值
  - 则形如 X’ → Y-X’ 的规则（其中 X’ 是 X 的子集）也一定不满足置信度阈值

总结#

本指南涵盖了数据挖掘的核心概念和主要算法，从数据预处理到具体的挖掘技术，为期末复习提供了系统性的知识框架。重点掌握各算法的原理、优缺点和适用场景，理解评估方法和实际应用中的问题处理策略。

数据挖掘算法总结

Fri, 13 Jun 2025 00:00:00 GMT

1. 决策树归纳算法 (Decision Tree Induction Algorithm)#

说明: 决策树归纳算法是一种贪心算法，采用自顶向下递归的方式构建决策树。它在每一步选择最优的属性来划分数据集，直到满足预设的停止条件（例如，节点中的所有样本都属于同一类别，或没有可用于划分的属性）。

伪代码:

1
函数 Generate_decision_tree(数据集 E, 属性集 F):
2
    // 1. 创建结点N
3
    结点 N = createNode()
4

5
    // 2. 检查停止条件
6
    如果 E 中所有记录都属于同一个类 C:
7
        N.label = C  // 标记为叶结点
8
        返回 N
9
    如果 F 为空 (没有更多属性可用于划分):
10
        N.label = E 中最常见的类 (多数表决) // 标记为叶结点
11
        返回 N
12

13
    // 3. 选择最佳划分属性和条件
14
    root.test_cond = find_best_split(E, F) // 寻找能够最大化增益（或最小化不纯度）的最佳划分属性和条件
15
    标记结点 N 为 root.test_cond
16

17
    // 4. 根据划分条件递归构建子树
18
    对于 root.test_cond 的每个可能输出值 v:
19
        Ev = {e | root.test_cond(e) == v 并且 e 属于 E} // 获取满足条件v的子集
20
        创建从 N 到 child 的分支，标记为 v
21

22
        如果 Ev 为空:
23
            child = createNode()
24
            child.label = E 中最常见的类 (多数表决) // 为空子集添加默认叶结点
25
        否则:
26
            child = Generate_decision_tree(Ev, F - {root.test_cond.attribute}) // 递归调用，移除已用属性
27

28
        将 child 作为 N 的派生结点添加到树中
29

30
    返回 N

显示更多显示更少

2. k-近邻分类算法 (k-Nearest Neighbor Classification Algorithm)#

说明: k-NN是一种惰性学习算法（Lazy Learner），它不预先构建显式模型。对于一个未知测试样本，它通过计算与训练集中所有样本的距离，找出距离最近的 k 个邻居，然后根据这些邻居的类别进行多数表决（或距离加权表决）来决定测试样本的类别。

伪代码:

1
函数 k_Nearest_Neighbor_Classify(训练集 D, 测试样本 z=(x', y'), 参数 k):
2
    // 1. 计算测试样本 z 与训练集中每个样本的距离
3
    对于 D 中的每个训练样本 (x_i, y_i):
4
        计算 z 的特征向量 x' 和 x_i 之间的距离 d(x', x_i)
5

6
    // 2. 找出 k 个距离最近的训练样本
7
    将 D 中的样本按距离 d(x', x_i) 升序排序
8
    选择距离 z 最近的 k 个训练样本，构成集合 Dz
9

10
    // 3. 根据 k 个邻居的类别进行多数表决
11
    y_prime_predicted = argmax_v (∑ (i 属于 Dz) I(v == y_i)) // I 是指示函数，v 是类别标签
12
    // 另一种常见的表决方式是距离加权表决：
13
    // y_prime_predicted = argmax_v (∑ (i 属于 Dz) (1/d(x', x_i)) * I(v == y_i))
14

15
    返回 y_prime_predicted

显示更多显示更少

3. 后向传播算法 (Backpropagation Algorithm for Artificial Neural Network)#

说明: 后向传播是训练多层前馈神经网络的迭代算法。它通过两个主要阶段：向前传播输入以计算输出，然后向后传播误差。根据计算出的误差，算法会调整网络中的连接权重和偏置，以最小化网络的预测误差。

伪代码:

1
函数 Backpropagation(训练数据集 D, 学习率 l, 神经网络 Network):
2
    // 1. 初始化权重和偏置
3
    将 Network 中所有权重和偏置初始化为小的随机数 (例如，介于 -1.0 到 1.0 之间)
4

5
    // 2. 迭代训练直到满足终止条件
6
    当 终止条件不满足 时: // 终止条件可以是最大迭代次数、误差低于阈值等
7
        对于 D 中的每个训练元组 X (输入) 及其真实输出 T:
8
            // 2.1 向前传播输入 (计算各层的净输入和输出)
9
            对于 每个输入层单元 j:
10
                Oj = Ij // 输入单元的输出等于其输入值
11
            对于 隐藏层和输出层每个单元 j:
12
                净输入 Ij = ∑ (i 来自上一层) (w_ij * Oi) + θj // w_ij 是权重，Oi 是上一层单元i的输出，θj 是偏置
13
                输出 Oj = 1 / (1 + e^(-Ij)) // 使用 Logistic 激活函数
14

15
            // 2.2 后向传播误差 (从输出层开始向后计算误差)
16
            对于 输出层每个单元 j:
17
                Err_j = Oj * (1 - Oj) * (Tj - Oj) // Tj 是单元j的真实输出
18

19
            对于 从最后一个到第一个隐藏层，对于隐藏层每个单元 j:
20
                Err_j = Oj * (1 - Oj) * ∑ (k 来自下一较高层) (w_kj * Err_k) // w_kj 是单元j到下一层单元k的权重
21

22
            // 2.3 更新权重和偏置 (根据计算出的误差调整网络参数)
23
            对于 Network 中每个权重 w_ij (从单元 i 到单元 j):
24
                Δw_ij = l * Err_j * Oi // 权值增量
25
                w_ij = w_ij + Δw_ij // 权值更新
26

27
            对于 Network 中每个偏置 θj:
28
                Δθj = l * Err_j // 偏置增量
29
                θj = θj + Δθj // 偏置更新
30

31
返回 训练后的神经网络 Network

显示更多显示更少

4. Bagging 算法#

说明: Bagging (自助聚集) 是一种集成学习（Ensemble Learning）方法。它通过有放回抽样从原始训练集生成多个自助训练集，然后在每个自助集上独立地训练一个基分类器（通常是同类型的弱学习器）。最终分类时，所有基分类器对测试样本进行投票（分类问题为多数投票，回归问题为平均），选择得票最高的类别。

伪代码:

1
函数 Bagging_Train(原始训练集 D, 基分类器算法 A, 基分类器数量 M):
2
    分类器集合 C = {}
3
    对于 i 从 1 到 M:
4
        // 1. 从 D 中有放回地随机抽样，生成与 D 容量相同的子集 D_i
5
        // (此过程称为自助抽样)
6
        D_i = Bootstrap_Sample(D)
7

8
        // 2. 在自助抽样数据集 D_i 上训练基分类器 C_i
9
        C_i = A.train(D_i) // 使用算法 A 在数据集 D_i 上训练分类器
10
        将 C_i 添加到 C
11

12
    返回 分类器集合 C
13

14
函数 Bagging_Classify(分类器集合 C, 测试样本 x):
15
    类别预测计数 = 一个空字典 (用于存储每个类别的票数)
16

17
    对于 C 中的每个分类器 C_i:
18
        预测类别 p = C_i.predict(x) // 获取当前基分类器的预测结果
19
        增加 p 在类别预测计数中的票数
20

21
    返回 类别预测计数中票数最高的类别

显示更多显示更少

5. Boosting 算法 (通用框架)#

说明: Boosting 是一种迭代的集成学习方法。它为每个训练样本赋予权重，并迭代地训练一系列基分类器。每次训练时，后续的基分类器会“更关注”前一个分类器误分类的样本（通过调整样本权重实现）。最终分类时，基分类器根据其在训练中的表现（通常是其准确率的函数）进行加权投票。Adaboost 是其一个流行实现。

伪代码:

1
函数 Boosting_Train(训练集 D, 基分类器算法 A, 迭代次数 K):
2
    N = D 的样本总数
3
    初始化 D 中每个训练记录的权重 w_j = 1/N (j = 1 to N)
4
    分类器集合 C = []
5
    重要性权重集合 Alpha = [] // 存储每个基分类器的权重
6

7
    对于 i 从 1 到 K:
8
        // 1. 根据当前样本权重 w_j，训练基分类器 C_i
9
        // (算法 A 在训练时会考虑样本权重)
10
        C_i = A.train(D, w_j)
11

12
        // 2. 计算分类器 C_i 的分类误差 ε_i
13
        ε_i = ∑ (j = 1 to N) w_j * I(C_i(x_j) != y_j) // I 是指示函数，当预测错误时为 1
14

15
        // 3. 计算分类器 C_i 的重要性 α_i
16
        α_i = 0.5 * ln((1 - ε_i) / ε_i) // 示例公式，具体可能因算法而异
17

18
        // 4. 更新训练样本的权重
19
        对于 j 从 1 到 N:
20
            如果 C_i(x_j) 误分类了样本 j:
21
                w_j = w_j * e^(α_i)
22
            否则 (C_i 正确分类了样本 j):
23
                w_j = w_j * e^(-α_i)
24

25
        规范化权重 w_j，使其总和为 1 (∑w_j = 1)
26

27
        添加 C_i 到 C
28
        添加 α_i 到 Alpha
29

30
    返回 (分类器集合 C, 重要性权重集合 Alpha)
31

32
函数 Boosting_Classify(分类器集合 C, 重要性权重集合 Alpha, 测试样本 x):
33
    最终预测票数 = 一个空字典 (存储每个类别的加权票数)
34

35
    对于 C 中的每个分类器 C_i (对应的重要性权重 α_i):
36
        预测类别 p = C_i.predict(x)
37
        将 α_i 加到 p 的最终预测票数中
38

39
    返回 最终预测票数中票数最高的类别

显示更多显示更少

6. Adaboost 算法#

说明: Adaboost (Adaptive Boosting) 是 Boosting 算法的一个具体且流行的实现。它通过迭代训练一系列弱分类器，在每次迭代中，会增加前一轮被错误分类样本的权重，减少被正确分类样本的权重，使得后续的弱分类器更关注“困难”的样本。最终，通过加权多数投票的方式组合所有弱分类器，其中每个弱分类器的投票权重由其在训练中的错误率决定。

伪代码:

1
函数 Adaboost_Train(训练集 D = {(x_j, y_j)}, 基分类器算法 A, 迭代次数 K):
2
    N = D 的样本总数
3
    初始化每个训练样本的权重 w_j = 1/N (j = 1 to N)
4
    弱分类器集合 H = [] // 存储弱分类器
5
    弱分类器重要性权重集合 Alpha = [] // 存储每个弱分类器的权重
6

7
    对于 i 从 1 到 K:
8
        // 1. 使用当前样本权重 w_j 训练弱分类器 h_i
9
        // (这里假设算法 A 能处理带权重的样本)
10
        h_i = A.train(D, w_j)
11

12
        // 2. 计算弱分类器 h_i 的分类误差 ε_i
13
        ε_i = ∑ (j = 1 to N) w_j * I(h_i(x_j) != y_j) // I 是指示函数，当预测错误时为 1
14

15
        // 3. 检查误差，如果误差过大（大于 0.5），则视为无效学习，重新初始化权重并继续
16
        如果 ε_i > 0.5:
17
            w_j = 1/N (j = 1 to N) // 重置权重
18
            继续下一次迭代 (跳过当前迭代的剩余步骤)
19

20
        // 4. 计算弱分类器 h_i 的重要性权重 α_i
21
        α_i = 0.5 * ln((1 - ε_i) / ε_i)
22

23
        // 5. 更新样本权重
24
        对于 j 从 1 到 N:
25
            如果 h_i(x_j) != y_j: // 如果分类错误
26
                w_j = w_j * e^(α_i)
27
            否则: // 如果分类正确
28
                w_j = w_j * e^(-α_i)
29

30
        // 规范化权重 w_j，使其总和为 1
31
        w_sum = ∑ (j = 1 to N) w_j
32
        对于 j 从 1 到 N:
33
            w_j = w_j / w_sum
34

35
        添加 h_i 到 H
36
        添加 α_i 到 Alpha
37

38
    返回 (弱分类器集合 H, 弱分类器重要性权重集合 Alpha)
39

40
函数 Adaboost_Classify(H, Alpha, 测试样本 x):
41
    最终预测投票 = {} // 存储每个类别的加权票数
42

43
    对于 k 从 1 到 H.size():
44
        预测类别 p = H[k].predict(x) // 获取第 k 个弱分类器的预测结果
45
        将 Alpha[k] (第 k 个弱分类器的权重) 加到 最终预测投票[p] 中
46

47
    返回 最终预测投票中票数最高的类别

显示更多显示更少

7. k-means 算法#

说明: k-means 是一种迭代的划分聚类算法，旨在将 n 个数据对象划分为 k 个簇。它通过最小化平方误差准则（即每个簇内数据点到其簇中心的距离之和）来优化簇的划分。算法会反复调整簇的成员关系和簇中心，直到收敛。

伪代码:

1
函数 k_means_Cluster(数据集 D, 簇数目 k):
2
    // 1. 初始化：任意选择 k 个对象作为初始的簇中心 (平均值)
3
    随机选择 D 中的 k 个点作为初始均值 (μ_1, μ_2, ..., μ_k)
4

5
    重复:
6
        // 2. 簇分类 (分配步骤)：将每个对象分配到距离最近的簇
7
        创建 k 个空簇 C_1, C_2, ..., C_k
8
        对于 D 中的每个对象 x_j:
9
            找到距离 x_j 最近的簇中心 μ_i
10
            将 x_j 分配到簇 C_i
11

12
        // 3. 更新簇平均值 (更新步骤)：重新计算每个簇的平均值作为新的簇中心
13
        所有簇中心都设置为 null
14
        对于 每个簇 C_i (i = 1 to k):
15
            μ_i_new = C_i 中所有对象的平均值
16

17
        // 4. 检查收敛条件
18
        如果 所有簇中心 μ_i 不再明显地变化 (例如，新旧中心距离小于阈值)
19
        // 或 准则函数 E 不再明显地变化 (平方误差和)
20
        // E = ∑ (i=1 to k) ∑ (x 属于 C_i) ||x - μ_i_new||^2:
21
            跳出循环
22
        否则:
23
            μ_i = μ_i_new // 更新簇中心为新计算的值
24

25
    返回 k 个最终簇 C_1, C_2, ..., C_k

显示更多显示更少

8. AGNES 算法 (层次凝聚聚类)#

说明: AGNES (AGglomerative NESting) 是一种自底向上的层次聚类算法。它开始时将每个数据对象视为一个单独的簇，然后迭代地合并最相似的两个簇，直到达到预定义的簇数量。簇之间的相似度通常由它们之间最近的数据点对的距离确定（即“最小距离”准则）。

伪代码:

1
函数 AGNES_Cluster(数据集 D, 终止簇数目 k):
2
    // 1. 初始化：将每个对象当成一个初始簇
3
    簇集合 Clusters = { {o} | o 属于 D } // 每个对象都是一个单例簇
4

5
    重复:
6
        // 2. 检查终止条件
7
        如果 Clusters 中的簇数目 == k:
8
            跳出循环
9

10
        // 3. 找到当前簇集合中距离最近的两个簇
11
        min_distance = 无穷大
12
        closest_cluster_1 = null
13
        closest_cluster_2 = null
14

15
        对于 Clusters 中的每对不同簇 (C_a, C_b):
16
            // 计算 C_a 和 C_b 之间的距离 (例如，使用最小距离：两簇间最近点的距离)
17
            distance_ab = min(dist(p, q)) for p in C_a, q in C_b
18

19
            如果 distance_ab < min_distance:
20
                min_distance = distance_ab
21
                closest_cluster_1 = C_a
22
                closest_cluster_2 = C_b
23

24
        // 4. 合并最近的两个簇
25
        从 Clusters 中移除 closest_cluster_1 和 closest_cluster_2
26
        将 (closest_cluster_1 U closest_cluster_2) 添加到 Clusters // 合并后的新簇
27

28
    返回 最终的簇集合 Clusters

显示更多显示更少

9. DIANA 算法 (层次分裂聚类)#

说明: DIANA (Divisive ANAlysis) 是一种自顶向下的层次聚类算法。它开始时将所有对象放在一个簇中，然后迭代地将当前簇中“最不相似”（通常是直径最大或平均相异度最大的）的簇分裂成两个子簇，直到达到预定义的簇数量。分裂过程通常涉及识别簇中最“离群”的点作为新簇的种子。

伪代码:

1
函数 DIANA_Cluster(数据集 D, 终止簇数目 k):
2
    // 1. 初始化：将所有对象整个当成一个初始簇
3
    簇集合 Clusters = { D }
4

5
    对于 i 从 1 到 k-1: // 需要进行 k-1 次分裂才能得到 k 个簇
6
        // 2. 在所有当前簇中挑出具有最大直径（或平均相异度最大）的簇 C_to_split
7
        C_to_split = Clusters 中直径最大的簇 // 或者其他“最不紧凑”的度量
8

9
        // 3. 在 C_to_split 中找出与其它点平均相异度最大的一个点 p
10
        // (此点将被作为分裂的起点，形成新的分裂组)
11
        p = C_to_split 中平均相异度最大的点 // p 称为 splinter_group 的初始点
12
        splinter_group = {p}
13
        old_party = C_to_split - {p}
14

15
        重复:
16
            has_moved = 假
17
            // 4. 将 old_party 中满足条件（更接近 splinter_group）的点移入 splinter_group
18
            对于 old_party 中的每个点 q:
19
                dist_to_splinter = q 到 splinter_group 中点的最小距离
20
                dist_to_old_party = q 到 old_party 中点的最小距离
21

22
                如果 dist_to_splinter <= dist_to_old_party:
23
                    将 q 从 old_party 移到 splinter_group
24
                    has_moved = 真
25
            直到 not has_moved // 没有点再被移动
26

27
        // 5. 更新簇集合：移除被分裂的簇，加入新形成的两个子簇
28
        从 Clusters 中移除 C_to_split
29
        将 splinter_group 和 old_party 添加到 Clusters
30

31
    返回 最终的簇集合 Clusters

显示更多显示更少

10. DBSCAN 算法#

说明: DBSCAN (Density-Based Spatial Clustering of Applications with Noise) 是一种基于密度的聚类算法。它能够发现任意形状的簇，并且对噪声数据具有鲁棒性。DBSCAN 通过定义核心点、边界点和噪声点的概念，从核心点开始，将所有密度可达的点连接成簇。

伪代码 (根据概念描述综合，非直接源于PPT中的伪代码):

1
函数 DBSCAN_Cluster(数据集 D, 邻域半径 Eps, 最小点数 MinPts):
2
    簇标签 C = 一个映射，存储每个点所属的簇ID，初始为 未访问 (UNVISITED)
3
    簇ID = 0
4

5
    对于 D 中的每个点 P:
6
        如果 C[P] != UNVISITED:
7
            继续下一个点 (P 已经被处理过)
8

9
        C[P] = VISITED // 标记为已访问
10
        Neighbors = 获取 P 的 Eps-邻域内的所有点 // 包含 P 自身
11

12
        如果 Neighbors.size() < MinPts:
13
            C[P] = NOISE // 标记为噪声点
14
        否则:
15
            簇ID = 簇ID + 1 // 发现一个新的簇
16
            扩展簇(P, Neighbors, 簇ID, Eps, MinPts, D, C)
17

18
    返回 簇标签 C (每个点所属的簇ID或噪声标记)
19

20
函数 扩展簇(P_core, Neighbors, current_cluster_ID, Eps, MinPts, D, C):
21
    C[P_core] = current_cluster_ID // 将核心点 P_core 分配到当前簇
22
    队列 Q = new Queue()
23
    将 Neighbors 中的所有点添加到 Q
24

25
    当 Q 不为空时:
26
        CurrentP = Q.dequeue() // 从队列中取出一个点
27

28
        如果 C[CurrentP] == NOISE:
29
            C[CurrentP] = current_cluster_ID // 将噪声点重新分配为边界点
30

31
        如果 C[CurrentP] == UNVISITED: // 如果点未被访问过
32
            C[CurrentP] = VISITED // 标记为已访问
33
            CurrentP_Neighbors = 获取 CurrentP 的 Eps-邻域内的所有点
34

35
            如果 CurrentP_Neighbors.size() >= MinPts: // CurrentP 是新的核心点
36
                对于 CurrentP_Neighbors 中的每个点 N_neighbor:
37
                    如果 C[N_neighbor] == UNVISITED 或者 C[N_neighbor] == NOISE:
38
                        Q.enqueue(N_neighbor) // 将未访问或噪声点加入队列，以便后续处理
39

40
            C[CurrentP] = current_cluster_ID // 将 CurrentP 分配到当前簇

显示更多显示更少

11. Apriori 算法 (频繁项集产生和规则产生)#

说明: Apriori 算法是经典的关联规则挖掘算法，分为两个主要阶段：

频繁项集产生: 发现所有满足最小支持度阈值 (minsup) 的项集。它利用“先验原理”（任何非频繁项集的超集一定也是非频繁的）来有效剪枝搜索空间。
规则产生: 从所有发现的频繁项集中，提取满足最小置信度阈值 (minconf) 的关联规则。

伪代码:

1
函数 Apriori_Frequent_Itemset_Generation(事务数据集 T, 最小支持度 minsup):
2
    // 1. 发现频繁 1-项集 (F1)
3
    C1 = D 中所有唯一的项 (1-项集) 组成的集合
4
    F1 = {c 属于 C1 | c.support_count / |T| >= minsup} // 计算支持度并筛选
5

6
    频繁项集总集合 Frequent_Itemsets = F1
7
    k = 1
8

9
    重复:
10
        k = k + 1
11
        // 2. 候选项集产生 (Apriori-gen): 从 F(k-1) 生成 Ck
12
        // (此步骤会合并 F(k-1) 中的项集，并进行剪枝：如果一个 k-项集的任何 k-1 子集不在 F(k-1) 中，则该 k-项集不是频繁的)
13
        Ck = Apriori_candidate_generation(Fk-1)
14

15
        // 3. 计算候选项集 Ck 的支持度计数
16
        对于 T 中的每个事务 t:
17
            对于 Ck 中的每个候选项集 c:
18
                如果 c 包含在 t 中:
19
                    c.support_count++
20

21
        // 4. 从 Ck 中筛选出频繁项集 Fk
22
        Fk = {c 属于 Ck | c.support_count / |T| >= minsup}
23
        将 Fk 中的所有项集添加到 Frequent_Itemsets
24

25
    直到 Fk 为空 (没有新的频繁 k-项集产生)
26

27
    返回 Frequent_Itemsets // 所有频繁项集的集合
28

29

30
函数 Apriori_Rule_Generation(频繁项集 Frequent_Itemsets, 最小置信度 minconf):
31
    强关联规则集合 Rules = {}
32

33
    对于 Frequent_Itemsets 中的每个频繁项集 itemset (其长度 >= 2):
34
        // 对于 itemset 的每个非空真子集 antecedent:
35
        // 后件 consequent = itemset - antecedent
36
        // 剪枝原则：如果规则 X -> Y 的置信度不满足，那么任何 X' 包含 X 的规则 X' -> Y 的置信度也不会满足。
37
        // （这允许我们从后件最少的情况开始生成规则，并根据置信度进行剪枝）
38

39
        // 此处伪代码简化为直接遍历所有可能的 Antecedent 和 Consequent 组合
40
        对于 itemset 的每个非空真子集 antecedent:
41
            consequent = itemset - antecedent
42
            如果 consequent 为空:
43
                继续下一个子集 (后件不能是空集)
44

45
            confidence = itemset.support_count / antecedent.support_count
46

47
            如果 confidence >= minconf:
48
                将规则 (antecedent -> consequent) 添加到 Rules
49

50
    返回 Rules

显示更多显示更少

第八章维护

Sun, 08 Jun 2025 00:00:00 GMT

1. 维护的定义与持续时间#

定义：软件维护是指软件在交付使用之后，为了改正错误或满足新的需要而修改软件的过程。这包括修复错误（bug）或增加新功能（如游戏更新、App更新）。
持续时间：维护是软件开发过程中持续时间最长的阶段。它的时间定义是从软件交付之日到该软件最终被废弃为止。即使软件没有进行维护活动，但只要还在使用，就属于维护阶段。

2. 维护的四种类型#

维护活动可以分为四种类型：

改正性维护 (Corrective Maintenance / 改错性维护)：
- 定义：诊断和改正错误的过程。主要是修改bug。
- 特点：比较常见。
适应性维护 (Adaptive Maintenance)：
- 定义：为了和变化的环境适当配合而修改软件的过程。
- 特点：是必要且经常的维护活动。例如，当硬件发展较快，软件需要更新以适配新硬件时。
完善性维护 (Perfective Maintenance)：
- 定义：用户在使用软件过程中，提出增加新功能、修改已有功能或一般性改进建议而进行的维护。
- 特点：通常占维护活动的大部分比重。主要是增加或增强功能。
预防性维护 (Preventive Maintenance)：
- 定义：为了改进未来的可维护性、可靠性，或为未来的改进奠定更好的基础而修改软件时进行的维护。
- 特点：目前所占比重较少。例如，在预定维护日期前整理文档资料或修改不适应的代码。

四类维护所占大致比重：

完善性维护：55% 至 66%
改正性维护：约 20%
适应性维护：约 20%
预防性维护：约 4%

3. 软件维护的特点#

结构化维护与非结构化维护差别巨大：
- 非结构化维护：软件配置成分只有程序代码，文档、数据等缺失。这种软件维护起来非常困难，因为第一步就是难以读懂。
- 结构化维护：存在完整的软件配置，从设计阶段开始的文档、图文资料都齐全。这种软件相对容易读懂和维护。
- 主要区别在于文档是否齐全。
维护的代价高昂：
- 金钱代价：最明显的体现在维护费用上。
- 无形代价：
  - 耽误甚至丧失开发的良机：可用资源必须供给维护使用，可能需要抽调正在开发新项目的人员去做维护，从而耽误新项目的开发。
  - 引起用户不满：当看起来合理的改错和修改要求不能及时满足时。
  - 降低软件质量：维护时的改动可能在软件中引入潜伏的错误。为避免这种情况，需要进行回归测试以防止非预期的副作用。
  - 造成开发过程混乱：软件工程师被突然调去从事维护工作，会造成工作交接和断档问题。
维护问题很多：
- 根本原因：绝大多数问题都归因于软件定义和软件开发方法的缺点。通常是因为开发定义阶段没做好或文档资料不全。
- 具体问题：
  - 理解别人写的代码非常困难：尤其当软件配置成分减少（如仅有程序代码没有说明文档）时，困难程度迅速增加。
  - 软件缺乏合格的文档或文档资料显著不足。
  - 不能指望开发人员仔细说明：软件寿命长，原开发人员可能已离职或记不住细节。
  - 绝大多数软件在设计时没有考虑将来的修改：导致将来增加功能或扩充困难。
  - 软件维护不是一项吸引人的工作：因为维护工作可能很困难，需要反复论证和验证。

4. 软件维护过程#

维护过程本质上是修改和压缩的软件定义和开发阶段。

建立维护组织：通常不会成立专门的正式维护组织，而是指派原开发人员进行维护工作。
确定维护报告和评价过程：
- 软件问题报告表：由用户提交，类似于报修流程。
- 维护要求表：由维护人员编写，给出软件修改报告的必要信息，如所需工作量、维护性质和优先次序等。
为每个维护规定一个标准化的事件流：
- 第一步：确定要进行维护的类型（改错、改进或适应性维护）。
- 若是改错型：
  - 估算严重程度（优先级）。
  - 严重问题：立即开始工作。
  - 不严重问题：写入修正计划，等待统一修改。
- 若是改进或适应性：
  - 进行优先度评价。
  - 严重的：立即开始做。
  - 低的：放到开发目录，等待统一修改。
- 最后：进行复审。
建立用于维护的保存过程和规定复审标准：收集每项维护工作的数据，如完成日期、开始日期、使用人员等，可构建数据库。
评价维护活动：至少从七个方面对维护进行评价，包括每类维护活动的人员总数等。

5. 软件的可维护性#

定义：维护人员理解、改动、改进、改正软件的难易程度。也可指扩充和压缩的难易程度。
决定软件可维护性的因素（及提高方法）：
- 可理解性 (Understandability)：
  - 定义：外来读者理解软件结构、功能、接口和内部处理过程的难易程度。
  - 提高方法：模块化、详细的文档、结构化设计、程序的内部文档和良好的高级程序设计语言。
- 可测试性 (Testability)：
  - 定义：诊断和测试的容易程度，取决于软件的可理解程度。
  - 关系：可理解性与可测试性相互促进。
  - 提高方法：良好的文档、合理的软件结构、好用的测试工具和调试工具，以及良好的测试过程。
- 可修改性 (Modifiability)：
  - 影响因素：耦合、内聚、信息隐蔽、局部化、控制与作用力的关系等。强调模块独立性。
- 可移植性 (Portability)：
  - 定义：把程序从一个计算环境转移到另一个计算环境的难易程度。
  - 提高方法：将因环境变化而必须修改的程序局限在少数模块中。
- 可重用性 (Reusability)：
  - 定义：同一个事物不做修改或稍加修改，在不同环境中多次重复使用。
  - 益处：大量使用重用构件可以提高可维护性，因为重用构件经过多次验证且节省人力。例如：类、类库。
- 文档 (Documentation)：
  - 决定因素：文档是影响软件可维护性的决定因素。
  - 两类文档：
    - 用户文档：主要描述系统功能和使用方法。
    - 系统文档：如软件可行性报告、需求规格说明书等用户不关心但开发人员需要的资料。

6. 预防性维护的方法：软件再工程 (Software Re-engineering)#

软件再工程是预防性维护的一种方法。

预防性维护的几种做法：
1. 反复多次尝试修改程序，与源代码“顽强战斗” (不推荐)。
2. 通过仔细分析程序员，尽可能多地掌握内部细节以有效修改。
3. 在深入理解原有设计的基础上，用软件工程方法重新设计、编码、测试那些需要变更的部分 (部分再工程)。
4. 使用软件工具和方法学为指导，对程序进行全部重新设计、编码和测试 (完整再工程，使用CASE工具等)。
软件再工程的工作内容：
- 库存目录分析 (Inventory Analysis)：
  - 分析应用系统的基本信息（如年份、用户量、规模、修改次数、业务重要程度等）。
  - 识别预防性维护（再工程）的对象：
    - 预定要使用很多年的程序。
    - 当前正在成功使用的系统/程序。
    - 近期内具有重大修改或增强的程序。
- 文档重构 (Document Restructuring)：
  - 老程序固有特点是文档资料缺失。文档重构非常耗时。
  - 策略：
    - 保持现状：如果软件即将废弃，没必要重构文档。
    - 部分重构：只针对系统当前正在修改的部分建立文档，随时间推移逐渐攒齐。
    - 完整重构：针对业务关键系统，仍然需设法压缩工作量进行全面文档重构。
- 逆向工程 (Reverse Engineering)：
  - 定义：分析程序，以便在比源代码更高的抽象层次上创建程序的某种表示过程。
  - 目的：恢复设计结果。工具从现有程序中抽取有关数据、体系结构和处理过程的设计信息。
- 代码重构 (Code Restructuring)：
  - 描述：最常见的再工程活动。适用于体系结构完整但个体编码方式较差的老程序。
  - 做法：用重构工具分析源代码，标注违背结构化程序概念的部分，重构有问题代码，复审测试重构代码并更新文档。
- 数据重构 (Data Re-engineering)：发生在较低抽象层次上的全范围再工程活动。
- 正向工程 (Forward Engineering) / 革新或改造 (Renovation or Re-adaptation)：
  - 定义：不仅从现有程序中恢复设计信息，而且用该信息去改编或重构现有系统。
  - 目的：提高整体质量。

第七章实现

Sat, 07 Jun 2025 00:00:00 GMT

第七章“实现”主要包含编码工作和测试两大部分内容。

7.1 编码 (Coding)#

定义：将软件设计结果翻译成某种程序设计语言，书写程序。

7.1.1 选择程序设计语言

语言分类：
- 汇编语言 (Assembly Language)：将软件设计翻译成机器操作序列，表示方式不同，既困难又容易出错。
- 高级语言 (High-Level Language)：如 Java, C#, C++, C, Python, MATLAB 等。
  - 优势：
    - 一句对应多句，效率更高（实现相同功能代码量更少）。
    - 允许用户给程序变量或子程序赋予含义鲜明的名字，便于多人协作理解。
    - 使用的符号和概念符合人的习惯思维 (如 if-else, =, +)。
    - 书写、阅读、测试、调试和维护更容易。
  - 应用现状：绝大多数情况下使用高级语言，极特别领域使用汇编语言。
语言选择标准 (7个)：
1. 系统用户的要求：用户可能指定特定语言以方便内部维护。
2. 可使用的编译程序：目标环境提供的编译程序限制语言范围。
3. 可得到的软件工具：方便的软件工具利于编写和验证。
4. 工程的规模：有些语言更适合大型程序开发。
5. 程序员的知识：程序员是否熟练掌握该语言。
6. 可一致性要求：软件是否需分布到不同计算机上。
7. 应用领域：不同领域对语言有使用限制。

7.1.2 编码风格 (Coding Style)

定义：编写程序时表现出的特点、习惯和逻辑思路。
良好风格的养成

(5个方面)：
1. 程序的内部文档：
  - 恰当的标识符 (含义鲜明的名字)：帮助阅读者理解程序。
  - 适当的注解 (注释)：程序员之间及对未来自己的重要通信手段，有助于程序理解。
2. 程序的视觉组织 (代码排版)：
  - 对程序可读性有很大影响。
  - 应利用适当的阶梯形式来表示层次结构 (如 if-then-else 的缩进)。
3. 数据说明：
  - 次序应标准化 (按类型或数据结构)。
  - 多个变量名在同一语句说明时，应按字母顺序排列。
  - 复杂数据结构应注释说明其实现方法和特点。
4. 语句构造：
  - 每个语句应清晰而简单，不应为提高效率使程序过分复杂。
5. 效率：
  - 指处理机时间和存储容量两方面。
  - 效率是性能要求，应在需求分析阶段明确。
  - 好的设计提高效率。
  - 程序的效率和程序的简单程度应一致，不应牺牲清晰性和可读性不必要地提高效率。

7.2 测试基础 (Testing Basics)#

7.2.1 测试阶段的根本目标

尽可能多地发现并排除软件中潜藏的错误。
最终把一个高质量的软件交给用户使用。
强调：软件测试不可能排除所有的错误，因为技术和测试用例限制。

7.2.2 软件测试的目标 (定义)

测试是为了发现程序中错误而执行的过程。
好的测试方案是尽可能发现迄今为止尚未发现错误的测试方案。
成功的测试是发现了迄今为止尚未发现错误的测试。

7.2.3 测试准则 (7个)

所有测试都应追溯到用户需求：不符合需求是最严重的错误。
远在测试开始之前就应制定测试计划 (在设计阶段制定)。
应将二八原则 (Pareto principle) 应用到软件测试中。
应从小规模测试开始，逐步进行大规模测试 (如从单元测试到验收测试)。
穷举测试是不可能的：软件路径众多，测试用例无法穷尽，因此需要逻辑覆盖等方法。
为达到最佳测试效果，应有独立的第三方进行测试工作 (测试人员与代码编写人员分开)。

7.2.4 测试方法

黑盒测试 (Black-box Testing)：
- 定义：把程序看作一个黑盒子，完全不考虑程序内部结构和处理过程，只在程序的接口进行测试。
- 检查内容：程序功能是否按规格说明书正常使用，能否接收数据并产生正确输出，运行中是否保持外部信息完整性。
- 别称：功能测试。
- 理解：只关心结果是否正确，不关心过程 (类比数学题，结果对过程错，黑盒老师判对)。
- 使用阶段：通常在后期进行。
- 发现错误类型：功能不正确或遗漏、界面错误、数据结构错误、性能错误、初始化和终止错误。
- 技术：等价划分、边界值分析、错误推测。
白盒测试 (White-box Testing)：
- 定义：把程序装在透明盒子里，测试者完全知道程序的结构和处理算法，按照程序内部逻辑进行测试，检查执行通路是否按预定要求工作。
- 别称：结构测试。
- 理解：关心结果是否正确且过程是否正确 (类比数学题，过程错结果对，白盒老师判错)。
- 使用阶段：通常在早期使用。
- 关注重点：模块的接口、局部数据结构、重要的执行通路、出错处理通路、边界条件。
- 技术：
  - 逻辑覆盖 (Logic Coverage)：选取具有代表性的软件路径进行测试，是穷尽测试唯一可行的替代办法。
    - 语句覆盖 (Statement Coverage)：最弱，要求程序的每个语句都执行一次。
    - 判定覆盖 (Decision Coverage / Branch Coverage)：每个语句执行一次，且每一个判定结果的每种可能结果都执行一次 (每个分支至少执行一次)。
    - 条件覆盖 (Condition Coverage)：每个语句执行一次，且判定表达式的每个条件都能取得各种可能结果。
    - 判定/条件组合覆盖等 (要求更严格)。
- 控制结构测试 (Control Structure Testing)：
  - 基本路径测试 (Basis Path Testing)：非常重要。
    - 步骤：
      1. 根据设计结果画出相应的流图。
      2. 计算环形复杂度 (Cyclomatic Complexity)：
        
        方法一：V(G) = P + 1 (P为判定节点数)。
        
        方法二：数闭区间数量加一。
      3. 确定线性独立路径的基本集合：独立路径指至少引入程序一条新处理语句或一条新条件路径，或一条之前未使用的边。路径数量等于环形复杂度。
      4. 设计测试用例强制执行基本集合中的每条路径。
  - 条件测试、循环测试。
灰盒测试 (Grey-box Testing)：介于黑盒与白盒之间的一种测试方法。

7.2.5 测试步骤 (按顺序，及发现错误类型)

模块测试 (Module Testing) / 单元测试 (Unit Testing)：
- 目标：保证每个模块作为单元正常运行。
- 发现错误类型：编码和详细设计的错误。
- 主要使用：白盒测试技术。
- 手段：
  - 代码审查 (Code Review)：人工进行，可由编写者非正式进行，或由审查小组正式进行 (组长、设计者、编写者、测试者组成)。高效，能查出30%-70%的逻辑设计错误和编码错误。与计算机测试互补。
  - 计算机测试 (Computer Testing)：
    - 驱动软件 (Driver Software)：假的主程序，接收测试数据，传输给被测试模块，并打印结果。用于测试底层模块。
    - 存根软件 (Stub Software)：被代替模块所调用的模块 (虚拟子程序)，用于代替底层小弟接收指令。用于测试顶层模块。
    - 缺陷：驱动和存根软件代表开销，增加成本。
子系统测试 (Subsystem Testing)：
- 目标：将单元模块放在一起，测试模块相互之间的协调、通信。
- 发现错误类型：模块接口错误。
- 特点：兼有测试和组装两重含义，常称之为集成测试的一部分。
系统测试 (System Testing)：
- 目标：将测试的子系统装配成一个完整的整体进行测试。
- 发现错误类型：软件设计中的错误以及需求说明中的错误。
- 特点：兼有测试和组装两重含义，常称之为集成测试的一部分。
集成测试 (Integration Testing)：
- 包含：子系统测试和系统测试。
- 模块组装方法：
  - 非渐增式 (Non-incremental)：先分别测试每个模块，再全部组装成程序。
  - 渐增式 (Incremental)：将下一个要测试的模块与已测试好的模块结合，每次增加一个。更彻底，易于定位错误位置，通常推荐使用。
- 渐增式策略 (两种)：
  - 自顶向下集成 (Top-down Integration)：
    - 从主控模块 (上层) 开始向下移动，逐渐结合模块。
    - 优点：能在测试早期验证软件主要功能，早期发现上层模块的接口错误。
    - 缺点：需要存根程序，底层发现错误较晚。
  - 自底向上集成 (Bottom-up Integration)：
    - 从原子模块 (底层) 开始向上组装测试。
    - 优点：不需要存根程序，底层模块发现错误较早，能充分展示人力。
    - 缺点：需要驱动程序，验证主要功能和发现上层接口错误较晚。
- 回归测试 (Regression Testing)：
  - 目的：执行已做过测试的某个子集，保证软件由于调试或其他原因引起的变动不会带来非预期副作用 (如引入新的错误)。
验收测试 (Acceptance Testing) / 确认测试 (Confirmation Testing)：
- 目标：把软件作为一个单一实体进行测试，验证软件的有效性 (软件功能和性能如同用户合理期待)。
- 特点：用户积极参与，主要使用实际数据。
- 发现错误类型：需求规格说明书中的错误。
- 主要使用：黑盒测试。
- 重要内容：软件配置复查，确保所有成分齐全，质量符合要求，文档和程序一致，便于维护。
- 分类：
  - 阿尔法测试 (Alpha Testing)：
    - 在开发者场所进行，开发者在用户指导下进行，记录错误，受控环境。开发者是主导地位。
  - 贝塔测试 (Beta Testing)：
    - 由最终用户在一个或多个客户场所进行，开发者通常不在场，软件在开发者不能控制的环境下进行真实应用。用户拥有更多权利。
平行运行 (Parallel Running)：
- 定义：同时运行新开发的系统和即将被取代的旧系统。
- 目的/优点：
  - 可在准生产环境中运行新系统，不冒风险。
  - 用户有时间熟悉新系统。
  - 可以验证用户手册等文档。
  - 以准生产模式验证性能指标 (如负载冲击测试)。

7.2.6 测试阶段的信息流 (使用的文档资料)

软件配置文档：
- 需求说明书：用于编写用例，检查是否满足需求。
- 设计说明书：用于检测软件设计问题和进行白盒测试。
- 源程序清单 (代码)。
测试相关文档：
- 测试计划。
- 测试方案：不仅包含输入数据，还需有每组数据预期检验的功能和预期得到的正确输出 (像有题有答案)。

7.8 调试 (Debugging)#

定义：作为成功测试的后果出现，是发现错误后排错的过程。
过程：执行测试用例 -> 产生结果 -> 调试 (一眼识出/推测验证) -> 确认改正。
调试困难的原因 (心理、技术、软件固有特征)：
- 症状与问题发生地距离远。
- 改正错误后症状暂时消失。
- 症状并非由错误引起。
- 症状可能由不易跟踪的人为引起。
- 症状可能由定时问题引起。
- 很难产生完全一样的输入条件 (难以复现)。
- 症状时有时无。
- 症状可能分布在多个任务中。
调试的途径 (3种)：
1. 蛮干法 (Brute-force Method)：其他方法失效后的最后手段，地毯式搜索。
2. 回溯法 (Backtracking Method)：常用调试方法，从发现症状的地方人工沿控制流程回溯追踪错误点，小程序适用。
3. 原因排除法 (Cause Elimination Method)：
  - 对分查找法 (Binary Partitioning)：将程序一分为二，逐步缩小错误范围。
  - 归纳法 (Induction)：从个别现象推断一般结论，组织分析错误数据。
  - 演绎法 (Deduction)：从原理和前提出发，设想问题原因并逐个验证。

7.9 软件可靠性 (Software Reliability)#

定义：
- 软件可靠性：在给定时间间隔内成功运行的概率。
- 软件可用性 (Availability)：在给定时间点成功运行的概率。
估算平均无故障时间的方法：MTTF (Mean Time To Failure) 是一个重要的参考指标。

第一章数据挖掘概述

Mon, 02 Jun 2025 00:00:00 GMT

什么是数据挖掘？#

数据挖掘不是简单地从网络或数据库搜索数据。
数据挖掘与知识发现 (Knowledge Discovery in Database, KDD) 相关。

数据挖掘 (Data Mining, DM) 定义#

通用定义: 数据挖掘是发现数据中潜在的有用模式（信息、知识、规律、模型）的过程。
- 例如：猎人在动物迁徙行为中寻找模式，农夫在庄稼生长中寻找模式，政客在选民意见中寻找模式。
技术角度: 利用一种或多种计算机学习技术，从数据中自动分析并提取信息的处理过程。
- 目的是寻找和发现数据中潜在的、有价值的信息、知识、规律、联系和模式。
- 与计算机科学有关，通常使用机器学习、统计学、联机分析处理、专家系统和模式识别等多种方法实现。
学科角度: 是一门交叉学科，涉及数据库技术、人工智能技术、统计学、可视化技术、并行计算等多种技术。
商业角度: 是一种商业智能信息处理技术。
- 围绕商业目标开展，对大量商业数据进行抽取、转换、分析和处理。
- 从中提取辅助商业决策的关键性数据，揭示隐藏的、未知的或验证已知的规律性。
- 是一种深层次的商业数据分析方法。

数据挖掘与知识发现 (KDD) 的关系#

KDD 是指从数据中发现有用知识的整个过程。
数据挖掘 是 KDD 过程中的一个特定步骤。
数据挖掘是特定算法的应用，用于从数据中提取模式。
KDD 过程的步骤:
1. 选择: 从数据到目标数据。
2. 预处理: 将目标数据转换为已处理数据。
3. 转换: 将处理后的数据转换为转换数据。
4. 数据挖掘: 将数据转换为模式。
5. 解释和/或评估模式: 将模式转化为知识。

数据挖掘的四个“超级问题”或能做什么#

数据挖掘的核心任务或可以解决的问题包括：预测、聚类、关联分析和异常分析。进一步细化为以下几项功能：

分类 (Classification)
- 目的: 使用已知类别的实例建立分类模型，对未知类别的实例进行分类。
- 输出: 离散量。
- 类别数: 确定。
- 应用示例: 评估信用卡申请者的风险等级（低、中、高）。
- 与聚类的区别: 分类通过有标注语料学习假设函数、确定决策分界。
估值 (Estimation)
- 目的: 根据已知属性值，估计一个连续值的输出。
- 输出: 连续值。
- 量: 不确定。
- 应用示例: 根据购买模式，估计一个家庭的孩子个数、收入或财产。
- 与分类的区别: 类似于分类，但输出是连续值。
预测 (Prediction)
- 目的: 通过分类或估值得出预测模型，用该模型对未知变量进行预测。
- 方法: 通常通过分类或估值的方法来实现。
- 应用示例: 预测明天上证指数的收盘价。
相关分析 (Association Analysis)
- 目的: 发现数据中属性之间的有价值的联系。生成关联规则，表达客户购买行为的关联关系。
- 应用示例: 购物篮分析 (Market Basket Analysis)——寻找零售产品之间有趣的关系，如购买A同时是否经常购买B。
- 方法: 生成关联规则。关联规则可以有多个输出属性。
- 算法: 最著名的是 Apriori 算法 (Agrawal, 1993)。Apriori 算法不支持数值型数据，需进行数据变换。
- 关联规则示例
  
  (基于感冒数据集):
  - IF Leukocytosis = Yes THEN Fever = Yes
  - IF Increased-lym = No THEN Sore-throat = Yes
  - IF Cooling-effect = Good THEN Fever = Yes
聚类 (Clustering)
- 目的: 对实例分组，把相似的实例放在一个聚类（簇）中。发现最能区分各聚类的典型属性，使用这些属性开发预测未来结果的模型。
- 特点: 是一种无指导（无教师）的学习。在学习训练之前，无预先定义好分类的实例。
- 方法: 数据实例按照某种相似性度量方法计算相似程度，将最相似的实例聚类在一个组——簇 (Cluster) 中。然后解释和理解每个簇的含义。
- 应用示例: 在信用卡公司，发现一组输入属性来区分接受寿险促销和未接受促销的持卡人。市场细分、社交圈分析、集群计算、天体数据分析。
- 与分类的区别: 聚类通过簇内相似度及簇间的距离对不同簇进行划分。
- 聚类技术/算法: 基于划分（如 K-means）、基于分层、基于模型等。K-means (K-均值) 算法 是一种最为常用和易用的算法。
- K-means 算法过程: 迭代过程，分为簇分类和移动聚类中心。
  - 指定一个初始的簇的个数 (K)。
  - 任意选定 K 个对象作为初始簇中心。
  - 根据与簇中心的距离，每个对象被分配给最近的一个簇（簇分类）。
  - 计算每个簇中样本点的平均值，将相应的聚类中心移动到这个均值处。
  - 重复迭代，直到没有对象被重新分配或聚类中心不再改变。
- 聚类结果示例
  
  (基于感冒数据集，K=2): 聚类为两个簇，每个簇有5个实例。
  - Cluster0 = {1,3,4,8,9}
  - Cluster1 = {2,5,6,7,10}
  - 簇的概念结构可表示为产生式规则。
异常分析 (Anomaly Analysis) / 异常检测 (Anomaly Detection)
- 目的: 通过数据挖掘方法发现与数据集分布不一致的异常数据。也被称为离群点、异常值检测。
- 适用场景特点:
  - (1) 无标签或者类别极不均衡。
  - (2) 异常数据跟样本中大多数数据的差异性较大。
  - (3) 异常数据在总体数据样本中所占的比例很低。
- 常见应用案例:
  - 金融领域: 识别“欺诈用户”（信用卡申请欺诈、盗刷、信贷欺诈）。
  - 安全领域: 判断流量数据波动和是否受到攻击。
  - 电商领域: 识别“恶意买家”（羊毛党、恶意刷屏团伙）。
  - 生态灾难预警: 基于天气指标数据判断极端天气。
  - 医疗监控: 从医疗设备数据发现可能显示疾病状况的异常数据。

与数据挖掘有关的概念#

数据查询 (Data Query)
- 通过数据查询语言在数据中找出需要的数据或信息。
- 与数据挖掘的区别: 数据查询获取的是浅知识或多维知识，而数据挖掘获取的是潜在的、隐藏的信息或知识——隐含知识 (Hidden Knowledge)。
专家系统 (Expert System)
- 一种具有“智能”的计算机软件系统。
- 能够模拟某个领域人类专家的决策过程，解决复杂问题。
- 通常包含以规则形式表示的领域专家的知识和经验。
- 专家系统方法与数据挖掘方法有所不同。
机器学习 (Machine Learning)
- 是数据挖掘中常用的技术方法之一。
- 概念学习 (Concept Learning): 通过大量实例训练发现经验化规律。结果通常表现为概念。机器擅长学习概念。概念可以从传统、概率、样本三个角度看待。
- 归纳学习 (Induction-Based Learning): 基于归纳的学习，是机器学习的一种方式。通过观察特定实例、研究已有经验材料，获取和探索新知识，以概念形式表现。
- 有指导的学习 (Supervised Learning):
  - 定义: 通过对大量已知分类或输出结果值（有标记 labels）的实例进行训练。调整模型结构，建立能够准确分类或预测未知模型的目的。
  - 用于：分类、估值、预测。
  - 数据: 使用有标注数据集 (x(1),y(1)),(x(2),y(2)),…,(x(m),y(m))。
  - 目标: 学习出假设函数、确定决策分界。
  - 示例方法: 决策树、神经网络、回归分析。
- 无指导的聚类 (Unsupervised Clustering):
  - 定义: 无指导（无教师）的学习。未给出具体的标记 y(m)，仅有数据集 (x(1), x(2),…,x(m))。
  - 用于：聚类。
  - 目标: 算法对同一类的进行划分。
  - 示例方法: K-means 算法、凝聚聚类方法、概念分层 Cobweb 算法、EM 算法。神经网络也可以建立无指导聚类模型。

有监督学习的具体方法举例#

决策树 (Decision Tree)
- 一种倒立树。
- 非叶子节点表示在一个属性上的分类检查。
- 叶子节点表示决策判断的结果。
- 有很多算法 (文本提到 C4.5)。
- 可以被翻译为一个产生式规则集合。
- 产生式规则格式: IF 前提条件 THEN 结论。
- 示例 (基于感冒类型诊断): IF Sore-throat = No THEN Cold-type = Viral 等。
神经网络 (Neural Network)
- 一种具有统计特性的数学模型。
- 创建思想源于人类神经网络的结构、功能和运行过程。
- 试图模拟人脑功能来完成学习。
- 是非常流行的数据挖掘技术。
- 可以建立有指导学习模型和无指导聚类模型。
- 输入属性必须是数值的，输出属性可以是数值的或分类的。
- 前馈 (Feed-Forward) 神经网络
  
  是常用的有指导的学习模型。
  - 通常是全连接的：每一层的每个节点都与其下一层的所有节点相连接，同层节点不相连。每个网络连接有权重值。
- 建立神经网络模型的两个阶段:
  1. 学习训练阶段: 提交实例输入属性值，计算输出，与期望输出比较产生误差，通过修改连接权值传回网络。训练终止条件：达到迭代次数或错误率收敛。
  2. 检验阶段: 固定网络权重，用于计算新实例的输出值。
回归分析 (Regression Analysis)
- 一种有监督的统计分析方法。
- 用来确定两个或两个以上变量之间的定量的依赖关系。
- 建立一个数学方程作为数学模型，来概化一组数值数据。
- 进而进行数值数据的估值和预测。
- 示例: 使用回归方程预估办公楼的价值。

数据挖掘的过程 (KDD过程中的数据挖掘阶段)#

数据挖掘实验通常分为4个步骤：

准备数据:
- 重要且费时。
- 明确目标后，从传统数据库、数据仓库和平面文件收集和抽取数据。
  - 传统数据库: 操作型数据库，面向日常事务处理，关系模型，规范化二维关系表。
  - 数据仓库: 面向决策支持，非日常事务处理。
  - 平面文件: 数据量较小的数据集，如 Excel 电子表格。
- 包括准备训练数据和检验数据。
挖掘数据:
- 选择一种数据挖掘技术或算法，将数据提交给数据挖掘工具，应用算法建立模型。
- 选择技术/算法需考虑:
  - (1) 判断学习是有指导还是无指导的。
  - (2) 数据集中哪些实例和属性提交；哪些作训练数据；哪些作检验数据。
  - (3) 如何设置数据挖掘算法的参数。
解释和评估结果:
- 检查数据挖掘输出，评估是否达到目标，确定发现的信息是否有价值。
- 如果结果不理想，可以重复实验：(1) 使用新的数据实例或属性；(2) 选择新的数据挖掘算法或参数。
- 数据挖掘过程是一个迭代的过程。
模型应用:
- 数据挖掘的终极目标。
- 应用分类模型解决疾病诊断。
- 应用聚类模型进行顾客分类，找出特征，为促销提供决策支持。
- 应用关联分析模型找出商品购买关联关系，为货架摆放、促销提供决策支持。

数据挖掘的作用#

能够解决疾病诊断问题（如例1.1）。
能够解决对顾客的分类问题，为促销活动等提供决策支持。
能够找出商品购买关联关系，为货架摆放、商品促销提供决策支持。

数据挖掘的应用案例#

金融领域: 甄别虚假医疗凭据、识别洗钱行为、提高金融产品销售定价准确率。
通信领域: 根据家庭特征确定客户倾向和需求，帮助签约和增加交易额。
医疗领域: 通过心肌SPECT图像诊断冠心病。
媒体娱乐: 分析票房收入确定受欢迎的演员和故事情节。
科学研究: 发现第三类γ射线爆。
体育领域: 优化战术组合 (NBA)。
流媒体/内容推荐: 成功营销热播剧 (Netflix)。

数据挖掘软件 - Weka#

简介:
- 全称: Waikato Environment for Knowledge Analysis (怀卡托智能分析环境)。
- 诞生于新西兰怀卡托大学 (University of Waikato)。
- 基于 Java 的免费开源软件。
- 集成了数据挖掘的机器学习算法和统计技术。
- 功能: 数据预处理、分类、聚类、关联分析、属性选择和交互式可视化。
- 特点: 操作简单、易学易用，适合入门。若未安装 JRE 需下载包含 JRE 的版本。
Weka 软件特点:
- 跨平台。
- 支持多种文件格式 (结构化文本、数据挖掘格式、数据库接口)。
- 支持连续型数值数据和离散型（字符型和日期型）数据。
- 强大的数据预处理功能: 缺失数据处理、噪声处理、标准化、离散化、属性构造、变量转换、数据拆分、平滑等。
- 提供数据挖掘功能: 分类、聚类、关联、可视化。
- 算法灵活: 提供算法组合、用户自定义算法嵌入、参数设置。
- 报告和评估: 生成基本报告、测试报告、输出格式，实现模型解释、比较、数据评分。
- 可视化功能: 数据、挖掘过程和结果可视化。
Weka 的文件格式:
- 默认使用 ARFF (Attribute-Relation File Format) 格式。
- 一种 ASCII 文本文件格式。
- 由两部分组成:
  - 头信息 (Head Information): 关系的声明和属性的声明。
  - 数据信息 (Data Information): 数据集中的数据实例 (Instance)。
Weka 的功能/界面:
- 有 4 种界面 (GUI)。
- Explorer: 数据挖掘用户最常用的界面。包含 6 个选项卡/功能: Preprocess (预处理), Classify (分类), Cluster (聚类), Associate (关联分析), Select attributes (属性选择), Visualize (可视化)。
- Experimenter。
- Knowledge Flow。
使用 Weka 的基本步骤: (以示例为基础)
1. 准备数据。
2. 加载和预处理数据。
3. 建立模型（分类、聚类、关联分析等）。
4. 应用模型（如分类未知实例）、解释和评估结果。

本讲小结#

数据挖掘是建立模型，不是魔术！
模型建立是人类本性（归纳和分类）使然，是一个自然、有趣且有意义的过程。

第二章数据

Mon, 02 Jun 2025 00:00:00 GMT

数据挖掘导论第二章：数据

本章重点介绍了数据及其基本概念、数据质量问题与处理方法，以及数据预处理技术和衡量数据对象之间相似性与相异性的度量方法。

2.1 数据类型

数据：数据集是数据对象的集合。
数据对象 (Data Object)：用一组刻画其基本特性（如物体质量或事件发生时间）的属性描述。
- 其他名称：记录、点、向量、模式、事件、案例、样本、观测或实体。
属性 (Attribute)：对象的性质或特性。
- 其他名称：变量、特性、字段、特征或维。
- 例：眼球的颜色、温度。
测量标度 (Measurement Scale)：将数值或符号值与对象的属性相关联的规则（函数）。
属性 vs. 属性值
- 同样的属性可以映射到不同的值域中，例如身高可以用cm或m做单位。
- 不同属性可以映射到同一组值的集合，例如ID和年龄，但属性值的性质不同（ID没有上限，年龄有最大最小值）。
- 属性可以用一种不描述属性全部性质的方式测量。
属性的类型
- 属性可以通过数值的如下性质来描述：相异性 (= ≠), 序 (< >), 加法 (+ -), 乘法 (* /)。
- 标称属性 (Nominal)：
  - 值仅仅只是不同的名字，只提供足够的信息以区分对象。
  - 性质：相异性。
  - 允许的变换：任何一对一变换（例如值的排列）。
  - 例：邮政编码、雇员ID号、眼球颜色、性别。
  - 允许的操作：众数、熵、列联相关、χ²检验。
- 序数属性 (Ordinal)：
  - 值提供足够的信息确定对象的序。
  - 性质：相异性、序。
  - 允许的变换：值的保序变换（新值 = f(旧值), 其中f是单调函数）。
  - 例：矿石硬度、{好，较好，最好}、成绩、街道号码。
  - 允许的操作：中值、百分位、秩相关、游程检验、符号检验.
- 区间属性 (Interval)：
  - 值之间的差是有意义的，存在测量单位。
  - 性质：相异性、序、加法.
  - 允许的变换：新值 = a × 旧值 + b, 其中a、b是常数.
  - 例：日历日期、摄氏或华氏温度.
  - 允许的操作：均值、标准差、皮尔逊相关、t和F检验.
- 比率属性 (Ratio)：
  - 差和比率都是有意义的。
  - 性质：相异性、序、加法、乘法.
  - 允许的变换：新值 = a × 旧值.
  - 例：绝对温度、货币量、计数、年龄、质量、长度、电流.
  - 允许的操作：几何平均、调和平均、百分比变差.
- 上述属性类型可以分为分类的(定性的)和数值的(定量的).
离散 vs. 连续属性
- 离散属性 (Discrete Attribute)：
  - 有限或无限可数个值。
  - 常表示为整数变量。
  - 例：邮政编码, 计数, 文档集的词。
  - 注意：二元属性是离散属性的特例。
- 连续属性 (Continuous Attribute)：
  - 属性值为实数。
  - 实践中，实数只能用有限位数字的数度量和表示。
  - 一般用浮点变量表示。
  - 例：温度, 高度, 重量。
数据集的重要特性
- 维度 (Dimensionality)：数据集中对象具有的属性数目。
  - 维灾难 (Curse of Dimensionality)。
  - 维归约 (Dimensionality Reduction)。
- 稀疏性 (Sparsity)：具有非对称特征的数据集，一个对象的大部分属性上的值都为0。只存储和处理非零值。
- 分辨率 (Resolution)：模式依赖于度量尺度 (scale)。不同尺度下观察到的模式不同。

2.2 数据集类型

记录数据 (Record Data)：
- 典型情况。
- 数据矩阵 (Data Matrix)：对象具有相同的固定数值属性集，视为多维空间中的点，可用m*n矩阵表示。
- 文档数据 (Document Data)：每个文档是一个向量，分量为术语在文档中出现的次数。
- 事务数据 (Transaction Data)：每条记录（事务）涉及一组项目。例：杂货店购物记录。
基于图 (Graph) 的数据：
- 带有对象之间联系的数据。例：HTML链接。
- 具有图对象的数据：对象有结构，包含有联系的子对象。例：分子结构。
有序 (Ordered) 数据：
- 常常涉及时间或空间序。
- 时序数据 (Sequential Data)，也称时间数据 (Temporal Data)：时间次序重要，具体时间不重要。例：事务序列。
- 序列数据 (Sequence Data)：个体项的序列。例：基因组序列数据（如DNA序列），重要的是在序列中的位置.
- 时间序列数据 (Time Series Data)：特殊的时序数据，每个记录是时间序列（一段时间的测量序列）。具有时间自相关（临近测量值相似）。
- 空间数据 (Spatial Data)：具有空间属性，如位置或区域。例：地理位置的气象数据。具有空间自相关性（物理上靠近的对象趋向于在其他方面也相似）。
- 空间-时间数据 (Spatial-Temporal Data)：结合空间和时间序。

2.3 数据质量

数据质量问题：离群点、遗漏值、不一致值、重复数据。
测量误差 (Measurement Error) 和数据收集错误 (Data Collection Error)：
- 测量误差：测量过程导致的问题。
- 数据收集错误：遗漏数据对象或属性值，或不正确包含对象等。
- 都可能是系统的或随机的。
噪声 (Noise)：测量误差的随机部分。可能扭曲值或附加谬误对象。
离群点 (Outliers)：在某种意义上不同于数据集中其他大部分数据对象的特征。也称为异常对象。
噪声与离群点区别：噪声是随机测量误差，离群点是观测量中与大部分观测量明显不同的值，它既可能由真实数据产生，也可能由噪声带来。
遗漏值 (Missing Values)：
- 原因：信息未收集全、属性不适用于所有样例。
- 处理策略：删除数据对象、估计遗漏值、分析时忽略遗漏值、用所有可能值替换（按概率加权）。
不一致值 (Inconsistent Values)：数据可能包含互相矛盾的值。纠正需要附加或冗余信息。时序数据中的不一致可能是使用了不同的测量手段。
重复数据 (Duplicate Data)：数据集可能包括互为冗余或几乎互为冗余的数据对象。是合并异构数据源时的主要问题。
数据清理 (Data Cleaning)：包括格式标准化、异常数据清除、错误纠正、重复数据清除。
应用问题 (Application Issues)：
- 时效性 (Timeliness)：数据的快照只代表有限时间内的真实情况，过时数据上的模型也可能过时。
- 相关性 (Relevance)：可用数据必须包含应用需要的信息，否则模型精度受限。

2.4 数据预处理

数据预处理方法：聚集、抽样、维归约、特征子集选择、特征构造、离散化与二元化、属性变换。
聚集 (Aggregation)：
- 定义：将两个或多个属性（或对象）组合成单个属性（或对象）。
- 目的：
  - 数据规约 (Data Reduction)：减少属性或对象数量。
  - 范围转换 (Change of Scale)：将细粒度数据聚集成粗粒度（如城市聚集成区域、州、国家）。
  - 数据更稳定 (More “Stable” Data)：聚集数据变异性更小。
- 举例：澳大利亚降水变化的标准差在按地区聚集后变小.
抽样 (Sampling)：
- 定义：选择数据对象子集的常用方法。
- 目的：用于数据初步调查和最终分析。在数据挖掘中使用抽样是因为处理整个数据集太昂贵或耗时。
- 有效抽样原则：
  - 代表性 (Representativeness)：如果样本具有代表性，使用样本几乎和使用整个数据集一样有效。
  - 保留原数据集的性质：如果样本与原始数据集大致具有相同的属性，则样本具有代表性。
- 抽样方法：
  - 简单抽样 (Simple Random Sampling)：选择任何特定项目的概率相等。
    - 简单无放回抽样 (Sampling without replacement)。
    - 简单有放回抽样 (Sampling with replacement)：同一对象可以被多次提取。
  - 分层抽样 (Stratified Sampling)：将数据分成几个分区，然后从每个分区抽取随机样本。可以按相同个数或按比例抽取。
- 样本大小：示例展示了不同样本大小对保留原数据集结构的影响（2000点保留大部分结构，500点丢失结构）。对于容量相等的组，需从每组至少找出一个代表点。
- 渐进抽样 (Progressive Sampling) 或自适应抽样 (Adaptive Sampling)：
  - 原因：有时难以预先确定样本集大小。
  - 方法：从小样本开始，逐渐增加样本容量直到足够大。需要评估样本是否足够大（例如，预测模型准确率随样本容量增加趋于稳定时停止）。
维归约 (Dimensionality Reduction)：
- 问题：数据集包含大量特征（如文档数据集数万词），导致维灾难。高维数据越来越稀疏，许多算法（分类、聚类）效果下降。
- 目的：避免维灾难；降低数据挖掘算法空间和时间损耗；易于数据可视化；减少不相关特征或噪音。
- 方法：
  - 线性代数技术：主成分分析 (PCA)、奇异值分解 (SVD)。
  - 主成分分析 (PCA)：目标是找到新的属性（主成分），是原有属性的线性组合，相互正交，能捕获数据最大变差。通过求协方差矩阵的特征向量定义新空间。关键在于选择“特征明显的、重要的信息”：同一维度内方差大（有个性，易分开），不同维度间关联度小（表征共同信息少，理想情况不相关，协方差为0，线性空间内正交）。
特征子集选择 (Feature Subset Selection)：
- 降低维度的另一种方法。
- 原因：特征并非越多越好。
- 需避免的特征：
  - 冗余特征 (Redundant features)：重复一个或多个其他属性中的大部分信息。例：产品购买价格和支付的销售税。
  - 不相关特征 (Irrelevant features)：对数据挖掘任务无用。例：学生ID对预测GPA通常不相关。
- 技术：
  - 穷举方法 (Exhaustive methods)：尝试所有可能的特征子集作为算法输入。
  - 嵌入方法 (Embedded methods)：特征选择作为数据挖掘算法的一部分（如决策树算法本身决定哪些特征有用）。
  - 过滤方法 (Filter methods)：在运行数据挖掘算法之前选择特征。
  - 包装方法 (Wrapper methods)：使用数据挖掘算法作为黑箱来寻找最佳属性子集。
特征创建 (Feature Creation)：
- 目标：创建出比原始特征更能体现对象本质的新特征。
- 三种一般方法：
  - 特征提取 (Feature Extraction)：领域相关（domain-specific）。映射数据到新空间（如傅里叶变换、小波变换）。更好的特征可以揭示数据重要性质。
  - 特征构造 (Feature Construction)：由一个或多个原始特征构造新特征。例：密度=质量/体积。原始特征形式不适合算法时，构造新特征可能更有用。
离散化与二元化 (Discretization and Binarization)：
- 目的：减少属性值个数（便于挖掘，结果更简洁、易理解使用）；产生概念分层结构；满足某些算法（需要离散或二元属性）的要求。
- 非监督 vs. 监督：差别在于是否使用类信息。
- 离散属性二元化：
  - 方法1：属性有m个值，每个值映射到[0, m-1]整数（保序），再将m个整数变换为二进制，用n=⌈log₂m⌉个二元属性表示。缺点：建立了属性值之间的联系，不适合非对称属性（1比0更重要）。
  - 方法2：对m个属性值建立m个二元变量，每个对应于一个原属性值。适合非对称属性。
- 连续属性离散化：
  - 基本思想：将排序后的连续属性值通过n-1个分割点分成n个区间。将一个区间中的值映射到相同分类值。问题是决定分割点数目和位置。分割点数目一般由用户确定。
  - 分割点位置确定方法：
    - 非监督方法：等宽离散化、等频离散化、K-均值离散化。
    - 监督方法：假定数据属于不同类。原则是极大化区间纯度（区间中数据都属于一个类最纯，等比例属于各类最不纯）。有多种度量纯度的方法。
    - 基于熵的离散化：熵是一种不纯度度量。基本思想是初始切分成两部分使得结果区间产生最小熵，重复分割直到满足条件（区间数或终止条件）。
- 具有过多值的离散属性：
  - 序数属性：用类似于连续属性的方法。
  - 标称属性：一般需要领域知识。例：系名（合并成工程学、社会科学等），城市（合并成省、国家）。
属性变换 (Attribute Transformation)：
- 定义：将给定属性的整个值集映射到一组新的替换值的函数。
- 简单变换：xk, log(x), ex, |x|, 1/x 等简单函数。注意：可能改变数据特性。
- 标准化 (Standardization) / 规范化 (Normalization)：在数据挖掘中不区分，统计学有不同含义。目标是使值集具有特定性质（如均值0、标准差1）。可使用均值/中位数，标准差/绝对标准差。公式例：x’ = (x - 均值) / 标准差。

2.5 相似性和相异性的度量 (Similarity and Dissimilarity Measures)

相似性 (Similarity)：两个数据对象相似程度的数值度量。对象越相似，值越高。通常在范围内。
相异性 (Dissimilarity)：两个数据对象之间差异的数值度量。对象越相似，值越低。最小不相似度通常为0。
邻近性 (Proximity)：指相似或不同之处。
数据对象的相异度：
- 欧氏距离 (Euclidean Distance)：衡量n维空间中两点间的直线距离。公式：d(x, y) = √Σ(xk - yk)²。
- 闵可夫斯基距离 (Minkowski Distance)
  
  ：欧氏距离的推广。公式：d(x, y) = (Σ|xk - yk|^r)^(1/r)。
  - r = 1：城市街区距离 (Manhattan, taxicab, L1范数)。汉明距离是二元向量城市街区距离的常见例子。
  - r = 2：欧几里得距离。
  - r → ∞：上确界距离 (Lmax norm, L∞ norm)，是向量任意分量间最大差值。
距离的性质：
- 1. 非负性：d(x, y) ≥ 0，仅当x = y时d(x, y) = 0。
- 1. 对称性：d(x, y) = d(y, x)。
- 1. 三角不等式：d(x, z) ≤ d(x, y) + d(y, z)。
- 满足这三个性质的测度称为度量 (metric)。
非度量的相异度 (Non-metric Dissimilarity)：有些相异度不满足一个或多个度量性质。例：集合差 (size(A-B))，时间计算方式。
数据对象之间的相似度：
- 通常s(x, y) ∈。s(x, y)=1 (或最大相似度) 仅当x = y。s(x, y) = s(y, x) (对称性)。
- 三角不等式（或类似性质）通常不成立。
- 有时可将相似度变换成一种度量距离（如余弦相似性、Jaccard相似性）。
衡量相似度的方法：
- 简单匹配系数 (Simple Matching Coefficient, SMC)：用于二元属性。衡量两个对象之间匹配的属性个数占总属性个数的比例。公式：SMC = (f₁₁+f₀₀) / (f₀₁+f₁₀+f₁₁+f₀₀)。例：对于x=(1,0,…,0), y=(0,0,…,1) (10维)，SMC=0.7。
- Jaccard系数 (Jaccard Coefficient)：用于二元属性。衡量匹配个数（1-1匹配）占不涉及0-0匹配的属性个数的比例。更适合非对称二元属性（关注1-1匹配）。公式：J = f₁₁ / (f₀₁+f₁₀+f₁₁)。例：对于x=(1,0,…,0), y=(0,0,…,1) (10维)，J=0.0。
- 余弦相似度 (Cosine Similarity)：设x和y是两个向量。公式：cos(x, y) = (x · y) / (||x|| ||y||)。几何解释为向量夹角的余弦。例：对于x=(3,2,0,5,0,0,0,2,0,0), y=(1,0,0,0,0,0,0,1,0,2)，cos(x, y) ≈ 0.31.
- 广义Jaccard系数 (Generalized Jaccard Coefficient) 或 Tanimoto系数：用于向量。公式：EJ(x, y) = (x · y) / (||x||² + ||y||² - x · y)。
- 相关性 (Correlation)
  
  ：对象属性之间线性联系的度量。
  - 皮尔森相关系数 (Pearson’s Correlation)。公式涉及协方差和标准差。范围[-1, 1]。corr(x, y)=0 表示不相关；corr(x, y)=1 (-1) 表示正(负)相关。散点图可可视化相关度。
邻近度计算问题 (Proximity Calculation Issues)：
- 标准化：当属性值域不同时，距离可能被值域大的属性左右。处理方法是变换到相同值域。
- 相关性：当属性之间相关时，使用马氏距离 (Mahalanobis distance)。公式：mahalanobis(x, y) = (x - y)Σ⁻¹(x - y)ᵀ，其中Σ⁻¹是数据协方差矩阵的逆。协方差矩阵Σ的第ij个元素是第i和第j个属性的协方差。例：对于相关属性，马氏距离更能反映实际差异。
- 组合异种属性：当属性类型不同但需要计算总相似度时。算法2.1提供了一种方法：对每个属性计算的相似度sk(x,y)，定义指示变量δk（非对称属性且都为0或有遗漏值时δk=0，否则为1），使用加权公式计算总相似度：similarity(x, y) = (Σ δk sk(x, y)) / (Σ δk)。
- 加权：如果不希望所有属性同等对待，可以使用权重wk（0~1之间，累加和为1）计算加权的相似度或加权的闵可夫斯基距离。

第五章总体设计

Sun, 01 Jun 2025 00:00:00 GMT

1. 总体设计与详细设计

关系：总体设计与详细设计是全局和局部的关系。不是抽象与具体，也不是整体与部分。
衔接工具：软件结构图是总体设计与详细设计之间的衔接工具。
分工：总体设计（结构设计）主要确定系统由哪些模块组成以及它们之间的关系。详细设计（过程设计）主要确定每个模块的处理过程。

2. 总体设计的必要性

必要性在于可以在一个全局的高度、以较低的成本，从较抽象的层次 分析、对比各种系统实现方案和软件结构。
从中选取最优解（最佳方案和最合理的软件结构），从而以较低的成本开发出较高质量的软件系统。

3. 总体设计过程

大体分为两个阶段：
- 系统设计阶段：主要用来确定实现方案。
- 结构设计阶段：主要用来确定软件结构。
详细过程（九个步骤）：
1. 设想供选择的方案：常用方法是以需求分析阶段得到的数据流图作为出发点。设想将数据流图中的处理进行分组的各种可能。
2. 选取合理方案：一般选取低成本、中成本、高成本至少三种方案。每种方案需配备资料，包括系统流程图、物理部件清单、成本效益分析、实现系统进度计划。
3. 推荐最佳方案：分析对比各种可能方案的利弊，选取最佳方案，制定详细实现计划。
  - （步骤 1-3 属于系统设计阶段）。
4. 功能分解：确定系统由哪些模块组成及模块间的关系（结构设计）。
5. 设计软件结构：通常一个模块完成一个适当的子功能。将模块组织成良好的层次系统。层次结构是常见的考点，上层调用下层。顶层模块功能最抽象（发送调用命令），下层功能具体。可用层次图或结构图描绘。
6. 设计数据库：本章不详细赘述，后续章节更新。
7. 制定测试计划：本章不详细讨论，将在第七章展开。结合测试目的设计测试方案。注意：测试计划很早就在总体设计阶段实现。
8. 书写文档：记录总体设计结果。文档包括：系统说明（含系统流程图、系统构成方案）、用户手册（根据总体设计结果修改需求阶段得到的初步手册）、测试计划、详细实现计划、数据库设计结果。
9. 审查和复审：进行详细的技术审查和管理复审。

4. 设计原理

设计原理是软件设计过程应遵循的基本原理和概念。考试高频考点。
1. 模块化：
  - 模块：程序的基本构件。由边界元素限定、有总体标识符代表的相邻元素序列。
  - 模块化：将程序划分为独立命名、独立访问的模块。每个模块完成一个子功能。
  - 优点：
    - 使软件结构清晰，易于设计、阅读和理解。
    - 使软件易于测试和调试（错误局限在模块及接口），有助于提高可靠性。
    - 提高软件的可修改性（变动通常只涉及少数模块），避免修改引入错误影响过多程序。
    - 有助于软件开发的组织管理（分工合作）。
2. 抽象：将相似方面集中概括起来，暂时忽略差异。抽象出事物的本质特征，暂时不考虑细节。
3. 逐步求精：尽量推迟对问题细节的考虑，集中精力解决主要问题。有助于工程师集中精力于当前开发阶段最相关的方面。
4. 信息隐藏与局部化：与封装（第九章后）非常相像。
  - 信息隐藏：模块内包含的信息（过程和数据）对于不需要这些信息的模块不能访问。
  - 局部化：将关系密切的软件元素物理地彼此靠近。局部化有利于信息隐藏。
  - 优点：绝大多数部分被隐藏，修改期间引入的错误很少能传播到软件其他部分。
5. 模块独立性：
  - 概念：模块化、抽象、信息隐藏、局部化概念的直接结果和集大成者。开发具有独立功能、与其他模块之间没有过多相互作用的模块。
  - 重要性：
    - 有效的模块化更容易开发（分割功能、接口简化）。多人合作开发时尤其重要（与模块化优点相似）。
    - 模块比较容易测试和维护（所需工作量小，错误传播范围小）（与抽象、信息隐藏优点相似）。
  - 衡量尺度：内聚和耦合。模块独立是好设计的关键，设计决定软件质量。

5. 衡量模块独立性的尺度：耦合与内聚

二者相反。低耦合对应高内聚，高耦合对应低内聚。
耦合 (Coupling)：标志着一个软件结构内

不同模块之间相互关联的程度。
- 越弱越好（松散耦合系统更好）。
- 弱耦合优点：易于研究、测试、维护任一模块，不需了解其他部分。联系简单，错误传播可能性小。强烈影响系统的可理解性、可测试性、可靠性和可维护性。
- 类型（由低到高）：
  1. 数据耦合 (Data Coupling)：通过参数交换信息（最好）。
  2. 控制耦合 (Control Coupling)：传递信息包含控制信息（如开关量）。
  3. 特征耦合 (Stamp Coupling)：将整个数据结构作为参数传递，调用模块只需要一部分（给多了）。
  4. 公共环境耦合 (Common Coupling)：通过公共环境相互作用（如全局变量、共享通信区等）。
  5. 内容耦合 (Content Coupling)：最高程度的耦合（最差）。如：模块访问另一模块内部数据、不通过正常入口转入内部、有部分程序代码重叠、模块有多个入口。
- 设计原则：尽量使用数据耦合，少用控制/特征耦合，限制公共耦合范围，完全不用内容耦合。
内聚 (Cohesion)：标志着一个模块内

各个元素彼此结合的紧密程度。
- 越高越好（高内聚、强内聚、紧内聚更好）。
- 类型（由低到高）：
  1. 偶然内聚 (Coincidental Cohesion)：模块完成一组任务，彼此关系松散（如为节省空间把重复语句放一起）。最低。
  2. 逻辑内聚 (Logical Cohesion)：任务在逻辑上属于相同或相似一类（如产生各种类型的全部输出）。
  3. 时间内聚 (Temporal Cohesion)：任务必须在同一时间段内执行（如初始化工作）。
  4. 过程内聚 (Procedural Cohesion)：处理元素相关，必须以特定次序执行。
  5. 通信内聚 (Communicational Cohesion)：所有元素使用同一个输入数据，产生同一个输出数据。
  6. 顺序内聚 (Sequential Cohesion)：处理元素与同一功能密切相关，必须顺序执行（前一元素输出是后一元素输入）。高内聚。
  7. 功能内聚 (Functional Cohesion)：所有元素同属于一个整体，完成单一的功能。最高程度的内聚（最好）。

6. 启发规则（设计经验）

软件设计中应注意和遵循的经验。
1. 提高模块的独立性（低耦合、高内聚）。
2. 模块的规模应适中。过大分解不充分，独立性低；过小开销大于操作，接口复杂。
3. 深度、宽度、扇入、扇出
  
  都应适当。
  - 深度 (Depth)：软件结构中控制的层数。粗略标志系统大小复杂程度。
  - 宽度 (Width)：同一层次上模块总数的最大值。
  - 扇出 (Fan-out)：一个模块直接调用的模块数。
  - 扇入 (Fan-in)：有多少个上级模块直接调用它。
4. 模块的作用域 (Scope of Effect)和控制域 (Scope of Control)。
  - 作用域：受模块内一个判定影响的所有集合。
- 控制域：模块本身及所有直接或间接从属于它的模块。

力争降低模块的接口复杂度。
设计单入口、单出口的模块。易于理解和维护。
模块的功能应该可以预测，防止过分局限。

7. 描绘软件结构的图形工具

1. 层次图 (Hierarchy Diagram)：描绘软件的层次结构。矩形框代表模块，联系表示调用关系（与层次方框图、JASON图表示的组成关系不同）。适用于自顶向下设计。
- 1. HIPO图 (Hierarchy plus Input-Process-Output)：层次图 + 输入处理输出图 (IPO)。IPO图用于描述算法。特点是可追踪性（非顶层方框有编号）。
- 1. 结构图 (Structure Chart)：与层次图类似，都用于描绘软件结构。框之间表示调用关系。

8. 面向数据流的设计方法

通常也称为结构化设计方法。
基于数据流来设计软件结构。
数据流的类型决定映射方法。
两种数据流类型：
1. 变换流 (Transform Flow)：信息沿输入通路进入（外部转内部），经变换中心处理，沿输出通路离开（内部转外部）。
2. 事物流 (Transaction Flow)：数据流到达事务中心（处理器），事务中心根据类型选取若干动作序列之一执行。

第六章详细设计

Sun, 01 Jun 2025 00:00:00 GMT

1. 详细设计的基本概念

任务：详细设计的任务不是具体的编写代码。而是要设计出程序的蓝图。程序员将根据这个蓝图写出实际的代码。
- 考试判断题高频考点：详细设计是编码的依据。
与总体设计关系：总体设计（结构设计）确定系统由哪些模块组成及关系；详细设计（过程设计）确定每个模块的处理过程。总体设计与详细设计是全局和局部的关系。

2. 结构程序设计

经典定义：如果一个程序的代码块仅仅通过顺序、选择和重复三种基本控制结构进行链接，并且每个代码块只有一个入口和一个出口，则称程序是结构化的。
基本控制结构：
- 顺序 (A执行后执行B)
- 选择/分支 (根据条件执行A或B)
- 重复/循环 (根据条件重复执行A)
考试重点：记住这三种基本结构。

3. 人机界面设计 (Human-Computer Interface Design)

重要性：是接口设计的重要组成部分。对于交互式系统，人机界面设计、数据设计和体系结构设计与过程设计同等重要。用户能够直观感受到的就是界面。
包含的四个方面:
1. 系统响应时间：从用户完成某个控制动作到系统给出响应的时间。
  - 属性：长度（过长/过短都有弊端）、易变性（相对于平均响应时间的偏差，可能更重要）。
2. 用户帮助设施：提供联机帮助使用户无需离开用户界面解决问题。
  - 类型：集成的（一开始设计，对用户工作敏感）、附加的（系统建成后添加，能力有限，对用户操作不敏感）。
3. 出错信息处理：交互系统给出的一些坏消息。
  - 设计和编写时的注意事项 (属性):
    - 用用户可以理解的术语描述问题 (直白)。
    - 提供从错误中恢复的建设性意见 (帮助)。
    - 指出错误可能导致的负面后果 (提示检查/解决)。
    - 伴随听觉或视觉上的提示。
    - 不能带有指责色彩 (中性陈述)。
4. 命令交互：用户和系统软件进行交互的方式 (如 CTRL+A/C/V)。
  - 理想情况：所有应用软件使用一致的命令方式。
设计过程：是一个迭代的过程。用户评估和试用 -> 根据修改意见生成新版本 -> 循环直到用户满意。
评估标准 (早期复审):
- 规格说明书的长度/复杂程度 (预示用户学习工作量)。
- 命令/动作数量、参数个数、单个操作个数 (预示交互时间/效率)。
- 设计模型包含的动作/命令、系统状态数量 (预示用户需要记忆的内容)。
- 界面风格、帮助设施、出错处理协议 (预示界面复杂程度/用户接受程度)。
设计指南:
- 一般交互指南 (全局性):
  - 保持一致性 (菜单、命令、显示等风格一致)。
  - 提供有意义的反馈 (视觉/听觉双向通信)。
  - 执行有较大破坏动作前要求用户确认。
  - 允许取消绝大多数操作。
  - 减少两次操作之间必须记忆的信息量 (如短验证码).
  - 提高对话/思考效率 (减少按键/鼠标移动)。
  - 允许犯错 (系统有容错能力，不是非常脆弱)。
  - 按功能对动作进行分类。
  - 提供对用户工作内容敏感的帮助设施。
  - 使用简单的动词或动词短语作为命令名。
- 信息显示指南:
  - 只显示与当前工作内容相关的。
  - 不要用数据研磨用户 (用图形、表格、图表等易于吸收的方式表示)。
  - 使用一致的标记、标准缩写和可预知的颜色.
  - 允许用户保持可视化语境 (如图片放缩后仍能看到原始大小).
  - 产生有意义的出错信息.
  - 使用大小写、缩进、文本分组方式帮助理解。
  - 使用窗口分割不同类型的信息。
  - 模拟显示方式使信息易提取 (如电池颜色表示电量)。
  - 高效率使用显示屏。
- 数据输入指南:
  - 尽量减少用户的输入动作 (减少点击次数，用划标尺等)。
  - 保持信息显示与数据输入的一致性。
  - 允许用户自定义输入。
  - 交互方式应灵活并可调节 (鼠标、键盘、语音等)。
  - 在当前动作中不适用的命令不起作用。
  - 让用户控制交流流。
  - 对所有的输入动作都提供帮助。
  - 消除冗余输入 (设置默认值)。

4. 过程设计工具

第六章考试考察最多的位置。重点掌握文字上的考点 (优缺点，特点)。
程序流程图 (Program Flowchart):
- 优点：很直观，便于初学者掌握。
- 缺点 (高频考点)：
  - 本质上不是逐步求精工具，诱使程序员过早考虑控制流程。
  - 用箭头代表控制流，程序员不受约束，可以随意转移控制 (违背结构程序设计精神)。
  - 不易表示数据结构。
盒图 (N-S Chart / NS图):
- 特点：
  - 功能块明确，一眼看出。
  - 不可能任意转移控制。
  - 容易确定局部和全局数据的作用域。
  - 容易表示嵌套关系，也可表示模块的层次结构。
PAD图 (Problem Analysis Diagram):
- 优点：
  - 使用结构化程序设计符号，设计的程序必然是结构化的。
  - 描绘的程序结构非常清晰。
  - 表示程序逻辑易读易懂易记。
  - 容易转化为高级语言。
  - 用于表示程序逻辑，也可表示数据结构。
  - 支持自顶向下逐步求精。
判定表和判定树 (Decision Table & Decision Tree):
- 共同点：都能表示复杂的条件组合与应做动作之间的对应关系。
- 判定表优点：可以简洁又无歧义地描述处理规则。
- 判定表缺点：很难作为通用设计工具，难以同时表示顺序和重复等处理特性。
- 判定树优点：简单到不需要解释。
- 判定树缺点：简洁性不如判定表，同一元素同一值在树的叶端可能重复次数多。
过程设计语言 (PDL / 伪码):
- 用正文形式处理数据和处理过程的设计工具。常用在研究生论文中描述算法改进。
- 特点：关键字固定语法、自然语言自由语法、数据说明手段。
- 优点：
  - 可作为注释直接插入到程序中。
  - 可以使用普通文本编辑器或文字处理系统编写 (方便)。
  - 已有自动处理PDL的程序，可转换为程序代码。
- 缺点：
  - 与图形工具相比欠缺直观性。
  - 描述复杂条件组合不如判定表和判定树简洁。

5. 面向数据结构的设计方法

通常也称作结构化设计方法，基于数据流设计软件结构。
JASON图 (JSON图):
- 描绘的是数据元素彼此之间的逻辑关系 (第三章层次方框图和JASON图表示组成关系，与层次图/结构图表示调用关系不同)。
- 表示的三种逻辑关系：顺序、选择、重复。
- 优点：便于表示层次结构，形象直观，可读性好。既能表示数据结构，也能表示程序结构。
- 缺点：表示选择或重复结构时，选择条件或循环条件不能直接在图上表示，影响表达能力且不易转换为程序。框间连线为斜线，不宜在行式打印机上输出。
JASON方法 (五步骤):
1. 分析并确定输入/输出数据的逻辑关系，用JSON图描绘。
2. 找出输入数据和输出数据之间的对应数据单元。
3. 运用参数规则从描绘数据结构的JSON图导出描绘程序结构的JSON图。
4. 列出所有条件，分配到程序结构图适当位置。
5. 用伪码表示。

6. 程序复杂程度的定量度量

价值/目的:
- 估算软件中错误的数量以及软件开发所需的工作量。
- 用来比较两个设计或不同算法的优劣。
- 作为模块规模的精确限度。
McCabe方法 (麦克笔方法):
- 流图 (Flow Graph)：退化的程序流程图，仅仅描绘程序的控制流程。不表现数据的具体操作以及分支/循环的具体条件。
- 环形复杂度 (Cyclomatic Complexity) - V(G):
  - 标志程序逻辑复杂度的定量尺度。
  - 计算方法 (三种):
    - V(G) = P + 1：P为判定节点的数目 (节点有 >1 个分支/路径)。
    - V(G) = 封闭区域 + 1 (自创方法)。
    - V(G) = E - N + 2
  - 示例：图B，判定节点为1, 3, 6 (都有两个分支)，P=3。V(G) = 3 + 1 = 4。图中的封闭区域有3个 (绿色457A6，红色2457A7B3，1237B)，V(G) = 3 + 1 = 4。两种方法结果一致。
  image-20250602000805460

第三章需求分析

Wed, 21 May 2025 00:00:00 GMT

为了开发出真正满足用户需求的软件产品，首先必须知道用户的需求。对软件需求的深人理解是软件开发工作获得成功的前提条件。

image-20250521095947355

任务#

确定对系统的综合要求#

功能需求系统必须提供的服务
性能需求系统必须满足的定时/容量约束，速度、主存/磁盘容量、安全性等
可靠性和可用性需求可靠性：给定时间段内，系统成功运行的概率。可用性：给定时间点内，系统成功运行的概率。量化了用户可以使用系统的程度
出错处理需求
接口需求描述应用系统与它的环境通信的格式
约束设计约束和实际约束在过程中应遵循的限制条件精度、工具或语言约束
逆向需求说明系统不应该做什么确定系统的边界
将来可能提出的需求维护

分析系统的数据要求#

构建数据库/数据要求

导出系统的逻辑模型#

修正系统开发计划#

与用户沟通获取需求的方法#

访谈#

正式事先准备问题
非正式开放性问题
发放调查表，书面回答比起口头表达更加准确
情景分析技术给出具体情景

面向数据流自顶向下求精#

结构化分析方法（SA）#

面向数据流自顶向下逐步求精进行需求分析的方法

通过功能分解完成数据流图的细化

简易的规格说明技术#

前两种用户比较被动

快速建立软件原型#

快速
容易修改

分析建模与规格说明#

分析建模#

数据模型 ER
功能模型 DFD
行为模型状态图

软件需求规格说明#

软件需求规格说明书，需求阶段得出的最主要的文档

image-20250525235355695

验证软件需求#

一致性复查软件规格说明书
完整性
现实性
有效性

网络安全

Wed, 21 May 2025 00:00:00 GMT

网络安全#

安全威胁#

被动攻击#

攻击者通过窃听手段仅观察和分析网络中传输数据流中的敏感信息，而不对其进行干扰。

主动攻击#

攻击者对网络中传输着的数据流进行各种处理。

image-20250521134907333

安全服务#

image-20250521135500333

密码学#

如果不论攻击者截获了多少密文，在密文中都没有足够的信息来唯一地确定出对应的明文，则这一密码体制称为无条件安全的，或称为理论上是不可破的。

然而，在无任何条件限制下，目前几乎所有实用的密码体制均是可破的。因此，人们关心的是在计算（而不是理论上）是不可破的密码体制。如果一个密码体制中的密码不能在一定时间内被可以使用的计算资源破解，则这一密码体制称为在计算上是安全的。

对称密钥#

对称密钥密码体制是指加密密钥与解密密钥相同的密码体制。

image-20250521140655551

image-20250521140819375

高级加密标准（Advanced Encryption Standard，AES）支持128比特、192比特和256比特的密钥长度，用硬件和软件都可以快速实现。

公钥密码#

image-20250521141335812

报文摘要和报文鉴别码#

image-20250521144025176

image-20250521144109995

最有名的报文摘要算法（或称密码散列函数或散列算法）有MD5（Message Digest，MD-5）和安全散列算法1（Secure Hash Algorithm，SHA-1）。

image-20250521144633518

image-20250521144830098

数字签名#

在计算机网络中传送的报文可以使用数字签名（Digital Signature）来证明其真实来源。

image-20250521145006647

image-20250521150809231

实体鉴别#

实体鉴别就是通信双方的一方验证另一方身份的技术，常简称为鉴别。

image-20250521152336424

image-20250521152433474

image-20250521153235759

image-20250521153648445

image-20250521153813028

image-20250521153943800

访问控制（没讲）#

image-20250521154143798

image-20250521154306797

安全机制#

物理层安全实例：信道加密#

使用的是物理机器：信道加密机，加密和解密用硬件来实现，因此加密和解密速度快，并且无须传送额外的数据，采用该技术不会减少网络的有效带宽。

image-20250530145951069

数据链路层#

image-20250530150559892

image-20250530150935148

网络层#

image-20250530151815254

image-20250530151840410

image-20250530151911341

image-20250530152137491

image-20250530153050007

image-20250530153245736

image-20250530153303366

image-20250530153448513

image-20250530153746597

第二章可行性研究

Sun, 18 May 2025 00:00:00 GMT

概述#

可行性研究的目的，就是用最小的代价在尽可能短的时间内确定问题是否能够解决

技术可行性
经济可行性
操作可行性

法律、社会效益等

可行性研究最根本的任务是对以后的行动方针提出建议。如果问题没有可行的解，分析员应该建议停止这项开发工程，以避免时间、资源、人力和金钱的浪费：如果问题值得解，分析员应该推荐一个较好的解决方案，并且为工程制定一个初步的计划

过程#

复查系统规模和目标
研究目前正在使用的系统->系统流程图
导出新系统的高层逻辑模型->数据流图DFD+数据字典
进一步定义问题

image-20250518105427889

导出和评价供选择的解法
推荐行动方针
草拟开发计划粗糙
书写文档提交审查可行性研究报告

系统流程图#

描述当前运行的系统

image-20250518105748043

数据流图#

数据加工处理的过程

绘图方法：自顶向下、分层绘制、逐步求精

image-20250518105918715

用途#

交流信息的工具
分析和设计的工具

数据字典#

image-20250518110428145

相伴数据流图而生，解释数据流图的数据

image-20250518110512720

用途#

分析阶段的工具
数据字典包含的每个数据元素的控制信息是很有价值的
数据字典是开发数据库的第一步

image-20250518110820092

成本估计#

软件开发成本主要表现wei

第一章软件工程概述

Tue, 13 May 2025 00:00:00 GMT

软件工程的出现是因为存在软件危机。

软件危机是指在计算机软件的开发和维护过程中所遇到的一系列严重问题。

具体表现#

对软件开发成本和速度的估计常常不准确。特别是人工工时，造成成本更高
用户对软件不满意。需求分析不到位
软件产品质量靠不住
软件不可维护。文档、软件结构
软件没有适当文档资料
软件成本在计算机系统总成本中所占的比例逐年上升。人力消耗，工资涨
软件开发生产率提高的速度，跟不上计算机应用迅速普及及深入的趋势。

产生软件危机的原因#

软件本身的特点
- 软件是逻辑部件，缺乏可见性
- 错误隐藏深，测试阶段没有检测出来
- 软件规模庞大，复杂度较高
  - 技术上
  - 管理上，人员多
软件的开发与维护的方法不正确
- 软件专业人员错误认识软件开发，忽视软件需求分析，轻视软件维护
- 只重视程序而忽视软件配置其余成分。软件由程序、文档、数据组成。
消除软件危机的途径#
1. 对计算机软件有一个正确的认识。软件由程序、相关文档、数据组成。
  
  image-20250513221922796
2. 认识到软件开发是一种组织良好、管理严密、各类人员协同配合、共同完成的工程项目
3. 推广成功的技术和方法
4. 开发和使用更好的软件工具
两个方面，技术和管理

软件工程的定义#
image-20250514163335130

本质#

关注大型程序的构造
中心课题：控制复杂性。管理方面
软件经常变化。模拟现实，落后现实
软件开发效率非常重要
和谐的开发是关键
必须有效支持它的用户
在软件工程领域中通常由具有一种文化背景的人替具有另一种文化背景的人创造产品

基本原理#

分阶段的生命周期计划严格管理
进行阶段评审
严格的产品控制
采用现代程序设计技术
结果应该被清楚的审查
开发小组成员少而精
承认不断改进软件工程实践的必要性

软件工程方法学#

三个要素：方法、工具、过程

传统方法学#

以算法为核心，功能分解

也叫做生命周期方法学，采用结构化技术来完成软件开发的各项任务。结构化技术包括结构化分析（SA）、结构化设计（SD）和结构化实现（SP）

优点#

把软件生命周期划分为若干个阶段，每个阶段的任务相对独立且较简单，便于管理以及分工协作
采用科学的管理技术或良好的技术方法，每个阶段严格审查，提高软件开发的成功率

面向对象方法学#

以对象为核心，对象分解

以数据为主线，把数据和对数据的操作紧密地结合起来的方法

软件生命周期#

从提出开发要求到软件报废的整个时期

软件定义
- 问题定义
  - 关键是要解决的问题是什么
- 可行性研究
  - 关键是对于问题定义所确定的问题有行得通的解决办法吗
- 需求分析
  - 确定目标系统必须具备的功能
软件开发
- 总体设计
  - 概要设计
  - 确定方案、结构
- 详细设计
  - 确定算法和数据结构
- 编码和单元测试
  - 编写易懂、易维护的程序代码
  - 测试编写出的每一个模块
- 综合测试
  - 通过各种类型的测试使软件达到预定的要求
运行维护
- 交付之后到软件报废的阶段

软件过程#

为了获得高质量软件所需要完成的一系列任务的框架，它规定了完成各项任务的工作步骤

瀑布模型#

广泛使用，用于需求明确、完整、无重大变化的软件系统开发，例如操作系统、数据库管理系统、编译系统

特点#

阶段间具有顺序性、依赖性
尽可能推迟物理实现
质量保证
- 写文档
- 文档写得对

优点：

强迫开发人员采用规范的方法开发
严格规定了每个阶段必须要提交的文档
规定所有提交的产品都必须通过质量验证

缺点：

过于理想化，不可能不犯错
文档驱动的模型，写在纸上的动态说明很难全面正确认识动态的软件产品，可能导致开发的产品不能让用户满意
灵活性差

快速原型模型#

适用于用户需求不明确，小型或交互型系统开发、大型复杂系统的模型部分、设计一些复杂算法的场合。

快速建立一个能反映用户主要需求的原型系统，让用户试用它，然后记录反馈，快速修改原型系统，迭代多次版本

优点#

软件开发基本上是线性顺序进行的
加速开发过程，节约软件开发成本
获知用户的真正需求
克服瀑布模型的缺点，减少由于需求不明确带来的开发风险
吸引用户，快速占领市场
灵活性强

缺点#

选用的开发工具不一定符合主流的发展，小众冷门
快速建立的系统结构和连续的修改下可能导致产品质量低下

增量模型#

适用于技术风险较大、用户需求较为稳定的软件系统开发

渐增模型，是瀑布模型的变种

整体设计软件，实践中分阶段做

优点#

较短时间内向用户提交可完成部分工作的产品
用户有较充裕的时间学习和适应新产品，减少一个全新软件可能给客户组织带来的冲击
模型的灵活性可以使其适应需求的变化

缺点#

很容易退化为边做边改模型

螺旋模型#

适用于大型复杂的软件系统开发

瀑布模型+快速原型模型+风险分析

优点#

对可选方案和约束条件的强调有利于已有软件的重用，也有助于把软件质量作为软件开发的一个重要目标
减少了过多测试（浪费资金）或测试不足（产品故障多)所带来的风险
在螺旋模型中维护只是模型的另一个周期，在维护和开发之间并没有本质区别。

缺点#

风险驱动，依赖人的水平
不能让用户确信这种演化方法是可信的
建设周期长，成本上升

喷泉模型#

适用于面向对象的软件开发过程

在开发的早期阶段定义了一系列面向问题的对象，并且在整个开发过程中不断充实和扩充这些对象

优点#

可以提高软件项目开发效率，节省开发时间

缺点#

不利于项目管理

记忆#

瀑布模型

“瀑布需求少，熟悉环境好；低风险易控，用户参与少。”
快速原型模型

“快速原型适应变，原型工具快；成本高领域熟，用户参与多。”
螺旋模型

“螺旋大规模，风险控制严；设计灵活准，知识经验全。”
阶段化模型

“阶段化大项目，结构开放灵；风险难集成，整体性易失。”
喷泉模型

“喷泉面向对象，用户需求动；阶段无界限，迭代省时间；（过多迭代）成本增提交延。”

image-20250603212017498

最长公共子序列

Mon, 28 Apr 2025 00:00:00 GMT

题目#

image-20250428134905645

分析#

f[i][j]f[i][j]f[i][j]表示AAA以iii结尾，BBB以jjj结尾的公共子序列的集合
如果a[i]==b[j]a[i]==b[j]a[i]==b[j]，那么f[i][j]=f[i−1][j−1]+1f[i][j] = f[i-1][j-1] + 1f[i][j]=f[i−1][j−1]+1
如果a[i]!=b[j]a[i] ! = b[j]a[i]!=b[j]，那么有两种情况：
- a[i]a[i]a[i]在最长公共子序列中，b[j]b[j]b[j]不在 →f[i][j−1]\rightarrow f[i][j-1]→f[i][j−1]
- b[j]b[j]b[j]在最长公共子序列中，a[i]a[i]a[i]不在 →f[i−1][j]\rightarrow f[i-1][j]→f[i−1][j]
- a[i]a[i]a[i]和b[j]b[j]b[j]都不在→f[i−1][j−1]\rightarrow f[i-1][j-1]→f[i−1][j−1]
但是f[i][j−1]f[i][j-1]f[i][j−1]表示b[j]b[j]b[j]一定不在，a[i]a[i]a[i]可以在，可以不在，所以f[i][j]f[i][j]f[i][j]包含两个数都不在的情况。同理f[i−1][j]f[i-1][j]f[i−1][j]也是，所以我们只需要求这三个表达式的最大值即可。

代码#

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 1010;
6

7
int n, m;
8
char a[N], b[N];
9
int f[N][N];
10

11
int main()
12
{
13
    cin >> n >> m;
14
    scanf("%s%s", a + 1, b + 1);
15

16
    for (int i = 1; i <= n; i ++ )
17
        for (int j = 1; j <= m; j ++ )
18
        {
19
            f[i][j] = max(f[i][j - 1], f[i - 1][j]);
20
            if (a[i] == b[j]) f[i][j] = max(f[i - 1][j - 1] + 1, f[i][j]);
21
        }
22

23
    cout << f[n][m] << endl;
24
    return 0;
25
}

显示更多显示更少

石子合并

Sun, 27 Apr 2025 00:00:00 GMT

题目描述#

image-20250427205036779

输入格式

第一行一个数 NNN 表示石子的堆数 NNN。

第二行 NNN 个数，表示每堆石子的质量(均不超过1000)。

输出格式

输出一个整数，表示最小代价。

数据范围

1≤NNN≤300

输入样例：

输出样例：

1
22

分析#

8a64f74c321debf7f9807b3e412d601

合并的代价其实就是[i,j][i, j][i,j]的价值的总和，所以可以使用前缀和

区间DP一般都是两层循环，外层len，内层起点

代码#

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 310;
6

7
int n;
8
int s[N], f[N][N];
9

10
int main()
11
{
12
    cin >> n;
13
    for (int i = 1; i <= n; i ++ ) cin >> s[i], s[i] += s[i - 1];
14

15
    for (int len = 2; len <= n; len ++ )
16
        for (int i = 1; i + len - 1<= n; i ++ )
17
        {
18
            int j = i + len - 1;
19
            f[i][j] = 1e8;
20
            for (int k = i; k < j; k ++ )
21
                f[i][j] = min(f[i][j], f[i][k] + f[k + 1][j] + s[j] - s[i - 1]);
22
        }
23

24
    cout << f[1][n] << endl;
25

26
    return 0;
27
}

显示更多显示更少

背包问题

Sun, 27 Apr 2025 00:00:00 GMT

01背包#

题目描述#

image-20250427221733213

输入样例

输出样例：

1
8

分析#

d6ff6b08f112cec54b1101aecc6d5c7

第一版#

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 1010;
6

7
int n, m;
8
int v[N], w[N];
9

10
int f[N][N];
11

12
int main()
13
{
14
    cin >> n >> m;
15

16
    for (int i = 1; i <= n; i ++ )   cin >> v[i] >> w[i];
17

18
    for (int i = 1; i <= n; i ++ )
19
        for (int j = 1; j <= m; j ++ )
20
        {
21
            f[i][j] = f[i - 1][j];
22
            if (j >= v[i])
23
              f[i][j] = max(f[i][j], f[i-1][j - v[i]] + w[i]);
24
        }
25

26
    cout << f[n][m] << endl;
27

28
    return 0;
29
}

显示更多显示更少

但是由于f[i][j]的状态转移方程都是由[i-1]层决定，所以第一维实际上可以省略。但是省略之后需要将j倒过来遍历，因为没有降维之前状态转移方程为：

f[i][j]=max(f[i−1][j],f[i−1][j−v[i]]+w[i])f[i][j] = max(f[i-1][j], f[i-1][j-v[i]]+w[i])f[i][j]=max(f[i−1][j],f[i−1][j−v[i]]+w[i])

我们需要使用到前一层的j−v[i]j-v[i]j−v[i]，所以要保证此时的j−v[i]j-v[i]j−v[i]仍然是上一层计算出来的值，而不是f[i][j−v[i]]f[i][j-v[i]]f[i][j−v[i]]，又因为j−v[i]j-v[i]j−v[i]小于jjj，所以只能倒序才能让j−v[i]j-v[i]j−v[i]在jjj之后更新。

第二版#

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 1010;
6

7
int n, m;
8
int v[N], w[N];
9

10
int f[N];
11

12
int main()
13
{
14
    cin >> n >> m;
15

16
    for (int i = 1; i <= n; i ++ )   cin >> v[i] >> w[i];
17

18
    for (int i = 1; i <= n; i ++ )
19
        for (int j = m; j >= v[i]; j -- )
20
            f[j] = max(f[j], f[j - v[i]] + w[i]);
21

22
    cout << f[m] << endl;
23

24
    return 0;
25
}

显示更多显示更少

完全背包#

image-20250427224301479

输入样例

输出样例：

1
10

分析#

由于物品可以选无数个，所以我们可以从000~kkk个不断尝试，找到最大的价值。

可以写出状态转移方程:

f[i][j]=max{f[i−1][j−k∗v[i]]+k∗w[i]}f[i][j] = max\{f[i - 1][j - k * v[i]] + k * w[i]\}\\f[i][j]=max{f[i−1][j−k∗v[i]]+k∗w[i]}

我们还观察到:

f[i][j]=max(f[i−1][j],f[i−1][j−v[i]],⋯ ,f[i−1][j−k∗v[i]]+w[i]∗k)f[i][j−v[i]]=max(f[i−1][j−v[i]],⋯ ,f[i−1][j−k∗v[i]]+w[i]∗k)f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i]], \cdots,f[i-1][j-k*v[i]]+w[i]*k)\\ f[i][j-v[i]] = max(f[i-1][j-v[i]],\cdots,f[i-1][j-k*v[i]]+w[i]*k)f[i][j]=max(f[i−1][j],f[i−1][j−v[i]],⋯,f[i−1][j−k∗v[i]]+w[i]∗k)f[i][j−v[i]]=max(f[i−1][j−v[i]],⋯,f[i−1][j−k∗v[i]]+w[i]∗k)

所以f[i][j]=max(f[i−1][j],f[i][j−v[i]])f[i][j] = max(f[i-1][j], f[i][j-v[i]])f[i][j]=max(f[i−1][j],f[i][j−v[i]])

代码#

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 1010;
6

7
int n, m;
8
int v[N], w[N];
9
int f[N];
10

11
int main()
12
{
13
    cin >> n >> m;
14
    for (int i = 1; i <= n; i ++ )  cin >> v[i] >> w[i];
15
    for (int i = 1; i <= n; i ++ )
16
        for (int j = v[i]; j <= m; j ++ )
17
            f[j] = max(f[j], f[j - v[i]] + w[i]);
18

19
    cout << f[m] << endl;
20
    return 0;
21
}

显示更多显示更少

多重背包#

基础#

数据范围小，普通DP即可

分组背包#

值函数近似

Fri, 18 Apr 2025 00:00:00 GMT

tabular -> function

我们需要找到一个最优的www使得v^(s,w)\hat{v}(s, w)v^(s,w)近似vπ(s)v_\pi(s)vπ(s)

image-20250417222051465

ΦT(s)\Phi ^T(s)ΦT(s)是特征向量，www是参数向量

或者神经网络

Objective function#

image-20250417213239736

Stationary distribution#

sss为随机变量，符合概率分布，若为均匀分布，实际上是不太好的，重要的状态喝不重要的状态被视为一致的。

所以我们引入stationary distribution，其中dπTd_\pi^TdπT可以用下面这个公式求出，PπP_\piPπ为转移矩阵，我们知道，到平稳状态时，概率分布会收敛，所以等式左右两边的值是一致的，由此可以解出dπTd_\pi^TdπT。

image-20250417213549405

image-20250417213620429

Optimization algorithm#

梯度下降
wk+1=wk−αk∇wJ(wk)w_{k+1} = w_k - \alpha_k\nabla_wJ(w_k)wk+1=wk−αk∇wJ(wk)

true gradient#

∇w(Jw)=−2E[(vπ(S)−v^(S,w)∇wv^(S,w))]\nabla_w(J_w) = -2\mathbb E[(v_\pi(S)-\hat v(S, w)\nabla_w\hat v(S, w))]∇w(Jw)=−2E[(vπ(S)−v^(S,w)∇wv^(S,w))]

这个式子有期望，所以我们用stochastic gradient代替true gradient，

image-20250417221313827

vπ(st)v_\pi(s_t)vπ(st)未知

image-20250417221514945

其中，函数v^(s,w)\hat v(s,w)v^(s,w)是由我们自己定义的

image-20250422105455972

线性方程拟合缺点：特征方程不好选
非线性神经网络 DQN

如果是线性方程，就被叫做TD-linear

最长上升子序列题解

Wed, 16 Apr 2025 00:00:00 GMT

1. base#

这是一个线性dp的版本，它的数据范围在1000

给定一个长度为 NNN的数列，求数值严格单调递增的子序列的长度最长是多少。

输入格式

第一行包含整数 NNN。

第二行包含 NNN 个整数，表示完整序列。

输出格式

输出一个整数，表示最大长度。

数据范围

1≤N≤10001≤N≤10001≤N≤1000， −109≤数列中的数≤109−10^9≤数列中的数≤10^9−109≤数列中的数≤109

输入样例：

1
7
2
3 1 2 1 8 5 6

输出样例：

1
4

DP分析#

23558fd23229a69e3a50d02b8e8ac61

代码#

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 1010;
6

7
int n;
8
int w[N], f[N];
9

10
int main()
11
{
12
    cin >> n;
13
    for (int i = 1; i <= n; i ++ )  cin >> w[i];
14

15
    for (int i = 1; i <= n; i ++ )
16
    {
17
        f[i] = 1;
18
        for (int j = 1; j < i; j ++ )
19
            if (w[i] > w[j])
20
                f[i] = max(f[j] + 1, f[i]);
21
    }
22

23
    int res = -1;
24
    for (int i = 1;i <= n; i ++ )
25
        res = max(res, f[i]);
26

27
    cout << res << endl;
28

29
    return 0;
30
}

显示更多显示更少

2. 进阶#

数据范围更大，使用DP会TLE(Time Limit Error)

数据范围

1≤N≤10000001≤N≤10000001≤N≤1000000， −109≤数列中的数≤109−10^9≤数列中的数≤10^9−109≤数列中的数≤109

分析#

存储每个长度中最后的数最小的情况，必定这个数组是单调递增的，可以用二分。

代码#

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 1e5 + 10;
6

7
int a[N], q[N];
8
int n;
9

10
int main()
11
{
12
    cin >> n;
13
    for (int i = 0; i < n; i ++ )  cin >> a[i];
14

15
    int len = 0;
16
    q[0] = -2e9;
17
    for (int i = 0; i < n; i ++ )
18
    {
19
        int l = 0, r = len;
20
        while (l < r)
21
        {
22
            int mid = l + r + 1 >> 1;
23
            if (q[mid] < a[i])  l = mid;
24
            else r = mid - 1;
25
        }
26
        len = max(len, r + 1);
27
        q[r + 1] = a[i];
28
    }
29

30
    cout << len << endl;
31
    return 0;
32
}

显示更多显示更少

model free and model based

Tue, 15 Apr 2025 00:00:00 GMT

model-based事实上就是模型已知，model-free是模型未知，事实上，在研究最优控制问题中，通过model-based求得最优解然后验证model-free的方法求得的最优解是否正确。

数字三角形

Mon, 14 Apr 2025 00:00:00 GMT

题目

分析#

image-20250416102612521

代码#

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 1010;
6

7
int a[N][N], f[N][N];
8
int n;
9

10
int main()
11
{
12
  cin >> n;
13
  for (int i = 1; i <= n; i ++ )
14
    for (int j = 1; j <= i; j ++ )
15
      cin >> a[i][j];
16

17
  for (int i = 1; i <= n; i ++ )  f[n][i] = w[n][i];
18
    for (int i = n - 1; i > 0; i ++ )
19
        for (int j = 1; j <= i; j ++ )
20
            f[i][j] = max(f[i + 1][j], f[i + 1][j + 1]);
21

22
    int res = -2e9;
23
    for (int i = 1; i <= n; i ++ )  res = max(res, f[n][i]);
24

25
    cout << res << endl;
26
    return 0;
27
}

显示更多显示更少

TD learning

Sun, 13 Apr 2025 00:00:00 GMT

TD learning of state values#

只能估计给定策略π\piπ的state value

image-20250414160137501

Sarsa#

给定策略可以估计action value

Sarsa is an action-value version of the TD algorithm

image-20250414194020139

expected Sarsa#

image-20250415213231678

image-20250415214119677

n-step Sarsa#

包含MC&&TD

image-20250415214523965

Q-learning#

image-20250416100428680

Summary#

image-20250416100310699

交替放置的玻璃杯题解

Sun, 13 Apr 2025 00:00:00 GMT

题目1: 交替放置的玻璃杯#

有2n个玻璃杯挨个排成一排，前n个装满苏打水，其余n个杯子为空。交换杯子的位置，使之按照满—空—满—空的模式排列，而且杯子移动的次数要最少

这道题目不在力扣里哦，提示：用分治法求解。

题目理解#

image-20250413135538159

我们可以发现：

目标状态的下标存在规律
- 杯满为偶数，杯空为奇数
要达到目标状态，只需要交换绿色线连着的两个杯子
两端的杯子必定在正确的位置，从1和2n−22n-22n−2开始，每隔一个杯子就不在正确的位置
最少的交换次数为⌊n/2⌋\lfloor n/2 \rfloor⌊n/2⌋

Method 1 双指针#

使用左右指针分别从两边向中间逼近，交换杯子

伪代码#

1
1. 初始化l=1, r=2n-2
2
2. 不断循环交换杯子，记录交换次数，l+=2,r+=2
3
3. return 交换次数

时空复杂度分析#

时间复杂度：实际上两个指针相遇即可退出循环，循环次数为n/2n/2n/2，所以时间复杂度为O(n)O(n)O(n)
空间复杂度：只需维护一个string数组，大小为2n2n2n，所以空间复杂度也为O(n)O(n)O(n)

代码#

1
#include <bits/stdc++.h>
2
using namespace std;
3
const int N = 20010;
4
string cups[N];// full的index应该为偶数，empty的index应该为奇数
5
int n;
6
int swap_cups()
7
{
8
    int res = 0;
9
    int l = 1, r = 2 * n - 2;
10
    while (l < n && r >= n)
11
    {
12
        swap(cups[l], cups[r]);
13
        l += 2, r -= 2;
14
        res ++ ;
15
    }
16
    return res;
17
}
18
int main()
19
{
20
    int res;
21
    cin >> n;
22
    for (int i = 0; i < n; i ++ )   cups[i] = "full";
23
    for (int i = n; i < 2 * n; i ++ ) cups[i] = "empty";
24

25
    res = swap_cups();
26
    cout << res << endl;
27
    for (int i = 0; i < 2 * n; i ++ )
28
        cout << cups[i] << " ";
29
    return 0;
30
}

显示更多显示更少

Method 2 分治#

base case#

n = 1时自动满足满-空
n = 2时只需交换中间两个杯子

general#

image-20250413135538159

T(n)={0n=01n=1T(n−2)+1n≥2T(n) = \begin{cases} 0 & n = 0\\ 1 & n = 1\\ T(n - 2)+1 & n \geq 2 \end{cases}T(n)=⎩⎨⎧01T(n−2)+1n=0n=1n≥2

时空复杂度分析#

时间复杂度：O(n)O(n)O(n)
空间复杂度：O(n)O(n)O(n)

代码#

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 20010;
6
string cups[N];// full的index应该为偶数，empty的index应该为奇数
7

8
int n;
9

10
int swap_cups_divide(int l, int r)
11
{
12
    if (l >= r) return 0;
13

14
    swap(cups[l], cups[r]);
15
    return swap_cups_divide(l + 2, r - 2) + 1;
16
}
17

18
int main()
19
{
20
    int res;
21
    cin >> n;
22
    for (int i = 0; i < n; i ++ )   cups[i] = "full";
23
    for (int i = n; i < 2 * n; i ++ ) cups[i] = "empty";
24

25
    res = swap_cups_divide(1, 2 * n - 2);
26
    cout << res << endl;
27
    for (int i = 0; i < 2 * n; i ++ )
28
        cout << cups[i] << " ";
29
    return 0;
30
}

显示更多显示更少

SGD

Sat, 12 Apr 2025 00:00:00 GMT

GD#

image-20250414135236982

BGD#

image-20250414135057529

MBGD#

每次取m个数据

SGD#

image-20250414095338304

Summary#

image-20250413213742809

图片如何处理

Mon, 01 Jan 2024 00:00:00 GMT

图片如何处理#

使用ppt把图片转换为pdf，然后使用inkscape将多余的空白去除，快捷键是Ctrl+Shift+R，之后导出为png，dpi设置为300。

MDX 格式文章示例

Fri, 02 Jan 1970 00:00:00 GMT

Tip

Firefly 支持 MDX 和 Markdown 两种类型的文章，你可以在文章中混合使用两种格式，如果没有特别复杂内容和需求，推荐使用 Markdown 格式就够了。

Markdown 和 MDX 的区别#

Markdown (MD) 是一种轻量级标记语言，允许用户使用纯文本格式编写文档，然后将其转换为格式化的HTML。它因其简洁易用的语法而广受欢迎，特别适合编写文档和博客文章。
MDX 是一种扩展了 Markdown 语法的格式，允许在 Markdown 文档中无缝地插入 JSX 代码。通过 MDX，用户可以在文档中嵌入 React 组件，从而实现更丰富的交互性和动态性。

特性	Markdown	MDX
基础语法	支持 (CommonMark)	支持 (CommonMark)
HTML 标签	支持	支持 (作为 JSX)
组件导入	不支持	支持 (import)
动态数据	不支持	支持 (JS 表达式)
样式定制	有限 (class/style)	灵活 (className/CSS-in-JS)

使用组件#

这是一个图标组件：

1
import { Icon } from 'astro-icon/components'
2

3
<div class="flex items-center gap-2 my-4">
4
  <Icon name="fa6-solid:rocket" class="text-4xl text-red-500" />
5
  <span>火箭发射！</span>
6
</div>

火箭发射！

使用 JSX#

你也可以直接写 HTML/JSX：

1
<div className="p-4 bg-blue-100 dark:bg-blue-900 rounded-lg my-4">
2
  这是一个自定义样式的 div 块，使用了 Tailwind CSS 类。
3
</div>

这是一个自定义样式的 div 块，使用了 Tailwind CSS 类。

简单的变量导出#

1
export const year = new Date().getFullYear()
2

3
今年是 {year} 年。

今年是 2026 年。

更多信息，请查看 MDX 文档

printsdf's Blog

大模型 1/?

我们向 GPT 输入的文字是如何被它处理的？#

经典案例：国王与王后的数学逻辑#

获取 Outlook Refresh Token

适用场景#

使用到的 Client ID#

详细操作步骤#

步骤 1：获取授权码（Authorization Code）#

步骤 2：用授权码换取 Refresh Token#

步骤 3：查看返回结果#

常见问题与解决#

后续使用建议#

CS336 2/？

从零实现 BPE Tokenizer：CS336 实战总结#

什么是 BPE Tokenizer？#

核心数据结构#

encode 流程#

第一步：用 special tokens 切分文本#

第二步：分别处理每个片段#

_encode_chunk：BPE 合并的核心#

decode 流程#

踩坑总结#

小结#

CS336 1/？

BPE 算法实现笔记#

什么是 BPE？#

第一步：预分词（Pretokenization）#

为什么需要这一步？#

GPT-2 的预分词 Pattern#

处理 Special Tokens#

第二步：数据结构#

初始化 vocab#

初始化 pair_counts#

第三步：主循环#

Tiebreak 规则#

核心优化：增量更新 pair_counts#

朴素做法（慢）#

高效做法#

⚠️ 踩坑：左邻居索引#

⚠️ 踩坑：****(a, b) 自身计数#

⚠️ 踩坑：迭代时修改字典#

完整流程图#

测试要求#

docker镜像更新

1. 拉取最新镜像#

2. 重新启动服务#

3. 清理旧镜像（可选）#

💡 核心注意事项#

大模型 3/？

大模型 2/？

Embedding 的局限#

Attention#

Attention 要解决什么问题#

Attention 的整体框架#

Q / K / V 是什么#

为什么不能直接用 X？#

Q / K / V 的角色#

Attention 的计算流程#

第一步：计算相关性 QKTQK^TQKT#

第二步：归一化为权重#

第三步：加权求和#

从 Token 到句子#

总结#

hf 空间不足

复习02

操作系统#

并发和并行有什么区别？#

什么是异步、同步？#

计算机网络#

解释C/S、B/S、P2P#

什么是DNS#

复习03

计算机网络#

简述DNS解析过程#

什么是DHCP协议#

操作系统#

什么是内核态和用户态？为什么要分两个态？#

用户态和内核态是如何切换的？#

复习04

`_encode_chunk`：BPE 合并的核心#

⚠️ 踩坑：`(a, b)` 自身计数#