



'''simple docstring'''





# Copyright 2022 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse
import os
import platform

import numpy as np
import psutil
import torch

from accelerate import __version__ as version
from accelerate.commands.config import default_config_file, load_config_from_file

from ..utils import is_npu_available, is_xpu_available
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase=None			):



    """simple docstring"""





    if subparsers is not None:
        lowerCAmelCase__ :  Any							      =					subparsers.add_parser("""env"""			)
    else:
        lowerCAmelCase__ :  List[str]							      =					argparse.ArgumentParser("""Accelerate env command"""			)

    parser.add_argument(
        """--config_file"""							,    default=UpperCamelCase							,    help="""The config file to use for the default values in the launching script."""			)

    if subparsers is not None:
        parser.set_defaults(func=UpperCamelCase			)
    return parser
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase			):



    """simple docstring"""





    lowerCAmelCase__ :  List[str]							      =					torch.__version__
    lowerCAmelCase__ :  List[Any]							      =					torch.cuda.is_available()
    lowerCAmelCase__ :  Optional[int]							      =					is_xpu_available()
    lowerCAmelCase__ :  Any							      =					is_npu_available()

    lowerCAmelCase__ :  str							      =					"""Not found"""
    # Get the default from the config file.
    if args.config_file is not None or os.path.isfile(UpperCamelCase			):
        lowerCAmelCase__ :  int							      =					load_config_from_file(args.config_file			).to_dict()

    lowerCAmelCase__ :  Optional[Any]							      =					{
        """`Accelerate` version""": version,
        """Platform""": platform.platform(),
        """Python version""": platform.python_version(),
        """Numpy version""": np.__version__,
        """PyTorch version (GPU?)""": f"""{pt_version} ({pt_cuda_available})""",
        """PyTorch XPU available""": str(UpperCamelCase			),
        """PyTorch NPU available""": str(UpperCamelCase			),
        """System RAM""": f"""{psutil.virtual_memory().total / 1024 ** 3:.2f} GB""",
    }
    if pt_cuda_available:
        lowerCAmelCase__ :  List[Any]							      =					torch.cuda.get_device_name()

    print("""\nCopy-and-paste the text below in your GitHub issue\n"""			)
    print("""\n""".join([f"""- {prop}: {val}""" for prop, val in info.items()]			)			)

    print("""- `Accelerate` default config:""" if args.config_file is None else """- `Accelerate` config passed:"""			)
    lowerCAmelCase__ :  Dict							      =					(
        """\n""".join([f"""\t- {prop}: {val}""" for prop, val in accelerate_config.items()]			)
        if isinstance(UpperCamelCase							,    UpperCamelCase			)
        else f"""\t{accelerate_config}"""
    )
    print(UpperCamelCase			)

    lowerCAmelCase__ :  str							      =					accelerate_config

    return info
def    _SCREAMING_SNAKE_CASE  (       ):



    """simple docstring"""





    lowerCAmelCase__ :  Optional[Any]							      =					env_command_parser()
    lowerCAmelCase__ :  Optional[Any]							      =					parser.parse_args()
    env_command(UpperCamelCase			)
    return 0


if __name__ == "__main__":
 raise SystemExit(main())







'''simple docstring'''





from collections import UserDict
from typing import List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
 from PIL import Image

 from ..image_utils import load_image

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

if is_tf_available():
 from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
 from ..tf_utils import stable_softmax

_lowerCAmelCase      						=	logging.get_logger(__name__)






