Bien démarrer avec Codestral Mamba : configuration et cas d’usage

Transformers vs Mamba : comprendre la différence

Pour comprendre ce qui distingue Codestral Mamba, comparons son architecture sous-jacente, le modèle d’espace d’états Mamba (SSM), à l’architecture Transformer traditionnelle.

Transformers

Les modèles Transformer, comme GPT-4o, utilisent le mécanisme d’auto-attention pour traiter des tâches linguistiques complexes en se focalisant simultanément sur différentes parties de l’entrée.

Cependant, ils présentent un écueil majeur : la complexité quadratique. À mesure que la taille de l’entrée augmente, le coût de calcul et l’usage mémoire explosent, ce qui les rend inefficaces sur de très longues séquences.

Mamba

Les modèles Mamba, fondés sur les State Space Models (SSM), contournent ce goulet d’étranglement quadratique, ce qui les rend bien plus aptes à gérer de longues séquences, jusqu’à 1 million de tokens. Ils peuvent fonctionner jusqu’à cinq fois plus vite que les Transformers.

Mamba égale les performances des Transformers et passe mieux à l’échelle avec des séquences longues. D’après ses concepteurs, Albert Gu et Tri Dao, Mamba offre une inférence rapide et une mise à l’échelle linéaire, dépassant souvent des Transformers de taille comparable et rivalisant avec des modèles deux fois plus grands.

Pourquoi Mamba pour le code ?

L’architecture de Mamba est particulièrement adaptée à la génération de code, où la conservation du contexte sur de longues séquences est essentielle. Contrairement aux Transformers, qui ralentissent et rencontrent des limites mémoire avec des contextes allongés, la complexité linéaire de Mamba et sa capacité à gérer des contextes virtuellement infinis garantissent des performances rapides et fiables sur de vastes bases de code.

Les Transformers pâtissent d’une complexité quadratique dans leur mécanisme d’attention. Chaque token « regarde » tous les tokens précédents lors de la prédiction, ce qui engendre des coûts de calcul et de mémoire élevés. L’entraînement et la génération deviennent alors de plus en plus lents à mesure que le contexte s’allonge, avec à la clé des erreurs de débordement mémoire.

Mamba résout ces problèmes en utilisant un SSM pour une communication efficace entre tokens, évitant la complexité quadratique des Transformers. Sa conception lui permet de traiter efficacement de longues séquences, ce qui en fait un excellent choix pour les applications nécessitant une gestion étendue du contexte.

Benchmarks de Codestral Mamba

Codestral Mamba (7B) excelle sur les tâches liées au code, dépassant régulièrement les autres modèles 7B sur le benchmark HumanEval, qui mesure les capacités de génération de code dans plusieurs langages de programmation.

Source : Mistral AI

Plus précisément, il atteint un impressionnant 75,0 % de précision sur HumanEval en Python, devant CodeGemma-1.1 7B (61,0 %), CodeLlama 7B (31,1 %) et DeepSeek v1.5 7B (65,9 %). Il talonne même le modèle Codestral (22B) avec 81,1 % de précision.

Sur les autres langages d’HumanEval, Codestral Mamba maintient des performances solides. Son score en Bash est inférieur aux autres benchmarks, mais il reste compétitif dans sa catégorie.

Notamment, sur le benchmark CruxE pour la génération de code inter-tâches, Codestral Mamba atteint 57,8 %, dépassant CodeGemma-1.1 7B et égalant CodeLlama 34B.

Ces résultats mettent en évidence l’efficacité de Codestral Mamba pour la génération et la compréhension de code, d’autant plus remarquable au vu de sa taille relativement modeste face à certains concurrents.

Même si des tests supplémentaires et des comparaisons sur un éventail plus large de modèles et de tâches seraient utiles, ces premiers résultats positionnent Codestral Mamba comme une alternative open source prometteuse pour les développeurs.

Configurer Codestral Mamba

Passons en revue les étapes pour bien démarrer avec Codestral Mamba.

Installation

Pour installer Codestral Mamba, exécutez la commande suivante :

pip install codestral_mamba

Obtenir une clé d’API

Pour utiliser l’API Codestral, vous aurez besoin d’une clé d’API. Voici comment l’obtenir :

1. Rendez-vous sur la page d’inscription Mistral AI et créez un compte.
2. Sur api.mistral.ai, allez dans l’onglet API Keys. Cliquez sur Create new key pour générer votre clé d’API.

Définissez votre clé d’API dans vos variables d’environnement avec cette commande :

export MISTRAL_API_KEY='your_api_key'

Cas d’usage de Codestral Mamba

Maintenant que Codestral Mamba est configuré, explorons quelques exemples.

Complétion de code

Si vous avez un extrait de code incomplet, utilisez Codestral Mamba pour le compléter. Voici un exemple :

import os
from mistralai.client import MistralClient
from mistralai.models.chat_completion import ChatMessage
api_key = os.environ["MISTRAL_API_KEY"]
client = MistralClient(api_key=api_key)
model = "codestral-mamba-latest"
messages = [
    ChatMessage(role="user", content="Please complete the following function: \\n def calculate_area_of_square(side_length):\\n    # missing part here")
]
chat_response = client.chat(
    model=model,
    messages=messages
)
print(chat_response.choices[0].message.content)

The function calculate_area_of_square(side_length) is designed to calculate the area of a square given its side length.
The area of a square can be calculated by squaring the length of one of its sides. Therefore, the function simply needs to multiply the side length by itself to get the area.
Here is how you can complete the function:
def calculate_area_of_square(side_length):
    area = side_length * side_length
    return area
