Скачать transformers embedder - transformers embedder Source Code Скачать

transformers embedder

AI Исходный код

3.0.11

Скачать

Трансформеры Embedder

Слой трансформатора уровня слов на основе питорха и? Трансформеры.

Как использовать

Установите библиотеку из PYPI:

pip install transformers-embedder

или из Conda:

conda install -c riccorl transformers-embedder

Он предлагает слой Pytorch и токенизатор, который поддерживает почти каждую предварительную модель от Huggingface? Transformers Library. Вот быстрый пример:

 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

Информация

Одним из раздражения использования моделей на основе трансформаторов является то, что не тривиально вычислять встраивание слов из встроенных вкладки, которые они выводят. С помощью этого API это так же просто, как и использовать? Трансформаторы, чтобы получить встраивание уровня слов от теоретически каждой модели трансформатора, которую он поддерживает.

Модель

Стратегия объединения подводов

Класс TransformersEmbedder предлагает 3 способа получить встраивание:

subword_pooling_strategy="sparse" : вычисляет среднее значение встроенных подтоконов каждого слова (то есть встроения подтокенов объединяются вместе) с использованием редкого умножения матрицы. Эта стратегия - по умолчанию.
subword_pooling_strategy="scatter" : вычисляет среднее значение встроенных подтоконов каждого слова, используя операцию с рассеянием от-тода. Это не детерминистично, но работает с Export Onnx.
subword_pooling_strategy="none" : возвращает необработанный вывод модели трансформатора без баллов.

Здесь маленькая таблица функций:

	Объединение	Детерминированный	Onnx
Редкий	✅	✅
Рассеянный	✅		✅
Никто		✅	✅

Стратегия объединения слоев

Существует также несколько типов выходов, которые вы можете получить, используя параметр layer_pooling_strategy :

layer_pooling_strategy="last" : возвращает последнее скрытое состояние модели трансформатора
layer_pooling_strategy="concat" : возвращает конкатенацию выбранного output_layers
Трансформатор модель
layer_pooling_strategy="sum" : возвращает сумму выбранного output_layers модели трансформатора
layer_pooling_strategy="mean" : возвращает среднее значение выбранного output_layers модели трансформатора
layer_pooling_strategy="scalar_mix" : возвращает выход параметризуемого слоя скалярной смеси выбранного output_layers модели трансформатора

Если вам также нужны все выходы из модели HuggingFace, вы можете установить return_all=True чтобы получить их.

 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 ,
    )

Токенизатор

Класс Tokenizer обеспечивает метод tokenize для предварительной обработки ввода для слоя TransformersEmbedder . Вы можете вынести необработанные предложения, предварительные предложения и предложения в партии. Это предварительно обработает их возвращение словаря с входными данными для модели. Пропустив return_tensors=True он вернет входы как torch.Tensor .

По умолчанию, если вы передаете текст (или пакетный) в качестве строк, он использует токенизатор HuggingFace для их токенизации.

 text = "This is a sample sentence"
tokenizer ( text )

text = [ "This is a sample sentence" , "This is another sample sentence" ]
tokenizer ( text )

Вы можете передать предварительное предложение (или партии предложений), установив 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 )

Примеры

Сначала инициализируйте токенизатор

 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 и return_tensors=True , токенизатор возвращает текст, готовый к модели

 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 )

Пользовательские поля

Можно добавить пользовательские поля к вводу модели и сообщить tokenizer , как наладить их, используя add_padding_ops . Начните с инициализации токенизатора с именем модели:

 import transformers_embedder as tre

tokenizer = tre . Tokenizer ( "bert-base-cased" )

Затем добавьте в него пользовательские поля:

 custom_fields = {
  "custom_filed_1" : [
    [ 0 , 0 , 0 , 0 , 1 , 0 , 0 ],
    [ 0 , 0 , 0 , 0 , 1 , 0 , 0 , 0 , 0 , 1 , 0 ]
  ]
}

Теперь мы можем добавить логику заполнения для нашего пользовательского поля custom_filed_1 . Метод add_padding_ops принимает вход

key : Имя поля при входе токенизатора
value : значение для использования для прокладки
length : длина к прокладке. Это может быть int , или два строкового значения, subword , в которой элемент сочетается в соответствии с длиной подчинок, и word , где элемент дополнен по сравнению с длиной партии после слияния подчинок.

 tokenizer . add_padding_ops ( "custom_filed_1" , 0 , "word" )

Наконец, мы можем токенизировать ввод с помощью пользовательского поля:

 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 )

Входные данные готовы к модели, в том числе на заказ.

 >>> 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],
}