# Inversion textuelle

Textual Inversion est une méthode d’entraînement permettant de personnaliser des modèles en apprenant de nouvelles embeddings de texte à partir de quelques images d’exemple. Le fichier généré par l’entraînement est extrêmement petit (quelques Ko) et les nouvelles embeddings peuvent être chargées dans l’encodeur de texte.

`TextualInversionLoaderMixin` fournit une fonction pour charger les embeddings Textual Inversion depuis Diffusers et Automatic1111 dans le text encoder, ainsi qu’un jeton spécial pour activer les embeddings.

> [!TIP]
> Pour en savoir plus sur la manière de charger les embeddings Textual Inversion, consultez le guide de chargement [Textual Inversion](../../using-diffusers/legacy_adapters#textual-inversion).

## TextualInversionLoaderMixin[[diffusers.loaders.TextualInversionLoaderMixin]]

#### diffusers.loaders.TextualInversionLoaderMixin[[diffusers.loaders.TextualInversionLoaderMixin]]

```python
diffusers.loaders.TextualInversionLoaderMixin()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/textual_inversion.py#L118)

Chargez les jetons et les plongements de Textual Inversion dans le tokenizer et l’encodeur de texte.

#### load_textual_inversion[[diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion]]

```python
load_textual_inversion(pretrained_model_name_or_path: str | list[str] | dict[str, torch.Tensor] | list[dict[str, torch.Tensor]], token: str | list[str] | None = None, tokenizer: 'PreTrainedTokenizer' | None = None, text_encoder: 'PreTrainedModel' | None = None, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/textual_inversion.py#L271)

**Paramètres :**

pretrained_model_name_or_path (`str` ou `os.PathLike` ou `list[str or os.PathLike]` ou `Dict` ou `list[Dict]`) : Peut être l'un des éléments suivants ou une liste de ceux-ci : - Une chaîne de caractères, l'*identifiant du modèle* (par exemple `sd-concepts-library/low-poly-hd-logos-icons`) d'un modèle pré-entraîné hébergé sur le Hub. - Un chemin vers un *dossier* (par exemple `./my_text_inversion_directory/`) contenant les poids d'inversion textuelle. - Un chemin vers un *fichier* (par exemple `./my_text_inversions.pt`) contenant des poids d'inversion textuelle. - Un [dictionnaire d'état torch](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict).

token (`str` ou `list[str]`, *facultatif*) : Remplace le jeton à utiliser pour les poids d'inversion textuelle. Si `pretrained_model_name_or_path` est une liste, alors `token` doit également être une liste de même longueur.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTextModel), *facultatif*) : encodeur de texte figé ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). S'il n'est pas spécifié, la fonction utilisera self.tokenizer.

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTokenizer), *facultatif*) : Un `CLIPTokenizer` pour tokeniser le texte. S'il n'est pas spécifié, la fonction utilisera self.tokenizer.

weight_name (`str`, *facultatif*) : Nom d'un fichier de poids personnalisé. À utiliser dans les cas suivants : - Le fichier d'inversion textuelle enregistré est au format 🤗 Diffusers, mais a été enregistré sous un nom de poids spécifique tel que `text_inv.bin`. - Le fichier d'inversion textuelle enregistré est au format Automatic1111.

cache_dir (`str | os.PathLike`, *facultatif*) : Chemin vers un répertoire où la configuration d'un modèle pré-entraîné téléchargé est mise en cache si le cache standard n'est pas utilisé.

