a С║Фh;"у@sаUddlZddlZddlmZddlmZddlZddlmZm Z GddДdГZ ee edЬdd ДZd dДZ e aeed<ejd dДГZGddДdГZdddДZdS)щN)┌Callable)┌ deprecated)┌Kernel┌RegistrationHandlec@sPeZdZdZedЬddДZeddДГZejddДГZdd Ьe ee d ЬddДZd S)┌FakeImplHolderz0A holder where one can register an fake impl to.)┌qualnamecCs||_g|_dSйN)r┌kernels)┌selfrйr·F/var/www/auris/lib/python3.9/site-packages/torch/_library/fake_impl.py┌__init__szFakeImplHolder.__init__cCst|jГdkrdS|jdS)Nrщ )┌lenr )r rrr┌kernelszFakeImplHolder.kernelcCstdГВdS)NzUnable to directly set kernel.й┌RuntimeError)r ┌valuerrrrsFй┌allow_override)┌func┌source┌returncs╛|snИjdur*tdИjЫdИjjЫdЭГВtjаИjdбrLtdИjЫdЭГВtjаИjdбrntdИjЫdЭГВt||ГЙИjа ИбЗЗfd d Д}t ИjИГ}|jИj|d|dНt|Г}|S)z}Register an fake impl. Returns a RegistrationHandle that one can use to de-register this fake impl. Nz!register_fake(...): the operator z( already has an fake impl registered at ┌.ZMetaz┤ already has an DispatchKey::Meta implementation via a pre-existing torch.library or TORCH_LIBRARY registration. Please either remove that registration or don't call register_fake.ZCompositeImplicitAutograda% already has an implementation for this device type via a pre-existing registration to DispatchKey::CompositeImplicitAutograd.CompositeImplicitAutograd operators do not need an fake impl; instead, the operator will decompose into its constituents and those can have fake impls defined on them.csИjаИбdSr)r ┌removerйrr rr┌deregister_fake_kernelNsz7FakeImplHolder.register..deregister_fake_kernelr) rrrr┌torchZ_CZ%_dispatch_has_kernel_for_dispatch_keyrr ┌append┌construct_meta_kernel┌implr)r rr┌librr┌meta_kernel┌handlerrr┌register"s0 ■ zFakeImplHolder.registerN)┌__name__┌ __module__┌__qualname__┌__doc__┌strr ┌propertyr┌setterrrr$rrrrrs ■r)r┌fake_impl_holderrcs.ИjdusJВtаИjjбЗЗfddДГ}|S)Ncs`ИjdusJВИjjЙЗЗfddД}t|ГП Иj|i|дОWdГS1sR0YdS)NcstИЫdИЫdЭГВdS)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.rr)rrrr┌error_on_ctx`s z@construct_meta_kernel..meta_kernel..error_on_ctx)rr┌set_ctx_getter)┌args┌kwargsr-йr,r)rrr"[s z*construct_meta_kernel..meta_kernel)r┌ functools┌wrapsr)rr,r"rr1rrXsrcCsdSrrrrrr┌get_nonersr4┌global_ctx_getterccs"t}z|adVW|an|a0dSr)r5)Z ctx_getter┌prevrrrr.ys r.c@sTeZdZdZddДZededНdddЬejd Ьd dДГZ dddЬejd Ьd dДZ dS)┌FakeImplCtxzO Context object for writing fake implementations for custom operators. cCs||_|j|_||_dSr)┌ _fake_mode┌ shape_env┌ _shape_env┌_op)r r8r;rrrr ЙszFakeImplCtx.__init__zM`create_unbacked_symint` is deprecated, please use `new_dynamic_size` instead)┌categoryщNй┌min┌max)rcCs|j||dНSйNr>)┌new_dynamic_sizeйr r?r@rrr┌create_unbacked_symintОsz"FakeImplCtx.create_unbacked_symintrcCsv|jdus|jjs"tjjа|jбВt|tjГs:t|tjГrPt d|Ыd|ЫdЭГВ|dkrht d|Ы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) Nzctx.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.)r:Zallow_dynamic_output_shape_opsrZ_subclassesZfake_tensorZDynamicOutputShapeExceptionr;┌ isinstance┌SymInt┌ ValueError┌ allocate_sizerCrrrrBХs3 ■ zFakeImplCtx.new_dynamic_size)r%r&r'r(r r┌ FutureWarningrrFrDrBrrrrr7Дs■r7cCs"|аб}tjjjj|||dН|SrA)rDrZfxZexperimentalZsymbolic_shapesZ_constrain_range_for_size)r9Zmin_valZmax_val┌resultrrrrH▐s rH)rN)┌ contextlibr2┌typingrZtyping_extensionsrrZtorch._library.utilsrrrr)rr4r5┌__annotations__┌contextmanagerr.r7rHrrrr┌s M Z