系列篇章💥

No.	文章
01	【DeepSeek应用实践】DeepSeek接入Word、WPS方法详解：无需代码，轻松实现智能办公助手功能
02	【DeepSeek应用实践】通义灵码 + DeepSeek：AI 编程助手的实战指南
03	【DeepSeek应用实践】Cline集成DeepSeek：开源AI编程助手，终端与Web开发的超强助力
04	【DeepSeek开发入门】DeepSeek API 开发初体验
05	【DeepSeek开发入门】DeepSeek API高级开发指南（推理与多轮对话机器人实践）
06	【DeepSeek开发入门】Function Calling 函数功能应用实战指南
07	【DeepSeek部署实战】DeepSeek-R1-Distill-Qwen-7B：本地部署与API服务快速上手
08	【DeepSeek部署实战】DeepSeek-R1-Distill-Qwen-7B：Web聊天机器人部署指南
09	【DeepSeek部署实战】DeepSeek-R1-Distill-Qwen-7B：基于vLLM 搭建高性能推理服务器
10	【DeepSeek部署实战】基于Ollama快速部署DeepSeek-R1系列模型实战指南（Linux）
11	【DeepSeek部署实战】基于Ollama+Chatbox零成本部署DeepSeek-R1系列模型攻略（Windows）
12	【DeepSeek开发实战】DeepSeek-R1-Distill-Qwen与LangChain的本地大模型应用开发指南

---

---

前言

在人工智能飞速发展的当下，大语言模型成为了众多领域创新的关键驱动力。DeepSeek-R1系列模型凭借其卓越的性能和独特的技术优势，在国产推理模型中脱颖而出，备受关注。本文将详细介绍如何通过Ollama这一便捷工具，快速实现DeepSeek-R1系列模型的部署，为开发者提供全面且实用的实战指南。

一、DeepSeek-R1特性解析

DeepSeek-R1作为对标OpenAI-o1的国产推理模型，展现出了令人瞩目的实力，尤其在数学推导、代码生成、逻辑推理等复杂场景中表现优异。其核心创新之处体现在以下多个方面：

1. 双重架构支持
   DeepSeek-R1提供了原生大模型与蒸馏模型双路线。原生大模型能够充分发挥其强大的计算和推理能力，为对性能要求极高的场景提供有力支持；而蒸馏模型则在保持一定性能的前提下，通过优化结构和参数，更加轻量化，适用于资源受限的环境。这种双重架构设计，使得开发者可以根据不同的应用需求和硬件条件，灵活选择合适的模型版本。
2. 知识蒸馏技术
   该模型运用了先进的知识蒸馏技术，通过70B大模型生成高质量的推理数据，然后将这些知识成功压缩至1.5B - 70B多规格的模型中。这一过程不仅减少了模型的参数量，降低了计算复杂度，还能在较小规模的模型中保留大模型的关键知识和能力，从而实现了模型性能和资源消耗之间的良好平衡。
3. 跨框架兼容
   基于Llama/Qwen双生态，DeepSeek-R1实现了模型蒸馏。这意味着它能够充分利用Llama和Qwen生态系统中的丰富资源和技术优势，进一步提升模型的性能和适应性。无论是在Llama生态的应用场景中，还是在Qwen生态的开发环境下，DeepSeek-R1都能表现出色，为开发者提供了更多的选择和便利。
4. 商用友好
   DeepSeek-R1系列模型遵循MIT许可证，这使得它对商业应用非常友好，支持二次开发与商业部署。企业和开发者可以在遵循许可证的前提下，自由地对模型进行定制和优化，将其应用于各种商业场景中，推动业务的创新和发展。

二、为什么选择 Ollama？

Ollama 是一款专为简化大语言模型的部署和管理而设计的开源工具。它通过高效的本地缓存机制和自动化的模型下载功能，极大地降低了部署复杂性，使得用户能够在本地轻松运行和管理多种高性能语言模型。无论是个人开发者还是企业用户，Ollama 都提供了简单易用的安装流程和灵活的使用方式，支持跨平台运行（包括 Windows、macOS 和 Linux），并兼容多种主流语言模型，包括DeepSeek 系列。通过 Ollama，用户可以快速启动模型推理任务，同时享受高性能和低延迟的交互体验，让大语言模型的使用变得更加高效和便捷。

三、环境准备

