Bangun Program Klasifikasi Teks: Tutorial NLP

Pembelajaran mendalam adalah teknologi yang telah menjadi bagian penting dari alur kerja pembelajaran mesin. Memanfaatkan peningkatan kekuatan komputasi paralel dan alat pendukung, jaringan saraf kompleks dan mendalam yang dulunya tidak praktis sekarang menjadi layak.

Munculnya perpustakaan yang kuat dan dapat diakses seperti Tensorflow, Torch, dan Deeplearning4j juga telah membuka pengembangan bagi pengguna di luar departemen akademis dan penelitian perusahaan teknologi besar. Sebagai bukti pertumbuhannya di mana-mana, perusahaan seperti Huawei dan Apple kini menyertakan prosesor khusus yang dioptimalkan untuk pembelajaran mendalam di perangkat terbaru mereka untuk mendukung aplikasi pembelajaran mendalam.

Pembelajaran mendalam telah membuktikan kekuatannya di banyak domain. Yang paling menonjol, Google AlphaGo mampu mengalahkan pemain manusia dalam permainan Go, sebuah permainan yang kompleksitas membingungkannya pernah dianggap sebagai penghalang yang hampir tidak dapat diatasi oleh komputer dalam persaingannya melawan pemain manusia. Proyek Flow Machines oleh Sony telah mengembangkan jaringan saraf yang dapat membuat musik dengan gaya musisi terkenal di masa lalu. FaceID, fitur keamanan yang dikembangkan oleh Apple, menggunakan pembelajaran mendalam untuk mengenali wajah pengguna dan melacak perubahan wajah pengguna dari waktu ke waktu.

Dalam artikel ini, kami akan menerapkan pembelajaran mendalam pada dua topik favorit saya: pemrosesan bahasa alami dan anggur. Kami akan membuat model untuk memahami ulasan anggur bahasa alami oleh para ahli dan menyimpulkan variasi anggur yang mereka ulas.

Pembelajaran Mendalam untuk NLP

Pembelajaran mendalam telah digunakan secara luas dalam pemrosesan bahasa alami (NLP) karena sangat cocok untuk mempelajari struktur dasar kalimat yang kompleks dan kedekatan semantik berbagai kata. Misalnya, keadaan seni saat ini untuk analisis sentimen menggunakan pembelajaran mendalam untuk menangkap konsep linguistik yang sulit dimodelkan seperti negasi dan sentimen campuran.

Pembelajaran mendalam memiliki beberapa keunggulan dibandingkan algoritma lain untuk NLP:

1. Model fleksibel: Model pembelajaran mendalam jauh lebih fleksibel daripada model ML lainnya. Kita dapat dengan mudah bereksperimen dengan struktur yang berbeda, menambahkan dan menghapus lapisan sesuai kebutuhan. Model pembelajaran mendalam juga memungkinkan untuk membangun model dengan keluaran yang fleksibel. Fleksibilitas adalah kunci untuk mengembangkan model yang cocok untuk memahami struktur linguistik yang kompleks. Ini juga penting untuk mengembangkan aplikasi NLP seperti terjemahan, chatbots, dan aplikasi text-to-speech.
2. Pengetahuan domain yang lebih sedikit diperlukan: Sementara seseorang tentu saja membutuhkan beberapa pengetahuan domain dan intuisi untuk mengembangkan model pembelajaran mendalam yang baik, kemampuan algoritma pembelajaran mendalam untuk mempelajari hierarki fitur sendiri berarti bahwa pengembang tidak memerlukan banyak pengetahuan mendalam tentang ruang masalah untuk mengembangkan algoritma NLP pembelajaran mendalam. Untuk ruang masalah serumit bahasa alami, ini adalah keuntungan yang sangat disambut baik.
3. Pembelajaran berkelanjutan yang lebih mudah: Algoritme pembelajaran mendalam mudah dilatih saat data baru masuk. Beberapa algoritme pembelajaran mesin mengharuskan seluruh kumpulan data dikirim melalui model untuk diperbarui, yang akan menimbulkan masalah bagi kumpulan data besar dan langsung.

Masalah Hari Ini

Hari ini, kami akan membangun algoritme pembelajaran mendalam untuk menentukan variasi anggur yang ditinjau berdasarkan teks ulasan. Kami akan menggunakan kumpulan data majalah anggur di https://www.kaggle.com/zynicide/wine-reviews yang disediakan oleh pengguna Kaggle zackthoutt .

Secara konseptual, pertanyaannya adalah, bisakah kita mengambil ulasan anggur seperti ...

