Deepseek本地化部署 返回首页

发表于 2025-03-10 | 本文共 3321 字

deepseek研究

本地大语言模型运行工具部署(Ollama)

以下是 Ollama 的部署安装步骤：

Windows 系统

  1. 下载安装包：从 Ollama 官网下载适用于 Windows 的安装包（.exe 格式）。
  2. 安装：
    • 通过命令安装（推荐）：以管理员身份运行 CMD，定位到 OllamaSetup.exe 所在的目录，执行以下命令（假设要安装到 D:\Net_Program\Net_Ollama 目录下）： 
        OllamaSetup.exe /DIR="D:\Net_Program\Net_Ollama"

      然后点击弹出的安装窗体界面中的 Install 按钮，等待安装完成。

    • 通过鼠标双击安装（不推荐）：直接双击安装包，点击 Install 按钮等待安装完成。
  3. 验证安装：在安装完成后，可以通过命令 ollama --version 验证是否安装成功。

Linux 系统

  1. 脚本安装：
    • 打开终端，执行以下命令下载安装脚本： 
        curl -fsSL https://ollama.com/install.sh | sh
    • 等待安装完成，安装脚本会自动下载所需的组件，并完成 Ollama 的安装与配置。
    • 安装完成后，可以通过以下命令启动 Ollama： 
        ollama serve
  2. 二进制安装：
    • 将 Ollama 的二进制文件下载到 PATH 中的目录： 
        sudo curl -L https://ollama.com/download/ollama-linux-amd64 -o /usr/bin/ollama
  sudo chmod +x /usr/bin/ollama
    • 将 Ollama 添加为自启动服务，为 Ollama 创建用户并创建服务文件： 
        sudo useradd -r -s /bin/false -m -d /usr/share/ollama ollama

      在 /etc/systemd/system/ollama.service 创建服务文件，内容如下：

        [Unit]
  Description=Ollama Service
  After=network-online.target

  [Service]
  ExecStart=/usr/bin/ollama serve
  User=ollama
  Group=ollama
  Restart=always
  RestartSec=3

  [Install]
  WantedBy=default.target
    • 设置开机自启动并启动 Ollama： 
        sudo systemctl daemon-reload
  sudo systemctl enable ollama
  sudo systemctl start ollama
  3. 安装特定版本：设置 OLLAMA_VERSION 字段，可以安装对应的版本。例如： 
     curl -fsSL https://ollama.com/install.sh | OLLAMA_VERSION=0.3.13 sh
  4. 查看日志：查看作为启动服务运行的 Ollama 的日志： 
     journalctl -e -u ollama
  5. 更新：通过以下命令更新 Ollama： 
     curl -fsSL https://ollama.com/install.sh | sh

    或者下载 Ollama 二进制文件：

     sudo curl -L https://ollama.com/download/ollama-linux-amd64 -o /usr/bin/ollama
 sudo chmod +x /usr/bin/ollama

注意事项

人工智能模型部署（DeepSeek）

以下是通过 Ollama 部署 DeepSeek 模型的详细步骤：

1. 下载 DeepSeek 模型

2. 运行模型

3. 其他注意事项

通过以上步骤，你可以在本地成功部署并使用 DeepSeek 模型。

人工智能桌面客户端应用部署

以下是关于人工智能桌面客户端应用 Chatbox 和 AnythingLLM 的部署指南：

Chatbox 部署指南

Chatbox 是一个用户友好的桌面客户端应用程序，支持多种大型语言模型（LLM），如 OpenAI、Ollama 等，并提供 Windows、MacOS、Linux、iOS 和 Android 版本。

安装步骤：

  1. 下载安装包：
    • 访问 Chatbox 官网，选择适合您操作系统的安装包进行下载。
    • 官网提供官方版和社区版，官方版更易于安装且功能更新。
  2. 安装：
    • 下载完成后，双击安装包并按照提示完成安装。
  3. 配置模型：
    • 打开 Chatbox 应用程序。
    • 在设置中选择 Ollama API，并配置已安装的模型（如 DeepSeek-R1）。
  4. 使用：
    • 配置完成后，即可在 Chatbox 中与选定的模型进行交互。

