o ¶ Ïi£˜ã@s˜ddlZddlZddlZddlmZGdd„dƒZdidddddifdd „ZGd d „d ƒZd d „Zdd„Z Gdd„dƒZ dd„Z ddd„Z ddd„Z dS)éN)Útrangec@sHeZdZ     ddd„Zdd„Zd d „Zd d „Zd d„Zdd„ZdS)ÚNoiseScheduleVPÚdiscreteNçš™™™™™¹?ç4@cCsF|dvr td |¡ƒ‚||_|dkrS|dur$dt d|¡jdd}n |dus*J‚dt |¡}t|ƒ|_d |_t  d d |jd¡dd…  d ¡|_ |  d ¡|_ dSd |_||_ ||_d |_d|_t |jd |jtj¡dd |jtj|j|_t t |jd |jtjd¡¡|_||_|dkržd|_dSd |_dS)aHCreate a wrapper class for the forward SDE (VP type). *** Update: We support discrete-time diffusion models by implementing a picewise linear interpolation for log_alpha_t. We recommend to use schedule='discrete' for the discrete-time diffusion models, especially for high-resolution images. *** The forward SDE ensures that the condition distribution q_{t|0}(x_t | x_0) = N ( alpha_t * x_0, sigma_t^2 * I ). We further define lambda_t = log(alpha_t) - log(sigma_t), which is the half-logSNR (described in the DPM-Solver paper). Therefore, we implement the functions for computing alpha_t, sigma_t and lambda_t. For t in [0, T], we have: log_alpha_t = self.marginal_log_mean_coeff(t) sigma_t = self.marginal_std(t) lambda_t = self.marginal_lambda(t) Moreover, as lambda(t) is an invertible function, we also support its inverse function: t = self.inverse_lambda(lambda_t) =============================================================== We support both discrete-time DPMs (trained on n = 0, 1, ..., N-1) and continuous-time DPMs (trained on t in [t_0, T]). 1. For discrete-time DPMs: For discrete-time DPMs trained on n = 0, 1, ..., N-1, we convert the discrete steps to continuous time steps by: t_i = (i + 1) / N e.g. for N = 1000, we have t_0 = 1e-3 and T = t_{N-1} = 1. We solve the corresponding diffusion ODE from time T = 1 to time t_0 = 1e-3. Args: betas: A `torch.Tensor`. The beta array for the discrete-time DPM. (See the original DDPM paper for details) alphas_cumprod: A `torch.Tensor`. The cumprod alphas for the discrete-time DPM. (See the original DDPM paper for details) Note that we always have alphas_cumprod = cumprod(betas). Therefore, we only need to set one of `betas` and `alphas_cumprod`. **Important**: Please pay special attention for the args for `alphas_cumprod`: The `alphas_cumprod` is the \hat{alpha_n} arrays in the notations of DDPM. Specifically, DDPMs assume that q_{t_n | 0}(x_{t_n} | x_0) = N ( \sqrt{\hat{alpha_n}} * x_0, (1 - \hat{alpha_n}) * I ). Therefore, the notation \hat{alpha_n} is different from the notation alpha_t in DPM-Solver. In fact, we have alpha_{t_n} = \sqrt{\hat{alpha_n}}, and log(alpha_{t_n}) = 0.5 * log(\hat{alpha_n}). 2. For continuous-time DPMs: We support two types of VPSDEs: linear (DDPM) and cosine (improved-DDPM). The hyperparameters for the noise schedule are the default settings in DDPM and improved-DDPM: Args: beta_min: A `float` number. The smallest beta for the linear schedule. beta_max: A `float` number. The largest beta for the linear schedule. cosine_s: A `float` number. The hyperparameter in the cosine schedule. cosine_beta_max: A `float` number. The hyperparameter in the cosine schedule. T: A `float` number. The ending time of the forward process. =============================================================== Args: schedule: A `str`. The noise schedule of the forward SDE. 'discrete' for discrete-time DPMs, 'linear' or 'cosine' for continuous-time DPMs. Returns: A wrapper object of the forward SDE (VP type). =============================================================== Example: # For discrete-time DPMs, given betas (the beta array for n = 0, 1, ..., N - 1): >>> ns = NoiseScheduleVP('discrete', betas=betas) # For discrete-time DPMs, given alphas_cumprod (the \hat{alpha_n} array for n = 0, 1, ..., N - 1): >>> ns = NoiseScheduleVP('discrete', alphas_cumprod=alphas_cumprod) # For continuous-time DPMs (VPSDE), linear schedule: >>> ns = NoiseScheduleVP('linear', continuous_beta_0=0.1, continuous_beta_1=20.) )rÚlinearÚcosinezZUnsupported noise schedule {}. The schedule needs to be 'discrete' or 'linear' or 'cosine'rNçà?ér©Údimçð?g)r éÿÿÿÿiègü©ñÒMb€?g8@ç@rgO@aÃÓï?)Ú ValueErrorÚformatÚscheduleÚtorchÚlogÚcumsumÚlenÚtotal_NÚTÚlinspaceÚreshapeÚt_arrayÚlog_alpha_arrayÚbeta_0Úbeta_1Úcosine_sÚcosine_beta_maxÚmathÚatanÚpiÚ cosine_t_maxÚcosÚcosine_log_alpha_0)ÚselfrÚbetasÚalphas_cumprodÚcontinuous_beta_0Úcontinuous_beta_1Ú log_alphas©r-ú9/mnt/c/Users/fbmor/ComfyUI/comfy/extra_samplers/uni_pc.pyÚ__init__ s.X  $8(  zNoiseScheduleVP.__init__cs’ˆjdkrt| d¡ˆj |j¡ˆj |j¡ƒ d¡Sˆjdkr3d|dˆjˆjd|ˆjSˆjdkrG‡fd d „}||ƒˆj }|Sd S) zT Compute log(alpha_t) of a given continuous-time label t in [0, T]. r©rr rrgпér rcs*t t |ˆjdˆjtjd¡¡S©Nr r)rrr%rr!r#)Ús©r'r-r.ÚŠs*z9NoiseScheduleVP.marginal_log_mean_coeff..N) rÚinterpolate_fnrrÚtoÚdevicerrrr&)r'ÚtÚ log_alpha_fnÚ log_alpha_tr-r4r.Úmarginal_log_mean_coeffs , &  ýz'NoiseScheduleVP.marginal_log_mean_coeffcCót | |¡¡S)zO Compute alpha_t of a given continuous-time label t in [0, T]. ©rÚexpr<©r'r9r-r-r.Úmarginal_alphaŽszNoiseScheduleVP.marginal_alphac Cót dt d| |¡¡¡S)zO Compute sigma_t of a given continuous-time label t in [0, T]. r r©rÚsqrtr?r<r@r-r-r.Ú marginal_std”szNoiseScheduleVP.marginal_stdcCó.| |¡}dt dt d|¡¡}||S©zn Compute lambda_t = log(alpha_t) - log(sigma_t) of a given continuous-time label t in [0, T]. r r r©r<rrr?©r'r9Úlog_mean_coeffÚlog_stdr-r-r.Úmarginal_lambdašó zNoiseScheduleVP.marginal_lambdacs ˆjdkr2dˆjˆjt d|t d¡ |¡¡}ˆjd|}|t |¡ˆjˆjˆjSˆjdkrjdt t d¡ |j¡d|¡}t |  d¡t  ˆj  |j¡d g¡t  ˆj  |j¡d g¡ƒ}|  d ¡Sdt d|t d¡ |¡¡}‡fd d „}||ƒ}|S) z` Compute the continuous-time label t in [0, T] of a given half-logSNR lambda_t. rrgÀ©r r1rgà¿r0r ©rcs0t t |ˆj¡¡ddˆjtjˆjS)Nrr )rÚarccosr?r&rr!r#)r;r4r-r.r5°s0z0NoiseScheduleVP.inverse_lambda..)rrrrÚ logaddexpÚzerosr7rDr8r6rÚfliprr)r'ÚlambÚtmpÚDeltaÚ log_alphar9Út_fnr-r4r.Úinverse_lambda¢s ,  ":   zNoiseScheduleVP.inverse_lambda)rNNrr) Ú__name__Ú __module__Ú __qualname__r/r<rArErLrYr-r-r-r.r s úv  rÚnoiseÚuncondr c sj‡ fdd„‰d ‡‡‡‡ ‡ fdd„ ‰ ‡‡‡fdd„‰‡‡‡‡‡‡‡ ‡ ‡ f dd „} ˆ d vs-J‚ˆd vs3J‚| S) a!Create a wrapper function for the noise prediction model. DPM-Solver needs to solve the continuous-time diffusion ODEs. For DPMs trained on discrete-time labels, we need to firstly wrap the model function to a noise prediction model that accepts the continuous time as the input. We support four types of the diffusion model by setting `model_type`: 1. "noise": noise prediction model. (Trained by predicting noise). 2. "x_start": data prediction model. (Trained by predicting the data x_0 at time 0). 3. "v": velocity prediction model. (Trained by predicting the velocity). The "v" prediction is derivation detailed in Appendix D of [1], and is used in Imagen-Video [2]. [1] Salimans, Tim, and Jonathan Ho. "Progressive distillation for fast sampling of diffusion models." arXiv preprint arXiv:2202.00512 (2022). [2] Ho, Jonathan, et al. "Imagen Video: High Definition Video Generation with Diffusion Models." arXiv preprint arXiv:2210.02303 (2022). 4. "score": marginal score function. (Trained by denoising score matching). Note that the score function and the noise prediction model follows a simple relationship: ``` noise(x_t, t) = -sigma_t * score(x_t, t) ``` We support three types of guided sampling by DPMs by setting `guidance_type`: 1. "uncond": unconditional sampling by DPMs. The input `model` has the following format: `` model(x, t_input, **model_kwargs) -> noise | x_start | v | score `` 2. "classifier": classifier guidance sampling [3] by DPMs and another classifier. The input `model` has the following format: `` model(x, t_input, **model_kwargs) -> noise | x_start | v | score `` The input `classifier_fn` has the following format: `` classifier_fn(x, t_input, cond, **classifier_kwargs) -> logits(x, t_input, cond) `` [3] P. Dhariwal and A. Q. Nichol, "Diffusion models beat GANs on image synthesis," in Advances in Neural Information Processing Systems, vol. 34, 2021, pp. 8780-8794. 3. "classifier-free": classifier-free guidance sampling by conditional DPMs. The input `model` has the following format: `` model(x, t_input, cond, **model_kwargs) -> noise | x_start | v | score `` And if cond == `unconditional_condition`, the model output is the unconditional DPM output. [4] Ho, Jonathan, and Tim Salimans. "Classifier-free diffusion guidance." arXiv preprint arXiv:2207.12598 (2022). The `t_input` is the time label of the model, which may be discrete-time labels (i.e. 0 to 999) or continuous-time labels (i.e. epsilon to T). We wrap the model function to accept only `x` and `t_continuous` as inputs, and outputs the predicted noise: `` def model_fn(x, t_continuous) -> noise: t_input = get_model_input_time(t_continuous) return noise_pred(model, x, t_input, **model_kwargs) `` where `t_continuous` is the continuous time labels (i.e. epsilon to T). And we use `model_fn` for DPM-Solver. =============================================================== Args: model: A diffusion model with the corresponding format described above. noise_schedule: A noise schedule object, such as NoiseScheduleVP. model_type: A `str`. The parameterization type of the diffusion model. "noise" or "x_start" or "v" or "score". model_kwargs: A `dict`. A dict for the other inputs of the model function. guidance_type: A `str`. The type of the guidance for sampling. "uncond" or "classifier" or "classifier-free". condition: A pytorch tensor. The condition for the guided sampling. Only used for "classifier" or "classifier-free" guidance type. unconditional_condition: A pytorch tensor. The condition for the unconditional sampling. Only used for "classifier-free" guidance type. guidance_scale: A `float`. The scale for the guided sampling. classifier_fn: A classifier function. Only used for the classifier guidance. classifier_kwargs: A `dict`. A dict for the other inputs of the classifier function. Returns: A noise prediction model that accepts the noised data and the continuous time as the inputs. cs ˆjdkr|dˆjdS|S)a Convert the continuous-time `t_continuous` (in [epsilon, T]) to the model input time. For discrete-time DPMs, we convert `t_continuous` in [1 / N, 1] to `t_input` in [0, 1000 * (N - 1) / N]. For continuous-time DPMs, we just use `t_continuous`. rr g@@)rr)Ú t_continuous)Únoise_scheduler-r.Úget_model_input_times z+model_wrapper..get_model_input_timeNcsü| d¡jddkr| |jd¡}ˆ|ƒ}ˆ||fiˆ¤Ž}ˆdkr%|SˆdkrFˆ |¡ˆ |¡}}| ¡}|t||ƒ|t||ƒSˆdkrgˆ |¡ˆ |¡}}| ¡}t||ƒ|t||ƒ|Sˆdkr|ˆ |¡}| ¡}t||ƒ |SdS)NrOrr r]Úx_startÚvÚscore)rÚshapeÚexpandrArEr Ú expand_dims)Úxr_ÚcondÚt_inputÚoutputÚalpha_tÚsigma_tÚdims)raÚmodelÚ model_kwargsÚ model_typer`r-r.Ú noise_pred_fn%s& ýz$model_wrapper..noise_pred_fncsdt ¡$| ¡ d¡}ˆ||ˆfiˆ¤Ž}tj | ¡|¡dWdƒS1s+wYdS)z] Compute the gradient of the classifier, i.e. nabla_{x} log p_t(cond | x_t). TrN)rÚ enable_gradÚdetachÚrequires_grad_ÚautogradÚgradÚsum)rhrjÚx_inÚlog_prob)Ú classifier_fnÚclassifier_kwargsÚ conditionr-r.Ú cond_grad_fn9s $ýz#model_wrapper..cond_grad_fnc s | d¡jddkr| |jd¡}ˆdkrˆ||ƒSˆdkrFˆdus%J‚ˆ|ƒ}ˆ||ƒ}ˆ |¡}ˆ||ƒ}|ˆt|| ¡d|Sˆdkr„ˆd ksRˆdurYˆ||ˆd St |gd ¡}t |gd ¡}t ˆˆg¡}ˆ|||d  d ¡\} }| ˆ|| SdS) zS The noise predicition model function that is used for DPM-Solver. rOrr r^Ú classifierN©rnúclassifier-freer )rir1) rrerfrErgr rÚcatÚchunk) rhr_rjÚ cond_gradrmr]ryÚt_inÚc_inÚ noise_uncond) r{r~r}raÚguidance_scaleÚ guidance_typerrr`Úunconditional_conditionr-r.Úmodel_fnBs(     øzmodel_wrapper..model_fn)r]rbrc)r^rr©Nr-) ror`rqrpr‰r}rŠrˆr{r|r‹r-) r{r|r~r}rarˆr‰rorprqrrr`rŠr.Ú model_wrapperµs e   rc@s„eZdZ    d$dd„Zd%dd „Zd d „Zd d „Zdd„Zdd„Zdd„Z dd„Z dd„Z d&dd„Z d'dd„Z   d(d"d#„ZdS))ÚUniPCTFr Úbh1cCs(||_||_||_||_||_||_dS)zZConstruct a UniPC. We support both data_prediction and noise_prediction. N)ror`ÚvariantÚ predict_x0Ú thresholdingÚmax_val)r'r‹r`r‘r’r“rr-r-r.r/as   zUniPC.__init__NcCsr| ¡}|j}tjt |¡ |jddf¡|dd}tt ||j t  |¡  |j ¡¡|ƒ}t  || |¡|}|S)z2 The dynamic thresholding method. rrr r )r Údynamic_thresholding_ratiorÚquantileÚabsrrergÚmaximumÚthresholding_max_valÚ ones_liker7r8Úclamp)r'Úx0r9rnÚpr3r-r-r.Údynamic_thresholding_fnus &&zUniPC.dynamic_thresholding_fncCó | ||¡S)z4 Return the noise prediction model. ©ro©r'rhr9r-r-r.Únoise_prediction_fn€ó zUniPC.noise_prediction_fnc Cs¸| ||¡}| ¡}|j |¡|j |¡}}|t||ƒ|t||ƒ}|jrZd}tjt  |¡  |j ddf¡|dd} tt  | |j t | ¡ | j¡¡|ƒ} t || | ¡| }|S)zG Return the data prediction model (with thresholding). g×£p= ×ï?rrr r )r¡r r`rArErgr’rr•r–rrer—r“r™r7r8rš) r'rhr9r]rnrlrmr›rœr3r-r-r.Údata_prediction_fn†s &&zUniPC.data_prediction_fncCs|jr | ||¡S| ||¡S)z_ Convert the model to the noise prediction model or the data prediction model. )r‘r£r¡r r-r-r.r‹•s  zUniPC.model_fnc CsØ|dkr6|j t |¡ |¡¡}|j t |¡ |¡¡}t | ¡ ¡| ¡ ¡|d¡ |¡}|j |¡S|dkrFt |||d¡ |¡S|dkred} t |d| |d| |d¡  | ¡ |¡} | St d  |¡ƒ‚)z:Compute the intermediate time steps for sampling. ÚlogSNRr Ú time_uniformÚtime_quadraticr1r zSUnsupported skip_type {}, need to be 'logSNR' or 'time_uniform' or 'time_quadratic') r`rLrÚtensorr7rÚcpuÚitemrYÚpowrr) r'Ú skip_typeÚt_TÚt_0ÚNr8Úlambda_TÚlambda_0Ú logSNR_stepsÚt_orderr9r-r-r.Úget_time_stepsžs( .zUniPC.get_time_stepsc Cs4|dkr8|dd}|ddkrdg|dddg}nQ|ddkr-dg|ddg}n@dg|ddg}n5|dkr]|ddkrL|d}dg|}n!|dd}dg|ddg}n|dkri|}dg|}ntdƒ‚|dkr~| |||||¡} | |fS| |||||¡t t dg|¡d¡ |¡} | |fS)zW Get the order of each step for sampling by the singlestep DPM-Solver. ér rr1z"'order' must be '1' or '2' or '3'.r¤)rr³rrr§r7) r'ÚstepsÚorderr«r¬r­r8ÚKÚordersÚtimesteps_outerr-r-r.Ú.get_orders_and_timesteps_for_singlestep_solver¯s,       0ÿz4UniPC.get_orders_and_timesteps_for_singlestep_solvercCrž)z‡ Denoise at the final step, which is equivalent to solve the ODE from lambda_s to infty by first-order discretization. )r£)r'rhr3r-r-r.Údenoise_to_zero_fnÎr¢zUniPC.denoise_to_zero_fncKsdt|jƒdkr | d¡}d|jvr|j|||||fi|¤ŽS|jdks%J‚|j|||||fi|¤ŽS)NrrÚbhÚ vary_coeff)rreÚviewrÚmultistep_uni_pc_bh_updateÚmultistep_uni_pc_vary_update)r'rhÚmodel_prev_listÚ t_prev_listr9r¶Úkwargsr-r-r.Úmultistep_uni_pc_updateÔs   zUniPC.multistep_uni_pc_updatec* Cst d|›d¡|j}|t|ƒksJ‚|d}| |¡} | |¡} |d} | |¡| |¡} } | |¡}t |¡}| | }g}g}t d|ƒD])}||d }||d }| |¡}|| |}|  |¡|  || |¡qH|  d¡tj ||j d}t|ƒ}g}t  |¡}t d|dƒD]}|  |¡|||d}q‘tj|dd}t|ƒdkrÅtj|dd}tj |dd…dd…f¡}|}|rÏtj |¡}|}|jrÕ| n|} t | ¡}!g}"d}#|!}$t d|d ƒD]}|"  |$¡|$| d|#}$|#|d9}#qéd}%|jr}| | |||!| }&|&}'t|ƒdkr7t |dƒD]}|'||"|dt d |||¡}'q |ry| |'|¡}%|%| }(|&}'d}t |dƒD]}|'||"|dt d |||dd…¡}'qN|'||"||(||d}'|'|%fS| |¡| |¡})}t ||)¡|| |!| }&|&}'t|ƒdkr½t |dƒD]}|'| |"|dt d |||¡}'q¦|rÿ| |'|¡}%|%| }(|&}'d}t |dƒD]}|'| |"|dt d |||dd…¡}'qÔ|'| |"||(||d}'|'|%fS) Nz-using unified predictor-corrector with order z (solver type: vary coeff)rr r ©r8r rr1z bkchw,k->bchw)ÚloggingÚinfor`rrLrEr<rr?ÚrangeÚappendr§r8r™ÚstackÚlinalgÚinvr‘Úexpm1Úeinsumr‹)*r'rhrÁrÂr9r¶Ú use_correctorÚnsÚt_prev_0Ú lambda_prev_0Úlambda_tÚ model_prev_0Ú sigma_prev_0rmr;rlÚhÚrksÚD1sÚiÚt_prev_iÚ model_prev_iÚ lambda_prev_iÚrkr·ÚCÚcolÚkÚC_inv_pÚA_pÚC_invÚA_cÚhhÚh_phi_1Úh_phi_ksÚ factorial_kÚh_phi_kÚmodel_tÚx_t_Úx_tÚD1_tÚlog_alpha_prev_0r-r-r.rÀÝs¤                ÿÿ* 2 ì ÿÿ* 2 z"UniPC.multistep_uni_pc_vary_updatec*CsH|j}|t|ƒks J‚| ¡} |d} | | ¡} | |¡} |d} | | ¡| |¡}}| | ¡| |¡}}t |¡}| | }g}g}td|ƒD]+}||d }||d }| |¡}|| |d}|  |¡|  || |¡qI|  d¡tj ||j d}g}g}|j rŽ|d n|d}t  |¡}||d}d} |jdkr§|}!n|jdkr²t  |¡}!ntƒ‚td|dƒD]$}|  t ||d¡¡|  || |!¡| |d9} ||d| }q¼t |¡}tj ||j d}t|ƒdko÷|du}"t|ƒdkr.tj|dd}|dur-|d krtj d g|j d}#ntj |dd…dd…f|dd…¡}#nd}|rI|dkrBtj d g|j d}$ntj ||¡}$d}%|j r½t||| ƒ|t||| ƒ| }&|durƒ|"rvtj||#dgdgfd }'nd}'|&t||!| ƒ|'}|r¹| ||¡}%|dur¢tj||$dd…dgdgfd }(nd}(|%| })|&t||!| ƒ|(|$d|)}||%fStt ||¡| ƒ|t||| ƒ| }&|durï|"rât d |#|¡}'nd}'|&t||!| ƒ|'}|r | ||¡}%|dur t d |$dd…|¡}(nd}(|%| })|&t||!| ƒ|(|$d|)}||%fS) Nrr rr rÅrÚbh2r r1r r€z k,bkchw->bchw)r`rr rLrEr<rr?rÈrÉr§r8r‘rÍrÚNotImplementedErrorrªrÊrËÚsolvergÚ tensordotr‹rÎ)*r'rhrÁrÂr9r¶rìrÏrÐrnrÑrÒrÓrÔrÕrmrîr;rlrÖr×rØrÙrÚrÛrÜrÝÚRÚbråræréÚ factorial_iÚB_hÚ use_predictorÚrhos_pÚrhos_crêrëÚpred_resÚcorr_resrír-r-r.r¿Cs²               &€ ÿÿ   ""îÿÿ   "z UniPC.multistep_uni_pc_bh_updater´r¥Ú singlestepÚ dpm_solverçÞqŠŽäò?çš™™™™™©?c Csêt|ƒd}|dkrò||ksJ‚|jdd|ksJ‚t||dD]Î}|dkr<|d |jd¡}| ||¡g}|g}n¥||krn|}|| |jd¡}|j|||||dd\}}|durc| ||¡}| |¡| |¡nsd}||dkrxd}t||d|ƒD]_}|| |jd¡}|r™t||d|ƒ}n|}||kr¢d}nd}|j||||||d\}}t|dƒD]}||d||<||d||<q·||d<||krà|durÜ| ||¡}||d<q|durï||||dd œƒq!|St ƒ‚) Nr Ú multistepr)ÚdisableT)rÏFr)rhrÙÚdenoised) rrerrfr‹rÄrÉrÈÚminrð)r'rhÚ timestepsÚt_startÚt_endr¶r«ÚmethodÚlower_order_finalÚdenoise_to_zeroÚ solver_typeÚatolÚrtolÚ correctorÚcallbackÚ disable_pbarrµÚ step_indexÚvec_trÁrÂÚ init_orderÚmodel_xÚextra_final_stepÚstepÚ step_orderrÏrÙr-r-r.Úsample¼sV       €€ýz UniPC.sample)TFr rrŒ)T)NT) NNr´r¥rüTFrýrþrÿFNF)rZr[r\r/rr¡r£r‹r³rºr»rÄrÀr¿rr-r-r-r.rŽ`s( ù    fyþrŽc Cs¶|jd|jd}}tj| d¡| d¡ |ddf¡gdd}tj|dd\}}tj|dd}|d} t t |d¡tj d|j dt t ||¡tj |d|j d| ¡¡} t t | | ¡| d| d¡} tj |d|  d¡d  d¡} tj |d|  d¡d  d¡} t t |d¡tj d|j dt t ||¡tj |d|j d| ¡¡}| d¡  |dd¡}tj |d| d¡d  d¡}tj |d|d d¡d  d¡}||| ||| | }|S)a A piecewise linear function y = f(x), using xp and yp as keypoints. We implement f(x) in a differentiable way (i.e. applicable for autograd). The function f(x) is well-defined for all x-axis. (For x beyond the bounds of xp, we use the outmost points of xp to define the linear function.) Args: x: PyTorch tensor with shape [N, C], where N is the batch size, C is the number of channels (we use C = 1 for DPM-Solver). xp: PyTorch tensor with shape [C, K], where K is the number of keypoints. yp: PyTorch tensor with shape [C, K]. Returns: The function values f(x), with shape [N, C]. rr r1r rÅ)r Úindexr)rerr‚Ú unsqueezeÚrepeatÚsortÚargminÚwhereÚeqr§r8ÚgatherÚsqueezerf)rhÚxpÚypr®r·Úall_xÚ sorted_all_xÚ x_indicesÚx_idxÚcand_start_idxÚ start_idxÚend_idxÚstart_xÚend_xÚ start_idx2Úy_positions_expandedÚstart_yÚend_yÚcandr-r-r.r6þs6 * ÿý ÿý r6cCs|dd|dS)zé Expand the tensor `v` to the dim `dims`. Args: `v`: a PyTorch tensor with shape [N]. `dim`: a `int`. Returns: a PyTorch tensor with shape [N, 1, 1, ..., 1] and the total dimension is `dims`. ).rŒr r-)rcrnr-r-r.rg(s rgc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S) Ú SigmaConvertÚcCsdt d||d¡S)Nr r )rr)r'Úsigmar-r-r.r<7sz$SigmaConvert.marginal_log_mean_coeffcCr=rŒr>r@r-r-r.rA:szSigmaConvert.marginal_alphac CrBr2rCr@r-r-r.rE=szSigmaConvert.marginal_stdcCrFrGrHrIr-r-r.rL@rMzSigmaConvert.marginal_lambdaN)rZr[r\rr<rArErLr-r-r-r.r15s  r1cKsP| |jdd…d|jd¡}||ddd}||||fi|¤Ž|S)Nr rNr1r r )r¾reÚndim)roÚinputÚsigma_inrÃr3r-r-r.Úpredict_eps_sigmaHs"r7Frc sÄ| ¡}|ddkr|dd…}d|d<n| ¡}tƒ}|t d|dd¡}d} t‡fdd„|| d |d } td t|ƒd ƒ} t| |d d|d} | j||dd| d ||d} | |  |d¡} | S)Nrrgü©ñÒMbP?r rr]cstˆ||fi|¤ŽSrŒ)r7)r5r3rÃrŸr-r.r5[szsample_unipc..r^)rqr‰rpr´r1TF)r‘r’rr¥r)rr«rr¶rrr) Úcloner1rrDrrrrŽrrA)ror]ÚsigmasÚ extra_argsrrrrrÐrqr‹r¶Úuni_pcrhr-rŸr.Ú sample_unipcNs(    ûr<c Cst||||||ddS)Nrï)r)r<)ror]r9r:rrr-r-r.Úsample_unipc_bh2hsr=)NNFr)NNF)rr!rÆÚ tqdm.autorrrrŽr6rgr1r7r<r=r-r-r-r.Ús4 / ö,!*