o 2hW@sNddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddl m Z ddl m Z dd lmZ ed d gGd d d ZedddedfddZedGdddeZddZGdddeZed   d.ddZ edd/d d!Zed"d#d$Zed%d&d'Zed(d/d)d*Zed+d/d,d-ZdS)0N)backend)ops) keras_export) KerasTensor)any_symbolic_tensors)canonicalize_axis)standardize_axis_for_numpy) Operationzkeras.Quantizerzkeras.quantizers.Quantizerc@s2eZdZd ddZddZeddZdd Zd S) Quantizerint8cCs ||_dSN output_dtype)selfrrZ/var/www/html/chatgem/venv/lib/python3.10/site-packages/keras/src/quantizers/quantizers.py__init__s zQuantizer.__init__cCs|S)z0Compute a quantized output from an input tensor.r)rxrrr__call__szQuantizer.__call__cCs|di|S)aCreates a quantizer from its config. This method is the reverse of `get_config`, capable of instantiating the same quantizer from the config dictionary. This method is used by Keras `model_to_estimator`, saving and loading models to HDF5 formats, Keras model cloning, some visualization utilities, and exporting models to and from JSON. Args: config: A Python dictionary, typically the output of get_config. Returns: A quantizer instance. Nrr)clsconfigrrr from_configzQuantizer.from_configcCst|d)aReturns the config of the quantizer. A quantizer config is a Python dictionary (serializable) containing all configuration parameters of the quantizer. The same quantizer can be reinstantiated later (without any saved state) from this configuration. This method is optional if you are just training and executing models, exporting to and from SavedModels, or using weight checkpoints. This method is required for Keras `model_to_estimator`, saving and loading models to HDF5 formats, Keras model cloning, some visualization utilities, and exporting models to and from JSON. Returns: Python dictionary. z does not implement get_config())NotImplementedErrorrrrr get_config-rzQuantizer.get_configN)r )__name__ __module__ __qualname__rr classmethodrrrrrrr s    r z!keras.quantizers.abs_max_quantizeir Fc Cs|rKt|j}t|}t|}t|dttj t ||dd|}t ||}t t ||d|d}||}t|tj||dfSt|}t|dttj t ||dd|}t|t|j}t ||}t t ||d|d}t||}||fS)NT)axiskeepdimsrdtype)rstandardize_dtyper&rconvert_to_numpyrnpdivideaddmaxabsmultiplycliproundastypeconvert_to_tensorcast) inputsr# value_ranger&epsilonto_numpyoriginal_dtypescaleoutputsrrrabs_max_quantizeBs0        r;z keras.quantizers.AbsMaxQuantizerc@s0eZdZdedfddZddZddZd S) AbsMaxQuantizerr r cCs8tj||dt|tr|f}t||_||_||_dS)Nr )r r isinstanceinttupler#r5r6)rr#r5r6rrrrris    zAbsMaxQuantizer.__init__cCs$t||j|j|j|j\}}||fSr )r;r#r5rr6)rr quantized_xr9rrrrwszAbsMaxQuantizer.__call__cCs|j|j|j|jdS)Nr#r5r6rrArrrrr}s zAbsMaxQuantizer.get_configN)rrrrr6rrrrrrrr<gs  r<cCst|jd}t||}t||}d|>d}|sdnd}t||}t|||}t|||} |t||} t| ||} t| } t t|| |} t t|| |}| ||| fS)z>Adjusts and nudges the quantization range for better accuracy.float32r"r) r result_typer&rr3subtractr*r/r0r.) min_range max_rangenum_bits narrow_range compute_dtype quant_max quant_min diff_ranger9 inv_scalezero_point_from_min zero_pointnudged_zero_point nudged_min nudged_maxrrradjust_and_nudges       rScs.eZdZd fdd ZddZdd ZZS) FakeQuantWithMinMaxVarsFNcs t||_||_||_dSr )superrrGrHr#)rrGrHr# __class__rrrs  z FakeQuantWithMinMaxVars.__init__cCst||||j|j|jdS)N)rGrHr#)fake_quant_with_min_max_varsrGrHr#rr4min_valsmax_valsrrrcallszFakeQuantWithMinMaxVars.callcCst|j|jdS)Nr%)rshaper&rZrrrcompute_output_specsz+FakeQuantWithMinMaxVars.compute_output_specrUFN)rrrrr]r_ __classcell__rrrWrrTs rTz-keras.quantizers.fake_quant_with_min_max_varsrUc sLt|fr t|||St|}t|}t|}tdur*t|jtdkrddl }t |j }durd|j j t|dtt|ddtt|ddd}tj||dS|jd} t|| }|j jt|dt|dt|dd}tj||d}t|| Stjfd d } | |||S) auPerform per-tensor or per-channel fake quantization. `[min_vals, max_vals]` define the clamping range for the `inputs`. The `inputs` are quantized into the quantization range: - `[0, 2^num_bits - 1]` when `narrow_range=False` - `[1, 2^num_bits - 1]` when `narrow_range=True` After quantization, the values are dequantized and output as floats within the `[min_vals, max_vals]` interval. This operation supports gradient computation, allowing `min_vals` and `max_vals` to be trained. Args: inputs: Input Keras tensor of float dtype. min_vals: A global minimum scalar or a per-channel minimum tensor. max_vals: A global maximum scalar or a per-channel maximum tensor. num_bits: Quantization bit width (e.g., `8` for int8). Defaults to `8`. narrow_range: Whether to use narrow quantization range. Defaults to `False`. axis: Axis along which to perform per-channel quantization. If `None`, per-tensor quantization is performed. Defaults to `None`. Returns: Tensor: A Keras tensor with fake quantization applied. N tensorflowrrBr)rGrHr%r"c stj}t||\}}ttt |d}tt jt j}t |}tttt t|||d|} tj | |d} t t t ddfdd } | | fS)Ng?r%)upstreamcs|dur|\}t|d}fddtt|jD}t}t||d}dur5tj||d}nt|}t}t||d}durStj||d}nt|}|||fS)Ncg|]}|kr|qSrr.0ir#rr 6zqfake_quant_with_min_max_vars.._fake_quant_with_min_max_vars_per_channel..grad..ri)rwhererangelenr^ less_equalsum greater_equal)rcargsdxaxesmin_maskgrad_minmax_maskgrad_max)r#masksrRrQrrrgrad0s     z]fake_quant_with_min_max_vars.._fake_quant_with_min_max_vars_per_channel..grad)rr'r&rSrfloorr+r.r/r3rD logical_andrqro) rmin_valmax_valr&r9rM quant_zero x_clampedx_clamped_shiftedresultrzr#rHrG)ryrRrQrr)_fake_quant_with_min_max_vars_per_channels8     zOfake_quant_with_min_max_vars.._fake_quant_with_min_max_vars_per_channel)rrT symbolic_callrr2r>rndimrrbr'r& quantizationrYr3reshapeswapaxes(fake_quant_with_min_max_vars_per_channelcustom_gradient) r4r[r\rGrHr#tfr&r: last_axisrrrrrYsH %            ?rYz%keras.quantizers.compute_float8_scalecCsRt|}tt||d|}t|dk||}tt|||}t|S)Nrd)r reciprocalr*rlisfinite)amaxr9 dtype_maxmarginsfrrrcompute_float8_scaleTs  rz,keras.quantizers.compute_float8_amax_historycCsDttt||j}ttj|dddggt|dg}|S)N)shiftrr")rr3r,r-r&scatter_updaterollr)r amax_history amax_updatenew_amax_historyrrrcompute_float8_amax_historyas  rz(keras.quantizers.quantize_and_dequantizecCshttt|j|}t|t||}t|| |}t||}tt||t||}|Sr ) rr3float ml_dtypesfinfor,r*r/r.)r4r9quantized_dtyperIquantized_dtype_maxrrrrquantize_and_dequantizels rzkeras.quantizers.pack_int4csxt|jdkrtd|jt|jddpt|j}dkr$|7gfddt|Dfddt|D}t |}t |d}t t |d d }|dd d fd}t j ||gdd }|t |d } |d| d f} | ddd d f} | d dd d f} t jddd} t | | }t | | }t |t |d}t |d}t ||}|}|t ||fS)a Pack an int4 tensor into an int8 tensor with packed nibbles. The input values must already be int8 in the signed range `[-8, 7]` and represent the desired int4 values. Packing is performed along the specified axis (default is 0). For every two consecutive rows, the **low nibble** of the output byte stores the value from the first row, and the **high nibble** stores the value from the second row. Args: arr: An int8 tensor containing int4 values in the range `[-8, 7]`. axis: The axis along which to pack the tensor. Defaults to 0. Returns: tuple: A tuple `(packed, packed_shape, orig_rows)` where `packed` is the packed int8 tensor with int4 values stored in nibbles, `packed_shape` is the shape of the packed tensor, and `orig_rows` is the original (unpacked) row count prior to any padding that may have been inserted when an odd number of rows is supplied. Example: ```python >>> import numpy as np >>> from keras.quantizers import pack_int4, unpack_int4 # Example with axis=0 # Original array has shape (3, 2) >>> original_array = np.array([[-3, 7], [2, -8], [1, 0]], dtype=np.int8) # Pack the array along axis 0. Since the length of axis 0 (3) is # odd, it will be padded to a length of 4. The packed array will # have a shape of (ceil(3/2), 2) = (2, 2). >>> packed, packed_shape, orig_len = pack_int4(original_array, axis=0) >>> print("Packed array: ", packed) Packed array: [[ 45 -121] [ 1 0]] # Now, unpack the array back to its original form >>> unpacked = unpack_int4(packed, orig_len, axis=0) >>> print("Unpacked array: ", unpacked) Unpacked array: [[-3 7] [ 2 -8] [ 1 0]] >>> np.allclose(original_array, unpacked) True # Example with axis=1 # Original array has shape (2, 3) >>> original_array = np.array([[-3, 7, 2], [-8, 1, 0]], dtype=np.int8) # Pack along axis 1. Length of axis 1 (3) is padded to 4. # The new shape is (2, ceil(3/2)) = (2, 2). >>> packed, packed_shape, orig_len = pack_int4(original_array, axis=1) >>> print("Packed array: ", packed) Packed array: [[ 125 2] [ 24 0]] # Unpack the array >>> unpacked = unpack_int4(packed, orig_len, axis=1) >>> print("Unpacked array: ", unpacked) Unpacked array: [[-3 7 2] [-8 1 0]] >>> np.allclose(original_array, unpacked) True ``` r z(Expected int8 tensor for packing, got {}rankNrcrerrrfrirrrjrkzpack_int4..cg|]}|qSrindexrfpermrrrjrr".riint32r%)rr'r& TypeErrorformatgetattrr^rnrmr transposeequalmod concatenater3array bitwise_and bitwise_or left_shift)arrr#rinv_perm transposedrows needs_padzero_row padded_full rows_packedpaddedlowhighmasklow_uhigh_upackedorig_lenr)r#rr pack_int4{s4J      rzkeras.quantizers.unpack_int4cst|jdkrtd|jt|jddpt|j}dkr$|7dkr||dkr|tjd|jd}t ||}t t |d |}t |d k||d }t |d k||d }tj ||gd d } t | dtt|d d} | d|dfSgfddt|Dfddt|D} t|} tjddd}t | |} t t | d |}tjd ddtjd ddfdd}|| } ||}tj | |gd d } t | dtt| d d} | d|df} t| | } | S)a Unpack a packed int4 back to an int8 tensor in the range [-8, 7]. This function reverses the packing performed by `pack_int4`, restoring the original int8 tensor (values in the range [-8, 7]) from a packed int8 tensor where each element contains two int4 values (one in the lower nibble, one in the upper nibble). The function restores the original axis order and removes any padding that was added during packing. Args: packed: An int8 tensor containing packed int4 values along the specified axis. Each int8 value encodes two int4 values. orig_len: The original (unpadded) length of the axis that was packed. This is used to remove any padding that may have been added during packing to ensure an even number of rows. axis: The axis along which the tensor was packed. Defaults to 0. Returns: unpacked: An int8 tensor with the same shape as the original (unpacked) tensor, with values in the range [-8, 7]. Example: ```python >>> import numpy as np >>> from keras.quantizers import pack_int4, unpack_int4 # Example with axis=0 # Original array has shape (3, 2) >>> original_array = np.array([[-3, 7], [2, -8], [1, 0]], dtype=np.int8) # Pack the array along axis 0. Since the length of axis 0 (3) is # odd, it will be padded to a length of 4. The packed array will # have a shape of (ceil(3/2), 2) = (2, 2). >>> packed, packed_shape, orig_len = pack_int4(original_array, axis=0) >>> print("Packed array: ", packed) Packed array: [[ 45 -121] [ 1 0]] # Now, unpack the array back to its original form >>> unpacked = unpack_int4(packed, orig_len, axis=0) >>> print("Unpacked array: ", unpacked) Unpacked array: [[-3 7] [ 2 -8] [ 1 0]] >>> np.allclose(original_array, unpacked) True # Example with axis=1 # Original array has shape (2, 3) >>> original_array = np.array([[-3, 7, 2], [-8, 1, 0]], dtype=np.int8) # Pack along axis 1. Length of axis 1 (3) is padded to 4. # The new shape is (2, ceil(3/2)) = (2, 2). >>> packed, packed_shape, orig_len = pack_int4(original_array, axis=1) >>> print("Packed array: ", packed) Packed array: [[ 125 2] [ 24 0]] # Unpack the array >>> unpacked = unpack_int4(packed, orig_len, axis=1) >>> print("Unpacked array: ", unpacked) Unpacked array: [[-3 7 2] [-8 1 0]] >>> np.allclose(original_array, unpacked) True ``` r z(Expected int8 tensor for unpacking, got rNrrrr%rrUr"ri)r.crerrrfrirrrjbrkzunpack_int4..crrrrfrrrrjcrcst|k||Sr )rrl)r)eightsixteenrr to_signednszunpack_int4..to_signed)rr'r&rrr^rnrrr right_shiftrlstackrr?rmr)rrr#rr low_unpacked high_unpacked low_signed high_signedstackedunpackedrrrrrr)r#rrrr unpack_int4sHK  "  " rr`)r)rnumpyr) keras.srcrrkeras.src.api_exportrkeras.src.backendrr&keras.src.backend.common.backend_utilsrrkeras.src.ops.operationr r r6r;r<rSrTrYrrrrrrrrrsP         1 $!     z