Vector, Skalar, Matriks, dan Tensor

Vector Dalam konteks Deep Learning, vektor memiliki peran penting sebagai representasi matematis yang mendefinisikan input,
output, parameter, bias, gradient, dan sebagainya. Berikut adalah beberapa fungsi vektor dalam Deep Learning:

Representasi Data: Vektor digunakan untuk merepresentasikan data input, seperti pada gambar, teks, atau data numerik
lainnya. Setiap elemen vektor biasanya mewakili fitur atau nilai tertentu dari data.
Bobot dan Bias: Dalam jaringan saraf, vektor bobot digunakan untuk menghubungkan neuron antar lapisan. Bobot
merepresentasikan kekuatan koneksi antar neuron. Selain itu, bias ditambahkan ke vektor keluaran dari lapisan
sebelumnya sebelum dijadikan input untuk fungsi aktivasi.
Masukan dan Keluaran Model: Bagian penting dari model Deep Learning, seperti jaringan saraf, sering kali menerima
vektor sebagai masukan dan memberikan vektor luaran setelah proses yang sesuai.
Error dan Gradient: Saat melakukan proses pelatihan (training), kesalahan (error) model diukur menggunakan vektor untuk
menyesuaikan bobot model. Metode backpropagation menghasilkan gradient vektor yang menunjukkan arah di mana kita
harus menyesuaikan bobot agar kesalahan model berkurang.
Parameter Model: Bobot dan bias model Deep Learning sering dinyatakan dalam bentuk vektor yang panjangnya
ditentukan oleh jumlah parameter model.

Skalar adalah entitas matematis tunggal yang hanya memiliki magnitudo (nilai) tanpa arah atau orientasi tertentu. Dalam
berbagai operasi matematis dan aplikasi Deep Learning, skalar digunakan untuk merepresentasikan berbagai komponen, seperti:

Loss Function: Skalar sering digunakan untuk mengukur seberapa baik model Machine Learning atau Deep Learning
bekerja. Nilai skalar ini (biasanya disebut "loss" atau "cost") menyatakan seberapa dekat prediksi model dengan nilai yang
sebenarnya.
Output dari Layer: Ketika sebuah neural network atau model Deep Learning mentransfer sinyal dari satu lapisan ke lapisan
lainnya, output umumnya adalah skalar.
Learning Rate: Learning rate digunakan untuk mengontrol seberapa banyak model harus beradaptasi pada setiap langkah
iterasi sehingga nilai loss berkurang. Learning rate juga merupakan skalar penting dalam proses optimisasi.
 Bias dalam Linear Layer: Bias umumnya merupakan skalar yang ditambahkan ke jumlah berbobot dalam perhitungan
dalam lapisan neural network. Nilai Bobot (Weight): Dalam beberapa kasus, nilai bobot yang memberikan bobot pada
berbagai hubungan antara neuron/neuron harus berupa skalar.
Error dan Gradients: Error dan gradien sebagian besar adalah skalar yang memberikan informasi evaluasi terkait
bagaimana model menyesuaikan prediksi dengan target yang sebenarnya.

Matriks adalah salah satu struktur data yang sangat umum digunakan.

Berikut adalah beberapa contoh peran penting matriks dalam deep learning:

Bobot Antar-Neuron: Matriks bobot digunakan untuk menghubungkan neuron dari satu lapisan ke neuron di lapisan
berikutnya dalam jaringan saraf tiruan. Setiap baris dalam matriks bobot mengaitkan keluaran suatu neuron dengan
masukan ke neuron berikutnya.
Data Masukan: Data dalam deep learning sering direpresentasikan dalam bentuk matriks. Misalnya, gambar grayscale bisa
direpresentasikan sebagai matriks dua dimensi, sementara gambar berwarna mungkin sebagai matriks tiga dimensi.
Lapisan Output: Keluaran dari model deep learning dapat direpresentasikan dalam bentuk matriks, khususnya dalam
konteks klasifikasi multi-kelas di mana setiap baris matriks mewakili probabilitas kelas tertentu. Operasi Konvolusi: Operasi
konvolusi penting dalam deep learning melibatkan penggunaan berbagai matriks kernel untuk mengekstrak fitur dari data,
seperti citra.
Operasi Matematika: Banyak operasi matematika dalam deep learning melibatkan manipulasi matriks, seperti perkalian
matriks, penjumlahan matriks, ataupun dekomposisi matriks.
Pemrosesan Bahasa: Dalam Natural Language Processing, matriks embedding digunakan untuk merepresentasikan kata-
kata atau entitas lainnya dalam ruang vektor numerik untuk analisis dan pemrosesan lebih lanjut.

