McAfee-Secured Website

Exam Code: AI-300

Exam Name: Operationalizing Machine Learning and Generative AI Solutions

Certification Provider: Microsoft

Corresponding Certification: Microsoft Certified: Machine Learning Operations Engineer Associate

100% Microsoft AI-300 Guaranteed Success With Testking Training Materials

Get Real AI-300 Exam Questions & Expert Verified Answers as Experienced on the Real Exam!

213 Questions & Answers with Testing Engine

"Operationalizing Machine Learning and Generative AI Solutions Exam", also known as AI-300 exam, is a Microsoft certification exam.

Pass your tests with the always up-to-date AI-300 Exam Engine. Your AI-300 training materials keep you at the head of the pack!

Satisfaction Guaranteed

Money Back Guarantee

Testking provides hassle-free money back guarantee with our products. That is because we have 100% trust in the abilities of our professional and experience product team, and our record is a proof of that.

99.6% PASS RATE
Was: $137.49
Now: $124.99

Microsoft AI-300 Practice Test 27

Question 260

An online scoring API waits seconds to retrieve every feature although the business latency budget is 100 ms. What should the team specify?

  1. Design a low-latency online feature retrieval path and validate its performance in the model package.
  2. Package only the retrieval interface and fetch credentials from a managed runtime secret store.
  3. Include a tested input-feature schema and retrieval mapping in the model contract.
  4. Use time-consistent feature retrieval tied to each prediction event timestamp.

Explanation

Correct Answer

A:

Real-time inference must fit feature access latency into the endpoint SLA, not only model computation time.

Incorrect Answers

B:

Package only the retrieval interface and fetch credentials from a managed runtime secret store. This is useful for the distinct issue: A model needs a third-party feature API, but developers embed its token in the serialized model artifact. The relevant technical rationale or evidence for that issue is: Model artifacts may be redistributed; separating secrets from interface metadata avoids credential leakage across consumers. Here the reported issue is: An online scoring API waits seconds to retrieve every feature although the business latency budget is 100 ms. The relevant response is: Design a low-latency online feature retrieval path and validate its performance in the model package. The first result cannot verify this different correction: Real-time inference must fit feature access latency into the endpoint SLA, not only model computation time.

C:

Include a tested input-feature schema and retrieval mapping in the model contract. It addresses another case: Production model calls fail because online feature lookups return a different field name from the training pipeline. For that case, the distinguishing justification or acceptance check is: Schema and mapping metadata prevent silent training-serving differences in feature names and data types. The present case instead states: An online scoring API waits seconds to retrieve every feature although the business latency budget is 100 ms. It calls for Design a low-latency online feature retrieval path and validate its performance in the model package. Showing success for the other case would not establish: Real-time inference must fit feature access latency into the endpoint SLA, not only model computation time.

D:

The alternative, Use time-consistent feature retrieval tied to each prediction event timestamp, belongs to a different technical condition: A fraud model trained using point-in-time account balances but production code reads the latest balance for old records during batch replay. There the source-specific mechanism or proof is: Point-in-time lookup avoids hindsight leakage and makes historical inference comparable to the original live decision. The condition asked about here is: An online scoring API waits seconds to retrieve every feature although the business latency budget is 100 ms. A suitable correction is Design a low-latency online feature retrieval path and validate its performance in the model package; the targeted justification or result is: Real-time inference must fit feature access latency into the endpoint SLA, not only model computation time.

Question 261

A production feature service temporarily returns missing values; the trained model cannot accept nulls. What decision belongs in the model's feature specification?

  1. Specify the feature timestamp and time-zone normalization contract explicitly.
  2. Use a named and versioned feature schema with explicit column alignment.
  3. Design a low-latency online feature retrieval path and validate its performance in the model package.
  4. Document and test supported missing-feature handling and defaults.

Explanation

Correct Answer

D:

A declared missing-value policy prevents ad hoc serving-time substitutions that can invalidate training assumptions.

Incorrect Answers

A:

Specify the feature timestamp and time-zone normalization contract explicitly. A separate source case supports that approach when: A feature retrieval function uses a hard-coded default time zone and shifts calendar features after deployment. The supporting rationale or observable result is: Time semantics are part of feature generation; undocumented server-local time zones change model inputs across environments. This question describes a different issue: A production feature service temporarily returns missing values; the trained model cannot accept nulls. Address it through Document and test supported missing-feature handling and defaults, with the required justification or evidence: A declared missing-value policy prevents ad hoc serving-time substitutions that can invalidate training assumptions.

