
'''simple docstring'''





import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import VideoMAEConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, 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, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch
			from torch import nn

			from transformers import (
			    MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
			    VideoMAEForPreTraining,
			    VideoMAEForVideoClassification,
			    VideoMAEModel,
			)
			from transformers.models.videomae.modeling_videomae import VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			from transformers import VideoMAEImageProcessor





class 			_lowerCAmelCase      :




				def __init__(      self       ,       _UpperCamelCase       ,       _UpperCamelCase=13       ,       _UpperCamelCase=10       ,       _UpperCamelCase=3       ,       _UpperCamelCase=2       ,       _UpperCamelCase=2       ,       _UpperCamelCase=2       ,       _UpperCamelCase=True       ,       _UpperCamelCase=True       ,       _UpperCamelCase=32       ,       _UpperCamelCase=5       ,       _UpperCamelCase=4       ,       _UpperCamelCase=37       ,       _UpperCamelCase="gelu"       ,       _UpperCamelCase=0.1       ,       _UpperCamelCase=0.1       ,       _UpperCamelCase=10       ,       _UpperCamelCase=0.02       ,       _UpperCamelCase=0.9       ,       _UpperCamelCase=None       ,       )       ->   Dict:
							lowerCAmelCase_      			=			parent
							lowerCAmelCase_      			=			batch_size
							lowerCAmelCase_      			=			image_size
							lowerCAmelCase_      			=			num_channels
							lowerCAmelCase_      			=			patch_size
							lowerCAmelCase_      			=			tubelet_size
							lowerCAmelCase_      			=			num_frames
							lowerCAmelCase_      			=			is_training
							lowerCAmelCase_      			=			use_labels
							lowerCAmelCase_      			=			hidden_size
							lowerCAmelCase_      			=			num_hidden_layers
							lowerCAmelCase_      			=			num_attention_heads
							lowerCAmelCase_      			=			intermediate_size
							lowerCAmelCase_      			=			hidden_act
							lowerCAmelCase_      			=			hidden_dropout_prob
							lowerCAmelCase_      			=			attention_probs_dropout_prob
							lowerCAmelCase_      			=			type_sequence_label_size
							lowerCAmelCase_      			=			initializer_range
							lowerCAmelCase_      			=			mask_ratio
							lowerCAmelCase_      			=			scope

							# in VideoMAE, the number of tokens equals num_frames/tubelet_size * num_patches per frame
							lowerCAmelCase_      			=			(image_size // patch_size) ** 2
							lowerCAmelCase_      			=			(num_frames // tubelet_size) * self.num_patches_per_frame

							# use this variable to define bool_masked_pos
							lowerCAmelCase_      			=			int(mask_ratio * self.seq_length  )




				def   __a		(      self  )       ->   Dict:
							lowerCAmelCase_      			=			floats_tensor(
							    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]  )

							lowerCAmelCase_      			=			None
							if self.use_labels:
										lowerCAmelCase_      			=			ids_tensor([self.batch_size]       ,       self.type_sequence_label_size  )

							lowerCAmelCase_      			=			self.get_config()

							return config, pixel_values, labels




				def   __a		(      self  )       ->   Any:
							return VideoMAEConfig(
							    image_size=self.image_size       ,       patch_size=self.patch_size       ,       num_channels=self.num_channels       ,       num_frames=self.num_frames       ,       tubelet_size=self.tubelet_size       ,       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       ,       )




				def   __a		(      self       ,       _UpperCamelCase       ,       _UpperCamelCase       ,       _UpperCamelCase  )       ->   int:
							lowerCAmelCase_      			=			VideoMAEModel(config=_UpperCamelCase  )
							model.to(_UpperCamelCase  )
							model.eval()
							lowerCAmelCase_      			=			model(_UpperCamelCase  )
							self.parent.assertEqual(result.last_hidden_state.shape       ,       (self.batch_size, self.seq_length, self.hidden_size)  )




				def   __a		(      self       ,       _UpperCamelCase       ,       _UpperCamelCase       ,       _UpperCamelCase  )       ->   Optional[Any]:
							lowerCAmelCase_      			=			VideoMAEForPreTraining(_UpperCamelCase  )
							model.to(_UpperCamelCase  )
							model.eval()
							# important: each video needs to have the same number of masked patches
							# hence we define a single mask, which we then repeat for each example in the batch
							lowerCAmelCase_      			=			torch.ones((self.num_masks,)  )
							lowerCAmelCase_      			=			torch.cat([mask, torch.zeros(self.seq_length - mask.size(0  )  )]  )
							lowerCAmelCase_      			=			mask.expand(self.batch_size       ,       -1  ).bool()

							lowerCAmelCase_      			=			model(_UpperCamelCase       ,       _UpperCamelCase  )
							# model only returns predictions for masked patches
							lowerCAmelCase_      			=			mask.sum().item()
							lowerCAmelCase_      			=			3 * self.tubelet_size * self.patch_size**2
							self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, num_masked_patches, decoder_num_labels)  )




				def   __a		(      self  )       ->   Dict:
							lowerCAmelCase_      			=			self.prepare_config_and_inputs()
							lowerCAmelCase_			,						lowerCAmelCase_			,						lowerCAmelCase_      			=			config_and_inputs
							lowerCAmelCase_      			=			{"pixel_values": pixel_values}
							return config, inputs_dict





