Lab 1 - Introduction - Full Stack Deep Learning

The lab setup centers on building a production-minded deep learning pipeline for a text-recognition app—turning an uploaded page image into a clean transcription—while giving participants a structured codebase to train and evaluate models. The workflow is split into three interacting modules: a web backend receives an image, a compiled prediction model performs inference, and training code produces the model weights used for serving. Inference itself is staged: a line detector first extracts individual text lines from the full image, then a line text recognizer converts each line into text, and the results are returned to the backend for API-ready output.

Before any modeling begins, the course walks through getting access to a managed compute environment using Weights & Biases (W&B). Participants sign up at an app.wandb.ai site, then redeem a token to unlock a Jupyter hub environment. Each user receives access to two GPUs, and the lab notebooks run in a web-based JupyterLab interface already configured for the class. If setup stalls, help is routed through a Slack channel, and the intent is to minimize local laptop friction so learners can focus on understanding and improving the codebase over the following month.

Lab 1 then lays out the architecture and the learning path. The first lab trains a “simple character predictor” rather than tackling full page transcription immediately. The system starts with predicting a single handwritten character from an image, using the EMNIST dataset (an extension of MNIST with 80 classes including digits, uppercase letters, lowercase letters, and a few symbols). Participants inspect dataset statistics and image shapes (700,000 training images of size 28×28) and visualize samples to build intuition about what the model is learning.

A major portion of the session is devoted to how the repository is organized. At the top level, notebooks support data exploration; tasks provide reusable scripts for common commands; training contains the scalable training entry points; and the text recognizer package holds the core logic. Inside that package, datasets manage downloading, preprocessing, augmentation, and loading into TensorFlow (while keeping raw data external to version control). Networks define “dumb” input-output architectures (e.g., an MLP that flattens 28×28 images into vectors and stacks dense layers with softmax, or a CNN-style LeNet-like option using convolutional layers). Models wrap those networks with training functionality—loss functions, optimizers, metrics, weight saving/loading, evaluation, and a fit loop.

The training pipeline is driven by a run-experiment configuration (a JSON/dictionary specifying dataset, model, network, and training arguments). A run experiment script imports the requested dataset and model, downloads data if needed, trains via a model.fit call, and then evaluates on a test set. The session also emphasizes modularity as a bug-prevention strategy: isolating data generation, swapping datasets easily, and avoiding monolithic scripts that duplicate logic across architectures. Participants then begin an actual training run in the Jupyter environment, installing dependencies as needed and watching loss decrease, with encouragement to iterate on hyperparameters and improvements on their own time.