🐾 Fast.ai Course Lesson 2: Deploying Cat vs Dog Classifier to Hugging Face Spaces in the Summer of 2025

If you’re working through the Fast.ai course in the summer of 2025 — this is for you.

In this post, I’ll walk you through how I deployed my trained Cats vs Dogs image classifier to Hugging Face Spaces using Gradio. This is Lesson 2 of the course.

It took some version wrangling, YAML tweaking, and a few broken builds to get there — but the final result is finally live.

👉 For the core learning steps, follow Lesson 2 here

Below is what’s changed in the 3 years and what will not work if you just follow the video / notebook from 2023.

✅ What worked for me in 2025:

🧠 I trained the model in Colab

Downloaded the .pkl file and uploaded it to my Hugging Face repo manually. Git wouldn’t let me push over 10MB.

🧪 My app.py (Gradio interface)

from fastai.vision.all import *
import gradio as gr
import cloudpickle

learn = load_learner('model.pkl')
categories = ('Cat', 'Dog')

def classify_image(img):
    pred, idx, probs = learn.predict(img)
    return {categories[i]: float(probs[i]) for i in range(len(categories))}

image = gr.Image(type="pil", label="Upload an image of a cat or dog")
label = gr.Label(num_top_classes=2, label="Prediction")

app = gr.Interface(fn=classify_image, inputs=image, outputs=label, title="Cat vs Dog Classifier")
app.launch(inline=False)

🧾 My requirements.txt

fastai==2.8.2
gradio==4.24.0
fasttransform
cloudpickle

⚙️ My README.md config block

---
title: Dogs Cats
emoji: 🐾
colorFrom: pink
colorTo: blue
sdk: gradio
python_version: 3.11
sdk_version: 5.38.2
app_file: app.py
pinned: false
license: apache-2.0
short_description: a dog or a cat?
---

This configuration block defines your runtime environment. python_version: 3.11 is important — older versions from 2023 may not match what your dependencies expect in 2025.

If you’re stuck or hitting weird bugs, feel free to fork my repo or reach out.

🐶😸 Good luck!

Reach out on X: @alexvasyuk
ChatGPT wrote this post.

Prompt: Assume you are on the Home and Lighting team for the USA market, how would you go about improving our category page?

Step 1 — Context

CANDIDATE: I want to make sure I’m on the same page with you. You are talking about the main page for the category “Home and Lighting” for US users on Amazon’s Desktop, Mobile Web, and iOS & Android clients. The people who visit this page are ordinary Amazon users from different walks of life looking to find the best deal on the internet for the items they are looking for. They use the category page to begin their search for items they want to buy.

Step 2 — Personas

CANDIDATE: Great, let’s start by breaking up the user base into multiple personas. I can imagine the following groups to frequent the category page:

• Homeowners: age 30–45; first time homeowners; low-mid budget range; busy professional; time sensitive; multitasking. Purpose — want to find best-value quality items at the cheapest price point; want a one stop-shop for all their home & lighting needs as they are busy professionals with no time to shop around. Picking out lights and other items probably feels like a chore technology should solve for them.
• Contractors: age 25–40; price insensitive; busy on multiple projects — too many details to keep in mind. Have incentive to either a) purchase the most convenient option, even if it’s more expensive — they aren’t paying. b) purchase from a merchant they receive commission from — personal financial gain.
• Interior designers: age 30–50; work within client budgets, busy on multiple projects — too many details to keep in mind. Have incentive to work with merchants who pay they commission per customer.

From the three, I’d recommend focusing on the first time home owners as they probably make up the majority of the users visiting the category page.

Step 3 — User needs

CANDIDATE: I briefly mentioned some key needs of first-time home owners, let me outline a few in more detail:

• As the first time home owner I want a one stop shop for all my home & lightning needs so I can quickly buy validated things for my house. I don’t have time to research and validate many options myself. I want to rely on social proof and research of others to get recommendations on what I should buy.
• As the first time home owner I want to get the best price, yet not spend excessive time searching for it. The majority of my budget has been spent on the downpayment, but I don’t want to sacrifice quality of my lighting, etc.
• As the first time home owner I want to make sure I install what I purchase a) correctly b) without devoting too much time to figuring out how to do it, because I’m short on time and don’t have the budget to make a mistake and have to purchase the item again.

Step 4 — Prioritize user needs

CANDIDATE: To prioritize what to tackle first I choose and estimate the key parameters that affect the decision. For this problem I chose revenue impact and effort as the two key parameters. In the future we could also factor in impact on customer satisfaction.