使用 Ubuntu 22.04 LTS 操作系统、Python 3.12 环境、CUDA 12.1 与 PyTorch 2.3.0，以及 24GB GPU。

1. 安装Ollama

Linux一键安装：在Linux系统中，只需在终端中执行以下命令，即可完成Ollama的一键安装：

curl -fsSL https://ollama.com/install.sh | sh

2. 启动服务

安装完成后，在终端中执行以下命令启动Ollama服务：

ollama serve

启动服务后，Ollama将在本地运行，并监听默认端口，等待接收模型部署和推理请求。

四、模型部署全流程

1. 基础模型部署

在Ollama中部署DeepSeek-R1系列的基础模型非常简单，只需执行相应的命令即可。

ollama run deepseek-r1:7b

当模型部署成功后，即可与模型进行交互。

2. 蒸馏模型部署指南

DeepSeek-R1系列的蒸馏模型根据不同的规格和适用场景，提供了多种选择。以下是不同模型规格的详细信息和部署命令：

模型规格	基础架构	适用场景	部署命令
轻量级(1.5B)	Qwen-2.5	移动端/边缘计算	ollama run deepseek-r1:1.5b
平衡型(7B)	Qwen-2.5	本地开发环境	ollama run deepseek-r1:7b
高性能(70B)	Llama3.3	服务器集群	ollama run deepseek-r1:70b

轻量级的1.5B模型基于Qwen-2.5架构，非常适合资源有限的移动端或边缘计算设备，能够在这些设备上实现快速的推理和响应；平衡型的7B模型同样基于Qwen-2.5架构，适用于本地开发环境，在性能和资源消耗之间达到了较好的平衡；高性能的70B模型基于Llama3.3架构，主要面向服务器集群，能够充分发挥其强大的计算能力，满足大规模、高并发的推理需求。
其他版本部署示例：

五、应用案例实践

1. 文本生成

场景描述：假设需要AI帮忙撰写一篇作文
提示词：请帮我编写一篇400字小作文，我今年10岁

>>> 请帮我编写一篇400字小作文，我今年10岁
<think>
嗯，用户让我帮他写一篇400字的小作文，说他今年10岁。首先，我需要确定他的真实需求是什么。可能是一个家长或者老师在帮助孩子完成作业。

年龄只有10岁，所以作文不能太复杂，语言要简单明了，内容适合他的理解水平。他可能想要表达对童年的感受，或者分享一个有趣的事情。

考虑到字数限制，400字左右，得结构清晰，有开头、中间和结尾。或许可以从一个具体的事件入手，比如过生日、玩耍的经历，或者学习新东西的过程。

为了让作文更生动，可以加入一些细节描写，比如天气、人物的动作或表情，这样会更有画面感。同时，情感表达要真挚，表现出童年的纯真和快乐。

最后，确保语言流畅，没有语法错误，并且符合小学生的写作水平。这样写出来的作文既满足字数要求，又能传达出他真实的情感。
</think>

## 我的小秘密花园

今天是妈妈给我买的一个特别的生日礼物——一个小小的花园。

这个花园只有我的手掌那么大，我把它放在窗台上。春天来得不算早，但妈妈说已经种好了喜欢看花的人。于是，我每天放学回家都会来看看这个小花园的变化。

花园里种了几株小花，有红色的、黄色的、还有白色的。每当我走过时，它们都在微风中轻轻摇曳，仿佛在跟我打招呼。阳光透过窗户洒进来，照在这些小花上，显得格外 bright and 
cheerful.

我最喜欢的是那几株紫色的小花。它们看起来像是穿上了蝴蝶结一样漂亮。每到周末，我都会给它们浇水。看着这些小生命慢慢长大，我觉得特别开心。

上周，我在看护花园的时候发现了一株奇怪的小草。它的根部不像其他植物那么整齐，还总是朝向一边生长。后来我才听说，这是妈妈特意从一个不知名的地方带回来的。现在，它已经长
成了一个小苗，但它的根部却像一根真正的蛇一样扭曲着。

看到这株特别的小苗，我的心里突然涌上一股说不出的感觉。也许这就是成长的意义吧——即使有些东西看起来不太完美，也要坚持努力生长下去。我决定把这个小秘密一直好好照顾好，让
它也长成一个小小的花园。

这就是我的小秘密花园，一个充满希望的地方。每天放学回家，看着它在阳光下慢慢长大，我就感觉特别幸福。

