Jupyter Notebooks and Google Colab

CSI 4106 - Fall 2025

Marcel Turcotte

Version: Sep 5, 2025 10:19

Preamble

Learning objectives

• Write and execute a Jupyter Notebook.
• Execute a Jupyter Notebook on Google Colab.

Requirements

Proficiency in Python is expected.

For those needing a refresher, the official tutorial on Python.org is a good place to start.

Simultaneously enhance your skills by creating a Jupyter Notebook that incorporates examples and notes from the tutorial.

Other resources include:

• Stanford CS231n Python Tutorial with Google Colab
• Advanced Python Tutorial

Stanford CS231n Python Tutorial with Google Colab: This link directs you to a Python tutorial presented in a Jupyter Notebook format, which can be executed within the Google Colab environment. Additional details are provided below.

Finally, here is an Advanced Python Tutorial provided by Google.

Creating a Jupyter Notebook that incorporates examples and notes from the tutorial can be pretty handy. Later, when you want to look up a concept, you can also prototype your solution directly in the notebook.

Jupyter Notebooks

What is a Notebook?

A notebook is a shareable document that combines computer code, plain language descriptions, data, rich visualizations like 3D models, charts, graphs and figures, and interactive controls. A notebook, along with an editor (like JupyterLab), provides a fast interactive environment for prototyping and explaining code, exploring and visualizing data, and sharing ideas with others.

Quick Start

This tutorial is designed for those who may not yet be acquainted with Jupyter Notebook and Google Colab. Both platforms are widely used in machine learning communities for interactive computational work.

Google Colab provides a user-friendly interface for writing and executing notebooks without requiring any local software installation. Notably, it allows you to edit and run your code on various devices, including tablets and mobile phones.

While anyone can view a shared notebook, you will need a Google account to execute it. For most educational purposes, the free version of Google Colab should suffice. However, there are paid options, such as Colab Pro and Pro Plus. These versions offer longer runtimes, priority access to more powerful GPUs and TPUs, increased memory and storage capacities, and fewer interruptions and timeouts.

A notebook seamlessly integrates narrative text with source code and visualizations. As you explore the document, notice how it alternates between explanatory text, code snippets, and graphics.

Your code is executed within an environment known as a kernel. In this tutorial, we are using a Python kernel. Other available kernels include Julia and R. For additional details, you can refer to the Jupyter Kernels documentation.

You may run the entire notebook by selecting Runtime → Run all. However, a more common practice is to execute cells individually. This approach allows you to follow the instructions closely and observe the results of each cell. It also facilitates code experimentation by enabling you to modify code and immediately see the effects of your changes.

All cells within a notebook share a common execution environment, which makes the sequence of cell execution crucial. A cell that depends on variables or functions defined in another cell must be executed subsequently. Therefore, ensure that any necessary libraries are loaded before running dependent cells.

See also: - The Jupyter Notebook

Jupyter Notebooks are widely utilized in the fields of data science and machine learning.

Running Jupyter on your computer

Assuming the notebook is in the current directory, execute the following command from the terminal.

jupyter notebook 01_ottawa_river_temperature.ipynb

Similarly, to create a new notebook from scratch,

jupyter notebook

These commands launch a Jupyter server on your computer, listening on a local port and directing your browser to the specified local URL. The output will be something like this:

Jupyter Server 2.14.2 is running at:
     http://localhost:8888/tree?token=94eca753b1887a460404d2b5eebb3b7a6211be0b839e9c34
     http://127.0.0.1:8888/tree?token=94eca753b1887a460404d2b5eebb3b7a6211be0b839e9c34
Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).

As you can see, executing a notebook locally is similar to running it in Google Colab. However, it requires that Jupyter and all necessary libraries (such as NumPy, pandas, and scikit-learn) be installed on your local system.

In a new notebook:

1. Create an example showing how text and cells alternate.
2. Write an example showing how the order of execution matters.

See also:

• Running the Notebook

The installation process for Jupyter and other environments will be covered later in this presentation.

Why?

• Ease of Use: The interface is intuitive and conducive to exploratory analysis.

• Visualization: The capability to embed rich, interactive visualizations directly within the notebook enhances its utility for data analysis and presentation.

• Reproducibility: Jupyter Notebooks have become the de facto standard in many domains for demonstrating code functionality and ensuring reproducibility.

How?

• Google Colab
• Local installation
  • In your browser
    • Notebook or JupyterLab
  • Visual Studio Code
• More options, including JupyterHub (a multi-user version)

Mastering new technology often requires time and patience. Recognize that your levels of experience may vary. Select the option that best aligns with your current expertise. Begin with simpler choices, knowing that you can revisit and adjust your decisions as you gain proficiency.

For those comfortable with technology, JupyterLab may be the preferable choice. As the next-generation web-based interface for Jupyter projects, it offers an integrated development environment (IDE)-like experience with support for multiple tabs. Conversely, if you prefer a more straightforward starting point, Jupyter Notebook might be a better option.

Installing Jupyter (1/2)

These instructions use pip, the recommended installation tool for Python.

The initial step is to verify that you have a functioning Python installation with pip installed.

• Linux/macOS
• Windows

$ python --version 

Python 3.10.14

