ludwig

Outro código-fonte

v0.10.4

Baixar

Estrutura declarativa de aprendizagem profunda construída para escala e eficiência.

Importante

Nossa comunidade mudou para o Discord – junte-se a nós lá!

O que é Ludwig?

Ludwig é uma estrutura de baixo código para a construção de modelos de IA personalizados , como LLMs e outras redes neurais profundas.

Principais recursos:

? Crie modelos personalizados com facilidade: um arquivo de configuração YAML declarativo é tudo que você precisa para treinar um LLM de última geração em seus dados. Suporte para aprendizagem multitarefa e multimodalidade. A validação abrangente de configuração detecta combinações de parâmetros inválidas e evita falhas de tempo de execução.
⚡ Otimizado para escala e eficiência: seleção automática de tamanho de lote, treinamento distribuído (DDP, DeepSpeed), ajuste fino com eficiência de parâmetros (PEFT), quantização de 4 bits (QLoRA), otimizadores paginados e de 8 bits e maior que memória conjuntos de dados.
? Controle de nível especializado: mantenha o controle total de seus modelos até as funções de ativação. Suporte para otimização de hiperparâmetros, explicabilidade e visualizações métricas ricas.
? Modular e extensível: experimente diferentes arquiteturas de modelos, tarefas, recursos e modalidades com apenas algumas alterações de parâmetros na configuração. Pense em blocos de construção para um aprendizado profundo.
? Projetado para produção: contêineres Docker pré-construídos, suporte nativo para execução com Ray no Kubernetes, exportação de modelos para Torchscript e Triton, upload para HuggingFace com um comando.

Ludwig é hospedado pela Linux Foundation AI & Data.

? Instalação

Instale a partir do PyPi. Esteja ciente de que Ludwig requer Python 3.8+.

pip install ludwig

Ou instale com todas as dependências opcionais:

pip install ludwig[full]

Consulte a contribuição para obter instruções de instalação mais detalhadas.

? Começando

Quer dar uma olhada rápida em alguns dos recursos do Ludwig 0.8? Confira este caderno Colab

Quer ajustar o Llama-2 ou o Mistral? Confira estes cadernos:

Ajuste fino Llama-2-7b:
Ajuste fino Llama-2-13b:
Ajuste fino do Mistral-7b:

Para um tutorial completo, confira o guia oficial de primeiros passos ou dê uma olhada nos exemplos completos.

Ajuste fino de modelo de linguagem grande

Vamos ajustar um modelo de linguagem grande LLaMA-2-7b pré-treinado para seguir instruções como um chatbot ("ajuste de instruções").

Pré-requisitos

Token de API HuggingFace
Aprovação de acesso ao Llama2-7b-hf
GPU com pelo menos 12 GiB de VRAM (em nossos testes, usamos uma Nvidia T4)

Correndo

Usaremos o conjunto de dados Stanford Alpaca, que será formatado como um arquivo semelhante a uma tabela semelhante a este:

instrução	entrada	saída
Dê três dicas para se manter saudável.		1. Faça uma dieta balanceada e certifique-se de incluir...
Organize os itens abaixo na ordem de ...	bolo, eu, comendo	Estou comendo bolo.
Escreva um parágrafo introdutório sobre um famoso...	Michelle Obama	Michelle Obama é uma mulher inspiradora que...
...	...	...

Crie um arquivo de configuração YAML chamado model.yaml com o seguinte:

 model_type : llm
base_model : meta-llama/Llama-2-7b-hf

quantization :
  bits : 4

adapter :
  type : lora

prompt :
  template : |
    Below is an instruction that describes a task, paired with an input that may provide further context.
    Write a response that appropriately completes the request.

    ### Instruction:
    {instruction}

    ### Input:
    {input}

    ### Response:

input_features :
  - name : prompt
    type : text

output_features :
  - name : output
    type : text

trainer :
  type : finetune
  learning_rate : 0.0001
  batch_size : 1
  gradient_accumulation_steps : 16
  epochs : 3
  learning_rate_scheduler :
    decay : cosine
    warmup_fraction : 0.01

preprocessing :
  sample_ratio : 0.1

backend :
  type : local

E agora vamos treinar o modelo:

 export HUGGING_FACE_HUB_TOKEN = " <api_token> "

ludwig train --config model.yaml --dataset " ludwig://alpaca "

ML supervisionado

Vamos construir uma rede neural que preveja se a crítica de um determinado crítico de cinema no Rotten Tomatoes foi positiva ou negativa.

Nosso conjunto de dados será um arquivo CSV parecido com este:

filme_título	classificação_de_conteúdo	gêneros	tempo de execução	top_critic	review_content	recomendado
Livrai-nos do Mal	R	Ação e Aventura, Terror	117,0	verdadeiro	O diretor Scott Derrickson e seu co-roteirista, Paul Harris Boardman, apresentam um procedimento rotineiro com sustos comuns.	0
Bárbara	PG-13	Art House e Internacional, Drama	105,0	FALSO	De alguma forma, nesta narrativa emocionante, Bárbara consegue manter os seus princípios, a sua humanidade e coragem, e luta para salvar uma adolescente dissidente cuja vida os comunistas estão a tentar destruir.	1
Chefes horríveis	R	Comédia	98,0	FALSO	Estes patrões não conseguem justificar nem homicídios nem memórias cómicas duradouras, comprometendo fatalmente uma farsa que poderia ter sido grande mas que acaba por ser meramente medíocre.	0
...	...	...	...	...	...	...

