Buckets:
| # Inversión textual | |
| Textual Inversion es un método de entrenamiento para personalizar modelos mediante el aprendizaje de nuevas incrustaciones de texto a partir de algunas imágenes de ejemplo. El archivo generado durante el entrenamiento es extremadamente pequeño (unos pocos KB) y las nuevas incrustaciones pueden cargarse en el codificador de texto. | |
| `TextualInversionLoaderMixin` proporciona una función para cargar embeddings de Textual Inversion desde Diffusers y Automatic1111 en el codificador de texto y para cargar un token especial que active los embeddings. | |
| > [!TIP] | |
| > Para obtener más información sobre cómo cargar los embeddings de Textual Inversion, consulte la guía de carga de [Textual Inversion](../../using-diffusers/legacy_adapters#textual-inversion). | |
| ## TextualInversionLoaderMixin[[diffusers.loaders.TextualInversionLoaderMixin]] | |
| #### diffusers.loaders.TextualInversionLoaderMixin[[diffusers.loaders.TextualInversionLoaderMixin]] | |
| ```python | |
| diffusers.loaders.TextualInversionLoaderMixin() | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/textual_inversion.py#L118) | |
| Carga los tokens y embeddings de Textual Inversion en el tokenizer y el codificador de texto. | |
| #### 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) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/textual_inversion.py#L271) | |
| **Parámetros:** | |
| pretrained_model_name_or_path (`str` o `os.PathLike` o `list[str or os.PathLike]` o `Dict` o `list[Dict]`) : Puede ser cualquiera de los siguientes o una lista de ellos: - Una cadena de texto, el *model id* (por ejemplo `sd-concepts-library/low-poly-hd-logos-icons`) de un modelo preentrenado alojado en el Hub. - Una ruta a un *directorio* (por ejemplo `./my_text_inversion_directory/`) que contiene los pesos de textual inversion. - Una ruta a un *archivo* (por ejemplo `./my_text_inversions.pt`) que contiene pesos de textual inversion. - Un [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict). | |
| token (`str` o `list[str]`, *opcional*) : Anula el token que se usará para los pesos de inversión textual. Si `pretrained_model_name_or_path` es una lista, `token` también debe ser una lista de la misma longitud. | |
| text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel), *opcional*) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). Si no se especifica, la función tomará self.tokenizer. | |
| tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer), *opcional*) : Un `CLIPTokenizer` para tokenizar texto. Si no se especifica, la función tomará self.tokenizer. | |
| weight_name (`str`, *opcional*) : Nombre de un archivo de pesos personalizado. Debe usarse cuando: - El archivo de inversión textual guardado está en formato 🤗 Diffusers, pero se guardó con un nombre de pesos específico como `text_inv.bin`. - El archivo de inversión textual guardado está en formato Automatic1111. | |
| cache_dir (`str | os.PathLike`, *opcional*) : Ruta a un directorio donde se almacena en caché la configuración de un modelo preentrenado descargado si no se utiliza la caché estándar. | |
| force_download (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe forzar la (re)descarga de los pesos del modelo y los archivos de configuración, reemplazando las versiones en caché si existen. | |
| proxies (`dict[str, str]`, *opcional*) : Un diccionario de servidores proxy a utilizar por protocolo o punto de acceso, por ejemplo, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Los proxies se utilizan en cada solicitud. | |
| local_files_only (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben cargar únicamente los pesos y archivos de configuración del modelo localmente. Si se establece en `True`, el modelo no se descargará desde el Hub. | |
| hf_token (`str` o *bool*, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. Si es `True`, se utiliza el token generado por `diffusers-cli login` (almacenado en `~/.huggingface`). | |
| revision (`str`, *opcional*, valor predeterminado `"main"`) : La versión específica del modelo que se va a utilizar. Puede ser el nombre de una rama, el nombre de una etiqueta, un id de commit o cualquier identificador permitido por Git. | |
| subfolder (`str`, *opcional*, valor predeterminado `""`) : La ubicación de la subcarpeta de un archivo de modelo dentro de un repositorio de modelos más grande en el Hub o localmente. | |
| mirror (`str`, *opcional*) : Origen de espejo para resolver problemas de accesibilidad si estás descargando un modelo en China. No garantizamos la oportunidad ni la seguridad de la fuente, y debes consultar el sitio de espejo para obtener más información. | |
| Carga los embeddings de Textual Inversion en el codificador de texto de [StableDiffusionPipeline](/docs/diffusers/main/es/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) (se admiten tanto el formato de 🤗 Diffusers como el de Automatic1111). | |
| Ejemplo: | |
| Para cargar un vector de incrustación de Textual Inversion en formato 🤗 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") | |
| ``` | |
| Para cargar un vector de incrustación de Textual Inversion en formato Automatic1111, asegúrese de descargar primero el vector (por ejemplo, desde [civitAI](https://civitai.com/models/3036?modelVersionId=9857)) y luego cargar el vector | |
| localmente: | |
| ```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') | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/textual_inversion.py#L123) | |
| **Parámetros:** | |
| prompt (`str` o lista de `str`) : El prompt o los prompts para guiar la generación de la imagen. | |
| tokenizer (`PreTrainedTokenizer`) : El tokenizador responsable de codificar el prompt en tokens de entrada. | |
| **Devuelve:** `str` o lista de `str` | |
| El prompt convertido | |
| Procesa los prompts que incluyen un token especial correspondiente a una incrustación de inversión textual multivectorial que debe reemplazarse con múltiples tokens especiales, cada uno correspondiente a uno de los vectores. Si el prompt no tiene un token de inversión textual o si el token de inversión textual es de un solo vector, se devuelve el prompt de entrada. | |
| #### 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) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/textual_inversion.py#L467) | |
| Descargar los embeddings de Textual Inversion del codificador de texto de [StableDiffusionPipeline](/docs/diffusers/main/es/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) | |
| Ejemplo: | |
| ```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 | |
| ) | |
| ``` | |
Xet Storage Details
- Size:
- 10.1 kB
- Xet hash:
- efcb46fd098a5558d574bba63be790c75f3e96659646f5556c95ada49b864d71
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.