Unit 6 - Practice Quiz

Tableau is a leading data visualization tool used to create charts, graphs, and dashboards to help users understand and interpret data.

Structured data is highly organized and formatted in a way that is easily searchable, like data in a relational database (e.g., SQL) with clear rows and columns.

Unstructured data, such as video, audio, and text documents, does not have a predefined data model or organization, making it more difficult to process and analyze.

A data pipeline is a series of processes that ingests data from various sources and moves it to a destination (like a data warehouse) for analysis. It often includes steps for cleaning and transforming the data along the way.

Cloud services provide scalability and access to expensive hardware (like GPUs and TPUs) on a pay-as-you-go basis, which is often more cost-effective than purchasing and maintaining the hardware yourself.

Edge deployment involves placing the AI model on the device where the data is generated (the 'edge' of the network), which reduces latency and reliance on a constant internet connection.

MLOps (Machine Learning Operations) aims to streamline the lifecycle of machine learning models, from development to deployment and monitoring, by applying DevOps principles to the machine learning process.

Overfitting occurs when a model learns the training data, including its noise and random fluctuations, so well that it fails to generalize to new, unseen data.

AI process automation focuses on using AI and machine learning to handle routine, rule-based, and high-volume tasks, freeing up human workers to focus on more complex, strategic activities.

Before you can fix a problem, you must first clearly identify what is going wrong. This involves looking at error messages, model performance metrics, and logs.

These tools are designed to be user-friendly. The user uploads a data file (like a CSV) and types a request in plain English, such as "Create a bar chart of sales by region."

Automating a data pipeline ensures that data processing steps run consistently and on a schedule without a person needing to manually trigger each step, which reduces the chance of errors.

Edge deployment is ideal for applications that require low latency (fast response times) and may need to function without a stable internet connection, such as real-time processing on a mobile device.

Deployment is the phase where the model is integrated into a production system, such as a web application or mobile app, so it can be used by end-users.

Cloud computing is the on-demand availability of computer system resources, especially data storage and computing power, without direct active management by the user.

A syntax error is like a grammatical mistake in a language. The code cannot be correctly interpreted or compiled because it doesn't follow the language's structural rules.

Debugging is a systematic process of identifying, analyzing, and removing errors (bugs) from computer software or hardware to make it behave as expected.

The defining feature of structured data is its organization. It conforms to a tabular format with clear relationships between rows and columns or data points, defined by a schema.

Models can degrade over time due to changes in the real-world data (a concept called 'model drift'). MLOps emphasizes continuous monitoring to detect and correct such issues.

This task uses Natural Language Processing (an AI technique) to automate the routine process of sorting emails, which would otherwise be done manually by a person.

For rapid, prompt-based exploration without coding, ChatGPT's Advanced Data Analysis is ideal. It can interpret requests like "find the correlation between sales and advertising spend" and generate the code and output automatically. While Tableau is a powerful visualization tool, it requires more manual setup. Python and SQL are powerful but require explicit coding, which contradicts the user's requirement.

Structured data has a predefined format (e.g., name, priority level, date). Unstructured data does not have a clear, predefined model (e.g., the free-text problem description). This scenario clearly contains both types.

The Data Validation stage acts as a quality gate. It ensures that the new data conforms to the expected schema (e.g., correct data types, number of columns) and statistical properties, preventing corrupted or unexpected data from breaking the pipeline or degrading model performance.

For applications requiring real-time response and high reliability, such as surgical assistance, edge deployment is critical. Processing the data directly on or near the device avoids the network latency and potential connectivity issues associated with sending data to a remote cloud server.

Overfitting occurs when a model learns the training data too well, including its noise and specific patterns, but fails to generalize to new, unseen data. The high accuracy on training data and low accuracy on test data is the primary indicator of this problem.

A feature store solves problems of feature duplication and inconsistency. It's a central place where data scientists can define, store, and share features, ensuring that the same feature engineering logic is used for both model training and real-time inference, which helps prevent train-serve skew.

