+ jT^RIt^RIHuHt^RIHt^RIHtH t .ROt !R R ] 4t !R R] 4t !R R]] 4t !RR] 4t!RR]] 4t!RR] 4t!RR ]] 4tR#)NTensor) _LazyNormBase _NormBaseInstanceNorm1dInstanceNorm2dInstanceNorm3dLazyInstanceNorm1dLazyInstanceNorm2dLazyInstanceNorm3dcaa]tRt^toRRR/V3RlV3RlllltRtRtRtRtV3R lV3R llt V3R lR lt R t Vt V;t #) _InstanceNormbiasTcB<V^8dQhRS[RS[RS[RS[RS[RS[RR/#)  num_featuresepsmomentumaffinetrack_running_statsrreturnN)intfloatbool)format __classdict__s"^/home/luca/screen-checking/.venv/lib/python3.14/site-packages/torch/nn/modules/instancenorm.py __annotate___InstanceNorm.__annotate__sQ        "     cF<RVRV/p \S V`!VVVVV3/V BRV/BR#)devicedtyperN)super__init__) selfrrrrrr"r#rfactory_kwargs __class__s &&&&&&&&$ rr%_InstanceNorm.__init__sC#FGU;           r c\hNNotImplementedErrorr&inputs&&r_check_input_dim_InstanceNorm._check_input_dim-!!r c\hr+r,r&s&r_get_no_batch_dim_InstanceNorm._get_no_batch_dim0r2r c`VPVP^44P^4#)r)_apply_instance_norm unsqueezesqueezer.s&&r_handle_no_batch_input$_InstanceNorm._handle_no_batch_input3s'(();<DDQGGr c 8\P!TVPVPVPVP VP ;'gVP'*VPeVPVP4#RVP4#)Ng) F instance_norm running_mean running_varweightrtrainingrrrr.s&&rr8"_InstanceNorm._apply_instance_norm6s|        KK II MM 9 9!9!99!]]6DMM HH  =@ HH  r c<V^8dQhRR/#rrN)rrs"rrrBs, ,  , r c <VPRR4pVfVP'g.p RF$p W*,p W9gKV PV 4K& \V 4^8dgVPRP RP RV 44VP PR74V Fp VPV 4K \S V`)VVVVVVV4R#)versionNaUnexpected running stats buffer(s) {names} for {klass} with track_running_stats=False. If state_dict is a checkpoint saved before 0.4.0, this may be expected because {klass} does not track running stats by default since 0.4.0. Please remove these keys from state_dict. If the running stats are actually needed, instead set track_running_stats=True in {klass} to enable them. See the documentation of {klass} for details.z and c3."TF pRV R2xK R#5i)"NrG).0ks& r 6_InstanceNorm._load_from_state_dict.._s*P=OQqc8=Os)namesklass)r@rA) getrappendlenrjoinr(__name__popr$_load_from_state_dict) r& state_dictprefixlocal_metadatastrict missing_keysunexpected_keys error_msgsrIrunning_stats_keysnamekeyr(s &&&&&&&& rrX#_InstanceNorm._load_from_state_dictBs!$$Y5 ?4#;#;#;!# 7m$&--c28%&*!!@AG%ll*P=O*PP"nn55AGA .CNN3'. %        r c&<V^8dQhRS[RS[/#)rr/rr)rrs"rrrps00V00r c VPV4VP4VP4, pVPV4VP8wd]VP 'd/\ RV RVP RVPV4 R24h\P!RV R2^R7VP4VP48XdVPV4#VPV4#)zexpected input's size at dim=z to match num_features (z ), but got: .zinput's size at dim=z does not match num_features. You can silence this warning by not passing in num_features, which is not used because affine=False) stacklevel) r0dimr5sizerr ValueErrorwarningswarnr;r8)r&r/ feature_dims&& rforward_InstanceNorm.forwardps e$iikD$:$:$<< ::k "d&7&7 7{{{ 3K=A**+< ;8O7PPQS  *;-8== !  99;$002 2..u5 5((//r rG)gh㈵>g?FFNN)rV __module__ __qualname____firstlineno__r%r0r5r;r8rXrn__static_attributes____classdictcell__ __classcell__)r(rs@@rrrsH   .""H  , , \000r rcHa]tRt^toRtV3RlRltV3RlRltRtVtR#)ra Applies Instance Normalization. This operation applies Instance Normalization over a 2D (unbatched) or 3D (batched) input as described in the paper `Instance Normalization: The Missing Ingredient for Fast Stylization `__. .. math:: y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta The mean and standard-deviation are calculated per-dimension separately for each object in a mini-batch. :math:`\gamma` and :math:`\beta` are learnable parameter vectors of size `C` (where `C` is the number of features or channels of the input) if :attr:`affine` is ``True``. The variance is calculated via the biased estimator, equivalent to `torch.var(input, correction=0)`. By default, this layer uses instance statistics computed from input data in both training and evaluation modes. If :attr:`track_running_stats` is set to ``True``, during training this layer keeps running estimates of its computed mean and variance, which are then used for normalization during evaluation. The running estimates are kept with a default :attr:`momentum` of 0.1. .. note:: This :attr:`momentum` argument is different from one used in optimizer classes and the conventional notion of momentum. Mathematically, the update rule for running statistics here is :math:`\hat{x}_\text{new} = (1 - \text{momentum}) \times \hat{x} + \text{momentum} \times x_t`, where :math:`\hat{x}` is the estimated statistic and :math:`x_t` is the new observed value. .. note:: :class:`InstanceNorm1d` and :class:`LayerNorm` are very similar, but have some subtle differences. :class:`InstanceNorm1d` is applied on each channel of channeled data like multidimensional time series, but :class:`LayerNorm` is usually applied on entire sample and often in NLP tasks. Additionally, :class:`LayerNorm` applies elementwise affine transform, while :class:`InstanceNorm1d` usually doesn't apply affine transform. Args: num_features: number of features or channels :math:`C` of the input eps: a value added to the denominator for numerical stability. Default: 1e-5 momentum: the value used for the running_mean and running_var computation. Default: 0.1 affine: a boolean value that when set to ``True``, this module has learnable affine parameters, initialized the same way as done for batch normalization. Default: ``False`` track_running_stats: a boolean value that when set to ``True``, this module tracks the running mean and variance, and when set to ``False``, this module does not track such statistics and always uses batch statistics in both training and eval modes. Default: ``False`` bias: If set to ``False``, the layer will not learn an additive bias (only relevant if :attr:`affine` is ``True``). Default: ``True`` Shape: - Input: :math:`(N, C, L)` or :math:`(C, L)` - Output: :math:`(N, C, L)` or :math:`(C, L)` (same shape as input) Examples:: >>> # Without Learnable Parameters >>> m = nn.InstanceNorm1d(100) >>> # With Learnable Parameters >>> m = nn.InstanceNorm1d(100, affine=True) >>> input = torch.randn(20, 100, 40) >>> output = m(input) c <V^8dQhRS[/#rrr)rrs"rrInstanceNorm1d.__annotate__3r c^#rrGr4s&rr5 InstanceNorm1d._get_no_batch_dimr c<V^8dQhRR/#rFrG)rrs"rrrzTTTr cjVP4R9d\RVP4 R24hR#rzexpected 2D or 3D input (got D input)N)rrhrjr.s&&rr0InstanceNorm1d._check_input_dim0 99;f $`__. .. math:: y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta The mean and standard-deviation are calculated per-dimension separately for each object in a mini-batch. :math:`\gamma` and :math:`\beta` are learnable parameter vectors of size `C` (where `C` is the input size) if :attr:`affine` is ``True``. The standard-deviation is calculated via the biased estimator, equivalent to `torch.var(input, correction=0)`. By default, this layer uses instance statistics computed from input data in both training and evaluation modes. If :attr:`track_running_stats` is set to ``True``, during training this layer keeps running estimates of its computed mean and variance, which are then used for normalization during evaluation. The running estimates are kept with a default :attr:`momentum` of 0.1. .. note:: This :attr:`momentum` argument is different from one used in optimizer classes and the conventional notion of momentum. Mathematically, the update rule for running statistics here is :math:`\hat{x}_\text{new} = (1 - \text{momentum}) \times \hat{x} + \text{momentum} \times x_t`, where :math:`\hat{x}` is the estimated statistic and :math:`x_t` is the new observed value. .. note:: :class:`InstanceNorm2d` and :class:`LayerNorm` are very similar, but have some subtle differences. :class:`InstanceNorm2d` is applied on each channel of channeled data like RGB images, but :class:`LayerNorm` is usually applied on entire sample and often in NLP tasks. Additionally, :class:`LayerNorm` applies elementwise affine transform, while :class:`InstanceNorm2d` usually doesn't apply affine transform. Args: num_features: :math:`C` from an expected input of size :math:`(N, C, H, W)` or :math:`(C, H, W)` eps: a value added to the denominator for numerical stability. Default: 1e-5 momentum: the value used for the running_mean and running_var computation. Default: 0.1 affine: a boolean value that when set to ``True``, this module has learnable affine parameters, initialized the same way as done for batch normalization. Default: ``False`` track_running_stats: a boolean value that when set to ``True``, this module tracks the running mean and variance, and when set to ``False``, this module does not track such statistics and always uses batch statistics in both training and eval modes. Default: ``False`` bias: If set to ``False``, the layer will not learn an additive bias (only relevant if :attr:`affine` is ``True``). Default: ``True`` Shape: - Input: :math:`(N, C, H, W)` or :math:`(C, H, W)` - Output: :math:`(N, C, H, W)` or :math:`(C, H, W)` (same shape as input) Examples:: >>> # Without Learnable Parameters >>> m = nn.InstanceNorm2d(100) >>> # With Learnable Parameters >>> m = nn.InstanceNorm2d(100, affine=True) >>> input = torch.randn(20, 100, 35, 45) >>> output = m(input) c <V^8dQhRS[/#rxry)rrs"rrInstanceNorm2d.__annotate__Gr{r c^#rrGr4s&rr5 InstanceNorm2d._get_no_batch_dimGrr c<V^8dQhRR/#rFrG)rrs"rrrJrr cjVP4R9d\RVP4 R24hR#rzexpected 3D or 4D input (got rN)rrr.s&&rr0InstanceNorm2d._check_input_dimJrr rGNrrs@rrrs"FPTTr cLa]tRtRtoRt]tV3RlRltV3RlRltRt Vt R#) r iOaA :class:`torch.nn.InstanceNorm2d` module with lazy initialization of the ``num_features`` argument. The ``num_features`` argument of the :class:`InstanceNorm2d` is inferred from the ``input.size(1)``. The attributes that will be lazily initialized are `weight`, `bias`, `running_mean` and `running_var`. Check the :class:`torch.nn.modules.lazy.LazyModuleMixin` for further documentation on lazy modules and their limitations. Args: num_features: :math:`C` from an expected input of size :math:`(N, C, H, W)` or :math:`(C, H, W)` eps: a value added to the denominator for numerical stability. Default: 1e-5 momentum: the value used for the running_mean and running_var computation. Default: 0.1 affine: a boolean value that when set to ``True``, this module has learnable affine parameters, initialized the same way as done for batch normalization. Default: ``False`` track_running_stats: a boolean value that when set to ``True``, this module tracks the running mean and variance, and when set to ``False``, this module does not track such statistics and always uses batch statistics in both training and eval modes. Default: ``False`` bias: If set to ``False``, the layer will not learn an additive bias (only relevant if :attr:`affine` is ``True``). Default: ``True`` Shape: - Input: :math:`(N, C, H, W)` or :math:`(C, H, W)` - Output: :math:`(N, C, H, W)` or :math:`(C, H, W)` (same shape as input) c <V^8dQhRS[/#rxry)rrs"rrLazyInstanceNorm2d.__annotate__or{r c^#rrGr4s&rr5$LazyInstanceNorm2d._get_no_batch_dimorr c<V^8dQhRR/#rFrG)rrs"rrrrrr cjVP4R9d\RVP4 R24hR#rrr.s&&rr0#LazyInstanceNorm2d._check_input_dimrrr rGN) rVrprqrrrrrr5r0rsrtrs@rr r O':#MTTr cHa]tRtRtoRtV3RlRltV3RlRltRtVtR#) r iwa Applies Instance Normalization. This operation applies Instance Normalization over a 5D input (a mini-batch of 3D inputs with additional channel dimension) as described in the paper `Instance Normalization: The Missing Ingredient for Fast Stylization `__. .. math:: y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta The mean and standard-deviation are calculated per-dimension separately for each object in a mini-batch. :math:`\gamma` and :math:`\beta` are learnable parameter vectors of size C (where C is the input size) if :attr:`affine` is ``True``. The standard-deviation is calculated via the biased estimator, equivalent to `torch.var(input, correction=0)`. By default, this layer uses instance statistics computed from input data in both training and evaluation modes. If :attr:`track_running_stats` is set to ``True``, during training this layer keeps running estimates of its computed mean and variance, which are then used for normalization during evaluation. The running estimates are kept with a default :attr:`momentum` of 0.1. .. note:: This :attr:`momentum` argument is different from one used in optimizer classes and the conventional notion of momentum. Mathematically, the update rule for running statistics here is :math:`\hat{x}_\text{new} = (1 - \text{momentum}) \times \hat{x} + \text{momentum} \times x_t`, where :math:`\hat{x}` is the estimated statistic and :math:`x_t` is the new observed value. .. note:: :class:`InstanceNorm3d` and :class:`LayerNorm` are very similar, but have some subtle differences. :class:`InstanceNorm3d` is applied on each channel of channeled data like 3D models with RGB color, but :class:`LayerNorm` is usually applied on entire sample and often in NLP tasks. Additionally, :class:`LayerNorm` applies elementwise affine transform, while :class:`InstanceNorm3d` usually doesn't apply affine transform. Args: num_features: :math:`C` from an expected input of size :math:`(N, C, D, H, W)` or :math:`(C, D, H, W)` eps: a value added to the denominator for numerical stability. Default: 1e-5 momentum: the value used for the running_mean and running_var computation. Default: 0.1 affine: a boolean value that when set to ``True``, this module has learnable affine parameters, initialized the same way as done for batch normalization. Default: ``False`` track_running_stats: a boolean value that when set to ``True``, this module tracks the running mean and variance, and when set to ``False``, this module does not track such statistics and always uses batch statistics in both training and eval modes. Default: ``False`` bias: If set to ``False``, the layer will not learn an additive bias (only relevant if :attr:`affine` is ``True``). Default: ``True`` Shape: - Input: :math:`(N, C, D, H, W)` or :math:`(C, D, H, W)` - Output: :math:`(N, C, D, H, W)` or :math:`(C, D, H, W)` (same shape as input) Examples:: >>> # Without Learnable Parameters >>> m = nn.InstanceNorm3d(100) >>> # With Learnable Parameters >>> m = nn.InstanceNorm3d(100, affine=True) >>> input = torch.randn(20, 100, 35, 45, 10) >>> output = m(input) c <V^8dQhRS[/#rxry)rrs"rrInstanceNorm3d.__annotate__r{r c^#rrGr4s&rr5 InstanceNorm3d._get_no_batch_dimrr c<V^8dQhRR/#rFrG)rrs"rrrrr cjVP4R9d\RVP4 R24hR#rzexpected 4D or 5D input (got rN)rrr.s&&rr0InstanceNorm3d._check_input_dimrr rGNrrs@rr r ws"ENTTr cLa]tRtRtoRt]tV3RlRltV3RlRltRt Vt R#) r iaA :class:`torch.nn.InstanceNorm3d` module with lazy initialization of the ``num_features`` argument. The ``num_features`` argument of the :class:`InstanceNorm3d` is inferred from the ``input.size(1)``. The attributes that will be lazily initialized are `weight`, `bias`, `running_mean` and `running_var`. Check the :class:`torch.nn.modules.lazy.LazyModuleMixin` for further documentation on lazy modules and their limitations. Args: num_features: :math:`C` from an expected input of size :math:`(N, C, D, H, W)` or :math:`(C, D, H, W)` eps: a value added to the denominator for numerical stability. Default: 1e-5 momentum: the value used for the running_mean and running_var computation. Default: 0.1 affine: a boolean value that when set to ``True``, this module has learnable affine parameters, initialized the same way as done for batch normalization. Default: ``False`` track_running_stats: a boolean value that when set to ``True``, this module tracks the running mean and variance, and when set to ``False``, this module does not track such statistics and always uses batch statistics in both training and eval modes. Default: ``False`` bias: If set to ``False``, the layer will not learn an additive bias (only relevant if :attr:`affine` is ``True``). Default: ``True`` Shape: - Input: :math:`(N, C, D, H, W)` or :math:`(C, D, H, W)` - Output: :math:`(N, C, D, H, W)` or :math:`(C, D, H, W)` (same shape as input) c <V^8dQhRS[/#rxry)rrs"rrLazyInstanceNorm3d.__annotate__r{r c^#rrGr4s&rr5$LazyInstanceNorm3d._get_no_batch_dimrr c<V^8dQhRR/#rFrG)rrs"rrrrr cjVP4R9d\RVP4 R24hR#rrr.s&&rr0#LazyInstanceNorm3d._check_input_dimrr rGN) rVrprqrrrr rr5r0rsrtrs@rr r rr )rrr r r r )rktorch.nn.functionalnn functionalr>torchr batchnormrr__all__rrr rr r r rGr rrs/ p0Ip0fLT]LT^$T $TNNT]NTb%T %TPMT]MT`%T %Tr