Which cheese are we eating?

Machine Learning

Computer Vision

Python

Did you ever wonder what kind of cheese you should buy? They all look the same. And then the embarrasement when you can just point and say: that one. Meet the cheese classifier.

Author

Dominik Lindner

Published

March 13, 2025

1 Let’s start with the why

I love cheese. Sometimes it is quite difficult to distinguish the varieties. Think about the embarrasement when you are in front of a mountain of cheese and can only point with your finger.

Therefore, I decided to built a ML classifier to help me.

The special difficulty here is that cheeses all look quite similar. Take, for example, the swiss Gruyere and the French Comte.

They are twins.

2 Let’s continue with with the data.

First, we need some data. Fast.ai provides an easy download module to download images from DuckDuckGo.

As an alternative, we could use a dataset, if we have one. Let’s start by downloading the files and then create a dataset.

2.1 Getting data from DuckDuckGo

Let’s start by defining what we want to download. We want cheese. In particular, French cheese.

cheeses = [
    "Camembert",
    "Roquefort",
    "Comté",
    "Époisses de Bourgogne",
    "Tomme de Savoie",
    "Bleu d’Auvergne",
    "Brie de Meaux",
    "Mimolette",
    "Munster",
    "Livarot",
    "Pont-l’Évêque",
    "Reblochon",
    "Chabichou du Poitou",
    "Valençay",
    "Pélardon",
    "Fourme d’Ambert",
    "Selles-sur-Cher",
    "Cantal",
    "Neufchâtel",
    "Banon",
    "Gruyere"
]

To have a larger variety of images we define some extra search terms.

search_terms = [
    "cheese close-up texture",
    "cheese macro shot",
    "cheese cut section"
]

As we work with Fast.ai , let’s import the basic stuff.

from duckduckgo_search import DDGS
from fastcore.all import *
from fastai.vision.all import *
def search_images(keywords, max_images=20): return L(DDGS().images(keywords, max_results=max_images)).itemgot('image')
import time, json

And then define our download function:

from fastdownload import download_url
from pathlib import Path
import time

data_acquisition=False

def download():
    # Loop through all combinations of cheeses and search terms
    for cheese in cheeses:
        dest = Path("which_cheese") / cheese  # Create subdirectory for each cheese
        dest.mkdir(exist_ok=True, parents=True)

        for term in search_terms:
            query = f"{cheese} {term}"
            download_images(dest, urls=search_images(f"{query} photo"))
            time.sleep(5)

        # Resize images after downloading
        resize_images(dest, max_size=400, dest=dest)

# Run download only if data acquisition is enabled
if data_acquisition:
    download()

We can verify the images now or later.

if data_acquisition:
    failed = verify_images(get_image_files(path))
    failed.map(Path.unlink)
    len(failed)
    failed

2.2 Loading data from a Kaggle dataset

I created a dataset of these images to avoid having to download again when I start over.

Sadly to uncertain copyright issues of this data, my dataset needs to remain private. But you can easily create your own.

As I run most of my code locally, I have some code to get it from Kaggle

competition_name= None
dataset_name = 'cheese'

import os
from pathlib import Path

iskaggle = os.environ.get('KAGGLE_KERNEL_RUN_TYPE', '')
if competition_name:
    if iskaggle: 
        comp_path = Path('../input/'+ competition_name)
    else:
        comp_path = Path(competition_name)
        if not path.exists():
            import zipfile,kaggle
            kaggle.api.competition_download_cli(str(comp_path))
            zipfile.ZipFile(f'{comp_path}.zip').extractall(comp_path)


if dataset_name:
    if iskaggle:
        path = Path(f'../input/{dataset_name}')
    else:
        path = Path(dataset_name)
        if not path.exists():
            import zipfile, kaggle
            kaggle.api.dataset_download_cli(dataset_name, path='.')
            zipfile.ZipFile(f'{dataset_name}.zip').extractall(path)

Now we have downloaded the data, we can start using it.

3 Cleaning the data with the help of our first model

Before we dive into different options for modelling, we will do a quick pass through the data and see which images are bad.

The background is that the scrapper picks up many images, which are not good for training.

We start by creating a working copy of the dataset.

!mkdir -p working/which_cheese_first 
!cp -r cheese/which_cheese  working/which_cheese_first

To be sure that all images are valid, we check again for corrupeted files and remove them.

from pathlib import Path
from PIL import Image

data_path = Path("working/which_cheese_first")

# Check all images
corrupt_files = []
for img_path in data_path.rglob("*.*"):  # Match all files inside subfolders
    try:
        with Image.open(img_path) as img:
            img.verify()  # Verify if it's a valid image
    except (IOError, SyntaxError):
        corrupt_files.append(img_path)

# Remove corrupt images
print(f"Found {len(corrupt_files)} corrupt images.")
for corrupt in corrupt_files:
    print(f"Deleting {corrupt}")
    corrupt.unlink()  # Delete the file

