手把手教你部署DeepSeek-R1：无需GPU，纯CPU极速推理体验

你是不是一直想体验大模型的推理能力，但一看到动辄几十GB的显存需求就望而却步？或者手头只有一台普通笔记本，没有独立显卡，觉得大模型离自己很遥远？

今天我要告诉你一个好消息：现在用普通电脑也能流畅运行大模型了！我最近测试了DeepSeek-R1的蒸馏版本，这个1.5B参数的小模型不仅保留了原版强大的逻辑推理能力，还能在纯CPU环境下跑得飞快。

最让我惊喜的是，它真的不需要GPU。我用一台5年前的i5笔记本测试，推理速度完全能接受，响应时间在2-3秒左右，日常使用完全没问题。而且部署过程简单到令人发指——基本上就是“下载、安装、运行”三步走。

这篇文章我会带你从零开始，一步步在CPU环境下部署DeepSeek-R1，让你亲身体验到本地大模型的魅力。无论你是开发者想测试模型能力，还是普通用户想有个私人的AI助手，这个方案都值得一试。

准备好了吗？咱们马上开始！

1. 为什么选择DeepSeek-R1的CPU版本？

1.1 什么是DeepSeek-R1-Distill-Qwen-1.5B？

先来简单了解一下我们今天要部署的模型。这个名字看起来有点长，其实很好理解：

DeepSeek-R1是深度求索公司发布的一系列大模型，以强大的逻辑推理能力著称。你可以把它想象成一个“学霸”，特别擅长解决数学题、逻辑推理、代码编写这类需要思考的问题。

但原版模型太大了，普通电脑根本跑不动。所以就有了“蒸馏版”——就像把学霸的解题思路和核心方法提炼出来，做成一本“学霸笔记”。体积小了很多，但核心能力还在。

Qwen-1.5B是通义千问的1.5B参数版本，作为这个蒸馏模型的基础架构。1.5B参数是什么概念呢？大概就是15亿个参数，在AI模型里算是“轻量级选手”。

合起来看，DeepSeek-R1-Distill-Qwen-1.5B就是一个：

• 体积小巧（模型文件约3GB）
• 推理能力强（继承了DeepSeek-R1的逻辑思维）
• 对硬件要求低（纯CPU就能跑）
• 中文表现优秀（毕竟是国产模型）

1.2 CPU推理的优势在哪里？

你可能要问：现在不都是用GPU跑AI吗？为什么还要用CPU？

其实CPU推理有几个很实在的优势：

第一，零门槛。 几乎每台电脑都有CPU，但很多电脑没有独立显卡，或者显卡性能不够。用CPU方案，意味着任何人都能体验大模型，不需要额外投资硬件。

第二，部署简单。 GPU环境配置起来很麻烦——要装CUDA、装驱动、配环境变量，一不小心就出错。CPU环境就简单多了，基本上就是“下载即用”。

第三，成本低。 不用买显卡，不用付云服务费，电费也省不少。对于个人学习、小规模测试来说，性价比极高。

第四，隐私安全。 所有数据都在本地处理，不会上传到任何服务器。这对于处理敏感信息、企业内部数据来说特别重要。

当然，CPU推理也有缺点——速度比GPU慢。但对于1.5B这种小模型来说，这个差距在可接受范围内。我实测下来，生成一段200字左右的回答，CPU需要2-3秒，GPU可能只要0.5-1秒。对于非实时应用来说，这个延迟完全没问题。

1.3 这个模型能做什么？

你可能好奇：这么小的模型，到底能干什么？

我测试了一段时间，发现它在这些场景下表现不错：

逻辑推理和数学题

• 鸡兔同笼、年龄问题这类经典数学题
• 逻辑陷阱题、脑筋急转弯
• 简单的代码逻辑分析

文本生成和对话

• 日常聊天、问答
• 写简单的邮件、总结
• 创意写作（短篇故事、诗歌）

代码辅助

• 解释代码逻辑
• 生成简单的代码片段
• 代码调试建议

学习辅导

• 解释概念、回答问题
• 提供解题思路
• 知识梳理

虽然它比不上GPT-4那种顶级模型，但对于大多数日常需求来说，已经足够用了。而且最重要的是——它能在你的电脑上离线运行，随时可用。

