code: def find_interior_point(
      A: np.ndarray,
      b: np.ndarray,
      A_eq: Optional[np.ndarray] = None,
      b_eq: Optional[np.ndarray] = None,
  ) -> np.ndarray:
      r"""Find an interior point of a polytope via linear programming.
  
      Args:
          A: A `n_ineq x d`-dim numpy array containing the coefficients of the
              constraint inequalities.
          b: A `n_ineq x 1`-dim numpy array containing the right hand sides of
              the constraint inequalities.
          A_eq: A `n_eq x d`-dim numpy array containing the coefficients of the
              constraint equalities.
          b_eq: A `n_eq x 1`-dim numpy array containing the right hand sides of
              the constraint equalities.
  
      Returns:
          A `d`-dim numpy array containing an interior point of the polytope.
          This function will raise a ValueError if there is no such point.
  
      This method solves the following Linear Program:
  
          min -s subject to A @ x <= b - 2 * s, s >= 0, A_eq @ x = b_eq
  
      In case the polytope is unbounded, then it will also constrain the slack
      variable `s` to `s<=1`.
      """
      # augment inequality constraints: A @ (x, s) <= b
      d = A.shape[-1]
      ncon = A.shape[-2] + 1
      c = np.zeros(d + 1)
      c[-1] = -1
      b_ub = np.zeros(ncon)
      b_ub[:-1] = b.reshape(-1)
      A_ub = np.zeros((ncon, d + 1))
      A_ub[:-1, :-1] = A
      A_ub[:-1, -1] = 2.0
      A_ub[-1, -1] = -1.0
  
      result = scipy.optimize.linprog(
          c=c,
          A_ub=A_ub,
          b_ub=b_ub,
          A_eq=A_eq,
          b_eq=b_eq,
          bounds=(None, None),
          method="highs",
      )
  
      if result.status == 3:
          # problem is unbounded - to find a bounded solution we constrain the
          # slack variable `s` to `s <= 1.0`.
          A_s = np.concatenate(
              [np.zeros((1, d)), np.ones((1, 1))], axis=-1
          )
          A_ub = np.concatenate([A_ub, A_s], axis=0)
          b_ub = np.concatenate([b_ub, np.ones(1)], axis=-1)
          result = scipy.optimize.linprog(
              c=c,
              A_ub=A_ub,
              b_ub=b_ub,
              A_eq=A_eq,
              b_eq=b_eq,
              bounds=(None, None),
              method="highs",
          )
  
      if result.status == 2:
          raise ValueError(
              "No feasible point found. Constraint polytope appears empty. "
              + "Check your constraints."
          )
      elif result.status > 0:
          raise ValueError(
              "Problem checking constraint specification. "
              + "linprog status: {}".format(result.message)
          )
      # the x in the result is really (x, s)
      return result.x[:-1]
  
imports: from __future__ import annotations
  from abc import ABC, abstractmethod
  from contextlib import contextmanager
  from typing import Any, Generator, Iterable, List, Optional, Tuple, TYPE_CHECKING
  import numpy
  import scipy
  import torch
  from botorch.exceptions.errors import BotorchError
  from botorch.sampling.qmc import NormalQMCEngine
  from botorch.utils.transforms import unnormalize
  from scipy.spatial import Delaunay, HalfspaceIntersection
  from torch import LongTensor, Tensor
  from torch.quasirandom import SobolEngine
label_desc: Use image node_id 9 for calling a global function with example usage: find_interior_point(A, b, A_eq, b_eq) and returns: result