Azure Certifications

Appearance

Implement Computer Vision Solutions - Q&A ​

This document contains comprehensive questions and answers for the Implement Computer Vision Solutions domain of the AI-102 exam.

Section 1: Azure AI Vision Service Basics ​

Q1.1: What is Azure AI Vision Service, and what capabilities does it provide? ​

Answer: Azure AI Vision Service is a cloud-based service that provides advanced image analysis capabilities using pre-trained machine learning models. Key capabilities include:

  1. Image Analysis:

    • Tag detection (objects, scenes, activities)
    • Image categorization
    • Color scheme detection
    • Image type detection (clip art, line drawing, photograph)
    • Content moderation (adult/racy content detection)

  2. Optical Character Recognition (OCR):

    • Extract printed and handwritten text
    • Multi-language text recognition
    • Text extraction from images and PDFs
    • Layout preservation

  3. Object Detection:

    • Detect and locate objects in images
    • Bounding box coordinates
    • Object counts and positions

  4. Face Detection:

    • Detect faces in images
    • Age and gender estimation
    • Face landmarks detection

  5. Spatial Analysis:

    • People counting
    • Crowd analysis
    • Zone analytics
    • Track movement patterns

  6. Read API:

    • Advanced OCR for documents
    • Handwritten text recognition
    • Batch processing support
    • Improved accuracy for documents

Detailed Explanation: Azure AI Vision Service offers comprehensive image understanding capabilities without requiring model training, making it accessible for various use cases from content moderation to document digitization.

Use Cases:

  • Content moderation for user-generated content
  • Document digitization and OCR
  • Image tagging and categorization
  • Quality control in manufacturing
  • Retail analytics
  • Accessibility features (image descriptions)

Service Tiers:

  • Free Tier (F0): Limited transactions
  • Standard Tier (S1): Pay-as-you-go pricing
  • S0 Tier: Alternative pricing tier

Documentation Links:

Q1.2: How do you analyze images using Azure AI Vision Service? ​

Answer: Analyze images using Azure AI Vision Service:

  1. Setup:

    python
    from azure.cognitiveservices.vision.computervision import ComputerVisionClient
from msrest.authentication import CognitiveServicesCredentials

client = ComputerVisionClient(
    endpoint=endpoint,
    credentials=CognitiveServicesCredentials(api_key)
)

  2. Image Analysis:

    python
    # Analyze image
image_url = "https://example.com/image.jpg"
analysis = client.analyze_image(
    image_url,
    visual_features=[
        VisualFeatures.tags,
        VisualFeatures.description,
        VisualFeatures.categories,
        VisualFeatures.color,
        VisualFeatures.adult
    ]
)

  3. Extract Information:

    • Tags: analysis.tags
    • Description: analysis.description.captions
    • Categories: analysis.categories
    • Colors: analysis.color
    • Adult content: analysis.adult

  4. Local Image Analysis:

    python
    with open("local_image.jpg", "rb") as image_file:
    analysis = client.analyze_image_in_stream(
        image_file,
        visual_features=[...]
    )

Detailed Explanation: Image analysis extracts comprehensive information from images using pre-trained models, enabling applications to understand image content without custom training.

Visual Features:

  • Tags: Object and scene tags (e.g., "person", "outdoor", "building")
  • Description: Natural language description
  • Categories: High-level category classification
  • Color: Dominant colors and accent colors
  • Adult: Adult/racy content detection
  • Faces: Face detection and attributes
  • Image Type: Clip art, line drawing, or photograph
  • Objects: Object detection with bounding boxes
  • Brands: Brand logo detection

Response Structure:

json
{
  "tags": [
    {"name": "person", "confidence": 0.99},
    {"name": "outdoor", "confidence": 0.95}
  ],
  "description": {
    "captions": [
      {"text": "A person standing outside", "confidence": 0.91}
    ]
  },
  "categories": [
    {"name": "outdoor_", "score": 0.93}
  ],
  "color": {
    "dominantColors": ["Blue", "Green"],
    "accentColor": "1A2B3C"
  },
  "adult": {
    "isAdultContent": false,
    "isRacyContent": false,
    "adultScore": 0.01,
    "racyScore": 0.01
  }
}