$ pip --version

pip 24.2

C:> py --version 

Python 3.10.14

C:> py -m pip --version

pip 24.2

Consult the appendix for other options, including conda, mamba. and pipenv.

Installing Jupyter (2/2)

Installing JupyterLab with pip:

$ pip install jupyterlab

Once installed, run JupyterLab with:

$ jupyter lab

Sample Jupyter Notebooks

• 01_ottawa_river_temperature (Jupyter Notebook)
• 02_empty (Jupyter Notebook)
• 03_missing_library (Jupyter Notebook)
• 04_stock_price (Jupyter Notebook)
• 05_central_limit (Jupyter Notebook)

Missing libraries

Launching 03_missing_library in Colab.

What to do when libraries are missing in Google Colab?

04_stock_price

Launching 04_stock_price in Colab.

05_central_limit

Launching 05_central_limit in Colab.

Lecture Notes

Each lecture is provided as a Jupyter Notebook.

import numpy as np
import matplotlib.pyplot as plt

# Sigmoid function
def sigmoid(t):
    return 1 / (1 + np.exp(-t))

# Generate x values
t = np.linspace(-6, 6, 400)

# Compute y values for the sigmoid function
y = sigmoid(t)

# Create a figure and remove axes and grid
fig, ax = plt.subplots()
ax.plot(t, y, color='black', linewidth=2)  # Keep the curve opaque

plt.grid(True)

# Set transparent background for the figure and axes
fig.patch.set_alpha(0)  # Transparent background for the figure

plt.show()

Throughout the semester, the lectures will incorporate a variety of programming examples. The slides are provided in Jupyter Notebook format, allowing you to interact with the code directly. Since Jupyter Notebooks also support plain text, you can personalize the lecture notes by adding your own annotations.

Lecture Notes

Prologue

Summary

• Introducing the tools, specifically Jupyter Notebooks and Google Colab.

Resources

• Project Jupyter Documentation
• Google Colab
• Colab Primer

References

Appendix: Version Control

Version Control (GitHub)

By default, Jupyter Notebooks store the outputs of code cells, including media objects.

Jupyter Notebooks are JSON documents, and images within them are encoded in PNG base64 format.

This encoding can lead to several issues when using version control systems, such as GitHub.

• Large File Sizes: Jupyter Notebooks can become quite large due to embedded images and outputs, leading to prolonged upload times and potential storage constraints.
• Incompatibility with Text-Based Version Control: GitHub is optimized for text-based files, and the inclusion of binary data, such as images, complicates the process of tracking changes and resolving conflicts. Traditional diff and merge operations are not well-suited for handling these binary formats.

Version Control (GitHub) - solutions

1. In JupyterLab or Notebook, Edit \(\rightarrow\) Clear Outputs of All Cells, then save.
2. On the command line, use jupyter nbconvert --clear-output

jupyter nbconvert --clear-output --inplace 04_stock_price.ipynb

or

jupyter nbconvert 04_stock_price.ipynb --to notebook --ClearOutputPreprocessor.enabled=True --output 04_stock_price_clear

3. Use nbdime, specialized for Jupyter Notebooks.

When copying source code from slides or notebooks, click on the ‘Copy to Clipboard’ icon to ensure that only the plain text is copied, excluding any HTML formatting.

For assignments, we will ask you to keep the outputs.

Appendix: environment management

Environment management

Important

Do not attempt to install these tools unless you are confident in your technical skills. An incorrect installation could waste significant time or even render your environment unusable. There is nothing wrong with using pip or Google Colab for your coursework. You can develop these installation skills later without impacting your grades.

Package management

• Managing package dependencies can be complex.
  • A package manager addresses these challenges.
• Different projects may require different versions of the same libraries.
  • Package management tools, such as conda, facilitate the creation of virtual environments tailored to specific projects.

Anaconda

Anaconda is a comprehensive package management platform for Python and R. It utilizes Conda to manage packages, dependencies, and environments.

• Anaconda is advantageous as it comes pre-installed with over 250 popular packages, providing a robust starting point for users.

• However, this extensive distribution results in a large file size, which can be a drawback.

• Additionally, since Anaconda relies on conda, it also inherits the limitations and issues associated with conda (see subsequent slides).

Miniconda

Miniconda is a minimal version of Anaconda that includes only conda, Python, their dependencies, and a small selection of essential packages.

Conda

Conda is an open-source package and environment management system for Python and R. It facilitates the installation and management of software packages and the creation of isolated virtual environments.

• Dependency conflicts due to complex package interdependencies can force the user reinstall Anaconda/Conda.

• Plague with large storage requirements and performance issues during package resolution.

Mamba

Mamba is a reimplementation of the conda package manager in C++.

• It is significantly faster than conda.
• It consumes fewer computational resources.
• It provides clearer and more informative error messages.
• It is fully compatible with conda, making it a viable replacement.

Micromamba is a fully statically-linked, self-contained executable. Its empty base environment ensures that the base is never corrupted, eliminating the need for reinstallation.

Further your education

• The Missing Semester of Your CS Education

Marcel Turcotte

Marcel.Turcotte@uOttawa.ca

School of Electrical Engineering and Computer Science (EECS)

University of Ottawa