TensorFlow adalah sebuah perpustakaan software sumber terbuka yang digunakan untuk

mesin belajar dalam berbagai macam tugas pemahaman persepsi dan bahasa. TensorFlow
adalah API generasi kedua, menggantikan DistBelief (API generasi pertama) yang digunakan
oleh 50 tim yang berbeda untuk penelitian dan pengembangan puluhan produk komersial
milik Google, seperti Speech Recognition, Gmail, Google Image, dan Google Search.
TensorFlow pada awalnya dikembangkan oleh Brain Google Team untuk tujuan penelitian
dan produksi Google, kemudian dirilis dengan sumber terbuka di bawah lisensi Apache 2.0
pada 9 November 2015. TensorFlow berjalan di platform Linux dan Mac OS X.
http://freakermedia.blogspot.com/2016/01/pengertian-tensorflow_26.html

Panduan Awal TF: Toolkit

Perkiraan Waktu: 4 menit

Tensorflow adalah sebuah framework komputasional untuk membuat model machine

learning. TensorFlow menyediakan berbagai toolkit yang memungkinkan Anda membuat
model pada tingkat abstraksi yang Anda sukai. Anda dapat menggunakan API dengan tingkat
yang lebih rendah untuk membuat model dengan menentukan serangkaian operasi matematis.
Sebagai alternatif, Anda dapat menggunakan API dengan tingkat yang lebih tinggi (seperti
tf.estimator ) untuk menentukan arsitektur yang telah ditetapkan, seperti regresi linier atau
jaringan neural.

Gambar berikut menunjukkan hierarki toolkit TensorFlow saat ini:

Gambar 1. Hierarki toolkit TensorFlow.

Tabel berikut berisi ringkasan tujuan dari berbagai lapisan:

Toolkit Deskripsi

Estimator (tf.estimator) API tingkat tinggi yang berorientasi objek.

tf.layers/tf.losses/tf.metrics Library untuk komponen model umum.

TensorFlow API dengan tingkat lebih rendah

TensorFlow terdiri dari dua komponen berikut:

 buffer protokol grafik

 waktu proses yang menjalankan grafik (terdistribusi)
Kedua komponen ini bersifat analog terhadap kode Python dan penafsir Python. Sama seperti
penafsir Python yang diterapkan pada beberapa platform hardware untuk menjalankan kode
Python, TensorFlow dapat menjalankan grafik pada beberapa platform hardware, termasuk
CPU, GPU, dan TPU.

API mana yang harus Anda gunakan? Anda harus menggunakan tingkat abstraksi tertinggi
yang dapat memecahkan masalah. Tingkat abstraksi yang lebih tinggi lebih mudah
digunakan, tetapi juga (berdasarkan desain) kurang fleksibel. Sebaiknya mulai dengan API
tingkat tertinggi terlebih dahulu dan pastikan semuanya berfungsi. Jika Anda memerlukan
fleksibilitas tambahan untuk beberapa masalah pemodelan khusus, berpindahlah ke satu
tingkat lebih rendah. Perhatikan bahwa setiap tingkat dibuat menggunakan API di tingkat
yang lebih rendah, sehingga menurunkan hierarki seharusnya cukup mudah.

tf.estimator API
Kita akan menggunakan tf.estimator untuk sebagian besar latihan di Kursus Singkat Machine
Learning. Segala hal yang akan Anda lakukan dalam latihan ini dapat dilakukan di
TensorFlow dengan tingkat yang lebih rendah (mentah), tetapi menggunakan tf.estimator
secara drastis menurunkan jumlah baris kode.

tf.estimator kompatibel dengan scikit-learn API. Scikit-learn adalah library ML open-source

yang sangat populer di Python, dengan lebih 100 ribu pengguna, termasuk di Google.

Secara umum, inilah kode-pseudo (pseudo-code) untuk program klasifikasi linier yang
diterapkan dalam tf.estimator:

import tensorflow as tf

# Set up a linear classifier.

classifier = tf.estimator.LinearClassifier(feature_columns)

# Train the model on some example data.

classifier.train(input_fn=train_input_fn, steps=2000)

# Use it to predict.
predictions = classifier.predict(input_fn=predict_input_fn)

https://developers.google.com/machine-learning/crash-course/first-steps-with-
tensorflow/toolkit?hl=id
Pembelajaran Mesin IoT 11 April 2018

Menggunakan TensorFlow untuk IoT

Industri: Yang Perlu Anda Ketahui
Sekarang
TensorFlow adalah pustaka pembelajaran mesin yang dapat digunakan untuk aplikasi seperti
jaringan saraf dalam aplikasi riset dan komersial. Awalnya dikembangkan oleh tim Google
Brain untuk penggunaan internal, sekarang tersedia untuk semua orang di bawah lisensi open
source Apache 2.0 . TensorFlow terus berkembang pesat sejak dirilis pada 2015, dengan lebih
dari 21.000 komitmen sejauh ini, banyak dari kontributor luar .

Dalam posting ini, kita akan melihat bagaimana TensorFlow dan pembelajaran mesin secara
umum dapat diterapkan pada bisnis di berbagai jenis industri serta beberapa aplikasi
teknologi IoT.
Pembelajaran Mesin dalam Konteks

Semakin banyak perangkat terhubung ke internet , lebih mudah dari sebelumnya untuk
mengekstrak data berharga dari mereka.

Akibatnya, teknologi pembelajaran mesin mengalami percepatan dengan cepat,

memungkinkan beragam kasus penggunaan di berbagai industri.

Salah satu metode pembelajaran mesin yang sangat berguna disebut pembelajaran dalam .
Pembelajaran mendalam menggunakan algoritma pembelajaran yang disebut jaringan saraf
untuk memproses informasi. Hal ini memungkinkan komputer untuk mengidentifikasi pola
dalam data dan mendefinisikan hubungan antara sistem input dan output yang kompleks, di
antara tugas-tugas lainnya.

Untuk memasukkan ini ke dalam konteks, pikirkan tentang jaringan saraf di otak manusia.
Ketika neuron tertentu diaktifkan oleh rangsangan seperti cahaya atau suara, mereka
mengirimkan sinyal listrik yang memproses rangsangan tersebut menjadi penglihatan dan
pendengaran.

Bahkan, jaringan saraf biologis menginspirasi desain jaringan saraf tiruan!

Semua Tentang Menggunakan TensorFlow

Dukungan kuat TensorFlow untuk pembelajaran mendalam serta algoritma pembelajaran
mesin hanyalah salah satu dari banyak keunggulan kerangka kerja ini.

Contoh lain adalah arsitektur Tensorflow . Ini memungkinkan perhitungan numerik

berkinerja tinggi untuk digunakan di berbagai platform serta komputer dan perangkat seluler,
server, dan perangkat tepi.

Sumber Gambar

Selain itu, kerangka kerja ini menawarkan berbagai bahasa pemrograman, serta fungsionalitas
untuk pengembang berpengalaman dan pemula .

Akhirnya, selain menjadi platform penyajian yang paling maju dibandingkan dengan
kerangka pembelajaran mesin lainnya, dukungan signifikan Tensorflow dari Google telah
membuatnya menjadi pemimpin pasar yang terbukti.

Semua fitur ini memungkinkan TensorFlow berada di posisi terbaik untuk memberikan
perubahan dari pembelajaran mesin di lab ke penggunaan di dunia nyata.

Beberapa Penggunaan Yang Dikutip Secara Umum Untuk

TensorFlow
TensorFlow digunakan untuk berbagai aplikasi berbeda dari deteksi bahasa, hingga
pengenalan gambar , dan analisis deret waktu. Ada sejumlah contoh yang sering dikutip yang
menunjukkan kemampuan produk dan menggambarkan betapa beragamnya aplikasi
pembelajaran dalam dunia nyata.

Kasus Penyortir Mentimun Jepang Yang Terkenal

Sumber gambar

