Klasifikasi Gambar CNN di TensorFlow dengan Langkah & Contoh

Apa itu Jaringan Saraf Konvolusi?

Jaringan Saraf Konvolusional, juga dikenal sebagai convnets atau CNN, adalah metode yang terkenal dalam aplikasi visi komputer. Ini adalah kelas jaringan saraf dalam yang digunakan untuk menganalisis citra visual. Jenis arsitektur ini dominan untuk mengenali objek dari gambar atau video. Ini digunakan dalam aplikasi seperti pengenalan gambar atau video, pemrosesan bahasa saraf, dll.

Architekstur Jaringan Neural Konvolusional

Coba pikirkan tentang Facebook beberapa tahun yang lalu, setelah Anda mengunggah gambar ke profil Anda, Anda diminta menambahkan nama wajah pada gambar tersebut secara manual. Saat ini, Facebook menggunakan convnet untuk menandai teman Anda di gambar secara otomatis.

Jaringan saraf konvolusional untuk klasifikasi gambar tidak terlalu sulit dipahami. Gambar masukan diproses selama fase konvolusi dan kemudian diberi label.

Arsitektur convnet yang umum dapat diringkas dalam gambar di bawah ini. Pertama-tama, sebuah gambar dimasukkan ke jaringan; ini disebut gambar input. Kemudian, gambar input melewati langkah-langkah yang jumlahnya tak terbatas; ini adalah bagian konvolusional dari jaringan. Akhirnya, jaringan saraf dapat memprediksi digit pada gambar.

Sebuah gambar terdiri dari array piksel dengan tinggi dan lebar. Gambar skala abu-abu hanya memiliki satu saluran sedangkan gambar berwarna memiliki tiga saluran (masing-masing untuk Merah, Hijau, dan Biru). Sebuah saluran ditumpuk satu sama lain. Dalam tutorial ini, Anda akan menggunakan gambar skala abu-abu dengan hanya satu saluran. Setiap piksel memiliki nilai dari 0 hingga 255 untuk mencerminkan intensitas warna. Misalnya, piksel yang sama dengan 0 akan menampilkan warna putih, sedangkan piksel yang nilainya mendekati 255 akan berwarna lebih gelap.

Mari kita lihat gambar yang disimpan di kumpulan data MNIST. Gambar di bawah menunjukkan cara merepresentasikan gambar sebelah kiri dalam format matriks. Perhatikan bahwa matriks asli telah distandarisasi menjadi antara 0 dan 1. Untuk warna yang lebih gelap, nilai dalam matriks adalah sekitar 0.9 sedangkan piksel putih memiliki nilai 0.

Operasi konvolusional

Komponen paling penting dalam model ini adalah lapisan konvolusional. Bagian ini bertujuan untuk memperkecil ukuran gambar untuk penghitungan bobot yang lebih cepat dan meningkatkan generalisasinya.

Selama bagian konvolusional, jaringan mempertahankan fitur-fitur penting dari gambar dan mengecualikan noise yang tidak relevan. Misalnya, model sedang mempelajari cara mengenali gajah dari gambar dengan latar belakang gunung. Jika Anda menggunakan jaringan saraf tradisional, model akan memberikan bobot pada semua piksel, termasuk piksel yang berasal dari gunung yang tidak penting dan dapat menyesatkan jaringan.

Sebaliknya, a Keras 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 potongan-potongan kecil untuk mempelajari elemen yang paling penting dalam setiap bagian.

Komponen Jaringan Neural Konvolusional (ConvNet atau CNN)

Ada empat komponen Convnets

1. Lilit
2. Non Linearitas (ReLU)
3. Pooling atau Sub Sampling
4. Klasifikasi (Lapisan Terhubung Sepenuhnya)

Lilit

Tujuan dari konvolusi adalah untuk mengekstraksi fitur objek pada citra secara lokal. Artinya, jaringan akan mempelajari pola tertentu di dalam gambar dan akan mampu mengenalinya di mana pun dalam gambar.

Konvolusi adalah perkalian elemen demi elemen. Konsepnya mudah dipahami. Komputer akan memindai bagian gambar, biasanya berdimensi 3×3 dan mengalikannya ke filter. Output dari perkalian elemen demi elemen disebut peta fitur. Langkah ini diulang hingga seluruh gambar dipindai. Perhatikan bahwa, setelah konvolusi, ukuran gambar diperkecil.

