





'''simple docstring'''







import math
class 				__SCREAMING_SNAKE_CASE  :






				"""simple docstring"""







				def   UpperCamelCase__   (  self     :					List[str]					,				__a     :					list[list[float]]					,				__a     :					list[int]					):
								_a								= 0.0
								_a								= 0.0
								for i in range(len(__a					)					):
												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   UpperCamelCase__   (  self     :					List[Any]					,				__a     :					list[list[int | float]]					,				__a     :					list[int]					,				__a     :					int					,				__a     :					float					):
								for i in range(len(__a					)					):
												weights[j][i] += alpha * (sample[i] - weights[j][i])
								return weights






def  _lowerCamelCase				( )	->	None:
				# Training Examples ( m, n )
				_a								= [[1, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 1]]

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

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

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

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

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

    # classify test sample
				_a								= [0, 0, 0, 1]
				_a								= 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()



"""simple docstring"""





import time
from contextlib import contextmanager
from pathlib import Path

import pytest
import requests
from huggingface_hub.hf_api import HfApi, HfFolder


_a       =							'__DUMMY_TRANSFORMERS_USER__'
_a       =							'Dummy User'
_a       =							'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'

_a       =							'https://hub-ci.huggingface.co'
_a       =							CI_HUB_ENDPOINT + '/datasets/{repo_id}/resolve/{revision}/{path}'
_a       =							CI_HUB_ENDPOINT + '/{repo_id}/resolve/{revision}/{filename}'
_a       =							Path('~/.huggingface/hub_ci_token').expanduser()




@pytest.fixture
def   _A  (  UpperCamelCase_     :       List[Any])	->						Tuple:
   '''simple docstring'''


   monkeypatch.setattr(
       "huggingface_hub.file_download.HUGGINGFACE_CO_URL_TEMPLATE",			UpperCamelCase_)




@pytest.fixture
def   _A  (  UpperCamelCase_     :       int)	->						List[Any]:
   '''simple docstring'''


   monkeypatch.setattr("datasets.config.HF_ENDPOINT",			UpperCamelCase_)
   monkeypatch.setattr("datasets.config.HUB_DATASETS_URL",			UpperCamelCase_)




@pytest.fixture
def   _A  (  UpperCamelCase_     :       str)	->						Dict:
   '''simple docstring'''


   monkeypatch.setattr("huggingface_hub.hf_api.HfFolder.path_token",			UpperCamelCase_)




@pytest.fixture
def   _A  (  UpperCamelCase_     :       Optional[Any],			UpperCamelCase_     :       List[Any])	->						List[str]:
   '''simple docstring'''


   HfFolder.save_token(UpperCamelCase_)
   yield
   HfFolder.delete_token()




@pytest.fixture(scope="session")
def   _A  (  )	->						List[Any]:
   '''simple docstring'''


   return HfApi(endpoint=UpperCamelCase_)




@pytest.fixture(scope="session")
def   _A  (  UpperCamelCase_     :       HfApi)	->						List[Any]:
   '''simple docstring'''


   __lowercase								=						HfFolder.get_token()
   HfFolder.save_token(UpperCamelCase_)
   yield CI_HUB_USER_TOKEN
   if previous_token is not None:
      HfFolder.save_token(UpperCamelCase_)




@pytest.fixture
def   _A  (  UpperCamelCase_     :       Dict)	->						int:
   '''simple docstring'''


   def _cleanup_repo(UpperCamelCase_     :       Optional[int]):
      hf_api.delete_repo(UpperCamelCase_,			token=UpperCamelCase_,			repo_type="dataset")

   return _cleanup_repo




@pytest.fixture
def   _A  (  UpperCamelCase_     :       str)	->						Any:
   '''simple docstring'''


   @contextmanager
   def _temporary_repo(UpperCamelCase_     :       Any):
      try:
         yield repo_id
      finally:
         cleanup_repo(UpperCamelCase_)

   return _temporary_repo