This task involves understanding and categorizing text, which is a core function of Natural Language Processing (NLP). A text classification model can be trained to automatically assign the correct category to each email based on its content, streamlining the support workflow.

Machine learning models operate on numbers, not raw text. Vectorization techniques (like TF-IDF or word embeddings) transform words, sentences, or documents into numerical vectors, allowing the model to perform mathematical operations and learn patterns from the text data.

The key advantage of the cloud for large-scale training is elasticity. The company can access a massive amount of computational power when needed for the heavy training job and then release those resources, paying only for what they use. Maintaining such hardware on-premise would be extremely expensive and inefficient.

Tableau specializes in creating interactive, shareable, and embeddable dashboards with features like live data connections and user-driven filters. While ChatGPT can create plots, it's not designed for building persistent, interactive dashboards. Jupyter notebooks are for analysis, not public-facing applications, and Excel has limitations in interactivity and live data handling.

Once a model is in production, it's crucial to monitor its performance on live data. Model monitoring tracks key metrics and data distributions to alert the team when the model's performance drops (degradation) or when the input data characteristics change (data drift), indicating that retraining may be necessary.

High bias is synonymous with underfitting. The model is too simple to capture the underlying patterns in the data. As a result, it performs poorly not just on new data, but also on the data it was trained on, indicating it has failed to learn the relationships effectively.

Idempotency is a critical property for data pipeline reliability. It means that if a pipeline task fails and is retried, or is run accidentally multiple times, it won't duplicate data, create incorrect entries, or corrupt the final state. The end result is the same as if it had run successfully just once.

Traditional RPA excels at automating repetitive, rule-based tasks that involve structured data and deterministic steps. Copying and pasting between well-defined locations is a perfect example. The other options require cognitive capabilities like understanding handwriting, analyzing sentiment, or predictive modeling, which fall into the domain of AI.

Canary deployment involves rolling out a new version of a model to a small subset of users/requests first. This allows the team to monitor its performance and stability in a live environment with minimal risk. If it performs well, the rollout can be gradually increased until it replaces the old version entirely.

Documents like invoices have a crucial 2D structure. The location of text (e.g., text next to the label 'Total Amount') is key to its meaning. This requires technologies like Optical Character Recognition (OCR) combined with layout analysis, making it more complex than just processing a linear sequence of text.

Most machine learning libraries and models require numerical input for regression tasks. The presence of non-numeric characters ($, ,, USD) makes the data type a string (or object). This mismatch will cause the program to fail, typically with a TypeError or ValueError, until the data is cleaned and converted to a proper numeric format (e.g., float or integer).

Reproducibility is a cornerstone of MLOps and scientific rigor. A model is a product of both code and data. If the training data changes, even with the same code, you will get a different model. Versioning the data (e.g., using tools like DVC) allows you to track which dataset was used to produce which model version, making experiments reproducible and debugging easier.

Edge devices (like smartphones, sensors, or IoT devices) have significant constraints on processing power, RAM, and battery life compared to cloud servers. This often requires model optimization, quantization, or the use of smaller, less complex models, which can sometimes trade off accuracy for efficiency.

Modern BI tools like Tableau have built-in intelligence to analyze the data within a column (not just its header) and infer its semantic type. Recognizing patterns like state names or city names allows it to automatically assign a 'Geographical Role', enabling powerful map-based visualizations without manual configuration.

This is the most proactive and robust solution. Increasing retraining frequency (B) might just retrain the bias faster. Manual review (C) is reactive, not preventative. Rolling back (D) is a temporary fix that doesn't solve the underlying problem. Stratified retraining ensures the model sees a fair distribution of data, and adding a fairness constraint directly penalizes the model for biased predictions during training, addressing the root cause systematically.

