diffusers/main/fr/api/schedulers/tcd.md

TCDScheduler

Trajectory Consistency Distillation de Jianbin Zheng, Minghui Hu, Zhongyi Fan, Chaoyue Wang, Changxing Ding, Dacheng Tao et Tat-Jen Cham a introduit un échantillonnage stochastique stratégique (Algorithme 4) capable de générer de bons échantillons en un petit nombre d'étapes. En tant qu'itération avancée du planificateur multi-étapes (Algorithme 1) des Consistency Models, l'échantillonnage stochastique stratégique est spécifiquement adapté à la fonction de cohérence de trajectoire.

L'abstract de l'article est :

Le modèle de cohérence latente (LCM) étend le modèle de cohérence à l’espace latent et exploite la technique de distillation de cohérence guidée pour obtenir des performances impressionnantes dans l’accélération de la synthèse texte-vers-image. Cependant, nous avons observé que le LCM a du mal à générer des images à la fois claires et richement détaillées. Pour remédier à cette limitation, nous analysons et clarifions d’abord les causes sous-jacentes. Notre enquête identifie que le problème principal provient d’erreurs dans trois domaines distincts. Par conséquent, nous introduisons la distillation de cohérence de trajectoire (TCD), qui englobe la fonction de cohérence de trajectoire et l’échantillonnage stochastique stratégique. La fonction de cohérence de trajectoire réduit les erreurs de distillation en élargissant le champ de la condition aux limites d’auto-cohérence et en dotant le TCD de la capacité à tracer précisément toute la trajectoire de l’EDO de flux de probabilité. De plus, l’échantillonnage stochastique stratégique est spécifiquement conçu pour contourner les erreurs accumulées inhérentes à l’échantillonnage de cohérence multi-étapes, et est soigneusement adapté pour compléter le modèle TCD. Les expériences démontrent que le TCD non seulement améliore considérablement la qualité des images à faible NFE, mais produit également des résultats plus détaillés par rapport au modèle enseignant à haut NFE.

Le code source original peut être trouvé sur jabir-zheng/TCD.

TCDScheduler[[diffusers.TCDScheduler]]

diffusers.TCDScheduler[[diffusers.TCDScheduler]]

diffusers.TCDScheduler(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)

Source

Paramètres :

num_train_timesteps (int, par défaut 1000) : Le nombre d'étapes de diffusion pour entraîner le modèle.

beta_start (float, par défaut 0.00085) : valeur initiale de beta pour l'inférence.

beta_end (float, par défaut 0.012) : La valeur finale de beta.

beta_schedule (str, par défaut "scaled_linear") : Le planning des bêtas, une correspondance entre une plage de bêtas et une séquence de bêtas pour faire avancer le modèle. Choisissez parmi linear, scaled_linear ou squaredcos_cap_v2.

trained_betas (np.ndarray ou list[float], facultatif) : Passez un tableau de bêtas directement au constructeur pour contourner beta_start et beta_end.

original_inference_steps (int, par défaut 50) : Le nombre par défaut d'étapes d'inférence utilisé pour générer un calendrier de pas de temps linéairement espacés, à partir duquel nous extrairons finalement num_inference_steps pas de temps uniformément espacés pour former le calendrier de pas de temps final.

clip_sample (bool, par défaut False) : Applique un seuil à l'échantillon prédit pour la stabilité numérique.

clip_sample_range (float, par défaut 1.0) : L'amplitude maximale pour le rognage des échantillons. Valable uniquement lorsque clip_sample=True.

set_alpha_to_one (bool, par défaut True) : Chaque étape de diffusion utilise la valeur du produit des alphas à cette étape et à l'étape précédente. Pour l'étape finale, il n'y a pas d'alpha précédent. Lorsque cette option est True, le produit des alphas précédents est fixé à 1, sinon il utilise la valeur de l'alpha à l'étape 0.

steps_offset (int, par défaut 0) : Un décalage ajouté aux étapes d'inférence, tel que requis par certaines familles de modèles.

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 paper).

thresholding (bool, par défaut False) : Indique s'il faut utiliser la méthode de « seuillage dynamique ». Cette méthode n'est pas adaptée aux modèles de diffusion en espace latent, tels que Stable Diffusion.

dynamic_thresholding_ratio (float, par défaut 0.995) : Le ratio pour la méthode de seuillage dynamique. Valable uniquement lorsque thresholding=True.

sample_max_value (float, par défaut 1.0) : La valeur de seuil pour le seuillage dynamique. Valable uniquement lorsque thresholding=True.

