Guia de inferência de LLM para Web

A API LLM Inference permite executar modelos de linguagem grandes (LLMs) totalmente no dispositivo para aplicativos da Web, que podem ser usados para realizar uma ampla gama de tarefas, como gerar texto, recuperar informações em linguagem natural e resumir documentos. A tarefa oferece suporte integrado a vários modelos de linguagem grandes de texto para texto. Assim, você pode aplicar os modelos de IA generativa mais recentes no dispositivo aos seus apps da Web.

Para adicionar rapidamente a API LLM Inference ao seu aplicativo da Web, siga o guia de início rápido. Para conferir um exemplo básico de um aplicativo da Web que executa a API LLM Inference, consulte o exemplo de aplicativo. Para entender melhor como a API LLM Inference funciona, consulte as seções opções de configuração, conversão de modelos e ajuste de LoRA.

Confira essa tarefa em ação com a demonstração do MediaPipe Studio. Para mais informações sobre os recursos, modelos e opções de configuração dessa tarefa, consulte a Visão geral.

Guia de início rápido

Siga as etapas abaixo para adicionar a API LLM Inference ao seu aplicativo da Web. A API de inferência LLM requer um navegador da Web com compatibilidade com o WebGPU. Para conferir uma lista completa de navegadores compatíveis, consulte Compatibilidade de navegadores com GPU.

Adicionar dependências

A API LLM Inference usa o pacote @mediapipe/tasks-genai.

Instale os pacotes necessários para a preparação local:

npm install @mediapipe/tasks-genai

Para implantar em um servidor, use um serviço de rede de fornecimento de conteúdo (CDN), como o jsDelivr, para adicionar código diretamente à página HTML:

<head>
  <script src="https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai/genai_bundle.cjs"
    crossorigin="anonymous"></script>
</head>

Fazer o download de um modelo

Faça o download do Gemma-2 2B em um formato quantizado de 8 bits em Modelos Kaggle. Para mais informações sobre os modelos disponíveis, consulte a documentação de modelos.

Armazene o modelo no diretório do projeto:

<dev-project-root>/assets/gemma-2b-it-gpu-int8.bin

Especifique o caminho do modelo com o parâmetro modelAssetPath do objeto baseOptions:

baseOptions: { modelAssetPath: `/assets/gemma-2b-it-gpu-int8.bin`}

Inicializar a tarefa

Inicialize a tarefa com opções de configuração básicas:

const genai = await FilesetResolver.forGenAiTasks(
    // path/to/wasm/root
    "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
llmInference = await LlmInference.createFromOptions(genai, {
    baseOptions: {
        modelAssetPath: '/assets/gemma-2b-it-gpu-int8.bin'
    },
    maxTokens: 1000,
    topK: 40,
    temperature: 0.8,
    randomSeed: 101
});

Executar a tarefa

Use a função generateResponse() para acionar inferências.

const response = await llmInference.generateResponse(inputPrompt);
document.getElementById('output').textContent = response;

Para transmitir a resposta, use o seguinte:

llmInference.generateResponse(
  inputPrompt,
  (partialResult, done) => {
        document.getElementById('output').textContent += partialResult;
});

Exemplo de aplicativo

O aplicativo de exemplo é um exemplo de um app básico de geração de texto para Web, usando a API LLM Inference. Você pode usar o app como ponto de partida para seu próprio app da Web ou consultá-lo ao modificar um app existente. O código de exemplo está hospedado no GitHub.

Clone o repositório do Git usando o seguinte comando:

git clone https://github.com/google-ai-edge/mediapipe-samples

Para mais informações, consulte o Guia de configuração para a Web.

Opções de configuração

Use as opções de configuração a seguir para configurar um app da Web:

Nome da opção Descrição Intervalo de valor Valor padrão
modelPath O caminho para onde o modelo é armazenado no diretório do projeto. CAMINHO N/A
maxTokens O número máximo de tokens (tokens de entrada + tokens de saída) que o modelo processa. Número inteiro 512
topK O número de tokens que o modelo considera em cada etapa de geração. Limita as previsões aos k tokens mais prováveis. Número inteiro 40
temperature A quantidade de aleatoriedade introduzida durante a geração. Uma temperatura mais alta resulta em mais criatividade no texto gerado, enquanto uma temperatura mais baixa produz uma geração mais previsível. Ponto flutuante 0,8
randomSeed A semente aleatória usada durante a geração de texto. Número inteiro 0
loraRanks Classificações da LoRA que serão usadas pelos modelos da LoRA durante a execução. Observação: esse recurso é compatível apenas com modelos de GPU. Matriz de números inteiros N/A

Conversão de modelos

A API LLM Inference é compatível com os seguintes tipos de modelos, alguns dos quais exigem conversão de modelo. Use a tabela para identificar o método de etapas necessário para seu modelo.

Modelos Método de conversão Plataformas compatíveis Tipo de arquivo
Gemma-3 1B Nenhuma conversão é necessária Android, Web .task
Gemma 2B, Gemma 7B, Gemma-2 2B Nenhuma conversão é necessária Android, iOS e Web .bin
Phi-2, StableLM, Falcon Script de conversão do MediaPipe Android, iOS e Web .bin
Todos os modelos LLM do PyTorch Biblioteca generativa AI Edge Torch Android, iOS .task

Para saber como converter outros modelos, consulte a seção Conversão de modelos.

Personalização da LoRA

A API Inference LLM oferece suporte ao ajuste da LoRA (adaptação de classificação baixa) usando a biblioteca PEFT (ajuste fino de eficiência de parâmetros). O ajuste do LoRA personaliza o comportamento dos LLMs por meio de um processo de treinamento econômico, criando um pequeno conjunto de pesos treináveis com base em novos dados de treinamento em vez de treinar o modelo inteiro novamente.

A API de inferência LLM oferece suporte à adição de pesos de LoRA às camadas de atenção dos modelos Gemma-2 2B, Gemma 2B e Phi-2. Faça o download do modelo no formato safetensors.

O modelo base precisa estar no formato safetensors para criar pesos de LoRA. Após o treinamento do LoRA, você pode converter os modelos no formato FlatBuffers para execução no MediaPipe.

Preparar pesos da LoRA

Use o guia Métodos LoRA do PEFT para treinar um modelo LoRA ajustado no seu conjunto de dados.

A API de inferência de LLM só oferece suporte a LoRA em camadas de atenção. Portanto, especifique apenas as camadas de atenção em LoraConfig:

# For Gemma
from peft import LoraConfig
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)

# For Phi-2
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "dense"],
)

Depois de treinar no conjunto de dados preparado e salvar o modelo, os pesos do modelo LoRA ajustados estarão disponíveis em adapter_model.safetensors. O arquivo safetensors é o ponto de verificação do LoRA usado durante a conversão do modelo.

Conversão de modelos

Use o pacote MediaPipe Python para converter os pesos do modelo no formato Flatbuffer. O ConversionConfig especifica as opções de modelo básico e as opções adicionais do LoRA.

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_FILE,
)

converter.convert_checkpoint(config)

O conversor vai produzir dois arquivos compatíveis com o MediaPipe, um para o modelo base e outro para o modelo LoRA.

Inferência de modelo LoRA

A Web oferece suporte ao LoRA dinâmico durante a execução, o que significa que os usuários declaram as classificações do LoRA durante a inicialização. Isso significa que você pode trocar diferentes modelos de LoRa durante a execução.

const genai = await FilesetResolver.forGenAiTasks(
    // path/to/wasm/root
    "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
const llmInference = await LlmInference.createFromOptions(genai, {
    // options for the base model
    ...
    // LoRA ranks to be used by the LoRA models during runtime
    loraRanks: [4, 8, 16]
});

Carregue os modelos LoRA durante a execução, depois de inicializar o modelo base. Acione o modelo LoRA transmitindo a referência do modelo ao gerar a resposta do LLM.

// Load several LoRA models. The returned LoRA model reference is used to specify
// which LoRA model to be used for inference.
loraModelRank4 = await llmInference.loadLoraModel(loraModelRank4Url);
loraModelRank8 = await llmInference.loadLoraModel(loraModelRank8Url);

// Specify LoRA model to be used during inference
llmInference.generateResponse(
  inputPrompt,
  loraModelRank4,
  (partialResult, done) => {
        document.getElementById('output').textContent += partialResult;
});