





import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.model_selection import train_test_split
from xgboost import XGBRegressor



def      __lowercase     (   _SCREAMING_SNAKE_CASE			)				->     tuple:


      '''simple docstring'''


      return (data["data"], data["target"])



def      __lowercase     (   _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)				->     np.ndarray:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE	=		XGBRegressor(verbosity=0				,		random_state=42			)
      xgb.fit(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)
      # Predict target for test data
      SCREAMING_SNAKE_CASE	=		xgb.predict(_SCREAMING_SNAKE_CASE			)
      SCREAMING_SNAKE_CASE	=		predictions.reshape(len(_SCREAMING_SNAKE_CASE			)				,		1			)
      return predictions



def      __lowercase     (   )				->     None:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE	=		fetch_california_housing()
      SCREAMING_SNAKE_CASE,      SCREAMING_SNAKE_CASE	=		data_handling(_SCREAMING_SNAKE_CASE			)
      SCREAMING_SNAKE_CASE,      SCREAMING_SNAKE_CASE,      SCREAMING_SNAKE_CASE,      SCREAMING_SNAKE_CASE	=		train_test_split(
          _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		test_size=0.25				,		random_state=1			)
      SCREAMING_SNAKE_CASE	=		xgboost(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)
      # Error printing
      print(F"""Mean Absolute Error : {mean_absolute_error(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)}"""			)
      print(F"""Mean Square Error  : {mean_squared_error(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)}"""			)


if __name__ == "__main__":
      import doctest

      doctest.testmod(verbose=True)
      main()









import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from torchvision import transforms

from transformers import BitImageProcessor, FocalNetConfig, FocalNetForImageClassification
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling



def      __lowercase     (   _SCREAMING_SNAKE_CASE			)				->     Any:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE	=		[2, 2, 6, 2] if """tiny""" in model_name else [2, 2, 18, 2]
      SCREAMING_SNAKE_CASE	=		True if """large""" in model_name or """huge""" in model_name else False
      SCREAMING_SNAKE_CASE	=		True if """large""" in model_name or """huge""" in model_name else False
      SCREAMING_SNAKE_CASE	=		True if """large""" in model_name or """huge""" in model_name else False

      if "large" in model_name or "xlarge" in model_name or "huge" in model_name:
            if "fl3" in model_name:
                  SCREAMING_SNAKE_CASE	=		[3, 3, 3, 3]
                  SCREAMING_SNAKE_CASE	=		[5, 5, 5, 5]
            elif "fl4" in model_name:
                  SCREAMING_SNAKE_CASE	=		[4, 4, 4, 4]
                  SCREAMING_SNAKE_CASE	=		[3, 3, 3, 3]

      if "tiny" in model_name or "small" in model_name or "base" in model_name:
            SCREAMING_SNAKE_CASE	=		[3, 3, 3, 3]
            if "lrf" in model_name:
                  SCREAMING_SNAKE_CASE	=		[3, 3, 3, 3]
            else:
                  SCREAMING_SNAKE_CASE	=		[2, 2, 2, 2]

      if "tiny" in model_name:
            SCREAMING_SNAKE_CASE	=		96
      elif "small" in model_name:
            SCREAMING_SNAKE_CASE	=		96
      elif "base" in model_name:
            SCREAMING_SNAKE_CASE	=		1_28
      elif "large" in model_name:
            SCREAMING_SNAKE_CASE	=		1_92
      elif "xlarge" in model_name:
            SCREAMING_SNAKE_CASE	=		2_56
      elif "huge" in model_name:
            SCREAMING_SNAKE_CASE	=		3_52

      # set label information
      SCREAMING_SNAKE_CASE	=		"""huggingface/label-files"""
      if "large" in model_name or "huge" in model_name:
            SCREAMING_SNAKE_CASE	=		"""imagenet-22k-id2label.json"""
      else:
            SCREAMING_SNAKE_CASE	=		"""imagenet-1k-id2label.json"""

      SCREAMING_SNAKE_CASE	=		json.load(open(hf_hub_download(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		repo_type="""dataset"""			)				,		"""r"""			)			)
      SCREAMING_SNAKE_CASE	=		{int(_SCREAMING_SNAKE_CASE			): v for k, v in idalabel.items()}
      SCREAMING_SNAKE_CASE	=		{v: k for k, v in idalabel.items()}

      SCREAMING_SNAKE_CASE	=		FocalNetConfig(
          embed_dim=_SCREAMING_SNAKE_CASE				,		depths=_SCREAMING_SNAKE_CASE				,		focal_levels=_SCREAMING_SNAKE_CASE				,		focal_windows=_SCREAMING_SNAKE_CASE				,		use_conv_embed=_SCREAMING_SNAKE_CASE				,		idalabel=_SCREAMING_SNAKE_CASE				,		labelaid=_SCREAMING_SNAKE_CASE				,		use_post_layernorm=_SCREAMING_SNAKE_CASE				,		use_layerscale=_SCREAMING_SNAKE_CASE				,		)

      return config



