Cara menggunakan TF.RANDOM.CATEGORICAL pada Python

Draws samples from a categorical distribution.

Table of Contents Show

Dalam tulisan ini akan mencakup beberapa hal:
Hal yang perlu disiapkan:
Library yang digunakan
Membuat flow datanya
Transformasi data generator menjadi tf.data
Compile model
Visualisasi Model

View aliases

Compat aliases for migration

See Migration guide for more details.

tf.compat.v1.random.categorical, `tf.compat.v2.random.categorical`

tf.random.categorical(
    logits, num_samples, dtype=None, seed=None, name=None
)

Example:

# samples has shape [1, 5], where each value is either 0 or 1 with equal
# probability.
samples = tf.random.categorical(tf.math.log([[0.5, 0.5]]), 5)

Argslogits2-D Tensor with shape [batch_size, num_classes]. Each slice [i, :] represents the unnormalized log-probabilities for all classes.num_samples0-D. Number of independent samples to draw for each row slice.dtypeinteger type to use for the output. Defaults to int64.seedA Python integer. Used to create a random seed for the distribution. See tf.compat.v1.set_random_seed for behavior.

# samples has shape [1, 5], where each value is either 0 or 1 with equal
# probability.
samples = tf.random.categorical(tf.math.log([[0.5, 0.5]]), 5)

0Optional name for the operation.ReturnsThe drawn samples of shape

# samples has shape [1, 5], where each value is either 0 or 1 with equal
# probability.
samples = tf.random.categorical(tf.math.log([[0.5, 0.5]]), 5)

Assalamualaikum, Setelah lama tidak menulis artikel dan tutorial, akhirnya diriku ke-pikiran juga buat nulis ini karena ini cukup penting sih tapi kadang suka lupa, jadi akhirnya cari-cari lagi materi tentang ini di internet, jadi daripada nanti diriku mencari-cari lagi dan bingung sendiri mungkin sebaiknya bikin tutorial nya saja sekalian. Biar tidak bingung.dan di sini tensorflow yang digunakan adalah tensorflow 2.1 yang terbaru. sudah tidak menggunakan keras lagi. Kemudian mari kita masuk ke outline nya dulu.

Dalam tulisan ini akan mencakup beberapa hal:

Image classification, apa itu ?
Apa yang perlu disiapkan untuk membuat sebuah image classifier ?
Mempersiapkan dataset
Membuat Pipeline untuk input dataset
Membangun Model Convolutional Neural Network,
Menggunakan Arsitektur Model CNN yang sudah ada.
Meng-Compile Model
Model Training
Model Save
Model Evaluation
Create Predict Function.

Let’s Start! Image Classification, Apa itu ?

Ya klasifikasi sebuah citra, berdasarkan klasifikasi yang kita buat. dan Ya, klasifikasi gambar merupakan salah satu metode machine learning / artificial intelligence yang dapat digunakan untuk mendeteksi sebuah gambar dengan cepat. intinya sih misalnya kita punya kebun bunga, terus kita panen semua tuh bunganya. Nah kita agak kesulitan buat mengelompokkan bunganya karena ada bunga yang hampir mirip dan bunganya itu banyak banget. jadi daripada kita kelompokin bunganya satu satu, mungkin sebaiknya kita membuat mesin untuk mengelompokan bunga tersebut sehingga kita dapat lebih mudah untuk pengelompokannya dan menjadi lebih efisien. Ya gitu aja sih gambarannya.

Jika membutuhkan pendalaman lebih lanjut mengenai image classification kalian bisa mengunjungi Youtube/ Cari di Google. Pasti sudah banyak sih referensi nya. Dan tujuan dari menulis ini adalah karena tensorflow sudah mengeluarkan versi 2.x maka sudah saatnya upgrade dari yang sebelumnya menggunakan

├── dataset
    │   ├── test
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   ├── train
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   └── validation
    │       ├── daisy
    │       ├── dandelion
    │       ├── rose
    │       ├── sunflower
    │       └── tulip

8menjadi

├── dataset
    │   ├── test
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   ├── train
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   └── validation
    │       ├── daisy
    │       ├── dandelion
    │       ├── rose
    │       ├── sunflower
    │       └── tulip

9dan dalam prosesnya modul

