
'''simple docstring'''



import argparse
import json

import numpy
import torch

from transformers.models.xlm.tokenization_xlm import VOCAB_FILES_NAMES
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()
def  lowerCAmelCase_						(					SCREAMING_SNAKE_CASE_     ,   SCREAMING_SNAKE_CASE_    )  ->  Optional[int]:




   """simple docstring"""
   # Load checkpoint
   _SCREAMING_SNAKE_CASE  			=					torch.load(SCREAMING_SNAKE_CASE_     ,   map_location="""cpu"""    )

   _SCREAMING_SNAKE_CASE  			=					chkpt["""model"""]

   # We have the base model one level deeper than the original XLM repository
   _SCREAMING_SNAKE_CASE  			=					{}
   for k, v in state_dict.items():
      if "pred_layer" in k:
         _SCREAMING_SNAKE_CASE  			=					v
      else:
         _SCREAMING_SNAKE_CASE  			=					v

   _SCREAMING_SNAKE_CASE  			=					chkpt["""params"""]
   _SCREAMING_SNAKE_CASE  			=					{n: v for n, v in config.items() if not isinstance(SCREAMING_SNAKE_CASE_     ,   (torch.FloatTensor, numpy.ndarray)    )}

   _SCREAMING_SNAKE_CASE  			=					chkpt["""dico_word2id"""]
   _SCREAMING_SNAKE_CASE  			=					{s + """</w>""" if s.find("""@@"""    ) == -1 and i > 13 else s.replace("""@@"""     ,   """"""    ): i for s, i in vocab.items()}

   # Save pytorch-model
   _SCREAMING_SNAKE_CASE  			=					pytorch_dump_folder_path + """/""" + WEIGHTS_NAME
   _SCREAMING_SNAKE_CASE  			=					pytorch_dump_folder_path + """/""" + CONFIG_NAME
   _SCREAMING_SNAKE_CASE  			=					pytorch_dump_folder_path + """/""" + VOCAB_FILES_NAMES["""vocab_file"""]

   print(F"Save PyTorch model to {pytorch_weights_dump_path}"    )
   torch.save(SCREAMING_SNAKE_CASE_     ,   SCREAMING_SNAKE_CASE_    )

   print(F"Save configuration file to {pytorch_config_dump_path}"    )
   with open(SCREAMING_SNAKE_CASE_     ,   """w"""     ,   encoding="""utf-8"""    ) as f:
      f.write(json.dumps(SCREAMING_SNAKE_CASE_     ,   indent=2    ) + """\n"""    )

   print(F"Save vocab file to {pytorch_config_dump_path}"    )
   with open(SCREAMING_SNAKE_CASE_     ,   """w"""     ,   encoding="""utf-8"""    ) as f:
      f.write(json.dumps(SCREAMING_SNAKE_CASE_     ,   indent=2    ) + """\n"""    )


if __name__ == "__main__":
     UpperCamelCase__   :		List[Any]											=	argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         "--xlm_checkpoint_path", default=None, type=str, required=True, help="Path the official PyTorch dump."
     )
     parser.add_argument(
         "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
     )
     UpperCamelCase__   :		Optional[Any]											=	parser.parse_args()
     convert_xlm_checkpoint_to_pytorch(args.xlm_checkpoint_path, args.pytorch_dump_folder_path)









'''simple docstring'''




from io import BytesIO
from typing import List, Union

import requests

from ..utils import add_end_docstrings, is_decord_available, is_torch_available, logging, requires_backends
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_decord_available():
  import numpy as np
  from decord import VideoReader


if is_torch_available():
  from ..models.auto.modeling_auto import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING

_a					:			List[Any]							=    logging.get_logger(__name__)



@add_end_docstrings(a			)
class 							lowercase_						(		a			):

  '''simple docstring'''





  def __init__(  self ,			*a_ ,			**a_  )				->					str:


    """simple docstring"""
    super().__init__(*a_ ,			**a_  )
    requires_backends(self ,			'decord'  )
    self.check_model_type(a_  )
  def     snake_case_      (  self ,			a_=None ,			a_=None ,			a_=None  )				->					int:


    """simple docstring"""
    UpperCAmelCase    				=						{}
    if frame_sampling_rate is not None:
      UpperCAmelCase    				=						frame_sampling_rate
    if num_frames is not None:
      UpperCAmelCase    				=						num_frames

    UpperCAmelCase    				=						{}
    if top_k is not None:
      UpperCAmelCase    				=						top_k
    return preprocess_params, {}, postprocess_params
  def __call__(  self ,			a_ ,			**a_  )				->					Union[str, Any]:


    """simple docstring"""
    return super().__call__(a_ ,			**a_  )
  def     snake_case_      (  self ,			a_ ,			a_=None ,			a_=1  )				->					Tuple:


    """simple docstring"""
    if num_frames is None:
      UpperCAmelCase    				=						self.model.config.num_frames

    if video.startswith('http://'  ) or video.startswith('https://'  ):
      UpperCAmelCase    				=						BytesIO(requests.get(a_  ).content  )

    UpperCAmelCase    				=						VideoReader(a_  )
    videoreader.seek(0  )

    UpperCAmelCase    				=						0
    UpperCAmelCase    				=						num_frames * frame_sampling_rate - 1
    UpperCAmelCase    				=						np.linspace(a_ ,			a_ ,			num=a_ ,			dtype=np.intaa  )

    UpperCAmelCase    				=						videoreader.get_batch(a_  ).asnumpy()
    UpperCAmelCase    				=						list(a_  )

    UpperCAmelCase    				=						self.image_processor(a_ ,			return_tensors=self.framework  )
    return model_inputs
  def     snake_case_      (  self ,			a_  )				->					Union[str, Any]:


    """simple docstring"""
    UpperCAmelCase    				=						self.model(**a_  )
    return model_outputs





  def     snake_case_      (  self ,			a_ ,			a_=5  )				->					Union[str, Any]:


    """simple docstring"""
    if top_k > self.model.config.num_labels:
      UpperCAmelCase    				=						self.model.config.num_labels

    if self.framework == "pt":
      UpperCAmelCase    				=						model_outputs.logits.softmax(-1  )[0]
      UpperCAmelCase				,   UpperCAmelCase    				=						probs.topk(a_  )
    else:
      raise ValueError(F'''Unsupported framework: {self.framework}'''  )

    UpperCAmelCase    				=						scores.tolist()
    UpperCAmelCase    				=						ids.tolist()
    return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(a_ ,			a_  )]