B:

Use a named and versioned feature schema with explicit column alignment. This is useful for the distinct issue: Two runtime services consume the same model but supply differently ordered raw input arrays. The relevant technical rationale or evidence for that issue is: Named feature contracts avoid relying on accidental column order between training and inference client implementations. Here the reported issue is: A production feature service temporarily returns missing values; the trained model cannot accept nulls. The relevant response is: Document and test supported missing-feature handling and defaults. The first result cannot verify this different correction: A declared missing-value policy prevents ad hoc serving-time substitutions that can invalidate training assumptions.

C:

Design a low-latency online feature retrieval path and validate its performance in the model package. It addresses another case: An online scoring API waits seconds to retrieve every feature although the business latency budget is 100 ms. For that case, the distinguishing justification or acceptance check is: Real-time inference must fit feature access latency into the endpoint SLA, not only model computation time. The present case instead states: A production feature service temporarily returns missing values; the trained model cannot accept nulls. It calls for Document and test supported missing-feature handling and defaults. Showing success for the other case would not establish: A declared missing-value policy prevents ad hoc serving-time substitutions that can invalidate training assumptions.

Question 262

A fraud model trained using point-in-time account balances but production code reads the latest balance for old records during batch replay. What should the feature specification require?

  1. Pin the exact feature-set name and version required by the model.
  2. Record external feature-source dependencies and their ownership as part of the model contract.
  3. Use time-consistent feature retrieval tied to each prediction event timestamp.
  4. Package the exact transformation logic and preprocessing parameters with the model.

Explanation

Correct Answer

C:

Point-in-time lookup avoids hindsight leakage and makes historical inference comparable to the original live decision.

Incorrect Answers

A:

Pin the exact feature-set name and version required by the model. That operation would be relevant if: A feature store contains several versions of customer_age but the deployed model expects the training-time version. Its corresponding reason or verification is: An explicit feature version prevents a deployment from silently reading an incompatible revised definition. However the problem in this question is: A fraud model trained using point-in-time account balances but production code reads the latest balance for old records during batch replay. The requirement instead calls for Use time-consistent feature retrieval tied to each prediction event timestamp; the question-specific check is: Point-in-time lookup avoids hindsight leakage and makes historical inference comparable to the original live decision.

B:

Record external feature-source dependencies and their ownership as part of the model contract. A separate source case supports that approach when: A deployed model's feature source is deleted, but the model registry still advertises the version as deployable. The supporting rationale or observable result is: Versioned model metadata must identify required feature systems so operations can detect and repair missing dependencies. This question describes a different issue: A fraud model trained using point-in-time account balances but production code reads the latest balance for old records during batch replay. Address it through Use time-consistent feature retrieval tied to each prediction event timestamp, with the required justification or evidence: Point-in-time lookup avoids hindsight leakage and makes historical inference comparable to the original live decision.

D:

Package the exact transformation logic and preprocessing parameters with the model. This is useful for the distinct issue: A data scientist uses one feature transformation in training and a different normalization constant in online scoring. The relevant technical rationale or evidence for that issue is: Identical feature processing is necessary to avoid training-serving skew caused by mismatched normalization steps. Here the reported issue is: A fraud model trained using point-in-time account balances but production code reads the latest balance for old records during batch replay. The relevant response is: Use time-consistent feature retrieval tied to each prediction event timestamp. The first result cannot verify this different correction: Point-in-time lookup avoids hindsight leakage and makes historical inference comparable to the original live decision.

Question 263

A model needs a third-party feature API, but developers embed its token in the serialized model artifact. What should be packaged instead?

  1. Use a named and versioned feature schema with explicit column alignment.
  2. Package only the retrieval interface and fetch credentials from a managed runtime secret store.
  3. Specify the feature timestamp and time-zone normalization contract explicitly.
  4. Package the feature retrieval and transformation specification with the registered model.

Explanation

Correct Answer

B:

Model artifacts may be redistributed; separating secrets from interface metadata avoids credential leakage across consumers.

Incorrect Answers

A:

The alternative, Use a named and versioned feature schema with explicit column alignment, belongs to a different technical condition: Two runtime services consume the same model but supply differently ordered raw input arrays. There the source-specific mechanism or proof is: Named feature contracts avoid relying on accidental column order between training and inference client implementations. The condition asked about here is: A model needs a third-party feature API, but developers embed its token in the serialized model artifact. A suitable correction is Package only the retrieval interface and fetch credentials from a managed runtime secret store; the targeted justification or result is: Model artifacts may be redistributed; separating secrets from interface metadata avoids credential leakage across consumers.

C:

Specify the feature timestamp and time-zone normalization contract explicitly. That operation would be relevant if: A feature retrieval function uses a hard-coded default time zone and shifts calendar features after deployment. Its corresponding reason or verification is: Time semantics are part of feature generation; undocumented server-local time zones change model inputs across environments. However the problem in this question is: A model needs a third-party feature API, but developers embed its token in the serialized model artifact. The requirement instead calls for Package only the retrieval interface and fetch credentials from a managed runtime secret store; the question-specific check is: Model artifacts may be redistributed; separating secrets from interface metadata avoids credential leakage across consumers.

D:

Package the feature retrieval and transformation specification with the registered model. A separate source case supports that approach when: A recommendation model was trained using customer features with specific transformations, but the package contains only serialized weights. The supporting rationale or observable result is: Serving requires the same feature definitions and lookup behavior as training; weights alone do not describe that input contract. This question describes a different issue: A model needs a third-party feature API, but developers embed its token in the serialized model artifact. Address it through Package only the retrieval interface and fetch credentials from a managed runtime secret store, with the required justification or evidence: Model artifacts may be redistributed; separating secrets from interface metadata avoids credential leakage across consumers.

Question 264

A data scientist uses one feature transformation in training and a different normalization constant in online scoring. What should be shared?

  1. Package the exact transformation logic and preprocessing parameters with the model.
  2. Design a low-latency online feature retrieval path and validate its performance in the model package.
  3. Record external feature-source dependencies and their ownership as part of the model contract.
  4. Use time-consistent feature retrieval tied to each prediction event timestamp.

Explanation

Correct Answer

A:

Identical feature processing is necessary to avoid training-serving skew caused by mismatched normalization steps.

Incorrect Answers

B:

Design a low-latency online feature retrieval path and validate its performance in the model package. It addresses another case: An online scoring API waits seconds to retrieve every feature although the business latency budget is 100 ms. For that case, the distinguishing justification or acceptance check is: Real-time inference must fit feature access latency into the endpoint SLA, not only model computation time. The present case instead states: A data scientist uses one feature transformation in training and a different normalization constant in online scoring. It calls for Package the exact transformation logic and preprocessing parameters with the model. Showing success for the other case would not establish: Identical feature processing is necessary to avoid training-serving skew caused by mismatched normalization steps.

C:

The alternative, Record external feature-source dependencies and their ownership as part of the model contract, belongs to a different technical condition: A deployed model's feature source is deleted, but the model registry still advertises the version as deployable. There the source-specific mechanism or proof is: Versioned model metadata must identify required feature systems so operations can detect and repair missing dependencies. The condition asked about here is: A data scientist uses one feature transformation in training and a different normalization constant in online scoring. A suitable correction is Package the exact transformation logic and preprocessing parameters with the model; the targeted justification or result is: Identical feature processing is necessary to avoid training-serving skew caused by mismatched normalization steps.

D:

Use time-consistent feature retrieval tied to each prediction event timestamp. That operation would be relevant if: A fraud model trained using point-in-time account balances but production code reads the latest balance for old records during batch replay. Its corresponding reason or verification is: Point-in-time lookup avoids hindsight leakage and makes historical inference comparable to the original live decision. However the problem in this question is: A data scientist uses one feature transformation in training and a different normalization constant in online scoring. The requirement instead calls for Package the exact transformation logic and preprocessing parameters with the model; the question-specific check is: Identical feature processing is necessary to avoid training-serving skew caused by mismatched normalization steps.

Question 265

A deployed model's feature source is deleted, but the model registry still advertises the version as deployable. What should its metadata record?

  1. Specify the feature timestamp and time-zone normalization contract explicitly.
  2. Validate offline-to-online feature parity and document equivalent transformations.
  3. Document and test supported missing-feature handling and defaults.
  4. Record external feature-source dependencies and their ownership as part of the model contract.

Explanation

Correct Answer

D:

Versioned model metadata must identify required feature systems so operations can detect and repair missing dependencies.

Incorrect Answers

A:

Specify the feature timestamp and time-zone normalization contract explicitly. This is useful for the distinct issue: A feature retrieval function uses a hard-coded default time zone and shifts calendar features after deployment. The relevant technical rationale or evidence for that issue is: Time semantics are part of feature generation; undocumented server-local time zones change model inputs across environments. Here the reported issue is: A deployed model's feature source is deleted, but the model registry still advertises the version as deployable. The relevant response is: Record external feature-source dependencies and their ownership as part of the model contract. The first result cannot verify this different correction: Versioned model metadata must identify required feature systems so operations can detect and repair missing dependencies.

B:

Validate offline-to-online feature parity and document equivalent transformations. It addresses another case: A model was trained against an offline feature dataset but production is reading an independently generated online feature table. For that case, the distinguishing justification or acceptance check is: Training-serving skew can result from inconsistent feature values even when both sources use the same names. The present case instead states: A deployed model's feature source is deleted, but the model registry still advertises the version as deployable. It calls for Record external feature-source dependencies and their ownership as part of the model contract. Showing success for the other case would not establish: Versioned model metadata must identify required feature systems so operations can detect and repair missing dependencies.

C:

The alternative, Document and test supported missing-feature handling and defaults, belongs to a different technical condition: A production feature service temporarily returns missing values; the trained model cannot accept nulls. There the source-specific mechanism or proof is: A declared missing-value policy prevents ad hoc serving-time substitutions that can invalidate training assumptions. The condition asked about here is: A deployed model's feature source is deleted, but the model registry still advertises the version as deployable. A suitable correction is Record external feature-source dependencies and their ownership as part of the model contract; the targeted justification or result is: Versioned model metadata must identify required feature systems so operations can detect and repair missing dependencies.

Question 266

A feature retrieval function uses a hard-coded default time zone and shifts calendar features after deployment. What should the packaged specification define?

  1. Use time-consistent feature retrieval tied to each prediction event timestamp.
  2. Pin the exact feature-set name and version required by the model.
  3. Specify the feature timestamp and time-zone normalization contract explicitly.
  4. Document and test supported missing-feature handling and defaults.

Explanation

Correct Answer

C:

Time semantics are part of feature generation; undocumented server-local time zones change model inputs across environments.

Incorrect Answers

A:

Use time-consistent feature retrieval tied to each prediction event timestamp. A separate source case supports that approach when: A fraud model trained using point-in-time account balances but production code reads the latest balance for old records during batch replay. The supporting rationale or observable result is: Point-in-time lookup avoids hindsight leakage and makes historical inference comparable to the original live decision. This question describes a different issue: A feature retrieval function uses a hard-coded default time zone and shifts calendar features after deployment. Address it through Specify the feature timestamp and time-zone normalization contract explicitly, with the required justification or evidence: Time semantics are part of feature generation; undocumented server-local time zones change model inputs across environments.

B:

Pin the exact feature-set name and version required by the model. This is useful for the distinct issue: A feature store contains several versions of customer_age but the deployed model expects the training-time version. The relevant technical rationale or evidence for that issue is: An explicit feature version prevents a deployment from silently reading an incompatible revised definition. Here the reported issue is: A feature retrieval function uses a hard-coded default time zone and shifts calendar features after deployment. The relevant response is: Specify the feature timestamp and time-zone normalization contract explicitly. The first result cannot verify this different correction: Time semantics are part of feature generation; undocumented server-local time zones change model inputs across environments.

D:

Document and test supported missing-feature handling and defaults. It addresses another case: A production feature service temporarily returns missing values; the trained model cannot accept nulls. For that case, the distinguishing justification or acceptance check is: A declared missing-value policy prevents ad hoc serving-time substitutions that can invalidate training assumptions. The present case instead states: A feature retrieval function uses a hard-coded default time zone and shifts calendar features after deployment. It calls for Specify the feature timestamp and time-zone normalization contract explicitly. Showing success for the other case would not establish: Time semantics are part of feature generation; undocumented server-local time zones change model inputs across environments.

Question 267

Two runtime services consume the same model but supply differently ordered raw input arrays. What packaging improvement prevents wrong feature interpretation?

  1. Use time-consistent feature retrieval tied to each prediction event timestamp.
  2. Use a named and versioned feature schema with explicit column alignment.
  3. Record model-to-feature dependency lineage in the registered model package.
  4. Record external feature-source dependencies and their ownership as part of the model contract.