Best Practices:

  • Select relevant visual features to reduce costs
  • Use appropriate image resolution (not too large)
  • Handle errors gracefully
  • Cache results for frequently analyzed images
  • Respect rate limits

Documentation Links:

Q1.3: How do you extract text from images using OCR? ​

Answer: Extract text using OCR:

  1. Using OCR API:

    python
    # From URL
ocr_result = client.recognize_printed_text(
    url=image_url,
    language="en",
    detect_orientation=True
)

# From local file
with open("image.jpg", "rb") as image_file:
    ocr_result = client.recognize_printed_text_in_stream(
        image_file,
        language="en",
        detect_orientation=True
    )

  2. Using Read API (Recommended):

    python
    # Start read operation
read_operation = client.read(
    image_url,
    raw=True
)

# Get operation ID
operation_id = read_operation.headers["Operation-Location"].split("/")[-1]

# Wait for completion
while True:
    read_result = client.get_read_result(operation_id)
    if read_result.status == OperationStatusCodes.succeeded:
        break
    time.sleep(1)

# Extract text
for result in read_result.analyze_result.read_results:
    for line in result.lines:
        print(line.text)

  3. Extract Text Regions:

    • Access regions with bounding boxes
    • Extract text from specific areas
    • Preserve text layout
    • Handle multiple languages

Detailed Explanation: Azure AI Vision provides two OCR options: traditional OCR API for simple scenarios and Read API for advanced document processing with better accuracy and support for handwritten text.

OCR vs Read API:

FeatureOCR APIRead API
Printed Text✅✅
Handwritten Text❌✅
AccuracyGoodBetter
LanguagesMultipleMultiple
Processing TimeFasterSlower (async)
Document SupportLimitedBetter
Layout PreservationBasicAdvanced

OCR Best Practices:

  1. Image Quality:

    • Use high-resolution images
    • Ensure good contrast
    • Minimize noise and blur
    • Proper lighting

  2. Language Specification:

    • Specify language when known
    • Use multi-language for mixed content
    • Auto-detect if unknown

  3. Orientation Detection:

    • Enable automatic orientation detection
    • Pre-rotate if needed
    • Handle rotated text

  4. Performance:

    • Use Read API for documents
    • Use OCR API for simple text extraction
    • Batch process for multiple images
    • Cache results when possible

Supported Languages:

  • English, Spanish, French, German, Italian, Portuguese
  • Chinese (Simplified and Traditional)
  • Japanese, Korean
  • Arabic, Russian
  • And many more (100+ languages)

Documentation Links:

Section 2: Custom Vision ​

Q2.1: What is Azure Custom Vision, and when should you use it? ​

Answer: Azure Custom Vision is a service for building custom image classification and object detection models without deep learning expertise. Use it when:

  1. Domain-Specific Classification:

    • Classify images specific to your domain
    • Pre-trained models don't cover your use case
    • Need custom categories not in general models

  2. Object Detection:

    • Detect and locate specific objects
    • Count objects in images
    • Find object positions with bounding boxes

  3. Custom Requirements:

    • Specific accuracy requirements
    • Need for fine-tuned models
    • Industry-specific classifications

  4. Limited Training Data:

    • Quick iteration with limited examples
    • Transfer learning from pre-trained models
    • Fast model training

Detailed Explanation: Custom Vision simplifies creating custom computer vision models by handling the complexity of deep learning, enabling developers to build models with minimal machine learning knowledge.

Custom Vision Types:

  1. Image Classification:

    • Single-label: One tag per image
    • Multi-label: Multiple tags per image
    • Predict tags for new images

  2. Object Detection:

    • Detect objects in images
    • Provide bounding boxes and confidence scores
    • Count instances of objects