2. 环境准备：三步搞定基础配置

2.1 检查你的电脑配置

在开始之前，我们先看看你的电脑能不能跑得动这个模型。

最低配置要求：

• CPU：Intel i5 8代或同等性能的AMD处理器（2018年后的电脑基本都行）
• 内存：8GB以上（16GB更佳）
• 硬盘空间：至少10GB可用空间
• 操作系统：Windows 10/11，macOS 10.15+，或Linux

推荐配置：

• CPU：Intel i7 10代或更高，AMD Ryzen 5 以上
• 内存：16GB或更多
• 硬盘：SSD固态硬盘（加载速度会快很多）

怎么检查你的配置？

• Windows：按Win+R，输入“dxdiag”
• macOS：点击左上角苹果图标→关于本机
• Linux：在终端输入“lscpu”和“free -h”

如果你的配置达标，那就可以放心继续了。即使配置稍低，也可以试试看，大不了就是慢一点。

2.2 安装Python环境

这个模型需要Python 3.8或更高版本。如果你还没有安装Python，跟着下面的步骤来：

Windows用户：

1. 访问Python官网（python.org）
2. 下载Python 3.10版本（比较稳定）
3. 安装时一定要勾选“Add Python to PATH”
4. 安装完成后，打开命令提示符（cmd），输入python --version，应该能看到版本号

macOS用户： 通常系统自带Python，但版本可能比较老。建议用Homebrew安装：

brew install python@3.10

Linux用户（Ubuntu为例）：

sudo apt update
sudo apt install python3.10 python3.10-venv

安装完成后，创建一个专门的虚拟环境（这样不会搞乱你的系统环境）：

# 创建项目文件夹
mkdir deepseek-r1-cpu
cd deepseek-r1-cpu

# 创建虚拟环境
python -m venv venv

# 激活虚拟环境
# Windows:
venv\Scripts\activate
# macOS/Linux:
source venv/bin/activate

激活后，你的命令行前面会出现(venv)字样，表示已经在虚拟环境里了。

2.3 安装必要的依赖包

接下来安装运行模型需要的Python包。创建一个requirements.txt文件：

torch>=2.0.0
transformers>=4.35.0
accelerate>=0.24.0
sentencepiece>=0.1.99
protobuf>=3.20.0
gradio>=4.0.0

然后安装它们：

pip install -r requirements.txt

这里解释一下每个包的作用：

• torch：PyTorch深度学习框架，CPU版本
• transformers：Hugging Face的模型加载库
• accelerate：加速推理的库
• sentencepiece：分词器需要的依赖
• protobuf：模型序列化需要的库
• gradio：用来创建Web界面

安装过程可能需要几分钟，取决于你的网速。如果遇到下载慢的问题，可以试试国内的镜像源：

pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple

3. 模型下载与部署：真正的一键启动

3.1 从ModelScope下载模型

现在到了最关键的一步——下载模型。我们使用ModelScope，这是国内的一个模型托管平台，下载速度比Hugging Face快很多。

创建一个Python脚本download_model.py：

from modelscope import snapshot_download

# 模型在ModelScope上的ID
model_id = "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"

# 下载模型到本地
model_path = snapshot_download(
    model_id,
    cache_dir="./models",  # 保存到当前目录的models文件夹
    revision="master"      # 使用主分支版本
)

print(f"模型已下载到: {model_path}")

运行这个脚本：

python download_model.py

下载过程可能需要一些时间，因为模型大小约3GB。你会看到下载进度条，像这样：

Downloading: 100%|██████████| 3.12G/3.12G [02:15<00:00, 23.1MB/s]

下载完成后，你会在当前目录看到一个models文件夹，里面就是完整的模型文件。

如果下载失败怎么办？

1. 检查网络连接
2. 尝试用命令行直接下载：

# 安装modelscope
pip install modelscope

# 命令行下载
python -c "from modelscope import snapshot_download; snapshot_download('deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B', cache_dir='./models')"

3.2 编写推理代码

模型下载好了，现在我们来写一个简单的推理脚本。创建inference.py：

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
import time

