|hdZddlZddlZddlmcmZddlmZddl m Z ddl m Z ddl mZdZdZd ZeeegZed Gd d Zed dgGddeZeddgGddeZeddgGddeZeddgGddeZeddgGd d!eZed"d#gGd$d%eZed&d'gGd(d)eZed*d+gGd,d-eZed.d/gGd0d1eZed2d3gGd4d5eZed6d7gGd8d9eZed:d;gGd<d=eZed>d?gGd@dAeZ edBdCgGdDdEeZ!edFdGgGdHdIeZ"dJZ#dKZ$dLZ%dOdMZ&dNZ'y)PzKeras initializers.N)backend)utils)serialization_lib) keras_exportpartition_shapepartition_offsetlayoutzkeras.initializers.Initializerc4eZdZdZddZdZedZdZy) InitializeraInitializer base class: all TF-Keras initializers inherit from this class. Initializers should implement a `__call__()` method with the following signature: ```python def __call__(self, shape, dtype=None, **kwargs): # returns a tensor of shape `shape` and dtype `dtype` # containing values drawn from a distribution of your choice. return tf.random.uniform(shape=shape, dtype=dtype) ``` Optionally, you an also implement the method `get_config()` and the class method `from_config()` in order to support serialization -- just like with any TF-Keras object. Here's a simple example: a random normal initializer. ```python class ExampleRandomNormal(Initializer): def __init__(self, mean, stddev): self.mean = mean self.stddev = stddev def __call__(self, shape, dtype=None, **kwargs): return tf.random.normal( shape, mean=self.mean, stddev=self.stddev, dtype=dtype ) def get_config(self): # To support serialization return {"mean": self.mean, "stddev": self.stddev} ``` Note that we don't have to implement `from_config()` in the example above since the constructor arguments of the class the keys in the config returned by `get_config` are the same. In this case, the default `from_config()` works fine. Nc td)zReturns a tensor object initialized as specified by the initializer. Args: shape: Shape of the tensor. dtype: Optional dtype of the tensor. **kwargs: Additional keyword arguments. z>Initializer subclasses must implement the `__call__()` method.)NotImplementedError)selfshapedtypekwargss e/var/www/html/test/engine/venv/lib/python3.12/site-packages/tf_keras/src/initializers/initializers.py__call__zInitializer.__call__Ms" L  ciS)zReturns the initializer's configuration as a JSON-serializable dict. Returns: A JSON-serializable Python dict. rs r get_configzInitializer.get_configYs  rc6|jdd|di|S)aInstantiates an initializer from a configuration dictionary. Example: ```python initializer = RandomUniform(-1, 1) config = initializer.get_config() initializer = RandomUniform.from_config(config) ``` Args: config: A Python dictionary, the output of `get_config()`. Returns: An `Initializer` instance. rNr)popclsconfigs r from_configzInitializer.from_configas$  7D!}V}rct|ddr'>&?@//3DJrN) r& __module__ __qualname____doc__rr classmethodrr'rrrr r #s+&P  ( rr zkeras.initializers.Zeroszkeras.initializers.zeros)v1ceZdZdZddZy)ZerosaInitializer that generates tensors initialized to 0. Also available via the shortcut function `tf.keras.initializers.zeros`. Examples: >>> # Standalone usage: >>> initializer = tf.keras.initializers.Zeros() >>> values = initializer(shape=(2, 2)) >>> # Usage in a TF-Keras layer: >>> initializer = tf.keras.initializers.Zeros() >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Nc xt|jj|t|}|jr|t j k(rtd|dt|vr |t}|jdd}|r'tjt j|||St j||SaReturns a tensor object initialized as specified by the initializer. Args: shape: Shape of the tensor. dtype: Optional dtype of the tensor. Only numeric or boolean dtypes are supported. If not specified, `keras.backend.floatx()` is used, which defaults to `float32` unless you configured it otherwise (via `keras.backend.set_floatx(float_dtype)`). **kwargs: Additional keyword arguments. z'Expected numeric or boolean dtype, got .r Nrr) _validate_kwargsr%r& _get_dtypeis_numpy_compatibletfstring ValueError_PARTITION_SHAPErrcall_with_layoutzerosrrrrr s rrzZeros.__call__s 00&95!((ERYY,>FugQOP P v %+,EHd+ ))&U xxu%%rr(r&r)r*r+rrrrr/r/s  &rr/zkeras.initializers.Oneszkeras.initializers.onesceZdZdZddZy)OnesaInitializer that generates tensors initialized to 1. Also available via the shortcut function `tf.keras.initializers.ones`. Examples: >>> # Standalone usage: >>> initializer = tf.keras.initializers.Ones() >>> values = initializer(shape=(2, 2)) >>> # Usage in a TF-Keras layer: >>> initializer = tf.keras.initializers.Ones() >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Nc xt|jj|t|}|jr|t j k(rtd|dt|vr |t}|jdd}|r'tjt j|||St j||Sr1) r4r%r&r5r6r7r8r9r:rrr;onesr=s rrz Ones.__call__s 00&95!((ERYY,>FugQOP P v %+,EHd+ ))uE wwue$$rr(r>rrrr@r@s  %rr@zkeras.initializers.Constantzkeras.initializers.constantc6eZdZdZddZddZdZedZy) ConstantaInitializer that generates tensors with constant values. Also available via the shortcut function `tf.keras.initializers.constant`. Only scalar values are allowed. The constant value provided must be convertible to the dtype requested when calling the initializer. Examples: >>> # Standalone usage: >>> initializer = tf.keras.initializers.Constant(3.) >>> values = initializer(shape=(2, 2)) >>> # Usage in a TF-Keras layer: >>> initializer = tf.keras.initializers.Constant(3.) >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Args: value: A Python scalar. c||_yr(value)rrGs r__init__zConstant.__init__s  rNc \t|jj|t|}t|vr |t}|j dd}|r2t jtj||j||Stj|jt||S)aReturns a tensor object initialized to `self.value`. Args: shape: Shape of the tensor. dtype: Optional dtype of the tensor. If not specified, `keras.backend.floatx()` is used, which defaults to `float32` unless you configured it otherwise (via `keras.backend.set_floatx(float_dtype)`). **kwargs: Additional keyword arguments. r Nr3)rr) r4r%r&r5r:rrr;r7constantrGr=s rrzConstant.__call__s 00&95! v %+,EHd+ )) VTZZuE {{4::Z->eLLrcd|jiS)NrGrFrs rrzConstant.get_config s$$rc|jddd|vr.t|dtrtj|d|d<|di|S)NrrGr)r isinstancedictrdeserialize_keras_objectrs rrzConstant.from_configsO 7D! f &/40"3"L"L7O#w}V}r)rr() r&r)r*r+rHrrr,rrrrrDrDs+,M,%rrDz keras.initializers.RandomUniformz!keras.initializers.random_uniformc&eZdZdZddZddZdZy) RandomUniformaInitializer that generates tensors with a uniform distribution. Also available via the shortcut function `tf.keras.initializers.random_uniform`. Examples: >>> # Standalone usage: >>> initializer = tf.keras.initializers.RandomUniform(minval=0., maxval=1.) >>> values = initializer(shape=(2, 2)) >>> # Usage in a TF-Keras layer: >>> initializer = tf.keras.initializers.RandomUniform(minval=0., maxval=1.) >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Args: minval: A python scalar or a scalar tensor. Lower bound of the range of random values to generate (inclusive). maxval: A python scalar or a scalar tensor. Upper bound of the range of random values to generate (exclusive). seed: A Python integer. Used to make the behavior of the initializer deterministic. Note that a seeded initializer will produce the same random values across multiple calls. Ncf||_||_||_tj|d|_yN statelessrng_type)minvalmaxvalr!rRandomGenerator_random_generator)rrWrXr!s rrHzRandomUniform.__init__9s/   !(!8!8 ;" rc ^t|jj|t|}|js|j st d|dt|vr |t}|jtd}||j|r t|nd}|jdd}|rMttj|j j"|||j$|j&||S|j j#||j$|j&||S)aReturns a tensor object initialized as specified by the initializer. Args: shape: Shape of the tensor. dtype: Optional dtype of the tensor. Only floating point and integer types are supported. If not specified, `tf.keras.backend.floatx()` is used, which default to `float32` unless you configured it otherwise (via `tf.keras.backend.set_floatx(float_dtype)`). **kwargs: Additional keyword arguments. z%Expected float or integer dtype, got r2Nr )r4r%r&r5 is_floating is_integerr9r:get_PARTITION_OFFSETr'hashr_ensure_keras_seededrr;rZrandom_uniformrWrXrrrrrnoncer s rrzRandomUniform.__call__As 00&95!  )9)9DUG1MN N v %+,E!::&7>  #    *:%&Hd+  "))&&55   %%44 4;; UE  rcJ|j|j|jdS)NrWrXr!rfrs rrzRandomUniform.get_configis++diiPPr)g皙?Nr(r&r)r*r+rHrrrrrrQrQs 2 & PQrrQzkeras.initializers.RandomNormalz keras.initializers.random_normalc&eZdZdZddZddZdZy) RandomNormalaInitializer that generates tensors with a normal distribution. Also available via the shortcut function `tf.keras.initializers.random_normal`. Examples: >>> # Standalone usage: >>> initializer = tf.keras.initializers.RandomNormal(mean=0., stddev=1.) >>> values = initializer(shape=(2, 2)) >>> # Usage in a TF-Keras layer: >>> initializer = tf.keras.initializers.RandomNormal(mean=0., stddev=1.) >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Args: mean: a python scalar or a scalar tensor. Mean of the random values to generate. stddev: a python scalar or a scalar tensor. Standard deviation of the random values to generate. seed: A Python integer. Used to make the behavior of the initializer deterministic. Note that a seeded initializer will produce the same random values across multiple calls. Ncf||_||_||_tj|d|_yrSmeanstddevr!rrYrZrrmrnr!s rrHzRandomNormal.__init__/   !(!8!8 ;" rc "t|jj|tt |}t |vr |t }|j td}||j|r t|nd}|jdd}|rMttj|jj|||j |j"||S|jj||j |j"||S)aReturns a tensor object initialized to random normal values. Args: shape: Shape of the tensor. dtype: Optional dtype of the tensor. Only floating point types are supported. If not specified, `tf.keras.backend.floatx()` is used, which default to `float32` unless you configured it otherwise (via `tf.keras.backend.set_floatx(float_dtype)`) **kwargs: Additional keyword arguments. Nr )r4r%r&_assert_float_dtyper5r:r^r_r'r`rrarr;rZ random_normalrmrnrcs rrzRandomNormal.__call__s 00&9#Ju$56 v %+,E!::&7>  #    *:%&Hd+  "))&&44   %%33 499dkk5%  rcJ|j|j|jdSNrmrnr!rvrs rrzRandomNormal.get_config T[[$))LLrrgNr(rhrrrrjrjms2 # JMrrjz"keras.initializers.TruncatedNormalz#keras.initializers.truncated_normalc&eZdZdZddZddZdZy)TruncatedNormalaInitializer that generates a truncated normal distribution. Also available via the shortcut function `tf.keras.initializers.truncated_normal`. The values generated are similar to values from a `tf.keras.initializers.RandomNormal` initializer except that values more than two standard deviations from the mean are discarded and re-drawn. Examples: >>> # Standalone usage: >>> initializer = tf.keras.initializers.TruncatedNormal(mean=0., stddev=1.) >>> values = initializer(shape=(2, 2)) >>> # Usage in a TF-Keras layer: >>> initializer = tf.keras.initializers.TruncatedNormal(mean=0., stddev=1.) >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Args: mean: a python scalar or a scalar tensor. Mean of the random values to generate. stddev: a python scalar or a scalar tensor. Standard deviation of the random values to generate before truncation. seed: A Python integer. Used to make the behavior of the initializer deterministic. Note that a seeded initializer will produce the same random values across multiple calls. Ncf||_||_||_tj|d|_yrSrlros rrHzTruncatedNormal.__init__rprc lt|jj|tt |}t |vr |t }|j td}||j|r t|nd}|jdd}|rr|jj|j_ ttj |jj"|||j$|j&||S|jj#||j$|j&||S)aReturns a tensor initialized to random normal values (truncated). Args: shape: Shape of the tensor. dtype: Optional dtype of the tensor. Only floating point types are supported. If not specified, `tf.keras.backend.floatx()` is used, which default to `float32` unless you configured it otherwise (via `tf.keras.backend.set_floatx(float_dtype)`) **kwargs: Additional keyword arguments. Nr )r4r%r&rrr5r:r^r_r'r`rrZ RNG_STATEFUL _rng_typerarr;truncated_normalrmrnrcs rrzTruncatedNormal.__call__s 00&9#Ju$56 v %+,E!::&7>  #    *:%&Hd+ &&33  " " , ! "))&&77   %%66 499dkk5%  rcJ|j|j|jdSrurvrs rrzTruncatedNormal.get_configrwrrxr(rhrrrr{r{s < ( TMrr{z"keras.initializers.VarianceScalingz#keras.initializers.variance_scalingc4eZdZdZ ddZddZdZdZy) VarianceScalingaInitializer that adapts its scale to the shape of its input tensors. Also available via the shortcut function `tf.keras.initializers.variance_scaling`. With `distribution="truncated_normal" or "untruncated_normal"`, samples are drawn from a truncated/untruncated normal distribution with a mean of zero and a standard deviation (after truncation, if used) `stddev = sqrt(scale / n)`, where `n` is: - number of input units in the weight tensor, if `mode="fan_in"` - number of output units, if `mode="fan_out"` - average of the numbers of input and output units, if `mode="fan_avg"` With `distribution="uniform"`, samples are drawn from a uniform distribution within `[-limit, limit]`, where `limit = sqrt(3 * scale / n)`. Examples: >>> # Standalone usage: >>> initializer = tf.keras.initializers.VarianceScaling( ... scale=0.1, mode='fan_in', distribution='uniform') >>> values = initializer(shape=(2, 2)) >>> # Usage in a TF-Keras layer: >>> initializer = tf.keras.initializers.VarianceScaling( ... scale=0.1, mode='fan_in', distribution='uniform') >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Args: scale: Scaling factor (positive float). mode: One of `"fan_in"`, `"fan_out"`, `"fan_avg"`. distribution: Random distribution to use. One of `"truncated_normal"`, `"untruncated_normal"`, or `"uniform"`. seed: A Python integer. Used to make the behavior of the initializer deterministic. Note that a seeded initializer will produce the same random values across multiple calls. Nc2|dkrtd|dhd}||vrtd|d|d|j}|dk(rd}hd }||vrtd |d |d||_||_||_||_t j|d |_y)Nryz0`scale` must be positive float. Received: scale=r2>fan_infan_avgfan_outzInvalid `mode` argument: z. Please use one of the normalr>uniformruntruncated_normalz!Invalid `distribution` argument: z.Allowed distributions: rTrU) r9lowerscalemode distributionr!rrYrZ)rrrrr! allowed_modesallowed_distributionss rrHzVarianceScaling.__init__Bs C<B5'K 9 } $+D62))6q: $))+ 8 #-L!  4 43L>B**?)@C   ( !(!8!8 ;" rc t|jj|tt |}t |vr |t }|j td}||j|r t|nd}|jdd}|r.ttj|j||||S|j|||S)aReturns a tensor object initialized as specified by the initializer. Args: shape: Shape of the tensor. dtype: Optional dtype of the tensor. Only floating point types are supported. If not specified, `tf.keras.backend.floatx()` is used, which default to `float32` unless you configured it otherwise (via `tf.keras.backend.set_floatx(float_dtype)`) **kwargs: Additional keyword arguments. Nr )rrrd)r4r%r&rrr5r:r^r_r'r`rrarr;_generate_init_valrcs rrzVarianceScaling.__call__is 00&9#Ju$56 v %+,E!::&7>  #    *:%&Hd+  "))''  &&U%u&MMrc^|j}t|\}}|jdk(r|td|z}n4|jdk(r|td|z}n|td||zdz z}|jdk(r7t j |dz }|jj|d|||S|jdk(r4t j |}|jj|d|||St j d |z}|jj|| |||S) Nr?r@rg۶%?ryrg@) r _compute_fansrmaxrmathsqrtrZrrsrb) rrrrdrrrrnlimits rrz"VarianceScaling._generate_init_vals4 '. 99 Sf% %E YY) # Sg& &E Sv/367 7E    2 2YYu%(;;F))::sFE5   "6 6YYu%F))77sFE5 IIcEk*E))88vueU rc`|j|j|j|jdS)Nrrrr!rrs rrzVarianceScaling.get_configs*ZZII --II   r)rrrNr(r&r)r*r+rHrrrrrrrrs- %R '  % NNB6 rrzkeras.initializers.Orthogonalzkeras.initializers.orthogonalc,eZdZdZddZddZdZdZy) OrthogonalaInitializer that generates an orthogonal matrix. Also available via the shortcut function `tf.keras.initializers.orthogonal`. If the shape of the tensor to initialize is two-dimensional, it is initialized with an orthogonal matrix obtained from the QR decomposition of a matrix of random numbers drawn from a normal distribution. If the matrix has fewer rows than columns then the output will have orthogonal rows. Otherwise, the output will have orthogonal columns. If the shape of the tensor to initialize is more than two-dimensional, a matrix of shape `(shape[0] * ... * shape[n - 2], shape[n - 1])` is initialized, where `n` is the length of the shape vector. The matrix is subsequently reshaped to give a tensor of the desired shape. Examples: >>> # Standalone usage: >>> initializer = tf.keras.initializers.Orthogonal() >>> values = initializer(shape=(2, 2)) >>> # Usage in a TF-Keras layer: >>> initializer = tf.keras.initializers.Orthogonal() >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Args: gain: multiplicative factor to apply to the orthogonal matrix seed: A Python integer. Used to make the behavior of the initializer deterministic. Note that a seeded initializer will produce the same random values across multiple calls. References: - [Saxe et al., 2014](https://openreview.net/forum?id=_wzZwKpTDF_9C) NcX||_||_tj|d|_yrS)gainr!rrYrZ)rrr!s rrHzOrthogonal.__init__s(  !(!8!8 ;" rc t|jj|dtt |}t |dkrt d|dt |d|j|jdd}|r-ttj|j||| S|j||S) aReturns a tensor object initialized to an orthogonal matrix. Args: shape: Shape of the tensor. dtype: Optional dtype of the tensor. Only floating point types are supported. If not specified, `tf.keras.backend.floatx()` is used, which default to `float32` unless you configured it otherwise (via `tf.keras.backend.set_floatx(float_dtype)`) **kwargs: Additional keyword arguments. Fsupport_partitionzKThe tensor to initialize must be at least two-dimensional. Received: shape= of rank r2r Nr3) r4r%r&rrr5lenr9r'rrarr;rr=s rrzOrthogonal.__call__s  NN # #Vu $Ju$56 u:>yU A7  Hd+  "))''uE &&ue44rcd}|ddD]}||z} |d}t||t||f}|jj||}tj j |d\}} tj j| } |t j| z}||krtj j|}|jt j||zS)NrF) full_matrices) rminrZrsr7linalgqrtensor_diag_partsignmatrix_transposerreshape) rrrnum_rowsdimnum_cols flat_shapeaqrds rrzOrthogonal._generate_init_vals": C OH 9(H-s8X/FG   " " 0 05 0 Iyy||AU|31 II & &q ) RWWQZ h  **1-Ayy2::a///rc4|j|jdS)Nrr!rrs rrzOrthogonal.get_configs 49955r)rNr(rrrrrrs!F 5>0(6rrzkeras.initializers.Identityzkeras.initializers.identityc,eZdZdZddZddZdZdZy) Identitya3Initializer that generates the identity matrix. Also available via the shortcut function `tf.keras.initializers.identity`. Only usable for generating 2D matrices. Examples: >>> # Standalone usage: >>> initializer = tf.keras.initializers.Identity() >>> values = initializer(shape=(2, 2)) >>> # Usage in a TF-Keras layer: >>> initializer = tf.keras.initializers.Identity() >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Args: gain: Multiplicative factor to apply to the identity matrix. c||_yr(r)rrs rrHzIdentity.__init__+s  rNc Rt|jj|dtt |}t |dk7rt d|dt |d|jdd}|r#tj|j||| S|j||S) aReturns a tensor object initialized to a 2D identity matrix. Args: shape: Shape of the tensor. It should have exactly rank 2. dtype: Optional dtype of the tensor. Only floating point types are supported. If not specified, `tf.keras.backend.floatx()` is used, which default to `float32` unless you configured it otherwise (via `tf.keras.backend.set_floatx(float_dtype)`) **kwargs: Additional keyword arguments. FrrzNIdentity matrix initializer can only be used for 2D matrices. Received: shape=rr2r Nr3) r4r%r&rrr5rr9rrr;rr=s rrzIdentity.__call__.s  NN # #Vu $Ju$56 u:?##('3u:,aA Hd+ ))''uE &&ue44rcJtj|d|i}|j|zS)Nr)r7eyer)rrr initializers rrzIdentity._generate_init_valIs$ffe151 yy;&&rcd|jiS)Nrrrs rrzIdentity.get_configM ""r)rr(rrrrrrs(56'#rrz keras.initializers.GlorotUniformz!keras.initializers.glorot_uniformc*eZdZdZdfd ZdZxZS) GlorotUniformajThe Glorot uniform initializer, also called Xavier uniform initializer. Also available via the shortcut function `tf.keras.initializers.glorot_uniform`. Draws samples from a uniform distribution within `[-limit, limit]`, where `limit = sqrt(6 / (fan_in + fan_out))` (`fan_in` is the number of input units in the weight tensor and `fan_out` is the number of output units). Examples: >>> # Standalone usage: >>> initializer = tf.keras.initializers.GlorotUniform() >>> values = initializer(shape=(2, 2)) >>> # Usage in a TF-Keras layer: >>> initializer = tf.keras.initializers.GlorotUniform() >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Args: seed: A Python integer. Used to make the behavior of the initializer deterministic. Note that a seeded initializer will not produce the same random values across multiple calls, but multiple initializers will produce the same sequence when constructed with the same seed value. References: - [Glorot et al., 2010](http://proceedings.mlr.press/v9/glorot10a.html) c,t|ddd|y)NrrrrsuperrHrr!r%s rrHzGlorotUniform.__init__ts IID  rcd|jiSNr!r!rs rrzGlorotUniform.get_configyrrr(r&r)r*r+rHr __classcell__r%s@rrrQs : #rrzkeras.initializers.GlorotNormalz keras.initializers.glorot_normalc*eZdZdZdfd ZdZxZS) GlorotNormalaThe Glorot normal initializer, also called Xavier normal initializer. Also available via the shortcut function `tf.keras.initializers.glorot_normal`. Draws samples from a truncated normal distribution centered on 0 with `stddev = sqrt(2 / (fan_in + fan_out))` where `fan_in` is the number of input units in the weight tensor and `fan_out` is the number of output units in the weight tensor. Examples: >>> # Standalone usage: >>> initializer = tf.keras.initializers.GlorotNormal() >>> values = initializer(shape=(2, 2)) >>> # Usage in a TF-Keras layer: >>> initializer = tf.keras.initializers.GlorotNormal() >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Args: seed: A Python integer. Used to make the behavior of the initializer deterministic. Note that a seeded initializer will not produce the same random values across multiple calls, but multiple initializers will produce the same sequence when constructed with the same seed value. References: - [Glorot et al., 2010](http://proceedings.mlr.press/v9/glorot10a.html) c,t|ddd|y)Nrrrrrrs rrHzGlorotNormal.__init__s! +  rcd|jiSrrrs rrzGlorotNormal.get_configrrr(rrs@rrr}s< #rrzkeras.initializers.LecunNormalzkeras.initializers.lecun_normalc*eZdZdZdfd ZdZxZS) LecunNormalaLecun normal initializer. Also available via the shortcut function `tf.keras.initializers.lecun_normal`. Initializers allow you to pre-specify an initialization strategy, encoded in the Initializer object, without knowing the shape and dtype of the variable being initialized. Draws samples from a truncated normal distribution centered on 0 with `stddev = sqrt(1 / fan_in)` where `fan_in` is the number of input units in the weight tensor. Examples: >>> # Standalone usage: >>> initializer = tf.keras.initializers.LecunNormal() >>> values = initializer(shape=(2, 2)) >>> # Usage in a TF-Keras layer: >>> initializer = tf.keras.initializers.LecunNormal() >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Args: seed: A Python integer. Used to make the behavior of the initializer deterministic. Note that a seeded initializer will not produce the same random values across multiple calls, but multiple initializers will produce the same sequence when constructed with the same seed value. References: - [Klambauer et al., 2017](https://arxiv.org/abs/1706.02515) c,t|ddd|y)Nrrrrrrs rrHzLecunNormal.__init__ H3ED  rcd|jiSrrrs rrzLecunNormal.get_configrrr(rrs@rrrsB #rrzkeras.initializers.LecunUniformz keras.initializers.lecun_uniformc*eZdZdZdfd ZdZxZS) LecunUniformaLecun uniform initializer. Also available via the shortcut function `tf.keras.initializers.lecun_uniform`. Draws samples from a uniform distribution within `[-limit, limit]`, where `limit = sqrt(3 / fan_in)` (`fan_in` is the number of input units in the weight tensor). Examples: >>> # Standalone usage: >>> initializer = tf.keras.initializers.LecunUniform() >>> values = initializer(shape=(2, 2)) >>> # Usage in a TF-Keras layer: >>> initializer = tf.keras.initializers.LecunUniform() >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Args: seed: A Python integer. Used to make the behavior of the initializer deterministic. Note that a seeded initializer will not produce the same random values across multiple calls, but multiple initializers will produce the same sequence when constructed with the same seed value. References: - [Klambauer et al., 2017](https://arxiv.org/abs/1706.02515) c,t|ddd|y)Nrrrrrrs rrHzLecunUniform.__init__ H94  rcd|jiSrrrs rrzLecunUniform.get_configrrr(rrs@rrr: #rrzkeras.initializers.HeNormalzkeras.initializers.he_normalc*eZdZdZdfd ZdZxZS)HeNormalaHe normal initializer. Also available via the shortcut function `tf.keras.initializers.he_normal`. It draws samples from a truncated normal distribution centered on 0 with `stddev = sqrt(2 / fan_in)` where `fan_in` is the number of input units in the weight tensor. Examples: >>> # Standalone usage: >>> initializer = tf.keras.initializers.HeNormal() >>> values = initializer(shape=(2, 2)) >>> # Usage in a TF-Keras layer: >>> initializer = tf.keras.initializers.HeNormal() >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Args: seed: A Python integer. Used to make the behavior of the initializer deterministic. Note that a seeded initializer will not produce the same random values across multiple calls, but multiple initializers will produce the same sequence when constructed with the same seed value. References: - [He et al., 2015](https://arxiv.org/abs/1502.01852) c,t|ddd|y)Nrrrrrrs rrHzHeNormal.__init__$rrcd|jiSrrrs rrzHeNormal.get_config)rrr(rrs@rrrrrrzkeras.initializers.HeUniformzkeras.initializers.he_uniformc*eZdZdZdfd ZdZxZS) HeUniformaHe uniform variance scaling initializer. Also available via the shortcut function `tf.keras.initializers.he_uniform`. Draws samples from a uniform distribution within `[-limit, limit]`, where `limit = sqrt(6 / fan_in)` (`fan_in` is the number of input units in the weight tensor). Examples: >>> # Standalone usage: >>> initializer = tf.keras.initializers.HeUniform() >>> values = initializer(shape=(2, 2)) >>> # Usage in a TF-Keras layer: >>> initializer = tf.keras.initializers.HeUniform() >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Args: seed: A Python integer. Used to make the behavior of the initializer deterministic. Note that a seeded initializer will not produce the same random values across multiple calls, but multiple initializers will produce the same sequence when constructed with the same seed value. References: - [He et al., 2015](https://arxiv.org/abs/1502.01852) c,t|ddd|y)Nrrrrrrs rrHzHeUniform.__init__Nrrcd|jiSrrrs rrzHeUniform.get_configSrrr(rrs@rrr-rrrcX|tj}tj|Sr()rfloatxr7as_dtypers rr5r5Ws" }  ;;u rcftj|}|jstd|d|S)a Validate and return floating point type based on `dtype`. `dtype` must be a floating point type. Args: dtype: The data type to validate. Returns: Validated type. Raises: ValueError: if `dtype` is not a floating point type. z"Expected floating point type, got r2)r7rr\r9rs rrrrr]s5 KK E   =eWAFGG Lrct|dkrdx}}nPt|dk(r|dx}}n:t|dk(r |d}|d}n!d}|ddD]}||z} |d|z}|d|z}t|t|fS)zComputes the number of input and output units for a weight shape. Args: shape: Integer shape tuple or TF tensor shape. Returns: A tuple of integer scalars (fan_in, fan_out). rrrNr)rint)rrrreceptive_field_sizers rrrqs 5zA~ Uq 8# Uqq( !": (C C '  (r11)22 v;G $$rc|Dcgc] }|tvs |}}|rtd|dtd|st|vst|vrt |dyycc}w)NzUnknown keyword arguments: z. Allowed keyword arguments: r2z9 initializer doesn't support partition-related arguments.)_ALLOWED_INITIALIZER_KWARGS TypeErrorr:r_r9)cls_namerrkinvalid_kwargss rr4r4s!'PA14O+OaPNP).)9:""=!>a A   F"&76&Aj+ +  'B  Qs AAcPttjdds tdy)aMake sure the keras.backend global seed generator is set. This is important for DTensor use case to ensure that each client are initialized with same seed for tf.random.Generator, so that the value created are in sync among all the clients. generatorNzWhen using DTensor APIs, you need to set the global seed before using any TF-Keras initializers. Please make sure to call `tf.keras.utils.set_random_seed()` in your code.)r"r_SEED_GENERATORr9rrrraras. 7**K > G   ?r)T)(r+rr#tensorflow.compat.v2compatv2r7 tf_keras.srcrtf_keras.src.dtensorrtf_keras.src.savingr tensorflow.python.util.tf_exportrr:r__LAYOUTrr r/r@rDrQrjr{rrrrrrrrrr5rrrr4rarrrrs !! &1:$& /1BGL./^^0^B(*DL&&K&&M&&R')BrJ&%;&%K&%R!#@R;{;;|&'  KQKKQ  KQ\%'IbHM;HMHMV()  RMkRM  RMj()  Q kQ  Q h#%D_6_6_6D!#@R8#{8#8#v&'  $#O$#  $#N%'Ib(#?(#(#V$&GB(#/(#(#V%'Ib$#?$#$#N!#Ab$#$#$#N"$C$#$#$#N (%6   r