├── dataset
    │   ├── test
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   ├── train
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   └── validation
    │       ├── daisy
    │       ├── dandelion
    │       ├── rose
    │       ├── sunflower
    │       └── tulip

9 ini lebih efisien dibandingkan dengan sebelumnya.

Dan mungkin setelah ini saya akan pindah ke pytorch wkwkwk ~

Oke mari kita mulai

Yang perlu disiapkan!

Beberapa kebutuhan untuk membuat image classifier merupakan kebutuhan yang tidak murah, karena img classifier membutuhkan performa komputasi yang cukup tinggi agar dapat berjalan dengan lancar.Namun Kita dapat menggunakan Google Code Lab (Colab) untuk melakukannya.

Hal yang perlu disiapkan:

benda atau sesuatu objek yang ingin diklasifikasikan.
Komputer / PC yang dapat mengakses internet
Google Account untuk mengakses Google Colab (Pake di lokal juga bisa)
Pengetahuan dasar mengenai Python

Library yang digunakan

Tensorflow ≥ 2.2 ( tested on tf 2.7)
Numpy
Scikit-learn
PILLOW untuk image library

Mempersiapkan Data-set

Ya kita siapkan dulu data-setnya, Di sini kita gunakan contoh gambar/ image bunga dari kaggle saja biar enak untuk datanya bisa klik di sini .

Pertama tama kita extract terlebih dahulu datanya, lalu treedir nya akan seperti ini. saat data pertama kali di extract.

└── flowers
        ├── daisy
        ├── dandelion
        ├── flowers
        │   ├── daisy
        │   ├── dandelion
        │   ├── rose
        │   ├── sunflower
        │   └── tulip
        ├── rose
        ├── sunflower
        └── tulip

Dalam proses yang pertama ini, kita ingin membagi datanya menjadi 3 bagian. yaitu train, test, dan validation. dengan proporsi (80,10,10).

Kemudian, pada proses ini kita ingin membagi datanya menjadi seperti ini.

├── dataset
    │   ├── test
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   ├── train
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   └── validation
    │       ├── daisy
    │       ├── dandelion
    │       ├── rose
    │       ├── sunflower
    │       └── tulip

Berikut untuk kode nya.

Mempersiapkan variabel global untuk training

Dibagian ini kita akan menentukan seberapa banyak jumlah epoch untuk proses training, input dimension, batch_size. dll

# Parameter input untuk network
dim = (150, 150)
channel = (3, )
input_shape = dim + channel# Batch size
batch_size = 16# Epoch
epoch = 10

Mempersiapkan dataset pipeline dan augmentation Untuk proses pembuatan dataset

Dataset pipeline merupakan perintah untuk melakukan ekstraksi data yang berupa images/citra digital, yang berasal dari sebuah folder menjadi sebuah array yang dapat dibaca oleh tensorflow, fungsi yang digunakan adalah

# Parameter input untuk network
dim = (150, 150)
channel = (3, )
input_shape = dim + channel# Batch size
batch_size = 16# Epoch
epoch = 10

Fungsi tersebut merupakan Image data generator sehingga kita mengenerate data image dari sebuah file / folder yang telah kita buat sebelumnya. pada bagian ini kita dapat menentukan generator / augmentasi seperti apa yang dapat dilakukan.

Untuk bacaan lebih lanjut dapat mengunjungi tautan referensi berikut:
- https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html
- https://keras.io/preprocessing/image/

Pertama tama kita mendefinisikan terlebih dahulu bagaimana transformasi data yang akan digunakan.

train_datagen = ImageDataGenerator(rescale=1. / 255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)val_datagen = ImageDataGenerator(rescale=1. / 255,
                                 shear_range=0.2,
                                 zoom_range=0.2,
                                 horizontal_flip=True)test_datagen = ImageDataGenerator(rescale=1. / 255,
                                  shear_range=0.2,
                                  zoom_range=0.2,
                                  horizontal_flip=True)

Pada perintah diatas kita melakukan

Rescaling data menjadi 1/255.
Shearing image skala 0.2
Zooming image dengan range 0.2
dan melakukan Horizontal flip

Sehingga contohnya akan seperti ini

Src: https://towardsdatascience.com/machinex-image-data-augmentation-using-keras-b459ef87cd22

Membuat flow datanya

