calbert
1.0.0
ALBERT CATALAN (A Lite Bert), Google est le point de vue de l'apprentissage auto-supervisé des représentations linguistiques.
Il est formé sur un corpus de 19,557,475 paires de phrases (contenant 729 millions de mots uniques) extrait du sous-ensemble catalan de l'ensemble de données Oscar d'Inria. Nous utilisons l'ensemble de validation A de 833.259 paires de phrases pour évaluer le modèle.
Vous pouvez lire le papier Albert original ici.
Ils sont disponibles sur la page Model Hub de HuggingFace
| Modèle | Cambre. | Données de formation | Jouer avec | Visualiser |
|---|---|---|---|---|
codegram / calbert-tiny-uncased | Minuscule (sans case) | Oscar (4,3 Go de texte) | Carte sur Model Hub | Visualiser dans Exbert |
codegram / calbert-base-uncased | Base (non cuites) | Oscar (4,3 Go de texte) | Carte sur Model Hub | Visualiser dans Exbert |
Vous avez juste besoin de la bibliothèque transformers . Rien d'autre à cloner ou à installer.
Pour choisir la version du modèle à utiliser ( tiny ou base ), considérez que les modèles plus petits sont moins puissants, mais plus agiles et moins avertis en ressources à exécuter.
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 dropoutMaintenant sur les deux principaux cas d'utilisation que vous pouvez faire.
Il s'agit du cas d'utilisation le plus simple, mais pas le plus utile. Pourtant, le voici! Quels que soient les mots que vous souhaitez masquer, utilisez le jeton spécial [MASK] pour l'indiquer. Le modèle sortira les candidats les plus probables pour le mot masqué.
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}]Le vecteur de fonctionnalité extrait peut être utilisé pour indexer des documents comme des vecteurs denses dans Elasticsearch par exemple, et effectuer des recherches de similitude.
Un autre cas d'utilisation est la compréhension du langage naturel - l'utilisation de ces vecteurs comme des représentations abstraites de documents / phrases qui peuvent être utilisées comme entrée à d'autres modèles en aval tels que les classificateurs.
Voici comment extraire les vecteurs d'une phrase ou d'un document:
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]]]) Cela fait partie de la recherche appliquée que nous faisons chez Codegram (qui doit remercier pour le temps et le calcul!).
Cela aurait été une tonne de douleur à construire sans étreindre les puissants transformateurs et les bibliothèques de tokenisers de Face Face. Merci d'avoir rendu la PNL avec plaisir avec!
De plus, grâce à Google Research pour la création et l'ouverture d'Open d'origine Albert en premier lieu.
Albert est un modèle de langue, c'est-à-dire un réseau neuronal qui peut apprendre des séquences avec une certaine structure, telles que des phrases en langage naturel (mais pas seulement le langage naturel!).
Mais comment apprennent-ils la langue? Différents modèles de langue sont formés avec différentes tâches de prétexte , à savoir les défis que vous leur donnez afin qu'ils puissent apprendre comment fonctionne la langue. L'idée est que pour être réactif à cette seule tâche, ils doivent indirectement apprendre la grammaire de la langue, et même sa sémantique et son style.
Les modèles de langue traditionnels (également appelés causaux ) sont généralement formés avec la tâche de prédire le mot suivant dans une séquence, comme ceci:
Cependant, Albert est une autre famille appelée Masked Language Models . Dans cette famille, la tâche prétexte qu'ils doivent apprendre est similaire, mais au lieu de toujours prédire le dernier mot d'une séquence, certains mots de la phrase sont transformés au hasard en blancs (ou masqués ), comme ceci:
Cette tâche est un peu plus difficile et, plus important encore, nécessite de comprendre le contexte entourant un blanc beaucoup mieux.
Il s'avère que une fois qu'un modèle de langue devient vraiment, vraiment bon dans cette tâche de prétexte assez inutile, elle peut être facilement réutilisée pour des tâches beaucoup plus intéressantes.
Une fois qu'une langue apprend la grammaire et la sémantique, elle peut devenir un très bon classificateur de phrases, et même des documents entiers, par exemple.
Si vous l'enseignez ensuite à classer les tweets ou les documents en catégories (ou identifiez le sentiment ou la toxicité par exemple), il ne voit plus juste un tas de personnages confus, mais il s'agit plutôt de "lire" le document à un niveau beaucoup plus abstrait, donc cela peut en avoir un sens beaucoup plus facilement. (Notez les citations d'air, ce n'est pas magique mais c'est probablement la chose la plus proche.)
Parce qu'il n'y a pas de modèles de langue en catalan! Et il y a beaucoup de texte catalan à traiter. (En Catalogne).
Pour la gestion des dépendances, nous utilisons la poésie (et Docker bien sûr).
pip install -U poetry
poetry install
poetry shell L'image de production pour former le modèle est sous docker/ , et elle s'appelle codegram/calbert . Il contient toutes les dernières dépendances, mais pas de code - Deepkit expédiera le code dans chaque expérience (lisez la suite pour en savoir plus sur Deepkit).
Toute config vit sous config . Là, vous pouvez contrôler les paramètres liés à la formation, au tokenisage et à tout, et même choisir la version du modèle à former.
Toute la configuration est remplacée, car sa configuration HYDRA. Vérifiez leurs documents.
Un minuscule sous-ensemble de l'ensemble de données vit sous dist/data afin que vous puissiez former un petit modèle et faire des expériences rapides localement.
Pour télécharger l'ensemble de données complet et le diviser automatiquement en formation / validation, exécutez simplement cette commande:
python -m calbert download_data --out-dir dataset Les jetons pré-entraînés sont à dist/tokenizer-{cased,uncased} . Ils ne sont formés que sur l'ensemble de formation complet.
Si vous souhaitez rétracter le tokenizer (par défaut, sans réserve):
python -m calbert train_tokenizer --input-file dataset/train.txt --out-dir tokenizerPour entraîner le boîtier, il suffit de remplacer la configuration HYDRA appropriée:
python -m calbert train_tokenizer --input-file dataset/train.txt --out-dir tokenizer vocab.lowercase=FalseNous utilisons Deepkit pour fonctionner et suivre les expériences. Téléchargez-le gratuitement pour votre plate-forme de choix si vous souhaitez exécuter localement, ou vérifiez leurs documents pour exécuter leur serveur communautaire gratuit.
Pour vous assurer que tout fonctionne, formons un modèle de test avec l'image Docker réelle dans Deepkit:
deepkit run test.deepkit.ymlPar défaut, il le formera dans votre instance Deepkit locale, en utilisant votre CPU. Lisez leurs documents pour apprendre à personnaliser vos courses.
Configurez un cluster dans votre Deepkit local avec au moins une machine avec un GPU.
deepkit run --clusterUne fois que vous avez un modèle formé, vous pouvez l'exporter pour être utilisé comme modèle standard des transformateurs en étreinte.
Par exemple, imaginons que vous avez formé un modèle base-uncased et que vous souhaitez l'exporter.
Téléchargez le dossier export à partir des sorties de votre course Deepkit et exécutez:
mv export calbert-base-uncased
transformers-cli login
transformers-cli upload exportmake test
