
    ij                        d dl mZ d dl mZ d dlmZ  ed       G d d             Z eddg       G d	 d
e             Z eddg       G d de             Z eddg       G d de             Z eddg       G d de             Z	y)    )backend)ops)keras_exportzkeras.constraints.Constraintc                   ,    e Zd ZdZd Zd Zed        Zy)
ConstraintaG  Base class for weight constraints.

    A `Constraint` instance works like a stateless function.
    Users who subclass this
    class should override the `__call__()` method, which takes a single
    weight parameter and return a projected version of that parameter
    (e.g. normalized or clipped). Constraints can be used with various Keras
    layers via the `kernel_constraint` or `bias_constraint` arguments.

    Here's a simple example of a non-negative weight constraint:

    >>> class NonNegative(keras.constraints.Constraint):
    ...
    ...  def __call__(self, w):
    ...    return w * ops.cast(ops.greater_equal(w, 0.), dtype=w.dtype)

    >>> weight = ops.convert_to_tensor((-1.0, 1.0))
    >>> NonNegative()(weight)
    [0.,  1.]

    Usage in a layer:

    >>> keras.layers.Dense(4, kernel_constraint=NonNegative())
    c                     |S )ak  Applies the constraint to the input weight variable.

        By default, the inputs weight variable is not modified.
        Users should override this method to implement their own projection
        function.

        Args:
            w: Input weight variable.

        Returns:
            Projected variable (by default, returns unmodified inputs).
         selfws     v/var/www/html/emotional.easysim.app/public_html/venv/lib/python3.12/site-packages/keras/src/constraints/constraints.py__call__zConstraint.__call__!   s	         c                     i S )a  Returns a Python dict of the object config.

        A constraint config is a Python dictionary (JSON-serializable) that can
        be used to reinstantiate the same object.

        Returns:
            Python dict containing the configuration of the constraint object.
        r	   r   s    r   
get_configzConstraint.get_config0   s	     	r   c                      | di |S )a  Instantiates a weight constraint from a configuration dictionary.

        Example:

        ```python
        constraint = UnitNorm()
        config = constraint.get_config()
        constraint = UnitNorm.from_config(config)
        ```

        Args:
            config: A Python dictionary, the output of `get_config()`.

        Returns:
            A `keras.constraints.Constraint` instance.
        r	   r	   )clsconfigs     r   from_configzConstraint.from_config;   s    $ }V}r   N)__name__
__module____qualname____doc__r   r   classmethodr   r	   r   r   r   r      s%    2	  r   r   zkeras.constraints.MaxNormzkeras.constraints.max_normc                   $    e Zd ZdZddZd Zd Zy)MaxNormaz  MaxNorm weight constraint.

    Constrains the weights incident to each hidden unit
    to have a norm less than or equal to a desired value.

    Also available via the shortcut function `keras.constraints.max_norm`.

    Args:
        max_value: the maximum norm value for the incoming weights.
        axis: integer, axis along which to calculate weight norms.
            For instance, in a `Dense` layer the weight matrix
            has shape `(input_dim, output_dim)`,
            set `axis` to `0` to constrain each weight vector
            of length `(input_dim,)`.
            In a `Conv2D` layer with `data_format="channels_last"`,
            the weight tensor has shape
            `(rows, cols, input_depth, output_depth)`,
            set `axis` to `[0, 1, 2]`
            to constrain the weights of each filter tensor of size
            `(rows, cols, input_depth)`.

    c                      || _         || _        y N	max_valueaxis)r   r!   r"   s      r   __init__zMaxNorm.__init__i   s    "	r   c                 t   t        j                  |      }t        j                  t        j                  t        j
                  |      | j                  d            }t        j                  |d| j                        }t        j                  ||j                        |t        j                         |z   z  z  S )NTr"   keepdimsr   )r   convert_to_tensorr   sqrtsumsquarer"   clipr!   castdtypeepsilonr   r   normsdesireds       r   r   zMaxNorm.__call__m   s    %%a(ATYYNO((5!T^^4xx5;;'w(501
 	
r   c                 4    | j                   | j                  dS )Nr    r    r   s    r   r   zMaxNorm.get_configu   s    !^^TYY??r   N)   r   r   r   r   r   r#   r   r   r	   r   r   r   r   P   s    .
@r   r   zkeras.constraints.NonNegzkeras.constraints.non_negc                       e Zd ZdZd Zy)NonNegz*Constrains the weights to be non-negative.c                 X    t        j                  |      }t        j                  |d      S )Nr   )r   r'   r   maximumr
   s     r   r   zNonNeg.__call__}   s#    %%a({{1a  r   N)r   r   r   r   r   r	   r   r   r6   r6   y   s
    4!r   r6   zkeras.constraints.UnitNormzkeras.constraints.unit_normc                   $    e Zd ZdZddZd Zd Zy)UnitNorma  Constrains the weights incident to each hidden unit to have unit norm.

    Args:
        axis: integer, axis along which to calculate weight norms.
            For instance, in a `Dense` layer the weight matrix
            has shape `(input_dim, output_dim)`,
            set `axis` to `0` to constrain each weight vector
            of length `(input_dim,)`.
            In a `Conv2D` layer with `data_format="channels_last"`,
            the weight tensor has shape
            `(rows, cols, input_depth, output_depth)`,
            set `axis` to `[0, 1, 2]`
            to constrain the weights of each filter tensor of size
            `(rows, cols, input_depth)`.
    c                     || _         y r   r"   )r   r"   s     r   r#   zUnitNorm.__init__   s	    	r   c                 ,   t        j                  |      }t        j                  t        j                  t        j
                  |      | j                  d            }t        j                  ||j                        t        j                         |z   z  S )NTr%   )
