Klasifikasi Imej TensorFlow: CNN (Rangkaian Neural Konvolusional)

Isi kandungan:

Anonim

Apa itu Rangkaian Neural Konvolusional?

Rangkaian saraf konvolusional, juga dikenal sebagai konvensional atau CNN, adalah kaedah yang terkenal dalam aplikasi penglihatan komputer. Jenis seni bina ini dominan untuk mengenali objek dari gambar atau video.

Dalam tutorial ini, anda akan belajar bagaimana membina konnet dan bagaimana menggunakan TensorFlow untuk menyelesaikan set data tulisan tangan.

Dalam tutorial ini, anda akan belajar

  • Rangkaian Neural Konvolusional
  • Senibina Rangkaian Neural Konvolusional
  • Komponen Convnets
  • Latih CNN dengan TensorFlow
  • Langkah 1: Muat naik Set Data
  • Langkah 2: Lapisan input
  • Langkah 3: Lapisan konvolusional
  • Langkah 4: Lapisan kolam
  • Langkah 5: Lapisan Konvolusi Kedua dan Lapisan Pengumpulan
  • Langkah 6: Lapisan padat
  • Langkah 7: Lapisan Logit

Senibina Rangkaian Neural Konvolusional

Fikirkan tentang Facebook beberapa tahun yang lalu, setelah anda memuat naik gambar ke profil anda, anda diminta untuk menambahkan nama pada wajah pada gambar tersebut secara manual. Pada masa kini, Facebook menggunakan convnet untuk menandai rakan anda dalam gambar secara automatik.

Rangkaian saraf konvolusioner tidak begitu sukar untuk difahami. Imej input diproses semasa fasa konvolusi dan kemudian mengaitkan label.

Senibina konvensional boleh diringkaskan dalam gambar di bawah. Pertama sekali, gambar ditolak ke rangkaian; ini dipanggil gambar input. Kemudian, gambar input melalui beberapa langkah; ini adalah bahagian konvolusional rangkaian. Akhirnya, rangkaian saraf dapat meramalkan digit pada gambar.

Gambar terdiri daripada susunan piksel dengan tinggi dan lebar. Gambar skala kelabu hanya mempunyai satu saluran manakala gambar warna mempunyai tiga saluran (masing-masing untuk Merah, Hijau, dan Biru). Saluran disusun di antara satu sama lain. Dalam tutorial ini, anda akan menggunakan gambar skala kelabu dengan hanya satu saluran. Setiap piksel mempunyai nilai dari 0 hingga 255 untuk mencerminkan intensitas warna. Sebagai contoh, piksel sama dengan 0 akan menunjukkan warna putih sementara piksel dengan nilai hampir 255 akan lebih gelap.

Mari lihat gambar yang disimpan dalam set data MNIST. Gambar di bawah menunjukkan cara mewakili gambar sebelah kiri dalam format matriks. Perhatikan bahawa, matriks asli telah diseragamkan antara 0 dan 1. Untuk warna yang lebih gelap, nilai dalam matriks adalah sekitar 0,9 sementara piksel putih mempunyai nilai 0.

Operasi konvolusional

Komponen yang paling kritikal dalam model adalah lapisan konvolusional. Bahagian ini bertujuan untuk mengurangkan ukuran gambar untuk pengiraan berat yang lebih cepat dan meningkatkan generalisasi.

Semasa bahagian konvolusional, rangkaian menyimpan ciri-ciri penting gambar dan tidak termasuk bunyi yang tidak berkaitan. Sebagai contoh, model ini belajar bagaimana mengenali gajah dari gambar dengan gunung di latar belakang. Sekiranya anda menggunakan rangkaian neural tradisional, model akan memberikan bobot kepada semua piksel, termasuk dari gunung yang tidak penting dan dapat menyesatkan rangkaian.

Sebaliknya, rangkaian saraf konvolusional akan menggunakan teknik matematik untuk mengekstrak piksel yang paling relevan sahaja. Operasi matematik ini dipanggil konvolusi. Teknik ini membolehkan rangkaian mempelajari ciri-ciri yang semakin kompleks pada setiap lapisan. Konvolusi membahagikan matriks menjadi kepingan kecil untuk mempelajari unsur-unsur penting dalam setiap bahagian.

Komponen Convnets

Terdapat empat komponen Convnets

  1. Konvolusi
  2. Tidak Lineariti (ReLU)
  3. Pengumpulan atau Sub Persampelan
  4. Klasifikasi (Lapisan Terhubung Sepenuhnya)
  • Konvolusi

