Keras: Python Keras Text Classification - Revision history

Onnowpurbo: /* Penggunaan Pretrained Word Embeddings */

2019-08-14T01:30:32Z

Penggunaan Pretrained Word Embeddings

Onnowpurbo: /* Penggunaan Pretrained Word Embeddings */

2019-08-14T01:25:05Z

Penggunaan Pretrained Word Embeddings

Onnowpurbo: /* Pranala Menarik */

2019-08-14T01:01:06Z

Pranala Menarik

Onnowpurbo: /* Conclusion */

2019-08-14T00:56:28Z

Conclusion

Onnowpurbo: /* Optimasi Hyperparameters */

2019-08-14T00:48:37Z

Optimasi Hyperparameters

Onnowpurbo: /* Hyperparameters Optimization */

2019-08-14T00:38:30Z

Hyperparameters Optimization

Onnowpurbo: /* 1D Convolution (Image source) */

2019-08-14T00:29:42Z

1D Convolution (Image source)

Onnowpurbo: /* Convolutional Neural Networks (CNN) */

2019-08-14T00:24:33Z

Convolutional Neural Networks (CNN)

Onnowpurbo: /* Convolutional Neural Networks (CNN) */

2019-08-14T00:23:11Z

Convolutional Neural Networks (CNN)

Onnowpurbo: /* Convolutional Neural Networks (CNN) */

2019-08-14T00:18:52Z

Convolutional Neural Networks (CNN)

@@ Line 634: / Line 634: @@
                   idx = word_index[word]
                   embedding_matrix[idx] = np.array(
-                     vector, dtype=np.float32)[:embedding_dim]
+                         vector, dtype=np.float32)[:embedding_dim]
       return embedding_matrix
@@ Line 642: / Line 641: @@
   embedding_dim = 50
   embedding_matrix = create_embedding_matrix(
-     'data/glove_word_embeddings/glove.6B.50d.txt',
+         '/home/onno/TensorFlow/glove.6B/glove.6B.50d.txt',
-     tokenizer.word_index, embedding_dim)
+         tokenizer.word_index, embedding_dim)
 Sekarang kita siap menggunakan embedding matrix dalam training. Mari gunakan network sebelumnya dengan global max pooling dan lihat apakah kita bisa meningkatkan model ini. Saat kita menggunakan pretrained word embeddings  kita memiliki pilihan untuk memperbolehkan embedding diperbarui selama training atau hanya menggunakan embedding vectors yang dihasilkan apa adanya.
@@ Line 650: / Line 649: @@
   nonzero_elements = np.count_nonzero(np.count_nonzero(embedding_matrix, axis=1))
-  nonzero_elements / vocab_size
+  print(nonzero_elements / vocab_size)
-.9507727532913566
 Ini berarti 95.1% dari vocabulary tercakup oleh pretrained model, yang merupakan cakupan yang baik dari vocabulary kita. Mari kita lihat kinerja ketika menggunakan lapisan GlobalMaxPool1D:

@@ Line 617: / Line 617: @@
 Ini adalah file besar dengan 400.000 baris, dengan setiap baris mewakili kata yang diikuti oleh vektornya sebagai aliran floating point. Misalnya, berikut adalah 50 karakter pertama dari baris pertama:
-  $ head -n 1 data/glove_word_embeddings/glove.6B.50d.txt | cut -c-50
+  $ head -n 1 glove.6B/glove.6B.50d.txt | cut -c-50
       the 0.418 0.24968 -0.41242 0.1217 0.34527 -0.04445

← Older revision		Revision as of 01:01, 14 August 2019
Line 991:		Line 991:

	==Pranala Menarik==		==Pranala Menarik==
		+
		+	* [[Keras]]

@@ Line 970: / Line 970: @@
 ==Conclusion==