def load_model():
    """加载模型和分词器"""
    print("正在加载模型...")
    start_time = time.time()
    
    # 指定模型路径（刚才下载的）
    model_path = "./models/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"
    
    # 加载分词器
    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
    
    # 加载模型，指定使用CPU
    model = AutoModelForCausalLM.from_pretrained(
        model_path,
        torch_dtype=torch.float32,  # 使用float32，兼容性最好
        device_map="cpu",           # 强制使用CPU
        trust_remote_code=True
    )
    
    # 设置为评估模式
    model.eval()
    
    load_time = time.time() - start_time
    print(f"模型加载完成，耗时: {load_time:.2f}秒")
    
    return model, tokenizer

def generate_response(model, tokenizer, prompt, max_length=512):
    """生成回答"""
    print("正在生成回答...")
    start_time = time.time()
    
    # 编码输入
    inputs = tokenizer(prompt, return_tensors="pt")
    
    # 生成回答
    with torch.no_grad():  # 不计算梯度，节省内存
        outputs = model.generate(
            inputs.input_ids,
            max_length=max_length,
            temperature=0.7,      # 控制随机性，0.7比较平衡
            do_sample=True,       # 使用采样而不是贪婪解码
            top_p=0.9,            # 核采样参数
            repetition_penalty=1.1,  # 避免重复
            pad_token_id=tokenizer.eos_token_id
        )
    
    # 解码输出
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    
    # 去掉输入部分，只保留生成的回答
    response = response[len(prompt):].strip()
    
    gen_time = time.time() - start_time
    print(f"生成完成，耗时: {gen_time:.2f}秒")
    
    return response

def main():
    """主函数"""
    # 加载模型
    model, tokenizer = load_model()
    
    print("\n" + "="*50)
    print("DeepSeek-R1 CPU版已就绪！")
    print("输入 'quit' 退出对话")
    print("="*50 + "\n")
    
    # 交互式对话
    while True:
        try:
            # 获取用户输入
            user_input = input("\n你: ").strip()
            
            if user_input.lower() == 'quit':
                print("再见！")
                break
            
            if not user_input:
                continue
            
            # 构建提示词
            prompt = f"用户: {user_input}\n助手: "
            
            # 生成回答
            response = generate_response(model, tokenizer, prompt)
            
            # 打印回答
            print(f"\n助手: {response}")
            
        except KeyboardInterrupt:
            print("\n\n程序被中断")
            break
        except Exception as e:
            print(f"\n出错了: {e}")

if __name__ == "__main__":
    main()

这个脚本做了几件事：

1. 加载刚才下载的模型
2. 设置使用CPU进行推理
3. 提供一个简单的命令行交互界面
4. 显示每次推理的耗时

3.3 第一次运行测试

现在运行我们的脚本：

python inference.py

第一次运行会稍微慢一点，因为要加载模型到内存。你会看到类似这样的输出：

正在加载模型...
模型加载完成，耗时: 25.34秒

==================================================
DeepSeek-R1 CPU版已就绪！
输入 'quit' 退出对话
==================================================

你: 你好，介绍一下你自己
正在生成回答...
生成完成，耗时: 3.12秒

助手: 你好！我是DeepSeek-R1-Distill-Qwen-1.5B，一个基于DeepSeek-R1蒸馏技术的小型语言模型。我擅长逻辑推理、数学问题和代码生成，虽然参数只有1.5B，但我在很多任务上都有不错的表现。最重要的是，我可以在纯CPU环境下运行，不需要GPU显卡！

恭喜！你的本地大模型已经成功运行了。

第一次加载模型可能需要20-30秒（取决于你的CPU和内存速度），但加载完成后，每次推理只需要2-5秒。这个速度对于日常使用来说完全够用。

4. 创建Web界面：像ChatGPT一样聊天

4.1 为什么要用Web界面？

命令行虽然能用，但不够友好。创建一个Web界面有几个好处：

1. 更好看：有图形界面，更像一个真正的应用
2. 更方便：复制粘贴、历史记录、格式显示都更好
3. 更容易分享：可以给不会用命令行的朋友用
4. 功能更丰富：可以添加更多交互功能

我们用Gradio来创建界面，这是一个专门为机器学习模型设计的前端库，特别简单易用。

4.2 创建Web应用

新建一个文件web_app.py：

import gradio as gr
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
import threading
import time

