Mata Kuliah: Machine Learning

Neural Network

Pendahuluan

  • Neural Networks (Jaringan Saraf Tiruan) adalah model machine learning yang terinspirasi oleh jaringan neuron dalam sistem biologis.
  • Neural Networks adalah “fungsi” dari neuron yang juga disebut unit tersembunyi (hidden unit).
  • Model Neural Networks terdiri dari banyak neuron tunggal yang saling terhubung.
  • Setiap neuron tunggal mampu “belajar” menyelesaikan masalah tertentu.
  • Setiap unit (neuron) menerima sejumlah input bernilai real dan menghasilkan output bernilai real.
  • Algoritma ini sangat kuat untuk klasifikasi kompleks dan regresi, tetapi sering dianggap sebagai “black box” karena sulitnya interpretasi.

Neural Network

Perceptron

Perceptron adalah unit dasar dari jaringan saraf.

Arsitektur

  • Beberapa input
  • Satu output
  • Setiap input terkait dengan bobot (weight) arbitrer
  • Parameter tambahan berupa bias
  • Pre-aktivasi neuron: \(a = \sum_{i=1}^{N} w_i x_i + b\)
  • Fungsi aktivasi

Perceptron (Lanjutan)

Perhatikan bahwa pre-aktivasi perceptron menggunakan model linear. \[ a = \sum_{i=1}^{N} w_i x_i + b \]

Fungsi Aktivasi

Fungsi Aktivasi Linear

  • Tidak ada penekanan input
  • Input: \(a = \sum_{i=1}^{N} w_i x_i + b\)
  • Output: \(g(a) = a\)

Fungsi Aktivasi Sigmoid

  • Menekan pre-aktivasi neuron antara 0 dan 1
  • Selalu positif dan terbatas
  • Selalu meningkat
  • Output: \(g(a) = sigmoid(a) = \frac{1}{1+e^{-a}}\)

Fungsi aktivasi menentukan:

  • Apakah neuron diaktifkan atau tidak
  • Seberapa banyak nilai yang diteruskan ke neuron lain
  • Non-linearitas model

Fungsi Aktivasi (Lanjutan)

Fungsi Aktivasi Tanh

  • Menekan pre-aktivasi neuron antara -1 dan 1
  • Bisa positif atau negatif
  • Terbatas dan selalu meningkat
  • Output: \(g(a) = tanh(a) = \frac{e^a - e^{-a}}{e^a + e^{-a}}\)

Fungsi Aktivasi Softmax

  • Untuk klasifikasi multi-kelas
  • Digunakan pada output layer
  • Output: \(g(a) = softmax(a) = \begin{bmatrix} \frac{\exp(a_1)}{\sum_c \exp(a_c)} & \dots & \frac{\exp(a_n)}{\sum_c \exp(a_c)} \end{bmatrix}^T\)
  • Selalu positif dan berjumlah satu
  • Kelas yang diprediksi adalah yang memiliki probabilitas tertinggi

Multilayer Perceptron

Kumpulan perceptron yang terhubung disebut Multilayer Perceptron (MLP) atau jaringan saraf.

Arsitektur MLP

  • Input Layer: Menerima data input (fitur)
  • Hidden Layer: Satu atau lebih layer tersembunyi yang memproses input
  • Output Layer: Menghasilkan prediksi akhir

Contoh struktur MLP:

  • Input Layer: 3 input
  • Hidden Layer: 4 neuron
  • Output Layer: 2 output

Dalam MLP, bobot dan bias dilatih untuk meminimalkan error prediksi.

Forward & Backward Propagation

Forward Propagation

Forward Propagation adalah proses menghitung output jaringan saraf dengan meneruskan input melalui semua layer.

Back Propagation

Back Propagation adalah proses untuk menghitung gradien error terhadap bobot dan bias dalam jaringan saraf.

Arsitektur Neural Network

Arsitektur Neural Network

Belajar Dari Ahlinya

https://www.youtube.com/@AnakAI/playlists

Hyperparameter Neural Network

Parameter Fungsi Efek
learning_rate Menentukan ukuran langkah update Konvergensi & stabilitas
hidden_layers Jumlah layer tersembunyi Kapasitas & kompleksitas
neurons_per_layer Jumlah neuron per layer Kapasitas representasi
activation Fungsi aktivasi Non-linearitas & performa
optimizer Algoritma optimasi (SGD, Adam, dll) Kecepatan & kualitas konvergensi
batch_size Ukuran batch dalam training Memori & generalisasi
epochs Jumlah iterasi training Konvergensi & overfitting

Implementasi TensorFlow

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.optimizers import Adam
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import numpy as np

# Mengaktifkan reproduktifitas
np.random.seed(42)
tf.random.set_seed(42)

# Load data
data = load_breast_cancer()
X, y = data.data, data.target

# Preprocessing
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.2, random_state=42
)

# Membangun model dengan Keras (API tingkat tinggi TensorFlow)
model = Sequential([
    Dense(100, activation='relu', input_shape=(X_train.shape[1],)),
    Dropout(0.2),  # Menambahkan dropout untuk mencegah overfitting
    Dense(50, activation='relu'),
    Dropout(0.2),
    Dense(1, activation='sigmoid')  # Sigmoid untuk output biner
])

# Kompilasi model
model.compile(
    optimizer=Adam(learning_rate=0.001),
    loss='binary_crossentropy',
    metrics=['accuracy']
)

# Ringkasan arsitektur model
model.summary()

# Melatih model
history = model.fit(
    X_train, y_train,
    epochs=50,
    batch_size=32,
    validation_split=0.2,
    verbose=0
)

# Evaluasi model
train_loss, train_acc = model.evaluate(X_train, y_train, verbose=0)
test_loss, test_acc = model.evaluate(X_test, y_test, verbose=0)

print(f"Training accuracy: {train_acc:.4f}")
print(f"Test accuracy: {test_acc:.4f}")

# Visualisasi pelatihan (opsional - memerlukan matplotlib)
import matplotlib.pyplot as plt

plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.legend()
plt.title('Accuracy')

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.legend()
plt.title('Loss')
plt.show()

Terima Kasih