Primi passi con Codestral Mamba: configurazione e applicazioni

Transformer vs Mamba: capire la differenza

Per capire perché Codestral Mamba si distingue, confrontiamo la sua architettura di base, il modello a spazio di stato Mamba (SSM), con l'architettura tradizionale dei Transformer.

Transformer

I modelli Transformer, come GPT-4o, usano la self-attention per gestire compiti linguistici complessi concentrandosi contemporaneamente su parti diverse dell'input.

Hanno però un problema importante: la complessità quadratica. All'aumentare della dimensione dell'input, il costo computazionale e l'uso di memoria crescono esponenzialmente, portando a inefficienze con sequenze molto lunghe.

Mamba

I modelli Mamba, basati su State Space Models (SSM), evitano questo collo di bottiglia quadratico, risultando molto più adatti a gestire sequenze lunghe, fino a 1 milione di token. Possono essere fino a cinque volte più veloci dei Transformer.

Mamba eguaglia le prestazioni dei Transformer e scala meglio con sequenze lunghe. Secondo i suoi creatori, Albert Gu e Tri Dao, Mamba offre inferenza rapida e scalabilità lineare, spesso superando Transformer della stessa dimensione e tenendo il passo con quelli due volte più grandi.

Perché Mamba per il codice?

L'architettura di Mamba è adatta alla generazione di codice, dove è importante mantenere il contesto su sequenze lunghe. A differenza dei Transformer, che rallentano e incontrano problemi di memoria con contesti più estesi, la complessità temporale lineare di Mamba e la capacità di gestire lunghezze di contesto potenzialmente infinite garantiscono prestazioni rapide e affidabili con codebase di grandi dimensioni.

I Transformer soffrono di complessità quadratica nel meccanismo di attenzione. Ogni token guarda a tutti i token precedenti durante la predizione, con costi computazionali e di memoria elevati. Questo rende l'addestramento e la generazione di nuovi token sempre più lenti all'aumentare del contesto, causando spesso errori di esaurimento della memoria.

Mamba risolve questi problemi usando un SSM per una comunicazione efficiente tra token, evitando la complessità quadratica dei Transformer. Il suo design consente di elaborare sequenze lunghe in modo efficiente, rendendolo una scelta solida per applicazioni che richiedono un'ampia gestione del contesto.

Benchmark di Codestral Mamba

Codestral Mamba (7B) eccelle nei compiti legati al codice, superando costantemente altri modelli 7B nel benchmark HumanEval, che misura le capacità di generazione di codice in più linguaggi di programmazione.

Fonte: Mistral AI

Nello specifico, ottiene un notevole 75,0% di accuratezza su HumanEval per Python, superando CodeGemma-1.1 7B (61,0%), CodeLlama 7B (31,1%) e DeepSeek v1.5 7B (65,9%). Riesce persino a superare di poco il più grande modello Codestral (22B) con un'accuratezza dell'81,1%.

Negli altri linguaggi di HumanEval, Codestral Mamba continua a mostrare ottime prestazioni. Sebbene il punteggio nello scripting Bash sia inferiore rispetto ad altri benchmark, rimane competitivo nella sua categoria.

In particolare, sul benchmark CruxE per la generazione di codice cross-task, Codestral Mamba ottiene un solido 57,8%, superando CodeGemma-1.1 7B e uguagliando CodeLlama 34B.

Questi risultati evidenziano l'efficacia di Codestral Mamba nei compiti di generazione e comprensione del codice, soprattutto considerando le sue dimensioni relativamente ridotte rispetto ad alcuni concorrenti.

Pur essendo auspicabili ulteriori test e confronti con una gamma più ampia di modelli e task, i risultati iniziali posizionano Codestral Mamba come un'alternativa open-source promettente per gli sviluppatori.

Configurazione di Codestral Mamba

Vediamo i passaggi necessari per iniziare a usare Codestral Mamba.

Installazione

