DEV Community: Irakoze Deborah

My First Steps into Computer Vision: Teaching a Computer to Understand Images

Irakoze Deborah — Tue, 13 Oct 2026 13:46:28 +0000

My First Steps into Computer Vision: Teaching a Computer to Understand Images

Have you ever wondered how your phone recognises a face, how a self-driving car detects pedestrians, or how a computer can identify objects in a photograph?

These are examples of computer vision, a field of artificial intelligence that helps computers extract meaningful information from images and videos.

During my introduction to computer vision, I learned that computers do not see images the same way humans do. They process numerical data, discover patterns, and use those patterns to make predictions.

In this article, I will explore how computers represent images, how filters detect edges, how neural networks classify images, and how object detection can locate objects in a scene. I will also discuss some challenges that arise when applying computer vision to real-world problems.

How Does a Computer See an Image?

When humans look at a photograph, we can immediately recognise colours, people, vehicles, and other objects. A computer, however, processes an image as a collection of pixels.

Each pixel contains numerical information. In a typical RGB colour image, each pixel has three values representing red, green, and blue intensity.

For example, the following Python code loads an image and examines its pixel values.

Python example: Reading image pixels
from PIL import Image
import numpy as np

Load an image

image = Image.open("my_image.jpg").convert("RGB")

Convert the image into a NumPy array

pixels = np.array(image)

Display image information

print("Image shape:", pixels.shape)
print("First pixel:", pixels[0, 0])
print("Minimum value:", pixels.min())
print("Maximum value:", pixels.max())

Install the required libraries using:

pip install pillow numpy

The image shape gives us its height, width, and colour channels. For example, an image with dimensions 600 × 400 pixels and three colour channels contains 720,000 individual channel values.

This demonstrates an important concept: an image that looks simple to us can contain a large amount of numerical information.

How Do Image Filters Find Edges?

Images contain different patterns, textures, and boundaries. Sometimes, we want to highlight particular features to make an image easier to analyse.

Image filters can help us reduce noise, smooth images, sharpen details, or detect edges.

One useful technique is edge detection. It identifies areas where pixel intensity changes significantly, helping reveal the boundaries of objects.

For example, edge detection can highlight the outline of a vehicle, a building, or a person.

Python example: Detecting edges

import cv2
import matplotlib.pyplot as plt

Load the image

image = cv2.imread("my_image.jpg")

if image is None:
raise FileNotFoundError("Image not found. Check the filename.")

Convert BGR to RGB for correct display

image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

Convert the image to grayscale

gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)

Detect edges using the Canny algorithm

edges = cv2.Canny(gray, 100, 200)

Display the original image and its edges

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

plt.subplot(1, 2, 1)
plt.imshow(image)
plt.title("Original Image")
plt.axis("off")

plt.subplot(1, 2, 2)
plt.imshow(edges, cmap="gray")
plt.title("Detected Edges")
plt.axis("off")

plt.tight_layout()
plt.show()

Install the required libraries:

pip install opencv-python matplotlib

This example shows how a computer can transform an ordinary photograph into a representation that highlights its boundaries.

What Is a Convolutional Neural Network?

Image filters can reveal useful features, but modern computer vision also relies heavily on deep learning.

A Convolutional Neural Network (CNN) is a neural network architecture commonly used to process images. It learns patterns from training examples rather than depending entirely on manually designed rules.

Early layers may learn to respond to edges and simple textures. Deeper layers can combine these features into more complex patterns.

For example, a trained model may learn visual patterns that help distinguish a bus from a car.

We can experiment with a pretrained image-classification model using TensorFlow.

Python example: Classifying an image
import tensorflow as tf

Load a pretrained MobileNetV2 model

model = tf.keras.applications.MobileNetV2(
weights="imagenet"
)

Load and resize the image

image = tf.keras.utils.load_img(
"my_image.jpg",
target_size=(224, 224)
)

Convert the image to an array

image_array = tf.keras.utils.img_to_array(image)
image_array = tf.expand_dims(image_array, axis=0)

Prepare the image for MobileNetV2

image_array = tf.keras.applications.mobilenet_v2.preprocess_input(
image_array
)

Predict the image category

predictions = model.predict(image_array)

Display the three most likely categories

results = tf.keras.applications.mobilenet_v2.decode_predictions(
predictions,
top=3
)

for _, label, score in results[0]:
print(f"{label}: {score:.2%}")

Install TensorFlow using:

pip install tensorflow

The model uses pretrained ImageNet weights and returns its top three predicted categories with scores. Those scores are model outputs, not guarantees that a prediction is correct.

This experiment demonstrates how a pretrained model can use learned visual patterns to make predictions about an image.

Classification, Object Detection, and Segmentation

Computer vision includes several tasks that may appear similar but serve different purposes.

Image classification

Classification predicts a category for an image or image region.

