DEV Community: Rose Umutesi

# Understanding Computer Vision: From Pixels to Object Detection

Rose Umutesi — Tue, 13 Oct 2026 14:25:36 +0000

Introduction

Computer vision is a field of artificial intelligence that enables computers to process and understand images and videos. It can be used in different areas, such as detecting vehicles, analyzing medical images, and identifying plant diseases.

During the Introduction to Computer Vision — Live Demo in the kLab TekHer AI Program, Cohort 2, I explored how computer vision works through practical experiments using Python and pretrained YOLO models. I worked with a sample bus image and my own photo to explore image processing, classification, object detection, and segmentation. I also tested how changes in brightness and image resolution affected the model's predictions.

In this blog, I explain what I did, the results I observed, and what I learned from the experiment.

1. How does a computer see an image?

When we look at a photograph, we can easily recognize objects such as people, buses, and buildings. A computer processes an image differently. A digital image is represented by numbers stored in an array, and a computer vision model uses patterns learned from data to make predictions.

For example, an RGB image has three color channels: red, green, and blue. Each pixel contains a value for each channel.

I used Python to load the bus image and inspect its numerical values.

import numpy as np
from PIL import Image

img = np.array(Image.open(IMAGE_PATH).convert("RGB"))

print("Image shape:", img.shape)
print("Data type:", img.dtype)
print("Minimum value:", img.min())
print("Maximum value:", img.max())

My output was:

Image shape: (1080, 810, 3)
Data type: uint8
Minimum value: 0
Maximum value: 255

This means the image had 1080 rows, 810 columns, and three color channels. The data type uint8 stores integer values between 0 and 255 for each channel.

For example, a pixel with values [197, 184, 168] represents a color formed by combining its red, green, and blue values.

What I learned: An image is not just a photograph to a computer. It is numerical data that can be inspected and processed using Python. Understanding this helped me see how computers can work with images.

2. Applying filters to images

After exploring how images are represented, I tested how filters can change them. A filter applies a mathematical operation to image pixels to create an effect, such as smoothing an image or highlighting its edges.

Grayscale

Grayscale removes the original color information and represents the image using shades of gray. I created a simple grayscale image by averaging the three color channels.

gray = img.mean(axis=2)

plt.imshow(gray, cmap="gray")
plt.title("Grayscale Image")
plt.axis("off")
plt.show()

Blur

A blur filter smooths an image by averaging nearby pixel values. I used a 5 × 5 kernel for this experiment.

blur_kernel = np.ones((5, 5)) / 25
blurred = convolve(gray, blur_kernel)

plt.imshow(blurred, cmap="gray")
plt.title("Blurred Image")
plt.axis("off")
plt.show()

The kernel is a small matrix that moves across the image and combines neighboring pixel values.

Edge detection

Edges are areas where brightness changes sharply. I used Sobel filters to highlight changes in horizontal and vertical directions.

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

sobel_y = sobel_x.T

edges = np.hypot(
    convolve(gray, sobel_x),
    convolve(gray, sobel_y)
)

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

I also tested sharpening, which emphasizes differences between neighboring pixels and can make details appear clearer.

These operations relate to image enhancement, where image properties are adjusted to change the visual result. The Pillow documentation explains how enhancement factors can be used to modify properties such as brightness and sharpness. Pillow ImageEnhance documentation

What I learned: Different filters highlight different information. Grayscale removes color, blur smooths details, edge detection highlights boundaries, and sharpening emphasizes details. This helped me understand some of the basic operations used in image processing.

3. Image classification: What is in the image?

Image classification assigns a category to an entire image. It answers a question such as, “What does this picture most likely contain?”

The Ultralytics documentation describes classification as categorizing an image based on its content. This is different from identifying the exact location of each object in the image. Ultralytics YOLO tasks documentation

I used a pretrained YOLO classification model:

from ultralytics import YOLO

classifier = YOLO("yolo11n-cls.pt")
results = classifier(IMAGE_PATH, verbose=False)

print(results[0].probs.top5)

When I tested the bus image, the top predictions were:

Predicted label	Confidence
Minibus	57.1%
Police van	33.7%
Trolleybus	4.2%
Recreational vehicle	1.4%
Streetcar	0.6%

The model predicted minibus with the highest confidence, followed by police van.

I also tested my own photo. The top predictions included grocery_store at 16.6%, French_horn at 16.4%, and restaurant at 8.6%. These labels did not clearly describe my photo, and the confidence scores were low.

What I learned: Classification can provide useful predictions, but it does not always produce the correct or most meaningful label. I learned to examine the model's predictions and confidence scores instead of automatically accepting its first answer.

