

'''simple docstring'''
import math

class 						__magic_name__   :







 def 						_A(       self  , snake_case_  , snake_case_   ):
   lowercase									=0.0
   lowercase									=0.0
   for i in range(len(snake_case_   )   ):
     da += math.pow((sample[i] - weights[0][i])  , 2   )
     da += math.pow((sample[i] - weights[1][i])  , 2   )
     return 0 if da > da else 1
   return 0







 def 						_A(       self  , snake_case_  , snake_case_  , snake_case_  , snake_case_   ):
   for i in range(len(snake_case_   )   ):
     weights[j][i] += alpha * (sample[i] - weights[j][i])
   return weights




def 	UpperCamelCase   (       )		->	None:




  '''simple docstring'''



  lowercase									=[[1, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 1]]

  # weight initialization ( n, C )
  lowercase									=[[0.2, 0.6, 0.5, 0.9], [0.8, 0.4, 0.7, 0.3]]

  # training
  lowercase									=SelfOrganizingMap()
  lowercase									=3
  lowercase									=0.5

  for _ in range(lowercase_	):
    for j in range(len(lowercase_	)	):
      # training sample
      lowercase									=training_samples[j]

      # Compute the winning vector
      lowercase									=self_organizing_map.get_winner(lowercase_     ,					lowercase_	)

      # Update the winning vector
      lowercase									=self_organizing_map.update(lowercase_     ,					lowercase_     ,					lowercase_     ,					lowercase_	)

    # classify test sample
  lowercase									=[0, 0, 0, 1]
  lowercase									=self_organizing_map.get_winner(lowercase_     ,					lowercase_	)

  # results
  print(f'Clusters that the test sample belongs to : {winner}'	)
  print(f'Weights that have been trained : {weights}'	)


# running the main() function
if __name__ == "__main__":
     main()



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


UpperCAmelCase_							:					Optional[Any]		 =   {
    '''configuration_wav2vec2''': ['''WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Wav2Vec2Config'''],
    '''feature_extraction_wav2vec2''': ['''Wav2Vec2FeatureExtractor'''],
    '''processing_wav2vec2''': ['''Wav2Vec2Processor'''],
    '''tokenization_wav2vec2''': ['''Wav2Vec2CTCTokenizer''', '''Wav2Vec2Tokenizer'''],
}


try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			UpperCAmelCase_							:					Optional[Any]		 =   [
			    '''WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''Wav2Vec2ForAudioFrameClassification''',
			    '''Wav2Vec2ForCTC''',
			    '''Wav2Vec2ForMaskedLM''',
			    '''Wav2Vec2ForPreTraining''',
			    '''Wav2Vec2ForSequenceClassification''',
			    '''Wav2Vec2ForXVector''',
			    '''Wav2Vec2Model''',
			    '''Wav2Vec2PreTrainedModel''',
			]

try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			UpperCAmelCase_							:					List[Any]		 =   [
			    '''TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''TFWav2Vec2ForCTC''',
			    '''TFWav2Vec2Model''',
			    '''TFWav2Vec2PreTrainedModel''',
			    '''TFWav2Vec2ForSequenceClassification''',
			]

try:
			if not is_flax_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			UpperCAmelCase_							:					Dict		 =   [
			    '''FlaxWav2Vec2ForCTC''',
			    '''FlaxWav2Vec2ForPreTraining''',
			    '''FlaxWav2Vec2Model''',
			    '''FlaxWav2Vec2PreTrainedModel''',
			]


if TYPE_CHECKING:
			from .configuration_wavaveca import WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, WavaVecaConfig
			from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
			from .processing_wavaveca import WavaVecaProcessor
			from .tokenization_wavaveca import WavaVecaCTCTokenizer, WavaVecaTokenizer

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_wavaveca import (
						    WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
						    WavaVecaForAudioFrameClassification,
						    WavaVecaForCTC,
						    WavaVecaForMaskedLM,
						    WavaVecaForPreTraining,
						    WavaVecaForSequenceClassification,
						    WavaVecaForXVector,
						    WavaVecaModel,
						    WavaVecaPreTrainedModel,
						)

			try:
						if not is_tf_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_wavaveca import (
						    TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFWavaVecaForCTC,
						    TFWavaVecaForSequenceClassification,
						    TFWavaVecaModel,
						    TFWavaVecaPreTrainedModel,
						)

			try:
						if not is_flax_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_wavaveca import (
						    FlaxWavaVecaForCTC,
						    FlaxWavaVecaForPreTraining,
						    FlaxWavaVecaModel,
						    FlaxWavaVecaPreTrainedModel,
						)


else:
			import sys

			UpperCAmelCase_							:					Optional[Any]		 =   _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





