Klasifikasi Gambar CNN di TensorFlow dengan Langkah & Contoh

Apa itu Jaringan Saraf Konvolusi?

Jaringan Saraf KonvolusionalJaringan saraf konvolusional (convnets atau CNN), juga dikenal sebagai convnets, 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. Jaringan ini digunakan dalam aplikasi seperti pengenalan gambar atau video, pemrosesan bahasa alami, dan sistem rekomendasi.

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 dalam jaringan; ini disebut gambar masukan. Kemudian, gambar masukan melewati serangkaian langkah; ini adalah bagian konvolusi dari jaringan. Akhirnya, jaringan saraf dapat memprediksi angka pada gambar tersebut.

Sebuah gambar terdiri dari susunan 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). Saluran-saluran tersebut tersusun di atas 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 dengan nilai 0 akan menunjukkan warna putih, sedangkan piksel dengan nilai mendekati 255 akan lebih gelap.

Mari kita lihat gambar yang disimpan di kumpulan data MNISTGambar di bawah ini menunjukkan cara merepresentasikan gambar di sebelah kiri dalam format matriks. Perhatikan bahwa matriks asli telah distandarisasi agar nilainya 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 konvolusi. Bagian ini bertujuan untuk mengurangi ukuran gambar agar perhitungan bobot lebih cepat dan meningkatkan generalisasi.

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 mengekstraksitracHanya piksel yang paling relevan yang dipilih. 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-elemen paling penting di dalam setiap bagian.

Komponen Jaringan Neural Konvolusional (ConvNet atau CNN)

Jaringan konvolusi (convnet) memiliki empat komponen:

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

Lilit

Tujuan dari konvolusi adalah untuk mengekstraksitracJaringan saraf akan mempelajari fitur-fitur objek pada gambar secara lokal. Artinya, jaringan akan mempelajari pola-pola spesifik dalam gambar dan mampu mengenali pola-pola tersebut di mana pun dalam gambar.

Konvolusi adalah perkalian elemen demi elemen. Konsepnya mudah dipahami. Komputer akan memindai sebagian gambar, biasanya dengan dimensi 3×3, dan mengalikannya dengan filter. Hasil dari perkalian elemen demi elemen disebut peta fitur. Langkah ini diulang sampai seluruh gambar dipindai. Perhatikan bahwa, setelah konvolusi, ukuran gambar berkurang.

Diagram di bawah ini menunjukkan satu bagian gambar yang dikalikan dengan filter untuk menghasilkan satu sel tunggal dari peta fitur.

Animasi di bawah ini menunjukkan konvolusi yang sama yang berjalan di seluruh gambar.

Tersedia banyak sekali filter. Di bawah ini, kami telah mencantumkan beberapa di antaranya. Anda dapat melihat bahwa setiap filter memiliki tujuan spesifik. Perhatikan bahwa pada gambar di bawah ini, kernel adalah sinonim dari filter.

Aritmatika di balik konvolusi

Fase konvolusi akan menerapkan filter pada sejumlah kecil piksel dalam gambar. Filter akan bergerak di sepanjang gambar masukan dengan bentuk umum 3×3 atau 5×5. Artinya, jaringan akan menggeser jendela-jendela ini di seluruh gambar masukan dan menghitung konvolusi. Animasi di bawah ini menunjukkan bagaimana konvolusi beroperasi. Ukuran patch adalah 3×3, dan matriks keluaran adalah hasil dari 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 tersebut memiliki peta fitur 5×5 dan filter 3×3. Hanya ada satu jendela di tengah tempat filter dapat menyaring grid 3×3. Peta fitur keluaran menyusut sebanyak dua ubin pada setiap sumbu, menyisakan dimensi 3×3.

Untuk mendapatkan dimensi output yang sama dengan dimensi input, Anda perlu menambahkan padding. Padding terdiri dari menambahkan jumlah baris dan kolom yang tepat di setiap sisi matriks. Ini akan memungkinkan konvolusi untuk menyesuaikan setiap ubin input di tengah. Pada gambar di bawah, matriks input dan output memiliki dimensi yang sama, 5×5.

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

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

Melangkah: Ini menentukan jumlah "lompatan piksel" antara dua irisan. Jika stride sama dengan 1, jendela akan bergerak dengan penyebaran piksel sebesar satu. Jika stride sama dengan dua, jendela akan melompat sejauh 2 piksel. Jika Anda meningkatkan stride, Anda akan mendapatkan peta fitur yang lebih kecil. Dua diagram di bawah ini membandingkan stride 1 dengan stride 2.

Contoh langkah 1

langkah 2

Pengisian nol: Padding adalah operasi penambahan sejumlah baris dan kolom yang sesuai di setiap sisi peta fitur input. Dalam hal ini, output memiliki dimensi yang sama dengan input.

