AI-900: Describe AI Workloads and Considerations

Target Certification: AI-900 Microsoft Azure AI Fundamentals Exam Module: 15–20% of the exam (first module in the series) Level: Beginner Last Updated: See the Change Log on Microsoft Learn

Table of Contents

1. Overview of Artificial Intelligence
2. AI Workloads and Their Use Cases
3. Responsible AI — Microsoft’s 6 Principles
4. Corresponding Azure Services by Workload
5. Practical Implementation – Code Examples
6. Architecture and AI Deployment Patterns
7. AI-900 Exam Preparation
8. Exam Tips and Classic Pitfalls
9. Practice Questions
10. Summary and Key Points
11. Glossary

1. Overview of Artificial Intelligence

1.1 What is AI, Really?

Artificial intelligence (AI) is not a magic brain or a sci-fi robot — it is software capable of performing tasks that normally require human intelligence:

• Recognizing what is in an image
• Understanding human speech
• Detecting patterns in data
• Generating new content (text, code, images, audio)

Teaching analogy: When you hear “artificial intelligence,” think “very sophisticated software trained on data” — not HAL 9000. AI is pragmatic: algorithms, data, and computing power.

1.2 AI as a Set of Workloads

A fundamental point for the AI-900: AI is not a single thing, it is a set of workloads. Microsoft uses the term “workload” to refer to each specialized category of problems that AI can solve.

mindmap
  root((Artificial Intelligence))
    Machine Learning
      Predictions
      Classification
      Clustering
      Regression
    Anomaly Detection
      Fraud Detection
      Industrial Monitoring
      Cybersecurity
    Computer Vision
      Image Classification
      Object Detection
      OCR
      Facial Recognition
      Video Analysis
    NLP
      Speech-to-Text
      Text-to-Speech
      Translation
      Sentiment Analysis
      NER
      Intent Recognition
    Document Processing
      Field Extraction
      Knowledge Mining
      Large-Scale Indexing
    Generative AI
      Text Generation
      Code Generation
      Image Generation
      Summaries

1.3 The Fundamental Reflex for AI-900

Mental approach: When you see a scenario on the exam, the first question to ask is: “What workload is this?”

Is it prediction? Anomaly detection? Document processing? Vision? NLP? Generative AI?

This mental habit will transform your exam performance, because the majority of questions are simply a scenario wrapping one of these categories.

1.4 Decision Tree — Identifying the Right Workload

flowchart TD
    A["What is the problem?"] --> B{"Images or videos?"}
    B -->|Yes| C["🖼️ Computer Vision\n(Azure AI Vision, Custom Vision, Face)"]
    B -->|No| D{"PDFs, forms,\ninvoices, scans?"}
    D -->|Yes| E["📄 Document Processing\n(Azure AI Document Intelligence)\nor Knowledge Mining\n(Azure AI Search)"]
    D -->|No| F{"Text or speech?"}
    F -->|Yes| G["💬 NLP\n(Azure AI Language, Speech, Translator)"]
    F -->|No| H{"Numerical\nor tabular data?"}
    H -->|"Predict a\nnumber or category"| I["📊 Machine Learning\n(Azure ML, Azure AI Services)"]
    H -->|"Detect\nthe unusual"| J["🔍 Anomaly Detection\n(Azure AI Anomaly Detector)"]
    H -->|No| K{"Create new content\nfrom a prompt?"}
    K -->|Yes| L["✨ Generative AI\n(Azure OpenAI Service)"]
    K -->|No| M["Reconsider the scenario"]

1.5 AI in 2024 – An Evolutionary View

AI systems have evolved considerably in recent years:

2. AI Workloads and Their Use Cases

2.1 Machine Learning

Definition: Enabling a machine to learn to make predictions or group items by training a model with historical data. It is the foundation of most AI systems.

Core principle: Instead of manually coding rules for every possible situation, you train a model with data, and it makes predictions based on the patterns learned.

flowchart LR
    HIST["📊 Historical Data\n(past examples)"] --> TRAIN["🔧 Model\nTraining"]
    TRAIN --> MODEL["🧠 Trained Model\n(learned patterns)"]
    MODEL --> NEW["🆕 New Input\nData"]
    NEW --> PRED["💡 Prediction\n/ Result"]
    
    subgraph "Evaluation"
        TEST["Test Data"] --> EVAL["Metrics:\nAccuracy, RMSE, AUC..."]
    end
    
    MODEL --> TEST

Concrete example: An instructor records the temperature, humidity, time, and weather for each walk with their family. By training an ML model with this data, they can predict the time of the next walk based on today’s weather conditions — without ever coding a single “if-then” rule.

Machine Learning Subtypes

Real Business Examples

• Shipping company: Predict passenger numbers based on weather and season → resource optimization
• Bank: Classify loan applications (low/high risk) → automated decisions
• Retail: Forecast demand by product → order optimization
• HR: Predict employee turnover → proactive interventions

