How to retrain a Model in the Azure ML Workspace

Question

How to retrain a Model in the Azure ML Workspace

Nidhi Priya 661

Hello Experts!

We have trained a model in Azure ML Workspace using Python Libraries under Notebook. The model has been successfully deployed as an endpoint. Now we wanted to retrain the model using the new data. What I know through my research is that we can retrain model using Designer pipeline. But what I wanted to know is that can we retrain model from Notebook maintaining our process?

And when we retrain model, we don't want to redeploy it, and the endpoint URL should remain same throughout as the endpoint is integrated with our in-house application.

Thanks!

Nidhi

0 comments

Answer accepted by question author

SRILAKSHMI C 19,735 Microsoft External Staff Moderator

Hello @Nidhi Priya

Thank you for reaching out to Microsoft Q&A.

From what you've described, you currently train your model using Python libraries within Azure ML Notebooks, deploy it as an endpoint, and now want to retrain it using new data while ensuring that your in-house application can continue using the same endpoint URL. This is a very common scenario in production ML environments.

Based on the documentation and the information available, here's how this can be approached.

Can you retrain the model from a Notebook?

Yes. You can continue using your existing Notebook-based workflow for retraining. If your current training process is implemented using Python code in Azure ML Notebooks, you can reuse the same code to train a new version of the model using updated data.

Typically, the process would be:

Load the new dataset.

Execute the same preprocessing and training steps.

Generate the updated model artifact.

Register the retrained model as a new model version in Azure ML.

You do not have to move to Designer pipelines if you are comfortable maintaining your Notebook-based process.

Is using a Designer Pipeline also a valid approach?

Yes, the documentation explicitly supports retraining using published Azure ML pipelines. A common pattern is to:

Create a training pipeline,

Publish it as a Pipeline Endpoint,

Invoke that endpoint whenever new training data becomes available.

You can trigger the pipeline through:

Azure ML Studio,

Python SDK,

REST APIs,

Automation workflows.

The advantage of this approach is improved automation, repeatability, and operational governance.

However, it is important to note that the documentation primarily describes retraining through published pipelines and Pipeline Endpoints. It does not specifically describe an end-to-end "Notebook retrain and automatically update the serving endpoint" workflow.

Can the endpoint URL remain the same?

This is the key part of your question.

If your model is deployed using an Azure ML Managed Online Endpoint, the endpoint itself is separate from the model version being served.

That means your application can continue using the same endpoint URL.

For example:

Current deployment:

Endpoint: customer-risk-endpoint
Deployment: blue
Model: Version 1

After retraining:

Endpoint: customer-risk-endpoint
Deployment: blue
Model: Version 2

Your application continues calling the same endpoint URL without requiring any configuration changes.

Does retraining automatically update the endpoint?

This is where the documentation becomes important.

Based on the documents referenced, we can confirm that:

Training jobs can be submitted programmatically.

Published pipeline endpoints can be invoked using code or REST APIs.

Retraining can be automated using Pipeline Endpoints.

However, the documentation does not explicitly state that simply retraining the model from a Notebook will automatically replace the model behind an existing inference endpoint without any deployment update.

Therefore, we cannot confidently say that Notebook retraining alone will preserve the endpoint URL without any redeployment or deployment update step.

Will redeployment be required?

Technically, some form of deployment update is still required.

After retraining:

The retrained model becomes a new model version.

The existing deployment must be updated to reference that new version.

The important distinction is that this does not require creating a brand-new endpoint.

You do not need to:

Create another endpoint,

Change the endpoint URL,

Modify your application's integration.

You only need to update the deployment behind the existing endpoint to use the newer model version.

Recommended approach

If your primary goal is to preserve your current process while maintaining a stable endpoint URL, the safest approach would be:

Continue retraining using your existing Notebook and Python code.

Register each retrained model as a new version.

Update the existing online deployment to point to the latest model version.

Continue using the same endpoint URL from your application.

If you expect retraining to happen frequently, you may also consider converting your notebook logic into an Azure ML Pipeline and publishing it as a Pipeline Endpoint. You can then invoke the pipeline programmatically from your Notebook or automation process. This provides a more production-oriented retraining workflow, although the documentation still does not explicitly state that it automatically updates the serving deployment.

Please refer this

“Use pipeline inputs to retrain models in the designer” (pipeline endpoint + retraining on new data) https://learn.microsoft.com/azure/machine-learning/how-to-retrain-designer?view=azureml-api-1
“Tutorial: Train a model in Azure Machine Learning” (general workspace + notebook training context) https://learn.microsoft.com/azure/machine-learning/tutorial-train-model?view=azureml-api-2
“Retrain a model (ML.NET)” (not Azure ML retraining; only ML.NET retraining concept) https://learn.microsoft.com/dotnet/machine-learning/how-to-guides/retrain-model-ml-net?wt.mc_id=knowledgesearch_inproduct_azure-cxp-community-insider
https://learn.microsoft.com/en-us/azure/machine-learning/how-to-deploy-online-endpoints?view=azureml-api-2&tabs=cli
https://learn.microsoft.com/en-us/azure/machine-learning/how-to-manage-models?view=azureml-api-2&tabs=cli