You can also write this function in a more concise way using the exponentiation operator **:
def calculate_area_of_square(side_length):
    return side_length ** 2
Both of these functions will correctly calculate and return the area of a square given its side length.

Génération de fonctions

Codestral Mamba peut aussi générer une fonction à partir d’une description. Par exemple, voici la sortie pour : « Please write me a Python function that returns the factorial of a number. »

import os
from mistralai.client import MistralClient
from mistralai.models.chat_completion import ChatMessage
client = MistralClient(api_key=api_key)
model = "codestral-mamba-latest"
messages = [
    ChatMessage(role="user", content="Please write me a Python function that returns the factorial of a number")
]
chat_response = client.chat(
    model=model,
    messages=messages
)
print(chat_response.choices[0].message.content)

Sure, here's a simple Python function that calculates the factorial of a number:
def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)
This function uses recursion, a method in which a function calls itself. The base case is when n is 0, in which case the function returns 1. For any other value, the function returns n multiplied by the factorial of n-1.

Refactorisation

Enfin, vous pouvez utiliser Codestral Mamba pour refactoriser et améliorer votre base de code existante comme suit :

import os
from mistralai.client import MistralClient
from mistralai.models.chat_completion import ChatMessage
api_key = os.environ["MISTRAL_API_KEY"]
client = MistralClient(api_key=api_key)
model = "codestral-mamba-latest"
messages = [
    ChatMessage(role="user", content="""Please improve / refactor the following Python function: \\n```python
def fibonacci(n: int) -> int:
    if n <= 0:
        return "Input should be a positive integer."
    elif n == 1:
        return 0
    elif n == 2:
        return 1
    else:
        a, b = 0, 1
        for _ in range(2, n):
            a, b = b, a + b
        return b
```""")
]
chat_response = client.chat(
    model=model,
    messages=messages
)
print(chat_response.choices[0].message.content)

The provided Python function is already quite well-written and efficient. However, it could be improved by adding some type hints for clarity and to provide better documentation. Here's a refactored version of the function:
def fibonacci(n: int) -> int:
    """
    Calculates the nth Fibonacci number.

    Args:
    n (int): The position of the Fibonacci number to be calculated.

    Returns:
    int: The nth Fibonacci number.
    """

    if not isinstance(n, int) or n <= 0:
        raise ValueError("Input should be a positive integer.")

    if n <= 2:
        return n - 1
    else:
        a, b = 0, 1
        for _ in range(2, n):
            a, b = b, a + b
        return b

I've added a docstring to the function to explain what it does. I've also added some input validation to check that the input is a positive integer and to raise a meaningful error if it's not. I've also adjusted the base cases to return `n - 1` for `n <= 2` to make the function more concise and easier to understand.

Autres atouts de Codestral Mamba

Codestral Mamba présente plusieurs autres avantages qui en font un choix convaincant.

Prise en charge multilingue

Codestral Mamba prend en charge plus de 80 langages de programmation. C’est un outil flexible pour les développeurs qui travaillent dans des environnements variés, que vous codiez en Python, JavaScript ou tout autre langage pris en charge.

Fenêtre de contexte étendue

Avec la capacité de traiter jusqu’à 256 000 tokens, Codestral Mamba peut gérer de plus grandes bases de code et conserver le contexte à travers plusieurs fichiers.

C’est particulièrement utile pour les projets complexes où le suivi d’un code volumineux et de ses dépendances est crucial.

Les avantages de l’open source

Codestral Mamba est open source et disponible sous licence Apache 2.0. Son code est donc transparent et accessible pour consultation, modification ou contribution.

Cette nature ouverte favorise la collaboration de la communauté, permettant aux développeurs d’améliorer et d’adapter le modèle à divers besoins.

Affiner Codestral Mamba et usages avancés

Bien que Codestral Mamba soit déjà performant prêt à l’emploi, vous pouvez encore améliorer ses résultats et l’adapter à vos besoins spécifiques via le fine-tuning et des techniques avancées d’ingénierie de prompts.

Fine-tuning sur vos données

Codestral Mamba peut être personnalisé pour répondre à vos besoins en le réentraînant sur vos propres données. Il s’agit d’exposer le modèle à du code et des informations propres à votre domaine ou à votre base de code.

Le fine-tuning renforce ses performances, le rendant plus efficace pour vos cas d’usage et améliorant la précision et la pertinence de la génération de code.

Prompts avancés

Pour traiter des tâches plus complexes, utilisez des techniques de prompting avancées avec Codestral Mamba. L’une d’elles est le chain-of-thought prompting, qui consiste à guider le modèle dans un raisonnement étape par étape. Cette approche exploite ses capacités de raisonnement avancées pour gérer des requêtes complexes et produire des réponses plus détaillées et réfléchies.

Conclusion

Codestral Mamba, fondé sur le modèle d’espace d’états Mamba, corrige les limites des Transformers traditionnels pour le traitement de longues séquences de code.

Son caractère open source, sa prise en charge multilingue et sa capacité à gérer de larges contextes en font une alternative précieuse pour les développeurs.

Pour en savoir plus sur la suite de LLM de Mistral, nous vous recommandons ces articles :

• Mistral Large 2
• Codestral 22B
• Codestral 22B API Tutorial : bien démarrer avec l’API de Mistral