2. 数学计算

场景描述：假设需要解决一个复杂的数学问题，例如计算一个二次方程的解。
提示词：请解方程：x² -5x +6=0

>>> 请解方程：x² -5x +6=0
<think>
首先，我观察到这是一个二次方程 \( x^2 - 5x + 6 = 0 \)，可以使用因式分解的方法来求解。

接下来，我会将常数项6分解成两个数的乘积，并使这两个数的和等于一次项的系数-5。经过尝试，发现3和2满足这些条件：\( 3 \times 2 = 6 \) 和 \( 3 + 2 = 5 \)。

然后，我将方程写成因式分解的形式：\( (x - 3)(x - 2) = 0 \)。

最后，根据零乘积性质，令每个因子等于零，得到两个解：\( x = 3 \) 和 \( x = 2 \)。
</think>

要解方程 \( x^2 - 5x + 6 = 0 \)，我们可以使用因式分解法。以下是详细的步骤：

1. **将方程写成标准形式：**
   \[
   x^2 - 5x + 6 = 0
   \]

2. **因式分解：**
   
   我们需要找到两个数，它们的乘积是6（常数项），且和是-5（一次项系数）。这两个数是-3和-2。
   
   因此，方程可以分解为：
   \[
   (x - 3)(x - 2) = 0
   \]

3. **应用零乘积性质：**
   
   如果两个因子的乘积等于零，那么每个因子至少有一个等于零。因此：
   \[
   x - 3 = 0 \quad \text{或} \quad x - 2 = 0
   \]
   
4. **求解方程：**
   
   解这两个简单的方程得到：
   \[
   x = 3 \quad \text{或} \quad x = 2
   \]

**最终答案：**

\[
\boxed{x = 2 \text{ 或 } 3}
\]

3. 代码编写

场景描述：假设需要编写一个简单的 Python 程序，利用堆排序获取TOP N的数据。
提示词：请编写一个 Python 程序，利用堆排序获取TOP N的数据。请提供完整的代码实现。

>>> 请编写一个 Python 程序，利用堆排序获取TOP N的数据。请提供完整的代码实现
<think>
嗯，我现在需要写一个Python程序来使用堆排序获取前N大的数据。我之前学过一点堆排序，记得堆有两种类型：最大堆和最小堆。那么，如果我要找前N大的数，应该用哪种堆呢？

我想应该是最大堆吧？因为这样堆顶就是最大的那个元素。那然后我需要将数组转换成一个大根堆，对吗？那Python中有没有默认的堆模块呢？是heapq库，可以实现堆的操作。

那么步骤大概是这样的：首先读取输入的数据，比如一个列表。然后将其转换为最大堆。然后每次取出最大的元素，重复N次。这样就能得到前N大的数据了。

不过等一下，Python中的heapq模块默认实现的是最小堆，那如何得到最大堆呢？我记得可以通过取反的方式来处理数值。也就是将每个元素乘以-1，然后构建堆，这样堆顶的元素就是最小
值，但其实对应原数组的最大值。对吗？

比如，假设我有一个数组nums。那么我可以做这样的处理：neg_nums = [-x for x in nums]，然后用heapify来建立最小堆。这样堆中的第一个元素是这些负数中最小的那个，也就是原数
组最大的那个对应的负数。

那接下来，进行N次堆操作。每次取出堆顶的元素（即最大的那个），然后把它放回去，或者不放回去？这里可能需要重新调整堆结构。

或者，更准确地说，在第一次弹出之后，我们需要将堆重新构建为最大堆吗？或者说heapq提供了一个heappop函数，可以弹出最小值。那在构造最大堆的情况下，使用这个函数会得到原数
组中的最大的元素。

所以，步骤应该是：

1. 将所有数据转换成负数，并用heapify生成一个最小堆。
2. 进行N次heappop操作，每次得到当前最大的元素（因为它们是按原数值排序的）。
3. 每次弹出之后，将结果存储到结果列表中。
4. 最终的结果列表就是前N大的元素。

那这样的话，代码的大致结构应该是：

- 导入heapq模块
- 读取输入数据，转换为列表nums
- 将nums中的所有数取反，得到neg_nums
- 调用heapify来生成堆结构
- 初始化结果列表result为空
- 循环N次：
   - 弹出最小的负数（即最大的原数）
   - 添加到result中
   - 重新调整堆结构？