@add_end_docstrings(SCREAMING_SNAKE_CASE_     )
class        lowerCAmelCase_(				SCREAMING_SNAKE_CASE_     ):
  '''simple docstring'''




  def __init__(    self  ,**__UpperCAmelCase      )    ->		Tuple:
      super().__init__(**__UpperCAmelCase      )

      requires_backends(self  ,"""vision"""      )
      self.check_model_type(
          TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
          if self.framework == """tf"""
          else MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING      )




  def __call__(    self  ,__UpperCAmelCase  ,**__UpperCAmelCase      )    ->		str:
      return super().__call__(__UpperCAmelCase  ,**__UpperCAmelCase      )




  def 							UpperCAmelCase_	(    self  ,**__UpperCAmelCase      )    ->		str:
      lowerCAmelCase__ :  List[Any]							      =					{}
      if "candidate_labels" in kwargs:
          lowerCAmelCase__ :  int							      =					kwargs["""candidate_labels"""]
      if "hypothesis_template" in kwargs:
          lowerCAmelCase__ :  Optional[int]							      =					kwargs["""hypothesis_template"""]

      return preprocess_params, {}, {}




  def 							UpperCAmelCase_	(    self  ,__UpperCAmelCase  ,__UpperCAmelCase=None  ,__UpperCAmelCase="This is a photo of {}."      )    ->		int:
      lowerCAmelCase__ :  str							      =					load_image(__UpperCAmelCase      )
      lowerCAmelCase__ :  Dict							      =					self.image_processor(images=[image]  ,return_tensors=self.framework      )
      lowerCAmelCase__ :  List[Any]							      =					candidate_labels
      lowerCAmelCase__ :  List[str]							      =					[hypothesis_template.format(__UpperCAmelCase      ) for x in candidate_labels]
      lowerCAmelCase__ :  Optional[Any]							      =					self.tokenizer(__UpperCAmelCase  ,return_tensors=self.framework  ,padding=__UpperCAmelCase      )
      lowerCAmelCase__ :  Tuple							      =					[text_inputs]
      return inputs




  def 							UpperCAmelCase_	(    self  ,__UpperCAmelCase      )    ->		Union[str, Any]:
      lowerCAmelCase__ :  Tuple							      =					model_inputs.pop("""candidate_labels"""      )
      lowerCAmelCase__ :  Union[str, Any]							      =					model_inputs.pop("""text_inputs"""      )
      if isinstance(text_inputs[0]  ,__UpperCAmelCase      ):
          lowerCAmelCase__ :  int							      =					text_inputs[0]
      else:
          # Batching case.
          lowerCAmelCase__ :  Dict							      =					text_inputs[0][0]

      lowerCAmelCase__ :  Any							      =					self.model(**__UpperCAmelCase  ,**__UpperCAmelCase      )

      lowerCAmelCase__ :  Union[str, Any]							      =					{
          """candidate_labels""": candidate_labels,
          """logits""": outputs.logits_per_image,
      }
      return model_outputs






  def 							UpperCAmelCase_	(    self  ,__UpperCAmelCase      )    ->		Any:
      lowerCAmelCase__ :  Union[str, Any]							      =					model_outputs.pop("""candidate_labels"""      )
      lowerCAmelCase__ :  List[str]							      =					model_outputs["""logits"""][0]
      if self.framework == "pt":
          lowerCAmelCase__ :  List[str]							      =					logits.softmax(dim=-1      ).squeeze(-1      )
          lowerCAmelCase__ :  Optional[Any]							      =					probs.tolist()
          if not isinstance(__UpperCAmelCase  ,__UpperCAmelCase      ):
              lowerCAmelCase__ :  Dict							      =					[scores]
      elif self.framework == "tf":
          lowerCAmelCase__ :  Any							      =					stable_softmax(__UpperCAmelCase  ,axis=-1      )
          lowerCAmelCase__ :  List[Any]							      =					probs.numpy().tolist()
      else:
          raise ValueError(F"""Unsupported framework: {self.framework}"""      )

      lowerCAmelCase__ :  Tuple							      =					[
          {"""score""": score, """label""": candidate_label}
          for score, candidate_label in sorted(zip(__UpperCAmelCase  ,__UpperCAmelCase      )  ,key=lambda __UpperCAmelCase      : -x[0]      )
      ]
      return result


