


import inspect
import unittest

from datasets import load_dataset
from packaging import version

from transformers import BeitConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch
			from torch import nn

			from transformers import (
			    MODEL_MAPPING,
			    BeitForImageClassification,
			    BeitForMaskedImageModeling,
			    BeitForSemanticSegmentation,
			    BeitModel,
			)
			from transformers.models.beit.modeling_beit import BEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			import PIL
			from PIL import Image

			from transformers import BeitImageProcessor


class 	_a							:

							def __init__(							self:     Dict   ,						UpperCamelCase_:     Optional[Any]   ,						UpperCamelCase_:     Union[str, Any]=100   ,						UpperCamelCase_:     Any=13   ,						UpperCamelCase_:     Optional[int]=30   ,						UpperCamelCase_:     str=2   ,						UpperCamelCase_:     int=3   ,						UpperCamelCase_:     Optional[int]=True   ,						UpperCamelCase_:     int=True   ,						UpperCamelCase_:     Optional[Any]=32   ,						UpperCamelCase_:     str=4   ,						UpperCamelCase_:     List[Any]=4   ,						UpperCamelCase_:     Any=37   ,						UpperCamelCase_:     List[str]="gelu"   ,						UpperCamelCase_:     Optional[int]=0.1   ,						UpperCamelCase_:     int=0.1   ,						UpperCamelCase_:     Tuple=10   ,						UpperCamelCase_:     Any=0.02   ,						UpperCamelCase_:     Any=3   ,						UpperCamelCase_:     Tuple=None   ,						UpperCamelCase_:     str=[0, 1, 2, 3]   ,						)      ->       int:





									"""simple docstring"""







									lowercase__						=				parent
									lowercase__						=				100
									lowercase__						=				batch_size
									lowercase__						=				image_size
									lowercase__						=				patch_size
									lowercase__						=				num_channels
									lowercase__						=				is_training
									lowercase__						=				use_labels
									lowercase__						=				hidden_size
									lowercase__						=				num_hidden_layers
									lowercase__						=				num_attention_heads
									lowercase__						=				intermediate_size
									lowercase__						=				hidden_act
									lowercase__						=				hidden_dropout_prob
									lowercase__						=				attention_probs_dropout_prob
									lowercase__						=				type_sequence_label_size
									lowercase__						=				initializer_range
									lowercase__						=				scope
									lowercase__						=				out_indices
									lowercase__						=				num_labels

									# in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
									lowercase__						=				(image_size // patch_size) ** 2
									lowercase__						=				num_patches + 1

							def 				lowerCamelCase_			(							self:     Dict							)      ->       int:





									"""simple docstring"""







									lowercase__						=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

									lowercase__						=				None
									lowercase__						=				None
									if self.use_labels:
											lowercase__						=				ids_tensor([self.batch_size]   ,						self.type_sequence_label_size							)
											lowercase__						=				ids_tensor([self.batch_size, self.image_size, self.image_size]   ,						self.num_labels							)

									lowercase__						=				self.get_config()

									return config, pixel_values, labels, pixel_labels

							def 				lowerCamelCase_			(							self:     int							)      ->       str:





									"""simple docstring"""







									return BeitConfig(
									    vocab_size=self.vocab_size   ,						image_size=self.image_size   ,						patch_size=self.patch_size   ,						num_channels=self.num_channels   ,						hidden_size=self.hidden_size   ,						num_hidden_layers=self.num_hidden_layers   ,						num_attention_heads=self.num_attention_heads   ,						intermediate_size=self.intermediate_size   ,						hidden_act=self.hidden_act   ,						hidden_dropout_prob=self.hidden_dropout_prob   ,						attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,						is_decoder=UpperCamelCase_   ,						initializer_range=self.initializer_range   ,						out_indices=self.out_indices   ,						)

							def 				lowerCamelCase_			(							self:     str   ,						UpperCamelCase_:     Union[str, Any]   ,						UpperCamelCase_:     Union[str, Any]   ,						UpperCamelCase_:     Optional[int]   ,						UpperCamelCase_:     int							)      ->       List[str]:





									"""simple docstring"""







									lowercase__						=				BeitModel(config=UpperCamelCase_							)
									model.to(UpperCamelCase_							)
									model.eval()
									lowercase__						=				model(UpperCamelCase_							)
									self.parent.assertEqual(result.last_hidden_state.shape   ,						(self.batch_size, self.seq_length, self.hidden_size)							)

							def 				lowerCamelCase_			(							self:     List[str]   ,						UpperCamelCase_:     int   ,						UpperCamelCase_:     Optional[Any]   ,						UpperCamelCase_:     Union[str, Any]   ,						UpperCamelCase_:     Dict							)      ->       Any:





									"""simple docstring"""







									lowercase__						=				BeitForMaskedImageModeling(config=UpperCamelCase_							)
									model.to(UpperCamelCase_							)
									model.eval()
									lowercase__						=				model(UpperCamelCase_							)
									self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.seq_length - 1, self.vocab_size)							)

							def 				lowerCamelCase_			(							self:     Dict   ,						UpperCamelCase_:     List[Any]   ,						UpperCamelCase_:     str   ,						UpperCamelCase_:     Optional[int]   ,						UpperCamelCase_:     List[Any]							)      ->       List[Any]:





									"""simple docstring"""







									lowercase__						=				self.type_sequence_label_size
									lowercase__						=				BeitForImageClassification(UpperCamelCase_							)
									model.to(UpperCamelCase_							)
									model.eval()
									lowercase__						=				model(UpperCamelCase_   ,						labels=UpperCamelCase_							)
									self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.type_sequence_label_size)							)

									# test greyscale images
									lowercase__						=				1
									lowercase__						=				BeitForImageClassification(UpperCamelCase_							)
									model.to(UpperCamelCase_							)
									model.eval()

									lowercase__						=				floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
									lowercase__						=				model(UpperCamelCase_   ,						labels=UpperCamelCase_							)
									self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.type_sequence_label_size)							)

							def 				lowerCamelCase_			(							self:     str   ,						UpperCamelCase_:     Optional[int]   ,						UpperCamelCase_:     Dict   ,						UpperCamelCase_:     Optional[Any]   ,						UpperCamelCase_:     List[str]							)      ->       Optional[int]:





									"""simple docstring"""







									lowercase__						=				self.num_labels
									lowercase__						=				BeitForSemanticSegmentation(UpperCamelCase_							)
									model.to(UpperCamelCase_							)
									model.eval()
									lowercase__						=				model(UpperCamelCase_							)
									self.parent.assertEqual(
									    result.logits.shape   ,						(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)							)
									lowercase__						=				model(UpperCamelCase_   ,						labels=UpperCamelCase_							)
									self.parent.assertEqual(
									    result.logits.shape   ,						(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)							)


							def 				lowerCamelCase_			(							self:     Optional[int]							)      ->       List[str]:





									"""simple docstring"""







									lowercase__						=				self.prepare_config_and_inputs()
									lowercase__					,		lowercase__					,		lowercase__					,		lowercase__						=				config_and_inputs
									lowercase__						=				{'''pixel_values''': pixel_values}
									return config, inputs_dict