Di bawah, terdapat URL untuk melihat cara kerja konvolusi.

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.

Aritmatika di balik konvolusi

Fase konvolusional akan menerapkan filter pada sejumlah kecil piksel dalam gambar. Filter akan bergerak sepanjang gambar input dengan bentuk umum 3×3 atau 5×5. Artinya, jaringan akan menggeser jendela ini melintasi semua gambar input dan menghitung konvolusi. Gambar di bawah ini menunjukkan cara kerja konvolusi. Ukuran patch adalah 3×3, dan matriks output adalah hasil operasi elemen demi elemen antara matriks gambar dan filter.

Anda memperhatikan bahwa lebar dan tinggi keluaran bisa berbeda dari lebar dan tinggi masukan. Hal ini terjadi karena adanya efek perbatasan.

Efek perbatasan

Gambar memiliki peta fitur 5×5 dan filter 3×3. Hanya ada satu jendela di tengah tempat filter dapat menyaring kisi 3x3. Peta fitur keluaran akan menyusut dua ubin dengan dimensi 3×3.

Untuk mendapatkan dimensi keluaran yang sama dengan dimensi masukan, Anda perlu menambahkan padding. Padding terdiri dari penambahan jumlah baris dan kolom yang tepat pada setiap sisi matriks. Ini akan memungkinkan konvolusi ke tengah sesuai dengan setiap ubin masukan. Pada gambar di bawah, matriks masukan/keluaran mempunyai dimensi yang sama 5×5

Saat Anda menentukan jaringan, fitur konvolusi dikontrol oleh tiga parameter:

1. Kedalaman: Ini menentukan jumlah filter yang akan diterapkan selama konvolusi. Pada contoh sebelumnya, Anda melihat kedalaman 1, artinya hanya satu filter yang digunakan. Dalam sebagian besar kasus, terdapat lebih dari satu filter. Gambar di bawah menunjukkan operasi yang dilakukan dalam situasi dengan tiga filter

2. Melangkah: Menentukan jumlah "lompatan piksel" antara dua irisan. Jika langkahnya sama dengan 1, jendela akan bergerak dengan sebaran piksel sebesar satu. Jika langkahnya sama dengan dua, jendela akan melompat sebanyak 2 piksel. Jika Anda menambah langkahnya, Anda akan memiliki peta fitur yang lebih kecil.

Contoh langkah 1

langkah 2

3. Bantalan nol: Padding adalah operasi penambahan jumlah baris dan kolom yang sesuai pada setiap sisi peta fitur masukan. Dalam hal ini keluaran mempunyai dimensi yang sama dengan masukan.

Non Linearitas (ReLU)

Pada akhir operasi konvolusi, keluaran tunduk pada fungsi aktivasi untuk memungkinkan non-linearitas. Fungsi aktivasi yang biasa untuk convnet adalah Relu. Semua piksel dengan nilai negatif akan diganti dengan nol.

Pooling Operaproduksi

Langkah ini mudah dipahami. Tujuan dari penggabungan adalah untuk mengurangi dimensionalitas gambar input. Langkah-langkah tersebut dilakukan untuk mengurangi kompleksitas komputasional dari operasi tersebut. Dengan mengurangi dimensionalitas, jaringan memiliki bobot yang lebih rendah untuk dihitung, sehingga mencegah terjadinya overfitting.

Pada tahap ini, Anda perlu menentukan ukuran dan langkah. Cara standar untuk menggabungkan gambar input adalah dengan menggunakan nilai maksimum peta fitur. Lihat gambar di bawah ini. "Penggabungan" akan menyaring empat submatriks dari peta fitur 4x4 dan mengembalikan nilai maksimum. Penggabungan mengambil nilai maksimum dari array 2x2 dan kemudian memindahkan jendela ini sejauh dua piksel. Misalnya, submatriks pertama adalah [3,1,3,2], penggabungan akan mengembalikan nilai maksimum, yaitu 3.

Ada operasi pengumpulan lain seperti mean.

Operasi ini secara agresif mengurangi ukuran peta fitur

Lapisan Terhubung Sepenuhnya