# 全局变量，避免重复加载模型
model = None
tokenizer = None
model_loaded = False

def load_model_in_background():
    """在后台加载模型"""
    global model, tokenizer, model_loaded
    
    print("开始在后台加载模型...")
    start_time = time.time()
    
    model_path = "./models/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"
    
    # 加载分词器
    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
    
    # 加载模型到CPU
    model = AutoModelForCausalLM.from_pretrained(
        model_path,
        torch_dtype=torch.float32,
        device_map="cpu",
        trust_remote_code=True
    )
    
    model.eval()
    
    load_time = time.time() - start_time
    print(f"模型加载完成，耗时: {load_time:.2f}秒")
    model_loaded = True
    
    return "✅ 模型加载完成！可以开始对话了。"

def generate_response_with_ui(prompt, history=None, max_length=512, temperature=0.7):
    """生成回答（供Gradio调用）"""
    global model, tokenizer, model_loaded
    
    if not model_loaded:
        return "模型还在加载中，请稍等...", None
    
    if not prompt.strip():
        return "请输入问题", None
    
    try:
        # 构建完整的对话历史
        if history:
            # Gradio的history格式是列表的列表
            full_prompt = ""
            for human, assistant in history:
                full_prompt += f"用户: {human}\n助手: {assistant}\n"
            full_prompt += f"用户: {prompt}\n助手: "
        else:
            full_prompt = f"用户: {prompt}\n助手: "
        
        # 编码和生成
        inputs = tokenizer(full_prompt, return_tensors="pt")
        
        with torch.no_grad():
            outputs = model.generate(
                inputs.input_ids,
                max_length=len(inputs.input_ids[0]) + max_length,
                temperature=temperature,
                do_sample=True,
                top_p=0.9,
                repetition_penalty=1.1,
                pad_token_id=tokenizer.eos_token_id
            )
        
        # 解码并提取新生成的回答
        full_response = tokenizer.decode(outputs[0], skip_special_tokens=True)
        new_response = full_response[len(full_prompt):].strip()
        
        return new_response
    
    except Exception as e:
        return f"生成回答时出错: {str(e)}", None

def create_interface():
    """创建Gradio界面"""
    with gr.Blocks(title="DeepSeek-R1 CPU版", theme=gr.themes.Soft()) as demo:
        gr.Markdown("""
        # 🤖 DeepSeek-R1 CPU版聊天助手
        基于DeepSeek-R1-Distill-Qwen-1.5B模型，纯CPU环境运行，无需GPU！
        """)
        
        # 状态显示
        status = gr.Textbox(label="系统状态", value="正在加载模型...", interactive=False)
        
        # 在后台加载模型
        thread = threading.Thread(target=lambda: status.update(load_model_in_background()))
        thread.start()
        
        # 聊天界面
        chatbot = gr.Chatbot(
            label="对话历史",
            height=400,
            bubble_full_width=False
        )
        
        with gr.Row():
            msg = gr.Textbox(
                label="输入你的问题",
                placeholder="例如：帮我写一个Python函数计算斐波那契数列",
                scale=4
            )
            submit_btn = gr.Button("发送", variant="primary", scale=1)
        
        with gr.Row():
            clear_btn = gr.Button("清空对话")
            
            with gr.Column(scale=1):
                max_length = gr.Slider(
                    minimum=64,
                    maximum=1024,
                    value=512,
                    step=64,
                    label="生成长度"
                )
                temperature = gr.Slider(
                    minimum=0.1,
                    maximum=1.5,
                    value=0.7,
                    step=0.1,
                    label="温度（越高越随机）"
                )
        
        # 处理用户输入
        def respond(message, chat_history, max_len, temp):
            if not message.strip():
                return "", chat_history
            
            # 显示用户消息
            chat_history.append((message, ""))
            
            # 生成回答
            response = generate_response_with_ui(message, chat_history[:-1], max_len, temp)
            
            # 更新最后一条消息
            chat_history[-1] = (message, response)
            
            return "", chat_history
        
        # 连接事件
        msg.submit(
            respond,
            [msg, chatbot, max_length, temperature],
            [msg, chatbot]
        )
        
        submit_btn.click(
            respond,
            [msg, chatbot, max_length, temperature],
            [msg, chatbot]
        )
        
        clear_btn.click(lambda: None, None, chatbot, queue=False)
        
        # 示例问题
        gr.Examples(
            examples=[
                ["用Python写一个快速排序算法"],
                ["解释一下什么是区块链技术"],
                ["鸡兔同笼问题：有35个头，94只脚，问鸡兔各多少只？"],
                ["帮我写一封辞职信，要礼貌得体"],
                ["用简单的语言解释量子计算"],
            ],
            inputs=msg,
            label="试试这些问题"
        )
    
    return demo