Setelah mendefinisikan generatornya, selanjutnya kita mendefinisikan darimana sumber datanya berasal. Misalkan pada project kali ini kita menggunakan data yang berasal dari folder (dictionary) sehingga code yang digunakan adalah sebagai berikut:

pada code diatas, kita menggunakan flow from dir dimana fungsi tersebut mengarahkan kita kepada folder set yang telah kita buat sebelumnya. di mana :

target size = dimensi dari citra yang akan digunakan dalam proses training
batch size = banyaknya citra yang dimasukan dalam setiap steps training.

class mode = metode pemilihan klasifikasi

# Parameter input untuk network
dim = (150, 150)
channel = (3, )
input_shape = dim + channel# Batch size
batch_size = 16# Epoch
epoch = 10

shuffle = data didalam folder tersebut diacak sehingga tidak sesuai urutan yang ada seperti urutan alfabetik.

Transformasi data generator menjadi tf.data

Pada proses ini kita akan melakukan transformasi variabel train_generator dan lainnya menjadi tf data, kenapa menggunakan

# Parameter input untuk network
dim = (150, 150)
channel = (3, )
input_shape = dim + channel# Batch size
batch_size = 16# Epoch
epoch = 10

3 karena

# Parameter input untuk network
dim = (150, 150)
channel = (3, )
input_shape = dim + channel# Batch size
batch_size = 16# Epoch
epoch = 10

3 merupakan tipe variabel generator yang cocok dengan

├── dataset
    │   ├── test
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   ├── train
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   └── validation
    │       ├── daisy
    │       ├── dandelion
    │       ├── rose
    │       ├── sunflower
    │       └── tulip

9 sehingga sangat optimal dalam pembacaan data yang dilakukan dalam proses training dibandingkan hanya menggunakan generator dari keras itu sendiri. Untuk lebih lanjut dapat dibaca di sini. Lalu berikut penerapannya.

def tf_data_generator(generator, input_shape):
    num_class = generator.num_classes
    tf_generator = tf.data.Dataset.from_generator(
        lambda: generator,
        output_types=(tf.float32, tf.float32),
        output_shapes=([None
                        , input_shape[0]
                        , input_shape[1]
                        , input_shape[2]]
                       ,[None, num_class])
    )
    return tf_generatortrain_data = tf_data_generator(train_generator, input_shape)
test_data = tf_data_generator(test_generator, input_shape)
val_data = tf_data_generator(val_generator, input_shape)

Membuat Struktur Convolutional Neural Network

Setelah membuat dataset generator, selanjutnya kita melakukan membuat jaringan nerual network. Namun karena kita terlalu malas maka kita dapat menggunakan network yang sudah ada. pada project ini kita menggunakan Mobilenet V2 untuk paper terkait dapat dibaca di sini. Kemudian untuk pilihan network-network yang sudah ada bisa dilihat di sini.

Pertama-tama kita mendefinisikan terlebih dahulu base-model kita / yang akan di gunakan pada project ini.

from tensorflow.keras.applications import MobileNetV2# get base models
base_model = MobileNetV2(
    input_shape=input_shape,
    include_top=False,
    weights='imagenet',
    classes=num_class,
)

Di mana :

Input_shape = merupakan dimensi dari gambar yang akan kita gunakan/ input dari citra
Include top = adalah perintah untuk menyertakan apakah model yang digunakan akan disertakan dengan top layer dari arsitektur network tersebut atau misalkan top network tersebut memiliki 3 node yaitu : flatten layer, layer dengan 1024 node dan fungsi aktivasinya, lalu prediction node dimana jumlah node sesuai dengan banyaknya jumlah kelas.
Dikarenakan jumlah kelas pada imagenet adalah 1000 maka ini tidak cocok dengan jumlah kelas yang kita miliki yaitu hanya 5. sehingga include top di sini adalah false.
Weights = adalah bobot dari masing-masing layer yang sudah di training berdasarkan bobot imagenet. Kita juga bisa meniadakan ini dengan menggunakan
```
# Parameter input untuk network
dim = (150, 150)
channel = (3, )
input_shape = dim + channel# Batch size
batch_size = 16# Epoch
epoch = 10
```
6 Namun ketika tidak menggunakan pre-trained weight proses training kita akan lebih lama karena initial value dari weight nya random sehingga perlu banyak penyesuaian terhadap data yang akan kita gunakan.
Classes = adalah jumlah class yang kita miliki

