NVidia GPU Stable Diffusion Install and Run Web UI

Automatic NVidia GPU Stable Diffusion Install Guide for Windows with NVidia GPU.

If you’re a Windows 10/11 user with an NVidia GPU, setting up the Stable Diffusion UI Online can be done with just a few simple steps:

1. Download: Start by downloading the sd.webui.zip file from this link. Once downloaded, extract the contents of the zip file.
2. Update: Double-click on the update.bat script to update the Stable Diffusion UI Online to the latest version. Wait for the update process to finish, then close the window.
3. Launch: Double-click on the run.bat script to launch the Stable Diffusion UI Online. The first time you launch the UI, it will download a large amount of data. Once everything has been downloaded and installed, you should see a message stating “Running on local URL: http://127.0.0.1:7860”.
4. Generate Images: Open the provided link in your browser to access the Stable Diffusion UI Online interface, and you should be ready to start generating images!

Please note that you should download the sd.webui.zip file from the v1.0.0-pre-release. Despite the older version number, these instructions are up-to-date.

With these straightforward steps, you can have the NVidia GPU Stable Diffusion Install UI Online set up and ready to go on your Windows system in no time.

Customizing the Stable Diffusion UI Online with COMMANDLINE_ARGS:

The Stable Diffusion UI Online offers a range of configuration options that you can customize to your liking. These options can be set through the COMMANDLINE_ARGS launch script.

To configure these options:

1. Navigate to the sd.webui\webui directory and open the webui-user.bat file.
2. Find the line that starts with set COMMANDLINE_ARGS=.
3. After the equals sign, add the arguments you want to apply. Each argument should be separated by a space.

For example: set COMMANDLINE_ARGS=--autolaunch --update-check

In the above example, the --autolaunch argument configures the Stable Diffusion UI Online to automatically launch the browser page after it finishes loading. The --update-check argument enables the UI to check for new versions upon launch.

By customizing these settings, you can tailor the behaviour of the NVidia GPU Stable Diffusion Install Online to better suit your needs.

Troubleshooting the NVidia GPU Stable Diffusion Install

While the default configuration of the NVidia GPU Stable Diffusion Install should work smoothly on most modern GPUs, there may be instances where you encounter issues. If you’re having trouble, here are some troubleshooting steps you can take:

Insufficient VRAM:

If your GPU has a lower amount of VRAM, you might need to use the --medvram or --lowvram arguments. These optimizations reduce VRAM requirements at the cost of performance.

If you don’t have enough VRAM, the Stable Diffusion UI Online may refuse to launch or fail to generate images due to an out-of-memory error. The VRAM required largely depends on the desired image resolution. The Tiled VAE extension can also help to reduce the VRAM requirement.

Black or Green Images:

If the images you’re generating are coming out black or green, try adding the --precision full and --no-half arguments.

NansException:

Some combinations of models and VAEs can produce a NansException, which results in a black image. If you encounter this issue, using the --no-half-vae option may help.

Remember to add these arguments to the COMMANDLINE_ARGS in the webui-user.bat file, as explained in the previous section.

By following these troubleshooting steps, you should be able to resolve common issues and get the NVidia GPU Stable Diffusion Install UI Online running smoothly on your system.

Exploring Extra Options for the Online Web GUI NVidia GPU Stable Diffusion Install:

The NVidia GPU Stable Diffusion Install offers a range of additional options that can enhance your user experience and optimize performance:

Cross-Attenuation Optimization Methods: There are several methods such as --xformers or --opt-sdp-attention that can drastically increase performance. You can find more details in the Optimizations section. It’s worthwhile to experiment with different options as different hardware may be better suited for different optimizations.

Benchmarking: If you wish to measure your system’s performance, consider using the sd-extension-system-info extension. This extension features a benchmarking tool and a database of user-submitted results.

Automatic Launch: If you want the web browser to launch automatically after the Stable Diffusion GUI Online powered by NVidia has started up, add --autolaunch to your command line arguments.

Update Check: To be notified when there’s a new version of the Stable Diffusion Online, add --update-check to your command line arguments.

For more configuration options, you can refer to the Command Line Arguments and Settings sections. These extra options provide greater control over your experience with the Stable Diffusion GUI Online and can help optimize its performance on your hardware.

