Jupyter Notebooks

Learning Objectives

• Install and launch JupyterLab, Jupyter Notebook, or VS Code with the Jupyter extension
• Use magic commands (%timeit, %%time, %matplotlib inline) to benchmark and visualize inline
• Distinguish when to use notebooks vs scripts and apply the "explore in notebooks, ship in scripts" workflow
• Identify and avoid common notebook traps: out-of-order execution, hidden state, and memory leaks

The Problem

Every AI paper, tutorial, and Kaggle competition uses Jupyter notebooks. They let you run code in pieces, see outputs inline, mix code with explanations, and iterate fast. If you try to learn AI without notebooks, you're doing math homework without scratch paper.

But notebooks have real traps. People use them for everything, including things they're terrible at. Knowing when to use a notebook and when to use a script will save you from debugging nightmares later.

The Concept

A notebook is a list of cells. Each cell is either code or text.

The kernel is a Python process running in the background. When you run a cell, it sends the code to the kernel, which executes it and sends back the result. All cells share the same kernel, so variables persist between cells.

That "whatever order you click" part is both the superpower and the foot-gun.

s0-cell-order

Build It

Step 1: Pick your interface

Three options, one format:

All three read and write the same .ipynb file. Pick whatever you like. JupyterLab is the most common in AI work.

pip install jupyterlab
jupyter lab

Step 2: Keyboard shortcuts that matter

You operate in two modes. Press Escape for command mode (blue bar on the left), Enter for edit mode (green bar).

Command mode (most used):

Edit mode:

Shift+Enter is the one you'll use a thousand times a day. Learn it first.

Step 3: Cell types

Code cells run Python and show the output:

import numpy as np
data = np.random.randn(1000)
data.mean(), data.std()

Output: (0.0032, 0.9987)

Markdown cells render formatted text. Use them to document what you're doing and why. Supports headers, bold, italic, LaTeX math ($E = mc^2$), tables, and images.

Step 4: Magic commands

These aren't Python. They're Jupyter-specific commands that start with % (line magic) or %% (cell magic).

Time your code:

%timeit np.random.randn(10000)

Output: 45.2 us +/- 1.3 us per loop

%%time
model.fit(X_train, y_train, epochs=10)

Output: Wall time: 2.34 s

%timeit runs the code many times and averages. %%time runs it once. Use %timeit for microbenchmarks, %%time for training runs.

Enable inline plots:

%matplotlib inline

Every plt.plot() or plt.show() now renders directly in the notebook.

Install packages without leaving the notebook:

!pip install scikit-learn

The ! prefix runs any shell command.

Check environment variables:

%env CUDA_VISIBLE_DEVICES

Step 5: Display rich output inline

Notebooks auto-display the last expression in a cell. But you can control it:

import pandas as pd

df = pd.DataFrame({
    "model": ["Linear", "Random Forest", "Neural Net"],
    "accuracy": [0.72, 0.89, 0.94],
    "training_time": [0.1, 2.3, 45.6]
})
df

This renders a formatted HTML table, not a text dump. Same with plots:

import matplotlib.pyplot as plt

plt.figure(figsize=(8, 4))
plt.plot([1, 2, 3, 4], [1, 4, 2, 3])
plt.title("Inline Plot")
plt.show()

The plot appears right below the cell. This is why notebooks dominate AI work. You see the data, the plot, and the code together.

For images:

from IPython.display import Image, display
display(Image(filename="architecture.png"))

Step 6: Google Colab

Colab is a free Jupyter notebook in the cloud. It gives you a GPU, pre-installed libraries, and Google Drive integration. No setup required.

1. Go to colab.research.google.com
2. Upload any .ipynb file from this course
3. Runtime > Change runtime type > T4 GPU (free)

Colab differences from local Jupyter:

• Files don't persist between sessions (save to Drive or download)
• Pre-installed: numpy, pandas, matplotlib, torch, tensorflow, sklearn
• from google.colab import files to upload/download files
• from google.colab import drive; drive.mount('/content/drive') for persistent storage
• Sessions time out after 90 minutes of inactivity (free tier)

Use It

Notebooks vs Scripts: When to use which

The rule: explore in notebooks, ship in scripts.

A common workflow in AI:

1. Explore data in a notebook
2. Prototype your model in the notebook
3. Once it works, move the code to .py files
4. Import those .py files back into the notebook for further experiments

Common traps

Out-of-order execution. You run cell 5, then cell 2, then cell 7. The notebook works on your machine but breaks when someone runs it top to bottom. Fix: Kernel > Restart & Run All before sharing.

Hidden state. You delete a cell but the variable it created is still in memory. The notebook looks clean but depends on a ghost cell. Fix: Restart the kernel regularly.

Memory leaks. Loading a 4GB dataset, training a model, loading another dataset. Nothing gets freed. Fix: del variable_name and gc.collect(), or restart the kernel.

Ship It

This lesson produces:

• outputs/prompt-notebook-helper.md for debugging notebook issues

Exercises

1. Open JupyterLab, create a notebook, and use %timeit to compare list comprehension vs numpy for creating an array of 100,000 random numbers
2. Create a notebook with both markdown and code cells that loads a CSV, displays a dataframe, and plots a chart. Then run Kernel > Restart & Run All to verify it works top to bottom
3. Take the code from code/notebook_tips.py, paste it into a Colab notebook, and run it with a free GPU

Hints

Exercise 1. Start JupyterLab with jupyter lab, then put each version in its own cell that begins with %timeit. Use the same 100,000 size in both cells so that the two times measure the same work.

Exercise 2. Use pd.read_csv for the data, show the dataframe as the last line of a cell, and plot with df.plot() or matplotlib. After Kernel > Restart & Run All, every cell must show a number in its execution counter and no cell may show an error.

Exercise 3. In Colab, select Runtime > Change runtime type > GPU before you paste the code. The run is correct when each function in code/notebook_tips.py prints its section, and torch.cuda.is_available() returns True in a cell.

Key Terms

Further Reading

• JupyterLab Docs for the full feature set
• Google Colab FAQ for Colab-specific limits and features
• 28 Jupyter Notebook Tips for power-user shortcuts