Tujuan konvolusi adalah untuk mengekstrak ciri objek pada gambar secara tempatan. Ini bermaksud rangkaian akan mempelajari corak tertentu dalam gambar dan dapat mengenalinya di mana-mana dalam gambar.

Konvolusi adalah pendaraban unsur-unsur. Konsepnya mudah difahami. Komputer akan mengimbas sebahagian gambar, biasanya dengan dimensi 3x3 dan mengalikannya ke penapis. Hasil darab unsur-unsur disebut peta ciri. Langkah ini diulang sehingga semua gambar diimbas. Perhatikan bahawa, selepas konvolusi, ukuran gambar dikurangkan.

Di bawah ini, terdapat URL untuk melihat bagaimana cara kerja konvolusi.

Terdapat banyak saluran yang ada. Di bawah ini, kami menyenaraikan beberapa saluran. Anda dapat melihat bahawa setiap penapis mempunyai tujuan tertentu. Perhatikan, dalam gambar di bawah; Kernel adalah sinonim penapis.

Sumber

Aritmetik di sebalik konvolusi

Fasa konvolusional akan menerapkan penapis pada susunan piksel kecil dalam gambar. Penapis akan bergerak di sepanjang gambar input dengan bentuk umum 3x3 atau 5x5. Ini bermaksud rangkaian akan meluncurkan tetingkap ini di semua gambar input dan mengira konvolusi. Gambar di bawah menunjukkan bagaimana konvolusi beroperasi. Ukuran tambalan adalah 3x3, dan matriks output adalah hasil operasi elemen-elemen antara matriks gambar dan penapis.

Sumber

Anda perhatikan bahawa lebar dan tinggi output boleh berbeza dengan lebar dan tinggi input. Ia berlaku kerana kesan sempadan.

Kesan sempadan

Imej mempunyai peta ciri 5x5 dan penapis 3x3. Hanya ada satu tetingkap di tengah di mana penapis dapat menyaring grid 3x3. Peta ciri keluaran akan menyusut dua jubin bersama dengan dimensi 3x3.

Untuk mendapatkan dimensi output yang sama dengan dimensi input, anda perlu menambahkan padding. Padding terdiri daripada menambahkan baris dan lajur yang tepat di setiap sisi matriks. Ini akan membolehkan konvolusi berpusat pada setiap jubin input. Dalam gambar di bawah, matriks input / output mempunyai dimensi yang sama 5x5

Semasa anda menentukan rangkaian, ciri berpusing dikendalikan oleh tiga parameter:

  1. Kedalaman: Ia menentukan bilangan saringan yang akan digunakan semasa konvolusi. Dalam contoh sebelumnya, anda melihat kedalaman 1, yang bermaksud hanya satu penapis yang digunakan. Dalam kebanyakan kes, terdapat lebih daripada satu penapis. Gambar di bawah menunjukkan operasi yang dilakukan dalam keadaan dengan tiga penapis

  1. Langkah: Ini menentukan bilangan "lompatan piksel" antara dua potongan. Sekiranya langkah sama dengan 1, tingkap akan bergerak dengan penyebaran piksel satu. Sekiranya langkahnya sama dengan dua, tingkap akan melonjak sebanyak 2 piksel. Sekiranya anda meningkatkan langkah, anda akan mempunyai peta ciri yang lebih kecil.

Contoh langkah 1

Langkah gambar 2

  1. Zero-padding: Padding adalah operasi menambahkan bilangan baris dan lajur yang sesuai di setiap sisi peta ciri input. Dalam kes ini, output mempunyai dimensi yang sama dengan input.
  2. Tidak Lineariti (ReLU)

Pada akhir operasi konvolusi, output dikenakan fungsi pengaktifan untuk membolehkan non-linear. Fungsi pengaktifan biasa untuk konvnet adalah Relu. Semua piksel dengan nilai negatif akan diganti dengan sifar.

  • Operasi pengumpulan maksimum

Langkah ini mudah difahami. Tujuan penyatuan adalah untuk mengurangkan dimensi gambar input. Langkah-langkahnya dilakukan untuk mengurangkan kerumitan pengiraan operasi. Dengan mengurangkan dimensi, rangkaian mempunyai bobot yang lebih rendah untuk dikira, sehingga mencegah overfitting.

