calbert

Calbert

Um Catalão Albert (A Lite Bert), a opinião do Google sobre o aprendizado auto-supervisionado das representações de idiomas.

É treinado em um corpus de 19.557.475 pares de frases (contendo 729 milhões de palavras únicas) extraídas do subconjunto catalão do conjunto de dados do Oscar da INRIA. Utilizamos o conjunto de validação de 833.259 pares de frases para avaliar o modelo.

Você pode ler o artigo Albert original aqui.

Modelos pré-treinados

Eles estão disponíveis na página do hub de modelo do Huggingface

Modelo	Arco.	Dados de treinamento	Brinque com ele	Visualize
codegram / calbert-tiny-uncased	Minúsculo (não baseado)	Oscar (4,3 GB de texto)	Cartão no Model Hub	Visualize em Exbert
codegram / calbert-base-uncased	Base (não baseada)	Oscar (4,3 GB de texto)	Cartão no Model Hub	Visualize em Exbert

Como usá -lo?

Você só precisa da biblioteca transformers . Nada mais para clonar ou instalar.

Para escolher qual versão do modelo usar ( tiny ou base ), considere que os modelos menores são menos poderosos, mas mais finos e menos sedentos de recursos para executar.

pip install transformers

 from transformers import AutoModel , AutoTokenizer

tokenizer = AutoTokenizer . from_pretrained ( "codegram/calbert-base-uncased" )
model = AutoModel . from_pretrained ( "codegram/calbert-base-uncased" )

model . eval () # disable dropout

Agora nos dois principais casos de uso que você pode fazer.

Prevendo uma palavra ausente em uma frase catalã

Este é o caso de uso mais simples, mas não é o mais útil. Ainda assim, aqui está! Quaisquer que sejam as palavras que você deseja mascarar, use o token especial [MASK] para indicá -lo. O modelo produzirá os candidatos mais prováveis ​​para a palavra mascarada.

 from transformers import pipeline

calbert_fill_mask  = pipeline ( "fill-mask" , model = "codegram/calbert-base-uncased" , tokenizer = "codegram/calbert-base-uncased" )
results = calbert_fill_mask ( "M'agrada [MASK] això" )
# results
# [{'sequence': "[CLS] m'agrada molt aixo[SEP]", 'score': 0.614592969417572, 'token': 61},
#  {'sequence': "[CLS] m'agrada moltíssim aixo[SEP]", 'score': 0.06058056280016899, 'token': 4867},
#  {'sequence': "[CLS] m'agrada més aixo[SEP]", 'score': 0.017195818945765495, 'token': 43},
#  {'sequence': "[CLS] m'agrada llegir aixo[SEP]", 'score': 0.016321714967489243, 'token': 684},
#  {'sequence': "[CLS] m'agrada escriure aixo[SEP]", 'score': 0.012185849249362946, 'token': 1306}]

Extraindo um vetor de recurso de uma frase ou documento catalão

O vetor de recurso extraído pode ser usado para indexar documentos como vetores densos no Elasticsearch, por exemplo, e executar pesquisas de similaridade.

Outro caso de uso é o entendimento da linguagem natural -usando esses vetores como representações abstratas de documentos/frases que podem ser usados ​​como entrada para outros modelos a jusante, como classificadores.

Veja como extrair os vetores de uma frase ou documento:

 import torch
# Tokenize in sub-words with SentencePiece
tokenized_sentence = tokenizer . tokenize ( "M'és una mica igual" )
# ['▁m', "'", 'es', '▁una', '▁mica', '▁igual']

# 1-hot encode and add special starting and end tokens
encoded_sentence = tokenizer . encode ( tokenized_sentence )
# [2, 109, 7, 71, 36, 371, 1103, 3]
# NB: Can be done in one step : tokenize.encode("M'és una mica igual")

# Feed tokens to Calbert as a torch tensor (batch dim 1)
encoded_sentence = torch . tensor ( encoded_sentence ). unsqueeze ( 0 )
embeddings , _ = model ( encoded_sentence )
embeddings . size ()
# torch.Size([1, 8, 768])
embeddings . detach ()
# tensor([[[-0.0261,  0.1166, -0.1075,  ..., -0.0368,  0.0193,  0.0017],
#          [ 0.1289, -0.2252,  0.9881,  ..., -0.1353,  0.3534,  0.0734],
#          [-0.0328, -1.2364,  0.9466,  ...,  0.3455,  0.7010, -0.2085],
#          ...,
#          [ 0.0397, -1.0228, -0.2239,  ...,  0.2932,  0.1248,  0.0813],
#          [-0.0261,  0.1165, -0.1074,  ..., -0.0368,  0.0193,  0.0017],
#          [-0.1934, -0.2357, -0.2554,  ...,  0.1831,  0.6085,  0.1421]]]) 

Créditos

Isso faz parte da pesquisa aplicada que fazemos no CodeGram (que deve agradecer pelo tempo e pela computação!).

Isso teria sido uma tonelada de dor para construir sem os poderosos transformadores e tokenizadores do Huggingface. Obrigado por fazer da PNL realmente bom trabalhar!

