[ 首页] | [🤖 与 DeepSeek Coder 聊天] | [🤗 模型下载] | [Discord] | [WeChat (微信)]

论文链接👁️

---

1. DeepSeek Coder 简介

DeepSeek Coder 是一系列从头开始训练的代码语言模型，总共使用了 2T 的数据进行训练，其中 87% 是代码，13% 是自然语言，涵盖英语和中文两种语言。我们提供了多种规模的代码模型，从 1B 到 33B 不等。每个模型都基于项目级别的代码语料库进行预训练，采用了 16K 的窗口大小以及额外的填空任务，以支持项目级别的代码补全和修复。在编码能力方面，DeepSeek Coder 在多个编程语言和各类基准测试中均达到了开源代码模型中的最先进水平。

• 海量训练数据：从头开始训练，使用了 2T 的数据，其中包括 87% 的代码和 13% 的语言数据，覆盖英语和中文。

• 高度灵活且可扩展：提供 1B、5.7B、6.7B 和 33B 四种模型规模，用户可以根据自身需求选择最适合的配置。

• 卓越的模型性能：在 HumanEval、MultiPL-E、MBPP、DS-1000 和 APPS 等公开可用的代码模型基准测试中，性能处于领先地位。

• 先进的代码补全能力：采用 16K 的窗口大小和填空任务，支持项目级别的代码补全和修复。

支持的编程语言

['ada', 'agda', 'alloy', 'antlr', 'applescript', 'assembly', 'augeas', 'awk', 'batchfile', 'bluespec', 'c', 'c-sharp', 'clojure', 'cmake', 'coffeescript', 'common-lisp', 'cpp', 'css', 'cuda', 'dart', 'dockerfile', 'elixir', 'elm', 'emacs-lisp', 'erlang', 'f-sharp', 'fortran', 'glsl', 'go', 'groovy', 'haskell', 'html', 'idris', 'isabelle', 'java', 'java-server-pages', 'javascript', 'json', 'julia', 'jupyter-notebook', 'kotlin', 'lean', 'literate-agda', 'literate-coffeescript', 'literate-haskell', 'lua', 'makefile', 'maple', 'markdown', 'mathematica', 'matlab', 'ocaml', 'pascal', 'perl', 'php', 'powershell', 'prolog', 'protocol-buffer', 'python', 'r', 'racket', 'restructuredtext', 'rmarkdown', 'ruby', 'rust', 'sas', 'scala', 'scheme', 'shell', 'smalltalk', 'solidity', 'sparql', 'sql', 'stan', 'standard-ml', 'stata', 'systemverilog', 'tcl', 'tcsh', 'tex', 'thrift', 'typescript', 'verilog', 'vhdl', 'visual-basic', 'xslt', 'yacc', 'yaml', 'zig']

2. 评估结果

我们在多个与编码相关的基准测试上对 DeepSeek Coder 进行了评估。 此处仅报告 HumanEval（Python 和多语言）、MBPP 以及 DS-1000 上的 pass@1 结果：

结果显示，DeepSeek-Coder-Base-33B 显著优于现有的开源代码大模型。与 CodeLlama-34B 相比，在 HumanEval Python、HumanEval 多语言、MBPP 和 DS-1000 上分别领先 7.9%、9.3%、10.8% 和 5.9%。令人惊讶的是，我们的 DeepSeek-Coder-Base-7B 已经达到了 CodeLlama-34B 的性能水平。而经过指令微调后的 DeepSeek-Coder-Instruct-33B 模型，在 HumanEval 上的表现超越了 GPT35-turbo，而在 MBPP 上则与之不相上下。

更多评估细节请参见 详细评估结果。

3. 数据构建与模型训练流程

数据构建

• 步骤 1：从 GitHub 收集代码数据，并应用与 StarCoder Data 相同的过滤规则来清理数据。
• 步骤 2：解析同一仓库内文件之间的依赖关系，根据依赖顺序重新排列文件位置。
• 步骤 3：将相互依赖的文件拼接成一个完整的示例，并使用仓库级别的 minhash 进行去重。
• 步骤 4：进一步过滤掉低质量的代码，例如存在语法错误或可读性较差的代码。

模型训练

