





import random
class SCREAMING_SNAKE_CASE_    :






						def __init__(   self   :   Optional[int]		, _A   :   list[list[float]]		, _A   :   list[int]		, _A   :   float = 0.0_1		, _A   :   int = 1000		, _A   :   float = -1		, )				->     None:







							"""simple docstring"""


							snake_case_		:      List[Any]           =						sample
							if len(self.sample						) == 0:
								raise ValueError('Sample data can not be empty'						)
							snake_case_		:      str           =						target
							if len(self.target						) == 0:
								raise ValueError('Target data can not be empty'						)
							if len(self.sample						) != len(self.target						):
								raise ValueError('Sample data and Target data do not have matching lengths'						)
							snake_case_		:      Optional[Any]           =						learning_rate
							snake_case_		:      Optional[int]           =						epoch_number
							snake_case_		:      str           =						bias
							snake_case_		:      Optional[int]           =						len(_A						)
							snake_case_		:      str           =						len(sample[0]						)  # number of columns in dataset
							snake_case_		:      list           =						[]






						def UpperCAmelCase_					(   self   :   Optional[int]						)				->     None:







							"""simple docstring"""


							for sample in self.sample:
								sample.insert(0		, self.bias						)

							for _ in range(self.col_sample						):
								self.weight.append(random.random()						)

							self.weight.insert(0		, self.bias						)

							snake_case_		:      List[str]           =						0

							while True:
								snake_case_		:      str           =						False
								for i in range(self.number_sample						):
									snake_case_		:      Any           =						0
									for j in range(self.col_sample + 1						):
										snake_case_		:      List[Any]           =						u + self.weight[j] * self.sample[i][j]
									snake_case_		:      List[str]           =						self.sign(_A						)
									if y != self.target[i]:
										for j in range(self.col_sample + 1						):
											snake_case_		:      Any           =						(
											    self.weight[j]
											    + self.learning_rate
											    * (self.target[i] - y)
											    * self.sample[i][j]
											)
										snake_case_		:      str           =						True
            # print('Epoch: \n',epoch_count)
								snake_case_		:      Optional[Any]           =						epoch_count + 1
								# if you want control the epoch or just by error
								if not has_misclassified:
									print(('\nEpoch:\n', epoch_count)						)
									print('------------------------\n'						)
									# if epoch_count > self.epoch_number or not error:
									break






						def UpperCAmelCase_					(   self   :   int		, _A   :   list[float]						)				->     None:







							"""simple docstring"""


							if len(self.sample						) == 0:
								raise ValueError('Sample data can not be empty'						)
							sample.insert(0		, self.bias						)
							snake_case_		:      List[str]           =						0
							for i in range(self.col_sample + 1						):
								snake_case_		:      List[str]           =						u + self.weight[i] * sample[i]

							snake_case_		:      str           =						self.sign(_A						)

							if y == -1:
								print(('Sample: ', sample)						)
								print('classification: P1'						)
							else:
								print(('Sample: ', sample)						)
								print('classification: P2'						)






						def UpperCAmelCase_					(   self   :   Optional[Any]		, _A   :   float						)				->     int:







							"""simple docstring"""


							return 1 if u >= 0 else -1
_SCREAMING_SNAKE_CASE   						=		[
    [-0.6_5_0_8, 0.1_0_9_7, 4.0_0_0_9],
    [-1.4_4_9_2, 0.8_8_9_6, 4.4_0_0_5],
    [2.0_8_5_0, 0.6_8_7_6, 1_2.0_7_1_0],
    [0.2_6_2_6, 1.1_4_7_6, 7.7_9_8_5],
    [0.6_4_1_8, 1.0_2_3_4, 7.0_4_2_7],
    [0.2_5_6_9, 0.6_7_3_0, 8.3_2_6_5],
    [1.1_1_5_5, 0.6_0_4_3, 7.4_4_4_6],
    [0.0_9_1_4, 0.3_3_9_9, 7.0_6_7_7],
    [0.0_1_2_1, 0.5_2_5_6, 4.6_3_1_6],
    [-0.0_4_2_9, 0.4_6_6_0, 5.4_3_2_3],
    [0.4_3_4_0, 0.6_8_7_0, 8.2_2_8_7],
    [0.2_7_3_5, 1.0_2_8_7, 7.1_9_3_4],
    [0.4_8_3_9, 0.4_8_5_1, 7.4_8_5_0],
    [0.4_0_8_9, -0.1_2_6_7, 5.5_0_1_9],
    [1.4_3_9_1, 0.1_6_1_4, 8.5_8_4_3],
    [-0.9_1_1_5, -0.1_9_7_3, 2.1_9_6_2],
    [0.3_6_5_4, 1.0_4_7_5, 7.4_8_5_8],
    [0.2_1_4_4, 0.7_5_1_5, 7.1_6_9_9],
    [0.2_0_1_3, 1.0_0_1_4, 6.5_4_8_9],
    [0.6_4_8_3, 0.2_1_8_3, 5.8_9_9_1],
    [-0.1_1_4_7, 0.2_2_4_2, 7.2_4_3_5],
    [-0.7_9_7_0, 0.8_7_9_5, 3.8_7_6_2],
    [-1.0_6_2_5, 0.6_3_6_6, 2.4_7_0_7],
    [0.5_3_0_7, 0.1_2_8_5, 5.6_8_8_3],
    [-1.2_2_0_0, 0.7_7_7_7, 1.7_2_5_2],
    [0.3_9_5_7, 0.1_0_7_6, 5.6_6_2_3],
    [-0.1_0_1_3, 0.5_9_8_9, 7.1_8_1_2],
    [2.4_4_8_2, 0.9_4_5_5, 1_1.2_0_9_5],
    [2.0_1_4_9, 0.6_1_9_2, 1_0.9_2_6_3],
    [0.2_0_1_2, 0.2_6_1_1, 5.4_6_3_1],
]

_SCREAMING_SNAKE_CASE   						=		[
    -1,
    -1,
    -1,
    1,
    1,
    -1,
    1,
    -1,
    1,
    1,
    -1,
    1,
    -1,
    -1,
    -1,
    -1,
    1,
    1,
    1,
    1,
    -1,
    1,
    1,
    1,
    1,
    -1,
    -1,
    1,
    -1,
    1,
]


if __name__ == "__main__":
						import doctest

						doctest.testmod()

						_SCREAMING_SNAKE_CASE   						=		Perceptron(
						    sample=samples, target=target, learning_rate=0.0_1, epoch_number=10_00, bias=-1
						)
						network.training()
						print("""Finished training perceptron""")
						print("""Enter values to predict or q to exit""")
						while True:
												_SCREAMING_SNAKE_CASE   						=		[]
												for i in range(len(samples[0])):
																		_SCREAMING_SNAKE_CASE   						=		input("""value: """).strip()
																		if user_input == "q":
																								break
																		_SCREAMING_SNAKE_CASE   						=		float(user_input)
																		sample.insert(i, observation)
												network.sort(sample)


import math
from timeit import timeit







def 					__lowerCAmelCase				(		__SCREAMING_SNAKE_CASE       :					int   ):







    '''simple docstring'''
    __snake_case       :				Optional[Any] 			=    0
    __snake_case       :				Union[str, Any] 			=    abs(__SCREAMING_SNAKE_CASE   )
    while True:
        __snake_case       :				List[str] 			=    n // 1_0
        digits += 1
        if n == 0:
            break
    return digits







def 					__lowerCAmelCase				(		__SCREAMING_SNAKE_CASE       :					int   ):







    '''simple docstring'''
    return 1 if n == 0 else math.floor(math.log(abs(__SCREAMING_SNAKE_CASE   )		,							1_0   ) + 1   )







def 					__lowerCAmelCase				(		__SCREAMING_SNAKE_CASE       :					int   ):







    '''simple docstring'''
    return len(str(abs(__SCREAMING_SNAKE_CASE   )   )   )







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    from collections.abc import Callable

    def benchmark_a_function(__SCREAMING_SNAKE_CASE       :					Callable		,							__SCREAMING_SNAKE_CASE       :					int   ) -> None:
        __snake_case       :				Tuple 			=    F'''{func.__name__}({value})'''
        __snake_case       :				Union[str, Any] 			=    timeit(F'''__main__.{call}'''		,							setup="""import __main__"""   )
        print(F'''{call}: {func(__SCREAMING_SNAKE_CASE   )} -- {timing} seconds'''   )

    for value in (2_6_2_1_4_4, 1_1_2_5_8_9_9_9_0_6_8_4_2_6_2_4, 1_2_6_7_6_5_0_6_0_0_2_2_8_2_2_9_4_0_1_4_9_6_7_0_3_2_0_5_3_7_6):
        for func in (num_digits, num_digits_fast, num_digits_faster):
            benchmark_a_function(__SCREAMING_SNAKE_CASE		,							__SCREAMING_SNAKE_CASE   )
        print()


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     benchmark()



