


'''simple docstring'''

import argparse
import logging
import os
import sys
import time

import tensorflow as tf
from datasets import load_dataset
from tqdm import tqdm

from transformers import AutoTokenizer, TFAutoModelForSequenceClassification
from transformers.utils import is_sagemaker_dp_enabled


if os.environ.get('SDP_ENABLED') or is_sagemaker_dp_enabled():
 lowerCamelCase							:       Any  						=     True
 lowerCamelCase							:       Optional[Any]  						=     'p3dn.24xlarge'
 import smdistributed.dataparallel.tensorflow as sdp
else:
 lowerCamelCase							:       List[Any]  						=     False

def _SCREAMING_SNAKE_CASE				(A  ,			A  ,			A  ,			A  ,			A  ,			A  ,			A=None	)	->	int:






       """simple docstring"""







       lowercase__				      =			tqdm(A	)
       for i, batch in enumerate(A	):
              with tf.GradientTape() as tape:
                     lowercase__      ,lowercase__				      =			batch
                     lowercase__				      =			model(A	)
                     lowercase__				      =			loss(A  ,			outputs.logits	)

              if SDP_ENABLED:
                     lowercase__				      =			sdp.DistributedGradientTape(A  ,			sparse_as_dense=A	)

              lowercase__				      =			tape.gradient(A  ,			model.trainable_variables	)
              opt.apply_gradients(zip(A  ,			model.trainable_variables	)	)

              pbar.set_description(f"Loss: {loss_value:.4f}"	)

              if SDP_ENABLED and i == 0:
                     sdp.broadcast_variables(model.variables  ,			root_rank=0	)
                     sdp.broadcast_variables(opt.variables()  ,			root_rank=0	)

              if max_steps and i >= max_steps:
                     break

       lowercase__				      =			{'''loss''': loss_value.numpy()}
       return train_results

def _SCREAMING_SNAKE_CASE				(A  ,			A  ,			A	)	->	Optional[Any]:






       """simple docstring"""







       lowercase__      ,lowercase__				      =			load_dataset('''imdb'''  ,			split=['''train''', '''test''']	)

       # Preprocess train dataset
       lowercase__				      =			train_dataset.map(
           lambda A	: tokenizer(e['''text''']  ,			truncation=A  ,			padding='''max_length'''	)  ,			batched=A	)
       train_dataset.set_format(type='''tensorflow'''  ,			columns=['''input_ids''', '''attention_mask''', '''label''']	)

       lowercase__				      =			{
           x: train_dataset[x].to_tensor(default_value=0  ,			shape=[None, tokenizer.model_max_length]	)
           for x in ['''input_ids''', '''attention_mask''']
       }
       lowercase__				      =			tf.data.Dataset.from_tensor_slices((train_features, train_dataset['''label'''])	)

       # Preprocess test dataset
       lowercase__				      =			test_dataset.map(
           lambda A	: tokenizer(e['''text''']  ,			truncation=A  ,			padding='''max_length'''	)  ,			batched=A	)
       test_dataset.set_format(type='''tensorflow'''  ,			columns=['''input_ids''', '''attention_mask''', '''label''']	)

       lowercase__				      =			{
           x: test_dataset[x].to_tensor(default_value=0  ,			shape=[None, tokenizer.model_max_length]	)
           for x in ['''input_ids''', '''attention_mask''']
       }
       lowercase__				      =			tf.data.Dataset.from_tensor_slices((test_features, test_dataset['''label'''])	)

       if SDP_ENABLED:
              lowercase__				      =			tf_train_dataset.shard(sdp.size()  ,			sdp.rank()	)
              lowercase__				      =			tf_test_dataset.shard(sdp.size()  ,			sdp.rank()	)
       lowercase__				      =			tf_train_dataset.batch(A  ,			drop_remainder=A	)
       lowercase__				      =			tf_test_dataset.batch(A  ,			drop_remainder=A	)

       return tf_train_dataset, tf_test_dataset


