6bi/ASrSSKrSSKJs Jr SSKJr SSK J r SSK J r SSKJr \"SS5"S S \ R 55rg) z"Normalization preprocessing layer.N)backend)base_preprocessing_layer)preprocessing_utils) keras_exportzkeras.layers.Normalizationz5keras.layers.experimental.preprocessing.Normalizationc^\rSrSrSrSU4SjjrU4SjrSU4SjjrSrSr Sr S r S r S r U4S jrS rU4SjrSrU=r$) Normalizationa<A preprocessing layer which normalizes continuous features. This layer will shift and scale inputs into a distribution centered around 0 with standard deviation 1. It accomplishes this by precomputing the mean and variance of the data, and calling `(input - mean) / sqrt(var)` at runtime. The mean and variance values for the layer must be either supplied on construction or learned via `adapt()`. `adapt()` will compute the mean and variance of the data and store them as the layer's weights. `adapt()` should be called before `fit()`, `evaluate()`, or `predict()`. For an overview and full list of preprocessing layers, see the preprocessing [guide](https://www.tensorflow.org/guide/tf_keras/preprocessing_layers). Args: axis: Integer, tuple of integers, or None. The axis or axes that should have a separate mean and variance for each index in the shape. For example, if shape is `(None, 5)` and `axis=1`, the layer will track 5 separate mean and variance values for the last axis. If `axis` is set to `None`, the layer will normalize all elements in the input by a scalar mean and variance. When `-1` the last axis of the input is assumed to be a feature dimension and is normalized per index. Note that in the specific case of batched scalar inputs where the only axis is the batch axis, the default will normalize each index in the batch separately. In this case, consider passing `axis=None`. Defaults to `-1`. mean: The mean value(s) to use during normalization. The passed value(s) will be broadcast to the shape of the kept axes above; if the value(s) cannot be broadcast, an error will be raised when this layer's `build()` method is called. variance: The variance value(s) to use during normalization. The passed value(s) will be broadcast to the shape of the kept axes above; if the value(s) cannot be broadcast, an error will be raised when this layer's `build()` method is called. invert: If True, this layer will apply the inverse transformation to its inputs: it would turn a normalized input back into its original form. Examples: Calculate a global mean and variance by analyzing the dataset in `adapt()`. >>> adapt_data = np.array([1., 2., 3., 4., 5.], dtype='float32') >>> input_data = np.array([1., 2., 3.], dtype='float32') >>> layer = tf.keras.layers.Normalization(axis=None) >>> layer.adapt(adapt_data) >>> layer(input_data) Calculate a mean and variance for each index on the last axis. >>> adapt_data = np.array([[0., 7., 4.], ... [2., 9., 6.], ... [0., 7., 4.], ... [2., 9., 6.]], dtype='float32') >>> input_data = np.array([[0., 7., 4.]], dtype='float32') >>> layer = tf.keras.layers.Normalization(axis=-1) >>> layer.adapt(adapt_data) >>> layer(input_data) Pass the mean and variance directly. >>> input_data = np.array([[1.], [2.], [3.]], dtype='float32') >>> layer = tf.keras.layers.Normalization(mean=3., variance=2.) >>> layer(input_data) Use the layer to de-normalize inputs (after adapting the layer). >>> adapt_data = np.array([[0., 7., 4.], ... [2., 9., 6.], ... [0., 7., 4.], ... [2., 9., 6.]], dtype='float32') >>> input_data = np.array([[1., 2., 3.]], dtype='float32') >>> layer = tf.keras.layers.Normalization(axis=-1, invert=True) >>> layer.adapt(adapt_data) >>> layer(input_data) c >[TU]"S0UD6 UcSnO$[U[5(aU4nO [ U5nXl[U[ R5(a [S5e[U[ R5(a [S5eUSLUSL:wa[SRX#55eX l X0l X@l g)NzJNormalization does not support passing a Variable for the `mean` init arg.zNNormalization does not support passing a Variable for the `variance` init arg.zcWhen setting values directly, both `mean` and `variance` must be set. Got mean: {} and variance: {}) super__init__ isinstanceinttupleaxistfVariable ValueErrorformat input_meaninput_varianceinvert)selfrmeanvariancerkwargs __class__s i/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/layers/preprocessing/normalization.pyr Normalization.__init__zs "6" <D c " "7D;D  dBKK ( (+  h , ,/   ($"6 7==CV>  & c>^^[TU]T5 [T[[45(a"[ ST55(a [ S5e[R"T5R5m[T5m[U4SjUR55(a%[ SRTUR55e[URVs/sHo"S:aUOUT-PM sn5UlURH/nTUbM [ SRURTU55e [!T5Vs/sHo"UR;dMUPM snUl[!T5Vs/sHo"UR;aSOSPM snUl[!T5Vs/sHo"UR;aTUOSPM snUl[ U4SjUR55nUR(c{UR+S UUR,S S S 9UlUR+S UUR,SS S 9UlUR+SS[R2S S S 9UlUR75 gUR([8R:"U5-nUR<[8R:"U5-n[R>"X@R&5n[R>"XPR&5n[R@"X@R,5Ul![R@"XPR,5Ul"gs snfs snfs snfs snf)Nc3V# UHn[U[R5v M! g7fN)rr TensorShape).0shapes r &Normalization.build..s!: ;F%Jubnn - -;s')zNormalization only accepts a single input. If you are passing a python list or tuple as a single input, please convert to a numpy array or `tf.Tensor`.c3F># UHoT*:=(d UT:v M g7fr#r )r%andims rr'r(s!9y!D5y%AI%ys!zPAll `axis` values must be in the range [-ndim, ndim). Found ndim: `{}`, axis: {}rzqAll `axis` values to be kept must have known shape. Got axis: {}, input shape: {}, with unknown axis at index: {}c3.># UH nTUv M g7fr#r )r%d input_shapes rr'r(s"K?a;q>?srzerosF)namer&dtype initializer trainableronescountr )#r buildrlistrallrrr$as_listlenanyrrsorted _keep_axisrange _reduce_axis_reduce_axis_mask_broadcast_shaper add_weight compute_dtype adapt_meanadapt_varianceint64r6finalize_statenpr5rreshapecastrr)rr/r.mean_and_var_shaperrr+rs ` @rr7Normalization.builds  k" kD%= 1 1c: ;F: 7 7 B  nn[199; ; 9tyy9 9 9--3VD$))-D !TYY!OYAv!1t8";Y!OPA1~% FFLf ;G!).d P 17OQ P7[TU]XUS9 g)ajComputes the mean and variance of values in a dataset. Calling `adapt()` on a `Normalization` layer is an alternative to passing in `mean` and `variance` arguments during layer construction. A `Normalization` layer should always either be adapted over a dataset or passed `mean` and `variance`. During `adapt()`, the layer will compute a `mean` and `variance` separately for each position in each axis specified by the `axis` argument. To calculate a single `mean` and `variance` over the input data, simply pass `axis=None`. In order to make `Normalization` efficient in any distribution context, the computed mean and variance are kept static with respect to any compiled `tf.Graph`s that call the layer. As a consequence, if the layer is adapted a second time, any models using the layer should be re-compiled. For more information see `tf.keras.layers.experimental.preprocessing.PreprocessingLayer.adapt`. `adapt()` is meant only as a single machine utility to compute layer state. To analyze a dataset that cannot fit on a single machine, see [Tensorflow Transform]( https://www.tensorflow.org/tfx/transform/get_started) for a multi-machine, map-reduce solution. Arguments: data: The data to train on. It can be passed either as a `tf.data.Dataset`, or as a numpy array. batch_size: Integer or `None`. Number of samples per state update. If unspecified, `batch_size` will default to 32. Do not specify the `batch_size` if your data is in the form of datasets, generators, or `keras.utils.Sequence` instances (since they generate batches). steps: Integer or `None`. Total number of steps (batches of samples) When training with input tensors such as TensorFlow data tensors, the default `None` is equal to the number of samples in your dataset divided by the batch size, or 1 if that cannot be determined. If x is a `tf.data` dataset, and 'steps' is None, the epoch will run until the input dataset is exhausted. When passing an infinitely repeating dataset, you must specify the `steps` argument. This argument is not supported with array inputs. ) batch_sizestepsN)r adapt)rdatarOrPrs rrQNormalization.adapts\  d ?r c*URb/[SRURUR55eUR(d [ S5eUR U5n[R"XRR5n[RRXRS9up#[R"XRRS9nUR(a7[R "X@R5n[R""U5nOSnX`R-n[R"X`R$S9[R"XpR$S9- nSU- n URU -X(--n UR&URU - S--U -X2U - S--U--n URR)U 5 UR&R)U 5 URR)U5 g) NzCannot `adapt` a Normalization layer that is initialized with static `mean` and `variance`, you passed mean {} and variance {}.z-`build` must be called before `update_state`.)axes)out_typer,)r2g?)rrrrbuilt RuntimeError_standardize_inputsrrKrEr2nnmomentsr@r&r6gather reduce_prodrDrFassign) rrR batch_meanbatch_variance batch_shapebatch_reduce_shape batch_count total_count batch_weightexisting_weight total_meantotal_variances r update_stateNormalization.update_states ?? &66O>O]%P" hhtjj.>.>?   !#;8I8I!J ..);2 +&r cURcUR(dgURR[R "UR55 UR R[R"UR 55 URR[R "UR55 gr#) rrXrEr_r zeros_likerF ones_liker6rs r reset_stateNormalization.reset_stateJsv ?? &djj  r}}T__=> ""2<<0C0C#DE "-- 34r cURcUR(dg[R"URUR 5Ul[R"UR UR5Ul[R"URUR 5Ul [R"URUR5Ul gr#) rrXrrJrErBrrKrDrFrros rrHNormalization.finalize_stateRs ?? &djj JJt0E0EF GGDIIt'9'9:  4#6#68M8MN  t/A/AB r cURU5n[R"XR5nUR(aXUR U[R "[R"UR5[R"55--$XR - [R "[R"UR5[R"55- $r#) rZrrKrDrrmaximumsqrtrrepsilonrinputss rcallNormalization.call]s))&1!3!34 ;;99BGGDMM$:GOO[TU]5nURURUR[ R "UR5[ R "UR5S.5 U$)N)rrrr) r get_configupdaterrutilslistify_tensorsrr)rconfigrs rrNormalization.get_configqs\#%  ++--doo>!11$2E2EF    r c[R"U5nURUR:wa [R"XR5nU$r#)rconvert_to_tensorr2rDrKrxs rrZ!Normalization._standardize_inputs}s=%%f- <<4-- -WWV%7%78F r cD>[TU]U5 UR5 gr#)r load_own_variablesrH)rstorers rr Normalization.load_own_variabless "5) r ) rBr>r@rArErFrr6rrrrr)NNF)NN)__name__ __module__ __qualname____firstlineno____doc__r r7rQrjrprHrzr}rrrZr__static_attributes__ __classcell__)rs@rrrsX Vr9>"HMB`.@`*'X5 C   r r)rnumpyrItensorflow.compat.v2compatv2r tf_keras.srcrtf_keras.src.enginer!tf_keras.src.layers.preprocessingrr tensorflow.python.util.tf_exportrPreprocessingLayerrr r rrsS)!! 8J: ;e,??e er