Tutorial Convolutional Neural Networks (CNN) dengan TensorFlow

Bayangkan Anda berada di kebun binatang dan mencoba mengenali apakah seekor hewan adalah cheetah atau macan tutul. Sebagai manusia, otak Anda dapat menganalisis ciri tubuh dan wajah dengan mudah untuk menarik kesimpulan yang tepat. Dengan cara yang sama, Convolutional Neural Networks (CNN) dapat dilatih untuk melakukan tugas pengenalan yang sama, apa pun kerumitan polanya. Hal ini membuatnya sangat kuat di bidang computer vision. 

Tutorial CNN konseptual ini akan dimulai dengan memberikan gambaran tentang apa itu CNN dan pentingnya dalam machine learning. Lalu Anda akan dituntun melalui implementasi CNN langkah demi langkah di TensorFlow Framework 2.

Apa itu CNN?

Convolutional Neural Network (CNN atau ConvNet) adalah algoritma deep learning yang secara khusus dirancang untuk tugas apa pun di mana pengenalan objek sangat penting seperti klasifikasi, deteksi, dan segmentasi gambar.  Banyak aplikasi nyata, seperti mobil swa-kemudi, kamera pengawas, dan lainnya, menggunakan CNN. 

Pentingnya CNN

Berikut beberapa alasan mengapa CNN penting, seperti disorot di bawah ini:

• Tidak seperti model machine learning tradisional seperti SVM dan decision tree yang memerlukan ekstraksi fitur manual, CNN dapat melakukan ekstraksi fitur otomatis dalam skala besar, sehingga efisien. 
• Lapisan konvolusi membuat CNN bersifat translasi-invariant, artinya mereka dapat mengenali pola dari data dan mengekstrak fitur terlepas dari posisinya, baik gambar diputar, diskalakan, maupun digeser.
• Banyak model CNN pralatih seperti VGG-16, ResNet50, Inceptionv3, dan EfficientNet terbukti mencapai hasil mutakhir dan dapat di-fine-tune pada tugas baru menggunakan jumlah data yang relatif kecil. 
• CNN juga dapat digunakan untuk masalah klasifikasi non-gambar dan tidak terbatas pada pemrosesan bahasa alami, analisis deret waktu, dan pengenalan suara.

Arsitektur CNN

Arsitektur CNN mencoba meniru struktur neuron pada sistem visual manusia yang tersusun dari banyak lapisan, di mana masing-masing bertanggung jawab mendeteksi fitur tertentu pada data.  Seperti diilustrasikan pada gambar di bawah, CNN tipikal terdiri dari kombinasi empat lapisan utama: 

• Lapisan konvolusi
• Rectified Linear Unit (disingkat ReLU)
• Lapisan pooling
• Lapisan fully connected 

Mari pahami bagaimana setiap lapisan ini bekerja menggunakan contoh klasifikasi digit tulisan tangan berikut.

Lapisan konvolusi

Ini adalah blok bangunan pertama CNN. Sesuai namanya, tugas matematis utama yang dilakukan adalah konvolusi, yaitu penerapan fungsi jendela geser pada matriks piksel yang merepresentasikan sebuah gambar. Fungsi geser yang diterapkan pada matriks disebut kernel atau filter, dan keduanya dapat digunakan bergantian. 

Pada lapisan konvolusi, beberapa filter dengan ukuran yang sama diterapkan, dan setiap filter digunakan untuk mengenali pola tertentu dari gambar, seperti lengkungan digit, tepi, bentuk keseluruhan digit, dan lainnya. 

Mari kita pertimbangkan gambar skala abu-abu 32x32 dari digit tulisan tangan ini. Nilai pada matriks diberikan untuk tujuan ilustrasi.

Selain itu, mari kita pertimbangkan kernel yang digunakan untuk konvolusi. Ini adalah matriks berukuran 3x3. Bobot setiap elemen kernel direpresentasikan pada kisi. Bobot nol ditunjukkan pada kisi hitam dan bobot satu pada kisi putih. 

Apakah kita harus mencari bobot ini secara manual? 

Dalam praktiknya, bobot kernel ditentukan selama proses pelatihan jaringan saraf. 

Dengan menggunakan dua matriks ini, kita dapat melakukan operasi konvolusi dengan menerapkan dot product, dan bekerja sebagai berikut: 