Salah satu contoh TensorFlow yang paling berkesan dalam aksi adalah penyortir mentimun
Makoto Koike . Makoto menggunakan kemampuan pengenalan gambar TensorFlow untuk
menyortir mentimun dengan kualitas, menghemat jam kerja untuk keluarganya setiap hari.

Tentu saja, pengenalan gambar berguna untuk berbagai industri dan aplikasi. Berikut adalah
daftar beberapa contoh dunia nyata dari teknologi ini yang sedang beraksi:


o Perusahaan media sosial menggunakan algoritma pengenalan objek untuk
penandaan foto.


o Para ilmuwan menggunakan pembelajaran mendalam untuk memfasilitasi analisis
gambar untuk aplikasi pencitraan seperti mikroskop.

 Toko eceran dapat menggunakan deteksi objek untuk menciptakan pengalaman checkout
yang lebih cerdas , mirip dengan toko Amazon Go .

Ada banyak industri lain yang mulai menggunakan pengenalan gambar dan objek termasuk
perawatan kesehatan, penerbangan, otomotif, dan eksplorasi ruang angkasa.
 Paket Penghematan Tagihan Energi Google

Anda mungkin terkejut mendengar bahwa Google khawatir tentang biaya tagihan energi
mereka. Tetapi kenyataannya adalah, penggunaan daya di pusat data adalah masalah besar
bagi banyak perusahaan besar, menelan biaya ratusan juta dolar setiap tahun.

Tapi bayangkan jika Anda bisa mengurangi konsumsi daya hingga 15%.

Google melakukannya. Bagaimana?

Nah, bersama dengan praktik terbaik lainnya, mereka menggunakan pembelajaran mesin
untuk memanfaatkan data sensor yang ada untuk memodelkan kinerja dan meningkatkan
efisiensi energi .

Mereka merancang jaringan saraf untuk melihat data dari sekitar 120 variabel yang berbeda
di pusat data dan mencari metode pendinginan, kecepatan pompa, temperatur, dan lainnya
yang lebih efisien untuk mengoptimalkan operasi mereka.

Seperti yang ditunjukkan dalam bagan di atas, Pusat Daya Efektivitas Penggunaan Data
(PUE) Google telah menurun secara signifikan sejak upaya dimulai pada tahun 2008. Pusat
data Google sekarang termasuk yang paling efisien di dunia.

TensorFlow dan IoT Industri: Pemeliharaan Prediktif dan

Melampaui
Kemampuan untuk bekerja mundur dari tujuan akhir tanpa perlu menentukan variabel yang
diperlukan untuk mencapai tujuan itu adalah salah satu aplikasi teknologi pembelajaran
mesin yang paling berharga.

Untuk menempatkan ini dalam konteks, pikirkan tentang banyak elemen dan variabel yang
dapat mempengaruhi proses yang terlibat dalam pembuatan kompleks dan operasi industri
lainnya.

Hal-hal seperti suhu , kelembaban, penggunaan daya, dan kecepatan kipas, antara lain semua
dapat memiliki efek pada operasi sistem.

Dengan pembelajaran mesin, perusahaan dapat menetapkan tujuan, misalnya, pengurangan

daya, dan algoritme akan dapat mengetahui elemen dan variabel mana yang penting dalam
mencapai tujuan itu. Ini mengurangi kebutuhan akan pengetahuan domain dalam memilah-
milah set data untuk menemukan yang paling penting.

Selain itu, TensorFlow (dan pembelajaran mesin secara umum) dapat menawarkan mengintip
ke masa depan dengan melihat data yang dikumpulkannya dan memperkirakan peristiwa di
masa mendatang berdasarkan informasi tersebut. Prediksi juga akan semakin akurat seiring
berjalannya waktu dan lebih banyak data yang berasimilasi.

Kemampuan 'peningkatan diri' dari algoritma ini bersama dengan sensor yang terhubung
dapat memberikan wawasan berharga bagi perusahaan di semua jenis industri terutama dalam
hal pemeliharaan prediktif.

Bahkan, menurut laporan dari McKinsey , kemampuan pembelajaran mesin seperti perawatan
prediktif akan membantu perusahaan menghemat $ 630 miliar pada tahun 2025.

Penggunaan, Kemampuan, dan Manfaat Tanpa Batas

Memanfaatkan TensorFlow dan IIoT bersama-sama dapat memungkinkan pengguna untuk:

  Meramalkan kemungkinan kegagalan perangkat
 Memprediksi masa pakai peralatan yang tersisa
 Lihat penyebab kegagalannya
 Kurangi waktu perawatan
 Menginformasikan penyesuaian proses waktu-nyata
 Mendeteksi anomali
 … Dan banyak lagi

Bayangkan sebuah dunia di mana Anda bisa menjadwalkan perawatan mesin Anda sebelum
rusak, menghilangkan elemen kejutan dan menjaga waktu henti menjadi minimum .

Bayangkan bisa benar-benar memperpanjang siklus hidup peralatan dengan menjalankannya

pada pengaturan yang paling optimal.

Bayangkan berapa banyak hal ini dapat mengurangi biaya menjalankan operasi Anda.

Dari penghitung mentimun hingga deteksi objek hingga pemeliharaan prediktif,

kemungkinan, aplikasi, dan kasus penggunaan TensorFlow hampir tidak terbatas.

Ingin tahu tentang bagaimana TensorFlow, pembelajaran mesin, dan IIoT dapat membantu
bisnis Anda? Hubungi Temboo hari ini untuk mempelajari lebih lanjut tentang solusi IoT
Industri kami untuk perusahaan dari semua ukuran. Dan pastikan untuk mengikuti kami di
Twitter , Instagram , Facebook , LinkedIn , YouTube , dan Medium untuk berita IIoT,
pembaruan, cerita, dan banyak lagi!

https://blog.temboo.com/using-tensorflow-for-iot/

Ikhtisar
Edit Catatan Istilah Ini

Tensorflow
Definisi
R
e
TensorFlow? adalah pustaka perangkat lunak sumber terbuka untuk perhitungan numerik
s
menggunakan grafik aliran data.
m
i

Node dalam grafik mewakili operasi matematika, sedangkan tepi grafik mewakili array data
multidimensi (tensor) yang dikomunikasikan di antara mereka. Arsitektur fleksibel
memungkinkan Anda untuk menyebarkan komputasi ke satu atau lebih CPU atau GPU di
desktop, server, atau perangkat seluler dengan satu API. TensorFlow pada awalnya
dikembangkan oleh para peneliti dan insinyur yang bekerja di Tim Google Brain dalam organisasi
penelitian Machine Intelligence Google untuk keperluan melakukan pembelajaran mesin dan
P penelitian jaringan saraf yang dalam, tetapi sistem ini cukup umum untuk dapat diterapkan di
r berbagai domain lain seperti baik.
a
https://www.iotone.com/term/tensorflow/t678
kt
is

Rekaman sesi TensorFlow dari O’Reilly AI Conference

San Francisco 2018
20 November 2018
Oleh Marcus Chang, Developer Relations Program Manager