Use Cases:

  • Quality control in manufacturing
  • Retail product categorization
  • Medical image classification
  • Agricultural monitoring
  • Security and surveillance
  • Brand logo detection

When NOT to Use:

  • General image analysis (use Azure AI Vision)
  • Simple tagging (use Azure AI Vision)
  • When training data is insufficient
  • Real-time requirements without edge deployment

Documentation Links:

Q2.2: How do you train a custom image classification model? ​

Answer: Train a custom image classification model:

  1. Create Project:

    python
    from azure.cognitiveservices.vision.customvision.training import CustomVisionTrainingClient
from msrest.authentication import ApiKeyCredentials

training_client = CustomVisionTrainingClient(
    endpoint=endpoint,
    credentials=ApiKeyCredentials(in_headers={"Training-key": training_key})
)

project = training_client.create_project(
    name="My Classification Project",
    description="Custom image classification",
    domain_id=domain_id,  # e.g., General
    classification_type="Multilabel"  # or "Multiclass"
)

  2. Upload and Tag Images:

    python
    # Create tags
tag1 = training_client.create_tag(project.id, "cat")
tag2 = training_client.create_tag(project.id, "dog")

# Upload images with tags
training_client.create_images_from_urls(
    project.id,
    images=[
        {"url": "https://example.com/cat1.jpg", "tag_ids": [tag1.id]},
        {"url": "https://example.com/dog1.jpg", "tag_ids": [tag2.id]}
    ]
)

  3. Train Model:

    python
    iteration = training_client.train_project(
    project.id,
    training_type="Regular",  # or "Advanced"
    reserved_budget_in_hours=0,  # For Training tier
    force_train=False
)

# Wait for training to complete
while iteration.status == "Training":
    iteration = training_client.get_iteration(project.id, iteration.id)
    time.sleep(1)

  4. Evaluate and Publish:

    python
    # Get performance metrics
performance = training_client.get_iteration_performance(
    project.id,
    iteration.id
)

# Publish iteration
training_client.publish_iteration(
    project.id,
    iteration.id,
    publish_name="production",
    prediction_resource_id=prediction_resource_id
)

Detailed Explanation: Custom Vision training involves creating a project, uploading labeled images, training the model, and publishing it for use. The service handles model architecture and training optimization.

Training Types:

  1. Regular Training:

    • Fast training
    • Good for most use cases
    • Quick iterations

  2. Advanced Training:

    • Longer training time
    • Better accuracy potential
    • Use when accuracy is critical

Classification Types:

  • Multiclass: One tag per image (mutually exclusive)
  • Multilabel: Multiple tags per image (can have multiple)

Training Data Requirements:

  • Minimum: 50 images per tag (recommended: 100+)
  • Balance: Equal number of images per tag
  • Quality: Clear, diverse, representative images
  • Variety: Different angles, lighting, backgrounds

Training Best Practices:

  1. Data Quality:

    • High-quality images
    • Consistent labeling
    • Remove duplicates
    • Balanced dataset

  2. Tag Strategy:

    • Clear, descriptive tags
    • Consistent naming
    • Avoid overlapping concepts
    • Include "negative" examples if needed

  3. Iteration:

    • Start with small dataset
    • Test early iterations
    • Add images based on errors
    • Iterate to improve

  4. Evaluation:

    • Review precision and recall
    • Test with validation set
    • Identify confusion cases
    • Improve weak areas

Performance Metrics:

  • Precision: Percentage of positive predictions that are correct
  • Recall: Percentage of actual positives correctly identified
  • Average Precision: Overall performance measure
  • Per-Tag Metrics: Performance for each tag

Documentation Links:

Q2.3: How do you train an object detection model? ​

