Machine Learning
Linear regression, classification, clustering—implement core algorithms with scikit‑learn and understand the math behind them.
02 — MACHINE LEARNING BASICS
Linear Regression with scikit‑learn
Linear regression predicts a continuous target variable. Here’s a minimal example using the Boston housing dataset (or synthetic data).
# Linear regression with scikit-learn
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
# Generate synthetic data
np.random.seed(42)
X = np.random.rand(100, 1) * 10
y = 2.5 * X.squeeze() + np.random.randn(100) * 2
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(f"RMSE: {mean_squared_error(y_test, y_pred, squared=False):.2f}")
03 — NEURAL NETWORKS WITH KERAS
Feedforward Network for Classification
Build a simple neural network to classify handwritten digits (MNIST).
# Feedforward network on MNIST
import tensorflow as tf
from tensorflow import keras
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0 # normalize
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x_train, y_train, epochs=5)
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test accuracy: {test_acc:.4f}")
04 — NATURAL LANGUAGE PROCESSING
Sentiment Analysis with NLTK
Use NLTK's VADER lexicon for simple sentiment analysis.
# Sentiment analysis with NLTK
import nltk
from nltk.sentiment import SentimentIntensityAnalyzer
nltk.download('vader_lexicon')
analyzer = SentimentIntensityAnalyzer()
texts = [
"I love this product! It's amazing.",
"This is the worst experience ever.",
"It's okay, nothing special."
]
for text in texts:
scores = analyzer.polarity_scores(text)
print(f"Text: {text}\nSentiment: {scores}\n")
05 — COMPUTER VISION WITH OPENCV
Face Detection using Haar Cascades
Detect faces in an image with OpenCV's pre‑trained classifier.
# Face detection with OpenCV
import cv2
# Load the cascade
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
# Read image
img = cv2.imread('friends.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Detect faces
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)
for (x, y, w, h) in faces:
cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2)
cv2.imshow('Detected Faces', img)
cv2.waitKey(0)
06 — REINFORCEMENT LEARNING
Q‑Learning for a Simple Environment
Reinforcement learning trains an agent by rewarding desired behaviors. Here’s a classic Q‑learning example on the FrozenLake environment (OpenAI Gym).
# Q-learning on FrozenLake
import gymnasium as gym
import numpy as np
env = gym.make("FrozenLake-v1", is_slippery=False)
Q = np.zeros([env.observation_space.n, env.action_space.n])
alpha = 0.8 # learning rate
gamma = 0.95 # discount factor
episodes = 5000
for i in range(episodes):
state, _ = env.reset()
done = False
while not done:
action = np.argmax(Q[state, :] + np.random.randn(1, env.action_space.n) * (1.0/(i+1)))
new_state, reward, done, _, _ = env.step(action)
Q[state, action] = Q[state, action] + alpha * (reward + gamma * np.max(Q[new_state, :]) - Q[state, action])
state = new_state
print("Trained Q-table:")
print(Q)
07 — GENERATIVE AI: TEXT GENERATION
Using Transformers for Text Generation
With the Hugging Face transformers library, you can load a pre‑trained GPT‑2 model and generate text.
# Text generation with GPT-2
from transformers import pipeline
generator = pipeline('text-generation', model='gpt2')
prompt = "Once upon a time, a young programmer"
result = generator(prompt, max_length=50, num_return_sequences=1)
print(result[0]['generated_text'])
08 — RETRIEVAL‑AUGMENTED GENERATION (RAG)
Simple RAG Pipeline with LangChain
RAG combines retrieval of relevant documents with a generative model to answer questions. Below is a minimal example using LangChain (conceptual).
# RAG pipeline (simplified)
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
# Assume documents are loaded and split
vectorstore = FAISS.from_documents(documents, OpenAIEmbeddings())
retriever = vectorstore.as_retriever()
qa_chain = RetrievalQA.from_chain_type(llm=OpenAI(), retriever=retriever)
query = "What is the capital of France?"
answer = qa_chain.run(query)
print(answer)
09 — FINE‑TUNING A PRE‑TRAINED MODEL
Fine‑tuning BERT for Sentiment Analysis
Fine‑tune a transformer model on a custom dataset using Hugging Face Trainer.
# Fine-tune BERT for sentiment
from transformers import BertForSequenceClassification, Trainer, TrainingArguments
from datasets import load_dataset
dataset = load_dataset('imdb')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')
training_args = TrainingArguments(output_dir='./results', num_train_epochs=3)
trainer = Trainer(model=model, args=training_args, train_dataset=dataset['train'])
trainer.train()
10 — TIME SERIES FORECASTING WITH LSTM
Predicting Stock Prices using LSTM
Long Short‑Term Memory networks are great for sequential data like time series.
# LSTM for time series (simplified)
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
# Generate dummy data
data = np.sin(np.linspace(0, 100, 1000))
X, y = [], []
for i in range(10, len(data)):
X.append(data[i-10:i])
y.append(data[i])
X, y = np.array(X), np.array(y)
X = X.reshape((X.shape[0], X.shape[1], 1))
model = Sequential()
model.add(LSTM(50, activation='relu', input_shape=(10, 1)))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')
model.fit(X, y, epochs=10, verbose=0)
11 — MODEL DEPLOYMENT WITH FASTAPI
Serving a Scikit‑learn Model via REST API
FastAPI is a modern web framework for building APIs. Below is an example of serving a trained classifier.
# app.py – deploy model with FastAPI
from fastapi import FastAPI
from pydantic import BaseModel
import joblib
import numpy as np
app = FastAPI()
model = joblib.load('model.pkl')
class InputData(BaseModel):
features: list
@app.post("/predict")
def predict(data: InputData):
X = np.array(data.features).reshape(1, -1)
prediction = model.predict(X)
return {"prediction": prediction.tolist()}
12 — BUILDING A CHATBOT WITH TRANSFORMERS
Simple Conversational Agent
Using the transformers library, we can create a chatbot with a conversational pipeline.
# Chatbot using Hugging Face conversational pipeline
from transformers import pipeline
chatbot = pipeline("conversational", model="microsoft/DialoGPT-medium")
user_input = "Hello, how are you?"
response = chatbot(user_input)
print(response)
13 — ANOMALY DETECTION WITH AUTOENCODERS
Detecting Outliers Using Reconstruction Error
Autoencoders learn to reconstruct normal data; anomalies yield high reconstruction error.
# Autoencoder for anomaly detection
import numpy as np
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Dense
# Normal data (e.g., 1000 samples, 10 features)
normal_data = np.random.randn(1000, 10)
input_layer = Input(shape=(10,))
encoded = Dense(5, activation='relu')(input_layer)
decoded = Dense(10, activation='linear')(encoded)
autoencoder = Model(input_layer, decoded)
autoencoder.compile(optimizer='adam', loss='mse')
autoencoder.fit(normal_data, normal_data, epochs=20, verbose=0)
# New sample (could be anomaly)
sample = np.random.randn(1, 10) * 5 # large deviation
reconstructed = autoencoder.predict(sample)
error = np.mean((sample - reconstructed)**2)
print(f"Reconstruction error: {error:.4f}")
14 — AI ETHICS AND BIAS
Considerations for Responsible AI
Building AI systems comes with responsibility. Key considerations include:
• Bias and fairness: Evaluate your data and model for demographic biases using tools like AI Fairness 360.
• Explainability: Use SHAP or LIME to interpret model predictions.
• Privacy: Ensure data anonymization and compliance with regulations (GDPR).
• Robustness: Test against adversarial examples and distribution shifts.
• Transparency: Document model limitations and intended use.
Integrate these practices early to build trustworthy AI.
15 — BEST PRACTICES IN AI DEVELOPMENT
Writing Maintainable AI Code
• Use virtual environments and requirements.txt
• Version control your data and experiments (DVC, Git‑LFS)
• Document data preprocessing steps
• Split data into train/validation/test sets
• Monitor for data leakage
• Log experiments with MLflow or TensorBoard
• Write unit tests for data transformations
• Use type hints for clarity
• Optimize with vectorization (NumPy) and GPU when possible
• Keep models simple before scaling complexity