Kaonashi's Blog

Staying curious as a developer

Fri, 03 Jul 2026 00:00:00 GMT

Compared to other sciences, computer science is probably the most recent one. Its tools and best practices continue to evolve every year. In tech, staying up to date with major changes is generally expected. A large part of studying computer science is learning how to learn.

I believe this is a field where you need to stay curious and keep discovering new things. And no, I am not saying people should spend their personal time coding and reading about tech. But there's a middle ground between it being an everyday passion and spending 10 years writing the same code with the same tools at the same company.

I'm convinced that trying new tools and languages, reading about how others work, and, most importantly, sharing those experiences with others is both enjoyable and something that can mostly fit within working hours.

Tech Watch

The practice of monitoring technological developments is often called tech watch. Over time, I've found multiple ways of staying informed. I'll share some of them with you.

As strange as it may seem to introverted people, exchanging ideas with colleagues and fellow developers is a big part of staying up to date. You may discuss news, ideas, and projects that you find interesting.

At my previous workplace, we set up a short, 15-minute meeting with the tech team every Thursday morning to share tech news. Sometimes we'd have lots of cool stuff to share, and other times the meeting lasted a minute. Having a dedicated time slot let developers know they were allowed and encouraged to read the news during work hours.

To keep up with tech news, I mostly read individual blogs, but I also watch videos and browse some companies' forums. I've started sharing some of them on my read list page. More recently, I set up an RSS reader to follow the latest news from my favourite blogs and newsletters. On Mac, I've found NetNewsWire to be a great tool.

I wanted another way of sharing knowledge, so I helped promote the idea of workshops. For me, workshops became one of the best ways to combine active learning, experimentation, and knowledge sharing.

Workshops

We'd run a workshop about every two months. We'd block a Friday afternoon and spend anywhere from one to four hours on it. Anyone on the team could organise a new workshop or join an existing one.

The sessions that attracted the most people were often the ones where participants could simply sit and listen. The most memorable ones, however, were the hands-on workshops.

Some workshops were directly linked to the business. For instance, we spent an afternoon exploring ways to improve our OCR results, which had initially been a one-person job.

Others were completely unrelated, such as learning how to pick locks. This is a well-known cliché hobby for cyber security people. I brought a few of my lock-picking kits for participants to try after showing them how to pick a lock. A colleague brought handcuffs for a lock-picking demonstration. I still have a photo of my manager at the time wearing the handcuffs.

When AI, and specifically LLMs, started becoming popular, we organised a few workshops around those. One team tried to create a Dungeon & Dragons Game Master by using OpenAI's API. Later, we did a session on Speech-to-Text and Text-to-Speech where the same team reused this work so they could talk to their AI Game Master. I also have a very fond memory of this workshop because I made a program that could drive a drone with voice commands: it could take off, land, move around, and even do a backflip. That was so freaking cool.

I've included below a few more examples of workshops we ran. Maybe it'll give you some ideas.

Talk by a maintainer of an internal project about its architecture
General presentations: "Hiring in Tech", "Code Quality", "Architecture 101", "Playing with GPUs"
Based on our stack: "Encryption at rest", "Database optimization within our technology stack"
Tools: Elasticsearch, GitLab CI, PlantUML
Watching SymfonyCasts videos together and discussing the code
Live coding in a specific language
Build and host a blog on AWS
Rust: Getting started by building a small application
Build your own AI agent using MCP
Godot: Build a simple game
Kubernetes & K3s setup
CodinGame challenges
Pentesting exercises

As you can see, the subjects were quite diverse, chosen mostly based on people's interests and knowledge, there was no need to be an expert to share something.

The end goal was to create opportunities for others, and ourselves, to discover new things. Sometimes we'd learn a new skill, sometimes we'd simply have fun, and other times we'd realise we never wanted to touch a particular language or tool ever again.

Looking back, these moments were also a particularly good way of fostering a healthy engineering culture

Personal projects

You may or may not enjoy coding outside of work, but hear me out before you brush off this part.

There are plenty of side projects out there, more or less time consuming, and more or less related to tech.

For instance, you could spend a weekend on a hackathon. I've done a few, pouring way too many hours into projects I'd never touch again. I still do one every once in a while, for the competitiveness or just to spend time with friends. They're fun, but they eat up a lot of time.

I get a similar kind of satisfaction from Advent of Code, without losing my whole weekend to it.

But here's another idea: why not build projects for yourself? Better yet, why not mix your hobbies with your skills? This blog is one example, but there's so much more to do. Personally, there are still plenty of things I want to build:

A NAS so I can share photos with my friends and family. I'll build my own app for it, since I don't like the existing ones.
A personal finance app that fits my needs better than what's out there, so I can finally ditch my automated spreadsheet.
A genealogy app that doesn't look like it's from 1990 and keeps my data locally.
A way to automatically water my plants based on their type and needs.
When I grow up, I'll buy a house, and I'll make it smart. I've already started with a Raspberry Pi running Home Assistant, but it doesn't do much yet... My lights flicker when it's bedtime and they turn red when the CO2 is too high.

A friend who's a big RPG fan made a TTRPG Alin Motion Tracker (The picture looks cool, I know, I know, you're welcome.). A second friend made a board game tracker, where you can log the games you've played and the board games you own. A third is building a relatively smart apartment that helps manage electricity consumption. And a fourth built a private sports-logging app for their friend circle to run competitions.

With the rise of coding agents, building your own applications is more accessible than ever, though you'll admittedly learn a lot less along the way. If you're concerned about privacy, money, or the environment, you can run Ollama locally with Cursor. Either way, there's never been a lower barrier to finally building that project you keep putting off.

Thoughts

I hope I'll be able to promote this idea of workshops at my next job. Meanwhile, I'll keep doing personal projects and experiments in my free time. I've already started sharing some of them here on this blog.

You can't keep up with every new technology out there because there's simply too much. However, making time to discover, experiment with, and share new things has always felt like a worthwhile investment as a developer.

Building a movies RAG

Wed, 24 Jun 2026 00:00:00 GMT

Context

RAG, which stands for Retrieval-Augmented Generation, is an AI framework that combines the strengths of traditional information retrieval systems (such as search and databases) with the capabilities of generative large language models (LLMs). By combining your data and world knowledge with LLM language skills, grounded generation is more accurate, up-to-date, and relevant to your specific needs.

<p class="alt">Source: Google Cloud</p>

My goal with this project is to learn how to build a RAG system. I read this post from The Go Blog to better understand the concepts behind RAG and how to build one.

Dataset

The first problem we face is finding a dataset large enough for the RAG system to retrieve information from. For example, my brother built a RAG using Common Vulnerabilities and Exposures (CVE).

I chose to build one focused on movies. I found a useful dataset containing around 1 million movies based on data from The Movie Database (TMDB).

Understanding Vectors

For this project, we will need a vector database, so let's make sure we understand the basics first.

A vector is a mathematical object that has both magnitude and direction. Vectors can be added together and multiplied by scalars (numbers). This website provides a nice visual explanation with concrete examples.

A vector database, vector store or vector search engine is a database that stores and retrieves embeddings of data in vector space. Vector databases typically implement approximate nearest neighbor algorithms so users can search for records semantically similar to a given input, unlike traditional databases which primarily look up records by exact match. Wikipedia

A vector space is a set whose elements, often called vectors, can be added together and multiplied ("scaled") by numbers called scalars. Wikipedia

Embedding is a representation learning technique that maps complex, high-dimensional data into a lower-dimensional vector space of numerical vectors. Wikipedia

For example, two movie descriptions about space exploration may end up close together in the embedding space, even if they do not share the exact same words.

Alright, but these are just definitions. It is still hard to picture what embeddings and vector databases actually do. <img src="https://developers.google.com/static/machine-learning/crash-course/images/embeddings_3D_tangyuan.png" alt="Embedding" width="700"/>

<p class="alt">Image from <a href="https://developers.google.com/machine-learning/crash-course/embeddings/embedding-space">Google Developers: Embeddings</a></p>

I recommend reading the article Embeddings by Google Developers to get a better intuition of how embedding spaces work.

Architecture

I have two main parts to build. First, I need to ingest the movie data into a vector database. Second, I need to build a way to query this data.

Ingestion Flow

Here is a high-level diagram of the ingestion flow I am aiming for:

<p class="alt">High-level diagram of the data ingestion flow</p>

Raw movie data is converted into structured documents.
The document text is transformed into embeddings using a text embedding model.
The embeddings and associated metadata are stored in the vector database for later retrieval.

Now, here is the same ingestion flow including the technologies used in this project:

<p class="alt">Lower level diagram of ingestion flow of the data</p>

Movie data is cleaned and converted into structured documents.
The Nomic embedding model (served via Ollama) generates embeddings from each document.
These embeddings, along with their metadata, are stored in Qdrant, where they can be queried using similarity search at runtime.

RAG (User Flow / Query Pipeline)