Found 48 corrupt images.
Deleting working/which_cheese_first/which_cheese/Roquefort/350d3e67-dcf6-4292-b963-c1d5841b8788.jpg
Deleting working/which_cheese_first/which_cheese/Roquefort/594d40b1-f655-4db1-b3a9-4e7d6bb6c631.jpg
Deleting working/which_cheese_first/which_cheese/Roquefort/32a9069e-52c2-47e1-9db4-16197556c4fb.jpg
Deleting working/which_cheese_first/which_cheese/Roquefort/c73fb213-3813-43fd-b5ae-2d390ca8e3d5.jpg
Deleting working/which_cheese_first/which_cheese/Roquefort/2c426320-24bd-4869-8f1c-d09171ac6294.jpg
Deleting working/which_cheese_first/which_cheese/Roquefort/83a95414-4083-48d7-9956-be5d82b05caf.jpg
Deleting working/which_cheese_first/which_cheese/Roquefort/f4f09c62-652b-400c-8e09-419389635fc4.jpg
Deleting working/which_cheese_first/which_cheese/Roquefort/dfa07f3c-0931-49aa-b3c2-9c4a5901565d.jpg
Deleting working/which_cheese_first/which_cheese/Roquefort/609abf59-c1f0-4a34-b2cf-1bedf1b4cea0.jpg
Deleting working/which_cheese_first/which_cheese/Roquefort/b56ab8cc-5b37-40c9-be31-57d14c843978.jpg
Deleting working/which_cheese_first/which_cheese/Roquefort/422aec71-31d9-421e-880c-91867eaa5dfb.jpg
Deleting working/which_cheese_first/which_cheese/Roquefort/5591880b-37f4-4bcc-9927-8f60b6d6bb37.jpg
Deleting working/which_cheese_first/which_cheese/Roquefort/a9e2a7ad-038e-4b6d-8dee-19fd1661ebe1.jpg
Deleting working/which_cheese_first/which_cheese/Roquefort/4a572868-b982-47ed-b96e-3eb1a755e32a.jpg
Deleting working/which_cheese_first/which_cheese/Camembert/8903d049-4256-4fe5-9716-48e5fc8ef52b.jpg
Deleting working/which_cheese_first/which_cheese/Camembert/849c9bb0-b717-40a7-922e-091e22e36579.jpg
Deleting working/which_cheese_first/which_cheese/Camembert/4582e06a-0218-4b6b-aeaf-7e7d61dd3827.jpg
Deleting working/which_cheese_first/which_cheese/Camembert/bf950a7d-6ab2-4dd3-81dc-5ec14b9964dc.jpg
Deleting working/which_cheese_first/which_cheese/Camembert/052b599d-f560-473c-947c-74bb3c138167.jpg
Deleting working/which_cheese_first/which_cheese/Camembert/ccf3f8e7-aa87-426d-bea2-a1f18a89be05.jpg
Deleting working/which_cheese_first/which_cheese/Manchego/f7de39d9-0ff2-4a99-aa92-807b27fa7d90.jpg
Deleting working/which_cheese_first/which_cheese/Manchego/0352de9a-3f83-4ce7-bfbe-207da04840a3.jpg
Deleting working/which_cheese_first/which_cheese/Manchego/0592b012-96e5-4f22-ac2e-acc8ab41ecc4.jpg
Deleting working/which_cheese_first/which_cheese/Fourme d’Ambert/0e36dc86-5e2a-4635-afcc-e3e0ec972aee.jpg
Deleting working/which_cheese_first/which_cheese/Neufchâtel/d827858f-aac0-49f4-b397-facadcfb70fb.jpg
Deleting working/which_cheese_first/which_cheese/Neufchâtel/bed8cf04-9305-4f00-9a8a-1b869e00701c.jpg
Deleting working/which_cheese_first/which_cheese/Neufchâtel/8963c142-9a63-43dc-8268-f54a1b6fbb2b.jpg
Deleting working/which_cheese_first/which_cheese/Neufchâtel/bbf224a3-5033-49c0-8b0c-92068e50382f.jpg
Deleting working/which_cheese_first/which_cheese/Neufchâtel/19d6e4f5-0393-455c-b2d4-7ecccfd93431.jpg
Deleting working/which_cheese_first/which_cheese/Neufchâtel/6ad1c9d8-1f29-4da8-ae7d-78915460cf35.jpg
Deleting working/which_cheese_first/which_cheese/Selles-sur-Cher/93d14546-21bf-46e5-89de-e336b474baf3.jpg
Deleting working/which_cheese_first/which_cheese/Mimolette/17abeba3-b113-4c84-90ed-b17b6152c71d.jpg
Deleting working/which_cheese_first/which_cheese/Mimolette/72f3db51-da86-4934-bad7-c1b5e54cfb46.jpg
Deleting working/which_cheese_first/which_cheese/Mimolette/16f74a99-f1ef-46fd-a809-8f332ad235b7.jpg
Deleting working/which_cheese_first/which_cheese/Époisses de Bourgogne/9484a03b-af27-4155-a950-bc07187f00f0.jpg
Deleting working/which_cheese_first/which_cheese/Livarot/ffe3e263-a49b-41bc-bdba-4b66cdc12475.jpg
Deleting working/which_cheese_first/which_cheese/Livarot/57e84bd7-8936-4d55-8ec4-cfcc1073b9a4.jpg
Deleting working/which_cheese_first/which_cheese/Gruyere/9316e837-a0b2-468a-a287-69ee27b840ba.jpg
Deleting working/which_cheese_first/which_cheese/Gruyere/dcc3320a-408c-4b93-a1b6-bf2f3f25aa15.jpg
Deleting working/which_cheese_first/which_cheese/Gruyere/3d5755ba-b8b3-4636-8213-54a3bf19613d.jpg
Deleting working/which_cheese_first/which_cheese/Comté/5b92cce2-46d4-46f8-9f0f-7952076ded0a.jpg
Deleting working/which_cheese_first/which_cheese/Reblochon/3ff8d8f8-09c4-4f83-85b8-9c089fcd6805.jpg
Deleting working/which_cheese_first/which_cheese/Pélardon/a0e86302-8ca3-47ab-ab4c-bdf4834ca208.jpg
Deleting working/which_cheese_first/which_cheese/Pélardon/6370f787-f13e-4acf-aefb-ad67f68d32c2.jpg
Deleting working/which_cheese_first/which_cheese/Pont-l’Évêque/4efc1ad3-575d-4a32-9063-e403fd57d7c9.jpg
Deleting working/which_cheese_first/which_cheese/Tomme de Savoie/5e23fd21-574a-47a0-bc9b-ca52984ae9a5.jpg
Deleting working/which_cheese_first/which_cheese/Tomme de Savoie/5cf2571c-74f7-4a5b-9374-ef4c480267df.jpg
Deleting working/which_cheese_first/which_cheese/Valençay/a45d3613-5dbc-45b5-85c0-2ead70ccf221.jpg

3.1 Model definition

We will define a simple model and check if the data is loaded correctly. The most simple model for image classification is resnet18.

from fastcore.all import *
from fastai.vision.all import *

cheese = DataBlock(
    blocks=(ImageBlock, CategoryBlock), 
    get_items=get_image_files, 
    splitter=RandomSplitter(valid_pct=0.2, seed=42),
    get_y=parent_label,
    item_tfms=[Resize(192, method='squish')]
)

dls = cheese.dataloaders("working/which_cheese_first")

dls.show_batch()

For the metrics, I chose accuracy as this is the most easy to analyze. We later see that the dataset becomes slightly imbalanced in training and F1-score would be better.

learn = vision_learner(dls, resnet18, metrics=accuracy)

We then do a quick learning pass.

learn.fine_tune(3)

epoch	train_loss	valid_loss	accuracy	time
0	4.307302	2.287525	0.356164	00:02

epoch	train_loss	valid_loss	accuracy	time
0	2.265255	1.649305	0.547945	00:03
1	1.552460	1.265489	0.662100	00:03
2	1.129812	1.213783	0.666667	00:03