-There you have it: you have learned how to work with text classification with Keras, and we have gone from a bag-of-words model with logistic regression to increasingly more advanced methods leading to convolutional neural networks.
+Kita telah belajar cara bekerja dengan klasifikasi teks dengan Keras, dan kita telah beralih dari model bag-of-words dengan regresi logistik menjadi metode yang semakin maju yang mengarah ke convolutional neural networks.
-You should be now familiar with word embeddings, why they are useful, and also how to use pretrained word embeddings for your training. You have also learned how to work with neural networks and how to use hyperparameter optimization to squeeze more performance out of your model.
+Kita sekarang harus terbiasa dengan word embeddings, mengapa mereka berguna, dan juga bagaimana menggunakan pretrained word embeddings untuk training kita.  Kita juga telah belajar cara bekerja dengan neural network dan cara menggunakan optimasi hyperparameter untuk memeras lebih banyak kinerja dari model kita.
-One big topic which we have not covered here left for another time was recurrent neural networks, more specifically LSTM and GRU. Those are other powerful and popular tools to work with sequential data like text or time series. Other interesting developments are currently in neural networks that employ attention which are under active research and seem to be a promising next step since LSTM tend to be heavy on the computation.
+Satu topik besar yang belum kita bahas di sini dibiarkan lain waktu adalah recurrent neural networks, lebih khusus LSTM dan GRU. Itu adalah tool powerfull dan populer lainnya untuk bekerja dengan data sequential seperti teks atau time series. Perkembangan menarik lainnya saat ini dalam neural network yang menggunakan perhatian yang sedang dalam penelitian aktif dan tampaknya menjadi langkah berikutnya yang menjanjikan karena LSTM cenderung berat pada perhitungan.
-You have now an understanding of a crucial cornerstone in natural language processing which you can use for text classification of all sorts. Sentiment analysis is the most prominent example for this, but this includes many other applications such as:
+Kita sekarang memiliki pemahaman tentang landasan penting dalam natural language processing yang dapat kita gunakan untuk semua jenis text classification. Analisis sentimen adalah contoh yang paling menonjol untuk ini, tetapi ini mencakup banyak aplikasi lain seperti:
-* Spam detection in emails
+* Deteksi Spam di email
-* Automatic tagging of texts
+* Automatic tagging pada text
-* Categorization of news articles with predefined topics
+* Kategorisasi artikel berita untuk topik yang sudah di definisikan.
-You can use this knowledge and the models that you have trained on an advanced project as in this tutorial to employ sentiment analysis on a continuous stream of twitter data with Kibana and Elasticsearch. You could also combine sentiment analysis or text classification with speech recognition like in this handy tutorial using the SpeechRecognition library in Python.
+Kita dapat menggunakan pengetahuan ini dan model-model yang telah kita latih pada proyek lanjutan seperti dalam tutorial ini untuk menggunakan analisis sentimen pada  continuous stream data twitter dengan Kibana dan Elasticsearch. Kita juga bisa menggabungkan analisis sentimen atau  text classification dengan speech recognition seperti dalam tutorial praktis ini menggunakan library SpeechRecognition di Python.
 ==Referensi==

@@ Line 869: / Line 869: @@
       return model
-Next, you want to define the parameter grid that you want to use in training. This consists of a dictionary with each parameters named as in the previous function. The number of spaces on the grid is 3 * 3 * 1 * 1 * 1, where each of those numbers is the number of different choices for a given parameter.
+Selanjutnya, kita ingin menentukan parameter grid yang ingin kita gunakan dalam training. Ini terdiri dari dictionary dengan masing-masing parameter dalam fungsi sebelumnya. Jumlah spasi di grid adalah 3 * 3 * 1 * 1 * 1, di mana masing-masing angka tersebut adalah jumlah pilihan yang berbeda untuk parameter yang diberikan.
-You can see how this could get computationally expensive very quickly, but luckily both grid search and random search are embarrassingly parallel, and the classes come with an n_jobs parameter that lets you test grid spaces in parallel. The parameter grid is initialized with the following dictionary:
+Kita dapat melihat bagaimana ini bisa menjadi komputasi yang mahal dengan sangat cepat, tetapi untungnya grid search dan random search sebetulnya paralel, dan class muncul dengan parameter n_jobs yang memungkinkan kita menguji ruang grid secara paralel. Kotak parameter diinisialisasi dengan dictionary berikut:
   param_grid = dict(num_filters=[32, 64, 128],
@@ Line 879: / Line 879: @@
                     maxlen=[100])
-Now you are already ready to start running the random search. In this example we iterate over each data set and then you want to preprocess the data in the same way as previously. Afterwards you take the previous function and add it to the KerasClassifier wrapper class including the number of epochs.
+Sekarang kita sudah siap untuk mulai menjalankan random search. Dalam contoh ini kita mengulang setiap set data dan kemudian kita ingin memproses ulang data dengan cara yang sama seperti sebelumnya. Setelah itu kita mengambil fungsi sebelumnya dan menambahkannya ke KerasClassifier wrapper class termasuk jumlah epoch.
-The resulting instance and the parameter grid are then used as the estimator in the RandomSearchCV class. Additionally, you can choose the number of folds in the k-folds cross-validation, which is in this case 4. You have seen most of the code in this snippet before in our previous examples. Besides the RandomSearchCV and KerasClassifier, I have added a little block of code handling the evaluation:
+Selain itu, kita dapat memilih jumlah fold dalam k-folds cross-validation, yang dalam kasus ini 4. Kita telah melihat sebagian besar kode dalam cuplikan ini sebelumnya dalam contoh sebelumnya. Selain RandomSearchCV dan KerasClassifier,  telah menambahkan sedikit kode untuk penanganan evaluasi:
   from keras.wrappers.scikit_learn import KerasClassifier
