



from collections.abc import Callable
from math import log
from os import name, system
from random import gauss, seed
from typing import TypeVar



def  __a  (					lowerCAmelCase_     :      Dict    ,lowerCAmelCase_     :      Optional[int]    ,lowerCAmelCase_     :      Optional[Any]       )   ->				list:






      '''simple docstring'''



      seed(1       )
      return [gauss(lowerCAmelCase_    ,lowerCAmelCase_       ) for _ in range(lowerCAmelCase_       )]



def  __a  (					lowerCAmelCase_     :      int    ,lowerCAmelCase_     :      Dict       )   ->				list:






      '''simple docstring'''



      return [k for k in range(lowerCAmelCase_       ) for _ in range(instance_count[k]       )]



def  __a  (					lowerCAmelCase_     :      Optional[int]    ,lowerCAmelCase_     :      Dict       )   ->				float:






      '''simple docstring'''



      return sum(lowerCAmelCase_       ) / instance_count



def  __a  (					lowerCAmelCase_     :      List[str]    ,lowerCAmelCase_     :      Optional[int]       )   ->				float:






      '''simple docstring'''



      return instance_count / total_count



def  __a  (					lowerCAmelCase_     :      Optional[Any]    ,lowerCAmelCase_     :      int    ,lowerCAmelCase_     :      Tuple       )   ->				float:






      '''simple docstring'''



      UpperCAmelCase_=     []  # An empty list to store all squared differences
      # iterate over number of elements in items
      for i in range(len(lowerCAmelCase_       )       ):
            # for loop iterates over number of elements in inner layer of items
            for j in range(len(items[i]       )       ):
                  # appending squared differences to 'squared_diff' list
                  squared_diff.append((items[i][j] - means[i]) ** 2       )

    # one divided by (the number of all instances - number of classes) multiplied by
    # sum of all squared differences
      UpperCAmelCase_=     len(lowerCAmelCase_       )  # Number of classes in dataset
      return 1 / (total_count - n_classes) * sum(lowerCAmelCase_       )



def  __a  (					lowerCAmelCase_     :      Any    ,lowerCAmelCase_     :      List[Any]    ,lowerCAmelCase_     :      Optional[Any]    ,lowerCAmelCase_     :      List[Any]       )   ->				list:






      '''simple docstring'''



      UpperCAmelCase_=     []
      # for loop iterates over number of elements in list
      for i in range(len(lowerCAmelCase_       )       ):
            # for loop iterates over number of inner items of each element
            for j in range(len(x_items[i]       )       ):
                  UpperCAmelCase_=     []  # to store all discriminant values of each item as a list
                  # for loop iterates over number of classes we have in our dataset
                  for k in range(len(lowerCAmelCase_       )       ):
                        # appending values of discriminants for each class to 'temp' list
                        temp.append(
                            x_items[i][j] * (means[k] / variance)
                            - (means[k] ** 2 / (2 * variance))
                            + log(probabilities[k]       )       )
                  # appending discriminant values of each item to 'results' list
                  results.append(lowerCAmelCase_       )

      return [result.index(max(lowerCAmelCase_       )       ) for result in results]



def  __a  (					lowerCAmelCase_     :      Union[str, Any]    ,lowerCAmelCase_     :      Dict       )   ->				float:






      '''simple docstring'''



      UpperCAmelCase_=     sum(1 for i, j in zip(lowerCAmelCase_    ,lowerCAmelCase_       ) if i == j       )
      # percentage of accuracy equals to number of correct predictions divided by number
      # of all data and multiplied by 100
      return (correct / len(lowerCAmelCase_       )) * 1_00


__A       					=		TypeVar('''num''')



def  __a  (					lowerCAmelCase_     :      Dict    ,lowerCAmelCase_     :      List[Any]    ,lowerCAmelCase_     :      Dict    ,lowerCAmelCase_     :      Union[str, Any] = lambda lowerCAmelCase_       : True    ,lowerCAmelCase_     :      List[str] = None    ,)   ->				num:






      '''simple docstring'''



      while True:
            try:
                  UpperCAmelCase_=     input_type(input(lowerCAmelCase_       ).strip() or default       )
                  if condition(lowerCAmelCase_       ):
                        return user_input
                  else:
                        print(F"""{user_input}: {err_msg}"""       )
                        continue
            except ValueError:
                  print(
                      F"""{user_input}: Incorrect input type, expected {input_type.__name__!r}"""       )