Explanation

Correct Answer

B:

Named feature contracts avoid relying on accidental column order between training and inference client implementations.

Incorrect Answers

A:

Use time-consistent feature retrieval tied to each prediction event timestamp. That operation would be relevant if: A fraud model trained using point-in-time account balances but production code reads the latest balance for old records during batch replay. Its corresponding reason or verification is: Point-in-time lookup avoids hindsight leakage and makes historical inference comparable to the original live decision. However the problem in this question is: Two runtime services consume the same model but supply differently ordered raw input arrays. The requirement instead calls for Use a named and versioned feature schema with explicit column alignment; the question-specific check is: Named feature contracts avoid relying on accidental column order between training and inference client implementations.

C:

Record model-to-feature dependency lineage in the registered model package. A separate source case supports that approach when: A model owner retires a feature definition without identifying which models depend on it. The supporting rationale or observable result is: Explicit dependencies reveal affected deployments before retiring or altering a shared feature service. This question describes a different issue: Two runtime services consume the same model but supply differently ordered raw input arrays. Address it through Use a named and versioned feature schema with explicit column alignment, with the required justification or evidence: Named feature contracts avoid relying on accidental column order between training and inference client implementations.

D:

Record external feature-source dependencies and their ownership as part of the model contract. This is useful for the distinct issue: A deployed model's feature source is deleted, but the model registry still advertises the version as deployable. The relevant technical rationale or evidence for that issue is: Versioned model metadata must identify required feature systems so operations can detect and repair missing dependencies. Here the reported issue is: Two runtime services consume the same model but supply differently ordered raw input arrays. The relevant response is: Use a named and versioned feature schema with explicit column alignment. The first result cannot verify this different correction: Named feature contracts avoid relying on accidental column order between training and inference client implementations.

Question 268

A model was trained against an offline feature dataset but production is reading an independently generated online feature table. What should be compared?

  1. Validate offline-to-online feature parity and document equivalent transformations.
  2. Specify the feature timestamp and time-zone normalization contract explicitly.
  3. Package the exact transformation logic and preprocessing parameters with the model.
  4. Pin the exact feature-set name and version required by the model.

Explanation

Correct Answer

A:

Training-serving skew can result from inconsistent feature values even when both sources use the same names.

Incorrect Answers

B:

The alternative, Specify the feature timestamp and time-zone normalization contract explicitly, belongs to a different technical condition: A feature retrieval function uses a hard-coded default time zone and shifts calendar features after deployment. There the source-specific mechanism or proof is: Time semantics are part of feature generation; undocumented server-local time zones change model inputs across environments. The condition asked about here is: A model was trained against an offline feature dataset but production is reading an independently generated online feature table. A suitable correction is Validate offline-to-online feature parity and document equivalent transformations; the targeted justification or result is: Training-serving skew can result from inconsistent feature values even when both sources use the same names.

C:

Package the exact transformation logic and preprocessing parameters with the model. That operation would be relevant if: A data scientist uses one feature transformation in training and a different normalization constant in online scoring. Its corresponding reason or verification is: Identical feature processing is necessary to avoid training-serving skew caused by mismatched normalization steps. However the problem in this question is: A model was trained against an offline feature dataset but production is reading an independently generated online feature table. The requirement instead calls for Validate offline-to-online feature parity and document equivalent transformations; the question-specific check is: Training-serving skew can result from inconsistent feature values even when both sources use the same names.

D:

Pin the exact feature-set name and version required by the model. A separate source case supports that approach when: A feature store contains several versions of customer_age but the deployed model expects the training-time version. The supporting rationale or observable result is: An explicit feature version prevents a deployment from silently reading an incompatible revised definition. This question describes a different issue: A model was trained against an offline feature dataset but production is reading an independently generated online feature table. Address it through Validate offline-to-online feature parity and document equivalent transformations, with the required justification or evidence: Training-serving skew can result from inconsistent feature values even when both sources use the same names.

Question 269

A model owner retires a feature definition without identifying which models depend on it. What metadata makes migration safer?

  1. Package only the retrieval interface and fetch credentials from a managed runtime secret store.
  2. Package the feature retrieval and transformation specification with the registered model.
  3. Use time-consistent feature retrieval tied to each prediction event timestamp.
  4. Record model-to-feature dependency lineage in the registered model package.