Matriks memainkan peran kunci dalam merepresentasikan dan memanipulasi data dalam banyak model dan algoritma deep
learning, serta menjadi pondasi penting untuk operasi-operasi matematis dan perhitungan yang kompleks.

Tensor

Dalam konteks Deep Learning, tensor merupakan struktur data multidimensional yang sangat penting. Berikut adalah beberapa
peran penting tensor dalam Deep Learning:
 Representasi Data: Tensor digunakan untuk merepresentasikan data dalam berbagai bentuk, seperti gambar (2D tensor),
video (3D tensor), teks (1D tensor), dan data lainnya.
Bobot Model: Bobot dan parameter model dalam Deep Learning, seperti jaringan saraf, disimpan dalam tensor
multidimensional. Setiap layer dalam model neural network akan memiliki tensor bobot yang sesuai.
Operasi Matematika: Tensor digunakan dalam operasi matematika yang penting seperti perkalian tensor, penjumlahan
tensor, dan operasi lainnya yang ada di balik sistem Deep Learning, misalnya proses feedforward, backpropagation, dan
optimisasi.
Ekstraksi Fitur: Dalam konvolusi dan pengolahan citra, tensor digunakan untuk menyimpan gambar dan ekstrak fitur
menggunakan filter konvolusi. Arus Data: Data dalam model Deep Learning disalurkan melalui tensor. Nilai-nilai tensor
diubah dan diproses melalui berbagai lapisan jaringan untuk membuat prediksi atau evaluasi.
Output Model: Keluaran dari model Deep Learning direpresentasikan dalam bentuk tensor. Misalnya, dalam klasifikasi
gambar, probabilitas kelas yang diberikan untuk data input direpresentasikan dalam tensor.

Tensor adalah struktur data fundamental dalam deep learning yang mendefinisikan berbagai operasi yang dilakukan pada data,
memungkinkan penggunaan data dalam jumlah dimensi tertentu, mulai dari skalar (0D tensor) hingga array multidimensional
berdimensi tinggi.

keyboard_arrow_down TensorFlow Dasar

TensorFlow adalah sebuah platform open source yang dikembangkan oleh tim Google Brain untuk keperluan komputasi numerik dan
kecerdasan buatan (AI).

Berikut adalah beberapa dasar-dasar TensorFlow:

Definisi Graph: TensorFlow beroperasi dalam konsep computational graph, di mana operasi-operasi dibangun sebagai bagian
dari graf yang menunjukkan alur data antara node.

Tensor: Data dalam TensorFlow direpresentasikan sebagai tensor, yang pada dasarnya adalah array multidimensional.

Session: Untuk mengeksekusi operasi dalam TensorFlow, Anda perlu menginisiasi sesi atau session. Dalam sesi ini, barulah
operasi-operasi dijalankan.
 Variabel: Variabel digunakan untuk menyimpan parameter yang dapat diubah oleh model selama proses pelatihan.

Modeling: TensorFlow sangat populer untuk pembuatan, pelatihan, dan penilaian model neural networks dan berbagai model
machine learning lainnya. GPU Acceleration: TensorFlow mendukung akselerasi GPU untuk melatih model deep learning dengan
kecepatan yang lebih tinggi daripada melatih pada CPU.

TensorBoard: TensorFlow menyertakan TensorBoard, alat visualisasi yang memungkinkan Anda menganalisis bagaimana model
Anda berperforma dan memahami graf operasi yang anda buat.

Kers: TensorFlow memiliki API tingkat tinggi, Keras, yang mempermudah pembuatan dan pelatihan jaringan saraf berbasis graf.

Dengan TensorFlow, para peneliti dan praktisi dapat membangun, melatih, dan menerapkan berbagai model machine learning
dan kecerdasan buatan dengan kemampuan secara scalable dari komputasi paralel yang ditawarkannya.

# import tensorflow dan libr numpy

import tensorflow as tf
import numpy as np

# aktifkan sesi interaktif tensorflow

sess = tf.compat.v1.InteractiveSession()

# mendefinisikan tensor
a = tf.zeros((2,2))
b = tf.ones((2,2))

