DEV Community: anne sonia

Introduction to Computer Vision

anne sonia — Tue, 13 Oct 2026 13:13:46 +0000

Computer vision is the technology that teaches computers to understand pictures and videos. Look at a photo of a coffee cup and you know right away what it is. You may even guess the coffee is hot. A computer sees none of that. It sees only numbers, and computer vision is the set of ideas that turns those numbers into meaning.
In this post, we explain how computers "see", the main tasks they can do, why this field is growing so fast, and how it is already helping people across Africa.
What a computer really sees
A digital photo is a grid of tiny squares called pixels. Each pixel is stored as three numbers: how much red, green and blue it contains. Each number goes from 0 to 255.
So even a small photo, 400 pixels wide and 600 pixels tall, holds 400 × 600 × 3 = 720,000 numbers. A modern phone photo holds more than 30 million. The big challenge of computer vision is to go from all these numbers to real meaning.

You can think of a colour image as three grids stacked on top of each other: one for red, one for green and one for blue. A red cup looks bright in the red grid and dark in the blue grid.

Three questions every vision system answers
Computer vision lets computers get meaning from images and video. Almost every system answers one or more of these questions:
• What is in the picture? For example, a cat or a cassava leaf.
• Where is it? Which part of the picture, or which pixels.
• What is happening? For example, a person crossing the road. This is mostly for video.
Humans and computers see differently
Humans

Years of seeing the world 2.Understanding context, learning from few examples 3.Getting tired Computers
Millions of labelled images 2.Speed and working at large scale 3.Things that look different from their training images

A computer can check thousands of X-rays in a day without getting tired. But it can easily fail on something it has never seen before. We will come back to this later.
Five core tasks
Most computer vision work falls into five tasks:

Classification: give one label to the whole image.
Detection: draw a box around each object.
Segmentation: give a label to every single pixel.
OCR: read the text inside an image.
Tracking: follow objects from one video frame to the next.

Here is an example. Take one photo of a street. A classifier may say "minibus" and be 57% sure. That is not wrong, but it is not very useful. A detector will find one bus and four people and draw boxes around them. A segmenter will outline exactly which pixels belong to each object. The more detail you want, the more detailed the training labels must be, and the more it costs to create them.
How a computer finds patterns
The first step is to find edges, the places where brightness changes. To do this, we use a filter. A filter is a small grid of numbers. We slide it over the image, multiply each pixel by the matching number, and add up the results. This operation is called convolution.
Here is a simple example. The filter below is called a Sobel filter. It subtracts the left side from the right side:
-1,0,1
-2,0,2
-1,0,1
• On a flat area where every pixel is 100, the left side gives −400 and the right side gives +400. The total is 0, so there is no edge.
• On an area that goes from dark (0) to bright (200), the left side gives 0 and the right side gives +800. The big number tells us there is an edge.
Other filters can blur a picture or make it sharper. In code, a blur is just a 5 × 5 grid of ones divided by 25, which means each pixel becomes the average of the 25 pixels around it.