1. Terapkan matriks kernel dari sudut kiri atas ke kanan.
2. Lakukan perkalian elemen demi elemen.  
3. Jumlahkan nilai hasil perkalian.
4. Nilai yang dihasilkan merupakan nilai pertama (sudut kiri atas) pada matriks hasil konvolusi.
5. Geser kernel ke bawah sesuai ukuran langkah geser (stride).
6. Ulangi dari langkah 1 sampai 5 hingga matriks gambar tertutup seluruhnya.

Dimensi matriks hasil konvolusi bergantung pada ukuran langkah geser. Semakin besar langkah geser, semakin kecil dimensinya.

Nama lain yang terkait dengan kernel dalam literatur adalah feature detector karena bobotnya dapat diatur untuk mendeteksi fitur tertentu pada gambar masukan. 

Misalnya: 

• Kernel perata-rata piksel tetangga dapat digunakan untuk mengaburkan gambar masukan.
• Kernel pengurangan tetangga digunakan untuk melakukan deteksi tepi.

Semakin banyak lapisan konvolusi yang dimiliki jaringan, semakin baik lapisan tersebut dalam mendeteksi fitur yang lebih abstrak. 

Fungsi aktivasi

Fungsi aktivasi ReLU diterapkan setelah setiap operasi konvolusi. Fungsi ini membantu jaringan mempelajari hubungan non-linear antarfitur pada gambar, sehingga membuat jaringan lebih andal dalam mengidentifikasi pola yang berbeda. Ini juga membantu mengurangi masalah vanishing gradient. 

Lapisan pooling

Tujuan lapisan pooling adalah mengambil fitur paling signifikan dari matriks hasil konvolusi. Ini dilakukan dengan menerapkan beberapa operasi agregasi, yang mengurangi dimensi peta fitur (matriks hasil konvolusi), sehingga mengurangi penggunaan memori saat melatih jaringan.  Pooling juga relevan untuk mengurangi overfitting.

Fungsi agregasi yang paling umum diterapkan adalah: 

• Max pooling yaitu nilai maksimum dari peta fitur
• Sum pooling yaitu penjumlahan semua nilai pada peta fitur
• Average pooling yaitu nilai rata-rata dari semua nilai. 

Di bawah ini adalah ilustrasi untuk masing-masing contoh sebelumnya: 

Selain itu, dimensi peta fitur menjadi lebih kecil saat fungsi pooling diterapkan. 

Lapisan pooling terakhir melakukan flatten pada peta fiturnya agar dapat diproses oleh lapisan fully connected. 

Lapisan fully connected

Lapisan-lapisan ini berada di bagian akhir convolutional neural network,  dan  masukan mereka adalah matriks satu dimensi hasil flatten yang dihasilkan oleh lapisan pooling terakhir. Fungsi aktivasi ReLU diterapkan untuk non-linearitas. 

Terakhir, lapisan prediksi softmax digunakan untuk menghasilkan nilai probabilitas bagi masing-masing label keluaran yang mungkin, dan label akhir yang diprediksi adalah yang memiliki skor probabilitas tertinggi. 

Dropout 

Dropout adalah teknik regularisasi yang diterapkan untuk meningkatkan kemampuan generalisasi jaringan saraf dengan jumlah parameter besar. Ini dilakukan dengan menjatuhkan (menonaktifkan) beberapa neuron secara acak selama proses pelatihan, yang memaksa neuron yang tersisa mempelajari fitur baru dari data masukan.  

Karena implementasi teknis akan dilakukan menggunakan TensorFlow 2, bagian berikut bertujuan memberikan gambaran lengkap tentang berbagai komponen framework ini untuk membangun model deep learning secara efisien. 

Apa itu Framework TensorFlow?

Google mengembangkan TensorFlow pada November 2015. Mereka mendefinisikannya sebagai framework machine learning open-source untuk semua orang karena beberapa alasan. 

• Open-source: dirilis di bawah lisensi open-source Apache 2.0. Ini memungkinkan peneliti, organisasi, dan pengembang berkontribusi pada pustaka dengan membangunnya tanpa batasan. 
• Framework machine learning: artinya memiliki seperangkat pustaka dan alat yang mendukung proses pembangunan model machine learning.
• Untuk semua orang: Menggunakan TensorFlow mempermudah implementasi model machine learning melalui bahasa pemrograman umum seperti Python. Selain itu, pustaka bawaan seperti Keras membuat pembuatan model deep learning yang andal menjadi lebih mudah. 