# menjumlahkan elemen diseluruh dimensi tensor

x = tf.constant([[1,1,1], [1,1,1]])
tf.reduce_sum(x)

<tf.Tensor: shape=(), dtype=int32, numpy=6>

# Memeriksa bentuk tensor
a.get_shape()

TensorShape([2, 2])

tf.reshape(a,(1,4))

<tf.Tensor: shape=(1, 4), dtype=float32, numpy=array([[0., 0., 0., 0.]], dtype=float32)>

#bentuk tensor didlam TensorFlow

ta = tf.zeros((2,2))
print(ta)

tf.Tensor(
[[0. 0.]
[0. 0.]], shape=(2, 2), dtype=float32)

a = np.zeros((2,2))
a

array([[0., 0.],
[0., 0.]])
# definisi konstanta tensorflow

a = tf.constant(1)
b = tf.constant(5)

c = a*b # operasi perkalian tensor

with tf.compat.v1.Session() as sess:

print(c)

tf.Tensor(5, shape=(), dtype=int32)

#definisi variabel tensorflow

w = tf.Variable(tf.ones(2,2), name='weight')

#buat sesi tensorflow

with tf.compat.v1.Session() as sess:
# buat grafik aliran data
c = tf.constant([[1.0,2.0], [3.0, 4.0]])
d = tf.constant([[1.0,1.0], [0.0, 1.0]])
e = tf.matmul(c,d)
# menjalankan grafik dan simpan nilai ke variabel e
result = sess.run(e)
print(result)

[[1. 3.]
[3. 7.]]
keyboard_arrow_down Optimasi di TensorFlow
Optimizer dlm tensorflow : mengoptimalkan model deep learning dgn memperbaharui bobot secara iteratif selama proses pelatihan
(training)

bentuk optimizer di TensorFlow:

1. AdamOptimizer tf.train.AdamOptimizer
2. GradientDescentOptimizer tf.train.GradientDescentOptimizer
3. RMSPropOptimizer tf.train.RMSPropOptimizer
4. AdagradOptimizer tf.train.AdagradOptimizer
5. MomentumOptimizer tf.train.MomentumOptimizer

import tensorflow as tf
import numpy as np

# dataset dummy
X_train = np.random.rand(1000, 10)
Y_train = np.random.randint(0, 2, (1000,))

# building model

model = tf.keras.Sequential([
tf.keras.layers.Dense(64, activation='relu', input_shape=(10,)),
tf.keras.layers.Dense(1, activation='sigmoid')
])

#optimizer dan loss function

learning_rate = 0.01
optimizer_types = ['SGD', 'Adam', 'RMSprop', 'Adagrad', 'Momentum']
loss_function = tf.keras.losses.BinaryCrossentropy()

for optimizer_types in optimizer_types:

if optimizer types == 'SGD':
 p _ yp
optimizer = tf.keras.optimizers.SGD(learning_rate=learning_rate, momentum=0.9)
elif optimizer_types == 'Adam':
optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate, beta_1=0.9, beta_2=0.999, epsilon = 1e-0
elif optimizer_types == 'RMSprop':
optimizer = tf.keras.optimizers.RMSprop(learning_rate=learning_rate, rho=0.9, epsilon = 1e-10)
elif optimizer_types == 'Adagrad':
optimizer = tf.keras.optimizers.Adagrad(learning_rate=learning_rate, initial_accumulator_value=0.1)
elif optimizer_types == 'Momentum':
optimizer = tf.keras.optimizers.SGD(learning_rate=learning_rate, momentum=0.9, nesterov=False)
model.compile(optimizer = optimizer, loss=loss_function, metrics=['accuracy'])

model.fit(X_train,Y_train, epochs=5, batch_size=32)

Epoch 1/5
32/32 [==============================] - 1s 2ms/step - loss: 0.6934 - accuracy: 0.5110
Epoch 2/5
32/32 [==============================] - 0s 3ms/step - loss: 0.6918 - accuracy: 0.5190
Epoch 3/5
32/32 [==============================] - 0s 2ms/step - loss: 0.6907 - accuracy: 0.5330
Epoch 4/5
32/32 [==============================] - 0s 3ms/step - loss: 0.6898 - accuracy: 0.5270
Epoch 5/5
32/32 [==============================] - 0s 3ms/step - loss: 0.6904 - accuracy: 0.5390
<keras.src.callbacks.History at 0x7d5ab9482470>