(function() {
  function t(en, de) { return { en: en, de: de }; }
  function o(id, en, de) { return { id: id, text: t(en, de) }; }
  function q(id, type, domain, difficulty, scenario, question, options, correct, explanation, hint, reference) {
    return {
      id: id,
      type: type,
      domain: domain,
      difficulty: difficulty,
      scenario: scenario,
      question: question,
      options: options,
      correct: correct,
      explanation: explanation,
      hint: hint,
      reference: reference
    };
  }

  function c(en, de, reasonEn, reasonDe, hintEn, hintDe, reference) {
    return {
      label: t(en, de),
      reason: t(reasonEn, reasonDe),
      hint: t(hintEn, hintDe),
      reference: reference
    };
  }

  var design = t('Design a machine learning solution', 'Eine Machine-Learning-Lösung entwerfen');
  var explore = t('Explore data and train models', 'Daten untersuchen und Modelle trainieren');
  var prepare = t('Prepare a model for deployment', 'Ein Modell für die Bereitstellung vorbereiten');
  var deploy = t('Deploy and retrain a model', 'Ein Modell bereitstellen und neu trainieren');

  var ref = {
    registries: 'https://learn.microsoft.com/en-us/azure/machine-learning/how-to-share-models-pipelines-across-workspaces-with-registries',
    compute: 'https://learn.microsoft.com/en-us/azure/machine-learning/concept-compute-target',
    datastores: 'https://learn.microsoft.com/en-us/azure/machine-learning/how-to-datastore',
    dataAssets: 'https://learn.microsoft.com/en-us/azure/machine-learning/how-to-create-data-assets',
    env: 'https://learn.microsoft.com/en-us/azure/machine-learning/concept-environments',
    pipelines: 'https://learn.microsoft.com/en-us/azure/machine-learning/how-to-create-component-pipelines-cli',
    mlflow: 'https://learn.microsoft.com/en-us/azure/machine-learning/concept-mlflow',
    automl: 'https://learn.microsoft.com/en-us/azure/machine-learning/concept-automated-ml',
    train: 'https://learn.microsoft.com/en-us/azure/machine-learning/how-to-train-model',
    tune: 'https://learn.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters',
    rai: 'https://learn.microsoft.com/en-us/azure/machine-learning/concept-responsible-ai-dashboard',
    models: 'https://learn.microsoft.com/en-us/azure/machine-learning/how-to-manage-models',
    online: 'https://learn.microsoft.com/en-us/azure/machine-learning/concept-endpoints-online',
    deployOnline: 'https://learn.microsoft.com/en-us/azure/machine-learning/how-to-deploy-managed-online-endpoints',
    batch: 'https://learn.microsoft.com/en-us/azure/machine-learning/concept-endpoints-batch',
    batchOutput: 'https://learn.microsoft.com/en-us/azure/machine-learning/how-to-deploy-model-custom-output',
    schedule: 'https://learn.microsoft.com/en-us/azure/machine-learning/how-to-schedule-pipeline-job',
    monitor: 'https://learn.microsoft.com/en-us/azure/machine-learning/how-to-monitor-online-endpoints'
  };

  var concepts = {
    registry: c('Azure Machine Learning registry', 'Azure Machine Learning-Registry', 'a registry shares versioned models, components, and environments across workspaces while preserving governed promotion flows', 'eine Registry versionierte Modelle, Komponenten und Umgebungen arbeitsbereichsübergreifend bereitstellt und dabei geregelte Promotion-Abläufe unterstützt', 'Focus on governed cross-workspace sharing.', 'Achten Sie auf die geregelte, arbeitsbereichsübergreifende Freigabe.', ref.registries),
    computeInstance: c('Compute instance', 'Compute-Instanz', 'a compute instance is a managed personal workstation for notebooks, terminals, and interactive development', 'eine Compute-Instanz eine verwaltete persönliche Arbeitsstation für Notebooks, Terminals und interaktive Entwicklung ist', 'Look for personal interactive development.', 'Achten Sie auf persönliche interaktive Entwicklung.', ref.compute),
    datastore: c('Datastore', 'Datastore', 'a datastore stores a named connection to storage so jobs and assets can reuse it consistently', 'ein Datastore eine benannte Verbindung zu Speicherressourcen verwaltet, damit Jobs und Bestände sie konsistent wiederverwenden können', 'Look for a reusable storage connection by name.', 'Achten Sie auf eine wiederverwendbare Speicherverbindung per Namen.', ref.datastores),
    dataAssetVersion: c('Versioned data asset', 'Versionierter Datenbestand', 'a versioned data asset gives training jobs an immutable reference to the exact input snapshot they should use', 'ein versionierter Datenbestand Trainingsjobs einen unveränderlichen Verweis auf den exakt zu verwendenden Eingabestand gibt', 'Focus on immutability and reproducibility.', 'Achten Sie auf Unveränderlichkeit und Reproduzierbarkeit.', ref.dataAssets),
    environment: c('Environment', 'Umgebung', 'an environment versions Python packages, base images, and dependency settings for repeatable training and inference', 'eine Umgebung Python-Pakete, Basisimages und Abhängigkeitseinstellungen für wiederholbares Training und Inferenz versioniert', 'Look for dependencies and package consistency.', 'Achten Sie auf Abhängigkeiten und konsistente Paketstände.', ref.env),
    component: c('Component', 'Komponente', 'a component packages reusable pipeline logic behind declared inputs and outputs', 'eine Komponente wiederverwendbare Pipeline-Logik hinter deklarierten Ein- und Ausgaben kapselt', 'Look for a reusable typed pipeline step.', 'Achten Sie auf einen wiederverwendbaren typisierten Pipelineschritt.', ref.pipelines),
    computeCluster: c('Compute cluster', 'Computecluster', 'a compute cluster provides shared autoscaling compute for submitted training jobs', 'ein Computecluster gemeinsam genutzte, automatisch skalierende Rechenleistung für eingereichte Trainingsjobs bereitstellt', 'Look for queued jobs and elastic scale.', 'Achten Sie auf Warteschlangenjobs und elastische Skalierung.', ref.compute),
    mlflow: c('MLflow tracking', 'MLflow-Tracking', 'MLflow tracking centralizes parameters, metrics, and artifacts from local and remote experiments in one tracking system', 'MLflow-Tracking Parameter, Metriken und Artefakte aus lokalen und entfernten Experimenten in einem gemeinsamen Tracking-System zentralisiert', 'Look for experiment tracking across environments.', 'Achten Sie auf Experiment-Tracking über mehrere Umgebungen hinweg.', ref.mlflow),
    managedIdentity: c('Managed identity', 'Verwaltete Identität', 'a managed identity lets jobs and workspaces authenticate to Azure resources without embedding secrets in code', 'eine verwaltete Identität Jobs und Arbeitsbereichen die Authentifizierung bei Azure-Ressourcen ohne eingebettete Geheimnisse im Code ermöglicht', 'Look for secretless authentication.', 'Achten Sie auf geheimnislose Authentifizierung.', ref.datastores),
    automatedML: c('Automated ML', 'Automated ML', 'Automated ML tries algorithms, preprocessing, and model settings with minimal custom code', 'Automated ML Algorithmen, Vorverarbeitung und Modelleinstellungen mit minimalem benutzerdefiniertem Code ausprobiert', 'Look for broad model search with little code.', 'Achten Sie auf eine breite Modellsuche mit wenig Code.', ref.automl),
    mltable: c('MLTable data asset', 'MLTable-Datenbestand', 'an MLTable data asset describes tabular files, schema, and partitions so jobs read them consistently', 'ein MLTable-Datenbestand tabellarische Dateien, Schema und Partitionen beschreibt, damit Jobs sie konsistent lesen', 'Look for schema over partitioned tabular files.', 'Achten Sie auf ein Schema über partitionierte tabellarische Dateien.', ref.dataAssets),
    commandJob: c('Command job', 'Befehlsjob', 'a command job runs your script or shell command remotely on Azure Machine Learning compute', 'ein Befehlsjob Ihr Skript oder Ihren Shell-Befehl remote auf Azure-Machine-Learning-Compute ausführt', 'Look for remote script execution on selected compute.', 'Achten Sie auf die Remote-Ausführung eines Skripts auf ausgewähltem Compute.', ref.train),
    sweepJob: c('Sweep job', 'Sweep-Job', 'a sweep job searches a hyperparameter space across many trials and optimizes a chosen objective metric', 'ein Sweep-Job einen Hyperparameterraum über viele Versuche durchsucht und eine ausgewählte Zielmetrik optimiert', 'Look for automated hyperparameter search.', 'Achten Sie auf automatisierte Hyperparametersuche.', ref.tune),
    banditPolicy: c('Bandit early termination policy', 'Bandit-Richtlinie für frühes Beenden', 'a bandit policy stops weak hyperparameter trials early so the budget is spent on better candidates', 'eine Bandit-Richtlinie schwache Hyperparameter-Versuche früh beendet, damit das Budget für bessere Kandidaten verwendet wird', 'Look for early stopping of poor trials.', 'Achten Sie auf das frühe Stoppen schwacher Versuche.', ref.tune),
    crossValidation: c('K-fold cross-validation', 'K-fache Kreuzvalidierung', 'K-fold cross-validation gives a more stable estimate of model quality when labeled data is limited', 'die K-fache Kreuzvalidierung eine stabilere Schätzung der Modellgüte liefert, wenn nur begrenzte gelabelte Daten vorhanden sind', 'Look for repeated validation folds on limited data.', 'Achten Sie auf wiederholte Validierungsfaltungen bei wenig Daten.', ref.train),
    stratifiedSplit: c('Stratified split', 'Stratifizierter Split', 'a stratified split preserves class proportions across train and validation datasets', 'ein stratifizierter Split die Klassenverteilung über Trainings- und Validierungsdatensätze hinweg erhält', 'Look for preserved class ratios.', 'Achten Sie auf erhaltene Klassenverhältnisse.', ref.train),
    auprc: c('Area under the precision-recall curve', 'Fläche unter der Precision-Recall-Kurve', 'area under the precision-recall curve is often the most informative ranking metric when positive cases are rare', 'die Fläche unter der Precision-Recall-Kurve oft die aussagekräftigste Ranking-Metrik ist, wenn positive Fälle selten sind', 'Look for severe class imbalance with rare positives.', 'Achten Sie auf starke Klassenungleichgewichte mit seltenen positiven Fällen.', ref.automl),
    f1Score: c('F1 score', 'F1-Wert', 'the F1 score balances precision and recall in a single threshold-based measure', 'der F1-Wert Präzision und Recall in einem einzelnen schwellenwertbasierten Maß ausbalanciert', 'Look for one number that balances precision and recall.', 'Achten Sie auf eine Kennzahl, die Präzision und Recall ausbalanciert.', ref.automl),
    rmse: c('Root mean squared error', 'Wurzel des mittleren quadratischen Fehlers', 'RMSE squares residuals, so large regression errors are penalized more heavily', 'RMSE Residuen quadriert und dadurch große Regressionsfehler stärker bestraft', 'Look for a stronger penalty on large errors.', 'Achten Sie auf eine stärkere Bestrafung großer Fehler.', ref.train),
    mae: c('Mean absolute error', 'Mittlerer absoluter Fehler', 'MAE stays in original units and is less sensitive to a few extreme errors than RMSE', 'MAE in den Originaleinheiten bleibt und weniger empfindlich auf einige extreme Fehler reagiert als RMSE', 'Look for easier interpretation and less sensitivity to outliers.', 'Achten Sie auf leichtere Interpretierbarkeit und geringere Ausreißerempfindlichkeit.', ref.train),
    mlflowAutolog: c('MLflow autologging', 'MLflow-Autologging', 'MLflow autologging captures common parameters, metrics, and model artifacts automatically from supported libraries', 'MLflow-Autologging gängige Parameter, Metriken und Modellartefakte aus unterstützten Bibliotheken automatisch erfasst', 'Look for automatic capture with minimal code changes.', 'Achten Sie auf automatische Erfassung mit minimalen Codeänderungen.', ref.mlflow),
    featureImportance: c('Feature importance', 'Merkmalswichtigkeit', 'feature importance shows which input variables contribute most to predictions', 'die Merkmalswichtigkeit zeigt, welche Eingangsvariablen am stärksten zu Vorhersagen beitragen', 'Look for drivers behind predictions.', 'Achten Sie auf die Einflussfaktoren hinter Vorhersagen.', ref.rai),
    confusionMatrix: c('Confusion matrix', 'Konfusionsmatrix', 'a confusion matrix breaks classification results into true and false positives and negatives by class', 'eine Konfusionsmatrix Klassifikationsergebnisse in echte und falsche Positive sowie Negative je Klasse aufteilt', 'Look for detailed class-level error counts.', 'Achten Sie auf detaillierte Fehlerzahlen je Klasse.', ref.train),
    pipelineOutputs: c('Pipeline component outputs', 'Komponentenausgaben einer Pipeline', 'pipeline outputs let one component pass prepared data or models directly to downstream components', 'Pipeline-Ausgaben es einer Komponente ermöglichen, vorbereitete Daten oder Modelle direkt an nachgelagerte Komponenten zu übergeben', 'Look for data flow between pipeline steps.', 'Achten Sie auf den Datenfluss zwischen Pipelineschritten.', ref.pipelines),
    gpuCluster: c('GPU compute cluster', 'GPU-Computecluster', 'a GPU compute cluster provides scalable GPU-backed nodes for deep learning training jobs', 'ein GPU-Computecluster skalierbare GPU-gestützte Knoten für Deep-Learning-Trainingsjobs bereitstellt', 'Look for scalable GPU training.', 'Achten Sie auf skalierbares GPU-Training.', ref.compute),
    distributedTraining: c('Distributed training', 'Verteiltes Training', 'distributed training uses multiple workers or nodes so very large training workloads finish sooner', 'verteiltes Training mehrere Worker oder Knoten nutzt, damit sehr große Trainingsworkloads schneller abgeschlossen werden', 'Look for multi-worker training across the cluster.', 'Achten Sie auf Multi-Worker-Training über den Cluster hinweg.', ref.train),
    modelRegistration: c('Model registration', 'Modellregistrierung', 'model registration versions trained models and attaches governance metadata before deployment', 'die Modellregistrierung trainierte Modelle versioniert und Governance-Metadaten vor der Bereitstellung anfügt', 'Look for governed versioning of trained models.', 'Achten Sie auf geregelte Versionierung trainierter Modelle.', ref.models),
    scoringScript: c('Scoring script with init() and run()', 'Bewertungsskript mit init() und run()', 'a scoring script defines how the model is loaded and how inference requests are handled', 'ein Bewertungsskript definiert, wie das Modell geladen wird und wie Inferenzanforderungen verarbeitet werden', 'Look for inference entry points.', 'Achten Sie auf die Inferenz-Einstiegspunkte.', ref.deployOnline),
    batchEndpoint: c('Batch endpoint', 'Batchendpunkt', 'a batch endpoint is designed for asynchronous large-volume scoring over file-based inputs', 'ein Batchendpunkt für asynchrone Scoringvorgänge mit hohem Volumen über dateibasierte Eingaben ausgelegt ist', 'Look for asynchronous file-based scoring at scale.', 'Achten Sie auf asynchrones dateibasiertes Scoring im großen Maßstab.', ref.batch),
    localDeployment: c('Local deployment', 'Lokale Bereitstellung', 'a local deployment lets you debug the inference container and dependencies before using cloud resources', 'eine lokale Bereitstellung es ermöglicht, den Inferenzcontainer und seine Abhängigkeiten vor der Nutzung von Cloud-Ressourcen zu debuggen', 'Look for local debugging before cloud rollout.', 'Achten Sie auf lokales Debugging vor dem Cloud-Rollout.', ref.deployOnline),
    managedOnlineEndpoint: c('Managed online endpoint', 'Verwalteter Onlineendpunkt', 'a managed online endpoint provides a stable real-time scoring URL and can host multiple deployments', 'ein verwalteter Onlineendpunkt eine stabile URL für Echtzeit-Scoring bereitstellt und mehrere Bereitstellungen hosten kann', 'Look for real-time HTTPS scoring with stable routing.', 'Achten Sie auf Echtzeit-Scoring über HTTPS mit stabiler Weiterleitung.', ref.online),
    customBatchOutput: c('Custom output configuration for a batch deployment', 'Benutzerdefinierte Ausgabekonfiguration für eine Batchbereitstellung', 'custom output configuration controls the files and formats written by batch inference jobs', 'eine benutzerdefinierte Ausgabekonfiguration die von Batch-Inferenzjobs geschriebenen Dateien und Formate steuert', 'Look for control over generated batch output files.', 'Achten Sie auf Kontrolle über erzeugte Batch-Ausgabedateien.', ref.batchOutput),
    tokenAuth: c('Microsoft Entra token authentication', 'Microsoft Entra-Tokenauthentifizierung', 'Microsoft Entra token authentication avoids shared keys and integrates real-time scoring with identity-based access control', 'die Microsoft Entra-Tokenauthentifizierung gemeinsame Schlüssel vermeidet und Echtzeit-Scoring in identitätsbasierte Zugriffskontrolle integriert', 'Look for identity-based access instead of shared secrets.', 'Achten Sie auf identitätsbasierten Zugriff statt gemeinsamer Geheimnisse.', ref.online),
    azureMonitor: c('Azure Monitor', 'Azure Monitor', 'Azure Monitor collects endpoint metrics and logs, supports dashboards, and drives alert rules', 'Azure Monitor Endpunktmetriken und Protokolle erfasst, Dashboards unterstützt und Warnregeln ermöglicht', 'Look for metrics, dashboards, and alerts.', 'Achten Sie auf Metriken, Dashboards und Warnungen.', ref.monitor),
    applicationInsights: c('Application Insights', 'Application Insights', 'Application Insights helps analyze traces, custom logs, and request handling inside the deployed inference container', 'Application Insights bei der Analyse von Traces, benutzerdefinierten Protokollen und der Anforderungsverarbeitung im bereitgestellten Inferenzcontainer hilft', 'Look for traces and container-level diagnostics.', 'Achten Sie auf Traces und Diagnosen auf Containerebene.', ref.monitor),
    pipelineSchedule: c('Pipeline schedule', 'Pipelineszeitplan', 'a pipeline schedule runs retraining or batch inference workflows automatically on a recurring cadence', 'ein Pipelineszeitplan Retraining- oder Batch-Inferenzworkflows automatisch in einem wiederkehrenden Rhythmus ausführt', 'Look for recurring automated execution.', 'Achten Sie auf wiederkehrende automatisierte Ausführung.', ref.schedule),
    autoscale: c('Autoscale settings on the deployment', 'Autoscale-Einstellungen für die Bereitstellung', 'autoscale settings adjust the number of serving instances as traffic changes', 'Autoscale-Einstellungen die Anzahl der Serving-Instanzen an veränderten Datenverkehr anpassen', 'Look for changing instance count with traffic.', 'Achten Sie auf eine mit dem Datenverkehr veränderte Instanzzahl.', ref.online),
    trafficSplit: c('Weighted traffic splitting between deployments', 'Gewichtete Verkehrsaufteilung zwischen Bereitstellungen', 'weighted traffic splitting lets you roll out a new model gradually and compare it with the current deployment safely', 'eine gewichtete Verkehrsaufteilung es ermöglicht, ein neues Modell schrittweise auszurollen und sicher mit der aktuellen Bereitstellung zu vergleichen', 'Look for gradual rollout and safe comparison.', 'Achten Sie auf schrittweisen Rollout und sicheren Vergleich.', ref.online),
    retrainingPipeline: c('A retraining pipeline with prepare, train, evaluate, and register steps', 'Eine Retraining-Pipeline mit Schritten für Vorbereitung, Training, Auswertung und Registrierung', 'a retraining pipeline orchestrates the full closed-loop workflow from data preparation through model registration', 'eine Retraining-Pipeline den vollständigen Closed-Loop-Workflow von der Datenvorbereitung bis zur Modellregistrierung orchestriert', 'Look for end-to-end orchestration of the retraining loop.', 'Achten Sie auf die End-to-End-Orchestrierung des Retraining-Kreislaufs.', ref.schedule)
  };

  function optionText(option) {
    return typeof option === 'string' ? concepts[option].label : t(option[0], option[1]);
  }

  function mapOptions(options) {
    return options.map(function(option, index) {
      var letter = String.fromCharCode(65 + index);
      var text = optionText(option);
      return o(letter, text.en, text.de);
    });
  }

  function mapCorrect(indices) {
    return indices.map(function(index) { return String.fromCharCode(65 + index); });
  }

  function genericExplanation(answer) {
    var concept = concepts[answer];
    return t(
      'The best answer is ' + concept.label.en + ' because ' + concept.reason.en + '. That directly matches the requirement in the question.',
      'Die beste Antwort ist ' + concept.label.de + ', weil ' + concept.reason.de + '. Das entspricht direkt der Anforderung in der Frage.'
    );
  }

  function genericHint(answer) {
    var concept = concepts[answer];
    return t('Hint: ' + concept.hint.en, 'Hinweis: ' + concept.hint.de);
  }

  var singles = [
    { id: 'dp100-201', domain: design, difficulty: 'easy', question: t('Which Azure Machine Learning asset should you use to share approved models, components, and environments across multiple workspaces?', 'Welchen Azure-Machine-Learning-Bestand sollten Sie verwenden, um freigegebene Modelle, Komponenten und Umgebungen über mehrere Arbeitsbereiche hinweg bereitzustellen?'), options: ['registry', ['Azure Machine Learning workspace', 'Azure Machine Learning-Arbeitsbereich'], 'datastore', 'modelRegistration'], correct: [0], answer: 'registry' },
    { id: 'dp100-202', domain: design, difficulty: 'easy', question: t('A data scientist needs a managed workstation for notebooks, terminals, and package installation. Which compute option should you choose?', 'Ein Data Scientist benötigt eine verwaltete Arbeitsstation für Notebooks, Terminals und Paketinstallation. Welche Compute-Option sollten Sie wählen?'), options: ['computeInstance', 'computeCluster', 'managedOnlineEndpoint', 'batchEndpoint'], correct: [0], answer: 'computeInstance' },
    { id: 'dp100-203', domain: design, difficulty: 'easy', question: t('Which workspace asset should store a reusable connection to Azure Data Lake Storage so jobs can refer to it by name?', 'Welcher Arbeitsbereichsbestand sollte eine wiederverwendbare Verbindung zu Azure Data Lake Storage speichern, damit Jobs per Namen darauf verweisen können?'), options: ['datastore', 'dataAssetVersion', 'modelRegistration', 'applicationInsights'], correct: [0], answer: 'datastore' },
    { id: 'dp100-204', domain: design, difficulty: 'easy', question: t('Upstream files are overwritten every night. Which asset should training jobs reference to keep an immutable snapshot for reproducibility?', 'Vorgelagerte Dateien werden jede Nacht überschrieben. Auf welchen Bestand sollten Trainingsjobs verweisen, um einen unveränderlichen Snapshot für die Reproduzierbarkeit zu erhalten?'), options: ['dataAssetVersion', 'datastore', 'computeInstance', 'azureMonitor'], correct: [0], answer: 'dataAssetVersion' },
    { id: 'dp100-205', domain: design, difficulty: 'easy', question: t('Which Azure Machine Learning asset versions Python packages and container settings so the same dependency stack can be reused for training and inference?', 'Welcher Azure-Machine-Learning-Bestand versioniert Python-Pakete und Containereinstellungen, damit derselbe Abhängigkeitsstand für Training und Inferenz wiederverwendet werden kann?'), options: ['environment', 'component', 'registry', 'confusionMatrix'], correct: [0], answer: 'environment' },
    { id: 'dp100-206', domain: design, difficulty: 'medium', question: t('Which artifact should you create when you want a reusable preprocessing step with declared inputs and outputs for many pipelines?', 'Welches Artefakt sollten Sie erstellen, wenn Sie einen wiederverwendbaren Vorverarbeitungsschritt mit deklarierten Ein- und Ausgaben für viele Pipelines benötigen?'), options: ['component', 'modelRegistration', 'computeCluster', 'managedOnlineEndpoint'], correct: [0], answer: 'component' },
    { id: 'dp100-207', domain: design, difficulty: 'easy', question: t('Which compute target automatically scales node count based on queued training jobs?', 'Welches Computeziel skaliert die Knotenzahl automatisch anhand wartender Trainingsjobs?'), options: ['computeCluster', 'computeInstance', 'localDeployment', 'registry'], correct: [0], answer: 'computeCluster' },
    { id: 'dp100-208', domain: design, difficulty: 'hard', question: t('Which feature should you use when local experiments and remote Azure runs must store parameters, metrics, and artifacts in a common tracking system?', 'Welche Funktion sollten Sie verwenden, wenn lokale Experimente und entfernte Azure-Ausführungen Parameter, Metriken und Artefakte in einem gemeinsamen Tracking-System speichern sollen?'), options: ['mlflow', 'azureMonitor', 'mltable', 'batchEndpoint'], correct: [0], answer: 'mlflow' },
    { id: 'dp100-209', domain: design, difficulty: 'medium', question: t('Which authentication approach lets training jobs access storage without embedding account keys in code or YAML?', 'Welcher Authentifizierungsansatz ermöglicht Trainingsjobs den Zugriff auf Speicher, ohne Kontoschlüssel in Code oder YAML einzubetten?'), options: ['managedIdentity', ['Embedded storage account key', 'Eingebetteter Speicherkontoschlüssel'], ['Shared access signature stored in the script', 'Im Skript gespeicherte Shared Access Signature'], ['Personal access token', 'Persönliches Zugriffstoken']], correct: [0], answer: 'managedIdentity' },
    { id: 'dp100-210', domain: design, difficulty: 'hard', question: t('For a forecasting problem, the team wants Azure Machine Learning to try algorithms, lags, and preprocessing choices with minimal custom code. Which approach best fits?', 'Für ein Forecasting-Problem soll Azure Machine Learning mit minimalem benutzerdefiniertem Code Algorithmen, Verzögerungen und Vorverarbeitungsoptionen ausprobieren. Welcher Ansatz passt am besten?'), options: ['automatedML', 'component', 'batchEndpoint', 'applicationInsights'], correct: [0], answer: 'automatedML' },
    { id: 'dp100-211', domain: explore, difficulty: 'easy', question: t('Which data asset type should you create for partitioned tabular files that need a defined schema and repeatable reads in jobs?', 'Welchen Datenbestandstyp sollten Sie für partitionierte tabellarische Dateien erstellen, die ein definiertes Schema und reproduzierbare Lesevorgänge in Jobs benötigen?'), options: ['mltable', 'datastore', 'registry', 'modelRegistration'], correct: [0], answer: 'mltable' },
    { id: 'dp100-212', domain: explore, difficulty: 'easy', question: t('Which job type runs a custom training script or shell command on selected compute in Azure Machine Learning?', 'Welcher Jobtyp führt ein benutzerdefiniertes Trainingsskript oder einen Shell-Befehl auf ausgewähltem Compute in Azure Machine Learning aus?'), options: ['commandJob', 'sweepJob', 'batchEndpoint', 'localDeployment'], correct: [0], answer: 'commandJob' },
    { id: 'dp100-213', domain: explore, difficulty: 'easy', question: t('Which job type is designed to explore a hyperparameter search space across many trials?', 'Welcher Jobtyp ist dafür ausgelegt, einen Hyperparametersuchraum über viele Versuche hinweg zu erkunden?'), options: ['sweepJob', 'commandJob', 'modelRegistration', 'azureMonitor'], correct: [0], answer: 'sweepJob' },
    { id: 'dp100-214', domain: explore, difficulty: 'medium', question: t('Which early termination strategy stops poor-performing hyperparameter trials before they consume the full budget?', 'Welche Strategie für frühes Beenden stoppt schlecht performende Hyperparameter-Versuche, bevor sie das gesamte Budget verbrauchen?'), options: ['banditPolicy', ['Median stopping policy', 'Median-Stopping-Richtlinie'], 'trafficSplit', 'computeInstance'], correct: [0], answer: 'banditPolicy' },
    { id: 'dp100-215', domain: explore, difficulty: 'medium', question: t('Which validation approach is best when you have limited labeled data and want a more stable estimate of model performance?', 'Welcher Validierungsansatz ist am besten geeignet, wenn Sie nur begrenzt gelabelte Daten haben und eine stabilere Schätzung der Modellleistung wünschen?'), options: [['Simple holdout split', 'Einfacher Holdout-Split'], 'crossValidation', 'trafficSplit', 'managedIdentity'], correct: [1], answer: 'crossValidation' },
    { id: 'dp100-216', domain: explore, difficulty: 'medium', question: t('Which data split strategy should you use to keep class ratios consistent between train and validation sets?', 'Welche Datenaufteilungsstrategie sollten Sie verwenden, um die Klassenverhältnisse zwischen Trainings- und Validierungssätzen konsistent zu halten?'), options: [['Random split', 'Zufälliger Split'], 'stratifiedSplit', ['Hash partitioning by customer ID', 'Hash-Partitionierung nach Kunden-ID'], 'autoscale'], correct: [1], answer: 'stratifiedSplit' },
    { id: 'dp100-217', domain: explore, difficulty: 'hard', question: t('Which primary metric is usually best when positive cases are rare and you care about ranking them above a large negative class?', 'Welche primäre Metrik ist in der Regel am besten geeignet, wenn positive Fälle selten sind und Sie diese oberhalb einer großen negativen Klasse einordnen möchten?'), options: [['Accuracy', 'Genauigkeit'], 'auprc', ['R-squared', 'Bestimmtheitsmaß'], 'mae'], correct: [1], answer: 'auprc' },
    { id: 'dp100-218', domain: explore, difficulty: 'medium', question: t('Which metric is most appropriate when you want one number that balances precision and recall at the chosen threshold?', 'Welche Metrik ist am besten geeignet, wenn Sie eine einzelne Kennzahl möchten, die Präzision und Recall beim gewählten Schwellenwert ausbalanciert?'), options: [['Precision', 'Präzision'], ['Recall', 'Recall'], 'f1Score', 'rmse'], correct: [2], answer: 'f1Score' },
    { id: 'dp100-219', domain: explore, difficulty: 'medium', question: t('Which regression metric penalizes large errors more strongly because it squares residuals before averaging?', 'Welche Regressionsmetrik bestraft große Fehler stärker, weil sie Residuen vor dem Mitteln quadriert?'), options: ['rmse', 'mae', ['Precision', 'Präzision'], ['Area under the ROC curve', 'Fläche unter der ROC-Kurve']], correct: [0], answer: 'rmse' },
    { id: 'dp100-220', domain: explore, difficulty: 'medium', question: t('Which regression metric stays in original units and is less sensitive to a few large outliers than RMSE?', 'Welche Regressionsmetrik bleibt in Originaleinheiten und reagiert weniger empfindlich auf einige große Ausreißer als RMSE?'), options: [['Log loss', 'Log-Loss'], 'mae', ['Accuracy', 'Genauigkeit'], ['R-squared', 'Bestimmtheitsmaß']], correct: [1], answer: 'mae' },
    { id: 'dp100-221', domain: explore, difficulty: 'easy', question: t('Which capability automatically records common metrics, parameters, and models from supported training frameworks with minimal extra code?', 'Welche Funktion erfasst gängige Metriken, Parameter und Modelle aus unterstützten Trainingsframeworks mit minimalem Zusatzcode automatisch?'), options: ['mlflowAutolog', 'azureMonitor', 'modelRegistration', 'customBatchOutput'], correct: [0], answer: 'mlflowAutolog' },
    { id: 'dp100-222', domain: explore, difficulty: 'medium', question: t('Which interpretability output helps you identify which features most influenced predictions overall or for individual examples?', 'Welche Interpretierbarkeitsausgabe hilft Ihnen zu erkennen, welche Merkmale Vorhersagen insgesamt oder für einzelne Beispiele am stärksten beeinflusst haben?'), options: ['featureImportance', 'trafficSplit', 'datastore', 'tokenAuth'], correct: [0], answer: 'featureImportance' },
    { id: 'dp100-223', domain: explore, difficulty: 'medium', question: t('Which evaluation artifact shows true positives, false positives, true negatives, and false negatives by class?', 'Welches Auswertungsartefakt zeigt echte Positive, falsche Positive, echte Negative und falsche Negative je Klasse?'), options: [['Precision-recall curve', 'Precision-Recall-Kurve'], 'confusionMatrix', 'batchEndpoint', 'managedIdentity'], correct: [1], answer: 'confusionMatrix' },
    { id: 'dp100-224', domain: explore, difficulty: 'medium', question: t('What should you use when one pipeline step must pass a prepared dataset or model artifact directly to the next step?', 'Was sollten Sie verwenden, wenn ein Pipelineschritt einen vorbereiteten Datensatz oder ein Modellartefakt direkt an den nächsten Schritt übergeben muss?'), options: ['pipelineOutputs', 'computeCluster', 'registry', 'applicationInsights'], correct: [0], answer: 'pipelineOutputs' },
    { id: 'dp100-225', domain: explore, difficulty: 'medium', question: t('Which compute choice is best for deep learning training that requires scalable NVIDIA GPU nodes?', 'Welche Compute-Auswahl ist am besten für Deep-Learning-Training geeignet, das skalierbare NVIDIA-GPU-Knoten erfordert?'), options: ['gpuCluster', 'computeInstance', ['CPU-only compute cluster', 'CPU-basierter Computecluster'], 'azureMonitor'], correct: [0], answer: 'gpuCluster' },
    { id: 'dp100-226', domain: explore, difficulty: 'hard', question: t('Training a transformer on many millions of records does not finish in the available window on one GPU node. Which approach should you adopt to use multiple workers across the cluster?', 'Das Training eines Transformers auf vielen Millionen Datensätzen wird auf einem GPU-Knoten nicht rechtzeitig abgeschlossen. Welchen Ansatz sollten Sie wählen, um mehrere Worker über den Cluster hinweg zu nutzen?'), options: ['distributedTraining', 'modelRegistration', 'confusionMatrix', 'datastore'], correct: [0], answer: 'distributedTraining' },
    { id: 'dp100-227', domain: prepare, difficulty: 'easy', question: t('Which asset should you create to version a trained model and attach tags or properties before approval?', 'Welchen Bestand sollten Sie erstellen, um ein trainiertes Modell zu versionieren und vor der Freigabe mit Tags oder Eigenschaften zu versehen?'), options: ['modelRegistration', 'datastore', 'mlflow', 'applicationInsights'], correct: [0], answer: 'modelRegistration' },
    { id: 'dp100-228', domain: prepare, difficulty: 'easy', question: t('Which file defines how the model is loaded and how inference requests are processed during a custom deployment?', 'Welche Datei definiert, wie das Modell geladen wird und wie Inferenzanforderungen bei einer benutzerdefinierten Bereitstellung verarbeitet werden?'), options: ['scoringScript', 'environment', 'pipelineSchedule', 'azureMonitor'], correct: [0], answer: 'scoringScript' },
    { id: 'dp100-229', domain: prepare, difficulty: 'easy', question: t('Which asset should you update when you need to add Python packages required by the scoring container before deployment?', 'Welchen Bestand sollten Sie aktualisieren, wenn Sie vor der Bereitstellung Python-Pakete hinzufügen müssen, die vom Scoring-Container benötigt werden?'), options: ['environment', 'registry', 'confusionMatrix', 'trafficSplit'], correct: [0], answer: 'environment' },
    { id: 'dp100-230', domain: prepare, difficulty: 'easy', question: t('Which endpoint type is best for asynchronous scoring of large folders of input files?', 'Welcher Endpunkttyp eignet sich am besten für asynchrones Scoring großer Ordner mit Eingabedateien?'), options: ['batchEndpoint', 'managedOnlineEndpoint', 'computeInstance', 'modelRegistration'], correct: [0], answer: 'batchEndpoint' },
    { id: 'dp100-231', domain: prepare, difficulty: 'medium', question: t('Which step should you use to debug inference dependencies on your machine before spending cloud resources?', 'Welchen Schritt sollten Sie verwenden, um Inferenzabhängigkeiten auf Ihrem Rechner zu debuggen, bevor Sie Cloud-Ressourcen nutzen?'), options: ['localDeployment', 'trafficSplit', 'banditPolicy', 'azureMonitor'], correct: [0], answer: 'localDeployment' },
    { id: 'dp100-232', domain: prepare, difficulty: 'medium', question: t('Which serving option provides a stable real-time HTTPS scoring URL and can later host more than one deployment?', 'Welche Serving-Option stellt eine stabile HTTPS-URL für Echtzeit-Scoring bereit und kann später mehr als eine Bereitstellung hosten?'), options: ['managedOnlineEndpoint', 'batchEndpoint', 'datastore', 'confusionMatrix'], correct: [0], answer: 'managedOnlineEndpoint' },
    { id: 'dp100-233', domain: prepare, difficulty: 'hard', question: t('Which configuration should you use when batch inference must write custom files and output formats instead of the default predictions file?', 'Welche Konfiguration sollten Sie verwenden, wenn die Batch-Inferenz benutzerdefinierte Dateien und Ausgabeformate statt der Standarddatei für Vorhersagen schreiben muss?'), options: ['customBatchOutput', 'mlflowAutolog', 'managedIdentity', 'computeInstance'], correct: [0], answer: 'customBatchOutput' },
    { id: 'dp100-234', domain: prepare, difficulty: 'medium', question: t('Which authentication mode should internal applications use when they must call a real-time endpoint without relying on shared keys?', 'Welchen Authentifizierungsmodus sollten interne Anwendungen verwenden, wenn sie einen Echtzeitendpunkt ohne gemeinsame Schlüssel aufrufen müssen?'), options: ['tokenAuth', ['Primary and secondary keys', 'Primär- und Sekundärschlüssel'], ['Storage account key in the scoring script', 'Speicherkontoschlüssel im Bewertungsskript'], 'applicationInsights'], correct: [0], answer: 'tokenAuth' },
    { id: 'dp100-235', domain: prepare, difficulty: 'medium', question: t('Which asset should remain pinned if you want both training and inference to use the exact same dependency stack?', 'Welcher Bestand sollte fest versioniert bleiben, wenn Training und Inferenz exakt denselben Abhängigkeitsstand verwenden sollen?'), options: ['environment', 'scoringScript', 'batchEndpoint', 'computeCluster'], correct: [0], answer: 'environment' },
    { id: 'dp100-236', domain: prepare, difficulty: 'medium', question: t('Which artifact is the right place for version numbers, tags, and business metadata about the model that is heading toward production?', 'Welches Artefakt ist der richtige Ort für Versionsnummern, Tags und fachliche Metadaten über das Modell, das in Richtung Produktion geht?'), options: ['modelRegistration', 'datastore', 'featureImportance', 'azureMonitor'], correct: [0], answer: 'modelRegistration' },
    { id: 'dp100-237', domain: prepare, difficulty: 'hard', question: t('Which endpoint architecture lets one public scoring URL route requests to multiple deployments behind it?', 'Welche Endpunktarchitektur ermöglicht es, dass eine öffentliche Scoring-URL Anfragen an mehrere dahinterliegende Bereitstellungen weiterleitet?'), options: ['managedOnlineEndpoint', 'modelRegistration', 'sweepJob', 'mltable'], correct: [0], answer: 'managedOnlineEndpoint' },
    { id: 'dp100-238', domain: prepare, difficulty: 'hard', question: t('What should you do first if your goal is to catch dependency and request-schema issues before any cloud deployment?', 'Was sollten Sie zuerst tun, wenn Sie Abhängigkeits- und Request-Schema-Probleme vor jeder Cloud-Bereitstellung erkennen möchten?'), options: ['localDeployment', 'tokenAuth', 'modelRegistration', 'registry'], correct: [0], answer: 'localDeployment' },
    { id: 'dp100-239', domain: deploy, difficulty: 'easy', question: t('Which Azure service should you use to track endpoint latency, request volume, and error metrics over time?', 'Welchen Azure-Dienst sollten Sie verwenden, um Endpunktlatenz, Anforderungsvolumen und Fehlermetriken im Zeitverlauf nachzuverfolgen?'), options: ['azureMonitor', 'applicationInsights', 'mlflow', 'localDeployment'], correct: [0], answer: 'azureMonitor' },
    { id: 'dp100-240', domain: deploy, difficulty: 'easy', question: t('Which tool is best for analyzing traces, custom logs, and request handling inside a deployed inference container?', 'Welches Werkzeug eignet sich am besten zur Analyse von Traces, benutzerdefinierten Protokollen und der Anforderungsverarbeitung innerhalb eines bereitgestellten Inferenzcontainers?'), options: ['applicationInsights', 'azureMonitor', 'mltable', 'registry'], correct: [0], answer: 'applicationInsights' },
    { id: 'dp100-241', domain: deploy, difficulty: 'easy', question: t('Which feature should you configure to run a retraining workflow automatically every week?', 'Welche Funktion sollten Sie konfigurieren, um einen Retraining-Workflow automatisch jede Woche auszuführen?'), options: ['pipelineSchedule', 'trafficSplit', 'modelRegistration', 'localDeployment'], correct: [0], answer: 'pipelineSchedule' },
    { id: 'dp100-242', domain: deploy, difficulty: 'medium', question: t('Which serving approach is best when a nightly job must score files landing in storage and no user is waiting for an immediate response?', 'Welcher Serving-Ansatz ist am besten geeignet, wenn ein nächtlicher Job Dateien im Speicher bewerten muss und kein Benutzer auf eine sofortige Antwort wartet?'), options: ['batchEndpoint', 'computeInstance', 'managedIdentity', 'confusionMatrix'], correct: [0], answer: 'batchEndpoint' },
    { id: 'dp100-243', domain: deploy, difficulty: 'hard', question: t('Which configuration should you tune when a real-time deployment must add or remove serving instances as request volume changes?', 'Welche Konfiguration sollten Sie anpassen, wenn eine Echtzeitbereitstellung bei verändertem Anforderungsvolumen Serving-Instanzen hinzufügen oder entfernen muss?'), options: ['autoscale', 'computeInstance', 'modelRegistration', 'mlflow'], correct: [0], answer: 'autoscale' },
    { id: 'dp100-244', domain: deploy, difficulty: 'medium', question: t('Which service is the right foundation for alert rules when p95 latency or failure rate crosses a threshold?', 'Welcher Dienst ist die richtige Grundlage für Warnregeln, wenn p95-Latenz oder Fehlerrate einen Schwellenwert überschreiten?'), options: ['azureMonitor', 'featureImportance', 'datastore', 'component'], correct: [0], answer: 'azureMonitor' },
    { id: 'dp100-245', domain: deploy, difficulty: 'hard', question: t('Which rollout technique should you use to expose only part of live traffic to a new deployment first?', 'Welche Rollout-Technik sollten Sie verwenden, um zunächst nur einen Teil des Live-Verkehrs an eine neue Bereitstellung zu senden?'), options: ['trafficSplit', 'modelRegistration', 'stratifiedSplit', 'dataAssetVersion'], correct: [0], answer: 'trafficSplit' },
    { id: 'dp100-246', domain: deploy, difficulty: 'hard', question: t('A newly deployed model misbehaves under production traffic. Which control should you change first to send requests back to the stable deployment without changing the endpoint URL?', 'Ein neu bereitgestelltes Modell verhält sich unter Produktionslast fehlerhaft. Welche Steuerung sollten Sie zuerst ändern, um Anfragen ohne Änderung der Endpunkt-URL zurück an die stabile Bereitstellung zu senden?'), options: ['trafficSplit', 'azureMonitor', 'computeInstance', 'scoringScript'], correct: [0], answer: 'trafficSplit' },
    { id: 'dp100-247', domain: deploy, difficulty: 'medium', question: t('Which feature should you use to run monthly batch predictions automatically on a recurring cadence?', 'Welche Funktion sollten Sie verwenden, um monatliche Batchvorhersagen automatisch in einem wiederkehrenden Rhythmus auszuführen?'), options: ['pipelineSchedule', 'computeCluster', 'azureMonitor', 'tokenAuth'], correct: [0], answer: 'pipelineSchedule' },
    { id: 'dp100-248', domain: deploy, difficulty: 'medium', question: t('Which Azure service should you use to compare endpoint metrics between deployments over time in dashboards?', 'Welchen Azure-Dienst sollten Sie verwenden, um Endpunktmetriken zwischen Bereitstellungen im Zeitverlauf in Dashboards zu vergleichen?'), options: ['azureMonitor', 'applicationInsights', 'registry', 'component'], correct: [0], answer: 'azureMonitor' },
    { id: 'dp100-249', domain: deploy, difficulty: 'hard', question: t('Which design best supports a closed-loop process that prepares data, trains a model, evaluates it, and registers the approved version?', 'Welches Design unterstützt am besten einen Closed-Loop-Prozess, der Daten vorbereitet, ein Modell trainiert, es auswertet und die freigegebene Version registriert?'), options: ['retrainingPipeline', 'modelRegistration', 'azureMonitor', 'trafficSplit'], correct: [0], answer: 'retrainingPipeline' },
    { id: 'dp100-250', domain: deploy, difficulty: 'medium', question: t('Which tool should you inspect when your custom inference code writes traces and dependency errors from inside the online deployment container?', 'Welches Werkzeug sollten Sie prüfen, wenn Ihr benutzerdefinierter Inferenzcode Traces und Abhängigkeitsfehler aus dem Online-Bereitstellungscontainer schreibt?'), options: ['applicationInsights', 'pipelineSchedule', 'batchEndpoint', 'datastore'], correct: [0], answer: 'applicationInsights' }
  ];
  var multiples = [
    { id: 'dp100-251', domain: design, difficulty: 'easy', question: t('Which two benefits do Azure Machine Learning registries provide for enterprise MLOps? Choose all that apply.', 'Welche zwei Vorteile bieten Azure Machine Learning-Registries für unternehmensweites MLOps? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Share approved models, components, and environments across workspaces', 'Freigegebene Modelle, Komponenten und Umgebungen arbeitsbereichsübergreifend bereitstellen'], ['Support governed promotion flows between workspaces', 'Geregelte Promotion-Abläufe zwischen Arbeitsbereichen unterstützen'], ['Create personal notebook virtual machines for each user', 'Persönliche Notebook-VMs für jeden Benutzer erstellen'], ['Replace Azure Monitor for endpoint metrics', 'Azure Monitor für Endpunktmetriken ersetzen']], correct: [0, 1], explanation: t('Registries are built for sharing curated machine learning assets across workspaces and supporting governed promotion between environments. They do not replace monitoring services and they are not personal development machines.', 'Registries sind dafür ausgelegt, kuratierte Machine-Learning-Bestände arbeitsbereichsübergreifend bereitzustellen und geregelte Promotion zwischen Umgebungen zu unterstützen. Sie ersetzen keine Überwachungsdienste und sind keine persönlichen Entwicklungsmaschinen.'), hint: t('Choose the answers about cross-workspace asset governance.', 'Wählen Sie die Antworten zur Governance von Beständen über Arbeitsbereiche hinweg aus.'), reference: ref.registries },
    { id: 'dp100-252', domain: design, difficulty: 'medium', question: t('Which three actions most improve reproducibility of Azure Machine Learning training runs? Choose all that apply.', 'Welche drei Maßnahmen verbessern die Reproduzierbarkeit von Azure-Machine-Learning-Trainingsläufen am stärksten? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Reference versioned data assets', 'Auf versionierte Datenbestände verweisen'], ['Pin environment versions', 'Umgebungs-Versionen festschreiben'], ['Register resulting models with metadata', 'Entstandene Modelle mit Metadaten registrieren'], ['Use unnamed local files from a laptop folder', 'Unbenannte lokale Dateien aus einem Laptop-Ordner verwenden'], ['Edit the production endpoint directly during experiments', 'Den Produktionsendpunkt während Experimenten direkt bearbeiten']], correct: [0, 1, 2], explanation: t('Versioned data assets, pinned environments, and model registration create a reproducible chain of inputs, dependencies, and outputs. Unnamed local files and direct production edits undermine repeatability and governance.', 'Versionierte Datenbestände, festgeschriebene Umgebungen und die Modellregistrierung schaffen eine reproduzierbare Kette aus Eingaben, Abhängigkeiten und Ergebnissen. Unbenannte lokale Dateien und direkte Änderungen in der Produktion untergraben Wiederholbarkeit und Governance.'), hint: t('Pick the options that version inputs, dependencies, and outputs.', 'Wählen Sie die Optionen aus, die Eingaben, Abhängigkeiten und Ergebnisse versionieren.'), reference: ref.dataAssets },
    { id: 'dp100-253', domain: design, difficulty: 'medium', question: t('Which two scenarios are best matched to a compute instance? Choose all that apply.', 'Welche zwei Szenarien passen am besten zu einer Compute-Instanz? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Interactive notebook authoring and debugging', 'Interaktive Notebook-Erstellung und Debugging'], ['Ad hoc package installation for one data scientist', 'Ad-hoc-Paketinstallation für einen Data Scientist'], ['Queued multi-node team training', 'Mehrknotiges Teamtraining in einer Warteschlange'], ['Asynchronous file-based batch scoring', 'Asynchrones dateibasiertes Batch-Scoring']], correct: [0, 1], explanation: t('A compute instance is a personal managed development machine for notebook work and interactive troubleshooting. Queued team training belongs on a compute cluster, and file-based scoring belongs on a batch endpoint.', 'Eine Compute-Instanz ist eine persönliche verwaltete Entwicklungsmaschine für Notebook-Arbeit und interaktive Fehlerbehebung. Teamtraining in Warteschlangen gehört auf einen Computecluster, und dateibasiertes Scoring auf einen Batchendpunkt.'), hint: t('Choose the answers about personal interactive development.', 'Wählen Sie die Antworten zur persönlichen interaktiven Entwicklung aus.'), reference: ref.compute },
    { id: 'dp100-254', domain: design, difficulty: 'hard', question: t('Which two statements about datastores and data assets are correct? Choose all that apply.', 'Welche zwei Aussagen über Datastores und Datenbestände sind korrekt? Wählen Sie alle zutreffenden Antworten aus.'), options: [['A datastore stores connection details for an underlying storage service', 'Ein Datastore speichert Verbindungsdetails für einen zugrunde liegenden Speicherdienst'], ['A data asset version is an immutable reference used by jobs and pipelines', 'Eine Datenbestandsversion ist ein unveränderlicher Verweis, der von Jobs und Pipelines verwendet wird'], ['A datastore is the correct object for endpoint traffic routing', 'Ein Datastore ist das richtige Objekt für Endpunkt-Traffic-Routing'], ['A data asset replaces Azure Monitor dashboards', 'Ein Datenbestand ersetzt Azure-Monitor-Dashboards']], correct: [0, 1], explanation: t('Datastores abstract the storage connection, while data asset versions provide immutable references for jobs and pipelines. Traffic routing and monitoring are solved by endpoint and monitoring features, not by data connection assets.', 'Datastores abstrahieren die Speicherverbindung, während Datenbestandsversionen unveränderliche Verweise für Jobs und Pipelines bereitstellen. Traffic-Routing und Monitoring werden durch Endpunkt- und Überwachungsfunktionen gelöst, nicht durch Datenverbindungsbestände.'), hint: t('Choose one answer about storage connectivity and one about immutable references.', 'Wählen Sie eine Antwort zur Speicherkonnektivität und eine zu unveränderlichen Verweisen aus.'), reference: ref.datastores },
    { id: 'dp100-255', domain: design, difficulty: 'hard', question: t('Which three design choices support secretless and governed access to training data? Choose all that apply.', 'Welche drei Entwurfsentscheidungen unterstützen geheimnislosen und geregelten Zugriff auf Trainingsdaten? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Use managed identity for authentication', 'Verwaltete Identität für die Authentifizierung verwenden'], ['Reference storage through a datastore', 'Speicher über einen Datastore referenzieren'], ['Consume versioned data assets in jobs', 'Versionierte Datenbestände in Jobs verwenden'], ['Embed a storage key directly in the script', 'Einen Speicherschlüssel direkt im Skript einbetten'], ['Share a personal token in team notebooks', 'Ein persönliches Token in Team-Notebooks teilen']], correct: [0, 1, 2], explanation: t('Managed identity, datastores, and versioned data assets support governed access patterns without embedding secrets in code. Hardcoded keys and shared personal tokens create security and auditability problems.', 'Verwaltete Identitäten, Datastores und versionierte Datenbestände unterstützen geregelte Zugriffsmuster, ohne Geheimnisse im Code einzubetten. Hartcodierte Schlüssel und geteilte persönliche Tokens verursachen Sicherheits- und Nachvollziehbarkeitsprobleme.'), hint: t('Pick the options that remove secrets from code and preserve governance.', 'Wählen Sie die Optionen aus, die Geheimnisse aus dem Code entfernen und Governance erhalten.'), reference: ref.datastores },
    { id: 'dp100-256', domain: explore, difficulty: 'easy', question: t('Which two capabilities are central to a sweep job configuration? Choose all that apply.', 'Welche zwei Fähigkeiten sind zentral für die Konfiguration eines Sweep-Jobs? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Define a search space', 'Einen Suchraum definieren'], ['Choose an objective metric', 'Eine Zielmetrik auswählen'], ['Assign traffic weights between deployments', 'Traffic-Gewichte zwischen Bereitstellungen zuweisen'], ['Implement init() and run() in a scoring script', 'init() und run() in einem Bewertungsskript implementieren']], correct: [0, 1], explanation: t('A sweep job needs a parameter search space and an objective metric to optimize. Traffic routing and scoring entry points belong to deployment design, not hyperparameter tuning.', 'Ein Sweep-Job benötigt einen Parametersuchraum und eine Zielmetrik zur Optimierung. Traffic-Routing und Scoring-Einstiegspunkte gehören zum Bereitstellungsdesign und nicht zum Hyperparameter-Tuning.'), hint: t('Pick the answers tied to hyperparameter tuning.', 'Wählen Sie die Antworten aus, die zum Hyperparameter-Tuning gehören.'), reference: ref.tune },
    { id: 'dp100-257', domain: explore, difficulty: 'medium', question: t('Which three practices help evaluate imbalanced binary classifiers? Choose all that apply.', 'Welche drei Vorgehensweisen helfen bei der Bewertung unausgeglichener binärer Klassifikatoren? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Use a stratified split', 'Einen stratifizierten Split verwenden'], ['Inspect precision-recall metrics', 'Precision-Recall-Metriken prüfen'], ['Review the confusion matrix', 'Die Konfusionsmatrix prüfen'], ['Scale endpoint instances', 'Endpunktinstanzen skalieren'], ['Create a datastore', 'Einen Datastore erstellen']], correct: [0, 1, 2], explanation: t('For imbalanced classification, preserving class ratios and reviewing precision-recall behavior and confusion matrices reveals quality far better than infrastructure changes. Scaling endpoints and creating datastores do not improve offline evaluation.', 'Bei unausgeglichener Klassifikation liefern die Erhaltung der Klassenverteilung sowie die Prüfung von Precision-Recall-Verhalten und Konfusionsmatrix deutlich bessere Aussagen als Infrastrukturmaßnahmen. Das Skalieren von Endpunkten oder Erstellen von Datastores verbessert die Offline-Auswertung nicht.'), hint: t('Choose evaluation practices, not infrastructure actions.', 'Wählen Sie Auswertungspraktiken und keine Infrastrukturmaßnahmen.'), reference: ref.train },
    { id: 'dp100-258', domain: explore, difficulty: 'medium', question: t('Which two benefits are provided by an MLTable data asset? Choose all that apply.', 'Welche zwei Vorteile bietet ein MLTable-Datenbestand? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Describe schema for tabular files', 'Ein Schema für tabellarische Dateien beschreiben'], ['Read partitioned data consistently in jobs', 'Partitionierte Daten konsistent in Jobs lesen'], ['Automatically split live endpoint traffic', 'Live-Endpunktverkehr automatisch aufteilen'], ['Provide Microsoft Entra tokens for scoring', 'Microsoft Entra-Tokens für Scoring bereitstellen']], correct: [0, 1], explanation: t('MLTable assets standardize how tabular files are interpreted and read, especially when data is partitioned across many files. Traffic management and token issuance are unrelated endpoint concerns.', 'MLTable-Bestände standardisieren, wie tabellarische Dateien interpretiert und gelesen werden, insbesondere wenn Daten über viele Dateien partitioniert sind. Traffic-Management und Tokenausgabe sind davon unabhängige Endpunktthemen.'), hint: t('Pick the answers about tabular data interpretation.', 'Wählen Sie die Antworten zur Interpretation tabellarischer Daten aus.'), reference: ref.dataAssets },
    { id: 'dp100-259', domain: explore, difficulty: 'hard', question: t('Which three capabilities are associated with MLflow integration in Azure Machine Learning? Choose all that apply.', 'Welche drei Fähigkeiten sind mit der MLflow-Integration in Azure Machine Learning verbunden? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Log parameters and metrics', 'Parameter und Metriken protokollieren'], ['Store run artifacts', 'Run-Artefakte speichern'], ['Track experiments from local and remote execution', 'Experimente aus lokaler und entfernter Ausführung nachverfolgen'], ['Create traffic rules for batch endpoints', 'Traffic-Regeln für Batchendpunkte erstellen'], ['Scale compute clusters automatically', 'Computecluster automatisch skalieren']], correct: [0, 1, 2], explanation: t('MLflow integration focuses on experiment tracking and artifact management across execution environments. It does not configure endpoint routing or cluster autoscaling.', 'Die MLflow-Integration konzentriert sich auf Experiment-Tracking und Artefaktverwaltung über verschiedene Ausführungsumgebungen hinweg. Sie konfiguriert weder Endpunkt-Routing noch Cluster-Autoskalierung.'), hint: t('Choose the answers about experiment tracking and artifacts.', 'Wählen Sie die Antworten zu Experiment-Tracking und Artefakten aus.'), reference: ref.mlflow },
    { id: 'dp100-260', domain: explore, difficulty: 'hard', question: t('Which two statements about pipeline components are correct? Choose all that apply.', 'Welche zwei Aussagen über Pipeline-Komponenten sind korrekt? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Components expose typed inputs and outputs', 'Komponenten stellen typisierte Ein- und Ausgaben bereit'], ['Components improve reuse across pipelines', 'Komponenten verbessern die Wiederverwendung über Pipelines hinweg'], ['Components replace model registration', 'Komponenten ersetzen die Modellregistrierung'], ['Components exist only for endpoint monitoring', 'Komponenten existieren nur für das Endpunkt-Monitoring']], correct: [0, 1], explanation: t('Components define reusable pipeline interfaces and logic. They do not replace model governance and they are unrelated to endpoint monitoring.', 'Komponenten definieren wiederverwendbare Pipeline-Schnittstellen und Logik. Sie ersetzen keine Modell-Governance und haben nichts mit Endpunkt-Monitoring zu tun.'), hint: t('Pick the answers about reusable pipeline interfaces.', 'Wählen Sie die Antworten zu wiederverwendbaren Pipeline-Schnittstellen aus.'), reference: ref.pipelines },
    { id: 'dp100-261', domain: prepare, difficulty: 'medium', question: t('Which three assets are central to a custom online inference deployment? Choose all that apply.', 'Welche drei Bestände sind zentral für eine benutzerdefinierte Online-Inferenzbereitstellung? Wählen Sie alle zutreffenden Antworten aus.'), options: [['A registered model', 'Ein registriertes Modell'], ['An environment', 'Eine Umgebung'], ['A scoring script', 'Ein Bewertungsskript'], ['A confusion matrix', 'Eine Konfusionsmatrix'], ['An Azure Monitor alert rule', 'Eine Azure-Monitor-Warnregel']], correct: [0, 1, 2], explanation: t('A custom online deployment is built around the model, the environment that contains dependencies, and the scoring script that handles requests. Evaluation artifacts and alert rules are useful later but are not deployment building blocks.', 'Eine benutzerdefinierte Online-Bereitstellung basiert auf dem Modell, der Umgebung mit den Abhängigkeiten und dem Bewertungsskript für die Anforderungsverarbeitung. Auswertungsartefakte und Warnregeln sind später nützlich, gehören aber nicht zu den Bereitstellungsbausteinen.'), hint: t('Choose the core ingredients of the inference container.', 'Wählen Sie die Kernbestandteile des Inferenzcontainers aus.'), reference: ref.deployOnline },
    { id: 'dp100-262', domain: prepare, difficulty: 'medium', question: t('Which two requirements point to a batch endpoint rather than a managed online endpoint? Choose all that apply.', 'Welche zwei Anforderungen sprechen für einen Batchendpunkt statt für einen verwalteten Onlineendpunkt? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Large-scale file-based scoring', 'Dateibasiertes Scoring in großem Maßstab'], ['Asynchronous execution', 'Asynchrone Ausführung'], ['Subsecond response per request', 'Antwortzeiten pro Anfrage im Subsekundenbereich'], ['Interactive notebook authoring', 'Interaktive Notebook-Erstellung']], correct: [0, 1], explanation: t('Batch endpoints are designed for asynchronous, file-oriented workloads at scale. Subsecond request-response scenarios belong to online endpoints, and notebook authoring is a development concern.', 'Batchendpunkte sind für asynchrone, dateiorientierte Workloads im großen Maßstab ausgelegt. Anforderungs-Antwort-Szenarien im Subsekundenbereich gehören zu Onlineendpunkten, und die Notebook-Erstellung ist ein Entwicklungsthema.'), hint: t('Pick the answers about asynchronous file processing.', 'Wählen Sie die Antworten zur asynchronen Dateiverarbeitung aus.'), reference: ref.batch },
    { id: 'dp100-263', domain: prepare, difficulty: 'medium', question: t('Which three benefits come from registering models before release? Choose all that apply.', 'Welche drei Vorteile ergeben sich aus der Registrierung von Modellen vor der Freigabe? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Versioning', 'Versionierung'], ['Tags and properties', 'Tags und Eigenschaften'], ['Controlled promotion to deployment', 'Kontrollierte Promotion zur Bereitstellung'], ['Automatic endpoint autoscale', 'Automatische Endpunkt-Autoskalierung'], ['Automatic creation of datastores', 'Automatische Erstellung von Datastores']], correct: [0, 1, 2], explanation: t('Model registration provides governance and traceability through versions and metadata and supports controlled promotion into deployment flows. Autoscaling and datastore creation are separate concerns.', 'Die Modellregistrierung bietet Governance und Nachvollziehbarkeit durch Versionen und Metadaten und unterstützt die kontrollierte Promotion in Bereitstellungsabläufe. Autoskalierung und Datastore-Erstellung sind davon getrennte Themen.'), hint: t('Choose the answers about model governance and release readiness.', 'Wählen Sie die Antworten zu Modell-Governance und Release-Bereitschaft aus.'), reference: ref.models },
    { id: 'dp100-264', domain: prepare, difficulty: 'hard', question: t('Which two steps best reduce risk before deploying a new inference container to production? Choose all that apply.', 'Welche zwei Schritte reduzieren das Risiko am besten, bevor ein neuer Inferenzcontainer in die Produktion geht? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Test locally first', 'Zuerst lokal testen'], ['Create a second deployment and shift traffic gradually', 'Eine zweite Bereitstellung erstellen und den Verkehr schrittweise verlagern'], ['Overwrite the stable deployment directly', 'Die stabile Bereitstellung direkt überschreiben'], ['Store secrets in code for convenience', 'Geheimnisse der Einfachheit halber im Code speichern']], correct: [0, 1], explanation: t('Local testing catches packaging issues early, and gradual traffic shifting reduces blast radius in production. Overwriting the stable deployment and embedding secrets both increase operational risk.', 'Lokales Testen erkennt Paketierungsprobleme frühzeitig, und die schrittweise Verkehrsverlagerung reduziert den möglichen Schaden in der Produktion. Das direkte Überschreiben der stabilen Bereitstellung und das Einbetten von Geheimnissen erhöhen dagegen das Betriebsrisiko.'), hint: t('Pick one preproduction action and one safe rollout action.', 'Wählen Sie eine Maßnahme vor der Produktion und eine für den sicheren Rollout aus.'), reference: ref.deployOnline },
    { id: 'dp100-265', domain: prepare, difficulty: 'hard', question: t('Which two statements about managed online endpoints are correct? Choose all that apply.', 'Welche zwei Aussagen über verwaltete Onlineendpunkte sind korrekt? Wählen Sie alle zutreffenden Antworten aus.'), options: [['One endpoint can front multiple deployments', 'Ein Endpunkt kann mehrere Bereitstellungen bereitstellen'], ['The endpoint provides a stable scoring URL', 'Der Endpunkt stellt eine stabile Scoring-URL bereit'], ['Batch endpoints are required for real-time scoring', 'Batchendpunkte sind für Echtzeit-Scoring erforderlich'], ['Online endpoints cannot use token authentication', 'Onlineendpunkte können keine Tokenauthentifizierung verwenden']], correct: [0, 1], explanation: t('Managed online endpoints give clients one stable URL while allowing multiple deployments behind it. Real-time scoring does not require batch endpoints, and token-based access is supported.', 'Verwaltete Onlineendpunkte bieten Clients eine stabile URL und erlauben gleichzeitig mehrere Bereitstellungen dahinter. Für Echtzeit-Scoring sind keine Batchendpunkte erforderlich, und tokenbasierter Zugriff wird unterstützt.'), hint: t('Choose the answers about stable routing for real-time scoring.', 'Wählen Sie die Antworten zur stabilen Weiterleitung für Echtzeit-Scoring aus.'), reference: ref.online },
    { id: 'dp100-266', domain: deploy, difficulty: 'medium', question: t('Which two Azure Monitor signals are useful for endpoint health? Choose all that apply.', 'Welche zwei Azure-Monitor-Signale sind für die Endpunktgesundheit nützlich? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Request latency', 'Anforderungslatenz'], ['Error rate or failed requests', 'Fehlerrate oder fehlgeschlagene Anforderungen'], ['Model registry tags', 'Modell-Registry-Tags'], ['Package version list', 'Liste der Paketversionen']], correct: [0, 1], explanation: t('Latency and failure metrics directly describe service health and user impact. Tags and package lists may matter for governance, but they are not health signals.', 'Latenz- und Fehlermetriken beschreiben direkt die Servicegesundheit und die Auswirkungen auf Benutzer. Tags und Paketlisten können für Governance wichtig sein, sind aber keine Gesundheitssignale.'), hint: t('Pick the answers that measure runtime behavior.', 'Wählen Sie die Antworten aus, die das Laufzeitverhalten messen.'), reference: ref.monitor },
    { id: 'dp100-267', domain: deploy, difficulty: 'medium', question: t('Which three stages usually belong in a closed-loop retraining workflow? Choose all that apply.', 'Welche drei Phasen gehören üblicherweise zu einem Closed-Loop-Retraining-Workflow? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Prepare data', 'Daten vorbereiten'], ['Train and evaluate', 'Trainieren und auswerten'], ['Register the approved model', 'Das freigegebene Modell registrieren'], ['Split endpoint traffic', 'Endpunktverkehr aufteilen'], ['Open a notebook terminal', 'Ein Notebook-Terminal öffnen']], correct: [0, 1, 2], explanation: t('A closed-loop retraining process prepares data, trains and evaluates a candidate, and then registers the approved model. Traffic management may happen later, and opening a notebook terminal is not a workflow stage.', 'Ein Closed-Loop-Retraining-Prozess bereitet Daten vor, trainiert und bewertet einen Kandidaten und registriert anschließend das freigegebene Modell. Traffic-Management kann später erfolgen, und das Öffnen eines Notebook-Terminals ist keine Workflow-Phase.'), hint: t('Choose the steps that move a model through the retraining lifecycle.', 'Wählen Sie die Schritte aus, die ein Modell durch den Retraining-Lebenszyklus führen.'), reference: ref.schedule },
    { id: 'dp100-268', domain: deploy, difficulty: 'medium', question: t('Which two reasons justify using a pipeline schedule for recurring inference or retraining? Choose all that apply.', 'Welche zwei Gründe rechtfertigen die Verwendung eines Pipelineszeitplans für wiederkehrende Inferenz oder Retraining? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Repeated execution on a cadence', 'Wiederholte Ausführung in einem festen Rhythmus'], ['Orchestration of dependent steps', 'Orchestrierung abhängiger Schritte'], ['Support for personal notebook editing', 'Unterstützung für persönliche Notebook-Bearbeitung'], ['Replacement of model registration', 'Ersatz der Modellregistrierung']], correct: [0, 1], explanation: t('Pipeline schedules are valuable because they automate recurring runs and preserve the orchestration of dependent steps. They do not replace model governance or interactive authoring tools.', 'Pipelineszeitpläne sind wertvoll, weil sie wiederkehrende Läufe automatisieren und die Orchestrierung abhängiger Schritte erhalten. Sie ersetzen weder Modell-Governance noch interaktive Authoring-Werkzeuge.'), hint: t('Pick the answers about recurring automation and orchestration.', 'Wählen Sie die Antworten zu wiederkehrender Automatisierung und Orchestrierung aus.'), reference: ref.schedule },
    { id: 'dp100-269', domain: deploy, difficulty: 'hard', question: t('Which three actions improve rollback and release safety for online inference? Choose all that apply.', 'Welche drei Maßnahmen verbessern Rollback-Fähigkeit und Release-Sicherheit für Online-Inferenz? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Keep a stable deployment available', 'Eine stabile Bereitstellung verfügbar halten'], ['Shift traffic gradually', 'Verkehr schrittweise verlagern'], ['Monitor latency and failures during rollout', 'Latenz und Fehler während des Rollouts überwachen'], ['Delete the previous deployment before testing', 'Die vorherige Bereitstellung vor dem Test löschen'], ['Bypass monitoring to reduce noise', 'Monitoring aus Gründen geringerer Geräuschkulisse umgehen']], correct: [0, 1, 2], explanation: t('Rollback safety comes from preserving a known-good deployment, moving traffic gradually, and monitoring runtime behavior during release. Deleting the fallback path or disabling monitoring increases risk.', 'Rollback-Sicherheit entsteht dadurch, dass eine bekannte stabile Bereitstellung erhalten bleibt, der Verkehr schrittweise verlagert wird und das Laufzeitverhalten während des Releases überwacht wird. Das Löschen des Rückfallpfads oder das Deaktivieren des Monitorings erhöht das Risiko.'), hint: t('Choose the actions that preserve fallback and visibility.', 'Wählen Sie die Maßnahmen aus, die Rückfallpfad und Transparenz erhalten.'), reference: ref.monitor },
    { id: 'dp100-270', domain: deploy, difficulty: 'hard', question: t('Which two reasons make Application Insights useful for online inference troubleshooting? Choose all that apply.', 'Welche zwei Gründe machen Application Insights für die Fehlerbehebung bei Online-Inferenz nützlich? Wählen Sie alle zutreffenden Antworten aus.'), options: [['Capture traces and custom logs from user containers', 'Traces und benutzerdefinierte Protokolle aus Benutzercontainern erfassen'], ['Investigate request handling inside the deployed service', 'Die Anforderungsverarbeitung im bereitgestellten Dienst untersuchen'], ['Replace model registration', 'Die Modellregistrierung ersetzen'], ['Define hyperparameter search spaces', 'Hyperparametersuchräume definieren']], correct: [0, 1], explanation: t('Application Insights is valuable because it exposes what happens inside the inference service, including traces and custom logs. It is not a model governance or tuning feature.', 'Application Insights ist wertvoll, weil es sichtbar macht, was im Inferenzdienst geschieht, einschließlich Traces und benutzerdefinierter Protokolle. Es ist keine Funktion für Modell-Governance oder Tuning.'), hint: t('Pick the answers about runtime diagnostics inside the service.', 'Wählen Sie die Antworten zu Laufzeitdiagnosen innerhalb des Dienstes aus.'), reference: ref.monitor }
  ];
  var scenarios = [
    { id: 'dp100-271', domain: design, difficulty: 'easy', scenario: t('Contoso is building a fraud analytics platform with separate development, test, and production Azure Machine Learning workspaces. The platform team curates common environments, reusable components, and approved base models. Manual export and import between workspaces has already created version drift. Leadership wants one governed place to publish shared assets for every workspace.', 'Contoso baut eine Plattform für Betrugsanalysen mit getrennten Azure-Machine-Learning-Arbeitsbereichen für Entwicklung, Test und Produktion auf. Das Plattformteam kuratiert gemeinsame Umgebungen, wiederverwendbare Komponenten und freigegebene Basismodelle. Manueller Export und Import zwischen Arbeitsbereichen hat bereits zu Versionsabweichungen geführt. Die Leitung möchte einen geregelten Ort, an dem gemeinsame Bestände für alle Arbeitsbereiche veröffentlicht werden.'), question: t('What should Contoso use?', 'Was sollte Contoso verwenden?'), options: ['registry', 'datastore', 'computeCluster', 'batchEndpoint'], correct: [0], answer: 'registry' },
    { id: 'dp100-272', domain: design, difficulty: 'easy', scenario: t('Fabrikam assigns each data scientist a private Azure Machine Learning workspace. They need Jupyter notebooks, shell access, and the ability to install packages for exploratory work. The activity is personal and interactive rather than queued team training. The solution should feel like a managed workstation instead of a shared cluster.', 'Fabrikam weist jedem Data Scientist einen privaten Azure-Machine-Learning-Arbeitsbereich zu. Sie benötigen Jupyter-Notebooks, Shell-Zugriff und die Möglichkeit, Pakete für explorative Arbeit zu installieren. Die Aktivität ist persönlich und interaktiv und nicht als Teamtraining in Warteschlangen gedacht. Die Lösung soll sich wie eine verwaltete Arbeitsstation und nicht wie ein gemeinsam genutzter Cluster anfühlen.'), question: t('Which compute option should Fabrikam choose?', 'Welche Compute-Option sollte Fabrikam wählen?'), options: ['computeInstance', 'computeCluster', 'managedOnlineEndpoint', 'batchEndpoint'], correct: [0], answer: 'computeInstance' },
    { id: 'dp100-273', domain: design, difficulty: 'medium', scenario: t('Tailwind Traders trains demand forecasting models from files in Azure Data Lake Storage. Upstream systems overwrite those files every night after late corrections arrive. Auditors require the team to reproduce any historical training run exactly. The team therefore needs an immutable reference for each training snapshot.', 'Tailwind Traders trainiert Nachfrageprognosemodelle aus Dateien in Azure Data Lake Storage. Vorgelagerte Systeme überschreiben diese Dateien jede Nacht, nachdem späte Korrekturen eingegangen sind. Prüfer verlangen, dass das Team jeden historischen Trainingslauf exakt reproduzieren kann. Das Team benötigt deshalb einen unveränderlichen Verweis auf jeden Trainingssnapshot.'), question: t('What should the team reference in training jobs?', 'Worauf sollte das Team in Trainingsjobs verweisen?'), options: ['dataAssetVersion', 'datastore', 'computeInstance', 'azureMonitor'], correct: [0], answer: 'dataAssetVersion' },
    { id: 'dp100-274', domain: design, difficulty: 'easy', scenario: t('Litware stores raw training data in Azure Data Lake Storage Gen2. Several jobs and assets need to refer to the same storage account from the workspace by a consistent name. The platform team wants to rotate credentials or switch to identity-based access centrally. Data scientists should not keep storage connection details in every job definition.', 'Litware speichert rohe Trainingsdaten in Azure Data Lake Storage Gen2. Mehrere Jobs und Bestände sollen aus dem Arbeitsbereich mit einem konsistenten Namen auf dasselbe Speicherkonto verweisen. Das Plattformteam möchte Anmeldeinformationen zentral rotieren oder auf identitätsbasierten Zugriff umstellen. Data Scientists sollen Speicherdetails nicht in jeder Jobdefinition pflegen müssen.'), question: t('What should Litware create?', 'Was sollte Litware erstellen?'), options: ['datastore', 'modelRegistration', 'applicationInsights', 'trafficSplit'], correct: [0], answer: 'datastore' },
    { id: 'dp100-275', domain: design, difficulty: 'medium', scenario: t('Woodgrove Bank has separate teams for feature engineering, model training, and deployment. All teams must use the same approved Python packages and base image for regulatory consistency. Security also wants every dependency change to be versioned and reviewable. The bank needs one reusable asset for that dependency definition.', 'Woodgrove Bank hat getrennte Teams für Feature Engineering, Modelltraining und Bereitstellung. Alle Teams müssen aus regulatorischen Gründen dieselben freigegebenen Python-Pakete und dasselbe Basisimage verwenden. Die Sicherheitsabteilung verlangt zudem, dass jede Abhängigkeitsänderung versioniert und prüfbar ist. Die Bank benötigt dafür einen wiederverwendbaren Bestand.'), question: t('Which asset should the bank standardize on?', 'Auf welchen Bestand sollte die Bank standardisieren?'), options: ['environment', 'registry', 'computeCluster', 'confusionMatrix'], correct: [0], answer: 'environment' },
    { id: 'dp100-276', domain: design, difficulty: 'hard', scenario: t('Trey Research is building a shared machine learning platform for many study teams. A preprocessing step must be reusable in dozens of pipelines and expose a stable contract for its inputs and outputs. Different teams will call the step without editing its internal code. The platform team wants reuse and clear interfaces rather than copy-and-paste scripts.', 'Trey Research baut eine gemeinsame Machine-Learning-Plattform für viele Studienteams auf. Ein Vorverarbeitungsschritt muss in Dutzenden von Pipelines wiederverwendbar sein und einen stabilen Vertrag für Ein- und Ausgaben bereitstellen. Verschiedene Teams sollen den Schritt verwenden können, ohne den internen Code zu bearbeiten. Das Plattformteam möchte Wiederverwendung und klare Schnittstellen statt kopierter Skripte.'), question: t('What should Trey Research create?', 'Was sollte Trey Research erstellen?'), options: ['component', 'modelRegistration', 'computeCluster', 'managedOnlineEndpoint'], correct: [0], answer: 'component' },
    { id: 'dp100-277', domain: design, difficulty: 'hard', scenario: t('Datum Corporation trains models both on local developer machines and on Azure Machine Learning compute. Management wants one experiment history that captures parameters, metrics, and artifacts regardless of where the run started. The approach must work with an open source tracking standard already known to the team. They also want the same lineage visible when models are promoted later.', 'Datum Corporation trainiert Modelle sowohl auf lokalen Entwicklerrechnern als auch auf Azure-Machine-Learning-Compute. Das Management möchte eine gemeinsame Experimenthistorie, die Parameter, Metriken und Artefakte erfasst, unabhängig davon, wo der Lauf gestartet wurde. Der Ansatz soll mit einem Open-Source-Tracking-Standard arbeiten, den das Team bereits kennt. Außerdem soll dieselbe Herkunft sichtbar bleiben, wenn Modelle später hochgestuft werden.'), question: t('Which capability should Datum Corporation adopt?', 'Welche Funktion sollte Datum Corporation einführen?'), options: ['mlflow', 'azureMonitor', 'mltable', 'batchEndpoint'], correct: [0], answer: 'mlflow' },
    { id: 'dp100-278', domain: explore, difficulty: 'easy', scenario: t('Northwind Traders stores training data in many parquet files partitioned by year and month. Analysts want jobs to read those files as one tabular dataset with a declared schema. The team also wants a reusable asset instead of repeating file parsing logic in every notebook. Consistency matters more than ad hoc file handling.', 'Northwind Traders speichert Trainingsdaten in vielen Parquet-Dateien, partitioniert nach Jahr und Monat. Analysten möchten, dass Jobs diese Dateien als einen tabellarischen Datensatz mit deklariertem Schema lesen. Das Team möchte zudem einen wiederverwendbaren Bestand, statt in jedem Notebook dieselbe Dateilogik zu wiederholen. Konsistenz ist wichtiger als ad hoc Dateibehandlung.'), question: t('What should the team create?', 'Was sollte das Team erstellen?'), options: ['mltable', 'datastore', 'registry', 'modelRegistration'], correct: [0], answer: 'mltable' },
    { id: 'dp100-279', domain: explore, difficulty: 'medium', scenario: t('Humongous Insurance is training a claims triage model with many tunable hyperparameters. The team wants Azure Machine Learning to run many trials automatically and optimize a chosen metric. They have a fixed compute budget and do not want to submit each run manually. The goal is structured hyperparameter search, not a one-off script execution.', 'Humongous Insurance trainiert ein Modell zur Priorisierung von Schadensfällen mit vielen einstellbaren Hyperparametern. Das Team möchte, dass Azure Machine Learning viele Versuche automatisch ausführt und eine ausgewählte Metrik optimiert. Es gibt ein festes Compute-Budget, und einzelne Läufe sollen nicht manuell gestartet werden. Das Ziel ist eine strukturierte Hyperparametersuche und keine einmalige Skriptausführung.'), question: t('Which job type should the team use?', 'Welchen Jobtyp sollte das Team verwenden?'), options: ['sweepJob', 'commandJob', 'modelRegistration', 'azureMonitor'], correct: [0], answer: 'sweepJob' },
    { id: 'dp100-280', domain: explore, difficulty: 'medium', scenario: t('Proseware is building a churn model in which only a small percentage of customers actually leave. The data science team wants both training and validation datasets to reflect the same class balance. Without that safeguard, one split can look much easier than the other. They need the split strategy that preserves class proportions.', 'Proseware entwickelt ein Churn-Modell, bei dem nur ein kleiner Prozentsatz der Kunden tatsächlich abwandert. Das Data-Science-Team möchte, dass Trainings- und Validierungsdatensätze dieselbe Klassenbalance widerspiegeln. Ohne diese Absicherung kann ein Split deutlich einfacher wirken als der andere. Das Team benötigt daher die Split-Strategie, die Klassenverhältnisse erhält.'), question: t('Which split strategy should Proseware use?', 'Welche Split-Strategie sollte Proseware verwenden?'), options: [['Random split', 'Zufälliger Split'], 'stratifiedSplit', ['Hash partitioning by customer ID', 'Hash-Partitionierung nach Kunden-ID'], 'autoscale'], correct: [1], answer: 'stratifiedSplit' },
    { id: 'dp100-281', domain: explore, difficulty: 'medium', scenario: t('Contoso is running a large hyperparameter search for an image classifier on expensive GPU nodes. After a few epochs it becomes obvious that some trials are far behind the best ones. The team wants those poor candidates stopped automatically so the remaining budget goes to stronger runs. They need an early termination policy rather than a new objective metric.', 'Contoso führt eine große Hyperparametersuche für einen Bildklassifikator auf teuren GPU-Knoten aus. Nach einigen Epochen ist klar, dass einige Versuche weit hinter den besten zurückliegen. Das Team möchte diese schwachen Kandidaten automatisch stoppen, damit das restliche Budget in stärkere Läufe fließt. Benötigt wird also eine Richtlinie für frühes Beenden und keine neue Zielmetrik.'), question: t('Which tuning feature should Contoso configure?', 'Welche Tuning-Funktion sollte Contoso konfigurieren?'), options: ['banditPolicy', ['Median stopping policy', 'Median-Stopping-Richtlinie'], 'trafficSplit', 'computeInstance'], correct: [0], answer: 'banditPolicy' },
    { id: 'dp100-282', domain: explore, difficulty: 'hard', scenario: t('Fabrikam has a limited medical imaging dataset and cannot afford to reserve a large holdout set. The model quality estimate also varies too much when the team uses only one split. Researchers want a validation approach that reuses the labeled data more effectively while still producing a more stable estimate. The method should evaluate across multiple folds rather than one partition.', 'Fabrikam verfügt über einen begrenzten Datensatz medizinischer Bilder und kann es sich nicht leisten, einen großen Holdout-Satz zu reservieren. Außerdem schwankt die Schätzung der Modellqualität zu stark, wenn das Team nur einen Split verwendet. Die Forschenden möchten einen Validierungsansatz, der die gelabelten Daten effizienter nutzt und zugleich eine stabilere Schätzung liefert. Die Methode soll über mehrere Faltungen auswerten und nicht nur über eine Partition.'), question: t('Which validation approach should Fabrikam choose?', 'Welchen Validierungsansatz sollte Fabrikam wählen?'), options: [['Simple holdout split', 'Einfacher Holdout-Split'], 'crossValidation', 'trafficSplit', 'managedIdentity'], correct: [1], answer: 'crossValidation' },
    { id: 'dp100-283', domain: explore, difficulty: 'hard', scenario: t('Tailwind Traders already trains models with a supported open source framework. The team wants common metrics, parameters, and model artifacts captured automatically for every run. Engineers prefer not to add extensive manual logging code to each training script. They are looking for the Azure Machine Learning capability that integrates with MLflow in the most automatic way.', 'Tailwind Traders trainiert Modelle bereits mit einem unterstützten Open-Source-Framework. Das Team möchte, dass gängige Metriken, Parameter und Modellartefakte für jeden Lauf automatisch erfasst werden. Die Ingenieure möchten nicht in jedes Trainingsskript umfangreichen manuellen Logging-Code einbauen. Gesucht ist die Azure-Machine-Learning-Funktion, die am automatischsten mit MLflow integriert ist.'), question: t('What should the engineers enable?', 'Was sollten die Ingenieure aktivieren?'), options: ['mlflowAutolog', 'azureMonitor', 'modelRegistration', 'customBatchOutput'], correct: [0], answer: 'mlflowAutolog' },
    { id: 'dp100-284', domain: explore, difficulty: 'medium', scenario: t('Litware is building a pipeline with separate data preparation, training, and evaluation steps. The prepared dataset produced by the first step must be consumed directly by the next step without relying on ad hoc storage conventions. The team wants a typed, explicit handoff between steps. They are not trying to solve endpoint monitoring or deployment routing.', 'Litware baut eine Pipeline mit getrennten Schritten für Datenvorbereitung, Training und Auswertung auf. Der vom ersten Schritt erzeugte vorbereitete Datensatz muss direkt vom nächsten Schritt genutzt werden, ohne von ad hoc Speicher-Konventionen abzuhängen. Das Team möchte eine typisierte, explizite Übergabe zwischen den Schritten. Es geht dabei weder um Endpunkt-Monitoring noch um Bereitstellungs-Routing.'), question: t('What should the team use between the steps?', 'Was sollte das Team zwischen den Schritten verwenden?'), options: ['pipelineOutputs', 'computeCluster', 'registry', 'applicationInsights'], correct: [0], answer: 'pipelineOutputs' },
    { id: 'dp100-285', domain: prepare, difficulty: 'easy', scenario: t('Woodgrove Bank has approved a fraud detection model for release. Governance requires a version number, tags, and business metadata before the model can move further in the release process. The deployment team also wants a standard asset that later deployments can reference directly. The current model file sitting in a run output is not enough.', 'Woodgrove Bank hat ein Betrugserkennungsmodell für die Freigabe genehmigt. Die Governance verlangt eine Versionsnummer, Tags und fachliche Metadaten, bevor das Modell im Releaseprozess weitergehen darf. Das Bereitstellungsteam möchte außerdem einen Standardbestand, auf den spätere Bereitstellungen direkt verweisen können. Die aktuelle Modelldatei in einer Run-Ausgabe reicht dafür nicht aus.'), question: t('What should the bank do next?', 'Was sollte die Bank als Nächstes tun?'), options: ['modelRegistration', 'datastore', 'mlflow', 'applicationInsights'], correct: [0], answer: 'modelRegistration' },
    { id: 'dp100-286', domain: prepare, difficulty: 'medium', scenario: t('Trey Research is packaging a custom inference service for a clinical model. The container must load the model at startup and handle request payloads during scoring. The team already has the model file and dependency list. What is missing is the code artifact that defines the inference entry points.', 'Trey Research paketiert einen benutzerdefinierten Inferenzdienst für ein klinisches Modell. Der Container muss das Modell beim Start laden und Anforderungspayloads während des Scorings verarbeiten. Das Team hat die Modelldatei und die Abhängigkeitsliste bereits. Es fehlt jedoch noch das Codeartefakt, das die Inferenz-Einstiegspunkte definiert.'), question: t('What should the team provide?', 'Was sollte das Team bereitstellen?'), options: ['scoringScript', 'environment', 'pipelineSchedule', 'azureMonitor'], correct: [0], answer: 'scoringScript' },
    { id: 'dp100-287', domain: prepare, difficulty: 'medium', scenario: t('Datum Corporation must score millions of records delivered as files every night. Business users do not wait for immediate responses, and the output can be written after the job finishes. The team wants Azure Machine Learning to accept pointers to the input data and run asynchronously. They are not optimizing for a single low-latency request-response call.', 'Datum Corporation muss jede Nacht Millionen von als Dateien angelieferten Datensätzen bewerten. Fachanwender warten nicht auf sofortige Antworten, und die Ausgabe kann nach Abschluss des Jobs geschrieben werden. Das Team möchte, dass Azure Machine Learning Verweise auf die Eingabedaten entgegennimmt und asynchron ausführt. Es geht nicht um einen einzelnen Aufruf mit geringer Latenz im Request-Response-Stil.'), question: t('Which endpoint type should Datum Corporation use?', 'Welchen Endpunkttyp sollte Datum Corporation verwenden?'), options: ['batchEndpoint', 'managedOnlineEndpoint', 'computeInstance', 'modelRegistration'], correct: [0], answer: 'batchEndpoint' },
    { id: 'dp100-288', domain: prepare, difficulty: 'medium', scenario: t('Northwind Traders has built a custom inference container and wants to validate it before deploying to Azure. The team suspects there might be dependency or request-schema issues. They want the fastest way to debug those problems without first consuming cloud resources. Success means the container can be exercised on a local machine.', 'Northwind Traders hat einen benutzerdefinierten Inferenzcontainer erstellt und möchte ihn vor der Bereitstellung in Azure validieren. Das Team vermutet mögliche Probleme mit Abhängigkeiten oder dem Request-Schema. Es sucht nach dem schnellsten Weg, diese Probleme zu debuggen, ohne zuerst Cloud-Ressourcen zu verbrauchen. Erfolg bedeutet, dass der Container auf einem lokalen Rechner ausgeführt und getestet werden kann.'), question: t('What should the team do first?', 'Was sollte das Team zuerst tun?'), options: ['localDeployment', 'trafficSplit', 'banditPolicy', 'azureMonitor'], correct: [0], answer: 'localDeployment' },
    { id: 'dp100-289', domain: prepare, difficulty: 'medium', scenario: t('Humongous Insurance needs a stable public scoring URL for a real-time underwriting model. The release plan also calls for hosting both the current and the next deployment behind that same URL. Clients must not change their integration when a new deployment is added. The platform therefore needs endpoint-level indirection in front of deployments.', 'Humongous Insurance benötigt eine stabile öffentliche Scoring-URL für ein Echtzeitmodell zur Risikoprüfung. Der Releaseplan sieht außerdem vor, sowohl die aktuelle als auch die nächste Bereitstellung hinter derselben URL zu hosten. Clients dürfen ihre Integration nicht ändern müssen, wenn eine neue Bereitstellung hinzukommt. Die Plattform benötigt daher eine Endpunktabstraktion vor den Bereitstellungen.'), question: t('Which serving option fits best?', 'Welche Serving-Option passt am besten?'), options: ['managedOnlineEndpoint', 'batchEndpoint', 'datastore', 'confusionMatrix'], correct: [0], answer: 'managedOnlineEndpoint' },
    { id: 'dp100-290', domain: prepare, difficulty: 'hard', scenario: t('Proseware runs nightly batch inference for a pricing model. Downstream systems require both a parquet file of predictions and a separate summary file with custom naming. The default output file layout is therefore not sufficient. The deployment must explicitly control which files are written and how they are organized.', 'Proseware führt eine nächtliche Batch-Inferenz für ein Preismodell aus. Nachgelagerte Systeme benötigen sowohl eine Parquet-Datei mit Vorhersagen als auch eine separate Zusammenfassungsdatei mit benutzerdefinierter Benennung. Das Standardlayout der Ausgabedateien reicht daher nicht aus. Die Bereitstellung muss explizit steuern, welche Dateien geschrieben werden und wie sie organisiert sind.'), question: t('Which batch deployment feature should Proseware use?', 'Welche Funktion der Batchbereitstellung sollte Proseware verwenden?'), options: ['customBatchOutput', 'mlflowAutolog', 'managedIdentity', 'computeInstance'], correct: [0], answer: 'customBatchOutput' },
    { id: 'dp100-291', domain: prepare, difficulty: 'hard', scenario: t('Contoso exposes a real-time endpoint to internal applications across several business units. Security has prohibited long-lived shared keys in application configuration. The calling services already authenticate with Microsoft Entra ID and should continue using identity-based access. The endpoint must align with that security model.', 'Contoso stellt einen Echtzeitendpunkt für interne Anwendungen in mehreren Geschäftsbereichen bereit. Die Sicherheitsabteilung hat langlebige gemeinsame Schlüssel in Anwendungskonfigurationen untersagt. Die aufrufenden Dienste authentifizieren sich bereits mit Microsoft Entra ID und sollen identitätsbasierten Zugriff weiterverwenden. Der Endpunkt muss mit diesem Sicherheitsmodell übereinstimmen.'), question: t('Which authentication mode should Contoso choose?', 'Welchen Authentifizierungsmodus sollte Contoso wählen?'), options: ['tokenAuth', ['Primary and secondary keys', 'Primär- und Sekundärschlüssel'], ['Storage account key in the scoring script', 'Speicherkontoschlüssel im Bewertungsskript'], 'applicationInsights'], correct: [0], answer: 'tokenAuth' },
    { id: 'dp100-292', domain: prepare, difficulty: 'hard', scenario: t('Fabrikam wants to keep one public scoring URL while preparing a new version of a recommendation model. The current deployment must remain available until validation is complete. Product teams do not want clients to change endpoint addresses during the cutover. The platform therefore needs an endpoint layer that can sit in front of more than one deployment.', 'Fabrikam möchte während der Vorbereitung einer neuen Version eines Empfehlungsmodells eine öffentliche Scoring-URL beibehalten. Die aktuelle Bereitstellung muss verfügbar bleiben, bis die Validierung abgeschlossen ist. Die Produktteams möchten nicht, dass Clients während der Umstellung Endpunktadressen ändern müssen. Die Plattform benötigt daher eine Endpunktschicht, die vor mehr als einer Bereitstellung liegen kann.'), question: t('What should Fabrikam use as the serving architecture?', 'Was sollte Fabrikam als Serving-Architektur verwenden?'), options: ['managedOnlineEndpoint', 'modelRegistration', 'sweepJob', 'mltable'], correct: [0], answer: 'managedOnlineEndpoint' },
    { id: 'dp100-293', domain: deploy, difficulty: 'easy', scenario: t('Woodgrove Bank has already deployed a real-time fraud scoring service. Operations needs dashboards for latency, throughput, and failures over time. The same platform should also support alert rules when thresholds are crossed. The team is looking for the standard Azure monitoring foundation for those needs.', 'Woodgrove Bank hat bereits einen Echtzeitdienst für Betrugsscoring bereitgestellt. Der Betrieb benötigt Dashboards für Latenz, Durchsatz und Fehler im Zeitverlauf. Dieselbe Plattform soll außerdem Warnregeln unterstützen, wenn Schwellenwerte überschritten werden. Gesucht ist die Standardgrundlage von Azure für diese Überwachungsanforderungen.'), question: t('Which service should operations use?', 'Welchen Dienst sollte der Betrieb verwenden?'), options: ['azureMonitor', 'applicationInsights', 'mlflow', 'localDeployment'], correct: [0], answer: 'azureMonitor' },
    { id: 'dp100-294', domain: deploy, difficulty: 'hard', scenario: t('Trey Research deployed a clinical inference service and now sees intermittent request failures. The team wants traces and custom logs from inside the user container to understand where processing breaks down. Basic endpoint counters alone are not enough. They need deeper application-level diagnostics.', 'Trey Research hat einen klinischen Inferenzdienst bereitgestellt und sieht nun sporadische Anforderungsfehler. Das Team möchte Traces und benutzerdefinierte Protokolle aus dem Benutzercontainer, um zu verstehen, wo die Verarbeitung fehlschlägt. Einfache Endpunktzähler allein reichen nicht aus. Benötigt werden tiefere Diagnosen auf Anwendungsebene.'), question: t('Which tool should the team inspect?', 'Welches Werkzeug sollte das Team prüfen?'), options: ['applicationInsights', 'azureMonitor', 'mltable', 'registry'], correct: [0], answer: 'applicationInsights' },
    { id: 'dp100-295', domain: deploy, difficulty: 'medium', scenario: t('Datum Corporation wants its churn model to retrain every Sunday night. The workflow already contains data preparation, training, evaluation, and registration steps. Operators do not want to start the pipeline manually each week. They need a built-in recurring trigger for the pipeline.', 'Datum Corporation möchte sein Churn-Modell jeden Sonntagabend neu trainieren. Der Workflow enthält bereits Schritte für Datenvorbereitung, Training, Auswertung und Registrierung. Die Operatoren möchten die Pipeline nicht jede Woche manuell starten. Benötigt wird daher ein integrierter wiederkehrender Trigger für die Pipeline.'), question: t('Which feature should the operators configure?', 'Welche Funktion sollten die Operatoren konfigurieren?'), options: ['pipelineSchedule', 'trafficSplit', 'modelRegistration', 'localDeployment'], correct: [0], answer: 'pipelineSchedule' },
    { id: 'dp100-296', domain: deploy, difficulty: 'medium', scenario: t('Northwind Traders publishes a fresh folder of transactions every night and wants predictions generated automatically before the business day starts. No user waits for an immediate response, and the scoring logic already exists. The team is looking for the built-in way to launch that recurring workflow on a cadence. The aim is scheduled execution, not a new development environment.', 'Northwind Traders veröffentlicht jede Nacht einen neuen Ordner mit Transaktionen und möchte, dass die Vorhersagen automatisch vor Beginn des Geschäftstages erzeugt werden. Kein Benutzer wartet auf eine sofortige Antwort, und die Scoring-Logik existiert bereits. Das Team sucht nach der integrierten Möglichkeit, diesen wiederkehrenden Workflow nach einem Zeitplan zu starten. Ziel ist die geplante Ausführung und keine neue Entwicklungsumgebung.'), question: t('What should Northwind Traders configure?', 'Was sollte Northwind Traders konfigurieren?'), options: ['pipelineSchedule', 'computeCluster', 'azureMonitor', 'tokenAuth'], correct: [0], answer: 'pipelineSchedule' },
    { id: 'dp100-297', domain: deploy, difficulty: 'medium', scenario: t('Humongous Insurance serves predictions through a managed online endpoint. Operations wants an automated notification when p95 latency rises or the failure rate exceeds a threshold. They also want the supporting data visible in dashboards for investigation. The alerting solution should be based on the same monitoring platform that stores the metrics.', 'Humongous Insurance stellt Vorhersagen über einen verwalteten Onlineendpunkt bereit. Der Betrieb möchte eine automatische Benachrichtigung, wenn die p95-Latenz steigt oder die Fehlerrate einen Schwellenwert überschreitet. Außerdem sollen die zugrunde liegenden Daten in Dashboards zur Untersuchung sichtbar sein. Die Warnlösung soll auf derselben Überwachungsplattform basieren, die auch die Metriken speichert.'), question: t('Which service should the team use for the alerting foundation?', 'Welchen Dienst sollte das Team als Grundlage für die Warnungen verwenden?'), options: ['azureMonitor', 'featureImportance', 'datastore', 'component'], correct: [0], answer: 'azureMonitor' },
    { id: 'dp100-298', domain: deploy, difficulty: 'hard', scenario: t('Proseware is releasing a new ranking model for its commerce site. Leadership wants only 10 percent of live traffic to reach the new deployment at first while the rest continues to use the stable version. If latency or errors degrade, the change must be reversible immediately. The endpoint URL itself must remain unchanged for clients.', 'Proseware veröffentlicht ein neues Ranking-Modell für seine Commerce-Plattform. Die Leitung möchte, dass zunächst nur 10 Prozent des Live-Verkehrs die neue Bereitstellung erreichen, während der Rest weiterhin die stabile Version nutzt. Wenn Latenz oder Fehler schlechter werden, muss die Änderung sofort rückgängig gemacht werden können. Die Endpunkt-URL selbst muss für Clients unverändert bleiben.'), question: t('Which rollout technique should Proseware use?', 'Welche Rollout-Technik sollte Proseware verwenden?'), options: ['trafficSplit', 'modelRegistration', 'stratifiedSplit', 'dataAssetVersion'], correct: [0], answer: 'trafficSplit' },
    { id: 'dp100-299', domain: deploy, difficulty: 'hard', scenario: t('Contoso runs monthly risk scoring across the entire customer base and writes the results to storage for downstream ETL. The workload processes large files and is not interactive. The company wants the serving pattern that is optimized for asynchronous, high-volume scoring jobs. Real-time request-response serving would add cost without benefit.', 'Contoso führt monatlich ein Risikoscoring für den gesamten Kundenbestand durch und schreibt die Ergebnisse für nachgelagertes ETL in den Speicher. Der Workload verarbeitet große Dateien und ist nicht interaktiv. Das Unternehmen möchte das Serving-Muster, das für asynchrone Scoring-Jobs mit hohem Volumen optimiert ist. Echtzeit-Serving im Request-Response-Stil würde Kosten ohne Nutzen verursachen.'), question: t('Which serving option should Contoso use?', 'Welche Serving-Option sollte Contoso verwenden?'), options: ['batchEndpoint', 'computeInstance', 'managedIdentity', 'confusionMatrix'], correct: [0], answer: 'batchEndpoint' },
    { id: 'dp100-300', domain: deploy, difficulty: 'hard', scenario: t('Fabrikam wants to operationalize its full model refresh process. New source data must be prepared, a candidate model must be trained and evaluated, and the approved result must be registered before release. The company does not want these steps coordinated manually each time. It needs one orchestrated workflow for the full retraining loop.', 'Fabrikam möchte seinen vollständigen Modellaktualisierungsprozess operationalisieren. Neue Quelldaten müssen vorbereitet, ein Kandidatenmodell trainiert und bewertet und das freigegebene Ergebnis vor der Veröffentlichung registriert werden. Das Unternehmen möchte diese Schritte nicht jedes Mal manuell koordinieren. Es benötigt einen orchestrierten Workflow für den gesamten Retraining-Kreislauf.'), question: t('Which design should Fabrikam implement?', 'Welches Design sollte Fabrikam implementieren?'), options: ['retrainingPipeline', 'modelRegistration', 'azureMonitor', 'trafficSplit'], correct: [0], answer: 'retrainingPipeline' }
  ];

  var extra = [];

  singles.forEach(function(item) {
    extra.push(q(
      item.id,
      'single',
      item.domain,
      item.difficulty,
      null,
      item.question,
      mapOptions(item.options),
      mapCorrect(item.correct),
      genericExplanation(item.answer),
      genericHint(item.answer),
      concepts[item.answer].reference
    ));
  });

  multiples.forEach(function(item) {
    extra.push(q(
      item.id,
      'multiple',
      item.domain,
      item.difficulty,
      null,
      item.question,
      mapOptions(item.options),
      mapCorrect(item.correct),
      item.explanation,
      item.hint,
      item.reference
    ));
  });

  scenarios.forEach(function(item) {
    extra.push(q(
      item.id,
      'scenario',
      item.domain,
      item.difficulty,
      item.scenario,
      item.question,
      mapOptions(item.options),
      mapCorrect(item.correct),
      genericExplanation(item.answer),
      genericHint(item.answer),
      concepts[item.answer].reference
    ));
  });

  if (window.ExamData && window.ExamData['dp-100']) {
    window.ExamData['dp-100'].questions = window.ExamData['dp-100'].questions.concat(extra);
  }
})();
