UNIVERSITAS GUNADARMA

PRAKTIKUM PENGANTAR KECERDASAN BUATAN

MANUAL BOOK

“Sign Language Translation - CNN”

Nama Glend Junus Lodo Li

NPM 52417576

Fakultas : Teknologi Industri

Jurusan : Teknik Informatika

Penanggung Jawab : Batari Wahyu

Ditulis Guna Melengkapi Sebagian Syarat

Praktikum Pengantar Kecerdasan Buatan Jenjang S1

Universitas Gunadarma

2019
 DAFTAR ISI

Daftar Isi............................................................................................... 1

BAB I : PENDAHULUAN ................................................................. 2

BAB II : PEMBAHASAN ................................................................... 3

BAB III : PERANCANGAN DAN IMPLEMENTASI....................... 11

LAMPIRAN ...............................................................................................13

Daftar Pustaka ............................................................................................32

1
 BAB I

PENDAHULUAN

1. Latar Belakang
Convolutional Neural Network adalah salah satu metode machine
learning dari pengembangan Multi Layer Perceptron (MLP) yang didesain
untuk mengolah data dua dimensi. CNN termasuk dalam jenis Deep Neural
Network karena dalamnya tingkat jaringan dan banyak diimplementasikan
dalam data citra. CNN memiliki dua metode; yakni klasifikasi
menggunakan feedforward dan tahap pembelajaran menggunakan
backpropagation. Cara kerja CNN memiliki kesamaan pada MLP, namun
dalam CNN setiap neuron dipresentasikan dalam bentuk dua dimensi, tidak
seperti MLP yang setiap neuron hanya berukuran satu dimensi.

2. Tujuan
Pada projek ini kami memilih penenerjemahan bahasa isyarat yaitu
merupakan image processing menggunakan algoritma pembelajaran
CNN(Convolutional Neural Network).Kami memilih judul karena untuk
mempelajari image processing dengan CNN.

2
 BAB II

PEMBAHASAN

1. Artificial Intelligence
Menurut Stuart J. Russel dan Peter Norvig, AI atau kecerdasan
buatan bisa dipahami sebagai sebuah perangkat komputer yang mampu
memahami lingkungan di sekitarnya, sekaligus memberikan respons yang
sesuai dengan tujuan tindakannya tersebut. Dalam hal ini, Minsky
memberikan pengertian yang hampir sama. Menurutnya, kecerdasan
buatan adalah satu ilmu yang mempelajari cara membuat komputer
melakukan atau memproduksi tindakan sama seperti yang dilakukan
manusia.

Melihat dua pengertian di atas, bisa disimpulkan jika Artificial

Intelligence adalah satu ilmu untuk merancang, membangun, dan
mengonstruksi satu mesin (komputer) atau program komputer hingga
memiliki kecerdasan layaknya manusia. Kecerdasan dalam hal ini adalah
kemampuan untuk mengambil tindakan, atau menyelesaikan masalah
layaknya manusia menggunakan kecerdasannya.

Lingkup penelitian Artificial Intelligence meliputi banyak aspek

kemampuan kecerdasan manusia seperti penalaran, pengetahuan,
perencanaan, pembelajaran, pemrosesan bahasa alami, hingga kemampuan
untuk memanipulasi objek. Akhirnya, Artificial Intelligence diharapkan
bisa menjadi sebuah mesin yang benar-benar memiliki kecerdasan umum
layaknya manusia.

Lebih jauh lagi, berikut adalah beberapa definisi mengenai kecerdasan

buatan, yang dapat diketahui, yaitu:
a. “Kecerdasan buatan (Artificial Intelligence) merupakan
kawasan penelitian, aplikasi dan instruksi yang terkait
dengan pemrograman komputer untuk melakukan sesuatu

3
 hal yang –dalam pandangan manusia adalah– cerdas”
– H. A. Simon (1987)

b. “Kecerdasan Buatan (AI) merupakan sebuah studi tentang

bagaimana membuat komputer melakukan hal-hal yang
pada saat ini dapat dilakukan lebih baik oleh manusia”
– Rich and Knight (1991)

c. “Bagian dari ilmu komputer yang mempelajari bagaimana

membuat mesin (komputer) dapat melakukan pekerjaan
seperti dan sebaik yang dilakukan oleh manusia bahkan bisa
lebih baik daripada yang dilakukan manusia”
– Idhawati Hestiningsih