Classic exam pitfall: “Classification” in ML (classifying tabular data) is different from image classification in Computer Vision. If the scenario talks about images → CV. If the scenario talks about data/attributes → ML.

Exam keywords: “predict a number”, “classify data”, “group data”, “demand forecasting”, “low/high risk”, “segmentation”, “regression”

2.2 Anomaly Detection

Definition: Detecting what seems unusual compared to the norm. This is not predicting a value — it is detecting a deviation from expected behavior.

xychart-beta
    title "Anomaly Detection in a Time Series"
    x-axis ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug"]
    y-axis "Value" 0 --> 100
    line [42, 45, 44, 43, 46, 88, 44, 45]

How it works: The system learns what is “normal” (baseline), then continuously monitors data to flag anything that deviates significantly from it.

Concrete Examples

Difference from Machine Learning

Exam keywords: “doesn’t match the usual pattern”, “seems unusual”, “detect fraud”, “real-time monitoring”, “alert”, “deviation from the norm”, “abnormal behavior”

2.3 Computer Vision

Definition: Helping software to interpret what is in images and videos. Every time your phone unlocks with your face or a car is detected on a traffic camera, that is Computer Vision.

mindmap
  root((Computer Vision))
    Image Classification
      What is this image?
      One label per image
      Ex dog cat forklift
    Object Detection
      Where are the objects?
      Multiple objects and bounding boxes
      Ex 2 cars located
    Face Detection
      There is a face here
      No identity
      Ex counting people
    Face Recognition
      This is YOUR face
      Associated identity
      Ex phone unlock
    OCR
      Extract text from an image
      Receipts labels signs
      Photos of whiteboards
    Landmark Recognition
      Identify famous places
      Empire State Eiffel Tower
    Spatial Analysis
      Analyze movement in space
      Ex in-store counting
    Video Analysis
      Person tracking
      Scene detection
      Video transcription

Computer Vision Capabilities Table

Important distinction: Face Detection = “yes, there is a face” — no identity assigned. Face Recognition = “this is person X” — linked identity. For the exam, these two terms are distinct.

Classic pitfall: The exam may ask whether image classification is Computer Vision or Machine Learning. The answer is always Computer Vision — even if ML is used under the hood, the primary workload is CV.

Exam keywords: “detect objects”, “identify a landmark”, “read text from an image”, “analyze video images”, “count people”, “facial unlock”, “bounding box”

2.4 Natural Language Processing (NLP)

Definition: AI that processes written and spoken language — where computers attempt to understand humans. If you have used automatic subtitles, real-time translation, a voice assistant, or an app that detects whether a review is positive or negative, you have used NLP.

flowchart TD
    NLP["💬 Natural Language Processing"] --> SPEECH["🎙️ Speech"]
    NLP --> TEXT["📝 Text"]
    NLP --> INTENT["🎯 Intent"]
    
    SPEECH --> STT["Speech-to-Text\nAudio → Words"]
    SPEECH --> TTS["Text-to-Speech\nWords → Audio"]
    SPEECH --> STRANS["Speech Translation\nAudio → Translated Audio"]
    
    TEXT --> TRANS["Translation\nEnglish → Spanish"]
    TEXT --> SENT["Sentiment Analysis\nPositive / Negative / Neutral"]
    TEXT --> KPE["Key Phrase Extraction\nMain ideas"]
    TEXT --> NER["Named Entity Recognition\nPeople, Places, Orgs"]
    TEXT --> PII["PII Detection\nPersonal data"]
    TEXT --> LANG["Language Detection\nWhich language?"]
    
    INTENT --> CLU["Conversational Language\nUnderstanding (CLU)"]
    INTENT --> QA["Question Answering\nAutomatic FAQ"]

Detailed NLP Capabilities

Exam keywords: “analyze reviews”, “translate”, “positive/negative sentiment”, “named entities”, “speech-to-text”, “text-to-speech”, “voice assistant”, “understand a command”, “subtitles”

2.5 Document Processing and Knowledge Mining

Definition: Going beyond simple OCR to extract, understand, and organize information contained in documents. Most organizations have thousands of PDFs, forms, and invoices containing valuable but inaccessible data.

flowchart LR
    DOCS["📂 Document Stack\n(PDFs, scans, forms,\ninvoices, emails)"] --> PROC["Azure AI\nDocument Intelligence"]
    PROC --> EXTRACT["Structured Extraction\n(specific fields)"]
    PROC --> UNDERSTAND["Structure\nUnderstanding"]
    
    EXTRACT --> INVOICE["Invoice: number,\ntotal, date, vendor"]
    EXTRACT --> RECEIPT["Receipt: merchant,\ntotal, items"]
    EXTRACT --> ID["ID: name, first name,\ndob, doc number"]
    
    DOCS --> SEARCH["Azure AI Search\n(Knowledge Mining)"]
    SEARCH --> INDEX["Search Index\n(extracted text, entities,\nkey phrases)"]
    INDEX --> QUERY["Semantic Search\nat Scale"]

Document Processing vs Knowledge Mining:

Prebuilt model types (Document Intelligence):

Exam keywords: “extract text from a scan”, “process forms”, “extract fields”, “index documents”, “search in PDFs”, “build a knowledge base”

2.6 Generative AI

Definition: AI that creates new content — text, code, images, music — from prompts. It is built on Large Language Models (LLMs) that have learned patterns from billions of data points.

flowchart LR
    USER["👤 User\n(prompt)"] --> LLM["🧠 Large Language Model\n(Azure OpenAI Service)"]
    
    LLM --> TEXT["📝 Generated Text\n(article, summary, email...)"]
    LLM --> CODE["💻 Generated Code\n(Python, SQL, JSON...)"]
    LLM --> IMAGE["🖼️ Generated Images\n(DALL-E)"]
    LLM --> ANSWER["💬 Answers\n(chatbot, Q&A)"]
    
    USER2["👤 User\n(image prompt)"] --> DALLE["🎨 DALL-E\n(image generation)"]
    DALLE --> IMGOUT["🖼️ Image created\nfrom a text description"]

Generative AI Capabilities:

How LLMs work:

An LLM is trained on billions of documents. It learns the patterns of human language: grammar, style, facts, logic. When you give it a prompt, it predicts the most probable next token (word/sub-word), repeating this process until the response is complete.

Important: LLMs don’t “understand” like a human — they statistically generate the most probable text. They can therefore be wrong (hallucination). This is why human verification remains essential.

Exam keywords: “create something new from a prompt”, “draft content”, “image generation”, “intelligent chatbot”, “LLM”, “Azure OpenAI”

2.7 Final Comparative Table of Workloads

flowchart TD
    subgraph PREDICT["🔵 Analyze Data"]
        ML["📊 Machine Learning\nPredict / Classify / Group\n• Regression\n• Classification\n• Clustering"]
        AD["🔍 Anomaly Detection\nDetect the Unusual\n• Bank fraud\n• Industrial monitoring"]
    end
    
    subgraph PERCEIVE["🟢 Perceive the Real World"]
        CV["🖼️ Computer Vision\nImages & Videos\n• Classification\n• Detection\n• OCR\n• Faces"]
        NLP["💬 NLP\nText & Speech\n• Sentiment\n• Translation\n• STT/TTS\n• Intent"]
    end
    
    subgraph EXTRACT["🟡 Extract & Organize"]
        DP["📄 Document Processing\nStructured Extraction\n• Invoices\n• Forms\n• Receipts"]
        KM["🗂️ Knowledge Mining\nLarge-Scale Search\n• PDF Indexing\n• Semantic Search"]
    end
    
    subgraph CREATE["🔴 Create Content"]
        GA["✨ Generative AI\nText, Code, Images\n• LLMs\n• DALL-E\n• Chatbots"]
    end

3. Responsible AI — Microsoft’s 6 Principles

3.1 Overview

Before deploying any AI system, Microsoft recommends verifying it adheres to its 6 Responsible AI principles. These principles are tested on the AI-900 exam — you must know them and be able to identify which principle applies in a given scenario.

flowchart TD
    subgraph "6 Responsible AI Principles"
        FAIR["🤝 Fairness\nTreat all users\njustly"]
        REL["🛡️ Reliability & Safety\nOperate in a\nconsistent and safe way"]
        PRIV["🔒 Privacy & Security\nProtect\npersonal data"]
        INC["♿ Inclusiveness\nAccessible and useful\nfor everyone"]
        TRANS["🔍 Transparency\nExplainable and\nunderstandable"]
        ACC["✅ Accountability\nClear accountability\nand governance"]
    end

3.2 Detail of Each Principle

🤝 Fairness

Definition: An AI system must treat all people equitably, without disadvantaging groups based on protected characteristics (gender, ethnicity, age, disability, etc.).

Typical problem: Training data may contain historical biases. If you train a loan approval model on biased historical data (e.g., fewer approvals for a certain ethnicity), the model will reproduce that bias.

Exam examples:

Scenario: A recruitment model systematically rejects resumes with
foreign-sounding names, even if qualifications are identical.
→ Principle violated: FAIRNESS
→ Solution: Audit training data, test fairness by group,
  use fairness metrics (disparate impact, equal opportunity)

Keywords: “biased results”, “treat certain groups differently”, “discrimination”, “protected characteristics”, “algorithmic fairness”

🛡️ Reliability & Safety

Definition: The system must operate consistently, handle edge cases, resist manipulation, and not cause harm — especially in critical domains.

Typical problem: An AI system for autonomous vehicles that works well in sunny weather but fails in the rain. Or a medical AI assistant that gives dangerous recommendations for atypical cases.

Exam examples:

Scenario: An AI medical diagnosis system works well with 95%
of patients but gives incorrect recommendations for rare cases.
→ Principle violated: RELIABILITY & SAFETY
→ Solution: Testing on diverse distributions, clinical validation,
  continuous monitoring, human fallback procedures

