LAPORAN PRAKTIKUM

TEAM TEACHING

DILAPORKAN OLEH :

RIO TAMYIZ MAULANA (11120017)

UNIVERSITAS GUNADARMA

FAKULTAS IMU COMPUTER DAN TEKNOLOGI INFORMASI

JURUSAN SYSTEM INFORMASI

2021
Daftar isi
Pengenalan Image Processing dengan Python...................................................................................3
Mambaca dan menampilkan gambar.................................................................................................3
Tugas 1: Baca gambar dari URL dan tampilkan............................................................................5
Kontur Gambar dan Histogram..........................................................................................................5
Histogram citra berwarna dan citra grayscale................................................................................5
Plot histogram gambar abu-abu.....................................................................................................7
Tugas 2: Tampilkan gambar anda dalam grayscale dan buat histogramnya...................................8
Temukan kontur gambar dari gambar grayscale................................................................................9
Metode 1: Gunakan matplotlib. contour........................................................................................9
Metode 2: Gunakan library openCV..............................................................................................9
Tugas 3: Temukan kontur gambar Anda sendiri..........................................................................10
Transformasi Grayscale dan Persamaan Histogram.........................................................................11
Grayscale Transformation............................................................................................................11
Tugas 4: Cobalah beberapa operasi matematika pada gambar Anda............................................13
Histogram Equalization...................................................................................................................13
Tugas 5: Lakukan pemerataan histogram pada gambar grayscale Anda......................................15
Transformasi Fourier dari Gambar Abu-abu....................................................................................16
Menemukan Tepi dengan Highpass Filtering di FFT.......................................................................17
Image Recognition.............................................................................................................................18
Import library yang dibutuhkan.......................................................................................................18
Melakukan proses training terhadap dataset....................................................................................22
Mengevaluasi hasil prediksi.............................................................................................................26
Menampilkan Salah Satu Hasil Prediksi Yang salah............................................................26
Menampilkan Hasil Prediksi Keseluruhan Dari Algoritma yang Dibangun.........................26
Pengenalan Image Processing dengan Python
Import module yang diperlukan
• Numpy adalah library untuk manipulasi array, digunakan untuk aljabar linier,
transformasi Fourier, dan kemampuan bilangan acak.
• Pandas adalah library untuk manipulasi data dan analisis data.
• CV2 adalah library untuk tugas-tugas computer vision.
• Skimage adalah library yang mendukung aplikasi pengolah gambar pada python.
• Matplotlib adalah library yang menghasilkan gambar dan menyediakan toolkit antarmuka
pengguna grafis.

Mambaca dan menampilkan gambar

path dari gambar yang dipilih

input_path="/content/image-1.jpeg"
input_path="/content/image-2.jpeg"
input_path="/content/image-3.jpeg"

untuk membaca path dari gambar lalu menampilkannya

def cv_imshow(img):

plt.figure(figsize = (15,15))
plt.imshow(img)
plt.xticks([]), plt.yticks([])
plt.show()

input_path="/content/image-1.jpeg"
input_path="/content/image-2.jpeg"
input_path="/content/image-3.jpeg"

untuk menyimpan url gambar

urls = ["image-1.jpeg",
"image-2.jpeg",
"image-3.jpeg"
]

untuk membaca dan tampilkan gambar

def cv_imshow(img):
plt.figure(figsize = (15,15))
plt.imshow(img)
plt.xticks([]), plt.yticks([])
plt.show()
loop terhadap URL gambar

for url in urls:

image = io.imread(url)
image_2 = cv.cvtColor(image, cv.COLOR_BGR2RGB)
final_frame = cv.hconcat((image, image_2))
cv_imshow(final_frame)
Tugas 1: Baca gambar dari URL dan tampilkan
Cari gambar dari google, lalu gunakan url address dari gambar tersebut untuk melakukan operasi
di bawah ini dengan menghapus tanda komentarnya.

url =
https://www.google.com/url?sa=i&url=https%3A%2F%2Ffanyv88.com%3A443%2Fhttps%2Fkhyzylsaleem.ar
tstation.com%2F&psig=AOvVaw3xZfG9fHJgJHmwocQfuLOo&ust=16198545891
11000&source=images&cd=vfe&ved=0CAoQjRxqFwoTCLCF7Oa6pfACFQAAAAAdA
AAAABAD
myImg = io.imread(url)
cv_imshow(cv.cvtColor(myImg, cv.COLOR_BGR2RGB))

Kontur Gambar dan Histogram

Untuk menggunakan image dari indeks pertama dalam variabel urls

image = io.imread(urls[0])

Histogram citra berwarna dan citra grayscale

Terkadang meningkatkan kontras pada gambar atau memperluas kontras di wilayah tertentu
sambil mengorbankan detail dalam warna yang tidak terlalu bervariasi, atau tidak penting. Alat yang baik
untuk menemukan wilayah yang menarik adalah histogram. Untuk membuat histogram dari data
gambar kita, kita menggunakan fungsi matplot.pylab hist ().

Untuk menampilkan histogram dari semua piksel pada gambar berwarna

plt.hist(image.ravel(),bins = 256, range = [0,256])

plt.show()
 Menampilkan histogram saluran R, G, B Kita dapat mengamati bahwa saluran hijau memiliki
banyak piksel di 255, yang mewakili tambalan putih pada gambar.

color = ('b','g','r')
for i,col in enumerate(color):
histr = cv.calcHist([image],[i],None,[256],[0,256])
plt.plot(histr,color = col)
plt.xlim([0,256])
plt.show()

gray_image = cv.cvtColor(image, cv.COLOR_BGR2GRAY)

cv_imshow(gray_image)
Plot histogram gambar abu-abu.
Kita bisa mengamati bahwa frekuensi histori citra mengalami penurunan ~ 1/3 dari histogram
citra berwarna
plt.hist(gray_image.ravel(),bins = 256, range = [0, 256])
plt.show()
Tugas 2: Tampilkan gambar anda dalam grayscale dan buat histogramnya

myGrayImg = cv.cvtColor(image, cv.COLOR_BGR2GRAY)

cv_imshow(myGrayImg)

plt.hist(image.ravel(),bins = 256, range = [0,256])

plt.show()
Temukan kontur gambar dari gambar grayscale
Metode 1: Gunakan matplotlib. contour

plt.contour(gray_image, origin = "image")

Metode 2: Gunakan library openCV

Setel ambang batas untuk deteksi kontur

ret, thresh = cv.threshold(gray_image,100,200,0)

contours, hierarchy = cv.findContours(thresh, cv.RETR_TREE,
cv.CHAIN_APPROX_SIMPLE)
 cv.drawContours(image, contours, -1, (0, 255, 0), 3)
plt.imshow(image)

Tugas 3: Temukan kontur gambar Anda sendiri

plt.contour(gray_image, origin = "image")

<matplotlib.contour.QuadContourSet at 0x7f8daa4e3210>
Transformasi Grayscale dan Persamaan Histogram

Grayscale Transformation

Bagian ini memberikan beberapa contoh melakukan transformasi matematis dari gambar
grayscale

Ini adalah operasi kebalikan dari gambar grayscale,

bisa dilihat bahwa piksel cerah menjadi gelap, dan piksel gelap menjadi
cerah im2 = 255 - gray_image
cv_imshow(im2)

Transformasi gambar lainnya, setelah menambahkan konstanta, semua piksel menjadi lebih cerah
dan efek gambar seperti perpeloncoan dihasilkan
im3 = (100.0/255)*gray_image + 100
cv_imshow(im3)
Tingkat kecerahan gambar abu-abu berkurang setelah langkah ini

im4 = 255.0*(gray_image/255.0)**2
cv_imshow(im4)
Tugas 4: Cobalah beberapa operasi matematika pada gambar Anda

myGrayImgTrans = (14980.0/255)*gray_image4 *(gray_image/255.0)**8

cv_imshow(myGrayImgTrans)

Histogram Equalization
Bagian ini mendemonstrasikan pemerataan histogram pada gambar gelap. Transformasi ini
meratakan histogram tingkat abu-abu sehingga semua intensitas menjadi seumum mungkin. Fungsi
transformasi adalah fungsi distribusi kumulatif (cdf) dari nilai piksel pada citra (dinormalisasi untuk
memetakan rentang nilai piksel ke rentang yang diinginkan). Contoh ini menggunakan gambar 4 (im4).