Handy Tip for Existing Stable Diffusion Users:

If you have already downloaded Stable Diffusion models, you can streamline the setup process for the Stable Diffusion UI Online. Simply move the models into the sd.webui\webui\models\Stable-diffusion\ directory before running the run.bat script in step 3 of the setup process.

By doing this, the system will recognize the existing models and skip the automatic download of the vanilla stable-diffusion-v1-5 model. This can save you some time and get you up and running with the Stable Diffusion UI Online even faster.

Alternative Installation Method for Windows:

If you prefer to use the command line for installation, here’s an alternative method to get the Stable Diffusion UI Online up and running on Windows:

1. Install Python and Git: Download and install Python 3.10.6, making sure to tick the ‘Add to PATH’ option during installation. Also, download and install Git.
2. Clone the Repository: Open Command Prompt from your computer’s search bar, and type git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui. This command will clone the repository for the Stable Diffusion UI Online onto your computer.
3. Run the Batch File: Navigate to the directory where the repository was cloned, and double-click on webui-user.bat. This will launch the Stable Diffusion UI Online.

By following these steps, you can have the NVidia GPU Stable Diffusion Install set up and ready to go on your Windows system, using only the command line.

Installation Video Assistance

In case you encounter any issues during the installation process or prefer a visual guide, there’s a handy installation video available. This step-by-step video tutorial will walk you through the entire installation process, ensuring you can smoothly set up the NVidia GPU Stable Diffusion Install on your system.

Remember, assistance is always available if you need it. Don’t hesitate to refer to the video or ask for help if you get stuck during installation.

Alternative Launch Scripts using PowerShell:

For those who prefer using PowerShell over the Command Prompt or Batch files, the NVidia GPU Stable Diffusion Install also provides alternative PowerShell launch scripts.

if ($env:PYTHON -eq "" -or $env:PYTHON -eq $null) {
    $PYTHON = "Python.exe"
} else {
    $PYTHON = $env:PYTHON
}

if ($env:VENV_DIR -eq "" -or $env:VENV_DIR -eq $null) {
    $VENV_DIR = "$PSScriptRoot\venv"
} else {
    $VENV_DIR = $env:VENV_DIR
}

if ($env:LAUNCH_SCRIPT -eq "" -or $env:LAUNCH_SCRIPT -eq $null) {
    $LAUNCH_SCRIPT = "$PSScriptRoot\launch.py"
} else {
    $LAUNCH_SCRIPT = $env:LAUNCH_SCRIPT
}

$ERROR_REPORTING = $false

mkdir tmp 2>$null

function Start-Venv {
    if ($VENV_DIR -eq '-') {
        Skip-Venv
    }

    if (Test-Path -Path "$VENV_DIR\Scripts\$python") {
        Activate-Venv
    } else {
        $PYTHON_FULLNAME = & $PYTHON -c "import sys; print(sys.executable)"
        Write-Output "Creating venv in directory $VENV_DIR using python $PYTHON_FULLNAME"
        Invoke-Expression "$PYTHON_FULLNAME -m venv $VENV_DIR > tmp/stdout.txt 2> tmp/stderr.txt"
        if ($LASTEXITCODE -eq 0) {
            Activate-Venv
        } else {
            Write-Output "Unable to create venv in directory $VENV_DIR"
        }
    }
}

function Activate-Venv {
    $PYTHON = "$VENV_DIR\Scripts\Python.exe"
    $ACTIVATE = "$VENV_DIR\Scripts\activate.bat"
    Invoke-Expression "cmd.exe /c $ACTIVATE"
    Write-Output "Venv set to $VENV_DIR."
    if ($ACCELERATE -eq 'True') {
        Check-Accelerate
    } else {
        Launch-App
    }
}

function Skip-Venv {
    Write-Output "Venv set to $VENV_DIR."
    if ($ACCELERATE -eq 'True') {
        Check-Accelerate
    } else {
        Launch-App
    }
}

function Check-Accelerate {
    Write-Output 'Checking for accelerate'
    $ACCELERATE = "$VENV_DIR\Scripts\accelerate.exe"
    if (Test-Path -Path $ACCELERATE) {
        Accelerate-Launch
    } else {
        Launch-App
    }
}