Scenario: A chatbot can be manipulated via adversarial prompts
to provide harmful information.
→ Principle violated: RELIABILITY & SAFETY
→ Solution: Content filters, red teaming, content safety

Keywords: “edge cases”, “system failures”, “unexpected conditions”, “consistent behavior”, “resist manipulation”, “exhaustive testing”, “continuous monitoring”

🔒 Privacy & Security

Definition: AI systems must respect user privacy, protect sensitive data, and prevent unauthorized access.

Typical problem: An NLP model trained on corporate emails may memorize and reveal confidential information via its responses. Or an AI API exposed without authentication.

Exam examples:

Scenario: A text analysis model exposes confidential medical
information in its API responses.
→ Principle violated: PRIVACY & SECURITY
→ Solution: Training data anonymization, access control,
  encryption, GDPR/HIPAA compliance

Scenario: Customer data is used to train a model
without their explicit consent.
→ Principle violated: PRIVACY & SECURITY
→ Solution: Obtain consent, clear privacy policy,
  right to erasure

Keywords: “sensitive data”, “unauthorized access”, “data leak”, “consent”, “GDPR”, “personal data”, “encryption”

♿ Inclusiveness

Definition: AI systems must be accessible and useful for all users, including those with physical, cognitive, or linguistic disabilities.

Typical problem: A speech recognition system that works well with neutral accents but fails for regional accents or people with speech impairments. Or an AI interface without screen reader support.

Exam examples:

Scenario: An AI recruitment system is only accessible via a
visual interface, excluding blind applicants.
→ Principle violated: INCLUSIVENESS
→ Solution: Accessible interface (screen reader, keyboard),
  multimodal, WCAG accessibility testing

Scenario: A voice assistant only works in American English,
excluding non-English speakers or people with a strong accent.
→ Principle violated: INCLUSIVENESS
→ Solution: Multilingual support, training on diverse accents,
  alternative interface (text)

Keywords: “accessibility”, “people with disabilities”, “support for all”, “exclusion”, “accessible interface”, “multilingual”

🔍 Transparency

Definition: Users and stakeholders must understand how the system works, what its limitations are, and how it makes decisions.

Typical problem: A “black box” model that rejects a loan without being able to explain why. Or a recommendation system that doesn’t indicate it uses AI.

Exam examples:

Scenario: An AI system refuses loan applications without providing
an explanation of the decision criteria.
→ Principle violated: TRANSPARENCY
→ Solution: Explainable models (XAI), SHAP values, clear
  notifications about AI use, right to explanation

Scenario: A chatbot pretends to be human without disclosing
that it is powered by AI.
→ Principle violated: TRANSPARENCY
→ Solution: Clear disclosure of AI status, documentation of capabilities,
  communication of limitations

Keywords: “explain results”, “disclose limitations”, “users must understand”, “black box”, “interpretability”, “right to explanation”

✅ Accountability

Definition: Developers, organizations, and AI systems must be accountable for their actions and decisions. There must be clear accountability when something goes wrong.

Typical problem: An incident caused by an AI system where nobody takes responsibility. Or a deployment without governance processes or review.

Exam examples:

Scenario: An AI resume screening system causes legal discrimination,
but the company claims it is not responsible because "the AI decides."
→ Principle violated: ACCOUNTABILITY
→ Solution: Designate owners, human review processes,
  regular audits, right of recourse

Scenario: An AI model is deployed to production without a
review process or documentation.
→ Principle violated: ACCOUNTABILITY
→ Solution: Model cards, governance framework, mandatory ethics review,
  continuous monitoring

Keywords: “who is responsible”, “governance”, “audit”, “review process”, “accountability”, “recourse”

3.3 Responsible AI Summary Table

3.4 Practical Application of the Principles

# Example: Responsible AI Checklist for an ML project
from dataclasses import dataclass
from typing import Optional

@dataclass
class ResponsibleAIChecklist:
    """
    Checklist to validate before deploying an AI system.
    Based on Microsoft's 6 Responsible AI principles.
    """
    
    # 🤝 Fairness
    training_data_bias_audited: bool = False
    equitable_performance_by_group: bool = False
    fairness_metrics_defined: bool = False
    
    # 🛡️ Reliability & Safety
    edge_case_testing_done: bool = False
    diverse_data_validation: bool = False
    human_fallback_procedure: bool = False
    continuous_monitoring_enabled: bool = False
    
    # 🔒 Privacy & Security
    data_anonymized: bool = False
    api_authentication: bool = False
    user_consent_obtained: bool = False
    gdpr_compliant: bool = False
    
    # ♿ Inclusiveness
    wcag_accessible_interface: bool = False
    multilingual_support: bool = False
    accessibility_tests_done: bool = False
    
    # 🔍 Transparency
    limitations_documented: bool = False
    explainable_model: bool = False
    ai_usage_disclosed: bool = False
    
    # ✅ Accountability
    ai_owner_designated: bool = False
    audit_process_defined: bool = False
    model_card_created: bool = False
    recourse_mechanism: bool = False
    
    def deployment_readiness_score(self) -> dict:
        """Calculates the deployment readiness score."""
        items = [
            self.training_data_bias_audited, self.equitable_performance_by_group,
            self.fairness_metrics_defined, self.edge_case_testing_done,
            self.diverse_data_validation, self.human_fallback_procedure,
            self.continuous_monitoring_enabled, self.data_anonymized,
            self.api_authentication, self.user_consent_obtained,
            self.gdpr_compliant, self.wcag_accessible_interface,
            self.multilingual_support, self.accessibility_tests_done,
            self.limitations_documented, self.explainable_model,
            self.ai_usage_disclosed, self.ai_owner_designated,
            self.audit_process_defined, self.model_card_created,
            self.recourse_mechanism
        ]
        
        score = sum(1 for item in items if item)
        total = len(items)
        percentage = score / total * 100
        
        if percentage >= 90:
            status = "✅ READY for deployment"
        elif percentage >= 70:
            status = "⚠️ ALMOST READY - a few items to fix"
        else:
            status = "❌ NOT READY - actions required before deployment"
        
        return {
            "score": f"{score}/{total}",
            "percentage": f"{percentage:.0f}%",
            "status": status
        }