Letting the computer learn its own filters
In the past, people designed filters by hand. Today we use a convolutional neural network (CNN), which learns its own filters from labelled examples. Nobody designs them. The network builds up understanding step by step:
Pixels → Edges → Textures → Objects
The first layers find simple edges and colours. The middle layers find textures and parts, like eyes or wheels. The last layers recognise whole objects.
Finding objects fast with YOLO
Older detectors, such as R-CNN, worked in two steps. First they looked for regions that might contain an object, then they classified each region. This was accurate but slow.
YOLO stands for "You Only Look Once". It looks at the whole image one time and predicts every box and label together. This is fast enough for live video and for small devices. It was introduced in 2015 by Joseph Redmon and his colleagues.
Why computer vision is growing now
Five things came together at the same time:
• Cameras everywhere: every phone is a camera and a small computer.
• Data: there are huge image collections, including satellite images of whole continents.
• Computing power: cloud GPUs train big models, and small models can run on cheap phones with no internet.
• Pretrained models: you do not start from zero. You can adapt an existing model with a few thousand local photos.
• Multimodal AI: AI assistants can now read images as well as text.
There is also a link with language AI. A Vision Transformer cuts an image into small 16 × 16 patches and treats each patch like a word. A 224 × 224 image becomes 196 patches. Then the same attention method used for text reads the picture.
Computer vision across Africa
Computer vision is already solving real problems on the continent. Here are six examples.
• Farming (East Africa): The Nuru app helps farmers find crop diseases. A farmer takes a photo of a cassava leaf and the app names the disease and gives advice. It works offline on a basic phone, so it is useful in fields with no internet. Task: image classification.
• Health (Nigeria): In 2022, software scored the chest X-rays of 5,298 people in Gombe and Adamawa. People with a high score got a lab test, and 85 people with TB were found. Task: classification with a threshold.
• Conservation (Gabon): A small computer next to a camera trap spots elephants and people, then sends an alert to rangers by satellite within minutes. Task: object detection "at the edge", meaning on the device itself.
• Finance (6 countries): Smile ID matches a selfie to an ID photo and checks that the person is real and live. It handled more than 1 million identity checks per month in 2021. Tasks: face verification and OCR.
• Mapping (whole continent): Google's Open Buildings project found 1.8 billion building outlines from satellite images. Health teams use them to plan vaccination campaigns, and aid teams use them after floods. Task: segmentation.
• Accessibility (Kigali): BLAIVA, built by FabLab Rwanda and still in beta testing, is a wearable camera that describes objects, text and faces through earphones. Tasks: detection, OCR and face recognition.
When computer vision fails
A model only knows what it was trained on. In one test on a street photo, the model found "1 bus, 4 people". Then the photo was changed:
• Very dark: the model added a skateboard that was not there.
• Upside down: the model missed the bus.
• Very low resolution: the model found nothing.
Many popular models were trained mostly on photos from Europe, North America and Asia. They can make more mistakes on African crops, clothes, roads, skin tones and lighting. Early face recognition systems, for example, often worked worse on darker skin because the training data was not representative. Face data is also very private, so it needs great care.
The fix is local data. When a model is adapted with local photos, it works better for local people. It is also important to ask who could be harmed if a model is wrong: a farmer, a patient or a customer.
Tools to get started
You rarely need to start from zero. These tools are popular:
• PyTorch: build and train your own neural networks.
• TensorFlow / Keras: Google's alternative, common in mobile apps.
• Hugging Face: download pretrained models and adapt them.
• Ultralytics YOLO: ready-made detection, classification and segmentation.
Key takeaways
• Images are just numbers: height × width × 3.
• Filters find patterns, and CNNs learn the filters by themselves.
• The main tasks are classification, detection and segmentation.
• Computer vision is already used in farming, health, conservation, finance, mapping and accessibility across Africa.
• Models fail on things they have not seen, so local data matters.
A good way to start is to take 5 to 10 photos of your own surroundings, such as a street, a market stall or a crop leaf, and run them through a pretrained model. Notice what it gets right and what it misses. That is the best way to understand both the power and the limits of computer vision.

Word Embeddings: How Machines Learn the Meaning Behind Words

anne sonia — Wed, 30 Sep 2026 12:54:46 +0000

When I started learning Natural Language Processing (NLP), one of the things that confused me was a simple question: How can a computer understand the meaning of words?

Computers work with numbers, but humans communicate using words, sentences, and different ways of expressing the same idea. This became especially interesting to me when I started building a simple FAQ chatbot for a clothing shop.

My first approach used TF-IDF to represent questions. It worked by looking at the words in a question and comparing them with the words in stored FAQ questions. But I wanted my chatbot to understand more than just matching words.

That is where word embeddings became important.

What are word embeddings?

Word embeddings are numerical representations of words or pieces of text. Instead of representing a word only as a label such as "dress", an embedding represents it as a vector of numbers.

For example, we can imagine:

dress → [0.21, -0.14, 0.73, 0.42, ...]
shirt → [0.19, -0.10, 0.68, 0.39, ...]
car → [-0.51, 0.83, -0.22, 0.11, ...]

The actual vectors contain many more dimensions, and the numbers are learned from data.

The important idea is that words or sentences with related meanings can have vectors that are closer together in the embedding space.

This is useful because language is not only about exact words. Two people can ask the same question using completely different wording.

For example:

"What is the price of this dress?"

and:

"How much does this dress cost?"

They are different sentences, but they have almost the same meaning.

A system based only on exact word matching can have difficulty with this. Embeddings help us represent semantic relationships.

Word2Vec

One of the important embedding methods I learned about is Word2Vec.

Word2Vec was introduced by Mikolov and colleagues in 2013. It learns vector representations of words from their surrounding context. The basic idea is that words appearing in similar contexts tend to develop similar representations.

There are two well-known Word2Vec approaches:

CBOW (Continuous Bag of Words)
Skip-gram

CBOW uses surrounding words to predict a target word.