4. Object detection: What is in the image, and where?

Object detection goes a step further than classification. It identifies objects and shows their locations using rectangular boxes called bounding boxes. The model can return a label, a confidence score, and coordinates for each detected object.

According to the Ultralytics documentation, object detection identifies and locates objects in images or video frames using bounding boxes. This makes it useful when we need to know both what an object is and where it appears. Ultralytics YOLO tasks documentation

I loaded a pretrained YOLO detection model and tested it on the bus image.

detector = YOLO("yolo11n.pt")

results = detector(IMAGE_PATH, conf=0.4, verbose=False)

annotated_image = results[0].plot()[:, :, ::-1]

plt.imshow(annotated_image)
plt.title("Object Detection")
plt.axis("off")
plt.show()

The model detected one bus at 94% confidence and four people at confidence scores of 89%, 88%, 86%, and 62%.

This was more informative than classification because I could see the locations of the detected objects.

Testing different confidence thresholds

I changed the confidence threshold to see how the results changed.

Confidence threshold	What I observed
0.1 (10%)	The bus and people were detected, along with a skateboard at 12% confidence.
0.4 (40%)	The model detected the bus and four people.
0.9 (90%)	Only the bus at 94% confidence remained.

A lower threshold allows more possible detections, including predictions that may be incorrect. A higher threshold removes lower-confidence predictions but may also exclude real objects.

What I learned: The confidence threshold affects which predictions are kept. Choosing a threshold involves balancing the possibility of missing real objects against the possibility of accepting incorrect detections.

5. Image segmentation: Understanding object shapes

Image segmentation provides more detailed information about the pixels belonging to an object. Instead of drawing only a rectangle around a person or bus, a segmentation model produces a mask that follows the object's visible shape.

Ultralytics explains that instance segmentation extends detection by producing pixel-level masks for individual objects. This detail can be useful in applications such as agricultural analysis and medical imaging. Ultralytics YOLO tasks documentation

I used a pretrained YOLO segmentation model:

segmenter = YOLO("yolo11n-seg.pt")

results = segmenter(IMAGE_PATH, conf=0.4, verbose=False)

annotated_image = results[0].plot()[:, :, ::-1]

plt.imshow(annotated_image)
plt.title("Image Segmentation")
plt.axis("off")
plt.show()

In my experiment, the notebook reported approximately 44% mask coverage for the bus image. It also produced masks for objects including the bus and several people.

The 44% value came from the mask calculation in my notebook. It should not be treated as an exact measurement of the real-world area occupied by the objects.

What I learned: Classification, detection, and segmentation solve different problems. Classification predicts what an image may contain, detection shows where objects are located, and segmentation provides more detail about their visible shapes. The right task depends on what information we need.

6. Testing the models on my own photo

One of the most interesting parts of the experiment was testing the models on my own photo instead of only using the sample images.

At a confidence threshold of 0.4, the detection model returned six person boxes. However, some boxes overlapped, so six detections did not necessarily mean six different people.

The classification model also returned unexpected labels, including grocery_store and French_horn. This helped me compare the output of classification with the output of object detection and segmentation.

What I learned: Testing a model on new images is important because its predictions may differ from what we expect. I also learned that detection counts need to be interpreted carefully, especially when bounding boxes overlap.

7. How brightness and resolution affected detection

I wanted to understand whether changing image quality would affect the model's predictions. I therefore tested different brightness levels and image resolutions.

Brightness experiment

I tested brightness factors of 0.3, 0.7, 1.0, and 1.5. A factor of 1.0 represented the original brightness, while lower and higher factors made the image darker and brighter.

Brightness factor	Person detections
0.3	4
0.7	6
1.0	6
1.5	5

The number of person detections changed when I adjusted the brightness. This showed that a change to the input image could affect the model's output.

Resolution experiment

I also resized my photo to different widths and ran the detection model again.

Image width	Observed result
48 pixels	1 person detection
128 pixels	4 person detections
320 pixels	3 person detections, plus two unexpected `pizza` predictions
640 pixels	6 person detections

The smallest image contained much less visual detail, and the model detected fewer people. The unexpected predictions at 320 pixels also showed that a model can make incorrect predictions.

These results describe my experiment. They do not mean that every small or bright image will produce the same results.

What I learned: Image quality can influence computer vision predictions. Changes in brightness may make objects harder to recognize, while reducing resolution can remove useful details. Increasing resolution does not guarantee that every prediction will be correct.

Result 1