@require_torch
class 	_a							(      UpperCamelCase__					,     UpperCamelCase__					,     unittest.TestCase      ):
							_lowercase     :      Optional[Any]  				=			(
							    (BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
							    if is_torch_available()
							    else ()
							)
							_lowercase     :      int  				=			(
							    {
							        '''feature-extraction''': BeitModel,
							        '''image-classification''': BeitForImageClassification,
							        '''image-segmentation''': BeitForSemanticSegmentation,
							    }
							    if is_torch_available()
							    else {}
							)

							_lowercase     :      str  				=			False
							_lowercase     :      Dict  				=			False
							_lowercase     :      List[Any]  				=			False

							def 				lowerCamelCase_			(							self:     Optional[int]							)      ->       Any:





									"""simple docstring"""







									lowercase__						=				BeitModelTester(self							)
									lowercase__						=				ConfigTester(self   ,						config_class=UpperCamelCase_   ,						has_text_modality=UpperCamelCase_   ,						hidden_size=37							)

							def 				lowerCamelCase_			(							self:     List[Any]							)      ->       Optional[Any]:





									"""simple docstring"""







									self.config_tester.run_common_tests()

							@unittest.skip(reason='''BEiT does not use inputs_embeds'''							)
							def 				lowerCamelCase_			(							self:     List[Any]							)      ->       Optional[int]:





									"""simple docstring"""







									pass

							@require_torch_multi_gpu
							@unittest.skip(reason='''BEiT has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'''							)
							def 				lowerCamelCase_			(							self:     Dict							)      ->       List[Any]:





									"""simple docstring"""







									pass

							def 				lowerCamelCase_			(							self:     Optional[int]							)      ->       List[str]:





									"""simple docstring"""







									lowercase__					,		lowercase__						=				self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
											lowercase__						=				model_class(UpperCamelCase_							)
											self.assertIsInstance(model.get_input_embeddings()   ,						(nn.Module)							)
											lowercase__						=				model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(UpperCamelCase_   ,						nn.Linear							)							)

							def 				lowerCamelCase_			(							self:     List[str]							)      ->       Optional[Any]:





									"""simple docstring"""







									lowercase__					,		lowercase__						=				self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
											lowercase__						=				model_class(UpperCamelCase_							)
											lowercase__						=				inspect.signature(model.forward							)
											# signature.parameters is an OrderedDict => so arg_names order is deterministic
											lowercase__						=				[*signature.parameters.keys()]

											lowercase__						=				['''pixel_values''']
											self.assertListEqual(arg_names[:1]   ,						UpperCamelCase_							)

							def 				lowerCamelCase_			(							self:     Union[str, Any]							)      ->       List[Any]:





									"""simple docstring"""







									lowercase__						=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*UpperCamelCase_							)

							def 				lowerCamelCase_			(							self:     Optional[Any]							)      ->       List[Any]:





									"""simple docstring"""







									lowercase__						=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase_							)

							def 				lowerCamelCase_			(							self:     Dict							)      ->       int:





									"""simple docstring"""







									lowercase__						=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*UpperCamelCase_							)

							def 				lowerCamelCase_			(							self:     str							)      ->       Dict:





									"""simple docstring"""







									lowercase__						=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_semantic_segmentation(*UpperCamelCase_							)

							def 				lowerCamelCase_			(							self:     Optional[Any]							)      ->       Optional[Any]:





									"""simple docstring"""







									if not self.model_tester.is_training:
											return

									lowercase__					,		lowercase__						=				self.model_tester.prepare_config_and_inputs_for_common()
									lowercase__						=				True

									for model_class in self.all_model_classes:
											# we don't test BeitForMaskedImageModeling
											if model_class in [*get_values(UpperCamelCase_							), BeitForMaskedImageModeling]:
													continue

											lowercase__						=				model_class(UpperCamelCase_							)
											model.to(UpperCamelCase_							)
											model.train()
											lowercase__						=				self._prepare_for_class(UpperCamelCase_   ,						UpperCamelCase_   ,						return_labels=UpperCamelCase_							)
											lowercase__						=				model(**UpperCamelCase_							).loss
											loss.backward()

							def 				lowerCamelCase_			(							self:     List[str]							)      ->       List[Any]:





									"""simple docstring"""







									lowercase__					,		lowercase__						=				self.model_tester.prepare_config_and_inputs_for_common()
									if not self.model_tester.is_training:
											return

									lowercase__						=				False
									lowercase__						=				True

									for model_class in self.all_model_classes:
											# we don't test BeitForMaskedImageModeling
											if (
											    model_class in [*get_values(UpperCamelCase_							), BeitForMaskedImageModeling]
											    or not model_class.supports_gradient_checkpointing
											):
													continue

											lowercase__						=				model_class(UpperCamelCase_							)
											model.gradient_checkpointing_enable()
											model.to(UpperCamelCase_							)
											model.train()
											lowercase__						=				self._prepare_for_class(UpperCamelCase_   ,						UpperCamelCase_   ,						return_labels=UpperCamelCase_							)
											lowercase__						=				model(**UpperCamelCase_							).loss
											loss.backward()

							def 				lowerCamelCase_			(							self:     Optional[int]							)      ->       List[Any]:





									"""simple docstring"""







									lowercase__					,		lowercase__						=				self.model_tester.prepare_config_and_inputs_for_common()

									lowercase__						=				_config_zero_init(UpperCamelCase_							)
									for model_class in self.all_model_classes:
											lowercase__						=				model_class(config=UpperCamelCase_							)
											for name, param in model.named_parameters():
													# we skip lambda parameters as these require special initial values
													# determined by config.layer_scale_init_value
													if "lambda" in name:
															continue
													if param.requires_grad:
															self.assertIn(
															    ((param.data.mean() * 1E9).round() / 1E9).item()   ,						[0.0, 1.0]   ,						msg=f'Parameter {name} of model {model_class} seems not properly initialized'   ,						)


							@slow
							def 				lowerCamelCase_			(							self:     Optional[Any]							)      ->       int:





									"""simple docstring"""







									for model_name in BEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											lowercase__						=				BeitModel.from_pretrained(UpperCamelCase_							)
											self.assertIsNotNone(UpperCamelCase_							)
