[ViPPET] Implementing a dedicated script for managing model installation (open-edge-platform#1000)

Author: p-zak

tools/visual-pipeline-and-platform-evaluation-tool/.gitignore

@@ -1,11 +1,4 @@
 __pycache__
-emissions.csv
-.collector.out
-.collector.run
-free_output.log
-qmassa_output.json
-turbostat_output.log
-videos/
-models/*
 .coverage
-.public_models_env
+models/output/*
+videos/

tools/visual-pipeline-and-platform-evaluation-tool/Dockerfile.vippet

@@ -41,14 +41,15 @@ COPY --chown=dlstreamer:dlstreamer \
     app.css \
     benchmark.py \
     chart.py \
-    cleanup_models.sh \
     device.py \
     explore.py \
     gstpipeline.py \
+    models/supported_models.lst \
+    models.py \
     optimize.py \
     utils.py \
     /home/dlstreamer/vippet/
 
 COPY --chown=dlstreamer:dlstreamer pipelines/ /home/dlstreamer/vippet/pipelines
 
-CMD ["/bin/bash", "-c", "./cleanup_models.sh; python app.py"]
+CMD ["/bin/bash", "-c", "python app.py"]

tools/visual-pipeline-and-platform-evaluation-tool/Makefile

@@ -7,7 +7,8 @@ SHELL := bash -eu -o pipefail
 .DEFAULT_GOAL := help
 .PHONY: all lint build mdlint ruff fix-linter format pyright run build-dev run-dev test \
 	shell shell-vippet shell-models shell-collector shell-videogenerator stop clean help \
-	public_models_choice reset_public_models_choice build-videogenerator docker-build
+	build-videogenerator build-models docker-build check-device-type \
+	install-models-once install-models-force install-models-all
 
 # Code Versions
 VERSION := v1.2
@@ -23,8 +24,6 @@ DEV_COMPOSE_FILE := compose.dev.yml
 # Python venv Target
 VENV_DIR := .venv
 
-PUBLIC_MODELS_ENV := .public_models_env
-
 # Placeholder to prevent warnings about missing variables.
 # This value is overridden by setup_env.sh in relevant targets.
 export RENDER_GROUP_ID := 1000
@@ -81,35 +80,20 @@ build-dev: check-device-type $(VENV_DIR) ## Build core dev images (vippet-app, v
 build-videogenerator: ## Build videogenerator image
 	DOCKER_TAG=$(VERSION) docker compose build videogenerator
 
+build-models: ## Build model image
+	DOCKER_TAG=$(VERSION) docker compose build models
+
 docker-build: ## Build all images
 	$(MAKE) build DEVICE_TYPE=$(or $(DEVICE_TYPE),CPU)
 	$(MAKE) build-videogenerator
+	$(MAKE) build-models
 
-public_models_choice: ## Ask if public models shall be downloaded
-	@if [ -f $(PUBLIC_MODELS_ENV) ]; then \
-		printf "Choice on downloading public models was already made, skipping prompt. "; \
-		printf "To reset choice run \`make reset_public_models_choice\`.\n"; \
-		exit 0; \
-	fi; \
-	read -p "Do you want to download public models? (y/n): " yn; \
-	case $$yn in \
-		y|Y|[yY][eE][sS]) DOWNLOAD_PUBLIC_MODELS=true ;; \
-		*) DOWNLOAD_PUBLIC_MODELS=false ;; \
-	esac; \
-	echo "DOWNLOAD_PUBLIC_MODELS set to $$DOWNLOAD_PUBLIC_MODELS" ;\
-	echo "DOWNLOAD_PUBLIC_MODELS=$$DOWNLOAD_PUBLIC_MODELS" > $(PUBLIC_MODELS_ENV)
-
-reset_public_models_choice: ## Reset choice on public models download
-	rm -rf $(PUBLIC_MODELS_ENV)
-
-run: check-device-type public_models_choice ## Run the docker compose services
+run: check-device-type install-models-once ## Run the docker compose services
 	source setup_env.sh -d $(DEVICE_TYPE) && \
-	mkdir -p models && chmod o+w models && \
 	DOCKER_TAG=$(VERSION) docker compose up -d
 
-run-dev: check-device-type public_models_choice ## Run the docker compose services for development
+run-dev: check-device-type install-models-once ## Run the docker compose services for development
 	source setup_env.sh -d $(DEVICE_TYPE) && \
-	mkdir -p models && chmod o+w models && \
 	DOCKER_TAG=$(VERSION) docker compose -f $(COMPOSE_FILE) -f $(DEV_COMPOSE_FILE) up -d
 
 test: $(VENV_DIR) ## Run tests and generate coverage report
@@ -119,6 +103,18 @@ test: $(VENV_DIR) ## Run tests and generate coverage report
 		python -m coverage run --source=./ --data-file=/tmp/.vippet-coverage -m unittest discover -v -s ./tests -p '*_test.py' && \
 		python -m coverage report --data-file=/tmp/.vippet-coverage --omit=*/config-3.py,*/config.py,*_test.py"
 
+install-models-once: ## Handle models download and installation (once)
+	mkdir -p models/output && chmod o+w models/output
+	MODEL_INSTALLATION=once DOCKER_TAG=$(VERSION) docker compose run --rm -it models
+
+install-models-force: ## Handle models download and installation (force)
+	mkdir -p models/output && chmod o+w models/output
+	MODEL_INSTALLATION=force DOCKER_TAG=$(VERSION) docker compose run --rm -it models
+
+install-models-all: ## Install all models automatically (no dialog)
+	mkdir -p models/output && chmod o+w models/output
+	MODEL_INSTALLATION=all DOCKER_TAG=$(VERSION) docker compose run --rm -it models
+
 shell: ## Open shell in specified container (i.e. make shell SERVICE=vippet-gpu)
 	docker exec -it $(SERVICE) bash
 
@@ -140,7 +136,7 @@ stop: ## Stop the docker compose services
 	DOCKER_TAG=$(VERSION) docker compose down models collector videogenerator $$VIPPET_SERVICE
 
 clean: ## Clean all build artifacts
-	rm -rf .collector-signals/ models/ videos/
+	rm -rf .collector-signals/ models/output/ videos/
 
 help: ## Print help for each target
 	@echo ViPPET make targets

tools/visual-pipeline-and-platform-evaluation-tool/app.py

@@ -1,5 +1,6 @@
 import logging
 import os
+import sys
 from datetime import datetime
 from typing import Dict, List, Optional, Tuple
 
@@ -16,6 +17,7 @@
 from optimize import PipelineOptimizer
 from gstpipeline import GstPipeline, PipelineLoader
 from utils import prepare_video_and_constants
+from models import SupportedModelsManager
 
 logging.getLogger("httpx").setLevel(logging.WARNING)
 
@@ -41,6 +43,11 @@
 )
 gst_inspector = GstInspector()
 device_discovery = DeviceDiscovery()
