ij`"ddlZddlmZddlmZddlmZddlm Z ddlm Z ddl m Z ddl mZdd l mZdd lmZdd lmZGd d ZdZdZeddgdZdZdZeddZeddZdZGddZy)Nbackend) keras_export)config)dtypes) global_state) current_path)get_stateless_scope)in_stateless_scope) tensorflow) auto_nameceZdZdZ dEdZdZdZdZdZe dZ e d Z e d Z d Z d Zd Ze dZe dZe dZe dZej(dZe dZe dZe dZej(dZe dZej(dZe dZej(dZdZdZdZdFdZdZd Zd!Z dFd"Z!d#Z"d$Z#d%Z$d&Z%d'Z&d(Z'd)Z(d*Z)d+Z*d,Z+d-Z,d.Z-d/Z.d0Z/d1Z0d2Z1d3Z2d4Z3d5Z4d6Z5d7Z6d8Z7d9Z8d:Z9d;Z:d<Z;d=ZZ=d?Z>d@Z?dAZ@dBZAdCZBdFdDZCy)GVariablear Represents a backend-agnostic variable in Keras. A `Variable` acts as a container for state. It holds a tensor value and can be updated. With the JAX backend, variables are used to implement "functionalization", the pattern of lifting stateful operations out of a piece of computation to turn it into a stateless function. Args: initializer: Initial value or callable for initialization. If a callable is used, it should take the arguments `shape` and `dtype`. shape: Optional. Tuple for the variable's shape. Required if `initializer` is a callable. dtype: Optional. Data type of the variable. Defaults to the global float dtype type (`"float32"` if never configured). trainable: Optional. Boolean indicating if variable is trainable. Defaults to `True`. autocast: Optional. Boolean indicating whether the variable supports autocasting. If `True`, the layer may first convert the variable to the compute data type when accessed. Defaults to `True`. aggregation: Optional string, one of `None`, `"none"`, `"mean"`, `"sum"` or `"only_first_replica"` specifying how a distributed variable will be aggregated. This serves as a semantic annotation, to be taken into account by downstream backends or users. Defaults to `"none"`. name: Optional. A unique name for the variable. Automatically generated if not set. layout: Optional. Sharding layout for the variable. Can be a `keras.distribution.TensorLayout` or a backend-specific layout. kwargs: Additional backend-specific keyword arguments. Attributes: shape: The shape of the variable (tuple of integers). ndim: The number of dimensions of the variable (integer). dtype: The data type of the variable (string). trainable: Whether the variable is trainable (boolean). autocast: Whether the variable supports autocasting (boolean). aggregation: How a distributed variable will be aggregated (string). value: The current value of the variable (NumPy array or tensor). name: The name of the variable (string). path: The path of the variable within the Keras model or layer (string). Examples: **Initializing a `Variable` with a NumPy array:** ```python import numpy as np import keras initial_array = np.ones((3, 3)) variable_from_array = keras.Variable(initializer=initial_array) ``` **Using a Keras initializer to create a `Variable`:** ```python from keras.src.initializers import Ones variable_from_initializer = keras.Variable( initializer=Ones(), shape=(3, 3), dtype="float32" ) ``` **Updating the value of a `Variable`:** ```python new_value = np.zeros((3, 3), dtype="float32") variable_from_array.assign(new_value) ``` **Marking a `Variable` as non-trainable:** ```python non_trainable_variable = keras.Variable( initializer=np.ones((3, 3), dtype="float32"), trainable=False ) ``` Nc  |xst|jj}t|trd|vrt d||dvrt d||d}|dvrt d||d}||_t} | r | d||_n||_d|_ d|_ d|_ d|_ t||_t||_||_||_| |_d|_t|trd d lm} | j-|}t/|r|2t d |d ||j1|| }| |j2}t5||_t9rFt/|r0d|_||_ |j=||_ t?|nyt dt/|r(|j=||_ |jA|n;|jC||j=|j:jD|_ tG|j|_$y)N/zRArgument `name` must be a string and cannot contain character `/`. Received: name=)Nnonemeansumonly_first_replicazInvalid value for argument `aggregation`. Expected one of `None`, `'none'`, `'mean'`, `'sum'`, `'only_first_replica'`. Received: aggregation=r)Nron_readon_writeautozInvalid value for argument `synchronization`. Expected one of `None`, `'none'`, `'on_read'`, `'on_write'`, `'auto'`. Received: synchronization=Fr) initializersznWhen creating a Variable from an initializer, the `shape` argument should be specified. Received: initializer=z and shape=dtypeadYou are attempting to create a variable while in a stateless scope. This is disallowed. Make sure that all variables are created before you start using your layer/model objects. In some cases, you might be seeing this error because you need to implement a `def build(self, input_shape)` method on your layer/model, which will create its variables. In some other cases, you might be seeing this error because you are instantiating a `Variable` and assigning it to a layer without going through self.add_variable()/self.add_weight(). Always prefer using these methods (with a `shape` and `initializer` argument).)%r __class____name__ isinstancestr ValueError_namer _path_shape _initializer _regularizer _constraintbool _trainable _autocast _aggregation_synchronization_layout_overwrite_with_gradient keras.srcrgetcallable_convert_to_tensorrstandardize_dtype_dtyper _value_validate_shaperegister_uninitialized_variable_initialize_with_initializer _initializeshapelen_ndim) self initializerr9r trainableautocast aggregationsynchronizationnamelayoutkwargs parent_pathrs w/var/www/html/emotional.easysim.app/public_html/venv/lib/python3.12/site-packages/keras/src/backend/common/variables.py__init__zVariable.__init__^sq9y!8!89$$t ""&)    )*5 7    K #  -.=,=?   "$O "n '=$0DJDJ   y/h' / ).% k3 ' .&**;7K K } --8M:!!&)11+U1KK}#))'.   $" $/!"2259 /5 C$ $"2259 11+>  -"224;;3D3DE % c|j.tjrytd|jdt r td|j |jd|_y)Nz Variable z is already initialized.zYou are attempting to initialize a variable while in a stateless scope. This is disallowed. Make sure that all variables are initialized before you start using your layer/model objects.)r4ris_nnx_enabledr pathr r7r$r<s rF_deferred_initializezVariable._deferred_initializesm ;; "$$&y 3KLM M  C  ))$*;*;< rHc\t|}d|vrtd|d|jd|S)NzbShapes used to initialize variables must be fully-defined (no `None` dimensions). Received: shape=z for variable path='')standardize_shaper rK)r<r9s rFr5zVariable._validate_shapesD!%( 5=3DII;aA   rHcXt}|jr||j|S|SN)get_autocast_scoper) maybe_cast)r<valueautocast_scopes rF_maybe_autocastzVariable._maybe_autocasts,+- >>n8!,,U3 3 rHc,tj|SrR)nparrayrLs rFnumpyzVariable.numpysxx~rHc|jS)z+The strategy for aggregating this variable.)r*rLs rFr@zVariable.aggregations   rHc|jS)z-The strategy for synchronizing this variable.)r+rLs rFrAzVariable.synchronizations$$$rHc,tr.t}|j|}||j|S|j6|j|j |j |jS|j|jS)zBThe current value of the variable (numpy array or backend tensor).r)r r get_current_valuerWr4r$r#r3)r<scoperUs rFrUzVariable.values  ')E++D1E ++E22 ;;  ''!!$++T[[!A ##DKK00rHcD|j||j}t|j|js(t d|jd|jd|t rt }|j||f|S|j||S)NrzzThe shape of the target variable and the shape of the target value in `variable.assign(value)` must match. variable.shape=z, Received: value.shape=z. Target variable: ) r1r3 shape_equalr9r r r add_update_direct_assign)r<rUr`s rFassignzVariable.assigns''T[['A5;; 3"#'**.)). 6$$(6 +   ')E   dE] +     & rHc*|j||zSrRrer<rUs rF assign_addzVariable.assign_add,{{4%<((rHc*|j||z SrRrgrhs rF assign_subzVariable.assign_sub/rjrHct}|jr$|"t|jr |j}n |j}t j |S)zThe data type of the variable.)rSr)is_float_dtyper3rrr2)r<rVrs rFrzVariable.dtype2sJ,- NN*t{{+"((EKKE((//rHc|jS)zThe shape of the variable.)r#rLs rFr9zVariable.shape@s{{rHc|jS)z)The number of dimensions of the variable.)r;rLs rFndimz Variable.ndimEzzrHc|jS)z"Whether the variable is trainable.)r(rLs rFr>zVariable.trainableJsrHc$t||_yrR)r'r(rhs rFr>zVariable.trainableOs u+rHc|jS)zThe name of the variable.)r!rLs rFrBz Variable.nameSrrrHc|jS)z9The path of the variable within the Keras model or layer.)r"rLs rFrKz Variable.pathXrrrHc|jS)aWhether this variable should be overwritten by the gradient. This property is designed for a special case where we want to overwrite the variable directly with its computed gradient. For example, in float8 training, new `scale` and `amax_history` are computed as gradients, and we want to overwrite them directly instead of following the typical procedure such as gradient descent with a learning rate, gradient clipping and weight decaying. )r-rLs rFoverwrite_with_gradientz Variable.overwrite_with_gradient]s,,,rHcNt|tstd|||_y)Nz7`overwrite_with_gradient` must be a boolean. Received: )rr' TypeErrorr-rhs rFrxz Variable.overwrite_with_gradientjs2%&"G% ).%rHc|jSrR)r%rLs rF regularizerzVariable.regularizerss   rHcH|t|std|||_y)NzInvalid value for attribute `regularizer`. Expected a callable (such as a `keras.regularizers.Regularizer` instance) or `None`. Received: regularizer=)r0r r%rhs rFr|zVariable.regularizerws5  Xe_>>CWF  "rHc|jSrR)r&rLs rF constraintzVariable.constraintsrHcH|t|std|||_y)NzInvalid value for attribute `constraint`. Expected a callable (such as a `keras.constraints.Constraint` instance) or `None`. Received: constraint=)r0r r&rhs rFrzVariable.constraints4  Xe_338';  !rHcd}t|dr6|j* tjj |j}|d|nd}d|j d|j d|j|dS#Y9xYw)Nr4z, value=z)hasattrr4rcoreconvert_to_numpyrKr9r)r<rU value_strs rF__repr__zVariable.__repr__s 4 "t{{'>  55dkkB+0*;hug& dii[ =ZZL 1 .  s )A::A>ctrRNotImplementedErrorrhs rFr8zVariable._initialize!!rHc|j||j|j}|j|y)Nr)r1r#r3r8)r<r=rUs rFr7z%Variable._initialize_with_initializers4''  4;; 7  rHctrRr)r<rUrs rFr1zVariable._convert_to_tensorrrHc8|jj|SrR)rU __getitem__)r<idxs rFrzVariable.__getitem__szz%%c**rHcz|jdkDrtd|jt|jSNrzBOnly scalar arrays can be converted to Python scalars. Got: shape=)rqrzr9intrUrLs rF__int__zVariable.__int__s= 99q="jj\+ 4::rHcz|jdkDrtd|jt|jSr)rqrzr9floatrUrLs rF __float__zVariable.__float__s> 99q="jj\+ TZZ  rHc^tj|jj|SrR)rYasarrayrU __array__r<rs rFrzVariable.__array__s" zz$**..u566rHctd)Nz-A Keras Variable cannot be used as a boolean.)rzrLs rF__bool__zVariable.__bool__sGHHrHc6|jjSrR)rU__neg__rLs rFrzVariable.__neg__zz!!##rHc|jSrR)rUrLs rF__pos__zVariable.__pos__s zzrHc6|jjSrR)rU__abs__rLs rFrzVariable.__abs__rrHc6|jjSrR)rU __invert__rLs rFrzVariable.__invert__szz$$&&rHcVtjj|j|SrR)rr[equalrUr<others rF__eq__zVariable.__eq__}}""4::u55rHcVtjj|j|SrR)rr[ not_equalrUrs rF__ne__zVariable.__ne__s}}&&tzz599rHcVtjj|j|SrR)rr[lessrUrs rF__lt__zVariable.__lt__s}}!!$**e44rHcVtjj|j|SrR)rr[ less_equalrUrs rF__le__zVariable.__le__}}'' E::rHcVtjj|j|SrR)rr[greaterrUrs rF__gt__zVariable.__gt__s}}$$TZZ77rHcVtjj|j|SrR)rr[ greater_equalrUrs rF__ge__zVariable.__ge__s}}**4::u==rHcVtjj|j|SrRrr[addrUrs rF__add__zVariable.__add__}}  U33rHcVtjj||jSrRrrs rF__radd__zVariable.__radd__}}   33rHcVtjj|j|SrRrr[subtractrUrs rF__sub__zVariable.__sub__}}%%djj%88rHcVtjj||jSrRrrs rF__rsub__zVariable.__rsub__}}%%eTZZ88rHcVtjj|j|SrRrr[multiplyrUrs rF__mul__zVariable.__mul__rrHcVtjj||jSrRrrs rF__rmul__zVariable.__rmul__rrHcVtjj|j|SrRrr[ true_dividerUrs rF __truediv__zVariable.__truediv__}}((U;;rHcVtjj||jSrRrrs rF __rtruediv__zVariable.__rtruediv__}}(( ;;rHcVtjj|j|SrRrr[ floor_dividerUrs rF __floordiv__zVariable.__floordiv__s}}))$**e<setterrBrKrxr|rrr8r7r1rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rHrFrrsyLb x&t!& !!%%11"$)) 0 0&& - -##.$.!!""  !!  " "+!7I$$'6:5;8>449999<<==446677<<;;<<BrHrcVtjdgd}|j|y)Nuninitialized_variablesT)set_to_default)rget_global_attributeappend)variablers rFr6r6+s**??!2d""8,rHctjd}|r|D]}|jtjdgy)Nr)rrrMset_global_attribute) collectionvs rFinitialize_all_variablesr2sB223LMJ %A " " $ %%%&?DrHzkeras.utils.standardize_dtypezkeras.backend.standardize_dtypec|tjStjj ||}t |dr |j }n\t |dr |j}nCt |dr7dt|vs dt|vrt|jdd}|tjvrtd||S) NrBr__str__torchz jax.numpy.zInvalid dtype: ) rfloatxrPYTHON_DTYPES_MAPr/rrBrrsplitALLOWED_DTYPESr rs rFr2r2:s }}}  $ $ ( ( 6Euf   #  "3u:E !:E   %b) F)))?5'233 LrHc 2t|tsi| tdt|dstd|dt j dk(r*t|t jr|j}t j dk(rddl m tfd |D}t j d k(rddl tfd |D}g}|D]{}||j|t|ttfrtd|d |d t|d t!|}|dkrtd|d|j|}t|S#t"$r$}td|d |d t|d|d}~wwxYw)Nz#Undefined shapes are not supported.__iter__zCannot convert 'z ' to a shape.r jaxr)exportc3HK|]}j|rdn|ywrR)is_symbolic_dim).0d jax_exports rF z$standardize_shape.._s( =>J..q1Dq 8 s"rc3RK|]}t|jrdn| ywrR)rSymInt)r+r,rs rFr.z$standardize_shape..hs#PQjELL9dq@Ps$'z'' to a shape. Found invalid dimension 'z ' of type 'z'. z2' to a shape. Negative dimensions are not allowed.)rtupler rrrtf TensorShapeas_listr'r(rrrrtyper Exception)r9standardized_shaper,er-rs @@rFrPrPOs eU # =BC Cuj)/wmDE E >> | +%0  ~~5 , BG  ~~7" P%PP % 9  % %a (  a#u &"5'*,,-3k$q'#G   AA q5"5'*77  !!!$3%8 # $$ "5'*,,-3k$q'#G  s, E)) F2FFcvt|t|k7ryt||D]\}}| | ||k7syy)z8Return whether a_shape == b_shape (allows None entries).FT)r:zip)a_shapeb_shapee1e2s rFrbrbsF 7|s7|#gw'B >bnr rHzkeras.backend.is_float_dtypec`t|}|jdxs|jdS)Nrbfloatr2 startswithrs rFrnrns- e $E   G $ B(8(8(BBrHzkeras.backend.is_int_dtypec`t|}|jdxs|jdS)NruintrArs rF is_int_dtyperEs- e $E   E " >e&6&6v&>>rHc,tjdSNrV)rrrrHrFrSrSs  , ,-= >>rHc(eZdZdZdZdZdZdZy) AutocastScopezContext manager that enables the autocasting of float variables. Under this context manager, float `Variables`s will be cast to `dtype` (note that `dtype` must also be float). cl|$t|}t|std|||_d|_y)Nzh`AutocastScope` can only be used with a floating-point target dtype, such as 'float16'. Received: dtype=)r2rnr roriginal_scopers rFrGzAutocastScope.__init__sG  %e,E!%( '',g/  "rHcddlm}|j3t|jr|j||jS|S)Nrrr)r.rrrncast)r<rUrs rFrTzAutocastScope.maybe_casts6% :: !nU[[&A7<<TZZ8 8 rHcNt|_tjd|yrG)rSrKrrrLs rF __enter__zAutocastScope.__enter__s02))*:DArHcDtjd|jyrG)rrrK)r<argsrDs rF__exit__zAutocastScope.__exit__s))*:DrZs-$+1<HG9,YBYBx-E$&GH$9%x,-C.C *+?,? ?QQrH