Apa itu Convolutional Neural Network?
Jaringan saraf konvolusional, juga dikenal sebagai konvnet atau CNN, adalah metode terkenal dalam aplikasi visi komputer. Jenis arsitektur ini dominan mengenali objek dari sebuah gambar atau video.
Dalam tutorial ini, Anda akan mempelajari cara membuat konvnet dan cara menggunakan TensorFlow untuk menyelesaikan set data tulisan tangan.
Dalam tutorial ini, Anda akan belajar
- Jaringan Neural Konvolusional
- Arsitektur Jaringan Neural Konvolusional
- Komponen Convnet
- Latih CNN dengan TensorFlow
- Langkah 1: Unggah Set Data
- Langkah 2: Masukkan lapisan
- Langkah 3: Lapisan konvolusional
- Langkah 4: Pooling layer
- Langkah 5: Lapisan Konvolusional Kedua dan Lapisan Penyatuan
- Langkah 6: Lapisan padat
- Langkah 7: Logit Layer
Arsitektur Jaringan Neural Konvolusional
Pikirkan tentang Facebook beberapa tahun yang lalu, setelah Anda mengunggah gambar ke profil Anda, Anda diminta untuk menambahkan nama ke wajah pada gambar secara manual. Saat ini, Facebook menggunakan convnet untuk menandai teman Anda di gambar secara otomatis.
Jaringan saraf konvolusional tidak terlalu sulit untuk dipahami. Gambar masukan diproses selama fase konvolusi dan kemudian diberi label.
Arsitektur konvnet yang khas dapat diringkas pada gambar di bawah ini. Pertama-tama, gambar didorong ke jaringan; ini disebut gambar masukan. Kemudian, citra masukan melalui langkah-langkah yang tak terhingga jumlahnya; ini adalah bagian jaringan yang konvolusional. Akhirnya, jaringan saraf dapat memprediksi digit pada gambar.
Sebuah gambar terdiri dari larik piksel dengan tinggi dan lebar. Gambar grayscale hanya memiliki satu saluran sedangkan gambar berwarna memiliki tiga saluran (masing-masing untuk Merah, Hijau, dan Biru). Saluran ditumpuk satu sama lain. Dalam tutorial ini, Anda akan menggunakan gambar grayscale dengan hanya satu saluran. Setiap piksel memiliki nilai dari 0 hingga 255 untuk mencerminkan intensitas warna. Misalnya, piksel sama dengan 0 akan menunjukkan warna putih sedangkan piksel dengan nilai mendekati 255 akan lebih gelap.
Mari kita lihat gambar yang disimpan dalam dataset MNIST. Gambar di bawah ini menunjukkan bagaimana merepresentasikan gambar kiri dalam format matriks. Perhatikan bahwa matriks asli telah distandarisasi antara 0 dan 1. Untuk warna yang lebih gelap, nilai dalam matriks sekitar 0,9 sedangkan piksel putih memiliki nilai 0.
Operasi konvolusional
Komponen paling penting dalam model ini adalah lapisan konvolusional. Bagian ini bertujuan untuk mengurangi ukuran gambar untuk komputasi bobot yang lebih cepat dan meningkatkan generalisasinya.
Selama bagian konvolusional, jaringan menyimpan fitur-fitur penting dari gambar dan mengecualikan noise yang tidak relevan. Misalnya, model belajar mengenali gajah dari gambar dengan latar gunung. Jika Anda menggunakan jaringan neural tradisional, model akan memberikan bobot ke semua piksel, termasuk yang berasal dari gunung yang tidak penting dan dapat menyesatkan jaringan.
Sebaliknya, jaringan saraf konvolusional akan menggunakan teknik matematika untuk mengekstrak hanya piksel yang paling relevan. Operasi matematika ini disebut konvolusi. Teknik ini memungkinkan jaringan untuk mempelajari fitur yang semakin kompleks di setiap lapisan. Konvolusi membagi matriks menjadi bagian-bagian kecil untuk mempelajari elemen paling penting dalam setiap bagian.
Komponen Convnet
Ada empat komponen Convnet
- Lilitan
- Non Linearitas (ULT)
- Pooling atau Sub Sampling
- Klasifikasi (Lapisan Terhubung Sepenuhnya)
- Lilitan
Tujuan konvolusi adalah untuk mengekstrak fitur objek pada citra secara lokal. Artinya, jaringan akan mempelajari pola tertentu di dalam gambar dan akan dapat mengenalinya di mana pun dalam gambar.
Konvolusi adalah perkalian berdasarkan elemen. Konsepnya mudah dimengerti. Komputer akan memindai sebagian gambar, biasanya dengan dimensi 3x3 dan menggandakannya menjadi filter. Keluaran dari perkalian bijak disebut peta fitur. Langkah ini diulangi sampai semua gambar dipindai. Perhatikan bahwa, setelah konvolusi, ukuran gambar dikurangi.
Di bawah ini, ada URL untuk melihat bagaimana konvolusi bekerja.
Ada banyak saluran yang tersedia. Di bawah ini, kami mencantumkan beberapa saluran. Anda dapat melihat bahwa setiap filter memiliki tujuan tertentu. Perhatikan, pada gambar di bawah ini; Kernel adalah sinonim dari filter.
Sumber
Aritmatika di balik konvolusi
Fase konvolusional akan menerapkan filter pada array kecil piksel di dalam gambar. Filter akan bergerak di sepanjang gambar masukan dengan bentuk umum 3x3 atau 5x5. Ini berarti jaringan akan menggeser jendela ini di semua gambar masukan dan menghitung konvolusi. Gambar di bawah ini menunjukkan bagaimana konvolusi beroperasi. Ukuran tambalan adalah 3x3, dan matriks keluaran adalah hasil dari operasi bijak-elemen antara matriks gambar dan filter.
Sumber
Anda perhatikan bahwa lebar dan tinggi output bisa berbeda dari lebar dan tinggi input. Itu terjadi karena efek perbatasan.
Efek perbatasan
Gambar memiliki peta fitur 5x5 dan filter 3x3. Hanya ada satu jendela di tengah tempat filter dapat menyaring kisi 3x3. Peta fitur keluaran akan menyusut dua petak bersama dengan dimensi 3x3.
Untuk mendapatkan dimensi keluaran yang sama dengan dimensi masukan, Anda perlu menambahkan bantalan. Pengisi terdiri dari penambahan jumlah baris dan kolom yang tepat di setiap sisi matriks. Ini akan memungkinkan konvolusi untuk menyesuaikan dengan setiap ubin masukan. Pada gambar di bawah ini, matriks input / output memiliki dimensi yang sama yaitu 5x5
Saat Anda menentukan jaringan, fitur berbelit-belit dikontrol oleh tiga parameter:
- Kedalaman: Ini menentukan jumlah filter yang akan diterapkan selama konvolusi. Pada contoh sebelumnya, Anda melihat kedalaman 1, artinya hanya satu filter yang digunakan. Dalam kebanyakan kasus, ada lebih dari satu filter. Gambar di bawah ini menunjukkan operasi yang dilakukan dalam situasi dengan tiga filter
- Stride: Ini mendefinisikan jumlah "lompatan piksel" antara dua irisan. Jika langkahnya sama dengan 1, jendela akan bergerak dengan sebaran piksel satu. Jika langkahnya sama dengan dua, jendela akan melompat sebesar 2 piksel. Jika Anda meningkatkan langkahnya, Anda akan memiliki peta fitur yang lebih kecil.
Contoh langkah 1
Langkah gambar 2
- Zero-padding: Padding adalah operasi penambahan jumlah baris dan kolom yang sesuai di setiap sisi peta fitur masukan. Dalam hal ini, keluaran memiliki dimensi yang sama dengan masukan.
- Non Linearitas (ULT)
Pada akhir operasi konvolusi, output dikenakan fungsi aktivasi untuk memungkinkan non-linearitas. Fungsi aktivasi biasa untuk konvnet adalah Relu. Semua piksel dengan nilai negatif akan diganti dengan nol.
- Operasi penggabungan maksimal
Langkah ini mudah dimengerti. Tujuan dari pooling adalah untuk mengurangi dimensi citra masukan. Langkah-langkah tersebut dilakukan untuk mengurangi kompleksitas operasi komputasi. Dengan mengurangi dimensionalitas, jaringan memiliki bobot yang lebih rendah untuk dihitung, sehingga mencegah overfitting.
Pada tahap ini, Anda perlu menentukan ukuran dan langkahnya. Cara standar untuk mengumpulkan gambar masukan adalah dengan menggunakan nilai maksimum peta fitur. Lihatlah gambar di bawah ini. The "pooling" akan menyaring empat submatrix dari peta fitur 4x4 dan mengembalikan nilai maksimum. Penggabungan mengambil nilai maksimum dari larik 2x2 dan kemudian memindahkan jendela ini sebanyak dua piksel. Misalnya, sub-matriks pertama adalah [3,1,3,2], penggabungan akan menghasilkan nilai maksimum, yaitu 3.
Ada operasi penggabungan lain seperti mean.
Operasi ini secara agresif mengurangi ukuran peta fitur
- Lapisan yang terhubung sepenuhnya
Langkah terakhir terdiri dari membangun jaringan saraf tiruan tradisional seperti yang Anda lakukan di tutorial sebelumnya. Anda menghubungkan semua neuron dari lapisan sebelumnya ke lapisan berikutnya. Anda menggunakan fungsi aktivasi softmax untuk mengklasifikasikan nomor pada gambar masukan.
Rekap:
Jaringan Neural Konvolusional menyusun berbagai lapisan sebelum membuat prediksi. Jaringan saraf memiliki:
- Lapisan konvolusional
- Fungsi Relu Activation
- Lapisan penggabungan
- Lapisan yang sangat terhubung
Lapisan konvolusional menerapkan filter berbeda pada subkawasan gambar. Fungsi aktivasi Relu menambahkan non-linearitas, dan lapisan penyatuan mengurangi dimensi peta fitur.
Semua lapisan ini mengekstrak informasi penting dari gambar. Terakhir, peta fitur diumpankan ke lapisan utama yang terhubung sepenuhnya dengan fungsi softmax untuk membuat prediksi.
Latih CNN dengan TensorFlow
Sekarang setelah Anda terbiasa dengan elemen penyusun konvnet, Anda siap untuk membuatnya dengan TensorFlow. Kami akan menggunakan dataset MNIST untuk klasifikasi gambar.
Penyusunan datanya sama dengan tutorial sebelumnya. Anda dapat menjalankan kode dan melompat langsung ke arsitektur CNN.
Anda akan mengikuti langkah-langkah di bawah ini:
Langkah 1: Unggah Set Data
Langkah 2: Masukkan lapisan
Langkah 3: Lapisan konvolusional
Langkah 4: Pooling layer
Langkah 5: Lapisan Konvolusional Kedua dan Lapisan Penyatuan
Langkah 6: Lapisan padat
Langkah 7: Logit Layer
Langkah 1: Unggah Set Data
Dataset MNIST tersedia dengan scikit untuk dipelajari di URL ini. Silakan unduh dan simpan di Unduhan. Anda dapat mengunggahnya dengan fetch_mldata ('MNIST original').
Buat set kereta / pengujian
Anda perlu membagi dataset dengan train_test_split
Skala fitur
Terakhir, Anda dapat menskalakan fitur dengan MinMaxScaler
import numpy as npimport tensorflow as tffrom sklearn.datasets import fetch_mldata#Change USERNAME by the username of your machine## Windows USERmnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')## Mac Usermnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')print(mnist.data.shape)print(mnist.target.shape)from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)y_train = y_train.astype(int)y_test = y_test.astype(int)batch_size =len(X_train)print(X_train.shape, y_train.shape,y_test.shape )## resclaefrom sklearn.preprocessing import MinMaxScalerscaler = MinMaxScaler()# TrainX_train_scaled = scaler.fit_transform(X_train.astype(np.float64))# testX_test_scaled = scaler.fit_transform(X_test.astype(np.float64))feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]X_train_scaled.shape[1:]
Tentukan CNN
CNN menggunakan filter pada piksel mentah suatu gambar untuk mempelajari pola detail dibandingkan dengan pola global dengan jaringan saraf tradisional. Untuk membuat CNN, Anda perlu menentukan:
- Lapisan konvolusional: Terapkan sejumlah n filter ke peta fitur. Setelah konvolusi, Anda perlu menggunakan fungsi aktivasi Relu untuk menambahkan non-linearitas ke jaringan.
- Pooling layer: Langkah selanjutnya setelah konvolusi adalah downsample fitur maks. Tujuannya adalah untuk mengurangi dimensi peta fitur untuk mencegah overfitting dan meningkatkan kecepatan komputasi. Penggabungan maksimum adalah teknik konvensional, yang membagi peta fitur menjadi subkawasan (biasanya dengan ukuran 2x2) dan hanya menyimpan nilai maksimum.
- Lapisan terhubung sepenuhnya: Semua neuron dari lapisan sebelumnya terhubung ke lapisan berikutnya. CNN akan mengklasifikasikan label menurut fitur dari lapisan konvolusional dan dikurangi dengan lapisan penyatuan.
Arsitektur CNN
- Convolutional Layer: Menerapkan 14 filter 5x5 (mengekstrak subregional 5x5-piksel), dengan fungsi aktivasi ULT
- Lapisan Penggabungan: Melakukan penggabungan maksimal dengan filter 2x2 dan langkah 2 (yang menentukan bahwa wilayah yang digabungkan tidak tumpang tindih)
- Convolutional Layer: Menerapkan 36 filter 5x5, dengan fungsi aktivasi ULT
- Pooling Layer # 2: Sekali lagi, lakukan penggabungan maksimal dengan filter 2x2 dan langkah 2
- 1.764 neuron, dengan tingkat regularisasi putus 0,4 (probabilitas 0,4 bahwa setiap elemen tertentu akan dijatuhkan selama pelatihan)
- Dense Layer (Logits Layer): 10 neuron, satu untuk setiap kelas target digit (0-9).
Ada tiga modul penting yang digunakan untuk membuat CNN:
- konv2d (). Membangun lapisan konvolusional dua dimensi dengan jumlah filter, ukuran kernel filter, padding, dan fungsi aktivasi sebagai argumen.
- max_pooling2d (). Membuat lapisan penyatuan dua dimensi menggunakan algoritme penyatuan maksimal.
- padat(). Membangun lapisan padat dengan lapisan dan unit tersembunyi
Anda akan menentukan fungsi untuk membangun CNN. Mari kita lihat secara detail bagaimana membangun setiap blok penyusun sebelumnya untuk menyatukan semuanya dalam fungsi.
Langkah 2: Masukkan lapisan
def cnn_model_fn(features, labels, mode):input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
Anda perlu menentukan tensor dengan bentuk datanya. Untuk itu, Anda dapat menggunakan modul tf.reshape. Dalam modul ini, Anda perlu mendeklarasikan tensor yang akan dibentuk ulang dan bentuk tensor. Argumen pertama adalah fitur data, yang didefinisikan dalam argumen fungsi.
Sebuah gambar memiliki tinggi, lebar, dan saluran. Dataset MNIST merupakan gambar monokronik dengan ukuran 28x28. Kami menetapkan ukuran batch ke -1 dalam argumen bentuk sehingga mengambil bentuk fitur ["x"]. Keuntungannya adalah membuat hyperparameter ukuran batch untuk disetel. Jika ukuran batch diatur ke 7, maka tensor akan memberi makan 5,488 nilai (28 * 28 * 7).
Step 3: Convolutional layer
# first Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)
Lapisan konvolusional pertama memiliki 14 filter dengan ukuran kernel 5x5 dengan padding yang sama. Padding yang sama berarti tensor keluaran dan tensor masukan harus memiliki tinggi dan lebar yang sama. Tensorflow akan menambahkan angka nol ke baris dan kolom untuk memastikan ukuran yang sama.
Anda menggunakan fungsi aktivasi Relu. Ukuran keluaran akan menjadi [28, 28, 14].
Langkah 4: Pooling layer
Langkah selanjutnya setelah konvolusi adalah komputasi penggabungan. Perhitungan penggabungan akan mengurangi dimensi data. Anda dapat menggunakan modul max_pooling2d dengan ukuran 2x2 dan langkah 2. Anda menggunakan layer sebelumnya sebagai input. Ukuran keluaran akan menjadi [ukuran_batch, 14, 14, 14]
# first Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Langkah 5: Lapisan Konvolusional Kedua dan Lapisan Penyatuan
Lapisan konvolusional kedua memiliki 32 filter, dengan ukuran keluaran [batch_size, 14, 14, 32]. Layer pooling memiliki ukuran yang sama seperti sebelumnya dan bentuk keluarannya adalah [batch_size, 14, 14, 18].
conv2 = tf.layers.conv2d(inputs=pool1,filters=36,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)
Langkah 6: Lapisan padat
Kemudian, Anda perlu menentukan lapisan yang sepenuhnya terhubung. Peta fitur harus diratakan sebelum dihubungkan dengan lapisan padat. Anda dapat menggunakan modul membentuk kembali dengan ukuran 7 * 7 * 36.
Lapisan padat akan menghubungkan 1764 neuron. Anda menambahkan fungsi aktivasi Relu. Selain itu, Anda menambahkan istilah regularisasi pelolosan dengan rasio 0,3, yang berarti 30 persen bobot akan disetel ke 0. Perhatikan bahwa, pelepasan hanya terjadi selama fase pelatihan. Fungsi cnn_model_fn memiliki mode argumen untuk menyatakan apakah model perlu dilatih atau dievaluasi.
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)
Langkah 7: Logit Layer
Terakhir, Anda dapat menentukan lapisan terakhir dengan prediksi model. Bentuk keluaran sama dengan ukuran kumpulan dan 10, jumlah total gambar.
# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)
Anda dapat membuat kamus yang berisi kelas dan probabilitas setiap kelas. Modul tf.argmax () dengan mengembalikan nilai tertinggi jika lapisan logit. Fungsi softmax mengembalikan probabilitas setiap kelas.
predictions = {# Generate predictions"classes": tf.argmax(input=logits, axis=1),"probabilities": tf.nn.softmax(logits, name="softmax_tensor") }
Anda hanya ingin mengembalikan prediksi kamus jika mode disetel ke prediksi. Anda menambahkan kode ini untuk menyebarkan prediksi
if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
Langkah selanjutnya terdiri dari menghitung kerugian model. Di tutorial terakhir, Anda mengetahui bahwa fungsi kerugian untuk model multikelas adalah entropi silang. Kerugiannya mudah dihitung dengan kode berikut:
# Calculate Loss (for both TRAIN and EVAL modes)loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)
Langkah terakhir adalah mengoptimalkan model, yaitu menemukan nilai bobot terbaik. Untuk itu, Anda menggunakan pengoptimal penurunan Gradien dengan kecepatan pemelajaran 0,001. Tujuannya adalah meminimalkan kerugian
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)train_op = optimizer.minimize(loss=loss,global_step=tf.train.get_global_step())
Anda sudah selesai dengan CNN. Namun, Anda ingin menampilkan metrik kinerja selama mode evaluasi. Metrik kinerja untuk model multikelas adalah metrik akurasi. Tensorflow dilengkapi dengan modul akurasi dengan dua argumen, label, dan nilai prediksi.
eval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)
Itu dia. Anda membuat CNN pertama dan siap menggabungkan semuanya ke dalam fungsi untuk menggunakannya untuk melatih dan mengevaluasi model.
def cnn_model_fn(features, labels, mode):"""Model function for CNN."""# Input Layerinput_layer = tf.reshape(features["x"], [-1, 28, 28, 1])# Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=32,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)# Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)# Convolutional Layer #2 and Pooling Layerconv2 = tf.layers.conv2d(inputs=pool1,filters=36,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)# Dense Layerpool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)predictions = {# Generate predictions (for PREDICT and EVAL mode)"classes": tf.argmax(input=logits, axis=1),"probabilities": tf.nn.softmax(logits, name="softmax_tensor")}if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)# Calculate Lossloss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)# Configure the Training Op (for TRAIN mode)if mode == tf.estimator.ModeKeys.TRAIN:optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)train_op = optimizer.minimize(loss=loss,global_step=tf.train.get_global_step())return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)# Add evaluation metrics Evaluation modeeval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)
Langkah-langkah di bawah ini sama dengan tutorial sebelumnya.
Pertama-tama, Anda mendefinisikan estimator dengan model CNN.
# Create the Estimatormnist_classifier = tf.estimator.Estimator(model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")
CNN membutuhkan banyak waktu untuk dilatih, oleh karena itu, Anda membuat pengait Logging untuk menyimpan nilai lapisan softmax setiap 50 iterasi.
# Set up logging for predictionstensors_to_log = {"probabilities": "softmax_tensor"}logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)
Anda siap untuk memperkirakan modelnya. Anda menetapkan ukuran tumpukan 100 dan mengocok data. Perhatikan bahwa kami menetapkan langkah pelatihan sebesar 16.000, perlu banyak waktu untuk berlatih. Sabar.
# Train the modeltrain_input_fn = tf.estimator.inputs.numpy_input_fn(x={"x": X_train_scaled},y=y_train,batch_size=100,num_epochs=None,shuffle=True)mnist_classifier.train(input_fn=train_input_fn,steps=16000,hooks=[logging_hook])
Setelah modelnya dilatih, Anda dapat mengevaluasinya dan mencetak hasilnya
# Evaluate the model and print resultseval_input_fn = tf.estimator.inputs.numpy_input_fn(x={"x": X_test_scaled},y=y_test,num_epochs=1,shuffle=False)eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)print(eval_results)
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}
Dengan arsitektur saat ini, Anda mendapatkan akurasi sebesar 97%. Anda dapat mengubah arsitektur, ukuran batch, dan jumlah iterasi untuk meningkatkan akurasi. Jaringan saraf CNN berkinerja jauh lebih baik daripada ANN atau regresi logistik. Dalam tutorial tentang jaringan saraf tiruan, Anda memiliki akurasi 96%, yang menurunkan CNN. Pertunjukan dari CNN yang mengesankan dengan gambar yang lebih besar set , baik dalam hal kecepatan komputasi dan akurasi.
Ringkasan
Jaringan saraf konvolusional bekerja sangat baik untuk mengevaluasi gambar. Jenis arsitektur ini dominan mengenali objek dari sebuah gambar atau video.
Untuk membangun CNN, Anda perlu mengikuti enam langkah:
Langkah 1: Lapisan masukan:
Langkah ini membentuk ulang data. Bentuknya sama dengan akar kuadrat dari jumlah piksel. Misalnya, jika sebuah gambar berukuran 156 piksel, maka bentuknya adalah 26x26. Anda perlu menentukan apakah gambar tersebut berwarna atau tidak. Jika ya, maka Anda memiliki 3 untuk bentuk- 3 untuk RGB-, jika tidak 1.
input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
Langkah 2: Lapisan konvolusional
Selanjutnya, Anda perlu membuat lapisan konvolusional. Anda menerapkan filter yang berbeda untuk memungkinkan jaringan mempelajari fitur penting. Anda menentukan ukuran kernel dan jumlah filter.
conv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)
Langkah 3: Pooling layer
Pada langkah ketiga, Anda menambahkan lapisan penggabungan. Lapisan ini mengurangi ukuran input. Ia melakukannya dengan mengambil nilai maksimum dari sub-matriks. Misalnya, jika sub-matriksnya [3,1,3,2], penggabungan akan menghasilkan nilai maksimum, yaitu 3.
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Langkah 4: Tambahkan Convolutional Layer dan Pooling Layer
Pada langkah ini, Anda dapat menambahkan sebanyak yang Anda inginkan, lapisan konv dan lapisan penggabungan. Google menggunakan arsitektur dengan lebih dari 20 lapisan konv.
Langkah 5: Lapisan padat
Langkah 5 meratakan sebelumnya untuk membuat lapisan yang terhubung sepenuhnya. Pada langkah ini, Anda dapat menggunakan fungsi aktivasi yang berbeda dan menambahkan efek putus sekolah.
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)
Langkah 6: Logit Layer
Langkah terakhir adalah prediksi.
logits = tf.layers.dense(inputs=dropout, units=10)