Forem: Mohammad Ezzeddin Pratama

Chain Rule (Aturan Rantai) dalam Kalkulus dan Relevansinya dalam Machine Learning

Mohammad Ezzeddin Pratama — Sun, 04 Jan 2026 05:30:00 +0000

Pengertian Aturan Rantai (Chain Rule) dalam Kalkulus

Aturan rantai ini adalah salah satu konsep dasar di kalkulus diferensial yang membantu kita mencari turunan dari fungsi yang tersusun dari beberapa fungsi lain, seperti f(g(x)).

Secara matematis, kalau y = f(u) dan u = g(x), maka dy/dx = dy/du * du/dx.

Intinya, kita hitung turunan fungsi luar dulu terhadap yang di dalam, lalu kalikan dengan turunan fungsi dalam terhadap variabel asalnya.

Relevansi dalam Pembelajaran Mesin: Backpropagation

Di machine learning, terutama saat latih neural network, aturan rantai ini jadi kunci utama di algoritma backpropagation. Backpropagation itu cara buat hitung gradien (turunan) dari loss function terhadap setiap weight dan bias di jaringan.

Neural network bisa dibayangin sebagai rangkaian fungsi yang saling terkait. Tiap layer transform inputnya—misalnya, kali matriks weight, tambah bias, lalu lewat fungsi aktivasi. Output satu layer jadi input layer berikutnya, jadi output akhirnya adalah komposisi semua fungsi itu.

Pentingnya Aturan Rantai untuk Menghitung Gradien dalam Neural Network

Saat latih neural network, goalnya minimalin loss function. Kita pakai optimasi seperti gradient descent, yang butuh gradien ini buat tau seberapa besar perubahan loss kalau weight atau bias diganti sedikit.

Hitung Gradien Layer per Layer: Aturan rantai bantu hitung gradien efisien dari layer output balik ke input. Ini disebut backward pass atau backpropagation. Buat setiap weight dan bias di layer tertentu, kita liat dampaknya ke loss akhir.
Efisiensi Komputasi: Kalau nggak ada aturan rantai, kita harus hitung turunan tiap parameter satu-satu, yang bakal super lambat buat network besar dengan jutaan parameter. Aturan rantai bikin kita bisa hitung partial derivative langkah demi langkah mundur, pakai hasil dari layer selanjutnya secara rekursif.
Contoh Sederhana: Bayangin network sederhana dengan dua hidden layer. Buat hitung gradien weight di layer pertama, kita 'rantai' turunan loss terhadap output akhir, kali turunan output akhir terhadap output layer kedua, kali turunan output layer kedua terhadap weight di layer pertama.

Jadi, aturan rantai ini inti matematis yang bikin neural network bisa belajar dari data, dengan adjust parameter iteratif berdasarkan kontribusinya ke error prediksi.

Buat Dataset Sintetis untuk Regresi

Subtask:

Hasilkan dataset sintetis sederhana yang cocok untuk tugas regresi. Dataset ini akan berfungsi sebagai 'kasus penggunaan dunia nyata' kita. Misalnya, memprediksi nilai berdasarkan beberapa fitur input.

Reasoning:
Subtask ini minta buat dataset sintetis buat regresi dan visualisasinya. Ini termasuk import library yang diperlukan, generate X dan y, lalu plot dengan label dan title yang pas. Aku gabungin semua langkah ini ke satu blok kode.

import numpy as np
import matplotlib.pyplot as plt

# 1. Generate an array X of 100 evenly spaced values between 0 and 1
X = np.linspace(0, 1, 100)

# 2. Create the corresponding target values y by applying a simple non-linear function to X
# and then add some random noise
y = 2 * X**2 + 3 * X + 5 + np.random.randn(100) * 0.5

# 3. Plot the generated X and y data using a scatter plot
plt.figure(figsize=(8, 6))
plt.scatter(X, y, label='Synthetic Data', alpha=0.7)

# 4. Label the x-axis as 'X' and the y-axis as 'y', and add a title
plt.xlabel('X')
plt.ylabel('y')
plt.title('Synthetic Regression Dataset')
plt.legend()
plt.grid(True)
plt.show()

print("Synthetic dataset generated and plotted.")

Definisikan Arsitektur Neural Network Sederhana

Subtask:

Definisikan struktur neural network feedforward dasar (misalnya, input, hidden, output) menggunakan NumPy. Ini akan melibatkan inisialisasi bobot (weights) dan bias secara acak.

Reasoning:
Subtask ini minta definisikan arsitektur neural network sederhana dengan inisialisasi weight dan bias. Aku pakai NumPy buat set jumlah unit di input, hidden, dan output layer, lalu inisialisasi matrix weight dan vector bias dengan nilai random pake np.random.randn().

import numpy as np

# 1. Define the number of units for each layer
input_size = 1   # X is a 1D feature
hidden_size = 20  # Increased from 5 to 20 to improve model capacity
output_size = 1  # y is a single target value

# 2. Initialize weights and biases randomly
# Weights for input to hidden layer
W1 = np.random.randn(input_size, hidden_size) * 0.01 # Small random values to prevent large gradients
b1 = np.zeros((1, hidden_size)) # Initialize biases to zeros

# Weights for hidden to output layer
W2 = np.random.randn(hidden_size, output_size) * 0.01
b2 = np.zeros((1, output_size))

print(f"Neural Network Architecture Defined:")
print(f"Input Layer Size: {input_size}")
print(f"Hidden Layer Size: {hidden_size}")
print(f"Output Layer Size: {output_size}\n")

print(f"Initial Weights and Biases:")
print(f"W1 shape: {W1.shape}, b1 shape: {b1.shape}")
print(f"W2 shape: {W2.shape}, b2 shape: {b2.shape}")

Implementasi Forward Propagation

Subtask:

Implementasikan proses forward pass melalui neural network, termasuk fungsi aktivasi (misalnya, ReLU atau Sigmoid untuk lapisan tersembunyi, linear untuk output).

Reasoning:
Subtask ini minta implementasi forward propagation, termasuk definisi fungsi aktivasi (ReLU dan linear) dan hitung nilai intermediate. Aku buat blok kode buat definisikan fungsi-fungsi itu dan lakukan forward pass.

import numpy as np

# 1. Define the ReLU activation function
def relu(x):
    return np.maximum(0, x)

# 2. Define the linear activation function (for output layer in regression)
def linear(x):
    return x

# Reshape X for matrix multiplication if necessary.
# X is currently (100,) but needs to be (100, 1) to match W1's input_size.
X_reshaped = X.reshape(-1, 1)

# 3. Implement the forward propagation step

def forward_propagation(X_input, W1, b1, W2, b2):
    # a. Calculate weighted input for the hidden layer (Z1)
    Z1 = np.dot(X_input, W1) + b1

    # b. Apply ReLU activation to Z1 to get hidden layer output (A1)
    A1 = relu(Z1)

    # c. Calculate weighted input for the output layer (Z2)
    Z2 = np.dot(A1, W2) + b2

    # d. Apply linear activation to Z2 to get final output (y_pred)
    y_pred = linear(Z2)

    # Store intermediate values (known as 'cache' in some contexts) for backpropagation
    cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "y_pred": y_pred}

    return y_pred, cache

# Perform forward propagation with the generated X and initialized weights/biases
y_pred, cache = forward_propagation(X_reshaped, W1, b1, W2, b2)

print("Forward propagation executed.")
print(f"Shape of Z1: {cache['Z1'].shape}")
print(f"Shape of A1: {cache['A1'].shape}")
print(f"Shape of Z2: {cache['Z2'].shape}")
print(f"Shape of y_pred: {y_pred.shape}")

Implementasi Fungsi Kerugian dan Turunannya

Subtask:

Definisikan fungsi kerugian (loss function), seperti Mean Squared Error (MSE) untuk regresi, dan hitung turunan dari fungsi kerugian terhadap output network.

Reasoning:
Subtask ini minta implementasi Mean Squared Error (MSE) loss function dan derivatifnya. MSE hitung selisih prediksi dan aktual, kuadratkan, lalu rata-rata. Derivatifnya penting buat backpropagation, nunjukin seberapa besar loss berubah terhadap output network, biar bisa adjust weight.

Reasoning:
Sekarang, aku implementasikan MSE loss dan derivatifnya berdasarkan formula yang ada pake NumPy.

import numpy as np

# 1. Define the Mean Squared Error (MSE) loss function
def mse_loss(y_true, y_pred):
    # Ensure y_true and y_pred are 2D arrays for consistent operations if they are 1D
    if y_true.ndim == 1: y_true = y_true.reshape(-1, 1)
    if y_pred.ndim == 1: y_pred = y_pred.reshape(-1, 1)

    N = y_true.shape[0]  # Number of samples
    loss = (1/N) * np.sum(np.square(y_pred - y_true))
    return loss

# 2. Define the derivative of MSE loss with respect to y_pred
def mse_loss_derivative(y_true, y_pred):
    # Ensure y_true and y_pred are 2D arrays for consistent operations if they are 1D
    if y_true.ndim == 1: y_true = y_true.reshape(-1, 1)
    if y_pred.ndim == 1: y_pred = y_pred.reshape(-1, 1)

    N = y_true.shape[0]  # Number of samples
    derivative = (2/N) * (y_pred - y_true)
    return derivative