@@ Line 946: / Line 947: @@
           f.write(output_string)
-This takes a while which is a perfect chance to go outside to get some fresh air or even go on a hike, depending on how many models you want to run. Let’s take a look what we have got:
+Ini membutuhkan waktu yang merupakan kesempatan sempurna untuk pergi keluar untuk mendapatkan udara segar atau bahkan mendaki gunung, tergantung pada berapa banyak model yang ingin kita jalankan. Mari kita lihat apa yang kita punya:
   Running amazon data set
@@ Line 963: / Line 964: @@
   Test Accuracy : 0.8384
-Interesting! For some reason the testing accuracy is higher than the training accuracy which might be because there is a large variance in the scores during cross-validation. We can see that we were still not able to break much through the dreaded 80%, which seems to be a natural limit for this data with its given size. Remember that we have a small data set and convolutional neural networks tend to perform the best with large data sets.
+Menarik! Untuk beberapa hal maka akurasi testing lebih tinggi daripada akurasi training yang mungkin karena ada perbedaan besar dalam skor selama cross-validation. Kita dapat melihat bahwa kita masih tidak dapat menembus banyak melalui 80% yang ditakuti, yang tampaknya menjadi batas alami untuk data ini dengan ukuran yang diberikan. Ingat bahwa kita memiliki satu set data kecil dan convolutional neural networks cenderung melakukan yang terbaik dengan set data besar.
-Another method for CV is the nested cross-validation (shown here) which is used when the hyperparameters also need to be optimized. This is used because the resulting non-nested CV model has a bias toward the data set which can lead to an overly optimistic score. You see, when doing hyperparameter optimization as we did in the previous example, we are picking the best hyperparameters for that specific training set but this does not mean that these hyperparameters generalize the best.
+Metode lain untuk CV adalah nested cross-validation (ditampilkan di sini) yang digunakan ketika hyperparameters juga perlu dioptimalkan. Ini digunakan karena model non-nested CV yang dihasilkan memiliki bias terhadap kumpulan data yang dapat menyebabkan skor terlalu optimis. Kita tahu, ketika melakukan optimasi hiperparameter seperti yang kita lakukan dalam contoh sebelumnya, kita memilih hyperparameter terbaik untuk set training tertentu tetapi ini tidak berarti bahwa hyperparameter ini menggeneralisasi yang terbaik.
 ==Conclusion==

@@ Line 841: / Line 841: @@
 CNN bekerja paling baik dengan training set yang besar di mana mereka dapat menemukan generalisasi di mana model sederhana seperti regresi logistik tidak akan mampu.
