Introducing - Fast AI

With Fast AI we move away from the notion that you first have to study the mathematical parts of deep learning before you can get to building actual models. Basically we use a Top-Down approach, as Jeremy Howard put it, where we start by building models first and then later get to learning the beautiful maths that powers these models.

Unlike trying to learn the maths first before getting to build models, this is a much better approach because it becomes easier and exciting to learn the Maths behind it once you have gotten practice with building actual models. Your own curiosity will push you to try and understand why this works or why something is not working as expected.

In my own experience it has been frustrating to learn the maths and not knowing where I am actually going to apply this. Long weeks of doing calculations without writing any code was a huge demotivator.

What is Fast AI

Fast AI is a library built on top of Pytorch that simplifies the task of training fast and accurate Neural Nets.

This is possible because of Fast AI's extensive API for many deep learning tasks, from data loading, data cleaning, training models and evaluating them, Fast AI offers a high level abstraction to these tasks. This makes training neural nets easier by also reducing the risks of getting errors since we write very minimal code as you will see.

Demo

To show the power of Fast AI, we will build a simple Computer Vision model to classify animal breeds. We will break down these tasks into four:

1. Data Loading

2. Data Cleaning

3. Model Training

4. Evaluation

1. Data Loading

We will first install fastai

!pip install fastai

With Fast AI installed, we will now download our training data - OXFORD-IIIT Pet Dataset. This is already built in to Fast AI

# Import everything for vision
from fastai.vision.all import *

path = untar_data(
    URLs.PETS
) # `untar_data` is a helper function that downloads data and unzips it.

100.00% [811712512/811706944 00:16<00:00]

# untar_data also returns the location of the decompressed archive
path, path.ls()

(Path('/root/.fastai/data/oxford-iiit-pet'),
 [Path('/root/.fastai/data/oxford-iiit-pet/images'), Path('/root/.fastai/data/oxford-iiit-pet/annotations')])

# get_image_files is a function that return all images in a folder
files = get_image_files(
    path/'images'
)
print(f"Found {len(files)} images")

Found 7390 images

Labelling data

To label our data, we will extract the name of the animal from the filename using regular expressions

files[0].name

'beagle_115.jpg'

regex = r'^(.*)_\d+.jpg'

To load our data we will need to use a DataLoaders object. Specifically ImageDataLoaders.from_name_re() - (From Regular Expressions). Fast AI provides different data loaders for different types of data you are working with, but for now since we are working with images, we will use ImageDataLoaders.

dls = ImageDataLoaders.from_name_re(
    path=path,
    fnames=files,
    pat=regex,
    item_tfms=Resize(460),
    batch_tfms=aug_transforms(size=224) # Resize images to 224 X 224, for deep learning all images must be of the same size
)

# Show the loaded data
dls.show_batch()

We have successfully loaded our data!! You can rerun dls.show_batch() to check is there are any incorrect labels

1. Cleaning Data

The next step should be cleaing data right? Well actually not really, for Fast AI we actually train a model first and then we will use Fast AI's cool feature for data cleaning.

3. Model Training

In Fast AI, we train a Leaner. A Learner combines, a model and the data for training and uses transfer learning to fine tune a pretrained model. For this example we will fine tune a resnet34 model.

learn = vision_learner(
    arch=resnet34, # pretrained model
    dls=dls, # data
    metrics=error_rate # measure how worse the model is doing
)

Downloading: "https://download.pytorch.org/models/resnet34-b627a593.pth" to /root/.cache/torch/hub/checkpoints/resnet34-b627a593.pth


100%|██████████| 83.3M/83.3M [00:00<00:00, 165MB/s] 

The above downloaded the resnet34 model which we will fine tune

learn.fine_tune(
    1, # how many times the model will see the data
    3e-3 # rate at which the model adjusts to reduce the error (Learning)
)

We now have a trained model that can classify the animal breeds. Lets get to testing

4. Model Evaluation

Let's see how the model predicts

learn.show_results() # show predictions on images (green if the model was correct, red if it was wrong)

We can also use the interpretation object to see the model's worst responses:

interp = Interpretation.from_learner(learn)

interp.plot_top_losses(9, figsize=(15,10)) # plot the worst predictions

We can finally save the model and use it elsewhere in our applications

learn.export('my_model.pkl')

Further Actions