Semua fungsionalitas ini menjadikan TensorFlow kandidat yang baik untuk membangun jaringan saraf. 

Selain itu, memasang TensorFlow 2 sangat mudah dan dapat dilakukan sebagai berikut menggunakan pengelola paket Python pip seperti dijelaskan dalam dokumentasi resmi. 

Setelah pemasangan, kita dapat melihat versi yang digunakan adalah 2.9.1

import tensorflow as tf
print("TensorFlow version:", tf.__version__)

Sekarang, mari kita telusuri lebih jauh komponen utama untuk membuat jaringan tersebut. 

Apa itu Tensor?

Kita terutama berurusan dengan data berdimensi tinggi saat membangun model machine learning dan deep learning. Tensor adalah array multi-dimensi dengan tipe seragam yang digunakan untuk merepresentasikan berbagai fitur data. 

Di bawah ini adalah representasi grafis dari berbagai jenis dimensi tensor. 

• Tensor berdimensi 0 berisi satu nilai tunggal.
• Tensor berdimensi 1, juga dikenal sebagai tensor “rank-1”, adalah daftar nilai. 
• Tensor berdimensi 2 adalah tensor “rank-2”.
• Akhirnya, kita dapat memiliki tensor berdimensi N, di mana N mewakili jumlah dimensi dalam tensor. Pada kasus sebelumnya, N masing-masing adalah 0, 1, dan 2.

Berikut ilustrasi tensor berdimensi nol hingga tiga. Setiap tensor dibuat menggunakan fungsi constant() dari TensorFlow. 

# Zero dimensional tensor
zero_dim_tensor = tf.constant(20)
print(zero_dim_tensor)

# One dimensional tensor
one_dim_tensor = tf.constant([12, 20, 53, 26, 11, 56])
print(one_dim_tensor)

# Two dimensional tensor
two_dim_array = [[3, 6, 7, 5],
             	[9, 2, 3, 4],
             	[7, 1, 10,6],
             	[0, 8, 11,2]]

two_dim_tensor = tf.constant(two_dim_array)
print(two_dim_tensor)

Eksekusi kode sebelumnya yang berhasil akan menghasilkan keluaran di bawah, dan kita dapat melihat kata kunci “tf.Tensor” yang berarti hasilnya adalah tensor. Ia memiliki tiga parameter:

• Nilai aktual dari tensor.
• bentuk (shape) tensor, yaitu 0, 6 kali 1, dan 4 kali 4, masing-masing untuk tensor pertama, kedua, dan ketiga.
• Tipe data yang direpresentasikan oleh atribut dtype, dan semua tensor bertipe int32.

Tutorial TensorFlow untuk Pemula kami memberikan gambaran lengkap tentang TensorFlow dan mengajarkan cara membangun dan melatih model.

Tensor vs Matriks: Perbedaan

Banyak orang menyamakan tensor dengan matriks. Meskipun keduanya tampak serupa, mereka memiliki sifat yang sama sekali berbeda. Bagian ini memberikan pemahaman yang lebih baik tentang perbedaan antara matriks dan tensor.

• Kita dapat menganggap matriks sebagai tensor dengan hanya dua dimensi. 
• Tensor, di sisi lain, adalah format yang lebih umum yang dapat memiliki jumlah dimensi berapa pun.

Berbeda dengan matriks, tensor lebih cocok untuk masalah deep learning karena alasan berikut: 

• Mereka dapat menangani jumlah dimensi apa pun, yang membuatnya lebih sesuai untuk data multi-dimensi.
• Kemampuan tensor untuk kompatibel dengan beragam tipe data, bentuk, dan dimensi membuatnya lebih serbaguna daripada matriks.
• TensorFlow menyediakan dukungan GPU dan TPU untuk mempercepat komputasi. Dengan menggunakan tensor, engineer machine learning dapat secara otomatis memanfaatkan manfaat ini.
• Tensor secara native mendukung broadcasting, yaitu melakukan operasi aritmatika antara tensor dengan bentuk berbeda, yang tidak selalu mungkin saat berurusan dengan matriks.  

TensorFlow: Constants, Variables, dan Placeholders

Constant bukan satu-satunya jenis tensor. Ada juga variable dan placeholder, yang semuanya merupakan blok bangunan dari computational graph. 