As we can see, accuracy increased to 66% after 3 epochs.

4 Data Cleaning

We can have a look at the confusion matrix. There are some cheeses that are easily confused with each other. For example Bleu d’Auvergne with Fourme d’Ambert. In fact, in cheese stores outside France, few people seem to know the second one. But also the hard cheeses, Cantal, Comte, and Gruyere. The last two are two standard mountain cheeses, one from France and the other from Switzerland. The only differ by their texture. Comte of the same age are a little creamier and have fewer crevices. I especially added the Gruyere to make the dataset harder.

interp = ClassificationInterpretation.from_learner(learn)
interp.plot_confusion_matrix()

Let’s have a look at the top losses.

interp.plot_top_losses(10)

4.1 All the same?

As expected, similar cheese from the same group is difficult to distinguish.

Let’s do some data cleaning.

For the Comte, Gruyere, Munster: pictures with the highest loss are those with little detail or other accessories like bread or knifes.

from fastai.vision.widgets import *

files_to_clean=[]

cleaner = ImageClassifierCleaner(learn)
cleaner

4.2 IMPORTANT: How to use the cleaner

For each category and train & valid sets, select the images and then run the following cell. It seems the cleaner doesn’t remember the selections in other categories.

We can also not run the above cell multiple times after we cleaned some files, as those will be missing. Instead, we go through all categories and collect files to be deleted.

We do not change categories for now.

for idx in cleaner.delete(): 
    files_to_clean.append(cleaner.fns[idx])

for file in files_to_clean:
    try:
        file.unlink()
    except:
        pass

After a lot of examination I cleaned my dataset from 1100 files to 1029. I have run the following cells to create a copy of the cleaned data. For protection of the data, this cell is commented.

#!mkdir -p working/which_cheese_cleaned
#!cp -r working/which_cheese_first  working/which_cheese_cleaned

5 Fast iterations to improve to analyze the data

5.1 Working with cleaned data

Now we have cleaned some data, we can train again, using more advanced techniques.

We will start by a simple training again, to see if the cleaning was successful.

from fastcore.all import *
from fastai.vision.all import *

cheese = DataBlock(
    blocks=(ImageBlock, CategoryBlock), 
    get_items=get_image_files, 
    splitter=RandomSplitter(valid_pct=0.2, seed=42),
    get_y=parent_label,
    item_tfms=[Resize(192, method='squish')]
)
dls = cheese.dataloaders("working/which_cheese_cleaned")
learn = vision_learner(dls, resnet18, metrics=accuracy)

learn.fine_tune(3)

epoch	train_loss	valid_loss	accuracy	time
0	4.137223	2.343409	0.326829	00:02

epoch	train_loss	valid_loss	accuracy	time
0	2.324481	1.571146	0.570732	00:02
1	1.581721	1.212596	0.643902	00:02
2	1.146727	1.148679	0.678049	00:02

We now roughly archieve 68% accuracy. Let’s train further to see how far when can get.

learn.fine_tune(13)

epoch	train_loss	valid_loss	accuracy	time
0	0.523904	1.073870	0.717073	00:02

epoch	train_loss	valid_loss	accuracy	time
0	0.314336	1.042765	0.721951	00:02
1	0.260081	0.991794	0.741463	00:02
2	0.203073	0.943358	0.741463	00:02
3	0.158532	0.913470	0.756098	00:02
4	0.141772	0.872876	0.751220	00:02
5	0.121437	0.816914	0.751220	00:02
6	0.101683	0.836497	0.765854	00:02
7	0.085780	0.845604	0.751220	00:02
8	0.071734	0.842247	0.760976	00:02
9	0.062432	0.823996	0.765854	00:02
10	0.053119	0.811724	0.760976	00:02
11	0.044131	0.817966	0.760976	00:02
12	0.038983	0.820316	0.760976	00:02

We seem to have hit a wall at 76% accuracy as early as iteration 6.

5.1.1 A word on the choice of metrics

Earlier I chose accuracy as the metric. Let’s examine our data to see if the choice is still valid.

pd.Series([dls.vocab[o[1]] for o in dls.train_ds]).value_counts()

Fourme d’Ambert          48
Chabichou du Poitou      47
Mimolette                44
Pont-l’Évêque            44
Brie de Meaux            43
Comté                    41
Tomme de Savoie          41
Cantal                   40
Pélardon                 40
Reblochon                39
Valençay                 39
Bleu d’Auvergne          38
Neufchâtel               37
Livarot                  36
Selles-sur-Cher          35
Camembert                34
Époisses de Bourgogne    33
Manchego                 32
Munster                  32
Gruyere                  29
Roquefort                27
Banon                    24
Name: count, dtype: int64

As I mentioned earlier, the dataset is no longer balanced. However, it is also not imbalanced, as the imbalance is 2:1 and not 1:10, an order of magnitude. We stick with accuracy.

5.2 Data Augmentation

We do not have many images in the data. Therefore, we will use data augmentation and move from squishing to RandomResizedCrop.

cheese_augmented = DataBlock(
    blocks=(ImageBlock, CategoryBlock), 
    get_items=get_image_files, 
    splitter=RandomSplitter(valid_pct=0.2, seed=42),
    get_y=parent_label,
    item_tfms=RandomResizedCrop(192, min_scale=0.3),
    batch_tfms=aug_transforms(mult=2))

dls = cheese_augmented.dataloaders("working/which_cheese_cleaned")

Note: I choose here to override the variables. A standard programming approach would use new variables. However, the learner reserves memory on the GPU. We will hit an out of memory error. One option is to delete the previous variable and free up the memory. The other option, which I chose here, is to override it with a new learner. This override implicitly deleted the old learner.

learn = vision_learner(dls, resnet18, metrics=accuracy)

We will pull another trick and use a better learning rate.

learn.lr_find()

SuggestedLRs(valley=0.0014454397605732083)

learn.fine_tune(16, 1.44e-3)

epoch	train_loss	valid_loss	accuracy	time
0	4.298504	2.772096	0.278049	00:02

