Merge branch 'main' into diffusers-upgrade

invokeai/backend/install/invokeai_configure.py

@@ -40,6 +40,7 @@ import invokeai.configs as configs
 from invokeai.app.services.config import (
     InvokeAIAppConfig,
 )
+from invokeai.backend.util.logging import InvokeAILogger
 from invokeai.frontend.install.model_install import addModelsForm, process_and_execute
 from invokeai.frontend.install.widgets import (
     CenteredButtonPress,
@@ -80,6 +81,7 @@ INIT_FILE_PREAMBLE = """# InvokeAI initialization file
 # or renaming it and then running invokeai-configure again.
 """
 
+logger=None
 
 # --------------------------------------------
 def postscript(errors: None):
@@ -824,6 +826,7 @@ def main():
     if opt.full_precision:
         invoke_args.extend(['--precision','float32'])
     config.parse_args(invoke_args)
+    logger = InvokeAILogger().getLogger(config=config)
 
     errors = set()
 

invokeai/backend/model_management/model_manager.py

@@ -784,7 +784,7 @@ class ModelManager(object):
 
         self.logger.info(f"Probing {thing} for import")
 
-        if thing.startswith(("http:", "https:", "ftp:")):
+        if str(thing).startswith(("http:", "https:", "ftp:")):
             self.logger.info(f"{thing} appears to be a URL")
             model_path = self._resolve_path(
                 thing, "models/ldm/stable-diffusion-v1"

invokeai/backend/stable_diffusion/diffusers_pipeline.py

@@ -218,7 +218,7 @@ class GeneratorToCallbackinator(Generic[ParamType, ReturnType, CallbackType]):
 class ControlNetData:
     model: ControlNetModel = Field(default=None)
     image_tensor: torch.Tensor= Field(default=None)
-    weight: float = Field(default=1.0)
+    weight: Union[float, List[float]]= Field(default=1.0)
     begin_step_percent: float = Field(default=0.0)
     end_step_percent: float = Field(default=1.0)
 
@@ -226,7 +226,7 @@ class ControlNetData:
 class ConditioningData:
     unconditioned_embeddings: torch.Tensor
     text_embeddings: torch.Tensor
-    guidance_scale: float
+    guidance_scale: Union[float, List[float]]
     """
     Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
     `guidance_scale` is defined as `w` of equation 2. of [Imagen Paper](https://arxiv.org/pdf/2205.11487.pdf).
@@ -662,7 +662,9 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         down_block_res_samples, mid_block_res_sample = None, None
 
         if control_data is not None:
-            if conditioning_data.guidance_scale > 1.0:
+            # FIXME: make sure guidance_scale < 1.0 is handled correctly if doing per-step guidance setting
+            # if conditioning_data.guidance_scale > 1.0:
+            if conditioning_data.guidance_scale is not None:
                 # expand the latents input to control model if doing classifier free guidance
                 #    (which I think for now is always true, there is conditional elsewhere that stops execution if
                 #     classifier_free_guidance is <= 1.0 ?)
@@ -679,13 +681,19 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
                 # only apply controlnet if current step is within the controlnet's begin/end step range
                 if step_index >= first_control_step and step_index <= last_control_step:
                     # print("running controlnet", i, "for step", step_index)
+                    if isinstance(control_datum.weight, list):
+                        # if controlnet has multiple weights, use the weight for the current step
+                        controlnet_weight = control_datum.weight[step_index]
+                    else:
+                        # if controlnet has a single weight, use it for all steps
+                        controlnet_weight = control_datum.weight
                     down_samples, mid_sample = control_datum.model(
                         sample=latent_control_input,
                         timestep=timestep,
                         encoder_hidden_states=torch.cat([conditioning_data.unconditioned_embeddings,
                                                          conditioning_data.text_embeddings]),
                         controlnet_cond=control_datum.image_tensor,
-                        conditioning_scale=control_datum.weight,
+                        conditioning_scale=controlnet_weight,
                         # cross_attention_kwargs,
                         guess_mode=False,
                         return_dict=False,

invokeai/backend/stable_diffusion/diffusion/shared_invokeai_diffusion.py

@@ -1,7 +1,7 @@
 from contextlib import contextmanager
 from dataclasses import dataclass
 from math import ceil
-from typing import Any, Callable, Dict, Optional, Union
+from typing import Any, Callable, Dict, Optional, Union, List
 
 import numpy as np
 import torch
@@ -180,7 +180,8 @@ class InvokeAIDiffuserComponent:
         sigma: torch.Tensor,
         unconditioning: Union[torch.Tensor, dict],
         conditioning: Union[torch.Tensor, dict],
-        unconditional_guidance_scale: float,
+        # unconditional_guidance_scale: float,
+        unconditional_guidance_scale: Union[float, List[float]],
         step_index: Optional[int] = None,
         total_step_count: Optional[int] = None,
         **kwargs,
@@ -195,6 +196,11 @@ class InvokeAIDiffuserComponent:
         :return: the new latents after applying the model to x using unscaled unconditioning and CFG-scaled conditioning.
         """
 
+        if isinstance(unconditional_guidance_scale, list):
+            guidance_scale = unconditional_guidance_scale[step_index]
+        else:
+            guidance_scale = unconditional_guidance_scale
+
         cross_attention_control_types_to_do = []
         context: Context = self.cross_attention_control_context
         if self.cross_attention_control_context is not None:
@@ -243,7 +249,8 @@ class InvokeAIDiffuserComponent:
             )
 
         combined_next_x = self._combine(
-            unconditioned_next_x, conditioned_next_x, unconditional_guidance_scale
+            # unconditioned_next_x, conditioned_next_x, unconditional_guidance_scale
+            unconditioned_next_x, conditioned_next_x, guidance_scale
         )
 
         return combined_next_x
@@ -497,7 +504,7 @@ class InvokeAIDiffuserComponent:
             logger.debug(
                 f"min, mean, max = {minval:.3f}, {mean:.3f}, {maxval:.3f}\tstd={std}"
             )
-            logger.debug(   
+            logger.debug(
                 f"{outside / latents.numel() * 100:.2f}% values outside threshold"
             )
 

invokeai/backend/util/logging.py

@@ -1,6 +1,7 @@
 # Copyright (c) 2023 Lincoln D. Stein and The InvokeAI Development Team
 
-"""invokeai.util.logging
+"""
+invokeai.util.logging
 
 Logging class for InvokeAI that produces console messages
 
@@ -11,6 +12,7 @@ from invokeai.backend.util.logging import InvokeAILogger
 logger = InvokeAILogger.getLogger(name='InvokeAI') // Initialization
 (or)
 logger = InvokeAILogger.getLogger(__name__) // To use the filename
+logger.configure()
 
 logger.critical('this is critical') // Critical Message
 logger.error('this is an error') // Error Message
@@ -28,6 +30,149 @@ Console messages:
 Alternate Method (in this case the logger name will be set to InvokeAI):
 import invokeai.backend.util.logging as IAILogger
 IAILogger.debug('this is a debugging message')
+
+## Configuration
+
+The default configuration will print to stderr on the console. To add
+additional logging handlers, call getLogger with an initialized InvokeAIAppConfig
+object:
+
+
+ config = InvokeAIAppConfig.get_config()
+ config.parse_args()
+ logger = InvokeAILogger.getLogger(config=config)
+
+### Three command-line options control logging:
+
+`--log_handlers <handler1> <handler2> ...`
+
+This option activates one or more log handlers. Options are "console", "file", "syslog" and "http". To specify more than one, separate them by spaces:
+
+```
+invokeai-web --log_handlers console syslog=/dev/log file=C:\\Users\\fred\\invokeai.log
+```
+
+The format of these options is described below.
+
+### `--log_format {plain|color|legacy|syslog}`
+
+This controls the format of log messages written to the console. Only the "console" log handler is currently affected by this setting.
+
+* "plain" provides formatted messages like this:
+
+```bash
+
+[2023-05-24 23:18:2[2023-05-24 23:18:50,352]::[InvokeAI]::DEBUG --> this is a debug message
+[2023-05-24 23:18:50,352]::[InvokeAI]::INFO --> this is an informational messages
+[2023-05-24 23:18:50,352]::[InvokeAI]::WARNING --> this is a warning
+[2023-05-24 23:18:50,352]::[InvokeAI]::ERROR --> this is an error
+[2023-05-24 23:18:50,352]::[InvokeAI]::CRITICAL --> this is a critical error
+```
+
+* "color" produces similar output, but the text will be color coded to indicate the severity of the message.
+
+* "legacy" produces output similar to InvokeAI versions 2.3 and earlier:
+
+```
+### this is a critical error
+*** this is an error
+** this is a warning
+>> this is an informational messages
+   | this is a debug message
+```
+
+* "syslog" produces messages suitable for syslog entries:
+
+```bash
+InvokeAI [2691178] <CRITICAL> this is a critical error
+InvokeAI [2691178] <ERROR> this is an error
+InvokeAI [2691178] <WARNING> this is a warning
+InvokeAI [2691178] <INFO> this is an informational messages
+InvokeAI [2691178] <DEBUG> this is a debug message
+```
+
+(note that the date, time and hostname will be added by the syslog system)
+
+### `--log_level {debug|info|warning|error|critical}`
+
+Providing this command-line option will cause only messages at the specified level or above to be emitted.
+
+## Console logging
+
+When "console" is provided to `--log_handlers`, messages will be written to the command line window in which InvokeAI was launched. By default, the color formatter will be used unless overridden by `--log_format`.
+
+## File logging
+
+When "file" is provided to `--log_handlers`, entries will be written to the file indicated in the path argument. By default, the "plain" format will be used:
+
+```bash
+invokeai-web --log_handlers file=/var/log/invokeai.log
+```
+
+## Syslog logging
+
+When "syslog" is requested, entries will be sent to the syslog system. There are a variety of ways to control where the log message is sent:
+
+* Send to the local machine using the `/dev/log` socket:
+
+```
+invokeai-web --log_handlers syslog=/dev/log
+```
+
+* Send to the local machine using a UDP message:
+
+```
+invokeai-web --log_handlers syslog=localhost
+```
+
+* Send to the local machine using a UDP message on a nonstandard port:
+
+```
+invokeai-web --log_handlers syslog=localhost:512
+```
+
+* Send to a remote machine named "loghost" on the local LAN using  facility LOG_USER and UDP packets:
+
+```
+invokeai-web --log_handlers syslog=loghost,facility=LOG_USER,socktype=SOCK_DGRAM
+```
+
+This can be abbreviated `syslog=loghost`, as LOG_USER and SOCK_DGRAM are defaults.
+
+* Send to a remote machine named "loghost" using the facility LOCAL0  and using a TCP socket:
+
+```
+invokeai-web --log_handlers syslog=loghost,facility=LOG_LOCAL0,socktype=SOCK_STREAM
+```
+
+If no arguments are specified (just a bare "syslog"), then the logging system will look for a UNIX socket named `/dev/log`, and if not found try to send a UDP message to `localhost`. The Macintosh OS used to support logging to a socket named `/var/run/syslog`, but this feature has since been disabled.
+
+## Web logging
+
+If you have access to a web server that is configured to log messages when a particular URL is requested, you can log using the "http" method:
+
+```
+invokeai-web --log_handlers http=http://my.server/path/to/logger,method=POST
+```
+
+The optional [,method=] part can be used to specify whether the URL accepts GET (default) or POST messages.
+
+Currently password authentication and SSL are not supported.
+
+## Using the configuration file
+
+You can set and forget logging options by adding a "Logging" section to `invokeai.yaml`:
+
+```
+InvokeAI:
+  [... other settings...]
+  Logging:
+    log_handlers:
+       - console
+       - syslog=/dev/log
+    log_level: info
+    log_format: color
+```
 """
 
 import logging.handlers
@@ -180,14 +325,17 @@ class InvokeAILogger(object):
     loggers = dict()
 
     @classmethod
-    def getLogger(cls, name: str = 'InvokeAI') -> logging.Logger:
-        config = get_invokeai_config()
-        
-        if name not in cls.loggers:
+    def getLogger(cls,
+                  name: str = 'InvokeAI',
+                  config: InvokeAIAppConfig=InvokeAIAppConfig.get_config())->logging.Logger:
+        if name in cls.loggers:
+            logger = cls.loggers[name]
+            logger.handlers.clear()
+        else:
             logger = logging.getLogger(name)
-            logger.setLevel(config.log_level.upper()) # yes, strings work here
-            for ch in cls.getLoggers(config):
-                logger.addHandler(ch)
+        logger.setLevel(config.log_level.upper()) # yes, strings work here
+        for ch in cls.getLoggers(config):
+            logger.addHandler(ch)
             cls.loggers[name] = logger
         return cls.loggers[name]
 
@@ -199,9 +347,11 @@ class InvokeAILogger(object):
             handler_name,*args = handler.split('=',2)
             args = args[0] if len(args) > 0 else None
 
-            # console is the only handler that gets a custom formatter
+            # console and file get the fancy formatter.
+            # syslog gets a simple one
+            # http gets no custom formatter
+            formatter = LOG_FORMATTERS[config.log_format]
             if handler_name=='console':
-                formatter = LOG_FORMATTERS[config.log_format]
                 ch = logging.StreamHandler()
                 ch.setFormatter(formatter())
                 handlers.append(ch)
@@ -212,7 +362,9 @@ class InvokeAILogger(object):
                 handlers.append(ch)
                 
             elif handler_name=='file':
-                handlers.append(cls._parse_file_args(args))
+                ch = cls._parse_file_args(args)
+                ch.setFormatter(formatter())
+                handlers.append(ch)
                 
             elif handler_name=='http':
                 handlers.append(cls._parse_http_args(args))