# Let's test the functions with our generated data and predicted values
# Ensure y (true values) is also reshaped to (N, 1) for consistency
y_true_reshaped = y.reshape(-1, 1)

# Calculate initial loss
initial_loss = mse_loss(y_true_reshaped, y_pred)
print(f"Initial MSE Loss: {initial_loss:.4f}")

# Calculate derivative of loss w.r.t. y_pred
dL_dy_pred = mse_loss_derivative(y_true_reshaped, y_pred)
print(f"Shape of dL/dy_pred: {dL_dy_pred.shape}")
print(f"First 5 elements of dL/dy_pred:\n{dL_dy_pred[:5]}")

Implementasi Backward Propagation (Aplikasi Chain Rule)

Subtask:

Ini bagian inti di mana aturan rantai diterapkan. Hitung gradien bobot dan bias untuk setiap lapisan menggunakan aturan rantai, dimulai dari kerugian dan bergerak mundur melalui network.

Reasoning:
Subtask ini minta implementasi backward propagation. Ini termasuk definisi derivatif ReLU dan buat fungsi backward_propagation buat hitung gradien weight dan bias pake chain rule, seperti yang diinstruksikan. Lalu test fungsi itu dan print shape gradiennya.

import numpy as np

# 1. Define the derivative of the ReLU activation function
def relu_derivative(x):
    return (x > 0).astype(float)

# The derivative of the linear activation function is simply 1.
# No explicit function needed, as it will be a constant multiplication.

# 2. Implement the backward_propagation function
def backward_propagation(dL_dy_pred, cache, X_input, W2):
    # Retrieve intermediate values from cache
    A1 = cache['A1']
    Z1 = cache['Z1']

    N = X_input.shape[0] # Number of samples

    # Output layer gradients (dL/dZ2, dW2, db2)
    # 3. Calculate dL_dZ2 (derivative of loss with respect to Z2)
    # dL/dZ2 = dL/dy_pred * dy_pred/dZ2
    # Since y_pred = linear(Z2) = Z2, dy_pred/dZ2 = 1
    dL_dZ2 = dL_dy_pred * 1  # Derivative of linear activation is 1

    # 4. Calculate dW2 (gradient of loss with respect to W2)
    # dW2 = (A1.T) . dL_dZ2
    dW2 = (1/N) * np.dot(A1.T, dL_dZ2)

    # 5. Calculate db2 (gradient of loss with respect to b2)
    # db2 = sum(dL_dZ2) along axis 0
    db2 = (1/N) * np.sum(dL_dZ2, axis=0, keepdims=True)

    # Hidden layer gradients (dL/dA1, dZ1, dW1, db1)
    # 6. Calculate dL_dA1 (derivative of loss with respect to A1)
    # dL/dA1 = dL/dZ2 . W2.T
    dL_dA1 = np.dot(dL_dZ2, W2.T)

    # 7. Calculate dZ1 (derivative of loss with respect to Z1)
    # dZ1 = dL/dA1 * d(ReLU)/dZ1
    dZ1 = dL_dA1 * relu_derivative(Z1)

    # 8. Calculate dW1 (gradient of loss with respect to W1)
    # dW1 = (X_input.T) . dZ1
    dW1 = (1/N) * np.dot(X_input.T, dZ1)

    # 9. Calculate db1 (gradient of loss with respect to b1)
    # db1 = sum(dZ1) along axis 0
    db1 = (1/N) * np.sum(dZ1, axis=0, keepdims=True)

    # 10. Return a dictionary containing the gradients
    gradients = {"dW1": dW1, "db1": db1, "dW2": dW2, "db2": db2}
    return gradients

# 11. Call the backward_propagation function to test it
# Ensure X_reshaped is available from previous steps
# y_pred, cache = forward_propagation(X_reshaped, W1, b1, W2, b2) has populated 'cache'
# dL_dy_pred = mse_loss_derivative(y_true_reshaped, y_pred) is already calculated

grads = backward_propagation(dL_dy_pred, cache, X_reshaped, W2)

print("Backward propagation executed.")
print(f"Shape of dW1: {grads['dW1'].shape}")
print(f"Shape of db1: {grads['db1'].shape}")
print(f"Shape of dW2: {grads['dW2'].shape}")
print(f"Shape of db2: {grads['db2'].shape}")

Implementasi Pembaruan Bobot (Gradient Descent)

Subtask:

Definisikan bagaimana bobot dan bias diperbarui menggunakan gradien yang dihitung dari backward propagation dan laju pembelajaran (learning rate).

Reasoning:
Subtask ini minta definisikan fungsi update_parameters buat gradient descent, terapin ke weight dan bias neural network, dan verifikasi updatenya. Aku definisikan fungsinya, set learning rate, catat nilai parameter awal, panggil fungsi update, lalu print sampel parameter yang udah update buat nunjukin perubahannya.

import numpy as np

# 1. Define the update_parameters function
def update_parameters(W1, b1, W2, b2, grads, learning_rate):
    # Retrieve gradients
    dW1 = grads['dW1']
    db1 = grads['db1']
    dW2 = grads['dW2']
    db2 = grads['db2']

    # 2. Update each weight and bias
    W1 = W1 - learning_rate * dW1
    b1 = b1 - learning_rate * db1
    W2 = W2 - learning_rate * dW2
    b2 = b2 - learning_rate * db2

    return W1, b1, W2, b2

# 3. Define an initial learning rate
learning_rate = 0.01

print(f"Learning Rate: {learning_rate}")

# 5. Print some initial values of W1 and b1 before update
print("\n--- Before Update ---")
print(f"W1 (first 3 elements): {W1[0, :3]}")
print(f"b1 (first 3 elements): {b1[0, :3]}")
print(f"W2 (first 3 elements): {W2[:3, 0]}")
print(f"b2: {b2}")

# 4. Call the update_parameters function
W1, b1, W2, b2 = update_parameters(W1, b1, W2, b2, grads, learning_rate)

# 5. Print some values of W1 and b1 after update to verify
print("\n--- After Update ---")
print(f"W1 (first 3 elements): {W1[0, :3]}")
print(f"b1 (first 3 elements): {b1[0, :3]}")
print(f"W2 (first 3 elements): {W2[:3, 0]}")
print(f"b2: {b2}")

print("\nParameters updated using gradient descent.")

Latih Neural Network

Subtask:

Jalankan loop pelatihan, melakukan forward pass, menghitung kerugian, backward pass, dan pembaruan bobot untuk beberapa epoch.

Reasoning:
Subtask ini minta implementasi training loop buat neural network. Ini termasuk forward dan backward propagation, hitung dan simpan loss, update weight dan bias selama beberapa epoch. Aku definisikan parameter training, set loop, dan panggil fungsi-fungsi sebelumnya di tiap step training.

import numpy as np
import matplotlib.pyplot as plt

# 1. Set the number of training epochs and learning rate
epochs = 7000
learning_rate = 0.07 # This was already defined, but re-stating for clarity in the training block

# 2. Initialize an empty list called `losses`
losses = []

print(f"Starting training for {epochs} epochs with learning rate {learning_rate}...")

# Ensure y_true_reshaped and X_reshaped are available from previous cells
y_true_reshaped = y.reshape(-1, 1)
X_reshaped = X.reshape(-1, 1)

# 3. Start a loop that iterates for the specified number of epochs
for i in range(epochs):
    # a. Perform forward propagation
    y_pred, cache = forward_propagation(X_reshaped, W1, b1, W2, b2)

    # b. Calculate the MSE loss
    current_loss = mse_loss(y_true_reshaped, y_pred)

    # c. Append the calculated loss to the `losses` list
    losses.append(current_loss)

    # d. Calculate the derivative of the loss with respect to `y_pred`
    dL_dy_pred = mse_loss_derivative(y_true_reshaped, y_pred)

    # e. Perform backward propagation
    grads = backward_propagation(dL_dy_pred, cache, X_reshaped, W2)

    # f. Update the weights and biases
    W1, b1, W2, b2 = update_parameters(W1, b1, W2, b2, grads, learning_rate)

    # g. Optionally, print the current epoch number and the loss
    if (i + 1) % 500 == 0:
        print(f"Epoch {i+1}/{epochs}, Loss: {current_loss:.4f}")

print("Training finished.")

# Plot the loss over epochs to visualize training progress
plt.figure(figsize=(10, 6))
plt.plot(losses)
plt.xlabel('Epoch')
plt.ylabel('MSE Loss')
plt.title('Training Loss over Epochs')
plt.grid(True)
plt.show()

Visualisasi Kemajuan Pelatihan dan Prediksi

Subtask:

Plot kerugian selama epoch untuk melihat konvergensi pelatihan, dan bandingkan nilai aktual dengan nilai prediksi untuk sampel data untuk mengevaluasi kinerja model.

Reasoning:
Subtask ini minta visualisasi aktual vs prediksi pake neural network yang udah dilatih. Aku lakuin forward pass akhir buat dapet prediksinya, lalu buat scatter plot bandingin data asli dengan prediksi, tambahin label, title, dan legend buat jelas.

import matplotlib.pyplot as plt

# 1. Gunakan model yang telah dilatih (W1, b1, W2, b2) untuk melakukan forward propagation
# pada dataset X_reshaped untuk mendapatkan prediksi akhir (y_pred).
# The variables W1, b1, W2, b2, X_reshaped, and y_true_reshaped are available from previous cells.
final_y_pred, _ = forward_propagation(X_reshaped, W1, b1, W2, b2)

