13 KiB
13 KiB
Documentation
- Class name: WAS_KSampler_Cycle
- Category: WAS Suite/Sampling
- Output node: False
- Repo Ref: https://github.com/WASasquatch/was-node-suite-comfyui
WAS_KSampler_Cycle 节点旨在 WAS 套件中执行高级采样操作。它利用各种参数来控制采样过程，包括模型选择、种子初始化、步数计数和条件输入。该节点能够处理复杂的采样任务，如迭代去噪和潜在图像操作，以实现高质量的结果。它还支持可选功能，如次要模型切换和后处理增强，使其成为复杂采样需求的多功能工具。
Input types
Required
- model
- 模型参数对于采样过程至关重要，因为它定义了用于生成输出的底层神经网络模型。模型的选择可以显著影响生成样本的质量和特性。
- Comfy dtype: MODEL
- Python dtype: torch.nn.Module
- seed
- 种子参数对于初始化随机数生成器至关重要，确保了采样过程的可重复性。它允许在不同运行中使用相同的种子值生成一致的结果。
- Comfy dtype: INT
- Python dtype: int
- steps
- 步数参数决定了采样过程中的迭代次数。步数越多，可以导致更精细的样本，但也可能增加计算时间。
- Comfy dtype: INT
- Python dtype: int
Output types
- latent(s)
- 输出的潜在表示生成样本的编码形式。这些潜在表示可以进一步处理或用于各种下游任务，如图像重建或特征提取。
- Comfy dtype: LATENT
- Python dtype: torch.Tensor
Usage tips
- Infra type: GPU
Source code
class WAS_KSampler_Cycle:
@classmethod
def INPUT_TYPES(s):
return {'required': {'model': ('MODEL',), 'seed': ('INT', {'default': 0, 'min': 0, 'max': 18446744073709551615}), 'steps': ('INT', {'default': 20, 'min': 1, 'max': 10000}), 'cfg': ('FLOAT', {'default': 8.0, 'min': 0.0, 'max': 100.0}), 'sampler_name': (comfy.samplers.KSampler.SAMPLERS,), 'scheduler': (comfy.samplers.KSampler.SCHEDULERS,), 'positive': ('CONDITIONING',), 'negative': ('CONDITIONING',), 'latent_image': ('LATENT',), 'tiled_vae': (['disable', 'enable'],), 'latent_upscale': (['disable', 'nearest-exact', 'bilinear', 'area', 'bicubic', 'bislerp'],), 'upscale_factor': ('FLOAT', {'default': 2.0, 'min': 0.1, 'max': 8.0, 'step': 0.1}), 'upscale_cycles': ('INT', {'default': 2, 'min': 2, 'max': 12, 'step': 1}), 'starting_denoise': ('FLOAT', {'default': 1.0, 'min': 0.0, 'max': 1.0, 'step': 0.01}), 'cycle_denoise': ('FLOAT', {'default': 0.5, 'min': 0.0, 'max': 1.0, 'step': 0.01}), 'scale_denoise': (['enable', 'disable'],), 'scale_sampling': (['bilinear', 'bicubic', 'nearest', 'lanczos'],), 'vae': ('VAE',)}, 'optional': {'secondary_model': ('MODEL',), 'secondary_start_cycle': ('INT', {'default': 2, 'min': 2, 'max': 16, 'step': 1}), 'upscale_model': ('UPSCALE_MODEL',), 'processor_model': ('UPSCALE_MODEL',), 'pos_additive': ('CONDITIONING',), 'neg_additive': ('CONDITIONING',), 'pos_add_mode': (['increment', 'decrement'],), 'pos_add_strength': ('FLOAT', {'default': 0.25, 'min': 0.01, 'max': 1.0, 'step': 0.01}), 'pos_add_strength_scaling': (['enable', 'disable'],), 'pos_add_strength_cutoff': ('FLOAT', {'default': 2.0, 'min': 0.01, 'max': 10.0, 'step': 0.01}), 'neg_add_mode': (['increment', 'decrement'],), 'neg_add_strength': ('FLOAT', {'default': 0.25, 'min': 0.01, 'max': 1.0, 'step': 0.01}), 'neg_add_strength_scaling': (['enable', 'disable'],), 'neg_add_strength_cutoff': ('FLOAT', {'default': 2.0, 'min': 0.01, 'max': 10.0, 'step': 0.01}), 'sharpen_strength': ('FLOAT', {'default': 0.0, 'min': 0.0, 'max': 10.0, 'step': 0.01}), 'sharpen_radius': ('INT', {'default': 2, 'min': 1, 'max': 12, 'step': 1}), 'steps_scaling': (['enable', 'disable'],), 'steps_control': (['decrement', 'increment'],), 'steps_scaling_value': ('INT', {'default': 10, 'min': 1, 'max': 20, 'step': 1}), 'steps_cutoff': ('INT', {'default': 20, 'min': 4, 'max': 1000, 'step': 1}), 'denoise_cutoff': ('FLOAT', {'default': 0.25, 'min': 0.01, 'max': 1.0, 'step': 0.01})}}
RETURN_TYPES = ('LATENT',)
RETURN_NAMES = ('latent(s)',)
FUNCTION = 'sample'
CATEGORY = 'WAS Suite/Sampling'
def sample(self, model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, tiled_vae, latent_upscale, upscale_factor, upscale_cycles, starting_denoise, cycle_denoise, scale_denoise, scale_sampling, vae, secondary_model=None, secondary_start_cycle=None, pos_additive=None, pos_add_mode=None, pos_add_strength=None, pos_add_strength_scaling=None, pos_add_strength_cutoff=None, neg_additive=None, neg_add_mode=None, neg_add_strength=None, neg_add_strength_scaling=None, neg_add_strength_cutoff=None, upscale_model=None, processor_model=None, sharpen_strength=0, sharpen_radius=2, steps_scaling=None, steps_control=None, steps_scaling_value=None, steps_cutoff=None, denoise_cutoff=0.25):
upscale_steps = upscale_cycles
division_factor = upscale_steps if steps >= upscale_steps else steps
current_upscale_factor = upscale_factor ** (1 / (division_factor - 1))
tiled_vae = tiled_vae == 'enable'
scale_denoise = scale_denoise == 'enable'
pos_add_strength_scaling = pos_add_strength_scaling == 'enable'
neg_add_strength_scaling = neg_add_strength_scaling == 'enable'
steps_scaling = steps_scaling == 'enable'
run_model = model
secondary_switched = False
for i in range(division_factor):
cstr(f'Cycle Pass {i + 1}/{division_factor}').msg.print()
if scale_denoise:
denoise = (round(cycle_denoise * 2 ** (-(i - 1)), 2) if i > 0 else cycle_denoise) if i > 0 else round(starting_denoise, 2)
else:
denoise = round(cycle_denoise if i > 0 else starting_denoise, 2)
if denoise < denoise_cutoff and scale_denoise:
denoise = denoise_cutoff
if i >= secondary_start_cycle - 1 and secondary_model and (not secondary_switched):
run_model = secondary_model
denoise = cycle_denoise
model = None
secondary_switched = True
if steps_scaling and i > 0:
steps = steps + steps_scaling_value if steps_control == 'increment' else steps - steps_scaling_value
steps = (steps if steps <= steps_cutoff else steps_cutoff) if steps_control == 'increment' else steps if steps >= steps_cutoff else steps_cutoff
print('Steps:', steps)
print('Denoise:', denoise)
if pos_additive:
pos_strength = 0.0 if i <= 0 else pos_add_strength
if pos_add_mode == 'increment':
pos_strength = (round(pos_add_strength * 2 ** (i - 1), 2) if i > 0 else pos_add_strength) if pos_add_strength_scaling else pos_add_strength
pos_strength = pos_add_strength_cutoff if pos_strength > pos_add_strength_cutoff else pos_strength
else:
pos_strength = (round(pos_add_strength / 2 ** (i - 1), 2) if i > 0 else pos_add_strength) if pos_add_strength_scaling else pos_add_strength
pos_strength = pos_add_strength_cutoff if pos_strength < pos_add_strength_cutoff else pos_strength
comb = nodes.ConditioningAverage()
positive = comb.addWeighted(pos_additive, positive, pos_strength)[0]
print('Positive Additive Strength:', pos_strength)
if neg_additive:
neg_strength = 0.0 if i <= 0 else pos_add_strength
if neg_add_mode == 'increment':
neg_strength = (round(neg_add_strength * 2 ** (i - 1), 2) if i > 0 else neg_add_strength) if neg_add_strength_scaling else neg_add_strength
neg_strength = neg_add_strength_cutoff if neg_strength > neg_add_strength_cutoff else neg_strength
else:
neg_strength = (round(neg_add_strength / 2 ** (i - 1), 2) if i > 0 else neg_add_strength) if neg_add_strength_scaling else neg_add_strength
neg_strength = neg_add_strength_cutoff if neg_strength < neg_add_strength_cutoff else neg_strength
comb = nodes.ConditioningAverage()
negative = comb.addWeighted(neg_additive, negative, neg_strength)[0]
print('Negative Additive Strength:', neg_strength)
if i != 0:
latent_image = latent_image_result
samples = nodes.common_ksampler(run_model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise=denoise)
if i < division_factor - 1:
tensors = None
upscaler = None
resample_filters = {'nearest': 0, 'bilinear': 2, 'bicubic': 3, 'lanczos': 1}
if latent_upscale == 'disable':
if tiled_vae:
tensors = vae.decode_tiled(samples[0]['samples'])
else:
tensors = vae.decode(samples[0]['samples'])
if processor_model or upscale_model:
from comfy_extras import nodes_upscale_model
upscaler = nodes_upscale_model.ImageUpscaleWithModel()
if processor_model:
original_size = tensor2pil(tensors[0]).size
upscaled_tensors = upscaler.upscale(processor_model, tensors)
tensor_images = []
for tensor in upscaled_tensors[0]:
pil = tensor2pil(tensor)
if pil.size[0] != original_size[0] or pil.size[1] != original_size[1]:
pil = pil.resize((original_size[0], original_size[1]), Image.Resampling(resample_filters[scale_sampling]))
if sharpen_strength != 0.0:
pil = self.unsharp_filter(pil, sharpen_radius, sharpen_strength)
tensor_images.append(pil2tensor(pil))
tensor_images = torch.cat(tensor_images, dim=0)
if upscale_model:
if processor_model:
tensors = tensor_images
del tensor_images
original_size = tensor2pil(tensors[0]).size
new_width = round(original_size[0] * current_upscale_factor)
new_height = round(original_size[1] * current_upscale_factor)
new_width = int(round(new_width / 32) * 32)
new_height = int(round(new_height / 32) * 32)
upscaled_tensors = upscaler.upscale(upscale_model, tensors)
tensor_images = []
for tensor in upscaled_tensors[0]:
tensor = pil2tensor(tensor2pil(tensor).resize((new_width, new_height), Image.Resampling(resample_filters[scale_sampling])))
size = max(tensor2pil(tensor).size)
if sharpen_strength != 0.0:
tensor = pil2tensor(self.unsharp_filter(tensor2pil(tensor), sharpen_radius, sharpen_strength))
tensor_images.append(tensor)
tensor_images = torch.cat(tensor_images, dim=0)
else:
tensor_images = []
scale = WAS_Image_Rescale()
for tensor in tensors:
tensor = scale.image_rescale(tensor.unsqueeze(0), 'rescale', 'true', scale_sampling, current_upscale_factor, 0, 0)[0]
size = max(tensor2pil(tensor).size)
if sharpen_strength > 0.0:
tensor = pil2tensor(self.unsharp_filter(tensor2pil(tensor), sharpen_radius, sharpen_strength))
tensor_images.append(tensor)
tensor_images = torch.cat(tensor_images, dim=0)
if tiled_vae:
latent_image_result = {'samples': vae.encode_tiled(self.vae_encode_crop_pixels(tensor_images)[:, :, :, :3])}
else:
latent_image_result = {'samples': vae.encode(self.vae_encode_crop_pixels(tensor_images)[:, :, :, :3])}
else:
upscaler = nodes.LatentUpscaleBy()
latent_image_result = upscaler.upscale(samples[0], latent_upscale, current_upscale_factor)[0]
else:
latent_image_result = samples[0]
return (latent_image_result,)
@staticmethod
def vae_encode_crop_pixels(pixels):
x = pixels.shape[1] // 8 * 8
y = pixels.shape[2] // 8 * 8
if pixels.shape[1] != x or pixels.shape[2] != y:
x_offset = pixels.shape[1] % 8 // 2
y_offset = pixels.shape[2] % 8 // 2
pixels = pixels[:, x_offset:x + x_offset, y_offset:y + y_offset, :]
return pixels
@staticmethod
def unsharp_filter(image, radius=2, amount=1.0):
from skimage.filters import unsharp_mask
img_array = np.array(image)
img_array = img_array / 255.0
sharpened = unsharp_mask(img_array, radius=radius, amount=amount, channel_axis=2)
sharpened = (sharpened * 255.0).astype(np.uint8)
sharpened_pil = Image.fromarray(sharpened)
return sharpened_pil