






import argparse
import logging

import numpy as np
import torch

from transformers import AutoModelForCausalLM, AutoTokenizer


logging.basicConfig(
    format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""",
    datefmt="""%m/%d/%Y %H:%M:%S""",
    level=logging.INFO,
)
UpperCamelCase			=      logging.getLogger(__name__)






def     A(  snake_case_		):
       """simple docstring"""





       np.random.seed(args.seed		)
       torch.manual_seed(args.seed		)
       if args.n_gpu > 0:
              torch.cuda.manual_seed_all(args.seed		)






def     A(  ):
       """simple docstring"""





       lowercase__:    Any        =      argparse.ArgumentParser()
       parser.add_argument(
           "--model_name_or_path"						,       default=snake_case_						,       type=snake_case_						,       required=snake_case_						,       )
       parser.add_argument("--prompt"						,       type=snake_case_						,       default=""		)
       parser.add_argument("--length"						,       type=snake_case_						,       default=20		)
       parser.add_argument("--stop_token"						,       type=snake_case_						,       default=snake_case_						,       help="Token at which text generation is stopped"		)
       parser.add_argument(
           "--temperature"						,       type=snake_case_						,       default=1.0						,       help="temperature of 1.0 has no effect, lower tend toward greedy sampling"						,       )
       parser.add_argument(
           "--repetition_penalty"						,       type=snake_case_						,       default=1.0						,       help="primarily useful for CTRL model; in that case, use 1.2"		)
       parser.add_argument("--k"						,       type=snake_case_						,       default=0		)
       parser.add_argument("--penalty_alpha"						,       type=snake_case_						,       default=0.0		)
       parser.add_argument("--p"						,       type=snake_case_						,       default=0.9		)

       parser.add_argument("--prefix"						,       type=snake_case_						,       default=""						,       help="Text added prior to input."		)
       parser.add_argument("--padding_text"						,       type=snake_case_						,       default=""						,       help="Deprecated, the use of `--prefix` is preferred."		)
       parser.add_argument("--xlm_language"						,       type=snake_case_						,       default=""						,       help="Optional language when used with the XLM model."		)

       parser.add_argument("--seed"						,       type=snake_case_						,       default=42						,       help="random seed for initialization"		)
       parser.add_argument("--no_cuda"						,       action="store_true"						,       help="Avoid using CUDA when available"		)
       parser.add_argument(
           "--fp16"						,       action="store_true"						,       help="Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit"						,       )
       lowercase__:    int        =      parser.parse_args()

       lowercase__:    List[Any]        =      torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu"		)
       lowercase__:    Any        =      0 if args.no_cuda else torch.cuda.device_count()

       logger.warning(F"""device: {args.device}, n_gpu: {args.n_gpu}, 16-bits training: {args.fpaa}"""		)

       set_seed(snake_case_		)

       # Initialize the model and tokenizer
       lowercase__:    Union[str, Any]        =      AutoTokenizer.from_pretrained(args.model_name_or_path		)
       lowercase__:    int        =      AutoModelForCausalLM.from_pretrained(args.model_name_or_path		)

       # tokenizer = GPT2Tokenizer.from_pretrained(args.model_name_or_path)
       # model = OPTForCausalLM.from_pretrained(args.model_name_or_path)
       model.to(args.device		)

       if args.fpaa:
              model.half()

       logger.info(snake_case_		)
       lowercase__:    Union[str, Any]        =      args.prompt if args.prompt else input("Model prompt >>> "		)

       lowercase__:    Any        =      tokenizer(snake_case_						,       return_tensors="pt"						,       add_special_tokens=snake_case_		)
       lowercase__:    str        =      {key: value.to(args.device		) for key, value in inputs.items()}

       lowercase__:    Optional[int]        =      model.generate(
           **snake_case_						,       max_length=args.length + len(inputs["input_ids"][0]		)						,       penalty_alpha=args.penalty_alpha						,       top_k=args.k						,       )

       lowercase__:    Dict        =      []
       for generated_sequence_idx, generated_sequence in enumerate(snake_case_		):
              print(F"""=== GENERATED SEQUENCE {generated_sequence_idx + 1} ==="""		)
              lowercase__:    str        =      generated_sequence.tolist()

              # Decode text
              lowercase__:    List[str]        =      tokenizer.decode(snake_case_						,       clean_up_tokenization_spaces=snake_case_						,       add_special_tokens=snake_case_		)

              # Remove all text after the stop token
              lowercase__:    Any        =      text[: text.find(args.stop_token		) if args.stop_token else None]

              # Add the prompt at the beginning of the sequence. Remove the excess text that was used for pre-processing
              lowercase__:    Optional[int]        =      (
                  prompt_text + text[len(tokenizer.decode(inputs["input_ids"][0]						,       clean_up_tokenization_spaces=snake_case_		)		) :]
              )

              generated_sequences.append(snake_case_		)
              print(snake_case_		)

       return generated_sequences


if __name__ == "__main__":
  main()














"""simple docstring"""





# Copyright 2023 The HuggingFace Inc. 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.
from typing import TYPE_CHECKING

from ..utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


UpperCamelCase			=      {
    """agents""": ["""Agent""", """AzureOpenAiAgent""", """HfAgent""", """LocalAgent""", """OpenAiAgent"""],
    """base""": ["""PipelineTool""", """RemoteTool""", """Tool""", """launch_gradio_demo""", """load_tool"""],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCamelCase			=      ["""DocumentQuestionAnsweringTool"""]
  UpperCamelCase			=      ["""ImageCaptioningTool"""]
  UpperCamelCase			=      ["""ImageQuestionAnsweringTool"""]
  UpperCamelCase			=      ["""ImageSegmentationTool"""]
  UpperCamelCase			=      ["""SpeechToTextTool"""]
  UpperCamelCase			=      ["""TextClassificationTool"""]
  UpperCamelCase			=      ["""TextQuestionAnsweringTool"""]
  UpperCamelCase			=      ["""TextSummarizationTool"""]
  UpperCamelCase			=      ["""TextToSpeechTool"""]
  UpperCamelCase			=      ["""TranslationTool"""]

if TYPE_CHECKING:
  from .agents import Agent, AzureOpenAiAgent, HfAgent, LocalAgent, OpenAiAgent
  from .base import PipelineTool, RemoteTool, Tool, launch_gradio_demo, load_tool

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .document_question_answering import DocumentQuestionAnsweringTool
    from .image_captioning import ImageCaptioningTool
    from .image_question_answering import ImageQuestionAnsweringTool
    from .image_segmentation import ImageSegmentationTool
    from .speech_to_text import SpeechToTextTool
    from .text_classification import TextClassificationTool
    from .text_question_answering import TextQuestionAnsweringTool
    from .text_summarization import TextSummarizationTool
    from .text_to_speech import TextToSpeechTool
    from .translation import TranslationTool
else:
  import sys

  UpperCamelCase			=      _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