epoch	train_loss	valid_loss	accuracy	time
0	3.559263	2.476911	0.331707	00:02
1	3.395612	2.182159	0.370732	00:02
2	3.096542	1.812795	0.492683	00:02
3	2.789779	1.489513	0.570732	00:02
4	2.507986	1.255989	0.629268	00:02
5	2.255753	1.103503	0.687805	00:02
6	1.996111	1.050033	0.726829	00:02
7	1.788129	0.995375	0.741463	00:02
8	1.612162	0.972283	0.741463	00:02
9	1.448160	0.921064	0.736585	00:02
10	1.303951	0.902030	0.751220	00:02
11	1.197405	0.879721	0.765854	00:02
12	1.133353	0.869218	0.760976	00:02
13	1.073917	0.860385	0.775610	00:02
14	1.003178	0.850505	0.770732	00:02
15	0.972047	0.851660	0.775610	00:02

learn.fine_tune(6, 1.44e-3)

epoch	train_loss	valid_loss	accuracy	time
0	0.824386	0.848143	0.780488	00:02

epoch	train_loss	valid_loss	accuracy	time
0	0.778520	0.854400	0.780488	00:02
1	0.784403	0.840095	0.770732	00:02
2	0.752580	0.833080	0.760976	00:02
3	0.711079	0.824473	0.775610	00:02
4	0.661186	0.804503	0.760976	00:02
5	0.619942	0.800512	0.765854	00:02

learn.fine_tune(6, 1.44e-3)

epoch	train_loss	valid_loss	accuracy	time
0	0.536938	0.783610	0.775610	00:02

epoch	train_loss	valid_loss	accuracy	time
0	0.553907	0.786242	0.775610	00:02
1	0.547560	0.848543	0.765854	00:02
2	0.524134	0.848381	0.756098	00:02
3	0.499666	0.811153	0.780488	00:02
4	0.473074	0.783625	0.780488	00:02
5	0.465626	0.781733	0.785366	00:02

The training advanced more slowly. It seems to have hit the same block at 76%, 77%. Only after 12 more iterations, we seem to have converged on a path with over 78%. The Validation loss is only going down after 6 iterations, showing convergence issues of the gradient descent.

Let’s look at the solution

interp = ClassificationInterpretation.from_learner(learn)
interp.plot_confusion_matrix()

interp.plot_top_losses(5, nrows=1)

The fourme d'ambert uncertainty has almost vanished. The top losses are from images that have slipped my cleaning efforts and are indeeed misleading.

5.3 Label smoothing

As the data still has a lot of noise, we can try label smoothing. Labelsmoothing assumes a natural uncertainty and no label can have 100%. Instead, Label smoothing redistributes a small portion of the correct class’s probability across all classes to prevent overconfidence and improve generalization.

We will start with 28 iterations.

from fastai.losses import LabelSmoothingCrossEntropy

learn = vision_learner(dls, resnet18, metrics=accuracy, loss_func=LabelSmoothingCrossEntropy())

learn.lr_find()

SuggestedLRs(valley=0.00363078061491251)

learn.fine_tune(28, 3.6e-3)

epoch	train_loss	valid_loss	accuracy	time
0	4.273853	2.742732	0.307317	00:02

epoch	train_loss	valid_loss	accuracy	time
0	2.933313	2.152079	0.429268	00:02
1	2.757924	1.957854	0.531707	00:02
2	2.600373	1.795183	0.595122	00:02
3	2.414058	1.652869	0.648780	00:02
4	2.251830	1.555603	0.692683	00:02
5	2.109990	1.569267	0.702439	00:02
6	1.985083	1.525316	0.717073	00:02
7	1.878232	1.548784	0.717073	00:02
8	1.782599	1.508083	0.726829	00:02
9	1.692580	1.468358	0.746341	00:02
10	1.610464	1.430262	0.741463	00:02
11	1.544696	1.419962	0.721951	00:02
12	1.477807	1.413017	0.751220	00:02
13	1.419630	1.305687	0.760976	00:02
14	1.370959	1.298595	0.795122	00:02
15	1.320189	1.298479	0.814634	00:02
16	1.275702	1.271670	0.785366	00:02
17	1.247922	1.282414	0.770732	00:02
18	1.205016	1.259176	0.775610	00:02
19	1.168169	1.248492	0.775610	00:02
20	1.135880	1.244297	0.780488	00:02
21	1.108426	1.244742	0.785366	00:02
22	1.088607	1.238094	0.775610	00:02
23	1.073189	1.241032	0.780488	00:02
24	1.053456	1.239150	0.775610	00:02
25	1.044365	1.244962	0.780488	00:02
26	1.034709	1.242740	0.780488	00:02
27	1.029999	1.233360	0.790244	00:02

Starting at iteration 13, issues emerged with the loss function. We observed an accuracy of approximately 81%. Yet, our accuracy is just 79%, despite the reduced loss

5.4 Summary

Data augmentation and Label Smoothing both help with very noisy data and a low amount of samples. We got the accuracy from 76% to 81%.

6 Bigger is better

So they say in mechanical engineering.

Let’s try improvements for size.

6.1 Bigger images

First, we increase the images.

from fastcore.all import *
from fastai.vision.all import *

cheese = DataBlock(
    blocks=(ImageBlock, CategoryBlock), 
    get_items=get_image_files, 
    splitter=RandomSplitter(valid_pct=0.2, seed=42),
    get_y=parent_label,
    item_tfms=RandomResizedCrop(256, min_scale=0.3),
    batch_tfms=aug_transforms(mult=2))

dls = cheese.dataloaders("working/which_cheese_cleaned")

learn_better = vision_learner(dls, resnet18, metrics=accuracy)

learn_better.lr_find()

SuggestedLRs(valley=0.0008317637839354575)

6.1.1 Note: Beware CUDA out of memory

As we increase the size of the data and the model we can run of memory. After the crash, the memory stays allocated.

The standard approach is to run torch.cuda.empty_cache() and run garbage collection..

Sometimes, the memory still keeps being allocated and i need multiple passes to free up the memory. I wrote a utility function to do just that.

As I use an old GPU with only 8GB, I frequently run in the out-of-memory error.

def free_cuda_memory(var_name, globals_dict, max_attempts=5, delay=0.5):
    """
    Deletes a variable by name, collects garbage, and repeatedly clears CUDA memory until freed.
    
    Args:
        var_name (str): Name of the variable to delete.
        globals_dict (dict): Pass `globals()` to delete from the global scope.
        max_attempts (int): Maximum attempts to clear memory.
        delay (float): Time (in seconds) to wait between attempts.
    """
    import torch
    import gc
    import time
    if var_name in globals_dict:
        del globals_dict[var_name]
    else:
        print(f"Variable '{var_name}' not found in globals.")
        return

    for _ in range(max_attempts):
        gc.collect()
        torch.cuda.empty_cache()
        torch.cuda.ipc_collect()
        time.sleep(delay)

        # Check if memory is freed
        allocated = torch.cuda.memory_allocated()
        cached = torch.cuda.memory_reserved()

        if allocated == 0 and cached == 0:
            print("CUDA memory successfully freed.")
            return
    
    print("Warning: Some CUDA memory may still be blocked.")
    print(f"Allocated: {torch.cuda.memory_allocated() / 1e9:.2f} GB")
    print(f"Cached: {torch.cuda.memory_reserved() / 1e9:.2f} GB")

