
'''simple docstring'''







import inspect
import unittest

from transformers import DataaVecVisionConfig
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,
							    DataaVecVisionForImageClassification,
							    DataaVecVisionForSemanticSegmentation,
							    DataaVecVisionModel,
							)
							from transformers.models.dataavec.modeling_dataavec_vision import DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import BeitImageProcessor






class 					lowerCAmelCase__  :






					def __init__(  self							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE=1_00							,				__SCREAMING_SNAKE_CASE=13							,				__SCREAMING_SNAKE_CASE=30							,				__SCREAMING_SNAKE_CASE=2							,				__SCREAMING_SNAKE_CASE=3							,				__SCREAMING_SNAKE_CASE=True							,				__SCREAMING_SNAKE_CASE=True							,				__SCREAMING_SNAKE_CASE=32							,				__SCREAMING_SNAKE_CASE=4							,				__SCREAMING_SNAKE_CASE=4							,				__SCREAMING_SNAKE_CASE=37							,				__SCREAMING_SNAKE_CASE="gelu"							,				__SCREAMING_SNAKE_CASE=0.1							,				__SCREAMING_SNAKE_CASE=0.1							,				__SCREAMING_SNAKE_CASE=10							,				__SCREAMING_SNAKE_CASE=0.02							,				__SCREAMING_SNAKE_CASE=3							,				__SCREAMING_SNAKE_CASE=None							,				__SCREAMING_SNAKE_CASE=[0, 1, 2, 3]							,				):


											"""simple docstring"""





											lowercase_      :	str						=			parent
											lowercase_      :	List[str]						=			1_00
											lowercase_      :	str						=			batch_size
											lowercase_      :	List[Any]						=			image_size
											lowercase_      :	Dict						=			patch_size
											lowercase_      :	Optional[Any]						=			num_channels
											lowercase_      :	List[Any]						=			is_training
											lowercase_      :	int						=			use_labels
											lowercase_      :	str						=			hidden_size
											lowercase_      :	Dict						=			num_hidden_layers
											lowercase_      :	str						=			num_attention_heads
											lowercase_      :	Tuple						=			intermediate_size
											lowercase_      :	Optional[int]						=			hidden_act
											lowercase_      :	Tuple						=			hidden_dropout_prob
											lowercase_      :	Any						=			attention_probs_dropout_prob
											lowercase_      :	Optional[int]						=			type_sequence_label_size
											lowercase_      :	List[Any]						=			initializer_range
											lowercase_      :	Optional[Any]						=			scope
											lowercase_      :	Dict						=			out_indices
											lowercase_      :	int						=			num_labels

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






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	List[str]						=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

											lowercase_      :	Optional[int]						=			None
											lowercase_      :	Optional[int]						=			None
											if self.use_labels:
																	lowercase_      :	str						=			ids_tensor([self.batch_size]							,				self.type_sequence_label_size						)
																	lowercase_      :	Any						=			ids_tensor([self.batch_size, self.image_size, self.image_size]							,				self.num_labels						)

											lowercase_      :	List[Any]						=			self.get_config()

											return config, pixel_values, labels, pixel_labels






					def       _snake_case       (  self						):


											"""simple docstring"""





											return DataaVecVisionConfig(
											    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=__SCREAMING_SNAKE_CASE							,				initializer_range=self.initializer_range							,				out_indices=self.out_indices							,				)






					def       _snake_case       (  self							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						):


											"""simple docstring"""





											lowercase_      :	Dict						=			DataaVecVisionModel(config=__SCREAMING_SNAKE_CASE						)
											model.to(__SCREAMING_SNAKE_CASE						)
											model.eval()
											lowercase_      :	List[Any]						=			model(__SCREAMING_SNAKE_CASE						)
											# expected sequence length = num_patches + 1 (we add 1 for the [CLS] token)
											lowercase_      :	Any						=			(self.image_size // self.patch_size) ** 2
											self.parent.assertEqual(result.last_hidden_state.shape							,				(self.batch_size, num_patches + 1, self.hidden_size)						)






					def       _snake_case       (  self							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						):


											"""simple docstring"""





											lowercase_      :	Tuple						=			self.type_sequence_label_size
											lowercase_      :	Optional[Any]						=			DataaVecVisionForImageClassification(__SCREAMING_SNAKE_CASE						)
											model.to(__SCREAMING_SNAKE_CASE						)
											model.eval()
											lowercase_      :	Any						=			model(__SCREAMING_SNAKE_CASE							,				labels=__SCREAMING_SNAKE_CASE						)
											self.parent.assertEqual(result.logits.shape							,				(self.batch_size, self.type_sequence_label_size)						)






					def       _snake_case       (  self							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						):


											"""simple docstring"""





											lowercase_      :	Optional[Any]						=			self.num_labels
											lowercase_      :	Optional[Any]						=			DataaVecVisionForSemanticSegmentation(__SCREAMING_SNAKE_CASE						)
											model.to(__SCREAMING_SNAKE_CASE						)
											model.eval()
											lowercase_      :	Optional[int]						=			model(__SCREAMING_SNAKE_CASE						)
											self.parent.assertEqual(
											    result.logits.shape							,				(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)						)
											lowercase_      :	int						=			model(__SCREAMING_SNAKE_CASE							,				labels=__SCREAMING_SNAKE_CASE						)
											self.parent.assertEqual(
											    result.logits.shape							,				(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)						)






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	Optional[Any]						=			self.prepare_config_and_inputs()
											lowercase_		,					lowercase_		,					lowercase_		,					lowercase_      :	Optional[int]						=			config_and_inputs
											lowercase_      :	List[Any]						=			{'''pixel_values''': pixel_values}
											return config, inputs_dict







@require_torch
class 					lowerCAmelCase__  (    lowerCamelCase_       ,		lowerCamelCase_       ,		unittest.TestCase	):
					lowerCAmelCase_	  =	(
					    (DataaVecVisionModel, DataaVecVisionForImageClassification, DataaVecVisionForSemanticSegmentation)
					    if is_torch_available()
					    else ()
					)
					lowerCAmelCase_	  =	(
					    {
					        '''feature-extraction''': DataaVecVisionModel,
					        '''image-classification''': DataaVecVisionForImageClassification,
					        '''image-segmentation''': DataaVecVisionForSemanticSegmentation,
					    }
					    if is_torch_available()
					    else {}
					)

					lowerCAmelCase_	  =	False
					lowerCAmelCase_	  =	False
					lowerCAmelCase_	  =	False






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	List[str]						=			DataaVecVisionModelTester(self						)
											lowercase_      :	List[Any]						=			ConfigTester(
											    self							,				config_class=__SCREAMING_SNAKE_CASE							,				has_text_modality=__SCREAMING_SNAKE_CASE							,				hidden_size=37						)






					def       _snake_case       (  self						):


											"""simple docstring"""





											self.config_tester.run_common_tests()






					def       _snake_case       (  self						):


											"""simple docstring"""





											pass






					@require_torch_multi_gpu
					@unittest.skip(
					    reason='''Data2VecVision has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'''						)
					def       _snake_case       (  self						):


											"""simple docstring"""





											pass






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_		,					lowercase_      :	Any						=			self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																	lowercase_      :	Optional[int]						=			model_class(__SCREAMING_SNAKE_CASE						)
																	self.assertIsInstance(model.get_input_embeddings()							,				(nn.Module)						)
																	lowercase_      :	List[Any]						=			model.get_output_embeddings()
																	self.assertTrue(x is None or isinstance(__SCREAMING_SNAKE_CASE							,				nn.Linear						)						)






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_		,					lowercase_      :	Tuple						=			self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																	lowercase_      :	int						=			model_class(__SCREAMING_SNAKE_CASE						)
																	lowercase_      :	List[str]						=			inspect.signature(model.forward						)
																	# signature.parameters is an OrderedDict => so arg_names order is deterministic
																	lowercase_      :	List[Any]						=			[*signature.parameters.keys()]

																	lowercase_      :	Tuple						=			['''pixel_values''']
																	self.assertListEqual(arg_names[:1]							,				__SCREAMING_SNAKE_CASE						)






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	Dict						=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE						)






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	List[Any]						=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_segmentation(*__SCREAMING_SNAKE_CASE						)






					def       _snake_case       (  self						):


											"""simple docstring"""





											if not self.model_tester.is_training:
																	return

											lowercase_		,					lowercase_      :	Tuple						=			self.model_tester.prepare_config_and_inputs_for_common()
											lowercase_      :	Tuple						=			True

											for model_class in self.all_model_classes:
																	if model_class in [*get_values(__SCREAMING_SNAKE_CASE						)]:
																							continue

																	lowercase_      :	List[Any]						=			model_class(__SCREAMING_SNAKE_CASE						)
																	model.to(__SCREAMING_SNAKE_CASE						)
																	model.train()
																	lowercase_      :	str						=			self._prepare_for_class(__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				return_labels=__SCREAMING_SNAKE_CASE						)
																	lowercase_      :	Optional[int]						=			model(**__SCREAMING_SNAKE_CASE						).loss
																	loss.backward()






					def       _snake_case       (  self						):


											"""simple docstring"""





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

											lowercase_      :	List[Any]						=			False
											lowercase_      :	Dict						=			True

											for model_class in self.all_model_classes:
																	if model_class in [*get_values(__SCREAMING_SNAKE_CASE						)] or not model_class.supports_gradient_checkpointing:
																							continue
																	# TODO: remove the following 3 lines once we have a MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING
																	# this can then be incorporated into _prepare_for_class in test_modeling_common.py
																	elif model_class.__name__ == "Data2VecVisionForSemanticSegmentation":
																							lowercase_		,					lowercase_		,					lowercase_		,					lowercase_      :	Optional[Any]						=			inputs_dict['''pixel_values'''].shape
																							lowercase_      :	int						=			torch.zeros(
																							    [self.model_tester.batch_size, height, width]							,				device=__SCREAMING_SNAKE_CASE						).long()
																	lowercase_      :	List[Any]						=			model_class(__SCREAMING_SNAKE_CASE						)
																	model.gradient_checkpointing_enable()
																	model.to(__SCREAMING_SNAKE_CASE						)
																	model.train()
																	lowercase_      :	Dict						=			self._prepare_for_class(__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				return_labels=__SCREAMING_SNAKE_CASE						)
																	lowercase_      :	str						=			model(**__SCREAMING_SNAKE_CASE						).loss
																	loss.backward()






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_		,					lowercase_      :	List[Any]						=			self.model_tester.prepare_config_and_inputs_for_common()

											lowercase_      :	List[str]						=			_config_zero_init(__SCREAMING_SNAKE_CASE						)
											for model_class in self.all_model_classes:
																	lowercase_      :	Union[str, Any]						=			model_class(config=__SCREAMING_SNAKE_CASE						)
																	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'''							,				)






					def       _snake_case       (  self							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE=2E-4							,				__SCREAMING_SNAKE_CASE="outputs"							,				__SCREAMING_SNAKE_CASE=None						):


											"""simple docstring"""





											super().check_pt_tf_outputs(__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						)






					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	str						=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE						)






					@slow
					def       _snake_case       (  self						):


											"""simple docstring"""





											for model_name in DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	lowercase_      :	int						=			DataaVecVisionModel.from_pretrained(__SCREAMING_SNAKE_CASE						)
																	self.assertIsNotNone(__SCREAMING_SNAKE_CASE						)







def    snake_case_						(							):



						"""simple docstring"""





						lowercase_      :	Optional[int]						=			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
						return image






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






					@cached_property
					def       _snake_case       (  self						):


											"""simple docstring"""





											return (
											    BeitImageProcessor.from_pretrained('''facebook/data2vec-vision-base-ft1k'''						) if is_vision_available() else None
											)






					@slow
					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	Optional[int]						=			DataaVecVisionForImageClassification.from_pretrained('''facebook/data2vec-vision-base-ft1k'''						).to(
											    __SCREAMING_SNAKE_CASE						)

											lowercase_      :	Dict						=			self.default_image_processor
											lowercase_      :	Union[str, Any]						=			prepare_img()
											lowercase_      :	List[str]						=			image_processor(images=__SCREAMING_SNAKE_CASE							,				return_tensors='''pt'''						).to(__SCREAMING_SNAKE_CASE						)

											# forward pass
											with torch.no_grad():
																	lowercase_      :	Tuple						=			model(**__SCREAMING_SNAKE_CASE						)
											lowercase_      :	List[str]						=			outputs.logits

											# verify the logits
											lowercase_      :	List[str]						=			torch.Size((1, 10_00)						)
											self.assertEqual(logits.shape							,				__SCREAMING_SNAKE_CASE						)

											lowercase_      :	Union[str, Any]						=			torch.tensor([0.3_277, -0.1_395, 0.0_911]						).to(__SCREAMING_SNAKE_CASE						)

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

											lowercase_      :	Union[str, Any]						=			[model.config.labelaid[i] for i in ['''remote control, remote''', '''tabby, tabby cat''']]
											self.assertEqual(logits[0].topk(2						).indices.cpu().tolist()							,				__SCREAMING_SNAKE_CASE						)





'''simple docstring'''







import importlib
from typing import List, Optional, Union

from seqeval.metrics import accuracy_score, classification_report

import datasets


_lowercase					:    Optional[int]       				=			"\\n@inproceedings{ramshaw-marcus-1995-text,\n    title = \"Text Chunking using Transformation-Based Learning\",\n    author = \"Ramshaw, Lance  and\n      Marcus, Mitch\",\n    booktitle = \"Third Workshop on Very Large Corpora\",\n    year = \"1995\",\n    url = \"https://www.aclweb.org/anthology/W95-0107\",\n}\n@misc{seqeval,\n  title={{seqeval}: A Python framework for sequence labeling evaluation},\n  url={https://github.com/chakki-works/seqeval},\n  note={Software available from https://github.com/chakki-works/seqeval},\n  author={Hiroki Nakayama},\n  year={2018},\n}\n"

_lowercase					:    List[Any]       				=			"\\nseqeval is a Python framework for sequence labeling evaluation.\nseqeval can evaluate the performance of chunking tasks such as named-entity recognition, part-of-speech tagging, semantic role labeling and so on.\n\nThis is well-tested by using the Perl script conlleval, which can be used for\nmeasuring the performance of a system that has processed the CoNLL-2000 shared task data.\n\nseqeval supports following formats:\nIOB1\nIOB2\nIOE1\nIOE2\nIOBES\n\nSee the [README.md] file at https://github.com/chakki-works/seqeval for more information.\n"

_lowercase					:    int       				=			"\nProduces labelling scores along with its sufficient statistics\nfrom a source against one or more references.\n\nArgs:\n    predictions: List of List of predicted labels (Estimated targets as returned by a tagger)\n    references: List of List of reference labels (Ground truth (correct) target values)\n    suffix: True if the IOB prefix is after type, False otherwise. default: False\n    scheme: Specify target tagging scheme. Should be one of [\"IOB1\", \"IOB2\", \"IOE1\", \"IOE2\", \"IOBES\", \"BILOU\"].\n        default: None\n    mode: Whether to count correct entity labels with incorrect I/B tags as true positives or not.\n        If you want to only count exact matches, pass mode=\"strict\". default: None.\n    sample_weight: Array-like of shape (n_samples,), weights for individual samples. default: None\n    zero_division: Which value to substitute as a metric value when encountering zero division. Should be on of 0, 1,\n        \"warn\". \"warn\" acts as 0, but the warning is raised.\n\nReturns:\n    'scores': dict. Summary of the scores for overall and per type\n        Overall:\n            'accuracy': accuracy,\n            'precision': precision,\n            'recall': recall,\n            'f1': F1 score, also known as balanced F-score or F-measure,\n        Per type:\n            'precision': precision,\n            'recall': recall,\n            'f1': F1 score, also known as balanced F-score or F-measure\nExamples:\n\n    >>> predictions = [['O', 'O', 'B-MISC', 'I-MISC', 'I-MISC', 'I-MISC', 'O'], ['B-PER', 'I-PER', 'O']]\n    >>> references = [['O', 'O', 'O', 'B-MISC', 'I-MISC', 'I-MISC', 'O'], ['B-PER', 'I-PER', 'O']]\n    >>> seqeval = datasets.load_metric(\"seqeval\")\n    >>> results = seqeval.compute(predictions=predictions, references=references)\n    >>> print(list(results.keys()))\n    ['MISC', 'PER', 'overall_precision', 'overall_recall', 'overall_f1', 'overall_accuracy']\n    >>> print(results[\"overall_f1\"])\n    0.5\n    >>> print(results[\"PER\"][\"f1\"])\n    1.0\n"






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION       ,		_KWARGS_DESCRIPTION	)
class 					lowerCAmelCase__  (    datasets.Metric	):






					def       _snake_case       (  self						):


											"""simple docstring"""





											return datasets.MetricInfo(
											    description=_DESCRIPTION							,				citation=_CITATION							,				homepage='''https://github.com/chakki-works/seqeval'''							,				inputs_description=_KWARGS_DESCRIPTION							,				features=datasets.Features(
											        {
											            '''predictions''': datasets.Sequence(datasets.Value('''string'''							,				id='''label'''						)							,				id='''sequence'''						),
											            '''references''': datasets.Sequence(datasets.Value('''string'''							,				id='''label'''						)							,				id='''sequence'''						),
											        }						)							,				codebase_urls=['''https://github.com/chakki-works/seqeval''']							,				reference_urls=['''https://github.com/chakki-works/seqeval''']							,				)






					def       _snake_case       (  self							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE = False							,				__SCREAMING_SNAKE_CASE = None							,				__SCREAMING_SNAKE_CASE = None							,				__SCREAMING_SNAKE_CASE = None							,				__SCREAMING_SNAKE_CASE = "warn"							,				):


											"""simple docstring"""





											if scheme is not None:
																	try:
																							lowercase_      :	List[str]						=			importlib.import_module('''seqeval.scheme'''						)
																							lowercase_      :	int						=			getattr(__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						)
																	except AttributeError:
																							raise ValueError(F'''Scheme should be one of [IOB1, IOB2, IOE1, IOE2, IOBES, BILOU], got {scheme}'''						)
											lowercase_      :	List[Any]						=			classification_report(
											    y_true=__SCREAMING_SNAKE_CASE							,				y_pred=__SCREAMING_SNAKE_CASE							,				suffix=__SCREAMING_SNAKE_CASE							,				output_dict=__SCREAMING_SNAKE_CASE							,				scheme=__SCREAMING_SNAKE_CASE							,				mode=__SCREAMING_SNAKE_CASE							,				sample_weight=__SCREAMING_SNAKE_CASE							,				zero_division=__SCREAMING_SNAKE_CASE							,				)
											report.pop('''macro avg'''						)
											report.pop('''weighted avg'''						)
											lowercase_      :	int						=			report.pop('''micro avg'''						)

											lowercase_      :	List[Any]						=			{
											    type_name: {
											        '''precision''': score['''precision'''],
											        '''recall''': score['''recall'''],
											        '''f1''': score['''f1-score'''],
											        '''number''': score['''support'''],
											    }
											    for type_name, score in report.items()
											}
											lowercase_      :	Optional[Any]						=			overall_score['''precision''']
											lowercase_      :	Optional[Any]						=			overall_score['''recall''']
											lowercase_      :	Optional[int]						=			overall_score['''f1-score''']
											lowercase_      :	Optional[int]						=			accuracy_score(y_true=__SCREAMING_SNAKE_CASE							,				y_pred=__SCREAMING_SNAKE_CASE						)

											return scores