@require_torch
class 			_lowerCAmelCase      (			__a      ,   __a      ,   unittest.TestCase ):
				_lowercase    	=(
				    (VideoMAEModel, VideoMAEForPreTraining, VideoMAEForVideoClassification) if is_torch_available() else ()
				)
				_lowercase    	=(
				    {'''feature-extraction''': VideoMAEModel, '''video-classification''': VideoMAEForVideoClassification}
				    if is_torch_available()
				    else {}
				)

				_lowercase    	=False
				_lowercase    	=False
				_lowercase    	=False
				_lowercase    	=False




				def   __a		(      self  )       ->   Tuple:
							lowerCAmelCase_      			=			VideoMAEModelTester(self  )
							lowerCAmelCase_      			=			ConfigTester(self       ,       config_class=_UpperCamelCase       ,       has_text_modality=_UpperCamelCase       ,       hidden_size=37  )




				def   __a		(      self       ,       _UpperCamelCase       ,       _UpperCamelCase       ,       _UpperCamelCase=False  )       ->   int:
							lowerCAmelCase_      			=			copy.deepcopy(_UpperCamelCase  )

							if model_class == VideoMAEForPreTraining:
										# important: each video needs to have the same number of masked patches
										# hence we define a single mask, which we then repeat for each example in the batch
										lowerCAmelCase_      			=			torch.ones((self.model_tester.num_masks,)  )
										lowerCAmelCase_      			=			torch.cat([mask, torch.zeros(self.model_tester.seq_length - mask.size(0  )  )]  )
										lowerCAmelCase_      			=			mask.expand(self.model_tester.batch_size       ,       -1  ).bool()
										lowerCAmelCase_      			=			bool_masked_pos.to(_UpperCamelCase  )

							if return_labels:
										if model_class in [
										    *get_values(_UpperCamelCase  ),
										]:
													lowerCAmelCase_      			=			torch.zeros(
													    self.model_tester.batch_size       ,       dtype=torch.long       ,       device=_UpperCamelCase  )

							return inputs_dict




				def   __a		(      self  )       ->   Tuple:
							self.config_tester.run_common_tests()




				@unittest.skip(reason="VideoMAE does not use inputs_embeds"  )
				def   __a		(      self  )       ->   List[str]:
							pass




				def   __a		(      self  )       ->   Dict:
							lowerCAmelCase_			,						lowerCAmelCase_      			=			self.model_tester.prepare_config_and_inputs_for_common()

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




				def   __a		(      self  )       ->   int:
							lowerCAmelCase_			,						lowerCAmelCase_      			=			self.model_tester.prepare_config_and_inputs_for_common()

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

										lowerCAmelCase_      			=			["pixel_values"]
										self.assertListEqual(arg_names[:1]       ,       _UpperCamelCase  )




				def   __a		(      self  )       ->   Any:
							lowerCAmelCase_      			=			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_UpperCamelCase  )




				def   __a		(      self  )       ->   str:
							lowerCAmelCase_      			=			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_pretraining(*_UpperCamelCase  )




				@slow
				def   __a		(      self  )       ->   Optional[Any]:
							for model_name in VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowerCAmelCase_      			=			VideoMAEModel.from_pretrained(_UpperCamelCase  )
										self.assertIsNotNone(_UpperCamelCase  )




				def   __a		(      self  )       ->   Optional[Any]:
							if not self.has_attentions:
										pass

							else:
										lowerCAmelCase_			,						lowerCAmelCase_      			=			self.model_tester.prepare_config_and_inputs_for_common()
										lowerCAmelCase_      			=			True

										for model_class in self.all_model_classes:
													lowerCAmelCase_      			=			self.model_tester.seq_length - self.model_tester.num_masks
													lowerCAmelCase_      			=			(
													    num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length
													)

													lowerCAmelCase_      			=			True
													lowerCAmelCase_      			=			False
													lowerCAmelCase_      			=			True
													lowerCAmelCase_      			=			model_class(_UpperCamelCase  )
													model.to(_UpperCamelCase  )
													model.eval()
													with torch.no_grad():
																lowerCAmelCase_      			=			model(**self._prepare_for_class(_UpperCamelCase       ,       _UpperCamelCase  )  )
													lowerCAmelCase_      			=			outputs.attentions
													self.assertEqual(len(_UpperCamelCase  )       ,       self.model_tester.num_hidden_layers  )

													# check that output_attentions also work using config
													del inputs_dict["output_attentions"]
													lowerCAmelCase_      			=			True
													lowerCAmelCase_      			=			model_class(_UpperCamelCase  )
													model.to(_UpperCamelCase  )
													model.eval()
													with torch.no_grad():
																lowerCAmelCase_      			=			model(**self._prepare_for_class(_UpperCamelCase       ,       _UpperCamelCase  )  )
													lowerCAmelCase_      			=			outputs.attentions
													self.assertEqual(len(_UpperCamelCase  )       ,       self.model_tester.num_hidden_layers  )

													self.assertListEqual(
													    list(attentions[0].shape[-3:]  )       ,       [self.model_tester.num_attention_heads, seq_len, seq_len]       ,       )
													lowerCAmelCase_      			=			len(_UpperCamelCase  )

													# Check attention is always last and order is fine
													lowerCAmelCase_      			=			True
													lowerCAmelCase_      			=			True
													lowerCAmelCase_      			=			model_class(_UpperCamelCase  )
													model.to(_UpperCamelCase  )
													model.eval()
													with torch.no_grad():
																lowerCAmelCase_      			=			model(**self._prepare_for_class(_UpperCamelCase       ,       _UpperCamelCase  )  )

													self.assertEqual(out_len + 1       ,       len(_UpperCamelCase  )  )

													lowerCAmelCase_      			=			outputs.attentions

													self.assertEqual(len(_UpperCamelCase  )       ,       self.model_tester.num_hidden_layers  )
													self.assertListEqual(
													    list(self_attentions[0].shape[-3:]  )       ,       [self.model_tester.num_attention_heads, seq_len, seq_len]       ,       )




				def   __a		(      self  )       ->   List[str]:
							def check_hidden_states_output(_UpperCamelCase       ,       _UpperCamelCase       ,       _UpperCamelCase  ):
										lowerCAmelCase_      			=			model_class(_UpperCamelCase  )
										model.to(_UpperCamelCase  )
										model.eval()

										with torch.no_grad():
													lowerCAmelCase_      			=			model(**self._prepare_for_class(_UpperCamelCase       ,       _UpperCamelCase  )  )

										lowerCAmelCase_      			=			outputs.hidden_states
										lowerCAmelCase_      			=			self.model_tester.num_hidden_layers + 1
										self.assertEqual(len(_UpperCamelCase  )       ,       _UpperCamelCase  )

										lowerCAmelCase_      			=			self.model_tester.seq_length - self.model_tester.num_masks
										lowerCAmelCase_      			=			num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length

										self.assertListEqual(
										    list(hidden_states[0].shape[-2:]  )       ,       [seq_length, self.model_tester.hidden_size]       ,       )

							lowerCAmelCase_			,						lowerCAmelCase_      			=			self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
										lowerCAmelCase_      			=			True
										check_hidden_states_output(_UpperCamelCase       ,       _UpperCamelCase       ,       _UpperCamelCase  )

										# check that output_hidden_states also work using config
										del inputs_dict["output_hidden_states"]
										lowerCAmelCase_      			=			True

										check_hidden_states_output(_UpperCamelCase       ,       _UpperCamelCase       ,       _UpperCamelCase  )




				@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."  )
				def   __a		(      self  )       ->   Dict:
							pass






def      lowerCamelCase__       (       ):




			"""simple docstring"""


			lowerCAmelCase_      			=			hf_hub_download(
			    repo_id="hf-internal-testing/spaghetti-video"					,							filename="eating_spaghetti.npy"					,							repo_type="dataset"       )
			lowerCAmelCase_      			=			np.load(__lowerCAmelCase       )
			return list(__lowerCAmelCase       )





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




				@cached_property
				def   __a		(      self  )       ->   str:
							# logits were tested with a different mean and std, so we use the same here
							return (
							    VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]       ,       image_std=[0.5, 0.5, 0.5]  )
							    if is_vision_available()
							    else None
							)




				@slow
				def   __a		(      self  )       ->   Any:
							lowerCAmelCase_      			=			VideoMAEForVideoClassification.from_pretrained("MCG-NJU/videomae-base-finetuned-kinetics"  ).to(
							    _UpperCamelCase  )

							lowerCAmelCase_      			=			self.default_image_processor
							lowerCAmelCase_      			=			prepare_video()
							lowerCAmelCase_      			=			image_processor(_UpperCamelCase       ,       return_tensors="pt"  ).to(_UpperCamelCase  )

							# forward pass
							with torch.no_grad():
										lowerCAmelCase_      			=			model(**_UpperCamelCase  )

							# verify the logits
							lowerCAmelCase_      			=			torch.Size((1, 400)  )
							self.assertEqual(outputs.logits.shape       ,       _UpperCamelCase  )

							lowerCAmelCase_      			=			torch.tensor([0.3669, -0.0688, -0.2421]  ).to(_UpperCamelCase  )

							self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,       _UpperCamelCase       ,       atol=1e-4  )  )




				@slow
				def   __a		(      self  )       ->   Tuple:
							lowerCAmelCase_      			=			VideoMAEForPreTraining.from_pretrained("MCG-NJU/videomae-base-short"  ).to(_UpperCamelCase  )

							lowerCAmelCase_      			=			self.default_image_processor
							lowerCAmelCase_      			=			prepare_video()
							lowerCAmelCase_      			=			image_processor(_UpperCamelCase       ,       return_tensors="pt"  ).to(_UpperCamelCase  )

							# add boolean mask, indicating which patches to mask
							lowerCAmelCase_      			=			hf_hub_download(repo_id="hf-internal-testing/bool-masked-pos"       ,       filename="bool_masked_pos.pt"  )
							lowerCAmelCase_      			=			torch.load(_UpperCamelCase  )

							# forward pass
							with torch.no_grad():
										lowerCAmelCase_      			=			model(**_UpperCamelCase  )

							# verify the logits
							lowerCAmelCase_      			=			torch.Size([1, 1_408, 1_536]  )
							lowerCAmelCase_      			=			torch.tensor(
							    [[0.7994, 0.9612, 0.8508], [0.7401, 0.8958, 0.8302], [0.5862, 0.7468, 0.7325]]       ,       device=_UpperCamelCase  )
							self.assertEqual(outputs.logits.shape       ,       _UpperCamelCase  )
							self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]       ,       _UpperCamelCase       ,       atol=1e-4  )  )

							# verify the loss (`config.norm_pix_loss` = `True`)
							lowerCAmelCase_      			=			torch.tensor([0.5142]       ,       device=_UpperCamelCase  )
							self.assertTrue(torch.allclose(outputs.loss       ,       _UpperCamelCase       ,       atol=1e-4  )  )

							# verify the loss (`config.norm_pix_loss` = `False`)
							lowerCAmelCase_      			=			VideoMAEForPreTraining.from_pretrained("MCG-NJU/videomae-base-short"       ,       norm_pix_loss=_UpperCamelCase  ).to(
							    _UpperCamelCase  )

							with torch.no_grad():
										lowerCAmelCase_      			=			model(**_UpperCamelCase  )

							lowerCAmelCase_      			=			torch.tensor(torch.tensor([0.6469]  )       ,       device=_UpperCamelCase  )
							self.assertTrue(torch.allclose(outputs.loss       ,       _UpperCamelCase       ,       atol=1e-4  )  )





