WIP - still need to figure out why the keys are wrong.

invokeai/app/api/routers/model_manager.py

@@ -614,8 +614,8 @@ async def convert_model(
     The return value is the model configuration for the converted model.
     """
     model_manager = ApiDependencies.invoker.services.model_manager
-    loader = model_manager.load
     logger = ApiDependencies.invoker.services.logger
+    loader = ApiDependencies.invoker.services.model_manager.load
     store = ApiDependencies.invoker.services.model_manager.store
     installer = ApiDependencies.invoker.services.model_manager.install
 
@@ -630,13 +630,7 @@ async def convert_model(
         raise HTTPException(400, f"The model with key {key} is not a main checkpoint model.")
 
     # loading the model will convert it into a cached diffusers file
-    try:
-        cc_size = loader.convert_cache.max_size
-        if cc_size == 0:  # temporary set the convert cache to a positive number so that cached model is written
-            loader._convert_cache.max_size = 1.0
-        loader.load_model(model_config, submodel_type=SubModelType.Scheduler)
-    finally:
-        loader._convert_cache.max_size = cc_size
+    model_manager.load.load_model(model_config, submodel_type=SubModelType.Scheduler)
 
     # Get the path of the converted model from the loader
     cache_path = loader.convert_cache.cache_path(key)

invokeai/app/invocations/compel.py

@@ -9,7 +9,8 @@ from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField
 from invokeai.app.invocations.primitives import ConditioningOutput
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.util.ti_utils import generate_ti_list
-from invokeai.backend.lora import LoRAModelRaw
+from invokeai.backend.lora_model_patcher import LoraModelPatcher
+from invokeai.backend.lora_model_raw import LoRAModelRaw
 from invokeai.backend.model_patcher import ModelPatcher
 from invokeai.backend.stable_diffusion.diffusion.conditioning_data import (
     BasicConditioningInfo,
@@ -80,7 +81,8 @@ class CompelInvocation(BaseInvocation):
             ),
             text_encoder_info as text_encoder,
             # Apply the LoRA after text_encoder has been moved to its target device for faster patching.
-            ModelPatcher.apply_lora_text_encoder(text_encoder, _lora_loader()),
+            # ModelPatcher.apply_lora_text_encoder(text_encoder, _lora_loader()),
+            LoraModelPatcher.apply_lora_to_text_encoder(text_encoder, _lora_loader(), "text_encoder"),
             # Apply CLIP Skip after LoRA to prevent LoRA application from failing on skipped layers.
             ModelPatcher.apply_clip_skip(text_encoder_model, self.clip.skipped_layers),
         ):
@@ -181,7 +183,8 @@ class SDXLPromptInvocationBase:
             ),
             text_encoder_info as text_encoder,
             # Apply the LoRA after text_encoder has been moved to its target device for faster patching.
-            ModelPatcher.apply_lora(text_encoder, _lora_loader(), lora_prefix),
+            # ModelPatcher.apply_lora(text_encoder, _lora_loader(), lora_prefix),
+            LoraModelPatcher.apply_lora_to_text_encoder(text_encoder, _lora_loader(), lora_prefix),
             # Apply CLIP Skip after LoRA to prevent LoRA application from failing on skipped layers.
             ModelPatcher.apply_clip_skip(text_encoder_model, clip_field.skipped_layers),
         ):
@@ -259,15 +262,15 @@ class SDXLCompelPromptInvocation(BaseInvocation, SDXLPromptInvocationBase):
     @torch.no_grad()
     def invoke(self, context: InvocationContext) -> ConditioningOutput:
         c1, c1_pooled, ec1 = self.run_clip_compel(
-            context, self.clip, self.prompt, False, "lora_te1_", zero_on_empty=True
+            context, self.clip, self.prompt, False, "text_encoder", zero_on_empty=True
         )
         if self.style.strip() == "":
             c2, c2_pooled, ec2 = self.run_clip_compel(
-                context, self.clip2, self.prompt, True, "lora_te2_", zero_on_empty=True
+                context, self.clip2, self.prompt, True, "text_encoder_2", zero_on_empty=True
             )
         else:
             c2, c2_pooled, ec2 = self.run_clip_compel(
-                context, self.clip2, self.style, True, "lora_te2_", zero_on_empty=True
+                context, self.clip2, self.style, True, "text_encoder_2", zero_on_empty=True
             )
 
         original_size = (self.original_height, self.original_width)

invokeai/app/invocations/latent.py

@@ -52,7 +52,8 @@ from invokeai.app.invocations.t2i_adapter import T2IAdapterField
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.util.controlnet_utils import prepare_control_image
 from invokeai.backend.ip_adapter.ip_adapter import IPAdapter, IPAdapterPlus
-from invokeai.backend.lora import LoRAModelRaw
+from invokeai.backend.lora_model_patcher import LoraModelPatcher
+from invokeai.backend.lora_model_raw import LoRAModelRaw
 from invokeai.backend.model_manager import BaseModelType, LoadedModel
 from invokeai.backend.model_patcher import ModelPatcher
 from invokeai.backend.stable_diffusion import PipelineIntermediateState, set_seamless
@@ -739,7 +740,8 @@ class DenoiseLatentsInvocation(BaseInvocation):
                 set_seamless(unet_info.model, self.unet.seamless_axes),  # FIXME
                 unet_info as unet,
                 # Apply the LoRA after unet has been moved to its target device for faster patching.
-                ModelPatcher.apply_lora_unet(unet, _lora_loader()),
+                # ModelPatcher.apply_lora_unet(unet, _lora_loader()),
+                LoraModelPatcher.apply_lora_to_unet(unet, _lora_loader()),
             ):
                 assert isinstance(unet, UNet2DConditionModel)
                 latents = latents.to(device=unet.device, dtype=unet.dtype)

invokeai/app/services/model_install/model_install_default.py

@@ -348,13 +348,8 @@ class ModelInstallService(ModelInstallServiceBase):
                     config: dict[str, Any] = {}
                     config["name"] = model_name
                     config["description"] = stanza.get("description")
-                    legacy_config_path = stanza.get("config")
-                    if legacy_config_path:
-                        # In v3, these paths were relative to the root. Migrate them to be relative to the legacy_conf_dir.
-                        legacy_config_path: Path = self._app_config.root_path / legacy_config_path
-                        if legacy_config_path.is_relative_to(self._app_config.legacy_conf_path):
-                            legacy_config_path = legacy_config_path.relative_to(self._app_config.legacy_conf_path)
-                        config["config_path"] = str(legacy_config_path)
+                    config["config_path"] = stanza.get("config")
+
                     try:
                         id = self.register_path(model_path=model_path, config=config)
                         self._logger.info(f"Migrated {model_name} with id {id}")
@@ -373,13 +368,11 @@ class ModelInstallService(ModelInstallServiceBase):
     def delete(self, key: str) -> None:  # noqa D102
         """Unregister the model. Delete its files only if they are within our models directory."""
         model = self.record_store.get_model(key)
-        model_path = self.app_config.models_path / model.path
-
-        if model_path.is_relative_to(self.app_config.models_path):
-            # If the models is in the Invoke-managed models dir, we delete it
+        models_dir = self.app_config.models_path
+        model_path = models_dir / Path(model.path)  # handle legacy relative model paths
+        if model_path.is_relative_to(models_dir):
             self.unconditionally_delete(key)
         else:
-            # Else we only unregister it, leaving the file in place
             self.unregister(key)
 
     def unconditionally_delete(self, key: str) -> None:  # noqa D102
@@ -507,9 +500,9 @@ class ModelInstallService(ModelInstallServiceBase):
     def _scan_for_missing_models(self) -> list[AnyModelConfig]:
         """Scan the models directory for missing models and return a list of them."""
         missing_models: list[AnyModelConfig] = []
-        for model_config in self.record_store.all_models():
-            if not (self.app_config.models_path / model_config.path).resolve().exists():
-                missing_models.append(model_config)
+        for x in self.record_store.all_models():
+            if not Path(x.path).resolve().exists():
+                missing_models.append(x)
         return missing_models
 
     def _register_orphaned_models(self) -> None:
@@ -519,9 +512,7 @@ class ModelInstallService(ModelInstallServiceBase):
         only situations in which we may have orphaned models in the models directory.
         """
 
-        installed_model_paths = {
-            (self._app_config.models_path / x.path).resolve() for x in self.record_store.all_models()
-        }
+        installed_model_paths = {Path(x.path).resolve() for x in self.record_store.all_models()}
 
         # The bool returned by this callback determines if the model is added to the list of models found by the search
         def on_model_found(model_path: Path) -> bool:
@@ -557,11 +548,10 @@ class ModelInstallService(ModelInstallServiceBase):
         May raise an UnknownModelException.
         """
         model = self.record_store.get_model(key)
-        models_dir = self.app_config.models_path
-        old_path = self.app_config.models_path / model.path
+        old_path = Path(model.path).resolve()
+        models_dir = self.app_config.models_path.resolve()
 
         if not old_path.is_relative_to(models_dir):
-            # The model is not in the models directory - we don't need to move it.
             return model
 
         new_path = (models_dir / model.base.value / model.type.value / model.name).with_suffix(old_path.suffix)
@@ -571,7 +561,7 @@ class ModelInstallService(ModelInstallServiceBase):
 
         self._logger.info(f"Moving {model.name} to {new_path}.")
         new_path = self._move_model(old_path, new_path)
-        model.path = new_path.relative_to(models_dir).as_posix()
+        model.path = new_path.as_posix()
         self.record_store.update_model(key, ModelRecordChanges(path=model.path))
         return model
 
@@ -610,19 +600,12 @@ class ModelInstallService(ModelInstallServiceBase):
 
         model_path = model_path.resolve()
 
-        # Models in the Invoke-managed models dir should use relative paths.
-        if model_path.is_relative_to(self.app_config.models_path):
-            model_path = model_path.relative_to(self.app_config.models_path)
-
         info.path = model_path.as_posix()
 
+        # Checkpoints have a config file needed for conversion - resolve this to an absolute path
         if isinstance(info, CheckpointConfigBase):
-            # Checkpoints have a config file needed for conversion. Same handling as the model weights - if it's in the
-            # invoke-managed legacy config dir, we use a relative path.
-            legacy_config_path = self.app_config.legacy_conf_path / info.config_path
-            if legacy_config_path.is_relative_to(self.app_config.legacy_conf_path):
-                legacy_config_path = legacy_config_path.relative_to(self.app_config.legacy_conf_path)
-            info.config_path = legacy_config_path.as_posix()
+            legacy_conf = (self.app_config.legacy_conf_path / info.config_path).resolve()
+            info.config_path = legacy_conf.as_posix()
         self.record_store.add_model(info)
         return info.key
 

invokeai/app/services/session_processor/session_processor_default.py

@@ -70,18 +70,8 @@ class DefaultSessionProcessor(SessionProcessorBase):
     async def _on_queue_event(self, event: FastAPIEvent) -> None:
         event_name = event[1]["event"]
 
-        if (
-            event_name == "session_canceled"
-            and self._queue_item
-            and self._queue_item.item_id == event[1]["data"]["queue_item_id"]
-        ):
-            self._cancel_event.set()
-            self._poll_now()
-        elif (
-            event_name == "queue_cleared"
-            and self._queue_item
-            and self._queue_item.queue_id == event[1]["data"]["queue_id"]
-        ):
+        if event_name == "session_canceled" or event_name == "queue_cleared":
+            # These both mean we should cancel the current session.
             self._cancel_event.set()
             self._poll_now()
         elif event_name == "batch_enqueued":
@@ -121,146 +111,141 @@ class DefaultSessionProcessor(SessionProcessorBase):
                 poll_now_event.clear()
                 # Middle processor try block; any unhandled exception is a non-fatal processor error
                 try:
-                    # If we are paused, wait for resume event
-                    resume_event.wait()
-
                     # Get the next session to process
                     self._queue_item = self._invoker.services.session_queue.dequeue()
+                    if self._queue_item is not None and resume_event.is_set():
+                        self._invoker.services.logger.debug(f"Executing queue item {self._queue_item.item_id}")
+                        cancel_event.clear()
 
-                    if self._queue_item is None:
-                        # The queue was empty, wait for next polling interval or event to try again
-                        self._invoker.services.logger.debug("Waiting for next polling interval or event")
-                        poll_now_event.wait(self._polling_interval)
-                        continue
+                        # If profiling is enabled, start the profiler
+                        if self._profiler is not None:
+                            self._profiler.start(profile_id=self._queue_item.session_id)
 
-                    self._invoker.services.logger.debug(f"Executing queue item {self._queue_item.item_id}")
-                    cancel_event.clear()
+                        # Prepare invocations and take the first
+                        self._invocation = self._queue_item.session.next()
 
-                    # If profiling is enabled, start the profiler
-                    if self._profiler is not None:
-                        self._profiler.start(profile_id=self._queue_item.session_id)
+                        # Loop over invocations until the session is complete or canceled
+                        while self._invocation is not None and not cancel_event.is_set():
+                            # get the source node id to provide to clients (the prepared node id is not as useful)
+                            source_invocation_id = self._queue_item.session.prepared_source_mapping[self._invocation.id]
 
-                    # Prepare invocations and take the first
-                    self._invocation = self._queue_item.session.next()
+                            # Send starting event
+                            self._invoker.services.events.emit_invocation_started(
+                                queue_batch_id=self._queue_item.batch_id,
+                                queue_item_id=self._queue_item.item_id,
+                                queue_id=self._queue_item.queue_id,
+                                graph_execution_state_id=self._queue_item.session_id,
+                                node=self._invocation.model_dump(),
+                                source_node_id=source_invocation_id,
+                            )
 
-                    # Loop over invocations until the session is complete or canceled
-                    while self._invocation is not None and not cancel_event.is_set():
-                        # get the source node id to provide to clients (the prepared node id is not as useful)
-                        source_invocation_id = self._queue_item.session.prepared_source_mapping[self._invocation.id]
+                            # Innermost processor try block; any unhandled exception is an invocation error & will fail the graph
+                            try:
+                                with self._invoker.services.performance_statistics.collect_stats(
+                                    self._invocation, self._queue_item.session.id
+                                ):
+                                    # Build invocation context (the node-facing API)
+                                    data = InvocationContextData(
+                                        invocation=self._invocation,
+                                        source_invocation_id=source_invocation_id,
+                                        queue_item=self._queue_item,
+                                    )
+                                    context = build_invocation_context(
+                                        data=data,
+                                        services=self._invoker.services,
+                                        cancel_event=self._cancel_event,
+                                    )
 
-                        # Send starting event
-                        self._invoker.services.events.emit_invocation_started(
-                            queue_batch_id=self._queue_item.batch_id,
-                            queue_item_id=self._queue_item.item_id,
-                            queue_id=self._queue_item.queue_id,
-                            graph_execution_state_id=self._queue_item.session_id,
-                            node=self._invocation.model_dump(),
-                            source_node_id=source_invocation_id,
-                        )
+                                    # Invoke the node
+                                    outputs = self._invocation.invoke_internal(
+                                        context=context, services=self._invoker.services
+                                    )
 
-                        # Innermost processor try block; any unhandled exception is an invocation error & will fail the graph
-                        try:
-                            with self._invoker.services.performance_statistics.collect_stats(
-                                self._invocation, self._queue_item.session.id
-                            ):
-                                # Build invocation context (the node-facing API)
-                                data = InvocationContextData(
-                                    invocation=self._invocation,
-                                    source_invocation_id=source_invocation_id,
-                                    queue_item=self._queue_item,
-                                )
-                                context = build_invocation_context(
-                                    data=data,
-                                    services=self._invoker.services,
-                                    cancel_event=self._cancel_event,
+                                    # Save outputs and history
+                                    self._queue_item.session.complete(self._invocation.id, outputs)
+
+                                    # Send complete event
+                                    self._invoker.services.events.emit_invocation_complete(
+                                        queue_batch_id=self._queue_item.batch_id,
+                                        queue_item_id=self._queue_item.item_id,
+                                        queue_id=self._queue_item.queue_id,
+                                        graph_execution_state_id=self._queue_item.session.id,
+                                        node=self._invocation.model_dump(),
+                                        source_node_id=source_invocation_id,
+                                        result=outputs.model_dump(),
+                                    )
+
+                            except KeyboardInterrupt:
+                                # TODO(MM2): Create an event for this
+                                pass
+
+                            except CanceledException:
+                                # When the user cancels the graph, we first set the cancel event. The event is checked
+                                # between invocations, in this loop. Some invocations are long-running, and we need to
+                                # be able to cancel them mid-execution.
+                                #
+                                # For example, denoising is a long-running invocation with many steps. A step callback
+                                # is executed after each step. This step callback checks if the canceled event is set,
+                                # then raises a CanceledException to stop execution immediately.
+                                #
+                                # When we get a CanceledException, we don't need to do anything - just pass and let the
+                                # loop go to its next iteration, and the cancel event will be handled correctly.
+                                pass
+
+                            except Exception as e:
+                                error = traceback.format_exc()
+
+                                # Save error
+                                self._queue_item.session.set_node_error(self._invocation.id, error)
+                                self._invoker.services.logger.error(
+                                    f"Error while invoking session {self._queue_item.session_id}, invocation {self._invocation.id} ({self._invocation.get_type()}):\n{e}"
                                 )
+                                self._invoker.services.logger.error(error)
 
-                                # Invoke the node
-                                outputs = self._invocation.invoke_internal(
-                                    context=context, services=self._invoker.services
-                                )
-
-                                # Save outputs and history
-                                self._queue_item.session.complete(self._invocation.id, outputs)
-
-                                # Send complete event
-                                self._invoker.services.events.emit_invocation_complete(
-                                    queue_batch_id=self._queue_item.batch_id,
+                                # Send error event
+                                self._invoker.services.events.emit_invocation_error(
+                                    queue_batch_id=self._queue_item.session_id,
                                     queue_item_id=self._queue_item.item_id,
                                     queue_id=self._queue_item.queue_id,
                                     graph_execution_state_id=self._queue_item.session.id,
                                     node=self._invocation.model_dump(),
                                     source_node_id=source_invocation_id,
-                                    result=outputs.model_dump(),
+                                    error_type=e.__class__.__name__,
+                                    error=error,
                                 )
+                                pass
 
-                        except KeyboardInterrupt:
-                            # TODO(MM2): Create an event for this
-                            pass
-
-                        except CanceledException:
-                            # When the user cancels the graph, we first set the cancel event. The event is checked
-                            # between invocations, in this loop. Some invocations are long-running, and we need to
-                            # be able to cancel them mid-execution.
-                            #
-                            # For example, denoising is a long-running invocation with many steps. A step callback
-                            # is executed after each step. This step callback checks if the canceled event is set,
-                            # then raises a CanceledException to stop execution immediately.
-                            #
-                            # When we get a CanceledException, we don't need to do anything - just pass and let the
-                            # loop go to its next iteration, and the cancel event will be handled correctly.
-                            pass
-
-                        except Exception as e:
-                            error = traceback.format_exc()
-
-                            # Save error
-                            self._queue_item.session.set_node_error(self._invocation.id, error)
-                            self._invoker.services.logger.error(
-                                f"Error while invoking session {self._queue_item.session_id}, invocation {self._invocation.id} ({self._invocation.get_type()}):\n{e}"
-                            )
-                            self._invoker.services.logger.error(error)
-
-                            # Send error event
-                            self._invoker.services.events.emit_invocation_error(
-                                queue_batch_id=self._queue_item.session_id,
-                                queue_item_id=self._queue_item.item_id,
-                                queue_id=self._queue_item.queue_id,
-                                graph_execution_state_id=self._queue_item.session.id,
-                                node=self._invocation.model_dump(),
-                                source_node_id=source_invocation_id,
-                                error_type=e.__class__.__name__,
-                                error=error,
-                            )
-                            pass
-
-                        # The session is complete if the all invocations are complete or there was an error
-                        if self._queue_item.session.is_complete() or cancel_event.is_set():
-                            # Send complete event
-                            self._invoker.services.events.emit_graph_execution_complete(
-                                queue_batch_id=self._queue_item.batch_id,
-                                queue_item_id=self._queue_item.item_id,
-                                queue_id=self._queue_item.queue_id,
-                                graph_execution_state_id=self._queue_item.session.id,
-                            )
-                            # If we are profiling, stop the profiler and dump the profile & stats
-                            if self._profiler:
-                                profile_path = self._profiler.stop()
-                                stats_path = profile_path.with_suffix(".json")
-                                self._invoker.services.performance_statistics.dump_stats(
-                                    graph_execution_state_id=self._queue_item.session.id, output_path=stats_path
+                            # The session is complete if the all invocations are complete or there was an error
+                            if self._queue_item.session.is_complete() or cancel_event.is_set():
+                                # Send complete event
+                                self._invoker.services.events.emit_graph_execution_complete(
+                                    queue_batch_id=self._queue_item.batch_id,
+                                    queue_item_id=self._queue_item.item_id,
+                                    queue_id=self._queue_item.queue_id,
+                                    graph_execution_state_id=self._queue_item.session.id,
                                 )
-                            # We'll get a GESStatsNotFoundError if we try to log stats for an untracked graph, but in the processor
-                            # we don't care about that - suppress the error.
-                            with suppress(GESStatsNotFoundError):
-                                self._invoker.services.performance_statistics.log_stats(self._queue_item.session.id)
-                                self._invoker.services.performance_statistics.reset_stats()
+                                # If we are profiling, stop the profiler and dump the profile & stats
+                                if self._profiler:
+                                    profile_path = self._profiler.stop()
+                                    stats_path = profile_path.with_suffix(".json")
+                                    self._invoker.services.performance_statistics.dump_stats(
+                                        graph_execution_state_id=self._queue_item.session.id, output_path=stats_path
+                                    )
+                                # We'll get a GESStatsNotFoundError if we try to log stats for an untracked graph, but in the processor
+                                # we don't care about that - suppress the error.
+                                with suppress(GESStatsNotFoundError):
+                                    self._invoker.services.performance_statistics.log_stats(self._queue_item.session.id)
+                                    self._invoker.services.performance_statistics.reset_stats()
 
-                            # Set the invocation to None to prepare for the next session
-                            self._invocation = None
-                        else:
-                            # Prepare the next invocation
-                            self._invocation = self._queue_item.session.next()
+                                # Set the invocation to None to prepare for the next session
+                                self._invocation = None
+                            else:
+                                # Prepare the next invocation
+                                self._invocation = self._queue_item.session.next()
+
+                        # The session is complete, immediately poll for next session
+                        self._queue_item = None
+                        poll_now_event.set()
                     else:
                         # The queue was empty, wait for next polling interval or event to try again
                         self._invoker.services.logger.debug("Waiting for next polling interval or event")

invokeai/app/services/shared/sqlite/sqlite_util.py

@@ -10,7 +10,6 @@ from invokeai.app.services.shared.sqlite_migrator.migrations.migration_4 import
 from invokeai.app.services.shared.sqlite_migrator.migrations.migration_5 import build_migration_5
 from invokeai.app.services.shared.sqlite_migrator.migrations.migration_6 import build_migration_6
 from invokeai.app.services.shared.sqlite_migrator.migrations.migration_7 import build_migration_7
-from invokeai.app.services.shared.sqlite_migrator.migrations.migration_8 import build_migration_8
 from invokeai.app.services.shared.sqlite_migrator.sqlite_migrator_impl import SqliteMigrator
 
 
@@ -38,7 +37,6 @@ def init_db(config: InvokeAIAppConfig, logger: Logger, image_files: ImageFileSto
     migrator.register_migration(build_migration_5())
     migrator.register_migration(build_migration_6())
     migrator.register_migration(build_migration_7())
-    migrator.register_migration(build_migration_8(app_config=config))
     migrator.run_migrations()
 
     return db

invokeai/app/services/shared/sqlite_migrator/migrations/migration_7.py

@@ -11,7 +11,7 @@ class Migration7Callback:
     def _drop_old_models_tables(self, cursor: sqlite3.Cursor) -> None:
         """Drops the old model_records, model_metadata, model_tags and tags tables."""
 
-        tables = ["model_config", "model_metadata", "model_tags", "tags"]
+        tables = ["model_records", "model_metadata", "model_tags", "tags"]
 
         for table in tables:
             cursor.execute(f"DROP TABLE IF EXISTS {table};")

invokeai/app/services/shared/sqlite_migrator/migrations/migration_8.py

@@ -1,91 +0,0 @@
-import sqlite3
-from pathlib import Path
-
-from invokeai.app.services.config.config_default import InvokeAIAppConfig
-from invokeai.app.services.shared.sqlite_migrator.sqlite_migrator_common import Migration
-
-
-class Migration8Callback:
-    def __init__(self, app_config: InvokeAIAppConfig) -> None:
-        self._app_config = app_config
-
-    def __call__(self, cursor: sqlite3.Cursor) -> None:
-        self._drop_model_config_table(cursor)
-        self._migrate_abs_models_to_rel(cursor)
-
-    def _drop_model_config_table(self, cursor: sqlite3.Cursor) -> None:
-        """Drops the old model_config table. This was missed in a previous migration."""
-
-        cursor.execute("DROP TABLE IF EXISTS model_config;")
-
-    def _migrate_abs_models_to_rel(self, cursor: sqlite3.Cursor) -> None:
-        """Check all model paths & legacy config paths to determine if they are inside Invoke-managed directories. If
-        they are, update the paths to be relative to the managed directories.
-
-        This migration is a no-op for normal users (their paths will already be relative), but is necessary for users
-        who have been testing the RCs with their live databases. The paths were made absolute in the initial RC, but this
-        change was reverted. To smooth over the revert for our tests, we can migrate the paths back to relative.
-        """
-
-        models_path = self._app_config.models_path
-        legacy_conf_path = self._app_config.legacy_conf_path
-        legacy_conf_dir = self._app_config.legacy_conf_dir
-
-        stmt = """---sql
-        SELECT
-            id,
-            path,
-            json_extract(config, '$.config_path') as config_path
-        FROM models;
-        """
-
-        all_models = cursor.execute(stmt).fetchall()
-
-        for model_id, model_path, model_config_path in all_models:
-            # If the model path is inside the models directory, update it to be relative to the models directory.
-            if Path(model_path).is_relative_to(models_path):
-                new_path = Path(model_path).relative_to(models_path)
-                cursor.execute(
-                    """--sql
-                    UPDATE models
-                    SET config = json_set(config, '$.path', ?)
-                    WHERE id = ?;
-                    """,
-                    (str(new_path), model_id),
-                )
-            # If the model has a legacy config path and it is inside the legacy conf directory, update it to be
-            # relative to the legacy conf directory. This also fixes up cases in which the config path was
-            # incorrectly relativized to the root directory. It will now be relativized to the legacy conf directory.
-            if model_config_path:
-                if Path(model_config_path).is_relative_to(legacy_conf_path):
-                    new_config_path = Path(model_config_path).relative_to(legacy_conf_path)
-                elif Path(model_config_path).is_relative_to(legacy_conf_dir):
-                    new_config_path = Path(*Path(model_config_path).parts[1:])
-                else:
-                    new_config_path = None
-                if new_config_path:
-                    cursor.execute(
-                        """--sql
-                        UPDATE models
-                        SET config = json_set(config, '$.config_path', ?)
-                        WHERE id = ?;
-                        """,
-                        (str(new_config_path), model_id),
-                    )
-
-
-def build_migration_8(app_config: InvokeAIAppConfig) -> Migration:
-    """
-    Build the migration from database version 7 to 8.
-
-    This migration does the following:
-    - Removes the `model_config` table.
-    - Migrates absolute model & legacy config paths to be relative to the models directory.
-    """
-    migration_8 = Migration(
-        from_version=7,
-        to_version=8,
-        callback=Migration8Callback(app_config),
-    )
-
-    return migration_8

invokeai/backend/ip_adapter/ip_adapter.py

@@ -9,7 +9,6 @@ from transformers import CLIPImageProcessor, CLIPVisionModelWithProjection
 
 from invokeai.backend.ip_adapter.ip_attention_weights import IPAttentionWeights
 
-from ..raw_model import RawModel
 from .resampler import Resampler
 
 
@@ -92,7 +91,7 @@ class MLPProjModel(torch.nn.Module):
         return clip_extra_context_tokens
 
 
-class IPAdapter(RawModel):
+class IPAdapter(torch.nn.Module):
     """IP-Adapter: https://arxiv.org/pdf/2308.06721.pdf"""
 
     def __init__(

invokeai/backend/lora_model_patcher.py

@@ -0,0 +1,65 @@
+from contextlib import contextmanager
+from typing import Iterator, Tuple, Union
+
+from diffusers.loaders.lora import LoraLoaderMixin
+from diffusers.models.unets.unet_2d_condition import UNet2DConditionModel
+from diffusers.utils.peft_utils import recurse_remove_peft_layers
+from transformers import CLIPTextModel
+
+from invokeai.backend.lora_model_raw import LoRAModelRaw
+
+
+class LoraModelPatcher:
+    @classmethod
+    def unload_lora_from_model(cls, m: Union[UNet2DConditionModel, CLIPTextModel]):
+        """Unload all LoRA models from a UNet or Text Encoder.
+        This implementation is base on LoraLoaderMixin.unload_lora_weights().
+        """
+        recurse_remove_peft_layers(m)
+        if hasattr(m, "peft_config"):
+            del m.peft_config  # type: ignore
+        if hasattr(m, "_hf_peft_config_loaded"):
+            m._hf_peft_config_loaded = None  # type: ignore
+
+    @classmethod
+    @contextmanager
+    def apply_lora_to_unet(cls, unet: UNet2DConditionModel, loras: Iterator[Tuple[LoRAModelRaw, float]]):
+        try:
+            # TODO(ryand): Test speed of low_cpu_mem_usage=True.
+            for lora, lora_weight in loras:
+                LoraLoaderMixin.load_lora_into_unet(
+                    state_dict=lora.state_dict,
+                    network_alphas=lora.network_alphas,
+                    unet=unet,
+                    low_cpu_mem_usage=True,
+                    adapter_name=lora.name,
+                    _pipeline=None,
+                )
+            yield
+        finally:
+            cls.unload_lora_from_model(unet)
+
+    @classmethod
+    @contextmanager
+    def apply_lora_to_text_encoder(
+        cls, text_encoder: CLIPTextModel, loras: Iterator[Tuple[LoRAModelRaw, float]], prefix: str
+    ):
+        assert prefix in ["text_encoder", "text_encoder_2"]
+        try:
+            for lora, lora_weight in loras:
+                # Filter the state_dict to only include the keys that start with the prefix.
+                text_encoder_state_dict = {
+                    key: value for key, value in lora.state_dict.items() if key.startswith(prefix + ".")
+                }
+                if len(text_encoder_state_dict) > 0:
+                    LoraLoaderMixin.load_lora_into_text_encoder(
+                        state_dict=text_encoder_state_dict,
+                        network_alphas=lora.network_alphas,
+                        text_encoder=text_encoder,
+                        low_cpu_mem_usage=True,
+                        adapter_name=lora.name,
+                        _pipeline=None,
+                    )
+            yield
+        finally:
+            cls.unload_lora_from_model(text_encoder)

invokeai/backend/lora_model_raw.py

@@ -0,0 +1,66 @@
+from pathlib import Path
+from typing import Optional, Union
+
+import torch
+from diffusers.loaders.lora import LoraLoaderMixin
+from typing_extensions import Self
+
+
+class LoRAModelRaw:
+    def __init__(
+        self,
+        name: str,
+        state_dict: dict[str, torch.Tensor],
+        network_alphas: Optional[dict[str, float]],
+    ):
+        self._name = name
+        self.state_dict = state_dict
+        self.network_alphas = network_alphas
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    def to(self, device: Optional[torch.device] = None, dtype: Optional[torch.dtype] = None) -> None:
+        for key, layer in self.state_dict.items():
+            self.state_dict[key] = layer.to(device=device, dtype=dtype)
+
+    def calc_size(self) -> int:
+        """Calculate the size of the model in bytes."""
+        model_size = 0
+        for layer in self.state_dict.values():
+            model_size += layer.numel() * layer.element_size()
+        return model_size
+
+    @classmethod
+    def from_checkpoint(
+        cls, file_path: Union[str, Path], device: Optional[torch.device] = None, dtype: Optional[torch.dtype] = None
+    ) -> Self:
+        """This function is based on diffusers LoraLoaderMixin.load_lora_weights()."""
+
+        file_path = Path(file_path)
+        if file_path.is_dir():
+            raise NotImplementedError("LoRA models from directories are not yet supported.")
+
+        dir_path = file_path.parent
+        file_name = file_path.name
+
+        state_dict, network_alphas = LoraLoaderMixin.lora_state_dict(
+            pretrained_model_name_or_path_or_dict=str(file_path), local_files_only=True, weight_name=str(file_name)
+        )
+
+        is_correct_format = all("lora" in key for key in state_dict.keys())
+        if not is_correct_format:
+            raise ValueError("Invalid LoRA checkpoint.")
+
+        model = cls(
+            # TODO(ryand): Handle both files and directories here?
+            name=Path(file_path).stem,
+            state_dict=state_dict,
+            network_alphas=network_alphas,
+        )
+
+        device = device or torch.device("cpu")
+        dtype = dtype or torch.float32
+        model.to(device=device, dtype=dtype)
+        return model

invokeai/backend/lora_old.py

@@ -11,8 +11,6 @@ from typing_extensions import Self
 
 from invokeai.backend.model_manager import BaseModelType
 
-from .raw_model import RawModel
-
 
 class LoRALayerBase:
     # rank: Optional[int]
@@ -368,7 +366,7 @@ class IA3Layer(LoRALayerBase):
 AnyLoRALayer = Union[LoRALayer, LoHALayer, LoKRLayer, FullLayer, IA3Layer]
 
 
-class LoRAModelRaw(RawModel):  # (torch.nn.Module):
+class LoRAModelRaw(torch.nn.Module):
     _name: str
     layers: Dict[str, AnyLoRALayer]
 

invokeai/backend/model_manager/__init__.py

@@ -33,3 +33,42 @@ __all__ = [
     "SchedulerPredictionType",
     "SubModelType",
 ]
+
+########## to help populate the openapi_schema with format enums for each config ###########
+# This code is no longer necessary?
+# leave it here just in case
+#
+# import inspect
+# from enum import Enum
+# from typing import Any, Iterable, Dict, get_args, Set
+# def _expand(something: Any) -> Iterable[type]:
+#     if isinstance(something, type):
+#         yield something
+#     else:
+#         for x in get_args(something):
+#             for y in _expand(x):
+#                 yield y
+
+# def _find_format(cls: type) -> Iterable[Enum]:
+#     if hasattr(inspect, "get_annotations"):
+#         fields = inspect.get_annotations(cls)
+#     else:
+#         fields = cls.__annotations__
+#     if "format" in fields:
+#         for x in get_args(fields["format"]):
+#             yield x
+#     for parent_class in cls.__bases__:
+#         for x in _find_format(parent_class):
+#             yield x
+#     return None
+
+# def get_model_config_formats() -> Dict[str, Set[Enum]]:
+#     result: Dict[str, Set[Enum]] = {}
+#     for model_config in _expand(AnyModelConfig):
+#         for field in _find_format(model_config):
+#             if field is None:
+#                 continue
+#             if not result.get(model_config.__qualname__):
+#                 result[model_config.__qualname__] = set()
+#             result[model_config.__qualname__].add(field)
+#     return result

invokeai/backend/model_manager/config.py

@@ -31,12 +31,13 @@ from typing_extensions import Annotated, Any, Dict
 
 from invokeai.app.invocations.constants import SCHEDULER_NAME_VALUES
 from invokeai.app.util.misc import uuid_string
-
-from ..raw_model import RawModel
+from invokeai.backend.ip_adapter.ip_adapter import IPAdapter
+from invokeai.backend.lora_model_raw import LoRAModelRaw
+from invokeai.backend.onnx.onnx_runtime import IAIOnnxRuntimeModel
+from invokeai.backend.textual_inversion import TextualInversionModelRaw
 
 # ModelMixin is the base class for all diffusers and transformers models
-# RawModel is the InvokeAI wrapper class for ip_adapters, loras, textual_inversion and onnx runtime
-AnyModel = Union[ModelMixin, RawModel, torch.nn.Module]
+AnyModel = Union[ModelMixin, torch.nn.Module, IPAdapter, LoRAModelRaw, TextualInversionModelRaw, IAIOnnxRuntimeModel]
 
 
 class InvalidModelConfigException(Exception):

invokeai/backend/model_manager/convert_ckpt_to_diffusers.py

@@ -3,10 +3,10 @@
 """Conversion script for the Stable Diffusion checkpoints."""
 
 from pathlib import Path
-from typing import Optional
+from typing import Dict
 
 import torch
-from diffusers.models.autoencoders.autoencoder_kl import AutoencoderKL
+from diffusers import AutoencoderKL
 from diffusers.pipelines.stable_diffusion.convert_from_ckpt import (
     convert_ldm_vae_checkpoint,
     create_vae_diffusers_config,
@@ -15,14 +15,11 @@ from diffusers.pipelines.stable_diffusion.convert_from_ckpt import (
 )
 from omegaconf import DictConfig
 
-from . import AnyModel
-
 
 def convert_ldm_vae_to_diffusers(
-    checkpoint: torch.Tensor | dict[str, torch.Tensor],
+    checkpoint: Dict[str, torch.Tensor],
     vae_config: DictConfig,
     image_size: int,
-    dump_path: Optional[Path] = None,
     precision: torch.dtype = torch.float16,
 ) -> AutoencoderKL:
     """Convert a checkpoint-style VAE into a Diffusers VAE"""
@@ -31,21 +28,16 @@ def convert_ldm_vae_to_diffusers(
 
     vae = AutoencoderKL(**vae_config)
     vae.load_state_dict(converted_vae_checkpoint)
-    vae.to(precision)
-
-    if dump_path:
-        vae.save_pretrained(dump_path, safe_serialization=True)
-
-    return vae
+    return vae.to(precision)
 
 
 def convert_ckpt_to_diffusers(
     checkpoint_path: str | Path,
-    dump_path: Optional[str | Path] = None,
+    dump_path: str | Path,
     precision: torch.dtype = torch.float16,
     use_safetensors: bool = True,
     **kwargs,
-) -> AnyModel:
+):
     """
     Takes all the arguments of download_from_original_stable_diffusion_ckpt(),
     and in addition a path-like object indicating the location of the desired diffusers
@@ -55,20 +47,18 @@ def convert_ckpt_to_diffusers(
     pipe = pipe.to(precision)
 
     # TO DO: save correct repo variant
-    if dump_path:
-        pipe.save_pretrained(
-            dump_path,
-            safe_serialization=use_safetensors,
-        )
-    return pipe
+    pipe.save_pretrained(
+        dump_path,
+        safe_serialization=use_safetensors,
+    )
 
 
 def convert_controlnet_to_diffusers(
     checkpoint_path: Path,
-    dump_path: Optional[Path] = None,
+    dump_path: Path,
     precision: torch.dtype = torch.float16,
     **kwargs,
-) -> AnyModel:
+):
     """
     Takes all the arguments of download_controlnet_from_original_ckpt(),
     and in addition a path-like object indicating the location of the desired diffusers
@@ -78,6 +68,4 @@ def convert_controlnet_to_diffusers(
     pipe = pipe.to(precision)
 
     # TO DO: save correct repo variant
-    if dump_path:
-        pipe.save_pretrained(dump_path, safe_serialization=True)
-    return pipe
+    pipe.save_pretrained(dump_path, safe_serialization=True)

invokeai/backend/model_manager/load/convert_cache/convert_cache_default.py

@@ -19,20 +19,11 @@ class ModelConvertCache(ModelConvertCacheBase):
         self._cache_path = cache_path
         self._max_size = max_size
 
-        # adjust cache size at startup in case it has been changed
-        if self._cache_path.exists():
-            self.make_room(0.0)
-
     @property
     def max_size(self) -> float:
         """Return the maximum size of this cache directory (GB)."""
         return self._max_size
 
-    @max_size.setter
-    def max_size(self, value: float) -> None:
-        """Set the maximum size of this cache directory (GB)."""
-        self._max_size = value
-
     def cache_path(self, key: str) -> Path:
         """Return the path for a model with the indicated key."""
         return self._cache_path / key

invokeai/backend/model_manager/load/load_base.py

@@ -83,15 +83,3 @@ class ModelLoaderBase(ABC):
     ) -> int:
         """Return size in bytes of the model, calculated before loading."""
         pass
-
-    @property
-    @abstractmethod
-    def convert_cache(self) -> ModelConvertCacheBase:
-        """Return the convert cache associated with this loader."""
-        pass
-
-    @property
-    @abstractmethod
-    def ram_cache(self) -> ModelCacheBase[AnyModel]:
-        """Return the ram cache associated with this loader."""
-        pass

invokeai/backend/model_manager/load/load_default.py

@@ -3,13 +3,14 @@
 
 from logging import Logger
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Tuple
 
 from invokeai.app.services.config import InvokeAIAppConfig
 from invokeai.backend.model_manager import (
     AnyModel,
     AnyModelConfig,
     InvalidModelConfigException,
+    ModelRepoVariant,
     SubModelType,
 )
 from invokeai.backend.model_manager.config import DiffusersConfigBase, ModelType
@@ -53,43 +54,51 @@ class ModelLoader(ModelLoaderBase):
         if model_config.type is ModelType.Main and not submodel_type:
             raise InvalidModelConfigException("submodel_type is required when loading a main model")
 
-        model_path = self._get_model_path(model_config)
+        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}")
 
-        with skip_torch_weight_init():
-            locker = self._convert_and_load(model_config, model_path, submodel_type)
+        model_path = self._convert_if_needed(model_config, model_path, submodel_type)
+        locker = self._load_if_needed(model_config, model_path, submodel_type)
         return LoadedModel(config=model_config, _locker=locker)
 
-    @property
-    def convert_cache(self) -> ModelConvertCacheBase:
-        """Return the convert cache associated with this loader."""
-        return self._convert_cache
-
-    @property
-    def ram_cache(self) -> ModelCacheBase[AnyModel]:
-        """Return the ram cache associated with this loader."""
-        return self._ram_cache
-
-    def _get_model_path(self, config: AnyModelConfig) -> Path:
+    def _get_model_path(
+        self, config: AnyModelConfig, submodel_type: Optional[SubModelType] = None
+    ) -> Tuple[Path, AnyModelConfig, Optional[SubModelType]]:
         model_base = self._app_config.models_path
-        return (model_base / config.path).resolve()
+        result = (model_base / config.path).resolve(), config, submodel_type
+        return result
 
-    def _convert_and_load(
+    def _convert_if_needed(
+        self, config: AnyModelConfig, model_path: Path, submodel_type: Optional[SubModelType] = None
+    ) -> Path:
+        cache_path: Path = self._convert_cache.cache_path(config.key)
+
+        if not self._needs_conversion(config, model_path, cache_path):
+            return cache_path if cache_path.exists() else model_path
+
+        self._convert_cache.make_room(self.get_size_fs(config, model_path, submodel_type))
+        return self._convert_model(config, model_path, cache_path)
+
+    def _needs_conversion(self, config: AnyModelConfig, model_path: Path, dest_path: Path) -> bool:
+        return False
+
+    def _load_if_needed(
         self, config: AnyModelConfig, model_path: Path, submodel_type: Optional[SubModelType] = None
     ) -> ModelLockerBase:
+        # TO DO: This is not thread safe!
         try:
             return self._ram_cache.get(config.key, submodel_type)
         except IndexError:
             pass
 
-        cache_path: Path = self._convert_cache.cache_path(config.key)
-        if self._needs_conversion(config, model_path, cache_path):
-            loaded_model = self._do_convert(config, model_path, cache_path, submodel_type)
-        else:
-            config.path = str(cache_path) if cache_path.exists() else str(self._get_model_path(config))
-            loaded_model = self._load_model(config, submodel_type)
+        model_variant = getattr(config, "repo_variant", None)
+        self._ram_cache.make_room(self.get_size_fs(config, model_path, submodel_type))
+
+        # This is where the model is actually loaded!
+        with skip_torch_weight_init():
+            loaded_model = self._load_model(model_path, model_variant=model_variant, submodel_type=submodel_type)
 
         self._ram_cache.put(
             config.key,
@@ -114,34 +123,15 @@ class ModelLoader(ModelLoaderBase):
             variant=config.repo_variant if isinstance(config, DiffusersConfigBase) else None,
         )
 
-    def _do_convert(
-        self, config: AnyModelConfig, model_path: Path, cache_path: Path, submodel_type: Optional[SubModelType] = None
-    ) -> AnyModel:
-        self.convert_cache.make_room(calc_model_size_by_fs(model_path))
-        pipeline = self._convert_model(config, model_path, cache_path if self.convert_cache.max_size > 0 else None)
-        if submodel_type:
-            # Proactively load the various submodels into the RAM cache so that we don't have to re-convert
-            # the entire pipeline every time a new submodel is needed.
-            for subtype in SubModelType:
-                if subtype == submodel_type:
-                    continue
-                if submodel := getattr(pipeline, subtype.value, None):
-                    self._ram_cache.put(
-                        config.key, submodel_type=subtype, model=submodel, size=calc_model_size_by_data(submodel)
-                    )
-        return getattr(pipeline, submodel_type.value) if submodel_type else pipeline
-
-    def _needs_conversion(self, config: AnyModelConfig, model_path: Path, dest_path: Path) -> bool:
-        return False
-
     # This needs to be implemented in subclasses that handle checkpoints
-    def _convert_model(self, config: AnyModelConfig, model_path: Path, output_path: Optional[Path] = None) -> AnyModel:
+    def _convert_model(self, config: AnyModelConfig, model_path: Path, output_path: Path) -> Path:
         raise NotImplementedError
 
     # This needs to be implemented in the subclass
     def _load_model(
         self,
-        config: AnyModelConfig,
+        model_path: Path,
+        model_variant: Optional[ModelRepoVariant] = None,
         submodel_type: Optional[SubModelType] = None,
     ) -> AnyModel:
         raise NotImplementedError

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

@@ -122,11 +122,6 @@ class ModelCache(ModelCacheBase[AnyModel]):
         """Return the cap on cache size."""
         return self._max_cache_size
 
-    @max_cache_size.setter
-    def max_cache_size(self, value: float) -> None:
-        """Set the cap on cache size."""
-        self._max_cache_size = value
-
     @property
     def stats(self) -> Optional[CacheStats]:
         """Return collected CacheStats object."""
@@ -162,9 +157,8 @@ class ModelCache(ModelCacheBase[AnyModel]):
     ) -> None:
         """Store model under key and optional submodel_type."""
         key = self._make_cache_key(key, submodel_type)
-        if key in self._cached_models:
-            return
-        self.make_room(size)
+        assert key not in self._cached_models
+
         cache_record = CacheRecord(key, model, size)
         self._cached_models[key] = cache_record
         self._cache_stack.append(key)
@@ -411,8 +405,6 @@ class ModelCache(ModelCacheBase[AnyModel]):
             #
             # Keep in mind that gc is only responsible for handling reference cycles. Most objects should be cleaned up
             # immediately when their reference count hits 0.
-            if self.stats:
-                self.stats.cleared = models_cleared
             gc.collect()
 
         torch.cuda.empty_cache()

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

@@ -2,10 +2,8 @@
 """Class for ControlNet model loading in InvokeAI."""
 
 from pathlib import Path
-from typing import Optional
 
 from invokeai.backend.model_manager import (
-    AnyModel,
     AnyModelConfig,
     BaseModelType,
     ModelFormat,
@@ -35,7 +33,7 @@ class ControlNetLoader(GenericDiffusersLoader):
         else:
             return True
 
-    def _convert_model(self, config: AnyModelConfig, model_path: Path, output_path: Optional[Path] = None) -> AnyModel:
+    def _convert_model(self, config: AnyModelConfig, model_path: Path, output_path: Path) -> Path:
         assert isinstance(config, CheckpointConfigBase)
         image_size = (
             512
@@ -46,8 +44,8 @@ class ControlNetLoader(GenericDiffusersLoader):
         )
 
         self._logger.info(f"Converting {model_path} to diffusers format")
-        with open(self._app_config.legacy_conf_path / config.config_path, "r") as config_stream:
-            result = convert_controlnet_to_diffusers(
+        with open(self._app_config.root_path / config.config_path, "r") as config_stream:
+            convert_controlnet_to_diffusers(
                 model_path,
                 output_path,
                 original_config_file=config_stream,
@@ -55,4 +53,4 @@ class ControlNetLoader(GenericDiffusersLoader):
                 precision=self._torch_dtype,
                 from_safetensors=model_path.suffix == ".safetensors",
             )
-        return result
+        return output_path

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

@@ -10,14 +10,13 @@ from diffusers.models.modeling_utils import ModelMixin
 
 from invokeai.backend.model_manager import (
     AnyModel,
-    AnyModelConfig,
     BaseModelType,
     InvalidModelConfigException,
     ModelFormat,
+    ModelRepoVariant,
     ModelType,
     SubModelType,
 )
-from invokeai.backend.model_manager.config import DiffusersConfigBase
 
 from .. import ModelLoader, ModelLoaderRegistry
 
@@ -29,15 +28,14 @@ class GenericDiffusersLoader(ModelLoader):
 
     def _load_model(
         self,
-        config: AnyModelConfig,
+        model_path: Path,
+        model_variant: Optional[ModelRepoVariant] = None,
         submodel_type: Optional[SubModelType] = None,
     ) -> AnyModel:
-        model_path = Path(config.path)
         model_class = self.get_hf_load_class(model_path)
         if submodel_type is not None:
             raise Exception(f"There are no submodels in models of type {model_class}")
-        repo_variant = config.repo_variant if isinstance(config, DiffusersConfigBase) else None
-        variant = repo_variant.value if repo_variant else None
+        variant = model_variant.value if model_variant else None
         try:
             result: AnyModel = model_class.from_pretrained(model_path, torch_dtype=self._torch_dtype, variant=variant)
         except OSError as e:

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

@@ -9,14 +9,13 @@ import torch
 from invokeai.backend.ip_adapter.ip_adapter import build_ip_adapter
 from invokeai.backend.model_manager import (
     AnyModel,
-    AnyModelConfig,
     BaseModelType,
     ModelFormat,
+    ModelRepoVariant,
     ModelType,
     SubModelType,
 )
 from invokeai.backend.model_manager.load import ModelLoader, ModelLoaderRegistry
-from invokeai.backend.raw_model import RawModel
 
 
 @ModelLoaderRegistry.register(base=BaseModelType.Any, type=ModelType.IPAdapter, format=ModelFormat.InvokeAI)
@@ -25,13 +24,13 @@ class IPAdapterInvokeAILoader(ModelLoader):
 
     def _load_model(
         self,
-        config: AnyModelConfig,
+        model_path: Path,
+        model_variant: Optional[ModelRepoVariant] = None,
         submodel_type: Optional[SubModelType] = None,
     ) -> AnyModel:
         if submodel_type is not None:
             raise ValueError("There are no submodels in an IP-Adapter model.")
-        model_path = Path(config.path)
-        model: RawModel = build_ip_adapter(
+        model = build_ip_adapter(
             ip_adapter_ckpt_path=str(model_path / "ip_adapter.bin"),
             device=torch.device("cpu"),
             dtype=self._torch_dtype,

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

@@ -3,15 +3,16 @@
 
 from logging import Logger
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Tuple
 
 from invokeai.app.services.config import InvokeAIAppConfig
-from invokeai.backend.lora import LoRAModelRaw
+from invokeai.backend.lora_model_raw import LoRAModelRaw
 from invokeai.backend.model_manager import (
     AnyModel,
     AnyModelConfig,
     BaseModelType,
     ModelFormat,
+    ModelRepoVariant,
     ModelType,
     SubModelType,
 )
@@ -40,24 +41,26 @@ class LoRALoader(ModelLoader):
 
     def _load_model(
         self,
-        config: AnyModelConfig,
+        model_path: Path,
+        model_variant: Optional[ModelRepoVariant] = None,
         submodel_type: Optional[SubModelType] = None,
     ) -> AnyModel:
         if submodel_type is not None:
             raise ValueError("There are no submodels in a LoRA model.")
-        model_path = Path(config.path)
         assert self._model_base is not None
         model = LoRAModelRaw.from_checkpoint(
             file_path=model_path,
             dtype=self._torch_dtype,
-            base_model=self._model_base,
         )
         return model
 
     # override
-    def _get_model_path(self, config: AnyModelConfig) -> Path:
-        # cheating a little - we remember this variable for using in the subsequent call to _load_model()
-        self._model_base = config.base
+    def _get_model_path(
+        self, config: AnyModelConfig, submodel_type: Optional[SubModelType] = None
+    ) -> Tuple[Path, AnyModelConfig, Optional[SubModelType]]:
+        self._model_base = (
+            config.base
+        )  # cheating a little - we remember this variable for using in the subsequent call to _load_model()
 
         model_base_path = self._app_config.models_path
         model_path = model_base_path / config.path
@@ -69,4 +72,5 @@ class LoRALoader(ModelLoader):
                     model_path = path
                     break
 
-        return model_path.resolve()
+        result = model_path.resolve(), config, submodel_type
+        return result

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

@@ -7,9 +7,9 @@ from typing import Optional
 
 from invokeai.backend.model_manager import (
     AnyModel,
-    AnyModelConfig,
     BaseModelType,
     ModelFormat,
+    ModelRepoVariant,
     ModelType,
     SubModelType,
 )
@@ -25,19 +25,18 @@ class OnnyxDiffusersModel(GenericDiffusersLoader):
 
     def _load_model(
         self,
-        config: AnyModelConfig,
+        model_path: Path,
+        model_variant: Optional[ModelRepoVariant] = None,
         submodel_type: Optional[SubModelType] = None,
     ) -> AnyModel:
         if not submodel_type is not None:
             raise Exception("A submodel type must be provided when loading onnx pipelines.")
-        model_path = Path(config.path)
         load_class = self.get_hf_load_class(model_path, submodel_type)
-        repo_variant = getattr(config, "repo_variant", None)
-        variant = repo_variant.value if repo_variant else None
+        variant = model_variant.value if model_variant else None
         model_path = model_path / submodel_type.value
         result: AnyModel = load_class.from_pretrained(
             model_path,
             torch_dtype=self._torch_dtype,
             variant=variant,
-        )
+        )  # type: ignore
         return result

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

@@ -9,16 +9,12 @@ from invokeai.backend.model_manager import (
     AnyModelConfig,
     BaseModelType,
     ModelFormat,
+    ModelRepoVariant,
     ModelType,
     SchedulerPredictionType,
     SubModelType,
 )
-from invokeai.backend.model_manager.config import (
-    CheckpointConfigBase,
-    DiffusersConfigBase,
-    MainCheckpointConfig,
-    ModelVariantType,
-)
+from invokeai.backend.model_manager.config import CheckpointConfigBase, MainCheckpointConfig, ModelVariantType
 from invokeai.backend.model_manager.convert_ckpt_to_diffusers import convert_ckpt_to_diffusers
 
 from .. import ModelLoaderRegistry
@@ -45,15 +41,14 @@ class StableDiffusionDiffusersModel(GenericDiffusersLoader):
 
     def _load_model(
         self,
-        config: AnyModelConfig,
+        model_path: Path,
+        model_variant: Optional[ModelRepoVariant] = None,
         submodel_type: Optional[SubModelType] = None,
     ) -> AnyModel:
         if not submodel_type is not None:
             raise Exception("A submodel type must be provided when loading main pipelines.")
-        model_path = Path(config.path)
         load_class = self.get_hf_load_class(model_path, submodel_type)
-        repo_variant = config.repo_variant if isinstance(config, DiffusersConfigBase) else None
-        variant = repo_variant.value if repo_variant else None
+        variant = model_variant.value if model_variant else None
         model_path = model_path / submodel_type.value
         try:
             result: AnyModel = load_class.from_pretrained(
@@ -83,7 +78,7 @@ class StableDiffusionDiffusersModel(GenericDiffusersLoader):
         else:
             return True
 
-    def _convert_model(self, config: AnyModelConfig, model_path: Path, output_path: Optional[Path] = None) -> AnyModel:
+    def _convert_model(self, config: AnyModelConfig, model_path: Path, output_path: Path) -> Path:
         assert isinstance(config, MainCheckpointConfig)
         base = config.base
 
@@ -99,11 +94,11 @@ class StableDiffusionDiffusersModel(GenericDiffusersLoader):
 
         self._logger.info(f"Converting {model_path} to diffusers format")
 
-        loaded_model = convert_ckpt_to_diffusers(
+        convert_ckpt_to_diffusers(
             model_path,
             output_path,
             model_type=self.model_base_to_model_type[base],
-            original_config_file=self._app_config.legacy_conf_path / config.config_path,
+            original_config_file=self._app_config.root_path / config.config_path,
             extract_ema=True,
             from_safetensors=model_path.suffix == ".safetensors",
             precision=self._torch_dtype,
@@ -113,4 +108,4 @@ class StableDiffusionDiffusersModel(GenericDiffusersLoader):
             load_safety_checker=False,
             num_in_channels=VARIANT_TO_IN_CHANNEL_MAP[config.variant],
         )
-        return loaded_model
+        return output_path

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

@@ -2,13 +2,14 @@
 """Class for TI model loading in InvokeAI."""
 
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Tuple
 
 from invokeai.backend.model_manager import (
     AnyModel,
     AnyModelConfig,
     BaseModelType,
     ModelFormat,
+    ModelRepoVariant,
     ModelType,
     SubModelType,
 )
@@ -26,19 +27,22 @@ class TextualInversionLoader(ModelLoader):
 
     def _load_model(
         self,
-        config: AnyModelConfig,
+        model_path: Path,
+        model_variant: Optional[ModelRepoVariant] = None,
         submodel_type: Optional[SubModelType] = None,
     ) -> AnyModel:
         if submodel_type is not None:
             raise ValueError("There are no submodels in a TI model.")
         model = TextualInversionModelRaw.from_checkpoint(
-            file_path=config.path,
+            file_path=model_path,
             dtype=self._torch_dtype,
         )
         return model
 
     # override
-    def _get_model_path(self, config: AnyModelConfig) -> Path:
+    def _get_model_path(
+        self, config: AnyModelConfig, submodel_type: Optional[SubModelType] = None
+    ) -> Tuple[Path, AnyModelConfig, Optional[SubModelType]]:
         model_path = self._app_config.models_path / config.path
 
         if config.format == ModelFormat.EmbeddingFolder:
@@ -49,4 +53,4 @@ class TextualInversionLoader(ModelLoader):
         if not path.exists():
             raise OSError(f"The embedding file at {path} was not found")
 
-        return path
+        return path, config, submodel_type

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

@@ -2,7 +2,6 @@
 """Class for VAE model loading in InvokeAI."""
 
 from pathlib import Path
-from typing import Optional
 
 import torch
 from omegaconf import DictConfig, OmegaConf
@@ -14,7 +13,7 @@ from invokeai.backend.model_manager import (
     ModelFormat,
     ModelType,
 )
-from invokeai.backend.model_manager.config import AnyModel, CheckpointConfigBase
+from invokeai.backend.model_manager.config import CheckpointConfigBase
 from invokeai.backend.model_manager.convert_ckpt_to_diffusers import convert_ldm_vae_to_diffusers
 
 from .. import ModelLoaderRegistry
@@ -39,13 +38,13 @@ class VAELoader(GenericDiffusersLoader):
         else:
             return True
 
-    def _convert_model(self, config: AnyModelConfig, model_path: Path, output_path: Optional[Path] = None) -> AnyModel:
+    def _convert_model(self, config: AnyModelConfig, model_path: Path, output_path: Path) -> Path:
         # TODO(MM2): check whether sdxl VAE models convert.
         if config.base not in {BaseModelType.StableDiffusion1, BaseModelType.StableDiffusion2}:
             raise Exception(f"VAE conversion not supported for model type: {config.base}")
         else:
             assert isinstance(config, CheckpointConfigBase)
-            config_file = self._app_config.legacy_conf_path / config.config_path
+            config_file = self._app_config.root_path / config.config_path
 
         if model_path.suffix == ".safetensors":
             checkpoint = safetensors_load_file(model_path, device="cpu")
@@ -64,6 +63,6 @@ class VAELoader(GenericDiffusersLoader):
             vae_config=ckpt_config,
             image_size=512,
             precision=self._torch_dtype,
-            dump_path=output_path,
         )
-        return vae_model
+        vae_model.save_pretrained(output_path, safe_serialization=True)
+        return output_path

invokeai/backend/model_manager/probe.py

@@ -323,7 +323,7 @@ class ModelProbe(object):
         with SilenceWarnings():
             if model_path.suffix.endswith((".ckpt", ".pt", ".pth", ".bin")):
                 cls._scan_model(model_path.name, model_path)
-                model = torch.load(model_path, map_location="cpu")
+                model = torch.load(model_path)
                 assert isinstance(model, dict)
                 return model
             else:

invokeai/backend/model_patcher.py

@@ -17,7 +17,7 @@ from invokeai.backend.model_manager import AnyModel
 from invokeai.backend.model_manager.load.optimizations import skip_torch_weight_init
 from invokeai.backend.onnx.onnx_runtime import IAIOnnxRuntimeModel
 
-from .lora import LoRAModelRaw
+from .lora_model_raw import LoRAModelRaw
 from .textual_inversion import TextualInversionManager, TextualInversionModelRaw
 
 """

invokeai/backend/onnx/onnx_runtime.py

@@ -6,17 +6,16 @@ from typing import Any, List, Optional, Tuple, Union
 
 import numpy as np
 import onnx
+import torch
 from onnx import numpy_helper
 from onnxruntime import InferenceSession, SessionOptions, get_available_providers
 
-from ..raw_model import RawModel
-
 ONNX_WEIGHTS_NAME = "model.onnx"
 
 
 # NOTE FROM LS: This was copied from Stalker's original implementation.
 # I have not yet gone through and fixed all the type hints
-class IAIOnnxRuntimeModel(RawModel):
+class IAIOnnxRuntimeModel(torch.nn.Module):
     class _tensor_access:
         def __init__(self, model):  # type: ignore
             self.model = model

invokeai/backend/raw_model.py

@@ -1,15 +0,0 @@
-"""Base class for 'Raw' models.
-
-The RawModel class is the base class of LoRAModelRaw and TextualInversionModelRaw,
-and is used for type checking of calls to the model patcher. Its main purpose
-is to avoid a circular import issues when lora.py tries to import BaseModelType
-from invokeai.backend.model_manager.config, and the latter tries to import LoRAModelRaw
-from lora.py.
-
-The term 'raw' was introduced to describe a wrapper around a torch.nn.Module
-that adds additional methods and attributes.
-"""
-
-
-class RawModel:
-    """Base class for 'Raw' model wrappers."""

invokeai/backend/stable_diffusion/seamless.py

@@ -28,10 +28,6 @@ def _conv_forward_asymmetric(self, input, weight, bias):
 
 @contextmanager
 def set_seamless(model: Union[UNet2DConditionModel, AutoencoderKL, AutoencoderTiny], seamless_axes: List[str]):
-    if not seamless_axes:
-        yield
-        return
-
     # Callable: (input: Tensor, weight: Tensor, bias: Optional[Tensor]) -> Tensor
     to_restore: list[tuple[nn.Conv2d | nn.ConvTranspose2d, Callable]] = []
     try:

invokeai/backend/textual_inversion.py

@@ -9,10 +9,8 @@ from safetensors.torch import load_file
 from transformers import CLIPTokenizer
 from typing_extensions import Self
 
-from .raw_model import RawModel
 
-
-class TextualInversionModelRaw(RawModel):
+class TextualInversionModelRaw(torch.nn.Module):
     embedding: torch.Tensor  # [n, 768]|[n, 1280]
     embedding_2: Optional[torch.Tensor] = None  # [n, 768]|[n, 1280]   - for SDXL models
 

invokeai/backend/util/db_maintenance.py

@@ -31,9 +31,6 @@ class ConfigMapper:
     YAML_FILENAME = "invokeai.yaml"
     DATABASE_FILENAME = "invokeai.db"
 
-    DEFAULT_OUTDIR = "outputs"
-    DEFAULT_DB_DIR = "databases"
-
     database_path = None
     database_backup_dir = None
     outputs_path = None
@@ -53,18 +50,12 @@ class ConfigMapper:
     def __load_from_root_config(self, invoke_root):
         """Validate a yaml path exists, confirm the user wants to use it and load config."""
         yaml_path = os.path.join(invoke_root, self.YAML_FILENAME)
-        if not os.path.exists(yaml_path):
-            print(f"Unable to find invokeai.yaml at {yaml_path}!")
-            return False
         if os.path.exists(yaml_path):
             db_dir, outdir = self.__load_paths_from_yaml_file(yaml_path)
 
-            if db_dir is None:
-                db_dir = self.DEFAULT_DB_DIR
-                print(f"The invokeai.yaml file was found but is missing the db_dir setting! Defaulting to {db_dir}")
-            if outdir is None:
-                outdir = self.DEFAULT_OUTDIR
-                print(f"The invokeai.yaml file was found but is missing the outdir setting! Defaulting to {outdir}")
+            if db_dir is None or outdir is None:
+                print("The invokeai.yaml file was found but is missing the db_dir and/or outdir setting!")
+                return False
 
             if os.path.isabs(db_dir):
                 self.database_path = os.path.join(db_dir, self.DATABASE_FILENAME)

pyproject.toml

@@ -44,6 +44,7 @@ dependencies = [
   "onnx==1.15.0",
   "onnxruntime==1.16.3",
   "opencv-python==4.9.0.80",
+  "peft==0.9.0",
   "pytorch-lightning==2.1.3",
   "safetensors==0.4.2",
   "timm==0.6.13",               # needed to override timm latest in controlnet_aux, see  https://github.com/isl-org/ZoeDepth/issues/26
@@ -73,7 +74,7 @@ dependencies = [
   "easing-functions",
   "einops",
   "facexlib",
-  "matplotlib",       # needed for plotting of Penner easing functions
+  "matplotlib",                            # needed for plotting of Penner easing functions
   "npyscreen",
   "omegaconf",
   "picklescan",

tests/app/services/model_install/test_model_install.py

@@ -43,7 +43,8 @@ def test_registration_meta(mm2_installer: ModelInstallServiceBase, embedding_fil
     assert model_record is not None
     assert model_record.name == "test_embedding"
     assert model_record.type == ModelType.TextualInversion
-    assert Path(model_record.path) == embedding_file
+    assert model_record.path.endswith(embedding_file.as_posix())
+    assert Path(model_record.path).is_absolute()
     assert Path(model_record.path).exists()
     assert model_record.base == BaseModelType("sd-1")
     assert model_record.description is not None
@@ -76,7 +77,8 @@ def test_install(
     key = mm2_installer.install_path(embedding_file)
     model_record = store.get_model(key)
     assert model_record.path.endswith("sd-1/embedding/test_embedding.safetensors")
-    assert (mm2_app_config.models_path / model_record.path).exists()
+    assert Path(model_record.path).is_absolute()
+    assert Path(model_record.path).exists()
     assert model_record.source == embedding_file.as_posix()
 
 
@@ -145,7 +147,10 @@ def test_background_install(
     model_record = mm2_installer.record_store.get_model(key)
     assert model_record is not None
     assert model_record.path.endswith(destination)
-    assert (mm2_app_config.models_path / model_record.path).exists()
+    assert Path(model_record.path).is_absolute()
+    assert Path(model_record.path).exists()
+    assert model_record.key != "<NOKEY>"
+    assert Path(model_record.path).exists()
 
     # see if metadata was properly passed through
     assert model_record.description == description
@@ -167,7 +172,7 @@ def test_not_inplace_install(
     assert job is not None
     assert job.config_out is not None
     assert Path(job.config_out.path) != embedding_file
-    assert (mm2_app_config.models_path / job.config_out.path).exists()
+    assert Path(job.config_out.path).exists()
 
 
 def test_inplace_install(
@@ -179,21 +184,16 @@ def test_inplace_install(
     assert job is not None
     assert job.config_out is not None
     assert Path(job.config_out.path) == embedding_file
-    assert Path(job.config_out.path).exists()
 
 
-def test_delete_install(
-    mm2_installer: ModelInstallServiceBase, embedding_file: Path, mm2_app_config: InvokeAIAppConfig
-) -> None:
+def test_delete_install(mm2_installer: ModelInstallServiceBase, embedding_file: Path) -> None:
     store = mm2_installer.record_store
     key = mm2_installer.install_path(embedding_file)
     model_record = store.get_model(key)
-    assert (mm2_app_config.models_path / model_record.path).exists()
+    assert Path(model_record.path).exists()
     assert embedding_file.exists()  # original should still be there after installation
     mm2_installer.delete(key)
-    assert not (
-        mm2_app_config.models_path / model_record.path
-    ).exists()  # after deletion, installed copy should not exist
+    assert not Path(model_record.path).exists()  # after deletion, installed copy should not exist
     assert embedding_file.exists()  # but original should still be there
     with pytest.raises(UnknownModelException):
         store.get_model(key)
@@ -232,7 +232,7 @@ def test_simple_download(mm2_installer: ModelInstallServiceBase, mm2_app_config:
 
     key = job.config_out.key
     model_record = store.get_model(key)
-    assert (mm2_app_config.models_path / model_record.path).exists()
+    assert Path(model_record.path).exists()
 
     assert len(bus.events) == 4
     event_names = [x.event_name for x in bus.events]
@@ -261,7 +261,7 @@ def test_huggingface_download(mm2_installer: ModelInstallServiceBase, mm2_app_co
 
     key = job.config_out.key
     model_record = store.get_model(key)
-    assert (mm2_app_config.models_path / model_record.path).exists()
+    assert Path(model_record.path).exists()
     assert model_record.type == ModelType.Main
     assert model_record.format == ModelFormat.Diffusers
 

tests/backend/model_manager/test_lora.py

@@ -5,7 +5,7 @@
 import pytest
 import torch
 
-from invokeai.backend.lora import LoRALayer, LoRAModelRaw
+from invokeai.backend.lora_model_raw import LoRALayer, LoRAModelRaw
 from invokeai.backend.model_patcher import ModelPatcher