How to switch the model in the api?

[Funny-dot]

How to switch the model in the api? For example, sdapi/v1/txt2img

[vladmandic]

something like

opt = get('/sdapi/v1/options')
opt['sd_model_checkpoint'] = 'model name'
post('/sdapi/v1/options', opt)

[Funny-dot]

Global or individual?

[vladmandic]

there is no individual - only one model can be active at the time in webui in general.
you can enable multiple models to be cached in memory so switching is much faster than loading from disk, but thats about it.

[timlenardo]

For other lazy people out there, in Python (using requests) this is:

url = "http://127.0.0.1:7860" # or your URL
opt = requests.get(url=f'{url}/sdapi/v1/options')
opt_json = opt.json()
opt_json['sd_model_checkpoint'] = '<MODEL_NAME>'
requests.post(url=f'{url}/sdapi/v1/options', json=opt_json)

You can also sanity check which models are available with:

response = requests.get(url=f'{url}/sdapi/v1/sd-models', json=payload)
print(response.json())

[eugenecooper]

Your suggestion works great to update the config.
However, even though the config is updated, for some reason the backend doesn't apply the changes (doesn't change the current model).
Maybe some additional API call is required in order to apply the changes...

I tried calling "unload-checkpoint" and "reload-checkpoint" endpoints after the options call, but it doesn't do anything good. Instead it actually reverts "sd_model_checkpoint" to a previous value

[timlenardo]

I had the same issue at first, but then realized I was sending a GET request to make the update instead of a POST request. When I changed the request to POST, the changes take effect as intended.

[MNeMoNiCuZ]

How do I switch model without using the API?
I'm working on an extension with python, and I can't figure out how to trigger the switch to another model, so that when I generate the next image using processing.StableDiffusionProcessingTxt2Img, I use the target model.

Here's what I have in my processing, but the sd_model and override_settings both seem to be wrong for this usecase:

        # Set up processing parameters
        p = processing.StableDiffusionProcessingTxt2Img(
            sd_model=model_name,
            outpath_samples="outputs/txt2img-images",
            outpath_grids="outputs/txt2img-grids",
            prompt=set_data.get("prompt", "Default Prompt"),
            negative_prompt=set_data.get("negativePrompt", ""),
            steps=int(set_data.get("steps", 25)),
            cfg_scale=float(set_data.get("cfgScale", 6.0)),
            sampler_name=set_data.get("sampler", "Default Sampler"),
            width=int(set_data.get("width", 420)),
            height=int(set_data.get("height", 640)),
            seed=int(set_data.get("seed", -1)),
            override_settings={"sd_model_checkpoint": model_name}
        )

[vladmandic]

from modules.shared import opts
opts.sd_model_checkpoint = 'name'

it will trigger the model load and is equivalent as changing via ui or via api - its all the same thing.

[MNeMoNiCuZ]

Thanks for the help @vladmandic

I seem to be unable to figure out how to use it, I can't figure out the expected format of the model.
I've tried with just the file name, with absolute file paths, and with paths relative from the 'Models/Stable-diffusion' folder.

I've also tried hard-coding the path to the file in all ways I can think of, and I've tried converting it to str() and path().

Do you have an example of it being used or do you know what input it needs?

Not quite sure what to try next with this one.

[vladmandic]

its a name, as it appears in ui.
you cannot trigger loading of safetensors file directly - if you want that, you need to place it in folder, then trigger refresh list and then load by name as i wrote.

[MNeMoNiCuZ]

Sorry I don't understand what you mean.
I'm trying to load a checkpoint which is not loaded currently, to be able to batch-generate the same prompt using multiple checkpoints. Just like how it's done in the XYZ-script when you choose the "Checkpoint name" and select a bunch of checkpoints in the list.

When I use opts.sd_model_checkpoint = str(my_model_name_ext) as you suggested, I end up with this output:

Checkpoint C:\AI\stable-diffusion-webui\models\Stable-diffusion\Checkpoints\01 - Photorealistic\absolutereality_v16.safetensors not found; loading fallback diffusion_pytorch_model.safetensors [a1d9934885]

The system is telling me that the file fails to be found, but it definitely exists at this path. Do you know why it's reporting that it's failing?

In sd_models.py theres a select_checkpoint(): function, which has this in it:

    checkpoint_info = checkpoint_aliases.get(model_checkpoint, None)
    if checkpoint_info is not None:
        return checkpoint_info

This if is failing, and I can't figure out why it fails.

Solved in the next message

[MNeMoNiCuZ]

Okay, I got it working now.