或者，在弹出之后，不需要重新调整，因为heapq模块的函数会自动处理？

哦，对了，每次调用heappop之后，堆会自动调整。但是，当N次操作后，堆中的元素会被弹出全部吗？比如，假设原始数组有M个元素，且M >= N，那么这不会有问题。

那举个例子：假设nums = [3,1,4,2]，n=2.

转换为负数列表是[-3,-1,-4,-2]. heapify之后堆的结构是什么呢？最小的负数是-4。弹出后得到的是最大的原数值4吗？

不，等一下，原数组中最大值应该是4对吧？所以第一次弹出得到4，添加到result。

然后剩下的元素包括3,1,2中的一个最大值是3。那第二次弹出会是3吗？

那结果列表会是[4,3]，这是正确的前两大的数。

那代码的大致结构应该没有问题。

那么，在Python中具体的实现步骤：

- 导入heapq。
- 读取输入的数据：可能需要用input()函数多次获取每一行的数值，或者使用sys.stdin来读取所有数据。例如，nums = list(map(int, input().split()))可能会遇到多行的情况吗？比
如，用户输入的数据是多个数字在一行中的话就不用问题；如果是多行，那么需要合并处理。

假设输入是一行多个数字，那可以用input().split()然后转换成整数列表。或者，如果数据量很大，可以读取所有行并处理。

举个例子：

nums = list(map(int, input().split()))

if not nums:
    print("Please enter numbers.")
else:
    # proceed

这样是不是有问题？比如，如果用户输入的是空的话？

那假设现在我们已经获取了nums列表。然后将它们转换成负数列表，并建立堆。

neg_nums = [-x for x in nums]
heapq.heapify(neg_nums)

result = []
for _ in range(n):
    largest = -heapq.heappop(neg_nums)
    result.append(largest)

这样得到的result就是前N大的元素吗？

但是，这个结果是否排序呢？比如，假设n=3，得到的是最大的、第二大的、第三大的元素。那result列表中是这些数值，但顺序是什么样的？因为它们被弹出的顺序是从大到小，所以
result列表已经是按从大到小排列的。

如果需要将这些数按照降序排序输出，或者升序，那需要根据需求处理结果列表。

比如，在上面的例子中，nums = [3,1,4,2], n=2。弹出后得到的是4和3吗？是的，因为堆的结构被正确维护。

所以代码的大致框架应该是这样的：

import heapq

nums = list(map(int, input().split()))
n = int(input())

if not nums or n <= 0:
    print("Please enter valid numbers and a positive integer for n.")
else:
    neg_nums = [-x for x in nums]
    heapq.heapify(neg_nums)
    result = []
    for _ in range(n):
        largest = -heapq.heappop(neg_nums)
        result.append(largest)
    print("Top N elements:", result)

等等，这样对吗？或者，在Python中，当n的值超过数组长度的时候会如何处理？

比如，如果nums只有5个元素，而n=6。那代码将尝试弹出堆中的元素，但堆已经被初始化为size=len(nums)，所以调用heappop 6次会导致IndexError。

所以需要确保输入时，n不超过len(nums)吗？或者在程序中进行检查？

比如，在else块中添加一个条件：

if n > len(nums):
    print("N cannot be larger than the number of elements.")
    exit()

这样处理是否正确呢？

那现在代码的大致结构是这样的：

import heapq

nums = list(map(int, input().split()))
n = int(input())

if not nums or n <= 0:
    print("Please enter valid numbers and a positive integer for n.")
else:
    if n > len(nums):
        print("N cannot be larger than the number of elements.")
        exit()
    
    neg_nums = [-x for x in nums]
    heapq.heapify(neg_nums)
    result = []
    for _ in range(n):
        largest = -heapq.heappop(neg_nums)
        result.append(largest)
    print("Top N elements:", result)

那这样是否正确？

让我测试一下。

比如，测试案例：

输入：6个数，5 4 3 2 1 0。n=3.

转换为负数是-5,-4,-3,-2,-1,0. 堆的结构会被heapify处理成最小堆吗？假设Python中的heapq模块已经正确维护了这个。

第一次弹出：最小的-5，即原数组的最大值5被添加到result中。然后将堆调整为剩下的元素[-4,-3,-2,-1,0]。此时堆顶是-4（因为heapify后是最小堆）。

