Mirrored_Repos/InvokeAI
1
0
Fork 0
mirror of https://github.com/invoke-ai/InvokeAI synced 2024-08-30 20:32:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into lstein/new-model-manager

Browse Source
This commit is contained in:
Lincoln Stein 2023-05-03 18:09:29 -04:00 committed by GitHub
commit a273bdbdc1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
40 changed files with 652 additions and 536 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
invokeai/app/api/dependencies.py
View File

@ -1,14 +1,12 @@
# Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654) # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
import os import os
from argparse import Namespace
from invokeai.app.services.metadata import PngMetadataService, MetadataServiceBase import invokeai.backend.util.logging as logger
from typing import types
from ..services.default_graphs import create_system_graphs from ..services.default_graphs import create_system_graphs
from ..services.latent_storage import DiskLatentsStorage, ForwardCacheLatentsStorage from ..services.latent_storage import DiskLatentsStorage, ForwardCacheLatentsStorage
from ...backend import Globals from ...backend import Globals
from ..services.model_manager_initializer import get_model_manager from ..services.model_manager_initializer import get_model_manager
from ..services.restoration_services import RestorationServices from ..services.restoration_services import RestorationServices
@ -19,6 +17,7 @@ from ..services.invocation_services import InvocationServices
from ..services.invoker import Invoker from ..services.invoker import Invoker
from ..services.processor import DefaultInvocationProcessor from ..services.processor import DefaultInvocationProcessor
from ..services.sqlite import SqliteItemStorage from ..services.sqlite import SqliteItemStorage
from ..services.metadata import PngMetadataService
from .events import FastAPIEventService from .events import FastAPIEventService
@ -44,15 +43,16 @@ class ApiDependencies:
invoker: Invoker = None invoker: Invoker = None
@staticmethod @staticmethod
def initialize(config, event_handler_id: int): def initialize(config, event_handler_id: int, logger: types.ModuleType=logger):
Globals.try_patchmatch = config.patchmatch Globals.try_patchmatch = config.patchmatch
Globals.always_use_cpu = config.always_use_cpu Globals.always_use_cpu = config.always_use_cpu
Globals.internet_available = config.internet_available and check_internet() Globals.internet_available = config.internet_available and check_internet()
Globals.disable_xformers = not config.xformers Globals.disable_xformers = not config.xformers
Globals.ckpt_convert = config.ckpt_convert Globals.ckpt_convert = config.ckpt_convert
# TODO: Use a logger # TO DO: Use the config to select the logger rather than use the default
print(f">> Internet connectivity is {Globals.internet_available}") # invokeai logging module
logger.info(f"Internet connectivity is {Globals.internet_available}")
events = FastAPIEventService(event_handler_id) events = FastAPIEventService(event_handler_id)
@ -70,8 +70,9 @@ class ApiDependencies:
db_location = os.path.join(output_folder, "invokeai.db") db_location = os.path.join(output_folder, "invokeai.db")
services = InvocationServices( services = InvocationServices(
model_manager=get_model_manager(config), model_manager=get_model_manager(config,logger),
events=events, events=events,
logger=logger,
latents=latents, latents=latents,
images=images, images=images,
metadata=metadata, metadata=metadata,
@ -83,7 +84,7 @@ class ApiDependencies:
filename=db_location, table_name="graph_executions" filename=db_location, table_name="graph_executions"
), ),
processor=DefaultInvocationProcessor(), processor=DefaultInvocationProcessor(),
restoration=RestorationServices(config), restoration=RestorationServices(config,logger),
) )
create_system_graphs(services.graph_library) create_system_graphs(services.graph_library)

13
invokeai/app/api/routers/models.py
View File

@ -8,10 +8,6 @@ from fastapi.routing import APIRouter, HTTPException
from pydantic import BaseModel, Field, parse_obj_as from pydantic import BaseModel, Field, parse_obj_as
from pathlib import Path from pathlib import Path
from ..dependencies import ApiDependencies from ..dependencies import ApiDependencies
from invokeai.backend.globals import Globals, global_converted_ckpts_dir
from invokeai.backend.args import Args
models_router = APIRouter(prefix="/v1/models", tags=["models"]) models_router = APIRouter(prefix="/v1/models", tags=["models"])
@ -112,19 +108,20 @@ async def update_model(
async def delete_model(model_name: str) -> None: async def delete_model(model_name: str) -> None:
"""Delete Model""" """Delete Model"""
model_names = ApiDependencies.invoker.services.model_manager.model_names() model_names = ApiDependencies.invoker.services.model_manager.model_names()
logger = ApiDependencies.invoker.services.logger
model_exists = model_name in model_names model_exists = model_name in model_names
# check if model exists # check if model exists
print(f">> Checking for model {model_name}...") logger.info(f"Checking for model {model_name}...")
if model_exists: if model_exists:
print(f">> Deleting Model: {model_name}") logger.info(f"Deleting Model: {model_name}")
ApiDependencies.invoker.services.model_manager.del_model(model_name, delete_files=True) ApiDependencies.invoker.services.model_manager.del_model(model_name, delete_files=True)
print(f">> Model Deleted: {model_name}") logger.info(f"Model Deleted: {model_name}")
raise HTTPException(status_code=204, detail=f"Model '{model_name}' deleted successfully") raise HTTPException(status_code=204, detail=f"Model '{model_name}' deleted successfully")
else: else:
print(f">> Model not found") logger.error(f"Model not found")
raise HTTPException(status_code=404, detail=f"Model '{model_name}' not found") raise HTTPException(status_code=404, detail=f"Model '{model_name}' not found")

4
invokeai/app/api_app.py
View File

@ -3,6 +3,7 @@ import asyncio
from inspect import signature from inspect import signature
import uvicorn import uvicorn
import invokeai.backend.util.logging as logger
from fastapi import FastAPI from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware from fastapi.middleware.cors import CORSMiddleware
from fastapi.openapi.docs import get_redoc_html, get_swagger_ui_html from fastapi.openapi.docs import get_redoc_html, get_swagger_ui_html
@ -16,7 +17,6 @@ from ..backend import Args
from .api.dependencies import ApiDependencies from .api.dependencies import ApiDependencies
from .api.routers import images, sessions, models from .api.routers import images, sessions, models
from .api.sockets import SocketIO from .api.sockets import SocketIO
from .invocations import *
from .invocations.baseinvocation import BaseInvocation from .invocations.baseinvocation import BaseInvocation
# Create the app # Create the app
@ -56,7 +56,7 @@ async def startup_event():
config.parse_args() config.parse_args()
ApiDependencies.initialize( ApiDependencies.initialize(
config=config, event_handler_id=event_handler_id config=config, event_handler_id=event_handler_id, logger=logger
) )

7
invokeai/app/cli/commands.py
View File

@ -2,14 +2,15 @@
from abc import ABC, abstractmethod from abc import ABC, abstractmethod
import argparse import argparse
from typing import Any, Callable, Iterable, Literal, get_args, get_origin, get_type_hints from typing import Any, Callable, Iterable, Literal, Union, get_args, get_origin, get_type_hints
from pydantic import BaseModel, Field from pydantic import BaseModel, Field
import networkx as nx import networkx as nx
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
import invokeai.backend.util.logging as logger
from ..invocations.baseinvocation import BaseInvocation from ..invocations.baseinvocation import BaseInvocation
from ..invocations.image import ImageField from ..invocations.image import ImageField
from ..services.graph import GraphExecutionState, LibraryGraph, GraphInvocation, Edge from ..services.graph import GraphExecutionState, LibraryGraph, Edge
from ..services.invoker import Invoker from ..services.invoker import Invoker
@ -229,7 +230,7 @@ class HistoryCommand(BaseCommand):
for i in range(min(self.count, len(history))): for i in range(min(self.count, len(history))):
entry_id = history[-1 - i] entry_id = history[-1 - i]
entry = context.get_session().graph.get_node(entry_id) entry = context.get_session().graph.get_node(entry_id)
print(f"{entry_id}: {get_invocation_command(entry)}") logger.info(f"{entry_id}: {get_invocation_command(entry)}")
class SetDefaultCommand(BaseCommand): class SetDefaultCommand(BaseCommand):

5
invokeai/app/cli/completer.py
View File

@ -10,6 +10,7 @@ import shlex
from pathlib import Path from pathlib import Path
from typing import List, Dict, Literal, get_args, get_type_hints, get_origin from typing import List, Dict, Literal, get_args, get_type_hints, get_origin
import invokeai.backend.util.logging as logger
from ...backend import ModelManager, Globals from ...backend import ModelManager, Globals
from ..invocations.baseinvocation import BaseInvocation from ..invocations.baseinvocation import BaseInvocation
from .commands import BaseCommand from .commands import BaseCommand
@ -160,8 +161,8 @@ def set_autocompleter(model_manager: ModelManager) -> Completer:
pass pass
except OSError: # file likely corrupted except OSError: # file likely corrupted
newname = f"{histfile}.old" newname = f"{histfile}.old"
print( logger.error(
f"## Your history file {histfile} couldn't be loaded and may be corrupted. Renaming it to {newname}" f"Your history file {histfile} couldn't be loaded and may be corrupted. Renaming it to {newname}"
) )
histfile.replace(Path(newname)) histfile.replace(Path(newname))
atexit.register(readline.write_history_file, histfile) atexit.register(readline.write_history_file, histfile)

22
invokeai/app/cli_app.py
View File

@ -13,21 +13,20 @@ from typing import (
from pydantic import BaseModel from pydantic import BaseModel
from pydantic.fields import Field from pydantic.fields import Field
import invokeai.backend.util.logging as logger
from invokeai.app.services.metadata import PngMetadataService from invokeai.app.services.metadata import PngMetadataService
from .services.default_graphs import create_system_graphs from .services.default_graphs import create_system_graphs
from .services.latent_storage import DiskLatentsStorage, ForwardCacheLatentsStorage from .services.latent_storage import DiskLatentsStorage, ForwardCacheLatentsStorage
from ..backend import Args from ..backend import Args
from .cli.commands import BaseCommand, CliContext, ExitCli, add_graph_parsers, add_parsers, get_graph_execution_history from .cli.commands import BaseCommand, CliContext, ExitCli, add_graph_parsers, add_parsers
from .cli.completer import set_autocompleter from .cli.completer import set_autocompleter
from .invocations import *
from .invocations.baseinvocation import BaseInvocation from .invocations.baseinvocation import BaseInvocation
from .services.events import EventServiceBase from .services.events import EventServiceBase
from .services.model_manager_initializer import get_model_manager from .services.model_manager_initializer import get_model_manager
from .services.restoration_services import RestorationServices from .services.restoration_services import RestorationServices
from .services.graph import Edge, EdgeConnection, ExposedNodeInput, GraphExecutionState, GraphInvocation, LibraryGraph, are_connection_types_compatible from .services.graph import Edge, EdgeConnection, GraphExecutionState, GraphInvocation, LibraryGraph, are_connection_types_compatible
from .services.default_graphs import default_text_to_image_graph_id from .services.default_graphs import default_text_to_image_graph_id
from .services.image_storage import DiskImageStorage from .services.image_storage import DiskImageStorage
from .services.invocation_queue import MemoryInvocationQueue from .services.invocation_queue import MemoryInvocationQueue
@ -182,7 +181,7 @@ def invoke_all(context: CliContext):
# Print any errors # Print any errors
if context.session.has_error(): if context.session.has_error():
for n in context.session.errors: for n in context.session.errors:
print( context.invoker.services.logger.error(
f"Error in node {n} (source node {context.session.prepared_source_mapping[n]}): {context.session.errors[n]}" f"Error in node {n} (source node {context.session.prepared_source_mapping[n]}): {context.session.errors[n]}"
) )
@ -192,13 +191,13 @@ def invoke_all(context: CliContext):
def invoke_cli(): def invoke_cli():
config = Args() config = Args()
config.parse_args() config.parse_args()
model_manager = get_model_manager(config) model_manager = get_model_manager(config,logger=logger)
# This initializes the autocompleter and returns it. # This initializes the autocompleter and returns it.
# Currently nothing is done with the returned Completer # Currently nothing is done with the returned Completer
# object, but the object can be used to change autocompletion # object, but the object can be used to change autocompletion
# behavior on the fly, if desired. # behavior on the fly, if desired.
completer = set_autocompleter(model_manager) set_autocompleter(model_manager)
events = EventServiceBase() events = EventServiceBase()
@ -225,7 +224,8 @@ def invoke_cli():
filename=db_location, table_name="graph_executions" filename=db_location, table_name="graph_executions"
), ),
processor=DefaultInvocationProcessor(), processor=DefaultInvocationProcessor(),
restoration=RestorationServices(config), restoration=RestorationServices(config,logger=logger),
logger=logger,
) )
system_graphs = create_system_graphs(services.graph_library) system_graphs = create_system_graphs(services.graph_library)
@ -365,12 +365,12 @@ def invoke_cli():
invoke_all(context) invoke_all(context)
except InvalidArgs: except InvalidArgs:
print('Invalid command, use "help" to list commands') invoker.services.logger.warning('Invalid command, use "help" to list commands')
continue continue
except SessionError: except SessionError:
# Start a new session # Start a new session
print("Session error: creating a new session") invoker.services.logger.warning("Session error: creating a new session")
context.reset() context.reset()
except ExitCli: except ExitCli:

5
invokeai/app/invocations/util/choose_model.py
View File

@ -3,12 +3,11 @@ from invokeai.backend.model_management.model_manager import ModelManager
def choose_model(model_manager: ModelManager, model_name: str): def choose_model(model_manager: ModelManager, model_name: str):
"""Returns the default model if the `model_name` not a valid model, else returns the selected model.""" """Returns the default model if the `model_name` not a valid model, else returns the selected model."""
logger = model_manager.logger
if model_manager.valid_model(model_name): if model_manager.valid_model(model_name):
model = model_manager.get_model(model_name) model = model_manager.get_model(model_name)
else: else:
model = model_manager.get_model() model = model_manager.get_model()
print( logger.warning(f"{model_name}' is not a valid model name. Using default model \'{model['model_name']}\' instead.")
f"* Warning: '{model_name}' is not a valid model name. Using default model \'{model['model_name']}\' instead."
)
return model return model

6
invokeai/app/services/invocation_services.py
View File

@ -1,4 +1,6 @@
# Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654) # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654) and the InvokeAI Team
from typing import types
from invokeai.app.services.metadata import MetadataServiceBase from invokeai.app.services.metadata import MetadataServiceBase
from invokeai.backend import ModelManager from invokeai.backend import ModelManager
@ -29,6 +31,7 @@ class InvocationServices:
self, self,
model_manager: ModelManager, model_manager: ModelManager,
events: EventServiceBase, events: EventServiceBase,
logger: types.ModuleType,
latents: LatentsStorageBase, latents: LatentsStorageBase,
images: ImageStorageBase, images: ImageStorageBase,
metadata: MetadataServiceBase, metadata: MetadataServiceBase,
@ -40,6 +43,7 @@ class InvocationServices:
): ):
self.model_manager = model_manager self.model_manager = model_manager
self.events = events self.events = events
self.logger = logger
self.latents = latents self.latents = latents
self.images = images self.images = images
self.metadata = metadata self.metadata = metadata

31
invokeai/app/services/model_manager_initializer.py
View File

@ -5,6 +5,7 @@ from argparse import Namespace
from invokeai.backend import Args from invokeai.backend import Args
from omegaconf import OmegaConf from omegaconf import OmegaConf
from pathlib import Path from pathlib import Path
from typing import types
import invokeai.version import invokeai.version
from ...backend import ModelManager from ...backend import ModelManager
@ -12,16 +13,16 @@ from ...backend.util import choose_precision, choose_torch_device
from ...backend import Globals from ...backend import Globals
# TODO: Replace with an abstract class base ModelManagerBase # TODO: Replace with an abstract class base ModelManagerBase
def get_model_manager(config: Args) -> ModelManager: def get_model_manager(config: Args, logger: types.ModuleType) -> ModelManager:
if not config.conf: if not config.conf:
config_file = os.path.join(Globals.root, "configs", "models.yaml") config_file = os.path.join(Globals.root, "configs", "models.yaml")
if not os.path.exists(config_file): if not os.path.exists(config_file):
report_model_error( report_model_error(
config, FileNotFoundError(f"The file {config_file} could not be found.") config, FileNotFoundError(f"The file {config_file} could not be found."), logger
) )
print(f">> {invokeai.version.__app_name__}, version {invokeai.version.__version__}") logger.info(f"{invokeai.version.__app_name__}, version {invokeai.version.__version__}")
print(f'>> InvokeAI runtime directory is "{Globals.root}"') logger.info(f'InvokeAI runtime directory is "{Globals.root}"')
# these two lines prevent a horrible warning message from appearing # these two lines prevent a horrible warning message from appearing
# when the frozen CLIP tokenizer is imported # when the frozen CLIP tokenizer is imported
@ -62,11 +63,12 @@ def get_model_manager(config: Args) -> ModelManager:
device_type=device, device_type=device,
max_loaded_models=config.max_loaded_models, max_loaded_models=config.max_loaded_models,
embedding_path = Path(embedding_path), embedding_path = Path(embedding_path),
logger = logger,
) )
except (FileNotFoundError, TypeError, AssertionError) as e: except (FileNotFoundError, TypeError, AssertionError) as e:
report_model_error(config, e) report_model_error(config, e, logger)
except (IOError, KeyError) as e: except (IOError, KeyError) as e:
print(f"{e}. Aborting.") logger.error(f"{e}. Aborting.")
sys.exit(-1) sys.exit(-1)
# try to autoconvert new models # try to autoconvert new models
@ -76,18 +78,18 @@ def get_model_manager(config: Args) -> ModelManager:
conf_path=config.conf, conf_path=config.conf,
weights_directory=path, weights_directory=path,
) )
logger.info('Model manager initialized')
return model_manager return model_manager
def report_model_error(opt: Namespace, e: Exception): def report_model_error(opt: Namespace, e: Exception, logger: types.ModuleType):
print(f'** An error occurred while attempting to initialize the model: "{str(e)}"') logger.error(f'An error occurred while attempting to initialize the model: "{str(e)}"')
print( logger.error(
"** This can be caused by a missing or corrupted models file, and can sometimes be fixed by (re)installing the models." "This can be caused by a missing or corrupted models file, and can sometimes be fixed by (re)installing the models."
) )
yes_to_all = os.environ.get("INVOKE_MODEL_RECONFIGURE") yes_to_all = os.environ.get("INVOKE_MODEL_RECONFIGURE")
if yes_to_all: if yes_to_all:
print( logger.warning(
"** Reconfiguration is being forced by environment variable INVOKE_MODEL_RECONFIGURE" "Reconfiguration is being forced by environment variable INVOKE_MODEL_RECONFIGURE"
) )
else: else:
response = input( response = input(
@ -96,13 +98,12 @@ def report_model_error(opt: Namespace, e: Exception):
if response.startswith(("n", "N")): if response.startswith(("n", "N")):
return return
print("invokeai-configure is launching....\n") logger.info("invokeai-configure is launching....\n")
# Match arguments that were set on the CLI # Match arguments that were set on the CLI
# only the arguments accepted by the configuration script are parsed # only the arguments accepted by the configuration script are parsed
root_dir = ["--root", opt.root_dir] if opt.root_dir is not None else [] root_dir = ["--root", opt.root_dir] if opt.root_dir is not None else []
config = ["--config", opt.conf] if opt.conf is not None else [] config = ["--config", opt.conf] if opt.conf is not None else []
previous_config = sys.argv
sys.argv = ["invokeai-configure"] sys.argv = ["invokeai-configure"]
sys.argv.extend(root_dir) sys.argv.extend(root_dir)
sys.argv.extend(config.to_dict()) sys.argv.extend(config.to_dict())

29
invokeai/app/services/restoration_services.py
View File

@ -1,6 +1,7 @@
import sys import sys
import traceback import traceback
import torch import torch
from typing import types
from ...backend.restoration import Restoration from ...backend.restoration import Restoration
from ...backend.util import choose_torch_device, CPU_DEVICE, MPS_DEVICE from ...backend.util import choose_torch_device, CPU_DEVICE, MPS_DEVICE
@ -10,7 +11,7 @@ from ...backend.util import choose_torch_device, CPU_DEVICE, MPS_DEVICE
class RestorationServices: class RestorationServices:
'''Face restoration and upscaling''' '''Face restoration and upscaling'''
def __init__(self,args): def __init__(self,args,logger:types.ModuleType):
try: try:
gfpgan, codeformer, esrgan = None, None, None gfpgan, codeformer, esrgan = None, None, None
if args.restore or args.esrgan: if args.restore or args.esrgan:
@ -20,20 +21,22 @@ class RestorationServices:
args.gfpgan_model_path args.gfpgan_model_path
) )
else: else:
print(">> Face restoration disabled") logger.info("Face restoration disabled")
if args.esrgan: if args.esrgan:
esrgan = restoration.load_esrgan(args.esrgan_bg_tile) esrgan = restoration.load_esrgan(args.esrgan_bg_tile)
else: else:
print(">> Upscaling disabled") logger.info("Upscaling disabled")
else: else:
print(">> Face restoration and upscaling disabled") logger.info("Face restoration and upscaling disabled")
except (ModuleNotFoundError, ImportError): except (ModuleNotFoundError, ImportError):
print(traceback.format_exc(), file=sys.stderr) print(traceback.format_exc(), file=sys.stderr)
print(">> You may need to install the ESRGAN and/or GFPGAN modules") logger.info("You may need to install the ESRGAN and/or GFPGAN modules")
self.device = torch.device(choose_torch_device()) self.device = torch.device(choose_torch_device())
self.gfpgan = gfpgan self.gfpgan = gfpgan
self.codeformer = codeformer self.codeformer = codeformer
self.esrgan = esrgan self.esrgan = esrgan
self.logger = logger
self.logger.info('Face restoration initialized')
# note that this one method does gfpgan and codepath reconstruction, as well as # note that this one method does gfpgan and codepath reconstruction, as well as
# esrgan upscaling # esrgan upscaling
@ -58,15 +61,15 @@ class RestorationServices:
if self.gfpgan is not None or self.codeformer is not None: if self.gfpgan is not None or self.codeformer is not None:
if facetool == "gfpgan": if facetool == "gfpgan":
if self.gfpgan is None: if self.gfpgan is None:
print( self.logger.info(
">> GFPGAN not found. Face restoration is disabled." "GFPGAN not found. Face restoration is disabled."
) )
else: else:
image = self.gfpgan.process(image, strength, seed) image = self.gfpgan.process(image, strength, seed)
if facetool == "codeformer": if facetool == "codeformer":
if self.codeformer is None: if self.codeformer is None:
print( self.logger.info(
">> CodeFormer not found. Face restoration is disabled." "CodeFormer not found. Face restoration is disabled."
) )
else: else:
cf_device = ( cf_device = (
@ -80,7 +83,7 @@ class RestorationServices:
fidelity=codeformer_fidelity, fidelity=codeformer_fidelity,
) )
else: else:
print(">> Face Restoration is disabled.") self.logger.info("Face Restoration is disabled.")
if upscale is not None: if upscale is not None:
if self.esrgan is not None: if self.esrgan is not None:
if len(upscale) < 2: if len(upscale) < 2:
@ -93,10 +96,10 @@ class RestorationServices:
denoise_str=upscale_denoise_str, denoise_str=upscale_denoise_str,
) )
else: else:
print(">> ESRGAN is disabled. Image not upscaled.") self.logger.info("ESRGAN is disabled. Image not upscaled.")
except Exception as e: except Exception as e:
print( self.logger.info(
f">> Error running RealESRGAN or GFPGAN. Your image was not upscaled.\n{e}" f"Error running RealESRGAN or GFPGAN. Your image was not upscaled.\n{e}"
) )
if image_callback is not None: if image_callback is not None:

18
invokeai/backend/args.py
View File

@ -96,6 +96,7 @@ from pathlib import Path
from typing import List from typing import List
import invokeai.version import invokeai.version
import invokeai.backend.util.logging as logger
from invokeai.backend.image_util import retrieve_metadata from invokeai.backend.image_util import retrieve_metadata
from .globals import Globals from .globals import Globals
@ -189,7 +190,7 @@ class Args(object):
print(f"{APP_NAME} {APP_VERSION}") print(f"{APP_NAME} {APP_VERSION}")
sys.exit(0) sys.exit(0)
print("* Initializing, be patient...") logger.info("Initializing, be patient...")
Globals.root = Path(os.path.abspath(switches.root_dir or Globals.root)) Globals.root = Path(os.path.abspath(switches.root_dir or Globals.root))
Globals.try_patchmatch = switches.patchmatch Globals.try_patchmatch = switches.patchmatch
@ -197,14 +198,13 @@ class Args(object):
initfile = os.path.expanduser(os.path.join(Globals.root, Globals.initfile)) initfile = os.path.expanduser(os.path.join(Globals.root, Globals.initfile))
legacyinit = os.path.expanduser("~/.invokeai") legacyinit = os.path.expanduser("~/.invokeai")
if os.path.exists(initfile): if os.path.exists(initfile):
print( logger.info(
f">> Initialization file {initfile} found. Loading...", f"Initialization file {initfile} found. Loading...",
file=sys.stderr,
) )
sysargs.insert(0, f"@{initfile}") sysargs.insert(0, f"@{initfile}")
elif os.path.exists(legacyinit): elif os.path.exists(legacyinit):
print( logger.warning(
f">> WARNING: Old initialization file found at {legacyinit}. This location is deprecated. Please move it to {Globals.root}/invokeai.init." f"Old initialization file found at {legacyinit}. This location is deprecated. Please move it to {Globals.root}/invokeai.init."
) )
sysargs.insert(0, f"@{legacyinit}") sysargs.insert(0, f"@{legacyinit}")
Globals.log_tokenization = self._arg_parser.parse_args( Globals.log_tokenization = self._arg_parser.parse_args(
@ -214,7 +214,7 @@ class Args(object):
self._arg_switches = self._arg_parser.parse_args(sysargs) self._arg_switches = self._arg_parser.parse_args(sysargs)
return self._arg_switches return self._arg_switches
except Exception as e: except Exception as e:
print(f"An exception has occurred: {e}") logger.error(f"An exception has occurred: {e}")
return None return None
def parse_cmd(self, cmd_string): def parse_cmd(self, cmd_string):
@ -1154,7 +1154,7 @@ class Args(object):
def format_metadata(**kwargs): def format_metadata(**kwargs):
print("format_metadata() is deprecated. Please use metadata_dumps()") logger.warning("format_metadata() is deprecated. Please use metadata_dumps()")
return metadata_dumps(kwargs) return metadata_dumps(kwargs)
@ -1326,7 +1326,7 @@ def metadata_loads(metadata) -> list:
import sys import sys
import traceback import traceback
print(">> could not read metadata", file=sys.stderr) logger.error("Could not read metadata")
print(traceback.format_exc(), file=sys.stderr) print(traceback.format_exc(), file=sys.stderr)
return results return results

131
invokeai/backend/generate.py
View File

@ -27,6 +27,7 @@ from diffusers.utils.import_utils import is_xformers_available
from omegaconf import OmegaConf from omegaconf import OmegaConf
from pathlib import Path from pathlib import Path
import invokeai.backend.util.logging as logger
from .args import metadata_from_png from .args import metadata_from_png
from .generator import infill_methods from .generator import infill_methods
from .globals import Globals, global_cache_dir from .globals import Globals, global_cache_dir
@ -195,12 +196,12 @@ class Generate:
# device to Generate(). However the device was then ignored, so # device to Generate(). However the device was then ignored, so
# it wasn't actually doing anything. This logic could be reinstated. # it wasn't actually doing anything. This logic could be reinstated.
self.device = torch.device(choose_torch_device()) self.device = torch.device(choose_torch_device())
print(f">> Using device_type {self.device.type}") logger.info(f"Using device_type {self.device.type}")
if full_precision: if full_precision:
if self.precision != "auto": if self.precision != "auto":
raise ValueError("Remove --full_precision / -F if using --precision") raise ValueError("Remove --full_precision / -F if using --precision")
print("Please remove deprecated --full_precision / -F") logger.warning("Please remove deprecated --full_precision / -F")
print("If auto config does not work you can use --precision=float32") logger.warning("If auto config does not work you can use --precision=float32")
self.precision = "float32" self.precision = "float32"
if self.precision == "auto": if self.precision == "auto":
self.precision = choose_precision(self.device) self.precision = choose_precision(self.device)
@ -208,13 +209,13 @@ class Generate:
if is_xformers_available(): if is_xformers_available():
if torch.cuda.is_available() and not Globals.disable_xformers: if torch.cuda.is_available() and not Globals.disable_xformers:
print(">> xformers memory-efficient attention is available and enabled") logger.info("xformers memory-efficient attention is available and enabled")
else: else:
print( logger.info(
">> xformers memory-efficient attention is available but disabled" "xformers memory-efficient attention is available but disabled"
) )
else: else:
print(">> xformers not installed") logger.info("xformers not installed")
# model caching system for fast switching # model caching system for fast switching
self.model_manager = ModelManager( self.model_manager = ModelManager(
@ -229,8 +230,8 @@ class Generate:
fallback = self.model_manager.default_model() or FALLBACK_MODEL_NAME fallback = self.model_manager.default_model() or FALLBACK_MODEL_NAME
model = model or fallback model = model or fallback
if not self.model_manager.valid_model(model): if not self.model_manager.valid_model(model):
print( logger.warning(
f'** "{model}" is not a known model name; falling back to {fallback}.' f'"{model}" is not a known model name; falling back to {fallback}.'
) )
model = None model = None
self.model_name = model or fallback self.model_name = model or fallback
@ -246,10 +247,10 @@ class Generate:
# load safety checker if requested # load safety checker if requested
if safety_checker: if safety_checker:
print(">> Initializing NSFW checker") logger.info("Initializing NSFW checker")
self.safety_checker = SafetyChecker(self.device) self.safety_checker = SafetyChecker(self.device)
else: else:
print(">> NSFW checker is disabled") logger.info("NSFW checker is disabled")
def prompt2png(self, prompt, outdir, **kwargs): def prompt2png(self, prompt, outdir, **kwargs):
""" """
@ -567,7 +568,7 @@ class Generate:
self.clear_cuda_cache() self.clear_cuda_cache()
if catch_interrupts: if catch_interrupts:
print("**Interrupted** Partial results will be returned.") logger.warning("Interrupted** Partial results will be returned.")
else: else:
raise KeyboardInterrupt raise KeyboardInterrupt
except RuntimeError: except RuntimeError:
@ -575,11 +576,11 @@ class Generate:
self.clear_cuda_cache() self.clear_cuda_cache()
print(traceback.format_exc(), file=sys.stderr) print(traceback.format_exc(), file=sys.stderr)
print(">> Could not generate image.") logger.info("Could not generate image.")
toc = time.time() toc = time.time()
print("\n>> Usage stats:") logger.info("Usage stats:")
print(f">> {len(results)} image(s) generated in", "%4.2fs" % (toc - tic)) logger.info(f"{len(results)} image(s) generated in "+"%4.2fs" % (toc - tic))
self.print_cuda_stats() self.print_cuda_stats()
return results return results
@ -609,16 +610,16 @@ class Generate:
def print_cuda_stats(self): def print_cuda_stats(self):
if self._has_cuda(): if self._has_cuda():
self.gather_cuda_stats() self.gather_cuda_stats()
print( logger.info(
">> Max VRAM used for this generation:", "Max VRAM used for this generation: "+
"%4.2fG." % (self.max_memory_allocated / 1e9), "%4.2fG. " % (self.max_memory_allocated / 1e9)+
"Current VRAM utilization:", "Current VRAM utilization: "+
"%4.2fG" % (self.memory_allocated / 1e9), "%4.2fG" % (self.memory_allocated / 1e9)
) )
print( logger.info(
">> Max VRAM used since script start: ", "Max VRAM used since script start: " +
"%4.2fG" % (self.session_peakmem / 1e9), "%4.2fG" % (self.session_peakmem / 1e9)
) )
# this needs to be generalized to all sorts of postprocessors, which should be wrapped # this needs to be generalized to all sorts of postprocessors, which should be wrapped
@ -647,7 +648,7 @@ class Generate:
seed = random.randrange(0, np.iinfo(np.uint32).max) seed = random.randrange(0, np.iinfo(np.uint32).max)
prompt = opt.prompt or args.prompt or "" prompt = opt.prompt or args.prompt or ""
print(f'>> using seed {seed} and prompt "{prompt}" for {image_path}') logger.info(f'using seed {seed} and prompt "{prompt}" for {image_path}')
# try to reuse the same filename prefix as the original file. # try to reuse the same filename prefix as the original file.
# we take everything up to the first period # we take everything up to the first period
@ -696,8 +697,8 @@ class Generate:
try: try:
extend_instructions[direction] = int(pixels) extend_instructions[direction] = int(pixels)
except ValueError: except ValueError:
print( logger.warning(
'** invalid extension instruction. Use <directions> <pixels>..., as in "top 64 left 128 right 64 bottom 64"' 'invalid extension instruction. Use <directions> <pixels>..., as in "top 64 left 128 right 64 bottom 64"'
) )
opt.seed = seed opt.seed = seed
@ -720,8 +721,8 @@ class Generate:
# fetch the metadata from the image # fetch the metadata from the image
generator = self.select_generator(embiggen=True) generator = self.select_generator(embiggen=True)
opt.strength = opt.embiggen_strength or 0.40 opt.strength = opt.embiggen_strength or 0.40
print( logger.info(
f">> Setting img2img strength to {opt.strength} for happy embiggening" f"Setting img2img strength to {opt.strength} for happy embiggening"
) )
generator.generate( generator.generate(
prompt, prompt,
@ -748,12 +749,12 @@ class Generate:
return restorer.process(opt, args, image_callback=callback, prefix=prefix) return restorer.process(opt, args, image_callback=callback, prefix=prefix)
elif tool is None: elif tool is None:
print( logger.warning(
"* please provide at least one postprocessing option, such as -G or -U" "please provide at least one postprocessing option, such as -G or -U"
) )
return None return None
else: else:
print(f"* postprocessing tool {tool} is not yet supported") logger.warning(f"postprocessing tool {tool} is not yet supported")
return None return None
def select_generator( def select_generator(
@ -797,8 +798,8 @@ class Generate:
image = self._load_img(img) image = self._load_img(img)
if image.width < self.width and image.height < self.height: if image.width < self.width and image.height < self.height:
print( logger.warning(
f">> WARNING: img2img and inpainting may produce unexpected results with initial images smaller than {self.width}x{self.height} in both dimensions" f"img2img and inpainting may produce unexpected results with initial images smaller than {self.width}x{self.height} in both dimensions"
) )
# if image has a transparent area and no mask was provided, then try to generate mask # if image has a transparent area and no mask was provided, then try to generate mask
@ -809,8 +810,8 @@ class Generate:
if (image.width * image.height) > ( if (image.width * image.height) > (
self.width * self.height self.width * self.height
) and self.size_matters: ) and self.size_matters:
print( logger.info(
">> This input is larger than your defaults. If you run out of memory, please use a smaller image." "This input is larger than your defaults. If you run out of memory, please use a smaller image."
) )
self.size_matters = False self.size_matters = False
@ -891,11 +892,11 @@ class Generate:
try: try:
model_data = cache.get_model(model_name) model_data = cache.get_model(model_name)
except Exception as e: except Exception as e:
print(f"** model {model_name} could not be loaded: {str(e)}") logger.warning(f"model {model_name} could not be loaded: {str(e)}")
print(traceback.format_exc(), file=sys.stderr) print(traceback.format_exc(), file=sys.stderr)
if previous_model_name is None: if previous_model_name is None:
raise e raise e
print("** trying to reload previous model") logger.warning("trying to reload previous model")
model_data = cache.get_model(previous_model_name) # load previous model_data = cache.get_model(previous_model_name) # load previous
if model_data is None: if model_data is None:
raise e raise e
@ -962,15 +963,15 @@ class Generate:
if self.gfpgan is not None or self.codeformer is not None: if self.gfpgan is not None or self.codeformer is not None:
if facetool == "gfpgan": if facetool == "gfpgan":
if self.gfpgan is None: if self.gfpgan is None:
print( logger.info(
">> GFPGAN not found. Face restoration is disabled." "GFPGAN not found. Face restoration is disabled."
) )
else: else:
image = self.gfpgan.process(image, strength, seed) image = self.gfpgan.process(image, strength, seed)
if facetool == "codeformer": if facetool == "codeformer":
if self.codeformer is None: if self.codeformer is None:
print( logger.info(
">> CodeFormer not found. Face restoration is disabled." "CodeFormer not found. Face restoration is disabled."
) )
else: else:
cf_device = ( cf_device = (
@ -984,7 +985,7 @@ class Generate:
fidelity=codeformer_fidelity, fidelity=codeformer_fidelity,
) )
else: else:
print(">> Face Restoration is disabled.") logger.info("Face Restoration is disabled.")
if upscale is not None: if upscale is not None:
if self.esrgan is not None: if self.esrgan is not None:
if len(upscale) < 2: if len(upscale) < 2:
@ -997,10 +998,10 @@ class Generate:
denoise_str=upscale_denoise_str, denoise_str=upscale_denoise_str,
) )
else: else:
print(">> ESRGAN is disabled. Image not upscaled.") logger.info("ESRGAN is disabled. Image not upscaled.")
except Exception as e: except Exception as e:
print( logger.info(
f">> Error running RealESRGAN or GFPGAN. Your image was not upscaled.\n{e}" f"Error running RealESRGAN or GFPGAN. Your image was not upscaled.\n{e}"
) )
if image_callback is not None: if image_callback is not None:
@ -1066,17 +1067,17 @@ class Generate:
if self.sampler_name in scheduler_map: if self.sampler_name in scheduler_map:
sampler_class = scheduler_map[self.sampler_name] sampler_class = scheduler_map[self.sampler_name]
msg = ( msg = (
f">> Setting Sampler to {self.sampler_name} ({sampler_class.__name__})" f"Setting Sampler to {self.sampler_name} ({sampler_class.__name__})"
) )
self.sampler = sampler_class.from_config(self.model.scheduler.config) self.sampler = sampler_class.from_config(self.model.scheduler.config)
else: else:
msg = ( msg = (
f">> Unsupported Sampler: {self.sampler_name} " f" Unsupported Sampler: {self.sampler_name} "+
f"Defaulting to {default}" f"Defaulting to {default}"
) )
self.sampler = default self.sampler = default
print(msg) logger.info(msg)
if not hasattr(self.sampler, "uses_inpainting_model"): if not hasattr(self.sampler, "uses_inpainting_model"):
# FIXME: terrible kludge! # FIXME: terrible kludge!
@ -1085,17 +1086,17 @@ class Generate:
def _load_img(self, img) -> Image: def _load_img(self, img) -> Image:
if isinstance(img, Image.Image): if isinstance(img, Image.Image):
image = img image = img
print(f">> using provided input image of size {image.width}x{image.height}") logger.info(f"using provided input image of size {image.width}x{image.height}")
elif isinstance(img, str): elif isinstance(img, str):
assert os.path.exists(img), f">> {img}: File not found" assert os.path.exists(img), f"{img}: File not found"
image = Image.open(img) image = Image.open(img)
print( logger.info(
f">> loaded input image of size {image.width}x{image.height} from {img}" f"loaded input image of size {image.width}x{image.height} from {img}"
) )
else: else:
image = Image.open(img) image = Image.open(img)
print(f">> loaded input image of size {image.width}x{image.height}") logger.info(f"loaded input image of size {image.width}x{image.height}")
image = ImageOps.exif_transpose(image) image = ImageOps.exif_transpose(image)
return image return image
@ -1183,14 +1184,14 @@ class Generate:
def _transparency_check_and_warning(self, image, mask, force_outpaint=False): def _transparency_check_and_warning(self, image, mask, force_outpaint=False):
if not mask: if not mask:
print( logger.info(
">> Initial image has transparent areas. Will inpaint in these regions." "Initial image has transparent areas. Will inpaint in these regions."
) )
if (not force_outpaint) and self._check_for_erasure(image): if (not force_outpaint) and self._check_for_erasure(image):
print( logger.info(
">> WARNING: Colors underneath the transparent region seem to have been erased.\n", "Colors underneath the transparent region seem to have been erased.\n" +
">> Inpainting will be suboptimal. Please preserve the colors when making\n", "Inpainting will be suboptimal. Please preserve the colors when making\n" +
">> a transparency mask, or provide mask explicitly using --init_mask (-M).", "a transparency mask, or provide mask explicitly using --init_mask (-M)."
) )
def _squeeze_image(self, image): def _squeeze_image(self, image):
@ -1201,11 +1202,11 @@ class Generate:
def _fit_image(self, image, max_dimensions): def _fit_image(self, image, max_dimensions):
w, h = max_dimensions w, h = max_dimensions
print(f">> image will be resized to fit inside a box {w}x{h} in size.") logger.info(f"image will be resized to fit inside a box {w}x{h} in size.")
# note that InitImageResizer does the multiple of 64 truncation internally # note that InitImageResizer does the multiple of 64 truncation internally
image = InitImageResizer(image).resize(width=w, height=h) image = InitImageResizer(image).resize(width=w, height=h)
print( logger.info(
f">> after adjusting image dimensions to be multiples of 64, init image is {image.width}x{image.height}" f"after adjusting image dimensions to be multiples of 64, init image is {image.width}x{image.height}"
) )
return image return image
@ -1216,8 +1217,8 @@ class Generate:
) # resize to integer multiple of 64 ) # resize to integer multiple of 64
if h != height or w != width: if h != height or w != width:
if log: if log:
print( logger.info(
f">> Provided width and height must be multiples of 64. Auto-resizing to {w}x{h}" f"Provided width and height must be multiples of 64. Auto-resizing to {w}x{h}"
) )
height = h height = h
width = w width = w

5
invokeai/backend/generator/base.py
View File

@ -25,6 +25,7 @@ from typing import Callable, List, Iterator, Optional, Type
from dataclasses import dataclass, field from dataclasses import dataclass, field
from diffusers.schedulers import SchedulerMixin as Scheduler from diffusers.schedulers import SchedulerMixin as Scheduler
import invokeai.backend.util.logging as logger
from ..image_util import configure_model_padding from ..image_util import configure_model_padding
from ..util.util import rand_perlin_2d from ..util.util import rand_perlin_2d
from ..safety_checker import SafetyChecker from ..safety_checker import SafetyChecker
@ -372,7 +373,7 @@ class Generator:
try: try:
x_T = self.get_noise(width, height) x_T = self.get_noise(width, height)
except: except:
print("** An error occurred while getting initial noise **") logger.error("An error occurred while getting initial noise")
print(traceback.format_exc()) print(traceback.format_exc())
# Pass on the seed in case a layer beneath us needs to generate noise on its own. # Pass on the seed in case a layer beneath us needs to generate noise on its own.
@ -607,7 +608,7 @@ class Generator:
image = self.sample_to_image(sample) image = self.sample_to_image(sample)
dirname = os.path.dirname(filepath) or "." dirname = os.path.dirname(filepath) or "."
if not os.path.exists(dirname): if not os.path.exists(dirname):
print(f"** creating directory {dirname}") logger.info(f"creating directory {dirname}")
os.makedirs(dirname, exist_ok=True) os.makedirs(dirname, exist_ok=True)
image.save(filepath, "PNG") image.save(filepath, "PNG")

37
invokeai/backend/generator/embiggen.py
View File

@ -8,10 +8,11 @@ import torch
from PIL import Image from PIL import Image
from tqdm import trange from tqdm import trange
import invokeai.backend.util.logging as logger
from .base import Generator from .base import Generator
from .img2img import Img2Img from .img2img import Img2Img
class Embiggen(Generator): class Embiggen(Generator):
def __init__(self, model, precision): def __init__(self, model, precision):
super().__init__(model, precision) super().__init__(model, precision)
@ -72,22 +73,22 @@ class Embiggen(Generator):
embiggen = [1.0] # If not specified, assume no scaling embiggen = [1.0] # If not specified, assume no scaling
elif embiggen[0] < 0: elif embiggen[0] < 0:
embiggen[0] = 1.0 embiggen[0] = 1.0
print( logger.warning(
">> Embiggen scaling factor cannot be negative, fell back to the default of 1.0 !" "Embiggen scaling factor cannot be negative, fell back to the default of 1.0 !"
) )
if len(embiggen) < 2: if len(embiggen) < 2:
embiggen.append(0.75) embiggen.append(0.75)
elif embiggen[1] > 1.0 or embiggen[1] < 0: elif embiggen[1] > 1.0 or embiggen[1] < 0:
embiggen[1] = 0.75 embiggen[1] = 0.75
print( logger.warning(
">> Embiggen upscaling strength for ESRGAN must be between 0 and 1, fell back to the default of 0.75 !" "Embiggen upscaling strength for ESRGAN must be between 0 and 1, fell back to the default of 0.75 !"
) )
if len(embiggen) < 3: if len(embiggen) < 3:
embiggen.append(0.25) embiggen.append(0.25)
elif embiggen[2] < 0: elif embiggen[2] < 0:
embiggen[2] = 0.25 embiggen[2] = 0.25
print( logger.warning(
">> Overlap size for Embiggen must be a positive ratio between 0 and 1 OR a number of pixels, fell back to the default of 0.25 !" "Overlap size for Embiggen must be a positive ratio between 0 and 1 OR a number of pixels, fell back to the default of 0.25 !"
) )
# Convert tiles from their user-freindly count-from-one to count-from-zero, because we need to do modulo math # Convert tiles from their user-freindly count-from-one to count-from-zero, because we need to do modulo math
@ -97,8 +98,8 @@ class Embiggen(Generator):
embiggen_tiles.sort() embiggen_tiles.sort()
if strength >= 0.5: if strength >= 0.5:
print( logger.warning(
f"* WARNING: Embiggen may produce mirror motifs if the strength (-f) is too high (currently {strength}). Try values between 0.35-0.45." f"Embiggen may produce mirror motifs if the strength (-f) is too high (currently {strength}). Try values between 0.35-0.45."
) )
# Prep img2img generator, since we wrap over it # Prep img2img generator, since we wrap over it
@ -121,8 +122,8 @@ class Embiggen(Generator):
from ..restoration.realesrgan import ESRGAN from ..restoration.realesrgan import ESRGAN
esrgan = ESRGAN() esrgan = ESRGAN()
print( logger.info(
f">> ESRGAN upscaling init image prior to cutting with Embiggen with strength {embiggen[1]}" f"ESRGAN upscaling init image prior to cutting with Embiggen with strength {embiggen[1]}"
) )
if embiggen[0] > 2: if embiggen[0] > 2:
initsuperimage = esrgan.process( initsuperimage = esrgan.process(
@ -312,10 +313,10 @@ class Embiggen(Generator):
def make_image(): def make_image():
# Make main tiles ------------------------------------------------- # Make main tiles -------------------------------------------------
if embiggen_tiles: if embiggen_tiles:
print(f">> Making {len(embiggen_tiles)} Embiggen tiles...") logger.info(f"Making {len(embiggen_tiles)} Embiggen tiles...")
else: else:
print( logger.info(
f">> Making {(emb_tiles_x * emb_tiles_y)} Embiggen tiles ({emb_tiles_x}x{emb_tiles_y})..." f"Making {(emb_tiles_x * emb_tiles_y)} Embiggen tiles ({emb_tiles_x}x{emb_tiles_y})..."
) )
emb_tile_store = [] emb_tile_store = []
@ -361,11 +362,11 @@ class Embiggen(Generator):
# newinitimage.save(newinitimagepath) # newinitimage.save(newinitimagepath)
if embiggen_tiles: if embiggen_tiles:
print( logger.debug(
f"Making tile #{tile + 1} ({embiggen_tiles.index(tile) + 1} of {len(embiggen_tiles)} requested)" f"Making tile #{tile + 1} ({embiggen_tiles.index(tile) + 1} of {len(embiggen_tiles)} requested)"
) )
else: else:
print(f"Starting {tile + 1} of {(emb_tiles_x * emb_tiles_y)} tiles") logger.debug(f"Starting {tile + 1} of {(emb_tiles_x * emb_tiles_y)} tiles")
# create a torch tensor from an Image # create a torch tensor from an Image
newinitimage = np.array(newinitimage).astype(np.float32) / 255.0 newinitimage = np.array(newinitimage).astype(np.float32) / 255.0
@ -547,8 +548,8 @@ class Embiggen(Generator):
# Layer tile onto final image # Layer tile onto final image
outputsuperimage.alpha_composite(intileimage, (left, top)) outputsuperimage.alpha_composite(intileimage, (left, top))
else: else:
print( logger.error(
"Error: could not find all Embiggen output tiles in memory? Something must have gone wrong with img2img generation." "Could not find all Embiggen output tiles in memory? Something must have gone wrong with img2img generation."
) )
# after internal loops and patching up return Embiggen image # after internal loops and patching up return Embiggen image

6
invokeai/backend/generator/txt2img2img.py
View File

@ -14,6 +14,8 @@ from ..stable_diffusion.diffusers_pipeline import StableDiffusionGeneratorPipeli
from ..stable_diffusion.diffusers_pipeline import ConditioningData from ..stable_diffusion.diffusers_pipeline import ConditioningData
from ..stable_diffusion.diffusers_pipeline import trim_to_multiple_of from ..stable_diffusion.diffusers_pipeline import trim_to_multiple_of
import invokeai.backend.util.logging as logger
class Txt2Img2Img(Generator): class Txt2Img2Img(Generator):
def __init__(self, model, precision): def __init__(self, model, precision):
super().__init__(model, precision) super().__init__(model, precision)
@ -77,8 +79,8 @@ class Txt2Img2Img(Generator):
# the message below is accurate. # the message below is accurate.
init_width = first_pass_latent_output.size()[3] * self.downsampling_factor init_width = first_pass_latent_output.size()[3] * self.downsampling_factor
init_height = first_pass_latent_output.size()[2] * self.downsampling_factor init_height = first_pass_latent_output.size()[2] * self.downsampling_factor
print( logger.info(
f"\n>> Interpolating from {init_width}x{init_height} to {width}x{height} using DDIM sampling" f"Interpolating from {init_width}x{init_height} to {width}x{height} using DDIM sampling"
) )
# resizing # resizing

9
invokeai/backend/image_util/patchmatch.py
View File

@ -5,10 +5,9 @@ wraps the actual patchmatch object. It respects the global
be suppressed or deferred be suppressed or deferred
""" """
import numpy as np import numpy as np
import invokeai.backend.util.logging as logger
from invokeai.backend.globals import Globals from invokeai.backend.globals import Globals
class PatchMatch: class PatchMatch:
""" """
Thin class wrapper around the patchmatch function. Thin class wrapper around the patchmatch function.
@ -28,12 +27,12 @@ class PatchMatch:
from patchmatch import patch_match as pm from patchmatch import patch_match as pm
if pm.patchmatch_available: if pm.patchmatch_available:
print(">> Patchmatch initialized") logger.info("Patchmatch initialized")
else: else:
print(">> Patchmatch not loaded (nonfatal)") logger.info("Patchmatch not loaded (nonfatal)")
self.patch_match = pm self.patch_match = pm
else: else:
print(">> Patchmatch loading disabled") logger.info("Patchmatch loading disabled")
self.tried_load = True self.tried_load = True
@classmethod @classmethod

16
invokeai/backend/image_util/txt2mask.py
View File

@ -30,9 +30,9 @@ work fine.
import numpy as np import numpy as np
import torch import torch
from PIL import Image, ImageOps from PIL import Image, ImageOps
from torchvision import transforms
from transformers import AutoProcessor, CLIPSegForImageSegmentation from transformers import AutoProcessor, CLIPSegForImageSegmentation
import invokeai.backend.util.logging as logger
from invokeai.backend.globals import global_cache_dir from invokeai.backend.globals import global_cache_dir
CLIPSEG_MODEL = "CIDAS/clipseg-rd64-refined" CLIPSEG_MODEL = "CIDAS/clipseg-rd64-refined"
@ -83,7 +83,7 @@ class Txt2Mask(object):
""" """
def __init__(self, device="cpu", refined=False): def __init__(self, device="cpu", refined=False):
print(">> Initializing clipseg model for text to mask inference") logger.info("Initializing clipseg model for text to mask inference")
# BUG: we are not doing anything with the device option at this time # BUG: we are not doing anything with the device option at this time
self.device = device self.device = device
@ -101,18 +101,6 @@ class Txt2Mask(object):
provided image and returns a SegmentedGrayscale object in which the brighter provided image and returns a SegmentedGrayscale object in which the brighter
pixels indicate where the object is inferred to be. pixels indicate where the object is inferred to be.
""" """
transform = transforms.Compose(
[
transforms.ToTensor(),
transforms.Normalize(
mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
),
transforms.Resize(
(CLIPSEG_SIZE, CLIPSEG_SIZE)
), # must be multiple of 64...
]
)
if type(image) is str: if type(image) is str:
image = Image.open(image).convert("RGB") image = Image.open(image).convert("RGB")

17
invokeai/backend/model_management/convert_ckpt_to_diffusers.py
View File

@ -25,6 +25,7 @@ from typing import Union
import torch import torch
from safetensors.torch import load_file from safetensors.torch import load_file
import invokeai.backend.util.logging as logger
from invokeai.backend.globals import global_cache_dir, global_config_dir from invokeai.backend.globals import global_cache_dir, global_config_dir
from .model_manager import ModelManager, SDLegacyType from .model_manager import ModelManager, SDLegacyType
@ -372,9 +373,9 @@ def convert_ldm_unet_checkpoint(checkpoint, config, path=None, extract_ema=False
unet_key = "model.diffusion_model." unet_key = "model.diffusion_model."
# at least a 100 parameters have to start with `model_ema` in order for the checkpoint to be EMA # at least a 100 parameters have to start with `model_ema` in order for the checkpoint to be EMA
if sum(k.startswith("model_ema") for k in keys) > 100: if sum(k.startswith("model_ema") for k in keys) > 100:
print(f" | Checkpoint {path} has both EMA and non-EMA weights.") logger.debug(f"Checkpoint {path} has both EMA and non-EMA weights.")
if extract_ema: if extract_ema:
print(" | Extracting EMA weights (usually better for inference)") logger.debug("Extracting EMA weights (usually better for inference)")
for key in keys: for key in keys:
if key.startswith("model.diffusion_model"): if key.startswith("model.diffusion_model"):
flat_ema_key = "model_ema." + "".join(key.split(".")[1:]) flat_ema_key = "model_ema." + "".join(key.split(".")[1:])
@ -392,8 +393,8 @@ def convert_ldm_unet_checkpoint(checkpoint, config, path=None, extract_ema=False
key key
) )
else: else:
print( logger.debug(
" | Extracting only the non-EMA weights (usually better for fine-tuning)" "Extracting only the non-EMA weights (usually better for fine-tuning)"
) )
for key in keys: for key in keys:
@ -1115,7 +1116,7 @@ def load_pipeline_from_original_stable_diffusion_ckpt(
if "global_step" in checkpoint: if "global_step" in checkpoint:
global_step = checkpoint["global_step"] global_step = checkpoint["global_step"]
else: else:
print(" | global_step key not found in model") logger.debug("global_step key not found in model")
global_step = None global_step = None
# sometimes there is a state_dict key and sometimes not # sometimes there is a state_dict key and sometimes not
@ -1229,15 +1230,15 @@ def load_pipeline_from_original_stable_diffusion_ckpt(
# If a replacement VAE path was specified, we'll incorporate that into # If a replacement VAE path was specified, we'll incorporate that into
# the checkpoint model and then convert it # the checkpoint model and then convert it
if vae_path: if vae_path:
print(f" | Converting VAE {vae_path}") logger.debug(f"Converting VAE {vae_path}")
replace_checkpoint_vae(checkpoint,vae_path) replace_checkpoint_vae(checkpoint,vae_path)
# otherwise we use the original VAE, provided that # otherwise we use the original VAE, provided that
# an externally loaded diffusers VAE was not passed # an externally loaded diffusers VAE was not passed
elif not vae: elif not vae:
print(" | Using checkpoint model's original VAE") logger.debug("Using checkpoint model's original VAE")
if vae: if vae:
print(" | Using replacement diffusers VAE") logger.debug("Using replacement diffusers VAE")
else: # convert the original or replacement VAE else: # convert the original or replacement VAE
vae_config = create_vae_diffusers_config( vae_config = create_vae_diffusers_config(
original_config, image_size=image_size original_config, image_size=image_size

191
invokeai/backend/model_management/model_manager.py
View File

@ -18,12 +18,13 @@ import warnings
from enum import Enum, auto from enum import Enum, auto
from pathlib import Path from pathlib import Path
from shutil import move, rmtree from shutil import move, rmtree
from typing import Any, Optional, Union, Callable from typing import Any, Optional, Union, Callable, types
import safetensors import safetensors
import safetensors.torch import safetensors.torch
import torch import torch
import transformers import transformers
import invokeai.backend.util.logging as logger
from diffusers import ( from diffusers import (
AutoencoderKL, AutoencoderKL,
UNet2DConditionModel, UNet2DConditionModel,
@ -75,6 +76,8 @@ class ModelManager(object):
Model manager handles loading, caching, importing, deleting, converting, and editing models. Model manager handles loading, caching, importing, deleting, converting, and editing models.
""" """
logger: types.ModuleType = logger
def __init__( def __init__(
self, self,
config: OmegaConf | Path, config: OmegaConf | Path,
@ -83,6 +86,7 @@ class ModelManager(object):
max_loaded_models=DEFAULT_MAX_MODELS, max_loaded_models=DEFAULT_MAX_MODELS,
sequential_offload=False, sequential_offload=False,
embedding_path: Path = None, embedding_path: Path = None,
logger: types.ModuleType = logger,
): ):
""" """
Initialize with the path to the models.yaml config file or Initialize with the path to the models.yaml config file or
@ -104,6 +108,7 @@ class ModelManager(object):
self.current_model = None self.current_model = None
self.sequential_offload = sequential_offload self.sequential_offload = sequential_offload
self.embedding_path = embedding_path self.embedding_path = embedding_path
self.logger = logger
def valid_model(self, model_name: str) -> bool: def valid_model(self, model_name: str) -> bool:
""" """
@ -132,8 +137,8 @@ class ModelManager(object):
) )
if not self.valid_model(model_name): if not self.valid_model(model_name):
print( self.logger.error(
f'** "{model_name}" is not a known model name. Please check your models.yaml file' f'"{model_name}" is not a known model name. Please check your models.yaml file'
) )
return self.current_model return self.current_model
@ -144,7 +149,7 @@ class ModelManager(object):
if model_name in self.models: if model_name in self.models:
requested_model = self.models[model_name]["model"] requested_model = self.models[model_name]["model"]
print(f">> Retrieving model {model_name} from system RAM cache") self.logger.info(f"Retrieving model {model_name} from system RAM cache")
requested_model.ready() requested_model.ready()
width = self.models[model_name]["width"] width = self.models[model_name]["width"]
height = self.models[model_name]["height"] height = self.models[model_name]["height"]
@ -379,7 +384,7 @@ class ModelManager(object):
""" """
omega = self.config omega = self.config
if model_name not in omega: if model_name not in omega:
print(f"** Unknown model {model_name}") self.logger.error(f"Unknown model {model_name}")
return return
# save these for use in deletion later # save these for use in deletion later
conf = omega[model_name] conf = omega[model_name]
@ -392,13 +397,13 @@ class ModelManager(object):
self.stack.remove(model_name) self.stack.remove(model_name)
if delete_files: if delete_files:
if weights: if weights:
print(f"** Deleting file {weights}") self.logger.info(f"Deleting file {weights}")
Path(weights).unlink(missing_ok=True) Path(weights).unlink(missing_ok=True)
elif path: elif path:
print(f"** Deleting directory {path}") self.logger.info(f"Deleting directory {path}")
rmtree(path, ignore_errors=True) rmtree(path, ignore_errors=True)
elif repo_id: elif repo_id:
print(f"** Deleting the cached model directory for {repo_id}") self.logger.info(f"Deleting the cached model directory for {repo_id}")
self._delete_model_from_cache(repo_id) self._delete_model_from_cache(repo_id)
def add_model( def add_model(
@ -439,7 +444,7 @@ class ModelManager(object):
def _load_model(self, model_name: str): def _load_model(self, model_name: str):
"""Load and initialize the model from configuration variables passed at object creation time""" """Load and initialize the model from configuration variables passed at object creation time"""
if model_name not in self.config: if model_name not in self.config:
print( self.logger.error(
f'"{model_name}" is not a known model name. Please check your models.yaml file' f'"{model_name}" is not a known model name. Please check your models.yaml file'
) )
return return
@ -457,7 +462,7 @@ class ModelManager(object):
model_format = mconfig.get("format", "ckpt") model_format = mconfig.get("format", "ckpt")
if model_format == "ckpt": if model_format == "ckpt":
weights = mconfig.weights weights = mconfig.weights
print(f">> Loading {model_name} from {weights}") self.logger.info(f"Loading {model_name} from {weights}")
model, width, height, model_hash = self._load_ckpt_model( model, width, height, model_hash = self._load_ckpt_model(
model_name, mconfig model_name, mconfig
) )
@ -473,13 +478,15 @@ class ModelManager(object):
# usage statistics # usage statistics
toc = time.time() toc = time.time()
print(">> Model loaded in", "%4.2fs" % (toc - tic)) self.logger.info("Model loaded in " + "%4.2fs" % (toc - tic))
if self._has_cuda(): if self._has_cuda():
print( self.logger.info(
">> Max VRAM used to load the model:", "Max VRAM used to load the model: "+
"%4.2fG" % (torch.cuda.max_memory_allocated() / 1e9), "%4.2fG" % (torch.cuda.max_memory_allocated() / 1e9)
"\n>> Current VRAM usage:" )
"%4.2fG" % (torch.cuda.memory_allocated() / 1e9), self.logger.info(
"Current VRAM usage: "+
"%4.2fG" % (torch.cuda.memory_allocated() / 1e9)
) )
return model, width, height, model_hash return model, width, height, model_hash
@ -487,11 +494,11 @@ class ModelManager(object):
name_or_path = self.model_name_or_path(mconfig) name_or_path = self.model_name_or_path(mconfig)
using_fp16 = self.precision == "float16" using_fp16 = self.precision == "float16"
print(f">> Loading diffusers model from {name_or_path}") self.logger.info(f"Loading diffusers model from {name_or_path}")
if using_fp16: if using_fp16:
print(" | Using faster float16 precision") self.logger.debug("Using faster float16 precision")
else: else:
print(" | Using more accurate float32 precision") self.logger.debug("Using more accurate float32 precision")
# TODO: scan weights maybe? # TODO: scan weights maybe?
pipeline_args: dict[str, Any] = dict( pipeline_args: dict[str, Any] = dict(
@ -523,8 +530,8 @@ class ModelManager(object):
if str(e).startswith("fp16 is not a valid"): if str(e).startswith("fp16 is not a valid"):
pass pass
else: else:
print( self.logger.error(
f"** An unexpected error occurred while downloading the model: {e})" f"An unexpected error occurred while downloading the model: {e})"
) )
if pipeline: if pipeline:
break break
@ -542,7 +549,7 @@ class ModelManager(object):
# square images??? # square images???
width = pipeline.unet.config.sample_size * pipeline.vae_scale_factor width = pipeline.unet.config.sample_size * pipeline.vae_scale_factor
height = width height = width
print(f" | Default image dimensions = {width} x {height}") self.logger.debug(f"Default image dimensions = {width} x {height}")
return pipeline, width, height, model_hash return pipeline, width, height, model_hash
@ -559,14 +566,14 @@ class ModelManager(object):
weights = os.path.normpath(os.path.join(Globals.root, weights)) weights = os.path.normpath(os.path.join(Globals.root, weights))
# Convert to diffusers and return a diffusers pipeline # Convert to diffusers and return a diffusers pipeline
print(f">> Converting legacy checkpoint {model_name} into a diffusers model...") self.logger.info(f"Converting legacy checkpoint {model_name} into a diffusers model...")
from . import load_pipeline_from_original_stable_diffusion_ckpt from . import load_pipeline_from_original_stable_diffusion_ckpt
try: try:
if self.list_models()[self.current_model]["status"] == "active": if self.list_models()[self.current_model]["status"] == "active":
self.offload_model(self.current_model) self.offload_model(self.current_model)
except Exception as e: except Exception:
pass pass
vae_path = None vae_path = None
@ -624,7 +631,7 @@ class ModelManager(object):
if model_name not in self.models: if model_name not in self.models:
return return
print(f">> Offloading {model_name} to CPU") self.logger.info(f"Offloading {model_name} to CPU")
model = self.models[model_name]["model"] model = self.models[model_name]["model"]
model.offload_all() model.offload_all()
self.current_model = None self.current_model = None
@ -640,30 +647,26 @@ class ModelManager(object):
and option to exit if an infected file is identified. and option to exit if an infected file is identified.
""" """
# scan model # scan model
print(f" | Scanning Model: {model_name}") self.logger.debug(f"Scanning Model: {model_name}")
scan_result = scan_file_path(checkpoint) scan_result = scan_file_path(checkpoint)
if scan_result.infected_files != 0: if scan_result.infected_files != 0:
if scan_result.infected_files == 1: if scan_result.infected_files == 1:
print(f"\n### Issues Found In Model: {scan_result.issues_count}") self.logger.critical(f"Issues Found In Model: {scan_result.issues_count}")
print( self.logger.critical("The model you are trying to load seems to be infected.")
"### WARNING: The model you are trying to load seems to be infected." self.logger.critical("For your safety, InvokeAI will not load this model.")
) self.logger.critical("Please use checkpoints from trusted sources.")
print("### For your safety, InvokeAI will not load this model.") self.logger.critical("Exiting InvokeAI")
print("### Please use checkpoints from trusted sources.")
print("### Exiting InvokeAI")
sys.exit() sys.exit()
else: else:
print( self.logger.warning("InvokeAI was unable to scan the model you are using.")
"\n### WARNING: InvokeAI was unable to scan the model you are using."
)
model_safe_check_fail = ask_user( model_safe_check_fail = ask_user(
"Do you want to to continue loading the model?", ["y", "n"] "Do you want to to continue loading the model?", ["y", "n"]
) )
if model_safe_check_fail.lower() != "y": if model_safe_check_fail.lower() != "y":
print("### Exiting InvokeAI") self.logger.critical("Exiting InvokeAI")
sys.exit() sys.exit()
else: else:
print(" | Model scanned ok") self.logger.debug("Model scanned ok")
def import_diffuser_model( def import_diffuser_model(
self, self,
@ -780,26 +783,24 @@ class ModelManager(object):
model_path: Path = None model_path: Path = None
thing = path_url_or_repo # to save typing thing = path_url_or_repo # to save typing
print(f">> Probing {thing} for import") self.logger.info(f"Probing {thing} for import")
if thing.startswith(("http:", "https:", "ftp:")): if thing.startswith(("http:", "https:", "ftp:")):
print(f" | {thing} appears to be a URL") self.logger.info(f"{thing} appears to be a URL")
model_path = self._resolve_path( model_path = self._resolve_path(
thing, "models/ldm/stable-diffusion-v1" thing, "models/ldm/stable-diffusion-v1"
) # _resolve_path does a download if needed ) # _resolve_path does a download if needed
elif Path(thing).is_file() and thing.endswith((".ckpt", ".safetensors")): elif Path(thing).is_file() and thing.endswith((".ckpt", ".safetensors")):
if Path(thing).stem in ["model", "diffusion_pytorch_model"]: if Path(thing).stem in ["model", "diffusion_pytorch_model"]:
print( self.logger.debug(f"{Path(thing).name} appears to be part of a diffusers model. Skipping import")
f" | {Path(thing).name} appears to be part of a diffusers model. Skipping import"
)
return return
else: else:
print(f" | {thing} appears to be a checkpoint file on disk") self.logger.debug(f"{thing} appears to be a checkpoint file on disk")
model_path = self._resolve_path(thing, "models/ldm/stable-diffusion-v1") model_path = self._resolve_path(thing, "models/ldm/stable-diffusion-v1")
elif Path(thing).is_dir() and Path(thing, "model_index.json").exists(): elif Path(thing).is_dir() and Path(thing, "model_index.json").exists():
print(f" | {thing} appears to be a diffusers file on disk") self.logger.debug(f"{thing} appears to be a diffusers file on disk")
model_name = self.import_diffuser_model( model_name = self.import_diffuser_model(
thing, thing,
vae=dict(repo_id="stabilityai/sd-vae-ft-mse"), vae=dict(repo_id="stabilityai/sd-vae-ft-mse"),
@ -810,34 +811,30 @@ class ModelManager(object):
elif Path(thing).is_dir(): elif Path(thing).is_dir():
if (Path(thing) / "model_index.json").exists(): if (Path(thing) / "model_index.json").exists():
print(f" | {thing} appears to be a diffusers model.") self.logger.debug(f"{thing} appears to be a diffusers model.")
model_name = self.import_diffuser_model( model_name = self.import_diffuser_model(
thing, commit_to_conf=commit_to_conf thing, commit_to_conf=commit_to_conf
) )
else: else:
print( self.logger.debug(f"{thing} appears to be a directory. Will scan for models to import")
f" |{thing} appears to be a directory. Will scan for models to import"
)
for m in list(Path(thing).rglob("*.ckpt")) + list( for m in list(Path(thing).rglob("*.ckpt")) + list(
Path(thing).rglob("*.safetensors") Path(thing).rglob("*.safetensors")
): ):
if model_name := self.heuristic_import( if model_name := self.heuristic_import(
str(m), commit_to_conf=commit_to_conf str(m), commit_to_conf=commit_to_conf
): ):
print(f" >> {model_name} successfully imported") self.logger.info(f"{model_name} successfully imported")
return model_name return model_name
elif re.match(r"^[\w.+-]+/[\w.+-]+$", thing): elif re.match(r"^[\w.+-]+/[\w.+-]+$", thing):
print(f" | {thing} appears to be a HuggingFace diffusers repo_id") self.logger.debug(f"{thing} appears to be a HuggingFace diffusers repo_id")
model_name = self.import_diffuser_model( model_name = self.import_diffuser_model(
thing, commit_to_conf=commit_to_conf thing, commit_to_conf=commit_to_conf
) )
pipeline, _, _, _ = self._load_diffusers_model(self.config[model_name]) pipeline, _, _, _ = self._load_diffusers_model(self.config[model_name])
return model_name return model_name
else: else:
print( self.logger.warning(f"{thing}: Unknown thing. Please provide a URL, file path, directory or HuggingFace repo_id")
f"** {thing}: Unknown thing. Please provide a URL, file path, directory or HuggingFace repo_id"
)
# Model_path is set in the event of a legacy checkpoint file. # Model_path is set in the event of a legacy checkpoint file.
# If not set, we're all done # If not set, we're all done
@ -845,7 +842,7 @@ class ModelManager(object):
return return
if model_path.stem in self.config: # already imported if model_path.stem in self.config: # already imported
print(" | Already imported. Skipping") self.logger.debug("Already imported. Skipping")
return model_path.stem return model_path.stem
# another round of heuristics to guess the correct config file. # another round of heuristics to guess the correct config file.
@ -861,39 +858,39 @@ class ModelManager(object):
# look for a like-named .yaml file in same directory # look for a like-named .yaml file in same directory
if model_path.with_suffix(".yaml").exists(): if model_path.with_suffix(".yaml").exists():
model_config_file = model_path.with_suffix(".yaml") model_config_file = model_path.with_suffix(".yaml")
print(f" | Using config file {model_config_file.name}") self.logger.debug(f"Using config file {model_config_file.name}")
else: else:
model_type = self.probe_model_type(checkpoint) model_type = self.probe_model_type(checkpoint)
if model_type == SDLegacyType.V1: if model_type == SDLegacyType.V1:
print(" | SD-v1 model detected") self.logger.debug("SD-v1 model detected")
model_config_file = Path( model_config_file = Path(
Globals.root, "configs/stable-diffusion/v1-inference.yaml" Globals.root, "configs/stable-diffusion/v1-inference.yaml"
) )
elif model_type == SDLegacyType.V1_INPAINT: elif model_type == SDLegacyType.V1_INPAINT:
print(" | SD-v1 inpainting model detected") self.logger.debug("SD-v1 inpainting model detected")
model_config_file = Path( model_config_file = Path(
Globals.root, Globals.root,
"configs/stable-diffusion/v1-inpainting-inference.yaml", "configs/stable-diffusion/v1-inpainting-inference.yaml",
) )
elif model_type == SDLegacyType.V2_v: elif model_type == SDLegacyType.V2_v:
print(" | SD-v2-v model detected") self.logger.debug("SD-v2-v model detected")
model_config_file = Path( model_config_file = Path(
Globals.root, "configs/stable-diffusion/v2-inference-v.yaml" Globals.root, "configs/stable-diffusion/v2-inference-v.yaml"
) )
elif model_type == SDLegacyType.V2_e: elif model_type == SDLegacyType.V2_e:
print(" | SD-v2-e model detected") self.logger.debug("SD-v2-e model detected")
model_config_file = Path( model_config_file = Path(
Globals.root, "configs/stable-diffusion/v2-inference.yaml" Globals.root, "configs/stable-diffusion/v2-inference.yaml"
) )
elif model_type == SDLegacyType.V2: elif model_type == SDLegacyType.V2:
print( self.logger.warning(
f"** {thing} is a V2 checkpoint file, but its parameterization cannot be determined. Please provide configuration file path." f"{thing} is a V2 checkpoint file, but its parameterization cannot be determined. Please provide configuration file path."
) )
return return
else: else:
print( self.logger.warning(
f"** {thing} is a legacy checkpoint file but not a known Stable Diffusion model. Please provide configuration file path." f"{thing} is a legacy checkpoint file but not a known Stable Diffusion model. Please provide configuration file path."
) )
return return
@ -909,7 +906,7 @@ class ModelManager(object):
for suffix in ["pt", "ckpt", "safetensors"]: for suffix in ["pt", "ckpt", "safetensors"]:
if (model_path.with_suffix(f".vae.{suffix}")).exists(): if (model_path.with_suffix(f".vae.{suffix}")).exists():
vae_path = model_path.with_suffix(f".vae.{suffix}") vae_path = model_path.with_suffix(f".vae.{suffix}")
print(f" | Using VAE file {vae_path.name}") self.logger.debug(f"Using VAE file {vae_path.name}")
vae = None if vae_path else dict(repo_id="stabilityai/sd-vae-ft-mse") vae = None if vae_path else dict(repo_id="stabilityai/sd-vae-ft-mse")
diffuser_path = Path( diffuser_path = Path(
@ -955,14 +952,14 @@ class ModelManager(object):
from . import convert_ckpt_to_diffusers from . import convert_ckpt_to_diffusers
if diffusers_path.exists(): if diffusers_path.exists():
print( self.logger.error(
f"ERROR: The path {str(diffusers_path)} already exists. Please move or remove it and try again." f"The path {str(diffusers_path)} already exists. Please move or remove it and try again."
) )
return return
model_name = model_name or diffusers_path.name model_name = model_name or diffusers_path.name
model_description = model_description or f"Converted version of {model_name}" model_description = model_description or f"Converted version of {model_name}"
print(f" | Converting {model_name} to diffusers (30-60s)") self.logger.debug(f"Converting {model_name} to diffusers (30-60s)")
try: try:
# By passing the specified VAE to the conversion function, the autoencoder # By passing the specified VAE to the conversion function, the autoencoder
# will be built into the model rather than tacked on afterward via the config file # will be built into the model rather than tacked on afterward via the config file
@ -979,10 +976,10 @@ class ModelManager(object):
vae_path=vae_path, vae_path=vae_path,
scan_needed=scan_needed, scan_needed=scan_needed,
) )
print( self.logger.debug(
f" | Success. Converted model is now located at {str(diffusers_path)}" f"Success. Converted model is now located at {str(diffusers_path)}"
) )
print(f" | Writing new config file entry for {model_name}") self.logger.debug(f"Writing new config file entry for {model_name}")
new_config = dict( new_config = dict(
path=str(diffusers_path), path=str(diffusers_path),
description=model_description, description=model_description,
@ -993,17 +990,17 @@ class ModelManager(object):
self.add_model(model_name, new_config, True) self.add_model(model_name, new_config, True)
if commit_to_conf: if commit_to_conf:
self.commit(commit_to_conf) self.commit(commit_to_conf)
print(" | Conversion succeeded") self.logger.debug("Conversion succeeded")
except Exception as e: except Exception as e:
print(f"** Conversion failed: {str(e)}") self.logger.warning(f"Conversion failed: {str(e)}")
print( self.logger.warning(
"** If you are trying to convert an inpainting or 2.X model, please indicate the correct config file (e.g. v1-inpainting-inference.yaml)" "If you are trying to convert an inpainting or 2.X model, please indicate the correct config file (e.g. v1-inpainting-inference.yaml)"
) )
return model_name return model_name
def search_models(self, search_folder): def search_models(self, search_folder):
print(f">> Finding Models In: {search_folder}") self.logger.info(f"Finding Models In: {search_folder}")
models_folder_ckpt = Path(search_folder).glob("**/*.ckpt") models_folder_ckpt = Path(search_folder).glob("**/*.ckpt")
models_folder_safetensors = Path(search_folder).glob("**/*.safetensors") models_folder_safetensors = Path(search_folder).glob("**/*.safetensors")
@ -1027,8 +1024,8 @@ class ModelManager(object):
num_loaded_models = len(self.models) num_loaded_models = len(self.models)
if num_loaded_models >= self.max_loaded_models: if num_loaded_models >= self.max_loaded_models:
least_recent_model = self._pop_oldest_model() least_recent_model = self._pop_oldest_model()
print( self.logger.info(
f">> Cache limit (max={self.max_loaded_models}) reached. Purging {least_recent_model}" f"Cache limit (max={self.max_loaded_models}) reached. Purging {least_recent_model}"
) )
if least_recent_model is not None: if least_recent_model is not None:
del self.models[least_recent_model] del self.models[least_recent_model]
@ -1036,8 +1033,8 @@ class ModelManager(object):
def print_vram_usage(self) -> None: def print_vram_usage(self) -> None:
if self._has_cuda: if self._has_cuda:
print( self.logger.info(
">> Current VRAM usage: ", "Current VRAM usage:"+
"%4.2fG" % (torch.cuda.memory_allocated() / 1e9), "%4.2fG" % (torch.cuda.memory_allocated() / 1e9),
) )
@ -1123,10 +1120,10 @@ class ModelManager(object):
dest = hub / model.stem dest = hub / model.stem
if dest.exists() and not source.exists(): if dest.exists() and not source.exists():
continue continue
print(f"** {source} => {dest}") cls.logger.info(f"{source} => {dest}")
if source.exists(): if source.exists():
if dest.is_symlink(): if dest.is_symlink():
print(f"** Found symlink at {dest.name}. Not migrating.") logger.warning(f"Found symlink at {dest.name}. Not migrating.")
elif dest.exists(): elif dest.exists():
if source.is_dir(): if source.is_dir():
rmtree(source) rmtree(source)
@ -1143,7 +1140,7 @@ class ModelManager(object):
] ]
for d in empty: for d in empty:
os.rmdir(d) os.rmdir(d)
print("** Migration is done. Continuing...") cls.logger.info("Migration is done. Continuing...")
def _resolve_path( def _resolve_path(
self, source: Union[str, Path], dest_directory: str self, source: Union[str, Path], dest_directory: str
@ -1186,15 +1183,15 @@ class ModelManager(object):
def _add_embeddings_to_model(self, model: StableDiffusionGeneratorPipeline): def _add_embeddings_to_model(self, model: StableDiffusionGeneratorPipeline):
if self.embedding_path is not None: if self.embedding_path is not None:
print(f">> Loading embeddings from {self.embedding_path}") self.logger.info(f"Loading embeddings from {self.embedding_path}")
for root, _, files in os.walk(self.embedding_path): for root, _, files in os.walk(self.embedding_path):
for name in files: for name in files:
ti_path = os.path.join(root, name) ti_path = os.path.join(root, name)
model.textual_inversion_manager.load_textual_inversion( model.textual_inversion_manager.load_textual_inversion(
ti_path, defer_injecting_tokens=True ti_path, defer_injecting_tokens=True
) )
print( self.logger.info(
f'>> Textual inversion triggers: {", ".join(sorted(model.textual_inversion_manager.get_all_trigger_strings()))}' f'Textual inversion triggers: {", ".join(sorted(model.textual_inversion_manager.get_all_trigger_strings()))}'
) )
def _has_cuda(self) -> bool: def _has_cuda(self) -> bool:
@ -1216,7 +1213,7 @@ class ModelManager(object):
with open(hashpath) as f: with open(hashpath) as f:
hash = f.read() hash = f.read()
return hash return hash
print(" | Calculating sha256 hash of model files") self.logger.debug("Calculating sha256 hash of model files")
tic = time.time() tic = time.time()
sha = hashlib.sha256() sha = hashlib.sha256()
count = 0 count = 0
@ -1228,7 +1225,7 @@ class ModelManager(object):
sha.update(chunk) sha.update(chunk)
hash = sha.hexdigest() hash = sha.hexdigest()
toc = time.time() toc = time.time()
print(f" | sha256 = {hash} ({count} files hashed in", "%4.2fs)" % (toc - tic)) self.logger.debug(f"sha256 = {hash} ({count} files hashed in", "%4.2fs)" % (toc - tic))
with open(hashpath, "w") as f: with open(hashpath, "w") as f:
f.write(hash) f.write(hash)
return hash return hash
@ -1246,13 +1243,13 @@ class ModelManager(object):
hash = f.read() hash = f.read()
return hash return hash
print(" | Calculating sha256 hash of weights file") self.logger.debug("Calculating sha256 hash of weights file")
tic = time.time() tic = time.time()
sha = hashlib.sha256() sha = hashlib.sha256()
sha.update(data) sha.update(data)
hash = sha.hexdigest() hash = sha.hexdigest()
toc = time.time() toc = time.time()
print(f">> sha256 = {hash}", "(%4.2fs)" % (toc - tic)) self.logger.debug(f"sha256 = {hash} "+"(%4.2fs)" % (toc - tic))
with open(hashpath, "w") as f: with open(hashpath, "w") as f:
f.write(hash) f.write(hash)
@ -1273,12 +1270,12 @@ class ModelManager(object):
local_files_only=not Globals.internet_available, local_files_only=not Globals.internet_available,
) )
print(f" | Loading diffusers VAE from {name_or_path}") self.logger.debug(f"Loading diffusers VAE from {name_or_path}")
if using_fp16: if using_fp16:
vae_args.update(torch_dtype=torch.float16) vae_args.update(torch_dtype=torch.float16)
fp_args_list = [{"revision": "fp16"}, {}] fp_args_list = [{"revision": "fp16"}, {}]
else: else:
print(" | Using more accurate float32 precision") self.logger.debug("Using more accurate float32 precision")
fp_args_list = [{}] fp_args_list = [{}]
vae = None vae = None
@ -1302,12 +1299,12 @@ class ModelManager(object):
break break
if not vae and deferred_error: if not vae and deferred_error:
print(f"** Could not load VAE {name_or_path}: {str(deferred_error)}") self.logger.warning(f"Could not load VAE {name_or_path}: {str(deferred_error)}")
return vae return vae
@staticmethod @classmethod
def _delete_model_from_cache(repo_id): def _delete_model_from_cache(cls,repo_id):
cache_info = scan_cache_dir(global_cache_dir("hub")) cache_info = scan_cache_dir(global_cache_dir("hub"))
# I'm sure there is a way to do this with comprehensions # I'm sure there is a way to do this with comprehensions
@ -1318,8 +1315,8 @@ class ModelManager(object):
for revision in repo.revisions: for revision in repo.revisions:
hashes_to_delete.add(revision.commit_hash) hashes_to_delete.add(revision.commit_hash)
strategy = cache_info.delete_revisions(*hashes_to_delete) strategy = cache_info.delete_revisions(*hashes_to_delete)
print( cls.logger.warning(
f"** Deletion of this model is expected to free {strategy.expected_freed_size_str}" f"Deletion of this model is expected to free {strategy.expected_freed_size_str}"
) )
strategy.execute() strategy.execute()

17
invokeai/backend/prompting/conditioning.py
View File

@ -18,6 +18,7 @@ from compel.prompt_parser import (
PromptParser, PromptParser,
) )
import invokeai.backend.util.logging as logger
from invokeai.backend.globals import Globals from invokeai.backend.globals import Globals
from ..stable_diffusion import InvokeAIDiffuserComponent from ..stable_diffusion import InvokeAIDiffuserComponent
@ -162,8 +163,8 @@ def log_tokenization(
negative_prompt: Union[Blend, FlattenedPrompt], negative_prompt: Union[Blend, FlattenedPrompt],
tokenizer, tokenizer,
): ):
print(f"\n>> [TOKENLOG] Parsed Prompt: {positive_prompt}") logger.info(f"[TOKENLOG] Parsed Prompt: {positive_prompt}")
print(f"\n>> [TOKENLOG] Parsed Negative Prompt: {negative_prompt}") logger.info(f"[TOKENLOG] Parsed Negative Prompt: {negative_prompt}")
log_tokenization_for_prompt_object(positive_prompt, tokenizer) log_tokenization_for_prompt_object(positive_prompt, tokenizer)
log_tokenization_for_prompt_object( log_tokenization_for_prompt_object(
@ -237,12 +238,12 @@ def log_tokenization_for_text(text, tokenizer, display_label=None, truncate_if_t
usedTokens += 1 usedTokens += 1
if usedTokens > 0: if usedTokens > 0:
print(f'\n>> [TOKENLOG] Tokens {display_label or ""} ({usedTokens}):') logger.info(f'[TOKENLOG] Tokens {display_label or ""} ({usedTokens}):')
print(f"{tokenized}\x1b[0m") logger.debug(f"{tokenized}\x1b[0m")
if discarded != "": if discarded != "":
print(f"\n>> [TOKENLOG] Tokens Discarded ({totalTokens - usedTokens}):") logger.info(f"[TOKENLOG] Tokens Discarded ({totalTokens - usedTokens}):")
print(f"{discarded}\x1b[0m") logger.debug(f"{discarded}\x1b[0m")
def try_parse_legacy_blend(text: str, skip_normalize: bool = False) -> Optional[Blend]: def try_parse_legacy_blend(text: str, skip_normalize: bool = False) -> Optional[Blend]:
@ -295,8 +296,8 @@ def split_weighted_subprompts(text, skip_normalize=False) -> list:
return parsed_prompts return parsed_prompts
weight_sum = sum(map(lambda x: x[1], parsed_prompts)) weight_sum = sum(map(lambda x: x[1], parsed_prompts))
if weight_sum == 0: if weight_sum == 0:
print( logger.warning(
"* Warning: Subprompt weights add up to zero. Discarding and using even weights instead." "Subprompt weights add up to zero. Discarding and using even weights instead."
) )
equal_weight = 1 / max(len(parsed_prompts), 1) equal_weight = 1 / max(len(parsed_prompts), 1)
return [(x[0], equal_weight) for x in parsed_prompts] return [(x[0], equal_weight) for x in parsed_prompts]

12
invokeai/backend/restoration/base.py
View File

@ -1,3 +1,5 @@
import invokeai.backend.util.logging as logger
class Restoration: class Restoration:
def __init__(self) -> None: def __init__(self) -> None:
pass pass
@ -8,17 +10,17 @@ class Restoration:
# Load GFPGAN # Load GFPGAN
gfpgan = self.load_gfpgan(gfpgan_model_path) gfpgan = self.load_gfpgan(gfpgan_model_path)
if gfpgan.gfpgan_model_exists: if gfpgan.gfpgan_model_exists:
print(">> GFPGAN Initialized") logger.info("GFPGAN Initialized")
else: else:
print(">> GFPGAN Disabled") logger.info("GFPGAN Disabled")
gfpgan = None gfpgan = None
# Load CodeFormer # Load CodeFormer
codeformer = self.load_codeformer() codeformer = self.load_codeformer()
if codeformer.codeformer_model_exists: if codeformer.codeformer_model_exists:
print(">> CodeFormer Initialized") logger.info("CodeFormer Initialized")
else: else:
print(">> CodeFormer Disabled") logger.info("CodeFormer Disabled")
codeformer = None codeformer = None
return gfpgan, codeformer return gfpgan, codeformer
@ -39,5 +41,5 @@ class Restoration:
from .realesrgan import ESRGAN from .realesrgan import ESRGAN
esrgan = ESRGAN(esrgan_bg_tile) esrgan = ESRGAN(esrgan_bg_tile)
print(">> ESRGAN Initialized") logger.info("ESRGAN Initialized")
return esrgan return esrgan

7
invokeai/backend/restoration/codeformer.py
View File

@ -5,6 +5,7 @@ import warnings
import numpy as np import numpy as np
import torch import torch
import invokeai.backend.util.logging as logger
from ..globals import Globals from ..globals import Globals
pretrained_model_url = ( pretrained_model_url = (
@ -23,12 +24,12 @@ class CodeFormerRestoration:
self.codeformer_model_exists = os.path.isfile(self.model_path) self.codeformer_model_exists = os.path.isfile(self.model_path)
if not self.codeformer_model_exists: if not self.codeformer_model_exists:
print("## NOT FOUND: CodeFormer model not found at " + self.model_path) logger.error("NOT FOUND: CodeFormer model not found at " + self.model_path)
sys.path.append(os.path.abspath(codeformer_dir)) sys.path.append(os.path.abspath(codeformer_dir))
def process(self, image, strength, device, seed=None, fidelity=0.75): def process(self, image, strength, device, seed=None, fidelity=0.75):
if seed is not None: if seed is not None:
print(f">> CodeFormer - Restoring Faces for image seed:{seed}") logger.info(f"CodeFormer - Restoring Faces for image seed:{seed}")
with warnings.catch_warnings(): with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=DeprecationWarning) warnings.filterwarnings("ignore", category=DeprecationWarning)
warnings.filterwarnings("ignore", category=UserWarning) warnings.filterwarnings("ignore", category=UserWarning)
@ -97,7 +98,7 @@ class CodeFormerRestoration:
del output del output
torch.cuda.empty_cache() torch.cuda.empty_cache()
except RuntimeError as error: except RuntimeError as error:
print(f"\tFailed inference for CodeFormer: {error}.") logger.error(f"Failed inference for CodeFormer: {error}.")
restored_face = cropped_face restored_face = cropped_face
restored_face = restored_face.astype("uint8") restored_face = restored_face.astype("uint8")

14
invokeai/backend/restoration/gfpgan.py
View File

@ -6,9 +6,9 @@ import numpy as np
import torch import torch
from PIL import Image from PIL import Image
import invokeai.backend.util.logging as logger
from invokeai.backend.globals import Globals from invokeai.backend.globals import Globals
class GFPGAN: class GFPGAN:
def __init__(self, gfpgan_model_path="models/gfpgan/GFPGANv1.4.pth") -> None: def __init__(self, gfpgan_model_path="models/gfpgan/GFPGANv1.4.pth") -> None:
if not os.path.isabs(gfpgan_model_path): if not os.path.isabs(gfpgan_model_path):
@ -19,7 +19,7 @@ class GFPGAN:
self.gfpgan_model_exists = os.path.isfile(self.model_path) self.gfpgan_model_exists = os.path.isfile(self.model_path)
if not self.gfpgan_model_exists: if not self.gfpgan_model_exists:
print("## NOT FOUND: GFPGAN model not found at " + self.model_path) logger.error("NOT FOUND: GFPGAN model not found at " + self.model_path)
return None return None
def model_exists(self): def model_exists(self):
@ -27,7 +27,7 @@ class GFPGAN:
def process(self, image, strength: float, seed: str = None): def process(self, image, strength: float, seed: str = None):
if seed is not None: if seed is not None:
print(f">> GFPGAN - Restoring Faces for image seed:{seed}") logger.info(f"GFPGAN - Restoring Faces for image seed:{seed}")
with warnings.catch_warnings(): with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=DeprecationWarning) warnings.filterwarnings("ignore", category=DeprecationWarning)
@ -47,14 +47,14 @@ class GFPGAN:
except Exception: except Exception:
import traceback import traceback
print(">> Error loading GFPGAN:", file=sys.stderr) logger.error("Error loading GFPGAN:", file=sys.stderr)
print(traceback.format_exc(), file=sys.stderr) print(traceback.format_exc(), file=sys.stderr)
os.chdir(cwd) os.chdir(cwd)
if self.gfpgan is None: if self.gfpgan is None:
print(f">> WARNING: GFPGAN not initialized.") logger.warning("WARNING: GFPGAN not initialized.")
print( logger.warning(
f">> Download https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.4.pth to {self.model_path}" f"Download https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.4.pth to {self.model_path}"
) )
image = image.convert("RGB") image = image.convert("RGB")

4
invokeai/backend/restoration/outcrop.py
View File

@ -1,7 +1,7 @@
import math import math
from PIL import Image from PIL import Image
import invokeai.backend.util.logging as logger
class Outcrop(object): class Outcrop(object):
def __init__( def __init__(
@ -82,7 +82,7 @@ class Outcrop(object):
pixels = extents[direction] pixels = extents[direction]
# round pixels up to the nearest 64 # round pixels up to the nearest 64
pixels = math.ceil(pixels / 64) * 64 pixels = math.ceil(pixels / 64) * 64
print(f">> extending image {direction}ward by {pixels} pixels") logger.info(f"extending image {direction}ward by {pixels} pixels")
image = self._rotate(image, direction) image = self._rotate(image, direction)
image = self._extend(image, pixels) image = self._extend(image, pixels)
image = self._rotate(image, direction, reverse=True) image = self._rotate(image, direction, reverse=True)

15
invokeai/backend/restoration/realesrgan.py
View File

@ -6,18 +6,13 @@ import torch
from PIL import Image from PIL import Image
from PIL.Image import Image as ImageType from PIL.Image import Image as ImageType
import invokeai.backend.util.logging as logger
from invokeai.backend.globals import Globals from invokeai.backend.globals import Globals
class ESRGAN: class ESRGAN:
def __init__(self, bg_tile_size=400) -> None: def __init__(self, bg_tile_size=400) -> None:
self.bg_tile_size = bg_tile_size self.bg_tile_size = bg_tile_size
if not torch.cuda.is_available(): # CPU or MPS on M1
use_half_precision = False
else:
use_half_precision = True
def load_esrgan_bg_upsampler(self, denoise_str): def load_esrgan_bg_upsampler(self, denoise_str):
if not torch.cuda.is_available(): # CPU or MPS on M1 if not torch.cuda.is_available(): # CPU or MPS on M1
use_half_precision = False use_half_precision = False
@ -74,16 +69,16 @@ class ESRGAN:
import sys import sys
import traceback import traceback
print(">> Error loading Real-ESRGAN:", file=sys.stderr) logger.error("Error loading Real-ESRGAN:")
print(traceback.format_exc(), file=sys.stderr) print(traceback.format_exc(), file=sys.stderr)
if upsampler_scale == 0: if upsampler_scale == 0:
print(">> Real-ESRGAN: Invalid scaling option. Image not upscaled.") logger.warning("Real-ESRGAN: Invalid scaling option. Image not upscaled.")
return image return image
if seed is not None: if seed is not None:
print( logger.info(
f">> Real-ESRGAN Upscaling seed:{seed}, scale:{upsampler_scale}x, tile:{self.bg_tile_size}, denoise:{denoise_str}" f"Real-ESRGAN Upscaling seed:{seed}, scale:{upsampler_scale}x, tile:{self.bg_tile_size}, denoise:{denoise_str}"
) )
# ESRGAN outputs images with partial transparency if given RGBA images; convert to RGB # ESRGAN outputs images with partial transparency if given RGBA images; convert to RGB
image = image.convert("RGB") image = image.convert("RGB")

9
invokeai/backend/safety_checker.py
View File

@ -14,6 +14,7 @@ from PIL import Image, ImageFilter
from transformers import AutoFeatureExtractor from transformers import AutoFeatureExtractor
import invokeai.assets.web as web_assets import invokeai.assets.web as web_assets
import invokeai.backend.util.logging as logger
from .globals import global_cache_dir from .globals import global_cache_dir
from .util import CPU_DEVICE from .util import CPU_DEVICE
@ -40,8 +41,8 @@ class SafetyChecker(object):
cache_dir=safety_model_path, cache_dir=safety_model_path,
) )
except Exception: except Exception:
print( logger.error(
"** An error was encountered while installing the safety checker:" "An error was encountered while installing the safety checker:"
) )
print(traceback.format_exc()) print(traceback.format_exc())
@ -65,8 +66,8 @@ class SafetyChecker(object):
) )
self.safety_checker.to(CPU_DEVICE) # offload self.safety_checker.to(CPU_DEVICE) # offload
if has_nsfw_concept[0]: if has_nsfw_concept[0]:
print( logger.warning(
"** An image with potential non-safe content has been detected. A blurred image will be returned. **" "An image with potential non-safe content has been detected. A blurred image will be returned."
) )
return self.blur(image) return self.blur(image)
else: else:

23
invokeai/backend/stable_diffusion/concepts_lib.py
View File

@ -17,6 +17,7 @@ from huggingface_hub import (
hf_hub_url, hf_hub_url,
) )
import invokeai.backend.util.logging as logger
from invokeai.backend.globals import Globals from invokeai.backend.globals import Globals
@ -66,11 +67,11 @@ class HuggingFaceConceptsLibrary(object):
# when init, add all in dir. when not init, add only concepts added between init and now # when init, add all in dir. when not init, add only concepts added between init and now
self.concept_list.extend(list(local_concepts_to_add)) self.concept_list.extend(list(local_concepts_to_add))
except Exception as e: except Exception as e:
print( logger.warning(
f" ** WARNING: Hugging Face textual inversion concepts libraries could not be loaded. The error was {str(e)}." f"Hugging Face textual inversion concepts libraries could not be loaded. The error was {str(e)}."
) )
print( logger.warning(
" ** You may load .bin and .pt file(s) manually using the --embedding_directory argument." "You may load .bin and .pt file(s) manually using the --embedding_directory argument."
) )
return self.concept_list return self.concept_list
else: else:
@ -83,7 +84,7 @@ class HuggingFaceConceptsLibrary(object):
be downloaded. be downloaded.
""" """
if not concept_name in self.list_concepts(): if not concept_name in self.list_concepts():
print( logger.warning(
f"{concept_name} is not a local embedding trigger, nor is it a HuggingFace concept. Generation will continue without the concept." f"{concept_name} is not a local embedding trigger, nor is it a HuggingFace concept. Generation will continue without the concept."
) )
return None return None
@ -221,7 +222,7 @@ class HuggingFaceConceptsLibrary(object):
if chunk == 0: if chunk == 0:
bytes += total bytes += total
print(f">> Downloading {repo_id}...", end="") logger.info(f"Downloading {repo_id}...", end="")
try: try:
for file in ( for file in (
"README.md", "README.md",
@ -235,22 +236,22 @@ class HuggingFaceConceptsLibrary(object):
) )
except ul_error.HTTPError as e: except ul_error.HTTPError as e:
if e.code == 404: if e.code == 404:
print( logger.warning(
f"Concept {concept_name} is not known to the Hugging Face library. Generation will continue without the concept." f"Concept {concept_name} is not known to the Hugging Face library. Generation will continue without the concept."
) )
else: else:
print( logger.warning(
f"Failed to download {concept_name}/{file} ({str(e)}. Generation will continue without the concept.)" f"Failed to download {concept_name}/{file} ({str(e)}. Generation will continue without the concept.)"
) )
os.rmdir(dest) os.rmdir(dest)
return False return False
except ul_error.URLError as e: except ul_error.URLError as e:
print( logger.error(
f"ERROR while downloading {concept_name}: {str(e)}. This may reflect a network issue. Generation will continue without the concept." f"an error occurred while downloading {concept_name}: {str(e)}. This may reflect a network issue. Generation will continue without the concept."
) )
os.rmdir(dest) os.rmdir(dest)
return False return False
print("...{:.2f}Kb".format(bytes / 1024)) logger.info("...{:.2f}Kb".format(bytes / 1024))
return succeeded return succeeded
def _concept_id(self, concept_name: str) -> str: def _concept_id(self, concept_name: str) -> str:

4
invokeai/backend/stable_diffusion/diffusion/cross_attention_control.py
View File

@ -13,9 +13,9 @@ from compel.cross_attention_control import Arguments
from diffusers.models.attention_processor import AttentionProcessor from diffusers.models.attention_processor import AttentionProcessor
from torch import nn from torch import nn
import invokeai.backend.util.logging as logger
from ...util import torch_dtype from ...util import torch_dtype
class CrossAttentionType(enum.Enum): class CrossAttentionType(enum.Enum):
SELF = 1 SELF = 1
TOKENS = 2 TOKENS = 2
@ -421,7 +421,7 @@ def get_cross_attention_modules(
expected_count = 16 expected_count = 16
if cross_attention_modules_in_model_count != expected_count: if cross_attention_modules_in_model_count != expected_count:
# non-fatal error but .swap() won't work. # non-fatal error but .swap() won't work.
print( logger.error(
f"Error! CrossAttentionControl found an unexpected number of {cross_attention_class} modules in the model " f"Error! CrossAttentionControl found an unexpected number of {cross_attention_class} modules in the model "
+ f"(expected {expected_count}, found {cross_attention_modules_in_model_count}). Either monkey-patching failed " + f"(expected {expected_count}, found {cross_attention_modules_in_model_count}). Either monkey-patching failed "
+ "or some assumption has changed about the structure of the model itself. Please fix the monkey-patching, " + "or some assumption has changed about the structure of the model itself. Please fix the monkey-patching, "

21
invokeai/backend/stable_diffusion/diffusion/shared_invokeai_diffusion.py
View File

@ -8,6 +8,7 @@ import torch
from diffusers.models.attention_processor import AttentionProcessor from diffusers.models.attention_processor import AttentionProcessor
from typing_extensions import TypeAlias from typing_extensions import TypeAlias
import invokeai.backend.util.logging as logger
from invokeai.backend.globals import Globals from invokeai.backend.globals import Globals
from .cross_attention_control import ( from .cross_attention_control import (
@ -466,10 +467,14 @@ class InvokeAIDiffuserComponent:
outside = torch.count_nonzero( outside = torch.count_nonzero(
(latents < -current_threshold) | (latents > current_threshold) (latents < -current_threshold) | (latents > current_threshold)
) )
print( logger.info(
f"\nThreshold: %={percent_through} threshold={current_threshold:.3f} (of {threshold:.3f})\n" f"Threshold: %={percent_through} threshold={current_threshold:.3f} (of {threshold:.3f})"
f" | min, mean, max = {minval:.3f}, {mean:.3f}, {maxval:.3f}\tstd={std}\n" )
f" | {outside / latents.numel() * 100:.2f}% values outside threshold" logger.debug(
f"min, mean, max = {minval:.3f}, {mean:.3f}, {maxval:.3f}\tstd={std}"
)
logger.debug(
f"{outside / latents.numel() * 100:.2f}% values outside threshold"
) )
if maxval < current_threshold and minval > -current_threshold: if maxval < current_threshold and minval > -current_threshold:
@ -496,9 +501,11 @@ class InvokeAIDiffuserComponent:
) )
if self.debug_thresholding: if self.debug_thresholding:
print( logger.debug(
f" | min, , max = {minval:.3f}, , {maxval:.3f}\t(scaled by {scale})\n" f"min, , max = {minval:.3f}, , {maxval:.3f}\t(scaled by {scale})"
f" | {num_altered / latents.numel() * 100:.2f}% values altered" )
logger.debug(
f"{num_altered / latents.numel() * 100:.2f}% values altered"
) )
return latents return latents

4
invokeai/backend/stable_diffusion/image_degradation/utils_image.py
View File

@ -10,7 +10,7 @@ from torchvision.utils import make_grid
# import matplotlib.pyplot as plt # TODO: check with Dominik, also bsrgan.py vs bsrgan_light.py # import matplotlib.pyplot as plt # TODO: check with Dominik, also bsrgan.py vs bsrgan_light.py
import invokeai.backend.util.logging as logger
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE" os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
@ -191,7 +191,7 @@ def mkdirs(paths):
def mkdir_and_rename(path): def mkdir_and_rename(path):
if os.path.exists(path): if os.path.exists(path):
new_name = path + "_archived_" + get_timestamp() new_name = path + "_archived_" + get_timestamp()
print("Path already exists. Rename it to [{:s}]".format(new_name)) logger.error("Path already exists. Rename it to [{:s}]".format(new_name))
os.replace(path, new_name) os.replace(path, new_name)
os.makedirs(path) os.makedirs(path)

59
invokeai/backend/stable_diffusion/textual_inversion_manager.py
View File

@ -10,6 +10,7 @@ from compel.embeddings_provider import BaseTextualInversionManager
from picklescan.scanner import scan_file_path from picklescan.scanner import scan_file_path
from transformers import CLIPTextModel, CLIPTokenizer from transformers import CLIPTextModel, CLIPTokenizer
import invokeai.backend.util.logging as logger
from .concepts_lib import HuggingFaceConceptsLibrary from .concepts_lib import HuggingFaceConceptsLibrary
@dataclass @dataclass
@ -59,12 +60,12 @@ class TextualInversionManager(BaseTextualInversionManager):
or self.has_textual_inversion_for_trigger_string(concept_name) or self.has_textual_inversion_for_trigger_string(concept_name)
or self.has_textual_inversion_for_trigger_string(f"<{concept_name}>") or self.has_textual_inversion_for_trigger_string(f"<{concept_name}>")
): # in case a token with literal angle brackets encountered ): # in case a token with literal angle brackets encountered
print(f">> Loaded local embedding for trigger {concept_name}") logger.info(f"Loaded local embedding for trigger {concept_name}")
continue continue
bin_file = self.hf_concepts_library.get_concept_model_path(concept_name) bin_file = self.hf_concepts_library.get_concept_model_path(concept_name)
if not bin_file: if not bin_file:
continue continue
print(f">> Loaded remote embedding for trigger {concept_name}") logger.info(f"Loaded remote embedding for trigger {concept_name}")
self.load_textual_inversion(bin_file) self.load_textual_inversion(bin_file)
self.hf_concepts_library.concepts_loaded[concept_name] = True self.hf_concepts_library.concepts_loaded[concept_name] = True
@ -85,8 +86,8 @@ class TextualInversionManager(BaseTextualInversionManager):
embedding_list = self._parse_embedding(str(ckpt_path)) embedding_list = self._parse_embedding(str(ckpt_path))
for embedding_info in embedding_list: for embedding_info in embedding_list:
if (self.text_encoder.get_input_embeddings().weight.data[0].shape[0] != embedding_info.token_dim): if (self.text_encoder.get_input_embeddings().weight.data[0].shape[0] != embedding_info.token_dim):
print( logger.warning(
f" ** Notice: {ckpt_path.parents[0].name}/{ckpt_path.name} was trained on a model with an incompatible token dimension: {self.text_encoder.get_input_embeddings().weight.data[0].shape[0]} vs {embedding_info.token_dim}." f"Notice: {ckpt_path.parents[0].name}/{ckpt_path.name} was trained on a model with an incompatible token dimension: {self.text_encoder.get_input_embeddings().weight.data[0].shape[0]} vs {embedding_info.token_dim}."
) )
continue continue
@ -105,8 +106,8 @@ class TextualInversionManager(BaseTextualInversionManager):
if ckpt_path.name == "learned_embeds.bin" if ckpt_path.name == "learned_embeds.bin"
else f"<{ckpt_path.stem}>" else f"<{ckpt_path.stem}>"
) )
print( logger.info(
f">> {sourcefile}: Trigger token '{trigger_str}' is already claimed by '{self.trigger_to_sourcefile[trigger_str]}'. Trigger this concept with {replacement_trigger_str}" f"{sourcefile}: Trigger token '{trigger_str}' is already claimed by '{self.trigger_to_sourcefile[trigger_str]}'. Trigger this concept with {replacement_trigger_str}"
) )
trigger_str = replacement_trigger_str trigger_str = replacement_trigger_str
@ -120,8 +121,8 @@ class TextualInversionManager(BaseTextualInversionManager):
self.trigger_to_sourcefile[trigger_str] = sourcefile self.trigger_to_sourcefile[trigger_str] = sourcefile
except ValueError as e: except ValueError as e:
print(f' | Ignoring incompatible embedding {embedding_info["name"]}') logger.debug(f'Ignoring incompatible embedding {embedding_info["name"]}')
print(f" | The error was {str(e)}") logger.debug(f"The error was {str(e)}")
def _add_textual_inversion( def _add_textual_inversion(
self, trigger_str, embedding, defer_injecting_tokens=False self, trigger_str, embedding, defer_injecting_tokens=False
@ -133,8 +134,8 @@ class TextualInversionManager(BaseTextualInversionManager):
:return: The token id for the added embedding, either existing or newly-added. :return: The token id for the added embedding, either existing or newly-added.
""" """
if trigger_str in [ti.trigger_string for ti in self.textual_inversions]: if trigger_str in [ti.trigger_string for ti in self.textual_inversions]:
print( logger.warning(
f"** TextualInversionManager refusing to overwrite already-loaded token '{trigger_str}'" f"TextualInversionManager refusing to overwrite already-loaded token '{trigger_str}'"
) )
return return
if not self.full_precision: if not self.full_precision:
@ -155,11 +156,11 @@ class TextualInversionManager(BaseTextualInversionManager):
except ValueError as e: except ValueError as e:
if str(e).startswith("Warning"): if str(e).startswith("Warning"):
print(f">> {str(e)}") logger.warning(f"{str(e)}")
else: else:
traceback.print_exc() traceback.print_exc()
print( logger.error(
f"** TextualInversionManager was unable to add a textual inversion with trigger string {trigger_str}." f"TextualInversionManager was unable to add a textual inversion with trigger string {trigger_str}."
) )
raise raise
@ -219,16 +220,16 @@ class TextualInversionManager(BaseTextualInversionManager):
for ti in self.textual_inversions: for ti in self.textual_inversions:
if ti.trigger_token_id is None and ti.trigger_string in prompt_string: if ti.trigger_token_id is None and ti.trigger_string in prompt_string:
if ti.embedding_vector_length > 1: if ti.embedding_vector_length > 1:
print( logger.info(
f">> Preparing tokens for textual inversion {ti.trigger_string}..." f"Preparing tokens for textual inversion {ti.trigger_string}..."
) )
try: try:
self._inject_tokens_and_assign_embeddings(ti) self._inject_tokens_and_assign_embeddings(ti)
except ValueError as e: except ValueError as e:
print( logger.debug(
f" | Ignoring incompatible embedding trigger {ti.trigger_string}" f"Ignoring incompatible embedding trigger {ti.trigger_string}"
) )
print(f" | The error was {str(e)}") logger.debug(f"The error was {str(e)}")
continue continue
injected_token_ids.append(ti.trigger_token_id) injected_token_ids.append(ti.trigger_token_id)
injected_token_ids.extend(ti.pad_token_ids) injected_token_ids.extend(ti.pad_token_ids)
@ -306,16 +307,16 @@ class TextualInversionManager(BaseTextualInversionManager):
if suffix in [".pt",".ckpt",".bin"]: if suffix in [".pt",".ckpt",".bin"]:
scan_result = scan_file_path(embedding_file) scan_result = scan_file_path(embedding_file)
if scan_result.infected_files > 0: if scan_result.infected_files > 0:
print( logger.critical(
f" ** Security Issues Found in Model: {scan_result.issues_count}" f"Security Issues Found in Model: {scan_result.issues_count}"
) )
print(" ** For your safety, InvokeAI will not load this embed.") logger.critical("For your safety, InvokeAI will not load this embed.")
return list() return list()
ckpt = torch.load(embedding_file,map_location="cpu") ckpt = torch.load(embedding_file,map_location="cpu")
else: else:
ckpt = safetensors.torch.load_file(embedding_file) ckpt = safetensors.torch.load_file(embedding_file)
except Exception as e: except Exception as e:
print(f" ** Notice: unrecognized embedding file format: {embedding_file}: {e}") logger.warning(f"Notice: unrecognized embedding file format: {embedding_file}: {e}")
return list() return list()
# try to figure out what kind of embedding file it is and parse accordingly # try to figure out what kind of embedding file it is and parse accordingly
@ -334,7 +335,7 @@ class TextualInversionManager(BaseTextualInversionManager):
def _parse_embedding_v1(self, embedding_ckpt: dict, file_path: str)->List[EmbeddingInfo]: def _parse_embedding_v1(self, embedding_ckpt: dict, file_path: str)->List[EmbeddingInfo]:
basename = Path(file_path).stem basename = Path(file_path).stem
print(f' | Loading v1 embedding file: {basename}') logger.debug(f'Loading v1 embedding file: {basename}')
embeddings = list() embeddings = list()
token_counter = -1 token_counter = -1
@ -342,7 +343,7 @@ class TextualInversionManager(BaseTextualInversionManager):
if token_counter < 0: if token_counter < 0:
trigger = embedding_ckpt["name"] trigger = embedding_ckpt["name"]
elif token_counter == 0: elif token_counter == 0:
trigger = f'<basename>' trigger = '<basename>'
else: else:
trigger = f'<{basename}-{int(token_counter:=token_counter)}>' trigger = f'<{basename}-{int(token_counter:=token_counter)}>'
token_counter += 1 token_counter += 1
@ -365,7 +366,7 @@ class TextualInversionManager(BaseTextualInversionManager):
This handles embedding .pt file variant #2. This handles embedding .pt file variant #2.
""" """
basename = Path(file_path).stem basename = Path(file_path).stem
print(f' | Loading v2 embedding file: {basename}') logger.debug(f'Loading v2 embedding file: {basename}')
embeddings = list() embeddings = list()
if isinstance( if isinstance(
@ -384,7 +385,7 @@ class TextualInversionManager(BaseTextualInversionManager):
) )
embeddings.append(embedding_info) embeddings.append(embedding_info)
else: else:
print(f" ** {basename}: Unrecognized embedding format") logger.warning(f"{basename}: Unrecognized embedding format")
return embeddings return embeddings
@ -393,7 +394,7 @@ class TextualInversionManager(BaseTextualInversionManager):
Parse 'version 3' of the .pt textual inversion embedding files. Parse 'version 3' of the .pt textual inversion embedding files.
""" """
basename = Path(file_path).stem basename = Path(file_path).stem
print(f' | Loading v3 embedding file: {basename}') logger.debug(f'Loading v3 embedding file: {basename}')
embedding = embedding_ckpt['emb_params'] embedding = embedding_ckpt['emb_params']
embedding_info = EmbeddingInfo( embedding_info = EmbeddingInfo(
name = f'<{basename}>', name = f'<{basename}>',
@ -411,11 +412,11 @@ class TextualInversionManager(BaseTextualInversionManager):
basename = Path(filepath).stem basename = Path(filepath).stem
short_path = Path(filepath).parents[0].name+'/'+Path(filepath).name short_path = Path(filepath).parents[0].name+'/'+Path(filepath).name
print(f' | Loading v4 embedding file: {short_path}') logger.debug(f'Loading v4 embedding file: {short_path}')
embeddings = list() embeddings = list()
if list(embedding_ckpt.keys()) == 0: if list(embedding_ckpt.keys()) == 0:
print(f" ** Invalid embeddings file: {short_path}") logger.warning(f"Invalid embeddings file: {short_path}")
else: else:
for token,embedding in embedding_ckpt.items(): for token,embedding in embedding_ckpt.items():
embedding_info = EmbeddingInfo( embedding_info = EmbeddingInfo(

109
invokeai/backend/util/logging.py Normal file
View File

@ -0,0 +1,109 @@
# Copyright (c) 2023 Lincoln D. Stein and The InvokeAI Development Team
"""invokeai.util.logging
Logging class for InvokeAI that produces console messages that follow
the conventions established in InvokeAI 1.X through 2.X.
One way to use it:
from invokeai.backend.util.logging import InvokeAILogger
logger = InvokeAILogger.getLogger(__name__)
logger.critical('this is critical')
logger.error('this is an error')
logger.warning('this is a warning')
logger.info('this is info')
logger.debug('this is debugging')
Console messages:
### this is critical
*** this is an error ***
** this is a warning
>> this is info
| this is debugging
Another way:
import invokeai.backend.util.logging as ialog
ialogger.debug('this is a debugging message')
"""
import logging
# module level functions
def debug(msg, *args, **kwargs):
InvokeAILogger.getLogger().debug(msg, *args, **kwargs)
def info(msg, *args, **kwargs):
InvokeAILogger.getLogger().info(msg, *args, **kwargs)
def warning(msg, *args, **kwargs):
InvokeAILogger.getLogger().warning(msg, *args, **kwargs)
def error(msg, *args, **kwargs):
InvokeAILogger.getLogger().error(msg, *args, **kwargs)
def critical(msg, *args, **kwargs):
InvokeAILogger.getLogger().critical(msg, *args, **kwargs)
def log(level, msg, *args, **kwargs):
InvokeAILogger.getLogger().log(level, msg, *args, **kwargs)
def disable(level=logging.CRITICAL):
InvokeAILogger.getLogger().disable(level)
def basicConfig(**kwargs):
InvokeAILogger.getLogger().basicConfig(**kwargs)
def getLogger(name: str=None)->logging.Logger:
return InvokeAILogger.getLogger(name)
class InvokeAILogFormatter(logging.Formatter):
'''
Repurposed from:
https://stackoverflow.com/questions/14844970/modifying-logging-message-format-based-on-message-logging-level-in-python3
'''
crit_fmt = "### %(msg)s"
err_fmt = "*** %(msg)s"
warn_fmt = "** %(msg)s"
info_fmt = ">> %(msg)s"
dbg_fmt = " | %(msg)s"
def __init__(self):
super().__init__(fmt="%(levelno)d: %(msg)s", datefmt=None, style='%')
def format(self, record):
# Remember the format used when the logging module
# was installed (in the event that this formatter is
# used with the vanilla logging module.
format_orig = self._style._fmt
if record.levelno == logging.DEBUG:
self._style._fmt = InvokeAILogFormatter.dbg_fmt
if record.levelno == logging.INFO:
self._style._fmt = InvokeAILogFormatter.info_fmt
if record.levelno == logging.WARNING:
self._style._fmt = InvokeAILogFormatter.warn_fmt
if record.levelno == logging.ERROR:
self._style._fmt = InvokeAILogFormatter.err_fmt
if record.levelno == logging.CRITICAL:
self._style._fmt = InvokeAILogFormatter.crit_fmt
# parent class does the work
result = super().format(record)
self._style._fmt = format_orig
return result
class InvokeAILogger(object):
loggers = dict()
@classmethod
def getLogger(self, name:str='invokeai')->logging.Logger:
if name not in self.loggers:
logger = logging.getLogger(name)
logger.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
fmt = InvokeAILogFormatter()
ch.setFormatter(fmt)
logger.addHandler(ch)
self.loggers[name] = logger
return self.loggers[name]

31
invokeai/backend/util/util.py
View File

@ -18,6 +18,7 @@ import torch
from PIL import Image, ImageDraw, ImageFont from PIL import Image, ImageDraw, ImageFont
from tqdm import tqdm from tqdm import tqdm
import invokeai.backend.util.logging as logger
from .devices import torch_dtype from .devices import torch_dtype
@ -38,7 +39,7 @@ def log_txt_as_img(wh, xc, size=10):
try: try:
draw.text((0, 0), lines, fill="black", font=font) draw.text((0, 0), lines, fill="black", font=font)
except UnicodeEncodeError: except UnicodeEncodeError:
print("Cant encode string for logging. Skipping.") logger.warning("Cant encode string for logging. Skipping.")
txt = np.array(txt).transpose(2, 0, 1) / 127.5 - 1.0 txt = np.array(txt).transpose(2, 0, 1) / 127.5 - 1.0
txts.append(txt) txts.append(txt)
@ -80,8 +81,8 @@ def mean_flat(tensor):
def count_params(model, verbose=False): def count_params(model, verbose=False):
total_params = sum(p.numel() for p in model.parameters()) total_params = sum(p.numel() for p in model.parameters())
if verbose: if verbose:
print( logger.debug(
f" | {model.__class__.__name__} has {total_params * 1.e-6:.2f} M params." f"{model.__class__.__name__} has {total_params * 1.e-6:.2f} M params."
) )
return total_params return total_params
@ -132,8 +133,8 @@ def parallel_data_prefetch(
raise ValueError("list expected but function got ndarray.") raise ValueError("list expected but function got ndarray.")
elif isinstance(data, abc.Iterable): elif isinstance(data, abc.Iterable):
if isinstance(data, dict): if isinstance(data, dict):
print( logger.warning(
'WARNING:"data" argument passed to parallel_data_prefetch is a dict: Using only its values and disregarding keys.' '"data" argument passed to parallel_data_prefetch is a dict: Using only its values and disregarding keys.'
) )
data = list(data.values()) data = list(data.values())
if target_data_type == "ndarray": if target_data_type == "ndarray":
@ -175,7 +176,7 @@ def parallel_data_prefetch(
processes += [p] processes += [p]
# start processes # start processes
print("Start prefetching...") logger.info("Start prefetching...")
import time import time
start = time.time() start = time.time()
@ -194,7 +195,7 @@ def parallel_data_prefetch(
gather_res[res[0]] = res[1] gather_res[res[0]] = res[1]
except Exception as e: except Exception as e:
print("Exception: ", e) logger.error("Exception: ", e)
for p in processes: for p in processes:
p.terminate() p.terminate()
@ -202,7 +203,7 @@ def parallel_data_prefetch(
finally: finally:
for p in processes: for p in processes:
p.join() p.join()
print(f"Prefetching complete. [{time.time() - start} sec.]") logger.info(f"Prefetching complete. [{time.time() - start} sec.]")
if target_data_type == "ndarray": if target_data_type == "ndarray":
if not isinstance(gather_res[0], np.ndarray): if not isinstance(gather_res[0], np.ndarray):
@ -318,23 +319,23 @@ def download_with_resume(url: str, dest: Path, access_token: str = None) -> Path
resp = requests.get(url, headers=header, stream=True) # new request with range resp = requests.get(url, headers=header, stream=True) # new request with range
if exist_size > content_length: if exist_size > content_length:
print("* corrupt existing file found. re-downloading") logger.warning("corrupt existing file found. re-downloading")
os.remove(dest) os.remove(dest)
exist_size = 0 exist_size = 0
if resp.status_code == 416 or exist_size == content_length: if resp.status_code == 416 or exist_size == content_length:
print(f"* {dest}: complete file found. Skipping.") logger.warning(f"{dest}: complete file found. Skipping.")
return dest return dest
elif resp.status_code == 206 or exist_size > 0: elif resp.status_code == 206 or exist_size > 0:
print(f"* {dest}: partial file found. Resuming...") logger.warning(f"{dest}: partial file found. Resuming...")
elif resp.status_code != 200: elif resp.status_code != 200:
print(f"** An error occurred during downloading {dest}: {resp.reason}") logger.error(f"An error occurred during downloading {dest}: {resp.reason}")
else: else:
print(f"* {dest}: Downloading...") logger.error(f"{dest}: Downloading...")
try: try:
if content_length < 2000: if content_length < 2000:
print(f"*** ERROR DOWNLOADING {url}: {resp.text}") logger.error(f"ERROR DOWNLOADING {url}: {resp.text}")
return None return None
with open(dest, open_mode) as file, tqdm( with open(dest, open_mode) as file, tqdm(
@ -349,7 +350,7 @@ def download_with_resume(url: str, dest: Path, access_token: str = None) -> Path
size = file.write(data) size = file.write(data)
bar.update(size) bar.update(size)
except Exception as e: except Exception as e:
print(f"An error occurred while downloading {dest}: {str(e)}") logger.error(f"An error occurred while downloading {dest}: {str(e)}")
return None return None
return dest return dest

57
invokeai/backend/web/invoke_ai_web_server.py
View File

@ -19,6 +19,7 @@ from PIL import Image
from PIL.Image import Image as ImageType from PIL.Image import Image as ImageType
from werkzeug.utils import secure_filename from werkzeug.utils import secure_filename
import invokeai.backend.util.logging as logger
import invokeai.frontend.web.dist as frontend import invokeai.frontend.web.dist as frontend
from .. import Generate from .. import Generate
@ -213,7 +214,7 @@ class InvokeAIWebServer:
self.load_socketio_listeners(self.socketio) self.load_socketio_listeners(self.socketio)
if args.gui: if args.gui:
print(">> Launching Invoke AI GUI") logger.info("Launching Invoke AI GUI")
try: try:
from flaskwebgui import FlaskUI from flaskwebgui import FlaskUI
@ -231,17 +232,17 @@ class InvokeAIWebServer:
sys.exit(0) sys.exit(0)
else: else:
useSSL = args.certfile or args.keyfile useSSL = args.certfile or args.keyfile
print(">> Started Invoke AI Web Server") logger.info("Started Invoke AI Web Server")
if self.host == "0.0.0.0": if self.host == "0.0.0.0":
print( logger.info(
f"Point your browser at http{'s' if useSSL else ''}://localhost:{self.port} or use the host's DNS name or IP address." f"Point your browser at http{'s' if useSSL else ''}://localhost:{self.port} or use the host's DNS name or IP address."
) )
else: else:
print( logger.info(
">> Default host address now 127.0.0.1 (localhost). Use --host 0.0.0.0 to bind any address." "Default host address now 127.0.0.1 (localhost). Use --host 0.0.0.0 to bind any address."
) )
print( logger.info(
f">> Point your browser at http{'s' if useSSL else ''}://{self.host}:{self.port}" f"Point your browser at http{'s' if useSSL else ''}://{self.host}:{self.port}"
) )
if not useSSL: if not useSSL:
self.socketio.run(app=self.app, host=self.host, port=self.port) self.socketio.run(app=self.app, host=self.host, port=self.port)
@ -273,7 +274,7 @@ class InvokeAIWebServer:
# path for thumbnail images # path for thumbnail images
self.thumbnail_image_path = os.path.join(self.result_path, "thumbnails/") self.thumbnail_image_path = os.path.join(self.result_path, "thumbnails/")
# txt log # txt log
self.log_path = os.path.join(self.result_path, "invoke_log.txt") self.log_path = os.path.join(self.result_path, "invoke_logger.txt")
# make all output paths # make all output paths
[ [
os.makedirs(path, exist_ok=True) os.makedirs(path, exist_ok=True)
@ -290,7 +291,7 @@ class InvokeAIWebServer:
def load_socketio_listeners(self, socketio): def load_socketio_listeners(self, socketio):
@socketio.on("requestSystemConfig") @socketio.on("requestSystemConfig")
def handle_request_capabilities(): def handle_request_capabilities():
print(">> System config requested") logger.info("System config requested")
config = self.get_system_config() config = self.get_system_config()
config["model_list"] = self.generate.model_manager.list_models() config["model_list"] = self.generate.model_manager.list_models()
config["infill_methods"] = infill_methods() config["infill_methods"] = infill_methods()
@ -330,7 +331,7 @@ class InvokeAIWebServer:
if model_name in current_model_list: if model_name in current_model_list:
update = True update = True
print(f">> Adding New Model: {model_name}") logger.info(f"Adding New Model: {model_name}")
self.generate.model_manager.add_model( self.generate.model_manager.add_model(
model_name=model_name, model_name=model_name,
@ -348,14 +349,14 @@ class InvokeAIWebServer:
"update": update, "update": update,
}, },
) )
print(f">> New Model Added: {model_name}") logger.info(f"New Model Added: {model_name}")
except Exception as e: except Exception as e:
self.handle_exceptions(e) self.handle_exceptions(e)
@socketio.on("deleteModel") @socketio.on("deleteModel")
def handle_delete_model(model_name: str): def handle_delete_model(model_name: str):
try: try:
print(f">> Deleting Model: {model_name}") logger.info(f"Deleting Model: {model_name}")
self.generate.model_manager.del_model(model_name) self.generate.model_manager.del_model(model_name)
self.generate.model_manager.commit(opt.conf) self.generate.model_manager.commit(opt.conf)
updated_model_list = self.generate.model_manager.list_models() updated_model_list = self.generate.model_manager.list_models()
@ -366,14 +367,14 @@ class InvokeAIWebServer:
"model_list": updated_model_list, "model_list": updated_model_list,
}, },
) )
print(f">> Model Deleted: {model_name}") logger.info(f"Model Deleted: {model_name}")
except Exception as e: except Exception as e:
self.handle_exceptions(e) self.handle_exceptions(e)
@socketio.on("requestModelChange") @socketio.on("requestModelChange")
def handle_set_model(model_name: str): def handle_set_model(model_name: str):
try: try:
print(f">> Model change requested: {model_name}") logger.info(f"Model change requested: {model_name}")
model = self.generate.set_model(model_name) model = self.generate.set_model(model_name)
model_list = self.generate.model_manager.list_models() model_list = self.generate.model_manager.list_models()
if model is None: if model is None:
@ -454,7 +455,7 @@ class InvokeAIWebServer:
"update": True, "update": True,
}, },
) )
print(f">> Model Converted: {model_name}") logger.info(f"Model Converted: {model_name}")
except Exception as e: except Exception as e:
self.handle_exceptions(e) self.handle_exceptions(e)
@ -490,7 +491,7 @@ class InvokeAIWebServer:
if vae := self.generate.model_manager.config[models_to_merge[0]].get( if vae := self.generate.model_manager.config[models_to_merge[0]].get(
"vae", None "vae", None
): ):
print(f">> Using configured VAE assigned to {models_to_merge[0]}") logger.info(f"Using configured VAE assigned to {models_to_merge[0]}")
merged_model_config.update(vae=vae) merged_model_config.update(vae=vae)
self.generate.model_manager.import_diffuser_model( self.generate.model_manager.import_diffuser_model(
@ -507,8 +508,8 @@ class InvokeAIWebServer:
"update": True, "update": True,
}, },
) )
print(f">> Models Merged: {models_to_merge}") logger.info(f"Models Merged: {models_to_merge}")
print(f">> New Model Added: {model_merge_info['merged_model_name']}") logger.info(f"New Model Added: {model_merge_info['merged_model_name']}")
except Exception as e: except Exception as e:
self.handle_exceptions(e) self.handle_exceptions(e)
@ -698,7 +699,7 @@ class InvokeAIWebServer:
} }
) )
except Exception as e: except Exception as e:
print(f">> Unable to load {path}") logger.info(f"Unable to load {path}")
socketio.emit( socketio.emit(
"error", {"message": f"Unable to load {path}: {str(e)}"} "error", {"message": f"Unable to load {path}: {str(e)}"}
) )
@ -735,9 +736,9 @@ class InvokeAIWebServer:
printable_parameters["init_mask"][:64] + "..." printable_parameters["init_mask"][:64] + "..."
) )
print(f"\n>> Image Generation Parameters:\n\n{printable_parameters}\n") logger.info(f"Image Generation Parameters:\n\n{printable_parameters}\n")
print(f">> ESRGAN Parameters: {esrgan_parameters}") logger.info(f"ESRGAN Parameters: {esrgan_parameters}")
print(f">> Facetool Parameters: {facetool_parameters}") logger.info(f"Facetool Parameters: {facetool_parameters}")
self.generate_images( self.generate_images(
generation_parameters, generation_parameters,
@ -750,8 +751,8 @@ class InvokeAIWebServer:
@socketio.on("runPostprocessing") @socketio.on("runPostprocessing")
def handle_run_postprocessing(original_image, postprocessing_parameters): def handle_run_postprocessing(original_image, postprocessing_parameters):
try: try:
print( logger.info(
f'>> Postprocessing requested for "{original_image["url"]}": {postprocessing_parameters}' f'Postprocessing requested for "{original_image["url"]}": {postprocessing_parameters}'
) )
progress = Progress() progress = Progress()
@ -861,14 +862,14 @@ class InvokeAIWebServer:
@socketio.on("cancel") @socketio.on("cancel")
def handle_cancel(): def handle_cancel():
print(">> Cancel processing requested") logger.info("Cancel processing requested")
self.canceled.set() self.canceled.set()
# TODO: I think this needs a safety mechanism. # TODO: I think this needs a safety mechanism.
@socketio.on("deleteImage") @socketio.on("deleteImage")
def handle_delete_image(url, thumbnail, uuid, category): def handle_delete_image(url, thumbnail, uuid, category):
try: try:
print(f'>> Delete requested "{url}"') logger.info(f'Delete requested "{url}"')
from send2trash import send2trash from send2trash import send2trash
path = self.get_image_path_from_url(url) path = self.get_image_path_from_url(url)
@ -1263,7 +1264,7 @@ class InvokeAIWebServer:
image, os.path.basename(path), self.thumbnail_image_path image, os.path.basename(path), self.thumbnail_image_path
) )
print(f'\n\n>> Image generated: "{path}"\n') logger.info(f'Image generated: "{path}"\n')
self.write_log_message(f'[Generated] "{path}": {command}') self.write_log_message(f'[Generated] "{path}": {command}')
if progress.total_iterations > progress.current_iteration: if progress.total_iterations > progress.current_iteration:
@ -1329,7 +1330,7 @@ class InvokeAIWebServer:
except Exception as e: except Exception as e:
# Clear the CUDA cache on an exception # Clear the CUDA cache on an exception
self.empty_cuda_cache() self.empty_cuda_cache()
print(e) logger.error(e)
self.handle_exceptions(e) self.handle_exceptions(e)
def empty_cuda_cache(self): def empty_cuda_cache(self):

158
invokeai/frontend/CLI/CLI.py
View File

@ -16,6 +16,7 @@ if sys.platform == "darwin":
import pyparsing # type: ignore import pyparsing # type: ignore
import invokeai.version as invokeai import invokeai.version as invokeai
import invokeai.backend.util.logging as logger
from ...backend import Generate, ModelManager from ...backend import Generate, ModelManager
from ...backend.args import Args, dream_cmd_from_png, metadata_dumps, metadata_from_png from ...backend.args import Args, dream_cmd_from_png, metadata_dumps, metadata_from_png
@ -69,7 +70,7 @@ def main():
# run any post-install patches needed # run any post-install patches needed
run_patches() run_patches()
print(f">> Internet connectivity is {Globals.internet_available}") logger.info(f"Internet connectivity is {Globals.internet_available}")
if not args.conf: if not args.conf:
config_file = os.path.join(Globals.root, "configs", "models.yaml") config_file = os.path.join(Globals.root, "configs", "models.yaml")
@ -78,8 +79,8 @@ def main():
opt, FileNotFoundError(f"The file {config_file} could not be found.") opt, FileNotFoundError(f"The file {config_file} could not be found.")
) )
print(f">> {invokeai.__app_name__}, version {invokeai.__version__}") logger.info(f"{invokeai.__app_name__}, version {invokeai.__version__}")
print(f'>> InvokeAI runtime directory is "{Globals.root}"') logger.info(f'InvokeAI runtime directory is "{Globals.root}"')
# loading here to avoid long delays on startup # loading here to avoid long delays on startup
# these two lines prevent a horrible warning message from appearing # these two lines prevent a horrible warning message from appearing
@ -121,7 +122,7 @@ def main():
else: else:
raise FileNotFoundError(f"{opt.infile} not found.") raise FileNotFoundError(f"{opt.infile} not found.")
except (FileNotFoundError, IOError) as e: except (FileNotFoundError, IOError) as e:
print(f"{e}. Aborting.") logger.critical('Aborted',exc_info=True)
sys.exit(-1) sys.exit(-1)
# creating a Generate object: # creating a Generate object:
@ -142,12 +143,12 @@ def main():
) )
except (FileNotFoundError, TypeError, AssertionError) as e: except (FileNotFoundError, TypeError, AssertionError) as e:
report_model_error(opt, e) report_model_error(opt, e)
except (IOError, KeyError) as e: except (IOError, KeyError):
print(f"{e}. Aborting.") logger.critical("Aborted",exc_info=True)
sys.exit(-1) sys.exit(-1)
if opt.seamless: if opt.seamless:
print(">> changed to seamless tiling mode") logger.info("Changed to seamless tiling mode")
# preload the model # preload the model
try: try:
@ -180,9 +181,7 @@ def main():
f'\nGoodbye!\nYou can start InvokeAI again by running the "invoke.bat" (or "invoke.sh") script from {Globals.root}' f'\nGoodbye!\nYou can start InvokeAI again by running the "invoke.bat" (or "invoke.sh") script from {Globals.root}'
) )
except Exception: except Exception:
print(">> An error occurred:") logger.error("An error occurred",exc_info=True)
traceback.print_exc()
# TODO: main_loop() has gotten busy. Needs to be refactored. # TODO: main_loop() has gotten busy. Needs to be refactored.
def main_loop(gen, opt): def main_loop(gen, opt):
@ -248,7 +247,7 @@ def main_loop(gen, opt):
if not opt.prompt: if not opt.prompt:
oldargs = metadata_from_png(opt.init_img) oldargs = metadata_from_png(opt.init_img)
opt.prompt = oldargs.prompt opt.prompt = oldargs.prompt
print(f'>> Retrieved old prompt "{opt.prompt}" from {opt.init_img}') logger.info(f'Retrieved old prompt "{opt.prompt}" from {opt.init_img}')
except (OSError, AttributeError, KeyError): except (OSError, AttributeError, KeyError):
pass pass
@ -265,9 +264,9 @@ def main_loop(gen, opt):
if opt.init_img is not None and re.match("^-\\d+$", opt.init_img): if opt.init_img is not None and re.match("^-\\d+$", opt.init_img):
try: try:
opt.init_img = last_results[int(opt.init_img)][0] opt.init_img = last_results[int(opt.init_img)][0]
print(f">> Reusing previous image {opt.init_img}") logger.info(f"Reusing previous image {opt.init_img}")
except IndexError: except IndexError:
print(f">> No previous initial image at position {opt.init_img} found") logger.info(f"No previous initial image at position {opt.init_img} found")
opt.init_img = None opt.init_img = None
continue continue
@ -288,9 +287,9 @@ def main_loop(gen, opt):
if opt.seed is not None and opt.seed < 0 and operation != "postprocess": if opt.seed is not None and opt.seed < 0 and operation != "postprocess":
try: try:
opt.seed = last_results[opt.seed][1] opt.seed = last_results[opt.seed][1]
print(f">> Reusing previous seed {opt.seed}") logger.info(f"Reusing previous seed {opt.seed}")
except IndexError: except IndexError:
print(f">> No previous seed at position {opt.seed} found") logger.info(f"No previous seed at position {opt.seed} found")
opt.seed = None opt.seed = None
continue continue
@ -309,7 +308,7 @@ def main_loop(gen, opt):
subdir = subdir[: (path_max - 39 - len(os.path.abspath(opt.outdir)))] subdir = subdir[: (path_max - 39 - len(os.path.abspath(opt.outdir)))]
current_outdir = os.path.join(opt.outdir, subdir) current_outdir = os.path.join(opt.outdir, subdir)
print('Writing files to directory: "' + current_outdir + '"') logger.info('Writing files to directory: "' + current_outdir + '"')
# make sure the output directory exists # make sure the output directory exists
if not os.path.exists(current_outdir): if not os.path.exists(current_outdir):
@ -438,15 +437,14 @@ def main_loop(gen, opt):
catch_interrupts=catch_ctrl_c, catch_interrupts=catch_ctrl_c,
**vars(opt), **vars(opt),
) )
except (PromptParser.ParsingException, pyparsing.ParseException) as e: except (PromptParser.ParsingException, pyparsing.ParseException):
print("** An error occurred while processing your prompt **") logger.error("An error occurred while processing your prompt",exc_info=True)
print(f"** {str(e)} **")
elif operation == "postprocess": elif operation == "postprocess":
print(f">> fixing {opt.prompt}") logger.info(f"fixing {opt.prompt}")
opt.last_operation = do_postprocess(gen, opt, image_writer) opt.last_operation = do_postprocess(gen, opt, image_writer)
elif operation == "mask": elif operation == "mask":
print(f">> generating masks from {opt.prompt}") logger.info(f"generating masks from {opt.prompt}")
do_textmask(gen, opt, image_writer) do_textmask(gen, opt, image_writer)
if opt.grid and len(grid_images) > 0: if opt.grid and len(grid_images) > 0:
@ -469,12 +467,12 @@ def main_loop(gen, opt):
) )
results = [[path, formatted_dream_prompt]] results = [[path, formatted_dream_prompt]]
except AssertionError as e: except AssertionError:
print(e) logger.error(e)
continue continue
except OSError as e: except OSError as e:
print(e) logger.error(e)
continue continue
print("Outputs:") print("Outputs:")
@ -513,7 +511,7 @@ def do_command(command: str, gen, opt: Args, completer) -> tuple:
gen.set_model(model_name) gen.set_model(model_name)
add_embedding_terms(gen, completer) add_embedding_terms(gen, completer)
except KeyError as e: except KeyError as e:
print(str(e)) logger.error(e)
except Exception as e: except Exception as e:
report_model_error(opt, e) report_model_error(opt, e)
completer.add_history(command) completer.add_history(command)
@ -527,8 +525,8 @@ def do_command(command: str, gen, opt: Args, completer) -> tuple:
elif command.startswith("!import"): elif command.startswith("!import"):
path = shlex.split(command) path = shlex.split(command)
if len(path) < 2: if len(path) < 2:
print( logger.warning(
"** please provide (1) a URL to a .ckpt file to import; (2) a local path to a .ckpt file; or (3) a diffusers repository id in the form stabilityai/stable-diffusion-2-1" "please provide (1) a URL to a .ckpt file to import; (2) a local path to a .ckpt file; or (3) a diffusers repository id in the form stabilityai/stable-diffusion-2-1"
) )
else: else:
try: try:
@ -541,7 +539,7 @@ def do_command(command: str, gen, opt: Args, completer) -> tuple:
elif command.startswith(("!convert", "!optimize")): elif command.startswith(("!convert", "!optimize")):
path = shlex.split(command) path = shlex.split(command)
if len(path) < 2: if len(path) < 2:
print("** please provide the path to a .ckpt or .safetensors model") logger.warning("please provide the path to a .ckpt or .safetensors model")
else: else:
try: try:
convert_model(path[1], gen, opt, completer) convert_model(path[1], gen, opt, completer)
@ -553,7 +551,7 @@ def do_command(command: str, gen, opt: Args, completer) -> tuple:
elif command.startswith("!edit"): elif command.startswith("!edit"):
path = shlex.split(command) path = shlex.split(command)
if len(path) < 2: if len(path) < 2:
print("** please provide the name of a model") logger.warning("please provide the name of a model")
else: else:
edit_model(path[1], gen, opt, completer) edit_model(path[1], gen, opt, completer)
completer.add_history(command) completer.add_history(command)
@ -562,7 +560,7 @@ def do_command(command: str, gen, opt: Args, completer) -> tuple:
elif command.startswith("!del"): elif command.startswith("!del"):
path = shlex.split(command) path = shlex.split(command)
if len(path) < 2: if len(path) < 2:
print("** please provide the name of a model") logger.warning("please provide the name of a model")
else: else:
del_config(path[1], gen, opt, completer) del_config(path[1], gen, opt, completer)
completer.add_history(command) completer.add_history(command)
@ -642,8 +640,8 @@ def import_model(model_path: str, gen, opt, completer):
try: try:
default_name = url_attachment_name(model_path) default_name = url_attachment_name(model_path)
default_name = Path(default_name).stem default_name = Path(default_name).stem
except Exception as e: except Exception:
print(f"** URL: {str(e)}") logger.warning(f"A problem occurred while assigning the name of the downloaded model",exc_info=True)
model_name, model_desc = _get_model_name_and_desc( model_name, model_desc = _get_model_name_and_desc(
gen.model_manager, gen.model_manager,
completer, completer,
@ -664,11 +662,11 @@ def import_model(model_path: str, gen, opt, completer):
model_config_file=config_file, model_config_file=config_file,
) )
if not imported_name: if not imported_name:
print("** Aborting import.") logger.error("Aborting import.")
return return
if not _verify_load(imported_name, gen): if not _verify_load(imported_name, gen):
print("** model failed to load. Discarding configuration entry") logger.error("model failed to load. Discarding configuration entry")
gen.model_manager.del_model(imported_name) gen.model_manager.del_model(imported_name)
return return
if click.confirm("Make this the default model?", default=False): if click.confirm("Make this the default model?", default=False):
@ -676,7 +674,7 @@ def import_model(model_path: str, gen, opt, completer):
gen.model_manager.commit(opt.conf) gen.model_manager.commit(opt.conf)
completer.update_models(gen.model_manager.list_models()) completer.update_models(gen.model_manager.list_models())
print(f">> {imported_name} successfully installed") logger.info(f"{imported_name} successfully installed")
def _pick_configuration_file(completer)->Path: def _pick_configuration_file(completer)->Path:
print( print(
@ -720,21 +718,21 @@ Please select the type of this model:
return choice return choice
def _verify_load(model_name: str, gen) -> bool: def _verify_load(model_name: str, gen) -> bool:
print(">> Verifying that new model loads...") logger.info("Verifying that new model loads...")
current_model = gen.model_name current_model = gen.model_name
try: try:
if not gen.set_model(model_name): if not gen.set_model(model_name):
return return
except Exception as e: except Exception as e:
print(f"** model failed to load: {str(e)}") logger.warning(f"model failed to load: {str(e)}")
print( logger.warning(
"** note that importing 2.X checkpoints is not supported. Please use !convert_model instead." "** note that importing 2.X checkpoints is not supported. Please use !convert_model instead."
) )
return False return False
if click.confirm("Keep model loaded?", default=True): if click.confirm("Keep model loaded?", default=True):
gen.set_model(model_name) gen.set_model(model_name)
else: else:
print(">> Restoring previous model") logger.info("Restoring previous model")
gen.set_model(current_model) gen.set_model(current_model)
return True return True
@ -757,7 +755,7 @@ def convert_model(model_name_or_path: Union[Path, str], gen, opt, completer):
ckpt_path = None ckpt_path = None
original_config_file = None original_config_file = None
if model_name_or_path == gen.model_name: if model_name_or_path == gen.model_name:
print("** Can't convert the active model. !switch to another model first. **") logger.warning("Can't convert the active model. !switch to another model first. **")
return return
elif model_info := manager.model_info(model_name_or_path): elif model_info := manager.model_info(model_name_or_path):
if "weights" in model_info: if "weights" in model_info:
@ -767,7 +765,7 @@ def convert_model(model_name_or_path: Union[Path, str], gen, opt, completer):
model_description = model_info["description"] model_description = model_info["description"]
vae_path = model_info.get("vae") vae_path = model_info.get("vae")
else: else:
print(f"** {model_name_or_path} is not a legacy .ckpt weights file") logger.warning(f"{model_name_or_path} is not a legacy .ckpt weights file")
return return
model_name = manager.convert_and_import( model_name = manager.convert_and_import(
ckpt_path, ckpt_path,
@ -788,16 +786,16 @@ def convert_model(model_name_or_path: Union[Path, str], gen, opt, completer):
manager.commit(opt.conf) manager.commit(opt.conf)
if click.confirm(f"Delete the original .ckpt file at {ckpt_path}?", default=False): if click.confirm(f"Delete the original .ckpt file at {ckpt_path}?", default=False):
ckpt_path.unlink(missing_ok=True) ckpt_path.unlink(missing_ok=True)
print(f"{ckpt_path} deleted") logger.warning(f"{ckpt_path} deleted")
def del_config(model_name: str, gen, opt, completer): def del_config(model_name: str, gen, opt, completer):
current_model = gen.model_name current_model = gen.model_name
if model_name == current_model: if model_name == current_model:
print("** Can't delete active model. !switch to another model first. **") logger.warning("Can't delete active model. !switch to another model first. **")
return return
if model_name not in gen.model_manager.config: if model_name not in gen.model_manager.config:
print(f"** Unknown model {model_name}") logger.warning(f"Unknown model {model_name}")
return return
if not click.confirm( if not click.confirm(
@ -810,17 +808,17 @@ def del_config(model_name: str, gen, opt, completer):
) )
gen.model_manager.del_model(model_name, delete_files=delete_completely) gen.model_manager.del_model(model_name, delete_files=delete_completely)
gen.model_manager.commit(opt.conf) gen.model_manager.commit(opt.conf)
print(f"** {model_name} deleted") logger.warning(f"{model_name} deleted")
completer.update_models(gen.model_manager.list_models()) completer.update_models(gen.model_manager.list_models())
def edit_model(model_name: str, gen, opt, completer): def edit_model(model_name: str, gen, opt, completer):
manager = gen.model_manager manager = gen.model_manager
if not (info := manager.model_info(model_name)): if not (info := manager.model_info(model_name)):
print(f"** Unknown model {model_name}") logger.warning(f"** Unknown model {model_name}")
return return
print()
print(f"\n>> Editing model {model_name} from configuration file {opt.conf}") logger.info(f"Editing model {model_name} from configuration file {opt.conf}")
new_name = _get_model_name(manager.list_models(), completer, model_name) new_name = _get_model_name(manager.list_models(), completer, model_name)
for attribute in info.keys(): for attribute in info.keys():
@ -858,7 +856,7 @@ def edit_model(model_name: str, gen, opt, completer):
manager.set_default_model(new_name) manager.set_default_model(new_name)
manager.commit(opt.conf) manager.commit(opt.conf)
completer.update_models(manager.list_models()) completer.update_models(manager.list_models())
print(">> Model successfully updated") logger.info("Model successfully updated")
def _get_model_name(existing_names, completer, default_name: str = "") -> str: def _get_model_name(existing_names, completer, default_name: str = "") -> str:
@ -869,11 +867,11 @@ def _get_model_name(existing_names, completer, default_name: str = "") -> str:
if len(model_name) == 0: if len(model_name) == 0:
model_name = default_name model_name = default_name
if not re.match("^[\w._+:/-]+$", model_name): if not re.match("^[\w._+:/-]+$", model_name):
print( logger.warning(
'** model name must contain only words, digits and the characters "._+:/-" **' 'model name must contain only words, digits and the characters "._+:/-" **'
) )
elif model_name != default_name and model_name in existing_names: elif model_name != default_name and model_name in existing_names:
print(f"** the name {model_name} is already in use. Pick another.") logger.warning(f"the name {model_name} is already in use. Pick another.")
else: else:
done = True done = True
return model_name return model_name
@ -940,11 +938,10 @@ def do_postprocess(gen, opt, callback):
opt=opt, opt=opt,
) )
except OSError: except OSError:
print(traceback.format_exc(), file=sys.stderr) logger.error(f"{file_path}: file could not be read",exc_info=True)
print(f"** {file_path}: file could not be read")
return return
except (KeyError, AttributeError): except (KeyError, AttributeError):
print(traceback.format_exc(), file=sys.stderr) logger.error(f"an error occurred while applying the {tool} postprocessor",exc_info=True)
return return
return opt.last_operation return opt.last_operation
@ -999,13 +996,13 @@ def prepare_image_metadata(
try: try:
filename = opt.fnformat.format(**wildcards) filename = opt.fnformat.format(**wildcards)
except KeyError as e: except KeyError as e:
print( logger.error(
f"** The filename format contains an unknown key '{e.args[0]}'. Will use {{prefix}}.{{seed}}.png' instead" f"The filename format contains an unknown key '{e.args[0]}'. Will use {{prefix}}.{{seed}}.png' instead"
) )
filename = f"{prefix}.{seed}.png" filename = f"{prefix}.{seed}.png"
except IndexError: except IndexError:
print( logger.error(
"** The filename format is broken or complete. Will use '{prefix}.{seed}.png' instead" "The filename format is broken or complete. Will use '{prefix}.{seed}.png' instead"
) )
filename = f"{prefix}.{seed}.png" filename = f"{prefix}.{seed}.png"
@ -1094,14 +1091,14 @@ def split_variations(variations_string) -> list:
for part in variations_string.split(","): for part in variations_string.split(","):
seed_and_weight = part.split(":") seed_and_weight = part.split(":")
if len(seed_and_weight) != 2: if len(seed_and_weight) != 2:
print(f'** Could not parse with_variation part "{part}"') logger.warning(f'Could not parse with_variation part "{part}"')
broken = True broken = True
break break
try: try:
seed = int(seed_and_weight[0]) seed = int(seed_and_weight[0])
weight = float(seed_and_weight[1]) weight = float(seed_and_weight[1])
except ValueError: except ValueError:
print(f'** Could not parse with_variation part "{part}"') logger.warning(f'Could not parse with_variation part "{part}"')
broken = True broken = True
break break
parts.append([seed, weight]) parts.append([seed, weight])
@ -1125,23 +1122,23 @@ def load_face_restoration(opt):
opt.gfpgan_model_path opt.gfpgan_model_path
) )
else: else:
print(">> Face restoration disabled") logger.info("Face restoration disabled")
if opt.esrgan: if opt.esrgan:
esrgan = restoration.load_esrgan(opt.esrgan_bg_tile) esrgan = restoration.load_esrgan(opt.esrgan_bg_tile)
else: else:
print(">> Upscaling disabled") logger.info("Upscaling disabled")
else: else:
print(">> Face restoration and upscaling disabled") logger.info("Face restoration and upscaling disabled")
except (ModuleNotFoundError, ImportError): except (ModuleNotFoundError, ImportError):
print(traceback.format_exc(), file=sys.stderr) print(traceback.format_exc(), file=sys.stderr)
print(">> You may need to install the ESRGAN and/or GFPGAN modules") logger.info("You may need to install the ESRGAN and/or GFPGAN modules")
return gfpgan, codeformer, esrgan return gfpgan, codeformer, esrgan
def make_step_callback(gen, opt, prefix): def make_step_callback(gen, opt, prefix):
destination = os.path.join(opt.outdir, "intermediates", prefix) destination = os.path.join(opt.outdir, "intermediates", prefix)
os.makedirs(destination, exist_ok=True) os.makedirs(destination, exist_ok=True)
print(f">> Intermediate images will be written into {destination}") logger.info(f"Intermediate images will be written into {destination}")
def callback(state: PipelineIntermediateState): def callback(state: PipelineIntermediateState):
latents = state.latents latents = state.latents
@ -1183,21 +1180,20 @@ def retrieve_dream_command(opt, command, completer):
try: try:
cmd = dream_cmd_from_png(path) cmd = dream_cmd_from_png(path)
except OSError: except OSError:
print(f"## {tokens[0]}: file could not be read") logger.error(f"{tokens[0]}: file could not be read")
except (KeyError, AttributeError, IndexError): except (KeyError, AttributeError, IndexError):
print(f"## {tokens[0]}: file has no metadata") logger.error(f"{tokens[0]}: file has no metadata")
except: except:
print(f"## {tokens[0]}: file could not be processed") logger.error(f"{tokens[0]}: file could not be processed")
if len(cmd) > 0: if len(cmd) > 0:
completer.set_line(cmd) completer.set_line(cmd)
def write_commands(opt, file_path: str, outfilepath: str): def write_commands(opt, file_path: str, outfilepath: str):
dir, basename = os.path.split(file_path) dir, basename = os.path.split(file_path)
try: try:
paths = sorted(list(Path(dir).glob(basename))) paths = sorted(list(Path(dir).glob(basename)))
except ValueError: except ValueError:
print(f'## "{basename}": unacceptable pattern') logger.error(f'"{basename}": unacceptable pattern')
return return
commands = [] commands = []
@ -1206,9 +1202,9 @@ def write_commands(opt, file_path: str, outfilepath: str):
try: try:
cmd = dream_cmd_from_png(path) cmd = dream_cmd_from_png(path)
except (KeyError, AttributeError, IndexError): except (KeyError, AttributeError, IndexError):
print(f"## {path}: file has no metadata") logger.error(f"{path}: file has no metadata")
except: except:
print(f"## {path}: file could not be processed") logger.error(f"{path}: file could not be processed")
if cmd: if cmd:
commands.append(f"# {path}") commands.append(f"# {path}")
commands.append(cmd) commands.append(cmd)
@ -1218,18 +1214,18 @@ def write_commands(opt, file_path: str, outfilepath: str):
outfilepath = os.path.join(opt.outdir, basename) outfilepath = os.path.join(opt.outdir, basename)
with open(outfilepath, "w", encoding="utf-8") as f: with open(outfilepath, "w", encoding="utf-8") as f:
f.write("\n".join(commands)) f.write("\n".join(commands))
print(f">> File {outfilepath} with commands created") logger.info(f"File {outfilepath} with commands created")
def report_model_error(opt: Namespace, e: Exception): def report_model_error(opt: Namespace, e: Exception):
print(f'** An error occurred while attempting to initialize the model: "{str(e)}"') logger.warning(f'An error occurred while attempting to initialize the model: "{str(e)}"')
print( logger.warning(
"** This can be caused by a missing or corrupted models file, and can sometimes be fixed by (re)installing the models." "This can be caused by a missing or corrupted models file, and can sometimes be fixed by (re)installing the models."
) )
yes_to_all = os.environ.get("INVOKE_MODEL_RECONFIGURE") yes_to_all = os.environ.get("INVOKE_MODEL_RECONFIGURE")
if yes_to_all: if yes_to_all:
print( logger.warning(
"** Reconfiguration is being forced by environment variable INVOKE_MODEL_RECONFIGURE" "Reconfiguration is being forced by environment variable INVOKE_MODEL_RECONFIGURE"
) )
else: else:
if not click.confirm( if not click.confirm(
@ -1238,7 +1234,7 @@ def report_model_error(opt: Namespace, e: Exception):
): ):
return return
print("invokeai-configure is launching....\n") logger.info("invokeai-configure is launching....\n")
# Match arguments that were set on the CLI # Match arguments that were set on the CLI
# only the arguments accepted by the configuration script are parsed # only the arguments accepted by the configuration script are parsed
@ -1255,7 +1251,7 @@ def report_model_error(opt: Namespace, e: Exception):
from ..install import invokeai_configure from ..install import invokeai_configure
invokeai_configure() invokeai_configure()
print("** InvokeAI will now restart") logger.warning("InvokeAI will now restart")
sys.argv = previous_args sys.argv = previous_args
main() # would rather do a os.exec(), but doesn't exist? main() # would rather do a os.exec(), but doesn't exist?
sys.exit(0) sys.exit(0)

17
invokeai/frontend/install/model_install.py
View File

@ -22,6 +22,7 @@ import torch
from npyscreen import widget from npyscreen import widget
from omegaconf import OmegaConf from omegaconf import OmegaConf
import invokeai.backend.util.logging as logger
from invokeai.backend.globals import Globals, global_config_dir from invokeai.backend.globals import Globals, global_config_dir
from ...backend.config.model_install_backend import ( from ...backend.config.model_install_backend import (
@ -455,8 +456,8 @@ def main():
Globals.root = os.path.expanduser(get_root(opt.root) or "") Globals.root = os.path.expanduser(get_root(opt.root) or "")
if not global_config_dir().exists(): if not global_config_dir().exists():
print( logger.info(
">> Your InvokeAI root directory is not set up. Calling invokeai-configure." "Your InvokeAI root directory is not set up. Calling invokeai-configure."
) )
from invokeai.frontend.install import invokeai_configure from invokeai.frontend.install import invokeai_configure
@ -466,18 +467,18 @@ def main():
try: try:
select_and_download_models(opt) select_and_download_models(opt)
except AssertionError as e: except AssertionError as e:
print(str(e)) logger.error(e)
sys.exit(-1) sys.exit(-1)
except KeyboardInterrupt: except KeyboardInterrupt:
print("\nGoodbye! Come back soon.") logger.info("Goodbye! Come back soon.")
except widget.NotEnoughSpaceForWidget as e: except widget.NotEnoughSpaceForWidget as e:
if str(e).startswith("Height of 1 allocated"): if str(e).startswith("Height of 1 allocated"):
print( logger.error(
"** Insufficient vertical space for the interface. Please make your window taller and try again" "Insufficient vertical space for the interface. Please make your window taller and try again"
) )
elif str(e).startswith("addwstr"): elif str(e).startswith("addwstr"):
print( logger.error(
"** Insufficient horizontal space for the interface. Please make your window wider and try again." "Insufficient horizontal space for the interface. Please make your window wider and try again."
) )

27
invokeai/frontend/merge/merge_diffusers.py
View File

@ -27,6 +27,8 @@ from ...backend.globals import (
global_models_dir, global_models_dir,
global_set_root, global_set_root,
) )
import invokeai.backend.util.logging as logger
from ...backend.model_management import ModelManager from ...backend.model_management import ModelManager
from ...frontend.install.widgets import FloatTitleSlider from ...frontend.install.widgets import FloatTitleSlider
@ -113,7 +115,7 @@ def merge_diffusion_models_and_commit(
model_name=merged_model_name, description=f'Merge of models {", ".join(models)}' model_name=merged_model_name, description=f'Merge of models {", ".join(models)}'
) )
if vae := model_manager.config[models[0]].get("vae", None): if vae := model_manager.config[models[0]].get("vae", None):
print(f">> Using configured VAE assigned to {models[0]}") logger.info(f"Using configured VAE assigned to {models[0]}")
import_args.update(vae=vae) import_args.update(vae=vae)
model_manager.import_diffuser_model(dump_path, **import_args) model_manager.import_diffuser_model(dump_path, **import_args)
model_manager.commit(config_file) model_manager.commit(config_file)
@ -391,10 +393,8 @@ class mergeModelsForm(npyscreen.FormMultiPageAction):
for name in self.model_manager.model_names() for name in self.model_manager.model_names()
if self.model_manager.model_info(name).get("format") == "diffusers" if self.model_manager.model_info(name).get("format") == "diffusers"
] ]
print(model_names)
return sorted(model_names) return sorted(model_names)
class Mergeapp(npyscreen.NPSAppManaged): class Mergeapp(npyscreen.NPSAppManaged):
def __init__(self): def __init__(self):
super().__init__() super().__init__()
@ -414,7 +414,7 @@ def run_gui(args: Namespace):
args = mergeapp.merge_arguments args = mergeapp.merge_arguments
merge_diffusion_models_and_commit(**args) merge_diffusion_models_and_commit(**args)
print(f'>> Models merged into new model: "{args["merged_model_name"]}".') logger.info(f'Models merged into new model: "{args["merged_model_name"]}".')
def run_cli(args: Namespace): def run_cli(args: Namespace):
@ -425,8 +425,8 @@ def run_cli(args: Namespace):
if not args.merged_model_name: if not args.merged_model_name:
args.merged_model_name = "+".join(args.models) args.merged_model_name = "+".join(args.models)
print( logger.info(
f'>> No --merged_model_name provided. Defaulting to "{args.merged_model_name}"' f'No --merged_model_name provided. Defaulting to "{args.merged_model_name}"'
) )
model_manager = ModelManager(OmegaConf.load(global_config_file())) model_manager = ModelManager(OmegaConf.load(global_config_file()))
@ -435,7 +435,7 @@ def run_cli(args: Namespace):
), f'A model named "{args.merged_model_name}" already exists. Use --clobber to overwrite.' ), f'A model named "{args.merged_model_name}" already exists. Use --clobber to overwrite.'
merge_diffusion_models_and_commit(**vars(args)) merge_diffusion_models_and_commit(**vars(args))
print(f'>> Models merged into new model: "{args.merged_model_name}".') logger.info(f'Models merged into new model: "{args.merged_model_name}".')
def main(): def main():
@ -455,17 +455,16 @@ def main():
run_cli(args) run_cli(args)
except widget.NotEnoughSpaceForWidget as e: except widget.NotEnoughSpaceForWidget as e:
if str(e).startswith("Height of 1 allocated"): if str(e).startswith("Height of 1 allocated"):
print( logger.error(
"** You need to have at least two diffusers models defined in models.yaml in order to merge" "You need to have at least two diffusers models defined in models.yaml in order to merge"
) )
else: else:
print( logger.error(
"** Not enough room for the user interface. Try making this window larger." "Not enough room for the user interface. Try making this window larger."
) )
sys.exit(-1) sys.exit(-1)
except Exception: except Exception as e:
print(">> An error occurred:") logger.error(e)
traceback.print_exc()
sys.exit(-1) sys.exit(-1)
except KeyboardInterrupt: except KeyboardInterrupt:
sys.exit(-1) sys.exit(-1)

25
invokeai/frontend/training/textual_inversion.py
View File

@ -20,6 +20,7 @@ import npyscreen
from npyscreen import widget from npyscreen import widget
from omegaconf import OmegaConf from omegaconf import OmegaConf
import invokeai.backend.util.logging as logger
from invokeai.backend.globals import Globals, global_set_root from invokeai.backend.globals import Globals, global_set_root
from ...backend.training import do_textual_inversion_training, parse_args from ...backend.training import do_textual_inversion_training, parse_args
@ -368,14 +369,14 @@ def copy_to_embeddings_folder(args: dict):
dest_dir_name = args["placeholder_token"].strip("<>") dest_dir_name = args["placeholder_token"].strip("<>")
destination = Path(Globals.root, "embeddings", dest_dir_name) destination = Path(Globals.root, "embeddings", dest_dir_name)
os.makedirs(destination, exist_ok=True) os.makedirs(destination, exist_ok=True)
print(f">> Training completed. Copying learned_embeds.bin into {str(destination)}") logger.info(f"Training completed. Copying learned_embeds.bin into {str(destination)}")
shutil.copy(source, destination) shutil.copy(source, destination)
if ( if (
input("Delete training logs and intermediate checkpoints? [y] ") or "y" input("Delete training logs and intermediate checkpoints? [y] ") or "y"
).startswith(("y", "Y")): ).startswith(("y", "Y")):
shutil.rmtree(Path(args["output_dir"])) shutil.rmtree(Path(args["output_dir"]))
else: else:
print(f'>> Keeping {args["output_dir"]}') logger.info(f'Keeping {args["output_dir"]}')
def save_args(args: dict): def save_args(args: dict):
@ -422,10 +423,10 @@ def do_front_end(args: Namespace):
do_textual_inversion_training(**args) do_textual_inversion_training(**args)
copy_to_embeddings_folder(args) copy_to_embeddings_folder(args)
except Exception as e: except Exception as e:
print("** An exception occurred during training. The exception was:") logger.error("An exception occurred during training. The exception was:")
print(str(e)) logger.error(str(e))
print("** DETAILS:") logger.error("DETAILS:")
print(traceback.format_exc()) logger.error(traceback.format_exc())
def main(): def main():
@ -437,21 +438,21 @@ def main():
else: else:
do_textual_inversion_training(**vars(args)) do_textual_inversion_training(**vars(args))
except AssertionError as e: except AssertionError as e:
print(str(e)) logger.error(e)
sys.exit(-1) sys.exit(-1)
except KeyboardInterrupt: except KeyboardInterrupt:
pass pass
except (widget.NotEnoughSpaceForWidget, Exception) as e: except (widget.NotEnoughSpaceForWidget, Exception) as e:
if str(e).startswith("Height of 1 allocated"): if str(e).startswith("Height of 1 allocated"):
print( logger.error(
"** You need to have at least one diffusers models defined in models.yaml in order to train" "You need to have at least one diffusers models defined in models.yaml in order to train"
) )
elif str(e).startswith("addwstr"): elif str(e).startswith("addwstr"):
print( logger.error(
"** Not enough window space for the interface. Please make your window larger and try again." "Not enough window space for the interface. Please make your window larger and try again."
) )
else: else:
print(f"** An error has occurred: {str(e)}") logger.error(e)
sys.exit(-1) sys.exit(-1)

1
tests/nodes/test_graph_execution_state.py
View File

@ -25,6 +25,7 @@ def mock_services():
return InvocationServices( return InvocationServices(
model_manager = None, # type: ignore model_manager = None, # type: ignore
events = None, # type: ignore events = None, # type: ignore
logger = None, # type: ignore
images = None, # type: ignore images = None, # type: ignore
latents = None, # type: ignore latents = None, # type: ignore
metadata = None, # type: ignore metadata = None, # type: ignore

1
tests/nodes/test_invoker.py
View File

@ -23,6 +23,7 @@ def mock_services() -> InvocationServices:
return InvocationServices( return InvocationServices(
model_manager = None, # type: ignore model_manager = None, # type: ignore
events = TestEventService(), events = TestEventService(),
logger = None, # type: ignore
images = None, # type: ignore images = None, # type: ignore
latents = None, # type: ignore latents = None, # type: ignore
metadata = None, # type: ignore metadata = None, # type: ignore