Per installare Codestral Mamba, esegui il seguente comando:

pip install codestral_mamba

Ottenere una chiave API

Per usare l'API di Codestral, ti servirà una chiave API. Ecco come ottenerla:

1. Vai alla pagina di registrazione di Mistral AI e crea un account.
2. Per api.mistral.ai, vai alla scheda API Keys. Clicca su Create new key per generare la tua chiave API.

Imposta la tua chiave API nelle variabili d'ambiente con questo comando:

export MISTRAL_API_KEY='your_api_key'

Applicazioni di Codestral Mamba

Ora che abbiamo configurato Codestral Mamba, vediamo alcuni esempi.

Completamento del codice

Se hai uno snippet di codice incompleto, usa Codestral Mamba per completarlo. Ecco un esempio:

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.

Generazione di funzioni

Codestral Mamba può anche generare una funzione a partire da una descrizione. Ad esempio, qui sotto trovi l'output per la descrizione: "Scrivimi una funzione Python che restituisca il fattoriale di un numero".

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.

Refactoring

Infine, puoi usare Codestral Mamba per rifattorizzare e migliorare il tuo codebase esistente come segue:

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.

Vantaggi aggiuntivi di Codestral Mamba

Codestral Mamba offre diversi altri vantaggi che lo rendono una scelta interessante.

Supporto multilingue

Codestral Mamba supporta oltre 80 linguaggi di programmazione. È quindi uno strumento flessibile per sviluppatori che lavorano in ambienti diversi, che tu stia programmando in Python, JavaScript o in un altro linguaggio supportato.

Ampia finestra di contesto

Con la capacità di gestire fino a 256.000 token, Codestral Mamba può affrontare codebase più grandi e mantenere il contesto tra più file.

Questo è particolarmente utile per progetti complessi in cui è fondamentale tenere traccia di ampi volumi di codice e dipendenze.

Vantaggi dell'open source

Codestral Mamba è open-source e disponibile sotto licenza Apache 2.0. Ciò significa che il codice è trasparente e accessibile a chiunque per consultarlo, modificarlo o contribuire.

La natura open-source promuove la collaborazione della community, permettendo agli sviluppatori di migliorare e adattare il modello per esigenze diverse.

Fine-tuning di Codestral Mamba e usi avanzati

Sebbene Codestral Mamba offra già capacità notevoli out-of-the-box, puoi migliorarne ulteriormente le prestazioni e adattarlo alle tue esigenze specifiche tramite fine-tuning e tecniche avanzate di prompting.

Fine-tuning su dati personalizzati

Codestral Mamba può essere personalizzato per adattarsi meglio alle tue esigenze effettuando fine-tuning sui tuoi dati. Questo processo prevede l'addestramento del modello su codice e informazioni rilevanti per il tuo dominio o codebase specifico.

Il fine-tuning migliora le prestazioni del modello, rendendolo più efficace per le tue applicazioni e aumentando accuratezza e pertinenza nella generazione del codice.

Prompt avanzati

Per affrontare compiti più complessi, puoi usare tecniche avanzate di prompting con Codestral Mamba. Un metodo è il chain-of-thought prompting, che consiste nel guidare il modello attraverso un processo di ragionamento passo dopo passo. Questa tecnica sfrutta le capacità di ragionamento avanzate del modello per gestire richieste articolate e produrre risposte più dettagliate e ponderate.

Conclusione

Codestral Mamba, grazie al modello a spazio di stato Mamba, affronta i limiti dei modelli Transformer tradizionali nella gestione di lunghe sequenze di codice.

La sua natura open-source, il supporto multilingue e la capacità di elaborare contesti ampi lo rendono un'alternativa preziosa per gli sviluppatori.

Se vuoi saperne di più sulla suite di LLM di Mistral, ti consiglio questi post del blog:

• Mistral Large 2
• Codestral 22B
• Tutorial API di Codestral 22B: iniziare con l'API di Mistral