O’Reilly AI Conference, San Francisco Pada bulan September, tim TensorFlow mempresentasikan
dua hari pembicaraan terkait TensorFlow pada O’Reilly AI Conference di San Francisco yang
mencakup topik meliputi TensorFlow Lite, TensorFlow.js, TFX (Extended) & Hub, Distributed
TensorFlow, dan banyak lagi! Rekaman sesi sekarang tersedia di saluran YouTube TensorFlow
kami bila Anda ingin melihatnya. Lihat semua playlist di sini. Sesi: Mem-build AI dengan
TensorFlow: Ringkasan TensorFlow adalah salah satu project open source terbesar di dunia, dan
tingkat adopsi serta fungsionalitasnya terus berkembang. Kami membagikan pengembangan
utama terbaru dan memperjelas langkah-langkah pada masa mendatang, serta mendiskusikan
bagaimana Anda bisa lebih terlibat dalam komunitas TensorFlow. TensorFlow: Machine Learning
untuk Programmer Dalam pembicaraan ini, Laurence Moroney dari Google berbicara tentang
Machine Learning, AI, Deep Learning, dan banyak lagi, serta bagaimana mereka cocok digunakan
dengan toolkit programmer. Dia memperkenalkan semua hal ini, menjelaskan hype, untuk
menunjukkan peluang yang tersedia dalam Machine Learning. Dia juga memperkenalkan
TensorFlow, dan bagaimana framework-nya yang dirancang untuk menjadikan Machine Learning
mudah dan bisa diakses, dan bagaimana aplikasi cerdas yang menggunakan ML dapat berjalan di
berbagai platform termasuk seluler, web, dan IoT. TensorFlow untuk JavaScript TensorFlow.js
adalah TensorFlow versi JavaScript yang baru saja dirilis yang berjalan di browser dan Node.js.
Dalam pembicaraan ini, tim memperkenalkan framework ML TensorFlow.js, dan menunjukkan
demo tentang cara melakukan alur kerja machine-learning lengkap, termasuk pelatihan,
penerapan sisi klien, dan pembelajaran transfer. Swift untuk TensorFlow Swift untuk TensorFlow
menggabungkan fleksibilitas Eager Execution dengan kinerja Grafik dan Sesi yang tinggi. Di
belakang layar, Swift menganalisis kode Tensor dan secara otomatis mem-build grafik untuk
Anda. Swift juga menangkap error ketik dan ketidakcocokan bentuk sebelum menjalankan kode
Anda, memiliki kemampuan untuk mengimpor library Python, dan memiliki Diferensiasi Otomatis
terintegrasi-bahasa. Kami percaya bahwa fitur machine learning sangat penting sehingga mereka
layak mendapatkan compiler dan bahasa kelas satu. TensorFlow Lite TensorFlow Lite adalah
framework machine-learning ringan yang bisa melakukan inferensi pada berbagai perangkat kecil
dan seluler (dari ponsel, Raspberry Pi dan pengontrol mikro). Ini juga menyediakan abstraksi
sederhana yang memungkinkan Anda untuk mengakses akselerator AI. Tim berbicara tentang
dasar-dasar framework, status pengembangan saat ini dan pengembangan terbaru. Dalam sesi
ini, Anda akan mempelajari konsep cara menyiapkan model untuk seluler, dan cara menulis kode
yang mengeksekusinya di berbagai platform yang berbeda. TensorFlow Extended (TFX) & Hub
Dalam sesi ini tim memperkenalkan TensorFlow Extended (TFX), platform machine learning end-
to-end untuk TensorFlow yang mendukung semua produk di Alphabet. Seiring dengan
berkembangnya machine learning dari eksperimen hingga melayani beban kerja produksi, begitu
juga kebutuhannya untuk secara efektif mengelola alur kerja produksi dan pelatihan end-to-end
termasuk manajemen model, pembuatan versi, dan penyajian. Cloud TPU Pembicaraan ini
memberikan Anda pemahaman teknis yang mendalam mengenai akselerator Cloud TPU Google,
serta cara memprogramnya. Ini juga mencakup abstraksi pemrograman yang memungkinkan
Anda menjalankan model pada CPU, GPU, dan Cloud TPU, dari satu perangkat hingga seluruh
pod Cloud TPU. TensorFlow Autograph TensorFlow AutoGraph secara otomatis mengonversi
kode Python biasa menjadi TensorFlow yang setara, menggunakan transformasi kode sumber.
Pendekatan kami bersifat komplementer dengan project Eager TensorFlow yang baru dan akan
memperbolehkan penggunaan model imperatif dari mode Eager, selagi mempertahankan
keuntungan mode grafik. Dengan menggunakan konversi kode otomatis, developer bisa menulis
kode yang lebih ringkas, efisien, dan kuat. TensorFlow Probability TensorflowProbability (TFP)
adalah library TF/Python yang menawarkan pendekatan modern pada fitur probabilitas/statistik
tradisional & yang baru muncul. Ahli statistik/data scientist akan menemukan kemampuan
seperti-R yang secara natural memanfaatkan hardware modern. Peneliti/praktisi ML akan
menemukan blok building yang kuat untuk menentukan dan mempelajari model probabilistik
yang mendalam. Dalam pembicaraan ini, kami memperkenalkan abstraksi TFP inti dan
mendemonstrasikan beberapa kemudahan dan kekuatan pemodelannya. Deep learning untuk
sains dasar menggunakan komputasi berkinerja tinggi Sains dasar (termasuk fisika partikel dan
kosmologi) menghasilkan data berukuran beberapa exabyte dari instrumen kompleks dan
menganalisisnya untuk mengungkap rahasia alam semesta. Deep learning memungkinkan
eksploitasi langsung data instrumen berdimensi lebih tinggi dari sebelumnya, sehingga
meningkatkan sensitivitas penemuan baru. Dalam pembicaraan ini, pembicara tamu kami Wahid
Bhimji (NERSC) menjelaskan aktivitas terbaru di bidang ini, terutama di NERSC, pusat
superkomputer misi untuk sains dasar AS, yang berbasis di Berkeley National Lab. Pekerjaan ini
memanfaatkan dan mem-build di Tensorflow untuk mengeksplorasi metode dan aplikasi baru;
memanfaatkan skala komputasi berkinerja tinggi; dan menyediakan lingkungan deep learning
yang produktif bagi para ilmuwan fundamental. Tensor2Tensor Tensor2Tensor adalah library
dataset dan model deep learning, yang memfasilitasi pembuatan model terkini untuk berbagai
aplikasi ML, seperti penerjemahan, penguraian kalimat, pemberian teks gambar dan banyak lagi,
yang memungkinkan eksplorasi berbagai ide jauh lebih cepat daripada yang sebelumnya.
Distributed TensorFlow Pembicaraan ini menunjukkan bagaimana melakukan pelatihan
TensorFlow terdistribusi menggunakan API tingkat tinggi Keras. Tim akan menjelaskan arsitektur
terdistribusi TensorFlow, cara menyiapkan kluster terdistribusi menggunakan Kubeflow dan
Kubernetes, dan cara mendistribusikan model yang dibuat di Keras.

https://developers-id.googleblog.com/2018/11/rekaman-sesi-tensorflow-dari-oreilly-ai.html

CARA KERJA

How Tensorflow work

March 27, 2018 Artificial Intelligence, Python, Tensorflow

Google’s Tensorflow memiliki cara unik untuk memecahkan masalah. Cara unik ini memungkinkan
kita untuk memecahkan masalah belajar sangat efisien mesin. Pembelajaran mesin digunakan
dalam hampir semua bidang kehidupan dan pekerjaan, tetapi beberapa daerah yang lebih terkenal
computer vision, speech recognition, language translations, dan healthcare.

Pada awalnya, perhitungan dalam TensorFlow mungkin tampak sia-sia dan rumit. Tetapi ada
alasan untuk itu karena bagaimana TensorFlow memperlakukan komputasi, mengembangkan
algoritma yang lebih rumit adalah relatif mudah. Tutorial ini akan membimbing kita melalui
pseudocode algoritma TensorFlow.

Di sini kita akan memperkenalkan aliran umum algoritma TensorFlow. Kebanyakan tutorial akan
mengikuti garis besar ini:

1. Import atau menghasilkan dataset

Semua algoritma Machine Learning akan tergantung pada dataset. Pada artikel selanjutnya kita
akan menghasilkan data atau menggunakan sumber luar dataset. Kadang-kadang itu lebih baik
untuk bergantung pada data yang dihasilkan karena kita hanya ingin tahu hasil yang diharapkan.

2. Mengubah dan menormalisasi data

Biasanya, masukan dataset tidak datang dalam bentuk yang diharapkan TensorFlow jadi kita perlu
mengubah TensorFlow mereka menjadi bentuk yang bisa diterima. Data ini biasanya tidak dalam
dimensi yang benar atau jenis yang diharapkan oleh algoritma. Kita akan mentransform data
sebelum dapat menggunakannya. TensorFlow memiliki fungsi builtin yang dapat menormalisasi
data sebagai berikut:

data = tf.nn.batch_norm_with_global_normalization(...)

3. Partisi dataset (train,test and validation sets)

Kita umumnya ingin menguji algoritma pada sets berbeda yang telah dilatih. Juga, banyak
algoritma memerlukan hyperparameter tuning, sehingga kita menyisihkan validation set yang
ditetapkan untuk menentukan set terbaik hyperparameters.

4. Tetapkan parameter algoritma (hyperparameters)

Algoritma kita biasanya memiliki satu set parameter yang kita jalankan konstan sepanjang
prosedur. Misalnya, ini bisa menjadi jumlah iterasi, tingkat belajar atau parameter tetap lainnya
yang kita pilih. Hal ini dianggap bentuk yang baik untuk menginisialisasi parameter bersama-sama
sehingga pembaca atau pengguna dapat dengan mudah menemukan mereka, sebagai berikut:

learning_rate = 0,01
batch_size = 100
iterasi = 1000

5. Inisialisasi variabel dan pengganti

TensorFlow tergantung pada mengetahui apa yang dapat dan tidak dapat diubah. TensorFlow
akan mengubah/menyesuaikan variabel dan berat/bias selama optimasi untuk meminimalkan
kehilangan fungsi. Untuk mencapai hal ini, kita feed data melalui placeholders. Kita perlu untuk
menginisialisasi kedua variabel dan pengganti dengan ukuran dan jenis, sehingga TensorFlow
tahu apa yang diharapkan. TensorFlow juga perlu tahu jenis data yang diharapkan, kita akan
menggunakan float32. Lihat kode berikut:

a_var = tf.constant(42)
x_input = tf.placeholder (tf.float32, [None, input_size])
y_input = tf.placeholder (tf.float32, [None, num_classes])

6. Mendefinisikan struktur model

Setelah kita memiliki data, dan telah menginisialisasi variabel dan placeholders, kita bisa
menentukan model. Hal ini dilakukan dengan membangun sebuah grafik komputasi. TensorFlow
memilih operasi dan nilai-nilai harus variabel dan placeholders untuk sampai pada hasil model.
Model kita untuk contoh ini akan menjadi suatu model linier:

y_pred = tf.add (tf.mul (x_input, weight_matrix), b_matrix)

7. Loss function

Setelah menentukan model, kita harus dapat mengevaluasi output. Ini adalah dimana kita
mendeklarasikan loss function. Loss function sangat penting karena itu memberitahu kita
seberapa jauh prediksi kita dari nilai yang sebenarnya.

loss = tf.reduce_mean(tf.square(y_actual – y_pred))

8. Inisialisasi dan train model

Sekarang setelah kita memiliki segalanya, kita perlu membuat turunan dari grafik kita, feed pada
data melalui placeholder, dan biarkan TensorFlow mengubah variabel untuk memprediksi data
pelatihan kita menjadi lebih baik. Berikut ini salah satu cara untuk menginisialisasi
grafik komputasional:

with tf.Session(graph=graph) as session:

...
session.run(...)
...

Kita juga bisa menggunakan :

session = tf.Session(graph=graph) session.run(…)

9. Evaluasi model
Setelah kita membangun dan melatih model, kita harus mengevaluasi model dengan melihat
seberapa baik hal itu dengan data baru melalui beberapa kriteria yang ditentukan. Kita
mengevaluasi pada set train dan test kemudian evaluasi ini akan memungkinkan kita untuk melihat
apakah model adalah underfit atau overfit.
10. Tune hyperparameters
Sebagian besar waktu, kita ingin kembali dan mengubah beberapa hyperparamters, berdasarkan
kinerja model. Kita kemudian ulangi langkah sebelumnya dengan hyperparameters berbeda dan
mengevaluasi model pada set validasi.

11. Deploy/memprediksi hasil baru

Hal ini juga penting untuk mengetahui bagaimana untuk membuat prediksi pada data baru. Kita
dapat melakukan ini dengan semua model kita, setelah kita telah melatih mereka.

http://thinkstudioo.blogspot.com/2018/03/how-tensorflow-work.html

TensorFlow - Custom Object Detection

API
Thursday, Jan 25, 2018

Deep Learning

2043 word 10 min read

Contents
 Mempersiapkan Dataset
o Membuat struktur direktori
o Membuat Annotation
o Convert XML ke CSV
o Convert TFRecord
o Membuat Label Map
o Konfiguras Pipeline
 Training Model
o Grafik TensorBoard
o Evaluation / Testing
o Export Graph
 Mencoba Hasil Model
o Pengujian via Jupyter Notebook
o Pengujian via Webcam

Tutorial ini adalah lanjutan dari tutorial TensorFlow - Object Detection API yang
membahas tentang penggunaan API untuk deteksi objek menggunakan TensorFlow, pada
tutorial sebelumnya terdapat permasalahan yaitu objek yang dikenali hanya objek umum
saja dan model yang kita gunakan adalah model yang sudah di-training oleh seseorang
yang kita tidak tahu bagaimana prosesnya, maka pada tutorial ini menjawab pertanyaan
pada tutorial sebelumnya yaitu “Bagaimana jika kita ingin mendeteksi objek khusus yang
kita tentukan sendiri?”.

Tutorial ini membahas bagaimana cara menggunakan objek yang kita tentukan sendiri
yaitu pada kasus ini adalah deteksi objek Tanda Nomor Kendaraan Bermotor (TNKB)
atau yang sering disebut Plat Nomor.

Mempersiapkan Dataset
Jika kita ingin mengenali objek “khusus” yang ingin kita deteksi, tentu kita memerlukan
dataset untuk proses training, sehingga Neural Network yang akan kita latih untuk
mengenali objek tersebut dapat mengenali objek yang kita maksud. Penulis sudah
menyiapkan dataset yang kita butuhkan yaitu dataset gambar Plat Nomor sebanyak 502
beserta annotationnya, 472 untuk training dan 30 untuk testing/validation. Namun jika
anda bermaksud untuk mendeteksi objek yang anda tentukan sendiri silahkan
mengumpulkan dataset tersebut minimal 100 gambar.

Jika ingin menggunakan dataset yang sudah penulis siapkan silahkan unduh disini yang
berukuran 102MB. Unduh file annotations.zip dan images.zip saja dan langsung ke
tahap Training. Tapi jika ingin menggunakan dataset sendiri langsung menuju tahap
Membuat Annotation dibawah ini.

Membuat struktur direktori

Struktur direktori berikut ini digunakan untuk menyimpan konfigurasi dan dataset
annotation maupun gambar yang akan kita gunakan untuk proses training

1 $ mkdir data
2 $ mkdir {images,annotations}/{train,test}

Membuat Annotation
Untuk memuat annotation atau memberikan label pada gambar kita akan menggunakan
aplikasi LabelImg yang nantinya akan disimpan kedalam file XML dengan format
PASCAL VOC Cara membuat anotasinya :

1. Buka aplikasi labelImg

2. Klik tombol “OpenDir”
3. Pilih direktori dataset gambar
4. Klik tombol “Create RectBox” untuk membuat kotak area objek yang akan dikenali
5. Arahkan kursos dan tarik area kotak disekitar objek
6. Lalu akan muncul kotak dialog untuk memberikan nama label dari objek yang akan kita
kenali
7. Simpan hasil pelabelan dengan menekan tombol CTRL+S
8. Pilih direktori penyimpanan file hasil pelabelan *.xml

Note: Nama label objek yang dikenali harus sama Case Sensitive.
Simpan hasilnya kedalam direktori yang sama dengan data gambar
Convert XML ke CSV
Dataset annotation yang kita buat diatas menggunakan aplikasi labelImg perlu dikonversi
dari format .xml ke .csv yang nantinya akan digunakan untuk mengenerate berkas
TFRecord, berikut kode untuk mengkonversi format berkas yang kita butuhkan