The opts.sd_model_checkpoint = 'name' wasn't what was needed for me.
Instead it was the path in the override_settings in processing.StableDiffusionProcessingTxt2Img().

    try:
        # Set up processing parameters
        p = processing.StableDiffusionProcessingTxt2Img(
            sd_model=shared.sd_model,
            outpath_samples="outputs/txt2img-images",
            outpath_grids="outputs/txt2img-grids",
            prompt=set_data.get("prompt", "Default Prompt"),
            negative_prompt=set_data.get("negativePrompt", ""),
            steps=int(set_data.get("steps", 25)),
            cfg_scale=float(set_data.get("cfgScale", 6.0)),
            sampler_name=set_data.get("sampler", "Default Sampler"),
            width=int(set_data.get("width", 420)),
            height=int(set_data.get("height", 640)),
            seed=int(set_data.get("seed", -1)),
            override_settings={"sd_model_checkpoint": model_path}
        )

override_settings={"sd_model_checkpoint": model_path}
This needed to be the relative path to the model, from the checkpoint directory (/models/Stable-diffusion) as the root level.

If the model is in the checkpoint directory, it just needs the model-name (model.safetensors).
If the model is in a subfolder, like I was using: C:\AI\stable-diffusion-webui\models\Stable-diffusion\Checkpoints\Checkpoints\01 - Photorealistic\model.safetensors, it needed to use relative paths (Checkpoints\Checkpoints\01 - Photorealistic\model.safetensors).

In case anyone is helped by the full code for it, here it is.

def generate_thumbnail_for_model(model_name, suffix, model_path, full_model_path):
    ckpt_dir = shared.cmd_opts.ckpt_dir or sd_models.model_path

    # Initialize processed to None
    processed = None

    # Get set data
    set_data = get_set_data(current_set_name)

    try:
        # Set up processing parameters
        p = processing.StableDiffusionProcessingTxt2Img(
            sd_model=shared.sd_model,
            outpath_samples="outputs/txt2img-images",
            outpath_grids="outputs/txt2img-grids",
            prompt=set_data.get("prompt", "Default Prompt"),
            negative_prompt=set_data.get("negativePrompt", ""),
            steps=int(set_data.get("steps", 25)),
            cfg_scale=float(set_data.get("cfgScale", 6.0)),
            sampler_name=set_data.get("sampler", "Default Sampler"),
            width=int(set_data.get("width", 420)),
            height=int(set_data.get("height", 640)),
            seed=int(set_data.get("seed", -1)),
            override_settings={"sd_model_checkpoint": model_path}
        )

        # Perform necessary pre-processing or initialization
        p.init(["Empty Prompt"],[-1],[-1])

        # Print model info
        print (f"\nModel:{model_name}\nRelative Path:{model_path}\nFull Path:{full_model_path}.\n")

        # Printing instructions
        print(f"Retrieved set data for '{current_set_name}': {set_data}\n")
        
        # Process the image
        with closing(p):
            if processed is None:
                processed = processing.process_images(p)

        # Ensure that images were generated
        if not processed or not processed.images:
            raise ValueError("No images were generated.")

        # Extract the first image
        image = processed.images[0]

        # Ensure the image is a PIL Image
        if not isinstance(image, Image.Image):
            raise TypeError("The generated image is not a PIL Image.")

        # Find the full path of the model
        model_full_path = next((path for path in relevant_model_paths if Path(path).stem == Path(model_name).stem), None)
        if model_full_path is None:
            raise FileNotFoundError(f"Model file for {model_name} not found or is blocklisted.")
        
        # Use the model's directory to save the thumbnail
        model_directory = Path(ckpt_dir) / Path(model_full_path).parent
        suffix_str = f".{suffix}" if suffix and not suffix.startswith(".") else suffix
        output_filename = f"{Path(model_name).stem}{suffix_str}.png"
        output_path = model_directory / output_filename

        # Create the output directory if it doesn't exist
        model_directory.mkdir(parents=True, exist_ok=True)

        image.save(output_path)
        print(f"Thumbnail generated and saved as {output_path}")

    except Exception as e:
        print(f"Error in generating thumbnail for {model_name}: {e}")
        traceback.print_exc()

You can ignore the set_data, and replace the generation properties in the list with your values manually. This is just the settings being kept in a JSON so I can switch between sets of parameters.
You don't actually need the model_name and full_model_path.
The suffix is just for me saving the images with a specific name suffix.
The ckpt_dir is only for saving images in the model-folders as thumbnails.
If you want the built-in image saving, you can just use the outpath_samples folder for your normal image generation outputs.