add missing import

README.md

@@ -2,102 +2,21 @@
 
 ![project hero](https://github.com/invoke-ai/InvokeAI/assets/31807370/6e3728c7-e90e-4711-905c-3b55844ff5be)
 
-# Invoke - Professional Creative AI Tools for Visual Media
+# Invoke - Professional Creative AI Tools for Visual Media 
+##  To learn more about Invoke, or implement our Business solutions, visit [invoke.com](https://www.invoke.com/about)
+  
 
-#### To learn more about Invoke, or implement our Business solutions, visit [invoke.com]
 
-[![discord badge]][discord link] [![latest release badge]][latest release link] [![github stars badge]][github stars link] [![github forks badge]][github forks link] [![CI checks on main badge]][CI checks on main link] [![latest commit to main badge]][latest commit to main link] [![github open issues badge]][github open issues link] [![github open prs badge]][github open prs link] [![translation status badge]][translation status link]
+[![discord badge]][discord link]
 
-</div>
+[![latest release badge]][latest release link] [![github stars badge]][github stars link] [![github forks badge]][github forks link]
 
-Invoke is a leading creative engine built to empower professionals and enthusiasts alike. Generate and create stunning visual media using the latest AI-driven technologies. Invoke offers an industry leading web-based UI, and serves as the foundation for multiple commercial products.
+[![CI checks on main badge]][CI checks on main link] [![latest commit to main badge]][latest commit to main link]
 
-[Installation and Updates][installation docs] - [Documentation and Tutorials][docs home] - [Bug Reports][github issues] - [Contributing][contributing docs]
+[![github open issues badge]][github open issues link] [![github open prs badge]][github open prs link] [![translation status badge]][translation status link]
 
-<div align="center">
-
-![Highlighted Features - Canvas and Workflows](https://github.com/invoke-ai/InvokeAI/assets/31807370/708f7a82-084f-4860-bfbe-e2588c53548d)
-
-</div>
-
-## Quick Start
-
-1. Download and unzip the installer from the bottom of the [latest release][latest release link].
-2. Run the installer script.
-
-   - **Windows**: Double-click on the `install.bat` script.
-   - **macOS**: Open a Terminal window, drag the file `install.sh` from Finder into the Terminal, and press enter.
-   - **Linux**: Run `install.sh`.
-
-3. When prompted, enter a location for the install and select your GPU type.
-4. Once the install finishes, find the directory you selected during install. The default location is `C:\Users\Username\invokeai` for Windows or `~/invokeai` for Linux/macOS.
-5. Run the launcher script (`invoke.bat` for Windows, `invoke.sh` for macOS and Linux) the same way you ran the installer script in step 2.
-6. Select option 1 to start the application. Once it starts up, open your browser and go to <http://localhost:9090>.
-7. Open the model manager tab to install a starter model and then you'll be ready to generate.
-
-More detail, including hardware requirements and manual install instructions, are available in the [installation documentation][installation docs].
-
-## Troubleshooting, FAQ and Support
-
-Please review our [FAQ][faq] for solutions to common installation problems and other issues.
-
-For more help, please join our [Discord][discord link].
-
-## Features
-
-Full details on features can be found in [our documentation][features docs].
-
-### Web Server & UI
-
-Invoke runs a locally hosted web server & React UI with an industry-leading user experience.
-
-### Unified Canvas
-
-The Unified Canvas is a fully integrated canvas implementation with support for all core generation capabilities, in/out-painting, brush tools, and more. This creative tool unlocks the capability for artists to create with AI as a creative collaborator, and can be used to augment AI-generated imagery, sketches, photography, renders, and more.
-
-### Workflows & Nodes
-
-Invoke offers a fully featured workflow management solution, enabling users to combine the power of node-based workflows with the easy of a UI. This allows for customizable generation pipelines to be developed and shared by users looking to create specific workflows to support their production use-cases.
-
-### Board & Gallery Management
-
-Invoke features an organized gallery system for easily storing, accessing, and remixing your content in the Invoke workspace. Images can be dragged/dropped onto any Image-base UI element in the application, and rich metadata within the Image allows for easy recall of key prompts or settings used in your workflow.
-
-### Other features
-
-- Support for both ckpt and diffusers models
-- SD1.5, SD2.0, and SDXL support
-- Upscaling Tools
-- Embedding Manager & Support
-- Model Manager & Support
-- Workflow creation & management
-- Node-Based Architecture
-
-## Contributing
-
-Anyone who wishes to contribute to this project - whether documentation, features, bug fixes, code cleanup, testing, or code reviews - is very much encouraged to do so.
-
-Get started with contributing by reading our [contribution documentation][contributing docs], joining the [#dev-chat] or the GitHub discussion board.
-
-We hope you enjoy using Invoke as much as we enjoy creating it, and we hope you will elect to become part of our community.
-
-## Thanks
-
-Invoke is a combined effort of [passionate and talented people from across the world][contributors]. We thank them for their time, hard work and effort.
-
-Original portions of the software are Copyright © 2024 by respective contributors.
-
-[features docs]: https://invoke-ai.github.io/InvokeAI/features/
-[faq]: https://invoke-ai.github.io/InvokeAI/help/FAQ/
-[contributors]: https://invoke-ai.github.io/InvokeAI/other/CONTRIBUTORS/
-[invoke.com]: https://www.invoke.com/about
-[github issues]: https://github.com/invoke-ai/InvokeAI/issues
-[docs home]: https://invoke-ai.github.io/InvokeAI
-[installation docs]: https://invoke-ai.github.io/InvokeAI/installation/INSTALLATION/
-[#dev-chat]: https://discord.com/channels/1020123559063990373/1049495067846524939
-[contributing docs]: https://invoke-ai.github.io/InvokeAI/contributing/CONTRIBUTING/
 [CI checks on main badge]: https://flat.badgen.net/github/checks/invoke-ai/InvokeAI/main?label=CI%20status%20on%20main&cache=900&icon=github
-[CI checks on main link]: https://github.com/invoke-ai/InvokeAI/actions?query=branch%3Amain
+[CI checks on main link]:https://github.com/invoke-ai/InvokeAI/actions?query=branch%3Amain
 [discord badge]: https://flat.badgen.net/discord/members/ZmtBAhwWhy?icon=discord
 [discord link]: https://discord.gg/ZmtBAhwWhy
 [github forks badge]: https://flat.badgen.net/github/forks/invoke-ai/InvokeAI?icon=github
@@ -111,6 +30,402 @@ Original portions of the software are Copyright © 2024 by respective contributo
 [latest commit to main badge]: https://flat.badgen.net/github/last-commit/invoke-ai/InvokeAI/main?icon=github&color=yellow&label=last%20dev%20commit&cache=900
 [latest commit to main link]: https://github.com/invoke-ai/InvokeAI/commits/main
 [latest release badge]: https://flat.badgen.net/github/release/invoke-ai/InvokeAI/development?icon=github
-[latest release link]: https://github.com/invoke-ai/InvokeAI/releases/latest
+[latest release link]: https://github.com/invoke-ai/InvokeAI/releases
 [translation status badge]: https://hosted.weblate.org/widgets/invokeai/-/svg-badge.svg
 [translation status link]: https://hosted.weblate.org/engage/invokeai/
+
+</div>
+
+InvokeAI is a leading creative engine built to empower professionals
+and enthusiasts alike. Generate and create stunning visual media using
+the latest AI-driven technologies. InvokeAI offers an industry leading
+Web Interface, interactive Command Line Interface, and also serves as
+the foundation for multiple commercial products.
+
+**Quick links**: [[How to
+  Install](https://invoke-ai.github.io/InvokeAI/installation/INSTALLATION/)] [<a
+  href="https://discord.gg/ZmtBAhwWhy">Discord Server</a>] [<a
+  href="https://invoke-ai.github.io/InvokeAI/">Documentation and
+  Tutorials</a>]
+  [<a href="https://github.com/invoke-ai/InvokeAI/issues">Bug Reports</a>]
+  [<a
+  href="https://github.com/invoke-ai/InvokeAI/discussions">Discussion,
+  Ideas & Q&A</a>] 
+   [<a
+  href="https://invoke-ai.github.io/InvokeAI/contributing/CONTRIBUTING/">Contributing</a>] 
+
+<div align="center">
+
+
+![Highlighted Features - Canvas and Workflows](https://github.com/invoke-ai/InvokeAI/assets/31807370/708f7a82-084f-4860-bfbe-e2588c53548d)
+
+
+</div>
+
+## Table of Contents
+
+Table of Contents 📝
+
+**Getting Started**
+1. 🏁 [Quick Start](#quick-start) 
+3. 🖥️ [Hardware Requirements](#hardware-requirements) 
+
+**More About Invoke**
+1. 🌟 [Features](#features) 
+2. 📣 [Latest Changes](#latest-changes) 
+3. 🛠️ [Troubleshooting](#troubleshooting) 
+
+**Supporting the Project**
+1. 🤝 [Contributing](#contributing) 
+2. 👥 [Contributors](#contributors) 
+3. 💕 [Support](#support) 
+
+## Quick Start
+
+For full installation and upgrade instructions, please see:
+[InvokeAI Installation Overview](https://invoke-ai.github.io/InvokeAI/installation/INSTALLATION/)
+
+If upgrading from version 2.3, please read [Migrating a 2.3 root
+directory to 3.0](#migrating-to-3) first.
+
+### Automatic Installer (suggested for 1st time users)
+
+1. Go to the bottom of the [Latest Release Page](https://github.com/invoke-ai/InvokeAI/releases/latest)
+
+2. Download the .zip file for your OS (Windows/macOS/Linux).
+
+3. Unzip the file.
+
+4. **Windows:** double-click on the `install.bat` script. **macOS:** Open a Terminal window, drag the file `install.sh` from Finder
+into the Terminal, and press return. **Linux:** run `install.sh`.
+
+5. You'll be asked to confirm the location of the folder in which
+to install InvokeAI and its image generation model files. Pick a
+location with at least 15 GB of free memory. More if you plan on
+installing lots of models.
+
+6. Wait while the installer does its thing. After installing the software,
+the installer will launch a script that lets you configure InvokeAI and
+select a set of starting image generation models.
+
+7. Find the folder that InvokeAI was installed into (it is not the
+same as the unpacked zip file directory!) The default location of this
+folder (if you didn't change it in step 5) is `~/invokeai` on
+Linux/Mac systems, and `C:\Users\YourName\invokeai` on Windows. This directory will contain launcher scripts named `invoke.sh` and `invoke.bat`.
+
+8. On Windows systems, double-click on the `invoke.bat` file. On
+macOS, open a Terminal window, drag `invoke.sh` from the folder into
+the Terminal, and press return. On Linux, run `invoke.sh`
+
+9. Press 2 to open the "browser-based UI", press enter/return, wait a
+minute or two for Stable Diffusion to start up, then open your browser
+and go to http://localhost:9090.
+
+10. Type `banana sushi` in the box on the top left and click `Invoke`
+
+### Command-Line Installation (for developers and users familiar with Terminals)
+
+You must have Python 3.10 through 3.11 installed on your machine. Earlier or
+later versions are not supported.
+Node.js also needs to be installed along with `pnpm` (can be installed with
+the command `npm install -g pnpm` if needed)
+
+1. Open a command-line window on your machine. The PowerShell is recommended for Windows.
+2. Create a directory to install InvokeAI into. You'll need at least 15 GB of free space:
+
+    ```terminal
+    mkdir invokeai
+    ````
+
+3. Create a virtual environment named `.venv` inside this directory and activate it:
+
+    ```terminal
+    cd invokeai
+    python -m venv .venv --prompt InvokeAI
+    ```
+
+4. Activate the virtual environment (do it every time you run InvokeAI)
+
+    _For Linux/Mac users:_
+
+    ```sh
+    source .venv/bin/activate
+    ```
+
+    _For Windows users:_
+
+    ```ps
+    .venv\Scripts\activate
+    ```
+
+5. Install the InvokeAI module and its dependencies. Choose the command suited for your platform & GPU.
+
+    _For Windows/Linux with an NVIDIA GPU:_
+
+    ```terminal
+    pip install "InvokeAI[xformers]" --use-pep517 --extra-index-url https://download.pytorch.org/whl/cu121
+    ```
+
+    _For Linux with an AMD GPU:_
+
+    ```sh
+    pip install InvokeAI --use-pep517 --extra-index-url https://download.pytorch.org/whl/rocm5.6
+    ```
+
+    _For non-GPU systems:_
+    ```terminal
+    pip install InvokeAI --use-pep517 --extra-index-url https://download.pytorch.org/whl/cpu
+    ``` 
+
+    _For Macintoshes, either Intel or M1/M2/M3:_
+
+    ```sh
+    pip install InvokeAI --use-pep517
+    ```
+
+6. Configure InvokeAI and install a starting set of image generation models (you only need to do this once):
+
+    ```terminal
+    invokeai-configure --root .
+    ```
+	Don't miss the dot at the end!
+
+7. Launch the web server (do it every time you run InvokeAI):
+
+    ```terminal
+    invokeai-web
+    ```
+
+8. Point your browser to http://localhost:9090 to bring up the web interface.
+
+9. Type `banana sushi` in the box on the top left and click `Invoke`.
+
+Be sure to activate the virtual environment each time before re-launching InvokeAI,
+using `source .venv/bin/activate` or `.venv\Scripts\activate`.
+
+## Detailed Installation Instructions
+
+This fork is supported across Linux, Windows and Macintosh. Linux
+users can use either an Nvidia-based card (with CUDA support) or an
+AMD card (using the ROCm driver). For full installation and upgrade
+instructions, please see:
+[InvokeAI Installation Overview](https://invoke-ai.github.io/InvokeAI/installation/INSTALL_SOURCE/)
+
+<a name="migrating-to-3"></a>
+### Migrating a v2.3 InvokeAI root directory
+
+The InvokeAI root directory is where the InvokeAI startup file,
+installed models, and generated images are stored. It is ordinarily
+named `invokeai` and located in your home directory. The contents and
+layout of this directory has changed between versions 2.3 and 3.0 and
+cannot be used directly.
+
+We currently recommend that you use the installer to create a new root
+directory named differently from the 2.3 one, e.g. `invokeai-3` and
+then use a migration script to copy your 2.3 models into the new
+location. However, if you choose, you can upgrade this directory in
+place.  This section gives both recipes.
+
+#### Creating a new root directory and migrating old models
+
+This is the safer recipe because it leaves your old root directory in
+place to fall back on.
+
+1. Follow the instructions above to create and install InvokeAI in a
+directory that has a different name from the 2.3 invokeai directory.
+In this example, we will use "invokeai-3"
+
+2. When you are prompted to select models to install, select a minimal
+set of models, such as stable-diffusion-v1.5 only.
+
+3. After installation is complete launch `invokeai.sh` (Linux/Mac) or
+`invokeai.bat` and select option 8 "Open the developers console". This
+will take you to the command line.
+
+4. Issue the command `invokeai-migrate3 --from /path/to/v2.3-root --to
+/path/to/invokeai-3-root`. Provide the correct `--from` and `--to`
+paths for your v2.3 and v3.0 root directories respectively.
+
+This will copy and convert your old models from 2.3 format to 3.0
+format and create a new `models` directory in the 3.0 directory. The
+old models directory (which contains the models selected at install
+time) will be renamed `models.orig` and can be deleted once you have
+confirmed that the migration was successful.
+
+ If you wish, you can pass the 2.3 root directory to both `--from` and
+`--to` in order to update in place. Warning: this directory will no
+longer be usable with InvokeAI 2.3.
+
+#### Migrating in place
+
+For the adventurous, you may do an in-place upgrade from 2.3 to 3.0
+without touching the command line. ***This recipe does not work on
+Windows platforms due to a bug in the Windows version of the 2.3
+upgrade script.** See the next section for a Windows recipe.
+
+##### For Mac and Linux Users:
+
+1. Launch the InvokeAI launcher script in your current v2.3 root directory.
+
+2. Select option [9] "Update InvokeAI" to bring up the updater dialog.
+
+3. Select option [1] to upgrade to the latest release.
+
+4. Once the upgrade is finished you will be returned to the launcher
+menu. Select option [6] "Re-run the configure script to fix a broken
+install or to complete a major upgrade".
+
+This will run the configure script against the v2.3 directory and
+update it to the 3.0 format. The following files will be replaced:
+
+  - The invokeai.init file, replaced by invokeai.yaml
+  - The models directory
+  - The configs/models.yaml model index
+  
+The original versions of these files will be saved with the suffix
+".orig" appended to the end. Once you have confirmed that the upgrade
+worked, you can safely remove these files. Alternatively you can
+restore a working v2.3 directory by removing the new files and
+restoring the ".orig" files' original names.
+
+##### For Windows Users:
+
+Windows Users can upgrade with the
+
+1. Enter the 2.3 root directory you wish to upgrade
+2. Launch `invoke.sh` or `invoke.bat`
+3. Select the "Developer's console" option [8]
+4. Type the following commands
+
+```
+pip install "invokeai @ https://github.com/invoke-ai/InvokeAI/archive/refs/tags/v3.0.0" --use-pep517 --upgrade
+invokeai-configure --root .
+```
+(Replace `v3.0.0` with the current release number if this document is out of date).
+
+The first command will install and upgrade new software to run
+InvokeAI. The second will prepare the 2.3 directory for use with 3.0.
+You may now launch the WebUI in the usual way, by selecting option [1]
+from the launcher script
+
+#### Migrating Images
+
+The migration script will migrate your invokeai settings and models,
+including textual inversion models, LoRAs and merges that you may have
+installed previously. However it does **not** migrate the generated
+images stored in your 2.3-format outputs directory. To do this, you 
+need to run an additional step:
+
+1. From a working InvokeAI 3.0 root directory, start the launcher and
+enter menu option [8] to open the "developer's console".
+
+2. At the developer's console command line, type the command:
+
+```bash
+invokeai-import-images
+```
+
+3. This will lead you through the process of confirming the desired
+   source and destination for the imported images. The images will
+   appear in the gallery board of your choice, and contain the
+   original prompt, model name, and other parameters used to generate
+   the image.
+   
+(Many kudos to **techjedi** for contributing this script.)
+
+## Hardware Requirements
+
+InvokeAI is supported across Linux, Windows and macOS. Linux
+users can use either an Nvidia-based card (with CUDA support) or an
+AMD card (using the ROCm driver).
+
+### System
+
+You will need one of the following:
+
+- An NVIDIA-based graphics card with 4 GB or more VRAM memory. 6-8 GB
+  of VRAM is highly recommended for rendering using the Stable
+  Diffusion XL models
+- An Apple computer with an M1 chip.
+- An AMD-based graphics card with 4GB or more VRAM memory (Linux
+  only), 6-8 GB for XL rendering.
+
+We do not recommend the GTX 1650 or 1660 series video cards. They are
+unable to run in half-precision mode and do not have sufficient VRAM
+to render 512x512 images.
+
+**Memory** - At least 12 GB Main Memory RAM.
+
+**Disk** - At least 12 GB of free disk space for the machine learning model, Python, and all its dependencies.
+
+## Features
+
+Feature documentation can be reviewed by navigating to [the InvokeAI Documentation page](https://invoke-ai.github.io/InvokeAI/features/)
+
+### *Web Server & UI*
+
+InvokeAI offers a locally hosted Web Server & React Frontend, with an industry leading user experience. The Web-based UI allows for simple and intuitive workflows, and is responsive for use on mobile devices and tablets accessing the web server.
+
+### *Unified Canvas*
+
+The Unified Canvas is a fully integrated canvas implementation with support for all core generation capabilities, in/outpainting, brush tools, and more. This creative tool unlocks the capability for artists to create with AI as a creative collaborator, and can be used to augment AI-generated imagery, sketches, photography, renders, and more.
+
+### *Workflows & Nodes*
+
+InvokeAI offers a fully featured workflow management solution, enabling users to combine the power of nodes based workflows with the easy of a UI. This allows for customizable generation pipelines to be developed and shared by users looking to create specific workflows to support their production use-cases.
+
+### *Board & Gallery Management*
+
+Invoke AI provides an organized gallery system for easily storing, accessing, and remixing your content in the Invoke workspace. Images can be dragged/dropped onto any Image-base UI element in the application, and rich metadata within the Image allows for easy recall of key prompts or settings used in your workflow. 
+
+### Other features
+
+- *Support for both ckpt and diffusers models*
+- *SD 2.0, 2.1, XL support*
+- *Upscaling Tools*
+- *Embedding Manager & Support*
+- *Model Manager & Support*
+- *Workflow creation & management*
+- *Node-Based Architecture*
+
+
+### Latest Changes
+
+For our latest changes, view our [Release
+Notes](https://github.com/invoke-ai/InvokeAI/releases) and the
+[CHANGELOG](docs/CHANGELOG.md).
+
+### Troubleshooting / FAQ
+
+Please check out our **[FAQ](https://invoke-ai.github.io/InvokeAI/help/FAQ/)** to get solutions for common installation
+problems and other issues. For more help, please join our [Discord][discord link]
+
+## Contributing
+
+Anyone who wishes to contribute to this project, whether documentation, features, bug fixes, code
+cleanup, testing, or code reviews, is very much encouraged to do so.
+
+Get started with contributing by reading our [Contribution documentation](https://invoke-ai.github.io/InvokeAI/contributing/CONTRIBUTING/), joining the [#dev-chat](https://discord.com/channels/1020123559063990373/1049495067846524939) or the GitHub discussion board.
+
+If you are unfamiliar with how
+to contribute to GitHub projects, we have a new contributor checklist you can follow to get started contributing: 
+[New Contributor Checklist](https://invoke-ai.github.io/InvokeAI/contributing/contribution_guides/newContributorChecklist/).
+
+We hope you enjoy using our software as much as we enjoy creating it,
+and we hope that some of those of you who are reading this will elect
+to become part of our community.
+
+Welcome to InvokeAI!
+
+### Contributors
+
+This fork is a combined effort of various people from across the world.
+[Check out the list of all these amazing people](https://invoke-ai.github.io/InvokeAI/other/CONTRIBUTORS/). We thank them for
+their time, hard work and effort.
+
+### Support
+
+For support, please use this repository's GitHub Issues tracking service, or join the [Discord][discord link].
+
+Original portions of the software are Copyright (c) 2023 by respective contributors.
+

docs/features/CONFIGURATION.md

@@ -51,11 +51,13 @@ The settings in this file will override the defaults. You only need
 to change this file if the default for a particular setting doesn't
 work for you.
 
-You'll find an example file next to `invokeai.yaml` that shows the default values.
-
 Some settings, like [Model Marketplace API Keys], require the YAML
 to be formatted correctly. Here is a [basic guide to YAML files].
 
+You can fix a broken `invokeai.yaml` by deleting it and running the
+configuration script again -- option [6] in the launcher, "Re-run the
+configure script".
+
 #### Custom Config File Location
 
 You can use any config file with the `--config` CLI arg. Pass in the path to the `invokeai.yaml` file you want to use.

docs/features/TRAINING.md

@@ -4,6 +4,278 @@ title: Training
 
 # :material-file-document: Training
 
-Invoke Training has moved to its own repository, with a dedicated UI for accessing common scripts like Textual Inversion and LoRA training.
+# Textual Inversion Training
+## **Personalizing Text-to-Image Generation**
 
-You can find more by visiting the repo at https://github.com/invoke-ai/invoke-training
+You may personalize the generated images to provide your own styles or objects
+by training a new LDM checkpoint and introducing a new vocabulary to the fixed
+model as a (.pt) embeddings file. Alternatively, you may use or train
+HuggingFace Concepts embeddings files (.bin) from
+<https://huggingface.co/sd-concepts-library> and its associated
+notebooks.
+
+## **Hardware and Software Requirements**
+
+You will need a GPU to perform training in a reasonable length of
+time, and at least 12 GB of VRAM. We recommend using the [`xformers`
+library](../installation/070_INSTALL_XFORMERS.md) to accelerate the
+training process further. During training, about ~8 GB is temporarily
+needed in order to store intermediate models, checkpoints and logs.
+
+## **Preparing for Training**
+
+To train, prepare a folder that contains 3-5 images that illustrate
+the object or concept. It is good to provide a variety of examples or
+poses to avoid overtraining the system. Format these images as PNG
+(preferred) or JPG. You do not need to resize or crop the images in
+advance, but for more control you may wish to do so.
+
+Place the training images in a directory on the machine InvokeAI runs
+on. We recommend placing them in a subdirectory of the
+`text-inversion-training-data` folder located in the InvokeAI root
+directory, ordinarily `~/invokeai` (Linux/Mac), or
+`C:\Users\your_name\invokeai` (Windows). For example, to create an
+embedding for the "psychedelic" style, you'd place the training images
+into the directory
+`~invokeai/text-inversion-training-data/psychedelic`.
+
+## **Launching Training Using the Console Front End**
+
+InvokeAI 2.3 and higher comes with a text console-based training front
+end. From within the `invoke.sh`/`invoke.bat` Invoke launcher script,
+start training tool selecting choice (3):
+
+```sh
+1 "Generate images with a browser-based interface"
+2 "Explore InvokeAI nodes using a command-line interface"
+3 "Textual inversion training"
+4 "Merge models (diffusers type only)"
+5 "Download and install models"
+6 "Change InvokeAI startup options"
+7 "Re-run the configure script to fix a broken install or to complete a major upgrade"
+8 "Open the developer console"
+9 "Update InvokeAI"
+```
+
+Alternatively, you can select option (8) or from the command line, with the InvokeAI virtual environment active,
+you can then launch the front end with the command `invokeai-ti --gui`.
+
+This will launch a text-based front end that will look like this:
+
+<figure markdown>
+![ti-frontend](../assets/textual-inversion/ti-frontend.png)
+</figure>
+
+The interface is keyboard-based. Move from field to field using
+control-N (^N) to move to the next field and control-P (^P) to the
+previous one. <Tab> and <shift-TAB> work as well. Once a field is
+active, use the cursor keys. In a checkbox group, use the up and down
+cursor keys to move from choice to choice, and <space> to select a
+choice. In a scrollbar, use the left and right cursor keys to increase
+and decrease the value of the scroll. In textfields, type the desired
+values.
+
+The number of parameters may look intimidating, but in most cases the
+predefined defaults work fine. The red circled fields in the above
+illustration are the ones you will adjust most frequently.
+
+### Model Name
+
+This will list all the diffusers models that are currently
+installed. Select the one you wish to use as the basis for your
+embedding. Be aware that if you use a SD-1.X-based model for your
+training, you will only be able to use this embedding with other
+SD-1.X-based models. Similarly, if you train on SD-2.X, you will only
+be able to use the embeddings with models based on SD-2.X.
+
+### Trigger Term
+
+This is the prompt term you will use to trigger the embedding. Type a
+single word or phrase you wish to use as the trigger, example
+"psychedelic" (without angle brackets). Within InvokeAI, you will then
+be able to activate the trigger using the syntax `<psychedelic>`.
+
+### Initializer
+
+This is a single character that is used internally during the training
+process as a placeholder for the trigger term. It defaults to "*" and
+can usually be left alone.
+
+### Resume from last saved checkpoint
+
+As training proceeds, textual inversion will write a series of
+intermediate files that can be used to resume training from where it
+was left off in the case of an interruption. This checkbox will be
+automatically selected if you provide a previously used trigger term
+and at least one checkpoint file is found on disk.
+
+Note that as of 20 January 2023, resume does not seem to be working
+properly due to an issue with the upstream code.
+
+### Data Training Directory
+
+This is the location of the images to be used for training. When you
+select a trigger term like "my-trigger", the frontend will prepopulate
+this field with `~/invokeai/text-inversion-training-data/my-trigger`,
+but you can change the path to wherever you want.
+
+### Output Destination Directory
+
+This is the location of the logs, checkpoint files, and embedding
+files created during training. When you select a trigger term like
+"my-trigger", the frontend will prepopulate this field with
+`~/invokeai/text-inversion-output/my-trigger`, but you can change the
+path to wherever you want.
+
+### Image resolution
+
+The images in the training directory will be automatically scaled to
+the value you use here. For best results, you will want to use the
+same default resolution of the underlying model (512 pixels for
+SD-1.5, 768 for the larger version of SD-2.1).
+
+### Center crop images
+
+If this is selected, your images will be center cropped to make them
+square before resizing them to the desired resolution. Center cropping
+can indiscriminately cut off the top of subjects' heads for portrait
+aspect images, so if you have images like this, you may wish to use a
+photoeditor to manually crop them to a square aspect ratio.
+
+### Mixed precision
+
+Select the floating point precision for the embedding. "no" will
+result in a full 32-bit precision, "fp16" will provide 16-bit
+precision, and "bf16" will provide mixed precision (only available
+when XFormers is used).
+
+### Max training steps
+
+How many steps the training will take before the model converges. Most
+training sets will converge with 2000-3000 steps.
+
+### Batch size
+
+This adjusts how many training images are processed simultaneously in
+each step. Higher values will cause the training process to run more
+quickly, but use more memory. The default size will run with GPUs with
+as little as 12 GB.
+
+### Learning rate
+
+The rate at which the system adjusts its internal weights during
+training. Higher values risk overtraining (getting the same image each
+time), and lower values will take more steps to train a good
+model. The default of 0.0005 is conservative; you may wish to increase
+it to 0.005 to speed up training.
+
+### Scale learning rate by number of GPUs, steps and batch size
+
+If this is selected (the default) the system will adjust the provided
+learning rate to improve performance.
+
+### Use xformers acceleration
+
+This will activate XFormers memory-efficient attention. You need to
+have XFormers installed for this to have an effect.
+
+### Learning rate scheduler
+
+This adjusts how the learning rate changes over the course of
+training. The default "constant" means to use a constant learning rate
+for the entire training session. The other values scale the learning
+rate according to various formulas.
+
+Only "constant" is supported by the XFormers library.
+
+### Gradient accumulation steps
+
+This is a parameter that allows you to use bigger batch sizes than
+your GPU's VRAM would ordinarily accommodate, at the cost of some
+performance.
+
+### Warmup steps
+
+If "constant_with_warmup" is selected in the learning rate scheduler,
+then this provides the number of warmup steps. Warmup steps have a
+very low learning rate, and are one way of preventing early
+overtraining.
+
+## The training run
+
+Start the training run by advancing to the OK button (bottom right)
+and pressing <enter>. A series of progress messages will be displayed
+as the training process proceeds. This may take an hour or two,
+depending on settings and the speed of your system. Various log and
+checkpoint files will be written into the output directory (ordinarily
+`~/invokeai/text-inversion-output/my-model/`)
+
+At the end of successful training, the system will copy the file
+`learned_embeds.bin` into the InvokeAI root directory's `embeddings`
+directory, using a subdirectory named after the trigger token. For
+example, if the trigger token was `psychedelic`, then look for the
+embeddings file in
+`~/invokeai/embeddings/psychedelic/learned_embeds.bin`
+
+You may now launch InvokeAI and try out a prompt that uses the trigger
+term. For example `a plate of banana sushi in <psychedelic> style`.
+
+## **Training with the Command-Line Script**
+
+Training can also be done using a traditional command-line script. It
+can be launched from within the "developer's console", or from the
+command line after activating InvokeAI's virtual environment.
+
+It accepts a large number of arguments, which can be summarized by
+passing the `--help` argument:
+
+```sh
+invokeai-ti --help
+```
+
+Typical usage is shown here:
+```sh
+invokeai-ti \
+       --model=stable-diffusion-1.5 \
+       --resolution=512 \
+       --learnable_property=style \
+       --initializer_token='*' \
+       --placeholder_token='<psychedelic>' \
+       --train_data_dir=/home/lstein/invokeai/training-data/psychedelic \
+       --output_dir=/home/lstein/invokeai/text-inversion-training/psychedelic \
+       --scale_lr \
+       --train_batch_size=8 \
+       --gradient_accumulation_steps=4 \
+       --max_train_steps=3000 \
+       --learning_rate=0.0005 \
+       --resume_from_checkpoint=latest \
+       --lr_scheduler=constant \
+       --mixed_precision=fp16 \
+       --only_save_embeds
+```
+
+## Troubleshooting
+
+### `Cannot load embedding for <trigger>. It was trained on a model with token dimension 1024, but the current model has token dimension 768`
+
+Messages like this indicate you trained the embedding on a different base model than the currently selected one.
+
+For example, in the error above, the training was done on SD2.1 (768x768) but it was used on SD1.5 (512x512).
+
+## Reading
+
+For more information on textual inversion, please see the following
+resources:
+
+* The [textual inversion repository](https://github.com/rinongal/textual_inversion) and
+  associated paper for details and limitations.
+* [HuggingFace's textual inversion training
+  page](https://huggingface.co/docs/diffusers/training/text_inversion)
+* [HuggingFace example script
+  documentation](https://github.com/huggingface/diffusers/tree/main/examples/textual_inversion)
+  (Note that this script is similar to, but not identical, to
+  `textual_inversion`, but produces embed files that are completely compatible.
+
+---
+
+copyright (c) 2023, Lincoln Stein and the InvokeAI Development Team

docs/installation/010_INSTALL_AUTOMATED.md

@@ -1,10 +1,8 @@
-# Automatic Install & Updates
+# Automatic Install
 
-**The same packaged installer file can be used for both new installs and updates.**
-Using the installer for updates will leave everything you've added since installation, and just update the core libraries used to run Invoke.
-Simply use the same path you installed to originally.
+The installer is used for both new installs and updates.
 
-Both release and pre-release versions can be installed using the installer. It also supports install through a wheel if needed.
+Both release and pre-release versions can be installed using it. It also supports install a wheel if needed.
 
 Be sure to review the [installation requirements] and ensure your system has everything it needs to install Invoke.
 

docs/installation/INSTALLATION.md

@@ -1,4 +1,4 @@
-# Installation and Updating Overview
+# Installation Overview
 
 Before installing, review the [installation requirements] to ensure your system is set up properly.
 
@@ -6,21 +6,14 @@ See the [FAQ] for frequently-encountered installation issues.
 
 If you need more help, join our [discord] or [create an issue].
 
-<h2>Automatic Install & Updates </h2>
+<h2>Automatic Install</h2>
 
 ✅ The automatic install is the best way to run InvokeAI. Check out the [installation guide] to get started.
 
-⬆️ The same installer is also the best way to update InvokeAI - Simply rerun it for the same folder you installed to.
-
-The installation process simply manages installation for the core libraries & application dependencies that run Invoke.
-Any models, images, or other assets in the Invoke root folder won't be affected by the installation process.
-
 <h2>Manual Install</h2>
 
 If you are familiar with python and want more control over the packages that are installed, you can [install InvokeAI manually via PyPI].
 
-Updates are managed by reinstalling the latest version through PyPi.
-
 <h2>Developer Install</h2>
 
 If you want to contribute to InvokeAI, consult the [developer install guide].

docs/installation/INSTALL_REQUIREMENTS.md

@@ -37,13 +37,13 @@ Invoke runs best with a dedicated GPU, but will fall back to running on CPU, alb
     === "Nvidia"
 
         ```
-        Any GPU with at least 8GB VRAM.
+        Any GPU with at least 8GB VRAM. Linux only.
         ```
 
     === "AMD"
 
         ```
-        Any GPU with at least 16GB VRAM. Linux only.
+        Any GPU with at least 16GB VRAM.
         ```
 
     === "Mac"

invokeai/app/api/routers/app_info.py

@@ -13,6 +13,7 @@ from pydantic import BaseModel, Field
 from invokeai.app.invocations.upscale import ESRGAN_MODELS
 from invokeai.app.services.invocation_cache.invocation_cache_common import InvocationCacheStatus
 from invokeai.backend.image_util.infill_methods.patchmatch import PatchMatch
+from invokeai.backend.image_util.safety_checker import SafetyChecker
 from invokeai.backend.util.logging import logging
 from invokeai.version import __version__
 
@@ -108,7 +109,9 @@ async def get_config() -> AppConfig:
         upscaling_models.append(str(Path(model).stem))
     upscaler = Upscaler(upscaling_method="esrgan", upscaling_models=upscaling_models)
 
-    nsfw_methods = ["nsfw_checker"]
+    nsfw_methods = []
+    if SafetyChecker.safety_checker_available():
+        nsfw_methods.append("nsfw_checker")
 
     watermarking_methods = ["invisible_watermark"]
 

invokeai/app/api/routers/model_manager.py

@@ -6,7 +6,7 @@ import pathlib
 import shutil
 import traceback
 from copy import deepcopy
-from typing import Any, Dict, List, Optional, Type
+from typing import Any, Dict, List, Optional
 
 from fastapi import Body, Path, Query, Response, UploadFile
 from fastapi.responses import FileResponse
@@ -16,7 +16,6 @@ from pydantic import AnyHttpUrl, BaseModel, ConfigDict, Field
 from starlette.exceptions import HTTPException
 from typing_extensions import Annotated
 
-from invokeai.app.services.model_images.model_images_common import ModelImageFileNotFoundException
 from invokeai.app.services.model_install import ModelInstallJob
 from invokeai.app.services.model_records import (
     DuplicateModelException,
@@ -53,13 +52,6 @@ class ModelsList(BaseModel):
     model_config = ConfigDict(use_enum_values=True)
 
 
-def add_cover_image_to_model_config(config: AnyModelConfig, dependencies: Type[ApiDependencies]) -> AnyModelConfig:
-    """Add a cover image URL to a model configuration."""
-    cover_image = dependencies.invoker.services.model_images.get_url(config.key)
-    config.cover_image = cover_image
-    return config
-
-
 ##############################################################################
 # These are example inputs and outputs that are used in places where Swagger
 # is unable to generate a correct example.
@@ -126,7 +118,8 @@ async def list_model_records(
             record_store.search_by_attr(model_type=model_type, model_name=model_name, model_format=model_format)
         )
     for model in found_models:
-        model = add_cover_image_to_model_config(model, ApiDependencies)
+        cover_image = ApiDependencies.invoker.services.model_images.get_url(model.key)
+        model.cover_image = cover_image
     return ModelsList(models=found_models)
 
 
@@ -167,9 +160,12 @@ async def get_model_record(
     key: str = Path(description="Key of the model record to fetch."),
 ) -> AnyModelConfig:
     """Get a model record"""
+    record_store = ApiDependencies.invoker.services.model_manager.store
     try:
-        config = ApiDependencies.invoker.services.model_manager.store.get_model(key)
-        return add_cover_image_to_model_config(config, ApiDependencies)
+        config: AnyModelConfig = record_store.get_model(key)
+        cover_image = ApiDependencies.invoker.services.model_images.get_url(key)
+        config.cover_image = cover_image
+        return config
     except UnknownModelException as e:
         raise HTTPException(status_code=404, detail=str(e))
 
@@ -298,15 +294,14 @@ async def update_model_record(
     installer = ApiDependencies.invoker.services.model_manager.install
     try:
         record_store.update_model(key, changes=changes)
-        config = installer.sync_model_path(key)
-        config = add_cover_image_to_model_config(config, ApiDependencies)
+        model_response: AnyModelConfig = installer.sync_model_path(key)
         logger.info(f"Updated model: {key}")
     except UnknownModelException as e:
         raise HTTPException(status_code=404, detail=str(e))
     except ValueError as e:
         logger.error(str(e))
         raise HTTPException(status_code=409, detail=str(e))
-    return config
+    return model_response
 
 
 @model_manager_router.get(
@@ -653,14 +648,6 @@ async def convert_model(
         logger.error(str(e))
         raise HTTPException(status_code=409, detail=str(e))
 
-    # Update the model image if the model had one
-    try:
-        model_image = ApiDependencies.invoker.services.model_images.get(key)
-        ApiDependencies.invoker.services.model_images.save(model_image, new_key)
-        ApiDependencies.invoker.services.model_images.delete(key)
-    except ModelImageFileNotFoundException:
-        pass
-
     # delete the original safetensors file
     installer.delete(key)
 
@@ -668,8 +655,7 @@ async def convert_model(
     shutil.rmtree(cache_path)
 
     # return the config record for the new diffusers directory
-    new_config = store.get_model(new_key)
-    new_config = add_cover_image_to_model_config(new_config, ApiDependencies)
+    new_config: AnyModelConfig = store.get_model(new_key)
     return new_config
 
 

invokeai/app/api_app.py

@@ -28,7 +28,7 @@ from invokeai.app.api.no_cache_staticfiles import NoCacheStaticFiles
 from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.services.config.config_default import get_config
 from invokeai.app.services.session_processor.session_processor_common import ProgressImage
-from invokeai.backend.util.devices import TorchDevice
+from invokeai.backend.util.devices import get_torch_device_name
 
 from ..backend.util.logging import InvokeAILogger
 from .api.dependencies import ApiDependencies
@@ -63,7 +63,7 @@ logger = InvokeAILogger.get_logger(config=app_config)
 mimetypes.add_type("application/javascript", ".js")
 mimetypes.add_type("text/css", ".css")
 
-torch_device_name = TorchDevice.get_torch_device_name()
+torch_device_name = get_torch_device_name()
 logger.info(f"Using torch device: {torch_device_name}")
 
 

invokeai/app/invocations/compel.py

@@ -24,7 +24,7 @@ from invokeai.backend.stable_diffusion.diffusion.conditioning_data import (
     ConditioningFieldData,
     SDXLConditioningInfo,
 )
-from invokeai.backend.util.devices import TorchDevice
+from invokeai.backend.util.devices import torch_dtype
 
 from .baseinvocation import BaseInvocation, BaseInvocationOutput, invocation, invocation_output
 from .model import CLIPField
@@ -99,7 +99,7 @@ class CompelInvocation(BaseInvocation):
                 tokenizer=tokenizer,
                 text_encoder=text_encoder,
                 textual_inversion_manager=ti_manager,
-                dtype_for_device_getter=TorchDevice.choose_torch_dtype,
+                dtype_for_device_getter=torch_dtype,
                 truncate_long_prompts=False,
             )
 
@@ -193,7 +193,7 @@ class SDXLPromptInvocationBase:
                 tokenizer=tokenizer,
                 text_encoder=text_encoder,
                 textual_inversion_manager=ti_manager,
-                dtype_for_device_getter=TorchDevice.choose_torch_dtype,
+                dtype_for_device_getter=torch_dtype,
                 truncate_long_prompts=False,  # TODO:
                 returned_embeddings_type=ReturnedEmbeddingsType.PENULTIMATE_HIDDEN_STATES_NON_NORMALIZED,  # TODO: clip skip
                 requires_pooled=get_pooled,

invokeai/app/invocations/controlnet_image_processors.py

@@ -35,16 +35,22 @@ from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.invocations.primitives import ImageOutput
 from invokeai.app.invocations.util import validate_begin_end_step, validate_weights
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.app.util.controlnet_utils import CONTROLNET_MODE_VALUES, CONTROLNET_RESIZE_VALUES, heuristic_resize
 from invokeai.backend.image_util.canny import get_canny_edges
 from invokeai.backend.image_util.depth_anything import DepthAnythingDetector
 from invokeai.backend.image_util.dw_openpose import DWOpenposeDetector
 from invokeai.backend.image_util.hed import HEDProcessor
 from invokeai.backend.image_util.lineart import LineartProcessor
 from invokeai.backend.image_util.lineart_anime import LineartAnimeProcessor
-from invokeai.backend.image_util.util import np_to_pil, pil_to_np
 
-from .baseinvocation import BaseInvocation, BaseInvocationOutput, Classification, invocation, invocation_output
+from .baseinvocation import BaseInvocation, BaseInvocationOutput, invocation, invocation_output
+
+CONTROLNET_MODE_VALUES = Literal["balanced", "more_prompt", "more_control", "unbalanced"]
+CONTROLNET_RESIZE_VALUES = Literal[
+    "just_resize",
+    "crop_resize",
+    "fill_resize",
+    "just_resize_simple",
+]
 
 
 class ControlField(BaseModel):
@@ -165,13 +171,13 @@ class ImageProcessorInvocation(BaseInvocation, WithMetadata, WithBoard):
     title="Canny Processor",
     tags=["controlnet", "canny"],
     category="controlnet",
-    version="1.3.3",
+    version="1.3.2",
 )
 class CannyImageProcessorInvocation(ImageProcessorInvocation):
     """Canny edge detection for ControlNet"""
 
-    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
-    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    detect_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.image_res)
     low_threshold: int = InputField(
         default=100, ge=0, le=255, description="The low threshold of the Canny pixel gradient (0-255)"
     )
@@ -199,13 +205,13 @@ class CannyImageProcessorInvocation(ImageProcessorInvocation):
     title="HED (softedge) Processor",
     tags=["controlnet", "hed", "softedge"],
     category="controlnet",
-    version="1.2.3",
+    version="1.2.2",
 )
 class HedImageProcessorInvocation(ImageProcessorInvocation):
     """Applies HED edge detection to image"""
 
-    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
-    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    detect_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.image_res)
     # safe not supported in controlnet_aux v0.0.3
     # safe: bool = InputField(default=False, description=FieldDescriptions.safe_mode)
     scribble: bool = InputField(default=False, description=FieldDescriptions.scribble_mode)
@@ -228,13 +234,13 @@ class HedImageProcessorInvocation(ImageProcessorInvocation):
     title="Lineart Processor",
     tags=["controlnet", "lineart"],
     category="controlnet",
-    version="1.2.3",
+    version="1.2.2",
 )
 class LineartImageProcessorInvocation(ImageProcessorInvocation):
     """Applies line art processing to image"""
 
-    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
-    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    detect_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.image_res)
     coarse: bool = InputField(default=False, description="Whether to use coarse mode")
 
     def run_processor(self, image: Image.Image) -> Image.Image:
@@ -250,13 +256,13 @@ class LineartImageProcessorInvocation(ImageProcessorInvocation):
     title="Lineart Anime Processor",
     tags=["controlnet", "lineart", "anime"],
     category="controlnet",
-    version="1.2.3",
+    version="1.2.2",
 )
 class LineartAnimeImageProcessorInvocation(ImageProcessorInvocation):
     """Applies line art anime processing to image"""
 
-    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
-    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    detect_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.image_res)
 
     def run_processor(self, image: Image.Image) -> Image.Image:
         processor = LineartAnimeProcessor()
@@ -273,15 +279,15 @@ class LineartAnimeImageProcessorInvocation(ImageProcessorInvocation):
     title="Midas Depth Processor",
     tags=["controlnet", "midas"],
     category="controlnet",
-    version="1.2.4",
+    version="1.2.3",
 )
 class MidasDepthImageProcessorInvocation(ImageProcessorInvocation):
     """Applies Midas depth processing to image"""
 
     a_mult: float = InputField(default=2.0, ge=0, description="Midas parameter `a_mult` (a = a_mult * PI)")
     bg_th: float = InputField(default=0.1, ge=0, description="Midas parameter `bg_th`")
-    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
-    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    detect_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.image_res)
     # depth_and_normal not supported in controlnet_aux v0.0.3
     # depth_and_normal: bool = InputField(default=False, description="whether to use depth and normal mode")
 
@@ -304,13 +310,13 @@ class MidasDepthImageProcessorInvocation(ImageProcessorInvocation):
     title="Normal BAE Processor",
     tags=["controlnet"],
     category="controlnet",
-    version="1.2.3",
+    version="1.2.2",
 )
 class NormalbaeImageProcessorInvocation(ImageProcessorInvocation):
     """Applies NormalBae processing to image"""
 
-    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
-    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    detect_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.image_res)
 
     def run_processor(self, image):
         normalbae_processor = NormalBaeDetector.from_pretrained("lllyasviel/Annotators")
@@ -321,13 +327,13 @@ class NormalbaeImageProcessorInvocation(ImageProcessorInvocation):
 
 
 @invocation(
-    "mlsd_image_processor", title="MLSD Processor", tags=["controlnet", "mlsd"], category="controlnet", version="1.2.3"
+    "mlsd_image_processor", title="MLSD Processor", tags=["controlnet", "mlsd"], category="controlnet", version="1.2.2"
 )
 class MlsdImageProcessorInvocation(ImageProcessorInvocation):
     """Applies MLSD processing to image"""
 
-    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
-    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    detect_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.image_res)
     thr_v: float = InputField(default=0.1, ge=0, description="MLSD parameter `thr_v`")
     thr_d: float = InputField(default=0.1, ge=0, description="MLSD parameter `thr_d`")
 
@@ -344,13 +350,13 @@ class MlsdImageProcessorInvocation(ImageProcessorInvocation):
 
 
 @invocation(
-    "pidi_image_processor", title="PIDI Processor", tags=["controlnet", "pidi"], category="controlnet", version="1.2.3"
+    "pidi_image_processor", title="PIDI Processor", tags=["controlnet", "pidi"], category="controlnet", version="1.2.2"
 )
 class PidiImageProcessorInvocation(ImageProcessorInvocation):
     """Applies PIDI processing to image"""
 
-    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
-    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    detect_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.image_res)
     safe: bool = InputField(default=False, description=FieldDescriptions.safe_mode)
     scribble: bool = InputField(default=False, description=FieldDescriptions.scribble_mode)
 
@@ -371,13 +377,13 @@ class PidiImageProcessorInvocation(ImageProcessorInvocation):
     title="Content Shuffle Processor",
     tags=["controlnet", "contentshuffle"],
     category="controlnet",
-    version="1.2.3",
+    version="1.2.2",
 )
 class ContentShuffleImageProcessorInvocation(ImageProcessorInvocation):
     """Applies content shuffle processing to image"""
 
-    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
-    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    detect_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.image_res)
     h: int = InputField(default=512, ge=0, description="Content shuffle `h` parameter")
     w: int = InputField(default=512, ge=0, description="Content shuffle `w` parameter")
     f: int = InputField(default=256, ge=0, description="Content shuffle `f` parameter")
@@ -401,7 +407,7 @@ class ContentShuffleImageProcessorInvocation(ImageProcessorInvocation):
     title="Zoe (Depth) Processor",
     tags=["controlnet", "zoe", "depth"],
     category="controlnet",
-    version="1.2.3",
+    version="1.2.2",
 )
 class ZoeDepthImageProcessorInvocation(ImageProcessorInvocation):
     """Applies Zoe depth processing to image"""
@@ -417,15 +423,15 @@ class ZoeDepthImageProcessorInvocation(ImageProcessorInvocation):
     title="Mediapipe Face Processor",
     tags=["controlnet", "mediapipe", "face"],
     category="controlnet",
-    version="1.2.4",
+    version="1.2.3",
 )
 class MediapipeFaceProcessorInvocation(ImageProcessorInvocation):
     """Applies mediapipe face processing to image"""
 
     max_faces: int = InputField(default=1, ge=1, description="Maximum number of faces to detect")
     min_confidence: float = InputField(default=0.5, ge=0, le=1, description="Minimum confidence for face detection")
-    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
-    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    detect_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.image_res)
 
     def run_processor(self, image):
         mediapipe_face_processor = MediapipeFaceDetector()
@@ -444,7 +450,7 @@ class MediapipeFaceProcessorInvocation(ImageProcessorInvocation):
     title="Leres (Depth) Processor",
     tags=["controlnet", "leres", "depth"],
     category="controlnet",
-    version="1.2.3",
+    version="1.2.2",
 )
 class LeresImageProcessorInvocation(ImageProcessorInvocation):
     """Applies leres processing to image"""
@@ -452,8 +458,8 @@ class LeresImageProcessorInvocation(ImageProcessorInvocation):
     thr_a: float = InputField(default=0, description="Leres parameter `thr_a`")
     thr_b: float = InputField(default=0, description="Leres parameter `thr_b`")
     boost: bool = InputField(default=False, description="Whether to use boost mode")
-    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
-    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    detect_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.image_res)
 
     def run_processor(self, image):
         leres_processor = LeresDetector.from_pretrained("lllyasviel/Annotators")
@@ -473,7 +479,7 @@ class LeresImageProcessorInvocation(ImageProcessorInvocation):
     title="Tile Resample Processor",
     tags=["controlnet", "tile"],
     category="controlnet",
-    version="1.2.3",
+    version="1.2.2",
 )
 class TileResamplerProcessorInvocation(ImageProcessorInvocation):
     """Tile resampler processor"""
@@ -513,13 +519,13 @@ class TileResamplerProcessorInvocation(ImageProcessorInvocation):
     title="Segment Anything Processor",
     tags=["controlnet", "segmentanything"],
     category="controlnet",
-    version="1.2.4",
+    version="1.2.3",
 )
 class SegmentAnythingProcessorInvocation(ImageProcessorInvocation):
     """Applies segment anything processing to image"""
 
-    detect_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.detect_res)
-    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    detect_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.detect_res)
+    image_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.image_res)
 
     def run_processor(self, image):
         # segment_anything_processor = SamDetector.from_pretrained("ybelkada/segment-anything", subfolder="checkpoints")
@@ -560,12 +566,12 @@ class SamDetectorReproducibleColors(SamDetector):
     title="Color Map Processor",
     tags=["controlnet"],
     category="controlnet",
-    version="1.2.3",
+    version="1.2.2",
 )
 class ColorMapImageProcessorInvocation(ImageProcessorInvocation):
     """Generates a color map from the provided image"""
 
-    color_map_tile_size: int = InputField(default=64, ge=1, description=FieldDescriptions.tile_size)
+    color_map_tile_size: int = InputField(default=64, ge=0, description=FieldDescriptions.tile_size)
 
     def run_processor(self, image: Image.Image):
         np_image = np.array(image, dtype=np.uint8)
@@ -592,7 +598,7 @@ DEPTH_ANYTHING_MODEL_SIZES = Literal["large", "base", "small"]
     title="Depth Anything Processor",
     tags=["controlnet", "depth", "depth anything"],
     category="controlnet",
-    version="1.1.2",
+    version="1.1.1",
 )
 class DepthAnythingImageProcessorInvocation(ImageProcessorInvocation):
     """Generates a depth map based on the Depth Anything algorithm"""
@@ -600,7 +606,7 @@ class DepthAnythingImageProcessorInvocation(ImageProcessorInvocation):
     model_size: DEPTH_ANYTHING_MODEL_SIZES = InputField(
         default="small", description="The size of the depth model to use"
     )
-    resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    resolution: int = InputField(default=512, ge=64, multiple_of=64, description=FieldDescriptions.image_res)
 
     def run_processor(self, image: Image.Image):
         depth_anything_detector = DepthAnythingDetector()
@@ -615,7 +621,7 @@ class DepthAnythingImageProcessorInvocation(ImageProcessorInvocation):
     title="DW Openpose Image Processor",
     tags=["controlnet", "dwpose", "openpose"],
     category="controlnet",
-    version="1.1.1",
+    version="1.1.0",
 )
 class DWOpenposeImageProcessorInvocation(ImageProcessorInvocation):
     """Generates an openpose pose from an image using DWPose"""
@@ -623,7 +629,7 @@ class DWOpenposeImageProcessorInvocation(ImageProcessorInvocation):
     draw_body: bool = InputField(default=True)
     draw_face: bool = InputField(default=False)
     draw_hands: bool = InputField(default=False)
-    image_resolution: int = InputField(default=512, ge=1, description=FieldDescriptions.image_res)
+    image_resolution: int = InputField(default=512, ge=0, description=FieldDescriptions.image_res)
 
     def run_processor(self, image: Image.Image):
         dw_openpose = DWOpenposeDetector()
@@ -635,27 +641,3 @@ class DWOpenposeImageProcessorInvocation(ImageProcessorInvocation):
             resolution=self.image_resolution,
         )
         return processed_image
-
-
-@invocation(
-    "heuristic_resize",
-    title="Heuristic Resize",
-    tags=["image, controlnet"],
-    category="image",
-    version="1.0.1",
-    classification=Classification.Prototype,
-)
-class HeuristicResizeInvocation(BaseInvocation):
-    """Resize an image using a heuristic method. Preserves edge maps."""
-
-    image: ImageField = InputField(description="The image to resize")
-    width: int = InputField(default=512, ge=1, description="The width to resize to (px)")
-    height: int = InputField(default=512, ge=1, description="The height to resize to (px)")
-
-    def invoke(self, context: InvocationContext) -> ImageOutput:
-        image = context.images.get_pil(self.image.image_name, "RGB")
-        np_img = pil_to_np(image)
-        np_resized = heuristic_resize(np_img, (self.width, self.height))
-        resized = np_to_pil(np_resized)
-        image_dto = context.images.save(image=resized)
-        return ImageOutput.build(image_dto)

invokeai/app/invocations/image.py

@@ -1,5 +1,6 @@
 # Copyright (c) 2022 Kyle Schouviller (https://github.com/kyle0654)
 
+from pathlib import Path
 from typing import Literal, Optional
 
 import cv2
@@ -503,7 +504,7 @@ class ImageInverseLerpInvocation(BaseInvocation, WithMetadata, WithBoard):
     title="Blur NSFW Image",
     tags=["image", "nsfw"],
     category="image",
-    version="1.2.3",
+    version="1.2.2",
 )
 class ImageNSFWBlurInvocation(BaseInvocation, WithMetadata, WithBoard):
     """Add blur to NSFW-flagged images"""
@@ -515,12 +516,23 @@ class ImageNSFWBlurInvocation(BaseInvocation, WithMetadata, WithBoard):
 
         logger = context.logger
         logger.debug("Running NSFW checker")
-        image = SafetyChecker.blur_if_nsfw(image)
+        if SafetyChecker.has_nsfw_concept(image):
+            logger.info("A potentially NSFW image has been detected. Image will be blurred.")
+            blurry_image = image.filter(filter=ImageFilter.GaussianBlur(radius=32))
+            caution = self._get_caution_img()
+            blurry_image.paste(caution, (0, 0), caution)
+            image = blurry_image
 
         image_dto = context.images.save(image=image)
 
         return ImageOutput.build(image_dto)
 
+    def _get_caution_img(self) -> Image.Image:
+        import invokeai.app.assets.images as image_assets
+
+        caution = Image.open(Path(image_assets.__path__[0]) / "caution.png")
+        return caution.resize((caution.width // 2, caution.height // 2))
+
 
 @invocation(
     "img_watermark",

invokeai/app/invocations/ip_adapter.py

@@ -4,8 +4,20 @@ from typing import List, Literal, Optional, Union
 from pydantic import BaseModel, Field, field_validator, model_validator
 from typing_extensions import Self
 
-from invokeai.app.invocations.baseinvocation import BaseInvocation, BaseInvocationOutput, invocation, invocation_output
-from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField, TensorField, UIType
+from invokeai.app.invocations.baseinvocation import (
+    BaseInvocation,
+    BaseInvocationOutput,
+    invocation,
+    invocation_output,
+)
+from invokeai.app.invocations.fields import (
+    FieldDescriptions,
+    Input,
+    InputField,
+    OutputField,
+    TensorField,
+    UIType,
+)
 from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.invocations.primitives import ImageField
 from invokeai.app.invocations.util import validate_begin_end_step, validate_weights
@@ -24,7 +36,6 @@ class IPAdapterField(BaseModel):
     ip_adapter_model: ModelIdentifierField = Field(description="The IP-Adapter model to use.")
     image_encoder_model: ModelIdentifierField = Field(description="The name of the CLIP image encoder model.")
     weight: Union[float, List[float]] = Field(default=1, description="The weight given to the IP-Adapter.")
-    target_blocks: List[str] = Field(default=[], description="The IP Adapter blocks to apply")
     begin_step_percent: float = Field(
         default=0, ge=0, le=1, description="When the IP-Adapter is first applied (% of total steps)"
     )
@@ -58,7 +69,7 @@ class IPAdapterOutput(BaseInvocationOutput):
 CLIP_VISION_MODEL_MAP = {"ViT-H": "ip_adapter_sd_image_encoder", "ViT-G": "ip_adapter_sdxl_image_encoder"}
 
 
-@invocation("ip_adapter", title="IP-Adapter", tags=["ip_adapter", "control"], category="ip_adapter", version="1.4.0")
+@invocation("ip_adapter", title="IP-Adapter", tags=["ip_adapter", "control"], category="ip_adapter", version="1.3.0")
 class IPAdapterInvocation(BaseInvocation):
     """Collects IP-Adapter info to pass to other nodes."""
 
@@ -79,9 +90,6 @@ class IPAdapterInvocation(BaseInvocation):
     weight: Union[float, List[float]] = InputField(
         default=1, description="The weight given to the IP-Adapter", title="Weight"
     )
-    method: Literal["full", "style", "composition"] = InputField(
-        default="full", description="The method to apply the IP-Adapter"
-    )
     begin_step_percent: float = InputField(
         default=0, ge=0, le=1, description="When the IP-Adapter is first applied (% of total steps)"
     )
@@ -116,32 +124,12 @@ class IPAdapterInvocation(BaseInvocation):
 
         image_encoder_model = self._get_image_encoder(context, image_encoder_model_name)
 
-        if self.method == "style":
-            if ip_adapter_info.base == "sd-1":
-                target_blocks = ["up_blocks.1"]
-            elif ip_adapter_info.base == "sdxl":
-                target_blocks = ["up_blocks.0.attentions.1"]
-            else:
-                raise ValueError(f"Unsupported IP-Adapter base type: '{ip_adapter_info.base}'.")
-        elif self.method == "composition":
-            if ip_adapter_info.base == "sd-1":
-                target_blocks = ["down_blocks.2", "mid_block"]
-            elif ip_adapter_info.base == "sdxl":
-                target_blocks = ["down_blocks.2.attentions.1"]
-            else:
-                raise ValueError(f"Unsupported IP-Adapter base type: '{ip_adapter_info.base}'.")
-        elif self.method == "full":
-            target_blocks = ["block"]
-        else:
-            raise ValueError(f"Unexpected IP-Adapter method: '{self.method}'.")
-
         return IPAdapterOutput(
             ip_adapter=IPAdapterField(
                 image=self.image,
                 ip_adapter_model=self.ip_adapter_model,
                 image_encoder_model=ModelIdentifierField.from_config(image_encoder_model),
                 weight=self.weight,
-                target_blocks=target_blocks,
                 begin_step_percent=self.begin_step_percent,
                 end_step_percent=self.end_step_percent,
                 mask=self.mask,

invokeai/app/invocations/latent.py

@@ -3,7 +3,7 @@ import inspect
 import math
 from contextlib import ExitStack
 from functools import singledispatchmethod
-from typing import Any, Dict, Iterator, List, Literal, Optional, Tuple, Union
+from typing import Any, Iterator, List, Literal, Optional, Tuple, Union
 
 import einops
 import numpy as np
@@ -11,6 +11,7 @@ import numpy.typing as npt
 import torch
 import torchvision
 import torchvision.transforms as T
+from diffusers import AutoencoderKL, AutoencoderTiny
 from diffusers.configuration_utils import ConfigMixin
 from diffusers.image_processor import VaeImageProcessor
 from diffusers.models.adapter import T2IAdapter
@@ -20,12 +21,9 @@ from diffusers.models.attention_processor import (
     LoRAXFormersAttnProcessor,
     XFormersAttnProcessor,
 )
-from diffusers.models.autoencoders.autoencoder_kl import AutoencoderKL
-from diffusers.models.autoencoders.autoencoder_tiny import AutoencoderTiny
 from diffusers.models.unets.unet_2d_condition import UNet2DConditionModel
-from diffusers.schedulers.scheduling_dpmsolver_sde import DPMSolverSDEScheduler
-from diffusers.schedulers.scheduling_tcd import TCDScheduler
-from diffusers.schedulers.scheduling_utils import SchedulerMixin as Scheduler
+from diffusers.schedulers import DPMSolverSDEScheduler
+from diffusers.schedulers import SchedulerMixin as Scheduler
 from PIL import Image, ImageFilter
 from pydantic import field_validator
 from torchvision.transforms.functional import resize as tv_resize
@@ -53,7 +51,6 @@ from invokeai.app.util.controlnet_utils import prepare_control_image
 from invokeai.backend.ip_adapter.ip_adapter import IPAdapter, IPAdapterPlus
 from invokeai.backend.lora import LoRAModelRaw
 from invokeai.backend.model_manager import BaseModelType, LoadedModel
-from invokeai.backend.model_manager.config import MainConfigBase, ModelVariantType
 from invokeai.backend.model_patcher import ModelPatcher
 from invokeai.backend.stable_diffusion import PipelineIntermediateState, set_seamless
 from invokeai.backend.stable_diffusion.diffusion.conditioning_data import (
@@ -75,12 +72,15 @@ from ...backend.stable_diffusion.diffusers_pipeline import (
     image_resized_to_grid_as_tensor,
 )
 from ...backend.stable_diffusion.schedulers import SCHEDULER_MAP
-from ...backend.util.devices import TorchDevice
+from ...backend.util.devices import choose_precision, choose_torch_device
 from .baseinvocation import BaseInvocation, BaseInvocationOutput, invocation, invocation_output
 from .controlnet_image_processors import ControlField
 from .model import ModelIdentifierField, UNetField, VAEField
 
-DEFAULT_PRECISION = TorchDevice.choose_torch_dtype()
+if choose_torch_device() == torch.device("mps"):
+    from torch import mps
+
+DEFAULT_PRECISION = choose_precision(choose_torch_device())
 
 
 @invocation_output("scheduler_output")
@@ -188,7 +188,7 @@ class GradientMaskOutput(BaseInvocationOutput):
     title="Create Gradient Mask",
     tags=["mask", "denoise"],
     category="latents",
-    version="1.1.0",
+    version="1.0.0",
 )
 class CreateGradientMaskInvocation(BaseInvocation):
     """Creates mask for denoising model run."""
@@ -201,32 +201,6 @@ class CreateGradientMaskInvocation(BaseInvocation):
     minimum_denoise: float = InputField(
         default=0.0, ge=0, le=1, description="Minimum denoise level for the coherence region", ui_order=4
     )
-    image: Optional[ImageField] = InputField(
-        default=None,
-        description="OPTIONAL: Only connect for specialized Inpainting models, masked_latents will be generated from the image with the VAE",
-        title="[OPTIONAL] Image",
-        ui_order=6,
-    )
-    unet: Optional[UNetField] = InputField(
-        description="OPTIONAL: If the Unet is a specialized Inpainting model, masked_latents will be generated from the image with the VAE",
-        default=None,
-        input=Input.Connection,
-        title="[OPTIONAL] UNet",
-        ui_order=5,
-    )
-    vae: Optional[VAEField] = InputField(
-        default=None,
-        description="OPTIONAL: Only connect for specialized Inpainting models, masked_latents will be generated from the image with the VAE",
-        title="[OPTIONAL] VAE",
-        input=Input.Connection,
-        ui_order=7,
-    )
-    tiled: bool = InputField(default=False, description=FieldDescriptions.tiled, ui_order=8)
-    fp32: bool = InputField(
-        default=DEFAULT_PRECISION == "float32",
-        description=FieldDescriptions.fp32,
-        ui_order=9,
-    )
 
     @torch.no_grad()
     def invoke(self, context: InvocationContext) -> GradientMaskOutput:
@@ -262,27 +236,8 @@ class CreateGradientMaskInvocation(BaseInvocation):
         expanded_mask_image = Image.fromarray((expanded_mask.squeeze(0).numpy() * 255).astype(np.uint8), mode="L")
         expanded_image_dto = context.images.save(expanded_mask_image)
 
-        masked_latents_name = None
-        if self.unet is not None and self.vae is not None and self.image is not None:
-            # all three fields must be present at the same time
-            main_model_config = context.models.get_config(self.unet.unet.key)
-            assert isinstance(main_model_config, MainConfigBase)
-            if main_model_config.variant is ModelVariantType.Inpaint:
-                mask = blur_tensor
-                vae_info: LoadedModel = context.models.load(self.vae.vae)
-                image = context.images.get_pil(self.image.image_name)
-                image_tensor = image_resized_to_grid_as_tensor(image.convert("RGB"))
-                if image_tensor.dim() == 3:
-                    image_tensor = image_tensor.unsqueeze(0)
-                img_mask = tv_resize(mask, image_tensor.shape[-2:], T.InterpolationMode.BILINEAR, antialias=False)
-                masked_image = image_tensor * torch.where(img_mask < 0.5, 0.0, 1.0)
-                masked_latents = ImageToLatentsInvocation.vae_encode(
-                    vae_info, self.fp32, self.tiled, masked_image.clone()
-                )
-                masked_latents_name = context.tensors.save(tensor=masked_latents)
-
         return GradientMaskOutput(
-            denoise_mask=DenoiseMaskField(mask_name=mask_name, masked_latents_name=masked_latents_name, gradient=True),
+            denoise_mask=DenoiseMaskField(mask_name=mask_name, masked_latents_name=None, gradient=True),
             expanded_mask_area=ImageField(image_name=expanded_image_dto.image_name),
         )
 
@@ -343,7 +298,7 @@ class DenoiseLatentsInvocation(BaseInvocation):
     )
     steps: int = InputField(default=10, gt=0, description=FieldDescriptions.steps)
     cfg_scale: Union[float, List[float]] = InputField(
-        default=7.5, description=FieldDescriptions.cfg_scale, title="CFG Scale"
+        default=7.5, ge=1, description=FieldDescriptions.cfg_scale, title="CFG Scale"
     )
     denoising_start: float = InputField(
         default=0.0,
@@ -523,10 +478,9 @@ class DenoiseLatentsInvocation(BaseInvocation):
             )
 
         if is_sdxl:
-            return (
-                SDXLConditioningInfo(embeds=text_embedding, pooled_embeds=pooled_embedding, add_time_ids=add_time_ids),
-                regions,
-            )
+            return SDXLConditioningInfo(
+                embeds=text_embedding, pooled_embeds=pooled_embedding, add_time_ids=add_time_ids
+            ), regions
         return BasicConditioningInfo(embeds=text_embedding), regions
 
     def get_conditioning_data(
@@ -566,11 +520,6 @@ class DenoiseLatentsInvocation(BaseInvocation):
             dtype=unet.dtype,
         )
 
-        if isinstance(self.cfg_scale, list):
-            assert (
-                len(self.cfg_scale) == self.steps
-            ), "cfg_scale (list) must have the same length as the number of steps"
-
         conditioning_data = TextConditioningData(
             uncond_text=uncond_text_embedding,
             cond_text=cond_text_embedding,
@@ -586,6 +535,13 @@ class DenoiseLatentsInvocation(BaseInvocation):
         unet: UNet2DConditionModel,
         scheduler: Scheduler,
     ) -> StableDiffusionGeneratorPipeline:
+        # TODO:
+        # configure_model_padding(
+        #    unet,
+        #    self.seamless,
+        #    self.seamless_axes,
+        # )
+
         class FakeVae:
             class FakeVaeConfig:
                 def __init__(self) -> None:
@@ -726,7 +682,6 @@ class DenoiseLatentsInvocation(BaseInvocation):
                 IPAdapterData(
                     ip_adapter_model=ip_adapter_model,
                     weight=single_ip_adapter.weight,
-                    target_blocks=single_ip_adapter.target_blocks,
                     begin_step_percent=single_ip_adapter.begin_step_percent,
                     end_step_percent=single_ip_adapter.end_step_percent,
                     ip_adapter_conditioning=IPAdapterConditioningInfo(image_prompt_embeds, uncond_image_prompt_embeds),
@@ -821,7 +776,7 @@ class DenoiseLatentsInvocation(BaseInvocation):
         denoising_start: float,
         denoising_end: float,
         seed: int,
-    ) -> Tuple[int, List[int], int, Dict[str, Any]]:
+    ) -> Tuple[int, List[int], int]:
         assert isinstance(scheduler, ConfigMixin)
         if scheduler.config.get("cpu_only", False):
             scheduler.set_timesteps(steps, device="cpu")
@@ -849,15 +804,13 @@ class DenoiseLatentsInvocation(BaseInvocation):
         timesteps = timesteps[t_start_idx : t_start_idx + t_end_idx]
         num_inference_steps = len(timesteps) // scheduler.order
 
-        scheduler_step_kwargs: Dict[str, Any] = {}
+        scheduler_step_kwargs = {}
         scheduler_step_signature = inspect.signature(scheduler.step)
         if "generator" in scheduler_step_signature.parameters:
             # At some point, someone decided that schedulers that accept a generator should use the original seed with
             # all bits flipped. I don't know the original rationale for this, but now we must keep it like this for
             # reproducibility.
-            scheduler_step_kwargs.update({"generator": torch.Generator(device=device).manual_seed(seed ^ 0xFFFFFFFF)})
-        if isinstance(scheduler, TCDScheduler):
-            scheduler_step_kwargs.update({"eta": 1.0})
+            scheduler_step_kwargs = {"generator": torch.Generator(device=device).manual_seed(seed ^ 0xFFFFFFFF)}
 
         return num_inference_steps, timesteps, init_timestep, scheduler_step_kwargs
 
@@ -1006,7 +959,9 @@ class DenoiseLatentsInvocation(BaseInvocation):
 
             # https://discuss.huggingface.co/t/memory-usage-by-later-pipeline-stages/23699
             result_latents = result_latents.to("cpu")
-            TorchDevice.empty_cache()
+            torch.cuda.empty_cache()
+            if choose_torch_device() == torch.device("mps"):
+                mps.empty_cache()
 
             name = context.tensors.save(tensor=result_latents)
         return LatentsOutput.build(latents_name=name, latents=result_latents, seed=None)
@@ -1073,7 +1028,9 @@ class LatentsToImageInvocation(BaseInvocation, WithMetadata, WithBoard):
                 vae.disable_tiling()
 
             # clear memory as vae decode can request a lot
-            TorchDevice.empty_cache()
+            torch.cuda.empty_cache()
+            if choose_torch_device() == torch.device("mps"):
+                mps.empty_cache()
 
             with torch.inference_mode():
                 # copied from diffusers pipeline
@@ -1085,7 +1042,9 @@ class LatentsToImageInvocation(BaseInvocation, WithMetadata, WithBoard):
 
                 image = VaeImageProcessor.numpy_to_pil(np_image)[0]
 
-        TorchDevice.empty_cache()
+        torch.cuda.empty_cache()
+        if choose_torch_device() == torch.device("mps"):
+            mps.empty_cache()
 
         image_dto = context.images.save(image=image)
 
@@ -1124,7 +1083,9 @@ class ResizeLatentsInvocation(BaseInvocation):
 
     def invoke(self, context: InvocationContext) -> LatentsOutput:
         latents = context.tensors.load(self.latents.latents_name)
-        device = TorchDevice.choose_torch_device()
+
+        # TODO:
+        device = choose_torch_device()
 
         resized_latents = torch.nn.functional.interpolate(
             latents.to(device),
@@ -1135,8 +1096,9 @@ class ResizeLatentsInvocation(BaseInvocation):
 
         # https://discuss.huggingface.co/t/memory-usage-by-later-pipeline-stages/23699
         resized_latents = resized_latents.to("cpu")
-
-        TorchDevice.empty_cache()
+        torch.cuda.empty_cache()
+        if device == torch.device("mps"):
+            mps.empty_cache()
 
         name = context.tensors.save(tensor=resized_latents)
         return LatentsOutput.build(latents_name=name, latents=resized_latents, seed=self.latents.seed)
@@ -1163,7 +1125,8 @@ class ScaleLatentsInvocation(BaseInvocation):
     def invoke(self, context: InvocationContext) -> LatentsOutput:
         latents = context.tensors.load(self.latents.latents_name)
 
-        device = TorchDevice.choose_torch_device()
+        # TODO:
+        device = choose_torch_device()
 
         # resizing
         resized_latents = torch.nn.functional.interpolate(
@@ -1175,7 +1138,9 @@ class ScaleLatentsInvocation(BaseInvocation):
 
         # https://discuss.huggingface.co/t/memory-usage-by-later-pipeline-stages/23699
         resized_latents = resized_latents.to("cpu")
-        TorchDevice.empty_cache()
+        torch.cuda.empty_cache()
+        if device == torch.device("mps"):
+            mps.empty_cache()
 
         name = context.tensors.save(tensor=resized_latents)
         return LatentsOutput.build(latents_name=name, latents=resized_latents, seed=self.latents.seed)
@@ -1307,7 +1272,8 @@ class BlendLatentsInvocation(BaseInvocation):
         if latents_a.shape != latents_b.shape:
             raise Exception("Latents to blend must be the same size.")
 
-        device = TorchDevice.choose_torch_device()
+        # TODO:
+        device = choose_torch_device()
 
         def slerp(
             t: Union[float, npt.NDArray[Any]],  # FIXME: maybe use np.float32 here?
@@ -1360,8 +1326,9 @@ class BlendLatentsInvocation(BaseInvocation):
 
         # https://discuss.huggingface.co/t/memory-usage-by-later-pipeline-stages/23699
         blended_latents = blended_latents.to("cpu")
-
-        TorchDevice.empty_cache()
+        torch.cuda.empty_cache()
+        if device == torch.device("mps"):
+            mps.empty_cache()
 
         name = context.tensors.save(tensor=blended_latents)
         return LatentsOutput.build(latents_name=name, latents=blended_latents)

invokeai/app/invocations/mask.py

@@ -1,8 +1,7 @@
-import numpy as np
 import torch
 
-from invokeai.app.invocations.baseinvocation import BaseInvocation, Classification, InvocationContext, invocation
-from invokeai.app.invocations.fields import ImageField, InputField, TensorField, WithMetadata
+from invokeai.app.invocations.baseinvocation import BaseInvocation, InvocationContext, invocation
+from invokeai.app.invocations.fields import InputField, TensorField, WithMetadata
 from invokeai.app.invocations.primitives import MaskOutput
 
 
@@ -35,86 +34,3 @@ class RectangleMaskInvocation(BaseInvocation, WithMetadata):
             width=self.width,
             height=self.height,
         )
-
-
-@invocation(
-    "alpha_mask_to_tensor",
-    title="Alpha Mask to Tensor",
-    tags=["conditioning"],
-    category="conditioning",
-    version="1.0.0",
-    classification=Classification.Beta,
-)
-class AlphaMaskToTensorInvocation(BaseInvocation):
-    """Convert a mask image to a tensor. Opaque regions are 1 and transparent regions are 0."""
-
-    image: ImageField = InputField(description="The mask image to convert.")
-    invert: bool = InputField(default=False, description="Whether to invert the mask.")
-
-    def invoke(self, context: InvocationContext) -> MaskOutput:
-        image = context.images.get_pil(self.image.image_name)
-        mask = torch.zeros((1, image.height, image.width), dtype=torch.bool)
-        if self.invert:
-            mask[0] = torch.tensor(np.array(image)[:, :, 3] == 0, dtype=torch.bool)
-        else:
-            mask[0] = torch.tensor(np.array(image)[:, :, 3] > 0, dtype=torch.bool)
-
-        return MaskOutput(
-            mask=TensorField(tensor_name=context.tensors.save(mask)),
-            height=mask.shape[1],
-            width=mask.shape[2],
-        )
-
-
-@invocation(
-    "invert_tensor_mask",
-    title="Invert Tensor Mask",
-    tags=["conditioning"],
-    category="conditioning",
-    version="1.0.0",
-    classification=Classification.Beta,
-)
-class InvertTensorMaskInvocation(BaseInvocation):
-    """Inverts a tensor mask."""
-
-    mask: TensorField = InputField(description="The tensor mask to convert.")
-
-    def invoke(self, context: InvocationContext) -> MaskOutput:
-        mask = context.tensors.load(self.mask.tensor_name)
-        inverted = ~mask
-
-        return MaskOutput(
-            mask=TensorField(tensor_name=context.tensors.save(inverted)),
-            height=inverted.shape[1],
-            width=inverted.shape[2],
-        )
-
-
-@invocation(
-    "image_mask_to_tensor",
-    title="Image Mask to Tensor",
-    tags=["conditioning"],
-    category="conditioning",
-    version="1.0.0",
-)
-class ImageMaskToTensorInvocation(BaseInvocation, WithMetadata):
-    """Convert a mask image to a tensor. Converts the image to grayscale and uses thresholding at the specified value."""
-
-    image: ImageField = InputField(description="The mask image to convert.")
-    cutoff: int = InputField(ge=0, le=255, description="Cutoff (<)", default=128)
-    invert: bool = InputField(default=False, description="Whether to invert the mask.")
-
-    def invoke(self, context: InvocationContext) -> MaskOutput:
-        image = context.images.get_pil(self.image.image_name, mode="L")
-
-        mask = torch.zeros((1, image.height, image.width), dtype=torch.bool)
-        if self.invert:
-            mask[0] = torch.tensor(np.array(image)[:, :] >= self.cutoff, dtype=torch.bool)
-        else:
-            mask[0] = torch.tensor(np.array(image)[:, :] < self.cutoff, dtype=torch.bool)
-
-        return MaskOutput(
-            mask=TensorField(tensor_name=context.tensors.save(mask)),
-            height=mask.shape[1],
-            width=mask.shape[2],
-        )

invokeai/app/invocations/metadata.py

@@ -3,6 +3,7 @@ from typing import Any, Literal, Optional, Union
 from pydantic import BaseModel, ConfigDict, Field
 
 from invokeai.app.invocations.baseinvocation import BaseInvocation, BaseInvocationOutput, invocation, invocation_output
+from invokeai.app.invocations.controlnet_image_processors import CONTROLNET_MODE_VALUES, CONTROLNET_RESIZE_VALUES
 from invokeai.app.invocations.fields import (
     FieldDescriptions,
     ImageField,
@@ -13,7 +14,6 @@ from invokeai.app.invocations.fields import (
 )
 from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.app.util.controlnet_utils import CONTROLNET_MODE_VALUES, CONTROLNET_RESIZE_VALUES
 
 from ...version import __version__
 
@@ -36,7 +36,6 @@ class IPAdapterMetadataField(BaseModel):
     image: ImageField = Field(description="The IP-Adapter image prompt.")
     ip_adapter_model: ModelIdentifierField = Field(description="The IP-Adapter model.")
     clip_vision_model: Literal["ViT-H", "ViT-G"] = Field(description="The CLIP Vision model")
-    method: Literal["full", "style", "composition"] = Field(description="Method to apply IP Weights with")
     weight: Union[float, list[float]] = Field(description="The weight given to the IP-Adapter")
     begin_step_percent: float = Field(description="When the IP-Adapter is first applied (% of total steps)")
     end_step_percent: float = Field(description="When the IP-Adapter is last applied (% of total steps)")

invokeai/app/invocations/noise.py

@@ -9,7 +9,7 @@ from invokeai.app.invocations.fields import FieldDescriptions, InputField, Laten
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.util.misc import SEED_MAX
 
-from ...backend.util.devices import TorchDevice
+from ...backend.util.devices import choose_torch_device, torch_dtype
 from .baseinvocation import (
     BaseInvocation,
     BaseInvocationOutput,
@@ -46,7 +46,7 @@ def get_noise(
             height // downsampling_factor,
             width // downsampling_factor,
         ],
-        dtype=TorchDevice.choose_torch_dtype(device=device),
+        dtype=torch_dtype(device),
         device=noise_device_type,
         generator=generator,
     ).to("cpu")
@@ -111,14 +111,14 @@ class NoiseInvocation(BaseInvocation):
 
     @field_validator("seed", mode="before")
     def modulo_seed(cls, v):
-        """Return the seed modulo (SEED_MAX + 1) to ensure it is within the valid range."""
+        """Returns the seed modulo (SEED_MAX + 1) to ensure it is within the valid range."""
         return v % (SEED_MAX + 1)
 
     def invoke(self, context: InvocationContext) -> NoiseOutput:
         noise = get_noise(
             width=self.width,
             height=self.height,
-            device=TorchDevice.choose_torch_device(),
+            device=choose_torch_device(),
             seed=self.seed,
             use_cpu=self.use_cpu,
         )

invokeai/app/invocations/t2i_adapter.py

@@ -8,11 +8,11 @@ from invokeai.app.invocations.baseinvocation import (
     invocation,
     invocation_output,
 )
+from invokeai.app.invocations.controlnet_image_processors import CONTROLNET_RESIZE_VALUES
 from invokeai.app.invocations.fields import FieldDescriptions, ImageField, Input, InputField, OutputField, UIType
 from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.invocations.util import validate_begin_end_step, validate_weights
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.app.util.controlnet_utils import CONTROLNET_RESIZE_VALUES
 
 
 class T2IAdapterField(BaseModel):

invokeai/app/invocations/upscale.py

@@ -4,6 +4,7 @@ from typing import Literal
 
 import cv2
 import numpy as np
+import torch
 from PIL import Image
 from pydantic import ConfigDict
 
@@ -13,7 +14,7 @@ from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.util.download_with_progress import download_with_progress_bar
 from invokeai.backend.image_util.basicsr.rrdbnet_arch import RRDBNet
 from invokeai.backend.image_util.realesrgan.realesrgan import RealESRGAN
-from invokeai.backend.util.devices import TorchDevice
+from invokeai.backend.util.devices import choose_torch_device
 
 from .baseinvocation import BaseInvocation, invocation
 from .fields import InputField, WithBoard, WithMetadata
@@ -34,6 +35,9 @@ ESRGAN_MODEL_URLS: dict[str, str] = {
     "RealESRGAN_x2plus.pth": "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.1/RealESRGAN_x2plus.pth",
 }
 
+if choose_torch_device() == torch.device("mps"):
+    from torch import mps
+
 
 @invocation("esrgan", title="Upscale (RealESRGAN)", tags=["esrgan", "upscale"], category="esrgan", version="1.3.2")
 class ESRGANInvocation(BaseInvocation, WithMetadata, WithBoard):
@@ -116,7 +120,9 @@ class ESRGANInvocation(BaseInvocation, WithMetadata, WithBoard):
         upscaled_image = upscaler.upscale(cv2_image)
         pil_image = Image.fromarray(cv2.cvtColor(upscaled_image, cv2.COLOR_BGR2RGB)).convert("RGBA")
 
-        TorchDevice.empty_cache()
+        torch.cuda.empty_cache()
+        if choose_torch_device() == torch.device("mps"):
+            mps.empty_cache()
 
         image_dto = context.images.save(image=pil_image)
 

invokeai/app/services/config/config_default.py

@@ -27,12 +27,12 @@ DEFAULT_RAM_CACHE = 10.0
 DEFAULT_VRAM_CACHE = 0.25
 DEFAULT_CONVERT_CACHE = 20.0
 DEVICE = Literal["auto", "cpu", "cuda", "cuda:1", "mps"]
-PRECISION = Literal["auto", "float16", "bfloat16", "float32"]
+PRECISION = Literal["auto", "float16", "bfloat16", "float32", "autocast"]
 ATTENTION_TYPE = Literal["auto", "normal", "xformers", "sliced", "torch-sdp"]
 ATTENTION_SLICE_SIZE = Literal["auto", "balanced", "max", 1, 2, 3, 4, 5, 6, 7, 8]
 LOG_FORMAT = Literal["plain", "color", "syslog", "legacy"]
 LOG_LEVEL = Literal["debug", "info", "warning", "error", "critical"]
-CONFIG_SCHEMA_VERSION = "4.0.1"
+CONFIG_SCHEMA_VERSION = "4.0.0"
 
 
 def get_default_ram_cache_size() -> float:
@@ -105,7 +105,7 @@ class InvokeAIAppConfig(BaseSettings):
         lazy_offload: Keep models in VRAM until their space is needed.
         log_memory_usage: If True, a memory snapshot will be captured before and after every model cache operation, and the result will be logged (at debug level). There is a time cost to capturing the memory snapshots, so it is recommended to only enable this feature if you are actively inspecting the model cache's behaviour.
         device: Preferred execution device. `auto` will choose the device depending on the hardware platform and the installed torch capabilities.<br>Valid values: `auto`, `cpu`, `cuda`, `cuda:1`, `mps`
-        precision: Floating point precision. `float16` will consume half the memory of `float32` but produce slightly lower-quality images. The `auto` setting will guess the proper precision based on your video card and operating system.<br>Valid values: `auto`, `float16`, `bfloat16`, `float32`
+        precision: Floating point precision. `float16` will consume half the memory of `float32` but produce slightly lower-quality images. The `auto` setting will guess the proper precision based on your video card and operating system.<br>Valid values: `auto`, `float16`, `bfloat16`, `float32`, `autocast`
         sequential_guidance: Whether to calculate guidance in serial instead of in parallel, lowering memory requirements.
         attention_type: Attention type.<br>Valid values: `auto`, `normal`, `xformers`, `sliced`, `torch-sdp`
         attention_slice_size: Slice size, valid when attention_type=="sliced".<br>Valid values: `auto`, `balanced`, `max`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`
@@ -370,9 +370,6 @@ def migrate_v3_config_dict(config_dict: dict[str, Any]) -> InvokeAIAppConfig:
             # `max_vram_cache_size` was renamed to `vram` some time in v3, but both names were used
             if k == "max_vram_cache_size" and "vram" not in category_dict:
                 parsed_config_dict["vram"] = v
-            # autocast was removed in v4.0.1
-            if k == "precision" and v == "autocast":
-                parsed_config_dict["precision"] = "auto"
             if k == "conf_path":
                 parsed_config_dict["legacy_models_yaml_path"] = v
             if k == "legacy_conf_dir":
@@ -395,28 +392,6 @@ def migrate_v3_config_dict(config_dict: dict[str, Any]) -> InvokeAIAppConfig:
     return config
 
 
-def migrate_v4_0_0_config_dict(config_dict: dict[str, Any]) -> InvokeAIAppConfig:
-    """Migrate v4.0.0 config dictionary to a current config object.
-
-    Args:
-        config_dict: A dictionary of settings from a v4.0.0 config file.
-
-    Returns:
-        An instance of `InvokeAIAppConfig` with the migrated settings.
-    """
-    parsed_config_dict: dict[str, Any] = {}
-    for k, v in config_dict.items():
-        # autocast was removed from precision in v4.0.1
-        if k == "precision" and v == "autocast":
-            parsed_config_dict["precision"] = "auto"
-        else:
-            parsed_config_dict[k] = v
-        if k == "schema_version":
-            parsed_config_dict[k] = CONFIG_SCHEMA_VERSION
-    config = DefaultInvokeAIAppConfig.model_validate(parsed_config_dict)
-    return config
-
-
 def load_and_migrate_config(config_path: Path) -> InvokeAIAppConfig:
     """Load and migrate a config file to the latest version.
 
@@ -443,21 +418,17 @@ def load_and_migrate_config(config_path: Path) -> InvokeAIAppConfig:
             raise RuntimeError(f"Failed to load and migrate v3 config file {config_path}: {e}") from e
         migrated_config.write_file(config_path)
         return migrated_config
-
-    if loaded_config_dict["schema_version"] == "4.0.0":
-        loaded_config_dict = migrate_v4_0_0_config_dict(loaded_config_dict)
-        loaded_config_dict.write_file(config_path)
-
-    # Attempt to load as a v4 config file
-    try:
-        # Meta is not included in the model fields, so we need to validate it separately
-        config = InvokeAIAppConfig.model_validate(loaded_config_dict)
-        assert (
-            config.schema_version == CONFIG_SCHEMA_VERSION
-        ), f"Invalid schema version, expected {CONFIG_SCHEMA_VERSION}: {config.schema_version}"
-        return config
-    except Exception as e:
-        raise RuntimeError(f"Failed to load config file {config_path}: {e}") from e
+    else:
+        # Attempt to load as a v4 config file
+        try:
+            # Meta is not included in the model fields, so we need to validate it separately
+            config = InvokeAIAppConfig.model_validate(loaded_config_dict)
+            assert (
+                config.schema_version == CONFIG_SCHEMA_VERSION
+            ), f"Invalid schema version, expected {CONFIG_SCHEMA_VERSION}: {config.schema_version}"
+            return config
+        except Exception as e:
+            raise RuntimeError(f"Failed to load config file {config_path}: {e}") from e
 
 
 @lru_cache(maxsize=1)

invokeai/app/services/download/download_default.py

@@ -270,7 +270,7 @@ class DownloadQueueService(DownloadQueueServiceBase):
             job.dest.parent.mkdir(parents=True, exist_ok=True)
             job.download_path = job.dest
 
-        assert job.download_path
+        assert job.download_path is not None
 
         # Don't clobber an existing file. See commit 82c2c85202f88c6d24ff84710f297cfc6ae174af
         # for code that instead resumes an interrupted download.
@@ -280,6 +280,9 @@ class DownloadQueueService(DownloadQueueServiceBase):
         # append ".downloading" to the path
         in_progress_path = self._in_progress_path(job.download_path)
 
+        # catch rare race condition that is appearing in unit tests.
+        assert in_progress_path.parent.exists(), f"Directory doesn't exist! in_progress_path={in_progress_path}; parent={in_progress_path.parent}"
+
         # signal caller that the download is starting. At this point, key fields such as
         # download_path and total_bytes will be populated. We call it here because the might
         # discover that the local file is already complete and generate a COMPLETED status.
@@ -318,8 +321,10 @@ class DownloadQueueService(DownloadQueueServiceBase):
         in_progress_path.rename(job.download_path)
 
     def _validate_filename(self, directory: str, filename: str) -> bool:
-        pc_name_max = get_pc_name_max(directory)
-        pc_path_max = get_pc_path_max(directory)
+        pc_name_max = os.pathconf(directory, "PC_NAME_MAX") if hasattr(os, "pathconf") else 260  # hardcoded for windows
+        pc_path_max = (
+            os.pathconf(directory, "PC_PATH_MAX") if hasattr(os, "pathconf") else 32767
+        )  # hardcoded for windows with long names enabled
         if "/" in filename:
             return False
         if filename.startswith(".."):
@@ -417,26 +422,6 @@ class DownloadQueueService(DownloadQueueServiceBase):
             self._logger.warning(excp)
 
 
-def get_pc_name_max(directory: str) -> int:
-    if hasattr(os, "pathconf"):
-        try:
-            return os.pathconf(directory, "PC_NAME_MAX")
-        except OSError:
-            # macOS w/ external drives raise OSError
-            pass
-    return 260  # hardcoded for windows
-
-
-def get_pc_path_max(directory: str) -> int:
-    if hasattr(os, "pathconf"):
-        try:
-            return os.pathconf(directory, "PC_PATH_MAX")
-        except OSError:
-            # some platforms may not have this value
-            pass
-    return 32767  # hardcoded for windows with long names enabled
-
-
 # Example on_progress event handler to display a TQDM status bar
 # Activate with:
 #   download_service.download(DownloadJob('http://foo.bar/baz', '/tmp', on_progress=TqdmProgress().update))

invokeai/app/services/model_install/model_install_default.py

@@ -3,6 +3,7 @@
 import locale
 import os
 import re
+import signal
 import threading
 import time
 from hashlib import sha256
@@ -12,7 +13,6 @@ from shutil import copyfile, copytree, move, rmtree
 from tempfile import mkdtemp
 from typing import Any, Dict, List, Optional, Union
 
-import torch
 import yaml
 from huggingface_hub import HfFolder
 from pydantic.networks import AnyHttpUrl
@@ -42,8 +42,7 @@ from invokeai.backend.model_manager.metadata.metadata_base import HuggingFaceMet
 from invokeai.backend.model_manager.probe import ModelProbe
 from invokeai.backend.model_manager.search import ModelSearch
 from invokeai.backend.util import InvokeAILogger
-from invokeai.backend.util.catch_sigint import catch_sigint
-from invokeai.backend.util.devices import TorchDevice
+from invokeai.backend.util.devices import choose_precision, choose_torch_device
 
 from .model_install_base import (
     MODEL_SOURCE_TO_TYPE_MAP,
@@ -112,6 +111,17 @@ class ModelInstallService(ModelInstallServiceBase):
     def start(self, invoker: Optional[Invoker] = None) -> None:
         """Start the installer thread."""
 
+        # Yes, this is weird. When the installer thread is running, the
+        # thread masks the ^C signal. When we receive a
+        # sigINT, we stop the thread, reset sigINT, and send a new
+        # sigINT to the parent process.
+        def sigint_handler(signum, frame):
+            self.stop()
+            signal.signal(signal.SIGINT, signal.SIG_DFL)
+            signal.raise_signal(signal.SIGINT)
+
+        signal.signal(signal.SIGINT, sigint_handler)
+
         with self._lock:
             if self._running:
                 raise Exception("Attempt to start the installer service twice")
@@ -121,8 +131,7 @@ class ModelInstallService(ModelInstallServiceBase):
             # In normal use, we do not want to scan the models directory - it should never have orphaned models.
             # We should only do the scan when the flag is set (which should only be set when testing).
             if self.app_config.scan_models_on_startup:
-                with catch_sigint():
-                    self._register_orphaned_models()
+                self._register_orphaned_models()
 
             # Check all models' paths and confirm they exist. A model could be missing if it was installed on a volume
             # that isn't currently mounted. In this case, we don't want to delete the model from the database, but we do
@@ -625,10 +634,11 @@ class ModelInstallService(ModelInstallServiceBase):
             self._next_job_id += 1
         return id
 
-    def _guess_variant(self) -> Optional[ModelRepoVariant]:
+    @staticmethod
+    def _guess_variant() -> Optional[ModelRepoVariant]:
         """Guess the best HuggingFace variant type to download."""
-        precision = TorchDevice.choose_torch_dtype()
-        return ModelRepoVariant.FP16 if precision == torch.float16 else None
+        precision = choose_precision(choose_torch_device())
+        return ModelRepoVariant.FP16 if precision == "float16" else None
 
     def _import_local_model(self, source: LocalModelSource, config: Optional[Dict[str, Any]]) -> ModelInstallJob:
         return ModelInstallJob(
@@ -744,8 +754,6 @@ class ModelInstallService(ModelInstallServiceBase):
             self._download_cache[download_job.source] = install_job  # matches a download job to an install job
             install_job.download_parts.add(download_job)
 
-        # only start the jobs once install_job.download_parts is fully populated
-        for download_job in install_job.download_parts:
             self._download_queue.submit_download_job(
                 download_job,
                 on_start=self._download_started_callback,
@@ -754,7 +762,6 @@ class ModelInstallService(ModelInstallServiceBase):
                 on_error=self._download_error_callback,
                 on_cancelled=self._download_cancelled_callback,
             )
-
         return install_job
 
     def _stat_size(self, path: Path) -> int:

invokeai/app/services/model_manager/model_manager_default.py

@@ -1,14 +1,12 @@
 # Copyright (c) 2023 Lincoln D. Stein and the InvokeAI Team
 """Implementation of ModelManagerServiceBase."""
 
-from typing import Optional
-
 import torch
 from typing_extensions import Self
 
 from invokeai.app.services.invoker import Invoker
 from invokeai.backend.model_manager.load import ModelCache, ModelConvertCache, ModelLoaderRegistry
-from invokeai.backend.util.devices import TorchDevice
+from invokeai.backend.util.devices import choose_torch_device
 from invokeai.backend.util.logging import InvokeAILogger
 
 from ..config import InvokeAIAppConfig
@@ -69,7 +67,7 @@ class ModelManagerService(ModelManagerServiceBase):
         model_record_service: ModelRecordServiceBase,
         download_queue: DownloadQueueServiceBase,
         events: EventServiceBase,
-        execution_device: Optional[torch.device] = None,
+        execution_device: torch.device = choose_torch_device(),
     ) -> Self:
         """
         Construct the model manager service instance.
@@ -84,7 +82,7 @@ class ModelManagerService(ModelManagerServiceBase):
             max_vram_cache_size=app_config.vram,
             lazy_offloading=app_config.lazy_offload,
             logger=logger,
-            execution_device=execution_device or TorchDevice.choose_torch_device(),
+            execution_device=execution_device,
         )
         convert_cache = ModelConvertCache(cache_path=app_config.convert_cache_path, max_size=app_config.convert_cache)
         loader = ModelLoadService(

invokeai/app/services/object_serializer/object_serializer_disk.py

@@ -1,6 +1,6 @@
-import shutil
 import tempfile
 import typing
+from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Optional, TypeVar
 
@@ -17,6 +17,12 @@ if TYPE_CHECKING:
 T = TypeVar("T")
 
 
+@dataclass
+class DeleteAllResult:
+    deleted_count: int
+    freed_space_bytes: float
+
+
 class ObjectSerializerDisk(ObjectSerializerBase[T]):
     """Disk-backed storage for arbitrary python objects. Serialization is handled by `torch.save` and `torch.load`.
 
@@ -29,12 +35,6 @@ class ObjectSerializerDisk(ObjectSerializerBase[T]):
         self._ephemeral = ephemeral
         self._base_output_dir = output_dir
         self._base_output_dir.mkdir(parents=True, exist_ok=True)
-
-        if self._ephemeral:
-            # Remove dangling tempdirs that might have been left over from an earlier unplanned shutdown.
-            for temp_dir in filter(Path.is_dir, self._base_output_dir.glob("tmp*")):
-                shutil.rmtree(temp_dir)
-
         # Must specify `ignore_cleanup_errors` to avoid fatal errors during cleanup on Windows
         self._tempdir = (
             tempfile.TemporaryDirectory(dir=self._base_output_dir, ignore_cleanup_errors=True) if ephemeral else None

invokeai/app/util/controlnet_utils.py

@@ -1,21 +1,13 @@
-from typing import Any, Literal, Union
+from typing import Union
 
 import cv2
 import numpy as np
 import torch
+from controlnet_aux.util import HWC3
+from diffusers.utils import PIL_INTERPOLATION
 from einops import rearrange
 from PIL import Image
 
-from invokeai.backend.image_util.util import nms, normalize_image_channel_count
-
-CONTROLNET_RESIZE_VALUES = Literal[
-    "just_resize",
-    "crop_resize",
-    "fill_resize",
-    "just_resize_simple",
-]
-CONTROLNET_MODE_VALUES = Literal["balanced", "more_prompt", "more_control", "unbalanced"]
-
 ###################################################################
 # Copy of scripts/lvminthin.py from Mikubill/sd-webui-controlnet
 ###################################################################
@@ -76,6 +68,17 @@ def lvmin_thin(x, prunings=True):
     return y
 
 
+def nake_nms(x):
+    f1 = np.array([[0, 0, 0], [1, 1, 1], [0, 0, 0]], dtype=np.uint8)
+    f2 = np.array([[0, 1, 0], [0, 1, 0], [0, 1, 0]], dtype=np.uint8)
+    f3 = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=np.uint8)
+    f4 = np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]], dtype=np.uint8)
+    y = np.zeros_like(x)
+    for f in [f1, f2, f3, f4]:
+        np.putmask(y, cv2.dilate(x, kernel=f) == x, x)
+    return y
+
+
 ################################################################################
 # copied from Mikubill/sd-webui-controlnet external_code.py and modified for InvokeAI
 ################################################################################
@@ -131,122 +134,98 @@ def pixel_perfect_resolution(
     return int(np.round(estimation))
 
 
-def clone_contiguous(x: np.ndarray[Any, Any]) -> np.ndarray[Any, Any]:
-    """Get a memory-contiguous clone of the given numpy array, as a safety measure and to improve computation efficiency."""
-    return np.ascontiguousarray(x).copy()
-
-
-def np_img_to_torch(np_img: np.ndarray[Any, Any], device: torch.device) -> torch.Tensor:
-    """Convert a numpy image to a PyTorch tensor. The image is normalized to 0-1, rearranged to BCHW format and sent to
-    the specified device."""
-
-    torch_img = torch.from_numpy(np_img)
-    normalized = torch_img.float() / 255.0
-    bchw = rearrange(normalized, "h w c -> 1 c h w")
-    on_device = bchw.to(device)
-    return on_device.clone()
-
-
-def heuristic_resize(np_img: np.ndarray[Any, Any], size: tuple[int, int]) -> np.ndarray[Any, Any]:
-    """Resizes an image using a heuristic to choose the best resizing strategy.
-
-    - If the image appears to be an edge map, special handling will be applied to ensure the edges are not distorted.
-    - Single-pixel edge maps use NMS and thinning to keep the edges as single-pixel lines.
-    - Low-color-count images are resized with nearest-neighbor to preserve color information (for e.g. segmentation maps).
-    - The alpha channel is handled separately to ensure it is resized correctly.
-
-    Args:
-        np_img (np.ndarray): The input image.
-        size (tuple[int, int]): The target size for the image.
-
-    Returns:
-        np.ndarray: The resized image.
-
-    Adapted from https://github.com/Mikubill/sd-webui-controlnet.
-    """
-
-    # Return early if the image is already at the requested size
-    if np_img.shape[0] == size[1] and np_img.shape[1] == size[0]:
-        return np_img
-
-    # If the image has an alpha channel, separate it for special handling later.
-    inpaint_mask = None
-    if np_img.ndim == 3 and np_img.shape[2] == 4:
-        inpaint_mask = np_img[:, :, 3]
-        np_img = np_img[:, :, 0:3]
-
-    new_size_is_smaller = (size[0] * size[1]) < (np_img.shape[0] * np_img.shape[1])
-    new_size_is_bigger = (size[0] * size[1]) > (np_img.shape[0] * np_img.shape[1])
-    unique_color_count = np.unique(np_img.reshape(-1, np_img.shape[2]), axis=0).shape[0]
-    is_one_pixel_edge = False
-    is_binary = False
-
-    if unique_color_count == 2:
-        # If the image has only two colors, it is likely binary. Check if the image has one-pixel edges.
-        is_binary = np.min(np_img) < 16 and np.max(np_img) > 240
-        if is_binary:
-            eroded = cv2.erode(np_img, np.ones(shape=(3, 3), dtype=np.uint8), iterations=1)
-            dilated = cv2.dilate(eroded, np.ones(shape=(3, 3), dtype=np.uint8), iterations=1)
-            one_pixel_edge_count = np.where(dilated < np_img)[0].shape[0]
-            all_edge_count = np.where(np_img > 127)[0].shape[0]
-            is_one_pixel_edge = one_pixel_edge_count * 2 > all_edge_count
-
-    if 2 < unique_color_count < 200:
-        # With a low color count, we assume this is a map where exact colors are important. Near-neighbor preserves
-        # the colors as needed.
-        interpolation = cv2.INTER_NEAREST
-    elif new_size_is_smaller:
-        # This works best for downscaling
-        interpolation = cv2.INTER_AREA
-    else:
-        # Fall back for other cases
-        interpolation = cv2.INTER_CUBIC  # Must be CUBIC because we now use nms. NEVER CHANGE THIS
-
-    # This may be further transformed depending on the binary nature of the image.
-    resized = cv2.resize(np_img, size, interpolation=interpolation)
-
-    if inpaint_mask is not None:
-        # Resize the inpaint mask to match the resized image using the same interpolation method.
-        inpaint_mask = cv2.resize(inpaint_mask, size, interpolation=interpolation)
-
-    # If the image is binary, we will perform some additional processing to ensure the edges are preserved.
-    if is_binary:
-        resized = np.mean(resized.astype(np.float32), axis=2).clip(0, 255).astype(np.uint8)
-        if is_one_pixel_edge:
-            # Use NMS and thinning to keep the edges as single-pixel lines.
-            resized = nms(resized)
-            _, resized = cv2.threshold(resized, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-            resized = lvmin_thin(resized, prunings=new_size_is_bigger)
-        else:
-            _, resized = cv2.threshold(resized, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-        resized = np.stack([resized] * 3, axis=2)
-
-    # Restore the alpha channel if it was present.
-    if inpaint_mask is not None:
-        inpaint_mask = (inpaint_mask > 127).astype(np.float32) * 255.0
-        inpaint_mask = inpaint_mask[:, :, None].clip(0, 255).astype(np.uint8)
-        resized = np.concatenate([resized, inpaint_mask], axis=2)
-
-    return resized
-
-
 ###########################################################################
 # Copied from detectmap_proc method in scripts/detectmap_proc.py in Mikubill/sd-webui-controlnet
 #    modified for InvokeAI
 ###########################################################################
-def np_img_resize(
-    np_img: np.ndarray,
-    resize_mode: CONTROLNET_RESIZE_VALUES,
-    h: int,
-    w: int,
-    device: torch.device = torch.device("cpu"),
-) -> tuple[torch.Tensor, np.ndarray[Any, Any]]:
-    np_img = normalize_image_channel_count(np_img)
+# def detectmap_proc(detected_map, module, resize_mode, h, w):
+def np_img_resize(np_img: np.ndarray, resize_mode: str, h: int, w: int, device: torch.device = torch.device("cpu")):
+    # if 'inpaint' in module:
+    #     np_img = np_img.astype(np.float32)
+    # else:
+    #     np_img = HWC3(np_img)
+    np_img = HWC3(np_img)
 
+    def safe_numpy(x):
+        # A very safe method to make sure that Apple/Mac works
+        y = x
+
+        # below is very boring but do not change these. If you change these Apple or Mac may fail.
+        y = y.copy()
+        y = np.ascontiguousarray(y)
+        y = y.copy()
+        return y
+
+    def get_pytorch_control(x):
+        # A very safe method to make sure that Apple/Mac works
+        y = x
+
+        # below is very boring but do not change these. If you change these Apple or Mac may fail.
+        y = torch.from_numpy(y)
+        y = y.float() / 255.0
+        y = rearrange(y, "h w c -> 1 c h w")
+        y = y.clone()
+        # y = y.to(devices.get_device_for("controlnet"))
+        y = y.to(device)
+        y = y.clone()
+        return y
+
+    def high_quality_resize(x: np.ndarray, size):
+        # Written by lvmin
+        # Super high-quality control map up-scaling, considering binary, seg, and one-pixel edges
+        inpaint_mask = None
+        if x.ndim == 3 and x.shape[2] == 4:
+            inpaint_mask = x[:, :, 3]
+            x = x[:, :, 0:3]
+
+        new_size_is_smaller = (size[0] * size[1]) < (x.shape[0] * x.shape[1])
+        new_size_is_bigger = (size[0] * size[1]) > (x.shape[0] * x.shape[1])
+        unique_color_count = np.unique(x.reshape(-1, x.shape[2]), axis=0).shape[0]
+        is_one_pixel_edge = False
+        is_binary = False
+        if unique_color_count == 2:
+            is_binary = np.min(x) < 16 and np.max(x) > 240
+            if is_binary:
+                xc = x
+                xc = cv2.erode(xc, np.ones(shape=(3, 3), dtype=np.uint8), iterations=1)
+                xc = cv2.dilate(xc, np.ones(shape=(3, 3), dtype=np.uint8), iterations=1)
+                one_pixel_edge_count = np.where(xc < x)[0].shape[0]
+                all_edge_count = np.where(x > 127)[0].shape[0]
+                is_one_pixel_edge = one_pixel_edge_count * 2 > all_edge_count
+
+        if 2 < unique_color_count < 200:
+            interpolation = cv2.INTER_NEAREST
+        elif new_size_is_smaller:
+            interpolation = cv2.INTER_AREA
+        else:
+            interpolation = cv2.INTER_CUBIC  # Must be CUBIC because we now use nms. NEVER CHANGE THIS
+
+        y = cv2.resize(x, size, interpolation=interpolation)
+        if inpaint_mask is not None:
+            inpaint_mask = cv2.resize(inpaint_mask, size, interpolation=interpolation)
+
+        if is_binary:
+            y = np.mean(y.astype(np.float32), axis=2).clip(0, 255).astype(np.uint8)
+            if is_one_pixel_edge:
+                y = nake_nms(y)
+                _, y = cv2.threshold(y, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+                y = lvmin_thin(y, prunings=new_size_is_bigger)
+            else:
+                _, y = cv2.threshold(y, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+            y = np.stack([y] * 3, axis=2)
+
+        if inpaint_mask is not None:
+            inpaint_mask = (inpaint_mask > 127).astype(np.float32) * 255.0
+            inpaint_mask = inpaint_mask[:, :, None].clip(0, 255).astype(np.uint8)
+            y = np.concatenate([y, inpaint_mask], axis=2)
+
+        return y
+
+    # if resize_mode == external_code.ResizeMode.RESIZE:
     if resize_mode == "just_resize":  # RESIZE
-        np_img = heuristic_resize(np_img, (w, h))
-        np_img = clone_contiguous(np_img)
-        return np_img_to_torch(np_img, device), np_img
+        np_img = high_quality_resize(np_img, (w, h))
+        np_img = safe_numpy(np_img)
+        return get_pytorch_control(np_img), np_img
 
     old_h, old_w, _ = np_img.shape
     old_w = float(old_w)
@@ -257,6 +236,7 @@ def np_img_resize(
     def safeint(x: Union[int, float]) -> int:
         return int(np.round(x))
 
+    # if resize_mode == external_code.ResizeMode.OUTER_FIT:
     if resize_mode == "fill_resize":  # OUTER_FIT
         k = min(k0, k1)
         borders = np.concatenate([np_img[0, :, :], np_img[-1, :, :], np_img[:, 0, :], np_img[:, -1, :]], axis=0)
@@ -265,23 +245,23 @@ def np_img_resize(
             # Inpaint hijack
             high_quality_border_color[3] = 255
         high_quality_background = np.tile(high_quality_border_color[None, None], [h, w, 1])
-        np_img = heuristic_resize(np_img, (safeint(old_w * k), safeint(old_h * k)))
+        np_img = high_quality_resize(np_img, (safeint(old_w * k), safeint(old_h * k)))
         new_h, new_w, _ = np_img.shape
         pad_h = max(0, (h - new_h) // 2)
         pad_w = max(0, (w - new_w) // 2)
         high_quality_background[pad_h : pad_h + new_h, pad_w : pad_w + new_w] = np_img
         np_img = high_quality_background
-        np_img = clone_contiguous(np_img)
-        return np_img_to_torch(np_img, device), np_img
+        np_img = safe_numpy(np_img)
+        return get_pytorch_control(np_img), np_img
     else:  # resize_mode == "crop_resize"  (INNER_FIT)
         k = max(k0, k1)
-        np_img = heuristic_resize(np_img, (safeint(old_w * k), safeint(old_h * k)))
+        np_img = high_quality_resize(np_img, (safeint(old_w * k), safeint(old_h * k)))
         new_h, new_w, _ = np_img.shape
         pad_h = max(0, (new_h - h) // 2)
         pad_w = max(0, (new_w - w) // 2)
         np_img = np_img[pad_h : pad_h + h, pad_w : pad_w + w]
-        np_img = clone_contiguous(np_img)
-        return np_img_to_torch(np_img, device), np_img
+        np_img = safe_numpy(np_img)
+        return get_pytorch_control(np_img), np_img
 
 
 def prepare_control_image(
@@ -289,12 +269,12 @@ def prepare_control_image(
     width: int,
     height: int,
     num_channels: int = 3,
-    device: str = "cuda",
-    dtype: torch.dtype = torch.float16,
-    control_mode: CONTROLNET_MODE_VALUES = "balanced",
-    resize_mode: CONTROLNET_RESIZE_VALUES = "just_resize_simple",
-    do_classifier_free_guidance: bool = True,
-) -> torch.Tensor:
+    device="cuda",
+    dtype=torch.float16,
+    do_classifier_free_guidance=True,
+    control_mode="balanced",
+    resize_mode="just_resize_simple",
+):
     """Pre-process images for ControlNets or T2I-Adapters.
 
     Args:
@@ -312,15 +292,26 @@ def prepare_control_image(
         resize_mode (str, optional): Defaults to "just_resize_simple".
 
     Raises:
+        NotImplementedError: If resize_mode == "crop_resize_simple".
+        NotImplementedError: If resize_mode == "fill_resize_simple".
         ValueError: If `resize_mode` is not recognized.
         ValueError: If `num_channels` is out of range.
 
     Returns:
         torch.Tensor: The pre-processed input tensor.
     """
-    if resize_mode == "just_resize_simple":
+    if (
+        resize_mode == "just_resize_simple"
+        or resize_mode == "crop_resize_simple"
+        or resize_mode == "fill_resize_simple"
+    ):
         image = image.convert("RGB")
-        image = image.resize((width, height), resample=Image.LANCZOS)
+        if resize_mode == "just_resize_simple":
+            image = image.resize((width, height), resample=PIL_INTERPOLATION["lanczos"])
+        elif resize_mode == "crop_resize_simple":
+            raise NotImplementedError(f"prepare_control_image is not implemented for resize_mode='{resize_mode}'.")
+        elif resize_mode == "fill_resize_simple":
+            raise NotImplementedError(f"prepare_control_image is not implemented for resize_mode='{resize_mode}'.")
         nimage = np.array(image)
         nimage = nimage[None, :]
         nimage = np.concatenate([nimage], axis=0)
@@ -337,7 +328,8 @@ def prepare_control_image(
             resize_mode=resize_mode,
             h=height,
             w=width,
-            device=torch.device(device),
+            # device=torch.device('cpu')
+            device=device,
         )
     else:
         raise ValueError(f"Unsupported resize_mode: '{resize_mode}'.")

invokeai/backend/image_util/__init__.py

@@ -4,4 +4,5 @@ Initialization file for invokeai.backend.image_util methods.
 
 from .infill_methods.patchmatch import PatchMatch  # noqa: F401
 from .pngwriter import PngWriter, PromptFormatter, retrieve_metadata, write_metadata  # noqa: F401
+from .seamless import configure_model_padding  # noqa: F401
 from .util import InitImageResizer, make_grid  # noqa: F401

invokeai/backend/image_util/depth_anything/__init__.py

@@ -13,7 +13,7 @@ from invokeai.app.services.config.config_default import get_config
 from invokeai.app.util.download_with_progress import download_with_progress_bar
 from invokeai.backend.image_util.depth_anything.model.dpt import DPT_DINOv2
 from invokeai.backend.image_util.depth_anything.utilities.util import NormalizeImage, PrepareForNet, Resize
-from invokeai.backend.util.devices import TorchDevice
+from invokeai.backend.util.devices import choose_torch_device
 from invokeai.backend.util.logging import InvokeAILogger
 
 config = get_config()
@@ -56,7 +56,7 @@ class DepthAnythingDetector:
     def __init__(self) -> None:
         self.model = None
         self.model_size: Union[Literal["large", "base", "small"], None] = None
-        self.device = TorchDevice.choose_torch_device()
+        self.device = choose_torch_device()
 
     def load_model(self, model_size: Literal["large", "base", "small"] = "small"):
         DEPTH_ANYTHING_MODEL_PATH = config.models_path / DEPTH_ANYTHING_MODELS[model_size]["local"]
@@ -81,7 +81,7 @@ class DepthAnythingDetector:
             self.model.load_state_dict(torch.load(DEPTH_ANYTHING_MODEL_PATH.as_posix(), map_location="cpu"))
             self.model.eval()
 
-        self.model.to(self.device)
+        self.model.to(choose_torch_device())
         return self.model
 
     def __call__(self, image: Image.Image, resolution: int = 512) -> Image.Image:
@@ -94,7 +94,7 @@ class DepthAnythingDetector:
 
         image_height, image_width = np_image.shape[:2]
         np_image = transform({"image": np_image})["image"]
-        tensor_image = torch.from_numpy(np_image).unsqueeze(0).to(self.device)
+        tensor_image = torch.from_numpy(np_image).unsqueeze(0).to(choose_torch_device())
 
         with torch.no_grad():
             depth = self.model(tensor_image)

invokeai/backend/image_util/dw_openpose/wholebody.py

@@ -7,7 +7,7 @@ import onnxruntime as ort
 
 from invokeai.app.services.config.config_default import get_config
 from invokeai.app.util.download_with_progress import download_with_progress_bar
-from invokeai.backend.util.devices import TorchDevice
+from invokeai.backend.util.devices import choose_torch_device
 
 from .onnxdet import inference_detector
 from .onnxpose import inference_pose
@@ -28,9 +28,9 @@ config = get_config()
 
 class Wholebody:
     def __init__(self):
-        device = TorchDevice.choose_torch_device()
+        device = choose_torch_device()
 
-        providers = ["CUDAExecutionProvider"] if device.type == "cuda" else ["CPUExecutionProvider"]
+        providers = ["CUDAExecutionProvider"] if device == "cuda" else ["CPUExecutionProvider"]
 
         DET_MODEL_PATH = config.models_path / DWPOSE_MODELS["yolox_l.onnx"]["local"]
         download_with_progress_bar("yolox_l.onnx", DWPOSE_MODELS["yolox_l.onnx"]["url"], DET_MODEL_PATH)

invokeai/backend/image_util/hed.py

@@ -8,7 +8,7 @@ from huggingface_hub import hf_hub_download
 from PIL import Image
 
 from invokeai.backend.image_util.util import (
-    nms,
+    non_maximum_suppression,
     normalize_image_channel_count,
     np_to_pil,
     pil_to_np,
@@ -134,7 +134,7 @@ class HEDProcessor:
         detected_map = cv2.resize(detected_map, (width, height), interpolation=cv2.INTER_LINEAR)
 
         if scribble:
-            detected_map = nms(detected_map, 127, 3.0)
+            detected_map = non_maximum_suppression(detected_map, 127, 3.0)
             detected_map = cv2.GaussianBlur(detected_map, (0, 0), 3.0)
             detected_map[detected_map > 4] = 255
             detected_map[detected_map < 255] = 0

invokeai/backend/image_util/infill_methods/lama.py

@@ -8,7 +8,7 @@ from PIL import Image
 import invokeai.backend.util.logging as logger
 from invokeai.app.services.config.config_default import get_config
 from invokeai.app.util.download_with_progress import download_with_progress_bar
-from invokeai.backend.util.devices import TorchDevice
+from invokeai.backend.util.devices import choose_torch_device
 
 
 def norm_img(np_img):
@@ -29,7 +29,7 @@ def load_jit_model(url_or_path, device):
 
 class LaMA:
     def __call__(self, input_image: Image.Image, *args: Any, **kwds: Any) -> Any:
-        device = TorchDevice.choose_torch_device()
+        device = choose_torch_device()
         model_location = get_config().models_path / "core/misc/lama/lama.pt"
 
         if not model_location.exists():

invokeai/backend/image_util/realesrgan/realesrgan.py

@@ -11,7 +11,7 @@ from cv2.typing import MatLike
 from tqdm import tqdm
 
 from invokeai.backend.image_util.basicsr.rrdbnet_arch import RRDBNet
-from invokeai.backend.util.devices import TorchDevice
+from invokeai.backend.util.devices import choose_torch_device
 
 """
 Adapted from https://github.com/xinntao/Real-ESRGAN/blob/master/realesrgan/utils.py
@@ -65,7 +65,7 @@ class RealESRGAN:
         self.pre_pad = pre_pad
         self.mod_scale: Optional[int] = None
         self.half = half
-        self.device = TorchDevice.choose_torch_device()
+        self.device = choose_torch_device()
 
         loadnet = torch.load(model_path, map_location=torch.device("cpu"))
 

invokeai/backend/image_util/safety_checker.py

@@ -8,15 +8,14 @@ from pathlib import Path
 
 import numpy as np
 from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
-from PIL import Image, ImageFilter
+from PIL import Image
 from transformers import AutoFeatureExtractor
 
 import invokeai.backend.util.logging as logger
 from invokeai.app.services.config.config_default import get_config
-from invokeai.backend.util.devices import TorchDevice
+from invokeai.backend.util.devices import choose_torch_device
 from invokeai.backend.util.silence_warnings import SilenceWarnings
 
-repo_id = "CompVis/stable-diffusion-safety-checker"
 CHECKER_PATH = "core/convert/stable-diffusion-safety-checker"
 
 
@@ -25,34 +24,34 @@ class SafetyChecker:
     Wrapper around SafetyChecker model.
     """
 
-    feature_extractor = None
     safety_checker = None
+    feature_extractor = None
+    tried_load: bool = False
 
     @classmethod
     def _load_safety_checker(cls):
-        if cls.safety_checker is not None and cls.feature_extractor is not None:
+        if cls.tried_load:
             return
 
         try:
-            model_path = get_config().models_path / CHECKER_PATH
-            if model_path.exists():
-                cls.feature_extractor = AutoFeatureExtractor.from_pretrained(model_path)
-                cls.safety_checker = StableDiffusionSafetyChecker.from_pretrained(model_path)
-            else:
-                model_path.mkdir(parents=True, exist_ok=True)
-                cls.feature_extractor = AutoFeatureExtractor.from_pretrained(repo_id)
-                cls.feature_extractor.save_pretrained(model_path, safe_serialization=True)
-                cls.safety_checker = StableDiffusionSafetyChecker.from_pretrained(repo_id)
-                cls.safety_checker.save_pretrained(model_path, safe_serialization=True)
+            cls.safety_checker = StableDiffusionSafetyChecker.from_pretrained(get_config().models_path / CHECKER_PATH)
+            cls.feature_extractor = AutoFeatureExtractor.from_pretrained(get_config().models_path / CHECKER_PATH)
         except Exception as e:
             logger.warning(f"Could not load NSFW checker: {str(e)}")
+        cls.tried_load = True
+
+    @classmethod
+    def safety_checker_available(cls) -> bool:
+        return Path(get_config().models_path, CHECKER_PATH).exists()
 
     @classmethod
     def has_nsfw_concept(cls, image: Image.Image) -> bool:
+        if not cls.safety_checker_available() and cls.tried_load:
+            return False
         cls._load_safety_checker()
         if cls.safety_checker is None or cls.feature_extractor is None:
             return False
-        device = TorchDevice.choose_torch_device()
+        device = choose_torch_device()
         features = cls.feature_extractor([image], return_tensors="pt")
         features.to(device)
         cls.safety_checker.to(device)
@@ -61,24 +60,3 @@ class SafetyChecker:
         with SilenceWarnings():
             checked_image, has_nsfw_concept = cls.safety_checker(images=x_image, clip_input=features.pixel_values)
         return has_nsfw_concept[0]
-
-    @classmethod
-    def blur_if_nsfw(cls, image: Image.Image) -> Image.Image:
-        if cls.has_nsfw_concept(image):
-            logger.warning("A potentially NSFW image has been detected. Image will be blurred.")
-            blurry_image = image.filter(filter=ImageFilter.GaussianBlur(radius=32))
-            caution = cls._get_caution_img()
-            # Center the caution image on the blurred image
-            x = (blurry_image.width - caution.width) // 2
-            y = (blurry_image.height - caution.height) // 2
-            blurry_image.paste(caution, (x, y), caution)
-            image = blurry_image
-
-        return image
-
-    @classmethod
-    def _get_caution_img(cls) -> Image.Image:
-        import invokeai.app.assets.images as image_assets
-
-        caution = Image.open(Path(image_assets.__path__[0]) / "caution.png")
-        return caution.resize((caution.width // 2, caution.height // 2))

invokeai/backend/image_util/seamless.py

@@ -0,0 +1,52 @@
+import torch.nn as nn
+
+
+def _conv_forward_asymmetric(self, input, weight, bias):
+    """
+    Patch for Conv2d._conv_forward that supports asymmetric padding
+    """
+    working = nn.functional.pad(input, self.asymmetric_padding["x"], mode=self.asymmetric_padding_mode["x"])
+    working = nn.functional.pad(working, self.asymmetric_padding["y"], mode=self.asymmetric_padding_mode["y"])
+    return nn.functional.conv2d(
+        working,
+        weight,
+        bias,
+        self.stride,
+        nn.modules.utils._pair(0),
+        self.dilation,
+        self.groups,
+    )
+
+
+def configure_model_padding(model, seamless, seamless_axes):
+    """
+    Modifies the 2D convolution layers to use a circular padding mode based on
+    the `seamless` and `seamless_axes` options.
+    """
+    # TODO: get an explicit interface for this in diffusers: https://github.com/huggingface/diffusers/issues/556
+    for m in model.modules():
+        if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
+            if seamless:
+                m.asymmetric_padding_mode = {}
+                m.asymmetric_padding = {}
+                m.asymmetric_padding_mode["x"] = "circular" if ("x" in seamless_axes) else "constant"
+                m.asymmetric_padding["x"] = (
+                    m._reversed_padding_repeated_twice[0],
+                    m._reversed_padding_repeated_twice[1],
+                    0,
+                    0,
+                )
+                m.asymmetric_padding_mode["y"] = "circular" if ("y" in seamless_axes) else "constant"
+                m.asymmetric_padding["y"] = (
+                    0,
+                    0,
+                    m._reversed_padding_repeated_twice[2],
+                    m._reversed_padding_repeated_twice[3],
+                )
+                m._conv_forward = _conv_forward_asymmetric.__get__(m, nn.Conv2d)
+            else:
+                m._conv_forward = nn.Conv2d._conv_forward.__get__(m, nn.Conv2d)
+                if hasattr(m, "asymmetric_padding_mode"):
+                    del m.asymmetric_padding_mode
+                if hasattr(m, "asymmetric_padding"):
+                    del m.asymmetric_padding

invokeai/backend/image_util/util.py

@@ -1,5 +1,4 @@
 from math import ceil, floor, sqrt
-from typing import Optional
 
 import cv2
 import numpy as np
@@ -144,21 +143,20 @@ def resize_image_to_resolution(input_image: np.ndarray, resolution: int) -> np.n
     h = float(input_image.shape[0])
     w = float(input_image.shape[1])
     scaling_factor = float(resolution) / min(h, w)
-    h = int(h * scaling_factor)
-    w = int(w * scaling_factor)
+    h *= scaling_factor
+    w *= scaling_factor
+    h = int(np.round(h / 64.0)) * 64
+    w = int(np.round(w / 64.0)) * 64
     if scaling_factor > 1:
         return cv2.resize(input_image, (w, h), interpolation=cv2.INTER_LANCZOS4)
     else:
         return cv2.resize(input_image, (w, h), interpolation=cv2.INTER_AREA)
 
 
-def nms(np_img: np.ndarray, threshold: Optional[int] = None, sigma: Optional[float] = None) -> np.ndarray:
+def non_maximum_suppression(image: np.ndarray, threshold: int, sigma: float):
     """
     Apply non-maximum suppression to an image.
 
-    If both threshold and sigma are provided, the image will blurred before the suppression and thresholded afterwards,
-    resulting in a binary output image.
-
     This function is adapted from https://github.com/lllyasviel/ControlNet.
 
     Args:
@@ -168,36 +166,23 @@ def nms(np_img: np.ndarray, threshold: Optional[int] = None, sigma: Optional[flo
 
     Returns:
         The image after non-maximum suppression.
-
-    Raises:
-        ValueError: If only one of threshold and sigma provided.
     """
 
-    # Raise a value error if only one of threshold and sigma is provided
-    if (threshold is None) != (sigma is None):
-        raise ValueError("Both threshold and sigma must be provided if one is provided.")
-
-    if sigma is not None and threshold is not None:
-        # Blurring the image can help to thin out features
-        np_img = cv2.GaussianBlur(np_img.astype(np.float32), (0, 0), sigma)
+    image = cv2.GaussianBlur(image.astype(np.float32), (0, 0), sigma)
 
     filter_1 = np.array([[0, 0, 0], [1, 1, 1], [0, 0, 0]], dtype=np.uint8)
     filter_2 = np.array([[0, 1, 0], [0, 1, 0], [0, 1, 0]], dtype=np.uint8)
     filter_3 = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=np.uint8)
     filter_4 = np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]], dtype=np.uint8)
 
-    nms_img = np.zeros_like(np_img)
+    y = np.zeros_like(image)
 
     for f in [filter_1, filter_2, filter_3, filter_4]:
-        np.putmask(nms_img, cv2.dilate(np_img, kernel=f) == np_img, np_img)
+        np.putmask(y, cv2.dilate(image, kernel=f) == image, image)
 
-    if sigma is not None and threshold is not None:
-        # We blurred - now threshold to get a binary image
-        thresholded = np.zeros_like(nms_img, dtype=np.uint8)
-        thresholded[nms_img > threshold] = 255
-        return thresholded
-
-    return nms_img
+    z = np.zeros_like(y, dtype=np.uint8)
+    z[y > threshold] = 255
+    return z
 
 
 def safe_step(x: np.ndarray, step: int = 2) -> np.ndarray:

invokeai/backend/model_manager/config.py

@@ -301,12 +301,12 @@ class MainConfigBase(ModelConfigBase):
     default_settings: Optional[MainModelDefaultSettings] = Field(
         description="Default settings for this model", default=None
     )
-    variant: ModelVariantType = ModelVariantType.Normal
 
 
 class MainCheckpointConfig(CheckpointConfigBase, MainConfigBase):
     """Model config for main checkpoint models."""
 
+    variant: ModelVariantType = ModelVariantType.Normal
     prediction_type: SchedulerPredictionType = SchedulerPredictionType.Epsilon
     upcast_attention: bool = False
 

invokeai/backend/model_manager/load/load_default.py

@@ -18,7 +18,7 @@ from invokeai.backend.model_manager.load.load_base import LoadedModel, ModelLoad
 from invokeai.backend.model_manager.load.model_cache.model_cache_base import ModelCacheBase, ModelLockerBase
 from invokeai.backend.model_manager.load.model_util import calc_model_size_by_data, calc_model_size_by_fs
 from invokeai.backend.model_manager.load.optimizations import skip_torch_weight_init
-from invokeai.backend.util.devices import TorchDevice
+from invokeai.backend.util.devices import choose_torch_device, torch_dtype
 
 
 # TO DO: The loader is not thread safe!
@@ -37,7 +37,7 @@ class ModelLoader(ModelLoaderBase):
         self._logger = logger
         self._ram_cache = ram_cache
         self._convert_cache = convert_cache
-        self._torch_dtype = TorchDevice.choose_torch_dtype()
+        self._torch_dtype = torch_dtype(choose_torch_device())
 
     def load_model(self, model_config: AnyModelConfig, submodel_type: Optional[SubModelType] = None) -> LoadedModel:
         """

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

@@ -30,12 +30,15 @@ import torch
 
 from invokeai.backend.model_manager import AnyModel, SubModelType
 from invokeai.backend.model_manager.load.memory_snapshot import MemorySnapshot, get_pretty_snapshot_diff
-from invokeai.backend.util.devices import TorchDevice
+from invokeai.backend.util.devices import choose_torch_device
 from invokeai.backend.util.logging import InvokeAILogger
 
 from .model_cache_base import CacheRecord, CacheStats, ModelCacheBase, ModelLockerBase
 from .model_locker import ModelLocker
 
+if choose_torch_device() == torch.device("mps"):
+    from torch import mps
+
 # Maximum size of the cache, in gigs
 # Default is roughly enough to hold three fp16 diffusers models in RAM simultaneously
 DEFAULT_MAX_CACHE_SIZE = 6.0
@@ -241,7 +244,9 @@ class ModelCache(ModelCacheBase[AnyModel]):
                     f"Removing {cache_entry.key} from VRAM to free {(cache_entry.size/GIG):.2f}GB; vram free = {(torch.cuda.memory_allocated()/GIG):.2f}GB"
                 )
 
-        TorchDevice.empty_cache()
+        torch.cuda.empty_cache()
+        if choose_torch_device() == torch.device("mps"):
+            mps.empty_cache()
 
     def move_model_to_device(self, cache_entry: CacheRecord[AnyModel], target_device: torch.device) -> None:
         """Move model into the indicated device.
@@ -411,7 +416,10 @@ class ModelCache(ModelCacheBase[AnyModel]):
                 self.stats.cleared = models_cleared
             gc.collect()
 
-        TorchDevice.empty_cache()
+        torch.cuda.empty_cache()
+        if choose_torch_device() == torch.device("mps"):
+            mps.empty_cache()
+
         self.logger.debug(f"After making room: cached_models={len(self._cached_models)}")
 
     def _delete_cache_entry(self, cache_entry: CacheRecord[AnyModel]) -> None:

invokeai/backend/model_manager/merge.py

@@ -17,7 +17,7 @@ from diffusers.utils import logging as dlogging
 
 from invokeai.app.services.model_install import ModelInstallServiceBase
 from invokeai.app.services.model_records.model_records_base import ModelRecordChanges
-from invokeai.backend.util.devices import TorchDevice
+from invokeai.backend.util.devices import choose_torch_device, torch_dtype
 
 from . import (
     AnyModelConfig,
@@ -43,7 +43,6 @@ class ModelMerger(object):
         Initialize a ModelMerger object with the model installer.
         """
         self._installer = installer
-        self._dtype = TorchDevice.choose_torch_dtype()
 
     def merge_diffusion_models(
         self,
@@ -69,7 +68,7 @@ class ModelMerger(object):
             warnings.simplefilter("ignore")
             verbosity = dlogging.get_verbosity()
             dlogging.set_verbosity_error()
-            dtype = torch.float16 if variant == "fp16" else self._dtype
+            dtype = torch.float16 if variant == "fp16" else torch_dtype(choose_torch_device())
 
             # Note that checkpoint_merger will not work with downloaded HuggingFace fp16 models
             # until upstream https://github.com/huggingface/diffusers/pull/6670 is merged and released.
@@ -152,7 +151,7 @@ class ModelMerger(object):
         dump_path.mkdir(parents=True, exist_ok=True)
         dump_path = dump_path / merged_model_name
 
-        dtype = torch.float16 if variant == "fp16" else self._dtype
+        dtype = torch.float16 if variant == "fp16" else torch_dtype(choose_torch_device())
         merged_pipe.save_pretrained(dump_path.as_posix(), safe_serialization=True, torch_dtype=dtype, variant=variant)
 
         # register model and get its unique key

invokeai/backend/model_manager/probe.py

@@ -51,7 +51,6 @@ LEGACY_CONFIGS: Dict[BaseModelType, Dict[ModelVariantType, Union[str, Dict[Sched
     },
     BaseModelType.StableDiffusionXL: {
         ModelVariantType.Normal: "sd_xl_base.yaml",
-        ModelVariantType.Inpaint: "sd_xl_inpaint.yaml",
     },
     BaseModelType.StableDiffusionXLRefiner: {
         ModelVariantType.Normal: "sd_xl_refiner.yaml",

invokeai/backend/model_manager/starter_models.py

@@ -155,7 +155,7 @@ STARTER_MODELS: list[StarterModel] = [
     StarterModel(
         name="IP Adapter",
         base=BaseModelType.StableDiffusion1,
-        source="https://huggingface.co/InvokeAI/ip_adapter_sd15/resolve/main/ip-adapter_sd15.safetensors",
+        source="InvokeAI/ip_adapter_sd15",
         description="IP-Adapter for SD 1.5 models",
         type=ModelType.IPAdapter,
         dependencies=[ip_adapter_sd_image_encoder],
@@ -163,7 +163,7 @@ STARTER_MODELS: list[StarterModel] = [
     StarterModel(
         name="IP Adapter Plus",
         base=BaseModelType.StableDiffusion1,
-        source="https://huggingface.co/InvokeAI/ip_adapter_plus_sd15/resolve/main/ip-adapter-plus_sd15.safetensors",
+        source="InvokeAI/ip_adapter_plus_sd15",
         description="Refined IP-Adapter for SD 1.5 models",
         type=ModelType.IPAdapter,
         dependencies=[ip_adapter_sd_image_encoder],
@@ -171,7 +171,7 @@ STARTER_MODELS: list[StarterModel] = [
     StarterModel(
         name="IP Adapter Plus Face",
         base=BaseModelType.StableDiffusion1,
-        source="https://huggingface.co/InvokeAI/ip_adapter_plus_face_sd15/resolve/main/ip-adapter-plus-face_sd15.safetensors",
+        source="InvokeAI/ip_adapter_plus_face_sd15",
         description="Refined IP-Adapter for SD 1.5 models, adapted for faces",
         type=ModelType.IPAdapter,
         dependencies=[ip_adapter_sd_image_encoder],
@@ -179,7 +179,7 @@ STARTER_MODELS: list[StarterModel] = [
     StarterModel(
         name="IP Adapter SDXL",
         base=BaseModelType.StableDiffusionXL,
-        source="https://huggingface.co/InvokeAI/ip_adapter_sdxl_vit_h/resolve/main/ip-adapter_sdxl_vit-h.safetensors",
+        source="InvokeAI/ip_adapter_sdxl",
         description="IP-Adapter for SDXL models",
         type=ModelType.IPAdapter,
         dependencies=[ip_adapter_sdxl_image_encoder],

invokeai/backend/stable_diffusion/diffusers_pipeline.py

@@ -21,11 +21,14 @@ from pydantic import Field
 from transformers import CLIPFeatureExtractor, CLIPTextModel, CLIPTokenizer
 
 from invokeai.app.services.config.config_default import get_config
-from invokeai.backend.stable_diffusion.diffusion.conditioning_data import IPAdapterData, TextConditioningData
+from invokeai.backend.stable_diffusion.diffusion.conditioning_data import (
+    IPAdapterData,
+    TextConditioningData,
+)
 from invokeai.backend.stable_diffusion.diffusion.shared_invokeai_diffusion import InvokeAIDiffuserComponent
-from invokeai.backend.stable_diffusion.diffusion.unet_attention_patcher import UNetAttentionPatcher, UNetIPAdapterData
+from invokeai.backend.stable_diffusion.diffusion.unet_attention_patcher import UNetAttentionPatcher
 from invokeai.backend.util.attention import auto_detect_slice_size
-from invokeai.backend.util.devices import TorchDevice
+from invokeai.backend.util.devices import normalize_device
 
 
 @dataclass
@@ -255,7 +258,7 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         if self.unet.device.type == "cpu" or self.unet.device.type == "mps":
             mem_free = psutil.virtual_memory().free
         elif self.unet.device.type == "cuda":
-            mem_free, _ = torch.cuda.mem_get_info(TorchDevice.normalize(self.unet.device))
+            mem_free, _ = torch.cuda.mem_get_info(normalize_device(self.unet.device))
         else:
             raise ValueError(f"unrecognized device {self.unet.device}")
         # input tensor of [1, 4, h/8, w/8]
@@ -391,13 +394,8 @@ class StableDiffusionGeneratorPipeline(StableDiffusionPipeline):
         unet_attention_patcher = None
         self.use_ip_adapter = use_ip_adapter
         attn_ctx = nullcontext()
-
         if use_ip_adapter or use_regional_prompting:
-            ip_adapters: Optional[List[UNetIPAdapterData]] = (
-                [{"ip_adapter": ipa.ip_adapter_model, "target_blocks": ipa.target_blocks} for ipa in ip_adapter_data]
-                if use_ip_adapter
-                else None
-            )
+            ip_adapters = [ipa.ip_adapter_model for ipa in ip_adapter_data] if use_ip_adapter else None
             unet_attention_patcher = UNetAttentionPatcher(ip_adapters)
             attn_ctx = unet_attention_patcher.apply_ip_adapter_attention(self.invokeai_diffuser.model)
 

invokeai/backend/stable_diffusion/diffusion/conditioning_data.py

@@ -53,7 +53,6 @@ class IPAdapterData:
     ip_adapter_model: IPAdapter
     ip_adapter_conditioning: IPAdapterConditioningInfo
     mask: torch.Tensor
-    target_blocks: List[str]
 
     # Either a single weight applied to all steps, or a list of weights for each step.
     weight: Union[float, List[float]] = 1.0

invokeai/backend/stable_diffusion/diffusion/custom_atttention.py

@@ -1,5 +1,4 @@
-from dataclasses import dataclass
-from typing import List, Optional, cast
+from typing import Optional
 
 import torch
 import torch.nn.functional as F
@@ -10,12 +9,6 @@ from invokeai.backend.stable_diffusion.diffusion.regional_ip_data import Regiona
 from invokeai.backend.stable_diffusion.diffusion.regional_prompt_data import RegionalPromptData
 
 
-@dataclass
-class IPAdapterAttentionWeights:
-    ip_adapter_weights: IPAttentionProcessorWeights
-    skip: bool
-
-
 class CustomAttnProcessor2_0(AttnProcessor2_0):
     """A custom implementation of AttnProcessor2_0 that supports additional Invoke features.
     This implementation is based on
@@ -27,7 +20,7 @@ class CustomAttnProcessor2_0(AttnProcessor2_0):
 
     def __init__(
         self,
-        ip_adapter_attention_weights: Optional[List[IPAdapterAttentionWeights]] = None,
+        ip_adapter_weights: Optional[list[IPAttentionProcessorWeights]] = None,
     ):
         """Initialize a CustomAttnProcessor2_0.
         Note: Arguments that are the same for all attention layers are passed to __call__(). Arguments that are
@@ -37,22 +30,23 @@ class CustomAttnProcessor2_0(AttnProcessor2_0):
                 for the i'th IP-Adapter.
         """
         super().__init__()
-        self._ip_adapter_attention_weights = ip_adapter_attention_weights
+        self._ip_adapter_weights = ip_adapter_weights
+
+    def _is_ip_adapter_enabled(self) -> bool:
+        return self._ip_adapter_weights is not None
 
     def __call__(
         self,
         attn: Attention,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: Optional[torch.Tensor] = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        temb: Optional[torch.Tensor] = None,
-        # For Regional Prompting:
+        hidden_states: torch.FloatTensor,
+        encoder_hidden_states: Optional[torch.FloatTensor] = None,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        temb: Optional[torch.FloatTensor] = None,
+        # For regional prompting:
         regional_prompt_data: Optional[RegionalPromptData] = None,
-        percent_through: Optional[torch.Tensor] = None,
+        percent_through: Optional[torch.FloatTensor] = None,
         # For IP-Adapter:
         regional_ip_data: Optional[RegionalIPData] = None,
-        *args,
-        **kwargs,
     ) -> torch.FloatTensor:
         """Apply attention.
         Args:
@@ -136,19 +130,17 @@ class CustomAttnProcessor2_0(AttnProcessor2_0):
 
         # Apply IP-Adapter conditioning.
         if is_cross_attention:
-            if self._ip_adapter_attention_weights:
+            if self._is_ip_adapter_enabled():
                 assert regional_ip_data is not None
                 ip_masks = regional_ip_data.get_masks(query_seq_len=query_seq_len)
-
                 assert (
                     len(regional_ip_data.image_prompt_embeds)
-                    == len(self._ip_adapter_attention_weights)
+                    == len(self._ip_adapter_weights)
                     == len(regional_ip_data.scales)
                     == ip_masks.shape[1]
                 )
-
                 for ipa_index, ipa_embed in enumerate(regional_ip_data.image_prompt_embeds):
-                    ipa_weights = self._ip_adapter_attention_weights[ipa_index].ip_adapter_weights
+                    ipa_weights = self._ip_adapter_weights[ipa_index]
                     ipa_scale = regional_ip_data.scales[ipa_index]
                     ip_mask = ip_masks[0, ipa_index, ...]
 
@@ -161,33 +153,29 @@ class CustomAttnProcessor2_0(AttnProcessor2_0):
 
                     # Expected ip_hidden_state shape: (batch_size, num_ip_images, ip_seq_len, ip_image_embedding)
 
-                    if not self._ip_adapter_attention_weights[ipa_index].skip:
-                        ip_key = ipa_weights.to_k_ip(ip_hidden_states)
-                        ip_value = ipa_weights.to_v_ip(ip_hidden_states)
+                    ip_key = ipa_weights.to_k_ip(ip_hidden_states)
+                    ip_value = ipa_weights.to_v_ip(ip_hidden_states)
 
-                        # Expected ip_key and ip_value shape:
-                        # (batch_size, num_ip_images, ip_seq_len, head_dim * num_heads)
+                    # Expected ip_key and ip_value shape: (batch_size, num_ip_images, ip_seq_len, head_dim * num_heads)
 
-                        ip_key = ip_key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
-                        ip_value = ip_value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
+                    ip_key = ip_key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
+                    ip_value = ip_value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
 
-                        # Expected ip_key and ip_value shape:
-                        # (batch_size, num_heads, num_ip_images * ip_seq_len, head_dim)
+                    # Expected ip_key and ip_value shape: (batch_size, num_heads, num_ip_images * ip_seq_len, head_dim)
 
-                        # TODO: add support for attn.scale when we move to Torch 2.1
-                        ip_hidden_states = F.scaled_dot_product_attention(
-                            query, ip_key, ip_value, attn_mask=None, dropout_p=0.0, is_causal=False
-                        )
+                    # TODO: add support for attn.scale when we move to Torch 2.1
+                    ip_hidden_states = F.scaled_dot_product_attention(
+                        query, ip_key, ip_value, attn_mask=None, dropout_p=0.0, is_causal=False
+                    )
 
-                        # Expected ip_hidden_states shape: (batch_size, num_heads, query_seq_len, head_dim)
-                        ip_hidden_states = ip_hidden_states.transpose(1, 2).reshape(
-                            batch_size, -1, attn.heads * head_dim
-                        )
+                    # Expected ip_hidden_states shape: (batch_size, num_heads, query_seq_len, head_dim)
 
-                        ip_hidden_states = ip_hidden_states.to(query.dtype)
+                    ip_hidden_states = ip_hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
+                    ip_hidden_states = ip_hidden_states.to(query.dtype)
 
-                        # Expected ip_hidden_states shape: (batch_size, query_seq_len, num_heads * head_dim)
-                        hidden_states = hidden_states + ipa_scale * ip_hidden_states * ip_mask
+                    # Expected ip_hidden_states shape: (batch_size, query_seq_len, num_heads * head_dim)
+
+                    hidden_states = hidden_states + ipa_scale * ip_hidden_states * ip_mask
             else:
                 # If IP-Adapter is not enabled, then regional_ip_data should not be passed in.
                 assert regional_ip_data is None
@@ -200,15 +188,11 @@ class CustomAttnProcessor2_0(AttnProcessor2_0):
         hidden_states = attn.to_out[1](hidden_states)
 
         if input_ndim == 4:
-            batch_size, channel, height, width = hidden_states.shape
             hidden_states = hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width)
 
         if attn.residual_connection:
             hidden_states = hidden_states + residual
 
         hidden_states = hidden_states / attn.rescale_output_factor
-        # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-        # End of unmodified block from AttnProcessor2_0
 
-        # casting torch.Tensor to torch.FloatTensor to avoid type issues
-        return cast(torch.FloatTensor, hidden_states)
+        return hidden_states

invokeai/backend/stable_diffusion/diffusion/unet_attention_patcher.py

@@ -1,25 +1,17 @@
 from contextlib import contextmanager
-from typing import List, Optional, TypedDict
+from typing import Optional
 
 from diffusers.models import UNet2DConditionModel
 
 from invokeai.backend.ip_adapter.ip_adapter import IPAdapter
-from invokeai.backend.stable_diffusion.diffusion.custom_atttention import (
-    CustomAttnProcessor2_0,
-    IPAdapterAttentionWeights,
-)
-
-
-class UNetIPAdapterData(TypedDict):
-    ip_adapter: IPAdapter
-    target_blocks: List[str]
+from invokeai.backend.stable_diffusion.diffusion.custom_atttention import CustomAttnProcessor2_0
 
 
 class UNetAttentionPatcher:
     """A class for patching a UNet with CustomAttnProcessor2_0 attention layers."""
 
-    def __init__(self, ip_adapter_data: Optional[List[UNetIPAdapterData]]):
-        self._ip_adapters = ip_adapter_data
+    def __init__(self, ip_adapters: Optional[list[IPAdapter]]):
+        self._ip_adapters = ip_adapters
 
     def _prepare_attention_processors(self, unet: UNet2DConditionModel):
         """Prepare a dict of attention processors that can be injected into a unet, and load the IP-Adapter attention
@@ -34,22 +26,9 @@ class UNetAttentionPatcher:
                 attn_procs[name] = CustomAttnProcessor2_0()
             else:
                 # Collect the weights from each IP Adapter for the idx'th attention processor.
-                ip_adapter_attention_weights_collection: list[IPAdapterAttentionWeights] = []
-
-                for ip_adapter in self._ip_adapters:
-                    ip_adapter_weights = ip_adapter["ip_adapter"].attn_weights.get_attention_processor_weights(idx)
-                    skip = True
-                    for block in ip_adapter["target_blocks"]:
-                        if block in name:
-                            skip = False
-                            break
-                    ip_adapter_attention_weights: IPAdapterAttentionWeights = IPAdapterAttentionWeights(
-                        ip_adapter_weights=ip_adapter_weights, skip=skip
-                    )
-                    ip_adapter_attention_weights_collection.append(ip_adapter_attention_weights)
-
-                attn_procs[name] = CustomAttnProcessor2_0(ip_adapter_attention_weights_collection)
-
+                attn_procs[name] = CustomAttnProcessor2_0(
+                    [ip_adapter.attn_weights.get_attention_processor_weights(idx) for ip_adapter in self._ip_adapters],
+                )
         return attn_procs
 
     @contextmanager

invokeai/backend/stable_diffusion/schedulers/schedulers.py

@@ -13,7 +13,6 @@ from diffusers import (
     LCMScheduler,
     LMSDiscreteScheduler,
     PNDMScheduler,
-    TCDScheduler,
     UniPCMultistepScheduler,
 )
 
@@ -41,5 +40,4 @@ SCHEDULER_MAP = {
     "dpmpp_sde_k": (DPMSolverSDEScheduler, {"use_karras_sigmas": True, "noise_sampler_seed": 0}),
     "unipc": (UniPCMultistepScheduler, {"cpu_only": True}),
     "lcm": (LCMScheduler, {}),
-    "tcd": (TCDScheduler, {}),
 }

invokeai/backend/stable_diffusion/seamless.py

@@ -1,51 +1,89 @@
-from contextlib import contextmanager
-from typing import Callable, List, Optional, Tuple, Union
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import Callable, List, Union
 
-import torch
 import torch.nn as nn
 from diffusers.models.autoencoders.autoencoder_kl import AutoencoderKL
 from diffusers.models.autoencoders.autoencoder_tiny import AutoencoderTiny
-from diffusers.models.lora import LoRACompatibleConv
 from diffusers.models.unets.unet_2d_condition import UNet2DConditionModel
 
 
+def _conv_forward_asymmetric(self, input, weight, bias):
+    """
+    Patch for Conv2d._conv_forward that supports asymmetric padding
+    """
+    working = nn.functional.pad(input, self.asymmetric_padding["x"], mode=self.asymmetric_padding_mode["x"])
+    working = nn.functional.pad(working, self.asymmetric_padding["y"], mode=self.asymmetric_padding_mode["y"])
+    return nn.functional.conv2d(
+        working,
+        weight,
+        bias,
+        self.stride,
+        nn.modules.utils._pair(0),
+        self.dilation,
+        self.groups,
+    )
+
+
 @contextmanager
 def set_seamless(model: Union[UNet2DConditionModel, AutoencoderKL, AutoencoderTiny], seamless_axes: List[str]):
     if not seamless_axes:
         yield
         return
 
-    # override conv_forward
-    # https://github.com/huggingface/diffusers/issues/556#issuecomment-1993287019
-    def _conv_forward_asymmetric(self, input: torch.Tensor, weight: torch.Tensor, bias: Optional[torch.Tensor] = None):
-        self.paddingX = (self._reversed_padding_repeated_twice[0], self._reversed_padding_repeated_twice[1], 0, 0)
-        self.paddingY = (0, 0, self._reversed_padding_repeated_twice[2], self._reversed_padding_repeated_twice[3])
-        working = torch.nn.functional.pad(input, self.paddingX, mode=x_mode)
-        working = torch.nn.functional.pad(working, self.paddingY, mode=y_mode)
-        return torch.nn.functional.conv2d(
-            working, weight, bias, self.stride, torch.nn.modules.utils._pair(0), self.dilation, self.groups
-        )
-
-    original_layers: List[Tuple[nn.Conv2d, Callable]] = []
-
+    # Callable: (input: Tensor, weight: Tensor, bias: Optional[Tensor]) -> Tensor
+    to_restore: list[tuple[nn.Conv2d | nn.ConvTranspose2d, Callable]] = []
     try:
-        x_mode = "circular" if "x" in seamless_axes else "constant"
-        y_mode = "circular" if "y" in seamless_axes else "constant"
+        # Hard coded to skip down block layers, allowing for seamless tiling at the expense of prompt adherence
+        skipped_layers = 1
+        for m_name, m in model.named_modules():
+            if not isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
+                continue
 
-        conv_layers: List[torch.nn.Conv2d] = []
+            if isinstance(model, UNet2DConditionModel) and m_name.startswith("down_blocks.") and ".resnets." in m_name:
+                # down_blocks.1.resnets.1.conv1
+                _, block_num, _, resnet_num, submodule_name = m_name.split(".")
+                block_num = int(block_num)
+                resnet_num = int(resnet_num)
 
-        for module in model.modules():
-            if isinstance(module, torch.nn.Conv2d):
-                conv_layers.append(module)
+                if block_num >= len(model.down_blocks) - skipped_layers:
+                    continue
 
-        for layer in conv_layers:
-            if isinstance(layer, LoRACompatibleConv) and layer.lora_layer is None:
-                layer.lora_layer = lambda *x: 0
-            original_layers.append((layer, layer._conv_forward))
-            layer._conv_forward = _conv_forward_asymmetric.__get__(layer, torch.nn.Conv2d)
+                # Skip the second resnet (could be configurable)
+                if resnet_num > 0:
+                    continue
+
+                # Skip Conv2d layers (could be configurable)
+                if submodule_name == "conv2":
+                    continue
+
+            m.asymmetric_padding_mode = {}
+            m.asymmetric_padding = {}
+            m.asymmetric_padding_mode["x"] = "circular" if ("x" in seamless_axes) else "constant"
+            m.asymmetric_padding["x"] = (
+                m._reversed_padding_repeated_twice[0],
+                m._reversed_padding_repeated_twice[1],
+                0,
+                0,
+            )
+            m.asymmetric_padding_mode["y"] = "circular" if ("y" in seamless_axes) else "constant"
+            m.asymmetric_padding["y"] = (
+                0,
+                0,
+                m._reversed_padding_repeated_twice[2],
+                m._reversed_padding_repeated_twice[3],
+            )
+
+            to_restore.append((m, m._conv_forward))
+            m._conv_forward = _conv_forward_asymmetric.__get__(m, nn.Conv2d)
 
         yield
 
     finally:
-        for layer, orig_conv_forward in original_layers:
-            layer._conv_forward = orig_conv_forward
+        for module, orig_conv_forward in to_restore:
+            module._conv_forward = orig_conv_forward
+            if hasattr(module, "asymmetric_padding_mode"):
+                del module.asymmetric_padding_mode
+            if hasattr(module, "asymmetric_padding"):
+                del module.asymmetric_padding

invokeai/backend/util/__init__.py

@@ -2,6 +2,7 @@
 Initialization file for invokeai.backend.util
 """
 
+from .devices import choose_precision, choose_torch_device
 from .logging import InvokeAILogger
 from .util import GIG, Chdir, directory_size
 
@@ -10,4 +11,6 @@ __all__ = [
     "directory_size",
     "Chdir",
     "InvokeAILogger",
+    "choose_precision",
+    "choose_torch_device",
 ]

invokeai/backend/util/catch_sigint.py

@@ -1,29 +0,0 @@
-"""
-This module defines a context manager `catch_sigint()` which temporarily replaces
-the sigINT handler defined by the ASGI in order to allow the user to ^C the application
-and shut it down immediately. This was implemented in order to allow the user to interrupt
-slow model hashing during startup.
-
-Use like this:
-
-  from invokeai.backend.util.catch_sigint import catch_sigint
-  with catch_sigint():
-      run_some_hard_to_interrupt_process()
-"""
-
-import signal
-from contextlib import contextmanager
-from typing import Generator
-
-
-def sigint_handler(signum, frame):  # type: ignore
-    signal.signal(signal.SIGINT, signal.SIG_DFL)
-    signal.raise_signal(signal.SIGINT)
-
-
-@contextmanager
-def catch_sigint() -> Generator[None, None, None]:
-    original_handler = signal.getsignal(signal.SIGINT)
-    signal.signal(signal.SIGINT, sigint_handler)
-    yield
-    signal.signal(signal.SIGINT, original_handler)

invokeai/backend/util/devices.py

@@ -1,110 +1,89 @@
-from typing import Dict, Literal, Optional, Union
+from __future__ import annotations
+
+from contextlib import nullcontext
+from typing import Literal, Optional, Union
 
 import torch
-from deprecated import deprecated
+from torch import autocast
 
-from invokeai.app.services.config.config_default import get_config
+from invokeai.app.services.config.config_default import PRECISION, get_config
 
-# legacy APIs
-TorchPrecisionNames = Literal["float32", "float16", "bfloat16"]
 CPU_DEVICE = torch.device("cpu")
 CUDA_DEVICE = torch.device("cuda")
 MPS_DEVICE = torch.device("mps")
 
 
-@deprecated("Use TorchDevice.choose_torch_dtype() instead.")  # type: ignore
-def choose_precision(device: torch.device) -> TorchPrecisionNames:
-    """Return the string representation of the recommended torch device."""
-    torch_dtype = TorchDevice.choose_torch_dtype(device)
-    return PRECISION_TO_NAME[torch_dtype]
-
-
-@deprecated("Use TorchDevice.choose_torch_device() instead.")  # type: ignore
 def choose_torch_device() -> torch.device:
-    """Return the torch.device to use for accelerated inference."""
-    return TorchDevice.choose_torch_device()
-
-
-@deprecated("Use TorchDevice.choose_torch_dtype() instead.")  # type: ignore
-def torch_dtype(device: torch.device) -> torch.dtype:
-    """Return the torch precision for the recommended torch device."""
-    return TorchDevice.choose_torch_dtype(device)
-
-
-NAME_TO_PRECISION: Dict[TorchPrecisionNames, torch.dtype] = {
-    "float32": torch.float32,
-    "float16": torch.float16,
-    "bfloat16": torch.bfloat16,
-}
-PRECISION_TO_NAME: Dict[torch.dtype, TorchPrecisionNames] = {v: k for k, v in NAME_TO_PRECISION.items()}
-
-
-class TorchDevice:
-    """Abstraction layer for torch devices."""
-
-    @classmethod
-    def choose_torch_device(cls) -> torch.device:
-        """Return the torch.device to use for accelerated inference."""
-        app_config = get_config()
-        if app_config.device != "auto":
-            device = torch.device(app_config.device)
-        elif torch.cuda.is_available():
-            device = CUDA_DEVICE
-        elif torch.backends.mps.is_available():
-            device = MPS_DEVICE
-        else:
-            device = CPU_DEVICE
-        return cls.normalize(device)
-
-    @classmethod
-    def choose_torch_dtype(cls, device: Optional[torch.device] = None) -> torch.dtype:
-        """Return the precision to use for accelerated inference."""
-        device = device or cls.choose_torch_device()
-        config = get_config()
-        if device.type == "cuda" and torch.cuda.is_available():
-            device_name = torch.cuda.get_device_name(device)
-            if "GeForce GTX 1660" in device_name or "GeForce GTX 1650" in device_name:
-                # These GPUs have limited support for float16
-                return cls._to_dtype("float32")
-            elif config.precision == "auto":
-                # Default to float16 for CUDA devices
-                return cls._to_dtype("float16")
-            else:
-                # Use the user-defined precision
-                return cls._to_dtype(config.precision)
-
-        elif device.type == "mps" and torch.backends.mps.is_available():
-            if config.precision == "auto":
-                # Default to float16 for MPS devices
-                return cls._to_dtype("float16")
-            else:
-                # Use the user-defined precision
-                return cls._to_dtype(config.precision)
-        # CPU / safe fallback
-        return cls._to_dtype("float32")
-
-    @classmethod
-    def get_torch_device_name(cls) -> str:
-        """Return the device name for the current torch device."""
-        device = cls.choose_torch_device()
-        return torch.cuda.get_device_name(device) if device.type == "cuda" else device.type.upper()
-
-    @classmethod
-    def normalize(cls, device: Union[str, torch.device]) -> torch.device:
-        """Add the device index to CUDA devices."""
-        device = torch.device(device)
-        if device.index is None and device.type == "cuda" and torch.cuda.is_available():
-            device = torch.device(device.type, torch.cuda.current_device())
-        return device
-
-    @classmethod
-    def empty_cache(cls) -> None:
-        """Clear the GPU device cache."""
-        if torch.backends.mps.is_available():
-            torch.mps.empty_cache()
+    """Convenience routine for guessing which GPU device to run model on"""
+    config = get_config()
+    if config.device == "auto":
         if torch.cuda.is_available():
-            torch.cuda.empty_cache()
+            return torch.device("cuda")
+        if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+            return torch.device("mps")
+        else:
+            return CPU_DEVICE
+    else:
+        return torch.device(config.device)
 
-    @classmethod
-    def _to_dtype(cls, precision_name: TorchPrecisionNames) -> torch.dtype:
-        return NAME_TO_PRECISION[precision_name]
+
+def get_torch_device_name() -> str:
+    device = choose_torch_device()
+    return torch.cuda.get_device_name(device) if device.type == "cuda" else device.type.upper()
+
+
+def choose_precision(device: torch.device) -> Literal["float32", "float16", "bfloat16"]:
+    """Return an appropriate precision for the given torch device."""
+    app_config = get_config()
+    if device.type == "cuda":
+        device_name = torch.cuda.get_device_name(device)
+        if "GeForce GTX 1660" in device_name or "GeForce GTX 1650" in device_name:
+            # These GPUs have limited support for float16
+            return "float32"
+        elif app_config.precision == "auto" or app_config.precision == "autocast":
+            # Default to float16 for CUDA devices
+            return "float16"
+        else:
+            # Use the user-defined precision
+            return app_config.precision
+    elif device.type == "mps":
+        if app_config.precision == "auto" or app_config.precision == "autocast":
+            # Default to float16 for MPS devices
+            return "float16"
+        else:
+            # Use the user-defined precision
+            return app_config.precision
+    # CPU / safe fallback
+    return "float32"
+
+
+def torch_dtype(device: Optional[torch.device] = None) -> torch.dtype:
+    device = device or choose_torch_device()
+    precision = choose_precision(device)
+    if precision == "float16":
+        return torch.float16
+    if precision == "bfloat16":
+        return torch.bfloat16
+    else:
+        # "auto", "autocast", "float32"
+        return torch.float32
+
+
+def choose_autocast(precision: PRECISION):
+    """Returns an autocast context or nullcontext for the given precision string"""
+    # float16 currently requires autocast to avoid errors like:
+    # 'expected scalar type Half but found Float'
+    if precision == "autocast" or precision == "float16":
+        return autocast
+    return nullcontext
+
+
+def normalize_device(device: Union[str, torch.device]) -> torch.device:
+    """Ensure device has a device index defined, if appropriate."""
+    device = torch.device(device)
+    if device.index is None:
+        # cuda might be the only torch backend that currently uses the device index?
+        # I don't see anything like `current_device` for cpu or mps.
+        if device.type == "cuda":
+            device = torch.device(device.type, torch.cuda.current_device())
+    return device

invokeai/configs/stable-diffusion/sd_xl_inpaint.yaml

@@ -1,98 +0,0 @@
-model:
-  target: sgm.models.diffusion.DiffusionEngine
-  params:
-    scale_factor: 0.13025
-    disable_first_stage_autocast: True
-
-    denoiser_config:
-      target: sgm.modules.diffusionmodules.denoiser.DiscreteDenoiser
-      params:
-        num_idx: 1000
-
-        weighting_config:
-          target: sgm.modules.diffusionmodules.denoiser_weighting.EpsWeighting
-        scaling_config:
-          target: sgm.modules.diffusionmodules.denoiser_scaling.EpsScaling
-        discretization_config:
-          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
-
-    network_config:
-      target: sgm.modules.diffusionmodules.openaimodel.UNetModel
-      params:
-        adm_in_channels: 2816
-        num_classes: sequential
-        use_checkpoint: True
-        in_channels: 9
-        out_channels: 4
-        model_channels: 320
-        attention_resolutions: [4, 2]
-        num_res_blocks: 2
-        channel_mult: [1, 2, 4]
-        num_head_channels: 64
-        use_spatial_transformer: True
-        use_linear_in_transformer: True
-        transformer_depth: [1, 2, 10]  # note: the first is unused (due to attn_res starting at 2) 32, 16, 8 --> 64, 32, 16
-        context_dim: 2048
-        spatial_transformer_attn_type: softmax-xformers
-        legacy: False
-
-    conditioner_config:
-      target: sgm.modules.GeneralConditioner
-      params:
-        emb_models:
-          # crossattn cond
-          - is_trainable: False
-            input_key: txt
-            target: sgm.modules.encoders.modules.FrozenCLIPEmbedder
-            params:
-              layer: hidden
-              layer_idx: 11
-          # crossattn and vector cond
-          - is_trainable: False
-            input_key: txt
-            target: sgm.modules.encoders.modules.FrozenOpenCLIPEmbedder2
-            params:
-              arch: ViT-bigG-14
-              version: laion2b_s39b_b160k
-              freeze: True
-              layer: penultimate
-              always_return_pooled: True
-              legacy: False
-          # vector cond
-          - is_trainable: False
-            input_key: original_size_as_tuple
-            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
-            params:
-              outdim: 256  # multiplied by two
-          # vector cond
-          - is_trainable: False
-            input_key: crop_coords_top_left
-            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
-            params:
-              outdim: 256  # multiplied by two
-          # vector cond
-          - is_trainable: False
-            input_key: target_size_as_tuple
-            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
-            params:
-              outdim: 256  # multiplied by two
-
-    first_stage_config:
-      target: sgm.models.autoencoder.AutoencoderKLInferenceWrapper
-      params:
-        embed_dim: 4
-        monitor: val/rec_loss
-        ddconfig:
-          attn_type: vanilla-xformers
-          double_z: true
-          z_channels: 4
-          resolution: 256
-          in_channels: 3
-          out_ch: 3
-          ch: 128
-          ch_mult: [1, 2, 4, 4]
-          num_res_blocks: 2
-          attn_resolutions: []
-          dropout: 0.0
-        lossconfig:
-          target: torch.nn.Identity

invokeai/frontend/web/.storybook/preview.tsx

@@ -11,7 +11,6 @@ import { createStore } from '../src/app/store/store';
 // @ts-ignore
 import translationEN from '../public/locales/en.json';
 import { ReduxInit } from './ReduxInit';
-import { $store } from 'app/store/nanostores/store';
 
 i18n.use(initReactI18next).init({
   lng: 'en',
@@ -26,7 +25,6 @@ i18n.use(initReactI18next).init({
 });
 
 const store = createStore(undefined, false);
-$store.set(store);
 $baseUrl.set('http://localhost:9090');
 
 const preview: Preview = {

invokeai/frontend/web/package.json

@@ -52,61 +52,58 @@
   },
   "dependencies": {
     "@chakra-ui/react-use-size": "^2.1.0",
-    "@dagrejs/dagre": "^1.1.2",
-    "@dagrejs/graphlib": "^2.2.2",
+    "@dagrejs/dagre": "^1.1.1",
+    "@dagrejs/graphlib": "^2.2.1",
     "@dnd-kit/core": "^6.1.0",
     "@dnd-kit/sortable": "^8.0.0",
     "@dnd-kit/utilities": "^3.2.2",
-    "@fontsource-variable/inter": "^5.0.18",
-    "@invoke-ai/ui-library": "^0.0.25",
+    "@fontsource-variable/inter": "^5.0.17",
+    "@invoke-ai/ui-library": "^0.0.21",
     "@nanostores/react": "^0.7.2",
-    "@reduxjs/toolkit": "2.2.3",
+    "@reduxjs/toolkit": "2.2.2",
     "@roarr/browser-log-writer": "^1.3.0",
     "chakra-react-select": "^4.7.6",
     "compare-versions": "^6.1.0",
     "dateformat": "^5.0.3",
-    "fracturedjsonjs": "^4.0.1",
-    "framer-motion": "^11.1.8",
-    "i18next": "^23.11.3",
-    "i18next-http-backend": "^2.5.1",
+    "framer-motion": "^11.0.22",
+    "i18next": "^23.10.1",
+    "i18next-http-backend": "^2.5.0",
     "idb-keyval": "^6.2.1",
     "jsondiffpatch": "^0.6.0",
     "konva": "^9.3.6",
     "lodash-es": "^4.17.21",
-    "nanostores": "^0.10.3",
+    "nanostores": "^0.10.0",
     "new-github-issue-url": "^1.0.0",
-    "overlayscrollbars": "^2.7.3",
-    "overlayscrollbars-react": "^0.5.6",
+    "overlayscrollbars": "^2.6.1",
+    "overlayscrollbars-react": "^0.5.5",
     "query-string": "^9.0.0",
-    "react": "^18.3.1",
+    "react": "^18.2.0",
     "react-colorful": "^5.6.1",
-    "react-dom": "^18.3.1",
+    "react-dom": "^18.2.0",
     "react-dropzone": "^14.2.3",
     "react-error-boundary": "^4.0.13",
-    "react-hook-form": "^7.51.4",
+    "react-hook-form": "^7.51.2",
     "react-hotkeys-hook": "4.5.0",
-    "react-i18next": "^14.1.1",
-    "react-icons": "^5.2.0",
+    "react-i18next": "^14.1.0",
+    "react-icons": "^5.0.1",
     "react-konva": "^18.2.10",
-    "react-redux": "9.1.2",
-    "react-resizable-panels": "^2.0.19",
+    "react-redux": "9.1.0",
+    "react-resizable-panels": "^2.0.16",
     "react-select": "5.8.0",
     "react-use": "^17.5.0",
-    "react-virtuoso": "^4.7.10",
-    "reactflow": "^11.11.3",
+    "react-virtuoso": "^4.7.5",
+    "reactflow": "^11.10.4",
     "redux-dynamic-middlewares": "^2.2.0",
     "redux-remember": "^5.1.0",
-    "redux-undo": "^1.1.0",
     "rfdc": "^1.3.1",
     "roarr": "^7.21.1",
     "serialize-error": "^11.0.3",
     "socket.io-client": "^4.7.5",
     "use-debounce": "^10.0.0",
-    "use-device-pixel-ratio": "^1.1.2",
     "use-image": "^1.1.1",
     "uuid": "^9.0.1",
-    "zod": "^3.23.6",
-    "zod-validation-error": "^3.2.0"
+    "zod": "^3.22.4",
+    "zod-validation-error": "^3.0.3"
   },
   "peerDependencies": {
     "@chakra-ui/react": "^2.8.2",
@@ -117,19 +114,19 @@
   "devDependencies": {
     "@invoke-ai/eslint-config-react": "^0.0.14",
     "@invoke-ai/prettier-config-react": "^0.0.7",
-    "@storybook/addon-essentials": "^8.0.10",
-    "@storybook/addon-interactions": "^8.0.10",
-    "@storybook/addon-links": "^8.0.10",
-    "@storybook/addon-storysource": "^8.0.10",
-    "@storybook/manager-api": "^8.0.10",
-    "@storybook/react": "^8.0.10",
-    "@storybook/react-vite": "^8.0.10",
-    "@storybook/theming": "^8.0.10",
+    "@storybook/addon-essentials": "^8.0.4",
+    "@storybook/addon-interactions": "^8.0.4",
+    "@storybook/addon-links": "^8.0.4",
+    "@storybook/addon-storysource": "^8.0.4",
+    "@storybook/manager-api": "^8.0.4",
+    "@storybook/react": "^8.0.4",
+    "@storybook/react-vite": "^8.0.4",
+    "@storybook/theming": "^8.0.4",
     "@types/dateformat": "^5.0.2",
     "@types/lodash-es": "^4.17.12",
-    "@types/node": "^20.12.10",
-    "@types/react": "^18.3.1",
-    "@types/react-dom": "^18.3.0",
+    "@types/node": "^20.11.30",
+    "@types/react": "^18.2.73",
+    "@types/react-dom": "^18.2.22",
     "@types/uuid": "^9.0.8",
     "@vitejs/plugin-react-swc": "^3.6.0",
     "concurrently": "^8.2.2",
@@ -137,20 +134,20 @@
     "eslint": "^8.57.0",
     "eslint-plugin-i18next": "^6.0.3",
     "eslint-plugin-path": "^1.3.0",
-    "knip": "^5.12.3",
+    "knip": "^5.6.1",
     "openapi-types": "^12.1.3",
     "openapi-typescript": "^6.7.5",
     "prettier": "^3.2.5",
     "rollup-plugin-visualizer": "^5.12.0",
-    "storybook": "^8.0.10",
+    "storybook": "^8.0.4",
     "ts-toolbelt": "^9.6.0",
     "tsafe": "^1.6.6",
-    "typescript": "^5.4.5",
-    "vite": "^5.2.11",
-    "vite-plugin-css-injected-by-js": "^3.5.1",
-    "vite-plugin-dts": "^3.9.1",
+    "typescript": "^5.4.3",
+    "vite": "^5.2.6",
+    "vite-plugin-css-injected-by-js": "^3.5.0",
+    "vite-plugin-dts": "^3.8.0",
     "vite-plugin-eslint": "^1.8.1",
     "vite-tsconfig-paths": "^4.3.2",
-    "vitest": "^1.6.0"
+    "vitest": "^1.4.0"
   }
 }

invokeai/frontend/web/public/locales/de.json

@@ -76,9 +76,7 @@
         "aboutHeading": "Nutzen Sie Ihre kreative Energie",
         "toResolve": "Lösen",
         "add": "Hinzufügen",
-        "loglevel": "Protokoll Stufe",
-        "selected": "Ausgewählt",
-        "beta": "Beta"
+        "loglevel": "Protokoll Stufe"
     },
     "gallery": {
         "galleryImageSize": "Bildgröße",
@@ -87,8 +85,7 @@
         "loadMore": "Mehr laden",
         "noImagesInGallery": "Keine Bilder in der Galerie",
         "loading": "Lade",
-        "deleteImage_one": "Lösche Bild",
-        "deleteImage_other": "Lösche {{count}} Bilder",
+        "deleteImage": "Lösche Bild",
         "copy": "Kopieren",
         "download": "Runterladen",
         "setCurrentImage": "Setze aktuelle Bild",
@@ -399,14 +396,7 @@
         "cancel": "Stornieren",
         "defaultSettingsSaved": "Standardeinstellungen gespeichert",
         "addModels": "Model hinzufügen",
-        "deleteModelImage": "Lösche Model Bild",
-        "hfTokenInvalidErrorMessage": "Falscher oder fehlender HuggingFace Schlüssel.",
-        "huggingFaceRepoID": "HuggingFace Repo ID",
-        "hfToken": "HuggingFace Schlüssel",
-        "hfTokenInvalid": "Falscher oder fehlender HF Schlüssel",
-        "huggingFacePlaceholder": "besitzer/model-name",
-        "hfTokenSaved": "HF Schlüssel gespeichert",
-        "hfTokenUnableToVerify": "Konnte den HF Schlüssel nicht validieren"
+        "deleteModelImage": "Lösche Model Bild"
     },
     "parameters": {
         "images": "Bilder",
@@ -695,11 +685,7 @@
         "hands": "Hände",
         "dwOpenpose": "DW Openpose",
         "dwOpenposeDescription": "Posenschätzung mit DW Openpose",
-        "selectCLIPVisionModel": "Wähle ein CLIP Vision Model aus",
-        "ipAdapterMethod": "Methode",
-        "composition": "Nur Komposition",
-        "full": "Voll",
-        "style": "Nur Style"
+        "selectCLIPVisionModel": "Wähle ein CLIP Vision Model aus"
     },
     "queue": {
         "status": "Status",
@@ -730,6 +716,7 @@
         "resume": "Wieder aufnehmen",
         "item": "Auftrag",
         "notReady": "Warteschlange noch nicht bereit",
+        "queueCountPrediction": "{{promptsCount}} Prompts × {{iterations}} Iterationen -> {{count}} Generationen",
         "clearQueueAlertDialog": "\"Die Warteschlange leeren\" stoppt den aktuellen Prozess und leert die Warteschlange komplett.",
         "completedIn": "Fertig in",
         "cancelBatchSucceeded": "Stapel abgebrochen",

invokeai/frontend/web/public/locales/en.json

@@ -69,7 +69,6 @@
         "auto": "Auto",
         "back": "Back",
         "batch": "Batch Manager",
-        "beta": "Beta",
         "cancel": "Cancel",
         "copy": "Copy",
         "copyError": "$t(gallery.copy) Error",
@@ -84,17 +83,13 @@
         "direction": "Direction",
         "ipAdapter": "IP Adapter",
         "t2iAdapter": "T2I Adapter",
-        "positivePrompt": "Positive Prompt",
-        "negativePrompt": "Negative Prompt",
         "discordLabel": "Discord",
         "dontAskMeAgain": "Don't ask me again",
-        "editor": "Editor",
         "error": "Error",
         "file": "File",
         "folder": "Folder",
         "format": "format",
         "githubLabel": "Github",
-        "goTo": "Go to",
         "hotkeysLabel": "Hotkeys",
         "imageFailedToLoad": "Unable to Load Image",
         "img2img": "Image To Image",
@@ -140,13 +135,7 @@
         "red": "Red",
         "green": "Green",
         "blue": "Blue",
-        "alpha": "Alpha",
-        "selected": "Selected",
-        "tab": "Tab",
-        "viewing": "Viewing",
-        "viewingDesc": "Review images in a large gallery view",
-        "editing": "Editing",
-        "editingDesc": "Edit on the Control Layers canvas"
+        "alpha": "Alpha"
     },
     "controlnet": {
         "controlAdapter_one": "Control Adapter",
@@ -162,7 +151,6 @@
         "balanced": "Balanced",
         "base": "Base",
         "beginEndStepPercent": "Begin / End Step Percentage",
-        "beginEndStepPercentShort": "Begin/End %",
         "bgth": "bg_th",
         "canny": "Canny",
         "cannyDescription": "Canny edge detection",
@@ -225,17 +213,12 @@
         "resize": "Resize",
         "resizeSimple": "Resize (Simple)",
         "resizeMode": "Resize Mode",
-        "ipAdapterMethod": "Method",
-        "full": "Full",
-        "style": "Style Only",
-        "composition": "Composition Only",
         "safe": "Safe",
         "saveControlImage": "Save Control Image",
-        "scribble": "Scribble",
+        "scribble": "scribble",
         "selectModel": "Select a model",
         "selectCLIPVisionModel": "Select a CLIP Vision model",
-        "setControlImageDimensions": "Copy size to W/H (optimize for model)",
-        "setControlImageDimensionsForce": "Copy size to W/H (ignore model)",
+        "setControlImageDimensions": "Set Control Image Dimensions To W/H",
         "showAdvanced": "Show Advanced",
         "small": "Small",
         "toggleControlNet": "Toggle this ControlNet",
@@ -261,6 +244,7 @@
         "queue": "Queue",
         "queueFront": "Add to Front of Queue",
         "queueBack": "Add to Queue",
+        "queueCountPrediction": "{{promptsCount}} prompts \u00d7 {{iterations}} iterations -> {{count}} generations",
         "queueEmpty": "Queue Empty",
         "enqueueing": "Queueing Batch",
         "resume": "Resume",
@@ -313,13 +297,7 @@
         "batchFailedToQueue": "Failed to Queue Batch",
         "graphQueued": "Graph queued",
         "graphFailedToQueue": "Failed to queue graph",
-        "openQueue": "Open Queue",
-        "prompts_one": "Prompt",
-        "prompts_other": "Prompts",
-        "iterations_one": "Iteration",
-        "iterations_other": "Iterations",
-        "generations_one": "Generation",
-        "generations_other": "Generations"
+        "openQueue": "Open Queue"
     },
     "invocationCache": {
         "invocationCache": "Invocation Cache",
@@ -595,10 +573,6 @@
         "upscale": {
             "desc": "Upscale the current image",
             "title": "Upscale"
-        },
-        "toggleViewer": {
-            "desc": "Switches between the Image Viewer and workspace for the current tab.",
-            "title": "Toggle Image Viewer"
         }
     },
     "metadata": {
@@ -796,8 +770,6 @@
         "float": "Float",
         "fullyContainNodes": "Fully Contain Nodes to Select",
         "fullyContainNodesHelp": "Nodes must be fully inside the selection box to be selected",
-        "showEdgeLabels": "Show Edge Labels",
-        "showEdgeLabelsHelp": "Show labels on edges, indicating the connected nodes",
         "hideLegendNodes": "Hide Field Type Legend",
         "hideMinimapnodes": "Hide MiniMap",
         "inputMayOnlyHaveOneConnection": "Input may only have one connection",
@@ -914,7 +886,6 @@
         "denoisingStrength": "Denoising Strength",
         "downloadImage": "Download Image",
         "general": "General",
-        "globalSettings": "Global Settings",
         "height": "Height",
         "imageFit": "Fit Initial Image To Output Size",
         "images": "Images",
@@ -932,37 +903,23 @@
             "missingInputForField": "{{nodeLabel}} -> {{fieldLabel}} missing input",
             "missingNodeTemplate": "Missing node template",
             "noControlImageForControlAdapter": "Control Adapter #{{number}} has no control image",
-            "imageNotProcessedForControlAdapter": "Control Adapter #{{number}}'s image is not processed",
             "noInitialImageSelected": "No initial image selected",
             "noModelForControlAdapter": "Control Adapter #{{number}} has no model selected.",
             "incompatibleBaseModelForControlAdapter": "Control Adapter #{{number}} model is incompatible with main model.",
             "noModelSelected": "No model selected",
             "noPrompts": "No prompts generated",
             "noNodesInGraph": "No nodes in graph",
-            "systemDisconnected": "System disconnected",
-            "layer": {
-                "initialImageNoImageSelected": "no initial image selected",
-                "controlAdapterNoModelSelected": "no Control Adapter model selected",
-                "controlAdapterIncompatibleBaseModel": "incompatible Control Adapter base model",
-                "controlAdapterNoImageSelected": "no Control Adapter image selected",
-                "controlAdapterImageNotProcessed": "Control Adapter image not processed",
-                "t2iAdapterIncompatibleDimensions": "T2I Adapter requires image dimension to be multiples of 64",
-                "ipAdapterNoModelSelected": "no IP adapter selected",
-                "ipAdapterIncompatibleBaseModel": "incompatible IP Adapter base model",
-                "ipAdapterNoImageSelected": "no IP Adapter image selected",
-                "rgNoPromptsOrIPAdapters": "no text prompts or IP Adapters",
-                "rgNoRegion": "no region selected"
-            }
+            "systemDisconnected": "System disconnected"
         },
         "maskBlur": "Mask Blur",
         "negativePromptPlaceholder": "Negative Prompt",
-        "globalNegativePromptPlaceholder": "Global Negative Prompt",
         "noiseThreshold": "Noise Threshold",
         "patchmatchDownScaleSize": "Downscale",
         "perlinNoise": "Perlin Noise",
         "positivePromptPlaceholder": "Positive Prompt",
-        "globalPositivePromptPlaceholder": "Global Positive Prompt",
         "iterations": "Iterations",
+        "iterationsWithCount_one": "{{count}} Iteration",
+        "iterationsWithCount_other": "{{count}} Iterations",
         "scale": "Scale",
         "scaleBeforeProcessing": "Scale Before Processing",
         "scaledHeight": "Scaled H",
@@ -1219,10 +1176,6 @@
             "heading": "Resize Mode",
             "paragraphs": ["Method to fit Control Adapter's input image size to the output generation size."]
         },
-        "ipAdapterMethod": {
-            "heading": "Method",
-            "paragraphs": ["Method by which to apply the current IP Adapter."]
-        },
         "controlNetWeight": {
             "heading": "Weight",
             "paragraphs": [
@@ -1541,55 +1494,5 @@
     },
     "app": {
         "storeNotInitialized": "Store is not initialized"
-    },
-    "controlLayers": {
-        "deleteAll": "Delete All",
-        "addLayer": "Add Layer",
-        "moveToFront": "Move to Front",
-        "moveToBack": "Move to Back",
-        "moveForward": "Move Forward",
-        "moveBackward": "Move Backward",
-        "brushSize": "Brush Size",
-        "controlLayers": "Control Layers",
-        "globalMaskOpacity": "Global Mask Opacity",
-        "autoNegative": "Auto Negative",
-        "toggleVisibility": "Toggle Layer Visibility",
-        "deletePrompt": "Delete Prompt",
-        "resetRegion": "Reset Region",
-        "debugLayers": "Debug Layers",
-        "rectangle": "Rectangle",
-        "maskPreviewColor": "Mask Preview Color",
-        "addPositivePrompt": "Add $t(common.positivePrompt)",
-        "addNegativePrompt": "Add $t(common.negativePrompt)",
-        "addIPAdapter": "Add $t(common.ipAdapter)",
-        "regionalGuidance": "Regional Guidance",
-        "regionalGuidanceLayer": "$t(controlLayers.regionalGuidance) $t(unifiedCanvas.layer)",
-        "opacity": "Opacity",
-        "globalControlAdapter": "Global $t(controlnet.controlAdapter_one)",
-        "globalControlAdapterLayer": "Global $t(controlnet.controlAdapter_one) $t(unifiedCanvas.layer)",
-        "globalIPAdapter": "Global $t(common.ipAdapter)",
-        "globalIPAdapterLayer": "Global $t(common.ipAdapter) $t(unifiedCanvas.layer)",
-        "globalInitialImage": "Global Initial Image",
-        "globalInitialImageLayer": "$t(controlLayers.globalInitialImage) $t(unifiedCanvas.layer)",
-        "opacityFilter": "Opacity Filter",
-        "clearProcessor": "Clear Processor",
-        "resetProcessor": "Reset Processor to Defaults",
-        "noLayersAdded": "No Layers Added",
-        "layers_one": "Layer",
-        "layers_other": "Layers"
-    },
-    "ui": {
-        "tabs": {
-            "generation": "Generation",
-            "generationTab": "$t(ui.tabs.generation) $t(common.tab)",
-            "canvas": "Canvas",
-            "canvasTab": "$t(ui.tabs.canvas) $t(common.tab)",
-            "workflows": "Workflows",
-            "workflowsTab": "$t(ui.tabs.workflows) $t(common.tab)",
-            "models": "Models",
-            "modelsTab": "$t(ui.tabs.models) $t(common.tab)",
-            "queue": "Queue",
-            "queueTab": "$t(ui.tabs.queue) $t(common.tab)"
-        }
     }
 }

invokeai/frontend/web/public/locales/es.json

@@ -25,24 +25,7 @@
         "areYouSure": "¿Estas seguro?",
         "batch": "Administrador de lotes",
         "modelManager": "Administrador de modelos",
-        "communityLabel": "Comunidad",
-        "direction": "Dirección",
-        "ai": "Ia",
-        "add": "Añadir",
-        "auto": "Automático",
-        "copyError": "Error $t(gallery.copy)",
-        "details": "Detalles",
-        "or": "o",
-        "checkpoint": "Punto de control",
-        "controlNet": "ControlNet",
-        "aboutHeading": "Sea dueño de su poder creativo",
-        "advanced": "Avanzado",
-        "data": "Fecha",
-        "delete": "Borrar",
-        "copy": "Copiar",
-        "beta": "Beta",
-        "on": "En",
-        "aboutDesc": "¿Utilizas Invoke para trabajar? Mira aquí:"
+        "communityLabel": "Comunidad"
     },
     "gallery": {
         "galleryImageSize": "Tamaño de la imagen",
@@ -50,9 +33,7 @@
         "autoSwitchNewImages": "Auto seleccionar Imágenes nuevas",
         "loadMore": "Cargar más",
         "noImagesInGallery": "No hay imágenes para mostrar",
-        "deleteImage_one": "Eliminar Imagen",
-        "deleteImage_many": "",
-        "deleteImage_other": "",
+        "deleteImage": "Eliminar Imagen",
         "deleteImageBin": "Las imágenes eliminadas se enviarán a la papelera de tu sistema operativo.",
         "deleteImagePermanent": "Las imágenes eliminadas no se pueden restaurar.",
         "assets": "Activos",
@@ -460,13 +441,7 @@
         "previousImage": "Imagen anterior",
         "nextImage": "Siguiente imagen",
         "showOptionsPanel": "Mostrar el panel lateral",
-        "menu": "Menú",
-        "showGalleryPanel": "Mostrar panel de galería",
-        "loadMore": "Cargar más",
-        "about": "Acerca de",
-        "createIssue": "Crear un problema",
-        "resetUI": "Interfaz de usuario $t(accessibility.reset)",
-        "mode": "Modo"
+        "menu": "Menú"
     },
     "nodes": {
         "zoomInNodes": "Acercar",
@@ -479,68 +454,5 @@
         "reloadNodeTemplates": "Recargar las plantillas de nodos",
         "loadWorkflow": "Cargar el flujo de trabajo",
         "downloadWorkflow": "Descargar el flujo de trabajo en un archivo JSON"
-    },
-    "boards": {
-        "autoAddBoard": "Agregar panel automáticamente",
-        "changeBoard": "Cambiar el panel",
-        "clearSearch": "Borrar la búsqueda",
-        "deleteBoard": "Borrar el panel",
-        "selectBoard": "Seleccionar un panel",
-        "uncategorized": "Sin categoría",
-        "cancel": "Cancelar",
-        "addBoard": "Agregar un panel",
-        "movingImagesToBoard_one": "Moviendo {{count}} imagen al panel:",
-        "movingImagesToBoard_many": "Moviendo {{count}} imágenes al panel:",
-        "movingImagesToBoard_other": "Moviendo {{count}} imágenes al panel:",
-        "bottomMessage": "Al eliminar este panel y las imágenes que contiene, se restablecerán las funciones que los estén utilizando actualmente.",
-        "deleteBoardAndImages": "Borrar el panel y las imágenes",
-        "loading": "Cargando...",
-        "deletedBoardsCannotbeRestored": "Los paneles eliminados no se pueden restaurar",
-        "move": "Mover",
-        "menuItemAutoAdd": "Agregar automáticamente a este panel",
-        "searchBoard": "Buscando paneles…",
-        "topMessage": "Este panel contiene imágenes utilizadas en las siguientes funciones:",
-        "downloadBoard": "Descargar panel",
-        "deleteBoardOnly": "Borrar solo el panel",
-        "myBoard": "Mi panel",
-        "noMatching": "No hay paneles que coincidan"
-    },
-    "accordions": {
-        "compositing": {
-            "title": "Composición",
-            "infillTab": "Relleno"
-        },
-        "generation": {
-            "title": "Generación"
-        },
-        "image": {
-            "title": "Imagen"
-        },
-        "control": {
-            "title": "Control"
-        },
-        "advanced": {
-            "options": "$t(accordions.advanced.title) opciones",
-            "title": "Avanzado"
-        }
-    },
-    "ui": {
-        "tabs": {
-            "generationTab": "$t(ui.tabs.generation) $t(common.tab)",
-            "canvas": "Lienzo",
-            "generation": "Generación",
-            "queue": "Cola",
-            "queueTab": "$t(ui.tabs.queue) $t(common.tab)",
-            "workflows": "Flujos de trabajo",
-            "models": "Modelos",
-            "modelsTab": "$t(ui.tabs.models) $t(common.tab)",
-            "canvasTab": "$t(ui.tabs.canvas) $t(common.tab)",
-            "workflowsTab": "$t(ui.tabs.workflows) $t(common.tab)"
-        }
-    },
-    "controlLayers": {
-        "layers_one": "Capa",
-        "layers_many": "Capas",
-        "layers_other": "Capas"
     }
 }

invokeai/frontend/web/public/locales/it.json

@@ -5,7 +5,7 @@
         "reportBugLabel": "Segnala un errore",
         "settingsLabel": "Impostazioni",
         "img2img": "Immagine a Immagine",
-        "unifiedCanvas": "Tela",
+        "unifiedCanvas": "Tela unificata",
         "nodes": "Flussi di lavoro",
         "upload": "Caricamento",
         "load": "Carica",
@@ -74,18 +74,7 @@
         "file": "File",
         "toResolve": "Da risolvere",
         "add": "Aggiungi",
-        "loglevel": "Livello di log",
-        "beta": "Beta",
-        "positivePrompt": "Prompt positivo",
-        "negativePrompt": "Prompt negativo",
-        "selected": "Selezionato",
-        "goTo": "Vai a",
-        "editor": "Editor",
-        "tab": "Scheda",
-        "viewing": "Visualizza",
-        "viewingDesc": "Rivedi le immagini in un'ampia vista della galleria",
-        "editing": "Modifica",
-        "editingDesc": "Modifica nell'area Livelli di controllo"
+        "loglevel": "Livello di log"
     },
     "gallery": {
         "galleryImageSize": "Dimensione dell'immagine",
@@ -93,9 +82,7 @@
         "autoSwitchNewImages": "Passaggio automatico a nuove immagini",
         "loadMore": "Carica altro",
         "noImagesInGallery": "Nessuna immagine da visualizzare",
-        "deleteImage_one": "Elimina l'immagine",
-        "deleteImage_many": "Elimina {{count}} immagini",
-        "deleteImage_other": "Elimina {{count}} immagini",
+        "deleteImage": "Elimina l'immagine",
         "deleteImagePermanent": "Le immagini eliminate non possono essere ripristinate.",
         "deleteImageBin": "Le immagini eliminate verranno spostate nel cestino del tuo sistema operativo.",
         "assets": "Risorse",
@@ -191,8 +178,8 @@
             "desc": "Mostra le informazioni sui metadati dell'immagine corrente"
         },
         "sendToImageToImage": {
-            "title": "Invia a Generazione da immagine",
-            "desc": "Invia l'immagine corrente a Generazione da immagine"
+            "title": "Invia a Immagine a Immagine",
+            "desc": "Invia l'immagine corrente a da Immagine a Immagine"
         },
         "deleteImage": {
             "title": "Elimina immagine",
@@ -345,10 +332,6 @@
         "remixImage": {
             "desc": "Utilizza tutti i parametri tranne il seme dell'immagine corrente",
             "title": "Remixa l'immagine"
-        },
-        "toggleViewer": {
-            "title": "Attiva/disattiva il visualizzatore di immagini",
-            "desc": "Passa dal Visualizzatore immagini all'area di lavoro per la scheda corrente."
         }
     },
     "modelManager": {
@@ -486,8 +469,8 @@
         "scaledHeight": "Altezza ridimensionata",
         "infillMethod": "Metodo di riempimento",
         "tileSize": "Dimensione piastrella",
-        "sendToImg2Img": "Invia a Generazione da immagine",
-        "sendToUnifiedCanvas": "Invia alla Tela",
+        "sendToImg2Img": "Invia a Immagine a Immagine",
+        "sendToUnifiedCanvas": "Invia a Tela Unificata",
         "downloadImage": "Scarica l'immagine",
         "usePrompt": "Usa Prompt",
         "useSeed": "Usa Seme",
@@ -523,11 +506,13 @@
             "incompatibleBaseModelForControlAdapter": "Il modello dell'adattatore di controllo #{{number}} non è compatibile con il modello principale.",
             "missingNodeTemplate": "Modello di nodo mancante",
             "missingInputForField": "{{nodeLabel}} -> {{fieldLabel}} ingresso mancante",
-            "missingFieldTemplate": "Modello di campo mancante",
-            "imageNotProcessedForControlAdapter": "L'immagine dell'adattatore di controllo #{{number}} non è stata elaborata"
+            "missingFieldTemplate": "Modello di campo mancante"
         },
         "useCpuNoise": "Usa la CPU per generare rumore",
         "iterations": "Iterazioni",
+        "iterationsWithCount_one": "{{count}} Iterazione",
+        "iterationsWithCount_many": "{{count}} Iterazioni",
+        "iterationsWithCount_other": "{{count}} Iterazioni",
         "isAllowedToUpscale": {
             "useX2Model": "L'immagine è troppo grande per l'ampliamento con il modello x4, utilizza il modello x2",
             "tooLarge": "L'immagine è troppo grande per l'ampliamento, seleziona un'immagine più piccola"
@@ -547,10 +532,7 @@
         "infillMosaicMinColor": "Colore minimo",
         "infillMosaicMaxColor": "Colore massimo",
         "infillMosaicTileHeight": "Altezza piastrella",
-        "infillColorValue": "Colore di riempimento",
-        "globalSettings": "Impostazioni globali",
-        "globalPositivePromptPlaceholder": "Prompt positivo globale",
-        "globalNegativePromptPlaceholder": "Prompt negativo globale"
+        "infillColorValue": "Colore di riempimento"
     },
     "settings": {
         "models": "Modelli",
@@ -575,7 +557,7 @@
         "intermediatesCleared_one": "Cancellata {{count}} immagine intermedia",
         "intermediatesCleared_many": "Cancellate {{count}} immagini intermedie",
         "intermediatesCleared_other": "Cancellate {{count}} immagini intermedie",
-        "clearIntermediatesDesc1": "La cancellazione delle immagini intermedie ripristinerà lo stato della Tela e degli Adattatori di Controllo.",
+        "clearIntermediatesDesc1": "La cancellazione delle immagini intermedie ripristinerà lo stato di Tela Unificata e ControlNet.",
         "intermediatesClearedFailed": "Problema con la cancellazione delle immagini intermedie",
         "clearIntermediatesWithCount_one": "Cancella {{count}} immagine intermedia",
         "clearIntermediatesWithCount_many": "Cancella {{count}} immagini intermedie",
@@ -591,8 +573,8 @@
         "imageCopied": "Immagine copiata",
         "imageNotLoadedDesc": "Impossibile trovare l'immagine",
         "canvasMerged": "Tela unita",
-        "sentToImageToImage": "Inviato a Generazione da immagine",
-        "sentToUnifiedCanvas": "Inviato alla Tela",
+        "sentToImageToImage": "Inviato a Immagine a Immagine",
+        "sentToUnifiedCanvas": "Inviato a Tela Unificata",
         "parametersNotSet": "Parametri non impostati",
         "metadataLoadFailed": "Impossibile caricare i metadati",
         "serverError": "Errore del Server",
@@ -811,7 +793,7 @@
         "float": "In virgola mobile",
         "currentImageDescription": "Visualizza l'immagine corrente nell'editor dei nodi",
         "fieldTypesMustMatch": "I tipi di campo devono corrispondere",
-        "edge": "Collegamento",
+        "edge": "Bordo",
         "currentImage": "Immagine corrente",
         "integer": "Numero Intero",
         "inputMayOnlyHaveOneConnection": "L'ingresso può avere solo una connessione",
@@ -861,9 +843,7 @@
         "resetToDefaultValue": "Ripristina il valore predefinito",
         "noFieldsViewMode": "Questo flusso di lavoro non ha campi selezionati da visualizzare. Visualizza il flusso di lavoro completo per configurare i valori.",
         "edit": "Modifica",
-        "graph": "Grafico",
-        "showEdgeLabelsHelp": "Mostra etichette sui collegamenti, che indicano i nodi collegati",
-        "showEdgeLabels": "Mostra le etichette del collegamento"
+        "graph": "Grafico"
     },
     "boards": {
         "autoAddBoard": "Aggiungi automaticamente bacheca",
@@ -940,7 +920,7 @@
         "colorMapTileSize": "Dimensione piastrella",
         "mediapipeFaceDescription": "Rilevamento dei volti tramite Mediapipe",
         "hedDescription": "Rilevamento dei bordi nidificati olisticamente",
-        "setControlImageDimensions": "Copia le dimensioni in L/A (ottimizza per il modello)",
+        "setControlImageDimensions": "Imposta le dimensioni dell'immagine di controllo su L/A",
         "maxFaces": "Numero massimo di volti",
         "addT2IAdapter": "Aggiungi $t(common.t2iAdapter)",
         "addControlNet": "Aggiungi $t(common.controlNet)",
@@ -969,17 +949,12 @@
         "mediapipeFace": "Mediapipe Volto",
         "ip_adapter": "$t(controlnet.controlAdapter_one) #{{number}} ($t(common.ipAdapter))",
         "t2i_adapter": "$t(controlnet.controlAdapter_one) #{{number}} ($t(common.t2iAdapter))",
-        "selectCLIPVisionModel": "Seleziona un modello CLIP Vision",
-        "ipAdapterMethod": "Metodo",
-        "full": "Completo",
-        "composition": "Solo la composizione",
-        "style": "Solo lo stile",
-        "beginEndStepPercentShort": "Inizio/Fine %",
-        "setControlImageDimensionsForce": "Copia le dimensioni in L/A (ignora il modello)"
+        "selectCLIPVisionModel": "Seleziona un modello CLIP Vision"
     },
     "queue": {
         "queueFront": "Aggiungi all'inizio della coda",
         "queueBack": "Aggiungi alla coda",
+        "queueCountPrediction": "{{promptsCount}} prompt × {{iterations}} iterazioni -> {{count}} generazioni",
         "queue": "Coda",
         "status": "Stato",
         "pruneSucceeded": "Rimossi {{item_count}} elementi completati dalla coda",
@@ -1016,7 +991,7 @@
         "cancelBatchSucceeded": "Lotto annullato",
         "clearTooltip": "Annulla e cancella tutti gli elementi",
         "current": "Attuale",
-        "pauseTooltip": "Sospendi l'elaborazione",
+        "pauseTooltip": "Sospende l'elaborazione",
         "failed": "Falliti",
         "cancelItem": "Annulla l'elemento",
         "next": "Prossimo",
@@ -1417,12 +1392,6 @@
             "paragraphs": [
                 "La dimensione del bordo del passaggio di coerenza."
             ]
-        },
-        "ipAdapterMethod": {
-            "heading": "Metodo",
-            "paragraphs": [
-                "Metodo con cui applicare l'adattatore IP corrente."
-            ]
         }
     },
     "sdxl": {
@@ -1551,56 +1520,5 @@
         "compatibleEmbeddings": "Incorporamenti compatibili",
         "addPromptTrigger": "Aggiungi Trigger nel prompt",
         "noMatchingTriggers": "Nessun Trigger corrispondente"
-    },
-    "controlLayers": {
-        "opacityFilter": "Filtro opacità",
-        "deleteAll": "Cancella tutto",
-        "addLayer": "Aggiungi Livello",
-        "moveToFront": "Sposta in primo piano",
-        "moveToBack": "Sposta in fondo",
-        "moveForward": "Sposta avanti",
-        "moveBackward": "Sposta indietro",
-        "brushSize": "Dimensioni del pennello",
-        "globalMaskOpacity": "Opacità globale della maschera",
-        "autoNegative": "Auto Negativo",
-        "toggleVisibility": "Attiva/disattiva la visibilità dei livelli",
-        "deletePrompt": "Cancella il prompt",
-        "debugLayers": "Debug dei Livelli",
-        "rectangle": "Rettangolo",
-        "maskPreviewColor": "Colore anteprima maschera",
-        "addPositivePrompt": "Aggiungi $t(common.positivePrompt)",
-        "addNegativePrompt": "Aggiungi $t(common.negativePrompt)",
-        "addIPAdapter": "Aggiungi $t(common.ipAdapter)",
-        "regionalGuidance": "Guida regionale",
-        "regionalGuidanceLayer": "$t(unifiedCanvas.layer) $t(controlLayers.regionalGuidance)",
-        "opacity": "Opacità",
-        "globalControlAdapter": "$t(controlnet.controlAdapter_one) Globale",
-        "globalControlAdapterLayer": "$t(controlnet.controlAdapter_one) - $t(unifiedCanvas.layer) Globale",
-        "globalIPAdapter": "$t(common.ipAdapter) Globale",
-        "globalIPAdapterLayer": "$t(common.ipAdapter) - $t(unifiedCanvas.layer) Globale",
-        "globalInitialImage": "Immagine iniziale",
-        "globalInitialImageLayer": "$t(controlLayers.globalInitialImage) - $t(unifiedCanvas.layer) Globale",
-        "clearProcessor": "Cancella processore",
-        "resetProcessor": "Ripristina il processore alle impostazioni predefinite",
-        "noLayersAdded": "Nessun livello aggiunto",
-        "resetRegion": "Reimposta la regione",
-        "controlLayers": "Livelli di controllo",
-        "layers_one": "Livello",
-        "layers_many": "Livelli",
-        "layers_other": "Livelli"
-    },
-    "ui": {
-        "tabs": {
-            "generation": "Generazione",
-            "generationTab": "$t(ui.tabs.generation) $t(common.tab)",
-            "canvas": "Tela",
-            "canvasTab": "$t(ui.tabs.canvas) $t(common.tab)",
-            "workflows": "Flussi di lavoro",
-            "workflowsTab": "$t(ui.tabs.workflows) $t(common.tab)",
-            "models": "Modelli",
-            "modelsTab": "$t(ui.tabs.models) $t(common.tab)",
-            "queue": "Coda",
-            "queueTab": "$t(ui.tabs.queue) $t(common.tab)"
-        }
     }
 }

invokeai/frontend/web/public/locales/ja.json

@@ -90,7 +90,7 @@
         "problemDeletingImages": "画像の削除中に問題が発生",
         "drop": "ドロップ",
         "dropOrUpload": "$t(gallery.drop) またはアップロード",
-        "deleteImage_other": "画像を削除",
+        "deleteImage": "画像を削除",
         "deleteImageBin": "削除された画像はOSのゴミ箱に送られます。",
         "deleteImagePermanent": "削除された画像は復元できません。",
         "download": "ダウンロード",
@@ -570,6 +570,7 @@
         "pauseSucceeded": "処理が一時停止されました",
         "queueFront": "キューの先頭へ追加",
         "queueBack": "キューに追加",
+        "queueCountPrediction": "{{promptsCount}} プロンプト × {{iterations}} イテレーション -> {{count}} 枚生成",
         "pause": "一時停止",
         "queue": "キュー",
         "pauseTooltip": "処理を一時停止",

invokeai/frontend/web/public/locales/ko.json

@@ -82,7 +82,7 @@
         "drop": "드랍",
         "problemDeletingImages": "이미지 삭제 중 발생한 문제",
         "downloadSelection": "선택 항목 다운로드",
-        "deleteImage_other": "이미지 삭제",
+        "deleteImage": "이미지 삭제",
         "currentlyInUse": "이 이미지는 현재 다음 기능에서 사용되고 있습니다:",
         "dropOrUpload": "$t(gallery.drop) 또는 업로드",
         "copy": "복사",
@@ -505,6 +505,7 @@
         "completed": "완성된",
         "queueBack": "Queue에 추가",
         "cancelFailed": "항목 취소 중 발생한 문제",
+        "queueCountPrediction": "Queue에 {{predicted}} 추가",
         "batchQueued": "Batch Queued",
         "pauseFailed": "프로세서 중지 중 발생한 문제",
         "clearFailed": "Queue 제거 중 발생한 문제",

invokeai/frontend/web/public/locales/nl.json

@@ -42,8 +42,7 @@
         "autoSwitchNewImages": "Wissel autom. naar nieuwe afbeeldingen",
         "loadMore": "Laad meer",
         "noImagesInGallery": "Geen afbeeldingen om te tonen",
-        "deleteImage_one": "Verwijder afbeelding",
-        "deleteImage_other": "",
+        "deleteImage": "Verwijder afbeelding",
         "deleteImageBin": "Verwijderde afbeeldingen worden naar de prullenbak van je besturingssysteem gestuurd.",
         "deleteImagePermanent": "Verwijderde afbeeldingen kunnen niet worden hersteld.",
         "assets": "Eigen onderdelen",
@@ -383,6 +382,8 @@
         "useCpuNoise": "Gebruik CPU-ruis",
         "imageActions": "Afbeeldingshandeling",
         "iterations": "Iteraties",
+        "iterationsWithCount_one": "{{count}} iteratie",
+        "iterationsWithCount_other": "{{count}} iteraties",
         "coherenceMode": "Modus"
     },
     "settings": {
@@ -938,6 +939,7 @@
         "completed": "Voltooid",
         "queueBack": "Voeg toe aan wachtrij",
         "cancelFailed": "Fout bij annuleren onderdeel",
+        "queueCountPrediction": "Voeg {{predicted}} toe aan wachtrij",
         "batchQueued": "Reeks in wachtrij geplaatst",
         "pauseFailed": "Fout bij onderbreken verwerker",
         "clearFailed": "Fout bij wissen van wachtrij",

invokeai/frontend/web/public/locales/ru.json

@@ -76,18 +76,7 @@
         "localSystem": "Локальная система",
         "aboutDesc": "Используя Invoke для работы? Проверьте это:",
         "add": "Добавить",
-        "loglevel": "Уровень логов",
-        "beta": "Бета",
-        "selected": "Выбрано",
-        "positivePrompt": "Позитивный запрос",
-        "negativePrompt": "Негативный запрос",
-        "editor": "Редактор",
-        "goTo": "Перейти к",
-        "tab": "Вкладка",
-        "viewing": "Просмотр",
-        "editing": "Редактирование",
-        "viewingDesc": "Просмотр изображений в режиме большой галереи",
-        "editingDesc": "Редактировать на холсте слоёв управления"
+        "loglevel": "Уровень логов"
     },
     "gallery": {
         "galleryImageSize": "Размер изображений",
@@ -97,9 +86,7 @@
         "noImagesInGallery": "Изображений нет",
         "deleteImagePermanent": "Удаленные изображения невозможно восстановить.",
         "deleteImageBin": "Удаленные изображения будут отправлены в корзину вашей операционной системы.",
-        "deleteImage_one": "Удалить изображение",
-        "deleteImage_few": "Удалить {{count}} изображения",
-        "deleteImage_many": "Удалить {{count}} изображений",
+        "deleteImage": "Удалить изображение",
         "assets": "Ресурсы",
         "autoAssignBoardOnClick": "Авто-назначение доски по клику",
         "deleteSelection": "Удалить выделенное",
@@ -347,10 +334,6 @@
         "remixImage": {
             "desc": "Используйте все параметры, кроме сида из текущего изображения",
             "title": "Ремикс изображения"
-        },
-        "toggleViewer": {
-            "title": "Переключить просмотр изображений",
-            "desc": "Переключение между средством просмотра изображений и рабочей областью для текущей вкладки."
         }
     },
     "modelManager": {
@@ -527,8 +510,7 @@
             "missingNodeTemplate": "Отсутствует шаблон узла",
             "missingFieldTemplate": "Отсутствует шаблон поля",
             "addingImagesTo": "Добавление изображений в",
-            "invoke": "Создать",
-            "imageNotProcessedForControlAdapter": "Изображение адаптера контроля №{{number}} не обрабатывается"
+            "invoke": "Создать"
         },
         "isAllowedToUpscale": {
             "useX2Model": "Изображение слишком велико для увеличения с помощью модели x4. Используйте модель x2",
@@ -539,6 +521,9 @@
         "useCpuNoise": "Использовать шум CPU",
         "imageActions": "Действия с изображениями",
         "iterations": "Кол-во",
+        "iterationsWithCount_one": "{{count}} Интеграция",
+        "iterationsWithCount_few": "{{count}} Итерации",
+        "iterationsWithCount_many": "{{count}} Итераций",
         "useSize": "Использовать размер",
         "coherenceMode": "Режим",
         "aspect": "Соотношение",
@@ -554,10 +539,7 @@
         "infillMosaicTileHeight": "Высота плиток",
         "infillMosaicMinColor": "Мин цвет",
         "infillMosaicMaxColor": "Макс цвет",
-        "infillColorValue": "Цвет заливки",
-        "globalSettings": "Глобальные настройки",
-        "globalNegativePromptPlaceholder": "Глобальный негативный запрос",
-        "globalPositivePromptPlaceholder": "Глобальный запрос"
+        "infillColorValue": "Цвет заливки"
     },
     "settings": {
         "models": "Модели",
@@ -722,9 +704,7 @@
         "coherenceModeBoxBlur": "коробчатое размытие",
         "discardCurrent": "Отбросить текущее",
         "invertBrushSizeScrollDirection": "Инвертировать прокрутку для размера кисти",
-        "initialFitImageSize": "Подогнать размер изображения при перебросе",
-        "hideBoundingBox": "Скрыть ограничительную рамку",
-        "showBoundingBox": "Показать ограничительную рамку"
+        "initialFitImageSize": "Подогнать размер изображения при перебросе"
     },
     "accessibility": {
         "uploadImage": "Загрузить изображение",
@@ -867,10 +847,7 @@
         "editMode": "Открыть в редакторе узлов",
         "resetToDefaultValue": "Сбросить к стандартному значкнию",
         "edit": "Редактировать",
-        "noFieldsViewMode": "В этом рабочем процессе нет выбранных полей для отображения. Просмотрите полный рабочий процесс для настройки значений.",
-        "graph": "График",
-        "showEdgeLabels": "Показать метки на ребрах",
-        "showEdgeLabelsHelp": "Показать метки на ребрах, указывающие на соединенные узлы"
+        "noFieldsViewMode": "В этом рабочем процессе нет выбранных полей для отображения. Просмотрите полный рабочий процесс для настройки значений."
     },
     "controlnet": {
         "amult": "a_mult",
@@ -938,8 +915,8 @@
         "lineartAnime": "Контурный рисунок в стиле аниме",
         "mediapipeFaceDescription": "Обнаружение лиц с помощью Mediapipe",
         "hedDescription": "Целостное обнаружение границ",
-        "setControlImageDimensions": "Скопируйте размер в Ш/В (оптимизируйте для модели)",
-        "scribble": "Штрихи",
+        "setControlImageDimensions": "Установите размеры контрольного изображения на Ш/В",
+        "scribble": "каракули",
         "maxFaces": "Макс Лица",
         "mlsdDescription": "Минималистичный детектор отрезков линии",
         "resizeSimple": "Изменить размер (простой)",
@@ -954,18 +931,7 @@
         "small": "Маленький",
         "body": "Тело",
         "hands": "Руки",
-        "selectCLIPVisionModel": "Выбрать модель CLIP Vision",
-        "ipAdapterMethod": "Метод",
-        "full": "Всё",
-        "mlsd": "M-LSD",
-        "h": "H",
-        "style": "Только стиль",
-        "dwOpenpose": "DW Openpose",
-        "pidi": "PIDI",
-        "composition": "Только композиция",
-        "hed": "HED",
-        "beginEndStepPercentShort": "Начало/конец %",
-        "setControlImageDimensionsForce": "Скопируйте размер в Ш/В (игнорируйте модель)"
+        "selectCLIPVisionModel": "Выбрать модель CLIP Vision"
     },
     "boards": {
         "autoAddBoard": "Авто добавление Доски",
@@ -1344,12 +1310,6 @@
             "paragraphs": [
                 "Плавно укладывайте изображение вдоль вертикальной оси."
             ]
-        },
-        "ipAdapterMethod": {
-            "heading": "Метод",
-            "paragraphs": [
-                "Метод, с помощью которого применяется текущий IP-адаптер."
-            ]
         }
     },
     "metadata": {
@@ -1397,6 +1357,7 @@
         "completed": "Выполнено",
         "queueBack": "Добавить в очередь",
         "cancelFailed": "Проблема с отменой элемента",
+        "queueCountPrediction": "{{promptsCount}} запросов × {{iterations}} изображений -> {{count}} генераций",
         "batchQueued": "Пакетная очередь",
         "pauseFailed": "Проблема с приостановкой рендеринга",
         "clearFailed": "Проблема с очисткой очереди",
@@ -1512,11 +1473,7 @@
         "projectWorkflows": "Рабочие процессы проекта",
         "defaultWorkflows": "Стандартные рабочие процессы",
         "name": "Имя",
-        "noRecentWorkflows": "Нет последних рабочих процессов",
-        "loadWorkflow": "Рабочий процесс $t(common.load)",
-        "convertGraph": "Конвертировать график",
-        "loadFromGraph": "Загрузка рабочего процесса из графика",
-        "autoLayout": "Автоматическое расположение"
+        "noRecentWorkflows": "Нет последних рабочих процессов"
     },
     "hrf": {
         "enableHrf": "Включить исправление высокого разрешения",
@@ -1569,56 +1526,5 @@
         "addPromptTrigger": "Добавить триггер запроса",
         "compatibleEmbeddings": "Совместимые встраивания",
         "noMatchingTriggers": "Нет соответствующих триггеров"
-    },
-    "controlLayers": {
-        "moveToBack": "На задний план",
-        "moveForward": "Переместить вперёд",
-        "moveBackward": "Переместить назад",
-        "brushSize": "Размер кисти",
-        "controlLayers": "Слои управления",
-        "globalMaskOpacity": "Глобальная непрозрачность маски",
-        "autoNegative": "Авто негатив",
-        "deletePrompt": "Удалить запрос",
-        "resetRegion": "Сбросить регион",
-        "debugLayers": "Слои отладки",
-        "rectangle": "Прямоугольник",
-        "maskPreviewColor": "Цвет предпросмотра маски",
-        "addNegativePrompt": "Добавить $t(common.negativePrompt)",
-        "regionalGuidance": "Региональная точность",
-        "opacity": "Непрозрачность",
-        "globalControlAdapter": "Глобальный $t(controlnet.controlAdapter_one)",
-        "globalControlAdapterLayer": "Глобальный $t(controlnet.controlAdapter_one) $t(unifiedCanvas.layer)",
-        "globalIPAdapter": "Глобальный $t(common.ipAdapter)",
-        "globalIPAdapterLayer": "Глобальный $t(common.ipAdapter) $t(unifiedCanvas.layer)",
-        "opacityFilter": "Фильтр непрозрачности",
-        "deleteAll": "Удалить всё",
-        "addLayer": "Добавить слой",
-        "moveToFront": "На передний план",
-        "toggleVisibility": "Переключить видимость слоя",
-        "addPositivePrompt": "Добавить $t(common.positivePrompt)",
-        "addIPAdapter": "Добавить $t(common.ipAdapter)",
-        "regionalGuidanceLayer": "$t(controlLayers.regionalGuidance) $t(unifiedCanvas.layer)",
-        "resetProcessor": "Сброс процессора по умолчанию",
-        "clearProcessor": "Чистый процессор",
-        "globalInitialImage": "Глобальное исходное изображение",
-        "globalInitialImageLayer": "$t(controlLayers.globalInitialImage) $t(unifiedCanvas.layer)",
-        "noLayersAdded": "Без слоев",
-        "layers_one": "Слой",
-        "layers_few": "Слоя",
-        "layers_many": "Слоев"
-    },
-    "ui": {
-        "tabs": {
-            "generation": "Генерация",
-            "canvas": "Холст",
-            "workflowsTab": "$t(ui.tabs.workflows) $t(common.tab)",
-            "models": "Модели",
-            "generationTab": "$t(ui.tabs.generation) $t(common.tab)",
-            "workflows": "Рабочие процессы",
-            "canvasTab": "$t(ui.tabs.canvas) $t(common.tab)",
-            "queueTab": "$t(ui.tabs.queue) $t(common.tab)",
-            "modelsTab": "$t(ui.tabs.models) $t(common.tab)",
-            "queue": "Очередь"
-        }
     }
 }

invokeai/frontend/web/public/locales/tr.json

@@ -298,8 +298,7 @@
         "noImagesInGallery": "Gösterilecek Görsel Yok",
         "autoSwitchNewImages": "Yeni Görseli Biter Bitmez Gör",
         "currentlyInUse": "Bu görsel şurada kullanımda:",
-        "deleteImage_one": "Görseli Sil",
-        "deleteImage_other": "",
+        "deleteImage": "Görseli Sil",
         "loadMore": "Daha Getir",
         "setCurrentImage": "Çalışma Görseli Yap",
         "unableToLoad": "Galeri Yüklenemedi",

invokeai/frontend/web/public/locales/zh_CN.json

@@ -66,7 +66,7 @@
         "saveAs": "保存为",
         "ai": "ai",
         "or": "或",
-        "aboutDesc": "使用 Invoke 工作？来看看：",
+        "aboutDesc": "使用 Invoke 工作？查看：",
         "add": "添加",
         "loglevel": "日志级别",
         "copy": "复制",
@@ -78,7 +78,7 @@
         "autoSwitchNewImages": "自动切换到新图像",
         "loadMore": "加载更多",
         "noImagesInGallery": "无图像可用于显示",
-        "deleteImage_other": "删除图片",
+        "deleteImage": "删除图片",
         "deleteImageBin": "被删除的图片会发送到你操作系统的回收站。",
         "deleteImagePermanent": "删除的图片无法被恢复。",
         "assets": "素材",
@@ -445,6 +445,7 @@
             "useX2Model": "图像太大，无法使用 x4 模型，使用 x2 模型作为替代",
             "tooLarge": "图像太大无法进行放大，请选择更小的图像"
         },
+        "iterationsWithCount_other": "{{count}} 次迭代生成",
         "cfgRescaleMultiplier": "CFG 重缩放倍数",
         "useSize": "使用尺寸",
         "setToOptimalSize": "优化模型大小",
@@ -852,6 +853,7 @@
         "pruneSucceeded": "从队列修剪 {{item_count}} 个已完成的项目",
         "notReady": "无法排队",
         "batchFailedToQueue": "批次加入队列失败",
+        "queueCountPrediction": "{{promptsCount}} 提示词 × {{iterations}} 迭代次数 -> {{count}} 次生成",
         "batchQueued": "加入队列的批次",
         "front": "前",
         "pruneTooltip": "修剪 {{item_count}} 个已完成的项目",

invokeai/frontend/web/src/app/logging/logger.ts

@@ -20,14 +20,14 @@ export type LoggerNamespace =
   | 'models'
   | 'config'
   | 'canvas'
-  | 'generation'
+  | 'txt2img'
+  | 'img2img'
   | 'nodes'
   | 'system'
   | 'socketio'
   | 'session'
   | 'queue'
-  | 'dnd'
-  | 'controlLayers';
+  | 'dnd';
 
 export const logger = (namespace: LoggerNamespace) => $logger.get().child({ namespace });
 

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/index.ts

@@ -16,7 +16,6 @@ import { addCanvasMaskSavedToGalleryListener } from 'app/store/middleware/listen
 import { addCanvasMaskToControlNetListener } from 'app/store/middleware/listenerMiddleware/listeners/canvasMaskToControlNet';
 import { addCanvasMergedListener } from 'app/store/middleware/listenerMiddleware/listeners/canvasMerged';
 import { addCanvasSavedToGalleryListener } from 'app/store/middleware/listenerMiddleware/listeners/canvasSavedToGallery';
-import { addControlAdapterPreprocessor } from 'app/store/middleware/listenerMiddleware/listeners/controlAdapterPreprocessor';
 import { addControlNetAutoProcessListener } from 'app/store/middleware/listenerMiddleware/listeners/controlNetAutoProcess';
 import { addControlNetImageProcessedListener } from 'app/store/middleware/listenerMiddleware/listeners/controlNetImageProcessed';
 import { addEnqueueRequestedCanvasListener } from 'app/store/middleware/listenerMiddleware/listeners/enqueueRequestedCanvas';
@@ -32,6 +31,7 @@ import { addImagesStarredListener } from 'app/store/middleware/listenerMiddlewar
 import { addImagesUnstarredListener } from 'app/store/middleware/listenerMiddleware/listeners/imagesUnstarred';
 import { addImageToDeleteSelectedListener } from 'app/store/middleware/listenerMiddleware/listeners/imageToDeleteSelected';
 import { addImageUploadedFulfilledListener } from 'app/store/middleware/listenerMiddleware/listeners/imageUploaded';
+import { addInitialImageSelectedListener } from 'app/store/middleware/listenerMiddleware/listeners/initialImageSelected';
 import { addModelSelectedListener } from 'app/store/middleware/listenerMiddleware/listeners/modelSelected';
 import { addModelsLoadedListener } from 'app/store/middleware/listenerMiddleware/listeners/modelsLoaded';
 import { addDynamicPromptsListener } from 'app/store/middleware/listenerMiddleware/listeners/promptChanged';
@@ -72,6 +72,9 @@ const startAppListening = listenerMiddleware.startListening as AppStartListening
 // Image uploaded
 addImageUploadedFulfilledListener(startAppListening);
 
+// Image selected
+addInitialImageSelectedListener(startAppListening);
+
 // Image deleted
 addRequestedSingleImageDeletionListener(startAppListening);
 addDeleteBoardAndImagesFulfilledListener(startAppListening);
@@ -154,4 +157,3 @@ addUpscaleRequestedListener(startAppListening);
 addDynamicPromptsListener(startAppListening);
 
 addSetDefaultSettingsListener(startAppListening);
-addControlAdapterPreprocessor(startAppListening);

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/boardAndImagesDeleted.ts

@@ -1,9 +1,9 @@
 import type { AppStartListening } from 'app/store/middleware/listenerMiddleware';
 import { resetCanvas } from 'features/canvas/store/canvasSlice';
 import { controlAdaptersReset } from 'features/controlAdapters/store/controlAdaptersSlice';
-import { allLayersDeleted } from 'features/controlLayers/store/controlLayersSlice';
 import { getImageUsage } from 'features/deleteImageModal/store/selectors';
 import { nodeEditorReset } from 'features/nodes/store/nodesSlice';
+import { clearInitialImage } from 'features/parameters/store/generationSlice';
 import { imagesApi } from 'services/api/endpoints/images';
 
 export const addDeleteBoardAndImagesFulfilledListener = (startAppListening: AppStartListening) => {
@@ -14,14 +14,19 @@ export const addDeleteBoardAndImagesFulfilledListener = (startAppListening: AppS
 
       // Remove all deleted images from the UI
 
+      let wasInitialImageReset = false;
       let wasCanvasReset = false;
       let wasNodeEditorReset = false;
       let wereControlAdaptersReset = false;
-      let wereControlLayersReset = false;
 
-      const { canvas, nodes, controlAdapters, controlLayers } = getState();
+      const { generation, canvas, nodes, controlAdapters } = getState();
       deleted_images.forEach((image_name) => {
-        const imageUsage = getImageUsage(canvas, nodes, controlAdapters, controlLayers.present, image_name);
+        const imageUsage = getImageUsage(generation, canvas, nodes, controlAdapters, image_name);
+
+        if (imageUsage.isInitialImage && !wasInitialImageReset) {
+          dispatch(clearInitialImage());
+          wasInitialImageReset = true;
+        }
 
         if (imageUsage.isCanvasImage && !wasCanvasReset) {
           dispatch(resetCanvas());
@@ -37,11 +42,6 @@ export const addDeleteBoardAndImagesFulfilledListener = (startAppListening: AppS
           dispatch(controlAdaptersReset());
           wereControlAdaptersReset = true;
         }
-
-        if (imageUsage.isControlLayerImage && !wereControlLayersReset) {
-          dispatch(allLayersDeleted());
-          wereControlLayersReset = true;
-        }
       });
     },
   });

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/controlAdapterPreprocessor.ts

@@ -1,175 +0,0 @@
-import { isAnyOf } from '@reduxjs/toolkit';
-import { logger } from 'app/logging/logger';
-import type { AppStartListening } from 'app/store/middleware/listenerMiddleware';
-import type { AppDispatch } from 'app/store/store';
-import { parseify } from 'common/util/serialize';
-import {
-  caLayerImageChanged,
-  caLayerModelChanged,
-  caLayerProcessedImageChanged,
-  caLayerProcessorConfigChanged,
-  caLayerProcessorPendingBatchIdChanged,
-  caLayerRecalled,
-  isControlAdapterLayer,
-} from 'features/controlLayers/store/controlLayersSlice';
-import { CA_PROCESSOR_DATA } from 'features/controlLayers/util/controlAdapters';
-import { isImageOutput } from 'features/nodes/types/common';
-import { addToast } from 'features/system/store/systemSlice';
-import { t } from 'i18next';
-import { getImageDTO } from 'services/api/endpoints/images';
-import { queueApi } from 'services/api/endpoints/queue';
-import type { BatchConfig } from 'services/api/types';
-import { socketInvocationComplete } from 'services/events/actions';
-import { assert } from 'tsafe';
-
-const matcher = isAnyOf(caLayerImageChanged, caLayerProcessorConfigChanged, caLayerModelChanged, caLayerRecalled);
-
-const DEBOUNCE_MS = 300;
-const log = logger('session');
-
-/**
- * Simple helper to cancel a batch and reset the pending batch ID
- */
-const cancelProcessorBatch = async (dispatch: AppDispatch, layerId: string, batchId: string) => {
-  const req = dispatch(queueApi.endpoints.cancelByBatchIds.initiate({ batch_ids: [batchId] }));
-  log.trace({ batchId }, 'Cancelling existing preprocessor batch');
-  try {
-    await req.unwrap();
-  } catch {
-    // no-op
-  } finally {
-    req.reset();
-    // Always reset the pending batch ID - the cancel req could fail if the batch doesn't exist
-    dispatch(caLayerProcessorPendingBatchIdChanged({ layerId, batchId: null }));
-  }
-};
-
-export const addControlAdapterPreprocessor = (startAppListening: AppStartListening) => {
-  startAppListening({
-    matcher,
-    effect: async (action, { dispatch, getState, cancelActiveListeners, delay, take, signal }) => {
-      const layerId = caLayerRecalled.match(action) ? action.payload.id : action.payload.layerId;
-
-      // Cancel any in-progress instances of this listener
-      cancelActiveListeners();
-      log.trace('Control Layer CA auto-process triggered');
-
-      // Delay before starting actual work
-      await delay(DEBOUNCE_MS);
-
-      // Double-check that we are still eligible for processing
-      const state = getState();
-      const layer = state.controlLayers.present.layers.filter(isControlAdapterLayer).find((l) => l.id === layerId);
-
-      // If we have no image or there is no processor config, bail
-      if (!layer) {
-        return;
-      }
-
-      const image = layer.controlAdapter.image;
-      const config = layer.controlAdapter.processorConfig;
-
-      if (!image || !config) {
-        // The user has reset the image or config, so we should clear the processed image
-        dispatch(caLayerProcessedImageChanged({ layerId, imageDTO: null }));
-      }
-
-      // At this point, the user has stopped fiddling with the processor settings and there is a processor selected.
-
-      // If there is a pending processor batch, cancel it.
-      if (layer.controlAdapter.processorPendingBatchId) {
-        cancelProcessorBatch(dispatch, layerId, layer.controlAdapter.processorPendingBatchId);
-      }
-
-      // @ts-expect-error: TS isn't able to narrow the typing of buildNode and `config` will error...
-      const processorNode = CA_PROCESSOR_DATA[config.type].buildNode(image, config);
-      const enqueueBatchArg: BatchConfig = {
-        prepend: true,
-        batch: {
-          graph: {
-            nodes: {
-              [processorNode.id]: {
-                ...processorNode,
-                // Control images are always intermediate - do not save to gallery
-                is_intermediate: true,
-              },
-            },
-            edges: [],
-          },
-          runs: 1,
-        },
-      };
-
-      // Kick off the processor batch
-      const req = dispatch(
-        queueApi.endpoints.enqueueBatch.initiate(enqueueBatchArg, {
-          fixedCacheKey: 'enqueueBatch',
-        })
-      );
-
-      try {
-        const enqueueResult = await req.unwrap();
-        // TODO(psyche): Update the pydantic models, pretty sure we will _always_ have a batch_id here, but the model says it's optional
-        assert(enqueueResult.batch.batch_id, 'Batch ID not returned from queue');
-        dispatch(caLayerProcessorPendingBatchIdChanged({ layerId, batchId: enqueueResult.batch.batch_id }));
-        log.debug({ enqueueResult: parseify(enqueueResult) }, t('queue.graphQueued'));
-
-        // Wait for the processor node to complete
-        const [invocationCompleteAction] = await take(
-          (action): action is ReturnType<typeof socketInvocationComplete> =>
-            socketInvocationComplete.match(action) &&
-            action.payload.data.queue_batch_id === enqueueResult.batch.batch_id &&
-            action.payload.data.source_node_id === processorNode.id
-        );
-
-        // We still have to check the output type
-        assert(
-          isImageOutput(invocationCompleteAction.payload.data.result),
-          `Processor did not return an image output, got: ${invocationCompleteAction.payload.data.result}`
-        );
-        const { image_name } = invocationCompleteAction.payload.data.result.image;
-
-        const imageDTO = await getImageDTO(image_name);
-        assert(imageDTO, "Failed to fetch processor output's image DTO");
-
-        // Whew! We made it. Update the layer with the processed image
-        log.debug({ layerId, imageDTO }, 'ControlNet image processed');
-        dispatch(caLayerProcessedImageChanged({ layerId, imageDTO }));
-        dispatch(caLayerProcessorPendingBatchIdChanged({ layerId, batchId: null }));
-      } catch (error) {
-        if (signal.aborted) {
-          // The listener was canceled - we need to cancel the pending processor batch, if there is one (could have changed by now).
-          const pendingBatchId = getState()
-            .controlLayers.present.layers.filter(isControlAdapterLayer)
-            .find((l) => l.id === layerId)?.controlAdapter.processorPendingBatchId;
-          if (pendingBatchId) {
-            cancelProcessorBatch(dispatch, layerId, pendingBatchId);
-          }
-          log.trace('Control Adapter preprocessor cancelled');
-        } else {
-          // Some other error condition...
-          console.log(error);
-          log.error({ enqueueBatchArg: parseify(enqueueBatchArg) }, t('queue.graphFailedToQueue'));
-
-          if (error instanceof Object) {
-            if ('data' in error && 'status' in error) {
-              if (error.status === 403) {
-                dispatch(caLayerImageChanged({ layerId, imageDTO: null }));
-                return;
-              }
-            }
-          }
-
-          dispatch(
-            addToast({
-              title: t('queue.graphFailedToQueue'),
-              status: 'error',
-            })
-          );
-        }
-      } finally {
-        req.reset();
-      }
-    },
-  });
-};

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/enqueueRequestedCanvas.ts

@@ -30,7 +30,7 @@ import type { ImageDTO } from 'services/api/types';
 export const addEnqueueRequestedCanvasListener = (startAppListening: AppStartListening) => {
   startAppListening({
     predicate: (action): action is ReturnType<typeof enqueueRequested> =>
-      enqueueRequested.match(action) && action.payload.tabName === 'canvas',
+      enqueueRequested.match(action) && action.payload.tabName === 'unifiedCanvas',
     effect: async (action, { getState, dispatch }) => {
       const log = logger('queue');
       const { prepend } = action.payload;

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/enqueueRequestedLinear.ts

@@ -1,27 +1,35 @@
 import { enqueueRequested } from 'app/store/actions';
 import type { AppStartListening } from 'app/store/middleware/listenerMiddleware';
-import { isImageViewerOpenChanged } from 'features/gallery/store/gallerySlice';
-import { buildGenerationTabGraph } from 'features/nodes/util/graph/buildGenerationTabGraph';
-import { buildGenerationTabSDXLGraph } from 'features/nodes/util/graph/buildGenerationTabSDXLGraph';
 import { prepareLinearUIBatch } from 'features/nodes/util/graph/buildLinearBatchConfig';
+import { buildLinearImageToImageGraph } from 'features/nodes/util/graph/buildLinearImageToImageGraph';
+import { buildLinearSDXLImageToImageGraph } from 'features/nodes/util/graph/buildLinearSDXLImageToImageGraph';
+import { buildLinearSDXLTextToImageGraph } from 'features/nodes/util/graph/buildLinearSDXLTextToImageGraph';
+import { buildLinearTextToImageGraph } from 'features/nodes/util/graph/buildLinearTextToImageGraph';
 import { queueApi } from 'services/api/endpoints/queue';
 
 export const addEnqueueRequestedLinear = (startAppListening: AppStartListening) => {
   startAppListening({
     predicate: (action): action is ReturnType<typeof enqueueRequested> =>
-      enqueueRequested.match(action) && action.payload.tabName === 'generation',
+      enqueueRequested.match(action) && (action.payload.tabName === 'txt2img' || action.payload.tabName === 'img2img'),
     effect: async (action, { getState, dispatch }) => {
       const state = getState();
-      const { shouldShowProgressInViewer } = state.ui;
       const model = state.generation.model;
       const { prepend } = action.payload;
 
       let graph;
 
       if (model && model.base === 'sdxl') {
-        graph = await buildGenerationTabSDXLGraph(state);
+        if (action.payload.tabName === 'txt2img') {
+          graph = await buildLinearSDXLTextToImageGraph(state);
+        } else {
+          graph = await buildLinearSDXLImageToImageGraph(state);
+        }
       } else {
-        graph = await buildGenerationTabGraph(state);
+        if (action.payload.tabName === 'txt2img') {
+          graph = await buildLinearTextToImageGraph(state);
+        } else {
+          graph = await buildLinearImageToImageGraph(state);
+        }
       }
 
       const batchConfig = prepareLinearUIBatch(state, graph, prepend);
@@ -31,14 +39,7 @@ export const addEnqueueRequestedLinear = (startAppListening: AppStartListening)
           fixedCacheKey: 'enqueueBatch',
         })
       );
-      try {
-        await req.unwrap();
-        if (shouldShowProgressInViewer) {
-          dispatch(isImageViewerOpenChanged(true));
-        }
-      } finally {
-        req.reset();
-      }
+      req.reset();
     },
   });
 };

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/enqueueRequestedNodes.ts

@@ -8,7 +8,7 @@ import type { BatchConfig } from 'services/api/types';
 export const addEnqueueRequestedNodes = (startAppListening: AppStartListening) => {
   startAppListening({
     predicate: (action): action is ReturnType<typeof enqueueRequested> =>
-      enqueueRequested.match(action) && action.payload.tabName === 'workflows',
+      enqueueRequested.match(action) && action.payload.tabName === 'nodes',
     effect: async (action, { getState, dispatch }) => {
       const state = getState();
       const { nodes, edges } = state.nodes;
@@ -39,11 +39,7 @@ export const addEnqueueRequestedNodes = (startAppListening: AppStartListening) =
           fixedCacheKey: 'enqueueBatch',
         })
       );
-      try {
-        await req.unwrap();
-      } finally {
-        req.reset();
-      }
+      req.reset();
     },
   });
 };

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/imageDeleted.ts

@@ -1,6 +1,5 @@
 import { logger } from 'app/logging/logger';
 import type { AppStartListening } from 'app/store/middleware/listenerMiddleware';
-import type { AppDispatch, RootState } from 'app/store/store';
 import { resetCanvas } from 'features/canvas/store/canvasSlice';
 import {
   controlAdapterImageChanged,
@@ -8,13 +7,6 @@ import {
   selectControlAdapterAll,
 } from 'features/controlAdapters/store/controlAdaptersSlice';
 import { isControlNetOrT2IAdapter } from 'features/controlAdapters/store/types';
-import {
-  isControlAdapterLayer,
-  isInitialImageLayer,
-  isIPAdapterLayer,
-  isRegionalGuidanceLayer,
-  layerDeleted,
-} from 'features/controlLayers/store/controlLayersSlice';
 import { imageDeletionConfirmed } from 'features/deleteImageModal/store/actions';
 import { isModalOpenChanged } from 'features/deleteImageModal/store/slice';
 import { selectListImagesQueryArgs } from 'features/gallery/store/gallerySelectors';
@@ -22,82 +14,12 @@ import { imageSelected } from 'features/gallery/store/gallerySlice';
 import { fieldImageValueChanged } from 'features/nodes/store/nodesSlice';
 import { isImageFieldInputInstance } from 'features/nodes/types/field';
 import { isInvocationNode } from 'features/nodes/types/invocation';
+import { clearInitialImage } from 'features/parameters/store/generationSlice';
 import { clamp, forEach } from 'lodash-es';
 import { api } from 'services/api';
 import { imagesApi } from 'services/api/endpoints/images';
-import type { ImageDTO } from 'services/api/types';
 import { imagesSelectors } from 'services/api/util';
 
-const deleteNodesImages = (state: RootState, dispatch: AppDispatch, imageDTO: ImageDTO) => {
-  state.nodes.nodes.forEach((node) => {
-    if (!isInvocationNode(node)) {
-      return;
-    }
-
-    forEach(node.data.inputs, (input) => {
-      if (isImageFieldInputInstance(input) && input.value?.image_name === imageDTO.image_name) {
-        dispatch(
-          fieldImageValueChanged({
-            nodeId: node.data.id,
-            fieldName: input.name,
-            value: undefined,
-          })
-        );
-      }
-    });
-  });
-};
-
-const deleteControlAdapterImages = (state: RootState, dispatch: AppDispatch, imageDTO: ImageDTO) => {
-  forEach(selectControlAdapterAll(state.controlAdapters), (ca) => {
-    if (
-      ca.controlImage === imageDTO.image_name ||
-      (isControlNetOrT2IAdapter(ca) && ca.processedControlImage === imageDTO.image_name)
-    ) {
-      dispatch(
-        controlAdapterImageChanged({
-          id: ca.id,
-          controlImage: null,
-        })
-      );
-      dispatch(
-        controlAdapterProcessedImageChanged({
-          id: ca.id,
-          processedControlImage: null,
-        })
-      );
-    }
-  });
-};
-
-const deleteControlLayerImages = (state: RootState, dispatch: AppDispatch, imageDTO: ImageDTO) => {
-  state.controlLayers.present.layers.forEach((l) => {
-    if (isRegionalGuidanceLayer(l)) {
-      if (l.ipAdapters.some((ipa) => ipa.image?.name === imageDTO.image_name)) {
-        dispatch(layerDeleted(l.id));
-      }
-    }
-    if (isControlAdapterLayer(l)) {
-      if (
-        l.controlAdapter.image?.name === imageDTO.image_name ||
-        l.controlAdapter.processedImage?.name === imageDTO.image_name
-      ) {
-        dispatch(layerDeleted(l.id));
-      }
-    }
-    if (isIPAdapterLayer(l)) {
-      if (l.ipAdapter.image?.name === imageDTO.image_name) {
-        dispatch(layerDeleted(l.id));
-      }
-    }
-    if (isInitialImageLayer(l)) {
-      if (l.image?.name === imageDTO.image_name) {
-        dispatch(layerDeleted(l.id));
-      }
-    }
-  });
-};
-
 export const addRequestedSingleImageDeletionListener = (startAppListening: AppStartListening) => {
   startAppListening({
     actionCreator: imageDeletionConfirmed,
@@ -151,9 +73,50 @@ export const addRequestedSingleImageDeletionListener = (startAppListening: AppSt
       }
 
       imageDTOs.forEach((imageDTO) => {
-        deleteControlAdapterImages(state, dispatch, imageDTO);
-        deleteNodesImages(state, dispatch, imageDTO);
-        deleteControlLayerImages(state, dispatch, imageDTO);
+        // reset init image if we deleted it
+        if (getState().generation.initialImage?.imageName === imageDTO.image_name) {
+          dispatch(clearInitialImage());
+        }
+
+        // reset control adapters that use the deleted images
+        forEach(selectControlAdapterAll(getState().controlAdapters), (ca) => {
+          if (
+            ca.controlImage === imageDTO.image_name ||
+            (isControlNetOrT2IAdapter(ca) && ca.processedControlImage === imageDTO.image_name)
+          ) {
+            dispatch(
+              controlAdapterImageChanged({
+                id: ca.id,
+                controlImage: null,
+              })
+            );
+            dispatch(
+              controlAdapterProcessedImageChanged({
+                id: ca.id,
+                processedControlImage: null,
+              })
+            );
+          }
+        });
+
+        // reset nodes that use the deleted images
+        getState().nodes.nodes.forEach((node) => {
+          if (!isInvocationNode(node)) {
+            return;
+          }
+
+          forEach(node.data.inputs, (input) => {
+            if (isImageFieldInputInstance(input) && input.value?.image_name === imageDTO.image_name) {
+              dispatch(
+                fieldImageValueChanged({
+                  nodeId: node.data.id,
+                  fieldName: input.name,
+                  value: undefined,
+                })
+              );
+            }
+          });
+        });
       });
 
       // Delete from server
@@ -205,9 +168,50 @@ export const addRequestedSingleImageDeletionListener = (startAppListening: AppSt
         }
 
         imageDTOs.forEach((imageDTO) => {
-          deleteControlAdapterImages(state, dispatch, imageDTO);
-          deleteNodesImages(state, dispatch, imageDTO);
-          deleteControlLayerImages(state, dispatch, imageDTO);
+          // reset init image if we deleted it
+          if (getState().generation.initialImage?.imageName === imageDTO.image_name) {
+            dispatch(clearInitialImage());
+          }
+
+          // reset control adapters that use the deleted images
+          forEach(selectControlAdapterAll(getState().controlAdapters), (ca) => {
+            if (
+              ca.controlImage === imageDTO.image_name ||
+              (isControlNetOrT2IAdapter(ca) && ca.processedControlImage === imageDTO.image_name)
+            ) {
+              dispatch(
+                controlAdapterImageChanged({
+                  id: ca.id,
+                  controlImage: null,
+                })
+              );
+              dispatch(
+                controlAdapterProcessedImageChanged({
+                  id: ca.id,
+                  processedControlImage: null,
+                })
+              );
+            }
+          });
+
+          // reset nodes that use the deleted images
+          getState().nodes.nodes.forEach((node) => {
+            if (!isInvocationNode(node)) {
+              return;
+            }
+
+            forEach(node.data.inputs, (input) => {
+              if (isImageFieldInputInstance(input) && input.value?.image_name === imageDTO.image_name) {
+                dispatch(
+                  fieldImageValueChanged({
+                    nodeId: node.data.id,
+                    fieldName: input.name,
+                    value: undefined,
+                  })
+                );
+              }
+            });
+          });
         });
       } catch {
         // no-op

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/imageDropped.ts

@@ -7,16 +7,10 @@ import {
   controlAdapterImageChanged,
   controlAdapterIsEnabledChanged,
 } from 'features/controlAdapters/store/controlAdaptersSlice';
-import {
-  caLayerImageChanged,
-  iiLayerImageChanged,
-  ipaLayerImageChanged,
-  rgLayerIPAdapterImageChanged,
-} from 'features/controlLayers/store/controlLayersSlice';
 import type { TypesafeDraggableData, TypesafeDroppableData } from 'features/dnd/types';
 import { imageSelected } from 'features/gallery/store/gallerySlice';
 import { fieldImageValueChanged } from 'features/nodes/store/nodesSlice';
-import { selectOptimalDimension } from 'features/parameters/store/generationSlice';
+import { initialImageChanged, selectOptimalDimension } from 'features/parameters/store/generationSlice';
 import { imagesApi } from 'services/api/endpoints/images';
 
 export const dndDropped = createAction<{
@@ -53,6 +47,18 @@ export const addImageDroppedListener = (startAppListening: AppStartListening) =>
         return;
       }
 
+      /**
+       * Image dropped on initial image
+       */
+      if (
+        overData.actionType === 'SET_INITIAL_IMAGE' &&
+        activeData.payloadType === 'IMAGE_DTO' &&
+        activeData.payload.imageDTO
+      ) {
+        dispatch(initialImageChanged(activeData.payload.imageDTO));
+        return;
+      }
+
       /**
        * Image dropped on ControlNet
        */
@@ -77,79 +83,6 @@ export const addImageDroppedListener = (startAppListening: AppStartListening) =>
         return;
       }
 
-      /**
-       * Image dropped on Control Adapter Layer
-       */
-      if (
-        overData.actionType === 'SET_CA_LAYER_IMAGE' &&
-        activeData.payloadType === 'IMAGE_DTO' &&
-        activeData.payload.imageDTO
-      ) {
-        const { layerId } = overData.context;
-        dispatch(
-          caLayerImageChanged({
-            layerId,
-            imageDTO: activeData.payload.imageDTO,
-          })
-        );
-        return;
-      }
-
-      /**
-       * Image dropped on IP Adapter Layer
-       */
-      if (
-        overData.actionType === 'SET_IPA_LAYER_IMAGE' &&
-        activeData.payloadType === 'IMAGE_DTO' &&
-        activeData.payload.imageDTO
-      ) {
-        const { layerId } = overData.context;
-        dispatch(
-          ipaLayerImageChanged({
-            layerId,
-            imageDTO: activeData.payload.imageDTO,
-          })
-        );
-        return;
-      }
-
-      /**
-       * Image dropped on RG Layer IP Adapter
-       */
-      if (
-        overData.actionType === 'SET_RG_LAYER_IP_ADAPTER_IMAGE' &&
-        activeData.payloadType === 'IMAGE_DTO' &&
-        activeData.payload.imageDTO
-      ) {
-        const { layerId, ipAdapterId } = overData.context;
-        dispatch(
-          rgLayerIPAdapterImageChanged({
-            layerId,
-            ipAdapterId,
-            imageDTO: activeData.payload.imageDTO,
-          })
-        );
-        return;
-      }
-
-      /**
-       * Image dropped on II Layer Image
-       */
-      if (
-        overData.actionType === 'SET_II_LAYER_IMAGE' &&
-        activeData.payloadType === 'IMAGE_DTO' &&
-        activeData.payload.imageDTO
-      ) {
-        const { layerId } = overData.context;
-        dispatch(
-          iiLayerImageChanged({
-            layerId,
-            imageDTO: activeData.payload.imageDTO,
-          })
-        );
-        return;
-      }
-
       /**
        * Image dropped on Canvas
        */

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/imageToDeleteSelected.ts

@@ -14,6 +14,7 @@ export const addImageToDeleteSelectedListener = (startAppListening: AppStartList
 
       const isImageInUse =
         imagesUsage.some((i) => i.isCanvasImage) ||
+        imagesUsage.some((i) => i.isInitialImage) ||
         imagesUsage.some((i) => i.isControlImage) ||
         imagesUsage.some((i) => i.isNodesImage);
 

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/imageUploaded.ts

@@ -6,14 +6,8 @@ import {
   controlAdapterImageChanged,
   controlAdapterIsEnabledChanged,
 } from 'features/controlAdapters/store/controlAdaptersSlice';
-import {
-  caLayerImageChanged,
-  iiLayerImageChanged,
-  ipaLayerImageChanged,
-  rgLayerIPAdapterImageChanged,
-} from 'features/controlLayers/store/controlLayersSlice';
 import { fieldImageValueChanged } from 'features/nodes/store/nodesSlice';
-import { selectOptimalDimension } from 'features/parameters/store/generationSlice';
+import { initialImageChanged, selectOptimalDimension } from 'features/parameters/store/generationSlice';
 import { addToast } from 'features/system/store/systemSlice';
 import { t } from 'i18next';
 import { omit } from 'lodash-es';
@@ -114,48 +108,15 @@ export const addImageUploadedFulfilledListener = (startAppListening: AppStartLis
         return;
       }
 
-      if (postUploadAction?.type === 'SET_CA_LAYER_IMAGE') {
-        const { layerId } = postUploadAction;
-        dispatch(caLayerImageChanged({ layerId, imageDTO }));
+      if (postUploadAction?.type === 'SET_INITIAL_IMAGE') {
+        dispatch(initialImageChanged(imageDTO));
         dispatch(
           addToast({
             ...DEFAULT_UPLOADED_TOAST,
-            description: t('toast.setControlImage'),
-          })
-        );
-      }
-
-      if (postUploadAction?.type === 'SET_IPA_LAYER_IMAGE') {
-        const { layerId } = postUploadAction;
-        dispatch(ipaLayerImageChanged({ layerId, imageDTO }));
-        dispatch(
-          addToast({
-            ...DEFAULT_UPLOADED_TOAST,
-            description: t('toast.setControlImage'),
-          })
-        );
-      }
-
-      if (postUploadAction?.type === 'SET_RG_LAYER_IP_ADAPTER_IMAGE') {
-        const { layerId, ipAdapterId } = postUploadAction;
-        dispatch(rgLayerIPAdapterImageChanged({ layerId, ipAdapterId, imageDTO }));
-        dispatch(
-          addToast({
-            ...DEFAULT_UPLOADED_TOAST,
-            description: t('toast.setControlImage'),
-          })
-        );
-      }
-
-      if (postUploadAction?.type === 'SET_II_LAYER_IMAGE') {
-        const { layerId } = postUploadAction;
-        dispatch(iiLayerImageChanged({ layerId, imageDTO }));
-        dispatch(
-          addToast({
-            ...DEFAULT_UPLOADED_TOAST,
-            description: t('toast.setControlImage'),
+            description: t('toast.setInitialImage'),
           })
         );
+        return;
       }
 
       if (postUploadAction?.type === 'SET_NODES_IMAGE') {

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/initialImageSelected.ts

@@ -0,0 +1,21 @@
+import type { AppStartListening } from 'app/store/middleware/listenerMiddleware';
+import { initialImageSelected } from 'features/parameters/store/actions';
+import { initialImageChanged } from 'features/parameters/store/generationSlice';
+import { addToast } from 'features/system/store/systemSlice';
+import { makeToast } from 'features/system/util/makeToast';
+import { t } from 'i18next';
+
+export const addInitialImageSelectedListener = (startAppListening: AppStartListening) => {
+  startAppListening({
+    actionCreator: initialImageSelected,
+    effect: (action, { dispatch }) => {
+      if (!action.payload) {
+        dispatch(addToast(makeToast({ title: t('toast.imageNotLoadedDesc'), status: 'error' })));
+        return;
+      }
+
+      dispatch(initialImageChanged(action.payload));
+      dispatch(addToast(makeToast(t('toast.sentToImageToImage'))));
+    },
+  });
+};

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/modelsLoaded.ts

@@ -6,10 +6,9 @@ import {
   controlAdapterModelCleared,
   selectControlAdapterAll,
 } from 'features/controlAdapters/store/controlAdaptersSlice';
-import { heightChanged, widthChanged } from 'features/controlLayers/store/controlLayersSlice';
 import { loraRemoved } from 'features/lora/store/loraSlice';
 import { calculateNewSize } from 'features/parameters/components/ImageSize/calculateNewSize';
-import { modelChanged, vaeSelected } from 'features/parameters/store/generationSlice';
+import { heightChanged, modelChanged, vaeSelected, widthChanged } from 'features/parameters/store/generationSlice';
 import { zParameterModel, zParameterVAEModel } from 'features/parameters/types/parameterSchemas';
 import { getIsSizeOptimal, getOptimalDimension } from 'features/parameters/util/optimalDimension';
 import { refinerModelChanged } from 'features/sdxl/store/sdxlSlice';
@@ -70,22 +69,16 @@ const handleMainModels: ModelHandler = (models, state, dispatch, log) => {
       dispatch(modelChanged(defaultModelInList, currentModel));
 
       const optimalDimension = getOptimalDimension(defaultModelInList);
-      if (
-        getIsSizeOptimal(
-          state.controlLayers.present.size.width,
-          state.controlLayers.present.size.height,
-          optimalDimension
-        )
-      ) {
+      if (getIsSizeOptimal(state.generation.width, state.generation.height, optimalDimension)) {
         return;
       }
       const { width, height } = calculateNewSize(
-        state.controlLayers.present.size.aspectRatio.value,
+        state.generation.aspectRatio.value,
         optimalDimension * optimalDimension
       );
 
-      dispatch(widthChanged({ width }));
-      dispatch(heightChanged({ height }));
+      dispatch(widthChanged(width));
+      dispatch(heightChanged(height));
       return;
     }
   }

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/promptChanged.ts

@@ -1,6 +1,5 @@
 import { isAnyOf } from '@reduxjs/toolkit';
 import type { AppStartListening } from 'app/store/middleware/listenerMiddleware';
-import { positivePromptChanged } from 'features/controlLayers/store/controlLayersSlice';
 import {
   combinatorialToggled,
   isErrorChanged,
@@ -11,16 +10,11 @@ import {
   promptsChanged,
 } from 'features/dynamicPrompts/store/dynamicPromptsSlice';
 import { getShouldProcessPrompt } from 'features/dynamicPrompts/util/getShouldProcessPrompt';
+import { setPositivePrompt } from 'features/parameters/store/generationSlice';
 import { utilitiesApi } from 'services/api/endpoints/utilities';
 import { socketConnected } from 'services/events/actions';
 
-const matcher = isAnyOf(
-  positivePromptChanged,
-  combinatorialToggled,
-  maxPromptsChanged,
-  maxPromptsReset,
-  socketConnected
-);
+const matcher = isAnyOf(setPositivePrompt, combinatorialToggled, maxPromptsChanged, maxPromptsReset, socketConnected);
 
 export const addDynamicPromptsListener = (startAppListening: AppStartListening) => {
   startAppListening({
@@ -28,7 +22,7 @@ export const addDynamicPromptsListener = (startAppListening: AppStartListening)
     effect: async (action, { dispatch, getState, cancelActiveListeners, delay }) => {
       cancelActiveListeners();
       const state = getState();
-      const { positivePrompt } = state.controlLayers.present;
+      const { positivePrompt } = state.generation;
       const { maxPrompts } = state.dynamicPrompts;
 
       if (state.config.disabledFeatures.includes('dynamicPrompting')) {
@@ -38,7 +32,7 @@ export const addDynamicPromptsListener = (startAppListening: AppStartListening)
       const cachedPrompts = utilitiesApi.endpoints.dynamicPrompts.select({
         prompt: positivePrompt,
         max_prompts: maxPrompts,
-      })(state).data;
+      })(getState()).data;
 
       if (cachedPrompts) {
         dispatch(promptsChanged(cachedPrompts.prompts));
@@ -46,8 +40,8 @@ export const addDynamicPromptsListener = (startAppListening: AppStartListening)
         return;
       }
 
-      if (!getShouldProcessPrompt(positivePrompt)) {
-        dispatch(promptsChanged([positivePrompt]));
+      if (!getShouldProcessPrompt(state.generation.positivePrompt)) {
+        dispatch(promptsChanged([state.generation.positivePrompt]));
         dispatch(parsingErrorChanged(undefined));
         dispatch(isErrorChanged(false));
         return;

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/setDefaultSettings.ts

@@ -1,13 +1,14 @@
 import type { AppStartListening } from 'app/store/middleware/listenerMiddleware';
-import { heightChanged, widthChanged } from 'features/controlLayers/store/controlLayersSlice';
 import { setDefaultSettings } from 'features/parameters/store/actions';
 import {
+  heightRecalled,
   setCfgRescaleMultiplier,
   setCfgScale,
   setScheduler,
   setSteps,
   vaePrecisionChanged,
   vaeSelected,
+  widthRecalled,
 } from 'features/parameters/store/generationSlice';
 import {
   isParameterCFGRescaleMultiplier,
@@ -96,16 +97,16 @@ export const addSetDefaultSettingsListener = (startAppListening: AppStartListeni
             dispatch(setScheduler(scheduler));
           }
         }
-        const setSizeOptions = { updateAspectRatio: true, clamp: true };
+
         if (width) {
           if (isParameterWidth(width)) {
-            dispatch(widthChanged({ width, ...setSizeOptions }));
+            dispatch(widthRecalled(width));
           }
         }
 
         if (height) {
           if (isParameterHeight(height)) {
-            dispatch(heightChanged({ height, ...setSizeOptions }));
+            dispatch(heightRecalled(height));
           }
         }
 

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/socketio/socketInvocationComplete.ts

@@ -2,12 +2,7 @@ import { logger } from 'app/logging/logger';
 import type { AppStartListening } from 'app/store/middleware/listenerMiddleware';
 import { parseify } from 'common/util/serialize';
 import { addImageToStagingArea } from 'features/canvas/store/canvasSlice';
-import {
-  boardIdSelected,
-  galleryViewChanged,
-  imageSelected,
-  isImageViewerOpenChanged,
-} from 'features/gallery/store/gallerySlice';
+import { boardIdSelected, galleryViewChanged, imageSelected } from 'features/gallery/store/gallerySlice';
 import { IMAGE_CATEGORIES } from 'features/gallery/store/types';
 import { isImageOutput } from 'features/nodes/types/common';
 import { CANVAS_OUTPUT } from 'features/nodes/util/graph/constants';
@@ -106,7 +101,6 @@ export const addInvocationCompleteEventListener = (startAppListening: AppStartLi
             }
 
             dispatch(imageSelected(imageDTO));
-            dispatch(isImageViewerOpenChanged(true));
           }
         }
       }

invokeai/frontend/web/src/app/store/store.ts

@@ -10,11 +10,6 @@ import {
   controlAdaptersPersistConfig,
   controlAdaptersSlice,
 } from 'features/controlAdapters/store/controlAdaptersSlice';
-import {
-  controlLayersPersistConfig,
-  controlLayersSlice,
-  controlLayersUndoableConfig,
-} from 'features/controlLayers/store/controlLayersSlice';
 import { deleteImageModalSlice } from 'features/deleteImageModal/store/slice';
 import { dynamicPromptsPersistConfig, dynamicPromptsSlice } from 'features/dynamicPrompts/store/dynamicPromptsSlice';
 import { galleryPersistConfig, gallerySlice } from 'features/gallery/store/gallerySlice';
@@ -35,7 +30,6 @@ import { defaultsDeep, keys, omit, pick } from 'lodash-es';
 import dynamicMiddlewares from 'redux-dynamic-middlewares';
 import type { SerializeFunction, UnserializeFunction } from 'redux-remember';
 import { rememberEnhancer, rememberReducer } from 'redux-remember';
-import undoable from 'redux-undo';
 import { serializeError } from 'serialize-error';
 import { api } from 'services/api';
 import { authToastMiddleware } from 'services/api/authToastMiddleware';
@@ -65,7 +59,6 @@ const allReducers = {
   [queueSlice.name]: queueSlice.reducer,
   [workflowSlice.name]: workflowSlice.reducer,
   [hrfSlice.name]: hrfSlice.reducer,
-  [controlLayersSlice.name]: undoable(controlLayersSlice.reducer, controlLayersUndoableConfig),
   [api.reducerPath]: api.reducer,
 };
 
@@ -110,7 +103,6 @@ const persistConfigs: { [key in keyof typeof allReducers]?: PersistConfig } = {
   [loraPersistConfig.name]: loraPersistConfig,
   [modelManagerV2PersistConfig.name]: modelManagerV2PersistConfig,
   [hrfPersistConfig.name]: hrfPersistConfig,
-  [controlLayersPersistConfig.name]: controlLayersPersistConfig,
 };
 
 const unserialize: UnserializeFunction = (data, key) => {
@@ -122,7 +114,6 @@ const unserialize: UnserializeFunction = (data, key) => {
   try {
     const { initialState, migrate } = persistConfig;
     const parsed = JSON.parse(data);
-
     // strip out old keys
     const stripped = pick(parsed, keys(initialState));
     // run (additive) migrations
@@ -150,9 +141,7 @@ const serialize: SerializeFunction = (data, key) => {
   if (!persistConfig) {
     throw new Error(`No persist config for slice "${key}"`);
   }
-  // Heuristic to determine if the slice is undoable - could just hardcode it in the persistConfig
-  const isUndoable = 'present' in data && 'past' in data && 'future' in data && '_latestUnfiltered' in data;
-  const result = omit(isUndoable ? data.present : data, persistConfig.persistDenylist);
+  const result = omit(data, persistConfig.persistDenylist);
   return JSON.stringify(result);
 };
 

invokeai/frontend/web/src/common/components/IAIColorPicker.tsx

@@ -26,7 +26,7 @@ const sx: ChakraProps['sx'] = {
 
 const colorPickerStyles: CSSProperties = { width: '100%' };
 
-const numberInputWidth: ChakraProps['w'] = '3.5rem';
+const numberInputWidth: ChakraProps['w'] = '4.2rem';
 
 const IAIColorPicker = (props: IAIColorPickerProps) => {
   const { color, onChange, withNumberInput, ...rest } = props;
@@ -41,7 +41,7 @@ const IAIColorPicker = (props: IAIColorPickerProps) => {
       {withNumberInput && (
         <Flex gap={5}>
           <FormControl gap={0}>
-            <FormLabel>{t('common.red')[0]}</FormLabel>
+            <FormLabel>{t('common.red')}</FormLabel>
             <CompositeNumberInput
               value={color.r}
               onChange={handleChangeR}
@@ -53,7 +53,7 @@ const IAIColorPicker = (props: IAIColorPickerProps) => {
             />
           </FormControl>
           <FormControl gap={0}>
-            <FormLabel>{t('common.green')[0]}</FormLabel>
+            <FormLabel>{t('common.green')}</FormLabel>
             <CompositeNumberInput
               value={color.g}
               onChange={handleChangeG}
@@ -65,7 +65,7 @@ const IAIColorPicker = (props: IAIColorPickerProps) => {
             />
           </FormControl>
           <FormControl gap={0}>
-            <FormLabel>{t('common.blue')[0]}</FormLabel>
+            <FormLabel>{t('common.blue')}</FormLabel>
             <CompositeNumberInput
               value={color.b}
               onChange={handleChangeB}
@@ -77,7 +77,7 @@ const IAIColorPicker = (props: IAIColorPickerProps) => {
             />
           </FormControl>
           <FormControl gap={0}>
-            <FormLabel>{t('common.alpha')[0]}</FormLabel>
+            <FormLabel>{t('common.alpha')}</FormLabel>
             <CompositeNumberInput
               value={color.a}
               onChange={handleChangeA}

invokeai/frontend/web/src/common/components/IAIDndImage.tsx

@@ -70,7 +70,6 @@ const IAIDndImage = (props: IAIDndImageProps) => {
     onMouseOver,
     onMouseOut,
     dataTestId,
-    ...rest
   } = props;
 
   const [isHovered, setIsHovered] = useState(false);
@@ -139,7 +138,6 @@ const IAIDndImage = (props: IAIDndImageProps) => {
           minH={minSize ? minSize : undefined}
           userSelect="none"
           cursor={isDragDisabled || !imageDTO ? 'default' : 'pointer'}
-          {...rest}
         >
           {imageDTO && (
             <Flex

invokeai/frontend/web/src/common/components/InformationalPopover/constants.ts

@@ -24,7 +24,6 @@ export type Feature =
   | 'dynamicPromptsSeedBehaviour'
   | 'imageFit'
   | 'infillMethod'
-  | 'ipAdapterMethod'
   | 'lora'
   | 'loraWeight'
   | 'noiseUseCPU'

invokeai/frontend/web/src/common/components/RgbColorPicker.tsx

@@ -1,84 +0,0 @@
-import type { ChakraProps } from '@invoke-ai/ui-library';
-import { CompositeNumberInput, Flex, FormControl, FormLabel } from '@invoke-ai/ui-library';
-import type { CSSProperties } from 'react';
-import { memo, useCallback } from 'react';
-import { RgbColorPicker as ColorfulRgbColorPicker } from 'react-colorful';
-import type { ColorPickerBaseProps, RgbColor } from 'react-colorful/dist/types';
-import { useTranslation } from 'react-i18next';
-
-type RgbColorPickerProps = ColorPickerBaseProps<RgbColor> & {
-  withNumberInput?: boolean;
-};
-
-const colorPickerPointerStyles: NonNullable<ChakraProps['sx']> = {
-  width: 6,
-  height: 6,
-  borderColor: 'base.100',
-};
-
-const sx: ChakraProps['sx'] = {
-  '.react-colorful__hue-pointer': colorPickerPointerStyles,
-  '.react-colorful__saturation-pointer': colorPickerPointerStyles,
-  '.react-colorful__alpha-pointer': colorPickerPointerStyles,
-  gap: 5,
-  flexDir: 'column',
-};
-
-const colorPickerStyles: CSSProperties = { width: '100%' };
-
-const numberInputWidth: ChakraProps['w'] = '3.5rem';
-
-const RgbColorPicker = (props: RgbColorPickerProps) => {
-  const { color, onChange, withNumberInput, ...rest } = props;
-  const { t } = useTranslation();
-  const handleChangeR = useCallback((r: number) => onChange({ ...color, r }), [color, onChange]);
-  const handleChangeG = useCallback((g: number) => onChange({ ...color, g }), [color, onChange]);
-  const handleChangeB = useCallback((b: number) => onChange({ ...color, b }), [color, onChange]);
-  return (
-    <Flex sx={sx}>
-      <ColorfulRgbColorPicker color={color} onChange={onChange} style={colorPickerStyles} {...rest} />
-      {withNumberInput && (
-        <Flex gap={5}>
-          <FormControl gap={0}>
-            <FormLabel>{t('common.red')[0]}</FormLabel>
-            <CompositeNumberInput
-              value={color.r}
-              onChange={handleChangeR}
-              min={0}
-              max={255}
-              step={1}
-              w={numberInputWidth}
-              defaultValue={90}
-            />
-          </FormControl>
-          <FormControl gap={0}>
-            <FormLabel>{t('common.green')[0]}</FormLabel>
-            <CompositeNumberInput
-              value={color.g}
-              onChange={handleChangeG}
-              min={0}
-              max={255}
-              step={1}
-              w={numberInputWidth}
-              defaultValue={90}
-            />
-          </FormControl>
-          <FormControl gap={0}>
-            <FormLabel>{t('common.blue')[0]}</FormLabel>
-            <CompositeNumberInput
-              value={color.b}
-              onChange={handleChangeB}
-              min={0}
-              max={255}
-              step={1}
-              w={numberInputWidth}
-              defaultValue={255}
-            />
-          </FormControl>
-        </Flex>
-      )}
-    </Flex>
-  );
-};
-
-export default memo(RgbColorPicker);

invokeai/frontend/web/src/common/hooks/useFullscreenDropzone.ts

@@ -17,10 +17,14 @@ const accept: Accept = {
 const selectPostUploadAction = createMemoizedSelector(activeTabNameSelector, (activeTabName) => {
   let postUploadAction: PostUploadAction = { type: 'TOAST' };
 
-  if (activeTabName === 'canvas') {
+  if (activeTabName === 'unifiedCanvas') {
     postUploadAction = { type: 'SET_CANVAS_INITIAL_IMAGE' };
   }
 
+  if (activeTabName === 'img2img') {
+    postUploadAction = { type: 'SET_INITIAL_IMAGE' };
+  }
+
   return postUploadAction;
 });
 

invokeai/frontend/web/src/common/hooks/useGlobalHotkeys.ts

@@ -9,7 +9,7 @@ import { useHotkeys } from 'react-hotkeys-hook';
 
 export const useGlobalHotkeys = () => {
   const dispatch = useAppDispatch();
-  const isModelManagerEnabled = useFeatureStatus('modelManager');
+  const isModelManagerEnabled = useFeatureStatus('modelManager').isFeatureEnabled;
   const { queueBack, isDisabled: isDisabledQueueBack, isLoading: isLoadingQueueBack } = useQueueBack();
 
   useHotkeys(
@@ -67,7 +67,7 @@ export const useGlobalHotkeys = () => {
   useHotkeys(
     '1',
     () => {
-      dispatch(setActiveTab('generation'));
+      dispatch(setActiveTab('txt2img'));
     },
     [dispatch]
   );
@@ -75,7 +75,7 @@ export const useGlobalHotkeys = () => {
   useHotkeys(
     '2',
     () => {
-      dispatch(setActiveTab('canvas'));
+      dispatch(setActiveTab('img2img'));
     },
     [dispatch]
   );
@@ -83,23 +83,31 @@ export const useGlobalHotkeys = () => {
   useHotkeys(
     '3',
     () => {
-      dispatch(setActiveTab('workflows'));
+      dispatch(setActiveTab('unifiedCanvas'));
     },
     [dispatch]
   );
 
   useHotkeys(
     '4',
+    () => {
+      dispatch(setActiveTab('nodes'));
+    },
+    [dispatch]
+  );
+
+  useHotkeys(
+    '5',
     () => {
       if (isModelManagerEnabled) {
-        dispatch(setActiveTab('models'));
+        dispatch(setActiveTab('modelManager'));
       }
     },
     [dispatch, isModelManagerEnabled]
   );
 
   useHotkeys(
-    isModelManagerEnabled ? '5' : '4',
+    isModelManagerEnabled ? '6' : '5',
     () => {
       dispatch(setActiveTab('queue'));
     },

invokeai/frontend/web/src/common/hooks/useGroupedModelCombobox.ts

@@ -13,7 +13,6 @@ type UseGroupedModelComboboxArg<T extends AnyModelConfig> = {
   onChange: (value: T | null) => void;
   getIsDisabled?: (model: T) => boolean;
   isLoading?: boolean;
-  groupByType?: boolean;
 };
 
 type UseGroupedModelComboboxReturn = {
@@ -24,21 +23,17 @@ type UseGroupedModelComboboxReturn = {
   noOptionsMessage: () => string;
 };
 
-const groupByBaseFunc = <T extends AnyModelConfig>(model: T) => model.base.toUpperCase();
-const groupByBaseAndTypeFunc = <T extends AnyModelConfig>(model: T) =>
-  `${model.base.toUpperCase()} / ${model.type.replaceAll('_', ' ').toUpperCase()}`;
-
 export const useGroupedModelCombobox = <T extends AnyModelConfig>(
   arg: UseGroupedModelComboboxArg<T>
 ): UseGroupedModelComboboxReturn => {
   const { t } = useTranslation();
   const base_model = useAppSelector((s) => s.generation.model?.base ?? 'sdxl');
-  const { modelConfigs, selectedModel, getIsDisabled, onChange, isLoading, groupByType = false } = arg;
+  const { modelConfigs, selectedModel, getIsDisabled, onChange, isLoading } = arg;
   const options = useMemo<GroupBase<ComboboxOption>[]>(() => {
     if (!modelConfigs) {
       return [];
     }
-    const groupedModels = groupBy(modelConfigs, groupByType ? groupByBaseAndTypeFunc : groupByBaseFunc);
+    const groupedModels = groupBy(modelConfigs, 'base');
     const _options = reduce(
       groupedModels,
       (acc, val, label) => {
@@ -54,9 +49,9 @@ export const useGroupedModelCombobox = <T extends AnyModelConfig>(
       },
       [] as GroupBase<ComboboxOption>[]
     );
-    _options.sort((a) => (a.label?.split('/')[0]?.toLowerCase().includes(base_model) ? -1 : 1));
+    _options.sort((a) => (a.label === base_model ? -1 : 1));
     return _options;
-  }, [modelConfigs, groupByType, getIsDisabled, base_model]);
+  }, [getIsDisabled, modelConfigs, base_model]);
 
   const value = useMemo(
     () =>

invokeai/frontend/web/src/common/hooks/useIsReadyToEnqueue.ts

@@ -5,8 +5,6 @@ import {
   selectControlAdaptersSlice,
 } from 'features/controlAdapters/store/controlAdaptersSlice';
 import { isControlNetOrT2IAdapter } from 'features/controlAdapters/store/types';
-import { selectControlLayersSlice } from 'features/controlLayers/store/controlLayersSlice';
-import type { Layer } from 'features/controlLayers/store/types';
 import { selectDynamicPromptsSlice } from 'features/dynamicPrompts/store/dynamicPromptsSlice';
 import { getShouldProcessPrompt } from 'features/dynamicPrompts/util/getShouldProcessPrompt';
 import { selectNodesSlice } from 'features/nodes/store/nodesSlice';
@@ -15,16 +13,9 @@ import { selectGenerationSlice } from 'features/parameters/store/generationSlice
 import { selectSystemSlice } from 'features/system/store/systemSlice';
 import { activeTabNameSelector } from 'features/ui/store/uiSelectors';
 import i18n from 'i18next';
-import { forEach, upperFirst } from 'lodash-es';
+import { forEach } from 'lodash-es';
 import { getConnectedEdges } from 'reactflow';
 
-const LAYER_TYPE_TO_TKEY: Record<Layer['type'], string> = {
-  initial_image_layer: 'controlLayers.globalInitialImage',
-  control_adapter_layer: 'controlLayers.globalControlAdapter',
-  ip_adapter_layer: 'controlLayers.globalIPAdapter',
-  regional_guidance_layer: 'controlLayers.regionalGuidance',
-};
-
 const selector = createMemoizedSelector(
   [
     selectControlAdaptersSlice,
@@ -32,27 +23,28 @@ const selector = createMemoizedSelector(
     selectSystemSlice,
     selectNodesSlice,
     selectDynamicPromptsSlice,
-    selectControlLayersSlice,
     activeTabNameSelector,
   ],
-  (controlAdapters, generation, system, nodes, dynamicPrompts, controlLayers, activeTabName) => {
-    const { model } = generation;
-    const { size } = controlLayers.present;
-    const { positivePrompt } = controlLayers.present;
+  (controlAdapters, generation, system, nodes, dynamicPrompts, activeTabName) => {
+    const { initialImage, model, positivePrompt } = generation;
 
     const { isConnected } = system;
 
-    const reasons: { prefix?: string; content: string }[] = [];
+    const reasons: string[] = [];
 
     // Cannot generate if not connected
     if (!isConnected) {
-      reasons.push({ content: i18n.t('parameters.invoke.systemDisconnected') });
+      reasons.push(i18n.t('parameters.invoke.systemDisconnected'));
     }
 
-    if (activeTabName === 'workflows') {
+    if (activeTabName === 'img2img' && !initialImage) {
+      reasons.push(i18n.t('parameters.invoke.noInitialImageSelected'));
+    }
+
+    if (activeTabName === 'nodes') {
       if (nodes.shouldValidateGraph) {
         if (!nodes.nodes.length) {
-          reasons.push({ content: i18n.t('parameters.invoke.noNodesInGraph') });
+          reasons.push(i18n.t('parameters.invoke.noNodesInGraph'));
         }
 
         nodes.nodes.forEach((node) => {
@@ -64,7 +56,7 @@ const selector = createMemoizedSelector(
 
           if (!nodeTemplate) {
             // Node type not found
-            reasons.push({ content: i18n.t('parameters.invoke.missingNodeTemplate') });
+            reasons.push(i18n.t('parameters.invoke.missingNodeTemplate'));
             return;
           }
 
@@ -77,17 +69,17 @@ const selector = createMemoizedSelector(
             );
 
             if (!fieldTemplate) {
-              reasons.push({ content: i18n.t('parameters.invoke.missingFieldTemplate') });
+              reasons.push(i18n.t('parameters.invoke.missingFieldTemplate'));
               return;
             }
 
             if (fieldTemplate.required && field.value === undefined && !hasConnection) {
-              reasons.push({
-                content: i18n.t('parameters.invoke.missingInputForField', {
+              reasons.push(
+                i18n.t('parameters.invoke.missingInputForField', {
                   nodeLabel: node.data.label || nodeTemplate.title,
                   fieldLabel: field.label || fieldTemplate.title,
-                }),
-              });
+                })
+              );
               return;
             }
           });
@@ -95,122 +87,44 @@ const selector = createMemoizedSelector(
       }
     } else {
       if (dynamicPrompts.prompts.length === 0 && getShouldProcessPrompt(positivePrompt)) {
-        reasons.push({ content: i18n.t('parameters.invoke.noPrompts') });
+        reasons.push(i18n.t('parameters.invoke.noPrompts'));
       }
 
       if (!model) {
-        reasons.push({ content: i18n.t('parameters.invoke.noModelSelected') });
+        reasons.push(i18n.t('parameters.invoke.noModelSelected'));
       }
 
-      if (activeTabName === 'generation') {
-        // Handling for generation tab
-        controlLayers.present.layers
-          .filter((l) => l.isEnabled)
-          .forEach((l, i) => {
-            const layerLiteral = i18n.t('controlLayers.layers_one');
-            const layerNumber = i + 1;
-            const layerType = i18n.t(LAYER_TYPE_TO_TKEY[l.type]);
-            const prefix = `${layerLiteral} #${layerNumber} (${layerType})`;
-            const problems: string[] = [];
-            if (l.type === 'control_adapter_layer') {
-              // Must have model
-              if (!l.controlAdapter.model) {
-                problems.push(i18n.t('parameters.invoke.layer.controlAdapterNoModelSelected'));
-              }
-              // Model base must match
-              if (l.controlAdapter.model?.base !== model?.base) {
-                problems.push(i18n.t('parameters.invoke.layer.controlAdapterIncompatibleBaseModel'));
-              }
-              // Must have a control image OR, if it has a processor, it must have a processed image
-              if (!l.controlAdapter.image) {
-                problems.push(i18n.t('parameters.invoke.layer.controlAdapterNoImageSelected'));
-              } else if (l.controlAdapter.processorConfig && !l.controlAdapter.processedImage) {
-                problems.push(i18n.t('parameters.invoke.layer.controlAdapterImageNotProcessed'));
-              }
-              // T2I Adapters require images have dimensions that are multiples of 64
-              if (l.controlAdapter.type === 't2i_adapter' && (size.width % 64 !== 0 || size.height % 64 !== 0)) {
-                problems.push(i18n.t('parameters.invoke.layer.t2iAdapterIncompatibleDimensions'));
-              }
-            }
+      selectControlAdapterAll(controlAdapters).forEach((ca, i) => {
+        if (!ca.isEnabled) {
+          return;
+        }
 
-            if (l.type === 'ip_adapter_layer') {
-              // Must have model
-              if (!l.ipAdapter.model) {
-                problems.push(i18n.t('parameters.invoke.layer.ipAdapterNoModelSelected'));
-              }
-              // Model base must match
-              if (l.ipAdapter.model?.base !== model?.base) {
-                problems.push(i18n.t('parameters.invoke.layer.ipAdapterIncompatibleBaseModel'));
-              }
-              // Must have an image
-              if (!l.ipAdapter.image) {
-                problems.push(i18n.t('parameters.invoke.layer.ipAdapterNoImageSelected'));
-              }
-            }
+        if (!ca.model) {
+          reasons.push(
+            i18n.t('parameters.invoke.noModelForControlAdapter', {
+              number: i + 1,
+            })
+          );
+        } else if (ca.model.base !== model?.base) {
+          // This should never happen, just a sanity check
+          reasons.push(
+            i18n.t('parameters.invoke.incompatibleBaseModelForControlAdapter', {
+              number: i + 1,
+            })
+          );
+        }
 
-            if (l.type === 'initial_image_layer') {
-              // Must have an image
-              if (!l.image) {
-                problems.push(i18n.t('parameters.invoke.layer.initialImageNoImageSelected'));
-              }
-            }
-
-            if (l.type === 'regional_guidance_layer') {
-              // Must have a region
-              if (l.maskObjects.length === 0) {
-                problems.push(i18n.t('parameters.invoke.layer.rgNoRegion'));
-              }
-              // Must have at least 1 prompt or IP Adapter
-              if (l.positivePrompt === null && l.negativePrompt === null && l.ipAdapters.length === 0) {
-                problems.push(i18n.t('parameters.invoke.layer.rgNoPromptsOrIPAdapters'));
-              }
-              l.ipAdapters.forEach((ipAdapter) => {
-                // Must have model
-                if (!ipAdapter.model) {
-                  problems.push(i18n.t('parameters.invoke.layer.ipAdapterNoModelSelected'));
-                }
-                // Model base must match
-                if (ipAdapter.model?.base !== model?.base) {
-                  problems.push(i18n.t('parameters.invoke.layer.ipAdapterIncompatibleBaseModel'));
-                }
-                // Must have an image
-                if (!ipAdapter.image) {
-                  problems.push(i18n.t('parameters.invoke.layer.ipAdapterNoImageSelected'));
-                }
-              });
-            }
-
-            if (problems.length) {
-              const content = upperFirst(problems.join(', '));
-              reasons.push({ prefix, content });
-            }
-          });
-      } else {
-        // Handling for all other tabs
-        selectControlAdapterAll(controlAdapters)
-          .filter((ca) => ca.isEnabled)
-          .forEach((ca, i) => {
-            if (!ca.isEnabled) {
-              return;
-            }
-
-            if (!ca.model) {
-              reasons.push({ content: i18n.t('parameters.invoke.noModelForControlAdapter', { number: i + 1 }) });
-            } else if (ca.model.base !== model?.base) {
-              // This should never happen, just a sanity check
-              reasons.push({
-                content: i18n.t('parameters.invoke.incompatibleBaseModelForControlAdapter', { number: i + 1 }),
-              });
-            }
-
-            if (
-              !ca.controlImage ||
-              (isControlNetOrT2IAdapter(ca) && !ca.processedControlImage && ca.processorType !== 'none')
-            ) {
-              reasons.push({ content: i18n.t('parameters.invoke.noControlImageForControlAdapter', { number: i + 1 }) });
-            }
-          });
-      }
+        if (
+          !ca.controlImage ||
+          (isControlNetOrT2IAdapter(ca) && !ca.processedControlImage && ca.processorType !== 'none')
+        ) {
+          reasons.push(
+            i18n.t('parameters.invoke.noControlImageForControlAdapter', {
+              number: i + 1,
+            })
+          );
+        }
+      });
     }
 
     return { isReady: !reasons.length, reasons };
@@ -218,6 +132,6 @@ const selector = createMemoizedSelector(
 );
 
 export const useIsReadyToEnqueue = () => {
-  const value = useAppSelector(selector);
-  return value;
+  const { isReady, reasons } = useAppSelector(selector);
+  return { isReady, reasons };
 };

invokeai/frontend/web/src/common/util/arrayUtils.test.ts

@@ -1,85 +0,0 @@
-import { moveBackward, moveForward, moveToBack, moveToFront } from 'common/util/arrayUtils';
-import { describe, expect, it } from 'vitest';
-
-describe('Array Manipulation Functions', () => {
-  const originalArray = ['a', 'b', 'c', 'd'];
-  describe('moveForwardOne', () => {
-    it('should move an item forward by one position', () => {
-      const array = [...originalArray];
-      const result = moveForward(array, (item) => item === 'b');
-      expect(result).toEqual(['a', 'c', 'b', 'd']);
-    });
-
-    it('should do nothing if the item is at the end', () => {
-      const array = [...originalArray];
-      const result = moveForward(array, (item) => item === 'd');
-      expect(result).toEqual(['a', 'b', 'c', 'd']);
-    });
-
-    it("should leave the array unchanged if the item isn't in the array", () => {
-      const array = [...originalArray];
-      const result = moveForward(array, (item) => item === 'z');
-      expect(result).toEqual(originalArray);
-    });
-  });
-
-  describe('moveToFront', () => {
-    it('should move an item to the front', () => {
-      const array = [...originalArray];
-      const result = moveToFront(array, (item) => item === 'c');
-      expect(result).toEqual(['c', 'a', 'b', 'd']);
-    });
-
-    it('should do nothing if the item is already at the front', () => {
-      const array = [...originalArray];
-      const result = moveToFront(array, (item) => item === 'a');
-      expect(result).toEqual(['a', 'b', 'c', 'd']);
-    });
-
-    it("should leave the array unchanged if the item isn't in the array", () => {
-      const array = [...originalArray];
-      const result = moveToFront(array, (item) => item === 'z');
-      expect(result).toEqual(originalArray);
-    });
-  });
-
-  describe('moveBackwardsOne', () => {
-    it('should move an item backward by one position', () => {
-      const array = [...originalArray];
-      const result = moveBackward(array, (item) => item === 'c');
-      expect(result).toEqual(['a', 'c', 'b', 'd']);
-    });
-
-    it('should do nothing if the item is at the beginning', () => {
-      const array = [...originalArray];
-      const result = moveBackward(array, (item) => item === 'a');
-      expect(result).toEqual(['a', 'b', 'c', 'd']);
-    });
-
-    it("should leave the array unchanged if the item isn't in the array", () => {
-      const array = [...originalArray];
-      const result = moveBackward(array, (item) => item === 'z');
-      expect(result).toEqual(originalArray);
-    });
-  });
-
-  describe('moveToBack', () => {
-    it('should move an item to the back', () => {
-      const array = [...originalArray];
-      const result = moveToBack(array, (item) => item === 'b');
-      expect(result).toEqual(['a', 'c', 'd', 'b']);
-    });
-
-    it('should do nothing if the item is already at the back', () => {
-      const array = [...originalArray];
-      const result = moveToBack(array, (item) => item === 'd');
-      expect(result).toEqual(['a', 'b', 'c', 'd']);
-    });
-
-    it("should leave the array unchanged if the item isn't in the array", () => {
-      const array = [...originalArray];
-      const result = moveToBack(array, (item) => item === 'z');
-      expect(result).toEqual(originalArray);
-    });
-  });
-});

invokeai/frontend/web/src/common/util/arrayUtils.ts

@@ -1,37 +0,0 @@
-export const moveForward = <T>(array: T[], callback: (item: T) => boolean): T[] => {
-  const index = array.findIndex(callback);
-  if (index >= 0 && index < array.length - 1) {
-    //@ts-expect-error - These indicies are safe per the previous check
-    [array[index], array[index + 1]] = [array[index + 1], array[index]];
-  }
-  return array;
-};
-
-export const moveToFront = <T>(array: T[], callback: (item: T) => boolean): T[] => {
-  const index = array.findIndex(callback);
-  if (index > 0) {
-    const [item] = array.splice(index, 1);
-    //@ts-expect-error - These indicies are safe per the previous check
-    array.unshift(item);
-  }
-  return array;
-};
-
-export const moveBackward = <T>(array: T[], callback: (item: T) => boolean): T[] => {
-  const index = array.findIndex(callback);
-  if (index > 0) {
-    //@ts-expect-error - These indicies are safe per the previous check
-    [array[index], array[index - 1]] = [array[index - 1], array[index]];
-  }
-  return array;
-};
-
-export const moveToBack = <T>(array: T[], callback: (item: T) => boolean): T[] => {
-  const index = array.findIndex(callback);
-  if (index >= 0 && index < array.length - 1) {
-    const [item] = array.splice(index, 1);
-    //@ts-expect-error - These indicies are safe per the previous check
-    array.push(item);
-  }
-  return array;
-};

invokeai/frontend/web/src/common/util/stopPropagation.ts

@@ -1,3 +0,0 @@
-export const stopPropagation = (e: React.MouseEvent) => {
-  e.stopPropagation();
-};

invokeai/frontend/web/src/features/canvas/components/IAICanvasToolbar/IAICanvasToolbar.tsx

@@ -21,6 +21,7 @@ import {
   setShouldShowBoundingBox,
 } from 'features/canvas/store/canvasSlice';
 import type { CanvasLayer } from 'features/canvas/store/canvasTypes';
+import { LAYER_NAMES_DICT } from 'features/canvas/store/canvasTypes';
 import { memo, useCallback, useMemo } from 'react';
 import { useHotkeys } from 'react-hotkeys-hook';
 import { useTranslation } from 'react-i18next';
@@ -215,20 +216,13 @@ const IAICanvasToolbar = () => {
     [dispatch, isMaskEnabled]
   );
 
-  const layerOptions = useMemo<{ label: string; value: CanvasLayer }[]>(
-    () => [
-      { label: t('unifiedCanvas.base'), value: 'base' },
-      { label: t('unifiedCanvas.mask'), value: 'mask' },
-    ],
-    [t]
-  );
-  const layerValue = useMemo(() => layerOptions.filter((o) => o.value === layer)[0] ?? null, [layer, layerOptions]);
+  const value = useMemo(() => LAYER_NAMES_DICT.filter((o) => o.value === layer)[0], [layer]);
 
   return (
     <Flex alignItems="center" gap={2} flexWrap="wrap">
       <Tooltip label={`${t('unifiedCanvas.layer')} (Q)`}>
         <FormControl isDisabled={isStaging} w="5rem">
-          <Combobox value={layerValue} options={layerOptions} onChange={handleChangeLayer} />
+          <Combobox value={value} options={LAYER_NAMES_DICT} onChange={handleChangeLayer} />
         </FormControl>
       </Tooltip>
 

invokeai/frontend/web/src/features/canvas/hooks/useCanvasHotkeys.ts

@@ -75,7 +75,7 @@ const useInpaintingCanvasHotkeys = () => {
 
   const onKeyDown = useCallback(
     (e: KeyboardEvent) => {
-      if (e.repeat || e.key !== ' ' || isInteractiveTarget(e.target) || activeTabName !== 'canvas') {
+      if (e.repeat || e.key !== ' ' || isInteractiveTarget(e.target) || activeTabName !== 'unifiedCanvas') {
         return;
       }
       if ($toolStash.get() || $tool.get() === 'move') {
@@ -90,7 +90,7 @@ const useInpaintingCanvasHotkeys = () => {
   );
   const onKeyUp = useCallback(
     (e: KeyboardEvent) => {
-      if (e.repeat || e.key !== ' ' || isInteractiveTarget(e.target) || activeTabName !== 'canvas') {
+      if (e.repeat || e.key !== ' ' || isInteractiveTarget(e.target) || activeTabName !== 'unifiedCanvas') {
         return;
       }
       if (!$toolStash.get() || $tool.get() !== 'move') {

invokeai/frontend/web/src/features/canvas/hooks/useCanvasZoom.ts

@@ -10,18 +10,6 @@ import { clamp } from 'lodash-es';
 import type { MutableRefObject } from 'react';
 import { useCallback } from 'react';
 
-export const calculateNewBrushSize = (brushSize: number, delta: number) => {
-  // This equation was derived by fitting a curve to the desired brush sizes and deltas
-  // see https://github.com/invoke-ai/InvokeAI/pull/5542#issuecomment-1915847565
-  const targetDelta = Math.sign(delta) * 0.7363 * Math.pow(1.0394, brushSize);
-  // This needs to be clamped to prevent the delta from getting too large
-  const finalDelta = clamp(targetDelta, -20, 20);
-  // The new brush size is also clamped to prevent it from getting too large or small
-  const newBrushSize = clamp(brushSize + finalDelta, 1, 500);
-
-  return newBrushSize;
-};
-
 const useCanvasWheel = (stageRef: MutableRefObject<Konva.Stage | null>) => {
   const dispatch = useAppDispatch();
   const stageScale = useAppSelector((s) => s.canvas.stageScale);
@@ -48,7 +36,15 @@ const useCanvasWheel = (stageRef: MutableRefObject<Konva.Stage | null>) => {
       }
 
       if ($ctrl.get() || $meta.get()) {
-        dispatch(setBrushSize(calculateNewBrushSize(brushSize, delta)));
+        // This equation was derived by fitting a curve to the desired brush sizes and deltas
+        // see https://github.com/invoke-ai/InvokeAI/pull/5542#issuecomment-1915847565
+        const targetDelta = Math.sign(delta) * 0.7363 * Math.pow(1.0394, brushSize);
+        // This needs to be clamped to prevent the delta from getting too large
+        const finalDelta = clamp(targetDelta, -20, 20);
+        // The new brush size is also clamped to prevent it from getting too large or small
+        const newBrushSize = clamp(brushSize + finalDelta, 1, 500);
+
+        dispatch(setBrushSize(newBrushSize));
       } else {
         const cursorPos = stageRef.current.getPointerPosition();
         let delta = e.evt.deltaY;

invokeai/frontend/web/src/features/canvas/store/canvasSlice.ts

@@ -8,7 +8,6 @@ import calculateScale from 'features/canvas/util/calculateScale';
 import { STAGE_PADDING_PERCENTAGE } from 'features/canvas/util/constants';
 import floorCoordinates from 'features/canvas/util/floorCoordinates';
 import getScaledBoundingBoxDimensions from 'features/canvas/util/getScaledBoundingBoxDimensions';
-import { calculateNewSize } from 'features/parameters/components/ImageSize/calculateNewSize';
 import { initialAspectRatioState } from 'features/parameters/components/ImageSize/constants';
 import type { AspectRatioState } from 'features/parameters/components/ImageSize/types';
 import { modelChanged } from 'features/parameters/store/generationSlice';
@@ -589,9 +588,8 @@ export const canvasSlice = createSlice({
   },
   extraReducers: (builder) => {
     builder.addCase(modelChanged, (state, action) => {
-      const newModel = action.payload;
-      if (!newModel || action.meta.previousModel?.base === newModel.base) {
-        // Model was cleared or the base didn't change
+      if (action.meta.previousModel?.base === action.payload?.base) {
+        // The base model hasn't changed, we don't need to optimize the size
         return;
       }
       const optimalDimension = getOptimalDimension(action.payload);
@@ -599,8 +597,14 @@ export const canvasSlice = createSlice({
       if (getIsSizeOptimal(width, height, optimalDimension)) {
         return;
       }
-      const newSize = calculateNewSize(state.aspectRatio.value, optimalDimension * optimalDimension);
-      setBoundingBoxDimensionsReducer(state, newSize, optimalDimension);
+      setBoundingBoxDimensionsReducer(
+        state,
+        {
+          width,
+          height,
+        },
+        optimalDimension
+      );
     });
 
     builder.addCase(socketQueueItemStatusChanged, (state, action) => {

invokeai/frontend/web/src/features/canvas/store/canvasTypes.ts

@@ -5,6 +5,11 @@ import { z } from 'zod';
 
 export type CanvasLayer = 'base' | 'mask';
 
+export const LAYER_NAMES_DICT: { label: string; value: CanvasLayer }[] = [
+  { label: 'Base', value: 'base' },
+  { label: 'Mask', value: 'mask' },
+];
+
 const zBoundingBoxScaleMethod = z.enum(['none', 'auto', 'manual']);
 export type BoundingBoxScaleMethod = z.infer<typeof zBoundingBoxScaleMethod>;
 export const isBoundingBoxScaleMethod = (v: unknown): v is BoundingBoxScaleMethod =>

invokeai/frontend/web/src/features/canvas/util/blobToDataURL.ts

@@ -7,22 +7,3 @@ export const blobToDataURL = (blob: Blob): Promise<string> => {
     reader.readAsDataURL(blob);
   });
 };
-
-export function imageDataToDataURL(imageData: ImageData): string {
-  const { width, height } = imageData;
-
-  // Create a canvas to transfer the ImageData to
-  const canvas = document.createElement('canvas');
-  canvas.width = width;
-  canvas.height = height;
-
-  // Draw the ImageData onto the canvas
-  const ctx = canvas.getContext('2d');
-  if (!ctx) {
-    throw new Error('Unable to get canvas context');
-  }
-  ctx.putImageData(imageData, 0, 0);
-
-  // Convert the canvas to a data URL (base64)
-  return canvas.toDataURL();
-}

invokeai/frontend/web/src/features/canvas/util/colorToString.ts

@@ -1,11 +1,6 @@
-import type { RgbaColor, RgbColor } from 'react-colorful';
+import type { RgbaColor } from 'react-colorful';
 
 export const rgbaColorToString = (color: RgbaColor): string => {
   const { r, g, b, a } = color;
   return `rgba(${r}, ${g}, ${b}, ${a})`;
 };
-
-export const rgbColorToString = (color: RgbColor): string => {
-  const { r, g, b } = color;
-  return `rgba(${r}, ${g}, ${b})`;
-};

invokeai/frontend/web/src/features/controlAdapters/components/ControlAdapterConfig.tsx

@@ -21,7 +21,6 @@ import ControlAdapterShouldAutoConfig from './ControlAdapterShouldAutoConfig';
 import ControlNetCanvasImageImports from './imports/ControlNetCanvasImageImports';
 import { ParamControlAdapterBeginEnd } from './parameters/ParamControlAdapterBeginEnd';
 import ParamControlAdapterControlMode from './parameters/ParamControlAdapterControlMode';
-import ParamControlAdapterIPMethod from './parameters/ParamControlAdapterIPMethod';
 import ParamControlAdapterProcessorSelect from './parameters/ParamControlAdapterProcessorSelect';
 import ParamControlAdapterResizeMode from './parameters/ParamControlAdapterResizeMode';
 import ParamControlAdapterWeight from './parameters/ParamControlAdapterWeight';
@@ -76,7 +75,7 @@ const ControlAdapterConfig = (props: { id: string; number: number }) => {
         <Box minW={0} w="full" transitionProperty="common" transitionDuration="0.1s">
           <ParamControlAdapterModel id={id} />
         </Box>
-        {activeTabName === 'canvas' && <ControlNetCanvasImageImports id={id} />}
+        {activeTabName === 'unifiedCanvas' && <ControlNetCanvasImageImports id={id} />}
         <IconButton
           size="sm"
           tooltip={t('controlnet.duplicate')}
@@ -112,8 +111,7 @@ const ControlAdapterConfig = (props: { id: string; number: number }) => {
 
       <Flex w="full" flexDir="column" gap={4}>
         <Flex gap={8} w="full" alignItems="center">
-          <Flex flexDir="column" gap={4} h={controlAdapterType === 'ip_adapter' ? 40 : 32} w="full">
-            <ParamControlAdapterIPMethod id={id} />
+          <Flex flexDir="column" gap={2} h={32} w="full">
             <ParamControlAdapterWeight id={id} />
             <ParamControlAdapterBeginEnd id={id} />
           </Flex>