+ &j.^RIHt^RIHt^RIHt!RR]4t!RR]4t!RR ]4t !R R ]4t !R R ]4t R#))TupleN)Modulec^aa]tRt^ toRtRV3RlV3RllltRtV3RlRltRtVt V;t #) InstanceNormavApplies instance normalization [1] on the inputs. Computes .. math:: y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta, where :math:`\gamma` and :math:`\beta` are learned per feature dimension parameters initialized at 1 and 0 respectively. Both are of size :attr:`dims`, if :attr:`affine` is ``True``. Args: dims (int): The number of features of the input. eps (float): A value added to the denominator for numerical stability. Default: ``1e-5``. affine (bool): Default: ``False``. Shape: - Input: :math:`(..., C)` where :math:`C` is equal to :attr:`dims`. - Output: Same shape as the input. Examples: >>> import mlx.core as mx >>> import mlx.nn as nn >>> x = mx.random.normal((8, 4, 4, 16)) >>> inorm = nn.InstanceNorm(dims=16) >>> output = inorm(x) References: [1]: https://arxiv.org/abs/1607.08022 c,<V^8dQhRS[RS[RS[/#)dimsepsaffineintfloatbool)format __classdict__s"s/Users/jameslopez/projects/CWCArchive/cwc-podcast/.venv/lib/python3.14/site-packages/mlx/nn/layers/normalization.py __annotate__InstanceNorm.__annotate__*s)     c<\SV`4V'd9\P!V34Vn\P !V34VnWnW nR#N) super__init__mxonesweightzerosbiasr r )selfr r r __class__s&&&&rrInstanceNorm.__init__*sA  ''4'*DK$)DI rcDVP RVP RRV9 2#, eps= , affine=rr r rs&r _extra_reprInstanceNorm._extra_repr7'))F488*Ih$6F5GHHrcN<V^8dQhRS[PRS[P/#rxreturnrarray)rrs"rrr:s'HH"((HrxxHrcn\\^VP^, 44p\P!WRR7p\P !WRR7pW, \P !W@P,4,pRV9d%VPV,VP,#T#)Taxiskeepdimsr) tuplerangendimrmeanvarrsqrtr rrrr-reduction_axesr9r:s&& r__call__InstanceNorm.__call__:syuQ 34wwq=ffQd; X#.1 108D0@ a$))+GaGrrr r r)h㈵>F __name__ __module__ __qualname____firstlineno____doc__rr(r>__static_attributes____classdictcell__ __classcell__r rs@@rrr s-@  IHHHrrcRaa]tRt^EtoRtRV3RlV3RllltRtRtRtVt V;t #) LayerNormaApplies layer normalization [1] on the inputs. Computes .. math:: y = \frac{x - E[x]}{\sqrt{Var[x]} + \epsilon} \gamma + \beta, where :math:`\gamma` and :math:`\beta` are learned per feature dimension parameters initialized at 1 and 0 respectively. [1]: https://arxiv.org/abs/1607.06450 Args: dims (int): The feature dimension of the input to normalize over eps (float): A small additive constant for numerical stability affine (bool): If True learn an affine transform to apply after the normalization bias (bool): If True include a translation to the affine transformation. If set to False the transformation is not really affine just scaling. c2<V^8dQhRS[RS[RS[RS[/#)rr r r rr )rrs"rrLayerNorm.__annotate__]s-   # 48 GK rc<\SV`4V'dA\P!V34VnV'd\P !V34VnW nWnR#r) rrrrrrrr r )rr r r rr s&&&&&rrLayerNorm.__init__]sD  ''4'*DKHHdW-  rcDVP RVP RRV9 2#r#r&r's&rr(LayerNorm._extra_reprhr*rcRV9d VPMRpRV9d VPMRp\PP WW0P 4#)rNr)rrrfast layer_normr )rr-rrs&& rr>LayerNorm.__call__ks@ (D 0d"dNtyyww!!!T88<RMSNorm.__call__s!ww>488<2 2 IIe )d )D )rcVP'd VPM VPpV!V4pRV9d%VPV,VP,#T#rb)rirvrzrr)rr- group_norms&& rr>GroupNorm.__call__sW&&&  / /!!  qM08D0@ a$))+GaGr)rr r rhrir)rATF) rCrDrErFrGrr(rvrzr>rHrIrJrKs@@rrfrfs/:55"  HHrrfc|aa]tRt^toRtR V3RlV3RllltV3RltRtV3RlRltV3RlR lt R t Vt V;t #) BatchNormaApplies Batch Normalization over a 2D or 3D input. Computes .. math:: y = \frac{x - E[x]}{\sqrt{Var[x]} + \epsilon} \gamma + \beta, where :math:`\gamma` and :math:`\beta` are learned per feature dimension parameters initialized at 1 and 0 respectively. The input shape is specified as ``NC`` or ``NLC``, where ``N`` is the batch, ``C`` is the number of features or channels, and ``L`` is the sequence length. The output has the same shape as the input. For four-dimensional arrays, the shape is ``NHWC``, where ``H`` and ``W`` are the height and width respectively. For more information on Batch Normalization, see the original paper `Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift `_. Args: num_features (int): The feature dimension to normalize over. eps (float, optional): A small additive constant for numerical stability. Default: ``1e-5``. momentum (float, optional): The momentum for updating the running mean and variance. Default: ``0.1``. affine (bool, optional): If ``True``, apply a learned affine transformation after the normalization. Default: ``True``. track_running_stats (bool, optional): If ``True``, track the running mean and variance. Default: ``True``. Examples: >>> import mlx.core as mx >>> import mlx.nn as nn >>> x = mx.random.normal((5, 4)) >>> bn = nn.BatchNorm(num_features=4, affine=True) >>> output = bn(x) c 8<V^8dQhRS[RS[RS[RS[RS[/#)r num_featuresr momentumr track_running_statsr )rrs"rrBatchNorm.__annotate__sDMMMM M  M " Mrc<\SV`4WnW nW0nWPnV'd9\ P!V34Vn\ P!V34Vn VP 'dP\ P!V34Vn \ P!V34Vn VPRR.RR7R#R#) running_mean running_varFkeysrecurseN)rrrr rrrrrrrrrfreeze)rrr rr rr s&&&&&&rrBatchNorm.__init__s ( #6 '' rcx<V^8dQhRS[PRS[S[PS[P3,/#r,)rr0r)rrs"rrr>s1RXX%"((0B*Crc \\^VP^, 44p\P!WR7p\P !WR7pW43#)z Calculate the mean and variance of the input tensor across the batch and spatial dimensions. Args: x (array): Input tensor. Returns: tuple: Tuple containing mean and variance. )r4)r6r7r8rr9r:r<s&& r _calc_statsBatchNorm._calc_stats>sAuQ 34wwq.ffQ,yrcN<V^8dQhRS[PRS[P/#r,r/)rrs"rrrPs'HH"((HrxxHrc VP^8gVP^8d\RVP 24hVPV4wr#VP'dxVP'dfVP p^V, VP ,WB,,Vn^V, VP,WC,,VnM*VP'dVP pVPpW, \P!W0P,4,pRV9d%VPV,VP,#T#)zo Forward pass of BatchNorm. Args: x (array): Input tensor. Returns: array: Normalized output tensor. zBatchNorm.__call__Ps 66A:!NqvvhW  $$Q'  ===T555B!"R4+<+< rHrIrJrKs@@rrrs>&PMM0I  $HHHrr) typingrmlx.corecorermlx.nn.layers.baserrrMrYrfrrrrsZ%9H69Hx)=)=X=f=B[H[H|{H{Hr