Setelah berhasil maka base-model sudah terbentuk dan selanjutnya adalah menambahkan top layer yang akan kita definisikan karena kita set false pada base model di atas.

from tensorflow.keras import layers,Sequential
from tensorflow.keras.models import Model#Adding custom layers
x = base_model.output
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dropout(0.2)(x)
x = layers.Dense(1024, activation="relu")(x)predictions = layers.Dense(num_class, activation="softmax")(x)
model = Model(inputs=base_model.input, outputs=predictions)

Kita telah menambahkan top-layer kedalam network dan variabel yang digunakan adalah model. Kemudian kita dapat melihat keseluruhan network dengan menggunakan

# Parameter input untuk network
dim = (150, 150)
channel = (3, )
input_shape = dim + channel# Batch size
batch_size = 16# Epoch
epoch = 10

Bisa kita lihat bahwa top layer yang kita definisikan sudah masuk kedalam model. Dan model bisa kita compile sehingga dapat digunakan untuk training.

Compile model

# Compile the model
print('Compiling Model')
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

Pada proses ini kita meyusun model menjadi siap dilakukan proses training. Dimana variabel yang digunakan adalah-
sebagai berikut:

Optimizer = merupakan metode optimasi yang digunakan.
loss = adalah metode pengukuran nilai loss berdasarkan pada nilai apa. karena
```
# Parameter input untuk network
dim = (150, 150)
channel = (3, )
input_shape = dim + channel# Batch size
batch_size = 16# Epoch
epoch = 10
```
8 kita menggunakan categorical sehingga pada nilai loss ini kita juga menggunakan categorical loss.
Metrics = Nilai matriks yang diukur pada project ini kita menggunakan nilai akurasi sebagai nilai pengukurannya. Untuk lainnya bisa baca di sini

Visualisasi Model

Kita bisa memvisualisasikan model menggunakan perintah berikut.

model_viz = tf.keras.utils.plot_model(model,
                          to_file='model.png',
                          show_shapes=True,
                          show_layer_names=True,
                          rankdir='TB',
                          expand_nested=True,
                          dpi=55)
model_viz

Dan hasilnya akan seperti ini.

Dan itu hasilnya sangat panjang. atau kalian dapat membuka filenya dengan nama file

# Parameter input untuk network
dim = (150, 150)
channel = (3, )
input_shape = dim + channel# Batch size
batch_size = 16# Epoch
epoch = 10

Proses Training Model

Setelah membuat model selanjutnya adalah melakukan proses training, dimana proses training ini merupakan proses dimana machine learning bekerja sehingga algoritma yang sudah kita definisikan dapat mengingat pola dari masing masing kelas pada data yang kita train. Untuk perintahnya adalah menggunakan perintah berikut.

EPOCH = 5
history = model.fit(x=train_data,
        steps_per_epoch=len(train_generator),
        epochs=EPOCH,
        validation_data=val_data,
        validation_steps=len(val_generator),
        shuffle=True,
        verbose = 1)

Dimana:

X = merupakan data generator yang sudah kita proses sehingga menjadi

train_datagen = ImageDataGenerator(rescale=1. / 255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)val_datagen = ImageDataGenerator(rescale=1. / 255,
                                 shear_range=0.2,
                                 zoom_range=0.2,
                                 horizontal_flip=True)test_datagen = ImageDataGenerator(rescale=1. / 255,
                                  shear_range=0.2,
                                  zoom_range=0.2,
                                  horizontal_flip=True)

0 ini merupakan data training.

Steps per epoch merupakan banyaknya steps / langkah untuk menyelesaikan 1 epoch, disini 1 steps merupakan 1 batch_size / 1 batch_size adalah 16 citra, seperti yang sudah di definisikan diatas.
epoch = banyaknya proses iterasi/ pengulangan pada training
val_data = validation data yang dievaluasi pada setiap epoch berakhir
val_steps = sama seperti step per epoch
shuffle = adalah dimana masing masing batch pada generator diacak sehingga data tidak akan urut.
Verbose =menampilkan progress bar dimana 1 karena kita dapat melihat proses dan hasil dari setiap steps seperti gambar dibawah nanti.

