DEV Community: Igihozo Gwiza Aline

From Pixels to Meaning: A Beginner's First Day in Computer Vision

Igihozo Gwiza Aline — Tue, 13 Oct 2026 13:09:48 +0000

Before the first day of computer vision, I thought it meant "teaching a computer to look at pictures, the way we do." By the end of the day I realised that sentence hides about six different questions. These are the ones I wrote down, with the answers that finally made sense to me.

1. Why is "seeing" hard for a computer?

Because a computer doesn't receive a picture. It receives numbers.

A photo is a grid of pixels, and each pixel is three numbers: how much red, green and blue light it has, each from 0 to 255. Our sample street photo is 1080 rows by 810 columns, so that is 1080 x 810 x 3 = 2,624,400 numbers. Somewhere in those numbers is a bus, but nothing in the file says "bus".

Think of it like being handed a spreadsheet of 2.6 million cells and being asked what it shows. Computer vision is the work of getting from the spreadsheet to the meaning.

2. What can computer vision actually do?

I found it easier to remember the field as five jobs, from simplest to most detailed:

Classification: one label for the whole picture ("minibus").
Detection: a box around each object ("1 bus, 4 people").
Segmentation: a label for every single pixel.
OCR: reading text inside an image.
Tracking: following an object from frame to frame in a video.

The same street photo can feed the first three, and each gives a different kind of answer. Choosing the right job matters. If you want to count motorcycles at a junction, a single label for the whole photo will not help you. You need detection.

3. How does a computer find an edge?

An edge is just a place where brightness changes quickly. To find one, the computer slides a small grid of weights, called a filter, across the image, multiplying and adding as it goes.

You can see the whole idea in a few lines of NumPy, with no model and no download. Here is a tiny 6x6 "image" that is dark on the left and bright on the right:

import numpy as np

image = np.array([[0, 0, 0, 200, 200, 200]] * 6)

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

flat_patch = image[1:4, 0:3]   # all zeros: no change in brightness
edge_patch = image[1:4, 2:5]   # dark -> bright: an edge

print((flat_patch * sobel_x).sum())   # 0
print((edge_patch * sobel_x).sum())   # 800

Where nothing changes, the answer is 0. Where the brightness jumps from left to right, the answer is 800. That big number is the computer's way of saying "something is happening here". Run the same filter over the whole photo and every edge lights up.

4. So what does a CNN add?

In that example I chose the weights. A Convolutional Neural Network (CNN) uses the same sliding-filter idea, but it learns the weights by itself from thousands of labelled images.

Early layers end up finding edges. Middle layers combine edges into textures and shapes. Later layers combine those into whole objects. I found this the most surprising part of the day: nobody tells the network what an edge is. It works that out because edges turn out to be useful.

5. How can a detector find objects so quickly?

Older detectors worked in two steps: first propose regions that might hold an object, then classify each region. That was accurate, but slow.

YOLO ("You Only Look Once") does it in one pass. The whole image goes through the network once, and out come every box, label and confidence score together. It is fast enough for live video, and the small version we used is only about 5 MB.

from ultralytics import YOLO

detector = YOLO("yolo11n.pt")
result = detector("bus.jpg", conf=0.4, verbose=False)[0]

for box in result.boxes:
    print(result.names[int(box.cls)], f"{float(box.conf):.0%}")

On the sample photo it finds the bus (94% sure) and the people standing in front of it. The conf value is a setting you choose, and it changes the result: lower it and you get more boxes with more mistakes, raise it and you get fewer but surer ones.

6. Does it work everywhere? What can go wrong?

This was the question that stayed with me, because the answer is: not automatically.

We made the same photo harder on purpose. In the dark, the model invented a skateboard. Upside down, it missed the bus. At very low resolution, it found nothing. The pixels were the same photo, but the conditions were different from what the model was trained on.

That matters here, because many of these models were trained mostly on photos from other parts of the world. And yet computer vision is already being used in Africa:

Nuru helps farmers diagnose cassava disease from a leaf photo, offline, on a basic phone.
In Nigeria, X-ray screening software helped find TB: 5,298 people were screened, and 85 with TB were found.
BLAIVA, built by FabLab Rwanda in Kigali, is a wearable camera that describes objects, text and faces for people with low vision.

For each of these, the useful question is not "does it work?" but "what happens to the person if it fails?" A wrong answer on a leaf photo and a wrong answer on an X-ray are not the same kind of mistake.

What I take away

A photo is height x width x 3 numbers.
Filters find patterns, and CNNs learn their own filters.
Classification, detection and segmentation answer different questions.
A model is only as good as the data it has seen, so local data matters.

Next I want to learn how datasets are built, how to train my own small CNN in PyTorch, and how to test a model honestly. If you have tried a computer vision model on your own photos, I would love to hear what it got right and what it got wrong.

