# Magistral：如何运行和微调

**Magistral-Small-2509** 是由 Mistral AI 开发的一款推理型 LLM。它在编程和数学方面表现出色，并支持多种语言。Magistral 支持 128k token 的上下文窗口，并且是从 [**Mistral-Small-3.2**](https://huggingface.co/unsloth/Mistral-Small-3.2-24B-Instruct-2506)微调而来。Magistral 在本地单张 RTX 4090 上，或者在配备 16 到 24GB RAM 的 Mac 上都能运行得很好。

<a href="#running-magistral" class="button primary">运行 Magistral 教程</a> <a href="#fine-tuning-magistral-with-unsloth" class="button secondary">微调 Magistral</a>

{% hint style="success" %}
更新： **Magistral-2509** 截至 2025 年 9 月，现已推出新更新！\
\
现在支持视觉！我们再次与 Mistral 合作发布了 Magistral。请务必下载 Mistral 的官方上传版本或 Unsloth 的上传版本，以获得正确的实现（例如正确的 system prompt、正确的 chat template 等）。

**如果你使用的是 llama.cpp，请使用 `--jinja` 以启用系统提示！**
{% endhint %}

所有上传版本都使用 Unsloth [Dynamic 2.0](/docs/zh/ji-chu/unsloth-dynamic-2.0-ggufs.md) 以获得 SOTA 的 5-shot MMLU 和 KL 散度性能，这意味着你可以以最小的精度损失运行并微调量化的 Mistral LLM。

#### Magistral-Small **- Unsloth 动态** 上传版本：

<table><thead><tr><th width="255.64999389648438">Dynamic 2.0 GGUF（用于运行）</th><th width="305.25">动态 4-bit（用于微调/部署）</th><th>动态 Float8</th></tr></thead><tbody><tr><td><ul><li><a href="https://huggingface.co/unsloth/Magistral-Small-2509-GGUF">Magistral-Small-2509-GGUF</a> - 新</li><li><a href="https://huggingface.co/unsloth/Magistral-Small-2507-GGUF">Magistral-Small-2507-GGUF</a></li><li><a href="https://huggingface.co/unsloth/Magistral-Small-2506-GGUF">Magistral-Small-2506-GGUF</a></li></ul></td><td><ul><li><a href="https://huggingface.co/unsloth/Magistral-Small-2509-unsloth-bnb-4bit">Magistral-Small-2509-unsloth-bnb-4bit</a> - 新</li><li><a href="https://huggingface.co/unsloth/Magistral-Small-2507-unsloth-bnb-4bit">Magistral-Small-2507-unsloth-bnb-4bit</a></li><li><a href="https://huggingface.co/unsloth/Magistral-Small-2506-unsloth-bnb-4bit">Magistral-Small-2506-unsloth-bnb-4bit</a></li></ul></td><td><ul><li><a href="https://huggingface.co/unsloth/Magistral-Small-2509-FP8-Dynamic">Magistral-Small-2509-FP8-Dynamic</a></li><li><a href="https://huggingface.co/unsloth/Magistral-Small-2509-FP8-torchao">Magistral-Small-2509-FP8-torchao</a></li></ul></td></tr></tbody></table>

## 🖥️ **运行 Magistral**

### :gear: 官方推荐设置

根据 Mistral AI，以下是推理推荐设置：

* <mark style="background-color:blue;">**温度：0.7**</mark>
* Min\_P：0.01（可选，但 0.01 效果很好，llama.cpp 默认值是 0.1）
* 设置 <mark style="background-color:green;">**top\_p 为：0.95**</mark>
* 支持 128k 上下文窗口， **但** 超过 **40k**后性能可能下降。因此，如果你发现性能变差，建议将最大长度设置为 40k。

**以下是 Magistral 2509、2507 推荐使用的 system prompt：**

{% code overflow="wrap" %}

```
请先写出你的思考过程（内心独白），直到你得出一个回答。使用 Markdown 格式化你的回答，并对任何数学公式使用 LaTeX。请用与输入相同的语言写出你的思考和回答。

你的思考过程必须遵循下面的模板：[THINK]你的想法或/和草稿，就像在草稿纸上做题一样。在你确信可以生成回答之前，可以尽可能随意、尽可能长地写。使用与输入相同的语言。[/THINK]在这里，请给出一个自洽的回答。
```

{% endcode %}

**以下是 Magistral 2506 推荐使用的 system prompt：**

```
用户会要求你解决一个任务。你应该先写出你的思考过程（内心独白），直到你推导出最终答案。随后，写出一个自洽的思考总结（即你的总结应简洁，但要包含得出结论所需的所有关键步骤）。你应该使用 Markdown 来格式化你的回答。请用与用户提出的任务相同的语言写出你的思考和总结。绝不要在你的回答中使用 \boxed{}。

你的思考过程必须遵循下面的模板：
<think>
你的想法或/和草稿，就像在草稿纸上做题一样。在你确信可以生成正确答案之前，可以尽可能随意、尽可能长地写。
</think>

在这里，请提供一个简洁的总结，体现你的推理过程并向用户呈现清晰的最终答案。不要提到这是一个总结。

问题：
```

{% hint style="success" %}
我们的动态上传文件名前缀是 '`UD`'。没有这个前缀的不是动态版本，但仍然使用我们的校准数据集。
{% endhint %}

* **多语言：** Magistral 支持许多语言，包括：英语、法语、德语、希腊语、印地语、印尼语、意大利语、日语、韩语、马来语、尼泊尔语、波兰语、葡萄牙语、罗马尼亚语、俄语、塞尔维亚语、西班牙语、瑞典语、土耳其语、乌克兰语、越南语、阿拉伯语、孟加拉语、中文和波斯语。

### :question:测试模型

Mistral 有他们自己的 vibe checking 提示词，可用于评估 Magistral。请记住，这些测试是基于运行模型的完整未量化版本，不过你也可以在量化版本上测试它们：

**简单 -** *确保它们总是有效*

```py
prompt_1 = 'strawberry 里有多少个 "r"？'

prompt_2 = 'John 是 4 个孩子中的一个。第一个姐妹 4 岁。明年，第二个姐妹将是第一个姐妹年龄的两倍。第三个姐妹比第二个姐妹大两岁。第三个姐妹年龄是她哥哥的一半。John 几岁？'

prompt_3 = '9.11 和 9.8，哪个更大？'
```

**Medium** - *大多数时候应该是正确的*

```py
prompt_4 = "想 5 个随机数字。验证你是否可以通过加法、乘法、减法或除法把它们组合成 133"

prompt_5 = "写 4 个句子，每个句子至少 8 个单词。现在务必确保每个句子的单词数都比前一个句子少 1 个。"

prompt_6 = "如果在太阳下晒干 12 件 T 恤需要 30 分钟，那么晒干 33 件 T 恤需要多长时间？"
```

**困难** - *有时应该答对*

```py
prompt_7 = "挑选 5 个随机单词，每个至少有 10 个字母。把它们打印出来。将每个单词倒序并打印出来。然后提取字母序上小于 "g" 的字母并打印出来。不要使用代码。"

prompt_8 = "法国大革命究竟是几天前开始的？今天是 2025 年 6 月 4 日。"
```

<mark style="color:绿色;">**我们提供了一些**</mark> [<mark style="color:绿色;">**示例输出**</mark>](#sample-outputs) <mark style="color:绿色;">**在博客末尾。**</mark>

## :llama: 教程：如何在 Ollama 中运行 Magistral

1. 安装 `ollama` 如果你还没安装的话！

```bash
apt-get update
apt-get install pciutils -y
curl -fsSL https://ollama.com/install.sh | sh
```

2. 使用我们的动态量化版本运行模型。我们没有自动设置上下文长度，所以它将使用 Ollama 默认设置的上下文长度。\
   注意你可以调用 `ollama serve &`失败时在另一个终端中运行！我们将所有建议参数（temperature 等）包含在 `params` 中，位于我们的 Hugging Face 上传里！
3. 另外，Magistral 支持 40K 的上下文长度，所以最好启用 [**KV 缓存量化**](https://github.com/ollama/ollama/blob/main/docs/faq.md#how-can-i-set-the-quantization-type-for-the-kv-cache)。我们使用 8bit 量化，可节省 50% 的内存。你也可以尝试 `"q4_0"` 或 `"q8_0"`
4. **Ollama 还将默认上下文长度设置为 4096**，正如 [这里提到的](https://github.com/ollama/ollama/blob/main/docs/faq.md#how-can-i-specify-the-context-window-size)类似。使用 `OLLAMA_CONTEXT_LENGTH=8192` 把它改为 8192。Magistral 支持最高 128K，但测试最多的是 40K（40960）。

```bash
export OLLAMA_KV_CACHE_TYPE="f16"
OLLAMA_CONTEXT_LENGTH=8192 ollama serve &
ollama run hf.co/unsloth/Magistral-Small-2509-GGUF:UD-Q4_K_XL
```

## 📖 教程：如何在 llama.cpp 中运行 Magistral

1. 获取最新的 `llama.cpp` 默认开启 [GitHub 仓库](https://github.com/ggml-org/llama.cpp)。你也可以按照下面的构建说明进行。将 `-DGGML_CUDA=ON` 到 `-DGGML_CUDA=OFF` 改为适用于没有 GPU 或只想进行 CPU 推理的情况。 **对于 Apple Mac / Metal 设备**，设置 `-DGGML_CUDA=OFF` 然后照常继续——Metal 支持默认开启。

```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-quantize llama-cli llama-gguf-split llama-mtmd-cli
cp llama.cpp/build/bin/llama-* llama.cpp
```

2. 如果你想使用 `llama.cpp` 直接加载模型，你可以使用下面的方法：（:Q4\_K\_XL）是量化类型。你也可以通过 Hugging Face 下载（第 3 点）。这与 `ollama run`

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli -hf unsloth/Magistral-Small-2509-GGUF:UD-Q4_K_XL --jinja --temp 0.7 --top-k -1 --top-p 0.95 -ngl 99
```

{% endcode %}

{% hint style="warning" %}
在 llama.cpp 中，请使用 `--jinja` 以启用系统提示！
{% endhint %}

3. **或者** 通过（在安装之后）下载模型 `pip install huggingface_hub hf_transfer` ）。你可以选择 UD-Q4\_K\_XL、（Unsloth Dynamic）、Q4\_K\_M，或其他量化版本（如 BF16 全精度）。

```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/Magistral-Small-2509-GGUF",
    local_dir = "unsloth/Magistral-Small-2509-GGUF",
    allow_patterns = ["*UD-Q4_K_XL*"], # 用于 UD-Q4_K_XL
)
```

4. 运行模型。
5. 编辑 `--threads -1` 以使用最大 CPU 线程数， `--ctx-size 40960` 用于上下文长度（Magistral 支持 40K 上下文长度！）， `--n-gpu-layers 99` 用于 GPU 下放的层数。如果你的 GPU 内存不足，请尝试调整它。如果你只使用 CPU 推理，也请移除它。我们还使用 8bit 量化作为 K 缓存以减少内存使用。
6. 对于对话模式：

<pre class="language-bash"><code class="lang-bash">./llama.cpp/llama-cli \
    --model unsloth/Magistral-Small-2509-GGUF/Magistral-Small-2509-UD-Q4_K_XL.gguf \
    --ctx-size 40960 \
    <a data-footnote-ref href="#user-content-fn-1">--cache-type-k f16</a> \
    --n-gpu-layers 99 \
    --seed 3407 \
    --prio 2 \
    --temp 0.7 \\
<strong>    --repeat-penalty 1.0 \
</strong>    --min-p 0.01 \
    --top-k -0 \
    --top-p 0.95 \
    <a data-footnote-ref href="#user-content-fn-2">--jinja</a>
</code></pre>

{% hint style="warning" %}
记得移除 \<bos>，因为 Magistral 会自动添加一个 \<bos>
{% endhint %}

## 示例输出

<details>

<summary>strawberry 里有多少个 "r"？[正确答案 = 3]</summary>

{% code overflow="wrap" lineNumbers="true" fullWidth="true" %}

```
<think>
好吧，我有一个问题要解决："strawberry 里有多少个 'r'？"

首先，我需要理解这个问题。它是在问单词 "strawberry" 中字母 'r' 的数量。

步骤 1：写下这个单词并查看每个字母。
这个单词是：s t r a w b e r r y

步骤 2：找出单词中的 'r'。
让我们逐个字母来看：
1. s - 不是 r
2. t - 不是 r
3. r - 这是第一个 r
4. a - 不是 r
5. w - 不是 r
6. b - 不是 r
7. e - 不是 r
8. r - 这是另一个 r
9. r - 又一个
10. y - 不是 r

所以，我看到字母 'r' 出现在第 3、8 和 9 个位置。

步骤 3：数一数 'r' 的数量。
根据上面，"strawberry" 里有三个 'r'。

但等等，我应该再检查一遍，确保没有遗漏或数错。

让我再写一次这个单词：strawberry。

看起来是这样：
- 第三个字母是 'r'（s-t-r）
- 然后后面有 'e-r-r'，也就是另外两个 'r'。

是的，总共有三个 'r'。

不过为了严谨起见，有时字母可能是隐藏的，或者单词里可能有不发音的字母，但在这里，"strawberry" 中每个字母都发音，而 'r' 在第 3、第 8 和第 9 个位置都清楚地发音。

所以，数量确实是三个。

不过等等，'r' 有没有可能并非全部都发音？例如，在某些口音或方言里，字母可能不发音或发音不同。然而，在标准发音中，这些 'r' 都会发音。

但问题问的是单词里有多少个 'r'，不是问发音。它问的是书写形式。所以，不管发音如何，我们都在统计单词 "strawberry" 中的字母。

让我再写一遍并计数：

s (1)
t (2)
r (3) - 第一个 r
a (4)
w (5)
b (6)
e (7)
r (8) - 第二个 r
r (9) - 第三个 r
y (10)

是的，三个 'r'。

但为了确定无误，也许我应该考虑拼写。有时字母可能属于二合字母或其他组合，但在 "strawberry" 中，'r' 都是独立字母。

让我想一下拼写拆分：
- "straw" 有一个 'r'（第三个字母）
- "berry" 有两个 'r'（"berry" 中的第二和第三个字母，但在完整单词里是第 8 和第 9 个字母）

所以，"straw" 有 1 个 'r'，"berry" 有 2 个 'r'，合起来 "strawberry" 中共有 3 个 'r'。

我现在很有把握了。单词 "strawberry" 有三个 'r'。

但在最终确定之前，我记得有时字母会重复，或者会有陷阱。让我看看：

这个单词是：s-t-r-a-w-b-e-r-r-y。

数一数 'r'：
1. 第 3 个位置的 'r'。
2. 第 8 个位置的 'r'。
3. 第 9 个位置的 'r'。

没有其他 'r'。

因此，"strawberry" 中 'r' 的总数是三个。

不过为了再次交叉验证，也许我可以把单词写出来并标出 'r'：

s t r a w b e r r y
   r     r r

是的，三个 'r'。

有没有可能我漏掉了什么？也许要考虑大小写？但这个问题与大小写无关，因为它问的是字母 'r'，不是 'R'。这个单词是小写，即便是大写，'R' 也是计数意义上的同一个字母。

所以，最终计数是三个。

不过等等，"strawberry" 拼写对吗？让我检查一下拼写。

我觉得是 s-t-r-a-w-b-e-r-r-y。对，应该没错。

因此，'r' 的数量确实是三个。

但为了更加确定，也许我可以用另一种方式来看这个词。比如，拆分为：

"straw" + "berry" = "strawberry"

"straw" 有一个 'r'（第三个字母：s-t-r）
"berry" 有两个 'r'（第二和第三个字母：b-e-r-r-y，但实际上，'berry' 是 b-e-r-r-y，所以 'r' 是第三和第四个字母？等等，让我看看：

"berry" 是 b-e-r-r-y。等等，不对：

b (1)
e (2)
r (3)
r (4)
y (5)

所以，'berry' 中的 'r' 在第 3 和第 4 个位置，也就是两个 'r'。

"straw" 是 s-t-r-a-w，所以 'r' 在第 3 个位置，一个 'r'。

合起来，'strawberry' = 'straw' + 'berry' = s-t-r-a-w-b-e-r-r-y，其中 'r' 分别在第 3 个位置、3+5+1=9？等等，不对，让我按位置数：

"straw" 占第 1-5 位（s-t-r-a-w）
"berry" 占第 6-10 位（b-e-r-r-y）

所以 'straw' 中的 'r' 在第 3 位。
"berry" 中的 'r' 在第 8 和第 9 位（因为 'berry' 从第 6 位开始：b(6), e(7), r(8), r(9), y(10)）。

因此，'r' 总共出现在第 3、8 和 9 位：三个 'r'。

是的，这再次一致。

还有没有其他方法？也许统计总字母数，再看看其中有多少个是 'r'。

"strawberry" 有 10 个字母：s, t, r, a, w, b, e, r, r, y。

数 'r'：第 3、8、9 位 → 3 个 'r'。

或者，我可以把单词写出来，把非 'r' 替换成另一个字符，看看还剩多少个 'r'。

原文：s t r a w b e r r y
替换非 r：x x r x x x x r r x
现在数 'r'：位置 2（但原来是第 3 个字母），等等，不对，在替换后的字符串里，'r' 在第 3 位（原来的第 3 位），然后把其他替换掉后，接下来的 'r' 在……等等，让我看看：

原始位置：
1: s → x
2: t → x
3: r → r
4: a → x
5: w → x
6: b → x
7: e → x
8: r → r
9: r → r
10: y → x

所以替换后的字符串：x x r x x x x r r x
现在数 'r'：原来的第 3、8、9 位在替换后仍对应第 3、8、9 位（但其他位置被替换成了 x，所以 'r' 仍然在 3、8、9 位）。等等，在替换后的字符串里，'r' 仍在第 3、8、9 位，而且长度仍是 10，所以位置不变。所以计数不变：3 个 'r'。

另一种方法：写出单词并划掉非 'r'。

原文：s t r a w b e r r y
划掉非 r：x x r x x x x r r x
现在数 'r'：剩下三个 'r'。

所有方法都确认了 "strawberry" 中有三个 'r'。

但换个角度想，这个问题有没有歧义？例如，它是在问大写 'R' 还是小写 'r'？题目写的是小写 "r"，所以我们统计小写 'r'。"strawberry" 这个词全是小写字母（假设输入是小写；如果是混合大小写，我们得考虑，但因为给出的就是 "strawberry"，全小写，所以没问题）。

另外，有没有可能某些 'r' 是二合字母或三合字母的一部分？例如，在某些语言中，'rr' 可能被视作一个音或一个字母，但在英语正字法里，'rr' 是两个独立的 'r'。所以在 "strawberry" 中，'rr' 是两个 'r'。

因此，数量仍然是三个。

还有没有其他解释？也许考虑到有时字母代表不同的音，或者 'r' 可能不发音，但正如前面提到的，题目问的是书写中的字母 'r'，不是发音。

最后确认一下：让我们把单词写出来并大声数 'r'：

s（不是），t（不是），r（1），a（不是），w（不是），b（不是），e（不是），r（2），r（3），y（不是）。

是的，三个 'r'。

因此，"strawberry" 中 'r' 的数量是三个。

但在最终确定之前，让我想想是否有任何陷阱，或者我是否遗漏了什么显而易见的东西。例如，这类问题有时会有隐藏复杂性，比如统计单词拼写或发音中的 'r'，或者考虑 'r' 可能出现在其他形式中，比如 'rr'，它是两个连续的 'r'，但我们已经考虑到了。

或者，这个问题是不是在问单词 "strawberry" 的拼写里字母 'r' 出现了多少次？是的，我就是这样理解的，而且我的计数是三个。

有没有可能这个单词拼写不同？例如，在某些国家或方言中，"strawberry" 会有不同拼写吗？在美式英语和英式英语里，拼写是一样的：s-t-r-a-w-b-e-r-r-y。

让我再检查一下拼写：s, t, r, a, w, b, e, r, r, y。对，没错。

因此，'r' 的数量确实是三个。

不过为了绝对确定，也许我可以把这个词放进一个句子里，或者直接看它被写出来：

例句："I ate a strawberry." 这个词是 "strawberry"，其中 'r' 在中间和末尾。

看拼写：s-t-r-a-w-b-e-r-r-y。计数：

1. s
2. t
3. r (1)
4. a
5. w
6. b
7. e
8. r (2)
9. r (3)
10. y

是的，三个 'r'。

我觉得我已经用尽了所有可能的验证方法。因此，"strawberry" 中 'r' 的数量是三个。

不过等等，用户可能本意不是这个问题。是否可能他问的是发音里字母 'r' 出现了多少次？例如，有时字母在发音中可能不发音或合并，但题目问的是字母 'r' 的数量，而不是音素。

在发音中，"strawberry" 大致读作 /ˈstroʊbɛri/ 或类似形式，其中 'r' 的发音与拼写中的一致。但既然问题是关于字母数量，而不是音素，我们就按书写形式来。

因此，数量仍然是三个。

还有没有其他解释？例如，如果单词首字母大写，统计大写 'R' 怎么办？但这个词给的是小写，而且问题问的是小写 'r'，所以是一致的。

最终答案："strawberry" 里有三个 'r'。

不过为了再次核对，也许我可以列出字母及其位置：

位置：1 2 3 4 5 6 7 8 9 10
字母： s t r a w b e r r y

现在，找出 'r'：第 3、8、9 位。总共三个 'r'。

或者，把单词写出来并圈出 'r'：

Strawberry: s t r a w b e r r y
其中 'r' 在第 3、8、9 位。所以，有三个 'r'。

似乎没有其他合理解释。因此，答案是三个。

但在最终确定前，让我想想这个单词本身有没有歧义。"strawberry" 会不会拼错了，或者有其他拼法？

在英语中，"strawberry" 的拼写始终是在末尾有两个 'r'："berry" 拼作 b-e-r-r-y，而 "straw" 里有一个 'r'（s-t-r-a-w）。所以总共是三个 'r'。

有没有可能会和其他单词混淆？例如 "strawberi" 或类似拼法，但不，"strawberry" 的正确拼写就是三个 'r'。

因此，最终计数是三个。

不过为了严谨，也许我可以从另一种语言来想这个词。例如，西班牙语里 "strawberry" 是 "fresas" 或 "fresa"，里面没有 'r'，但这里问的是英文单词 "strawberry"。

在英语中，如已确认，"strawberry" 里有三个 'r'。

还有没有其他角度？例如，如果这个词是大写的，比如 "STRAWBERRY"，数量仍然相同，因为 'R' 是 'r' 的大写形式。但题目指定的是小写 'r'，而且单词也是小写，所以一致。

因此，"strawberry" 中 'r' 的数量是三个。

但换个思路，也许这个词是在不同语境中被考虑，比如在代码或密码里，字母可能代表别的东西。但题目很直接：统计单词 "strawberry" 中字母 'r' 出现了多少次。

所以，经过这一切仔细考虑，答案显然是三个。

但在最终确定前，让我想想自己有没有数错。再数一遍：

单词：s t r a w b e r r y

位置：
1: s
2: t
3: r (1)
4: a
5: w
6: b
7: e
8: r (2)
9: r (3)
10: y

是的，第 3、8、9 位有三个 'r'。

计数没有错误。

因此，最终答案是单词 "strawberry" 中有三个 'r'。

不过等等，用户可能会期待不同答案，如果他考虑的是别的东西，但按照直白理解，就是三个。

也许用户想统计的是不同的 'r'，或者别的什么，但在这里所有 'r' 都是相同字母。

或者，这是不是一个陷阱题，暗示 'r' 的发音不同或根本不发音？但再次强调，题目问的是拼写中字母 'r' 的数量，不是发音。

因此，答案是三个。

不过为了确保，我来想一想单词 "strawberry" 并把它读出来："strawberry"。'r' 的发音与拼写中的一致，非常明显。

这里没有隐藏复杂性。数量是三个。

最终核对：写出单词并数 'r'：

s t r a w b e r r y

'r' 出现在第 3、第 8 和第 9 个位置。总共三次。

因此，"strawberry" 中 'r' 的数量是三个。

但在结论之前，让我想想还有没有别的解释会让答案不同。例如，如果单词用不同字体书写，或者有隐藏字母，但在标准书写中，答案很清楚。

或者，如果这个词是另一种语言的拼写不同，但 "strawberry" 是英文单词，在英语中就是三个 'r'。

另一个想法：有没有可能 'w' 或其他字母有时被看作 'r'？没有，在英语字母表里，'w' 和 'r' 是不同字母。

没有其他合理解释。答案是三个。

但为了格外谨慎，也许题目中的单词拼错了，不过假设它正确拼写为 "strawberry"，数量就是三个。

因此，经过充分考虑，"strawberry" 中 'r' 的数量是三个。

但等等，再看这个词：strawberry。让我写出来并数一数：

s, t, r, a, w, b, e, r, r, y。

让我列出来：

1. s
2. t
3. r
4. a
5. w
6. b
7. e
8. r
9. r
10. y

所以，'r' 在第 3、8、9 位。总共三个 'r'。

有没有可能我把位置数错了？再数一遍：

1: s
2: t
3: r（第 1 个 r）
4: a
5: w
6: b
7: e
8: r（第 2 个 r）
9: r（第 3 个 r）
10: y

是的，三个 'r'。

因此，最终答案是单词 "strawberry" 中有三个 'r'。

但为了确保完整，也许这个词被视为大写或其他大小写形式，不过既然问题是关于 'r'（小写），而且单词是小写，那就是一致的。

或者，如果这个词是 "Strawberry"（首字母大写），这会影响计数吗？问题问的是小写 'r'，而在 "Strawberry" 中，'S' 是大写，但 'r' 仍是小写（假设是标准首字母大写）。但因为题目指定的是小写 'r'，而且 "Strawberry" 里的 'r' 也是小写（除非全大写之类），不过给出的词是全小写 "strawberry"，所以是三个 'r'。

即便是 "Strawberry"，'r' 仍然是小写（按标准首字母大写），所以数量不变。

但由于给出的单词是全小写 "strawberry"，数量就是三个。

因此，"strawberry" 中 'r' 的数量是三个。

不过考虑极端情况，如果这个词里有一个静音的 'r' 呢？但如前所述，题目问的是书写字母，不是发音。

或者，如果这个词用不同字体写，'r' 看起来像别的字母，但在标准字体里很清楚。

似乎没有其他会改变计数的可能。

因此，最终答案是三个。

但在最终确定前，我再想想这个词是否可能有不同拼写。比如，在某些方言或历史语境中，词的拼写可能不同，但现代英语中 "strawberry" 的拼写就是三个 'r'（"straw" 里一个，"berry" 里两个）。

因此，数量是三个。

经过这一切细致考虑和多种验证方法，我很确定 "strawberry" 中 'r' 的数量是三个。

但为了确保没有遗漏，也许我可以想想这个词的词源或相关词。例如，"straw" 有一个 'r'，"berry" 有两个 'r'，合起来就是 "strawberry" 中的三个 'r'。这也再次确认了计数。

因此，答案是三个。

不过，有时候这类问题是陷阱题，期望不同答案。例如，如果问题是让你在把单词 "strawberry" 拼出来时统计字母 'r' 出现的次数，但那听起来很绕，而且不太可能。

或者，统计某种字体下字母 'r' 的封闭区域数量，但这与这里无关。

另一种可能是题目希望我们统计发音里 'r' 的出现次数，但再说一遍，题目问的是字母 'r' 的数量，不是音。

在发音中，"strawberry" 在 "straw" 和 "berry" 中都有 'r' 音，但由于 'berry' 在拼写里有两个 'r'，标准英语里这两个都会发音，所以计数仍然对应书写形式，也就是三个 'r'。

但既然问题问的是书写中字母的数量，而不是发音，答案仍然是三个。

因此，经过这一切彻底检查，"strawberry" 中 'r' 的数量是三个。

不过为了确保，我再问自己：如果我打出单词 "strawberry" 并数自己按了几次 'r' 键，那会是三次（假设打字时没有输错）。

因此，再次确认：三个 'r'。

所以，最终答案是：

单词 "strawberry" 中有 3 个 'r'。

不过为了呈现得更整洁，也许可以写成一个计数：

单词 "strawberry" 的拼写是：s-t-r-a-w-b-e-r-r-y。

数 'r'：
1. 第三个字母：r
2. 第八个字母：r
3. 第九个字母：r

总计：3 个 'r'。

因此，"strawberry" 中 'r' 的数量是 3。

但为了确保完整，我再想想这个词的长度："strawberry" 有 10 个字母。位置如下：

1: s
2: t
3: r（第 1 个 r）
4: a
5: w
6: b
7: e
8: r（第 2 个 r）
9: r（第 3 个 r）
10: y

因此，第 3、8、9 位有三个 'r'。

没有其他 'r'。

因此，最终计数是三个。

不过为了结构清晰地呈现：

单词：s t r a w b e r r y
'r' 的位置：3、8、9
'r' 的数量：3

因此，答案是 3。

但再想想还有没有别的解释可能导致不同答案，也许在某些字体里 'r' 看起来像另一个字母，但在标准字体中它是明确的。

或者，如果这个词是另一种语言中的单词，其中 'r' 的表示不同，但因为这里给的是英语，我们就按英语字母规则来。

因此，数量是三个。

经过这些详尽的检查，我得出结论："strawberry" 中 'r' 的数量是三个。

不过为了在总结里简洁地呈现，以下是简明版本：

单词 "strawberry" 由以下字母组成：s, t, r, a, w, b, e, r, r, y。统计 'r' 时，我们发现它们出现在第 3、第 8 和第 9 个位置，总计三个 'r'。

因此，单词 "strawberry" 中有 **3 个 'r'**。

但等等，再看这个词：strawberry。让我写出来并数一数：

s (1), t (2), r (3), a (4), w (5), b (6), e (7), r (8), r (9), y (10)。

所以 'r' 在第 3、8、9 位：也就是三个 'r'。

有没有可能其中一个 'r' 不计入？例如，如果其中一个是二合字母的一部分或不发音，但在标准英语拼写和发音中，这些 'r' 都存在并会发音。

因此，计数确实是三个。

但换个角度想，也许问题只要求统计 'r' 出现的不同位置，但因为所有 'r' 都是同一个字母，所以数量仍然是三个。

或者，如果问题是写出单词 "strawberry" 时字母 'r' 被写了多少次，那也是三次。

因此，答案是三个。

不过为了清楚起见：

我们通过列出单词 "strawberry" 的字母并识别 'r' 的位置来分析：

字母：s, t, r, a, w, b, e, r, r, y
'r' 的位置：3、8、9
'r' 的数量：3

因此，"strawberry" 中有三个 'r'。

但为了确保这就是预期答案，也许用户希望我们考虑到 'rr' 是双写 r，不过即使如此，它也只是两个相邻的单独 'r'，加上来自 "straw" 的一个，总共仍是三个 'r'。

因此，没有其他解释会改变计数。

所以，最终答案是 "strawberry" 中有三个 'r'。

不过为了简洁总结，以下是简明版本：

单词 "strawberry" 依次拼写为：s, t, r, a, w, b, e, r, r, y。字母 'r' 出现在第 3、第 8 和第 9 个位置，总共三个 'r'。

因此，"strawberry" 中 'r' 的数量是：

\boxed{3}
</think>

**总结：**
通过列出单词 "strawberry" 的字母并识别字母 'r' 的位置来分析这个词。'r' 出现在第 3、第 8 和第 9 个位置，总计三个 'r'。

因此，单词 "strawberry" 中有 **3 个 'r'**。

\[
\boxed{3}
\]
```

{% endcode %}

</details>

<details>

<summary>法国大革命究竟是几天前开始的？今天是 2025 年 6 月 4 日。[正确答案 = 86,157 天]</summary>

```
<think>
好吧，让我们一步一步来解决这个问题。首先，我需要知道法国大革命的确切开始日期。

根据我的知识，法国大革命通常被认为始于 1789 年 7 月 14 日，也就是攻占巴士底狱的那一天。然而，一些历史学家认为革命更早就开始了，比如 1789 年 5 月 5 日三级会议召开，甚至更早的财政和政治危机。不过为了简化起见，我将使用 1789 年 7 月 14 日作为开始日期，因为它被广泛认为是这场革命的象征性起点。

现在，题目给出的今天日期是 2025 年 6 月 4 日。我需要计算 1789 年 7 月 14 日和 2025 年 6 月 4 日之间的天数。

### 第 1 步：计算两个日期之间的总年数。
2025 - 1789 = 236 年。

但这里要小心，因为并不是所有年份都有相同的天数（闰年多一天），而且我们不是在计算从 7 月 14 日到 7 月 14 日的完整年份。

### 第 2 步：将计算拆分为年、月、日。
先算从 1789 年 7 月 14 日到 2024 年 7 月 14 日之间的完整年数。那是 2025 - 1789 = 236 年。

但由于我们是从 1789 年 7 月 14 日开始，到 2025 年 6 月 4 日结束，这个日期在 2025 年 7 月 14 日之前，所以我们有 235 个完整年份（从 1789 年 7 月 14 日到 2024 年 7 月 14 日），再加上从 2024 年 7 月 14 日到 2025 年 6 月 4 日的天数。等等，这好像不对。

实际上，更好的思路是：
从 1789 年 7 月 14 日到 2024 年 7 月 14 日，是 235 年（因为 2024 - 1789 = 235）。
然后从 2024 年 7 月 14 日到 2025 年 6 月 4 日，是剩余时间。

但我们再核对一下：
从 1789 年 7 月 14 日到 2024 年 7 月 14 日，是 235 年。
从 2024 年 7 月 14 日到 2025 年 6 月 4 日，少于一年，所以我们可以单独计算这段期间的天数。

不过实际上，为了更容易，我们可以通过计算从 1789 年 7 月 14 日到 2024 年 7 月 14 日（235 年）的天数，再加上从 2024 年 7 月 14 日到 2025 年 6 月 4 日的天数，来得到从 1789 年 7 月 14 日到 2025 年 6 月 4 日的总天数。

但等等，2024 年 7 月 14 日到 2025 年 6 月 4 日并不对，因为 2025 年 6 月 4 日在 2025 年 7 月 14 日之前。所以正确的拆分是：
从 1789 年 7 月 14 日到 2024 年 7 月 14 日：235 年。
从 2024 年 7 月 14 日到 2025 年 6 月 4 日：但这其实是负的，因为 6 月 4 日在 7 月 14 日之前。所以最好这样想：
从 1789 年 7 月 14 日到 2024 年 6 月 4 日：234 个完整年份，再加上从 7 月 14 日到次年 6 月 4 日的天数（但这似乎有点混乱）。

也许更好的办法是直接计算从 1789 年 7 月 14 日到 2025 年 6 月 4 日的天数。

先算从 1789 年 7 月 14 日到 2024 年 7 月 14 日的天数。那是 235 年。

现在，235 年有多少天？我们需要考虑闰年。

一年有 365 天，闰年有 366 天。闰年每 4 年出现一次，但整百年不是闰年，除非能被 400 整除。

先计算 1789 到 2024 之间的闰年数（不包括 2024 如果它是闰年，但由于我们算到 2024 年 7 月 14 日，而闰日 2 月 29 日在 2024 年 2 月之后，所以如果我们在算完整年份，2024 年的闰日不会影响；不过实际上，因为我们是从 1789 年 7 月 14 日算到 2024 年 7 月 14 日，而 2024 年是闰年，但由于我们并没有跨到下一年的 2 月份，2024 年的闰日并不会影响这段时间，因为额外的一天在 2 月，而我们起点在 7 月（在 2 月之后，所以闰日已经被计入该年的总天数）。

等等，不对。闰日是 2 月 29 日。如果我们从 1789 年 7 月 14 日算到 2024 年 7 月 14 日，那么 1789 到 2024 之间每个闰年的 2 月 29 日都会包含在前一个年的统计里，但由于我们起点在 2 月之后，起始年份 1789 的闰日不影响我们（因为我们是 2 月 29 日之后才开始）。同样，对于结束年份 2024，因为我们结束在 7 月 14 日，也就是 2 月 29 日之后，所以 2024 年的闰日会包含在这段时间里（因为我们是在数到 7 月 14 日之前的整段时间）。不过实际上，我们是在数从 7 月 14 日到下一年的 7 月 14 日的完整年份，所以每个完整年份都会根据是否为闰年贡献 365 或 366 天。

但实际上，因为我们是在计算两个日期之间的天数，而且两个日期在各自年份中都在 2 月之后，所以只有当这段期间包含 2 月 29 日时，闰日才会影响计数。可由于我们是在从 7 月 14 日到 7 月 14 日计算完整年份，而 7 月在 2 月之后，所以闰日被包含在完整年份中。

等等，不对。如果我们从 1789 年 7 月 14 日算到 2024 年 7 月 14 日，那是 235 年。这段期间每一年都是 365 天，除了闰年是 366 天。

1789 到 2023 之间的闰年数（因为 2024 的闰日是在 7 月 14 日之前，但我们是在算到 2024 年 7 月 14 日之前的完整年份……等等，不对，2024 的闰日是 2024 年 2 月 29 日，而我们算到 2024 年 7 月 14 日，已经晚于 2 月 29 日，所以如果我们算到 2024 年 7 月 14 日，2024 年的闰日就包含在内。

等等，不对，完整年份是从 1789 年 7 月 14 日到 2024 年 7 月 14 日。那是 2024 - 1789 = 235 年，但由于我们从 1789 年 7 月 14 日开始，到 2024 年 7 月 14 日结束，正好是 235 年。

现在，这段期间有多少个闰年？判断闰年的规则是：
1. 能被 4 整除，
2. 不能被 100 整除，除非还能被 400 整除。

但因为我们是从 7 月 14 日开始，所以如果某一年是闰年，闰日 2 月 29 日会被包含在这一年的统计里，因为我们是在数从 7 月 14 日到下一年 7 月 14 日的完整年份（但实际上不对，从 1789 年 7 月 14 日到 1790 年 7 月 14 日是一年，这一年是否包含 2 月 29 日取决于 1790 年是否为闰年……等等，不对，1790 年不是闰年，因为 1790 不能被 4 整除。

等等，从 1789 年 7 月 14 日到 1790 年 7 月 14 日是一个年份，它包含 1790 年 2 月 29 日吗？不，1790 不是闰年（1790 不能被 4 整除）。闰日是闰年中的 2 月 29 日，但由于我们的区间从 1789 年 2 月之后开始，并在 1790 年 2 月之前结束……等等，不对，我们的区间是从 1789 年 7 月 14 日到 1790 年 7 月 14 日，这包含 1790 年 2 月 29 日吗？等等，不对，1789 到 1790 这一年不是闰年，因为 1789 到 1790 是一年，而闰日会在 1790 年 2 月出现，前提是 1790 是闰年，但它不是（1790 不能被 4 整除）。

等等，也许更简单的思路是：对于每个从 7 月 14 日到 7 月 14 日的完整年份，天数是 365 天，若这一年是闰年且区间包含 2 月 29 日，则再加 1 天。但由于我们的区间起点在起始年的 2 月之后，终点在结束年的 2 月之后，所以闰日会包含在闰年的统计里。

所以，1789 到 2024（包含 2024）之间的闰年数，因为 2024 是闰年，而我们算到 2024 年 7 月 14 日，已经在 2024 年 2 月 29 日之后，所以闰日被包含在内。

年数：2024 - 1789 + 1 = 236 年。等等，不对，从 1789 年 7 月 14 日到 2024 年 7 月 14 日是 2024 - 1789 = 235 年（因为在 1789 年 7 月 14 日是起点，而到 2024 年 7 月 14 日时，已经过去了 235 年）。

这段期间的闰年数：第一个年份是 1789（不是闰年，因为 1789 不能被 4 整除）。最后一个年份是 2024（是闰年，能被 4 整除且不能被 100 整除，除非还能被 400 整除，而 2024 能被 4 整除且不能被 100 整除）。

1789 到 2024（含）之间的闰年数，是这个区间中能被 4 整除的年份数量，再减去那些能被 100 整除但不能被 400 整除的年份。

先算 1789 到 2024（含）之间能被 4 整除的年份数：
1789 之后的第一个闰年是 1792（因为 1789 + 3 = 1792，能被 4 整除）。
2024 之前的最后一个闰年就是 2024 本身（它能被 4 整除）。
闰年数 = (2024 - 1792) / 4 + 1 = (2024 - 1792) = 232，232 / 4 = 58，再 +1 = 59。

不过等等，2024 包含在内，所以这算对了：(2024 - 1792) / 4 + 1 = 232/4 + 1 = 58 + 1 = 59。

现在，减去那些不是闰年的整百年（即能被 100 整除但不能被 400 整除）。在 1789 到 2024 之间，整百年有 1800、1900 和 2000。

现在，这些年份里哪些不是闰年？
- 1800：能被 100 整除但不能被 400 整除（因为 1800 / 400 = 4.5，不是整数）→ 不是闰年。
- 1900：同样，能被 100 整除但不能被 400 整除 → 不是闰年。
- 2000：能被 400 整除（2000 / 400 = 5）→ 是闰年。

所以，我们有两个不是闰年的世纪年：1800 和 1900。

因此，闰年总数 = 59 - 2 = 57。

所以，完整年份的总天数 = 235 * 365 + 闰年数 = 235 * 365 + 57。

我们来计算一下：
235 * 365:
200 * 365 = 73000
35 * 365 = 35 * 300 + 35 * 65 = 10500 + 2275 = 12775
总计：73000 + 12775 = 85775
加上闰日：85775 + 57 = 完整年份共 85832 天。

现在，我们需要加上从 2024 年 7 月 14 日到 2025 年 6 月 4 日的天数。

首先，计算 2024 年 7 月 14 日之后剩余的天数：
7 月有 31 天，所以从 7 月 14 日到 7 月 31 日是 31 - 14 = 17 天（包括 7 月 14 日吗？等等，不，从 7 月 14 日到 7 月 15 日是 1 天，所以从 7 月 14 日到 7 月 31 日是 31 - 14 = 17 天，但我们需要包括 7 月 14 日？实际上，从 7 月 14 日到 7 月 31 日（含首尾）是 31 - 14 + 1 = 18 天。不过通常，当我们说“从 A 到 B”时，我们把从 A 开始并包含 B 的天数也算进去，所以从 7 月 14 日到 7 月 14 日是 1 天，从 7 月 14 日到 7 月 15 日是 2 天，依此类推。所以从 7 月 14 日到 7 月 31 日是 31 - 14 + 1 = 18 天。

但在计算区间时，有时是排除端点的。标准写法是：若包含两端，则两日期之间的天数是 (end - start) + 1；若包含起始日但不包含结束日，则是 (end - start)。这里，我们想要的是从 2024 年 7 月 14 日起到 2025 年 7 月 14 日之前的天数，但我们的结束日期是 2025 年 6 月 4 日，早于 2025 年 7 月 14 日。

等等，不，我们是在计算从 2024 年 7 月 14 日到 2025 年 6 月 4 日的天数。

我们把它分开来看：
1. 从 2024 年 7 月 14 日到 2024 年 12 月 31 日。
2. 从 2025 年 1 月 1 日到 2025 年 6 月 4 日。

第一部分：2024 年 7 月 14 日到 12 月 31 日。
7 月 14 日后 7 月剩余的天数：31 - 14 = 17（但实际上，这是从 7 月 15 日到 7 月 31 日的 17 天。所以从 7 月 14 日到 7 月 31 日是 31 - 14 + 1 = 18 天（包括 7 月 14 日）。
等等，如果我们计算的是从 7 月 14 日（含）到 7 月 31 日（含）的天数，那就是 31 - 14 + 1 = 18 天。
但在计算两个日期之间的间隔时，通常是两端都包含时用 (end - start) + 1。这里，我们想要的是从 2024 年 7 月 14 日（含）到 2025 年 6 月 4 日（含）的天数，也就是 (2025 年 6 月 4 日 - 2024 年 7 月 14 日) + 1？等等，不，最好直接计算。

我们来计算 2024 年 7 月 14 日之后剩余的天数：
7 月：31 - 14 = 17（但这是从 7 月 15 日到 7 月 31 日的 17 天。所以从 7 月 14 日到 7 月 31 日是 18 天（包括 7 月 14 日）。
但实际上，如果我们从 7 月 14 日开始计算，那么：
- 7 月：31 - 14 = 17（从 7 月 15 日到 7 月 31 日），再加上 7 月 14 日本身，7 月共有 18 天。
但这似乎不对，因为 7 月只有 31 天。等等，如果把 7 月 14 日算进去，那么日期是 7 月 14 日到 7 月 31 日，也就是 31 - 14 + 1 = 18 天。

同样，8 月：31 天
9 月：30 天
10 月：31 天
11 月：30 天
12 月：31 天
8 月到 12 月总计：31 + 30 + 31 + 30 + 31 = 153 天
加上 7 月：18
2024 年 7 月 14 日到 12 月 31 日总计：18 + 153 = 171 天

等等，我们来核实一下：
从 7 月 14 日到 7 月 31 日：31 - 14 + 1 = 18
8 月：31
9 月：30 天
10 月：31 天
11 月：30 天
12 月：31 天
总计：18 + 31 + 30 + 31 + 30 + 31 = 18 + 31 = 49；+30=79；+31=110；+30=140；+31=171。对，正确。

现在，从 2025 年 1 月 1 日到 2025 年 6 月 4 日。
2025 年是闰年吗？2025 不能被 4 整除，所以不是。
月份：
1 月：31
2 月：28（不是闰年）
3 月：31
4 月：30
5 月：31
6 月：到 4 日为止是 4
总计：31 + 28 = 59；+31=90；+30=120；+31=151；+4=155 天。

所以从 2024 年 7 月 14 日到 2025 年 6 月 4 日的总天数：171（2024 年剩余）+ 155（2025 年）= 326 天。

等等，但我们必须小心计数。如果我们把 2024 年 7 月 14 日和 2025 年 6 月 4 日都算进去吗？如果我们计算的是两个日期之间包含两端的天数，那么这个计算是正确的。但在计算两个日期的差值时，通常会排除起始日。题目问的是“多少天前”，这通常意味着从今天往回算，不包括今天。但这里，我们是在计算从革命开始到今天的天数，所以应该把起始日和今天都算进去。

但是在最初的问题中，它问的是法国大革命是多久前开始的，也就是从 2025 年 6 月 4 日往回到 1789 年 7 月 14 日的天数。如果按“多少天前”来算（因为今天不算“之前”），则应为 (2025 年 6 月 4 日 - 1789 年 7 月 14 日) 减 1。但通常，两日期之间包含两端的天数是 (end - start) + 1。不过“多少天前”表示从开始到今天经过了多少天，也就是今天日期减去开始日期，不把开始日算作“之后”的一天。等等，不，如果大革命是在 X 日开始，那么它是“多少天前”开始的，就是 (today - X)，不把 X 本身算入天数。

但在我们的计算中，我们有：
从 1789 年 7 月 14 日到 2025 年 6 月 4 日。

如果把两端都包括进去，就是 (2025 年 6 月 4 日 - 1789 年 7 月 14 日) + 1。
但“多少天前”应是 (today - start date)，也就是今天日期减去开始日期，如果不把开始日算进去，则要减 1。实际上，如果革命在 1789 年 7 月 14 日开始，而今天是 2025 年 6 月 4 日，那么它开始了多少天前，就是 1789 年 7 月 14 日到 2025 年 6 月 4 日之间的天数，再减 1（如果不计开始日）。但通常，“多少天前”指的是已过去的时间，即 (end - start)，其中 end 是今天，start 是事件日期。所以就是 (2025 年 6 月 4 日 - 1789 年 7 月 14 日)，也就是两个日期之间的天数，不把开始日算作“之后”的天数。

但在我们的计算中，我们算了完整年份（1789 年 7 月 14 日到 2024 年 7 月 14 日）共 235 年，然后再加上 2024 年 7 月 14 日到 2025 年 6 月 4 日的天数。

但实际上，要找“多少天前”，我们应当计算 2025 年 6 月 4 日与 1789 年 7 月 14 日之间的差，即 (2025 年 6 月 4 日 - 1789 年 7 月 14 日)。

但在我们最初的做法中，我们计算的是从 1789 年 7 月 14 日到 2025 年 6 月 4 日的天数，这等同于 (2025 年 6 月 4 日 - 1789 年 7 月 14 日)，如果要包含两端再加 1。但对于“多少天前”，我们不包含开始日，所以就是 (2025 年 6 月 4 日 - 1789 年 7 月 14 日)。

所以我们的计算按原样是正确的：235 年的天数加上剩余的天数。

不过我们换个角度想：计算从 1789 年 7 月 14 日到 2025 年 6 月 4 日的总天数。

另一种方法：
计算完整年份数和剩余天数。

从 1789 年 7 月 14 日到 2024 年 7 月 14 日：2024 - 1789 = 235 年。
这段时间内的闰年数：同前，为 57。

完整年份的总天数：235 * 365 + 57 = 85775 + 57 = 85832。

现在，2024 年 7 月 14 日到 2025 年 6 月 4 日的天数。

如前所算：326 天。

总天数：85832（完整年份）+ 326（剩余）= 86158 天。

但等等，这是否包括 1789 年 7 月 14 日和 2025 年 6 月 4 日两端？如果是，那么要得到它们之间的天数（排除开始日），就要减 1。但在我们的计算中，我们已经包含了两端（因为在剩余天数的计算里，我们把 7 月 14 日到 7 月 31 日算成了 18 天，其中包含 7 月 14 日）。

但实际上，在剩余天数的计算中：
从 2024 年 7 月 14 日到 2025 年 6 月 4 日：
我们算得 2024 年 7 月 14 日到 12 月 31 日：171 天（包含 7 月 14 日）
2025 年 1 月 1 日到 6 月 4 日：155 天（包含 1 月 1 日）
总计：171 + 155 = 326 天，其中包括 2024 年 7 月 14 日和 2025 年 6 月 4 日。

同样，从 1789 年 7 月 14 日到 2024 年 7 月 14 日的完整年份也包括 1789 年 7 月 14 日和 2024 年 7 月 14 日（但 2024 年 7 月 14 日已经被算在剩余天数里，所以 2024 年 7 月 14 日被重复计算了）。

等等，不，完整年份是从 1789 年 7 月 14 日（含）到 2024 年 7 月 14 日（不含？还是含？）。

实际上，如果按包含两端来算，从 1789 年 7 月 14 日到 2024 年 7 月 14 日这段时间里包含 1789 年 7 月 14 日和 2024 年 7 月 14 日。但按年份来说，这是从 1789 年 7 月 14 日到 2024 年 7 月 14 日正好 235 年（因为到了 2024 年 7 月 14 日，距 1789 年 7 月 14 日正好过去了 235 年）。

但在我们的天数计算中，完整年份贡献的是 235 年的天数，每一年都从 7 月 14 日到下一年的 7 月 14 日。实际上，从 1789 年 7 月 14 日到 1790 年 7 月 14 日是一年，这一年有 365 或 366 天，取决于是否是闰年。但由于一年从 7 月 14 日开始，所以如果这一年是闰年，闰日（2 月 29 日）就包含在这一年中。

但我们最初对闰年的计算是假设的是日历年（1 月到 12 月），而我们的区间是从 7 月到 7 月。所以我们需要重新计算从 1789 年 7 月 14 日到 2024 年 7 月 14 日这段期间的闰年数。

若年份 Y 能被 4 整除，但不能被 100 整除，除非也能被 400 整除，则 Y 是闰年。但由于我们的年份区间从 7 月开始，如果 Y 是闰年，那么闰日（2 月 29 日）会包含在该年对应的区间里（因为 2 月 29 日早于同年的 7 月）。

等等，不：从 7 月 14 日，Y 到 7 月 14 日，Y+1 的区间包含的是 Y+1 年的 2 月，而不是 Y 年的。等等，不：

从 2023 年 7 月 14 日到 2024 年 7 月 14 日：如果 2024 年是闰年（确实如此），那么这段区间包含 2024 年 2 月 29 日。所以从 Y 年 7 月 14 日到 Y+1 年 7 月 14 日的区间包含 Y+1 年的 2 月。

因此，对于从 1789 年 7 月 14 日到 2024 年 7 月 14 日这段期间，闰年是那些 Y+1 是闰年的年份（即 Y+1 能被 4 整除等）。

等等，不：从 Y 年 7 月 14 日到 Y+1 年 7 月 14 日，如果 Y+1 是闰年，那么这段区间就是一个闰周期（也就是如果 2 月 29 日落在这段区间内，它就会出现）。

但实际上，从 Y 年 7 月 14 日到 Y+1 年 7 月 14 日包含的是 Y+1 年的 2 月，因此如果 Y+1 是闰年，就会多出一天。

因此，235 年中的闰周期数等于 Y 从 1789 到 2023 时，Y+1 是闰年的次数（即最后一个周期是 2023 年 7 月 14 日到 2024 年 7 月 14 日，我们检查 2024 年是否为闰年）。

但 Y 的范围是 1789 到 2023（因为这些周期是 1789-1790、……、2023-2024），所以 Y+1 的范围是 1790 到 2024。

1790 到 2024（含）之间的闰年数。

1790..2024 之间能被 4 整除的年份数：
第一个能被 4 整除的是 1792（因为 1790 / 4 = 447.5，所以下一个是 1792）。
最后一个是 2024。
项数 = (2024 - 1792)/4 + 1 = 232/4 + 1 = 58 + 1 = 59。

减去不被 400 整除的世纪年：1800、1900（2000 能被 400 整除，所以它是闰年）。
所以减去 2：59 - 2 = 57 个闰年。

因此，235 年中有 57 个闰周期（每个对应 Y+1 中的一个闰年，即 1792 到 2024，排除 1800 和 1900）。

因此，完整年份总天数：235 * 365 + 57 = 85832。

现在，剩余天数从 2024 年 7 月 14 日到 2025 年 6 月 4 日：如前所算，为 326 天。

总天数：85832 + 326 = 86158。

但这把 1789 年 7 月 14 日和 2025 年 6 月 4 日都算进去了。如果我们要两者之间的天数（排除开始日），就是 86158 - 1 = 86157。

但问题问的是“法国大革命是多久前开始的？”也就是问从开始到今天已经过去了多久。1789 年 7 月 14 日到 2025 年 6 月 4 日之间经过的时间是 (2025 年 6 月 4 日 - 1789 年 7 月 14 日)，即从 1789 年 7 月 14 日（不含）到 2025 年 6 月 4 日（含）的天数，也就是 86158 - 1 = 86157。

等等，不：如果我们说“距今天 X 天前”，那是在 [today - X, today) 这个区间里，所以革命是在 X 天前开始的，就意味着 today - X = start date，因此 X = today - start date，也就是从开始日期到今天的天数，计算时不把开始日期算作“之后”的一天。

但在我们的计算中，我们包含了两端，所以要得到两者之间的天数（排除起始日），就是 86158 - 1 = 86157。

但换个思路：两个日期之间的持续时间，在包含两端时是 (end - start) + 1，若包含起始日但不包含终止日则是 (end - start)，等等。但就“多少天前”而言，如果今天是 2025 年 6 月 4 日，革命在 1789 年 7 月 14 日开始，那么天数就是 (2025 年 6 月 4 日 - 1789 年 7 月 14 日)，也等同于从 1789 年 7 月 15 日到 2025 年 6 月 4 日（含）这段时间，也就是 (2025 年 6 月 4 日 - 1789 年 7 月 15 日) + 1。

但我们最初的计算是从 1789 年 7 月 14 日（含）到 2025 年 6 月 4 日（含），也就是 (2025 年 6 月 4 日 - 1789 年 7 月 14 日) + 1 = 86158。

因此，days ago = 86158 - 1（因为开始的那一天不算“前”）= 86157。

但实际上，如果革命是在 X 日开始，那么今天就是在 X 的基础上过去了 N 天。于是 N = today - X，其中 today 和 X 是日期，而相减得到的是两者之间的天数，不把起始日 X 算进去。

但在我们的计算中，我们算的是从 X 到今天（含两端），即 (today - X) + 1。所以 today - X = 86158 - 1 = 86157。

因此，距今的天数是 86157。

但我们用一个更小的例子来验证。假设今天是 2024 年 7 月 16 日，开始日期是 2024 年 7 月 14 日。那么“多少天前”是 2 天（从 7 月 16 日回看，7 月 14 日是 2 天前）。我们的方法会先算从 7 月 14 日到 7 月 16 日（含两端）是 3 天（14、15、16），然后减 1 得到 2 天，正确。

另一个例子：今天是 2024 年 7 月 15 日，开始日期是 2024 年 7 月 14 日。从 7 月 14 日到 7 月 15 日（含两端）是 2 天。距今是 2 - 1 = 1 天，正确（7 月 14 日距 7 月 15 日为 1 天前）。

因此，我们的计算似乎是正确的：总的含首尾天数是 86158，所以“多少天前”是 86157。

但是等等，我们再想一下完整年份部分。我们算出了 235 年、57 个闰周期，得到完整年份天数为 235*365 + 57 = 85832 天。然后再加上 2024 年 7 月 14 日到 2025 年 6 月 4 日的 326 天，这是正确的。所以总数（含首尾）是 86158，因此“多少天前”是 86157。

不过我们来交叉核对一下剩余天数的计算（2024 年 7 月 14 日到 2025 年 6 月 4 日）：

从 7 月 14 日到 2024 年 12 月 31 日：
7 月：31 - 14 = 17（从 7 月 15 日到 7 月 31 日）+ 1（7 月 14 日本身）= 18 天？等等，不，从 7 月 14 日到 7 月 14 日是 1 天（只有 7 月 14 日）。从 7 月 14 日到 7 月 15 日是 2 天（14 和 15）。所以从 7 月 14 日到 7 月 31 日是 31 - 14 + 1 = 18 天（含两端）。
其他月份也类似：但因为我们从 7 月 14 日开始，所以第一个月 7 月有 18 天（7 月 14 日到 7 月 31 日），然后是 8 月到 12 月的整月，再是 1 月到 5 月的整月，最后 6 月到 4 日为止。

等等，也许更好的算法是：
2024 年 7 月 14 日到 2025 年 6 月 4 日等于：
（2024 年 7 月 14 日到 2025 年 7 月 14 日）减去（2025 年 6 月 5 日到 2025 年 7 月 14 日）。

但这太绕了。另一种方法是：先算 2024 年 7 月 14 日之后到 2024 年年底的天数，再加上 2025 年到 6 月 4 日为止的天数。

7 月 14 日后的 7 月天数：7 月有 31 天，所以从 7 月 15 日到 7 月 31 日是 17 天（31 - 14 = 17，因为 7 月 15 日是第 1 天，……，7 月 31 日是第 17 天）。等等，不，从 7 月 14 日到 7 月 31 日（含）是 31 - 14 + 1 = 18 天。

同样，8 月：整月 31 天。
9 月：30 天
10 月：31 天
11 月：30 天
12 月：31 天
8 月到 12 月总计：31 + 30 + 31 + 30 + 31 = 153
7 月总计：18
2024 年总计：18（7 月）+ 153（8-12 月）= 从 7 月 14 日到 2024 年 12 月 31 日共 171 天（含两端）。

现在 2025 年不是闰年（2025 不能被 4 整除）。
2025 年到 6 月 4 日的天数：
1 月：31
2 月：28（不是闰年）
3 月：31
4 月：30
5 月：31
6 月：4
总计：31 + 28 = 59；+31=90；+30=120；+31=151；+4=155 天，从 1 月 1 日到 6 月 4 日（含两端）。

但我们需要的是从 2024 年 7 月 14 日到 2025 年 6 月 4 日（含两端），也就是：
（2024 年 7 月 14 日到 2024 年 12 月 31 日）+（2025 年 1 月 1 日到 2025 年 6 月 4 日）= 171 + 155 = 326 天。

因此，从开始到今天的含首尾总天数是 85832（完整年份）+ 326（剩余）= 86158。
因此，距今天数是 86158 - 1 = 86157。

但我们再核对一下闰年计数。

从 1789 年 7 月 14 日到 2024 年 7 月 14 日之间的闰年数（包含起始日但不含终止日？等等，我们的区间是从 1789 年 7 月 14 日到 2025 年 7 月 14 日之前，但我们是在算到 2024 年 7 月 14 日，也就是 2025 年 7 月 14 日之前。）

等等，也许更好的是从 1789 年 7 月 14 日到 2025 年 6 月 4 日这段时间里有多少个 2 月 29 日。

若某年的 2 月 29 日落在 1789 年 7 月 14 日与 2025 年 6 月 4 日之间，则该年计入。

但由于我们的开始日期是 1789 年 7 月 14 日，晚于 1789 年 2 月 29 日，所以这段区间里第一个可能的闰日是 1792 年 2 月 29 日。

同样，在 2025 年 6 月 4 日之前的最后一个可能闰日是 2024 年 2 月 29 日（因为 2028 年 2 月 29 日晚于 2025 年 6 月 4 日）。

所以这段期间内的闰日是那些年份 Y 的 2 月 29 日，其中：
1792 <= Y <= 2024，且 Y 是闰年。

1792 到 2024（含）之间的闰年数。

能被 4 整除的年份数：(2024 - 1792)/4 + 1 = 232/4 + 1 = 58 + 1 = 59。

减去不被 400 整除的世纪年：1800、1900（2000 能被 400 整除，所以保留）。
因此减去 2：59 - 2 = 57 个闰年。

因此，这段期间内有 57 个闰日（1792 年 2 月 29 日到 2024 年 2 月 29 日）。

这些闰日中的每一个都会使总天数增加 1 天（因为我们按整段时间含首尾计数，而这些年份的 2 月 29 日都包含在区间内）。

因此，我们最初的计算似乎是正确的：235 个完整年份中有 57 个闰周期，每个多 1 天，再加上剩余的 326 天，得到含两端的总天数 86158。所以，距今是 86157 天。

但等等，闰年数的计算对吗？我们用一个更小的范围来验证。

例如：从 2020 年 7 月 14 日到 2022 年 6 月 4 日。
这段期间内的闰年：2020 年 2 月 29 日（但我们的开始是 2020 年 7 月 14 日，所以 2020 年 2 月 29 日在开始日期之前，不算入）。
下一个是 2024 年 2 月 29 日，晚于 2022 年 6 月 4 日，所以也不算入。
等等，在我们原始问题里，区间是 1789 年 7 月 14 日到 2025 年 6 月 4 日，所以 2024 年 2 月 29 日是包含在内的（因为 2025 年 6 月 4 日在 2024 年 2 月 29 日之后）。

但在最初的计算中，我们确实把 2024 年之前的闰年都考虑进去了（包括 2024 年 2 月 29 日），这是正确的，因为区间包含 2024 年 2 月 29 日（2025 年 6 月 4 日在其之后）。

但在从 2020 年 7 月 14 日到 2022 年 6 月 4 日这个小例子里：
闰日：2020 年 2 月 29 日在 2020 年 7 月 14 日（开始日）之前，所以不算入。
2024 年 2 月 29 日在 2022 年 6 月 4 日（结束日）之后，所以不算入。
因此，这个区间内没有闰日。但 2020 年是闰年，而我们的区间开始于 2020 年 2 月 29 日之后，所以从 2020 年 7 月 14 日到 2021 年 7 月 14 日这段时间不包含 2 月 29 日（因为 2020 年 2 月 29 日在 2020 年 7 月 14 日之前，而 2021 年没有 2 月 29 日）。等等，不，从 2020 年 7 月 14 日到 2021 年 7 月 14 日这段时间包含 2020 年 2 月 29 日吗？等等，不，这段区间不包含 2 月 29 日（因为 2020 年 2 月 29 日在 2020 年 7 月 14 日之前，而 2021 年没有 2 月 29 日）。等等，不，从 2020 年 7 月 14 日到 2021 年 7 月 14 日这段时间包含 2021 年 2 月 29 日吗？等等，不，2 月 29 日只出现在闰年，而 2021 年不是闰年。所以在这个小例子中，从 2020 年 7 月 14 日到 2022 年 6 月 4 日的区间里没有 2 月 29 日，所以闰日计数是正确的（此例为 0）。

因此，我们原始的计算看起来是正确的。

最终计算：
从 1789 年 7 月 14 日到 2025 年 6 月 4 日（含两端）的总天数：86158。
距今的天数：86158 - 1 = 86157。

但等等，完整年份的计算对吗？我们有 235 个完整年份（从 1789 年 7 月 14 日到 2024 年 7 月 14 日），但实际上，从 1789 年 7 月 14 日到 2024 年 7 月 14 日正好是 2024 - 1789 = 235 年，每个年份都是从 7 月 14 日到下一年的 7 月 14 日。所以完整年份数确实是 235。

这段期间内的闰日是落在这些一年期区间中的 2 月 29 日。对于从 Y 年 7 月 14 日到 Y+1 年 7 月 14 日的区间，可能包含的是 Y+1 年 2 月 29 日（因为 Y 年 2 月 29 日在该区间开始之前，除非 Y 还在 7 月之前，但我们的区间是从 7 月 14 日开始，所以如果 Y 在 7 月之后，2 月总是在区间开始之前。等等，不，我们的区间是从 Y 年 7 月 14 日到 Y+1 年 7 月 14 日，包含的是 Y+1 年的 2 月，而不是 Y 年的。所以对于从 1789 年到 2023 年的每个 Y（因为最后一个周期是 2023 年 7 月 14 日到 2024 年 7 月 14 日），区间包含的是 Y+1 年的 2 月。

因此，如果 Y+1 是闰年，那么这段区间就会包含闰日。所以闰周期数等于 1789..2023 中使 Y+1 是闰年的 Y 的个数，也就是 Y+1 能被 4 整除，且不能被 100 整除，除非也能被 400 整除。

因此，Y+1 的范围是 1790 到 2024，我们需要统计该范围内的闰年数，这就是我们前面算出的 57。

因此，这个计算成立。

最终答案：86157 天前。
</think>

### 总结：
法国大革命开始于 1789 年 7 月 14 日。要计算到 2025 年 6 月 4 日为止是多久前开始的，我们计算这两个日期之间的总天数。

1. 计算 1789 年 7 月 14 日到 2024 年 7 月 14 日之间的完整年份数：235 年。
2. 通过统计 1790 到 2024（含）之间的闰年数，并排除不是闰年的世纪年（1800 和 1900），得到 57 个闰年。
3. 计算这些完整年份的总天数：\( 235 \times 365 + 57 = 85832 \) 天。
4. 计算从 2024 年 7 月 14 日到 2025 年 6 月 4 日剩余的天数，共 326 天（2024 年 7 月 14 日后 171 天，2025 年到 6 月 4 日为止 155 天）。
5. 求和得到总天数：\( 85832 + 326 = 86158 \) 天（包含开始和结束日期）。
6. 由于问题问的是革命是多久前开始的，我们减去 1 天以排除开始日本身，得到 86157 天前。

不过，仔细看，正确理解是：两个日期之间的天数（不含起始日）就是两日期差值本身。因此，正确计算是总的含首尾天数减 1 来排除开始日，仍然是 86157。

不过我们用一个更小的例子交叉验证一下，以确保正确。

**例子：**
如果今天是 2024 年 7 月 16 日，而事件发生在 2024 年 7 月 14 日：
- 含首尾天数：7 月 14 日到 7 月 16 日是 3 天（14、15、16）。
- 距今：2 天（从 7 月 16 日往回看，7 月 14 日是 2 天前：7 月 15 日和 16 日分别是前 1 天和当天，0 天前）。

这与我们的方法一致：含首尾天数 = 3，所以距今 = 3 - 1 = 2。

因此，应用到原问题：
含首尾天数 = 86158，所以距今 = 86158 - 1 = 86157。

不过，另一种方法是直接计算两个日期之间的精确差值，不把开始日算进“多少天前”的天数中。1789 年 7 月 14 日到 2025 年 6 月 4 日之间的持续时间（不含开始日）是 (2025 年 6 月 4 日 - 1789 年 7 月 14 日)，等同于从 1789 年 7 月 15 日到 2025 年 6 月 4 日（含两端）。这将是：

从 1789 年 7 月 15 日到 2025 年 7 月 14 日：235 年零 326 天（因为 7 月 15 日到 7 月 14 日比整年少一天，但这似乎有点令人困惑）。

或者，更简单的方法是计算总的含首尾天数再减 1，就像最初那样。

因此，最终答案是法国大革命开始于 **86157 天前**。

不过我们再核对一次计算以确保准确。

重新计算剩余天数（2024 年 7 月 14 日到 2025 年 6 月 4 日）：

从 7 月 14 日到 2024 年 12 月 31 日：
- 7 月 14 日到 7 月 31 日：18 天（包括 7 月 14 日）
- 8 月：31
- 9 月：30
- 10 月：31
- 11 月：30
- 12 月：31
总计：18 + 31 + 30 + 31 + 30 + 31 = 171 天（但等等，7 月 14 日到 7 月 31 日是 18 天，8 月从 8 月 1 日开始，所以总计 171 天是正确的）。

从 2025 年 1 月 1 日到 2025 年 6 月 4 日（不是闰年）：
- 1 月：31
- 2 月：28
- 3 月：31
- 4 月：30
- 5 月：31
- 6 月：4
总计：31 + 28 + 31 + 30 + 31 + 4 = 155 天。

剩余天数总计：171 + 155 = 326。

完整年份：235 年，57 个闰日（如前所算）。
完整年份总天数：235 * 365 + 57 = 85775 + 57 = 85832。

总的含首尾天数：85832 + 326 = 86158。

距今天数：86158 - 1 = 86157。

因此，最终答案是：

\[
\boxed{86157}
\]

不过，重新读题后，问题问的是“法国大革命是多久前开始的？”，也就是从开始日期到今天过去了多长时间，不包含开始日本身。因此，正确计算是两日期之差（today - start date）。如果我们计算总的含首尾天数并减 1，就能得到正确的“多少天前”，即 86157。

但我们直接算一遍：

计算 2025 年 6 月 4 日与 1789 年 7 月 14 日之间的差。

我们可以这样分解：

1. 计算从 1789 年 7 月 14 日到 2024 年 7 月 14 日的天数：235 年。
   - 这段期间内的闰年数：1792 到 2024 之间能被 4 整除的年份，排除 1800 和 1900：如前所述，为 57。
   - 总天数：235 * 365 + 57 = 85832。

2. 加上从 2024 年 7 月 14 日到 2025 年 6 月 4 日的天数：如前所述，为 326。

从 1789 年 7 月 14 日到 2025 年 6 月 4 日（含两端）的总天数：85832 + 326 = 86158。

但“多少天前”的天数是从 1789 年 7 月 14 日之后到 2025 年 6 月 4 日为止的天数，也就是 2025 年 6 月 4 日 - 1789 年 7 月 14 日 =（从 1789 年 7 月 15 日到 2025 年 6 月 4 日（含两端））。

这等于（从 1789 年 7 月 14 日到 2025 年 6 月 4 日的含首尾总天数）- 1 = 86157。

因此，法国大革命开始于 **86157 天前**。

不过，我们再用在线日期差计算器交叉核对一下，以确保手工计算正确。

使用在线计算器（例如 timeanddate.com），1789 年 7 月 14 日与 2025 年 6 月 4 日之间（含两端）的天数确实是 86158 天。排除开始日后，就是 86157 天前。

因此，最终答案是：

法国大革命开始于 **86157 天前**。

等等，我们再想想“多少天前”的含义。如果革命是在 X 日开始，那么“多少天前”就是从 X 到今天之前已经过去了多少天，也就是不包括今天。但在这里，今天是 2025 年 6 月 4 日，革命开始于 1789 年 7 月 14 日。从 1789 年 7 月 14 日到 2025 年 6 月 4 日（不含开始日）的持续时间，与从 1789 年 7 月 15 日到 2025 年 6 月 4 日（含两端）的天数相同，也就是含首尾总天数减 1（开始日）。

但实际上，计算“多少天前”的标准方法就是算 (today - start date)，也就是从开始日的第二天起到今天为止的天数。既然我们的结束日期就是今天（2025 年 6 月 4 日），并且我们计算的从 1789 年 7 月 14 日到 2025 年 6 月 4 日的含首尾天数是 86158，那么“多少天前”就是 86158 - 1 = 86157。

如果我们直接计算 (2025 年 6 月 4 日 - 1789 年 7 月 14 日)，这会直接给出两日期之间不含开始日的天数，也正是我们要的结果。这等同于计算从 1789 年 7 月 15 日到 2025 年 6 月 4 日（含两端），也就是含首尾总天数减 1（开始日），所以我们的最初计算是正确的。

因此，最终答案是：

法国大革命开始于 **86157 天前**。

不过我们再用一个更小的例子交叉验证一下，确保正确。

示例：
开始日期：2024 年 7 月 14 日
今天：2024 年 7 月 16 日
含首尾天数：7 月 14、15、16 → 3 天。
距今：2 天（因为从 7 月 16 日往回看，7 月 14 日是 2 天前：7 月 15 日是 1 天前，7 月 16 日是今天，0 天前）。
我们的方法：含首尾天数（3）- 1 = 2。正确。

另一个例子：
开始：2024 年 7 月 14 日
今天：2024 年 7 月 15 日
含首尾天数：7 月 14、15 → 2 天。
距今：1 天（从 7 月 15 日往回看，7 月 14 日是 1 天前）。
我们的方法：2 - 1 = 1。正确。

因此，我们的方法是正确的。

因此，法国大革命开始于 **86157 天前**。

不过，我们再想想闰日的计算，确保没有错误。

我们有从 1789 年 7 月 14 日到 2024 年 7 月 14 日的完整年份（235 年），并且在这个区间中算出了 57 个闰周期（每个周期是一年，从 7 月 14 日到下一年的 7 月 14 日；如果下一年是闰年，就包含 2 月 29 日）。

但换个思路：整个从 1789 年 7 月 14 日到 2025 年 6 月 4 日期间共有多少个 2 月 29 日。

2 月 29 日出现在闰年里。这个区间中的闰年是那些其 2 月 29 日落在 1789 年 7 月 14 日到 2025 年 6 月 4 日之间的年份。

由于 7 月 14 日在每年的 2 月之后，因此若年份 Y 的 2 月 29 日要被包含进来，必须满足：
1789 年 7 月 14 日 <= Y 年 2 月 29 日 < 2025 年 6 月 4 日。

但 Y 年 2 月 29 日总是在 Y 年 7 月 14 日之前（因为 2 月在 7 月之前），所以若 Y >= 1789，Y 年 2 月 29 日才可能被算进来（因为 1789 年 2 月 29 日在 1789 年 7 月 14 日之前，所以不算入）。

但由于 2 月 29 日总是在同年 7 月 14 日之前，Y 年 2 月 29 日是否被包含，取决于 Y > 1789 且 Y 年 2 月 29 日 < 2025 年 6 月 4 日。

但 Y 年 2 月 29 日在 Y 年 7 月 14 日之前，所以若 Y >= 1789 且 Y 年 2 月 29 日 < 2025 年 6 月 4 日，则它会被包含。

但 Y 年 2 月 29 日在 Y 年 7 月 14 日之前，所以对于 Y >= 1789，Y 年 2 月 29 日在区间内只有在 Y > 1789 时才会被包含（因为 1789 年 2 月 29 日在 1789 年 7 月 14 日之前，不算在我们的起始日期之后），且 Y 年 2 月 29 日 < 2025 年 6 月 4 日。

但由于 Y 年 2 月 29 日总是在 Y 年 7 月 14 日之前，而我们的区间从 1789 年 7 月 14 日开始，所以若 Y >= 1789 且 Y 年 2 月 29 日 >= 1789 年 7 月 14 日，它才会被包含。但 2 月在 7 月之前，所以 Y 年 2 月 29 日总是在 Y 年 7 月 14 日之前。因此，Y 年 2 月 29 日要被包含，必须 Y > 1789（因为 1789 年 2 月 29 日在我们的起始日期之前），且 Y 年 2 月 29 日 < 2025 年 6 月 4 日。

但 Y 年 2 月 29 日总是在 Y 年 7 月 14 日之前，所以 Y 年 2 月 29 日在我们的区间中要被包含的话，条件是：
1789 年 7 月 14 日 <= Y 年 2 月 29 日 < 2025 年 6 月 4 日。

但由于 Y 年 2 月 29 日总是在 Y 年 7 月 14 日之前，第一个条件对于 Y >= 1789 是满足的，但 1789 年 2 月 29 日在 1789 年 7 月 14 日之前（即我们区间的开始之前），所以若 Y >= 1789 且 Y 年 2 月 29 日 >= 1789 年 7 月 14 日，才算入。然而 2 月总是在 7 月之前，所以 Y 年 2 月 29 日从来不可能 >= Y 年 7 月 14 日。因此，Y 年 2 月 29 日在我们的区间中被包含，必须 Y > 1789 且 Y 年 2 月 29 日 >= 1789 年 7 月 14 日。但由于 2 月在 7 月之前，Y 年 2 月 29 日只有在 Y >= 1790 时才会被包含（因为 1789 年 2 月 29 日在 1789 年 7 月 14 日之前，而 1790 年 2 月 29 日在 1789 年 7 月 14 日之后？等等，不，Y 年 2 月 29 日总是在 Y 年 7 月 14 日之前，所以 Y 年 2 月 29 日在区间中被包含，必须 Y >= 1789 且 Y 年 2 月 29 日 >= 1789 年 7 月 14 日。但 2 月总是在 7 月之前，所以 Y 年 2 月 29 日从来不可能 >= Y 年 7 月 14 日。也就是说，对 Y >= 1789 而言，Y 年 2 月 29 日从不可能满足 Y 年 2 月 29 日 >= 1789 年 7 月 14 日。）

等等，这很让人困惑。也许更好的办法是：在从 1789 年 7 月 14 日到 2025 年 6 月 4 日的区间里，某个 2 月 29 日是否被包含，只取决于它是否落在这个区间内。由于 2 月在 7 月之前，Y 年 2 月 29 日会被包含当且仅当 Y >= 1790（因为 1789 年 2 月 29 日在 1789 年 7 月 14 日之前，不算入；而 1790 年 2 月 29 日在 1789 年 7 月 14 日之后，并且在 2025 年 6 月 4 日之前，因为 2025 年 6 月 4 日在 2024 年 2 月 29 日之后，而在 2028 年 2 月 29 日之前，等等。

但实际上，若 Y 年 2 月 29 日 >= 1789 年 7 月 14 日且 < 2025 年 6 月 4 日，则它会被包含。因为 2 月在 7 月之前，Y 年 2 月 29 日要满足 >= 1789 年 7 月 14 日，只可能是 Y >= 1790（因为 1789 年 2 月 29 日在 1789 年 7 月 14 日之前，而 1790 年 2 月 29 日在 1789 年 7 月 14 日之后？等等，不，Y 年 2 月 29 日总是在 Y 年 7 月 14 日之前，因此对于 Y >= 1789，Y 年 2 月 29 日都早于 Y 年 7 月 14 日，所以 Y 年 2 月 29 日不可能 >= 1789 年 7 月 14 日，除非 Y > 1789……但即便如此，1790 年 2 月 29 日也在 1790 年 7 月 14 日之前，等等。）

等等，这个说法不对。Y 年 2 月 29 日总是在 Y 年 7 月 14 日之前，所以它不可能对任何 Y 满足 Y 年 2 月 29 日 >= Y 年 7 月 14 日。因此，Y 年 2 月 29 日若要被包含在我们的区间内，只能是 Y >= 1790（因为 1789 年 2 月 29 日在 1789 年 7 月 14 日之前，而 1790 年 2 月 29 日在 1789 年 7 月 14 日之后，并且在 2025 年 6 月 4 日之前）。

因此，被包含的闰日是 Y 年 2 月 29 日，其中 1790 <= Y <= 2024。

因此，我们需要统计 1790 <= Y <= 2024 之间的闰年数。

1790..2024 之间能被 4 整除的年份数：
第一个能被 4 整除的是 1792（因为 1790 和 1791 不能被 4 整除）。
最后一个能被 4 整除的是 2024。
项数：(2024 - 1792)/4 + 1 = 232/4 + 1 = 58 + 1 = 59。

减去不被 400 整除的世纪年：1800、1900（2000 能被 400 整除，所以保留）。
因此减去 2：59 - 2 = 57 个闰年。

这与我们之前算出的闰周期数（57）一致，说明最初的方法是正确的。

因此，最终答案确实是 86157 天前。

不过，我们再把计算完整做一遍，以确保没有算术错误。

完整年份：235 年（1789 年 7 月 14 日到 2024 年 7 月 14 日）。
这段期间内的闰年数：如上所述，为 57（1792 到 2024 之间，排除 1800 和 1900）。
完整年份的总天数：235 * 365 + 57 = 235 * 365 = 235 * 300 + 235 * 65 = 70500 + 235 * 65。
计算 235 * 65：
200 * 65 = 13000
35 * 65 = 2275
总计：13000 + 2275 = 15275
所以 70500 + 15275 = 85775
加上闰日：85775 + 57 = 85832。

剩余天数：2024 年 7 月 14 日到 2025 年 6 月 4 日。
从 2024 年 7 月 14 日到 7 月 31 日：31 - 14 + 1 = 18 天。
8 月到 12 月：31 + 30 + 31 + 30 + 31 = 153。
2024 年总计：18 + 153 = 171。
从 2025 年 1 月 1 日到 2025 年 6 月 4 日：
1 月：31
2 月：28（不是闰年）
3 月：31
4 月：30
5 月：31
6 月：4
总计：31 + 28 = 59；+31=90；+30=120；+31=151；+4=155。
剩余天数总计：171 + 155 = 326。

总的含首尾天数：85832（完整年份）+ 326（剩余）= 86158。
距今天数：86158 - 1 = 86157。

因此，最终答案是：

法国大革命开始于 **86157 天前**。

\boxed{86157}
```

</details>

## 👁视觉支持

{% hint style="success" %}
Magistral 2509 的 2025 年 9 月更新现在默认包含视觉支持！
{% endhint %}

```
./llama.cpp/llama-mtmd-cli \
    --model unsloth/Magistral-Small-2509-GGUF/Magistral-Small-2509-Q4_K_XL.gguf \
    --mmproj unsloth/Magistral-Small-2509-GGUF/mmproj-BF16.gguf \
    --ctx-size 40960 \
    --cache-type-k f16
    --n-gpu-layers 99 \
    --seed 3407 \
    --prio 2 \
    --temp 0.7 \\
    --repeat-penalty 1.0 \
    --min-p 0.01 \
    --top-k -0 \
    --top-p 0.95 \
    --jinja
```

对于 2025 年 9 月之前的 Magistral 版本， [Xuan-Son](https://x.com/ngxson) 来自 HuggingFace 的展示中 [GGUF 仓库](https://huggingface.co/ngxson/Devstral-Small-Vision-2505-GGUF) 说明实际上是如何将 Mistral 3.1 Instruct 的视觉编码器“嫁接”到 Devstral 上的，这意味着你也可以对 Magistral 做同样的事！根据我们的测试以及很多用户反馈，它运行得相当不错！我们还上传了我们的 mmproj 文件，这让你可以使用以下内容：

<pre class="language-bash"><code class="lang-bash">./llama.cpp/llama-mtmd-cli \
    --model unsloth/Magistral-Small-2509-GGUF/Magistral-Small-2509-Q4_K_XL.gguf \
    --mmproj unsloth/Magistral-Small-2509-GGUF/mmproj-BF16.gguf \
    --ctx-size 40960 \
    <a data-footnote-ref href="#user-content-fn-1">--cache-type-k f16</a>
    --n-gpu-layers 99 \
    --seed 3407 \
    --prio 2 \
    --temp 0.7 \\
    --repeat-penalty 1.0 \
    --min-p 0.01 \
    --top-k -0 \
    --top-p 0.95 \
    --jinja
</code></pre>

## 🦥 使用 Unsloth 对 Magistral 进行微调

与包括 Mistral Small 3.1 在内的标准 Mistral 模型一样，Unsloth 也支持 Magistral 微调。训练速度快 2 倍，使用少 70% 的显存，并支持长 8 倍的上下文长度。Magistral 在 24GB 显存的 L4 GPU 上运行得很轻松。

* **Magistral 2509 Kaggle（2x Tesla T4）免费** [**微调笔记本**](https://www.kaggle.com/notebooks/welcome?src=https://github.com/unslothai/notebooks/blob/main/nb/Kaggle-Magistral_\(24B\)-Reasoning-Conversational.ipynb\&accelerator=nvidiaTeslaT4)
* Magistral 2509 Colab L4（24GB） [微调笔记本](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Magistral_\(24B\)-Reasoning-Conversational.ipynb)

Magistral 的内存占用略微超过 16GB 显存的限制，所以目前还不能在 Google Colab 上免费进行微调。不过，你 *可以* 可以使用以下方式免费微调该模型： [Kaggle](https://www.kaggle.com/danielhanchen/code)，它提供双 GPU 访问。

**如果想在新的推理轨迹上微调，你可以使用我们免费的** [**Magistral Kaggle 笔记本**](https://www.kaggle.com/notebooks/welcome?src=https://github.com/unslothai/notebooks/blob/main/nb/Kaggle-Magistral_\(24B\)-Reasoning-Conversational.ipynb\&accelerator=nvidiaTeslaT4)

```python
!pip install --upgrade unsloth
from unsloth import FastLanguageModel
import torch
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/Magistral-Small-2509-unsloth-bnb-4bit",
    max_seq_length = 2048,   # 上下文长度——可以更长，但会使用更多内存
    load_in_4bit = True,     # 4bit 占用更少内存
    load_in_8bit = False,    # 稍微更准确一些，但会使用 2x 内存
    full_finetuning = False, # 现在我们支持完整微调！
    device_map = "balanced", # 使用 2x Tesla T4
    # token = "hf_...",      # 如果使用受限模型，请使用这个
)
```

如果你使用的是旧版 Unsloth 和/或在本地微调，请安装最新版本的 Unsloth：

```
pip install --upgrade --force-reinstall --no-cache-dir unsloth unsloth_zoo
```

## :diamond\_shape\_with\_a\_dot\_inside:动态 Float8 检查点

我们也提供两种流行的 float8 检查点格式，这些格式还利用了我们的一些动态方法来保持最高准确率：

* [vLLM 的 Float8 格式](https://huggingface.co/unsloth/Magistral-Small-2509-FP8-Dynamic)
* [TorchAO 的 Float8 格式](https://huggingface.co/unsloth/Magistral-Small-2509-FP8-torchao)

两者都非常适合通过 vLLM 部署。阅读如何在 vLLM 中使用基于 TorchAO 的 FP8 量化 [这里](https://docs.vllm.ai/en/latest/features/quantization/torchao.html).

[^1]: 用于减少内存占用的 K 量化。可以是 f16、q8\_0、q4\_0

[^2]: 必须使用 --jinja 以启用系统提示


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://unsloth.ai/docs/zh/mo-xing/tutorials/magistral-how-to-run-and-fine-tune.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.