




import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
						import tensorflow as tf

						from transformers import (
						    TFEfficientFormerForImageClassification,
						    TFEfficientFormerForImageClassificationWithTeacher,
						    TFEfficientFormerModel,
						)
						from transformers.models.efficientformer.modeling_tf_efficientformer import (
						    TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
						)


if is_vision_available():
						from PIL import Image

						from transformers import EfficientFormerImageProcessor



class    lowercase_		:



						def __init__(			self	:   List[Any]					,							snake_case__	:   int					,							snake_case__	:   int = 13					,							snake_case__	:   int = 64					,							snake_case__	:   int = 2					,							snake_case__	:   int = 3					,							snake_case__	:   int = 3					,							snake_case__	:   bool = True					,							snake_case__	:   bool = True					,							snake_case__	:   int = 1_28					,							snake_case__	:   Optional[int]=[16, 32, 64, 1_28]					,							snake_case__	:   int = 7					,							snake_case__	:   int = 4					,							snake_case__	:   int = 37					,							snake_case__	:   str = "gelu"					,							snake_case__	:   float = 0.1					,							snake_case__	:   float = 0.1					,							snake_case__	:   int = 10					,							snake_case__	:   float = 0.02					,							snake_case__	:   int = 2					,							snake_case__	:   int = 1					,							snake_case__	:   int = 1_28					,							snake_case__	:   List[int] = [2, 2, 2, 2]					,							snake_case__	:   int = 2					,							snake_case__	:   int = 2					,							):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							parent
								SCREAMING_SNAKE_CASE_					      =							batch_size
								SCREAMING_SNAKE_CASE_					      =							image_size
								SCREAMING_SNAKE_CASE_					      =							patch_size
								SCREAMING_SNAKE_CASE_					      =							num_channels
								SCREAMING_SNAKE_CASE_					      =							is_training
								SCREAMING_SNAKE_CASE_					      =							use_labels
								SCREAMING_SNAKE_CASE_					      =							hidden_size
								SCREAMING_SNAKE_CASE_					      =							num_hidden_layers
								SCREAMING_SNAKE_CASE_					      =							num_attention_heads
								SCREAMING_SNAKE_CASE_					      =							intermediate_size
								SCREAMING_SNAKE_CASE_					      =							hidden_act
								SCREAMING_SNAKE_CASE_					      =							hidden_dropout_prob
								SCREAMING_SNAKE_CASE_					      =							attention_probs_dropout_prob
								SCREAMING_SNAKE_CASE_					      =							type_sequence_label_size
								SCREAMING_SNAKE_CASE_					      =							initializer_range
								SCREAMING_SNAKE_CASE_					      =							encoder_stride
								SCREAMING_SNAKE_CASE_					      =							num_attention_outputs
								SCREAMING_SNAKE_CASE_					      =							embed_dim
								SCREAMING_SNAKE_CASE_					      =							embed_dim + 1
								SCREAMING_SNAKE_CASE_					      =							resolution
								SCREAMING_SNAKE_CASE_					      =							depths
								SCREAMING_SNAKE_CASE_					      =							hidden_sizes
								SCREAMING_SNAKE_CASE_					      =							dim
								SCREAMING_SNAKE_CASE_					      =							mlp_expansion_ratio



						def 	__a					(			self	:   List[str]  ):

								"""simple docstring"""

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

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

								SCREAMING_SNAKE_CASE_					      =							self.get_config()

								return config, pixel_values, labels



						def 	__a					(			self	:   Tuple  ):

								"""simple docstring"""

								return EfficientFormerConfig(
								    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=snake_case__					,							initializer_range=self.initializer_range					,							encoder_stride=self.encoder_stride					,							resolution=self.resolution					,							depths=self.depths					,							hidden_sizes=self.hidden_sizes					,							dim=self.dim					,							mlp_expansion_ratio=self.mlp_expansion_ratio					,							)



						def 	__a					(			self	:   int					,							snake_case__	:   Optional[Any]					,							snake_case__	:   Union[str, Any]					,							snake_case__	:   Optional[int]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							TFEfficientFormerModel(config=snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							training=snake_case__  )
								self.parent.assertEqual(result.last_hidden_state.shape					,							(self.batch_size, self.seq_length, self.hidden_size)  )



						def 	__a					(			self	:   int					,							snake_case__	:   List[str]					,							snake_case__	:   Any					,							snake_case__	:   int  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.type_sequence_label_size
								SCREAMING_SNAKE_CASE_					      =							TFEfficientFormerForImageClassification(snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							labels=snake_case__					,							training=snake_case__  )
								self.parent.assertEqual(result.logits.shape					,							(self.batch_size, self.type_sequence_label_size)  )

								# test greyscale images
								SCREAMING_SNAKE_CASE_					      =							1
								SCREAMING_SNAKE_CASE_					      =							TFEfficientFormerForImageClassification(snake_case__  )

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






						def 	__a					(			self	:   int  ):

								"""simple docstring"""

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



@require_tf
class    lowercase_		(SCREAMING_SNAKE_CASE__							,	SCREAMING_SNAKE_CASE__							,	unittest.TestCase ):
						lowerCAmelCase__			      =(
						    (
						        TFEfficientFormerModel,
						        TFEfficientFormerForImageClassificationWithTeacher,
						        TFEfficientFormerForImageClassification,
						    )
						    if is_tf_available()
						    else ()
						)
						lowerCAmelCase__			      =(
						    {
						        "feature-extraction": TFEfficientFormerModel,
						        "image-classification": (
						            TFEfficientFormerForImageClassification,
						            TFEfficientFormerForImageClassificationWithTeacher,
						        ),
						    }
						    if is_tf_available()
						    else {}
						)

						lowerCAmelCase__			      =False

						lowerCAmelCase__			      =False
						lowerCAmelCase__			      =False
						lowerCAmelCase__			      =False
						lowerCAmelCase__			      =False



						def 	__a					(			self	:   str  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							TFEfficientFormerModelTester(self  )
								SCREAMING_SNAKE_CASE_					      =							ConfigTester(
								    self					,							config_class=snake_case__					,							has_text_modality=snake_case__					,							hidden_size=37  )



						def 	__a					(			self	:   Union[str, Any]  ):

								"""simple docstring"""

								self.config_tester.run_common_tests()



						@unittest.skip(reason='EfficientFormer does not use inputs_embeds'  )
						def 	__a					(			self	:   List[Any]  ):

								"""simple docstring"""

								pass



						@unittest.skip(reason='EfficientFormer does not support input and output embeddings'  )
						def 	__a					(			self	:   Dict  ):

								"""simple docstring"""

								pass



						def 	__a					(			self	:   Optional[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs_for_common()

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

										SCREAMING_SNAKE_CASE_					      =							['pixel_values']
										self.assertListEqual(arg_names[:1]					,							snake_case__  )



						def 	__a					(			self	:   List[Any]  ):

								"""simple docstring"""

								def check_hidden_states_output(snake_case__	:   Optional[Any]					,							snake_case__	:   Optional[Any]					,							snake_case__	:   Dict  ):
										SCREAMING_SNAKE_CASE_					      =							model_class(snake_case__  )

										SCREAMING_SNAKE_CASE_					      =							model(**self._prepare_for_class(snake_case__					,							snake_case__  )					,							training=snake_case__  )
										SCREAMING_SNAKE_CASE_					      =							outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

										SCREAMING_SNAKE_CASE_					      =							getattr(
										    self.model_tester					,							'expected_num_hidden_layers'					,							self.model_tester.num_hidden_layers + 1  )
										self.assertEqual(len(snake_case__  )					,							snake_case__  )

										if hasattr(self.model_tester					,							'encoder_seq_length'  ):
												SCREAMING_SNAKE_CASE_					      =							self.model_tester.encoder_seq_length
												if hasattr(self.model_tester					,							'chunk_length'  ) and self.model_tester.chunk_length > 1:
														SCREAMING_SNAKE_CASE_					      =							seq_length * self.model_tester.chunk_length
										else:
												SCREAMING_SNAKE_CASE_					      =							self.model_tester.seq_length

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

										if config.is_encoder_decoder:
												SCREAMING_SNAKE_CASE_					      =							outputs.decoder_hidden_states

												self.asseretIsInstance(snake_case__					,							(list, tuple)  )
												self.assertEqual(len(snake_case__  )					,							snake_case__  )
												SCREAMING_SNAKE_CASE_					      =							getattr(self.model_tester					,							'seq_length'					,							snake_case__  )
												SCREAMING_SNAKE_CASE_					      =							getattr(self.model_tester					,							'decoder_seq_length'					,							snake_case__  )

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

								SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
										SCREAMING_SNAKE_CASE_					      =							True
										check_hidden_states_output(snake_case__					,							snake_case__					,							snake_case__  )

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

										check_hidden_states_output(snake_case__					,							snake_case__					,							snake_case__  )



						def 	__a					(			self	:   str					,							snake_case__	:   Any					,							snake_case__	:   List[Any]					,							snake_case__	:   Optional[Any]=False  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							super()._prepare_for_class(snake_case__					,							snake_case__					,							return_labels=snake_case__  )

								if return_labels:
										if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
												del inputs_dict["labels"]

								return inputs_dict



						def 	__a					(			self	:   Tuple  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*snake_case__  )



						@unittest.skip(reason='EfficientFormer does not implement masked image modeling yet'  )
						def 	__a					(			self	:   Any  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_image_modeling(*snake_case__  )



						def 	__a					(			self	:   Optional[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*snake_case__  )



						@slow
						def 	__a					(			self	:   Union[str, Any]  ):

								"""simple docstring"""

								for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										SCREAMING_SNAKE_CASE_					      =							TFEfficientFormerModel.from_pretrained(snake_case__  )
										self.assertIsNotNone(snake_case__  )



						def 	__a					(			self	:   List[str]  ):

								"""simple docstring"""

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

								SCREAMING_SNAKE_CASE_					      =							getattr(self.model_tester					,							'seq_length'					,							snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							getattr(self.model_tester					,							'encoder_seq_length'					,							snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							getattr(self.model_tester					,							'key_length'					,							snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							getattr(self.model_tester					,							'chunk_length'					,							snake_case__  )

								if chunk_length is not None and hasattr(self.model_tester					,							'num_hashes'  ):
										SCREAMING_SNAKE_CASE_					      =							encoder_seq_length * self.model_tester.num_hashes

								for model_class in self.all_model_classes:
										SCREAMING_SNAKE_CASE_					      =							True
										SCREAMING_SNAKE_CASE_					      =							False
										SCREAMING_SNAKE_CASE_					      =							True
										SCREAMING_SNAKE_CASE_					      =							model_class(snake_case__  )

										SCREAMING_SNAKE_CASE_					      =							model(**self._prepare_for_class(snake_case__					,							snake_case__  )					,							training=snake_case__  )
										SCREAMING_SNAKE_CASE_					      =							outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
										self.assertEqual(len(snake_case__  )					,							self.model_tester.num_attention_outputs  )

										# check that output_attentions also work using config
										del inputs_dict["output_attentions"]
										SCREAMING_SNAKE_CASE_					      =							True
										SCREAMING_SNAKE_CASE_					      =							model_class(snake_case__  )
										SCREAMING_SNAKE_CASE_					      =							model(**self._prepare_for_class(snake_case__					,							snake_case__  )					,							training=snake_case__  )

										SCREAMING_SNAKE_CASE_					      =							outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
										self.assertEqual(len(snake_case__  )					,							self.model_tester.num_attention_outputs  )

										if chunk_length is not None:
												self.assertListEqual(
												    list(attentions[0].shape[-4:]  )					,							[self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]					,							)
										else:
												self.assertListEqual(
												    list(attentions[0].shape[-3:]  )					,							[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]					,							)






						def 	__a					(			self	:   List[str]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
										# Prepare our model
										SCREAMING_SNAKE_CASE_					      =							model_class(snake_case__  )
										# These are maximally general inputs for the model, with multiple None dimensions
										# Hopefully this will catch any conditionals that fail for flexible shapes
										SCREAMING_SNAKE_CASE_					      =							{
										    key: tf.keras.Input(shape=val.shape[1:]					,							dtype=val.dtype					,							name=snake_case__  )
										    for key, val in model.input_signature.items()
										    if key in model.dummy_inputs
										}
										SCREAMING_SNAKE_CASE_					      =							model(snake_case__  )
										self.assertTrue(outputs_dict is not None  )


def 					_a							(					)->	Dict:
		SCREAMING_SNAKE_CASE_					      =							Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
		return image




@require_tf
@require_vision
class    lowercase_		(unittest.TestCase ):



						@cached_property
						def 	__a					(			self	:   str  ):

								"""simple docstring"""

								return (
								    EfficientFormerImageProcessor.from_pretrained('snap-research/efficientformer-l1-300'  )
								    if is_vision_available()
								    else None
								)



						@slow
						def 	__a					(			self	:   List[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							TFEfficientFormerForImageClassification.from_pretrained('snap-research/efficientformer-l1-300'  )
								SCREAMING_SNAKE_CASE_					      =							self.default_image_processor
								SCREAMING_SNAKE_CASE_					      =							prepare_img()
								SCREAMING_SNAKE_CASE_					      =							image_processor(images=snake_case__					,							return_tensors='tf'  )
								# forward pass
								SCREAMING_SNAKE_CASE_					      =							model(**snake_case__					,							training=snake_case__  )
								# verify the logits
								SCREAMING_SNAKE_CASE_					      =							tf.TensorShape((1, 10_00)  )
								self.assertEqual(outputs.logits.shape					,							snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							tf.constant([-0.05_55, 0.48_25, -0.08_52]  )
								self.assertTrue(np.allclose(outputs.logits[0, :3]					,							snake_case__					,							atol=1e-4  )  )






						@slow
						def 	__a					(			self	:   Optional[int]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
								    'snap-research/efficientformer-l1-300'  )
								SCREAMING_SNAKE_CASE_					      =							self.default_image_processor
								SCREAMING_SNAKE_CASE_					      =							prepare_img()
								SCREAMING_SNAKE_CASE_					      =							image_processor(images=snake_case__					,							return_tensors='tf'  )
								# forward pass
								SCREAMING_SNAKE_CASE_					      =							model(**snake_case__					,							training=snake_case__  )
								# verify the logits
								SCREAMING_SNAKE_CASE_					      =							tf.TensorShape((1, 10_00)  )
								self.assertEqual(outputs.logits.shape					,							snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							tf.constant([-0.13_12, 0.43_53, -1.04_99]  )
								self.assertTrue(np.allclose(outputs.logits[0, :3]					,							snake_case__					,							atol=1e-4  )  )





import numpy as np
from numpy import ndarray
from scipy.optimize import Bounds, LinearConstraint, minimize


def 					_a							(					lowerCAmelCase )->	float:
		return np.dot(lowerCAmelCase    ,						lowerCAmelCase )



class    lowercase_		:



						def __init__(			self	:   int					,							*,
						    snake_case__	:   float = np.inf					,							snake_case__	:   str = "linear"					,							snake_case__	:   float = 0.0					,							):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							regularization
								SCREAMING_SNAKE_CASE_					      =							gamma
								if kernel == "linear":
										SCREAMING_SNAKE_CASE_					      =							self.__linear
								elif kernel == "rbf":
										if self.gamma == 0:
												raise ValueError('rbf kernel requires gamma'  )
										if not isinstance(self.gamma					,							(float, int)  ):
												raise ValueError('gamma must be float or int'  )
										if not self.gamma > 0:
												raise ValueError('gamma must be > 0'  )
										SCREAMING_SNAKE_CASE_					      =							self.__rbf
										# in the future, there could be a default value like in sklearn
										# sklear: def_gamma = 1/(n_features * X.var()) (wiki)
										# previously it was 1/(n_features)
								else:
										SCREAMING_SNAKE_CASE_					      =							f'''Unknown kernel: {kernel}'''
										raise ValueError(snake_case__  )



						def 	__a					(			self	:   Tuple					,							snake_case__	:   ndarray					,							snake_case__	:   ndarray  ):

								"""simple docstring"""

								return np.dot(snake_case__					,							snake_case__  )



						def 	__a					(			self	:   int					,							snake_case__	:   ndarray					,							snake_case__	:   ndarray  ):

								"""simple docstring"""

								return np.exp(-(self.gamma * norm_squared(vectora - vectora  ))  )



						def 	__a					(			self	:   int					,							snake_case__	:   list[ndarray]					,							snake_case__	:   ndarray  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							observations
								SCREAMING_SNAKE_CASE_					      =							classes

								# using Wolfe's Dual to calculate w.
								# Primal problem: minimize 1/2*norm_squared(w)
								#   constraint: yn(w . xn + b) >= 1
								#
								# With l a vector
								# Dual problem: maximize sum_n(ln) -
								#       1/2 * sum_n(sum_m(ln*lm*yn*ym*xn . xm))
								#   constraint: self.C >= ln >= 0
								#           and sum_n(ln*yn) = 0
								# Then we get w using w = sum_n(ln*yn*xn)
								# At the end we can get b ~= mean(yn - w . xn)
								#
								# Since we use kernels, we only need l_star to calculate b
								# and to classify observations

								((SCREAMING_SNAKE_CASE_)      ,				)					      =							np.shape(snake_case__  )

								def to_minimize(snake_case__	:   ndarray  ) -> float:
										SCREAMING_SNAKE_CASE_					      =							0
										((SCREAMING_SNAKE_CASE_)      ,				)					      =							np.shape(snake_case__  )
										for i in range(snake_case__  ):
												for j in range(snake_case__  ):
														s += (
														    candidate[i]
														    * candidate[j]
														    * classes[i]
														    * classes[j]
														    * self.kernel(observations[i]					,							observations[j]  )
														)
										return 1 / 2 * s - sum(snake_case__  )

								SCREAMING_SNAKE_CASE_					      =							LinearConstraint(snake_case__					,							0					,							0  )
								SCREAMING_SNAKE_CASE_					      =							Bounds(0					,							self.regularization  )

								SCREAMING_SNAKE_CASE_					      =							minimize(
								    snake_case__					,							np.ones(snake_case__  )					,							bounds=snake_case__					,							constraints=[ly_contraint]  ).x
								SCREAMING_SNAKE_CASE_					      =							l_star

								# calculating mean offset of separation plane to points
								SCREAMING_SNAKE_CASE_					      =							0
								for i in range(snake_case__  ):
										for j in range(snake_case__  ):
												s += classes[i] - classes[i] * self.optimum[i] * self.kernel(
												    observations[i]					,							observations[j]  )
								SCREAMING_SNAKE_CASE_					      =							s / n






						def 	__a					(			self	:   Any					,							snake_case__	:   ndarray  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							sum(
								    self.optimum[n]
								    * self.classes[n]
								    * self.kernel(self.observations[n]					,							snake_case__  )
								    for n in range(len(self.classes  )  )  )
								return 1 if s + self.offset >= 0 else -1


if __name__ == "__main__":
						import doctest

						doctest.testmod()