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

Paginated reports are designed for printing or PDF generation, with table-style reports that span multiple pages.

These are built using Power BI Report Builder , a standalone tool.

B. Charticulator is for creating custom visuals, not paginated reports.

C. Power BI Desktop builds interactive reports, dashboards, and data models, not paginated reports.

D. Power BI Service is for publishing, sharing, and consuming reports, but not building paginated reports.

Correct Answer: A. Power BI Report Builder

The requirement:

You are using Azure AI Anomaly Detector.

You need to deploy it on Server1, which has intermittent internet access.

This means you need to run the service locally using containers (Docker).

Step 1 – Install Docker Engine

Before pulling or running any containers, Docker must be installed on Server1.

Without Docker Engine, no container can be deployed.

Step 2 – Pull the container image

Use docker pull to download the Anomaly Detector container image from Microsoft Container Registry.

This requires internet access, so it should be done when connectivity is available.

Step 3 – Run the container

After pulling the image, use docker run to start the Anomaly Detector container.

This exposes a local REST API endpoint on Server1.

Step 4 – Query the local endpoint

Once the container is running, you can query the prediction endpoint on Server1.

This allows local inference without requiring continuous internet access.

Correct Sequence:

Install the Docker Engine on Server1.

From Server1, run the docker pull command.

From Server1, run the docker run command.

Query the prediction endpoint on Server1.

Microsoft References

Use Azure AI Anomaly Detector on containers

Deploy Azure AI services in Docker containers

Anomaly Detector container setup

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

You need to analyze confidential documents with the Language service while ensuring those documents never leave your premises. The supported pattern for Azure AI Services (Cognitive Services) is to run the Language service container on-premises and send the app’s requests to that local container endpoint. The container performs inference locally; only metering/billing calls are sent to Azure.

To achieve this:

Provision an on-premises Kubernetes cluster that has internet connectivity.

Azure AI service containers running on-prem require outbound access to Azure for metering and billing unless you’re using the special disconnected model (not implied here). Therefore, the cluster must have internet connectivity so the container can reach the Azure billing endpoint while keeping document content local.

Pull an image from the Microsoft Container Registry (MCR).

Official Azure AI service containers (including Language) are published in MCR, not Docker Hub. You must pull the Language (Text Analytics/Language) container image from MCR.

Run the container and specify an API key and the Endpoint URL of the Cognitive Services resource.

When you start the container, you configure it with the API key and billing (endpoint) URL of your Azure Cognitive Services (multi-service or Language) resource. This enables the container to authenticate and report usage to Azure, while your data stays on-prem.

Why not the other options?

AKS would place workloads in Azure, which isn’t required when the requirement is to keep documents on-prem.

On-prem cluster isolated from the internet would block the container’s required calls to Azure’s billing endpoint.

Pull from Docker Hub is incorrect because Azure AI service containers are published to MCR.

App ID and Client Secret are not the standard parameters for Azure AI service containers; they require API key + billing endpoint.

Microsoft Azure AI Solution References

Use Azure AI services in containers (billing/endpoint and API key requirements, data remains local):

Microsoft Learn – Install and run containers for Azure AI services and Use containers with Azure AI services (metering and billing) .

https://learn.microsoft.com/azure/ai-services/containers/

Language service container images on Microsoft Container Registry (MCR):

Microsoft Learn – Deploy language containers (Text Analytics/Language) .

https://learn.microsoft.com/azure/ai-services/language-service/how-to/use-containers

Networking requirements (internet connectivity for metering):

Microsoft Learn – Configure containers and network access for Azure AI services containers .

https://learn.microsoft.com/azure/ai-services/containers/container-requirements-and-limits

These documents collectively show that: (a) containers are pulled from MCR, (b) they are configured with API key + endpoint for billing, and (c) internet egress is required for metering while payload data remains on-premises.

Azure AI Document Intelligence (formerly Form Recognizer) is provisioned as a Cognitive Services account with the kind set to FormRecognizer . In an ARM template, Document Intelligence is created under the resource provider Microsoft.CognitiveServices with the resource type accounts . Therefore:

type must be " Microsoft.CognitiveServices/accounts "

kind must be " FormRecognizer "

This aligns with Microsoft’s ARM schema for Cognitive Services accounts and the documented way to deploy Document Intelligence.

Key references from Microsoft documentation:

Azure Resource Manager template reference for Cognitive Services accounts — shows type: Microsoft.CognitiveServices/accounts and supported kind values including FormRecognizer .

https://learn.microsoft.com/azure/templates/microsoft.cognitiveservices/accounts

Azure AI Document Intelligence (Form Recognizer) resource creation guidance — indicates the service is deployed as a Cognitive Services account with kind FormRecognizer .

https://learn.microsoft.com/azure/ai-services/document-intelligence/overview

Create Document Intelligence resources (portal/ARM/Bicep) – reiterates Cognitive Services account with FormRecognizer kind.

https://learn.microsoft.com/azure/ai-services/document-intelligence/create-resources

Comprehensive Detailed Explanation

The scenario:

You are working with Azure AI Video Indexer.

You need to add a custom brand/logo and also configure an exclusion so that this brand is not indexed.

In Video Indexer’s REST API for brands, the configuration JSON includes:

" enabled " : true/false → Determines whether the brand should be indexed.

Setting " enabled " : false means the brand is excluded.

The other properties in the dropdown ( state , tags , useBuiltin ) are not correct in this context for configuring exclusions.

Therefore, to exclude a custom brand:

" enabled " : false

Correct Answer:

Attribute: " enabled "

Value: false

Microsoft References

Video Indexer – Brands customization

Azure Video Indexer API – Brands

Azure AI Document Intelligence offers pre-built models for common document types like invoices, which extract key fields (e.g., vendor, amount, date) with minimal setup. For custom forms like internal authorization requests, the pre-built general document model handles layout and text extraction, but to minimize development effort, use the pre-built invoice model where applicable and a custom model only if pre-built options fall short. However, the standard recommendation prioritizes pre-built for both to avoid training.

To detect harmful content with Azure AI Content Safety using the .NET SDK, you instantiate a ContentSafetyClient with the endpoint and key. For text moderation, you construct an AnalyzeTextOptions object with the input string (and optionally specify categories, blocklists, etc.). You then call client.AnalyzeText(AnalyzeTextOptions options) and inspect the result (e.g., categories analysis and blocklist matches).

Code completed:

var client = new ContentSafetyClient(new Uri(endpoint), new AzureKeyCredential(key));

var request = new AnalyzeTextOptions( " what is the weather forecast for Seattle " );

Response < AnalyzeTextResult > response = client.AnalyzeText(request);

Microsoft Azure AI References

Azure AI Content Safety – SDK usage for text analysis with ContentSafetyClient and AnalyzeTextOptions (Analyze Text API).

Azure AI Content Safety – Concepts: text categories (hate/sexual/violence/self-harm) and blocklists, returned in AnalyzeTextResult .

For an Azure AI Language Custom Question Answering project (QA1), you can import Q & A pairs directly from Excel (.xls/.xlsx) or TSV files in Language Studio. Microsoft’s guidance explicitly states that when importing question–answer sources into a project, you can choose Excel or TSV. JSON, LU, and CSV are not supported as import file types for Q & A pairs in Language Studio. Microsoft Learn

Additional Microsoft guidance notes that structured TXT, TSV, and XLS files can be uploaded to create or augment a project, and clarifies import/export behavior for TSV and XLS. This reinforces that Excel and TSV are the supported formats here. Microsoft Learn

Microsoft References:

Move projects and Q & A pairs – “Import question and answers… option to import either an Excel or TSV file.” Microsoft Learn

Format guidelines for Custom Question Answering – structured TXT, TSV, and XLS supported; import/export notes for TSV and XLS. Microsoft Learn