force_download (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut forcer le (re)téléchargement des poids du modèle et des fichiers de configuration, en ignorant les versions mises en cache si elles existent.

proxies (`dict[str, str]`, *facultatif*) : Un dictionnaire de serveurs proxy à utiliser par protocole ou point de terminaison, par exemple, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Les proxys sont utilisés pour chaque requête.

local_files_only (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut charger uniquement les poids et les fichiers de configuration du modèle locaux. Si défini sur `True`, le modèle ne sera pas téléchargé depuis le Hub.

hf_token (`str` ou *bool*, *facultatif*) : Le jeton à utiliser comme autorisation bearer HTTP pour les fichiers distants. Si `True`, le jeton généré par `diffusers-cli login` (stocké dans `~/.huggingface`) est utilisé.

revision (`str`, *facultatif*, par défaut `"main"`) : La version spécifique du modèle à utiliser. Il peut s'agir d'un nom de branche, d'un nom de tag, d'un identifiant de commit ou de tout identifiant autorisé par Git.

subfolder (`str`, *facultatif*, valeur par défaut `""`) : Emplacement du sous-dossier du fichier de modèle au sein d'un dépôt de modèle plus large sur le Hub ou en local.

mirror (`str`, *facultatif*) : Source miroir pour résoudre les problèmes d'accessibilité si vous téléchargez un modèle en Chine. Nous ne garantissons ni la réactivité ni la sécurité de la source, et vous devez consulter le site miroir pour plus d'informations.

Chargez les embeddings de Textual Inversion dans l’encodeur de texte de [StableDiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) (les formats 🤗 Diffusers et Automatic1111 sont pris en charge).

Exemple :

Pour charger un vecteur d'intégration de Textual Inversion au format 🤗 Diffusers :

```py
from diffusers import StableDiffusionPipeline
import torch

model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")

pipe.load_textual_inversion("sd-concepts-library/cat-toy")

prompt = "A <cat-toy> backpack"

image = pipe(prompt, num_inference_steps=50).images[0]
image.save("cat-backpack.png")
```

Pour charger un vecteur d'intégration Textual Inversion au format Automatic1111, assurez-vous d'abord de télécharger le vecteur (par exemple depuis [civitAI](https://civitai.com/models/3036?modelVersionId=9857)), puis chargez le vecteur

localement :

```py
from diffusers import StableDiffusionPipeline
import torch

model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")

pipe.load_textual_inversion("./charturnerv2.pt", token="charturnerv2")

prompt = "charturnerv2, multiple views of the same character in the same outfit, a character turnaround of a woman wearing a black jacket and red shirt, best quality, intricate details."

image = pipe(prompt, num_inference_steps=50).images[0]
image.save("character.png")
```

#### maybe_convert_prompt[[diffusers.loaders.TextualInversionLoaderMixin.maybe_convert_prompt]]

```python
maybe_convert_prompt(prompt: str | list[str], tokenizer: 'PreTrainedTokenizer')
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/textual_inversion.py#L123)

**Paramètres :**

prompt (`str` ou liste de `str`) : Le prompt ou les prompts pour guider la génération d'image.

tokenizer (`PreTrainedTokenizer`) : le tokenizer chargé d'encoder le prompt en jetons d'entrée.

**Retourne :** `str` ou liste de `str`

Le prompt converti

Traite les invites qui incluent un jeton spécial correspondant à un embedding d'inversion textuelle multi-vecteurs, à remplacer par plusieurs jetons spéciaux, chacun correspondant à l'un des vecteurs. Si l'invite ne contient aucun jeton d'inversion textuelle, ou si le jeton d'inversion textuelle est un vecteur unique, l'invite d'entrée est renvoyée.

#### unload_textual_inversion[[diffusers.loaders.TextualInversionLoaderMixin.unload_textual_inversion]]

```python
unload_textual_inversion(tokens: str | list[str] | None = None, tokenizer: 'PreTrainedTokenizer' | None = None, text_encoder: 'PreTrainedModel' | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/textual_inversion.py#L467)

Décharger les embeddings de Textual Inversion du text encoder de [StableDiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline)

Exemple :
```py
from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5")

# Example 1
pipeline.load_textual_inversion("sd-concepts-library/gta5-artwork")
pipeline.load_textual_inversion("sd-concepts-library/moeb-style")

# Remove all token embeddings
pipeline.unload_textual_inversion()

# Example 2
pipeline.load_textual_inversion("sd-concepts-library/moeb-style")
pipeline.load_textual_inversion("sd-concepts-library/gta5-artwork")

# Remove just one token
pipeline.unload_textual_inversion("<moe-bius>")

# Example 3: unload from SDXL
pipeline = AutoPipelineForText2Image.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0")
embedding_path = hf_hub_download(
    repo_id="linoyts/web_y2k", filename="web_y2k_emb.safetensors", repo_type="model"
)

# load embeddings to the text encoders
state_dict = load_file(embedding_path)

# load embeddings of text_encoder 1 (CLIP ViT-L/14)
pipeline.load_textual_inversion(
    state_dict["clip_l"],
    tokens=["<s0>", "<s1>"],
    text_encoder=pipeline.text_encoder,
    tokenizer=pipeline.tokenizer,
)
# load embeddings of text_encoder 2 (CLIP ViT-G/14)
pipeline.load_textual_inversion(
    state_dict["clip_g"],
    tokens=["<s0>", "<s1>"],
    text_encoder=pipeline.text_encoder_2,
    tokenizer=pipeline.tokenizer_2,
)

# Unload explicitly from both text encoders and tokenizers
pipeline.unload_textual_inversion(
    tokens=["<s0>", "<s1>"], text_encoder=pipeline.text_encoder, tokenizer=pipeline.tokenizer
)
pipeline.unload_textual_inversion(
    tokens=["<s0>", "<s1>"], text_encoder=pipeline.text_encoder_2, tokenizer=pipeline.tokenizer_2
)
```