def      __lowercase     (   _SCREAMING_SNAKE_CASE			)				->     Optional[int]:


      '''simple docstring'''


      if "patch_embed.proj" in name:
            SCREAMING_SNAKE_CASE	=		name.replace("""patch_embed.proj"""				,		"""embeddings.patch_embeddings.projection"""			)
      if "patch_embed.norm" in name:
            SCREAMING_SNAKE_CASE	=		name.replace("""patch_embed.norm"""				,		"""embeddings.norm"""			)
      if "layers" in name:
            SCREAMING_SNAKE_CASE	=		"""encoder.""" + name
      if "encoder.layers" in name:
            SCREAMING_SNAKE_CASE	=		name.replace("""encoder.layers"""				,		"""encoder.stages"""			)
      if "downsample.proj" in name:
            SCREAMING_SNAKE_CASE	=		name.replace("""downsample.proj"""				,		"""downsample.projection"""			)
      if "blocks" in name:
            SCREAMING_SNAKE_CASE	=		name.replace("""blocks"""				,		"""layers"""			)
      if "modulation.f.weight" in name or "modulation.f.bias" in name:
            SCREAMING_SNAKE_CASE	=		name.replace("""modulation.f"""				,		"""modulation.projection_in"""			)
      if "modulation.h.weight" in name or "modulation.h.bias" in name:
            SCREAMING_SNAKE_CASE	=		name.replace("""modulation.h"""				,		"""modulation.projection_context"""			)
      if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
            SCREAMING_SNAKE_CASE	=		name.replace("""modulation.proj"""				,		"""modulation.projection_out"""			)

      if name == "norm.weight":
            SCREAMING_SNAKE_CASE	=		"""layernorm.weight"""
      if name == "norm.bias":
            SCREAMING_SNAKE_CASE	=		"""layernorm.bias"""

      if "head" in name:
            SCREAMING_SNAKE_CASE	=		name.replace("""head"""				,		"""classifier"""			)
      else:
            SCREAMING_SNAKE_CASE	=		"""focalnet.""" + name

      return name