For strict latency and power constraints, INT8 quantization is necessary. Quantization-Aware Training (QAT) almost always yields the highest accuracy for quantized models because it allows the model to adapt its weights to the precision loss during the training process itself. Post-training quantization (A, B) is easier but often results in a more significant accuracy drop. Simply converting to TFLite without quantization (D) may not be sufficient to meet the strict power and latency requirements on resource-constrained devices.

Idempotency is the property of an operation that ensures running it multiple times has the same effect as running it once. In this scenario, an idempotent aggregation step would be designed to overwrite or correctly update the summary data upon a re-run, preventing duplicate records or incorrect calculations that would result from simply adding the same data again. This is crucial for data integrity in pipelines that can fail and be restarted.

Mode collapse is a common GAN failure mode where the generator learns to produce a very limited set of outputs (a few 'modes' of the data distribution) that are particularly effective at fooling the discriminator. This leads to the generator's loss becoming very low (as it's succeeding at its one trick) while the discriminator's loss stays high (as it can't distinguish the fake samples from the real ones in that specific mode). The lack of diversity in generated samples is the key symptom.

This scenario highlights a key challenge with natural language interfaces for data analysis: ambiguity. "Profit margin" can be interpreted in several ways (e.g., gross profit margin, net profit margin) or confused with a simpler metric like total profit (Sales - Cost). The AI latching onto the simpler, more common metric is a very plausible failure mode. While C is possible, it's a data issue; A is an AI interpretation issue, which is a core concept when using these tools. B and D are less likely for a standard calculation.

This is a classic problem in multimodal learning. High-dimensional vectors from one modality (text) can numerically overwhelm features from another (structured data), causing the model's gradients to be dominated by the text features. This requires careful feature scaling, dimensionality reduction (e.g., PCA, autoencoders) on the embeddings, or using model architectures (like multi-headed attention) specifically designed to handle this imbalance, making it the most significant challenge.

The core value of a feature store is solving the training-serving skew problem. Often, features are generated in a batch process for training (e.g., using a Spark job) but need to be generated in real-time with low latency for serving. Discrepancies between these two code paths can lead to a significant drop in model performance. A feature store provides a unified, consistent source for features for both contexts, directly addressing this critical MLOps challenge. While it helps with discovery (B), it is distinct from model versioning (C) and hyperparameter tuning (D).

In distributed training, the model's gradients and weights must be synchronized across all nodes/GPUs. This communication is highly sensitive to network performance. If the interconnect bandwidth is low or latency is high, the GPUs will spend more time waiting for data from other GPUs than performing computations. This communication overhead is often the primary bottleneck that prevents linear scaling and is a complex engineering problem to solve, often requiring specialized hardware (like AWS's EFA or NVIDIA's NVLink) and careful architecture choices.

The core weakness of traditional, template-based automation is its brittleness. It requires a predefined template for every single invoice layout. When a new vendor is added or an existing vendor changes their template, the system breaks. An AI-powered IDP solution uses models trained to understand the meaning of an invoice (e.g., it looks for a field labeled "Total" or a monetary value near the bottom), making it adaptable to new and unseen templates. This contextual understanding is the key advantage.

Exactly-once semantics is extremely difficult to achieve because it requires handling failure scenarios perfectly. The system must be able to distinguish between 'at-least-once' (duplicates are possible on retry) and 'at-most-once' (data loss is possible on retry). To get it exactly right, the system needs atomic commits across distributed components. This often involves techniques like two-phase commits or transactional writes, which are complex to implement correctly and robustly, especially in the face of machine or network failures. This coordination is the hardest part of the problem.

The Area Under the ROC Curve (AUC) is calculated from the True Positive Rate () and False Positive Rate (). In a highly imbalanced dataset, the number of true negatives (TN) is massive. This makes the FPR very small even if the number of false positives (FP) is significant compared to the number of true positives (TP). This can result in a high AUC score that looks impressive but hides the fact that the model is failing to identify the rare, important class. For such cases, metrics like Precision-Recall AUC (PR-AUC) are more informative.