Aroma termasuk buah tropis, sapu, belerang dan ramuan kering. Langit-langitnya tidak terlalu ekspresif, menawarkan apel mentah, jeruk, dan sage kering di samping keasaman cepat.

…dan menyadari bahwa ini tentang campuran putih? Beberapa penggemar anggur mungkin mengenali tanda-tanda anggur putih seperti apel, jeruk, dan keasaman yang nyata, tetapi dapatkah kita melatih jaringan saraf kita untuk mengenali sinyal-sinyal ini? Selain itu, dapatkah kita melatih jaringan saraf kita untuk mengenali perbedaan halus antara ulasan campuran putih dan ulasan pinot grigio?

Algoritma serupa

Masalah yang kita kerjakan hari ini pada dasarnya adalah masalah klasifikasi NLP. Ada beberapa algoritma klasifikasi NLP yang telah diterapkan pada berbagai masalah dalam NLP. Misalnya, naive Bayes telah digunakan dalam berbagai algoritma deteksi spam, dan mesin vektor dukungan (SVM) telah digunakan untuk mengklasifikasikan teks seperti catatan kemajuan di lembaga kesehatan. Akan menarik untuk menerapkan versi sederhana dari algoritme ini sebagai dasar untuk model pembelajaran mendalam kami.

Naif Bayes

Implementasi naive Bayes yang populer untuk NLP melibatkan pra-pemrosesan teks menggunakan TF-IDF dan kemudian menjalankan naive Bayes multinomial pada output yang telah diproses sebelumnya. Ini memungkinkan algoritme dijalankan pada kata-kata yang paling menonjol di dalam dokumen. Kita dapat mengimplementasikan naive bayes sebagai berikut:

 import numpy as np from sklearn.naive_bayes import MultinomialNB from sklearn.feature_extraction.text import CountVectorizer import pandas as pd from collections import Counter from sklearn.model_selection import train_test_split from sklearn.feature_extraction.text import TfidfTransformer df = pd.read_csv('data/wine_data.csv') counter = Counter(df['variety'].tolist()) top_10_varieties = {i[0]: idx for idx, i in enumerate(counter.most_common(10))} df = df[df['variety'].map(lambda x: x in top_10_varieties)] description_list = df['description'].tolist() varietal_list = [top_10_varieties[i] for i in df['variety'].tolist()] varietal_list = np.array(varietal_list) count_vect = CountVectorizer() x_train_counts = count_vect.fit_transform(description_list) tfidf_transformer = TfidfTransformer() x_train_tfidf = tfidf_transformer.fit_transform(x_train_counts) train_x, test_x, train_y, test_y = train_test_split(x_train_tfidf, varietal_list, test_size=0.3) clf = MultinomialNB().fit(train_x, train_y) y_score = clf.predict(test_x) n_right = 0 for i in range(len(y_score)): if y_score[i] == test_y[i]: n_right += 1 print("Accuracy: %.2f%%" % ((n_right/float(len(test_y)) * 100)))

Jalankan kode di atas dan Anda akan melihat sesuatu seperti berikut: 73,56%

Mengingat kita sedang melihat 10 kelas, ini adalah hasil yang cukup baik.

Kami juga dapat menggunakan mesin vektor dukungan dan melihat bagaimana hasilnya. Untuk melihat kinerjanya, cukup ganti definisi pengklasifikasi dengan

 clf = SVC(kernel='linear').fit(train_x, train_y)

Jalankan ini dan Anda akan melihat output berikut:

Akurasi: 80,66%

Tidak terlalu lusuh juga.

Mari kita lihat apakah kita dapat membangun model pembelajaran mendalam yang dapat melampaui atau setidaknya menyamai hasil ini. Jika kami mengelolanya, itu akan menjadi indikasi bagus bahwa model pembelajaran mendalam kami efektif setidaknya dalam mereplikasi hasil model pembelajaran mesin populer yang diinformasikan oleh keahlian domain.

Membangun Model

Hari ini, kita akan menggunakan Keras dengan Tensorflow untuk membangun model kita. Keras adalah library Python yang membuat pembuatan model deep learning menjadi sangat mudah dibandingkan dengan antarmuka Tensorflow API tingkat yang relatif rendah. Selain lapisan padat, kami juga akan menggunakan lapisan penyematan dan konvolusi untuk mempelajari informasi semantik yang mendasari kata-kata dan pola struktural potensial dalam data.

Pembersihan Data

Pertama, kita harus menyusun ulang data dengan cara yang dapat dengan mudah diproses dan dipahami oleh jaringan saraf kita. Kita dapat melakukan ini dengan mengganti kata-kata dengan angka pengenal yang unik. Dikombinasikan dengan vektor embedding, kami dapat merepresentasikan kata-kata dengan cara yang fleksibel dan sensitif secara semantik.

