6bij1SrSSKrSSKJs Jr SSKJr SSKJ r SSK J r SSK J r SSKJr SSKJr \"S 5"S S \ \R$S 95rS rg)zEContains the base ProcessingLayer and a subclass that uses Combiners.N) data_adapter)Layer) version_utils)context) keras_export) doc_controlsz:keras.layers.experimental.preprocessing.PreprocessingLayerc<^\rSrSrSrSrU4Sjr\S5r\ RS5r \ RS5r \ RS5r \ RS 5rSS jrSS jrS r\R&R(R*S 5rSrSrU=r$)PreprocessingLayera'Base class for Preprocessing Layers. **Don't use this class directly: it's an abstract base class!** You may be looking for one of the many built-in [preprocessing layers](https://keras.io/guides/preprocessing_layers/) instead. Preprocessing layers are layers whose state gets computed before model training starts. They do not get updated during training. Most preprocessing layers implement an `adapt()` method for state computation. The `PreprocessingLayer` class is the base class you would subclass to implement your own preprocessing layers. Tc >[TU]"S0UD6 SUlSUlURUlUR UlSUlg)NF)super__init__ _is_compiled _is_adapted reset_state_reset_state_impl_reset_state_wrapper_adapt_function)selfkwargs __class__s f/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/engine/base_preprocessing_layer.pyrPreprocessingLayer.__init__2sI "6"! "&!1!144#cUR$)z/Whether the layer has been fit to data already.)rrs r is_adaptedPreprocessingLayer.is_adapted=src[e)zmAccumulates statistics for the preprocessing layer. Arguments: data: A mini-batch of inputs to the layer. NotImplementedError)rdatas r update_statePreprocessingLayer.update_stateBs "!rc[e)z1Resets the statistics of the preprocessing layer.r!rs rrPreprocessingLayer.reset_stateKs "!rcg)a Finalize the statistics for the preprocessing layer. This method is called at the end of `adapt` or after restoring a serialized preprocessing layer's state. This method handles any one-time operations that should occur on the layer's state before `Layer.__call__`. Nr rs rfinalize_state!PreprocessingLayer.finalize_statePs rc$^^TRb TR$U4SjmTRR5R5S:XaTnOUU4SjnTR(d[ R "U5nUTlTR$)aeCreates a function to execute one step of `adapt`. This method can be overridden to support custom adapt logic. This method is called by `PreprocessingLayer.adapt`. Typically, this method directly controls `tf.function` settings, and delegates the actual state update logic to `PreprocessingLayer.update_state`. This function is cached the first time `PreprocessingLayer.adapt` is called. The cache is cleared whenever `PreprocessingLayer.compile` is called. Returns: Function. The function created by this method should accept a `tf.data.Iterator`, retrieve a batch, and update the state of the layer. c`>[U5nTRU5 TRU5 gN)next_adapt_maybe_buildr$)iteratorr#rs r adapt_step:PreprocessingLayer.make_adapt_function..adapt_steprs(>D  # #D )   d #rcd>[R"TR5H nT"U5 M gr-)tfrange_steps_per_execution)r0_r1rs radapt_fn8PreprocessingLayer.make_adapt_function..adapt_fn{s$$";"; SSS5 Mp UR'5 SUlg!,(df  M=f)a Fits the state of the preprocessing layer to the data being passed. After calling `adapt` on a layer, a preprocessing layer's state will not update during training. In order to make preprocessing layers efficient in any distribution context, they are kept constant with respect to any compiled `tf.Graph`s that call the layer. This does not affect the layer use when adapting each layer only once, but if you adapt a layer multiple times you will need to take care to re-compile any compiled functions as follows: * If you are adding a preprocessing layer to a `keras.Model`, you need to call `model.compile` after each subsequent call to `adapt`. * If you are calling a preprocessing layer inside `tf.data.Dataset.map`, you should call `map` again on the input `tf.data.Dataset` after each `adapt`. * If you are using a `tf.function` directly which calls a preprocessing layer, you need to call `tf.function` again on your callable after each subsequent call to `adapt`. `tf.keras.Model` example with multiple adapts: >>> layer = tf.keras.layers.Normalization( ... axis=None) >>> layer.adapt([0, 2]) >>> model = tf.keras.Sequential(layer) >>> model.predict([0, 1, 2]) array([-1., 0., 1.], dtype=float32) >>> layer.adapt([-1, 1]) >>> model.compile() # This is needed to re-compile model.predict! >>> model.predict([0, 1, 2]) array([0., 1., 2.], dtype=float32) `tf.data.Dataset` example with multiple adapts: >>> layer = tf.keras.layers.Normalization( ... axis=None) >>> layer.adapt([0, 2]) >>> input_ds = tf.data.Dataset.range(3) >>> normalized_ds = input_ds.map(layer) >>> list(normalized_ds.as_numpy_iterator()) [array([-1.], dtype=float32), array([0.], dtype=float32), array([1.], dtype=float32)] >>> layer.adapt([-1, 1]) >>> normalized_ds = input_ds.map(layer) # Re-map over the input dataset. >>> list(normalized_ds.as_numpy_iterator()) [array([0.], dtype=float32), array([1.], dtype=float32), array([2.], dtype=float32)] `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. adaptz+`adapt` is only supported in tensorflow v2.r3F) batch_sizesteps_per_epochepochsrE distributeNT)_disallow_inside_tf_functionr should_use_v2 RuntimeErrorrrFbuiltrr DataHandlerr7r?renumerate_epochscatch_stop_iterationsteps should_syncr async_waitr)r)rr#rJrU data_handlerr8r0s rrIPreprocessingLayer.adapts Z %W-**,,LM M  LLN ::    #// !! $ 9 9   $779'88:KA224%++-A((2#///**,.54;  54s4EE E c2UR5 SUlg)z2Calls `reset_state` and sets `adapted` to `False`.FN)rrrs rr'PreprocessingLayer._reset_state_wrappers   rcj[R"US[RRS9Ulg)Nint64)dtype aggregation)r5VariableVariableAggregationONLY_FIRST_REPLICAr7)rrEs rrB1PreprocessingLayer._configure_steps_per_executions($&KK ..AA% !rc UR(d^URn[S/[UR5-5n[ USS5nUcX0lURU5 SUlgg![a SnSnN@f=f)N_batch_input_shapeT)rQshapetuplelenAttributeErrorgetattrrebuild)rr# data_shapedata_shape_nonesbatch_input_shapes rr/%PreprocessingLayer._adapt_maybe_buildszz ("ZZ #($#djj/)A#B !(.BD I  (*:' JJz "DJ# " (! #'  (s.A11BB) rrerrrr=r7rQr)NN)__name__ __module__ __qualname____firstlineno____doc___must_restore_from_configrpropertyrrdo_not_generate_docsr$rr)r?rFrIrr5 __internal__tracking no_automatic_dependency_trackingrBr/__static_attributes__ __classcell__)rs@rr r s !% $  &&"'"&&"'"&& ' &&'$''$R!.d L! __>> ? rr ) metaclasscl[R"5(aSRUS9n[U5eg)z1Disallow calling a method inside a `tf.function`.aDetected a call to `PreprocessingLayer.{method_name}` inside a `tf.function`. `PreprocessingLayer.{method_name} is a high-level endpoint that manages its own `tf.function`. Please move the call to `PreprocessingLayer.{method_name}` outside of all enclosing `tf.function`s. Note that you can call a `PreprocessingLayer` directly on `Tensor`s inside a `tf.function` like: `layer(x)`, or update its state like: `layer.update_state(x)`.) method_nameN)r5inside_functionformatrP)r error_msgs rrNrN%s<  A &[& ) 9%%r)rtabctensorflow.compat.v2compatv2r5tf_keras.src.enginertf_keras.src.engine.base_layerrtf_keras.src.utilsrtensorflow.python.eagerr tensorflow.python.util.tf_exportrtensorflow.tools.docsrABCMetar rNr rrrsYL !!,0,,9.JKB#++BLBJ &r