MODUL PEMBELAJARAN

PYTHON UNTUK AI & MACHINE LEARNING

Dari Dasar Hingga Advanced

Kurikulum Komprehensif untuk Menguasai

Artificial Intelligence & Machine Learning

2025
DAFTAR ISI
Modul 1: Dasar-Dasar Python .................................................. 3
Modul 2: Python untuk Data Science ........................................ 12
Modul 3: Machine Learning Fundamentals ................................. 22
Modul 4: Deep Learning dengan TensorFlow/PyTorch .................. 35
Modul 5: Computer Vision ...................................................... 48
Modul 6: Natural Language Processing (NLP) ............................ 60
Modul 7: Advanced AI & MLOps .............................................. 72
Modul 8: Proyek Capstone ...................................................... 85
MODUL 1: DASAR-DASAR PYTHON
Estimasi waktu: 2-3 minggu | Tingkat: Pemula

1.1 Instalasi dan Setup Environment

Langkah pertama adalah menyiapkan environment Python yang proper untuk
pengembangan AI.
Instalasi Python & Anaconda

# Download Anaconda dari [Link]

# Atau install Python murni dari [Link]

# Verifikasi instalasi
python --version
pip --version

# Buat virtual environment

python -m venv ai_env
source ai_env/bin/activate # Linux/Mac
ai_env\Scripts\activate # Windows

# Install packages dasar

pip install numpy pandas matplotlib jupyter

1.2 Syntax Dasar Python

Variables dan Data Types

# Tipe data dasar

integer_var = 42
float_var = 3.14159
string_var = "Hello AI"
boolean_var = True
none_var = None

# Type checking
print(type(integer_var)) # <class 'int'>
print(isinstance(float_var, float)) # True

# Type conversion
str_num = "100"
int_num = int(str_num)
float_num = float(str_num)

Collections: List, Tuple, Dict, Set

 # List - mutable, ordered
fruits = ["apple", "banana", "cherry"]
[Link]("orange")
fruits[0] = "mango"
print(fruits[1:3]) # slicing

# Tuple - immutable, ordered

coordinates = (10, 20, 30)
x, y, z = coordinates # unpacking

# Dictionary - key-value pairs

student = {
"name": "John",
"age": 25,
"courses": ["Math", "Physics"]
}
student["grade"] = "A" # add new key
print([Link]("name"))

# Set - unique elements

unique_nums = {1, 2, 3, 3, 4} # {1, 2, 3, 4}
unique_nums.add(5)

Control Flow

# If-elif-else
score = 85
if score >= 90:
grade = "A"
elif score >= 80:
grade = "B"
elif score >= 70:
grade = "C"
else:
grade = "F"

# For loops
for i in range(5):
print(i)

for index, value in enumerate(["a", "b", "c"]):

print(f"{index}: {value}")

# While loops
count = 0
while count < 5:
print(count)
count += 1

# List comprehension
squares = [x**2 for x in range(10)]
even_squares = [x**2 for x in range(10) if x % 2 == 0]
1.3 Functions dan Lambda
# Basic function
def greet(name, greeting="Hello"):
"""Docstring: fungsi untuk menyapa"""
return f"{greeting}, {name}!"

print(greet("John"))
print(greet("Jane", "Hi"))

# *args dan **kwargs

def flexible_func(*args, **kwargs):
print(f"Args: {args}")
print(f"Kwargs: {kwargs}")

flexible_func(1, 2, 3, name="John", age=25)

# Lambda functions
square = lambda x: x ** 2
add = lambda a, b: a + b

# Map, Filter, Reduce

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
evens = list(filter(lambda x: x % 2 == 0, numbers))

from functools import reduce

total = reduce(lambda a, b: a + b, numbers)

1.4 Object-Oriented Programming (OOP)

class NeuralNetwork:
"""Contoh class untuk neural network sederhana"""

def __init__(self, layers, learning_rate=0.01):

[Link] = layers
self.learning_rate = learning_rate
[Link] = []
self._initialize_weights()

def _initialize_weights(self):
"""Private method untuk inisialisasi weights"""
import random
for i in range(len([Link]) - 1):
w = [[[Link]() for _ in range([Link][i+1])]
for _ in range([Link][i])]
[Link](w)

def forward(self, inputs):

"""Forward propagation"""
activation = inputs
 for w in [Link]:
activation = self._activate(activation, w)
return activation

@staticmethod
def _activate(inputs, weights):
"""Static method untuk aktivasi"""
# Simplified matrix multiplication
return [sum(i*w for i, w in zip(inputs, col))
for col in zip(*weights)]

def __str__(self):
return f"NeuralNetwork(layers={[Link]})"

def __repr__(self):
return self.__str__()

# Inheritance
class ConvolutionalNN(NeuralNetwork):
def __init__(self, layers, kernel_size=3):
super().__init__(layers)
self.kernel_size = kernel_size

# Usage
nn = NeuralNetwork([784, 128, 64, 10])
print(nn)

1.5 File I/O dan Exception Handling

# File operations
# Writing
with open("[Link]", "w") as f:
[Link]("Hello, AI World!")

# Reading
with open("[Link]", "r") as f:
content = [Link]()

# JSON handling
import json

data = {"model": "CNN", "accuracy": 0.95}

with open("[Link]", "w") as f:
[Link](data, f, indent=2)

with open("[Link]", "r") as f:

loaded = [Link](f)

# Exception handling
try:
result = 10 / 0
 except ZeroDivisionError as e:
print(f"Error: {e}")
except Exception as e:
print(f"Unexpected error: {e}")
finally:
print("Cleanup code here")

# Custom exception
class ModelNotTrainedError(Exception):
pass

def predict(model, data):

if not model.is_trained:
raise ModelNotTrainedError("Train the model first!")

1.6 Latihan Modul 1

Latihan 1: Buat kalkulator sederhana dengan fungsi +, -, *, /
Latihan 2: Implementasikan stack dan queue menggunakan class
Latihan 3: Buat program untuk membaca CSV dan menghitung statistik dasar
Latihan 4: Implementasikan binary search dengan rekursi
MODUL 2: PYTHON UNTUK DATA SCIENCE
Estimasi waktu: 2-3 minggu | Tingkat: Pemula-Menengah