Untuk keterangan lebih lanjut dapat dibaca disini.

Kemudian untuk contoh proses training nya akan seperti ini.

Mari kita tunggu sampai proses training selesai. Dari hasil diatas bisa kita baca bahwa akurasi pada data training adalah 0.70 dan nilai lossnya adalah 0.91, Kemudian untuk data validasinya adalah 0.544 dan nilai lossnya adalah 2.388. Namun ini baru iterasi pertama. Sehingga kita bisa menunggu untuk iterasi berikutnya / hingga model selesai dilatih dengan 5 iterasi.

├── dataset
    │   ├── test
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   ├── train
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   └── validation
    │       ├── daisy
    │       ├── dandelion
    │       ├── rose
    │       ├── sunflower
    │       └── tulip

Dan hasil training nya adalah seperti itu, Hasil tersebut rupanya tidak bagus ternyata untuk model ini. Di mana

Dimana nilai loss pada data validasi adalah cenderung tidak stabil. Sehingga bisa dibilang model ini overfit terhadap data training namun belum tentu. Perlu percobaan lebih lanjut apakah model ini overfit atau tidak.

Begitu juga dengan nilai akurasi nya. Di mana nilai akurasi untuk data validasi cenderung tidak stabil sehingga model ini kurang baik. Maka diperlukan penelitian lebih lanjut untuk mencari model yang terbaik. Bisa dilakukan training ulang atau mengganti dengan model / network yang baru.

Simpan Model yang sudah di training

Setelah melakukan proses training, selanjutnya adalah melakukan save pada model.

├── dataset
    │   ├── test
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   ├── train
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   └── validation
    │       ├── daisy
    │       ├── dandelion
    │       ├── rose
    │       ├── sunflower
    │       └── tulip

Pada bagian

train_datagen = ImageDataGenerator(rescale=1. / 255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)val_datagen = ImageDataGenerator(rescale=1. / 255,
                                 shear_range=0.2,
                                 zoom_range=0.2,
                                 horizontal_flip=True)test_datagen = ImageDataGenerator(rescale=1. / 255,
                                  shear_range=0.2,
                                  zoom_range=0.2,
                                  horizontal_flip=True)

1 ini merupakan agar si tensorflow tidak menyimpan keadaan optimizer pada saat terakhir disimpan, Ini agar dapat menghemat media penyimpanan dan mempermudah dalam proses deployment. Dan contoh perbandingannya adalah sebagai berikut:

Model pertama merupakan

train_datagen = ImageDataGenerator(rescale=1. / 255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)val_datagen = ImageDataGenerator(rescale=1. / 255,
                                 shear_range=0.2,
                                 zoom_range=0.2,
                                 horizontal_flip=True)test_datagen = ImageDataGenerator(rescale=1. / 255,
                                  shear_range=0.2,
                                  zoom_range=0.2,
                                  horizontal_flip=True)

2yang tanpa optimizer dan

train_datagen = ImageDataGenerator(rescale=1. / 255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)val_datagen = ImageDataGenerator(rescale=1. / 255,
                                 shear_range=0.2,
                                 zoom_range=0.2,
                                 horizontal_flip=True)test_datagen = ImageDataGenerator(rescale=1. / 255,
                                  shear_range=0.2,
                                  zoom_range=0.2,
                                  horizontal_flip=True)

3 adalah model dengan optimizer didalamnya. Sehingga perbedaannya adalah 3 kali lipat dari model tanpa optimizer. ini sangat menghemat penyimpanan.

Evaluasi model menggunakan data testing

Pada bagian ini kita melakukan testing menggunakan data test. Di mana, data test ini tidak diikut sertakan ke dalam proses training. Berikut adalah perintahnya:

├── dataset
    │   ├── test
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   ├── train
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   └── validation
    │       ├── daisy
    │       ├── dandelion
    │       ├── rose
    │       ├── sunflower
    │       └── tulip

dan hasilnya adalah sebagai berikut :

├── dataset
    │   ├── test
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   ├── train
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   └── validation
    │       ├── daisy
    │       ├── dandelion
    │       ├── rose
    │       ├── sunflower
    │       └── tulip

Dari hasil tersebut dilihat bahwa model cukup stabil di kedua data sehingga dapat disarankan untuk melakukan training lagi atau dapat mencari algoritma / model yang lain seperti inception_v2 ataupun inception_resnet.