• 步骤 1：初始预训练阶段使用的数据集中包含 87% 的代码、10% 的代码相关语言（如 GitHub Markdown 和 StackExchange）以及 3% 的非代码相关中文语言。在此步骤中，模型使用 1.8T 的数据和 4K 的窗口大小进行预训练。
• 步骤 2：进一步使用 200B 的数据进行扩展的 16K 窗口大小预训练，最终得到基础模型（DeepSeek-Coder-Base）。
• 步骤 3：使用 2B 的指令数据进行指令微调，从而得到指令微调后的模型（DeepSeek-Coder-Instruct）。

4. 使用方法

在开始之前，您需要安装必要的依赖项。可以通过运行以下命令来完成：

pip install -r requirements.txt

此外，在 🤗 Hugging Face Space 上也提供了一个演示，您也可以使用 demo 文件夹中的 app.py 在本地运行该演示。（感谢 HF 团队的所有支持）

以下是关于我们模型的一些使用示例。

1) 代码补全

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/deepseek-coder-6.7b-base", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/deepseek-coder-6.7b-base", trust_remote_code=True, torch_dtype=torch.bfloat16).cuda()
input_text = "#write a quick sort algorithm"
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_length=128)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

这段代码将输出以下结果：

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[0]
    left = []
    right = []
    for i in range(1, len(arr)):
        if arr[i] < pivot:
            left.append(arr[i])
        else:
            right.append(arr[i])
    return quick_sort(left) + [pivot] + quick_sort(right)

2) 代码插入

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/deepseek-coder-6.7b-base", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/deepseek-coder-6.7b-base", trust_remote_code=True, torch_dtype=torch.bfloat16).cuda()
input_text = """<｜fim▁begin｜>def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[0]
    left = []
    right = []
<｜fim▁hole｜>
        if arr[i] < pivot:
            left.append(arr[i])
        else:
            right.append(arr[i])
    return quick_sort(left) + [pivot] + quick_sort(right)<｜fim▁end｜>"""
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_length=128)
print(tokenizer.decode(outputs[0], skip_special_tokens=True)[len(input_text):])

这段代码将输出以下结果：

   for i in range(1, len(arr)):

3) 聊天模型推理

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/deepseek-coder-6.7b-instruct", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/deepseek-coder-6.7b-instruct", trust_remote_code=True, torch_dtype=torch.bfloat16).cuda()
messages=[
    { 'role': 'user', 'content': "write a quick sort algorithm in python."}
]
inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt").to(model.device)
# tokenizer.eos_token_id 是 <|EOT|> 标记的 ID
outputs = model.generate(inputs, max_new_tokens=512, do_sample=False, top_k=50, top_p=0.95, num_return_sequences=1, eos_token_id=tokenizer.eos_token_id)
print(tokenizer.decode(outputs[0][len(inputs[0]):], skip_special_tokens=True))

这段代码将输出以下结果：

当然，这里有一个简单的 Python 快速排序算法实现：

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    else:
        pivot = arr[0]
        less_than_pivot = [x for x in arr[1:] if x <= pivot]
        greater_than_pivot = [x for x in arr[1:] if x > pivot]
        return quick_sort(less_than_pivot) + [pivot] + quick_sort(greater_than_pivot)

# 测试函数
arr = [10, 7, 8, 9, 1, 5]
print("原始数组:", arr)
print("排序后的数组:", quick_sort(arr))

这段代码通过选择数组中的一个“基准”元素，并根据其与基准的关系将其他元素分为两组：小于基准和大于基准。然后，基准元素就位于其最终位置上。接下来，对这两组分别重复上述过程。

如果您不想使用提供的 API apply_chat_template，它会从 tokenizer_config.json 中加载模板，那么您可以使用以下模板与我们的模型进行对话。将 ['content'] 替换为您的指令以及模型之前的回复（如果有的话），模型就会针对当前给出的指令生成回复。

你是一位 AI 编程助手，使用由 DeepSeek 公司开发的 DeepSeek Coder 模型，只回答与计算机科学相关的问题。对于政治敏感问题、安全与隐私问题以及其他非计算机科学类问题，你将拒绝回答。
### 指令：
['content']
### 回答：
['content']
<|EOT|>
### 指令：
['content']
### 回答：

4) 仓库级别的代码补全

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/deepseek-coder-6.7b-base", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/deepseek-coder-6.7b-base", trust_remote_code=True, torch_dtype=torch.bfloat16).cuda()

