/usr/local/lib64/python3.6/site-packages/torch/quantization/fx/__pycache__
Edit: /usr/local/lib64/python3.6/site-packages/torch/quantization/fx/__pycache__/prepare.cpython-36.pyc (25938B)
3
EgJ @ s d dl Z d dlZd dlZd dlmZ d dlmZmZ d dlm Z m
Z
d dl m Z ddl
mZmZ dd lmZmZmZ dd
lmZmZmZ dd lmZ dd lmZm Z dd
l m Z m Z ddl m!Z!m"Z" ddl#m$Z$ ddl%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z. ddl/m0Z0 ddl1m2Z2 d dl3m4Z4m5Z5 ddl%m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m
m?Z? ddl>m@Z@ d dlAmBZBmCZCmDZDmEZEmFZFmGZGmHZH e
eDeIe jJjKf eLdddZMe
eBeLdd d ZNe jJjOjPe jJjOjQe jJjOjRhZSdZTe
eBeLdd d ZUe
eDeIe jJjKf eDeIeBf eeGeDeIeBf eDeIeBf f d d!d"ZVe jJjKeDeCeCf dd#d$d%ZWeBeDeCeCf eBd&d'd(ZXeeBeBd)d*d+ZYe
e jZje jJjKeDeIe jJjKf e e
d,d-d.Z[e
ee\e\eEe\ eEe\ eFe eDeIe jJjKf eDe
eLf eFe j] d/
d0d1Z^eHe
eBf e ee jJjKeDeIe jJjKf e eDeIeBf eFe eDeIeBf e d2
d3d4Z_e
ee jJjKeDeIe jJjKf e eDeIeBf eFe eDeIeBf dd5 d6d7Z`e
eBe jJjKeDeIe jJjKf e eDeIeBf eLdd8d9d:Zae
e jJjKeDeIe jJjKf e eDeIe!f eDeIeBf eBeFe eFe
d; dd?d@Zce
e j]eDeIe j]f eDeIe!f ddAdBdCZde eDeIe j]f eDeIe!f ddDdEdFZee
e jJjKeDeIe jJjKf eLdGdHdIZfe
e jJjKeDeIe jJjKf dJdKdLZge
eeDeIe jJjKf eDeIeBf dMdNdOZheeDeIe jJjKf eDeIe!f eDeIef e eDeIeBf eDeIeBf eEe\ eEe\ eFe
dP
dQdRZie jJjKeDeIe jJjKf eBeDeIeBf ddSdTdUZjeeDeIef eDeIeGeIekf f eDeef eDeIeBf eDeIeBf ddVdWdXZld]eeBeDeIeGeIekf f eFeDeIeBf eFeDeIeBf eFeDeIeBf eLe dZd[d\ZmdS )^ N) GraphModule)propagate_qconfig_ ObserverBase)GraphNode)Argument )
QConfigAnyqconfig_equals ) convert_dict_to_ordered_dictgenerate_qconfig_mapget_flattened_qconfig_dict)QuantizeHandlerCustomModuleQuantizeHandler StandaloneModuleQuantizeHandler)Pattern)is_equalization_observernode_supports_equalization)ObservedGraphModule ObservedStandaloneGraphModule) MatchResult.get_default_output_activation_post_process_map) find_matches) _parent_name get_custom_module_class_keys all_node_args_have_no_tensors assert_and_get_unique_device node_bool_tensor_arg_indexes get_new_attr_name_with_prefixNON_QUANTIZABLE_WEIGHT_OPSWEIGHT_INDEX_DICTFUNCTIONAL_OPS_WITH_BIAS) DEFAULT_OP_LIST_TO_FUSER_METHOD) get_default_qat_module_mappings)is_activation_post_processconvert)get_combined_dictget_qconfig_dtypes get_swapped_custom_module_classweight_is_quantized"activation_is_statically_quantized activation_is_int8_quantizedactivation_dtype weight_dtype) get_fbgemm_backend_config_dict) validate_backend_config_dict)AnyCallableDictListOptionalTupleUnion)nodemodulesreturnc C s* t | tjjo(| jdko(t|t| j S )N call_module)
isinstancetorchZfxr opr% strtarget)r8 r9 rA I/usr/local/lib64/python3.6/site-packages/torch/quantization/fx/prepare.py is_activation_post_process_node[ s rC )r8 argr: c C s t | tr|| jdkr|| jtkr|x0t| jD ]"\}}||kr*|t| j kr*dS q*W x*| jj D ] \}}|dkr\||kr\dS q\W dS )N
call_functionTweightF) r< r r> r@ r! enumerateargskwargsitems)r8 rD inode_arg
kwarg_name kwarg_valuerA rA rB node_arg_is_weight_ s
rO c C s t | tr| jdkr| jtkrLxbt| jD ] \}}||kr*|tkr*dS q*W n6| jtkrx*| j j
D ] \}}|dkrb||krbdS qbW dS )NrE TZbiasF) r< r r> r@ CONV_OPS_WITH_BIASrG rH CONV_BIAS_ARG_INDEXr" rI rJ )r8 rD rK rL rM rN rA rA rB node_arg_is_biasr s
rR )r8 r9 prepare_custom_config_dictqconfigr: c C s || j }|jdg }|jdg }dd |D }dd |D }|jt|d
} |j| j | } | d dkrpd|in| d }
| d dkri n| d } |
| fS ) z
Returns the standalone module qconfig_dict and prepare_config_dict
for `node`, assuming that the module pointed to by `node` is
a standalone modules.
standalone_module_namestandalone_module_classc S s" i | ]}|d |d f|d qS )r r r rA ).0xrA rA rB
s z1get_standalone_module_configs..c S s" i | ]}|d |d f|d qS )r r r rA )rW rX rA rA rB rY s Nr r )NN)r@ gettype) r8 r9 rS rT standalone_module standalone_module_name_configs standalone_module_class_configsZclass_config_mapZname_config_mapconfigsm_qconfig_dictsm_prepare_config_dictrA rA rB get_standalone_module_configs~ s
rc )root additional_qat_module_mappingr: c C s t t |}t| |ddd d S )NTF)mappingZinplaceZremove_qconfig)r' r$ r& )rd re Z all_mappingsrA rA rB qat_swap_modules s
rg ) qconfig_dictre r: c C sN t t |}| jdd}|j }x(|j D ] \}}||kr*|||| < q*W | S )z
Update the qconfig_dict to account for module swaps during QAT.
During QAT we perform a module swap on the nn.Module types to the corresponding nn.qat.modules types.
object_typeN)r' r$ r[ copyrJ )rh re Zall_qat_mappingsobject_type_dictZnew_object_type_dictkvrA rA rB update_qconfig_for_qat s
rn )modelrh r: c
C s |j dd}|dkr|S t| j }x| jjD ]}|jdkr.t|t|j }|t t
j kr`q.xpt
j D ]d\}}||krj|j |d d}x2|D ]*} t
|j | d|stdd| d qW |dk rj|||< qjW q.W |S )zR
Update the qconfig_dict to account for fused modules such as LinearReLU.
ri Nr; r z+During fusion, we need to specify the same z qconfigs for both modules in .)r[ dict
named_modulesgraphnodesr> r\ r? r@ listr# valuesrJ r
LookupError)
ro rh rk r9 r8 module_typeopsZfuserZ
fused_qconfigr> rA rA rB update_qconfig_for_fusion s&
rz )r8 observerro r9 rs r: c
C s t |}|r|j| t|r*| jd }n
| jd }t|}||}t||| |||< |j| |jd|| fi } W dQ R X | S )zp
Attaches `observer` to `model`, and creates a node which calls
`observer` on the output of `node`.
Z_equalization_process_Z_activation_post_process_r; N)r Ztor namer setattrZinserting_afterZ create_node)
r8 r{ ro r9 rs Z model_deviceprefixZget_new_observer_nameZ
observer_namenew_obsrA rA rB insert_observer s
r )
r8 rT inputs_seen_counteroutputs_seen_counterinput_quantized_idxsoutput_quantized_idxsqhandlerr9 cache_for_no_tensor_checkr: c C s | j dkr ||krtjS tjS n| j d
krt| ||} | r>dS | j dkoR| jtjk}
|
r^tjS |dk r|dk r|j r|j |drt
|\} } }
| S tjS qtjS nB| j dkrtjS | j dkr||krtjS tjS nt d | j dS ) ay
Returns the expected dtype of the input and output of this node after
convert. If the value is not None, it represents the dtype of the
Tensor. If the value is None, it means the value is not a Tensor.
Note: this is for activations only, weight dtypes are not handled here.
TODO(future PR, if needed): explicitly spell out the non-Tensor
dtypes.
placeholderr; call_methodrE NFZget_attroutputzneed to handle )r; r rE )
r> r= quint8floatr r@ operatorgetitemZinput_output_observedZis_output_quantizedr( AssertionErrorZ format_node)r8 rT r r r r r r9 r Zargs_have_no_tensors
is_getitemZ act_dtyper. Zact_compute_dtyperA rA rB $get_target_activation_dtype_for_node s4
r )
r8 rD rT ro r9 rs node_name_to_target_dtyper rS r: c $ C sz t |ttfrNg } x.|D ]&}
t| |
||||||| } | j| qW t|| S t |ts\|S t |tsjt|} |dk o~t |t}
|
sPt | |}|dk st|r|j
n|j }t | |}|p| }|ot
|o| jtk}|ot|tjkot|tjk}||j }|| j }||ko<|tjko<|tjdfko<|o r )$r8 rD rT ro r9 rs r r rS Znew_arg_to_returnZ inner_argZ
new_inner_argnew_argis_standalone_module is_weightact_post_process_ctrZis_biasZ
is_activationZweight_needs_obsZbias_needs_obsZ arg_dtypeZ
node_dtypeZ(dtype_changes_and_second_dtype_not_floatZ needs_obsZ_sm_qconfig_dictrb Zsm_input_quantized_idxsZ
cur_input_idxZarg_idxZ arg_to_checkZ new_obs_modZexisting_obs_nodeZmaybe_obs_node_Z
maybe_obs_modZ new_obs_noderA rA rB r 0 s
r ) r8 rT ro r9 rs r r rS r: c C s |dkr dS |dk st g }x0| jD ]&} t| | ||||||| }
|j|
q$W i } x6| jj D ](\} }
t| |
||||||| }|| | < q^W t|| _| | _dS )a
If needed, inserts observers to the input args and kwargs of `node`.
Note: modifies `node` inplace.
For example, if cur_node needs an observer after prev_node, we change from
prev_node -> cur_node
To
prev_node -> obs -> cur_node
N)r rH r r rI rJ r )r8 rT ro r9 rs r r rS new_argsrD r Z
new_kwargsrl kwargZ new_kwargrA rA rB %maybe_insert_input_observers_for_node s&
r )r8 equalization_qconfigro r9 rs r is_branchr: c
C s |dkst | | rdS |r2tjd| d dS g }xz| jD ]p}t|t sXt| |rd|j| q>t| |} | rx|j n|j
}
|
} t || |||} ||j || j < |j| q>W t
|| _dS )z
If `node` needs to be equalized, find the input/weight observers it needs in
`equalization_qconfig`, creates them, and inserts it into `graph`.
If `node` does not need an equalization observer, returns None.
NzCannot equalize z because it is part of a branch.)r warningswarnrH r< r rR r rO rF Zinput_activationr r| r )
r8 r ro r9 rs r r r rD r Zact_eq_process_ctrZnew_eq_obs_modZnew_eq_obs_noderA rA rB 2maybe_insert_input_equalization_observers_for_node s(
r ) r8 ro r9 rs matchesr matched_patternr r: c C s |j | jd\}} }
}} |dkr$dS | dk s0t| jdksBtd|dk oRt|t} || j }
|j| |jo||
tj dtj
fk}|ot | }|o| }|r| j }t
| rt j ||}| }t| ||||}|| j ||j< |S dS dS )z
If `node` needs an output observer, creates it, inserts it into `graph`
and returns it.
If `node` does not need an output observer, returns None.
Nr z3observer insertion for outputs is handled elsewhere)NNNNN)r[ r| r r> r< r Z!should_insert_observer_for_outputtrainingr= r r r+ r r, r r )r8 ro r9 rs r r r r root_node
matched_nodespatternrT r dtypeZshould_insert_observerr r{ r rA rA rB %maybe_insert_output_observer_for_node s4
r )graph_output_noder r qconfig_mapro r9 rs r: c
s |dgks|g kst d|g kr&dS tj}ttjtttjf tttf tjj tttjj f t
td fdd g }x(| j D ] } |j | |||||| q|W || _ dS )z
If the output needs to be quantized and there are any nodes
in the output which are not already observed, inserts observers
for those nodes.
r z,unrecognized format of output_quantized_idxsN)
maybe_node target_dtyper r ro r9 rs r: c
s t | trZ|| j }||krT|j| j}|dk s8td|j } t| | |||}
|
S | S nt | ttfrg } x&| D ] } | j | |||||| qrW t | tr| S t| S nDt | t
ri }
x,| j D ] \}} ||||||||
|< qW |
S | S dS )a`
Navigate an arbitrary data structure of lists, tuples, dicts.
For each container type, recurse on all inputs. Once any Node
is found, insert an observer if needed and do not recurse further.
For example, given a structure of
{'foo1': [[bar1]], 'foo2': {'foo3': [[[bar3]]]}}
we recurse down to bar1 and bar3, observe them if necessary,
and if we inserted an observer then replace the original node
with its observer.
Returns the data structure with all nodes needing observation being
replaced by their observers.
Nz=Quantizing the output node without a qconfig is not supported) r< r r| r[ r r r ru r r rq rJ )r r r r ro r9 rs this_node_dtyperT Z observer_modZ
observer_noderesultsZ
inner_nodeZ results_dictrl Zinner_v)&_recursive_maybe_replace_node_with_obsrA rB r l s8
zZmaybe_insert_observers_before_graph_output.._recursive_maybe_replace_node_with_obs)
r r= r r r r3 r? r nnModuler rH r )
r r r r ro r9 rs Zoutput_target_dtyper Zold_argrA )r rB *maybe_insert_observers_before_graph_outputO s(
5 r )r8 r r r r: c
C sX ||| j < |j| j d\}}}}}|dk rT|j rT| jd } t| trTt| ||| dS )a
Assigns `target_dtype` to `node`. If `node` is a general tensor shape op
(see GeneralTensorShapeOpQuantizeHandler in quantization_patterns.py for more details)
also call this function recursively on
the first argument, to propagate the dtype to the caller.
Nr )NNNNN)r| r[ is_general_tensor_shape_oprH r< r maybe_propagate_dtype_for_node)
r8 r r r r r r r rT Z prev_noderA rA rB r s
r )rs r r r: c C sD x>| j D ]4}t|}x&|D ] }|j| }t|tj|| qW qW dS )a
Currently we assume that inputs to the graph are either `torch.float` or
`torch.quint8`, which is not always correct. For ops such as
`x.masked_fill(mask, value)`, we know that the dtype of `mask` is a
`BoolTensor`. Propagate this information throughout the graph.
Note: not all dtypes in the graph will be correct after this pass, but a
higher percentage of them will be correct. Hopefully in the future we can
replace this with a better way to reason about dtypes of tensors.
N)rt r rH r r= r )rs r r r8 Z
bool_arg_idxsZ bool_arg_idxZcur_noderA rA rB propagate_dtypes_for_known_nodes s
r )r8 ro r9 r: c C s d}x8t t| jD ]&}t| j| tttfr| j| }P qW |dkrJdS t|ttfrb|d }nt|trr|}ndS d}xt||s t|tsdS |jdkrdS d}x,t t|jD ]}|j| }t|trP qW |dkrdS |}|d7 }|dkr|t dq|W t|tst |j
}t|t s(t || } t|ttfrx~t |D ]r\}
} |
dkr`qJd}x6t| |s| jd } |d7 }|dkrft dqfW t
| j
\} }
t|| |
| qJW xF| jj D ]8\}}t||st t
|j
\} }
t|| |
| qW dS ) a
Ensures that we share an observer
for all input arguments as well as the output argument. In detail, given
a graph of
x0 -> obs0 -> op -> x2
/
x1 -> obs1 /
where node obs0 points to observer instance observer0,
obs1 points to observer1 and obs2 points to observer2, we make nodes obs1
and ob2 point to observer0.
Returns: whether the operation succeeded or not
NFr r r i' z(Unable to find observer of previous nodeT)rangelenrH r< r ru r rC r> r r@ r? rG r r} r rJ )r8 ro r9 Z first_argrK Z
first_arg_argZiteration_guardZtrace_back_nodeZ
target_to_useZobs_mod_to_useZ input_idxZ input_arg parent_namer| output_obs_noder rA rA rB 'maybe_make_input_output_share_observers sd
r )r8 ro r9 c C sH t | jj }x4|D ],\}}t||s*t|j| |jj| qW d S )N)ru r rJ rC r Zreplace_all_uses_withrs Z
erase_node)r8 ro r9 rJ r r rA rA rB remove_output_observer9 s
r )r8 rT r9 rS c
C sN || j }|jdi }t|||}|j|}t| j \}} t|| | | d S )N%float_to_observed_custom_module_class)r@ r[ r)
from_floatr r} )
r8 rT r9 rS Z
custom_moduleZcustom_module_class_mappingZ observed_custom_module_classZobserved_custom_moduler r| rA rA rB swap_custom_module_to_observedC s
r )
ro r9 r r rs rS equalization_config_mapr r r: c # C s i } t }
d} d} d}
t | jdd}xF| jjD ]:}|j|jd \}}}}}t||| | |||||
| |j< q0W t| j| | t| jj}x|D ]}|j dkrnH|j d
kr|j|jd\}}}}}|j|jd}| |j }|dk}|j dk o|j
t j k}|dks|s|o |j d k }|st | jdd}|j d krd}t
|jdkrt|jd trt
|jd jd
krx^|jd jD ]N}|j|jddk p|j dkot|t|j
t} ||kr| rd }qW t||| ||| || t||| ||| | ||k} |dk o"|j } |dk o4|j } | r| rt|| |||| ||} | dk rt|jj }!x(|!D ] }"|"| krqx|"j|| qxW | rt|| |st || | t|t rt |||| nt ||| || || |j dkr| d
7 } q|j d kr| d
7 } |}
qW |
S )a$
Inserts observers, using the following high level algorithm:
For each node in the graph:
1. determine the target dtype of this node in the quantized graph, and save
it for future steps
2. determine the target dtype or all args and kwargs of this node
3. if any arg or kwarg's target dtype does not match the current node's
dtype, insert an observer
4. if the current node needs an output observer, insert it
For example:
- starting graph:
x0 -> linear -> x1
- observed graph after processing x0:
x0(fp32)
- observed graph after processing linear:
x0(fp32) -> x0_obs0(int8) -> linear(int8) -> linear_obs0(int8)
- observed graph after processing x1:
x0(fp32) -> x0_obs0(int8) -> linear(int8) -> linear_obs0(int8) -> x1
After a node is processed, the naive observer placement is guaranteed to be
complete for that node and all of its predecessors. There can be future
passes which optimize the graph by deduplicating observers, etc.
r NF)Zremove_duplicater r; r rE r r T)NNNNN)r; r rE r )NNNNN) rq rr rs rt r[ r| r r ru r> r@ r r r rH r< r r r? r r r is_general_tensor_value_opr r keysZreplace_input_withr r r r r )#ro r9 r r rs rS r r r r r r r Z results_noder8 r r r r rT Znodes_before_observationr r Zoutput_not_a_tensorr Zskip_inserting_observersZis_quantized_branchuserZis_user_quantizedZis_last_node_of_patternr r Zmaybe_output_obs_nodeZ
orig_usersZ user_noderA rA rB insert_observers_for_modelS s )
r )ro r9 r rS r: c C s x|j D ]\}\}}}}} |dkr(q
n t|ts4q
t|||| \}
} ||j } tjjj}
|
| |
| }t | j
dg }t ||j |}t
|j\}}t|| || |||j< q
W dS )z
Runs prepare_fx on each standalone module. Note: this does
not modify the graph, it just replaces the unobserved modules with
their observed versions.
Npreserved_attributes)rJ r< r rc r@ r= quantizationZ quantize_fxZ _prepare_standalone_module_fxsetr[ r rs r r} )ro r9 r rS Z node_namer r r r rT ra rb r] prepareZobserved_standalone_moduler r r| rA rA rB $run_prepare_fx_on_standalone_modules# s&
r )observedr node_name_to_scopepatternsrS equalization_qconfig_mapr: c C s" || _ || _|| _|| _|| _d S )N)Z _patternsZ _qconfig_mapZ_prepare_custom_config_dictZ_node_name_to_scopeZ_equalization_qconfig_map)r r r r rS r rA rA rB
save_stateJ s
r F)ro rh r rS equalization_qconfig_dictbackend_config_dictr r: c
C s |dkr i }|dkri }|dkr&t }t| |jdi }|d }t||} t| t| t|}
t| |
| jr|jdi } t| | t || }t
| |}t
| |}t | j } t
| | | j||}
t
| | | j||}|jdg }|jdg }dd |D }d d |D }t|d
}t| j| | ||||}|jd g }|jd g }t| | || t| | ||| j||
|| }t| ||| ||
t|jd
g }t| | j|} |r|dk stt|jd tstdtj|| _ tj|| _ | S )aQ standalone_module means it a submodule that is not inlined in
parent module, and will be quantized separately as one unit.
How the standalone module is observed is specified by `input_quantized_idxs` and
`output_quantized_idxs` in the prepare_custom_config for the standalone module
Args:
node_name_to_scope: mapping from node name to the scope of the module which contains the node.
The scope is a tuple of fully qualified path of the module and the type of the module
Returns:
model(GraphModule): prepared standalone module
attributes:
_standalone_module_input_quantized_idxs(List[Int]): a list of
indexes for the graph input that is expected to be quantized,
same as input_quantized_idxs configuration provided
for the standalone module
_standalone_module_output_quantized_idxs(List[Int]): a list of
indexs for the graph output that is quantized
same as input_quantized_idxs configuration provided
for the standalone module
NZadditional_quant_patternquant_patternsre rU rV c S s g | ] }|d qS )r rA )rW r` rA rA rB
s zprepare..c S s g | ] }|d qS )r rA )rW r` rA rA rB r s r r r r r zVstandalone module only supports returning simple value currently(not tuple, dict etc.)) r/ r0 r[ r' r r r r rg rn rz rq rr r
rs r r r r r r r r r< rH r r= ZtensorZ'_standalone_module_input_quantized_idxsZ(_standalone_module_output_quantized_idxs)ro rh r rS r r r Zadditional_quant_patternsr r Zflattened_qconfig_dictre r9 r r r^ r_ Zstandalone_module_namesZstandalone_module_classesZcustom_module_classesr r r Z result_noder rA rA rB r Y st
r )NNNF)nr= r r Ztorch.fxr Ztorch.quantizationr r Ztorch.fx.graphr r Z
torch.fx.noder rT r r
Z
qconfig_utilsr r
r Zquantization_patternsr r r Zquantization_typesr Z _equalizer r Z graph_moduler r Z
pattern_utilsr r Z match_utilsr utilsr r r r r r r r! r" Zfuser_method_mappingsr# Zquantization_mappingsr$ Z torch.ao.quantization.quantizer% r& r' r( r) r* r+ r, r- r. r r/ r0 typingr1 r2 r3 r4 r5 r6 r7 r? r r r rC rO Z
functionalZconv1dZconv2dZconv3drP rQ rR rc rg rn rz r r intr r r r r r r r r r r r r r r\ r r rA rA rA rB s* , ( $
&
!
:
{
*
(
2
]
W
H
#