So far we've used CNNs for a single task: looking at an image and assigning it a label. But classification is just the entry door. With the very same feature-extraction engine you already command — conv+pooling blocks building the edges→textures→parts→objects hierarchy — much richer tasks get solved: saying where each object is, cutting out its exact silhouette, reading text in a photo, or finding visually similar products. In this lesson we'll draw the complete map of computer vision tasks, each applied to a real TecnoMarket need, see what the pipeline of a production recognition system looks like, and ground it with two runnable examples: a Keras classifier making predictions on images, and a similarity search demo using embeddings and cosine similarity.

1. The task map: from classifying to segmenting
2. Object detection: YOLO and SSD from a bird's-eye view
3. Segmentation: semantic and instance
4. OCR: reading text in images
5. Visual similarity search: embeddings
6. The pipeline of a real system
7. Example 1: classify and predict with Keras
8. Example 2: cosine similarity between embeddings

Recognition tasks line up by the richness of their answer to the same photo:

Two clarifications about the table:

• Localization adds a regression to classification: besides the softmax probabilities, the network produces the rectangle's 4 numbers (x, y, width, height). Same convolutional extractor, one more output "head" — trained with a combined loss (the classification CCE from 02-04 plus an MSE over the coordinates).
• Detection generalizes to N objects, and that's where the difficulty lies: you don't know in advance how many there are.

Concrete TecnoMarket use cases, which we'll connect to each technique:

1. Moderating seller photos (our flagship project): classifying the product's category and rejecting photos that don't belong (a blurry photo, a prohibited object, an image with no product).
2. Detecting products in catalog images: a supplier sends a photo with 12 items on a table; the system localizes and crops each one.
3. Visual "similar products" search: a customer photographs a lamp they saw at a friend's place and the app finds the most similar ones in the catalog.
4. Label reading: extracting the serial number or model from the photo of an appliance's back label.

How does a network find a variable number of objects? The naive idea — sliding a classifier over thousands of windows of every possible size — works but is painfully slow. The modern families solve it in a single pass:

• YOLO (You Only Look Once): divides the image into a grid (e.g. 13×13). Each cell predicts, in one go, a few candidate boxes with their confidence and their class. Since everything comes out of a single pass through the CNN, it's fast enough to process video in real time.
• SSD (Single Shot Detector): same single-pass philosophy, but it predicts boxes from several levels of the convolutional hierarchy: the large maps of the early layers (high resolution) detect small objects, and the small, deep maps detect large objects — a direct use of the hierarchy of features from 03-01.

Common pieces worth knowing by name:

• Confidence: each box carries a probability of "there's an object here"; boxes below a threshold are discarded.
• Non-maximum suppression (NMS): several cells tend to propose nearly identical boxes over the same object; NMS keeps the highest-confidence one and removes the overlapping ones.

For the supplier photo with 12 items, a detector returns something like [("monitor", box1, 0.97), ("keyboard", box2, 0.91), ...], and with those boxes the system automatically crops each product to register it in the catalog. Training a detector requires datasets annotated with boxes and specialized losses — that's beyond this course; what matters here is knowing what to ask of these tools and recognizing their pieces.

When the rectangle isn't enough — removing the background of a product photo requires knowing exactly which pixels are product — we move to segmentation:

• Semantic: each pixel gets a class ("product", "background", "seller's hand"). Two coffee makers side by side form a single "coffee maker" blob.
• Instance: it additionally separates individual objects: coffee maker no. 1 and coffee maker no. 2 get different masks (it's the combination of detection + a mask per object).

The reference conceptual architecture for segmentation is the U-Net: it's U-shaped because the usual convolutional stage that shrinks the image while extracting features (the encoder, everything you learned in 03-02) is followed by a symmetric stage that expands it back to the original size (the decoder), producing a per-pixel prediction. The skip connections between symmetric levels of the U (close cousins of ResNet's, but concatenating instead of adding) reinject the fine detail of the early layers so the contours come out sharp.

Use at TecnoMarket: automatic background removal so all catalog photos have a uniform white background — semantic product/background segmentation and replacement of the background pixels.

OCR (Optical Character Recognition) converts images containing text into digital text. A modern system chains two stages, both powered by CNNs:

1. Text detection: locating the regions of the image that contain text (a detection problem like the previous section's, with "text" as the class).
2. Recognition: reading each region. A CNN extracts features from the image strip and a sequential component transcribes them character by character — text is a sequence, and to model sequences we'll use the recurrent networks of module 4; here we stay at the concept level.

At TecnoMarket, OCR automates label reading: the seller photographs the appliance's back label and the system extracts model, serial number, and energy class, filling in the product sheet without typing. In practice you rarely train your own OCR: existing engines are used (Tesseract, cloud services) except for very specific needs.

The most elegant application of the feature extractor: using the CNN without the classification layer. Recall the anatomy from 03-01: after the convolutional stage (and the global average pooling from 03-03), the image ends up summarized in a vector of, say, 128 numbers that condense its visual features. That vector is called an embedding.

The key property: visually similar images produce nearby embeddings. Two lamps of similar design land at close points in that 128-dimensional space even though their pixels differ in everything (background, angle, lighting); a lamp and an air fryer land far apart.

How "near" is measured: with cosine similarity, the cosine of the angle between the two vectors:

It equals 1 if they point in the same direction (very similar), 0 if they're perpendicular (nothing in common), and −1 if they're opposite. It's preferred over Euclidean distance because it ignores the vector's magnitude (how much the image activates overall) and compares only the pattern of features.

TecnoMarket's "similar products" system ends up like this:

1. Indexing (once): run every catalog photo through the CNN and store its embedding in a database.
2. Query (live): the customer uploads their photo → embedding → cosine similarity against the index → return the K nearest products.

This pattern (encoding anything as a vector and searching by proximity) is universal today: you'll meet it again with text in module 4 and with the autoencoders of 05-02.

None of these networks works alone. TecnoMarket's photo moderation system, from the seller's upload to the published product sheet, chains:

• Preprocessing: photos arrive in arbitrary sizes and formats; they are resized to the network's input size and the pixels are normalized (for example from [0, 255] to [0, 1], as we did with MNIST in 02-05). Iron rule: the inference image must be preprocessed exactly like the training ones.
• Training is separate: during training (not inference), data augmentation is additionally applied — rotating, cropping, changing brightness — to multiply variety; it's a regularization technique and we'll develop it in 05-04.
• Inference: one forward pass (02-03) of the already-trained model. No backprop, no gradients: milliseconds per image.
• Threshold-based decision: a production system never blindly trusts the softmax. If the maximum probability doesn't clear a threshold (e.g. 0.85), the photo goes to human review. The threshold balances automating a lot against making few mistakes.

The course's methodology: prototype on a public dataset before touching TecnoMarket's data. We use CIFAR-10 (60,000 32×32 color photos, 10 classes: airplane, automobile, bird...), which stands in for our product photos. We train a small CNN briefly and focus on the new part: predicting on images and reading the predictions. (The full guided project, with more training, fine-grained evaluation, and iterative improvement, is the one in lesson 07-01.)

Typical output (it will vary with the random initialization):

How to read it with production-system eyes:

• model.predict returns the full softmax distribution (10 probabilities per image), not a label. The label is our decision: np.argmax(probs).
• The "ship" at 88.9% would clear a 0.85 threshold and get auto-labeled; the "cat" at 54.2% would go to human review. Showing the top-3 helps the reviewer: if the first two options are "cat" and "dog", the doubt is reasonable; if they are "cat" and "truck", something odd is going on with the photo.
• For a new TecnoMarket photo the flow would be identical: load the JPG, resize to 32×32 (or the model's input size), normalize by dividing by 255, add the batch dimension (np.expand_dims(img, 0)), and call predict.

Now the visual search. Teaching trick: instead of training a specialized embedding network, we reuse the previous CNN cut off before the softmax layer — the output of the GlobalAveragePooling2D (64 numbers) is our embedding.

Typical output:

Observations:

• keras.Model(inputs=..., outputs=intermediate_layer.output) creates a "view" of the network that ends wherever we say: this is how embeddings are extracted (and how intermediate feature maps are visualized, as we noted in 03-02).
• The nearest neighbors share the class or are visually related classes (horse/deer): the embedding space organizes images by visual resemblance, not by pixels. And nobody trained the network "to search": it's a side effect of learning to classify.
• TecnoMarket's real system would follow this scheme with two upgrades: a much more powerful extractor (a pretrained network — transfer learning, 05-03) and a vector database to search among millions of embeddings without scanning them one by one.

• Choosing a more expensive task than necessary. If knowing what product it is suffices, don't set up detection; if the box suffices, don't set up segmentation. Each jump in output richness multiplies the cost of annotating data and computing. Start with the minimal task that solves the problem.
• Preprocessing differently in training and inference. If you trained with pixels in [0, 1] and production feeds in [0, 255], the model will see garbage and fail without raising an error. Encapsulate the preprocessing in a single function used in both places.
• Treating the softmax as certainty. A 99% softmax is no guarantee; faced with a truly bizarre image (a product that didn't exist at training time) the network will spread probabilities across what it knows. Hence the thresholds and the human review queue.
• Forgetting the batch dimension when predicting a single image. predict expects shape (N, height, width, channels); with a lone image of shape (32, 32, 3) it will fail. Solution: np.expand_dims(image, axis=0).
• Comparing embeddings with Euclidean distance without normalizing. Two images with the same feature pattern but different activation "intensity" would end up far apart in Euclidean terms; cosine similarity (or normalizing the vectors first) compares directions and is the standard practice.

For each TecnoMarket need, name the appropriate vision task (classification, localization, detection, semantic segmentation, instance segmentation, OCR, or embedding search) and justify it in one sentence:

1. Automatically rejecting photos where the product occupies less than 20% of the image.
2. Generating the uniform white background for all catalog photos.
3. Counting how many units appear in the photo of a batch of identical headphones and cropping each one.
4. Suggesting "other customers viewed these similar products" from the product sheet's photo.
5. Verifying that the serial number in the photo matches the one declared in the form.

Three products have these simplified 3-dimensional embeddings: lamp A = (0.9, 0.1, 0.2), lamp B = (0.8, 0.2, 0.1), air fryer = (0.1, 0.9, 0.8). Compute the cosine similarity between lamp A and lamp B, and between lamp A and the air fryer. Do the numbers confirm the intuition?

TecnoMarket's photo classifier automates publication if the maximum probability exceeds the threshold T. With T = 0.5 it automates 95% of photos with 8% errors; with T = 0.9 it automates 60% with 1% errors. Which threshold would you choose if (a) category errors are cheap to fix afterwards, (b) a misclassified photo could publish a product into a category with legal requirements (e.g. gas appliances)? What third, middle-ground option does the pipeline from this lesson offer?

Exercise 1:

1. Classification + localization: a box around the product is enough to compute what fraction of the image it occupies.
2. Semantic segmentation: you have to decide pixel by pixel what is product and what is background in order to replace the background.
3. Instance segmentation (or detection, if the box is enough for cropping): the headphones are identical and must be separated unit by unit.
4. Embedding search: it is exactly the case of visual similarity between catalog and query.
5. OCR: locate and read the serial number's text to compare it against the form.

Exercise 2:

• A · B = 0.9·0.8 + 0.1·0.2 + 0.2·0.1 = 0.76. ‖A‖ = √(0.81+0.01+0.04) = √0.86 ≈ 0.927. ‖B‖ = √(0.64+0.04+0.01) = √0.69 ≈ 0.831. Similarity = 0.76 / (0.927 × 0.831) ≈ 0.987.
• A · F = 0.9·0.1 + 0.1·0.9 + 0.2·0.8 = 0.34. ‖F‖ = √(0.01+0.81+0.64) = √1.46 ≈ 1.208. Similarity = 0.34 / (0.927 × 1.208) ≈ 0.304.
• Yes: the two lamps are almost collinear (0.987, practically identical to the system) and the air fryer sits far away (0.304).

Exercise 3:

• (a) With cheap errors, T = 0.5: automating 95% saves an enormous amount of human work, and the 8% of errors gets fixed later at little cost.
• (b) With legal risk, T = 0.9 (or higher): 1% of errors may still be too much for that particular category; you could even force human review whenever the predicted class is a regulated category, regardless of confidence.
• The third option is the pipeline's: threshold + human review queue — photos below the threshold aren't rejected, they get reviewed. It can be tuned per category: a low threshold for phone cases, a very high one (or mandatory review) for sensitive categories.

This module started with a limitation (dense networks don't scale to images) and ends with a complete panorama of what CNNs make possible. In this lesson you've placed every task in its slot — classifying, localizing, detecting (YOLO/SSD in a single pass), segmenting (U-Net with its encoder-decoder), reading text, and searching by similarity — and mapped them to TecnoMarket's operations: photo moderation, automatic catalog registration, uniform white backgrounds, label reading, and "similar products". You've seen that a real system is a pipeline (identical preprocessing in training and inference, confidence thresholds, human review), you've made real predictions with Keras on CIFAR-10 reading the softmax with a production mindset, and you've built a similarity search engine by reusing your classifier as an embedding extractor — the definitive demonstration that the convolutional stage is a general-purpose feature extractor.

With this we close the CNN module: you know why they exist (03-01), how their layers are configured (03-02), which architectures paved the way (03-03), and everything that gets built with them (03-04). The full guided project on classifying product photos awaits you in 07-01, and the reuse of pretrained networks in 05-03. But first, a change of gears: CNNs dominate data with spatial structure; module 4 tackles data with temporal or sequential structure — the reviews TecnoMarket customers write, their purchase histories, week-by-week demand. For that we need networks with memory: recurrent neural networks (RNNs).