free_cuda_memory("learn_better",globals())

Variable 'learn_better' not found in globals.

learn_better.fine_tune(20, 8.3e-4)

epoch	train_loss	valid_loss	accuracy	time
0	4.542337	3.085513	0.146341	00:02

epoch	train_loss	valid_loss	accuracy	time
0	4.000002	2.851287	0.180488	00:03
1	3.854214	2.640312	0.214634	00:03
2	3.678350	2.329466	0.321951	00:03
3	3.460999	1.959772	0.409756	00:03
4	3.187331	1.625292	0.536585	00:03
5	2.932109	1.408548	0.604878	00:03
6	2.674737	1.244989	0.668293	00:03
7	2.424846	1.146155	0.663415	00:03
8	2.201131	1.025524	0.707317	00:03
9	2.034413	0.931238	0.726829	00:03
10	1.865840	0.851306	0.756098	00:03
11	1.716559	0.824157	0.741463	00:03
12	1.578321	0.804028	0.770732	00:03
13	1.461851	0.793212	0.775610	00:03
14	1.359122	0.781659	0.795122	00:03
15	1.279223	0.774161	0.795122	00:03
16	1.229434	0.775929	0.795122	00:03
17	1.166556	0.768999	0.795122	00:03
18	1.123601	0.767946	0.800000	00:03
19	1.104936	0.771056	0.790244	00:03

learn_better.export('resnet.pkl')

Almost 80%. After 20 epochs, the goal seems to have been reached. In another run I had 82%. Despite the lack of consistency, I count this as a record.

6.2 Bigger Model

Instead of the images we can increase the model, we will go for resnet34 and resnet50.

cheese = DataBlock(
    blocks=(ImageBlock, CategoryBlock), 
    get_items=get_image_files, 
    splitter=RandomSplitter(valid_pct=0.2, seed=42),
    get_y=parent_label,
    item_tfms=RandomResizedCrop(192, min_scale=0.3),
    batch_tfms=aug_transforms(mult=2))

dls = cheese.dataloaders("working/which_cheese_cleaned")

learn_better = vision_learner(dls, resnet34, metrics=accuracy)

learn_better.lr_find()

SuggestedLRs(valley=0.0020892962347716093)

learn_better.fine_tune(20, 2e-3)

epoch	train_loss	valid_loss	accuracy	time
0	4.319314	2.530106	0.243902	00:02

epoch	train_loss	valid_loss	accuracy	time
0	3.351670	2.044574	0.380488	00:03
1	3.058213	1.685639	0.507317	00:03
2	2.746131	1.313843	0.639024	00:03
3	2.436243	1.013334	0.731707	00:03
4	2.142230	0.840266	0.775610	00:03
5	1.898090	0.805258	0.770732	00:03
6	1.671135	0.764192	0.800000	00:03
7	1.478277	0.738444	0.809756	00:03
8	1.305836	0.683891	0.785366	00:03
9	1.142530	0.632159	0.790244	00:03
10	1.006283	0.622701	0.814634	00:03
11	0.882134	0.641913	0.790244	00:03
12	0.775799	0.630769	0.780488	00:03
13	0.712351	0.629713	0.790244	00:03
14	0.638866	0.643542	0.790244	00:03
15	0.576997	0.637436	0.790244	00:03
16	0.545079	0.637268	0.804878	00:03
17	0.505899	0.642498	0.804878	00:03
18	0.472322	0.642579	0.800000	00:03
19	0.449359	0.632896	0.804878	00:03

learn_better = vision_learner(dls, resnet50, metrics=accuracy)

learn_better.lr_find()

SuggestedLRs(valley=0.0010000000474974513)

learn_better.fine_tune(20, 1e-3)

epoch	train_loss	valid_loss	accuracy	time
0	4.393582	2.744330	0.204878	00:04

epoch	train_loss	valid_loss	accuracy	time
0	3.321695	2.486286	0.287805	00:06
1	3.125788	2.221527	0.356098	00:06
2	2.849939	1.930392	0.439024	00:06
3	2.639139	1.629388	0.502439	00:06
4	2.387037	1.396374	0.600000	00:06
5	2.145477	1.242509	0.648780	00:06
6	1.933496	1.132375	0.687805	00:06
7	1.738567	1.025986	0.717073	00:06
8	1.557685	0.977237	0.756098	00:06
9	1.412416	0.930118	0.765854	00:06
10	1.275174	0.908866	0.756098	00:06
11	1.159127	0.913954	0.765854	00:06
12	1.066809	0.898841	0.775610	00:06
13	0.990926	0.876705	0.780488	00:06
14	0.921643	0.868463	0.785366	00:06
15	0.874949	0.841853	0.780488	00:06
16	0.826003	0.845446	0.765854	00:06
17	0.782675	0.861964	0.765854	00:06
18	0.737917	0.838224	0.770732	00:06
19	0.717874	0.844599	0.765854	00:06

Remarkably the bigger model resnet34 also can achieve 81% and the training is better converging. Conversely, the even larger ResNet50 model yields inferior results. This could be due to the limited amount of data.

Let’s see how the big model handles big images.

cheese = DataBlock(
    blocks=(ImageBlock, CategoryBlock), 
    get_items=get_image_files, 
    splitter=RandomSplitter(valid_pct=0.2, seed=42),
    get_y=parent_label,
    item_tfms=RandomResizedCrop(256, min_scale=0.3),
    batch_tfms=aug_transforms(mult=2))

dls = cheese.dataloaders("working/which_cheese_cleaned")
learn_better = vision_learner(dls, resnet34, metrics=accuracy)

learn_better.lr_find()

SuggestedLRs(valley=0.0006918309954926372)

learn_better.fine_tune(20, 6.9e-4)

epoch	train_loss	valid_loss	accuracy	time
0	4.543718	3.211622	0.092683	00:04