The winner among the three needs for first-time homeowners is the need to afford quality items. Let’s see what we can do about it.

Step 5 — Brainstorm solutions

CANDIDATE: There are multiple ways to make something more affordable, one of the most straightforward ones is to sell it at a discount. But often times it is neither feasible nor economically rational. Lets brainstorm alternative ways to make items more affordable.

Idea 1: Advertise the option to pay in installments on the “Home and Lighting” category page. Since the category page is where the majority of the users land, advertising this new financial instrument should increase sales among users who can’t afford the item at a lump sum.

Idea 2: Advertise “group” buying on the “Home and Lighting” category page, whereby when enough people commit to purchasing by a certain deadline, the item is sold at a reduced price to each person. Users can offer such deals to sellers on Amazon as a reversal to when the seller needs to figure out the threshold for the minimal number of people and the discounted price.

Idea 3: Often the decision to purchase is the result of many potential purchases competing for the same budget. Highlight on the “Home and Lighting” category page the scarcity of the recommended items or groups of items. For example if there’s a world shortage of microchips, highlight the scarcity of home appliances that use them.

Step 6 — Evaluate trade-offs

CANDIDATE: To evaluate tradeoffs between potential solutions I usually define a few relevant criteria within the context of the problem. Here I think it’s important to consider: honesty, revenue potential, and ease of implementation.

Since we are dealing with financial instruments it is paramount to consider how honest the users will perceive them to be in the context of other platforms they user and market norms in general.

Installments need to be communicated as tools devoid of hidden fees and other “gotcha” fine print moments. The customer needs to know exactly how installments are scheduled and paid out, and what the consequences are for failure to pay.

Group buying is relatively straightforward, it’s just a simple abstraction over the checkout process which is delayed in time. It is important to communicate clearly that the purchase will not happen if the minimal number of customers isn’t met. Failure to do so will generate disgruntled customers and negatively affect brand perception.

Scarcity highlights can be perceived to be the most dishonest as it is easily faked. Additionally people can leave the platform agitated having negative thoughts, because they either couldn’t afford the increase in price or they could, but overpaid for what was once cheaper.

Step 7 — Make a recommendation

CANDIDATE: To summarize I recommend that we improve the “Home & Lighting” category page by introducing the ability to pay with installments, which should solve a critical problem of affording more quality items for our core audience — first time home owners — and be useful to other user segments who can benefit from splitting up the price into more manageable chunks.

Although there are substantial risks in a) execution (e.g debt collection is not our expertise) b) brand perception if this financial instrument is deemed dishonest, the business will benefit, because we will have introduced a new revenue stream which if successful can be easily scaled to other categories.

Reviewing the answer

Few things people suggested to pay attention to:

• In the “Context” step, clarify what the goal for the improvement is. Is it to drive revenue or improve customer experience? Ideally attach a metric to the goal and center the conversation around it. By doing so you are starting with a goal that can be measured (success metric) and when you end your discussion, you can circle back and point out that your proposed solution drives this success metric the best.
• Think a bit deeper when defining personas and imagine how their CJM differs from the average one. Things like buying in bulk and getting alternative offers when you go over budget seem very logical and intuitive.
• I thought I could shortcut on prioritizing which customer segment to focus on, by assuming and stating that they are the majority. But this stands out as shallow. Think of a few criteria and use them to prioritize which customer segment to choose from. Examples: which customer segment aligns best with company’s strategic vision; which customer segment generates the most revenue; which customer segment is growing very rapidly across the market. Perhaps I’m missing some key ones here, would love to hear from you!
• Validating your solutions is an important sub-step of evaluating tradeoffs. Best done by demonstrating a good grasp on some real world numbers + conversions and being able to apply them to the specific case you are working on.

A trie is a tree. It’s an n-ary tree, designed for efficient retrieval. How efficient is efficient? A trie allows us to search for a string in O(m), where m is the number of characters in that string. Do other data structures perform better? Perhaps, here is an argument in favor of Hashtables:

Trie vs Hash Table Deathmatch!

Anyhow — tries. In a trie one can retrieve anything one can prefix and the most common example is to retrieve strings. One can treat individual characters as prefixes to a string. If we are to imagine a tree like structure with nodes having characters for keys, we will see that a path from the root to a leaf constitutes a string. We will also see that if two string were to share first character, their paths will share that one node and branch off into different directions afterwards. If one was so inclined, she could have a value at every leaf, which is admissible, however most of the nodes will just have a key, as they serve as prefixes.

Note the root is an empty string denotes as “.” and \0 or null signals that the node completes a string.

Operations

What can a trie do and what can one for on a trie? Three simple operations are as follows:

1. add
2. search
3. remove

Data structure representation

Implementation

The add method has two while loops. The first looks for an appropriate place to insert an element and the second iterates through the remaining characters of the string, filling out the trie.

The search method returns the depth of the given key or -1 if it does not find any.

If the string in question is present in the trie, the remove method recurses down to the node that represents the last character of the string and removes nodes associated with the characters in the string only if they have no sub nodes dependent on them.

Filters:

Only interested in traffic associated with font resources? — use a filter — font filter.

The ‘Filter’ search box, top-left corner, allows for advanced filters. Ex: type in “Domain”.

Don’t neglect the statistics:

Wondering what the difference between DOMContentLoaded and Load events is? Me too.

From the Mozilla Developer Center:

The DOMContentLoaded event is fired when the document has been completely loaded and parsed, without waiting for stylesheets, images, and subframes to finish loading (the load event can be used to detect a fully-loaded page).

Okay, so I choose an actual item resource — I get a few panes: headers, response, preview, cookies, timing. These are self explanatory.

Back in the default view I see default columns: method, status, type… right click on any one — I get more options: cookies, domain.

Right click on a resource itself — get copy options.

By the way — initiator column. It tells me how a resource came to be. Style — link tag. JS — probably a script tag. It can also give a stack of calls that initiated the resource.

Reference: TutsPlus “Chrome developer tools”

Why — accelerate debugging

The console panel gives the ability to inject javascript into the context of the current page.

Console API:

console.error — gives us a stack of the function calls that lead up to the error

console.group(n) & console.groupEnd (n)— group logging messages

%c — inside the log message allows us to apply limited css properties to the message

console.time(name) & console.timeEnd(name) — everything executed in-between these two calls is timed, then the time is logged as “name: time”

Command API:

$0 — returns currently selected element

$_ — returns the value of the last evaluated piece of code

Handy trick: to get autocomplete on a jquery selection — make the selection, then use $_ to get the last value — press “.” and autocomplete is available. This works because the code has already been evaluated.

getEventListeners(x) — returns a list of event listeners registered on the DOM node ‘x’ we passed in. For instance x could be document.body. Right click— ‘show function definition’ will take you to the defining function. Good for debugging outside in.

keys/values(o) — returns keys/value of the object o

monitorEvents(object, eventName) — ex: monitorEvents(window, ‘scroll’) logs scroll events to the console. Good for debugging outside in.

Object API:

Object.observe: to pause in the debugger every time a property is set on an object we care about we can do this:

Object.defineProperty — find out every time a property on the object in question is being accessed.

Reference: Tutsplus course “Chrome developer tools”

*The formulation of the question comes from 28 questions by Arden Dertat
Given a linked list of integers and an integer, delete every node of the linked list containing the value.

Input: linked list of integers and an integer value
Output: same linked list without the nodes containing the integer value
Constraints: in linear time

Step 1: Questions

Q: Is the linked list doubly or singly linked?
A: Doubly

Step 2: Design an algorithm

The mechanics of the algorithm are simple. Keep track of the parent of the current node. If the current node is to be removed, set parent’s next to current’s next and current next’s parent to the parent. However there are a couple corner cases that need to be addressed.

1. The head node is to be removed. — The function return value ought to be the head node.
2. There are duplicate elements, in which case you only advance the current node

Step 3: Pseudocode

The Node class will have pointers to the next and parent nodes and an integer variable to hold the data;

private Node parent;
private Node next;
private Node data;

Since the member variables are private the class defines public getters and setters:

public Node getParent() {..}
public Node getNext() {..}
public void setParent() {..}
public void setNext() {..}
public Integer getData() {..}

We should not be able to create an empty node, so the constructor will take an int as its argument and assign it to the data variable.

public Node(int d) {data = d}

The DoublyLinkedList class has pointers to its head and its tail.

private Node head;
private Node tail;

Again the member variable are private, so we define getters/setters as we did previously. The append method takes an integer argument, create a new node and appends it to tail. Here we need to remember that if the head is null, the tail should also be null and if the append is called both head and tail are set to the same node.

append(int d) {
 if head is null, set head and tail to a new node(d)
 else set tail's next to a new node(d), set the new node's parent to tail and advance the tail
}

We do not define a constructor for this class, so one with no arguments is defined for us by default.

The remove method will return the head of the linked list just in case the head is the node to be removed. Other than that the mechanism of deletion is specified in step 2. Here is the pseudocode:

Node remove(int d) {
id head == null: return null
while head isn't null and head's data matches d: advance head and set new head's parent to null
while there are still nodes to be traversed:
 if current node's data matches d: set parent's next to
 current's next and current's next's parent to parent, advance
 current only
 else advance both parent and current
return head

Step 4: Code

The entire code is below:

To test this code run something like:

evaluate(infixToBinaryTree(“3+4*2/(1-(3+4*2/1–5))”))

This should return 1.4

This is a rewrite of my original article as I realized the problem was more complicated than I initially thought.

Parse and evaluate “(1+2)*3” expression.

This is a two step process. First I decided to tackle the problem without worrying about parentheses. Turns out that there is an algorithm named “Shunting-yard algorithm” that parses mathematical expressions specified in infix notation (normal human readable notation, in which the two expressions above are specified). Follow the Wikipedia link above to read about the algorithm.

However this procedure will return the output queue in the Reverse Polish Notation(RPN), so the output will look like this: “1 2 3 * +” What I want is to build a binary tree in the form:

 + 
1 * 
 2 3 

To convert my output into binary tree form, it is informative to read about how RPN is parsed. Based on that knowledge I came up with my own version of the algorithm that creates a binary tree which if traversed post-order will produce the correct result of a mathematical expression. Note that I replaced the output queue with an output stack.

First I defined some auxiliary classes and methods. Stack class is really just a wrapper for an array, with an additional peek method. Operator is a parent to fours of its subclasses: Plus, Minus, Multiply, Divide, which each define how they are applied two two arguments arg1 and arg2. createOperator is a factory method for the Operator class.

The main part of the application is the infixToBinary function. In its core it is a for loop that parses the string (one bug I quickly discovered was that numbers can have more than one digit):

and the logic of the algorithm:

If a token is a number it is pushed onto the outputStack, where it waits to be converted into a node of the resulting binary tree by either one of two functions: createSubtree() or updateTree(). Essentially my modification consists of placing subtrees onto the output stack for the updateTree() to pick up when in the final while loop it assembles the entire binary tree. Note that for this version of the algorithm intermediate subtrees are computed if the next operator on the stack is less than or equal to the current one, not just less than. A quick example :“3 — 5 +2". The correct answer to this is 0, but if you only choose to create intermediate subtrees for operators less than the current one, then you will end up with -4, because the algorithm will create a tree looking like this:

 -
3 +
 5 2 

I learned it the hard way.

The createSubtree function creates intermediate subtrees that are then placed on the output stack:

The updateTree walks through the stack creating the final tree:

To test the tree use this evaluation function

Read Part 2

Objective:

Write a function that will recursively merge two objects with the following conditions:
1.) If a[field] is an array, and b[field] is defined and is not an array, add b[field] to the array
2.) If a[field] is an array an b[field] exists but is undefined or null, set a[field] to an empty array
3.) If a[filed] is an array and b[field] is an array, set a[field] to b[field]
4.) If a[field] exists and b[field] exists but is undefined, delete a[field]
5.) If b[field] is a non-complex type (number, string, boolean, et cetera), copy to a[field]

This is my attempt:

A couple valuable things I came across while doing this problem:
1. == vs === The difference lies in type conversion to compare to values. === does not do type conversion, whereas == does.

2. The correct way to check if a variable is undefined is

typeof nameOfVariable === "undefined"

This ensures that even if ‘nameOfVariable’ is not defined, the condition still returns true.

3. I needed to write deepCompare(a, result) to check my answer:

The reason I have the second for loop is because ‘b’ can have fields that ‘a’ doesn’t and vice versa.

Given an array of positive integers and a second array, which was formed by shuffling the elements of the first array and deleting one, find the missing element.

1. Sum all elements in 1st array and in 2nd array. The difference of two sums will be your missing number. As Arden points out, with large number this approach wont work because of overflow.
2. Sort both arrays and scan both at the same time. Once you hit two elements that differ, the one in the first array is the missing element-> O(nlogn) and requires no duplicate elements
3. Create a counter hashmap. Scan the second array counting how many times each element appears, then scan the first one, subtracting from appropriate values in the hash. When you hit a zero -> missing element. Although this is O(N) in time, it is also O(N) in space.
4. XOR all elements in first and second array, you will be left with the missing element. XORing the number with itself gives 0, plus what is very important is the order of the xor operation does not make a difference, meaning n1 ^ n2 ^ n3 ^n2 ^n3 = n1. This approach is O(n) time and O(1) space.