2. Neural Network
Convolutional Neural Network (CNN) adalah salah satu jenis neural
network yang biasa digunakan pada data image. CNN bisa digunakan untuk
mendeteksi dan mengenali object pada sebuah image.
Secara garis besar CNN tidak jauh beda dengan neural network
biasanya. CNN terdiri dari neuron yang memiliki weight, bias dan
activation function.

Gambar. 1. Arsitektur MLP Sederhana

Sebuah MLP seperti pada Gambar. 1. memiliki i layer (kotak merah

dan biru) dengan masing-masing layer berisi ji neuron (lingkaran putih).
MLP menerima input data satu dimensi dan mempropagasikan data tersebut
pada jaringan hingga menghasilkan output. Setiap hubungan antar neuron
4
pada dua layer yang bersebelahan memiliki parameter bobot satu dimensi
yang menentukan kualitas mode. Disetiap data input pada layer dilakukan
operasi linear dengan nilai bobot yang ada, kemudian hasil komputasi akan
ditransformasi menggunakan operasi non linear yang disebut sebagai fungsi
aktivasi. Data yang dipropagasikan pada CNN adalah data dua dimensi,
sehingga operasi linear dan parameter bobot pada CNN berbeda. Operasi
linear pada CNN menggunakan operasi konvolusi, dengan bobot yang tidak
lagi satu dimensi saja, namun berbentuk empat dimensi yang merupakan
kumpulan kernel konvolusi seperti pada Gambar.2. Dimensi bobot pada
CNN adalah:

neuron input x neuron output x tinggi x lebar

Gambar 2. Proses Konvolusi pada CNN

CNN merupakan pengembangan lebih lanjut dari MLP karena

menggunakan metode yang mirip dengan dimensi yang lebih banyak. Di
algoritma CNN ini, input dari layer sebelumnya bukan array 1 dimensi
melainkan array 2 dimensi. Jika di analogikan dengan fitur dari wajah
manusia, layer pertama merupakan refleksi goresan-goresan berbeda arah,
pada layer kedua fitur seperti bentuk mata, hidung, dan mulut mulai terlihat,
hal ini karena di lakukan pooling/penggabungan dari layer pertama yang
masih berupa goresan-goresan, pada layer ketiga akan terbentuk kombinasi
fitur-fitur mata, hidung, dan mulut yang nantinya akan disimpulkan dengan
wajah orang tertentu.

5
 Gambar 3. Contoh dan arsitektur dari CNN

Sama halnya dengan Neural Network pada umumnya, CNN memiliki

beberapa lapisan tersembunyi (hidden layers) dari sebuah input berupa
vector tunggal. Pada Gambar 3, dengan input berupa citra yang dijadikan
vektor tunggal 32 × 32. Di tiap hidden layer, terdapat beberapa neuron
layaknya empat feature maps C1 pada gambar tersebut. Neuron-neuron
pada C1 dihubungkan dengan neuron di S1, dan seterusnya. Lapisan
terakhir yang terhubung dengan lapisan-lapisan tersembunyi sebelumnya
disebut dengan output layer dan merepresentasikan hasil akhir klasifikasi
kelas. Seperti n2 yang ditunjukkan oleh Gambar 2 yang merepresentasikan
hasil pada output layer, seperti 30, 50, 60, dll.

Keseluruhan skala dalam objek sangat penting agar input tidak

kehilangan informasi spasialnya yang akan diekstraksi fitur dan
diklasifikasikan. Hal ini akan menambah tingkat akurasi dan optimum
algoritma CNN. Seperti pada kubus yang memiliki skala pada panjang,
lebar, dan tinggi. Jika hanya menggunakan Neural Network biasa, mungkin
hanya memuat skala panjang dan tinggi. Namun CNN bisa memuat semua
informasi dari keseluruhan skala yang bisa mengklasifikasikan objek
dengan lebih akurat karena bisa menggunakan skala lebarnya juga (yang
mungkin tidak akan terlihat oleh Neural Network lainnya yang berdimensi
dua).

6
Gambar 4. Perbedaan arsitektur antara Neural Network pada umumnya dengan CNN

CNN terdiri dari berbagai lapisan yang dimana setiap lapisan memiliki
Application Program Interface (API) alias antarmuka program aplikasi sederhana.
Pada Gambar 4, CNN dengan input awal balok tiga dimensi akan
ditransformasikan menjadi output tiga dimensi dengan beberapa fungsi
diferensiasi yang memiliki atau tidak memiliki parameter. CNN membentuk
neuron-neuronnya ke dalam tiga dimensi (panjang, lebar, dan tinggi) dalam
sebuah lapisan.

Gambar 5. Lapisan yang terdapat pada CNN