Baixe uma amostra do conjunto de dados aqui.

wget https://ludwig.ai/latest/data/rotten_tomatoes.csv

Em seguida, crie um arquivo de configuração YAML chamado model.yaml com o seguinte:

 input_features :
  - name : genres
    type : set
    preprocessing :
      tokenizer : comma
  - name : content_rating
    type : category
  - name : top_critic
    type : binary
  - name : runtime
    type : number
  - name : review_content
    type : text
    encoder :
      type : embed
output_features :
  - name : recommended
    type : binary

É isso! Agora vamos treinar o modelo:

ludwig train --config model.yaml --dataset rotten_tomatoes.csv

Modelagem feliz

Tente aplicar Ludwig aos seus dados. Entre em contato pelo Discord se tiver alguma dúvida.

❓ Por que você deve usar Ludwig

Padrão mínimo de aprendizado de máquina
Ludwig cuida da complexidade de engenharia do aprendizado de máquina imediatamente, permitindo que os cientistas pesquisadores se concentrem na construção de modelos no mais alto nível de abstração. Pré-processamento de dados, otimização de hiperparâmetros, gerenciamento de dispositivos e treinamento distribuído para modelos torch.nn.Module são totalmente gratuitos.
Crie facilmente seus benchmarks
Criar uma linha de base de última geração e compará-la com um novo modelo é uma simples alteração de configuração.
Aplique facilmente novas arquiteturas a vários problemas e conjuntos de dados
Aplique novos modelos no extenso conjunto de tarefas e conjuntos de dados suportados pelo Ludwig. Ludwig inclui um kit de ferramentas de benchmarking completo acessível a qualquer usuário, para executar experimentos com vários modelos em vários conjuntos de dados com apenas uma configuração simples.
Pré-processamento, modelagem e métricas de dados altamente configuráveis
Todo e qualquer aspecto da arquitetura do modelo, do loop de treinamento, da pesquisa de hiperparâmetros e da infraestrutura de back-end pode ser modificado como campos adicionais na configuração declarativa para personalizar o pipeline para atender aos seus requisitos. Para obter detalhes sobre o que pode ser configurado, consulte os documentos de configuração do Ludwig.
Aprendizagem multimodal e multitarefa pronta para uso
Misture e combine dados tabulares, texto, imagens e até mesmo áudio em configurações de modelos complexos sem escrever código.
Exportação e rastreamento de modelos ricos
Rastreie automaticamente todos os testes e métricas com ferramentas como Tensorboard, Comet ML, Weights & Biases, MLFlow e Aim Stack.
Escale automaticamente o treinamento para clusters com várias GPUs e vários nós
Passe do treinamento em sua máquina local para a nuvem sem alterações de código.
Interface de baixo código para modelos de última geração, incluindo Huggingface Transformers pré-treinados
Ludwig também se integra nativamente com modelos pré-treinados, como os disponíveis em Huggingface Transformers. Os usuários podem escolher entre uma vasta coleção de modelos PyTorch pré-treinados de última geração para usar sem a necessidade de escrever nenhum código. Por exemplo, treinar um modelo de análise de sentimento baseado em BERT com Ludwig é tão simples quanto:
```
ludwig train --dataset sst5 --config_str " {input_features: [{name: sentence, type: text, encoder: bert}], output_features: [{name: label, type: category}]} "
```
Interface de baixo código para AutoML
Ludwig AutoML permite que os usuários obtenham modelos treinados, fornecendo apenas um conjunto de dados, a coluna de destino e um orçamento de tempo.
```
 auto_train_results = ludwig . automl . auto_train ( dataset = my_dataset_df , target = target_column_name , time_limit_s = 7200 )
```
Fácil produção
Ludwig facilita o atendimento de modelos de aprendizado profundo, inclusive em GPUs. Inicie uma API REST para seu modelo Ludwig treinado.
```
ludwig serve --model_path=/path/to/model
```
Ludwig oferece suporte à exportação de modelos para pacotes Torchscript eficientes.
```
ludwig export_torchscript -–model_path=/path/to/model
```

Tutoriais

Classificação de Texto
Classificação de dados tabulares
Classificação de imagens
Classificação Multimodal

? Exemplos de casos de uso

Marcação de reconhecimento de entidade nomeada
Compreensão da linguagem natural
Tradução automática
Modelagem de diálogo Chit-Chat por meio de seq2seq
Análise de sentimento
Aprendizagem única com redes siamesas
Resposta visual a perguntas
Reconhecimento de fala de dígitos falados
Verificação de alto-falante
Classificação Binária (Titanic)
Previsão de série temporal
Previsão de série temporal (clima)
Previsão de classificação de filmes
Classificação multi-rótulo
Aprendizagem multitarefa
Regressão Simples: Previsão de Eficiência de Combustível
Detecção de fraude

Mais informações

Leia nossas publicações sobre Ludwig, ML declarativo e benchmarks SoTA de Ludwig.

Saiba mais sobre como Ludwig funciona, como começar e trabalhe com mais exemplos.

Se você estiver interessado em contribuir, tiver dúvidas, comentários ou ideias para compartilhar, ou se apenas quiser ficar por dentro, considere entrar em nosso Discord da comunidade e siga-nos no X!

? Junte-se à comunidade para construir Ludwig conosco

Ludwig é um projeto de código aberto gerenciado ativamente que depende de contribuições de pessoas como você. Considere juntar-se ao grupo ativo de colaboradores do Ludwig para tornar o Ludwig uma estrutura ainda mais acessível e rica em recursos para todos usarem!