Answer: Train an object detection model:

  1. Create Object Detection Project:

    python
    project = training_client.create_project(
    name="My Object Detection Project",
    description="Custom object detection",
    domain_id=domain_id,  # Object Detection domain
    project_type="ObjectDetection"
)

  2. Upload Images and Create Regions:

    python
    # Create tags
tag = training_client.create_tag(project.id, "product")

# Upload image
image = training_client.create_images_from_data(
    project.id,
    image_data=image_bytes,
    tag_ids=[tag.id]
)

# Create region with bounding box
# Region format: left, top, width, height (normalized 0-1)
region = {
    "tag_id": tag.id,
    "left": 0.1,
    "top": 0.2,
    "width": 0.3,
    "height": 0.4
}

training_client.create_image_regions(
    project.id,
    image.id,
    regions=[region]
)

  3. Train Model:

    python
    iteration = training_client.train_project(
    project.id,
    training_type="Advanced"  # Recommended for object detection
)

# Wait for training
while iteration.status == "Training":
    iteration = training_client.get_iteration(project.id, iteration.id)
    time.sleep(1)

  4. Test and Publish:

    python
    # Test prediction
from azure.cognitiveservices.vision.customvision.prediction import CustomVisionPredictionClient

predictor = CustomVisionPredictionClient(
    endpoint=prediction_endpoint,
    credentials=ApiKeyCredentials(in_headers={"Prediction-key": prediction_key})
)

results = predictor.detect_image(
    project.id,
    publish_name,
    image_data
)

# Publish iteration
training_client.publish_iteration(
    project.id,
    iteration.id,
    publish_name="production",
    prediction_resource_id=prediction_resource_id
)

Detailed Explanation: Object detection models identify and locate objects in images, providing both classification and spatial information (bounding boxes). Training requires images with annotated bounding boxes.

Object Detection Features:

  • Bounding Boxes: Precise object location
  • Confidence Scores: Prediction certainty
  • Multiple Objects: Detect multiple instances
  • Object Counting: Count instances per class

Training Data Requirements:

  • Minimum: 50 images per tag (recommended: 200+)
  • Annotations: Accurately labeled bounding boxes
  • Coverage: Various sizes, positions, angles
  • Diversity: Different backgrounds and contexts

Bounding Box Format:

  • Coordinates normalized to 0-1 range
  • Format: (left, top, width, height)
  • Left/Top: Top-left corner position
  • Width/Height: Bounding box dimensions

Annotation Best Practices:

  1. Accuracy:

    • Tight bounding boxes around objects
    • Include entire object
    • Consistent annotation style

  2. Coverage:

    • Annotate all instances
    • Include partial/occluded objects
    • Handle overlapping objects

  3. Quality:

    • Review annotations
    • Remove incorrect annotations
    • Update based on errors

Use Cases:

  • Product detection in retail
  • Vehicle detection for parking
  • Quality inspection in manufacturing
  • Wildlife monitoring
  • Safety equipment detection

Documentation Links:

Q2.4: How do you deploy a Custom Vision model for production use? ​

Answer: Deploy Custom Vision model:

  1. Publish Iteration:

    python
    training_client.publish_iteration(
    project.id,
    iteration.id,
    publish_name="production",
    prediction_resource_id=prediction_resource_id
)

  2. Get Prediction Endpoint:

    python
    publish_name = "production"
prediction_endpoint = f"{endpoint}/customvision/v3.0/Prediction/{project.id}/classify/iterations/{publish_name}"

  3. Use Prediction API:

    python
    from azure.cognitiveservices.vision.customvision.prediction import CustomVisionPredictionClient

predictor = CustomVisionPredictionClient(
    endpoint=prediction_endpoint,
    credentials=ApiKeyCredentials(in_headers={"Prediction-key": prediction_key})
)

# Predict from URL
results = predictor.classify_image(
    project.id,
    publish_name,
    url=image_url
)

# Predict from bytes
with open("image.jpg", "rb") as image_file:
    results = predictor.classify_image_with_no_store(
        project.id,
        publish_name,
        image_file.read()
    )