Além disso, graças ao Google Research por criar e de origem aberta Albert em primeiro lugar.

O que diabos é um Albert

Albert é um modelo de idioma, ou seja, uma rede neural que pode aprender sequências com certa estrutura, como frases na linguagem natural (mas não apenas na linguagem natural!).

Mas como eles aprendem a linguagem? Diferentes modelos de idiomas são treinados com diferentes tarefas de pretexto , ou seja, desafios que você lhes dá para que eles possam aprender como a linguagem funciona. A idéia é que, para se tornarem muito boas nessa tarefa, eles devem indiretamente aprender a gramática do idioma e até sua semântica e estilo.

Os modelos tradicionais (também conhecidos como causais ) geralmente são treinados com a tarefa de prever a próxima palavra em uma sequência, assim:

• Entrada: "O cachorro estava comendo muito [em branco]"
• Saída correta: "Rapidamente"

No entanto, Albert é de outra família chamada modelos de idiomas mascarados . Nesta família, a tarefa de pretexto que eles precisam aprender é semelhante, mas, em vez de sempre prever a última palavra em uma sequência, algumas palavras na frase são aleatoriamente transformadas em espaços em branco (ou mascarados ), assim:

• Entrada: "O [Blank] estava comendo muito [em branco]"
• Saída correta: "cachorro", "rapidamente"

Essa tarefa é um pouco mais difícil e, mais importante, requer a compreensão do contexto em torno de um espaço em branco muito melhor.

Como essas tarefas de pretexto são mais do que um desperdício inútil de eletricidade

Acontece que, uma vez que um modelo de idioma se torna muito, muito bom nessa tarefa de pretexto sem sentido, ele pode ser facilmente reaproveitado para tarefas muito mais interessantes.

Depois que um idioma aprende gramática e semântica, ele pode se tornar um classificador muito bom de frases e até documentos inteiros, por exemplo.

Se você o ensinar a classificar tweets ou documentos em categorias (ou identificar sentimentos ou toxicidade, por exemplo), ele não vê mais apenas um monte de personagens confusos, mas está "lendo" o documento em um nível muito mais abstrato, para que possa "fazer sentido" disso com muito mais facilidade. (Observe as citações do ar, isso não é mágico, mas provavelmente é a coisa mais próxima.)

Por que Albert em catalão

Porque não há modelos de linguagem no catalão! E há muito texto catalão a ser processado. (Na Catalunha).

Configurar

Para gerenciamento de dependência, usamos poesia (e Docker, é claro).

pip install -U poetry
poetry install
poetry shell

A imagem de produção para treinar o modelo está em docker/ e é chamada codegram/calbert . Ele contém todas as dependências mais recentes, mas nenhum código - o Deepkit enviará o código em todos os experimentos (continue lendo para saber mais sobre o DeepKit).

DataSet e Tokenizers

Todas as vidas de configuração sob config . Lá você pode controlar parâmetros relacionados ao treinamento, tokenize e tudo mais, e até escolher qual versão do modelo treinar.

Toda a configuração é substituída, pois é a configuração do Hydra. Verifique seus documentos.

Obtendo o conjunto de dados

Um pequeno subconjunto do conjunto de dados vive em dist/data para que você possa treinar um modelo pequeno e fazer experimentos rápidos localmente.

Para baixar o conjunto de dados completo e dividi -lo automaticamente em treinamento / validação, basta executar este comando:

python -m calbert download_data --out-dir dataset

Re-treinamento dos tokenizadores

Os tokenizadores pré-treinados estão em dist/tokenizer-{cased,uncased} . Eles são treinados apenas no conjunto completo de treinamento.

Se você deseja re-treinar o tokenizer (por padrão não -as-fases):

python -m calbert train_tokenizer --input-file dataset/train.txt --out-dir tokenizer

Para treinar o revestido, basta substituir a configuração Hydra apropriada:

python -m calbert train_tokenizer --input-file dataset/train.txt --out-dir tokenizer vocab.lowercase=False

Experiências de treinamento e corrida

Usamos o DeepKit para correr e acompanhar os experimentos. Faça o download gratuito de sua plataforma de escolha, se quiser executar localmente ou verifique os documentos para executar o servidor comunitário gratuito.

Treinando um modelo de teste

Para garantir que tudo funcione, vamos treinar um modelo de teste com a imagem real do Docker em Deepkit:

deepkit run test.deepkit.yml

Por padrão, ele o treinará na sua instância local de Deepkit, usando sua CPU. Leia os documentos para aprender a personalizar suas corridas.

Treinamento em um cluster

Configure um cluster no seu Deepkit local com pelo menos uma máquina com uma GPU.

deepkit run --cluster

Compartilhando o modelo com o mundo

Depois de ter um modelo treinado, você pode exportá -lo para ser usado como um modelo padrão do HuggingFace Transformers.

Por exemplo, vamos imaginar que você treinou um modelo base-uncased e deseja exportá-lo.

Faça o download da pasta export das saídas em sua execução do Deepkit e execute:

mv export calbert-base-uncased
transformers-cli login
transformers-cli upload export

Testes de execução

make test