PhzUddlZddlZddlZddlmZmZddlZddlmZm Z GddZ de de defd Z d Z e aeed <ej d ZGd dZy)N)CallableOptional)KernelRegistrationHandlec0eZdZdZdefdZdededefdZy) AbstractImplHolderz4A holder where one can register an abstract impl to.qualnamec.||_d|_d|_yN)r kernellib)selfr s gC:\Users\daisl\Desktop\realtime-object-detection\venv\Lib\site-packages\torch/_library/abstract_impl.py__init__zAbstractImplHolder.__init__ s% (, 48funcsourcereturncj0tdjdjjdtj j jdrtdjdtj j jdrtdjdt||_jCjjdd }tjj|d _tj}jjj|dfd }t|S) zRegister an abstract impl. Returns a RegistrationHandle that one can use to de-register this abstract impl. z!impl_abstract(...): the operator z, already has an abstract impl registered at .Metaz 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 impl_abstract.CompositeImplicitAutograda- already has an implementation for this device type via a pre-existing registration to DispatchKey::CompositeImplicitAutograd.CompositeImplicitAutograd operators do not need an abstract impl; instead, the operator will decompose into its constituents and those can have abstract impls defined on them.z::rFRAGMENTcnjr!jjd_d_yr )r _destroyr )rsrderegister_abstract_implz=AbstractImplHolder.register..deregister_abstract_impl@s(xx!!#DKr)r RuntimeErrorr rtorch_C%_dispatch_has_kernel_for_dispatch_keyrr splitlibraryLibraryconstruct_meta_kernelimplr)rrrns meta_kernelrs` rregisterzAbstractImplHolder.registersL ;; "3DMM?C>;;%%&a)  88 9 9$-- P3DMM?C!"  88 9 9 MM6 3DMM?C;<  T6*  88 $$T*1-B}},,R99 4.meta_kernel..error_on_ctxSs+j 1&: r)r rset_ctx_getter)argskwargsr3rr/r s @rr'z*construct_meta_kernel..meta_kernelNsW#**666%,,33 L ).'..??* ) )s AA)r functoolswrapsr)r r/r's`` rr$r$IsI & & 22 2__)00556@7@" rcyr r.r.rrget_noner:cs rglobal_ctx_getterc#8Kt} |ad|ay#|awxYwwr )r;) ctx_getterprevs rr4r4js' D!&  DscfeZdZdZdZddddej fdZddddej fd Zy) AbstractImplCtxzS Context object for writing abstract implementations for custom operators. c ||_||_yr ) _shape_env_op)rrBrCs rrzAbstractImplCtx.__init__zs$rNminmaxrcRtjd|j||S)NzIcreate_unbacked_symint is deprecated, please use new_dynamic_size insteadrE)warningswarnnew_dynamic_size)rrFrGs rcreate_unbacked_symintz&AbstractImplCtx.create_unbacked_symint~s) W $$#$66rrc|j|jjs3tjjj |j t|tjst|tjrtd|d|d|dkrtd|d|jj}tjjjj||||S)a= Constructs a new symint (symbolic int) representing a data-dependent value. This is useful for writing the abstract 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.impl_abstract("mymodule::custom_nonzero") >>> def custom_nonzero_abstract(x): >>> # Number of nonzero-elements is data-dependent. >>> # Since we cannot peek at the data in an abstract 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 custom_nonzero_cpu(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.rE)rBallow_dynamic_output_shape_opsr _subclasses fake_tensorDynamicOutputShapeExceptionrC isinstanceSymInt ValueErrorrLfx experimentalsymbolic_shapes_constrain_range_for_size)rrFrGresults rrKz AbstractImplCtx.new_dynamic_sizesf OO #??AA##//KKDHHU U c5<< (JsELL,I+C5se<)*  7+C51&'  779 --GG  H  r) r)r*r+r,rrrSrLrKr.rrr@r@us<-.47ELL7 '(TJellJrr@) contextlibr7rItypingrrrtorch._library.utilsrrrr-r$r:r;__annotations__contextmanagerr4r@r.rrr_sw% ;<<<<~); 4'8& !!YYr