# For object detection
results = predictor.detect_image(
    project.id,
    publish_name,
    image_data
)

  4. Edge Deployment (Optional):

    • Export model to TensorFlow or ONNX
    • Deploy to edge devices
    • Use offline inference

Detailed Explanation: After training, models are published and accessible via prediction API. Models can also be exported for edge deployment when internet connectivity is limited.

Deployment Options:

  1. Cloud API:

    • REST API calls to Azure
    • Internet required
    • Automatic updates
    • Scalable

  2. Edge Deployment:

    • Export to TensorFlow or ONNX
    • Deploy to edge devices
    • Offline inference
    • Lower latency

Edge Export Formats:

  • TensorFlow: For TensorFlow Lite
  • ONNX: Open Neural Network Exchange
  • Docker Container: For containerized deployment
  • CoreML: For iOS/macOS (classification only)

Export and Deploy Edge:

python
# Export model
export = training_client.export_iteration(
    project.id,
    iteration.id,
    platform="TensorFlow",  # or "ONNX", "DockerFile", "CoreML"
    flavor="TensorFlowLite"  # or "TensorFlowNormal"
)

# Download exported model
# Use exported model on edge device

Production Best Practices:

  1. Versioning:

    • Use meaningful publish names
    • Keep multiple iterations
    • Test before promoting
    • Rollback capability

  2. Monitoring:

    • Track prediction performance
    • Monitor API usage
    • Log predictions and errors
    • Alert on issues

  3. Performance:

    • Cache predictions when possible
    • Batch requests when appropriate
    • Optimize image size
    • Use edge deployment for low latency

  4. Security:

    • Secure API keys
    • Use Azure AD authentication if available
    • Implement rate limiting
    • Monitor for abuse

Documentation Links:

Section 3: Face Service ​

Q3.1: What is Azure Face Service, and what capabilities does it provide? ​

Answer: Azure Face Service provides face recognition and analysis capabilities using AI. Key capabilities include:

  1. Face Detection:

    • Detect faces in images
    • Face landmarks (eyes, nose, mouth, etc.)
    • Face attributes (age, gender, emotion, accessories)

  2. Face Verification:

    • Verify if two faces belong to the same person
    • One-to-one verification
    • Confidence scores

  3. Face Identification:

    • Identify a person from a group
    • One-to-many matching
    • Large-scale identity matching

  4. Face Grouping:

    • Group similar faces together
    • Organize faces by similarity
    • Find duplicate faces

  5. Find Similar Faces:

    • Find faces similar to a query face
    • Similarity-based search
    • Face similarity ranking

  6. Face Recognition:

    • Build face recognition systems
    • Large-scale person recognition
    • Access control systems

Detailed Explanation: Azure Face Service enables building face recognition applications with robust detection, verification, and identification capabilities, suitable for security, access control, and personalization scenarios.

Key Features:

  • High Accuracy: State-of-the-art face recognition
  • Robust Detection: Handles various poses, lighting, and expressions
  • Scalability: Supports large-scale face databases
  • Privacy: Configurable data retention policies
  • Compliance: GDPR and privacy-compliant options

Use Cases:

  • Access control and security
  • Customer identification
  • Photo organization and tagging
  • Attendance systems
  • Missing person searches
  • Personalized experiences

Limitations and Considerations:

  • Privacy and ethical considerations
  • Bias and fairness concerns
  • Consent requirements
  • Regulatory compliance (GDPR, etc.)
  • Lighting and angle requirements

Documentation Links:

Q3.2: How do you implement face detection and recognition? ​

Answer: Implement face detection and recognition:

  1. Setup Face Client:

    python
    from azure.cognitiveservices.vision.face import FaceClient
from msrest.authentication import CognitiveServicesCredentials

face_client = FaceClient(
    endpoint=endpoint,
    credentials=CognitiveServicesCredentials(api_key)
)

  2. Detect Faces:

    python
    # Detect faces from URL
