Diffuser库Stable_diffusion pipeline代码逐行解析（喂饭级别）_diffusionpipeline

对文本提示编码，旧版本已经不使用了。用新版本的。

def encode_prompt(
    self,
    prompt,  # 文本提示
    device,
    num_images_per_prompt,  # 每个提示生成的文本数量
    do_classifier_free_guidance,  # cfg
    negative_prompt=None,   # 负向词
    prompt_embeds: Optional[torch.FloatTensor] = None,  # 预设的文本embed
    negative_prompt_embeds: Optional[torch.FloatTensor] = None, # 预设的负向文本embed
    lora_scale: Optional[float] = None,  # lora_scale
    clip_skip: Optional[int] = None, # clip输出要跳过的层数
):
    r"""
    Encodes the prompt into text encoder hidden states.
    Args:
        prompt (`str` or `List[str]`, *optional*):
            prompt to be encoded
        device: (`torch.device`):
            torch device
        num_images_per_prompt (`int`):
            number of images that should be generated per prompt
        do_classifier_free_guidance (`bool`):
            whether to use classifier free guidance or not
        negative_prompt (`str` or `List[str]`, *optional*):
            The prompt or prompts not to guide the image generation. If not defined, one has to pass
            `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
            less than `1`).
        prompt_embeds (`torch.FloatTensor`, *optional*):
            Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
            provided, text embeddings will be generated from `prompt` input argument.
        negative_prompt_embeds (`torch.FloatTensor`, *optional*):
            Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
            weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
            argument.
        lora_scale (`float`, *optional*):
            A LoRA scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded.
        clip_skip (`int`, *optional*):
            Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
            the output of the pre-final layer will be used for computing the prompt embeddings.
    """
    # set lora scale so that monkey patched LoRA
    # function of text encoder can correctly access it
    # 设置text_encoder中的lora_scale
    if lora_scale is not None and isinstance(self, LoraLoaderMixin):
        self._lora_scale = lora_scale
 
        # dynamically adjust the LoRA scale
        if not USE_PEFT_BACKEND:
            adjust_lora_scale_text_encoder(self.text_encoder, lora_scale)
        else:
            scale_lora_layers(self.text_encoder, lora_scale)
    
    # 根据prompt数量设置batch_size
    if prompt is not None and isinstance(prompt, str):
        batch_size = 1
    elif prompt is not None and isinstance(prompt, list):
        batch_size = len(prompt)
    else:
        batch_size = prompt_embeds.shape[0]
    
    # 若没有预设的prompt_embed
    if prompt_embeds is None:
        # textual inversion: procecss multi-vector tokens if necessary
        # 若当前对象是TextualInversionLoaderMixin的实例，
        # 那么会调用maybe_convert_prompt函数对多向量标记进行处理，以进行文本反转。
        if isinstance(self, TextualInversionLoaderMixin):
            prompt = self.maybe_convert_prompt(prompt, self.tokenizer)
 
        # 文本编码，输出是字典形式，有input_ids,attention_mask
        # input_ids是token, attention_mask指出哪些是输入文本，哪些是填充
        text_inputs = self.tokenizer(
            prompt,
            padding="max_length",
            max_length=self.tokenizer.model_max_length,
            truncation=True,
            return_tensors="pt",
        )
        # 获取token，即input_ids
        text_input_ids = text_inputs.input_ids
        # 使用longest，获取没截断的文本tokens
        untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids
        # 如果没截断的文本tokens大于tokens，获取removed_text，即被截断的文本。
        if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
            text_input_ids, untruncated_ids
        ):
            # 对被截断的文本token做decoder
            removed_text = self.tokenizer.batch_decode(
                untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]
            )
            logger.warning(
                "The following part of your input was truncated because CLIP can only handle sequences up to"
                f" {self.tokenizer.model_max_length} tokens: {removed_text}"
            )
        
        # 若文本编码器有use_attention_mask参数，且use_attention_mask不为空，获取attn_mask
        if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
            attention_mask = text_inputs.attention_mask.to(device)
        else:
            attention_mask = None
        
        # 获取text_embed，没有clip_skip，直接输出
        if clip_skip is None:
            prompt_embeds = self.text_encoder(text_input_ids.to(device), attention_mask=attention_mask)
            prompt_embeds = prompt_embeds[0]
        # 有clip_skip
        else:
            prompt_embeds = self.text_encoder(
                text_input_ids.to(device), attention_mask=attention_mask, output_hidden_states=True
            )
            # Access the `hidden_states` first, that contains a tuple of
            # all the hidden states from the encoder layers. Then index into
            # the tuple to access the hidden states from the desired layer.
            # keys中有['last_hidden_state', 'pooler_output', 'hidden_states']
            # 选择hidden_states，-（clip_skip+1）表示输出倒数第几层
            prompt_embeds = prompt_embeds[-1][-(clip_skip + 1)]
            # We also need to apply the final LayerNorm here to not mess with the
            # representations. The `last_hidden_states` that we typically use for
            # obtaining the final prompt representations passes through the LayerNorm
            # layer.
            # 对输出的hidden_states做最后一层的layer_norm，使分布一样
            prompt_embeds = self.text_encoder.text_model.final_layer_norm(prompt_embeds)
    
    # 根据模型提取数据格式，将text_embed数据格式统一化
    if self.text_encoder is not None:
        prompt_embeds_dtype = self.text_encoder.dtype
    elif self.unet is not None:
        prompt_embeds_dtype = self.unet.dtype
    else:
        prompt_embeds_dtype = prompt_embeds.dtype
    
    # 设置数据格式
    prompt_embeds = prompt_embeds.to(dtype=prompt_embeds_dtype, device=device)
    
    # 获取batch_size，序列长度
    bs_embed, seq_len, _ = prompt_embeds.shape
    # duplicate text embeddings for each generation per prompt, using mps friendly method
    # 按序列长度维度重复num_images_per_prompt次
    prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1)
    # 将[bs_embed, num_images_per_prompt*seq_len, channel] -> [bs_embed*num_images_per_prompt, seq_len, channel]
    prompt_embeds = prompt_embeds.view(bs_embed * num_images_per_prompt, seq_len, -1)
 
    # get unconditional embeddings for classifier free guidance
    # 获取无条件tokens
    # 1.若要cfg而没有预设的负向embed
    # 2.若负向prompt为空，用空文本代替。否则用负向prompt
    if do_classifier_free_guidance and negative_prompt_embeds is None:
        uncond_tokens: List[str]
        if negative_prompt is None:
            uncond_tokens = [""] * batch_size
        # 判断prompt格式和neg_prompt格式
        elif prompt is not None and type(prompt) is not type(negative_prompt):
            raise TypeError(
                f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
                f" {type(prompt)}."
            )
        # 根据neg_prompt格式设定无条件tokens
        elif isinstance(negative_prompt, str):
            uncond_tokens = [negative_prompt]
        elif batch_size != len(negative_prompt):
            raise ValueError(
                f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
                f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
                " the batch size of `prompt`."
            )
        else:
            uncond_tokens = negative_prompt
 
        # textual inversion: procecss multi-vector tokens if necessary
        # tokens反推文本。
        if isinstance(self, TextualInversionLoaderMixin):
            uncond_tokens = self.maybe_convert_prompt(uncond_tokens, self.tokenizer)
        
        # 重新提取无条件tokens
        max_length = prompt_embeds.shape[1]
        uncond_input = self.tokenizer(
            uncond_tokens,
            padding="max_length",
            max_length=max_length,
            truncation=True,
            return_tensors="pt",
        )
        
        # 提取无条件tokens的attention_mask
        if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
            attention_mask = uncond_input.attention_mask.to(device)
        else:
            attention_mask = None
        
        # 用无条件tokens的embed做负向embed
        negative_prompt_embeds = self.text_encoder(
            uncond_input.input_ids.to(device),
            attention_mask=attention_mask,
        )
        negative_prompt_embeds = negative_prompt_embeds[0]
    
    # 若有cfg，复制负向embed，和正向embed一样。
    if do_classifier_free_guidance:
        # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
        seq_len = negative_prompt_embeds.shape[1]
 
        negative_prompt_embeds = negative_prompt_embeds.to(dtype=prompt_embeds_dtype, device=device)
 
        negative_prompt_embeds = negative_prompt_embeds.repeat(1, num_images_per_prompt, 1)
        negative_prompt_embeds = negative_prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1)
 
    if isinstance(self, LoraLoaderMixin) and USE_PEFT_BACKEND:
        # Retrieve the original scale by scaling back the LoRA layers
        unscale_lora_layers(self.text_encoder, lora_scale)
 
    return prompt_embeds, negative_prompt_embeds