Here is a simple diagram of the RAG user flow I am aiming for:

<p class="alt">High-level diagram of the RAG user flow</p>

The user submits a query through the interface, which forwards it to the API.
The API converts the query into an embedding, retrieves similar documents from the vector database, and prepares the context.
The LLM generates an answer using the retrieved context, and the response is returned to the user.

Here is the same RAG user flow including the technologies used in this project:

<p class="alt">Lower-level diagram of the RAG user flow</p>

The user interacts with the Chainlit interface, which sends the request to FastAPI.
FastAPI uses the Nomic embedding model, served through Ollama, to embed the query and performs a similarity search in Qdrant using cosine distance.
The retrieved documents are passed to Llama 3.1, served through Ollama, which generates the final response returned through FastAPI to the interface.

Setup

I run my applications on a Mac M3 with 18 GB of RAM and an 11-core CPU.

Python stack

I chose Python for this project because I wanted to try some of the newer tools in the ecosystem.

I picked:

uv as the package manager
Ruff as the linter and formatter
ty as the type checker
FastAPI as the API framework
uvicorn as the web server

AI stack

The tools used for the AI part are:

Ollama to run LLMs locally on my machine
Qdrant as the vector database
Nomic (nomic-embed-text through Ollama) as the text embedding model
Llama (llama3.1:8b through Ollama) as the LLM
Chainlit as an open-source Python framework for building conversational AI applications

Docker

If you check the repository, you will see that I Dockerized everything from the start to have a portable environment.

This is a personal preference and is probably overkill for this project. A Python virtual environment with the required tools installed locally would work perfectly fine.

Ingestion

I'll walk through the steps I took to ingest the data into the vector database.

Step 0: Install the tools

We don't need the full stack installed yet, so let's iterate step by step.

The first tools we need are:

We also need to download the embedding model from Nomic:

ollama pull nomic-embed-text

And a few Python libraries:

kagglehub - interact with Kaggle resources
ollama - communicate with the Ollama API from Python.
pandas - data analysis and manipulation library
qdrant-client - Python client library for Qdrant
requests - HTTP client library

Installing these libraries with uv is trivial:

uv add kagglehub ollama pandas qdrant-client requests

Step 1: Get the dataset

The chosen dataset is a large CSV file, so we will use pandas later to read and process it.

We download the dataset using the kagglehub Python library.

from pathlib import Path


def downloadDataset():
    raw_path = kagglehub.dataset_download(
        "asaniczka/tmdb-movies-dataset-2023-930k-movies"
    )

    target_dir = Path("/app/data/tmdb")

    target_dir.mkdir(parents=True, exist_ok=True)

    for item in Path(raw_path).rglob("*"):
        if item.is_file():
            dest = target_dir / item.name
            shutil.copy2(item, dest)

    print("[DATASET] stored at:", target_dir)

    return str(target_dir)


if __name__ == "__main__":
    downloadDataset()

<p class="alt">Github file: scripts/download_dataset.py</p>

Step 2: Explore the dataset

Before ingesting the data, we need to understand the structure of the CSV file and decide which fields will be useful for our documents.

First, let's create a function to load the dataset.

from src.config import DATASET_PATH


def load_movies():
    if not DATASET_PATH.exists():
        raise FileNotFoundError(f"Dataset not found at {DATASET_PATH}")

    df = pd.read_csv(DATASET_PATH)

    return df

<p class="alt">Github file: src/dataset/loader.py</p>

Let's inspect the dataset using pandas:

from src.dataset.loader import load_movies
from src.dataset.documentBuilder import movieToDocument


if __name__ == "__main__":
    try: 
        df = load_movies().fillna("")

        print(df.columns)  # The titles
        print(df.head())  # The first 5 rows
        movie = df.iloc[0]

        for column in df.columns:
            print(f"{column}: {movie[column]}")  # The first movie's columns

    except Exception as err:
        print(f"err {err}")

<p class="alt">Github file: cmd/exploreDataset.py</p>

Index(['id', 'title', 'vote_average', 'vote_count', 'status', 'release_date',
       'revenue', 'runtime', 'adult', 'backdrop_path', 'budget', 'homepage',
       'imdb_id', 'original_language', 'original_title', 'overview',
       'popularity', 'poster_path', 'tagline', 'genres',
       'production_companies', 'production_countries', 'spoken_languages',
       'keywords'],
      dtype='str')

       id  ...                                           keywords
0   27205  ...  rescue, mission, dream, airplane, paris, franc...
1  157336  ...  rescue, future, spacecraft, race against time,...
2     155  ...  joker, sadism, chaos, secret identity, crime f...
3   19995  ...  future, society, culture clash, space travel, ...
4   24428  ...  new york city, superhero, shield, based on com...

[5 rows x 24 columns]
id: 27205
title: Inception
vote_average: 8.364
vote_count: 34495
status: Released
release_date: 2010-07-15
revenue: 825532764
runtime: 148
adult: False
backdrop_path: /8ZTVqvKDQ8emSGUEMjsS4yHAwrp.jpg
budget: 160000000
homepage: https://www.warnerbros.com/movies/inception
imdb_id: tt1375666
original_language: en
original_title: Inception
overview: Cobb, a skilled thief who commits corporate espionage by infiltrating the subconscious of his targets is offered a chance to regain his old life as payment for a task considered to be impossible: "inception", the implantation of another person's idea into a target's subconscious.
popularity: 83.952
poster_path: /oYuLEt3zVCKq57qu2F8dT7NIa6f.jpg
tagline: Your mind is the scene of the crime.
genres: Action, Science Fiction, Adventure
production_companies: Legendary Pictures, Syncopy, Warner Bros. Pictures
production_countries: United Kingdom, United States of America
spoken_languages: English, French, Japanese, Swahili
keywords: rescue, mission, dream, airplane, paris, france, virtual reality, kidnapping, philosophy, spy, allegory, manipulation, car crash, heist, memory, architecture, los angeles, california, dream world, subconscious

Step 3: Initalize the database

We create a Qdrant client, connect to the Qdrant instance, and create a collection called movies.

In the model's documentation, we can see that nomic-bert.embedding_length=768. This means each embedding generated by the model contains 768 dimensions, so the Qdrant collection needs to be configured with the same vector size.

Qdrant is a vector database that performs nearest-neighbor search. We use cosine distance to measure the similarity between vectors.

from qdrant_client import QdrantClient
from qdrant_client.models import VectorParams, Distance

client = QdrantClient(url="http://qdrant:6333")


def createCollection(vector_size: int = 768):
    client.recreate_collection(
        collection_name="movies",
        vectors_config=VectorParams(
            size=vector_size,
            distance=Distance.COSINE,
        ),
    )

    print("[QDRANT] collection 'movies' ready")

if __name__ == "__main__":
    createCollection(vector_size=768)

<p class="alt">Github file: src/vectordb/qdrantClient.py</p>

Step 4: Ingestion

Before creating the ingestion pipeline, we need a way to convert text into embeddings. For this, we send the movie text to the nomic-embed-text embedding model through Ollama.


OLLAMA_URL = "http://ollama:11434"


def embedText(text: str) -> list[float]:
    response = requests.post(
        f"{OLLAMA_URL}/api/embeddings",
        json={
            "model": "nomic-embed-text",
            "prompt": text,
        },
        timeout=30,
    )
    response.raise_for_status()
    return response.json()["embedding"]

<p class="alt">Github file: src/embeddings/httpEmbedding.py</p>

An embedding is a list of numbers that represents a piece of data in a vector space.

For text, embedding models transform sentences into vectors where similar concepts tend to be located closer together. This allows computers to compare text based on semantic similarity rather than only exact word matches.

from numpy.typing import NDArray


Embedding = NDArray[np.float64]


def cosine_similarity(a: Embedding, b: Embedding) -> float:
    return float(
        np.dot(a, b) /
        (np.linalg.norm(a) * np.linalg.norm(b))
    )


def compare_texts(text_a: str, text_b: str) -> float:
    embedding_a = np.array(embedText(text_a), dtype=np.float64)
    embedding_b = np.array(embedText(text_b), dtype=np.float64)

    return cosine_similarity(embedding_a, embedding_b)


def main() -> None:
    base_sentence: str = "Prince, Princess"
    sentence_comparison1: str = "A fairy tale about royalty and a king and queen"
    similarity = compare_texts(base_sentence, sentence_comparison1)
    print(f"{base_sentence} <-- vs -> {sentence_comparison1}")
    print(f"Similarity: {round(similarity, 2)}\n")

    sentence_comparison2: str = "A car engine repair manual with mechanical instructions"
    similarity = compare_texts(
        base_sentence,
        sentence_comparison2
    )
    print(f"{base_sentence} <-- vs --> {sentence_comparison2}")
    print(f"Similarity: {round(similarity, 2)}")
    

if __name__ == "__main__":
    main()

Result:

Prince, Princess <-- vs -> A fairy tale about royalty and a king and queen
Similarity: 0.73

Prince, Princess <-- vs --> A car engine repair manual with mechanical instructions
Similarity: 0.42

Next, we ingest a few movies into Qdrant. We do not need to test the project with a database containing 1 million entries yet, so 200 movies is enough for now.

Each movie becomes a Qdrant point. The vector contains the embedding, while the payload contains metadata associated with the movie.

from src.dataset.loader import load_movies
from src.embeddings.httpEmbedding import embedText
from src.vectordb.qdrantClient import client


def ingest(n=200):
    df = load_movies().fillna("")
    df = df.head(n)

    for i, row in df.iterrows():
        text = f"{row['title']} {row['overview']} {row['tagline']}"
        vector = embedText(text)

        client.upsert(
            collection_name="movies",
            points=[
                {
                    "id": int(row["id"]),
                    "vector": vector,
                    "payload": {
                        "title": row["title"],
                        "overview": row["overview"],
                        "genres": row["genres"],
                    },
                }
            ],
        )

        if i % 50 == 0:
            print("ingested:", i)


if __name__ == "__main__":
    ingest()

<p class="alt">Github file: cmd/ingest.py</p>

Step 5: Search database

Now that we have stored data in the vector database, we can query it.

The top_k parameter determines how many results Qdrant should return. These results are ranked by vector similarity.

from qdrant_client import QdrantClient
from qdrant_client.models import SearchRequest
from src.embeddings.httpEmbedding import embedText

client = QdrantClient(url="http://qdrant:6333")


def search_movies(query: str, top_k: int = 5):
    query_vector = embedText(query)

    results = client.query_points(
        collection_name="movies",
        query=query_vector,
        limit=top_k,
        with_payload=True,
    )

    for r in results.points:
        print("\n---")
        print("title:", r.payload["title"])
        print("genres:", r.payload["genres"])
        print("overview:", r.payload["overview"][:200])


if __name__ == "__main__":
    search_movies("dream infiltration mind heist")

<p class="alt">Github file: cmd/qdrantSearch.py</p>

---
title: Inception
genres: Action, Science Fiction, Adventure
overview: Cobb, a skilled thief who commits corporate espionage by infiltrating the subconscious of his targets is offered a chance to regain his old life as payment for a task considered to be impossible: "inc

---
title: Fear in the Night
genres: Crime, Drama, Mystery, Thriller
overview: The dream is unusually vivid: Bank employee Vince Grayson finds himself murdering a man in a sinister octagonal-shaped room lined with mirrors while a mysterious woman breaks into a safe. It is so viv

---
title: The Master Touch
genres: Thriller, Action, Crime
overview: A master thief, just out of prison, concocts a risky final score that would net him over a million dollars.

---
title: Trance
genres: Thriller, Crime, Drama, Mystery
overview: A violent gang enlists the help of a hypnotherapist in an attempt to locate a painting which somehow vanished in the middle of a heist.

---
title: In Dreams
genres: Mystery, Thriller, Horror
overview: A suburban housewife learns that she has psychic connections to a serial killer, and can predict this person's motives through her dreams.

Step 6: Qdrant client

On this url http://localhost:6333/dashboard you may access Qdrant's dashboard. It allows you to visualize and query your vector database, inspect collections, and explore stored points.

<p class="alt">Qdrant collections</p>

<p class="alt">Qdrant point example</p>

The Qdrant API provides query operations, such as listing collections:

// List all collections
GET collections

Which returns:

{
  "result": {
    "collections": [
      {
        "name": "movies"
      }
    ]
  },
  "status": "ok",
  "time": 0.000262373
}

You can also retrieve points using filters:

POST collections/movies/points/scroll
{
  "limit": 10,
  "filter": {
    "must": [
      {
        "key": "title",
        "match": {
          "any": [
            "Star Wars"
          ]
        }
      }
    ]
  }
}

This returns points matching the filter:

{
  "result": {
    "points": [
      {
        "id": 11,
        "payload": {
          "movie_id": 11,
          "imdb_id": "tt0076759",
          "title": "Star Wars",
          "overview": "Princess Leia is captured and held hostage by the evil Imperial forces in their effort to take over the galactic Empire. Venturesome Luke Skywalker and dashing captain Han Solo team together with the loveable robot duo R2-D2 and C-3PO to rescue the beautiful princess and restore peace and justice in the Empire.",
          "genres": "Adventure, Action, Science Fiction",
          "popularity": 88.559,
          "vote_average": 8.204,
          "vote_count": 19155,
          "runtime": 121,
          "adult": false,
          "release_date": "1977-05-25"
        }
      }
    ],
    "next_page_offset": null
  },
  "status": "ok",
  "time": 0.024117376
}

RAG

We now have a vector database containing a few movie points. Let's build the Retrieval-Augmented Generation part.

Step 0: Install the tools

The last tool we need is Chainlit, which will provide the chat interface for interacting with our RAG.

We also need to download the LLM:

ollama pull llama3.1:8b

And a few more Python libraries:

uvicorn - ASGI web server implementation for Python
chainlit - framework for building conversational AI interfaces
fastapi - web framework for building APIs

We're installing them with uv:

uv add uvicorn chainlit fastapi

Step 1: Chainlit

We'll use Chainlit only as the user interface layer. It receives messages from the user and forwards the queries to the FastAPI backend that we will create next.

@cl.on_message is a Chainlit event handler that runs every time the user sends a message.


API_URL = "http://app:8000/ask"


@cl.on_message
async def main(message: cl.Message):
    response = requests.post(
        API_URL,
        json={"question": message.content},
        timeout=120,
    )

    if response.status_code != 200:
        await cl.Message(content="Error calling API").send()
        return

    answer = response.json()["answer"]

    await cl.Message(content=answer).send()

Step 2: Building our app's API

We need a FastAPI backend that responds to the /ask route when we send a message from Chainlit.

When we receive a message, we want to:

Convert the user's text into an embedding.
Search Qdrant for similar movie points.
Build a context from the retrieved movies.
Send this context to the LLM and ask it to generate an answer.

This is the main RAG pipeline: retrieval + generation.

from fastapi import FastAPI
from pydantic import BaseModel

from src.embeddings.httpEmbedding import embedText
from qdrant_client import QdrantClient

app = FastAPI()

qdrant = QdrantClient(url="http://qdrant:6333")
OLLAMA_URL = "http://ollama:11434"


class AskRequest(BaseModel):
    question: str


def search_qdrant(vector: list[float], top_k=5):
    results = qdrant.query_points(
        collection_name="movies",
        query=vector,
        limit=top_k,
        with_payload=True,
    )
    return results.points


def build_context(points):
    context = []
    for p in points:
        payload = p.payload
        context.append(
            f"{payload.get('title')}: {payload.get('overview')}"
        )
    return "\n\n".join(context)


def generate_answer(question, context):
    prompt = f"""
You are a movie recommendation system.

Use ONLY the context below.

Context:
{context}

User question:
{question}

Answer:
"""

    response = requests.post(
        f"{OLLAMA_URL}/api/generate",
        json={
            "model": "llama3.1:8b",
            "prompt": prompt,
            "stream": False,
        },
    )

    response.raise_for_status()
    return response.json()["response"]


@app.post("/ask")
def ask(req: AskRequest):
    vector = embedText(req.question)
    matches = search_qdrant(vector)
    context = build_context(matches)
    answer = generate_answer(req.question, context)

    return {
        "question": req.question,
        "answer": answer,
    }

The app is run with the following command:

uvicorn src.api.client:app --host 0.0.0.0 --port 8000 --reload

Step 3: Using our RAG

We now have a functional RAG application and can start asking questions about movies.

I verified in the database that the returned movies are stored in Qdrant, have a rating above 6.5/10, and were released between 2010 and 2020.

What next

I cleaned up the code, added a linter (Ruff), a type checker (ty), some tests, a GitHub pipeline, and tidied up my Makefile, Docker, and Compose setup. Here is the repository at the moment.

At this point, we have a working RAG system, but there is still a lot we could improve.

1. Ingestion

Qdrant currently contains 200 movies, but the full dataset contains around 1 million entries.

I tried ingesting more data, but I ran into a performance issue: ingestion is very slow. I ingested around 40k points in an hour, which means the full dataset would take roughly 25 hours.

During ingestion, my machine is running at full capacity. There are a few things I could try:

Sending batches of movies instead of one movie at a time
Checking whether running Ollama outside Docker improves performance
Using a more powerful machine or a remote server for the embedding process

2. Chat memory

The LLM currently has no awareness of previous conversations.

A possible improvement would be to send Chainlit's chat_context to the /ask route, allowing the model to use previous messages when answering follow-up questions.

3. Reranking

Currently, we retrieve 5 points from Qdrant. A possible improvement would be to retrieve more candidates (for example 20) and rerank them before sending the final context to the LLM.

The closest embedding is not always the most relevant movie.

