





'''simple docstring'''

from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
  import tensorflow as tf

  from transformers import (
      AutoTokenizer,
      TFAutoModelForCausalLM,
      TFAutoModelForSeqaSeqLM,
      TFAutoModelForSpeechSeqaSeq,
      TFAutoModelForVisionaSeq,
      TFBartForConditionalGeneration,
      TFLogitsProcessorList,
      TFMinLengthLogitsProcessor,
      tf_top_k_top_p_filtering,
  )

if is_tensorflow_text_available():
  import tensorflow_text as text






@require_tf
class   UpperCAmelCase      (			unittest.TestCase							):
 def 	UpperCAmelCase_				(							self :Optional[int]				)->				Tuple:
     A__							=     tf.convert_to_tensor(
         [
             [
                 8.2_2_2_0_9_9_1,  # 3rd highest value; idx. 0
                 -0.5_6_2_0_0_4_4,
                 5.2_3_2_2_9_7_5_2,
                 4.0_3_8_6_3_9_3,
                 -6.8_7_9_8_3_7_8,
                 -0.5_4_7_8_5_8_0_2,
                 -3.2_0_1_2_1_5_3,
                 2.9_2_7_7_7_1_7_6,
                 1.8_8_1_7_1_9_5_3,
                 7.3_5_3_4_1_2_7_6,  # 5th highest value; idx. 9
                 8.4_3_2_0_7_8_3_3,  # 2nd highest value; idx. 10
                 -9.8_5_7_1_1_8_3_6,
                 -5.9_6_2_0_9_2_3_6,
                 -1.1_3_0_3_9_1_6_1,
                 -7.1_1_1_5_2_9_4,
                 -0.8_3_6_9_6_3_3,
                 -5.3_1_8_6_4_0_8,
                 7.0_6_4_2_7_4_0_7,
                 0.8_1_3_6_9_3_4_4,
                 -0.8_2_0_2_3_8_1_7,
                 -5.9_1_7_9_7_9_6,
                 0.5_8_8_1_3_4_4_3,
                 -6.9_9_7_7_8_4_3_8,
                 4.7_1_5_5_1_1_8_9,
                 -0.1_8_7_7_1_6_3_7,
                 7.4_4_0_2_0_7_5_9,  # 4th highest value; idx. 25
                 9.3_8_4_5_0_9_8_7,  # 1st highest value; idx. 26
                 2.1_2_6_6_2_9_4_1,
                 -9.3_2_5_6_2_0_3_8,
                 2.3_5_6_5_2_5_2_2,
             ],  # cummulative prob of 5 highest values <= 0.6
             [
                 0.5_8_4_2_5_5_1_8,
                 4.5_3_1_3_9_2_3_8,
                 -5.5_7_5_1_0_4_6_4,
                 -6.2_8_0_3_0_6_9_9,
                 -7.1_9_5_2_9_5_0_3,
                 -4.0_2_1_2_2_5_5_1,
                 1.3_9_3_3_7_0_3_7,
                 -6.0_6_7_0_7_0_5_7,
                 1.5_9_4_8_0_5_1_7,
                 -9.6_4_3_1_1_9,
                 0.0_3_9_0_7_7_9_9,
                 0.6_7_2_3_1_7_6_2,
                 -8.8_8_2_0_6_7_2_6,
                 6.2_7_1_1_5_9_2_2,  # 4th highest value; idx. 13
                 2.2_8_5_2_0_7_2_3,
                 4.8_2_7_6_7_5_0_6,
                 4.3_0_4_2_1_3_6_8,
                 8.8_2_7_5_3_1_3,  # 2nd highest value; idx. 17
                 5.4_4_0_2_9_9_5_8,  # 5th highest value; idx. 18
                 -4.4_7_3_5_7_9_4,
                 7.3_8_5_7_9_5_3_6,  # 3rd highest value; idx. 20
                 -2.9_1_0_5_1_6_6_3,
                 2.6_1_9_4_6_0_7_7,
                 -2.5_6_7_4_7_6_2,
                 -9.4_8_9_5_9_3_0_2,
                 -4.0_2_9_2_2_6_4_5,
                 -1.3_5_4_1_6_9_1_8,
                 9.6_7_7_0_2_3_2_3,  # 1st highest value; idx. 27
                 -5.8_9_4_7_8_5_5_3,
                 1.8_5_3_7_0_4_6_7,
             ],  # cummulative prob of 5 highest values <= 0.6
         ]		,			dtype=tf.floataa		,			)

     A__							=     tf.convert_to_tensor(
         [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]]		,			dtype=tf.intaa		,			)  # expected non filtered idx as noted above

     A__							=     tf.convert_to_tensor(
         [8.2_2_2_0_9_9, 7.3_5_3_4_1_2_6, 8.4_3_2_0_7_8, 7.4_4_0_2_0_7_5, 9.3_8_4_5_1, 6.2_7_1_1_5_9, 8.8_2_7_5_3_1, 5.4_4_0_2_9_9_5, 7.3_8_5_7_9_5_6, 9.6_7_7_0_2_3]		,			dtype=tf.floataa		,			)  # expected non filtered values as noted above

     A__							=     tf_top_k_top_p_filtering(lowercase_		,			top_k=10		,			top_p=0.6		,			min_tokens_to_keep=4				)

     A__							=     output[output != -float("inf"				)]
     A__							=     tf.cast(
         tf.where(tf.not_equal(lowercase_		,			tf.constant(-float("inf"				)		,			dtype=tf.floataa				)				)				)		,			dtype=tf.intaa		,			)

     tf.debugging.assert_near(lowercase_		,			lowercase_		,			rtol=1E-12				)
     tf.debugging.assert_equal(lowercase_		,			lowercase_				)






