/usr/local/lib64/python3.6/site-packages/torch/ao/quantization/__pycache__
Edit: /usr/local/lib64/python3.6/site-packages/torch/ao/quantization/__pycache__/observer.cpython-36.pyc (39227B)
3
Eg9 @ s U d dl Z d dlZd dlmZmZ d dlmZ d dlmZ d dl m
Z
m Z m Z m
Z
mZmZ d dlZd dljZd dlmZmZ G dd deZd d
Zd d Zeed
efi Ze
G dd deej Z G dd de Z G dd de Z G dd de Z G dd de Z!G dd de!Z"G dd de Z#G d d d e Z$G d d d e Z%G d d! d!e Z&d"d# Z'd$d% Z(d&d' Z)d(d) Z*d*d+ Z+e j,d,d-Z-e$Z.e%Z/e j,ej0ej1d.Z2e#j,d,d-Z3e!j,ej0ej4d.Z5e$j,ej6ej7d/Z8e!j,ej7ej9d d0Z:dS )1 N)ABCMetaabstractmethod) OrderedDict)partial)AnyListTupleOptionalDictUnion)check_min_max_validcalculate_qmin_qmaxc @ s4 e Zd Zdd Zdd Zdd Zdd Zd d
Zd S ) _PartialWrapperc C s || _ i | _d S )N)p
callable_args)selfr r J/usr/local/lib64/python3.6/site-packages/torch/ao/quantization/observer.py__init__ s z_PartialWrapper.__init__c O s8 x*| j D ] }||kr||| j | i}qW | j||S )N)r r )r argskeywordsZarg_namer r r __call__ s z_PartialWrapper.__call__c C s | j j | jj S )N)r __repr__r )r r r r r s z_PartialWrapper.__repr__c K s t | f|S )N)
_with_args)r kwargsr r r with_args s z_PartialWrapper.with_argsc K s t | jd}| j||_|S )N)r )r r r )r r resultr r r with_callable_args s z"_PartialWrapper.with_callable_argsN)__name__
__module__ __qualname__r r r r r r r r r r
s
r c K s t t| f|}|S )a Wrapper that allows creation of class factories.
This can be useful when there is a need to create classes with the same
constructor arguments, but different instances. Can be used in conjunction with
_callable_args
Example::
>>> Foo.with_args = classmethod(_with_args)
>>> foo_builder = Foo.with_args(a=3, b=4).with_args(answer=42)
>>> foo_instance1 = foo_builder()
>>> foo_instance2 = foo_builder()
>>> id(foo_instance1) == id(foo_instance2)
False
)r r ) cls_or_selfr rr r r r & s r c K s t t| }|jf |S )a Wrapper that allows creation of class factories args that need to be
called at construction time.
This can be useful when there is a need to create classes with the same
constructor arguments, but different instances and those arguments should only
be calculated at construction time. Can be used in conjunction with _with_args
Example::
>>> Foo.with_callable_args = classmethod(_with_callable_args)
>>> Foo.with_args = classmethod(_with_args)
>>> foo_builder = Foo.with_callable_args(cur_time=get_time_func).with_args(name="dan")
>>> foo_instance1 = foo_builder()
>>> wait 50
>>> foo_instance2 = foo_builder()
>>> id(foo_instance1.creation_time) == id(foo_instance2.creation_time)
False
)r r r )r! r r" r r r _with_callable_args9 s r# ABCc sH e Zd ZdZ fddZedd Zedd Zee Z
ee Z Z
S ) ObserverBasea Base observer Module.
Any observer implementation should derive from this class.
Concrete observers should follow the same API. In forward, they will update
the statistics of the observed Tensor. And they should provide a
`calculate_qparams` function that computes the quantization parameters given
the collected statistics.
Args:
dtype: Quantized data type
c s t t| j || _d S )N)superr% r dtype)r r' ) __class__r r r ` s zObserverBase.__init__c C s d S )Nr )r xr r r forwardd s zObserverBase.forwardc K s d S )Nr )r r r r r calculate_qparamsh s z ObserverBase.calculate_qparams)r r r __doc__r r r* r+ classmethodr r r# r
__classcell__r r )r( r r% S s r% c s e Zd ZU dZdZejejej ddddfdd fdd
Z
fdd Z ej j
eedd
d d Zej j
ejejeejejf d
ddZej j
dd Z ZS )
_ObserverBasea Internal common base for all qint/quint8 observers.
This base is for commonly used parameters used internally.
Users should use `~torch.quantization.observer.ObserverBase` as a base class
for custom observers.
Args:
dtype: Quantized data type.
qscheme: Quantization scheme to be used.
reduce_range: Reduces the range of the quantized data type by 1 bit.
This is sometimes required to avoid instruction overflow.
quant_min: Minimum quantization value. If unspecified, it will follow the 8-bit setup.
quant_max: Maximum quantization value. If unspecified, it will follow the 8-bit setup.
.. warning::
:attr:`dtype` can only take ``torch.qint8`` or ``torch.quint8``.
.. warning::
:attr:`qscheme` can only take one of the following options:
- ``torch.per_tensor_affine``
- ``torch.per_tensor_symmetric``
- ``torch.per_channel_affine``
- ``torch.per_channel_symmetric``
FN)returnc s t jj|}tt| j|d || _|r2tjd || _ | j
dt j t j t j
jgf| | jt jt jt jt jt jfkstd| jt jt jt jfkstd|d k o|d k | _| jr| j|| t||| j| j| j \| _ | _ d S )N)r' zPlease use quant_min and quant_max to specify the range for observers. reduce_range will be deprecated in a future release of PyTorch.epszDefault Observer only works for per_tensor_affine, per_tensor_symmetric, per_channel_affine, per_channel_symmetric and per_channel_float_qparams quantization schemezDDefault Observer only works for qint8, quint8 and quint4x2 data type) torchnnfactory_kwargsr& r/ r qschemewarningswarn reduce_rangeregister_buffertensorfinfofloat32r2 per_tensor_affineper_tensor_symmetricper_channel_affineper_channel_symmetric per_channel_affine_float_qparamsAssertionErrorr' qint8quint8Zquint4x2has_customized_qrange_validate_qmin_qmaxr
quant_min quant_max)r r' r6 r9 rH rI r5 )r( r r r s2 z_ObserverBase.__init__c
s^ |j dd }|d ks |dkr>tjtjtjjg} | ||d < tt| j||||||| d S )Nversion r2 ) getr3 r; r< r= r2 r& r% _load_from_state_dict)
r
state_dictprefixlocal_metadatastrict missing_keysunexpected_keys
error_msgsrJ r2 )r( r r rM s
z#_ObserverBase._load_from_state_dict)rH rI r1 c C s4 |d ko|kn s t d||k s0t ddS )a Validates that the user-specified quantization range is properly initialized
and within the given bound supported by the observer dtype.
To accommodate lower-bit quantization with respect to the existing torch.qint8 and
torch.quint8 datatypes, the user can choose to use dynamic quantization range by passing
in a tuple of initial qmin and qmax values. One use case is these customized qmin and qmax
values are used to calculate static estimates of the scale and zero point for aggressive lower-bit
fake quantization. These estimates are compared against parameters learned through backpropagation.
The related literatures for scale and zero point via backpropagation are as follows:
Learned Step Size Quantization: https://openreview.net/pdf?id=rkgO66VKDS
Trained Quantization Thresholds: https://arxiv.org/pdf/1903.08066.pdf
r z1Used-specified quantization range must include 0.zKqmin must be strictly less than qmax for user-specified quantization range.N)rC )r rH rI r r r rG s
z!_ObserverBase._validate_qmin_qmax)min_valmax_valr1 c
C s4 t ||s2tjdg|jjdtjdg|jjdfS | j| j }}tj|tj|}tj |tj|}|j}tj
|j tj |d}tj
|j tj|d} | jtjks| jtjkr"tj | |}|t|| d }tj || j}| jtjkr| jr| j| j || d } n| j| j d} n| jtjkrl|| t|| }tj|| jk|tj|}d| | } nJ|| t|| }tj || j}|tj|| j tj } tj | ||} t |j dkrtjt|g|j|d}t | j dkr,tjt | g| j|d} | jtjkr,tjt| g| j|d} || fS ) a Calculates the quantization parameters, given min and max
value tensors. Works for both per tensor and per channel cases
Args:
min_val: Minimum values per channel
max_val: Maximum values per channel
Returns:
scales: Scales tensor of shape (#channels,)
zero_points: Zero points tensor of shape (#channels,)
g ?)devicer )r' rW rK )!r r3 r; rW typerH rI minZ
zeros_likemaxonessizer= zerosZint64r6 r? rA floatr2 r' rE rF Znew_fullrB whereZ ones_likeroundtointclamplenshape)
r rU rV rH rI Z min_val_negZ max_val_posrW ZscaleZ
zero_pointr r r _calculate_qparams sF
( z _ObserverBase._calculate_qparamsc C s t dd S )Nz2Cannot reset min/max values in the given observer.)NotImplementedError)r r r r reset_min_max_valsD s z _ObserverBase.reset_min_max_vals)r r r r, _versionr3 Tensorr2 rE r> r rM jitexportre rG r ri rk r. r r )r( r r/ p s"
! Er/ c s~ e Zd ZU dZejejejej ddddfdd fdd
Z
dd Z ej j
d d
Zej j
d d Zej j
d
d Z ZS )MinMaxObservera Observer module for computing the quantization parameters based on the
running min and max values.
This observer uses the tensor min/max statistics to compute the quantization
parameters. The module records the running minimum and maximum of incoming
tensors, and uses this statistic to compute the quantization parameters.
Args:
dtype: Quantized data type
qscheme: Quantization scheme to be used
reduce_range: Reduces the range of the quantized data type by 1 bit
quant_min: Minimum quantization value. If unspecified, it will follow the 8-bit setup.
quant_max: Maximum quantization value. If unspecified, it will follow the 8-bit setup.
Given running min/max as :math:`x_\text{min}` and :math:`x_\text{max}`,
scale :math:`s` and zero point :math:`z` are computed as:
The running minimum/maximum :math:`x_\text{min/max}` is computed as:
.. math::
\begin{array}{ll}
x_\text{min} &= \begin{cases}
\min(X) & \text{if~}x_\text{min} = \text{None} \\
\min\left(x_\text{min}, \min(X)\right) & \text{otherwise}
\end{cases}\\
x_\text{max} &= \begin{cases}
\max(X) & \text{if~}x_\text{max} = \text{None} \\
\max\left(x_\text{max}, \max(X)\right) & \text{otherwise}
\end{cases}\\
\end{array}
where :math:`X` is the observed tensor.
The scale :math:`s` and zero point :math:`z` are then computed as:
.. math::
\begin{aligned}
\text{if Symmetric:}&\\
&s = 2 \max(|x_\text{min}|, x_\text{max}) /
\left( Q_\text{max} - Q_\text{min} \right) \\
&z = \begin{cases}
0 & \text{if dtype is qint8} \\
128 & \text{otherwise}
\end{cases}\\
\text{Otherwise:}&\\
&s = \left( x_\text{max} - x_\text{min} \right ) /
\left( Q_\text{max} - Q_\text{min} \right ) \\
&z = Q_\text{min} - \text{round}(x_\text{min} / s)
\end{aligned}
where :math:`Q_\text{min}` and :math:`Q_\text{max}` are the minimum and
maximum of the quantized data type.
.. warning:: Only works with ``torch.per_tensor_symmetric`` quantization scheme
.. warning:: :attr:`dtype` can only take ``torch.qint8`` or ``torch.quint8``.
.. note:: If the running minimum equals to the running maximum, the scale
and zero_point are set to 1.0 and 0.
FN)r1 c s t t| j||||||d tjj|}| jdtjtdf| | jdtjtdf| | j tj
kr| j r| j tj
krtdd S )N)r' r6 r9 rH rI r5 rU infrV z-infz`Cannot reduce range for symmetric quantization for quint8)r& rp r r3 r4 r5 r: r; ra r6 r? r9 r' rE rj )r r' r6 r9 rH rI r5 )r( r r r s
zMinMaxObserver.__init__c C sl |j dkr|S |j }|j| jj}tj|\}}tj|| j}tj|| j }| jj
| | j j
| |S )z1Records the running minimum and maximum of ``x``.r ) numeldetachrd rU r' r3 _aminmaxr\ r] rV copy_)r x_origr) min_val_cur max_val_currU rV r r r r* s zMinMaxObserver.forwardc C s | j | j| jS )z'Calculates the quantization parameters.)ri rU rV )r r r r r+ s z MinMaxObserver.calculate_qparamsc C s dj | j| jS )Nzmin_val={}, max_val={})formatrU rV )r r r r
extra_repr s zMinMaxObserver.extra_reprc C s$ t jtd| _t jtd| _dS )zResets the min/max values.rq z-infN)r3 r; ra rU rV )r r r r rk s z!MinMaxObserver.reset_min_max_vals)r r r r, r3 rm rU rV rE r> r r* rn ro r+ rz rk r. r r )r( r rp I s
>
rp c s@ e Zd ZdZdejejdddfdd fdd
Zdd Z Z S )
MovingAverageMinMaxObservera; Observer module for computing the quantization parameters based on the
moving average of the min and max values.
This observer computes the quantization parameters based on the moving
averages of minimums and maximums of the incoming tensors. The module
records the average minimum and maximum of incoming tensors, and uses this
statistic to compute the quantization parameters.
Args:
averaging_constant: Averaging constant for min/max.
dtype: Quantized data type
qscheme: Quantization scheme to be used
reduce_range: Reduces the range of the quantized data type by 1 bit
quant_min: Minimum quantization value. If unspecified, it will follow the 8-bit setup.
quant_max: Maximum quantization value. If unspecified, it will follow the 8-bit setup.
The moving average min/max is computed as follows
.. math::
\begin{array}{ll}
x_\text{min} = \begin{cases}
\min(X) & \text{if~}x_\text{min} = \text{None} \\
(1 - c) x_\text{min} + c \min(X) & \text{otherwise}
\end{cases}\\
x_\text{max} = \begin{cases}
\max(X) & \text{if~}x_\text{max} = \text{None} \\
(1 - c) x_\text{max} + c \max(X) & \text{otherwise}
\end{cases}\\
\end{array}
where :math:`x_\text{min/max}` is the running average min/max, :math:`X` is
is the incoming tensor, and :math:`c` is the ``averaging_constant``.
The scale and zero point are then computed as in
:class:`~torch.quantization.observer.MinMaxObserver`.
.. note:: Only works with ``torch.per_tensor_affine`` quantization scheme.
.. note:: If the running minimum equals to the running maximum, the scale
and zero_point are set to 1.0 and 0.
g{Gz?FN)r1 c s, || _ tt| jf |||||d| d S )N)r' r6 r9 rH rI )averaging_constantr& r{ r )r r| r' r6 r9 rH rI r )r( r r r s
z$MovingAverageMinMaxObserver.__init__c C s |j dkr|S |j }|j| jj}| j}| j}|tdkrZ|tdkrZtj|\}}n2tj|\}}|| j || }|| j || }| jj
| | jj
| |S )Nr rq z-inf) rr rs rd rU r' rV ra r3 rt r| ru )r rv r) rU rV rw rx r r r r* s z#MovingAverageMinMaxObserver.forward)
r r r r, r3 rE r> r r* r. r r )r( r r{ s * r{ c s e Zd ZU dZejejdejej ddddfdd fdd
Z
dd Z d
d Z ej
jd d
Zdd Zeeeejf eeejf f eeeejf eee ee ee d fdd Zeeeejf eeejf f eeeejf eee ee ee dddZej
jdd Z ZS )PerChannelMinMaxObservera Observer module for computing the quantization parameters based on the
running per channel min and max values.
This observer uses the tensor min/max statistics to compute the per channel
quantization parameters. The module records the running minimum and maximum
of incoming tensors, and uses this statistic to compute the quantization
parameters.
Args:
ch_axis: Channel axis
dtype: Quantized data type
qscheme: Quantization scheme to be used
reduce_range: Reduces the range of the quantized data type by 1 bit
quant_min: Minimum quantization value. If unspecified, it will follow the 8-bit setup.
quant_max: Maximum quantization value. If unspecified, it will follow the 8-bit setup.
The quantization parameters are computed the same way as in
:class:`~torch.quantization.observer.MinMaxObserver`, with the difference
that the running min/max values are stored per channel.
Scales and zero points are thus computed per channel as well.
.. note:: If the running minimum equals to the running maximum, the scales
and zero_points are set to 1.0 and 0.
r FN)r1 c s t t| j||||||d tjj|}|| _| jdtjg f| | jdtjg f| | j tj
kr| j r| j tj
krtdd S )N)r' r6 r9 rH rI r5 rU rV z9Cannot reduce range for symmetric quantization for quint8)r& r} r r3 r4 r5 ch_axisr: r; r6 rA r9 r' rE rj )r r~ r' r6 r9 rH rI r5 )r( r r r : s
z!PerChannelMinMaxObserver.__init__c C s
| j |S )N)_forward)r rv r r r r* Y s z PerChannelMinMaxObserver.forwardc
C s |j dkr|S |j }| j}| j}|j }dd tt|D }d|| j< | j|d< |j|}|j | jj
}t j |dd}|j dks|j dkrt j
|d\}}n(t j
|d\}} t j||}t j| |}| jj|j | jj|j | jj| | jj| |S )Nr c S s g | ]}|qS r r ).0ir r r
d s z5PerChannelMinMaxObserver._forward..rK ) start_dim)rr rs rU rV r_ rangerg r~ permuterd r' r3 flattenrt r\ r] resize_rh ru )
r rv r) rU rV x_dim
new_axis_listyrw rx r r r r \ s,
z!PerChannelMinMaxObserver._forwardc C s | j | j| jS )N)ri rU rV )r r r r r+ x s z*PerChannelMinMaxObserver.calculate_qparamsc C s dj | j| jS )Nzmin_val={}, max_val={})ry rU rV )r r r r rz | s z#PerChannelMinMaxObserver.extra_repr)rN rO rP rQ rR rS rT c s& |j dd }|d ks |dk r.ddg} d}
d} nddg} d}
d} x| D ]} || }
|
|kr||
}| |
krx| jj|j n(| | kr| jj|j ntjdj| tj j
r| |
kr| jj | q| | kr| jj | qtjdj| qD|rD|j |
qDW tj j
s"t
t| j|||d||| d S ) NrJ r0 Zmin_valsZmax_valsrU rV z4Observer load_from_state_dict got unexpected name {}F)rL rU r rh rV r7 r8 ry r3 rn Z is_scriptingru appendr& r} rM )r rN rO rP rQ rR rS rT rJ local_stateZexpected_min_nameZexpected_max_namenamekeyval)r( r r rM sD
z.PerChannelMinMaxObserver._load_from_state_dictc C s | j ||||||| d S )N)rM )r rN rO rP rQ rR rS rT r r r _load_from_state_dict_script s z5PerChannelMinMaxObserver._load_from_state_dict_scriptc C s t jg | _t jg | _dS )zResets the min/max values.N)r3 r; rU rV )r r r r rk s z+PerChannelMinMaxObserver.reset_min_max_vals)r r r r, r3 rm rU rV rE r@ r r* r rn ro r+ rz r r
strboolr rM r rk r. r r )r( r r} s<
2
r} c sB e Zd ZdZddejejdddfdd fdd
Zd d
Z Z S ) %MovingAveragePerChannelMinMaxObservera Observer module for computing the quantization parameters based on the
running per channel min and max values.
This observer uses the tensor min/max statistics to compute the per channel
quantization parameters. The module records the running minimum and maximum
of incoming tensors, and uses this statistic to compute the quantization
parameters.
Args:
averaging_constant: Averaging constant for min/max.
ch_axis: Channel axis
dtype: Quantized data type
qscheme: Quantization scheme to be used
reduce_range: Reduces the range of the quantized data type by 1 bit
quant_min: Minimum quantization value. If unspecified, it will follow the 8-bit setup.
quant_max: Maximum quantization value. If unspecified, it will follow the 8-bit setup.
The quantization parameters are computed the same way as in
:class:`~torch.quantization.observer.MovingAverageMinMaxObserver`, with the
difference that the running min/max values are stored per channel.
Scales and zero points are thus computed per channel as well.
.. note:: If the running minimum equals to the running maximum, the scales
and zero_points are set to 1.0 and 0.
g{Gz?r FN)r1 c s. t t| jf ||||||d| || _d S )N)r~ r' r6 r9 rH rI )r& r r r| ) r r| r~ r' r6 r9 rH rI r )r( r r r s z.MovingAveragePerChannelMinMaxObserver.__init__c
C s |j dkr|S |j }|j| jj}| j}| j}|j }dd tt|D }d|| j < | j |d< |j
|}t j |dd}|j dks|j dkrt j
|d\}}n4t j
|d\}} || j|| }|| j| | }| jj|j | jj|j | jj| | jj| |S )Nr c S s g | ]}|qS r r )r r r r r r
s zAMovingAveragePerChannelMinMaxObserver.forward..rK )r )rr rs rd rU r' rV r_ r rg r~ r r3 r rt r| r rh ru )
r rv r) rU rV r r r rw rx r r r r* s,
z-MovingAveragePerChannelMinMaxObserver.forward)
r r r r, r3 rE r@ r r* r. r r )r( r r s r c s e Zd ZU dZejejejddej ej
ddfe e ej dd fdd
Z
ejejejejd d
d Ze e d d
dZeejejf dddZejeje eejeje e f dddZejeje e e e ejdddZejejdddZejjdd Z fd d Z fd d Z ZS )!HistogramObserveraX
The module records the running histogram of tensor values along with
min/max values. ``calculate_qparams`` will calculate scale and zero_point.
Args:
bins: Number of bins to use for the histogram
upsample_rate: Factor by which the histograms are upsampled, this is
used to interpolate histograms with varying ranges across observations
dtype: Quantized data type
qscheme: Quantization scheme to be used
reduce_range: Reduces the range of the quantized data type by 1 bit
The scale and zero point are computed as follows:
1. Create the histogram of the incoming inputs.
The histogram is computed continuously, and the ranges per bin change
with every new tensor observed.
2. Search the distribution in the histogram for optimal min/max values.
The search for the min/max values ensures the minimization of the
quantization error with respect to the floating point model.
3. Compute the scale and zero point the same way as in the
:class:`~torch.quantization.MinMaxObserver`
i rY FN)bins
upsample_rater' r1 c s t t| j||||d tjj|}|| _| jdtj| jf| | jdtj t
df| | jdtj t
df| dtj | j j
| _|| _d S )N)r' r6 r9 r5 histogramrU rq rV z-infrX )r& r r r3 r4 r5 r r: r` r; ra Ziinfor' bits dst_nbinsr )r r r r' r6 r9 r5 )r( r r r ; s
zHistogramObserver.__init__) delta_begin delta_enddensityr1 c C s$ || | || | d }|| S )a
Compute the norm of the values uniformaly distributed between
delta_begin and delta_end.
Currently only L2 norm is supported.
norm = density * (integral_{begin, end} x^2)
= density * (end^3 - begin^3) / 3
r0 r )r r r r normr r r _get_normS s zHistogramObserver._get_norm)next_start_bin next_end_binc C sz | j j | jj | j }||| d | j }|dkrg g ?rK rq ) r r_ r rC rV rU r3 r r cumsumra r )r r totalZcSumZstepsizealphabetaZ start_binZend_binZnorm_minZ
next_alphaZ next_betalr" r r r new_minnew_maxr r r _non_linear_param_search sJ
z*HistogramObserver._non_linear_param_search) combined_min combined_maxr r1 c C s | j | j | j| }ttj|| | j| j }|| j| || }|| }|}ttj| j| | j }||||fS )N)rV rU r re r3 ceilr rc )r r r r Zhist_bin_widthdownsample_ratee start_idxr r r _adjust_min_max s
z!HistogramObserver._adjust_min_max) orig_histnew_histr r r Nbinsr1 c C s |j |}tj|| |jd}||||| | < tj|dtjd|d d | } tj||jd}
| dd |
d|< | |
| } || jtj }|S )N)rW r )r' rK rZ )Zrepeat_interleaver3 r` rW r doublerd ra ) r r r r r r r Zupsampled_histogramZhistogram_with_output_rangeZintegral_histogramZshifted_integral_histogramZinterpolated_histogramr r r _combine_histograms s
z%HistogramObserver._combine_histograms)rv r1 c C s |j dkr|S |j }| j}| j}|j |j k}|tdkoJ|tdk}|sT|rtj|\}}| jj|j | jj
| | jj|j | jj
| |j dkr|j dkst dtj || j
t|t|| jd ntj|\}}tj||} tj||}
| j| |
| j\} }
} } | j dkr4|
j dks re r' r r r r r r r r* rn ro r+ r rM r. r r )r( r r s8
2@
; r c sH e Zd ZdZejddfdd fdd
Zdd Zejj d d
Z
Z S ) PlaceholderObservera
Observer that doesn't do anything and just passes its configuration to the
quantized module's ``.from_float()``.
Can be used for quantization to float16 which doesn't require determining
ranges.
Args:
dtype: Quantized data type
custom_op_name: (temporary) specify this observer for an operator that doesn't require any observation
(Can be used in Graph Mode Passes for special case ops).
N)r1 c s, t t| j|d || _|| _|r(|| _d S )N)r' )r& r r r' custom_op
compute_dtype)r r' custom_op_namer )r( r r r s
z PlaceholderObserver.__init__c C s |S )Nr )r r) r r r r* s zPlaceholderObserver.forwardc C s t dd S )Nz>calculate_qparams should not be called for PlaceholderObserver) Exception)r r r r r+ s z%PlaceholderObserver.calculate_qparams) r r r r, r3 r= r r* rn ro r+ r. r r )r( r r s
r c sZ e Zd ZdZdeeej iZ fddZ dd Z
ej j dd Z
ej j d d
Z ZS ) RecordingObservera
The module is mainly for debug and records the tensor values during runtime.
Args:
dtype: Quantized data type
qscheme: Quantization scheme to be used
reduce_range: Reduces the range of the quantized data type by 1 bit
tensor_valc s t t| jf | g | _d S )N)r& r r r )r r )r( r r r s zRecordingObserver.__init__c C s | j j|j |S )N)r r clone)r r) r r r r* s zRecordingObserver.forwardc C s t dd S )Nz sZ
Z R 6L u$