Describe features of Natural Language Processing workloads on Azure practice questions

Sentiment analysis and key phrase extraction

Why it fails: Sentiment analysis and key phrase extraction. Sentiment analysis is not used for summarization; it determines sentiment polarity, not key phrases.

Language detection and entity extraction

Why it fails: Language detection and entity extraction. While language detection is correct, entity extraction identifies named entities (people, organizations, etc.) but does not extract key phrases to summarize the issue. The stem explicitly requires key phrase extraction.

Entity extraction and sentiment analysis

Why it fails: Entity extraction and sentiment analysis. Neither entity extraction nor sentiment analysis extracts key phrases for summarization, and the first step should be language detection.

Language detection and entity extraction

Why it fails: Incorrect. While language detection identifies the language of the text and entity extraction pulls out specific entities (like names, places), these features do not provide sentiment analysis, which is required to understand customer sentiment. Entity extraction alone does not adequately capture the 'most frequently discussed topics' as it focuses on specific named entities rather than general topics.

Text summarization and question answering

Why it fails: Summarization condenses text, and question answering extracts answers to specific queries. Neither directly provides sentiment analysis or topic identification.

Named entity recognition and translation

Why it fails: NER finds entities like dates and organizations; translation converts language. Neither addresses sentiment or topic discovery.

Entity recognition

Why it fails: Entity recognition detects predefined named entities such as people, organizations, locations, dates, and product names, typically using a trained sequence-labeling model. While this can extract useful metadata from a support ticket—like a customer’s name or a product version—it is not designed to infer the overall emotional tone or to pull out arbitrary key phrases describing the problem. Thus it fails to meet the requirement to analyze sentiment, and it also falls short of general key phrase extraction for open-ended support reasons.

Language detection

Why it fails: Language detection identifies the dominant natural language of a text (e.g., English, Spanish) using statistical models over character patterns and word frequency. It assigns a language name and confidence score, but does not evaluate the emotional tone expressed by the author. Therefore, it cannot tell whether a customer message is positive, negative, or neutral, nor can it surface the specific phrases explaining why the customer contacted support.

Sentiment analysis

Why it fails: Sentiment analysis determines the emotional tone (positive, negative, neutral) of the text, not the specific topics being discussed.

Language detection

Why it fails: Language detection identifies the language in which the text is written, not the topics or key phrases within it.

Entity recognition

Why it fails: Entity recognition extracts pre-defined categories like persons, organizations, and locations, but not general topics or phrases like 'battery life'.

Sentiment analysis

Why it fails: Sentiment analysis returns positive, negative, and neutral scores per document, not topic categories. The agency needs key phrase extraction or topic modelling, which surfaces main subjects without labelled training data, so sentiment cannot produce 'politics' or 'sports' labels.

Named entity recognition

Why it fails: Named entity recognition extracts specific entities such as people, places, and organisations, not broad subject categories. Topic classification of articles into 'politics' or 'sports' without labelled data requires key phrase extraction or topic modelling instead.

Language detection

Why it fails: Language detection identifies which natural language a document is written in, returning locale codes such as 'en' or 'fr'. It says nothing about subject matter, so it cannot assign topic categories like 'economy' or 'sports' to articles.

Automatically applying CSS classes to text displayed on a web page

Why it fails: Applying CSS classes to text is purely a presentation concern that controls how HTML elements appear in a web browser, such as font colour, spacing, or layout. Custom text classification, on the other hand, is a natural language processing task that extracts the meaning of the text and assigns a semantic label; it has nothing to do with styling, and CSS classes carry no semantic information about the content of the text itself.

Classifying text files by their file type (PDF, Word, TXT)

Why it fails: Detecting whether a file is a PDF, Word document, or plain text is a low-level file system operation based on file extensions or magic byte signatures, not on understanding the meaning of the content. Custom text classification requires parsing the actual words and sentences to infer a semantic category, so distinguishing file formats by metadata or binary headers is entirely outside the scope of an NLP model.

A pre-built classifier that categorises all text into 10 universal topics

Why it fails: A pre-built classifier with a fixed set of ten universal topics is fundamentally different from custom text classification because its categories are predefined and cannot be adapted to a specific business domain. Custom text classification, by contrast, lets you define your own labels and train the model on your own annotated examples, so the model learns categories that are meaningful for your particular use case rather than relying on a generic taxonomy.

