

from typing import Any, Dict, List, Optional, Tuple, Union

import torch
from torch import nn
from torch.utils.data import DistributedSampler, RandomSampler

from transformers import PreTrainedModel, Trainer, logging
from transformers.integrations import is_fairscale_available
from transformers.models.fsmt.configuration_fsmt import FSMTConfig
from transformers.optimization import (
    Adafactor,
    AdamW,
    get_constant_schedule,
    get_constant_schedule_with_warmup,
    get_cosine_schedule_with_warmup,
    get_cosine_with_hard_restarts_schedule_with_warmup,
    get_linear_schedule_with_warmup,
    get_polynomial_decay_schedule_with_warmup,
)
from transformers.trainer_pt_utils import get_tpu_sampler
from transformers.training_args import ParallelMode
from transformers.utils import is_torch_tpu_available


if is_fairscale_available():
      from fairscale.optim import OSS


a_    :						Optional[Any]    		=      logging.get_logger(__name__)

a_    :						str    		=      {
    "linear": get_linear_schedule_with_warmup,
    "cosine": get_cosine_schedule_with_warmup,
    "cosine_w_restarts": get_cosine_with_hard_restarts_schedule_with_warmup,
    "polynomial": get_polynomial_decay_schedule_with_warmup,
    "constant": get_constant_schedule,
    "constant_w_warmup": get_constant_schedule_with_warmup,
}