第二次弹出：得到4吗？或者是不是会更复杂？

那结果应该是5、4、3，对吗？

运行一下程序：

nums = [5,4,3,2,1,0]
n=3

转换为负数列表是[-5,-4,-3,-2,-1,0]

heapify之后，堆的结构可能有不同的表现。然后弹出三次。

第一次：-5被弹出，得到5。堆剩下五个元素：[-4,-3,-2,-1,0] → heapified后的最小值应该是-4吗？

第二次弹出：-4→4。堆剩下四个元素：[-3,-2,-1,0].

第三次弹出：-3 → 3.

所以结果列表是[5,4,3]. 是正确的。

那这样代码是对的。

那么，现在的问题是什么？编写这样的Python程序是否正确？

另一个测试案例：

输入：nums = [7,9,6], n=2

转换成负数：[-7,-9,-6]

heapify后堆顶是-9。弹出得到9→加入结果。剩下的列表是[-7,-6].

第二次弹出：-7→7. 结果是[9,7]. 正确。

那代码是正确的吗？

看起来是对的。
</think>

为了获取前N大的数据，可以利用最大堆（通过取反将最小堆转换为最大堆）的方法。以下是完整的Python代码实现：

\```python
import heapq

nums = list(map(int, input().split()))
n = int(input())

if not nums or n <= 0:
    print("Please enter valid numbers and a positive integer for n.")
else:
    if n > len(nums):
        print("N cannot be larger than the number of elements.")
        exit()
    
    neg_nums = [-x for x in nums]
    heapq.heapify(neg_nums)
    result = []
    for _ in range(n):
        largest = -heapq.heappop(neg_nums)
        result.append(largest)
    print("Top N elements:", result)
\```

**步骤解释：**

1. **读取输入数据：**
   - 从标准输入读取一行数字，作为数组 `nums`。
   - 读取第二个整数，表示要获取的前N个最大值。

2. **输入验证：**
   - 检查 `nums` 是否为空或 `n` 是否为非正数，显示提示信息并退出程序。
   - 检查 `n` 是否大于数组长度，若超过则显示提示信息并退出。

3. **转换为最大堆：**
   - 将数组中的每个元素取反，得到负数列表 `neg_nums`。
   - 调用 `heapq.heapify(neg_nums)` 函数，将负数列表转换为最小堆。由于原始数据已经被取反，这个最小堆实际上对应了原数组的最大堆。

4. **提取前N个最大值：**
   - 初始化一个空列表 `result` 来存储结果。
   - 在循环中进行 N 次操作：
     - 每次调用 `heapq.heappop(neg_nums)` 弹出最小的负数（即原数组中的最大值）。
     - 将弹出的负数值取反，添加到 `result` 列表中。

5. **输出结果：**
   - 打印存储在 `result` 中的前N个最大值。这些值已经按从大到小的顺序排列。

该程序通过将数组转换为最大堆，利用堆结构高效地提取最大的元素，确保了在 O(N log N) 的时间复杂度内完成任务。

总结

通过本文的详细介绍，相信开发者已经掌握了基于Ollama快速部署DeepSeek-R1系列模型的方法和技巧，以及在部署和使用过程中需要注意的各种事项。希望开发者能够充分利用DeepSeek-R1系列模型的优势，结合Ollama的便捷工具，开发出更多创新的应用，推动人工智能技术在各个领域的广泛应用和发展。

🎯🔖更多专栏系列文章：AI大模型提示工程完全指南、AI大模型探索之路（零基础入门）、AI大模型预训练微调进阶、AI大模型开源精选实践、AI大模型RAG应用探索实践🔥🔥🔥 其他专栏可以查看博客主页📑

😎 作者介绍：资深程序老猿，从业10年+、互联网系统架构师，目前专注于AIGC的探索（CSDN博客之星|AIGC领域优质创作者）
📖专属社群：欢迎关注【小兵的AI视界】公众号或扫描下方👇二维码，回复‘入群’ 即刻上车，获取邀请链接。
💘领取三大专属福利：1️⃣免费赠送AI+编程📚500本，2️⃣AI技术教程副业资料1套，3️⃣DeepSeek资料教程1套🔥（限前500人）
如果文章内容对您有所触动，别忘了点赞、⭐关注，收藏！加入我们，一起携手同行AI的探索之旅，开启智能时代的大门！