Download transformers embedder - Download Kode Sumber transformers embedder

transformers embedder

Kode Sumber AI

3.0.11

Unduh

Transformers Embedder

Lapisan transformator level kata berdasarkan Pytorch dan? Transformer.

Cara menggunakan

Instal perpustakaan dari PYPI:

pip install transformers-embedder

atau dari conda:

conda install -c riccorl transformers-embedder

Ini menawarkan lapisan Pytorch dan tokenizer yang mendukung hampir setiap model pretrained dari Huggingface? Transformers Library. Berikut adalah contoh singkat:

 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

Info

Salah satu gangguan menggunakan model berbasis transformator adalah bahwa tidak sepele untuk menghitung embeddings kata dari embeddings sub-token yang mereka output. Dengan API ini semudah menggunakan? Transformers untuk mendapatkan embeddings tingkat kata dari secara teoritis setiap model transformator yang didukungnya.

Model

Strategi Pooling Subword

Kelas TransformersEmbedder menawarkan 3 cara untuk mendapatkan embeddings:

subword_pooling_strategy="sparse" : Menghitung rata-rata embeddings dari sub-token dari masing-masing kata (yaitu embedding dari sub-token dikumpulkan bersama-sama) menggunakan multiplikasi matriks jarang. Strategi ini adalah yang default.
subword_pooling_strategy="scatter" : Menghitung rata-rata embeddings dari sub-token dari setiap kata menggunakan operasi hambatan-kogen. Ini tidak deterministik, tetapi bekerja dengan ekspor ONNX.
subword_pooling_strategy="none" : Mengembalikan output mentah dari model transformator tanpa pengumpulan sub-token.

Di sini tabel fitur kecil:

	Pooling	Deterministik	Onnx
Jarang	✅	✅
Menyebarkan	✅		✅
Tidak ada		✅	✅

Strategi Pooling Layer

Ada juga beberapa jenis output yang bisa Anda dapatkan menggunakan parameter layer_pooling_strategy :

layer_pooling_strategy="last" : Mengembalikan keadaan tersembunyi terakhir dari model transformator
layer_pooling_strategy="concat" : Mengembalikan gabungan output_layers yang dipilih dari
Model Transformer
layer_pooling_strategy="sum" : Mengembalikan jumlah output_layers yang dipilih dari model transformator
layer_pooling_strategy="mean" : Mengembalikan rata -rata output_layers yang dipilih dari model transformator
layer_pooling_strategy="scalar_mix" : Mengembalikan output dari lapisan campuran skalar parameterisasi dari output_layers yang dipilih dari model transformator

Jika Anda juga menginginkan semua output dari model HuggingFace, Anda dapat mengatur return_all=True untuk mendapatkannya.

 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

Kelas Tokenizer menyediakan metode tokenize untuk preprocess input untuk lapisan TransformersEmbedder . Anda dapat melewati kalimat mentah, kalimat yang diwaspadai dan kalimat dalam batch. Ini akan melakukan preprocess mereka mengembalikan kamus dengan input untuk model. Dengan melewati return_tensors=True itu akan mengembalikan input sebagai torch.Tensor .

Secara default, jika Anda melewati teks (atau batch) sebagai string, ia menggunakan tokenizer huggingface untuk tokenize mereka.

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

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

Anda dapat melewati kalimat yang telah diwariskan (atau batch kalimat) dengan mengatur 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 )

Contoh

Pertama, inisialisasi tokenizer

 import transformers_embedder as tre

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

Anda dapat melewati satu kalimat sebagai string:

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

Pasangan kalimat

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

Batch kalimat atau pasangan kalimat. Menggunakan padding=True dan return_tensors=True , tokenizer mengembalikan teks yang siap untuk model

 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 )

Bidang khusus

Dimungkinkan untuk menambahkan bidang khusus ke input model dan memberi tahu tokenizer cara memadukannya menggunakan add_padding_ops . Mulailah dengan menginisialisasi tokenizer dengan nama model:

 import transformers_embedder as tre

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

Kemudian tambahkan bidang khusus ke dalamnya:

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

Sekarang kami dapat menambahkan logika padding untuk bidang khusus kami custom_filed_1 . Metode add_padding_ops mengambil input

key : Nama bidang di input tokenizer
value : Nilai untuk digunakan untuk bantalan
length : Panjang ke pad. Ini bisa berupa int , atau dua nilai string, subword di mana elemen empuk agar sesuai dengan panjang subword, dan word di mana elemen empuk relatif terhadap panjang batch setelah penggabungan subwords.

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

Akhirnya, kita dapat tokenize input dengan bidang khusus:

 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 )

Input siap untuk model, termasuk yang diajukan khusus.

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