function Launch-App {
    Write-Output "Launching with python"
    Invoke-Expression "$PYTHON $LAUNCH_SCRIPT"
    #pause
    exit
}

function Accelerate-Launch {
    Write-Output 'Accelerating'
    Invoke-Expression "$ACCELERATE launch --num_cpu_threads_per_process=6 $LAUNCH_SCRIPT"
    #pause
    exit
}


try {
    if(Get-Command $PYTHON){
        Start-Venv
    }
} Catch {
    Write-Output "Couldn't launch python."
}

By using these PowerShell scripts, you can easily launch the Stable Diffusion UI Online in an environment you are comfortable with. Remember, the goal is to make the AI image generation process as seamless and user-friendly as possible, and that includes offering a variety of options for launching the application.

If you prefer using PowerShell, there’s a script named webui-user.ps1 available for launching the Stable Diffusion UI Online. Here’s how you can use it:

1. Navigate to the directory where you cloned the repository.
2. Find the webui-user.ps1 script.
3. Right-click on the script and select ‘Run with PowerShell’.

[Environment]::SetEnvironmentVariable("PYTHON", "")
[Environment]::SetEnvironmentVariable("GIT", "")
[Environment]::SetEnvironmentVariable("VENV_DIR","")

# Commandline arguments for webui.py, for example: [Environment]::SetEnvironmentVariable("COMMANDLINE_ARGS", "--medvram --opt-split-attention")
[Environment]::SetEnvironmentVariable("COMMANDLINE_ARGS", "")

# script to launch to start the app
# [Environment]::SetEnvironmentVariable("LAUNCH_SCRIPT", "launch.py")

# install command for torch
# [Environment]::SetEnvironmentVariable("TORCH_COMMAND", "pip install torch==1.12.1+cu113 torchvision==0.13.1+cu113 --extra-index-url https://download.pytorch.org/whl/cu113")

# Requirements file to use for stable-diffusion-webui
# [Environment]::SetEnvironmentVariable("REQS_FILE", "requirements_versions.txt")

# [Environment]::SetEnvironmentVariable("GFPGAN_PACKAGE", "")
# [Environment]::SetEnvironmentVariable("CLIP_PACKAGE", "")
# [Environment]::SetEnvironmentVariable("OPENCLIP_PACKAGE", "")

# URL to a WHL if you wish to override default xformers windows
# [Environment]::SetEnvironmentVariable("XFORMERS_WINDOWS_PACKAGE", "")

# Uncomment and set to enable an alternate repository URL
# [Environment]::SetEnvironmentVariable("STABLE_DIFFUSION_REPO", "")
# [Environment]::SetEnvironmentVariable("TAMING_TRANSFORMERS_REPO", "")
# [Environment]::SetEnvironmentVariable("K_DIFFUSION_REPO", "")
# [Environment]::SetEnvironmentVariable("CODEFORMER_REPO", "")
# [Environment]::SetEnvironmentVariable("BLIP_REPO", "")

# Uncomment and set to enable a specific revision of a repository
# [Environment]::SetEnvironmentVariable("STABLE_DIFFUSION_COMMIT_HASH", "")
# [Environment]::SetEnvironmentVariable("TAMING_TRANSFORMERS_COMMIT_HASH", "")
# [Environment]::SetEnvironmentVariable("K_DIFFUSION_COMMIT_HASH", "")
# [Environment]::SetEnvironmentVariable("CODEFORMER_COMMIT_HASH", "")
# [Environment]::SetEnvironmentVariable("BLIP_COMMIT_HASH", "")


# Uncomment to enable accelerated launch
# [Environment]::SetEnvironmentVariable("ACCELERATE", "True")

$SCRIPT = "$PSScriptRoot\webui.ps1"
Invoke-Expression "$SCRIPT"

This should launch the Stable Diffusion UI Online in your default web browser. By using this PowerShell script, you can run the application in an environment that you’re comfortable with.

Troubleshooting Support:

If you encounter any issues while setting up or using the Stable Diffusion UI Online, do not worry. There’s a comprehensive Troubleshooting section available to help you resolve any problems.

Installing and Running Stable Diffusion UI Online on Linux:

If you’re a Linux user, the process of setting up the Stable Diffusion UI Online is slightly different from that of Windows. The steps specific to Linux will be provided below.

Installation on Debian-based Linux Systems:

If you’re using a Debian-based Linux distribution (like Ubuntu), you can install the Stable Diffusion UI Online in your current directory using a set of specific commands.

sudo apt install git python3.10-venv -y
git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui && cd stable-diffusion-webui
python3.10 -m venv venv

Once you’ve installed the Stable Diffusion UI Online on your Debian-based Linux system, you can run it using the following command in your terminal:

bashCopy code./webui.sh {your_arguments}

Replace {your_arguments} with any command-line arguments you want to pass to the application. For example, if you want to check for updates at startup, you would use:

bashCopy code./webui.sh --update-check

By using this command, you’ll launch the Stable Diffusion UI Online with your specified settings, ready to start generating images.

Installation on Arch-based Linux Systems:

If you’re using an Arch-based Linux distribution, the process for installing the Stable Diffusion UI Online can be slightly different.

sudo pacman -S git python3 -y && git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui && cd stable-diffusion-webui && ./webui.sh

By following these instructions, you can set up the Stable Diffusion UI Online in your current directory and start generating images on your Arch-based Linux system.

Installation on Red Hat-based Linux Systems:

For users operating a Red Hat-based Linux distribution, the installation procedure for the Stable Diffusion UI Online may differ slightly.

sudo dnf install git python3 -y && git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui && cd stable-diffusion-webui && ./webui.sh

By adhering to these guidelines, you’ll be able to install the Stable Diffusion UI Online in your current directory and commence generating images on your Red Hat-based Linux system.

Installing Python 3.10 on Linux Systems:

On some Linux distributions, the system’s default Python version may be older or newer than Python 3.10. If you need to install Python 3.10, you can do so using the pyenv version management tool. Here’s how:

1. Navigate to the stable-diffusion-webui directory with the command: cd stable-diffusion-webui
2. Install pyenv with the command: sudo pacman -S pyenv (this is for Arch-based systems; use the appropriate package manager command for your distribution)
3. Install Python 3.10.6 with pyenv using the command: pyenv install 3.10.6
4. Set Python 3.10.6 as the local version for your current directory with the command: pyenv local 3.10.6
5. Finally, create a new virtual environment using the installed version of Python with the command: python -m venv

By following these steps, you can install Python 3.10.6 on your Linux system, allowing you to run the Stable Diffusion UI Online.

Running the Stable Diffusion UI Online without a Virtual Environment:

If you prefer not to use a virtual environment, you can install the required packages directly via pip and run the Stable Diffusion UI Online. Here’s how you can do it:

1. Install the necessary packages with the command: python launch.py
2. If you want to pass command-line arguments directly, you can do so by including them after the script name. For example, if you want to use the --opt-split-attention option and specify a checkpoint file, you would use the following command: python launch.py --opt-split-attention --ckpt ../secret/anime9999.ckpt

By running these commands, you can launch the Stable Diffusion UI Online with your specified settings without the need for a virtual environment.

Manual Installation of Stable Diffusion UI Online:

While manual installation of the Stable Diffusion UI Online is possible, please note that the process is quite outdated and may not work as expected. If you’re looking for a more reliable installation method, I would recommend using the Colab instructions provided in the repository’s README file.

However, if you still wish to proceed with the manual installation, the following process can be applied to both Windows and Linux systems (for Linux, replace dir with ls):

# install torch with CUDA support. See https://pytorch.org/get-started/locally/ for more instructions if this fails.
pip install torch --extra-index-url https://download.pytorch.org/whl/cu113

# check if torch supports GPU; this must output "True". You need CUDA 11. installed for this. You might be able to use
# a different version, but this is what I tested.
python -c "import torch; print(torch.cuda.is_available())"

# clone web ui and go into its directory
git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git
cd stable-diffusion-webui

# clone repositories for Stable Diffusion and (optionally) CodeFormer
mkdir repositories
git clone https://github.com/CompVis/stable-diffusion.git repositories/stable-diffusion-stability-ai
git clone https://github.com/CompVis/taming-transformers.git repositories/taming-transformers
git clone https://github.com/sczhou/CodeFormer.git repositories/CodeFormer
git clone https://github.com/salesforce/BLIP.git repositories/BLIP

# install requirements of Stable Diffusion
pip install transformers==4.19.2 diffusers invisible-watermark --prefer-binary