493-626

图像编码函数

def encode_image(self, image, device, num_images_per_prompt, output_hidden_states=None):
    """
    对图片做encoder，输出image_embeds和ucond_image_embeds
    Args:
        image:参考图（ip_adapter_image）
        num_images_per_prompt:每个prompt生成的图片数量
        output_hidden_states:是否输出隐藏状态，具体为倒数第二层(hidden_states[-2])
             = False if isinstance(self.unet.encoder_hid_proj, ImageProjection) else True
    """
    # 获取图像编码器的数据类型，以便统一后续image数据
    dtype = next(self.image_encoder.parameters()).dtype
    
    # 判断输入image是不是Tensor，不是则用feature_extractor（CLIPImmageProcessor）函数转Tensor
    if not isinstance(image, torch.Tensor):
        image = self.feature_extractor(image, return_tensors="pt").pixel_values
    # 将image存入device，修改数据类型
    image = image.to(device=device, dtype=dtype)
    
    # 输出隐藏状态
    if output_hidden_states:
        # 获取倒数第二层的隐藏状态输出
        image_enc_hidden_states = self.image_encoder(image, output_hidden_states=True).hidden_states[-2]
        # 在第0维重复num_images_per_prompt次，用作输出num_images_per_prompt张图
        image_enc_hidden_states = image_enc_hidden_states.repeat_interleave(num_images_per_prompt, dim=0)
        # 以零矩阵作为无条件输入图像编码器
        uncond_image_enc_hidden_states = self.image_encoder(
            torch.zeros_like(image), output_hidden_states=True
        ).hidden_states[-2]
        uncond_image_enc_hidden_states = uncond_image_enc_hidden_states.repeat_interleave(
            num_images_per_prompt, dim=0
        )
        return image_enc_hidden_states, uncond_image_enc_hidden_states
    # 不输出隐藏状态
    else:
        # 直接输出image_embed
        image_embeds = self.image_encoder(image).image_embeds
        # 重复堆叠num_images_per_prompt次
        image_embeds = image_embeds.repeat_interleave(num_images_per_prompt, dim=0)
        # 直接以零矩阵作为无条件编码
        uncond_image_embeds = torch.zeros_like(image_embeds)
 
        return image_embeds, uncond_image_embeds

对最终输出的图片作安全检查，输出image和has_nsfw_concept。

def run_safety_checker(self, image, device, dtype):
    # 若不需要安全检查，则设置has_nsfw_concept为None
    if self.safety_checker is None:
        has_nsfw_concept = None
    # 需要安全检查
    # 先将image转为pil格式，然后再用CLIP提取特征，最后将image和特征输入安全检查器
    else:
        # 若image是Tensor，用后处理将image转为pil
        if torch.is_tensor(image):
            feature_extractor_input = self.image_processor.postprocess(image, output_type="pil")
        # 若image不是Tensor，用numpy_to_pil转为pil
        else:
            feature_extractor_input = self.image_processor.numpy_to_pil(image)
        # 用feature_extractor（CLIPImageProcessor）提取特征
        safety_checker_input = self.feature_extractor(feature_extractor_input, return_tensors="pt").to(device)
        # 安全检查
        image, has_nsfw_concept = self.safety_checker(
            images=image, clip_input=safety_checker_input.pixel_values.to(dtype)
        )
    return image, has_nsfw_concept

准备调度器额外的关键参数，eta和generator。

def prepare_extra_step_kwargs(self, generator, eta):
    # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
    # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
    # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
    # and should be between [0, 1]
    
    # 检查调度器函数是否有'eta'关键字，只有DDIM要用
    accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
    extra_step_kwargs = {}
    if accepts_eta:
        extra_step_kwargs["eta"] = eta
    
    # 检查调度器函数是否有'generator'关键字
    # check if the scheduler accepts generator
    accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
    if accepts_generator:
        extra_step_kwargs["generator"] = generator
    return extra_step_kwargs