import json
import os
from collections import Counter

import torch
import torchvision
import torchvision.transforms as transforms
from PIL import Image
from torch import nn
from torch.utils.data import Dataset


_A     =  {1: (1, 1), 2: (2, 1), 3: (3, 1), 4: (2, 2), 5: (5, 1), 6: (3, 2), 7: (7, 1), 8: (4, 2), 9: (3, 3)}





class 			_lowerCAmelCase      (			nn.Module ):




				def __init__(      self       ,       _UpperCamelCase  )       ->   Optional[Any]:
							super().__init__()
							lowerCAmelCase_      			=			torchvision.models.resnetaaa(pretrained=_UpperCamelCase  )
							lowerCAmelCase_      			=			list(model.children()  )[:-2]
							lowerCAmelCase_      			=			nn.Sequential(*_UpperCamelCase  )
							lowerCAmelCase_      			=			nn.AdaptiveAvgPoolad(POOLING_BREAKDOWN[args.num_image_embeds]  )




				def   __a		(      self       ,       _UpperCamelCase  )       ->   Dict:
							# Bx3x224x224 -> Bx2048x7x7 -> Bx2048xN -> BxNx2048
							lowerCAmelCase_      			=			self.pool(self.model(_UpperCamelCase  )  )
							lowerCAmelCase_      			=			torch.flatten(_UpperCamelCase       ,       start_dim=2  )
							lowerCAmelCase_      			=			out.transpose(1       ,       2  ).contiguous()
							return out  # BxNx2048





