To be able to participate in workshops during the course, students will need to install Anaconda and set up an environment for running AGQ Jupyter notebooks. Below are some instructions on how to get started. Please attempt to do this before the first workshop on 16 January. If you’re having trouble, we’ll help you out during that workshop.

Installing Anaconda

First you need to install Anaconda on your laptop.

The installation is slightly different for Windows, Mac, and Linux. Whichever system you use, make sure to select “Add Anaconda3 to my PATH environment variable” (if given the option).

Windows: here’s an excellent video explaining the installation of Anaconda and use of environments. Please download Git and Git Bash as well, as explained in the video. (At around minute 11:45, VS Code pops up — it’s not required for this course, might be helpful; see below). Caution: there is a bug with some managed Windows laptops at our universities. Before installing Anaconda, make a new folder “C:\Anaconda” directly in your C drive, and during the installation, choose this folder as the install location. A handful of other problems seem to be popping up — we can help at the workshops or by email.

Mac: somewhat simpler, here’s a Mac version of the same video. (You can ignore VS Code at minute 7:15.)

Linux: no video; we assume you know what you’re doing.

Import an Anaconda environment

The environment file for the start of this course is found here:

https://github.com/tdimofte/AGQ-computing-2026/blob/main/Week0/agq-env.yaml

An “environment” is a workspace on your computer, containing particular versions of the programs and packages used to run code. In our case, the agq-env environment contains python and a few particular python modules that we’ll call upon.

You’ll need to import the agq-env environment into Anaconda in order to use it. There are two ways. We recommend using the command line (e.g. Git Bash on Windows or Terminal on Mac) and running

conda env create -f agq-env.yaml

The first time you do this, the “create” command will install Python too, since it’s required by the agq-env environment. (See the videos above for more info.) Also, here’s a cheat sheet with further Anaconda commands.

The other way to import the agq-env environment is using the visual Anaconda Navigator (instructions here). Totally fine to do it this way, but it’s better to start getting used to the command line.

Jupyter notebooks: web browser and VS Code

Most of the coding we’ll do will happen in Jupyter notebooks. For beginners, the easiest way to run a notebook is from a web browser. Follow these steps to launch your first notebook:

1. Download the notebook file TestPlayBookAGQ.ipynb notebook file to a directory on your computer.
2. Open a terminal (e.g. Git Bash on Windows) and navigate to the that directory. (See minute 3:20 in the tutorial here if you’re confused about the command line.)
3. Run conda activate agq-env to enter the agq-env environment.
4. Run jupyter notebook to launch a notebook server in your default web browser. 
5. Now navigate the directory in your web browser. Click on the TestPlayBookAGQ.ipynb notebook to open it.
6. Run the entire notebook by clicking on the menu Cell -> Run All.
7. (When finished, run conda deactivate to exit the environment in your terminal.)

Running the notebook should at the very bottom display the line:   `AGQ Tests Passed!`

If you see a bunch of red text then something has gone wrong and you may need to reach out to an expert for help. We can help you out at the first workshop.

An alternative to running Jupyter notebooks in a web browser is to edit and run them in VS Code. VS Code is a powerful and versatile code editor that works across Windows/Mac/Linux platforms. However, its great variety features may actually be confusing to beginners. If you’d like to try VS Code, download it and follow its Jupyter video tutorial.

Familiarity with Jupyter Notebooks

We will use Jupyter notebooks throughout the entire course, for machine learning, topological data analysis, and scientific computing. There are loads of guides for beginners online (you can search and find your favorite). If it’s your first time, we recommend taking a look at the Cells and Keyboard Shortcuts sections of  Dataquest’s intro to Jupyter-Notebooks. See also the Geeks4Geeks tutorial, this basic Jupyter/Python tutorial on GitHub, and Anaconda’s intro to Jupyter Notebooks.

Familiarity with Python3

If you’ve never used Python before (and even if you have), we recommend downloading, opening, and playing around with the following two notebooks:

data-science-tools.ipynb

minimization_problems.ipynb

Looking at, and modifying, the examples here should help get you up to speed. Some other Python tutorials include those from python.land, python-course.eu, and Microsoft.

The first half of the course this year will combine a rapid, practical review of Python programming skills and an introduction to neural networks — a rapidly developing research area with multiple connections (as well as applications) to mathematics and the physical sciences, as well as great broader importance in society.

This first lecture and workshop will go through the fundamentals of how Deep Neural Networks are constructed. We will work through an example of building and fitting a simple DNN in NumPy and training it on some input data.

After doing this, we will introduce the PyTorch framework and show how it can be used to create models to perform the same task but much quicker.

The workshop will finish with describing, building and training a DNN classifier using the PyTorch framework.

Slides

https://github.com/tdimofte/AGQ-computing-2026/blob/main/Week1/AGQ-Lecture1.pdf