Pada peringkat ini, anda perlu menentukan ukuran dan langkahnya. Kaedah standard untuk mengumpulkan gambar input adalah dengan menggunakan nilai maksimum peta ciri. Lihat gambar di bawah. "Pengumpulan" akan menyaring empat submatrix peta ciri 4x4 dan mengembalikan nilai maksimum. Pengumpulan mengambil nilai maksimum array 2x2 dan kemudian memindahkan tetingkap ini dengan dua piksel. Sebagai contoh, sub-matriks pertama adalah [3,1,3,2], penyatuan akan mengembalikan maksimum, iaitu 3.

Terdapat operasi penyatuan lain seperti min.

Operasi ini secara agresif mengurangkan ukuran peta ciri

  • Lapisan yang disambungkan sepenuhnya

Langkah terakhir terdiri daripada membina rangkaian saraf tiruan tradisional seperti yang anda lakukan dalam tutorial sebelumnya. Anda menghubungkan semua neuron dari lapisan sebelumnya ke lapisan seterusnya. Anda menggunakan fungsi pengaktifan softmax untuk mengklasifikasikan nombor pada gambar input.

Rekap:

Rangkaian Neural konvolusioner menyusun lapisan yang berlainan sebelum membuat ramalan. Rangkaian saraf mempunyai:

  • Lapisan konvolusional
  • Fungsi Pengaktifan Relu
  • Lapisan kolam
  • Lapisan yang bersambung dengan padat

Lapisan konvolusional menggunakan penapis yang berbeza pada subkawasan gambar. Fungsi pengaktifan Relu menambahkan non-linearitas, dan lapisan penyatuan mengurangkan dimensi peta ciri.

Semua lapisan ini mengekstrak maklumat penting dari gambar. Akhirnya, peta ciri menyalurkan lapisan utama yang terhubung sepenuhnya dengan fungsi softmax untuk membuat ramalan.

Latih CNN dengan TensorFlow

Sekarang anda sudah biasa dengan blok bangunan konvet, anda sudah bersedia untuk membina satu dengan TensorFlow. Kami akan menggunakan set data MNIST untuk pengelasan gambar.

Penyediaan data sama dengan tutorial sebelumnya. Anda boleh menjalankan kod dan melompat terus ke seni bina CNN.

Anda akan mengikuti langkah-langkah di bawah:

Langkah 1: Muat naik Set Data

Langkah 2: Lapisan input

Langkah 3: Lapisan konvolusional

Langkah 4: Lapisan kolam

Langkah 5: Lapisan Konvolusi Kedua dan Lapisan Pengumpulan

Langkah 6: Lapisan padat

Langkah 7: Lapisan Logit

Langkah 1: Muat naik Set Data

Set data MNIST tersedia dengan scikit untuk belajar di URL ini. Sila muat turun dan simpan dalam Muat turun. Anda boleh memuat naiknya dengan fetch_mldata ('MNIST original').

Buat set kereta / ujian

Anda perlu membahagikan set data dengan train_test_split

Skala ciri

Akhirnya, anda boleh menskalakan ciri 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 penapis pada piksel mentah gambar untuk mengetahui corak perincian dibandingkan dengan corak global dengan jaring saraf tradisional. Untuk membina CNN, anda perlu menentukan:

  1. Lapisan konvolusional: Terapkan jumlah penapis pada peta ciri. Selepas konvolusi, anda perlu menggunakan fungsi pengaktifan Relu untuk menambahkan non-linear pada rangkaian.
  2. Lapisan penggabungan: Langkah seterusnya setelah konvolusi adalah menurunkan fitur maks. Tujuannya adalah untuk mengurangkan dimensi peta ciri untuk mengelakkan overfitting dan meningkatkan kelajuan pengiraan. Pengumpulan maksimum adalah teknik konvensional, yang membahagikan peta ciri menjadi subkawasan (biasanya dengan ukuran 2x2) dan hanya menyimpan nilai maksimum.
  3. Lapisan yang disambungkan sepenuhnya: Semua neuron dari lapisan sebelumnya disambungkan ke lapisan seterusnya. CNN akan mengklasifikasikan label mengikut ciri dari lapisan konvolusional dan dikurangkan dengan lapisan penyatuan.

