# ML Model Lifecycle using Apolo Console
This comprehensive guide will walk you through creating a complete machine learning workflow using Apolo's platform. You'll learn how to:
* Set up a Jupyter Lab environment for model development
* Train a simple classification model with scikit-learn
* Track experiments and models with MLflow
* Convert models to ONNX format for deployment
* Deploy your model as an inference service using NVIDIA Triton
### Prerequisites
* Basic familiarity with Python and machine learning concepts
### 1. Accessing the Apolo Console
1. Log in to the [Apolo](https://docs.apolo.us/index/)
2. Verify your project selection in the top-right corner dropdown
### 2. Setting Up Your Jupyter Lab Environment
1. Navigate to the **Apps** section in the left sidebar, make sure you have the **All Apps** tab selected to view available applications
2. Locate and click on the **Jupyter Lab** card
3. Click the **Install** button
4. Configure your Jupyter Lab instance:
* Under **Resources**, select a preset (we'll use `cpu-small` for this tutorial)
* Under **Metadata**, name your instance (e.g., `jupyter-lab-demo`)
* Click **Install App**
5. Wait for the status to change from **Pending** to **Succeeded**
Find more about launching Jupyter in Apolo by going to our [Jupyter Notebook page](/index/apolo-console/apps/installable-apps/available-apps/jupyter-notebook.md).
### 3. Setting Up MLflow for Experiment Tracking
1. Return to the Apolo Console
2. Navigate to **Apps** > **All Apps**
3. Find and install the **MLflow** application:
* Select a resource preset (e.g., `cpu-small`)
* Name your instance (e.g., `mlflow-demo`)
* Click **Install App**
4. Wait for the MLflow instance to reach the **Succeeded** state
### 4. Setting Up Your Development Environment
1. Return to **Apps** > **Installed Apps** and find your Jupyter Lab instance
2. Click the **Open** button to launch Jupyter Lab in a new tab
3. Open a terminal by clicking **Terminal** under the "Other" section in the launcher
4. Navigate to the persistent storage location:
```bash
cd /var/storage
```
5. Clone the example repository:
```bash
git clone https://github.com/neuro-inc/model-lifecycle-example
```
### 5. Training Your Machine Learning Model
1. Navigate to the cloned repository through the file browser:
* Open the `model-lifecycle-example` directory
* Open the `notebooks` directory
* Open `training-demo.ipynb`
2. Run the notebook cells sequentially (using Shift+Enter or the Run button)
### 6. Reviewing Your Model in MLflow
1. Return to the Apolo Console
2. Navigate to **Apps** > **Installed Apps**
3. Find your MLflow instance and click **Open**
4. Explore the experiment run:
* Click on the most recent run
* Review the logged parameters, metrics, and artifacts
5. Promote your ONNX model to production:
* Click on the **Models** tab in the MLflow UI
* Select the `onnx_iris_perceptron` model
* Click on the latest version
* **Important:** Ensure the **New model registry UI** toggle is turned off
* Change the **Stage** from "None" to "Production"
* Confirm the stage transition
### 7. Deploying Your Model with Apolo Deploy
1. Return to the Apolo Console
2. Navigate to **Apps** > **All Apps**
3. Find and install **Apolo Deploy**:
* Select a resource preset (e.g., `cpu-small`)
* Under **Integrations**, select your MLflow instance
* Name your deployment (e.g., `apolo-deploy-demo`)
* Click **Install App**
4. Wait for Apolo Deploy to reach the **Running** state
5. Open Apolo Deploy and configure your model deployment:
* Locate the `onnx_iris_perceptron` model in Production stage
* Click the dropdown in the **Deployment** column
* Configure the deployment:
* Set **Server type** to `Triton`
* Set **Create new server instance** to `True`
* Set an optional server name (default: `triton`)
* Select a resource preset
* Set **Force Platform Auth** to `False` (for demo purposes only)
* Click **Deploy**
6. Wait for the deployment to complete
### 8. Testing Your Deployed Model
1. Return to your Jupyter Lab application
2. Open the notebook called `inference-demo.ipynb`
3. Run the cells to test your deployed model
### Conclusion
Congratulations! You've successfully:
* Set up a Jupyter Lab environment on Apolo
* Trained a simple classification model
* Tracked your experiment and model with MLflow
* Converted your model to ONNX format
* Deployed your model using NVIDIA Triton via Apolo Deploy
* Tested your deployed model endpoint
This workflow demonstrates a complete MLOps pipeline that you can adapt for your own machine learning projects.
### Additional Resources
* [Apolo Documentation](https://docs.apolo.us/)
* [MLflow Documentation](https://www.mlflow.org/docs/latest/index.html)
* [NVIDIA Triton Inference Server](https://developer.nvidia.com/nvidia-triton-inference-server)
* [ONNX Model Format](https://onnx.ai/)
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://docs.apolo.us/index/examples-use-cases/generic/ml-model-lifecycle-using-apolo-console.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.