


"""simple docstring"""
# Lint as: python3
import sys
from collections.abc import Mapping
from typing import TYPE_CHECKING, Dict, Optional

import numpy as np
import pyarrow as pa

from .. import config
from ..utils.logging import get_logger
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter


if TYPE_CHECKING:
 import jax
 import jaxlib

UpperCAmelCase				=						get_logger()

UpperCAmelCase				=						None




class 	lowercase__				(					TensorFormatter[Mapping, '''jax.Array''', Mapping]				):





   def __init__(							self      ,   SCREAMING_SNAKE_CASE=None      ,   SCREAMING_SNAKE_CASE=None      ,   **SCREAMING_SNAKE_CASE)  ->  int:
      super().__init__(features=SCREAMING_SNAKE_CASE)
      import jax
      from jaxlib.xla_client import Device

      if isinstance(SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE):
         raise ValueError(
             F'Expected {device} to be a `str` not {type(SCREAMING_SNAKE_CASE)}, as `jaxlib.xla_extension.Device` '
             """is not serializable neither with `pickle` nor with `dill`. Instead you can surround """
             """the device with `str()` to get its string identifier that will be internally mapped """
             """to the actual `jaxlib.xla_extension.Device`.""")
      _lowerCamelCase	:					str   =		device if isinstance(SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE) else str(jax.devices()[0])
      # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
      # with `pickle` nor with `dill`, so we need to use a global variable instead
      global DEVICE_MAPPING
      if DEVICE_MAPPING is None:
         _lowerCamelCase	:					Optional[int]   =		self._map_devices_to_str()
      if self.device not in list(DEVICE_MAPPING.keys()):
         logger.warning(
             F'Device with string identifier {self.device} not listed among the available '
             F'devices: {list(DEVICE_MAPPING.keys())}, so falling back to the default '
             F'device: {str(jax.devices()[0])}.')
         _lowerCamelCase	:					str   =		str(jax.devices()[0])
      _lowerCamelCase	:					Tuple   =		jnp_array_kwargs





   @staticmethod
   def 		UpperCamelCase_  (							)  ->  Dict[str, "jaxlib.xla_extension.Device"]:
      import jax

      return {str(SCREAMING_SNAKE_CASE): device for device in jax.devices()}





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  List[Any]:
      import jax
      import jax.numpy as jnp

      if isinstance(SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE) and column:
         if all(
             isinstance(SCREAMING_SNAKE_CASE      ,   jax.Array) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column):
            return jnp.stack(SCREAMING_SNAKE_CASE      ,   axis=0)
      return column





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  Optional[Any]:
      import jax
      import jax.numpy as jnp

      if isinstance(SCREAMING_SNAKE_CASE      ,   (str, bytes, type(SCREAMING_SNAKE_CASE))):
         return value
      elif isinstance(SCREAMING_SNAKE_CASE      ,   (np.character, np.ndarray)) and np.issubdtype(value.dtype      ,   np.character):
         return value.tolist()

      _lowerCamelCase	:					List[str]   =		{}

      if isinstance(SCREAMING_SNAKE_CASE      ,   (np.number, np.ndarray)) and np.issubdtype(value.dtype      ,   np.integer):
         # the default int precision depends on the jax config
         # see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision
         if jax.config.jax_enable_xaa:
            _lowerCamelCase	:					int   =		{"""dtype""": jnp.intaa}
         else:
            _lowerCamelCase	:					Dict   =		{"""dtype""": jnp.intaa}
      elif isinstance(SCREAMING_SNAKE_CASE      ,   (np.number, np.ndarray)) and np.issubdtype(value.dtype      ,   np.floating):
         _lowerCamelCase	:					Any   =		{"""dtype""": jnp.floataa}
      elif config.PIL_AVAILABLE and "PIL" in sys.modules:
         import PIL.Image

         if isinstance(SCREAMING_SNAKE_CASE      ,   PIL.Image.Image):
            _lowerCamelCase	:					List[Any]   =		np.asarray(SCREAMING_SNAKE_CASE)

        # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
        # with `pickle` nor with `dill`, so we need to use a global variable instead
      global DEVICE_MAPPING
      if DEVICE_MAPPING is None:
         _lowerCamelCase	:					List[Any]   =		self._map_devices_to_str()

      with jax.default_device(DEVICE_MAPPING[self.device]):
         # calling jnp.array on a np.ndarray does copy the data
         # see https://github.com/google/jax/issues/4486
         return jnp.array(SCREAMING_SNAKE_CASE      ,   **{**default_dtype, **self.jnp_array_kwargs})





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  Any:
      import jax

      # support for torch, tf, jax etc.
      if config.TORCH_AVAILABLE and "torch" in sys.modules:
         import torch

         if isinstance(SCREAMING_SNAKE_CASE      ,   torch.Tensor):
            return self._tensorize(data_struct.detach().cpu().numpy()[()])
      if hasattr(SCREAMING_SNAKE_CASE      ,   """__array__""") and not isinstance(SCREAMING_SNAKE_CASE      ,   jax.Array):
         _lowerCamelCase	:					str   =		data_struct.__array__()
      # support for nested types like struct of list of struct
      if isinstance(SCREAMING_SNAKE_CASE      ,   np.ndarray):
         if data_struct.dtype == object:  # jax arrays cannot be instantied from an array of objects
            return self._consolidate([self.recursive_tensorize(SCREAMING_SNAKE_CASE) for substruct in data_struct])
      elif isinstance(SCREAMING_SNAKE_CASE      ,   (list, tuple)):
         return self._consolidate([self.recursive_tensorize(SCREAMING_SNAKE_CASE) for substruct in data_struct])
      return self._tensorize(SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  int:
      return map_nested(self._recursive_tensorize      ,   SCREAMING_SNAKE_CASE      ,   map_list=SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  Mapping:
      _lowerCamelCase	:					List[str]   =		self.numpy_arrow_extractor().extract_row(SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					List[str]   =		self.python_features_decoder.decode_row(SCREAMING_SNAKE_CASE)
      return self.recursive_tensorize(SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  "jax.Array":
      _lowerCamelCase	:					str   =		self.numpy_arrow_extractor().extract_column(SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					int   =		self.python_features_decoder.decode_column(SCREAMING_SNAKE_CASE      ,   pa_table.column_names[0])
      _lowerCamelCase	:					List[str]   =		self.recursive_tensorize(SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					Any   =		self._consolidate(SCREAMING_SNAKE_CASE)
      return column





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  Mapping:
      _lowerCamelCase	:					Optional[int]   =		self.numpy_arrow_extractor().extract_batch(SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					Union[str, Any]   =		self.python_features_decoder.decode_batch(SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					Dict   =		self.recursive_tensorize(SCREAMING_SNAKE_CASE)
      for column_name in batch:
         _lowerCamelCase	:					int   =		self._consolidate(batch[column_name])
      return batch





"""simple docstring"""
import numpy as np

def 				_snake_case      (   __snake_case							:      np.ndarray   ):




   """simple docstring"""







   return 1 / (1 + np.exp(-vector   ))

def 				_snake_case      (   __snake_case							:      np.ndarray   ):




   """simple docstring"""







   return vector * sigmoid(__snake_case   )


if __name__ == "__main__":
 import doctest

 doctest.testmod()