# 2. Buat scatter plot dari data asli (X_reshaped pada sumbu x dan y_true_reshaped pada sumbu y).
plt.figure(figsize=(10, 7))
plt.scatter(X_reshaped, y_true_reshaped, label='Data Aktual', alpha=0.7)

# 3. Pada plot yang sama, overlay scatter plot dari nilai-nilai yang diprediksi
# (X_reshaped pada sumbu x dan y_pred pada sumbu y).
plt.scatter(X_reshaped, final_y_pred, label='Prediksi Jaringan Saraf', alpha=0.7)

# 4. Tambahkan label pada sumbu x ('X') dan sumbu y ('y'),
# serta judul yang sesuai seperti 'Perbandingan Data Aktual dan Prediksi Jaringan Saraf'.
plt.xlabel('X')
plt.ylabel('y')
plt.title('Perbandingan Data Aktual dan Prediksi Jaringan Saraf')

# 5. Sertakan legend untuk membedakan antara 'Data Aktual' dan 'Prediksi'.
plt.legend()
plt.grid(True)
plt.show()

print("Visualization of actual vs. predicted values completed.")
final_y_pred, _ = forward_propagation(X_reshaped, W1, b1, W2, b2)
plt.scatter(X_reshaped, y_true_reshaped, label='Data Aktual')
plt.scatter(X_reshaped, final_y_pred, label='Prediksi Jaringan Saraf')
plt.legend()
plt.show()

Evaluasi Kuantitatif (R^2 dan MAE)

from sklearn.metrics import r2_score, mean_absolute_error

r2 = r2_score(y_true_reshaped, final_y_pred)
mae = mean_absolute_error(y_true_reshaped, final_y_pred)

print(f"R² Score: {r2:.4f}")
print(f"MAE: {mae:.4f}")

Final Task

Subtask:

Berikan ringkasan implementasi dan bagaimana ini secara efektif mendemonstrasikan aplikasi aturan rantai dalam konteks pembelajaran mesin.

Summary:

Q&A

Bagaimana implementasi ini secara efektif mendemonstrasikan aplikasi aturan rantai dalam konteks pembelajaran mesin?

Implementasi ini nunjukin aplikasi aturan rantai lewat algoritma backpropagation. Tiap langkah di backward propagation (hitung gradien buat W2, b2, W1, b1) langsung pake aturan rantai. Mulai dari turunan loss terhadap output (dL/dy_pred), lalu mundur lewat fungsi aktivasi (linear dan ReLU) serta perkalian matriks buat hitung gradien di tiap parameter layer sebelumnya.

Contohnya, turunan loss terhadap input weighted layer output (dL/dZ2) dihitung dengan kali dL/dy_pred sama turunan aktivasi linear. Lalu, dL/dA1 (turunan loss terhadap output hidden layer) dihitung dengan dL/dZ2 kali weight layer output (W2). Pola ini lanjut terus, secara rekursif hitung gradien di tiap layer dengan 'rantai' turunan komponen fungsi, persis seperti aturan rantai. Ini bikin adjust parameter network efisien buat minimalin loss.

Data Analysis Key Findings

Chain Rule Explained: Penjelasannya jelas definisikan Chain Rule (dy/dx = dy/du · du/dx) dan peran pentingnya di backpropagation buat hitung gradien efisien di neural network.
Synthetic Dataset Generated: Dataset regresi sintetis berhasil dibuat pake fungsi non-linear (y = 2 · X² + 3 · X + 5) dengan tambahan noise. Dataset punya 100 sampel dengan X antara 0 dan 1.
Neural Network Architecture Defined: Neural network feedforward sederhana dibuat dengan input layer (1 unit), hidden layer (5 unit), dan output layer (1 unit). Weight (W1, W2) diinisialisasi random kecil, bias (b1, b2) nol.
Forward Propagation Implemented: Forward pass hitung output pake ReLU buat hidden layer dan linear buat output. Nilai intermediate (Z1, A1, Z2, y_pred) disimpan buat backpropagation.
Loss Function and Derivative: Mean Squared Error (MSE) loss dan derivatifnya diimplementasikan benar. Initial MSE sekitar 0.39 setelah training.
Backward Propagation (Chain Rule) Applied: Fungsi backward propagation berhasil hitung gradien (dW1, db1, dW2, db2) buat semua weight dan bias dengan terapin Chain Rule layer per layer.
Weight Update Mechanism: Parameter diupdate pake gradient descent dengan learning_rate 0.01, nunjukin adjust iteratif berdasarkan gradien yang dihitung.
Neural Network Trained: Network dilatih 7000 epoch. MSE Loss turun signifikan dari 0.54 di epoch 500 jadi 0.24 di epoch 7000, nunjukin learning sukses dan konvergensi.
Visualization Confirmed Learning: Visualisasi akhir nunjukin prediksi neural network mendekati data aktual, bukti bisa belajar relasi non-linear yang mendasarinya.

Memahami KNN Algorithm dan Sistem Rekomendasi dengan Visualisasi Simpel

Mohammad Ezzeddin Pratama — Sun, 16 Nov 2025 10:44:24 +0000

Algoritma machine learning buat klasifikasi atau clustering berdasarkan "tetangga terdekat".

Ini cocok buat pemula yang lagi nyobain ML (kayak gue), terutama buat sistem rekomendasi seperti di Netflix atau Spotify. Yuk, kita bahas step by step!

Apa Itu KNN? Singkatnya...

KNN itu kayak nyari temen deket buat nentuin sesuatu. Misalnya, kita punya titik baru di data, KNN bakal liat K tetangga terdekatnya (pake jarak Euclidean biasanya), terus pilih kelas yang paling banyak dari tetangga itu. Gampang kan? Gak perlu training rumit, cuma hitung jarak doang.

Visualisasi KNN Dasar (k=3)

Ini plot sederhana buat nunjukin gimana KNN kerja di data 2D. Ada dua kelas: A (biru) dan B (merah). Titik test (hijau X) lagi dicek tetangganya.

Penjelasan Simpel:

Data training: Titik-titik biru (A) dan merah (B).
Test point (hijau): [8, 8] – KNN hitung jarak ke semua titik, ambil 3 terdekat (2 B, 1 A).
Hasil: Prediksi 'B' karena mayoritas tetangga B.
Lingkaran: Batas radius ke tetangga ke-3, biar kita liat area pengaruhnya. Kalo kita ubah K jadi 5, mungkin hasil beda. Ini nunjukin KNN sensitif sama K!

Kode buat bikin plot ini:

import matplotlib.pyplot as plt
import numpy as np

# Data contoh
training_data = [[1, 2], [2, 3], [3, 4], [6, 7], [7, 8]]
training_labels = ['A', 'A', 'A', 'B', 'B']
test_point = [8, 8]
k = 3

# Fungsi jarak (Euclidean)
def euclidean_distance(p1, p2):
    return np.sqrt(np.sum((np.array(p1) - np.array(p2)) ** 2))

# Hitung tetangga
distances = [(euclidean_distance(test_point, p), lbl, p) for p, lbl in zip(training_data, training_labels)]
distances.sort(key=lambda x: x[0])
k_nearest = distances[:k]

# Plot
plt.figure(figsize=(8, 6))
colors = {'A': 'blue', 'B': 'red'}
for p, lbl in zip(training_data, training_labels):
    plt.scatter(p[0], p[1], color=colors[lbl], label=f'Class {lbl}')

plt.scatter(test_point[0], test_point[1], color='green', marker='X', s=200, label='Test Point')

for dist, lbl, p in k_nearest:
    plt.scatter(p[0], p[1], color=colors[lbl], edgecolor='black', linewidth=2)
    plt.plot([test_point[0], p[0]], [test_point[1], p[1]], 'k--')

# Lingkaran radius
if k > 0:
    radius = distances[k-1][0]
    circle = plt.Circle(test_point, radius, color='gray', fill=False, linestyle='--')
    plt.gca().add_patch(circle)

plt.title('KNN Visualization with k=3')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend()
plt.grid(True)
plt.show()

KNN di Sistem Rekomendasi (User-Based Collaborative Filtering)

Sekarang, aplikasinya ke rekomendasi film. Ide dasar: Cari user yang selera ratingnya mirip sama kita (pake KNN), terus rekomen film yang mereka suka tapi kita belum nonton. Mirip "orang mirip kita suka ini nih!"

Visualisasi User Similarity (k=2)

Ini plot rating film A vs B. User digambarin sebagai titik berdasarkan ratingnya. TargetUser (hijau X) lagi dicek tetangganya.

Penjelasan Simpel:

Sumbu: Rating Film A (x) vs Film B (y). Semakin deket titik, semakin mirip selera.
TargetUser (hijau X): kita nih, ratingnya [4, np.nan, np.nan, np.nan] – film C & D belum dirating.
Nearest Neighbors (orange): User2 (jarak 0, super mirip) & User1 (jarak 1.41). Mereka dipilih karena KNN.
Anotasi kuning: Rekomendasi film yang belum kita rating, prediksi dari rata-rata rating neighbors. Film C (4.0) lebih direkomendasikan daripada Film D (2.5) karena skor lebih tinggi. Panah nunjukin hubungannya langsung dari posisi kita .
Other Users (abu/abu muda): Yang lain, gak terlalu mirip, jadi gak dipake. Ini bikin kita paham visually gimana KNN nyari "temen selera" dan kasih saran film.

