Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Arquitetura Multimodal dos Modelos Mistral

Aula 2 de 12 Atualizada a 29 de julho de 2026 Programador
Nesta página
  1. Como é que um modelo processa texto e imagens?
  2. O Codificador Visual (Vision Encoder)
  3. Fusão Texto-Imagem no LLM
  4. Impacto na Contagem de Tokens
  5. Limites de Tamanho e Resolução
  6. Arquitetura Simplificada
  7. Pontos-chave

Como é que um modelo processa texto e imagens?

Quando envia uma imagem para um modelo Mistral, este não a “vê” da mesma forma que um ser humano. O processamento baseia-se numa arquitetura de duas fases: primeiro, um codificador visual transforma a imagem numa sequência de tokens numéricos; em seguida, o modelo de linguagem processa esses tokens visuais juntamente com os tokens de texto do seu prompt.

Esta lição pode parecer teórica, mas é, na verdade, a parte mais rentável do curso. Compreender este mecanismo explica por que razão uma imagem 4K não produz resultados melhores do que uma imagem 1080p, por que razão a sua fatura mensal dispara mais rapidamente com cinco imagens do que com cinco parágrafos e por que razão o texto minúsculo numa captura de ecrã é frequentemente transcrito de forma deficiente.

O Codificador Visual (Vision Encoder)

O codificador visual é uma rede neuronal especializada — tipicamente um Vision Transformer (ViT) — que divide a imagem em pequenos quadrados (patches), por exemplo de 14×14 píxeis, e os converte em embeddings numéricos. O pipeline executa-se em cinco etapas:

  1. Redimensionamento: a imagem é escalada para uma resolução padrão (ex.: 384×384 ou 768×768 píxeis)
  2. Extração de patches: a imagem redimensionada é dividida em patches regulares
  3. Projeção: cada patch é convertido num vetor numérico (embedding)
  4. Codificação posicional: a informação de posição de cada patch é adicionada
  5. Atenção: o transformador visual processa a sequência completa

O resultado é uma sequência de tokens visuais, totalmente comparável aos tokens de texto, exceto pelo facto de representarem regiões da imagem em vez de fragmentos de palavras. A primeira etapa merece a sua atenção: é ela que explica por que razão uma digitalização de fatura com 4.000 píxeis de largura é reduzida a algumas centenas de píxeis antes mesmo de a análise começar. Os caracteres em letra miúda, já no limite da legibilidade, tornam-se alguns píxeis desfocados.

Fusão Texto-Imagem no LLM

Uma vez gerados os tokens visuais, estes são inseridos na sequência de entrada do modelo de linguagem, juntamente com os tokens de texto. O modelo processa tudo de forma uniforme graças ao mecanismo de atenção cruzada (cross-attention).

[text tokens: "Describe this image"] + [visual tokens: patch1, patch2, ..., patchN]
                                    ↓
                          Language Model (LLM)
                                    ↓
                    [output tokens: "This image shows..."]

O modelo pode assim “ler” a imagem e o texto simultaneamente, permitindo-lhe responder a perguntas específicas sobre o conteúdo visual. Isto explica também por que razão uma pergunta feita antes da imagem e outra feita depois não produzem exatamente o mesmo resultado: tudo reside na mesma sequência e a ordem importa.

Impacto na Contagem de Tokens

Cada imagem consome um determinado número de tokens, dependendo da sua resolução após o redimensionamento. Esta é a conclusão principal para estimar os seus custos. Uma imagem padrão, com cerca de 768×768, consome entre 800 e 1.500 tokens — o equivalente a uma ou duas páginas de texto. As imagens maiores são redimensionadas antes do processamento: enviar uma imagem 4K não custa mais do que uma imagem 1080p, mas também não lhe traz qualquer vantagem. A este total, acrescente os tokens do seu prompt e da resposta gerada.

# Exemplo: estimar o custo de uma chamada de visão
tokens_image = 1000  # estimativa média
tokens_prompt = 50   # "Descreva esta imagem em detalhe"
tokens_response = 200  # resposta estimada

total_tokens = tokens_image + tokens_prompt + tokens_response
print(f"Estimated total tokens: {total_tokens}")
# → Estimated total tokens: 1250

Execute este cálculo com o seu próprio volume antes de industrializar: mil imagens por dia representam pelo menos um milhão de tokens de entrada, mudando a conversa de protótipo para orçamento.

Limites de Tamanho e Resolução

O Mistral aceita os formatos JPEG, PNG, GIF (apenas o primeiro quadro) e WebP, com um tamanho máximo de cerca de 20 MB por imagem. Várias imagens podem coexistir numa única mensagem, um tópico que abordaremos na Lição 6. A restrição mais contra-intuitiva permanece o redimensionamento interno: uma resolução muito elevada não melhora os resultados; apenas aumenta o tempo de transferência.

A consequência prática é que deve redimensionar as imagens você mesmo a montante, em vez de deixar a API fazê-lo após um upload desnecessariamente pesado:

from PIL import Image

def prepare_image(path, max_size=1024):
    """Redimensiona uma imagem antes do envio para otimizar a latência."""
    img = Image.open(path)
    img.thumbnail((max_size, max_size))
    img.save(path, quality=85)
    return path

Insira esta função imediatamente antes da codificação Base64 ou da hospedagem por URL. Num lote de fotografias de smartphone de 4 MB, isto reduz o volume transferido num fator significativo, sem perda de qualidade relevante para a análise.

Arquitetura Simplificada

De ponta a ponta, o percurso de um pedido resume-se a cinco etapas: envia uma mensagem contendo texto e uma ou mais imagens; a API redimensiona cada imagem e envia-a para o codificador visual; os tokens visuais resultantes fundem-se com os tokens de texto; o modelo gera uma resposta em linguagem natural; recebe-a tal como numa chamada de texto padrão. Nada muda no seu código do lado da API — o Mistral gere toda a complexidade — mas isso não significa que possa ignorar o custo que isso representa para si.

Pontos-chave

  • As imagens são convertidas em tokens visuais por um codificador Vision Transformer
  • O LLM processa estes tokens visuais tal como os tokens de texto
  • Uma imagem padrão consome aproximadamente 800 a 1.500 tokens
  • As imagens são redimensionadas internamente — não é necessário enviar resoluções muito elevadas
  • Redimensionar as imagens no lado do cliente reduz a latência sem perda de qualidade