6biPSrSSKrSSKrSSKJs Jr SSKJr SSK J r SSK J r SSK Jr SrSrS r\\\/r\"S 5"S S 55r\"S S/S9"SS\55r\"SS/S9"SS\55r\"SS/S9"SS\55r\"SS/S9"SS\55r\"SS/S9"S S!\55r\"S"S#/S9"S$S%\55r\"S&S'/S9"S(S)\55r\"S*S+/S9"S,S-\55r\"S.S//S9"S0S1\55r\"S2S3/S9"S4S5\55r\"S6S7/S9"S8S9\55r\"S:S;/S9"S<S=\55r\"S>S?/S9"S@SA\55r \"SBSC/S9"SDSE\55r!\"SFSG/S9"SHSI\55r"SJr#SKr$SLr%SOSMjr&SNr'g)PzKeras initializers.N)backend)utils)serialization_lib) keras_exportpartition_shapepartition_offsetlayoutzkeras.initializers.Initializerc>\rSrSrSrS SjrSr\S5rSr Sr g) Initializer#aInitializer 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 [S5e)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 `/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/initializers/initializers.py__call__Initializer.__call__Ms" L  c0$)ztReturns the initializer's configuration as a JSON-serializable dict. Returns: A JSON-serializable Python dict. rs r get_configInitializer.get_configYs  rc6URSS5 U"S0UD6$)a:Instantiates 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_configInitializer.from_configas$  7D!}V}rc[USS5(a>[USS5c/[R"SURRS35 ggSUlg)N_usedFseedzThe initializer z is unseeded and being called multiple times, which will return identical values each time (even if the initializer is unseeded). Please update your code to provide a seed to the initializer, or avoid using the same initializer instance more than once.T)getattrwarningswarn __class____name__r$rs r _warn_reuseInitializer._warn_reusevsW 4% ( (tVT*2 &t~~'>'>&?@//3DJr)r$N) r* __module__ __qualname____firstlineno____doc__rr classmethodr!r+__static_attributes__rrrr r #s+&P  ( rr zkeras.initializers.Zeroszkeras.initializers.zeros)v1c"\rSrSrSrSSjrSrg)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 [URRU5 [U5nUR(aU[ R :Xa[SUS35e[U;a U[nURSS5nU(a$[R"[ RXAUS9$[ R"X5$aReturns 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 rrZeros.__call__s 00&95!((ERYY,>FugQOP P v %+,EHd+ ))&U xx%%rrr-r*r.r/r0r1rr3rrrr6r6s  &rr6zkeras.initializers.Oneszkeras.initializers.onesc"\rSrSrSrSSjrSrg)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 [URRU5 [U5nUR(aU[ R :Xa[SUS35e[U;a U[nURSS5nU(a$[R"[ RXAUS9$[ R"X5$r9) r<r)r*r=r>r?r@rArBrrrConesrEs rr Ones.__call__s 00&95!((ERYY,>FugQOP P v %+,EHd+ ))E wwu$$rrr-rGrrrrIrIs  %rrIzkeras.initializers.Constantzkeras.initializers.constantcB\rSrSrSrS SjrS SjrSr\S5r Sr g) ConstantaJInitializer 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. cXlgr-value)rrSs r__init__Constant.__init__s rNc ^[URRU5 [U5n[U;a U[nUR SS5nU(a.[ R"[RX@RXS9$[R"UR[U5US9$)aoReturns 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 Nr;)rr) r<r)r*r=rBrrrCr?constantrSrEs rrConstant.__call__s 00&95! v %+,EHd+ )) VZZu {{4::Z->eLLrcSUR0$)NrSrRrs rrConstant.get_config s$$rcURSS5 SU;a4[US[5(a[R"US5US'U"S0UD6$)NrrSr)r isinstancedictrdeserialize_keras_objectrs rr!Constant.from_configsR 7D! f &/400"3"L"L7O#w}V}rrR)rr-) r*r.r/r0r1rTrrr2r!r3rrrrOrOs+,M,%rrOz keras.initializers.RandomUniformz!keras.initializers.random_uniformc2\rSrSrSrSSjrS SjrSrSrg) RandomUniformiaInitializer 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. Nc\XlX lX0l[R"USS9UlgN statelessrng_type)minvalmaxvalr%rRandomGenerator_random_generator)rrgrhr%s rrTRandomUniform.__init__9s)   !(!8!8 ;" rc [URRU5 [U5nUR(d UR (d[ SUS35e[U;a U[nUR[S5nUcUR5 U(a [U5OSnURSS5nU(aN[5 [R"UR R"UUUR$UR&UU5$UR R#XR$UR&X%5$)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 r:Nr )r<r)r*r= is_floating is_integerrArBget_PARTITION_OFFSETr+hashr_ensure_keras_seededrrCrjrandom_uniformrgrhrrrrrnoncer s rrRandomUniform.__call__As 00&95!  )9)9DUG1MN N v %+,E!::&7>  #    *:%&Hd+  "))&&55   %%44 ;; U  rcJURURURS.$)Nrgrhr%rxrs rrRandomUniform.get_configis++diiPPr)rjrhrgr%)g皙?Nr- r*r.r/r0r1rTrrr3rrrraras 2 & PQrrazkeras.initializers.RandomNormalz keras.initializers.random_normalc2\rSrSrSrSSjrS SjrSrSrg) RandomNormalimaQInitializer 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. Nc\XlX lX0l[R"USS9Ulgrcmeanstddevr%rrirjrrrr%s rrTRandomNormal.__init__)   !(!8!8 ;" rc :[URRU5 [[ U55n[ U;a U[ nUR [S5nUcUR5 U(a [U5OSnURSS5nU(aN[5 [R"URRUUUR UR"UU5$URRXR UR"X%5$)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 )r<r)r*_assert_float_dtyper=rBrorpr+rqrrrrrCrj random_normalrrrts rrRandomNormal.__call__s 00&9#Ju$56 v %+,E!::&7>  #    *:%&Hd+  "))&&44   %%33 99dkk5  rcJURURURS.$Nrrr%rrs rrRandomNormal.get_config T[[$))LLrrjrr%rrzNr-r{rrrr}r}ms2 # JMrr}z"keras.initializers.TruncatedNormalz#keras.initializers.truncated_normalc2\rSrSrSrSSjrS SjrSrSrg) TruncatedNormalia,Initializer 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. Nc\XlX lX0l[R"USS9Ulgrcrrs rrTTruncatedNormal.__init__rrc [URRU5 [[ U55n[ U;a U[ nUR [S5nUcUR5 U(a [U5OSnURSS5nU(asURRURl [5 [R "URR"UUUR$UR&UU5$URR#XR$UR&X%5$)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 )r<r)r*rr=rBrorpr+rqrrj RNG_STATEFUL _rng_typerrrrCtruncated_normalrrrts rrTruncatedNormal.__call__s 00&9#Ju$56 v %+,E!::&7>  #    *:%&Hd+ &&33  " " , ! "))&&77   %%66 99dkk5  rcJURURURS.$rrrs rrTruncatedNormal.get_configrrrrr-r{rrrrrs < ( TMrrz"keras.initializers.VarianceScalingz#keras.initializers.variance_scalingc@\rSrSrSrS SjrS SjrSrSrSr g) VarianceScalingia Initializer 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. Nc.US::a[SUS35e1SknX%;a[SUSUS35eUR5nUS:XaSn1S knX6;a[S US US35eXlX lX0lX@l[ R"US S 9Ulg)Nrz0`scale` must be positive float. Received: scale=r:>fan_infan_avgfan_outzInvalid `mode` argument: z. Please use one of the normalr>uniformruntruncated_normalz!Invalid `distribution` argument: z.Allowed distributions: rdre) rAlowerscalemode distributionr%rrirj)rrrrr% allowed_modesallowed_distributionss rrTVarianceScaling.__init__Bs C<B5'K 9  $+D62))6q: $))+ 8 #-L!   43L>B**?)@C   ( !(!8!8 ;" rc [URRU5 [[ U55n[ U;a U[ nUR [S5nUcUR5 U(a [U5OSnURSS5nU(a,[5 [R"URUUUUS9$URXUS9$)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 )rrru)r<r)r*rr=rBrorpr+rqrrrrrC_generate_init_valrts rrVarianceScaling.__call__is 00&9#Ju$56 v %+,E!::&7>  #    *:%&Hd+  "))''  &&Uu&MMrc`URn[U5upVURS:XaU[SU5-nO4URS:XaU[SU5-nOU[SXV-S- 5-nURS:Xa7[ R "U5S- nURRUSXrU5$URS:Xa4[ R "U5nURRUSXrU5$[ R "S U-5nURRX*XU5$) Nr?r@rg۶%?rrg@) r _compute_fansrmaxrmathsqrtrjrrrs) rrrrurrrrlimits rr"VarianceScaling._generate_init_vals( '. 99 Sf% %E YY) # Sg& &E Sv/367 7E    2 2YYu%(;;F))::sF5   "6 6YYu%F))77sF5 IIcEk*E))88vuU rc`URURURURS.$)Nrrrr%rrs rrVarianceScaling.get_configs*ZZII --II   r)rjrrrr%)rrrNr- r*r.r/r0r1rTrrrr3rrrrrs- %R '  % NNB6 rrzkeras.initializers.Orthogonalzkeras.initializers.orthogonalc8\rSrSrSrS SjrS SjrSrSrSr g) OrthogonaliaVInitializer 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) NcPXlX l[R"USS9Ulgrc)gainr%rrirj)rrr%s rrTOrthogonal.__init__s$  !(!8!8 ;" rc [URRUSS9 [[ U55n[ U5S:a[ SUS[ U5S35eUR5 URSS5nU(a*[5 [R"URXAUS 9$URX5$) 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 r:r Nr;) r<r)r*rr=lenrAr+rrrrrCrrEs rrOrthogonal.__call__s  NN # #Vu $Ju$56 u:>yU A7  Hd+  "))''E &&u44rcSnUSSHnX4-nM USn[XS5[XS54nURRXbS9n[R R USS9up[R RU 5n U[R"U 5-nX5:a[R RU5nUR[R"X5-$)NrF) full_matrices) rminrjrr?linalgqrtensor_diag_partsignmatrix_transposerreshape) rrrnum_rowsdimnum_cols flat_shapeaqrds rrOrthogonal._generate_init_vals":C OH9(-s8/FG   " " 0 0 0 Iyy||AU|3 II & &q ) RWWQZ   **1-Ayy2::a///rc4URURS.$)Nrr%rrs rrOrthogonal.get_configs 49955r)rjrr%)rNr-rrrrrrs!F 5>0(6rrzkeras.initializers.Identityzkeras.initializers.identityc8\rSrSrSrS SjrS SjrSrSrSr g) IdentityiaInitializer 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. cXlgr-r)rrs rrTIdentity.__init__+s rNc P[URRUSS9 [[ U55n[ U5S:wa[ SUS[ U5S35eURSS5nU(a [R"URXAUS 9$URX5$) 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=rr:r Nr;) r<r)r*rr=rrArrrCrrEs rrIdentity.__call__.s  NN # #Vu $Ju$56 u:?##('3u:,aA Hd+ ))''E &&u44rcL[R"USU06nURU-$)Nr)r?eyer)rrr initializers rrIdentity._generate_init_valIs$ffe151 yy;&&rcSUR0$)Nrrrs rrIdentity.get_configM ""rr)rr-rrrrrrs(56'#rrz keras.initializers.GlorotUniformz!keras.initializers.glorot_uniformc6^\rSrSrSrSU4SjjrSrSrU=r$) GlorotUniformiQaThe 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&>[TU]SSSUS9 g)NrrrrsuperrTrr%r)s rrTGlorotUniform.__init__ts IID  rcSUR0$Nr%r%rs rrGlorotUniform.get_configyrrrr- r*r.r/r0r1rTrr3 __classcell__r)s@rrrQs : ##rrzkeras.initializers.GlorotNormalz keras.initializers.glorot_normalc6^\rSrSrSrSU4SjjrSrSrU=r$) GlorotNormali}a+The 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&>[TU]SSSUS9 g)Nrrrrrrs rrTGlorotNormal.__init__s! +  rcSUR0$rrrs rrGlorotNormal.get_configrrrr-rrs@rrr}s< ##rrzkeras.initializers.LecunNormalzkeras.initializers.lecun_normalc6^\rSrSrSrSU4SjjrSrSrU=r$) LecunNormaliaRLecun 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&>[TU]SSSUS9 g)Nrrrrrrs rrTLecunNormal.__init__ H3ED  rcSUR0$rrrs rrLecunNormal.get_configrrrr-rrs@rrrsB ##rrzkeras.initializers.LecunUniformz keras.initializers.lecun_uniformc6^\rSrSrSrSU4SjjrSrSrU=r$) LecunUniformiaLecun 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&>[TU]SSSUS9 g)Nrrrrrrs rrTLecunUniform.__init__ H94  rcSUR0$rrrs rrLecunUniform.get_configrrrr-rrs@rr r : ##rr zkeras.initializers.HeNormalzkeras.initializers.he_normalc6^\rSrSrSrSU4SjjrSrSrU=r$)HeNormaliaHe 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&>[TU]SSSUS9 g)Nrrrrrrs rrTHeNormal.__init__$rrcSUR0$rrrs rrHeNormal.get_config)rrrr-rrs@rrrrrrzkeras.initializers.HeUniformzkeras.initializers.he_uniformc6^\rSrSrSrSU4SjjrSrSrU=r$) HeUniformi-aHe 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&>[TU]SSSUS9 g)Nrrrrrrs rrTHeUniform.__init__Nr rcSUR0$rrrs rrHeUniform.get_configSrrrr-rrs@rrr-rrrc^Uc[R"5n[R"U5$r-)rfloatxr?as_dtypers rr=r=Ws" }  ;;u rcr[R"U5nUR(d[SUS35eU$)zValidate 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 r:)r?rrmrArs rrr]s5 KK E   =eWAFGG Lrc[U5S:aS=pOR[U5S:XaUS=pO<[U5S:Xa USnUSnO"SnUSSHnX4-nM USU-nUSU-n[U5[U54$)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 ' r11)22 v;G $$rcUVs/sHo3[;dMUPM nnU(a[SUS[S35eU(d#[U;d [U;a[ US35eggs snf)NzUnknown keyword arguments: z. Allowed keyword arguments: r:z9 initializer doesn't support partition-related arguments.)_ALLOWED_INITIALIZER_KWARGS TypeErrorrBrprA)cls_namerrkinvalid_kwargss rr<r<s!'PA4O+OaNP).)9:""=!>a A   F"&76&Aj+ +  'B  Qs A&A&cZ[[RSS5(d [S5eg)zMake 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_GENERATORrArrrrrrrs1 7**K > > G   ?r)T)(r1rr'tensorflow.compat.v2compatv2r? tf_keras.srcrtf_keras.src.dtensorrtf_keras.src.savingr tensorflow.python.util.tf_exportrrBrp_LAYOUTr&r r6rIrOrar}rrrrrrrr rrr=rrr<rrrrrr6s !! &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