For example, a model might predict that a photograph contains a bus.

Object detection

Object detection identifies objects and estimates their locations, commonly using rectangular bounding boxes.

For example, a model might identify several vehicles and people in a street photograph.

Image segmentation

Segmentation assigns labels to individual pixels or regions, depending on the task. It can help distinguish the road from vehicles, pedestrians, and other parts of a scene.

These tasks answer different questions:

Classification: What is in the image?
Detection: What objects are present, and where are they?
Segmentation: Which pixels belong to each object or region?
Python example: Detecting objects with YOLO

YOLO is a family of object-detection models designed to identify objects and their locations in images.

from ultralytics import YOLO

Load a pretrained object-detection model

model = YOLO("yolo11n.pt")

Run detection on an image

results = model("my_image.jpg")

Display the detection results

results[0].show()

Print each detected object's label and confidence

for box in results[0].boxes:
class_id = int(box.cls[0])
confidence = float(box.conf[0])
label = model.names[class_id]

print(f"{label}: {confidence:.2%}")

Install Ultralytics using:

pip install ultralytics

The pretrained model weights may download when you run the example for the first time.

Seeing those boxes makes the difference between classification and object detection easier to understand. The model does not simply predict what might be in the photograph; it also estimates where detected objects are located.

Why Do Computer Vision Models Make Mistakes?

One important lesson is that computer vision models are not perfect.

A model might confuse objects that look similar, miss an object in poor lighting, or perform poorly on images that differ from its training data.

For example, an object detector trained on clear photographs may struggle with a blurry image taken at night.

Confidence thresholds also affect detection results. A lower threshold can produce more detections, including incorrect ones. A higher threshold can remove weak predictions but may also cause genuine objects to be missed.

This means that a model's output should be evaluated rather than accepted automatically.

When developing computer vision applications, it is important to test different conditions, examine incorrect predictions, and understand the limitations of the model.

Why Does Local Data Matter?

Computer vision can support many useful applications in African communities.

In agriculture, models could help researchers identify plant diseases. In transportation, detection systems could help analyse traffic. In healthcare, computer vision could assist qualified professionals in examining medical images.

However, a model trained mainly on images from other regions may not perform equally well on local data.

Differences in lighting, road conditions, clothing, crop varieties, building styles, and camera quality can affect its predictions.

This makes local data collection and testing important. A model should be evaluated using representative examples from the environment where it will actually be used.

For sensitive applications such as healthcare, predictions also need appropriate professional oversight.

What I Learned

My introduction to computer vision helped me connect several important ideas.

First, images can be represented as numerical arrays. Second, filters can highlight useful visual features. Third, CNNs learn patterns from data, while classification, detection, and segmentation solve different problems.

I also learned that computer vision is not only about building a model. It involves preparing data, testing predictions, identifying mistakes, and understanding how the system behaves in real-world situations.

The most interesting part is seeing how mathematical operations and code can turn image pixels into useful information.

Conclusion

Computer vision is an exciting field because it gives computers the ability to analyse images and videos in increasingly useful ways.

From examining individual pixel values to detecting objects with pretrained models, each step reveals another part of how machines process visual information.

There is still much to learn, especially about improving model accuracy, working with diverse datasets, and developing responsible applications.

I look forward to exploring more computer vision projects and understanding how these techniques can help solve practical problems in my community.

What would you choose for your first computer vision project: image classification, object detection, or segmentation? Share your thoughts in the comments!

Teaching a Computer Word Meaning Without a Dictionary

Irakoze Deborah — Thu, 01 Oct 2026 15:16:58 +0000

When I started learning Natural Language Processing (NLP), one question bugged me: how does a computer understand words?

The honest answer is that it doesn't. Computers only understand numbers. So before a model can work with language, we have to turn words into numbers, and the way we do it makes a huge difference. That is what word embeddings are about.

In this post I'll explain what they are, show tiny examples you can run in seconds with plain Python, and look at how Word2Vec learns them.

What is a word embedding?

A word embedding is a word written as a list of numbers (a vector):

cat → [0.21, 0.85, -0.13, 0.42, ...]

Nobody types these numbers in by hand. They are learned from text. The big idea is that words used in similar contexts get similar numbers.

The cat eats fish.
The dog eats meat.

"cat" and "dog" both eat things, so their vectors end up close together. A machine-learning model can then treat them as related instead of as complete strangers. That is why embeddings matter: the model can reuse what it knows about "cat" when it meets "dog".

The old way: one-hot encoding

The simplest approach gives each word a vector with a single 1 and the rest 0. Let's test how "related" these vectors are. The function below multiplies matching positions and adds them up (a dot product):

cat = [1, 0, 0]
dog = [0, 1, 0]
car = [0, 0, 1]

def similarity(a, b):
    return sum(x * y for x, y in zip(a, b))