input_text = """#utils.py
import torch
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score

def load_data():
    iris = datasets.load_iris()
    X = iris.data
    y = iris.target

    # 数据标准化
    scaler = StandardScaler()
    X = scaler.fit_transform(X)

    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

    # 将 numpy 数据转换为 PyTorch 张量
    X_train = torch.tensor(X_train, dtype=torch.float32)
    X_test = torch.tensor(X_test, dtype=torch.float32)
    y_train = torch.tensor(y_train, dtype=torch.int64)
    y_test = torch.tensor(y_test, dtype=torch.int64)

    return X_train, X_test, y_train, y_test

def evaluate_predictions(y_test, y_pred):
    return accuracy_score(y_test, y_pred)

# model.py
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

class IrisClassifier(nn.Module):
    def __init__(self):
        super(IrisClassifier, self).__init__()
        self.fc = nn.Sequential(
            nn.Linear(4, 16),
            nn.ReLU(),
            nn.Linear(16, 3)
        )

    def forward(self, x):
        return self.fc(x)

    def train_model(self, X_train, y_train, epochs, lr, batch_size):
        criterion = nn.CrossEntropyLoss()
        optimizer = optim.Adam(self.parameters(), lr=lr)

        # 创建数据加载器以进行批次处理
        dataset = TensorDataset(X_train, y_train)
        dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

        for epoch in range(epochs):
            for batch_X, batch_y in dataloader:
                optimizer.zero_grad()
                outputs = self(batch_X)
                loss = criterion(outputs, batch_y)
                loss.backward()
                optimizer.step()

    def predict(self, X_test):
        with torch.no_grad():
            outputs = self(X_test)
            _, predicted = outputs.max(1)
        return predicted.numpy()


# main.py
from utils import load_data, evaluate_predictions
from model import IrisClassifier as Classifier

def main():
    # 模型训练和评估
"""
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=140)
print(tokenizer.decode(outputs[0]))

---

在以下场景中，DeepSeek-Coder-6.7B模型能够有效地调用model.py文件中的IrisClassifier类及其成员函数，并使用utils.py文件中的函数，从而正确完成main.py文件中的主函数，实现模型的训练与评估。

5. 如何微调 DeepSeek-Coder

我们提供了脚本 finetune/finetune_deepseekcoder.py，供用户在其下游任务上对我们的模型进行微调。

该脚本支持使用 DeepSpeed 进行训练。您需要通过以下命令安装所需的依赖包：

pip install -r finetune/requirements.txt

请按照 样本数据集格式 准备您的训练数据。每行应为一个 JSON 序列化的字符串，包含两个必填字段：instruction 和 output。

数据准备完成后，您可以使用示例 Shell 脚本来微调 deepseek-ai/deepseek-coder-6.7b-instruct。请务必指定 DATA_PATH 和 OUTPUT_PATH，并根据您的具体情况选择合适的超参数（例如：learning_rate、per_device_train_batch_size）。

DATA_PATH="<your_data_path>"
OUTPUT_PATH="<your_output_path>"
MODEL="deepseek-ai/deepseek-coder-6.7b-instruct"

cd finetune && deepspeed finetune_deepseekcoder.py \
    --model_name_or_path $MODEL_PATH \
    --data_path $DATA_PATH \
    --output_dir $OUTPUT_PATH \
    --num_train_epochs 3 \
    --model_max_length 1024 \
    --per_device_train_batch_size 16 \
    --per_device_eval_batch_size 1 \
    --gradient_accumulation_steps 4 \
    --evaluation_strategy "no" \
    --save_strategy "steps" \
    --save_steps 100 \
    --save_total_limit 100 \
    --learning_rate 2e-5 \
    --warmup_steps 10 \
    --logging_steps 1 \
    --lr_scheduler_type "cosine" \
    --gradient_checkpointing True \
    --report_to "tensorboard" \
    --deepspeed configs/ds_config_zero3.json \
    --bf16 True

6. 详细评估结果

以下评估结果的可复现代码可在 Evaluation 目录中找到。

1) 多语言 HumanEval 基准测试

2) MBPP 基准测试

3) DS-1000 基准测试

4) Program-Aid 数学推理基准测试

使用 vLLM 进行推理

