Keras: Python Keras Text Classification - Revision history

Onnowpurbo: /* Penggunaan Pretrained Word Embeddings */

2019-08-14T01:30:32Z

Penggunaan Pretrained Word Embeddings

← Older revision		Revision as of 01:30, 14 August 2019
Line 634:		Line 634:
	idx = word_index[word]		idx = word_index[word]
	embedding_matrix[idx] = np.array(		embedding_matrix[idx] = np.array(
	vector, dtype=np.float32)[:embedding_dim]		vector, dtype=np.float32)[:embedding_dim]

	return embedding_matrix		return embedding_matrix

Line 642:		Line 641:
	embedding_dim = 50		embedding_dim = 50
	embedding_matrix = create_embedding_matrix(		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.		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 = np.count_nonzero(np.count_nonzero(embedding_matrix, axis=1))
	nonzero_elements / vocab_size		print(nonzero_elements / vocab_size)
	0.~~9507727532913566~~
			Hasilnya:

			0.9522330097087378

	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:		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:

Onnowpurbo: /* Penggunaan Pretrained Word Embeddings */

2019-08-14T01:25:05Z

Penggunaan Pretrained Word Embeddings

← Older revision		Revision as of 01:25, 14 August 2019
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:		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		the 0.418 0.24968 -0.41242 0.1217 0.34527 -0.04445

Onnowpurbo: /* Pranala Menarik */

2019-08-14T01:01:06Z

Pranala Menarik

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

	==Pranala Menarik==		==Pranala Menarik==

			* [[Keras]]

Onnowpurbo: /* Conclusion */

2019-08-14T00:56:28Z

Conclusion

← Older revision		Revision as of 00:56, 14 August 2019
Line 970:		Line 970:
	==Conclusion==		==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==		==Referensi==

Onnowpurbo: /* Optimasi Hyperparameters */

2019-08-14T00:48:37Z

Optimasi Hyperparameters

← Older revision		Revision as of 00:48, 14 August 2019
Line 869:		Line 869:
	return model		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],		param_grid = dict(num_filters=[32, 64, 128],
Line 879:		Line 879:
	maxlen=[100])		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.
			Instance yang dihasilkan dan parameter grid kemudian digunakan sebagai estimator di RandomSearchCV class.

	~~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		from keras.wrappers.scikit_learn import KerasClassifier
Line 946:		Line 947:
	f.write(output_string)		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		Running amazon data set
Line 963:		Line 964:
	Test Accuracy : 0.8384		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==		==Conclusion==

Onnowpurbo: /* Hyperparameters Optimization */

2019-08-14T00:38:30Z

Hyperparameters Optimization

← Older revision		Revision as of 00:38, 14 August 2019
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.		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):		def create_model(num_filters, kernel_size, vocab_size, embedding_dim, maxlen):

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

2019-08-14T00:29:42Z

1D Convolution (Image source)

← Older revision		Revision as of 00:29, 14 August 2019
Line 780:		Line 780:
	==1D Convolution (Image source)==		==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		embedding_dim = 100
Line 795:		Line 795:
	model.summary()		model.summary()

	~~The result will be as follows~~:		Hasilnya:

	_________________________________________________________________		_________________________________________________________________
Line 826:		Line 826:
	plot_history(history)		plot_history(history)

	~~The result will be as follows~~:		Hasilnya:

	Training Accuracy: 1.0000		Training Accuracy: 1.0000
	Testing Accuracy: 0.7700		Testing Accuracy: 0.7700

	~~loss~~ accuracy convolution ~~model~~		[[File:Loss-accuracy-convolution-model4.png\|center\|400px\|thumb]]
	~~Accuracy and loss for convolutional neural network~~

	~~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==		==Hyperparameters Optimization==

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

2019-08-14T00:24:33Z

Convolutional Neural Networks (CNN)

← 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)==

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

2019-08-14T00:23:11Z

Convolutional Neural Networks (CNN)

← Older revision		Revision as of 00:23, 14 August 2019
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.		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:
	~~one dimensional convolution~~

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

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

2019-08-14T00:18:52Z

Convolutional Neural Networks (CNN)

← Older revision		Revision as of 00:18, 14 August 2019
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.		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.

	~~This is the very core of the technique~~, ~~the mathematical process of convolution~~. ~~With each convolutional layer the~~ network ~~is able to detect more complex patterns~~. ~~In the~~ Feature Visualization by Chris Olah ~~you can get a good intuition what these features can look like~~.		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.

	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.		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.