
"""simple docstring"""

from dataclasses import dataclass, field
from typing import Optional

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






@dataclass
class 	_lowercase       :
	lowercase_				=     field(
	    metadata={'help': 'The output directory where the model will be written.'}    ,	)
	lowercase_				=     field(
	    metadata={
	        'help': (
	            'The encoder model checkpoint for weights initialization.'
	            'Don\'t set if you want to train an encoder model from scratch.'
	        )
	    }    ,	)
	lowercase_				=     field(
	    metadata={
	        'help': (
	            'The decoder model checkpoint for weights initialization.'
	            'Don\'t set if you want to train a decoder model from scratch.'
	        )
	    }    ,	)
	lowercase_				=     field(
	    default=__UpperCAmelCase    ,	metadata={'help': 'Pretrained encoder config name or path if not the same as encoder_model_name'}		)
	lowercase_				=     field(
	    default=__UpperCAmelCase    ,	metadata={'help': 'Pretrained decoder config name or path if not the same as decoder_model_name'}		)


def 		UpperCAmelCase (		):





		'''simple docstring'''


		lowerCamelCase					:      str          =   HfArgumentParser((ModelArguments,)      )
		((lowerCamelCase)     ,   )					:      Optional[int]          =   parser.parse_args_into_dataclasses()

		# Load pretrained model and tokenizer

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

		# Use explicit specified decoder config
		if model_args.decoder_config_name:
				lowerCamelCase					:      Optional[int]          =   AutoConfig.from_pretrained(model_args.decoder_config_name      )
		# Use pretrained decoder model's config
		else:
				lowerCamelCase					:      Any          =   AutoConfig.from_pretrained(model_args.decoder_model_name_or_path      )

		# necessary for `from_encoder_decoder_pretrained` when `decoder_config` is passed
		lowerCamelCase					:      Optional[int]          =   True
		lowerCamelCase					:      Optional[Any]          =   True

		lowerCamelCase					:      Optional[int]          =   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=a_,						decoder_config=a_,						)

		# GPT2 only has bos/eos tokens but not decoder_start/pad tokens
		lowerCamelCase					:      List[str]          =   decoder_config.decoder_start_token_id
		lowerCamelCase					:      Any          =   decoder_config.pad_token_id
		if decoder_start_token_id is None:
				lowerCamelCase					:      Optional[int]          =   decoder_config.bos_token_id
		if pad_token_id is None:
				lowerCamelCase					:      Optional[int]          =   decoder_config.eos_token_id

		# This is necessary to make Flax's generate() work
		lowerCamelCase					:      str          =   decoder_config.eos_token_id
		lowerCamelCase					:      List[str]          =   decoder_start_token_id
		lowerCamelCase					:      Union[str, Any]          =   pad_token_id

		lowerCamelCase					:      List[Any]          =   AutoImageProcessor.from_pretrained(model_args.encoder_model_name_or_path      )

		lowerCamelCase					:      Union[str, Any]          =   AutoTokenizer.from_pretrained(model_args.decoder_model_name_or_path      )
		lowerCamelCase					:      Dict          =   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()








"""simple docstring"""

def 		UpperCAmelCase (		a_ = 1000      ):





		'''simple docstring'''


		lowerCamelCase					:      Dict          =   2**power
		lowerCamelCase					:      List[str]          =   str(a_      )
		lowerCamelCase					:      Dict          =   list(a_      )
		lowerCamelCase					:      Optional[Any]          =   0

		for i in list_num:
				sum_of_num += int(a_      )

		return sum_of_num


if __name__ == "__main__":
					_A						=			int(input('Enter the power of 2: ').strip())
					print('2 ^ ', power, ' = ', 2**power)
					_A						=			solution(power)
					print('Sum of the digits is: ', result)






