

import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
_a:      Any								=     logging.get_logger(__name__)



def  __lowerCAmelCase (  ):
	UpperCAmelCase_    			=     DetaConfig(
	    num_queries=900    ,       encoder_ffn_dim=2048    ,       decoder_ffn_dim=2048    ,       num_feature_levels=5    ,       assign_first_stage=A    ,       with_box_refine=A    ,       two_stage=A    ,       )

	# set labels
	UpperCAmelCase_    			=     91
	UpperCAmelCase_    			=     "huggingface/label-files"
	UpperCAmelCase_    			=     "coco-detection-id2label.json"
	UpperCAmelCase_    			=     json.load(open(cached_download(hf_hub_url(A    ,       A    ,       repo_type="dataset"      )      )    ,       "r"      )      )
	UpperCAmelCase_    			=     {int(A      ): v for k, v in idalabel.items()}
	UpperCAmelCase_    			=     idalabel
	UpperCAmelCase_    			=     {v: k for k, v in idalabel.items()}

	return config



def  __lowerCAmelCase (  A      ):
	UpperCAmelCase_    			=     []

	# stem
	# fmt: off
	rename_keys.append(("backbone.0.body.conv1.weight", "model.backbone.model.embedder.embedder.convolution.weight")      )
	rename_keys.append(("backbone.0.body.bn1.weight", "model.backbone.model.embedder.embedder.normalization.weight")      )
	rename_keys.append(("backbone.0.body.bn1.bias", "model.backbone.model.embedder.embedder.normalization.bias")      )
	rename_keys.append(("backbone.0.body.bn1.running_mean", "model.backbone.model.embedder.embedder.normalization.running_mean")      )
	rename_keys.append(("backbone.0.body.bn1.running_var", "model.backbone.model.embedder.embedder.normalization.running_var")      )
	# stages
	for stage_idx in range(len(config.backbone_config.depths      )      ):
		for layer_idx in range(config.backbone_config.depths[stage_idx]      ):
			# shortcut
			if layer_idx == 0:
				rename_keys.append(
				    (
				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight",
				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight",
				    )      )
				rename_keys.append(
				    (
				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight",
				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight",
				    )      )
				rename_keys.append(
				    (
				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias",
				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias",
				    )      )
				rename_keys.append(
				    (
				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean",
				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean",
				    )      )
				rename_keys.append(
				    (
				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var",
				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var",
				    )      )
			# 3 convs
			for i in range(3      ):
				rename_keys.append(
				    (
				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv{i+1}.weight",
				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight",
				    )      )
				rename_keys.append(
				    (
				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.weight",
				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight",
				    )      )
				rename_keys.append(
				    (
				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.bias",
				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias",
				    )      )
				rename_keys.append(
				    (
				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_mean",
				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean",
				    )      )
				rename_keys.append(
				    (
				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_var",
				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var",
				    )      )
    # transformer encoder
	for i in range(config.encoder_layers      ):
		rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight", F"model.encoder.layers.{i}.self_attn.sampling_offsets.weight")      )
		rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias", F"model.encoder.layers.{i}.self_attn.sampling_offsets.bias")      )
		rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.attention_weights.weight", F"model.encoder.layers.{i}.self_attn.attention_weights.weight")      )
		rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.attention_weights.bias", F"model.encoder.layers.{i}.self_attn.attention_weights.bias")      )
		rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.value_proj.weight", F"model.encoder.layers.{i}.self_attn.value_proj.weight")      )
		rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.value_proj.bias", F"model.encoder.layers.{i}.self_attn.value_proj.bias")      )
		rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.output_proj.weight", F"model.encoder.layers.{i}.self_attn.output_proj.weight")      )
		rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.output_proj.bias", F"model.encoder.layers.{i}.self_attn.output_proj.bias")      )
		rename_keys.append((F"transformer.encoder.layers.{i}.norm1.weight", F"model.encoder.layers.{i}.self_attn_layer_norm.weight")      )
		rename_keys.append((F"transformer.encoder.layers.{i}.norm1.bias", F"model.encoder.layers.{i}.self_attn_layer_norm.bias")      )
		rename_keys.append((F"transformer.encoder.layers.{i}.linear1.weight", F"model.encoder.layers.{i}.fc1.weight")      )
		rename_keys.append((F"transformer.encoder.layers.{i}.linear1.bias", F"model.encoder.layers.{i}.fc1.bias")      )
		rename_keys.append((F"transformer.encoder.layers.{i}.linear2.weight", F"model.encoder.layers.{i}.fc2.weight")      )
		rename_keys.append((F"transformer.encoder.layers.{i}.linear2.bias", F"model.encoder.layers.{i}.fc2.bias")      )
		rename_keys.append((F"transformer.encoder.layers.{i}.norm2.weight", F"model.encoder.layers.{i}.final_layer_norm.weight")      )
		rename_keys.append((F"transformer.encoder.layers.{i}.norm2.bias", F"model.encoder.layers.{i}.final_layer_norm.bias")      )

	# transformer decoder
	for i in range(config.decoder_layers      ):
		rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight", F"model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias", F"model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.attention_weights.weight", F"model.decoder.layers.{i}.encoder_attn.attention_weights.weight")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.attention_weights.bias", F"model.decoder.layers.{i}.encoder_attn.attention_weights.bias")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.value_proj.weight", F"model.decoder.layers.{i}.encoder_attn.value_proj.weight")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.value_proj.bias", F"model.decoder.layers.{i}.encoder_attn.value_proj.bias")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.output_proj.weight", F"model.decoder.layers.{i}.encoder_attn.output_proj.weight")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.output_proj.bias", F"model.decoder.layers.{i}.encoder_attn.output_proj.bias")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.norm1.weight", F"model.decoder.layers.{i}.encoder_attn_layer_norm.weight")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.norm1.bias", F"model.decoder.layers.{i}.encoder_attn_layer_norm.bias")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.self_attn.out_proj.weight", F"model.decoder.layers.{i}.self_attn.out_proj.weight")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.self_attn.out_proj.bias", F"model.decoder.layers.{i}.self_attn.out_proj.bias")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.norm2.weight", F"model.decoder.layers.{i}.self_attn_layer_norm.weight")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.norm2.bias", F"model.decoder.layers.{i}.self_attn_layer_norm.bias")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.linear1.weight", F"model.decoder.layers.{i}.fc1.weight")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.linear1.bias", F"model.decoder.layers.{i}.fc1.bias")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.linear2.weight", F"model.decoder.layers.{i}.fc2.weight")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.linear2.bias", F"model.decoder.layers.{i}.fc2.bias")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.norm3.weight", F"model.decoder.layers.{i}.final_layer_norm.weight")      )
		rename_keys.append((F"transformer.decoder.layers.{i}.norm3.bias", F"model.decoder.layers.{i}.final_layer_norm.bias")      )

	# fmt: on

	return rename_keys



def  __lowerCAmelCase (  A    ,       A    ,       A      ):
	UpperCAmelCase_    			=     dct.pop(A      )
	UpperCAmelCase_    			=     val



def  __lowerCAmelCase (  A    ,       A      ):
	# transformer decoder self-attention layers
	UpperCAmelCase_    			=     config.d_model
	for i in range(config.decoder_layers      ):
		# read in weights + bias of input projection layer of self-attention
		UpperCAmelCase_    			=     state_dict.pop(F"transformer.decoder.layers.{i}.self_attn.in_proj_weight"      )
		UpperCAmelCase_    			=     state_dict.pop(F"transformer.decoder.layers.{i}.self_attn.in_proj_bias"      )
		# next, add query, keys and values (in that order) to the state dict
		UpperCAmelCase_    			=     in_proj_weight[:hidden_size, :]
		UpperCAmelCase_    			=     in_proj_bias[:hidden_size]
		UpperCAmelCase_    			=     in_proj_weight[
		    hidden_size : hidden_size * 2, :
		]
		UpperCAmelCase_    			=     in_proj_bias[hidden_size : hidden_size * 2]
		UpperCAmelCase_    			=     in_proj_weight[-hidden_size:, :]
		UpperCAmelCase_    			=     in_proj_bias[-hidden_size:]



def  __lowerCAmelCase (  ):
	UpperCAmelCase_    			=     "http://images.cocodataset.org/val2017/000000039769.jpg"
	UpperCAmelCase_    			=     Image.open(requests.get(A    ,       stream=A      ).raw      )

	return im



@torch.no_grad()
def  __lowerCAmelCase (  A    ,       A    ,       A      ):
	UpperCAmelCase_    			=     get_deta_config()

	# load original state dict
	if model_name == "deta-resnet-50":
		UpperCAmelCase_    			=     "adet_checkpoint0011.pth"
	elif model_name == "deta-resnet-50-24-epochs":
		UpperCAmelCase_    			=     "adet_2x_checkpoint0023.pth"
	else:
		raise ValueError(F"Model name {model_name} not supported"      )
	UpperCAmelCase_    			=     hf_hub_download(repo_id="nielsr/deta-checkpoints"    ,       filename=A      )
	UpperCAmelCase_    			=     torch.load(A    ,       map_location="cpu"      )["model"]

	# rename keys
	UpperCAmelCase_    			=     create_rename_keys(A      )
	for src, dest in rename_keys:
		rename_key(A    ,       A    ,       A      )
	read_in_decoder_q_k_v(A    ,       A      )

	# fix some prefixes
	for key in state_dict.copy().keys():
		if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
			UpperCAmelCase_    			=     state_dict.pop(A      )
			UpperCAmelCase_    			=     val
		if "input_proj" in key:
			UpperCAmelCase_    			=     state_dict.pop(A      )
			UpperCAmelCase_    			=     val
		if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
			UpperCAmelCase_    			=     state_dict.pop(A      )
			UpperCAmelCase_    			=     val

    # finally, create HuggingFace model and load state dict
	UpperCAmelCase_    			=     DetaForObjectDetection(A      )
	model.load_state_dict(A      )
	model.eval()

	UpperCAmelCase_    			=     "cuda" if torch.cuda.is_available() else "cpu"
	model.to(A      )

	# load image processor
	UpperCAmelCase_    			=     DetaImageProcessor(format="coco_detection"      )

	# verify our conversion on image
	UpperCAmelCase_    			=     prepare_img()
	UpperCAmelCase_    			=     processor(images=A    ,       return_tensors="pt"      )
	UpperCAmelCase_    			=     encoding["pixel_values"]
	UpperCAmelCase_    			=     model(pixel_values.to(A      )      )

	# verify logits
	if model_name == "deta-resnet-50":
		UpperCAmelCase_    			=     torch.tensor(
		    [[-7.3978, -2.5406, -4.1668], [-8.2684, -3.9933, -3.8096], [-7.0515, -3.7973, -5.8516]]      )
		UpperCAmelCase_    			=     torch.tensor([[0.5043, 0.4973, 0.9998], [0.2542, 0.5489, 0.4748], [0.5490, 0.2765, 0.0570]]      )
	elif model_name == "deta-resnet-50-24-epochs":
		UpperCAmelCase_    			=     torch.tensor(
		    [[-7.1688, -2.4857, -4.8669], [-7.8630, -3.8154, -4.2674], [-7.2730, -4.1865, -5.5323]]      )
		UpperCAmelCase_    			=     torch.tensor([[0.5021, 0.4971, 0.9994], [0.2546, 0.5486, 0.4731], [0.1686, 0.1986, 0.2142]]      )

	assert torch.allclose(outputs.logits[0, :3, :3]    ,       expected_logits.to(A      )    ,       atol=1E-4      )
	assert torch.allclose(outputs.pred_boxes[0, :3, :3]    ,       expected_boxes.to(A      )    ,       atol=1E-4      )
	print("Everything ok!"      )

	if pytorch_dump_folder_path:
		# Save model and processor
		logger.info(F"Saving PyTorch model and processor to {pytorch_dump_folder_path}..."      )
		Path(A      ).mkdir(exist_ok=A      )
		model.save_pretrained(A      )
		processor.save_pretrained(A      )

	# Push to hub
	if push_to_hub:
		print("Pushing model and processor to hub..."      )
		model.push_to_hub(F"jozhang97/{model_name}"      )
		processor.push_to_hub(F"jozhang97/{model_name}"      )


if __name__ == "__main__":
				_a:      Optional[int]								=     argparse.ArgumentParser()

				parser.add_argument(
				    """--model_name""",
				    type=str,
				    default="""deta-resnet-50""",
				    choices=["""deta-resnet-50""", """deta-resnet-50-24-epochs"""],
				    help="""Name of the model you'd like to convert.""",
				)
				parser.add_argument(
				    """--pytorch_dump_folder_path""",
				    default=None,
				    type=str,
				    help="""Path to the folder to output PyTorch model.""",
				)
				parser.add_argument(
				    """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub."""
				)
				_a:      Union[str, Any]								=     parser.parse_args()
				convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)






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

				_a:      List[Any]								=     True
except ImportError:
				_a:      int								=     False


# Cache this result has it's a C FFI call which can be pretty time-consuming
_a:      str								=     torch.distributed.is_available()



def  __lowerCAmelCase (  A      ):
	# Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
	UpperCAmelCase_    			=     importlib.util.find_spec(A      ) is not None
	if package_exists:
		try:
			UpperCAmelCase_    			=     importlib.metadata.metadata(A      )
			return True
		except importlib.metadata.PackageNotFoundError:
			return False



def  __lowerCAmelCase (  ):
	return _torch_distributed_available



def  __lowerCAmelCase (  ):
	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  __lowerCAmelCase (  ):
	return importlib.metadata.version("oneccl_bind_pt"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("transformer_engine"      )



@lru_cache
def  __lowerCAmelCase (  A=True      ):
	# 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
			UpperCAmelCase_    			=     xm.xla_device()
			return True
		except RuntimeError:
			return False
	return _tpu_available



def  __lowerCAmelCase (  ):
	return _is_package_available("deepspeed"      )



def  __lowerCAmelCase (  A=False      ):
	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  __lowerCAmelCase (  ):
	UpperCAmelCase_    			=     _is_package_available("bitsandbytes"      )
	if package_exists:
		UpperCAmelCase_    			=     version.parse(importlib.metadata.version("bitsandbytes"      )      )
		return compare_versions(A    ,       ">="    ,       "0.39.0"      )
	return False



def  __lowerCAmelCase (  ):
	UpperCAmelCase_    			=     _is_package_available("bitsandbytes"      )
	if package_exists:
		UpperCAmelCase_    			=     version.parse(importlib.metadata.version("bitsandbytes"      )      )
		return compare_versions(A    ,       ">="    ,       "0.37.2"      )
	return False



def  __lowerCAmelCase (  ):
	return _is_package_available("bitsandbytes"      )



def  __lowerCAmelCase (  ):
	if strtobool(os.environ.get("ACCELERATE_USE_MEGATRON_LM"    ,       "False"      )      ) == 1:
		UpperCAmelCase_    			=     importlib.util.find_spec("megatron"      ) is not None
		if package_exists:
			try:
				UpperCAmelCase_    			=     parse(importlib.metadata.version("megatron-lm"      )      )
				return compare_versions(A    ,       ">="    ,       "2.2.0"      )
			except Exception as e:
				warnings.warn(F"Parse Megatron version failed. Exception:{e}"      )
				return False



def  __lowerCAmelCase (  ):
	return _is_package_available("safetensors"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("transformers"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("datasets"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("aim"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("tensorboard"      ) or _is_package_available("tensorboardX"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("wandb"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("comet_ml"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("boto3"      )



def  __lowerCAmelCase (  ):
	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"    ,       A      )
		return parse_flag_from_env("ACCELERATE_ENABLE_RICH"    ,       A      )
	return False



def  __lowerCAmelCase (  ):
	return _is_package_available("sagemaker"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("tqdm"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("mlflow"      )



def  __lowerCAmelCase (  ):
	return is_torch_version(">="    ,       "1.12"      ) and torch.backends.mps.is_available() and torch.backends.mps.is_built()



def  __lowerCAmelCase (  ):
	def get_major_and_minor_from_version(A      ):
		return str(version.parse(A      ).major      ) + "." + str(version.parse(A      ).minor      )

	UpperCAmelCase_    			=     importlib.metadata.version("torch"      )
	if importlib.util.find_spec("intel_extension_for_pytorch"      ) is None:
		return False
	UpperCAmelCase_    			=     "N/A"
	try:
		UpperCAmelCase_    			=     importlib.metadata.version("intel_extension_for_pytorch"      )
	except importlib.metadata.PackageNotFoundError:
		return False
	UpperCAmelCase_    			=     get_major_and_minor_from_version(_torch_version      )
	UpperCAmelCase_    			=     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  __lowerCAmelCase (  A=False      ):
	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
			UpperCAmelCase_    			=     torch.npu.device_count()
			return torch.npu.is_available()
		except RuntimeError:
			return False
	return hasattr(A    ,       "npu"      ) and torch.npu.is_available()




@lru_cache
def  __lowerCAmelCase (  A=False      ):
	if not parse_flag_from_env("ACCELERATE_USE_XPU"    ,       default=A      ):
		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
			UpperCAmelCase_    			=     torch.xpu.device_count()
			return torch.xpu.is_available()
		except RuntimeError:
			return False
	return hasattr(A    ,       "xpu"      ) and torch.xpu.is_available()