Exercise: Choose the Right CV Architecture

Build the mental model

Across this course you've built a toolkit — CNN classifiers, transfer learning, object detection, segmentation with U-Net, self-supervised representation learning, and model compression/quantization for edge deployment. Each tool carries different trade-offs along three axes: how much labeled data is available (plentiful, scarce, or none at all), what kind of output the task needs (a single label for the whole image, bounding boxes for multiple objects, or a pixel-level mask), and what the deployment environment allows (a beefy server GPU versus a power- and latency-constrained mobile chip). Choosing an architecture well means asking not 'which one gets the highest accuracy in a benchmark' but 'which one actually fits this problem's data, output, and deployment constraints.'

Connect it to a real scenario

The Tutorial Platform's 'Architecture Picker' quiz widget shuffles scenarios like these on each attempt — after you submit your reasoning for each one, the platform compares it against a scoring rubric and flags which considerations (data volume, output type, deployment target) you missed.

Choosing an architecture depends on data volume, output type, and deployment constraints together, not accuracy alone.
When labeled data is scarce, transfer learning or self-supervised learning is often the more practical choice than training from scratch.
For mobile or edge deployment, a compressed or quantized model that meets latency limits usually beats the highest-accuracy model available.

Try the working example

python

# Read each scenario and decide which architecture/technique from
# this course fits best. This script just prints the scenarios --
# the actual exercise happens in your head (or on paper).

scenarios = [
    {
        "id": 1,
        "description": "Classify product photos into 20 categories. "
                        "You have 50,000 labeled images.",
    },
    {
        "id": 2,
        "description": "Detect and count cars in real-time traffic "
                        "camera footage.",
    },
    {
        "id": 3,
        "description": "Segment tumors in CT scans, but only 200 "
                        "labeled scans are available.",
    },
    {
        "id": 4,
        "description": "Find visually similar images in a large photo "
                        "library with no labels at all.",
    },
    {
        "id": 5,
        "description": "Deploy an image classifier on a low-power "
                        "mobile device with strict latency limits.",
    },
]

if __name__ == "__main__":
    print("Computer Vision Architecture Picker")
    print("=" * 40)
    for scenario in scenarios:
        print(f"Scenario {scenario['id']}: {scenario['description']}")

You should see

Running this script simply prints a header and the five numbered scenarios — nothing else happens; there's no model training or architecture selection in the code itself. The real exercise happens after execution, in the reader's own reasoning about which technique fits each printed scenario.

5-minute try-it

Run the script and read the five scenarios it prints. For each one, write down which architecture or technique from this course (CNN classifier, transfer learning, object detection, segmentation/U-Net, self-supervised learning, or compression/quantization for edge deployment) fits best, and justify your choice by referencing data volume, output type, and deployment constraints.

One important caution

Picking whichever architecture sounds most powerful or accurate in isolation, ignoring hard deployment constraints like the mobile latency limit in scenario 5.

Overlooking how little labeled data a scenario actually has (only 200 CT scans in scenario 3) and reaching for a data-hungry from-scratch approach instead of transfer learning or self-supervised techniques.

Wikipedia — Computer vision — Computer Vision