1. Feature Learning
Lapisan-lapisan yang terdapat dalam Feature Learning berguna
untuk mentranslasikan suatu input menjadi menjadi features berdasarkan ciri
dari input tersebut yang berbentuk angka-angka dalam vektor. Lapisan
ekstraksi fitur ini terdiri dari Convolutional Layer dan Pooling Layer.
a. Convolutional Layer akan menghitung output dari neuron yang terhubung ke
daerah lokal dalam input, masing-masing menghitung produk titik antara
bobot mereka dan wilayah kecil yang terhubung ke dalam volume input.
b. Rectified Linear Unit (ReLU) akan menghilangkan vanishing gradient dengan
cara menerapkan fungsi aktivasi element sebagai f(x)=max⁡(0,x) alias
aktivasi elemen akan dilakukan saat berada di ambang batas 0. Kelebihan dan

7
 kekurangan dalam penggunaan ReLU :
(+) : Bisa mempercepat gradien stokastik dibandingkan dengan fungsi sigmoid /
tan h karena ReLU berbentuk linear
(+) : Tidak menggunakan operasi eksponensial seperti sigmoid/tan h, sehingga
bisa melakukan dengan pembuatan matriks aktivasi saat ambang batas berada
pada nilai 0.
(-) : ReLU bisa rapuh saat masa training dan mati karena gradien besar yang
mengalir melalui ReLU menyebabkan update bobot, sehingga neuron tidak
aktif pada datapoint lagi. Jika ini terjadi, maka gradien yang mengalir melalui
unit akan selamanya nol dari titik itu. Artinya, unit ReLU dapat mati secara
ireversibel selama pelatihan karena mereka dapat melumpuhkan data
manifold. Misalnya, Anda mungkin menemukan bahwa sebanyak 40% dari
jaringan Anda dapat “mati” (yaitu neuron yang tidak pernah aktif di seluruh
dataset pelatihan) jika tingkat pembelajaran ditetapkan terlalu tinggi. Dengan
pengaturan tingkat pembelajaran yang tepat, ini lebih jarang menjadi
masalah.

c. Pooling Layer
Pooling layer adalah lapisan yang mengurangi dimensi dari feature
map atau lebih dikenal dengan langkan untuk downsampling, sehingga
mempercepat komputasi karena parameter yang harus diupdate semakin
sedikit dan mengatasi overfitting. Pooling yang biasa digunakan adalah Max
Pooling dan Average Pooling. Max Pooling untuk menentukan nilai
maksimum tiap pergeseran filter, sementara Average Pooling akan
menentukan nilai rata-ratanya.

Gambar 6. Contoh dari max pooling

8
2. Classification
Lapisan ini berguna untuk mengklasifikasikan tiap neuron yang
telah diekstraksi fitur pada sebelumnya. Terdiri dari :
a. Flatten
Membentuk ulang fitur (reshape feature map) menjadi sebuah vector agar
bisa kita gunakan sebagai input dari fully-connected layer.
b. Fully-connected
Lapisan FC (yaitu terhubung sepenuhnya) akan menghitung skor kelas.
Seperti Jaringan Saraf biasa dan seperti namanya, setiap neuron dalam
lapisan ini akan terhubung ke semua angka dalam volume.
c. Softmax
Fungsi Softmax menghitung probabilitas dari setiap kelas target atas semua
kelas target yang memungkinkan dan akan membantu untuk menentukan
kelas target untuk input yang diberikan. Keuntungan utama menggunakan
Softmax adalah rentang probabilitas output dengan nilai 0 hingga 1, dan
jumlah semua probabilitas akan sama dengan satu. Jika fungsi softmax
digunakan untuk model multi-klasifikasi, dia akan mengembalikan peluang
dari masing-masing kelas dan kelas target akan memiliki probabilitas tinggi.
Softmax menggunakan eksponensial (e-power) dari nilai input yang
diberikan dan jumlah nilai eksponensial dari semua nilai dalam input. Maka
rasio eksponensial dari nilai input dan jumlah nilai eksponensial adalah
output dari fungsi softmax.

3. Library Python
a. Tensorflow
Tensorflow adalah library untuk deep learning (neural net dengan
banyak layer dan bermacam topologi) yang dikembangkan Google
dan dijadikan open source
b. OS
OS merupakan library yang digunakan untuk mengambil file pada
storage pada Python
c. Numpy
Numpy merupakan library yang bersifat fundamental untuk
komputasi scientific pada Pyhton
9
d. Matplotlib.pyplot
Matplotlib adalah library 2 dimensi pada Python yang mengolah
angka menjadi gambar yang interaktif misalnya, grafik dan tabel
e. Pandas
Pandas berfungsi untuk membaca file dari berbagai format seperti .txt, .csv, .tsv,
dan lainnya. Anggap saja Pandas adalah spreadsheet namun tidak memiliki GUI
dan punya fitur seperti SQL.

