Google Colab — Module 3.3

Module 3.3 Capstone — Putting It All Together

This is the final lecture in AI & Data Libraries. You have learned NumPy for arrays, Pandas for tables, Matplotlib for visualization, Scikit-learn for classical ML, PyTorch and TensorFlow for deep learning, and Jupyter for interactive workflows.

Google Colab combines all of that in a zero-setup cloud notebook with optional GPU/TPU runtime—the fastest way to go from idea to trained model when you lack local hardware or want effortless sharing.

Learning Objectives

By the end of this capstone lesson, students should be able to:

Create, configure, and share Colab notebooks.
Select GPU/TPU runtimes and monitor resource limits.
Mount Google Drive and load datasets into a notebook workflow.
Install packages and integrate Colab with GitHub.
Run an end-to-end ML experiment using libraries from this module.
Articulate when Colab fits versus local Jupyter, Kaggle, or cloud VMs.

What Google Colab Is—and When to Use It

Google Colab (Colaboratory) is a free hosted Jupyter notebook environment running on Google’s infrastructure. It requires only a Google account and a browser—no local Python installation needed.

Use Google Colab when…	Use alternatives when…
You need a free GPU for coursework or prototyping	You need persistent servers or custom networking → cloud VM
You want one-click sharing with collaborators	Enterprise data cannot leave your VPC → private JupyterHub
You are teaching or demoing without setup friction	Long multi-day training jobs need dedicated hardware
You store data and models in Google Drive	You need production CI/CD → scripts + container pipelines

Creating Your First Notebook

Visit colab.research.google.com
File → New notebook
Runtime → Change runtime type → GPU (for deep-learning workloads)
Verify the accelerator in a code cell

import sys, platform
print("Python:", sys.version)
print("Platform:", platform.platform())

import torch
print("CUDA available:", torch.cuda.is_available())
if torch.cuda.is_available():
    print("GPU:", torch.cuda.get_device_name(0))

Colab Limits

Free-tier GPU sessions are time-limited and may be preempted. Save checkpoints to Drive frequently. Do not treat Colab as a production training cluster—it is an exploration and education platform.

Mounting Google Drive

Persist datasets, model weights, and notebook outputs beyond the ephemeral runtime.

from google.colab import drive
drive.mount("/content/drive")

import pandas as pd
DATA_PATH = "/content/drive/MyDrive/ai_projects/churn.csv"
df = pd.read_csv(DATA_PATH)
df.shape

Installing Packages

Colab ships with many scientific packages preinstalled, but you can pip-install anything per session.

!pip install -q transformers datasets accelerate

import transformers
print(transformers.__version__)

Capstone Project — End-to-End Churn Classifier

This workflow stitches together every library in Module 3.3. Adapt it to your own dataset.

Step 1: Load and Explore (Pandas + Matplotlib)

import matplotlib.pyplot as plt

print(df.isna().sum())
df["churned"].value_counts().plot(kind="bar", title="Class balance")
plt.show()

Step 2: Baseline Model (Scikit-learn)

from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

features = ["tenure_months", "monthly_spend", "support_tickets"]
X, y = df[features], df["churned"]
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)

baseline = Pipeline([
    ("scaler", StandardScaler()),
    ("clf", RandomForestClassifier(n_estimators=200, random_state=42)),
])
baseline.fit(X_train, y_train)
print(classification_report(y_test, baseline.predict(X_test)))

Step 3: Neural Baseline (PyTorch on GPU)

import torch
import torch.nn as nn
import numpy as np

device = "cuda" if torch.cuda.is_available() else "cpu"
X_np = StandardScaler().fit_transform(X_train).astype(np.float32)
y_np = y_train.to_numpy()

X_t = torch.tensor(X_np, device=device)
y_t = torch.tensor(y_np, device=device)

class ChurnMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(3, 32), nn.ReLU(),
            nn.Linear(32, 1), nn.Sigmoid(),
        )
    def forward(self, x):
        return self.net(x).squeeze(1)