You need to identify industry-specific technical terms in documents. That is a classic use case for Custom Named Entity Recognition (custom NER) , which lets you build a model to extract domain-specific entities (for example, chemical names, part numbers, contract IDs) from unstructured text. Among the options, only custom NER is designed to recognize entities unique to your domain.

Why not Key Phrase Extraction? It returns the main concepts/talking points of text, not typed, domain-specific entities.

Why not CLU? Conversational Language Understanding is for intent and entity extraction from user utterances in conversations , not for mining technical terms from documents. Microsoft Learn

Why not Language Detection? It detects the language of the text only.

Custom NER fits: Purpose-built to extract domain-specific entities with minimal code; you label a small dataset and train in Language Studio.

Microsoft References:

Custom Named Entity Recognition overview – purpose is extracting domain-specific entities . Microsoft Learn

Transparency note for custom NER – emphasizes domain-specific extraction. Microsoft Learn

Key Phrase Extraction overview – identifies main concepts , not domain entities. Microsoft Learn

CLU overview – intent/entity for conversational scenarios. Microsoft Learn

Step 1: Create a project. (Given)

Step 2: Add a data connection.

Step 3: Add a deployment.

Explanation

Add a data connection: Before the model can " see " your grounding data stored in an Azure Files share, you must establish a connection. This step allows the project to securely access and index the external data source so it can be used for retrieval.

Add a deployment: In Microsoft Foundry, you don ' t just " add a model " in a vacuum; you must deploy a specific model (such as a GPT-4 chat model or an embedding model) to make it active and available to interact with your data and respond to queries.

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.

The requirement is to ensure the chatbot provides formal responses to spurious questions (random/off-topic).

The correct way to handle this is to add a chit-chat personality dataset (such as qna_chitchat_professional.tsv ) in Language Studio, retrain, and republish.

Modifying existing QnA pairs for custom intents (as the solution suggests) would not cover spurious/off-topic questions automatically. It only affects known knowledge base intents.

Therefore, this solution does not meet the goal.

Correct Answer: B

 SpeechRecognitionLanguage must be set to " fr " (French).

 AddTargetLanguage( " de " ) must be used to specify German as the translation output.

Correct Code Completion

var speechTranslationConfig =

SpeechTranslationConfig.FromSubscription(speechKey, speechRegion);

speechTranslationConfig.SpeechRecognitionLanguage = " fr " ;

speechTranslationConfig.AddTargetLanguage( " de " );

Explanation

SpeechRecognitionLanguage → sets the source spoken language that the Speech service listens to (here, French).

AddTargetLanguage( " de " ) → adds German as the target translation language.

SpeechSynthesisLanguage would be used if you want to speak out the translation, but since the requirement is only about defining input and output languages, we use AddTargetLanguage .

Microsoft Reference

Speech translation with Speech SDK

Final Answer:

First blank → SpeechRecognitionLanguage

Second blank → AddTargetLanguage

Comprehensive Detailed Explanation

Looking at the exhibit:

The GetWeather dialog is set up with a trigger phrase:

“what is the weather like in {city=Seattle}”

Here, city is an entity (ex: Seattle, New York, London, etc.).

1. User asks “what is the weather like in New York”

Since “New York” matches the city entity, the bot will correctly identify New York as a city entity.

It will not confuse it with a state entity, nor default to Seattle, because entity recognition extracts the correct city name dynamically.

Correct choice: Identify New York as a city entity

2. GetWeather dialog trigger

In Bot Framework Composer, the trigger type determines how the dialog is activated.

Since GetWeather is linked to the intent “GetWeather” from the Language Understanding model (LUIS/CLU), the trigger is Language Understanding Intent recognized.

This means whenever the user utterance maps to the GetWeather intent, the dialog starts.

Correct choice: Language Understanding Intent recognized

Correct Answer:

Identify New York as a city entity

Language Understanding Intent recognized

Microsoft References

Bot Framework Composer – Triggers

Entities in Conversational Language Understanding

Comprehensive Detailed Explanation