特点：

AnythingLLM Desktop部署指南

AnythingLLM 是一个开源的全栈应用程序，支持多种 LLM 和向量数据库，允许用户构建私有的 AI 系统。

安装步骤：

  1. 下载安装包：
  2. 安装：
    • 下载完成后，双击安装包并按照提示完成安装。
  3. 配置模型：
    • LLM 首选项：选择 Ollama 作为 LLM 提供商，确保本地 Ollama 模型已正常运行。
    • 向量数据库：选择默认的 LanceDB。
    • 嵌入偏好：安装并配置嵌入工具（如 nomic-embed-text）。
  4. 创建和使用工作区：
    • 启动 AnythingLLM 后，创建新的工作区并上传文档（如 PDF、TXT 等）。
    • 点击 Save and Embed，将文档嵌入到工作区。
    • 设置文档为当前对话的背景文档，即可开始与模型进行交互。

特点：

注意事项

AnythingLLM Docker部署指南

以下是使用 Docker 部署 AnythingLLM 的详细步骤：

1. 拉取 AnythingLLM 镜像

2. 设置存储路径

3. 运行 Docker 命令

4. 访问 AnythingLLM 应用

5. 配置 AnythingLLM

注意事项

通过以上步骤，您可以轻松部署 Chatbox 和 AnythingLLM，打造属于自己的 AI 桌面应用。

AnythingLLM 提供了两种主要的部署方式：桌面版（Desktop）和云版（Cloud）

以下是它们的主要区别和特点：

1. 桌面版（Desktop）

2. 云版（Cloud）

桌面版 vs 云版

| 特性 | 桌面版 | 云版 | |——|——–|——| | 部署方式 | 本地安装（Windows、MacOS、Linux） | Docker 部署、云平台部署 | | 功能支持 | 基础功能，适合个人使用 | 多用户支持、权限管理、嵌入式小部件 | | 数据隐私 | 数据完全本地化 | 数据存储灵活（本地或云端） | | 适用场景 | 个人知识管理、单机使用 | 企业级应用、多用户协作 | | 定制化能力 | 有限 | 高（支持 API 集成） |

总结

以下是基于 Docker 部署 Dify 的详细步骤，适用于私有化部署场景：

1. 前置条件

  1. 安装 Docker：
    • 根据您使用的操作系统（如 Windows、Linux、macOS），从 Docker 官网 下载并安装 Docker。
    • 确保 Docker 服务已启动且运行正常，可以通过命令 docker -v 验证。
  2. 安装 Git：
    • 确保系统已安装 Git，用于克隆 Dify 的源代码。
  3. 系统资源：
    • 确保服务器至少有 4GB 内存，建议分配更多资源以保证运行。

2. 部署步骤

步骤 1：克隆 Dify 源代码

git clone https://github.com/langgenius/dify.git
cd dify/docker

将 dify/docker 目录复制出来，方便后续操作：

cp -r dify/docker dify-docker
cd dify-docker

步骤 2：配置环境变量

复制环境变量配置文件：

cp .env.example .env

根据需要编辑 .env 文件，例如配置邮件服务（如 RESEND API）。

步骤 3：拉取镜像

运行以下命令拉取所需镜像：

docker-compose pull

如果拉取失败，可以手动逐个拉取所需镜像，例如：

docker pull langgenius/dify-api:0.15.3
docker pull langgenius/dify-web:0.15.3
docker pull postgres:15-alpine
docker pull redis:6-alpine

步骤 4：启动服务

根据您的 Docker Compose 版本，选择合适的命令启动服务：

# Docker Compose V2
docker compose up -d

# Docker Compose V1
docker-compose up -d

步骤 5：访问 Dify

启动完成后，通过浏览器访问 http://<服务器IP>:<端口>，例如 http://127.0.0.1:8001。

3. 配置 Dify

  1. 创建管理员账户：
    • 访问 Dify 的设置页面，创建管理员账户。
  2. 配置模型：
    • 在 Dify 中配置模型供应商（如 Ollama），并指定基础 URL（如 http://host.docker.internal:11434）。
  3. HTTPS 配置（可选）：
    • 如果需要启用 HTTPS，将 SSL 证书和私钥复制到 /dify/docker/nginx/ssl 目录，并编辑 docker-compose-template.yaml 文件。

4. 注意事项

  1. 镜像加速：
    • 如果在国内网络环境下拉取镜像失败，可以配置 Docker 镜像加速地址。
    • 修改 docker-compose.yaml 文件，添加国内镜像源。
  2. 版本选择：
    • 建议使用稳定版本（如 0.15.3），避免使用测试版本（如 1.0.0）。
  3. 资源限制：
    • 确保服务器资源充足，避免因资源不足导致服务运行异常。

通过以上步骤，您可以在服务器上通过 Docker 部署 Dify，实现私有化部署并支持多人使用。

本地知识库部署

以下是使用 AnythingLLM 搭建本地知识库的详细步骤：

  1. 配置 AnythingLLM：
    • 打开 AnythingLLM 应用程序，点击 Get Started。
    • 在 LLM 首选项 中选择 Ollama，并确保模型地址指向本地运行的 DeepSeek 模型（如 http://127.0.0.1:11434）。
    • 在 嵌入偏好 中选择默认的嵌入工具（如 nomic-embed-text）。
    • 在 向量数据库 中选择默认的 LanceDB。
  2. 创建工作区：
    • 在 AnythingLLM 中，点击 New Workspace，输入工作区名称（如 My Knowledge Base）。
    • 点击 Save 完成创建工作区。
  3. 上传文档：
    • 在工作区界面，点击 Upload 按钮。
    • 选择需要上传的文档（支持 PDF、TXT、DOCX 等格式）。
    • 点击 Save and Embed，系统将自动对文档进行切分和向量化处理。
  4. 设置背景文档：
    • 上传完成后，点击文档旁边的图钉按钮，将该文档设置为当前对话的背景文档。
  5. 与知识库对话：
    • 在工作区的输入框中输入问题，模型将根据上传的文档内容提供答案。
    • 您可以查看模型的推理过程和引用的文档。
  6. 多工作区管理：
    • 您可以创建多个工作区，每个工作区独立隔离。
    • 在不同工作区中上传不同的文档，实现知识库的分类管理。
  7. 调整聊天模式：
    • 在工作区设置中，调整 聊天提示 和 查询模式拒绝响应 的内容，以优化模型的回答。

通过以上步骤，您可以轻松搭建一个本地化的知识库，结合 DeepSeek 模型和 AnythingLLM 的强大功能，实现高效的文档管理和问答体验。

模型训练及微调

Unsloth部署

1. 下载 Miniconda 安装脚本

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh

2. 赋予安装脚本可执行权限

chmod +x Miniconda3-latest-Linux-x86_64.sh

3. 运行 Miniconda 安装脚本

./Miniconda3-latest-Linux-x86_64.sh

4. 配置环境变量

cat .bashrc
source .bashrc

5. 验证 Conda 安装

conda --version

6. 创建 Python 环境

conda create --name myenv python=3.11 -y

7. 激活环境

conda activate myenv

8. 安装常用库

conda install numpy pandas -y

9. 检查环境配置

9.1 检查 bitsandbytes

python -m bitsandbytes

9.2 检查 PyTorch 环境

python -m torch.utils.collect_env

9.3 检查 xformers

python -m xformers.info

10. 创建 Conda 环境

10.1 创建环境

conda create --name unsloth_env python=3.11 pytorch-cuda=12.1 pytorch torchvision torchaudio cudatoolkit=12.1 -c pytorch -c nvidia -y

conda create --name unsloth_env python=3.10 pytorch-cuda=11.8 pytorch cudatoolkit xformers -c pytorch -c nvidia -c xformers -y