10
 BAB III

PERANCANGAN DAN IMPLEMENTASI

1. Perancangan
Pada project perancangan kecerdasan buatan tentang Convolutional
Nueral Network, ada berbagai macam hal yang dibutuhkan, yaitu :

a. Google colab
b. Menginstal library Kaggle pada
colab

c. Library Python yaitu, Tensorflow, Scipy, Scikit Image, Pandas,

OpenCV, Numpy dan Matplotlib

11
2. Implementasi
a. Installasi Kaggle pada colab
1. Buka Google colab
https://colab.research.google.com
2. Cari data source di Kaggle.

3. Login menggunakan ke dalam menggunakan akun google lalu masuk ke “My

Account” lalu scroll kebawah hingga bagian “API” lalu klik “Crate New API
TOKEN”,maka file Kaggle.json akan ter-download,file ini merupakan cara sederhana
berbasis teks untuk menyimpan dan mengirim data terstruktur

4.Buka link data set yang sudah ditentukan pada Kaggle klik pada lalu pilih Copy
API Command

12
 LAMPIRAN

Kodingan

!pip install kaggle

from google.colab import files

files.upload()

!mkdir -p ~/.kaggle
!cp kaggle.json ~/.kaggle/

!chmod 600 ~/.kaggle/kaggle.json

!kaggle datasets download -d datamunge/sign-language-mnist

from zipfile import ZipFile

file_name = "sign-language-mnist.zip"

with ZipFile (file_name, 'r') as zip :

zip.extractall()
print ('Done')

import warnings
warnings.filterwarnings('ignore')

import os
print(os.listdir("../content"))

import numpy as np
import pandas as pd
import tensorflow as tf
import matplotlib.pyplot as plt
from collections import Counter

data = pd.read_csv('../content/sign_mnist_train.csv')
print('Dataframe Shape:', data.shape)

data.head()
13
x = data.iloc[:, 1:].values
print("Number of images:", x.shape[0])
print("Number of pixels in each image:", x.shape[1])

y = data.iloc[:, :1].values.flatten()
print('Labels:\n', y)
print('Shape of Labels:', y.shape)

def next_batch(batch_size, data, labels):

idx = np.arange(0, len(data))
np.random.shuffle(idx)
idx = idx[: batch_size]
data_shuffle = [data[i] for i in idx]
labels_shuffle = [labels[i] for i in idx]
return np.asarray(data_shuffle), np.asarray(labels_shuffle)

def display_images(data):
x, y = data
fig, axes = plt.subplots(3, 3)
fig.subplots_adjust(hspace = 0.5, wspace = 0.5)
for i, ax in enumerate(axes.flat):
ax.imshow(x[i].reshape(28, 28), cmap = 'binary')
ax.set_xlabel(chr(y[i] + 65))
ax.set_xticks([])
ax.set_yticks([])
plt.show()

display_images(next_batch(9, x, y))

z = dict(Counter(list(y)))
labels = z.keys()
frequencies = [z[i] for i in labels]
labels = [chr(i + 65) for i in z.keys()]

plt.figure(figsize = (20, 10))

plt.bar(labels, frequencies)
plt.title('Frequency Distribution of Alphabets', fontsize = 20)
plt.show()

def one_hot_encode(y):
14
 return np.eye(25)[y]
y_encoded = one_hot_encode(y)
print('Shape of y after encoding:', y_encoded.shape)

# Training Parameters
learning_rate = 0.001
epochs = 2000
batch_size = 128
display_step = 100

# Neural Network Hyperparameters

n_input = 784
n_classes = 25
dropout = 0.75

# Placeholders
X = tf.placeholder(tf.float32, shape = [None, n_input]) # Placeholder for Fea
ture Matrix
Y = tf.placeholder(tf.float32, shape = [None, n_classes]) # Placeholder for L
abels
keep_prob = tf.placeholder(tf.float32) # Placeholder for Dropout Rate