@pytest.fixture(scope="session")
def   _A  (  UpperCamelCase_     :       HfApi,			UpperCamelCase_     :       str,			UpperCamelCase_     :       Optional[int])	->						List[Any]:
   '''simple docstring'''


   __lowercase								=						F"""repo_txt_data-{int(time.time() * 10E3)}"""
   __lowercase								=						F"""{CI_HUB_USER}/{repo_name}"""
   hf_api.create_repo(UpperCamelCase_,			token=UpperCamelCase_,			repo_type="dataset",			private=UpperCamelCase_)
   hf_api.upload_file(
       token=UpperCamelCase_,			path_or_fileobj=str(UpperCamelCase_),			path_in_repo="data/text_data.txt",			repo_id=UpperCamelCase_,			repo_type="dataset",			)
   yield repo_id
   try:
      hf_api.delete_repo(UpperCamelCase_,			token=UpperCamelCase_,			repo_type="dataset")
   except (requests.exceptions.HTTPError, ValueError):  # catch http error and token invalid error
      pass




@pytest.fixture()
def   _A  (  UpperCamelCase_     :       Tuple,			UpperCamelCase_     :       Any,			UpperCamelCase_     :       Dict)	->						Optional[int]:
   '''simple docstring'''


   return hf_private_dataset_repo_txt_data_




@pytest.fixture(scope="session")
def   _A  (  UpperCamelCase_     :       HfApi,			UpperCamelCase_     :       int,			UpperCamelCase_     :       Optional[int])	->						int:
   '''simple docstring'''


   __lowercase								=						F"""repo_zipped_txt_data-{int(time.time() * 10E3)}"""
   __lowercase								=						F"""{CI_HUB_USER}/{repo_name}"""
   hf_api.create_repo(UpperCamelCase_,			token=UpperCamelCase_,			repo_type="dataset",			private=UpperCamelCase_)
   hf_api.upload_file(
       token=UpperCamelCase_,			path_or_fileobj=str(UpperCamelCase_),			path_in_repo="data.zip",			repo_id=UpperCamelCase_,			repo_type="dataset",			)
   yield repo_id
   try:
      hf_api.delete_repo(UpperCamelCase_,			token=UpperCamelCase_,			repo_type="dataset")
   except (requests.exceptions.HTTPError, ValueError):  # catch http error and token invalid error
      pass




@pytest.fixture()
def   _A  (  UpperCamelCase_     :       List[str],			UpperCamelCase_     :       Dict,			UpperCamelCase_     :       Any)	->						int:
   '''simple docstring'''


   return hf_private_dataset_repo_zipped_txt_data_




@pytest.fixture(scope="session")
def   _A  (  UpperCamelCase_     :       HfApi,			UpperCamelCase_     :       List[str],			UpperCamelCase_     :       List[str])	->						List[Any]:
   '''simple docstring'''


   __lowercase								=						F"""repo_zipped_img_data-{int(time.time() * 10E3)}"""
   __lowercase								=						F"""{CI_HUB_USER}/{repo_name}"""
   hf_api.create_repo(UpperCamelCase_,			token=UpperCamelCase_,			repo_type="dataset",			private=UpperCamelCase_)
   hf_api.upload_file(
       token=UpperCamelCase_,			path_or_fileobj=str(UpperCamelCase_),			path_in_repo="data.zip",			repo_id=UpperCamelCase_,			repo_type="dataset",			)
   yield repo_id
   try:
      hf_api.delete_repo(UpperCamelCase_,			token=UpperCamelCase_,			repo_type="dataset")
   except (requests.exceptions.HTTPError, ValueError):  # catch http error and token invalid error
      pass




@pytest.fixture()
def   _A  (  UpperCamelCase_     :       Union[str, Any],			UpperCamelCase_     :       List[str],			UpperCamelCase_     :       List[str])	->						str:
   '''simple docstring'''


   return hf_private_dataset_repo_zipped_img_data_




