code: def poisson_nll_loss(
      input: tf.Tensor,
      target: tf.Tensor,
      *,
      log_input: bool = True,
      full: bool = False,
      eps: float = 1e-8,
      reduction: str = "mean",
  ) -> tf.Tensor:
      input_tensor = tf.constant(input, dtype=input.dtype)
      target_tensor = tf.constant(target, dtype=input.dtype)
  
      _validate_poisson_nll_params(
          input_tensor, target_tensor, eps, reduction
      )
      if log_input:
          loss = (
              tf.math.exp(input_tensor) - target_tensor * input_tensor
          )
      else:
          loss = input_tensor - target_tensor * tf.math.log(
              input_tensor + eps
          )
      if full:
          point_five = tf.constant(0.5, dtype=target_tensor.dtype)
          two_pi = tf.constant(2 * math.pi, dtype=target_tensor.dtype)
  
          stirling_approx = (
              (target_tensor * tf.math.log(target_tensor))
              - target_tensor
              + (point_five * tf.math.log(two_pi * target_tensor))
          )
          zeros = tf.zeros_like(
              target_tensor, dtype=target_tensor.dtype
          )
          ones = tf.ones_like(target_tensor, dtype=target_tensor.dtype)
          cond = tf.math.logical_and(
              target_tensor >= zeros, target_tensor <= ones
          )
          loss = loss + tf.where(cond, zeros, stirling_approx)
      return _apply_loss_reduction(loss, reduction)
  
file_path: ivy/ivy/functional/backends/tensorflow/experimental/losses.py
imports: import tensorflow
  import math
  from typing import Optional
  from ivy.func_wrapper import with_unsupported_dtypes, with_supported_device_and_dtypes
  from .None import backend_version
label_desc: Use image node_id 6 for calling a global function with example usage: poisson_nll_loss(input, target) and returns: _apply_loss_reduction