2.1 NumPy - Numerical Computing

import numpy as np

# Array creation
arr1d = [Link]([1, 2, 3, 4, 5])
arr2d = [Link]([[1, 2, 3], [4, 5, 6]])
zeros = [Link]((3, 4))
ones = [Link]((2, 3))
identity = [Link](4)
random_arr = [Link](3, 3) # normal distribution
linspace = [Link](0, 10, 50) # 50 points from 0 to 10

# Array properties
print(f"Shape: {[Link]}")
print(f"Dtype: {[Link]}")
print(f"Ndim: {[Link]}")

# Indexing dan slicing

print(arr2d[0, 1]) # element
print(arr2d[:, 1]) # column
print(arr2d[1, :]) # row
print(arr2d[0:2, 1:3]) # subarray

# Reshaping
reshaped = [Link](6, 1)
flattened = [Link]()
transposed = arr2d.T

# Mathematical operations (vectorized)

a = [Link]([1, 2, 3])
b = [Link]([4, 5, 6])
print(a + b) # element-wise addition
print(a * b) # element-wise multiplication
print([Link](a, b)) # dot product
print(a @ b) # matrix multiplication (same as dot for 1D)

# Broadcasting
matrix = [Link]([[1, 2, 3], [4, 5, 6]])
vector = [Link]([10, 20, 30])
result = matrix + vector # broadcasts vector to each row

# Aggregations
print([Link](arr2d))
print([Link](arr2d, axis=0)) # mean per column
print([Link](arr2d, axis=1)) # std per row
 print([Link](arr2d))
print([Link](arr2d)) # index of max

2.2 Pandas - Data Manipulation

import pandas as pd

# Creating DataFrames
df = [Link]({
'name': ['Alice', 'Bob', 'Charlie', 'David'],
'age': [25, 30, 35, 28],
'salary': [50000, 60000, 70000, 55000],
'department': ['IT', 'HR', 'IT', 'Finance']
})

# Reading data
df_csv = pd.read_csv('[Link]')
df_excel = pd.read_excel('[Link]')
df_json = pd.read_json('[Link]')

# Basic info
print([Link]())
print([Link]())
print([Link]())
print([Link])

# Selection
print(df['name']) # single column
print(df[['name', 'age']]) # multiple columns
print([Link][0]) # row by label
print([Link][0:2]) # rows by position
print([Link][df['age'] > 28]) # conditional

# Data manipulation
df['bonus'] = df['salary'] * 0.1 # new column
df['age_group'] = df['age'].apply(lambda x: 'young' if x < 30 else
'senior')

# Groupby operations
grouped = [Link]('department').agg({
'salary': ['mean', 'max'],
'age': 'mean'
})

# Merging DataFrames
df1 = [Link]({'id': [1, 2, 3], 'value': ['a', 'b', 'c']})
df2 = [Link]({'id': [2, 3, 4], 'score': [10, 20, 30]})
merged = [Link](df1, df2, on='id', how='inner')

# Handling missing values

df_missing = [Link]()
 df_missing.loc[0, 'salary'] = None
df_filled = df_missing.fillna(df_missing['salary'].mean())
df_dropped = df_missing.dropna()

# Pivot tables
pivot = df.pivot_table(values='salary',
index='department',
aggfunc=['mean', 'count'])

2.3 Matplotlib & Seaborn - Visualization

import [Link] as plt
import seaborn as sns
import numpy as np

# Basic plots
fig, axes = [Link](2, 2, figsize=(12, 10))

# Line plot
x = [Link](0, 10, 100)
axes[0, 0].plot(x, [Link](x), label='sin(x)')
axes[0, 0].plot(x, [Link](x), label='cos(x)')
axes[0, 0].set_title('Line Plot')
axes[0, 0].legend()
axes[0, 0].grid(True)

# Scatter plot
[Link](42)
x_scatter = [Link](100)
y_scatter = x_scatter + [Link](100) * 0.5
axes[0, 1].scatter(x_scatter, y_scatter, alpha=0.6)
axes[0, 1].set_title('Scatter Plot')

# Bar plot
categories = ['A', 'B', 'C', 'D']
values = [23, 45, 56, 78]
axes[1, 0].bar(categories, values, color='steelblue')
axes[1, 0].set_title('Bar Plot')

# Histogram
data = [Link](1000)
axes[1, 1].hist(data, bins=30, edgecolor='black')
axes[1, 1].set_title('Histogram')

plt.tight_layout()
[Link]('[Link]', dpi=150)
[Link]()

# Seaborn - Statistical visualization

tips = sns.load_dataset('tips')
 fig, axes = [Link](2, 2, figsize=(12, 10))

# Distribution plot
[Link](tips['total_bill'], kde=True, ax=axes[0, 0])

# Box plot
[Link](x='day', y='total_bill', data=tips, ax=axes[0, 1])

# Heatmap (correlation matrix)

corr = tips.select_dtypes(include=[[Link]]).corr()
[Link](corr, annot=True, cmap='coolwarm', ax=axes[1, 0])

# Pair plot (separate figure)

# [Link](tips, hue='sex')

plt.tight_layout()
[Link]()

2.4 Latihan Modul 2

Latihan 1: Load dataset Titanic, lakukan EDA lengkap
Latihan 2: Buat visualisasi untuk stock price dengan moving average
Latihan 3: Implementasikan feature engineering pada dataset housing
Latihan 4: Buat dashboard interaktif dengan Plotly
MODUL 3: MACHINE LEARNING FUNDAMENTALS
Estimasi waktu: 3-4 minggu | Tingkat: Menengah

3.1 Preprocessing & Feature Engineering

from sklearn.model_selection import train_test_split
from [Link] import StandardScaler, MinMaxScaler
from [Link] import LabelEncoder, OneHotEncoder
from [Link] import SimpleImputer
import pandas as pd
import numpy as np

# Sample data
df = [Link]({
'age': [25, 30, None, 35, 28],
'salary': [50000, 60000, 70000, None, 55000],
'department': ['IT', 'HR', 'IT', 'Finance', 'HR'],
'target': [0, 1, 1, 0, 1]
})