timestep_spacing (str, par défaut "leading") : La méthode de mise à l'échelle des timesteps. Consultez le tableau 2 de Common Diffusion Noise Schedules and Sample Steps are Flawed pour plus d'informations.

timestep_scaling (float, par défaut 10.0) : Le facteur par lequel les timesteps seront multipliés lors du calcul des conditions aux limites du modèle de cohérence c_skip et c_out. L'augmenter réduira l'erreur d'approximation (bien que l'erreur d'approximation par défaut de 10.0 soit déjà assez faible).

rescale_betas_zero_snr (bool, par défaut False) : Indique s'il faut rééchelonner les bêtas pour obtenir un SNR terminal nul. Cela permet au modèle de générer des échantillons très clairs et très sombres, au lieu de se limiter à des échantillons de luminosité moyenne. Lié de manière lâche à --offset_noise.

TCDScheduler intègre le Strategic Stochastic Sampling introduit par l’article Trajectory Consistency Distillation, étendant l’échantillonnage de cohérence multistep original pour permettre un parcours de trajectoire sans restriction.

Ce code est basé sur le dépôt officiel de TCD(https://github.com/jabir-zheng/TCD).

Ce modèle hérite de SchedulerMixin et de ConfigMixin. ~ConfigMixin gère le stockage de tous les attributs de configuration passés dans la fonction __init__ du scheduler, tels que num_train_timesteps. Ils sont accessibles via scheduler.config.num_train_timesteps. SchedulerMixin fournit des fonctionnalités générales de chargement et d'enregistrement via les fonctions SchedulerMixin.save_pretrained() et from_pretrained().

add_noise[[diffusers.TCDScheduler.add_noise]]

add_noise(original_samples: Tensor, noise: Tensor, timesteps: IntTensor)

Source

Paramètres :

original_samples (torch.Tensor) : Les échantillons d'origine auxquels du bruit sera ajouté.

noise (torch.Tensor) : Le bruit à ajouter aux échantillons.

timesteps (torch.IntTensor) : Les pas de temps indiquant le niveau de bruit pour chaque échantillon.

Retourne : torch.Tensor

Les échantillons bruités.

Ajoutez du bruit aux échantillons d'origine en fonction de l'amplitude du bruit à chaque pas de temps (il s'agit du processus de diffusion avant).

get_velocity[[diffusers.TCDScheduler.get_velocity]]

get_velocity(sample: Tensor, noise: Tensor, timesteps: IntTensor)

Source

Paramètres :

sample (torch.Tensor) : L'échantillon d'entrée.

noise (torch.Tensor) : Le tenseur de bruit.

timesteps (torch.IntTensor) : Les pas de temps pour le calcul de la vitesse.

Retourne : torch.Tensor

La vitesse calculée.

Calculer la prédiction de vitesse à partir de l'échantillon et du bruit selon la formule de vitesse.

index_for_timestep[[diffusers.TCDScheduler.index_for_timestep]]

index_for_timestep(timestep: typing.Union[float, torch.Tensor], schedule_timesteps: typing.Optional[torch.Tensor] = None)

Source

Paramètres :

timestep (float ou torch.Tensor) : La valeur de timestep à rechercher dans le planning.

schedule_timesteps (torch.Tensor, facultatif) : Le calendrier des pas de temps à explorer. Si None, utilise self.timesteps.

Retourne : int

L'indice de la pas de temps dans le planning. Pour la toute première étape, renvoie le deuxième indice si plusieurs correspondances existent, afin d'éviter de sauter un sigma lors d'un démarrage en cours de planning (par exemple, pour l'image-vers-image).

Trouver l'index d'une étape de temps donnée dans le calendrier des étapes de temps.

previous_timestep[[diffusers.TCDScheduler.previous_timestep]]

previous_timestep(timestep: int)

Source

Paramètres :

timestep (int) : L'étape temporelle actuelle.

Retourne : int ou torch.Tensor

L'étape de temps précédente.

Calculer l'étape précédente dans la chaîne de diffusion.

scale_model_input[[diffusers.TCDScheduler.scale_model_input]]

scale_model_input(sample: Tensor, timestep: typing.Union[int, torch.Tensor, NoneType] = None)

Source

Paramètres :

sample (torch.Tensor) : L'échantillon d'entrée.

timestep (int ou torch.Tensor, facultatif) : L'étape temporelle actuelle dans la chaîne de diffusion.

Retourne : torch.Tensor

Un échantillon d'entrée mis à l'échelle.

Assure l'interchangeabilité avec les planificateurs qui doivent mettre à l'échelle l'entrée du modèle de débruitage en fonction de l'étape temporelle actuelle.

set_begin_index[[diffusers.TCDScheduler.set_begin_index]]

set_begin_index(begin_index: int = 0)

Source

Paramètres :

begin_index (int, par défaut 0) : L'index de début pour le planificateur.

Définit l'index de début pour le planificateur. Cette fonction doit être exécutée depuis le pipeline avant l'inférence.

set_timesteps[[diffusers.TCDScheduler.set_timesteps]]

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)