In the provided LUDown file snippet:

Intents represent the purpose or action the user wants to perform.

Examples: ## Confirm , ## ExtractName , ## Logout , ## SelectItem , ## SelectNone .

These are all intent definitions.

So, SelectItem is an intent.

Utterances are the example phrases that users might say to invoke a particular intent.

Under ## SelectItem , one example utterance is:

choose { @DirectionalReference =top right}

This is an example phrase that maps to the SelectItem intent and contains the DirectionalReference entity.

Therefore, Choose {@DirectionalReference=top right} is an utterance.

Why not the other options?

Domain: Predefined category grouping multiple intents (not applicable here).

Entity: Extracted data within utterances (e.g., @DirectionalReference=top right or @personName ).

The entire phrase " choose {@DirectionalReference=top right} " is not an entity but an utterance containing an entity.

Correct Answers

SelectItem → an intent

Choose {@DirectionalReference=top right} → an utterance

Microsoft References

LUDown file format for LUIS

LUIS concepts: intents, utterances, and entities

The None intent is a built-in intent in CLU/Language Understanding models.

It is used to capture queries that don’t match any of the defined intents.

By adding representative irrelevant utterances to the None intent , the model learns how to reject spurious queries.

Correct Answer: C

Active learning is a technique of machine learning in which the machine learned model is used to identify informative new examples to label. In LUIS, active learning refers to adding utterances from the endpoint traffic whose current predictions are unclear to improve your model.

When working with Speech Studio in Azure AI Speech (for example, to build a custom speech model for recognition or training purposes), you must provide speech samples along with their transcripts.

Requirements for Uploading Speech Samples:

Audio File Format

The supported format is .wav (PCM, 16-bit, 16 kHz or 8 kHz mono).

Other formats like .wma , .flac , or .mp3 are not accepted for training custom models.

Batch Upload via .zip

Audio files must be placed in a .zip archive.

The .zip file must also include a transcription file (usually a .txt or .json file) that maps the spoken audio in each .wav file to the correct text.

Transcript Format

Transcripts must be plain text, not Microsoft Word documents.

The transcript must align correctly with each audio file to ensure the Speech service learns from accurate mappings.

Option Analysis

A. Combine into one .wma file

Incorrect. .wma is not supported. Also, Speech Studio expects multiple .wav samples, not one big file.

B. Upload a .zip file containing .wav files + transcript

Correct. This is the officially supported method for uploading training data into a Speech Studio project.

C. Upload .flac files with Word transcript

Incorrect. .flac is not supported. Transcripts must be plain text, not Word files.

D. Upload individual .wma files

Incorrect. .wma is not supported.

Correct Answer: B. Upload a .zip file that contains a collection of audio files in the .wav format and a corresponding text transcript file.

Microsoft References

Prepare training data for Custom Speech

Speech Studio – Data Requirements

To maximize answer accuracy (reduce randomness and hallucinations) with Azure OpenAI GPT-3.5, you should lower the sampling randomness. The primary control for this is temperature :

Temperature controls how “creative” or random the model is.

Lower values → more deterministic, focused, and conservative outputs.

temperature = 0 makes the model pick the highest-probability tokens, which typically yields the most accurate and repeatable responses for transactional bots like booking/reservations.

Top P (nucleus sampling) is an alternative to temperature. Microsoft recommends using one or the other. While reducing Top P also narrows randomness, the clearest and most common approach for maximizing accuracy is setting temperature to 0. Setting Top P to 0 is generally not recommended and may be invalid depending on the SDK.

System message tuning (Option D) helps with tone, role, and policy adherence, but does not itself guarantee factual accuracy if decoding randomness remains high.

Including the travel agent’s database (Option A) would require Azure OpenAI on your data or a RAG pattern. That can improve grounding of facts, but it’s not a model parameter change and is outside the scope of simply configuring GPT-3.5; moreover, accuracy still benefits from low temperature even when using your own data.

Therefore, the best single action here is: set Temperature to 0.

