





import math

class 							__SCREAMING_SNAKE_CASE       :






							def 					_lowerCamelCase		(    self	,			__lowerCAmelCase	,			__lowerCAmelCase	):
														UpperCamelCase__					  =      0.0
														UpperCamelCase__					  =      0.0
														for i in range(len(__lowerCAmelCase	)	):
																					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 					_lowerCamelCase		(    self	,			__lowerCAmelCase	,			__lowerCAmelCase	,			__lowerCAmelCase	,			__lowerCAmelCase	):
														for i in range(len(__lowerCAmelCase	)	):
																					weights[j][i] += alpha * (sample[i] - weights[j][i])
														return weights






def      _UpperCamelCase  ():






							"""simple docstring"""





							UpperCamelCase__					  =      [[1, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 1]]

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

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

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

																					# Compute the winning vector
																					UpperCamelCase__					  =      self_organizing_map.get_winner(a__ ,      a__							)

																					# Update the winning vector
																					UpperCamelCase__					  =      self_organizing_map.update(a__ ,      a__ ,      a__ ,      a__							)

    # classify test sample
							UpperCamelCase__					  =      [0, 0, 0, 1]
							UpperCamelCase__					  =      self_organizing_map.get_winner(a__ ,      a__							)

							# 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()











# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re

from ..utils import cached_file


# docstyle-ignore
UpperCamelCase__           =			"\nHuman: <<task>>\n\nAssistant: "


UpperCamelCase__           =			"huggingface-tools/default-prompts"
UpperCamelCase__           =			{"chat": "chat_prompt_template.txt", "run": "run_prompt_template.txt"}





def      _UpperCamelCase  (a__ :List[Any] ,      a__ :Optional[Any] ,      a__ :List[str]="run"							):






							"""simple docstring"""





							if prompt_or_repo_id is None:
														UpperCamelCase__					  =      DEFAULT_PROMPTS_REPO

							# prompt is considered a repo ID when it does not contain any kind of space
							if re.search("""\\s""" ,      a__							) is not None:
														return prompt_or_repo_id

							UpperCamelCase__					  =      cached_file(
							    a__ ,      PROMPT_FILES[mode] ,      repo_type="""dataset""" ,      user_agent={"""agent""": agent_name}							)
							with open(a__ ,      """r""" ,      encoding="""utf-8"""							) as f:
														return f.read()




