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

Merge branch 'blessedcoolant-gfpgan-optimization' into main

Browse Source 
This reduces VRAM requirements when GFPGAN face fixing and Real-ESRGAN
upscaling are used. --gfpgan flag is no longer needed (or accepted)
This commit is contained in:
Lincoln Stein 2022-08-28 17:06:49 -04:00
commit 36bc989a27
6 changed files with 479 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

368
README.md
View File

@ -5,13 +5,13 @@ text-to-image generator. The original has been improved in several ways:
## Interactive command-line interface similar to the Discord bot ## Interactive command-line interface similar to the Discord bot
The *dream.py* script, located in scripts/dream.py, The _dream.py_ script, located in scripts/dream.py,
provides an interactive interface to image generation similar to provides an interactive interface to image generation similar to
the "dream mothership" bot that Stable AI provided on its Discord the "dream mothership" bot that Stable AI provided on its Discord
server. Unlike the txt2img.py and img2img.py scripts provided in the server. Unlike the txt2img.py and img2img.py scripts provided in the
original CompViz/stable-diffusion source code repository, the original CompViz/stable-diffusion source code repository, the
time-consuming initialization of the AI model time-consuming initialization of the AI model
initialization only happens once. After that image generation initialization only happens once. After that image generation
from the command-line interface is very fast. from the command-line interface is very fast.
The script uses the readline library to allow for in-line editing, The script uses the readline library to allow for in-line editing,
@ -25,7 +25,7 @@ The script is confirmed to work on Linux and Windows systems. It should
work on MacOSX as well, but this is not confirmed. Note that this script work on MacOSX as well, but this is not confirmed. Note that this script
runs from the command-line (CMD or Terminal window), and does not have a GUI. runs from the command-line (CMD or Terminal window), and does not have a GUI.
~~~~ ```
(ldm) ~/stable-diffusion$ python3 ./scripts/dream.py (ldm) ~/stable-diffusion$ python3 ./scripts/dream.py
* Initializing, be patient... * Initializing, be patient...
Loading model from models/ldm/text2img-large/model.ckpt Loading model from models/ldm/text2img-large/model.ckpt
@ -47,13 +47,13 @@ dream> q
00009.png: "ashley judd riding a camel" -s150 -S 416354203 00009.png: "ashley judd riding a camel" -s150 -S 416354203
00010.png: "ashley judd riding a camel" -s150 -S 1362479620 00010.png: "ashley judd riding a camel" -s150 -S 1362479620
00011.png: "there's a fly in my soup" -n6 -g -S 2685670268 00011.png: "there's a fly in my soup" -n6 -g -S 2685670268
~~~~ ```
The dream> prompt's arguments are pretty much identical to those used The dream> prompt's arguments are pretty much identical to those used
in the Discord bot, except you don't need to type "!dream" (it doesn't in the Discord bot, except you don't need to type "!dream" (it doesn't
hurt if you do). A significant change is that creation of individual hurt if you do). A significant change is that creation of individual
images is now the default unless --grid (-g) is given. For backward images is now the default unless --grid (-g) is given. For backward
compatibility, the -i switch is recognized. For command-line help compatibility, the -i switch is recognized. For command-line help
type -h (or --help) at the dream> prompt. type -h (or --help) at the dream> prompt.
The script itself also recognizes a series of command-line switches The script itself also recognizes a series of command-line switches
@ -65,12 +65,12 @@ image outputs and the location of the model weight files.
This script also provides an img2img feature that lets you seed your This script also provides an img2img feature that lets you seed your
creations with a drawing or photo. This is a really cool feature that tells creations with a drawing or photo. This is a really cool feature that tells
stable diffusion to build the prompt on top of the image you provide, preserving stable diffusion to build the prompt on top of the image you provide, preserving
the original's basic shape and layout. To use it, provide the --init_img the original's basic shape and layout. To use it, provide the --init_img
option as shown here: option as shown here:
~~~~ ```
dream> "waterfall and rainbow" --init_img=./init-images/crude_drawing.png --strength=0.5 -s100 -n4 dream> "waterfall and rainbow" --init_img=./init-images/crude_drawing.png --strength=0.5 -s100 -n4
~~~~ ```
The --init_img (-I) option gives the path to the seed picture. --strength (-f) controls how much The --init_img (-I) option gives the path to the seed picture. --strength (-f) controls how much
the original will be modified, ranging from 0.0 (keep the original intact), to 1.0 (ignore the original the original will be modified, ranging from 0.0 (keep the original intact), to 1.0 (ignore the original
@ -80,77 +80,81 @@ You may also pass a -v<count> option to generate count variants on the original
passing the first generated image back into img2img the requested number of times. It generates interesting passing the first generated image back into img2img the requested number of times. It generates interesting
variants. variants.
## GFPGAN Support ## GFPGAN and Real-ESRGAN Support
This script also provides the ability to invoke GFPGAN after image The script also provides the ability to do face restoration and upscaling with the help of GFPGAN and Real-ESRGAN respectively.
generation. Doing so will enhance faces and optionally upscale the
image to a higher resolution.
To use the ability, clone the [GFPGAN To use the ability, clone the **[GFPGAN
repository](https://github.com/TencentARC/GFPGAN) and follow their repository](https://github.com/TencentARC/GFPGAN)** and follow their
installation instructions. By default, we expect GFPGAN to be installation instructions. By default, we expect GFPGAN to be
installed in a 'GFPGAN' sibling directory. Be sure that the "ldm" installed in a 'GFPGAN' sibling directory. Be sure that the `"ldm"`
conda environment is active as you install GFPGAN. conda environment is active as you install GFPGAN.
You may also want to install Real-ESRGAN, if you want to enhance You can use the `--gfpgan_dir` argument with `dream.py` to set a custom path to your GFPGAN directory. _There are other GFPGAN related boot arguments if you wish to customize further._
non-face regions in the image, by installing the pip Real-ESRGAN
package. You can install **Real-ESRGAN** by typing the following command.
``` ```
pip install realesrgan pip install realesrgan
``` ```
Users whose GPU machines are isolated from the Internet (e.g. on a **Preloading Models**
University cluster) should be aware that the first time you run
dream.py with GFPGAN turned on, it will try to download model files
from the Internet. To rectify this, you may run `python3
scripts/preload_models.pl` after you have installed GFPGAN and all its
dependencies.
Now, you can run this script by adding the **--gfpgan** option. Any Users whose GPU machines are isolated from the Internet (e.g. on a University cluster) should be aware that the first time you run
issues with GFPGAN will be reported on initialization. dream.py with GFPGAN and Real-ESRGAN turned on, it will try to download model files from the Internet. To rectify this, you may run `python3 scripts/preload_models.py` after you have installed GFPGAN and all its dependencies.
~~~~ **Usage**
You will now have access to two new prompt arguments.
**Upscaling**
`-U : <upscaling_factor> <upscaling_strength>`
The upscaling prompt argument takes two values. The first value is a scaling factor and should be set to either `2` or `4` only. This will either scale the image 2x or 4x respectively using different models.
You can set the scaling stength between `0` and `1.0` to control intensity of the of the scaling. This is handy because AI upscalers generally tend to smooth out texture details. If you wish to retain some of those for natural looking results, we recommend using values between `0.5 to 0.8`.
**Face Restoration**
`-G : <gfpgan_strength>`
This prompt argument controls the strength of the face restoration that is being applied. Similar to upscaling, values between `0.5 to 0.8` are recommended.
You can use either one or both without any conflicts. In cases where you use both, the image will be first upscaled and then the face restoration process will be executed to ensure you get the highest quality facial features.
`-save_orig`
When you use either `-U` or `-G`, the final result you get is upscaled or face modified. If you want to save the original Stable Diffusion generation, you can use the `-save_orig` prompt argument to save the original unaffected version too.
**Example Usage**
```
dream > superman dancing with a panda bear -U 2 0.6 -G 0.4
```
```
(ldm) ~/stable-diffusion$ python3 ./scripts/dream.py --gfpgan (ldm) ~/stable-diffusion$ python3 ./scripts/dream.py --gfpgan
* Initializing, be patient... * Initializing, be patient...
(...more initialization messages...) (...more initialization messages...)
* --gfpgan was specified, loading gfpgan... * --gfpgan was specified, loading gfpgan...
(...even more initialization messages...) (...even more initialization messages...)
* Initialization done! Awaiting your command... * Initialization done! Awaiting your command...
~~~~ ```
When generating prompts, add a -G or --gfpgan_strenth option to
control the strength of the GFPGAN enhancement. 0.0 is no
enhancement, 1.0 is maximum enhancement.
So for instance, to apply the maximum strength:
~~~~
dream> a man wearing a pineapple hat -G 1
~~~~
This also works with img2img: This also works with img2img:
~~~
dream> a man wearing a pineapple hat -I path/to/your/file.png -G 1
~~~
That's it! ```
dream> a man wearing a pineapple hat -I path/to/your/file.png -U 2 0.5 -G 0.6
```
There's also a bunch of options to control GFPGAN settings when **Note**
starting the script for different configs that you can read about in
the help text. This will let you control where GFPGAN is installed, if
upsampling is enabled, the upsampler to use and the model path.
By default, images will be upscaled by 2-fold, meaning that the old GFPGAN and Real-ESRGAN are both memory intensive. In order to avoid crashes and memory overloads during the Stable Diffusion process, these effects are applied after Stable Diffusion has completed its work.
Stable Diffusion default size of 512x512 will now be a glorious
detailed 1024x1024. The extent of upscaling is set when you run the
script, and can't be changed while it's running. However, at any time
you may specify **-G0** to turn off upscaling and facial enhancement
for that image or set of images.
Note that loading GFPGAN consumes additional GPU memory, and will add In single image generations, you will see the output right away but when you are using multiple iterations, the images will first be generated and then upscaled and face restored after that process is complete. While the image generation is taking place, you will still be able to preview the base images.
a few seconds to image generation. However, if can afford a 3090s with
24Gi, the results are well worth it. If you wish to stop during the image generation but want to upscale or face restore a particular generated image, pass it again with the same prompt and generated seed along with the `-U` and `-G` prompt arguments to perform those actions.
## Barebones Web Server ## Barebones Web Server
@ -158,6 +162,10 @@ As of version 1.10, this distribution comes with a bare bones web
server (see screenshot). To use it, run the *dream.py* script by server (see screenshot). To use it, run the *dream.py* script by
adding the **--web** option. adding the **--web** option.
```
(ldm) ~/stable-diffusion$ python3 scripts/dream_web.py --web
```
You can then connect to the server by pointing your web browser at You can then connect to the server by pointing your web browser at
http://localhost:9090, or to the network name or IP address of the server. http://localhost:9090, or to the network name or IP address of the server.
@ -174,23 +182,23 @@ you want to run, one line per prompt. The text file must be composed
with a text editor (e.g. Notepad) and not a word processor. Each line with a text editor (e.g. Notepad) and not a word processor. Each line
should look like what you would type at the dream> prompt: should look like what you would type at the dream> prompt:
~~~~ ```
a beautiful sunny day in the park, children playing -n4 -C10 a beautiful sunny day in the park, children playing -n4 -C10
stormy weather on a mountain top, goats grazing -s100 stormy weather on a mountain top, goats grazing -s100
innovative packaging for a squid's dinner -S137038382 innovative packaging for a squid's dinner -S137038382
~~~~ ```
Then pass this file's name to dream.py when you invoke it: Then pass this file's name to dream.py when you invoke it:
~~~~ ```
(ldm) ~/stable-diffusion$ python3 scripts/dream.py --from_file "path/to/prompts.txt" (ldm) ~/stable-diffusion$ python3 scripts/dream.py --from_file "path/to/prompts.txt"
~~~~ ```
You may read a series of prompts from standard input by providing a filename of "-": You may read a series of prompts from standard input by providing a filename of "-":
~~~~ ```
(ldm) ~/stable-diffusion$ echo "a beautiful day" | python3 scripts/dream.py --from_file - (ldm) ~/stable-diffusion$ echo "a beautiful day" | python3 scripts/dream.py --from_file -
~~~~ ```
## Shortcut for reusing seeds from the previous command ## Shortcut for reusing seeds from the previous command
@ -206,7 +214,7 @@ Here's an example of using this to do a quick refinement. It also
illustrates using the new **-G** switch to turn on upscaling and illustrates using the new **-G** switch to turn on upscaling and
face enhancement (see previous section): face enhancement (see previous section):
~~~~ ```
dream> a cute child playing hopscotch -G0.5 dream> a cute child playing hopscotch -G0.5
[...] [...]
outputs/img-samples/000039.3498014304.png: "a cute child playing hopscotch" -s50 -b1 -W512 -H512 -C7.5 -mk_lms -S3498014304 outputs/img-samples/000039.3498014304.png: "a cute child playing hopscotch" -s50 -b1 -W512 -H512 -C7.5 -mk_lms -S3498014304
@ -216,9 +224,7 @@ dream> a cute child playing hopscotch -G1.0 -s100 -S -1
reusing previous seed 3498014304 reusing previous seed 3498014304
[...] [...]
outputs/img-samples/000040.3498014304.png: "a cute child playing hopscotch" -G1.0 -s100 -b1 -W512 -H512 -C7.5 -mk_lms -S3498014304 outputs/img-samples/000040.3498014304.png: "a cute child playing hopscotch" -G1.0 -s100 -b1 -W512 -H512 -C7.5 -mk_lms -S3498014304
~~~~ ```
## Weighted Prompts ## Weighted Prompts
@ -226,9 +232,9 @@ You may weight different sections of the prompt to tell the sampler to attach di
priority to them, by adding :(number) to the end of the section you wish to up- or downweight. priority to them, by adding :(number) to the end of the section you wish to up- or downweight.
For example consider this prompt: For example consider this prompt:
~~~~ ```
tabby cat:0.25 white duck:0.75 hybrid tabby cat:0.25 white duck:0.75 hybrid
~~~~ ```
This will tell the sampler to invest 25% of its effort on the tabby This will tell the sampler to invest 25% of its effort on the tabby
cat aspect of the image and 75% on the white duck aspect cat aspect of the image and 75% on the white duck aspect
@ -243,7 +249,7 @@ and introducing a new vocabulary to the fixed model.
To train, prepare a folder that contains images sized at 512x512 and execute the following: To train, prepare a folder that contains images sized at 512x512 and execute the following:
~~~~ ```
# As the default backend is not available on Windows, if you're using that platform, execute SET PL_TORCH_DISTRIBUTED_BACKEND=gloo # As the default backend is not available on Windows, if you're using that platform, execute SET PL_TORCH_DISTRIBUTED_BACKEND=gloo
(ldm) ~/stable-diffusion$ python3 ./main.py --base ./configs/stable-diffusion/v1-finetune.yaml \ (ldm) ~/stable-diffusion$ python3 ./main.py --base ./configs/stable-diffusion/v1-finetune.yaml \
-t \ -t \
@ -252,14 +258,14 @@ To train, prepare a folder that contains images sized at 512x512 and execute the
--gpus 0, \ --gpus 0, \
--data_root D:/textual-inversion/my_cat \ --data_root D:/textual-inversion/my_cat \
--init_word 'cat' --init_word 'cat'
~~~~ ```
During the training process, files will be created in /logs/[project][time][project]/ During the training process, files will be created in /logs/[project][time][project]/
where you can see the process. where you can see the process.
conditioning* contains the training prompts conditioning\* contains the training prompts
inputs, reconstruction the input images for the training epoch inputs, reconstruction the input images for the training epoch
samples, samples scaled for a sample of the prompt and one with the init word provided samples, samples scaled for a sample of the prompt and one with the init word provided
On a RTX3090, the process for SD will take ~1h @1.6 iterations/sec. On a RTX3090, the process for SD will take ~1h @1.6 iterations/sec.
@ -273,28 +279,29 @@ heat death of the universe, when you find a low loss epoch or around
Once the model is trained, specify the trained .pt file when starting Once the model is trained, specify the trained .pt file when starting
dream using dream using
~~~~ ```
(ldm) ~/stable-diffusion$ python3 ./scripts/dream.py --embedding_path /path/to/embedding.pt --full_precision (ldm) ~/stable-diffusion$ python3 ./scripts/dream.py --embedding_path /path/to/embedding.pt --full_precision
~~~~ ```
Then, to utilize your subject at the dream prompt Then, to utilize your subject at the dream prompt
~~~ ```
dream> "a photo of *" dream> "a photo of *"
~~~ ```
this also works with image2image this also works with image2image
~~~~
```
dream> "waterfall and rainbow in the style of *" --init_img=./init-images/crude_drawing.png --strength=0.5 -s100 -n4 dream> "waterfall and rainbow in the style of *" --init_img=./init-images/crude_drawing.png --strength=0.5 -s100 -n4
~~~~ ```
It's also possible to train multiple tokens (modify the placeholder string in configs/stable-diffusion/v1-finetune.yaml) and combine LDM checkpoints using: It's also possible to train multiple tokens (modify the placeholder string in configs/stable-diffusion/v1-finetune.yaml) and combine LDM checkpoints using:
~~~~ ```
(ldm) ~/stable-diffusion$ python3 ./scripts/merge_embeddings.py \ (ldm) ~/stable-diffusion$ python3 ./scripts/merge_embeddings.py \
--manager_ckpts /path/to/first/embedding.pt /path/to/second/embedding.pt [...] \ --manager_ckpts /path/to/first/embedding.pt /path/to/second/embedding.pt [...] \
--output_path /path/to/output/embedding.pt --output_path /path/to/output/embedding.pt
~~~~ ```
Credit goes to @rinongal and the repository located at Credit goes to @rinongal and the repository located at
https://github.com/rinongal/textual_inversion Please see the https://github.com/rinongal/textual_inversion Please see the
@ -302,86 +309,90 @@ repository and associated paper for details and limitations.
## Changes ## Changes
* v1.12 (28 August 2022) - v1.12 (28 August 2022)
* Improved file handling, including ability to read prompts from standard input.
(kudos to [Yunsaki](https://github.com/yunsaki) - Improved file handling, including ability to read prompts from standard input.
* The web server is now integrated with the dream.py script. Invoke by adding --web to (kudos to [Yunsaki](https://github.com/yunsaki)
- The web server is now integrated with the dream.py script. Invoke by adding --web to
the dream.py command arguments. the dream.py command arguments.
* v1.11 (26 August 2022)
* NEW FEATURE: Support upscaling and face enhancement using the GFPGAN module. (kudos to [Oceanswave](https://github.com/Oceanswave)
* You now can specify a seed of -1 to use the previous image's seed, -2 to use the seed for the image generated before that, etc.
Seed memory only extends back to the previous command, but will work on all images generated with the -n# switch.
* Variant generation support temporarily disabled pending more general solution.
* Created a feature branch named **yunsaki-morphing-dream** which adds experimental support for
iteratively modifying the prompt and its parameters. Please see[ Pull Request #86](https://github.com/lstein/stable-diffusion/pull/86)
for a synopsis of how this works. Note that when this feature is eventually added to the main branch, it will may be modified
significantly.
* v1.10 (25 August 2022)
* A barebones but fully functional interactive web server for online generation of txt2img and img2img.
* v1.09 (24 August 2022)
* A new -v option allows you to generate multiple variants of an initial image
in img2img mode. (kudos to [Oceanswave](https://github.com/Oceanswave). [
See this discussion in the PR for examples and details on use](https://github.com/lstein/stable-diffusion/pull/71#issuecomment-1226700810))
* Added ability to personalize text to image generation (kudos to [Oceanswave](https://github.com/Oceanswave) and [nicolai256](https://github.com/nicolai256))
* Enabled all of the samplers from k_diffusion
* v1.08 (24 August 2022)
* Escape single quotes on the dream> command before trying to parse. This avoids
parse errors.
* Removed instruction to get Python3.8 as first step in Windows install.
Anaconda3 does it for you.
* Added bounds checks for numeric arguments that could cause crashes.
* Cleaned up the copyright and license agreement files.
* v1.07 (23 August 2022) - v1.11 (26 August 2022)
* Image filenames will now never fill gaps in the sequence, but will be assigned the - NEW FEATURE: Support upscaling and face enhancement using the GFPGAN module. (kudos to [Oceanswave](https://github.com/Oceanswave)
next higher name in the chosen directory. This ensures that the alphabetic and chronological - You now can specify a seed of -1 to use the previous image's seed, -2 to use the seed for the image generated before that, etc.
sort orders are the same. Seed memory only extends back to the previous command, but will work on all images generated with the -n# switch.
- Variant generation support temporarily disabled pending more general solution.
- Created a feature branch named **yunsaki-morphing-dream** which adds experimental support for
iteratively modifying the prompt and its parameters. Please see[ Pull Request #86](https://github.com/lstein/stable-diffusion/pull/86)
for a synopsis of how this works. Note that when this feature is eventually added to the main branch, it will may be modified
significantly.
- v1.10 (25 August 2022)
- A barebones but fully functional interactive web server for online generation of txt2img and img2img.
- v1.09 (24 August 2022)
- A new -v option allows you to generate multiple variants of an initial image
in img2img mode. (kudos to [Oceanswave](https://github.com/Oceanswave). [
See this discussion in the PR for examples and details on use](https://github.com/lstein/stable-diffusion/pull/71#issuecomment-1226700810))
- Added ability to personalize text to image generation (kudos to [Oceanswave](https://github.com/Oceanswave) and [nicolai256](https://github.com/nicolai256))
- Enabled all of the samplers from k_diffusion
- v1.08 (24 August 2022)
* v1.06 (23 August 2022) - Escape single quotes on the dream> command before trying to parse. This avoids
* Added weighted prompt support contributed by [xraxra](https://github.com/xraxra) parse errors.
* Example of using weighted prompts to tweak a demonic figure contributed by [bmaltais](https://github.com/bmaltais) - Removed instruction to get Python3.8 as first step in Windows install.
Anaconda3 does it for you.
- Added bounds checks for numeric arguments that could cause crashes.
- Cleaned up the copyright and license agreement files.
* v1.05 (22 August 2022 - after the drop) - v1.07 (23 August 2022)
* Filenames now use the following formats:
000010.95183149.png -- Two files produced by the same command (e.g. -n2),
000010.26742632.png -- distinguished by a different seed.
000011.455191342.01.png -- Two files produced by the same command using - Image filenames will now never fill gaps in the sequence, but will be assigned the
000011.455191342.02.png -- a batch size>1 (e.g. -b2). They have the same seed. next higher name in the chosen directory. This ensures that the alphabetic and chronological
sort orders are the same.
000011.4160627868.grid#1-4.png -- a grid of four images (-g); the whole grid can - v1.06 (23 August 2022)
be regenerated with the indicated key
* It should no longer be possible for one image to overwrite another - Added weighted prompt support contributed by [xraxra](https://github.com/xraxra)
* You can use the "cd" and "pwd" commands at the dream> prompt to set and retrieve - Example of using weighted prompts to tweak a demonic figure contributed by [bmaltais](https://github.com/bmaltais)
the path of the output directory. (NOTE: Removed in v1.12)
* v1.04 (22 August 2022 - after the drop)
* Updated README to reflect installation of the released weights.
* Suppressed very noisy and inconsequential warning when loading the frozen CLIP
tokenizer.
* v1.03 (22 August 2022) - v1.05 (22 August 2022 - after the drop)
* The original txt2img and img2img scripts from the CompViz repository have been moved into
a subfolder named "orig_scripts", to reduce confusion. - Filenames now use the following formats:
000010.95183149.png -- Two files produced by the same command (e.g. -n2),
* v1.02 (21 August 2022) 000010.26742632.png -- distinguished by a different seed.
* A copy of the prompt and all of its switches and options is now stored in the corresponding
000011.455191342.01.png -- Two files produced by the same command using
000011.455191342.02.png -- a batch size>1 (e.g. -b2). They have the same seed.
000011.4160627868.grid#1-4.png -- a grid of four images (-g); the whole grid can
be regenerated with the indicated key
- It should no longer be possible for one image to overwrite another
- You can use the "cd" and "pwd" commands at the dream> prompt to set and retrieve
the path of the output directory.
- v1.04 (22 August 2022 - after the drop)
- Updated README to reflect installation of the released weights.
- Suppressed very noisy and inconsequential warning when loading the frozen CLIP
tokenizer.
- v1.03 (22 August 2022)
- The original txt2img and img2img scripts from the CompViz repository have been moved into
a subfolder named "orig_scripts", to reduce confusion.
- v1.02 (21 August 2022)
- A copy of the prompt and all of its switches and options is now stored in the corresponding
image in a tEXt metadata field named "Dream". You can read the prompt using scripts/images2prompt.py, image in a tEXt metadata field named "Dream". You can read the prompt using scripts/images2prompt.py,
or an image editor that allows you to explore the full metadata. or an image editor that allows you to explore the full metadata.
**Please run "conda env update -f environment.yaml" to load the k_lms dependencies!!** **Please run "conda env update -f environment.yaml" to load the k_lms dependencies!!**
* v1.01 (21 August 2022) - v1.01 (21 August 2022)
* added k_lms sampling. - added k_lms sampling.
**Please run "conda env update -f environment.yaml" to load the k_lms dependencies!!** **Please run "conda env update -f environment.yaml" to load the k_lms dependencies!!**
* use half precision arithmetic by default, resulting in faster execution and lower memory requirements - use half precision arithmetic by default, resulting in faster execution and lower memory requirements
Pass argument --full_precision to dream.py to get slower but more accurate image generation Pass argument --full_precision to dream.py to get slower but more accurate image generation
## Installation ## Installation
There are separate installation walkthroughs for [Linux/Mac](#linuxmac) and [Windows](#windows). There are separate installation walkthroughs for [Linux/Mac](#linuxmac) and [Windows](#windows).
@ -389,38 +400,48 @@ There are separate installation walkthroughs for [Linux/Mac](#linuxmac) and [Win
### Linux/Mac ### Linux/Mac
1. You will need to install the following prerequisites if they are not already available. Use your 1. You will need to install the following prerequisites if they are not already available. Use your
operating system's preferred installer operating system's preferred installer
* Python (version 3.8.5 recommended; higher may work)
* git - Python (version 3.8.5 recommended; higher may work)
- git
2. Install the Python Anaconda environment manager using pip3. 2. Install the Python Anaconda environment manager using pip3.
``` ```
~$ pip3 install anaconda ~$ pip3 install anaconda
``` ```
After installing anaconda, you should log out of your system and log back in. If the installation After installing anaconda, you should log out of your system and log back in. If the installation
worked, your command prompt will be prefixed by the name of the current anaconda environment, "(base)". worked, your command prompt will be prefixed by the name of the current anaconda environment, "(base)".
3. Copy the stable-diffusion source code from GitHub: 3. Copy the stable-diffusion source code from GitHub:
``` ```
(base) ~$ git clone https://github.com/lstein/stable-diffusion.git (base) ~$ git clone https://github.com/lstein/stable-diffusion.git
``` ```
This will create stable-diffusion folder where you will follow the rest of the steps. This will create stable-diffusion folder where you will follow the rest of the steps.
4. Enter the newly-created stable-diffusion folder. From this step forward make sure that you are working in the stable-diffusion directory! 4. Enter the newly-created stable-diffusion folder. From this step forward make sure that you are working in the stable-diffusion directory!
``` ```
(base) ~$ cd stable-diffusion (base) ~$ cd stable-diffusion
(base) ~/stable-diffusion$ (base) ~/stable-diffusion$
``` ```
5. Use anaconda to copy necessary python packages, create a new python environment named "ldm", 5. Use anaconda to copy necessary python packages, create a new python environment named "ldm",
and activate the environment. and activate the environment.
``` ```
(base) ~/stable-diffusion$ conda env create -f environment.yaml (base) ~/stable-diffusion$ conda env create -f environment.yaml
(base) ~/stable-diffusion$ conda activate ldm (base) ~/stable-diffusion$ conda activate ldm
(ldm) ~/stable-diffusion$ (ldm) ~/stable-diffusion$
``` ```
After these steps, your command prompt will be prefixed by "(ldm)" as shown above. After these steps, your command prompt will be prefixed by "(ldm)" as shown above.
6. Load a couple of small machine-learning models required by stable diffusion: 6. Load a couple of small machine-learning models required by stable diffusion:
``` ```
(ldm) ~/stable-diffusion$ python3 scripts/preload_models.py (ldm) ~/stable-diffusion$ python3 scripts/preload_models.py
``` ```
@ -440,13 +461,14 @@ to a page that prompts you to click the "download" link. Save the file somewhere
Now run the following commands from within the stable-diffusion directory. This will create a symbolic Now run the following commands from within the stable-diffusion directory. This will create a symbolic
link from the stable-diffusion model.ckpt file, to the true location of the sd-v1-4.ckpt file. link from the stable-diffusion model.ckpt file, to the true location of the sd-v1-4.ckpt file.
``` ```
(ldm) ~/stable-diffusion$ mkdir -p models/ldm/stable-diffusion-v1 (ldm) ~/stable-diffusion$ mkdir -p models/ldm/stable-diffusion-v1
(ldm) ~/stable-diffusion$ ln -sf /path/to/sd-v1-4.ckpt models/ldm/stable-diffusion-v1/model.ckpt (ldm) ~/stable-diffusion$ ln -sf /path/to/sd-v1-4.ckpt models/ldm/stable-diffusion-v1/model.ckpt
``` ```
8. Start generating images! 8. Start generating images!
``` ```
# for the pre-release weights use the -l or --liaon400m switch # for the pre-release weights use the -l or --liaon400m switch
(ldm) ~/stable-diffusion$ python3 scripts/dream.py -l (ldm) ~/stable-diffusion$ python3 scripts/dream.py -l
@ -457,15 +479,18 @@ link from the stable-diffusion model.ckpt file, to the true location of the sd-v
# for additional configuration switches and arguments, use -h or --help # for additional configuration switches and arguments, use -h or --help
(ldm) ~/stable-diffusion$ python3 scripts/dream.py -h (ldm) ~/stable-diffusion$ python3 scripts/dream.py -h
``` ```
9. Subsequently, to relaunch the script, be sure to run "conda activate ldm" (step 5, second command), enter the "stable-diffusion"
directory, and then launch the dream script (step 8). If you forget to activate the ldm environment, the script will fail with multiple ModuleNotFound errors. 9. Subsequently, to relaunch the script, be sure to run "conda activate ldm" (step 5, second command), enter the "stable-diffusion"
directory, and then launch the dream script (step 8). If you forget to activate the ldm environment, the script will fail with multiple ModuleNotFound errors.
#### Updating to newer versions of the script #### Updating to newer versions of the script
This distribution is changing rapidly. If you used the "git clone" method (step 5) to download the stable-diffusion directory, then to update to the latest and greatest version, launch the Anaconda window, enter "stable-diffusion", and type: This distribution is changing rapidly. If you used the "git clone" method (step 5) to download the stable-diffusion directory, then to update to the latest and greatest version, launch the Anaconda window, enter "stable-diffusion", and type:
``` ```
(ldm) ~/stable-diffusion$ git pull (ldm) ~/stable-diffusion$ git pull
``` ```
This will bring your local copy into sync with the remote one. This will bring your local copy into sync with the remote one.
### Windows ### Windows
@ -477,24 +502,30 @@ This will bring your local copy into sync with the remote one.
3. Launch Anaconda from the Windows Start menu. This will bring up a command window. Type all the remaining commands in this window. 3. Launch Anaconda from the Windows Start menu. This will bring up a command window. Type all the remaining commands in this window.
4. Run the command: 4. Run the command:
``` ```
git clone https://github.com/lstein/stable-diffusion.git git clone https://github.com/lstein/stable-diffusion.git
``` ```
This will create stable-diffusion folder where you will follow the rest of the steps. This will create stable-diffusion folder where you will follow the rest of the steps.
5. Enter the newly-created stable-diffusion folder. From this step forward make sure that you are working in the stable-diffusion directory! 5. Enter the newly-created stable-diffusion folder. From this step forward make sure that you are working in the stable-diffusion directory!
``` ```
cd stable-diffusion cd stable-diffusion
``` ```
6. Run the following two commands: 6. Run the following two commands:
``` ```
conda env create -f environment.yaml (step 6a) conda env create -f environment.yaml (step 6a)
conda activate ldm (step 6b) conda activate ldm (step 6b)
``` ```
This will install all python requirements and activate the "ldm" environment which sets PATH and other environment variables properly. This will install all python requirements and activate the "ldm" environment which sets PATH and other environment variables properly.
7. Run the command: 7. Run the command:
``` ```
python scripts\preload_models.py python scripts\preload_models.py
``` ```
@ -507,30 +538,32 @@ downloaded just-in-time)
8. Now you need to install the weights for the big stable diffusion model. 8. Now you need to install the weights for the big stable diffusion model.
For running with the released weights, you will first need to set up For running with the released weights, you will first need to set up
an acount with Hugging Face (https://huggingface.co). Use your an acount with Hugging Face (https://huggingface.co). Use your
credentials to log in, and then point your browser at credentials to log in, and then point your browser at
https://huggingface.co/CompVis/stable-diffusion-v-1-4-original. You https://huggingface.co/CompVis/stable-diffusion-v-1-4-original. You
may be asked to sign a license agreement at this point. may be asked to sign a license agreement at this point.
Click on "Files and versions" near the top of the page, and then click Click on "Files and versions" near the top of the page, and then click
on the file named "sd-v1-4.ckpt". You'll be taken to a page that on the file named "sd-v1-4.ckpt". You'll be taken to a page that
prompts you to click the "download" link. Now save the file somewhere prompts you to click the "download" link. Now save the file somewhere
safe on your local machine. The weight file is >4 GB in size, so safe on your local machine. The weight file is >4 GB in size, so
downloading may take a while. downloading may take a while.
Now run the following commands from **within the stable-diffusion Now run the following commands from **within the stable-diffusion
directory** to copy the weights file to the right place: directory** to copy the weights file to the right place:
``` ```
mkdir -p models\ldm\stable-diffusion-v1 mkdir -p models\ldm\stable-diffusion-v1
copy C:\path\to\sd-v1-4.ckpt models\ldm\stable-diffusion-v1\model.ckpt copy C:\path\to\sd-v1-4.ckpt models\ldm\stable-diffusion-v1\model.ckpt
``` ```
Please replace "C:\path\to\sd-v1.4.ckpt" with the correct path to wherever Please replace "C:\path\to\sd-v1.4.ckpt" with the correct path to wherever
you stashed this file. If you prefer not to copy or move the .ckpt file, you stashed this file. If you prefer not to copy or move the .ckpt file,
you may instead create a shortcut to it from within you may instead create a shortcut to it from within
"models\ldm\stable-diffusion-v1\". "models\ldm\stable-diffusion-v1\".
9. Start generating images! 9. Start generating images!
``` ```
# for the pre-release weights # for the pre-release weights
python scripts\dream.py -l python scripts\dream.py -l
@ -538,14 +571,17 @@ python scripts\dream.py -l
# for the post-release weights # for the post-release weights
python scripts\dream.py python scripts\dream.py
``` ```
10. Subsequently, to relaunch the script, first activate the Anaconda command window (step 3), enter the stable-diffusion directory (step 5, "cd \path\to\stable-diffusion"), run "conda activate ldm" (step 6b), and then launch the dream script (step 9). 10. Subsequently, to relaunch the script, first activate the Anaconda command window (step 3), enter the stable-diffusion directory (step 5, "cd \path\to\stable-diffusion"), run "conda activate ldm" (step 6b), and then launch the dream script (step 9).
#### Updating to newer versions of the script #### Updating to newer versions of the script
This distribution is changing rapidly. If you used the "git clone" method (step 5) to download the stable-diffusion directory, then to update to the latest and greatest version, launch the Anaconda window, enter "stable-diffusion", and type: This distribution is changing rapidly. If you used the "git clone" method (step 5) to download the stable-diffusion directory, then to update to the latest and greatest version, launch the Anaconda window, enter "stable-diffusion", and type:
``` ```
git pull git pull
``` ```
This will bring your local copy into sync with the remote one. This will bring your local copy into sync with the remote one.
## Simplified API for text to image generation ## Simplified API for text to image generation
@ -554,22 +590,21 @@ For programmers who wish to incorporate stable-diffusion into other
products, this repository includes a simplified API for text to image generation, which products, this repository includes a simplified API for text to image generation, which
lets you create images from a prompt in just three lines of code: lets you create images from a prompt in just three lines of code:
~~~~ ```
from ldm.simplet2i import T2I from ldm.simplet2i import T2I
model = T2I() model = T2I()
outputs = model.txt2img("a unicorn in manhattan") outputs = model.txt2img("a unicorn in manhattan")
~~~~ ```
Outputs is a list of lists in the format [[filename1,seed1],[filename2,seed2]...] Outputs is a list of lists in the format [[filename1,seed1],[filename2,seed2]...]
Please see ldm/simplet2i.py for more information. Please see ldm/simplet2i.py for more information.
## Workaround for machines with limited internet connectivity ## Workaround for machines with limited internet connectivity
My development machine is a GPU node in a high-performance compute My development machine is a GPU node in a high-performance compute
cluster which has no connection to the internet. During model cluster which has no connection to the internet. During model
initialization, stable-diffusion tries to download the Bert tokenizer initialization, stable-diffusion tries to download the Bert tokenizer
and a file needed by the kornia library. This obviously didn't work and a file needed by the kornia library. This obviously didn't work
for me. for me.
To work around this, I have modified ldm/modules/encoders/modules.py To work around this, I have modified ldm/modules/encoders/modules.py
@ -580,7 +615,7 @@ prior to running the code on an isolated one. This assumes that both
machines share a common network-mounted filesystem with a common machines share a common network-mounted filesystem with a common
.cache directory. .cache directory.
~~~~ ```
(ldm) ~/stable-diffusion$ python3 ./scripts/preload_models.py (ldm) ~/stable-diffusion$ python3 ./scripts/preload_models.py
preloading bert tokenizer... preloading bert tokenizer...
Downloading: 100%|██████████████████████████████████| 28.0/28.0 [00:00<00:00, 49.3kB/s] Downloading: 100%|██████████████████████████████████| 28.0/28.0 [00:00<00:00, 49.3kB/s]
@ -592,7 +627,7 @@ preloading kornia requirements...
Downloading: "https://github.com/DagnyT/hardnet/raw/master/pretrained/train_liberty_with_aug/checkpoint_liberty_with_aug.pth" to /u/lstein/.cache/torch/hub/checkpoints/checkpoint_liberty_with_aug.pth Downloading: "https://github.com/DagnyT/hardnet/raw/master/pretrained/train_liberty_with_aug/checkpoint_liberty_with_aug.pth" to /u/lstein/.cache/torch/hub/checkpoints/checkpoint_liberty_with_aug.pth
100%|███████████████████████████████████████████████| 5.10M/5.10M [00:00<00:00, 101MB/s] 100%|███████████████████████████████████████████████| 5.10M/5.10M [00:00<00:00, 101MB/s]
...success ...success
~~~~ ```
If you don't need this change and want to download the files just in If you don't need this change and want to download the files just in
time, copy over the file ldm/modules/encoders/modules.py from the time, copy over the file ldm/modules/encoders/modules.py from the
@ -605,16 +640,15 @@ For support,
please use this repository's GitHub Issues tracking service. Feel free please use this repository's GitHub Issues tracking service. Feel free
to send me an email if you use and like the script. to send me an email if you use and like the script.
*Original Author:* Lincoln D. Stein <lincoln.stein@gmail.com> _Original Author:_ Lincoln D. Stein <lincoln.stein@gmail.com>
*Contributions by:* _Contributions by:_
[Peter Kowalczyk](https://github.com/slix), [Henry Harrison](https://github.com/hwharrison), [Peter Kowalczyk](https://github.com/slix), [Henry Harrison](https://github.com/hwharrison),
[xraxra](https://github.com/xraxra), [bmaltais](https://github.com/bmaltais), [Sean McLellan](https://github.com/Oceanswave), [xraxra](https://github.com/xraxra), [bmaltais](https://github.com/bmaltais), [Sean McLellan](https://github.com/Oceanswave),
[nicolai256](https://github.com/nicolai256), [Benjamin Warner](https://github.com/warner-benjamin), [nicolai256](https://github.com/nicolai256), [Benjamin Warner](https://github.com/warner-benjamin),
[tildebyte](https://github.com/tildebyte),[yunsaki](https://github.com/yunsaki) [tildebyte](https://github.com/tildebyte),[yunsaki](https://github.com/yunsaki)
and [Tesseract Cat](https://github.com/TesseractCat) and [Tesseract Cat](https://github.com/TesseractCat)
Original portions of the software are Copyright (c) 2020 Lincoln D. Stein (https://github.com/lstein) Original portions of the software are Copyright (c) 2020 Lincoln D. Stein (https://github.com/lstein)
#Further Reading #Further Reading

13
ldm/dream/pngwriter.py
View File

@ -14,6 +14,8 @@ from math import sqrt, floor, ceil
from PIL import Image, PngImagePlugin from PIL import Image, PngImagePlugin
# -------------------image generation utils----- # -------------------image generation utils-----
class PngWriter: class PngWriter:
def __init__(self, outdir, prompt=None, batch_size=1): def __init__(self, outdir, prompt=None, batch_size=1):
self.outdir = outdir self.outdir = outdir
@ -23,18 +25,19 @@ class PngWriter:
self.files_written = [] self.files_written = []
os.makedirs(outdir, exist_ok=True) os.makedirs(outdir, exist_ok=True)
def write_image(self, image, seed): def write_image(self, image, seed, upscaled=False):
self.filepath = self.unique_filename( self.filepath = self.unique_filename(
seed, self.filepath seed, upscaled, self.filepath
) # will increment name in some sensible way ) # will increment name in some sensible way
try: try:
prompt = f'{self.prompt} -S{seed}' prompt = f'{self.prompt} -S{seed}'
self.save_image_and_prompt_to_png(image, prompt, self.filepath) self.save_image_and_prompt_to_png(image, prompt, self.filepath)
except IOError as e: except IOError as e:
print(e) print(e)
self.files_written.append([self.filepath, seed]) if not upscaled:
self.files_written.append([self.filepath, seed])
def unique_filename(self, seed, previouspath=None): def unique_filename(self, seed, upscaled, previouspath=None):
revision = 1 revision = 1
if previouspath is None: if previouspath is None:
@ -68,6 +71,8 @@ class PngWriter:
if self.batch_size > 1 or os.path.exists( if self.batch_size > 1 or os.path.exists(
os.path.join(self.outdir, filename) os.path.join(self.outdir, filename)
): ):
if upscaled:
break
filename = f'{basecount:06}.{seed}.{series:02}.png' filename = f'{basecount:06}.{seed}.{series:02}.png'
finished = not os.path.exists( finished = not os.path.exists(
os.path.join(self.outdir, filename) os.path.join(self.outdir, filename)

165
ldm/gfpgan/gfpgan_tools.py Normal file
View File

@ -0,0 +1,165 @@
import torch
import warnings
import os
import sys
import numpy as np
from PIL import Image
from scripts.dream import create_argv_parser
arg_parser = create_argv_parser()
opt = arg_parser.parse_args()
def _run_gfpgan(image, strength, prompt, seed, upsampler_scale=4):
print(f'\n* GFPGAN - Restoring Faces: {prompt} : seed:{seed}')
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=DeprecationWarning)
warnings.filterwarnings('ignore', category=UserWarning)
try:
model_path = os.path.join(opt.gfpgan_dir, opt.gfpgan_model_path)
if not os.path.isfile(model_path):
raise Exception('GFPGAN model not found at path ' + model_path)
sys.path.append(os.path.abspath(opt.gfpgan_dir))
from gfpgan import GFPGANer
bg_upsampler = _load_gfpgan_bg_upsampler(
opt.gfpgan_bg_upsampler, upsampler_scale, opt.gfpgan_bg_tile
)
gfpgan = GFPGANer(
model_path=model_path,
upscale=upsampler_scale,
arch='clean',
channel_multiplier=2,
bg_upsampler=bg_upsampler,
)
except Exception:
import traceback
print('Error loading GFPGAN:', file=sys.stderr)
print(traceback.format_exc(), file=sys.stderr)
if gfpgan is None:
print(
f'GFPGAN not initialized, it must be loaded via the --gfpgan argument'
)
return image
image = image.convert('RGB')
cropped_faces, restored_faces, restored_img = gfpgan.enhance(
np.array(image, dtype=np.uint8),
has_aligned=False,
only_center_face=False,
paste_back=True,
)
res = Image.fromarray(restored_img)
if strength < 1.0:
# Resize the image to the new image if the sizes have changed
if restored_img.size != image.size:
image = image.resize(res.size)
res = Image.blend(image, res, strength)
if torch.cuda.is_available():
torch.cuda.empty_cache()
gfpgan = None
return res
def _load_gfpgan_bg_upsampler(bg_upsampler, upsampler_scale, bg_tile=400):
if bg_upsampler == 'realesrgan':
if not torch.cuda.is_available(): # CPU
warnings.warn(
'The unoptimized RealESRGAN is slow on CPU. We do not use it. '
'If you really want to use it, please modify the corresponding codes.'
)
bg_upsampler = None
else:
model_path = {
2: 'https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.1/RealESRGAN_x2plus.pth',
4: 'https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth',
}
if upsampler_scale not in model_path:
return None
from basicsr.archs.rrdbnet_arch import RRDBNet
from realesrgan import RealESRGANer
if upsampler_scale == 4:
model = RRDBNet(
num_in_ch=3,
num_out_ch=3,
num_feat=64,
num_block=23,
num_grow_ch=32,
scale=4,
)
if upsampler_scale == 2:
model = RRDBNet(
num_in_ch=3,
num_out_ch=3,
num_feat=64,
num_block=23,
num_grow_ch=32,
scale=2,
)
bg_upsampler = RealESRGANer(
scale=upsampler_scale,
model_path=model_path[upsampler_scale],
model=model,
tile=bg_tile,
tile_pad=10,
pre_pad=0,
half=True,
) # need to set False in CPU mode
else:
bg_upsampler = None
return bg_upsampler
def real_esrgan_upscale(image, strength, upsampler_scale, prompt, seed):
print(
f'\n* Real-ESRGAN Upscaling: {prompt} : seed:{seed} : scale:{upsampler_scale}x'
)
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=DeprecationWarning)
warnings.filterwarnings('ignore', category=UserWarning)
try:
upsampler = _load_gfpgan_bg_upsampler(
opt.gfpgan_bg_upsampler, upsampler_scale, opt.gfpgan_bg_tile
)
except Exception:
import traceback
print('Error loading Real-ESRGAN:', file=sys.stderr)
print(traceback.format_exc(), file=sys.stderr)
output, img_mode = upsampler.enhance(
np.array(image, dtype=np.uint8),
outscale=upsampler_scale,
alpha_upsampler=opt.gfpgan_bg_upsampler,
)
res = Image.fromarray(output)
if strength < 1.0:
# Resize the image to the new image if the sizes have changed
if output.size != image.size:
image = image.resize(res.size)
res = Image.blend(image, res, strength)
if torch.cuda.is_available():
torch.cuda.empty_cache()
upsampler = None
return res

112
ldm/simplet2i.py
View File

@ -7,7 +7,6 @@
import torch import torch
import numpy as np import numpy as np
import random import random
import sys
import os import os
from omegaconf import OmegaConf from omegaconf import OmegaConf
from PIL import Image from PIL import Image
@ -21,7 +20,6 @@ from contextlib import contextmanager, nullcontext
import transformers import transformers
import time import time
import re import re
import traceback
from ldm.util import instantiate_from_config from ldm.util import instantiate_from_config
from ldm.models.diffusion.ddim import DDIMSampler from ldm.models.diffusion.ddim import DDIMSampler
@ -133,9 +131,9 @@ class T2I:
full_precision=False, full_precision=False,
strength=0.75, # default in scripts/img2img.py strength=0.75, # default in scripts/img2img.py
embedding_path=None, embedding_path=None,
latent_diffusion_weights=False, # just to keep track of this parameter when regenerating prompt # just to keep track of this parameter when regenerating prompt
latent_diffusion_weights=False,
device='cuda', device='cuda',
gfpgan=None,
): ):
self.batch_size = batch_size self.batch_size = batch_size
self.iterations = iterations self.iterations = iterations
@ -157,7 +155,7 @@ class T2I:
self.sampler = None self.sampler = None
self.latent_diffusion_weights = latent_diffusion_weights self.latent_diffusion_weights = latent_diffusion_weights
self.device = device self.device = device
self.gfpgan = gfpgan
self.session_peakmem = torch.cuda.max_memory_allocated() self.session_peakmem = torch.cuda.max_memory_allocated()
if seed is None: if seed is None:
self.seed = self._new_seed() self.seed = self._new_seed()
@ -176,7 +174,8 @@ class T2I:
outdir, prompt, kwargs.get('batch_size', self.batch_size) outdir, prompt, kwargs.get('batch_size', self.batch_size)
) )
for r in results: for r in results:
metadata_str = f'prompt2png("{prompt}" {kwargs} seed={r[1]}' # gets written into the PNG # gets written into the PNG
metadata_str = f'prompt2png("{prompt}" {kwargs} seed={r[1]}'
pngwriter.write_image(r[0], r[1]) pngwriter.write_image(r[0], r[1])
return pngwriter.files_written return pngwriter.files_written
@ -210,6 +209,8 @@ class T2I:
init_img=None, init_img=None,
strength=None, strength=None,
gfpgan_strength=None, gfpgan_strength=None,
save_original=False,
upscale=None,
variants=None, variants=None,
**args, **args,
): # eat up additional cruft ): # eat up additional cruft
@ -266,7 +267,7 @@ class T2I:
f'Height and width must be multiples of 64. Resizing to {h}x{w}.' f'Height and width must be multiples of 64. Resizing to {h}x{w}.'
) )
height = h height = h
width = w width = w
scope = autocast if self.precision == 'autocast' else nullcontext scope = autocast if self.precision == 'autocast' else nullcontext
@ -302,29 +303,47 @@ class T2I:
) )
with scope(self.device.type), self.model.ema_scope(): with scope(self.device.type), self.model.ema_scope():
for n in trange(iterations, desc='Sampling'): for n in trange(iterations, desc='Generating'):
seed_everything(seed) seed_everything(seed)
iter_images = next(images_iterator) iter_images = next(images_iterator)
for image in iter_images: for image in iter_images:
try:
# if gfpgan strength is none or less than or equal to 0.0 then
# don't even attempt to use GFPGAN.
# if the user specified a value of -G that satisifies the condition and
# --gfpgan wasn't specified, at startup then
# the net result is a message gets printed - nothing else happens.
if gfpgan_strength is not None and gfpgan_strength > 0.0:
image = self._run_gfpgan(
image, gfpgan_strength
)
except Exception as e:
print(
f'Error running GFPGAN - Your image was not enhanced.\n{e}'
)
results.append([image, seed]) results.append([image, seed])
if image_callback is not None: if image_callback is not None:
image_callback(image, seed) image_callback(image, seed)
seed = self._new_seed() seed = self._new_seed()
if upscale is not None or gfpgan_strength > 0:
for result in results:
image, seed = result
try:
if upscale is not None:
from ldm.gfpgan.gfpgan_tools import (
real_esrgan_upscale,
)
image = real_esrgan_upscale(
image,
upscale[1],
int(upscale[0]),
prompt,
seed,
)
if gfpgan_strength > 0:
from ldm.gfpgan.gfpgan_tools import _run_gfpgan
image = _run_gfpgan(
image, gfpgan_strength, prompt, seed, 1
)
except Exception as e:
print(
f'Error running RealESRGAN - Your image was not upscaled.\n{e}'
)
if image_callback is not None:
if save_original:
image_callback(image, seed)
else:
image_callback(image, seed, upscaled=True)
except KeyboardInterrupt: except KeyboardInterrupt:
print('*interrupted*') print('*interrupted*')
print( print(
@ -335,11 +354,21 @@ class T2I:
print('Are you sure your system has an adequate NVIDIA GPU?') print('Are you sure your system has an adequate NVIDIA GPU?')
toc = time.time() toc = time.time()
self.session_peakmem = max(self.session_peakmem,torch.cuda.max_memory_allocated() ) self.session_peakmem = max(
self.session_peakmem, torch.cuda.max_memory_allocated()
)
print('Usage stats:') print('Usage stats:')
print(f' {len(results)} image(s) generated in', '%4.2fs' % (toc - tic)) print(
print(f' Max VRAM used for this generation:', '%4.2fG' % (torch.cuda.max_memory_allocated()/1E9)) f' {len(results)} image(s) generated in', '%4.2fs' % (toc - tic)
print(f' Max VRAM used since script start: ', '%4.2fG' % (self.session_peakmem/1E9)) )
print(
f' Max VRAM used for this generation:',
'%4.2fG' % (torch.cuda.max_memory_allocated() / 1e9),
)
print(
f' Max VRAM used since script start: ',
'%4.2fG' % (self.session_peakmem / 1e9),
)
return results return results
@torch.no_grad() @torch.no_grad()
@ -498,7 +527,9 @@ class T2I:
self.device = self._get_device() self.device = self._get_device()
model = self._load_model_from_config(config, self.weights) model = self._load_model_from_config(config, self.weights)
if self.embedding_path is not None: if self.embedding_path is not None:
model.embedding_manager.load(self.embedding_path, self.full_precision) model.embedding_manager.load(
self.embedding_path, self.full_precision
)
self.model = model.to(self.device) self.model = model.to(self.device)
# model.to doesn't change the cond_stage_model.device used to move the tokenizer output, so set it here # model.to doesn't change the cond_stage_model.device used to move the tokenizer output, so set it here
self.model.cond_stage_model.device = self.device self.model.cond_stage_model.device = self.device
@ -561,7 +592,7 @@ class T2I:
def _load_img(self, path): def _load_img(self, path):
with Image.open(path) as img: with Image.open(path) as img:
image = img.convert("RGB") image = img.convert('RGB')
w, h = image.size w, h = image.size
print(f'loaded input image of size ({w}, {h}) from {path}') print(f'loaded input image of size ({w}, {h}) from {path}')
@ -620,28 +651,3 @@ class T2I:
weights.append(1.0) weights.append(1.0)
remaining = 0 remaining = 0
return prompts, weights return prompts, weights
def _run_gfpgan(self, image, strength):
if self.gfpgan is None:
print(
f'GFPGAN not initialized, it must be loaded via the --gfpgan argument'
)
return image
image = image.convert('RGB')
cropped_faces, restored_faces, restored_img = self.gfpgan.enhance(
np.array(image, dtype=np.uint8),
has_aligned=False,
only_center_face=False,
paste_back=True,
)
res = Image.fromarray(restored_img)
if strength < 1.0:
# Resize the image to the new image if the sizes have changed
if restored_img.size != image.size:
image = image.resize(res.size)
res = Image.blend(image, res, strength)
return res

147
scripts/dream.py
View File

@ -11,6 +11,7 @@ import ldm.dream.readline
from ldm.dream.pngwriter import PngWriter, PromptFormatter from ldm.dream.pngwriter import PngWriter, PromptFormatter
from ldm.dream.server import DreamServer, ThreadingDreamServer from ldm.dream.server import DreamServer, ThreadingDreamServer
def main(): def main():
"""Initialize command-line parsers and the diffusion model""" """Initialize command-line parsers and the diffusion model"""
arg_parser = create_argv_parser() arg_parser = create_argv_parser()
@ -67,52 +68,22 @@ def main():
if opt.infile: if opt.infile:
try: try:
if os.path.isfile(opt.infile): if os.path.isfile(opt.infile):
infile = open(opt.infile,'r') infile = open(opt.infile, 'r')
elif opt.infile=='-': # stdin elif opt.infile == '-': # stdin
infile = sys.stdin infile = sys.stdin
else: else:
raise FileNotFoundError(f'{opt.infile} not found.') raise FileNotFoundError(f'{opt.infile} not found.')
except (FileNotFoundError,IOError) as e: except (FileNotFoundError, IOError) as e:
print(f'{e}. Aborting.') print(f'{e}. Aborting.')
sys.exit(-1) sys.exit(-1)
# preload the model # preload the model
t2i.load_model() t2i.load_model()
# load GFPGAN if requested if not infile:
if opt.use_gfpgan: print(
print('\n* --gfpgan was specified, loading gfpgan...') "\n* Initialization done! Awaiting your command (-h for help, 'q' to quit)"
with warnings.catch_warnings(): )
warnings.filterwarnings('ignore', category=DeprecationWarning)
try:
model_path = os.path.join(
opt.gfpgan_dir, opt.gfpgan_model_path
)
if not os.path.isfile(model_path):
raise Exception(
'GFPGAN model not found at path ' + model_path
)
sys.path.append(os.path.abspath(opt.gfpgan_dir))
from gfpgan import GFPGANer
bg_upsampler = load_gfpgan_bg_upsampler(
opt.gfpgan_bg_upsampler, opt.gfpgan_bg_tile
)
t2i.gfpgan = GFPGANer(
model_path=model_path,
upscale=opt.gfpgan_upscale,
arch='clean',
channel_multiplier=2,
bg_upsampler=bg_upsampler,
)
except Exception:
import traceback
print('Error loading GFPGAN:', file=sys.stderr)
print(traceback.format_exc(), file=sys.stderr)
log_path = os.path.join(opt.outdir, 'dream_log.txt') log_path = os.path.join(opt.outdir, 'dream_log.txt')
with open(log_path, 'a') as log: with open(log_path, 'a') as log:
@ -237,9 +208,10 @@ def main_loop(t2i, outdir, parser, log_path, infile):
print('goodbye!') print('goodbye!')
def get_next_command(infile=None) -> 'command string': def get_next_command(infile=None) -> 'command string':
if infile is None: if infile is None:
command = input("dream> ") command = input('dream> ')
else: else:
command = infile.readline() command = infile.readline()
if not command: if not command:
@ -269,78 +241,13 @@ def dream_server_loop(t2i):
dream_server.server_close() dream_server.server_close()
def load_gfpgan_bg_upsampler(bg_upsampler, bg_tile=400):
import torch
if bg_upsampler == 'realesrgan':
if not torch.cuda.is_available(): # CPU
import warnings
warnings.warn(
'The unoptimized RealESRGAN is slow on CPU. We do not use it. '
'If you really want to use it, please modify the corresponding codes.'
)
bg_upsampler = None
else:
from basicsr.archs.rrdbnet_arch import RRDBNet
from realesrgan import RealESRGANer
model = RRDBNet(
num_in_ch=3,
num_out_ch=3,
num_feat=64,
num_block=23,
num_grow_ch=32,
scale=2,
)
bg_upsampler = RealESRGANer(
scale=2,
model_path='https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.1/RealESRGAN_x2plus.pth',
model=model,
tile=bg_tile,
tile_pad=10,
pre_pad=0,
half=True,
) # need to set False in CPU mode
else:
bg_upsampler = None
return bg_upsampler
# variant generation is going to be superseded by a generalized
# "prompt-morph" functionality
# def generate_variants(t2i,outdir,opt,previous_gens):
# variants = []
# print(f"Generating {opt.variants} variant(s)...")
# newopt = copy.deepcopy(opt)
# newopt.iterations = 1
# newopt.variants = None
# for r in previous_gens:
# newopt.init_img = r[0]
# prompt = PromptFormatter(t2i,newopt).normalize_prompt()
# print(f"] generating variant for {newopt.init_img}")
# for j in range(0,opt.variants):
# try:
# file_writer = PngWriter(outdir,prompt,newopt.batch_size)
# callback = file_writer.write_image
# t2i.prompt2image(image_callback=callback,**vars(newopt))
# results = file_writer.files_written
# variants.append([prompt,results])
# except AssertionError as e:
# print(e)
# continue
# print(f'{opt.variants} variants generated')
# return variants
### the t2i variable doesn't seem to be necessary here. maybe remove it? ### the t2i variable doesn't seem to be necessary here. maybe remove it?
def write_log_message(t2i, prompt, results, log_path): def write_log_message(t2i, prompt, results, log_path):
"""logs the name of the output image, its prompt and seed to the terminal, log file, and a Dream text chunk in the PNG metadata""" """logs the name of the output image, its prompt and seed to the terminal, log file, and a Dream text chunk in the PNG metadata"""
log_lines = [f"{r[0]}: {prompt} -S{r[1]}\n" for r in results] log_lines = [f'{r[0]}: {prompt} -S{r[1]}\n' for r in results]
print(*log_lines, sep="") print(*log_lines, sep='')
with open(log_path, "a") as file: with open(log_path, 'a') as file:
file.writelines(log_lines) file.writelines(log_lines)
@ -413,18 +320,6 @@ def create_argv_parser():
help='device to run stable diffusion on. defaults to cuda `torch.cuda.current_device()` if avalible', help='device to run stable diffusion on. defaults to cuda `torch.cuda.current_device()` if avalible',
) )
# GFPGAN related args # GFPGAN related args
parser.add_argument(
'--gfpgan',
dest='use_gfpgan',
action='store_true',
help='load gfpgan for use in the dreambot. Note: Enabling GFPGAN will require more GPU memory',
)
parser.add_argument(
'--gfpgan_upscale',
type=int,
default=2,
help='The final upsampling scale of the image. Default: 2. Only used if --gfpgan is specified',
)
parser.add_argument( parser.add_argument(
'--gfpgan_bg_upsampler', '--gfpgan_bg_upsampler',
type=str, type=str,
@ -529,10 +424,24 @@ def create_cmd_parser():
parser.add_argument( parser.add_argument(
'-G', '-G',
'--gfpgan_strength', '--gfpgan_strength',
default=None, default=0,
type=float, type=float,
help='The strength at which to apply the GFPGAN model to the result, in order to improve faces.', help='The strength at which to apply the GFPGAN model to the result, in order to improve faces.',
) )
parser.add_argument(
'-U',
'--upscale',
nargs=2,
default=None,
type=float,
help='Scale factor for Real-ESRGAN. Either use 2 or 4.',
)
parser.add_argument(
'-save_orig',
'--save_original',
action='store_true',
help='Save original. Use it when upscaling to save both versions.',
)
# variants is going to be superseded by a generalized "prompt-morph" function # variants is going to be superseded by a generalized "prompt-morph" function
# parser.add_argument('-v','--variants',type=int,help="in img2img mode, the first generated image will get passed back to img2img to generate the requested number of variants") # parser.add_argument('-v','--variants',type=int,help="in img2img mode, the first generated image will get passed back to img2img to generate the requested number of variants")
parser.add_argument( parser.add_argument(

20
scripts/preload_models.py
View File

@ -3,6 +3,9 @@
# Before running stable-diffusion on an internet-isolated machine, # Before running stable-diffusion on an internet-isolated machine,
# run this script from one with internet connectivity. The # run this script from one with internet connectivity. The
# two machines must share a common .cache directory. # two machines must share a common .cache directory.
from transformers import CLIPTokenizer, CLIPTextModel
import clip
from transformers import BertTokenizerFast
import sys import sys
import transformers import transformers
import os import os
@ -12,7 +15,6 @@ transformers.logging.set_verbosity_error()
# this will preload the Bert tokenizer fles # this will preload the Bert tokenizer fles
print('preloading bert tokenizer...') print('preloading bert tokenizer...')
from transformers import BertTokenizerFast
tokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased') tokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased')
print('...success') print('...success')
@ -28,8 +30,6 @@ version = 'openai/clip-vit-large-patch14'
print('preloading CLIP model (Ignore the deprecation warnings)...') print('preloading CLIP model (Ignore the deprecation warnings)...')
sys.stdout.flush() sys.stdout.flush()
import clip
from transformers import CLIPTokenizer, CLIPTextModel
tokenizer = CLIPTokenizer.from_pretrained(version) tokenizer = CLIPTokenizer.from_pretrained(version)
transformer = CLIPTextModel.from_pretrained(version) transformer = CLIPTextModel.from_pretrained(version)
@ -63,6 +63,20 @@ if gfpgan:
scale=2, scale=2,
), ),
) )
RealESRGANer(
scale=4,
model_path='https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth',
model=RRDBNet(
num_in_ch=3,
num_out_ch=3,
num_feat=64,
num_block=23,
num_grow_ch=32,
scale=4,
),
)
FaceRestoreHelper(1, det_model='retinaface_resnet50') FaceRestoreHelper(1, det_model='retinaface_resnet50')
print('...success') print('...success')
except Exception: except Exception: