






'''simple docstring'''







import math

class _lowercase     :




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





def 			SCREAMING_SNAKE_CASE_	()				->	None:
							# Training Examples ( m, n )
							lowerCamelCase__ :     Any	  =	[[1, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 1]]

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

							# training
							lowerCamelCase__ :     Optional[int]	  =	SelfOrganizingMap()
							lowerCamelCase__ :     Optional[Any]	  =	3
							lowerCamelCase__ :     Tuple	  =	0.5

							for _ in range(UpperCamelCase				):
														for j in range(len(UpperCamelCase				)				):
																					# training sample
																					lowerCamelCase__ :     List[Any]	  =	training_samples[j]

																					# Compute the winning vector
																					lowerCamelCase__ :     Optional[int]	  =	self_organizing_map.get_winner(UpperCamelCase    ,      UpperCamelCase				)

																					# Update the winning vector
																					lowerCamelCase__ :     str	  =	self_organizing_map.update(UpperCamelCase    ,      UpperCamelCase    ,      UpperCamelCase    ,      UpperCamelCase				)

    # classify test sample
							lowerCamelCase__ :     List[Any]	  =	[0, 0, 0, 1]
							lowerCamelCase__ :     List[Any]	  =	self_organizing_map.get_winner(UpperCamelCase    ,      UpperCamelCase				)

							# 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'''







from torch import nn





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase				)				->	Dict:
							if act_fn in ["swish", "silu"]:
														return nn.SiLU()
							elif act_fn == "mish":
														return nn.Mish()
							elif act_fn == "gelu":
														return nn.GELU()
							else:
														raise ValueError(f'''Unsupported activation function: {act_fn}'''				)

