# CodeLlama

{% hint style="info" %}
**更新的替代方案！** 对于编码任务，请考虑 [**Qwen2.5-Coder**](https://docs.clore.ai/guides/guides_v2-zh/yu-yan-mo-xing/qwen25) （32B，最先进的代码生成）或 [**DeepSeek-R1**](https://docs.clore.ai/guides/guides_v2-zh/yu-yan-mo-xing/deepseek-r1) （推理 + 编码）。CodeLlama 对于轻量部署仍然有用。
{% endhint %}

使用 Meta 的 CodeLlama 生成、补全和解释代码。

{% hint style="success" %}
所有示例都可以在通过以下方式租用的 GPU 服务器上运行： [CLORE.AI 市场](https://clore.ai/marketplace).
{% endhint %}

## 在 CLORE.AI 上租用

1. 访问 [CLORE.AI 市场](https://clore.ai/marketplace)
2. 按 GPU 类型、显存和价格筛选
3. 选择 **按需** （固定费率）或 **竞价** （出价价格）
4. 配置您的订单：
   * 选择 Docker 镜像
   * 设置端口（用于 SSH 的 TCP，Web 界面的 HTTP）
   * 如有需要，添加环境变量
   * 输入启动命令
5. 选择支付方式： **CLORE**, **BTC**，或 **USDT/USDC**
6. 创建订单并等待部署

### 访问您的服务器

* 在以下位置查找连接详情： **我的订单**
* Web 界面：使用 HTTP 端口的 URL
* SSH： `ssh -p <port> root@<proxy-address>`

## 1024x1024

| A100          | 规模  | 显存    | 最适合  |
| ------------- | --- | ----- | ---- |
| CodeLlama-7B  | 7B  | 8GB   | 快速补全 |
| CodeLlama-13B | 13B | 16GB  | 平衡   |
| CodeLlama-34B | 34B | 40GB  | 最佳质量 |
| CodeLlama-70B | 70B | 80GB+ | 最高质量 |

### 变体

* **基础版**: 代码补全
* **指令版**: 遵循指令
* **Python**: 专注于 Python

## 快速部署

**Docker 镜像：**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime
```

**端口：**

```
22/tcp
8000/http
```

**命令：**

```bash
pip install vllm && \
python -m vllm.entrypoints.openai.api_server \
    --model codellama/CodeLlama-7b-Instruct-hf \
    --port 8000
```

## 访问您的服务

部署后，在以下位置查找您的 `http_pub` URL： **我的订单**:

1. 前往 **我的订单** 页面
2. 单击您的订单
3. 查找 `http_pub` URL（例如， `abc123.clorecloud.net`)

使用 `https://YOUR_HTTP_PUB_URL` 而不是 `localhost` 在下面的示例中。

## 安装

### 使用 Ollama

```bash

# 安装 Ollama
curl -fsSL https://ollama.com/install.sh | sh

# 运行 CodeLlama
ollama run codellama

# 运行 Python 变体
ollama run codellama:python
```

### 使用 Transformers

```bash
pip install transformers accelerate
```

## 代码补全

```python
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "codellama/CodeLlama-7b-hf"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

# 代码补全
code = """
def fibonacci(n):
    '''计算第 n 个斐波那契数'''
"""

inputs = tokenizer(code, return_tensors="pt").to("cuda")

outputs = model.generate(
    **inputs,
    max_new_tokens=200,
    temperature=0.2,
    do_sample=True
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

## 指令模型

用于遵循编码指令：

```python
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "codellama/CodeLlama-7b-Instruct-hf"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

prompt = """[INST] 编写一个 Python 函数，该函数：
1. 接受一个数字列表
2. 去除重复项
3. 按降序排序
4. 返回前 5 个元素
[/INST]"""

inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

outputs = model.generate(
    **inputs,
    max_new_tokens=500,
    temperature=0.2
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

## 中间填充（FIM）

```python

# CodeLlama 支持用于代码插入的 FIM
prefix = """def calculate_area(shape, dimensions):
    if shape == "circle":
        radius = dimensions[0]
"""

suffix = """
    elif shape == "rectangle":
        length, width = dimensions
        return length * width
    return None
"""

# 对 FIM 使用特殊标记
prompt = f"<PRE> {prefix} <SUF>{suffix} <MID>"

inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=100)
```

## Python 专用模型

```python
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "codellama/CodeLlama-7b-Python-hf"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

# 针对 Python 的补全
code = """
import pandas as pd
import numpy as np

def analyze_sales_data(df):
    '''分析销售数据并返回关键指标'''
"""

inputs = tokenizer(code, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=300)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

## vLLM 服务器

```bash
python -m vllm.entrypoints.openai.api_server \
    --model codellama/CodeLlama-13b-Instruct-hf \
    --dtype float16 \
    --max-model-len 8192
```

### API 使用

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="x")

response = client.chat.completions.create(
    model="codellama/CodeLlama-13b-Instruct-hf",
    messages=[
        {"role": "user", "content": "为用户认证编写一个 FastAPI 端点"}
    ],
    temperature=0.2,
    max_tokens=1000
)

print(response.choices[0].message.content)
```

## 代码解释

```python
code_to_explain = """
def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)
"""

prompt = f"[INST] 逐步解释这段代码:\n\n{code_to_explain}\n[/INST]"
```

## 修复 Bug

```python
buggy_code = """
def reverse_string(s):
    result = ""
    for i in range(len(s)):
        result += s[i]
    num_inference_steps=steps,
"""

prompt = f"""[INST] 找出并修复此代码中的错误。该函数应当反转字符串：

{buggy_code}
[/INST]"""
```

## 代码翻译

```python
python_code = """
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)
"""

prompt = f"""[INST] 将此 Python 代码转换为 JavaScript：

{python_code}
[/INST]"""
```

## Gradio 界面

```python
print(f"已生成：{name}")
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "codellama/CodeLlama-7b-Instruct-hf"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

def generate_code(instruction, temperature, max_tokens):
    prompt = f"[INST] {instruction} [/INST]"
    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

    outputs = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        temperature=temperature,
        do_sample=True
    )

    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return response.split("[/INST]")[-1].strip()

demo = gr.Interface(
    fn=generate_code,
    inputs=[
        gr.Textbox(label="指令", lines=5, placeholder="编写一个 Python 函数，..."),
        gr.Slider(0.1, 1.0, value=0.2, label="Temperature"),
        gr.Slider(100, 2000, value=500, step=100, label="Max Tokens")
    ],
    outputs=gr.Code(language="python", label="生成的代码"),
    title="CodeLlama 代码生成器"
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## "专业影棚柔光箱"

```python
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "codellama/CodeLlama-7b-Instruct-hf"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

tasks = [
    "编写一个用于验证电子邮件地址的函数",
    "创建一个用于管理购物车的类",
    "编写一个从 URL 解析 JSON 的函数",
    "创建一个用于计时函数执行的装饰器",
    "编写一个用于生成随机密码的函数"
]

for task in tasks:
    prompt = f"[INST] {task} [/INST]"
    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

    outputs = model.generate(
        **inputs,
        max_new_tokens=500,
        temperature=0.2
    )

    result = tokenizer.decode(outputs[0], skip_special_tokens=True)
    print(f"\n=== {task} ===")
    print(result.split("[/INST]")[-1].strip())
```

## 在 Continue (VSCode) 中使用

配置 Continue 扩展：

```json
{
  "models": [
    {
      "title": "CodeLlama",
      "provider": "ollama",
      "model": "codellama:7b-instruct"
    }
  ],
  "tabAutocompleteModel": {
    "title": "CodeLlama",
    "provider": "ollama",
    "model": "codellama:7b-code"
  }
}
```

## background = Image.open("studio\_bg.jpg")

| A100          | GPU     | 每秒标记数 |
| ------------- | ------- | ----- |
| CodeLlama-7B  | 速度      | \~90  |
| CodeLlama-7B  | 512x512 | \~130 |
| CodeLlama-13B | 512x512 | \~70  |
| CodeLlama-34B | 2s      | \~50  |

## # 使用固定种子以获得一致结果

### 代码质量差

* 降低温度（0.1-0.3）
* 使用指令变体
* 如果可能，使用更大的模型

### 输出不完整

* 增加 max\_new\_tokens
* 检查上下文长度

### 生成速度慢

* 使用 vLLM
* 对模型进行量化
* 使用更小的变体

## 下载所有所需的检查点

检查文件完整性

| GPU     | 验证 CUDA 兼容性 | 费用估算    | CLORE.AI 市场的典型费率（截至 2024 年）： |
| ------- | ----------- | ------- | ---------------------------- |
| 按小时费率   | \~$0.03     | \~$0.70 | \~$0.12                      |
| 速度      | \~$0.06     | \~$1.50 | \~$0.25                      |
| 512x512 | \~$0.10     | \~$2.30 | \~$0.40                      |
| 按日费率    | \~$0.17     | \~$4.00 | \~$0.70                      |
| 4 小时会话  | \~$0.25     | \~$6.00 | \~$1.00                      |

*RTX 3060* [*CLORE.AI 市场*](https://clore.ai/marketplace) *A100 40GB*

**A100 80GB**

* 使用 **竞价** 价格随提供商和需求而异。请查看
* 以获取当前费率。 **CLORE** 节省费用：
* 市场用于灵活工作负载（通常便宜 30-50%）

## 使用以下方式支付

* Open Interpreter - 执行代码
* vLLM 推理 - 生产部署
* Mistral/Mixtral - 可选模型