I Hope this helps. Do let me know if you have any further queries.

If this answers your query, please do click Accept Answer and Yes for was this answer helpful.

Thank you!

SRILAKSHMI C 19,735 Reputation points Microsoft External Staff Moderator

2026-06-22T17:09:29.32+00:00

Hi @Nidhi Priya,

Following up to see if the above answer was helpful. If this answers your query, please do click Accept Answer and Yes for was this answer helpful. And, if you have any further query do let us know.

Thank you!
Nidhi Priya 661 Reputation points

2026-06-23T06:46:54.8266667+00:00

Hi @SRILAKSHMI C ,

Thank you for replying for my query, i understand that we can retrain model using notebook by rerunning the training cell, But will the endpoint URL remain same when we retrain model from notebook?
SRILAKSHMI C 19,735 Reputation points Microsoft External Staff Moderator

2026-06-28T07:35:44.8233333+00:00
Hi @Nidhi Priya

You're welcome! Thank you for the follow-up question.

Yes, the endpoint URL can remain the same, but it depends on how you update your deployed model after retraining.

Retraining the model from an Azure ML Notebook only produces a new model artifact (and typically a new registered model version). The retraining process itself does not modify or recreate the online endpoint, so it does not change the endpoint URL.

If your model is deployed to an Azure ML Managed Online Endpoint, you can:

Retrain the model from your Notebook using the new data.

Register the retrained model as a new version.

Update the existing deployment to reference the newly registered model version.

By updating the deployment behind the existing endpoint, the endpoint URL remains unchanged, allowing your in-house application to continue using the same endpoint without any configuration changes.

For example:

Before retraining

Endpoint: customer-risk-endpoint

Deployment: `blue` Model: Version 1 **After retraining** Endpoint: `customer-risk-endpoint` *(same endpoint)* Deployment: `blue` *(same deployment)* Model: Version 2

In this scenario, your application continues to call the same endpoint URL. Only the model version serving the requests changes.

The important distinction is that retraining does not automatically update the deployed model. After the new model is trained and registered, you'll still need to update the existing deployment to use the latest model version. This is a deployment update—not the creation of a new endpoint—so the endpoint URL remains the same.

You can refer to the following Microsoft Learn documentation for more information:

Deploy and manage online endpoints: https://learn.microsoft.com/azure/machine-learning/how-to-deploy-online-endpoints?view=azureml-api-2

Manage models in Azure Machine Learning: https://learn.microsoft.com/azure/machine-learning/how-to-manage-models?view=azureml-api-2

I hope this clarifies the distinction between retraining, deployment updates, and the endpoint URL.

Thank you!

1 additional answer

Your answer

SRILAKSHMI C 19,735 Reputation points Microsoft External Staff Moderator

2026-06-22T17:09:29.32+00:00

Hi @Nidhi Priya,

Following up to see if the above answer was helpful. If this answers your query, please do click Accept Answer and Yes for was this answer helpful. And, if you have any further query do let us know.

Thank you!
Nidhi Priya 661 Reputation points

2026-06-23T06:46:54.8266667+00:00

Hi @SRILAKSHMI C ,

Thank you for replying for my query, i understand that we can retrain model using notebook by rerunning the training cell, But will the endpoint URL remain same when we retrain model from notebook?

Answer 1

Yes, a model can be retrained from a notebook while keeping the same online endpoint URL, as long as the endpoint is updated with the newly trained model instead of creating a new endpoint.

In Azure Machine Learning there are two main parts to this scenario:

Retraining the model
- Retraining does not have to use Designer. Models can be trained using:
  - Python SDK jobs (for example, command() jobs or pipelines), or
  - Designer pipelines, or
  - Automated ML.
- The key is that training is just another job in the workspace. A notebook can submit such jobs programmatically using the SDK, so the existing Python-based process can be preserved while changing only the data inputs or parameters.
- Pipelines are often used when retraining needs to be repeatable and parameterized (for example, changing the training data path or hyperparameters). The Designer article shows this pattern using pipeline inputs to make the training data path configurable and then reusing the same pipeline for retraining with new data.
Keeping the same endpoint URL while updating the model
- The endpoint URL is tied to the online endpoint, not to a specific model version. To keep the same URL, the existing endpoint must be updated with a new deployment (or updated deployment) that uses the newly trained model.
- In the Designer-based workflow, the process is:
  1. Modify and resubmit the training pipeline (for example, with new data via pipeline inputs).
  2. When the training job completes, register the new trained model output.
  3. Open or clone the inference pipeline, replace the old trained model (the MD-xxxx node) with the newly registered model, and submit the inference pipeline job.
  4. Deploy the updated inference pipeline to the existing online endpoint instead of creating a new one. This keeps the endpoint URL unchanged while the model behind it is updated.
- The same pattern applies when training from a notebook: after retraining and registering a new model version, the deployment associated with the existing endpoint is updated to point to the new model. The endpoint name (and thus its URL) remains the same; only the underlying model artifact changes.

In summary, retraining can be done entirely from notebooks using Python, and as long as the existing online endpoint is updated rather than recreated, the endpoint URL used by the in-house application remains constant while the model is refreshed with new data.

References: