


'''simple docstring'''







import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoImageProcessor, ViTImageProcessor
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / 'utils'))

from test_module.custom_image_processing import CustomImageProcessor  # noqa E402


SCREAMING_SNAKE_CASE_      =			get_tests_dir('fixtures')


class  lowerCAmelCase_						(       unittest.TestCase      ):





  """simple docstring"""



  def __a						(					self     :							Dict						):





       '''simple docstring'''

       __a       =   mock.Mock()
       __a       =   5_0_0
       __a       =   {}
       __a       =   HTTPError
       __a       =   {}

       # Download this model to make sure it's in the cache.
       __a       =   ViTImageProcessor.from_pretrained("""hf-internal-testing/tiny-random-vit"""						)
       # Under the mock environment we get a 500 error when trying to reach the model.
       with mock.patch("""requests.Session.request"""				,							return_value=SCREAMING_SNAKE_CASE__						) as mock_head:
            __a       =   ViTImageProcessor.from_pretrained("""hf-internal-testing/tiny-random-vit"""						)
            # This check we did call the fake head request
            mock_head.assert_called()

  def __a						(					self     :							List[str]						):





       '''simple docstring'''

       __a       =   ViTImageProcessor.from_pretrained(
           """https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json"""						)


  def __a						(					self     :							Any						):





       '''simple docstring'''

       with self.assertRaises(SCREAMING_SNAKE_CASE__						):
            # config is in subfolder, the following should not work without specifying the subfolder
            __a       =   AutoImageProcessor.from_pretrained("""hf-internal-testing/stable-diffusion-all-variants"""						)

       __a       =   AutoImageProcessor.from_pretrained(
           """hf-internal-testing/stable-diffusion-all-variants"""				,							subfolder="""feature_extractor"""						)

       self.assertIsNotNone(SCREAMING_SNAKE_CASE__						)


@is_staging_test
class  lowerCAmelCase_						(       unittest.TestCase      ):





  """simple docstring"""



  @classmethod
  def __a						(					cls     :							str						):





       '''simple docstring'''

       __a       =   TOKEN
       HfFolder.save_token(SCREAMING_SNAKE_CASE__						)

  @classmethod
  def __a						(					cls     :							List[str]						):





       '''simple docstring'''

       try:
            delete_repo(token=cls._token				,							repo_id="""test-image-processor"""						)
       except HTTPError:
            pass

       try:
            delete_repo(token=cls._token				,							repo_id="""valid_org/test-image-processor-org"""						)
       except HTTPError:
            pass

       try:
            delete_repo(token=cls._token				,							repo_id="""test-dynamic-image-processor"""						)
       except HTTPError:
            pass

  def __a						(					self     :							Tuple						):





       '''simple docstring'''

       __a       =   ViTImageProcessor.from_pretrained(SCREAMING_SNAKE_CASE__						)
       image_processor.push_to_hub("""test-image-processor"""				,							use_auth_token=self._token						)

       __a       =   ViTImageProcessor.from_pretrained(f'''{USER}/test-image-processor'''						)
       for k, v in image_processor.__dict__.items():
            self.assertEqual(SCREAMING_SNAKE_CASE__				,							getattr(SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__						)						)

       # Reset repo
       delete_repo(token=self._token				,							repo_id="""test-image-processor"""						)

       # Push to hub via save_pretrained
       with tempfile.TemporaryDirectory() as tmp_dir:
            image_processor.save_pretrained(
                SCREAMING_SNAKE_CASE__				,							repo_id="""test-image-processor"""				,							push_to_hub=SCREAMING_SNAKE_CASE__				,							use_auth_token=self._token						)

       __a       =   ViTImageProcessor.from_pretrained(f'''{USER}/test-image-processor'''						)
       for k, v in image_processor.__dict__.items():
            self.assertEqual(SCREAMING_SNAKE_CASE__				,							getattr(SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__						)						)

  def __a						(					self     :							str						):





       '''simple docstring'''

       __a       =   ViTImageProcessor.from_pretrained(SCREAMING_SNAKE_CASE__						)
       image_processor.push_to_hub("""valid_org/test-image-processor"""				,							use_auth_token=self._token						)

       __a       =   ViTImageProcessor.from_pretrained("""valid_org/test-image-processor"""						)
       for k, v in image_processor.__dict__.items():
            self.assertEqual(SCREAMING_SNAKE_CASE__				,							getattr(SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__						)						)

       # Reset repo
       delete_repo(token=self._token				,							repo_id="""valid_org/test-image-processor"""						)

       # Push to hub via save_pretrained
       with tempfile.TemporaryDirectory() as tmp_dir:
            image_processor.save_pretrained(
                SCREAMING_SNAKE_CASE__				,							repo_id="""valid_org/test-image-processor-org"""				,							push_to_hub=SCREAMING_SNAKE_CASE__				,							use_auth_token=self._token						)

       __a       =   ViTImageProcessor.from_pretrained("""valid_org/test-image-processor-org"""						)
       for k, v in image_processor.__dict__.items():
            self.assertEqual(SCREAMING_SNAKE_CASE__				,							getattr(SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__						)						)


  def __a						(					self     :							List[str]						):





       '''simple docstring'''

       CustomImageProcessor.register_for_auto_class()
       __a       =   CustomImageProcessor.from_pretrained(SCREAMING_SNAKE_CASE__						)

       image_processor.push_to_hub("""test-dynamic-image-processor"""				,							use_auth_token=self._token						)

       # This has added the proper auto_map field to the config
       self.assertDictEqual(
           image_processor.auto_map				,							{"""AutoImageProcessor""": """custom_image_processing.CustomImageProcessor"""}				,							)

       __a       =   AutoImageProcessor.from_pretrained(
           f'''{USER}/test-dynamic-image-processor'''				,							trust_remote_code=SCREAMING_SNAKE_CASE__						)
       # Can't make an isinstance check because the new_image_processor is from the CustomImageProcessor class of a dynamic module
       self.assertEqual(new_image_processor.__class__.__name__				,							"""CustomImageProcessor"""						)










