Diffuser库Stable_diffusion pipeline代码逐行解析（喂饭级别）_runtimeerror: failed to import diffusers.pipelines

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

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/很楠不爱3/article/detail/524263
  推荐阅读
  articleRedis系列(十八)、Redis中的管道pipeline操作(Python)_redis pipe...
  Redis默认每次执行请求都会创建和断开一次连接池的操作，如果想执行多条命令的时候会在这件事情上消耗过多的时间，因此我们...
                  
                      赞
  踩
  articleStable Diffusion XL之使用Stable Diffusion XL训练自己的AI绘画...
  其中config_file.toml文件中的配置文件包含了sdxl_arguments，model_arguments，...
                  
                      赞
  踩
  article(含代码)利用NVIDIA Triton加速Stable Diffusion XL推理速度_sd推理...
  在 NVIDIA AI 推理平台上部署 SDXL 可为企业提供可扩展、可靠且经济高效的解决方案。TensorRT 和 T...
                  
                      赞
  踩
  articlestable diffusion 1.5大模型炼制详细教程，几块钱即可炼制大模型...
  之前已经讲过SDXL_LORA,SD1.5_LORA训练过程，基本说的比较清楚了，有兴趣可以去看看，下面我将讲解一下SD...
                  
                      赞
  踩
  articleStable Diffusion中的embedding...
  嵌入，也称为文本反转，是在 Stable Diffusion 中控制图像样式的另一种方法。在这篇文章中，我们将学习什么是...
                  
                      赞
  踩
  article深入浅出解析Stable Diffusion XL完整核心基础知识 | 【算法兵器谱】...
  详解Stable Diffusion XL核心基础知识，包含各模块网络结构图。_stable diffusion xls...
                  
                      赞
  踩
  articleStable Diffusion XL 带来哪些新东西？...
  前几天写了一篇小短文《 Stable Diffusion 即将发布全新版本》，很快，Stability AI 的创始人兼...
                  
                      赞
  踩
  articleStable Diffusion升级版SDXL，一键运行包和18G模型分享！...
  今天主要分享两个东西，一个是ComfyUI软件包，一个是SDXL的两个模型。有这两个东西就可以快速出图了先来简单介绍一下...
                  
                      赞
  踩
  articleStable Diffusion XL 现已推出——有什么新功能？...
  今天，Stability AI的创始人兼首席执行官Emad Mostaque宣布，Stable Diffusion XL...
                  
                      赞
  踩
  articleCES 2024的亮点仅仅聚焦AI深度赋能和产业创新吗？｜ DALL-E 3、Stable Diff...
  CES作为颇具影响力的科技展览，展示芯片硬件到终端应用的全方位科技成果，涉及AI、VR、消费电子、汽车电子和智能家居等领...
                  
                      赞
  踩
  article海外三大AI图片生成器对比（Stable Diffusion、Midjourney、DALL·E 3...
  海外三大AI图片生成器对比：Stable Diffusion、Midjourney、DALL·E 3海外三大AI图片生成...
                  
                      赞
  踩
  articleAI绘画必看，一次弄懂所有技术名词 | Stable Diffusion、Midjourney、Da...
  本文介绍了时下最流行的AI绘图工具和模型训练方法以及一些 AI 绘图相关的技术名词，包括 Stable Diffusio...
                  
                      赞
  踩
  article图像生成模型浅析（Stable Diffusion、DALL-E、Imagen）_stable-di...
  图像生成模型浅析（Stable Diffusion、DALL-E、Imagen）_stable-diffusion-im...
                  
                      赞
  踩
  articleStable Diffusion 3 终于来了，性能碾压Midjourney、DALL·E...
  4月17日，在Stable Diffusion 3技术报告发布几个月后，Stability AI终于正式发布Stable...
                  
                      赞
  踩
  article新智元 | Stable Diffusion 3技术报告流出，Sora构架再立大功！生图圈开源暴打M...
  Stability AI放出了号称能暴打闭源模型的Stable Diffusion 3的技术报告，采用DiT构架的新模型...
                  
                      赞
  踩
  article如何让Midjourney， Stable Diffusion XL, Dall.E根据用户中文要求...
  随着AIGC应用的逐步深入，大家也开始逐渐将文生图大模型集成到自家的产品中，以求让自己的产品在竞争中更加突出。日月摘星针...
                  
                      赞
  踩
  articleAIGC：Stable Diffusion、DALL-E、Imagen框架介绍_imagen介绍...
  此处需要注意，去噪的过程是「随机高斯噪音」逐步变成「最终 Latent Representation」的过程，该过程中的...
                  
                      赞
  踩
  articleAI图像模型的深度分析：DALL·E 3、Google Imagen2、Stable Diffusi...
  本文深入分析了四个主要的 AI 图像生成模型——DALL·E 3、Google Imagen2、Stable Diffu...
                  
                      赞
  踩
  articleAI绘画工具使用指南：Midjourny、Stable Diffusion、DALL·E的使用_如何...
  最近尝试了一些AI绘画工具和在线网站，包括：Midjourny，OpenAI的DALL·E以及Stable Diffus...
                  
                      赞
  踩
  article【持续更新中】基于zynq的数控机床控制板ethercat，igh库开发，qt开发图像显示_ethe...
  硬件：7010，实体机windows10（vivado2018.3），实体机ubuntu16（petalinux）背景引...
                  
                      赞
  踩
  相关标签
  Redis
  管道
  pipeline
  script
  事务
  stable diffusion
  AI作画
  人工智能
  NVIDIA
  GPU
  AIGC
  TensorRT
  Triton
  embedding
  计算机视觉
  程序那些事
  深度学习
  机器学习
  AI绘画
  算法工程师
  

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

  

闽ICP备14008679号