weights = {
# Weight for Convolutional Layer 1: 5x5 filter, 1 input channel, 32 outpu
t channels
'w1' : tf.Variable(tf.random_normal([5, 5, 1, 32])),
# Weight for Convolutional Layer 2: 5x5 filter, 32 input channels, 64 out
put channels
'w2' : tf.Variable(tf.random_normal([5, 5, 32, 64])),
# Weight for Fully Connected Layer 1: 49 * 64 input channels, 1024 output
channels
'w3' : tf.Variable(tf.random_normal([7 * 7 * 64, 1024])),
# Weight for Convolutional Layer 1: 1024 input channels, 25(number of cla
sses) output channels
'w4' : tf.Variable(tf.random_normal([1024, n_classes]))
}
biases = {
# Bias for Convolutional Layer 1
'b1' : tf.Variable(tf.random_normal([32])),
# Bias for Convolutional Layer 2
'b2' : tf.Variable(tf.random_normal([64])),
15
 # Bias for Fully Connected Layer 1
'b3' : tf.Variable(tf.random_normal([1024])),
# Bias for Outout Layer
'b4' : tf.Variable(tf.random_normal([n_classes]))
}

# Wrapper function for creating a Convolutional Layer

def conv2d(x, W, b, strides = 1):
x = tf.nn.conv2d(x, W, strides = [1, strides, strides, 1], padding='SAME'
)
x = tf.nn.bias_add(x, b)
return tf.nn.relu(x)

# Wrapper function for creating a Pooling Layer

def maxpool2d(x, k=2):
return tf.nn.max_pool(x, ksize = [1, k, k, 1], strides = [1, k, k, 1], pa
dding = 'SAME')

def neural_network(x, weight, bias, dropout):

x = tf.reshape(x, shape = [-1, 28, 28, 1])

conv1 = conv2d(x, weight['w1'], bias['b1']) # Convolutional Layer 1

conv1 = maxpool2d(conv1) # Pooling Layer 1

conv2 = conv2d(conv1, weight['w2'], bias['b2']) # Convolutional Layer 1

conv2 = maxpool2d(conv2) # Pooling Layer 1

# Fully Connected Layer 1

# Reshaping output of previous convolutional layer to fit the fully conne
cted layer
fc = tf.reshape(conv2, [-1, weights['w3'].get_shape().as_list()[0]])
fc = tf.add(tf.matmul(fc, weight['w3']), bias['b3']) # Linear Function
fc = tf.nn.relu(fc) # Activation Function

fc = tf.nn.dropout(fc, dropout) # Applying dropout on Fully Connected Lay

er

out = tf.add(tf.matmul(fc, weight['w4']), bias['b4']) # Output Layer

return out

16
logits = neural_network(X, weights, biases, keep_prob)

loss_op = tf.nn.softmax_cross_entropy_with_logits_v2(logits = logits, labels

= Y)
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate)
train_op = optimizer.minimize(loss_op)

correct_pred = tf.equal(tf.argmax(logits, 1), tf.argmax(Y, 1))

accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

init = tf.global_variables_initializer()

# Splitting the dataset into Training and Holdout(Test set)

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(x, y_encoded, test_size =
0.33, random_state = 42)
print('X train shape', X_train.shape)
print('y train shape', y_train.shape)
print('X test shape', X_test.shape)
print('y test shape', y_test.shape)

with tf.Session() as sess:

# Running Initializer
sess.run(init)
cost_hist, acc_hist = [], []
for epoch in range(1, epochs + 1):
_x, _y = next_batch(batch_size, X_train, y_train)
# Running Optimizer
sess.run(train_op, feed_dict = { X : _x, Y : _y, keep_prob : dropout
})
if epoch % display_step == 0:
# Calculating Loss and Accuracy on the current Epoch
loss, acc = sess.run([loss_op, accuracy], feed_dict = { X : _x, Y
: _y, keep_prob : 1.0 })
loss = sum(loss)
cost_hist.append(loss)
acc_hist.append(acc)
print('Epoch ' + str(epoch) + ', Cost: ' + str(loss) + ', Accurac
y: ' + str(acc * 100) + ' %')
17
 print('-' * 50)
print('\nOptimization Finished\n')
print('Accuracy on Training Data: ' + str(sess.run(accuracy,
feed_dict = {
X : X_train,
Y : y_train,
keep_prob : 1.0
}) * 100) + ' %')
print('Accuracy on Test Data: ' + str(sess.run(accuracy,
feed_dict = {
X : X_test,
Y : y_test,
keep_prob : 1.0
}) * 100) + ' %')

plt.plot(list(range(len(cost_hist))), cost_hist)
plt.title("Change in cost")
plt.show()

plt.plot(list(range(len(acc_hist))), acc_hist)
plt.title("Change in accuracy")
plt.show()

print('Training on the whole dataset....\n')

with tf.Session() as sess:
sess.run(init) # Running Initializer
cost_hist, acc_hist = [], []
for epoch in range(1, epochs + 1):
_x, _y = next_batch(batch_size, x, y_encoded)
# Running Optimizer
sess.run(train_op,
feed_dict = {
X : _x,
Y : _y,
keep_prob : dropout
})
if epoch % display_step == 0:
# Calculating Loss and Accuracy on the current Epoch
loss, acc = sess.run([loss_op, accuracy],
18
 feed_dict = {
X : _x,
Y : _y,
keep_prob : 1.0
})
loss = sum(loss)
cost_hist.append(loss)
acc_hist.append(acc)
print('Epoch ' + str(epoch) + ', Cost: ' + str(loss) + ', Accurac
y: ' + str(acc * 100) + ' %')
print('-' * 50)
print('\nOptimization Finished\n')
print('Accuracy after training on whole dataset Data: ' + str(sess.run(ac
curacy,
feed_dict = {
X : x,
Y : y_encoded,
keep_prob : 1.0
}) * 100) + ' %')
W = sess.run(weights)
B = sess.run(biases)

plt.plot(list(range(len(cost_hist))), cost_hist)
plt.title("Change in cost")
plt.show()

19
plt.plot(list(range(len(acc_hist))), acc_hist)
plt.title("Change in accuracy")
plt.show()

data_test = pd.read_csv('../content/sign_mnist_test.csv')
print('Dataframe Shape:', data_test.shape)

data_test.head()

x_test = data_test.iloc[:, 1:].values

y_test = data_test.iloc[:, :1].values.flatten()
y_test = one_hot_encode(y_test)
x_test.shape, y_test.shape

X = tf.placeholder(tf.float32, shape = [None, n_input]) # Placeholder for Fea

ture Matrix
Y = tf.placeholder(tf.float32, shape = [None, n_classes]) # Placeholder for L
abels
keep_prob = tf.placeholder(tf.float32) # Placeholder for Dropout Rate

y_pred = neural_network(X, W, B, 1.0)

def get_prediction(img):
with tf.Session() as sess:
pred = sess.run(y_pred, feed_dict = { X : img, keep_prob : 1.0 })
img = img.reshape(28, 28)
pred = list(pred.flatten())
pred = chr(pred.index(max(pred)) + 65)
return (img, pred)

image, pred = get_prediction(x_test[1].reshape(1, 784))

plt.imshow(image, cmap = 'binary')
plt.title(pred)
plt.show()
20
for key in W.keys():
np.save(key, W[key])

for key in B.keys():

np.save(key, B[key])

21
Penjelasan :

1.Digunakan untuk mengimport dataset kedalam google colab

from google.colab import files
files.upload()

!mkdir -p ~/.kaggle
!cp kaggle.json ~/.kaggle/

!chmod 600 ~/.kaggle/kaggle.json

!kaggle datasets download -d datamunge/sign-language-mnist

from zipfile import ZipFile

file_name = "sign-language-mnist.zip"

with ZipFile (file_name, 'r') as zip :

zip.extractall()
print ('Done')

2.Potongan skrip berikut digunakan untuk menggunakan library yang ada pada python dalam colab
import warnings
warnings.filterwarnings('ignore')

import os
print(os.listdir("../content"))

import numpy as np
import pandas as pd
import tensorflow as tf
import matplotlib.pyplot as plt
from collections import Counter

3.Potongan ini digunakan untuk Analisis eksplorasi data train

data = pd.read_csv('../content/sign_mnist_train.csv')
print('Dataframe Shape:', data.shape)

data.head()

x = data.iloc[:, 1:].values
22
print("Number of images:", x.shape[0])
print("Number of pixels in each image:", x.shape[1])

y = data.iloc[:, :1].values.flatten()
print('Labels:\n', y)
print('Shape of Labels:', y.shape)

def next_batch(batch_size, data, labels):

idx = np.arange(0, len(data))
np.random.shuffle(idx)
idx = idx[: batch_size]
data_shuffle = [data[i] for i in idx]
labels_shuffle = [labels[i] for i in idx]
return np.asarray(data_shuffle), np.asarray(labels_shuffle)

def display_images(data):
x, y = data
fig, axes = plt.subplots(3, 3)
fig.subplots_adjust(hspace = 0.5, wspace = 0.5)
for i, ax in enumerate(axes.flat):
ax.imshow(x[i].reshape(28, 28), cmap = 'binary')
ax.set_xlabel(chr(y[i] + 65))
ax.set_xticks([])
ax.set_yticks([])
plt.show()

display_images(next_batch(9, x, y))

z = dict(Counter(list(y)))
labels = z.keys()
frequencies = [z[i] for i in labels]
labels = [chr(i + 65) for i in z.keys()]

plt.figure(figsize = (20, 10))

plt.bar(labels, frequencies)
plt.title('Frequency Distribution of Alphabets', fontsize = 20)
plt.show()

def one_hot_encode(y):
return np.eye(25)[y]
y_encoded = one_hot_encode(y)
23
print('Shape of y after encoding:', y_encoded.shape)

5.Potongan skrip berikut digunakan untuk membuat struktur CNN

# Training Parameters
learning_rate = 0.001
epochs = 2000
batch_size = 128
display_step = 100

# Neural Network Hyperparameters

n_input = 784
n_classes = 25
dropout = 0.75

# Placeholders
X = tf.placeholder(tf.float32, shape = [None, n_input]) # Placeholder for Fea
ture Matrix
Y = tf.placeholder(tf.float32, shape = [None, n_classes]) # Placeholder for L
abels
keep_prob = tf.placeholder(tf.float32) # Placeholder for Dropout Rate

weights = {
# Weight for Convolutional Layer 1: 5x5 filter, 1 input channel, 32 outpu
t channels
'w1' : tf.Variable(tf.random_normal([5, 5, 1, 32])),
# Weight for Convolutional Layer 2: 5x5 filter, 32 input channels, 64 out
put channels
'w2' : tf.Variable(tf.random_normal([5, 5, 32, 64])),
# Weight for Fully Connected Layer 1: 49 * 64 input channels, 1024 output
channels
'w3' : tf.Variable(tf.random_normal([7 * 7 * 64, 1024])),
# Weight for Convolutional Layer 1: 1024 input channels, 25(number of cla
sses) output channels
'w4' : tf.Variable(tf.random_normal([1024, n_classes]))
}
biases = {
# Bias for Convolutional Layer 1
'b1' : tf.Variable(tf.random_normal([32])),
# Bias for Convolutional Layer 2
'b2' : tf.Variable(tf.random_normal([64])),
# Bias for Fully Connected Layer 1
'b3' : tf.Variable(tf.random_normal([1024])),

24
 # Bias for Outout Layer
'b4' : tf.Variable(tf.random_normal([n_classes]))
}

# Wrapper function for creating a Convolutional Layer

def conv2d(x, W, b, strides = 1):
x = tf.nn.conv2d(x, W, strides = [1, strides, strides, 1], padding='SAME'
)
x = tf.nn.bias_add(x, b)
return tf.nn.relu(x)

# Wrapper function for creating a Pooling Layer

def maxpool2d(x, k=2):
return tf.nn.max_pool(x, ksize = [1, k, k, 1], strides = [1, k, k, 1], pa
dding = 'SAME')

def neural_network(x, weight, bias, dropout):

x = tf.reshape(x, shape = [-1, 28, 28, 1])

conv1 = conv2d(x, weight['w1'], bias['b1']) # Convolutional Layer 1

conv1 = maxpool2d(conv1) # Pooling Layer 1

conv2 = conv2d(conv1, weight['w2'], bias['b2']) # Convolutional Layer 1

conv2 = maxpool2d(conv2) # Pooling Layer 1

# Fully Connected Layer 1

# Reshaping output of previous convolutional layer to fit the fully conne
cted layer
fc = tf.reshape(conv2, [-1, weights['w3'].get_shape().as_list()[0]])
fc = tf.add(tf.matmul(fc, weight['w3']), bias['b3']) # Linear Function
fc = tf.nn.relu(fc) # Activation Function

fc = tf.nn.dropout(fc, dropout) # Applying dropout on Fully Connected Lay

er

out = tf.add(tf.matmul(fc, weight['w4']), bias['b4']) # Output Layer

return out

logits = neural_network(X, weights, biases, keep_prob)

25
loss_op = tf.nn.softmax_cross_entropy_with_logits_v2(logits = logits, labels
= Y)
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate)
train_op = optimizer.minimize(loss_op)

