a SicӤ@sfdZddlZddlZddlmmZddlmZddl m Z ddl m Z dZ dZdZe eegZe d Gd d d Ze d d gdGdddeZe ddgdGdddeZe ddgdGdddeZe ddgdGdddeZe ddgdGdd d eZe d!d"gdGd#d$d$eZe d%d&gdGd'd(d(eZe d)d*gdGd+d,d,eZe d-d.gdGd/d0d0eZe d1d2gdGd3d4d4eZe d5d6gdGd7d8d8eZe d9d:gdGd;d<dgdGd?d@d@eZe dAdBgdGdCdDdDeZe dEdFgdGdGdHdHeZ dIdJZ!dKdLZ"dMdNZ#dTdPdQZ$dRdSZ%dS)UzKeras initializers for TF 2.N)backend)utils) keras_exportpartition_shapepartition_offsetlayoutzkeras.initializers.Initializerc@s6eZdZdZd ddZddZeddZd d ZdS) Initializera9Initializer base class: all 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. ``` Optionally, you an also implement the method `get_config` and the class method `from_config` in order to support serialization -- just like with any Keras object. Here's a simple example: a random normal initializer. ```python import tensorflow as tf class ExampleRandomNormal(tf.keras.initializers.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. NcKs tddS)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.N)NotImplementedError)selfshapedtypekwargsr^/var/www/html/django/DPS/env/lib/python3.9/site-packages/keras/initializers/initializers_v2.py__call__LszInitializer.__call__cCsiS)zReturns the configuration of the initializer as a JSON-serializable dict. Returns: A JSON-serializable Python dict. rr rrr get_configXszInitializer.get_configcCs|dd|fi|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: A `tf.keras.initializers.Initializer` instance. r N)pop)clsconfigrrr from_config`s zInitializer.from_configcCs>t|ddr4t|dddur:td|jjdnd|_dS)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 initalizer instance more than once.T)getattrwarningswarn __class____name__rrrrr _warn_reuseus   zInitializer._warn_reuse)N) r __module__ __qualname____doc__rr classmethodrrrrrrr"s (  rzkeras.initializers.Zeroszkeras.initializers.zeros)v1c@seZdZdZdddZdS)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 Keras layer: >>> initializer = tf.keras.initializers.Zeros() >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) NcKsvt|jj|t|}|jr&|tjkr6td|dt|vrF|t}| dd}|rjt j tj |||dSt ||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, `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 numeric or boolean dtype, got .rNr r ) _validate_kwargsrr _get_dtypeis_numpy_compatibletfstring ValueError_PARTITION_SHAPErrcall_with_layoutzerosr r r r rrrrrs   zZeros.__call__)Nrrr r!rrrrrr$sr$zkeras.initializers.Oneszkeras.initializers.onesc@seZdZdZdddZdS)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 Keras layer: >>> initializer = tf.keras.initializers.Ones() >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) NcKsvt|jj|t|}|jr&|tjkr6td|dt|vrF|t}| dd}|rjt j tj |||dSt ||Sr%) r(rrr)r*r+r,r-r.rrr/onesr1rrrrs   z Ones.__call__)Nr2rrrrr3sr3zkeras.initializers.Constantzkeras.initializers.constantc@s,eZdZdZd ddZd ddZdd ZdS) Constanta}Initializer 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 Keras layer: >>> initializer = tf.keras.initializers.Constant(3.) >>> layer = tf.keras.layers.Dense(3, kernel_initializer=initializer) Args: value: A Python scalar. rcCs ||_dSNvalue)r r8rrr__init__szConstant.__init__NcKsdt|jj|t|}t|vr&|t}|dd}|rNtjtj ||j ||dStj |j t||dS)aReturns a tensor object initialized to `self.value`. Args: shape: Shape of the tensor. dtype: Optional dtype of the tensor. 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. rNr')r r ) r(rrr)r.rrr/r+constantr8r1rrrrs  zConstant.__call__cCs d|jiS)Nr8r7rrrrr szConstant.get_config)r)Nrrr r!r9rrrrrrr5s  r5z keras.initializers.RandomUniformz!keras.initializers.random_uniformc@s,eZdZdZd ddZd ddZd d ZdS) 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 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. 皙皙?NcCs&||_||_||_tj|dd|_dSN statelessrng_type)minvalmaxvalrrRandomGenerator_random_generator)r rCrDrrrrr9.s zRandomUniform.__init__c Kst|jj|t|}|js2|js2td|dt|vrB|t}|t d}|dur^| |rjt |nd}| dd}|rt t|jj|||j|j||S|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 r&Nr)r(rrr) is_floating is_integerr-r.get_PARTITION_OFFSETrhashr_ensure_keras_seededrr/rFrandom_uniformrCrDr r r r rnoncerrrrr6s2     zRandomUniform.__call__cCs|j|j|jdS)NrCrDrrPrrrrr^szRandomUniform.get_config)r=r>N)Nr;rrrrr<s  (r<zkeras.initializers.RandomNormalz keras.initializers.random_normalc@s,eZdZdZd ddZd ddZd d ZdS) 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 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. r>NcCs&||_||_||_tj|dd|_dSr?meanstddevrrrErFr rTrUrrrrr9s zRandomNormal.__init__c Kst|jj|tt|}t|vr*|t}|td}|durF||rRt |nd}| dd}|rt t |jj|||j|j||S|j||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)r(rr_assert_float_dtyper)r.rIrJrrKrrLrr/rF random_normalrTrUrNrrrrs.     zRandomNormal.__call__cCs|j|j|jdSNrTrUrrZrrrrrszRandomNormal.get_config)rRr>N)Nr;rrrrrQbs  %rQz"keras.initializers.TruncatedNormalz#keras.initializers.truncated_normalc@s,eZdZdZd ddZd ddZd d ZdS) 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 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. rRr>NcCs&||_||_||_tj|dd|_dSr?rSrVrrrr9s zTruncatedNormal.__init__c Kst|jj|tt|}t|vr*|t}|td}|durF||rRt |nd}| dd}|r|j j |j _ tt|j j|||j|j||S|j ||j|j||S)aReturns a tensor object 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(rrrWr)r.rIrJrrKrrF RNG_STATEFUL _rng_typerLrr/truncated_normalrTrUrNrrrrs2     zTruncatedNormal.__call__cCs|j|j|jdSrYrZrrrrrszTruncatedNormal.get_config)rRr>N)Nr;rrrrr[s  *r[z"keras.initializers.VarianceScalingz#keras.initializers.variance_scalingc@s4eZdZdZdddZddd Zd d Zd d ZdS)VarianceScalingadInitializer capable of adapting its scale to the shape of weights 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 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" and "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. ?fan_inr^NcCs|dkrtd|dhd}||vr>td|d|d|}|dkrRd}hd }||vrxtd |d |d||_||_||_||_tj|d d |_dS)NrRz0`scale` must be positive float. Received: scale=r&>rafan_avgfan_outzInvalid `mode` argument: z. Please use one of the normalr^>untruncated_normaluniformr^z!Invalid `distribution` argument: z.Allowed distributions: r@rA) r-lowerscalemode distributionrrrErF)r rhrirjrZ allowed_modesZallowed_distributionsrrrr97s8 zVarianceScaling.__init__cKst|jj|tt|}t|vr*|t}|td}|durF||rRt |nd}| dd}|rt t j |j||||dS|j|||dS)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)r r rO)r(rrrWr)r.rIrJrrKrrLrr/_generate_init_valrNrrrr^s&    zVarianceScaling.__call__c Cs|j}t|\}}|jdkr,|td|}n0|jdkrF|td|}n|td||d}|jdkrt|d}|j|d|||S|jdkrt|}|j |d|||Std |}|j || |||SdS) Nrar`rc@r^g۶%?rRreg@) rh _compute_fansrimaxrjmathsqrtrFr^rXrM) r r r rOrhrarcrUlimitrrrrks*         z"VarianceScaling._generate_init_valcCs|j|j|j|jdS)Nrhrirjrrrrrrrrs zVarianceScaling.get_config)r`rar^N)Nrrr r!r9rrkrrrrrr_ s) ' !r_zkeras.initializers.Orthogonalzkeras.initializers.orthogonalc@s4eZdZdZd ddZd ddZdd Zd d ZdS) 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 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) r`NcCs ||_||_tj|dd|_dSr?)gainrrrErF)r rurrrrr9s zOrthogonal.__init__cKst|jj|ddtt|}t|dkrDtd|dt|d||dd}|rvt t j |j |||d S| ||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 r&rNr') r(rrrWr)lenr-rrrLrr/rkr1rrrrs(      zOrthogonal.__call__c Csd}|ddD] }||9}q|d}t||t||f}|jj||d}tjj|dd\}} tj| } |t| 9}||krtj |}|j t ||S)Nr F) full_matrices) rnminrFrXr+linalgqrtensor_diag_partsignmatrix_transposerureshape) r r r num_rowsdimnum_cols flat_shapeaqrdrrrrks   zOrthogonal._generate_init_valcCs|j|jdS)NrurrrrrrrszOrthogonal.get_config)r`N)Nrsrrrrrts #  rtzkeras.initializers.Identityzkeras.initializers.identityc@s4eZdZdZd ddZd ddZdd Zd d ZdS)Identitya0Initializer 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 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. r`cCs ||_dSr6ru)r rurrrr9 szIdentity.__init__NcKstt|jj|ddtt|}t|dkrDtd|dt|d|dd}|rhtj |j |||d S| ||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. FrvrxzNIdentity matrix initializer can only be used for 2D matrices. Received: shape=ryr&rNr') r(rrrWr)rzr-rrr/rkr1rrrr#s$      zIdentity.__call__cCstj|d|i}|j|S)Nr )r+eyeru)r r r initializerrrrrk>szIdentity._generate_init_valcCs d|jiS)NrurrrrrrBszIdentity.get_config)r`)Nrsrrrrrs   rz keras.initializers.GlorotUniformz!keras.initializers.glorot_uniformcs*eZdZdZdfdd ZddZZS) GlorotUniformagThe 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 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) Ncstjddd|ddS)Nr`rbrfrrsuperr9r rrrrr9iszGlorotUniform.__init__cCs d|jiSNrrrrrrrnszGlorotUniform.get_config)Nrrr r!r9r __classcell__rrrrrFsrzkeras.initializers.GlorotNormalz keras.initializers.glorot_normalcs*eZdZdZdfdd ZddZZS) GlorotNormala|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 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) Ncstjddd|ddS)Nr`rbr^rrrrrrrr9s zGlorotNormal.__init__cCs d|jiSrrrrrrrszGlorotNormal.get_config)Nrrrrrrrsrzkeras.initializers.LecunNormalzkeras.initializers.lecun_normalcs*eZdZdZdfdd ZddZZS) 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 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) Ncstjddd|ddS)Nr`rar^rrrrrrrr9szLecunNormal.__init__cCs d|jiSrrrrrrrszLecunNormal.get_config)Nrrrrrrs!rzkeras.initializers.LecunUniformz keras.initializers.lecun_uniformcs*eZdZdZdfdd ZddZZS) 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 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) Ncstjddd|ddS)Nr`rarfrrrrrrrr9szLecunUniform.__init__cCs d|jiSrrrrrrrszLecunUniform.get_config)Nrrrrrrsrzkeras.initializers.HeNormalzkeras.initializers.he_normalcs*eZdZdZdfdd ZddZZS)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 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) Ncstjddd|ddS)Nrlrar^rrrrrrrr9szHeNormal.__init__cCs d|jiSrrrrrrrszHeNormal.get_config)Nrrrrrrsrzkeras.initializers.HeUniformzkeras.initializers.he_uniformcs*eZdZdZdfdd ZddZZS) 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 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) Ncstjddd|ddS)Nrlrarfrrrrrrrr9CszHeUniform.__init__cCs d|jiSrrrrrrrHszHeUniform.get_config)Nrrrrrr"srcCs|durt}t|Sr6)rfloatxr+as_dtyper}rrrr)Lsr)cCs$t|}|js td|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 r&)r+rrGr-r}rrrrWRs rWcCst|dkrd}}nnt|dkr0|d}}nTt|dkrN|d}|d}n6d}|ddD] }||9}q^|d|}|d|}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). r{rrxNr|)rzint)r rarcreceptive_field_sizerrrrrmfs        rmTcCsNdd|D}|r(td|dtd|sJt|vsz$_validate_kwargs..zUnknown keyword arguments: z. Allowed keyword arguments: r&z9 initializer doesn't support partition-related arguments.) TypeErrorrr.rJr-)cls_namer rwinvalid_kwargsrrrr(sr(cCsttjddstddS)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 Keras initializers. Please make sure to call `tf.keras.utils.set_random_seed()` in your code.)rr_SEED_GENERATORr-rrrrrLsrL)T)&r!rortensorflow.compat.v2compatv2r+kerasrZ keras.dtensorr tensorflow.python.util.tf_exportrr.rJ_LAYOUTrrr$r3r5r<rQr[r_rtrrrrrrrr)rWrmr(rLrrrrs    a ) )4NKUb;'++'''