r   r'   r   r(   r)   r*   r"   r,   r-   r.   )r   r   r0   s      r   r   zUnitNorm.__call__   s_    %%a(ATYYNOxx5;;'7??+<u+DEEr   c                     d| j                   iS )Nr"   r<   r   s    r   r   zUnitNorm.get_config   s    		""r   N)r   r4   r	   r   r   r:   r:      s     F
#r   r:   zkeras.constraints.MinMaxNormzkeras.constraints.min_max_normc                   $    e Zd ZdZddZd Zd Zy)
MinMaxNorma  MinMaxNorm weight constraint.

    Constrains the weights incident to each hidden unit
    to have the norm between a lower bound and an upper bound.

    Args:
        min_value: the minimum norm for the incoming weights.
        max_value: the maximum norm for the incoming weights.
        rate: rate for enforcing the constraint: weights will be
            rescaled to yield
            `(1 - rate) * norm + rate * norm.clip(min_value, max_value)`.
            Effectively, this means that rate=1.0 stands for strict
            enforcement of the constraint, while rate<1.0 means that
            weights will be rescaled at each step to slowly move
            towards a value inside the desired interval.
        axis: integer, axis along which to calculate weight norms.
            For instance, in a `Dense` layer the weight matrix
            has shape `(input_dim, output_dim)`,
            set `axis` to `0` to constrain each weight vector
            of length `(input_dim,)`.
            In a `Conv2D` layer with `data_format="channels_last"`,
            the weight tensor has shape
            `(rows, cols, input_depth, output_depth)`,
            set `axis` to `[0, 1, 2]`
            to constrain the weights of each filter tensor of size
            `(rows, cols, input_depth)`.
    c                 <    || _         || _        || _        || _        y r   	min_valuer!   rater"   )r   rC   r!   rD   r"   s        r   r#   zMinMaxNorm.__init__   s    ""		r   c                    t        j                  |      }t        j                  t        j                  t        j
                  |      | j                  d            }| j                  t        j                  || j                  | j                        z  d| j                  z
  |z  z   }t        j                  ||j                        |t        j                         |z   z  z  S )NTr%      )r   r'   r   r(   r)   r*   r"   rD   r+   rC   r!   r,   r-   r.   r/   s       r   r   zMinMaxNorm.__call__   s    %%a(ATYYNOIIGG499}%& 	 xx5;;'w(501
 	
r   c                 `    | j                   | j                  | j                  | j                  dS )NrB   rB   r   s    r   r   zMinMaxNorm.get_config   s(    IIII	
 	
r   N)g              ?rH   r   r4   r	   r   r   r@   r@      s    8	

r   r@   N)
	keras.srcr   r   keras.src.api_exportr   r   r   r6   r:   r@   r	   r   r   <module>rK      s      - ,-F F .FR *,HIJ%@j %@ K%@P )+FGH!Z ! I! +-JKL#z # M#: #%EF4
 4
4
r   