Preparing Datasets for Fine-Tuning ML Models: A Comprehensive Guide

O ajuste fino dos modelos de aprendizado de máquina começa com conjuntos de dados bem preparados. Este guia o orientará sobre como criar esses conjuntos de dados, desde a coleta de dados até a criação de arquivos de instruções. Ao final, você estará equipado com conhecimentos práticos e ferramentas para preparar conjuntos de dados de alta qualidade para suas tarefas de ajuste fino.

Esta postagem continua os guias de detalhes de Preparação de dados para RAGe Criação de aplicativos RAG de ponta a ponta com a pesquisa vetorial do Couchbase.

Visão geral de alto nível

Coleta de dados

A primeira etapa é a coleta de dados de várias fontes. Isso envolve a coleta de informações brutas que, posteriormente, serão limpas e organizadas em conjuntos de dados estruturados.

Para obter um guia detalhado e passo a passo sobre a preparação de dados para a geração aumentada de recuperação, consulte nossa publicação abrangente no blog: "Guia passo a passo para preparar dados para a geração aumentada de recuperação".

Nossa abordagem à coleta de dados

Em nossa abordagem, utilizamos vários métodos para coletar todos os dados relevantes:

1. Raspagem da Web usando o Scrapy:
  - Scrapy é uma poderosa estrutura Python para extrair dados de sites. Ele permite que você escreva spiders que rastreiam sites e extraem dados com eficiência.
2. Extração de documentos do Confluence:
  - Fizemos o download direto dos documentos armazenados em nosso espaço de trabalho do Confluence. Mas isso também pode ser feito utilizando a função API do Confluence que envolveria a criação de scripts para automatizar o processo de extração.
3. Recuperação de arquivos relevantes dos repositórios Git:
  - Foram criados scripts personalizados para clonar repositórios e extrair arquivos relevantes. Isso garantiu a coleta de todos os dados necessários armazenados em nossos sistemas de controle de versão.

Ao combinar esses métodos, garantimos um processo de coleta de dados abrangente e eficiente, cobrindo todas as fontes necessárias.

Extração de conteúdo de texto

Depois que os dados são coletados, a próxima etapa crucial é a extração de texto de documentos, como páginas da Web e PDFs. Esse processo envolve a análise desses documentos para obter dados de texto limpos e estruturados.

Para obter etapas detalhadas e exemplos de código sobre a extração de texto dessas fontes, consulte nosso guia abrangente na postagem do blog: "Guia passo a passo para preparar dados para a geração aumentada de recuperação".

Bibliotecas usadas para extração de texto

- HTML: BeautifulSoup é usado para navegar em estruturas HTML e extrair conteúdo de texto.
- PDFs: PyPDF2 facilita a leitura de arquivos PDF e a extração de texto de cada página.

Essas ferramentas nos permitem transformar documentos não estruturados em dados de texto organizados, prontos para processamento posterior.

Criação de dados JSON de amostra

Esta seção se concentra na geração de instruções para a criação de conjuntos de dados usando funções como generate_content() e generate_instructions()que derivam perguntas com base no conhecimento do domínio.

Geração de instruções (perguntas)

Para gerar perguntas de instrução, seguiremos estas etapas:

1. Seções de pedaços: O texto é dividido semanticamente para garantir perguntas significativas e contextualmente relevantes.
2. Formule perguntas: Esses blocos são enviados a um modelo de linguagem (LLM), que gera perguntas com base no bloco recebido.
3. Criar formato JSON: Por fim, estruturaremos as perguntas e as informações associadas em um formato JSON para facilitar o acesso e a utilização.

Amostra instructions.json

Aqui está um exemplo do que o instructions.json pode ter a aparência de um arquivo depois de gerar e salvar as instruções:

[
    "What is the significance of KV-Engine in the context of Magma Storage Engine?",
    "What is the significance of Architecture in the context of Magma Storage Engine?"
]

[

"Qual é a importância do KV-Engine no contexto do Magma Storage Engine?",

"Qual é a importância da arquitetura no contexto do Magma Storage Engine?"

]

Implementação

Para implementar esse processo:

1. Carregar conhecimento do domínioRecuperar informações específicas do domínio de um arquivo designado
2. Gerar instruções: utilizar funções como generate_content() para decompor os dados e formular perguntas usando generate_instructions()
3. Salvar perguntas: uso save_instructions() para armazenar perguntas geradas em um arquivo JSON