Microsoft Azure AI Solution References

Azure OpenAI Service – Chat Completions parameters (Temperature and Top P): “Lower values like 0.2 will make the output more focused and deterministic… use either temperature or top_p but generally not both.”

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

Prompt engineering with Azure OpenAI – controlling randomness and determinism:

https://learn.microsoft.com/azure/ai-services/openai/concepts/prompt-engineering

Azure OpenAI on your data (grounding with enterprise data/RAG):

https://learn.microsoft.com/azure/ai-services/openai/concepts/use-your-data

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

Obtain values to connect your bot to the knowledge base

1.In the QnA Maker site, select your knowledge base.

2.With your knowledge base open, select the SETTINGS tab. Record the value shown for service name. This value is useful for finding your knowledge base of interest when using the QnA Maker portal interface. It ' s not used to connect your bot app to this knowledge base.

3.Scroll down to find Deployment details and record the following values from the Postman sample HTTP request:

4.POST /knowledgebases/ < knowledge-base-id > /generateAnswer

5.Host: < your-host-url >

6.Authorization: EndpointKey < your-endpoint-key >

To make the chatbot respond only when the answer’s confidence is ≥ 95%, you must set the request body property confidenceScoreThreshold to 0.95 in the Query knowledge bases operation of Custom question answering. The REST API for querying a Custom question answering project is:

POST { Endpoint }/language/ :query-knowledgebases?projectName= {projectName} & deploymentName={deploymentName} & api-version= 2021 - 10 - 01

Here, projectName identifies the Custom question answering project you’re querying (the screenshot’s placeholder < chatbot-project > ), while deploymentName specifies which deployment (for example, production ) to use. The request body includes confidenceScoreThreshold (0–1) to filter out answers below that score; setting it to 0.95 enforces the requirement.

Example snippet:

curl -X POST " $LANGUAGE_ENDPOINT /language/:query-knowledgebases?projectName= < chatbot-project > & deploymentName=production & api-version=2021-10-01 " \

-H " Ocp-Apim-Subscription-Key: $LANGUAGE_KEY " \

-H " Content-Type: application/json " \

-d ' {

" question " : " How much energy does my phone have left? " ,

" confidenceScoreThreshold " : 0.95

} '

References

REST API: Question Answering – Get Answers (shows endpoint with projectName / deploymentName and the confidenceScoreThreshold request property). Microsoft Learn

REST API (newer version) parameter list for projectName / deploymentName . Microsoft Learn

Comprehensive Detailed Explanation

The requirement:

You have an Azure OpenAI resource.

You want to build an app (App1) that writes press releases.

The solution must minimize development effort.

Step 1 – Select the model deployment

Since press release generation requires natural language generation, the best choice is GPT-3.5 Turbo.

The text-embedding-ada-002 model is used for semantic search and embeddings, not text generation, so it’s not appropriate here.

Step 2 – Apply a system message template

Azure OpenAI Studio provides pre-built system message templates to speed up development.

For writing press releases, the correct template is the Marketing Writing Assistant template.

This minimizes development effort since it already configures prompt engineering for marketing copywriting.

Step 3 – Deploy the solution

Once the deployment and template are configured, you deploy the solution to a new web app so it can be used as App1.

Correct Sequence:

Create a deployment that uses the GPT-3.5 Turbo model.

Apply the Marketing Writing Assistant system message template.

Deploy the solution to a new web app.

Microsoft References

Azure OpenAI Studio – Getting Started

Azure OpenAI GPT-3.5 models

Azure OpenAI Studio system message templates

Box 1: Yes

The ActivityHandler.OnMembersAddedAsync method overrides this in a derived class to provide logic for when members other than the bot join the conversation, such as your bot ' s welcome logic.

Box 2: Yes

membersAdded is a list of all the members added to the conversation, as described by the conversation update activity.

Box 3: No

Instead, you could migrate to a Cognitive Search service that uses a higher tier.