# Handle missing values

imputer = SimpleImputer(strategy='mean')
df[['age', 'salary']] = imputer.fit_transform(df[['age', 'salary']])

# Encoding categorical variables

# Label Encoding
le = LabelEncoder()
df['dept_encoded'] = le.fit_transform(df['department'])

# One-Hot Encoding
df_encoded = pd.get_dummies(df, columns=['department'])

# Feature scaling
scaler = StandardScaler() # or MinMaxScaler()
X = df[['age', 'salary']].values
X_scaled = scaler.fit_transform(X)

# Train-test split
X = df_encoded.drop('target', axis=1)
y = df_encoded['target']
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)

# Feature selection
from sklearn.feature_selection import SelectKBest, f_classif
selector = SelectKBest(f_classif, k=5)
X_selected = selector.fit_transform(X_train, y_train)
3.2 Supervised Learning - Classification
from sklearn.linear_model import LogisticRegression
from [Link] import DecisionTreeClassifier
from [Link] import RandomForestClassifier,
GradientBoostingClassifier
from [Link] import SVC
from [Link] import KNeighborsClassifier
from [Link] import accuracy_score, classification_report
from [Link] import confusion_matrix, roc_auc_score

# Load sample dataset

from [Link] import load_breast_cancer
data = load_breast_cancer()
X, y = [Link], [Link]

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, random_state=42
)

# Scale features
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = [Link](X_test)

# Models dictionary
models = {
'Logistic Regression': LogisticRegression(max_iter=1000),
'Decision Tree': DecisionTreeClassifier(max_depth=5),
'Random Forest': RandomForestClassifier(n_estimators=100),
'Gradient Boosting': GradientBoostingClassifier(),
'SVM': SVC(kernel='rbf', probability=True),
'KNN': KNeighborsClassifier(n_neighbors=5)
}

# Train and evaluate

results = {}
for name, model in [Link]():
[Link](X_train_scaled, y_train)
y_pred = [Link](X_test_scaled)

accuracy = accuracy_score(y_test, y_pred)

results[name] = accuracy

print(f"\n{name}:")
print(f"Accuracy: {accuracy:.4f}")
print(classification_report(y_test, y_pred))

# Feature importance (for tree-based models)

rf = models['Random Forest']
importances = [Link]({
'feature': data.feature_names,
'importance': rf.feature_importances_
 }).sort_values('importance', ascending=False)

3.3 Supervised Learning - Regression

from sklearn.linear_model import LinearRegression, Ridge, Lasso
from [Link] import DecisionTreeRegressor
from [Link] import RandomForestRegressor,
GradientBoostingRegressor
from [Link] import mean_squared_error, mean_absolute_error,
r2_score
import numpy as np

# Load sample dataset

from [Link] import fetch_california_housing
data = fetch_california_housing()
X, y = [Link], [Link]

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, random_state=42
)

# Scale features
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = [Link](X_test)

# Models
models = {
'Linear Regression': LinearRegression(),
'Ridge': Ridge(alpha=1.0),
'Lasso': Lasso(alpha=0.1),
'Decision Tree': DecisionTreeRegressor(max_depth=10),
'Random Forest': RandomForestRegressor(n_estimators=100),
'Gradient Boosting': GradientBoostingRegressor()
}

# Evaluate
for name, model in [Link]():
[Link](X_train_scaled, y_train)
y_pred = [Link](X_test_scaled)

mse = mean_squared_error(y_test, y_pred)

rmse = [Link](mse)
mae = mean_absolute_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"{name}:")
print(f" RMSE: {rmse:.4f}, MAE: {mae:.4f}, R2: {r2:.4f}")

3.4 Unsupervised Learning

 from [Link] import KMeans, DBSCAN, AgglomerativeClustering
from [Link] import PCA
from [Link] import TSNE
from [Link] import silhouette_score

# Clustering with K-Means

kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
clusters = kmeans.fit_predict(X_scaled)

# Evaluate clustering
silhouette = silhouette_score(X_scaled, clusters)
print(f"Silhouette Score: {silhouette:.4f}")

# Elbow method for optimal k

inertias = []
for k in range(1, 11):
km = KMeans(n_clusters=k, random_state=42, n_init=10)
[Link](X_scaled)
[Link](km.inertia_)

# DBSCAN (density-based)
dbscan = DBSCAN(eps=0.5, min_samples=5)
db_clusters = dbscan.fit_predict(X_scaled)

# Dimensionality reduction
# PCA
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)
print(f"Explained variance ratio: {pca.explained_variance_ratio_}")

# t-SNE
tsne = TSNE(n_components=2, random_state=42, perplexity=30)
X_tsne = tsne.fit_transform(X_scaled)

# Visualization
import [Link] as plt
fig, axes = [Link](1, 2, figsize=(14, 5))

axes[0].scatter(X_pca[:, 0], X_pca[:, 1], c=clusters, cmap='viridis')

axes[0].set_title('PCA + K-Means Clustering')

axes[1].scatter(X_tsne[:, 0], X_tsne[:, 1], c=clusters, cmap='viridis')

axes[1].set_title('t-SNE + K-Means Clustering')
[Link]()

3.5 Model Selection & Hyperparameter Tuning

from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.model_selection import RandomizedSearchCV, StratifiedKFold
 # Cross-validation
rf = RandomForestClassifier(random_state=42)
cv_scores = cross_val_score(rf, X_train_scaled, y_train, cv=5,
scoring='accuracy')
print(f"CV Accuracy: {cv_scores.mean():.4f} (+/-
{cv_scores.std()*2:.4f})")

# Grid Search
param_grid = {
'n_estimators': [50, 100, 200],
'max_depth': [5, 10, 15, None],
'min_samples_split': [2, 5, 10],
'min_samples_leaf': [1, 2, 4]
}

grid_search = GridSearchCV(
RandomForestClassifier(random_state=42),
param_grid,
cv=5,
scoring='accuracy',
n_jobs=-1,
verbose=1
)
grid_search.fit(X_train_scaled, y_train)

