AI-102 Designing and Implementing a Microsoft Azure AI Solution Questions and Answers

Box 1: Azure Blob storage

At the start of the pipeline, you have unstructured text or non-text content (such as images, scanned documents, or JPEG files). Data must exist in an Azure data storage service that can be accessed by an indexer.

Box 2: Computer Vision API

Scenario: Provide users with the ability to search insight gained from the images, manuals, and videos associated with the products.

The Computer Vision Read API is Azure ' s latest OCR technology (learn what ' s new) that extracts printed text (in several languages), handwritten text (English only), digits, and currency symbols from images and multi-page PDF documents.

Box 3: Translator API

Scenario: Product descriptions, transcripts, and all text must be available in English, Spanish, and Portuguese.

Box 4: Azure Files

Scenario: Store all raw insight data that was generated, so the data can be processed later.

Scenario: When the response confidence score is low, ensure that the chatbot can provide other response options to the customers.

When no good match is found by the ranker, the confidence score of 0.0 or " None " is returned and the default response is " No good match found in the KB " . You can override this default response in the bot or application code calling the endpoint. Alternately, you can also set the override response in Azure and this changes the default for all knowledge bases deployed in a particular QnA Maker service.

Choosing Ranker type: By default, QnA Maker searches through questions and answers. If you want to search through questions only, to generate an answer, use the RankerType=QuestionOnly in the POST body of the GenerateAnswer request.

The requirements state:

All AI solution responses must have a confidence score ≥ 70%.

If the response confidence score is < 70%, the response must be improved by human input.

Members of the Consultant-Bookkeeper group must be able to process financial documents, which includes performing manual review when the AI confidence is below threshold.

Looking at the provided JSON:

" fields " : {

" ReceiptType " : {

" type " : " string " ,

" valueString " : " Itemized " ,

" confidence " : 0.672

},

" MerchantName " : {

" type " : " string " ,

" valueString " : " Tailwind " ,

" confidence " : 0.913

}

}

ReceiptType.confidence = 0.672 → this is below 0.7.

MerchantName.confidence = 0.913 → this is above 0.7.

Therefore, the correct condition for triggering manual review is:

documentResults.fields. < field > .confidence < 0.7

Now, evaluating the options:

A. documentResults.docType == " prebuilt:receipt "

Always true for receipts, does not check confidence. Not correct.

B. documentResults.fields.*.confidence < 0.7

This is the correct general expression: trigger manual review whenever any field confidence is below 0.7.

C. documentResults.fields.ReceiptType.confidence > 0.7

This would bypass manual review when ReceiptType has high confidence. The requirement is to trigger review when confidence < 0.7, so this is the opposite.

D. documentResults.fields.MerchantName.confidence < 0.7

This only checks one field (MerchantName). In the JSON, MerchantName has confidence 0.913 ( > 0.7), so this condition would not trigger, but ReceiptType clearly needs review. Too narrow.

Correct Answer: B. documentResults.fields.*.confidence < 0.7

Microsoft References

Azure AI Document Intelligence – Confidence scores

Human-in-the-loop for Document Intelligence

Box 1: api-nam.cognitive.microsofttranslator.com

https://docs.microsoft.com/en-us/azure/cognitive-services/translator/reference/v3-0-reference

Box 2: /translate

Scenario: All videos must have transcripts that are associated to the video and included in product descriptions.

Product descriptions, transcripts, and all text must be available in English, Spanish, and Portuguese.

Step 1: Upload the video to blob storage

Given a video or audio file, the file is first dropped into a Blob Storage. T

Step 2: Index the video by using the Video Indexer API.

When a video is indexed, Video Indexer produces the JSON content that contains details of the specified video insights. The insights include: transcripts, OCRs, faces, topics, blocks, etc.

Step 3: Extract the transcript from the Video Indexer API.

Step 4: Translate the transcript by using the Translator API.

Scenario: Support autocompletion and autosuggestion based on all product name variants.

A: Call a suggester-enabled query, in the form of a Suggestion request or Autocomplete request, using an API. API usage is illustrated in the following call to the Autocomplete REST API.

POST /indexes/myxboxgames/docs/autocomplete?search & api-version=2020-06-30

{

" search " : " minecraf " ,

" suggesterName " : " sg "

}

B: In Azure Cognitive Search, typeahead or " search-as-you-type " is enabled through a suggester. A suggester provides a list of fields that undergo additional tokenization, generating prefix sequences to support matches on partial terms. For example, a suggester that includes a City field with a value for " Seattle " will have prefix combinations of " sea " , " seat " , " seatt " , and " seattl " to support typeahead.