Langkah terakhir terdiri dari membangun tradisional jaringan saraf tiruan seperti yang Anda lakukan pada tutorial sebelumnya. Anda menghubungkan semua neuron dari lapisan sebelumnya ke lapisan berikutnya. Anda menggunakan fungsi aktivasi softmax untuk mengklasifikasikan nomor pada gambar input.

Rekap:

Jaringan Neural Konvolusional TensorFlow mengkompilasi lapisan yang berbeda sebelum membuat prediksi. Jaringan saraf memiliki:

• Lapisan konvolusional
• Fungsi Aktivasi Relu
• Poolinlapisan g
• Lapisan yang terhubung erat

Lapisan konvolusional menerapkan filter yang berbeda pada subwilayah gambar. Fungsi aktivasi Relu menambahkan non-linearitas, dan lapisan penggabungan mengurangi dimensionalitas 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 familiar dengan blok penyusun sebuah convnets, Anda siap untuk membangunnya TensorFlow. Kami akan menggunakan dataset MNIST untuk klasifikasi gambar CNN.

Persiapan data sama dengan tutorial sebelumnya. Anda dapat menjalankan kode dan langsung beralih ke arsitektur CNN.

Anda akan mengikuti langkah-langkah di bawah ini untuk klasifikasi gambar menggunakan CNN:

Langkah 1: Unggah Kumpulan Data

Langkah 2: Lapisan masukan

Langkah 3: Lapisan konvolusional

Langkah 4: Poolinlapisan g

Langkah 5: Lapisan Konvolusional Kedua dan Pooling Lapisan

Langkah 6: Lapisan padat

Langkah 7: Lapisan Logit

Langkah 1: Unggah Kumpulan Data

Kumpulan data MNIST tersedia dengan scikit untuk dipelajari di sini URL. Silakan unduh dan simpan di Unduhan. Anda dapat mengunggahnya dengan mengambil_mldata('MNIST asli').

Buat set kereta/ujian

Anda perlu membagi kumpulan data dengan train_test_split

Skalakan fiturnya

Terakhir, Anda dapat menskalakan fitur dengan MinMaxScaler seperti yang ditunjukkan pada klasifikasi gambar di bawah menggunakan contoh TensorFlow CNN.

import numpy as np
import tensorflow as tf
from sklearn.datasets import fetch_mldata

#Change USERNAME by the username of your machine
## Windows USER
mnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')
## Mac User
mnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')

print(mnist.data.shape)
print(mnist.target.shape)
from sklearn.model_selection import train_test_split

X_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 )
## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_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:]

Definisikan CNN

CNN menggunakan filter pada piksel mentah suatu gambar untuk mempelajari pola detail dibandingkan dengan pola global dengan jaringan saraf tradisional. Untuk membangun CNN, Anda perlu menentukan:

1. Lapisan konvolusional: Terapkan sejumlah filter ke peta fitur. Setelah konvolusi, Anda perlu menggunakan fungsi aktivasi Relu untuk menambahkan non-linearitas ke jaringan.
2. Poolinlapisan g: Langkah berikutnya setelah konvolusi adalah melakukan downsample terhadap fitur maks. Tujuannya adalah untuk mengurangi dimensionalitas peta fitur guna mencegah overfitting dan meningkatkan kecepatan komputasi. Pengumpulan maks adalah teknik konvensional, yang membagi peta fitur menjadi subwilayah (biasanya dengan ukuran 2×2) dan hanya menyimpan nilai maksimum.
3. Lapisan yang terhubung penuh: Semua neuron dari lapisan sebelumnya terhubung ke lapisan berikutnya. CNN akan mengklasifikasikan label menurut fitur dari lapisan konvolusional dan direduksi dengan lapisan penggabungan.

Arsitektur CNN

• Lapisan Konvolusional: Menerapkan 14 filter 5×5 (mengekstraksi subkawasan 5×5 piksel), dengan fungsi aktivasi ReLU
• Pooling Layer: Melakukan penggabungan maksimal dengan filter 2×2 dan langkah 2 (yang menentukan bahwa wilayah yang digabungkan tidak saling tumpang tindih)
• Lapisan Konvolusional: Menerapkan 36 filter 5×5, dengan fungsi aktivasi ReLU
• Pooling Lapisan #2: Sekali lagi, lakukan penggabungan maksimal dengan filter 2×2 dan langkah 2
• 1,764 neuron, dengan tingkat regularisasi putus sekolah 0.4 (probabilitas 0.4 bahwa elemen tertentu akan dihapus selama pelatihan)
• Lapisan Padat (Lapisan Logits): 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(). Membangun lapisan pengumpulan dua dimensi menggunakan algoritma max-pooling.
• padat(). Membangun lapisan padat dengan lapisan dan unit tersembunyi