print(f"Best params: {grid_search.best_params_}")

print(f"Best score: {grid_search.best_score_:.4f}")

# Randomized Search (lebih efisien untuk large search space)

from [Link] import randint, uniform

param_dist = {
'n_estimators': randint(50, 300),
'max_depth': randint(3, 20),
'min_samples_split': randint(2, 20),
'min_samples_leaf': randint(1, 10)
}

random_search = RandomizedSearchCV(
RandomForestClassifier(random_state=42),
param_dist,
n_iter=50,
cv=5,
scoring='accuracy',
n_jobs=-1,
random_state=42
)
random_search.fit(X_train_scaled, y_train)

3.6 Ensemble Methods

 from [Link] import VotingClassifier, StackingClassifier
from [Link] import BaggingClassifier, AdaBoostClassifier

# Voting Classifier
voting_clf = VotingClassifier(
estimators=[
('lr', LogisticRegression(max_iter=1000)),
('rf', RandomForestClassifier(n_estimators=100)),
('svm', SVC(probability=True))
],
voting='soft' # 'hard' for majority voting
)
voting_clf.fit(X_train_scaled, y_train)

# Stacking Classifier
stacking_clf = StackingClassifier(
estimators=[
('rf', RandomForestClassifier(n_estimators=100)),
('gb', GradientBoostingClassifier()),
('svm', SVC(probability=True))
],
final_estimator=LogisticRegression(),
cv=5
)
stacking_clf.fit(X_train_scaled, y_train)

# Bagging
bagging_clf = BaggingClassifier(
estimator=DecisionTreeClassifier(),
n_estimators=100,
max_samples=0.8,
bootstrap=True,
random_state=42
)

# AdaBoost
ada_clf = AdaBoostClassifier(
estimator=DecisionTreeClassifier(max_depth=1),
n_estimators=100,
learning_rate=0.1,
random_state=42
)

3.7 Latihan Modul 3

Latihan 1: Klasifikasi Iris dengan multiple algorithms dan cross-validation
Latihan 2: Prediksi harga rumah dengan feature engineering lengkap
Latihan 3: Customer segmentation dengan clustering
Latihan 4: Implementasikan ensemble stacking untuk competition
MODUL 4: DEEP LEARNING
Estimasi waktu: 4-5 minggu | Tingkat: Menengah-Advanced

4.1 Neural Network Fundamentals

import tensorflow as tf
from tensorflow import keras
from [Link] import layers, models, optimizers
from [Link] import EarlyStopping, ModelCheckpoint
import numpy as np

# Simple neural network from scratch (untuk pemahaman)

class SimpleNeuralNetwork:
def __init__(self, layer_sizes):
[Link] = []
[Link] = []

for i in range(len(layer_sizes) - 1):

w = [Link](layer_sizes[i], layer_sizes[i+1]) * 0.01
b = [Link]((1, layer_sizes[i+1]))
[Link](w)
[Link](b)

def sigmoid(self, z):

return 1 / (1 + [Link](-[Link](z, -500, 500)))

def sigmoid_derivative(self, a):

return a * (1 - a)

def forward(self, X):

[Link] = [X]
a = X
for w, b in zip([Link], [Link]):
z = [Link](a, w) + b
a = [Link](z)
[Link](a)
return a

def backward(self, X, y, learning_rate=0.01):

m = [Link][0]
deltas = [None] * len([Link])

# Output layer
error = [Link][-1] - y
deltas[-1] = error * self.sigmoid_derivative([Link][-1])

# Hidden layers
for i in range(len([Link]) - 2, -1, -1):
error = [Link](deltas[i+1], [Link][i+1].T)
deltas[i] = error *
 self.sigmoid_derivative([Link][i+1])

# Update weights
for i in range(len([Link])):
[Link][i] -= learning_rate * [Link](
[Link][i].T, deltas[i]
) / m
[Link][i] -= learning_rate * [Link](
deltas[i], axis=0, keepdims=True
) / m

# Usage
nn = SimpleNeuralNetwork([784, 128, 64, 10])

4.2 TensorFlow/Keras - Building Models

# Sequential API
model_sequential = [Link]([
[Link](128, activation='relu', input_shape=(784,)),
[Link](0.2),
[Link](64, activation='relu'),
[Link](0.2),
[Link](10, activation='softmax')
])

# Functional API (lebih fleksibel)

inputs = [Link](shape=(784,))
x = [Link](128, activation='relu')(inputs)
x = [Link]()(x)
x = [Link](0.2)(x)
x = [Link](64, activation='relu')(x)
x = [Link](0.2)(x)
outputs = [Link](10, activation='softmax')(x)
model_functional = [Link](inputs=inputs, outputs=outputs)

# Compile
model_functional.compile(
optimizer=[Link](learning_rate=0.001),
loss='sparse_categorical_crossentropy',
metrics=['accuracy']
)

# Callbacks
callbacks = [
EarlyStopping(patience=5, restore_best_weights=True),
ModelCheckpoint('best_model.keras', save_best_only=True)
]

# Training
# history = model_functional.fit(
# X_train, y_train,
 # epochs=50,
# batch_size=32,
# validation_split=0.2,
# callbacks=callbacks
# )

# Model summary
model_functional.summary()

4.3 Convolutional Neural Networks (CNN)

# CNN untuk Image Classification
def create_cnn_model(input_shape, num_classes):
model = [Link]([
# Block 1
layers.Conv2D(32, (3, 3), activation='relu',
input_shape=input_shape, padding='same'),
[Link](),
layers.Conv2D(32, (3, 3), activation='relu', padding='same'),
layers.MaxPooling2D((2, 2)),
[Link](0.25),

# Block 2
layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
[Link](),
layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
layers.MaxPooling2D((2, 2)),
[Link](0.25),

# Block 3
layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
[Link](),
layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
layers.MaxPooling2D((2, 2)),
[Link](0.25),

# Classifier
[Link](),
[Link](256, activation='relu'),
[Link](),
[Link](0.5),
[Link](num_classes, activation='softmax')
])
return model