correct_pred = tf.equal(tf.argmax(logits, 1), tf.argmax(Y, 1))

accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

init = tf.global_variables_initializer()

6. Memisahkan dataset ke dalam Training and Holdout (Test set)

# Splitting the dataset into Training and Holdout(Test set)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(x, y_encoded, test_size =
0.33, random_state = 42)
print('X train shape', X_train.shape)
print('y train shape', y_train.shape)
print('X test shape', X_test.shape)
print('y test shape', y_test.shape)

with tf.Session() as sess:

# Running Initializer
sess.run(init)
cost_hist, acc_hist = [], []
for epoch in range(1, epochs + 1):
_x, _y = next_batch(batch_size, X_train, y_train)
# Running Optimizer
sess.run(train_op, feed_dict = { X : _x, Y : _y, keep_prob : dropout
})
if epoch % display_step == 0:
# Calculating Loss and Accuracy on the current Epoch
loss, acc = sess.run([loss_op, accuracy], feed_dict = { X : _x, Y
: _y, keep_prob : 1.0 })
loss = sum(loss)
cost_hist.append(loss)
acc_hist.append(acc)
print('Epoch ' + str(epoch) + ', Cost: ' + str(loss) + ', Accurac
y: ' + str(acc * 100) + ' %')
print('-' * 50)
print('\nOptimization Finished\n')
26
 print('Accuracy on Training Data: ' + str(sess.run(accuracy,
feed_dict = {
X : X_train,
Y : y_train,
keep_prob : 1.0
}) * 100) + ' %')
print('Accuracy on Test Data: ' + str(sess.run(accuracy,
feed_dict = {
X : X_test,
Y : y_test,
keep_prob : 1.0
}) * 100) + ' %')

plt.plot(list(range(len(cost_hist))), cost_hist)
plt.title("Change in cost")
plt.show()

plt.plot(list(range(len(acc_hist))), acc_hist)
plt.title("Change in accuracy")
plt.show()

7. Mentrain Neural Network pada seluruh dataset untuk mendapatkan Weight dan Bias yang Dioptimalkan
print('Training on the whole dataset....\n')
with tf.Session() as sess:
sess.run(init) # Running Initializer
cost_hist, acc_hist = [], []
for epoch in range(1, epochs + 1):
_x, _y = next_batch(batch_size, x, y_encoded)
# Running Optimizer
sess.run(train_op,
feed_dict = {
X : _x,
Y : _y,
keep_prob : dropout
})
if epoch % display_step == 0:
# Calculating Loss and Accuracy on the current Epoch
loss, acc = sess.run([loss_op, accuracy],
feed_dict = {
X : _x,

27
 Y : _y,
keep_prob : 1.0
})
loss = sum(loss)
cost_hist.append(loss)
acc_hist.append(acc)
print('Epoch ' + str(epoch) + ', Cost: ' + str(loss) + ', Accurac
y: ' + str(acc * 100) + ' %')
print('-' * 50)
print('\nOptimization Finished\n')
print('Accuracy after training on whole dataset Data: ' + str(sess.run(ac
curacy,
feed_dict = {
X : x,
Y : y_encoded,
keep_prob : 1.0
}) * 100) + ' %')
W = sess.run(weights)
B = sess.run(biases)

plt.plot(list(range(len(cost_hist))), cost_hist)
plt.title("Change in cost")
plt.show()

28
plt.plot(list(range(len(acc_hist))), acc_hist)
plt.title("Change in accuracy")
plt.show()

8.Memprediksi model pada data test

data_test = pd.read_csv('../content/sign_mnist_test.csv')
print('Dataframe Shape:', data_test.shape)

data_test.head()

x_test = data_test.iloc[:, 1:].values

y_test = data_test.iloc[:, :1].values.flatten()
y_test = one_hot_encode(y_test)
x_test.shape, y_test.shape

X = tf.placeholder(tf.float32, shape = [None, n_input]) # Placeholder for Fea

ture Matrix
Y = tf.placeholder(tf.float32, shape = [None, n_classes]) # Placeholder for L
abels
keep_prob = tf.placeholder(tf.float32) # Placeholder for Dropout Rate

y_pred = neural_network(X, W, B, 1.0)

def get_prediction(img):
with tf.Session() as sess:
pred = sess.run(y_pred, feed_dict = { X : img, keep_prob : 1.0 })
img = img.reshape(28, 28)
pred = list(pred.flatten())
pred = chr(pred.index(max(pred)) + 65)
return (img, pred)

image, pred = get_prediction(x_test[1].reshape(1, 784))

plt.imshow(image, cmap = 'binary')
plt.title(pred)

29
plt.show()

9.Menyimpan parameter
for key in W.keys():
np.save(key, W[key])

for key in B.keys():

np.save(key, B[key])

30
Outputnya :

31
 DAFTAR PUSTAKA

NN. 2012. Dasar Pemahaman Neural Network.

https://medium.com/@nadhifasofia/1-convolutional-neural-network-
convolutional-neural-network-merupakan-salah-satu-metode-machine-
28189e17335b. Diunduh pada tanggal 5 Oktober 2019

32