# Example usage
checklist = ResponsibleAIChecklist(
    training_data_bias_audited=True,
    equitable_performance_by_group=True,
    edge_case_testing_done=True,
    data_anonymized=True,
    api_authentication=True,
    user_consent_obtained=True,
    gdpr_compliant=True,
    limitations_documented=True,
    ai_usage_disclosed=True,
    ai_owner_designated=True,
    audit_process_defined=True
)

result = checklist.deployment_readiness_score()
print(f"Score: {result['score']} ({result['percentage']})")
print(f"Status: {result['status']}")

4. Corresponding Azure Services by Workload

4.1 Workload → Azure Service Mapping

flowchart TD
    subgraph "Machine Learning"
        AML["Azure Machine Learning\n(AML Studio, AutoML,\nDesigner, SDK v2)"]
        AZAI["Azure AI Services\n(pre-trained models)"]
    end
    
    subgraph "Anomaly Detection"
        AAD["Azure AI Anomaly Detector\n(REST API + SDK)"]
    end
    
    subgraph "Computer Vision"
        AIV["Azure AI Vision\n(Image Analysis, OCR, Smart Crop)"]
        AICV["Azure AI Custom Vision\n(Custom Models)"]
        AIF["Azure AI Face\n(Facial Analysis)"]
    end
    
    subgraph "NLP"
        AIL["Azure AI Language\n(Text Analytics, CLU, QA)"]
        AIS["Azure AI Speech\n(STT, TTS, Translation)"]
        AIT["Azure AI Translator\n(Text, Documents)"]
    end
    
    subgraph "Document Processing"
        AIDI["Azure AI Document Intelligence\n(Prebuilt + Custom models)"]
        AISEARCH["Azure AI Search\n(Knowledge Mining)"]
    end
    
    subgraph "Generative AI"
        AOAI["Azure OpenAI Service\n(GPT-4, DALL-E, Embeddings)"]
        AIFOUND["Azure AI Foundry\n(Unified AI Hub)"]
    end

4.2 Complete Reference Table

5. Practical Implementation – Code Examples

5.1 Automatically Detect and Classify Workloads

# Automatically classify user requests by AI workload
# (pedagogical example illustrating workloads)

from enum import Enum
from dataclasses import dataclass
import re

class AIWorkload(Enum):
    """Types of AI workloads on Azure."""
    MACHINE_LEARNING = "Machine Learning"
    ANOMALY_DETECTION = "Anomaly Detection"
    COMPUTER_VISION = "Computer Vision"
    NLP = "Natural Language Processing"
    DOCUMENT_PROCESSING = "Document Processing"
    KNOWLEDGE_MINING = "Knowledge Mining"
    GENERATIVE_AI = "Generative AI"
    UNKNOWN = "Unknown"

@dataclass
class WorkloadAnalysis:
    """Result of a scenario analysis."""
    scenario: str
    workload: AIWorkload
    confidence: str
    recommended_service: str
    detected_keywords: list[str]
    explanation: str