def       _a			(				):


		"""simple docstring"""




		lowercase__						=				Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''					)
		return image


@require_torch
@require_vision
class 	_a							(      unittest.TestCase      ):

							@cached_property
							def 				lowerCamelCase_			(							self:     List[Any]							)      ->       Union[str, Any]:





									"""simple docstring"""







									return BeitImageProcessor.from_pretrained('''microsoft/beit-base-patch16-224'''							) if is_vision_available() else None

							@slow
							def 				lowerCamelCase_			(							self:     Union[str, Any]							)      ->       List[Any]:





									"""simple docstring"""







									lowercase__						=				BeitForMaskedImageModeling.from_pretrained('''microsoft/beit-base-patch16-224-pt22k'''							).to(UpperCamelCase_							)

									lowercase__						=				self.default_image_processor
									lowercase__						=				prepare_img()
									lowercase__						=				image_processor(images=UpperCamelCase_   ,						return_tensors='''pt'''							).pixel_values.to(UpperCamelCase_							)

									# prepare bool_masked_pos
									lowercase__						=				torch.ones((1, 196)   ,						dtype=torch.bool							).to(UpperCamelCase_							)

									# forward pass
									with torch.no_grad():
											lowercase__						=				model(pixel_values=UpperCamelCase_   ,						bool_masked_pos=UpperCamelCase_							)
									lowercase__						=				outputs.logits

									# verify the logits
									lowercase__						=				torch.Size((1, 196, 8_192)							)
									self.assertEqual(logits.shape   ,						UpperCamelCase_							)

									lowercase__						=				torch.tensor(
									    [[-3.2437, 0.5072, -13.9174], [-3.2456, 0.4948, -13.9401], [-3.2033, 0.5121, -13.8550]]							).to(UpperCamelCase_							)

									self.assertTrue(torch.allclose(logits[bool_masked_pos][:3, :3]   ,						UpperCamelCase_   ,						atol=1E-2							)							)

							@slow
							def 				lowerCamelCase_			(							self:     List[str]							)      ->       Tuple:





									"""simple docstring"""







									lowercase__						=				BeitForImageClassification.from_pretrained('''microsoft/beit-base-patch16-224'''							).to(UpperCamelCase_							)

									lowercase__						=				self.default_image_processor
									lowercase__						=				prepare_img()
									lowercase__						=				image_processor(images=UpperCamelCase_   ,						return_tensors='''pt'''							).to(UpperCamelCase_							)

									# forward pass
									with torch.no_grad():
											lowercase__						=				model(**UpperCamelCase_							)
									lowercase__						=				outputs.logits

									# verify the logits
									lowercase__						=				torch.Size((1, 1_000)							)
									self.assertEqual(logits.shape   ,						UpperCamelCase_							)

									lowercase__						=				torch.tensor([-1.2385, -1.0987, -1.0108]							).to(UpperCamelCase_							)

									self.assertTrue(torch.allclose(logits[0, :3]   ,						UpperCamelCase_   ,						atol=1E-4							)							)

									lowercase__						=				281
									self.assertEqual(logits.argmax(-1							).item()   ,						UpperCamelCase_							)

							@slow
							def 				lowerCamelCase_			(							self:     List[str]							)      ->       Optional[int]:





									"""simple docstring"""







									lowercase__						=				BeitForImageClassification.from_pretrained('''microsoft/beit-large-patch16-224-pt22k-ft22k'''							).to(
									    UpperCamelCase_							)

									lowercase__						=				self.default_image_processor
									lowercase__						=				prepare_img()
									lowercase__						=				image_processor(images=UpperCamelCase_   ,						return_tensors='''pt'''							).to(UpperCamelCase_							)

									# forward pass
									with torch.no_grad():
											lowercase__						=				model(**UpperCamelCase_							)
									lowercase__						=				outputs.logits

									# verify the logits
									lowercase__						=				torch.Size((1, 21_841)							)
									self.assertEqual(logits.shape   ,						UpperCamelCase_							)

									lowercase__						=				torch.tensor([1.6881, -0.2787, 0.5901]							).to(UpperCamelCase_							)

									self.assertTrue(torch.allclose(logits[0, :3]   ,						UpperCamelCase_   ,						atol=1E-4							)							)

									lowercase__						=				2_396
									self.assertEqual(logits.argmax(-1							).item()   ,						UpperCamelCase_							)

							@slow
							def 				lowerCamelCase_			(							self:     Optional[Any]							)      ->       Optional[int]:





									"""simple docstring"""







									lowercase__						=				BeitForSemanticSegmentation.from_pretrained('''microsoft/beit-base-finetuned-ade-640-640'''							)
									lowercase__						=				model.to(UpperCamelCase_							)

									lowercase__						=				BeitImageProcessor(do_resize=UpperCamelCase_   ,						size=640   ,						do_center_crop=UpperCamelCase_							)

									lowercase__						=				load_dataset('''hf-internal-testing/fixtures_ade20k'''   ,						split='''test'''							)
									lowercase__						=				Image.open(ds[0]['''file''']							)
									lowercase__						=				image_processor(images=UpperCamelCase_   ,						return_tensors='''pt'''							).to(UpperCamelCase_							)

									# forward pass
									with torch.no_grad():
											lowercase__						=				model(**UpperCamelCase_							)
									lowercase__						=				outputs.logits

									# verify the logits
									lowercase__						=				torch.Size((1, 150, 160, 160)							)
									self.assertEqual(logits.shape   ,						UpperCamelCase_							)

									lowercase__						=				version.parse(PIL.__version__							) < version.parse('''9.0.0'''							)

									if is_pillow_less_than_a:
											lowercase__						=				torch.tensor(
											    [
											        [[-4.9225, -2.3954, -3.0522], [-2.8822, -1.0046, -1.7561], [-2.9549, -1.3228, -2.1347]],
											        [[-5.8168, -3.4129, -4.0778], [-3.8651, -2.2214, -3.0277], [-3.8356, -2.4643, -3.3535]],
											        [[-0.0078, 3.9952, 4.0754], [2.9856, 4.6944, 5.0035], [3.2413, 4.7813, 4.9969]],
											    ]   ,						device=UpperCamelCase_   ,						)
									else:
											lowercase__						=				torch.tensor(
											    [
											        [[-4.8960, -2.3688, -3.0355], [-2.8478, -0.9836, -1.7418], [-2.9449, -1.3332, -2.1456]],
											        [[-5.8081, -3.4124, -4.1006], [-3.8561, -2.2081, -3.0323], [-3.8365, -2.4601, -3.3669]],
											        [[-0.0309, 3.9868, 4.0540], [2.9640, 4.6877, 4.9976], [3.2081, 4.7690, 4.9942]],
											    ]   ,						device=UpperCamelCase_   ,						)

									self.assertTrue(torch.allclose(logits[0, :3, :3, :3]   ,						UpperCamelCase_   ,						atol=1E-4							)							)


							@slow
							def 				lowerCamelCase_			(							self:     Optional[Any]							)      ->       List[Any]:





									"""simple docstring"""







									lowercase__						=				BeitForSemanticSegmentation.from_pretrained('''microsoft/beit-base-finetuned-ade-640-640'''							)
									lowercase__						=				model.to(UpperCamelCase_							)

									lowercase__						=				BeitImageProcessor(do_resize=UpperCamelCase_   ,						size=640   ,						do_center_crop=UpperCamelCase_							)

									lowercase__						=				load_dataset('''hf-internal-testing/fixtures_ade20k'''   ,						split='''test'''							)
									lowercase__						=				Image.open(ds[0]['''file''']							)
									lowercase__						=				image_processor(images=UpperCamelCase_   ,						return_tensors='''pt'''							).to(UpperCamelCase_							)

									# forward pass
									with torch.no_grad():
											lowercase__						=				model(**UpperCamelCase_							)

									lowercase__						=				outputs.logits.detach().cpu()

									lowercase__						=				image_processor.post_process_semantic_segmentation(outputs=UpperCamelCase_   ,						target_sizes=[(500, 300)]							)
									lowercase__						=				torch.Size((500, 300)							)
									self.assertEqual(segmentation[0].shape   ,						UpperCamelCase_							)

									lowercase__						=				image_processor.post_process_semantic_segmentation(outputs=UpperCamelCase_							)
									lowercase__						=				torch.Size((160, 160)							)
									self.assertEqual(segmentation[0].shape   ,						UpperCamelCase_							)