Kode buat plot rekomendasi (pake Pandas buat data rating):

import pandas as pd
import matplotlib.pyplot as plt

# Data rating contoh
data = {'Film A': [4, 5, 3, 2, 4], 'Film B': [5, 4, 4, 3, 2], 'Film C': [3, 5, 2, 4, np.nan], 'Film D': [2, 3, 5, 1, np.nan]}
users = ['User1', 'User2', 'User3', 'User4', 'TargetUser']
df = pd.DataFrame(data, index=users)

# Fungsi jarak dengan NaN
def euclidean_distance_with_nan(r1, r2):
    mask = ~r1.isna() & ~r2.isna()
    if mask.sum() == 0: return np.inf
    return np.sqrt(((r1[mask] - r2[mask]) ** 2).sum())

# Hitung neighbors (contoh k=2)
target = df.loc['TargetUser']
distances = {u: euclidean_distance_with_nan(target, df.loc[u]) for u in df.index if u != 'TargetUser'}
sorted_dist = sorted(distances.items(), key=lambda x: x[1])
neighbors = [u for u, d in sorted_dist[:2]]  # User2, User1

# Prediksi rekomendasi (rata-rata sederhana)
unrated = target[target.isna()].index
preds = {m: df.loc[neighbors, m].mean() for m in unrated}  # {'Film C': 4.0, 'Film D': 2.5}

# Plot
plt.figure(figsize=(10, 8))
for u in df.index:
    color = 'green' if u == 'TargetUser' else 'orange' if u in neighbors else 'lightgray'
    marker = 'X' if u == 'TargetUser' else 'o'
    size = 200 if u == 'TargetUser' or u in neighbors else 100
    plt.scatter(df.loc[u, 'Film A'], df.loc[u, 'Film B'], color=color, marker=marker, s=size, label=u if color != 'lightgray' else 'Other Users')

# Anotasi rekomen
tx, ty = df.loc['TargetUser', 'Film A'], df.loc['TargetUser', 'Film B']
offset = 0.5
for m, p in sorted(preds.items(), key=lambda x: x[1], reverse=True):
    plt.annotate(f'Rec: {m} ({p:.1f})', (tx, ty), (tx + 0.5, ty + offset), arrowprops={'facecolor': 'purple', 'connectionstyle': 'arc3,rad=-0.2'})
    offset -= 0.5

plt.title('User Similarity and Recommendations (k=2) based on Film A and B Ratings')
plt.xlabel('Rating for Film A')
plt.ylabel('Rating for Film B')
plt.grid(True)
plt.legend()
plt.show()

Kesimpulan dan Tips

KNN gampang dipake buat rekomendasi karena cuma butuh data rating, gak ribet model. Tapi hati-hati sama skalanya (bisa lambat kalo data gede) dan pilih K yang pas. kita bisa improve pake weighted average atau cosine similarity buat kemiripan lebih akurat.

Bangun "OpenAI Versi Internal" dengan Dedicated AI Cluster

Mohammad Ezzeddin Pratama — Sun, 31 Aug 2025 00:49:45 +0000

Pernah kepikiran nggak sih, gimana kalau perusahaan pengen adopsi LLM tapi was-was soal data privacy?

Wajar banget. Banyak perusahaan (apalagi di bidang finance, health, atau pemerintahan) yang mikir:

“Kalau request ke API publik (OpenAI, Gemini, Anthropic, dll), aman nggak data kita? Jangan-jangan kepakai buat training lagi?”

Walaupun vendor besar klaim data aman, tetap saja ada rasa nggak tenang.

Dan di sinilah Dedicated AI Cluster masuk jadi solusi. 🔐

Kenapa Dedicated AI Cluster itu menarik?

Model jalan dedicated di cluster sendiri → resource compute bener-bener kepakai buat workload internal, bukan di-share sama orang lain.
Data training & inference nggak keluar ke pihak ketiga. Kalau pun ada vendor infra, biasanya kontraknya sudah jelas (SLA, compliance, audit).
Bisa fine-tune internal data tanpa takut bocor ke luar.

Intinya: perusahaan bisa punya kontrol penuh atas LLM yang dipakai.

Kalau jadi engineer perusahaan, gimana setup-nya?

Bayangin dapet task:

“Setup-in LLM internal ya. Jangan pakai OpenAI/Gemini. Harus private dan aman.”

Kira-kira langkahnya seperti ini:

1. Assessment awal

Cari tahu dulu: butuh apa? Chatbot internal? Search engine? Knowledge base otomatis?
Tentukan apakah butuh fine-tuning atau cukup main di prompt engineering.

2. Pilih model base

Kalau butuh chat general purpose → pakai Cohere Command R atau Llama 70B.
Kalau fokus ke search/rekomendasi → pakai Cohere Embed V3.

3. Setup cluster

Tentukan mau jalan di cloud atau on-premise (tergantung budget & regulasi).
Misalnya pilih Cohere Command R:
- Fine-tuning butuh 8 Small Cohere Dedicated units
- Hosting butuh 1 unit
- Total = 9 units → 904 unit-hours/bulan

4. Integrasi security

Pastikan data nggak keluar dari VPC.
Tambahkan audit log + enkripsi (at-rest & in-transit).

5. Deploy & monitoring

Sediakan endpoint internal API yang hanya bisa diakses lewat jaringan perusahaan.
Tambahkan observability: logging, tracing, dan alerting (misalnya deteksi spike traffic atau overuse token).

Kenapa lebih aman dibanding OpenAI/Gemini?

Kontrol penuh atas data & model.
Regulasi → di industri regulated (finance, kesehatan, dll), sering ada aturan data tidak boleh keluar.
Scalability custom → bisa disesuaikan kebutuhan bisnis, tanpa harus ikuti pricing & limit provider publik.

Jadi, kalau perusahaan mau self-hosted LLM dengan privasi ketat, arahnya memang ke Dedicated Cluster.

Bisa dibilang, ini seperti bikin “OpenAI versi internal perusahaan”.

Belajar AI: Memahami Language Agents | OCI Generative AI Professional Course #3

Mohammad Ezzeddin Pratama — Sun, 24 Aug 2025 00:14:08 +0000

1. Apa Itu Language Agents?

Language Agents adalah bidang riset baru yang ngembangin LLM-based agents, alias model AI yang bisa ngelakuin lebih dari sekadar jawab pertanyaan. Bayangin LLM kayak GPT-4 atau DeepSeek yang dikasih kemampuan buat:

Bikin rencana dan "berpikir" (reasoning).
Ambil tindakan berdasarkan rencana dan lingkungan sekitar.
Pake tools (alat) buat bantu kerja mereka.

Ini kayak ngubah LLM dari chatbot biasa jadi asisten cerdas yang bisa ngatur strategi dan eksekusi tugas. Area ini masih "budding" (baru berkembang), jadi banyak inovasi seru yang lagi diteliti!

Analogi sederhana:

Tanpa Language Agents, LLM cuma bisa jawab berdasarkan pelatihan.
Dengan Language Agents, LLM jadi agen yang bisa nyari solusi, pake kalkulator, atau ngakses data eksternal.

2. Kemampuan Utama Language Agents

Berdasarkan gambar, ada tiga kemampuan utama Language Agents:

Create plans and "reason":
- Agen ini bisa bikin rencana dan "berpikir" langkah demi langkah. Misalnya, kalau ditanya "Gimana cara bikin aplikasi AI sederhana?", agen bakal buat outline: 1) Pilih model, 2) Siapin data, 3) Coding, dll.
Take actions in response to plans and the environment:
- Setelah bikin rencana, agen bisa eksekusi tindakan berdasarkan situasi. Contoh: Kalau rencananya pake Python, agen bisa nulis kode atau panggil library yang dibutuhin.
Are capable of using tools:
- Agen bisa pake tools eksternal, kayak kalkulator, API, atau database, buat bantu jawab atau selesain tugas. Ini bikin mereka lebih fleksibel daripada LLM biasa.

3. Metode Terkenal di Language Agents

Gambar juga ngasih contoh beberapa karya penting di bidang ini. Aku jelasin satu-satu:

a. ReAct [Yao et al., 2022]

Apa itu?: ReAct adalah framework iteratif di mana LLM ngeluarin thoughts (pikiran), lalu ambil actions (tindakan), dan ngamatin results (hasil).
Cara kerja:
1. LLM mikir: "Aku perlu data buat jawab ini."
2. Ambil tindakan: Nyari data di corpus atau panggil tool.
3. Ngamatin hasil: Periksa apakah data cukup, lalu lanjut.
Contoh:
- Pertanyaan: "Berapa 5 + 7?"
- Thought: "Aku perlu kalkulator."
- Action: Panggil tool kalkulator.
- Result: "12".
Kerennya: ReAct bikin LLM lebih interaktif dan adaptif.

b. Toolformer [Schick et al., 2023]

Apa itu?: Teknik pre-training di mana strings (teks biasa) diganti dengan calls ke tools yang ngasih hasil.
Cara kerja:
- Selama pelatihan, LLM dilatih buat ngerti kapan harus panggil tool (misalnya, API cuaca) daripada nulis teks manual.
- Contoh: "Cuaca hari ini" diganti jadi panggil API cuaca, trus hasilnya (misalnya, "25°C") diproses lagi.
Contoh:
- Input: "Cuaca di Jakarta?"
- Toolformer: Panggil API cuaca → "25°C di Jakarta hari ini."
Kerennya: Bikin LLM lebih praktis buat tugas real-time tanpa perlu data pelatihan baru.

c. Bootstrapped reasoning [Zelikman et al., 2022]

Apa itu?: Metode yang nyuruh LLM ngeluarin rationalization (penjelasan langkah) dari proses berpikir, lalu pake data itu buat fine-tuning.
Cara kerja:
1. Prompt LLM buat jelasin langkah-langkah (misalnya, "Aku tambah 5 + 7 jadi 12").
2. Simpen penjelasan ini sebagai data fine-tuning.
3. Latih ulang LLM biar lebih jago nalar.
Contoh:
- Pertanyaan: "Kenapa 5 + 7 = 12?"
- LLM: "Aku tambah 5 + 7, step by step: 5 + 2 = 7, 7 + 3 = 10, 10 + 2 = 12."
- Data ini dipake buat improve reasoning.
Kerennya: Bikin LLM lebih transparan dan terlatih buat nalar logis.

4. Kaitan dengan DeepSeek 1.5B

DeepSeek 1.5B yang kamu pake di lokal bisa nggak sih jadi Language Agent?

Bisa, tapi ada batasannya. Karena cuma 1.5B parameter, DeepSeek udah jago di reasoning (matematika, coding), tapi buat jadi agen penuh (bikin rencana, pake tools), perlu tambahan:
- Integrasi ReAct buat bikin dia mikir dan ambil tindakan.
- Tambahin tools sederhana (misalnya, kalkulator atau API lokal) pake framework kayak LangChain.
- Optimasi hardware biar prosesnya nggak lelet (misalnya, pake GPU kalau ada).
Tips: Coba tes DeepSeek dengan prompt sederhana kayak "Bikin rencana buat ngerjain soal matematika" dan lihat apakah dia bisa ngeluarin langkah-langkah.

5. Catatan Belajar dan Langkah Selanjutnya

Progres gue: Gue sekarang ngerti Language Agents adalah LLM yang bisa bikin rencana, ambil tindakan, dan pake tools. Metode kayak ReAct, Toolformer, sama Bootstrapped reasoning nunjukin cara bikin LLM lebih cerdas.
Rencana berikutnya:
- Coba implementasi ReAct sederhana pake DeepSeek 1.5B di lokal. Misalnya, bikin agen yang mikir dan panggil kalkulator.
- Eksplor LangChain atau library lain buat tambahin tools ke DeepSeek.
- Tes Bootstrapped reasoning dengan prompt langkah-langkah buat latih reasoning lebih baik.
- Dalemin detail ReAct atau coba bikin agen yang interaktif pake Python.

Motivasi: Language Agents bikin AI lebih hidup kayak karakter di game! Dengan DeepSeek, gue bisa eksperimen bikin agen sederhana di lokal. Ser

# Belajar AI: Apa Itu RAG (Retrieval-Augmented Generation)? | OCI Generative AI Professional Course #2

Mohammad Ezzeddin Pratama — Sat, 23 Aug 2025 23:49:25 +0000

Ini salah satu teknik penting di aplikasi LLM (Large Language Model) yang bikin AI bisa jawab pertanyaan lebih akurat dengan nyari info dari data eksternal. Yuk, kita bedah apa itu RAG, cara kerjanya, dan apakah bener metode yang gue denger (input dokumen → nyari di corpus → LLM jawab) itu cara kerja RAG.

Belajar AI: Apa Itu RAG (Retrieval-Augmented Generation)?

1. Definisi Simpel: Apa Itu RAG?

RAG adalah teknik yang ngegabungin dua dunia: pencarian informasi (retrieval) dan *generasi teks (generation)
*.

Tanpa RAG: LLM kayak temen yang jawab pertanyaan berdasarkan ingetan doang—kadang bener, kadang ngarang (hallucination).

Dengan RAG: LLM kayak temen yang googling dulu di perpustakaan sebelum jawab, jadi lebih akurat.

Contoh:

Kamu tanya, "Apa kebijakan terbaru soal AI di Indonesia tahun 2025?"

Tanpa RAG: mungkin ngasal berdasarkan data lama.
Dengan RAG: model nyari dokumen terbaru (misalnya laporan atau artikel) terus bikin jawaban dari situ.

2. Cara Kerja RAG

Metode yang sering disebut (input → corpus → LLM) bener banget sebagai gambaran umum. Lebih detailnya:

Input (dokumen atau pertanyaan)
- Kamu kasih input berupa pertanyaan/perintah.
- Input diubah jadi vektor embedding.
Query ke Corpus (pencarian di database)
- Corpus = kumpulan dokumen yang sudah diubah jadi vektor embedding.
- Vektor input dibandingin dengan vektor dokumen di corpus (pakai cosine similarity atau FAISS).
- Hasilnya: dokumen yang paling relevan.

Contoh:

Input: "Kebijakan AI Indonesia 2025"

Dokumen relevan: "Laporan Kominfo 2025: Regulasi AI di Indonesia"

LLM menjawab berdasarkan corpus
- Dokumen relevan + input dimasukin ke LLM.
- LLM bikin jawaban pakai konteks tambahan ini.

Contoh output:

"Berdasarkan laporan Kominfo 2025, kebijakan AI di Indonesia fokus pada etika penggunaan data dan pengembangan talenta lokal."

Komponen utama RAG
- Retriever → nyari dokumen relevan (pakai embedding model).
- Generator → LLM itu sendiri (DeepSeek, GPT-4, LLaMA, dll).

Corpus biasanya disimpen di database vektor (contoh: FAISS, Pinecone) biar pencarian cepat.

3. Kenapa RAG Penting?

Kelebihan:

Lebih akurat → kurangi hallucination.
Up-to-date → bisa pake dokumen terbaru tanpa retrain LLM.
Fleksibel → cocok buat chatbot perusahaan, Q&A ilmiah, asisten programmer.

Kelemahan:

Butuh corpus yang relevan dan berkualitas.
Bisa lambat kalau corpus gede dan database nggak dioptimasi.

4. Kaitan dengan DeepSeek 1.5B

Bisa nggak bikin RAG dengan DeepSeek 1.5B di lokal? Bisa.

DeepSeek jadi bagian generator.
Tambahin retriever (misalnya pakai Hugging Face Transformers) dan corpus (file teks atau database vektor).
Karena DeepSeek 1.5B fokus ke penalaran, RAG bisa melengkapi dia dengan pengetahuan umum dari corpus.

Tantangan:

Hardware terbatas bikin lambat kalau corpus terlalu besar.
Lebih aman mulai dari corpus kecil (contoh: 10 artikel).

5. Catatan Belajar dan Langkah Selanjutnya

Progres: gue sekarang ngerti RAG = retriever + generator. Flow kerjanya: input → cari di corpus → LLM jawab.

Rencana:

Bikin aplikasi RAG sederhana pakai DeepSeek 1.5B.
Eksperimen dengan 5 artikel AI sebagai corpus.
Tes pertanyaan spesifik dan bandingin jawaban dengan/ tanpa RAG.
Dalemin database vektor (FAISS, Pinecone) biar performa lebih cepat.

Motivasi: RAG itu kayak nambah superpower ke LLM. Dengan ini, AI bisa jawab pertanyaan berdasarkan dokumen spesifik tanpa perlu model raksasa.

# Belajar AI: Memahami Parameter, Embedding, dan Decoder dalam Model Bahasa | OCI Generative AI Professional Course #1

Mohammad Ezzeddin Pratama — Sat, 23 Aug 2025 08:44:40 +0000

Belajar AI: Memahami Parameter, Embedding, dan Decoder di Model Bahasa

Semua ini berawal dari pengalaman gue nyobain DeepSeek 1.5B di laptop, dan penasaran apa sih artinya 1.5 miliar parameter, terus gimana kata-kata bisa jadi vektor, sampe cara model ngeluarin teks. Yuk, kita bongkar bareng!

1. Apa Itu Parameter di Model AI?

Saat gue download DeepSeek 1.5B, gue notice dia punya 1.5 miliar parameter. Apa sih itu?

Parameter itu kayak "sinaps" di otak AI.
Secara teknis: ini adalah weights (bobot) dalam neural network yang nyimpen pola dari data pelatihan.
Bisa dibayangin kayak koneksi di otak yang bikin AI bisa "berpikir".

1.5B parameter berarti model punya 1,5 miliar koneksi.

Ini menentukan seberapa kompleks model bisa nangkep informasi.

Makin banyak parameter = makin besar "otaknya", tapi butuh hardware lebih kuat.

Tapi, besarnya parameter nggak otomatis bikin AI super pintar. Kecerdasan tergantung pada:

Data pelatihan
Kualitas pelatihan
Arsitektur

Kesimpulan: Parameter itu ukuran kapasitas AI, tapi ilmu yang dimiliki tergantung data dan pelatihan.

DeepSeek 1.5B lebih cocok buat soal logika atau coding daripada jadi ensiklopedia berjalan.

Tips eksperimen: coba tes DeepSeek 1.5B di lokal dengan soal matematika SMA atau coding sederhana.

2. Gimana Kata Jadi Vektor? (Encoding dan Embedding)

Pernah penasaran gimana AI ngerti kata kayak kucing atau lari? Jawabannya adalah embedding, yaitu cara AI ubah kata jadi vektor numerik.