Computational graph pada dasarnya adalah representasi urutan operasi dan aliran data di antaranya. 

Sekarang, mari pahami perbedaan antara jenis-jenis tensor ini.

Constants

Constant adalah tensor yang nilainya tidak berubah selama eksekusi computational graph. Mereka dibuat menggunakan fungsi tf.constant() dan terutama digunakan untuk menyimpan parameter tetap yang tidak memerlukan perubahan selama pelatihan model.

Variables

Variable adalah tensor yang nilainya dapat diubah selama eksekusi computational graph dan dibuat menggunakan fungsi tf.Variable(). Misalnya, dalam jaringan saraf, bobot dan bias dapat didefinisikan sebagai variable karena perlu diperbarui selama proses pelatihan. 

Placeholders

Ini digunakan pada versi pertama TensorFlow sebagai wadah kosong yang tidak memiliki nilai spesifik. Mereka hanya digunakan untuk “memesan tempat” bagi data yang akan digunakan di masa depan. Ini memberi pengguna kebebasan untuk menggunakan dataset dan ukuran batch berbeda selama pelatihan dan validasi model.

Dalam TensorFlow versi 2, placeholder telah digantikan oleh fungsi tf.function(), yang merupakan pendekatan yang lebih Pythonik dan dinamis untuk memasukkan data ke dalam computational graph. 

Implementasi CNN Langkah demi Langkah

Mari mempraktikkan semua yang telah kita pelajari. Bagian ini akan mengilustrasikan implementasi ujung-ke-ujung convolutional neural network di TensorFlow yang diterapkan pada dataset CIFAR-10, yaitu dataset bawaan dengan karakteristik berikut: 

• Berisi 60.000 gambar berwarna 32 kali 32
• Dataset memiliki 10 kelas berbeda
• Setiap kelas memiliki 6000 gambar
• Terdapat total 50.000 gambar pelatihan 
• Dan total 10.000 gambar pengujian

Kode sumber artikel tersedia di workspace DataCamp

Arsitektur jaringan

Sebelum masuk ke implementasi teknis, mari pahami terlebih dahulu arsitektur keseluruhan jaringan yang akan diimplementasikan. 

• Masukan model adalah tensor 32x32x3, masing-masing untuk lebar, tinggi, dan kanal. 
• Kita akan memiliki dua lapisan konvolusi. Lapisan pertama menerapkan 32 filter berukuran 3x3 masing-masing dan fungsi aktivasi ReLU. Dan yang kedua menerapkan 64 filter berukuran 3x3
• Lapisan pooling pertama akan menerapkan max pooling 2x2
• Lapisan pooling kedua juga akan menerapkan max pooling 2x2
• Lapisan fully connected akan memiliki 128 unit dan fungsi aktivasi ReLU
• Terakhir, keluaran akan berupa 10 unit yang sesuai dengan 10 kelas, dan fungsi aktivasinya adalah softmax untuk menghasilkan distribusi probabilitas.

Memuat dataset

Dataset bawaan dimuat dari keras.datasets() sebagai berikut: 

(train_images, train_labels), (test_images, test_labels) = cf10.load_data()

Eksplorasi Data

Pada bagian ini, kita akan fokus hanya pada menampilkan beberapa contoh gambar karena kita sudah mengetahui proporsi setiap kelas pada data pelatihan dan pengujian. 

Fungsi pembantu show_images() menampilkan total 12 gambar secara default dan menerima tiga parameter utama: 

• Gambar pelatihan
• Nama kelas
• Dan label pelatihan.

import matplotlib.pyplot as plt

def show_images(train_images,
            	class_names,
            	train_labels,
            	nb_samples = 12, nb_row = 4):
    
	plt.figure(figsize=(12, 12))
	for i in range(nb_samples):
    	plt.subplot(nb_row, nb_row, i + 1)
    	plt.xticks([])
    	plt.yticks([])
    	plt.grid(False)
    	plt.imshow(train_images[i], cmap=plt.cm.binary)
    	plt.xlabel(class_names[train_labels[i][0]])
	plt.show()

Sekarang, kita dapat memanggil fungsi tersebut dengan parameter yang diperlukan. 

class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
           	'dog', 'frog', 'horse', 'ship', 'truck']

show_images(train_images, class_names, train_labels)

Eksekusi kode sebelumnya yang berhasil menghasilkan gambar di bawah ini. 

