calbert

Calbert

A Catalan Albert (A Lite Bert), Google mengambil pembelajaran sendiri dari representasi bahasa.

Ini dilatih pada corpus 19.557.475 pasangan kalimat (berisi 729 juta kata unik) yang diekstraksi dari subset Catalan dari dataset Oscar Inria. Kami menggunakan set validasi 833.259 pasangan kalimat untuk mengevaluasi model.

Anda dapat membaca kertas Albert asli di sini.

Model pra-terlatih

Mereka tersedia di halaman hub model HuggingFace

Model	Lengkungan.	Data pelatihan	Bermain dengannya	Visualisasikan
codegram / calbert-tiny-uncased	Tiny (Uncased)	Oscar (4,3 GB teks)	Kartu di Model Hub	Visualisasikan di Exbert
codegram / calbert-base-uncased	Pangkalan (uncased)	Oscar (4,3 GB teks)	Kartu di Model Hub	Visualisasikan di Exbert

Bagaimana cara menggunakannya?

Anda hanya membutuhkan perpustakaan transformers . Tidak ada lagi yang bisa dikloning atau diinstal.

Untuk memilih versi model mana yang akan digunakan ( tiny , atau base ), pertimbangkan bahwa model yang lebih kecil kurang kuat, tetapi lebih gesit dan kurang haus sumber daya untuk dijalankan.

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 dropout

Sekarang ke dua kasus penggunaan utama yang dapat Anda lakukan.

Memprediksi kata yang hilang dalam kalimat Catalan

Ini adalah kasus penggunaan paling sederhana, namun bukan yang paling berguna. Tetap saja, ini dia! Kata -kata apa pun yang ingin Anda tutupi, gunakan token khusus [MASK] untuk menunjukkannya. Model akan menghasilkan kandidat yang paling mungkin untuk kata bertopeng.

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

Mengekstraksi vektor fitur dari kalimat atau dokumen Catalan

Vektor fitur yang diekstraksi dapat digunakan untuk mengindeks dokumen sebagai vektor padat di Elasticsearch misalnya, dan melakukan pencarian kesamaan.

Kasus penggunaan lainnya adalah pemahaman bahasa alami -menggunakan vektor -vektor ini sebagai representasi abstrak dari dokumen/kalimat yang dapat digunakan sebagai input ke model hilir lainnya seperti pengklasifikasi.

Inilah cara mengekstrak vektor dari kalimat atau dokumen:

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

Kredit

Ini adalah bagian dari penelitian terapan yang kami lakukan di Codegram (siapa yang harus berterima kasih atas waktu dan komputasi!).

Ini akan menjadi satu ton rasa sakit untuk dibangun tanpa perpustakaan transformator dan token yang kuat dari Huggingface. Terima kasih telah membuat NLP benar -benar menyenangkan untuk diajak bekerja sama!

Juga, terima kasih kepada Google Research untuk membuat dan open-sourcing Albert di tempat pertama.

Apa di Bumi itu Albert

Albert adalah model bahasa, yaitu jaringan saraf yang dapat mempelajari urutan dengan struktur tertentu, seperti kalimat dalam bahasa alami (tetapi bukan hanya bahasa alami!).

Tapi bagaimana mereka belajar bahasa? Model bahasa yang berbeda dilatih dengan tugas dalih yang berbeda, yaitu tantangan yang Anda berikan kepada mereka sehingga mereka dapat belajar bagaimana bahasa bekerja. Idenya adalah bahwa untuk menjadi baik dalam tugas yang satu ini mereka harus secara tidak langsung mempelajari tata bahasa bahasa, dan bahkan semantik dan gayanya.

Model bahasa tradisional (juga dikenal sebagai kausal ) biasanya dilatih dengan tugas memprediksi kata berikutnya dalam urutan, seperti ini:

• Input: "Anjing itu makan sangat [kosong]"
• Output yang benar: "dengan cepat"

Namun, Albert berasal dari keluarga lain yang disebut model bahasa bertopeng . Dalam keluarga ini, tugas dalih yang harus mereka pelajari adalah serupa, tetapi alih -alih selalu memprediksi kata terakhir dalam urutan, beberapa kata dalam kalimat secara acak berubah menjadi kosong (atau bertopeng ), seperti ini:

• Input: "The [blank] makan sangat [kosong]"
• Output yang benar: "anjing", "cepat"

