Génération de code à l'aide de modèles LLM locaux – exemples pratiques

De nos jours, les réseaux de neurones artificiels, en particulier les grands modèles linguistiques (LLM), deviennent de plus en plus populaires pour la génération de code. Grâce à la possibilité d'exécuter des modèles localement, les programmeurs peuvent tirer parti de leur potentiel sans avoir besoin de recourir à des solutions cloud. Dans cet article, nous allons discuter de la manière d'utiliser les modèles LLM locaux pour générer du code, en présentant des exemples pratiques.

Pourquoi les modèles LLM locaux ?

L'utilisation de modèles LLM locaux présente plusieurs avantages :

• Confidentialité : Les codes sources et les données ne quittent pas votre ordinateur.
• Contrôle : Contrôle total sur l'environnement d'exécution.
• Coûts : Pas de frais pour les API cloud.

Préparation de l'environnement

Pour commencer, vous aurez besoin de :

1. Un modèle LLM : Par exemple, Mistral-7B ou Llama-2.
2. Bibliothèques : transformers et accelerate de la bibliothèque Hugging Face.
3. Prise en charge du GPU : Pour une meilleure performance.

Installation des bibliothèques requises

pip install transformers accelerate torch

Exemple 1 : Génération de code Python simple

Voici un exemple de génération de code Python simple à l'aide d'un modèle LLM local.

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Chargement du modèle et du tokeniseur
model_name = "mistral-7b"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# Préparation du prompt
prompt = "Écrivez une fonction Python qui calcule la somme de deux nombres :"
input_ids = tokenizer(prompt, return_tensors="pt").input_ids

# Génération du code
output = model.generate(input_ids, max_length=100, num_return_sequences=1)
generated_code = tokenizer.decode(output[0], skip_special_tokens=True)

print(generated_code)

Résultat

def sum_two_numbers(a, b):
    return a + b

Exemple 2 : Génération de code utilisant la bibliothèque requests

Dans cet exemple, nous allons montrer comment le modèle peut générer du code utilisant la bibliothèque requests pour effectuer une requête HTTP.

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Chargement du modèle et du tokeniseur
model_name = "mistral-7b"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# Préparation du prompt
prompt = "Écrivez du code Python qui effectue une requête GET vers l'API JSONPlaceholder :"
input_ids = tokenizer(prompt, return_tensors="pt").input_ids

# Génération du code
output = model.generate(input_ids, max_length=150, num_return_sequences=1)
generated_code = tokenizer.decode(output[0], skip_special_tokens=True)

print(generated_code)

Résultat

import requests

response = requests.get("https://jsonplaceholder.typicode.com/posts/1")
print(response.json())

Exemple 3 : Génération de code utilisant une classe en Python

Dans cet exemple, nous allons montrer comment le modèle peut générer du code définissant une classe en Python.

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Chargement du modèle et du tokeniseur
model_name = "mistral-7b"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# Préparation du prompt
prompt = "Créez une classe Python qui représente un rectangle :"
input_ids = tokenizer(prompt, return_tensors="pt").input_ids

# Génération du code
output = model.generate(input_ids, max_length=200, num_return_sequences=1)
generated_code = tokenizer.decode(output[0], skip_special_tokens=True)

print(generated_code)

Résultat

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

Optimisation de la génération de code

Pour améliorer la qualité du code généré, plusieurs techniques peuvent être appliquées :

1. Prompts précis : Décrire précisément ce que vous attendez.
2. Contrôle de la longueur : Définir une longueur appropriée pour le code généré.
3. Génération multiple : Générer plusieurs versions de code et choisir la meilleure.

Conclusion

La génération de code à l'aide de modèles LLM locaux est un outil puissant pour les programmeurs. Grâce à la possibilité d'exécuter des modèles localement, on peut bénéficier de confidentialité et de contrôle sur le code. Dans cet article, nous avons présenté plusieurs exemples pratiques qui montrent comment utiliser ces technologies dans le travail quotidien.

N'oubliez pas que la qualité du code généré dépend de la qualité du modèle et de la précision des prompts. Expérimentez avec différents modèles et techniques pour obtenir les meilleurs résultats.