Prapemrosesan data

Sebelum melatih model, kita perlu menormalkan nilai piksel data dalam rentang yang sama (misalnya 0 hingga 1). Ini adalah langkah prapemrosesan umum saat berurusan dengan gambar untuk memastikan invariansi skala, dan konvergensi yang lebih cepat selama pelatihan. 

max_pixel_value = 255

train_images = train_images / max_pixel_value
test_images = test_images / max_pixel_value

Selain itu, kita melihat bahwa label direpresentasikan dalam format kategorikal seperti cat, horse, bird, dan seterusnya. Kita perlu mengonversinya ke format numerik agar dapat diproses dengan mudah oleh jaringan saraf.

from tensorflow.keras.utils import to_categorical
train_labels = to_categorical(train_labels, len(class_names))
test_labels = to_categorical(test_labels, len(class_names))

Implementasi arsitektur model

Langkah berikutnya adalah mengimplementasikan arsitektur jaringan berdasarkan deskripsi sebelumnya. 

Pertama, kita mendefinisikan model menggunakan kelas Sequential(), dan setiap lapisan ditambahkan ke model dengan fungsi add(). 

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

# Variables
INPUT_SHAPE = (32, 32, 3)
FILTER1_SIZE = 32
FILTER2_SIZE = 64
FILTER_SHAPE = (3, 3)
POOL_SHAPE = (2, 2)
FULLY_CONNECT_NUM = 128
NUM_CLASSES = len(class_names)

# Model architecture implementation
model = Sequential()
model.add(Conv2D(FILTER1_SIZE, FILTER_SHAPE, activation='relu', input_shape=INPUT_SHAPE))
model.add(MaxPooling2D(POOL_SHAPE))
model.add(Conv2D(FILTER2_SIZE, FILTER_SHAPE, activation='relu'))
model.add(MaxPooling2D(POOL_SHAPE))
model.add(Flatten())
model.add(Dense(FULLY_CONNECT_NUM, activation='relu'))
model.add(Dense(NUM_CLASSES, activation='softmax'))

Setelah menerapkan fungsi summary() pada model, kita mendapatkan ringkasan komprehensif arsitektur model dengan informasi tentang setiap lapisan, jenisnya, bentuk keluaran, dan total jumlah parameter yang dapat dilatih. 

Pelatihan model

Semua sumber daya akhirnya tersedia untuk mengonfigurasi dan memicu pelatihan model. Ini dilakukan masing-masing dengan fungsi compile() dan fit() yang menerima parameter berikut: 

• Optimizer bertanggung jawab memperbarui bobot dan bias model. Dalam kasus kita, kita menggunakan optimizer Adam. 
• Fungsi loss digunakan untuk mengukur kesalahan klasifikasi, dan kita menggunakan Crosentropy().
• Terakhir, metrics digunakan untuk mengukur kinerja model, dan accuracy, precision, serta recall akan ditampilkan pada kasus kita.

from tensorflow.keras.metrics import Precision, Recall

BATCH_SIZE = 32
EPOCHS = 30

METRICS = metrics=['accuracy',
               	Precision(name='precision'),
               	Recall(name='recall')]

model.compile(optimizer='adam',
          	loss='categorical_crossentropy',
          	metrics = METRICS)

# Train the model
training_history = model.fit(train_images, train_labels,
                	epochs=EPOCHS, batch_size=BATCH_SIZE,
                	validation_data=(test_images, test_labels))

Evaluasi model

Setelah pelatihan model, kita dapat membandingkan kinerjanya pada dataset pelatihan dan pengujian dengan memplot metrik di atas menggunakan fungsi pembantu show_performance_curve() dalam dua dimensi. 

• Sumbu horizontal (x) adalah jumlah epoch
• Sumbu vertikal (y) adalah kinerja model yang mendasari. 
• Kurva merepresentasikan nilai metrik pada epoch tertentu.

Untuk visualisasi yang lebih baik, garis merah vertikal digambar melalui titik potong nilai kinerja pelatihan dan validasi bersama dengan nilai optimal.