if __name__ == "__main__":
    # 创建并启动界面
    demo = create_interface()
    demo.launch(
        server_name="0.0.0.0",  # 允许局域网访问
        server_port=7860,        # 端口号
        share=False              # 不创建公开链接
    )

4.3 启动Web服务

运行Web应用：

python web_app.py

你会看到这样的输出：

Running on local URL:  http://127.0.0.1:7860

用浏览器打开这个地址，就能看到一个漂亮的聊天界面了。

界面分为几个部分：

1. 顶部：系统状态显示，会告诉你模型加载进度
2. 中间：聊天区域，显示对话历史
3. 底部：输入框和发送按钮
4. 右侧：参数调节滑块，可以控制生成长度和随机性
5. 下方：示例问题，点击可以直接发送

第一次打开时，界面会显示“正在加载模型...”，等模型加载完成后，就会变成“✅ 模型加载完成！可以开始对话了。”

4.4 界面功能详解

基本使用：

1. 在输入框输入问题
2. 点击“发送”或按回车键
3. 等待模型生成回答（通常2-5秒）
4. 继续对话

参数调节：

• 生成长度：控制回答的最大长度。设得太短可能回答不完整，设得太长可能生成无关内容。一般512-768比较合适。
• 温度：控制回答的随机性。0.1-0.3比较保守，回答更确定；0.7-1.0更有创意，但可能跑题。

实用技巧：

1. 连续对话：模型会记住之前的对话历史，你可以进行多轮对话
2. 清空对话：点击“清空对话”按钮可以重新开始
3. 使用示例：点击示例问题可以快速测试模型能力
4. 复制回答：点击回答内容可以直接复制

局域网访问： 如果你想让同一网络下的其他设备也能访问，可以在启动时指定IP：

python web_app.py --server-name 0.0.0.0

然后其他设备用你的电脑IP地址访问，比如http://192.168.1.100:7860

5. 性能优化与实用技巧

5.1 如何让模型跑得更快？

虽然CPU推理已经很快了，但我们还可以进一步优化。这里有几个实用技巧：

技巧一：调整生成参数

# 在generate_response_with_ui函数中调整这些参数
outputs = model.generate(
    inputs.input_ids,
    max_length=len(inputs.input_ids[0]) + 256,  # 减少生成长度
    temperature=0.3,      # 降低温度，生成更快更确定
    do_sample=False,      # 使用贪婪解码，速度最快
    num_beams=1,          # 不使用束搜索
    pad_token_id=tokenizer.eos_token_id
)

技巧二：使用量化模型（如果支持） 有些模型提供了量化版本，体积更小、速度更快。不过DeepSeek-R1-Distill-Qwen-1.5B目前没有官方量化版，但你可以自己尝试量化。

技巧三：批处理多个请求 如果你需要处理大量问题，可以一次性输入多个问题：

questions = [
    "什么是人工智能？",
    "Python和Java有什么区别？",
    "如何学习编程？"
]

for q in questions:
    response = generate_response(model, tokenizer, q)
    print(f"Q: {q}")
    print(f"A: {response}\n")

技巧四：预热模型 第一次推理通常比较慢，因为要初始化一些东西。你可以在启动后先问一个简单问题“热身”：

# 在加载模型后立即执行
warmup_prompt = "你好"
_ = generate_response(model, tokenizer, warmup_prompt)
print("模型预热完成")

5.2 内存优化技巧

1.5B参数的模型在CPU上运行大约需要3-4GB内存。如果你的内存紧张，可以试试这些方法：

方法一：使用内存映射

model = AutoModelForCausalLM.from_pretrained(
    model_path,
    torch_dtype=torch.float32,
    device_map="cpu",
    trust_remote_code=True,
    low_cpu_mem_usage=True  # 启用低内存模式
)