'''simple docstring'''







import numpy

# List of input, output pairs
SCREAMING_SNAKE_CASE_      =			(
    ((5, 2, 3), 15),
    ((6, 5, 9), 25),
    ((11, 12, 13), 41),
    ((1, 1, 1), 8),
    ((11, 12, 13), 41),
)
SCREAMING_SNAKE_CASE_      =			(((5_15, 22, 13), 5_55), ((61, 35, 49), 1_50))
SCREAMING_SNAKE_CASE_      =			[2, 4, 1, 5]
SCREAMING_SNAKE_CASE_      =			len(train_data)
SCREAMING_SNAKE_CASE_      =			0.0_0_9




def        __lowercase						(      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE="train"		)				->					Optional[int]:
     """simple docstring"""




     return calculate_hypothesis_value(__SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE		) - output(
         __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE		)




def        __lowercase						(      __SCREAMING_SNAKE_CASE		)				->					int:
     """simple docstring"""




     __a       =   0
     for i in range(len(__SCREAMING_SNAKE_CASE		) - 1		):
          hyp_val += data_input_tuple[i] * parameter_vector[i + 1]
     hyp_val += parameter_vector[0]
     return hyp_val




def        __lowercase						(      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE		)				->					Optional[int]:
     """simple docstring"""




     if data_set == "train":
          return train_data[example_no][1]
     elif data_set == "test":
          return test_data[example_no][1]
     return None




def        __lowercase						(      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE		)				->					Tuple:
     """simple docstring"""




     if data_set == "train":
          return _hypothesis_value(train_data[example_no][0]		)
     elif data_set == "test":
          return _hypothesis_value(test_data[example_no][0]		)
     return None




def        __lowercase						(      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE=m		)				->					Optional[Any]:
     """simple docstring"""




     __a       =   0
     for i in range(__SCREAMING_SNAKE_CASE		):
          if index == -1:
               summation_value += _error(__SCREAMING_SNAKE_CASE		)
          else:
               summation_value += _error(__SCREAMING_SNAKE_CASE		) * train_data[i][0][index]
     return summation_value




def        __lowercase						(      __SCREAMING_SNAKE_CASE		)				->					List[str]:
     """simple docstring"""




     __a       =   summation_of_cost_derivative(__SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE		) / m
     return cost_derivative_value




def        __lowercase						(      )				->					str:
     """simple docstring"""




     global parameter_vector
     # Tune these values to set a tolerance value for predicted output
     __a       =   0.000_002
     __a       =   0
     __a       =   0
     while True:
          j += 1
          __a       =   [0, 0, 0, 0]
          for i in range(0				,  len(__SCREAMING_SNAKE_CASE		)		):
               __a       =   get_cost_derivative(i - 1		)
               __a       =   (
                   parameter_vector[i] - LEARNING_RATE * cost_derivative
               )
          if numpy.allclose(
              __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE				,  atol=__SCREAMING_SNAKE_CASE				,  rtol=__SCREAMING_SNAKE_CASE				,  ):
               break
          __a       =   temp_parameter_vector
     print(("""Number of iterations:""", j)		)




def        __lowercase						(      )				->					List[Any]:
     """simple docstring"""




     for i in range(len(__SCREAMING_SNAKE_CASE		)		):
          print(("""Actual output value:""", output(__SCREAMING_SNAKE_CASE				,  """test"""		))		)
          print(("""Hypothesis output:""", calculate_hypothesis_value(__SCREAMING_SNAKE_CASE				,  """test"""		))		)


if __name__ == "__main__":
 run_gradient_descent()
 print('\nTesting gradient descent for a linear hypothesis function.\n')
 test_gradient_descent()