1 import os
2 import glob
3 import pandas as pd
4 import xml.etree.ElementTree as ET
5 def xml_to_csv(path):
6 xml_list = []
7 for xml_file in glob.glob(path + '/*.xml'):
8 tree = ET.parse(xml_file)
9 root = tree.getroot()
10 for member in root.findall('object'):
11 value = (root.find('filename').text,
12 int(root.find('size')[0].text),
13 int(root.find('size')[1].text),
14 member[0].text,
15 int(member[4][0].text),
16 int(member[4][1].text),
17 int(member[4][2].text),
18 int(member[4][3].text)
19 )
20 xml_list.append(value)
21 column_name = ['filename', 'width', 'height', 'class', 'xmin',
22 'ymin', 'xmax', 'ymax']
23 xml_df = pd.DataFrame(xml_list, columns=column_name)
24 return xml_df
25 def main():
26 for directory in ['train', 'test']:
27 image_path = os.path.join(os.getcwd(),
28 'annotations/{}'.format(directory))
29 xml_df = xml_to_csv(image_path)
30 xml_df.to_csv('data/{}_labels.csv'.format(directory),
31 index=None)
32 print('Successfully converted xml to csv.')
33 main()

Simpan kode program diatas dengan nama xml_to_csv.py. Lalu jalankan perintah
dibawah ini untuk mengkonversi file XML ke CSV.

1 $ python3 xml_to_csv.py

