Começando com o Codestral Mamba: instalação e aplicações

Transformers vs. Mamba: entendendo as diferenças

Para entender por que o Codestral Mamba se destaca, vamos comparar sua arquitetura, o state-space model (SSM) Mamba, com a arquitetura Transformer tradicional.

Transformers

Modelos Transformer, como o GPT-4o, usam autoatenção para lidar com tarefas complexas de linguagem, focando em diferentes partes da entrada ao mesmo tempo.

Mas eles têm um problema importante: complexidade quadrática. À medida que o tamanho da entrada cresce, o custo computacional e o uso de memória aumentam drasticamente, levando à ineficiência em sequências muito longas.

Mamba

Modelos Mamba, baseados em State Space Models (SSMs), evitam esse gargalo quadrático, tornando-se muito melhores para lidar com sequências longas, chegando a até 1 milhão de tokens. Eles podem rodar até cinco vezes mais rápido que Transformers.

O Mamba iguala o desempenho dos Transformers e escala melhor com sequências longas. Segundo seus criadores, Albert Gu e Tri Dao, o Mamba oferece inferência rápida e escalonamento linear, muitas vezes superando Transformers do mesmo tamanho e igualando os que são o dobro.

Por que usar Mamba para código?

A arquitetura do Mamba é ideal para geração de código, onde manter o contexto em sequências longas é essencial. Diferente dos Transformers, que ficam mais lentos e enfrentam problemas de memória com contextos maiores, a complexidade temporal linear do Mamba e a capacidade de lidar com comprimentos de contexto praticamente infinitos garantem desempenho rápido e confiável em grandes bases de código.

Transformers sofrem com complexidade quadrática no mecanismo de atenção. Cada token olha para todos os tokens anteriores durante a previsão, gerando custos altos de computação e memória. Isso torna o treinamento e a geração de novos tokens cada vez mais lentos conforme o contexto cresce, muitas vezes causando erros de estouro de memória.

O Mamba resolve esses problemas usando um SSM para comunicação eficiente entre tokens, evitando a complexidade quadrática dos Transformers. Seu design permite processar sequências longas com eficiência, sendo uma ótima escolha para aplicações que exigem muito contexto.

Benchmarks do Codestral Mamba

O Codestral Mamba (7B) brilha em tarefas relacionadas a código, superando de forma consistente outros modelos de 7B no benchmark HumanEval, que mede a capacidade de geração de código em várias linguagens de programação.

Fonte: Mistral AI

Especificamente, ele atinge uma precisão impressionante de 75,0% no HumanEval para Python, superando CodeGemma-1.1 7B (61,0%), CodeLlama 7B (31,1%) e DeepSeek v1.5 7B (65,9%). Ele chega até a superar o modelo Codestral (22B) maior, com 81,1% de precisão.

Em outras linguagens do HumanEval, o Codestral Mamba continua mostrando desempenho forte. Embora sua pontuação em Bash seja menor que em outros cenários, ele se mantém competitivo dentro da sua categoria.

No benchmark CruxE, para geração de código entre tarefas, o Codestral Mamba alcança sólidos 57,8%, superando o CodeGemma-1.1 7B e igualando o CodeLlama 34B.

Esses resultados de benchmark destacam a eficácia do Codestral Mamba em tarefas de geração e compreensão de código, especialmente considerando seu tamanho relativamente menor em comparação com alguns concorrentes.

Embora testes adicionais e comparações com uma gama mais ampla de modelos e tarefas sejam bem-vindos, os resultados iniciais colocam o Codestral Mamba como uma alternativa open-source promissora para desenvolvedores.

Como configurar o Codestral Mamba

Vamos percorrer os passos para começar a usar o Codestral Mamba.

Instalação

Para instalar o Codestral Mamba, execute o comando abaixo:

pip install codestral_mamba

Obtendo uma chave de API

Para usar a API do Codestral, você vai precisar de uma chave de API. Veja como obter uma:

1. Acesse a página de cadastro da Mistral AI e crie uma conta.
2. Em api.mistral.ai, navegue até a aba API Keys. Clique em Create new key para gerar sua chave.

Defina sua chave de API nas variáveis de ambiente com este comando:

export MISTRAL_API_KEY='your_api_key'

Aplicações do Codestral Mamba

Agora que configuramos o Codestral Mamba, vamos ver alguns exemplos.

Autocompletar código

Se você tem um trecho de código incompleto, use o Codestral Mamba para completá-lo. Veja um exemplo:

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.

Geração de função

O Codestral Mamba também pode gerar uma função a partir de uma descrição. Por exemplo, veja abaixo a saída para a descrição: “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.

Refatoração

Por fim, você pode usar o Codestral Mamba para refatorar e melhorar sua base de código existente, assim:

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.

Benefícios adicionais do Codestral Mamba

O Codestral Mamba traz várias outras vantagens que o tornam uma escolha atraente.

Suporte multilíngue

O Codestral Mamba oferece suporte a mais de 80 linguagens de programação. Isso o torna uma ferramenta flexível para desenvolvedores que trabalham em diferentes ambientes, seja em Python, JavaScript ou qualquer outra linguagem suportada.

Janela de contexto ampla

Com capacidade para lidar com até 256.000 tokens, o Codestral Mamba consegue gerenciar bases de código maiores e manter o contexto entre vários arquivos.

Isso é especialmente útil em projetos complexos, nos quais acompanhar um código extenso e suas dependências é crucial.

Vantagens do open-source

O Codestral Mamba é open-source e está disponível sob a licença Apache 2.0. Isso significa que seu código é transparente e acessível para qualquer pessoa ver, modificar ou contribuir.

A natureza open-source incentiva a colaboração da comunidade, permitindo que desenvolvedores melhorem e adaptem o modelo para diversas necessidades.

Fine-tuning do Codestral Mamba e uso avançado

Embora o Codestral Mamba já ofereça recursos impressionantes pronto para uso, você pode potencializar ainda mais seu desempenho e ajustá-lo às suas necessidades por meio de fine-tuning e técnicas avançadas de prompts.

Fine-tuning com dados próprios

O Codestral Mamba pode ser customizado para se adaptar melhor às suas necessidades ao fazer fine-tuning com seus próprios dados. Esse processo envolve treinar o modelo com código e informações relevantes ao seu domínio ou base de código.

O fine-tuning melhora o desempenho do modelo, tornando-o mais eficaz para suas aplicações e aumentando a precisão e a relevância na geração de código.

Prompts avançados

Para encarar tarefas mais complexas, você pode usar técnicas avançadas de prompting com o Codestral Mamba. Um exemplo é o chain-of-thought prompting, que envolve guiar o modelo por um processo de raciocínio passo a passo. Essa técnica aproveita as capacidades avançadas de raciocínio do modelo para lidar com consultas complexas e produzir respostas mais detalhadas e bem elaboradas.

Conclusão

O Codestral Mamba, alavancando o state-space model Mamba, resolve limitações dos Transformers tradicionais ao lidar com sequências longas de código.

Sua natureza open-source, o suporte multilíngue e a capacidade de processar grandes contextos o colocam como uma alternativa valiosa para desenvolvedores.

Se você quer aprender mais sobre a família de LLMs da Mistral, recomendo estes posts:

• Mistral Large 2
• Codestral 22B
• Codestral 22B API Tutorial: Getting Started With Mistral’s API