def classify_workload(scenario: str) -> WorkloadAnalysis:
    """
    Classifies a natural language scenario to the appropriate AI workload.
    (Simplified heuristic logic - in prod, use CLU)
    """
    scenario_lower = scenario.lower()
    
    # Patterns for each workload
    patterns = {
        AIWorkload.GENERATIVE_AI: {
            "keywords": ["generate", "create content", "draft", "llm", "gpt",
                         "prompt", "dall-e", "chatgpt", "summarize", "paraphrase",
                         "writing assist", "image generation", "openai"],
            "service": "Azure OpenAI Service (GPT-4 / DALL-E)"
        },
        AIWorkload.COMPUTER_VISION: {
            "keywords": ["image", "photo", "video", "camera", "detect in image",
                         "recognize", "bounding box", "ocr image", "face",
                         "read text image", "landmark", "object in image",
                         "classify image", "video analysis"],
            "service": "Azure AI Vision / Custom Vision / Azure AI Face"
        },
        AIWorkload.DOCUMENT_PROCESSING: {
            "keywords": ["invoice", "receipt", "form", "scan", "pdf extract",
                         "extract fields", "document", "contract",
                         "digital form"],
            "service": "Azure AI Document Intelligence"
        },
        AIWorkload.KNOWLEDGE_MINING: {
            "keywords": ["search within", "index", "knowledge base",
                         "search in pdf", "search portal",
                         "thousands of documents", "search index"],
            "service": "Azure AI Search"
        },
        AIWorkload.NLP: {
            "keywords": ["text", "speech", "voice", "sentiment",
                         "translation", "language", "translate", "analyze review",
                         "named entities", "subtitles", "transcription",
                         "chatbot", "voice assistant", "understand command"],
            "service": "Azure AI Language / Speech / Translator"
        },
        AIWorkload.ANOMALY_DETECTION: {
            "keywords": ["unusual", "anomaly", "fraud", "out of norm",
                         "deviation", "monitoring", "alert", "abnormal",
                         "detect fraud", "unusual pattern"],
            "service": "Azure AI Anomaly Detector"
        },
        AIWorkload.MACHINE_LEARNING: {
            "keywords": ["predict", "forecast", "classify data", "regression",
                         "clustering", "segmentation", "risk", "scoring",
                         "predictive model", "probability"],
            "service": "Azure Machine Learning"
        }
    }
    
    # Score each workload
    scores = {}
    detected = {}
    
    for workload, config in patterns.items():
        found_keywords = [k for k in config["keywords"] if k in scenario_lower]
        scores[workload] = len(found_keywords)
        detected[workload] = found_keywords
    
    # Find the workload with the highest score
    if max(scores.values()) == 0:
        return WorkloadAnalysis(
            scenario=scenario,
            workload=AIWorkload.UNKNOWN,
            confidence="Low",
            recommended_service="Not determined",
            detected_keywords=[],
            explanation="No workload clearly identified in this scenario."
        )
    
    best_workload = max(scores, key=scores.get)
    max_score = scores[best_workload]
    
    confidence = "High" if max_score >= 3 else "Medium" if max_score >= 2 else "Low"
    
    explanations = {
        AIWorkload.GENERATIVE_AI: "This scenario involves creating new content → Generative AI",
        AIWorkload.COMPUTER_VISION: "This scenario involves analyzing images or videos → Computer Vision",
        AIWorkload.DOCUMENT_PROCESSING: "This scenario involves extracting data from documents → Document Processing",
        AIWorkload.KNOWLEDGE_MINING: "This scenario involves searching a large document base → Knowledge Mining",
        AIWorkload.NLP: "This scenario involves language processing (text or speech) → NLP",
        AIWorkload.ANOMALY_DETECTION: "This scenario involves detecting unusual behaviors → Anomaly Detection",
        AIWorkload.MACHINE_LEARNING: "This scenario involves predictions on structured data → Machine Learning",
        AIWorkload.UNKNOWN: "Scenario cannot be classified"
    }
    
    return WorkloadAnalysis(
        scenario=scenario,
        workload=best_workload,
        confidence=confidence,
        recommended_service=patterns[best_workload]["service"],
        detected_keywords=detected[best_workload],
        explanation=explanations[best_workload]
    )

# Tests with typical exam scenarios
scenarios = [
    "Analyze customer reviews to determine whether the sentiment is positive or negative",
    "Automatically extract the total amount and invoice number from scanned invoices",
    "Detect whether a bank transaction seems fraudulent compared to the customer's habits",
    "Automatically create product descriptions for an e-commerce catalog",
    "Identify and locate cars and pedestrians in images from surveillance cameras",
    "Predict the number of customers who will cancel their subscription this month",
    "Make the company's 5,000 contract PDFs searchable and queryable"
]

print("=== AI Scenario Classification ===\n")
for scenario in scenarios:
    analysis = classify_workload(scenario)
    print(f"📋 Scenario: {scenario[:70]}...")
    print(f"   🎯 Workload: {analysis.workload.value}")
    print(f"   📊 Confidence: {analysis.confidence}")
    print(f"   🔧 Service: {analysis.recommended_service}")
    print(f"   💡 {analysis.explanation}")
    print()

5.2 Responsible AI Compliance Checker

# Responsible AI compliance evaluation tool
from dataclasses import dataclass, field
from typing import Optional
import json

