Tujuan artikel ini adalah untuk membantu pembaca memahami cara memanfaatkan penyematan kata dan pembelajaran mendalam saat membuat pengklasifikasi teks.
Selain itu, bagian pemodelan teks yang sering diabaikan seperti apa itu penyematan kata, apa itu lapisan Penyematan, atau apa masukan untuk model pembelajaran mendalam akan dibahas di sini.
Terakhir, semua konsep akan dipraktikkan pada kumpulan data yang dipublikasikan dari twitter tentang apakah sebuah tweet berisi tentang bencana alam atau tidak.
Teknologi utama yang digunakan dalam artikel ini adalah Python dan Keras API.
Saluran klasifikasi teks yang berfungsi penuh dengan kumpulan data dari Twitter dapat ditemukan di sini: https://github.com/Eligijus112/twitter-genuine-tweets.
File penyematan kata yang digunakan dalam artikel ini dapat ditemukan di sini: https://nlp.stanford.edu/projects/glove/.
Alur pembuatan model pembelajaran mendalam menggunakan teks berlabel adalah sebagai berikut:
- Pisahkan data menjadi teks (X) dan label (Y)
- Praproses X
- Buat matriks penyematan kata dari X
- Buat masukan tensor dari X
- Latih model pembelajaran mendalam menggunakan masukan tensor dan label (Y)
- Membuat prediksi pada data baru
Pada artikel ini, saya akan membahas setiap langkah ini. Bagian pertama artikel ini akan membahas contoh kumpulan data kecil untuk mencakup semua konsep. Bagian kedua artikel ini akan menerapkan semua konsep ke dalam contoh kehidupan nyata mengenai apakah sebuah tweet tentang bencana alam atau tidak.
Komponen utama model pembelajaran mendalam yang menggunakan teks untuk membuat prediksi adalah penyematan kata.
Dari wiki:Penyematan kata adalah nama kolektif untuk serangkaian teknik "pemodelan bahasa" dan "pembelajaran fitur" dalam "pemrosesan bahasa alami" (NLP) di mana kata atau frasa dari kosakata dipetakan ke vektor bilangan real. Misalnya,
“ayah” = [0,1548, 0,4848, 1,864]
“ibu” = [0,8785, 0,8974, 2,794]
Singkatnya, penyematan kata adalah vektor numerik yang mewakili string.
Dalam praktiknya, representasi kata berupa vektor berdimensi 100, 200, atau 300 dan dilatih pada teks yang sangat besar.
Salah satu fitur yang sangat penting dari penyematan kata adalah bahwa kata-kata yang mirip dalam arti semantik memiliki jarak yang lebih kecil (baik Euclidean, kosinus, atau lainnya) di antara kata-kata tersebut dibandingkan kata-kata yang tidak memiliki hubungan semantik. Misalnya, kata-kata seperti “ibu” dan “ayah” seharusnya lebih dekat secara matematis daripada kata “ibu” dan “kecap” atau “ayah” dan “mentega”.
Fitur penting kedua dari penyematan kata adalah, saat membuat matriks masukan untuk model, tidak peduli berapa banyak kata unik yang kita miliki dalam korpus teks, kita akan memiliki jumlah kolom yang sama dalam matriks masukan. Ini adalah kemenangan besar jika dibandingkan dengan teknik pengkodean one-hot di mana jumlah kolom biasanya sama dengan jumlah kata unik dalam sebuah dokumen. Jumlahnya bisa ratusan ribu bahkan jutaan. Berurusan dengan matriks masukan yang sangat luas secara komputasi sangat menuntut.
Misalnya,
Bayangkan sebuah kalimat: Clark suka berjalan-jalan di taman.
Ada 7 kata unik di sini. Dengan menggunakan satu vektor berkode panas, kami akan merepresentasikan setiap kata dengan:
Clark = [1, 0, 0, 0, 0, 0, 0] likes = [0, 1, 0, 0, 0, 0, 0] to = [0, 0, 1, 0, 0, 0, 0] walk = [0, 0, 0, 1, 0, 0, 0] in = [0, 0, 0, 0, 1, 0, 0] the = [0, 0, 0, 0, 0, 1, 0] park = [0, 0, 0, 0, 0, 0, 1]
Sedangkan jika menggunakan embeddings kata 2 dimensi kita akan menangani vektor:
Clark = [0.13, 0.61] likes = [0.23, 0.66] to = [0.55, 0.11] walk = [0.03, 0.01] in = [0.15, 0.69] the = [0.99, 0.00] park = [0.98, 0.12]
Sekarang bayangkan memiliki kalimat n. Vektor dalam kasus enkode one-hot akan tumbuh secara eksponensial sedangkan vektor representasi kata yang disematkan akan tetap berukuran sama. Inilah sebabnya ketika bekerja dengan banyak teks, penyematan kata digunakan untuk mewakili kata, kalimat, atau keseluruhan dokumen.
Penyematan kata dibuat menggunakan jaringan saraf dengan satu lapisan masukan, satu lapisan tersembunyi, dan satu lapisan keluaran.
Untuk informasi lebih lanjut tentang membuat penyematan kata, kunjungi artikel:
Agar komputer dapat menentukan teks mana yang ‘baik’ dan mana yang ‘buruk’, kita perlu memberi label pada teks tersebut. Kelasnya bisa berapa saja dan kelas itu sendiri bisa mempunyai arti yang sangat beragam. Mari kita membuat beberapa teks:
d = [
('This article is awesome', 1),
('There are just too much words here', 0),
('The math is actually wrong here', 0),
('I really enjoy learning new stuff', 1),
('I am kinda lazy so I just skim these texts', 0),
('Who cares about AI?', 0),
('I will surely be a better person after reading this!', 1),
('The author is pretty cute :)', 1)
]
Kami memiliki 8 tupel dengan koordinat pertama adalah teks dan koordinat kedua adalah label. Label 0 berarti sentimen negatif dan label 1 berarti sentimen positif. Untuk membangun model yang berfungsi, kita memerlukan lebih banyak data (dalam praktik saya, seribu atau lebih titik data berlabel akan mulai memberikan hasil yang baik jika hanya ada dua kelas dan kelas-kelas tersebut seimbang).
Mari kita melakukan beberapa prapemrosesan teks klasik:
X_train = [x[0] for x in d] # Text Y_train = [y[1] for y in d] # Label X_train = [clean_text(x) for x in X_train]
Teks yang dibersihkan (X_train):
'this article is awesome' 'there are just too much words here' 'the math is actually wrong here' 'i really enjoy learning new stuff' 'i am kinda lazy so i just skim these texts' 'who cares about ai' 'i will surely be a better person after reading this' 'the author is pretty cute'
Label (Y_train):
[1, 0, 0, 1, 0, 0, 1, 1]
Sekarang kita memiliki teks yang telah diproses sebelumnya dalam matriks X_train dan matriks kelas Y_train, kita perlu membuat masukan untuk jaringan saraf.
Masukan model pembelajaran mendalam dengan lapisan Penyematan menggunakan matriks penyematan. Matriks penyematan adalah matriks yang ukuran barisnya sama dengan jumlah kata unik dalam dokumen dan memiliki ukuran kolom sebesar dimensi vektor penyematan. Jadi, untuk membuat matriks penyematan, seseorang perlu membuat vektor penyematan kata atau menggunakan penyematan kata yang telah dilatih sebelumnya. Dalam contoh ini, kita akan membaca file penyematan kata fiksi dan membuat matriks.
Format umum penyimpanan penyematan kata adalah dalamdokumen teks.
Mari kita panggil file penyematan di atas sebagai mini_embedding.txt. Untuk penggunaan salin-tempel cepat:
beautiful 1.5804182 0.25605154 boy -0.4558624 -1.5827272 can 0.9358587 -0.68037164 children -0.51683635 1.4153042 daughter 1.1436981 0.66987246 family -0.33289963 0.9955545
Dalam contoh ini, dimensi penyematan sama dengan 2 tetapi dalam kata penyematan dari tautan https://nlp.stanford.edu/projects/glove/, dimensinya adalah 300. Dalam kedua kasus tersebut, the strukturnya adalah kata adalah elemen pertama, diikuti oleh koefisien yang dipisahkan oleh spasi. Koordinatnya berakhir ketika ada pemisah garis baru di ujung garis.
Untuk membaca dokumen txt tersebut mari kita membuat kelas:
Anggap saja Anda memiliki file penyematan di folder embeddings.
embedding = Embeddings( 'embeddings/mini_embedding.txt', vector_dimension=2 ) embedding_matrix = embedding.create_embedding_matrix()
Kami belum memindai dokumen apa pun sehingga matriks penyematan akan mengembalikan semua kata yang ada di file mini_embeddings.txt:
array([[ 1.58041823, 0.25605154],
[-0.4558624 , -1.58272719],
[ 0.93585873, -0.68037164],
[-0.51683635, 1.41530418],
[ 1.1436981 , 0.66987246],
[-0.33289963, 0.99555451]])
Matriks penyematan akan selalu memiliki jumlah kolom yang sama dengan jumlah dimensi penyematan dan jumlah baris akan sama dengan jumlah kata unik dalam dokumen atau jumlah baris yang ditentukan pengguna.
Kecuali jika Anda memiliki RAM dalam jumlah besar di mesin Anda, umumnya disarankan untuk membuat matriks penyematan dengan menggunakan maksimal semua kata unik dari dokumen pelatihan yang digunakan untuk membuat matriks penyematan. Dalam file penyematan GloVe, terdapat jutaan kata, sebagian besar bahkan tidak muncul satu kali pun di sebagian besar dokumen teks. Oleh karena itu, sangat tidak disarankan untuk membuat matriks penyematan dengan semua kata unik dari file penyematan besar.
Penyematan kata yang telah dilatih sebelumnya dalam model pembelajaran mendalam dimasukkan ke dalam matriks dan digunakan di lapisan masukan sebagai bobot. Dari dokumentasi Keras API https://keras.io/layers/embeddings/:
keras.layers.Embedding(input_dim, output_dim,...) Turns positive integers (indexes) into dense vectors of fixed size. eg. [[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]] This layer can only be used as the first layer in a deep learning model.
Dua argumen masukan utama adalah input_dim dan output_dim.
input_dim sama dengan jumlah total kata unik dalam teks kita (atau sejumlah kata unik tertentu yang ditentukan pengguna).
output_dim sama dengan dimensi vektor yang disematkan.
Untuk membuat kamus kata unik kita akan menggunakan metode Tokenizer() dari perpustakaan Keras.
from keras.preprocessing.text import Tokenizer tokenizer = Tokenizer() tokenizer.fit_on_texts(X_train)
Sebagai pengingat, X_train kami yang telah diproses sebelumnya adalah:
'this article is awesome' 'there are just too much words here' 'the math is actually wrong here' 'i really enjoy learning new stuff' 'i am kinda lazy so i just skim these texts' 'who cares about ai' 'i will surely be a better person after reading this' 'the author is pretty cute'
Metode Tokenizer() membuat kamus internal berisi kata-kata unik dan memberikan bilangan bulat pada setiap kata. Keluaran dari tokenizer.word_index:
{'i': 1,
'is': 2,
'this': 3,
'just': 4,
'here': 5,
'the': 6,
'article': 7,
'awesome': 8,
'there': 9,
'are': 10,
'too': 11,
'much': 12,
'words': 13,
'math': 14,
'actually': 15,
'wrong': 16,
'really': 17,
'enjoy': 18,
'learning': 19,
'new': 20,
'stuff': 21,
'am': 22,
'kinda': 23,
'lazy': 24,
'so': 25,
'skim': 26,
'these': 27,
'texts': 28,
'who': 29,
'cares': 30,
'about': 31,
'ai': 32,
'will': 33,
'surely': 34,
'be': 35,
'a': 36,
'better': 37,
'person': 38,
'after': 39,
'reading': 40,
'author': 41,
'pretty': 42,
'cute': 43}
Ada 43 kata unik dalam teks X_train kami. Mari kita ubah teks menjadi daftar yang diindeks:
tokenizer.texts_to_sequences(X_train) [[3, 7, 2, 8], [9, 10, 4, 11, 12, 13, 5], [6, 14, 2, 15, 16, 5], [1, 17, 18, 19, 20, 21], [1, 22, 23, 24, 25, 1, 4, 26, 27, 28], [29, 30, 31, 32], [1, 33, 34, 35, 36, 37, 38, 39, 40, 3], [6, 41, 2, 42, 43]]
Kalimat pertama dalam matriks X_train 'artikel ini keren' diubah menjadi daftar [3, 7, 2, 8]. Indeks ini mewakili nilai-nilai kunci dalam kamus yang dibuat tokenizer:
{...
'is': 2,
'this': 3,
...
'article': 7,
'awesome': 8,
...}
Metode text_to_sequence() memberi kita daftar yang setiap itemnya memiliki dimensi berbeda dan tidak terstruktur. Setiap model pembelajaran mesin perlu mengetahui jumlah dimensi fitur dan jumlah tersebut harus sama untuk pelatihan dan prediksi pada observasi baru. Untuk mengubah urutan menjadi matriks yang terstruktur dengan baik untuk pelatihan pembelajaran mendalam, kita akan menggunakan metode pad_sequances() dari Keras:
import numpy as np from keras.preprocessing.sequence import pad_sequences # Getting the biggest sentence max_len = np.max([len(text.split()) for text in X_train]) # Creating the padded matrices X_train_NN = tokenizer.texts_to_sequences(X_train) X_train_NN = pad_sequences(string_list, maxlen=max_len)
Objek X_train_NN terlihat seperti:
array([[ 0, 0, 0, 0, 0, 0, 3, 7, 2, 8],
[ 0, 0, 0, 9, 10, 4, 11, 12, 13, 5],
[ 0, 0, 0, 0, 6, 14, 2, 15, 16, 5],
[ 0, 0, 0, 0, 1, 17, 18, 19, 20, 21],
[ 1, 22, 23, 24, 25, 1, 4, 26, 27, 28],
[ 0, 0, 0, 0, 0, 0, 29, 30, 31, 32],
[ 1, 33, 34, 35, 36, 37, 38, 39, 40, 3],
[ 0, 0, 0, 0, 0, 6, 41, 2, 42, 43]])
Jumlah baris sama dengan jumlah elemen X_train dan jumlah kolom sama dengan kalimat terpanjang (yaitu sama dengan 10 kata). Jumlah kolom biasanya ditentukan oleh pengguna bahkan sebelum membaca dokumen. Hal ini karena ketika bekerja dengan teks berlabel di kehidupan nyata, teks terpanjang bisa sangat panjang (ribuan kata) dan ini akan menyebabkan masalah dengan memori komputer saat melatih jaringan saraf.
Untuk membuat masukan yang rapi untuk jaringan saraf menggunakan teks yang telah diproses sebelumnya, saya menggunakan kelas TextToTensor yang saya tentukan:
Tensor adalah wadah yang dapat menampung data dalam dimensi N. Vektor dapat menampung data dalam 1 dimensi, matriks dapat menampungnya dalam 2 dimensi, dan tensor dapat menampungnya dalam N. Lebih lanjut tentang tensor:
https://www.kdnuggets.com/2018/05/wtf-tensor.html
Penggunaan penuh TextToTensor:
# Tokenizing the text tokenizer = Tokenizer() tokenizer.fit_on_texts(X_train) # Getting the longest sentence max_len = np.max([len(text.split()) for text in X_train]) # Converting to tensor TextToTensor_instance = TextToTensor( tokenizer=tokenizer, max_len=max_len ) X_train_NN = TextToTensor_instance.string_to_tensor(X_train)
Sekarang kita bisa membuat tensor dari teks, kita bisa mulai menggunakan lapisan Embedding dari Keras API.
from keras.models import Sequential from keras.layers import Embedding model = Sequential() model.add(Embedding( input_dim=44, output_dim=3, input_length=max_len)) model.compile('rmsprop', 'mse') output_array = model.predict(X_train_NN)[0]
Perhatikan bahwa di lapisan Embedding, input_dim sama dengan 44, namun teks kita hanya memiliki 43 kata unik. Ini karena definisi Penyematan di Keras API:
input_dim: int › 0. Ukuran kosakata, yaitu indeks bilangan bulat maksimum + 1.
Output_array terlihat seperti:
array([[-0.03353775, 0.01123261, 0.03025569],
[-0.03353775, 0.01123261, 0.03025569],
[-0.03353775, 0.01123261, 0.03025569],
[-0.03353775, 0.01123261, 0.03025569],
[-0.03353775, 0.01123261, 0.03025569],
[-0.03353775, 0.01123261, 0.03025569],
[ 0.04183744, -0.00413301, 0.04792741],
[-0.00870543, -0.00829206, 0.02079277],
[ 0.02819189, -0.04957005, 0.03384084],
[ 0.0394035 , -0.02159669, 0.01720046]], dtype=float32)
Urutan inputnya adalah (elemen pertama X_train_NN):
array([0, 0, 0, 0, 0, 0, 3, 7, 2, 8])
Lapisan Penyematan secara otomatis menetapkan vektor dengan ukuran output_dim ke bilangan bulat, yang dalam kasus kita sama dengan 3. Kita tidak memiliki kendali atas penghitungan bagian dalam tersebut dan vektor yang ditetapkan ke masing-masing indeks bilangan bulat tidak memiliki fitur yang kata-kata yang berkerabat dekat dalam arti semantik memiliki jarak yang lebih kecil di antara kata-kata tersebut dibandingkan dengan kata-kata yang memiliki arti semantik yang berbeda.
Untuk mengatasi masalah ini, kami akan menggunakan penyematan kata terlatih dari departemen NLP Stanford (https://nlp.stanford.edu/projects/glove/). Untuk membuat matriks penyematan kita akan menggunakan metode yang telah ditentukan sebelumnya.
Mari kita asumsikan bahwa X_train sekali lagi adalah daftar teks yang telah diproses sebelumnya.
embed_path = 'embeddings\\glove.840B.300d.txt' embed_dim = 300 # Tokenizing the text tokenizer = Tokenizer() tokenizer.fit_on_texts(X_train) # Creating the embedding matrix embedding = Embeddings(embed_path, embed_dim) embedding_matrix = embedding.create_embedding_matrix(tokenizer, len(tokenizer.word_counts))
Meskipun dokumen glove.840B.300d.txtmemiliki ratusan ribu kata unik, bentuk akhir matriks penyematan adalah (44, 300). Ini karena kami ingin menghemat memori sebanyak mungkin dan jumlah kata unik di seluruh dokumen kami sama dengan 44. Menyimpan koordinat semua kata lain dari dokumen txt akan sia-sia karena kita tidak akan menggunakannya di mana pun.
Untuk menggunakan matriks penyematan dalam model pembelajaran mendalam, kita perlu meneruskan matriks tersebut sebagai parameter bobot di lapisan Penyematan.
from keras.models import Sequential from keras.layers import Embedding# Converting to tensor TextToTensor_instance = TextToTensor( tokenizer=tokenizer, max_len=max_len ) X_train_NN = TextToTensor_instance.string_to_tensor(X_train)model = Sequential() model.add(Embedding( input_dim=44, output_dim=300, input_length=max_len, weights=[embedding_matrix])) model.compile('rmsprop', 'mse') output_array = model.predict(X_train_NN)[0]
Bentuk output_array sekarang menjadi (10, 300)dan outputnya terlihat seperti:
array([[ 0.18733 , 0.40595 , -0.51174 , ..., 0.16495 , 0.18757 ,
0.53874 ],
[ 0.18733 , 0.40595 , -0.51174 , ..., 0.16495 , 0.18757 ,
0.53874 ],
[ 0.18733 , 0.40595 , -0.51174 , ..., 0.16495 , 0.18757 ,
0.53874 ],
...,
[-0.34338 , 0.1677 , -0.1448 , ..., 0.095014, -0.073342,
0.47798 ],
[-0.087595, 0.35502 , 0.063868, ..., 0.03446 , -0.15027 ,
0.40673 ],
[ 0.16718 , 0.30593 , -0.13682 , ..., -0.035268, 0.1281 ,
0.023683]], dtype=float32)
Hingga saat ini kami telah membahas:
- Apa yang dimaksud dengan penyematan kata
- Membuat tensor dari teks
- Membuat matriks penyematan kata
- Apa itu lapisan Keras Tertanam
- Cara memanfaatkan matriks Penyematan
Sekarang mari kita gabungkan semuanya dan hadapi masalah kehidupan nyata yang menentukan apakah tweet dari twitter tentang bencana alam atau bukan.
# Importing generic python packages
import pandas as pd
# Reading the data
train = pd.read_csv('data/train.csv')[['text', 'target']]
test = pd.read_csv('data/test.csv')
# Creating the input for the pipeline
X_train = train['text'].tolist()
Y_train = train['target'].tolist()
X_test = test['text'].tolist()
Bentuk data kereta adalah (7613, 2),artinya, ada7613 tweet yang dapat digunakan. Mari kita periksa distribusi tweetnya:
train.groupby(['target'], as_index=False).count()
Seperti yang bisa kita lihat, kelas-kelasnya, setidaknya untuk kasus data dunia nyata, seimbang.
Contoh tweet yang “bagus”:
[ 'Our Deeds are the Reason of this #earthquake May ALLAH Forgive us all', 'Forest fire near La Ronge Sask. Canada', "All residents asked to 'shelter in place' are being notified by officers. No other evacuation or shelter in place orders are expected", '13,000 people receive #wildfires evacuation orders in California ', 'Just got sent this photo from Ruby #Alaska as smoke from #wildfires pours into a school' ]
Contoh tweet buruk:
[ "What's up man?", 'I love fruits', 'Summer is lovely', 'My car is so fast', 'What a goooooooaaaaaal!!!!!!' ]
Mari kita melakukan beberapa pemrosesan awal teks dan melihat kata-kata teratas:
# Counting the number of words
from collections import Counter
# Plotting functions
import matplotlib.pyplot as plt
X_train = [clean_text(text) for text in X_train]
Y_train = np.asarray(Y_train)
# Tokenizing the text
tokenizer = Tokenizer()
tokenizer.fit_on_texts(X_train)
# Getting the most frequent words
d1 = train.loc[train['target']==1, 'text'].tolist()
d0 = train.loc[train['target']==0, 'text'].tolist()
d1 = [clean_text(x, stop_words=stop_words) for x in d1]
d0 = [clean_text(x, stop_words=stop_words) for x in d0]
d1_text = ' '.join(d1).split()
d0_text = ' '.join(d0).split()
topd1 = Counter(d1_text)
topd0 = Counter(d0_text)
topd1 = topd1.most_common(20)
topd0 = topd0.most_common(20)
plt.bar(range(len(topd1)), [val[1] for val in topd1], align='center')
plt.xticks(range(len(topd1)), [val[0] for val in topd1])
plt.xticks(rotation=70)
plt.title('Disaster tweets')
plt.show()
plt.bar(range(len(topd0)), [val[1] for val in topd0], align='center')
plt.xticks(range(len(topd0)), [val[0] for val in topd0])
plt.xticks(rotation=70)
plt.title('Not disaster tweets')
plt.show()
Kata-kata bukan bencana lebih umum daripada kata-kata bencana. Kita mungkin berharap bahwa penyematan GloVe dan model pembelajaran mendalam akan mampu menangkap perbedaan ini.
Distribusi jumlah kata dalam setiap tweet:
Kita dapat mengatakan dari distribusi di atas bahwa membuat tensor masukan dengan ukuran kolom 20 hanya akan mengecualikan sejumlah kecil kata dalam tweet. Di sisi profesional, kami akan memenangkan banyak waktu komputasi.
Arsitektur model pembelajaran mendalam adalah sebagai berikut:
Pipeline yang merangkum semua yang disebutkan dalam artikel ini juga didefinisikan sebagai kelas dalam python:
Seluruh kode dan seluruh alur kerja dapat ditemukan di sini:
Untuk melatih model gunakan kode:
results = Pipeline( X_train=X_train, Y_train=Y_train, embed_path='embeddings\\glove.840B.300d.txt', embed_dim=300, stop_words=stop_words, X_test=X_test, max_len=20, epochs=10, batch_size=256 )
Sekarang mari kita membuat dua teks:
bagus = [“Kebakaran di Vilnius! Dimana pemadam kebakaran??? #keadaan darurat"]
buruk= [“Sushi atau pizza? Hidup itu sulit :(("]
TextToTensor_instance = TextToTensor( tokenizer=results.tokenizer, max_len=20 ) # Converting to tensors good_nn = TextToTensor_instance.string_to_tensor(good) bad_nn = TextToTensor_instance.string_to_tensor(bad) # Forecasting p_good = results.model.predict(good_nn)[0][0] p_bad = results.model.predict(bad_nn)[0][0]
p_bad = 0,014 dan p_good = 0,963. Kemungkinan-kemungkinan tersebut adalah untuk pertanyaan apakah sebuah tweet berisi tentang bencana atau tidak. Jadi tweet tentang sushi memiliki skor yang sangat rendah dan tweet tentang api memiliki skor yang besar. Artinya logika yang dipaparkan dalam artikel ini setidaknya bekerja pada kalimat yang dibuat-buat.
