



import os
import random
from pathlib import Path
from typing import List

import numpy as np
import torch
from torch.cuda.amp import GradScaler

from .utils import (
    MODEL_NAME,
    OPTIMIZER_NAME,
    RNG_STATE_NAME,
    SCALER_NAME,
    SCHEDULER_NAME,
    get_pretty_name,
    is_tpu_available,
    is_xpu_available,
    save,
)


if is_tpu_available(check_device=False):
      import torch_xla.core.xla_model as xm

from .logging import get_logger
from .state import PartialState


lowerCamelCase__     =	get_logger(__name__)

def 					lowerCAmelCase__  (							_SCREAMING_SNAKE_CASE    :     str			,       _SCREAMING_SNAKE_CASE    :     List[dict]			,       _SCREAMING_SNAKE_CASE    :     list			,       _SCREAMING_SNAKE_CASE    :     list			,       _SCREAMING_SNAKE_CASE    :     int			,       _SCREAMING_SNAKE_CASE    :     GradScaler = None			,       ):
    """simple docstring"""







    for i, state in enumerate(_SCREAMING_SNAKE_CASE      ):
        __a					       =						f"{MODEL_NAME}.bin" if i == 0 else f"{MODEL_NAME}_{i}.bin"
        __a					       =						os.path.join(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE      )
        save(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE      )
        logger.info(f"Model weights saved in {output_model_file}"      )
    # Optimizer states
    for i, opt in enumerate(_SCREAMING_SNAKE_CASE      ):
        __a					       =						opt.state_dict()
        __a					       =						f"{OPTIMIZER_NAME}.bin" if i == 0 else f"{OPTIMIZER_NAME}_{i}.bin"
        __a					       =						os.path.join(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE      )
        save(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE      )
        logger.info(f"Optimizer state saved in {output_optimizer_file}"      )
    # Scheduler states
    for i, scheduler in enumerate(_SCREAMING_SNAKE_CASE      ):
        __a					       =						scheduler.state_dict()
        __a					       =						f"{SCHEDULER_NAME}.bin" if i == 0 else f"{SCHEDULER_NAME}_{i}.bin"
        __a					       =						os.path.join(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE      )
        save(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE      )
        logger.info(f"Scheduler state saved in {output_scheduler_file}"      )
    # GradScaler state
    if scaler is not None:
        __a					       =						scaler.state_dict()
        __a					       =						os.path.join(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE      )
        torch.save(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE      )
        logger.info(f"Gradient scaler state saved in {output_scaler_file}"      )
    # Random number generator states
    __a					       =						{}
    __a					       =						f"{RNG_STATE_NAME}_{process_index}.pkl"
    __a					       =						random.getstate()
    __a					       =						np.random.get_state()
    __a					       =						torch.get_rng_state()
    if is_xpu_available():
        __a					       =						torch.xpu.get_rng_state_all()
    else:
        __a					       =						torch.cuda.get_rng_state_all()
    if is_tpu_available():
        __a					       =						xm.get_rng_state()
    __a					       =						os.path.join(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE      )
    torch.save(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE      )
    logger.info(f"Random states saved in {output_states_file}"      )
    return output_dir

