CCNA Aio Implementing Ai Questions

Cosine similarity measures the angle between query and chunk embeddings, ignoring magnitude, which suits text embeddings where direction encodes semantic meaning. It is the default metric in most vector stores such as Azure AI Search.

Hierarchical chunking splits first on section headings, preserving the document's logical structure, then subdivides oversized sections with overlap. This keeps chunks semantically coherent and respects structure, which fixed-size or naive splitting would fragment across headings.

SMOTE generates synthetic minority-class samples by interpolating between existing minority neighbours, rebalancing the 95:5 split without discarding majority data. This gives the classifier more minority examples to learn from, unlike random undersampling which loses information.

ReAct interleaves reasoning with tool invocation, while function calling supplies the schema that constrains generated API parameters. Together they let the agent select the correct booking tool from its descriptions and emit valid arguments, satisfying the stem's decision and parameter-generation requirements.

Cleaning and correcting OCR output directly addresses the scanned-invoice constraint: OCR introduces character errors on low-quality scans, and those errors propagate into extraction models. Normalising recognised text before training or inference raises accuracy, since the system's inputs are images rather than typed digital text.

Collaborative filtering exploits the interaction matrix between users and items, learning latent factors from purchase and browsing history to predict unseen preferences. This directly matches the scenario's reliance on behavioural signals rather than item content, making matrix factorisation the best-suited approach for personalised product suggestions.

Planning capability decomposes a multi-step query into ordered sub-tasks, letting the agent decide which external tool to invoke and in what sequence. Without step-by-step decomposition, the agent cannot coordinate the weather API and database calls needed to reason over combined results before answering.

QLoRA quantises the frozen base weights to 4-bit NF4 and trains only small LoRA adapters, cutting memory enough to fine-tune a 70B model on a single 24 GB GPU. Plain LoRA or full fine-tuning cannot fit within that VRAM budget.

QLoRA quantises the frozen base weights to 4-bit NF4 while training LoRA adapters in higher precision, cutting GPU memory far below standard LoRA. This satisfies the limited-memory constraint, and because only adapters are trained, fine-tuning quality stays comparable.

Computing the mean and standard deviation across the whole dataset lets statistics from the test set influence the scaling applied to training features. Test information therefore leaks into training, producing optimistic evaluation results that will not generalise to unseen data.

Grouping all images from one patient into a single partition prevents the same patient's anatomy appearing in both training and test sets. Patient ID is the grouping key that satisfies the stem's no-overlap constraint, since random image-level splitting would leak patient-specific features.

SMOTE interpolates new minority-class points between existing minority neighbours, directly correcting the 95/5 skew. Unlike random oversampling, it does not merely duplicate rows, reducing overfitting risk. This addresses the stated class imbalance before training the classifier.

With unit-length embeddings, cosine similarity and dot product give identical rankings, but cosine similarity directly measures the angle between vectors, remaining invariant to magnitude. It satisfies the stem's normalisation constraint and is the standard metric for dense retrieval in vector stores.

Chronological splitting trains on earlier records and tests on later ones, mirroring real deployment where future data is unseen. This prevents temporal leakage, satisfying the constraint that test data must not influence or overlap with training information.

Few-shot examples demonstrate the exact JSON structure, key names and nesting the model must reproduce, anchoring its output distribution to valid syntax. This satisfies the downstream parsing constraint by showing rather than merely describing the required format.

The edgeHub module implements store-and-forward so that telemetry and inference results are buffered locally and delivered when connectivity returns. This preserves detection events generated during outages and prevents data loss, which is essential for a warehouse that must reconcile package damage records after a network gap. Together with local module execution, it satisfies the offline requirement.

Logging input feature values and predictions with timestamps creates the raw material for drift detection. Without captured production inputs, there is no way to compare current data against the training distribution. Timestamps allow the team to detect gradual or sudden shifts and to correlate them with external events. This is a foundational practice for any production drift monitoring implementation and is required before statistical drift tests can be applied.

Drift diagnosis begins with measuring how production data and outputs have shifted relative to the reference distribution. Comparing feature and label distributions reveals whether the change is in the inputs, the decision threshold behavior, or both. This evidence directs the next step, such as retraining or threshold recalibration, instead of guessing.

Queue-depth-based autoscaling lets worker instances expand only during the 1,000-request spikes and contract back to baseline for the 100-request average, so you pay for capacity actually consumed. RabbitMQ decouples ingestion from classification, absorbing bursts without dropping uploads — satisfying both the throughput ceiling and the cost-efficiency constraint.

