




'''simple docstring'''
import tempfile
import unittest

import numpy as np

import transformers
from transformers import GPTaConfig, GPTaTokenizer, is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
  import jax
  import jax.numpy as jnp

  from transformers.modeling_flax_pytorch_utils import (
      convert_pytorch_state_dict_to_flax,
      load_flax_weights_in_pytorch_model,
  )
  from transformers.models.gpta.modeling_flax_gpta import FlaxGPTaLMHeadModel, FlaxGPTaModel

if is_torch_available():
  import torch






class 			SCREAMING_SNAKE_CASE:

       def __init__(       self   ,						lowerCamelCase__   ,						lowerCamelCase__=14   ,						lowerCamelCase__=7   ,						lowerCamelCase__=True   ,						lowerCamelCase__=True   ,						lowerCamelCase__=False   ,						lowerCamelCase__=True   ,						lowerCamelCase__=99   ,						lowerCamelCase__=32   ,						lowerCamelCase__=5   ,						lowerCamelCase__=4   ,						lowerCamelCase__=37   ,						lowerCamelCase__="gelu"   ,						lowerCamelCase__=0.1   ,						lowerCamelCase__=0.1   ,						lowerCamelCase__=512   ,						lowerCamelCase__=0.02   ,						)       ->   Optional[int]:

           """simple docstring"""



           __lowercase     							=		parent
           __lowercase     							=		batch_size
           __lowercase     							=		seq_length
           __lowercase     							=		is_training
           __lowercase     							=		use_input_mask
           __lowercase     							=		use_token_type_ids
           __lowercase     							=		use_labels
           __lowercase     							=		vocab_size
           __lowercase     							=		hidden_size
           __lowercase     							=		num_hidden_layers
           __lowercase     							=		num_attention_heads
           __lowercase     							=		intermediate_size
           __lowercase     							=		hidden_act
           __lowercase     							=		hidden_dropout_prob
           __lowercase     							=		attention_probs_dropout_prob
           __lowercase     							=		max_position_embeddings
           __lowercase     							=		initializer_range
           __lowercase     							=		None
           __lowercase     							=		vocab_size - 1
           __lowercase     							=		vocab_size - 1
           __lowercase     							=		vocab_size - 1

       def        snake_case__     (       self	)       ->   List[Any]:

           """simple docstring"""



           __lowercase     							=		ids_tensor([self.batch_size, self.seq_length]   ,						self.vocab_size	)

           __lowercase     							=		None
           if self.use_input_mask:
               __lowercase     							=		random_attention_mask([self.batch_size, self.seq_length]	)

           __lowercase     							=		GPTaConfig(
               vocab_size=self.vocab_size   ,						n_embd=self.hidden_size   ,						n_layer=self.num_hidden_layers   ,						n_head=self.num_attention_heads   ,						n_positions=self.max_position_embeddings   ,						use_cache=SCREAMING_SNAKE_CASE_   ,						bos_token_id=self.bos_token_id   ,						eos_token_id=self.eos_token_id   ,						pad_token_id=self.pad_token_id   ,						)

           return (config, input_ids, input_mask)

       def        snake_case__     (       self	)       ->   Optional[Any]:

           """simple docstring"""



           __lowercase     							=		self.prepare_config_and_inputs()
           __lowercase     							=		config_and_inputs
           __lowercase     							=		{'''input_ids''': input_ids, '''attention_mask''': attention_mask}
           return config, inputs_dict

       def        snake_case__     (       self	)       ->   List[Any]:

           """simple docstring"""



           __lowercase     							=		self.prepare_config_and_inputs()

           __lowercase     							=		floats_tensor([self.batch_size, self.seq_length, self.hidden_size]	)
           __lowercase     							=		ids_tensor([self.batch_size, self.seq_length]   ,						vocab_size=2	)

           return (
               config,
               input_ids,
               attention_mask,
               encoder_hidden_states,
               encoder_attention_mask,
           )

       def        snake_case__     (       self   ,						lowerCamelCase__   ,						lowerCamelCase__   ,						lowerCamelCase__   ,						lowerCamelCase__	)       ->   Any:

           """simple docstring"""



           __lowercase     							=		20
           __lowercase     							=		model_class_name(SCREAMING_SNAKE_CASE_	)

           __lowercase     							=		model.init_cache(input_ids.shape[0]   ,						SCREAMING_SNAKE_CASE_	)
           __lowercase     							=		jnp.ones((input_ids.shape[0], max_decoder_length)   ,						dtype="""i4"""	)

           __lowercase     							=		jnp.broadcast_to(
               jnp.arange(input_ids.shape[-1] - 1	)[None, :]   ,						(input_ids.shape[0], input_ids.shape[-1] - 1)	)
           __lowercase     							=		model(
               input_ids[:, :-1]   ,						attention_mask=SCREAMING_SNAKE_CASE_   ,						past_key_values=SCREAMING_SNAKE_CASE_   ,						position_ids=SCREAMING_SNAKE_CASE_   ,						)

           __lowercase     							=		jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]   ,						dtype="""i4"""	)
           __lowercase     							=		model(
               input_ids[:, -1:]   ,						attention_mask=SCREAMING_SNAKE_CASE_   ,						past_key_values=outputs_cache.past_key_values   ,						position_ids=SCREAMING_SNAKE_CASE_   ,						)

           __lowercase     							=		model(SCREAMING_SNAKE_CASE_	)

           __lowercase     							=		np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])	)	)
           self.parent.assertTrue(diff < 1E-3   ,						msg=F'Max diff is {diff}'	)




       def        snake_case__     (       self   ,						lowerCamelCase__   ,						lowerCamelCase__   ,						lowerCamelCase__   ,						lowerCamelCase__	)       ->   Dict:

           """simple docstring"""



           __lowercase     							=		20
           __lowercase     							=		model_class_name(SCREAMING_SNAKE_CASE_	)

           __lowercase     							=		jnp.concatenate(
               [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])	)]   ,						axis=-1   ,						)

           __lowercase     							=		model.init_cache(input_ids.shape[0]   ,						SCREAMING_SNAKE_CASE_	)
           __lowercase     							=		jnp.broadcast_to(
               jnp.arange(input_ids.shape[-1] - 1	)[None, :]   ,						(input_ids.shape[0], input_ids.shape[-1] - 1)	)

           __lowercase     							=		model(
               input_ids[:, :-1]   ,						attention_mask=SCREAMING_SNAKE_CASE_   ,						past_key_values=SCREAMING_SNAKE_CASE_   ,						position_ids=SCREAMING_SNAKE_CASE_   ,						)
           __lowercase     							=		jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]   ,						dtype="""i4"""	)
           __lowercase     							=		model(
               input_ids[:, -1:]   ,						past_key_values=outputs_cache.past_key_values   ,						attention_mask=SCREAMING_SNAKE_CASE_   ,						position_ids=SCREAMING_SNAKE_CASE_   ,						)

           __lowercase     							=		model(SCREAMING_SNAKE_CASE_   ,						attention_mask=SCREAMING_SNAKE_CASE_	)

           __lowercase     							=		np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])	)	)
           self.parent.assertTrue(diff < 1E-3   ,						msg=F'Max diff is {diff}'	)






@require_flax
class 			SCREAMING_SNAKE_CASE(							UpperCAmelCase_  , UpperCAmelCase_  , unittest.TestCase	):
       snake_case_					:	Tuple       =   (FlaxGPTaModel, FlaxGPTaLMHeadModel) if is_flax_available() else ()
       snake_case_					:	Union[str, Any]       =   (FlaxGPTaLMHeadModel,) if is_flax_available() else ()

       def        snake_case__     (       self	)       ->   str:

           """simple docstring"""



           __lowercase     							=		FlaxGPTaModelTester(self	)

       def        snake_case__     (       self	)       ->   int:

           """simple docstring"""



           for model_class_name in self.all_model_classes:
               __lowercase     							=		self.model_tester.prepare_config_and_inputs()
               self.model_tester.check_use_cache_forward(SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_	)

       def        snake_case__     (       self	)       ->   Any:

           """simple docstring"""



           for model_class_name in self.all_model_classes:
               __lowercase     							=		self.model_tester.prepare_config_and_inputs()
               self.model_tester.check_use_cache_forward_with_attn_mask(
                   SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_	)

       @slow
       def        snake_case__     (       self	)       ->   str:

           """simple docstring"""



           __lowercase     							=		GPTaTokenizer.from_pretrained("""gpt2"""   ,						pad_token="""</s>"""   ,						padding_side="""left"""	)
           __lowercase     							=		tokenizer(["""Hello this is a long string""", """Hey"""]   ,						return_tensors="""np"""   ,						padding=SCREAMING_SNAKE_CASE_   ,						truncation=SCREAMING_SNAKE_CASE_	)

           __lowercase     							=		FlaxGPTaLMHeadModel.from_pretrained("""gpt2"""	)
           __lowercase     							=		False
           __lowercase     							=		model.config.eos_token_id

           __lowercase     							=		jax.jit(model.generate	)

           __lowercase     							=		jit_generate(inputs["""input_ids"""]   ,						attention_mask=inputs["""attention_mask"""]	).sequences

           __lowercase     							=		tokenizer.batch_decode(SCREAMING_SNAKE_CASE_   ,						skip_special_tokens=SCREAMING_SNAKE_CASE_	)

           __lowercase     							=		[
               '''Hello this is a long string of words. I\'m going to start with the first one.\n''',
               '''Hey, I\'m not sure if I\'m going to be able to do''',
           ]

           self.assertListEqual(SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_	)

       @is_pt_flax_cross_test
       def        snake_case__     (       self	)       ->   Tuple:

           """simple docstring"""



           __lowercase     							=		self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               with self.subTest(model_class.__name__	):
                   # prepare inputs
                   __lowercase     							=		self._prepare_for_class(SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_	)
                   __lowercase     							=		{k: torch.tensor(v.tolist()	) for k, v in prepared_inputs_dict.items()}

                   # load corresponding PyTorch class
                   __lowercase     							=		model_class.__name__[4:]  # Skip the "Flax" at the beginning
                   __lowercase     							=		getattr(SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_	)

                   __lowercase     							=		pt_inputs['''input_ids'''].shape
                   __lowercase     							=		np.random.randint(0   ,						seq_length - 1   ,						size=(batch_size,)	)
                   for batch_idx, start_index in enumerate(SCREAMING_SNAKE_CASE_	):
                       __lowercase     							=		0
                       __lowercase     							=		1
                       __lowercase     							=		0
                       __lowercase     							=		1
                   __lowercase     							=		pt_model_class(SCREAMING_SNAKE_CASE_	).eval()
                   __lowercase     							=		model_class(SCREAMING_SNAKE_CASE_   ,						dtype=jnp.floataa	)

                   __lowercase     							=		convert_pytorch_state_dict_to_flax(pt_model.state_dict()   ,						SCREAMING_SNAKE_CASE_	)
                   __lowercase     							=		fx_state

                   with torch.no_grad():
                       __lowercase     							=		pt_model(**SCREAMING_SNAKE_CASE_	).to_tuple()

                   __lowercase     							=		fx_model(**SCREAMING_SNAKE_CASE_	).to_tuple()
                   self.assertEqual(len(SCREAMING_SNAKE_CASE_	)   ,						len(SCREAMING_SNAKE_CASE_	)   ,						"""Output lengths differ between Flax and PyTorch"""	)
                   for fx_output, pt_output in zip(SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_	):
                       self.assert_almost_equals(fx_output[:, -1]   ,						pt_output[:, -1].numpy()   ,						4E-2	)

                   with tempfile.TemporaryDirectory() as tmpdirname:
                       pt_model.save_pretrained(SCREAMING_SNAKE_CASE_	)
                       __lowercase     							=		model_class.from_pretrained(SCREAMING_SNAKE_CASE_   ,						from_pt=SCREAMING_SNAKE_CASE_	)

                   __lowercase     							=		fx_model_loaded(**SCREAMING_SNAKE_CASE_	).to_tuple()
                   self.assertEqual(
                       len(SCREAMING_SNAKE_CASE_	)   ,						len(SCREAMING_SNAKE_CASE_	)   ,						"""Output lengths differ between Flax and PyTorch"""	)
                   for fx_output_loaded, pt_output in zip(SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_	):
                       self.assert_almost_equals(fx_output_loaded[:, -1]   ,						pt_output[:, -1].numpy()   ,						4E-2	)

       @is_pt_flax_cross_test
       def        snake_case__     (       self	)       ->   Optional[Any]:

           """simple docstring"""



           __lowercase     							=		self.model_tester.prepare_config_and_inputs_for_common()
           for model_class in self.all_model_classes:
               with self.subTest(model_class.__name__	):
                   # prepare inputs
                   __lowercase     							=		self._prepare_for_class(SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_	)
                   __lowercase     							=		{k: torch.tensor(v.tolist()	) for k, v in prepared_inputs_dict.items()}

                   # load corresponding PyTorch class
                   __lowercase     							=		model_class.__name__[4:]  # Skip the "Flax" at the beginning
                   __lowercase     							=		getattr(SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_	)

                   __lowercase     							=		pt_model_class(SCREAMING_SNAKE_CASE_	).eval()
                   __lowercase     							=		model_class(SCREAMING_SNAKE_CASE_   ,						dtype=jnp.floataa	)

                   __lowercase     							=		load_flax_weights_in_pytorch_model(SCREAMING_SNAKE_CASE_   ,						fx_model.params	)
                   __lowercase     							=		pt_inputs['''input_ids'''].shape
                   __lowercase     							=		np.random.randint(0   ,						seq_length - 1   ,						size=(batch_size,)	)
                   for batch_idx, start_index in enumerate(SCREAMING_SNAKE_CASE_	):
                       __lowercase     							=		0
                       __lowercase     							=		1
                       __lowercase     							=		0
                       __lowercase     							=		1

                   # make sure weights are tied in PyTorch
                   pt_model.tie_weights()

                   with torch.no_grad():
                       __lowercase     							=		pt_model(**SCREAMING_SNAKE_CASE_	).to_tuple()

                   __lowercase     							=		fx_model(**SCREAMING_SNAKE_CASE_	).to_tuple()
                   self.assertEqual(len(SCREAMING_SNAKE_CASE_	)   ,						len(SCREAMING_SNAKE_CASE_	)   ,						"""Output lengths differ between Flax and PyTorch"""	)
                   for fx_output, pt_output in zip(SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_	):
                       self.assert_almost_equals(fx_output[:, -1]   ,						pt_output[:, -1].numpy()   ,						4E-2	)

                   with tempfile.TemporaryDirectory() as tmpdirname:
                       fx_model.save_pretrained(SCREAMING_SNAKE_CASE_	)
                       __lowercase     							=		pt_model_class.from_pretrained(SCREAMING_SNAKE_CASE_   ,						from_flax=SCREAMING_SNAKE_CASE_	)

                   with torch.no_grad():
                       __lowercase     							=		pt_model_loaded(**SCREAMING_SNAKE_CASE_	).to_tuple()

                   self.assertEqual(
                       len(SCREAMING_SNAKE_CASE_	)   ,						len(SCREAMING_SNAKE_CASE_	)   ,						"""Output lengths differ between Flax and PyTorch"""	)
                   for fx_output, pt_output in zip(SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_	):
                       self.assert_almost_equals(fx_output[:, -1]   ,						pt_output[:, -1].numpy()   ,						4E-2	)




       @slow
       def        snake_case__     (       self	)       ->   str:

           """simple docstring"""



           for model_class_name in self.all_model_classes:
               __lowercase     							=		model_class_name.from_pretrained("""gpt2"""   ,						from_pt=SCREAMING_SNAKE_CASE_	)
               __lowercase     							=		model(np.ones((1, 1)	)	)
               self.assertIsNotNone(SCREAMING_SNAKE_CASE_	)










'''simple docstring'''


import importlib
import importlib.metadata
import os
import warnings
from distutils.util import strtobool
from functools import lru_cache

import torch
from packaging import version
from packaging.version import parse

from .environment import parse_flag_from_env
from .versions import compare_versions, is_torch_version


try:
     import torch_xla.core.xla_model as xm  # noqa: F401

     UpperCamelCase			     =					True
except ImportError:
     UpperCamelCase			     =					False


# Cache this result has it's a C FFI call which can be pretty time-consuming
UpperCamelCase			     =					torch.distributed.is_available()
def 					SCREAMING_SNAKE_CASE(   __lowercase	)			-> Optional[int]:
     # Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
     A:		Optional[Any]          =		importlib.util.find_spec(__lowercase	) is not None
     if package_exists:
          try:
               A:		Dict          =		importlib.metadata.metadata(__lowercase	)
               return True
          except importlib.metadata.PackageNotFoundError:
               return False
def 					SCREAMING_SNAKE_CASE(   )			-> bool:
     return _torch_distributed_available
def 					SCREAMING_SNAKE_CASE(   )			-> Optional[int]:
     try:
          pass
     except ImportError:
          print(
              '''Intel(R) oneCCL Bindings for PyTorch* is required to run DDP on Intel(R) GPUs, but it is not'''
              ''' detected. If you see \"ValueError: Invalid backend: \'ccl\'\" error, please install Intel(R) oneCCL'''
              ''' Bindings for PyTorch*.'''	)
     return (
         importlib.util.find_spec('''torch_ccl'''	) is not None
         or importlib.util.find_spec('''oneccl_bindings_for_pytorch'''	) is not None
     )
def 					SCREAMING_SNAKE_CASE(   )			-> List[str]:
     return importlib.metadata.version('''oneccl_bind_pt'''	)
def 					SCREAMING_SNAKE_CASE(   )			-> Union[str, Any]:
     return _is_package_available('''transformer_engine'''	)
@lru_cache
def 					SCREAMING_SNAKE_CASE(   __lowercase=True	)			-> Union[str, Any]:
     # Due to bugs on the amp series GPUs, we disable torch-xla on them
     if torch.cuda.is_available():
          return False
     if _tpu_available and check_device:
          try:
               # Will raise a RuntimeError if no XLA configuration is found
               A:		Tuple          =		xm.xla_device()
               return True
          except RuntimeError:
               return False
     return _tpu_available
def 					SCREAMING_SNAKE_CASE(   )			-> List[str]:
     return _is_package_available('''deepspeed'''	)
def 					SCREAMING_SNAKE_CASE(   __lowercase=False	)			-> Any:
     if is_tpu_available():
          return not ignore_tpu
     if torch.cuda.is_available():
          return torch.cuda.is_bfaa_supported()
     if is_npu_available():
          return False
     return True
def 					SCREAMING_SNAKE_CASE(   )			-> str:
     A:		List[str]          =		_is_package_available('''bitsandbytes'''	)
     if package_exists:
          A:		Union[str, Any]          =		version.parse(importlib.metadata.version('''bitsandbytes'''	)	)
          return compare_versions(__lowercase		,				'''>='''		,				'''0.39.0'''	)
     return False
def 					SCREAMING_SNAKE_CASE(   )			-> str:
     A:		int          =		_is_package_available('''bitsandbytes'''	)
     if package_exists:
          A:		Tuple          =		version.parse(importlib.metadata.version('''bitsandbytes'''	)	)
          return compare_versions(__lowercase		,				'''>='''		,				'''0.37.2'''	)
     return False
def 					SCREAMING_SNAKE_CASE(   )			-> int:
     return _is_package_available('''bitsandbytes'''	)
def 					SCREAMING_SNAKE_CASE(   )			-> Optional[int]:
     if strtobool(os.environ.get('''ACCELERATE_USE_MEGATRON_LM'''		,				'''False'''	)	) == 1:
          A:		Any          =		importlib.util.find_spec('''megatron'''	) is not None
          if package_exists:
               try:
                    A:		str          =		parse(importlib.metadata.version('''megatron-lm'''	)	)
                    return compare_versions(__lowercase		,				'''>='''		,				'''2.2.0'''	)
               except Exception as e:
                    warnings.warn(F"""Parse Megatron version failed. Exception:{e}"""	)
                    return False
def 					SCREAMING_SNAKE_CASE(   )			-> Any:
     return _is_package_available('''safetensors'''	)
def 					SCREAMING_SNAKE_CASE(   )			-> Tuple:
     return _is_package_available('''transformers'''	)
def 					SCREAMING_SNAKE_CASE(   )			-> Union[str, Any]:
     return _is_package_available('''datasets'''	)
def 					SCREAMING_SNAKE_CASE(   )			-> Union[str, Any]:
     return _is_package_available('''aim'''	)
def 					SCREAMING_SNAKE_CASE(   )			-> List[Any]:
     return _is_package_available('''tensorboard'''	) or _is_package_available('''tensorboardX'''	)
def 					SCREAMING_SNAKE_CASE(   )			-> Dict:
     return _is_package_available('''wandb'''	)
def 					SCREAMING_SNAKE_CASE(   )			-> Optional[Any]:
     return _is_package_available('''comet_ml'''	)
def 					SCREAMING_SNAKE_CASE(   )			-> Any:
     return _is_package_available('''boto3'''	)
def 					SCREAMING_SNAKE_CASE(   )			-> str:
     if _is_package_available('''rich'''	):
          if "ACCELERATE_DISABLE_RICH" in os.environ:
               warnings.warn(
                   '''`ACCELERATE_DISABLE_RICH` is deprecated and will be removed in v0.22.0 and deactivated by default. Please use `ACCELERATE_ENABLE_RICH` if you wish to use `rich`.'''	)
               return not parse_flag_from_env('''ACCELERATE_DISABLE_RICH'''		,				__lowercase	)
          return parse_flag_from_env('''ACCELERATE_ENABLE_RICH'''		,				__lowercase	)
     return False
def 					SCREAMING_SNAKE_CASE(   )			-> int:
     return _is_package_available('''sagemaker'''	)
def 					SCREAMING_SNAKE_CASE(   )			-> Union[str, Any]:
     return _is_package_available('''tqdm'''	)
def 					SCREAMING_SNAKE_CASE(   )			-> str:
     return _is_package_available('''mlflow'''	)
def 					SCREAMING_SNAKE_CASE(   )			-> int:
     return is_torch_version('''>='''		,				'''1.12'''	) and torch.backends.mps.is_available() and torch.backends.mps.is_built()
def 					SCREAMING_SNAKE_CASE(   )			-> str:
     def get_major_and_minor_from_version(__lowercase	):
          return str(version.parse(__lowercase	).major	) + "." + str(version.parse(__lowercase	).minor	)

     A:		int          =		importlib.metadata.version('''torch'''	)
     if importlib.util.find_spec('''intel_extension_for_pytorch'''	) is None:
          return False
     A:		Optional[Any]          =		'''N/A'''
     try:
          A:		List[Any]          =		importlib.metadata.version('''intel_extension_for_pytorch'''	)
     except importlib.metadata.PackageNotFoundError:
          return False
     A:		Optional[int]          =		get_major_and_minor_from_version(_torch_version	)
     A:		List[str]          =		get_major_and_minor_from_version(_ipex_version	)
     if torch_major_and_minor != ipex_major_and_minor:
          warnings.warn(
              F"""Intel Extension for PyTorch {ipex_major_and_minor} needs to work with PyTorch {ipex_major_and_minor}.*,"""
              F""" but PyTorch {_torch_version} is found. Please switch to the matching version and run again."""	)
          return False
     return True
@lru_cache
def 					SCREAMING_SNAKE_CASE(   __lowercase=False	)			-> Optional[Any]:
     if importlib.util.find_spec('''torch'''	) is None or importlib.util.find_spec('''torch_npu'''	) is None:
          return False

     import torch
     import torch_npu  # noqa: F401

     if check_device:
          try:
               # Will raise a RuntimeError if no NPU is found
               A:		Tuple          =		torch.npu.device_count()
               return torch.npu.is_available()
          except RuntimeError:
               return False
     return hasattr(__lowercase		,				'''npu'''	) and torch.npu.is_available()


@lru_cache
def 					SCREAMING_SNAKE_CASE(   __lowercase=False	)			-> Tuple:
     if not parse_flag_from_env('''ACCELERATE_USE_XPU'''		,				default=__lowercase	):
          return False
     if is_ipex_available():
          import torch

          if is_torch_version('''<='''		,				'''1.12'''	):
               return False
     else:
          return False

     import intel_extension_for_pytorch  # noqa: F401

     if check_device:
          try:
               # Will raise a RuntimeError if no XPU  is found
               A:		str          =		torch.xpu.device_count()
               return torch.xpu.is_available()
          except RuntimeError:
               return False
     return hasattr(__lowercase		,				'''xpu'''	) and torch.xpu.is_available()