What I Learned About Word Embeddings and Word2Vec

Igihozo Gwiza Aline — Wed, 30 Sep 2026 13:15:45 +0000

While learning Natural Language Processing (NLP), I came across a concept that helped me understand better how computers work with human language: word embeddings.

I read the Dive into Deep Learning material on natural language processing, especially the section about word embeddings and Word2Vec. Before reading it, I knew that text usually needs to be converted into numbers before a machine learning model can process it, but I did not fully understand how the representation of a word could contain information about its relationship with other words.

After going through the material, I understood word embeddings as a way of representing words using numerical vectors. Instead of treating a word as just a piece of text, we give it a position in a mathematical space. Words that are used in similar situations can have vectors that are closer to each other.

Why Are Word Embeddings Important?

One of the first things I learned is that there are different ways of converting words into numbers.

A simple method is one-hot encoding. For example, if our vocabulary contains four words:

cat
dog
car
house

we could represent them like this:

cat   → [1, 0, 0, 0]
dog   → [0, 1, 0, 0]
car   → [0, 0, 1, 0]
house → [0, 0, 0, 1]

This tells the computer which word we are talking about, but it does not really tell the computer how the words are related.

For example, "cat" and "dog" are both animals, but their one-hot vectors do not show that relationship.

This is where word embeddings become useful. Instead of giving every word an isolated position, embeddings can represent words in a way that allows relationships and similarities to be captured.

A simplified example could look like this:

cat → [0.21, 0.73, 0.45]
dog → [0.24, 0.70, 0.48]
car → [0.91, 0.12, 0.08]

These numbers are only for illustration. Real word embeddings normally have many more dimensions.

What Is Word2Vec?

The embedding method I focused on was Word2Vec.

The main idea I took from the D2L material is that a word can be understood partly by looking at the words that appear around it. If two words regularly appear in similar contexts, their representations can become similar.

For example:

The child plays with a ball.

and

The boy plays with a ball.

The words "child" and "boy" occur in similar contexts. A model can learn from these patterns instead of someone manually telling it that the two words are related.

Word2Vec has two main approaches: Skip-gram and Continuous Bag of Words (CBOW).

With Skip-gram, we start with a word and use it to predict words that appear around it.

With CBOW, we do the opposite: we use surrounding words to predict the word in the middle.

A simple way I remember the difference is:

Skip-gram:
center word → surrounding words

CBOW:
surrounding words → center word

The model learns during training, and the resulting numerical representations become the word embeddings.

Seeing Similarity in Practice

One thing I found interesting is that once words have been represented as vectors, we can compare those vectors.

For example, with a pretrained Word2Vec model, we could use Python to find words that are similar to another word:

similar_words = model.most_similar("computer", topn=5)

for word, score in similar_words:
    print(word, score)

The output might look something like:

software     0.78
technology   0.76
device       0.73
machine      0.71
internet     0.69

The actual results depend on the particular pretrained model and the data it learned from.

The important part for me is understanding what the similarity score represents. It gives us an indication of how close two words are in the learned vector space.

Word embeddings can also be used for word analogies. A well-known example is:

king - man + woman ≈ queen

What interested me here is that the model is not being given a rule saying "king relates to queen in this way." Instead, relationships can emerge from the patterns learned from large amounts of text.

What I Found Difficult

The most difficult part for me was understanding what each individual number in a word vector actually means.

At first, I thought that each dimension might have an obvious meaning. For example, I imagined that one number could represent whether a word was an animal, another could represent whether it was a person, and so on.

But that is not really how it works.

The information is distributed across the dimensions of the vector, which makes the representation useful but not always easy for humans to interpret.

This was one of the things I found most interesting because it showed me that a machine learning model can learn useful patterns even when those patterns are not represented in a way that is easy for us to explain dimension by dimension.

What I Took Away

My biggest takeaway from studying word embeddings is that the way we represent language matters.

A computer does not understand words in the same way humans do. We need to convert language into a form that a model can work with. Word embeddings provide a way to represent words as numbers while still preserving useful information about relationships between words.

Word2Vec made this idea clearer to me because it learns from context. The model looks at how words are used and learns representations from those patterns.

Reading the Dive into Deep Learning material also helped me see that Word2Vec is only one part of the bigger picture of NLP. There are other approaches, including GloVe and subword embeddings, and modern NLP systems have developed much further.

For me, the most important lesson is that NLP is not simply about giving text to a model. How we represent the text can have a major impact on what the model is able to learn.

Reference

Zhang, A., Lipton, Z. C., Li, M., & Smola, A. J. Dive into Deep Learning. Natural Language Processing: Pretraining — Word Embedding (word2vec). https://d2l.ai/chapter_natural-language-processing-pretraining/word2vec.html