Holding back a test set before any preprocessing prevents data leakage, since fitting scalers or imputers on the full dataset lets test statistics influence training. This gives an honest estimate of generalisation, directly satisfying the stem's requirement to prevent overfitting on the churn model.

Data preparation covers dataset splitting into training, validation and test subsets, and enforces leakage prevention by fitting transformations only on training data before applying them elsewhere. This satisfies the stem's requirement that the split occur without leakage, which later modelling phases cannot retroactively correct.

Streaming responses push tokens or detection results incrementally as they are produced, rather than buffering a complete payload. This satisfies the real-time constraint: the video pipeline receives bounding-box output with minimal latency, keeping inference aligned with the live stream.

Time-based splitting assigns earlier records to training and later records to testing, respecting chronological order. For temporal data this prevents future information leaking backwards into training, which random splitting would allow, thereby avoiding inflated evaluation results.

Isolation Forest works on numerical features; sliding windows capture temporal patterns.

QLoRA quantises the frozen base model to 4-bit and trains low-rank adapters, cutting GPU memory substantially while preserving fine-tuning quality. This directly satisfies the stem's limited-memory constraint, unlike standard LoRA, which still loads full-precision base weights.

Quantization stores weights in lower-precision formats such as INT8 instead of FP32, cutting memory footprint roughly fourfold with minimal accuracy loss. This directly satisfies the stem's constraint of limited GPU memory on the edge device, letting the pre-trained classifier fit and run without retraining or architectural changes.

SMOTE generates synthetic fraud examples by interpolating between existing minority-class neighbours, directly addressing the 2% class imbalance that would otherwise bias the classifier toward the majority class. Critically, it must be applied only to the training set, never the test set, to avoid leaking synthetic data into evaluation.

LoRA freezes the pretrained weights and injects trainable low-rank decomposition matrices into each transformer layer, updating only a tiny fraction of parameters. This satisfies the PEFT constraint of drastically reducing trainable parameters and memory during fine-tuning, unlike full fine-tuning which updates every weight.

Data preparation is the lifecycle stage where raw data is cleaned, transformed, and partitioned into training, validation, and test sets, satisfying the requirement to separate data before model training begins. This splitting prevents data leakage and enables unbiased evaluation, making it the stage that directly addresses the question's constraint.

Function calling lets the LLM emit structured JSON arguments naming which API to invoke and with what parameters, so the agent itself decides when a call is needed rather than following hard-coded logic. This directly satisfies the stem's autonomy requirement, since tool selection happens at inference time based on the user's request.

A managed service provides the modeling expertise, infrastructure, and deployment path without requiring the agency to hire a data science team, and it can be operational quickly using the data already collected. The agency retains ownership of the operational integration while the vendor handles training and hosting. This matches the speed and headcount constraints precisely.

Class weights scale the loss contribution of each class inversely to its frequency, so the 1% fraudulent examples penalise errors far more heavily. This shifts the decision boundary toward the minority class without altering the underlying 99:1 data distribution.

A multilingual LLM can perform cross-lingual tasks like translation and summarization without separate components. It handles the Spanish input and generates an English summary directly, reducing pipeline complexity and latency. This is efficient because the model's training includes multiple languages, enabling it to understand the source and produce the target output in a single inference pass.

Red-teaming deliberately probes a system with adversarial inputs to expose harmful or unsafe outputs. It targets exactly the edge cases described, where crafted prompts bypass safeguards, making it the testing type that surfaces these vulnerabilities before deployment.

QLoRA quantises the frozen base weights to 4-bit and trains small low-rank adapters, slashing GPU memory far below full fine-tuning. With only 500 labelled examples and constrained VRAM, this parameter-efficient method fits the domain task without exhausting memory.

Document intelligence combines optical character recognition with field extraction models, converting scanned invoice images into structured key-value output such as invoice number, date and total amount. This matches the stem's requirement to extract text from scans and return named structured fields.

Raising the reconstruction-error threshold makes the model flag only stronger deviations, so borderline normal sensor readings no longer trigger alerts. This directly reduces the false positives caused by an overly sensitive threshold, satisfying the stem's requirement to cut false alarms during monitoring.

A custom intent classifier can be trained to recognize financial-advice requests and trigger a handoff to a human agent, satisfying the routing requirement. Writing every conversation turn to Azure Monitor Logs with a defined retention policy creates the durable, queryable audit trail compliance needs. Together these two mechanisms directly address both stated requirements in a way that is verifiable during an audit.