-==Hyperparameters Optimization==
+==Optimasi Hyperparameters==
-One crucial steps of deep learning and working with neural networks is hyperparameter optimization.
+Salah satu langkah penting dalam deep learnig dan bekerja dengan neural network adalah optimasi hyperparameter.
-As you saw in the models that we have used so far, even with simpler ones, you had a large number of parameters to tweak and choose from. Those parameters are called hyperparameters. This is the most time consuming part of machine learning and sadly there are no one-fits-all solutions ready.
+Seperti yang kita lihat dalam model yang telah kita gunakan sejauh ini, bahkan dengan model yang lebih sederhana, kita memiliki sejumlah besar parameter untuk di-tweak dan dipilih. Parameter tersebut disebut hyperparameters. Ini adalah bagian yang paling memakan waktu dari machine learning dan sayangnya tidak ada solusi yang cocok untuk semua.
-When you have a look at the competitions on Kaggle, one of the largest places to compete against other fellow data scientists, you can see that many of the winning teams and models have gone through a lot of tweaking and experimenting until they reached their prime. So don’t get discouraged when it gets tough and you reach a plateau, but rather think about the ways you could optimize the model or the data.
+Ketika anda melihat kompetisi di Kaggle, salah satu tempat terbesar untuk bersaing dengan sesama ilmuwan data lainnya, anda dapat melihat bahwa banyak tim dan model pemenang telah melalui banyak penyesuaian dan percobaan hingga mencapai puncaknya. Jadi jangan berkecil hati ketika menjadi sulit dan anda mencapai dataran tinggi, tetapi pikirkan cara anda dapat mengoptimalkan model atau data.
-One popular method for hyperparameter optimization is grid search. What this method does is it takes lists of parameters and it runs the model with each parameter combination that it can find. It is the most thorough way but also the most computationally heavy way to do this. Another common way, random search, which you’ll see in action here, simply takes random combinations of parameters.
+Salah satu metode populer untuk optimasi hyperparameter adalah grid search. Apa yang dilakukan metode ini adalah mengambil daftar parameter dan menjalankan model dengan setiap kombinasi parameter yang dapat ditemukannya. Ini adalah cara yang paling menyeluruh tetapi juga cara yang paling berat secara komputasi untuk melakukan ini. Cara umum lain, pencarian acak, yang akan kita lihat dalam tindakan di sini, cukup mengambil kombinasi parameter secara acak.
-In order to apply random search with Keras, you will need to use the KerasClassifier which serves as a wrapper for the scikit-learn API. With this wrapper you are able to use the various tools available with scikit-learn like cross-validation. The class that you need is RandomizedSearchCV which implements random search with cross-validation. Cross-validation is a way to validate the model and take the whole data set and separate it into multiple testing and training data sets.
+Untuk menerapkan random search dengan Keras, kita harus menggunakan KerasClassifier yang berfungsi sebagai pembungkus untuk scikit-learn API. Dengan pembungkus ini kita dapat menggunakan berbagai tool yang tersedia dengan scikit-learn seperti cross-validation. Class yang kita butuhkan adalah RandomizedSearchCV yang mengimplementasikan random search dengan cross-validation.  Cross-validation adalah cara untuk memvalidasi model dan mengambil seluruh rangkaian data dan memisahkannya menjadi beberapa data set testing dan training.
-There are various types of cross-validation. One type is the k-fold cross-validation which you’ll see in this example. In this type the data set is partitioned into k equal sized sets where one set is used for testing and the rest of the partitions are used for training. This enables you to run k different runs, where each partition is once used as a testing set. So, the higher k is the more accurate the model evaluation is, but the smaller each testing set is.
+Ada berbagai jenis cross-validation. Salah satu jenis adalah cross-validation k-fold yang akan kita lihat dalam contoh ini. Dalam tipe ini set data dipartisi ke dalam k set ukuran yang sama di mana satu set digunakan untuk testing dan sisanya dari partisi digunakan untuk training. Ini memungkinkan kita untuk menjalankan k dalam berbagai proses yang berbeda, di mana setiap partisi pernah digunakan sebagai set testing. Jadi, semakin tinggi k adalah semakin akurat model evaluasi, tetapi semakin kecil setiap set testing-nya.
-First step for KerasClassifier is to have a function that creates a Keras model. We will use the previous model, but we will allow various parameters to be set for the hyperparameter optimization:
+Langkah pertama untuk KerasClassifier adalah memiliki fungsi yang menciptakan model Keras. Kita akan menggunakan model sebelumnya, tetapi kita akan mengizinkan berbagai parameter ditetapkan untuk optimasi hyperparameter:
   def create_model(num_filters, kernel_size, vocab_size, embedding_dim, maxlen):

@@ Line 780: / Line 780: @@
 ==1D Convolution (Image source)==
-Now let’s have a look how you can use this network in Keras. Keras offers again various Convolutional layers which you can use for this task. The layer you’ll need is the Conv1D layer. This layer has again various parameters to choose from. The ones you are interested in for now are the number of filters, the kernel size, and the activation function. You can add this layer in between the Embedding layer and the GlobalMaxPool1D layer:
+Sekarang mari kita lihat bagaimana kita dapat menggunakan network ini di Keras. Keras menawarkan lagi berbagai lapisan konvolusional yang dapat kita gunakan untuk tugas ini. Lapisan yang kita butuhkan adalah lapisan Conv1D. Lapisan ini memiliki lagi berbagai parameter untuk dipilih. Yang kita minati saat ini adalah jumlah filter, ukuran kernel, dan fungsi aktivasi. Kita bisa menambahkan lapisan ini di antara lapisan Embedding dan lapisan GlobalMaxPool1D:
   embedding_dim = 100
@@ Line 795: / Line 795: @@
   model.summary()
-The result will be as follows:
+Hasilnya:
   _________________________________________________________________
@@ Line 826: / Line 826: @@
   plot_history(history)
-The result will be as follows:
+Hasilnya:
   Training Accuracy: 1.0000
   Testing Accuracy:  0.7700