Senibina CNN

  • Lapisan Konvolusional: Menggunakan 14 penapis 5x5 (mengekstrak subkawasan 5x5 piksel), dengan fungsi pengaktifan ReLU
  • Pooling Layer: Melakukan penyatuan maksimum dengan penapis 2x2 dan langkah 2 (yang menentukan bahawa kawasan penyatuan tidak bertindih)
  • Lapisan Konvolusional: Menggunakan 36 penapis 5x5, dengan fungsi pengaktifan ReLU
  • Pooling Layer # 2: Sekali lagi, melakukan penyatuan maksimum dengan penapis 2x2 dan langkah 2
  • 1,764 neuron, dengan kadar regularisasi putus sekolah 0,4 (kebarangkalian 0,4 bahawa mana-mana elemen tertentu akan dijatuhkan semasa latihan)
  • Lapisan Dense (Logits Layer): 10 neuron, satu untuk setiap kelas sasaran digit (0-9).

Terdapat tiga modul penting untuk digunakan untuk membuat CNN:

  • konv2d (). Membina lapisan konvensional dua dimensi dengan bilangan penapis, ukuran kernel penapis, padding, dan fungsi pengaktifan sebagai argumen.
  • max_pooling2d (). Membina lapisan penyatuan dua dimensi menggunakan algoritma penyatuan maksimum.
  • padat(). Membina lapisan yang padat dengan lapisan dan unit tersembunyi

Anda akan menentukan fungsi untuk membina CNN. Mari kita lihat secara terperinci bagaimana membina setiap blok bangunan sebelum membungkus semuanya dalam fungsi.

Langkah 2: Lapisan input

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 data. Untuk itu, anda boleh menggunakan modul tf.reshape. Dalam modul ini, anda perlu menyatakan tensor untuk membentuk semula dan bentuk tensor. Argumen pertama adalah ciri-ciri data, yang ditentukan dalam argumen fungsi.

Gambar mempunyai tinggi, lebar, dan saluran. Set data MNIST adalah gambar monokronik dengan ukuran 28x28. Kami menetapkan ukuran kumpulan menjadi -1 dalam argumen bentuk sehingga mengambil bentuk ciri ["x"]. Kelebihannya ialah menjadikan hyperparameter ukuran batch untuk diselaraskan. Sekiranya saiz kumpulan ditetapkan 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 mempunyai 14 penapis dengan ukuran kernel 5x5 dengan pelapik yang sama. Padding yang sama bermaksud tensor output dan tensor input harus mempunyai tinggi dan lebar yang sama. Tensorflow akan menambahkan angka nol pada baris dan lajur untuk memastikan ukuran yang sama.

Anda menggunakan fungsi pengaktifan Relu. Saiz output adalah [28, 28, 14].

Langkah 4: Lapisan kolam

Langkah seterusnya selepas konvolusi adalah perhitungan penyatuan. Pengiraan penyatuan akan mengurangkan dimensi data. Anda boleh menggunakan modul max_pooling2d dengan ukuran 2x2 dan langkah 2. Anda menggunakan lapisan sebelumnya sebagai input. Saiz output akan [batch_size, 14, 14, 14]

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

Langkah 5: Lapisan Konvolusi Kedua dan Lapisan Pengumpulan

Lapisan konvolusional kedua mempunyai 32 penapis, dengan ukuran keluaran [batch_size, 14, 14, 32]. Lapisan penyatuan mempunyai 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 bersambung sepenuhnya. Peta ciri harus diratakan sebelum dihubungkan dengan lapisan yang padat. Anda boleh menggunakan pembentukan semula modul dengan ukuran 7 * 7 * 36.

Lapisan yang padat akan menghubungkan 1764 neuron. Anda menambah fungsi pengaktifan Relu. Selain itu, anda menambah istilah regulatorisasi putus sekolah dengan kadar 0.3, yang bermaksud 30 peratus berat akan ditetapkan ke 0. Perhatikan bahawa, putus sekolah berlaku hanya semasa fasa latihan. Fungsi cnn_model_fn mempunyai mod argumen untuk menyatakan apakah model itu perlu dilatih atau dinilai.

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

Akhirnya, anda boleh menentukan lapisan terakhir dengan ramalan model. Bentuk keluarannya sama dengan ukuran kumpulan dan 10, jumlah gambar.

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

Anda boleh membuat kamus yang mengandungi kelas dan kebarangkalian setiap kelas. Modul tf.argmax () dengan mengembalikan nilai tertinggi jika logit berlapis. Fungsi softmax mengembalikan kebarangkalian setiap kelas.