# Create model
cnn_model = create_cnn_model((32, 32, 3), 10)
cnn_model.compile(
optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy']
)
 # Data augmentation
from [Link] import ImageDataGenerator

datagen = ImageDataGenerator(
rotation_range=15,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=True,
zoom_range=0.1
)

4.4 Recurrent Neural Networks (RNN/LSTM)

# LSTM untuk sequence modeling
def create_lstm_model(vocab_size, embedding_dim, max_length, num_classes):
model = [Link]([
[Link](vocab_size, embedding_dim,
input_length=max_length),
layers.SpatialDropout1D(0.2),
[Link]([Link](128, return_sequences=True)),
[Link]([Link](64)),
[Link](64, activation='relu'),
[Link](0.5),
[Link](num_classes, activation='softmax')
])
return model

# GRU alternative
def create_gru_model(vocab_size, embedding_dim, max_length, num_classes):
model = [Link]([
[Link](vocab_size, embedding_dim,
input_length=max_length),
[Link](128, return_sequences=True),
[Link](64),
[Link](num_classes, activation='softmax')
])
return model

# Time series forecasting dengan LSTM

def create_time_series_model(n_features, n_steps):
model = [Link]([
[Link](100, activation='relu', return_sequences=True,
input_shape=(n_steps, n_features)),
[Link](50, activation='relu'),
[Link](1)
])
[Link](optimizer='adam', loss='mse')
return model

4.5 Transfer Learning

 from [Link] import VGG16, ResNet50, EfficientNetB0
from [Link].vgg16 import preprocess_input

# Load pretrained model

base_model = VGG16(
weights='imagenet',
include_top=False,
input_shape=(224, 224, 3)
)

# Freeze base model

base_model.trainable = False

# Add custom classifier

model = [Link]([
base_model,
layers.GlobalAveragePooling2D(),
[Link](256, activation='relu'),
[Link](0.5),
[Link](10, activation='softmax') # 10 classes
])

[Link](
optimizer=[Link](learning_rate=0.001),
loss='categorical_crossentropy',
metrics=['accuracy']
)

# Fine-tuning (setelah training classifier)

base_model.trainable = True

# Freeze early layers, train later layers

for layer in base_model.layers[:-4]:
[Link] = False

# Recompile dengan lower learning rate

[Link](
optimizer=[Link](learning_rate=0.0001),
loss='categorical_crossentropy',
metrics=['accuracy']
)

4.6 PyTorch Alternative

import torch
import [Link] as nn
import [Link] as optim
from [Link] import DataLoader, TensorDataset

# Define model
class NeuralNetwork([Link]):
 def __init__(self, input_size, hidden_sizes, output_size):
super(NeuralNetwork, self).__init__()

layers_list = []
prev_size = input_size

for hidden_size in hidden_sizes:

layers_list.append([Link](prev_size, hidden_size))
layers_list.append(nn.BatchNorm1d(hidden_size))
layers_list.append([Link]())
layers_list.append([Link](0.2))
prev_size = hidden_size

layers_list.append([Link](prev_size, output_size))
[Link] = [Link](*layers_list)

def forward(self, x):

return [Link](x)

# Create model
model = NeuralNetwork(784, [128, 64], 10)

# Loss and optimizer

criterion = [Link]()
optimizer = [Link]([Link](), lr=0.001)

# Training loop
def train(model, train_loader, criterion, optimizer, epochs=10):
[Link]()
for epoch in range(epochs):
total_loss = 0
for batch_x, batch_y in train_loader:
optimizer.zero_grad()
outputs = model(batch_x)
loss = criterion(outputs, batch_y)
[Link]()
[Link]()
total_loss += [Link]()

print(f"Epoch {epoch+1}, Loss:

{total_loss/len(train_loader):.4f}")

# CNN in PyTorch
class CNN([Link]):
def __init__(self):
super(CNN, self).__init__()
self.conv_layers = [Link](
nn.Conv2d(3, 32, kernel_size=3, padding=1),
nn.BatchNorm2d(32),
[Link](),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, kernel_size=3, padding=1),
nn.BatchNorm2d(64),
 [Link](),
nn.MaxPool2d(2)
)
self.fc_layers = [Link](
[Link](),
[Link](64 * 8 * 8, 256),
[Link](),
[Link](0.5),
[Link](256, 10)
)

def forward(self, x):

x = self.conv_layers(x)
x = self.fc_layers(x)
return x

4.7 Latihan Modul 4

Latihan 1: Klasifikasi MNIST dengan CNN dari scratch
Latihan 2: Sentiment analysis dengan LSTM
Latihan 3: Transfer learning untuk image classification
Latihan 4: Time series forecasting dengan LSTM
MODUL 5: COMPUTER VISION
Estimasi waktu: 3-4 minggu | Tingkat: Menengah-Advanced

5.1 OpenCV Fundamentals

import cv2
import numpy as np

# Read and display image

img = [Link]('[Link]')
img_rgb = [Link](img, cv2.COLOR_BGR2RGB)

# Basic operations
gray = [Link](img, cv2.COLOR_BGR2GRAY)
resized = [Link](img, (224, 224))
rotated = [Link](img, cv2.ROTATE_90_CLOCKWISE)

# Image filtering
blurred = [Link](img, (5, 5), 0)
edges = [Link](gray, 100, 200)

# Thresholding
_, binary = [Link](gray, 127, 255, cv2.THRESH_BINARY)
adaptive = [Link](gray, 255,
cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)

# Contour detection
contours, hierarchy = [Link](
binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
)

# Draw on image
img_copy = [Link]()
[Link](img_copy, contours, -1, (0, 255, 0), 2)
[Link](img_copy, (100, 100), (300, 300), (255, 0, 0), 2)
[Link](img_copy, (200, 200), 50, (0, 0, 255), -1)
[Link](img_copy, 'Hello', (50, 50),
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)

# Video processing
cap = [Link](0) # webcam
while True:
ret, frame = [Link]()
if not ret:
break

# Process frame
gray_frame = [Link](frame, cv2.COLOR_BGR2GRAY)
 [Link]('Video', frame)
if [Link](1) & 0xFF == ord('q'):
break

