📝 更新文档，优化OpenCV与Transformer示例

- 在OpenCV文档中新增了边缘与轮廓部分，提供了边缘检测的相关信息。
- 在Transformer文档中精简了内容，删除了冗余的示例，增强了文档的清晰度与实用性。
- 增加了注意力机制的相关描述，提升了对Transformer模型的理解。

Author: jiangyangcreate

docs/docs/深度学习/Transformer.mdx

@@ -83,20 +83,14 @@ $$
 
 </details>
 
-{/* 
-
-学习Transformer的原理，使用PyTorch实现一个简单的Transformer模型，对模型进行训练和推理。通过分布式训练，提升模型训练效率。
-
-这个配置预计显存占用：约 70GB+（使用 A100 GPU）。 且需要1-2周的训练时间，你才能拥有一个属于你自己的大模型（从随机权重开始预训练到基本连贯性）。
 
-如果你的显存不够，刚好也可以通过文档中计算公式，调整模型配置，降低显存占用。这算是一个实践调参练习。
 
 ## Embedding
 
 提前准备:训练好的词表
 
 - 文本 通过提前训练好的词表拆分为 Token（分词）
-- Token 通过提前训练好的词表转化为 Token ID（独热编码）
+- Token 通过提前训练好的词表转化为 Token ID
 - Token ID 通过提前训练好的词表转化为 Token Embedding（词嵌入）
 - 将位置信息 转化为 位置编码（位置编码）
 - 将 Token Embedding 和 位置编码 相加 得到 最终的输入向量
@@ -121,127 +115,6 @@ $$
 
 词嵌入的过程是分割好的词从【嵌入矩阵】中获取自己向量的过程，假设【嵌入矩阵】维度为4（GPT2选用768维）如下：
 
-| 词汇/Token | 维度1 | 维度2 | 维度3 | 维度4 |
-| ---------- | ----- | ----- | ----- | ----- |
-| \<PAD\>    | 0.00  | 0.00  | 0.00  | 0.00  |
-| \<UNK\>    | 0.12  | -0.51 | 0.32  | 0.89  |
-| 我         | 0.87  | 0.42  | -0.26 | 0.35  |
-| 机器       | 0.32  | 0.52  | 0.75  | 0.22  |
-| 学习       | 0.45  | 0.68  | 0.21  | 0.37  |
-| 爱         | 0.65  | 0.71  | 0.38  | -0.15 |
-
-当输入一个句子"我爱学习机器学习"时，会被分词为["我", "爱", "学习", "机器", "学习"]，然后每个词在嵌入矩阵中查找对应的向量，得到一系列向量表示：
-
-- "我" → [0.87, 0.42, -0.26, 0.35]
-- "爱" → [0.65, 0.71, 0.38, -0.15]
-- "学习" → [0.45, 0.68, 0.21, 0.37]
-- "机器" → [0.32, 0.52, 0.75, 0.22]
-- "学习" → [0.45, 0.68, 0.21, 0.37]
-
-这样，原本的文本序列就被转换为向量序列，这个过程人可以通过肉眼直接看到，机器如何完成？你可以使用for循环加判断，但是有更简单快速的方式：独热编码
-
-独热编码（One-Hot Encoding）是一种将每个词表示为一个向量，该向量的长度等于词表大小，只有对应词的位置为1，其余位置为0的编码方式：
-
-```python
-import numpy as np
-
-# 假设我们有一个词表和嵌入矩阵
-# 词 ： token_id
-vocab = {"<PAD>": 0, 
-         "<UNK>": 1, 
-         "我": 2, 
-         "爱": 3, 
-         "学习": 4, 
-        #..........
-         "机器": 5000,
-        }
-embedding_matrix = np.array([
-    # 假设为N个维度，N列，这里具象化为4列
-    [0.00, 0.00, 0.00, 0.00],  # <PAD>
-    [0.12, -0.51, 0.32, 0.89], # <UNK>
-    [0.87, 0.42, -0.26, 0.35], # 我
-    [0.65, 0.71, 0.38, -0.15], # 爱
-    [0.45, 0.68, 0.21, 0.37],  # 学习
-    # ........
-    [0.32, 0.52, 0.75, 0.22],  # 机器
-])
-
-# 将词转换为独热编码
-def word_to_onehot(word, vocab_size):
-    onehot = np.zeros(vocab_size)
-    if word in vocab:
-        onehot[vocab[word]] = 1 
-        # 以 "我"这个字为例，vocab["我"] 为2，对应下标位置的值为1，其他为0. 
-        # onehot[2] = 1 即[0,0,1,0,0,.....,0]
-    else:
-        onehot[vocab["<UNK>"]] = 1 # 即未知为1.其他为0 [0,1,0,0,0,.....,0]
-    return onehot # 形状为 ：1,5000
-
-# 通过独热编码获取词嵌入
-def get_embedding_via_onehot(word, vocab, embedding_matrix):
-    onehot = word_to_onehot(word, len(vocab)) 
-    return np.dot(onehot, embedding_matrix) # 1,5000  @ 5000,N列 =  1,N列
-
-# 示例
-tokens = ["我", "爱", "学习", "机器", "学习"] # 5个词
-embeddings = [get_embedding_via_onehot(token, vocab, embedding_matrix) for token in tokens]
-# 形状为 5 行 N列，每行即是词对应的向量
-```
-
-实际应用中，我们通常直接使用词索引进行查找，避免独热编码的稀疏计算：
-
-```python
-import torch
-import numpy as np
-embedding_matrix = np.array([
-    # 假设为N个维度，N列，这里具象化为4列
-    [0.00, 0.00, 0.00, 0.00],  # <PAD>
-    [0.12, -0.51, 0.32, 0.89], # <UNK>
-    [0.87, 0.42, -0.26, 0.35], # 我
-    [0.65, 0.71, 0.38, -0.15], # 爱
-    [0.45, 0.68, 0.21, 0.37],  # 学习
-    # ........
-    [0.32, 0.52, 0.75, 0.22],  # 机器
-])
-
-# 使用PyTorch的Embedding层
-vocab_size,embedding_dim = embedding_matrix.shape
-# embedding_dim 表示词嵌入向量的维度大小，即每个词被映射为4维向量，自己根据预定义的嵌入矩阵设置
-# vocab_size 表示词汇表的大小，自己根据预定义的嵌入矩阵设置
-
-# 假设我们有一个词表和嵌入矩阵
-vocab = {"<PAD>": 0, 
-         "<UNK>": 1, 
-         "我": 2, 
-         "爱": 3, 
-         "学习": 4, 
-        #..........
-         "机器": 5000,
-        }
-
-# 创建嵌入层并初始化权重
-embedding = torch.nn.Embedding(vocab_size, embedding_dim)
-# 设置预定义的嵌入矩阵
-embedding.weight.data = torch.tensor(embedding_matrix, dtype=torch.float)
-
-# 将文本转换为索引
-def tokens_to_indices(tokens, vocab):
-    return [vocab.get(token, vocab["<UNK>"]) for token in tokens]
-
-# 示例
-tokens = ["我", "爱", "学习", "机器", "学习"]
-indices = tokens_to_indices(tokens, vocab)
-token_indices = torch.tensor(indices)
-token_embeddings = embedding(token_indices) # 并行计算
-
-print(token_embeddings)
-'''
-
-在实际的Transformer模型中，词嵌入通常是模型训练的一部分，会根据任务目标不断优化调整。这种基于查表的方式比循环判断更高效，可以并行处理整个序列的所有词，大大提高了计算速度。
-
-词嵌入只考虑了词的语义信息，但在序列中，词的位置也很重要。Transformer通过位置编码（Positional Encoding）来捕捉序列中词的位置信息
-'''
-```
 
 ### 位置编码
 
@@ -322,6 +195,8 @@ print(final_input)
 这个空间占用代表了64组数据，每组数据有1024个token，每个向量有768个参数，每个参数占用16位（2字节）。
 :::
 
+{/* 
+
 ## 注意力机制
 
 ### 拆分QKV
@@ -340,6 +215,13 @@ print(final_input)
 
 其中，$W_q$、$W_k$、$W_v$ 是可变权重矩阵，$X$ 是输入的词向量。
 
+：：：tip
+
+在PyTorch等深度学习框架中，为了高效利用计算资源（例如CUDA核心），我们不会真的执行三次独立的矩阵乘法。
+
+
+:::
+
 
 ### 多头分割
 

docs/docs/深度学习/opencv.mdx

@@ -1291,6 +1291,7 @@ for i, (name, result) in enumerate(results.items()):
 plt.tight_layout()
 plt.show()
 ```
+
 ## 边缘与轮廓
 
 ### 边缘检测cv2.Canny

docs/docs/选择编程语言/Python/3序列.mdx

@@ -1211,6 +1211,11 @@ def func(a, b, c):
 
 args = (1, 2, 3)
 result = func(*args)  # 等同于 func(1, 2, 3)
+
+
+# 字典同样可以解包
+kwargs = {'a': 1, 'b': 2, 'c': 3}
+result = func(**kwargs)  # 等同于 func(a=1, b=2, c=3)
 ```
 
 [PEP 3132 – 扩展可迭代对象解包](https://peps.python.org/pep-3132/)