predictions = {# Generate predictions"classes": tf.argmax(input=logits, axis=1),"probabilities": tf.nn.softmax(logits, name="softmax_tensor") }

Anda hanya mahu mengembalikan ramalan diksi apabila mod ditetapkan ke ramalan. Anda menambahkan kod ini untuk menghilangkan ramalan

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

Langkah seterusnya adalah untuk mengira kehilangan model. Dalam tutorial terakhir, anda mengetahui bahawa fungsi kerugian untuk model multiclass adalah cross entropy. Kerugian dengan mudah dikira dengan kod berikut:

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

Langkah terakhir adalah mengoptimumkan model, iaitu mencari nilai timbang terbaik. Untuk itu, anda menggunakan pengoptimum keturunan Gradien dengan kadar pembelajaran 0.001. Objektifnya adalah untuk mengurangkan 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. Walau bagaimanapun, anda ingin memaparkan metrik prestasi semasa mod penilaian. Metrik prestasi untuk model multikelas adalah metrik ketepatan. Tensorflow dilengkapi dengan ketepatan modul dengan dua argumen, label, dan nilai yang diramalkan.

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 sahaja. Anda membuat CNN pertama anda dan anda bersedia untuk membungkus semuanya ke dalam fungsi untuk menggunakannya untuk melatih dan menilai 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 adalah sama dengan tutorial sebelumnya.

Pertama sekali, anda menentukan penganggar dengan model CNN.

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

CNN memerlukan banyak kali untuk melatih, oleh itu, anda membuat cangkuk Logging untuk menyimpan nilai-nilai lapisan softmax setiap 50 lelaran.

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

Anda sudah bersedia untuk menganggar model. Anda menetapkan ukuran kumpulan 100 dan mengubah data. Perhatikan bahawa kami menetapkan langkah latihan sebanyak 16.000, memerlukan banyak masa untuk melatih. Bersabarlah.

# 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])

Sekarang modelnya sudah siap, anda boleh menilai 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 seni bina semasa, anda mendapat ketepatan 97%. Anda boleh mengubah seni bina, ukuran kumpulan dan bilangan lelaran untuk meningkatkan ketepatan. Rangkaian saraf CNN telah menunjukkan prestasi yang jauh lebih baik daripada ANN atau regresi logistik. Dalam tutorial rangkaian saraf tiruan, anda mempunyai ketepatan 96%, yang lebih rendah dari CNN. Persembahan CNN sangat mengagumkan dengan set gambar yang lebih besar , baik dari segi pengiraan kelajuan dan ketepatan.

Ringkasan

Rangkaian saraf konvolusioner berfungsi dengan baik untuk menilai gambar. Jenis seni bina ini dominan untuk mengenali objek dari gambar atau video.

Untuk membina CNN, anda perlu mengikuti enam langkah:

Langkah 1: Lapisan input:

Langkah ini membentuk semula data. Bentuknya sama dengan punca kuasa dua bilangan piksel. Contohnya, jika gambar memiliki 156 piksel, maka bentuknya adalah 26x26. Anda perlu menentukan sama ada gambar itu mempunyai warna atau tidak. Sekiranya ya, maka anda mempunyai 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

Seterusnya, anda perlu membuat lapisan konvolusional. Anda menggunakan penapis yang berbeza untuk membolehkan rangkaian mempelajari ciri penting. Anda menentukan ukuran kernel dan jumlah penapis.

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

Langkah 3: Lapisan kolam

Pada langkah ketiga, anda menambah lapisan penyatuan. Lapisan ini mengurangkan ukuran input. Ia melakukannya dengan mengambil nilai maksimum sub-matriks. Sebagai contoh, jika sub-matriks adalah [3,1,3,2], penyatuan akan mengembalikan maksimum, iaitu 3.

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

Langkah 4: Tambahkan Lapisan Konvolusional dan Lapisan Penyatuan

Dalam langkah ini, anda boleh menambahkan seberapa banyak yang anda mahukan lapisan penukaran dan lapisan penyatuan. Google menggunakan seni bina dengan lebih daripada 20 lapisan penukaran.

Langkah 5: Lapisan padat

Langkah 5 meratakan yang sebelumnya untuk membuat lapisan yang bersambung sepenuhnya. Dalam langkah ini, anda boleh menggunakan fungsi pengaktifan yang berbeza dan menambahkan kesan 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: Lapisan Logit

Langkah terakhir adalah ramalan.

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