A chatbot that understands multiple languages and auto-translates responses

Why it fails: CLU can be trained on utterances in multiple languages and each project has a target language, but it does not translate text or generate responses; translation is the domain of Azure AI Translator, a distinct service. The 'auto-translates responses' capability describes a generative or translation service, not CLU's understanding pipeline. Since CLU's role is intent classification and entity extraction, the option conflates language support with translation.

A service that generates conversation transcripts from audio recordings

Why it fails: Speech-to-text transcription is handled by Azure AI Speech (specifically its speech recognition capabilities), which converts audio waveforms into written words. CLU does not process audio; it expects text as input and analyzes that text to infer conversational intent and entities. Therefore, this option misattributes the audio-processing component of a conversational AI solution to CLU, making it incorrect.

A tool for analysing the sentiment of customer conversations in real time

Why it fails: Sentiment analysis is a separate Azure AI Language feature that scores text on a positive-to-negative polarity continuum, usually for opinion mining or customer feedback. CLU, by contrast, uses classification models to identify which of your defined intents matches the utterance and extracts structured entities from it, rather than measuring emotional tone. Replacing intent classification with sentiment scoring would prevent a chatbot from knowing which action to take, so this substitution is incorrect.

Labelling training data with semantic tags for custom NLP model training

Why it fails: This describes data annotation for supervised machine learning, where human annotators tag text with labels to create training datasets. While such labels might include semantic tags or even role information, the labelling process itself is a data preparation step, not the automated NLP analysis performed by an SRL system. SRL is an algorithmic technique that processes input text at inference time to extract predicate-argument structures; it does not involve manually labelling training data.

Classifying the semantic category (positive, negative, neutral) of each sentence role

Why it fails: This option confuses semantic role labelling with sentiment analysis. Sentiment analysis classifies text (or aspects within text) into categories like positive, negative, or neutral, focusing on opinion and emotion rather than grammatical roles. SRL, by contrast, identifies syntactic-semantic roles such as Agent, Patient, and Location, which are about the structure of the action described, not its emotional polarity. Assigning a sentiment tag to each role would be a hybrid task, not the core SRL capability.

Assigning roles and responsibilities to team members in an AI project

Why it fails: This option misinterprets 'roles and responsibilities' as team management functions, conflating business project roles with linguistic semantic roles. In an AI project, assigning tasks to team members is project management, unrelated to natural language understanding. SRL specifically operates on sentences, assigning participant roles like Agent and Goal to words or phrases that denote entities involved in an action, not to people in a project team.

Extractive works on short texts; abstractive handles long documents

Why it fails: Document length is not the criterion that separates extractive from abstractive QA; both paradigms can operate on short passages and long corpora. For extractive QA, longer documents increase the number of candidate spans the model must rank, while abstractive QA may be constrained by the model's maximum context window, but these are practical engineering limitations, not definitional differences. The error is assuming that the form of the answer is tied to the size of the input.

Abstractive QA is faster because it doesn't need to search the full document

Why it fails: Abstractive question answering is not inherently faster; generating a response token by token is compute-intensive and typically slower than extractive span detection. Extractive models often use cross-attention over encoded tokens and decode a start/end boundary, which usually requires less computation than autoregressive generation. The fundamental distinction is output type and faithfulness, not wall-clock speed, since both methods must first encode and reason over the full document.

Extractive is pre-built; abstractive always requires custom model training

Why it fails: Both extractive and abstractive question answering exist as ready-made capabilities in Azure AI Language, so neither is inherently dependent on bespoke custom-model training. Extractive span prediction is built into custom question answering, while abstractive generative Q&A leverages pre-trained large language models like GPT-4 that can be used immediately. Customisation can improve domain-specific performance, but it is optional in both cases, making the claim that abstractive always requires custom training false.

A hosting service for training NLP models on conversational data

Why it fails: Azure AI Language (specifically Conversational Language Understanding) or Azure Machine Learning handles the training of NLP models on labeled conversational data, such as utterances and intents. Azure Bot Service does not train models; it is a runtime host that executes a bot application and manages the conversation loop, delegating any natural language understanding to a separately trained model. Training involves data labeling, model evaluation, and iteration, which is a data-science workflow completely outside the Bot Service's scope.