And we're done training the model, you can use the exported model in your applications or deploy it to Huggingface. Fast AI offers a book and a course Practical Deep Learning for coders. It goes deep into the Fast AI library and also deep learning, giving you all the knowledge you need to train deep learning models. It also introduces Maths concepts when needed. Enjoy!!

This blog was written by a human ♥

But there was always a nagging feeling, an imposter syndrome hovering in the background. I knew how to call the functions, but I didn’t truly understand why they worked. I was building a mental skyscraper on a foundation of sand. When things broke, or when I wanted to move beyond canned tutorials, I hit a wall. I realized something crucial was missing: the deep, intuitive understanding of the mathematics underneath the code.

My ultimate ambition is high: I want to work on cutting-edge AI at a place like Google DeepMind. To get there, "good enough" isn't good enough. I needed to stop, rewind, and build the foundation properly.

The Map: Mathematics for Machine Learning

I decided to tackle the definitive textbook: Mathematics for Machine Learning by Deisenroth, Faisal, and Ong. My goal is to internalize the "grammar" of ML before writing more "paragraphs" of code.

Today, I’m celebrating a significant milestone: I have completed Chapter 2: Linear Algebra. (The book starts counting content at Ch. 2).

This wasn't just about memorizing formulas. It was a journey from computation to intuition:

1. The Mechanics: It started with the nuts and bolts, what is a matrix, how does multiplication work, and solving systems of linear equations using Gaussian elimination.

2. The Structure: Then, we moved into the abstract, vector spaces, subspaces, and bases. Understanding where these mathematical objects live.

3. The Breakthrough (Linear Mappings): This was the most critical shift. I stopped seeing matrices as just static grids of numbers and started seeing them as active transformations, machines that stretch, rotate, and squash vectors from one coordinate system to another.

Understanding that matrix multiplication is essentially a transformation of space is a game-changer for visualizing what neural networks are actually doing.

$$\begin{bmatrix} a & b \\ c & d \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} = x \begin{bmatrix} a \\ c \end{bmatrix} + y \begin{bmatrix} b \\ d \end{bmatrix} = \begin{bmatrix} ax + by \\ cx + dy \end{bmatrix}$$

The Strategy: How I Stay Consistent

Math is hard. Self-studying math is even harder. Relying solely on willpower doesn't work for long-term goals like this. I needed a system.

My routine relies on a few key pillars to keep the momentum going:

• The Pomodoro Technique: I break my study sessions into focused intervals. It prevents burnout and keeps my brain fresh for dense topics like null spaces and affine subspaces.

• Virtual Accountability (James Scholz): Studying alone can be isolating. I sync my sessions with James Scholz’s "Study With Me" streams on YouTube. There is a powerful, unspoken motivation in working alongside thousands of others, even virtually.

• Daily Inspiration (5amoljen): Following accounts like 5amoljen on Instagram provides that necessary jolt of daily discipline. Seeing others wake up early and grind reminds me that the work needs to be done, regardless of how I feel.

What’s Next

Clearing the Linear Algebra chapter feels great, but I’m not rushing to the next topic yet. Knowledge without application fades quickly.

My next step is to dive into the practice problems in the book. I need to prove to myself that I can apply these concepts, calculating ranks, finding kernels, and performing changes of basis, before moving on.

Once I’m confident, I will begin Chapter 3: Analytic Geometry, where we will add lengths, angles, and distances to the vector spaces I just learned about.

The journey to DeepMind is long, and I'm still near the starting line. But for the first time, I feel like I’m running on solid ground.

For this project-based learning session, I decided to build something practical: a backend API to handle image uploads and store them locally.

Here’s the high-level process:

1. User uploads an image and metadata (like title and description) from the frontend via multipart/form-data.

2. The data is sent to an exposed API endpoint.

3. The server parses the request, validates the file, and stores it.

Project Structure

I wanted the codebase to be simple but easy to scale, so I split it into cmd and internal folders:

image-api/
    cmd/
        server/
            server.go
    internal/
        handlers/
            handlers.go
        utils/
            utils.go

• cmd/server/server.go – Entry point. Sets up the HTTP server, defines API endpoints, and handles CORS.

• internal/handlers/handlers.go – Contains handler functions for each API route.

• internal/utils/utils.go – Utility functions (like file type validation).

Setting Up the Server (server.go)

package main