A reranker model (for example a cross-encoder) could compare the user query with each retrieved movie and select the best matches.

4. Hybrid search

We could combine semantic search with lexical search.

Semantic search understands concepts. For example:

"Give me a movie like Avatar"

A vector search can understand: Avatar → blue aliens → another planet → nature → science fiction

However, lexical search can directly match the word Avatar

For instance "Give me a movie like Avatar". Vector search understands "Avatar -> blue aliens -> planet -> nature -> sci-fi". While exact keyword will match "Avatar" directly.

This is useful when users mention exact movie titles, actors, or keywords. Qdrant supports sparse vectors, which could be combined with dense vectors to create a hybrid search system.

5. Validation

My current prompt says:

"Use ONLY the context below"

but this is only a soft instruction. The LLM could still hallucinate a movie that does not exist in the database.

A possible improvement would be to include movie IDs in the retrieved context and validate the generated answer against the database.

Another option would be to use a second LLM as a validator, but that feels unnecessary for this project (and would increase the hardware requirements).

6. Evals

We could add evaluations with a tool such as Ragas to measure RAG quality.

The test data could look like:

[
 {
  "question": "movie about space survival",
  "expected": [
    "Interstellar",
    "The Martian"
  ]
 },
 {
  "question": "sad romance movies",
  "expected": [
    "Titanic"
  ]
 }
]

This would allow us to measure whether changes improve or degrade the system.

7. More ideas

Other possible improvements:

Use an LLM for query rewriting so the user's question is transformed into a better search query
Create a user profile to personalize recommendations based on preferences
Use metadata filters for structured data such as dates, ratings, runtime, and popularity
Add a recommendation score combining semantic similarity with movie metadata

Making sense of AI taxonomy

Sun, 07 Jun 2026 00:00:00 GMT

I have been looking for diagrams that classify AI types, methods, and definitions. It feels like no one agrees on the definitions. Every diagram differs from one source to another. Instead of helping me understand the field as a whole, it confused me even more.

I decided to make my own, with Wikipedia, React Flow, and time.

I am certain there are many things I have missed, but this was my first step toward understanding the big picture. If you spot any mistakes, please feel free to contact me at me@kaonashi.dev.

Some thoughts after doing this exercise: AI taxonomy should be a huge graph with connections going in all directions, or lots and lots of smaller diagrams. Here I mixed paradigms, architectures, models, learning methods and so on so I could make a mental map of it all.

You may click on boxes to get a definition.

Building my first AI with PyTorch

Mon, 01 Jun 2026 00:00:00 GMT

I wanted to build my own AI for a while. I used different types of AI at work (symbolic NLU, RAG, OCR, STT, TTS, agents, and LLMs), but I never truly understood what was happening behind the scenes.

My brother studied this field, so I asked him to guide me through building one.

We chose a very serious and important problem: distinguishing dogs from muffins.

Apparently, it's a classic exercise taught in engineering schools, and a dataset already exists for it.

My goal was to satisfy my curiosity about how models are built, learn some of the vocabulary, and understand the environment and tools required for this kind of project.

For this project, we will use machine learning, more specifically, deep learning. Since we have labeled examples of dogs and muffins, this is a supervised learning task. To solve it, we will build a Convolutional Neural Network (CNN).

Vocabulary

To understand each other, we first needed a little of AI vocabulary. I'll go through what we discussed.

A CNN is a type of neural network used for images.

Instead of looking at the whole image at once, it looks at small parts of the image first (like edges, shapes, and textures), then combines them to understand more complex patterns.

For example:

First layers detect simple things like lines or borders
Middle layers detect shapes like ears or eyes
Later layers combine these into full objects like "dog" or "muffin"

This step-by-step feature detection makes CNNs very effective for image classification tasks.

<p class="alt">A CNN Architecture, source</p>

Supervised learning is a type of machine learning where a model learns from labeled examples.

Each training example includes:

an input (data)
the correct output (label)

The model's job is to learn the relationship between inputs and outputs so it can predict the correct output for new, unseen inputs.

Example: If you show a model many emails labeled "spam" or "not spam," it learns patterns and can then classify new emails.

A GAN is a model that generates new data, such as images.

It has two parts:

Generator: creates fake data
Discriminator: tries to detect real vs fake

They train against each other, and over time the generator learns to produce more realistic results.

A Recurrent Neural Network (RNN) is a type of neural network designed to work with sequences of data, where order matters.

Unlike CNNs (which focus on images), RNNs process data step by step while keeping a kind of "memory" of what they have seen before. This makes them useful for things like text, speech, or time series.

For example, in a sentence, each word depends on the previous ones. An RNN can use earlier words to help understand the current word.

Example: Tesseract (OCR)

Tesseract is an OCR (Optical Character Recognition) system that reads text from images. Internally, systems like this can use sequence-based models (like RNNs or similar architectures) to interpret characters in order, forming words and sentences from visual input.

This is useful because text is not just individual symbols-it is a sequence where context matters.

A token is a basic unit of input data that a model processes.

In text models: a token is usually a word, part of a word, or a character chunk. Example: "unbelievable" might be split into tokens like "un", "believ", "able". In vision models (less common usage of the term): "tokens" can refer to patches of an image (especially in Vision Transformers), where an image is divided into small regions.

In other words, tokens are what the model reads as input.

A parameter is a learned internal value inside the neural network that determines how input is transformed into output.

Parameters include weights and biases in layers (including CNN convolution filters). In CNNs: A filter (kernel) is a set of parameters that learns to detect patterns like edges, textures, or shapes. These values are adjusted during training through backpropagation.

To summerize, parameters are what the model learns during training.

A loss function is a way to measure how wrong the model's predictions are.

It compares the model's output with the correct answer and gives a single number:

small value → the model is doing well
large value → the model is doing poorly

During training, the goal is to reduce the loss as much as possible, so the model gradually improves its predictions.

A label is the correct answer for a given input.

For example, if the input is an image of a cat, the label is "cat". It represents the truth that the model is supposed to learn from.

During training, the model's prediction is compared to the label to see if it is correct or not.

A feature is a small piece of information in the input that helps the model make a prediction.

In images, features can be simple things like edges, corners, textures, or shapes (for example: an ear, an eye, or a border).

The model combines many small features to understand the full object, like recognizing a cat or a muffin.

In the machine learning field, Data engineering is the process of preparing raw data so it can be used by a model.

This includes cleaning the data (removing errors or missing values), organizing it, and sometimes creating new useful information from it (called feature engineering).

Feature engineering means transforming raw data into better inputs for the model. For example, instead of only using sales numbers, we might add a feature like "holiday = yes/no" if sales tend to increase during holidays.

Transfer learning is when we take a model that has already been trained on a large dataset and reuse it for a new task.

Instead of training from scratch, we keep the learned knowledge (like basic patterns in images) and adapt it to a smaller, specific dataset.

This is useful because the model already knows general features, so it needs less data and less training time to learn the new task.

An agent is a system (often an AI model) that can take a goal and decide what actions to take to achieve it.

Instead of just producing an answer directly, an agent can:

write or run code
use tools or APIs
call external systems or scripts
combine multiple steps to solve a problem

For example, if asked to analyze data, an agent might first load a file, then run code to clean it, then compute results, and finally produce a summary.

Inference is when we use a trained model to make a prediction.

It is the step where we give the model new input data, and it produces an output (a result).

For example:

input: an image of a cat
inference output: "cat"

Inferences doe not change the model. It only uses what the model has already learned.

A generative pre-trained transformer (GPT) is a type of large language model (LLM).

A Transformer is a type of neural network used for sequences like text.

It works by looking at all words in a sentence at the same time and deciding which words are important to understand the meaning.

The key idea is attention: the model learns which parts of the input to focus on when making a prediction.

This makes Transformers very effective for language tasks like translation, text generation, and chat models.

A system prompt is the first instruction given to an AI model before any user input.

It defines how the model should behave, such as its tone, rules, or role.

For example, it can tell the model to be formal, concise, or to follow specific constraints. The system prompt is always applied before the user's message.

RAG is a method that improves a language model by giving it access to external information.

Instead of only using what the model learned during training, it first retrieves relevant data from a database or documents, and then uses that information to generate an answer.

This helps the model give more accurate and up-to-date responses, especially for specific or recent information.

ReLU is an activation function used in neural networks.

It decides what information should pass through the network by changing values:

if the input is positive → keep it
if the input is negative → replace it with 0

This helps the model learn faster and adds non-linearity, which allows it to learn more complex patterns.

More resources

My brother also recommended these videos:

Neural Networks explained
The Dark Matter of AI [Mechanistic Interpretability]. This one felt a bit too advanced for me yet.

Tools

We use a public image dataset from Kaggle:

The dataset is structured in a simple folder format, where each class has its own directory. This makes it compatible with PyTorch's ImageFolder, which automatically assigns labels based on folder names.