@dataclass
class ResponsibleAIEvaluation:
    """Complete AI system evaluation according to the 6 principles."""
    
    system_name: str
    description: str
    
    # Score per principle (0 = non-compliant, 1 = partial, 2 = compliant)
    fairness_score: int = 0
    fairness_notes: str = ""
    
    reliability_score: int = 0
    reliability_notes: str = ""
    
    privacy_score: int = 0
    privacy_notes: str = ""
    
    inclusiveness_score: int = 0
    inclusiveness_notes: str = ""
    
    transparency_score: int = 0
    transparency_notes: str = ""
    
    accountability_score: int = 0
    accountability_notes: str = ""
    
    identified_risks: list[str] = field(default_factory=list)
    
    def report(self) -> str:
        """Generates a Responsible AI compliance report."""
        total_score = (
            self.fairness_score + self.reliability_score +
            self.privacy_score + self.inclusiveness_score +
            self.transparency_score + self.accountability_score
        )
        max_score = 12  # 6 principles × 2 max points
        percentage = (total_score / max_score) * 100
        
        statuses = {0: "❌ Non-compliant", 1: "⚠️ Partial", 2: "✅ Compliant"}
        
        report = f"""
╔══════════════════════════════════════════════════════════════╗
║        RESPONSIBLE AI REPORT - {self.system_name[:20].upper():<20}     ║
╚══════════════════════════════════════════════════════════════╝

System: {self.system_name}
Description: {self.description}
Overall score: {total_score}/{max_score} ({percentage:.0f}%)

═══════ EVALUATION BY PRINCIPLE ═══════

🤝 FAIRNESS
   Status: {statuses[self.fairness_score]}
   Notes: {self.fairness_notes or 'Not evaluated'}

🛡️ RELIABILITY & SAFETY
   Status: {statuses[self.reliability_score]}
   Notes: {self.reliability_notes or 'Not evaluated'}

🔒 PRIVACY & SECURITY
   Status: {statuses[self.privacy_score]}
   Notes: {self.privacy_notes or 'Not evaluated'}

♿ INCLUSIVENESS
   Status: {statuses[self.inclusiveness_score]}
   Notes: {self.inclusiveness_notes or 'Not evaluated'}

🔍 TRANSPARENCY
   Status: {statuses[self.transparency_score]}
   Notes: {self.transparency_notes or 'Not evaluated'}

✅ ACCOUNTABILITY
   Status: {statuses[self.accountability_score]}
   Notes: {self.accountability_notes or 'Not evaluated'}
"""
        
        if self.identified_risks:
            report += "\n⚠️  IDENTIFIED RISKS:\n"
            for risk in self.identified_risks:
                report += f"   • {risk}\n"
        
        if percentage >= 80:
            report += "\n✅ VERDICT: System ready for final evaluation"
        elif percentage >= 60:
            report += "\n⚠️  VERDICT: Improvements required before deployment"
        else:
            report += "\n❌ VERDICT: Deployment refused - non-compliant"
        
        return report

# Example evaluation
eval_system = ResponsibleAIEvaluation(
    system_name="Automated Resume Screening System",
    description="ML model that classifies resumes into 3 categories: Interview, Contact, Archive",
    
    fairness_score=1,
    fairness_notes="Potential gender bias detected in training data - correction in progress",
    
    reliability_score=2,
    reliability_notes="Exhaustive testing completed, cross-validation on diverse data",
    
    privacy_score=2,
    privacy_notes="GDPR compliant, anonymized data, consent obtained",
    
    inclusiveness_score=1,
    inclusiveness_notes="Accessible interface but not all resume formats supported",
    
    transparency_score=1,
    transparency_notes="Partially explainable model, SHAP values available but not exposed to HR",
    
    accountability_score=2,
    accountability_notes="AI owner designated, quarterly audit process in place",
    
    identified_risks=[
        "Gender bias in historical recruitment data",
        "Lack of transparency for rejected candidates",
        "Non-standard resume formats potentially misanalyzed"
    ]
)

print(eval_system.report())

6. Architecture and AI Deployment Patterns

6.1 Typical Multi-Tier Architecture

flowchart TB
    subgraph "Presentation Layer"
        WEB["🌐 Web Application"]
        MOBILE["📱 Mobile Application"]
        TEAMS["💼 Microsoft Teams Bot"]
    end
    
    subgraph "API and Orchestration Layer"
        APIM["Azure API Management"]
        FUNC["Azure Functions\n(Orchestration)"]
        LOGIC["Azure Logic Apps\n(Workflows)"]
    end
    
    subgraph "AI Layer"
        AOAI["Azure OpenAI\n(Generative AI)"]
        AIL["Azure AI Language\n(NLP)"]
        AIV["Azure AI Vision\n(Computer Vision)"]
        AIM["Azure Machine Learning\n(ML Models)"]
    end
    
    subgraph "Data Layer"
        BLOB["Azure Blob Storage\n(Images, Documents)"]
        COSMOS["Azure Cosmos DB\n(AI Results)"]
        SEARCH["Azure AI Search\n(Index)"]
    end
    
    WEB --> APIM
    MOBILE --> APIM
    TEAMS --> APIM
    
    APIM --> FUNC
    FUNC --> AOAI
    FUNC --> AIL
    FUNC --> AIV
    FUNC --> AIM
    
    AIV --> BLOB
    AIL --> COSMOS
    AOAI --> COSMOS
    BLOB --> SEARCH