Dalam praktiknya, kami ingin menjadi sedikit lebih pintar tentang pra-pemrosesan ini. Masuk akal untuk fokus pada kata-kata yang umum digunakan, dan juga menyaring kata-kata yang paling umum digunakan (misalnya, the, this, a).

Kita dapat mengimplementasikan fungsi ini menggunakan Defaultdict dan NLTK. Tulis kode berikut ke dalam modul Python terpisah. Saya menempatkannya di lib/get_top_x_words.py .

 from nltk import word_tokenize from collections import defaultdict def count_top_x_words(corpus, top_x, skip_top_n): count = defaultdict(lambda: 0) for c in corpus: for w in word_tokenize(c): count[w] += 1 count_tuples = sorted([(w, c) for w, c in count.items()], key=lambda x: x[1], reverse=True) return [i[0] for i in count_tuples[skip_top_n: skip_top_n + top_x]] def replace_top_x_words_with_vectors(corpus, top_x): topx_dict = {top_x[i]: i for i in range(len(top_x))} return [ [topx_dict[w] for w in word_tokenize(s) if w in topx_dict] for s in corpus ], topx_dict def filter_to_top_x(corpus, n_top, skip_n_top=0): top_x = count_top_x_words(corpus, n_top, skip_n_top) return replace_top_x_words_with_vectors(corpus, top_x)

Sekarang kita siap untuk membangun modelnya. Kami menginginkan lapisan penyematan, lapisan konvolusi, dan lapisan padat untuk memanfaatkan semua fitur pembelajaran mendalam yang dapat membantu aplikasi kami. Dengan Keras, kita dapat membangun model dengan sangat sederhana:

 from keras.models import Sequential from keras.layers import Dense, Conv1D, Flatten from keras.layers.embeddings import Embedding from keras.preprocessing import sequence from keras.utils import to_categorical import pandas as pd from collections import Counter from sklearn.model_selection import train_test_split from lib.get_top_xwords import filter_to_top_x df = pd.read_csv('data/wine_data.csv') counter = Counter(df['variety'].tolist()) top_10_varieties = {i[0]: idx for idx, i in enumerate(counter.most_common(10))} df = df[df['variety'].map(lambda x: x in top_10_varieties)] description_list = df['description'].tolist() mapped_list, word_list = filter_to_top_x(description_list, 2500, 10) varietal_list_o = [top_10_varieties[i] for i in df['variety'].tolist()] varietal_list = to_categorical(varietal_list_o) max_review_length = 150 mapped_list = sequence.pad_sequences(mapped_list, maxlen=max_review_length) train_x, test_x, train_y, test_y = train_test_split(mapped_list, varietal_list, test_size=0.3) max_review_length = 150 embedding_vector_length = 64 model = Sequential() model.add(Embedding(2500, embedding_vector_length, input_length=max_review_length)) model.add(Conv1D(50, 5)) model.add(Flatten()) model.add(Dense(100, activation='relu')) model.add(Dense(max(varietal_list_o) + 1, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(train_x, train_y, epochs=3, batch_size=64) y_score = model.predict(test_x) y_score = [[1 if i == max(sc) else 0 for i in sc] for sc in y_score] n_right = 0 for i in range(len(y_score)): if all(y_score[i][j] == test_y[i][j] for j in range(len(y_score[i]))): n_right += 1 print("Accuracy: %.2f%%" % ((n_right/float(len(test_y)) * 100)))

Jalankan kode dan Anda akan melihat output berikut.

Akurasi: 77,20%

Ingatlah bahwa akurasi untuk naive Bayes dan SVC masing-masing adalah 73,56% dan 80,66%. Jadi jaringan saraf kami sangat menentang beberapa metode klasifikasi teks yang lebih umum di luar sana.

Kesimpulan

Hari ini, kami membahas membangun model pembelajaran mendalam klasifikasi untuk menganalisis ulasan anggur.

Kami menemukan bahwa kami mampu membangun model yang mampu bersaing dengan dan mengungguli beberapa algoritme pembelajaran mesin lainnya. Kami berharap Anda terinspirasi untuk menggunakan informasi ini untuk membangun aplikasi yang menganalisis kumpulan data yang lebih kompleks dan menghasilkan keluaran yang lebih kompleks!

Catatan: Anda dapat menemukan kode yang saya gunakan untuk artikel ini di GitHub.

Bacaan Lebih Lanjut di Blog Teknik Toptal:

• Arti Lebih Dalam: Pemodelan Topik dengan Python
• Cara Membuat Bot Analisis Sentimen Email: Tutorial NLP