10.2 激活环境

conda activate unsloth_env

11. 安装 Unsloth

11.1 使用自动安装脚本

wget -qO- https://raw.githubusercontent.com/unslothai/unsloth/main/unsloth/_auto_install.py | python -

11.2 手动安装 Unsloth

pip install --upgrade pip
pip install "unsloth[cu118-torch250] @ git+https://github.com/unslothai/unsloth.git"

11.3 简单安装 Unsloth

pip install unsloth

12. 验证安装

在完成安装后，可以通过以下命令验证 Unsloth 是否正确安装：

python -c "import unsloth; print(unsloth.__version__)"

Unsloth微调模型

# -*- coding: utf-8 -*-
"""
完整的 Unsloth 模型微调脚本
"""

import os
import torch
from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset

print(torch.cuda.is_available())
print(torch.cuda.get_device_name(0))

# 环境检查
def check_environment():
    if not torch.cuda.is_available():
        raise RuntimeError("CUDA is not available. Please ensure you have a compatible GPU.")
    print("CUDA is available. Proceeding with setup...")

# 加载预训练模型
def load_pretrained_model():
    print("Loading pre-trained model...")
    max_seq_length = 256  # 上下文长度
    load_in_4bit = True  # 使用 4 位量化
    model, tokenizer = FastLanguageModel.from_pretrained(
        model_name="/home/deepseek/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B",
        max_seq_length=max_seq_length,
        load_in_4bit=load_in_4bit
    )
    return model, tokenizer

# 添加 LoRA 适配器
def add_lora_adapter(model):
    print("Adding LoRA adapter to the model...")
    model = FastLanguageModel.get_peft_model(
        model,
        r=16,  # LoRA 的秩
        target_modules=[
            "q_proj", "k_proj", "v_proj", "o_proj",
            "gate_proj", "up_proj", "down_proj"
        ],
        lora_alpha=16,  # 缩放因子
        lora_dropout=0,  # Dropout 概率
        bias="none",  # 偏置设置
        use_gradient_checkpointing="unsloth",  # 使用梯度检查点
        random_state=3407  # 随机种子
    )
    return model

# 准备数据集
def prepare_dataset():
    print("Preparing dataset...")
    # 示例：加载 Hugging Face 数据集
    # 替换为你的数据集名称和字段名
    dataset = load_dataset("/home/deepseek/test/mydata", split="train")
    #dataset = dataset.map(lambda x: {"text": x["your_text_field"]})
    
    # 只保留 input 和 output
    #dataset = dataset.map(lambda x: {"text": f"{x['input']}\n{x['output']}"})
    return dataset

# 配置训练参数
def configure_trainer(model, tokenizer, dataset):
    print("Configuring trainer...")
    trainer = SFTTrainer(
        model=model,
        tokenizer=tokenizer,
        train_dataset=dataset,
        dataset_text_field="text",
        max_seq_length=256,
        dataset_num_proc=8,
        args=TrainingArguments(
            per_device_train_batch_size=4,
            gradient_accumulation_steps=8,
            warmup_steps=5,
            max_steps=60,
            learning_rate=2e-4,
            fp16=False,  # 如果你的硬件支持，可以使用 fp16
            logging_steps=10,
            optim="adamw_8bit",
            weight_decay=0.01,
            lr_scheduler_type="linear",
            seed=3407,
            output_dir="outputs"
        )
    )
    return trainer

# 微调模型
def fine_tune(trainer):
    print("Starting fine-tuning...")
    trainer.train()
    print("Fine-tuning completed.")

# 保存模型
def save_model(model, tokenizer):
    print("Saving the fine-tuned model...")
    model.save_pretrained("fine_tuned_model", tokenizer, save_method="merged_16bit")
    print("Model saved successfully.")

# 测试模型
def test_model(model, tokenizer):
    print("Testing the fine-tuned model...")
    inputs = tokenizer(["你的测试提示"], return_tensors="pt").to("cuda")
    outputs = model.generate(
        input_ids=inputs.input_ids,
        attention_mask=inputs.attention_mask,
        max_new_tokens=1200
    )
    response = tokenizer.batch_decode(outputs, skip_special_tokens=True)
    print("Model response:", response[0])

