Buckets:
| # Programador de pasos múltiples para el modelo de consistencia latente | |
| ## Resumen | |
| Programador de multietapas y de un solo paso (Algoritmo 3) introducido junto con los modelos de consistencia latente en el artículo [Latent Consistency Models: Synthesizing High-Resolution Images with Few-Step Inference](https://huggingface.co/papers/2310.04378) de Simian Luo, Yiqin Tan, Longbo Huang, Jian Li y Hang Zhao. Este programador debería ser capaz de generar buenas muestras desde [LatentConsistencyModelPipeline](/docs/diffusers/main/es/api/pipelines/latent_consistency_models#diffusers.LatentConsistencyModelPipeline) en 1-8 pasos. | |
| ## LCMScheduler[[diffusers.LCMScheduler]] | |
| #### diffusers.LCMScheduler[[diffusers.LCMScheduler]] | |
| ```python | |
| diffusers.LCMScheduler(num_train_timesteps: int = 1000, beta_start: float = 0.00085, beta_end: float = 0.012, beta_schedule: str = 'scaled_linear', trained_betas: numpy.ndarray | list[float] | None = None, original_inference_steps: int = 50, clip_sample: bool = False, clip_sample_range: float = 1.0, set_alpha_to_one: bool = True, steps_offset: int = 0, prediction_type: str = 'epsilon', thresholding: bool = False, dynamic_thresholding_ratio: float = 0.995, sample_max_value: float = 1.0, timestep_spacing: str = 'leading', timestep_scaling: float = 10.0, rescale_betas_zero_snr: bool = False) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_lcm.py#L142) | |
| **Parámetros:** | |
| num_train_timesteps (`int`, por defecto `1000`) : El número de pasos de difusión para entrenar el modelo. | |
| beta_start (`float`, por defecto `0.00085`) : El valor inicial de `beta` para la inferencia. | |
| beta_end (`float`, por defecto `0.012`) : El valor final de `beta`. | |
| beta_schedule (`str`, por defecto `"scaled_linear"`) : La programación de beta, un mapeo desde un rango de beta hasta una secuencia de betas para dar pasos al modelo. Elija entre `linear`, `scaled_linear` o `squaredcos_cap_v2`. | |
| trained_betas (`np.ndarray` o `list[float]`, *opcional*) : Pasa un array de betas directamente al constructor para omitir `beta_start` y `beta_end`. | |
| original_inference_steps (`int`, por defecto `50`) : El número predeterminado de pasos de inferencia utilizados para generar un calendario de pasos de tiempo espaciados linealmente, del cual finalmente tomaremos `num_inference_steps` pasos de tiempo equiespaciados para formar el calendario de pasos de tiempo final. | |
| clip_sample (`bool`, por defecto `False`) : Recorta la muestra predicha para la estabilidad numérica. | |
| clip_sample_range (`float`, por defecto `1.0`) : La magnitud máxima para el recorte de muestras. Solo es válido cuando `clip_sample=True`. | |
| set_alpha_to_one (`bool`, por defecto `True`) : Cada paso de difusión utiliza el valor del producto de alfas en ese paso y en el anterior. En el paso final no hay un alfa anterior. Cuando esta opción es `True`, el producto de alfas anterior se fija en `1`; de lo contrario, se utiliza el valor de alfa en el paso 0. | |
| steps_offset (`int`, por defecto `0`) : Un desplazamiento que se suma a los pasos de inferencia, tal como lo requieren algunas familias de modelos. | |
| prediction_type (`str`, defaults to `"epsilon"`) : Prediction type of the scheduler function; can be `epsilon` (predicts the noise of the diffusion process), `sample` (directly predicts the noisy sample`) or `v_prediction` (see section 2.4 of [Imagen Video](https://huggingface.co/papers/2210.02303) paper). | |
| thresholding (`bool`, por defecto `False`) : Si se debe utilizar el método de "umbral dinámico". No es adecuado para modelos de difusión en el espacio latente, como Stable Diffusion. | |
| dynamic_thresholding_ratio (`float`, por defecto `0.995`) : La proporción para el método de umbral dinámico. Solo es válido cuando `thresholding=True`. | |
| sample_max_value (`float`, por defecto `1.0`) : El valor de umbral para el umbral dinámico. Solo es válido cuando `thresholding=True`. | |
| timestep_spacing (`str`, por defecto `"leading"`) : La forma en que se deben escalar los pasos de tiempo. Consulte la Tabla 2 de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) para obtener más información. | |
| timestep_scaling (`float`, por defecto `10.0`) : El factor por el que se multiplicarán los timesteps al calcular las condiciones de frontera del modelo de consistencia `c_skip` y `c_out`. Aumentar este valor reducirá el error de aproximación (aunque el error de aproximación con el valor por defecto de `10.0` ya es bastante pequeño). | |
| rescale_betas_zero_snr (`bool`, por defecto `False`) : Si se deben reescalar los betas para tener un SNR terminal cero. Esto permite al modelo generar muestras muy brillantes y oscuras en lugar de limitarlo a muestras con un brillo medio. Relacionado de forma laxa con [`--offset_noise`](https://github.com/huggingface/diffusers/blob/74fd735eb073eb1d774b1ab4154a0876eb82f055/examples/dreambooth/train_dreambooth.py#L506). | |
| `LCMScheduler` extiende el procedimiento de desruido introducido en los modelos probabilísticos de difusión de desruido (DDPM) con una guía no markoviana. | |
| Este modelo hereda de [SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin) y [ConfigMixin](/docs/diffusers/main/es/api/configuration#diffusers.ConfigMixin). [~ConfigMixin](/docs/diffusers/main/es/api/configuration#diffusers.ConfigMixin) se encarga de almacenar todos los atributos de configuración que se pasan en la función `__init__` del scheduler, como `num_train_timesteps`. Se pueden acceder mediante `scheduler.config.num_train_timesteps`. [SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin) proporciona funcionalidad general de carga y guardado a través de las funciones [SchedulerMixin.save_pretrained()](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin.save_pretrained) y [from_pretrained()](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin.from_pretrained). | |
| #### add_noise[[diffusers.LCMScheduler.add_noise]] | |
| ```python | |
| add_noise(original_samples: Tensor, noise: Tensor, timesteps: IntTensor) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_lcm.py#L667) | |
| **Parámetros:** | |
| original_samples (`torch.Tensor`) : Las muestras originales a las que se les añadirá ruido. | |
| noise (`torch.Tensor`) : El ruido que se añadirá a las muestras. | |
| timesteps (`torch.IntTensor`) : Los pasos de tiempo que indican el nivel de ruido para cada muestra. | |
| **Devuelve:** `torch.Tensor` | |
| Las muestras ruidosas. | |
| Añada ruido a las muestras originales según la magnitud del ruido en cada paso temporal (este es el proceso de difusión hacia adelante). | |
| #### get_scalings_for_boundary_condition_discrete[[diffusers.LCMScheduler.get_scalings_for_boundary_condition_discrete]] | |
| ```python | |
| get_scalings_for_boundary_condition_discrete(timestep: int) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_lcm.py#L548) | |
| **Parámetros:** | |
| timestep (`int`) : El paso de tiempo discreto para el que se deben calcular las escalas. | |
| **Devuelve:** `tuple[float, float]` | |
| Una tupla que contiene `c_skip` (escalado para la muestra de entrada) y `c_out` (escalado para la muestra desruidada predicha). | |
| Calcula las escalas de las condiciones de frontera (`c_skip` y `c_out`) para el paso de tiempo discreto dado, tal como se utiliza en el Latent Consistency Model. | |
| #### get_velocity[[diffusers.LCMScheduler.get_velocity]] | |
| ```python | |
| get_velocity(sample: Tensor, noise: Tensor, timesteps: IntTensor) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_lcm.py#L710) | |
| **Parámetros:** | |
| sample (`torch.Tensor`) : La muestra de entrada. | |
| noise (`torch.Tensor`) : El tensor de ruido. | |
| timesteps (`torch.IntTensor`) : Los pasos de tiempo para el cálculo de la velocidad. | |
| **Devuelve:** `torch.Tensor` | |
| La velocidad calculada. | |
| Calcule la predicción de velocidad a partir de la muestra y el ruido según la fórmula de velocidad. | |
| #### index_for_timestep[[diffusers.LCMScheduler.index_for_timestep]] | |
| ```python | |
| index_for_timestep(timestep: typing.Union[float, torch.Tensor], schedule_timesteps: typing.Optional[torch.Tensor] = None) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_lcm.py#L262) | |
| **Parámetros:** | |
| timestep (`float` o `torch.Tensor`) : El valor de timestep a buscar en la programación. | |
| schedule_timesteps (`torch.Tensor`, *opcional*) : El calendario de pasos de tiempo en el que buscar. Si es `None`, usa `self.timesteps`. | |
| **Devuelve:** `int` | |
| El índice del paso de tiempo en la programación. Para el primer paso, devuelve el segundo índice si existen múltiples coincidencias para evitar omitir una sigma al comenzar a mitad de la programación (p. ej., para imagen a imagen). | |
| Encuentra el índice de un paso de tiempo dado en la programación de pasos de tiempo. | |
| #### previous_timestep[[diffusers.LCMScheduler.previous_timestep]] | |
| ```python | |
| previous_timestep(timestep) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_lcm.py#L755) | |
| **Parámetros:** | |
| timestep (`int`) : El paso de tiempo actual. | |
| **Devuelve:** `int` o `torch.Tensor` | |
| El paso de tiempo anterior. | |
| Calcule el paso de tiempo anterior en la cadena de difusión. | |
| #### scale_model_input[[diffusers.LCMScheduler.scale_model_input]] | |
| ```python | |
| scale_model_input(sample: Tensor, timestep: int | None = None) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_lcm.py#L341) | |
| **Parámetros:** | |
| sample (`torch.Tensor`) : La muestra de entrada. | |
| timestep (`int`, *opcional*) : El paso temporal actual en la cadena de difusión. | |
| **Devuelve:** `torch.Tensor` | |
| Una muestra de entrada escalada. | |
| Garantiza la interoperabilidad con los programadores que necesitan escalar la entrada del modelo de desruido en función del paso temporal actual. | |
| #### set_begin_index[[diffusers.LCMScheduler.set_begin_index]] | |
| ```python | |
| set_begin_index(begin_index: int = 0) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_lcm.py#L331) | |
| **Parámetros:** | |
| begin_index (`int`, por defecto `0`) : El índice inicial del programador. | |
| Establece el índice inicial para el programador. Esta función debe ejecutarse desde la tubería antes de la inferencia. | |
| #### set_timesteps[[diffusers.LCMScheduler.set_timesteps]] | |
| ```python | |
| set_timesteps(num_inference_steps: int | None = None, device: typing.Union[str, torch.device, NoneType] = None, original_inference_steps: int | None = None, timesteps: list[int] | None = None, strength: float = 1.0) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_lcm.py#L402) | |
| **Parámetros:** | |
| num_inference_steps (`int`, *opcional*) : El número de pasos de difusión utilizados al generar muestras con un modelo preentrenado. Si se usa, `timesteps` debe ser `None`. | |
| device (`str` o `torch.device`, *opcional*) : El dispositivo al que deben moverse los pasos de tiempo. Si es `None`, los pasos de tiempo no se mueven. | |
| original_inference_steps (`int`, *opcional*) : El número original de pasos de inferencia, que se utilizará para generar un calendario de pasos de tiempo linealmente espaciado (que es diferente de la implementación estándar de `diffusers`). A continuación, tomaremos `num_inference_steps` pasos de tiempo de este calendario, espaciados uniformemente en términos de índices, y usaremos eso como nuestro calendario final de pasos de tiempo. Si no se establece, esto se ajustará por defecto al atributo `original_inference_steps`. | |
| timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para admitir un espaciado arbitrario entre los pasos de tiempo. Si es `None`, se utiliza la estrategia de espaciado de pasos de tiempo predeterminada, que consiste en un espaciado igual entre los pasos de tiempo en la programación de pasos de tiempo de entrenamiento/destilación. Si se pasa `timesteps`, `num_inference_steps` debe ser `None`. | |
| strength (`float`, por defecto `1.0`) : Factor de fuerza utilizado para generar un horario de pasos parciales (p. ej., para imagen a imagen). Un valor de `1.0` utiliza el horario completo. | |
| **Devuelve:** `None` | |
| Establece los pasos discretos utilizados para la cadena de difusión (para ejecutarse antes de la inferencia). | |
| #### paso[[diffusers.LCMScheduler.step]] | |
| ```python | |
| step(model_output: Tensor, timestep: int, sample: Tensor, generator: typing.Optional[torch.Generator] = None, return_dict: bool = True) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_lcm.py#L569) | |
| **Parámetros:** | |
| model_output (`torch.Tensor`) : La salida directa del modelo de difusión aprendido. | |
| timestep (`int`) : El paso de tiempo discreto actual en la cadena de difusión. | |
| sample (`torch.Tensor`) : Una instancia actual de una muestra creada por el proceso de difusión. | |
| generator (`torch.Generator`, *opcional*) : Un generador de números aleatorios para muestreos reproducibles. | |
| return_dict (`bool`, por defecto `True`) : Si se devuelve un `LCMSchedulerOutput` o una `tuple`. | |
| **Devuelve:** `LCMSchedulerOutput` o `tuple` | |
| If return_dict is `True`, `LCMSchedulerOutput` is returned, otherwise a tuple is returned where the first element is the sample tensor. | |
| Predice la muestra del paso de tiempo anterior invirtiendo el SDE. Esta función propaga el proceso de difusión desde las salidas del modelo aprendido (con mayor frecuencia, el ruido predicho). | |
Xet Storage Details
- Size:
- 13.7 kB
- Xet hash:
- 6a4904cc3ecca4af45d3ec158600d0b4459e9c910b78ba69aca6ae93ba8323cc
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.