transformers embedder
3.0.11
Uma camada de transformador de nível de palavra baseada em pytorch e? Transformadores.
Instale a biblioteca da Pypi:
pip install transformers-embedderou de conda:
conda install -c riccorl transformers-embedderOferece uma camada pytorch e um tokenizador que suporta quase todos os modelo pré -treinados da Biblioteca de Transformers do Huggingface? Aqui está um exemplo rápido:
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
Um dos aborrecimentos do uso de modelos baseados em transformadores é que não é trivial calcular incorporações de palavras a partir das incorporações subcoken que eles geram. Com esta API, é tão fácil quanto usar? Transformers para obter incorporações no nível das palavras de teoricamente todos os modelo de transformadores que ele suporta.
A classe TransformersEmbedder oferece três maneiras de obter as incorporações:
subword_pooling_strategy="sparse" : calcula a média das incorporações dos sub-tochens de cada palavra (ou seja, as incorporações dos sub-tochens são agrupadas) usando uma multiplicação de matriz esparsa. Essa estratégia é a padrão.subword_pooling_strategy="scatter" : calcula a média das incorporações dos sub-tochens de cada palavra usando uma operação de dispersão. Não é determinístico, mas funciona com a exportação ONNX.subword_pooling_strategy="none" : Retorna a saída bruta do modelo do transformador sem pool de suboken.Aqui uma pequena tabela de recursos:
| Pooling | Determinístico | ONNX | |
|---|---|---|---|
| Escasso | ✅ | ✅ | |
| Dispersão | ✅ | ✅ | |
| Nenhum | ✅ | ✅ |
Também existem vários tipos de saídas que você pode obter usando o parâmetro layer_pooling_strategy :
layer_pooling_strategy="last" : retorna o último estado oculto do modelo de transformadorlayer_pooling_strategy="concat" : retorna a concatenação dos output_layers selecionados dolayer_pooling_strategy="sum" : retorna a soma do output_layers selecionado do modelo do transformadorlayer_pooling_strategy="mean" : retorna a média do output_layers selecionado do modelo do transformadorlayer_pooling_strategy="scalar_mix" : retorna a saída de uma camada de mistura escalar parametrizada dos output_layers selecionadas do modelo do transformador Se você também deseja todas as saídas do modelo Huggingface, você pode definir return_all=True para obtê -las.
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 ,
) A classe Tokenizer fornece o método tokenize para pré -processamento a entrada da camada TransformersEmbedder . Você pode passar frases brutas, frases pré-tocadas e sentenças em lote. Ele os pré -processará retornando um dicionário com as entradas do modelo. Ao aprovar return_tensors=True ele retornará as entradas como torch.Tensor .
Por padrão, se você passar o texto (ou lote) como strings, ele usará o tokenizador Huggingface para tokenizá -los.
text = "This is a sample sentence"
tokenizer ( text )
text = [ "This is a sample sentence" , "This is another sample sentence" ]
tokenizer ( text ) Você pode passar por uma frase pré-tocada (ou lote de frases) definindo 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 )Primeiro, inicialize o tokenizer
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 e return_tensors=True , o tokenizer retorna o texto pronto para o modelo 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 ) É possível adicionar campos personalizados à entrada do modelo e informar ao tokenizer como prendê -los usando add_padding_ops . Comece inicializando o tokenizer com o nome do modelo:
import transformers_embedder as tre
tokenizer = tre . Tokenizer ( "bert-base-cased" )Em seguida, adicione os campos personalizados:
custom_fields = {
"custom_filed_1" : [
[ 0 , 0 , 0 , 0 , 1 , 0 , 0 ],
[ 0 , 0 , 0 , 0 , 1 , 0 , 0 , 0 , 0 , 1 , 0 ]
]
} Agora, podemos adicionar a lógica de preenchimento para o nosso campo personalizado custom_filed_1 . o método add_padding_ops leva a entrada
key : Nome do campo na entrada do tokenizervalue : Valor a ser usado para preenchimentolength : Comprimento para Pad. Pode ser um int , ou dois valor da string, subword , no qual o elemento é acolchoado para corresponder ao comprimento das subpainhas e word em que o elemento é acolchoado em relação ao comprimento do lote após a mesclagem das subpainhas. tokenizer . add_padding_ops ( "custom_filed_1" , 0 , "word" )Finalmente, podemos tokenizar a entrada com o campo personalizado:
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 )As entradas estão prontas para o modelo, incluindo o personalizado.
>>> 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],
}
Algum código na classe TransformersEmbedder é retirado da biblioteca de dispersão Pytorch. Os modelos pré -treinados e o núcleo do tokenizer são de? Transformadores.