Proses:

Tokenisasi
- Kalimat: Kucing suka bermain
- Token: ["Kucing", "suka", "bermain"]
Mapping ke ID Token
- kucing → ID 1234
- suka → ID 567
Embedding Layer
- kucing → [0.23, -0.15, 0.67, ...]
Positional Encoding
- Biar model ngerti urutan kata.
Contextual Embedding
- Lewat attention, kata yang sama punya makna beda tergantung konteks.

Kenapa penting?

Embedding bikin AI bisa paham hubungan antar kata.

3. Proses Decoder: Ngubah Vektor Jadi Teks

Decoder adalah bagian model yang ngubah vektor embedding jadi teks.

DeepSeek, GPT-4, dan LLaMA pake arsitektur decoder-only (autoregressive).

Prosesnya:

Input diubah jadi token & embedding
Masuk ke transformer decoder dengan masked self-attention
Model hitung probabilitas token berikutnya
Pilih token → ubah ke kata
Ulangi sampai selesai

4. Token dan Pricelist OpenAI

Token = unit teks yang diproses AI (kata, bagian kata, atau tanda baca).

1 juta token ≈ 750k–800k kata dalam bahasa Inggris.

OpenAI ngitung biaya API berdasarkan token.

DeepSeek 1.5B di lokal gratis, tapi kecepatannya terbatas hardware.

5. Catatan Belajar dan Langkah Selanjutnya

Progres: sekarang gue ngerti parameter = kapasitas AI, embedding = ubah kata jadi vektor, decoder = bikin teks dari vektor.

Rencana:

Tes DeepSeek dengan soal matematika/coding
Coba input dengan konteks berbeda buat lihat embedding
Eksplor API OpenAI atau model lain kayak LLaMA
Dalemin soal attention mechanism atau coba visualisasi embedding

Motivasi: belajar AI itu kayak bongkar mainan baru—tiap langkah bikin penasaran.

Using OWASP ZAP in Docker for DevSecOps Workflow

Mohammad Ezzeddin Pratama — Mon, 11 Aug 2025 02:32:51 +0000

Why OWASP ZAP?

OWASP ZAP (Zed Attack Proxy) is one of the most popular open-source tools for web application security testing.
It’s a perfect fit for a DevSecOps workflow because it can be used for:

Automated scanning in the CI/CD pipeline
Manual security testing via GUI/Web UI
Baseline scan to check for common vulnerabilities

Running ZAP in Docker

To avoid the hassle of manual installation, we’ll use the Docker container version.

Pull the latest image

The old repository owasp/zap2docker-stable is deprecated, now use:

docker pull ghcr.io/zaproxy/zaproxy:stable

If successful, the output will include multiple Pull complete lines.

Running ZAP with Web UI

We can run ZAP WebSwing so it’s accessible directly from the browser:

docker run -u zap -p 8080:8080 ghcr.io/zaproxy/zaproxy:stable zap-webswing.sh

ZAP will be available at http://localhost:8080.

CLI Mode for Automation

If you want to integrate it into your CI/CD pipeline, usually it’s enough to run the CLI command:

docker run -u zap ghcr.io/zaproxy/zaproxy:stable zap-baseline.py -t https://targetwebsite.com

The scan output can be exported in HTML or XML format.

Important Tips

Make sure port 8080 is not being used by another application.
If your internet connection is unstable, Docker will resume layer downloads, so you don’t have to start from scratch.
Use a baseline scan in early development, and a full scan before production release.

Official Resources

Conclusion
Integrating OWASP ZAP into your DevSecOps workflow will improve application security without slowing down development.
With Docker, setup is super fast, letting you focus directly on testing.

Do you want me to also make a more concise, developer-focused version so it works well as a quick-start guide?

Read Input Until EOF (End-of-File) and Number Your Lines Effortlessly | Competitive Programming Java

Mohammad Ezzeddin Pratama — Sun, 01 Sep 2024 06:23:35 +0000

How to Read Input Until End of File (EOF) in Java

When dealing with input in Java, there might be situations where you don't know the number of lines you're going to read in advance. This is common in coding challenges or scenarios where you're reading from a file or stream until the end. In this post, I’ll show you a simple way to handle this using Java.

Problem Overview

Imagine you're given an unknown number of lines as input. Your task is to read all the lines until the end-of-file (EOF) and print each line, prefixed with its line number.

Here's what the input/output looks like:

Input:

Hello world
I am a file
Read me until end-of-file.

Output:

1 Hello world
2 I am a file
3 Read me until end-of-file.

The Java Approach

Java provides a handy way to handle such problems with the Scanner class and its hasNext() method. This method allows us to read input until there's no more data to read (EOF).

Code Solution

Let’s dive straight into the code:

import java.io.*;
import java.util.*;

public class Solution {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        for (int i = 1; sc.hasNext(); i++) {      
            String line = sc.nextLine();
            System.out.println(i + " " + line);
        }

        sc.close();
    }
}

Explanation

Import Required Packages: We import java.util.Scanner to use the Scanner class for reading input.
Initialize Scanner: We create a Scanner object to read from standard input (System.in).
Read Until EOF: The for loop is designed to read lines until there's no more input. The condition sc.hasNext() checks if there's more input to read. If there is, it reads the next line with sc.nextLine().
Print with Line Number: For every line read, we print it along with its line number. We use a loop counter i that starts from 1 and increments with each iteration.
Close Scanner: Although not strictly necessary here, it's a good practice to close the Scanner when you're done to avoid resource leaks.

Key Takeaways

The Scanner class in Java, with its hasNext() method, is a great tool for reading input until EOF.
Use sc.nextLine() to read each line of input.
Keep track of the line number using a simple counter.

Final Thoughts

This approach is simple yet effective for reading an unknown number of lines until EOF in Java. It comes in handy during competitive programming, file reading tasks, or any situation where you're dealing with streams of data.

Happy coding! 🚀

Fetching and Displaying Dynamic Product Data in Next.js with Prisma

Mohammad Ezzeddin Pratama — Mon, 26 Aug 2024 13:56:55 +0000

In this tutorial, ill build a dynamic product page using Next.js and Prisma.ill fetch data based on the selected category and display it using a visually appealing card layout.

1. Setting Up Dynamic Routes

Next.js allows us to create dynamic routes easily. We'll set up a dynamic route that will render products based on the selected category.

Creating the Dynamic Route

First, create a new file under the app/products/[category]/page.tsx directory. This file will handle rendering the products for the selected category.

`app/products/[category]/page.tsx`

import { notFound } from 'next/navigation';
import { type CategoryTypes } from '@prisma/client';
import React from 'react'
import prisma from '@/app/lib/db';
import ProductCard from '@/app/components/ProductCard';

async function getData(category: string) {
    let input;

    switch (category) {
        case "template":
            input = "template";
            break;
        case "uikit":
            input = "uikit";
            break;
        case "icon":
            input = "icon";
            break;
        case "all":
            input = undefined;
            break;
        default:
            return notFound();
    }

    const data = await prisma.product.findMany({
        where: {
            category: input as CategoryTypes,
        },
        select: {
            id: true,
            images: true,
            smallDescription: true,
            name: true,
            price: true,
        }
    });
    return data;
}

export default async function CategoryPage({ params }: { params: { category: string } }) {
    const data = await getData(params.category);

    return (
        <section className='max-w-7xl mx-auto px-4 md:px-8'>
            <div className="grid grid-cols-1 lg:grid-cols-3 sm:grid-cols-2 gap-10 mt-4">
                {data.map((product) => (
                    <ProductCard
                        key={product.id}
                        images={product.images}
                        name={product.name}
                        smallDescription={product.smallDescription}
                        price={product.price}
                        id={product.id}
                    />
                ))}
            </div>
        </section>
    )
}

Explanation

Dynamic Routing: The [category] in the file name tells Next.js to treat this segment as a variable. Based on this variable, we'll fetch and display products.
Fetching Data: The getData function retrieves products based on the category. It handles categories like "template", "uikit", "icon", and "all".
Rendering Cards: The ProductCard component is used to display each product in a grid layout.

2. Creating the Product Card Component

To present the products, we need a ProductCard component that displays product details in a card format.

`app/components/ProductCard.tsx`

import React from 'react'
import Image from 'next/image'
import { Carousel, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious } from '@/components/ui/carousel';
import Link from 'next/link';
import { Button } from '@/components/ui/button';

interface iAppProps {
    id: string;
    name: string;
    smallDescription: string;
    description?: string;
    price: number;
    images: string[];
}