A monitoring service that tracks bot conversation quality metrics

Why it fails: Monitoring bot conversation quality is an optional capability delivered through Application Insights and Bot Service's analytics dashboards, not the foundational purpose of the service. These dashboards track metrics like message volume, user retention, and conversation drop-off, but they are telemetry features layered on top of the hosting infrastructure. The core function of Azure Bot Service is to receive, process, and route conversation activities, not to serve as a monitoring or analytics platform.

Azure's billing service for tracking bot API call usage and costs

Why it fails: Azure Cost Management is the billing and cost-tracking service for all Azure resources, including any message charges incurred by Azure Bot Service, but Bot Service itself is not a metering or billing component. It is a managed conversational platform that hosts and routes bot messages; any usage visibility comes from Azure Monitor and Cost Management. Confusing Bot Service with a billing service ignores its architectural role as the runtime glue between a chatbot's logic, its NLP model, and user-facing channels.

Language Understanding (LUIS)

Why it fails: LUIS is designed for conversational applications where users input short, single-turn utterances (typically under 500 characters) and the service predicts intents and extracts entities based on a custom model. Applying LUIS to long-form medical notes would require chunking and risk missing context, because it lacks prebuilt healthcare-specific entity recognition and is not optimized for batch document analysis. Its focus on dialog state and intents makes it inappropriate for this data extraction task.

Translator Text

Why it fails: Translator is a language translation service that converts text from one language to another while preserving the raw content as continuous text. It provides no inherent capability to identify or extract structured data fields such as names, dates, or medical codes, and it does not understand semantic categories. Even after translation, separate NLP services would be required to extract the needed data, so it is not the right choice.

Speech

Why it fails: The Speech service is dedicated to processing audio, encompassing speech-to-text transcription, text-to-speech synthesis, speech translation, and speaker verification. While it can transcribe a doctor's verbal notes into text, it performs no natural language analysis to extract structured entities from that transcript or from pre-existing written notes. Therefore, it cannot fulfill the requirement of extracting specific data elements from the medical notes.

Speech to Text and Text Analytics API (standard)

Why it fails: Although Speech to Text can handle the transcription portion, the standard Text Analytics API performs generic tasks like sentiment analysis and broad entity recognition (e.g., person, organization, location). It is not trained on clinical vocabularies and therefore cannot identify medical-specific entities such as drug dosages, ICD-10 codes, or symptom relationships. This option falls short because the analysis layer lacks the specialized medical models that Text Analytics for Health provides.

Translator Text and Language Understanding (LUIS)

Why it fails: Translator Text is designed to translate written text between languages, so it neither transcribes audio input nor extracts structured information from clinical speech. Language Understanding (LUIS) is a conversational tool that detects intents and custom entities from user utterances, but it requires extensive training on domain-specific phrases and is not inherently equipped for medical terminology. This pairing fails to deliver any speech-to-text capability and does not offer the out-of-the-box healthcare entity extraction needed by the hospital.

Speaker Recognition and Question Answering

Why it fails: Speaker Recognition is a biometric service that identifies or verifies who is speaking based on voice characteristics, but it does not transcribe the content of the speech. Question Answering, such as QnA Maker, retrieves answers from a curated knowledge base by matching natural language queries, yet it has no capability to process raw audio or extract medical concepts from free-form text. Neither service addresses the requirement of turning spoken doctor notes into structured, medically relevant data.

Text Analytics

Why it fails: Text Analytics (now part of Azure Language) is incorrect for this bot because it provides sentiment analysis, key phrase extraction, and named entity recognition, but it does not perform intent classification. While it can detect emotional tone or identify entities like dates and locations, it cannot determine what action the user wants to take—a fundamental requirement for a customer service bot. Without intent recognition, the bot cannot route or respond appropriately.

Translator Text

Why it fails: Translator Text is incorrect because its sole purpose is to convert text from one language to another, preserving meaning without interpreting the user's communicative goal. It does not classify utterances into intents, extract task-relevant entities, or support dialogue management. Even if the bot translates a user's question, it still needs a separate NLU component to understand what the user is asking for, so Translator Text alone is insufficient.

