^jUn UdZddlmZddlZddlZddlZddlmZmZddl m Z ddl m Z m Z ddlZddlmZdd lmZmZd d lmZd d lmZd d lmZmZmZmZmZmZerddlZddl m!Z!ddl"m#Z#ddl$m%Z%erddl&Z&ddl'm(Z(ddl)m*Z+e rddl,m-Z-er ddl'm.Z.m/Z/m0Z0ejbe2Z3GddeZ4e dZ5dYdZ6edddZ7eddddZ8eddd Z9edd!d"Z:edd#d$Z;edd%d&Z<edd'd(Z=dZd)Z>edd*d+d,Z?edd-d.d/Z@edd0d1d2ZAedd3d4ZBedd5d6ZCedd7d8ZDedd9d:ZEedd;d<ZFedd=d>ZGedd?d@ZHeddAdBZIeddCdDZJeKejejejejejejhZRedd[dEZSedd[dFZTedd[dGZUedd[dHZVeWZXereXjejjjjejjjjejjjjejjjjejjjjhedd[dIZbedd[dJZcedd[dKZdedd[dLZeedd[dMZfd\dNZg d] d^dOZhd_d`dPZidadbdQZjdadRZkdSZldTZmiZndUeodV<erCenjejjjjeiejjjjehejjjjejejjjjejejjjjekejjjjemejjjjemejelidcdWZ{e{gZ|dddXZ}y)euXONNX exporter. Extends `DynamoExporter` with five extra stages that convert an `ExportedProgram` into an ONNX model via `torch.onnx.export`: 1. **Torch patches** (`_PATCHES["onnx"]` via `apply_patches("onnx")`): reversibly monkey-patch `torch` ops at tracing time so `torch.export` and `torch.onnx.export` emit ONNX-lowerable patterns. Reverted on exit. 2. **ONNX patches** (`_PATCHES["onnx"]` via `apply_patches("onnx")`): reversibly hook `torch.onnx` internals — specifically `_prepare_exported_program_for_export`, so the FX node fixes (stage 3) run again right after `run_decompositions`. Same registry as stage 1, installed by the same `apply_patches` call. 3. **FX node fixes** (`_FX_NODE_FIXES["onnx"]` via `apply_fx_node_fixes("onnx", gm)`): per-node in-place rewrites on the `GraphModule` to drop or replace nodes ONNX can't lower (alias, in-place ops, dead comparisons, `_assert_*`, …). Triggered both directly after `torch.export` and indirectly via the stage 2 hook. 4. **ONNX translations** (`_ONNX_TRANSLATION_TABLE`): custom onnxscript functions passed as `custom_translation_table` that override the default torchlib lowering for specific aten ops where it's buggy or missing. 5. **ONNX IR fixes** (`_IR_FIXES` via `apply_onnx_ir_fixes`): post-export in-place fixes on the `ONNXProgram` IR for ORT compatibility. ) annotationsN)MutableMappingSequence)contextmanager) TYPE_CHECKINGAny)logging)is_onnxscript_availableis_torch_available) OnnxConfig)DynamoExporter)apply_fx_node_fixes apply_patchesduplicate_leaf_tensorsget_leaf_tensorsregister_fx_node_fixregister_patch)ExportedProgram) ONNXProgram) masking_utils)aten_index_put)opset18)PreTrainedModel)BOOLINT64TRealcHeZdZdZgdZddddZ dfd ZxZS) OnnxExporteraExporter that converts a [`PreTrainedModel`] to an ONNX `ONNXProgram`. Example: ```python >>> from transformers.exporters.exporter_onnx import OnnxExporter, OnnxConfig >>> exporter = OnnxExporter() >>> onnx_program = exporter.export(model, inputs, config=OnnxConfig(dynamic=True)) >>> outputs = onnx_program(**inputs) # run in-memory >>> exporter.export(model, inputs, config=OnnxConfig(output_path="model.onnx")) # save to disk ``` )torchonnx onnxscriptz2.12.0z1.21.0z0.7.0ct|tr tdi|}n(t|turt dt|t |5\}}t d5t|!|||}t||\}}td|jtjj|d|j||tj t|t"|j$|j&|j(|j* }ddddddt-|S#1swYxYw#1swY"xYw)Nz1Expected config to be an OnnxConfig or dict, got r")config) argsf input_names output_nameskwargscustom_translation_table opset_version external_data export_paramsoptimize) isinstancedictrtype TypeErrorpatch_model_outputsrsuperexportdisambiguate_io_namesr graph_moduler!r" output_pathcopydeepcopy_ONNX_TRANSLATION_TABLEr-r.r/r0apply_onnx_ir_fixes) selfmodel sample_inputsr% inputs_names outputs_namesexported_program onnx_program __class__s o/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/exporters/exporter_onnx.pyr7zOnnxExporter.exportis/ fd #)&)F &\ +OPTU[P\~^_ _  ' +HL--X^J_ 05um\b0c *? m*\ 'L- (8(E(E F(- (9(9 $$(*}}T-%89)@$22$22$22): )L   $ L)'    s%D= B4D1D=1D: 6D==E)r@rrAzMutableMapping[str, Any]r%zOnnxConfig | dict[str, Any]returnr)__name__ __module__ __qualname____doc__required_packagestested_versionsr7 __classcell__)rFs@rGr r WsL 8 (('RO0,   r c#Kgg|jtjfd} ||_f|_y#|_wxYww)zWrap `model.forward` to return a flat `dict[str, Tensor]` with duplicated outputs, and capture the input/output tensor names from the traced forward in the yielded `(inputs_names, outputs_names)` lists. c tt|i|}jt|jj|j|SN)rrextendkeys)r'r+outputsrBoriginal_forwardrCs rGpatched_forwardz,patch_model_outputs..patched_forwardsU"#9:JD:[TZ:[#\],V499;<W\\^,rPN)forward functoolswraps)r@rXrBrWrCs @@@rGr5r5s_!L!M}}__%&' )' M))( ( s0A A A AAct|jt|D]0}d|||j|<d|||j|<2||fS)zEPrefix any name that appears in both lists with `input.` / `output.`.zinput.zoutput.)set intersectionindex)rBrCnames rGr8r8slL!..s=/ABD39$ \''-.5.patchs a &:a+F177VWV]V]K]QWW A 5<< (ZC;M-N Qaggahh?A 5<< (ZC;M-N Qaggahh?A 9I& & YIq) )Iq!, ,rPNNr&rorps` rG _patch_whererss - LrPztorch.unsqueezeztorch.Tensor.unsqueezecfd}|S)z+Support complex tensors in torch.unsqueeze.ctj|r<|j|}|j|}tj||S||SrS)r! is_complexrealimagcomplex) self_or_inputdimrwrxros rGrpz_patch_unsqueeze..patchsS   M *M..4DM..4D==t, , s++rPr&rrs` rG_patch_unsqueezer|s, LrPz/transformers.masking_utils._vmap_expansion_sdpac d}|S)z;Replace vmap-based mask expansion with broadcast expansion.cfd}|S)Nctj||||}|j|jd|jd|jd|jd}|SNr)r_non_vmap_expansion_sdpaexpandshape) batch_arange head_arangeq_arange kv_arange brodcastedresult mask_functions rG _expandedzA_patch_broadcast_mask_expansion..patch.._expandedsl&?? k[cenoJ"J/66""1%{'8'8';X^^A=NPYP_P_`aPbFMrPr&)rrs` rGrpz._patch_broadcast_mask_expansion..patchs rPr&) _originalrps rG_patch_broadcast_mask_expansionrs LrPztorch.nn.RMSNorm.forwardcfd}|S)zAUse non-fused RMS normalization when elementwise_affine is False.c(|js}|jtjj dj dd}|tj ||jzzj|jS||S)Nr T)keepdim) elementwise_affinergr!float32powmeanrsqrtepsrd)r?rmvarianceros rGrpz&_patch_rms_norm_forward..patchsr&&ttEMM*..q166r46HH Htxx$788<.patchs'}}UZZ&9:==eDDrP)r!int64stridedrrs rG_patch_randpermrs& ++emmDUZfjE LrPz torch.histccdddd}|S)u~Replace `torch.histc` with a statically-shaped, deterministic equivalent. The default torchlib `aten_histc` translation rejects integer input (`torch.histc only works on float`), and the obvious workaround — casting to float — calls `_histc_cuda` which has no deterministic implementation on CUDA. `bincount`'s output is an unbacked SymInt under torch.export and trips downstream meta-shape guards (e.g. grouped_mm's `offs` size check). Pre-allocating `torch.zeros(bins)` + `scatter_add_` keeps the output shape pinned to `bins` (a Python int), and `scatter_add_` is deterministic on integer indices. N)outc|jd}||cxk(rdk(r@nn=|jj}|jj}nTt j t||j }t j t||j }||z |z }|j|z |z jjd|dz } |jr |jntj} t j|| |j } | jd| t j| | S)Nrrrr rcrd)reshapeminrimaxr!rkrelongclamp_is_floating_pointrdzeros scatter_add_ ones_like) inputbinsrrrflatmin_valmax_val bin_widthidx out_dtypecountss rGrpz_patch_histc..patchs}}R  #??hhj&&(Ghhj&&(Gll5:dkkBGll5:dkkBGw&$.  w&)399;BB1dQhO#(#:#:#.patch+sV ::l #r ) JJ| $%nnRXXb-IJF7O.t.v..rPr&rrs` rG_patch_opset13_constantr s/ LrPcfd}|S)zFDecompose cummax/cummin via triangular-mask reduction (O(N^2) memory).c6|j|}|j|d}|jdjg|jdd||}t j ||tj |jj}|jtj k(r dk7}n|jrX dk(r)t j|jjn(t j|jj}nW dk(r)t j|jjn(t j|jj}t jd||j|j}t j |||} dk(r|jdn|jd} | j"jd|| j$jd|fS)Nrrcrr&r{)rmovedim unsqueezerr!onesrjretrilrdrfinforriinfofullwherevaluesindices) rr{rrmx_gridincludefill_valfillmaskedrmodes rGrpz&_patch_cummax_or_cummin..patch7s KK  MM#r "'R''<".patchYsZ   E " ,I==UZZ^^-=!=y5::>>K[?[\ \rPr&rrs` rG _patch_exprTs  LrPztorch.fft.irfftcdd}|S)uYReplace `irfft` with `ifft` over the conjugate-mirrored input — ORT's `DFT` op rejects the `is_onesided=1`/`inverse=1` combination that torch's `irfft` lowers to. Mirroring restores the full spectrum so the inverse path uses two-sided DFT, which ORT accepts. Assumes even `n` (which is the common case for STFT-based audio codecs).cb|d|j|dz z}tdg|jz}tdd||<tj||t |j |gjg|}tjj||||jS)Nr r r)dimsr)rr{norm) rslicendimr!cattupleflipconjfftifftrw)rrr{rslcrs rGrpz_patch_irfft..patchis 9U[[%)*AT{mejj(B<Cyy%uSz!2!7!7cU!7!C!H!H!JKQTUyy~~daSt~<AAArP)NrNr&rrs rG _patch_irfftrbsB LrPztorch.bucketizecdddd}|S)zUVectorized bucketize avoiding scalar-constant tensors that cause alias/detach issues.F) out_int32rightcv|jdk(rHtj|tj}|r|j tj S|S|r||j dk}n||j dk}|jd}|r|j tj S|S)Nrrr)numelr! zeros_likerrgint32rsum)r boundariesrrrmasks rGrpz_patch_bucketize..patchxs     "%%e5;;?F-6699U[[) BF B !44D 33D")2vyy%>>rPr&rrs rG_patch_bucketizerts/45 ? LrPztorch.searchsortedcddddddd}|S)uGDecompose searchsorted via broadcast comparison + sum — no ONNX op for searchsorted. For sorted inputs the insertion index equals the count of elements satisfying the comparison (< for left, <= for right). This is O(N*M) instead of the real binary-search O(M log N) but only uses ops with ONNX translations. FN)rrsidersorterc ||dk(}|r$|jd|jdk}n#|jd|jdk}|jd}|r|jtjS|S)Nrrr)rrrgr!r) sorted_sequencerrrrrrrrs rGrpz"_patch_searchsorted..patchs{  GOE ",,R0F4D4DR4HHD",,R063C3CB3GGD")2vyy%>>rPr&rrs rG_patch_searchsortedr s5:TW[dh? LrPz torch.fullcddfd }|S)z`Force dtype=torch.long when fill_value is int and no dtype specified (ONNX defaults to float32).Nrc|E|jdt|dkDr|dnd}t|trtj }|d|i|S)N fill_valuer rd)rlenr1rhr!r)rdr'r+r ros rGrpz_patch_full..patchsQ =LSY]$q'PTUJ*c* 5U5f55rPr&rrs` rG _patch_fullrs 6 LrPztorch.masked.meancddddd}|S)zCManual masked mean: avoids sum/int_count Div type mismatch in ONNX.NF)r{rrdc|j}|j|djd}||zj|||r|n|jz }||j |S|S)NTr{r?r)rirclampsqueezerg)rrr{rrd mask_floatrrs rGrpz!_patch_masked_mean..patchssZZ\ NNsDN 1 7 7C 7 @*$))c7)CGqYZYbYbYde#(#4vyy@&@rPr&rrs rG_patch_masked_meanrs#'TA LrPztorch.masked.varcddddd}|S)zBManual masked var: avoids sum/int_count Div type mismatch in ONNX.NFT)r{runbiasedcJ|j}|j|djd}||zj|d|z }||z jd|zj||}|r|dz n|} |s| j } || jdz S)NTrrrr )rirrrr) rrr{rrrrrvardenoms rGrpz _patch_masked_var..patchsZZ\ NNsDN 1 7 7C 7 @ "''C'>B !!!$z16636P%S1MMOEU[[S[)))rPr&rrs rG_patch_masked_varrs#'* LrPztorch.Tensor.masked_scatterc d}|S)zPCumsum-gather-where strategy for masked_scatter (avoids ScatterND ORT failures).cn|j|}|jd}|jtjj ddz j d}|jd|}tj|||jdj|jS)Nrrr r) expand_asrrgr!rcumsumrrr)r?rsource flat_mask positionsgathereds rGrpz$_patch_masked_scatter..patchs~~d#LL$ \\%++.55a81<CCCJ >>"%i0{{9h R0@AII$**UUrPr&rrs rG_patch_masked_scatterr&sV LrPz torch.rollcdfd }|S)aReplace `torch.roll(input, shifts, dims)` with explicit `narrow + cat` shifts. `torch.roll`'s torch.export lowering emits a `Shape(start, end)` op that can resolve to an empty INT64 result; the downstream `Slice` then has mismatched `axes` and `ends` lengths and ORT rejects the graph with `ShapeInferenceError` (seen in Gemma4-Unified Vision2Text, where roll is composed with an in-place scatter `[..., 0] = value`). The explicit form is bit-exact and traces to plain Slice + Concat nodes. ct|trt|tr|f}|f}nMt|ttfr-t|ttfrt |t |k(s  |||S|}t ||D]m\}}|j |}|dkDr||znd}|dk(r)|j|||z |}|j|d||z }tj||g|}o|S)Nrr) r1rhrlistr zipsizenarrowr!r) rshiftsrrshiftr{lengthfrontbackros rGrpz_patch_roll..patchs fc "z$'<YF7DVeT]3 4%QU8W\_`f\gknoskt\tE640 0fd+ 4JE3XXc]F&,qjEFNaEzJJsFUNE:E::c1fun5D))UDMs3C 4 rPrSr&rrs` rG _patch_rollr2s$ LrPzHtorch.onnx._internal.exporter._core._prepare_exported_program_for_exportcfd}|S)aRun the FX node fixes immediately after the ONNX internal decomposition step. `torch.onnx.export` internally calls `run_decompositions` with the ONNX decomposition table, which can introduce new symbolic-guard nodes (e.g. `operator.le(sym_size, int_oo)`). These overflow during ONNX translation. Wrapping the prepare step lets us apply our FX fixes immediately after. This hooks `torch.onnx._internal.exporter._core._prepare_exported_program_for_export`, a private PyTorch API. It may break on PyTorch version upgrades. If it does, find the new entry point in `torch/onnx/_internal/exporter/_core.py` where `ExportedProgram.run_decompositions` is called and hook there instead. cH||}td|j|S)N)registryr")rr9)epr5rros rGrpz(_patch_prepare_for_export..patchs$"x0FF$7$78 rPr&rrs` rG_patch_prepare_for_exportr7s& LrPcv|jtvryt|jdk(r|jj |yt d|jDrG |j|j}|j||jj |yy#t$rYywxYw)u.Erase or constant-fold comparison nodes involving symbolic infinities. torch.export emits guards like ``%le_3 = operator.le(sym_size, int_oo)`` where ``int_oo`` is a sympy ``IntInfinity`` object. The ONNX translator tries to lower it to a C long and overflows. Two cases handled: * No users → erase the node outright (PyTorch DCE skips Python callables). * Any arg is a non-FX-Node constant (e.g. ``int_oo``) → evaluate the comparison at graph-construction time, replace all uses with the Python bool result, and erase. FrTc3fK|])}t|tjj +ywrS)r1r!fxNode).0as rG z'_fix_dead_comparison..6s" ?z!UXX]]+ + ?s/1) target_COMPARISON_OPSr usersgraph erase_nodeanyr' Exceptionreplace_all_uses_with)gmnoders rG_fix_dead_comparisonrI$s {{/) 4::! D! ?TYY ??  T[[$)),F ""6* D!    s%B,, B87B8c|jtjjjj ury|j |jd|jj|y)zHReplace alias(x) -> x to break the alias -> detach_ -> index_put_ chain.FrT) r?r!opsatenaliasdefaultrFr'rBrCrGrHs rG _fix_aliasrPAsR {{%))....666tyy|,HH rPc|jtjjjj ury|j j|5|j jtjjjj |j|j}ddd|j|j j|y#1swY6xYw)z2Replace in-place detach_ with out-of-place detach.Fr'r+NT)r?r!rKrLdetach_rNrBinserting_before call_functiondetachr'r+rFrCrGrHnews rG_fix_detach_inplacerYKs {{%))..00888  " "4 (hhh$$UYY^^%:%:%B%B[_[f[f$ghs#HH  hh AC++C4c|jtjjjj ury|j j|5|j jtjjjj |j|j}ddd|j|j j|y#1swY6xYw)z8Replace in-place index_put_ with out-of-place index_put.FrRNT)r?r!rKrL index_put_rNrBrTrU index_putr'r+rFrCrWs rG_fix_index_put_inplacer^Ws {{%))..33;;;  " "4 (khh$$UYY^^%=%=%E%EDII^b^i^i$jks#HH  kkrZc`|jtvry|jj|y)zFErase assertion / shape-constraint nodes that have no ONNX equivalent.FT)r?_ASSERTION_OPSrBrCrOs rG_fix_assertionraps( {{.(HH rPc|jtjjjj ury|j j|5|jd}|jd}|j jtjjjj|df}|j jtjjjj|df}|j jtjjjj ||f}|j jtjjjj|tjf}|j jtjjj j ||f}|j jtjjj"j$|||f} ddd|j' |j j)|y#1swY6xYw)z=Replace in-place fill_diagonal_ with out-of-place equivalent.Frr r'NT)r?r!rKrLfill_diagonal_rNrBrTr'rUsym_sizerheyergrdrj full_likerr?rFrC) rGrH tensor_argr rowscolsrfeye_bool fill_tensorrXs rG_fix_fill_diagonal_inplacermys {{%))..77???  " "4 ( jYYq\ YYq\ xx%%eiinn&=&=&A&AUV%Xxx%%eiinn&=&=&A&AUV%Xhh$$UYY^^%7%7%?%?tTl$S88))%))..*;*;*A*AejjHY)Zhh,,UYY^^-E-E-M-MU_akTl,m hh$$UYY^^%9%9%>%>hP[]gEh$i j s#HH  j js G0I<<Jc|jtjjjj ury|j j|5|j jtjjjj |j|j}ddd|j|j j|y#1swY6xYw)z.Replace in-place triu_ with out-of-place triu.FrRNT)r?r!rKrLtriu_rNrBrTrUtriur'r+rFrCrWs rG_fix_triu_inplacerqs {{%))....666  " "4 (fhh$$UYY^^%8%8%@%@tyyY]YdYd$efs#HH  ffrZc|jtjjjj ury|j d}t|j dkDr|j dnd}t|j dkDr|j dnd}|jj|5|jjtjjjj|||f}ddd|j|jj|y#1swY6xYw) zMReplace aten.sort.stable with aten.sort.default (which has ONNX translation).Frr rrcNT)r?r!rKrLsortstabler'r rBrTrUrNrFrC)rGrHself_argr{ descendingrXs rG_fix_sort_stablerxs {{%))..--444yy|Hdii.1,$))A,"C!$TYY!!31J  " "4 (dhh$$UYY^^%8%8%@%@RUWaGb$cds#HH  dds 8A D::Ecl|jtjjjj uryt |jdks1t|jdtjjsy|jj|5|jjtjjjj|j}ddd|j|jj!|y#1swY6xYw)aRewrite remainder.Scalar to remainder.Tensor when the 'scalar' arg is actually a tensor. After decomposition the second operand of ``aten.remainder.Scalar`` can be a graph node (SymbolicTensor) rather than a Python scalar. The ONNX torchlib translation for ``remainder.Scalar`` calls ``int()`` on it and crashes. Rewriting to ``remainder.Tensor`` uses the two-tensor ONNX translation which handles this correctly. Fr r rcNT)r?r!rKrL remainderScalarr r'r1r:r;rBrTrUrfrFrCrWs rG_fix_remainder_scalarr|s {{%))..22999 499~DIIaL%((--!H  " "4 (Vhh$$UYY^^%=%=%D%D499$UVs#HH  VVs !AD**D3c|j7|j+t|jt|jkDryt|jt|jz }t|j|j|dD])\}} t|t|}}|dk7s#||k7s)yy#tt f$rYywxYw)uStatic-shape check: does ``values.shape`` broadcast against ``self.shape``? Returns ``True`` only when every dim of ``values`` is statically known and either equals the corresponding (right-aligned) dim of ``self`` or is ``1``. Used to dispatch `_aten_index_put` between the broadcast and flat-gather paths — bailing on dynamic / unknown dims keeps us on the safe flat-gather fallback. NFr T)rr r*rhr4 ValueError)rr?offsetv_dims_dims rG_values_broadcast_to_selfrs||tzz1S5FTZZ5X _s6<<0 0FFLL$**VW*=> u u:s5z5E A:%5.   :&  sCCCc*|d}|duxr3tt|ddddtjjk(}|st ||||St t |jt |jz D]-}tj|tjdg}/tj|tj|}t||r@tj|tj|}tj|||Stj|tjdg} tj | d} tj"| tjdg} tj$tj&| tjd gtjdg} tj|tjdg} tj(| | }tj|tjdg}tj| ||}tj|tj|S) uBool-mask index_put with two paths; delegates non-bool-mask cases to torchlib. For `self[bool_mask] = values`, PyTorch supports two distinct shapes for ``values``: 1. Broadcasts against ``self.shape`` (e.g. scalar `tensor[~mask] = 0`) — handled by `Expand(values, Shape(self)) + Where(mask, expanded, self)`. 2. Equals ``bool_mask.sum()`` along its first dim, with remaining dims matching ``self`` (e.g. `inputs_embeds[image_mask] = image_features_flat`) — handled by the flat cumulative-count-Gather + Where trick. Path 1 is correct only when broadcast-compatibility can be statically verified — for dynamic shapes we fall through to path 2, which is also torchlib's default behaviour. rNr3rdrrrgr )getattrrDataTyperrranger rop UnsqueezeConstantExpandShaperWhereReshapeCastCumSumClipSubGather)r?rr accumulate bool_maskis_bool_ expanded_maskexpanded_valuesr# flat_mask_intcsr$ flat_valuesr% flat_selfrs rG_aten_index_putrs$ Is'')VT*JGUY"Z^e^n^n^s^s"s  dGVZ@@ 3tzz?S%99 :JLLBKKB4,HI JIIi$8M .))FBHHTN;xx == ="++"*FGIGGI!,M ="++!"= >Br2;;1##>?YZX[A\]I**VR[[RD%ABKyyi0H 4!=>I XXi9 5F ::fbhhtn --rPctjdg}tjtj|dtjdg}tj||}|dkDr+tj |tj|g}tj ||tjddgd}tj|tjdgdS)aONNX implementation of `torch.bincount`: count occurrences of non-negative ints. No native ONNX op. We use `OneHot(self, depth=max+1, values=[0,1])` then `ReduceSum` along the input axis. Weights are unused (splinter's only caller passes none). r rr)keepdimsraxis)rrr ReduceMaxAddMaxOneHot ReduceSum)r?weights minlengthonerdepthone_hots rG_aten_bincountrs ++! %Cll2<<q92;;STRU;VWG FF7C E1}ubkki[ABiieR[[QF%C"MG <<! gs #G =J 2777q12;;2$3OPA2;;1##>JJzz"''$ 3R[[RD5QRRDJJIY)+G <<bkkgk]C DD'3y1}%$gk[[E2 JJrwww1-r{{rd/K LYY KKA3'A+#6 7 KKA3)g*=*A#B C  GGD* %E)) QG, t$ Wq[)  K ::e[ ))rPc Ltjtjtjtj|tj|tj tj ||tjjj}t|dr|jjn|jj}tjtj||tj ||S)u2Correct floor division (toward -inf) for signed integer SymInts. Torchlib's `operator_floordiv` translation only handles positive operands (plain `Div`, which truncates). For signed ints — including SymInt shape arithmetic — apply the offset correction `floor(a/b) = trunc(a/b) - (sign(a) != sign(b) AND a mod b != 0)`, matching `aten_floor_divide`. Without this, the Python ceil-div idiom `-(-x // y)` produces `1 + trunc((y - 1 - x) / y)` instead of `ceil(x / y)`, which silently breaks any shape arithmetic that crosses zero. rrd)rAndNotEqualSignrModrrrrhasattrrdrDiv)r?otherrrds rG_operator_floordivr\sVV rxx rwwu~67 tU#(8(8(=(=(C(CDF!(g 6DJJ  EKK None` IR fix to the main graph and every function.N)r@rB functionsr _IR_FIXES)rEgraphsfixrBs rGr>r>sU  && O););)E)E)L)L)N OF E J rP)rB list[str]rCrrHztuple[list[str], list[str]])rstr)rGztorch.fx.GraphModulerHz torch.fx.NoderHrj)rrr?rrHrj)F) r?rrzSequence[INT64 | BOOL | None]rrrrjrHrr)r?rrrhrHrrq)rrrrrrrHr)rz onnx_ir.GraphrHNone)rErrHr)~rL __future__rr;rZoperatorcollections.abcrr contextlibrtypingrrrrutilsr utils.import_utilsr r configsrexporter_dynamorrrrrrrr! torch.exportr torch.onnxrrr+onnxscript.function_libs.torch_lib.ops.coreronnxscript.onnx_opsetrrmodeling_utilsrrrr get_logger__file__loggerr r5r8rsr|rrrrrrrrrrrr rrrr&r2r7 frozensetleltgegteqner@rIrPrYr^r]r`updaterKrL _assert_asyncrNmsg_assert_scalar_assert_tensor_metadatasym_constrain_range_for_sizerarmrqrxr|rrrrrrrr=__annotations__bincountr] _grouped_mm transformersgrouped_mm_fallbackrepeat_interleaveself_int masked_fillr{rffloordivrrr>r&rPrGr"s .# 4%%L+,& J30 RR   H %0>0n))0'  &'()+CD E IJ K  23 4 ()* &':NOP&,(=>9?9(=>9?9 %78 9 )*+")*+",-.* % & +, - *+ ,  56 7  %&NbcdBX[[(++x{{HKKQYQ\Q\^f^i^ijkf8fff IINN ( ( 0 0 IINN ( ( , , IINN ) ) 1 1 IINN 2 2 : : IINN 7 7 ? ?  ff&ff  f22 &. &. *&. &. &.  &.R J'D(*VB$,"+-,"" IINN # # + +^ IINN $ $ , ,o IINN & & . .0@ II " " 6 6 > >@P IINN , , 5 57W IINN & & - -/@ IINN & & - -/@   1  4`  rP