# CodeLlama

{% hint style="info" %}
**Новые альтернативы!** Для задач кодирования рассмотрите [**Qwen2.5-Coder**](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/qwen25) (32B, передовая генерация кода) или [**DeepSeek-R1**](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/deepseek-r1) (умозаключение + кодирование). CodeLlama по-прежнему полезен для лёгких развёртываний.
{% endhint %}

Генерируйте, дополняйте и объясняйте код с Meta CodeLlama.

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендуемых через [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Аренда на CLORE.AI

1. Посетите [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Отфильтруйте по типу GPU, объему VRAM и цене
3. Выберите **On-Demand** (фиксированная ставка) или **Spot** (цена по ставке)
4. Настройте ваш заказ:
   * Выберите Docker-образ
   * Установите порты (TCP для SSH, HTTP для веб-интерфейсов)
   * Добавьте переменные окружения при необходимости
   * Введите команду запуска
5. Выберите способ оплаты: **CLORE**, **BTC**, или **USDT/USDC**
6. Создайте заказ и дождитесь развертывания

### Доступ к вашему серверу

* Найдите данные для подключения в **Моих заказах**
* Веб-интерфейсы: используйте URL HTTP-порта
* SSH: `ssh -p <port> root@<proxy-address>`

## Варианты моделей

| Модель        | Размер | VRAM  | Лучше всего для       |
| ------------- | ------ | ----- | --------------------- |
| CodeLlama-7B  | 7B     | 8GB   | Быстрое дополнение    |
| CodeLlama-13B | 13B    | 16GB  | Сбалансировано        |
| CodeLlama-34B | 34B    | 40GB  | Лучшее качество       |
| CodeLlama-70B | 70B    | 80GB+ | Максимальное качество |

### Варианты

* **Базовый**: Дополнение кода
* **Instruct**: Следование инструкциям
* **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))
```

## Instruct модель

Для выполнения инструкций по кодированию:

```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))
```

## Fill-in-the-Middle (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": "Напишите endpoint 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]"
```

## Исправление ошибок

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

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
import gradio as gr
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="Температура"),
        gr.Slider(100, 2000, value=500, step=100, label="Макс токенов")
    ],
    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 = [
    "Напишите функцию для проверки адресов электронной почты",
    "Создайте класс для управления корзиной покупок",
    "Напишите функцию для парсинга JSON с URL",
    "Создайте декоратор для измерения времени выполнения функции",
    "Напишите функцию для генерации случайных паролей"
]

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"
  }
}
```

## Производительность

| Модель        | GPU      | Токенов/с |
| ------------- | -------- | --------- |
| CodeLlama-7B  | RTX 3090 | \~90      |
| CodeLlama-7B  | RTX 4090 | \~130     |
| CodeLlama-13B | RTX 4090 | \~70      |
| CodeLlama-34B | A100     | \~50      |

## Устранение неполадок

### Плохое качество кода

* Понизьте температуру (0.1-0.3)
* Используйте вариант Instruct
* Бóльшая модель, если возможно

### Неполный вывод

* Увеличьте max\_new\_tokens
* Проверьте длину контекста

### Медленная генерация

* Используйте vLLM
* Квантуйте модель
* Используйте меньший вариант

## Оценка стоимости

Типичные ставки на маркетплейсе CLORE.AI (по состоянию на 2024):

| GPU       | Почасовая ставка | Дневная ставка | Сессия 4 часа |
| --------- | ---------------- | -------------- | ------------- |
| RTX 3060  | \~$0.03          | \~$0.70        | \~$0.12       |
| RTX 3090  | \~$0.06          | \~$1.50        | \~$0.25       |
| RTX 4090  | \~$0.10          | \~$2.30        | \~$0.40       |
| A100 40GB | \~$0.17          | \~$4.00        | \~$0.70       |
| A100 80GB | \~$0.25          | \~$6.00        | \~$1.00       |

*Цены варьируются в зависимости от провайдера и спроса. Проверьте* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *для текущих тарифов.*

**Экономьте деньги:**

* Используйте **Spot** рынок для гибких рабочих нагрузок (часто на 30–50% дешевле)
* Платите с помощью **CLORE** токенов
* Сравнивайте цены у разных провайдеров

## Дальнейшие шаги

* Open Interpreter - Выполнение кода
* vLLM Inference - Продакшен-сервинг
* Mistral/Mixtral - Альтернативные модели