Speech-to-text

Why it fails: Speech-to-text (i.e., speech recognition) is wrong because it only transcribes spoken audio into written text; it does not analyze the meaning or infer the user's intent from that text. This service addresses the input modality, converting voice into words, but leaves the cognitive step of understanding entirely untouched. In a bot pipeline, speech-to-text would have to be paired with a service like LUIS to actually determine what the customer wants.

Sentiment Analysis

Why it fails: Sentiment analysis evaluates the overall emotional tone of a text and assigns a score from positive to negative, possibly at both sentence and document level. It can tell you whether an article is celebratory, critical, or neutral, but it provides no vocabulary about the subject matter itself. Two articles about completely different topics can both return the same sentiment score, so this service cannot be used to identify important topics from thousands of incoming articles.

Named Entity Recognition

Why it fails: Named entity recognition (NER) finds and categorizes specific mentions such as people, organizations, locations, dates, and quantities, labeling each with a category and confidence. While it enriches metadata by telling you who and what appears in an article, it does not distill the core arguments or overarching topics. For example, an article about 'Google and Facebook' could focus on antitrust, privacy policy, or stock performance, and NER would only return the company names, not the central theme.

Language Detection

Why it fails: Language detection identifies the predominant written language of a document by analyzing character sets, script patterns, and linguistic cues. Its only output is a language code (such as 'en' or 'es') and a confidence score, which helps route content or trigger localization. The service is completely blind to the underlying subject and themes, making it irrelevant when the goal is to extract the key topics discussed in each article.

Sentiment Analysis

Why it fails: Sentiment Analysis scores text on a positive-to-negative scale using pre-trained models, often to gauge employee feedback or opinion. It has no notion of fact retrieval or question intent, and it cannot return an answer from a document corpus. Using it in a bot would produce only a mood label, not a useful response to a question like 'What is our parental leave policy?'.

Key Phrase Extraction

Why it fails: Key Phrase Extraction is an Azure Text Analytics capability that identifies the most important nouns and verb phrases in a document to support summarization or content categorization. It does not maintain a knowledge base or interpret a user's question, so it cannot retrieve a specific answer from an HR document. Even if you executed it on a query, it would only output keywords, not an explanatory response.

Language Detection

Why it fails: Language Detection identifies the written language of a document by analyzing character patterns and common words, returning codes such as 'en' or 'fr'. It does not reason about content or extract answers, and it lacks any memory of the company's HR information. It might be a preprocessing step for a bot, but it cannot supply the substantive answer the self-service bot needs.

Sentiment analysis

Why it fails: Sentiment analysis assigns a polarity score (positive, negative, or neutral) to the entire text or individual sentences, but it does not isolate which specific aspects (e.g., 'battery life', 'screen quality') are being praised or criticized. The output is an aggregate emotion score, not a list of topics or product features, so it cannot reveal which aspects are frequently mentioned across thousands of reviews.

Named entity recognition

Why it fails: Named entity recognition identifies references to predefined entities such as persons, organizations, locations, dates, and quantities—for example, 'Microsoft' or 'Seattle'—but it does not extract general descriptive phrases like 'battery life' or 'price point'. It is designed for structured entity types, not open-ended product features, so it would miss the very aspects the company wants to analyze.

Language detection

Why it fails: Language detection identifies the written language of a text (e.g., English, Spanish, French) by returning a language code and confidence score, but it does not interpret the content's subject matter. Because the goal is to find recurring product aspects, not the language used in reviews, this capability would be irrelevant to the analysis.

Named Entity Recognition (NER)

Why it fails: Named Entity Recognition (NER) in Azure AI Language identifies and tags entities such as people, organizations, locations, dates, and legal citations at the token or phrase level. It returns a list of recognized entities with their types, not a single document-level category. Since every incoming legal document must be assigned one predefined category (for example, contract, brief, or subpoena), NER cannot classify the document as a whole.

Key phrase extraction

Why it fails: Key phrase extraction is an unsupervised Azure AI Language API that scans a document to return a ranked list of salient phrases, such as 'breach of fiduciary duty' or 'statute of limitations', without any predefined categories. It never assigns a single label to the document; it only surfaces extracted text spans that may be repeated across many different document types. For a law firm needing deterministic classification, this would yield a set of relevant keywords but not the required category.

