DEV Community: Axelle Toni

How Computers See: What I Learned in My First Computer Vision Class

Axelle Toni — Tue, 13 Oct 2026 14:05:33 +0000

Before my first computer vision class, I thought a computer looked at a photo the way I do. I was wrong. A computer has never seen a photo, not once.

This week we started computer vision, the part of AI that teaches machines to "see". Here is what I learned, in simple words, for anyone starting from zero like me.

A photo is just numbers

When I look at a street photo, I instantly see a bus and some people. A computer gets a grid of numbers instead. Every tiny square (a pixel) has three numbers: how much red, green and blue it has, each from 0 to 255. Why 255? Each value uses 8 bits, and 8 bits can hold 256 different values, from 0 to 255.

In class we opened a sample photo with Python:

import numpy as np
from PIL import Image

img = np.array(Image.open("bus.jpg").convert("RGB"))
print(img.shape)   # (1080, 810, 3) for our sample photo
print(img.size)    # 2624400 numbers in total

That one photo is 1080 rows × 810 columns × 3 colours, which is 2,624,400 numbers. The computer never "sees a bus". It only sees those numbers. The big challenge of computer vision is getting from the numbers to the meaning.

What can a computer do with a photo?

Almost every vision system answers one of three questions: What is in the image? Where is it? What is happening? We ran three pretrained models on the same street photo, and each one answered differently:

Classification gives one label for the whole image. It said "minibus" with 57.1% confidence and "police van" with 33.7%. It was unsure between two vehicles that look alike, and one label is not very useful for a whole street scene.
Detection draws a box around each object. It found 1 bus (94% confident) and 4 people.
Segmentation labels every pixel. It marked exactly which pixels belong to each object. In our photo, the objects covered 44% of the image.

More detailed answers need more detailed training labels, and those cost more to create.

How does a computer find an edge?

This was my favourite part, because it is only multiplication and addition. A filter is a small grid of weights that slides over the image. At each spot, you multiply each pixel by its weight and add everything up.

sobel_x = np.array([[-1, 0, 1],
                    [-2, 0, 2],
                    [-1, 0, 1]])

This filter computes "right side minus left side". On a flat patch where every pixel is 100, you get −400 + 400 = 0, so there is no edge. On a patch that goes from dark (0) to bright (200), you get 0 + 800 = 800, a big number, so there is an edge.

A CNN (convolutional neural network) does exactly this, with one difference: nobody chooses the weights. Training learns them from thousands of labelled images. The first layers learn edges and colours, the middle layers learn textures and parts like eyes or wheels, and the last layers recognise whole objects.

Why YOLO is fast

For detection we used YOLO, which stands for "You Only Look Once". Older detectors first proposed possible regions and then classified each one, which was accurate but slow. YOLO looks at the whole image one time and predicts every box and label together. That is fast enough for live video and small devices. It was introduced in 2015 by Joseph Redmon and colleagues.

from ultralytics import YOLO

detector = YOLO("yolo11n.pt")            # small pretrained detection model
r = detector("street.jpg", conf=0.4)[0]  # only keep boxes it is 40%+ sure about
for box in r.boxes:
    print(r.names[int(box.cls)], f"{float(box.conf):.0%}")

When models fail

This part surprised me most. We made the same photo harder, the way a cheap phone or bad lighting would:

Very dark: the model invented a skateboard that was not there.
Upside down: it lost the bus.
Low resolution: it found nothing.

A model only knows what it was trained on. Many of these models were trained mostly on photos from Europe, North America and Asia. So where might they fail here? On crops, clothing, road scenes, skin tones and lighting. The fix is local data.

Why this matters for us

Our course looked at real examples from Africa. Nuru helps farmers diagnose cassava disease from a leaf photo, and it works offline on a basic phone, so it works in fields with no internet. BLAIVA, built by FabLab Rwanda in Kigali, is a wearable camera that describes objects, text and faces through earphones. It is still in beta testing. These systems were built by people like us, which makes this field feel close and possible.

What I'm taking away

Images are numbers: height × width × 3.
Filters find patterns, and CNNs learn those filters on their own.
Classification, detection and segmentation answer different questions.
Models fail on what they have not seen, so local data matters.

Next, I'll build my own image classifier on photos from around me, with a separate test set so I can check it honestly.

Sources