import math_equivalence  # From: git+https://github.com/hendrycks/math.git

import datasets


lowerCAmelCase	=							'\\n@article{hendrycksmath2021,\n  title={Measuring Mathematical Problem Solving With the MATH Dataset},\n  author={Dan Hendrycks\n    and Collin Burns\n    and Saurav Kadavath\n    and Akul Arora\n    and Steven Basart\n    and Eric Tang\n    and Dawn Song\n    and Jacob Steinhardt},\n  journal={arXiv preprint arXiv:2103.03874},\n  year={2021}\n}\n'


lowerCAmelCase	=							'\\nThis metric is used to assess performance on the Mathematics Aptitude Test of Heuristics (MATH) dataset.\nIt first canonicalizes the inputs (e.g., converting "1/2" to "\\frac{1}{2}") and then computes accuracy.\n'


lowerCAmelCase	=							R'\nCalculates accuracy after canonicalizing inputs.\n\nArgs:\n    predictions: list of predictions to score. Each prediction\n        is a string that contains natural language and LaTex.\n    references: list of reference for each prediction. Each\n        reference is a string that contains natural language\n        and LaTex.\nReturns:\n    accuracy: accuracy after canonicalizing inputs\n        (e.g., converting "1/2" to "\\frac{1}{2}")\n\nExamples:\n    >>> metric = datasets.load_metric("competition_math")\n    >>> results = metric.compute(references=["\\frac{1}{2}"], predictions=["1/2"])\n    >>> print(results)\n    {\'accuracy\': 1.0}\n'


