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 28

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.

Question 271

An inference team cannot determine the expected model input schema from its registered MLflow model. What should be included when logging?

  1. Retain the model version, producing run, environment, and related metadata under the retention policy.
  2. Capture an MLflow model signature and representative input example.
  3. Register and tag the specific passing artifact or model version as the approved candidate.
  4. Use the compatible MLflow flavor and model loading method for the artifact.

Explanation

Correct Answer

B:

Signatures document expected input and output shapes, helping serving clients send valid data.

Incorrect Answers

A:

Retain the model version, producing run, environment, and related metadata under the retention policy. This is useful for the distinct issue: A model must be archived for governance but remain reproducible and inspectable. The relevant technical rationale or evidence for that issue is: Auditability depends on both artifacts and provenance; removing every associated trace makes past decisions unreproducible. Here the reported issue is: An inference team cannot determine the expected model input schema from its registered MLflow model. The relevant response is: Capture an MLflow model signature and representative input example. The first result cannot verify this different correction: Signatures document expected input and output shapes, helping serving clients send valid data.

C:

Register and tag the specific passing artifact or model version as the approved candidate. It addresses another case: A model's training job finishes and artifacts appear in MLflow, but promotion automation cannot tell which one passed testing. For that case, the distinguishing justification or acceptance check is: Explicit model versions and controlled approval metadata prevent promotion by ambiguous latest-run ordering. The present case instead states: An inference team cannot determine the expected model input schema from its registered MLflow model. It calls for Capture an MLflow model signature and representative input example. Showing success for the other case would not establish: Signatures document expected input and output shapes, helping serving clients send valid data.

D:

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 inference team cannot determine the expected model input schema from its registered MLflow model. A suitable correction is Capture an MLflow model signature and representative input example; the targeted justification or result is: Signatures document expected input and output shapes, helping serving clients send valid data.

Question 272

Several versions of a classifier share a registered model name, and an analyst needs to reproduce a historical release. What should be referenced?

  1. Select the exact registered MLflow model version used by that release.
  2. Log the model in a supported MLflow flavor and register the resulting artifact.
  3. Capture an MLflow model signature and representative input example.
  4. Store the tracked model artifact in an accessible Azure ML-linked artifact store.

Explanation

Correct Answer

A:

A pinned version preserves the intended artifact instead of assuming the newest version represents the historical deployment.

Incorrect Answers

B:

Log the model in a supported MLflow flavor and register the resulting artifact. A separate source case supports that approach when: An MLflow training job logs loss and parameters but never logs the trained model artifact. The team wants to register it. The supporting rationale or observable result is: Registration needs an actual model artifact; scalar training metrics alone are not a deployable model package. This question describes a different issue: Several versions of a classifier share a registered model name, and an analyst needs to reproduce a historical release. Address it through Select the exact registered MLflow model version used by that release, with the required justification or evidence: A pinned version preserves the intended artifact instead of assuming the newest version represents the historical deployment.

C:

Capture an MLflow model signature and representative input example. This is useful for the distinct issue: An inference team cannot determine the expected model input schema from its registered MLflow model. The relevant technical rationale or evidence for that issue is: Signatures document expected input and output shapes, helping serving clients send valid data. Here the reported issue is: Several versions of a classifier share a registered model name, and an analyst needs to reproduce a historical release. The relevant response is: Select the exact registered MLflow model version used by that release. The first result cannot verify this different correction: A pinned version preserves the intended artifact instead of assuming the newest version represents the historical deployment.

D:

Store the tracked model artifact in an accessible Azure ML-linked artifact store. It addresses another case: An experiment logs an MLflow model only to a developer's local filesystem, but Azure ML registration cannot locate the artifact. For that case, the distinguishing justification or acceptance check is: Registry operations require reachable artifact paths; local files on an engineer's laptop are not automatically shared. The present case instead states: Several versions of a classifier share a registered model name, and an analyst needs to reproduce a historical release. It calls for Select the exact registered MLflow model version used by that release. Showing success for the other case would not establish: A pinned version preserves the intended artifact instead of assuming the newest version represents the historical deployment.

Question 273

A team registers a model but omits all information linking it to the training experiment and validation metrics. What provenance should be captured?

  1. Define stable model-family names and let new artifacts create separate registered versions.
  2. Verify model-asset write permissions in the target workspace or registry.
  3. Record the resolved registered-model version or artifact URI in deployment metadata.
  4. Attach producing-run identifiers and relevant evaluation metadata to the registered model.

Explanation

Correct Answer

D:

Run lineage lets reviewers trace a model back to its source code, data, parameters, and training evidence.

Incorrect Answers

A:

Define stable model-family names and let new artifacts create separate registered versions. That operation would be relevant if: An operator registers models with arbitrary manually chosen names, resulting in overwriting the wrong logical model family. Its corresponding reason or verification is: A consistent namespace distinguishes model identity from successive versions and reduces accidental cross-project releases. However the problem in this question is: A team registers a model but omits all information linking it to the training experiment and validation metrics. The requirement instead calls for Attach producing-run identifiers and relevant evaluation metadata to the registered model; the question-specific check is: Run lineage lets reviewers trace a model back to its source code, data, parameters, and training evidence.

B:

Verify model-asset write permissions in the target workspace or registry. A separate source case supports that approach when: An engineer has permission to read MLflow run metrics but receives an authorization error while registering the model. The supporting rationale or observable result is: Run visibility and model registration are distinct operations governed by applicable Azure resource permissions. This question describes a different issue: A team registers a model but omits all information linking it to the training experiment and validation metrics. Address it through Attach producing-run identifiers and relevant evaluation metadata to the registered model, with the required justification or evidence: Run lineage lets reviewers trace a model back to its source code, data, parameters, and training evidence.

C:

Record the resolved registered-model version or artifact URI in deployment metadata. This is useful for the distinct issue: A team wants to validate the exact model loaded by a production deployment because both old and new versions are present. The relevant technical rationale or evidence for that issue is: Deployment provenance should identify the exact artifact, not merely a friendly model label shared by many versions. Here the reported issue is: A team registers a model but omits all information linking it to the training experiment and validation metrics. The relevant response is: Attach producing-run identifiers and relevant evaluation metadata to the registered model. The first result cannot verify this different correction: Run lineage lets reviewers trace a model back to its source code, data, parameters, and training evidence.

Question 274

A model is logged using a framework-specific MLflow flavor, but a deployment script expects a different loading interface. Which issue should be resolved?

  1. Capture an MLflow model signature and representative input example.
  2. Attach producing-run identifiers and relevant evaluation metadata to the registered model.
  3. Use the compatible MLflow flavor and model loading method for the artifact.
  4. Select the exact registered MLflow model version used by that release.

Explanation

Correct Answer

C:

Model flavors describe serialization and inference interfaces; a mismatched loader cannot reliably reconstruct the model.

Incorrect Answers

A:

The alternative, Capture an MLflow model signature and representative input example, belongs to a different technical condition: An inference team cannot determine the expected model input schema from its registered MLflow model. There the source-specific mechanism or proof is: Signatures document expected input and output shapes, helping serving clients send valid data. The condition asked about here is: A model is logged using a framework-specific MLflow flavor, but a deployment script expects a different loading interface. A suitable correction is Use the compatible MLflow flavor and model loading method for the artifact; the targeted justification or result is: Model flavors describe serialization and inference interfaces; a mismatched loader cannot reliably reconstruct the model.

B:

Attach producing-run identifiers and relevant evaluation metadata to the registered model. That operation would be relevant if: A team registers a model but omits all information linking it to the training experiment and validation metrics. Its corresponding reason or verification is: Run lineage lets reviewers trace a model back to its source code, data, parameters, and training evidence. However the problem in this question is: A model is logged using a framework-specific MLflow flavor, but a deployment script expects a different loading interface. The requirement instead calls for Use the compatible MLflow flavor and model loading method for the artifact; the question-specific check is: Model flavors describe serialization and inference interfaces; a mismatched loader cannot reliably reconstruct the model.

D:

Select the exact registered MLflow model version used by that release. A separate source case supports that approach when: Several versions of a classifier share a registered model name, and an analyst needs to reproduce a historical release. The supporting rationale or observable result is: A pinned version preserves the intended artifact instead of assuming the newest version represents the historical deployment. This question describes a different issue: A model is logged using a framework-specific MLflow flavor, but a deployment script expects a different loading interface. Address it through Use the compatible MLflow flavor and model loading method for the artifact, with the required justification or evidence: Model flavors describe serialization and inference interfaces; a mismatched loader cannot reliably reconstruct the model.

Question 275

A scoring environment runs successfully in development, but the registered MLflow model has dependency versions incompatible with the production image. What should be checked?

  1. Register and tag the specific passing artifact or model version as the approved candidate.
  2. Use the model's logged dependency specification to align production runtime libraries.
  3. Store the tracked model artifact in an accessible Azure ML-linked artifact store.
  4. Attach producing-run identifiers and relevant evaluation metadata to the registered model.