class      UpperCamelCase (     SCREAMING_SNAKE_CASE   ):

    def __init__(			self :      Optional[Any]							,    snake_case__ :      Union[str, Any]=None							,    snake_case__ :      str=None							,    *snake_case__ :      Optional[Any]							,    **snake_case__ :      Dict    ):

     """simple docstring"""






     super().__init__(*snake_case__							,    **snake_case__    )

     if config is None:
      assert isinstance(self.model							,    snake_case__    ), (
          "If no `config` is passed the model to be trained has to be of type `PreTrainedModel`, but is"
          F""" {self.model.__class__}"""
      )
      SCREAMING_SNAKE_CASE								=			self.model.config
     else:
      SCREAMING_SNAKE_CASE								=			config

     SCREAMING_SNAKE_CASE								=			data_args
     SCREAMING_SNAKE_CASE								=			self.config.tgt_vocab_size if isinstance(self.config							,    snake_case__    ) else self.config.vocab_size

     if self.args.label_smoothing != 0 or (self.data_args is not None and self.data_args.ignore_pad_token_for_loss):
      assert self.config.pad_token_id is not None, (
          "Make sure that `config.pad_token_id` is correcly defined when ignoring `pad_token` for loss"
          " calculation or doing label smoothing."
      )

     if self.config.pad_token_id is None and self.config.eos_token_id is not None:
      logger.warning(
          F"""The `config.pad_token_id` is `None`. Using `config.eos_token_id` = {self.config.eos_token_id} for"""
          ' padding..'    )

     if self.args.label_smoothing == 0:
      SCREAMING_SNAKE_CASE								=			torch.nn.CrossEntropyLoss(ignore_index=self.config.pad_token_id    )
     else:
      # dynamically import label_smoothed_nll_loss
      from utils import label_smoothed_nll_loss

      SCREAMING_SNAKE_CASE								=			label_smoothed_nll_loss

    def UpperCamelCase			(			self :      str							,    snake_case__ :      int    ):

     """simple docstring"""






     if self.optimizer is None:
      SCREAMING_SNAKE_CASE								=			['bias', 'LayerNorm.weight']
      SCREAMING_SNAKE_CASE								=			[
          {
              'params': [p for n, p in self.model.named_parameters() if not any(nd in n for nd in no_decay    )],
              'weight_decay': self.args.weight_decay,
          },
          {
              'params': [p for n, p in self.model.named_parameters() if any(nd in n for nd in no_decay    )],
              'weight_decay': 0.0,
          },
      ]
      SCREAMING_SNAKE_CASE								=			Adafactor if self.args.adafactor else AdamW
      if self.args.adafactor:
       SCREAMING_SNAKE_CASE								=			Adafactor
       SCREAMING_SNAKE_CASE								=			{'scale_parameter': False, 'relative_step': False}
      else:
       SCREAMING_SNAKE_CASE								=			AdamW
       SCREAMING_SNAKE_CASE								=			{
           'betas': (self.args.adam_betaa, self.args.adam_betaa),
           'eps': self.args.adam_epsilon,
       }
      SCREAMING_SNAKE_CASE								=			self.args.learning_rate
      if self.sharded_ddp:
       SCREAMING_SNAKE_CASE								=			OSS(
           params=snake_case__							,    optim=snake_case__							,    **snake_case__							,    )
      else:
       SCREAMING_SNAKE_CASE								=			optimizer_cls(snake_case__							,    **snake_case__    )

     if self.lr_scheduler is None:
      SCREAMING_SNAKE_CASE								=			self._get_lr_scheduler(snake_case__    )
     else:  # ignoring --lr_scheduler
      logger.warning('scheduler is passed to `Seq2SeqTrainer`, `--lr_scheduler` arg is ignored.'    )

    def UpperCamelCase			(			self :      List[Any]							,    snake_case__ :      Optional[Any]    ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE								=			arg_to_scheduler[self.args.lr_scheduler]
     if self.args.lr_scheduler == "constant":
      SCREAMING_SNAKE_CASE								=			schedule_func(self.optimizer    )
     elif self.args.lr_scheduler == "constant_w_warmup":
      SCREAMING_SNAKE_CASE								=			schedule_func(self.optimizer							,    num_warmup_steps=self.args.warmup_steps    )
     else:
      SCREAMING_SNAKE_CASE								=			schedule_func(
          self.optimizer							,    num_warmup_steps=self.args.warmup_steps							,    num_training_steps=snake_case__    )
     return scheduler

    def UpperCamelCase			(			self :      Any    ):

     """simple docstring"""






     if isinstance(self.train_dataset							,    torch.utils.data.IterableDataset    ):
      return None
     elif is_torch_tpu_available():
      return get_tpu_sampler(self.train_dataset    )
     else:
      if self.args.sortish_sampler:
       self.train_dataset.make_sortish_sampler(
           self.args.per_device_train_batch_size							,    distributed=(self.args.parallel_mode == ParallelMode.DISTRIBUTED)							,    )

      return (
          RandomSampler(self.train_dataset    )
          if self.args.local_rank == -1
          else DistributedSampler(self.train_dataset    )
      )

    def UpperCamelCase			(			self :      List[str]							,    snake_case__ :      Tuple							,    snake_case__ :      Union[str, Any]							,    snake_case__ :      Union[str, Any]    ):

     """simple docstring"""






     if self.args.label_smoothing == 0:
      if self.data_args is not None and self.data_args.ignore_pad_token_for_loss:
       # force training to ignore pad token
       SCREAMING_SNAKE_CASE								=			model(**snake_case__							,    use_cache=snake_case__    )[0]
       SCREAMING_SNAKE_CASE								=			self.loss_fn(logits.view(-1							,    logits.shape[-1]    )							,    labels.view(-1    )    )
      else:
       # compute usual loss via models
       SCREAMING_SNAKE_CASE						,	SCREAMING_SNAKE_CASE								=			model(**snake_case__							,    labels=snake_case__							,    use_cache=snake_case__    )[:2]
     else:
      # compute label smoothed loss
      SCREAMING_SNAKE_CASE								=			model(**snake_case__							,    use_cache=snake_case__    )[0]
      SCREAMING_SNAKE_CASE								=			torch.nn.functional.log_softmax(snake_case__							,    dim=-1    )
      SCREAMING_SNAKE_CASE						,	SCREAMING_SNAKE_CASE								=			self.loss_fn(snake_case__							,    snake_case__							,    self.args.label_smoothing							,    ignore_index=self.config.pad_token_id    )
     return loss, logits

    def UpperCamelCase			(			self :      Optional[Any]							,    snake_case__ :      Dict							,    snake_case__ :      Optional[int]    ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE								=			inputs.pop('labels'    )
     SCREAMING_SNAKE_CASE						,	SCREAMING_SNAKE_CASE								=			self._compute_loss(snake_case__							,    snake_case__							,    snake_case__    )
     return loss

    def UpperCamelCase			(			self :      Any							,    snake_case__ :      nn.Module							,    snake_case__ :      Dict[str, Union[torch.Tensor, Any]]							,    snake_case__ :      bool							,    snake_case__ :      Optional[List[str]] = None							,    ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE								=			self._prepare_inputs(snake_case__    )

     SCREAMING_SNAKE_CASE								=			{
         'max_length': self.data_args.val_max_target_length
         if self.data_args is not None
         else self.config.max_length,
         'num_beams': self.data_args.eval_beams if self.data_args is not None else self.config.num_beams,
     }

     if self.args.predict_with_generate and not self.args.prediction_loss_only:
      SCREAMING_SNAKE_CASE								=			self.model.generate(
          inputs['input_ids']							,    attention_mask=inputs['attention_mask']							,    **snake_case__							,    )
      # in case the batch is shorter than max length, the output should be padded
      if generated_tokens.shape[-1] < gen_kwargs["max_length"]:
       SCREAMING_SNAKE_CASE								=			self._pad_tensors_to_max_len(snake_case__							,    gen_kwargs['max_length']    )

     SCREAMING_SNAKE_CASE								=			inputs.pop('labels'    )
     with torch.no_grad():
      # compute loss on predict data
      SCREAMING_SNAKE_CASE						,	SCREAMING_SNAKE_CASE								=			self._compute_loss(snake_case__							,    snake_case__							,    snake_case__    )

     SCREAMING_SNAKE_CASE								=			loss.mean().detach()
     if self.args.prediction_loss_only:
      return (loss, None, None)

     SCREAMING_SNAKE_CASE								=			generated_tokens if self.args.predict_with_generate else logits

     if labels.shape[-1] < gen_kwargs["max_length"]:
      SCREAMING_SNAKE_CASE								=			self._pad_tensors_to_max_len(snake_case__							,    gen_kwargs['max_length']    )

     return (loss, logits, labels)




    def UpperCamelCase			(			self :      List[Any]							,    snake_case__ :      Optional[int]							,    snake_case__ :      str    ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE								=			self.config.pad_token_id if self.config.pad_token_id is not None else self.config.eos_token_id

     if pad_token_id is None:
      raise ValueError(
          'Make sure that either `config.pad_token_id` or `config.eos_token_id` is defined if tensor has to be'
          F""" padded to `max_length`={max_length}"""    )

     SCREAMING_SNAKE_CASE								=			pad_token_id * torch.ones(
         (tensor.shape[0], max_length)							,    dtype=tensor.dtype							,    device=tensor.device    )
     SCREAMING_SNAKE_CASE								=			tensor
     return padded_tensor




def        __lowerCAmelCase    (       _UpperCamelCase		:  int = 10_00	)		->							int:
 '''simple docstring'''


 SCREAMING_SNAKE_CASE								=			2**power
 SCREAMING_SNAKE_CASE								=			str(_UpperCamelCase	)
 SCREAMING_SNAKE_CASE								=			list(_UpperCamelCase	)
 SCREAMING_SNAKE_CASE								=			0

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

 return sum_of_num


if __name__ == "__main__":
      a_    :						List[str]    		=      int(input("Enter the power of 2: ").strip())
      print("2 ^ ", power, " = ", 2**power)
      a_    :						int    		=      solution(power)
      print("Sum of the digits is: ", result)