-loss accuracy convolution model
+[[File:Loss-accuracy-convolution-model4.png|center|400px|thumb]]
-You can see that 80% accuracy seems to be tough hurdle to overcome with this data set and a CNN might not be well equipped. The reason for such a plateau might be that:
+Anda dapat melihat bahwa accuracy 80% tampaknya merupakan rintangan yang sulit untuk diatasi dengan kumpulan data ini dan CNN mungkin tidak dilengkapi dengan baik. Alasan untuk dataran tinggi accuracy seperti itu adalah:
-    There are not enough training samples
+* Tidak cukup banyak sample training
-    The data you have does not generalize well
+* Data yang kita miliki kurang generalize
-    Missing focus on tweaking the hyperparameters
+* Gagal fokus saat mengatur hyperparameters
-CNNs work best with large training sets where they are able to find generalizations where a simple model like logistic regression won’t be able.
+CNN bekerja paling baik dengan training set yang besar di mana mereka dapat menemukan generalisasi di mana model sederhana seperti regresi logistik tidak akan mampu.
 ==Hyperparameters Optimization==

← Older revision		Revision as of 00:24, 14 August 2019
Line 775:		Line 775:

	Pada gambar berikut, kita dapat melihat bagaimana konvolusi bekerja. Dimulai dengan menambahkan patch fitur input dengan ukuran kernel filter. Dengan patch ini, kita mengambil produk dot dari Weight filter yang dikalikan. Convnet satu dimensi tidak sama dengan terjemahan, yang berarti bahwa urutan tertentu dapat dikenali pada posisi yang berbeda. Ini dapat membantu untuk pola-pola tertentu dalam teks:		Pada gambar berikut, kita dapat melihat bagaimana konvolusi bekerja. Dimulai dengan menambahkan patch fitur input dengan ukuran kernel filter. Dengan patch ini, kita mengambil produk dot dari Weight filter yang dikalikan. Convnet satu dimensi tidak sama dengan terjemahan, yang berarti bahwa urutan tertentu dapat dikenali pada posisi yang berbeda. Ini dapat membantu untuk pola-pola tertentu dalam teks:
		+
		+	[[File:1d-convolution.png\|center\|400px\|thumb]]

	==1D Convolution (Image source)==		==1D Convolution (Image source)==

@@ Line 770: / Line 770: @@
 CNN memiliki lapisan tersembunyi yang disebut lapisan konvolusional. Ketika kita membayangkan sebuah gambar, komputer harus berurusan dengan matrix dua dimensi angka dan oleh karena itu kita perlu beberapa cara untuk mendeteksi fitur dalam matrix ini. Lapisan konvolusional ini mampu mendeteksi tepi, sudut dan jenis tekstur lainnya yang menjadikannya tool yang istimewa. Lapisan convolutional terdiri dari beberapa filter yang digeser melintasi gambar dan dapat mendeteksi fitur-fitur tertentu.
-Ini adalah inti dari tekniknya, proses konvolusi matematika. Dengan setiap lapisan konvolusional, network dapat mendeteksi pola yang lebih kompleks. Dalam Feature Visualization oleh Chris Olah kita bisa mendapatkan intuisi yang baik seperti apa fitur-fitur ini.
+Ini adalah inti dari tekniknya, proses konvolusi matematika. Dengan setiap lapisan konvolusional, network dapat mendeteksi pola yang lebih kompleks. Dalam Feature Visualization https://distill.pub/2017/feature-visualization/ oleh Chris Olah kita bisa mendapatkan intuisi yang baik seperti apa fitur-fitur ini.
-When you are working with sequential data, like text, you work with one dimensional convolutions, but the idea and the application stays the same. You still want to pick up on patterns in the sequence which become more complex with each added convolutional layer.
+Saat kita bekerja dengan data sekuensial, seperti teks, kita bekerja dengan konvolusi satu dimensi, tetapi gagasan dan aplikasinya tetap sama. Kita masih ingin menangkap pola dalam urutan yang menjadi lebih kompleks dengan setiap lapisan konvolusional yang ditambahkan.
-In the next figure you can see how such a convolution works. It starts by taking a patch of input features with the size of the filter kernel. With this patch you take the dot product of the multiplied weights of the filter. The one dimensional convnet is invariant to translations, which means that certain sequences can be recognized at a different position. This can be helpful for certain patterns in the text:
+Pada gambar berikut, kita dapat melihat bagaimana konvolusi bekerja. Dimulai dengan menambahkan patch fitur input dengan ukuran kernel filter. Dengan patch ini, kita mengambil produk dot dari Weight filter yang dikalikan. Convnet satu dimensi tidak sama dengan terjemahan, yang berarti bahwa urutan tertentu dapat dikenali pada posisi yang berbeda. Ini dapat membantu untuk pola-pola tertentu dalam teks:
 ==1D Convolution (Image source)==