export default function ProductCard({ id, name, smallDescription, price, images }: iAppProps) {
    return (
        <div className='rounded-lg p-2 w-full h-full flex flex-col justify-between items-center bg-white shadow-md'>
            <Carousel>
                <CarouselContent>
                    {images.map((item, index) => (
                        <CarouselItem key={index}>
                            <div className='relative h-[230px] w-full'>
                                <Image
                                    alt='Product image'
                                    src={item}
                                    width={230}
                                    height={230}
                                    quality={75}
                                    className='shadow-md object-cover w-full h-full rounded-lg' />
                            </div>
                        </CarouselItem>
                    ))}
                </CarouselContent>
                {images.length > 1 && (
                    <>
                        <CarouselPrevious className="ml-16" />
                        <CarouselNext className="mr-16" />
                    </>
                )}
            </Carousel>
            <div className='flex flex-col gap-y-2 p-2 items-end justify-start text-left h-full'>
                <div className='flex justify-between items-start mt-2 gap-x-3 w-full'>
                    <h1 className="text-md font-bold text-wrap">{name}</h1>
                    <h3 className="inline-flex items-center rounded-full bg-primary/10 px-2 py-1 text-sm font-medium text-primary ring-1 ring-inset ring-primary/10">$<span className="font-semibold">{price}</span></h3>
                </div>
                <p className='text-neutral-600 text-sm text-left line-clamp-2'>{smallDescription}</p>
                <div className='items-end justify-end pt-2'>
                    <Button className='rounded-lg hover:shadow-lg hover:scale-105 transition-all duration-300 '>
                        <Link href={`/product/${id}`}>View Details</Link>
                    </Button>
                </div>
            </div>
        </div>
    )
}

Explanation

Image Carousel: Displays multiple images for each product. Users can navigate through images using the carousel controls.
Product Details: Shows the product's name, price, and a brief description.
View Details Button: Links to a detailed product view page.

3. Adding Navigation Links

To enable navigation between different categories, create a NavbarLinks component.

`app/components/NavbarLinks.tsx`

"use client"
import { cn } from '@/lib/utils'
import Link from 'next/link'
import { usePathname } from 'next/navigation'
import React from 'react'

export const navdata = [
    {
        id: 0,
        name: "Home",
        href: "/",
    },
    {
        id: 1,
        name: "Templates", 
        href: "/products/template",
    },
    {
        id: 2,
        name: "UI Kits",
        href: "/products/uikit",
    },
    {
        id: 3,
        name: "Icons",
        href: "/products/icon",
    },
]

export default function NavbarLinks() {
    const location = usePathname();

    return (
        <div className='hidden md:flex justify-center items-center col-span-6 gap-x-9 text-md md:text-sm text-neutral-600'>
            {navdata.map((item) => {
                return (
                    <Link key={item.id} href={item.href} className={cn(
                        location === item.href ? "bg-orange-100/60 font-medium bg-opacity-100 py-1 px-2 transition-all duration-300 rounded-full text-orange-400" : "hover:text-orange-400 duration-300",
                    )}>
                        <h1>{item.name}</h1>
                    </Link>
                )
            })}
        </div>
    )
}

Explanation

Navigation Links: Provides links to different product categories. Highlights the currently active category based on the URL.

Conclusion

In this tutorial, we set up a dynamic route in Next.js to display products based on the selected category. We created a ProductCard component to present products and added a navigation bar to switch between categories.

Feel free to adapt these components and routing strategies to fit your specific project needs. Happy coding!

Building a Type-Safe Form in NextJs with Zod

Mohammad Ezzeddin Pratama — Thu, 22 Aug 2024 11:11:00 +0000

Forms are a crucial part of any web application, and building them in a type-safe manner ensures fewer bugs and better maintainability. In this blog post, we'll create a complete form in React using TypeScript and Zod for validation. All the code will be contained in a single file for simplicity.

What is Zod?
Zod is a TypeScript-first schema declaration and validation library. It allows you to define schemas for your data, which can then be used to validate inputs in a type-safe manner. This makes Zod an excellent choice for validating forms in React applications.

Setting Up the Project
If you haven't already, you'll need to install React, TypeScript, and Zod in your project:

npm install react react-dom typescript zod

Now, let's create a simple form that collects a user's first name, last name, and email, with validation for each field.

The Code
Here's the complete code for the form component:

typescript

import React, { useState } from 'react';
import { z } from 'zod';

// Define the schema using Zod
const formSchema = z.object({
  firstName: z.string().min(1, "First Name is required"),
  lastName: z.string().min(1, "Last Name is required"),
  email: z.string().email("Invalid email address"),
});

// TypeScript type derived from the Zod schema
type FormData = z.infer<typeof formSchema>;

export default function ZodForm() {
  // State to manage form input values
  const [formData, setFormData] = useState<FormData>({
    firstName: '',
    lastName: '',
    email: '',
  });

  // State to manage form errors
  const [formErrors, setFormErrors] = useState<Partial<FormData>>({});

  // Handle input changes
  const handleInputChange = (event: React.ChangeEvent<HTMLInputElement>) => {
    const { name, value } = event.target;
    setFormData({ ...formData, [name]: value });
  };

  // Handle form submission
  const handleSubmit = (event: React.FormEvent<HTMLFormElement>) => {
    event.preventDefault();

    // Validate form data using Zod
    const result = formSchema.safeParse(formData);

    if (!result.success) {
      // If validation fails, set errors
      const errors: Partial<FormData> = {};
      result.error.errors.forEach((error) => {
        if (error.path[0]) {
          errors[error.path[0] as keyof FormData] = error.message;
        }
      });
      setFormErrors(errors);
    } else {
      // If validation succeeds, clear errors and handle form submission
      setFormErrors({});
      alert('Form submitted successfully!');
      console.log(result.data);
    }
  };

  return (
    <form onSubmit={handleSubmit} className="max-w-sm mx-auto mt-10">
      <div className="mb-4">
        <label htmlFor="firstName" className="block text-sm font-medium text-gray-700">
          First Name
        </label>
        <input
          type="text"
          id="firstName"
          name="firstName"
          value={formData.firstName}
          onChange={handleInputChange}
          className="mt-1 block w-full p-2 border border-gray-300 rounded-md"
        />
        {formErrors.firstName && (
          <p className="text-red-500 text-sm mt-1">{formErrors.firstName}</p>
        )}
      </div>

      <div className="mb-4">
        <label htmlFor="lastName" className="block text-sm font-medium text-gray-700">
          Last Name
        </label>
        <input
          type="text"
          id="lastName"
          name="lastName"
          value={formData.lastName}
          onChange={handleInputChange}
          className="mt-1 block w-full p-2 border border-gray-300 rounded-md"
        />
        {formErrors.lastName && (
          <p className="text-red-500 text-sm mt-1">{formErrors.lastName}</p>
        )}
      </div>

      <div className="mb-4">
        <label htmlFor="email" className="block text-sm font-medium text-gray-700">
          Email
        </label>
        <input
          type="email"
          id="email"
          name="email"
          value={formData.email}
          onChange={handleInputChange}
          className="mt-1 block w-full p-2 border border-gray-300 rounded-md"
        />
        {formErrors.email && (
          <p className="text-red-500 text-sm mt-1">{formErrors.email}</p>
        )}
      </div>

      <button
        type="submit"
        className="w-full bg-blue-500 text-white py-2 px-4 rounded-md"
      >
        Submit
      </button>
    </form>
  );
}

Explanation
Let's break down what's happening in the code:

Defining the Schema with Zod We start by defining a schema using Zod. This schema enforces the rules for each form field. For instance, firstName and lastName are required fields, and email must be a valid email address.

typescript

const formSchema = z.object({
  firstName: z.string().min(1, "First Name is required"),
  lastName: z.string().min(1, "Last Name is required"),
  email: z.string().email("Invalid email address"),
});

Managing State We manage the form data using React's useState hook. This allows us to keep track of the user's input and any validation errors.

typescript

const [formData, setFormData] = useState<FormData>({
  firstName: '',
  lastName: '',
  email: '',
});

const [formErrors, setFormErrors] = useState<Partial<FormData>>({});

Handling Input Changes The handleInputChange function updates the state as the user types in each input field.

typescript

const handleInputChange = (event: React.ChangeEvent<HTMLInputElement>) => {
  const { name, value } = event.target;
  setFormData({ ...formData, [name]: value });
};

Handling Form Submission When the form is submitted, we validate the data using Zod's safeParse method. If the validation fails, we display error messages next to the relevant fields. If the validation succeeds, we proceed with form submission (in this case, simply logging the data and displaying an alert).

typescript

const handleSubmit = (event: React.FormEvent<HTMLFormElement>) => {
  event.preventDefault();

  const result = formSchema.safeParse(formData);

  if (!result.success) {
    const errors: Partial<FormData> = {};
    result.error.errors.forEach((error) => {
      if (error.path[0]) {
        errors[error.path[0] as keyof FormData] = error.message;
      }
    });
    setFormErrors(errors);
  } else {
    setFormErrors({});
    alert('Form submitted successfully!');
    console.log(result.data);
  }
};

Conclusion
In this post, we created a fully functional and type-safe form using React, TypeScript, and Zod. This setup ensures that your form handles user input and validation in a robust manner. By leveraging Zod, you can easily extend this approach to more complex forms and validation rules.

Adding efficient Blog Search Functionality with Tailwind CSS and React Nextjs

Mohammad Ezzeddin Pratama — Mon, 12 Aug 2024 06:16:24 +0000

In my recent project portfolio, I focused on improving the user experience by implementing a real-time search filter for blog content. This feature allows users to quickly find relevant posts by filtering through blog titles and descriptions as they type, resulting in a more efficient and user-friendly interface.

State Management with `useState`

The first step in building the search functionality was to manage the user’s input dynamically. For this, I used React’s useState hook to store the search term:

const [searchTerm, setSearchTerm] = useState<string>('');

This state variable, searchTerm, holds the current value of the text entered by the user in the search input field. As the user types, this state is updated in real-time, providing the foundation for the filtering logic.

Filtering Logic with `useEffect`