kLab TekHer AI Program, "Introduction to Computer Vision" class slides and demo notebook
Ultralytics YOLO11 pretrained models; ImageNet and COCO datasets
YOLO: Joseph Redmon et al., 2015

Word Embeddings, Explained Simply (For Developers Who Are New to NLP)

Axelle Toni — Wed, 30 Sep 2026 14:38:28 +0000

When I first heard the term "word embeddings," it sounded like something only researchers with PhDs would understand. It turns out the core idea is actually simple, and once it clicks, a lot of modern AI (chatbots, search engines, recommendation systems) suddenly makes a lot more sense.
What are word embeddings, really?

What are word embeddings, really?

Computers don't understand words the way we do. To a computer, "cat" and "dog" are just strings of letters with no relationship to each other unless we tell it otherwise. Word embeddings are a way of converting words into lists of numbers (called vectors) so that words with similar meanings end up with similar numbers.

For example, imagine every word gets plotted as a point in space. Words like "cat" and "dog" would land close together, because they're both animals, often pets, and used in similar sentences. A word like "airplane" would land far away, because it's used in a completely different context.

This matters because it lets computers do things like:

Understand that "good" and "great" mean similar things
Search for a term and still find related results, not just exact matches
Power translation, chatbots, and recommendation systems

Without embeddings, a computer would treat every word as completely unrelated to every other word which makes real language understanding almost impossible.

How Word2Vec works

One of the most well-known ways to create embeddings is Word2Vec, developed by researchers at Google. The idea behind it is surprisingly simple: "a word is defined by the company it keeps."

Word2Vec looks at huge amounts of text and learns, based on which words tend to appear near each other, how to place each word in that numerical space. If "coffee" and "tea" often show up in similar sentences ("I drink coffee every morning," "I drink tea every morning"), the model learns to place them close together — even though it was never explicitly told they're both drinks.

There are two main approaches inside Word2Vec:

CBOW (Continuous Bag of Words): predicts a word based on the words around it.
Skip-gram: does the opposite predicts the surrounding words based on one word

Either way, the model isn't taught definitions. It only learns patterns from context, and meaning emerges from that.

A concrete example

Here's a simple example using the gensim library in Python, training a tiny Word2Vec model on a small sample of sentences:

from gensim.models import Word2Vec

sentences = [
["i", "drink", "coffee", "every", "morning"],
["i", "drink", "tea", "every", "morning"],
["dogs", "and", "cats", "are", "pets"],
["cats", "chase", "mice"],
]

model = Word2Vec(sentences, vector_size=50, window=2, min_count=1, workers=1)

print(model.wv.most_similar("coffee"))

Even with this tiny amount of data, the model starts to notice that "coffee" and "tea" appear in similar contexts, and it will rank "tea" as more similar to "coffee" than something like "dogs."

A classic (and honestly kind of magical) example from real, large-scale Word2Vec models is:

King - man + woman = queen

The model isn't told anything about royalty or gender it just learns this relationship purely from patterns in text.

What surprised me and what I struggled with

I haven't worked hands-on with word embeddings yet, but I've always loved anything related to IT, so this topic caught my attention right away. What I enjoyed most was understanding how these models are trained how they "learn" without actually thinking. A model doesn't understand meaning; it only picks up patterns from whatever data it's given, which means how well it performs depends entirely on what you train it with. That part stuck with me: as the person training a model, you have to be careful about the data you feed it, because it will simply repeat whatever patterns exist in that data. What didn't surprise me is that computers don't naturally understand human language, I already knew that from earlier learning.

What I struggled with was the more practical side. When I looked at example code like the one above, I found it hard to fully understand the output, things like most_similar() results and what the numbers actually mean. I'm also still getting comfortable with writing this kind of code myself, rather than just reading someone else's. Understanding the theory made sense to me quickly, but going from theory to actually building and reading a working model is still something I'm learning to do.

Final thoughts

Word embeddings are one of those ideas that feel complicated from the outside but make a lot of sense once you see a small example. If you're starting out in NLP like I am, I would recommend just trying the code above with your own sentences seeing which words the model considers "similar" is a great way to build intuition.

Sources:

Sources: Mikolov et al., "Efficient Estimation of Word Representations in Vector Space" (2013); Gensim documentation: https://radimrehurek.com/gensim/