def  __a  (					)   ->				List[str]:






      '''simple docstring'''



      while True:
            print(""" Linear Discriminant Analysis """.center(50    ,"""*"""       )       )
            print("""*""" * 50    ,"""\n"""       )
            print("""First of all we should specify the number of classes that"""       )
            print("""we want to generate as training dataset"""       )
            # Trying to get number of classes
            UpperCAmelCase_=     valid_input(
                input_type=lowerCAmelCase_    ,condition=lambda lowerCAmelCase_       : x > 0    ,input_msg="""Enter the number of classes (Data Groupings): """    ,err_msg="""Number of classes should be positive!"""    ,)

            print("""-""" * 1_00       )

            # Trying to get the value of standard deviation
            UpperCAmelCase_=     valid_input(
                input_type=lowerCAmelCase_    ,condition=lambda lowerCAmelCase_       : x >= 0    ,input_msg=(
                    """Enter the value of standard deviation"""
                    """(Default value is 1.0 for all classes): """
                )    ,err_msg="""Standard deviation should not be negative!"""    ,default="""1.0"""    ,)

            print("""-""" * 1_00       )

            # Trying to get number of instances in classes and theirs means to generate
            # dataset
            UpperCAmelCase_=     []  # An empty list to store instance counts of classes in dataset
            for i in range(lowerCAmelCase_       ):
                  UpperCAmelCase_=     valid_input(
                      input_type=lowerCAmelCase_    ,condition=lambda lowerCAmelCase_       : x > 0    ,input_msg=(F"""Enter The number of instances for class_{i+1}: """)    ,err_msg="""Number of instances should be positive!"""    ,)
                  counts.append(lowerCAmelCase_       )
            print("""-""" * 1_00       )

            # An empty list to store values of user-entered means of classes
            UpperCAmelCase_=     []
            for a in range(lowerCAmelCase_       ):
                  UpperCAmelCase_=     valid_input(
                      input_type=lowerCAmelCase_    ,input_msg=(F"""Enter the value of mean for class_{a+1}: """)    ,err_msg="""This is an invalid value."""    ,)
                  user_means.append(lowerCAmelCase_       )
            print("""-""" * 1_00       )

            print("""Standard deviation: """    ,lowerCAmelCase_       )
            # print out the number of instances in classes in separated line
            for i, count in enumerate(lowerCAmelCase_    ,1       ):
                  print(F"""Number of instances in class_{i} is: {count}"""       )
            print("""-""" * 1_00       )

            # print out mean values of classes separated line
            for i, user_mean in enumerate(lowerCAmelCase_    ,1       ):
                  print(F"""Mean of class_{i} is: {user_mean}"""       )
            print("""-""" * 1_00       )

            # Generating training dataset drawn from gaussian distribution
            UpperCAmelCase_=     [
                gaussian_distribution(user_means[j]    ,lowerCAmelCase_    ,counts[j]       )
                for j in range(lowerCAmelCase_       )
            ]
            print("""Generated Normal Distribution: \n"""    ,lowerCAmelCase_       )
            print("""-""" * 1_00       )

            # Generating Ys to detecting corresponding classes
            UpperCAmelCase_=     y_generator(lowerCAmelCase_    ,lowerCAmelCase_       )
            print("""Generated Corresponding Ys: \n"""    ,lowerCAmelCase_       )
            print("""-""" * 1_00       )

            # Calculating the value of actual mean for each class
            UpperCAmelCase_=     [calculate_mean(counts[k]    ,x[k]       ) for k in range(lowerCAmelCase_       )]
            # for loop iterates over number of elements in 'actual_means' list and print
            # out them in separated line
            for i, actual_mean in enumerate(lowerCAmelCase_    ,1       ):
                  print(F"""Actual(Real) mean of class_{i} is: {actual_mean}"""       )
            print("""-""" * 1_00       )

            # Calculating the value of probabilities for each class
            UpperCAmelCase_=     [
                calculate_probabilities(counts[i]    ,sum(lowerCAmelCase_       )       ) for i in range(lowerCAmelCase_       )
            ]

            # for loop iterates over number of elements in 'probabilities' list and print
            # out them in separated line
            for i, probability in enumerate(lowerCAmelCase_    ,1       ):
                  print(F"""Probability of class_{i} is: {probability}"""       )
            print("""-""" * 1_00       )

            # Calculating the values of variance for each class
            UpperCAmelCase_=     calculate_variance(lowerCAmelCase_    ,lowerCAmelCase_    ,sum(lowerCAmelCase_       )       )
            print("""Variance: """    ,lowerCAmelCase_       )
            print("""-""" * 1_00       )

            # Predicting Y values
            # storing predicted Y values in 'pre_indexes' variable
            UpperCAmelCase_=     predict_y_values(lowerCAmelCase_    ,lowerCAmelCase_    ,lowerCAmelCase_    ,lowerCAmelCase_       )
            print("""-""" * 1_00       )

            # Calculating Accuracy of the model
            print(F"""Accuracy: {accuracy(lowerCAmelCase_    ,lowerCAmelCase_       )}"""       )
            print("""-""" * 1_00       )
            print(""" DONE """.center(1_00    ,"""+"""       )       )

            if input("""Press any key to restart or \'q\' for quit: """       ).strip().lower() == "q":
                  print("""\n""" + """GoodBye!""".center(1_00    ,"""-"""       ) + """\n"""       )
                  break
            system("""cls""" if name == """nt""" else """clear"""       )  # noqa: S605


if __name__ == "__main__":
 main()









import unittest

from transformers import YosoConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
	import torch

	from transformers import (
	    YosoForMaskedLM,
	    YosoForMultipleChoice,
	    YosoForQuestionAnswering,
	    YosoForSequenceClassification,
	    YosoForTokenClassification,
	    YosoModel,
	)
	from transformers.models.yoso.modeling_yoso import YOSO_PRETRAINED_MODEL_ARCHIVE_LIST






class 	lowercase		:






	"""simple docstring"""


	def __init__(			self			:		int		,						__UpperCAmelCase			:		int		,						__UpperCAmelCase			:		Optional[int]=13		,						__UpperCAmelCase			:		Optional[Any]=7		,						__UpperCAmelCase			:		Union[str, Any]=True		,						__UpperCAmelCase			:		Dict=True		,						__UpperCAmelCase			:		int=True		,						__UpperCAmelCase			:		Optional[int]=True		,						__UpperCAmelCase			:		Optional[Any]=99		,						__UpperCAmelCase			:		List[Any]=32		,						__UpperCAmelCase			:		int=5		,						__UpperCAmelCase			:		List[str]=4		,						__UpperCAmelCase			:		Union[str, Any]=37		,						__UpperCAmelCase			:		Any="gelu"		,						__UpperCAmelCase			:		Any=0.1		,						__UpperCAmelCase			:		List[Any]=0.1		,						__UpperCAmelCase			:		Any=512		,						__UpperCAmelCase			:		Tuple=16		,						__UpperCAmelCase			:		Any=2		,						__UpperCAmelCase			:		Tuple=0.02		,						__UpperCAmelCase			:		Any=3		,						__UpperCAmelCase			:		Tuple=4		,						__UpperCAmelCase			:		int=None		,						)    ->				str:
							UpperCAmelCase_=     parent
							UpperCAmelCase_=     batch_size
							UpperCAmelCase_=     seq_length
							UpperCAmelCase_=     is_training
							UpperCAmelCase_=     use_input_mask
							UpperCAmelCase_=     use_token_type_ids
							UpperCAmelCase_=     use_labels
							UpperCAmelCase_=     vocab_size
							UpperCAmelCase_=     hidden_size
							UpperCAmelCase_=     num_hidden_layers
							UpperCAmelCase_=     num_attention_heads
							UpperCAmelCase_=     intermediate_size
							UpperCAmelCase_=     hidden_act
							UpperCAmelCase_=     hidden_dropout_prob
							UpperCAmelCase_=     attention_probs_dropout_prob
							UpperCAmelCase_=     max_position_embeddings
							UpperCAmelCase_=     type_vocab_size
							UpperCAmelCase_=     type_sequence_label_size
							UpperCAmelCase_=     initializer_range
							UpperCAmelCase_=     num_labels
							UpperCAmelCase_=     num_choices
							UpperCAmelCase_=     scope




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Tuple  )    ->				str:
							UpperCAmelCase_=     ids_tensor([self.batch_size, self.seq_length]		,						self.vocab_size  )

							UpperCAmelCase_=     None
							if self.use_input_mask:
													UpperCAmelCase_=     random_attention_mask([self.batch_size, self.seq_length]  )

							UpperCAmelCase_=     None
							if self.use_token_type_ids:
													UpperCAmelCase_=     ids_tensor([self.batch_size, self.seq_length]		,						self.type_vocab_size  )

							UpperCAmelCase_=     None
							UpperCAmelCase_=     None
							UpperCAmelCase_=     None
							if self.use_labels:
													UpperCAmelCase_=     ids_tensor([self.batch_size]		,						self.type_sequence_label_size  )
													UpperCAmelCase_=     ids_tensor([self.batch_size, self.seq_length]		,						self.num_labels  )
													UpperCAmelCase_=     ids_tensor([self.batch_size]		,						self.num_choices  )

							UpperCAmelCase_=     self.get_config()

							return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				List[str]:
							return YosoConfig(
							    vocab_size=self.vocab_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		,						max_position_embeddings=self.max_position_embeddings		,						type_vocab_size=self.type_vocab_size		,						is_decoder=__UpperCAmelCase		,						initializer_range=self.initializer_range		,						)




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				Union[str, Any]:
							UpperCAmelCase_=     self.get_config()
							UpperCAmelCase_=     300
							return config




	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[Any]  )    ->				str:
							(
							    (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     
							)=     self.prepare_config_and_inputs()

							UpperCAmelCase_=     True
							UpperCAmelCase_=     floats_tensor([self.batch_size, self.seq_length, self.hidden_size]  )
							UpperCAmelCase_=     ids_tensor([self.batch_size, self.seq_length]		,						vocab_size=2  )

							return (
							    config,
							    input_ids,
							    token_type_ids,
							    input_mask,
							    sequence_labels,
							    token_labels,
							    choice_labels,
							    encoder_hidden_states,
							    encoder_attention_mask,
							)




	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[Any]		,						__UpperCAmelCase			:		Optional[Any]		,						__UpperCAmelCase			:		Optional[Any]		,						__UpperCAmelCase			:		Dict		,						__UpperCAmelCase			:		int		,						__UpperCAmelCase			:		Union[str, Any]		,						__UpperCAmelCase			:		Optional[Any]		,						__UpperCAmelCase			:		Any  )    ->				List[Any]:
							UpperCAmelCase_=     YosoModel(config=__UpperCAmelCase  )
							model.to(__UpperCAmelCase  )
							model.eval()
							UpperCAmelCase_=     model(__UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase  )
							UpperCAmelCase_=     model(__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase  )
							UpperCAmelCase_=     model(__UpperCAmelCase  )
							self.parent.assertEqual(result.last_hidden_state.shape		,						(self.batch_size, self.seq_length, self.hidden_size)  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[Any]		,						__UpperCAmelCase			:		List[str]		,						__UpperCAmelCase			:		List[Any]		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		Optional[int]		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		Dict		,						__UpperCAmelCase			:		Dict		,						__UpperCAmelCase			:		Optional[int]		,						__UpperCAmelCase			:		Dict		,						)    ->				List[str]:
							UpperCAmelCase_=     True
							UpperCAmelCase_=     YosoModel(__UpperCAmelCase  )
							model.to(__UpperCAmelCase  )
							model.eval()
							UpperCAmelCase_=     model(
							    __UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase		,						encoder_hidden_states=__UpperCAmelCase		,						encoder_attention_mask=__UpperCAmelCase		,						)
							UpperCAmelCase_=     model(
							    __UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase		,						encoder_hidden_states=__UpperCAmelCase		,						)
							UpperCAmelCase_=     model(__UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase  )
							self.parent.assertEqual(result.last_hidden_state.shape		,						(self.batch_size, self.seq_length, self.hidden_size)  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		str		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		List[Any]		,						__UpperCAmelCase			:		Optional[int]		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		List[Any]		,						__UpperCAmelCase			:		Any		,						__UpperCAmelCase			:		str  )    ->				List[Any]:
							UpperCAmelCase_=     YosoForMaskedLM(config=__UpperCAmelCase  )
							model.to(__UpperCAmelCase  )
							model.eval()
							UpperCAmelCase_=     model(__UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase		,						labels=__UpperCAmelCase  )
							self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.seq_length, self.vocab_size)  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[Any]		,						__UpperCAmelCase			:		List[str]		,						__UpperCAmelCase			:		Dict		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		Tuple		,						__UpperCAmelCase			:		Tuple		,						__UpperCAmelCase			:		Optional[int]		,						__UpperCAmelCase			:		Optional[int]  )    ->				List[Any]:
							UpperCAmelCase_=     YosoForQuestionAnswering(config=__UpperCAmelCase  )
							model.to(__UpperCAmelCase  )
							model.eval()
							UpperCAmelCase_=     model(
							    __UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase		,						start_positions=__UpperCAmelCase		,						end_positions=__UpperCAmelCase		,						)
							self.parent.assertEqual(result.start_logits.shape		,						(self.batch_size, self.seq_length)  )
							self.parent.assertEqual(result.end_logits.shape		,						(self.batch_size, self.seq_length)  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Any		,						__UpperCAmelCase			:		Dict		,						__UpperCAmelCase			:		Union[str, Any]		,						__UpperCAmelCase			:		Tuple		,						__UpperCAmelCase			:		Optional[Any]		,						__UpperCAmelCase			:		Optional[Any]		,						__UpperCAmelCase			:		List[str]		,						__UpperCAmelCase			:		List[str]  )    ->				str:
							UpperCAmelCase_=     self.num_labels
							UpperCAmelCase_=     YosoForSequenceClassification(__UpperCAmelCase  )
							model.to(__UpperCAmelCase  )
							model.eval()
							UpperCAmelCase_=     model(__UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase		,						labels=__UpperCAmelCase  )
							self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.num_labels)  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict		,						__UpperCAmelCase			:		Any		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		Any		,						__UpperCAmelCase			:		int		,						__UpperCAmelCase			:		Union[str, Any]		,						__UpperCAmelCase			:		Optional[Any]		,						__UpperCAmelCase			:		Tuple  )    ->				Union[str, Any]:
							UpperCAmelCase_=     self.num_labels
							UpperCAmelCase_=     YosoForTokenClassification(config=__UpperCAmelCase  )
							model.to(__UpperCAmelCase  )
							model.eval()
							UpperCAmelCase_=     model(__UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase		,						labels=__UpperCAmelCase  )
							self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.seq_length, self.num_labels)  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		str		,						__UpperCAmelCase			:		Optional[int]		,						__UpperCAmelCase			:		List[str]		,						__UpperCAmelCase			:		List[Any]		,						__UpperCAmelCase			:		List[Any]		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		Any		,						__UpperCAmelCase			:		Optional[int]  )    ->				Any:
							UpperCAmelCase_=     self.num_choices
							UpperCAmelCase_=     YosoForMultipleChoice(config=__UpperCAmelCase  )
							model.to(__UpperCAmelCase  )
							model.eval()
							UpperCAmelCase_=     input_ids.unsqueeze(1  ).expand(-1		,						self.num_choices		,						-1  ).contiguous()
							UpperCAmelCase_=     token_type_ids.unsqueeze(1  ).expand(-1		,						self.num_choices		,						-1  ).contiguous()
							UpperCAmelCase_=     input_mask.unsqueeze(1  ).expand(-1		,						self.num_choices		,						-1  ).contiguous()
							UpperCAmelCase_=     model(
							    __UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase		,						labels=__UpperCAmelCase		,						)
							self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.num_choices)  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				Any:
							UpperCAmelCase_=     self.prepare_config_and_inputs()
							(
							    (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     
							)=     config_and_inputs
							UpperCAmelCase_=     {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
							return config, inputs_dict






@require_torch
class 	lowercase		(				snake_case__				,					snake_case__				,					unittest.TestCase):






	"""simple docstring"""


	a__   :      Any	     =							(
	    (
	        YosoModel,
	        YosoForMaskedLM,
	        YosoForMultipleChoice,
	        YosoForQuestionAnswering,
	        YosoForSequenceClassification,
	        YosoForTokenClassification,
	    )
	    if is_torch_available()
	    else ()
	)
	a__   :      Optional[int]	     =							False
	a__   :      Optional[Any]	     =							False
	a__   :      Dict	     =							False

	a__   :      int	     =							()
	a__   :      int	     =							(
	    {
	        "feature-extraction": YosoModel,
	        "fill-mask": YosoForMaskedLM,
	        "question-answering": YosoForQuestionAnswering,
	        "text-classification": YosoForSequenceClassification,
	        "token-classification": YosoForTokenClassification,
	        "zero-shot": YosoForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				Optional[int]:
							UpperCAmelCase_=     YosoModelTester(self  )
							UpperCAmelCase_=     ConfigTester(self		,						config_class=__UpperCAmelCase		,						hidden_size=37  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Union[str, Any]  )    ->				Union[str, Any]:
							self.config_tester.run_common_tests()




	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[str]  )    ->				Dict:
							UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__UpperCAmelCase  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				Any:
							UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs()
							for type in ["absolute", "relative_key", "relative_key_query"]:
													UpperCAmelCase_=     type
													self.model_tester.create_and_check_model(*__UpperCAmelCase  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		int  )    ->				Any:
							UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*__UpperCAmelCase  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Any  )    ->				Optional[int]:
							UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_multiple_choice(*__UpperCAmelCase  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[Any]  )    ->				Dict:
							UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*__UpperCAmelCase  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		str  )    ->				int:
							UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*__UpperCAmelCase  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				Optional[Any]:
							UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*__UpperCAmelCase  )




	@slow
	def 						_SCREAMING_SNAKE_CASE	(			self			:		Union[str, Any]  )    ->				Optional[Any]:
							for model_name in YOSO_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													UpperCAmelCase_=     YosoModel.from_pretrained(__UpperCAmelCase  )
													self.assertIsNotNone(__UpperCAmelCase  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				Tuple:
							return






@require_torch
class 	lowercase		(				unittest.TestCase):






	"""simple docstring"""


	@slow
	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				Optional[int]:
							UpperCAmelCase_=     YosoModel.from_pretrained("""uw-madison/yoso-4096"""  )
							UpperCAmelCase_=     torch.tensor([[0, 1, 2, 3, 4, 5]]  )

							with torch.no_grad():
													UpperCAmelCase_=     model(__UpperCAmelCase  )[0]

							UpperCAmelCase_=     torch.Size((1, 6, 768)  )
							self.assertEqual(output.shape		,						__UpperCAmelCase  )

							UpperCAmelCase_=     torch.tensor(
							    [[[-0.0_611, 0.1_242, 0.0_840], [0.0_280, -0.0_048, 0.1_125], [0.0_106, 0.0_226, 0.0_751]]]  )

							self.assertTrue(torch.allclose(output[:, :3, :3]		,						__UpperCAmelCase		,						atol=1E-4  )  )




	@slow
	def 						_SCREAMING_SNAKE_CASE	(			self			:		str  )    ->				List[Any]:
							UpperCAmelCase_=     YosoForMaskedLM.from_pretrained("""uw-madison/yoso-4096"""  )
							UpperCAmelCase_=     torch.tensor([[0, 1, 2, 3, 4, 5]]  )

							with torch.no_grad():
													UpperCAmelCase_=     model(__UpperCAmelCase  )[0]

							UpperCAmelCase_=     50_265

							UpperCAmelCase_=     torch.Size((1, 6, vocab_size)  )
							self.assertEqual(output.shape		,						__UpperCAmelCase  )

							UpperCAmelCase_=     torch.tensor(
							    [[[-2.1_313, -3.7_285, -2.2_407], [-2.7_047, -3.3_314, -2.6_408], [0.0_629, -2.5_166, -0.3_356]]]  )

							self.assertTrue(torch.allclose(output[:, :3, :3]		,						__UpperCAmelCase		,						atol=1E-4  )  )




	@slow
	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				Tuple:
							UpperCAmelCase_=     YosoForMaskedLM.from_pretrained("""uw-madison/yoso-4096"""  )
							UpperCAmelCase_=     torch.arange(4_096  ).unsqueeze(0  )

							with torch.no_grad():
													UpperCAmelCase_=     model(__UpperCAmelCase  )[0]

							UpperCAmelCase_=     50_265

							UpperCAmelCase_=     torch.Size((1, 4_096, vocab_size)  )
							self.assertEqual(output.shape		,						__UpperCAmelCase  )

							UpperCAmelCase_=     torch.tensor(
							    [[[-2.3_914, -4.3_742, -5.0_956], [-4.0_988, -4.2_384, -7.0_406], [-3.1_427, -3.7_192, -6.6_800]]]  )

							self.assertTrue(torch.allclose(output[:, :3, :3]		,						__UpperCAmelCase		,						atol=1E-4  )  )




