Master Generative AI — Part 1: Foundation of AI & Machine Learning¶

# Traditional programming
def classify_email(email):
    if "FREE" in email and "CLICK HERE" in email:
        return "spam"
    return "not spam"

# Machine learning
# (the model learns these rules from 10,000 labeled examples)
model = train(emails, labels)
prediction = model.predict(new_email)

# Example: Supervised learning with scikit-learn
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Features: [size_sqm, bedrooms, distance_to_center]
X = [[85, 2, 3.2], [120, 3, 1.5], [45, 1, 8.0], [200, 4, 0.5]]
y = [4500000, 8000000, 2000000, 15000000]  # prices in THB

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model = RandomForestClassifier()
model.fit(X_train, y_train)
predictions = model.predict(X_test)

# Example: K-means clustering
from sklearn.cluster import KMeans
import numpy as np

# Customer data: [monthly_spend, purchase_frequency]
customers = np.array([
    [500, 2], [600, 3], [5000, 15], [4800, 12],
    [200, 1], [100, 1], [5200, 18], [300, 2]
])

kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(customers)
print(kmeans.labels_)  # [0, 0, 1, 1, 2, 2, 1, 0] → 3 customer segments found

import numpy as np

def neuron(inputs, weights, bias, activation="relu"):
    z = np.dot(inputs, weights) + bias  # linear combination
    if activation == "relu":
        return max(0, z)                # ReLU: max(0, z)
    elif activation == "sigmoid":
        return 1 / (1 + np.exp(-z))    # sigmoid: 0 to 1
    elif activation == "tanh":
        return np.tanh(z)              # tanh: -1 to 1
    return z

import torch
import torch.nn as nn

# A simple 3-layer neural network
class SimpleNet(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.layer1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(hidden_size, hidden_size)
        self.layer3 = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x = self.relu(self.layer1(x))  # input → hidden
        x = self.relu(self.layer2(x))  # hidden → hidden
        x = self.layer3(x)             # hidden → output
        return x

# Instantiate
model = SimpleNet(input_size=10, hidden_size=64, output_size=3)
print(model)
# Count parameters
total_params = sum(p.numel() for p in model.parameters())
print(f"Total parameters: {total_params:,}")  # 4,419

# Mean Squared Error (regression)
def mse_loss(predictions, targets):
    return ((predictions - targets) ** 2).mean()

# Cross-Entropy (classification)
def cross_entropy_loss(logits, targets):
    return nn.CrossEntropyLoss()(logits, targets)

import torch
import torch.nn as nn
import torch.optim as optim

# Dummy data: 100 samples, 10 features, 3 classes
X = torch.randn(100, 10)
y = torch.randint(0, 3, (100,))

model = SimpleNet(10, 64, 3)
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()

# Training loop
for epoch in range(50):
    # 1. Forward pass
    predictions = model(X)

    # 2. Compute loss
    loss = criterion(predictions, y)

    # 3. Backward pass (compute gradients)
    optimizer.zero_grad()   # clear old gradients
    loss.backward()         # compute new gradients

    # 4. Update weights
    optimizer.step()

    if epoch % 10 == 0:
        print(f"Epoch {epoch}: Loss = {loss.item():.4f}")

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("gpt2")
text = "Generative AI is transforming the world!"
tokens = tokenizer.encode(text)
print(tokens)
# [8645, 876, 3068, 318, 28287, 262, 995, 0]
# 8 tokens for 40 characters (~5 chars/token on average)

import torch
import torch.nn.functional as F

# Cross-entropy loss for a 3-class problem
logits = torch.tensor([[2.0, 1.0, 0.5]])  # model outputs (unnormalized)
target = torch.tensor([0])                 # correct class is 0

loss = F.cross_entropy(logits, target)
print(f"Loss: {loss.item():.4f}")  # lower is better

def accuracy(predictions, targets):
    correct = (predictions.argmax(dim=1) == targets).sum().item()
    return correct / len(targets)

# Watch out: 99% accuracy sounds great...
# But if 99% of your data is "not fraud", a model that predicts
# "not fraud" for everything gets 99% accuracy with zero utility

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

def calculate_perplexity(model, tokenizer, text: str) -> float:
    inputs = tokenizer(text, return_tensors="pt")
    input_ids = inputs.input_ids

    with torch.no_grad():
        outputs = model(**inputs, labels=input_ids)
        loss = outputs.loss  # cross-entropy per token

    return math.exp(loss.item())

# In a Colab notebook, most packages are pre-installed
# Check what GPU you have:
!nvidia-smi

# Install what's missing
!pip install -q transformers datasets accelerate

# Mount Google Drive to save model checkpoints
from google.colab import drive
drive.mount('/content/drive')

from transformers import pipeline

# Text generation
generator = pipeline("text-generation", model="gpt2")
result = generator("Generative AI is", max_new_tokens=50)
print(result[0]["generated_text"])

# Sentiment analysis
classifier = pipeline("sentiment-analysis")
result = classifier("This course is absolutely fantastic!")
print(result)  # [{'label': 'POSITIVE', 'score': 0.9998}]

# Text summarization
summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
text = """Generative AI models have revolutionized how we interact with computers.
          These models can produce text, images, audio, and video that are
          increasingly indistinguishable from human-created content..."""
summary = summarizer(text, max_length=50, min_length=20)
print(summary[0]["summary_text"])

# Translation
translator = pipeline("translation_en_to_fr")
result = translator("Hello, I am learning Generative AI!")
print(result[0]["translation_text"])  # "Bonjour, j'apprends l'IA générative !"

# health_check.py
import sys
print(f"Python: {sys.version}")

import torch
print(f"PyTorch: {torch.__version__}")
print(f"CUDA available: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"GPU: {torch.cuda.get_device_name(0)}")
    print(f"VRAM: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")

import transformers
print(f"Transformers: {transformers.__version__}")

from transformers import pipeline
pipe = pipeline("sentiment-analysis")
result = pipe("I love learning AI!")
print(f"Test inference: {result}")  # should print POSITIVE

print("\n✓ Environment ready for Generative AI!")