[Link]()
[Link]()

5.2 Object Detection dengan YOLO

from ultralytics import YOLO
import cv2

# Load pretrained model

model = YOLO('[Link]') # nano version

# Inference on image
results = model('[Link]')

# Process results
for result in results:
boxes = [Link]
for box in boxes:
x1, y1, x2, y2 = [Link][0].cpu().numpy()
confidence = [Link][0].cpu().numpy()
class_id = int([Link][0].cpu().numpy())
class_name = [Link][class_id]

print(f"{class_name}: {confidence:.2f}")

# Training custom model

# 1. Prepare dataset in YOLO format
# dataset/
# train/
# images/
# labels/
# val/
# images/
# labels/

# 2. Create [Link]
# path: ./dataset
# train: train/images
# val: val/images
# nc: 5 # number of classes
# names: ['class1', 'class2', 'class3', 'class4', 'class5']

# 3. Train
model = YOLO('[Link]')
results = [Link](
data='[Link]',
epochs=100,
 imgsz=640,
batch=16,
device=0 # GPU
)

# 4. Inference with trained model

trained_model = YOLO('runs/detect/train/weights/[Link]')
results = trained_model.predict('test_image.jpg', conf=0.5)

5.3 Image Segmentation

# Semantic Segmentation dengan U-Net
from tensorflow import keras
from [Link] import layers

def unet_model(input_shape=(256, 256, 3), num_classes=2):

inputs = [Link](shape=input_shape)

# Encoder
c1 = layers.Conv2D(64, 3, activation='relu', padding='same')(inputs)
c1 = layers.Conv2D(64, 3, activation='relu', padding='same')(c1)
p1 = layers.MaxPooling2D()(c1)

c2 = layers.Conv2D(128, 3, activation='relu', padding='same')(p1)

c2 = layers.Conv2D(128, 3, activation='relu', padding='same')(c2)
p2 = layers.MaxPooling2D()(c2)

c3 = layers.Conv2D(256, 3, activation='relu', padding='same')(p2)

c3 = layers.Conv2D(256, 3, activation='relu', padding='same')(c3)
p3 = layers.MaxPooling2D()(c3)

# Bridge
c4 = layers.Conv2D(512, 3, activation='relu', padding='same')(p3)
c4 = layers.Conv2D(512, 3, activation='relu', padding='same')(c4)

# Decoder
u5 = layers.UpSampling2D()(c4)
u5 = [Link]([u5, c3])
c5 = layers.Conv2D(256, 3, activation='relu', padding='same')(u5)
c5 = layers.Conv2D(256, 3, activation='relu', padding='same')(c5)

u6 = layers.UpSampling2D()(c5)
u6 = [Link]([u6, c2])
c6 = layers.Conv2D(128, 3, activation='relu', padding='same')(u6)
c6 = layers.Conv2D(128, 3, activation='relu', padding='same')(c6)

u7 = layers.UpSampling2D()(c6)
u7 = [Link]([u7, c1])
c7 = layers.Conv2D(64, 3, activation='relu', padding='same')(u7)
c7 = layers.Conv2D(64, 3, activation='relu', padding='same')(c7)

outputs = layers.Conv2D(num_classes, 1, activation='softmax')(c7)

 return [Link](inputs, outputs)

# Instance Segmentation dengan Mask R-CNN (using detectron2)

# pip install detectron2

# from detectron2 import model_zoo

# from [Link] import DefaultPredictor
# from [Link] import get_cfg

# cfg = get_cfg()
# cfg.merge_from_file(model_zoo.get_config_file(
# "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"
# ))
# [Link] = model_zoo.get_checkpoint_url(
# "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"
# )
# predictor = DefaultPredictor(cfg)
# outputs = predictor(image)

5.4 Latihan Modul 5

Latihan 1: Face detection dan recognition system
Latihan 2: Object detection untuk traffic monitoring
Latihan 3: Medical image segmentation
Latihan 4: Real-time pose estimation
MODUL 6: NATURAL LANGUAGE PROCESSING
Estimasi waktu: 3-4 minggu | Tingkat: Menengah-Advanced

6.1 Text Preprocessing

import re
import nltk
from [Link] import word_tokenize, sent_tokenize
from [Link] import stopwords
from [Link] import PorterStemmer, WordNetLemmatizer

# Download NLTK data

[Link]('punkt')
[Link]('stopwords')
[Link]('wordnet')

text = "The quick brown foxes are jumping over the lazy dogs! They're
having fun."

# Lowercase
text_lower = [Link]()

# Remove punctuation
text_clean = [Link](r'[^\w\s]', '', text_lower)

# Tokenization
tokens = word_tokenize(text_clean)
sentences = sent_tokenize(text)

# Remove stopwords
stop_words = set([Link]('english'))
filtered_tokens = [w for w in tokens if w not in stop_words]

# Stemming
stemmer = PorterStemmer()
stemmed = [[Link](w) for w in filtered_tokens]

# Lemmatization
lemmatizer = WordNetLemmatizer()
lemmatized = [[Link](w) for w in filtered_tokens]

print(f"Original: {tokens}")
print(f"Filtered: {filtered_tokens}")
print(f"Stemmed: {stemmed}")
print(f"Lemmatized: {lemmatized}")

6.2 Text Vectorization

from sklearn.feature_extraction.text import CountVectorizer,
TfidfVectorizer
import numpy as np

documents = [
"Machine learning is a subset of artificial intelligence",
"Deep learning uses neural networks with many layers",
"Natural language processing deals with text data"
]

# Bag of Words
count_vec = CountVectorizer()
bow_matrix = count_vec.fit_transform(documents)
print("Vocabulary:", count_vec.get_feature_names_out())

# TF-IDF
tfidf_vec = TfidfVectorizer()
tfidf_matrix = tfidf_vec.fit_transform(documents)

# Word Embeddings dengan Gensim

from [Link] import Word2Vec

# Prepare sentences (list of lists)

sentences = [[Link]().split() for doc in documents]

# Train Word2Vec
w2v_model = Word2Vec(
sentences,
vector_size=100,
window=5,
min_count=1,
workers=4
)

