Introdução
Você está intrigado com o LLM de recuperação aumentada de ponta ‘bge-large-en-v1.5’? Junte-se a nós neste blog enquanto exploramos este modelo em profundidade. Você descobrirá o papel dos modelos de embedding e suas aplicações práticas. Vamos guiá-lo pela implantação do ‘bge-large-en-v1.5’ em código, seu ajuste fino e sua integração perfeita com a LLM API. Prepare-se para desbloquear novas possibilidades na interseção de modelos de embedding e LLMs!
O que é o bge-large-en-v1.5?
Em resumo, o bge-large-en-v1.5 é um modelo de embedding de código aberto criado pela BAAI.
Especificamente, ‘bge’ em ‘bge-large-en-v1.5’ significa ‘BAAI General Embedding’. A BAAI, também conhecida como ‘FlagEmbedding’ no Github, é uma organização privada sem fins lucrativos dedicada à pesquisa e desenvolvimento de IA. Focada em modelos de linguagem grandes (LLMs) de recuperação aumentada, a BAAI lançou diversos projetos relacionados. Estes incluem LLM de contexto longo (Activation Beacon), ajuste fino de LM (LM-Cocktail), recuperação densa (BGE-M3, LLM Embedder, BGE Embedding), modelo de reranking (BGE Reranker) e benchmarking (C-MTEB). O bge-large-en-v1.5 pertence à série de modelos BGE Embedding, desenvolvido especificamente para fins de recuperação densa.
O que faz um modelo de embedding para recuperação densa?
Um modelo de embedding para recuperação densa transforma dados de texto em representações densas e semânticas que capturam o significado e o contexto da entrada. Essas representações densas são usadas por um recuperador denso para recuperar informações relevantes de forma eficiente. Veja como funciona e alguns exemplos:
Transformando texto em representações densas
O modelo de embedding recebe frases, parágrafos ou documentos inteiros como entrada e os converte em vetores de comprimento fixo (embeddings). Esses vetores codificam informações semânticas sobre o texto, permitindo uma compreensão mais sutil além da simples correspondência de palavras-chave.
LLMs frequentemente incorporam modelos de embedding como parte de sua arquitetura. Por exemplo, o BERT usa técnicas de embedding para representar palavras e sequências de entrada antes de processá-las através de suas camadas transformer. Os LLMs se beneficiam dos modelos de embedding ao alavancar sua capacidade de capturar relações semânticas e nuances contextuais, cruciais para gerar respostas coerentes e contextualmente apropriadas em tarefas como geração de diálogo ou tradução automática.
Papel do recuperador denso
O recuperador denso utiliza esses embeddings para realizar tarefas de recuperação. Diferentemente dos métodos tradicionais de recuperação esparsa que dependem de correspondências exatas de palavras-chave ou índices, um recuperador denso calcula diretamente pontuações de similaridade entre embeddings de consulta e embeddings de documento. Essa abordagem permite uma recuperação mais precisa em vários comprimentos de entrada de texto, desde frases curtas até documentos extensos.
Exemplos de aplicações
Em tarefas de recuperação de informação, como mecanismos de busca ou sistemas de perguntas e respostas, essas representações densas permitem a recuperação eficiente e precisa de documentos ou passagens relevantes.
Por exemplo, uma consulta como “Quais são os sintomas da COVID-19?” pode ser transformada em um vetor de embedding. Da mesma forma, documentos que discutem sintomas da COVID-19 também são convertidos em embeddings. Ao comparar a similaridade entre o embedding da consulta e os embeddings dos documentos (usando técnicas como similaridade de cosseno), os documentos mais relevantes podem ser rapidamente identificados e classificados.
Outro exemplo são os sistemas de recomendação. Nesse caso, os embeddings ajudam a recomendar produtos, artigos ou vídeos ao compreender as preferências do usuário e as similaridades de conteúdo.
No geral, modelos de embedding para recuperação densa, em conjunto com recuperadores densos, desempenham um papel crucial em aplicações modernas de IA ao transformar texto em representações significativas e recuperar informações relevantes de forma eficiente com base na similaridade semântica.
Como posso usar o bge-large-en-v1.5 em código?
Usando bge-large-en-v1.5 com Langchain
Você pode usar bge no langchain assim:
from langchain.embeddings import HuggingFaceBgeEmbeddings
model_name = "BAAI/bge-large-en-v1.5"
model_kwargs = {'device': 'cuda'}
encode_kwargs = {'normalize_embeddings': True} # set True to compute cosine similarity
model = HuggingFaceBgeEmbeddings(
model_name=model_name,
model_kwargs=model_kwargs,
encode_kwargs=encode_kwargs,
query_instruction="Generate a representation for this sentence to be used for retrieving relevant articles:"
)
model.query_instruction = "Generate a representation for this sentence to be used for retrieving relevant articles:"
Usando bge-large-en-v1.5 com Huggingface Transformers
Com o pacote transformers, você pode usar o modelo assim: Primeiro, passe sua entrada pelo modelo transformer, depois selecione o último estado oculto do primeiro token (ou seja, [CLS]) como o embedding da frase.
from transformers import AutoTokenizer, AutoModel
import torch
# Sentences we want sentence embeddings for
sentences = ["Sample Data-1", "Sample Data-2"]
# Load model from HuggingFace Hub
tokenizer = AutoTokenizer.from_pretrained('BAAI/bge-large-en-v1.5')
model = AutoModel.from_pretrained('BAAI/bge-large-en-v1.5')
model.eval()
# Tokenize sentences
encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt')
# for s2p(short query to long passage) retrieval task, add an instruction to query (not add instruction for passages)
# encoded_input = tokenizer([instruction + q for q in queries], padding=True, truncation=True, return_tensors='pt')
# Compute token embeddings
with torch.no_grad():
model_output = model(**encoded_input)
# Perform pooling. In this case, cls pooling.
sentence_embeddings = model_output[0][:, 0]
# normalize embeddings
sentence_embeddings = torch.nn.functional.normalize(sentence_embeddings, p=2, dim=1)
print("Sentence embeddings:", sentence_embeddings)
Para mais informações sobre o uso dos modelos bge, visite FlagEmbedding no Github.
Como posso fazer o ajuste fino do bge-large-en-v1.5?
Passo 1 Instalação
- Instale usando pip:
pip install -U FlagEmbedding - Ou instale a partir da fonte após clonar o repositório e navegar até ele:
pip install . - Para desenvolvimento, use instalação editável:
pip install -e .
Passo 2 Preparação dos dados
- Os dados de treinamento devem estar em formato JSON, com cada linha sendo um dicionário contendo
query,pos(lista de textos positivos) eneg(lista de textos negativos). - Se textos negativos não estiverem disponíveis, eles podem ser amostrados aleatoriamente do corpus.
Passo 3 Mineração de negativos difíceis
- Use um script para minerar negativos difíceis a fim de melhorar a qualidade dos embeddings de frases.
- Você pode minerar negativos difíceis seguindo este comando:
python -m FlagEmbedding.baai_general_embedding.finetune.hn_mine \
--model_name_or_path BAAI/bge-base-en-v1.5 \
--input_file toy_finetune_data.jsonl \
--output_file toy_finetune_data_minedHN.jsonl \
--range_for_sampling 2-200 \
--negative_number 15 \
--use_gpu_for_searching
- Arquivo de entrada: Um arquivo JSON contendo dados para ajuste fino, onde o script identifica os top-k documentos por consulta e então seleciona aleatoriamente exemplos negativos desses top-k resultados, excluindo quaisquer exemplos positivos já fornecidos.
- Arquivo de saída: O destino onde o arquivo JSON, agora enriquecido com os novos negativos difíceis amostrados, será armazenado para uso no processo de ajuste fino.
- Número de negativos: Especifica quantas amostras negativas coletar.
- Intervalo de amostragem: Define o escopo de onde extrair as amostras negativas. Por exemplo, um intervalo de 2–100 indica que os negativos serão retirados dos documentos do top 2 ao top 200. Ampliar esse intervalo, por exemplo para 60–300, torna a seleção de negativos menos desafiadora ao considerar um conjunto mais amplo de documentos.
- Pool de recuperação: A fonte da qual o script extrairá documentos para recuperação. Por padrão, é o conjunto de todos os negativos no arquivo de entrada, formatado como dados de pré-treinamento. Se um pool de recuperação específico for designado, o script usará esse conjunto para encontrar exemplos negativos.
- Busca baseada em GPU: Uma opção para indicar se o faiss-gpu acelerado por GPU deve ser utilizado para aumentar a eficiência do processo de recuperação de negativos.
Passo 4 Treinamento
torchrun --nproc_per_node {number of gpus} \
-m FlagEmbedding.baai_general_embedding.finetune.run \
--output_dir {path to save model} \
--model_name_or_path BAAI/bge-large-en-v1.5 \
--train_data ./toy_finetune_data.jsonl \
--learning_rate 1e-5 \
--fp16 \
--num_train_epochs 5 \
--per_device_train_batch_size {large batch size; set 1 for toy data} \
--dataloader_drop_last True \
--normlized True \
--temperature 0.02 \
--query_max_len 64 \
--passage_max_len 256 \
--train_group_size 2 \
--negatives_cross_device \
--logging_steps 10 \
--save_steps 1000 \
--query_instruction_for_retrieval ""
- Tamanho do lote de treinamento por dispositivo: A quantidade de amostras processadas em cada lote de treinamento. Geralmente, um tamanho de lote maior melhora o desempenho do modelo. Você pode aumentar esse tamanho utilizando opções como treinamento de meia precisão (
--fp16), configuração DeepSpeed (--deepspeed ./df_config.json, ondedf_config.jsontambém pode ser denotado comods_config.json) e checkpointing de gradiente (--gradient_checkpointing). - Tamanho do grupo de treinamento: Determina o número total de exemplos, tanto positivos quanto negativos, usados para cada consulta durante o treinamento. Como há um exemplo positivo garantido, essa configuração determina a contagem de exemplos negativos (calculada como
train_group_size - 1). Este número não deve exceder os negativos disponíveis na listanegdos seus dados. Além desses negativos do grupo, outros negativos dentro do lote também são incorporados ao processo de ajuste fino. - Compartilhamento cruzado de negativos entre dispositivos: Permite a distribuição de exemplos negativos por todas as GPUs disponíveis, aumentando efetivamente o número total de negativos utilizados no treinamento.
- Taxa de aprendizado: Escolha um valor adequado ao seu modelo específico. Para modelos grandes, base ou de pequena escala, valores como 1e-5, 2e-5 ou 3e-5 são tipicamente recomendados.
- Temperatura: Afeta a dispersão da distribuição das pontuações de similaridade. Valores sugeridos variam de 0.01 a 0.1.
- Comprimento máximo da consulta: O limite superior para o comprimento da consulta, que deve corresponder ao comprimento médio das consultas em seu conjunto de dados.
- Comprimento máximo da passagem: O limite superior para o comprimento da passagem, definido de acordo com o comprimento médio das passagens em seus dados.
- Instrução de consulta para recuperação: Uma diretiva opcional anexada a cada consulta para fins de recuperação. Você pode deixá-la em branco definindo-a como uma string vazia se nenhum contexto adicional for necessário.
- Uso de negativos no lote: Um sinalizador indicando se as passagens do mesmo lote devem ser consideradas como exemplos negativos no treinamento. A configuração padrão está habilitada (True).
- Intervalo de salvamento de checkpoint: Define a frequência de salvamento dos checkpoints do modelo com base no número de etapas de treinamento concluídas.
Passo 5 Carregamento do modelo
Depois que o modelo BGE for ajustado, você pode carregá-lo facilmente conforme demonstrado neste exemplo. Se você especificou um valor único para o hiperparâmetro --query_instruction_for_retrieval durante a fase de ajuste fino, certifique-se de substituir o query_instruction_for_retrieval adequadamente.
Passo 6 Carregamento do modelo (Avaliação)
Para avaliação do modelo, você pode executar este script fornecido pelo FlagEmbedding.
Ajustar o modelo bge fundamental através de ajuste fino pode resultar em melhor desempenho específico para a tarefa, mas também pode causar um declínio notável na eficácia geral do modelo fora do domínio alvo (por exemplo, uma queda no desempenho em tarefas c-mteb). Para obter informações sobre a solução (usando LM-Cocktail), bem como o processo de ajuste fino, consulte “FlagEmbedding/examples/finetune” no Github.
Como posso integrar o bge-large-en-v1.5 com a LLM API?
Integrar um modelo de embedding com um LLM enriquece as capacidades de processamento de linguagem natural da IA, permitindo busca semântica mais sofisticada, compreensão contextual e interações personalizadas. Essa integração é particularmente útil para aprimorar tarefas como recomendações baseadas em conteúdo, agrupamento de documentos, detecção de anomalias, processamento multilíngue e construção de gráficos de conhecimento. Também suporta sumarização avançada de texto e aprimoramento de características para modelos de aprendizado de máquina, levando a melhor desempenho em análise de sentimentos e classificação de tópicos.
Passo 1: Configure seu ambiente
Primeiro, certifique-se de ter o ambiente Python necessário com os pacotes requeridos instalados.
pip install openai
# Install other necessary packages, e.g., requests, numpy, etc.
Passo 2: Inicialize o cliente da Novita AI API
Você já forneceu o código para inicializar o cliente da Novita AI API. Aqui está para referência:
from openai import OpenAI
client = OpenAI(
base_url="https://api.novita.ai/v3/openai",
api_key="<YOUR Novita AI API Key>", # Replace with your actual API key
)
model = "nousresearch/nous-hermes-llama2-13b"
Passo 3: Obtenha o modelo de embedding
Supondo que você tenha acesso ao modelo bge-large-en-v1.5, você o carregaria. Se for um modelo do Hugging Face, você pode usar a biblioteca transformers assim:
from transformers import AutoModel, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("BAAI/bge-large-en-v1.5")
model = AutoModel.from_pretrained("BAAI/bge-large-en-v1.5")
Passo 4: Defina uma função para obter embeddings
Crie uma função para obter embeddings do modelo bge-large-en-v1.5.
def get_embeddings(text):
inputs = tokenizer(text, return_tensors="pt")
with torch.no_grad():
embeddings = model(**inputs)[0].mean(dim=1)
return embeddings.numpy()
Passo 5: Integre com a Novita AI LLM API
Agora, integre o modelo de embedding com a LLM API para aprimorar as respostas da API ou realizar tarefas como busca semântica.
def enhanced_llm_response(prompt):
# Get initial response from LLM
response = client.completions.create(
model=model,
prompt=prompt,
stream=True,
max_tokens=512,
)
# Process the response (e.g., extract text)
# This is a placeholder for the actual response processing
response_text = next(response)['choices'][0]['text'].content
# Get embeddings for the response
response_embeddings = get_embeddings(response_text)
# Here, you can use the embeddings for various purposes,
# such as semantic search, filtering, etc.
return response_text, response_embeddings
Passo 6: Use a função aprimorada
Agora você pode usar a função enhanced_llm_response para obter respostas do LLM e processá-las com o modelo de embedding.
prompt = "A chat between a curious user and an artificial intelligence assistant"
response, embeddings = enhanced_llm_response(prompt)
print(response)
# Do something with the embeddings, e.g., store them, search for similar texts, etc.
Passo 7: Tratamento de erros e registro
Adicione tratamento de erros e registro ao seu código para gerenciar limites de API, falhas de solicitação e outros problemas potenciais.
Passo 8: Teste e itere
Teste a integração minuciosamente e itere com base nos resultados. Talvez seja necessário ajustar parâmetros, lidar com mais casos extremos ou otimizar o desempenho.
Observe que os detalhes reais da implementação podem variar com base nas capacidades e requisitos específicos da Novita AI LLM API e do modelo bge-large-en-v1.5. Você pode entrar em contato com a Equipe Novita AI para suporte técnico: support@novita.ai.
Conclusão
Em resumo, nossa exploração do ‘bge-large-en-v1.5’ destacou seu papel integral em tarefas de recuperação densa, oferecendo um mergulho profundo em suas capacidades, aplicações e implementação prática. Desde a introdução do modelo e sua importância no domínio dos embeddings até a demonstração de seu uso em código e seu processo de ajuste fino, apresentamos um guia abrangente. Além disso, a integração com a Novita AI LLM API exemplifica o potencial do modelo para amplificar a compreensão semântica e a precisão da recuperação dos LLMs.
Fique atento para mais atualizações sobre LLMs!
Perguntas Frequentes
1. Como funciona um BGE reranker?
Ao inserir uma consulta e uma passagem no reranker, você obtém uma pontuação de relevância. Essa pontuação pode ser transformada em um valor de ponto flutuante no intervalo [0, 1] usando uma função sigmoide. Esse processo visa garantir que os resultados principais sejam mais relevantes e de maior qualidade, melhorando o desempenho geral do sistema.
2. Qual é o comprimento de contexto do BGE?
O modelo mais recente, bge-m3, tem um comprimento de contexto de 8kb.
3. Qual é o tamanho do embedding bge m3?
Ele pode lidar com entradas de comprimentos variados, desde frases curtas até documentos extensos contendo até 8192 tokens.
Novita AI é a plataforma de nuvem completa que impulsiona suas ambições de IA. Com APIs perfeitamente integradas, computação serverless e aceleração de GPU, fornecemos as ferramentas econômicas que você precisa para construir e escalar rapidamente seu negócio orientado por IA. Elimine dores de cabeça com infraestrutura e comece gratuitamente — a Novita AI torna seus sonhos de IA realidade.
Leitura Recomendada
Desvendando o Poder do BGE Large: O Futuro dos Embeddings de Texto
