Merge pull request #293 from HyperInspire/develop

Adapt Python-SDK to download models from modelscope

Author: tunmx

ci/quick_test_linux_x86_usual_python_native_interface.sh

@@ -38,6 +38,8 @@ cp build/${BUILD_DIRNAME}/lib/libInspireFace.so python/inspireface/modules/core/
 pip install opencv-python
 pip install click
 pip install loguru
+pip install filelock
+pip install modelscope
 
 cd python/
 

cpp/inspireface/middleware/any_net_adapter.h

@@ -38,7 +38,9 @@ class INSPIRE_API AnyNetAdapter {
      */
     explicit AnyNetAdapter(std::string name) : m_name_(std::move(name)) {
         m_processor_ = nexus::ImageProcessor::Create(INSPIREFACE_CONTEXT->GetImageProcessingBackend());
+#if defined(ISF_ENABLE_RKNN)
         m_processor_->SetAlignedWidth(INSPIREFACE_CONTEXT->GetImageProcessAlignedWidth());
+#endif
     }
 
     ~AnyNetAdapter() {

python/.gitignore

@@ -26,5 +26,4 @@ share/python-wheels/
 .pytest_cache/
 .idea/
 *.db
-version.txt
-post
+version.txt

python/inspireface/modules/__init__.py

@@ -8,4 +8,4 @@
     HF_PK_AUTO_INCREMENT, HF_PK_MANUAL_INPUT, HF_SEARCH_MODE_EAGER, HF_SEARCH_MODE_EXHAUSTIVE, \
     ignore_check_latest_model, set_cuda_device_id, get_cuda_device_id, print_cuda_device_info, get_num_cuda_devices, check_cuda_device_support, terminate, \
     InspireFaceError, InvalidInputError, SystemNotReadyError, ProcessingError, ResourceError, HardwareError, FeatureHubError, \
-    switch_image_processing_backend, HF_IMAGE_PROCESSING_CPU, HF_IMAGE_PROCESSING_RGA, set_image_process_aligned_width
+    switch_image_processing_backend, HF_IMAGE_PROCESSING_CPU, HF_IMAGE_PROCESSING_RGA, set_image_process_aligned_width, use_oss_download

python/inspireface/modules/inspireface.py

@@ -6,6 +6,7 @@
 from dataclasses import dataclass
 from loguru import logger
 from .utils import ResourceManager
+from .utils.resource import set_use_oss_download
 from . import herror as errcode
 # Exception system
 from .exception import (
@@ -22,6 +23,14 @@ def ignore_check_latest_model(ignore: bool):
     global IGNORE_VERIFICATION_OF_THE_LATEST_MODEL
     IGNORE_VERIFICATION_OF_THE_LATEST_MODEL = ignore
 
+def use_oss_download(use_oss: bool = True):
+    """Enable OSS download instead of ModelScope (for backward compatibility)
+    
+    Args:
+        use_oss (bool): If True, use OSS download; if False, use ModelScope (default)
+    """
+    set_use_oss_download(use_oss)
+
 class ImageStream(object):
     """
     ImageStream class handles the conversion of image data from various sources into a format compatible with the InspireFace library.
@@ -303,15 +312,18 @@ def __init__(self, param, detect_mode: int = HF_DETECT_MODE_ALWAYS_DETECT,
             SystemNotReadyError: If InspireFace is not launched.
             ProcessingError: If session creation fails.
         """
+        # Initialize _sess to None first to prevent AttributeError in __del__
+        self._sess = None
+        self.multiple_faces = None
+        self.param = param
+        
         # If InspireFace is not initialized, run launch() use Pikachu model
         if not query_launch_status():
             ret = launch()
             if not ret:
                 raise SystemNotReadyError("Failed to launch InspireFace automatically")
 
-        self.multiple_faces = None
         self._sess = HFSession()
-        self.param = param
 
         if isinstance(self.param, SessionCustomParameter):
             ret = HFCreateInspireFaceSession(self.param._c_struct(), detect_mode, max_detect_num, detect_pixel_level,
@@ -700,6 +712,38 @@ def __del__(self):
 
 
 # == Global API ==
+
+def _check_modelscope_availability():
+    """
+    Check if ModelScope is available when needed and provide helpful error message if not.
+    
+    Exits the program if ModelScope is needed but not available and OSS is not enabled.
+    """
+    import sys
+    from .utils.resource import USE_OSS_DOWNLOAD
+    
+    # Dynamic check for ModelScope availability (don't rely on cached MODELSCOPE_AVAILABLE)
+    modelscope_available = True
+    try:
+        from modelscope.hub.snapshot_download import snapshot_download
+        print("ModelScope import successful")
+    except Exception as e:
+        modelscope_available = False
+        print(f"ModelScope import failed: {e}")
+    
+    if not USE_OSS_DOWNLOAD and not modelscope_available:
+        print("ModelScope is not available, cannot download models!")
+        print("\nPlease choose one of the following solutions:")
+        print("1. Reinstall ModelScope with all dependencies:")
+        print("   pip install --upgrade modelscope")
+        print("\n2. Install missing dependencies manually:")
+        print("   pip install filelock")
+        print("\n3. Switch to OSS download mode:")
+        print("   import inspireface as isf")
+        print("   isf.use_oss_download(True)  # Execute before calling launch()")
+        print("\nNote: OSS download requires stable international network connection")
+        sys.exit(1)
+
 def launch(model_name: str = "Pikachu", resource_path: str = None) -> bool:
     """
     Launches the InspireFace system with the specified resource directory.
@@ -715,7 +759,13 @@ def launch(model_name: str = "Pikachu", resource_path: str = None) -> bool:
         SystemNotReadyError: If launch fails due to resource issues.
     """
     if resource_path is None:
-        sm = ResourceManager()
+        from .utils.resource import USE_OSS_DOWNLOAD
+        
+        # Check if ModelScope is available when needed
+        _check_modelscope_availability()
+        
+        # Use ModelScope by default unless OSS is forced
+        sm = ResourceManager(use_modelscope=not USE_OSS_DOWNLOAD)
         resource_path = sm.get_model(model_name, ignore_verification=IGNORE_VERIFICATION_OF_THE_LATEST_MODEL)
     path_c = String(bytes(resource_path, encoding="utf8"))
     ret = HFLaunchInspireFace(path_c)
@@ -737,7 +787,12 @@ def pull_latest_model(model_name: str = "Pikachu") -> str:
     Returns:
         str: Path to the downloaded model.
     """
-    sm = ResourceManager()
+    from .utils.resource import USE_OSS_DOWNLOAD
+    
+    # Check if ModelScope is available when needed
+    _check_modelscope_availability()
+    
+    sm = ResourceManager(use_modelscope=not USE_OSS_DOWNLOAD)
     resource_path = sm.get_model(model_name, re_download=True)
     return resource_path
 
@@ -753,7 +808,12 @@ def reload(model_name: str = "Pikachu", resource_path: str = None) -> bool:
         bool: True if reload was successful.
     """
     if resource_path is None:
-        sm = ResourceManager()
+        from .utils.resource import USE_OSS_DOWNLOAD
+        
+        # Check if ModelScope is available when needed
+        _check_modelscope_availability()
+        
+        sm = ResourceManager(use_modelscope=not USE_OSS_DOWNLOAD)
         resource_path = sm.get_model(model_name, ignore_verification=IGNORE_VERIFICATION_OF_THE_LATEST_MODEL)
     path_c = String(bytes(resource_path, encoding="utf8"))
     ret = HFReloadInspireFace(path_c)

python/inspireface/modules/utils/resource.py

@@ -1,10 +1,43 @@
+"""
+InspireFace Resource Manager
+
+This module provides model downloading functionality with two modes:
+1. Original mode: Download models from COS (Tencent Cloud Object Storage)
+2. ModelScope mode: Download models from ModelScope platform
+
+ModelScope mode usage:
+    rm = ResourceManager(use_modelscope=True, modelscope_model_id="tunmxy/InspireFace")
+    model_path = rm.get_model("Gundam_RV1106")
+
+Requirements for ModelScope mode:
+    pip install modelscope
+"""
+
 import os
 import sys
 from pathlib import Path
 import urllib.request
 import ssl
 import hashlib
 
+try:
+    from modelscope.hub.snapshot_download import snapshot_download
+    MODELSCOPE_AVAILABLE = True
+except ImportError:
+    MODELSCOPE_AVAILABLE = False
+
+# Global configuration for resource downloading
+USE_OSS_DOWNLOAD = False  # If True, force use OSS download instead of ModelScope
+
+def set_use_oss_download(use_oss: bool):
+    """Set whether to use OSS download instead of ModelScope
+    
+    Args:
+        use_oss (bool): If True, use OSS download; if False, use ModelScope (default)
+    """
+    global USE_OSS_DOWNLOAD
+    USE_OSS_DOWNLOAD = use_oss
+
 def get_file_hash_sha256(file_path):
     sha256 = hashlib.sha256()
     with open(file_path, 'rb') as f:
@@ -13,15 +46,35 @@ def get_file_hash_sha256(file_path):
     return sha256.hexdigest()
 
 class ResourceManager:
-    def __init__(self):
-        """Initialize resource manager and create necessary directories"""
+    def __init__(self, use_modelscope: bool = True, modelscope_model_id: str = "tunmxy/InspireFace"):
+        """Initialize resource manager and create necessary directories
+        
+        Args:
+            use_modelscope: Whether to download models from ModelScope platform
+            modelscope_model_id: ModelScope model ID (default: tunmxy/InspireFace)
+        """
         self.user_home = Path.home()
         self.base_dir = self.user_home / '.inspireface'
         self.models_dir = self.base_dir / 'models'
 
+        # ModelScope configuration
+        self.use_modelscope = use_modelscope
+        self.modelscope_model_id = modelscope_model_id
+        self.modelscope_cache_dir = self.base_dir / 'ms'
+        
         # Create directories
         self.base_dir.mkdir(exist_ok=True)
         self.models_dir.mkdir(exist_ok=True)
+        if self.use_modelscope:
+            self.modelscope_cache_dir.mkdir(exist_ok=True)
+            
+        # Check ModelScope availability
+        if self.use_modelscope and not MODELSCOPE_AVAILABLE:
+            raise ImportError(
+                "ModelScope is not available. You have two options:\n"
+                "1. Install ModelScope: pip install modelscope\n" 
+                "2. Switch to OSS download mode by calling: inspireface.use_oss_download(True) before using InspireFace"
+            )
 
         # Model URLs
         self._MODEL_LIST = {
@@ -52,6 +105,39 @@ def __init__(self):
             }
         }
 
+    def _download_from_modelscope(self, model_name: str) -> str:
+        """Download model from ModelScope platform
+        
+        Args:
+            model_name: Name of the model to download
+            
+        Returns:
+            str: Path to the downloaded model file
+        """
+        if not MODELSCOPE_AVAILABLE:
+            raise ImportError("ModelScope is not available. Please install it with: pip install modelscope")
+            
+        print(f"Downloading model '{model_name}' from ModelScope...")
+        
+        try:
+            # Download specific model file from ModelScope
+            cache_dir = snapshot_download(
+                model_id=self.modelscope_model_id,
+                cache_dir=str(self.modelscope_cache_dir),
+                allow_file_pattern=[model_name]  # Only download the specific model file
+            )
+            
+            model_file_path = Path(cache_dir) / model_name
+            
+            if not model_file_path.exists():
+                raise FileNotFoundError(f"Model file '{model_name}' not found in downloaded repository")
+                
+            print(f"ModelScope download completed: {model_file_path}")
+            return str(model_file_path)
+            
+        except Exception as e:
+            raise RuntimeError(f"Failed to download model from ModelScope: {e}")
+
     def get_model(self, name: str, re_download: bool = False, ignore_verification: bool = False) -> str:
         """
         Get model path. Download if not exists or re_download is True.
@@ -64,6 +150,15 @@ def get_model(self, name: str, re_download: bool = False, ignore_verification: b
         Returns:
             str: Full path to model file
         """
+        # Check global OSS setting first, then instance setting
+        use_oss = USE_OSS_DOWNLOAD
+        use_modelscope_actual = self.use_modelscope and not use_oss
+        
+        # Use ModelScope download if enabled and OSS is not forced
+        if use_modelscope_actual:
+            return self._download_from_modelscope_with_cache(name, re_download)
+            
+        # Original download logic for backwards compatibility
         if name not in self._MODEL_LIST:
             raise ValueError(f"Model '{name}' not found. Available models: {list(self._MODEL_LIST.keys())}")
 
@@ -124,13 +219,51 @@ def get_model(self, name: str, re_download: bool = False, ignore_verification: b
             if downloading_flag.exists():
                 downloading_flag.unlink()
             raise RuntimeError(f"Failed to download model: {e}")
+
+    def _download_from_modelscope_with_cache(self, name: str, re_download: bool = False) -> str:
+        """Download model from ModelScope with local caching logic
+        
+        Args:
+            name: Model name
+            re_download: Force re-download if True
+            
+        Returns:
+            str: Path to the model file
+        """
+        # Check if model exists in ModelScope cache
+        model_file_path = self.modelscope_cache_dir / name
 
-# Usage example
+        if model_file_path.exists() and not re_download:
+            print(f"Using cached model '{name}' from ModelScope")
+            return str(model_file_path)
+            
+        # Download from ModelScope
+        return self._download_from_modelscope(name)
+        
+# Usage examples
 if __name__ == "__main__":
     try:
+        # Example 1: Default mode (ModelScope)
+        print("=== Default mode (ModelScope) ===")
         rm = ResourceManager()
-        model_path = rm.get_model("Pikachu")
-        print(f"Model path: {model_path}")
+        model_path = rm.get_model("Gundam_RV1106")
+        print(f"ModelScope model path: {model_path}")
+        
+        # Example 2: Force OSS mode using global setting
+        print("\n=== OSS mode (global setting) ===")
+        set_use_oss_download(True)
+        rm_oss = ResourceManager()
+        model_path_oss = rm_oss.get_model("Pikachu")
+        print(f"OSS model path: {model_path_oss}")
+        
+        # Reset to default
+        set_use_oss_download(False)
+        
+        # Example 3: Explicit ModelScope mode
+        print("\n=== Explicit ModelScope mode ===")
+        rm_ms = ResourceManager(use_modelscope=True, modelscope_model_id="tunmxy/InspireFace")
+        model_path_ms = rm_ms.get_model("Gundam_RV1106")
+        print(f"Explicit ModelScope model path: {model_path_ms}")
 
     except Exception as e:
         print(f"Error: {e}")

python/post

@@ -2,7 +2,6 @@
 import cv2
 import inspireface as isf
 import click
-import numpy as np
 
 race_tags = ["Black", "Asian", "Latino/Hispanic", "Middle Eastern", "White"]
 gender_tags = ["Female", "Male"]

python/sample_face_detection.py

@@ -122,7 +122,9 @@ def get_target_platform_for_envs():
     },
     install_requires=[
         'numpy',
-        'loguru'
+        'loguru',
+        'filelock',
+        'modelscope'
     ],
     author='Jingyu Yan',
     author_email='tunmxy@163.com',