Tugas ini sedikit lebih sulit, dan yang lebih penting, membutuhkan pemahaman konteks seputar kekosongan yang jauh lebih baik.

Bagaimana tugas -tugas itu lebih dari sekadar pemborosan listrik yang tidak ada gunanya

Ternyata, begitu model bahasa menjadi sangat, sangat bagus dalam tugas dalih yang agak sia -sia ini, itu dapat dengan mudah digunakan kembali untuk tugas yang jauh lebih menarik.

Begitu bahasa belajar tata bahasa dan semantik, itu bisa menjadi pengklasifikasi kalimat yang sangat baik, dan bahkan seluruh dokumen, misalnya.

Jika Anda mengajarkannya untuk mengklasifikasikan tweet atau dokumen ke dalam kategori (atau mengidentifikasi sentimen, atau toksisitas misalnya) tidak lagi melihat sekelompok karakter yang membingungkan, tetapi lebih "membaca" dokumen pada tingkat yang jauh lebih abstrak, sehingga dapat "masuk akal" jauh lebih mudah. (Perhatikan kutipan udara, ini bukan sihir tetapi mungkin hal yang paling dekat.)

Mengapa Albert di Catalan

Karena tidak ada model bahasa di Catalan! Dan ada banyak teks Catalan yang harus diproses. (Di Catalonia).

Pengaturan

Untuk manajemen ketergantungan kami menggunakan puisi (dan Docker tentu saja).

pip install -U poetry
poetry install
poetry shell

Gambar produksi untuk melatih model berada di bawah docker/ , dan itu disebut codegram/calbert . Ini berisi semua dependensi terbaru, tetapi tidak ada kode - Deepkit akan mengirimkan kode dalam setiap percobaan (baca terus untuk mempelajari lebih lanjut tentang Deepkit).

Dataset dan tokenizer

Semua konfigurasi hidup di bawah config . Di sana Anda dapat mengontrol parameter yang terkait dengan pelatihan, tokenizing, dan segalanya, dan bahkan memilih versi model mana yang akan dilatih.

Semua konfigurasi dapat diterbitkan, karena konfigurasi Hydra. Periksa dokumen mereka.

Mendapatkan dataset

Subset kecil dari dataset hidup di bawah dist/data sehingga Anda dapat melatih model kecil dan melakukan eksperimen cepat secara lokal.

Untuk mengunduh dataset lengkap dan secara otomatis membaginya dalam pelatihan / validasi, cukup jalankan perintah ini:

python -m calbert download_data --out-dir dataset

Melatih kembali tokenizer

Tokenizer pretrained berada di dist/tokenizer-{cased,uncased} . Mereka hanya dilatih di set pelatihan penuh.

Jika Anda ingin melatih kembali tokenizer (secara default uncased):

python -m calbert train_tokenizer --input-file dataset/train.txt --out-dir tokenizer

Untuk melatih yang cased, amati konfigurasi Hydra yang sesuai:

python -m calbert train_tokenizer --input-file dataset/train.txt --out-dir tokenizer vocab.lowercase=False

Melatih dan menjalankan eksperimen

Kami menggunakan Deepkit untuk menjalankan dan melacak eksperimen. Unduh secara gratis untuk platform pilihan Anda jika Anda ingin berjalan secara lokal, atau periksa dokumen mereka untuk menjalankan server komunitas gratis mereka.

Melatih model tes

Untuk memastikan semuanya berfungsi, mari kita latih model uji dengan gambar Docker yang sebenarnya di Deepkit:

deepkit run test.deepkit.yml

Secara default itu akan melatihnya dalam instance Deepkit lokal Anda, menggunakan CPU Anda. Baca dokumen mereka untuk mempelajari cara menyesuaikan lari Anda.

Pelatihan tentang gugus

Konfigurasikan sebuah cluster di Deepkit lokal Anda dengan setidaknya satu mesin dengan GPU.

deepkit run --cluster

Berbagi model dengan dunia

Setelah Anda memiliki model yang terlatih, Anda dapat mengekspornya untuk digunakan sebagai model standar HuggingFace Transformers.

Misalnya, mari kita bayangkan Anda melatih model base-uncased dan Anda ingin mengekspornya.

Unduh folder export dari output di Deepkit Run Anda, dan jalankan:

mv export calbert-base-uncased
transformers-cli login
transformers-cli upload export

Menjalankan tes

make test