Non Linearitas (ReLU)

Pada akhir operasi konvolusi, output dikenakan fungsi aktivasi untuk memungkinkan non-linearitas. Fungsi aktivasi yang umum digunakan untuk convnet adalah ReLU. Semua piksel dengan nilai negatif akan diganti dengan nol.

Pooling Operaproduksi

Langkah ini mudah dipahami. Tujuan dari pooling adalah untuk mengurangi dimensi gambar masukan. Langkah-langkah ini dilakukan untuk mengurangi kompleksitas komputasi operasi. Dengan mengurangi dimensi, jaringan memiliki lebih sedikit bobot untuk dihitung, sehingga mencegah overfitting.

Pada tahap ini, Anda perlu menentukan ukuran dan stride. Cara standar untuk melakukan pooling pada gambar input adalah dengan menggunakan nilai maksimum dari feature map. Perhatikan gambar di bawah ini. Pooling akan menyaring empat submatriks dari feature map 4×4 dan mengembalikan nilai maksimumnya. Pooling mengambil nilai maksimum dari array 2×2 dan kemudian menggeser jendela ini sebanyak dua piksel. Misalnya, submatriks pertama adalah [3,1,3,2], sehingga pooling 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 saraf konvolusional TensorFlow menggabungkan berbagai lapisan sebelum membuat prediksi. Sebuah jaringan saraf memiliki:

• Lapisan konvolusional
• fungsi aktivasi ReLU
• Poolinlapisan g
• Lapisan yang terhubung erat

Lapisan konvolusi menerapkan filter berbeda pada subwilayah gambar. Fungsi aktivasi ReLU menambahkan non-linearitas, dan lapisan pooling mengurangi dimensi peta fitur.

Semua lapisan ini misalnyatracInformasi penting dari gambar tersebut kemudian diambil. Terakhir, peta fitur dimasukkan ke lapisan yang terhubung sepenuhnya dengan fungsi softmax untuk membuat prediksi.

Latih CNN dengan TensorFlow

Sekarang setelah Anda memahami komponen-komponen dasar dari sebuah convnet, 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:

1. Langkah 1: Unggah Kumpulan Data
2. Langkah 2: Lapisan masukan
3. Langkah 3: Lapisan konvolusional
4. Langkah 4: Poolinlapisan g
5. Langkah 5: Lapisan Konvolusional Kedua dan Pooling Lapisan
6. Langkah 6: Lapisan padat
7. Langkah 7: Lapisan Logit

Catatan versi: Daftar di bawah ini ditujukan untuk TensorFlow 1.x. Di TensorFlow 2, namespace tf.layers dan tf.estimator.inputs.numpy_input_fn tidak lagi ada; yang setara adalah tf.keras.layers.Conv2D, Max.Pooling2D, Dense, dan Dropout digabungkan dalam tf.keras.Model dan dilatih dengan model.fit(). Baca langkah-langkah untuk memahami mekanisme setiap lapisan, lalu petakan ke API Keras.

Langkah 1: Unggah Kumpulan Data

Dataset MNIST tersedia melalui scikit-learn. Silakan unduh dan simpan di folder Downloads. Anda dapat mengunggahnya dengan fetch_mldata('MNIST original').

Catatan versi: mldata.org telah ditutup dan fetch_mldata() telah dihapus di scikit-learn 0.22. Pada instalasi terbaru mana pun, muat angka yang sama dengan ambil_bukaml Sebagai gantinya, digunakan fetch_openml('mnist_784', version=1). Bagian pipeline lainnya tidak berubah.

Buat set kereta/ujian

Anda perlu membagi dataset menggunakan train_test_split.

Skalakan fiturnya

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

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 yang dipelajari oleh jaringan saraf tradisional. Untuk membangun CNN, Anda perlu mendefinisikan:

1. Lapisan konvolusi: Terapkan sejumlah n filter pada peta fitur. Setelah konvolusi, Anda perlu menggunakan fungsi aktivasi ReLU untuk menambahkan non-linearitas pada jaringan.
2. PoolinLapisan g: Langkah selanjutnya setelah konvolusi adalah melakukan downsampling pada feature map. Tujuannya adalah untuk mengurangi dimensi feature map guna mencegah overfitting dan meningkatkan kecepatan komputasi. Max pooling adalah teknik konvensional yang membagi feature map menjadi subwilayah (biasanya dengan ukuran 2×2) dan hanya menyimpan nilai maksimumnya.
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 Konvolusi: Menerapkan 14 filter 5×5 (contoh)trac(dengan subwilayah 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 mendefinisikan sebuah fungsi untuk membangun CNN. Mari kita lihat secara detail bagaimana cara membangun setiap blok penyusun sebelum kita membahasnya lebih lanjut.ping semuanya disatukan dalam fungsi tersebut.

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 memiliki tinggi, lebar, dan saluran. Dataset MNIST adalah gambar monokrom dengan ukuran 28×28. Kita mengatur ukuran batch menjadi -1 pada argumen bentuk sehingga bentuknya menyerupai fitur[“x”]. Keuntungannya adalah menjadikan ukuran batch sebagai hyperparameter yang dapat 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 konvolusi pertama memiliki 14 filter dengan ukuran kernel 5×5 dengan padding yang sama. Padding yang sama berarti tensor output dan tensor input 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 outputnya adalah [28, 28, 14].

Langkah 4: Poolinlapisan g

Langkah selanjutnya setelah konvolusi adalah komputasi pooling. Komputasi pooling akan mengurangi dimensi data. Anda dapat menggunakan modul max_pooling2d dengan ukuran 2×2 dan stride 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 konvolusi kedua menerapkan 36 filter, memberikan ukuran output [batch_size, 14, 14, 36]. Lapisan pooling menggunakan jendela 2×2 dan stride 2 yang sama seperti sebelumnya, sehingga membagi dua setiap sumbu spasial dan bentuk output menjadi [batch_size, 7, 7, 36].

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 mendefinisikan lapisan yang terhubung sepenuhnya (fully-connected layer). Peta fitur (feature map) harus diratakan (flattened) sebelum dihubungkan dengan lapisan padat (dense layer). Anda dapat menggunakan modul reshape dengan ukuran 7*7*36.

Lapisan dense akan menghubungkan 1,764 neuron. Anda menambahkan fungsi aktivasi ReLU. Selain itu, Anda menambahkan istilah regularisasi dropout dengan tingkat 0.3, yang berarti 30 persen aktivasi akan diatur ke 0. Perhatikan bahwa dropout hanya terjadi selama fase pelatihan. Fungsi cnn_model_fn memiliki argumen mode untuk menyatakan apakah model perlu dilatih atau dievaluasi, seperti yang ditunjukkan pada contoh klasifikasi gambar CNN TensorFlow 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 mendefinisikan lapisan terakhir dengan prediksi model. Bentuk outputnya sama dengan ukuran batch dan 10, yaitu jumlah total kelas target.

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

Anda dapat membuat kamus yang berisi kelas dan probabilitas setiap kelas. Fungsi tf.argmax() mengembalikan indeks nilai tertinggi pada 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 kamus prediksi 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 (loss function) model. Pada tutorial sebelumnya, Anda telah mempelajari bahwa fungsi kerugian untuk model multikelas adalah entropi silang (cross entropy). Kerugian dapat dengan 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 dari contoh CNN TensorFlow adalah mengoptimalkan model, yaitu menemukan nilai bobot terbaik. Untuk itu, Anda menggunakan pengoptimal penurunan gradien dengan laju pembelajaran 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 sudah selesai dengan CNN. Namun, Anda ingin menampilkan metrik kinerja selama mode evaluasi. Metrik kinerja untuk model multikelas adalah akurasi. TensorFlow dilengkapi dengan modul akurasi yang menerima dua argumen, yaitu 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)

Catatan tentang fungsi yang dirakit: Versi yang dibungkus di atas mengatur lapisan konvolusi pertama menjadi 32 filter dan dropout menjadi 0.4, sedangkan cuplikan langkah demi langkah menggunakan 14 filter dan 0.3. Keduanya berjalan, tetapi pilih satu pasang nilai dan pertahankan konsistensinya agar bentuk yang dicetak sesuai dengan tabel lapisan.

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 lama untuk dilatih, oleh karena itu, Anda membuat hook pencatatan untuk menyimpan nilai-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 untuk mengestimasi model. Anda menetapkan ukuran batch 100 dan mengacak data. Perhatikan bahwa kita menetapkan langkah pelatihan sebanyak 16,000, yang dapat memakan waktu lama untuk pelatihan. 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])

Setelah model 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)

Evaluasi tersebut mencetak titik pemeriksaan yang dipulihkan, langkah tempat berhenti, dan kamus metrik akhir.

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, kamus evaluasi melaporkan akurasi sebesar 0.9689286, atau sekitar 97%. Anda dapat mengubah arsitektur, ukuran batch, dan jumlah iterasi untuk meningkatkan akurasi. CNN telah berkinerja jauh lebih baik daripada jaringan saraf tiruan atau regresi logistik: dalam tutorial tentang jaringan saraf tiruan, Anda memperoleh akurasi 96%, yang lebih rendah daripada CNN. Performa CNN sangat mengesankan dengan kumpulan gambar yang lebih besar, baik dari segi kecepatan komputasi maupun akurasi.

Pertanyaan Umum Demo Slot