Cara menggunakan binary generator python

This initially creates clusters of points normally distributed [std=1] about vertices of an n_informative-dimensional hypercube with sides of length 2*class_sep and assigns an equal number of clusters to each class. It introduces interdependence between these features and adds various types of further noise to the data.

Without shuffling, X horizontally stacks features in the following order: the primary n_informative features, followed by n_redundant linear combinations of the informative features, followed by n_repeated duplicates, drawn randomly with replacement from the informative and redundant features. The remaining features are filled with random noise. Thus, without shuffling, all useful features are contained in the columns X[:, :n_informative + n_redundant + n_repeated].

Read more in the .

Parameters:n_samplesint, default=100

The number of samples.

n_featuresint, default=20

The total number of features. These comprise n_informative informative features, n_redundant redundant features, n_repeated duplicated features and n_informative1 useless features drawn at random.

n_informativeint, default=2

The number of informative features. Each class is composed of a number of gaussian clusters each located around the vertices of a hypercube in a subspace of dimension n_informative. For each cluster, informative features are drawn independently from N[0, 1] and then randomly linearly combined within each cluster in order to add covariance. The clusters are then placed on the vertices of the hypercube.

n_redundantint, default=2

The number of redundant features. These features are generated as random linear combinations of the informative features.

n_repeatedint, default=0

The number of duplicated features, drawn randomly from the informative and the redundant features.

n_classesint, default=2

The number of classes [or labels] of the classification problem.

n_clusters_per_classint, default=2

The number of clusters per class.

weightsarray-like of shape [n_classes,] or [n_classes - 1,], default=None

The proportions of samples assigned to each class. If None, then classes are balanced. Note that if n_informative3, then the last class weight is automatically inferred. More than n_informative4 samples may be returned if the sum of n_informative5 exceeds 1. Note that the actual class proportions will not exactly match n_informative5 when n_informative7 isn’t 0.

flip_yfloat, default=0.01

The fraction of samples whose class is assigned randomly. Larger values introduce noise in the labels and make the classification task harder. Note that the default setting flip_y > 0 might lead to less than n_informative8 in y in some cases.

class_sepfloat, default=1.0

The factor multiplying the hypercube size. Larger values spread out the clusters/classes and make the classification task easier.

hypercubebool, default=True

If True, the clusters are put on the vertices of a hypercube. If False, the clusters are put on the vertices of a random polytope.

shiftfloat, ndarray of shape [n_features,] or None, default=0.0

Shift features by the specified value. If None, then features are shifted by a random value drawn in [-class_sep, class_sep].

scalefloat, ndarray of shape [n_features,] or None, default=1.0

Multiply features by the specified value. If None, then features are scaled by a random value drawn in [1, 100]. Note that scaling happens after shifting.

shufflebool, default=True

Shuffle the samples and the features.

random_stateint, RandomState instance or None, default=None

Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See .

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

1

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:
- //blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html
- //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: //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

  2
• 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

7

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

9

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

0

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

1

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

2

dan hasilnya adalah sebagai berikut :

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

3

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

4

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

5

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

6

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

7

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-.