


from dataclasses import dataclass, field
from typing import Optional

from transformers import AutoConfig, AutoImageProcessor, AutoTokenizer, FlaxVisionEncoderDecoderModel, HfArgumentParser






@dataclass
class    UpperCAmelCase__	:



    """simple docstring"""






    UpperCAmelCase__						:		str              =  field(
        metadata={"help": "The output directory where the model will be written."}       ,  )
    UpperCAmelCase__						:		str              =  field(
        metadata={
            "help": (
                "The encoder model checkpoint for weights initialization."
                "Don't set if you want to train an encoder model from scratch."
            )
        }       ,  )
    UpperCAmelCase__						:		str              =  field(
        metadata={
            "help": (
                "The decoder model checkpoint for weights initialization."
                "Don't set if you want to train a decoder model from scratch."
            )
        }       ,  )
    UpperCAmelCase__						:		Optional[str]              =  field(
        default=A_       ,  metadata={"help": "Pretrained encoder config name or path if not the same as encoder_model_name"}		)
    UpperCAmelCase__						:		Optional[str]              =  field(
        default=A_       ,  metadata={"help": "Pretrained decoder config name or path if not the same as decoder_model_name"}		)

def 						_UpperCAmelCase    (      ):
     __UpperCamelCase   							=HfArgumentParser((ModelArguments,)    )
     ((__UpperCamelCase				)							,								)   							=parser.parse_args_into_dataclasses()

     # Load pretrained model and tokenizer

     # Use explicit specified encoder config
     if model_args.encoder_config_name:
          __UpperCamelCase   							=AutoConfig.from_pretrained(model_args.encoder_config_name    )
     # Use pretrained encoder model's config
     else:
          __UpperCamelCase   							=AutoConfig.from_pretrained(model_args.encoder_model_name_or_path    )

     # Use explicit specified decoder config
     if model_args.decoder_config_name:
          __UpperCamelCase   							=AutoConfig.from_pretrained(model_args.decoder_config_name    )
     # Use pretrained decoder model's config
     else:
          __UpperCamelCase   							=AutoConfig.from_pretrained(model_args.decoder_model_name_or_path    )

     # necessary for `from_encoder_decoder_pretrained` when `decoder_config` is passed
     __UpperCamelCase   							=True
     __UpperCamelCase   							=True

     __UpperCamelCase   							=FlaxVisionEncoderDecoderModel.from_encoder_decoder_pretrained(
         encoder_pretrained_model_name_or_path=model_args.encoder_model_name_or_path      ,					decoder_pretrained_model_name_or_path=model_args.decoder_model_name_or_path      ,					encoder_config=SCREAMING_SNAKE_CASE__      ,					decoder_config=SCREAMING_SNAKE_CASE__      ,					)

     # GPT2 only has bos/eos tokens but not decoder_start/pad tokens
     __UpperCamelCase   							=decoder_config.decoder_start_token_id
     __UpperCamelCase   							=decoder_config.pad_token_id
     if decoder_start_token_id is None:
          __UpperCamelCase   							=decoder_config.bos_token_id
     if pad_token_id is None:
          __UpperCamelCase   							=decoder_config.eos_token_id

     # This is necessary to make Flax's generate() work
     __UpperCamelCase   							=decoder_config.eos_token_id
     __UpperCamelCase   							=decoder_start_token_id
     __UpperCamelCase   							=pad_token_id

     __UpperCamelCase   							=AutoImageProcessor.from_pretrained(model_args.encoder_model_name_or_path    )

     __UpperCamelCase   							=AutoTokenizer.from_pretrained(model_args.decoder_model_name_or_path    )
     __UpperCamelCase   							=tokenizer.convert_ids_to_tokens(model.config.pad_token_id    )

     model.save_pretrained(model_args.output_dir    )
     image_processor.save_pretrained(model_args.output_dir    )
     tokenizer.save_pretrained(model_args.output_dir    )