您也可以使用 vLLM 进行高吞吐量推理。

文本补全

from vllm import LLM, SamplingParams

tp_size = 4 # 张量并行度
sampling_params = SamplingParams(temperature=0.7, top_p=0.9, max_tokens=100)
model_name = "deepseek-ai/deepseek-coder-6.7b-base"
llm = LLM(model=model_name, trust_remote_code=True, gpu_memory_utilization=0.9, tensor_parallel_size=tp_size)

prompts = [
    "如果一个国家的所有人都彼此相爱，",
    "研究还应关注那些技术，",
    "为了确定标签是否正确，我们需要"
]
outputs = llm.generate(prompts, sampling_params)

generated_text = [output.outputs[0].text for output in outputs]
print(generated_text)

聊天补全

from transformers import AutoTokenizer
from vllm import LLM, SamplingParams

tp_size = 4 # 张量并行度
sampling_params = SamplingParams(temperature=0.7, top_p=0.9, max_tokens=100)
model_name = "deepseek-ai/deepseek-coder-6.7b-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
llm = LLM(model=model_name, trust_remote_code=True, gpu_memory_utilization=0.9, tensor_parallel_size=tp_size)

messages_list = [
    [{"role": "user", "content": "你是谁？"}],
    [{"role": "user", "content": "你能做什么？"}],
    [{"role": "user", "content": "请简要解释一下 Transformer。"}],
]
prompts = [tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False) for messages in messages_list]

sampling_params.stop = [tokenizer.eos_token]
outputs = llm.generate(prompts, sampling_params)

generated_text = [output.outputs[0].text for output in outputs]
print(generated_text)

7. 问答

是否可以提供用于模型量化的 tokenizer.model 文件？

DeepSeek Coder 使用 HuggingFace Tokenizer 实现 Bytelevel-BPE 算法，并设计了特殊的预分词器以确保最佳性能。目前尚无直接方法将该分词器转换为 SentencePiece 格式。我们正在致力于开源量化方法，以促进 HuggingFace Tokenizer 的应用。

GGUF (llama.cpp)

我们已向流行的量化库 llama.cpp 提交了一个 PR，旨在全面支持所有 HuggingFace 预分词器，包括我们的预分词器。

在 PR 合并之前，您可以通过以下步骤生成自己的 GGUF 模型：

git clone https://github.com/DOGEwbx/llama.cpp.git
cd llama.cpp
git checkout regex_gpt2_preprocess
# 按照 README 设置环境
make
python3 -m pip install -r requirements.txt
# 生成 GGUF 模型
python convert-hf-to-gguf.py <MODEL_PATH> --outfile <GGUF_PATH> --model-name deepseekcoder

# 以 q4_0 量化为例
./quantize <GGUF_PATH> <OUTPUT_PATH> q4_0
./main -m <OUTPUT_PATH> -n 128 -p <PROMPT>

GPTQ(exllamav2)

更新：exllamav2 已经支持 Huggingface Tokenizer。请拉取最新版本并尝试使用。

请注意，为了获得正确的输出，需将 RoPE 缩放因子设置为 4，更多讨论可参见此 PR。

如何使用 DeepSeek-Coder-Instruct 完成代码？

尽管 DeepSeek-Coder-Instruct 模型在监督微调（SFT）过程中并未专门针对代码补全任务进行训练，但它们仍然具备高效执行代码补全的能力。要启用此功能，只需调整 eos_token_id 参数即可。将 eos_token_id 设置为 32014，而不是 DeepSeek-Coder-Instruct 配置中的默认值 32021。这一修改会促使模型以不同的方式识别序列的结束，从而更好地支持代码补全任务。

8. 资源

awesome-deepseek-coder 是一份关于 DeepSeek Coder 的开源项目精选列表。

9. 许可证

本代码仓库采用 MIT 许可证。DeepSeek Coder 模型的使用则受模型许可证约束。DeepSeek Coder 支持商业用途。

更多详情请参阅 LICENSE-CODE 和 LICENSE-MODEL。

10. 引用