person 90% box=(1096,857)-(1674,2446)
person 84% box=(153,976)-(706,2440)
person 64% box=(687,1290)-(1200,2445)
person 48% box=(654,996)-(1139,2442)
person 47% box=(1455,1073)-(1517,1171)
person 43% box=(2,1150)-(85,1359)

Result 2

person 91% box=(1104,857)-(1672,2446)
person 86% box=(152,981)-(703,2441)
person 58% box=(716,1454)-(1202,2446)
person 55% box=(677,1093)-(1195,2446)

Result 3

person 91% box=(1105,860)-(1675,2445)
person 82% box=(151,976)-(727,2441)
person 66% box=(655,999)-(1150,2442)
person 42% box=(1455,1075)-(1517,1172)
person 41% box=(0,1147)-(84,1360)

8. Testing model robustness

Model robustness refers to how well a model continues to perform when its input changes.

The notebook also included tests involving a very dark image, an image rotated upside down, a low-resolution image, and a blurred image. These conditions represent challenges that may occur when images are captured in real life.

My brightness and resolution experiments already showed that the number of detections could change when the input changed. I would need to compare the actual results from the rotation and blur tests before deciding which condition affected the model most.

What I learned: A model that performs well on one clear image may not perform equally well on every image. Testing different conditions helps us identify weaknesses and better understand the limits of a model.

9. My main lessons from the experiment

This practical session helped me connect computer vision concepts with actual code and model predictions. My main lessons were:

Images contain numerical data. I learned how pixels and RGB channels represent colors.
Filters change image information. Grayscale, blur, edge detection, and sharpening helped me understand basic image processing.
Classification and detection are different. Classification predicts a label for an image, while detection identifies objects and their locations.
Segmentation gives more detail. It produces masks that show the visible shapes of objects.
Confidence scores need interpretation. A model can produce uncertain or incorrect predictions.
Image quality matters. Changes in brightness and resolution affected the detections in my experiments.
Testing is important. Examining the outputs helped me notice unexpected predictions and overlapping boxes rather than assuming that the model was always right.

The most valuable part for me was testing the models on my own photo and observing how their predictions changed. It made the concepts easier to understand because I could compare what I expected with what the models actually produced.

Conclusion

This experiment gave me a practical introduction to computer vision. I started by examining an image as numerical data, then applied filters and explored classification, object detection, and segmentation. Finally, I tested how changes in brightness and resolution affected the model's predictions.

I learned that computer vision involves more than identifying objects in a photograph. We also need to understand the task we are solving, examine the results, and test how a model behaves when the input changes.

As I continue learning artificial intelligence and machine learning, I want to build on this knowledge by exploring how computer vision can be applied to practical problems, including identifying plant diseases in agriculture.

Resources

1. Ultralytics — YOLO Tasks Documentation

https://docs.ultralytics.com/tasks/

2. Pillow — ImageEnhance Documentation

https://pillow.readthedocs.io/en/stable/reference/ImageEnhance.html

Understanding Word Embeddings: How Machines Learn the Meaning of Words

Rose Umutesi — Wed, 30 Sep 2026 12:35:20 +0000

When I started learning Natural Language Processing (NLP), one question kept coming back to me: How can a computer understand words when words are just text?

A computer does not naturally understand that king and queen are related, or that cat and dog are more similar than cat and car. To a computer, these are simply sequences of characters.

This is where word embeddings become important.

What are word embeddings?

Word embeddings are a way of representing words as numerical vectors.

Instead of giving a machine the word:

"coffee"

we can represent it as something like:

[0.21, -0.43, 0.87, 0.12, ...]

The actual vectors usually have many more dimensions than this example. The important idea is that words with similar meanings or similar uses can have similar positions in a mathematical space.

This is based on a useful idea in linguistics: words that appear in similar contexts tend to have related meanings.

For example, consider:

I drank coffee in the morning.

and:

I drank tea in the morning.

Because coffee and tea appear in similar contexts, an embedding model can learn that they are related.

This is one reason embeddings are useful for NLP tasks such as text classification, recommendation systems, search, sentiment analysis, and information retrieval.

Word2Vec

One embedding method I studied is Word2Vec.

Word2Vec was introduced by researchers at Google and is designed to learn vector representations of words from text. Two important Word2Vec approaches are Continuous Bag of Words (CBOW) and Skip-gram.

The basic idea is surprisingly simple.

CBOW

CBOW tries to predict a word from the words surrounding it.

For example:

The farmer planted potatoes in the ___.

The surrounding words can help the model predict a word such as field.

Skip-gram

Skip-gram works in the opposite direction. It starts with a target word and tries to predict the words that appear around it.

