text stringlengths 0 1.28M |
|---|
import os import importlib.util from comfy.cli_args import args import subprocess def get_gpu_names(): if os.name == 'nt': import ctypes class DISPLAY_DEVICEA(ctypes.Structure): _fields_ = [ ('cb', ctypes.c_ulong), ('DeviceName', ctypes.c_char * 32), ('DeviceString', ctypes.c_char * 128), ('StateFlags', ctypes.c_ulong)... |
import sys import copy import logging import threading import heapq import traceback import inspect from typing import List, Literal, NamedTuple, Optional import torch import nodes import comfy.model_management def get_input_data(inputs, class_def, unique_id, outputs={}, prompt={}, extra_data={}): valid_inputs = class_... |
import os import time import logging supported_pt_extensions = set(['.ckpt', '.pt', '.bin', '.pth', '.safetensors', '.pkl']) folder_names_and_paths = {} base_path = os.path.dirname(os.path.realpath(__file__)) models_dir = os.path.join(base_path, "models") folder_names_and_paths["checkpoints"] = ([os.path.join(models_di... |
import torch from PIL import Image import struct import numpy as np from comfy.cli_args import args, LatentPreviewMethod from comfy.taesd.taesd import TAESD import comfy.model_management import folder_paths import comfy.utils import logging MAX_PREVIEW_RESOLUTION = 512 def preview_to_image(latent_image): latents_ubyte ... |
import comfy.options comfy.options.enable_args_parsing() import os import importlib.util import folder_paths import time def execute_prestartup_script(): def execute_script(script_path): module_name = os.path.splitext(script_path)[0] try: spec = importlib.util.spec_from_file_location(module_name, script_path) module = ... |
import os import shutil base_path = os.path.dirname(os.path.realpath(__file__)) def update_windows_updater(): top_path = os.path.dirname(base_path) updater_path = os.path.join(base_path, ".ci/update_windows/update.py") bat_path = os.path.join(base_path, ".ci/update_windows/update_comfyui.bat") dest_updater_path = os.pa... |
import torch import os import sys import json import hashlib import traceback import math import time import random import logging from PIL import Image, ImageOps, ImageSequence, ImageFile from PIL.PngImagePlugin import PngInfo import numpy as np import safetensors.torch sys.path.insert(0, os.path.join(os.path.dirname(... |
from PIL import ImageFile, UnidentifiedImageError def conditioning_set_values(conditioning, values={}): c = [] for t in conditioning: n = [t[0], t[1].copy()] for k in values: n[1][k] = values[k] c.append(n) return c def pillow(fn, arg): prev_value = None try: x = fn(arg) except (OSError, UnidentifiedImageError, ValueEr... |
ComfyUI ======= The most powerful and modular stable diffusion GUI and backend. -----------  This ui will let you design and execute advanced stable diffusion pipelines using a graph/nodes/flowchart based interface. For some workflow examples and see what ComfyUI can do you ... |
import os import sys import asyncio import traceback import nodes import folder_paths import execution import uuid import urllib import json import glob import struct import ssl from PIL import Image, ImageOps from PIL.PngImagePlugin import PngInfo from io import BytesIO import aiohttp from aiohttp import web import lo... |
import pygit2 from datetime import datetime import sys import os import shutil import filecmp def pull(repo, remote_name='origin', branch='master'): for remote in repo.remotes: if remote.name == remote_name: remote.fetch() remote_master_id = repo.lookup_reference('refs/remotes/origin/%s' % (branch)).target merge_result... |
name: Tests CI on: [push, pull_request] jobs: test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: actions/setup-node@v3 with: node-version: 18 - uses: actions/setup-python@v4 with: python-version: '3.10' - name: Install requirements run: | python -m pip install --upgrade pip pip install torch torchv... |
import os import json from aiohttp import web class AppSettings(): def __init__(self, user_manager): self.user_manager = user_manager def get_settings(self, request): file = self.user_manager.get_request_user_filepath( request, "comfy.settings.json") if os.path.isfile(file): with open(file) as f: return json.load(f) el... |
import json import os import re import uuid from aiohttp import web from comfy.cli_args import args from folder_paths import user_directory from .app_settings import AppSettings default_user = "default" users_file = os.path.join(user_directory, "users.json") class UserManager(): def __init__(self): global user_director... |
import pickle load = pickle.load class Empty: pass class Unpickler(pickle.Unpickler): def find_class(self, module, name): if module.startswith("pytorch_lightning"): return Empty return super().find_class(module, name) |
{ "architectures": [ "CLIPTextModel" ], "attention_dropout": 0.0, "bos_token_id": 0, "dropout": 0.0, "eos_token_id": 2, "hidden_act": "gelu", "hidden_size": 1280, "initializer_factor": 1.0, "initializer_range": 0.02, "intermediate_size": 5120, "layer_norm_eps": 1e-05, "max_position_embeddings": 77, "model_type": "clip_... |
import torch from comfy.ldm.modules.attention import optimized_attention_for_device class CLIPAttention(torch.nn.Module): def __init__(self, embed_dim, heads, dtype, device, operations): super().__init__() self.heads = heads self.q_proj = operations.Linear(embed_dim, embed_dim, bias=True, dtype=dtype, device=device) se... |
from .utils import load_torch_file, transformers_convert, state_dict_prefix_replace import os import torch import json import logging import comfy.ops import comfy.model_patcher import comfy.model_management import comfy.utils import comfy.clip_model class Output: def __getitem__(self, key): return getattr(self, key) d... |
{ "attention_dropout": 0.0, "dropout": 0.0, "hidden_act": "gelu", "hidden_size": 1664, "image_size": 224, "initializer_factor": 1.0, "initializer_range": 0.02, "intermediate_size": 8192, "layer_norm_eps": 1e-05, "model_type": "clip_vision_model", "num_attention_heads": 16, "num_channels": 3, "num_hidden_layers": 48, "p... |
{ "attention_dropout": 0.0, "dropout": 0.0, "hidden_act": "gelu", "hidden_size": 1280, "image_size": 224, "initializer_factor": 1.0, "initializer_range": 0.02, "intermediate_size": 5120, "layer_norm_eps": 1e-05, "model_type": "clip_vision_model", "num_attention_heads": 16, "num_channels": 3, "num_hidden_layers": 32, "p... |
{ "attention_dropout": 0.0, "dropout": 0.0, "hidden_act": "quick_gelu", "hidden_size": 1024, "image_size": 224, "initializer_factor": 1.0, "initializer_range": 0.02, "intermediate_size": 4096, "layer_norm_eps": 1e-05, "model_type": "clip_vision_model", "num_attention_heads": 16, "num_channels": 3, "num_hidden_layers": ... |
import argparse import enum import comfy.options class EnumAction(argparse.Action): """ Argparse action for handling Enums """ def __init__(self, **kwargs): enum_type = kwargs.pop("type", None) if enum_type is None: raise ValueError("type must be assigned an Enum when using EnumAction") if not issubclass(enum_type, enu... |
import torch import math import comfy.utils def lcm(a, b): return abs(a*b) class CONDRegular: def __init__(self, cond): self.cond = cond def _copy_with(self, cond): return self.__class__(cond) def process_cond(self, batch_size, device, **kwargs): return self._copy_with(comfy.utils.repeat_to_batch_size(self.cond, batch_... |
import torch import math import os import logging import comfy.utils import comfy.model_management import comfy.model_detection import comfy.model_patcher import comfy.ops import comfy.cldm.cldm import comfy.t2i_adapter.adapter import comfy.ldm.cascade.controlnet def broadcast_image_to(tensor, target_batch_size, batche... |
import re import torch import logging unet_conversion_map = [ ("time_embed.0.weight", "time_embedding.linear_1.weight"), ("time_embed.0.bias", "time_embedding.linear_1.bias"), ("time_embed.2.weight", "time_embedding.linear_2.weight"), ("time_embed.2.bias", "time_embedding.linear_2.bias"), ("input_blocks.0.0.weight", "c... |
import os import comfy.sd def first_file(path, filenames): for f in filenames: p = os.path.join(path, f) if os.path.exists(p): return p return None def load_diffusers(model_path, output_vae=True, output_clip=True, embedding_directory=None): diffusion_model_names = ["diffusion_pytorch_model.fp16.safetensors", "diffusion... |
import torch from torch import nn from .ldm.modules.attention import CrossAttention from inspect import isfunction import comfy.ops ops = comfy.ops.manual_cast def exists(val): return val is not None def uniq(arr): return{el: True for el in arr}.keys() def default(val, d): if exists(val): return val return d() if isfun... |
import torch class LatentFormat: scale_factor = 1.0 latent_channels = 4 latent_rgb_factors = None taesd_decoder_name = None def process_in(self, latent): return latent * self.scale_factor def process_out(self, latent): return latent / self.scale_factor class SD15(LatentFormat): def __init__(self, scale_factor=0.18215):... |
import comfy.utils import logging LORA_CLIP_MAP = { "mlp.fc1": "mlp_fc1", "mlp.fc2": "mlp_fc2", "self_attn.k_proj": "self_attn_k_proj", "self_attn.q_proj": "self_attn_q_proj", "self_attn.v_proj": "self_attn_v_proj", "self_attn.out_proj": "self_attn_out_proj", } def load_lora(lora, to_load): patch_dict = {} loaded_keys ... |
import torch import logging from comfy.ldm.modules.diffusionmodules.openaimodel import UNetModel, Timestep from comfy.ldm.cascade.stage_c import StageC from comfy.ldm.cascade.stage_b import StageB from comfy.ldm.modules.encoders.noise_aug_modules import CLIPEmbeddingNoiseAugmentation from comfy.ldm.modules.diffusionmod... |
import comfy.supported_models import comfy.supported_models_base import comfy.utils import math import logging import torch def count_blocks(state_dict_keys, prefix_string): count = 0 while True: c = False for k in state_dict_keys: if k.startswith(prefix_string.format(count)): c = True break if c == False: break count ... |
import psutil import logging from enum import Enum from comfy.cli_args import args import torch import sys import platform class VRAMState(Enum): DISABLED = 0 NO_VRAM = 1 LOW_VRAM = 2 NORMAL_VRAM = 3 HIGH_VRAM = 4 SHARED = 5 class CPUState(Enum): GPU = 0 CPU = 1 MPS = 2 vram_state = VRAMState.NORMAL_VRAM set_vram_to = ... |
import torch import copy import inspect import logging import uuid import comfy.utils import comfy.model_management from comfy.types import UnetWrapperFunction def weight_decompose(dora_scale, weight, lora_diff, alpha, strength): dora_scale = comfy.model_management.cast_to_device(dora_scale, weight.device, torch.float3... |
import torch from comfy.ldm.modules.diffusionmodules.util import make_beta_schedule import math class EPS: def calculate_input(self, sigma, noise): sigma = sigma.view(sigma.shape[:1] + (1,) * (noise.ndim - 1)) return noise / (sigma ** 2 + self.sigma_data ** 2) ** 0.5 def calculate_denoised(self, sigma, model_output, mo... |
""" This file is part of ComfyUI. Copyright (C) 2024 Stability AI This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program i... |
args_parsing = False def enable_args_parsing(enable=True): global args_parsing args_parsing = enable |
import torch import comfy.model_management import comfy.samplers import comfy.utils import numpy as np import logging def prepare_noise(latent_image, seed, noise_inds=None): """ creates random noise given a latent image and a seed. optional arg skip can be used to skip and discard x number of noise generations for a gi... |
from .k_diffusion import sampling as k_diffusion_sampling from .extra_samplers import uni_pc import torch import collections from comfy import model_management import math import logging import comfy.sampler_helpers def get_area_and_mult(conds, x_in, timestep_in): dims = tuple(x_in.shape[2:]) area = None strength = 1.0... |
import torch import comfy.model_management import comfy.conds def prepare_mask(noise_mask, shape, device): """ensures noise mask is of proper dimensions""" noise_mask = torch.nn.functional.interpolate(noise_mask.reshape((-1, 1, noise_mask.shape[-2], noise_mask.shape[-1])), size=(shape[2], shape[3]), mode="bilinear") no... |
from comfy import sd1_clip from transformers import T5TokenizerFast import comfy.t5 import os class T5BaseModel(sd1_clip.SDClipModel): def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None): textmodel_json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_config_base.json") supe... |
import torch from enum import Enum import logging from comfy import model_management from .ldm.models.autoencoder import AutoencoderKL, AutoencodingEngine from .ldm.cascade.stage_a import StageA from .ldm.cascade.stage_c_coder import StageC_coder from .ldm.audio.autoencoder import AudioOobleckVAE import yaml import com... |
import os from transformers import CLIPTokenizer import comfy.ops import torch import traceback import zipfile from . import model_management import comfy.clip_model import json import logging import numbers def gen_empty_tokens(special_tokens, length): start_token = special_tokens.get("start", None) end_token = specia... |
{ "_name_or_path": "openai/clip-vit-large-patch14", "architectures": [ "CLIPTextModel" ], "attention_dropout": 0.0, "bos_token_id": 0, "dropout": 0.0, "eos_token_id": 2, "hidden_act": "quick_gelu", "hidden_size": 768, "initializer_factor": 1.0, "initializer_range": 0.02, "intermediate_size": 3072, "layer_norm_eps": 1e-... |
from comfy import sd1_clip import os class SD2ClipHModel(sd1_clip.SDClipModel): def __init__(self, arch="ViT-H-14", device="cpu", max_length=77, freeze=True, layer="penultimate", layer_idx=None, dtype=None): if layer == "penultimate": layer="hidden" layer_idx=-2 textmodel_json_config = os.path.join(os.path.dirname(os.p... |
{ "architectures": [ "CLIPTextModel" ], "attention_dropout": 0.0, "bos_token_id": 0, "dropout": 0.0, "eos_token_id": 2, "hidden_act": "gelu", "hidden_size": 1024, "initializer_factor": 1.0, "initializer_range": 0.02, "intermediate_size": 4096, "layer_norm_eps": 1e-05, "max_position_embeddings": 77, "model_type": "clip_... |
from comfy import sd1_clip from comfy import sdxl_clip from transformers import T5TokenizerFast import comfy.t5 import torch import os import comfy.model_management import logging class T5XXLModel(sd1_clip.SDClipModel): def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None): textmodel_json_config = ... |
from comfy import sd1_clip import torch import os class SDXLClipG(sd1_clip.SDClipModel): def __init__(self, device="cpu", max_length=77, freeze=True, layer="penultimate", layer_idx=None, dtype=None): if layer == "penultimate": layer="hidden" layer_idx=-2 textmodel_json_config = os.path.join(os.path.dirname(os.path.real... |
import torch from . import model_base from . import utils from . import sd1_clip from . import sd2_clip from . import sdxl_clip from . import sd3_clip from . import sa_t5 from . import supported_models_base from . import latent_formats from . import diffusers_convert class SD15(supported_models_base.BASE): unet_config ... |
import torch from . import model_base from . import utils from . import latent_formats class ClipTarget: def __init__(self, tokenizer, clip): self.clip = clip self.tokenizer = tokenizer self.params = {} class BASE: unet_config = {} unet_extra_config = { "num_heads": -1, "num_head_channels": 64, } required_keys = {} cli... |
import torch import math from comfy.ldm.modules.attention import optimized_attention_for_device class T5LayerNorm(torch.nn.Module): def __init__(self, hidden_size, eps=1e-6, dtype=None, device=None, operations=None): super().__init__() self.weight = torch.nn.Parameter(torch.empty(hidden_size, dtype=dtype, device=device... |
{ "d_ff": 3072, "d_kv": 64, "d_model": 768, "decoder_start_token_id": 0, "dropout_rate": 0.1, "eos_token_id": 1, "dense_act_fn": "relu", "initializer_factor": 1.0, "is_encoder_decoder": true, "layer_norm_epsilon": 1e-06, "model_type": "t5", "num_decoder_layers": 12, "num_heads": 12, "num_layers": 12, "output_past": tru... |
{ "d_ff": 10240, "d_kv": 64, "d_model": 4096, "decoder_start_token_id": 0, "dropout_rate": 0.1, "eos_token_id": 1, "dense_act_fn": "gelu_pytorch_tanh", "initializer_factor": 1.0, "is_encoder_decoder": true, "layer_norm_epsilon": 1e-06, "model_type": "t5", "num_decoder_layers": 24, "num_heads": 64, "num_layers": 24, "ou... |
import torch from typing import Callable, Protocol, TypedDict, Optional, List class UnetApplyFunction(Protocol): """Function signature protocol on comfy.model_base.BaseModel.apply_model""" def __call__(self, x: torch.Tensor, t: torch.Tensor, **kwargs) -> torch.Tensor: pass class UnetApplyConds(TypedDict): """Optional c... |
import torch import math import struct import comfy.checkpoint_pickle import safetensors.torch import numpy as np from PIL import Image import logging import itertools def load_torch_file(ckpt, safe_load=False, device=None): if device is None: device = torch.device("cpu") if ckpt.lower().endswith(".safetensors"): sd = ... |
import torch import torch as th import torch.nn as nn from ..ldm.modules.diffusionmodules.util import ( zero_module, timestep_embedding, ) from ..ldm.modules.attention import SpatialTransformer from ..ldm.modules.diffusionmodules.openaimodel import UNetModel, TimestepEmbedSequential, ResBlock, Downsample from ..ldm.uti... |
import torch import torch.nn.functional as F import math from tqdm.auto import trange, tqdm class NoiseScheduleVP: def __init__( self, schedule='discrete', betas=None, alphas_cumprod=None, continuous_beta_0=0.1, continuous_beta_1=20., ): """Create a wrapper class for the forward SDE (VP type). *** Update: We support di... |
import math from scipy import integrate import torch from torch import nn import torchsde from tqdm.auto import trange, tqdm from . import utils def append_zero(x): return torch.cat([x, x.new_zeros([1])]) def get_sigmas_karras(n, sigma_min, sigma_max, rho=7., device='cpu'): """Constructs the noise schedule of Karras et... |
from contextlib import contextmanager import hashlib import math from pathlib import Path import shutil import urllib import warnings from PIL import Image import torch from torch import nn, optim from torch.utils import data def hf_datasets_augs_helper(examples, transform, image_key, mode='RGB'): """Apply passed in tr... |
import importlib import torch from torch import optim import numpy as np from inspect import isfunction from PIL import Image, ImageDraw, ImageFont def log_txt_as_img(wh, xc, size=10): b = len(xc) txts = list() for bi in range(b): txt = Image.new("RGB", wh, color="white") draw = ImageDraw.Draw(txt) font = ImageFont.tru... |
import torch from torch import nn from typing import Literal, Dict, Any import math import comfy.ops ops = comfy.ops.disable_weight_init def vae_sample(mean, scale): stdev = nn.functional.softplus(scale) + 1e-4 var = stdev * stdev logvar = torch.log(var) latents = torch.randn_like(mean) * stdev + mean kl = (mean * mean... |
from comfy.ldm.modules.attention import optimized_attention import typing as tp import torch from einops import rearrange from torch import nn from torch.nn import functional as F import math class FourierFeatures(nn.Module): def __init__(self, in_features, out_features, std=1., dtype=None, device=None): super().__init... |
import torch import torch.nn as nn from torch import Tensor, einsum from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, TypeVar, Union from einops import rearrange import math import comfy.ops class LearnedPositionalEmbedding(nn.Module): """Used for continuous time""" def __init__(self, dim: int): ... |
""" This file is part of ComfyUI. Copyright (C) 2024 Stability AI This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program i... |
""" This file is part of ComfyUI. Copyright (C) 2024 Stability AI This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program i... |
""" This file is part of ComfyUI. Copyright (C) 2024 Stability AI This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program i... |
""" This file is part of ComfyUI. Copyright (C) 2024 Stability AI This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program i... |
""" This file is part of ComfyUI. Copyright (C) 2024 Stability AI This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program i... |
""" This file is part of ComfyUI. Copyright (C) 2024 Stability AI This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program i... |
import torch from contextlib import contextmanager from typing import Any, Dict, List, Optional, Tuple, Union from comfy.ldm.modules.distributions.distributions import DiagonalGaussianDistribution from comfy.ldm.util import instantiate_from_config from comfy.ldm.modules.ema import LitEma import comfy.ops class Diagonal... |
import math import torch import torch.nn.functional as F from torch import nn, einsum from einops import rearrange, repeat from typing import Optional import logging from .diffusionmodules.util import AlphaBlender, timestep_embedding from .sub_quadratic_attention import efficient_dot_product_attention from comfy import... |
import torch from torch import nn class LitEma(nn.Module): def __init__(self, model, decay=0.9999, use_num_upates=True): super().__init__() if decay < 0.0 or decay > 1.0: raise ValueError('Decay must be between 0 and 1') self.m_name2s_name = {} self.register_buffer('decay', torch.tensor(decay, dtype=torch.float32)) sel... |
from functools import partial import torch from torch import Tensor from torch.utils.checkpoint import checkpoint import math import logging try: from typing import Optional, NamedTuple, List, Protocol except ImportError: from typing import Optional, NamedTuple, List from typing_extensions import Protocol from torch im... |
import functools from typing import Callable, Iterable, Union import torch from einops import rearrange, repeat import comfy.ops ops = comfy.ops.disable_weight_init from .diffusionmodules.model import ( AttnBlock, Decoder, ResnetBlock, ) from .diffusionmodules.openaimodel import ResBlock, timestep_embedding from .atten... |
import logging import math from typing import Dict, Optional import numpy as np import torch import torch.nn as nn from .. import attention from einops import rearrange, repeat def default(x, y): if x is not None: return x return y class Mlp(nn.Module): """ MLP as used in Vision Transformer, MLP-Mixer and related netwo... |
import math import torch import torch.nn as nn import numpy as np from typing import Optional, Any import logging from comfy import model_management import comfy.ops ops = comfy.ops.disable_weight_init if model_management.xformers_enabled_vae(): import xformers import xformers.ops def get_timestep_embedding(timesteps, ... |
from abc import abstractmethod import torch as th import torch.nn as nn import torch.nn.functional as F from einops import rearrange import logging from .util import ( checkpoint, avg_pool_nd, zero_module, timestep_embedding, AlphaBlender, ) from ..attention import SpatialTransformer, SpatialVideoTransformer, default f... |
import torch import torch.nn as nn import numpy as np from functools import partial from .util import extract_into_tensor, make_beta_schedule from comfy.ldm.util import default class AbstractLowScaleModel(nn.Module): def __init__(self, noise_schedule_config=None): super(AbstractLowScaleModel, self).__init__() if noise_... |
import os import math import torch import torch.nn as nn import numpy as np from einops import repeat, rearrange from comfy.ldm.util import instantiate_from_config class AlphaBlender(nn.Module): strategies = ["learned", "fixed", "learned_with_images"] def __init__( self, alpha: float, merge_strategy: str = "learned_wit... |
import torch import numpy as np class AbstractDistribution: def sample(self): raise NotImplementedError() def mode(self): raise NotImplementedError() class DiracDistribution(AbstractDistribution): def __init__(self, value): self.value = value def sample(self): return self.value def mode(self): return self.value class D... |
from ..diffusionmodules.upscaling import ImageConcatWithNoiseAugmentation from ..diffusionmodules.openaimodel import Timestep import torch class CLIPEmbeddingNoiseAugmentation(ImageConcatWithNoiseAugmentation): def __init__(self, *args, clip_stats_path=None, timestep_dim=256, **kwargs): super().__init__(*args, **kwargs... |
{ "bos_token": { "content": "<|startoftext|>", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false }, "eos_token": { "content": "<|endoftext|>", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false }, "pad_token": "<|endoftext|>", "unk_token": { "content": "<|endoftext|>", "... |
{ "add_prefix_space": false, "bos_token": { "__type": "AddedToken", "content": "<|startoftext|>", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false }, "do_lower_case": true, "eos_token": { "__type": "AddedToken", "content": "<|endoftext|>", "lstrip": false, "normalized": true, "rstrip": false, ... |
{ "!": 0, "!!": 1443, "!!!": 11194, "!!!!": 4003, "!!!!!!!!": 11281, "!!!!!!!!!!!!!!!!": 30146, "!!!!!!!!!!!</w>": 49339, "!!!!!!!!!!</w>": 35579, "!!!!!!!!!</w>": 28560, "!!!!!!!!</w>": 21622, "!!!!!!!</w>": 15203, "!!!!!!</w>": 9168, "!!!!!</w>": 5203, "!!!!</w>": 2360, "!!!\"</w>": 28048, "!!!)</w>": 42532, "!!!</w>... |
import torch import torch.nn as nn from collections import OrderedDict def conv_nd(dims, *args, **kwargs): """ Create a 1D, 2D, or 3D convolution module. """ if dims == 1: return nn.Conv1d(*args, **kwargs) elif dims == 2: return nn.Conv2d(*args, **kwargs) elif dims == 3: return nn.Conv3d(*args, **kwargs) raise ValueErr... |
{ "additional_special_tokens": [ "<extra_id_0>", "<extra_id_1>", "<extra_id_2>", "<extra_id_3>", "<extra_id_4>", "<extra_id_5>", "<extra_id_6>", "<extra_id_7>", "<extra_id_8>", "<extra_id_9>", "<extra_id_10>", "<extra_id_11>", "<extra_id_12>", "<extra_id_13>", "<extra_id_14>", "<extra_id_15>", "<extra_id_16>", "<extra_... |
{ "version": "1.0", "truncation": null, "padding": null, "added_tokens": [ { "id": 0, "content": "<pad>", "single_word": false, "lstrip": false, "rstrip": false, "normalized": false, "special": true }, { "id": 1, "content": "</s>", "single_word": false, "lstrip": false, "rstrip": false, "normalized": false, "special": ... |
{ "added_tokens_decoder": { "0": { "content": "<pad>", "lstrip": false, "normalized": false, "rstrip": false, "single_word": false, "special": true }, "1": { "content": "</s>", "lstrip": false, "normalized": false, "rstrip": false, "single_word": false, "special": true }, "2": { "content": "<unk>", "lstrip": false, "no... |
""" Tiny AutoEncoder for Stable Diffusion (DNN for encoding / decoding SD's latent space) """ import torch import torch.nn as nn import comfy.utils import comfy.ops def conv(n_in, n_out, **kwargs): return comfy.ops.disable_weight_init.Conv2d(n_in, n_out, 3, padding=1, **kwargs) class Clamp(nn.Module): def forward(self,... |
import comfy.samplers import comfy.utils import torch import numpy as np from tqdm.auto import trange, tqdm import math @torch.no_grad() def sample_lcm_upscale(model, x, sigmas, extra_args=None, callback=None, disable=None, total_upscale=2.0, upscale_method="bislerp", upscale_steps=None): extra_args = {} if extra_args ... |
import numpy as np import torch def loglinear_interp(t_steps, num_steps): """ Performs log-linear interpolation of a given array of decreasing numbers. """ xs = np.linspace(0, 1, len(t_steps)) ys = np.log(t_steps[::-1]) new_xs = np.linspace(0, 1, num_steps) new_ys = np.interp(new_xs, xs, ys) interped_ys = np.exp(new_ys... |
def attention_multiply(attn, model, q, k, v, out): m = model.clone() sd = model.model_state_dict() for key in sd: if key.endswith("{}.to_q.bias".format(attn)) or key.endswith("{}.to_q.weight".format(attn)): m.add_patches({key: (None,)}, 0.0, q) if key.endswith("{}.to_k.bias".format(attn)) or key.endswith("{}.to_k.weigh... |
import torchaudio import torch import comfy.model_management import folder_paths import os class EmptyLatentAudio: def __init__(self): self.device = comfy.model_management.intermediate_device() @classmethod def INPUT_TYPES(s): return {"required": {}} RETURN_TYPES = ("LATENT",) FUNCTION = "generate" CATEGORY = "_for_tes... |
from kornia.filters import canny import comfy.model_management class Canny: @classmethod def INPUT_TYPES(s): return {"required": {"image": ("IMAGE",), "low_threshold": ("FLOAT", {"default": 0.4, "min": 0.01, "max": 0.99, "step": 0.01}), "high_threshold": ("FLOAT", {"default": 0.8, "min": 0.01, "max": 0.99, "step": 0.01... |
import torch from nodes import MAX_RESOLUTION class CLIPTextEncodeSDXLRefiner: @classmethod def INPUT_TYPES(s): return {"required": { "ascore": ("FLOAT", {"default": 6.0, "min": 0.0, "max": 1000.0, "step": 0.01}), "width": ("INT", {"default": 1024.0, "min": 0, "max": MAX_RESOLUTION}), "height": ("INT", {"default": 1024... |
import numpy as np import torch import comfy.utils from enum import Enum def resize_mask(mask, shape): return torch.nn.functional.interpolate(mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])), size=(shape[0], shape[1]), mode="bilinear").squeeze(1) class PorterDuffMode(Enum): ADD = 0 CLEAR = 1 DARKEN = 2 DST = 3 DST... |
class CLIPTextEncodeControlnet: @classmethod def INPUT_TYPES(s): return {"required": {"clip": ("CLIP", ), "conditioning": ("CONDITIONING", ), "text": ("STRING", {"multiline": True, "dynamicPrompts": True})}} RETURN_TYPES = ("CONDITIONING",) FUNCTION = "encode" CATEGORY = "_for_testing/conditioning" def encode(self, cli... |
import comfy.samplers import comfy.sample from comfy.k_diffusion import sampling as k_diffusion_sampling import latent_preview import torch import comfy.utils import node_helpers class BasicScheduler: @classmethod def INPUT_TYPES(s): return {"required": {"model": ("MODEL",), "scheduler": (comfy.samplers.SCHEDULER_NAMES... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.