


"""simple docstring"""


import inspect
import unittest

from transformers import BitConfig
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_backbone_common import BackboneTesterMixin
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 BitBackbone, BitForImageClassification, BitImageProcessor, BitModel
	from transformers.models.bit.modeling_bit import BIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image
class 						_UpperCamelCase						:
							'''simple docstring'''







							def __init__(  self					,     __a					,     __a=3					,     __a=32					,     __a=3					,     __a=10					,     __a=[8, 16, 32, 64]					,     __a=[1, 1, 2, 1]					,     __a=True					,     __a=True					,     __a="relu"					,     __a=3					,     __a=None					,     __a=["stage2", "stage3", "stage4"]					,     __a=[2, 3, 4]					,     __a=1					,     ):
										__lowerCAmelCase       					=    parent
										__lowerCAmelCase       					=    batch_size
										__lowerCAmelCase       					=    image_size
										__lowerCAmelCase       					=    num_channels
										__lowerCAmelCase       					=    embeddings_size
										__lowerCAmelCase       					=    hidden_sizes
										__lowerCAmelCase       					=    depths
										__lowerCAmelCase       					=    is_training
										__lowerCAmelCase       					=    use_labels
										__lowerCAmelCase       					=    hidden_act
										__lowerCAmelCase       					=    num_labels
										__lowerCAmelCase       					=    scope
										__lowerCAmelCase       					=    len(__a			)
										__lowerCAmelCase       					=    out_features
										__lowerCAmelCase       					=    out_indices
										__lowerCAmelCase       					=    num_groups

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

										__lowerCAmelCase       					=    None
										if self.use_labels:
													__lowerCAmelCase       					=    ids_tensor([self.batch_size]					,     self.num_labels			)

										__lowerCAmelCase       					=    self.get_config()

										return config, pixel_values, labels

							def     snake_case       (  self			):
										return BitConfig(
										    num_channels=self.num_channels					,     embeddings_size=self.embeddings_size					,     hidden_sizes=self.hidden_sizes					,     depths=self.depths					,     hidden_act=self.hidden_act					,     num_labels=self.num_labels					,     out_features=self.out_features					,     out_indices=self.out_indices					,     num_groups=self.num_groups					,     )

							def     snake_case       (  self					,     __a					,     __a					,     __a			):
										__lowerCAmelCase       					=    BitModel(config=__a			)
										model.to(__a			)
										model.eval()
										__lowerCAmelCase       					=    model(__a			)
										self.parent.assertEqual(
										    result.last_hidden_state.shape					,     (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)					,     )

							def     snake_case       (  self					,     __a					,     __a					,     __a			):
										__lowerCAmelCase       					=    self.num_labels
										__lowerCAmelCase       					=    BitForImageClassification(__a			)
										model.to(__a			)
										model.eval()
										__lowerCAmelCase       					=    model(__a					,     labels=__a			)
										self.parent.assertEqual(result.logits.shape					,     (self.batch_size, self.num_labels)			)

							def     snake_case       (  self					,     __a					,     __a					,     __a			):
										__lowerCAmelCase       					=    BitBackbone(config=__a			)
										model.to(__a			)
										model.eval()
										__lowerCAmelCase       					=    model(__a			)

										# verify feature maps
										self.parent.assertEqual(len(result.feature_maps			)					,     len(config.out_features			)			)
										self.parent.assertListEqual(list(result.feature_maps[0].shape			)					,     [self.batch_size, self.hidden_sizes[1], 4, 4]			)

										# verify channels
										self.parent.assertEqual(len(model.channels			)					,     len(config.out_features			)			)
										self.parent.assertListEqual(model.channels					,     config.hidden_sizes[1:]			)

										# verify backbone works with out_features=None
										__lowerCAmelCase       					=    None
										__lowerCAmelCase       					=    BitBackbone(config=__a			)
										model.to(__a			)
										model.eval()
										__lowerCAmelCase       					=    model(__a			)

										# verify feature maps
										self.parent.assertEqual(len(result.feature_maps			)					,     1			)
										self.parent.assertListEqual(list(result.feature_maps[0].shape			)					,     [self.batch_size, self.hidden_sizes[-1], 1, 1]			)

										# verify channels
										self.parent.assertEqual(len(model.channels			)					,     1			)
										self.parent.assertListEqual(model.channels					,     [config.hidden_sizes[-1]]			)



							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.prepare_config_and_inputs()
										__lowerCAmelCase					,			__lowerCAmelCase					,			__lowerCAmelCase       					=    config_and_inputs
										__lowerCAmelCase       					=    {"pixel_values": pixel_values}
										return config, inputs_dict
