diff --git a/README.md b/README.md
index 8cb3c13..3123f95 100644
--- a/README.md
+++ b/README.md
@@ -44,6 +44,7 @@
 + [第七章：指令遵循微调](./cn-Book/7.指令遵循微调.md)
 + [附录A：PyTorch简介](./cn-Book/附录A.PyTorch简介.md)
 + [附录B：参考文献和进一步阅读](./cn-Book/附录B.参考文献和进一步阅读.md)
++ [附录C：习题解答](./cn-Book/附录C.习题解答.md)
 
 
 
diff --git a/cn-Book/附录C.习题解答.md b/cn-Book/附录C.习题解答.md
new file mode 100644
index 0000000..0161020
--- /dev/null
+++ b/cn-Book/附录C.习题解答.md
@@ -0,0 +1,494 @@
+
+- [第二掌](#第二掌)
+  - [练习 2.1](#练习-21)
+  - [练习 2.2](#练习-22)
+- [第三章](#第三章)
+  - [练习 3.1](#练习-31)
+  - [练习 3.2](#练习-32)
+  - [练习 3.3](#练习-33)
+- [第四章](#第四章)
+  - [练习 4.1](#练习-41)
+  - [练习 4.2](#练习-42)
+- [第五章](#第五章)
+  - [练习 5.1](#练习-51)
+  - [练习 5.2](#练习-52)
+  - [练习 5.3](#练习-53)
+  - [练习 5.4](#练习-54)
+  - [练习 5.5](#练习-55)
+  - [练习 5.6](#练习-56)
+- [第六章](#第六章)
+  - [练习 6.1](#练习-61)
+  - [练习 6.2](#练习-62)
+  - [练习 6.3](#练习-63)
+- [第七章](#第七章)
+  - [练习 7.1](#练习-71)
+  - [练习 7.2](#练习-72)
+  - [练习 7.3](#练习-73)
+  - [练习 7.4](#练习-74)
+
+-----
+<br />
+练习答案的完整代码示例可以在补充 GitHub 仓库中找到：https://github.com/rasbt/LLMs-from-scratch。
+
+<br />
+
+## 第二掌
+
+### 练习 2.1
+
+你可以通过一次用一个字符串提示编码器来获取单独的 token ID：
+
+```python
+print(tokenizer.encode("Ak"))
+print(tokenizer.encode("w"))
+# ...
+```
+
+打印如下：
+
+```python
+[33901]
+[86]
+# ...
+```
+
+然后你可以使用以下代码来组装原始字符串：
+
+```python
+print(tokenizer.decode([33901, 86, 343, 86, 220, 959]))
+```
+
+打印如下：
+
+```python
+'Akwirw ier'
+```
+
+<br />
+
+### 练习 2.2
+
+具有 max_length=2 和 stride=2 的数据加载器的代码：
+
+```python
+dataloader = create_dataloader(raw_text, batch_size=4, max_length=2, stride=2)
+```
+
+它产生以下格式的批次：
+
+```python
+tensor([[ 40, 367],
+        [2885, 1464],
+        [1807, 3619],
+        [ 402, 271]])
+```
+
+第二个数据加载器的代码，其 max_length=8，stride=2：
+
+```python
+dataloader = create_dataloader(raw_text, batch_size=4, max_length=8, stride=2)
+```
+
+一个示例批次如下所示：
+
+```python
+tensor([[ 40, 367, 2885, 1464, 1807, 3619, 402, 271],
+        [ 2885, 1464, 1807, 3619, 402, 271, 10899, 2138],
+        [ 1807, 3619, 402, 271, 10899, 2138, 257, 7026],
+        [ 402, 271, 10899, 2138, 257, 7026, 15632, 438]])
+```
+
+<br />
+
+## 第三章
+
+### 练习 3.1
+
+正确的权重分配如下：
+
+```python
+sa_v1.W_query = torch.nn.Parameter(sa_v2.W_query.weight.T)
+sa_v1.W_key = torch.nn.Parameter(sa_v2.W_key.weight.T)
+sa_v1.W_value = torch.nn.Parameter(sa_v2.W_value.weight.T)
+```
+
+<br />
+
+### 练习 3.2
+
+为了获得与单头注意力中相同的 2 维输出维度，我们需要将投影维度 d_ou t更改为 1 。
+
+```python
+d_out = 1
+mha = MultiHeadAttentionWrapper(d_in, d_out, block_size, 0.0, num_heads=2)
+```
+
+<br />
+
+### 练习 3.3
+
+最小 GPT-2 模型的初始化如下：
+
+```python
+block_size = 1024
+d_in, d_out = 768, 768
+num_heads = 12
+mha = MultiHeadAttention(d_in, d_out, block_size, 0.0, num_heads)
+```
+
+<br />
+
+## 第四章
+
+### 练习 4.1
+
+我们可以按如下方式计算前馈模块和注意力模块中的参数数量：
+
+```python
+block = TransformerBlock(GPT_CONFIG_124M)
+total_params = sum(p.numel() for p in block.ff.parameters())
+print(f"Total number of parameters in feed forward module: {total_params:,}")
+total_params = sum(p.numel() for p in block.att.parameters())
+print(f"Total number of parameters in attention module: {total_params:,}")
+```
+
+正如我们所见，前馈模块包含的参数数量大约是注意力模块的两倍：
+
+```python
+Total number of parameters in feed forward module: 4,722,432
+Total number of parameters in attention module: 2,360,064
+```
+
+<br />
+
+### 练习 4.2
+
+要实例化其他GPT模型尺寸，我们可以修改配置字典为如下所示（此处以GPT-2 XL为例）：
+
+```python
+GPT_CONFIG = GPT_CONFIG_124M.copy()
+GPT_CONFIG["emb_dim"] = 1600
+GPT_CONFIG["n_layers"] = 48
+GPT_CONFIG["n_heads"] = 25
+model = GPTModel(GPT_CONFIG)
+```
+
+然后，重用第 4.6 节中的代码来计算参数数量和 RAM 需求，我们得到以下结果：
+
+```python
+gpt2-xl:
+Total number of parameters: 1,637,792,000
+Number of trainable parameters considering weight tying: 1,557,380,800
+Total size of the model: 6247.68 MB
+```
+
+<br />
+
+## 第五章
+
+### 练习 5.1
+
+我们可以使用本节中定义的 `print_sampled_tokens` 函数来打印 token（或单词）“pizza” 被采样的次数。让我们从我们在 5.3.1 节中定义的代码开始。
+
+如果温度为 0 或 0.1，则 “pizza” token 被采样 0 次；如果温度升高到 5，则被采样 32 次。估计的概率是 32/1000 × 100% = 3.2%。实际概率是 4.3%，包含在重新缩放的 softmax 概率张量中 (scaled_probas[2][6])。
+
+<br />
+
+### 练习 5.2
+
+Top-k 采样和温度缩放是需要根据 LLM 以及输出中所需的 diversity 和随机性程度进行调整的设置。
+
+当使用相对较小的 top-k 值（例如，小于 10）并且温度设置为低于 1 时，模型的输出变得不那么随机，更具确定性。当我们希望生成的文本更具可预测性、连贯性，并且更接近基于训练数据的最可能结果时，这种设置非常有用。
+
+这种低 k 值和温度设置的应用包括生成正式文档或报告，在这些场景中，清晰度和准确性最为重要。其他应用示例包括技术分析或代码生成任务，在这些任务中，精确性至关重要。此外，问答和教育内容需要准确的答案，低于 1 的温度有助于实现这一点。
+
+另一方面，较大的 top-k 值（例如，范围在 20 到 40 之间）和高于 1 的温度值很有用，当使用 LLM 进行头脑风暴或生成创意内容（如小说）时。
+
+<br />
+
+### 练习 5.3
+
+有多种方法可以使用 `generate` 函数强制确定性行为：
+
+1. 将 top_k 设置为 None 且不应用温度缩放；
+2. 将 top_k 设置为 1。
+
+<br />
+
+### 练习 5.4
+
+本质上，我们必须加载我们在主章节中保存的模型和优化器：
+
+```python
+checkpoint = torch.load("model_and_optimizer.pth")
+model = GPTModel(GPT_CONFIG_124M)
+model.load_state_dict(checkpoint["model_state_dict"])
+optimizer = torch.optim.AdamW(model.parameters(), lr=5e-4, weight_decay=0.1)
+optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
+```
+
+然后，调用 `train_simple_function` 并设置 `num_epochs=1`，以再次训练模型一个 epoch。
+
+<br />
+
+### 练习 5.5
+
+我们可以使用以下代码来计算 GPT 模型的训练集和验证集损失：
+
+```python
+train_loss = calc_loss_loader(train_loader, gpt, device)
+val_loss = calc_loss_loader(val_loader, gpt, device)
+```
+
+具有 1.24 亿参数的模型得到的损失如下：
+
+```python
+Training loss: 3.754748503367106
+Validation loss: 3.559617757797241
+```
+
+主要的观察结果是，训练集和验证集的性能处于同一水平。这可能有多种解释。
+
+1. 当 OpenAI 训练 GPT-2 时，“The Verdict” 并非预训练数据集的一部分。因此，该模型并没有显式地过拟合训练集，并且在 “The Verdict” 的训练集和验证集部分上表现得同样出色。（验证集损失略低于训练集损失，这在深度学习中是不常见的。然而，这很可能是由于数据集相对较小而产生的随机噪声。在实践中，如果没有过拟合，训练集和验证集的性能预计大致相同。）
+2. “The Verdict” 是 GPT-2 训练数据集的一部分。在这种情况下，我们无法判断模型是否过拟合训练数据，因为验证集也可能被用于训练。为了评估过拟合的程度，我们需要一个在 OpenAI 完成 GPT-2 的训练后生成的新数据集，以确保它不可能是预训练数据的一部分。
+
+<br />
+
+### 练习 5.6
+
+在主章节中，我们使用了最小的 GPT-2 模型，它只有 1.24 亿个参数。原因是尽可能降低资源需求。然而，你可以通过极少的代码更改轻松地尝试更大的模型。例如，在第 5 章中，我们加载的是 15.58 亿个参数的模型权重而不是 1.24 亿个，我们只需要更改以下两行代码：
+
+```python
+hparams, params = download_and_load_gpt2(model_size="124M", models_dir="gpt2")
+model_name = "gpt2-small (124M)"
+```
+
+ 更新后的代码如下：
+
+```python
+hparams, params = download_and_load_gpt2(model_size="1558M", models_dir="gpt2")
+model_name = "gpt2-xl (1558M)"
+```
+
+<br />
+
+## 第六章
+
+### 练习 6.1
+
+我们可以通过在初始化数据集时将最大长度设置为 `max_length = 1024`，来将输入填充到模型支持的最大 token 数：
+
+```python
+train_dataset = SpamDataset(..., max_length=1024, ...)
+val_dataset = SpamDataset(..., max_length=1024, ...)
+test_dataset = SpamDataset(..., max_length=1024, ...)
+```
+
+然而，额外的填充导致测试准确率大幅下降，仅为 78.33%（相比之下，主章节中的准确率为 95.67%）。
+
+<br />
+
+### 练习 6.2
+
+与其仅微调最后一个 Transformer 模块，我们可以通过从代码中删除以下几行来微调整个模型：
+
+```python
+for param in model.parameters():
+		param.requires_grad = False
+```
+
+此修改使测试准确率提高了 1%，达到 96.67%（相比之下，主章节中的准确率为 95.67%）。
+
+<br />
+
+### 练习 6.3
+
+与其微调最后一个输出 token，我们可以通过将代码中所有出现的 `model(input_batch)[:, -1, :]` 更改为 `model(input_batch)[:, 0, :]` 来微调第一个输出 token。
+
+正如预期的那样，由于第一个 token 包含的信息比最后一个 token 少，这一更改导致测试准确率大幅下降至 75.00%（相比之下，主章节中的准确率为 95.67%）。
+
+<br />
+
+## 第七章
+
+### 练习 7.1
+
+Phi-3 的提示格式，如图 7.4 在第 7 章中所示，对于给定的输入示例，看起来如下：
+
+```python
+<user>
+Identify the correct spelling of the following word: 'Occasion'
+<assistant>
+The correct spelling is 'Occasion'.
+```
+
+要使用此模板，我们可以按如下方式修改 `format_input` 函数：
+
+```python
+def format_input(entry):
+    instruction_text = (
+    f"<|user|>\n{entry['instruction']}"
+    )
+    input_text = f"\n{entry['input']}" if entry["input"] else ""
+    return instruction_text + input_text
+```
+
+最后，当我们收集测试集响应时，我们还必须更新提取生成响应的方式：
+
+```python
+for i, entry in tqdm(enumerate(test_data), total=len(test_data)):
+    input_text = format_input(entry)
+    tokenizer=tokenizer
+    token_ids = generate(
+        model=model,
+        idx=text_to_token_ids(input_text, tokenizer).to(device),
+        max_new_tokens=256,
+        context_size=BASE_CONFIG["context_length"],
+        eos_id=50256
+    )
+    generated_text = token_ids_to_text(token_ids, tokenizer)
+    response_text = (                                          #A
+        generated_text[len(input_text):]
+        .replace("<|assistant|>:", "")
+        .strip()
+    )
+    test_data[i]["model_response"] = response_text
+    
+    
+#A New: Adjust ###Response to <|assistant|>
+```
+
+使用 Phi-3 模板对模型进行微调大约快 17%，因为它使得模型输入更短。得分接近 50，这与我们之前使用 Alpaca 风格的提示所获得的分数大致相同。
+
+<br />
+
+### 练习 7.2
+
+为了像第 7 章图 7.13 中所示那样屏蔽指令，我们需要对 `InstructionDataset` 类和 `custom_collate_fn` 函数进行一些小的修改。我们可以修改 `InstructionDataset` 类来收集指令的长度，我们将在 collate 函数中使用这些长度，以便在编写 collate 函数时定位目标中的指令内容位置，如下所示：
+
+```python
+class InstructionDataset(Dataset):
+    def __init__(self, data, tokenizer):
+        self.data = data
+        self.instruction_lengths = []                                     #A
+        self.encoded_texts = []
+
+        for entry in data:
+            instruction_plus_input = format_input(entry)
+            response_text = f"\n\n### Response:\n{entry['output']}"
+            full_text = instruction_plus_input + response_text
+        
+        self.encoded_texts.append(
+       		 tokenizer.encode(full_text)
+        )
+        instruction_length = len(tokenizer.encode(instruction_plus_input))
+        self.instruction_lengths.append(instruction_length)                #B
+    
+    def __getitem__(self, index):                                          #C
+    		return self.instruction_lengths[index], self.encoded_texts[index]
+  
+    def __len__(self):
+    		return len(self.data)
+      
+      
+#A 用于指令长度的单独列表
+#B 收集指令长度
+#C 分别返回指令长度和文本
+```
+
+接下来，我们更新 `custom_collate_fn`，由于 `InstructionDataset` 数据集的更改，现在的每个批次都是一个包含 `(instruction_length, item)` 的元组，而不仅仅是 `item`。此外，我们现在屏蔽目标 ID 列表中的相应指令 token：
+
+```python
+def custom_collate_fn(
+    batch,
+    pad_token_id=50256,
+    ignore_index=-100,
+    allowed_max_length=None,
+    device="cpu"
+):
+
+batch_max_length = max(len(item)+1 for instruction_length, item in batch)      #A
+inputs_lst, targets_lst = [], []
+
+for instruction_length, item in batch:                                         #A
+    new_item = item.copy()
+    new_item += [pad_token_id]
+    padded = new_item + [pad_token_id] * (batch_max_length - len(new_item))
+    inputs = torch.tensor(padded[:-1])
+    targets = torch.tensor(padded[1:])
+    mask = targets == pad_token_id
+    indices = torch.nonzero(mask).squeeze()
+    if indices.numel() > 1:
+    		targets[indices[1:]] = ignore_index
+        
+    targets[:instruction_length-1] = -100                                       #B
+    
+    if allowed_max_length is not None:
+        inputs = inputs[:allowed_max_length]
+        targets = targets[:allowed_max_length]
+    
+    inputs_lst.append(inputs)
+    targets_lst.append(targets)
+    
+inputs_tensor = torch.stack(inputs_lst).to(device)
+targets_tensor = torch.stack(targets_lst).to(device)
+
+return inputs_tensor, targets_tensor
+
+
+#A 批次现在是一个元组
+#B 屏蔽目标中的所有输入和指令 token
+```
+
+当评估使用这种指令屏蔽方法进行微调的模型时，它的性能略有下降（使用第 7 章中的 Ollama Llama 3 方法评估，大约下降 4 分）。这与论文《Instruction Tuning With Loss Over Instructions》（https://arxiv.org/abs/2405.14394）中的观察结果一致。
+
+<br />
+
+### 练习 7.3
+
+为了在原始的 Stanford Alpaca 数据集（https://github.com/tatsulab/stanford_alpaca）上微调模型，我们只需要将文件 URL 从：
+
+```python
+url = "https://raw.githubusercontent.com/rasbt/LLMs-from-scratch/main/ch07/01_mainchapter-code/instruction-data.json"
+```
+
+修改成：
+
+```python
+url = "https://raw.githubusercontent.com/tatsulab/stanford_alpaca/main/alpaca_data.json"
+```
+
+请注意，该数据集包含 5.2 万条记录（是第 7 章中的 50 倍），并且记录比我们在第 7 章中使用的更长。因此，强烈建议在 GPU 上运行训练。如果遇到内存不足的错误，请考虑将批处理大小从 8 减少到 4、2 或 1。除了降低批处理大小之外，您可能还需要考虑将 `allowed_max_length` 从 1024 降低到 512 或 256。
+
+以下是 Alpaca 数据集中的一些示例，包括生成的模型回复。
+
+<br />
+
+### 练习 7.4
+
+要使用 LoRA 对模型进行指令微调，请使用附录 E 中的相关类和函数：
+
+```python
+from appendix_E import LoRALayer, LinearWithLoRA, replace_linear_with_lora
+```
+
+接下来，在第 7.5 节的模型加载代码下方添加以下代码行：
+
+```python
+total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+print(f"Total trainable parameters before: {total_params:,}")
+
+for param in model.parameters():
+		param.requires_grad = False
+    
+total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+print(f"Total trainable parameters after: {total_params:,}")
+replace_linear_with_lora(model, rank=16, alpha=16)
+
+total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+print(f"Total trainable LoRA parameters: {total_params:,}")
+model.to(device)
+```
+
+请注意，在 Nvidia L4 GPU 上，使用 LoRA 进行微调在 L4 上运行需要 1.30 分钟。在同一 GPU 上，原始代码运行需要 1.80 分钟。因此，在这种情况下，LoRA 大约快 28%。使用第 7 章中的 Ollama Llama 3 方法评估的分数约为 50，这与原始模型的分数大致相同。
+