This is the ideal way to build interactive what-if analysis in Tableau. Parameters are user-driven variables that are not tied to the data source. One parameter allows the user to pick a segment, another allows them to input a value (like 15%). The Calculated Field can then use conditional logic (e.g., IF [Segment] = [Segment Parameter] THEN [Actual Churn] * (1 - [Reduction Parameter]) ELSE [Actual Churn] END) to display the hypothetical results dynamically. This is more flexible and interactive than the other options.

The core assumption of many distributed optimization algorithms is that the data is IID. In federated learning, each user's data is unique (non-IID). If one user's data consists entirely of pictures of cats and another's is all dogs, their locally trained models will become highly specialized. When these specialized updates are averaged, they can conflict and destabilize the training of the global model, causing it to perform poorly for everyone. This is a central research problem in federated learning, addressed by algorithms like FedAvg and FedProx.

This is the most sophisticated and correct trigger for continuous training. Retraining should happen when the world the model was trained on no longer matches the world it's operating in. Concept drift (or data drift) is the direct measure of this. Triggering on a code commit (B) is CI/CD, not CT. A fixed schedule (C) can be wasteful if the data hasn't changed, or too slow if it has. Waiting for a 20% accuracy drop (D) is a lagging indicator; the model has already been performing poorly for some time. Detecting drift is a proactive trigger.

This problem requires processing a massive amount of data. A distributed framework like Spark is designed for this scale. It can partition the one million documents across a cluster of machines (workers) and process them in parallel, providing horizontal scalability. While a serverless approach (C) is good for event-driven tasks, it can become very expensive at this scale and may face execution time limits. A single server (B) will be a bottleneck and cannot scale effectively. Manual processing (D) is not feasible.

Sensors are a core feature of Airflow designed for precisely this purpose: waiting for an external condition to be met. The S3KeySensor is a built-in operator that efficiently handles this use case. It occupies a worker slot only while it's actively checking (poking) and can be configured to 'reschedule' itself, freeing up the worker for other tasks between pokes, making it very efficient. The while loop (B) is a bad practice as it would tie up an Airflow worker slot continuously. The fixed schedule (C) is brittle and not event-driven. A separate DAG (D) is overly complex and less efficient than using a built-in sensor.

The core value proposition of serverless is paying only for compute time used. For workloads with sporadic or unpredictable traffic, this is very cost-effective. However, the infrastructure is scaled down to zero when not in use. When a new request arrives, the cloud provider must provision a container, load the model, and initialize the environment. This 'cold start' process introduces latency that would not be present on a provisioned, always-on endpoint. This trade-off between cost/scalability and cold-start latency is the key consideration.

In high-stakes environments like healthcare, the cost of a false positive or (especially) a false negative is extremely high. The AI should be used as a tool to assist and augment human experts, not replace them. The 'Human-in-the-loop' pattern ensures that the AI's role is to prioritize and provide a preliminary analysis, but the final, accountable decision rests with a qualified professional. This balances the efficiency gains of AI with the need for safety and accountability.

The key concept of a canary release is risk mitigation. Unlike a classic A/B test which might split traffic 50/50, a canary release sends a very small fraction of traffic to the new version first. This allows the team to observe its performance on live traffic and metrics (latency, error rate, business KPIs). If problems arise, the impact is contained to a small user base, and the release can be easily rolled back. A/B testing (B) is more focused on comparison than on risk mitigation during the deployment phase itself.

This is a classic pitfall in time-series modeling. If a series has a strong trend or seasonality (is non-stationary), the simplest and often most effective short-term prediction is just the previous value. A model that hasn't been given stationary data (e.g., via differencing) will often learn this 'naive forecast' as its optimal strategy, as it minimizes short-term error. This manifests as a prediction that perfectly mirrors the actual data but is shifted by one time step. Data leakage (A) is a different problem that usually leads to unrealistically high performance, not lagging.