Deep Learning dengan TensorFlow & PyTorch - Tutorial Lengkap Dasar Sampai Advance

Deep Learning Konsep dasar dapat dijalankan di browser. TensorFlow/PyTorch butuh GPU lokal.

Jika Machine Learning adalah mesin mobil, maka Deep Learning adalah mesin jet. Deep Learning adalah subset dari Machine Learning yang meniru cara kerja otak manusia menggunakan Artificial Neural Networks (ANN) yang bertingkat-tingkat ("deep").

Teknologi ini adalah otak di balik self-driving cars, ChatGPT, pengenalan wajah di HP Anda, dan generator gambar AI.

Dalam tutorial ini, kita akan:

1. Memahami cara kerja Neural Network "di balik layar" dengan NumPy (bisa dijalankan di sini!).
2. Mempelajari dua raksasa framework: TensorFlow dan PyTorch.
3. Membuat model pengenalan gambar sederhana.

Konsep Dasar: Neural Network from Scratch

Sebelum menggunakan library canggih, mari kita pahami apa yang sebenarnya terjadi di dalam sebuah "neuron" buatan.

Sebuah neuron melakukan dua hal sederhana:

1. Linear Transformation: Mengalikan input dengan bobot (weights) dan menambah bias. $$ z = x \cdot w + b $$
2. Non-linear Activation: Mengubah hasil menjadi output non-linear (misalnya dengan Sigmoid atau ReLU). $$ output = \sigma(z) $$

Mari Coba Sendiri! (Interactive Demo)

Kode di bawah ini adalah simulasi satu neuron sederhana menggunakan NumPy. Klik Run untuk melihat hasilnya!

import numpy as np

def sigmoid(x):
    # Fungsi aktivasi: mengubah angka menjadi antara 0 dan 1
    return 1 / (1 + np.exp(-x))

class Neuron:
    def __init__(self, weights, bias):
        self.weights = weights
        self.bias = bias

    def feedforward(self, inputs):
        # Langkah 1: Dot product input * bobot + bias
        total = np.dot(self.weights, inputs) + self.bias
        # Langkah 2: Fungsi aktivasi
        return sigmoid(total)

# Bobot (seberapa penting inputnya?)
weights = np.array([0, 1]) 
# Bias (threshold pemicu)
bias = 4                   

n = Neuron(weights, bias)

# Input data (misalnya [piksel1, piksel2])
x = np.array([2, 3])       

print(f"Output Neuron: {n.feedforward(x)}")

Menggabungkan Neuron Menjadi Jaringan (Network)

Deep Learning terjadi ketika kita menumpuk banyak neuron menjadi lapisan (layers).

1. Input Layer: Menerima data mentah.
2. Hidden Layers: Mengekstraksi fitur kompleks.
3. Output Layer: Memberikan prediksi.

Mari kita buat jaringan sederhana dengan satu Hidden Layer:

import numpy as np

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

class NeuralNetwork:
    def __init__(self):
        # Bobot acak untuk contoh
        self.w1 = np.array([[0.5, 0.6], [0.7, 0.8]]) # Input ke Hidden
        self.w2 = np.array([0.9, 1.0])               # Hidden ke Output
        
    def feedforward(self, x):
        # Input ke Hidden Layer
        h_in = np.dot(self.w1, x) 
        h_out = sigmoid(h_in)
        
        # Hidden ke Output Layer
        o_in = np.dot(self.w2, h_out)
        o_out = sigmoid(o_in)
        return o_out

network = NeuralNetwork()
x = np.array([2, 3])

print(f"Prediksi Jaringan: {network.feedforward(x)}")

Masuk ke Dunia Framework: TensorFlow vs PyTorch

Menulis kode seperti di atas untuk jaringan besar sangat rumit dan lambat. Itulah mengapa kita butuh framework yang dioptimalkan untuk GPU.

1. TensorFlow & Keras

TensorFlow modern menggunakan Keras sebagai interface utamanya. Ini membuatnya sangat mudah dibaca.

Contoh: Klasifikasi Angka (MNIST)

Kode di bawah ini mendefinisikan model untuk membaca tulisan tangan angka 0-9.

Catatan: Kode ini membutuhkan library TensorFlow yang besar. Silakan jalankan di Google Colab.

import tensorflow as tf

# 1. Load Data
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# 2. Definisi Model (Sequential)
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),     # Input layer
  tf.keras.layers.Dense(128, activation='relu'),     # Hidden layer
  tf.keras.layers.Dropout(0.2),                      # Regularization
  tf.keras.layers.Dense(10, activation='softmax')    # Output layer
])

# 3. Compile Model
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 4. Train Model
print("Mulai training...")
# model.fit(x_train, y_train, epochs=5) # Uncomment di Colab

print("Model didefinisikan dengan Keras!")

2. PyTorch

PyTorch memberikan kontrol lebih detail. Anda mendefinisikan arsitektur jaringan sebagai sebuah Class.

Catatan: Kode ini untuk referensi PyTorch. Jalankan di Colab untuk hasil terbaik.

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        # Definisi Layer
        self.flatten = nn.Flatten()
        self.fc1 = nn.Linear(28*28, 128) # Input ke Hidden
        self.fc2 = nn.Linear(128, 10)    # Hidden ke Output

    def forward(self, x):
        # Alur data (Feedforward)
        x = self.flatten(x)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = SimpleNet()
print(model)

Studi Kasus: Transfer Learning

Salah satu teknik paling powerful di Deep Learning adalah Transfer Learning. Alih-alih melatih model dari nol (yang butuh jutaan data dan berminggu-minggu waktu GPU), kita menggunakan model yang sudah dilatih oleh Google/Meta (seperti ResNet, VGG, MobileNet) dan menyesuaikannya dengan data kita.

Ilustrasi Transfer Learning

Model Pre-trained (ImageNet)
[====================================]
       (Sudah paham bentuk, tekstur, mata, telinga)
                               │
                               ▼
[Layer Baru Kita] -> Latih 5 menit saja!
                               │
                               ▼
                     "Kucing saya vs Kucing tetangga"

FAQ: Deep Learning

Sumber Daya Tambahan

• Google Colab: Environment Jupyter Notebook gratis dengan GPU. colab.research.google.com
• Keras Documentation: Dokumentasi yang sangat mudah dibaca. keras.io
• PyTorch Tutorials: Tutorial resmi PyTorch. pytorch.org/tutorials
• Fast.ai: Kursus Deep Learning praktis terbaik (Top Down approach). fast.ai

Kesimpulan

Deep Learning adalah teknologi yang sangat powerful namun kompleks. Jangan terintimidasi! Mulailah dengan Keras untuk membangun intuisi, lalu pelajari teori matematika di baliknya secara bertahap.

Di tutorial berikutnya, kita akan membahas cara menerapkan ini untuk proyek Computer Vision sederhana.

Coba kode Neural Network di atas di Google Colab ↗