6.2 AI Integration Patterns

7. AI-900 Exam Preparation

7.1 Section Weighting

Note: The Generative AI section is currently the most weighted section of the exam (up to 25%). Prioritize this section if you are short on time.

7.2 Exam Format

• Duration: 45 minutes
• Number of questions: ~40-60 questions
• Types: MCQ, multiple response, scenarios, drag-and-drop
• Passing score: 700/1000

8. Exam Tips and Classic Pitfalls

8.1 The 7 Most Common Pitfalls

Pitfall 1: Computer Vision vs Machine Learning

Typical question: "Image classification, is it Computer Vision or Machine Learning?"
Answer: COMPUTER VISION (even if ML is used under the hood)
Logic: The primary workload is vision → CV

Pitfall 2: Text Analytics vs OCR

Typical question: "Analyze the tone of a customer email"
Answer: Text Analytics (Azure AI Language)

Typical question: "Read text on a sign in a photo"
Answer: OCR (Azure AI Vision)

Difference: Text Analytics = analyze EXISTING TEXT
           OCR = EXTRACT text from an image

Pitfall 3: Cognitive Services = Azure AI Services

Old name: Azure Cognitive Services
New name: Azure AI Services

For the exam: If you see "Cognitive Services" in a question,
they are talking about Azure AI Services (multi-service account)

Pitfall 4: Face Detection vs Face Recognition

Face Detection: "There is a face at these coordinates" → NO identity
Face Recognition: "This face belongs to Alice Smith" → IDENTITY

For the exam: Phone unlock = Recognition
              Counting people in a space = Detection

Pitfall 5: Which Responsible AI Principle?

Biased, discriminatory → FAIRNESS
Failure, edge cases → RELIABILITY & SAFETY
Personal data, GDPR → PRIVACY & SECURITY
Accessibility, disabilities → INCLUSIVENESS
Black box, no explanation → TRANSPARENCY
Who is responsible, governance → ACCOUNTABILITY

Pitfall 6: Translator vs Speech Translation

Azure AI Translator: TEXT → TEXT (90+ languages, Word/PDF documents)
Azure AI Speech (Speech Translation): AUDIO → AUDIO or translated TEXT

If the question talks about translating AUDIO → Azure AI Speech
If the question talks about translating TEXT → Azure AI Translator

Pitfall 7: Document Processing vs Knowledge Mining

Document Processing: Extract specific fields from a document
  → "Extract the total from this invoice"
  → Azure AI Document Intelligence

Knowledge Mining: Make a large collection of documents searchable
  → "Search through 10,000 contracts"
  → Azure AI Search

8.2 Quick Keywords

🖼️ Computer Vision → images, video, camera, detect objects, OCR image, face
💬 NLP → text, speech, sentiment, translation, subtitles, intent, voice assistant
📄 Document Processing → scan, invoice, form, extract fields, receipt
🗂️ Knowledge Mining → index, search in PDFs, knowledge base
📊 Machine Learning → predict, classify data, regression, clustering
🔍 Anomaly Detection → unusual, fraud, alert, deviation from norm
✨ Generative AI → create content, prompt, LLM, GPT, draft, generate image

9. Practice Questions

Q1: A company wants to automatically detect whether its customers’ transactions are fraudulent. Which AI workload?

A: Anomaly Detection – detecting unusual behaviors compared to normal patterns.

Q2: A hiring model systematically rejects resumes from women even though their qualifications are identical. Which Responsible AI principle is violated?

A: Fairness – the model unfairly treats a group based on gender.

Q3: An app must automatically read the tracking numbers on photographed parcel labels. Which Azure service?

A: Azure AI Vision (Read OCR Engine) – text extraction from images.

Q4: A developer wants to create a voice assistant that understands commands like “Book a meeting room for tomorrow at 2pm”. Which service?

A: Azure AI Language (Conversational Language Understanding / CLU) + Azure AI Speech (Speech-to-Text).

Q5: What differentiates an LLM used in Generative AI from a classic ML model?

A: An LLM generates new content (text, code, images) from prompts, while a classic ML model makes predictions on existing structured data.

Q6: An AI recruitment platform does not offer an accessible interface for blind candidates. Which Responsible AI principle is violated?

A: Inclusiveness – the system is not accessible to all users.

Q7: A company uses Azure AI Vision, Azure AI Language, and Azure AI Speech together. To simplify management, they want a single endpoint and a single key. Which service?

A: Azure AI Services (formerly Cognitive Services) – multi-service account.

Q8: Classify: “Predict next month’s revenue” → which workload?

A: Machine Learning (Regression) – predicting a numerical value from historical data.

10. Summary and Key Points

10.1 The 6 AI Workloads

10.2 The 6 Responsible AI Principles

11. Glossary

Additional Resources:

Search Terms

ai-900 · describe · ai · workloads · considerations · azure · services · artificial · intelligence · generative · responsible · exam · machine · principles · workload · architecture · capabilities · computer · nlp · patterns · pitfalls · practical · processing · vision