# Get word vector

word_vector = w2v_model.wv['learning']

# Similar words
similar = w2v_model.wv.most_similar('learning', topn=5)

# Pretrained embeddings (GloVe, FastText)

# Download: [Link]
def load_glove_embeddings(file_path):
embeddings = {}
with open(file_path, 'r', encoding='utf-8') as f:
for line in f:
values = [Link]()
word = values[0]
vector = [Link](values[1:], dtype='float32')
embeddings[word] = vector
return embeddings
 # glove = load_glove_embeddings('[Link]')

6.3 Text Classification

from sklearn.naive_bayes import MultinomialNB
from sklearn.linear_model import LogisticRegression
from [Link] import Pipeline
from sklearn.model_selection import train_test_split
from [Link] import classification_report

# Sample data
texts = [
"This movie was amazing and wonderful",
"Terrible film, waste of time",
"Great acting and beautiful cinematography",
"Boring and predictable plot",
"Best movie I have ever seen",
"Disappointing ending, not recommended"
]
labels = [1, 0, 1, 0, 1, 0] # 1: positive, 0: negative

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(
texts, labels, test_size=0.2, random_state=42
)

# Pipeline dengan TF-IDF + Classifier

pipeline = Pipeline([
('tfidf', TfidfVectorizer(max_features=5000, ngram_range=(1, 2))),
('clf', LogisticRegression())
])

[Link](X_train, y_train)
predictions = [Link](X_test)
print(classification_report(y_test, predictions))

# Deep Learning untuk Text Classification

from [Link] import Tokenizer
from [Link] import pad_sequences

# Tokenization
tokenizer = Tokenizer(num_words=10000, oov_token='<OOV>')
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
padded = pad_sequences(sequences, maxlen=100, padding='post')

# Build model
model = [Link]([
[Link](10000, 128, input_length=100),
[Link]([Link](64)),
[Link](32, activation='relu'),
 [Link](0.5),
[Link](1, activation='sigmoid')
])

[Link](optimizer='adam', loss='binary_crossentropy',
metrics=['accuracy'])

6.4 Transformers & BERT

from transformers import AutoTokenizer, AutoModel,
AutoModelForSequenceClassification
from transformers import pipeline
import torch

# Using pretrained pipeline (easiest)

classifier = pipeline("sentiment-analysis")
result = classifier("I love this product!")
print(result) # [{'label': 'POSITIVE', 'score': 0.99}]

# Question answering
qa_pipeline = pipeline("question-answering")
context = "Python is a programming language created by Guido van Rossum."
question = "Who created Python?"
answer = qa_pipeline(question=question, context=context)
print(answer)

# Text generation
generator = pipeline("text-generation", model="gpt2")
text = generator("AI will change the world", max_length=50)

# Custom BERT for classification

model_name = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(
model_name, num_labels=2
)

# Tokenize
text = "This is an example sentence."
inputs = tokenizer(
text,
padding=True,
truncation=True,
max_length=128,
return_tensors="pt"
)

# Inference
with torch.no_grad():
outputs = model(**inputs)
predictions = [Link]([Link], dim=-1)
 print(predictions)

# Fine-tuning BERT dengan Trainer API

from transformers import Trainer, TrainingArguments

training_args = TrainingArguments(
output_dir='./results',
num_train_epochs=3,
per_device_train_batch_size=16,
per_device_eval_batch_size=64,
warmup_steps=500,
weight_decay=0.01,
logging_dir='./logs',
)

# trainer = Trainer(
# model=model,
# args=training_args,
# train_dataset=train_dataset,
# eval_dataset=eval_dataset
# )
# [Link]()

6.5 Latihan Modul 6

Latihan 1: Spam detection dengan Naive Bayes dan BERT
Latihan 2: Named Entity Recognition (NER)
Latihan 3: Text summarization dengan transformers
Latihan 4: Chatbot sederhana dengan seq2seq
MODUL 7: ADVANCED AI & MLOps
Estimasi waktu: 3-4 minggu | Tingkat: Advanced

7.1 Generative AI
# Variational Autoencoder (VAE)
from tensorflow import keras
from [Link] import layers
import tensorflow as tf

class VAE([Link]):
def __init__(self, latent_dim):
super(VAE, self).__init__()
self.latent_dim = latent_dim

# Encoder
[Link] = [Link]([
[Link](256, activation='relu'),
[Link](128, activation='relu'),
])
self.z_mean = [Link](latent_dim)
self.z_log_var = [Link](latent_dim)

# Decoder
[Link] = [Link]([
[Link](128, activation='relu'),
[Link](256, activation='relu'),
[Link](784, activation='sigmoid')
])

def encode(self, x):

h = [Link](x)
return self.z_mean(h), self.z_log_var(h)

def reparameterize(self, z_mean, z_log_var):

eps = [Link](shape=[Link](z_mean))
return z_mean + [Link](0.5 * z_log_var) * eps

def decode(self, z):

return [Link](z)

def call(self, x):

z_mean, z_log_var = [Link](x)
z = [Link](z_mean, z_log_var)
return [Link](z), z_mean, z_log_var

# GAN (Generative Adversarial Network)

def build_generator(latent_dim):
model = [Link]([
[Link](256, input_dim=latent_dim),
 [Link](0.2),
[Link](),
[Link](512),
[Link](0.2),
[Link](),
[Link](784, activation='tanh')
])
return model

def build_discriminator():
model = [Link]([
[Link](512, input_dim=784),
[Link](0.2),
[Link](0.3),
[Link](256),
[Link](0.2),
[Link](0.3),
[Link](1, activation='sigmoid')
])
return model

7.2 Reinforcement Learning

import gymnasium as gym
import numpy as np

# Q-Learning
class QLearningAgent:
def __init__(self, state_size, action_size, lr=0.1, gamma=0.99,
epsilon=1.0):
self.q_table = [Link]((state_size, action_size))
[Link] = lr
[Link] = gamma
[Link] = epsilon
self.epsilon_decay = 0.995
self.epsilon_min = 0.01
self.action_size = action_size

def choose_action(self, state):

