Buckets:
| # DDPMScheduler | |
| [Denoising Diffusion Probabilistic Models](https://huggingface.co/papers/2006.11239) (DDPM), de Jonathan Ho, Ajay Jain e Pieter Abbeel, propõe um modelo baseado em difusão com o mesmo nome. No contexto da biblioteca 🤗 Diffusers, DDPM se refere ao agendador de desruidização discreto do artigo, bem como ao pipeline. | |
| O resumo do artigo é: | |
| *Apresentamos resultados de alta qualidade em síntese de imagens usando modelos probabilísticos de difusão, uma classe de modelos de variáveis latentes inspirada em considerações da termodinâmica de não equilíbrio. Nossos melhores resultados são obtidos treinando em um limite variacional ponderado projetado de acordo com uma nova conexão entre modelos probabilísticos de difusão e correspondência de escores de desruído com dinâmica de Langevin, e nossos modelos admitem naturalmente um esquema progressivo de descompressão com perdas que pode ser interpretado como uma generalização da decodificação autoregressiva. No conjunto de dados incondicional CIFAR10, obtemos uma pontuação Inception de 9,46 e uma pontuação FID do estado da arte de 3,17. Em 256x256 LSUN, obtemos qualidade de amostras semelhante à do ProgressiveGAN. Nossa implementação está disponível em [este URL https](https://github.com/hojonathanho/diffusion).* | |
| ## DDPMScheduler[[diffusers.DDPMScheduler]] | |
| #### diffusers.DDPMScheduler[[diffusers.DDPMScheduler]] | |
| ```python | |
| diffusers.DDPMScheduler(num_train_timesteps: int = 1000, beta_start: float = 0.0001, beta_end: float = 0.02, beta_schedule: typing.Literal['linear', 'scaled_linear', 'squaredcos_cap_v2', 'sigmoid'] = 'linear', trained_betas: numpy.ndarray | list[float] | None = None, variance_type: typing.Literal['fixed_small', 'fixed_small_log', 'fixed_large', 'fixed_large_log', 'learned', 'learned_range'] = 'fixed_small', clip_sample: bool = True, prediction_type: typing.Literal['epsilon', 'sample', 'v_prediction'] = 'epsilon', thresholding: bool = False, dynamic_thresholding_ratio: float = 0.995, clip_sample_range: float = 1.0, sample_max_value: float = 1.0, timestep_spacing: typing.Literal['linspace', 'leading', 'trailing'] = 'leading', steps_offset: int = 0, rescale_betas_zero_snr: bool = False) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_ddpm.py#L137) | |
| **Parâmetros:** | |
| num_train_timesteps (`int`, padrão `1000`) : O número de etapas de difusão para treinar o modelo. | |
| beta_start (`float`, padrão `0.0001`) : O valor inicial de `beta` para a inferência. | |
| beta_end (`float`, padrão `0.02`) : O valor final de `beta`. | |
| beta_schedule (`"linear"`, `"scaled_linear"`, `"squaredcos_cap_v2"` ou `"sigmoid"`, padrão `"linear"`) : O agendamento de beta, um mapeamento de um intervalo de beta para uma sequência de betas para dar passos no modelo. | |
| trained_betas (`np.ndarray`, *opcional*) : Um array de betas para passar diretamente ao construtor sem usar `beta_start` e `beta_end`. | |
| variance_type (`"fixed_small"`, `"fixed_small_log"`, `"fixed_large"`, `"fixed_large_log"`, `"learned"` ou `"learned_range"`, padrão `"fixed_small"`) : Recorta a variância ao adicionar ruído à amostra desruidizada. | |
| clip_sample (`bool`, padrão `True`) : Recorta a amostra prevista para estabilidade numérica. | |
| clip_sample_range (`float`, padrão `1.0`) : A magnitude máxima para o recorte de amostras. Válido apenas quando `clip_sample=True`. | |
| prediction_type (`"epsilon"`, `"sample"`, or `"v_prediction"`, 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`, padrão `False`) : Se deve usar o método de "limiar dinâmico". Isso não é adequado para modelos de difusão em espaço latente, como o Stable Diffusion. | |
| dynamic_thresholding_ratio (`float`, padrão `0.995`) : A proporção para o método de limiar dinâmico. Válido apenas quando `thresholding=True`. | |
| sample_max_value (`float`, padrão `1.0`) : O valor de limiar para o limiar dinâmico. Válido apenas quando `thresholding=True`. | |
| timestep_spacing (`"linspace"`, `"leading"` ou `"trailing"`, padrão `"leading"`) : A forma como os timesteps devem ser escalonados. Consulte a Tabela 2 do [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) para mais informações. | |
| steps_offset (`int`, padrão `0`) : Um deslocamento adicionado às etapas de inferência, conforme exigido por algumas famílias de modelos. | |
| rescale_betas_zero_snr (`bool`, padrão `False`) : Se deve reescalar os betas para ter SNR terminal zero. Isso permite que o modelo gere amostras muito claras e escuras, em vez de limitá-lo a amostras com brilho médio. Relacionado de forma solta a [`--offset_noise`](https://github.com/huggingface/diffusers/blob/74fd735eb073eb1d774b1ab4154a0876eb82f055/examples/dreambooth/train_dreambooth.py#L506). | |
| `DDPMScheduler` explora as conexões entre o denoising score matching e a amostragem por dinâmica de Langevin. | |
| Este modelo herda de [SchedulerMixin](/docs/diffusers/main/pt/api/schedulers/overview#diffusers.SchedulerMixin) e [ConfigMixin](/docs/diffusers/main/pt/api/configuration#diffusers.ConfigMixin). Consulte a documentação da superclasse para os métodos genéricos que a biblioteca implementa para todos os agendadores, como carregamento e salvamento. | |
| #### add_noise[[diffusers.DDPMScheduler.add_noise]] | |
| ```python | |
| add_noise(original_samples: Tensor, noise: Tensor, timesteps: IntTensor) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_ddpm.py#L569) | |
| **Parâmetros:** | |
| original_samples (`torch.Tensor`) : As amostras originais às quais o ruído será adicionado. | |
| noise (`torch.Tensor`) : O ruído a ser adicionado às amostras. | |
| timesteps (`torch.IntTensor`) : Os timesteps que indicam o nível de ruído para cada amostra. | |
| **Retorna:** `torch.Tensor` | |
| As amostras ruidosas. | |
| Adicione ruído às amostras originais de acordo com a magnitude do ruído em cada timestep (este é o processo de difusão direta). | |
| #### get_velocity[[diffusers.DDPMScheduler.get_velocity]] | |
| ```python | |
| get_velocity(sample: Tensor, noise: Tensor, timesteps: IntTensor) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_ddpm.py#L611) | |
| **Parâmetros:** | |
| sample (`torch.Tensor`) : A amostra de entrada. | |
| noise (`torch.Tensor`) : O tensor de ruído. | |
| timesteps (`torch.IntTensor`) : Os passos de tempo para o cálculo da velocidade. | |
| **Retorna:** `torch.Tensor` | |
| A velocidade calculada. | |
| Calcule a previsão de velocidade a partir da amostra e do ruído de acordo com a fórmula de velocidade. | |
| #### previous_timestep[[diffusers.DDPMScheduler.previous_timestep]] | |
| ```python | |
| previous_timestep(timestep: int) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_ddpm.py#L648) | |
| **Parâmetros:** | |
| timestep (`int`) : O timestep atual. | |
| **Retorna:** `int` ou `torch.Tensor` | |
| O passo de tempo anterior. | |
| Calcule o passo de tempo anterior na cadeia de difusão. | |
| #### scale_model_input[[diffusers.DDPMScheduler.scale_model_input]] | |
| ```python | |
| scale_model_input(sample: Tensor, timestep: int | None = None) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_ddpm.py#L257) | |
| **Parâmetros:** | |
| sample (`torch.Tensor`) : A amostra de entrada. | |
| timestep (`int`, *opcional*) : O timestep atual na cadeia de difusão. | |
| **Retorna:** `torch.Tensor` | |
| Uma amostra de entrada escalada. | |
| Garante a intercambiabilidade com agendadores que precisam escalar a entrada do modelo de desruidamento dependendo do passo de tempo atual. | |
| #### set_timesteps[[diffusers.DDPMScheduler.set_timesteps]] | |
| ```python | |
| set_timesteps(num_inference_steps: int = None, device: typing.Union[str, torch.device] = None, timesteps: list[int] | None = None) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_ddpm.py#L274) | |
| **Parâmetros:** | |
| num_inference_steps (`int`, *opcional*) : O número de etapas de difusão usadas ao gerar amostras com um modelo pré-treinado. Se usado, `timesteps` deve ser `None`. | |
| device (`str` ou `torch.device`, *opcional*) : O dispositivo para o qual os timesteps devem ser movidos. Se `None`, os timesteps não são movidos. | |
| timesteps (`list[int]`, *opcional*) : Passos de tempo personalizados usados para suportar espaçamento arbitrário entre os passos de tempo. Se `None`, a estratégia de espaçamento padrão de passos de tempo, com espaçamento igual entre eles, é utilizada. Se `timesteps` for passado, `num_inference_steps` deve ser `None`. | |
| Define os passos discretos usados para a cadeia de difusão (a ser executado antes da inferência). | |
| #### etapa[[diffusers.DDPMScheduler.step]] | |
| ```python | |
| step(model_output: Tensor, timestep: int, sample: Tensor, generator: typing.Optional[torch.Generator] = None, return_dict: bool = True) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_ddpm.py#L461) | |
| **Parâmetros:** | |
| model_output (`torch.Tensor`) : A saída direta do modelo de difusão aprendido. | |
| timestep (`int`) : O passo de tempo discreto atual na cadeia de difusão. | |
| sample (`torch.Tensor`) : Uma instância atual de uma amostra criada pelo processo de difusão. | |
| generator (`torch.Generator`, *opcional*) : Um gerador de números aleatórios. | |
| return_dict (`bool`, padrão `True`) : Se deve ou não retornar um [DDPMSchedulerOutput](/docs/diffusers/main/pt/api/schedulers/ddpm#diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput) ou `tuple`. | |
| **Retorna:** [DDPMSchedulerOutput](/docs/diffusers/main/pt/api/schedulers/ddpm#diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput) ou `tuple` | |
| If return_dict is `True`, [DDPMSchedulerOutput](/docs/diffusers/main/pt/api/schedulers/ddpm#diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput) is returned, otherwise a tuple is returned where the first element is the sample tensor. | |
| Preveja a amostra do passo de tempo anterior revertendo o SDE. Esta função propaga o processo de difusão a partir das saídas do modelo aprendido (na maioria das vezes, o ruído previsto). | |
| ## DDPMSchedulerOutput[[diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput]] | |
| #### diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput[[diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput]] | |
| ```python | |
| diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput(prev_sample: Tensor, pred_original_sample: typing.Optional[torch.Tensor] = None) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_ddpm.py#L31) | |
| **Parâmetros:** | |
| prev_sample (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` para imagens) : Amostra calculada `(x_{t-1})` do passo anterior. `prev_sample` deve ser usado como entrada do próximo modelo no loop de remoção de ruído. | |
| pred_original_sample (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` para imagens) : A amostra desrujida prevista `(x_{0})` com base na saída do modelo do timestep atual. `pred_original_sample` pode ser usado para visualizar o progresso ou para orientação. | |
| Classe de saída para a saída da função `step` do agendador. | |
Xet Storage Details
- Size:
- 11.5 kB
- Xet hash:
- 33dfaee42f378f23f23f2390bcc2a1470dcecb311e50e6adf0de7d65056a3905
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.