6biE6SrSSKrSSKJs Jr SSKJr SSK J r SSK J r SSKJr SSKJr SSKJr SS KJr \ R,r\ R.r\ R0r\ R2rS rS rS rS rSr\"SS5"SS\ R>55r g)z)Keras discretization preprocessing layer.N)backend)base_preprocessing_layer)preprocessing_utils) layer_utils)tf_utils) tf_logging) keras_exportc[R"US/5n[R"U5n[R"[R"U5[R 5nSU- n[R"X#- [R 5nUn[R"US5nXSU2n[R"U5nU[R"U[R 5-n[R"Xx/5$)a!Reduce a 1D sequence of values to a summary. This algorithm is based on numpy.quantiles but modified to allow for intermediate steps between multiple data sets. It first finds the target number of bins as the reciprocal of epsilon and then takes the individual values spaced at appropriate intervals to arrive at that target. The final step is to return the corresponding counts between those values If the target num_bins is larger than the size of values, the whole array is returned (with weights of 1). Args: values: 1D `np.ndarray` to be summarized. epsilon: A `'float32'` that determines the approximate desired precision. Returns: A 2D `np.ndarray` that is a summary of the inputs. First column is the interpolated partition values, the second is the weights (counts). ?N) tfreshapesortcastsizefloat32int32maximum ones_likestack) valuesepsilonelements num_buckets incrementstartstep boundariesweightss j/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/layers/preprocessing/discretization.py summarizer"%s*ZZ %F WWV_Fwwrwwv 3H-K.9I E ::i #D t $Jll:&Gbjj11G 88Z) **cZ^[R"U4SjU/[R5$)aCompress a summary to within `epsilon` accuracy. The compression step is needed to keep the summary sizes small after merging, and also used to return the final target boundaries. It finds the new bins based on interpolating cumulative weight percentages from the large summary. Taking the difference of the cumulative weights from the previous bin's cumulative weight will give the new weight for that bin. Args: summary: 2D `np.ndarray` summary to be compressed. epsilon: A `'float32'` that determines the approxmiate desired precision. Returns: A 2D `np.ndarray` that is a compressed summary. First column is the interpolated partition values, the second is the weights (counts). c>[UT5$N)_compress_summary_numpy)srs r!compress..[s )!W5r#)rnumpy_functionr)summaryrs `r!compressr-Gs%&   5y"** r#cURSU-S:aU$U[R"SSU5-nUSR5nX3S- n[R"X$US5n[R"X$U5nU[R "[R "S/5USS45- n[R"XV45nUR[R5$)zCompress a summary with numpy.r gr r rN) shapenparangecumsuminterp concatenatearrayrastyper)r,rpercents cum_weightscum_weight_percentsnew_bins new_weightss r!r'r'_s}}Q'!A%3W55H!*##%K%B7yy CH))H;GK 1# CR()!Khh./G >>"** %%r#c[R"X4SS9n[R"U[R"US5SS9n[ X25$)aWeighted merge sort of summaries. Given two summaries of distinct data, this function merges (and compresses) them to stay within `epsilon` error tolerance. Args: prev_summary: 2D `np.ndarray` summary to be merged with `next_summary`. next_summary: 2D `np.ndarray` summary to be merged with `prev_summary`. epsilon: A float that determines the approxmiate desired precision. Returns: A 2-D `np.ndarray` that is a merged summary. First column is the interpolated partition values, the second is the weights (counts). r )axisr)rconcatgatherargsortr-) prev_summary next_summaryrmergeds r!merge_summariesrDpsAYY 3! >> input = np.array([[-1.5, 1.0, 3.4, .5], [0.0, 3.0, 1.3, 0.0]]) >>> layer = tf.keras.layers.Discretization(bin_boundaries=[0., 1., 2.]) >>> layer(input) Bucketize float values based on a number of buckets to compute. >>> input = np.array([[-1.5, 1.0, 3.4, .5], [0.0, 3.0, 1.3, 0.0]]) >>> layer = tf.keras.layers.Discretization(num_bins=4, epsilon=0.01) >>> layer.adapt(input) >>> layer(input) c >SU;aB[R"S5 [US[5(a UcUSnOUcUSnUS SU;dUSc3U[:Xa[ R O[R"5US'OAUS:Xa;[ R"US5R(d[ R US'[TU]0"S 0UD6 U[:XaB[ R"UR5R(dUSn[SU35e[R "U[["[$[&4UR(R*SS9 U(aU[:Xa[SUS U35eUb US :a[S R-U55eUbUb[S R-X!55e[.R0"U5nXlUbUO/UlX lX0lX@lXPlg)NbinszBbins is deprecated, please use bin_boundaries or num_bins instead.dtypeintzMWhen `output_mode='int'`, `dtype` should be an integer type. Received: dtype= output_mode)allowable_strings layer_namearg_namezi`sparse` may only be true if `output_mode` is `'one_hot'`, `'multi_hot'`, or `'count'`. Received: sparse=z and output_mode=rzG`num_bins` must be greater than or equal to 0. You passed `num_bins={}`zhBoth `num_bins` and `bin_boundaries` should not be set. You passed `num_bins={}` and `bin_boundaries={}`)loggingwarning isinstancerNINTrint64rfloatxas_dtype is_integersuper__init__ compute_dtype ValueErrorrvalidate_string_argONE_HOT MULTI_HOTCOUNT __class____name__formatutilslistify_tensorsinput_bin_boundariesbin_boundariesrFrrOsparse) selfrjrFrrOrkkwargs input_dtyperds r!r]Discretization.__init__s V  OOA &.#..83C!&>'!'v & F7O$;'3.GNN4D 7O 5 VG_)E)P)P!hhF7O "6" 3 KK 2 23>> /K))4 7  '' "GY>~~.."   kS($$*8,*m-   HqL++16(+;   N$>&&,fX&F  ..~>$2!,8Nb !  & r#c>[TU]U5 URbgURSS[R SSS9Ulg)Nr,)Nc ///$r&rSr/rMs r!r)&Discretization.build..0s .r#F)namer/rM initializer trainable)r\buildri add_weightrrr,)rl input_shaperds r!rxDiscretization.build$sL  k"  $ $ 0 **'   r#c">[TU]XUS9 g)aqComputes bin boundaries from quantiles in a input dataset. Calling `adapt()` on a `Discretization` layer is an alternative to passing in a `bin_boundaries` argument during construction. A `Discretization` layer should always be either adapted over a dataset or passed `bin_boundaries`. During `adapt()`, the layer will estimate the quantile boundaries of the input dataset. The number of quantiles can be controlled via the `num_bins` argument, and the error tolerance for quantile boundaries can be controlled via the `epsilon` argument. In order to make `Discretization` efficient in any distribution context, the computed boundaries 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)rldatar}r~rds r!rDiscretization.adapt8s\  d ?r#cURb$[SRUR55eUR(d [ S5e[ R "U5nUR[ R:wa%[ R"U[ R5n[XR5nURR[X RUR55 g)NzCannot adapt a Discretization layer that has been initialized with `bin_boundaries`, use `num_bins` instead. You passed `bin_boundaries={}`.z-`build` must be called before `update_state`.)rir_rfbuilt RuntimeErrorrconvert_to_tensorrMrrr"rr,assignrD)rlrr,s r! update_stateDiscretization.update_statehs  $ $ 0''-vd.G.G'H  zzNO O##D) :: #774,DD,,/  G\\4<< @ r#cURcUR(dg[R"[ UR UR 55Ulgr&)rirrgrhrGr,rFrjrls r!finalize_stateDiscretization.finalize_state{s>  $ $ 0 $33 t||T]] ; r#c|URcUR(dgURR///5 gr&)rirr,rrs r! reset_stateDiscretization.reset_states-  $ $ 0  RH%r#c>[TU]5nURURURUR UR URS.5 U$)N)rjrFrrOrk)r\ get_configupdaterirFrrOrk)rlconfigrds r!rDiscretization.get_configsO#% "&";"; MM<<#//++    r#cU$r&rS)rlrzs r!compute_output_shape#Discretization.compute_output_shapesr#c URURR55n[U[R 5(a[R "X R S9$[R"X R S9$)Nrs)rr/as_listrVrSparseTensorSpecr^ TensorSpec)rl input_spec output_shapes r!compute_output_signature'Discretization.compute_output_signaturesg001A1A1I1I1KL j""5"5 6 6&&"*<*< }}<7I7IJJr#c*^U4Sjn[R"U5(a [RR X!5nO[R "U5(ac[R "[R"UR5U"UR5[R"UR5S9nOU"U5n[R"UTR[TR5S-TR TR"S9$)NcT>[RRUTRS9$)N)inputr)rraw_ops Bucketizerj)inputsrls r! bucketize&Discretization.call..bucketizes*::'')<)<( r#)indicesr dense_shaper )rOdepthrkrM)r is_raggedrraggedmap_flat_values is_sparse SparseTensoridentityrrrrgencode_categorical_inputsrOlenrjrkr^)rlrrrs` r!callDiscretization.calls    f % %ii// BG    ' 'oo FNN3 /KK(:(:;G  'G.. ((d))*Q.;;$$   r#)rjrrirFrOrkr,)NNg{Gz?rNF)NN)re __module__ __qualname____firstlineno____doc__r]rxrrrrrrrr__static_attributes__ __classcell__)rds@r!rIrIsW AJ Rh (.@` & & K  r#rI)!rnumpyr0tensorflow.compat.v2compatv2r tf_keras.srcrtf_keras.src.enginer!tf_keras.src.layers.preprocessingrrgtf_keras.src.utilsrrtensorflow.python.platformrrT tensorflow.python.util.tf_exportr rWrbrarcr"r-r'rDrGPreprocessingLayerrIrSr#r!rs0!! 8J*'=9 ii OO -- +D0&"%(5!<m -@@m m r#