class 			_lowerCAmelCase      (			__a ):




				def __init__(      self       ,       _UpperCamelCase       ,       _UpperCamelCase       ,       _UpperCamelCase       ,       _UpperCamelCase       ,       _UpperCamelCase  )       ->   List[str]:
							lowerCAmelCase_      			=			[json.loads(_UpperCamelCase  ) for l in open(_UpperCamelCase  )]
							lowerCAmelCase_      			=			os.path.dirname(_UpperCamelCase  )
							lowerCAmelCase_      			=			tokenizer
							lowerCAmelCase_      			=			labels
							lowerCAmelCase_      			=			len(_UpperCamelCase  )
							lowerCAmelCase_      			=			max_seq_length

							lowerCAmelCase_      			=			transforms




				def __len__(      self  )       ->   Any:
							return len(self.data  )




				def __getitem__(      self       ,       _UpperCamelCase  )       ->   Any:
							lowerCAmelCase_      			=			torch.LongTensor(self.tokenizer.encode(self.data[index]["text"]       ,       add_special_tokens=_UpperCamelCase  )  )
							lowerCAmelCase_			,						lowerCAmelCase_			,						lowerCAmelCase_      			=			sentence[0], sentence[1:-1], sentence[-1]
							lowerCAmelCase_      			=			sentence[: self.max_seq_length]

							lowerCAmelCase_      			=			torch.zeros(self.n_classes  )
							lowerCAmelCase_      			=			1

							lowerCAmelCase_      			=			Image.open(os.path.join(self.data_dir       ,       self.data[index]["img"]  )  ).convert("RGB"  )
							lowerCAmelCase_      			=			self.transforms(_UpperCamelCase  )

							return {
							    "image_start_token": start_token,
							    "image_end_token": end_token,
							    "sentence": sentence,
							    "image": image,
							    "label": label,
							}




				def   __a		(      self  )       ->   str:
							lowerCAmelCase_      			=			Counter()
							for row in self.data:
										label_freqs.update(row["label"]  )
							return label_freqs






def      lowerCamelCase__       (       __lowerCAmelCase						:						List[str]       ):




			"""simple docstring"""


			lowerCAmelCase_      			=			[len(row["sentence"]       ) for row in batch]
			lowerCAmelCase_			,						lowerCAmelCase_      			=			len(__lowerCAmelCase       ), max(__lowerCAmelCase       )

			lowerCAmelCase_      			=			torch.zeros(__lowerCAmelCase					,							__lowerCAmelCase					,							dtype=torch.long       )
			lowerCAmelCase_      			=			torch.zeros(__lowerCAmelCase					,							__lowerCAmelCase					,							dtype=torch.long       )

			for i_batch, (input_row, length) in enumerate(zip(__lowerCAmelCase					,							__lowerCAmelCase       )       ):
						lowerCAmelCase_      			=			input_row["sentence"]
						lowerCAmelCase_      			=			1

			lowerCAmelCase_      			=			torch.stack([row["image"] for row in batch]       )
			lowerCAmelCase_      			=			torch.stack([row["label"] for row in batch]       )
			lowerCAmelCase_      			=			torch.stack([row["image_start_token"] for row in batch]       )
			lowerCAmelCase_      			=			torch.stack([row["image_end_token"] for row in batch]       )

			return text_tensor, mask_tensor, img_tensor, img_start_token, img_end_token, tgt_tensor






def      lowerCamelCase__       (       ):




			"""simple docstring"""


			return [
			    "Crime",
			    "Drama",
			    "Thriller",
			    "Action",
			    "Comedy",
			    "Romance",
			    "Documentary",
			    "Short",
			    "Mystery",
			    "History",
			    "Family",
			    "Adventure",
			    "Fantasy",
			    "Sci-Fi",
			    "Western",
			    "Horror",
			    "Sport",
			    "War",
			    "Music",
			    "Musical",
			    "Animation",
			    "Biography",
			    "Film-Noir",
			]






def      lowerCamelCase__       (       ):




			"""simple docstring"""


			return transforms.Compose(
			    [
			        transforms.Resize(256       ),
			        transforms.CenterCrop(224       ),
			        transforms.ToTensor(),
			        transforms.Normalize(
			            mean=[0.46_777_044, 0.44_531_429, 0.40_661_017]					,							std=[0.12_221_994, 0.12_145_835, 0.14_380_469]					,							),
			    ]       )