print("cat vs dog:", similarity(cat, dog))
print("cat vs car:", similarity(cat, car))
print("cat vs cat:", similarity(cat, cat))

Output:

cat vs dog: 0
cat vs car: 0
cat vs cat: 1

A word is only similar to itself. To one-hot encoding, "cat" is as unrelated to "dog" as it is to "car". There is also a practical problem: with a 100,000-word vocabulary, every vector would have 100,000 slots, almost all of them zeros. Embeddings fix both issues by using short, dense vectors (usually 50 to 300 numbers) where distance carries meaning.

Why context is so powerful

Before any machine learning, let's see the core idea. This code collects the words that appear in the same sentence as each word:

sentences = [
    "the cat eats fish",
    "the cat drinks milk",
    "the dog eats meat",
    "the dog drinks water",
    "the car needs fuel",
]

context = {}
for sentence in sentences:
    words = sentence.split()
    for w in words:
        context.setdefault(w, set()).update(words)
        context[w].discard(w)

print("cat & dog share:", sorted(context["cat"] & context["dog"]))
print("cat & car share:", sorted(context["cat"] & context["car"]))

Output:

cat & dog share: ['drinks', 'eats', 'the']
cat & car share: ['the']

"cat" and "dog" share three context words, while "cat" and "car" share only one. Just by looking at neighbours, we discovered that cats are closer to dogs than to cars.

Word2Vec in 30 seconds

Word2Vec takes this same idea and scales it up. It slides a small window over text and learns from the words nearby. It comes in two flavours:

Skip-gram: given a center word, predict its neighbours. (cat → the, eats, fish)
CBOW (Continuous Bag of Words): given the neighbours, predict the center word. (the ___ eats fish → cat)

While the model gets better at these predictions, it adjusts its internal vectors. The useful by-product is that words appearing in similar contexts end up with similar vectors. With millions of sentences, famous results like king − man + woman ≈ queen start to appear.

Build a tiny embedding yourself

Real Word2Vec libraries are heavy, so let's build the core idea in plain Python. Each word becomes a vector of counts: how often every other word appears in a sentence with it. Then we compare vectors with cosine similarity (1 means same direction, 0 means nothing in common).

sentences = [
    "the cat eats fish",
    "the cat drinks milk",
    "the dog eats meat",
    "the dog drinks water",
    "the car needs fuel",
]

vocab = sorted({w for s in sentences for w in s.split()})

def vector(word):
    counts = {v: 0 for v in vocab}
    for s in sentences:
        words = s.split()
        if word in words:
            for w in words:
                if w != word:
                    counts[w] += 1
    return [counts[v] for v in vocab]

def cosine(a, b):
    dot = sum(x * y for x, y in zip(a, b))
    return dot / ((sum(x * x for x in a) ** 0.5) * (sum(y * y for y in b) ** 0.5))

print("vocab:", vocab)
print("cat vector:", vector("cat"))
print("cat vs dog:", round(cosine(vector("cat"), vector("dog")), 2))
print("cat vs car:", round(cosine(vector("cat"), vector("car")), 2))

Output:

vocab: ['car', 'cat', 'dog', 'drinks', 'eats', 'fish', 'fuel', 'meat', 'milk', 'needs', 'the', 'water']
cat vector: [0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 2, 0]
cat vs dog: 0.75
cat vs car: 0.41

Unlike one-hot encoding, "cat" is now much closer to "dog" (0.75) than to "car" (0.41), and nobody told the program what any word means. Word2Vec goes further: instead of raw counts, it learns short dense vectors by predicting words from their neighbours, on millions of sentences.

What surprised me

The model is never told what a word means. There is no dictionary, no labels, and no "cat = animal". It only sees which words sit near which, and relationships appear on their own. I assumed a computer would need every word explained to it, so this was the most unintuitive part of the topic for me, and the most exciting once it clicked.

What I struggled with

I tried to install gensim, the popular Word2Vec library, and it failed on Windows with a "Microsoft Visual C++ 14.0 is required" build error. Instead of fighting the installer, I built a small count-based version in plain Python to show the same idea. It was a good reminder that understanding the concept matters more than the library.

Your turn: challenges

[ ] Add 3 more sentences about animals. Does cat vs dog go up?
[ ] Add a sentence like "the car needs oil". How does cat vs car change?
[ ] Try vector("fish") vs vector("milk"). Are they similar?
[ ] On a machine where it installs, try pip install gensim and compare with Word2Vec.

Share your numbers in the comments, I'd love to compare!

Ideas to explore next

GloVe and FastText: how do they differ from Word2Vec?
Famous analogies like king − man + woman ≈ queen
Plotting word vectors in 2D with PCA

Sources

Dive into Deep Learning, Word Embedding (word2vec): https://d2l.ai/chapter_natural-language-processing-pretraining/word2vec.html