






import argparse
import json
import logging
import os
import sys
from unittest import skip
from unittest.mock import patch

import tensorflow as tf

from transformers.testing_utils import TestCasePlus, get_gpu_count, slow


_a				     =  [
    os.path.join(os.path.dirname(__file__), dirname)
    for dirname in [
        '''text-generation''',
        '''text-classification''',
        '''token-classification''',
        '''language-modeling''',
        '''multiple-choice''',
        '''question-answering''',
        '''summarization''',
        '''translation''',
        '''image-classification''',
    ]
]
sys.path.extend(SRC_DIRS)


if SRC_DIRS is not None:
		import run_clm
		import run_image_classification
		import run_mlm
		import run_ner
		import run_qa as run_squad
		import run_summarization
		import run_swag
		import run_text_classification
		import run_translation


logging.basicConfig(level=logging.DEBUG)

_a				     =  logging.getLogger()


def __A   (				)->  Tuple:





						"""simple docstring"""



						_UpperCAmelCase     =      argparse.ArgumentParser()
						parser.add_argument('-f'     )
						_UpperCAmelCase     =      parser.parse_args()
						return args.f


def __A   (				__lowerCAmelCase     )->  Tuple:





						"""simple docstring"""



						_UpperCAmelCase     =      {}
						_UpperCAmelCase     =      os.path.join(__lowerCAmelCase			,		'all_results.json'     )
						if os.path.exists(__lowerCAmelCase     ):
												with open(__lowerCAmelCase			,		'r'     ) as f:
																		_UpperCAmelCase     =      json.load(__lowerCAmelCase     )
						else:
												raise ValueError(F"""can't find {path}"""     )
						return results


def __A   (				)->  Union[str, Any]:





						"""simple docstring"""



						return bool(tf.config.list_physical_devices('GPU'     )     )


_a				     =  logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)