Convert TFRecord
Pada saat proses training, pertama-tama TensorFlow akan membaca data input dan proses
ini dinamakan feeding data yang dijalankan melalui fungsi feed_dictionary, fungsi
tersebut secara langsung mengambil informasi dataset yang telah kita siapkan dalam
format TFRecord maka dari itu kita perlu men-generate data annotation yang telah kita
konversi ke .csv tadi kedalam format TFRecord. Berikut ini adalah kode untuk men-
generate file TFRecord
1
from __future__ import division
2
from __future__ import print_function
3
from __future__ import absolute_import
4
import os
5
import io
6
import pandas as pd
7
import tensorflow as tf
8
from PIL import Image
9
from object_detection.utils import dataset_util
10
from collections import namedtuple, OrderedDict
11
flags = tf.app.flags
12
flags.DEFINE_string('type', '', 'Type of CSV input (train/test)')
13
flags.DEFINE_string('csv_input', '', 'Path to the CSV input')
14
flags.DEFINE_string('output_path', '', 'Path to output TFRecord')
15
FLAGS = flags.FLAGS
16
def class_text_to_int(row_label):
17
if row_label == 'plate':
18
return 1
19
else:
20
None
21
def split(df, group):
22
data = namedtuple('data', ['filename', 'object'])
23
gb = df.groupby(group)
24
return [data(filename, gb.get_group(x)) for filename, x in
25
zip(gb.groups.keys(), gb.groups)]
26
def create_tf_example(group, path):
27
with tf.gfile.GFile(os.path.join(path,
28
'{}'.format(group.filename)), 'rb') as fid:
29
encoded_jpg = fid.read()
30
encoded_jpg_io = io.BytesIO(encoded_jpg)
31
image = Image.open(encoded_jpg_io)
32
width, height = image.size
33
filename = group.filename.encode('utf8')
34
image_format = b'jpg'
35
xmins = []
36
xmaxs = []
37
ymins = []
38
ymaxs = []
39
classes_text = []
40
classes = []
41
for index, row in group.object.iterrows():
42
xmins.append(row['xmin'] / width)
43
xmaxs.append(row['xmax'] / width)
44
ymins.append(row['ymin'] / height)
45
ymaxs.append(row['ymax'] / height)
46
classes_text.append(row['class'].encode('utf8'))
47
classes.append(class_text_to_int(row['class']))
48
tf_example =
49
tf.train.Example(features=tf.train.Features(feature={
50
'image/height': dataset_util.int64_feature(height),
51
'image/width': dataset_util.int64_feature(width),
52
'image/filename': dataset_util.bytes_feature(filename),
53
'image/source_id': dataset_util.bytes_feature(filename),
54
'image/encoded': dataset_util.bytes_feature(encoded_jpg),
55
'image/format': dataset_util.bytes_feature(image_format),
56
'image/object/bbox/xmin':
57
dataset_util.float_list_feature(xmins),
58
'image/object/bbox/xmax':
59
dataset_util.float_list_feature(xmaxs),
60
61 'image/object/bbox/ymin':
62 dataset_util.float_list_feature(ymins),
63 'image/object/bbox/ymax':
64 dataset_util.float_list_feature(ymaxs),
65 'image/object/class/text':
66 dataset_util.bytes_list_feature(classes_text),
67 'image/object/class/label':
68 dataset_util.int64_list_feature(classes),
69 }))
70 return tf_example
71 def main(_):
72 writer = tf.python_io.TFRecordWriter(FLAGS.output_path)
73 path = os.path.join(os.getcwd(), 'images/{}'.format(FLAGS.type))
74 examples = pd.read_csv(FLAGS.csv_input)
75 grouped = split(examples, 'filename')
76 for group in grouped:
77 tf_example = create_tf_example(group, path)
78 writer.write(tf_example.SerializeToString())
79 writer.close()
80 output_path = os.path.join(os.getcwd(), FLAGS.output_path)
81 print('Successfully created the TFRecords:
82 {}'.format(output_path))
83 if __name__ == '__main__':
tf.app.run()

Simpan kode program diatas dengan nama generate_tfrecord.py. Kemudian jalankan

perintah dibawah ini untuk men-generate TFRecord file.

$ python3 generate_tfrecord.py --type=train --

1 csv_input=data/train_labels.csv --output_path=data/train.record
2 // dan
3 $ python3 generate_tfrecord.py --type=test --
csv_input=data/test_labels.csv --output_path=data/test.record

Membuat Label Map

Berikut ini adalah konfigurasi untuk memetakan label yang akan kita gunakan untuk
memberikan penamaan pada objek yang akan kita deteksi. Jika objek yang akan kita
deteksi ada lebih dari satu objek maka buat item sebanyak objek yang akan kita deteksi
dan id maupun name harus menyesuaikan dokumentasi, namun pada kasus ini kita akan
mendeteksi hanya untuk satu objek saja. Berikut konfigurasi label map yang akan kita
gunakan

1 item {
2 id: 1
3 name: 'plate'
4}

Simpan konfigurasi label map tersebut dengan nama plate_number_map.pbtxt kedalam

folder data.

Konfiguras Pipeline
Karena tensorflow menggunakan ProtoBuf maka kita perlu membuat konfigurasi pipeline
dan kita akan menggunakan konfigurasi dari SSD with Mobilenet v1 yang digunakan oleh
Oxford-IIIT untuk Dataset hewan peliharaan. Contoh konfigurasi dapat dilihat disini.

1 model {
2 ssd {
3 num_classes: 1
4 box_coder {
5 faster_rcnn_box_coder {
6 y_scale: 10.0
7 x_scale: 10.0
8 height_scale: 5.0
9 width_scale: 5.0
10 }
11 }
12 matcher {
13 argmax_matcher {
14 matched_threshold: 0.5
15 unmatched_threshold: 0.5
16 ignore_thresholds: false
17 negatives_lower_than_unmatched: true
18 force_match_for_each_row: true
19 }
20 }
21 similarity_calculator {
22 iou_similarity {
23 }
24 }
25 anchor_generator {
26 ssd_anchor_generator {
27 num_layers: 6
28 min_scale: 0.2
29 max_scale: 0.95
30 aspect_ratios: 1.0
31 aspect_ratios: 2.0
32 aspect_ratios: 0.5
33 aspect_ratios: 3.0
34 aspect_ratios: 0.3333
35 }
36 }
37 image_resizer {
38 fixed_shape_resizer {
39 height: 300
40 width: 300
41 }
42 }
43 box_predictor {
44 convolutional_box_predictor {
45 min_depth: 0
46 max_depth: 0
47 num_layers_before_predictor: 0
48 use_dropout: false
49 dropout_keep_probability: 0.8
50 kernel_size: 1
51 box_code_size: 4
52 apply_sigmoid_to_scores: false
53 conv_hyperparams {
54 activation: RELU_6,
55 regularizer {
56 l2_regularizer {
57 weight: 0.00004
58 }
59 }
60 initializer {
61 truncated_normal_initializer {
62 stddev: 0.03
63 mean: 0.0
64 }
65 }
66 batch_norm {
67 train: true,
68 scale: true,
69 center: true,
70 decay: 0.9997,
71 epsilon: 0.001,
72 }
73 }
74 }
75 }
76 feature_extractor {
77 type: 'ssd_mobilenet_v1'
78 min_depth: 16
79 depth_multiplier: 1.0
80 conv_hyperparams {
81 activation: RELU_6,
82 regularizer {
83 l2_regularizer {
84 weight: 0.00004
85 }
86 }
87 initializer {
88 truncated_normal_initializer {
89 stddev: 0.03
90 mean: 0.0
91 }
92 }
93 batch_norm {
94 train: true,
95 scale: true,
96 center: true,
97 decay: 0.9997,
98 epsilon: 0.001,
99 }
100 }
101 }
102 loss {
103 classification_loss {
104 weighted_sigmoid {
105 anchorwise_output: true
106 }
107 }
108 localization_loss {
109 weighted_smooth_l1 {
110 anchorwise_output: true
111 }
112 }
113 hard_example_miner {
114 num_hard_examples: 3000
115 iou_threshold: 0.99
116 loss_type: CLASSIFICATION
117 max_negatives_per_positive: 3
118 min_negatives_per_image: 0
119 }
120 classification_weight: 1.0
121 localization_weight: 1.0
122 }
123 normalize_loss_by_num_matches: true
124 post_processing {
125 batch_non_max_suppression {
126 score_threshold: 1e-8
127 iou_threshold: 0.6
128 max_detections_per_class: 100
129 max_total_detections: 100
130 }
131 score_converter: SIGMOID
132 }
133 }
134 }
135 train_config: {
136 batch_size: 4
137 optimizer {
138 rms_prop_optimizer: {
139 learning_rate: {
140 exponential_decay_learning_rate {
141 initial_learning_rate: 0.004
142 decay_steps: 800720
143 decay_factor: 0.95
144 }
145 }
146 momentum_optimizer_value: 0.9
147 decay: 0.9
148 epsilon: 1.0
149 }
150 }
151 fine_tune_checkpoint:
152 "ssd_mobilenet_v1_coco_2017_11_17/model.ckpt"
153 from_detection_checkpoint: true
154 num_steps: 100000
155 data_augmentation_options {
156 random_horizontal_flip {
157 }
158 }
159 data_augmentation_options {
160 ssd_random_crop {
161 }
162 }
163 }
164 train_input_reader: {
165 tf_record_input_reader {
166 input_path: "data/train.record"
167 }
168 label_map_path: "data/plate_number_map.pbtxt"
169 }
170 eval_config: {
171 num_examples: 30
172 max_evals: 10
173 }
174 eval_input_reader: {
175 tf_record_input_reader {
176 input_path: "data/test.record"
177 }
178 label_map_path: "data/plate_number_map.pbtxt"
179 shuffle: false
180 num_readers: 1
181 num_epochs: 1
182 }
183
184
185

Simpan file konfigurasi diatas dengan nama plate_number_v1.config kedalam folder

training.

Konfigurasi diatas menggunakan batch_size=4 dan num_steps=100000 pada komputer

penulis dengan spesifikasi 8 Core CPU, 1 GPU, dan RAM 16GB, nilai tersebut cukup
berhasil untuk mendeteksi objek Plat Nomor, tapi sebaiknya nilai tersebut disesuaikan
dengan spesifikasi komputer yang anda gunakan. Jika komputer yang anda gunakan
mempunyai spesifikasi dibawah komputer yang penulis gunakan maka direkomendasikan
untuk menurunkan nilai batch_size setidaknya batch_size=2 dan num_steps=140000.

Sampai ditahap ini kita sudah selesai menyiapkan semua file yang dibutuhkan pada saat
training model object detection kita.

Note: Pastikan struktur direktori dan file dengan benar.

Berikut sususan akhir direktori yang penulis gunakan :

1 .
2 ├── annotations
3 │ ├── test
4 │ │ ├── IMG-20180108-WA0115.xml
5 │ │ ├── ...
6 │ │ ├── IMG-20180108-WA0120.xml
7 │ │ └── IMG-20180108-WA0121.xml
8 │ └── train
9 │ ├── 100.E 6467 QW-09-20.xml
10 │ ├── ...
11 │ ├── 255.E 6527 OD-02-20.xml
12 │ └── 256.E 4572 SS-01-16.xml
13 ├── data
14 │ ├── plate_number_map.pbtxt
15 │ ├── test.record
16 │ ├── test_labels.csv
17 │ ├── train.record
18 │ └── train_labels.csv
19 ├── images
20 │ ├── test
21 │ │ ├── IMG-20180108-WA0115.jpeg
22 │ │ ├── ...
23 │ │ ├── IMG-20180108-WA0120.jpg
24 │ │ └── IMG-20180108-WA0121.jpg
25 │ └── train
26 │ ├── 100.E 6467 QW-09-20.jpeg
27 │ ├── ...
28 │ ├── 255.E 6527 OD-02-20.jpg
29 │ └── 256.E 4572 SS-01-16.jpg
30 ├── training
31 │ └── plate_number_v1.config
32 ├── generate_tfrecord.py
33 └── xml_to_csv.py
34 8 directories, 1016 files
35

Training Model
Setelah semua file yang dibutuhkan selesai dipersiapkan maka kita akan memasuki tahap
training Neural Network untuk mengenali pola Tanda Nomor Kendaraan Bermotor
(TNKB). Kita perlu menyiapkan TensorFlow Model dan menyalin berkas-berkas yang
kita buat sebelumnya untuk kebutuhan proses training.

1. Salin direktori data, images, dan training yang kita buat sebelumnya ke dalam folder
models/research/object_detection.
2. Setelah semua berkas sudah disalin kita akan menggunakan pre-trained model yang
bernama SSD Mobilnet v1 dari COCO model tersebut bisa diunduh disini, jika sudah
berhasil diunduh lalu ekstrak ssd_mobilenet_v1_coco_2017_11_17.tar.gz
kedalam direktori models/research/object_detection.

Jika kita melihat ke daftar COCO-trained Model maka akan ada banyak model yang
tersedia dan silahkan pilih sendiri mana yang akan kita gunakan untuk training Neural
Network kita, tapi penulis akan memilih yang tercepat yaitu ssd_mobilenet_v1_coco
yang mana kecepatannya sampai 30/milisecond.

Baik! Mari kita mulai training Neural Network, jalankan perintah dibawah ini untuk
memulai proses training.

1 $ python3 train.py \
2 --logtostderr \
3 --train_dir=training \
4 --pipeline_config_path=training/plate_number_v1.config
Tunggu sampai proses training selesai, dikomputer penulis sendiri membutuhkan waktu
sekitar 12 sampai 13 jam untuk proses training ini
Grafik TensorBoard
Untuk melihat grafik selama proses training kita akan menggunakan TensorBoard,
jalankan perintah dibawah ini untuk menjalankan TensorBoard.

1 $ tensorboard --logdir=training

Kurang lebih tampilan TensorBoard akan seperti dibawah ini

Evaluation / Testing
Proses ini untuk mengevaluasi hasil dari tahap proses training sebelumnya, boleh
dilakukan boleh juga tidak tapi direkomendasikan proses ini tetap dilakukan agar model
yang dihasilkan mendapatkan hasil yang bagus

1 $ python3 eval.py \
2 --logtostderr \
3 --pipeline_config_path=training/plate_number_v1.config \
4 --checkpoint_dir=training \
5 --eval_dir=evaluation

Export Graph
Proses training diatas belum sepenuhnya selesai karena tujuan utama dari proses training
Neural Network adalah sebuah model yang akan kita gunakan untuk mendeteksi objek-
objek yang telah kita masukkan sebelumnya, maka dari itu kita perlu mengekspor
modelnya, jalankan perintah berikut untuk mengekspor model.

1 $ python3 export_inference_graph.py \
2 --input_type image_tensor \
3 --pipeline_config_path training/plate_number_v1.config \
4 --trained_checkpoint_prefix training/model.ckpt-100000 \
5 --output_directory plate_number_recognition_model_v1_2018_01_24

Mencoba Hasil Model

Ini adalah tahap terakhir yang kita lalui dan kita akan mencoba menggunakan model yang
telah kita latih untuk mengenali Tanda Nomor Kendaraan Bermotor (TNKB) sebelumnya.

Tahap pengujian berikut ini membutuhkan sampel gambar yang berbeda dari gambar
dataset yang kita gunakan pada proses training dan testing, maka kita perlu untuk
mendapatkan sampel gambar, anda dapat mencarinya via Google Images atau bisa juga
memotret langsung menggunakan kamera sendiri.

Taruh 2 sampel gambar kedalam direktori

models/research/object_detection/test_images dan berikan nama image1.jpg
dan image2.jpg atau replace gambar yang ada.

Pengujian via Jupyter Notebook

Untuk pengujian via Jupyter Notebook kita hanya perlu mengubah MODEL_NAME dengan
model yang telah kita ekspor sebelumnya dan NUM_CLASSES menjadi nilai 1 karena hanya
satu objek yang akan kita deteksi

Ubah kode berikut

1 MODEL_NAME = 'ssd_mobilenet_v1_coco_2017_11_17'
2 MODEL_FILE = MODEL_NAME + '.tar.gz'
3 DOWNLOAD_BASE =
4 'http://download.tensorflow.org/models/object_detection/'
5 PATH_TO_CKPT = MODEL_NAME + '/frozen_inference_graph.pb'
6 PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt')
NUM_CLASSES = 90

Menjadi

MODEL_NAME = 'plate_number_recognition_model_v1_2018_01_24'
1
# MODEL_FILE = MODEL_NAME + '.tar.gz'
2
# DOWNLOAD_BASE =
3
'http://download.tensorflow.org/models/object_detection/'
4
PATH_TO_CKPT = MODEL_NAME + '/frozen_inference_graph.pb'
5
PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt')
6
NUM_CLASSES = 1

Dan hapus bagian berikut ini karena kita tidak perlu mengunduh model
ssd_mobilenet_v1_coco_2017_11_17 karena kita akan menggunakan model yang telah
kita training sendiri

1 opener = urllib.request.URLopener()
2 opener.retrieve(DOWNLOAD_BASE + MODEL_FILE, MODEL_FILE)
3 tar_file = tarfile.open(MODEL_FILE)
4 for file in tar_file.getmembers():
5 file_name = os.path.basename(file.name)
6 if 'frozen_inference_graph.pb' in file_name:
7 tar_file.extract(file, os.getcwd())

Dan hasilnya kurang lebih akan seperti dibawah ini

Pengujian via Webcam
Untuk pengujian model menggunakan webcam langkahnya sama seperti pada pengujian
via Jupyter Notebook yaitu mengubah MODEL_NAME dan NUM_CLASSES kemudian kita
hanya perlu menambahkan beberapa baris kode untuk menggunakan webcam melalui
pustaka OpenCV, langkah ini sama seperti pada tutorial sebelumnya.

Author Imam Digmi

LastMod Thursday, Jan 25, 2018

License CC BY-NC-ND 4.0

tensorflow python deep learning machine learning

https://imamdigmi.github.io/post/tensorflow-custom-object-detection/

Object Detection Menggunakan

Tensorflow-API[Updated 2018–11–16]
Membuat pendeteksi makanan ringan dari minimarket

Hafizhan Aliady Afif

Mar 23, 2018

Well, Asalamualaikum People.

Kali ini saya akan membahas bagaimana cara membuat pendeteksi/ mendeteksi obyek/
objek menggunakan data yang kita buat sendiri.
Tahap 0: Persiapan Sebelum Masuk ke tahap pertama :)