For example:

The farmer planted potatoes in the field.

If the target word is potatoes, the model learns from words appearing around it, such as planted, farmer, and field.

After seeing many examples, the model adjusts its numerical representations so that words appearing in similar contexts develop related vectors.

A small Python example

We can experiment with Word2Vec using the gensim library.

from gensim.models import Word2Vec

sentences = [
    ["the", "farmer", "plants", "potatoes"],
    ["the", "farmer", "grows", "crops"],
    ["potatoes", "are", "important", "crops"],
    ["farmers", "grow", "maize", "and", "potatoes"],
    ["the", "farmer", "harvests", "crops"]
]

model = Word2Vec(
    sentences,
    vector_size=50,
    window=3,
    min_count=1,
    workers=4,
    seed=42
)

similar_words = model.wv.most_similar("potatoes", topn=3)

print(similar_words)

The output from my experiment was:

[('plants', 0.3308681547641754),
 ('the', 0.20481298863887787),
 ('are', 0.10614515095949173)]

The most_similar() method compares the vector for potatoes with the other word vectors and returns the words that are closest to it in the learned vector space.

In this experiment, plants had the highest similarity score among the three returned words. The scores indicate how close the word vectors are, with higher values representing greater similarity.

However, there is an important limitation. This example uses only five sentences, so the results should not be interpreted as meaningful knowledge about the English language. The model has very little data to learn from. A real Word2Vec model would normally be trained on a much larger and more representative corpus.

This experiment helped me understand an important point about word embeddings: the model is not learning dictionary definitions. Instead, it is learning patterns from how words appear in relation to other words.

What surprised me?

The most interesting thing I learned is that we can represent something as complicated as language using numbers.

At first, seeing a word represented by hundreds of numbers felt strange. I wondered how those numbers could possibly represent meaning.

The key realization was that one number does not represent one specific meaning. Instead, the entire vector represents a position in a learned mathematical space. Relationships between vectors can then capture useful patterns between words.

This also explains why word embeddings can perform interesting similarity tasks. If two words frequently occur in similar contexts, their vectors can end up relatively close together.

However, embeddings are not perfect. They can learn biases and patterns from the data used to train them. They also depend heavily on the quality and size of the training corpus.

What I struggled with

My biggest challenge was understanding the difference between text processing and meaning representation.

Techniques such as tokenization and TF-IDF are useful for converting text into numbers, but embeddings go a step further by learning relationships between words based on context.

I initially thought that an embedding was simply another way of encoding words. Now I understand that the important part is the relationship between the vectors, not just the individual numbers.

Final thoughts

Word embeddings helped me understand an important idea in NLP: computers do not need to understand language exactly like humans do in order to find useful patterns in text.

By representing words as vectors and learning from their contexts, models such as Word2Vec can capture relationships between words mathematically.

There are also other embedding approaches, including GloVe and FastText, each with different ways of learning word representations. Modern NLP has gone further with contextual representations from models such as BERT and transformer-based systems.

For me, learning word embeddings was a good reminder that machine learning often works by turning things that seem difficult to quantify—such as language—into representations that algorithms can process.

And that is what makes embeddings so interesting: words become numbers, but the relationships between those numbers can carry information about language.

References

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).
Goldberg & Levy, word2vec Explained: Deriving Mikolov et al.'s Negative-Sampling Word-Embedding Method (2014).

From Deep Learning Model to a Deployed Potato Disease Classifier 🥔

Rose Umutesi — Fri, 25 Sep 2026 12:07:14 +0000

From Deep Learning Model to a Deployed Potato Disease Classifier 🥔

Introduction

Potato diseases can significantly affect crop production and farmers' livelihoods. Early identification of diseases can help farmers take action before infections spread and cause greater losses.

As part of my AI and Machine Learning training, I worked on a deep learning project to build an image classification system that can identify three potato leaf conditions:

🌱 Healthy
🟤 Early Blight
🟤 Late Blight

The goal was not only to train a model, but to take the project from dataset preparation and model training to model export, application development, and online deployment.

The final application allows a user to upload a potato leaf image and receive a predicted class together with the model's confidence.

The Dataset

For this project, I used the PlantVillage dataset available through Kaggle.

I focused on three potato categories:

Potato___Early_blight
Potato___Late_blight
Potato___healthy

The selected dataset contained 2,152 potato leaf images.

Before training, I verified the images to make sure that the dataset did not contain corrupted files.

I then created a data pipeline using fastai. The images were resized to 224 × 224 pixels and divided into training and validation sets.

Choosing the Model