https://github.com/tdimofte/AGQ-computing-2026/blob/main/Week1/Tudor-math-comments.pdf

Workshop & Homework notebook

https://github.com/tdimofte/AGQ-computing-2026/blob/main/Week1/DNN-Simplified-Questions.ipynb

Homework is due by 9:30am on Friday 30 January, along with a few problems from Week 2.

This week will review some coding basics, focusing in particular on smart and efficient use of data structures in Python.

Lecture slides

https://github.com/tdimofte/AGQ-computing-2026/blob/main/Week2/AGQ_Python-Lecture2.pdf

Workshop & Homework notebook

https://github.com/tdimofte/AGQ-computing-2026/blob/main/Week2/Python-Questions.ipynb

Note: the first homework set is due on Friday 30 January, by 9:30am (the start of class). Instructions for submitting homework are on the class Discord.

This lecture will start with some basics of image analysis (filters, sampling), and how they motivate the architecture of CNN’s: convolutional neural networks. We’ll then discuss autoencoders, neural networks that learn features in data without explicit user input, by using bottlenecks. We consider the differences between traditional and variational autoencoders (VAE’s).

Lecture slides

https://github.com/tdimofte/AGQ-computing-2026/blob/main/Week3/AGQ-Lecture3.pdf

Workshop & Homework notebook

https://github.com/tdimofte/AGQ-computing-2026/blob/main/Week3/CNN_VAE_Questions.ipynb

You’ll also need a few additional image files in the repository at

https://github.com/tdimofte/AGQ-computing-2026/tree/main/Week3

where you can also find a pretrained VAE for (optional) use in the latter parts of the assignment.

This notebook will be the second Homework for the course, due on GitHub by 9:30am on Friday 13 February.

This week we’ll take a look at generating data (in our examples, images) by using adversarial networks, with multiple parts (generators and discriminators) trained in alternating cycles. We’ll start with standard GAN’s and then discuss the generalization to conditional GAN’s, or cGAN’s, where data is accompanied by additional labels.

Lecture slides:

https://github.com/tdimofte/AGQ-computing-2026/blob/main/Week4/AGQ-Lecture4.pdf

Worshop notebook (parts 1-5 are due on GitHub as part of Homework 3, by 9:30am on 27 February):

https://github.com/tdimofte/AGQ-computing-2026/blob/main/Week4/cGAN_Questions.ipynb

Original cGAN paper:

https://arxiv.org/abs/1411.1784

This lecture is about attention and transformers: key building blocks of most modern neural networks (including, but not limited to, large language models) that help them detect relationships among different parts of the data they process.

If you’re encountering attention for the first time, please take a look at the following sequence of short videos by 3Blue1Brown before the class:
     Deep Learning Chapter 5, Chapter 6, Chapter 7

Training a transformer takes a notoriously large amount of “compute.” In order to train efficiently during the workshop, we’ll recommend using Google Colab

https://colab.research.google.com/

You need a Google account to use Colab. Once you sign in, you can create and edit Jupyter notebooks, and access a large library of shared ones. The notebooks are run remotely on Google’s hardware: either CPU’s, GPU’s, or TPU’s, as selected by the runtime option. You have limited access to GPU’s and TPU’s without a paid subscription, so be careful not to connect to them for long periods unintentionally.

Lecture slides:

https://github.com/tdimofte/AGQ-computing-2026/blob/main/Week5/AGQ-Lecture5.pdf

Workshop notebook:

https://github.com/tdimofte/AGQ-computing-2026/blob/main/Week5/Attention_Questions.ipynb

Problems 1-4 are due by 9:30am on Friday 27 February, as the second half of Homework 3.

This lecture will introduce the basic methods of topological data analysis (TDA). We’ll start with a quick review of simplicial complexes (as they appear combinatorially in the TDA world), and then introduce the Vietoris-Rips complex, persistent homology, and the “barcode theorem” underlying its structure. The lecture slides are here.

The workshop involves computations and visualizations for some simple datasets, using GUDHI. Workshop files are here:

https://github.com/tdimofte/AGQ-computing-2026/tree/main/Week6

(Make sure to download the two python files in the helper_functions/ subdirectory as well.)

The problems on the workshop notebook form the majority of Homework 4; they are due on your githubs by 9:30am on Friday, 20 March.

(Bonus topic, slightly outside the main data/ML themes of the course.)

MIT students’ missing semester lectures, including command line and git

https://missing.csail.mit.edu/

A classic neural network textbook, a decade old but still insightful:

http://neuralnetworksanddeeplearning.com

Andrej Karpathy’s course:

https://karpathy.ai/zero-to-hero.html

Neural networks on 3Blue1Brown:

https://www.3blue1brown.com/topics/neural-networks