if __name__ == "__main__":
 lowerCamelCase							:       Union[str, Any]  						=     argparse.ArgumentParser()

 # Hyperparameters sent by the client are passed as command-line arguments to the script.
 parser.add_argument('--epochs', type=int, default=3)
 parser.add_argument('--per_device_train_batch_size', type=int, default=16)
 parser.add_argument('--per_device_eval_batch_size', type=int, default=8)
 parser.add_argument('--model_name_or_path', type=str)
 parser.add_argument('--learning_rate', type=str, default=5e-5)
 parser.add_argument('--do_train', type=bool, default=True)
 parser.add_argument('--do_eval', type=bool, default=True)
 parser.add_argument('--output_dir', type=str)
 parser.add_argument('--max_steps', type=int, default=None)

 # Data, model, and output directories
 parser.add_argument('--output_data_dir', type=str, default=os.environ['SM_OUTPUT_DATA_DIR'])
 parser.add_argument('--model_dir', type=str, default=os.environ['SM_MODEL_DIR'])
 parser.add_argument('--n_gpus', type=str, default=os.environ['SM_NUM_GPUS'])

 lowerCamelCase						,  lowerCamelCase							:       Tuple  						=     parser.parse_known_args()

 # Set up logging
 lowerCamelCase							:       Dict  						=     logging.getLogger(__name__)

 logging.basicConfig(
     level=logging.getLevelName('INFO'),
     handlers=[logging.StreamHandler(sys.stdout)],
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
 )

 if SDP_ENABLED:
  sdp.init()

  lowerCamelCase							:       List[Any]  						=     tf.config.experimental.list_physical_devices('GPU')
  for gpu in gpus:
   tf.config.experimental.set_memory_growth(gpu, True)
  if gpus:
   tf.config.experimental.set_visible_devices(gpus[sdp.local_rank()], 'GPU')

    # Load model and tokenizer
 lowerCamelCase							:       Any  						=     TFAutoModelForSequenceClassification.from_pretrained(args.model_name_or_path)
 lowerCamelCase							:       List[Any]  						=     AutoTokenizer.from_pretrained(args.model_name_or_path)

 # get datasets
 lowerCamelCase						,  lowerCamelCase							:       Optional[Any]  						=     get_datasets(
     tokenizer=tokenizer,
     train_batch_size=args.per_device_train_batch_size,
     eval_batch_size=args.per_device_eval_batch_size,
 )

 # fine optimizer and loss
 lowerCamelCase							:       List[str]  						=     tf.keras.optimizers.Adam(learning_rate=args.learning_rate)
 lowerCamelCase							:       Any  						=     tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
 lowerCamelCase							:       Optional[Any]  						=     [tf.keras.metrics.SparseCategoricalAccuracy()]
 model.compile(optimizer=optimizer, loss=loss, metrics=metrics)

 # Training
 if args.do_train:
  # train_results = model.fit(tf_train_dataset, epochs=args.epochs, batch_size=args.train_batch_size)
  lowerCamelCase							:       Optional[int]  						=     time.time()
  lowerCamelCase							:       Union[str, Any]  						=     fit(
      model,
      loss,
      optimizer,
      tf_train_dataset,
      args.epochs,
      args.per_device_train_batch_size,
      max_steps=args.max_steps,
  )
  lowerCamelCase							:       List[str]  						=     time.time() - start_train_time
  logger.info('*** Train ***')
  logger.info(f"""train_runtime = {end_train_time}""")

  lowerCamelCase							:       str  						=     os.path.join(args.output_dir, 'train_results.txt')

  if not SDP_ENABLED or sdp.rank() == 0:
   with open(output_eval_file, 'w') as writer:
    logger.info('***** Train results *****')
    logger.info(train_results)
    for key, value in train_results.items():
     logger.info(f"""  {key} = {value}""")
     writer.write(f"""{key} = {value}\n""")

    # Evaluation
 if args.do_eval and (not SDP_ENABLED or sdp.rank() == 0):
  lowerCamelCase							:       Optional[Any]  						=     model.evaluate(tf_test_dataset, batch_size=args.per_device_eval_batch_size, return_dict=True)
  logger.info('*** Evaluate ***')

  lowerCamelCase							:       Optional[int]  						=     os.path.join(args.output_dir, 'eval_results.txt')

  with open(output_eval_file, 'w') as writer:
   logger.info('***** Eval results *****')
   logger.info(result)
   for key, value in result.items():
    logger.info(f"""  {key} = {value}""")
    writer.write(f"""{key} = {value}\n""")

    # Save result
 if SDP_ENABLED:
  if sdp.rank() == 0:
   model.save_pretrained(args.output_dir)
   tokenizer.save_pretrained(args.output_dir)
 else:
  model.save_pretrained(args.output_dir)
  tokenizer.save_pretrained(args.output_dir)








'''simple docstring'''

import argparse
import json
import re
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    MobileNetVaConfig,
    MobileNetVaForImageClassification,
    MobileNetVaForSemanticSegmentation,
    MobileNetVaImageProcessor,
    load_tf_weights_in_mobilenet_va,
)
from transformers.utils import logging


logging.set_verbosity_info()
lowerCamelCase							:       Dict  						=     logging.get_logger(__name__)

def _SCREAMING_SNAKE_CASE				(A	)	->	Optional[Any]:






       """simple docstring"""







       lowercase__				      =			MobileNetVaConfig(layer_norm_eps=0.001	)

       if "quant" in model_name:
              raise ValueError('''Quantized models are not supported.'''	)

       lowercase__				      =			re.match(R'''^.*mobilenet_v2_([^_]*)_([^_]*)$'''  ,			A	)
       if matches:
              lowercase__				      =			float(matches[1]	)
              lowercase__				      =			int(matches[2]	)

       if model_name.startswith('''deeplabv3_'''	):
              lowercase__				      =			8
              lowercase__				      =			21
              lowercase__				      =			'''pascal-voc-id2label.json'''
       else:
              # The TensorFlow version of MobileNetV2 predicts 1001 classes instead
              # of the usual 1000. The first class (index 0) is "background".
              lowercase__				      =			1_001
              lowercase__				      =			'''imagenet-1k-id2label.json'''

       lowercase__				      =			'''huggingface/label-files'''
       lowercase__				      =			json.load(open(hf_hub_download(A  ,			A  ,			repo_type='''dataset'''	)  ,			'''r'''	)	)

       if config.num_labels == 1_001:
              lowercase__				      =			{int(A	) + 1: v for k, v in idalabel.items()}
              lowercase__				      =			'''background'''
       else:
              lowercase__				      =			{int(A	): v for k, v in idalabel.items()}

       lowercase__				      =			idalabel
       lowercase__				      =			{v: k for k, v in idalabel.items()}

       return config