@require_tf
class   UpperCAmelCase      (			unittest.TestCase     ,			UpperCamelCase__							):
 # setting framework_dependent_parameters needs to be gated, just like its contents' imports
 if is_tf_available():
  __lowercase  						=							{
      """AutoModelForCausalLM""": TFAutoModelForCausalLM,
      """AutoModelForSpeechSeq2Seq""": TFAutoModelForSpeechSeqaSeq,
      """AutoModelForSeq2SeqLM""": TFAutoModelForSeqaSeqLM,
      """AutoModelForVision2Seq""": TFAutoModelForVisionaSeq,
      """LogitsProcessorList""": TFLogitsProcessorList,
      """MinLengthLogitsProcessor""": TFMinLengthLogitsProcessor,
      """create_tensor_fn""": tf.convert_to_tensor,
      """floats_tensor""": floats_tensor,
      """return_tensors""": """tf""",
  }
 @slow
 def 	UpperCAmelCase_				(							self :Tuple				)->				Optional[int]:
     # TF-only test: tf.saved_model export
     A__							=     TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"				)
     A__							=     2
     A__							=     2






     class   UpperCAmelCase      (			tf.Module							):
      def __init__(							self :Any		,			lowercase_ :str				)->				Tuple:
          super(lowercase_		,			self				).__init__()
          A__							=     model



      @tf.function(
          input_signature=(
              tf.TensorSpec((None, input_length)		,			tf.intaa		,			name="input_ids"				),
              tf.TensorSpec((None, input_length)		,			tf.intaa		,			name="attention_mask"				),
          )		,			jit_compile=lowercase_		,			)
      def 	UpperCAmelCase_				(							self :Optional[Any]		,			lowercase_ :Tuple		,			lowercase_ :Dict				)->				int:
          A__							=     self.model.generate(
              input_ids=lowercase_		,			attention_mask=lowercase_		,			max_new_tokens=lowercase_		,			return_dict_in_generate=lowercase_		,			)
          return {"sequences": outputs["sequences"]}

     A__							=     [[2, 0], [1_02, 1_03]]
     A__							=     [[1, 0], [1, 1]]
     A__							=     DummyModel(model=lowercase_				)
     with tempfile.TemporaryDirectory() as tmp_dir:
         tf.saved_model.save(lowercase_		,			lowercase_		,			signatures={"serving_default": dummy_model.serving}				)
         A__							=     tf.saved_model.load(lowercase_				).signatures["serving_default"]
         for batch_size in range(1		,			len(lowercase_				) + 1				):
             A__							=     {
                 "input_ids": tf.constant(dummy_input_ids[:batch_size]				),
                 "attention_mask": tf.constant(dummy_attention_masks[:batch_size]				),
             }
             A__							=     serving_func(**lowercase_				)["sequences"]
             A__							=     test_model.generate(**lowercase_		,			max_new_tokens=lowercase_				)
             tf.debugging.assert_equal(lowercase_		,			lowercase_				)
 @slow
 def 	UpperCAmelCase_				(							self :str				)->				Dict:
     # TF-only test: tf.saved_model export
     A__							=     TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"				)
     A__							=     1
     A__							=     2






     class   UpperCAmelCase      (			tf.Module							):
      def __init__(							self :Union[str, Any]		,			lowercase_ :Dict				)->				Union[str, Any]:
          super(lowercase_		,			self				).__init__()
          A__							=     model



      @tf.function(
          input_signature=(
              tf.TensorSpec((batch_size, None)		,			tf.intaa		,			name="input_ids"				),
              tf.TensorSpec((batch_size, None)		,			tf.intaa		,			name="attention_mask"				),
          )		,			jit_compile=lowercase_		,			)
      def 	UpperCAmelCase_				(							self :List[Any]		,			lowercase_ :str		,			lowercase_ :str				)->				Optional[Any]:
          A__							=     self.model.generate(
              input_ids=lowercase_		,			attention_mask=lowercase_		,			max_new_tokens=lowercase_		,			return_dict_in_generate=lowercase_		,			)
          return {"sequences": outputs["sequences"]}

     A__							=     [[2], [1_02, 1_03]]
     A__							=     [[1], [1, 1]]
     A__							=     DummyModel(model=lowercase_				)
     with tempfile.TemporaryDirectory() as tmp_dir:
         tf.saved_model.save(lowercase_		,			lowercase_		,			signatures={"serving_default": dummy_model.serving}				)
         A__							=     tf.saved_model.load(lowercase_				).signatures["serving_default"]
         for input_row in range(len(lowercase_				)				):
             A__							=     {
                 "input_ids": tf.constant([dummy_input_ids[input_row]]				),
                 "attention_mask": tf.constant([dummy_attention_masks[input_row]]				),
             }
             A__							=     serving_func(**lowercase_				)["sequences"]
             A__							=     test_model.generate(**lowercase_		,			max_new_tokens=lowercase_				)
             tf.debugging.assert_equal(lowercase_		,			lowercase_				)
 @slow
 @require_tensorflow_text
 def 	UpperCAmelCase_				(							self :List[Any]				)->				Dict:
     # TF-only test: tf.saved_model export
     with tempfile.TemporaryDirectory() as tmp_dir:
         # file needed to load the TF tokenizer
         hf_hub_download(repo_id="google/flan-t5-small"		,			filename="spiece.model"		,			local_dir=lowercase_				)






         class   UpperCAmelCase      (			tf.keras.layers.Layer							):
          def __init__(							self :str				)->				int:
              super().__init__()
              A__							=     text.SentencepieceTokenizer(
                  model=tf.io.gfile.GFile(os.path.join(lowercase_		,			"spiece.model"				)		,			"rb"				).read()				)
              A__							=     TFAutoModelForSeqaSeqLM.from_pretrained("hf-internal-testing/tiny-random-t5"				)



          def 	UpperCAmelCase_				(							self :int		,			lowercase_ :int		,			*lowercase_ :int		,			**lowercase_ :Any				)->				List[Any]:
              A__							=     self.tokenizer.tokenize(lowercase_				)
              A__,      A__							=     text.pad_model_inputs(
                  lowercase_		,			max_seq_length=64		,			pad_value=self.model.config.pad_token_id				)
              A__							=     self.model.generate(input_ids=lowercase_		,			attention_mask=lowercase_				)
              return self.tokenizer.detokenize(lowercase_				)

         A__							=     CompleteSentenceTransformer()
         A__							=     tf.keras.layers.Input(shape=(1,)		,			dtype=tf.string		,			name="inputs"				)
         A__							=     complete_model(lowercase_				)
         A__							=     tf.keras.Model(lowercase_		,			lowercase_				)
         keras_model.save(lowercase_				)
 def 	UpperCAmelCase_				(							self :Dict				)->				Union[str, Any]:
     # Has PT equivalent: this test relies on random sampling
     A__							=     {
         "do_sample": True,
         "num_beams": 1,
         "top_p": 0.7,
         "top_k": 10,
         "temperature": 0.7,
     }
     A__							=     14

     A__							=     AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gpt2"				)
     A__							=     "Hello, my dog is cute and"
     A__							=     tokenizer(lowercase_		,			return_tensors="tf"				)
     A__							=     TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"				)

     A__							=     6_38
     # forces the generation to happen on CPU, to avoid GPU-related quirks
     with tf.device(":/CPU:0"				):
         tf.random.set_seed(0				)
         A__							=     model.generate(**lowercase_		,			eos_token_id=lowercase_		,			**lowercase_				)
     self.assertTrue(expectation == len(generated_tokens[0]				)				)

     A__							=     [6_38, 1_98]
     with tf.device(":/CPU:0"				):
         tf.random.set_seed(0				)
         A__							=     model.generate(**lowercase_		,			eos_token_id=lowercase_		,			**lowercase_				)
     self.assertTrue(expectation == len(generated_tokens[0]				)				)



 def 	UpperCAmelCase_				(							self :List[str]				)->				List[str]:
     # Has PT equivalent: ample use of framework-specific code
     A__							=     AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-bart"				)
     A__							=     "Hugging Face is a technology company based in New York and Paris."
     A__							=     bart_tokenizer(lowercase_		,			return_tensors="tf"				).input_ids
     A__							=     TFBartForConditionalGeneration.from_pretrained("hf-internal-testing/tiny-random-bart"				)
     A__							=     bart_model.generate(lowercase_				).numpy()






     class   UpperCAmelCase      (			UpperCamelCase__							):
      def 	UpperCAmelCase_				(							self :str		,			lowercase_ :Optional[Any]		,			lowercase_ :Optional[int]=None		,			**lowercase_ :str				)->				List[str]:
          return super().call(lowercase_		,			**lowercase_				)

     A__							=     FakeBart.from_pretrained("hf-internal-testing/tiny-random-bart"				)
     A__							=     bart_model.generate(lowercase_		,			foo="bar"				).numpy()
     self.assertTrue(np.array_equal(lowercase_		,			lowercase_				)				)






     class   UpperCAmelCase      (			bart_model.model.encoder.__class__							):
      def 	UpperCAmelCase_				(							self :Dict		,			lowercase_ :List[str]		,			**lowercase_ :List[Any]				)->				List[Any]:
          return super().call(lowercase_		,			**lowercase_				)

     A__							=     FakeEncoder(bart_model.config		,			bart_model.model.shared				)
     A__							=     fake_encoder

     # Normal generation still works (the output will be different because the encoder weights are different)
     A__							=     bart_model.generate(lowercase_				).numpy()
     with self.assertRaises(lowercase_				):
         # FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
         bart_model.generate(lowercase_		,			foo="bar"				)