To filter the list of blogs based on the search term, I used the useEffect hook. This ensures that every time the searchTerm or the list of blogs (blogs) changes, the filtering logic is executed:

useEffect(() => {
  const searchTermLower = searchTerm.toLowerCase();
  const filtered = blogs.filter((blog: BlogItem) => 
    blog.title.toLowerCase().includes(searchTermLower) ||
    blog.description.toLowerCase().includes(searchTermLower)
  );
  setFilteredBlogs(filtered);
}, [searchTerm, blogs]);

Here's how it works:

Normalization: The search term and the blog data are converted to lowercase to make the search case-insensitive.
Filtering: The filter method is applied to the blogs array, returning only those blog items where the title or description contains the search term.
Updating State: The filtered list is stored in a new state variable, filteredBlogs, ensuring the UI only displays relevant results.

Designing the Input Component with Tailwind CSS

The next step was to design an intuitive and responsive input field using Tailwind CSS. One challenge was ensuring the input field had a distinct border color that changes when focused, especially in different themes like dark mode.

Here’s how I implemented it:

<div className="relative w-40">
  <div className="absolute inset-0 border-4 border-blue-500 rounded-lg pointer-events-none transition-all duration-200 focus-within:border-blue-700"></div>
  <input
    type="text"
    placeholder="Search blogs..."
    value={searchTerm}
    onChange={(e) => setSearchTerm(e.target.value)}
    className="w-full h-full p-2 rounded-lg bg-black/[.05] dark:bg-white/[.05] text-black/80 dark:text-white/80 focus:outline-none"
  />
</div>

Wrapper div: This div wraps the input field and contains the customizable border.
- border-4 border-blue-500: Adds a thick blue border by default.
- focus-within:border-blue-700: Changes the border color to a darker blue when the input field is focused, providing a clear visual indication.
Input Field:
- w-full h-full: Ensures the input field occupies the full width and height of its container, creating a seamless design.
- focus:outline-none: Removes the default outline to rely solely on the custom border effect.

Bringing It All Together

The combination of useState for managing input, useEffect for filtering logic, and Tailwind CSS for styling, results in a robust and visually appealing search functionality. Here’s a brief walkthrough of how it all connects:

User Input: As the user types in the search box, searchTerm is updated in real-time.
Filtering: The useEffect hook triggers, filtering the blog list based on the updated searchTerm.
Rendering: The filtered list (filteredBlogs) is rendered, showing only the relevant blog posts.
Responsive Design: The input field and search results are styled using Tailwind CSS, ensuring the interface remains clean and user-friendly across all devices.

Conclusion

Full of my code in Blog.tsx

'use client'

import { fetcher } from '../../../services/fetcher';
import clsx from 'clsx';
import { motion } from 'framer-motion';
import useSWR from 'swr';
import { useEffect, useState } from 'react';

import EmptyState from '@/common/components/elements/EmptyState';
import LoadingCard from '@/common/components/elements/LoadingCard';
import { DEVTO_BLOG_API } from '@/common/constants';
import { BlogItem } from '@/common/types/blog';

import { useBlogView } from '../../../stores/blog-view';
import useIsMobile from '../../../hooks/useIsMobile';

import BlogCard from './BlogCard';
import BlogListHeader from './BlogListHeader';

export default function Blog() {
  const isMobile = useIsMobile();
  const [searchTerm, setSearchTerm] = useState<string>('');
  const [filteredBlogs, setFilteredBlogs] = useState<BlogItem[]>([]);
  const { viewOption, setViewOption } = useBlogView();

  const { data, isLoading } = useSWR(DEVTO_BLOG_API, fetcher, {
    revalidateOnMount: true,
  });

  const blogs: BlogItem[] = data?.filter((blog: BlogItem) => blog.collection_id === null) || [];

  // UseEffect untuk memperbarui filteredBlogs setiap kali searchTerm atau blogs berubah
  useEffect(() => {
    const searchTermLower = searchTerm.toLowerCase();
    const filtered = blogs.filter((blog: BlogItem) => 
      blog.title.toLowerCase().includes(searchTermLower) ||
      blog.description.toLowerCase().includes(searchTermLower)
    );
    setFilteredBlogs(filtered);
  }, [searchTerm, blogs]);

  if (isLoading) {
    return (
      <div
        className={clsx(
          'gap-5 sm:gap-4',
          viewOption === 'list' || isMobile ? 'flex flex-col' : 'grid grid-cols-2 sm:!gap-5'
        )}
      >
        {[1, 2].map((item) => (
          <LoadingCard key={item} view={viewOption} />
        ))}
      </div>
    );
  }

  if (blogs.length === 0 && !isLoading) {
    return <EmptyState message="No Data" />;
  }

  return (
    <>
      {!isMobile && <BlogListHeader viewOption={viewOption} setViewOption={setViewOption} />}
      <div
        className={clsx(
          'mt-6 gap-5 sm:gap-4',
          viewOption === 'list' || isMobile ? 'flex flex-col' : 'grid grid-cols-2'
        )}
      >
        <input
          type="text"
          placeholder="Search blogs..."
          value={searchTerm}
          onChange={(e) => setSearchTerm(e.target.value)}
          className="w-40 rounded-lg border border-neutral-300 dark:border-neutral-600 text-black/80 dark:text-white/80 bg-black/[.05] dark:bg-white/[.05] col-span-full hover:bg-black/10 dark:hover:bg-white/10 focus:border-blue-500 dark:focus:border-blue-500 focus:outline-none p-2"
        />
        {filteredBlogs.map((item: BlogItem, index: number) => (
          <motion.div
            key={item.id}
            initial={{ opacity: 0, scale: 0.8 }}
            animate={{ opacity: 1, scale: 1 }}
            transition={{ duration: 0.3, delay: index * 0.1 }}
          >
            <BlogCard view={viewOption} {...item} />
          </motion.div>
        ))}
      </div>
    </>
  );
}

This enhanced search functionality not only improves the user experience by making content more accessible but also showcases the flexibility of combining React and Tailwind CSS. Whether dealing with large datasets or simply aiming to provide a more intuitive user interface, this approach ensures high performance and a seamless user experience.

Fetching GitHub Repository Information with Next.js and TypeScript

Mohammad Ezzeddin Pratama — Wed, 07 Aug 2024 23:15:56 +0000

In this guide, we'll learn how to fetch and display GitHub repository information using Next.js and TypeScript. We'll use the GitHub API to get data and render it in a stylish manner using TailwindCSS.

Step 1: Set Up Your Next.js Project

If you don't have a Next.js project, create one with TypeScript:

npx create-next-app my-github-portfolio --typescript
cd my-github-portfolio

Step 2: Install Axios

We will use Axios to make HTTP requests to the GitHub API. Install it using npm:

npm install axios

Step 3: Create GitHub API Service

Create a new file services/github.ts to handle API requests:

import axios from 'axios';

const GITHUB_API_URL = 'https://api.github.com';

export const getUserProfile = async (username: string) => {
  const response = await axios.get(`${GITHUB_API_URL}/users/${username}`);
  return response.data;
};

export const getUserRepositories = async (username: string) => {
  const response = await axios.get(`${GITHUB_API_URL}/users/${username}/repos`);
  return response.data;
};

Step 4: Fetch Data in Your Page Component

In your page component (e.g., pages/index.tsx), use getStaticProps to fetch data from the GitHub API:

import { GetStaticProps } from 'next';
import { getUserProfile, getUserRepositories } from '../services/github';

interface Repository {
  id: number;
  name: string;
  description: string;
  html_url: string;
}

interface ProfileProps {
  profile: {
    avatar_url: string;
    name: string;
    bio: string;
    html_url: string;
  };
  repositories: Repository[];
}

const Home = ({ profile, repositories }: ProfileProps) => {
  return (
    <div className="container mx-auto p-4">
      <div className="flex items-center space-x-4">
        <img src={profile.avatar_url} alt={profile.name} className="w-16 h-16 rounded-full" />
        <div>
          <h1 className="text-2xl font-bold">{profile.name}</h1>
          <p>{profile.bio}</p>
          <a href={profile.html_url} className="text-blue-500">GitHub Profile</a>
        </div>
      </div>
      <div className="mt-8">
        <h2 className="text-xl font-semibold">Repositories</h2>
        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4 mt-4">
          {repositories.map(repo => (
            <div key={repo.id} className="p-4 border rounded-lg">
              <h3 className="text-lg font-bold">
                <a href={repo.html_url} className="text-blue-500">{repo.name}</a>
              </h3>
              <p>{repo.description}</p>
            </div>
          ))}
        </div>
      </div>
    </div>
  );
};

export const getStaticProps: GetStaticProps = async () => {
  const username = 'your-github-username';
  const profile = await getUserProfile(username);
  const repositories = await getUserRepositories(username);

  return {
    props: {
      profile,
      repositories,
    },
  };
};

export default Home;

Step 5: Style with TailwindCSS

Ensure you have TailwindCSS set up in your project. Add the following lines to your styles/globals.css:

@tailwind base;
@tailwind components;
@tailwind utilities;

You can now use TailwindCSS classes to style your components as demonstrated in the above code.

Step 6: Run Your Project

Start your development server to see your portfolio in action:

npm run dev

Conclusion

This tutorial showed how to fetch and display GitHub repository information in a Next.js application using TypeScript and TailwindCSS. This setup allows you to dynamically render your GitHub profile and repositories, making it a great addition to your developer portfolio.