BREAKING CHANGES: invocations now require model key, not base/type/name

- Implement new model loader and modify invocations and embeddings

- Finish implementation loaders for all models currently supported by
  InvokeAI.

- Move lora, textual_inversion, and model patching support into
  backend/embeddings.

- Restore support for model cache statistics collection (a little ugly,
  needs work).

- Fixed up invocations that load and patch models.

- Move seamless and silencewarnings utils into better location

invokeai/backend/model_manager/config.py

@@ -30,8 +30,11 @@ from typing_extensions import Annotated, Any, Dict
 
 from invokeai.backend.onnx.onnx_runtime import IAIOnnxRuntimeModel
 
+from ..embeddings.embedding_base import EmbeddingModelRaw
 from ..ip_adapter.ip_adapter import IPAdapter, IPAdapterPlus
 
+AnyModel = Union[ModelMixin, torch.nn.Module, IAIOnnxRuntimeModel, IPAdapter, IPAdapterPlus, EmbeddingModelRaw]
+
 
 class InvalidModelConfigException(Exception):
     """Exception for when config parser doesn't recognized this combination of model type and format."""
@@ -299,7 +302,7 @@ AnyModelConfig = Union[
 ]
 
 AnyModelConfigValidator = TypeAdapter(AnyModelConfig)
-AnyModel = Union[ModelMixin, torch.nn.Module, IAIOnnxRuntimeModel, IPAdapter, IPAdapterPlus]
+
 
 # IMPLEMENTATION NOTE:
 # The preferred alternative to the above is a discriminated Union as shown

invokeai/backend/model_manager/load/load_base.py

@@ -18,8 +18,8 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Optional, Tuple, Type
 
 from invokeai.app.services.config import InvokeAIAppConfig
-from invokeai.backend.model_manager import AnyModel, AnyModelConfig, BaseModelType, ModelFormat, ModelType, SubModelType
-from invokeai.backend.model_manager.config import VaeCheckpointConfig, VaeDiffusersConfig
+from invokeai.backend.model_manager import AnyModelConfig, BaseModelType, ModelFormat, ModelType, SubModelType
+from invokeai.backend.model_manager.config import AnyModel, VaeCheckpointConfig, VaeDiffusersConfig
 from invokeai.backend.model_manager.load.convert_cache.convert_cache_base import ModelConvertCacheBase
 from invokeai.backend.model_manager.load.model_cache.model_cache_base import ModelCacheBase, ModelLockerBase
 from invokeai.backend.util.logging import InvokeAILogger

invokeai/backend/model_manager/load/load_default.py

@@ -19,7 +19,7 @@ from invokeai.backend.model_manager import (
 )
 from invokeai.backend.model_manager.load.convert_cache import ModelConvertCacheBase
 from invokeai.backend.model_manager.load.load_base import LoadedModel, ModelLoaderBase
-from invokeai.backend.model_manager.load.model_cache.model_cache_base import ModelCacheBase, ModelLockerBase
+from invokeai.backend.model_manager.load.model_cache.model_cache_base import CacheStats, ModelCacheBase, ModelLockerBase
 from invokeai.backend.model_manager.load.model_util import calc_model_size_by_data, calc_model_size_by_fs
 from invokeai.backend.model_manager.load.optimizations import skip_torch_weight_init
 from invokeai.backend.util.devices import choose_torch_device, torch_dtype
@@ -71,7 +71,7 @@ class ModelLoader(ModelLoaderBase):
         model_path, model_config, submodel_type = self._get_model_path(model_config, submodel_type)
 
         if not model_path.exists():
-            raise InvalidModelConfigException(f"Files for model 'model_config.name' not found at {model_path}")
+            raise InvalidModelConfigException(f"Files for model '{model_config.name}' not found at {model_path}")
 
         model_path = self._convert_if_needed(model_config, model_path, submodel_type)
         locker = self._load_if_needed(model_config, model_path, submodel_type)

invokeai/backend/model_manager/load/model_cache/__init__.py

@@ -1,4 +1,6 @@
 """Init file for ModelCache."""
 
+from .model_cache_base import ModelCacheBase, CacheStats  # noqa F401
+from .model_cache_default import ModelCache  # noqa F401
 
-_all__ = ["ModelCacheBase", "ModelCache"]
+_all__ = ["ModelCacheBase", "ModelCache", "CacheStats"]

invokeai/backend/model_manager/load/model_cache/model_cache_base.py