@require_torch
class 						_UpperCamelCase						(     snake_case_ ,snake_case_ ,unittest.TestCase	):
							'''simple docstring'''







							__UpperCAmelCase		:					List[Any]          =(BitModel, BitForImageClassification, BitBackbone) if is_torch_available() else ()
							__UpperCAmelCase		:					Union[str, Any]          =(
							    {"""feature-extraction""": BitModel, """image-classification""": BitForImageClassification}
							    if is_torch_available()
							    else {}
							)

							__UpperCAmelCase		:					Dict          =False
							__UpperCAmelCase		:					Optional[Any]          =False
							__UpperCAmelCase		:					Optional[Any]          =False
							__UpperCAmelCase		:					Optional[int]          =False
							__UpperCAmelCase		:					str          =False

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    BitModelTester(self			)
										__lowerCAmelCase       					=    ConfigTester(self					,     config_class=__a					,     has_text_modality=__a			)

							def     snake_case       (  self			):
										self.create_and_test_config_common_properties()
										self.config_tester.create_and_test_config_to_json_string()
										self.config_tester.create_and_test_config_to_json_file()
										self.config_tester.create_and_test_config_from_and_save_pretrained()
										self.config_tester.create_and_test_config_with_num_labels()
										self.config_tester.check_config_can_be_init_without_params()
										self.config_tester.check_config_arguments_init()

							def     snake_case       (  self			):
										return

							@unittest.skip(reason="Bit does not output attentions"			)
							def     snake_case       (  self			):
										pass

							@unittest.skip(reason="Bit does not use inputs_embeds"			)
							def     snake_case       (  self			):
										pass

							@unittest.skip(reason="Bit does not support input and output embeddings"			)
							def     snake_case       (  self			):
										pass

							def     snake_case       (  self			):
										__lowerCAmelCase					,			__lowerCAmelCase       					=    self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													__lowerCAmelCase       					=    model_class(__a			)
													__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]					,     __a			)

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*__a			)

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_backbone(*__a			)

							def     snake_case       (  self			):
										__lowerCAmelCase					,			__lowerCAmelCase       					=    self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													__lowerCAmelCase       					=    model_class(config=__a			)
													for name, module in model.named_modules():
																if isinstance(__a					,     (nn.BatchNormad, nn.GroupNorm)			):
																			self.assertTrue(
																			    torch.all(module.weight == 1			)					,     msg=f"Parameter {name} of model {model_class} seems not properly initialized"					,     )
																			self.assertTrue(
																			    torch.all(module.bias == 0			)					,     msg=f"Parameter {name} of model {model_class} seems not properly initialized"					,     )

							def     snake_case       (  self			):
										def check_hidden_states_output(__a					,     __a					,     __a			):
													__lowerCAmelCase       					=    model_class(__a			)
													model.to(__a			)
													model.eval()

													with torch.no_grad():
																__lowerCAmelCase       					=    model(**self._prepare_for_class(__a					,     __a			)			)

													__lowerCAmelCase       					=    outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

													__lowerCAmelCase       					=    self.model_tester.num_stages
													self.assertEqual(len(__a			)					,     expected_num_stages + 1			)

													# Bit's feature maps are of shape (batch_size, num_channels, height, width)
													self.assertListEqual(
													    list(hidden_states[0].shape[-2:]			)					,     [self.model_tester.image_size // 4, self.model_tester.image_size // 4]					,     )

										__lowerCAmelCase					,			__lowerCAmelCase       					=    self.model_tester.prepare_config_and_inputs_for_common()
										__lowerCAmelCase       					=    ["preactivation", "bottleneck"]
										for model_class in self.all_model_classes:
													for layer_type in layers_type:
																__lowerCAmelCase       					=    layer_type
																__lowerCAmelCase       					=    True
																check_hidden_states_output(__a					,     __a					,     __a			)

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

																check_hidden_states_output(__a					,     __a					,     __a			)

							@unittest.skip(reason="Bit does not use feedforward chunking"			)
							def     snake_case       (  self			):
										pass

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*__a			)



							@slow
							def     snake_case       (  self			):
										for model_name in BIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__lowerCAmelCase       					=    BitModel.from_pretrained(__a			)
													self.assertIsNotNone(__a			)


def _lowerCamelCase			(	):

			'''simple docstring'''




			__lowerCAmelCase       					=    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"   )
			return image
@require_torch
@require_vision
class 						_UpperCamelCase						(     unittest.TestCase	):
							'''simple docstring'''







							@cached_property
							def     snake_case       (  self			):
										return (
										    BitImageProcessor.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]			) if is_vision_available() else None
										)



							@slow
							def     snake_case       (  self			):
										__lowerCAmelCase       					=    BitForImageClassification.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]			).to(__a			)

										__lowerCAmelCase       					=    self.default_image_processor
										__lowerCAmelCase       					=    prepare_img()
										__lowerCAmelCase       					=    image_processor(images=__a					,     return_tensors="pt"			).to(__a			)

										# forward pass
										with torch.no_grad():
													__lowerCAmelCase       					=    model(**__a			)

										# verify the logits
										__lowerCAmelCase       					=    torch.Size((1, 10_00)			)
										self.assertEqual(outputs.logits.shape					,     __a			)

										__lowerCAmelCase       					=    torch.tensor([[-0.6_5_2_6, -0.5_2_6_3, -1.4_3_9_8]]			).to(__a			)

										self.assertTrue(torch.allclose(outputs.logits[0, :3]					,     __a					,     atol=1e-4			)			)