Source

Paramètres :

num_inference_steps (int, facultatif) : Le nombre d'étapes de diffusion utilisées lors de la génération d'échantillons avec un modèle pré-entraîné. Si utilisé, timesteps doit être None.

device (str ou torch.device, facultatif) : L'appareil vers lequel les timesteps doivent être déplacés. Si None, les timesteps ne sont pas déplacés.

original_inference_steps (int, facultatif) : Le nombre original d'étapes d'inférence, qui sera utilisé pour générer un calendrier de pas de temps linéairement espacé (différent de l'implémentation standard de diffusers). Nous prendrons ensuite num_inference_steps pas de temps de ce calendrier, espacés uniformément en termes d'indices, et l'utiliserons comme calendrier final des pas de temps. S'il n'est pas défini, il prendra par défaut la valeur de l'attribut original_inference_steps.

timesteps (list[int], facultatif) : Étapes personnalisées utilisées pour prendre en charge un espacement arbitraire entre les étapes. Si None, la stratégie d’espacement par défaut, à savoir un espacement égal entre les étapes sur le calendrier d’entraînement/distillation, est utilisée. Si timesteps est transmis, num_inference_steps doit être None.

strength (float, par défaut 1.0) : Utilisé pour déterminer le nombre de timesteps utilisés pour l'inférence lors de l'utilisation d'img2img, inpaint, etc.

Définit les pas de temps discrets utilisés pour la chaîne de diffusion (à exécuter avant l'inférence).

étape[[diffusers.TCDScheduler.step]]

step(model_output: Tensor, timestep: typing.Union[int, torch.Tensor], sample: Tensor, eta: float = 0.3, generator: typing.Optional[torch.Generator] = None, return_dict: bool = True)

Source

Paramètres :

model_output (torch.Tensor) : La sortie directe du modèle de diffusion appris.

timestep (int ou torch.Tensor) : L'étape discrète actuelle dans la chaîne de diffusion.

sample (torch.Tensor) : Une instance actuelle d'un échantillon créé par le processus de diffusion.

eta (float, par défaut 0.3) : Un paramètre stochastique (dénommé gamma dans l'article) utilisé pour contrôler la stochasticité à chaque étape. Lorsque eta = 0, il représente un échantillonnage déterministe, tandis que eta = 1 indique un échantillonnage entièrement stochastique.

generator (torch.Generator, facultatif) : Un générateur de nombres aléatoires.

return_dict (bool, par défaut True) : Indique s'il faut retourner un TCDSchedulerOutput ou un tuple.

Retourne : TCDSchedulerOutput ou tuple[torch.Tensor, torch.Tensor]

If return_dict is True, TCDSchedulerOutput is returned, otherwise a tuple is returned containing the previous sample and the predicted noised sample.

Prédit l'échantillon de l'étape temporelle précédente en inversant l'EDS. Cette fonction propage le processus de diffusion à partir des sorties du modèle appris (le plus souvent le bruit prédit).

TCDSchedulerOutput[[diffusers.schedulers.scheduling_tcd.TCDSchedulerOutput]]

diffusers.schedulers.scheduling_tcd.TCDSchedulerOutput[[diffusers.schedulers.scheduling_tcd.TCDSchedulerOutput]]

diffusers.schedulers.scheduling_tcd.TCDSchedulerOutput(prev_sample: Tensor, pred_noised_sample: typing.Optional[torch.Tensor] = None)

Source

Paramètres :

prev_sample (torch.Tensor de forme (batch_size, num_channels, height, width) pour les images) : Échantillon calculé (x_{t-1}) de l'étape temporelle précédente. prev_sample doit être utilisé comme entrée du modèle suivante dans la boucle de débruitage.

pred_noised_sample (torch.Tensor de forme (batch_size, num_channels, height, width) pour les images, facultatif) : L'échantillon bruité prédit (x_{s}) basé sur la sortie du modèle à l'étape temporelle actuelle.

Classe de sortie pour la sortie de la fonction step du planificateur.