

import collections
import inspect
import unittest

from transformers import SwinvaConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel
    from transformers.models.swinva.modeling_swinva import SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor
class        _A						:

  def __init__( self       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE=13       ,    _SCREAMING_SNAKE_CASE=32       ,    _SCREAMING_SNAKE_CASE=2       ,    _SCREAMING_SNAKE_CASE=3       ,    _SCREAMING_SNAKE_CASE=16       ,    _SCREAMING_SNAKE_CASE=[1, 2, 1]       ,    _SCREAMING_SNAKE_CASE=[2, 2, 4]       ,    _SCREAMING_SNAKE_CASE=2       ,    _SCREAMING_SNAKE_CASE=2.0       ,    _SCREAMING_SNAKE_CASE=True       ,    _SCREAMING_SNAKE_CASE=0.0       ,    _SCREAMING_SNAKE_CASE=0.0       ,    _SCREAMING_SNAKE_CASE=0.1       ,    _SCREAMING_SNAKE_CASE="gelu"       ,    _SCREAMING_SNAKE_CASE=False       ,    _SCREAMING_SNAKE_CASE=True       ,    _SCREAMING_SNAKE_CASE=0.02       ,    _SCREAMING_SNAKE_CASE=1e-5       ,    _SCREAMING_SNAKE_CASE=True       ,    _SCREAMING_SNAKE_CASE=None       ,    _SCREAMING_SNAKE_CASE=True       ,    _SCREAMING_SNAKE_CASE=10       ,    _SCREAMING_SNAKE_CASE=8       ,    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     int							=   parent
        SCREAMING_SNAKE_CASE_ :     Dict							=   batch_size
        SCREAMING_SNAKE_CASE_ :     Tuple							=   image_size
        SCREAMING_SNAKE_CASE_ :     List[Any]							=   patch_size
        SCREAMING_SNAKE_CASE_ :     Optional[int]							=   num_channels
        SCREAMING_SNAKE_CASE_ :     List[str]							=   embed_dim
        SCREAMING_SNAKE_CASE_ :     Optional[int]							=   depths
        SCREAMING_SNAKE_CASE_ :     Dict							=   num_heads
        SCREAMING_SNAKE_CASE_ :     List[Any]							=   window_size
        SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   mlp_ratio
        SCREAMING_SNAKE_CASE_ :     Optional[int]							=   qkv_bias
        SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   hidden_dropout_prob
        SCREAMING_SNAKE_CASE_ :     Any							=   attention_probs_dropout_prob
        SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   drop_path_rate
        SCREAMING_SNAKE_CASE_ :     Dict							=   hidden_act
        SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   use_absolute_embeddings
        SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   patch_norm
        SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   layer_norm_eps
        SCREAMING_SNAKE_CASE_ :     List[str]							=   initializer_range
        SCREAMING_SNAKE_CASE_ :     Optional[int]							=   is_training
        SCREAMING_SNAKE_CASE_ :     Optional[int]							=   scope
        SCREAMING_SNAKE_CASE_ :     List[str]							=   use_labels
        SCREAMING_SNAKE_CASE_ :     Any							=   type_sequence_label_size
        SCREAMING_SNAKE_CASE_ :     List[Any]							=   encoder_stride

  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Dict							=   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

        SCREAMING_SNAKE_CASE_ :     List[str]							=   None
        if self.use_labels:
              SCREAMING_SNAKE_CASE_ :     int							=   ids_tensor([self.batch_size]       ,    self.type_sequence_label_size    )

        SCREAMING_SNAKE_CASE_ :     List[Any]							=   self.get_config()

        return config, pixel_values, labels

  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        return SwinvaConfig(
            image_size=self.image_size       ,    patch_size=self.patch_size       ,    num_channels=self.num_channels       ,    embed_dim=self.embed_dim       ,    depths=self.depths       ,    num_heads=self.num_heads       ,    window_size=self.window_size       ,    mlp_ratio=self.mlp_ratio       ,    qkv_bias=self.qkv_bias       ,    hidden_dropout_prob=self.hidden_dropout_prob       ,    attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,    drop_path_rate=self.drop_path_rate       ,    hidden_act=self.hidden_act       ,    use_absolute_embeddings=self.use_absolute_embeddings       ,    path_norm=self.patch_norm       ,    layer_norm_eps=self.layer_norm_eps       ,    initializer_range=self.initializer_range       ,    encoder_stride=self.encoder_stride       ,    )

  def        UpperCAmelCase			( self       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Any							=   SwinvaModel(config=snake_case_    )
        model.to(snake_case_    )
        model.eval()
        SCREAMING_SNAKE_CASE_ :     List[Any]							=   model(snake_case_    )

        SCREAMING_SNAKE_CASE_ :     str							=   ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths    ) - 1))
        SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   int(config.embed_dim * 2 ** (len(config.depths    ) - 1)    )

        self.parent.assertEqual(result.last_hidden_state.shape       ,    (self.batch_size, expected_seq_len, expected_dim)    )

  def        UpperCAmelCase			( self       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     str							=   SwinvaForMaskedImageModeling(config=snake_case_    )
        model.to(snake_case_    )
        model.eval()
        SCREAMING_SNAKE_CASE_ :     str							=   model(snake_case_    )
        self.parent.assertEqual(
            result.logits.shape       ,    (self.batch_size, self.num_channels, self.image_size, self.image_size)    )

        # test greyscale images
        SCREAMING_SNAKE_CASE_ :     Optional[int]							=   1
        SCREAMING_SNAKE_CASE_ :     str							=   SwinvaForMaskedImageModeling(snake_case_    )
        model.to(snake_case_    )
        model.eval()

        SCREAMING_SNAKE_CASE_ :     List[str]							=   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
        SCREAMING_SNAKE_CASE_ :     Optional[Any]							=   model(snake_case_    )
        self.parent.assertEqual(result.logits.shape       ,    (self.batch_size, 1, self.image_size, self.image_size)    )

  def        UpperCAmelCase			( self       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     List[str]							=   self.type_sequence_label_size
        SCREAMING_SNAKE_CASE_ :     Dict							=   SwinvaForImageClassification(snake_case_    )
        model.to(snake_case_    )
        model.eval()
        SCREAMING_SNAKE_CASE_ :     Optional[Any]							=   model(snake_case_       ,    labels=snake_case_    )
        self.parent.assertEqual(result.logits.shape       ,    (self.batch_size, self.type_sequence_label_size)    )



  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   self.prepare_config_and_inputs()
        SCREAMING_SNAKE_CASE_ :     List[Any]							=   config_and_inputs
        SCREAMING_SNAKE_CASE_ :     List[Any]							=   {'pixel_values': pixel_values}
        return config, inputs_dict

@require_torch
class        _A						(     UpperCAmelCase__      ,   UpperCAmelCase__      ,   unittest.TestCase):
  SCREAMING_SNAKE_CASE			:					Tuple				=     (
      (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
  )
  SCREAMING_SNAKE_CASE			:					Dict				=     (
      {"""feature-extraction""": SwinvaModel, """image-classification""": SwinvaForImageClassification}
      if is_torch_available()
      else {}
  )

  SCREAMING_SNAKE_CASE			:					Dict				=     False
  SCREAMING_SNAKE_CASE			:					int				=     False
  SCREAMING_SNAKE_CASE			:					Union[str, Any]				=     False
  SCREAMING_SNAKE_CASE			:					Dict				=     False

  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Dict							=   SwinvaModelTester(self    )
        SCREAMING_SNAKE_CASE_ :     Any							=   ConfigTester(self       ,    config_class=snake_case_       ,    embed_dim=37    )

  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        self.config_tester.create_and_test_config_to_json_string()
        self.config_tester.create_and_test_config_to_json_file()
        self.config_tester.create_and_test_config_from_and_save_pretrained()
        self.config_tester.create_and_test_config_with_num_labels()
        self.config_tester.check_config_can_be_init_without_params()
        self.config_tester.check_config_arguments_init()

  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     List[str]							=   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*snake_case_    )

  @unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.'    )
  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        pass

  @unittest.skip(reason='Swinv2 does not use inputs_embeds'    )
  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        pass

  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Optional[Any]							=   self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_ :     Optional[Any]							=   model_class(snake_case_    )
              self.assertIsInstance(model.get_input_embeddings()       ,    (nn.Module)    )
              SCREAMING_SNAKE_CASE_ :     str							=   model.get_output_embeddings()
              self.assertTrue(x is None or isinstance(snake_case_       ,    nn.Linear    )    )

  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     List[str]							=   self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_ :     Optional[int]							=   model_class(snake_case_    )
              SCREAMING_SNAKE_CASE_ :     List[str]							=   inspect.signature(model.forward    )
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              SCREAMING_SNAKE_CASE_ :     List[str]							=   [*signature.parameters.keys()]

              SCREAMING_SNAKE_CASE_ :     List[str]							=   ['pixel_values']
              self.assertListEqual(arg_names[:1]       ,    snake_case_    )

  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     List[Any]							=   self.model_tester.prepare_config_and_inputs_for_common()
        SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   True

        for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_ :     str							=   True
              SCREAMING_SNAKE_CASE_ :     Dict							=   False
              SCREAMING_SNAKE_CASE_ :     Tuple							=   True
              SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   model_class(snake_case_    )
              model.to(snake_case_    )
              model.eval()
              with torch.no_grad():
                    SCREAMING_SNAKE_CASE_ :     Dict							=   model(**self._prepare_for_class(snake_case_       ,    snake_case_    )    )
              SCREAMING_SNAKE_CASE_ :     str							=   outputs.attentions
              SCREAMING_SNAKE_CASE_ :     List[Any]							=   len(self.model_tester.depths    )
              self.assertEqual(len(snake_case_    )       ,    snake_case_    )

              # check that output_attentions also work using config
              del inputs_dict["output_attentions"]
              SCREAMING_SNAKE_CASE_ :     int							=   True
              SCREAMING_SNAKE_CASE_ :     List[Any]							=   config.window_size**2
              SCREAMING_SNAKE_CASE_ :     str							=   model_class(snake_case_    )
              model.to(snake_case_    )
              model.eval()
              with torch.no_grad():
                    SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   model(**self._prepare_for_class(snake_case_       ,    snake_case_    )    )
              SCREAMING_SNAKE_CASE_ :     List[str]							=   outputs.attentions
              self.assertEqual(len(snake_case_    )       ,    snake_case_    )

              self.assertListEqual(
                  list(attentions[0].shape[-3:]    )       ,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]       ,    )
              SCREAMING_SNAKE_CASE_ :     Dict							=   len(snake_case_    )

              # Check attention is always last and order is fine
              SCREAMING_SNAKE_CASE_ :     Optional[Any]							=   True
              SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   True
              SCREAMING_SNAKE_CASE_ :     int							=   model_class(snake_case_    )
              model.to(snake_case_    )
              model.eval()
              with torch.no_grad():
                    SCREAMING_SNAKE_CASE_ :     List[Any]							=   model(**self._prepare_for_class(snake_case_       ,    snake_case_    )    )

              if hasattr(self.model_tester       ,    'num_hidden_states_types'    ):
                    SCREAMING_SNAKE_CASE_ :     int							=   self.model_tester.num_hidden_states_types
              else:
                    # also another +1 for reshaped_hidden_states
                    SCREAMING_SNAKE_CASE_ :     str							=   2
              self.assertEqual(out_len + added_hidden_states       ,    len(snake_case_    )    )

              SCREAMING_SNAKE_CASE_ :     List[str]							=   outputs.attentions

              self.assertEqual(len(snake_case_    )       ,    snake_case_    )

              self.assertListEqual(
                  list(self_attentions[0].shape[-3:]    )       ,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]       ,    )

  def        UpperCAmelCase			( self       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Optional[Any]							=   model_class(snake_case_    )
        model.to(snake_case_    )
        model.eval()

        with torch.no_grad():
              SCREAMING_SNAKE_CASE_ :     Optional[Any]							=   model(**self._prepare_for_class(snake_case_       ,    snake_case_    )    )

        SCREAMING_SNAKE_CASE_ :     Dict							=   outputs.hidden_states

        SCREAMING_SNAKE_CASE_ :     List[Any]							=   getattr(
            self.model_tester       ,    'expected_num_hidden_layers'       ,    len(self.model_tester.depths    ) + 1    )
        self.assertEqual(len(snake_case_    )       ,    snake_case_    )

        # Swinv2 has a different seq_length
        SCREAMING_SNAKE_CASE_ :     List[Any]							=   (
            config.patch_size
            if isinstance(config.patch_size       ,    collections.abc.Iterable    )
            else (config.patch_size, config.patch_size)
        )

        SCREAMING_SNAKE_CASE_ :     List[Any]							=   (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

        self.assertListEqual(
            list(hidden_states[0].shape[-2:]    )       ,    [num_patches, self.model_tester.embed_dim]       ,    )

        SCREAMING_SNAKE_CASE_ :     int							=   outputs.reshaped_hidden_states
        self.assertEqual(len(snake_case_    )       ,    snake_case_    )

        SCREAMING_SNAKE_CASE_ :     List[str]							=   reshaped_hidden_states[0].shape
        SCREAMING_SNAKE_CASE_ :     Optional[Any]							=   (
            reshaped_hidden_states[0].view(snake_case_       ,    snake_case_       ,    height * width    ).permute(0       ,    2       ,    1    )
        )
        self.assertListEqual(
            list(reshaped_hidden_states.shape[-2:]    )       ,    [num_patches, self.model_tester.embed_dim]       ,    )

  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     int							=   self.model_tester.prepare_config_and_inputs_for_common()

        SCREAMING_SNAKE_CASE_ :     int							=   (
            self.model_tester.image_size
            if isinstance(self.model_tester.image_size       ,    collections.abc.Iterable    )
            else (self.model_tester.image_size, self.model_tester.image_size)
        )

        for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_ :     int							=   True
              self.check_hidden_states_output(snake_case_       ,    snake_case_       ,    snake_case_       ,    snake_case_    )

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              SCREAMING_SNAKE_CASE_ :     str							=   True

              self.check_hidden_states_output(snake_case_       ,    snake_case_       ,    snake_case_       ,    snake_case_    )

  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Dict							=   self.model_tester.prepare_config_and_inputs_for_common()
        SCREAMING_SNAKE_CASE_ :     int							=   3

        SCREAMING_SNAKE_CASE_ :     Any							=   (
            self.model_tester.image_size
            if isinstance(self.model_tester.image_size       ,    collections.abc.Iterable    )
            else (self.model_tester.image_size, self.model_tester.image_size)
        )
        SCREAMING_SNAKE_CASE_ :     Dict							=   (
            config.patch_size
            if isinstance(config.patch_size       ,    collections.abc.Iterable    )
            else (config.patch_size, config.patch_size)
        )

        SCREAMING_SNAKE_CASE_ :     Optional[int]							=   image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
        SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

        for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   True
              self.check_hidden_states_output(snake_case_       ,    snake_case_       ,    snake_case_       ,    (padded_height, padded_width)    )

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   True
              self.check_hidden_states_output(snake_case_       ,    snake_case_       ,    snake_case_       ,    (padded_height, padded_width)    )

  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Dict							=   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_image_modeling(*snake_case_    )

  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*snake_case_    )

  @slow
  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              SCREAMING_SNAKE_CASE_ :     str							=   SwinvaModel.from_pretrained(snake_case_    )
              self.assertIsNotNone(snake_case_    )



  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Dict							=   self.model_tester.prepare_config_and_inputs_for_common()

        SCREAMING_SNAKE_CASE_ :     Optional[int]							=   _config_zero_init(snake_case_    )
        for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_ :     List[str]							=   model_class(config=snake_case_    )
              for name, param in model.named_parameters():
                    if "embeddings" not in name and "logit_scale" not in name and param.requires_grad:
                          self.assertIn(
                              ((param.data.mean() * 1e9).round() / 1e9).item()       ,    [0.0, 1.0]       ,    msg=f"Parameter {name} of model {model_class} seems not properly initialized"       ,    )

@require_vision
@require_torch
class        _A						(     unittest.TestCase):

  @cached_property
  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        return (
            AutoImageProcessor.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'    )
            if is_vision_available()
            else None
        )



  @slow
  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     List[str]							=   SwinvaForImageClassification.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'    ).to(
            snake_case_    )
        SCREAMING_SNAKE_CASE_ :     List[str]							=   self.default_image_processor

        SCREAMING_SNAKE_CASE_ :     Dict							=   Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'    )
        SCREAMING_SNAKE_CASE_ :     List[Any]							=   image_processor(images=snake_case_       ,    return_tensors='pt'    ).to(snake_case_    )

        # forward pass
        with torch.no_grad():
              SCREAMING_SNAKE_CASE_ :     Any							=   model(**snake_case_    )

        # verify the logits
        SCREAMING_SNAKE_CASE_ :     Tuple							=   torch.Size((1, 1000)    )
        self.assertEqual(outputs.logits.shape       ,    snake_case_    )
        SCREAMING_SNAKE_CASE_ :     Dict							=   torch.tensor([-0.3947, -0.4306, 0.0026]    ).to(snake_case_    )
        self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,    snake_case_       ,    atol=1e-4    )    )













"""simple docstring"""




from arguments import InitializationArguments

from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer, HfArgumentParser


# Configuration
lowerCamelCase_     :						Any						=					HfArgumentParser(InitializationArguments)
lowerCamelCase_     :						Union[str, Any]						=					parser.parse_args()

# Load codeparrot tokenizer trained for Python code tokenization
lowerCamelCase_     :						List[Any]						=					AutoTokenizer.from_pretrained(args.tokenizer_name)

# Config: "scale_attn_by_layer_idx" and "reorder_and_upcast_attn" are Mistral stability tweaks
lowerCamelCase_     :						Tuple						=					{
    'vocab_size': len(tokenizer),
    'scale_attn_by_inverse_layer_idx': True,
    'reorder_and_upcast_attn': True,
}

# Load model config (GPT-2 large in this case)
lowerCamelCase_     :						int						=					AutoConfig.from_pretrained(args.config_name, **config_kwargs)

# Initialize new model with config
lowerCamelCase_     :						Any						=					AutoModelForCausalLM.from_config(config)

# Save model to the hub
model.save_pretrained(args.model_name, push_to_hub=args.push_to_hub)