class_docstr: This function implements SincConv (SincNet).
  
  M. Ravanelli, Y. Bengio, "Speaker Recognition from raw waveform with
  SincNet", in Proc. of  SLT 2018 (https://arxiv.org/abs/1808.00158)
  
  Arguments
  ---------
  input_shape : tuple
      The shape of the input. Alternatively use ``in_channels``.
  in_channels : int
      The number of input channels. Alternatively use ``input_shape``.
  out_channels : int
      It is the number of output channels.
  kernel_size: int
      Kernel size of the convolutional filters.
  stride : int
      Stride factor of the convolutional filters. When the stride factor > 1,
      a decimation in time is performed.
  dilation : int
      Dilation factor of the convolutional filters.
  padding : str
      (same, valid, causal). If "valid", no padding is performed.
      If "same" and stride is 1, output shape is the same as the input shape.
      "causal" results in causal (dilated) convolutions.
  padding_mode : str
      This flag specifies the type of padding. See torch.nn documentation
      for more information.
  groups : int
      This option specifies the convolutional groups. See torch.nn
      documentation for more information.
  bias : bool
      If True, the additive bias b is adopted.
  sample_rate : int,
      Sampling rate of the input signals. It is only used for sinc_conv.
  min_low_hz : float
      Lowest possible frequency (in Hz) for a filter. It is only used for
      sinc_conv.
  min_low_hz : float
      Lowest possible value (in Hz) for a filter bandwidth.
  
  Example
  -------
  >>> inp_tensor = torch.rand([10, 16000])
  >>> conv = SincConv(input_shape=inp_tensor.shape, out_channels=25, kernel_size=11)
  >>> out_tensor = conv(inp_tensor)
  >>> out_tensor.shape
  torch.Size([10, 16000, 25])
docstr: This functions creates the sinc-filters to used for sinc-conv.
docstr_tok: ["This","functions","creates","the","sinc-filters","to","used","for","sinc-conv","."]
code: def _get_sinc_filters(
      self,
  ):
      """This functions creates the sinc-filters to used for sinc-conv."""
      # Computing the low frequencies of the filters
      low = self.min_low_hz + torch.abs(self.low_hz_)
  
      # Setting minimum band and minimum freq
      high = torch.clamp(
          low + self.min_band_hz + torch.abs(self.band_hz_),
          self.min_low_hz,
          self.sample_rate / 2,
      )
      band = (high - low)[:, 0]
  
      # Passing from n_ to the corresponding f_times_t domain
      self.n_ = self.n_.to(self.device)
      self.window_ = self.window_.to(self.device)
      f_times_t_low = torch.matmul(low, self.n_)
      f_times_t_high = torch.matmul(high, self.n_)
  
      # Left part of the filters.
      band_pass_left = (
          (torch.sin(f_times_t_high) - torch.sin(f_times_t_low))
          / (self.n_ / 2)
      ) * self.window_
  
      # Central element of the filter
      band_pass_center = 2 * band.view(-1, 1)
  
      # Right part of the filter (sinc filters are symmetric)
      band_pass_right = torch.flip(band_pass_left, dims=[1])
  
      # Combining left, central, and right part of the filter
      band_pass = torch.cat(
          [band_pass_left, band_pass_center, band_pass_right], dim=1
      )
  
      # Amplitude normalization
      band_pass = band_pass / (2 * band[:, None])
  
      # Setting up the filter coefficients
      filters = band_pass.view(self.out_channels, 1, self.kernel_size)
  
      return filters
  
imports: import math
  import torch
  import logging
  import numpy
  import torch.nn
  import torch.nn.functional
  import torchaudio
  from typing import Tuple
  from speechbrain.processing.signal_processing import gabor_impulse_response, gabor_impulse_response_legacy_complex
label_desc: Use image node_id 4 for calling the SincConv obj's underlying member method code with example usage: obj._get_sinc_filters() and returns: filters