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:
-
- Raspagem da Web usando o Scrapy:
- Sucata é uma poderosa estrutura Python para extrair dados de sites. Ele permite que você escreva spiders que rastreiam sites e extraem dados com eficiência.
- 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.
- 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.
- Raspagem da Web usando o Scrapy:
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:
-
- Seções de pedaços: O texto é dividido semanticamente para garantir perguntas significativas e contextualmente relevantes.
- Formule perguntas: Esses blocos são enviados a um modelo de linguagem (LLM), que gera perguntas com base no bloco recebido.
- 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:
|
1 2 3 4 |
[ "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?" ] |
Implementação
Para implementar esse processo:
-
- Carregar conhecimento do domínioRecuperar informações específicas do domínio de um arquivo designado
- Gerar instruções: utilizar funções como
generate_content()para decompor dados e formular perguntas usandogenerate_instructions() - 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:
|
1 2 3 4 5 6 7 8 9 10 11 |
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 |
gerar_instruções função
Essa função demonstra como gerar perguntas de instrução usando uma API de modelo de idioma:
|
1 2 3 4 5 6 7 8 |
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 = 'https://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() |
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.
|
1 2 3 4 |
def load_domain_knowledge(domain_file): with open(domain_file, 'r') as file: domain_knowledge = file.read() return domain_knowledge |
save_instructions função
Essa função salva as instruções geradas em um arquivo JSON:
|
1 2 3 |
def save_instructions(instructions, filename): with open(filename, 'w') as file: json.dump(instructions, file, indent=4) |
Exemplo de uso
Veja a seguir um exemplo que demonstra como essas funções funcionam juntas:
|
1 2 3 4 5 6 |
# 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") |
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:
|
1 2 3 4 5 6 7 8 9 10 11 |
def query_ollama(prompt, domain, context='', model='llama2'): url = 'https://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() |
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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
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) |
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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
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.") |
Usando essas ferramentas
Para começar a refinar modelos como o Mistral 7B com o Llama 2 da Ollama:
-
- Preparar o conhecimento do domínio: armazenar detalhes específicos do domínio em
domínio.txt - Gerar instruções: criar um arquivo JSON,
instructions.jsoncom prompts para criação de conjuntos de dados - Execute a função principal: executar
principal()com caminhos de arquivos para criar conjuntos de dados para treinamento e validação de modelos
- Preparar o conhecimento do domínio: armazenar detalhes específicos do domínio em
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