F. Use the default standard Lucene analyzer ( " analyzer " : null) or a language analyzer (for example, " analyzer " : " en.Microsoft " ) on the field.

Comprehensive Detailed Explanation

The requirement is to build an Adaptive Card for the chatbot that supports multilingual product display and meets accessibility requirements.

Product Name Display

The product JSON stores localized names like " name " : { " en " : " ... " , " es " : " ... " , " pt " : " ... " } .

To dynamically render based on the current language, you must use name[language].

This ensures the product name shown in the card adapts automatically to the user’s preferred language.

Stock Level Warning

Business rules require warnings when stock is low or out of stock.

This means you display the stock warning only when stockLevel is not ' OK ' .

Therefore, the correct condition is:

" $when " : " ${stockLevel != ' OK ' } "

Image Alt Text for Accessibility

Accessibility requirements specify that all images must have alt text in English, Spanish, and Portuguese.

In the product JSON, " alttext " is also localized:

" altText " : { " en " : " Bicycle " , " es " : " Bicicleta " , " pt " : " Bicicleta " }

To render the correct localized alt text dynamically, use image.altText[language].

Correct Selections:

First blank: name[language]

Second blank: " $when " : " ${stockLevel != ' OK ' } "

Third blank: image.altText[language]

Microsoft References

Adaptive Cards Templating

Adaptive Card $when property

Multilingual data in Azure Cognitive Search and Adaptive Cards

Within a search service, synonym maps are a global resource that associate equivalent terms, expanding the scope of a query without the user having to actually provide the term. For example, assuming " dog " , " canine " , and " puppy " are mapped synonyms, a query on " canine " will match on a document containing " dog " .

Create synonyms: A synonym map is an asset that can be created once and used by many indexes.

The wiki contains text in English, French and Portuguese.

Scenario: All planned projects must support English, French, and Portuguese.

The Document Extraction skill extracts content from a file within the enrichment pipeline. This allows you to take advantage of the document extraction step that normally happens before the skillset execution with files that may be generated by other skills.

Note: The Translator Text API will be used to determine the from language. The Language detection skill is not required.

C: Analyze Receipt - Get Analyze Receipt Result.

Query the status and retrieve the result of an Analyze Receipt operation.

Request URL: https://{endpoint}/formrecognizer/v2.0-preview/prebuilt/receipt/analyzeResults/{resultId}

E: POST {Endpoint}/vision/v3.2/read/analyze

Use this interface to get the result of a Read operation, employing the state-of-the-art Optical Character Recognition (OCR) algorithms optimized for text-heavy documents.

Scenario: Contoso plans to develop a document processing workflow to extract information automatically from PDFs and images of financial documents

The document processing solution must be able to process standardized financial documents that have the following characteristics:

- Contain fewer than 20 pages.

- Be formatted as PDF or JPEG files.

- Have a distinct standard for each office.

*The document processing solution must be able to extract tables and text from the financial documents.

The document processing solution must be able to extract information from receipt images.

Can search content in different formats, including video

Audio and video insights (multi-channels). When indexing by one channel, partial result for those models will be available.

Keywords extraction: Extracts keywords from speech and visual text.

Named entities extraction: Extracts brands, locations, and people from speech and visual text via natural language processing (NLP).

Topic inference: Makes inference of main topics from transcripts. The 2nd-level IPTC taxonomy is included.

Artifacts: Extracts rich set of " next level of details " artifacts for each of the models.

Sentiment analysis: Identifies positive, negative, and neutral sentiments from speech and visual text.

Box 1: " categories " : [ " Locations " , " Persons " , " Organizations " ],

Locations, Persons, Organizations are in the outputs.

Scenario: Contoso plans to develop a searchable knowledgebase of all the intellectual property

Note: The categories parameter is an array of categories that should be extracted. Possible category types: " Person " , " Location " , " Organization " , " Quantity " , " Datetime " , " URL " , " Email " . If no category is provided, all types are returned.

Box 2: { " name " : " entities " }

The include wikis, so should include entities in the outputs.

Note: entities is an array of complex types that contains rich information about the entities extracted from text, with the following fields

name (the actual entity name. This represents a " normalized " form)

wikipediaId

wikipediaLanguage

wikipediaUrl (a link to Wikipedia page for the entity)

etc.