def 					lowerCAmelCase__  (							_SCREAMING_SNAKE_CASE    :     Optional[Any]			,       _SCREAMING_SNAKE_CASE    :     Tuple			,       _SCREAMING_SNAKE_CASE    :     Tuple			,       _SCREAMING_SNAKE_CASE    :     Tuple			,       _SCREAMING_SNAKE_CASE    :     List[Any]			,       _SCREAMING_SNAKE_CASE    :     Optional[Any]=None			,       _SCREAMING_SNAKE_CASE    :     Union[str, Any]=None			,       **_SCREAMING_SNAKE_CASE    :     Optional[Any]			,       ):
    """simple docstring"""







    if map_location not in [None, "cpu", "on_device"]:
        raise TypeError(
            """Unsupported optimizer map location passed, please choose one of `None`, `'cpu'`, or `'on_device'`"""      )
    if map_location is None:
        __a					       =						"""cpu"""
    elif map_location == "on_device":
        __a					       =						PartialState().device
    # Model states
    for i, model in enumerate(_SCREAMING_SNAKE_CASE      ):
        __a					       =						f"{MODEL_NAME}.bin" if i == 0 else f"{MODEL_NAME}_{i}.bin"
        __a					       =						os.path.join(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE      )
        models[i].load_state_dict(torch.load(_SCREAMING_SNAKE_CASE			,       map_location=_SCREAMING_SNAKE_CASE      )			,       **_SCREAMING_SNAKE_CASE      )
    logger.info("""All model weights loaded successfully"""      )

    # Optimizer states
    for i, opt in enumerate(_SCREAMING_SNAKE_CASE      ):
        __a					       =						f"{OPTIMIZER_NAME}.bin" if i == 0 else f"{OPTIMIZER_NAME}_{i}.bin"
        __a					       =						os.path.join(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE      )
        __a					       =						torch.load(_SCREAMING_SNAKE_CASE			,       map_location=_SCREAMING_SNAKE_CASE      )
        optimizers[i].load_state_dict(_SCREAMING_SNAKE_CASE      )
    logger.info("""All optimizer states loaded successfully"""      )

    # Scheduler states
    for i, scheduler in enumerate(_SCREAMING_SNAKE_CASE      ):
        __a					       =						f"{SCHEDULER_NAME}.bin" if i == 0 else f"{SCHEDULER_NAME}_{i}.bin"
        __a					       =						os.path.join(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE      )
        scheduler.load_state_dict(torch.load(_SCREAMING_SNAKE_CASE      )      )
    logger.info("""All scheduler states loaded successfully"""      )

    # GradScaler state
    if scaler is not None:
        __a					       =						os.path.join(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE      )
        scaler.load_state_dict(torch.load(_SCREAMING_SNAKE_CASE      )      )
        logger.info("""GradScaler state loaded successfully"""      )

    # Random states
    try:
        __a					       =						torch.load(os.path.join(_SCREAMING_SNAKE_CASE			,       f"{RNG_STATE_NAME}_{process_index}.pkl"      )      )
        random.setstate(states["""random_state"""]      )
        np.random.set_state(states["""numpy_random_seed"""]      )
        torch.set_rng_state(states["""torch_manual_seed"""]      )
        if is_xpu_available():
            torch.xpu.set_rng_state_all(states["""torch_xpu_manual_seed"""]      )
        else:
            torch.cuda.set_rng_state_all(states["""torch_cuda_manual_seed"""]      )
        if is_tpu_available():
            xm.set_rng_state(states["""xm_seed"""]      )
        logger.info("""All random states loaded successfully"""      )
    except Exception:
        logger.info("""Could not load random states"""      )

def 					lowerCAmelCase__  (							_SCREAMING_SNAKE_CASE    :     List[Any]			,       _SCREAMING_SNAKE_CASE    :     Dict			,       _SCREAMING_SNAKE_CASE    :     int = 0      ):
    """simple docstring"""







    __a					       =						Path(_SCREAMING_SNAKE_CASE      ) / f"custom_checkpoint_{index}.pkl"
    logger.info(f"Saving the state of {get_pretty_name(_SCREAMING_SNAKE_CASE      )} to {save_location}"      )
    torch.save(obj.state_dict()			,       _SCREAMING_SNAKE_CASE      )

def 					lowerCAmelCase__  (							_SCREAMING_SNAKE_CASE    :     int			,       _SCREAMING_SNAKE_CASE    :     Dict			,       _SCREAMING_SNAKE_CASE    :     int = 0      ):
    """simple docstring"""







    __a					       =						f"{path}/custom_checkpoint_{index}.pkl"
    logger.info(f"Loading the state of {get_pretty_name(_SCREAMING_SNAKE_CASE      )} from {load_location}"      )
    obj.load_state_dict(torch.load(_SCREAMING_SNAKE_CASE			,       map_location="""cpu"""      )      )





import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCamelCase__     =	logging.get_logger(__name__)

lowerCamelCase__     =	{
    """facebook/sam-vit-huge""": """https://huggingface.co/facebook/sam-vit-huge/resolve/main/config.json""",
    """facebook/sam-vit-large""": """https://huggingface.co/facebook/sam-vit-large/resolve/main/config.json""",
    """facebook/sam-vit-base""": """https://huggingface.co/facebook/sam-vit-base/resolve/main/config.json""",
}






class 				SCREAMING_SNAKE_CASE     (							lowerCamelCase__   ):





							def __init__(				self						:						List[Any] ,			__lowercase						:						Optional[Any]=256 ,			__lowercase						:						Optional[int]=1024 ,			__lowercase						:						Any=16 ,			__lowercase						:						Optional[Any]=16 ,			__lowercase						:						Optional[Any]=4 ,			__lowercase						:						Optional[int]="gelu" ,			__lowercase						:						List[Any]=1E-6 ,			**__lowercase						:						str ,			):

											'''simple docstring'''
											super().__init__(**__lowercase		)
											__a					       =						hidden_size
											__a					       =						image_size
											__a					       =						patch_size
											__a					       =						image_size // patch_size
											__a					       =						mask_input_channels
											__a					       =						num_point_embeddings
											__a					       =						hidden_act
											__a					       =						layer_norm_eps