For the classification task, I used ResNet18, a convolutional neural network architecture commonly used for image classification.

I used transfer learning rather than training the network completely from scratch. This allowed me to fine-tune a pretrained model for the three potato disease classes.

The model was implemented using fastai and PyTorch.

Baseline Model

I first trained a baseline ResNet18 model using four fine-tuning epochs.

The baseline achieved a validation accuracy of:

98.37%

This provided a strong starting point. I then investigated whether changing the training configuration could improve the validation performance.

Experiment: Improving the Training Configuration

For my second experiment, I kept the ResNet18 architecture unchanged.

Instead, I changed the fine-tuning configuration:

Configuration	Baseline	Experiment 2
Architecture	ResNet18	ResNet18
Fine-tuning epochs	4	6
Learning rate	Default	0.001
Validation accuracy	98.37%	98.84%

Experiment 2 achieved a validation accuracy of 99.07%.

This showed how changing the training configuration could affect validation performance without changing the underlying model architecture.

Error Analysis

After training, I performed error analysis using fastai's classification interpretation tools.

I examined the confusion matrix and examples associated with the model's highest-loss predictions.

This helped me look beyond a single accuracy number and understand where the model could still make mistakes.

I also tested the model using images outside the original dataset. This showed an important practical consideration: a model can perform very well on images from the same dataset while finding images from different environments more challenging.

Differences in lighting, background, camera quality, leaf position, and image conditions can affect predictions.

Confusion matrix showing the model's classification performance across Healthy, Early Blight, and Late Blight classes.

Exporting the Model

After training and analysis, I exported the trained PyTorch model so that it could be used outside the notebook environment.

I exported the model to TorchScript.

This allowed me to load the model in a separate Python application without depending on the original training notebook.

I then uploaded the exported model to Hugging Face, where it could be accessed by my deployed application.

Local verification of the exported TorchScript model using test images from the PlantVillage dataset.

Building the Application

The next step was to turn the trained model into an application.

I initially explored a Gradio implementation, but I encountered an inference compatibility issue when loading the exported fastai model locally.

Instead of stopping there, I changed the model export and inference approach by using TorchScript and built the final application with Streamlit.

The application allows a user to:

Upload a potato leaf image.
Process the image using the trained model.
Receive a predicted disease class.
View the probability for each class.

The three possible predictions are:

Healthy | Early Blight | Late Blight

Deploying the Application

The exported model was hosted on Hugging Face, while the Streamlit application was deployed using Streamlit Community Cloud.

The application code was stored in GitHub, while the larger model file was stored separately on Hugging Face.

This allowed the Streamlit application to download the model when it starts.

The final application is publicly available here:

👉 Potato Disease Classifier — Live Demo

Challenges I Encountered

One of the most important lessons from this project was that training a model successfully is only one part of machine learning development.

1. Model inference compatibility

The first application approach using the exported fastai model encountered an inference compatibility issue.

I investigated the problem and changed the model export and inference approach by using TorchScript.

2. Large model file

The exported model was approximately 47 MB, which was too large to upload directly through GitHub's browser interface.

I therefore hosted the model separately on Hugging Face.

3. Deployment

I initially explored deploying the application through Hugging Face Spaces. However, the available free option did not provide the type of Python compute environment required for the application.

I therefore deployed the Streamlit application using Streamlit Community Cloud.

These challenges taught me that deploying machine learning models involves more than model accuracy. Model serialization, dependencies, file size, hosting, and the inference environment all matter.

What I Learned

This project helped me understand the complete workflow of taking a deep learning model beyond a notebook.

I learned how to:

Work with an image classification dataset.
Build a data pipeline using fastai.
Use transfer learning with ResNet18.
Fine-tune a pretrained model.
Compare different training configurations.
Perform error analysis.
Export a trained PyTorch model to TorchScript.
Host a model on Hugging Face.
Build an interactive Streamlit application.
Connect an application to a remotely hosted model.
Deploy a machine learning application online.
Troubleshoot model inference and deployment problems.

Most importantly, I learned that a machine learning project does not end when the model reaches a high accuracy. Turning a model into something that another person can use requires additional engineering, testing, and deployment work.

Conclusion

This project took a potato disease classifier from a training notebook to a publicly accessible web application.

The final experiment using ResNet18 achieved 99.07% validation accuracy. The model was then exported to TorchScript, hosted on Hugging Face, integrated into a Streamlit application, and deployed online.

The project gave me practical experience across the machine learning lifecycle—from data preparation and model training to deployment and troubleshooting.

Project Links

You can explore the project and try the deployed application below:

Thank you for reading!