def show_performance_curve(training_result, metric, metric_label):
    
	train_perf = training_result.history[str(metric)]
	validation_perf = training_result.history['val_'+str(metric)]
	intersection_idx = np.argwhere(np.isclose(train_perf,
                                            	validation_perf, atol=1e-2)).flatten()[0]
	intersection_value = train_perf[intersection_idx]
    
	plt.plot(train_perf, label=metric_label)
	plt.plot(validation_perf, label = 'val_'+str(metric))
	plt.axvline(x=intersection_idx, color='r', linestyle='--', label='Intersection')
    
	plt.annotate(f'Optimal Value: {intersection_value:.4f}',
         	xy=(intersection_idx, intersection_value),
         	xycoords='data',
         	fontsize=10,
         	color='green')
            	 
	plt.xlabel('Epoch')
	plt.ylabel(metric_label)
	plt.legend(loc='lower right')

Lalu, fungsi diterapkan untuk accuracy dan precision model.

show_performance_curve(training_history, 'accuracy', 'accuracy')

show_performance_curve(training_history, 'precision', 'precision')

Setelah melatih model tanpa fine-tuning dan prapemrosesan apa pun, kita memperoleh:  

• Skor akurasi 67,09%, yang berarti model mengklasifikasikan dengan benar 67 sampel dari setiap 100 sampel. 
• Dan presisi 76,55%, yang berarti dari setiap 100 prediksi positif, hampir 77 di antaranya adalah positif benar, dan 23 sisanya positif palsu. 
• Skor ini dicapai masing-masing pada epoch ketiga dan kedua untuk akurasi dan presisi.

Kedua metrik ini memberikan pemahaman global tentang perilaku model. 

Bagaimana jika kita ingin mengetahui untuk setiap kelas mana yang baik diprediksi model dan mana yang masih sulit?

Ini dapat dicapai dari confusion matrix, yang menunjukkan untuk setiap kelas jumlah prediksi benar dan salah. Implementasinya diberikan di bawah. Kita mulai dengan membuat prediksi pada data uji, kemudian menghitung confusion matrix dan menampilkan hasil akhirnya.

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

test_predictions = model.predict(test_images)

test_predicted_labels = np.argmax(test_predictions, axis=1)

test_true_labels = np.argmax(test_labels, axis=1)

cm = confusion_matrix(test_true_labels, test_predicted_labels)

cmd = ConfusionMatrixDisplay(confusion_matrix=cm)

cmd.plot(include_values=True, cmap='viridis', ax=None, xticks_rotation='horizontal')
plt.show()

• Kelas 0, 1, 6, 7, 8, 9, masing-masing untuk airplane, automobile, frog, horse, ship, dan truck memiliki nilai tertinggi pada diagonal. Ini berarti model lebih baik dalam memprediksi kelas-kelas tersebut. 
• Di sisi lain, tampaknya model kesulitan dengan kelas yang tersisa:  
• Kelas dengan nilai off-diagonal tertinggi adalah kelas yang membuat model keliru dengan kelas yang benar. Misalnya, model keliru menganggap birds (kelas 2) sebagai airplane, dan automobile sebagai trucks (kelas 9).

Pelajari lebih lanjut tentang confusion matrix dari tutorial kami memahami confusion matrix di R, yang mengambil materi dari kursus Machine Learning toolbox DataCamp.

Model ini dapat ditingkatkan dengan tugas tambahan seperti:  

• Augmentasi gambar
• Transfer learning menggunakan model pralatih seperti ResNet, MobileNet, atau VGG. Tutorial transfer learning kami menjelaskan apa itu transfer learning dan beberapa penerapannya dalam kehidupan nyata.
• Menerapkan berbagai teknik regularisasi seperti L1, L2, atau dropout.  
• Fine-tuning berbagai hyperparameter seperti learning rate, ukuran batch, jumlah lapisan dalam jaringan. 

Kesimpulan

Artikel ini telah membahas gambaran lengkap CNN di TensorFlow, memberikan detail tentang setiap lapisan arsitektur CNN. Selain itu, artikel ini memberikan pengantar singkat tentang TensorFlow dan bagaimana ia membantu engineer dan peneliti machine learning membangun jaringan saraf yang canggih. 

Kami menerapkan semua keterampilan ini pada skenario dunia nyata terkait tugas klasifikasi multikelas.  

Panduan pemula untuk object detection kami bisa menjadi langkah berikut yang baik untuk memperdalam pembelajaran Anda tentang computer vision. Panduan ini membahas komponen kunci dalam object detection dan menjelaskan cara mengimplementasikannya di SSD dan Faster RCNN yang tersedia di TensorFlow.