# 主函数
def main():
    # 检查环境
    check_environment()
    
    # 加载预训练模型
    model, tokenizer = load_pretrained_model()
    
    # 添加 LoRA 适配器
    model = add_lora_adapter(model)
    
    # 准备数据集
    dataset = prepare_dataset()
    
    # 配置训练器
    trainer = configure_trainer(model, tokenizer, dataset)
    
    # 微调模型
    fine_tune(trainer)
    
    # 保存模型
    save_model(model, tokenizer)
    
    # 测试模型
    test_model(model, tokenizer)

if __name__ == "__main__":
    main()

Llama-Factory 部署

    conda create -n llama_factory python=3.10
    conda activate llama_factory
    pip install torch==2.4.0 torchvision==0.19.0 torchaudio==2.4.0 --index-url https://download.pytorch.org/whl/cu121
    git clone --depth 1 https://github.com/hiyouga/LLaMA-Factory.git
    cd LLaMA-Factory
    pip install -e ".[torch,metrics]"
    conda activate llama_factory
    export USE_MODELSCOPE_HUB=1
    export CUDA_VISIBLE_DEVICES=0
    llamafactory-cli webui

以下是基于 LLaMA-Factory 的环境搭建和启动 Web UI 的详细步骤：

1. 创建 Conda 环境

conda create -n llama_factory python=3.10

解释：创建一个名为 llama_factory 的 Conda 环境，并指定 Python 版本为 3.10。这一步是为了隔离依赖，确保后续安装的包不会与系统中其他 Python 环境冲突。

2. 激活环境

conda activate llama_factory

解释：激活刚才创建的 llama_factory 环境。只有在激活该环境后，后续安装的包才会被正确安装到该环境中。

3. 安装 PyTorch 和相关依赖

pip install torch==2.4.0 torchvision==0.19.0 torchaudio==2.4.0 --index-url https://download.pytorch.org/whl/cu121

解释：

4. 克隆 LLaMA-Factory 代码库

git clone --depth 1 https://github.com/hiyouga/LLaMA-Factory.git

解释：

5. 进入代码目录

cd LLaMA-Factory

解释：进入 LLaMA-Factory 的代码目录，后续的安装和运行命令需要在这个目录下执行。

6. 安装 LLaMA-Factory 的依赖

pip install -e ".[torch,metrics]"

解释：

7. 再次激活环境（可选）

conda activate llama_factory

解释：虽然前面已经激活了环境，但有时在切换目录或执行某些命令后，可能需要再次确认环境处于激活状态。

8. 设置使用 ModelScope Hub

export USE_MODELSCOPE_HUB=1

解释：设置环境变量 USE_MODELSCOPE_HUB 为 1，表示启用 ModelScope Hub。这允许你从 ModelScope Hub 下载预训练模型和数据集，作为 Hugging Face 的替代方案。

9. 指定 CUDA 设备

export CUDA_VISIBLE_DEVICES=0

解释：设置环境变量 CUDA_VISIBLE_DEVICES 为 0，表示只使用第一个 GPU 设备（设备编号从 0 开始）。如果你有多个 GPU，可以通过修改编号选择其他设备。这一步确保了 PyTorch 只使用指定的 GPU，避免资源冲突。

10. 启动 LLaMA-Factory Web UI

llamafactory-cli webui

解释：运行 llamafactory-cli webui 命令启动 LLaMA-Factory 的 Web UI。这将启动一个基于 Gradio 的 Web 界面，允许你通过浏览器进行模型的微调、推理等操作。

