code: import argparse
  import json
  import os
  
  import requests
  import torch
  from huggingface_hub import hf_hub_download
  from PIL import Image
  
  from transformers import ConvNextImageProcessor, ConvNextVaConfig, ConvNextVaForImageClassification
  from transformers.image_utils import PILImageResampling
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  a     :			Dict					    =						logging.get_logger(__name__)
  def 		snake_case__  (		lowercase				):
     lowerCAmelCase_:       Optional[Any]         =  ConvNextVaConfig()
  
     if "atto" in checkpoint_url:
        lowerCAmelCase_:       int         =  [2, 2, 6, 2]
        lowerCAmelCase_:       int         =  [40, 80, 160, 320]
     if "femto" in checkpoint_url:
        lowerCAmelCase_:       Dict         =  [2, 2, 6, 2]
        lowerCAmelCase_:       Optional[Any]         =  [48, 96, 192, 384]
     if "pico" in checkpoint_url:
        lowerCAmelCase_:       Any         =  [2, 2, 6, 2]
        lowerCAmelCase_:       List[Any]         =  [64, 128, 256, 512]
     if "nano" in checkpoint_url:
        lowerCAmelCase_:       Tuple         =  [2, 2, 8, 2]
        lowerCAmelCase_:       List[Any]         =  [80, 160, 320, 640]
     if "tiny" in checkpoint_url:
        lowerCAmelCase_:       Tuple         =  [3, 3, 9, 3]
        lowerCAmelCase_:       Union[str, Any]         =  [96, 192, 384, 768]
     if "base" in checkpoint_url:
        lowerCAmelCase_:       Dict         =  [3, 3, 27, 3]
        lowerCAmelCase_:       int         =  [128, 256, 512, 1024]
     if "large" in checkpoint_url:
        lowerCAmelCase_:       Optional[Any]         =  [3, 3, 27, 3]
        lowerCAmelCase_:       Optional[int]         =  [192, 384, 768, 1536]
     if "huge" in checkpoint_url:
        lowerCAmelCase_:       int         =  [3, 3, 27, 3]
        lowerCAmelCase_:       Tuple         =  [352, 704, 1408, 2816]
  
     lowerCAmelCase_:       List[str]         =  1000
     lowerCAmelCase_:       List[Any]         =  "imagenet-1k-id2label.json"
     lowerCAmelCase_:       Dict         =  (1, 1000)
  
     lowerCAmelCase_:       List[Any]         =  "huggingface/label-files"
     lowerCAmelCase_:       str         =  num_labels
     lowerCAmelCase_:       List[str]         =  json.load(open(hf_hub_download(lowercase       ,							lowercase       ,							repo_type="dataset"				)       ,							"r"				)				)
     lowerCAmelCase_:       Tuple         =  {int(lowercase				): v for k, v in idalabel.items()}
  
     lowerCAmelCase_:       Optional[Any]         =  idalabel
     lowerCAmelCase_:       int         =  {v: k for k, v in idalabel.items()}
     lowerCAmelCase_:       Dict         =  hidden_sizes
     lowerCAmelCase_:       Optional[Any]         =  depths
  
     return config, expected_shape
  def 		snake_case__  (		lowercase				):
     if "downsample_layers.0.0" in name:
        lowerCAmelCase_:       Union[str, Any]         =  name.replace("downsample_layers.0.0"       ,							"embeddings.patch_embeddings"				)
     if "downsample_layers.0.1" in name:
        lowerCAmelCase_:       str         =  name.replace("downsample_layers.0.1"       ,							"embeddings.norm"				)  # we rename to layernorm later on
     if "downsample_layers.1.0" in name:
        lowerCAmelCase_:       Dict         =  name.replace("downsample_layers.1.0"       ,							"stages.1.downsampling_layer.0"				)
     if "downsample_layers.1.1" in name:
        lowerCAmelCase_:       List[Any]         =  name.replace("downsample_layers.1.1"       ,							"stages.1.downsampling_layer.1"				)
     if "downsample_layers.2.0" in name:
        lowerCAmelCase_:       Optional[int]         =  name.replace("downsample_layers.2.0"       ,							"stages.2.downsampling_layer.0"				)
     if "downsample_layers.2.1" in name:
        lowerCAmelCase_:       Optional[int]         =  name.replace("downsample_layers.2.1"       ,							"stages.2.downsampling_layer.1"				)
     if "downsample_layers.3.0" in name:
        lowerCAmelCase_:       List[Any]         =  name.replace("downsample_layers.3.0"       ,							"stages.3.downsampling_layer.0"				)
     if "downsample_layers.3.1" in name:
        lowerCAmelCase_:       List[Any]         =  name.replace("downsample_layers.3.1"       ,							"stages.3.downsampling_layer.1"				)
     if "stages" in name and "downsampling_layer" not in name:
        # stages.0.0. for instance should be renamed to stages.0.layers.0.
        lowerCAmelCase_:       int         =  name[: len("stages.0"				)] + ".layers" + name[len("stages.0"				) :]
     if "gamma" in name:
        lowerCAmelCase_:       Optional[Any]         =  name.replace("gamma"       ,							"weight"				)
     if "beta" in name:
        lowerCAmelCase_:       Dict         =  name.replace("beta"       ,							"bias"				)
     if "stages" in name:
        lowerCAmelCase_:       Optional[Any]         =  name.replace("stages"       ,							"encoder.stages"				)
     if "norm" in name:
        lowerCAmelCase_:       Tuple         =  name.replace("norm"       ,							"layernorm"				)
     if "head" in name:
        lowerCAmelCase_:       Dict         =  name.replace("head"       ,							"classifier"				)
  
     return name
  def 		snake_case__  (		):
     lowerCAmelCase_:       List[str]         =  "http://images.cocodataset.org/val2017/000000039769.jpg"
     lowerCAmelCase_:       Dict         =  Image.open(requests.get(lowercase       ,							stream=lowercase				).raw				)
     return im
  def 		snake_case__  (		lowercase				):
     if "224" in checkpoint_url:
        lowerCAmelCase_:       Optional[int]         =  224
        lowerCAmelCase_:       str         =  224 / 256
     elif "384" in checkpoint_url:
        lowerCAmelCase_:       Tuple         =  384
        lowerCAmelCase_:       Tuple         =  None
     else:
        lowerCAmelCase_:       Optional[Any]         =  512
        lowerCAmelCase_:       int         =  None
  
     return ConvNextImageProcessor(
         size=lowercase       ,							crop_pct=lowercase       ,							image_mean=[0.485, 0.456, 0.406]       ,							image_std=[0.229, 0.224, 0.225]       ,							resample=PILImageResampling.BICUBIC       ,							)
  @torch.no_grad()
  def 		snake_case__  (		lowercase       ,							lowercase       ,							lowercase       ,							lowercase				):
     print("Downloading original model from checkpoint..."				)
     # define ConvNeXTV2 configuration based on URL
     lowerCAmelCase_     ,  lowerCAmelCase_:       List[Any]         =  get_convnextva_config(lowercase				)
     # load original state_dict from URL
     lowerCAmelCase_:       Optional[int]         =  torch.hub.load_state_dict_from_url(lowercase				)["model"]
  
     print("Converting model parameters..."				)
     # rename keys
     for key in state_dict.copy().keys():
        lowerCAmelCase_:       List[Any]         =  state_dict.pop(lowercase				)
        lowerCAmelCase_:       Optional[int]         =  val
     # add prefix to all keys expect classifier head
     for key in state_dict.copy().keys():
        lowerCAmelCase_:       Optional[Any]         =  state_dict.pop(lowercase				)
        if not key.startswith("classifier"				):
           lowerCAmelCase_:       str         =  "convnextv2." + key
        lowerCAmelCase_:       List[str]         =  val
  
     # load HuggingFace model
     lowerCAmelCase_:       List[str]         =  ConvNextVaForImageClassification(lowercase				)
     model.load_state_dict(lowercase				)
     model.eval()
  
     # Check outputs on an image, prepared by ConvNextImageProcessor
     lowerCAmelCase_:       Optional[Any]         =  convert_preprocessor(lowercase				)
     lowerCAmelCase_:       Any         =  preprocessor(images=prepare_img()       ,							return_tensors="pt"				)
     lowerCAmelCase_:       Dict         =  model(**lowercase				).logits
  
     # note: the logits below were obtained without center cropping
     if checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt":
        lowerCAmelCase_:       Dict         =  torch.tensor([-0.3930, 0.1747, -0.5246, 0.4177, 0.4295]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_femto_1k_224_ema.pt":
        lowerCAmelCase_:       List[Any]         =  torch.tensor([-0.1727, -0.5341, -0.7818, -0.4745, -0.6566]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_pico_1k_224_ema.pt":
        lowerCAmelCase_:       int         =  torch.tensor([-0.0333, 0.1563, -0.9137, 0.1054, 0.0381]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_nano_1k_224_ema.pt":
        lowerCAmelCase_:       str         =  torch.tensor([-0.1744, -0.1555, -0.0713, 0.0950, -0.1431]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_tiny_1k_224_ema.pt":
        lowerCAmelCase_:       Optional[int]         =  torch.tensor([0.9996, 0.1966, -0.4386, -0.3472, 0.6661]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_base_1k_224_ema.pt":
        lowerCAmelCase_:       Dict         =  torch.tensor([-0.2553, -0.6708, -0.1359, 0.2518, -0.2488]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_large_1k_224_ema.pt":
        lowerCAmelCase_:       Union[str, Any]         =  torch.tensor([-0.0673, -0.5627, -0.3753, -0.2722, 0.0178]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_huge_1k_224_ema.pt":
        lowerCAmelCase_:       List[Any]         =  torch.tensor([-0.6377, -0.7458, -0.2150, 0.1184, -0.0597]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_224_ema.pt":
        lowerCAmelCase_:       Union[str, Any]         =  torch.tensor([1.0799, 0.2322, -0.8860, 1.0219, 0.6231]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_384_ema.pt":
        lowerCAmelCase_:       str         =  torch.tensor([0.3766, 0.4917, -1.1426, 0.9942, 0.6024]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_224_ema.pt":
        lowerCAmelCase_:       Optional[Any]         =  torch.tensor([0.4220, -0.6919, -0.4317, -0.2881, -0.6609]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_384_ema.pt":
        lowerCAmelCase_:       List[Any]         =  torch.tensor([0.1082, -0.8286, -0.5095, 0.4681, -0.8085]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_224_ema.pt":
        lowerCAmelCase_:       List[str]         =  torch.tensor([-0.2419, -0.6221, 0.2176, -0.0980, -0.7527]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_384_ema.pt":
        lowerCAmelCase_:       Tuple         =  torch.tensor([0.0391, -0.4371, 0.3786, 0.1251, -0.2784]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_224_ema.pt":
        lowerCAmelCase_:       List[Any]         =  torch.tensor([-0.0504, 0.5636, -0.1729, -0.6507, -0.3949]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_384_ema.pt":
        lowerCAmelCase_:       str         =  torch.tensor([0.3560, 0.9486, 0.3149, -0.2667, -0.5138]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_384_ema.pt":
        lowerCAmelCase_:       int         =  torch.tensor([-0.2469, -0.4550, -0.5853, -0.0810, 0.0309]				)
     elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_512_ema.pt":
        lowerCAmelCase_:       Union[str, Any]         =  torch.tensor([-0.3090, 0.0802, -0.0682, -0.1979, -0.2826]				)
     else:
        raise ValueError(F'''Unknown URL: {checkpoint_url}'''				)
  
     assert torch.allclose(logits[0, :5]       ,							lowercase       ,							atol=1E-3				)
     assert logits.shape == expected_shape
     print("Model outputs match the original results!"				)
  
     if save_model:
        print("Saving model to local..."				)
        # Create folder to save model
        if not os.path.isdir(lowercase				):
           os.mkdir(lowercase				)
  
        model.save_pretrained(lowercase				)
        preprocessor.save_pretrained(lowercase				)
  
     lowerCAmelCase_:       Optional[Any]         =  "convnextv2"
     if "atto" in checkpoint_url:
        model_name += "-atto"
     if "femto" in checkpoint_url:
        model_name += "-femto"
     if "pico" in checkpoint_url:
        model_name += "-pico"
     if "nano" in checkpoint_url:
        model_name += "-nano"
     elif "tiny" in checkpoint_url:
        model_name += "-tiny"
     elif "base" in checkpoint_url:
        model_name += "-base"
     elif "large" in checkpoint_url:
        model_name += "-large"
     elif "huge" in checkpoint_url:
        model_name += "-huge"
     if "22k" in checkpoint_url and "1k" not in checkpoint_url:
        model_name += "-22k"
     elif "22k" in checkpoint_url and "1k" in checkpoint_url:
        model_name += "-22k-1k"
     elif "1k" in checkpoint_url:
        model_name += "-1k"
     if "224" in checkpoint_url:
        model_name += "-224"
     elif "384" in checkpoint_url:
        model_name += "-384"
     elif "512" in checkpoint_url:
        model_name += "-512"
  
     if push_to_hub:
        print(F'''Pushing {model_name} to the hub...'''				)
        model.push_to_hub(lowercase				)
        preprocessor.push_to_hub(lowercase				)
  
  
  if __name__ == "__main__":
   a     :			List[str]					    =						argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       """--checkpoint_url""",
       default="""https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt""",
       type=str,
       help="""URL of the original ConvNeXTV2 checkpoint you'd like to convert.""",
   )
   parser.add_argument(
       """--pytorch_dump_folder_path""",
       default="""model""",
       type=str,
       help="""Path to the output PyTorch model directory.""",
   )
   parser.add_argument("""--save_model""", action="""store_true""", help="""Save model to local""")
   parser.add_argument("""--push_to_hub""", action="""store_true""", help="""Push model and image preprocessor to the hub""")
  
   a     :			Tuple					    =						parser.parse_args()
   convert_convnextva_checkpoint(
       args.checkpoint_url, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub
   )
style_context: from typing import TYPE_CHECKING
  
  from ..utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available
  
  
  a     :			Optional[Any]					    =						{
      """configuration_utils""": ["""GenerationConfig"""],
      """streamers""": ["""TextIteratorStreamer""", """TextStreamer"""],
  }
  
  try:
   if not is_torch_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   a     :			Union[str, Any]					    =						[
       """Constraint""",
       """ConstraintListState""",
       """DisjunctiveConstraint""",
       """PhrasalConstraint""",
   ]
   a     :			Optional[int]					    =						[
       """BeamHypotheses""",
       """BeamScorer""",
       """BeamSearchScorer""",
       """ConstrainedBeamSearchScorer""",
   ]
   a     :			Any					    =						[
       """EpsilonLogitsWarper""",
       """EtaLogitsWarper""",
       """ForcedBOSTokenLogitsProcessor""",
       """ForcedEOSTokenLogitsProcessor""",
       """HammingDiversityLogitsProcessor""",
       """InfNanRemoveLogitsProcessor""",
       """LogitsProcessor""",
       """LogitsProcessorList""",
       """LogitsWarper""",
       """MinLengthLogitsProcessor""",
       """MinNewTokensLengthLogitsProcessor""",
       """NoBadWordsLogitsProcessor""",
       """NoRepeatNGramLogitsProcessor""",
       """PrefixConstrainedLogitsProcessor""",
       """RepetitionPenaltyLogitsProcessor""",
       """SequenceBiasLogitsProcessor""",
       """EncoderRepetitionPenaltyLogitsProcessor""",
       """TemperatureLogitsWarper""",
       """TopKLogitsWarper""",
       """TopPLogitsWarper""",
       """TypicalLogitsWarper""",
       """EncoderNoRepeatNGramLogitsProcessor""",
       """ExponentialDecayLengthPenalty""",
       """LogitNormalization""",
   ]
   a     :			int					    =						[
       """MaxNewTokensCriteria""",
       """MaxLengthCriteria""",
       """MaxTimeCriteria""",
       """StoppingCriteria""",
       """StoppingCriteriaList""",
       """validate_stopping_criteria""",
   ]
   a     :			Dict					    =						[
       """GenerationMixin""",
       """top_k_top_p_filtering""",
       """GreedySearchEncoderDecoderOutput""",
       """GreedySearchDecoderOnlyOutput""",
       """SampleEncoderDecoderOutput""",
       """SampleDecoderOnlyOutput""",
       """BeamSearchEncoderDecoderOutput""",
       """BeamSearchDecoderOnlyOutput""",
       """BeamSampleEncoderDecoderOutput""",
       """BeamSampleDecoderOnlyOutput""",
       """ContrastiveSearchEncoderDecoderOutput""",
       """ContrastiveSearchDecoderOnlyOutput""",
   ]
  
  try:
   if not is_tf_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   a     :			Optional[Any]					    =						[
       """TFForcedBOSTokenLogitsProcessor""",
       """TFForcedEOSTokenLogitsProcessor""",
       """TFLogitsProcessor""",
       """TFLogitsProcessorList""",
       """TFLogitsWarper""",
       """TFMinLengthLogitsProcessor""",
       """TFNoBadWordsLogitsProcessor""",
       """TFNoRepeatNGramLogitsProcessor""",
       """TFRepetitionPenaltyLogitsProcessor""",
       """TFTemperatureLogitsWarper""",
       """TFTopKLogitsWarper""",
       """TFTopPLogitsWarper""",
       """TFForceTokensLogitsProcessor""",
       """TFSuppressTokensAtBeginLogitsProcessor""",
       """TFSuppressTokensLogitsProcessor""",
   ]
   a     :			Any					    =						[
       """TFGenerationMixin""",
       """tf_top_k_top_p_filtering""",
       """TFGreedySearchDecoderOnlyOutput""",
       """TFGreedySearchEncoderDecoderOutput""",
       """TFSampleEncoderDecoderOutput""",
       """TFSampleDecoderOnlyOutput""",
       """TFBeamSearchEncoderDecoderOutput""",
       """TFBeamSearchDecoderOnlyOutput""",
       """TFBeamSampleEncoderDecoderOutput""",
       """TFBeamSampleDecoderOnlyOutput""",
       """TFContrastiveSearchEncoderDecoderOutput""",
       """TFContrastiveSearchDecoderOnlyOutput""",
   ]
  
  try:
   if not is_flax_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   a     :			Union[str, Any]					    =						[
       """FlaxForcedBOSTokenLogitsProcessor""",
       """FlaxForcedEOSTokenLogitsProcessor""",
       """FlaxLogitsProcessor""",
       """FlaxLogitsProcessorList""",
       """FlaxLogitsWarper""",
       """FlaxMinLengthLogitsProcessor""",
       """FlaxTemperatureLogitsWarper""",
       """FlaxTopKLogitsWarper""",
       """FlaxTopPLogitsWarper""",
   ]
   a     :			Dict					    =						[
       """FlaxGenerationMixin""",
       """FlaxGreedySearchOutput""",
       """FlaxSampleOutput""",
       """FlaxBeamSearchOutput""",
   ]
  
  if TYPE_CHECKING:
   from .configuration_utils import GenerationConfig
   from .streamers import TextIteratorStreamer, TextStreamer
  
   try:
    if not is_torch_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .beam_constraints import Constraint, ConstraintListState, DisjunctiveConstraint, PhrasalConstraint
    from .beam_search import BeamHypotheses, BeamScorer, BeamSearchScorer, ConstrainedBeamSearchScorer
    from .logits_process import (
        EncoderNoRepeatNGramLogitsProcessor,
        EncoderRepetitionPenaltyLogitsProcessor,
        EpsilonLogitsWarper,
        EtaLogitsWarper,
        ExponentialDecayLengthPenalty,
        ForcedBOSTokenLogitsProcessor,
        ForcedEOSTokenLogitsProcessor,
        HammingDiversityLogitsProcessor,
        InfNanRemoveLogitsProcessor,
        LogitNormalization,
        LogitsProcessor,
        LogitsProcessorList,
        LogitsWarper,
        MinLengthLogitsProcessor,
        MinNewTokensLengthLogitsProcessor,
        NoBadWordsLogitsProcessor,
        NoRepeatNGramLogitsProcessor,
        PrefixConstrainedLogitsProcessor,
        RepetitionPenaltyLogitsProcessor,
        SequenceBiasLogitsProcessor,
        TemperatureLogitsWarper,
        TopKLogitsWarper,
        TopPLogitsWarper,
        TypicalLogitsWarper,
    )
    from .stopping_criteria import (
        MaxLengthCriteria,
        MaxNewTokensCriteria,
        MaxTimeCriteria,
        StoppingCriteria,
        StoppingCriteriaList,
        validate_stopping_criteria,
    )
    from .utils import (
        BeamSampleDecoderOnlyOutput,
        BeamSampleEncoderDecoderOutput,
        BeamSearchDecoderOnlyOutput,
        BeamSearchEncoderDecoderOutput,
        ContrastiveSearchDecoderOnlyOutput,
        ContrastiveSearchEncoderDecoderOutput,
        GenerationMixin,
        GreedySearchDecoderOnlyOutput,
        GreedySearchEncoderDecoderOutput,
        SampleDecoderOnlyOutput,
        SampleEncoderDecoderOutput,
        top_k_top_p_filtering,
    )
  
   try:
    if not is_tf_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .tf_logits_process import (
        TFForcedBOSTokenLogitsProcessor,
        TFForcedEOSTokenLogitsProcessor,
        TFForceTokensLogitsProcessor,
        TFLogitsProcessor,
        TFLogitsProcessorList,
        TFLogitsWarper,
        TFMinLengthLogitsProcessor,
        TFNoBadWordsLogitsProcessor,
        TFNoRepeatNGramLogitsProcessor,
        TFRepetitionPenaltyLogitsProcessor,
        TFSuppressTokensAtBeginLogitsProcessor,
        TFSuppressTokensLogitsProcessor,
        TFTemperatureLogitsWarper,
        TFTopKLogitsWarper,
        TFTopPLogitsWarper,
    )
    from .tf_utils import (
        TFBeamSampleDecoderOnlyOutput,
        TFBeamSampleEncoderDecoderOutput,
        TFBeamSearchDecoderOnlyOutput,
        TFBeamSearchEncoderDecoderOutput,
        TFContrastiveSearchDecoderOnlyOutput,
        TFContrastiveSearchEncoderDecoderOutput,
        TFGenerationMixin,
        TFGreedySearchDecoderOnlyOutput,
        TFGreedySearchEncoderDecoderOutput,
        TFSampleDecoderOnlyOutput,
        TFSampleEncoderDecoderOutput,
        tf_top_k_top_p_filtering,
    )
  
   try:
    if not is_flax_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .flax_logits_process import (
        FlaxForcedBOSTokenLogitsProcessor,
        FlaxForcedEOSTokenLogitsProcessor,
        FlaxLogitsProcessor,
        FlaxLogitsProcessorList,
        FlaxLogitsWarper,
        FlaxMinLengthLogitsProcessor,
        FlaxTemperatureLogitsWarper,
        FlaxTopKLogitsWarper,
        FlaxTopPLogitsWarper,
    )
    from .flax_utils import FlaxBeamSearchOutput, FlaxGenerationMixin, FlaxGreedySearchOutput, FlaxSampleOutput
  else:
   import sys
  
   a     :			str					    =						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)