Collaborative filtering learns latent user and item factors directly from historical user-item interaction data, such as ratings or purchases, to predict unseen preferences. This matches the stem's available data exactly, unlike content-based approaches that would require item metadata.

Few-shot prompting places several complete, valid JSON examples in the prompt, so the model infers the required schema, key names and formatting by pattern matching. This constrains generation toward syntactically valid JSON, satisfying the always-valid-JSON requirement more reliably than zero-shot instructions alone.

QLoRA quantises the frozen base weights to 4-bit NormalFloat, then backpropagates through low-rank adapters, so gradients and optimiser states stay tiny. This slashes VRAM enough to fine-tune large models on consumer-grade GPUs, directly satisfying the stem's memory-reduction constraint.

Function calling lets the model emit structured JSON specifying which API to invoke and with which arguments, based on the user's natural-language request. The runtime executes that call and returns results, enabling reliable external API invocation without parsing free-form text.

LoRA rank controls the dimensionality of the low-rank update matrices, so r=1 gives the adapter minimal capacity to capture task-specific patterns. The adapter therefore learns too little, leaving outputs close to the frozen base model.

Hierarchical chunking preserves the document's section and subsection boundaries, embedding each node with its parent context intact. This directly satisfies the stem's requirement for natural hierarchical structure, unlike fixed-size or semantic splitting, which sever headings from their content and degrade retrieval precision during Microsoft Entra ID-secured RAG queries.

Retrieval is the point where sensitive documents enter the prompt, so enforcing the same permissions as the source repository prevents personal data, unreleased names, and pricing from ever reaching the model. Metadata filtering also restricts retrieval to approved campaign assets. This is the primary control because it blocks leakage at the source rather than trying to scrub output afterward.

Few-shot examples demonstrate the exact field names, nesting and formatting expected, steering the model toward the target schema. This pattern-matching improves consistency across calls, though it does not guarantee syntactic validity the way constrained decoding does.

A human-in-the-loop gate places a licensed professional between AI output and the clinical record, which is the expected oversight pattern for high-stakes healthcare decisions. It preserves clinician accountability, creates a clear audit trail of who approved each summary, and allows the organization to detect systematic model errors during review. This matches regulatory expectations for AI used in patient care.

For unit-length vectors, the dot product equals cosine similarity because the magnitude denominators are both one, eliminating the normalisation division. It satisfies the efficiency constraint by replacing cosine's two norms and division with a single sum of element-wise products, giving identical rankings at lower computational cost.

Faithfulness metrics measure whether each claim in the generated answer is grounded in the retrieved context, while answer relevancy scores how well it addresses the question. Running both over a held-out test set systematically quantifies hallucinated policy statements.

Microservices with streaming responses and async queues decouple request handling from model inference, letting tokens stream to users immediately while queued work absorbs bursts. This satisfies the stem's simultaneous cost and latency constraints for a real-time customer-facing workload.

LoRA freezes the 7B base weights and trains only small low-rank adapter matrices, cutting trainable parameters and optimiser memory dramatically. This directly satisfies the limited GPU budget while remaining effective with only 500 labelled legal examples.

Microservices decouple ingestion from inference via an async queue, absorbing thousands of readings per second without blocking, while streaming responses return anomaly results with minimal latency. This satisfies the throughput and latency constraints that synchronous request-response architectures cannot.

Frequent weekly updates suit RAG because retrieval pulls current documents at query time, so the assistant reflects new content without retraining. Fine-tuning bakes knowledge into model weights, requiring repeated, costly retraining to stay current — directly satisfying the stem's freshness constraint.

Feature selection removes redundant, highly correlated predictors, directly cutting the 100-feature dimensionality that drives overfitting. By retaining only informative variables, the regression model generalises better, satisfying the stem's requirement to improve performance while reducing overfitting from multicollinearity.

Hierarchical chunking splits on section and subsection boundaries, preserving parent-child relationships so retrieved chunks retain context. Fixed-size or semantic chunking would fragment subsections and lose the legal document's structure, which the stem explicitly requires be preserved.

SageMaker Clarify supports SHAP-based explanations and can be configured as an online explainer endpoint that returns per-request feature attributions alongside the prediction. This gives loan officers and regulators a ranked contribution of each feature for the individual decision without retraining or replacing the gradient boosting model, directly meeting the explainability requirement while leaving the production model untouched.

SHAP values come from cooperative game theory and assign each feature a signed contribution to the model's output for that specific instance, so a denial can be explained as a sum of feature-level reasons drawn from the applicant's own data. This is model-agnostic, works for tree ensembles, and directly produces the individualized, feature-value-based justification regulators are requesting.