@datasets.utils.file_utils.add_end_docstrings(_DESCRIPTION					,     _KWARGS_DESCRIPTION      )
class 	_a							(      datasets.Metric      ):

							def 				lowerCamelCase_			(							self:     List[str]							)      ->       Tuple:





									"""simple docstring"""







									return datasets.MetricInfo(
									    description=_DESCRIPTION   ,						citation=_CITATION   ,						inputs_description=_KWARGS_DESCRIPTION   ,						features=datasets.Features(
									        {
									            '''predictions''': datasets.Value('''string'''							),
									            '''references''': datasets.Value('''string'''							),
									        }							)   ,						homepage='''https://github.com/hendrycks/math'''   ,						codebase_urls=['''https://github.com/hendrycks/math''']   ,						)


							def 				lowerCamelCase_			(							self:     Union[str, Any]   ,						UpperCamelCase_:     Any   ,						UpperCamelCase_:     int							)      ->       List[str]:





									"""simple docstring"""







									lowercase__						=				0.0
									for i, j in zip(UpperCamelCase_   ,						UpperCamelCase_							):
											n_correct += 1.0 if math_equivalence.is_equiv(UpperCamelCase_   ,						UpperCamelCase_							) else 0.0
									lowercase__						=				n_correct / len(UpperCamelCase_							)
									return {
									    "accuracy": accuracy,
									}


