parameters: ()
return_statement: return results
docstring: Set of potential fusions, in reverse order.  The order is reversed
      to match how fusion patterns are defined in quantization code.
  
      Fusion format:
      ((fusion_op_0, fusion_op_1), base_op_idx)
  
      Where base_op_idx is the idx of the op we should use to match other related
      ops. Note: base_op_idx is specified in non-reverse order, i.e. a base_op_idx
      of 0 represents the first op in regular (non-reverse) order, 1 represents the
      second op, etc.
docstring_summary: Set of potential fusions, in reverse order.  The order is reversed
      to match how fusion patterns are defined in quantization code.
docstring_tokens: Set of potential fusions in reverse order . The order is reversed to match how fusion patterns are defined in quantization code .
function: def get_reversed_fusions() -> List[Tuple[NSFusionType, int]]:
      """
      Set of potential fusions, in reverse order.  The order is reversed
      to match how fusion patterns are defined in quantization code.
  
      Fusion format:
      ((fusion_op_0, fusion_op_1), base_op_idx)
  
      Where base_op_idx is the idx of the op we should use to match other related
      ops. Note: base_op_idx is specified in non-reverse order, i.e. a base_op_idx
      of 0 represents the first op in regular (non-reverse) order, 1 represents the
      second op, etc.
      """
      results: List[Tuple[NSFusionType, int]] = []
  
      # Possible syntaxes:
      # * single op: torch.nn.Conv2d
      # * multiple ops: (torch.nn.ReLU, torch.nn.Conv2d)
      # For fusions, we only care about patterns composed of multiple ops.
      # TODO(future PR): allow customizations from default patterns.
      all_quant_patterns = get_default_quant_patterns()
      default_base_op_idx = 0
      for quant_pattern, _quant_handler in all_quant_patterns.items():
          # Only patterns of multiple ops are fusions, ignore
          # patterns which contain a single ops (they get matched
          # without caring about fusions).
          if isinstance(quant_pattern, tuple):
              results.append((quant_pattern, default_base_op_idx))  # type: ignore[arg-type]
  
          # For each pattern, add additional patterns with observers and
          # fake quants at the end.
          # TODO(future PR): if needed, implement matching for a node
          #   having multiple output observers.
          for cls in (ObserverBase, FakeQuantizeBase):
              if isinstance(quant_pattern, tuple):
                  new_pattern = (cls, *quant_pattern)
              else:
                  new_pattern = (cls, quant_pattern)
              results.append((new_pattern, default_base_op_idx))  # type: ignore[arg-type]
  
  
      # After this point, results countains values such as
      # [..., ((torch.nn.Relu, torch.nn.Conv2d), 0), ...]
  
      # Patterns for matching fp16 emulation are not specified in the quantization
      # fusion mappings.  For now, define them here.
      fp16_em_base_op_idx = 1
      patterns_to_add = [
          # linear-relu fp16 emulation:
          # fp16_to_fp32 -> linear -> relu -> fp32_to_fp16
          ((("to", torch.float16), F.relu, F.linear, "dequantize"), fp16_em_base_op_idx,),
          # Conv-BN fusion (this happens outside of quantization patterns,
          # which is why it is defined separately here).
          ((nn.BatchNorm1d, nn.Conv1d), default_base_op_idx),
          ((nn.BatchNorm2d, nn.Conv2d), default_base_op_idx),
          ((nn.BatchNorm3d, nn.Conv3d), default_base_op_idx),
          ((nn.ReLU, nn.BatchNorm1d, nn.Conv1d), default_base_op_idx),
          ((nn.ReLU, nn.BatchNorm2d, nn.Conv2d), default_base_op_idx),
          ((nn.ReLU, nn.BatchNorm3d, nn.Conv3d), default_base_op_idx),
      ]
      for p in patterns_to_add:
          results.append(p)  # type: ignore[arg-type]
          results.append(((ObserverBase, *p[0]), p[1]))  # type: ignore[arg-type]
          results.append(((FakeQuantizeBase, *p[0]), p[1]))  # type: ignore[arg-type]
  
      return results
function_tokens: def get_reversed_fusions ( ) -> List [ Tuple [ NSFusionType , int ] ] : results : List [ Tuple [ NSFusionType , int ] ] = [ ] # Possible syntaxes: # * single op: torch.nn.Conv2d # * multiple ops: (torch.nn.ReLU, torch.nn.Conv2d) # For fusions, we only care about patterns composed of multiple ops. # TODO(future PR): allow customizations from default patterns. all_quant_patterns = get_default_quant_patterns ( ) default_base_op_idx = 0 for quant_pattern , _quant_handler in all_quant_patterns . items ( ) : # Only patterns of multiple ops are fusions, ignore # patterns which contain a single ops (they get matched # without caring about fusions). if isinstance ( quant_pattern , tuple ) : results . append ( ( quant_pattern , default_base_op_idx ) ) # type: ignore[arg-type] # For each pattern, add additional patterns with observers and # fake quants at the end. # TODO(future PR): if needed, implement matching for a node #   having multiple output observers. for cls in ( ObserverBase , FakeQuantizeBase ) : if isinstance ( quant_pattern , tuple ) : new_pattern = ( cls , * quant_pattern ) else : new_pattern = ( cls , quant_pattern ) results . append ( ( new_pattern , default_base_op_idx ) ) # type: ignore[arg-type] # After this point, results countains values such as # [..., ((torch.nn.Relu, torch.nn.Conv2d), 0), ...] # Patterns for matching fp16 emulation are not specified in the quantization # fusion mappings.  For now, define them here. fp16_em_base_op_idx = 1 patterns_to_add = [ # linear-relu fp16 emulation: # fp16_to_fp32 -> linear -> relu -> fp32_to_fp16 ( ( ( "to" , torch . float16 ) , F . relu , F . linear , "dequantize" ) , fp16_em_base_op_idx , ) , # Conv-BN fusion (this happens outside of quantization patterns, # which is why it is defined separately here). ( ( nn . BatchNorm1d , nn . Conv1d ) , default_base_op_idx ) , ( ( nn . BatchNorm2d , nn . Conv2d ) , default_base_op_idx ) , ( ( nn . BatchNorm3d , nn . Conv3d ) , default_base_op_idx ) , ( ( nn . ReLU , nn . BatchNorm1d , nn . Conv1d ) , default_base_op_idx ) , ( ( nn . ReLU , nn . BatchNorm2d , nn . Conv2d ) , default_base_op_idx ) , ( ( nn . ReLU , nn . BatchNorm3d , nn . Conv3d ) , default_base_op_idx ) , ] for p in patterns_to_add : results . append ( p ) # type: ignore[arg-type] results . append ( ( ( ObserverBase , * p [ 0 ] ) , p [ 1 ] ) ) # type: ignore[arg-type] results . append ( ( ( FakeQuantizeBase , * p [ 0 ] ) , p [ 1 ] ) ) # type: ignore[arg-type] return results