transformers embedder
3.0.11
Une couche de transformateur de niveau de mot basé sur pytorch et? Transformateurs.
Installez la bibliothèque depuis PYPI:
pip install transformers-embedderou de conda:
conda install -c riccorl transformers-embedderIl propose une couche Pytorch et un tokenizer qui prennent en charge presque tous les modèles pré-entraînés de la bibliothèque Transformers HuggingFace? Voici un exemple rapide:
import transformers_embedder as tre
tokenizer = tre . Tokenizer ( "bert-base-cased" )
model = tre . TransformersEmbedder (
"bert-base-cased" , subword_pooling_strategy = "sparse" , layer_pooling_strategy = "mean"
)
example = "This is a sample sentence"
inputs = tokenizer ( example , return_tensors = True ) {
'input_ids': tensor([[ 101, 1188, 1110, 170, 6876, 5650, 102]]),
'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1]]),
'token_type_ids': tensor([[0, 0, 0, 0, 0, 0, 0]])
'scatter_offsets': tensor([[0, 1, 2, 3, 4, 5, 6]]),
'sparse_offsets': {
'sparse_indices': tensor(
[
[0, 0, 0, 0, 0, 0, 0],
[0, 1, 2, 3, 4, 5, 6],
[0, 1, 2, 3, 4, 5, 6]
]
),
'sparse_values': tensor([1., 1., 1., 1., 1., 1., 1.]),
'sparse_size': torch.Size([1, 7, 7])
},
'sentence_length': 7 # with special tokens included
}
outputs = model ( ** inputs ) # outputs.word_embeddings.shape[1:-1] # remove [CLS] and [SEP]
torch.Size([1, 5, 768])
# len(example)
5
L'une des gênements de l'utilisation de modèles basés sur les transformateurs est qu'il n'est pas trivial de calculer les incorporations de mots à partir des incorporations de sous-token qu'ils publient. Avec cette API, c'est aussi simple que d'utiliser? Transformers pour obtenir des intégres de niveau de mot à partir théoriquement chaque modèle de transformateur qu'il prend en charge.
La classe TransformersEmbedder offre 3 façons d'obtenir les intégres:
subword_pooling_strategy="sparse" : calcule la moyenne des intégres des sous-tokens de chaque mot (c'est-à-dire que les intégres des sous-tokens sont regroupés) en utilisant une multiplication de matrice clairsemée. Cette stratégie est la par défaut.subword_pooling_strategy="scatter" : calcule la moyenne des intégres des sous-tokens de chaque mot à l'aide d'une opération de dispersion-gather. Ce n'est pas déterministe, mais il fonctionne avec l'exportation ONNX.subword_pooling_strategy="none" : Renvoie la sortie brute du modèle de transformateur sans regroupement de sous-token.Ici une petite table de fonctionnalité:
| Accélération | Déterministe | Onnx | |
|---|---|---|---|
| Clairsemé | ✅ | ✅ | |
| Dispersion | ✅ | ✅ | |
| Aucun | ✅ | ✅ |
Il existe également plusieurs types de sorties que vous pouvez obtenir en utilisant le paramètre layer_pooling_strategy :
layer_pooling_strategy="last" : renvoie le dernier état caché du modèle de transformateurlayer_pooling_strategy="concat" : renvoie la concaténation de la output_layers sélectionnée_layers dulayer_pooling_strategy="sum" : renvoie la somme de la output_layers sélectionnée_layers du modèle de transformateurlayer_pooling_strategy="mean" : renvoie la moyenne de l' output_layers sélectionné du modèle de transformateurlayer_pooling_strategy="scalar_mix" : renvoie la sortie d'une couche de mélange scalaire paramétré de l' output_layers sélectionné du modèle de transformateur Si vous souhaitez également toutes les sorties du modèle HuggingFace, vous pouvez définir return_all=True pour les obtenir.
class TransformersEmbedder ( torch . nn . Module ):
def __init__ (
self ,
model : Union [ str , tr . PreTrainedModel ],
subword_pooling_strategy : str = "sparse" ,
layer_pooling_strategy : str = "last" ,
output_layers : Tuple [ int ] = ( - 4 , - 3 , - 2 , - 1 ),
fine_tune : bool = True ,
return_all : bool = True ,
) La classe Tokenizer fournit la méthode tokenize pour prétraiter l'entrée pour la couche TransformersEmbedder . Vous pouvez passer des phrases brutes, des phrases pré-tendues et des phrases en lot. Il les préparera à renvoyer un dictionnaire avec les entrées du modèle. En passant return_tensors=True il renverra les entrées comme torch.Tensor .
Par défaut, si vous passez du texte (ou du lot) en tant que chaînes, il utilise le tokenizer HuggingFace pour les tokenize.
text = "This is a sample sentence"
tokenizer ( text )
text = [ "This is a sample sentence" , "This is another sample sentence" ]
tokenizer ( text ) Vous pouvez transmettre une phrase pré-tente (ou un lot de phrases) en définissant is_split_into_words=True
text = [ "This" , "is" , "a" , "sample" , "sentence" ]
tokenizer ( text , is_split_into_words = True )
text = [
[ "This" , "is" , "a" , "sample" , "sentence" , "1" ],
[ "This" , "is" , "sample" , "sentence" , "2" ],
]
tokenizer ( text , is_split_into_words = True )Tout d'abord, initialisez le jetons
import transformers_embedder as tre
tokenizer = tre . Tokenizer ( "bert-base-cased" ) text = "This is a sample sentence"
tokenizer ( text ) {
{
'input_ids': [[101, 1188, 1110, 170, 6876, 5650, 102]],
'token_type_ids': [[0, 0, 0, 0, 0, 0, 0]],
'attention_mask': [[1, 1, 1, 1, 1, 1, 1]],
'scatter_offsets': [[0, 1, 2, 3, 4, 5, 6]],
'sparse_offsets': {
'sparse_indices': tensor(
[
[0, 0, 0, 0, 0, 0, 0],
[0, 1, 2, 3, 4, 5, 6],
[0, 1, 2, 3, 4, 5, 6]
]
),
'sparse_values': tensor([1., 1., 1., 1., 1., 1., 1.]),
'sparse_size': torch.Size([1, 7, 7])
},
'sentence_lengths': [7],
}
text = "This is a sample sentence A"
text_pair = "This is a sample sentence B"
tokenizer ( text , text_pair ) {
'input_ids': [[101, 1188, 1110, 170, 6876, 5650, 138, 102, 1188, 1110, 170, 6876, 5650, 139, 102]],
'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1]],
'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]],
'scatter_offsets': [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]],
'sparse_offsets': {
'sparse_indices': tensor(
[
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],
[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
]
),
'sparse_values': tensor([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]),
'sparse_size': torch.Size([1, 15, 15])
},
'sentence_lengths': [15],
}
padding=True et return_tensors=True , le tokenzer renvoie le texte prêt pour le modèle batch = [
[ "This" , "is" , "a" , "sample" , "sentence" , "1" ],
[ "This" , "is" , "sample" , "sentence" , "2" ],
[ "This" , "is" , "a" , "sample" , "sentence" , "3" ],
# ...
[ "This" , "is" , "a" , "sample" , "sentence" , "n" , "for" , "batch" ],
]
tokenizer ( batch , padding = True , return_tensors = True )
batch_pair = [
[ "This" , "is" , "a" , "sample" , "sentence" , "pair" , "1" ],
[ "This" , "is" , "sample" , "sentence" , "pair" , "2" ],
[ "This" , "is" , "a" , "sample" , "sentence" , "pair" , "3" ],
# ...
[ "This" , "is" , "a" , "sample" , "sentence" , "pair" , "n" , "for" , "batch" ],
]
tokenizer ( batch , batch_pair , padding = True , return_tensors = True ) Il est possible d'ajouter des champs personnalisés à l'entrée du modèle et de dire au tokenizer comment les remplir à l'aide add_padding_ops . Commencez par initialiser le tokenizer avec le nom du modèle:
import transformers_embedder as tre
tokenizer = tre . Tokenizer ( "bert-base-cased" )Puis ajoutez-y les champs personnalisés:
custom_fields = {
"custom_filed_1" : [
[ 0 , 0 , 0 , 0 , 1 , 0 , 0 ],
[ 0 , 0 , 0 , 0 , 1 , 0 , 0 , 0 , 0 , 1 , 0 ]
]
} Nous pouvons maintenant ajouter la logique de rembourrage pour notre champ personnalisé custom_filed_1 . add_padding_ops La méthode prend l'entrée
key : nom du champ dans l'entrée du tokenzervalue : valeur à utiliser pour le rembourragelength : longueur à pad. Il peut s'agir d'un subword int ou de deux chaînes dans lequel l'élément est rembourré pour correspondre à la longueur des sous-mots, et word où l'élément est rembourré par rapport à la longueur du lot après la fusion des sous-mots. tokenizer . add_padding_ops ( "custom_filed_1" , 0 , "word" )Enfin, nous pouvons tokeniser l'entrée avec le champ personnalisé:
text = [
"This is a sample sentence" ,
"This is another example sentence just make it longer, with a comma too!"
]
tokenizer ( text , padding = True , return_tensors = True , additional_inputs = custom_fields )Les entrées sont prêtes pour le modèle, y compris la personnalité déposée.
>>> inputs
{
'input_ids': tensor(
[
[ 101, 1188, 1110, 170, 6876, 5650, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 101, 1188, 1110, 1330, 1859, 5650, 1198, 1294, 1122, 2039, 117, 1114, 170, 3254, 1918, 1315, 106, 102]
]
),
'token_type_ids': tensor(
[
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
]
),
'attention_mask': tensor(
[
[1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]
),
'scatter_offsets': tensor(
[
[ 0, 1, 2, 3, 4, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 14, 15, 16]
]
),
'sparse_offsets': {
'sparse_indices': tensor(
[
[ 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[ 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 14, 15, 16],
[ 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]
]
),
'sparse_values': tensor(
[1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,
1.0000, 1.0000, 0.5000, 0.5000, 1.0000, 1.0000, 1.0000]
),
'sparse_size': torch.Size([2, 17, 18])
}
'sentence_lengths': [7, 17],
}
Certains code de la classe TransformersEmbedder sont tirés de la bibliothèque de diffusion Pytorch. Les modèles pré-entraînés et le cœur du tokenzer proviennent? Transformateurs.
