# Documentation - Class name: KSamplerSeq - Category: sampling - Output node: False - Repo Ref: https://github.com/WASasquatch/WAS_Extras KSamplerSeq节点旨在使用各种种子模式和条件序列执行顺序采样操作。它管理生成潜在样本，具有在正负条件序列之间交替、插值潜在样本以及控制去噪过程的能力。该节点确保了一个连贯且可控的采样工作流程，可以根据特定的创造性或分析目的进行微调。 # Input types ## Required - model - 模型参数对于KSamplerSeq节点至关重要，因为它定义了将用于采样的生成模型。模型的选择显著影响生成样本的质量和风格。 - Comfy dtype: MODEL - Python dtype: torch.nn.Module - seed - 种子参数对于初始化随机数生成过程至关重要，确保了采样操作中的可重复性。它为生成的种子序列设定了起始点。 - Comfy dtype: INT - Python dtype: int ## Optional - seed_mode_seq - seed_mode_seq参数决定了采样序列中种子值是如何更新的，允许采用不同的采样策略，如增量、递减、随机选择或固定种子。 - Comfy dtype: COMBO['increment', 'decrement', 'random', 'fixed'] - Python dtype: str - alternate_values - alternate_values参数在采样过程中启用不同种子状态之间的交替，为生成的样本增加了变化性。 - Comfy dtype: BOOLEAN - Python dtype: bool - steps - steps参数指定了采样过程中的步骤数量，这直接影响生成样本的分辨率和细节。 - Comfy dtype: INT - Python dtype: int - cfg - cfg参数，代表配置值，用于控制采样过程的保真度，在生成样本的细节和噪声之间进行平衡。 - Comfy dtype: FLOAT - Python dtype: float - sampler_name - sampler_name参数从可用的采样器中选择要使用的特定采样方法，影响采样过程的整体行为和特性。 - Comfy dtype: comfy.samplers.KSampler.SAMPLERS - Python dtype: str - scheduler - scheduler参数定义了采样过程中的噪声减少策略，这可能会影响生成样本的平滑度和连贯性。 - Comfy dtype: comfy.samplers.KSampler.SCHEDULERS - Python dtype: str - sequence_loop_count - sequence_loop_count参数设置了采样序列的迭代次数，允许在单次运行中生成多个样本。 - Comfy dtype: INT - Python dtype: int - positive_seq - positive_seq参数提供了一系列正向条件值，引导采样过程朝着期望的结果发展。 - Comfy dtype: CONDITIONING_SEQ - Python dtype: List[Tuple[int, torch.Tensor, Dict[str, torch.Tensor]]] - negative_seq - negative_seq参数提供了一系列负向条件值，通过阻止不希望的结果来帮助完善采样过程。 - Comfy dtype: CONDITIONING_SEQ - Python dtype: List[Tuple[int, torch.Tensor, Dict[str, torch.Tensor]]] - use_conditioning_slerp - use_conditioning_slerp参数启用了球面线性插值（SLERP）来混合条件值，这可以导致样本状态之间更平滑的过渡。 - Comfy dtype: BOOLEAN - Python dtype: bool - cond_slerp_strength - cond_slerp_strength参数控制混合条件值时SLERP操作的强度，影响状态间插值的范围。 - Comfy dtype: FLOAT - Python dtype: float - latent_image - latent_image参数表示用作采样过程起点的初始潜在状态，影响生成样本的方向和特性。 - Comfy dtype: LATENT - Python dtype: Dict[str, torch.Tensor] - use_latent_interpolation - use_latent_interpolation参数切换应用潜在插值在生成样本之间，这可以产生更连贯的样本序列。 - Comfy dtype: BOOLEAN - Python dtype: bool - latent_interpolation_mode - latent_interpolation_mode参数选择要使用的潜在插值方法，这定义了连续样本如何混合在一起。 - Comfy dtype: COMBO['Blend', 'Slerp', 'Cosine Interp'] - Python dtype: str - latent_interp_strength - latent_interp_strength参数调整潜在插值的影响，决定一个样本在序列中如何平滑地过渡到下一个样本。 - Comfy dtype: FLOAT - Python dtype: float - denoise_start - denoise_start参数设置了初始去噪强度，这影响采样过程开始时的噪声减少。 - Comfy dtype: FLOAT - Python dtype: float - denoise_seq - denoise_seq参数控制整个采样序列中的去噪强度，允许随时间微调噪声减少。 - Comfy dtype: FLOAT - Python dtype: float - unsample_latents - 当启用unsample_latents参数时，触发未采样潜在状态的生成过程，这可以引入更多的多样性到采样输出中。 - Comfy dtype: BOOLEAN - Python dtype: bool # Output types - samples - samples参数封装了采样过程中生成的潜在样本。它是代表生成图像潜在空间的张量集合。 - Comfy dtype: LATENT - Python dtype: torch.Tensor # Usage tips - Infra type: GPU # Source code ``` class KSamplerSeq: def __init__(self): self.previous_seed = None self.current_seed = None def initialize_seeds(self, initial_seed): self.previous_seed = initial_seed self.current_seed = initial_seed @classmethod def INPUT_TYPES(s): return {'required': {'model': ('MODEL',), 'seed': ('INT', {'default': 0, 'min': 0, 'max': 18446744073709551615}), 'seed_mode_seq': (['increment', 'decrement', 'random', 'fixed'],), 'alternate_values': ('BOOLEAN', {'default': True}), 'steps': ('INT', {'default': 20, 'min': 1, 'max': 10000}), 'cfg': ('FLOAT', {'default': 8.0, 'min': 0.0, 'max': 100.0, 'step': 0.5, 'round': 0.01}), 'sampler_name': (comfy.samplers.KSampler.SAMPLERS,), 'scheduler': (comfy.samplers.KSampler.SCHEDULERS,), 'sequence_loop_count': ('INT', {'default': 20, 'min': 1, 'max': 1024, 'step': 1}), 'positive_seq': ('CONDITIONING_SEQ',), 'negative_seq': ('CONDITIONING_SEQ',), 'use_conditioning_slerp': ('BOOLEAN', {'default': False}), 'cond_slerp_strength': ('FLOAT', {'default': 0.5, 'min': 0.0, 'max': 1.0, 'step': 0.001}), 'latent_image': ('LATENT',), 'use_latent_interpolation': ('BOOLEAN', {'default': False}), 'latent_interpolation_mode': (['Blend', 'Slerp', 'Cosine Interp'],), 'latent_interp_strength': ('FLOAT', {'default': 0.5, 'min': 0.0, 'max': 1.0, 'step': 0.001}), 'denoise_start': ('FLOAT', {'default': 1.0, 'min': 0.0, 'max': 1.0, 'step': 0.01}), 'denoise_seq': ('FLOAT', {'default': 0.5, 'min': 0.0, 'max': 1.0, 'step': 0.01}), 'unsample_latents': ('BOOLEAN', {'default': False})}} RETURN_TYPES = ('LATENT',) FUNCTION = 'sample' CATEGORY = 'sampling' def update_seed(self, seed, seed_mode): if seed_mode == 'increment': return seed + 1 elif seed_mode == 'decrement': return seed - 1 elif seed_mode == 'random': return random.randint(0, 18446744073709551615) elif seed_mode == 'fixed': return seed def hash_tensor(self, tensor): tensor = tensor.cpu().contiguous() return hashlib.sha256(tensor.numpy().tobytes()).hexdigest() def update_conditioning(self, conditioning_seq, loop_count, last_conditioning): matching_conditioning = None for (idx, conditioning, *_) in conditioning_seq: if int(idx) == loop_count: matching_conditioning = conditioning break return matching_conditioning if matching_conditioning else last_conditioning if last_conditioning else None def update_alternate_seed(self, loop_count): if loop_count % 3 == 0: if self.previous_seed is None: self.previous_seed = self.current_seed else: (self.previous_seed, self.current_seed) = (self.current_seed, self.previous_seed + 1 if loop_count // 2 % 2 == 0 else self.previous_seed - 1) return self.current_seed def alternate_denoise(self, current_denoise): return 0.95 if current_denoise == 0.75 else 0.75 def sample(self, model, seed, seed_mode_seq, alternate_values, steps, cfg, sampler_name, scheduler, sequence_loop_count, positive_seq, negative_seq, cond_slerp_strength, latent_image, use_latent_interpolation, latent_interpolation_mode, latent_interp_strength, denoise_start=1.0, denoise_seq=0.5, use_conditioning_slerp=False, unsample_latents=False, alternate_mode=False): positive_seq = positive_seq negative_seq = negative_seq results = [] positive_conditioning = None negative_conditioning = None self.initialize_seeds(seed) for loop_count in range(sequence_loop_count): if alternate_values and loop_count % 2 == 0: seq_seed = self.update_alternate_seed(seed) if seed_mode_seq != 'fixed' else seed else: seq_seed = seed if loop_count <= 0 else self.update_seed(seq_seed, seed_mode_seq) print(f'Loop count: {loop_count}, Seed: {seq_seed}') last_positive_conditioning = positive_conditioning[0] if positive_conditioning else None last_negative_conditioning = negative_conditioning[0] if negative_conditioning else None positive_conditioning = self.update_conditioning(positive_seq, loop_count, last_positive_conditioning) negative_conditioning = self.update_conditioning(negative_seq, loop_count, last_negative_conditioning) if use_conditioning_slerp and (last_positive_conditioning and last_negative_conditioning): a = last_positive_conditioning[0].clone() b = positive_conditioning[0].clone() na = last_negative_conditioning[0].clone() nb = negative_conditioning[0].clone() pa = last_positive_conditioning[1]['pooled_output'].clone() pb = positive_conditioning[1]['pooled_output'].clone() npa = last_negative_conditioning[1]['pooled_output'].clone() npb = negative_conditioning[1]['pooled_output'].clone() pos_cond = slerp(cond_slerp_strength, a, b) pos_pooled = slerp(cond_slerp_strength, pa, pb) neg_cond = slerp(cond_slerp_strength, na, nb) neg_pooled = slerp(cond_slerp_strength, npa, npb) positive_conditioning = [pos_cond, {'pooled_output': pos_pooled}] negative_conditioning = [neg_cond, {'pooled_output': neg_pooled}] positive_conditioning = [positive_conditioning] negative_conditioning = [negative_conditioning] if positive_conditioning is not None or negative_conditioning is not None: end_at_step = steps if results is not None and len(results) > 0: latent_input = {'samples': results[-1]} denoise = denoise_seq start_at_step = round((1 - denoise) * steps) end_at_step = steps else: latent_input = latent_image denoise = denoise_start if unsample_latents and loop_count > 0: force_full_denoise = False if loop_count > 0 or loop_count <= steps - 1 else True disable_noise = False unsampled_latent = unsample(model=model, seed=seq_seed, cfg=cfg, sampler_name=sampler_name, steps=steps, end_at_step=end_at_step, scheduler=scheduler, normalize=False, positive=positive_conditioning, negative=negative_conditioning, latent_image=latent_input)[0] sample = nodes.common_ksampler(model, seq_seed, steps, cfg, sampler_name, scheduler, positive_conditioning, negative_conditioning, unsampled_latent, denoise=denoise, disable_noise=disable_noise, start_step=start_at_step, last_step=end_at_step, force_full_denoise=force_full_denoise)[0]['samples'] else: sample = nodes.common_ksampler(model, seq_seed, steps, cfg, sampler_name, scheduler, positive_conditioning, negative_conditioning, latent_input, denoise=denoise)[0]['samples'] if use_latent_interpolation and results and (loop_count > 0): if latent_interpolation_mode == 'Blend': sample = blend_latents(latent_interp_strength, results[-1], sample) elif latent_interpolation_mode == 'Slerp': sample = slerp_latents(latent_interp_strength, results[-1], sample) elif latent_interpolation_mode == 'Cosine Interp': sample = cosine_interp_latents(latent_interp_strength, results[-1], sample) else: sample = sample results.append(sample) results = torch.cat(results, dim=0) results = {'samples': results} return (results,) ```