Fungsi dari histogram equalization

def histeq(im, nbr_bins = 256):

""" Persamaan histogram dari citra grayscale. """

dapatkan histogram gambar

imhist, bins = np.histogram(im.flatten(), nbr_bins, [0, 256])

cdf = imhist.cumsum() # fungsi distribusi kumulatif
cdf = imhist.max()*cdf/cdf.max() #normalisasi
cdf_mask = np.ma.masked_equal(cdf, 0)
cdf_mask = (cdf_mask - cdf_mask.min())*255/(cdf_mask.max()-
cdf_mask.min())
cdf = np.ma.filled(cdf_mask,0).astype('uint8')
return cdf[im.astype('uint8')]
terapkan fungsi pada gambar gelap Anda untuk meningkatkan kontras
kita dapat mengamati bahwa kontras latar belakang hitam telah meningkat
im5 = histeq(im4)
cv_imshow(im5)

Ekstra: mencoba memvisualisasikan histogram citra setelah pemerataan histogram

Sebelum pemerataan histogram

plt.hist(im4.ravel(),bins = 256, range = [0, 256])

plt.show()

Setelah pemerataan histogram

plt.hist(im5.ravel(),bins = 256, range = [0, 256])
plt.show()

Tugas 5: Lakukan pemerataan histogram pada gambar grayscale Anda

def histeq(im, nbr_bins = 256):

imhist, bins = np.histogram(im.flatten(), nbr_bins, [0, 256])

cdf = imhist.cumsum()
cdf = imhist.max()*cdf/cdf.max()
cdf_mask = np.ma.masked_equal(cdf, 0)
cdf_mask = (cdf_mask - cdf_mask.min())*255/(cdf_mask.max()-
cdf_mask.min())
cdf = np.ma.filled(cdf_mask,0).astype('uint8')
return cdf[im.astype('uint8')]

grayIMG1 = histeq(myGrayImgTrans)
cv_imshow(grayIMG1)

plt.hist(myGrayImgTrans.ravel(),bins = 256, range = [0, 256])

plt.show()
plt.hist(grayIMG1.ravel(),bins = 256, range = [0, 256])
plt.show()
Sebelum

sesudah

Transformasi Fourier dari Gambar Abu-abu

Transformasi fourier digunakan untuk mencari domian frekuensi gambar. Anda dapat
menganggap gambar sebagai sinyal yang diambil sampelnya dalam dua arah. Jadi mengambil
transformasi fourier di kedua arah X dan Y memberi Anda representasi frekuensi gambar. Untuk sinyal
sinusoidal, jika amplitudo berubah sangat cepat dalam waktu singkat, dapat dikatakan itu adalah sinyal
frekuensi tinggi. Jika bervariasi perlahan, itu adalah sinyal frekuensi rendah. Tepi dan noise adalah konten
frekuensi tinggi dalam gambar karena berubah secara drastis dalam gambar.
Buramkan gambar grayscale dengan filter Guassian dengan ukuran kernel 10
imBlur = cv.blur(gray_image,(5,5))

Ubah gambar menjadi domain frekuensi

f = np.fft.fft2(imBlur)

Bawa komponen frekuensi-nol ke tengah

fshift = np.fft.fftshift(f)
magnitude_spectrum = 30*np.log(np.abs(fshift))

plt.subplot(121),plt.imshow(imBlur, cmap = 'gray')

plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()

Tugas 6: Hasilkan transformasi fourier dari gambar grayscale Anda

plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()

Menemukan Tepi dengan Highpass Filtering di FFT

Bagian ini mendemonstrasikan melakukan high pass filter untuk menghilangkan
komponen frekuensi rendah, sehingga menghasilkan gambar yang tajam yang berisi tepinya.

rows, cols = imBlur.shape

crow,ccol = round(rows/2) , round(cols/2)
hilangkan frekuensi rendah dengan ukuran persegi panjang 10
fshift[crow-10:crow+10, ccol-10:ccol+10] = 0
f_ishift = np.fft.ifftshift(fshift) img_back =
np.fft.ifft2(f_ishift) img_back =
np.abs(img_back)