To let an Azure AI Agent access publicly available, recent web content, you add the Bing grounding tool. In the SDK, you first define a ToolConnectionList with the Bing connection ID (here, " bingConnectionId " ), then construct a BingGroundingToolDefinition(connectionList) so the agent can call Bing Search with recency filters (e.g., last 90 days) when answering questions.

When creating the agent, tool definitions are passed via the tools: parameter of CreateAgentAsync(...) as a List < ToolDefinition > . The toolResources parameter is used when you must also supply resource descriptors (for example, an Azure AI Search index configuration), which is not needed here because the Bing grounding tool already references the connection through the ToolConnectionList .

Therefore:

Use BingGroundingToolDefinition to ground the agent on current public web data.

Provide that tool in tools: new List < ToolDefinition > { grounding } when calling CreateAgentAsync(...) .

Microsoft Azure AI References (titles only)

Azure AI Agent Service – Bing web grounding tool (tool definitions and connections)

Azure AI Agent Service SDK – Agent creation ( CreateAgentAsync parameters: tools vs toolResources )

Azure AI Agent Service – Tool connections and ToolConnectionList usage

An ML entity can be composed of smaller sub-entities, each of which can have its own properties. For example, Address could have the following structure:

Address: 4567 Main Street, NY, 98052, USA

Building Number: 4567

Street Name: Main Street

State: NY

Zip Code: 98052

Country: USA

https://docs.microsoft.com/en-us/azure/cognitive-services/luis/luis-concept-entity-types

Evaluate different models.

The best way to compare the performances of the detection models is to use them on a sample dataset. We recommend calling the Face - Detect API on a variety of images, especially images of many faces or of faces that are difficult to see, using each detection model. Pay attention to the number of faces that each model returns.

The requirement is to identify the created Azure AI services account within a DevOps pipeline.

The az cognitiveservices account show command returns the details (name, id, location, etc.) of an existing Azure AI service account.

az resource link creates or manages links between resources, not what we need.

az account list lists Azure subscriptions, not resources.

az cognitiveservices account network-rule manages network access rules but does not return account identity.

Microsoft References:

az cognitiveservices account show

Step 1: Create a new project and load sample documents

Create a new project. Projects store your configurations and settings.

Step 2: Label the sample documents

When you create or open a project, the main tag editor window opens.

Step 3: Train a custom model.

Finally, train a custom model.

To generate less deterministic and more creative responses with Azure OpenAI chat completions, increase the Temperature setting. Temperature controls sampling randomness: higher values (e.g., ~0.8–1.0) yield more diverse/creative outputs; lower values (~0–0.2) are more deterministic.

The message being sent in the Messages collection is the user’s prompt, so the correct role is ChatRole.User . The role does not control creativity; it only tells the model who authored the message (system/assistant/user/function). Creativity is governed by parameters such as Temperature (and, to a lesser extent, TopP ). PresencePenalty biases against repeating seen tokens/topics but does not primarily increase creativity in the intended way.

So the code should look like:

new ChatCompletionsOptions()

{

Messages =

{

new ChatMessage(ChatRole.User, @ " < user prompt here > " ),

},

Temperature = ( float ) 1.0 ,

MaxTokens = 800 ,

};

Microsoft Azure AI Solution References

Azure OpenAI Service – Chat Completions parameters (Temperature controls randomness/creativity; higher = more diverse results).

Azure OpenAI Service – Message roles in chat ( system , user , assistant , function ) and their purposes.

Azure OpenAI Service – Presence/Frequency penalties vs. Temperature (penalties reduce repetition; temperature changes creativity).

To create a single multi-service Cognitive Services resource (now Azure AI Services) that provides one key/endpoint for multiple services , consolidates billing, and allows adding services like Text Analytics (sentiment analysis) and Computer Vision (OCR) from the same resource, you must:

Use the Azure Resource Manager (ARM) REST API with PUT to create or update the account:

PUT /subscriptions/{subId}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{name}?api-version=2017-04-18

Set " kind " : " CognitiveServices " to create the multi-service account (not a single-service kind like ComputerVision or TextAnalytics).

This satisfies the requirements: single key/endpoint, consolidated billing, and future Computer Vision use.

Microsoft Azure AI Solution References

ARM REST for Cognitive Services accounts (create/update via PUT , multi-service " kind " : " CognitiveServices " ).

https://learn.microsoft.com/azure/ai-services/management/resource-manager-create-account

Azure AI Services multi-service resource (single endpoint/key across services).

https://learn.microsoft.com/azure/ai-services/multi-service-resource

To build narration for video training content using Custom Neural Voice, we must know where each step is done:

Creating a Custom Neural Voice

A Custom Neural Voice is a text-to-speech (TTS) feature within Azure AI Speech.

It allows you to create a unique, natural-sounding synthetic voice.

The correct tool to build and configure a custom voice is the Speech Studio portal.

Not the Language Understanding portal (LUIS), Azure portal directly, or Bot Framework Composer.

Generating narration

Narration requires converting written text into speech.

This is done via the Text-to-Speech service in Azure AI Speech.

Other options:

Language Understanding → For intent/utterance processing, not narration.

Speaker Recognition → For identifying/authenticating speakers, not narration.

Speech-to-text → Converts spoken words to text (the opposite direction).

Thus:

Custom Neural Voice → Speech Studio portal

Narration → Text-to-speech

Correct Answers:

Custom neural voice: The Speech Studio portal

Narration: Text-to-speech

Microsoft References

Custom Neural Voice in Speech Studio

Text-to-Speech overview

In Power BI, reports are interactive, visual, and support KPIs, drill-through, and drill-down functionality.

Power Apps is for app development, not analytics.

A view is a database object, not a visualization solution.

Dataflow is for ETL/ELT (data preparation), not reporting.

Correct Answer: A

On the Azure AI Video Indexer website, uploading directly from your device is limited to 2 GB —your file is 20 GB , so this won’t work. Instead, the recommended approach is to upload the video to an online location and use the “Enter URL” option in the Video Indexer site. The service accepts a direct media-file URL (not a web page like YouTube) and supports uploads up to 30 GB via URL. Given the options provided, OneDrive is the only viable online storage choice listed to host the file before submitting its direct URL to Video Indexer. (Note: the URL must resolve directly to the media file; YouTube links are explicitly not supported, and an Azure Storage queue is not for storing video files.)

Microsoft References

Azure AI Video Indexer support matrix: 2-GB limit from device; 30-GB limit via URL ; URL must be a direct media file, not a webpage (e.g., YouTube). Microsoft Learn

Upload & index media in the Video Indexer website (“Enter URL” flow). Microsoft Learn

Considerations at scale: prefer URL upload over byte array; reiterates 2-GB vs 30-GB limits. Microsoft Learn

=========================

Comprehensive Detailed Explanation

Relational databases (such as Azure SQL Database, SQL Server, or Azure Database for PostgreSQL) are designed for structured data and ACID-compliant transactions.

Let’s analyze the options:

Changes to relationships between entities

While relational databases do handle relationships (via primary/foreign keys), this phrase alone does not describe the core usage scenario for “high volume.”

Geographically distributed writes

This is better suited to NoSQL databases (e.g., Azure Cosmos DB) because they are optimized for global distribution and multi-region writes.

Transactional writes

Correct.

Relational databases excel at handling large volumes of transactional operations (INSERT, UPDATE, DELETE) while ensuring consistency, integrity, and rollback capabilities.

This is the primary workload for OLTP (Online Transaction Processing) systems.

Writes that have varying data structures

This is a use case for NoSQL/document databases like MongoDB or Azure Cosmos DB, not relational systems which require structured schema.

Correct Answer: Transactional writes

Microsoft References

Azure SQL Database – transactional processing

Data store considerations: relational vs non-relational

OLTP vs OLAP

Scenario: All planned projects must support English, French, and Portuguese.

If a bot uses multiple LUIS models and QnA Maker knowledge bases (knowledge bases), you can use the Dispatch tool to determine which LUIS model or QnA Maker knowledge base best matches the user input. The dispatch tool does this by creating a single LUIS app to route user input to the correct model.

To automatically delete blobs in Azure Blob Storage, you can configure a lifecycle management policy . This policy allows you to:

Transition blobs between hot, cool, and archive tiers.

Delete blobs automatically after a specified number of days.

Other options:

Change feed → Tracks all changes to blobs, but does not delete them.

Soft delete → Protects blobs from accidental deletion by allowing recovery, not automated deletion.

Archive storage → Storage tier for rarely accessed data, not a deletion mechanism.

Correct Answer: a lifecycle management policy

You are deploying a Language Understanding (LUIS) container. When running LUIS in Docker, the model must first be exported from the Language Understanding portal, and then provided to the container at runtime.

Step-by-step reasoning:

From the Language Understanding portal, export the solution as a package file.

The trained LUIS model must be exported from the portal into a .json package file.

This is required because the container cannot access the hosted service directly.

From the host computer, move the package file to the Docker input directory.

Containers expect the model to be available locally.

The package file is placed into the input directory that the container maps for models.

From the host computer, run the container and specify the input directory.

When starting the container, you specify --volume < local_input > :/input so the container has access to the package file.

This makes the exported model available inside the container for processing.

Why not the other options?

Retain the model in the portal is not sufficient; the container cannot pull directly from the cloud.

Build the container and specify the output directory is not required; the container image is already available from MCR and is not custom-built for this step.

Correct Answer Order:

Export the solution as a package file.

Move the package file to the Docker input directory.

Run the container and specify the input directory.

Microsoft References

Run LUIS containers

Use containers with Azure AI services

The requirement is:

" Measure the public perception of your brand on social media using natural language processing (NLP). "

A. Content Moderator

Designed to filter offensive or inappropriate content in text, images, and videos.

Not suitable for sentiment analysis or measuring perception.

B. Form Recognizer

Extracts structured data from documents (invoices, receipts, forms).

Not used for analyzing social media posts.

C. Computer Vision

Analyzes images and videos for object detection, image classification, OCR, etc.

Not used for text-based sentiment analysis.

D. Language service ✅

Provides natural language processing (NLP) capabilities such as sentiment analysis, opinion mining, key phrase extraction, entity recognition , and language detection .

Perfect fit for analyzing public perception from social media posts .

Box 1: mcr.microsoft.com/azure-cognitive-services/textanalytics/sentiment

To run the Sentiment Analysis v3 container, execute the following docker run command.

docker run --rm -it -p 5000:5000 --memory 8g --cpus 1 \

mcr.microsoft.com/azure-cognitive-services/textanalytics/sentiment \

Eula=accept \

Billing={ENDPOINT_URI} \

ApiKey={API_KEY} is the endpoint for accessing the Text Analytics API. https:// < your-custom-subdomain > .cognitiveservices.azure.com

Box 2: https://contoso.cognitiveservices.azure.com

{ENDPOINT_URI} is the endpoint for accessing the Text Analytics API: https:// < your-custom-subdomain > .cognitiveservices.a The endpoint for accessing the Text Analytics API. zure.com

The requirement is to extract structured information (invoice items, sales amounts, customer details) from scanned invoice images.

Form Recognizer (now part of Azure AI Document Intelligence) is specifically designed for extracting structured data from documents such as invoices, receipts, and business forms.

Custom Vision → used for image classification or object detection, not for text/data extraction.

Computer Vision → can extract text with OCR, but it doesn’t provide structured field-level extraction for invoices.

Immersive Reader → for accessibility (reading content aloud, translating text), not document data extraction.

Correct Answer: D

The application stores data in a shared folder on a Windows server. The equivalent in Azure Storage is Azure Files , which provides:

Fully managed file shares in the cloud.

Support for the SMB (Server Message Block) protocol, so they can be mounted like traditional shared folders.

Easy migration of on-premises file shares to Azure.

Other storage options:

Table → NoSQL key-value store, not for file shares.

Queue → For message storage and processing, not files.

Blob → For unstructured object storage, but not mountable as a shared drive.

Therefore, Azure File Storage is correct.

Microsoft Reference: Azure Files overview

You are configuring speech-to-speech translation in an app. The workflow is:

Recognize spoken input language (in this case, English).

Translate the recognized text into the target language (in this case, German).

(Optional) Synthesize speech in the target language.

Step 1 – SpeechRecognitionLanguage

This property defines the input language for speech recognition.

Since the input is English, it should be set to " en-US " .

Step 2 – AddTargetLanguage

This method specifies the output translation language(s).

Since the requirement is to translate into German, use " de " .

Other options (incorrect here):

speechSynthesisLanguage → used if you want to output translated text as synthesized speech in the target language voice. Not required in this snippet.

voiceName → specifies the actual voice to use for speech synthesis, not translation.

Correct Completed Code Snippet:

var translationConfig = SpeechTranslationConfig.FromSubscription(SPEECH_SUBSCRIPTION_KEY, SPEECH_SERVICE_REGION);

translationConfig.SpeechRecognitionLanguage = " en-US " ;

translationConfig.AddTargetLanguage( " de " );

Microsoft References

Speech Translation with Azure AI Speech SDK

SpeechTranslationConfig Class Reference

You are building a Text-to-Speech (TTS) solution in Azure Cognitive Services Speech that must:

Convert up to 400 characters (short-form TTS, not long audio synthesis).

Provide multiple voice options to users.

Minimize costs (short-form TTS is cheaper than long-form neural synthesis).

