Ë ¢rœh;"ãóÂ—UddlZddlZddlmZddlmZddlZddlmZm Z Gd„d«Z dede d efd „Zd„Z e aeed<ej d „«ZGd„d«Zdd„Zy)éN)ÚCallable)Ú deprecated)ÚKernelÚRegistrationHandlecój—eZdZdZdefd„Zed„«Zejd„«Zddœde d ed e fd„Zy) ÚFakeImplHolderz0A holder where one can register an fake impl to.Úqualnamecó —||_g|_y©N)r Úkernels)Úselfr s úk/var/www/html/ai-insurance-compliance-backend/venv/lib/python3.12/site-packages/torch/_library/fake_impl.pyÚ__init__zFakeImplHolder.__init__s€Ø%ˆŒ ð&(ˆócóR—t|j«dk(ry|jdS)Nréÿÿÿÿ)Úlenr)r s rÚkernelzFakeImplHolder.kernels%€äˆt|‰|Ó Ò!ØØ|‰|˜BÑÐrcó—td«‚)NzUnable to directly set kernel.©ÚRuntimeError)r Úvalues rrzFakeImplHolder.kernels€äÐ;Ó<Ð.deregister_fake_kernelNsø€ØL‰L×Ñ Õ'rr) rrr rÚtorchÚ_CÚ%_dispatch_has_kernel_for_dispatch_keyrrÚappendÚconstruct_meta_kernelÚimplr) r rrÚlibrr$Úmeta_kernelÚhandlers ` @rÚregisterzFakeImplHolder.register"s&ù€ñØ{‰{Ð&Ü"Ø7¸¿ ¹ °ðG>à—{‘{×)Ñ)Ð*¨!ð-óðô x‰x×=Ñ=¸d¿m¹mÈVÔTÜ"Ø7¸¿ ¹ °ðG%ð&óðôx‰x×=Ñ=Ø— ‘ Ð:ôô#Ø7¸¿ ¹ °ðG;ð<ó ð ô˜˜fÓ%ˆØ‰×Ñ˜FÔ#õ (ô,¨D¯M©M¸4Ó@ˆØ‰—‘ ¨VÀNˆÔSä#Ð$:Ó;ˆØˆ rN)Ú__name__Ú __module__Ú__qualname__Ú__doc__ÚstrrÚpropertyrÚsetterrrr.©rrrrsa„Ù:ð( ó(ðñ óð ð ‡]]ñ=óð=ðCHò3Øð3Ø&)ð3à ô3rrr Úfake_impl_holderrcóŠ‡‡—‰j€J‚tj‰jj«ˆˆfd„«}|S)NcóÀ•‡—‰j€J‚‰jjŠˆˆfd„}t|«5‰j|i|¤Žcddd«S#1swYyxYw)Ncó&•—t‰›d‰›d«‚)Nz (a¿): You're trying to run this operator with meta Tensors (as opposed to FakeTensors), but this operator may return an output Tensor with data-dependent shape. Meta Tensors don't support operators with outputs that have data-dependent shapes but FakeTensors do. If your operator does not return an output with data-dependent shape, make sure the FakeTensor and/or meta kernel does not call torch.library.get_ctx(). Otherwise, please use FakeTensors.r)r rs€€rÚerror_on_ctxz@construct_meta_kernel..meta_kernel..error_on_ctx`s'ø€ÜØ*˜B˜v˜hð'NðOó ð r)rrÚset_ctx_getter)ÚargsÚkwargsr;rr7r s @€€rr,z*construct_meta_kernel..meta_kernel[s`ù€à×&Ñ&Ð2Ð2Ð2Ø!×(Ñ(×/Ñ/ˆõ ô˜LÓ )ñ <Ø*Ð#×*Ñ*¨DÐ;°FÑ;÷ <÷ <ò <ús¸AÁA)rÚ functoolsÚwrapsr)r r7r,s`` rr)r)XsEù€Ø×"Ñ"Ð.Ð.Ð.ä‡__Ð%×,Ñ,×1Ñ1Ó2ô<ó3ð<ð&Ðrcó—yrr6r6rrÚget_nonerBrs€ØrÚglobal_ctx_getterc#ó8K—t} |ad–—|ay#|awxYwwr)rC)Ú ctx_getterÚprevs rr<r<ys'èø€ô€Dð!Ø&ÐÛ à Ñø˜DÑüs‚Š“—có€—eZdZdZd„Zede¬«dddœdejfd „«Z d ddœdejfd„Z y)ÚFakeImplCtxzO Context object for writing fake implementations for custom operators. cóB—||_|j|_||_yr)Ú _fake_modeÚ shape_envÚ _shape_envÚ_op)r rJrMs rrzFakeImplCtx.__init__‰s€Ø$ˆŒØ$×.Ñ.ˆŒØˆrzM`create_unbacked_symint` is deprecated, please use `new_dynamic_size` instead)ÚcategoryéN©ÚminÚmaxrcó(—|j||¬«S©NrP)Únew_dynamic_size©r rQrRs rÚcreate_unbacked_symintz"FakeImplCtx.create_unbacked_symintŽs€ð ×$Ñ$¨°#Ð$Ó6Ð6rrcóŽ—|j|jjs3tjjj|j«‚t|tj«st|tj«rtd|›d|›d«‚|dkrtd|›d«‚t|j||«S)a Constructs a new symint (symbolic int) representing a data-dependent value. This is useful for writing the fake implementation (which is necessary for torch.compile) for a CustomOp where an output Tensor has a size that depends on the data of the input Tensors. Args: min (int): A statically known inclusive lower bound for this symint. Default: 0 max (Optional[int]): A statically known inclusive upper bound for this symint. Default: None .. warning: It is important that the ``min`` and ``max`` (if not None) values are set correctly, otherwise, there will be undefined behavior under torch.compile. The default value of ``min`` is 2 due to torch.compile specializing on 0/1 sizes. You must also verify that your implementation on concrete Tensors (e.g. CPU/CUDA) only returns Tensors where the size that corresponds to the symint also has respects these constraint. The easiest way to do this is to add an assertion in the CPU/CUDA/etc implementation that the size follows these bounds. Example:: >>> # An operator with data-dependent output shape >>> lib = torch.library.Library("mymodule", "FRAGMENT") >>> lib.define("mymodule::custom_nonzero(Tensor x) -> Tensor") >>> >>> @torch.library.register_fake("mymodule::custom_nonzero") >>> def _(x): >>> # Number of nonzero-elements is data-dependent. >>> # Since we cannot peek at the data in an fake impl, >>> # we use the ctx object to construct a new symint that >>> # represents the data-dependent size. >>> ctx = torch.library.get_ctx() >>> nnz = ctx.new_dynamic_size() >>> shape = [nnz, x.dim()] >>> result = x.new_empty(shape, dtype=torch.int64) >>> return result >>> >>> @torch.library.impl(lib, "custom_nonzero", "CPU") >>> def _(x): >>> x_np = x.numpy() >>> res = np.stack(np.nonzero(x_np), axis=1) >>> return torch.tensor(res, device=x.device) zctx.new_dynamic_size(min=z, max=zZ): expected min and max to be statically known ints but got SymInt. This is not supported.rzc, ...): expected min to be greater than or equal to 0: this API can only create non-negative sizes.)rLÚallow_dynamic_output_shape_opsr%Ú_subclassesÚfake_tensorÚDynamicOutputShapeExceptionrMÚ isinstanceÚSymIntÚ ValueErrorÚ allocate_sizerVs rrUzFakeImplCtx.new_dynamic_size•s¸€ðf O‰OÐ#Ø—?‘?×AÒAä×#Ñ#×/Ñ/×KÑKÈDÏHÉHÓUÐUäcœ5Ÿ<™<Ô(¬J°s¼E¿L¹LÔ,IÜØ+¨C¨5°°s°eð<)ð*óð ðŠ7ÜØ+¨C¨5ð1&ð'óð ô˜TŸ_™_¨c°3Ó7Ð7r)r/r0r1r2rrÚ FutureWarningr%r^rWrUr6rrrHrH„sV„ñòñ ØWØôð-.°4ò7¸E¿L¹Lò7ó ð7ð'(¨TòF8°e·l±lôF8rrHcó’—|j«}tjjjj|||¬«|SrT)rWr%ÚfxÚexperimentalÚsymbolic_shapesÚ_constrain_range_for_size)rKÚmin_valÚmax_valÚresults rr`r`ÞsB€Ø × -Ñ -Ó /€FÜ ‡HH×Ñ×)Ñ)×CÑCØG ðDôð€Mr)rN)Ú contextlibr?ÚtypingrÚtyping_extensionsrr%Útorch._library.utilsrrrr3r)rBrCÚ__annotations__Úcontextmanagerr<rHr`r6rrúrps|ðäÛÝÝ(ãß;÷JñJðZ Cð¸>ðÈhóò4ð'Ð8Ó&ð×Ññ!óð!÷W8ñW8ôtr