U yтЭh╤у@sЪUddlZddlZddlmZmZddlmZddlZddlm Z m Z GddДdГZeeedЬdd ДZ d dДZeaeed<ejd dДГZGddДdГZdS)щN)┌Callable┌Optional)┌ deprecated)┌Kernel┌RegistrationHandlec@s0eZdZdZedЬddДZeeedЬddДZdS) ┌AbstractImplHolderz0A holder where one can register an fake impl to.)┌qualnamecCs||_d|_d|_dSйN)r┌kernel┌lib)┌selfrйr ·N/var/www/html/venv/lib/python3.8/site-packages/torch/_library/abstract_impl.py┌__init__szAbstractImplHolder.__init__)┌func┌source┌returncs╥Иjdk r&tdИjЫdИjjЫdЭГВtjаИjdбrHtdИjЫdЭГВtjаИjdбrjtdИjЫdЭГВt||ГИ_ИjdkrаИjа d бd }tj а|dбИ_tИjИГ}Иjа Иj|dбЗfdd Д}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.z::rZFRAGMENTcs ИjrИjабdИ_dИ_dSr )rZ_destroyr r йrr r┌deregister_fake_classAs z:AbstractImplHolder.register..deregister_fake_class)r ┌RuntimeErrorrr┌torchZ_CZ%_dispatch_has_kernel_for_dispatch_keyrr┌split┌library┌Library┌construct_meta_kernel┌implr)rrr┌ns┌meta_kernelrr rr┌registers. zAbstractImplHolder.registerN) ┌__name__┌ __module__┌__qualname__┌__doc__┌strrrrrr r r rrsr)r┌abstract_impl_holderrcs.Иjdk stВtаИjjбЗЗfddДГ}|S)Nc sPИjdk stВИjjЙЗЗfddД}t|ГПИj||ОW5QRгSQRXdS)NcstdИЫdИЫdЭГВdS)Nz.meta_kernel..error_on_ctx)r ┌AssertionErrorr┌set_ctx_getter)┌args┌kwargsr&йr%r)rrrOs z*construct_meta_kernel..meta_kernel)r r'┌ functools┌wrapsr)rr%rr r+rrJsrcCsdSr r r r r r┌get_nonedsr.┌global_ctx_getterccst}z|adVW5|aXdSr )r/)Z ctx_getter┌prevr r rr(ks r(c@sTeZdZdZddДZededНdddЬejd Ьd dДГZ dddЬejd Ьd dДZ dS)┌AbstractImplCtxzO Context object for writing fake implementations for custom operators. cCs||_|j|_||_dSr )┌ _fake_modeZ shape_env┌ _shape_env┌_op)rr2r4r r rr{szAbstractImplCtx.__init__zM`create_unbacked_symint` is deprecated, please use `new_dynamic_size` instead)┌categoryщNй┌min┌max)rcCs|j||dНS)Nr7)┌new_dynamic_size)rr8r9r r r┌create_unbacked_symintАsz&AbstractImplCtx.create_unbacked_symintrcCsМ|jdks|jjs"tjjа|jбВt|tjГs:t|tjГrPt d|Ыd|ЫdЭГВ|dkrht d|ЫdЭГВ|jа б}tjjj j|||dН|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.r7)r3Zallow_dynamic_output_shape_opsrZ_subclassesZfake_tensorZDynamicOutputShapeExceptionr4┌ isinstance┌SymInt┌ ValueErrorr;ZfxZexperimentalZsymbolic_shapesZ_constrain_range_for_size)rr8r9┌resultr r rr:Зs(3 ■ z AbstractImplCtx.new_dynamic_size)r r!r"r#rr┌ FutureWarningrr=r;r:r r r rr1vs■r1)┌ contextlibr,┌typingrr┌typing_extensionsrrZtorch._library.utilsrrrr$rr.r/┌__annotations__┌contextmanagerr(r1r r r r┌s @■