Explanation

Correct Answer

B:

MLflow packaging can capture required dependencies; incompatible framework versions can break an otherwise valid artifact.

Incorrect Answers

A:

Register and tag the specific passing artifact or model version as the approved candidate. It addresses another case: A model's training job finishes and artifacts appear in MLflow, but promotion automation cannot tell which one passed testing. For that case, the distinguishing justification or acceptance check is: Explicit model versions and controlled approval metadata prevent promotion by ambiguous latest-run ordering. The present case instead states: A scoring environment runs successfully in development, but the registered MLflow model has dependency versions incompatible with the production image. It calls for Use the model's logged dependency specification to align production runtime libraries. Showing success for the other case would not establish: MLflow packaging can capture required dependencies; incompatible framework versions can break an otherwise valid artifact.

C:

The alternative, Store the tracked model artifact in an accessible Azure ML-linked artifact store, belongs to a different technical condition: An experiment logs an MLflow model only to a developer's local filesystem, but Azure ML registration cannot locate the artifact. There the source-specific mechanism or proof is: Registry operations require reachable artifact paths; local files on an engineer's laptop are not automatically shared. The condition asked about here is: A scoring environment runs successfully in development, but the registered MLflow model has dependency versions incompatible with the production image. A suitable correction is Use the model's logged dependency specification to align production runtime libraries; the targeted justification or result is: MLflow packaging can capture required dependencies; incompatible framework versions can break an otherwise valid artifact.

D:

Attach producing-run identifiers and relevant evaluation metadata to the registered model. That operation would be relevant if: A team registers a model but omits all information linking it to the training experiment and validation metrics. Its corresponding reason or verification is: Run lineage lets reviewers trace a model back to its source code, data, parameters, and training evidence. However the problem in this question is: A scoring environment runs successfully in development, but the registered MLflow model has dependency versions incompatible with the production image. The requirement instead calls for Use the model's logged dependency specification to align production runtime libraries; the question-specific check is: MLflow packaging can capture required dependencies; incompatible framework versions can break an otherwise valid artifact.

Question 276

An operator registers models with arbitrary manually chosen names, resulting in overwriting the wrong logical model family. What convention helps?

  1. Define stable model-family names and let new artifacts create separate registered versions.
  2. Store the tracked model artifact in an accessible Azure ML-linked artifact store.
  3. Capture an MLflow model signature and representative input example.
  4. Attach producing-run identifiers and relevant evaluation metadata to the registered model.

Explanation

Correct Answer

A:

A consistent namespace distinguishes model identity from successive versions and reduces accidental cross-project releases.

Incorrect Answers

B:

Store the tracked model artifact in an accessible Azure ML-linked artifact store. This is useful for the distinct issue: An experiment logs an MLflow model only to a developer's local filesystem, but Azure ML registration cannot locate the artifact. The relevant technical rationale or evidence for that issue is: Registry operations require reachable artifact paths; local files on an engineer's laptop are not automatically shared. Here the reported issue is: An operator registers models with arbitrary manually chosen names, resulting in overwriting the wrong logical model family. The relevant response is: Define stable model-family names and let new artifacts create separate registered versions. The first result cannot verify this different correction: A consistent namespace distinguishes model identity from successive versions and reduces accidental cross-project releases.

C:

Capture an MLflow model signature and representative input example. It addresses another case: An inference team cannot determine the expected model input schema from its registered MLflow model. For that case, the distinguishing justification or acceptance check is: Signatures document expected input and output shapes, helping serving clients send valid data. The present case instead states: An operator registers models with arbitrary manually chosen names, resulting in overwriting the wrong logical model family. It calls for Define stable model-family names and let new artifacts create separate registered versions. Showing success for the other case would not establish: A consistent namespace distinguishes model identity from successive versions and reduces accidental cross-project releases.

D:

The alternative, Attach producing-run identifiers and relevant evaluation metadata to the registered model, belongs to a different technical condition: A team registers a model but omits all information linking it to the training experiment and validation metrics. There the source-specific mechanism or proof is: Run lineage lets reviewers trace a model back to its source code, data, parameters, and training evidence. The condition asked about here is: An operator registers models with arbitrary manually chosen names, resulting in overwriting the wrong logical model family. A suitable correction is Define stable model-family names and let new artifacts create separate registered versions; the targeted justification or result is: A consistent namespace distinguishes model identity from successive versions and reduces accidental cross-project releases.

Question 277

