Hugging Face 的 LOGO

AWS Trainium & Inferentia 文档

模型

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

模型

通用模型类

NeuronTracedModel

NeuronTracedModel 类可用于实例化一个没有特定头的基本 Neuron 模型。它被用作除文本生成外所有任务的基类。

class optimum.neuron.NeuronTracedModel

< >

( model: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_file_name: str | None = None preprocessors: list | None = None neuron_config: NeuronDefaultConfig | None = None **kwargs )

在 Neuron 设备上运行已编译和优化模型的基类。

它实现了与 Hugging Face Hub 交互的通用方法，以及将原生 transformers 模型编译为 neuron 优化的 TorchScript 模块并使用 optimum.exporters.neuron 工具链导出。

类属性

  • model_type (str, 可选, 默认为 "neuron_model") — 注册 NeuronTracedModel 类时要使用的模型类型名称。
  • auto_model_class (Type, 可选, 默认为 AutoModel) — 当前 NeuronTracedModel 类所代表的 AutoModel 类。

通用属性

  • model (torch.jit._script.ScriptModule) — 已加载的为 neuron 设备编译的 ScriptModule。
  • config (PretrainedConfig) — 模型的配置。
  • model_save_dir (Path) — 保存 neuron 编译模型的目录。默认情况下，如果加载的模型是本地的，将使用原始模型所在的目录。否则，将使用缓存目录。

can_generate

< >

( )

返回此模型是否可以使用 ` .generate()` 生成序列。

get_input_static_shapes

< >

( neuron_config: NeuronDefaultConfig )

获取一个包含输入及其有效静态形状的字典。

load_model

< >

( path: str | pathlib.Path to_neuron: bool = False device_id: int = 0 )

参数

  • path (str | Path) — 编译模型的路径。
  • to_neuron (bool, 默认为 False) — 是否手动将跟踪模型移动到 NeuronCore。仅在 `inline_weights_to_neff=False` 时需要，否则它会自动加载到 Neuron 设备。
  • device_id (int, 默认为 0) — 要加载跟踪模型的 NeuronCore 的索引。

加载由 neuron(x)-cc 编译器编译的 TorchScript 模块。它将首先加载到 CPU，然后移动到一个或多个 NeuronCore。

remove_padding

< >

( outputs: list[torch.Tensor] dims: list[int] indices: list[int] padding_side: typing.Literal['right', 'left'] = 'right' )

参数

  • outputs (list[torch.Tensor]) — torch 张量列表，即推理输出。
  • dims (list[int]) — 我们切片张量的维度列表。
  • indices (list[int]) — 我们沿轴切片张量的索引列表。
  • padding_side (Literal["right", "left"], 默认为 “right”) — 应用填充的一侧。

从输出张量中移除填充。

自然语言处理

以下 Neuron 模型类可用于自然语言处理任务。

NeuronModelForFeatureExtraction

class optimum.neuron.NeuronModelForFeatureExtraction

< >

( model: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_file_name: str | None = None preprocessors: list | None = None neuron_config: NeuronDefaultConfig | None = None **kwargs )