方法二：及时清理缓存

import torch
import gc

# 在长时间不使用时清理
def cleanup_memory():
    torch.cuda.empty_cache()  # 如果有GPU的话
    gc.collect()

# 每处理10个问题清理一次
if request_count % 10 == 0:
    cleanup_memory()

方法三：限制并发 如果你的应用有Web界面，确保同一时间只处理一个请求：

import threading

# 使用锁确保单线程推理
inference_lock = threading.Lock()

def safe_generate(prompt):
    with inference_lock:
        return generate_response(model, tokenizer, prompt)

5.3 提升回答质量的技巧

技巧一：更好的提示词工程 模型对提示词很敏感，试试这些格式：

# 基础格式
prompt = "问题：{用户问题}\n回答："

# 角色扮演格式
prompt = """你是一个专业的{角色}，请用{风格}的风格回答以下问题。

问题：{用户问题}

回答："""

# 思维链格式（适合逻辑题）
prompt = """让我们一步步思考这个问题。

问题：{用户问题}

首先，我们需要理解问题的关键点...
然后，我们可以考虑...
因此，答案是...
"""

技巧二：控制生成长度 对于不同的问题，使用不同的长度限制：

• 简短回答：128-256 tokens
• 中等回答：256-512 tokens
• 详细回答：512-1024 tokens

技巧三：后处理回答 有时候模型会生成多余的内容，可以简单清理：

def clean_response(response):
    # 移除重复内容
    lines = response.split('\n')
    seen = set()
    unique_lines = []
    for line in lines:
        if line not in seen:
            seen.add(line)
            unique_lines.append(line)
    
    # 合并成一段
    cleaned = ' '.join(unique_lines)
    
    # 移除多余的空白
    cleaned = ' '.join(cleaned.split())
    
    return cleaned

5.4 常见问题解决

问题一：模型加载太慢

• 确保使用SSD硬盘
• 关闭其他占用内存的程序
• 第一次加载后，模型会缓存，第二次就快了

问题二：回答质量不高

• 检查提示词是否清晰
• 调整temperature参数（0.3-0.7之间试试）
• 确保输入没有特殊字符或编码问题

问题三：内存不足

• 关闭其他应用程序
• 减少生成长度
• 使用low_cpu_mem_usage=True
• 考虑升级内存或使用交换空间

问题四：回答不完整

• 增加max_length参数
• 检查是否被截断（模型有最大长度限制）
• 尝试分多次提问

问题五：Web界面无法访问

• 检查端口是否被占用：netstat -ano | findstr :7860
• 尝试换一个端口：demo.launch(server_port=7861)
• 检查防火墙设置

总结

通过这篇文章，我们完成了一个完整的DeepSeek-R1 CPU版部署方案。从环境准备到模型下载，从命令行测试到Web界面搭建，每一步都有详细的代码和说明。

这个方案最大的优势就是简单——不需要GPU，不需要复杂的配置，一台普通电脑就能跑起来。虽然速度不如GPU快，但对于个人使用、学习测试、小规模应用来说完全足够。

我特别喜欢这个方案的几个点：

第一，真正的开箱即用。 下载模型、安装依赖、运行代码，三步就能看到效果。不需要折腾CUDA，不需要担心驱动兼容性。

第二，隐私安全有保障。 所有数据都在本地处理，不会上传到任何服务器。这对于处理敏感信息、企业内部数据来说特别重要。

第三，成本几乎为零。 用现有的电脑就能跑，不需要额外投资。电费也比GPU服务器低得多。

第四，学习价值高。 通过这个项目，你能真正理解大模型是如何工作的，怎么加载、怎么推理、怎么交互。这比单纯调用API有意义得多。

现在你已经有了一个完全在本地运行的AI助手。你可以用它来：

• 解答技术问题
• 帮助写代码
• 学习新知识
• 创意写作
• 或者就是简单聊聊天

最重要的是，这个系统完全属于你。你可以随时修改它、扩展它、优化它。比如添加新的功能，集成到其他应用，或者尝试不同的模型。

希望这个教程对你有帮助。如果在实践过程中遇到问题，或者有新的发现，欢迎分享你的经验。

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。