A team wants to validate the exact model loaded by a production deployment because both old and new versions are present. What evidence should it inspect?

  1. Verify model-asset write permissions in the target workspace or registry.
  2. Package the required preprocessing code or model pipeline within the MLflow model artifact.
  3. Attach producing-run identifiers and relevant evaluation metadata to the registered model.
  4. Record the resolved registered-model version or artifact URI in deployment metadata.

Explanation

Correct Answer

D:

Deployment provenance should identify the exact artifact, not merely a friendly model label shared by many versions.

Incorrect Answers

A:

Verify model-asset write permissions in the target workspace or registry. A separate source case supports that approach when: An engineer has permission to read MLflow run metrics but receives an authorization error while registering the model. The supporting rationale or observable result is: Run visibility and model registration are distinct operations governed by applicable Azure resource permissions. This question describes a different issue: A team wants to validate the exact model loaded by a production deployment because both old and new versions are present. Address it through Record the resolved registered-model version or artifact URI in deployment metadata, with the required justification or evidence: Deployment provenance should identify the exact artifact, not merely a friendly model label shared by many versions.

B:

Package the required preprocessing code or model pipeline within the MLflow model artifact. This is useful for the distinct issue: A registered model is later copied outside its workspace without its input transformation definitions. The relevant technical rationale or evidence for that issue is: Inference portability requires the transformations used to produce the model's expected input features, not just trained coefficients. Here the reported issue is: A team wants to validate the exact model loaded by a production deployment because both old and new versions are present. The relevant response is: Record the resolved registered-model version or artifact URI in deployment metadata. The first result cannot verify this different correction: Deployment provenance should identify the exact artifact, not merely a friendly model label shared by many versions.

C:

Attach producing-run identifiers and relevant evaluation metadata to the registered model. It addresses another case: A team registers a model but omits all information linking it to the training experiment and validation metrics. For that case, the distinguishing justification or acceptance check is: Run lineage lets reviewers trace a model back to its source code, data, parameters, and training evidence. The present case instead states: A team wants to validate the exact model loaded by a production deployment because both old and new versions are present. It calls for Record the resolved registered-model version or artifact URI in deployment metadata. Showing success for the other case would not establish: Deployment provenance should identify the exact artifact, not merely a friendly model label shared by many versions.

Question 278

An experiment logs an MLflow model only to a developer's local filesystem, but Azure ML registration cannot locate the artifact. What should be changed?

  1. Retain the model version, producing run, environment, and related metadata under the retention policy.
  2. Register and tag the specific passing artifact or model version as the approved candidate.
  3. Store the tracked model artifact in an accessible Azure ML-linked artifact store.
  4. Attach producing-run identifiers and relevant evaluation metadata to the registered model.

Explanation

Correct Answer

C:

Registry operations require reachable artifact paths; local files on an engineer's laptop are not automatically shared.

Incorrect Answers

A:

Retain the model version, producing run, environment, and related metadata under the retention policy. That operation would be relevant if: A model must be archived for governance but remain reproducible and inspectable. Its corresponding reason or verification is: Auditability depends on both artifacts and provenance; removing every associated trace makes past decisions unreproducible. However the problem in this question is: An experiment logs an MLflow model only to a developer's local filesystem, but Azure ML registration cannot locate the artifact. The requirement instead calls for Store the tracked model artifact in an accessible Azure ML-linked artifact store; the question-specific check is: Registry operations require reachable artifact paths; local files on an engineer's laptop are not automatically shared.

B:

Register and tag the specific passing artifact or model version as the approved candidate. A separate source case supports that approach when: A model's training job finishes and artifacts appear in MLflow, but promotion automation cannot tell which one passed testing. The supporting rationale or observable result is: Explicit model versions and controlled approval metadata prevent promotion by ambiguous latest-run ordering. This question describes a different issue: An experiment logs an MLflow model only to a developer's local filesystem, but Azure ML registration cannot locate the artifact. Address it through Store the tracked model artifact in an accessible Azure ML-linked artifact store, with the required justification or evidence: Registry operations require reachable artifact paths; local files on an engineer's laptop are not automatically shared.

D:

Attach producing-run identifiers and relevant evaluation metadata to the registered model. This is useful for the distinct issue: A team registers a model but omits all information linking it to the training experiment and validation metrics. The relevant technical rationale or evidence for that issue is: Run lineage lets reviewers trace a model back to its source code, data, parameters, and training evidence. Here the reported issue is: An experiment logs an MLflow model only to a developer's local filesystem, but Azure ML registration cannot locate the artifact. The relevant response is: Store the tracked model artifact in an accessible Azure ML-linked artifact store. The first result cannot verify this different correction: Registry operations require reachable artifact paths; local files on an engineer's laptop are not automatically shared.