plt.figure(figsize=([20, 20]))
plt.subplot(131),plt.imshow(imBlur, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(132),plt.imshow(img_back, cmap = 'gray')
plt.title('Gambar setelah HPF'), plt.xticks([]), plt.yticks([])
plt.subplot(133),plt.imshow(img_back)
plt.title('Hasil dalam JET'), plt.xticks([]), plt.yticks([])
plt.show()

Image Recognition
Pada praktikum ini, algoritma yang akan dibangun adalah untuk melakukan pengenalan obyek pada
sebuah gambar. Pada praktikum ini menggunakan library tensorflow.
Dalam melakukan proses pengenalan image, diperlukan fitur-fitur yang telah dipelajari pada notebook
sebelumnya seperti histogram, pengenalan edge, dan sebagainya
Adapun langkah langkah adalah sebagai berikut

1. Import library yang dibutuhkan

2. Melakukan proses training terhadap dataset
3. Mengevaluasi hasil prediks

Import library yang dibutuhkan

import cupy as cp
import time
import numpy as np

cp.cuda.Device(0).use()
for i in range (0,1):
    N = 1024
    
    start = time.time()
    A = cp.random.randint(-5,5,(N,N))
    B = cp.random.randint(-5,5,(N,N))
Untuk mengukur waktu yang diperlukan untuk membuat indeks matriks dengan menggunakan library
cupy yang menggunakan GPU untuk komputasi

    C = cp.matmul(A,B)
    cp.cuda.Stream.null.synchronize()
    print("Waktu yang diperlukan utk mengalikan 2 matirk berukuran %d,d 
proses ke %d dengan GPU = %.2f"%(N,N,i,time.time()-start))
    
    start = time.time()
    A1 = cp.asnumpy(A)
    B1 = cp.asnumpy(B)

Untuk mengukur waktu yang diperlukan untuk membuat indeks matriks dengan menggunakan library
NumPy yang menggunakan CPU untuk komputasi

    C = np.matmul(A1,B1)
    print("Waktu yang diperlukan utk mengalikan matirk berukuran %d,%d
proses ke %d dengan CPU = %.2f"%(N,N,i,time.time()-start))

output :

Waktu yang diperlukan utk mengalikan 2 matirk berukuran 1024,1024

proses ke 0 dengan GPU = 0.92
Waktu yang diperlukan utk mengalikan matirk berukuran 1024,1024 proses
ke 0 dengan CPU = 6.65

Untuk mengukur waktu yang diperlukan library tensorflow

import tensorflow as tf
import time

N = 1024
A = np.random.randint(-5,5,(N,N))
B = np.random.randint(-5,5,(N,N))

start = time.time()

with tf.compat.v1.device('/device:CPU:0'):
     C = tf.matmul(A,B)
print("Waktu matmul dengan Tensorflow = %.2f"%(time.time()-start))

output :
WARNING:tensorflow:Deprecation warnings have been disabled. Set
TF_ENABLE_DEPRECATION_WARNINGS=1 to re-enable them.
Waktu matmul dengan Tensorflow = 0.02
# mlp for binary classification
from pandas import read_csv
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
import numpy as np

# load dataset
path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/ion
osphere.csv'
df = read_csv(path, header=None)
# membagi kedalam kolom input dan output
X, y = df.values[:, :-1], df.values[:, -1]
# set tipe data menjadi float
X = X.astype('float32')
# membuat encode label
y = LabelEncoder().fit_transform(y)
# membagi kedalam dataset train dan test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3
3)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)
# determine the number of input features
n_features = X_train.shape[1]

untuk membuat model Neural Network dengan 3 layer

model = Sequential()
model.add(Dense(10, activation='relu', kernel_initializer='he_normal', 
input_shape=(n_features,)))
model.add(Dense(8, activation='relu', kernel_initializer='he_normal'))
model.add(Dense(1, activation='sigmoid'))
# compile model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['a
ccuracy'])

# fit model
model.fit(X_train, y_train, epochs=150, batch_size=32, verbose=0)
# evaluasi  model
loss, acc = model.evaluate(X_test, y_test, verbose=0)
print('Akurasi Data Tes: %.3f' % acc)

# make a prediction
row = np.random.random_sample((1,34))  
row = np.array(row)
yhat = model.predict(row)
print('Hasil Prediksi: %.3f' % yhat)
output :

(235, 34) (116, 34) (235,) (116,)

Akurasi Data Tes: 0.905
Hasil Prediksi: 0.744

# TensorFlow and tf.keras
import tensorflow as tf

# Helper libraries
import numpy as np
import matplotlib.pyplot as plt

fashion_mnist = tf.keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = fashion_mnis
t.load_data()
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False)
plt.show()

train_images = train_images / 255.0

test_images = test_images / 255.0
plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()
Melakukan proses training terhadap dataset
Bahan dataset untuk proses training model
train_images = train_images / 255.0

test_images = test_images / 255.0
plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()
Untuk membuat model
model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10)
])

Untuk meng-compile Model
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_l
ogits=True),
              metrics=['accuracy'])

untuk melatih Model
model.fit(train_images, train_labels, epochs=10)
untuk menguji model
test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose
=2)

print('\nTest accuracy:', test_acc)

probability_model = tf.keras.Sequential([model, 
                                         tf.keras.layers.Softmax()])

predictions = probability_model.predict(test_images)

np.argmax(predictions[0])

def plot_image(i, predictions_array, true_label, img):
  true_label, img = true_label[i], img[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])

  plt.imshow(img, cmap=plt.cm.binary)

  predicted_label = np.argmax(predictions_array)
  if predicted_label == true_label:
    color = 'blue'
  else:
    color = 'red'

  plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                100*np.max(predictions_array),
                                class_names[true_label]),
                                color=color)

def plot_value_array(i, predictions_array, true_label):
  true_label = true_label[i]
  plt.grid(False)
  plt.xticks(range(10))
  plt.yticks([])
  thisplot = plt.bar(range(10), predictions_array, color="#777777")
  plt.ylim([0, 1])
  predicted_label = np.argmax(predictions_array)

  thisplot[predicted_label].set_color('red')
  thisplot[true_label].set_color('blue')

i = 0
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i],  test_labels)
plt.show()

output :
Train on 60000 samples
Epoch 1/10
60000/60000 [==============================] - 2s 34us/sample - loss:
0.4963 - acc: 0.8268
Epoch 2/10
60000/60000 [==============================] - 2s 33us/sample - loss:
0.3782 - acc: 0.8637
Epoch 3/10
60000/60000 [==============================] - 2s 33us/sample - loss:
0.3386 - acc: 0.8756
Epoch 4/10
60000/60000 [==============================] - 2s 33us/sample - loss:
0.3158 - acc: 0.8832
Epoch 5/10
60000/60000 [==============================] - 2s 33us/sample - loss:
0.2969 - acc: 0.8898
Epoch 6/10
60000/60000 [==============================] - 2s 33us/sample - loss:
0.2815 - acc: 0.8951
Epoch 7/10
60000/60000 [==============================] - 2s 33us/sample - loss:
0.2706 - acc: 0.8998
Epoch 8/10
60000/60000 [==============================] - 2s 33us/sample - loss:
0.2590 - acc: 0.9039
Epoch 9/10
60000/60000 [==============================] - 2s 33us/sample - loss:
0.2490 - acc: 0.9069
Epoch 10/10
60000/60000 [==============================] - 2s 33us/sample - loss:
0.2410 - acc: 0.9100
10000/10000 - 0s - loss: 0.3479 - acc: 0.8784

Test accuracy: 0.8784

Mengevaluasi hasil prediksi

Menampilkan Salah Satu Hasil Prediksi Yang salah

Dalam hal ini gambar tersebut dikategorikan sebagai sandal (kode kelas 5), yang
seharusnya adalah kelas sneaker (kode kelas 7)
i = 12
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i],  test_labels)
plt.show()

Menampilkan Hasil Prediksi Keseluruhan Dari Algoritma yang

Dibangun
# Plot the first X test images, their predicted labels, and the true la
bels.
Biru adalah warna prediksi yang benar sedangkan yang merah adalah warna prediksi yang salah

num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
  plt.subplot(num_rows, 2*num_cols, 2*i+1)
  plot_image(i, predictions[i], test_labels, test_images)
  plt.subplot(num_rows, 2*num_cols, 2*i+2)
  plot_value_array(i, predictions[i], test_labels)
plt.tight_layout()
plt.show()