Untuk kode lengkapnya, bisa dilihat di notebook ini pada notebook ini saya contohkan juga menggunakan efficient-net dimana efficient net merupakan model yang terbaik pada #SOTA-1 Image-net.

Membuat Fungsi Prediksi

Setelah kita membuat model dan melakukan training model langkah selanjutnya adalah membuat fungsi prediksi. Sehingga jika kita memiliki data baru diluar data train test validasi. maka kita dapat dengan mudah memprediksinya.

Langkah pertama yang dilakukan adalah melakukan definisi variabel global.

├── dataset
    │   ├── test
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   ├── train
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   └── validation
    │       ├── daisy
    │       ├── dandelion
    │       ├── rose
    │       ├── sunflower
    │       └── tulip

Dimana kita input kan sesuai dengan nilai yang sama seperti pada saat proses training. untuk label nya bisa kita urutkan sesuai dengan abjad atau pada saat proses training. label nya disimpan seperti gambar berikut :

Lalu selanjutnya adalah mendefinisikan fungsi pre-process, dimana fungsi ini adalah mengubah sebuah citra menjadi sebuah array yang cocok untuk masuk kedalam model yang sudah kita latih.

├── dataset
    │   ├── test
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   ├── train
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   └── validation
    │       ├── daisy
    │       ├── dandelion
    │       ├── rose
    │       ├── sunflower
    │       └── tulip

fungsi diatas merupakan fungsi mengubah image menjadi array dimana image diubah menjadi frormat RGB kemudian dilakukan resize dengan metode interpolasi Nearest-neighbor default dari library tersebut.

Setelah itu melakukan reshape array yang awalnya adalah 3 dimensi, menjadi 4 dimensi, atau bisa disebut tensor.

Kemudian selanjutnya adalah melakukan load model yang sudah di training. Load model tersebut dapat lakukan dengan menggunakan perintah berikut.

├── dataset
    │   ├── test
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   ├── train
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   └── validation
    │       ├── daisy
    │       ├── dandelion
    │       ├── rose
    │       ├── sunflower
    │       └── tulip

Setelah model yang sudah dilatih telah berhasil dimuat. maka selanjutnya adalah melakukan prediksi terhadap sebuah gambar. Misalnya kita memiliki contoh gambar berikut :

Lalu kemudian perintahnya adalah sebagai berikut:

├── dataset
    │   ├── test
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   ├── train
    │   │   ├── daisy
    │   │   ├── dandelion
    │   │   ├── rose
    │   │   ├── sunflower
    │   │   └── tulip
    │   └── validation
    │       ├── daisy
    │       ├── dandelion
    │       ├── rose
    │       ├── sunflower
    │       └── tulip

Di mana, pada perintah di atas kita membuka image / citra . Kemudian, kita melakukan preprocess imagenya menjadi sebuah

train_datagen = ImageDataGenerator(rescale=1. / 255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)val_datagen = ImageDataGenerator(rescale=1. / 255,
                                 shear_range=0.2,
                                 zoom_range=0.2,
                                 horizontal_flip=True)test_datagen = ImageDataGenerator(rescale=1. / 255,
                                  shear_range=0.2,
                                  zoom_range=0.2,
                                  horizontal_flip=True)

4 yang kemudian direshape menjadi sebuah tensor. Setelah itu memprediksi termasuk bunga apakah gambar tersebut.

Hasilnya adalah seperti gambar diatas. Variabel

train_datagen = ImageDataGenerator(rescale=1. / 255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)val_datagen = ImageDataGenerator(rescale=1. / 255,
                                 shear_range=0.2,
                                 zoom_range=0.2,
                                 horizontal_flip=True)test_datagen = ImageDataGenerator(rescale=1. / 255,
                                  shear_range=0.2,
                                  zoom_range=0.2,
                                  horizontal_flip=True)

5 merupakan nilai dari hasil prediksi yang menghasilkan banyak nilai. Di mana nilai-nilai tersebut adalah nilai dari masing-masing kategori.

Kemudian kita mencari nilai ter-besarnya, yaitu pada kolom ke 4 yang merupakan kelas tulip berdasarkan label yang sudah di definisikan di atas. dan dengan nilai probabilitas ~0.91-.