@require_torch
class 						_UpperCamelCase						(     snake_case_ ,unittest.TestCase	):
							'''simple docstring'''







							__UpperCAmelCase		:					int          =(BitBackbone,) if is_torch_available() else ()
							__UpperCAmelCase		:					Any          =BitConfig

							__UpperCAmelCase		:					List[Any]          =False

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    BitModelTester(self			)








"""simple docstring"""


from itertools import product


def _lowerCamelCase			(	_UpperCamelCase					,				_UpperCamelCase   ):

			'''simple docstring'''




			__lowerCAmelCase       					=    sides_number
			__lowerCAmelCase       					=    max_face_number * dice_number
			__lowerCAmelCase       					=    [0] * (max_total + 1)

			__lowerCAmelCase       					=    1
			__lowerCAmelCase       					=    range(_UpperCamelCase					,				max_face_number + 1   )
			for dice_numbers in product(_UpperCamelCase					,				repeat=_UpperCamelCase   ):
						__lowerCAmelCase       					=    sum(_UpperCamelCase   )
						totals_frequencies[total] += 1

			return totals_frequencies


def _lowerCamelCase			(	):

			'''simple docstring'''




			__lowerCAmelCase       					=    total_frequency_distribution(
			    sides_number=4					,				dice_number=9   )
			__lowerCAmelCase       					=    total_frequency_distribution(
			    sides_number=6					,				dice_number=6   )

			__lowerCAmelCase       					=    0
			__lowerCAmelCase       					=    9
			__lowerCAmelCase       					=    4 * 9
			__lowerCAmelCase       					=    6
			for peter_total in range(_UpperCamelCase					,				max_peter_total + 1   ):
						peter_wins_count += peter_totals_frequencies[peter_total] * sum(
						    colin_totals_frequencies[min_colin_total:peter_total]   )

			__lowerCAmelCase       					=    (4**9) * (6**6)
			__lowerCAmelCase       					=    peter_wins_count / total_games_number

			__lowerCAmelCase       					=    round(_UpperCamelCase					,				ndigits=7   )

			return rounded_peter_win_probability


if __name__ == "__main__":
	print(f'''{solution() = }''')