To provide a list of available voices, Azure Speech exposes a REST API endpoint:

Correct endpoint:

https: / / < region > .tts.speech.microsoft.com/cognitiveservices/voices/list

This endpoint returns a list of all available voices (standard + neural) supported in the region, including locale, gender, and style.

Evaluating the Options:

Option A: /longaudiosynthesis/voices

Wrong. This is for long audio synthesis (narration/long documents).

More expensive and not needed for short social media messages.

Option B: /cognitiveservices/voices/list ✅

Correct. This endpoint lists available voices for short-form text-to-speech, which matches the requirements.

Option C: /cognitiveservices/v1?deploymentId={deployment}

Wrong. This is for using a custom voice deployment.

Not required here since the solution should minimize cost and use standard available voices.

Option D: /speechtotext/v3.0/models/base

Wrong. This is for speech-to-text (STT), not text-to-speech.

Correct Answer:

B. https://uksouth.tts.speech.microsoft.com/cognitiveservices/voices/list

Microsoft References

Azure Speech Service REST API reference

List voices in Azure Text-to-Speech

Comprehensive Detailed Explanation

The requirement:

You have an Azure AI Document Intelligence resource (formerly Form Recognizer).

You want the app to detect handwritten content inside PDF files.

Step 1 – Choosing the correct model

prebuilt-document: Extracts structure and text from documents, but not optimized specifically for handwriting.

prebuilt-contract: Designed for contracts, not general handwriting.

prebuilt-read: Extracts text (printed and handwritten) from documents. Supports handwritten content recognition.

Therefore, to analyze handwritten content, the correct choice is prebuilt-read.

Step 2 – Confidence threshold

The style.Confidence value indicates the confidence that the text is handwritten.

A typical threshold used is 0.75 (75%).

This ensures that only results with reasonably high confidence are considered handwritten.

Values like 0.1 would be too low (allowing false positives), while 1.0 might miss valid handwriting because it requires absolute certainty.

Correct Answer:

Model: prebuilt-read

Confidence threshold: 0.75

The requirement:

You have a system monitoring temperature data from a single data stream.

The system must generate an alert in response to atypical values.

The solution must minimize development effort.

Analysis of Options:

Univariate Anomaly Detection

Designed for detecting anomalies in a single time series (e.g., temperature, pressure, humidity, sales).

Since the system monitors temperature only, this is a classic univariate case.

Provides simple integration with minimal effort.

Correct choice.

Azure Stream Analytics

Can process real-time streaming data and detect conditions (with custom queries).

However, it requires more development effort since you would need to manually code logic for anomaly detection.

Not the minimal-effort option.

Metric alerts in Azure Monitor

Used to trigger alerts on predefined thresholds (static rules).

Not intelligent anomaly detection—does not automatically learn patterns from data.

Would require manual threshold setup, which is not efficient for anomaly detection.

Multivariate Anomaly Detection

Used when analyzing multiple related time series (e.g., temperature, pressure, vibration all together).

Since this scenario only has one variable (temperature), multivariate is unnecessary and adds complexity.

Correct Answer: A. Univariate Anomaly Detection

Microsoft References

Azure AI Anomaly Detector – Univariate

Multivariate Anomaly Detector

Difference between univariate and multivariate anomaly detection

On-premises Microsoft SQL Server database cannot be used as an index data source.

Note: Indexer in Azure Cognitive Search: : Automate aspects of an indexing operation by configuring a data source and an indexer that you can schedule or run on demand. This feature is supported for a limited number of data source types on Azure.

Indexers crawl data stores on Azure.

Azure Blob Storage

Azure Data Lake Storage Gen2 (in preview)

Azure Table Storage

Azure Cosmos DB

Azure SQL Database

SQL Managed Instance

SQL Server on Azure Virtual Machines

The requirement is to optimize the reading experience for users with dyslexia and learning differences .

Azure AI Immersive Reader is specifically designed to make text more accessible, improving comprehension by enabling features like text-to-speech, line focus, and translation.

Translator (A) is for translating text, not accessibility.

Document Intelligence (B) is for extracting information from documents.

Azure AI Language (D) is for NLP tasks, not improving reading accessibility.

Microsoft References:

Azure AI Immersive Reader overview

Upload to: An Azure Storage account

Model type: Custom neural

You have 1,000 scanned hand-written survey responses with no consistent layout. The goal is to extract data while minimizing development effort.

Step 1: Upload location

For Azure AI Document Intelligence (formerly Form Recognizer), training data (images, PDFs) must be placed in a container in an Azure Storage account.