参数

  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。用配置文件初始化不会加载与模型相关的权重，只加载配置。请查看 optimum.neuron.modeling.NeuronTracedModel.from_pretrained 方法来加载模型权重。
  • model (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是由 neuron(x) 编译器编译并嵌入了 NEFF (Neuron 可执行文件格式) 的 TorchScript 模块。

用于特征提取任务的 Neuron 模型，带有 BaseModelOutput。

此模型继承自 ~neuron.modeling.NeuronTracedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存）。

在 Neuron 设备上进行特征提取的模型。

forward

< >

( input_ids: Tensor attention_mask: Tensor token_type_ids: torch.Tensor | None = None **kwargs )

参数

  • input_ids (torch.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是 input ID？
  • attention_mask (torch.Tensor | None，形状为 (batch_size, sequence_length)，默认为 None) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值在 `[0, 1]` 中选择：
  • token_type_ids (torch.Tensor | None，形状为 (batch_size, sequence_length)，默认为 None) — 分段 token 索引，用于指示输入的第一部分和第二部分。索引在 `[0, 1]` 中选择：

NeuronModelForFeatureExtraction 的 forward 方法覆盖了 `__call__` 特殊方法。仅接受编译步骤中跟踪的输入。推理期间提供的任何额外输入都将被忽略。要包含额外输入，请重新编译模型并指定这些输入。

示例

>>> from transformers import AutoTokenizer
>>> from optimum.neuron import NeuronModelForFeatureExtraction

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/all-MiniLM-L6-v2-neuronx")
>>> model = NeuronModelForFeatureExtraction.from_pretrained("optimum/all-MiniLM-L6-v2-neuronx")

>>> inputs = tokenizer("Dear Evan Hansen is the winner of six Tony Awards.", return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> list(last_hidden_state.shape)
[1, 13, 384]

NeuronModelForSentenceTransformers

class optimum.neuron.NeuronModelForSentenceTransformers

< >

( model: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_file_name: str | None = None preprocessors: list | None = None neuron_config: NeuronDefaultConfig | None = None **kwargs )

参数

  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。用配置文件初始化不会加载与模型相关的权重，只加载配置。请查看 optimum.neuron.modeling.NeuronTracedModel.from_pretrained 方法来加载模型权重。
  • model (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是由 neuron(x) 编译器编译并嵌入了 NEFF (Neuron 可执行文件格式) 的 TorchScript 模块。

用于 Sentence Transformers 的 Neuron 模型。

此模型继承自 ~neuron.modeling.NeuronTracedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存）。

在 Neuron 设备上运行的 Sentence Transformers 模型。

forward

< >

( input_ids: Tensor attention_mask: Tensor pixel_values: torch.Tensor | None = None token_type_ids: torch.Tensor | None = None **kwargs )

参数

  • input_ids (torch.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是 input ID？
  • attention_mask (torch.Tensor | None，形状为 (batch_size, sequence_length)，默认为 None) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值在 `[0, 1]` 中选择：
  • token_type_ids (torch.Tensor | None，形状为 (batch_size, sequence_length)，默认为 None) — 分段 token 索引，用于指示输入的第一部分和第二部分。索引在 `[0, 1]` 中选择：

NeuronModelForSentenceTransformers 的 forward 方法覆盖了 `__call__` 特殊方法。仅接受编译步骤中跟踪的输入。推理期间提供的任何额外输入都将被忽略。要包含额外输入，请重新编译模型并指定这些输入。

文本示例

>>> from transformers import AutoTokenizer
>>> from optimum.neuron import NeuronModelForSentenceTransformers

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/bge-base-en-v1.5-neuronx")
>>> model = NeuronModelForSentenceTransformers.from_pretrained("optimum/bge-base-en-v1.5-neuronx")

>>> inputs = tokenizer("In the smouldering promise of the fall of Troy, a mythical world of gods and mortals rises from the ashes.", return_tensors="pt")

>>> outputs = model(**inputs)
>>> token_embeddings = outputs.token_embeddings
>>> sentence_embedding = = outputs.sentence_embedding

图像示例

>>> from PIL import Image
>>> from transformers import AutoProcessor
>>> from sentence_transformers import util
>>> from optimum.neuron import NeuronModelForSentenceTransformers

>>> processor = AutoProcessor.from_pretrained("optimum/clip_vit_emb_neuronx")
>>> model = NeuronModelForSentenceTransformers.from_pretrained("optimum/clip_vit_emb_neuronx")
>>> util.http_get("https://github.com/UKPLab/sentence-transformers/raw/master/examples/sentence_transformer/applications/image-search/two_dogs_in_snow.jpg", "two_dogs_in_snow.jpg")
>>> inputs = processor(
>>>     text=["Two dogs in the snow", 'A cat on a table', 'A picture of London at night'], images=Image.open("two_dogs_in_snow.jpg"), return_tensors="pt", padding=True
>>> )

>>> outputs = model(**inputs)
>>> cos_scores = util.cos_sim(outputs.image_embeds, outputs.text_embeds)  # Compute cosine similarities

NeuronModelForMaskedLM

class optimum.neuron.NeuronModelForMaskedLM

< >

( model: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_file_name: str | None = None preprocessors: list | None = None neuron_config: NeuronDefaultConfig | None = None **kwargs )

参数

  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。用配置文件初始化不会加载与模型相关的权重，只加载配置。请查看 optimum.neuron.modeling.NeuronTracedModel.from_pretrained 方法来加载模型权重。
  • model (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是由 neuron(x) 编译器编译并嵌入了 NEFF (Neuron 可执行文件格式) 的 TorchScript 模块。

用于掩码语言建模任务的 Neuron 模型，带有 MaskedLMOutput。

此模型继承自 ~neuron.modeling.NeuronTracedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存）。

在 Neuron 设备上运行的掩码语言模型。

forward

< >

( input_ids: Tensor attention_mask: Tensor token_type_ids: torch.Tensor | None = None **kwargs )

参数

  • input_ids (torch.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是 input ID？
  • attention_mask (torch.Tensor | None，形状为 (batch_size, sequence_length)，默认为 None) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值在 `[0, 1]` 中选择：
  • token_type_ids (torch.Tensor | None，形状为 (batch_size, sequence_length)，默认为 None) — 分段 token 索引，用于指示输入的第一部分和第二部分。索引在 `[0, 1]` 中选择：

NeuronModelForMaskedLM 的 forward 方法覆盖了 `__call__` 特殊方法。仅接受编译步骤中跟踪的输入。推理期间提供的任何额外输入都将被忽略。要包含额外输入，请重新编译模型并指定这些输入。

示例

>>> from transformers import AutoTokenizer
>>> from optimum.neuron import NeuronModelForMaskedLM

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/legal-bert-base-uncased-neuronx")
>>> model = NeuronModelForMaskedLM.from_pretrained("optimum/legal-bert-base-uncased-neuronx")

>>> inputs = tokenizer("This [MASK] Agreement is between General Motors and John Murray.", return_tensors="pt")

>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 13, 30522]

NeuronModelForSequenceClassification

class optimum.neuron.NeuronModelForSequenceClassification

< >

( model: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_file_name: str | None = None preprocessors: list | None = None neuron_config: NeuronDefaultConfig | None = None **kwargs )

参数

  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。用配置文件初始化不会加载与模型相关的权重，只加载配置。请查看 optimum.neuron.modeling.NeuronTracedModel.from_pretrained 方法来加载模型权重。
  • model (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是由 neuron(x) 编译器编译并嵌入了 NEFF (Neuron 可执行文件格式) 的 TorchScript 模块。

Neuron 模型带有一个序列分类/回归头（在池化输出之上加一个线性层），例如用于 GLUE 任务。

此模型继承自 ~neuron.modeling.NeuronTracedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存）。

在 Neuron 设备上运行的序列分类模型。

forward

< >

( input_ids: Tensor attention_mask: Tensor token_type_ids: torch.Tensor | None = None **kwargs )

参数

  • input_ids (torch.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是 input ID？
  • attention_mask (torch.Tensor | None，形状为 (batch_size, sequence_length)，默认为 None) — 用于避免对填充标记（padding token）的索引执行注意力机制的掩码。掩码值的取值范围为 [0, 1]：
  • token_type_ids (torch.Tensor | None，形状为 (batch_size, sequence_length)，默认为 None) — 分段标记索引，用于指示输入的第一部分和第二部分。索引的取值范围为 [0, 1]：

NeuronModelForSequenceClassification 的 forward 方法重写了 __call__ 特殊方法。它只接受在编译步骤中追踪的输入。在推理过程中提供的任何额外输入都将被忽略。要包含额外的输入，请使用指定的这些输入重新编译模型。

示例

>>> from transformers import AutoTokenizer
>>> from optimum.neuron import NeuronModelForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/distilbert-base-uncased-finetuned-sst-2-english-neuronx")
>>> model = NeuronModelForSequenceClassification.from_pretrained("optimum/distilbert-base-uncased-finetuned-sst-2-english-neuronx")

>>> inputs = tokenizer("Hamilton is considered to be the best musical of human history.", return_tensors="pt")

>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]

NeuronModelForQuestionAnswering

class optimum.neuron.NeuronModelForQuestionAnswering

< >

( model: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_file_name: str | None = None preprocessors: list | None = None neuron_config: NeuronDefaultConfig | None = None **kwargs )

参数

  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查阅 optimum.neuron.modeling.NeuronTracedModel.from_pretrained 方法以加载模型权重。
  • model (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是一个 TorchScript 模块，它内嵌了由 neuron(x) 编译器编译的 NEFF（Neuron 可执行文件格式）。

Neuron 模型带有一个 QuestionAnsweringModelOutput，用于处理如 SQuAD 等抽取式问答任务。

此模型继承自 ~neuron.modeling.NeuronTracedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存）。

在 Neuron 设备上运行的问答模型。

forward

< >

( input_ids: Tensor attention_mask: Tensor token_type_ids: torch.Tensor | None = None **kwargs )

参数

  • input_ids (torch.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。详情请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是输入 ID？
  • attention_mask (torch.Tensor | None，形状为 (batch_size, sequence_length)，默认为 None) — 用于避免对填充标记（padding token）的索引执行注意力机制的掩码。掩码值的取值范围为 [0, 1]：
  • token_type_ids (torch.Tensor | None，形状为 (batch_size, sequence_length)，默认为 None) — 分段标记索引，用于指示输入的第一部分和第二部分。索引的取值范围为 [0, 1]：

NeuronModelForQuestionAnswering 的 forward 方法重写了 __call__ 特殊方法。它只接受在编译步骤中追踪的输入。在推理过程中提供的任何额外输入都将被忽略。要包含额外的输入，请使用指定的这些输入重新编译模型。

示例

>>> import torch
>>> from transformers import AutoTokenizer
>>> from optimum.neuron import NeuronModelForQuestionAnswering

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/roberta-base-squad2-neuronx")
>>> model = NeuronModelForQuestionAnswering.from_pretrained("optimum/roberta-base-squad2-neuronx")

>>> question, text = "Are there wheelchair spaces in the theatres?", "Yes, we have reserved wheelchair spaces with a good view."
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> start_positions = torch.tensor([1])
>>> end_positions = torch.tensor([12])

>>> outputs = model(**inputs, start_positions=start_positions, end_positions=end_positions)
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logits

NeuronModelForTokenClassification

class optimum.neuron.NeuronModelForTokenClassification

< >

( model: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_file_name: str | None = None preprocessors: list | None = None neuron_config: NeuronDefaultConfig | None = None **kwargs )

参数

  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查阅 optimum.neuron.modeling.NeuronTracedModel.from_pretrained 方法以加载模型权重。
  • model (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是一个 TorchScript 模块，它内嵌了由 neuron(x) 编译器编译的 NEFF（Neuron 可执行文件格式）。

Neuron 模型在顶部带有一个标记分类头（在隐藏状态输出之上是一个线性层），例如用于命名实体识别（NER）任务。

此模型继承自 ~neuron.modeling.NeuronTracedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存）。

在 Neuron 设备上运行的标记分类模型。

forward

< >

( input_ids: Tensor attention_mask: Tensor token_type_ids: torch.Tensor | None = None **kwargs )

参数

  • input_ids (torch.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。详情请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是输入 ID？
  • attention_mask (torch.Tensor | None，形状为 (batch_size, sequence_length)，默认为 None) — 用于避免对填充标记（padding token）的索引执行注意力机制的掩码。掩码值的取值范围为 [0, 1]：
  • token_type_ids (torch.Tensor | None，形状为 (batch_size, sequence_length)，默认为 None) — 分段标记索引，用于指示输入的第一部分和第二部分。索引的取值范围为 [0, 1]：

NeuronModelForTokenClassification 的 forward 方法重写了 __call__ 特殊方法。它只接受在编译步骤中追踪的输入。在推理过程中提供的任何额外输入都将被忽略。要包含额外的输入，请使用指定的这些输入重新编译模型。

示例

>>> from transformers import AutoTokenizer
>>> from optimum.neuron import NeuronModelForTokenClassification

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/bert-base-NER-neuronx")
>>> model = NeuronModelForTokenClassification.from_pretrained("optimum/bert-base-NER-neuronx")

>>> inputs = tokenizer("Lin-Manuel Miranda is an American songwriter, actor, singer, filmmaker, and playwright.", return_tensors="pt")

>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 20, 9]

NeuronModelForMultipleChoice

class optimum.neuron.NeuronModelForMultipleChoice

< >

( model: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_file_name: str | None = None preprocessors: list | None = None neuron_config: NeuronDefaultConfig | None = None **kwargs )

参数

  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查阅 optimum.neuron.modeling.NeuronTracedModel.from_pretrained 方法以加载模型权重。
  • model (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是一个 TorchScript 模块，它内嵌了由 neuron(x) 编译器编译的 NEFF（Neuron 可执行文件格式）。

Neuron 模型在顶部带有一个多项选择分类头（在池化输出之上是一个线性层和一个 softmax），例如用于 RocStories/SWAG 任务。

此模型继承自 ~neuron.modeling.NeuronTracedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存）。

在 Neuron 设备上运行的多项选择模型。

forward

< >

( input_ids: Tensor attention_mask: Tensor token_type_ids: torch.Tensor | None = None **kwargs )

参数

  • input_ids (torch.Tensor，形状为 (batch_size, num_choices, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。详情请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是输入 ID？
  • attention_mask (torch.Tensor | None，形状为 (batch_size, num_choices, sequence_length)，默认为 None) — 用于避免对填充标记（padding token）的索引执行注意力机制的掩码。掩码值的取值范围为 [0, 1]：
  • token_type_ids (torch.Tensor | None，形状为 (batch_size, num_choices, sequence_length)，默认为 None) — 分段标记索引，用于指示输入的第一部分和第二部分。索引的取值范围为 [0, 1]：

NeuronModelForMultipleChoice 的 forward 方法重写了 __call__ 特殊方法。它只接受在编译步骤中追踪的输入。在推理过程中提供的任何额外输入都将被忽略。要包含额外的输入，请使用指定的这些输入重新编译模型。

示例

>>> from transformers import AutoTokenizer
>>> from optimum.neuron import NeuronModelForMultipleChoice

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/bert-base-uncased_SWAG-neuronx")
>>> model = NeuronModelForMultipleChoice.from_pretrained("optimum/bert-base-uncased_SWAG-neuronx")

>>> num_choices = 4
>>> first_sentence = ["Members of the procession walk down the street holding small horn brass instruments."] * num_choices
>>> second_sentence = [
...     "A drum line passes by walking down the street playing their instruments.",
...     "A drum line has heard approaching them.",
...     "A drum line arrives and they're outside dancing and asleep.",
...     "A drum line turns the lead singer watches the performance."
... ]
>>> inputs = tokenizer(first_sentence, second_sentence, truncation=True, padding=True)

# Unflatten the inputs values expanding it to the shape [batch_size, num_choices, seq_length]
>>> for k, v in inputs.items():
...     inputs[k] = [v[i: i + num_choices] for i in range(0, len(v), num_choices)]
>>> inputs = dict(inputs.convert_to_tensors(tensor_type="pt"))
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> logits.shape
[1, 4]

NeuronModelForCausalLM

class optimum.neuron.NeuronModelForCausalLM

< >

( model: PreTrainedModel config: PretrainedConfig )

带有因果语言模型头的 Neuron 模型，用于在 Neuron 设备上进行推理。

该模型继承自 ~neuron.NeuronModel。请查阅超类的文档，了解该库为所有模型实现的通用方法（如下载或保存）。

forward

< >

( *args **kwargs )

模型的前向传播，需要被重写。

NeuronModelForSeq2SeqLM

class optimum.neuron.NeuronModelForSeq2SeqLM

< >

( encoder: ScriptModule decoder: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None encoder_file_name: str | None = 'model.neuron' decoder_file_name: str | None = 'model.neuron' preprocessors: list | None = None neuron_configs: dict[str, 'NeuronDefaultConfig'] | None = None configs: dict[str, 'PretrainedConfig'] | None = None generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None **kwargs )

参数

  • encoder (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是编码器的 TorchScript 模块，它内嵌了由 neuron(x) 编译器编译的 NEFF（Neuron 可执行文件格式）。
  • decoder (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是解码器的 TorchScript 模块，它内嵌了由 neuron(x) 编译器编译的 NEFF（Neuron 可执行文件格式）。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查阅 optimum.neuron.modeling.NeuronTracedModel.from_pretrained 方法以加载模型权重。

Neuron 序列到序列模型，带有语言模型头，用于文本到文本生成任务。

此模型继承自 ~neuron.modeling.NeuronTracedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存）。

forward

< >

( attention_mask: torch.FloatTensor | None = None decoder_input_ids: torch.LongTensor | None = None decoder_attention_mask: torch.BoolTensor | None = None encoder_outputs: tuple[tuple[torch.Tensor]] | None = None beam_scores: torch.FloatTensor | None = None return_dict: bool = False output_attentions: bool = False output_hidden_states: bool = False )

参数

NeuronModelForSeq2SeqLM 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的流程需要在此函数内定义，但之后应调用 Module 实例而不是此函数，因为前者会处理预处理和后处理步骤，而后者会静默地忽略它们。

（以下模型使用 neuronx 编译器编译，只能在 INF2 上运行。）

文本到文本生成的示例

from transformers import AutoTokenizer
from optimum.neuron import NeuronModelForSeq2SeqLM
# export
neuron_model = NeuronModelForSeq2SeqLM.from_pretrained(google-t5/t5-small, export=True, dynamic_batch_size=False, batch_size=1, sequence_length=64, num_beams=4)
neuron_model.save_pretrained("t5_small_neuronx")
del neuron_model

# inference
neuron_model = NeuronModelForSeq2SeqLM.from_pretrained("t5_small_neuronx")
tokenizer = AutoTokenizer.from_pretrained("t5_small_neuronx")
inputs = tokenizer("translate English to German: Lets eat good food.", return_tensors="pt")

output = neuron_model.generate(
    **inputs,
    num_return_sequences=1,
)
results = [tokenizer.decode(t, skip_special_tokens=True) for t in output]

（对于大型模型，为了适应 Neuron 核心，我们需要应用张量并行。以下是在 inf2.24xlarge 上运行的示例。）

使用张量并行的文本到文本生成示例

from transformers import AutoTokenizer
from optimum.neuron import NeuronModelForSeq2SeqLM
# export
if __name__ == "__main__":  # compulsory for parallel tracing since the API will spawn multiple processes.
    neuron_model = NeuronModelForSeq2SeqLM.from_pretrained(
        google/flan-t5-xl, export=True, tensor_parallel_size=8, dynamic_batch_size=False, batch_size=1, sequence_length=128, num_beams=4,
    )
    neuron_model.save_pretrained("flan_t5_xl_neuronx_tp8")
    del neuron_model
# inference
neuron_model = NeuronModelForSeq2SeqLM.from_pretrained("flan_t5_xl_neuronx_tp8")
tokenizer = AutoTokenizer.from_pretrained("flan_t5_xl_neuronx_tp8")
inputs = tokenizer("translate English to German: Lets eat good food.", return_tensors="pt")

output = neuron_model.generate(
    **inputs,
    num_return_sequences=1,
)
results = [tokenizer.decode(t, skip_special_tokens=True) for t in output]

计算机视觉

以下 Neuron 模型类可用于计算机视觉任务。

NeuronModelForImageClassification

class optimum.neuron.NeuronModelForImageClassification

< >

( model: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_file_name: str | None = None preprocessors: list | None = None neuron_config: NeuronDefaultConfig | None = None **kwargs )

参数

  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查阅 optimum.neuron.modeling.NeuronTracedModel.from_pretrained 方法以加载模型权重。
  • model (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是一个 TorchScript 模块，它内嵌了由 neuron(x) 编译器编译的 NEFF（Neuron 可执行文件格式）。

Neuron 模型在顶部带有一个图像分类头（在 [CLS] 标记的最终隐藏状态之上是一个线性层），例如用于 ImageNet。

此模型继承自 ~neuron.modeling.NeuronTracedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存）。

用于图像分类任务的 Neuron 模型。该类正式支持 beit、convnext、convnextv2、deit、levit、mobilenet_v2、mobilevit、vit 等。

forward

< >

( pixel_values: Tensor **kwargs )

参数

  • pixel_values (torch.Tensor | None，形状为 (batch_size, num_channels, height, width)，默认为 None) — 与当前批次中图像相对应的像素值。可以使用 AutoImageProcessor 从编码图像中获取像素值。

NeuronModelForImageClassification 的 forward 方法重写了 __call__ 特殊方法。它只接受在编译步骤中追踪的输入。在推理过程中提供的任何额外输入都将被忽略。要包含额外的输入，请使用指定的这些输入重新编译模型。

示例

>>> import requests
>>> from PIL import Image
>>> from optimum.neuron import NeuronModelForImageClassification
>>> from transformers import AutoImageProcessor

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> preprocessor = AutoImageProcessor.from_pretrained("optimum/vit-base-patch16-224-neuronx")
>>> model = NeuronModelForImageClassification.from_pretrained("optimum/vit-base-patch16-224-neuronx")

>>> inputs = preprocessor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_label = logits.argmax(-1).item()

NeuronModelForSemanticSegmentation

class optimum.neuron.NeuronModelForSemanticSegmentation

< >

( model: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_file_name: str | None = None preprocessors: list | None = None neuron_config: NeuronDefaultConfig | None = None **kwargs )

参数

  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查阅 optimum.neuron.modeling.NeuronTracedModel.from_pretrained 方法以加载模型权重。
  • model (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是一个 TorchScript 模块，它内嵌了由 neuron(x) 编译器编译的 NEFF（Neuron 可执行文件格式）。

Neuron 模型在顶部带有一个语义分割头，例如用于 Pascal VOC。

此模型继承自 ~neuron.modeling.NeuronTracedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存）。

用于语义分割的 Neuron 模型，顶部带有一个全 MLP 解码头，例如用于 ADE20k、CityScapes。该类正式支持 mobilevit、mobilenet-v2 等。

forward

< >

( pixel_values: Tensor **kwargs )

参数

  • pixel_values (torch.Tensor | None，形状为 (batch_size, num_channels, height, width)，默认为 None) — 对应于当前批次中图像的像素值。像素值可以通过使用 AutoImageProcessor 从编码后的图像中获取。

NeuronModelForSemanticSegmentation 的 forward 方法会覆盖 __call__ 特殊方法。它只接受在编译步骤中追踪到的输入。在推理过程中提供的任何额外输入都将被忽略。要包含额外的输入，请使用指定的这些输入重新编译模型。

示例

>>> import requests
>>> from PIL import Image
>>> from optimum.neuron import NeuronModelForSemanticSegmentation
>>> from transformers import AutoImageProcessor

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> preprocessor = AutoImageProcessor.from_pretrained("optimum/deeplabv3-mobilevit-small-neuronx")
>>> model = NeuronModelForSemanticSegmentation.from_pretrained("optimum/deeplabv3-mobilevit-small-neuronx")

>>> inputs = preprocessor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> logits = outputs.logits

NeuronModelForObjectDetection

class optimum.neuron.NeuronModelForObjectDetection

< >

( model: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_file_name: str | None = None preprocessors: list | None = None neuron_config: NeuronDefaultConfig | None = None **kwargs )

参数

  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查阅 optimum.neuron.modeling.NeuronTracedModel.from_pretrained 方法来加载模型权重。
  • model (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是一个 TorchScript 模块，其中嵌入了由 neuron(x) 编译器编译的 NEFF（Neuron 可执行文件格式）。

带有目标检测头的 Neuron 模型，用于诸如 COCO 检测等任务。

此模型继承自 ~neuron.modeling.NeuronTracedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存）。

用于目标检测的 Neuron 模型，其顶部带有目标检测头，适用于诸如 COCO 检测等任务。

forward

< >

( pixel_values: Tensor **kwargs )

参数

  • pixel_values (torch.Tensor | None，形状为 (batch_size, num_channels, height, width)，默认为 None) — 对应于当前批次中图像的像素值。像素值可以通过使用 AutoImageProcessor 从编码后的图像中获取。

NeuronModelForObjectDetection 的 forward 方法会覆盖 __call__ 特殊方法。它只接受在编译步骤中追踪到的输入。在推理过程中提供的任何额外输入都将被忽略。要包含额外的输入，请使用指定的这些输入重新编译模型。

示例

>>> import requests
>>> from PIL import Image
>>> from optimum.neuron import NeuronModelForObjectDetection
>>> from transformers import AutoImageProcessor

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> preprocessor = AutoImageProcessor.from_pretrained("hustvl/yolos-tiny")
>>> model = NeuronModelForObjectDetection.from_pretrained("hustvl/yolos-tiny")

>>> inputs = preprocessor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.9, target_sizes=target_sizes)[0]

音频

以下 auto 类可用于下列音频任务。

NeuronModelForAudioClassification

class optimum.neuron.NeuronModelForAudioClassification

< >

( model: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_file_name: str | None = None preprocessors: list | None = None neuron_config: NeuronDefaultConfig | None = None **kwargs )

参数

  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查阅 optimum.neuron.modeling.NeuronTracedModel.from_pretrained 方法来加载模型权重。
  • model (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是一个 TorchScript 模块，其中嵌入了由 neuron(x) 编译器编译的 NEFF（Neuron 可执行文件格式）。

带有音频分类头的 Neuron 模型。

此模型继承自 ~neuron.modeling.NeuronTracedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存）。

用于音频分类的 Neuron 模型，其顶部带有一个序列分类头（在池化输出上加一个线性层），适用于像 SUPERB 关键词识别这样的任务。

forward

< >

( input_values: Tensor **kwargs )

参数

  • input_values (torch.Tensor，形状为 (batch_size, sequence_length)) — 输入原始语音波形的浮点值。输入值可以通过使用 AutoProcessor 将音频文件加载到数组中来获取。

NeuronModelForAudioClassification 的 forward 方法会覆盖 __call__ 特殊方法。它只接受在编译步骤中追踪到的输入。在推理过程中提供的任何额外输入都将被忽略。要包含额外的输入，请使用指定的这些输入重新编译模型。

示例

>>> from transformers import AutoProcessor
>>> from optimum.neuron import NeuronModelForAudioClassification
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoProcessor.from_pretrained("Jingya/wav2vec2-large-960h-lv60-self-neuronx-audio-classification")
>>> model = NeuronModelForAudioClassification.from_pretrained("Jingya/wav2vec2-large-960h-lv60-self-neuronx-audio-classification")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")

>>> logits = model(**inputs).logits
>>> predicted_class_ids = torch.argmax(logits, dim=-1).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]

NeuronModelForAudioFrameClassification

class optimum.neuron.NeuronModelForAudioFrameClassification

< >

( model: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_file_name: str | None = None preprocessors: list | None = None neuron_config: NeuronDefaultConfig | None = None **kwargs )

参数

  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查阅 optimum.neuron.modeling.NeuronTracedModel.from_pretrained 方法来加载模型权重。
  • model (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是一个 TorchScript 模块，其中嵌入了由 neuron(x) 编译器编译的 NEFF（Neuron 可执行文件格式）。

带有音频帧分类头的 Neuron 模型。

此模型继承自 ~neuron.modeling.NeuronTracedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存）。

带有帧分类头的 Neuron 模型，适用于像说话人日志（Speaker Diarization）这样的任务。

forward

< >

( input_values: Tensor **kwargs )

参数

  • input_values (torch.Tensor，形状为 (batch_size, sequence_length)) — 输入原始语音波形的浮点值。输入值可以通过使用 AutoProcessor 将音频文件加载到数组中来获取。

NeuronModelForAudioFrameClassification 的 forward 方法会覆盖 __call__ 特殊方法。它只接受在编译步骤中追踪到的输入。在推理过程中提供的任何额外输入都将被忽略。要包含额外的输入，请使用指定的这些输入重新编译模型。

示例

>>> from transformers import AutoProcessor
>>> from optimum.neuron import NeuronModelForAudioFrameClassification
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoProcessor.from_pretrained("Jingya/wav2vec2-base-superb-sd-neuronx")
>>> model =  NeuronModelForAudioFrameClassification.from_pretrained("Jingya/wav2vec2-base-superb-sd-neuronx")

>>> inputs = feature_extractor(dataset[0]["audio"]["array"], return_tensors="pt", sampling_rate=sampling_rate)
>>> logits = model(**inputs).logits

>>> probabilities = torch.sigmoid(logits[0])
>>> labels = (probabilities > 0.5).long()
>>> labels[0].tolist()

NeuronModelForCTC

class optimum.neuron.NeuronModelForCTC

< >

( model: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_file_name: str | None = None preprocessors: list | None = None neuron_config: NeuronDefaultConfig | None = None **kwargs )

参数

  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查阅 optimum.neuron.modeling.NeuronTracedModel.from_pretrained 方法来加载模型权重。
  • model (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是一个 TorchScript 模块，其中嵌入了由 neuron(x) 编译器编译的 NEFF（Neuron 可执行文件格式）。

带有连接主义时间分类（connectionist temporal classification）头的 Neuron 模型。

此模型继承自 ~neuron.modeling.NeuronTracedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存）。

带有用于连接主义时间分类（CTC）的语言建模头的 Neuron 模型。

forward

< >

( input_values: Tensor **kwargs )

参数

  • input_values (torch.Tensor，形状为 (batch_size, sequence_length)) — 输入原始语音波形的浮点值。输入值可以通过使用 AutoProcessor 将音频文件加载到数组中来获取。

NeuronModelForCTC 的 forward 方法会覆盖 __call__ 特殊方法。它只接受在编译步骤中追踪到的输入。在推理过程中提供的任何额外输入都将被忽略。要包含额外的输入，请使用指定的这些输入重新编译模型。

示例

>>> from transformers import AutoProcessor
>>> from optimum.neuron import NeuronModelForCTC
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("Jingya/wav2vec2-large-960h-lv60-self-neuronx-ctc")
>>> model = NeuronModelForCTC.from_pretrained("Jingya/wav2vec2-large-960h-lv60-self-neuronx-ctc")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> transcription = processor.batch_decode(predicted_ids)

使用 optimum.neuron.pipeline 的示例

>>> from transformers import AutoProcessor
>>> from optimum.neuron import NeuronModelForCTC, pipeline

>>> processor = AutoProcessor.from_pretrained("Jingya/wav2vec2-large-960h-lv60-self-neuronx-ctc")
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")

>>> model = NeuronModelForCTC.from_pretrained("Jingya/wav2vec2-large-960h-lv60-self-neuronx-ctc")
>>> asr = pipeline("automatic-speech-recognition", model=model, feature_extractor=processor.feature_extractor, tokenizer=processor.tokenizer)

NeuronModelForXVector

class optimum.neuron.NeuronModelForXVector

< >

( model: ScriptModule config: PretrainedConfig model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_file_name: str | None = None preprocessors: list | None = None neuron_config: NeuronDefaultConfig | None = None **kwargs )

参数

  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查阅 optimum.neuron.modeling.NeuronTracedModel.from_pretrained 方法来加载模型权重。
  • model (torch.jit._script.ScriptModule) — torch.jit._script.ScriptModule 是一个 TorchScript 模块，其中嵌入了由 neuron(x) 编译器编译的 NEFF（Neuron 可执行文件格式）。

带有 XVector 特征提取头的 Neuron 模型，用于像说话人验证这样的任务。

此模型继承自 ~neuron.modeling.NeuronTracedModel。请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存）。

带有 XVector 特征提取头的 Neuron 模型，用于像说话人验证这样的任务。

forward

< >

( input_values: Tensor **kwargs )

参数

  • input_values (torch.Tensor，形状为 (batch_size, sequence_length)) — 输入原始语音波形的浮点值。输入值可以通过使用 AutoProcessor 将音频文件加载到数组中来获取。

NeuronModelForXVector 的 forward 方法会覆盖 __call__ 特殊方法。它只接受在编译步骤中追踪到的输入。在推理过程中提供的任何额外输入都将被忽略。要包含额外的输入，请使用指定的这些输入重新编译模型。

示例

>>> from transformers import AutoProcessor
>>> from optimum.neuron import NeuronModelForXVector
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoProcessor.from_pretrained("Jingya/wav2vec2-base-superb-sv-neuronx")
>>> model = NeuronModelForXVector.from_pretrained("Jingya/wav2vec2-base-superb-sv-neuronx")

>>> inputs = feature_extractor(
...     [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
... )
>>> embeddings = model(**inputs).embeddings

>>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1)

>>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
>>> similarity = cosine_sim(embeddings[0], embeddings[1])
>>> threshold = 0.7
>>> if similarity < threshold:
...     print("Speakers are not the same!")
>>> round(similarity.item(), 2)

Stable Diffusion

以下 Neuron 模型类可用于 Stable Diffusion 任务。

NeuronStableDiffusionPipeline

class optimum.neuron.NeuronStableDiffusionPipeline

< >

( config: dict[str, typing.Any] configs: dict[str, 'PretrainedConfig'] neuron_configs: dict[str, 'NeuronDefaultConfig'] data_parallel_mode: typing.Literal['none', 'unet', 'transformer', 'all'] scheduler: diffusers.schedulers.scheduling_utils.SchedulerMixin | None vae_decoder: torch.jit._script.ScriptModule | NeuronModelVaeDecoder text_encoder: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None text_encoder_2: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None unet: torch.jit._script.ScriptModule | NeuronModelUnet | None = None transformer: torch.jit._script.ScriptModule | NeuronModelTransformer | None = None vae_encoder: torch.jit._script.ScriptModule | NeuronModelVaeEncoder | None = None image_encoder: torch.jit._script.ScriptModule | None = None safety_checker: torch.jit._script.ScriptModule | None = None tokenizer: transformers.models.clip.tokenization_clip.CLIPTokenizer | transformers.models.t5.tokenization_t5.T5Tokenizer | None = None tokenizer_2: transformers.models.clip.tokenization_clip.CLIPTokenizer | None = None feature_extractor: transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor | None = None controlnet: torch.jit._script.ScriptModule | list[torch.jit._script.ScriptModule]| NeuronControlNetModel | NeuronMultiControlNetModel | None = None requires_aesthetics_score: bool = False force_zeros_for_empty_prompt: bool = True add_watermarker: bool | None = None model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_and_config_save_paths: dict[str, tuple[str, pathlib.Path]] | None = None )

__call__

< >

( *args **kwargs )

NeuronStableDiffusionImg2ImgPipeline

class optimum.neuron.NeuronStableDiffusionImg2ImgPipeline

< >

( config: dict[str, typing.Any] configs: dict[str, 'PretrainedConfig'] neuron_configs: dict[str, 'NeuronDefaultConfig'] data_parallel_mode: typing.Literal['none', 'unet', 'transformer', 'all'] scheduler: diffusers.schedulers.scheduling_utils.SchedulerMixin | None vae_decoder: torch.jit._script.ScriptModule | NeuronModelVaeDecoder text_encoder: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None text_encoder_2: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None unet: torch.jit._script.ScriptModule | NeuronModelUnet | None = None transformer: torch.jit._script.ScriptModule | NeuronModelTransformer | None = None vae_encoder: torch.jit._script.ScriptModule | NeuronModelVaeEncoder | None = None image_encoder: torch.jit._script.ScriptModule | None = None safety_checker: torch.jit._script.ScriptModule | None = None tokenizer: transformers.models.clip.tokenization_clip.CLIPTokenizer | transformers.models.t5.tokenization_t5.T5Tokenizer | None = None tokenizer_2: transformers.models.clip.tokenization_clip.CLIPTokenizer | None = None feature_extractor: transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor | None = None controlnet: torch.jit._script.ScriptModule | list[torch.jit._script.ScriptModule]| NeuronControlNetModel | NeuronMultiControlNetModel | None = None requires_aesthetics_score: bool = False force_zeros_for_empty_prompt: bool = True add_watermarker: bool | None = None model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_and_config_save_paths: dict[str, tuple[str, pathlib.Path]] | None = None )

__call__

< >

( *args **kwargs )

NeuronStableDiffusionInpaintPipeline

class optimum.neuron.NeuronStableDiffusionInpaintPipeline

< >

( config: dict[str, typing.Any] configs: dict[str, 'PretrainedConfig'] neuron_configs: dict[str, 'NeuronDefaultConfig'] data_parallel_mode: typing.Literal['none', 'unet', 'transformer', 'all'] scheduler: diffusers.schedulers.scheduling_utils.SchedulerMixin | None vae_decoder: torch.jit._script.ScriptModule | NeuronModelVaeDecoder text_encoder: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None text_encoder_2: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None unet: torch.jit._script.ScriptModule | NeuronModelUnet | None = None transformer: torch.jit._script.ScriptModule | NeuronModelTransformer | None = None vae_encoder: torch.jit._script.ScriptModule | NeuronModelVaeEncoder | None = None image_encoder: torch.jit._script.ScriptModule | None = None safety_checker: torch.jit._script.ScriptModule | None = None tokenizer: transformers.models.clip.tokenization_clip.CLIPTokenizer | transformers.models.t5.tokenization_t5.T5Tokenizer | None = None tokenizer_2: transformers.models.clip.tokenization_clip.CLIPTokenizer | None = None feature_extractor: transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor | None = None controlnet: torch.jit._script.ScriptModule | list[torch.jit._script.ScriptModule]| NeuronControlNetModel | NeuronMultiControlNetModel | None = None requires_aesthetics_score: bool = False force_zeros_for_empty_prompt: bool = True add_watermarker: bool | None = None model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_and_config_save_paths: dict[str, tuple[str, pathlib.Path]] | None = None )

__call__

< >

( *args **kwargs )

NeuronLatentConsistencyModelPipeline

class optimum.neuron.NeuronLatentConsistencyModelPipeline

< >

( config: dict[str, typing.Any] configs: dict[str, 'PretrainedConfig'] neuron_configs: dict[str, 'NeuronDefaultConfig'] data_parallel_mode: typing.Literal['none', 'unet', 'transformer', 'all'] scheduler: diffusers.schedulers.scheduling_utils.SchedulerMixin | None vae_decoder: torch.jit._script.ScriptModule | NeuronModelVaeDecoder text_encoder: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None text_encoder_2: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None unet: torch.jit._script.ScriptModule | NeuronModelUnet | None = None transformer: torch.jit._script.ScriptModule | NeuronModelTransformer | None = None vae_encoder: torch.jit._script.ScriptModule | NeuronModelVaeEncoder | None = None image_encoder: torch.jit._script.ScriptModule | None = None safety_checker: torch.jit._script.ScriptModule | None = None tokenizer: transformers.models.clip.tokenization_clip.CLIPTokenizer | transformers.models.t5.tokenization_t5.T5Tokenizer | None = None tokenizer_2: transformers.models.clip.tokenization_clip.CLIPTokenizer | None = None feature_extractor: transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor | None = None controlnet: torch.jit._script.ScriptModule | list[torch.jit._script.ScriptModule]| NeuronControlNetModel | NeuronMultiControlNetModel | None = None requires_aesthetics_score: bool = False force_zeros_for_empty_prompt: bool = True add_watermarker: bool | None = None model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_and_config_save_paths: dict[str, tuple[str, pathlib.Path]] | None = None )

__call__

< >

( *args **kwargs )

NeuronStableDiffusionControlNetPipeline

class optimum.neuron.NeuronStableDiffusionControlNetPipeline

< >

( config: dict[str, typing.Any] configs: dict[str, 'PretrainedConfig'] neuron_configs: dict[str, 'NeuronDefaultConfig'] data_parallel_mode: typing.Literal['none', 'unet', 'transformer', 'all'] scheduler: diffusers.schedulers.scheduling_utils.SchedulerMixin | None vae_decoder: torch.jit._script.ScriptModule | NeuronModelVaeDecoder text_encoder: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None text_encoder_2: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None unet: torch.jit._script.ScriptModule | NeuronModelUnet | None = None transformer: torch.jit._script.ScriptModule | NeuronModelTransformer | None = None vae_encoder: torch.jit._script.ScriptModule | NeuronModelVaeEncoder | None = None image_encoder: torch.jit._script.ScriptModule | None = None safety_checker: torch.jit._script.ScriptModule | None = None tokenizer: transformers.models.clip.tokenization_clip.CLIPTokenizer | transformers.models.t5.tokenization_t5.T5Tokenizer | None = None tokenizer_2: transformers.models.clip.tokenization_clip.CLIPTokenizer | None = None feature_extractor: transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor | None = None controlnet: torch.jit._script.ScriptModule | list[torch.jit._script.ScriptModule]| NeuronControlNetModel | NeuronMultiControlNetModel | None = None requires_aesthetics_score: bool = False force_zeros_for_empty_prompt: bool = True add_watermarker: bool | None = None model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_and_config_save_paths: dict[str, tuple[str, pathlib.Path]] | None = None )

__call__

< >

( prompt: str | list[str] | None = None image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, typing.List[PIL.Image.Image], typing.List[numpy.ndarray], typing.List[torch.Tensor]] = None num_inference_steps: int = 50 timesteps: list[int] | None = None sigmas: list[float] | None = None guidance_scale: float = 7.5 negative_prompt: str | list[str] | None = None num_images_per_prompt: int | None = 1 eta: float = 0.0 generator: torch._C.Generator | list[torch._C.Generator] | None = None latents: torch.Tensor | None = None prompt_embeds: torch.Tensor | None = None negative_prompt_embeds: torch.Tensor | None = None ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, typing.List[PIL.Image.Image], typing.List[numpy.ndarray], typing.List[torch.Tensor], NoneType] = None ip_adapter_image_embeds: list[torch.Tensor] | None = None output_type: str = 'pil' return_dict: bool = True cross_attention_kwargs: dict[str, typing.Any] | None = None controlnet_conditioning_scale: float | list[float] = 1.0 guess_mode: bool = False control_guidance_start: float | list[float] = 0.0 control_guidance_end: float | list[float] = 1.0 clip_skip: int | None = None callback_on_step_end: typing.Union[typing.Callable[[int, int, dict], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None callback_on_step_end_tensor_inputs: list[str] = ['latents'] **kwargs ) → diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput 或 tuple

参数

  • prompt (str | list[str] | None，默认为 None) — 用于指导图像生成的提示或提示列表。如果未定义，则需要传递 prompt_embeds。
  • image ("PipelineImageInput" | None，默认为 None) — ControlNet 的输入条件，用于为 unet 的生成提供指导。如果类型指定为 torch.Tensor，它将按原样传递给 ControlNet。PIL.Image.Image 也可以作为图像被接受。输出图像的尺寸默认为 `image` 的尺寸。如果传递了高度和/或宽度，`image` 会相应地调整大小。如果在 `init` 中指定了多个 ControlNet，则图像必须作为列表传递，以便列表中的每个元素都可以正确地批处理以输入到单个 ControlNet 中。当 `prompt` 是一个列表时，如果为单个 ControlNet 传递了一个图像列表，每个图像将与 `prompt` 列表中的每个提示配对。这也适用于多个 ControlNet，其中可以传递图像列表的列表，以便为每个提示和每个 ControlNet 进行批处理。
  • num_inference_steps (int，默认为 50) — 去噪步数。更多的去噪步数通常会带来更高质量的图像，但代价是推理速度变慢。
  • timesteps (list[int] | None，默认为 None) — 用于去噪过程的自定义时间步，适用于在其 set_timesteps 方法中支持 timesteps 参数的调度器。如果未定义，将使用传递 num_inference_steps 时的默认行为。必须按降序排列。
  • sigmas (list[int] | None，默认为 None) — 用于去噪过程的自定义 sigma 值，适用于在其 set_timesteps 方法中支持 sigmas 参数的调度器。如果未定义，将使用传递 num_inference_steps 时的默认行为。
  • guidance_scale (float，默认为 7.5) — 更高的引导比例值会鼓励模型生成与文本 prompt 紧密相关的图像，但代价是图像质量较低。当 guidance_scale > 1 时启用引导比例。
  • negative_prompt (str | list[str] | None，默认为 None) — 用于指导图像生成时不应包含的内容的提示或提示列表。如果未定义，则需要传递 negative_prompt_embeds。在不使用引导时（guidance_scale < 1）会被忽略。
  • num_images_per_prompt (int，默认为 1) — 每个提示生成的图像数量。如果它与用于编译的批处理大小不同，它将被神经元的静态批处理大小覆盖（动态批处理除外）。
  • eta (float，默认为 0.0) — 对应于 DDIM 论文中的参数 eta (η)。仅适用于 diffusers.schedulers.DDIMScheduler，在其他调度器中被忽略。
  • generator (torch.Generator | list[torch.Generator] | None，默认为 None) — 一个 torch.Generator，用于使生成过程具有确定性。
  • latents (torch.Tensor | None，默认为 None) — 从高斯分布中采样的预生成噪声潜在变量，用作图像生成的输入。可用于使用不同的提示微调相同的生成过程。如果未提供，则通过使用提供的随机 generator 进行采样来生成潜在张量。
  • prompt_embeds (torch.Tensor | None，默认为 None) — 预生成的文本嵌入。可用于轻松微调文本输入（提示加权）。如果未提供，则从 prompt 输入参数生成文本嵌入。
  • negative_prompt_embeds (torch.Tensor | None，默认为 None) — 预生成的负向文本嵌入。可用于轻松微调文本输入（提示加权）。如果未提供，则从 negative_prompt 输入参数生成 negative_prompt_embeds。
  • ip_adapter_image — (PipelineImageInput | None，默认为 None)：用于 IP Adapters 的可选图像输入。
  • ip_adapter_image_embeds (list[torch.Tensor] | None，默认为 None) — 用于 IP-Adapter 的预生成图像嵌入。它应该是一个列表，其长度与 IP-adapter 的数量相同。每个元素都应该是一个形状为 (batch_size, num_images, emb_dim) 的张量。如果 do_classifier_free_guidance 设置为 True，它应该包含负向图像嵌入。如果未提供，则从 ip_adapter_image 输入参数计算嵌入。
  • output_type (str，默认为 "pil") — 生成图像的输出格式。在 PIL.Image 或 np.array 之间选择。
  • return_dict (bool，默认为 True) — 是否返回 diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput 而不是一个普通的元组。
  • cross_attention_kwargs (dict[str, Any] | None，默认为 None) — 一个 kwargs 字典，如果指定，将传递给 self.processor 中定义的 AttentionProcessor。
  • controlnet_conditioning_scale (float | list[float]，默认为 1.0) — ControlNet 的输出在添加到原始 unet 的残差之前会乘以 controlnet_conditioning_scale。如果在 init 中指定了多个 ControlNet，你可以将相应的比例设置为一个列表。
  • guess_mode (bool，默认为 False) — 即使你移除了所有提示，ControlNet 编码器也会尝试识别输入图像的内容。建议使用 3.0 到 5.0 之间的 guidance_scale 值。
  • control_guidance_start (float | list[float]，默认为 0.0) — ControlNet 开始应用的总步数的百分比。
  • control_guidance_end (float | list[float]，可选，默认为 1.0) — ControlNet 停止应用的总步数的百分比。
  • clip_skip (int | None，默认为 None) — 在计算提示嵌入时从 CLIP 中跳过的层数。值为 1 表示将使用倒数第二层的输出用于计算提示嵌入。
  • callback_on_step_end (Callable[[int, int, dict], None] | PipelineCallback | MultiPipelineCallbacks | None，默认为 None) — 在推理过程中每个去噪步骤结束时调用的函数或 PipelineCallback 或 MultiPipelineCallbacks 的子类。使用以下参数：callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: dict)。callback_kwargs 将包含 callback_on_step_end_tensor_inputs 指定的所有张量列表。
  • callback_on_step_end_tensor_inputs (list[str]，默认为 ["latents"]) — callback_on_step_end 函数的张量输入列表。列表中指定的张量将作为 callback_kwargs 参数传递。你只能包含管道类的 ._callback_tensor_inputs 属性中列出的变量。

返回

diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput 或 tuple

如果 return_dict 为 True，则返回 diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput，否则返回一个 tuple，其中第一个元素是包含生成图像的列表，第二个元素是一个 bool 列表，指示相应生成的图像是否包含“不适宜工作场所”（nsfw）内容。

用于生成的管道的调用函数。

NeuronPixArtAlphaPipeline

class optimum.neuron.NeuronPixArtAlphaPipeline

< >

( **kwargs )

__call__

< >

( *args **kwargs )

NeuronStableDiffusionXLPipeline

class optimum.neuron.NeuronStableDiffusionXLPipeline

< >

( config: dict[str, typing.Any] configs: dict[str, 'PretrainedConfig'] neuron_configs: dict[str, 'NeuronDefaultConfig'] data_parallel_mode: typing.Literal['none', 'unet', 'transformer', 'all'] scheduler: diffusers.schedulers.scheduling_utils.SchedulerMixin | None vae_decoder: torch.jit._script.ScriptModule | NeuronModelVaeDecoder text_encoder: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None text_encoder_2: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None unet: torch.jit._script.ScriptModule | NeuronModelUnet | None = None transformer: torch.jit._script.ScriptModule | NeuronModelTransformer | None = None vae_encoder: torch.jit._script.ScriptModule | NeuronModelVaeEncoder | None = None image_encoder: torch.jit._script.ScriptModule | None = None safety_checker: torch.jit._script.ScriptModule | None = None tokenizer: transformers.models.clip.tokenization_clip.CLIPTokenizer | transformers.models.t5.tokenization_t5.T5Tokenizer | None = None tokenizer_2: transformers.models.clip.tokenization_clip.CLIPTokenizer | None = None feature_extractor: transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor | None = None controlnet: torch.jit._script.ScriptModule | list[torch.jit._script.ScriptModule]| NeuronControlNetModel | NeuronMultiControlNetModel | None = None requires_aesthetics_score: bool = False force_zeros_for_empty_prompt: bool = True add_watermarker: bool | None = None model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_and_config_save_paths: dict[str, tuple[str, pathlib.Path]] | None = None )

__call__

< >

( *args **kwargs )

NeuronStableDiffusionXLImg2ImgPipeline

class optimum.neuron.NeuronStableDiffusionXLImg2ImgPipeline

< >

( config: dict[str, typing.Any] configs: dict[str, 'PretrainedConfig'] neuron_configs: dict[str, 'NeuronDefaultConfig'] data_parallel_mode: typing.Literal['none', 'unet', 'transformer', 'all'] scheduler: diffusers.schedulers.scheduling_utils.SchedulerMixin | None vae_decoder: torch.jit._script.ScriptModule | NeuronModelVaeDecoder text_encoder: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None text_encoder_2: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None unet: torch.jit._script.ScriptModule | NeuronModelUnet | None = None transformer: torch.jit._script.ScriptModule | NeuronModelTransformer | None = None vae_encoder: torch.jit._script.ScriptModule | NeuronModelVaeEncoder | None = None image_encoder: torch.jit._script.ScriptModule | None = None safety_checker: torch.jit._script.ScriptModule | None = None tokenizer: transformers.models.clip.tokenization_clip.CLIPTokenizer | transformers.models.t5.tokenization_t5.T5Tokenizer | None = None tokenizer_2: transformers.models.clip.tokenization_clip.CLIPTokenizer | None = None feature_extractor: transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor | None = None controlnet: torch.jit._script.ScriptModule | list[torch.jit._script.ScriptModule]| NeuronControlNetModel | NeuronMultiControlNetModel | None = None requires_aesthetics_score: bool = False force_zeros_for_empty_prompt: bool = True add_watermarker: bool | None = None model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_and_config_save_paths: dict[str, tuple[str, pathlib.Path]] | None = None )

__call__

< >

( *args **kwargs )

NeuronStableDiffusionXLInpaintPipeline

class optimum.neuron.NeuronStableDiffusionXLInpaintPipeline

< >

( config: dict[str, typing.Any] configs: dict[str, 'PretrainedConfig'] neuron_configs: dict[str, 'NeuronDefaultConfig'] data_parallel_mode: typing.Literal['none', 'unet', 'transformer', 'all'] scheduler: diffusers.schedulers.scheduling_utils.SchedulerMixin | None vae_decoder: torch.jit._script.ScriptModule | NeuronModelVaeDecoder text_encoder: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None text_encoder_2: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None unet: torch.jit._script.ScriptModule | NeuronModelUnet | None = None transformer: torch.jit._script.ScriptModule | NeuronModelTransformer | None = None vae_encoder: torch.jit._script.ScriptModule | NeuronModelVaeEncoder | None = None image_encoder: torch.jit._script.ScriptModule | None = None safety_checker: torch.jit._script.ScriptModule | None = None tokenizer: transformers.models.clip.tokenization_clip.CLIPTokenizer | transformers.models.t5.tokenization_t5.T5Tokenizer | None = None tokenizer_2: transformers.models.clip.tokenization_clip.CLIPTokenizer | None = None feature_extractor: transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor | None = None controlnet: torch.jit._script.ScriptModule | list[torch.jit._script.ScriptModule]| NeuronControlNetModel | NeuronMultiControlNetModel | None = None requires_aesthetics_score: bool = False force_zeros_for_empty_prompt: bool = True add_watermarker: bool | None = None model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_and_config_save_paths: dict[str, tuple[str, pathlib.Path]] | None = None )

__call__

< >

( *args **kwargs )

NeuronStableDiffusionXLControlNetPipeline

class optimum.neuron.NeuronStableDiffusionXLControlNetPipeline

< >

( config: dict[str, typing.Any] configs: dict[str, 'PretrainedConfig'] neuron_configs: dict[str, 'NeuronDefaultConfig'] data_parallel_mode: typing.Literal['none', 'unet', 'transformer', 'all'] scheduler: diffusers.schedulers.scheduling_utils.SchedulerMixin | None vae_decoder: torch.jit._script.ScriptModule | NeuronModelVaeDecoder text_encoder: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None text_encoder_2: torch.jit._script.ScriptModule | NeuronModelTextEncoder | None = None unet: torch.jit._script.ScriptModule | NeuronModelUnet | None = None transformer: torch.jit._script.ScriptModule | NeuronModelTransformer | None = None vae_encoder: torch.jit._script.ScriptModule | NeuronModelVaeEncoder | None = None image_encoder: torch.jit._script.ScriptModule | None = None safety_checker: torch.jit._script.ScriptModule | None = None tokenizer: transformers.models.clip.tokenization_clip.CLIPTokenizer | transformers.models.t5.tokenization_t5.T5Tokenizer | None = None tokenizer_2: transformers.models.clip.tokenization_clip.CLIPTokenizer | None = None feature_extractor: transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor | None = None controlnet: torch.jit._script.ScriptModule | list[torch.jit._script.ScriptModule]| NeuronControlNetModel | NeuronMultiControlNetModel | None = None requires_aesthetics_score: bool = False force_zeros_for_empty_prompt: bool = True add_watermarker: bool | None = None model_save_dir: str | pathlib.Path | tempfile.TemporaryDirectory | None = None model_and_config_save_paths: dict[str, tuple[str, pathlib.Path]] | None = None )

__call__

< >

( prompt: str | list[str] | None = None prompt_2: str | list[str] | None = None image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, typing.List[PIL.Image.Image], typing.List[numpy.ndarray], typing.List[torch.Tensor], NoneType] = None num_inference_steps: int = 50 timesteps: list[int] | None = None sigmas: list[float] | None = None denoising_end: float | None = None guidance_scale: float = 5.0 negative_prompt: str | list[str] | None = None negative_prompt_2: str | list[str] | None = None num_images_per_prompt: int | None = 1 eta: float = 0.0 generator: torch._C.Generator | list[torch._C.Generator] | None = None latents: torch.Tensor | None = None prompt_embeds: torch.Tensor | None = None negative_prompt_embeds: torch.Tensor | None = None pooled_prompt_embeds: torch.Tensor | None = None negative_pooled_prompt_embeds: torch.Tensor | None = None ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, typing.List[PIL.Image.Image], typing.List[numpy.ndarray], typing.List[torch.Tensor], NoneType] = None ip_adapter_image_embeds: list[torch.Tensor] | None = None output_type: str | None = 'pil' return_dict: bool = True cross_attention_kwargs: dict[str, typing.Any] | None = None controlnet_conditioning_scale: float | list[float] = 1.0 guess_mode: bool = False control_guidance_start: float | list[float] = 0.0 control_guidance_end: float | list[float] = 1.0 original_size: tuple[int, int] | None = None crops_coords_top_left: tuple[int, int] = (0, 0) target_size: tuple[int, int] | None = None negative_original_size: tuple[int, int] | None = None negative_crops_coords_top_left: tuple[int, int] = (0, 0) negative_target_size: tuple[int, int] | None = None clip_skip: int | None = None callback_on_step_end: typing.Union[typing.Callable[[int, int, dict], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None callback_on_step_end_tensor_inputs: list[str] = ['latents'] **kwargs ) → diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput 或 tuple

参数

  • prompt (str | list[str]，默认为 None) — 用于指导图像生成的提示或提示列表。如果未定义，则需要传递 prompt_embeds。
  • prompt_2 (str | list[str]，默认为 None) — 发送到 tokenizer_2 和 text_encoder_2 的提示或提示列表。如果未定义，则在两个文本编码器中都使用 prompt。
  • image (PipelineImageInput | None，默认为 None) — ControlNet 输入条件，为 unet 的生成提供指导。如果类型指定为 torch.Tensor，则按原样传递给 ControlNet。PIL.Image.Image 也可以作为图像被接受。输出图像的尺寸默认为 image 的尺寸。如果传递了高度和/或宽度，image 将相应地调整大小。如果在 init 中指定了多个 ControlNet，则必须将图像作为列表传递，以便列表的每个元素都可以正确地批处理以输入单个 ControlNet。
  • num_inference_steps (int，默认为 50) — 去噪步数。更多的去噪步数通常会带来更高质量的图像，但代价是推理速度变慢。
  • timesteps (list[int] | None，默认为 None) — 用于去噪过程的自定义时间步，适用于在其 set_timesteps 方法中支持 timesteps 参数的调度器。如果未定义，将使用传递 num_inference_steps 时的默认行为。必须按降序排列。
  • sigmas (list[float] | None，默认为 None) — 用于去噪过程的自定义 sigma 值，适用于在其 set_timesteps 方法中支持 sigmas 参数的调度器。如果未定义，将使用传递 num_inference_steps 时的默认行为。
  • denoising_end (float | None, 默认为 None) — 指定时，确定在有意提前终止之前要完成的总去噪过程的分数（介于 0.0 和 1.0 之间）。因此，返回的样本仍将保留由调度程序选择的离散时间步长确定的大量噪声。当该 pipeline 构成“去噪器混合（Mixture of Denoisers）”多 pipeline 设置的一部分时，应理想地使用 denoising_end 参数，详见优化图像输出
  • guidance_scale (float, 默认为 5.0) — 更高的引导比例值会鼓励模型生成与文本 prompt 紧密相关的图像，但代价是图像质量较低。当 guidance_scale > 1 时启用引导比例。
  • negative_prompt (str | list[str] | None, 默认为 None) — 用于指导在图像生成中不包含哪些内容的提示或提示列表。如果未定义，则需要传递 negative_prompt_embeds。在不使用引导时（guidance_scale < 1）将被忽略。
  • negative_prompt_2 (str | list[str] | None, 默认为 None) — 用于指导在图像生成中不包含哪些内容的提示或提示列表。此参数将发送给 tokenizer_2 和 text_encoder_2。如果未定义，则两个文本编码器都将使用 negative_prompt。
  • num_images_per_prompt (int, 默认为 1) — 每个提示生成的图像数量。
  • eta (float, 默认为 0.0) — 对应于 DDIM 论文中的参数 eta (η)。仅适用于 diffusers.schedulers.DDIMScheduler，在其他调度器中将被忽略。
  • generator (torch.Generator | list[torch.Generator] | None, 默认为 None) — 一个 torch.Generator，用于使生成过程具有确定性。
  • latents (torch.Tensor | None, 默认为 None) — 预先生成的从高斯分布中采样的噪声潜在变量，用作图像生成的输入。可用于使用不同的提示调整相同的生成过程。如果未提供，则通过使用提供的随机 generator 进行采样来生成一个潜在变量张量。
  • prompt_embeds (torch.Tensor | None, 默认为 None) — 预先生成的文本嵌入。可用于轻松调整文本输入（提示加权）。如果未提供，则从 prompt 输入参数生成文本嵌入。
  • negative_prompt_embeds (torch.Tensor | None, 默认为 None) — 预先生成的负面文本嵌入。可用于轻松调整文本输入（提示加权）。如果未提供，则从 negative_prompt 输入参数生成 negative_prompt_embeds。
  • pooled_prompt_embeds (torch.Tensor | None, 默认为 None) — 预先生成的池化文本嵌入。可用于轻松调整文本输入（提示加权）。如果未提供，则从 prompt 输入参数生成池化文本嵌入。
  • negative_pooled_prompt_embeds (torch.Tensor | None, 默认为 None) — 预先生成的负面池化文本嵌入。可用于轻松调整文本输入（提示加权）。如果未提供，则从 negative_prompt 输入参数生成池化的 negative_prompt_embeds。
  • ip_adapter_image (PipelineImageInput | None, 默认为 None) — 与 IP Adapters 配合使用的可选图像输入。
  • ip_adapter_image_embeds (list[torch.Tensor] | None, 默认为 None) — 用于 IP-Adapter 的预生成图像嵌入。它应该是一个列表，其长度与 IP-adapter 的数量相同。每个元素应该是一个形状为 (batch_size, num_images, emb_dim) 的张量。如果 do_classifier_free_guidance 设置为 True，它应该包含负面图像嵌入。如果未提供，则从 ip_adapter_image 输入参数计算嵌入。
  • output_type (str | None, 默认为 "pil") — 生成图像的输出格式。在 PIL.Image 或 np.array 之间选择。
  • return_dict (bool, 默认为 True) — 是否返回 ~pipelines.stable_diffusion.StableDiffusionPipelineOutput 而不是一个普通的元组。
  • cross_attention_kwargs (dict[str, Any] | None, 默认为 None) — 一个 kwargs 字典，如果指定，则传递给 self.processor 中定义的 AttentionProcessor。
  • controlnet_conditioning_scale (float | list[float], 默认为 1.0) — ControlNet 的输出在添加到原始 unet 中的残差之前，会乘以 controlnet_conditioning_scale。如果在 init 中指定了多个 ControlNet，你可以将相应的比例设置为一个列表。
  • guess_mode (bool, 默认为 False) — 即使你移除了所有提示，ControlNet 编码器也会尝试识别输入图像的内容。建议使用 3.0 到 5.0 之间的 guidance_scale 值。
  • control_guidance_start (float | list[float], 默认为 0.0) — ControlNet 开始应用的总步数的百分比。
  • control_guidance_end (float | list[float], 默认为 1.0) — ControlNet 停止应用的总步数的百分比。
  • original_size (tuple[int, int] | None, 默认为 (1024, 1024)) — 如果 original_size 与 target_size 不同，图像将显示为下采样或上采样。如果未指定，original_size 默认为 (height, width)。这是 SDXL 微调的一部分，如 https://huggingface.ac.cn/papers/2307.01952 的 2.2 节所述。
  • crops_coords_top_left (tuple[int, int], 默认为 (0, 0)) — crops_coords_top_left 可用于生成一个看起来像是从 crops_coords_top_left 位置向下“裁剪”的图像。通常通过将 crops_coords_top_left 设置为 (0, 0) 来获得良好、居中的图像。这是 SDXL 微调的一部分，如 https://huggingface.ac.cn/papers/2307.01952 的 2.2 节所述。
  • target_size (tuple[int, int] | None, 默认为 None) — 在大多数情况下，target_size 应设置为生成图像所需的高度和宽度。如果未指定，它将默认为 (height, width)。这是 SDXL 微调的一部分，如 https://huggingface.ac.cn/papers/2307.01952 的 2.2 节所述。
  • negative_original_size (tuple[int, int] | None, 默认为 None) — 根据特定图像分辨率对生成过程进行负面条件化。这是 SDXL 微调的一部分，如 https://huggingface.ac.cn/papers/2307.01952 的 2.2 节所述。有关更多信息，请参阅此 issue 讨论串：https://github.com/huggingface/diffusers/issues/4208。
  • negative_crops_coords_top_left (tuple[int, int], 默认为 (0, 0)) — 根据特定的裁剪坐标对生成过程进行负面条件化。这是 SDXL 微调的一部分，如 https://huggingface.ac.cn/papers/2307.01952 的 2.2 节所述。有关更多信息，请参阅此 issue 讨论串：https://github.com/huggingface/diffusers/issues/4208。
  • negative_target_size (tuple[int, int] | None, 默认为 None) — 根据目标图像分辨率对生成过程进行负面条件化。在大多数情况下，它应该与 target_size 相同。这是 SDXL 微调的一部分，如 https://huggingface.ac.cn/papers/2307.01952 的 2.2 节所述。有关更多信息，请参阅此 issue 讨论串：https://github.com/huggingface/diffusers/issues/4208。
  • clip_skip (int | None, 默认为 None) — 在计算提示嵌入时，从 CLIP 中跳过的层数。值为 1 表示将使用倒数第二层的输出计算提示嵌入。
  • callback_on_step_end (Callable[[int, int, dict], None] | PipelineCallback | MultiPipelineCallbacks | None, 默认为 None) — 在推理期间每个去噪步骤结束时调用的函数或 PipelineCallback 或 MultiPipelineCallbacks 的子类，具有以下参数：callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: dict)。callback_kwargs 将包含 callback_on_step_end_tensor_inputs 指定的所有张量的列表。
  • callback_on_step_end_tensor_inputs (list[str], 默认为 ["latents"]) — callback_on_step_end 函数的张量输入列表。列表中指定的张量将作为 callback_kwargs 参数传递。你只能包含 pipeline 类 ._callback_tensor_inputs 属性中列出的变量。

返回

diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput 或 tuple

如果 return_dict 为 True，则返回 diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput，否则返回一个包含输出图像的 tuple。

用于生成的管道的调用函数。

示例

←IP-Adapter