Hub GPT de banco de dados
V0.3.0
简体中文| Discórdia | Bate-papo | Abraçando o rosto | Comunidade | Papel
Texto2SQL | Texto2NLU
Métrica de precisão de execução de avaliação Text2SQL (ex), e iremos movê-la para src/dbgpt_hub_sql
| Modelo | Método | Fácil | Médio | Duro | Extra | Todos |
|---|---|---|---|---|---|---|
| base | 0 | 0 | 0 | 0 | 0 | |
| Llama2-7B-Chat | Lora | 0,887 | 0,641 | 0,489 | 0,331 | 0,626 |
| qlora | 0,847 | 0,623 | 0,466 | 0,361 | 0,608 | |
| base | 0 | 0 | 0 | 0 | 0 | |
| Lhama2-13B-Chat | Lora | 0,907 | 0,729 | 0,552 | 0,343 | 0,68 |
| qlora | 0,911 | 0,7 | 0,552 | 0,319 | 0,664 | |
| base | 0,214 | 0,177 | 0,092 | 0,036 | 0,149 | |
| CodeLlama-7B-Instrução | Lora | 0,923 | 0,756 | 0,586 | 0,349 | 0,702 |
| qlora | 0,911 | 0,751 | 0,598 | 0,331 | 0,696 | |
| base | 0,698 | 0,601 | 0,408 | 0,271 | 0,539 | |
| CodeLlama-13B-Instrução | Lora | 0,94 | 0,789 | 0,684 | 0,404 | 0,746 |
| qlora | 0,94 | 0,774 | 0,626 | 0,392 | 0,727 | |
| base | 0,577 | 0,352 | 0,201 | 0,066 | 0,335 | |
| Baichuan2-7B-Chat | Lora | 0,871 | 0,63 | 0,448 | 0,295 | 0,603 |
| qlora | 0,891 | 0,637 | 0,489 | 0,331 | 0,624 | |
| base | 0,581 | 0,413 | 0,264 | 0,187 | 0,392 | |
| Baichuan2-13B-Bate-papo | Lora | 0,903 | 0,702 | 0,569 | 0,392 | 0,678 |
| qlora | 0,895 | 0,675 | 0,58 | 0,343 | 0,659 | |
| base | 0,395 | 0,256 | 0,138 | 0,042 | 0,235 | |
| Qwen-7B-Chat | Lora | 0,855 | 0,688 | 0,575 | 0,331 | 0,652 |
| qlora | 0,911 | 0,675 | 0,575 | 0,343 | 0,662 | |
| base | 0,871 | 0,632 | 0,368 | 0,181 | 0,573 | |
| Qwen-14B-Bate-papo | Lora | 0,895 | 0,702 | 0,552 | 0,331 | 0,663 |
| qlora | 0,919 | 0,744 | 0,598 | 0,367 | 0,701 | |
| base | 0 | 0 | 0 | 0 | 0 | |
| Bate-papoGLM3-6b | Lora | 0,855 | 0,605 | 0,477 | 0,271 | 0,59 |
| qlora | 0,843 | 0,603 | 0,506 | 0,211 | 0,581 |
DB-GPT-Hub é um projeto experimental que aproveita Large Language Models (LLMs) para obter análise de texto para SQL. O projeto abrange várias etapas, incluindo coleta de dados, pré-processamento de dados, seleção e construção de modelos e ajuste fino de pesos de modelos. Através desses processos, nosso objetivo é aprimorar os recursos de Text-to-SQL e, ao mesmo tempo, reduzir os custos de treinamento de modelos, permitindo assim que mais desenvolvedores contribuam para melhorar a precisão do Text-to-SQL. Nosso objetivo final é implementar recursos automatizados de resposta a perguntas com base em bancos de dados, permitindo que os usuários executem consultas complexas em bancos de dados usando descrições em linguagem natural.
Até o momento, integramos com sucesso vários modelos grandes e estabelecemos um fluxo de trabalho abrangente que inclui processamento de dados, treinamento de modelo de ajuste fino supervisionado (SFT), resultados de previsão e avaliação. O código desenvolvido para este projeto é facilmente reutilizável dentro do próprio projeto.
Desde 10 de outubro de 2023, usamos este projeto para ajustar o modelo de código aberto de tamanho 13B, incorporando dados mais relevantes. Sob prompts zero-shot e utilizando o conjunto de testes baseado em Spider, alcançamos uma taxa de precisão de execução de 0,764 para um banco de dados com tamanho de 1,27G. Além disso, a precisão de execução do banco de dados apontada pelo site oficial do Spider, com tamanho de 95M, é de 0,825.
Melhoramos o desempenho do Text-to-SQL aplicando o Supervised Fine-Tuning (SFT) em modelos de linguagem grandes.
O conjunto de dados principal para os exemplos deste projeto é o conjunto de dados Spider :
Outros conjuntos de dados text2sql disponíveis:
WikiSQL: Um grande conjunto de dados de análise semântica que consiste em 80.654 expressões de instruções naturais e anotações SQL de 24.241 tabelas. Cada consulta no WikiSQL é limitada à mesma tabela e não contém operações complexas, como classificação, agrupamento. As consultas no WikiSQL são limitadas à mesma tabela e não incluem operações complexas, como classificação, agrupamento, subconsultas, etc.
CHASE: Um conjunto de dados chinês text2sql interativo de múltiplas rodadas entre domínios contendo uma lista de 5.459 perguntas de múltiplas rodadas consistindo em 17.940 grupos binários
BIRD-SQL: Um benchmark de texto para SQL de domínio cruzado em larga escala em inglês, com foco particular em conteúdo de banco de dados grande. O conjunto de dados contém 12.751 pares de dados texto para SQL e 95 bancos de dados com um tamanho total de 33,4 GB em 37 domínios ocupacionais. O conjunto de dados BIRD-SQL preenche a lacuna entre a pesquisa de texto para SQL e as aplicações do mundo real, explorando três desafios adicionais, nomeadamente lidar com valores de bases de dados grandes e confusos, inferência de conhecimento externo e otimização da eficiência de execução SQL.
CoSQL: um corpus para a construção de sistemas conversacionais de texto para SQL entre domínios. É uma versão conversacional das tarefas Spider e SParC. CoSQL consiste em mais de 30 mil rodadas e mais de 10 mil consultas SQL anotadas da coleção de 3 mil conversas do Mágico de Oz que consultam 200 bancos de dados complexos em 138 domínios. Cada conversa simula um cenário realista de consulta ao banco de dados, no qual um membro da equipe explora o banco de dados como usuário e um especialista em SQL usa SQL para recuperar respostas, esclarecer questões ambíguas ou informar de outra forma.
Seguindo o modelo de processamento do NSQL, o conjunto de dados passou por processamento básico, rendendo aproximadamente 20W de conjunto de dados
Atualmente, o DB-GPT-Hub oferece suporte aos seguintes modelos básicos:
O modelo é ajustado com base em um bit de quantização de 4 usando Quantized Learning over Redundant Architecture (QLoRA). Os requisitos mínimos de hardware para isso podem ser referidos da seguinte forma:
| Parâmetros do modelo | RAM da GPU | RAM da CPU | DISCO |
|---|---|---|---|
| 7b | 6 GB | 3,6 GB | 36,4 GB |
| 13b | 13,4 GB | 5,9 GB | 60,2 GB |
Todos os parâmetros relacionados são definidos no mínimo, com tamanho de lote de 1 e comprimento máximo de 512. Com base na experiência, para melhor desempenho, é recomendado definir os valores de comprimento relacionados como 1024 ou 2048.
git clone https://github.com/eosphoros-ai/DB-GPT-Hub.git
cd DB-GPT-Hub
conda create -n dbgpt_hub python=3.10
conda activate dbgpt_hub
cd src/dbgpt_hub_sql
pip install -e .
Primeiro, instale dbgpt-hub com o seguinte comando
pip install dbgpt-hub
Em seguida, configure os argumentos e execute todo o processo.
from dbgpt_hub_sql . data_process import preprocess_sft_data
from dbgpt_hub_sql . train import start_sft
from dbgpt_hub_sql . predict import start_predict
from dbgpt_hub_sql . eval import start_evaluate
# Config the input datasets
data_folder = "dbgpt_hub_sql/data"
data_info = [
{
"data_source" : "spider" ,
"train_file" : [ "train_spider.json" , "train_others.json" ],
"dev_file" : [ "dev.json" ],
"tables_file" : "tables.json" ,
"db_id_name" : "db_id" ,
"is_multiple_turn" : False ,
"train_output" : "spider_train.json" ,
"dev_output" : "spider_dev.json" ,
}
]
# Config training parameters
train_args = {
"model_name_or_path" : "codellama/CodeLlama-13b-Instruct-hf" ,
"do_train" : True ,
"dataset" : "example_text2sql_train" ,
"max_source_length" : 2048 ,
"max_target_length" : 512 ,
"finetuning_type" : "lora" ,
"lora_target" : "q_proj,v_proj" ,
"template" : "llama2" ,
"lora_rank" : 64 ,
"lora_alpha" : 32 ,
"output_dir" : "dbgpt_hub_sql/output/adapter/CodeLlama-13b-sql-lora" ,
"overwrite_cache" : True ,
"overwrite_output_dir" : True ,
"per_device_train_batch_size" : 1 ,
"gradient_accumulation_steps" : 16 ,
"lr_scheduler_type" : "cosine_with_restarts" ,
"logging_steps" : 50 ,
"save_steps" : 2000 ,
"learning_rate" : 2e-4 ,
"num_train_epochs" : 8 ,
"plot_loss" : True ,
"bf16" : True ,
}
# Config predict parameters
predict_args = {
"model_name_or_path" : "codellama/CodeLlama-13b-Instruct-hf" ,
"template" : "llama2" ,
"finetuning_type" : "lora" ,
"checkpoint_dir" : "dbgpt_hub_sql/output/adapter/CodeLlama-13b-sql-lora" ,
"predict_file_path" : "dbgpt_hub_sql/data/eval_data/dev_sql.json" ,
"predict_out_dir" : "dbgpt_hub_sql/output/" ,
"predicted_out_filename" : "pred_sql.sql" ,
}
# Config evaluation parameters
evaluate_args = {
"input" : "./dbgpt_hub_sql/output/pred/pred_sql_dev_skeleton.sql" ,
"gold" : "./dbgpt_hub_sql/data/eval_data/gold.txt" ,
"gold_natsql" : "./dbgpt_hub_sql/data/eval_data/gold_natsql2sql.txt" ,
"db" : "./dbgpt_hub_sql/data/spider/database" ,
"table" : "./dbgpt_hub_sql/data/eval_data/tables.json" ,
"table_natsql" : "./dbgpt_hub_sql/data/eval_data/tables_for_natsql2sql.json" ,
"etype" : "exec" ,
"plug_value" : True ,
"keep_distict" : False ,
"progress_bar_for_each_datapoint" : False ,
"natsql" : False ,
}
# Run the whole fine-tuning workflow
preprocess_sft_data (
data_folder = data_folder ,
data_info = data_info
)
start_sft ( train_args )
start_predict ( predict_args )
start_evaluate ( evaluate_args )O DB-GPT-Hub utiliza o método de geração de correspondência de informações para preparação de dados, ou seja, o método de geração SQL + Repositório que combina informações da tabela. Este método combina informações da tabela de dados para entender melhor a estrutura e os relacionamentos da tabela de dados e é adequado para gerar instruções SQL que atendam aos requisitos.
Baixe o conjunto de dados Spider no link do conjunto de dados Spider. Por padrão, após baixar e extrair os dados, coloque-os no diretório dbgpt_hub_sql/data, ou seja, o caminho deve ser dbgpt_hub_sql/data/spider .
Para a parte de pré-processamento de dados, basta executar o seguinte script :
# # generate train and dev(eval) data
sh dbgpt_hub_sql/scripts/gen_train_eval_data.sh No diretório dbgpt_hub_sql/data/ , você encontrará o arquivo de treinamento recém-gerado example_text2sql_train.json e o arquivo de teste example_text2sql_dev.json, contendo 8.659 e 1.034 entradas respectivamente. Para os dados usados no ajuste fino subsequente, defina o valor do parâmetro file_name como o nome do arquivo do conjunto de treinamento em dbgpt_hub_sql/data/dataset_info.json, como example_text2sql_train.json
Os dados no JSON gerado são mais ou menos assim:
{
"db_id": "department_management",
"instruction": "I want you to act as a SQL terminal in front of an example database, you need only to return the sql command to me.Below is an instruction that describes a task, Write a response that appropriately completes the request.n"n##Instruction:ndepartment_management contains tables such as department, head, management. Table department has columns such as Department_ID, Name, Creation, Ranking, Budget_in_Billions, Num_Employees. Department_ID is the primary key.nTable head has columns such as head_ID, name, born_state, age. head_ID is the primary key.nTable management has columns such as department_ID, head_ID, temporary_acting. department_ID is the primary key.nThe head_ID of management is the foreign key of head_ID of head.nThe department_ID of management is the foreign key of Department_ID of department.nn",
"input": "###Input:nHow many heads of the departments are older than 56 ?nn###Response:",
"output": "SELECT count(*) FROM head WHERE age > 56",
"history": []
},
O código de processamento de dados chase , cosql e sparc foi incorporado ao código de processamento de dados do projeto. Depois de baixar o conjunto de dados de acordo com o link acima, você só precisa in dbgpt_hub_sql/configs/config.py. Just loosen the corresponding code comment in SQL_DATA_INFO .
O ajuste fino do modelo suporta os métodos LoRA e QLoRA. Podemos executar o seguinte comando para ajustar o modelo. Por padrão, com o parâmetro --quantization_bit, ele usa o método de ajuste fino QLoRA. Para mudar para LoRAs, basta remover o parâmetro relacionado do script. Execute o comando:
sh dbgpt_hub_sql/scripts/train_sft.shApós o ajuste fino, os pesos do modelo serão salvos por padrão na pasta do adaptador, especificamente no diretório dbgpt_hub_sql/output/adapter.
Se você estiver usando treinamento multi-GPU e quiser utilizar deepseed , deverá modificar o conteúdo padrão em train_sft.sh. A mudança é:
CUDA_VISIBLE_DEVICES=0 python dbgpt_hub_sql/train/sft_train.py
--quantization_bit 4
...
mude para:
deepspeed --num_gpus 2 dbgpt_hub_sql/train/sft_train.py
--deepspeed dbgpt_hub_sql/configs/ds_config.json
--quantization_bit 4
...
se você precisar do ID do cartão do pedido
deepspeed --include localhost:0,1 dbgpt_hub_sql/train/sft_train.py
--deepspeed dbgpt_hub_sql/configs/ds_config.json
--quantization_bit 4
...
As outras partes omitidas (…) podem ser mantidas consistentes. Se você deseja alterar a configuração deepseed padrão, acesse o diretório dbgpt_hub_sql/configs e faça alterações em ds_config.json conforme necessário, o padrão é stage2.
No script, durante o ajuste fino, diferentes modelos correspondem aos parâmetros-chave lora_target e template, conforme mostrado na tabela a seguir:
| nome do modelo | lora_target | modelo |
|---|---|---|
| LLaMA-2 | q_proj,v_proj | lhama2 |
| CódigoLlama-2 | q_proj,v_proj | lhama2 |
| Baichuan2 | W_pack | baichuan2 |
| Qwen | c_attn | bate-papoml |
| sqlcoder-7b | q_proj,v_proj | mistral |
| sqlcoder2-15b | c_attn | padrão |
| EstagiárioLM | q_proj,v_proj | estagiário |
| XVERSO | q_proj,v_proj | xverso |
| Bate-papoGLM2 | query_key_value | chatglm2 |
| LLaMA | q_proj,v_proj | - |
| FLORESCER | query_key_value | - |
| FLORZ | query_key_value | - |
| Baichuan | W_pack | baichuan |
| Falcão | query_key_value | - |
Em train_sft.sh , outros parâmetros principais são os seguintes:
quantization_bit: Indica se a quantização é aplicada, sendo os valores válidos [4 ou 8].
model_name_or_path: O caminho do LLM (Large Language Model).
conjunto de dados: especifica o nome da configuração do conjunto de dados de treinamento, correspondente ao valor da chave externa em dbgpt_hub_sql/data/dataset_info.json, como example_text2sql.
max_source_length: o comprimento do texto inserido no modelo. Se os recursos computacionais permitirem, ele poderá ser definido como o maior possível, como 1.024 ou 2.048.
max_target_length: O comprimento da saída do conteúdo SQL pelo modelo; 512 é geralmente suficiente.
output_dir: O caminho de saída do módulo Peft durante SFT (Supervised Fine-Tuning), definido por padrão comodbgpt_hub_sql/output/adapter/.
per_device_train_batch_size: O tamanho do lote. Se os recursos computacionais permitirem, ele pode ser maior; o padrão é 1.
gradiente_accumulation_steps: O número de etapas para acumular gradientes antes de uma atualização.
save_steps: O número de etapas nas quais os pontos de verificação do modelo são salvos; ele pode ser definido como 100 por padrão.
num_train_epochs: o número de épocas para treinar o conjunto de dados.
No diretório do projeto ./dbgpt_hub_sql/output/pred/, esta pasta é o local de saída padrão para previsões de modelo (se não existir, apenas mkdir).
sh ./dbgpt_hub_sql/scripts/predict_sft.sh No script, por padrão com o parâmetro --quantization_bit , ele prevê usando QLoRA. Removê-lo muda para o método de previsão LoRA. O valor do parâmetro predicted_input_filename é o arquivo do conjunto de dados de teste de previsão. --predicted_out_filename é o nome do arquivo dos resultados previstos do modelo.
Você pode encontrar os pesos do segundo modelo correspondente em Huggingface hg-eosphoros-ai. Carregamos os pesos LoRA em outubro, cuja precisão de execução no conjunto de avaliação Spider atingiu 0,789.
Se você precisar mesclar os pesos do modelo base treinado e do módulo Peft ajustado para exportar um modelo completo, execute o seguinte script de exportação de modelo:
sh ./dbgpt_hub_sql/scripts/export_merge.shCertifique-se de substituir os valores do caminho dos parâmetros no script pelos caminhos correspondentes ao seu projeto.
Para avaliar o desempenho do modelo no conjunto de dados, o padrão é o conjunto de dados spider dev. Execute o seguinte comando:
python dbgpt_hub_sql/eval/evaluation.py --plug_value --input Your_model_pred_file Você pode encontrar os resultados de nossa última análise e parte dos resultados do experimento aqui
Nota : O banco de dados apontado pelo código padrão é um banco de dados de 95M baixado do [site oficial do Spider] (https://yale-lily.github.io/spider). Se você precisar usar o banco de dados Spider (tamanho 1,27G) no conjunto de testes, primeiro baixe o banco de dados no link para o diretório personalizado e execute o comando de avaliação acima que adiciona parâmetros e valores como --db Your_download_db_path .
Todo o processo vamos dividir em três fases:
Etapa 1:
Atualmente, oferecemos suporte para os seguintes recursos:
Etapa 2:
20231010 prompts Etapa 3:
Se nosso trabalho lhe forneceu pelo menos uma pequena ajuda, considere nos dar uma estrela. Seu feedback e apoio servem de motivação para continuarmos lançando mais trabalhos relacionados e melhorando nossos esforços. Obrigado!
Convidamos calorosamente mais pessoas a se juntarem a nós e se envolverem ativamente em vários aspectos do nosso projeto, como conjuntos de dados, ajuste fino de modelos, avaliação de desempenho, recomendações de artigos e reprodução de código. Não hesite em abrir problemas ou solicitar solicitações (PRs), e seremos proativos em responder às suas contribuições.
Antes de enviar seu código, certifique-se de que ele esteja formatado de acordo com o estilo preto usando o seguinte comando:
black dbgpt_hub
Se você tiver mais tempo para executar verificações de tipo e estilo mais detalhadas do seu código, use o seguinte comando:
pyright dbgpt_hub
pylint dbgpt_hub
Se você tiver alguma dúvida ou precisar de mais assistência, não hesite em entrar em contato. Agradecemos o seu envolvimento!
Nosso trabalho é baseado principalmente em inúmeras contribuições de código aberto. Graças aos seguintes projetos de código aberto
Obrigado a todos os contribuidores, especialmente @JBoRu que levantou a questão e nos lembrou de adicionar uma nova forma de avaliação promissora, ou seja, Test Suite. Como o artigo 《SQL-PALM: IMPROVED LARGE LANGUAGE MODEL ADAPTATION FOR TEXT-TO-SQL》 mencionou: "Consideramos duas métricas de avaliação comumente usadas: precisão de execução (EX) e precisão do conjunto de testes (TS). EX mede se o O resultado da execução do SQL corresponde à verdade básica (GT), enquanto o TS mede se o SQL passa em todas as avaliações EX para vários testes, gerados pelo aumento do banco de dados. Como EX contém falsos positivos, consideramos o TS como uma métrica de avaliação mais confiável".
Se você achar DB-GPT-Hub útil para sua pesquisa ou desenvolvimento, cite o seguinte artigo:
@misc { zhou2024dbgpthub ,
title = { DB-GPT-Hub: Towards Open Benchmarking Text-to-SQL Empowered by Large Language Models } ,
author = { Fan Zhou and Siqiao Xue and Danrui Qi and Wenhui Shi and Wang Zhao and Ganglin Wei and Hongyang Zhang and Caigai Jiang and Gangwei Jiang and Zhixuan Chu and Faqiang Chen } ,
year = { 2024 } ,
eprint = { 2406.11434 } ,
archivePrefix = { arXiv } ,
primaryClass = { id='cs.DB' full_name='Databases' is_active=True alt_name=None in_archive='cs' is_general=False description='Covers database management, datamining, and data processing. Roughly includes material in ACM Subject Classes E.2, E.5, H.0, H.2, and J.1.' }
}A Licença MIT (MIT)
Colaboramos como uma comunidade e se você tiver alguma ideia sobre nosso trabalho comunitário, não hesite em entrar em contato conosco. Se você estiver interessado em se aprofundar em um experimento aprofundado e otimizar o subprojeto DB-GPT-Hub, entre em contato com 'wangzai' no grupo WeChat. Agradecemos sinceramente suas contribuições para tornarmos tudo ainda melhor juntos!