Raising the anomaly threshold makes the detector flag only higher-scoring cases, so fewer legitimate transactions cross into the positive class. This directly lowers false positives, though some true anomalies may be missed. The stem prioritises reducing false positives without a large false-negative rise.

Cleaning imputes or removes missing values so the classifier receives complete records, while normalisation rescales features onto a comparable range, preventing large-magnitude features from dominating distance or gradient calculations. Both address the dataset's stated defects.

A managed AI platform endpoint matches every constraint: the provider handles scaling, patching, and availability, the team avoids Kubernetes operations, and billing is consumption-based. This is the fastest path to production for a small team without infrastructure expertise. It also provides built-in monitoring and integration with the provider's SDKs, reducing the amount of custom operational code the team must write and maintain.

ReAct interleaves reasoning traces with tool calls, letting the agent decompose the request, invoke flight, hotel and car APIs, then reason over each result before the next step. This satisfies the multi-step, external-API constraint that a single prompt or plain chain cannot handle.

Classical methods handle seasonality and trend well, can incorporate promotional regressors, and produce per-series forecasts that are easy to explain and monitor. They are fast to implement, require modest compute, and are robust for intermittent demand when configured appropriately. This makes them a strong initial production baseline before considering more complex models.

Recall for the churn class directly exposes the model's failure to identify actual churners, which accuracy conceals under the 90/10 imbalance. Optimising recall ensures genuine churn cases are captured, satisfying the stem's requirement to evaluate effectiveness on the minority class rather than overall correctness.

ReAct interleaves reasoning traces with tool-calling actions, letting the agent decide each next step based on observed results. This supports sequencing dependent tasks such as flight, hotel, and car rental bookings, where later steps rely on earlier outcomes.

The model was validated on one data distribution and now receives images from different hardware, which strongly suggests covariate shift: the input features moved while the learned relationship stayed fixed. Measuring distribution differences such as intensity histograms, resolution, and noise characteristics identifies whether inputs are out of the training envelope, which is the root cause to establish before choosing any remediation.

Object detection satisfies the requirement to tag multiple objects within one image, returning bounding boxes and labels per instance. Unlike image classification, which assigns a single label to the whole image, detection handles the stem's example of 'car', 'tree' and 'person' coexisting, so each object is identified separately.

A cloud-based AI microservice with a pre-built model removes the need to train, host or scale models, directly satisfying the limited in-house expertise and minimal infrastructure management constraints. Integration is largely API configuration, enabling rapid deployment within the mobile app.

Pre-trained transformer embeddings encode contextual semantics into fixed dense vectors, so semantically similar passages land close together in vector space. This supports accurate similarity search and retrieval in a RAG pipeline, unlike sparse lexical vectors that capture term overlap rather than meaning.

Indexing at clause and sub-clause levels with parent links preserves the legal hierarchy, so retrieval can return a precise sub-clause while still supplying its enclosing clause as context. This directly addresses the stem's hierarchical sections constraint.

Fine-tuning a pre-trained text classification model leverages the 10,000 labelled tickets to adapt existing language representations to the organisation's specific categories, satisfying the stem's supervised categorisation requirement. This outperforms training from scratch on a small dataset and avoids the cost and latency of prompt-based large-model inference.

Data preparation covers cleaning, labelling and splitting the dataset into training, validation and test partitions before modelling begins. These subsets support fitting, hyperparameter tuning and unbiased final evaluation respectively, so the split belongs to this phase rather than data collection or deployment.

With 95% of invoices from one vendor, the model optimises for the majority class, so minority-vendor patterns are underweighted during training. High overall F1 masks this, since majority-class performance dominates the metric. The poor minority-vendor results stem directly from this class imbalance, not from overfitting or feature scaling.

An input guardrail inspects the user prompt for known injection and extraction patterns, such as 'repeat everything above,' and blocks or sanitizes the request before it reaches the model. This directly addresses the attack vector shown in red-team testing while keeping the system prompt private, and it can be tuned and logged without retraining the underlying model.

A 29-point gap between training and test accuracy is the classic signature of overfitting: the model has memorised training noise rather than learning generalisable patterns. The constraint in the stem is the large train-test performance divergence, which variance-reduction techniques such as regularisation or more data would address.

Running inference inside the firm's network prevents sensitive financial figures from leaving the organization, directly satisfying the data-residency requirement. It also gives the firm control over model versions and logging infrastructure, which supports auditability. External API calls would transmit the same sensitive content to a third party.