detected_faces = face_client.face.detect_with_url(
    url=image_url,
    return_face_id=True,
    return_face_landmarks=True,
    return_face_attributes=[
        "age", "gender", "headPose", "smile",
        "facialHair", "glasses", "emotion",
        "hair", "makeup", "occlusion", "accessories",
        "blur", "exposure", "noise"
    ]
)

# Detect from local file
with open("image.jpg", "rb") as image_file:
    detected_faces = face_client.face.detect_with_stream(
        image_file,
        return_face_id=True,
        return_face_attributes=["age", "gender", "emotion"]
    )

  3. Face Attributes:

    python
    for face in detected_faces:
    print(f"Face ID: {face.face_id}")
    print(f"Age: {face.face_attributes.age}")
    print(f"Gender: {face.face_attributes.gender}")
    print(f"Emotion: {face.face_attributes.emotion}")
    print(f"Glasses: {face.face_attributes.glasses}")

  4. Face Recognition (Identification):

    python
    # Create Person Group
person_group_id = "my-person-group"
face_client.person_group.create(
    person_group_id,
    name="My Person Group",
    recognition_model="recognition_04"  # or recognition_03
)

# Create Person
person = face_client.person_group_person.create(
    person_group_id,
    name="John Doe"
)

# Add Face to Person
face_client.person_group_person.add_face_from_url(
    person_group_id,
    person.person_id,
    url=person_image_url
)

# Train Person Group
face_client.person_group.train(person_group_id)

# Wait for training
while True:
    status = face_client.person_group.get_training_status(person_group_id)
    if status.status == "succeeded":
        break
    time.sleep(1)

# Identify Face
face_ids = [face.face_id for face in detected_faces]
results = face_client.face.identify(
    face_ids=face_ids,
    person_group_id=person_group_id
)

  5. Face Verification:

    python
    # Verify two faces
verify_result = face_client.face.verify_face_to_face(
    face_id1=face_id1,
    face_id2=face_id2
)

print(f"Same person: {verify_result.is_identical}")
print(f"Confidence: {verify_result.confidence}")

Detailed Explanation: Face detection identifies faces and extracts attributes, while face recognition matches faces against known identities. Face Service supports both detection and recognition scenarios.

Recognition Models:

  • recognition_03: Previous generation
  • recognition_04: Latest, improved accuracy
  • recognition_02: Legacy

Person Group vs Large Person Group:

  • Person Group: Up to 1,000,000 persons, free tier supported
  • Large Person Group: Over 1,000,000 persons, requires S0 tier

Face Detection Attributes:

  • Age estimation
  • Gender classification
  • Emotion detection (anger, contempt, disgust, fear, happiness, neutral, sadness, surprise)
  • Head pose (pitch, roll, yaw)
  • Facial hair detection
  • Glasses detection
  • Hair color and style
  • Makeup detection
  • Occlusion detection
  • Accessories detection
  • Image quality (blur, exposure, noise)

Best Practices:

  1. Image Quality:

    • Clear, front-facing images
    • Good lighting
    • Minimal occlusion
    • Appropriate resolution (at least 200x200 pixels)

  2. Privacy:

    • Obtain consent for face recognition
    • Implement data retention policies
    • Comply with privacy regulations
    • Provide opt-out mechanisms

  3. Performance:

    • Use appropriate recognition model
    • Batch operations when possible
    • Cache face IDs when appropriate
    • Optimize image size

  4. Accuracy:

    • Train with multiple images per person
    • Use diverse angles and lighting
    • Update person groups regularly
    • Handle false positives/negatives

Documentation Links:

Q3.3: What are the privacy and compliance considerations for Face Service? ​

