ϑi!eSSKJr SSKrSSKJrJrJrJr SSKrSSKJ r SSK J r J r \(a!SSK Jr SSKJr SSKJr \"S \\\S 45r\S$S%S jj5r\S$S&S jj5rS$S jr\S$S%Sjj5r\S$S&Sjj5rS$SjrSrSr"SS5r"SS5r"SS5r"SS\5r"SS\5rSrSrS$SjrS r S!r!S$S"jr"S#r#g)') annotationsN) TYPE_CHECKINGCallableTypeVaroverload) framework)primapiutils)Sequence)Tensor)TensorOrTensors_OutputT.cgNfuncxsvs c/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/incubate/autograd/functional.pyvjpr! "cgrrrs rrr) +.rc6[XU5 [R"5(d[R"5(d[ U5[ U5p![ U[R5(aU"U6OU"U5n[X#5 U[X1U54$)aVComputes the Vector-Jacobian product, a functional form of reverse mode automatic differentiation. Warning: This API is in beta, the signatures could be changed in future version. Args: func(Callable): A function that takes ``xs`` as inputs parameter and returns a sequence of Tensors or a Tensor. xs(Tensor|Sequence[Tensor]): Used as positional arguments to evaluate ``func``. ``xs`` is accepted as one Tensor or a sequence of Tensors. v(Tensor|Sequence[Tensor]|None, optional): The cotangent vector involved in the VJP computation. ``v`` matches the size and shape of ``func`` 's output. Defaults to None, which is equivalent to all ones the same size of ``func`` 's output. Returns: output(tuple): - func_out(Tensor|tuple[Tensor]): The output of ``func(xs)`` . - vjp(Tensor|tuple[Tensor]): The vjp result. Examples: .. code-block:: python >>> import paddle >>> def func(x): ... return paddle.matmul(x, x) ... >>> x = paddle.ones(shape=[2, 2], dtype='float32') >>> _, vjp_result = paddle.incubate.autograd.vjp(func, x) >>> print(vjp_result) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=False, [[4., 4.], [4., 4.]]) >>> v = paddle.to_tensor([[1.0, 0.0], [0.0, 0.0]]) >>> _, vjp_result = paddle.incubate.autograd.vjp(func, x, v) >>> print(vjp_result) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=False, [[2., 1.], [1., 0.]]) ) _check_inputsrin_dygraph_moder prim_enabled _separate isinstancetypingr _check_v_shape_gradrrryss rrr1sv\$A  ""%*<*<*>*>" y|A V__55r48B1 uRQ rcgrrrs rjvpr(krrcgrrrs rr(r(srrc[XU5 [R"5(d[R"5(d[ U5[ U5p![ U[R5(aU"U6OU"U5n[X!5 [R"5(d3[R"5(aU[R"X1U54$U[X1U54$)a Computes the Jacobian-Vector product for a function at the given inputs and a vector in the tangent space induced by the inputs. Warning: This API is in beta, the signatures could be changed in future version. Args: func(Callable): The ``func`` takes as input a Tensor or a Sequence of Tensors and returns a Tensor or a Sequence of Tensors. xs(Tensor|Sequence[Tensor]): Used as positional arguments to evaluate ``func``. The ``xs`` is accepted as one Tensor or a Sequence of Tensors. v(Tensor|Sequence[Tensor]|None, Optional): The tangent vector involved in the JVP computation. The ``v`` matches the size and shape of ``xs`` . Default value is None and in this case is equivalent to all ones the same size of ``xs`` . Returns: output(tuple): - func_out(Tensor|tuple[Tensor]): The output of ``func(xs)`` . - jvp(Tensor|tuple[Tensor]): The jvp result. Examples: .. code-block:: python >>> import paddle >>> def func(x): ... return paddle.matmul(x, x) ... >>> x = paddle.ones(shape=[2, 2], dtype='float32') >>> _, jvp_result = paddle.incubate.autograd.jvp(func, x) >>> print(jvp_result) Tensor(shape=[2, 2], dtype=float32, place=Place(gpu:0), stop_gradient=False, [[4., 4.], [4., 4.]]) >>> v = paddle.to_tensor([[1.0, 0.0], [0.0, 0.0]]) >>> _, jvp_result = paddle.incubate.autograd.jvp(func, x, v) >>> print(jvp_result) Tensor(shape=[2, 2], dtype=float32, place=Place(gpu:0), stop_gradient=False, [[2., 1.], [1., 0.]]) ) rrrr rr r!r"r r#r forward_grad_double_backward_trickr%s rr(r({sb$A  ""%*<*<*>*>" y|A V__55r48B1  $ $ & &5+=+=+?+?7''222)"!444rcH[U5n[XU5n[XCU5$)zzDouble backward trick for computing ``jvp`` by ``vjp`` see details: https://j-towns.github.io/2017/06/12/A-new-trick.html )_zeros_like_with_gradr$)r&rrys_gradxs_grads rr,r,s' $B'GBG$G 1 %%rc[U[R5(d[R"U5nSUlU$/nUH1n[R"U5nSUlUR U5 M3 U$)zYCreate a zero or zeros sequence Tensor like ``xs`` with a flag ``stop_gradient=False`` . F)r!r"r paddle zeros_like stop_gradientappend)rr&xys rr.r.sn b&// * *   r "  I A!!!$A#AO IIaL Irc\\rSrSrSrSS SjjrS Sjr\S Sj5rSr g) Jacobianao Computes the Jacobian matrix of a given function. If the function has multiple inputs and multiple outputs, during internal implementation, all input tensors are concatenated after being flatten, the batch dimension is retained, and the output is subject to the same processing rules. Once the Jacobian ``J`` is constructed, you can use a multidimensional index to retrieve the submatrix of ``J``, as same as slicing a Tensor. The submatrix is lazily evaluated along row axis, and will be cached once evaluated. For examples, supposing ``is_batched=True``, you can retrieve the submatrix by following methods: * J[:], retrieving the full matrix. * J[:, :, j], retrieving the partial derivatives w.r.t. the j'th input variable. * J[:, i, :], retrieving the partial derivatives w.r.t. the i'th output variable. * J[:, i, j], retrieving the partial derivatives w.r.t. the i'th output variable and the j'th input variable. Notes: Ellipsis index is not supported currently. Warning: This API is in beta, the signatures could be changed in future version. Args: func (Callable): A python function that takes a Tensor or a sequence of Tensors as inputs(the first dimension is batch size) and returns a Tensor a sequence of Tensors. xs (Tensor|Sequence[Tensor]): The input to the function ``func`` . is_batched (bool): If true, the first axis is batch axis. Defaults to False. Returns: Jacobian (Object): A python object retains the Jacobian matrix. Examples: .. code-block:: python >>> import paddle >>> def func(x, y): ... return paddle.matmul(x, y) ... >>> x = paddle.to_tensor([[1., 2.], [3., 4.]]) >>> J = paddle.incubate.autograd.Jacobian(func, [x, x]) >>> print(J[:, :]) Tensor(shape=[4, 8], dtype=float32, place=Place(cpu), stop_gradient=False, [[1., 3., 0., 0., 1., 0., 2., 0.], [2., 4., 0., 0., 0., 1., 0., 2.], [0., 0., 1., 3., 3., 0., 4., 0.], [0., 0., 2., 4., 0., 3., 0., 4.]]) >>> print(J[0, :]) Tensor(shape=[8], dtype=float32, place=Place(cpu), stop_gradient=False, [1., 3., 0., 0., 1., 0., 2., 0.]) >>> print(J[:, 0]) Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=False, [1., 2., 0., 0.]) cTU(d[X5Ulg[X5Ulgr)_JacobianNoBatch _jacobian_JacobianBatchFirst)selfrr is_batcheds r__init__Jacobian.__init__s -d7DN0:DNrc URU$rr=r?indexess r __getitem__Jacobian.__getitem__(s~~g&&rc.URR$)z'The shape of flattened Jacobian matrix.)r=shaper?s rrJJacobian.shape-s~~###rrDNFrzCallable[..., TensorOrTensors]rr r@boolreturnNone)rFz%int | slice | tuple[int | slice, ...]rPr rPz list[int]) __name__ __module__ __qualname____firstlineno____doc__rArGpropertyrJ__static_attributes__rrrr9r9sbEV! ;, ;  ; ;  ;'<' ' $$rr9c`\rSrSr%SrS\S'S S SjjrS Sjr\S Sj5r Sr g )Hessiani3av Computes the Hessian matrix with a given ``func`` with respect to ``xs`` . If the function has multiple inputs, during internal implementation, all input tensors are concatenated after being flatten, the batch dimension is retained. The Hessian submatrix is lazily evaluated, and can be retrieved with a multidimensional indexes. See details ``Jacobian`` . Warning: This API is in beta, the signatures could be changed in future version. Args: func (Callable): A python function that takes a Tensor or a Tensor sequence as inputs and returns a Tensor with shape ``[batch_size, 1]`` with batch or ``[1]`` without batch. xs (Tensor|Sequence(Tensor)): The input Tensor or Tensor sequence of the function ``func``. is_batched (bool): If true, the first axis is batch axis. Defaults to False. Returns: Hessian (Object): A python object retains the Hessian matrix. Examples: .. code-block:: python >>> import paddle >>> def reducer(x): ... return paddle.sum(x * x) ... >>> x = paddle.rand([2, 2]) >>> h = paddle.incubate.autograd.Hessian(reducer, x) >>> print(h[:]) Tensor(shape=[4, 4], dtype=float32, place=CPUPlace(), stop_gradient=False, [[2., 0., 0., 0.], [0., 2., 0., 0.], [0., 0., 2., 0.], [0., 0., 0., 2.]]) r9symbolicc4^^UU4Sjn[XBTS9Ulg)Nc>[TUTS9nT(aURSS:wdT(dURSS:wa [S5eT(a USS2SSS24$USSS24$)Nr@rzfThe function given to Hessian should return as single element Tensor or batched single element Tensor.)r9rJ RuntimeError)rjacrr@s r _jac_func#Hessian.__init__.._jac_funcksf4 ;Csyy|q0399Q<1#4"|$.3q!Qw< <3q!t9 [TU]X5 grsuperrAr?rr __class__s rrA_JacobianNoBatch.__init__ "rcfURRSURRS4$Nr)rtrJrsrKs rrJ_JacobianNoBatch.shapes/  &&q)4+;+;+A+A!+DEErcgrrrKs rr}_JacobianNoBatch._lazy_axisrcN[R"[SU555$)Nc3B# UHoRS5v M g7f))N)r.0r6s r ,_JacobianNoBatch._flatten..s"@R99U#3#3Rs)r2rrrs rrr_JacobianNoBatch._flattens}}U"@R"@@AArcfUR[URUUR55$rrrr$rtror? row_indexs rr_JacobianNoBatch._evaluates0}}   +   rr rSrTrUrVrWrArXrJr}rrrrY __classcell__rs@rr<r<sG #FFB  rr<cX^\rSrSrSrU4Sjr\S5r\S5rSr Sr Sr U=r $) r>izCompute Jacobian matrix with batch at first axis. Suppose the mapping is :math:`f: R^{B,M} o R^{B,N}`, the output shape is ``(B, N, M)`` . c$>[TU]X5 grrrs rrA_JacobianBatchFirst.__init__rrcURRSURRSURRS4$r)rsrJrtrKs rrJ_JacobianBatchFirst.shapesJ    " "1 %    " "1 %    " "1 %  rcg)Nr`rrKs rr}_JacobianBatchFirst._lazy_axisrrcx[R"[S[R"U555S5$)Nc3`# UH$oRURSS45v M& g7f)rrN)rrJrs rr/_JacobianBatchFirst._flatten..s)L7K!))QWWQZ,--7Ks,.r`)r2rrr rprs rrr_JacobianBatchFirst._flattens.}} Lu7G7G7KL La  rcnUR[URSS2U4UR55$rrrs rr_JacobianBatchFirst._evaluates+}}U4#3#3AyL#A488LMMrrrrs@rr>r>sF #   NNrr>c `[U[R5(aUOU4n[SU55(a [ S5eU[ SSS54[ U5[ U5- --n/n[U5GH#up4[U[ 5(a[ UR=(d SUR=(d XUR=(d S5nUR[ URS:aURX-O URURS:aURX-O URUR55 M[U[5(a!URUS:aXAU-OU5 GM[SUS35e [U5$)a.A tool for parsing N-dimensional index into a standard format. Currently supporting following input format: * ([positive|negative|slice], ...), the right-most elements can be omitted. The standard format after converted is slice tuple which contains N elements: * ([positive|slice], ..., [positive|slice]) Notes: Ellipsis indexes such as ``(..., i), (i, ...)`` is not supported. Args: indexes (tuple): The input indexes. shape (tuple): The input shape. Returns: tuple: The standard format index as the above description. c3T# UHn[U[[55v M g7fr)r!typeEllipsis)rrs rr_multi_index..1s :'Q:ah ( ('s&(z*Ellipsis index currently is not supported.rNr`zNot supported index type .)r!r"r any IndexErrorrr enumeraterrrr5r TypeErrorr)rFrJpositive_indexesrrs rrrs_($GV__==gG:G :' :::EFFq$-/3u:G 3LMMGg& eU # #  q%**"8%**/E  # #.3kkAoEKK%(*5;;-2ZZ!^EJJ)JJ  s # #  # # E!H$4u M7wa@A A#'$ ! ""rc^Uc)[R"T5nTRUlU$[U[R 5(a[ U4Sj[U555$U$)Nc3F># UHup[UTU5v M g7fr)_replace_none_with_zero_tensor)rrr6refss rr1_replace_none_with_zero_tensor..Rs% CP41 *1d1g 6 6=s!)r2r3r4r!r"r rr)rrs `rrrLsa z   t $-- B ( ( CLR=    rc[R"5(a[R"XUSSS9n[ U[R RR [RR45(a3[ U[R5(a[U5S:aUSnO*[RRRXU5n[X15$)aA gradient function that can be used in dynamic graph and static graph. The ``grad`` combines ``paddle.grad`` used in dynamic graph and ``paddle.static.gradients`` used in static graph, and do following changes: * The ``allow_unused`` flag is removed and set defaults to true internally, none in outputs will be replaced by zero tensor. * The ``create_graph`` flag is removed and set defaults to true internally, only makes sense in dynamic graph. * When xs is a single Tensor, ``paddle.grad`` returns a list which only contains one Tensor. It may confuse users, thus in this case we improve to return a single Tensor in _grad interface. Args: ys (Tensor|Sequence[Tensor]): The output tensor or tensor sequence of the graph to compute gradients. xs (Tensor|Sequence[Tensor]): The input tensor or tensor sequence of the graph to compute gradients. The returned values of this API are the gradients of inputs . v (Tensor|Sequence[Tensor]|None,optional): The initial gradient values of outputs . If grad_outputs is None, the initial gradient values of outputs would be Tensors filled with 1; if grad_outputs is not None, it must have the same length as outputs , and in this case, the initial gradient value of the i-th outputs would be: (1) a Tensor filled with 1 when the i-th element of grad_outputs is None; (2) the i-th element of grad_outputs when the i-th element of grad_outputs is a Tensor. Default None. Returns: Tensor|tuple[Tensor]: Tensor or a tuple of Tensors, whose length is the same as the Tensor number inside inputs, and the i-th returned Tensor is the sum of gradients of outputs with respect to the i-th inputs. T) create_graph allow_unusedr)rrr2gradr!baseVariablepirValuer"r rincubateautogradr)r&rrr0s rr$r$YsF  ""++badN rFKK11::FJJ y0``, ``x0 -> x1 -> y0`` . ``paddle.grad(y0, x0)`` will reduce gradients along ``y0->x0`` and ``y0->x1->x0``, and ``vjp`` only need reduce along ``y0->x0``. So, it's needed to clone or detach xs for breaking the dependencies with other variables. Examples: .. code-block:: python >>> import paddle >>> from paddle.incubate.autograd.functional import _separate >>> def func(x, y): ... return x * y ... >>> x = paddle.ones((1,)) >>> x.stop_gradient = False >>> y = func(x, x) >>> print(paddle.grad(y, x)) [Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True, [2.])] >>> x1, x2 = _separate((x, x)) >>> y = func(x1, x2) >>> print(paddle.grad(y, x1)) [Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True, [1.])] c38# UHn[U5v M g7fr)_single_separaters rr_separate..s5"Q%a(("s)r!r"r rr)rs rr r s2X"foo&&5"555##rcUcU$UR(d[R"U5$UR5nSUlU$)NF)r4r2assigndetach)r6s rrrs9y ??}}Q HHJrc[U5(d[S[U5S35e[U[R [ R[RR45(d[S[U5S35e[U[ R5(a"[SU55(d [S5e[U[R [ R[S5[RR45(d[S[U5S35e[U[ R5(a#[SU55(d [S5egg)Nz$Expected 'fun' is Callable, but got rz4Expected 'xs' is a Tensor|Sequence[Tensor], but got c3# UH9n[U[R[RR 45v M; g7frr!rrr2rrrs rr _check_inputs..s23GI! 1y))6::+;+;<==rAAz&All elements of 'xs' should be Tensor.z6Expected 'v' is Tensor|Sequence[Tensor]|None, but got c3# UH9n[U[R[RR 45v M; g7frr)res rrrs22GH! 1y))6::+;+;<==qr) callablerrr!rrr"r r2rrallrs rrrs> D>>>tDzl!LMM  Y  &**2B2B C  B48*A N  "foo&&s3GI300@AA  I  dVZZ=M=M N  DT!WIQ O  !V__%%c2GH2//@AA/%rc Ucg[R"U5[R"U5p[U5[U5:wa$[S[U5S[U5S35e[ [ X55HKunup4UR UR :wdM$[SUSUR SUR S35e g)Nz6The argument v is a tuple of invalid length:should be z but got rzThe v[z] has invalid shape: should be )r rprrarziprJ)rrr element_v element_refs rr#r#syq!5#3#3D#9t 4yCFT 9SVHA 7  ,5S\+B'' ??k// / !''( )//1B!E ,Crr)rCallable[..., _OutputT]rr rTensorOrTensors | NonerPztuple[_OutputT, Tensor])rrrzSequence[Tensor]rrrPz#tuple[_OutputT, tuple[Tensor, ...]])$ __future__rr"rrrrr2 paddle.baserpaddle.incubate.autogradr r collections.abcr r paddle._typingr rrrr(r,r.r9r[rmr<r>rrr$r rrr#rrrrs# == !3(.z65+=>H !%" !""" " " !%. !...) . .7 t !%" !""" " " !%. !...) . .<5~&  [$[$|J#J#Z^"^"B y :N)N<-#` 07f/$d  B8r