注意事项

  1. 检查 CUDA 版本：确保你的系统中安装的 CUDA 版本与 PyTorch 的版本兼容。如果 CUDA 版本不匹配，可能会导致 PyTorch 无法正常运行。
  2. 网络问题：如果在安装过程中遇到网络问题（如无法访问 PyTorch 或 ModelScope 的镜像源），可以尝试更换为国内的镜像源，例如： 
    pip install torch==2.4.0 torchvision==0.19.0 torchaudio==2.4.0 --index-url https://mirror.tuna.tsinghua.edu.cn/pytorch/whl/cu121
  3. Web UI 访问：启动 Web UI 后，通常会在终端中显示一个本地访问地址（如 http://127.0.0.1:7860）。通过浏览器访问该地址即可进入 Web 界面。

以下是使用 LLaMA-Factory 的 Web UI 进行模型微调的详细步骤：

1. 启动 Web UI

在终端中运行以下命令启动 LLaMA-Factory 的 Web UI：

llamafactory-cli webui

如果需要从 ModelScope 魔搭社区下载模型，可在命令前设置环境变量：

USE_MODELSCOPE_HUB=1 llamafactory-cli webui

启动后，浏览器会自动打开 Web UI 页面，通常地址为 http://localhost:7860。

2. 选择模型和微调方法

3. 配置训练参数

4. 开始微调

5. 模型评估

6. 模型推理

注意事项

通过以上步骤，可以使用 LLaMA-Factory 的 Web UI 零代码微调大语言模型，并进行评估和推理。

命令行命令

 llamafactory-cli train     --stage pt     --do_train True     --model_name_or_path /home/deepseek/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B     --preprocessing_num_workers 1     --finetuning_type lora     --template deepseek3     --flash_attn auto     --dataset_dir /home/deepseek/test/data     --dataset my_dataset     --cutoff_len 256     --learning_rate 5e-05     --num_train_epochs 3.0     --max_samples 100000     --per_device_train_batch_size 2     --gradient_accumulation_steps 8     --lr_scheduler_type cosine     --max_grad_norm 1.0     --logging_steps 5     --save_steps 100     --warmup_steps 0     --packing True     --report_to none     --output_dir saves/DeepSeek-R1-1.5B-Distill/lora/train_2025-03-05-15-22-21     --bf16 True     --plot_loss True     --trust_remote_code True     --ddp_timeout 180000000     --include_num_input_tokens_seen True     --optim adamw_torch     --lora_rank 8     --lora_alpha 16     --lora_dropout 0     --lora_target all

模型准确性提升

提升大模型准确性的三种方法对比：提示词工程、知识库、微调

1. 提示词工程（Prompt Engineering）

提示词工程是指通过精心设计输入模型的提示（prompt），引导模型生成所需的输出。这种方法通过对提示词的优化，可以显著提高模型的准确性和响应质量，尤其在生成型任务中效果明显。

2. 知识库（Knowledge Base）

知识库是通过集成外部知识资源来丰富模型的知识面，从而提升模型在特定领域的准确性。通过将领域特定的知识、常识或实时数据嵌入到模型的输入或推理过程中，可以弥补模型的知识缺陷。

3. 微调（Fine-tuning）

微调是在已有的大规模预训练模型基础上，通过标注数据进行训练，进一步优化模型的表现，以适应特定任务或场景的需求。微调通过直接修改模型参数来优化模型能力，能够显著提升模型在特定任务中的表现。

3.1 全量微调与高效微调
3.2 高效微调方法

4. 高效微调的应用场景

5. 微调与强化学习训练、模型蒸馏等概念辨析

6. 三者对比总结

| 方法 | 优点 | 缺点 | 适用场景 | | — | — | — | — | | 提示词工程 | 快速、低成本、灵活 | 仅限于任务表层优化 | 文本生成、对话系统 | | 知识库 | 扩展知识面，动态更新 | 构建和维护成本高 | 问答系统、专业领域应用 | | 微调 | 深度定制，提升性能 | 需要大量数据和计算资源 | 分类、命名实体识别、专业领域 |

总结

根据任务需求，可以选择一种或多种方法结合使用，以达到最优效果。

本作品采用知识共享署名-非商业性使用-禁止演绎 4.0 国际许可协议进行许可。