Answer: Privacy and compliance considerations:

  1. Consent and Authorization:

    • Obtain explicit consent for face recognition
    • Inform users about face data collection
    • Provide clear privacy policy
    • Allow opt-out mechanisms

  2. Data Retention:

    • Configure retention policies
    • Automatically delete face data after expiration
    • Respect user deletion requests
    • Implement data lifecycle management

  3. Regulatory Compliance:

    • GDPR: Right to access, deletion, portability
    • CCPA: California privacy compliance
    • Biometric Privacy Laws: State-specific regulations
    • Industry Regulations: Healthcare, finance, etc.

  4. Data Security:

    • Encrypt face data in transit and at rest
    • Secure API keys and credentials
    • Implement access controls
    • Audit data access

  5. Bias and Fairness:

    • Test across diverse demographics
    • Monitor for biased outcomes
    • Implement fairness measures
    • Regular bias audits

  6. Transparency:

    • Disclose face recognition usage
    • Explain how data is used
    • Provide usage reports
    • Enable user access to their data

Detailed Explanation: Face recognition raises significant privacy and ethical concerns. Compliance with regulations and responsible AI practices is essential for ethical deployment.

Data Retention Configuration:

python
# Configure retention
face_client.person_group.create(
    person_group_id,
    name="My Person Group",
    user_data="Additional metadata",
    recognition_model="recognition_04"
)

# Set face data expiration
face_client.face.detect_with_url(
    url=image_url,
    return_face_id=True,
    detection_model="detection_03"
    # Face data expires after default retention period
)

GDPR Compliance:

  • Right to Access: Provide face data to users
  • Right to Deletion: Delete face data on request
  • Right to Portability: Export face data
  • Right to Objection: Allow opting out

Best Practices:

  1. Consent Management:

    • Clear consent forms
    • Granular consent options
    • Easy withdrawal process
    • Regular consent reviews

  2. Data Minimization:

    • Collect only necessary data
    • Delete when no longer needed
    • Use shortest retention periods
    • Avoid unnecessary attribute collection

  3. Security Measures:

    • Secure authentication
    • Encrypt stored data
    • Limit access to authorized personnel
    • Regular security audits

  4. Monitoring:

    • Track data access
    • Monitor for unauthorized use
    • Log all operations
    • Regular compliance audits

Documentation Links:

Section 4: Spatial Analysis ​

Q4.1: What is Spatial Analysis in Azure AI Vision, and what use cases does it support? ​

Answer: Spatial Analysis is a capability of Azure AI Vision that analyzes video streams to understand people movement and interactions in physical spaces. Use cases include:

  1. People Counting:

    • Count people entering/exiting zones
    • Real-time occupancy monitoring
    • Queue length measurement

  2. Crowd Analysis:

    • Crowd density monitoring
    • Social distancing compliance
    • Capacity management

  3. Zone Analytics:

    • Track people in defined zones
    • Dwell time analysis
    • Zone entry/exit events

  4. Movement Tracking:

    • Path analysis
    • Flow direction tracking
    • Speed and trajectory analysis

  5. Occupancy Management:

    • Room/building occupancy
    • Real-time capacity tracking
    • Overcrowding alerts

Detailed Explanation: Spatial Analysis uses computer vision to understand spatial relationships and movement patterns in video streams, enabling smart building and space management applications.

Key Features:

  • Real-time video analysis
  • Zone-based monitoring
  • Event detection (entry, exit, dwell)
  • Scalable processing
  • Privacy-preserving (no identity tracking)

Technology Stack:

  • Azure AI Vision
  • Azure Video Analyzer (or similar)
  • IoT Edge devices
  • Real-time processing

Privacy Considerations:

  • No identity recognition
  • Only aggregate statistics
  • Configurable data retention
  • Anonymized data

Documentation Links:

Summary ​

This document covers key aspects of implementing computer vision solutions, including Azure AI Vision Service, Custom Vision, Face Service, and spatial analysis. Each topic is essential for success in the AI-102 exam and real-world computer vision implementations.

Additional Study Resources ​

Released under the MIT License.

Copyright © 2025 Azure Certifications Study Guide