Persiapan Hardware Pc yang saya gunakan untuk melakukan percobaan ini adalah :

 OS : Windows 10 Profesional 64-bit

 CPU : i7–2600 3.4Ghz (4 Core 8 Thread)
 Ram : 8gb DDR3
 GPU : Nvidia GeForce 1060 3gb
 HDD : 1 Tb

Spesifikasi yang di gunakan di atas merupakan rekomendasi dari saya, karena di

berapakali pecobaan di laptop teman yang menggunakan spesifikasi kurang dari itu (i3 ,
ram 4gb,non-gpu) bisa di lakukan namun hal tersebut sangat memberatkan PC sehingga
tidak bisa di gunakan multi-tasking/ngerjain yg lain.

Persiapan Software

 Pake Python!
 Install Tensorflow yang versi terbaru (kalo bisa yang computingnya pake GPU sih :) disini
saya pake TF versi 1.7.0 GPU
 Fork github dari tensorflow Object Detection Disini, buka bagian research kemudian
object detection (Jangan lupa tambahin ke pythonpath nya).
 Atau semua Instalasinya Bisa dilihat disini.
Download Code dan Dataset

 Clone Full Code dan dataset dari github

WorkFlow Object Detection

Pertama, Siapkan dulu data-data foto yang akan di gunakan

Pada cerita kali ini saya akan mennggunakan data foto dari makanan makan ringan yang
tersedia di minimarket. Misalnya seperti Lays, Pocky dan goodtime. Kenapa saya pake
mereka semua(?) ya kalo di tanya alasannya sih saya suka mereka dan akhir akhir ini
sering beli jadi ya objeknya pake barang-barang itu aja biar gampang wkwk.

Untuk data yang saya gunakan itu totalnya ada 1500 an gambar semuanya saya ambil
menggunakan kamera HP.

Kedua, Labeling
Nah, Setelah fotonya selesai di kumpulkan buat semuanya jadi 1 folder kemudian install
modul LabelImg di python kalian. ini di pake buat labeling gambarnya satu satu. disini

Kemudian Buka labelimg nya. kemudian labeling deh satu per-satu ( ini proses paling
melelahkan sih nge labelin 1500 gambar, tapi kalo udah biasa sih ya kerasanya cepet
wkwk)

Contoh Labeling

Nah, nantikan jadinya seperti itu, jika sudah selesai semua file labelnya berupa xml. kalo
bisa sih semuanya jadi satu folder biar mantap. Jadi struktur foldernya kaya gini

+gambar
| +anotasi
| | -img1.xml
| | -img2.xml
| | -...
| | -imgn.xml
| -img1.jpg
| -img2.jpg
| -...
| -imgn.jpg
Ketiga, Mengubah XML menjadi CSV

Nah, pada tahap ini adalah mengubah XML menjadi CSV agar bisa kumpulkan menjadi 1
file yang kemudian di gunakan untuk mengambil data gambar dari box/ label yang telah
di berikan.

import os
import glob
import pandas as pd
import xml.etree.ElementTree as ET
def xml_to_csv(path):
xml_list = []
for xml_file in glob.glob(path + '/*.xml'):
tree = ET.parse(xml_file)
root = tree.getroot()
for member in root.findall('object'):
value = (root.find('filename').text,
int(root.find('size')[0].text),
int(root.find('size')[1].text),
member[0].text,
int(member[4][0].text),
int(member[4][1].text),
int(member[4][2].text),
int(member[4][3].text)
)
xml_list.append(value)
column_name = ['filename', 'width', 'height', 'class', 'xmin',
'ymin', 'xmax', 'ymax']
xml_df = pd.DataFrame(xml_list, columns=column_name)
return xml_df
def main():
image_path = os.path.join(os.getcwd(), 'images/anotation') #nama
folder
xml_df = xml_to_csv(image_path)
xml_df.to_csv('label.csv', index=None) #nama output csv
print('Successfully converted xml to csv.')
main()