class __lowerCamelCase			(				snake_case__):





	"""simple docstring"""






	@skip('Skipping until shape inference for to_tf_dataset PR is merged.'   )
	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.get_auto_remove_tmp_dir()
							_UpperCAmelCase     =      F"""
            run_text_classification.py
            --model_name_or_path distilbert-base-uncased
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv
            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv
            --do_train
            --do_eval
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --learning_rate=1e-4
            --max_steps=10
            --warmup_steps=2
            --seed=42
            --max_seq_length=128
            """.split()

							if is_cuda_available():
													testargs.append('--fp16'   )

							with patch.object(UpperCAmelCase	,   'argv'	,   UpperCAmelCase   ):
													run_text_classification.main()
													# Reset the mixed precision policy so we don't break other tests
													tf.keras.mixed_precision.set_global_policy('float32'   )
													_UpperCAmelCase     =      get_results(UpperCAmelCase   )
													self.assertGreaterEqual(result['eval_accuracy']	,   0.75   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.get_auto_remove_tmp_dir()
							_UpperCAmelCase     =      F"""
            run_clm.py
            --model_name_or_path distilgpt2
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --do_train
            --do_eval
            --block_size 128
            --per_device_train_batch_size 2
            --per_device_eval_batch_size 1
            --num_train_epochs 2
            --output_dir {tmp_dir}
            --overwrite_output_dir
            """.split()

							if len(tf.config.list_physical_devices('GPU'   )   ) > 1:
													# Skipping because there are not enough batches to train the model + would need a drop_last to work.
													return

							with patch.object(UpperCAmelCase	,   'argv'	,   UpperCAmelCase   ):
													run_clm.main()
													_UpperCAmelCase     =      get_results(UpperCAmelCase   )
													self.assertLess(result['eval_perplexity']	,   100   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.get_auto_remove_tmp_dir()
							_UpperCAmelCase     =      F"""
            run_mlm.py
            --model_name_or_path distilroberta-base
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --max_seq_length 64
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --do_train
            --do_eval
            --prediction_loss_only
            --num_train_epochs=1
            --learning_rate=1e-4
        """.split()

							with patch.object(UpperCAmelCase	,   'argv'	,   UpperCAmelCase   ):
													run_mlm.main()
													_UpperCAmelCase     =      get_results(UpperCAmelCase   )
													self.assertLess(result['eval_perplexity']	,   42   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      7 if get_gpu_count() > 1 else 2

							_UpperCAmelCase     =      self.get_auto_remove_tmp_dir()
							_UpperCAmelCase     =      F"""
            run_ner.py
            --model_name_or_path bert-base-uncased
            --train_file tests/fixtures/tests_samples/conll/sample.json
            --validation_file tests/fixtures/tests_samples/conll/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --do_train
            --do_eval
            --warmup_steps=2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=2
            --num_train_epochs={epochs}
            --seed 7
        """.split()

							with patch.object(UpperCAmelCase	,   'argv'	,   UpperCAmelCase   ):
													run_ner.main()
													_UpperCAmelCase     =      get_results(UpperCAmelCase   )
													self.assertGreaterEqual(result['accuracy']	,   0.75   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.get_auto_remove_tmp_dir()
							_UpperCAmelCase     =      F"""
            run_qa.py
            --model_name_or_path bert-base-uncased
            --version_2_with_negative
            --train_file tests/fixtures/tests_samples/SQUAD/sample.json
            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --max_steps=10
            --warmup_steps=2
            --do_train
            --do_eval
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
        """.split()

							with patch.object(UpperCAmelCase	,   'argv'	,   UpperCAmelCase   ):
													run_squad.main()
													_UpperCAmelCase     =      get_results(UpperCAmelCase   )
													self.assertGreaterEqual(result['f1']	,   30   )
													self.assertGreaterEqual(result['exact']	,   30   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.get_auto_remove_tmp_dir()
							_UpperCAmelCase     =      F"""
            run_swag.py
            --model_name_or_path bert-base-uncased
            --train_file tests/fixtures/tests_samples/swag/sample.json
            --validation_file tests/fixtures/tests_samples/swag/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --max_steps=20
            --warmup_steps=2
            --do_train
            --do_eval
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
        """.split()

							with patch.object(UpperCAmelCase	,   'argv'	,   UpperCAmelCase   ):
													run_swag.main()
													_UpperCAmelCase     =      get_results(UpperCAmelCase   )
													self.assertGreaterEqual(result['val_accuracy']	,   0.8   )

	@slow
	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.get_auto_remove_tmp_dir()
							_UpperCAmelCase     =      F"""
            run_summarization.py
            --model_name_or_path t5-small
            --train_file tests/fixtures/tests_samples/xsum/sample.json
            --validation_file tests/fixtures/tests_samples/xsum/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --max_steps=50
            --warmup_steps=8
            --do_train
            --do_eval
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
        """.split()

							with patch.object(UpperCAmelCase	,   'argv'	,   UpperCAmelCase   ):
													run_summarization.main()
													_UpperCAmelCase     =      get_results(UpperCAmelCase   )
													self.assertGreaterEqual(result['rouge1']	,   10   )
													self.assertGreaterEqual(result['rouge2']	,   2   )
													self.assertGreaterEqual(result['rougeL']	,   7   )
													self.assertGreaterEqual(result['rougeLsum']	,   7   )

	@slow
	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.get_auto_remove_tmp_dir()
							_UpperCAmelCase     =      F"""
            run_translation.py
            --model_name_or_path Rocketknight1/student_marian_en_ro_6_1
            --source_lang en
            --target_lang ro
            --train_file tests/fixtures/tests_samples/wmt16/sample.json
            --validation_file tests/fixtures/tests_samples/wmt16/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --warmup_steps=8
            --do_train
            --do_eval
            --learning_rate=3e-3
            --num_train_epochs 12
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --source_lang en_XX
            --target_lang ro_RO
        """.split()

							with patch.object(UpperCAmelCase	,   'argv'	,   UpperCAmelCase   ):
													run_translation.main()
													_UpperCAmelCase     =      get_results(UpperCAmelCase   )
													self.assertGreaterEqual(result['bleu']	,   30   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.get_auto_remove_tmp_dir()
							_UpperCAmelCase     =      F"""
            run_image_classification.py
            --dataset_name hf-internal-testing/cats_vs_dogs_sample
            --model_name_or_path microsoft/resnet-18
            --do_train
            --do_eval
            --learning_rate 1e-4
            --per_device_train_batch_size 2
            --per_device_eval_batch_size 1
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --dataloader_num_workers 16
            --num_train_epochs 2
            --train_val_split 0.1
            --seed 42
            --ignore_mismatched_sizes True
            """.split()

							with patch.object(UpperCAmelCase	,   'argv'	,   UpperCAmelCase   ):
													run_image_classification.main()
													_UpperCAmelCase     =      get_results(UpperCAmelCase   )
													self.assertGreaterEqual(result['accuracy']	,   0.7   )








import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


_a				     =  '''
Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf originally as a company that developed a chatbot app targeted at teenagers.[2] After open-sourcing the model behind the chatbot, the company pivoted to focus on being a platform for machine learning.

In March 2021, Hugging Face raised $40 million in a Series B funding round.[3]

On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model.[4] In 2022, the workshop concluded with the announcement of BLOOM, a multilingual large language model with 176 billion parameters.[5]
'''





class __lowerCamelCase			(				unittest.TestCase					,	snake_case__):





	"""simple docstring"""






	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      load_tool('summarization'   )
							self.tool.setup()
							_UpperCAmelCase     =      load_tool('summarization'	,   remote=UpperCAmelCase   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.tool(UpperCAmelCase   )
							self.assertEqual(
							    UpperCAmelCase	,   'Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM.'	,   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.remote_tool(UpperCAmelCase   )
							self.assertEqual(
							    UpperCAmelCase	,   'Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM.'	,   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.tool(text=UpperCAmelCase   )
							self.assertEqual(
							    UpperCAmelCase	,   'Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM.'	,   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.remote_tool(text=UpperCAmelCase   )
							self.assertEqual(
							    UpperCAmelCase	,   'Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM.'	,   )