Options like Cosmos DB or Azure Files share are not valid training data sources for Document Intelligence.

Therefore, you upload the survey images to Azure Storage account.

Step 2: Model type

The surveys are handwritten and do not have a consistent layout.

Custom template models work only when the layout is fixed and consistent (e.g., invoices with the same fields in the same place).

Identity document (ID) model is a prebuilt model for passports, driver’s licenses, etc., not for surveys.

Custom neural model is designed to handle unstructured or variable-layout forms, including handwritten content. This best fits the survey scenario.

Thus, the correct configuration is:

Upload to Azure Storage account

Use Custom neural model

Correct Answer:

Upload to: An Azure Storage account

Model type: Custom neural

Microsoft References

Azure AI Document Intelligence – Custom models

Custom neural vs custom template models

Train a custom model with Azure Storage input

“Monitor online activity” in Content Safety Studio shows usage and moderation results and allows viewing category distributions; it’s meant for observability of live traffic , not for running offline tests on sample questions to tune filter settings. Hence, it doesn’t meet the requirement. Content Safety Studio

References

Azure AI Content Safety – Protected material detection concepts & quickstart.

Azure OpenAI – System message (metaprompt) guidance. Microsoft Learn

Content Safety Studio – Monitor online activity page. Content Safety Studio

Azure OpenAI content filtering system and configuration overview.

Conversational Language Understanding (CLU) is trained using utterances .

Adding these example phrases as utterances for the FindContact intent is exactly how training is done.

This ensures the model learns to recognize similar queries.

Correct Answer: Yes

Box 1: Classification

Box 2: Multiclass

A multiclass classification project is for classifying images into a set of tags, or target labels. An image can be assigned to one tag only.

Box 3: General

General: Optimized for a broad range of image classification tasks. If none of the other specific domains are appropriate, or if you ' re unsure of which domain to choose, select one of the General domains.

With Azure OpenAI , you don’t call a raw “model name” directly; you call a deployment of that model. SDKs and REST require:

the resource endpoint ,

the API key (or Entra ID token), and

the deployment name to target the specific model instance.

References

Azure OpenAI quickstart (connect using endpoint, key, and deployment name ).

https://learn.microsoft.com/azure/ai-services/openai/quickstart

Chat/completions—path uses /deployments/{deployment-id}.

https://learn.microsoft.com/azure/ai-services/openai/reference#chat-completions

Entity linking in Azure AI Language identifies entities in text and links them to entries in a knowledge base such as Wikipedia, providing precisely the additional context and references you need. Custom NER extracts entities but doesn’t link to Wikipedia; Content Safety moderates content; Key phrase extraction surfaces topics without external links.

Microsoft References:

Entity linking overview (links entities to Wikipedia). Microsoft Learn

How to call the Entity Linking API (returns entities with Wikipedia links)

Key Knowledge:

To analyze images with Azure OpenAI, you must use a GPT-4 model with vision support (model version vision-preview ).

This requires deploying a GPT-4 model for vision.

Then you use the Chat playground (not completions, not DALL-E) since you want analysis, not generation.

You need to give the assistant instructions in the system message field (e.g., “You are an AI assistant that describes images”).

Finally, you upload an image and prompt the model to describe it.

Correct Sequence:

Create a new deployment, select a GPT-4 model, and set Model version to vision-preview.

Because GPT-4 with vision is required.

Open Chat playground and select the deployed model.

Vision capabilities are accessed through the Chat playground.

In the System message field, enter: “You are an AI assistant that describes images.”

This sets the assistant’s role.

In the Chat session pane, enter a text prompt of “Describe this image,” and upload an image by using the attachment button.

This triggers the model to analyze and describe the image.

Verified Answer (Correct Order):

Create a new deployment, select a GPT-4 model, and set Model version to vision-preview.

Open Chat playground and select the deployed model.

In the System message field, enter: You are an AI assistant that describes images.

In the Chat session pane, enter: Describe this image , and upload an image by using the attachment button.

Microsoft References:

Azure OpenAI vision capabilities

Azure OpenAI Studio overview

For Azure OpenAI fine-tuning, training data must be provided as a JSON Lines (.jsonl) file. Each line represents one example. Because your data is described as prompt–completion pairs, the required shape is typically:

{ " prompt " : " < your prompt > " , " completion " : " < ideal completion > " }

(Chat model fine-tuning instead uses a messages array per line, but the file format is still JSONL.) JSONL is the only accepted format for upload to the fine-tuning job.