Nah itu coding nya, pake python, jangan pake R soalnya ga jalan nanti. di tahap ini yang
perlu di ganti itu di bagian image_path, (dirktori nyimpen anotasi ) dan
ganti_ini.csv (ini file outputnya). itu di ganti pake yang sesuai dengan punya kalian.

Ke-Empat, Membuat Dataset (Memisahkan) Train dan Test

Nah, Setelah jadi dataset csv keseluruhannya, nanti langsung run aja script
split_train_test.py. Nanti datanya lansgung kepisah jadi 80:20 untuk train testnya.

train.csv
test.csv

Ke-5, Membuat TFRecord

Di bagian ini tugas untuk mengumpulkan dataset hampir selesai, jika sudah melakukan
pembuatan data train dan test dalam bentuk CSV maka selanjutnya adalah merubah csv
menjadi dataset yang dapat di baca oleh tensorflow. Yaitu TFRECORD

Caranya mudah karena koding pythonnya sudah ada di TF-API jadi tinggal run aja.
berikut perintahnya untuk data train

jangan lupa untuk merubah kategorinya menjadi kategori yang kalian definisikan di
bagian ini

def class_text_to_int(row_label):
if row_label =='lays':
return 1
elif row_label =='goodtime':
return 2
elif row_label =='pocky':
return 3
else:
return None

Disini row_labelnya di ganti menggunakan obyek yang kalian definisikan labelnya,

harus sesuai ya sama label yang di labelImg , kalo ga sesuai nanti tidak terbaca dongs :))

Lalu untuk untuk menjalankan perintah generate tfrnya jalankan saja script
generate_train_test_record.py

Ke-Six, Mengatur File Config

Nah setelah file tfrecord nya jadi maka selanjutnya adalah membuat(mengatur) file
config, dimana config ini akan di gunakan untuk melakukan konfigurasi dari model
training. Config ini menggunakan model SSD mobile Pet v1 dimana ini di sediakan oleh
tensorflow itu sendiri.

Beberapa bagian yang di ganti di sesuaikan dengan model yang akan kita buat. misalnya
pada bagian ini

model {
ssd {
num_classes: 2
box_coder {
faster_rcnn_box_coder {
y_scale: 10.0
x_scale: 10.0
height_scale: 5.0
width_scale: 5.0
}

Pada bagian num_classes: 3 ini adalah banyaknya obyek yang kita gunakan dalam
membuat model ini misalnya saya menggunakan 3 obyek yaitu lays,pocky dan goodtime.
train_config: {
batch_size: 18
optimizer {
rms_prop_optimizer: {
learning_rate: {
exponential_decay_learning_rate {
initial_learning_rate: 0.004
decay_steps: 800720
decay_factor: 0.95
}
}
momentum_optimizer_value: 0.9
decay: 0.9
epsilon: 1.0
}
}

Kemudian di bagian batch_size bisa di atur sesuai kemampuan ram kalian. Jika
menggunakan ram GPU sebaiknya perhatikan terlebih dahulu ram yang di sediakan oleh
GPU disini saya menggunakan ram 3GB dimana batch size yang di gunakan adalah 18.
dengan batch size ini menggunakan hampir 90% dari total ram GPU.

fine_tune_checkpoint: ""
from_detection_checkpoint: true
num_steps: 60000000000
data_augmentation_options {
random_horizontal_flip {

Pada bagian num_steps silahkan ganti sesuai dengan keinginan atau bisa di hapus saja
untuk proses training yang akan terus menerus berjalan (bisa di stop kok pake ctrl+c )

Sisanya ada di bagian-bagian bawah yang perlu di atur namun semuanya sudah rapih jika
mengikuti dari awal

Ke-6.1 mengatur daftar objek yang akan di gunakan

Disini kita atur dulu labelnya di atas kan label 1 untuk lays, label 2 untuk goodtime dan
label 3 untuk pocky. jadi isi dari file object_detection.pbtext nya itu kaya gini

item {
id: 1
name: 'lays'
}
item {
id: 2
name: 'goodtime'
}
item {
id: 3
name: 'pocky'
}
Ke-Tujuh, Mengatur tata letak file dan folder agar sesuai dengan file config

Pada tahap ini, kira-kira nanti susunan foldernya kaya gini

+data
| - ssd_mobilenet_v1_pet.config
| - object_detection.pbtext
| - train.tfrecord
| - test.tfrecord
+training

Jika susunan folder dalam folder object_detection sudah rapih, mari kita lanjutkan ke
moment of the truth

ke-DELAPAN, Moment of The Truth(Proses Training Model)

Nah, di bagian ini adalah saat-saat penentuan, apakah sebuah PC yang di gunakan bisa
untuk melakukan training object detection nya tensorflow. pada proses ini memakan
waktu yang sangat lama jika menggunakan PC/Laptop yang biasa-biasa saja tanpa
dukungan GPU

Untuk memulai proses trainnya bisa menggunakan perintah berikut di console nya

python train.py --logtostderr --train_dir=training/ --

pipeline_config_path=data/ssd_mobilenet_v1_pets.config

Perintah train_dir ini merupakan lokasi penyimpanan checkpoint untuk proses

pelatihan

Kemudian pipeline_config_path mengarah ke file config

Setelah melarikan(run) perintah di atas mari kita tunggu saja proses trainnya sampai kita
bosan :), kalo bisa kita tungguin sambl tidur biar hasilnya mantap.
Proses training model disini udah nyampe 85 ribu steps, mayan sih :’)

Pada PC yang saya gunakan proses training memakan waktu sekitar 40 Jam dengan
kurang lebih 86ribu steps :”). #padahaludahpakegpu #padahaludahhigh-end

NB: kalo local PC nya ga kuat buat training mungkin bisa pake server, ini lebih enak sih
apalagi server yang udah di dukung oleh GPU computing pasti itu mantep banget!

ERROR LOG :

JIKA MENGALAMI
TypeError: `pred` must be a Tensor, or a Python bool, or 1 or 0. Found
instead: None
PERBAIKI DI
...\models\research\object_detection\models\
FILE
ssd_mobilenet_v1_feature_extractor.py
BARIS KE 109
is_training=None
GANTI KE
is_training=True

Ke-9, Extract Model dari hasil training

Setelah Puas melakukan training dengan waktu yang begitu lama :)) marilah kita meng-
extract model menjadi frozen inference graph sehingga bisa digunakan untuk
memprediksi sebuah gambar yang kita sediakan.
Untuk mengextract modelnya bisa menggunakan export_inference_graph.py kemudian
menggunakan perintah ini

python export_inference_graph.py \
--input_type image_tensor \
--pipeline_config_path data/ssd_mobilenet_v1_pets.config \
--trained_checkpoint_prefix training/model.ckpt-xxxxx \
--output_directory snack_model

Pada bagian model.ckpt-xxxxx ini merupakan banyaknya steps yang kita lakukan saat
melatih model. jadi di bagian ini di sesuaikan dengan yang kalian miliki

Pada bagian pipeline_config_path ini merupakan tempat dimana kita menyimpan

config file

Kemudian di output_directory nya merupakan folder output silahkan buat foldernya,

kemudian nama snack_model di perintahnya di sesuaikan dengan folder yang di buat

Ke-10, Pengujian model menggunakan gambar yang kita ambil

Pada tahap ini menggunakan jupyter saja biar enak :))

tadaaaa……. berhasil memprediksi semua dengan baik :)

Object detection realtime

Setelah kita mendapatkan model yang sudah berbentuk pbgraph. kita bisa melakukan
pendeteksian objek secara real-time.

script py

jupyter script

https://medium.com/@hafizhan.aliady/lihat-apa-yang-ada-di-box-hijau-begini-cara-membuat-
object-detection-menggunakan-tensorflow-api-6d4a6d44e1a