def      __lowercase     (   _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE=False			)				->     Dict:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE	=		{
          """focalnet-tiny""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_srf.pth""",
          """focalnet-tiny-lrf""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_lrf.pth""",
          """focalnet-small""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_srf.pth""",
          """focalnet-small-lrf""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_lrf.pth""",
          """focalnet-base""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_srf.pth""",
          """focalnet-base-lrf""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_lrf.pth""",
          """focalnet-large-lrf-fl3""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384.pth""",
          """focalnet-large-lrf-fl4""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384_fl4.pth""",
          """focalnet-xlarge-lrf-fl3""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384.pth""",
          """focalnet-xlarge-lrf-fl4""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384_fl4.pth""",
      }
      # fmt: on

      SCREAMING_SNAKE_CASE	=		model_name_to_url[model_name]
      print("""Checkpoint URL: """				,		_SCREAMING_SNAKE_CASE			)
      SCREAMING_SNAKE_CASE	=		torch.hub.load_state_dict_from_url(_SCREAMING_SNAKE_CASE				,		map_location="""cpu"""			)["""model"""]

      # rename keys
      for key in state_dict.copy().keys():
            SCREAMING_SNAKE_CASE	=		state_dict.pop(_SCREAMING_SNAKE_CASE			)
            SCREAMING_SNAKE_CASE	=		val

      SCREAMING_SNAKE_CASE	=		get_focalnet_config(_SCREAMING_SNAKE_CASE			)
      SCREAMING_SNAKE_CASE	=		FocalNetForImageClassification(_SCREAMING_SNAKE_CASE			)
      model.eval()

      # load state dict
      model.load_state_dict(_SCREAMING_SNAKE_CASE			)

      # verify conversion
      SCREAMING_SNAKE_CASE	=		"""http://images.cocodataset.org/val2017/000000039769.jpg"""

      SCREAMING_SNAKE_CASE	=		BitImageProcessor(
          do_resize=_SCREAMING_SNAKE_CASE				,		size={"""shortest_edge""": 2_56}				,		resample=PILImageResampling.BILINEAR				,		do_center_crop=_SCREAMING_SNAKE_CASE				,		crop_size=2_24				,		do_normalize=_SCREAMING_SNAKE_CASE				,		image_mean=_SCREAMING_SNAKE_CASE				,		image_std=_SCREAMING_SNAKE_CASE				,		)
      SCREAMING_SNAKE_CASE	=		Image.open(requests.get(_SCREAMING_SNAKE_CASE				,		stream=_SCREAMING_SNAKE_CASE			).raw			)
      SCREAMING_SNAKE_CASE	=		processor(images=_SCREAMING_SNAKE_CASE				,		return_tensors="""pt"""			)

      SCREAMING_SNAKE_CASE	=		transforms.Compose(
          [
              transforms.Resize(2_56			),
              transforms.CenterCrop(2_24			),
              transforms.ToTensor(),
              transforms.Normalize(mean=[0.485, 0.456, 0.406]				,		std=[0.229, 0.224, 0.225]			),
          ]			)

      SCREAMING_SNAKE_CASE	=		image_transforms(_SCREAMING_SNAKE_CASE			).unsqueeze(0			)

      # verify pixel_values
      assert torch.allclose(inputs.pixel_values				,		_SCREAMING_SNAKE_CASE				,		atol=1E-4			)

      SCREAMING_SNAKE_CASE	=		model(**_SCREAMING_SNAKE_CASE			)

      SCREAMING_SNAKE_CASE	=		outputs.logits.argmax(-1			).item()
      print("""Predicted class:"""				,		model.config.idalabel[predicted_class_idx]			)

      print("""First values of logits:"""				,		outputs.logits[0, :3]			)

      if model_name == "focalnet-tiny":
            SCREAMING_SNAKE_CASE	=		torch.tensor([0.2_166, -0.4_368, 0.2_191]			)
      elif model_name == "focalnet-tiny-lrf":
            SCREAMING_SNAKE_CASE	=		torch.tensor([1.1_669, 0.0_125, -0.1_695]			)
      elif model_name == "focalnet-small":
            SCREAMING_SNAKE_CASE	=		torch.tensor([0.4_917, -0.0_430, 0.1_341]			)
      elif model_name == "focalnet-small-lrf":
            SCREAMING_SNAKE_CASE	=		torch.tensor([-0.2_588, -0.5_342, -0.2_331]			)
      elif model_name == "focalnet-base":
            SCREAMING_SNAKE_CASE	=		torch.tensor([-0.1_655, -0.4_090, -0.1_730]			)
      elif model_name == "focalnet-base-lrf":
            SCREAMING_SNAKE_CASE	=		torch.tensor([0.5_306, -0.0_483, -0.3_928]			)
      assert torch.allclose(outputs.logits[0, :3]				,		_SCREAMING_SNAKE_CASE				,		atol=1E-4			)
      print("""Looks ok!"""			)

      if pytorch_dump_folder_path is not None:
            print(F"""Saving model and processor of {model_name} to {pytorch_dump_folder_path}"""			)
            model.save_pretrained(_SCREAMING_SNAKE_CASE			)
            processor.save_pretrained(_SCREAMING_SNAKE_CASE			)

      if push_to_hub:
            print(F"""Pushing model and processor of {model_name} to the hub..."""			)
            model.push_to_hub(F"""{model_name}"""			)
            processor.push_to_hub(F"""{model_name}"""			)


if __name__ == "__main__":
      SCREAMING_SNAKE_CASE_		     = argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          """--model_name""",
          default="""focalnet-tiny""",
          type=str,
          help="""Name of the FocalNet model you'd like to convert.""",
      )
      parser.add_argument(
          """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
      )
      parser.add_argument(
          """--push_to_hub""",
          action="""store_true""",
          help="""Whether to push the model and processor to the hub.""",
      )

      SCREAMING_SNAKE_CASE_		     = parser.parse_args()
      convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)