import (
    "image_api/internal/handlers"
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/image-upload", withCORS(handlers.HandleImageUpload))
    http.HandleFunc("/delete", withCORS(handlers.HandleImageDelete))
    http.HandleFunc("/update", withCORS(handlers.HandleImageUpdate))
    http.HandleFunc("/image", withCORS(handlers.HandleImageUpdate))

    log.Println("Listening on port: 8282")
    err := http.ListenAndServe("localhost:8282", nil)
    if err != nil {
        log.Fatal(err)
    }
}

func withCORS(h http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Access-Control-Allow-Origin", "*")
        w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
        h(w, r)
    }
}

The withCORS wrapper ensures requests from different origins don’t fail with CORS errors — essential when connecting your API to a frontend.

Handling Image Uploads (handlers.go)

The heart of the project is the image upload handler:

func HandleImageUpload(w http.ResponseWriter, r *http.Request) {
    // Limit upload size to 10MB
    err := r.ParseMultipartForm(10 << 20)
    if err != nil {
        http.Error(w, "File is too big or invalid format", http.StatusBadRequest)
        return
    }

    // Retrieve the file from form data
    file, handler, err := r.FormFile("file")
    if err != nil {
        http.Error(w, "Could not read file", http.StatusBadRequest)
        return
    }
    defer file.Close()

    // Validate file type
    fileBytes, err := io.ReadAll(file)
    if err != nil {
        http.Error(w, "Invalid file", http.StatusBadRequest)
        return
    }
    if !utils.IsValidFileType(fileBytes) {
        http.Error(w, "Invalid file type", http.StatusUnsupportedMediaType)
        return
    }

    // Get additional form fields
    title := r.FormValue("title")
    description := r.FormValue("description")

    uploadDir := `C:\Users\USER\GolandProjects\image_api\uploads`
    if err := os.MkdirAll(uploadDir, 0755); err != nil {
        http.Error(w, "Could not create upload directory", http.StatusInternalServerError)
        return
    }

    // Save file to disk
    filePath := filepath.Join(uploadDir, handler.Filename)
    dst, err := os.Create(filePath)
    if err != nil {
        http.Error(w, "Could not save file", http.StatusInternalServerError)
        return
    }
    defer dst.Close()
    io.Copy(dst, bytes.NewReader(fileBytes))

    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, "Uploaded: %s\nTitle: %s\nDescription: %s", handler.Filename, title, description)
}

Key points:

• Size limit prevents huge uploads from consuming memory.

• File type validation ensures only images are accepted.

• os.MkdirAll guarantees the upload directory exists.

• Metadata capture allows storing more than just the image.

Utility Functions (utils.go)

func IsValidFileType(file []byte) bool {
    fileType := http.DetectContentType(file)
    return strings.HasPrefix(fileType, "image/")
}

This small function makes sure the uploaded file really is an image — no disguised .exe files slipping in.

Running the API

1. Clone or create the project.

2. Run:

    go run ./cmd/server
   

3. Send a request via Postman or a frontend form with:

   • File field: file

   • Metadata fields: title, description

With this small project, I not only learned about Go’s net/http package but also got comfortable with handling multipart/form-data, file validation, and CORS.
It’s a solid first step toward building more complex APIs in Go.

Key takeaways that resonated with me:

💡 Community & Collaboration

One of the standout moments was connecting with incredible minds in tech, including several professionals I've long admired. A powerful reminder came from a keynote speaker: "If you want to go fast, work alone; but if you want to go far, work with a team." This perfectly captures the essence of what I learned about the tech community's collaborative spirit.

🔍 Building Developer Relations

We delved into strategic approaches for fostering developer relationships, focusing on three critical pillars:

• Identifying clear goals

• Understanding your target audience

• Measuring impact and iterating based on successes and failures

🤖 AI Beyond Chatbots

The AI breakout sessions were particularly enlightening. It was refreshing to explore AI applications beyond the typical chatbot use cases, discovering innovative solutions to real-world challenges. This session expanded my perspective on AI's potential impact across various sectors.

🎯 Moving Forward

This experience has ignited a dual mission: developing my technical skills while contributing to our campus tech community's growth. While I feel challenged by the road ahead, I'm incredibly motivated by the possibilities.

As I look toward DevFest 2025, I'm excited to measure my growth and continue this journey in tech. A huge thank you to the organizers and everyone who made this event unforgettable!