code: def gaussian_nll_loss(
      input, target, var, full=False, eps=1e-6, reduction="mean"
  ):
      input, target = torch_frontend.promote_types_of_torch_inputs(
          input, target
      )
      target, var = torch_frontend.promote_types_of_torch_inputs(
          target, var
      )
      if var.shape != input.shape:
          if input.shape[:-1] == var.shape:
              var = torch_frontend.unsqueeze(var, dim=2)
          elif (
              input.shape[:-1] == var.shape[:-1] and var.shape[-1] == 1
          ):
              pass
          else:
              raise ivy.utils.exceptions.IvyError(
                  "var is of incorrect size"
              )
  
      if (
          reduction is not None
          and reduction != "mean"
          and reduction != "sum"
      ):
          raise ivy.utils.exceptions.IvyError(
              f"{reduction} is not valid"
          )
  
      if ivy.any(var < 0):
          raise ivy.utils.exceptions.IvyError(
              "var has negative entry/entries"
          )
  
      var = ivy.maximum(var, eps)
  
      loss = 0.5 * (ivy.log(var) + (input - target) ** 2 / var)
  
      if full:
          loss += 0.5 * ivy.log(2 * ivy.pi)
  
      reduction = _get_reduction_func(reduction)
      ret = reduction(loss)
  
      return ret.astype(input.dtype)
  
imports: import ivy
  import ivy.functional.frontends.torch
  from ivy.functional.frontends.torch.func_wrapper import to_ivy_arrays_and_back
  from ivy.func_wrapper import with_unsupported_dtypes, with_supported_dtypes
label_desc: Use image node_id 11 for calling a global function with example usage: gaussian_nll_loss(input, target, var, full, eps, reduction) and returns: ret