Conversational Language Understanding (CLU)

Why it fails: Conversational Language Understanding (CLU) is built to interpret short, user-facing utterances in a dialogue by mapping them to intents and extracting entities, like reserving a meeting or checking a status. It is not designed to process full-length legal documents or to produce a document-level classification. Running CLU on legal papers would require treating each document as a conversational query, which is conceptually wrong and would fail to deliver the required single-label category.

Sentiment Analysis

Why it fails: Sentiment analysis evaluates text for positive, negative, or neutral tone, producing a sentiment score and labels. It does not extract or identify specific entities like legal citations; its output contains no entity spans or structured data. Therefore, it is completely unsuitable for extracting structured legal references from documents.

Key Phrase Extraction

Why it fails: Key Phrase Extraction in Azure AI Language returns a list of important phrases based on statistical salience, but it cannot be trained to recognize domain-specific entities like legal citations (e.g., 'Smith v. Jones, 123 F.3d 456'). It operates without custom training data, so it would extract generic keywords rather than the structured legal references the company needs.

Conversational Language Understanding

Why it fails: CLU is optimized for building task-oriented conversational apps that process user utterances into intents and entities. It is not designed for document-level entity extraction, and applying it to static legal documents would require treating each document as an utterance, which is inefficient and fails to handle lengthy, multi-entity texts effectively.

Key Phrase Extraction

Why it fails: Key phrase extraction returns the most relevant phrases in a document (e.g., 'battery life', 'screen quality'), ranked by importance, but it assigns no sentiment and makes no connection between a phrase and the opinion expressed about it. While it might surface the text that mentions an aspect, it cannot tell the user whether the opinion is positive, negative, or neutral. For the requirement to analyze sentiment per aspect, key phrase extraction is only a precursor to, not a replacement for, aspect-based sentiment analysis.

Sentiment Analysis

Why it fails: Standard sentiment analysis in Azure AI Language returns an overall sentiment label (positive, negative, mixed, or neutral) and confidence scores for the document and each sentence, but it never maps those sentiments to specific topics. For example, a review might state 'battery life is bad but the camera is great' — document-level or sentence-level sentiment would produce a mixed or neutral result, losing the per-aspect breakdown. Because it does not generate aspect–sentiment pairs, it cannot satisfy the requirement to know which sentiment applies to which aspect.

Named Entity Recognition (NER)

Why it fails: Named Entity Recognition (NER) detects predefined entity categories such as person, organization, location, date, and quantity, using a trained model. Product features like 'battery life' or 'design' are typically not standard entity types in the built-in Azure AI NER model, so it would fail to extract them as aspects. Even if it found a phrase, NER provides only the entity label and not the sentiment or polarity associated with it.

Sentiment Analysis

Why it fails: Sentiment Analysis is wrong because it assigns a sentiment score and label (positive, negative, neutral, or mixed) to each sentence or document, based on how emotional or opinionated the language is. It does not summarize what the text is about; a negative score might flag an angry customer but not whether the complaint concerns latency, a dead battery, or a refund delay. The support team would still need a separate step to extract the actual words and phrases describing the technical problem, which is exactly what Key Phrase Extraction does.

Named Entity Recognition (NER)

Why it fails: Named Entity Recognition (NER) is not suitable because NER is trained to identify and classify rigid, predefined semantic categories — persons, organizations, locations, dates, quantities, and other proper-noun-like entities. Customer issues are typically expressed as descriptive multi-word phrases (e.g., 'account locked after password change') that do not fit these fixed entity types. NER would return 'Jasmine' as a person and 'billing' as a skill, but it would fail to group 'payment not going through' into a meaningful problem statement, whereas Key Phrase Extraction is designed to return exactly that.

Language Detection

Why it fails: Language Detection is incorrect because it only identifies the dominant natural language of each transcript (e.g., 'English' or 'Spanish') using character- and word-level patterns. It performs a simple classification over a handful of language codes and gives no information about the content, topics, or problems customers discuss. While language metadata might help route transcripts to the right local-language model, it cannot reveal 'internet is slow' or 'payment failed' as actionable issues.