@@ -8,13 +8,13 @@ model will be cleared and (re)loaded from disk when next needed.
 """
 
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from logging import Logger
-from typing import Generic, Optional, TypeVar
+from typing import Dict, Generic, Optional, TypeVar
 
 import torch
 
-from invokeai.backend.model_manager import AnyModel, SubModelType
+from invokeai.backend.model_manager.config import AnyModel, SubModelType
 
 
 class ModelLockerBase(ABC):
@@ -65,6 +65,19 @@ class CacheRecord(Generic[T]):
         return self._locks > 0
 
 
+@dataclass
+class CacheStats(object):
+    """Collect statistics on cache performance."""
+
+    hits: int = 0  # cache hits
+    misses: int = 0  # cache misses
+    high_watermark: int = 0  # amount of cache used
+    in_cache: int = 0  # number of models in cache
+    cleared: int = 0  # number of models cleared to make space
+    cache_size: int = 0  # total size of cache
+    loaded_model_sizes: Dict[str, int] = field(default_factory=dict)
+
+
 class ModelCacheBase(ABC, Generic[T]):
     """Virtual base class for RAM model cache."""
 
@@ -98,10 +111,22 @@ class ModelCacheBase(ABC, Generic[T]):
         pass
 
     @abstractmethod
-    def move_model_to_device(self, cache_entry: CacheRecord, device: torch.device) -> None:
+    def move_model_to_device(self, cache_entry: CacheRecord[AnyModel], device: torch.device) -> None:
         """Move model into the indicated device."""
         pass
 
+    @property
+    @abstractmethod
+    def stats(self) -> CacheStats:
+        """Return collected CacheStats object."""
+        pass
+
+    @stats.setter
+    @abstractmethod
+    def stats(self, stats: CacheStats) -> None:
+        """Set the CacheStats object for collectin cache statistics."""
+        pass
+
     @property
     @abstractmethod
     def logger(self) -> Logger:

invokeai/backend/model_manager/load/model_cache/model_cache_default.py

@@ -24,19 +24,17 @@ import math
 import sys
 import time
 from contextlib import suppress
-from dataclasses import dataclass, field
 from logging import Logger
 from typing import Dict, List, Optional
 
 import torch
 
-from invokeai.backend.model_manager import SubModelType
-from invokeai.backend.model_manager.load.load_base import AnyModel
+from invokeai.backend.model_manager import AnyModel, SubModelType
 from invokeai.backend.model_manager.load.memory_snapshot import MemorySnapshot, get_pretty_snapshot_diff
 from invokeai.backend.util.devices import choose_torch_device
 from invokeai.backend.util.logging import InvokeAILogger
 
-from .model_cache_base import CacheRecord, ModelCacheBase
+from .model_cache_base import CacheRecord, CacheStats, ModelCacheBase
 from .model_locker import ModelLocker, ModelLockerBase
 
 if choose_torch_device() == torch.device("mps"):
@@ -56,20 +54,6 @@ GIG = 1073741824
 MB = 2**20
 
 
-@dataclass
-class CacheStats(object):
-    """Collect statistics on cache performance."""
-
-    hits: int = 0  # cache hits
-    misses: int = 0  # cache misses
-    high_watermark: int = 0  # amount of cache used
-    in_cache: int = 0  # number of models in cache
-    cleared: int = 0  # number of models cleared to make space
-    cache_size: int = 0  # total size of cache
-    # {submodel_key => size}
-    loaded_model_sizes: Dict[str, int] = field(default_factory=dict)
-
-
 class ModelCache(ModelCacheBase[AnyModel]):
     """Implementation of ModelCacheBase."""
 
@@ -110,7 +94,7 @@ class ModelCache(ModelCacheBase[AnyModel]):
         self._logger = logger or InvokeAILogger.get_logger(self.__class__.__name__)
         self._log_memory_usage = log_memory_usage or self._logger.level == logging.DEBUG
         # used for stats collection
-        self.stats = CacheStats()
+        self._stats: Optional[CacheStats] = None
 
         self._cached_models: Dict[str, CacheRecord[AnyModel]] = {}
         self._cache_stack: List[str] = []
@@ -140,6 +124,16 @@ class ModelCache(ModelCacheBase[AnyModel]):
         """Return the cap on cache size."""
         return self._max_cache_size
 
+    @property
+    def stats(self) -> Optional[CacheStats]:
+        """Return collected CacheStats object."""
+        return self._stats
+
+    @stats.setter
+    def stats(self, stats: CacheStats) -> None:
+        """Set the CacheStats object for collectin cache statistics."""
+        self._stats = stats
+
     def cache_size(self) -> int:
         """Get the total size of the models currently cached."""
         total = 0
@@ -189,21 +183,24 @@ class ModelCache(ModelCacheBase[AnyModel]):
         """
         key = self._make_cache_key(key, submodel_type)
         if key in self._cached_models:
-            self.stats.hits += 1
+            if self.stats:
+                self.stats.hits += 1
         else:
-            self.stats.misses += 1
+            if self.stats:
+                self.stats.misses += 1
             raise IndexError(f"The model with key {key} is not in the cache.")
 
         cache_entry = self._cached_models[key]
 
         # more stats
-        stats_name = stats_name or key
-        self.stats.cache_size = int(self._max_cache_size * GIG)
-        self.stats.high_watermark = max(self.stats.high_watermark, self.cache_size())
-        self.stats.in_cache = len(self._cached_models)
-        self.stats.loaded_model_sizes[stats_name] = max(
-            self.stats.loaded_model_sizes.get(stats_name, 0), cache_entry.size
-        )
+        if self.stats:
+            stats_name = stats_name or key
+            self.stats.cache_size = int(self._max_cache_size * GIG)
+            self.stats.high_watermark = max(self.stats.high_watermark, self.cache_size())
+            self.stats.in_cache = len(self._cached_models)
+            self.stats.loaded_model_sizes[stats_name] = max(
+                self.stats.loaded_model_sizes.get(stats_name, 0), cache_entry.size
+            )
 
         # this moves the entry to the top (right end) of the stack
         with suppress(Exception):

invokeai/backend/model_manager/load/model_loaders/textual_inversion.py

@@ -5,7 +5,7 @@
 from pathlib import Path
 from typing import Optional, Tuple
 
-from invokeai.backend.embeddings.model_patcher import TextualInversionModel as TextualInversionModelRaw
+from invokeai.backend.embeddings.textual_inversion import TextualInversionModelRaw
 from invokeai.backend.model_manager import (
     AnyModel,
     AnyModelConfig,