class_docstr: Arguments:
  Apply gaussian smoothing on a 1d, 2d or 3d tensor. Filtering is performed seperately for each channel in the input
  using a depthwise convolution.
      channels (int, sequence): Number of channels of the input tensors. Output will
          have this number of channels as well.
      kernel_size (int, sequence): Size of the gaussian kernel. sigma (float, sequence): Standard deviation of the
      gaussian kernel. dim (int, optional): The number of dimensions of the data.
          Default value is 2 (spatial).
class_docstr_tok: ["Arguments",":","Apply","gaussian","smoothing","on","a","1d",",","2d","or","3d","tensor",".","Filtering","is","performed","seperately","for","each","channel","in","the","input","using","a","depthwise","convolution",".","channels","(","int",",","sequence",")",":","Number","of","channels","of","the","input","tensors",".","Output","will","have","this","number","of","channels","as","well",".","kernel_size","(","int",",","sequence",")",":","Size","of","the","gaussian","kernel",".","sigma","(","float",",","sequence",")",":","Standard","deviation","of","the","gaussian","kernel",".","dim","(","int",",","optional",")",":","The","number","of","dimensions","of","the","data",".","Default","value","is","2","(","spatial",")","."]
code: def __init__(
      self,
      channels: int = 1,
      kernel_size: int = 3,
      sigma: float = 0.5,
      dim: int = 2,
  ):
      super().__init__()
  
      if isinstance(kernel_size, int):
          kernel_size = [kernel_size] * dim
      if isinstance(sigma, float):
          sigma = [sigma] * dim
  
      # The gaussian kernel is the product of the
      # gaussian function of each dimension.
      kernel = 1
      meshgrids = torch.meshgrid(
          [
              torch.arange(size, dtype=torch.float32)
              for size in kernel_size
          ]
      )
      for size, std, mgrid in zip(kernel_size, sigma, meshgrids):
          mean = (size - 1) / 2
          kernel *= (
              1
              / (std * math.sqrt(2 * math.pi))
              * torch.exp(-(((mgrid - mean) / (2 * std)) ** 2))
          )
  
      # Make sure sum of values in gaussian kernel equals 1.
      kernel = kernel / torch.sum(kernel)
  
      # Reshape to depthwise convolutional weight
      kernel = kernel.view(1, 1, *kernel.size())
      kernel = kernel.repeat(channels, *[1] * (kernel.dim() - 1))
  
      self.register_buffer("weight", kernel)
      self.groups = channels
  
      if dim == 1:
          self.conv = F.conv1d
      elif dim == 2:
          self.conv = F.conv2d
      elif dim == 3:
          self.conv = F.conv3d
      else:
          raise RuntimeError(
              "Only 1, 2 and 3 dimensions are supported. Received {}.".format(
                  dim
              )
          )
  
imports: import inspect
  import math
  from typing import Any, Callable, Dict, List, Optional, Tuple, Union
  import numpy
  import torch
  from torch.nn import functional
  from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer
  from ...image_processor import VaeImageProcessor
  from ...loaders import LoraLoaderMixin, TextualInversionLoaderMixin
  from ...models import AutoencoderKL, UNet2DConditionModel
  from ...models.attention_processor import Attention
  from ...models.lora import adjust_lora_scale_text_encoder
  from ...schedulers import KarrasDiffusionSchedulers
  from ...utils import USE_PEFT_BACKEND, deprecate, logging, replace_example_docstring, scale_lora_layers, unscale_lora_layers
  from ...utils.torch_utils import randn_tensor
  from ..pipeline_utils import DiffusionPipeline
  from ..stable_diffusion import StableDiffusionPipelineOutput
  from ..stable_diffusion.safety_checker import StableDiffusionSafetyChecker
label_desc: Use image node_id 1 to create a new GaussianSmoothing object from inherited base classes: torch.nn with example: obj = GaussianSmoothing(channels, kernel_size, sigma, dim)