Merge branch 'dev' into efficient-vae-methods

import tqdm

from einops import rearrange, repeat

from ldm.util import default

from modules import devices, processing, sd_models, shared, sd_samplers, hashes, sd_hijack_checkpoint, errors

from modules import devices, sd_models, shared, sd_samplers, hashes, sd_hijack_checkpoint, errors

from modules.textual_inversion import textual_inversion, logging

from modules.textual_inversion.learn_schedule import LearnRateScheduler

from torch import einsum

def train_hypernetwork(id_task, hypernetwork_name, learn_rate, batch_size, gradient_step, data_root, log_directory, training_width, training_height, varsize, steps, clip_grad_mode, clip_grad_value, shuffle_tags, tag_drop_out, latent_sampling_method, use_weight, create_image_every, save_hypernetwork_every, template_filename, preview_from_txt2img, preview_prompt, preview_negative_prompt, preview_steps, preview_sampler_index, preview_cfg_scale, preview_seed, preview_width, preview_height):

    # images allows training previews to have infotext. Importing it at the top causes a circular import problem.

    from modules import images

    from modules import images, processing

    save_hypernetwork_every = save_hypernetwork_every or 0

    create_image_every = create_image_every or 0

from einops import repeat, rearrange

from blendmodes.blend import blendLayers, BlendType

decode_first_stage = sd_samplers_common.decode_first_stage

# some of those options should not be changed at all because they would break the model, so I removed them from options.

opt_C = 4

    return samples

def decode_first_stage(model, x):

    from modules.sd_samplers_common import samples_to_images_tensor, approximation_indexes

    x = x.to(devices.dtype_vae)

    approx_index = approximation_indexes.get(opts.sd_vae_decode_method, 0)

    return samples_to_images_tensor(x, approx_index, model)

def get_fixed_seed(seed):

    if seed is None or seed == '' or seed == -1:

        return int(random.randrange(4294967294))

from torch.nn.functional import silu

from types import MethodType

import modules.textual_inversion.textual_inversion

from modules import devices, sd_hijack_optimizations, shared, script_callbacks, errors, sd_unet

from modules.hypernetworks import hypernetwork

from modules.shared import cmd_opts

    clip = None

    optimization_method = None

    embedding_db = modules.textual_inversion.textual_inversion.EmbeddingDatabase()

    def __init__(self):

        import modules.textual_inversion.textual_inversion

        self.extra_generation_params = {}

        self.comments = []

        self.embedding_db = modules.textual_inversion.textual_inversion.EmbeddingDatabase()

        self.embedding_db.add_embedding_dir(cmd_opts.embeddings_dir)

    def apply_optimizations(self, option=None):

    return Image.fromarray(x_sample)

def decode_first_stage(model, x):

    x = model.decode_first_stage(x.to(devices.dtype_vae))

    return x

def sample_to_image(samples, index=0, approximation=None):

    return single_sample_to_image(samples[index], approximation)

def refresh_vae_list():

    global vae_dict

    vae_dict.clear()

    paths = [

        name = get_filename(filepath)

        vae_dict[name] = filepath

    vae_dict = dict(sorted(vae_dict.items(), key=lambda item: shared.natural_sort_key(item[0])))

def find_vae_near_checkpoint(checkpoint_file):

    checkpoint_path = os.path.basename(checkpoint_file).rsplit('.', 1)[0]