if __name__ == "__main__":
   main()









import inspect
import os
import unittest
from dataclasses import dataclass

import torch

from accelerate import Accelerator, DistributedDataParallelKwargs, GradScalerKwargs
from accelerate.state import AcceleratorState
from accelerate.test_utils import execute_subprocess_async, require_cuda, require_multi_gpu
from accelerate.utils import KwargsHandler






@dataclass
class    UpperCAmelCase__	( A_		):



    """simple docstring"""






    UpperCAmelCase__						:		int              =  0
    UpperCAmelCase__						:		bool              =  False
    UpperCAmelCase__						:		float              =  3.0






class    UpperCAmelCase__	( unittest.TestCase		):



    """simple docstring"""






    def _a (      self   )  ->	Any:
         # If no defaults are changed, `to_kwargs` returns an empty dict.
         self.assertDictEqual(MockClass().to_kwargs() ,       {}   )
         self.assertDictEqual(MockClass(a=2   ).to_kwargs() ,       {'a': 2}   )
         self.assertDictEqual(MockClass(a=2 ,       b=A_   ).to_kwargs() ,       {'a': 2, 'b': True}   )
         self.assertDictEqual(MockClass(a=2 ,       c=2.25   ).to_kwargs() ,       {'a': 2, 'c': 2.25}   )






    @require_cuda
    def _a (      self   )  ->	Union[str, Any]:
         # If no defaults are changed, `to_kwargs` returns an empty dict.
         __UpperCamelCase   							=GradScalerKwargs(init_scale=1024 ,       growth_factor=2   )
         AcceleratorState._reset_state()
         __UpperCamelCase   							=Accelerator(mixed_precision='fp16' ,       kwargs_handlers=[scaler_handler]   )
         print(accelerator.use_fpaa   )
         __UpperCamelCase   							=accelerator.scaler

         # Check the kwargs have been applied
         self.assertEqual(scaler._init_scale ,       1024.0   )
         self.assertEqual(scaler._growth_factor ,       2.0   )

         # Check the other values are at the default
         self.assertEqual(scaler._backoff_factor ,       0.5   )
         self.assertEqual(scaler._growth_interval ,       2000   )
         self.assertEqual(scaler._enabled ,       A_   )






    @require_multi_gpu
    def _a (      self   )  ->	Optional[int]:
         __UpperCamelCase   							=['torchrun', f'--nproc_per_node={torch.cuda.device_count()}', inspect.getfile(self.__class__   )]
         execute_subprocess_async(A_ ,       env=os.environ.copy()   )


if __name__ == "__main__":
   _A			=						DistributedDataParallelKwargs(bucket_cap_mb=15, find_unused_parameters=True)
   _A			=						Accelerator(kwargs_handlers=[ddp_scaler])
   _A			=						torch.nn.Linear(100, 200)
   _A			=						accelerator.prepare(model)

   # Check the values changed in kwargs
   _A			=						''
   _A			=						model.bucket_bytes_cap // (1024 * 1024)
   if observed_bucket_cap_map != 15:
      error_msg += f"Kwargs badly passed, should have `15` but found {observed_bucket_cap_map}.\n"
   if model.find_unused_parameters is not True:
      error_msg += f"Kwargs badly passed, should have `True` but found {model.find_unused_parameters}.\n"

   # Check the values of the defaults
   if model.dim != 0:
      error_msg += f"Default value not respected, should have `0` but found {model.dim}.\n"
   if model.broadcast_buffers is not True:
      error_msg += f"Default value not respected, should have `True` but found {model.broadcast_buffers}.\n"
   if model.gradient_as_bucket_view is not False:
      error_msg += f"Default value not respected, should have `False` but found {model.gradient_as_bucket_view}.\n"

   # Raise error at the end to make sure we don't stop at the first failure.
   if len(error_msg) > 0:
      raise ValueError(error_msg)





