3j)fSSKJr SSKJr SSKJr SSKrSSKrSSK J r SSK J r SSK JrJr SS KJr SS KJrJr SS KJrJr SS KJrJrJrJr SS KJr SSKJ r SSK!J"r" SSK#J$r$ \"5(a SSK%J&s J'r( Sr)OSr)\RT"\+5r,Sr-\"SS\55r."SS\"5r/g)) dataclass)partial)AnyN)Image)tqdm) CLIPTextModel CLIPTokenizer)PipelineImageInput) AutoencoderKLUNet2DConditionModel) DDIMScheduler LCMScheduler) BaseOutputis_torch_xla_availableloggingreplace_example_docstring)is_scipy_available) randn_tensor)DiffusionPipeline)MarigoldImageProcessorTFaE Examples: ```py >>> import diffusers >>> import torch >>> pipe = diffusers.MarigoldDepthPipeline.from_pretrained( ... "prs-eth/marigold-depth-v1-1", variant="fp16", torch_dtype=torch.float16 ... ).to("cuda") >>> image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg") >>> depth = pipe(image) >>> vis = pipe.image_processor.visualize_depth(depth.prediction) >>> vis[0].save("einstein_depth.png") >>> depth_16bit = pipe.image_processor.export_depth_to_16bit_png(depth.prediction) >>> depth_16bit[0].save("einstein_depth_16bit.png") ``` c\rSrSr%Sr\R \R-\ S'S\R -\R-\ S'S\R-\ S'Sr g)MarigoldDepthOutputRu7 Output class for Marigold monocular depth prediction pipeline. Args: prediction (`np.ndarray`, `torch.Tensor`): Predicted depth maps with values in the range [0, 1]. The shape is `numimages × 1 × height × width` for `torch.Tensor` or `numimages × height × width × 1` for `np.ndarray`. uncertainty (`None`, `np.ndarray`, `torch.Tensor`): Uncertainty maps computed from the ensemble, with values in the range [0, 1]. The shape is `numimages × 1 × height × width` for `torch.Tensor` or `numimages × height × width × 1` for `np.ndarray`. latent (`None`, `torch.Tensor`): Latent features corresponding to the predictions, compatible with the `latents` argument of the pipeline. The shape is `numimages * numensemble × 4 × latentheight × latentwidth`. predictionN uncertaintylatent) __name__ __module__ __qualname____firstlineno____doc__npndarraytorchTensor__annotations____static_attributes__r n/home/wildlama/miniconda3/lib/python3.13/site-packages/diffusers/pipelines/marigold/pipeline_marigold_depth.pyrrRsC  U\\)) "U\\11 5<< r,rc!^\rSrSrSrSrSrS/S\S\S\ \ -S \ S \ S \ S-S \S-S \S-S\S-S\S-4U4SjjjrS\S\S\S\S\ S\ S\S\\ \4S-S\R*S-S\R,\\R,-S-S\ S\S\4Sjr\R2R4S0Sj5r\R8"5\"\5S1S\S\S-S\S\S-S \S\ S\ S\S\\ \4S-S\R*\\R*-S-S\R,\\R,-S-S\ S\S!\S"\4S#jj55rS\R*S\R*S-S\R,S-S\S\S\ \R*\R*44 S$jr!S%\R*S\R*4S&jr"\#S2S'\R*S \S \S\S(\ S)\$S*\S+\$S,\S\ \R*\R*S-44S-jj5r%S.r&U=r'$)3MarigoldDepthPipelineha Pipeline for monocular depth estimation using the Marigold method: https://marigoldmonodepth.github.io. This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.) Args: unet (`UNet2DConditionModel`): Conditional U-Net to denoise the depth latent, conditioned on image latent. vae (`AutoencoderKL`): Variational Auto-Encoder (VAE) Model to encode and decode images and predictions to and from latent representations. scheduler (`DDIMScheduler` or `LCMScheduler`): A scheduler to be used in combination with `unet` to denoise the encoded image latents. text_encoder (`CLIPTextModel`): Text-encoder, for empty text embedding. tokenizer (`CLIPTokenizer`): CLIP tokenizer. prediction_type (`str`, *optional*): Type of predictions made by the model. scale_invariant (`bool`, *optional*): A model property specifying whether the predicted depth maps are scale-invariant. This value must be set in the model config. When used together with the `shift_invariant=True` flag, the model is also called "affine-invariant". NB: overriding this value is not supported. shift_invariant (`bool`, *optional*): A model property specifying whether the predicted depth maps are shift-invariant. This value must be set in the model config. When used together with the `scale_invariant=True` flag, the model is also called "affine-invariant". NB: overriding this value is not supported. default_denoising_steps (`int`, *optional*): The minimum number of denoising diffusion steps that are required to produce a prediction of reasonable quality with the given model. This value must be set in the model config. When the pipeline is called without explicitly setting `num_inference_steps`, the default value is used. This is required to ensure reasonable results with various model flavors compatible with the pipeline, such as those relying on very short denoising schedules (`LCMScheduler`) and those with full diffusion schedules (`DDIMScheduler`). default_processing_resolution (`int`, *optional*): The recommended value of the `processing_resolution` parameter of the pipeline. This value must be set in the model config. When the pipeline is called without explicitly setting `processing_resolution`, the default value is used. This is required to ensure reasonable results with various model flavors trained with varying optimal processing resolution values. ztext_encoder->unet->vae)depth disparityNunetvae scheduler text_encoder tokenizerprediction_typescale_invariantshift_invariantdefault_denoising_stepsdefault_processing_resolutionc >[T U]5 X`R;a&[R SUSURS35 UR UUUUUS9 UR UUUU U S9 [USS5(a/S[URRR5S- -OS Ul Xpl XlXlXlSUl[%URS 9Ulg) Nz*Potentially unsupported `prediction_type='z&'`; values supported by the pipeline: .)r3r4r5r6r7)r8r9r:r;r<r4rr)vae_scale_factor)super__init__supported_prediction_typesloggerwarningregister_modulesregister_to_configgetattrlenr4configblock_out_channelsr@r9r:r;r<empty_text_embeddingrimage_processor) selfr3r4r5r6r7r8r9r:r;r< __class__s r-rBMarigoldDepthPipeline.__init__s  "A"A A NN<_$-J*$(!5tG\G\]r,imagenum_inference_steps ensemble_sizeprocessing_resolutionresample_method_inputresample_method_output batch_sizeensembling_kwargslatents generator output_typeoutput_uncertaintyreturnc  ^ S[URRR5S- -n XR:wa[ SURSU S35eUc [ S5eUS:a [ S5eUS:a [ S5eUS:Xa[ RS 5 US:a<UR(dUR(a[5(d [S 5eUS:XaU (a [ S 5eUc [ S 5eUS :a [ S5eX@R-S :wa[ SURS35eUS;a [ S5eUS;a [ S5eUS:a [ S5eU S;a [ S5eU bT b [ S5eUb:[U[5(d [ S5eSU;aUSS;a [ S5eS nSunn[U[5(dU/n[U5GHunn[U[ R"5(d[$R&"U5(a`UR(S;a[ SUSUR*S35eUR*S SunnSnUR(S!:XaUR*S nOL[U[,R,5(aUR.unnSnO[ S"US#[1U5S35eUcUUnnO"UU4UU4:wa[ S$US%UU4S&UU435eUU- nGM U Gb%[$R&"U 5(d [ S'5eU R35S!:wa[ S(U R*S35eUS :a=[5UU5nUU-U-nX-U-nUS :XdUS :Xa[ S)US*US+35eUUnnXR-S- UR-nUUR-S- UR-nX-URRR6UU4nU R*U:wa[ S,U R*S-US35eT b[T [5(aD[T 5X-:wa [ S.5e[9U 4S/jT 55(d [ S05eU$[T [$R:5(d[ S1[1T 5S35eU$)2Nrrz/`vae_scale_factor` computed at initialization (z) differs from the actual one (z).zW`num_inference_steps` is not specified and could not be resolved from the model config.z'`num_inference_steps` must be positive.z!`ensemble_size` must be positive.zk`ensemble_size` == 2 results are similar to no ensembling (1); consider increasing the value to at least 3.z9Make sure to install scipy if you want to use ensembling.zpComputing uncertainty by setting `output_uncertainty=True` also requires setting `ensemble_size` greater than 1.zY`processing_resolution` is not specified and could not be resolved from the model config.rzx`processing_resolution` must be non-negative: 0 for native resolution, or any positive value for downsampled processing.z.`processing_resolution` must be a multiple of r>)nearest nearest-exactbilinearbicubicareazy`resample_method_input` takes string values compatible with PIL library: nearest, nearest-exact, bilinear, bicubic, area.zz`resample_method_output` takes string values compatible with PIL library: nearest, nearest-exact, bilinear, bicubic, area.z`batch_size` must be positive.)ptr&z*`output_type` must be one of `pt` or `np`.z2`latents` and `generator` cannot be used together.z)`ensembling_kwargs` must be a dictionary. reductionmeanmedianzF`ensembling_kwargs['reduction']` can be either `'mean'` or `'median'`.)NN)rr z`image[z(]` has unsupported dimensions or shape: rizUnsupported `image[z ]` type: z Input `image[z]` has incompatible dimensions z with the previous images z!`latents` must be a torch.Tensor.z/`latents` has unsupported dimensions or shape: z*Extreme aspect ratio of the input image: [z x ]z`latents` has unexpected shape=z expected=z^The number of generators must match the total number of ensemble members for all input images.c3># UH4oRRTSRR:Hv M6 g7f)rN)devicetype).0grZs r- 5MarigoldDepthPipeline.check_inputs..As,Xi88==IaL,?,?,D,DDis=> > l *IJ J  9#8QR R  (/66 !LMM//4Ek4RZl4l !ijj 1%&&GE&FAs#rzz**eooc.B.B889,$wqc1YZ]ZcZcYdde%fgg99RS>S88q=))A,CC--88S #6qc49+Q!OPPyC11QC:% #A3&EsCj\Qkmnpqlrkst # J'',  ??7++ !DEE{{}! #RSZS`S`Raab!cdd$q(q!911X=1X=A:!$'QRSQTTWXYWZZ[%\]]e1***Q.43H3HHAT***Q.43H3HHA(8$((//:Y:Y[\^_`N}}. #B7==/Q[\j[kkl!mnn  )T**y>Z%??$xXiXXX$%bccY  5??;; #?Y?PPQ!RSSr,c[US5(d0UlOA[UR[5(d"[ S[ UR5S35e[S0URD6nUR SU5US'UR SU5US'Ub [U40UD6$Ub [SSU0UD6$[ S5e) N_progress_bar_configz=`self._progress_bar_config` should be of type `dict`, but is r>descleavetotalz/Either `total` or `iterable` has to be defined.r )hasattrrrurvrsrngetr)rNiterablerrrprogress_bar_configs r- progress_bar"MarigoldDepthPipeline.progress_barHst344(*D %D55t<<OPTUYUnUnPoOppqr #?T%>%>?&9&=&=fd&KF#':'>'>w'NG$  8$78 8  ;e;':; ;NO Or,match_input_resolution output_latent return_dictcURnURnUc URnUc URnUR UUUUUUUU U U U U 5 nUR c]SnUR USUR RSSS9nURRU5nURU5SUlURRXUUU5unnnURXXU5unnAUR RUUS9RUS S 5n/nUR[!SUU-U5SS S 9HnUUUU-nUUUU-nUR"SnUSUn UR$R'UUS 9 URUR$R(S SS 9Hwn![*R,"UU/S S9n"UR/U"U!U S S9Sn#UR$R1U#U!UU S9R2n[4(dMb[6R8"5 My UR;U5 M [*R,"USS9nAAAAAA A"A#[*R,"[!SUR"SU5Vs/sHnUR=UUUU-5PM snSS9n$U(dSnURR?U$U5n$Sn%US :aU$R@"UU/U$R"S SQ76n$[!U5Vs/sH9nURB"U$UURDURFU 40U =(d 0D6PM; n$n[IU$6un$n%[*R,"U$SS9n$U (a[*R,"U%SS9n%OSn%U(aBURRKU$UUS S9n$U%b#U (aURRKU%UUS S9n%U S:Xa@URRMU$5n$U%b"U (aURRMU%5n%URO5 U(dU$U%U4$[QU$U%US9$s snfs snf)aA Function invoked when calling the pipeline. Args: image (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor`, `list[PIL.Image.Image]`, `list[np.ndarray]`), `list[torch.Tensor]`: An input image or images used as an input for the depth estimation task. For arrays and tensors, the expected value range is between `[0, 1]`. Passing a batch of images is possible by providing a four-dimensional array or a tensor. Additionally, a list of images of two- or three-dimensional arrays or tensors can be passed. In the latter case, all list elements must have the same width and height. num_inference_steps (`int`, *optional*, defaults to `None`): Number of denoising diffusion steps during inference. The default value `None` results in automatic selection. ensemble_size (`int`, defaults to `1`): Number of ensemble predictions. Higher values result in measurable improvements and visual degradation. processing_resolution (`int`, *optional*, defaults to `None`): Effective processing resolution. When set to `0`, matches the larger input image dimension. This produces crisper predictions, but may also lead to the overall loss of global context. The default value `None` resolves to the optimal value from the model config. match_input_resolution (`bool`, *optional*, defaults to `True`): When enabled, the output prediction is resized to match the input dimensions. When disabled, the longer side of the output will equal to `processing_resolution`. resample_method_input (`str`, *optional*, defaults to `"bilinear"`): Resampling method used to resize input images to `processing_resolution`. The accepted values are: `"nearest"`, `"nearest-exact"`, `"bilinear"`, `"bicubic"`, or `"area"`. resample_method_output (`str`, *optional*, defaults to `"bilinear"`): Resampling method used to resize output predictions to match the input resolution. The accepted values are `"nearest"`, `"nearest-exact"`, `"bilinear"`, `"bicubic"`, or `"area"`. batch_size (`int`, *optional*, defaults to `1`): Batch size; only matters when setting `ensemble_size` or passing a tensor of images. ensembling_kwargs (`dict`, *optional*, defaults to `None`) Extra dictionary with arguments for precise ensembling control. The following options are available: - reduction (`str`, *optional*, defaults to `"median"`): Defines the ensembling function applied in every pixel location, can be either `"median"` or `"mean"`. - regularizer_strength (`float`, *optional*, defaults to `0.02`): Strength of the regularizer that pulls the aligned predictions to the unit range from 0 to 1. - max_iter (`int`, *optional*, defaults to `2`): Maximum number of the alignment solver steps. Refer to `scipy.optimize.minimize` function, `options` argument. - tol (`float`, *optional*, defaults to `1e-3`): Alignment solver tolerance. The solver stops when the tolerance is reached. - max_res (`int`, *optional*, defaults to `None`): Resolution at which the alignment is performed; `None` matches the `processing_resolution`. latents (`torch.Tensor`, or `list[torch.Tensor]`, *optional*, defaults to `None`): Latent noise tensors to replace the random initialization. These can be taken from the previous function call's output. generator (`torch.Generator`, or `list[torch.Generator]`, *optional*, defaults to `None`): Random number generator object to ensure reproducibility. output_type (`str`, *optional*, defaults to `"np"`): Preferred format of the output's `prediction` and the optional `uncertainty` fields. The accepted values are: `"np"` (numpy array) or `"pt"` (torch tensor). output_uncertainty (`bool`, *optional*, defaults to `False`): When enabled, the output's `uncertainty` field contains the predictive uncertainty map, provided that the `ensemble_size` argument is set to a value above 2. output_latent (`bool`, *optional*, defaults to `False`): When enabled, the output's `latent` field contains the latent codes corresponding to the predictions within the ensemble. These codes can be saved, modified, and used for subsequent calls with the `latents` argument. return_dict (`bool`, *optional*, defaults to `True`): Whether or not to return a [`~pipelines.marigold.MarigoldDepthOutput`] instead of a plain tuple. Examples: Returns: [`~pipelines.marigold.MarigoldDepthOutput`] or `tuple`: If `return_dict` is `True`, [`~pipelines.marigold.MarigoldDepthOutput`] is returned, otherwise a `tuple` is returned where the first element is the prediction, the second element is the uncertainty (or `None`), and the third is the latent (or `None`). N do_not_padTrd)padding max_length truncationreturn_tensorsr)rmdtyperzMarigold predictions...)rr)rmFzDiffusion steps...r})encoder_hidden_statesr)rZ)is_aar&)rrr))_execution_devicerr;r<rrLr7model_max_length input_idstor6rM preprocessprepare_latentsrepeatrranger{r5 set_timesteps timestepsr(catr3step prev_sample XLA_AVAILABLExm mark_stepappenddecode_prediction unpad_imagereshapeensemble_depthr9r:zipresize_antialias pt_to_numpymaybe_free_model_hooksr)&rNrQrRrSrTrrUrVrWrXrYrZr[r\rrrmrrprompt text_inputstext_input_idsroriginal_resolution image_latent pred_latentbatch_empty_text_embedding pred_latentsrbatch_image_latentbatch_pred_latenteffective_batch_sizetextt batch_latentnoiserrs& r-__call__MarigoldDepthPipeline.__call__[st''   &"&">">  ($($F$F !&&    ! ! "        "  $ $ ,F..$>>::# )K)2255f=N(,(9(9.(I!(LD %/3.B.B.M.M *?/ +w+%)$8$8 Ij% ! k %)%>%>%A%AW\%A%]%d%d 1& " "" !Z-/ -.C/CDD NN ( ()O)PVWX  ,[` abcd$(NN$7$71/9%8%+"!=LLNi    1 2' *ii !4    &      YYq+"3"3A"6 C CA&&{1q:~'FGC   K))55j'J  1 #++J ] HXHXYZY[H\]Jz* +A##qM((((&  ).B +  '*:&6 #J :15J!#ii ; " "-->>/1Gu?J&+="22CC!46LTYD $ --99*EJ&+="22>>{K  ##% [9 9"!#   * s !P:AP?c Sn[R"[SURSU5Vs/sH(nU"URR XXu-55PM* snSS9nXRR R-nURUSS9nUn U c*[URUURURS9n X4$s snf)Nc[US5(aURR5$[US5(a UR$[ S5e)N latent_distrYz3Could not access latents of provided encoder_output)rrmoderYAttributeError)encoder_outputs r-retrieve_latents?MarigoldDepthPipeline.prepare_latents..retrieve_latentsusI~}55%11668833%---$%Z[[r,rr)rZrmr) r(rrr{r4encoderJscaling_factorrepeat_interleaverrmr) rNrQrYrZrSrWrrrrs r-r%MarigoldDepthPipeline.prepare_latentsms \yyq%++a.*= =A!1>1J!KL=   $hhoo&D&DD #55m5K   &""##**"(( K((% s/C rcUR5S:wd1URSURRR:wa:[ SURRRSURS35eURR XRRR- SS9SnURSS S 9n[R"US S 5nUS -S - nU$)Nrirz Expecting 4D tensor of shape [B,z ,H,W]; got r>F)rrTr}keepdimg?g@) r}r{r4rJrrsdecoderrgr(clip)rNrrs r-r'MarigoldDepthPipeline.decode_predictions ??  ![%6%6q%9TXX__=\=\%\2488??3R3R2SS^_j_p_p^qqrs XX__[88??3Q3Q%Q_d_efgh __D_9 ZZ D#6  3&#- r,r1reregularizer_strengthmax_itertolmax_resc ^^^^^^^^^^^^UR5S:wdURSS:wa[SURS35eTS;a[STS35eT(dT(a [S5eS[R4UUU4S jjmS[RS [ R S [R4UUU4S jjmSS [RS[S [[R[RS-44U4SjjjmS [ R S[RS [4UUUU4SjjmS[R4UUUUU4Sjjn T=(d Tn URSmU (aU "U5n T"X 5nT"XS9up UR5n T(aT(aUR5nOT(aSnO [S5eX- RSS9nX- U- nU(aX-n X 4$)a Ensembles the depth maps represented by the `depth` tensor with expected shape `(B, 1, H, W)`, where B is the number of ensemble members for a given prediction of size `(H x W)`. Even though the function is designed for depth maps, it can also be used with disparity maps as long as the input tensor values are non-negative. The alignment happens when the predictions have one or more degrees of freedom, that is when they are either affine-invariant (`scale_invariant=True` and `shift_invariant=True`), or just scale-invariant (only `scale_invariant=True`). For absolute predictions (`scale_invariant=False` and `shift_invariant=False`) alignment is skipped and only ensembling is performed. Args: depth (`torch.Tensor`): Input ensemble depth maps. scale_invariant (`bool`, *optional*, defaults to `True`): Whether to treat predictions as scale-invariant. shift_invariant (`bool`, *optional*, defaults to `True`): Whether to treat predictions as shift-invariant. output_uncertainty (`bool`, *optional*, defaults to `False`): Whether to output uncertainty map. reduction (`str`, *optional*, defaults to `"median"`): Reduction method used to ensemble aligned predictions. The accepted values are: `"mean"` and `"median"`. regularizer_strength (`float`, *optional*, defaults to `0.02`): Strength of the regularizer that pulls the aligned predictions to the unit range from 0 to 1. max_iter (`int`, *optional*, defaults to `2`): Maximum number of the alignment solver steps. Refer to `scipy.optimize.minimize` function, `options` argument. tol (`float`, *optional*, defaults to `1e-3`): Alignment solver tolerance. The solver stops when the tolerance is reached. max_res (`int`, *optional*, defaults to `1024`): Resolution at which the alignment is performed; `None` matches the `processing_resolution`. Returns: A tensor of aligned and ensembled depth maps and optionally a tensor of uncertainties of the same shape: `(1, 1, H, W)`. rirz,Expecting 4D tensor of shape [B,1,H,W]; got r>rfUnrecognized reduction method: z1Pure shift-invariant ensembling is not supported.r1c(>URTS5RSS9RnURTS5RSS9RnT(aUT(aNSX!- R SS9- nU*U-n[ R "X445R5R5nOCT(a1SUR SS9- nUR5R5nO [S5eUR[R5nU$)Nrrrư>minUnrecognized alignment.) rrvaluesr~clampr(rcpunumpyrsastyper&float64) r1init_mininit_maxinit_sinit_tparamrSr9r:s r- init_param8MarigoldDepthPipeline.ensemble_depth..init_params}}]B7;;;BIIH}}]B7;;;BIIH? 3::t:DD 8+ 6"23779??A x~~$~77 **, !:;;LL,ELr,rr]c>T(aT(a[R"US5up#[R"U5R U5R TSSS5n[R"U5R U5R TSSS5nX-U-nU$T(a=[R"U5R U5R TSSS5nX-nU$[ S5e)Nrrr)r&splitr( from_numpyrviewrs)r1rsroutrSr9r:s r-align3MarigoldDepthPipeline.ensemble_depth..aligns?xxq)$$Q'**5166}aAN$$Q'**5166}aANi!m J !$$U+..u5::=!QPQRiJ!!:;;r, depth_alignedreturn_uncertaintyNcj>SnTS:Xa6[R"USSS9nU(a[R"USSS9nX24$TS:Xa`[R"USSS9RnU(a6[R"[R "X- 5SSS9RnX24$[ STS35e)NrgrTrrhrr>)r(rgstdrhrabsrs)r r rrres r-ensemble6MarigoldDepthPipeline.ensemble_depth..ensemblesKF""ZZ 1dK %"'))Mq$"OK* * h&"\\-QMTT %"',,uyy9S/TZ[ei"j"q"qK* *!#B9+Q!OPPr,c>SnT "X5n[R"[R"T 55H?upEX4X5- nX&S-R5R 5R 5- nMA TS:anT "USS9upxUR 5R5R 5n SUR5- R5R 5n X)U -T-- nU$)NgrrFr r) r( combinationsarangergsqrtitemrrr~)rr1costr rjdiffr_err_nearerr_farrrrSrs r-cost_fn5MarigoldDepthPipeline.ensemble_depth..cost_fnsD!%/M**5<< +FG$'-*::q(--/4466H$a' (5 Q %>>+//1668!11668==?G+/CCCKr,c 0>SSKnUR[R5nTb4[ UR SS5T:a[ R"UTS5nT"U5nURR[TUS9UST TSS.S9nUR$) Nrrr`)r1BFGSF)maxiterdisp)methodroptions) scipyrr(float32r~r{rresize_to_max_edgeoptimizeminimizerx) r1r%depth_to_alignrresrrrrrs r- compute_param;MarigoldDepthPipeline.ensemble_depth..compute_params "XXemm4N"s>+?+?+C'Dw'N!7!J!J>[bds!t~.E..))~6$,e< *C55Lr,rrrrr)F) r}r{rsr(r)r&r'booltuplefloatr~rr)r1r9r:r\rerrrrr-requires_aligningrr depth_max depth_min depth_rangerrrrSrs `` ````` @@@@@r-r$MarigoldDepthPipeline.ensemble_depths\ 99;! u{{1~2KEKK=XYZ[ [ . .>ykKL L?PQ Q ell  "  bjj U\\  EJ + << +=A + 5<<!44 5 + +  2:: ell u      &,> A !%(E%'E%eSIIK  I I67 7 ,333= "k1   &K!!r,)rr;r<rLrMr9r:r@)NTTNN)NNNT)NrNTrararNNNr&FFT)TTFrhg{Gz?rgMbP?i)(r!r"r#r$r%model_cpu_offload_seqrCr r rrrr strr/intrBr rvrr(r)rrwrcompilerdisablerno_gradrEXAMPLE_DOC_STRINGrr0rr staticmethodr1rr+ __classcell__)rOs@r-r/r/hs'R6!7'+'+'+.248-^"-^-^!</ -^ $ -^ ! -^t-^-^-^"%t-^(+Tz-^-^^B!B!B B # B # B!$BB S>D0B$B??T%//%::TABB!B BH ^^PP$ ]]_12+/,0'+%/&037<@DH#(# !N !N !4ZN  N #Tz N !% N  #N !$N N  S>D0N U\\ 22T9N ??T%//%::TAN N !N N !N 3N `#)||#)$#)??T) #)  #)  #) u||U\\) *#)J U\\ ell !% $#(!&*Z"||Z"Z"Z"! Z"  Z" $ Z"Z"Z"Z" u||U\\D00 1Z"Z"r,r/)0 dataclassesr functoolsrtypingrrr&r(PILr tqdm.autor transformersrr rMr modelsr r schedulersrrutilsrrrrutils.import_utilsrutils.torch_utilsrpipeline_utilsrmarigold_image_processingrtorch_xla.core.xla_modelcore xla_modelrr get_loggerr!rDr=rr/r r,r-rQs&" 51 5-.=))MM   H %,  *   *S "-S "r,