/usr/local/lib64/python3.6/site-packages/torch/quantization/fx/__pycache__
Edit: /usr/local/lib64/python3.6/site-packages/torch/quantization/fx/__pycache__/utils.cpython-36.pyc (14660B)
3
EgP @ s d dl Z d dlZd dljZddlmZmZ d dlmZ d dl m
Z
m Z d dl m
Z
mZ d dlmZmZmZmZmZmZmZmZmZ d dlZejjjdgejjj dgejjj dgejjj dgejjj dgejjj dgejjj!d giZ"ejjj ejjj ejjj!hZ#ejjj ejjj ejjj ejjj!hZ$d
d Z%d@e&d
ddZ'dd Z(eee&eee&f ee&ef f dddZ)eejj*eee&ejj*f e
ee&ee&e+f f e,edddZ-ee d
ddZ.dd Z/eed d d Z0ee,ed d d!Z1e&ed"d#d$Z2eeee d%d&d'Z3e
ee e
d(d)d*Z4ejj*ed+d,d-Z5ejj*e
e&eed.d/d0Z6e&eeee&ejj*f e
ee&ee&e+f f eeef d1d2d3Z7eee&ejj*f eee,f e,d4d5d6Z8ee,d%d7d8Z9eee: d%d9d:Z;ee,d%d;d<Z
d?Z=dS )B N )
is_per_tensoris_per_channel)is_activation_post_process) GraphModulemap_arg)GraphNode) CallableOptionalListDictAnySetTupleUnionType c C s8 | j dd}t|dkr$d|d fS |d |d fS d S )N.r r )rsplitlen)targetr r G/usr/local/lib64/python3.6/site-packages/torch/quantization/fx/utils.py _parent_name& s r T)returnc C s t jd}t jd}dddddd}i }d}x|D ]}t|||< q2W g }x| jD ]
} t| j}
|rt|
jdd}
t| j} |r| |kr|| } t| j} |r|j | }
|
rd|
j
d d} |j | }|rd|j
d d} | jdd} t| j }|r|jdd}t| j }x8t
||
| | ||fD ] \}}t|| t|||< q(W |j|
| | ||g qTW d}d}||j||7 }x |D ]}||j||7 }qW |r|d7 }|S )zyReturns a printable representation of the ops in the graph of g.
If shorten is True, tries to abbreviate fields.
zz ZplchdrZgt_prmZcl_funZcl_modZcl_meth) placeholderget_attr
call_function call_module call_methodnameopr argskwargsactivation_post_processZobszz t | jstd| j \}}t|}t|}| j}|||fS )Nz)Only per tensor quantization is supported)r qschemeAssertionErrorcalculate_qparamsfloatintdtype)r( scale
zero_pointrE r r r get_per_tensor_qparamso s rH )r( r c C s | j }d}|tjtjgkrxd}| j \}}t| jrTt| j}||||d}tj }qt
|}t|}|||d}tj }n,|tj krd}d}d|i}nt
dt| |dk st|||fS ) z Given an activation_post_process module,
return node_type(e.g. call_function), quantize op(e.g. quantize_per_tensor) and a dictionary
of extracted qparams from the module
Nr! )_scale_ _zero_point_Z_axis__dtype_)rI rJ rK r# ZtorK z,Unsupported dtype in get_quantize_node_info:)rE torchZquint8qint8rB r r@ rD ch_axisZquantize_per_channelrC Zquantize_per_tensorfloat16 Exceptionr- rA )r( rE quantize_op node_typerF rG rN qparamsr r r get_quantize_node_infow s(
rT )in_node
obs_moduleobs_nodemodulesquantized_graphnode_name_to_scopeis_inputr c C s |r^t |j}|r|d nd}d} x,|D ]$}
|
jdkr(|
jtjjjkr(|
} P q(W | rX| }d} n| }d} |r|j|kr||j \} }
nd} |d }|}t |\}}}| g}xH|j
D ]<\}}|d krt ||| | | |}|j | q|j | qW |j
||t|i S )
a
Add quantization nodes (eg. quantize_per_tensor/per_channel) for given node to graph
with the qparams calculated from activation_post_process (obs_module).
The observer node (obs_node) is used to find the FQN of the user of act_post_process.
e.g. Given input `node` in `node = self.conv(x)`, insert node:
`quantized_node = torch.quantize_per_tensor(x, self._scale_0, self._zer_point_0, self._dtype_0)`
where self._scale_0, self._zero_point_0 and self._dtype_0 are
calculated from `obs_module`
r Nr! _input_outputr rI rJ )rI rJ )listusersr% r rL nn
functionallinearr$ rT itemscreate_getattr_from_valuer3 create_nodetuple)rU rV rW rX rY rZ r[ r_ Z first_linear_use_or_first_useZ linear_noder9 prefix module_path_ root_modulegraphrR rQ rS inputskeyvalueZ qparam_noder r r
quantize_node s4
ro c C sH t }| j|i }x,dD ]$}|j|i }t |j }||O }qW t|S )a_ Get all the unique custom module keys in the custom config dict
e.g.
Input:
custom_config_dict = {
"float_to_observed_custom_module_class": {
"static": {
CustomModule1: ObservedCustomModule
},
"dynamic": {
CustomModule2: DynamicObservedCustomModule
},
"weight_only": {
CustomModule3: WeightOnlyObservedCustomModule
},
},
}
Output:
# extract all the keys in "static", "dynamic" and "weight_only" dict
[CustomModule1, CustomModule2, CustomModule3]
staticdynamic weight_only)rp rq rr )setgetkeysr^ )Zcustom_config_dictZcustom_config_dict_keyZfloat_custom_module_classesZcustom_module_mappingZ
quant_modeZ quant_mode_custom_module_configZ quant_mode_custom_module_classesr r r get_custom_module_class_keys s
rv c C s6 | t jkrt jjjS | t jkr(t jjjS td| d S )Nz&can't get linear prepack op for dtype:)rL rO ops quantizedZlinear_prepack_fp16rM Zlinear_prepackrP )rE r r r get_linear_prepack_op_for_dtype s
ry )conv_opr c C sV t jjjt jjjt jjjt jjjt jjj t jjj
i}|j | d }|sRt dj
| |S )Nz Didn't find prepack op for {})rL r` ra conv1drw rx Zconv1d_prepackconv2dZconv2d_prepackconv3dZconv3d_prepackrt rA r4 )rz Z prepack_opsZ
prepack_opr r r get_qconv_prepack_op s r~ )rz has_relur c C s t jjjt jjjt jjjt jjjt jjj t jjj
it jjjt jjjt jjjt jjjt jjj t jjj id}|| j | }|st dj
| ||S )N)TFz4Can't find corresponding quantized conv op for {} {})rL r` ra r{ rw rx Z conv1d_relur| Z conv2d_relur} Z conv3d_relurt rA r4 )rz r Zqconv_opZqconvr r r get_qconv_op s r )rg r c s& j dd tjjd fdd }|S )Nr ri )modulec sB t d fdd }d}||}x t| |r<|d7 }||}q W |S )N)ic s t | S )N)r- )r )rg r r
get_attr_name s zOget_new_attr_name_with_prefix..get_new_attr_name..get_attr_namer r )rD hasattr)r r r attr_name)rg r r get_new_attr_name s z8get_new_attr_name_with_prefix..get_new_attr_name)r. rL r` Module)rg r r )rg r get_new_attr_name_with_prefix s r )noder c C s | g}| g}xx|r|j } t| jt| jj }xN|D ]F}t|tsHq8|jdkrVdS |j| |jdkor|j t
ks8|j| q8W qW |S )a Starting from a target node, trace back until we hit inpu or
getattr node. This is used to extract the chain of operators
starting from getattr to the target node, for example
def forward(self, x):
observed = self.observer(self.weight)
return F.linear(x, observed)
collect_producer_nodes(observed) will either return a list of nodes that
produces the observed node or None if we can't extract a self contained
graph without free variables(inputs of the forward function).
r Nr! ) popr^ r& r' values
isinstancer r% r3 r getattr)r r, ZfrontierZall_argsargr r r collect_producer_nodes# s
r )rootproducer_nodesr c sp t |dkstd|j t }i fdd}x |D ]}|j|| |< q8W |j||d t| |}|S )a- Construct a graph module from extracted producer nodes
from `collect_producer_nodes` function
Args:
root: the root module for the original graph
producer_nodes: a list of nodes we use to construct the graph
Return:
A graph module constructed from the producer nodes
r z'list of producer nodes can not be emptyc s t | fddS )Nc s | S )Nr )r )envr r O s zDgraph_module_from_producer_nodes..load_arg..)r )a)r r r load_argN s z2graph_module_from_producer_nodes..load_argr )r rA reverser Z node_copyoutputr )r r rk r Z
producer_nodeZ graph_moduler )r r graph_module_from_producer_nodes> s
r )r r c C s^ dd | j D dd | j D B }t|dks>tdj|t|dkrVtt|nd}|S )z
Returns the unique device for a module, or None if no device is found.
Throws an error if multiple devices are detected.
c S s h | ]
}|j qS r )device).0pr r r [ s z/assert_and_get_unique_device..c S s h | ]
}|j qS r )r )r r r r r r \ s r zMprepare only works with cpu or single-device CUDA modules, but got devices {}r N)
parametersbuffersr rA r4 nextiter)r Zdevicesr r r r assert_and_get_unique_deviceV s r )r rk rg rn r c C s> t |}|| }t| }| j|tj||d |jd|}|S )z
Given a value of any type, creates a getattr node corresponding to the value and
registers the value as a buffer to the module.
)r r )r r Zregister_bufferrL Ztensorre )r rk rg rn r r r Z attr_noder r r rd d s rd ) node_namerF rG rX rY rZ r c C s@ |d }|| \}}t |||d |} t |||d |}
| |
fS )z
Create getattr nodes in the quantized graph for scale and zero point values.
The nodes are registered with the root_module of the model.
r rI rJ )rd ) r rF rG rX rY rZ rj rh ri Z
scale_nodeZzero_point_noder r r create_qparam_nodesq s
r )r rX cacher c C s |r| |kr|| S d}t | ts*d}n| jdkr Zfound_one_tensorr Zlist_elZ!this_list_el_args_have_no_tensorsZ this_arg_args_have_no_tensorsr r r r sd
r c C s | j dko| jdkS )zd
Returns true if this node results in an integer, even if some of the args
are Tensors.
r# r )r% r )r r r r node_return_type_is_int s r c C s | j dkr| jdkrdgS g S )z0
Returns indexes of boolean Tensor args
r# Z masked_fillr )r% r )r r r r node_bool_tensor_arg_indexes s r c C s& | j dko | jtko | jd dk}|S )z Returns True if this node is a node that takes a Tensor as input and output some
meta information about the Tensor, e.g. shape, size etc.
r! r r )r% r r r& )r r> r r r is_get_tensor_info_node s "r )r rX target_module_typetarget_functional_typer c C sf x`| j j D ]R\}}|jdkr>|dk r>t|t|j |r>|S |jdkr |dk r |j|kr |S q W dS )a% Gets the next module that matches what is needed in
is_target_module_type if it exists
Args:
node: The node whose users we want to look at
target_module_type: Module type that we want to check
target_functional_type: Functional type that we want to check
r" Nr! )r_ rc r% r r- r )r rX r r userri r r r maybe_get_next_module s
r )T)NN)>r* rL Ztorch.nnr` utilsr r Z torch.ao.quantization.quantizer Ztorch.fxr r Ztorch.fx.graphr r typingr
r r r
r r r r r r ra r{ r| r} rb Z
layer_normZ
group_normZ
instance_normZWEIGHT_INDEX_DICTZNON_QUANTIZABLE_WEIGHT_OPSZFUNCTIONAL_OPS_WITH_BIASr r- r? rH rT r typeboolro rv ry r~ r r r r r rd r r r rD r r r r r r r sl
, B* 3
(L