Anda akan menentukan fungsi untuk membangun CNN. Mari kita lihat secara detail cara membuat setiap blok penyusun sebelum menggabungkan semuanya ke dalam fungsi.

Langkah 2: Lapisan masukan

def cnn_model_fn(features, labels, mode):
    input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Anda perlu mendefinisikan tensor dengan bentuk datanya. Untuk itu, Anda bisa 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 mempunyai tinggi, lebar, dan saluran. Dataset MNIST berupa gambar monokromatik dengan ukuran 28x28. Kita mengatur ukuran batch ke -1 dalam argumen bentuk sehingga mengambil bentuk fitur["x"]. Keuntungannya adalah membuat hyperparameter ukuran batch disesuaikan. Jika ukuran batch diatur ke 7, maka tensor akan memasukkan 5,488 nilai (28*28*7).

Langkah 3: Lapisan konvolusional

# first Convolutional Layer
  conv1 = 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 5×5 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 pada baris dan kolom untuk memastikan ukuran yang sama.

Anda menggunakan fungsi aktivasi Relu. Ukuran keluarannya adalah [28, 28, 14].

Langkah 4: Poolinlapisan g

Langkah berikutnya setelah konvolusi adalah komputasi penggabungan. Komputasi penggabungan akan mengurangi dimensionalitas data. Anda dapat menggunakan modul max_pooling2d dengan ukuran 2×2 dan langkah 2. Anda menggunakan lapisan sebelumnya sebagai input. Ukuran output akan menjadi [batch_size, 14, 14, 14]

# first Pooling Layer 
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Langkah 5: Lapisan Konvolusional Kedua dan Pooling Lapisan

Lapisan konvolusional kedua memiliki 32 filter, dengan ukuran keluaran [batch_size, 14, 14, 32]. Lapisan pengumpulan 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 terhubung sepenuhnya. Peta fitur harus diratakan sebelum dihubungkan dengan lapisan padat. Anda dapat menggunakan modul reshape dengan ukuran 7*7*36.

Lapisan padat akan menghubungkan 1764 neuron. Anda menambahkan fungsi aktivasi Relu. Selain itu, Anda menambahkan istilah regularisasi dropout dengan tingkat 0.3, artinya 30 persen bobot akan disetel ke 0. Perhatikan bahwa dropout hanya terjadi selama fase pelatihan. Fungsi cnn_model_fn memiliki mode argumen untuk mendeklarasikan apakah model perlu dilatih atau dievaluasi seperti yang ditunjukkan pada contoh TensorFlow klasifikasi gambar CNN di bawah ini.

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

Terakhir, dalam contoh klasifikasi gambar TensorFlow, Anda dapat menentukan lapisan terakhir dengan prediksi model. Bentuk keluarannya sama dengan ukuran kumpulan dan 10, jumlah total gambar.

# Logits Layer
logits = tf.layers.dense(inputs=dropout, units=10)

Anda dapat membuat kamus yang berisi kelas-kelas dan probabilitas setiap kelas. Modul tf.argmax() dengan mengembalikan nilai tertinggi jika logit berlapis. 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 ketika mode diatur ke prediksi. Anda menambahkan kode ini untuk menampilkan prediksi

if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

Langkah selanjutnya adalah menghitung kerugian model. Dalam tutorial terakhir, Anda mempelajari bahwa fungsi kerugian untuk model multikelas adalah entropi silang. Kerugian tersebut dapat dihitung dengan mudah menggunakan kode berikut:

# Calculate Loss (for both TRAIN and EVAL modes)
loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

Langkah terakhir dari contoh TensorFlow CNN adalah mengoptimalkan model, yaitu mencari nilai bobot terbaik. Untuk itu, Anda menggunakan pengoptimal penurunan Gradien dengan kecepatan pemelajaran 0.001. Tujuannya adalah untuk meminimalkan kerugian

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())

