class_docstr: Transforms the weights of a Conv2D kernel to a format suitable for Wingorad convolution
  For further information, refer to Lavin & Gray, 2015 - Fast Algorithms for Convolutional Neural Networks
code: def match(self, node):
      node_matches = isinstance(node, (Conv1D, Conv2D))
  
      # This optimizer works only after the Resource Strategy Optimizer, since order of transposition matters
      weights_transformed = (
          node.get_attr("_weights_transposed", False) is True
      )
  
      # User opted for Winograd
      implementation_is_winograd = (
          node.get_attr("implementation", "combination")
          == "combination"
          or node.get_attr("implementation", "combination")
          == "winograd"
      )
  
      parallel_io_type = (
          node.model.config.get_config_value("IOType") == "io_parallel"
      )
  
      # Winograd algorithm-specific conditions
      if isinstance(node, Conv1D):
          # Winograd only applies to specific kernel sizes
          # Current implementation only supports fs = 3; easily extendable to other filter sizes
          filter_size_matches = node.get_attr("filt_width", 3) == 3
  
          # Winograd's minimal filtering algorithm doesn't work with stride != 1
          stride_is_one = node.get_attr("stride_width", 1) == 1
  
          # HLS Compiler fails to pipeline the entire component if Winograd loop only executes once
          loop_itr_gt_one = node.get_attr("out_width") > 2
  
          winograd_conditions = (
              filter_size_matches
              and stride_is_one
              and loop_itr_gt_one
              and parallel_io_type
          )
  
      elif isinstance(node, (Conv2D)):
          # Winograd only applies to specific kernel sizes
          # Current implementation only supports fs = 3; easily extendable to other filter sizes
          filter_size_matches = (
              node.get_attr("filt_height", 3) == 3
              and node.get_attr("filt_width", 3) == 3
          )
  
          # Winograd's minimal filtering algorithm doesn't work with striede != 1
          stride_is_one = (
              node.get_attr("stride_height", 1) == 1
              and node.get_attr("stride_width", 1) == 1
          )
  
          # HLS Compiler fails to pipeline the entire component if Winograd loop only executes once
          loop_itr_gt_one = (
              node.get_attr("out_height") > 2
              and node.get_attr("out_width") > 2
          )
  
          padding_is_equal = node.get_attr(
              "pad_top", 0
          ) == node.get_attr("pad_bottom", 0) and node.get_attr(
              "pad_left", 0
          ) == node.get_attr(
              "pad_right", 0
          )
  
          winograd_conditions = (
              filter_size_matches
              and stride_is_one
              and padding_is_equal
              and loop_itr_gt_one
              and parallel_io_type
          )
  
      else:
          winograd_conditions = False
  
      # Check any previous transformations
      already_transformed = (
          node.get_attr("_winograd_transformation_applied", False)
          is True
      )
  
      if (
          not winograd_conditions
          and node.get_attr("implementation", "combination")
          == "winograd"
      ):
          raise RuntimeError(
              "Not possible to use Winograd algorithm with current architecture. "
              "Please set implementation to im2col or combination"
          )
  
      return (
          node_matches
          and weights_transformed
          and winograd_conditions
          and not already_transformed
          and implementation_is_winograd
      )
  
imports: import math
  import numpy
  from hls4ml.model.layers import Conv1D, Conv2D
  from hls4ml.model.optimizer import OptimizerPass
label_desc: Use image node_id 1 for calling the ApplyWinogradKernelTransformation obj's underlying member method code with example usage: obj.match(node) and returns: unknown