Our dataset hierarchy looks like:

data/
|-- test/
|   |-- chihuahua/
|   `-- muffin/
`-- train/
    |-- chihuahua/
    `-- muffin/

This structure separates training and testing data, allowing us to train the model on one set of images and evaluate it on unseen examples.

Tools used:

Python
VS Code IDE
Jupyter Notebook Plugin for VSCode

Python libraties:

torch==2.12.0  # (model building and training)
torchvision==0.27.0  # (image loading and transformations)
matplotlib==3.10.9  # (image file handling)
pillow==12.2.0  # (visualization)

To install the dependencies, we first create a Python virtual environment. This isolates the project so that its packages do not interfere with other Python installations on the system. Back here a month later, you may use uv to handle dependencies easily

python -m venv venv
source venv/bin/activate
pip install -r requirements.txt

Let's build

If you wish to access the notebook directly, here is my GitHub repository.

First we create a notebook.ipynb file.

We import PyTorch here to confirm the environment is set up correctly before going further.

We prepare an image so it can be used as input for a neural network. Machine learning models cannot work directly with raw image files, so the image must first be converted into a numerical format they can process.

The image is resized to 224x224 because most neural networks require inputs of a fixed size. Without this step, images of different dimensions would not be compatible with the model.

Next, the pixel values are scaled to a range between 0 and 1 and converted into floating-point numbers. This makes the data easier and more stable for the model to learn from, since very large integer values (0-255) can slow down or destabilize training.


from pathlib import Path
from typing import cast
from PIL import Image

PATH: Path = Path("./data/test/chihuahua/img_4_568.jpg")

img: Image.Image = Image.open(PATH).convert("RGB")

transform: transforms.Compose = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToImage(),
    transforms.ToDtype(torch.float32, scale=True),
])

img_tensor: torch.Tensor = cast(torch.Tensor, transform(img))

_, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4))

ax1.imshow(img)
ax1.set_title("Original")
ax1.axis("off")

ax2.imshow(img_tensor.permute(1, 2, 0).numpy())
ax2.set_title("Transformed (224x224)")
ax2.axis("off")

plt.tight_layout()
plt.show()

Output:

We create training and testing datasets so the model can learn from one set of images and be evaluated on another it has not seen before. This separation is important because it lets us measure how well the model generalizes to new data instead of just memorizing the training images.

We use ImageFolder, which automatically reads images from folders where each class has its own directory. This makes it easy to assign labels based on folder names without manually labeling each image.

We apply the same transformations as before to ensure all images have the same size and format, and that pixel values are scaled between 0 and 1. This consistency is necessary so the model receives data in a uniform structure during both training and testing.

Finally, we print class_to_idx to see how class names (folder names) are mapped to numeric labels, which is what the model actually uses internally.

from torchvision import datasets
from torchvision.datasets import ImageFolder

transform: transforms.Compose = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.ToDtype(torch.float32, scale=True),
])

train_dataset: ImageFolder = datasets.ImageFolder(
    root="./data/train",
    transform=transform,
)

test_dataset: ImageFolder = datasets.ImageFolder(
    root="./data/test",
    transform=transform,
)

class_to_idx: dict[str, int] = train_dataset.class_to_idx
print(class_to_idx)

Output:

{'chihuahua': 0, 'muffin': 1}

We create data loaders to feed images into the model in small groups called batches. Neural networks do not process one image at a time efficiently, so batching helps speed up training and makes better use of memory.

We set batch_size=32, which means the model will process 32 images at once before updating its weights. This improves training stability compared to processing single images.

We shuffle the training data so the model sees images in a different order each epoch, which helps prevent it from learning patterns based on the order of the data. We do not shuffle the test data because we want consistent evaluation results.

Finally, we load one batch from the training loader to check that everything works correctly. The image tensor shape shows 32 images with 3 color channels and 224x224 size, and the label tensor shows one label per image.

from torch.utils.data import DataLoader

train_loader: DataLoader[tuple[torch.Tensor, torch.Tensor]] = DataLoader(
    train_dataset,
    batch_size=32,
    shuffle=True,
)

test_loader: DataLoader[tuple[torch.Tensor, torch.Tensor]] = DataLoader(
    test_dataset,
    batch_size=32,
    shuffle=False,
)

images: torch.Tensor
labels: torch.Tensor
images, labels = next(iter(train_loader))

print(images.shape)
print(labels.shape)
print(labels)

Output:

torch.Size([32, 3, 224, 224])
torch.Size([32])
tensor([0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0,
        0, 0, 0, 0, 0, 1, 1, 1])

We define a convolutional neural network (CNN) to learn patterns in images and classify them into two categories. The convolution layers act as feature extractors, detecting simple patterns like edges and textures first, then combining them into more complex features. Pooling layers reduce the spatial size of the image, which makes the model more efficient and helps it focus on the most important information.

After feature extraction, we flatten the data and pass it through fully connected layers, which act like a decision-maker. These layers take the extracted features and learn how they relate to the final classes. The last layer outputs two values, one for each class, which the model uses to make a prediction.


class SnifferCNN(nn.Module):
    def __init__(self) -> None:
        super().__init__()

        self.conv_layers = nn.Sequential(
            nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )

        self.fc_layers = nn.Sequential(
            nn.Flatten(),
            nn.Linear(32 * 56 * 56, 128),
            nn.ReLU(),
            nn.Linear(128, 2),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.conv_layers(x)
        x = self.fc_layers(x)
        return x

We create the model and move it to the CPU so it is ready to process data. Printing the model shows its full structure, including all layers and their order. This helps us verify that the network was built correctly and understand how input data flows through it from convolution layers to the final classification output.

device: torch.device = torch.device("cpu")
model: SnifferCNN = SnifferCNN().to(device)
print(model)

Output:

SnifferCNN(
  (conv_layers): Sequential(
    (0): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (4): ReLU()
    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (fc_layers): Sequential(
    (0): Flatten(start_dim=1, end_dim=-1)
    (1): Linear(in_features=100352, out_features=128, bias=True)
    (2): ReLU()
    (3): Linear(in_features=128, out_features=2, bias=True)
  )
)

We define the loss function and the optimizer, which are two key parts of training a neural network.

The loss function measures how wrong the model's predictions are compared to the true labels. Here we use CrossEntropyLoss, which is commonly used for classification problems (like deciding which class an image belongs to).

The optimizer controls how the model learns from that error. We use Adam, which updates the model's parameters step by step to reduce the loss over time.

The learning rate (lr=0.001) controls the size of each update step:

If it is too high, the model changes too aggressively and may miss the best solution.
If it is too low, learning becomes very slow.

Together, the loss function and optimizer define how the model improves during training.


loss_function: nn.CrossEntropyLoss = nn.CrossEntropyLoss()
optimizer: optim.Adam = optim.Adam(
    model.parameters(),
    lr=0.001,
)

We train the model by showing it many batches of images and gradually adjusting its internal parameters to reduce errors. Each epoch means one full pass through the training dataset.

For each batch, we send the images through the model to get predictions, then compare those predictions to the correct labels using the loss function. This tells us how wrong the model is.

We then reset previous gradients, compute new gradients using backward(), and update the model using the optimizer. This is the step where the model actually learns by slightly adjusting its weights.

At the end of each epoch, we compute the average loss. A decreasing loss over time indicates that the model is improving its predictions.

epochs: int = 5

epoch: int
for epoch in range(epochs):
    model.train()
    total_loss: float = 0.0

    batch_images: torch.Tensor
    batch_labels: torch.Tensor
    for batch_images, batch_labels in train_loader:
        batch_images = batch_images.to(device)
        batch_labels = batch_labels.to(device)

        outputs: torch.Tensor = model(batch_images)
        loss: torch.Tensor = loss_function(outputs, batch_labels)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_loss += loss.item()

    print(f"Epoch {epoch + 1}, Loss: {total_loss / len(train_loader):.4f}")

Output:

Epoch 1, Loss: 0.6052
Epoch 2, Loss: 0.3601
Epoch 3, Loss: 0.2964
Epoch 4, Loss: 0.2346
Epoch 5, Loss: 0.1701

We test the model by switching it into evaluation mode so it behaves correctly during inference (for example, disabling training-specific behavior like dropout if it existed).

We take a single image from the test dataset and prepare it in the same format the model expects. Since the model processes batches, we add an extra dimension so the image becomes a batch of size 1.

We then run the image through the model without tracking gradients, because we are not training anymore. The model outputs scores for each class, and we select the class with the highest score as the prediction.

Finally, we compare the predicted label with the true label and display the image along with both values so we can visually check whether the model is performing correctly.

model.eval()

image: torch.Tensor
label: int
image, label = test_dataset[0]

image_input: torch.Tensor = image.unsqueeze(0).to(device)

with torch.no_grad():
    output: torch.Tensor = model(image_input)
    predicted: torch.Tensor
    _, predicted = torch.max(output, 1)

true_class: str = test_dataset.classes[label]
predicted_class: str = test_dataset.classes[predicted.item()]

print("True label:", true_class)
print("Predicted:", predicted_class)

title: str = f"True: {true_class} | Pred: {predicted_class}"

plt.imshow(image.permute(1, 2, 0).numpy())
plt.title(title)
plt.axis("off")
plt.show()

Output:

True label: chihuahua
Predicted: chihuahua

We evaluate the model on multiple random test images to get a better sense of its behavior instead of looking at just one prediction.

We first switch the model to evaluation mode so it behaves consistently during inference. Then we randomly select 10 images from the test dataset to avoid bias and to see varied examples.

For each image, we prepare it in the correct format by adding a batch dimension and passing it through the model without computing gradients. The model outputs raw scores, which we convert into probabilities using softmax so we can interpret them as confidence levels for each class.

We then display each image along with its true label and the model's predicted probability for every class. This makes it easier to see not only whether the model is correct, but also how confident it is in its predictions.

model.eval()

indices: list[int] = random.sample(range(len(test_dataset)), 10)

plt.figure(figsize=(14, 10))

i: int
idx: int
for i, idx in enumerate(indices):
    image: torch.Tensor
    label: int
    image, label = test_dataset[idx]

    input_tensor: torch.Tensor = image.unsqueeze(0).to(device)

    with torch.no_grad():
        output: torch.Tensor = model(input_tensor)
        probabilities: torch.Tensor = F.softmax(output, dim=1)[0]

    prob_text: str = "\n".join(
        f"{name}: {probabilities[j].item():.2f}"
        for j, name in enumerate(test_dataset.classes)
    )

    true_class: str = test_dataset.classes[label]

    plt.subplot(2, 5, i + 1)
    plt.imshow(image.permute(1, 2, 0).numpy())
    plt.title(f"True: {true_class}\n{prob_text}", fontsize=8)
    plt.axis("off")

plt.tight_layout()
plt.show()

Output:

We use this code to test the model on completely new images and understand how it behaves on real inputs outside the dataset.

We first collect all images from a folder and load the trained model in evaluation mode so predictions are consistent. Each image is preprocessed using the same transformations as during training so the model receives data in the correct format.

For each image, we run inference to get both the predicted class and the probability for each possible class. These probabilities come from applying softmax, which converts raw model scores into values between 0 and 1 that sum to 1.

We then visualize three things side by side: the original image, the transformed version that the model actually sees, and a bar chart showing the model's confidence for each class. This helps us understand not only what the model predicts, but also how certain it is.


img_paths: list[Path] = sorted(Path("./data/others").glob("*.jpg"))
img_paths: list[Path] = sorted(
    p for ext in ("*.jpg", "*.jpeg", "*.png")
    for p in Path("./data/others").glob(ext)
)

model.eval()

n_cols: int = 3
n_rows: int = len(img_paths)
plt.figure(figsize=(15, 5 * n_rows))

img_path: Path
for i, img_path in enumerate(img_paths):
    image: Image.Image = Image.open(img_path).convert("RGB")
    image_tensor: torch.Tensor = cast(torch.Tensor, transform(image))

    input_tensor: torch.Tensor = image_tensor.unsqueeze(0).to(device)

    with torch.no_grad():
        output: torch.Tensor = model(input_tensor)
        predicted: torch.Tensor
        _, predicted = torch.max(output, 1)
        probabilities: torch.Tensor = F.softmax(output, dim=1)

    class_name: str = test_dataset.classes[predicted.item()]

    probs: list[float] = [p.item() for p in probabilities[0]]

    # left: original image
    plt.subplot(n_rows, n_cols, i * n_cols + 1)
    plt.imshow(image)
    plt.title(f"Original\n{img_path.name}", fontsize=9)
    plt.axis("off")

    # middle: transformed image (denormalized for display)
    plt.subplot(n_rows, n_cols, i * n_cols + 2)
    plt.imshow(image_tensor.permute(1, 2, 0).numpy())
    plt.title(f"Transformed\nPrediction: {class_name}", fontsize=9)
    plt.axis("off")

    # right: probability bar chart
    plt.subplot(n_rows, n_cols, i * n_cols + 3)
    plt.barh(test_dataset.classes, probs)
    plt.xlim(0, 1)
    plt.xlabel("Probability")
    plt.title("Class probabilities", fontsize=9)

plt.tight_layout()
plt.show()

Output:

We evaluate the model on the test dataset to measure how well it generalizes to unseen data. We switch the model to evaluation mode so it behaves correctly during inference, and we disable gradient tracking because no learning happens during testing.

We loop through the test data in batches, pass each batch through the model, and take the class with the highest score as the prediction. We compare predictions with the true labels and keep a running count of correct predictions and total samples.

We then compute accuracy by dividing correct predictions by the total number of samples. This gives a single metric that summarizes model performance on the test set.

Finally, we also print the total number of trainable parameters in the model to understand its size and complexity.

model.eval()

correct: int = 0
total: int = 0

with torch.no_grad():
    batch_images: torch.Tensor
    batch_labels: torch.Tensor
    for batch_images, batch_labels in test_loader:
        batch_images = batch_images.to(device)
        batch_labels = batch_labels.to(device)

        outputs: torch.Tensor = model(batch_images)

        predicted: torch.Tensor
        _, predicted = torch.max(outputs, 1)

        total += batch_labels.size(0)
        correct += int((predicted == batch_labels).sum().item())

accuracy: float = correct / total
print(f"Test Accuracy: {accuracy:.4f}")

total_params: int = sum(p.numel() for p in model.parameters())
print(f"Total parameters: {total_params:,}")

Output:

Test Accuracy: 0.8446
Total parameters: 12,850,530

The test accuracy of 0.8446 means the model correctly classified about 84.46% of the images in the test dataset. This gives an estimate of how well the model generalizes to new, unseen data. The remaining errors show cases where the model made incorrect predictions, which can happen due to similar-looking classes, limited training data, or model limitations.

The model has 12,850,530 parameters, which represents the number of learnable weights and biases inside the network. This value reflects the model's capacity: more parameters allow the model to learn more complex patterns, but also increase memory usage and the risk of overfitting if the dataset is too small.

For comparison:

This model: ~13 million parameters Small language models (like BERT-base): ~110 million parameters (about 8x bigger) Large language models (like GPT-3): ~175 billion parameters (over 10,000x bigger) Very large modern models: even larger, but exact sizes are not always public

So this image model is relatively small compared to modern language models, but still large enough to learn useful visual patterns.

Going further

There are several practical ways to improve this image model and deepen my understanding of how larger models work.

more parameters (animals): Make the model bigger (more layers or filters). This can help it learn more detailed patterns, like differences between similar animals, but it also needs more data.
add normalization: Standardize the input data so values are in a consistent range. This usually makes training more stable and faster.
larger dataset (fine tuning): Train on more images or start from a model that was already trained on a large dataset. Then adjust it for your specific task, similar to how LLMs are adapted for different uses.
Data augmentation: Create variations of training images (flip, rotate, crop, color change). This helps the model generalize better and reduces overfitting.
More training epochs + monitoring loss: Train longer while tracking validation loss to avoid stopping too early or overfitting.
Better model architecture: Replace the simple CNN with a pretrained model like ResNet or EfficientNet. These are much stronger and already trained on large datasets.
Learning rate tuning: Try different learning rates. Small changes can significantly affect performance.
Validation set: Split test data into validation + test. Validation is used during training to tune settings, test is only for final evaluation.

Thoughts

This exercise was done in an afternoon. I am happy I did it, it helped me gain vocabulary, understand what an example setup looks like, and get a first practical sense of how a model is created and trained.

I feel like there is still a lot more to understand because there are many different types of neural network models, and PyTorch does most of the heavy lifting. I have yet to truly understand the maths behind the library's functions, which is probably the next important step.

Reclaiming my time

Mon, 30 Mar 2026 00:00:00 GMT

I was talking to a Gen Z friend the other day about our phone screen time, specifically social media such as TikTok and Instagram. She mentioned hers was over 10 hours a week, which is a little less than a full waking day. That's enormous ! She justified it by saying it's mostly commute time, and the rest of the time spent is done volontary. But is it really ?

Will versus Dark Patterns

Those platforms make money from your time and data. You log in, post and read content, see ads, and your behavior is shared so you can be shown more relevant ads. How did they get you to spend time on those platforms?

Thousands of brilliant brains have worked for years on how to make you stay on social media. The design is a well thought out loop. Infinite scrolling without friction delivers quick and variable rewards which are thought to engage the brain reward system, with feeds tailored to your preferences. This can be compared to a Skinner Box with extra steps, and you're the rat.

Can we talk about social media addiction then? I dug a little and found a meta analysis titled "Prevalence of social media addiction across 32 nations: Meta-analysis with subgroup analysis of classification schemes and cultural values". Its sources come from 63 independent samples with 34,798 respondents from 32 nations spanning seven world regions.

Here is the summary:

The pooled prevalence estimate was 5% (95% CI: 3%-7%) for studies adopting monothetic or strict monothetic classifications. A higher pooled prevalence estimate (13%; 95% CI: 8%-19%) was found for studies adopting a cutoff for severe level or strict polythetic classifications, and that estimate was even higher (25%; 95% CI: 21%-29%) for studies adopting a cutoff for moderate level or polythetic classifications.

In simpler words, researchers look at social media addiction using six signs: Thinking about it constantly, using it to change mood, needing more and more, feeling bad when you cannot use it, it causing problems in life, and going back to heavy use after trying to stop. Depending on how strictly you define addiction, between 5% and 25% of people meet the criteria. At most, one in four people could be considered addicted.

You can check BSMAS Test on the internet if you're curious about your addiction level. Note that messenging apps do count. This one is an example which does not require login but does store anonymous cookies.

But maybe you are not one of those people. Maybe you are not addicted. So it must be fine to use social media as you please, right? Now what if there were other effects beyond using your time and selling your data?

Shorts and the brain

The other day I stumbled upon (or, youtube algorithm chose that I watch) this video, "TikTok and the brain: what 70 studies really say". The channel Scilabus is run by a doctor in science communication who explains scientific subjects. The video discusses a meta analysis titled "Feeds, Feelings, and Focus: A Systematic Review and Meta-Analysis Examining the Cognitive and Mental Health Correlates of Short-Form Video Use" which includes data from 98,299 participants across 71 studies.

If you do not want to read the full paper, here are some key points:

This systematic review and meta-analytic investigation found that SFV (Short-Form Video) use was associated with poorer cognition (attention, inhibitory control, language, memory, and working memory) and most mental health indices except body image and self-esteem.
Moderator analyses revealed that these associations were consistent across youth and adult populations but were strongest when SFV use was measured via addiction scales and when general SFV use (as opposed to TikTok-specific use) was assessed.
The continuous cycle of swiping and receiving new, emotionally stimulating content has been proposed to trigger dopamine release, creating a reinforcement loop that contributes to patterns of habitual use and greater emotional reliance on digital interactions.
Tasks requiring prolonged concentration (e.g., reading comprehension, complex problem solving) may be more difficult to sustain, especially as SFV platforms reinforce brief, high-reward interactions through rapid feedback and algorithmic content delivery.

I did not start by reading meta analyses though. I started with simple steps to break the habit so I could spend time on things I value more.

Analysis of my screen time

My screen time in a week was high considering I work on a computer all day. Add scrolling during commute time on Instagram and Reddit, plus messaging apps such as Messenger, WhatsApp, and Signal. Add bad days where I came home and scrolled until I manage to get up from the couch. All combined, I reached up to eight hours a week on my phone.

Screen time information is easy to find. Apple and Android provide it in settings. I started checking it every week, which made me realize how much time I was spending.

Adding friction

Countering seamless navigation is simple. You add friction and force yourself to think.

I set up three methods:

First, I added a daily limit of one hour for Reddit and Instagram. After an hour, the phone asks whether to continue. It is small, but it creates a break.
Second, my boyfriend would ask what I was doing when I stayed on my phone too long. Then he would ask if I was enjoying my time. That worked only when we were together.
Third, and most effective, was an app called OneSec. I set it to trigger every ten minutes and when opening Reddit or Instagram. It asks you to breathe for a few seconds before access. I used it for a year. It prevented me from opening those apps 2569 times, which it estimates as 5.4 days saved.

My usage decreased by half. I barely used Instagram and preferred text on Reddit.

I also watched a video titled "You're not addicted to tiktoks/reels, you're addicted to the scrolling". She describes opening Reddit through browser tabs sorted by top of the month. The content gradually becomes less interesting, so the brain receives fewer rewards. That's a little tedious but seems to work well for her.

I also asked myself whether I was enjoying my time. The answer was not much. On Instagram, I saw cute animals, a few places, some hobbies. It became repetitive. Reddit often pushed stressful news instead of something pleasant. I don't care to see that the US president shat himself publicly once again. So on the whole, I was more being stressed by grave news than happy to see kittens.

I must also recommend this article, An argument for logging off, which tries to make you think about the influence you have over the information you get in you daily life.

Caring about something over which you have no agency is stressful

Unless you intend to influence national politics, what is the point of checking every day?

Data Awareness Prompted the Uninstall

At some point, Meta updated their privacy policy. When I logged into Instagram I received a notification.

That was a wake up call. They let you choose to be the product or the customer. I read their privacy policy to understand what that meant. It took hours of reading and searching. I will go into more detail in a future post.

After that, I uninstalled Instagram. I also installed Signal and encouraged friends to switch. Their privacy policy is quite straight foreward, it states:

Privacy of user data. Signal does not sell, rent or monetize your personal data or content in any way - ever.

Further steps

At that point, I was free from Instagram doomscrolling, and almost free from short videos. Almost. I do use YouTube on my desktop computer, and since 2020 YouTube Shorts have been taking more and more space on the website. I would sometimes get lost in them for an hour instead of relaxing properly. I installed the extension Remove YouTube Shorts, which simply hides them from sight. Booyah, no more easy access to shorts !

My daily commute totals two hours. I used to organize my life during that time, and when that was done I would go on social media. I tried phone games and puzzles, but my interest never lasted long. I invested 100€ in an e-reader that fits in my pocket. It has been a good decision so far, I now spend that time reading books I enjoy.

A few months ago I got the flu and spent the day lying on the couch scrolling through Reddit. At the end of the day I felt I had wasted it, letting my brain rot and not even resting properly. I decided to uninstall Reddit the next day. At that point I had no more apps to scroll. Since then I have not felt the need to go back. I occasionally spend a few minutes on Reddit's website when I am waiting for something without my e-reader available.

There are a few more distractions I try to remove. One is email spam. I unsubscribe from every newsletter. I repeat this every few years to make sure I am only bothered for a reason. Another is phone calls. France has a service called Bloctel which helps with cold calls. On top of that, I use a French app called Orange Phone. I gave it access to incoming numbers, and it blocks unwanted calls reported by users. I have had good results with it.

So what's next ? I still use messaging apps daily to communicate with friends and I enjoy doing so. One thing still bothers me, the disruptiveness of notifications. If my phone is beside me and I see it light up, my brain pauses and shifts focus. Even though I keep it in silent mode most of the time, seeing the screen is enough to interrupt my train of thought. The solution is simple. I need to keep my phone away more often and pick it up only when I intend to.

Final thoughts

Time is one of the only finite resource you possess, you should use it to do things that make you happy and/or proud. I hope reading this helped questioning your own usage of social media.

Why a blog

Tue, 03 Mar 2026 00:00:00 GMT

This post is a wink at Why a blog by Krayorn.

How I started writing

I won't lie, the main reason I worked on a blog is that Krayorn harassed me about making one. He's even been boasting about it here.

But let's get back a little further than that. Two years ago, I had a rather philosophical debate (still with Krayorn) about positivity and negativity, and how to become more positive.

To put this in context, I'm a very fact-driven person, which is, I think, a great advantage in the tech world. Say you have made a feature for your app, you'll need to think of all the cases that could go wrong to prevent them from happening. Well, I think I'm doing ok applying Murphy's law.

The drawbacks of this are:

I may become a downer for others: instead of hyping up a project, I'll state everything that could go wrong.
When presenting my own projects, I'll want to start with everything I messed up rather than simply listing what I've accomplished, because I convince myself it's better to be factual and truthful. Because of this alone, I'd make a terrible salesperson.
Sometimes, it becomes an easy excuse to simply be negative on some subjects. "You see, there are way too many problems with this idea, so why bother?"

I wanted to keep my critical thinking while improving my communication skills, and hopefully become a more positive person. That's a tough goal. Communication skills I can deal with, but becoming more positive felt like asking a depressive person to "just be happy". I was reluctant about the possibility of it happening at all, but still wanted to try. After hours of discussion, we came to an agreement that I should try to keep a gratitude journal.

At some point during the holidays, I used the "journal" app on my phone, linked it to a picture I had just taken, and thought hard about nice things I could say about it. So on Thursday, 25 January 2024, my first post was:

That was no easy first step, but it was the start of something. I kept going and added some highlights from my days. At some point, I started writing more and more (full sentences, I swear) about anything that happened that day. I kept writing in my journal every day for about a year. After that, it became scarce, and I finally stopped writing in the journal app in October 2025.

You know that feeling when you open your fridge and ask yourself, "What was I fetching already?" That decreased greatly. It was a great memory exercise, and there were fewer "the heck did I do today?" moments.

Apart from that, I am still uncertain whether I became more positive afterwards. Maybe I struggle a little less to find good things that happened in a day now. And maybe that's what being more positive is about, my core functioning hasn't changed.

I stopped journaling in my phone app but kept writing on paper, logging my vacations, and writing holiday letters. At that time, the idea of starting a blog crept back into the back of my mind.

Why a blog

Writing will surely improve my English, which is a cool bonus. However, I'm proficient enough to navigate the corporate world at my current level, and I do not intend to become an author, so there's no real objective here for me.

Half of the internet traffic is now bots, no doubt, this will only increase in the future. A growing number of websites will be AI-generated. I also like that I can add a drop of human content to an ocean of bots. But that's not a fight I can have a big impact on.

So what are my motivations?

When I say I do 3D printing as a hobby, I'm always asked for details. This is not yet a widespread hobby, so I need to show examples. I'll go through my phone and scroll through it, trying to find one to three examples. I ended up making a picture folder with a few examples. But that's not enough because some people want to show their friends, and I haven't put that on any social media. How convenient would it be if I had a link I could share with everything I've done?

Ok, we have a first motivator. But that's a little light, let's think harder.

When I reflect on my flaws, there's one thing that strikes me: I'm not good at debating. Of course, talking a little louder would help, but that's not how I want to communicate. To improve, I see two paths: Improve my improvisation skills or prepare the topics that matter to me.

Writing about a subject means you have to think hard about it, maybe search for more information to consolidate your thoughts. You should end up having clear, well-thought-out arguments that will have more impact in a debate than loud, imprecise claims.

That's a second motivator that could have an impact on the few subjects I chose to write about. Considering I'll write about what matters to me, this should be a great starting point.

I like the idea that this place on the internet is mine: No ads, no cookies, no pop-ups. Just me, my projects, and thoughts. I can put whatever I want on it, but more importantly, the content is mine. It doesn't belong to any big corporation's app that can be bought by any rich guy with a criminal record. This counts as a third motivator.

Let's say I make a blog, except for 3D printing, what would I even talk about ? Well, in that case, I already had 10 ideas before getting started. I'm bad at falling asleep. It takes time, even if I spend the day out, eat correctly, sleep early, and so on... My mind wanders a lot, either summing up what happened that day or going on any random thought. These thoughts are pretty clear, I just didn't put them to use by taking notes the next day. It's time they stopped going to waste.

What now ?

Well, I've made it. I've published my blog already! There's very little content yet, but I intend on posting more. Hopefully, link some of my projects to it soon.

A try at Pixel Art

Wed, 31 Dec 2025 00:00:00 GMT

December 2025

</div>

Novembre 2025

I needed a custom cursor for my website, so I used the default mac cursor and modified it with the colors of my website. Who says website says favicon, so here's little pixelated Kaonashi. I also made this podium for my article on a tribute to video games. <div class="pixel-grid">

</div>

Making some basic tiles <div class="pixel-grid">

</div>

Here's playing with perspective <div class="pixel-grid">

</div>

Here are the rest of the experiments I made. I've been trying to do some pixel art daily challenge to improve <div class="pixel-grid">

</div>

At first I was on Pixel Studio and ended up buying Aseprite because the use is just smoother. I've been asked to make a wallpaper for a pirate game, so layer by layer, with heavy inspiration from the internet, the project produced this stack of backgrounds and tent props: The sky and clouds <div class="pixel-grid">

</div> Now some birds and then the sea <div class="pixel-grid">

</div> Sprinkle some sand and greens <div class="pixel-grid">

</div> Let's add a plank and tents from where the pirates come out <div class="pixel-grid">

</div> And here's the first result

The tent sprite when it takes damage <div class="pixel-grid">

</div>

It's nowhere near perfect but that looks like a good start !

A tribute to Video Games

Mon, 24 Nov 2025 00:00:00 GMT

My father is a gamer, he put my brother and me on a computer very early. At two years old I was already on Adibou, and I was most likely a pro Tetris player by the time I was four. I captured over 150 Pokémon at least six times before I was eight. I spent many hours on various MMORPGs during my teenage years. I've crushed many heads on FPS to keep my sanity while getting my master's degree.

Gaming has been my main hobby since childhood. I want to write this post to remember the games I've played, the enjoyable moments, the friends I've made (make it more cheesy and it'll turn into a Raclette), and to acknowledge the titles that have shaped my life.

"This is our story! Now let's see this thing through together!" - Final Fantasy X

I'm a PC MaStER rAcE player, not because I believe PC > Console, but because it was what I had access to for a while. I eventually got a DS and a Wii. Emulators were available, so I used them to play older games (Thanks dad!).

In my early years, I mostly played alone or with my younger brother, who hated losing. I mean, I hate(d) losing too but let's be honest, I was the best. We'd go to war on Age of Mythology, continuously spamming "Wololo" at each other, compete on Rayman Raving Rabbids, screaming "Bwaaah" while our parents watched, helpless at the chaos, and tried to outperform each other in Mario Kart DS and Smash Bros.

"Bonjour mon ami!" - Clair Obscur: Expedition 33

In middle and high school, I discovered MMORPGs. I made many friends there, and even met two partners through different games at different times. Dofus was my first MMO. I once organized an event that crashed the servers because too many players joined the same map.

In highschool I remember being told by my english teacher that I would never achieve anything in life and would certainly never be able to speak english. Oh well. I don't mean to brag when I say gaming has brought me a list of skills which helped me navigate life more easily:

My english level mainly comes from playing online games on non French servers.
Taking down a raid requires planning, communication, and coordination.
Patience and perseverance are key when you're on game such as Dark Souls.
Portal makes your brain cells work overtime, that's puzzle solving for you.
Curiosity tends to make you go towards that "?" lost in the map and you get rewarded for that (unless you're playing Ubisoft games).
Having to debug an error message caused by a terrible anti-cheat system that leads you in the bios of your computer tends to give you the key to end up building your own machine a few years later.

After high school, convinced by my parents that I needed a prestigious degree to earn good money, I enrolled in an international business school. I did not fit in, neither did I want to fit in. At the time, I was playing Final Fantasy XIV. My guild master was studying computer science and offered to show me around his school. I switched to that path the following year.

Once in computer science school, a friend introduced me to Overwatch, which I still play occasionally. This game can be truely fun when played with a group, either because you're try harding to win or because you're just chit chatting while poucing the other team. I've made multiple lifelong friends with that game in the background. I love playing Ana, grandma healer sniper with some control skills. One evening I used the group finder and posted something like "Come play with grandma". I teamed up with an American dude who played Zarya, the buffed as heck tank of the Motherland, after a night full of victory we kept playing together for a while, we've been pen pals ever since and still chat almost daily.

I've been told multiple times that it's not possible to create real, deep connections with people online. I believe and know it's possible, I've had the best random phylosophical talks with friends at night on Mumble and Discord. Some people I met have had an impact on my life, just like I've had an impact on theirs. For instance, I became a programmer partially thanks to my Final Fantasy XIV Guild Master back in 2014.

"I choose you!" - Pokémon

When asked what my favorite games are, I definitely have a strong first and second, however the third place is a tie between several games.

My favorite is The Witcher 3. After finishing the whole series and reading the books, I realized that a story-driven RPG with moral complexity, strong music, and satisfying gameplay is what I enjoy the most. Now add a cool ass main character, an open world and put that into a Dark Fantasy universe and I'll sign up. My heart was broken when I originally finished the game and had the worst ending possible, so I reloaded a save 40 hours earlier to get a different ending. I have over 200 hours in the game, including the DLC and completion attempts.

The second place was taken recently by Clair Obscur: Expedition 33. All the boxes are ticked once again: story, music, gameplay, I only saw the sunlight again after completing the game. It's great in all aspects cited above, but add to that the fact that they're a small french team and even if I'm not very much of a patriot I was somehow proud of them. I've had the chance to go to their first concert in Paris and it was a remarkable experience, you could see the joy they had in sharing their work.

For third place, the contenders are Baldur's Gate 3, Ori and the Blind Forest, Hades, Overwatch, and Final Fantasy XIV. They are all strong in different ways, but I would choose Final Fantasy XIV due to the amount of days and nights I invested in it. If I played it again now, I might not rate it as highly, since many expansions have changed the game significantly.

"I used to be an adventurer like you" - Skyrim

And I wish I can keep on adventuring like that! Even though I have found new hobbies and go touch grass more regularly, I still play vdeo games and I intend to continue. We're in an amazing timeline for that hobby, they have become more accessible, they're seen less as a danger to society (by television, find the bug), more and more people are creating video games and even more people are playing them. I am thankful for the teams who developed these titles, for the hours of entertainment, the memories, and the friends I've made. They have been a great escape from reality for a long while, now they complement my reality nicely, the cake is no longer a lie.

"Reconstructing test chamber data." - Portal 2

Do you know what I like aside from video games? Data. Data's fun, I grouped the games by genre to create the chart below. I'll keep denying if someone says I have a type though.

Game count (I have forgoten plenty that's for sure): {gameCovers.length}

Here's to many more years of gaming!