'''simple docstring'''

import argparse
import json
import logging
import os
import shutil
import sys
import tempfile
import unittest
from unittest import mock

import torch
from accelerate.utils import write_basic_config

from transformers.testing_utils import TestCasePlus, get_gpu_count, run_command, slow, torch_device
from transformers.utils import is_apex_available


logging.basicConfig(level=logging.DEBUG)

__lowerCAmelCase				:      Dict						      =logging.getLogger()





def 		UpperCamelCase							(				):
    A__							=     argparse.ArgumentParser()
    parser.add_argument("-f"			)
    A__							=     parser.parse_args()
    return args.f





def 		UpperCamelCase							(				_lowerCamelCase   :   List[str]			):
    A__							=     {}
    A__							=     os.path.join(_lowerCamelCase		,			"all_results.json"			)
    if os.path.exists(_lowerCamelCase			):
        with open(_lowerCamelCase		,			"r"			) as f:
            A__							=     json.load(_lowerCamelCase			)
    else:
        raise ValueError(F"can't find {path}"			)
    return results





def 		UpperCamelCase							(				):
    A__							=     torch.cuda.is_available() and torch_device == "cuda"
    return is_using_cuda and is_apex_available()


__lowerCAmelCase				:      Union[str, Any]						      =logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)






class   UpperCAmelCase      (			UpperCamelCase__							):
 @classmethod
 def 	UpperCAmelCase_				(							cls :List[Any]				)->				Union[str, Any]:
     # Write Accelerate config, will pick up on CPU, GPU, and multi-GPU
     A__							=     tempfile.mkdtemp()
     A__							=     os.path.join(cls.tmpdir		,			"default_config.yml"				)
     write_basic_config(save_location=cls.configPath				)
     A__							=     ["accelerate", "launch", "--config_file", cls.configPath]
 @classmethod
 def 	UpperCAmelCase_				(							cls :Tuple				)->				List[Any]:
     shutil.rmtree(cls.tmpdir				)
 @mock.patch.dict(os.environ		,			{"WANDB_MODE": "offline"}				)
 def 	UpperCAmelCase_				(							self :Union[str, Any]				)->				Any:
     A__							=     self.get_auto_remove_tmp_dir()
     A__							=     F"\n            {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py\n            --model_name_or_path distilbert-base-uncased\n            --output_dir {tmp_dir}\n            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv\n            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --learning_rate=1e-4\n            --seed=42\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

     if is_cuda_and_apex_available():
         testargs.append("--fp16"				)

     run_command(self._launch_args + testargs				)
     A__							=     get_results(lowercase_				)
     self.assertGreaterEqual(result["eval_accuracy"]		,			0.7_5				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"epoch_0"				)				)				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"glue_no_trainer"				)				)				)
 @mock.patch.dict(os.environ		,			{"WANDB_MODE": "offline"}				)
 def 	UpperCAmelCase_				(							self :List[Any]				)->				Tuple:
     A__							=     self.get_auto_remove_tmp_dir()
     A__							=     F"\n            {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py\n            --model_name_or_path distilgpt2\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --block_size 128\n            --per_device_train_batch_size 5\n            --per_device_eval_batch_size 5\n            --num_train_epochs 2\n            --output_dir {tmp_dir}\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

     if torch.cuda.device_count() > 1:
         # Skipping because there are not enough batches to train the model + would need a drop_last to work.
         return

     run_command(self._launch_args + testargs				)
     A__							=     get_results(lowercase_				)
     self.assertLess(result["perplexity"]		,			1_00				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"epoch_0"				)				)				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"clm_no_trainer"				)				)				)
 @mock.patch.dict(os.environ		,			{"WANDB_MODE": "offline"}				)
 def 	UpperCAmelCase_				(							self :Any				)->				str:
     A__							=     self.get_auto_remove_tmp_dir()
     A__							=     F"\n            {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py\n            --model_name_or_path distilroberta-base\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --output_dir {tmp_dir}\n            --num_train_epochs=1\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

     run_command(self._launch_args + testargs				)
     A__							=     get_results(lowercase_				)
     self.assertLess(result["perplexity"]		,			42				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"epoch_0"				)				)				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"mlm_no_trainer"				)				)				)
 @mock.patch.dict(os.environ		,			{"WANDB_MODE": "offline"}				)
 def 	UpperCAmelCase_				(							self :Optional[Any]				)->				List[str]:
     # with so little data distributed training needs more epochs to get the score on par with 0/1 gpu
     A__							=     7 if get_gpu_count() > 1 else 2

     A__							=     self.get_auto_remove_tmp_dir()
     A__							=     F"\n            {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/conll/sample.json\n            --validation_file tests/fixtures/tests_samples/conll/sample.json\n            --output_dir {tmp_dir}\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=2\n            --num_train_epochs={epochs}\n            --seed 7\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

     run_command(self._launch_args + testargs				)
     A__							=     get_results(lowercase_				)
     self.assertGreaterEqual(result["eval_accuracy"]		,			0.7_5				)
     self.assertLess(result["train_loss"]		,			0.5				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"epoch_0"				)				)				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"ner_no_trainer"				)				)				)
 @unittest.skip(reason="Fix me @muellerzr"				)
 @mock.patch.dict(os.environ		,			{"WANDB_MODE": "offline"}				)
 def 	UpperCAmelCase_				(							self :Any				)->				Optional[int]:
     A__							=     self.get_auto_remove_tmp_dir()
     A__							=     F"\n            {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --version_2_with_negative\n            --train_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --output_dir {tmp_dir}\n            --seed=42\n            --max_train_steps=10\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

     run_command(self._launch_args + testargs				)
     A__							=     get_results(lowercase_				)
     # Because we use --version_2_with_negative the testing script uses SQuAD v2 metrics.
     self.assertGreaterEqual(result["eval_f1"]		,			28				)
     self.assertGreaterEqual(result["eval_exact"]		,			28				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"epoch_0"				)				)				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"qa_no_trainer"				)				)				)
 @mock.patch.dict(os.environ		,			{"WANDB_MODE": "offline"}				)
 def 	UpperCAmelCase_				(							self :Optional[int]				)->				List[str]:
     A__							=     self.get_auto_remove_tmp_dir()
     A__							=     F"\n            {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/swag/sample.json\n            --validation_file tests/fixtures/tests_samples/swag/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=20\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --with_tracking\n        ".split()

     run_command(self._launch_args + testargs				)
     A__							=     get_results(lowercase_				)
     self.assertGreaterEqual(result["eval_accuracy"]		,			0.8				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"swag_no_trainer"				)				)				)
 @slow
 @mock.patch.dict(os.environ		,			{"WANDB_MODE": "offline"}				)
 def 	UpperCAmelCase_				(							self :Tuple				)->				Any:
     A__							=     self.get_auto_remove_tmp_dir()
     A__							=     F"\n            {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py\n            --model_name_or_path t5-small\n            --train_file tests/fixtures/tests_samples/xsum/sample.json\n            --validation_file tests/fixtures/tests_samples/xsum/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=50\n            --num_warmup_steps=8\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

     run_command(self._launch_args + testargs				)
     A__							=     get_results(lowercase_				)
     self.assertGreaterEqual(result["eval_rouge1"]		,			10				)
     self.assertGreaterEqual(result["eval_rouge2"]		,			2				)
     self.assertGreaterEqual(result["eval_rougeL"]		,			7				)
     self.assertGreaterEqual(result["eval_rougeLsum"]		,			7				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"epoch_0"				)				)				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"summarization_no_trainer"				)				)				)
 @slow
 @mock.patch.dict(os.environ		,			{"WANDB_MODE": "offline"}				)
 def 	UpperCAmelCase_				(							self :Union[str, Any]				)->				Optional[int]:
     A__							=     self.get_auto_remove_tmp_dir()
     A__							=     F"\n            {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py\n            --model_name_or_path sshleifer/student_marian_en_ro_6_1\n            --source_lang en\n            --target_lang ro\n            --train_file tests/fixtures/tests_samples/wmt16/sample.json\n            --validation_file tests/fixtures/tests_samples/wmt16/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=50\n            --num_warmup_steps=8\n            --num_beams=6\n            --learning_rate=3e-3\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --source_lang en_XX\n            --target_lang ro_RO\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

     run_command(self._launch_args + testargs				)
     A__							=     get_results(lowercase_				)
     self.assertGreaterEqual(result["eval_bleu"]		,			30				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"epoch_0"				)				)				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"translation_no_trainer"				)				)				)
 @slow
 def 	UpperCAmelCase_				(							self :Optional[int]				)->				List[Any]:
     A__							=     logging.StreamHandler(sys.stdout				)
     logger.addHandler(lowercase_				)

     A__							=     self.get_auto_remove_tmp_dir()
     A__							=     F"\n            {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py\n            --dataset_name huggingface/semantic-segmentation-test-sample\n            --output_dir {tmp_dir}\n            --max_train_steps=10\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n        ".split()

     run_command(self._launch_args + testargs				)
     A__							=     get_results(lowercase_				)
     self.assertGreaterEqual(result["eval_overall_accuracy"]		,			0.1_0				)



 @mock.patch.dict(os.environ		,			{"WANDB_MODE": "offline"}				)
 def 	UpperCAmelCase_				(							self :str				)->				Dict:
     A__							=     self.get_auto_remove_tmp_dir()
     A__							=     F"\n            {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py\n            --model_name_or_path google/vit-base-patch16-224-in21k\n            --dataset_name hf-internal-testing/cats_vs_dogs_sample\n            --learning_rate 1e-4\n            --per_device_train_batch_size 2\n            --per_device_eval_batch_size 1\n            --max_train_steps 2\n            --train_val_split 0.1\n            --seed 42\n            --output_dir {tmp_dir}\n            --with_tracking\n            --checkpointing_steps 1\n        ".split()

     if is_cuda_and_apex_available():
         testargs.append("--fp16"				)

     run_command(self._launch_args + testargs				)
     A__							=     get_results(lowercase_				)
     # The base model scores a 25%
     self.assertGreaterEqual(result["eval_accuracy"]		,			0.6				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"step_1"				)				)				)
     self.assertTrue(os.path.exists(os.path.join(lowercase_		,			"image_classification_no_trainer"				)				)				)