epoch	train_loss	valid_loss	accuracy	time
0	4.034224	2.881157	0.180488	00:05
1	3.940435	2.636389	0.229268	00:05
2	3.715499	2.337412	0.326829	00:05
3	3.486756	1.973952	0.429268	00:05
4	3.248124	1.657461	0.507317	00:05
5	2.996700	1.410418	0.595122	00:05
6	2.718238	1.225778	0.673171	00:05
7	2.460284	1.119877	0.697561	00:05
8	2.235554	1.047230	0.692683	00:05
9	2.015765	0.982388	0.717073	00:05
10	1.827305	0.939780	0.726829	00:05
11	1.672784	0.906191	0.741463	00:05
12	1.559439	0.882196	0.756098	00:05
13	1.426843	0.865841	0.765854	00:05
14	1.338417	0.850578	0.765854	00:05
15	1.243912	0.847275	0.746341	00:05
16	1.178589	0.844610	0.751220	00:05
17	1.117920	0.846011	0.746341	00:05
18	1.063974	0.839167	0.751220	00:05
19	1.025944	0.836000	0.765854	00:05

First, it needs to be noted that the learning rate is lower. But also the results are worse than for resnet18.

6.3 Even bigger images

We will increase the images even further. We resized our images to 400px, so there is no point in going larger than 312px.

cheese = DataBlock(
    blocks=(ImageBlock, CategoryBlock), 
    get_items=get_image_files, 
    splitter=RandomSplitter(valid_pct=0.2, seed=42),
    get_y=parent_label,
    item_tfms=RandomResizedCrop(312, min_scale=0.3),
    batch_tfms=aug_transforms(mult=2))

dls = cheese.dataloaders("working/which_cheese_cleaned")
learn_better = vision_learner(dls, resnet34, metrics=accuracy)

learn_better.lr_find()

SuggestedLRs(valley=0.0010000000474974513)

learn_better.fine_tune(20, 1e-3)

epoch	train_loss	valid_loss	accuracy	time
0	4.543712	3.039113	0.146341	00:06

epoch	train_loss	valid_loss	accuracy	time
0	3.761286	2.706118	0.234146	00:07
1	3.621768	2.441219	0.297561	00:07
2	3.425048	2.090192	0.409756	00:08
3	3.118869	1.713392	0.507317	00:07
4	2.836166	1.382881	0.585366	00:07
5	2.560673	1.180610	0.629268	00:07
6	2.283780	1.015514	0.697561	00:07
7	2.033190	0.904861	0.736585	00:07
8	1.819672	0.865400	0.731707	00:07
9	1.640550	0.837150	0.736585	00:07
10	1.489337	0.794789	0.765854	00:07
11	1.336533	0.753989	0.770732	00:07
12	1.211884	0.724643	0.775610	00:07
13	1.124595	0.710352	0.790244	00:07
14	1.030781	0.710033	0.785366	00:07
15	0.960203	0.696822	0.790244	00:07
16	0.899652	0.694591	0.795122	00:07
17	0.841474	0.690466	0.809756	00:07
18	0.791879	0.689909	0.795122	00:07
19	0.763160	0.689728	0.800000	00:07

cheese = DataBlock(
    blocks=(ImageBlock, CategoryBlock), 
    get_items=get_image_files, 
    splitter=RandomSplitter(valid_pct=0.2, seed=42),
    get_y=parent_label,
    item_tfms=RandomResizedCrop(312, min_scale=0.3),
    batch_tfms=aug_transforms(mult=2))

dls = cheese.dataloaders("working/which_cheese_cleaned")
learn_better = vision_learner(dls, resnet18, metrics=accuracy)

learn_better.lr_find()

SuggestedLRs(valley=0.0010000000474974513)

learn_better.fine_tune(20, 1e-3)

epoch	train_loss	valid_loss	accuracy	time
0	4.559435	2.919010	0.170732	00:04

epoch	train_loss	valid_loss	accuracy	time
0	3.794993	2.674616	0.239024	00:05
1	3.646426	2.417594	0.307317	00:05
2	3.475905	2.064787	0.375610	00:05
3	3.235945	1.699186	0.502439	00:05
4	2.987770	1.406921	0.560976	00:05
5	2.700939	1.190468	0.643902	00:05
6	2.444276	1.058556	0.712195	00:05
7	2.220634	0.985898	0.726829	00:05
8	2.032653	0.906098	0.760976	00:05
9	1.847860	0.848331	0.765854	00:05
10	1.679043	0.809622	0.746341	00:05
11	1.530006	0.772010	0.736585	00:05
12	1.410453	0.746380	0.765854	00:05
13	1.309522	0.737125	0.780488	00:05
14	1.227750	0.726092	0.790244	00:05
15	1.161594	0.708379	0.785366	00:05
16	1.102717	0.702760	0.775610	00:05
17	1.054643	0.707285	0.785366	00:05
18	1.007804	0.689951	0.790244	00:05
19	0.993321	0.692554	0.785366	00:05

Interestingly, the even bigger size brings the bigger model to a slight advantage, but not much.

It could be that the bigger model has a better capacity to learn from more data. Whereas the smaller model generalizes better on a smaller dataset.

Research has also shown this: https://en.wikipedia.org/wiki/Neural_scaling_law.

Larger models often perform better with more data because of their capacity to learn complex patterns, while smaller models may generalize better on smaller datasets, reducing overfitting.

6.4 Label smoothing

We will try the size together with the label smoothing.

cheese = DataBlock(
    blocks=(ImageBlock, CategoryBlock), 
    get_items=get_image_files, 
    splitter=RandomSplitter(valid_pct=0.2, seed=42),
    get_y=parent_label,
    item_tfms=RandomResizedCrop(312, min_scale=0.3),
    batch_tfms=aug_transforms(mult=2))
dls = cheese.dataloaders("working/which_cheese_cleaned")
learn_better = vision_learner(dls, resnet18, metrics=accuracy, loss_func=LabelSmoothingCrossEntropy())

learn_better.lr_find()

SuggestedLRs(valley=0.0014454397605732083)

learn_better.fine_tune(20, 1.4e-3)

epoch	train_loss	valid_loss	accuracy	time
0	4.394593	2.871440	0.229268	00:04