def _SCREAMING_SNAKE_CASE				()	->	List[Any]:






       """simple docstring"""







       lowercase__				      =			'''http://images.cocodataset.org/val2017/000000039769.jpg'''
       lowercase__				      =			Image.open(requests.get(A  ,			stream=A	).raw	)
       return im

@torch.no_grad()
def _SCREAMING_SNAKE_CASE				(A  ,			A  ,			A  ,			A=False	)	->	Any:






       """simple docstring"""







       lowercase__				      =			get_mobilenet_va_config(A	)

       # Load 🤗 model
       if model_name.startswith('''deeplabv3_'''	):
              lowercase__				      =			MobileNetVaForSemanticSegmentation(A	).eval()
       else:
              lowercase__				      =			MobileNetVaForImageClassification(A	).eval()

       # Load weights from TensorFlow checkpoint
       load_tf_weights_in_mobilenet_va(A  ,			A  ,			A	)

       # Check outputs on an image, prepared by MobileNetV2ImageProcessor
       lowercase__				      =			MobileNetVaImageProcessor(
           crop_size={'''width''': config.image_size, '''height''': config.image_size}  ,			size={'''shortest_edge''': config.image_size + 32}  ,			)
       lowercase__				      =			image_processor(images=prepare_img()  ,			return_tensors='''pt'''	)
       lowercase__				      =			model(**A	)
       lowercase__				      =			outputs.logits

       if model_name.startswith('''deeplabv3_'''	):
              assert logits.shape == (1, 21, 65, 65)

              if model_name == "deeplabv3_mobilenet_v2_1.0_513":
                     lowercase__				      =			torch.tensor(
                         [
                             [[17.5_790, 17.7_581, 18.3_355], [18.3_257, 18.4_230, 18.8_973], [18.6_169, 18.8_650, 19.2_187]],
                             [[-2.1_595, -2.0_977, -2.3_741], [-2.4_226, -2.3_028, -2.6_835], [-2.7_819, -2.5_991, -2.7_706]],
                             [[4.2_058, 4.8_317, 4.7_638], [4.4_136, 5.0_361, 4.9_383], [4.5_028, 4.9_644, 4.8_734]],
                         ]	)

              else:
                     raise ValueError(f"Unknown model name: {model_name}"	)

              assert torch.allclose(logits[0, :3, :3, :3]  ,			A  ,			atol=1E-4	)
       else:
              assert logits.shape == (1, 1_001)

              if model_name == "mobilenet_v2_1.4_224":
                     lowercase__				      =			torch.tensor([0.0_181, -1.0_015, 0.4_688]	)
              elif model_name == "mobilenet_v2_1.0_224":
                     lowercase__				      =			torch.tensor([0.2_445, -1.1_993, 0.1_905]	)
              elif model_name == "mobilenet_v2_0.75_160":
                     lowercase__				      =			torch.tensor([0.2_482, 0.4_136, 0.6_669]	)
              elif model_name == "mobilenet_v2_0.35_96":
                     lowercase__				      =			torch.tensor([0.1_451, -0.4_624, 0.7_192]	)
              else:
                     lowercase__				      =			None

              if expected_logits is not None:
                     assert torch.allclose(logits[0, :3]  ,			A  ,			atol=1E-4	)

       Path(A	).mkdir(exist_ok=A	)
       print(f"Saving model {model_name} to {pytorch_dump_folder_path}"	)
       model.save_pretrained(A	)
       print(f"Saving image processor to {pytorch_dump_folder_path}"	)
       image_processor.save_pretrained(A	)

       if push_to_hub:
              print('''Pushing to the hub...'''	)
              lowercase__				      =			'''google/''' + model_name
              image_processor.push_to_hub(A	)
              model.push_to_hub(A	)


if __name__ == "__main__":
 lowerCamelCase							:       int  						=     argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     '--model_name',
     default='mobilenet_v2_1.0_224',
     type=str,
     help='Name of the MobileNetV2 model you\'d like to convert. Should in the form \'mobilenet_v2_<depth>_<size>\'.',
 )
 parser.add_argument(
     '--checkpoint_path', required=True, type=str, help='Path to the original TensorFlow checkpoint (.ckpt file).'
 )
 parser.add_argument(
     '--pytorch_dump_folder_path', required=True, type=str, help='Path to the output PyTorch model directory.'
 )
 parser.add_argument(
     '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
 )

 lowerCamelCase							:       int  						=     parser.parse_args()
 convert_movilevit_checkpoint(
     args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
 )