Anda 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 Anda dan Anda siap untuk menggabungkan semuanya ke dalam sebuah fungsi untuk menggunakannya untuk melatih dan mengevaluasi model.

def cnn_model_fn(features, labels, mode):
  """Model function for CNN."""
  # Input Layer
  input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])

  # Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=32,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

  # Pooling Layer
  pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

  # Convolutional Layer #2 and Pooling Layer
  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)

  # Dense Layer
  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.4, training=mode == tf.estimator.ModeKeys.TRAIN)

  # Logits Layer
  logits = 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 Loss
  loss = 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 mode
  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)

Langkah-langkah dibawah ini sama dengan tutorial sebelumnya.

Pertama-tama, Anda menentukan estimator dengan model CNN untuk klasifikasi gambar.

# Create the Estimator
mnist_classifier = tf.estimator.Estimator(
    model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")

CNN membutuhkan waktu berkali-kali untuk dilatih, oleh karena itu, Anda membuat hook Logging untuk menyimpan nilai lapisan softmax setiap 50 iterasi.

# Set up logging for predictions
tensors_to_log = {"probabilities": "softmax_tensor"}
logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)

Anda siap memperkirakan modelnya. Anda menetapkan ukuran batch 100 dan mengacak data. Perhatikan bahwa kami menetapkan langkah pelatihan sebesar 16.000, pelatihan ini memerlukan banyak waktu. Bersabarlah.

# Train the model
train_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])

Sekarang model sudah dilatih, Anda dapat mengevaluasinya dan mencetak hasilnya

# Evaluate the model and print results
eval_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:41
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56
INFO: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 memperoleh akurasi sebesar 97%. Anda dapat mengubah arsitektur, ukuran batch, dan jumlah iterasi untuk meningkatkan akurasi. Jaringan saraf CNN telah berkinerja jauh lebih baik daripada ANN atau regresi logistik. Dalam tutorial tentang jaringan saraf tiruan, Anda memperoleh akurasi sebesar 96%, yang lebih rendah daripada CNN. Performa CNN sangat mengesankan dengan gambar yang lebih besar. set, baik dari segi kecepatan komputasi maupun akurasi.

Ringkasan

Jaringan saraf konvolusional bekerja sangat baik untuk mengevaluasi gambar. Jenis arsitektur ini dominan untuk mengenali objek dari gambar atau video.

Untuk membuat CNN TensorFlow, Anda harus mengikuti Tujuh langkah:

Langkah 1: Unggah Kumpulan Data:

Kumpulan data MNIST tersedia dengan scikit untuk dipelajari. Silakan unduh dan simpan di Unduhan. Anda dapat mengunggahnya dengan mengambil_mldata('MNIST asli').

Langkah 2: Lapisan masukan:

Langkah ini akan mengubah bentuk data. Bentuknya sama dengan akar kuadrat jumlah piksel. Misalnya, jika gambar memiliki 156 piksel, maka bentuknya adalah 26×26. Anda perlu menentukan apakah gambar tersebut berwarna atau tidak. Jika ya, maka Anda memiliki 3 untuk bentuk tersebut - 3 untuk RGB-, jika tidak, 1.

input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Langkah 3: Lapisan konvolusional

Selanjutnya, Anda perlu membuat lapisan konvolusional. Anda menerapkan filter 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 4: Poolinlapisan g

Pada langkah ketiga, Anda menambahkan lapisan penggabungan. Lapisan ini mengurangi ukuran input. Hal ini dilakukan dengan mengambil nilai maksimum dari sub-matriks. Misalnya, jika sub-matriks adalah [3,1,3,2], penggabungan akan mengembalikan nilai maksimum, yaitu 3.

pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Langkah 5: Tambahkan Lapisan Konvolusional dan Pooling Lapisan

Pada langkah ini, Anda dapat menambahkan sebanyak mungkin lapisan konversi dan lapisan penggabungan. Google menggunakan arsitektur dengan lebih dari 20 lapisan konversi.

Langkah 6: Lapisan padat

Langkah 6 ratakan sebelumnya untuk membuat lapisan tersambung sepenuhnya. Pada langkah ini, Anda dapat menggunakan fungsi aktivasi yang berbeda dan menambahkan efek dropout.

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

Langkah terakhir adalah prediksi.

logits = tf.layers.dense(inputs=dropout, units=10)