gerar_conteúdo função

O gerar_conteúdo A função tokeniza o conhecimento do domínio em frases e gera perguntas lógicas com base nessas frases:

def generate_content(domain_knowledge, context):
    questions = []
    # Tokenize domain knowledge into sentences
    sentences = nltk.sent_tokenize(domain_knowledge)

    # Generate logical questions based on sentences
    for sentence in sentences:
        question = generate_instructions(sentence, context)
        questions.append(question)

    return questions

def gerar_conteúdo(conhecimento_do_domínio, contexto):

perguntas = []

# Tokenize o conhecimento do domínio em frases

sentenças = nltk.sent_tokenize(conhecimento_do_domínio)

# Gerar perguntas lógicas com base em frases

para sentença em sentenças:

pergunta = gerar_instruções(sentença, contexto)

perguntas.anexar(pergunta)

retorno perguntas

gerar_instruções função

Essa função demonstra como gerar perguntas de instrução usando uma API de modelo de idioma:

def generate_instructions(domain, context):
    prompt = "Generate a question from the domain knowledge provided which can be answered with the domain knowledge given. Don't create or print any numbered lists, no greetings, directly print the question."
    url = 'http://localhost:11434/api/generate'
    data = {"model": model, "stream": False, "prompt": f"[DOMAIN] {domain} [/DOMAIN] [CONTEXT] {context} [/CONTEXT] {prompt}"}
    response = requests.post(url, json=data)
    response.raise_for_status()

    return response.json()['response'].strip()

def gerar_instruções(domínio, contexto):

imediato = "Gere uma pergunta a partir do conhecimento de domínio fornecido que possa ser respondida com o conhecimento de domínio fornecido. Não crie nem imprima nenhuma lista numerada, nenhuma saudação, imprima diretamente a pergunta."

url = 'http://localhost:11434/api/generate'

dados = {"model" (modelo): modelo, "stream" (fluxo): Falso, "prompt": f"[DOMAIN] {domínio} [/DOMAIN] [CONTEXT] {context} [/CONTEXT] {prompt}"}

resposta = solicitações.postagem(url, json=dados)

resposta.raise_for_status()

retorno resposta.json()['resposta'].faixa()

Carregando e salvando conhecimento de domínio

Usamos duas funções adicionais: load_domain_knowledge() para carregar o conhecimento de domínio de um arquivo e save_instructions() para salvar as instruções geradas em um arquivo JSON.

load_domain_knowledge função

Essa função carrega o conhecimento de domínio de um arquivo especificado.

def load_domain_knowledge(domain_file):
    with open(domain_file, 'r') as file:
        domain_knowledge = file.read()
    return domain_knowledge

def load_domain_knowledge(arquivo_de_domínio):

com aberto(arquivo_de_domínio, 'r') como arquivo:

conhecimento_do_domínio = arquivo.ler()

retorno conhecimento_do_domínio

save_instructions função

Essa função salva as instruções geradas em um arquivo JSON:

def save_instructions(instructions, filename):
    with open(filename, 'w') as file:
        json.dump(instructions, file, indent=4)

def save_instructions(instruções, nome do arquivo):

com aberto(nome do arquivo, 'w') como arquivo:

json.lixão(instruções, arquivo, recuo=4)

Exemplo de uso

Veja a seguir um exemplo que demonstra como essas funções funcionam juntas:

# Example usage
domain_file = "domain_knowledge.txt"
context = "sample context"
domain_knowledge = load_domain_knowledge(domain_file)
instructions = generate_content(domain_knowledge, context)
save_instructions(instructions, "instructions.json")

# Exemplo de uso

arquivo_de_domínio = "domain_knowledge.txt"

contexto = "contexto de amostra"

conhecimento_do_domínio = load_domain_knowledge(arquivo_de_domínio)

instruções = gerar_conteúdo(conhecimento_do_domínio, contexto)

save_instructions(instruções, "instructions.json")

Esse fluxo de trabalho permite a criação e o armazenamento eficientes de perguntas para a preparação do conjunto de dados.

Geração de conjuntos de dados (treinamento, teste, validação)

