code: def compute_smoothed_feasibility_indicator(
      constraints: List[Callable[[Tensor], Tensor]],
      samples: Tensor,
      eta: Union[Tensor, float],
      log: bool = False,
      fat: bool = False,
  ) -> Tensor:
      r"""Computes the smoothed feasibility indicator of a list of constraints.
  
      Given posterior samples, using a sigmoid to smoothly approximate the feasibility
      indicator of each individual constraint to ensure differentiability and high
      gradient signal. The `fat` and `log` options improve the numerical behavior of
      the smooth approximation.
  
      NOTE: *Negative* constraint values are associated with feasibility.
  
      Args:
          constraints: A list of callables, each mapping a Tensor of size `b x q x m`
              to a Tensor of size `b x q`, where negative values imply feasibility.
              This callable must support broadcasting. Only relevant for multi-
              output models (`m` > 1).
          samples: A `n_samples x b x q x m` Tensor of samples drawn from the posterior.
          eta: The temperature parameter for the sigmoid function. Can be either a float
              or a 1-dim tensor. In case of a float the same eta is used for every
              constraint in constraints. In case of a tensor the length of the tensor
              must match the number of provided constraints. The i-th constraint is
              then estimated with the i-th eta value.
          log: Toggles the computation of the log-feasibility indicator.
          fat: Toggles the computation of the fat-tailed feasibility indicator.
  
      Returns:
          A `n_samples x b x q`-dim tensor of feasibility indicator values.
      """
      if type(eta) is not Tensor:
          eta = torch.full((len(constraints),), eta)
      if len(eta) != len(constraints):
          raise ValueError(
              "Number of provided constraints and number of provided etas do not match."
          )
      if not (eta > 0).all():
          raise ValueError("eta must be positive.")
      is_feasible = torch.zeros_like(samples[..., 0])
      log_sigmoid = log_fatmoid if fat else logexpit
      for constraint, e in zip(constraints, eta):
          is_feasible = is_feasible + log_sigmoid(
              -constraint(samples) / e
          )
  
      return is_feasible if log else is_feasible.exp()
  
file_path: botorch/botorch/utils/objective.py
imports: from __future__ import annotations
  import warnings
  from typing import Callable, List, Optional, Union
  import torch
  from botorch.utils.safe_math import log_fatmoid, logexpit
  from botorch.utils.transforms import normalize_indices
  from torch import Tensor
label_desc: Use image node_id 4 for calling a global function with example usage: compute_smoothed_feasibility_indicator(constraints, samples, eta, log, fat) and returns: unknown