WordRepresentations
1.0.0
Benchmark eksperimental ini membandingkan berbagai cara mewakili kata -kata dalam tugas yang disederhanakan untuk membangun model bahasa yang disebut SO.
Model bahasa adalah cara untuk menghitung probabilitas fragmen teks yang diberikan (rantai kata). NLP sebelumnya banyak menggunakan berbagai opsi untuk membangun LM berdasarkan penghitungan N-gram dan smoothing (smoothing) untuk mengkompensasi pelepasan N-gram lengkungan besar. Misalnya, NLTK memiliki implementasi metode Kneser-Ney. Ada juga sejumlah besar implementasi berbeda yang berbeda dalam detail teknis mengenai penyimpanan volume besar informasi n-gramer dan kecepatan pemrosesan teks, misalnya https://github.com/kpu/kenlm.
Dalam beberapa tahun terakhir, berbagai opsi untuk model bahasa saraf (NLM) telah menerima penggunaan luas, yang menggunakan berbagai arsitektur neurosoteal, termasuk berulang dan berkilau. NLM dapat dibagi menjadi dua kelompok: bekerja pada tingkat kata (nlm sadar-kata) dan pada tingkat karakter (karakter-sadar karakter). Opsi kedua sangat menarik karena memungkinkan model untuk bekerja dengan morfem . Ini sangat penting untuk bahasa dengan morfologi yang kaya. Untuk beberapa kata, ratusan bentuk tata bahasa berpotensi ada, seperti dalam kasus kata sifat dalam bahasa Rusia. Bahkan kasus teks yang sangat besar tidak menjamin bahwa semua varian bentuk kata akan dimasukkan dalam kosakata untuk NLM yang sadar-kata. Di sisi lain, struktur morfemik hampir selalu mematuhi aturan reguler, sehingga pengetahuan tentang dasar atau bentuk dasar dari kata tersebut memungkinkan Anda untuk menghasilkan opsi tata bahasa dan semantiknya: tebal, berani, gigitan, tebal, dll., Serta menentukan hubungan semantik antara kata -kata yang sama, bahkan jika kata -kata yang disesuaikan dengan konteksnya. Pernyataan terakhir menjadi sangat penting bagi bidang NLP dengan pembentukan kata yang dinamis, pertama -tama, itu adalah semua jenis media sosial.
Dalam kerangka tolok ukur, semua kode yang diperlukan telah disiapkan untuk mempelajari dan membandingkan kedua opsi NLM, bersama dengan metode lain untuk membangun LM-Characte-Aware dan Word-Aware.
Kami akan sedikit menyederhanakan model langage kami, mengatur tugas dalam bentuk ini. Ada N-gram dengan panjang yang dipilih sebelumnya (lihat konstanta NGRAM_ORDERD dalam modul DatasetVectorizers). Jika diperoleh dari kasing teks (jalur ke file UTF-8 yang menempel dijahit di _get_corpus_path kelas basevectorizer), maka kami percaya bahwa ini adalah kombinasi kata yang valid dan nilai target y = 1. Jika n-gram diperoleh dengan penggantian Acake dari salah satu kata dan rantai tersebut tidak ditemukan dalam kasus, maka targetnya = target.
N-gram yang tidak dapat diterima dihasilkan selama analisis kasus dalam jumlah yang sama dengan valid. Ternyata dataset seimbang, yang memfasilitasi tugas. Dan kurangnya kebutuhan untuk penandaan manual memungkinkan Anda untuk dengan mudah "bermain" dengan parameter seperti jumlah catatan dalam dataset pelatihan.
Dengan demikian, masalah klasifikasi biner diselesaikan. Klasifikasi akan menjadi implementasi gradien meningkatkan XGBOOST dan jaringan saraf, diimplementasikan pada keras, serta beberapa opsi lain pada bahasa pemrograman yang berbeda dan kerangka kerja DL.
Objek penelitian adalah pengaruh metode mewakili kata -kata dalam matriks input X pada keakuratan klasifikasi.
Analisis terperinci dari berbagai pendekatan untuk NLP, termasuk untuk tugas serupa, dapat ditemukan dalam artikel: primer pada model jaringan saraf untuk pemrosesan bahasa alami.
Opsi berikut diperiksa untuk XGBoost:
W2V - Kami menggunakan inti yang terlatih Word2vec, menempelkan kata -kata kata ke dalam satu vektor panjang
W2V_TAGS - Perluasan representasi W2V, kategori tambahan dari vektor akhir diperoleh dari tag morfologis kata. Ternyata sesuatu seperti model bahasa faktor
SDR - Representasi Terdistribusi Jarang Kata -kata yang diperoleh dengan faktorisasi model Word2Vector
Random_bitvector - Setiap kata dikaitkan dengan vektor fixed -panjang biner acak dengan proporsi 0/1 yang diberikan
BC - Vektor yang dibuat sebagai hasil dari karya pengelompokan coklat (lihat deskripsi https://en.wikipedia.org/wiki/bron_clustering dan implementasi https://github.com/percyliang/brunki) digunakan sebagai hasilnya
Chars - Setiap kata dikodekan sebagai rantai representasi simbol 1 -hot
HASHING_TRICK - Trik hashing yang digunakan untuk menyandikan kata -kata dengan sejumlah bit indeks terbatas (lihat deskripsi https://en.wikipedia.org/wiki/feature_hashing dan implementasi https://radimrehek.com/gensim/corpora/hashdictionary.html)
AE - Kata -kata kata diperoleh sebagai aktivasi pada lapisan dalam autoencoder. Pelatihan dalam autoencoder dan mendapatkan kata -kata vektor dilakukan oleh word_autoencoder3.py skrip dalam folder pymodels/wordautoencoders.
Dua metode presentasi tambahan tersedia untuk jaringan saraf, yang dikonversi menjadi representasi vektor tertentu menggunakan lapisan embedding (atau serupa dengan pustaka bekas yang digunakan.
Word_indeces - Kosakata disusun, setiap kata diberi indeks integer yang unik. Dengan demikian, 3-grade tampaknya menjadi tiga bilangan bulat.
Char_indeces - Alfabet dikompilasi, setiap simbol diberi indeks integer yang unik. Lebih lanjut, rantai indeks simbol dilengkapi dengan indeks sampel dengan panjang yang sama (panjang maksimum kata), dan rantai indeks simbol yang dihasilkan dikembalikan sebagai presentasi n-gram. Menggunakan lapisan penyematan (embedding di keras atau serupa), simbol dikonversi menjadi bentuk vektor padat yang dengannya jaringan saraf lainnya bekerja. Ternyata versi model bahasa saraf yang sadar karakter.
Untuk menyelesaikan masalah, berbagai perpustakaan pembelajaran mesin, jaringan saraf dan perpustakaan untuk komputasi matriks digunakan, termasuk:
Keras (dengan backend theano)
Lasagna (Theano)
Nolearn (theano)
Tensorflow
Solusi Python:
Pymodels/wr_xgboost.py - resolver berdasarkan xgboost
Pymodels/wr_catboost.py - resolver catboost pada indeks kata menggunakan kemampuan untuk menunjukkan indeks fitur kategori dalam dataset sehingga booster secara mandiri mempelajarinya selama pelatihan
Pymodels/wr_keras.py - resolver berdasarkan neurosette forward forward yang diimplementasikan pada keras
Pymodels/WR_KERAS_SDR2.PY - Solusi terpisah untuk memeriksa representasi terdistribusi yang jarang dari dimensi besar (dari 1024) dengan generasi matriks untuk pembelajaran dan validasi, pada keras. Pymodels/wr_lasagne.py - resolver berdasarkan neurosette foring forward yang diimplementasikan pada lasagna (Theano)
Pymodels/wr_nolearn.py - resolver berdasarkan neurosette umpan ke depan yang diimplementasikan pada nolearn+lasagna (theano)
Pymodels/wr_tensorflow.py - pemecah berdasarkan neurosette maju yang diimplementasikan pada TensorFlow
Solusi di C#:
Csharpmodels/withaccordnet/program.cs - resolver berdasarkan Feed Forward Grids Accord.net (C#, Project for VS 2015)
CSHARPMODELS/MYBASELINE/PROGRAM.CS - Solusi Berdasarkan Implementasi Saya Vanilla MLP (C#, Proyek untuk VS 2015)
Solusi di C ++:
Cxxmodels/tinydnn_model/tinydn_model.cpp - resolusi MLP, diimplementasikan oleh pustaka kecil -dnn (C ++, proyek untuk VS 2015)
Cxxmodels/singa_model/alexnet.cc - resolver berdasarkan jaringan saraf yang diimplementasikan oleh Apache.singa (C ++, proyek untuk VS 2015)
Cxxmodels/opennn_model/main.cpp - resolver berdasarkan neuroset, diimplementasikan oleh OpenNN (C ++, proyek untuk VS 2015)
Solusi di java javamodels/with4j/src/main/java/wordrepresentationstest.java - resolver mlp, diimplementasikan oleh deeplearning4j library
Kelas dan alat internal:
Pymodels/corpusreaders.py - kelas untuk membaca baris dari bangunan teks dari format yang berbeda (zip | txt polos) pymodels/datasetvectorizers.py - vektoris dan pabrik untuk pilihan yang nyaman
Pymodels/store_dataset_file.py - pembuatan dataset dan pelestariannya untuk model C# dan C ++
Untuk jaringan saraf, 2 arsitek diimplementasikan berdasarkan keras. MLP adalah feed forward nefete sederhana dengan lapisan penuh. Convnet adalah mesh yang menggunakan lapisan bundel.
Switching Architectures dilakukan oleh NET_ARCH di parameter Net_arch di file wr_keras.py.
Dapat dicatat bahwa opsi Bristly sering memberikan solusi yang lebih akurat, tetapi model yang sesuai memiliki varian yang lebih besar, sederhananya - akurasi akhir sangat melompat untuk beberapa model dengan parameter yang sama.
Deskripsi terperinci tentang arsitektur dan hasil numerik dari percobaan dapat ditemukan di sini: https://kelijah.livejournal.com/224925.html.
Semua opsi benchmark menggunakan file teks dalam pengkodean UTF-8 untuk menerima daftar N-gram. Diasumsikan bahwa pembagian teks menjadi kata -kata dan membawa ke register yang lebih rendah dibuat terlebih dahulu dengan kode pihak ketiga. Oleh karena itu, skrip membaca baris dari file ini, memecahnya menjadi kata -kata dengan spasi.
Untuk kenyamanan bermain eksperimen, saya menempatkan paparan terkompresi dari kotak besar dengan ukuran 100 ribu baris di folder data. Ini cukup untuk mengulangi semua pengukuran. Agar tidak membebani repositori dengan file besar, cincang. Metode BasEvectorizer._Load_ngrams itu sendiri membongkar isinya dengan cepat, jadi Anda tidak perlu melakukan manipulasi manual.
Dalam varian vektorisasi W2V_Tags, fitur morfologis ditambahkan ke vena W2V. Tanda-tanda ini untuk setiap kata diambil dari file Word2tags_bin.zip dalam subkatal data, yang diperoleh dengan mengonversi kamus tata bahasa saya (http://solarix.ru/sql-dictionary-sdk.shtml). Hasil konversi ditarik ke 165 MB, yang agak terlalu banyak untuk repositori git. Oleh karena itu, saya meneriakkan file yang dihasilkan dari kamus tata bahasa, dan kelas vektorisasi yang sesuai dari dataset itu sendiri membongkar dengan cepat selama operasi.
Harap dicatat bahwa karena homonim dari bentuk tata bahasa, banyak kata memiliki lebih dari satu set tag. Misalnya, kata 'beruang' dapat menjadi bentuk dari satu atau jamak, masing -masing, dalam kasus genitif atau nominatif. Saat membentuk tag untuk kata -kata, saya menggabungkan tag homonim.
Proses dua tahap digunakan. Pertama, kami mendapatkan vektor kata W2V. Sebuah skrip kecil pada python membongkar vektor ke dalam file teks dalam format CSV.
Kemudian, menggunakan utilitas https://github.com/mfaruqui/sparse-coding, sebuah perintah dilakukan:
./nonneg.o input_vectors.txt 16 0.2 1e-5 4 out_vecs.txt
File out_vecs.txt yang berisi kata -kata sdr dengan parameter yang ditunjukkan dihasilkan: size = 16*vektor w2v, mengisi = 0,2 file ini dimuat dengan kelas sdr_vectorizer.
https://habrahabr.ru/post/335838/
http://kelijah.livejournal.com/217608.html
Sebagai cek, kami menggunakan menghafal N-gram dari set pelatihan dan pencarian di antara N-gram yang diingat untuk set tes. Ukuran kecil dari set pelatihan mengarah pada fakta bahwa pada set tes, model berperilaku hanya sebagai penebak acak, memberikan akurasi 0,50.
Tabel utama hasil tersedia di tautan. Sisa hasil berikut diperoleh untuk satu set 1.000.000 3 gram.
Untuk resolver berdasarkan XGBoost (wr_xgboost.py), hasil berikut diperoleh.
Untuk dataset yang berisi 1.000.000 trigram: w2v_tags (Word2Vector + Morph Tags) ==> 0.81
W2V (Word2Vector Dim = 32) ==> 0.80
SDR (jarang terdistribusi mewakili, panjang 512, 20% unit) ==> 0,78 BC (Brown Clustering) ==> 0,70
chars (arang satu-panas encoding) ==> 0.71
Random_bitvector (vektor bit acak, bagian dari unit 16%) ==> 0,696
Hashing_trick (trik hashing dengan 32.000 slot) ==> 0,64
Untuk pemecah berdasarkan Lasagne MLP:
Akurasi = 0,71
Untuk pemecah berdasarkan nolearn+lasagne MLP:
Akurasi = 0,64
Untuk resolver berdasarkan MLP kecil-DNN:
Akurasi = 0,58
Untuk pemecah berdasarkan Accord.net Feed Forward Neural Net:
Word2Vector ==> 0.68
Untuk resolusi catboost pada karakteristik kategorikal "indeks kata":
Akurasi = 0,50
Untuk pemecah berdasarkan Apache.singa MLP:
Akurasi = 0,74
Solusi Baseline - Menghafal N -Gram dari Dataset Pelatihan
Akurasi = 0,50
