Tablet

Tablet: Aprendendo com as instruções para dados tabulares

Bem -vindo ao tablet Github! O objetivo deste projeto é comparar o progresso no aprendizado de instruções para a previsão tabular. Felizmente, podemos criar modelos que resolvam tarefas de previsão tabular usando instruções e poucos exemplos rotulados.

Links

• Confira o site do projeto
• Leia o papel do tablet
• Brinque com a demonstração do tablet

Visão geral

Embora muitos problemas de previsão exijam o uso de dados tabulares, geralmente, coletar dados de treinamento suficientes pode ser uma tarefa de desafio, devido a custos ou problemas de privacidade. Os grandes modelos de idiomas (LLMs) oferecem um conhecimento mundial considerável devido ao seu pré-treinamento e pode ajudar a melhorar a eficiência da amostra para esses problemas. Ainda assim, esses modelos geralmente não estão completamente alinhados com muitas tarefas de previsão tabulares devido a vieses de modelos de pré-treinamento e falta de informações sobre a tarefa, prejudicando seu desempenho nas configurações de zero e poucas fotos.

E se pudéssemos usar as instruções da tarefa para ajudar a preencher essa lacuna? É aí que entra o tablet. O tablet é uma referência viva dos conjuntos de dados tabulares anotados com instruções de tarefa para avaliar o quão bem os LLMs utilizam instruções para melhorar o desempenho nas tarefas de previsão tabular.

O que é tablet?

O tablet é um benchmark vivo de tarefas de previsão tabular anotadas com instruções. O tablet fornece as ferramentas para avaliar modelos nas tarefas atuais e contribuir com novas tarefas. O objetivo é ajudar os pesquisadores a desenvolver técnicas que melhorem a eficácia da amostra do LLMS na previsão tabular.

Citação

Se o tablet for útil para o seu trabalho, cite -nos.

@article{tabletSlack23,
         Author = {Dylan Slack and Sameer Singh},
         Title = {TABLET: Learning From Instructions For Tabular Data},
         Year = {2023},
         journal = {arXiv},
}

Instalação

Obtendo os dados

Para baixar os dados, clone o repositório do GitHub.

git clone https://github.com/dylan-slack/Tablet.git

Uma vez concluído, os dados são armazenados neste caminho.

Tablet/data/benchmark

Instalação do tablet

Use Python>=3.9 . Por causa de uma peculiaridade em um dos pacotes, não use Python=3.9.7 . Além disso, verifique se você possui pip>=23.0.1 .

conda create -n tablet python=3.9.6
conda activate tablet
pip install --upgrade pip

Se você deseja instalar o pacote tablet a partir da fonte, navegue no diretório do pacote do tablet e instale.

 cd Tablet
python3 -m pip install -e .

Caso contrário, você pode instalar a partir do Pypi com PIP. [Nota: ainda não foi lançado]

pip install tablet-benchmark

Completando o benchmark

Infelizmente, algumas instruções que ocorrem naturalmente vêm de fontes que não são licenciadas permissivamente e não permitem hospedagem em outros lugares. Fornecemos um guia para coletar estas instruções em

Tablet/fill_missing_instructions.py

Uma vez concluído, você pode correr

python fill_missing_instructions.py

e as instruções serão adicionadas aos dados de referência.

Avaliar

O pacote tablet oferece vários recursos úteis para avaliar o desempenho do LLMS + Instruções sobre conjuntos de dados tabulares. O Tablet fornece código para avaliar modelos arbitrários do HuggingFace em tarefas e também fornece ferramentas para simplesmente obter o conjunto de dados Huggingface para uma tarefa específica para que você possa executar qualquer avaliação que desejar.

Armazenamento de tarefas

Primeiro, vejamos como os conjuntos de dados de tarefas são armazenados no tablet. Todas as tarefas são armazenadas em

Tablet/data/benchmark/performance

Por exemplo, a tarefa adulta é armazenada em

Tablet/data/benchmark/performance/Adult

Dentro deste diretório, existem diretórios diferentes para cada anotação de instruções para a tarefa de adultos. Por exemplo, vejamos um dos protótipos gerados instruções. Esta instrução é armazenada em

Tablet/data/benchmark/performance/Adult/prototypes-synthetic-performance-0

As instruções coletadas através de outras fontes têm caminhos diferentes. Os conjuntos de regras gerados por instruções têm o nome do diretório

ruleset-synthetic-performance- *

E as instruções que ocorrem naturalmente têm

prototypes-naturallanguage-performance- *

Observe que o uso de protótipos aqui é apenas para manter a consistência de formatação com os outros nomes de diretórios.

Dentro de cada diretório, existem quatro arquivos

../test.csv
../test.json
../train.csv
../train.json