Microsoft References

Azure OpenAI Service – Fine-tuning: data preparation and formats (JSONL; prompt–completion and chat messages ).

Azure OpenAI Service – How to fine-tune models (training files must be .jsonl).

Comprehensive Detailed Explanation

You are asked to construct a URI for the Microsoft Translator API call that:

Translates webpage content into Greek (el).

Returns a transliteration in the Roman alphabet (Latin script).

The base URI given is:

https: //api.cognitive.microsofttranslator.com/translate?api-version=3.0

Now, let’s evaluate the required query parameters.

1. to=el

This specifies the target language for translation.

Since the requirement is to translate into Greek, we must include:

to =el

Correct

2. textType=html

The source content is from a webpage.

Translator API requires textType=html for web page or HTML-formatted content.

If omitted, the default is plain text.

Correct

3. toScript=Latn

By default, Greek text is written in its native Greek script.

To provide a transliteration in the Roman alphabet, we must set toScript=Latn .

Latn = Latin script.

Correct

Incorrect Options

A. toScript=Cyrl

Cyrl = Cyrillic script. Not required here.

B. from=el

This would mean the source language is Greek.

In the requirement, the target is Greek, so this is incorrect.

E. textType=plain

Incorrect, since we are translating HTML webpage content, not plain text.

Correct Answer: C. textType=html, D. to=el, F. toScript=Latn

Microsoft References

Translator Text API v3.0 Reference – Translate

Language and Script Parameters (to, from, toScript)

Your documents must include a field specifying which groups have access. This information becomes the filter criteria against which documents are selected or rejected from the result set returned to the issuer.

D: A query request targets the documents collection of a single index on a search service.

CF: In order to trim documents based on group_ids access, you should issue a search query with a group_ids/any(g:search.in(g, ' group_id1, group_id2,... ' )) filter, where ' group_id1, group_id2,... ' are the groups to which the search request issuer belongs.

Comprehensive Detailed Explanation

When an indexer runs in Azure AI Search, it processes each document through a fixed series of stages:

Document cracking

The indexer opens the item (file/row) and extracts text, images, and metadata, creating the root of the enriched document (/document). This is always the first stage.

Field mappings

Next, source fields are mapped directly to target index fields before any transformations . Field mappings occur after document cracking but before skillset execution . Microsoft Learn

Skillset execution

Built-in or custom skills (for example, language and sentiment analysis in your scenario) run and write outputs into the in-memory enriched document. Microsoft Learn

Output field mappings

Because skill outputs live only in memory, you must define output field mappings to route selected nodes of the enriched document into index fields. This step comes after skillset execution.

Push to index

Finally, the indexer hands off raw and enriched content to the search index (the physical data structures) so it becomes searchable—i.e., the content is “pushed to the index.” Microsoft Learn

This order— document cracking → field mappings → skillset execution → output field mappings → push to index —ensures raw content is extracted, direct source-to-index mappings are applied, AI enrichment is performed, enriched outputs are projected to fields, and the completed documents are written into the index.

Microsoft Azure AI References

Indexers in Azure AI Search – Stages of indexing (Document cracking; Field mappings; Skillset execution; Output field mappings, with field mappings occurring before transformations). Microsoft Learn

Skillset concepts (Output of skillset is routed to the index via output field mappings after skillset execution). Microsoft Learn

AI enrichment concepts (Field mappings move raw source content to the index; output field mappings move enriched content; indexing ingests raw and enriched content into the physical index). Microsoft Learn

Annotations & enriched document tree (Enriched document is created during document cracking at /document). Microsoft Learn

In the Azure AI Translator .NET SDK ( Azure.AI.Translation.Text ), the TextTranslationClient exposes TranslateAsync overloads that accept a target language (e.g., " fr " ) and an input string to translate. The call returns a Response < IReadOnlyList < TranslatedTextItem > > . Each TranslatedTextItem includes the automatically detected source language ( DetectedLanguage.Language ) and a collection of translations in Translations . To print the translated text for the first target language, read translation.Translations[0].Text .

Therefore:

Use TranslateAsync(targetLanguage, input) to perform the translation.

Output translation.Translations[0].Text to display the translated result.

Microsoft References

TextTranslationClient.TranslateAsync method (overloads, usage). Microsoft Learn

TextTranslationClient class overview. Microsoft Learn

TranslatedTextItem model and Translations property (array of translation results).

Quickstart: Translator text client libraries (end-to-end usage pattern). Microsoft Learn