Esta seção o orienta na criação de conjuntos de dados para ajustar vários modelos, como o Mistral 7B, usando o Llama2 da Ollama. Para garantir a precisão, você precisará do conhecimento do domínio armazenado em arquivos como domínio.txt.

Funções Python para criação de conjuntos de dados

query_ollama Função

Essa função solicita respostas e perguntas de acompanhamento ao modelo Llama 2 da Ollama com base em prompts específicos e no contexto do domínio:

def query_ollama(prompt, domain, context='', model='llama2'): 
  url = 'http://localhost:11434/api/generate'
  data = {"model": model, "stream": False, "prompt": f"[DOMAIN] {domain} [/DOMAIN] [CONTEXT] {context} [/CONTEXT] {prompt}"}
  response = requests.post(url, json=data)
  response.raise_for_status()

  followup_data = {"model": model, "stream": False, "prompt": response.json()['response'].strip() + "What is a likely follow-up question or request? Return just the text of one question or request."}

  followup_response = requests.post(url, json=followup_data)
  followup_response.raise_for_status()
  return response.json()['response'].strip(), followup_response.json()['response'].replace("\"", "").strip()

def query_ollama(imediato, domínio, contexto='', modelo='llama2'):

url = 'http://localhost:11434/api/generate'

dados = {"model" (modelo): modelo, "stream" (fluxo): Falso, "prompt": f"[DOMAIN] {domínio} [/DOMAIN] [CONTEXT] {context} [/CONTEXT] {prompt}"}

resposta = solicitações.postagem(url, json=dados)

resposta.raise_for_status()

dados_de_acompanhamento = {"model" (modelo): modelo, "stream" (fluxo): Falso, "prompt": resposta.json()['resposta'].faixa() + "Qual é uma provável pergunta ou solicitação de acompanhamento? Retorne apenas o texto de uma pergunta ou solicitação."}

followup_response = solicitações.postagem(url, json=dados_de_acompanhamento)

followup_response.raise_for_status()

retorno resposta.json()['resposta'].faixa(), followup_response.json()['resposta'].substituir("\"", "").faixa()

create_validation_file função

Essa função divide os dados em conjuntos de treinamento, teste e validação, salvando-os em arquivos separados para o treinamento do modelo:

def create_validation_file(temp_file, train_file, valid_file, test_file):
with open(temp_file, 'r') as file:
    lines = file.readlines()

train_lines = lines[:int(len(lines) * 0.8)]
test_lines = lines[int(len(lines) * 0.8):int(len(lines) * 0.9)]
valid_lines = lines[int(len(lines) * 0.9):]

with open(train_file, 'a') as file:
    file.writelines(train_lines)

with open(valid_file, 'a') as file:
    file.writelines(valid_lines)

with open(test_file, 'a') as file:
    file.writelines(test_lines)

def create_validation_file(temp_file, arquivo_de_treinamento, valid_file, arquivo_teste):

com aberto(temp_file, 'r') como arquivo:

linhas = arquivo.linhas de leitura()

linhas_de_trem = linhas[:int(len(linhas) * 0.8)]

linhas_teste = linhas[int(len(linhas) * 0.8):int(len(linhas) * 0.9)]

valid_lines = linhas[int(len(linhas) * 0.9):]

com aberto(arquivo_de_treinamento, 'a') como arquivo:

arquivo.linhas de escrita(linhas_de_trem)

com aberto(valid_file, 'a') como arquivo:

arquivo.linhas de escrita(valid_lines)

com aberto(arquivo_teste, 'a') como arquivo:

arquivo.linhas de escrita(linhas_teste)

Gerenciamento da criação de conjuntos de dados

principal função

A função principal coordena a geração do conjunto de dados, desde a consulta ao Llama 2 do Ollama até a formatação dos resultados em arquivos JSONL para treinamento do modelo:

def main(temp_file, instructions_file, train_file, valid_file, test_file, domain_file, context=''):
# Check if instructions file exists
if not Path(instructions_file).is_file():
    sys.exit(f'{instructions_file} not found.')

# Check if domain file exists
if not Path(domain_file).is_file():
    sys.exit(f'{domain_file} not found.')

# Load domain knowledge
domain = load_domain(domain_file)

# Load instructions from file
with open(instructions_file, 'r') as file:
    instructions = json.load(file)