@misc{deepseek-coder,
  author = {郭达亚、朱启浩、杨德健、谢振达、董凯、张文涛、陈冠廷、毕晓、吴Y、李YK、罗富利、熊英飞、梁文峰},
  title = {DeepSeek-Coder：当大型语言模型遇见编程——代码智能的崛起},
  journal = {CoRR},
  volume = {abs/2401.14196},
  year = {2024},
  url = {https://arxiv.org/abs/2401.14196},
}

11. 联系方式

如有任何问题，请提交 Issue 或发送邮件至 service@deepseek.com。

DeepSeek-Coder 快速上手指南

DeepSeek-Coder 是由深度求索（DeepSeek）推出的一系列代码语言模型，支持 80+ 种编程语言。该模型在 2T token 数据上从头训练（含 87% 代码和 13% 自然语言），提供从 1B 到 33B 多种尺寸版本，具备卓越的项目级代码补全、填空及指令遵循能力。

1. 环境准备

在开始之前，请确保您的开发环境满足以下要求：

• 操作系统: Linux (推荐) 或 Windows/macOS
• Python: 3.8 及以上版本
• GPU: 推荐使用 NVIDIA GPU 并安装 CUDA 驱动
  • 运行 6.7B 模型建议显存 ≥ 16GB (使用 bfloat16 精度)
  • 运行 33B 模型建议显存 ≥ 48GB (或使用多卡/量化方案)
• 前置依赖:
  • torch (建议 2.0+)
  • transformers (建议 4.35+)
  • accelerate

2. 安装步骤

方法一：通过 requirements.txt 安装（推荐）

如果您已克隆官方仓库，请直接运行：

pip install -r requirements.txt

方法二：手动安装核心依赖

若未克隆仓库，可直接安装必要的 Python 包。国内用户建议使用清华或阿里镜像源加速下载：

pip install torch transformers accelerate -i https://pypi.tuna.tsinghua.edu.cn/simple

注意：首次加载模型时会自动从 Hugging Face 下载权重。国内网络若连接缓慢，建议配置 Hugging Face 镜像环境变量：

export HF_ENDPOINT=https://hf-mirror.com

3. 基本使用

DeepSeek-Coder 提供两种主要类型的模型：

• Base 版 (-base): 适用于代码补全 (Completion) 和代码填空 (Infilling)。
• Instruct 版 (-instruct): 适用于对话交互和指令遵循 (Chat)。

以下是最简单的使用示例（以 6.7B 模型为例）：

场景一：代码补全 (Code Completion)

适用于根据注释或上下文生成后续代码。

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# 加载 Base 模型
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/deepseek-coder-6.7b-base", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/deepseek-coder-6.7b-base", trust_remote_code=True, torch_dtype=torch.bfloat16).cuda()

input_text = "#write a quick sort algorithm"
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)

# 生成代码
outputs = model.generate(**inputs, max_length=128)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

场景二：代码填空 (Code Insertion)

适用于在现有代码中间插入缺失逻辑（使用 <｜fim▁begin｜>, <｜fim▁hole｜>, <｜fim▁end｜> 标记）。

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/deepseek-coder-6.7b-base", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/deepseek-coder-6.7b-base", trust_remote_code=True, torch_dtype=torch.bfloat16).cuda()

input_text = """<｜fim▁begin｜>def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[0]
    left = []
    right = []
<｜fim▁hole｜>
        if arr[i] < pivot:
            left.append(arr[i])
        else:
            right.append(arr[i])
    return quick_sort(left) + [pivot] + quick_sort(right)<｜fim▁end｜>"""

inputs = tokenizer(input_text, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_length=128)

# 仅输出填充部分
print(tokenizer.decode(outputs[0], skip_special_tokens=True)[len(input_text):])

场景三：对话模式 (Chat / Instruct)

适用于向模型提问或请求编写完整功能模块。

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# 加载 Instruct 模型
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/deepseek-coder-6.7b-instruct", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/deepseek-coder-6.7b-instruct", trust_remote_code=True, torch_dtype=torch.bfloat16).cuda()

messages = [
    { 'role': 'user', 'content': "write a quick sort algorithm in python."}
]

# 应用对话模板
inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt").to(model.device)

outputs = model.generate(
    inputs, 
    max_new_tokens=512, 
    do_sample=False, 
    top_k=50, 
    top_p=0.95, 
    num_return_sequences=1, 
    eos_token_id=tokenizer.eos_token_id
)

print(tokenizer.decode(outputs[0][len(inputs[0]):], skip_special_tokens=True))