Question 279

An engineer has permission to read MLflow run metrics but receives an authorization error while registering the model. What should be checked?

  1. Define stable model-family names and let new artifacts create separate registered versions.
  2. Verify model-asset write permissions in the target workspace or registry.
  3. Select the exact registered MLflow model version used by that release.
  4. Retain the model version, producing run, environment, and related metadata under the retention policy.

Explanation

Correct Answer

B:

Run visibility and model registration are distinct operations governed by applicable Azure resource permissions.

Incorrect Answers

A:

The alternative, Define stable model-family names and let new artifacts create separate registered versions, belongs to a different technical condition: An operator registers models with arbitrary manually chosen names, resulting in overwriting the wrong logical model family. There the source-specific mechanism or proof is: A consistent namespace distinguishes model identity from successive versions and reduces accidental cross-project releases. The condition asked about here is: An engineer has permission to read MLflow run metrics but receives an authorization error while registering the model. A suitable correction is Verify model-asset write permissions in the target workspace or registry; the targeted justification or result is: Run visibility and model registration are distinct operations governed by applicable Azure resource permissions.

C:

Select the exact registered MLflow model version used by that release. That operation would be relevant if: Several versions of a classifier share a registered model name, and an analyst needs to reproduce a historical release. Its corresponding reason or verification is: A pinned version preserves the intended artifact instead of assuming the newest version represents the historical deployment. However the problem in this question is: An engineer has permission to read MLflow run metrics but receives an authorization error while registering the model. The requirement instead calls for Verify model-asset write permissions in the target workspace or registry; the question-specific check is: Run visibility and model registration are distinct operations governed by applicable Azure resource permissions.

D:

Retain the model version, producing run, environment, and related metadata under the retention policy. A separate source case supports that approach when: A model must be archived for governance but remain reproducible and inspectable. The supporting rationale or observable result is: Auditability depends on both artifacts and provenance; removing every associated trace makes past decisions unreproducible. This question describes a different issue: An engineer has permission to read MLflow run metrics but receives an authorization error while registering the model. Address it through Verify model-asset write permissions in the target workspace or registry, with the required justification or evidence: Run visibility and model registration are distinct operations governed by applicable Azure resource permissions.

Question 280

A registered model is later copied outside its workspace without its input transformation definitions. What should be included in the artifact packaging?

  1. Package the required preprocessing code or model pipeline within the MLflow model artifact.
  2. Use the model's logged dependency specification to align production runtime libraries.
  3. Retain the model version, producing run, environment, and related metadata under the retention policy.
  4. Log the model in a supported MLflow flavor and register the resulting artifact.

Explanation

Correct Answer

A:

Inference portability requires the transformations used to produce the model's expected input features, not just trained coefficients.

Incorrect Answers

B:

The alternative, Use the model's logged dependency specification to align production runtime libraries, belongs to a different technical condition: A scoring environment runs successfully in development, but the registered MLflow model has dependency versions incompatible with the production image. There the source-specific mechanism or proof is: MLflow packaging can capture required dependencies; incompatible framework versions can break an otherwise valid artifact. The condition asked about here is: A registered model is later copied outside its workspace without its input transformation definitions. A suitable correction is Package the required preprocessing code or model pipeline within the MLflow model artifact; the targeted justification or result is: Inference portability requires the transformations used to produce the model's expected input features, not just trained coefficients.

C:

Retain the model version, producing run, environment, and related metadata under the retention policy. That operation would be relevant if: A model must be archived for governance but remain reproducible and inspectable. Its corresponding reason or verification is: Auditability depends on both artifacts and provenance; removing every associated trace makes past decisions unreproducible. However the problem in this question is: A registered model is later copied outside its workspace without its input transformation definitions. The requirement instead calls for Package the required preprocessing code or model pipeline within the MLflow model artifact; the question-specific check is: Inference portability requires the transformations used to produce the model's expected input features, not just trained coefficients.

D:

Log the model in a supported MLflow flavor and register the resulting artifact. A separate source case supports that approach when: An MLflow training job logs loss and parameters but never logs the trained model artifact. The team wants to register it. The supporting rationale or observable result is: Registration needs an actual model artifact; scalar training metrics alone are not a deployable model package. This question describes a different issue: A registered model is later copied outside its workspace without its input transformation definitions. Address it through Package the required preprocessing code or model pipeline within the MLflow model artifact, with the required justification or evidence: Inference portability requires the transformations used to produce the model's expected input features, not just trained coefficients.

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