For example:

"The customer bought a new ___ yesterday."

The surrounding context can help the model predict a word such as:

dress

Skip-gram works in the opposite direction. It uses a target word to predict words that are likely to appear around it.

During training, the model learns vectors that capture relationships between words.

One famous type of example associated with word embeddings is:

king - man + woman ≈ queen

The interesting part is that the vectors can capture relationships rather than simply storing dictionary definitions.

Why do embeddings matter?

Embeddings are useful because many NLP problems require understanding relationships between words and text.

They can be used for:

Semantic search
Question answering
Chatbots
Text classification
Recommendation systems
Similarity detection
Information retrieval
Clustering

For my FAQ chatbot, the most important use is semantic similarity.

Imagine a clothing customer asks:

"Do you have something I can wear to a party?"

The FAQ database might contain:

"Do you sell party clothes?"

The two questions don't contain exactly the same words, but their meanings are related.

This is the kind of problem where embeddings can be useful.

From TF-IDF to embeddings in my chatbot

My first chatbot version used TF-IDF.

TF-IDF converts text into numerical vectors based mainly on the importance of words in the documents. I then used cosine similarity to find the FAQ question most similar to the user's question.

The improved version uses a pre-trained Sentence Transformer model:

from sentence_transformers import SentenceTransformer

model = SentenceTransformer(
"sentence-transformers/all-MiniLM-L6-v2"
)

questions = [
"Do you sell party clothes?",
"What sizes do you have?",
"How can I order clothes?"
]

embeddings = model.encode(questions)

print(embeddings.shape)

The Sentence Transformers documentation shows the same basic workflow: load a pretrained model, encode text into embeddings, and compare the resulting vectors for similarity. The all-MiniLM-L6-v2 model produces 384-dimensional embeddings.

For example, my chatbot can encode both the customer's question and the stored FAQ questions, then compare their vectors.

from sklearn.metrics.pairwise import cosine_similarity

user_question = model.encode(
["How much does a dress cost?"]
)

similarities = cosine_similarity(
user_question,
embeddings
)[0]

best_index = similarities.argmax()

print(questions[best_index])
print(similarities[best_index])

The chatbot can then return the FAQ answer associated with the question having the highest similarity.

What surprised me

The most interesting thing I learned is that similar meaning does not always require the same words.

Before learning about embeddings, I mainly thought of text as words that needed to be matched. Embeddings changed how I think about NLP.

For example, these questions are different:

"How much is a dress?"
"What is the price of a dress?"
"How expensive is that dress?"

A human immediately understands that they are asking about the same thing.

The goal of semantic embeddings is to represent that relationship numerically.

What I struggled with

One challenge was understanding what the numbers in an embedding actually mean.

At first, seeing a vector such as:

[0.034, -0.218, 0.731, ...]

does not tell us anything directly. The meaning is not stored in one specific number. Instead, useful information is distributed across the vector, and relationships can be studied by comparing vectors.

I also learned that choosing an embedding model matters. Different models can behave differently depending on the task and the data. A model that works well for general semantic similarity may not automatically be perfect for a specific FAQ dataset.

What I learned from the project

Building the clothing-shop FAQ chatbot helped me understand why embeddings are important in practical NLP systems.

TF-IDF is simple, fast, and useful when important keywords are enough to identify the correct answer.

Embeddings provide another way to represent text by capturing semantic relationships. This can be especially useful when users express the same idea using different words.

The next step in my project is to evaluate both approaches using the same test questions and compare their results.

For me, word embeddings are not just another machine learning technique. They are a way of moving from thinking about text as a collection of individual words toward thinking about relationships and meaning in language.

Sources
Mikolov et al., Efficient Estimation of Word Representations in Vector Space (2013).
Mikolov et al., Distributed Representations of Words and Phrases and their Compositionality (2013).
Sentence Transformers documentation, Quickstart and Computing Embeddings.
REFERENCES

Mikolov, T., Chen, K., Corrado, G., & Dean, J. (2013). Efficient Estimation of Word Representations in Vector Space. arXiv. https://arxiv.org/abs/1301.3781
Pennington, J., Socher, R., & Manning, C. D. (2014). GloVe: Global Vectors for Word Representation. Proceedings of EMNLP 2014. https://aclanthology.org/D14-1162/
Sentence Transformers Documentation. Quickstart. https://www.sbert.net/docs/quickstart.html
Sentence Transformers. all-MiniLM-L6-v2. Hugging Face. https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2

nlp #machinelearning #python