oi S/rSSKrSSKJrJr SSKJr SSKJr SSKrSSK J r SSK J r Jr SS KJrJrJrJrJr SS KJrJrJrJrJr \S S \S \\S \\S\\S\S\4 Sjj5r\S!S \S\S \\S\\S\S\\S\S\S\4Sjj5r Sr!SSK"r#\$"\#RJRLRNS5(d\("\#RJRLRN5r)\)Hr*\*RWS5(aM\,"\#RJRLRN\*5r*\$"\*S5(dMR\$"\*RZS5(aMl\"\*RZ5\*l-M S\#RJRLRNl.g!\/a,r0\(a\Rb"S\"\0535 Sr0C0gSr0C0ff=f)"patch_torch_functionsN) torch_compileUNSLOTH_ENABLE_LOGGING)logger)Tensor) functional) _reductiongrad)handle_torch_functionhas_torch_functionhas_torch_function_variadic normalizenp)CallableListOptionalTupleUnioninputnormalized_shapeweightbiasepsreturnc ([XU5(a.[[XU4UUUUUS9RUR5$[ R"XX#U[ R RR5RUR5$)zpApply Layer Normalization for last certain number of dimensions. See :class:`~torch.nn.LayerNorm` for details. )rrr) rr layer_normtodtypetorchbackendscudnnenabled)rrrrrs [/home/james-whalen/.local/lib/python3.13/site-packages/unsloth_zoo/patch_torch_functions.pyrr's#5$77$  D !    "U[[/     sENN4H4H4P4P botarget size_average ignore_indexreduce reductionlabel_smoothingc t[XU5(a1[[XU4UUUUUUUUS9 RUR5$UcUb[ R "X55n[RRRUUU[ R"U5UU5RUR5$)aCompute the cross entropy loss between input logits and target. See :class:`~torch.nn.CrossEntropyLoss` for details. Args: input (Tensor) : Predicted unnormalized logits; see Shape section below for supported shapes. target (Tensor) : Ground truth class indices or class probabilities; see Shape section below for supported shapes. weight (Tensor, optional): a manual rescaling weight given to each class. If given, has to be a Tensor of size `C` size_average (bool, optional): Deprecated (see :attr:`reduction`). By default, the losses are averaged over each loss element in the batch. Note that for some losses, there multiple elements per sample. If the field :attr:`size_average` is set to ``False``, the losses are instead summed for each minibatch. Ignored when reduce is ``False``. Default: ``True`` ignore_index (int, optional): Specifies a target value that is ignored and does not contribute to the input gradient. When :attr:`size_average` is ``True``, the loss is averaged over non-ignored targets. Note that :attr:`ignore_index` is only applicable when the target contains class indices. Default: -100 reduce (bool, optional): Deprecated (see :attr:`reduction`). By default, the losses are averaged or summed over observations for each minibatch depending on :attr:`size_average`. When :attr:`reduce` is ``False``, returns a loss per batch element instead and ignores :attr:`size_average`. Default: ``True`` reduction (str, optional): Specifies the reduction to apply to the output: ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction will be applied, ``'mean'``: the sum of the output will be divided by the number of elements in the output, ``'sum'``: the output will be summed. Note: :attr:`size_average` and :attr:`reduce` are in the process of being deprecated, and in the meantime, specifying either of those two args will override :attr:`reduction`. Default: ``'mean'`` label_smoothing (float, optional): A float in [0.0, 1.0]. Specifies the amount of smoothing when computing the loss, where 0.0 means no smoothing. The targets become a mixture of the original ground truth and a uniform distribution as described in `Rethinking the Inception Architecture for Computer Vision `__. Default: :math:`0.0`. Shape: - Input: Shape :math:`(C)`, :math:`(N, C)` or :math:`(N, C, d_1, d_2, ..., d_K)` with :math:`K \geq 1` in the case of `K`-dimensional loss. - Target: If containing class indices, shape :math:`()`, :math:`(N)` or :math:`(N, d_1, d_2, ..., d_K)` with :math:`K \geq 1` in the case of K-dimensional loss where each value should be between :math:`[0, C)`. If containing class probabilities, same shape as the input and each value should be between :math:`[0, 1]`. where: .. math:: \begin{aligned} C ={} & \text{number of classes} \\ N ={} & \text{batch size} \\ \end{aligned} Examples:: >>> # Example of target with class indices >>> input = torch.randn(3, 5, requires_grad=True) >>> target = torch.randint(5, (3,), dtype=torch.int64) >>> loss = F.cross_entropy(input, target) >>> loss.backward() >>> >>> # Example of target with class probabilities >>> input = torch.randn(3, 5, requires_grad=True) >>> target = torch.randn(3, 5).softmax(dim=1) >>> loss = F.cross_entropy(input, target) >>> loss.backward() )rr'r(r)r*r+) rr cross_entropyrr _Reductionlegacy_get_stringr _C_nncross_entropy_lossget_enum)rr&rr'r(r)r*r+s r$r-r-CsX#5&99$  F #  %%+   "U[[/ 6#500F 88<< * * I&   bor%c [[RRS5(de[RRR[RRl[[RRlgg)N_uncompiled_layer_norm)hasattrr nnr rr5r%r$rrsT 588&&(@ A A5:XX5H5H5S5S2)3& Br%__UNSLOTH_PATCHED___forwardget_compiler_configTz)TorchAO patching failed with exception = )NNgh㈵>)NNiNmeang)2__all__ostemporary_patches.commonrrlogrr rtorch.nnr Fr r.r torch.nn.functionalr r rrrtypingrrrrrintfloatrboolstrr-r'torchao.quantization.qat.fake_quantizertorchaor6 quantizationqatfake_quantizerdir qat_classes qat_class startswithgetattrr;r9 Exceptionewarningr8r%r$rWsT&  K $3:9 $!  3i V  6      0 $#'! a a a V a4. a  a TN aaa aaD4M2 7''++::