Pass the Microsoft Azure AI Engineer Associate AI-102 Questions and answers with ValidTests

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

Provision the Language service resource in Azure.

Deploy a Docker container to an on-premises server.

Run the container and query the prediction endpoint.

According to the Microsoft documentation, the Language service is a cloud-based service that provides various natural language processing features, such as sentiment analysis, key phrase extraction, named entity recognition, etc. You can provision the Language service resource in Azure by following the steps in Create a Language resource. You will need to provide a name, a subscription, a resource group, a region, and a pricing tier for your resource. You will also get a key and an endpoint for your resource, which you will use to authenticate your requests to the Language service API.

According to the Microsoft documentation, you can also use the Language service as a container on your own premises or in another cloud. This option gives you more control over your data and network, and allows you to use the Language service without an internet connection. You can deploy a Docker container to an on-premises server by following the steps in Deploy Language containers. You will need to have Docker installed on your server, pull the container image from the Microsoft Container Registry, and run the container with the appropriate parameters. You will also need to activate your container with your key and endpoint from your Azure resource.

According to the Microsoft documentation, once you have deployed and activated your container, you can run it and query the prediction endpoint to get sentiment analysis results. The prediction endpoint is a local URL that follows this format: http:// :/text/analytics/v3.1-preview.4/sentiment. You can send HTTP POST requests to this endpoint with your text input in JSON format, and receive JSON responses with sentiment labels and scores for each document and sentence in your input.

When deploying an Azure OpenAI model using the Microsoft.CognitiveServices/accounts/deployments resource in an ARM template, the throughput for a Standard deployment is set on the SKU object. Specifically:

Use the capacity field of the SKU to specify the per-deployment rate.

Provide the integer value that represents the requests per minute (RPM) you want the deployment to handle.

Therefore, to meet the requirement of 600 requests per minute, complete the template as:

"sku": {

"name": "Standard",

"capacity": 600

}

This uses a single deployment SKU with a defined capacity. The ARM schema for accounts/deployments explicitly includes sku.capacity for resources that support scale (Azure OpenAI deployments do), and Azure OpenAI quota/rate-limit guidance confirms that rate limits are assigned per deployment.

Microsoft Azure AI Solution References

ARM template—Microsoft.CognitiveServices/accounts/deployments (2023-05-01): property reference showing sku.capacity. Microsoft Learn

Resource type reference—latest accounts/deployments: confirms SKU usage on deployments. Microsoft Learn

Azure OpenAI quota and rate limits: explains assigning deployment-level limits (RPM/TPM). Microsoft Learn

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.

Box 1: GeographyV2

The prebuilt geographyV2 entity detects places. Because this entity is already trained, you do not need to add example utterances containing GeographyV2 to the application intents.

Box 2: Email

Email prebuilt entity for a LUIS app: Email extraction includes the entire email address from an utterance. Because this entity is already trained, you do not need to add example utterances containing email to the application intents.

Box 3: Machine learned

The machine-learning entity is the preferred entity for building LUIS applications.

Explanation:

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");

Speech Translation with Azure AI Speech SDK

SpeechTranslationConfig Class Reference

Microsoft References

Comprehensive Detailed ExplanationThe screenshot shows a Bot Framework Composer dialog that collects user input:

user.name is an entity.

False.

user.name is a property in bot state (a variable), not an entity.

Entities are part of LUIS/NLU models (e.g., PersonName, DateTime).

The dialog asks for a user name and a user age and assigns appropriate values to the user.name and user.age properties.

True.

The dialog explicitly has:

A Bot Asks (Text) step → assigns user’s response to user.name.

A Bot Asks (Number) step → assigns response to user.age.

So the values are stored in those properties.

The chatbot attempts to take the first non-null entity value for userName or personName and assigns the value to user.name.

True.

On the right-hand side, the Value expression is:

=coalesce(@userName, @personName)

coalesce returns the first non-null value.

This means if userName entity is available, it is used; otherwise, personName is used.

That result is assigned to user.name.

Correct Answers:

No

Yes

Yes

Bot Framework Composer - Manage variables and properties

Bot Framework Composer - Recognizers and entities

Coalesce function in Composer expressions

Microsoft References

1. Add a new application

2. Add a prebuilt domain intent ToDo (it has already utterances so we can skip this step)

3. Train

4. Publish

Non-relational databases (NoSQL) typically store semi-structured or unstructured data and have the following characteristics:

Entities are often self-describing, meaning they store their own schema within the data (e.g., JSON documents).

Schema is flexible, allowing for changes without restructuring the entire database.

Other options:

Full support for Transact-SQL → This is a characteristic of relational (SQL) databases, not NoSQL.

A fixed schema → Also a relational database characteristic.

Correct Answer: self describing entities

You need to monitor a video stream while ensuring the microphone stays enabled and detect when the user asks a question. The simplest/lowest-effort approach is to use Azure AI Speech-to-text to transcribe the user’s audio in real time, then apply a lightweight check (e.g., interrogatives like “who/what/how” or final “?”) to detect a question. Object detection or the Face service analyze visual content (objects/faces/emotions) and cannot tell whether a spoken utterance is a question. Language detection only identifies which language is being spoken; it does not transcribe or classify questions.

References

Azure AI Speech: real-time speech-to-text (streaming) for transcription and downstream analysis.https://learn.microsoft.com/azure/ai-services/speech-service/speech-to-text

Face service overview (not for speech/question detection).https://learn.microsoft.com/azure/ai-services/computer-vision/overview-identity

Custom Vision object detection overview (visual objects, not spoken questions).https://learn.microsoft.com/azure/ai-services/custom-vision-service/object-detection-overview

Language detection capability description (identifies language only).https://learn.microsoft.com/azure/ai-services/language-service/language-detection/overview