epoch	train_loss	valid_loss	accuracy	time
0	3.653049	2.588406	0.317073	00:05
1	3.530752	2.326544	0.365854	00:05
2	3.368824	2.011567	0.502439	00:05
3	3.158019	1.743854	0.590244	00:05
4	2.937979	1.583111	0.668293	00:05
5	2.703008	1.478423	0.707317	00:05
6	2.499692	1.461678	0.785366	00:05
7	2.328650	1.402460	0.770732	00:05
8	2.176972	1.380992	0.760976	00:05
9	2.045058	1.355799	0.751220	00:05
10	1.940953	1.329172	0.780488	00:05
11	1.850078	1.313228	0.809756	00:05
12	1.770922	1.311223	0.809756	00:05
13	1.706659	1.292058	0.819512	00:05
14	1.641106	1.296595	0.800000	00:05
15	1.590719	1.295866	0.814634	00:05
16	1.561213	1.287696	0.800000	00:05
17	1.523102	1.286888	0.809756	00:05
18	1.498262	1.279946	0.809756	00:05
19	1.474353	1.274973	0.814634	00:05

Sadly the LabelSmoothing only improved the convergence. The final score is not better than the initial try with bigger images.

7 Modern model architectures

Resnet is quite dated. A newer model, ConvNext is reported to deliver better results.

We will start with the base variant of the model. Due to its size, we need to limit the batch size to 16. Currently, I found no other way than trial and error to determine the batch size.

During the discovery of the correct batch size, I multiple times hit the memory ceiling. My free_cuda_memory function came in handy.

from fastcore.all import *
from fastai.vision.all import *

cheese = DataBlock(
    blocks=(ImageBlock, CategoryBlock), 
    get_items=get_image_files, 
    splitter=RandomSplitter(valid_pct=0.2, seed=42),
    get_y=parent_label,
    item_tfms=RandomResizedCrop(256, min_scale=0.3),
    batch_tfms=aug_transforms(mult=2))

dls = cheese.dataloaders("working/which_cheese_cleaned", bs=16)
learn = vision_learner(dls, convnext_base, metrics=accuracy)

learn.lr_find()

SuggestedLRs(valley=0.0010000000474974513)

learn.fine_tune(20, 1.e-3)

epoch	train_loss	valid_loss	accuracy	time
0	4.031354	2.283592	0.321951	00:37

epoch	train_loss	valid_loss	accuracy	time
0	2.887947	2.005787	0.385366	01:28
1	2.703871	1.712844	0.492683	01:28
2	2.446322	1.513336	0.585366	01:27
3	2.149493	1.298572	0.614634	01:30
4	1.878358	0.989779	0.712195	01:29
5	1.694279	0.902841	0.731707	01:29
6	1.502565	0.791859	0.775610	01:30
7	1.361015	0.699819	0.795122	01:30
8	1.272284	0.713360	0.809756	01:30
9	1.163435	0.629532	0.804878	01:29
10	1.010350	0.623500	0.829268	01:30
11	0.907372	0.668074	0.785366	01:30
12	0.915707	0.625355	0.804878	01:29
13	0.833985	0.539842	0.829268	01:30
14	0.772828	0.531026	0.824390	01:30
15	0.735248	0.518410	0.824390	01:30
16	0.715735	0.510863	0.819512	01:30
17	0.726851	0.512946	0.829268	01:30
18	0.732415	0.508770	0.824390	01:30
19	0.737635	0.505515	0.829268	01:29

The convnext-base model reached 83% already after 10 iterations. Afterwards, the loss improved, but accuracy did not. However, the model is big with 350mb. We will save it for later.

learn.export('convnext_base.pkl')

7.1 Trying something smaller

There is also a convnext-tiny model, which should produce a smaller model file.

dls_better_tiny = cheese.dataloaders("working/which_cheese_cleaned", bs=32)
learn = vision_learner(dls_better_tiny, convnext_tiny, metrics=accuracy)

dls_better_tiny.bs

learn.lr_find()

SuggestedLRs(valley=0.0014454397605732083)

learn.fine_tune(20,1.44e-3)

epoch	train_loss	valid_loss	accuracy	time
0	4.244600	2.932380	0.165854	00:15

epoch	train_loss	valid_loss	accuracy	time
0	3.287429	2.501591	0.287805	00:53
1	3.098157	2.106716	0.395122	00:53
2	2.910831	1.777798	0.512195	00:53
3	2.688967	1.506041	0.590244	00:53
4	2.420423	1.393299	0.653659	00:53
5	2.151483	1.200701	0.653659	00:53
6	1.887403	1.033586	0.697561	00:52
7	1.715113	0.973459	0.702439	00:53
8	1.539306	0.942053	0.702439	00:54
9	1.360577	0.849999	0.697561	00:53
10	1.227610	0.811377	0.746341	00:54
11	1.121673	0.766563	0.760976	00:53
12	1.017336	0.724510	0.785366	00:52
13	0.960135	0.694766	0.790244	00:52
14	0.924193	0.685870	0.790244	00:52
15	0.853204	0.688712	0.785366	00:53
16	0.816196	0.688337	0.795122	00:53
17	0.769849	0.678705	0.790244	00:53
18	0.743718	0.687633	0.804878	00:52
19	0.744009	0.674999	0.809756	00:52

learn.export("tiny.pkl")

The tiny model is not as good as the base model. However, the exported model is only 114MB. Still compared to good old resnet (47MB), that is more than twice the size.

8 Inference and getting ready for deployment

Let’s check if our models work in inferences.

We only test one image and do a visual inspection of the results. As already mentioned before, I did not provide a test set.

This is the biggest open TODO.

Another important aspect would be how certain the prediction is. How high is the probability for the second candidate? Many improvements are possible in problem definition and post-processing.

8.1 Comparison of three models

from fastcore.all import *
from fastai.vision.all import *

from fastai.learner import load_learner

# Load the FastAI Learner
learn_inf_tiny = load_learner("models/tiny.pkl")
learn_inf_base= load_learner("models/base.pkl")
learn_inf_resnet = load_learner("models/resnet.pkl")

learn_inf_tiny.predict("working/which_cheese_cleaned/which_cheese_first/which_cheese/Cantal/0c81aeec-c0a6-421e-844f-3e6e240885a8.jpg")

('Cantal',
 tensor(4),
 tensor([9.7780e-05, 9.0306e-06, 2.1395e-05, 1.0606e-05, 9.9840e-01, 1.2682e-07,
         4.7644e-04, 1.4753e-06, 9.9773e-06, 4.0509e-06, 2.3105e-05, 8.3267e-05,
         8.9159e-05, 2.2647e-06, 3.8224e-06, 4.5492e-07, 2.8718e-04, 2.2553e-06,
         7.6010e-07, 3.5029e-04, 2.3085e-07, 1.2567e-04]))

