CodeLlama

Générez, complétez et expliquez du code avec CodeLlama sur Clore.ai

Alternatives plus récentes ! Pour les tâches de codage, envisagez Qwen2.5-Coder (32B, génération de code à la pointe) ou DeepSeek-R1 (raisonnement + codage). CodeLlama reste utile pour les déploiements légers.

Générez, complétez et expliquez du code avec CodeLlama de Meta.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Location sur CLORE.AI

Visitez CLORE.AI Marketplace
Filtrer par type de GPU, VRAM et prix
Choisir À la demande (tarif fixe) ou Spot (prix d'enchère)
Configurez votre commande :
- Sélectionnez l'image Docker
- Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
- Ajoutez des variables d'environnement si nécessaire
- Entrez la commande de démarrage
Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC
Créez la commande et attendez le déploiement

Accédez à votre serveur

Trouvez les détails de connexion dans Mes commandes
Interfaces Web : utilisez l'URL du port HTTP
SSH : ssh -p <port> root@<adresse-proxy>

Variantes de modèle

Modèle

Taille

VRAM

Idéal pour

CodeLlama-7B

8 Go

Complétion rapide

CodeLlama-13B

13B

16Go

Équilibré

CodeLlama-34B

34B

40Go

Meilleure qualité

CodeLlama-70B

70B

80 Go+

Qualité maximale

Variantes

Base: Complétion de code
Instruct: Suivre les instructions
Python: Spécialisé Python

Déploiement rapide

Image Docker :

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

Ports :

22/tcp
8000/http

Commande :

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

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

Aller à la Mes commandes page
Cliquez sur votre commande
Trouvez l' http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://VOTRE_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Installation

Utilisation d'Ollama


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

# Exécuter CodeLlama
ollama run codellama

# Exécuter la variante Python
ollama run codellama:python

Utilisation de Transformers

pip install transformers accelerate

Complétion de code

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

# Complétion de code
code = """
def fibonacci(n):
    '''Calculer le nième nombre de Fibonacci'''
"""

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

Modèle Instruct

Pour suivre des instructions de codage :

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] Écris une fonction Python qui :
1. Prend une liste de nombres
2. Supprime les doublons
3. Trie par ordre décroissant
4. Retourne les 5 premiers éléments
[/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)


# CodeLlama prend en charge le FIM pour l'insertion de code
prefix = """def calculate_area(shape, dimensions):
    if shape == "circle":
        radius = dimensions[0]
"""

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

# Utiliser des tokens spéciaux pour le FIM
prompt = f"<PRE> {prefix} <SUF>{suffix} <MID>"

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

Modèle spécialisé 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"
)

# Complétion spécifique à Python
code = """
import pandas as pd
import numpy as np

def analyze_sales_data(df):
    '''Analyser les données de ventes et retourner les métriques clés'''
"""

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

Serveur vLLM

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

Utilisation de l'API

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": "Écris un endpoint FastAPI pour l'authentification des utilisateurs"}
    ],
    temperature=0.2,
    max_tokens=1000
)

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

Explication de code

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] Explique ce code étape par étape:\n\n{code_to_explain}\n[/INST]"

Correction de bogues

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

prompt = f"""[INST] Trouve et corrige le bug dans ce code. La fonction doit inverser une chaîne :

{buggy_code}
[/INST]"""

Traduction de code

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

prompt = f"""[INST] Convertis ce code Python en JavaScript :

{python_code}
[/INST]"""

Interface Gradio

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="Instruction", lines=5, placeholder="Écris une fonction Python qui..."),
        gr.Slider(0.1, 1.0, value=0.2, label="Température"),
        gr.Slider(100, 2000, value=500, step=100, label="Max Tokens")
    ],
    outputs=gr.Code(language="python", label="Code généré"),
    title="Générateur de code CodeLlama"
)

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

Traitement par lots

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 = [
    "Écris une fonction pour valider des adresses e-mail",
    "Crée une classe pour gérer un panier d'achat",
    "Écris une fonction pour analyser du JSON depuis une URL",
    "Crée un décorateur pour mesurer le temps d'exécution d'une fonction",
    "Écris une fonction pour générer des mots de passe aléatoires"
]

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

Utiliser avec Continue (VSCode)

Configurer l'extension Continue :

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

Performances

Modèle

GPU

Tokens/sec

CodeLlama-7B

RTX 3090

~90

CodeLlama-7B

RTX 4090

~130

CodeLlama-13B

RTX 4090

~70

CodeLlama-34B

A100

~50

Dépannage

Mauvaise qualité de code

Baisser la température (0.1-0.3)
Utiliser la variante Instruct
Modèle plus grand si possible

Sortie incomplète

Augmenter max_new_tokens
Vérifier la longueur du contexte

Génération lente

Utiliser vLLM
Quantifier le modèle
Utiliser une variante plus petite

Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

GPU

Tarif horaire

Tarif journalier

Session de 4 heures

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

Les prix varient selon le fournisseur et la demande. Vérifiez CLORE.AI Marketplace pour les tarifs actuels.

Économisez de l'argent :

Utilisez Spot market pour les charges de travail flexibles (souvent 30-50 % moins cher)
Payer avec CLORE jetons
Comparer les prix entre différents fournisseurs

Prochaines étapes

Open Interpreter - Exécuter du code
vLLM Inference - Mise en production
Mistral/Mixtral - Modèles alternatifs

PrécédentQwen2.5 SuivantGemma 2

Mis à jour il y a 1 jour

Ce contenu vous a-t-il été utile ?

hashtagLocation sur CLORE.AI

hashtagAccédez à votre serveur

hashtagVariantes de modèle

hashtagVariantes

hashtagDéploiement rapide

hashtagAccéder à votre service

hashtagInstallation

hashtagUtilisation d'Ollama

hashtagUtilisation de Transformers

hashtagComplétion de code

hashtagModèle Instruct

hashtagFill-in-the-Middle (FIM)

hashtagModèle spécialisé Python

hashtagServeur vLLM

hashtagUtilisation de l'API

hashtagExplication de code

hashtagCorrection de bogues

hashtagTraduction de code

hashtagInterface Gradio

hashtagTraitement par lots

hashtagUtiliser avec Continue (VSCode)

hashtagPerformances

hashtagDépannage

hashtagMauvaise qualité de code

hashtagSortie incomplète

hashtagGénération lente

hashtagEstimation des coûts

hashtagProchaines étapes

Location sur CLORE.AI

Accédez à votre serveur

Variantes de modèle

Variantes

Déploiement rapide

Accéder à votre service

Installation

Utilisation d'Ollama

Utilisation de Transformers

Complétion de code

Modèle Instruct

Fill-in-the-Middle (FIM)

Modèle spécialisé Python

Serveur vLLM

Utilisation de l'API

Explication de code

Correction de bogues

Traduction de code

Interface Gradio

Traitement par lots

Utiliser avec Continue (VSCode)

Performances

Dépannage

Mauvaise qualité de code

Sortie incomplète

Génération lente

Estimation des coûts

Prochaines étapes