Vh<PddlZddlZddlmcmZej dZdZy)Nc#Ktjj} tjj|dtjj|y#tjj|wxYwwN)torch_C_get_autograd_fallback_mode_set_autograd_fallback_mode)modeprevs e/home/dcms/DCMS/lib/python3.12/site-packages/torch/testing/_internal/optests/autograd_registration.pyset_autograd_fallback_moder sV 88 / / 1D3 ,,T2  ,,T2,,T2sB #A% B %!BB c t|tjjsJt j |i|}|Dcgc]}t|tj s|!}}td|Ds td|Dchc]}|jj}}|jddgstd|d|vrd}nd|vrd}tjj|jrytjj|jd rytjj|jd ryt!d 5||i|}ddd|Dchc] }t#|c} fd } t j$tj | syt'|jd cc}wcc}w#1swYsxYwcc}w)a)Check if autograd was registered correctly (for the operator). Operators should have "autograd support" registered directly to an autograd dispatch key. An incorrect registration may lead to unexpected silent incorrectness. Note that this check won't catch all problems but will catch the most common ones. Example usage: >>> x = torch.randn(3, requires_grad=True) >>> autograd_registration_check(torch.ops.aten.sin.default, (x,), {}) Here are some best practices if you do find your autograd is registered incorrectly: - If the operator is composite (i.e. consists of other PyTorch ops) and you wish the operator to decompose and get autograd support that way, then please register the implementation to DispatchKey::CompositeImplicitAutograd - If you're adding an autograd formula for the operator, the correct thing to do is to register an autograd.Function to DispatchKey::Autograd (preferred) or one of the DispatchKey::Autograd keys. It is NOT OK to register an autograd.Function to a backend (e.g. CPU/CUDA) key. - If your operator is non-differentiable, then you should register an implementation to the Autograd key that uses AutoDispatchBelowAutograd and re-invokes the operator. c34K|]}|jywr) requires_grad).0ts r z.autograd_registration_check..Ms41q4szautograd_registration_check: no inputs have requires_grad=True so we are unable to actually perform this test. Please pass inputs that do require grad.cpucudazBautograd_registration_check: NYI devices other than CPU/CUDA, got AutogradCUDA AutogradCPUNAutogradCompositeImplicitAutogradnothingc<|jsyt|vryy)NFT)rid)tensorinp_idss r not_an_input_and_requires_gradzCautograd_registration_check..not_an_input_and_requires_gradps!## f: aQ: at least one output of this operator has requires_grad=True but the operator does not have an autograd kernel defined at an autograd key (e.g. DispatchKey::Autograd). This could mean that you have incorrectly registered an autograd kernel to a non-Autograd DispatchKey, which may lead to silently incorrect results. If your operator consists of regular PyTorch operations, consider not using an operator at all or registering your operator as CompositeImplicitAutograd. If you have an autograd.Function registered to a backend (CPU/CUDA) key, the correct location for it is the Autograd key.) isinstancer_ops OpOverloadpytreearg_tree_leavesTensorany RuntimeErrordevicetypeissubsetNotImplementedErrorr%_dispatch_has_kernel_for_dispatch_keynamer r tree_any_onlyAssertionError) opargskwargs flat_argsarg all_tensorsall_device_typeskeyall_outsrrs @r autograd_registration_checkr9s: b%**// 00 06&&77I"+M3z#u||/L3MKM 4 4 4 $  4??C ??  $ $eV_ 5!PQaPb c  !! " " xx55bggiE xx55bggiL xx55  .  $I .'t&v&'#,,3r#w,G    .Lh W  779+/ 0  ]N@,''-s$G!GG#- G(G4(G1) contextlibrtorch.utils._pytreeutils_pytreer#contextmanagerr r9rr r@s3 $$ 33qr