# Process each instruction
for i, instruction in enumerate(instructions, start=1):
    print(f"Processing ({i}/{len(instructions)}): {instruction}")
      
    # Query Ollama's llama2 model to get model answer and follow-up question
    answer, followup_question = query_ollama(instruction, domain, context)
      
    # Format the result in JSONL format
    result = json.dumps({
        'text': f'<s>[INST] {instruction}[/INST] {answer}</s>[INST]{followup_question}[/INST]'
    }) + "\n"
      
    # Write the result to temporary file
    with open(temp_file, 'a') as file:
        file.write(result)

# Create train, test, and validate files
create_validation_file(temp_file, train_file, valid_file, test_file)
print("Done! Training, testing, and validation JSONL files created.")

def principal(temp_file, arquivo_de_instruções, arquivo_de_treinamento, valid_file, arquivo_teste, arquivo_de_domínio, contexto=''):

# Verifique se o arquivo de instruções existe

se não Caminho(arquivo_de_instruções).is_file():

sistema.saída(f'{instructions_file} não encontrado'.)

# Verifique se o arquivo de domínio existe

se não Caminho(arquivo_de_domínio).is_file():

sistema.saída(f'{domain_file} não encontrado'.)

# Conhecimento do domínio de carga

domínio = load_domain(arquivo_de_domínio)

# Carregar instruções do arquivo

com aberto(arquivo_de_instruções, 'r') como arquivo:

instruções = json.carregar(arquivo)

# Processar cada instrução

para i, instrução em enumerar(instruções, iniciar=1):

impressão(f"Processando ({i}/{len(instruções)}): {instruction}")

# Consultar o modelo llama2 da Ollama para obter a resposta do modelo e a pergunta de acompanhamento

resposta, followup_question = query_ollama(instrução, domínio, contexto)

# Formatar o resultado no formato JSONL

resultado = json.lixeiras({

'texto': f'~~[INST] {instruction}[/INST] {answer}~~[INST]{followup_question}[/INST]'

}) + "\n"

# Gravar o resultado em um arquivo temporário

com aberto(temp_file, 'a') como arquivo:

arquivo.escrever(resultado)

# Criar arquivos de treinamento, teste e validação

create_validation_file(temp_file, arquivo_de_treinamento, valid_file, arquivo_teste)

impressão("Feito! Arquivos JSONL de treinamento, teste e validação criados.")

Usando essas ferramentas

Para começar a refinar modelos como o Mistral 7B com o Llama 2 da Ollama:

1. Preparar o conhecimento do domínio: armazenar detalhes específicos do domínio em domínio.txt
2. Gerar instruções: criar um arquivo JSON, instructions.jsoncom prompts para criação de conjuntos de dados
3. Execute a função principal: executar principal() com caminhos de arquivos para criar conjuntos de dados para treinamento e validação de modelos

Essas funções Python permitem que você desenvolva conjuntos de dados que otimizam os modelos de aprendizado de máquina, melhorando o desempenho e a precisão de aplicativos avançados.

Conclusão

Isso é tudo por hoje! Com essas etapas, você agora tem o conhecimento e as ferramentas para aprimorar seu processo de treinamento de modelos de aprendizado de máquina. Agradecemos sua leitura e esperamos que você tenha achado este guia valioso. Não deixe de explorar nossos outros blogs para obter mais insights. Fique atento à próxima parte desta série e confira outros blogs relacionados à pesquisa de vetores. Boa modelagem e até a próxima!

Referências

Contribuintes

Sanjivani Patra – Nishanth VM – Ashok Kumar Alluri

Sanjivani Patra - Engenheiro de software

Plataforma

Autogerenciado

Serviços

Recursos

Por que o Couchbase?

Migrar para o Capella

Por caso de uso

Por setor

Por necessidade de aplicativo

Documentos populares

Por função de desenvolvedor

COMUNIDADE

Participe da comunidade de desenvolvedores

Centro de recursos

Educação

Comparar

Sobre

Parcerias

Nossos serviços

Parceiros: Registrar um negócio

Pronto para registrar um negócio com o Couchbase?

Marriott

Todas as publicações

Preparação de conjuntos de dados para ajuste fino de modelos de ML: Um guia abrangente