model = ChurnMLP().to(device)
opt = torch.optim.Adam(model.parameters(), lr=1e-3)
loss_fn = nn.BCELoss()

for epoch in range(50):
    model.train()
    pred = model(X_t)
    loss = loss_fn(pred, y_t.float())
    opt.zero_grad(); loss.backward(); opt.step()
print(f"Final training loss: {loss.item():.4f}")

Step 4: Save Artifacts to Drive

import joblib

OUT = "/content/drive/MyDrive/ai_projects/artifacts/"
joblib.dump(baseline, OUT + "churn_baseline.joblib")
torch.save(model.state_dict(), OUT + "churn_mlp.pt")
print("Artifacts saved.")

Capstone Deliverable

Submit a Colab notebook (shared link or .ipynb export) containing: data profile, at least two plots, sklearn baseline with metrics, optional PyTorch experiment, and saved artifacts. Write a short markdown cell comparing which approach you would ship and why.

GitHub Integration

Clone repositories directly into the runtime for reproducible projects.

!git clone https://github.com/your-org/your-ml-project.git
%cd your-ml-project
!pip install -r requirements.txt

Colab vs Local Jupyter

Colab Advantages

Zero local setup; free GPU access
Easy link-based collaboration
Integrated with Google Drive
Ideal for teaching and quick experiments

Local Jupyter Advantages

Full control over environment and versions
No session timeouts or preemption
Better for proprietary data governance
Smoother path to production tooling (Docker, CI)

Common Misconception: “Colab notebooks are production code.”

Reality: Colab is for exploration. Extract tested functions into Python modules, pin dependencies, and deploy via containers or cloud jobs. Module 3.4 covers the Python engineering skills—virtual environments, APIs, error handling—that turn notebook prototypes into reliable systems.

Quick Knowledge Check

Short Answer: How do you enable GPU in Colab? Answer: Runtime → Change runtime type → select GPU.
True/False: Colab runtimes persist indefinitely after you close the browser. Answer: False—sessions are ephemeral.
Short Answer: Why mount Google Drive? Answer: Persist data and model artifacts beyond the runtime.
Multiple Choice: First model to try on tabular churn data: (a) random deep net, (b) sklearn baseline, (c) LLM fine-tune. Answer: (b).
Short Answer: What module comes next in the curriculum? Answer: Module 3.4 — Essential Python Skills for AI Engineers.
True/False: !pip install in Colab persists across all future sessions automatically. Answer: False — reinstall when runtime restarts unless saved in environment spec.
Short Answer: Which Module 3.3 library handles tabular EDA? Answer: Pandas.
Multiple Choice: Best place to save trained model weights in Colab: (a) /tmp only, (b) mounted Drive path, (c) browser cache, (d) RAM. Answer: (b).
True/False: Colab notebooks are identical to local Jupyter in environment control. Answer: False — Colab is managed and session-limited.
Short Answer: Name two capstone steps from this lecture’s churn project. Answer: Any two of: EDA/plots, sklearn baseline, PyTorch GPU model, save artifacts.

Key Takeaways

Google Colab is a hosted Jupyter environment with free GPU—ideal for learning and prototyping.
Mount Drive, save checkpoints, and respect session limits.
The capstone workflow combines Pandas EDA, sklearn baselines, PyTorch experiments, and Matplotlib diagnostics.
Notebooks explore; production code lives in tested modules and pipelines.
Continue to Module 3.4: Essential Python Skills for AI Engineers to harden your engineering practice.

Trainer’s Guide

Capstone rubric: Grade on reproducibility (Run All passes), data hygiene, appropriate metric choice, at least one visualization, and a written recommendation for production. Bonus: student compares sklearn vs PyTorch runtime and accuracy on the same split.

Discussion prompt: What would you change before deploying this churn model to a bank’s production API?

Module Complete You have finished Module 3.3. Proceed to Module 3.4 for virtual environments, REST APIs, async I/O, and the Python patterns that separate notebook experiments from production AI systems.