Explanation

Correct Answer

D:

Explicit dependencies reveal affected deployments before retiring or altering a shared feature service.

Incorrect Answers

A:

Package only the retrieval interface and fetch credentials from a managed runtime secret store. It addresses another case: A model needs a third-party feature API, but developers embed its token in the serialized model artifact. For that case, the distinguishing justification or acceptance check is: Model artifacts may be redistributed; separating secrets from interface metadata avoids credential leakage across consumers. The present case instead states: A model owner retires a feature definition without identifying which models depend on it. It calls for Record model-to-feature dependency lineage in the registered model package. Showing success for the other case would not establish: Explicit dependencies reveal affected deployments before retiring or altering a shared feature service.

B:

The alternative, Package the feature retrieval and transformation specification with the registered model, belongs to a different technical condition: A recommendation model was trained using customer features with specific transformations, but the package contains only serialized weights. There the source-specific mechanism or proof is: Serving requires the same feature definitions and lookup behavior as training; weights alone do not describe that input contract. The condition asked about here is: A model owner retires a feature definition without identifying which models depend on it. A suitable correction is Record model-to-feature dependency lineage in the registered model package; the targeted justification or result is: Explicit dependencies reveal affected deployments before retiring or altering a shared feature service.

C:

Use time-consistent feature retrieval tied to each prediction event timestamp. That operation would be relevant if: A fraud model trained using point-in-time account balances but production code reads the latest balance for old records during batch replay. Its corresponding reason or verification is: Point-in-time lookup avoids hindsight leakage and makes historical inference comparable to the original live decision. However the problem in this question is: A model owner retires a feature definition without identifying which models depend on it. The requirement instead calls for Record model-to-feature dependency lineage in the registered model package; the question-specific check is: Explicit dependencies reveal affected deployments before retiring or altering a shared feature service.

Question 270

An MLflow training job logs loss and parameters but never logs the trained model artifact. The team wants to register it. What should happen first?

  1. Verify model-asset write permissions in the target workspace or registry.
  2. Use the compatible MLflow flavor and model loading method for the artifact.
  3. Log the model in a supported MLflow flavor and register the resulting artifact.
  4. Record the resolved registered-model version or artifact URI in deployment metadata.

Explanation

Correct Answer

C:

Registration needs an actual model artifact; scalar training metrics alone are not a deployable model package.

Incorrect Answers

A:

Verify model-asset write permissions in the target workspace or registry. It addresses another case: An engineer has permission to read MLflow run metrics but receives an authorization error while registering the model. For that case, the distinguishing justification or acceptance check is: Run visibility and model registration are distinct operations governed by applicable Azure resource permissions. The present case instead states: An MLflow training job logs loss and parameters but never logs the trained model artifact. The team wants to register it. It calls for Log the model in a supported MLflow flavor and register the resulting artifact. Showing success for the other case would not establish: Registration needs an actual model artifact; scalar training metrics alone are not a deployable model package.

B:

The alternative, Use the compatible MLflow flavor and model loading method for the artifact, belongs to a different technical condition: A model is logged using a framework-specific MLflow flavor, but a deployment script expects a different loading interface. There the source-specific mechanism or proof is: Model flavors describe serialization and inference interfaces; a mismatched loader cannot reliably reconstruct the model. The condition asked about here is: An MLflow training job logs loss and parameters but never logs the trained model artifact. The team wants to register it. A suitable correction is Log the model in a supported MLflow flavor and register the resulting artifact; the targeted justification or result is: Registration needs an actual model artifact; scalar training metrics alone are not a deployable model package.

D:

Record the resolved registered-model version or artifact URI in deployment metadata. That operation would be relevant if: A team wants to validate the exact model loaded by a production deployment because both old and new versions are present. Its corresponding reason or verification is: Deployment provenance should identify the exact artifact, not merely a friendly model label shared by many versions. However the problem in this question is: An MLflow training job logs loss and parameters but never logs the trained model artifact. The team wants to register it. The requirement instead calls for Log the model in a supported MLflow flavor and register the resulting artifact; the question-specific check is: Registration needs an actual model artifact; scalar training metrics alone are not a deployable model package.

Operationalizing Machine Learning and Generative AI Solutions (AI-300) Practice Tests