检查输入是否正确

def check_inputs(
    self,
    prompt, # 提示词
    height, # 图像高
    width,  # 图像宽
    callback_steps, # 表示在进行模型推断过程中，每经过callback_steps个步骤后，会执行一次回调操作。回调操作可以是对模型状态的检查、记录或其他自定义操作，用于监控和控制模型的行为。
    negative_prompt=None, # 负向词
    prompt_embeds=None, # 指定提示词embed
    negative_prompt_embeds=None, # 指定负向词embed
    callback_on_step_end_tensor_inputs=None, # 指定在每个步骤结束时要传递给回调函数的张量输入。
):
    # 长宽需8的倍数
    if height % 8 != 0 or width % 8 != 0:
        raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.")
    
    # callback_steps需正整数
    if callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0):
        raise ValueError(
            f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
            f" {type(callback_steps)}."
        )
      
    # callback_on_step_end_tensor_inputs必须在self._callback_tensor_inputs中
    # _callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds"]
    if callback_on_step_end_tensor_inputs is not None and not all(
        k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs
    ):
        raise ValueError(
            f"`callback_on_step_end_tensor_inputs` has to be in {self._callback_tensor_inputs}, but found {[k for k in callback_on_step_end_tensor_inputs if k not in self._callback_tensor_inputs]}"
        )
     
    # 提示词和提示词embed必须一个非空一个为空，且提示词必须是str或者list格式
    if prompt is not None and prompt_embeds is not None:
        raise ValueError(
            f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
            " only forward one of the two."
        )
    elif prompt is None and prompt_embeds is None:
        raise ValueError(
            "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
        )
    elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
        raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
    
    # 负向提示词和负向提示词embed不能同时有
    if negative_prompt is not None and negative_prompt_embeds is not None:
        raise ValueError(
            f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:"
            f" {negative_prompt_embeds}. Please make sure to only forward one of the two."
        )
     
    # 提示词的shape和负向提示词的shape要一样 
    if prompt_embeds is not None and negative_prompt_embeds is not None:
        if prompt_embeds.shape != negative_prompt_embeds.shape:
            raise ValueError(
                "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
                f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`"
                f" {negative_prompt_embeds.shape}."

准备潜变量，用于StableDiffusion模型的推断过程。

def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype, device, generator, latents=None):
    """
    Args:
        generator:torch的随机数生成器
    """
    # 定义潜变量的shape， self.vae_scale_factor为VAE下采样倍数
    shape = (batch_size, num_channels_latents, height // self.vae_scale_factor, width // self.vae_scale_factor)
    
    # 如果generator不是list或者长度不等于batch_size，报错
    if isinstance(generator, list) and len(generator) != batch_size:
        raise ValueError(
            f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
            f" size of {batch_size}. Make sure the batch size matches the length of the generators."
        )
    
    # 若潜变量为空，则随机生成高斯噪声。不为空，则直接用
    if latents is None:
        latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
    else:
        latents = latents.to(device)
 
    # scale the initial noise by the standard deviation required by the scheduler
    # 将初始化噪声乘以scheduler.init_noise_sigma，以缩放噪声的标准差。
    latents = latents * self.scheduler.init_noise_sigma
    return latents

628-776

这段代码定义了一个enable_freeu方法，用于启用Unet的FreeU机制。FreeU机制是一个用于增强去噪过程的方法.

该方法接受四个参数：

• s1：用于衰减跳跃特征贡献的阶段1的缩放因子，用于减轻增强去噪过程中的“过度平滑效应”。
• s2：用于衰减跳跃特征贡献的阶段2的缩放因子，用于减轻增强去噪过程中的“过度平滑效应”。
• b1：用于放大主干特征贡献的阶段1的缩放因子。
• b2：用于放大主干特征贡献的阶段2的缩放因子。

• def enable_freeu(self, s1: float, s2: float, b1: float, b2: float):
      r"""Enables the FreeU mechanism as in https://arxiv.org/abs/2309.11497.
      The suffixes after the scaling factors represent the stages where they are being applied.
      Please refer to the [official repository](https://github.com/ChenyangSi/FreeU) for combinations of the values
      that are known to work well for different pipelines such as Stable Diffusion v1, v2, and Stable Diffusion XL.
      Args:
          s1 (`float`):
              Scaling factor for stage 1 to attenuate the contributions of the skip features. This is done to
              mitigate "oversmoothing effect" in the enhanced denoising process.
          s2 (`float`):
              Scaling factor for stage 2 to attenuate the contributions of the skip features. This is done to
              mitigate "oversmoothing effect" in the enhanced denoising process.
          b1 (`float`): Scaling factor for stage 1 to amplify the contributions of backbone features.
          b2 (`float`): Scaling factor for stage 2 to amplify the contributions of backbone features.
      """
      if not hasattr(self, "unet"):
          raise ValueError("The pipeline must have `unet` for using FreeU.")
      self.unet.enable_freeu(s1=s1, s2=s2, b1=b1, b2=b2)
   
   
  # 关闭freeu方法
  def disable_freeu(self):
      """Disables the FreeU mechanism if enabled."""
      self.unet.disable_freeu()
  

  启用融合的qky投影。对于self attn，qkv都融合。对于cross-att，ky融合。

  具体来说，FusedAttnProcessor2_0使用更高效的矩阵乘法计算，将查询、键和值的投影矩阵合并为一个更大的投影矩阵，从而减少了计算的复杂度和内存消耗。

  # Copied from diffusers.pipelines.stable_diffusion_xl.pipeline_stable_diffusion_xl.StableDiffusionXLPipeline.fuse_qkv_projections
  def fuse_qkv_projections(self, unet: bool = True, vae: bool = True):
      """
      Enables fused QKV projections. For self-attention modules, all projection matrices (i.e., query,
      key, value) are fused. For cross-attention modules, key and value projection matrices are fused.
      <Tip warning={true}>
      This API is 
  声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/675277
  推荐阅读
  article一步步带你解锁Stable Diffusion：SD保姆级安装教程_sd安装教程...
  之前和小伙伴们说过后续也会开始分享 Stable Diffusion 的相关操作指南，不过之前也有分享过 Stable ...
                  
                      赞
  踩
  articlesd软件下载安装教程（Stable Diffusion绘画软件配置要求）_sd绘画软件...
  AIGC技术的未来发展前景广阔，随着人工智能技术的不断发展，AIGC技术也将不断提高。未来，AIGC技术将在游戏和计算领...
                  
                      赞
  踩
  article【stable diffusion】保姆级入门课程-Stable diffusion（SD）介绍与安...
  什么是AI绘画以及什么是stable diffusion_stable diffusion(sd)stable diff...
                  
                      赞
  踩
  articleAI绘画Stable Diffusion XL 可商用模型！写实艺术时尚摄影级真实感大模型推荐（附模...
  大家在使用AI绘画的时候，是不是遇到这种问题：收藏的模型确实很多，可商用的没几个，而今天阿威将给大家带来的这款写实艺术时...
                  
                      赞
  踩
  articleStable Diffusion教程|SD WebUI必备插件安装 菜鸟轻松成高手_stable-d...
  AIGC技术的未来发展前景广阔，随着人工智能技术的不断发展，AIGC技术也将不断提高。未来，AIGC技术将在游戏和计算领...
                  
                      赞
  踩
  articleStable Diffusion 系列教程 - 5 ControlNet_stable-diffus...
  单个ControlNet的大小在1.4G左右，上面为五个应用最为广泛的控制模型。ControINet之于整个AI绘画过程...
                  
                      赞
  踩
  articleDiffusion Model, Stable Diffusion, Stable Diffusio...
  常见的生成模型有：文生图模型的基本架构如下：衡量图像生成质量的指标基于上述思想，Denoising diffusion ...
                  
                      赞
  踩
  articleStable Diffusion超详细教程！从0-1入门到进阶_小程序集成stable diffus...
  目前市面上比较权威，并能用于工作中的AI绘画软件其实就两款。一个叫Midjourney（简称MJ），另一个叫Stable...
                  
                      赞
  踩
  articleStable Diffusion之最全详解图解...
  Stable Diffusion是2022年发布的深度学习文本到图像生成模型。它主要用于根据文本的描述产生详细图像，尽管...
                  
                      赞
  踩
  article【2024版】最新保姆级stable diffusion安装教程，小白直接点！一键安装，永久使用，s...
  从图中可看出，与 AMD 或英特尔的任何产品相比，Nvidia 的 GPU 提供了卓越的性能–有时是以巨大的优势。关于现...
                  
                      赞
  踩
  articlestable diffusion 小白最全详细使用教程_stable diffusion使用...
  稳定扩散算法（stable diffusion）可以应用于图像处理中的许多问题，例如图像去噪、图像分割、图像增强和图像恢...
                  
                      赞
  踩
  articleStable Diffusion简单食用方法...
  1.1打开B站哔哩哔哩 (゜-゜)つロ 干杯~-bilibili哔哩哔哩（bilibili.com)是国内知名的视频弹幕...
                  
                      赞
  踩
  articleInsCode Stable Diffusion使用教程（非常详细）从零基础入门到精通，看完这一篇就...
  第一部分：界面最上端可以选择模型文件，InsCode 上面提供了几个常用模型，如 chilloutmix、GuoFeng...
                  
                      赞
  踩
  articleStable Diffusion入门完整版指南，保姆级教程！干货满满，建议收藏！...
  Stable Diffusion入门完整版指南，保姆级教程！干货满满，建议收藏！Stable Diffusion入门完整...
                  
                      赞
  踩
  article完全详细教程：Stable Diffusion ComfyUI本地部署_stablediffusio...
  Stable Diffusion ComfyUI 是一款基于开源 Stable Diffusion 文本转图像模型的本地...
                  
                      赞
  踩
  articleStable Diffusion入门使用技巧及个人试用实例分享--SD提示词及ControlNet篇...
  ControlNet是斯坦福大学研究人员开发的Stable Diffusion的扩展，使创作者能够轻松地控制AI图像和视...
                  
                      赞
  踩
  articleStable Diffusion【插件篇】：智能标签提示词插件sd-danbooru-tags-up...
  AIGC技术的未来发展前景广阔，随着人工智能技术的不断发展，AIGC技术也将不断提高。未来，AIGC技术将在游戏和计算领...
                  
                      赞
  踩
  articleStable Diffusion | 万万没想到，SD最潮的提示词插件竟然是它！...
  在使用一个lora模型，或者需要多种不同状态的时候，需要每次都输入不同的关键词进行替换，还挺耗时间的，当然有人说可以用之...
                  
                      赞
  踩
  articleStable Diffusion提示词篇...
  篇幅有限，这里就不一一展示了，有需要的朋友可以点击下方的卡片进行领取！有需要的朋友，可以点击下方卡片免费领取！_stab...
                  
                      赞
  踩
  articleStable Diffusion 最强提示词手册，图片、提示词、参数都有，赶紧码住_stable d...
  提示词，我一般又称它为暗示词，暗示给AI你想表达的意思，写这个不能像领导布置任务那样，说一半留一半，不然AI没法懂你想要...
                  
                      赞
  踩
  相关标签
  stable diffusion
  scrapy
  开发语言
  数据分析
  爬虫
  AI作画
  midjourney
  SD插件分享
  人工智能
  ai绘画
  AIGC
  大模型
  AI教程
  干货分享
  SD安装教程
  diffusion
  DDPM
  AI绘画
  AI绘画教程
  

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号