Estes são os conjuntos de treinamento e teste, armazenados em seus formatos tabulares (os .CSV's e seus arquivos de linguagem natural (o .json). Dentro dos arquivos JSON, há cada componente rápido, como cabeçalho, serialização de pontos de dados e instrução.

Obtendo um conjunto de dados Huggingface para uma tarefa

Veja como usar o pacote de tablets para obter um conjunto de dados Huggingface para uma tarefa específica. Digamos que queremos obter um dos conjuntos de dados adultos e de tosse convulsa nesses locais

Tablet/data/benchmark/performance/Adult/prototypes-synthetic-performance-0
Tablet/data/benchmark/performance/A37/prototypes-synthetic-performance-0

Podemos obter os conjuntos de dados de teste da seguinte forma

 from Tablet import evaluate

benchmark_path = "./data/benchmark/performance/"
tasks = [ 'A37/prototypes-synthetic-performance-0' ,
         'Adult/prototypes-synthetic-performance-0' ]
evaluator = evaluate . Evaluator ( benchmark_path = benchmark_path ,
                               tasks_to_run = tasks ,
                               encoding_format = "flan" ,
                               k_shot = 0 )
whooping_cough , adult = evaluator . get_test_hf_datasets ()

Podemos especificar k_shot aqui para controlar quantas instâncias de K_Shot são amostradas a partir dos dados de treinamento e incluídas nos prompts. Em seguida, podemos acessar os dados e rótulos de teste adulto como

 test_data , ground_truth_labels = adult [ 'text' ], adult [ 'label' ] 

Avaliando o desempenho em uma tarefa

Também podemos avaliar diretamente o desempenho nas tarefas. Por exemplo, avaliar o pequeno desempenho do Flan-T5 de 2 tiros em adultos com protótipos gerados instruções com 3 sementes é o seguinte

 from Tablet import evaluate

benchmark_path = "./data/benchmark/performance/"
tasks = [ 'Adult/prototypes-synthetic-performance-0' ]
evaluator = evaluate . Evaluator ( benchmark_path = benchmark_path ,
                               tasks_to_run = tasks ,
                               encoding_format = "flan" ,
                               results_file = "my_cool_results.txt" ,
                               k_shot = 2 )
evaluator . run_eval ( how_many = 3 )

Os resultados serão anexados a my_cool_results.txt .

Contribuir

Para criar modelos que possam se alinhar com problemas de previsão tabular extremamente bem a partir de apenas instruções e talvez alguns exemplos, precisamos de muitas tarefas. Isso é útil para avaliar o quão bem estamos indo e pode ser útil para supervisão futura.

O tablet facilita a criação de novas tarefas escrevendo instruções ou gerando-as com o GPT-3 para novos conjuntos de dados. Veja como você faz isso.

Criando uma nova tarefa

Você deve ter treinamento e teste para sua tarefa armazenada nos Pandas DFs. Em seguida, você pode ligar para Tablet.create . Essa função cuidará da criação da tarefa para as instruções que você fornece naturalmente e também gerará instruções usando o GPT-3, se desejar.

 from Tablet import create

create . create_task ( train_x ,
                   eval_x ,
                   train_y ,
                   eval_y ,
                   name = my_data_set_name ,
                   header = "Predict xyz." ,
                   nl_instruction = "Generally, people papers are grad students." ,
                   categorical_columns = names_of_categorical_columns ,
                   num = index_of_task ,
                   num_gpt3_revisions = 10 ,
                   openai_key_path = path_to_open_ai_key ,
                   save_loc = "./data/benchmark" )

Aqui, train_x e eval_x são as divisões de trem e teste. Da mesma forma, train_y e eval_y são as colunas do rótulo. Essa função também aceita o nome da tarefa (por exemplo, coisas como Adult ou Wine ), o cabeçalho que descreve o objetivo de alto nível da tarefa e as instruções naturais de Langauge-esse é o argumento nl_instructions . Você também deve especificar os nomes das colunas categóricas. O argumento num é o índice que a tarefa com esta instrução de ocorrência natural será armazenada em (por exemplo, prototypes-naturallanguage-performance-{num} ).

Além disso, se você deseja gerar instruções com o GPT-3, precisará fornecer uma chave OpenAI em um arquivo e fornecer a localização desse arquivo ao argumento do openai_key_path e especificar quantas instruções para os modelos de protótipo e conjunto de regras que deseja criar com num_gpt3_revisions .

Enviando uma tarefa

Para incluir sua nova e incrível tarefa, verifique se os arquivos da tarefa estão em

./data/benchmark/performance/my_new_task

e envie uma solicitação de tração.

Inclua também um pequeno readmd.md na pasta que descreve o objetivo da tarefa e a licença que os dados e instruções estão abaixo. Por exemplo, algo assim é ideal:

Task: Predict how many sheep someone will need to count before they fall asleep.
Data License: Apache 2.0
Instruction License: MIT

Vamos revisá -lo e adicioná -lo à referência. Se você quiser seu nome e site adicionado às listas de tarefas na página inicial, mencione isso na solicitação de tração também.