# install k-diffusion
pip install git+https://github.com/crowsonkb/k-diffusion.git --prefer-binary

# (optional) install GFPGAN (face restoration)
pip install git+https://github.com/TencentARC/GFPGAN.git --prefer-binary

# (optional) install requirements for CodeFormer (face restoration)
pip install -r repositories/CodeFormer/requirements.txt --prefer-binary

# install requirements of web ui
pip install -r requirements.txt  --prefer-binary

# update numpy to latest version
pip install -U numpy  --prefer-binary

# (outside of command line) put stable diffusion model into web ui directory
# the command below must output something like: 1 File(s) 4,265,380,512 bytes
dir model.ckpt

Once you’ve finished installing the Stable Diffusion UI Online, you can start the application by running the following command:

python webui.py

Remember, while manual installation gives you more control over the setup process, it’s generally more complex and prone to issues than automated methods. If you encounter problems, don’t hesitate to refer to the Troubleshooting section or seek help.

Running Stable Diffusion UI Online on Windows 11 using WSL2:

If you’re using Windows 11 and want to install the Stable Diffusion UI Online under a Linux distribution using Windows Subsystem for Linux 2 (WSL2), you can follow these steps:

# install conda (if not already done)
wget https://repo.anaconda.com/archive/Anaconda3-2022.05-Linux-x86_64.sh
chmod +x Anaconda3-2022.05-Linux-x86_64.sh
./Anaconda3-2022.05-Linux-x86_64.sh

# Clone webui repo
git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git
cd stable-diffusion-webui

# Create and activate conda env
conda env create -f environment-wsl2.yaml
conda activate automatic

After setting up your Linux distribution on Windows 11 with WSL2, you can proceed with the manual installation of Stable Diffusion UI Online. You can start applying the instructions from the step that involves cloning the repositories for Stable Diffusion and, if desired, CodeFormer.

# clone repositories for Stable Diffusion and (optionally) CodeFormer

With the power of WSL2, you can enjoy the compatibility and flexibility of Linux while still using your Windows system. By following these instructions, you can smoothly run the Stable Diffusion UI Online on your Windows 11 system using WSL2.

Alternative Installation on Windows using Conda:

If you’re a Windows user and prefer using Conda for package management, there’s an alternative installation method for the Stable Diffusion UI Online. This method assumes you have Chocolatey installed, a package manager for Windows.

# install git
choco install git
# install conda
choco install anaconda3

Optional parameters: git, conda

By using Conda, you can manage the packages and dependencies for the Stable Diffusion UI Online in an isolated environment, making it easier to maintain and troubleshoot.

(in-depth) Alternative Installation on Windows using Conda:

For those who prefer to use Conda for package management, there’s an alternative installation method for the Stable Diffusion UI Online. Please ensure you have enough space as some files are multiple gigabytes in size.

1. Download and Extract: Download the project as a .zip file and extract it or clone it using git with the following command: git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git.
2. Launch Anaconda Prompt: Note that you can use older Python versions, but you might need to manually remove features like cache optimization, which could affect performance.
3. Navigate to the git Directory: Use the command cd "GIT\StableDiffusion" to navigate to the directory where you cloned the repository.
4. Create Environment: Use the command conda create -n StableDiffusion python=3.10.6 to create a new Conda environment for the project.
5. Activate Environment: Activate the new environment with the command conda activate StableDiffusion.
6. Validate Environment: Validate that the correct environment is selected with the command conda env list.
7. Start Local Webserver: Start the local webserver by running the batch file with the command webui-user.bat. Wait for the “Running on local URL: http://127.0.0.1:7860” message and open that URI in your web browser.
8. (Optional) Download Latest Model: Go to CompVis and download the latest model (for example, 1.4), and unpack it to GIT\StableDiffusion\models\Stable-diffusion. After that, restart the server by restarting the Anaconda prompt and running webui-user.bat.

For alternative default settings, try using the Ancestral Euler method with higher Sampling Steps (for example, 40 or others with 100). Set “Settings > User interface > Show image creation progress every N sampling steps” to 1 and pick a deterministic Seed value. This allows you to visually see how image diffusion happens and record a .gif with ScreenToGif. You can also use the Restore faces option for generally better results, but note that this will slow down the process.