+try:
+    supported_models_manager = SupportedModelsManager()
+except Exception as e:
+    logging.error(str(e))
+    sys.exit(1)
 
 # Device detection and chart title logic
 charts: List[Chart] = create_charts(device_discovery.list_devices())
@@ -674,17 +681,8 @@ def create_interface(title: str = "Visual Pipeline and Platform Evaluation Tool"
     # Mapping of these choices to actual model path in utils.py
     object_detection_model = gr.Dropdown(
         label="Object Detection Model",
-        choices=[
-            "SSDLite MobileNet V2 (INT8)",
-            "YOLO v5m 416x416 (INT8)",
-            "YOLO v5s 416x416 (INT8)",
-            "YOLO v5m 640x640 (INT8)",
-            "YOLO v10s 640x640 (FP16)",
-            "YOLO v10m 640x640 (FP16)",
-            "YOLO v8 License Plate Detector (FP32)",
-        ],
-        value="YOLO v5s 416x416 (INT8)",
         elem_id="object_detection_model",
+        # choices and value will be set for each pipeline later
     )
 
     # Object detection device
@@ -732,16 +730,8 @@ def create_interface(title: str = "Visual Pipeline and Platform Evaluation Tool"
     # Mapping of these choices to actual model path in utils.py
     object_classification_model = gr.Dropdown(
         label="Object Classification Model",
-        choices=[
-            "Disabled",
-            "EfficientNet B0 (INT8)",
-            "MobileNet V2 PyTorch (FP16)",
-            "ResNet-50 TF (INT8)",
-            "PaddleOCR (FP32)",
-            "Vehicle Attributes Recognition Barrier 0039 (FP16)",
-        ],
-        value="ResNet-50 TF (INT8)",
         elem_id="object_classification_model",
+        # choices and value will be set for each pipeline later
     )
 
     # Object classification device
@@ -1112,23 +1102,38 @@ def create_interface(title: str = "Visual Pipeline and Platform Evaluation Tool"
                                 None,
                                 inferencing_channels,
                             ).then(
+                                # Read supported models and update the model dropdowns every time a new pipeline is selected
+                                # (list of models may change)
                                 lambda: [
-                                    gr.Dropdown(
-                                        choices=current_pipeline[1]["parameters"][
-                                            "inference"
-                                        ]["detection_models"],
-                                        value=current_pipeline[1]["parameters"][
-                                            "inference"
-                                        ]["detection_model_default"],
-                                    ),
-                                    gr.Dropdown(
-                                        choices=current_pipeline[1]["parameters"][
-                                            "inference"
-                                        ]["classification_models"],
-                                        value=current_pipeline[1]["parameters"][
-                                            "inference"
-                                        ]["classification_model_default"],
-                                    ),
+                                    *(
+                                        lambda det, cls: [
+                                            gr.Dropdown(
+                                                choices=det[0],
+                                                value=det[1],
+                                            ),
+                                            gr.Dropdown(
+                                                choices=cls[0],
+                                                value=cls[1],
+                                            ),
+                                        ]
+                                    )(
+                                        supported_models_manager.filter_detection_models(
+                                            current_pipeline[1]["parameters"][
+                                                "inference"
+                                            ]["detection_models"],
+                                            current_pipeline[1]["parameters"][
+                                                "inference"
+                                            ]["detection_model_default"],
+                                        ),
+                                        supported_models_manager.filter_classification_models(
+                                            current_pipeline[1]["parameters"][
+                                                "inference"
+                                            ]["classification_models"],
+                                            current_pipeline[1]["parameters"][
+                                                "inference"
+                                            ]["classification_model_default"],
+                                        ),
+                                    )
                                 ],
                                 outputs=[
                                     object_detection_model,

tools/visual-pipeline-and-platform-evaluation-tool/cleanup_models.sh

@@ -14,41 +14,42 @@ x-vippet: &vippet
     interval: 30s
     timeout: 10s
     retries: 5
-  depends_on:
-    models:
-      condition: service_completed_successfully
   restart: on-failure:5
   environment:
     GST_DEBUG: "1"
     TZ: America/Los_Angeles
     PIPELINE: smartnvr
+    MODELS_PATH: /home/dlstreamer/vippet/models
     http_proxy: ${http_proxy}
     https_proxy: ${https_proxy}
     no_proxy: ${no_proxy}
-  env_file:
-    - path: '.public_models_env'
-      required: false
   volumes:
     - collector-signals:/home/dlstreamer/vippet/.collector-signals
-    - ./models:/home/dlstreamer/vippet/models
+    - ./models/output:/home/dlstreamer/vippet/models
 
 services:
   models:
-    image: intel/dlstreamer:2025.1.2-ubuntu24
+    profiles: [do-not-start]
+    image: docker.io/intel/vippet-models:${DOCKER_TAG}
+    build:
+      context: models
+      dockerfile: Dockerfile
+      args:
+        http_proxy:
+        https_proxy:
+        no_proxy:
+    stdin_open: true
+    tty: true
     container_name: models
     volumes:
-      - ./models/:/output
-      - ./models.sh:/home/dlstreamer/models.sh
+      - ./models/output/:/output
     environment:
-      - MODELS_PATH=/output/
+      - MODELS_PATH=/output
+      - MODEL_INSTALLATION=${MODEL_INSTALLATION:-once}
       - http_proxy=${http_proxy}
       - https_proxy=${https_proxy}
       - no_proxy=${no_proxy}
-    env_file:
-      - path: '.public_models_env'
-        required: false
-    command: './models.sh'
-    restart: on-failure:5
+    command: './model_manager.sh'
   vippet-cpu:
     <<: *vippet
     container_name: vippet-cpu
@@ -123,4 +124,3 @@ volumes:
     driver_opts:
       type: tmpfs
       device: tmpfs
-

tools/visual-pipeline-and-platform-evaluation-tool/compose.yml

@@ -23,7 +23,7 @@ By following this guide, you will learn how to:
     - Create and navigate to the directory:
 
       ```bash
-      mkdir visual-pipeline-and-platform-evaluation-tool
+      mkdir -p visual-pipeline-and-platform-evaluation-tool/models
       cd visual-pipeline-and-platform-evaluation-tool
       ```
 
@@ -33,15 +33,17 @@ By following this guide, you will learn how to:
       curl -LO "https://github.com/open-edge-platform/edge-ai-libraries/raw/refs/heads/main/tools/visual-pipeline-and-platform-evaluation-tool/setup_env.sh"
       curl -LO "https://github.com/open-edge-platform/edge-ai-libraries/raw/refs/heads/main/tools/visual-pipeline-and-platform-evaluation-tool/compose.yml"
       curl -LO "https://github.com/open-edge-platform/edge-ai-libraries/raw/refs/heads/main/tools/visual-pipeline-and-platform-evaluation-tool/Makefile"
-      curl -LO "https://github.com/open-edge-platform/edge-ai-libraries/raw/refs/heads/main/tools/visual-pipeline-and-platform-evaluation-tool/models.sh"
-      chmod +x models.sh
+      curl -Lo models/Dockerfile "https://github.com/open-edge-platform/edge-ai-libraries/raw/refs/heads/main/tools/visual-pipeline-and-platform-evaluation-tool/models/Dockerfile"
+      curl -Lo models/model_manager.sh "https://github.com/open-edge-platform/edge-ai-libraries/raw/refs/heads/main/tools/visual-pipeline-and-platform-evaluation-tool/models/model_manager.sh"
+      curl -Lo models/supported_models.lst "https://github.com/open-edge-platform/edge-ai-libraries/raw/refs/heads/main/tools/visual-pipeline-and-platform-evaluation-tool/models/supported_models.lst"
+      chmod +x models/model_manager.sh
       ```
 
 2. **Start the Application**:
     - Set the appropriate device type (CPU, GPU, or NPU) and run the following command:
 
       ```bash
-      make run DEVICE_TYPE=<CPU/GPU/NPU>
+      make build-models run DEVICE_TYPE=<CPU/GPU/NPU>
       ```
 
 3. **Verify the Application**:
@@ -70,6 +72,18 @@ For alternative ways to set up the sample application, see:
 
 - [How to Build from Source](./how-to-build-source.md)
 
+### Model Installation and Management
+
+When you first launch the Visual Pipeline and Platform Evaluation Tool,
+you will be prompted to select and install the models you wish to use.
+This step allows you to choose only the models relevant to your intended pipelines.
+
+If you want to manage your installed models again, run the following command:
+
+```bash
+make install-models-force
+```
+
 ### Known Issues
 
 - **Issue 1**: The Visual Pipeline and Platform Evaluation Tool container fails to start the analysis when the "Run"