Note: A simple fix to most throttling issues is to throw more resources at the search service (typically replicas for query-based throttling, or partitions for indexing-based throttling). However, increasing replicas or partitions adds cost, which is why it is important to know the reason why throttling is occurring at all.

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

In SQL, DML (Data Manipulation Language) statements include SELECT , INSERT , UPDATE , and DELETE . Often, you need to filter which rows are affected or returned. That filtering is done with the WHERE clause.

Let’s review the options:

ALTER

Used in Data Definition Language (DDL), not DML.

Alters the structure of a database object (e.g., add/remove columns, modify constraints).

Not used to filter rows.

ON

Used in JOIN operations to specify the relationship between tables.

Does not specify row-level filtering criteria in general DML.

SET

Used in the UPDATE statement to assign new values to columns.

Does not specify which rows to update.

WHERE

Used in DML statements to specify criteria for rows that must match.

Examples:

SELECT * FROM Customers WHERE Country = ' USA ' ;

DELETE FROM Orders WHERE OrderDate < ' 2020-01-01 ' ;

UPDATE Products SET Price = Price * 1.1 WHERE CategoryID = 5;

Thus, the correct clause is WHERE.

Correct Answer: WHERE

Microsoft References

SQL WHERE clause

SQL UPDATE with WHERE

SQL DELETE with WHERE

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

Box 1: QnA Maker Editor

Scenario: Provide all employees with the ability to edit Q & As.

The QnA Maker Editor (read/write) has the following permissions:

Create KB API

Update KB API

Replace KB API

Replace Alterations

" Train API " [in

new service model v5]

Box 2: Contributor

Scenario: Only senior managers must be able to publish updates.

Contributor permission: All except ability to add new members to roles

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

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

Box 2: /translate

Parameter type: stream

Visual features list: VisualFeatureTypes.Description

Result to use: results.Description.Captions[0]

To generate accessible alt text , you should use the caption produced by Azure Computer Vision’s Description feature (it produces a human-readable sentence with a confidence score). Therefore:

The image input should be a stream , because you’re uploading images (not just passing URLs) during product creation and AnalyzeImage…Async supports image streams .

Request the Description feature in VisualFeatureTypes so the service returns results.Description.Captions.

Use results.Description.Captions[0] and return the caption text if its confidence is high enough (e.g., > 0.5) to meet the accessibility requirement that all images must have relevant alt text .

Other features (Tags, Objects, Brands) are useful for enrichment but do not directly return natural-language captions suitable for alt text.

Microsoft Azure AI Solution References

Computer Vision (Image Analysis) – Description/Captions and features: Microsoft Docs, Image Analysis – VisualFeatureTypes.Description returns description.captions.

https://learn.microsoft.com/azure/ai-services/computer-vision/concept-image-analysis

SDK usage (analyze image from a stream): Microsoft Docs, Analyze an image by using the Computer Vision client library .

https://learn.microsoft.com/azure/ai-services/computer-vision/how-to/call-analyze-image?tabs=version-3-2#analyze-an-image-from-a-stream

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

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: 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.

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.

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

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.

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.

Box 1: Cognitive Service User

Ensure that the members of a group named Management-Accountants can approve the FAQs.

Approve=publish.

Cognitive Service User (read/write/publish): API permissions: All access to Cognitive Services resource except for ability to:

1. Add new members to roles.

2. Create new resources.

Box 2: Cognitive Services QnA Maker Editor

Ensure that the members of a group named Consultant-Accountants can create and amend the FAQs.

QnA Maker Editor: API permissions:

1. Create KB API

2. Update KB API

3. Replace KB API

4. Replace Alterations

5. " Train API " [in new service model v5]

Box 3: Cognitive Services QnA Maker Read

Ensure that the members of a group named the Agent-CustomerServices can browse the FAQs.

QnA Maker Read: API Permissions:

1. Download KB API

2. List KBs for user API

3. Get Knowledge base details

4. Download Alterations

Generate Answer

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.

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.

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.

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.

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.