learn_inf_base.predict("working/which_cheese_cleaned/which_cheese_first/which_cheese/Cantal/0c81aeec-c0a6-421e-844f-3e6e240885a8.jpg")

('Cantal',
 tensor(4),
 tensor([1.5877e-06, 5.6175e-05, 1.3185e-06, 4.0135e-06, 9.9739e-01, 1.9972e-06,
         1.6469e-03, 1.1616e-05, 1.5650e-04, 2.0251e-05, 1.6810e-05, 3.3364e-04,
         1.2042e-05, 1.8571e-06, 7.5011e-06, 5.5109e-07, 1.8472e-04, 2.0955e-06,
         1.5077e-05, 8.5131e-05, 1.5477e-07, 4.9878e-05]))

learn_inf_resnet.predict("working/which_cheese_cleaned/which_cheese_first/which_cheese/Cantal/0c81aeec-c0a6-421e-844f-3e6e240885a8.jpg")

('Cantal',
 tensor(4),
 tensor([1.2273e-06, 1.0518e-04, 2.1162e-05, 9.5564e-07, 9.9687e-01, 5.3281e-06,
         2.2306e-03, 5.5073e-08, 9.4349e-05, 1.3493e-06, 2.2718e-04, 2.3397e-04,
         8.0347e-06, 5.4313e-06, 4.4896e-06, 8.3956e-07, 3.2568e-05, 1.5521e-05,
         2.5339e-06, 1.2194e-04, 1.5376e-05, 4.0610e-07]))

8.2 Comparison of ONNX and Pytorch

We’ll require an onnx model at a later time. Let’s evaluate the resnet model’s prediction accuracy.

!pip install onnx

import torch

model = learn_inf_resnet.model
dummy_input = torch.randn(1, 3, 256, 256)  # Use batch size 1 for export
torch.onnx.export(
    model, 
    dummy_input, 
    "model.onnx", 
    export_params=True, 
    opset_version=11, 
    do_constant_folding=True, 
    input_names=["input"], 
    output_names=["output"], 
    dynamic_axes={"input": {0: "batch_size"}, "output": {0: "batch_size"}}  # Allow variable batch size
)

!pip install onnxruntime numpy pillow torchvision

class_names = learn_inf_resnet.dls.vocab
print(class_names)  # List of class names

['Banon', 'Bleu d’Auvergne', 'Brie de Meaux', 'Camembert', 'Cantal', 'Chabichou du Poitou', 'Comté', 'Fourme d’Ambert', 'Gruyere', 'Livarot', 'Manchego', 'Mimolette', 'Munster', 'Neufchâtel', 'Pont-l’Évêque', 'Pélardon', 'Reblochon', 'Roquefort', 'Selles-sur-Cher', 'Tomme de Savoie', 'Valençay', 'Époisses de Bourgogne']

import onnxruntime as ort
import numpy as np
from PIL import Image
import torchvision.transforms as transforms
# Load ONNX model
session = ort.InferenceSession("model.onnx", providers=["CPUExecutionProvider"])

# Preprocessing function
def preprocess_image(image_path):
    transform = transforms.Compose([
        transforms.Resize((256, 256)),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ])
    image = Image.open(image_path).convert("RGB")
    image = transform(image).unsqueeze(0).numpy().astype(np.float32)  # Add batch dim and convert to NumPy
    return image

# Load and preprocess image
image_path = "working/which_cheese_cleaned/which_cheese_first/which_cheese/Cantal/0c81aeec-c0a6-421e-844f-3e6e240885a8.jpg"  # Replace with your image path
input_tensor = preprocess_image(image_path)

# Run inference
outputs = session.run(None, {"input": input_tensor})


import torch
outputs = session.run(None, {"input": input_tensor})[0]  # Raw logits
probabilities = torch.nn.functional.softmax(torch.tensor(outputs), dim=1)  # Convert to probabilities
predicted_class = torch.argmax(probabilities, dim=1).item()
# Get predicted class index and label
predicted_idx = np.argmax(probabilities)
predicted_label = class_names[predicted_idx]

print(f"Predicted Class: {predicted_label} (Confidence: {probabilities[0][predicted_idx]:.6f})")

Predicted Class: Cantal (Confidence: 0.971699)

The prediction is correct, but the confidence is slightly different. We will try it anyway in deployment.

9 Deployment: Delivering an experience

Of course we want to share our model and not only by posting the source code on GitHub or hugging face. What we want is a live version of the model. Something users can experience.

You can deploy via cloud computing or on-device/edge computing. The used technologies are different.

9.1 Cloud based deployment

You cannot evaluate PyTorch ML models using simple JavaScript. A server runs a python backend, which provides an endpoint that is only doing the code of the previous section.

Here is a good tutorial how to get a simple setup running on hugging face with gradio.

I developed a webcam based app; the code is in the repo. And the app is live.

In the app you can select the convnext-base, convnext-tiny and the resnet model. All models are trained with 256px images. Just point the camera towards a cheese.

I used the Gradio framework, popular in ML and featured on Hugging Face. The processing takes several milliseconds, despite being server based. The Gradio app offers no frame dropping. I try to include dynamic throttling to avoid frame congestion.

One thing I observed from this app is that the Convnext models have high numbers for the second and third best candidate. The app tries to predict a cheese when there is no cheese present. Two points worth to examine.

9.2 Edge based deployment

The issue with edge-based deployment is python. Python is by default not available on mobile. And because of secure concerns, it is becoming more and more complex to run a full blown linux with a python installation.

The other two ways are mobile apps and browser-based inference. We limit ourselves to browser based, because this is accessible via desktop and mobile.

ONNX format is necessary for web browser model deployment. At the end of this, we will evaluate if inferring onnx gives us the same probability. Due to differences in preprocessing between fast.ai and manual methods, some variations may occur.

Using my knowledge of web development, I constructed a basic app that does inferring the resnet model.

My impressions were that the results were less good. But, the startup and inference time were acceptable and comparable to the python app. This is a point worth to examine once I have defined a proper test set.

10 The End

This was my first basic study in low level ML. I dabbled in pose recognition before and did work manage AI projects. I’m very impressed with the progress these tools have made.

If you have enjoyed the read, come back for the next project. We will revisit a recipe classification app, which I programmed in 2021 and which we will improve with AI.

10.1 Links

Github Repo

Javascript App

Gradio App