What Is Computer Vision?

Build the mental model

Computer vision is the field of getting a computer to extract useful information out of images or video — deciding what's in a photo, where an object sits, or whether a video frame contains motion. It sits at the intersection of image processing (manipulating pixel data) and machine learning (recognizing patterns from examples), and for most of its history the two were separate: someone would hand-design a way to turn pixels into a small set of numbers (features), and a separate, simpler classifier would make the actual decision. A photo of a stop sign, for instance, might be reduced by hand-designed rules to 'mostly red, roughly octagonal, contains the letters S-T-O-P' before any decision gets made — every one of those rules was chosen by a human who thought carefully about what makes a stop sign a stop sign.

Deep learning changed which part of that pipeline gets designed by a human. Instead of hand-picking features, you hand the raw pixels to a neural network and let it learn, from thousands of labeled examples, which patterns of pixels are worth paying attention to. You already know from the Deep Learning with PyTorch course that a network learns its weights through backpropagation; this course is about pointing that same machinery specifically at images, and about the vision-specific ideas — color spaces, filtering, augmentation, spatial structure — that make images a distinct kind of input worth their own toolkit.

Connect it to a real scenario

On the Tutorial Platform, every course's landing card needs a banner image, and the upload pipeline has to decide how aggressively to compress each one before serving it to thousands of visitors: a simple line-art diagram compresses cleanly with classical rules (few colors, sharp edges, small file), while a photographic banner needs a learned image classifier just to detect 'this is a photo' reliably enough to route it to a different, quality-preserving compression path — a nice small-scale example of the classical-vs-learned split this lesson introduces.

Computer vision means extracting information from images/video; classical pipelines hand-design the feature-extraction step, while deep learning learns it end-to-end.
Deep learning doesn't remove preprocessing or postprocessing from vision systems — it replaces the hand-designed feature extraction stage specifically.
This course assumes PyTorch/tensor/CNN fundamentals and focuses on what's specific to images: color spaces, filtering, augmentation, and spatial structure.

Try the working example

text

CLASSICAL COMPUTER VISION PIPELINE
-----------------------------------
Raw Pixels  -->  Preprocess   -->  Hand-designed     -->  Hand-tuned      -->  Task Output
(H x W x 3)      (blur, gray,      Feature Extractor      Classifier           (label / count /
                  normalize)       (Sobel edges,          (SVM, decision        detection)
                                    SIFT keypoints,        tree, rules)
                                    HOG descriptors)

Every arrow above is designed by a human. A person decided which
edge kernel to use, which threshold counts as a "corner", and which
rule separates a cat from a dog.

DEEP-LEARNING COMPUTER VISION PIPELINE
---------------------------------------
Raw Pixels  ---------------------------------------->  Task Output
(H x W x 3)     Learned Feature Extractor                (label / count /
                (stacked Conv2d + pooling layers,         detection)
                 trained end-to-end by backprop)

Here a single trainable model replaces the hand-designed
middle stages. The network decides for itself which patterns
of pixels are worth detecting -- we only supply labeled
examples and a loss function.

THIS COURSE'S ROADMAP
----------------------
Basic         - this chapter. Images as tensors, filtering, transforms,
                classical features, and a CNN refresher aimed at vision.
Intermediate  - vision-specific architectures and training tricks:
                transfer learning, fine-tuning pretrained backbones,
                data pipelines for real image datasets.
Advanced      - object detection, semantic/instance segmentation,
                and other structured vision outputs beyond a single label.
Projects      - end-to-end builds combining earlier chapters into a
                deployable vision feature.
Exercises     - standalone practice problems across all difficulty levels.

You should see

This is a conceptual ASCII diagram, not runnable code, so there is no program output. Reading it top to bottom: the classical pipeline shows four human-designed stages between raw pixels and the task output, the deep-learning pipeline collapses those middle stages into a single learned block, and the roadmap section lists the five chapters this course is organized into, from Basic (this chapter) through Exercises.

5-minute try-it

Sketch (in your own notes, or extend the ASCII diagram above) where a step like 'resize to a fixed input size' or 'normalize pixel values' belongs in each pipeline — is it part of preprocessing, feature extraction, or something that happens in both regardless of classical vs. learned?

One important caution

Assuming classical CV techniques are obsolete and safe to skip entirely — real production pipelines often still use classical steps (denoising, thresholding, color-space conversion) as cheap pre/post-processing around a learned model, so not understanding them leaves you unable to debug hybrid systems.

Assuming 'deep learning replaces the whole pipeline' means a CNN needs no preprocessing at all — real image pipelines still resize, normalize, and augment images before the learned stage runs, and skipping that step is a common beginner mistake that silently hurts accuracy.

Wikipedia — Computer vision — Computer Vision