class 				SCREAMING_SNAKE_CASE     (							lowerCamelCase__   ):





							def __init__(				self						:						int ,			__lowercase						:						Tuple=256 ,			__lowercase						:						List[Any]="relu" ,			__lowercase						:						Any=2048 ,			__lowercase						:						List[Any]=2 ,			__lowercase						:						List[str]=8 ,			__lowercase						:						Any=2 ,			__lowercase						:						List[Any]=3 ,			__lowercase						:						str=3 ,			__lowercase						:						str=256 ,			__lowercase						:						Optional[Any]=1E-6 ,			**__lowercase						:						Tuple ,			):

											'''simple docstring'''
											super().__init__(**__lowercase		)
											__a					       =						hidden_size
											__a					       =						hidden_act
											__a					       =						mlp_dim
											__a					       =						num_hidden_layers
											__a					       =						num_attention_heads
											__a					       =						attention_downsample_rate
											__a					       =						num_multimask_outputs
											__a					       =						iou_head_depth
											__a					       =						iou_head_hidden_dim
											__a					       =						layer_norm_eps






class 				SCREAMING_SNAKE_CASE     (							lowerCamelCase__   ):





							def __init__(				self						:						List[Any] ,			__lowercase						:						List[Any]=768 ,			__lowercase						:						List[Any]=256 ,			__lowercase						:						Any=12 ,			__lowercase						:						Tuple=12 ,			__lowercase						:						Union[str, Any]=3 ,			__lowercase						:						Tuple=1024 ,			__lowercase						:						Any=16 ,			__lowercase						:						Dict="gelu" ,			__lowercase						:						List[Any]=1E-06 ,			__lowercase						:						List[str]=0.0 ,			__lowercase						:						Optional[Any]=1E-10 ,			__lowercase						:						Optional[Any]=True ,			__lowercase						:						str=4.0 ,			__lowercase						:						List[Any]=True ,			__lowercase						:						Dict=True ,			__lowercase						:						Optional[Any]=14 ,			__lowercase						:						Optional[int]=[2, 5, 8, 11] ,			__lowercase						:						List[str]=128 ,			__lowercase						:						Optional[int]=None ,			**__lowercase						:						List[Any] ,			):

											'''simple docstring'''
											super().__init__(**__lowercase		)

											__a					       =						hidden_size
											__a					       =						output_channels
											__a					       =						num_hidden_layers
											__a					       =						num_attention_heads
											__a					       =						num_channels
											__a					       =						image_size
											__a					       =						patch_size
											__a					       =						hidden_act
											__a					       =						layer_norm_eps
											__a					       =						attention_dropout
											__a					       =						initializer_range
											__a					       =						qkv_bias
											__a					       =						mlp_ratio
											__a					       =						use_abs_pos
											__a					       =						use_rel_pos
											__a					       =						window_size
											__a					       =						global_attn_indexes
											__a					       =						num_pos_feats
											__a					       =						int(hidden_size * mlp_ratio		) if mlp_dim is None else mlp_dim






class 				SCREAMING_SNAKE_CASE     (							lowerCamelCase__   ):
							__lowerCamelCase		:		Dict      ='sam'
							__lowerCamelCase		:		Any      =True





							def __init__(				self						:						List[str] ,			__lowercase						:						List[str]=None ,			__lowercase						:						Optional[int]=None ,			__lowercase						:						Dict=None ,			__lowercase						:						Optional[int]=0.02 ,			**__lowercase						:						List[str] ,			):

											'''simple docstring'''
											super().__init__(**__lowercase		)
											__a					       =						vision_config if vision_config is not None else {}
											__a					       =						prompt_encoder_config if prompt_encoder_config is not None else {}
											__a					       =						mask_decoder_config if mask_decoder_config is not None else {}

											if isinstance(__lowercase ,			__lowercase		):
															__a					       =						vision_config.to_dict()
											if isinstance(__lowercase ,			__lowercase		):
															__a					       =						prompt_encoder_config.to_dict()
											if isinstance(__lowercase ,			__lowercase		):
															__a					       =						mask_decoder_config.to_dict()

											__a					       =						SamVisionConfig(**__lowercase		)
											__a					       =						SamPromptEncoderConfig(**__lowercase		)
											__a					       =						SamMaskDecoderConfig(**__lowercase		)
											__a					       =						initializer_range







							def   UpperCamelCase_   (				self						:						Union[str, Any]		):

											'''simple docstring'''
											__a					       =						copy.deepcopy(self.__dict__		)
											__a					       =						self.vision_config.to_dict()
											__a					       =						self.prompt_encoder_config.to_dict()
											__a					       =						self.mask_decoder_config.to_dict()
											__a					       =						self.__class__.model_type
											return output
