+hzSSKJr SSKJr SSKJrJrJrJrJ r J r SSK r SSK r SSKJr SSKJr SSKJrJr SS KJr SS KJrJr SS KJrJr SS KJrJrJ r J!r! SS K"J#r# SSK$J%r% SSK&J'r' SSK(J)r) \"5(a SSK*J+s J,r- Sr.OSr.\ R^"\05r1Sr2\"SS\55r3"SS\'5r4g)) dataclass)partial)AnyDictListOptionalTupleUnionN)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\R4\ S'\S\R\R4\ S'\S\R4\ S'Sr g)MarigoldDepthOutputRa 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 imes 1 imes height imes width$ for `torch.Tensor` or $numimages imes height imes width imes 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 imes 1 imes height imes width$ for `torch.Tensor` or $numimages imes height imes width imes 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 imes 4 imes latentheight imes latentwidth$. predictionN uncertaintylatent) __name__ __module__ __qualname____firstlineno____doc__r npndarraytorchTensor__annotations____static_attributes__r%n/home/james-whalen/.local/lib/python3.13/site-packages/diffusers/pipelines/marigold/pipeline_marigold_depth.pyr r RsO bjj%,,.//tRZZ566 $ $ %%r1r c!&^\rSrSrSrSrSrS.S\S\S\ \ \ 4S\ S \ S \\S \\S \\S \\S\\4U4SjjjrS\S\S\S\S\S\S\S\\\\4S\\R.S\\ \R0\\R04S\S\S\4Sjr\R6R8S/Sj5r\R<"5\"\ 5S0S\S\\S\S\\S\S\S\S\S\\\\4S\\ \R.\\R.4S\\ \R0\\R04S\S\S \S!\4S"jj55r!S\R.S\\R.S\\R0S\S\S\"\R.\R.44 S#jr#S$\R.S\R.4S%jr$\%S1S&\R.S \S \S\S'\S(\&S)\S*\&S+\S\"\R.\\R.44S,jj5r'S-r(U=r)$)2MarigoldDepthPipelineia 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 disparityunetvae 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: .)r8r9r:r;r<)r=r>r?r@rAr9rr)vae_scale_factor)super__init__supported_prediction_typesloggerwarningregister_modulesregister_to_configgetattrlenr9configblock_out_channelsrEr>r?r@rAempty_text_embeddingrimage_processor) selfr8r9r:r;r<r=r>r?r@rA __class__s r2rGMarigoldDepthPipeline.__init__s  "A"A A NN<_$-J*$(!5tG\G\]r1imagenum_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 rC)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)rrz`image[z(]` has unsupported dimensions or shape: rnzUnsupported `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).0gr_s r2 5MarigoldDepthPipeline.check_inputs..Bs,Xi88==IaL,?,?,D,DDisr?r ImportError isinstancedictlist enumerater+r,r- is_tensorndimshaper sizersdimmaxlatent_channelsall Generator)rSrVrWrXrYrZr[r\r]r^r_r`raactual_vae_scale_factor num_imagesWHiimgH_iW_iN_imax_orignew_Hnew_Wwhshape_expecteds ` r2 check_inputs"MarigoldDepthPipeline.check_inputss_#$DHHOO,N,N(ORS(S"T "&;&; ;A$BWBWAXXwyPxQQST   &vw w  "FG G 1 @A A A  NN?  1 $"6"6$:N:NXjXlXlYZ Z A "4"  ! (k  !1 $*  !#8#8 8A =MdNcNcMddefg g (c cC  ")d dC  >=> > 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!RSSr1c[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 rCdescleavetotalz/Either `total` or `iterable` has to be defined.r%)hasattrrrzr{rxrsgetr )rSiterablerrrprogress_bar_configs r2 progress_bar"MarigoldDepthPipeline.progress_barIst344(*D %D55t<<OPTUYUnUnPoOppqr #?T%>%>?&9&=&=fd&KF#':'>'>w'NG$  8$78 8  ;e;':; ;NO Or1match_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_padTri)padding max_length truncationreturn_tensorsr)rrdtyperzMarigold predictions...)rr)rrFzDiffusion steps...r)encoder_hidden_statesr)r_)is_aar+)r"r#r$))_execution_devicerr@rArrQr<model_max_length input_idstor;rR preprocessprepare_latentsrepeatrrangerr: set_timesteps timestepsr-catr8step prev_sample XLA_AVAILABLExm mark_stepappenddecode_prediction unpad_imagereshapeensemble_depthr>r?zipresize_antialias pt_to_numpymaybe_free_model_hooksr )&rSrVrWrXrYrrZr[r\r]r^r_r`rarrrrrrprompt text_inputstext_input_idsroriginal_resolution image_latent pred_latentbatch_empty_text_embedding pred_latentsrbatch_image_latentbatch_pred_latenteffective_batch_sizetextt batch_latentnoiser"r#s& r2__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_distr^z3Could not access latents of provided encoder_output)rrmoder^AttributeError)encoder_outputs r2retrieve_latents?MarigoldDepthPipeline.prepare_latents..retrieve_latentsvsI~}55%11668833%---$%Z[[r1rr)r_rrr) r-rrrr9encoderOscaling_factorrepeat_interleaverrrr) rSrVr^r_rXr\rrrrs r2r%MarigoldDepthPipeline.prepare_latentsns \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$)Nrnrz Expecting 4D tensor of shape [B,z ,H,W]; got rCF)rrTrkeepdimg?g@) rrr9rOrrxdecoderrlr-clip)rSrr"s r2r'MarigoldDepthPipeline.decode_predictions ??  ![%6%6q%9TXX__=\=\%\2488??3R3R2SS^_j_p_p^qqrs XX__[88??3Q3Q%Q_d_efgh __D_9 ZZ D#6  3&#- r1r6rjregularizer_strengthmax_itertolmax_resc ^^^^^^^^^^^^UR5S:wdURSS:wa[SURS35eTS;a[STS35eT(dT(a [S5eS[R4UUU4S jjmS[RS [ R S [R4UUU4S jjmSS [RS[S [[R[[R44U4SjjjmS [ 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)`. rnrz,Expecting 4D tensor of shape [B,1,H,W]; got rCrkUnrecognized reduction method: z1Pure shift-invariant ensembling is not supported.r6c(>URTS5RSS9RnURTS5RSS9RnT(aUT(aNSX!- R SS9- nU*U-n[ R "X445R5R5nOCT(a1SUR SS9- nUR5R5nO [S5eUR[R5nU$)Nrrrư>minUnrecognized alignment.) rrvaluesrclampr-rcpunumpyrxastyper+float64) r6init_mininit_maxinit_sinit_tparamrXr>r?s r2 init_param8MarigoldDepthPipeline.ensemble_depth..init_params}}]B7;;;BIIH}}]B7;;;BIIH? 3::t:DD 8+ 6"23779??A x~~$~77 **, !:;;LL,ELr1rrbc>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_numpyrviewrx)r6rsroutrXr>r?s r2align3MarigoldDepthPipeline.ensemble_depth..aligns?xxq)$$Q'**5166}aAN$$Q'**5166}aANi!m J !$$U+..u5::=!QPQRiJ!!:;;r1 depth_alignedreturn_uncertaintycj>SnTS:Xa6[R"USSS9nU(a[R"USSS9nX24$TS:Xa`[R"USSS9RnU(a6[R"[R "X- 5SSS9RnX24$[ STS35e)NrlrTrrmrrC)r-rlstdrmrabsrx)rrr#r"rjs r2ensemble6MarigoldDepthPipeline.ensemble_depth..ensemblesKF""ZZ 1dK %"'))Mq$"OK* * h&"\\-QMTT %"',,uyy9S/TZ[ei"j"q"qK* *!#B9+Q!OPPr1c>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$)NgrrFrr) r- combinationsarangerlsqrtitemrrr)rr6costrrjdiffr"_err_nearerr_farr rrXrs r2cost_fn5MarigoldDepthPipeline.ensemble_depth..cost_fnsD!%/M**5<< +FG$'-*::q(--/4466H$a' (5 Q %>>+//1668!11668==?G+/CCCKr1c 0>SSKnUR[R5nTb4[ UR SS5T:a[ R"UTS5nT"U5nURR[TUS9UST TSS.S9nUR$) Nrrre)r6BFGSF)maxiterdisp)methodroptions) scipyrr-float32rrrresize_to_max_edgeoptimizeminimizerx) r6r*depth_to_alignrresr"rrrrs r2 compute_param;MarigoldDepthPipeline.ensemble_depth..compute_params "XXemm4N"s>+?+?+C'Dw'N!7!J!J>[bds!t~.E..))~6$,e< *C55Lr1rrrrr)F)rrrxr-r.r+r,boolr rfloatrrr)r6r>r?rarjrrrrr2requires_aligningrr# depth_max depth_min depth_ranger r"rrXrs `` ````` @@@@@r2r$MarigoldDepthPipeline.ensemble_depths\ 99;! u{{1~2KEKK=XYZ[ [ . .>ykKL L?PQ Q ell  "  bjj U\\  EJ + << +=A + 5<<%,,!77 8 + +  2:: ell u      &,> A !%(E%'E%eSIIK  I I67 7 ,333= "k1   &K!!r1)rr@rArQrRr>r?rE)NTTNN)NNNT)NrNTrfrfrNNNr+FFT)TTFrmg{Gz?rgMbP?i)*r&r'r(r)r*model_cpu_offload_seqrHrrr rrr rrstrr4intrGrrrr-r.rrrcompilerdisablerno_gradrEXAMPLE_DOC_STRINGrr rr staticmethodr5rr0 __classcell__)rTs@r2r4r4is$'R6!7*.*.*.157;-^"-^-^ 45 -^ $ -^ ! -^"#-^"$-^"$-^"*#-^(0}-^-^^B!B!B B # B # B!$BB$DcN3B%,,'BE%//43H"HIJBB!B BH ^^PP$ ]]_12.2/3'+%/&06:EIMQ#(# !N !N &c]N  N (} N !% N  #N !$N N $DcN3N % d5<<.@ @ABN E%//43H"HIJN N !N N !N 3N `#)||#)%,,'#)EOO, #)  #)  #) u||U\\) *#)J U\\ ell !% $#(!&*Z"||Z"Z"Z"! Z"  Z" $ Z"Z"Z"Z" u||Xell33 4Z"Z"r1r4)5 dataclassesr functoolsrtypingrrrrr r rr+r-PILr tqdm.autor transformersr rrRrmodelsrr schedulersrrutilsrrrrutils.import_utilsrutils.torch_utilsrpipeline_utilsrmarigold_image_processingrtorch_xla.core.xla_modelcore xla_modelrr get_loggerr&rIrAr r4r%r1r2rUs&":: 51 5-.=))MM   H %, &*& &,S "-S "r1