if [Link]() < [Link]:
return [Link](self.action_size)
return [Link](self.q_table[state])

def learn(self, state, action, reward, next_state, done):

current_q = self.q_table[state, action]
if done:
target_q = reward
else:
target_q = reward + [Link] *
[Link](self.q_table[next_state])

self.q_table[state, action] += [Link] * (target_q - current_q)

 if [Link] > self.epsilon_min:
[Link] *= self.epsilon_decay

# Deep Q-Network (DQN)

class DQN([Link]):
def __init__(self, state_size, action_size):
super(DQN, self).__init__()
self.dense1 = [Link](64, activation='relu')
self.dense2 = [Link](64, activation='relu')
self.output_layer = [Link](action_size, activation='linear')

def call(self, state):

x = self.dense1(state)
x = self.dense2(x)
return self.output_layer(x)

# Training loop
env = [Link]('CartPole-v1')
agent = QLearningAgent(
state_size=env.observation_space.n if hasattr(env.observation_space,
'n') else 500,
action_size=env.action_space.n
)

7.3 MLOps & Deployment

# Model saving and loading
import joblib
import pickle

# Scikit-learn model
from [Link] import RandomForestClassifier
model = RandomForestClassifier()
# [Link](X_train, y_train)

# Save
[Link](model, '[Link]')
# or
with open('[Link]', 'wb') as f:
[Link](model, f)

# Load
loaded_model = [Link]('[Link]')

# TensorFlow model
# [Link]('my_model.keras')
# loaded = [Link].load_model('my_model.keras')

# FastAPI for serving

from fastapi import FastAPI
 from pydantic import BaseModel
import uvicorn

app = FastAPI()

class PredictionInput(BaseModel):
features: list

class PredictionOutput(BaseModel):
prediction: int
probability: float

@[Link]("/predict", response_model=PredictionOutput)
async def predict(input_data: PredictionInput):
features = [Link](input_data.features).reshape(1, -1)
prediction = loaded_model.predict(features)[0]
probability = loaded_model.predict_proba(features).max()
return PredictionOutput(prediction=int(prediction),
probability=float(probability))

# Run: uvicorn main:app --reload

# Docker deployment
# Dockerfile:
# FROM python:3.9-slim
# WORKDIR /app
# COPY [Link] .
# RUN pip install -r [Link]
# COPY . .
# CMD ["uvicorn", "main:app", "--host", "[Link]", "--port", "8000"]

7.4 Experiment Tracking dengan MLflow

import mlflow
import [Link]
from sklearn.model_selection import cross_val_score

# Set experiment
mlflow.set_experiment("my_classification_experiment")

# Start run
with mlflow.start_run():
# Log parameters
mlflow.log_param("n_estimators", 100)
mlflow.log_param("max_depth", 10)

# Train model
model = RandomForestClassifier(n_estimators=100, max_depth=10)
# [Link](X_train, y_train)

# Log metrics
 # accuracy = [Link](X_test, y_test)
# mlflow.log_metric("accuracy", accuracy)

# cv_scores = cross_val_score(model, X_train, y_train, cv=5)

# mlflow.log_metric("cv_mean", cv_scores.mean())

# Log model
[Link].log_model(model, "model")

# Log artifacts
# mlflow.log_artifact("feature_importance.png")

# Load model from registry

# model_uri = "runs:/<run_id>/model"
# loaded_model = [Link].load_model(model_uri)

7.5 Latihan Modul 7

Latihan 1: Build dan deploy API untuk image classification
Latihan 2: Implement GAN untuk image generation
Latihan 3: RL agent untuk game environment
Latihan 4: Complete MLOps pipeline dengan CI/CD
MODUL 8: PROYEK CAPSTONE
Estimasi waktu: 4-6 minggu | Tingkat: Advanced

8.1 Proyek Capstone Ideas

Proyek 1: End-to-End ML Pipeline
Build complete pipeline dari data collection hingga deployment untuk real-world problem
(e.g., customer churn prediction, fraud detection).
Proyek 2: Computer Vision Application
Object detection system untuk use case spesifik (e.g., traffic monitoring, medical
imaging, quality control).
Proyek 3: NLP Application
Build chatbot atau sentiment analysis system dengan transformer models dan deploy ke
production.
Proyek 4: Recommendation System
Collaborative filtering dan content-based recommendation dengan evaluation metrics.
Proyek 5: Time Series Forecasting
Stock price prediction atau demand forecasting dengan multiple models comparison.

8.2 Project Structure Template

my_ai_project/
├── data/
│ ├── raw/
│ ├── processed/
│ └── external/
├── notebooks/
│ ├── 01_eda.ipynb
│ ├── 02_preprocessing.ipynb
│ ├── 03_modeling.ipynb
│ └── 04_evaluation.ipynb
├── src/
│ ├── __init__.py
│ ├── data/
│ │ ├── __init__.py
│ │ └── [Link]
│ ├── features/
│ │ ├── __init__.py
│ │ └── [Link]
│ ├── models/
│ │ ├── __init__.py
│ │ ├── [Link]
│ │ └── [Link]
 │ └── utils/
│ └── [Link]
├── api/
│ ├── [Link]
│ └── [Link]
├── tests/
│ └── test_models.py
├── models/
│ └── trained_model.pkl
├── configs/
│ └── [Link]
├── [Link]
├── Dockerfile
├── [Link]
└── [Link]

8.3 Resources & Next Steps

Online Courses
- Coursera: Deep Learning Specialization (Andrew Ng)
- [Link]: Practical Deep Learning for Coders
- Stanford CS231n: Convolutional Neural Networks
- Stanford CS224n: Natural Language Processing
Books
- Hands-On Machine Learning (Aurélien Géron)
- Deep Learning (Ian Goodfellow)
- Pattern Recognition and Machine Learning (Bishop)
Practice Platforms
- Kaggle Competitions
- LeetCode (untuk coding skills)
- Papers With Code
Stay Updated
- [Link] untuk research papers
- Towards Data Science (Medium)
- AI/ML Twitter community
- Hugging Face blog

Selamat Belajar dan Sukses dalam Perjalanan AI Anda!