o jQ@s@dZddlZddlZddlZddlZddlZddlmZddlm Z m Z m Z zddl m Z mZee dZWn ey@dZYnwgdZdd Zd d Zd d ZddZddZd'ddZGdddejZGdddejZGdddejZGdddZGdddeZdd ZGd!d"d"ZGd#d$d$Z d%d&Z!dS)(a This is an almost carbon copy of gaussian_diffusion.py from OpenAI's ImprovedDiffusion repo, which itself: This code started out as a PyTorch port of Ho et al's diffusion models: https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/diffusion_utils_2.py Docstrings have been added, as well as DDIM sampling and a new collection of beta schedules. Ntqdm) DPM_SolverNoiseScheduleVP model_wrapper)sample_dpmpp_2msample_euler_ancestral) k_euler_adpm++2m)r pddimcsd||||fD] }t|tjr|nqdusJdfdd||fD\}}dd||t||||dt| S)z Compute the KL divergence between two gaussians. Shapes are automatically broadcasted, so batches can be compared to scalars, among other use cases. Nz&at least one argument must be a Tensorcs,g|]}t|tjr |nt|qS) isinstancethTensortensorto.0xrr T/home/kuhnn/.local/lib/python3.10/site-packages/TTS/tts/layers/tortoise/diffusion.py /s,znormal_kl..?g)rrrexp)mean1logvar1mean2logvar2objr rr normal_kls 6r!c Cs2ddttdtj|dt|dS)zb A fast approximation of the cumulative distribution function of the standard normal. r?@gHm?)rtanhnpsqrtpipowrr r rapprox_standard_normal_cdf4s2r+c Cs|j|jkr|jksJJ||}t| }||d}t|}||d}t|}t|jdd} td|jdd} ||} t|dk| t|dk| t| jdd} | j|jksfJ| S)a{ Compute the log-likelihood of a Gaussian distribution discretizing to a given image. :param x: the target images. It is assumed that this was uint8 values, rescaled to the range [-1, 1]. :param means: the Gaussian mean Tensor. :param log_scales: the Gaussian log stddev Tensor. :return: a tensor like x of log probabilities (in nats). gp?g-q=)minr"g++?)shaperrr+logclampwhere) rmeans log_scales centered_xinv_stdvplus_incdf_plusmin_incdf_min log_cdf_pluslog_one_minus_cdf_min cdf_delta log_probsr r r#discretized_gaussian_log_likelihood<s""    r>cCs|jttdt|jdS)z6 Take the mean over all non-batch dimensions. dim)meanlistrangelenr.rr r r mean_flatZsrFcCsX|dkrd|}|d}|d}tj|||tjdS|dkr%t|ddStd |) a@ Get a pre-defined beta schedule for the given name. The beta schedule library consists of beta schedules which remain similar in the limit of num_diffusion_timesteps. Beta schedules may be added, but should not be removed or changed once they are committed to maintain backwards compatibility. linearg-C6?g{Gz?dtypecosinecSs t|ddtjddS)NgMb?gT㥛 ?r)mathcosr()tr r rts z)get_named_beta_schedule..zunknown beta schedule: )r&linspacefloat64betas_for_alpha_barNotImplementedError) schedule_namenum_diffusion_timestepsscale beta_startbeta_endr r rget_named_beta_scheduleas rYr-cCsPg}t|D]}||}|d|}|td|||||qt|S)a$ Create a beta schedule that discretizes the given alpha_t_bar function, which defines the cumulative product of (1-beta) over time from t = [0,1]. :param num_diffusion_timesteps: the number of betas to produce. :param alpha_bar: a lambda that takes an argument t from 0 to 1 and produces the cumulative product of (1-beta) up to that part of the diffusion process. :param max_beta: the maximum beta to use; use values lower than 1 to prevent singularities. r?)rDappendr,r&array)rU alpha_barmax_betabetasit1t2r r rrRzs   " rRc@seZdZdZdZdZdZdS) ModelMeanTypez2 Which type of output the model predicts. previous_xstart_xepsilonN)__name__ __module__ __qualname____doc__ PREVIOUS_XSTART_XEPSILONr r r rrbs rbc@s eZdZdZdZdZdZdZdS) ModelVarTypez What is used as the model's output variance. The LEARNED_RANGE option has been added to allow the model to predict values between FIXED_SMALL and FIXED_LARGE, making its job easier. learned fixed_small fixed_large learned_rangeN)rfrgrhriLEARNED FIXED_SMALL FIXED_LARGE LEARNED_RANGEr r r rrms rmc@s$eZdZdZdZdZdZddZdS)LossTypemse rescaled_msekl rescaled_klcCs|tjkp |tjkSN)rvKL RESCALED_KL)selfr r ris_vbszLossType.is_vbN)rfrgrhMSE RESCALED_MSEr|r}rr r r rrvs  rvc@sleZdZdZddddddddZd d Zd;d d ZddZdd"d#Z  d=d$d%Z  d=d&d'Z  (d?d)d*Z  (d@d+d,Z   (dAd-d.Z   (dAd/d0ZdBd1d2ZdCd3d4Z dCd5d6Zd7d8ZdBd9d:Zd S)DGaussianDiffusionaO Utilities for training and sampling diffusion models. Ported directly from here, and then adapted over time to further experimentation. https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/diffusion_utils_2.py#L42 :param betas: a 1-D numpy array of betas for each diffusion timestep, starting at T and going to 1. :param model_mean_type: a ModelMeanType determining what the model outputs. :param model_var_type: a ModelVarType determining how variance is output. :param loss_type: a LossType determining the loss function to use. :param rescale_timesteps: if True, pass floating point timesteps into the model so that they are always scaled like in the original paper (0 to 1000). Fr?Tr )rescale_timestepsconditioning_freeconditioning_free_kramp_conditioning_freesamplerc Cs| |_t||_t||_t||_||_||_||_ ||_ t j |t j d}||_t|jdks4Jd|dkr@|dksBJt|jd|_d|} t j| dd|_t d|jdd|_t |jddd|_|jj|jfksxJt |j|_t d|j|_t d|j|_t d|j|_t d|jd|_|d|jd|j|_ t t |j d|j dd|_!|t |jd|j|_"d|jt | d|j|_#dS) NrIr?zbetas must be 1-Drr")axis)$rrbmodel_mean_typermmodel_var_typerv loss_typerrrrr&r[rQr^rEr.allint num_timestepscumprodalphas_cumprodrZalphas_cumprod_prevalphas_cumprod_nextr'sqrt_alphas_cumprodsqrt_one_minus_alphas_cumprodr/log_one_minus_alphas_cumprodsqrt_recip_alphas_cumprodsqrt_recipm1_alphas_cumprodposterior_varianceposterior_log_variance_clippedposterior_mean_coef1posterior_mean_coef2) r~r^rrrrrrrralphasr r r__init__s6   $$zGaussianDiffusion.__init__cCsBt|j||j|}td|j||j}t|j||j}|||fS)a Get the distribution q(x_t | x_0). :param x_start: the [N x C x ...] tensor of noiseless inputs. :param t: the number of diffusion steps (minus 1). Here, 0 means one step. :return: A tuple (mean, variance, log_variance), all of x_start's shape. r")_extract_into_tensorrr.rr)r~x_startrNrBvariance log_variancer r rq_mean_variances z!GaussianDiffusion.q_mean_varianceNcCsJ|dur t|}|j|jksJt|j||j|t|j||j|S)am Diffuse the data for a given number of diffusion steps. In other words, sample from q(x_t | x_0). :param x_start: the initial data batch. :param t: the number of diffusion steps (minus 1). Here, 0 means one step. :param noise: if specified, the split-out normal noise. :return: A noisy version of x_start. N)r randn_liker.rrr)r~rrNnoiser r rq_samples zGaussianDiffusion.q_samplecCs|j|jksJt|j||j|t|j||j|}t|j||j}t|j||j}|jd|jdkrH|jdkrH|jdksKJJ|||fS)zo Compute the mean and variance of the diffusion posterior: q(x_{t-1} | x_t, x_0) r)r.rrrrr)r~rx_trNposterior_meanrrr r rq_posterior_mean_variances z+GaussianDiffusion.q_posterior_mean_variancec s|duri}|jdd\}}|j|fksJ||||fi|} |jr4||||fddi|} |jtjtjfvr| j||dg|jddRksPJtj| |dd\} } |jrgtj| |dd\} } |jtjkru| } t | }net |j ||j}t t |j||j}| dd}||d||} t | }n.process_xstart)rrNxprev)rrNepsrrrN)rBrr pred_xstart) r._scale_timestepsrrrmrrrursplitrrrr&r/r^rtrZrrsrritemrrrbrj_predict_xstart_from_xprevrkrl_predict_xstart_from_epsrrS)r~modelrrNrr model_kwargsBC model_outputmodel_output_no_conditioningmodel_var_values_model_log_variancemodel_variancemin_logmax_logfraccfkrr model_meanr rrp_mean_variance*sn&       $  4z!GaussianDiffusion.p_mean_variancecCs8|j|jksJt|j||j|t|j||j|Sr{)r.rrr)r~rrNrr r rrs z*GaussianDiffusion._predict_xstart_from_epscCsB|j|jksJtd|j||j|t|j|j||j|S)Nr")r.rrr)r~rrNrr r rrs z,GaussianDiffusion._predict_xstart_from_xprevcCs(t|j||j||t|j||jSr{)rrr.r)r~rrNrr r r_predict_eps_from_xstartsz*GaussianDiffusion._predict_eps_from_xstartcCs|jr |d|jS|S)N@@)rfloatrr~rNr r rrsz"GaussianDiffusion._scale_timestepscCs8||||fi|}|d|d|}|S)a[ Compute the mean for the previous step, given a function cond_fn that computes the gradient of a conditional log probability with respect to x. In particular, cond_fn computes grad(log(p(y|x))), and we want to condition on y. This uses the conditioning strategy from Sohl-Dickstein et al. (2015). rBr)rr)r~cond_fn p_mean_varrrNrgradientnew_meanr r rcondition_means z GaussianDiffusion.condition_meanc Cst|j||j}||||d}|d|||||fi|}|}|||||d<|j|d||d\|d<} } |S)a3 Compute what the p_mean_variance output would have been, should the model's score function be conditioned by cond_fn. See condition_mean() for details on cond_fn. Unlike condition_mean(), this instead uses the conditioning strategy from Song et al (2020). rr?rrB) rrr.rr'rcopyrr) r~rrrrNrr\routrr r rcondition_scores (z!GaussianDiffusion.condition_scorec  sttsJ| durtj} ||jdg} fdd tdddd} fdd }t|| d d t d t d |j d }t || dd}|j ||jdddd}|S)Nrcs4|i|}tj||jdddd\}}||fS)Nr?rr@)rrr.)argskwargsr model_epsilon model_var)rr r model_splitsz>GaussianDiffusion.k_diffusion_sample_loop..model_splitrGg?g@)schedulecontinuous_beta_0continuous_beta_1csf |d\}}|dd\}}t||fddid||fidg}d|S)aT x_in = torch.cat([x] * 2) t_in = torch.cat([t_continuous] * 2) c_in = torch.cat([unconditional_condition, condition]) noise_uncond, noise = noise_pred_fn(x_in, t_in, cond=c_in).chunk(2) print(t) print(self.timestep_map) exit() rrHrTrr?)chunktorchcatupdate)rrNrrrres)rrpbarr rmodel_fn_prewraps  zCGaussianDiffusion.k_diffusion_sample_loop..model_fn_prewraprzclassifier-freer?) model_typer guidance_type conditionunconditional_conditionguidance_scalez dpmsolver++)algorithm_typer time_uniform multistep)stepsorder skip_typemethod)rdictnext parametersdevicenew_onesr.rrrrrrsampler)r~ k_samplerrrr.rrrrrrprogresss_innoise_schedulermodel_fn dpm_solverx_sampler )rrrrrk_diffusion_sample_loops6  z)GaussianDiffusion.k_diffusion_sample_loopcOs|j}|dkr|j|i|S|dkr|j|i|S|dkrW|jdur(tdt|jd}tdur7td|j t||g|Ri|WdS1sPwYdStd) Nr r r Tzcond_free must be true)totalz2Install k_diffusion for using k_diffusion samplerszsampler not impl) r p_sample_loopddim_sample_loopr RuntimeErrorrrK_DIFFUSION_SAMPLERSModuleNotFoundErrorr)r~rrsrr r r sample_loops $zGaussianDiffusion.sample_loopc Cs|j||||||d}t|} |dkjdgdgt|jdR} |dur5|j|||||d|d<|d| td|d | } | |d d S) a Sample x_{t-1} from the model at the given timestep. :param model: the model to sample from. :param x: the current tensor at x_{t-1}. :param t: the value of t, starting at 0 for the first diffusion step. :param clip_denoised: if True, clip the x_start prediction to [-1, 1]. :param denoised_fn: if not None, a function which applies to the x_start prediction before it is used to sample. :param cond_fn: if not None, this is a gradient function that acts similarly to the model. :param model_kwargs: if not None, a dict of extra keyword arguments to pass to the model. This can be used for conditioning. :return: a dict containing the following keys: - 'sample': a random sample from the model. - 'pred_xstart': a prediction of x_0. rrrrrr?NrrBrrrrr) rrrrviewrEr.rr) r~rrrNrrrrrr nonzero_maskrr r rp_sample"s *"zGaussianDiffusion.p_samplec Cs2d} |j||||||||| d D]} | } q| dS)a Generate samples from the model. :param model: the model module. :param shape: the shape of the samples, (N, C, H, W). :param noise: if specified, the noise from the encoder to sample. Should be of the same shape as `shape`. :param clip_denoised: if True, clip x_start predictions to [-1, 1]. :param denoised_fn: if not None, a function which applies to the x_start prediction before it is used to sample. :param cond_fn: if not None, this is a gradient function that acts similarly to the model. :param model_kwargs: if not None, a dict of extra keyword arguments to pass to the model. This can be used for conditioning. :param device: if specified, the device to create the samples on. If not specified, use a model parameter's device. :param progress: if True, show a tqdm progress bar. :return: a non-differentiable batch of samples. N)rrrrrrrr)p_sample_loop_progressive) r~rr.rrrrrrrfinalrr r rrLs  zGaussianDiffusion.p_sample_loopc  cs|dur t|j}t|ttfsJ|dur|} ntj|d|i} tt|j ddd} t | | dD]5} tj | g|d|d} t |j || | ||||d}|V|d} Wdn1sgwYq7dS) a Generate samples from the model and yield intermediate samples from each timestep of diffusion. Arguments are the same as p_sample_loop(). Returns a generator over dicts, where each dict is the return value of p_sample(). Nrrdisablerr)rrrrr)rrrrtuplerCrrandnrDrrrno_gradr )r~rr.rrrrrrrimgindicesr_rNrr r rr zs2  z+GaussianDiffusion.p_sample_loop_progressiverc Cs|j||||||d} |dur|j|| |||d} |||| d} t|j||j} t|j||j} |td| d| td| | } t |}| dt| td| | d| }|dk j dgdgt |jdR}||| |}|| dd S) z^ Sample x_{t-1} from the model using DDIM. Same usage as p_sample(). rNrrr?rrrr) rrrrrr.rrr'rrrrE)r~rrrNrrrretarrr\alpha_bar_prevsigmar mean_predr rr r r ddim_samples&, ,*zGaussianDiffusion.ddim_samplec Cs|dksJd|j||||||d}t|j||j||dt|j||j} t|j||j} |dt| td| | } | |ddS)zG Sample x_{t+1} from the model using DDIM reverse ODE. rz'Reverse ODE only for deterministic pathrrr?r)rrrr.rrrr') r~rrrNrrrrrralpha_bar_nextrr r rddim_reverse_samples  $z%GaussianDiffusion.ddim_reverse_samplec Cs4d} |j||||||||| | d D]} | } q| dS)ze Generate samples from the model using DDIM. Same usage as p_sample_loop(). N)rrrrrrrrr)ddim_sample_loop_progressive) r~rr.rrrrrrrrr rr r rrs  z"GaussianDiffusion.ddim_sample_loopc  cs|dur t|j}t|ttfsJ|dur|} ntj|d|i} tt|j ddd} | r?ddl m } | | | d} | D]6}tj |g|d|d}t |j|| |||||| d}|V|d } Wdn1srwYqAdS) z Use DDIM to sample from the model and yield intermediate samples from each timestep of DDIM. Same usage as p_sample_loop_progressive(). Nrrrrr r)rrrrrr)rrrrrrCrrrDr tqdm.autorrrr)r~rr.rrrrrrrrrrrr_rNrr r rrs:   z.GaussianDiffusion.ddim_sample_loop_progressivecCs|j|||d\}}} |j|||||d} t|| | d| d} t| td} t|| dd| dd } | j|jks?Jt| td} t |dk| | } | | d d S) ai Get a term for the variational lower-bound. The resulting units are bits (rather than nats, as one might expect). This allows for comparison to other papers. :return: a dict with the following keys: - 'output': a shape [N] tensor of NLLs or KLs. - 'pred_xstart': the x_0 predictions. r)rrrBrr#r)r2r3rr)outputr) rrr!rFr&r/r>r.rr1)r~rrrrNrr true_meanrtrue_log_variance_clippedrry decoder_nllrr r r _vb_terms_bpdEs zGaussianDiffusion._vb_terms_bpdcCs|duri}|durt|}|j|||d}i}|jtjks%|jtjkrE|j||||d|dd|d<|jtjkrC|d|j9<|S|jtj ksR|jtj krA||| |fi|}t |t rp|d} |dd|d <n|} |jtjtjfvr|jdd \} } | j| | d g|jd dRksJtj| | dd \} } tj| | gdd } |j| d d d|||ddd|d<|jtj kr|d|jd9<|jtjkr|j|||dd}t|}n!|jtjkr|}| }n|jtjkr|}|||| }nt|j| j|jkr|jksJJt || d |d<||d<d|vr9|d|d|d<|S|d|d<|St|j)\ Compute training losses for a single timestep. :param model: the model to evaluate loss on. :param x_start: the [N x C x ...] tensor of inputs. :param t: a batch of timestep indices. :param model_kwargs: if not None, a dict of extra keyword arguments to pass to the model. This can be used for conditioning. :param noise: if specified, the specific Gaussian noise to try to remove. :return: a dict with the key "loss" containing a tensor of shape [N]. Some mean or variance settings may also have other keys. NrF)rrrrNrrrlossrr? extra_outputsrr@rcW|Sr{r r(rr r rrOz3GaussianDiffusion.training_losses..rrrrNrvbrrrwx_start_predicted)!rrrrrvr|r}r"rrrrrrrrmrrrur.rrdetachrrbrjrrzerosrkrlrrSrF)r~rrrNrrrterms model_outputsrrrr frozen_outtarget x_start_predr r rtraining_losses`s   4 &      &   z!GaussianDiffusion.training_lossescCsb|duri}|durt|}|j|||d}i} |jtjks%|jtjkr'J|jtjks4|jtjkr,|||| |fi|} | ddt || D| |} |j t jt jfvr|jdd\} } | j| | dg|jddRksvJ| dddddf| dddddf} }tj| |gdd }|j|d d d |||dd d| d<|jtjkr| d|jd9<|jtjkr|j|||dd}t|}n |jtjkr|}| }n|jtjkr|}|||| }nt|j| j|jkr|jksJJt|| d| d<|| d<d| vr$| d| d| d<| S| d| d<| St|j)r#Nr$FcSsi|]\}}||qSr r )rkor r r szDGaussianDiffusion.autoregressive_training_losses..rrr?r@r'cWr)r{r r*r r rrOr+zBGaussianDiffusion.autoregressive_training_losses..r,rr-rrrwr.r%) rrrrrvr|r}rrrrziprrmrrrur.rr/r"rrrbrjrrr0rkrlrrSrF)r~rrrNmodel_output_keys gd_out_keyrrrr1r2rrrrr3r4r5r r rautoregressive_training_lossessd $.       &   z0GaussianDiffusion.autoregressive_training_lossescCsZ|jd}tj|jdg||jd}|||\}}}t||ddd}t|t dS)a= Get the prior KL term for the variational lower-bound, measured in bits-per-dim. This term can't be optimized, as it only depends on the encoder. :param x_start: the [N x C x ...] tensor of inputs. :return: a batch of [N] KL values (in bits), one per batch element. rr?rr)rrrrr#) r.rrrrrr!rFr&r/)r~r batch_sizerNqt_meanrqt_log_variancekl_priorr r r _prior_bpds zGaussianDiffusion._prior_bpdc CsJ|j}|jd}g}g}g} tt|jdddD]`} tj| g||d} t|} |j|| | d} t |j ||| | ||d}Wdn1sMwY| |d| t |d|d | | | |d}| t || d qtj|d d }tj|d d }tj| d d } ||}|jd d |}||||| d S) au Compute the entire variational lower-bound, measured in bits-per-dim, as well as other related quantities. :param model: the model to evaluate loss on. :param x_start: the [N x C x ...] tensor of inputs. :param clip_denoised: if True, clip denoised samples. :param model_kwargs: if not None, a dict of extra keyword arguments to pass to the model. This can be used for conditioning. :return: a dict containing the following keys: - total_bpd: the total variational lower-bound, per batch element. - prior_bpd: the prior term in the lower-bound. - vb: an [N x T] tensor of terms in the lower-bound. - xstart_mse: an [N x T] tensor of x_0 MSEs for each timestep. - mse: an [N x T] tensor of epsilon MSEs for each timestep. rNrr)rrNr)rrrNrrrrrr?r@) total_bpd prior_bpdr- xstart_mserw)rr.rCrDrrrrrrr"rZrFrstackrBsum)r~rrrrrr>r-rErwrNt_batchrrrrrDrCr r r calc_bpd_loopsD     zGaussianDiffusion.calc_bpd_loopr{)TNN)NTNNNNF)TNNN)TNNNr)TNNr)NTNNNNFr)TN)NN)rfrgrhrirrrrrrrrrrrrrr rr rrrrr"r6r=rBrIr r r rrs 3  `   O . 2 1 . & & 2 W HrcsneZdZdZfddZfddZfddZfdd Zfd d Zfd d Z dddZ ddZ Z S)SpacedDiffusiona# A diffusion process which can skip steps in a base diffusion process. :param use_timesteps: a collection (sequence or set) of timesteps from the original diffusion process to retain. :param kwargs: the kwargs to create the base diffusion process. c st||_g|_t|d|_tdi|}d}g}t|jD]\}}||jvr9|d|||}|j|qt ||d<t j di|dS)Nr^r"r?r ) set use_timesteps timestep_maprEoriginal_num_stepsr enumeraterrZr&r[superr)r~rLrbase_diffusionlast_alpha_cumprod new_betasr_ alpha_cumprod __class__r rrQs   zSpacedDiffusion.__init__c tj||g|Ri|Sr{)rPr _wrap_modelr~rrrrUr rr` zSpacedDiffusion.p_mean_variancecrWr{)rPr6rXrYrUr rr6crZzSpacedDiffusion.training_lossescs"tj||dg|Ri|S)NT)rPr=rXrYrUr rr=fs"z.SpacedDiffusion.autoregressive_training_lossescrWr{)rPrrXr~rrrrUr rrirZzSpacedDiffusion.condition_meancrWr{)rPrrXr[rUr rrlrZzSpacedDiffusion.condition_scoreFcCs8t|ts t|tr |S|rtnt}|||j|j|jSr{)r _WrappedModel_WrappedAutoregressiveModelrMrrN)r~rautoregressivemodr r rrXos zSpacedDiffusion._wrap_modelcCs|Sr{r rr r rrusz SpacedDiffusion._scale_timesteps)F) rfrgrhrirrr6r=rrrXr __classcell__r r rUrrJHs       rJcCsLt|trB|dr8t|tdd}td|D]}ttd|||kr/ttd||Sqtd|ddd|d D}|t|}|t|}d}g}t |D]K\}}|||kradnd} | |krrtd | d ||dkryd} n| d|d} d } g} t|D]} | |t | | | 7} q|| 7}|| 7}qVt|S) aT Create a list of timesteps to use from an original diffusion process, given the number of timesteps we want to take from equally-sized portions of the original process. For example, if there's 300 timesteps and the section counts are [10,15,20] then the first 100 timesteps are strided to be 10 timesteps, the second 100 are strided to be 15 timesteps, and the final 100 are strided to be 20. If the stride is a string starting with "ddim", then the fixed striding from the DDIM paper is used, and only one section is allowed. :param num_timesteps: the number of diffusion steps in the original process to divide up. :param section_counts: either a list of numbers, or a string containing comma-separated numbers, indicating the step count per section. As a special case, use "ddimN" where N is a number of steps to use the striding from the DDIM paper. :return: a set of diffusion steps from the original process to use. r Nr?rzcannot create exactly z steps with an integer stridecSsg|]}t|qSr )rrr r rrsz#space_timesteps..,zcannot divide section of z steps into r) rstr startswithrrErDrK ValueErrorrrOrZround)rsection_counts desired_countr_size_perextra start_idx all_steps section_countsize frac_stridecur_idx taken_stepsrr r rspace_timestepszs8       rqc@eZdZddZddZdS)r\cC||_||_||_||_dSr{rrMrrNr~rrMrrNr r rr z_WrappedModel.__init__cKsNtj|j|j|jd}||}|jr|d|j}|j||fi|}|SN)rrJr rrrMrrJrrrNr)r~rtsr map_tensornew_tsrr r r__call__s z_WrappedModel.__call__Nrfrgrhrr|r r r rr\ r\c@rr)r]cCrsr{rtrur r rrrvz$_WrappedAutoregressiveModel.__init__cKsLtj|j|j|jd}||}|jr|d|j}|j|||fi|Srwrx)r~rx0ryrrzr{r r rr|s z$_WrappedAutoregressiveModel.__call__Nr}r r r rr]r~r]cCsRt|j|jd|}t|jt|kr$|d}t|jt|ks||S)a Extract values from a 1-D numpy array for a batch of indices. :param arr: the 1-D numpy array. :param timesteps: a tensor of indices into the array to extract. :param broadcast_shape: a larger shape of K dimensions with the batch dimension equal to the length of timesteps. :return: a tensor of shape [batch_size, 1, ...] where the shape has K dims. r).N)r from_numpyrrrrEr.expand)arr timestepsbroadcast_shaperr r rrs   r)r-)"rienumrLnumpyr&rrr"TTS.tts.layers.tortoise.dpm_solverrrrk_diffusion.samplingrrr ImportErrorSAMPLERSr!r+r>rFrYrREnumrbrmrvrrJrqr\r]rr r r rsJ      24