code: 
  '''simple docstring'''
  import random
  
  
  
  
  
  
  class   snake_case__					:
  
  
  
  
  
  
  
  		"""simple docstring"""
  
  		def __init__(			self							: List[str]     ,  UpperCamelCase__							: str     ,  UpperCamelCase__							: Tuple     ,  UpperCamelCase__							: Any = 0.01     ,  UpperCamelCase__							: List[Any] = 1000     ,  UpperCamelCase__							: Dict = -1     ,  )	-> None:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					Dict     =	sample
  				if len(self.sample			) == 0:
  						raise ValueError('''Sample data can not be empty'''			)
  				snake_case     :					Tuple     =	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     :					List[Any]     =	learning_rate
  				snake_case     :					Union[str, Any]     =	epoch_number
  				snake_case     :					Any     =	bias
  				snake_case     :					str     =	len(UpperCamelCase__			)
  				snake_case     :					Tuple     =	len(sample[0]			)  # number of columns in dataset
  				snake_case     :					list     =	[]
  
  
  
  		def 			lowerCAmelCase							(			self							: str			)	-> 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     :					Tuple     =	0
  
  				while True:
  						snake_case     :					Tuple     =	False
  						for i in range(self.number_sample			):
  								snake_case     :					Optional[int]     =	0
  								for j in range(self.col_sample + 1			):
  										snake_case     :					int     =	u + self.weight[j] * self.sample[i][j]
  								snake_case     :					Tuple     =	self.sign(UpperCamelCase__			)
  								if y != self.target[i]:
  										for j in range(self.col_sample + 1			):
  												snake_case     :					int     =	(
  												    self.weight[j]
  												    + self.learning_rate
  												    * (self.target[i] - y)
  												    * self.sample[i][j]
  												)
  										snake_case     :					Union[str, Any]     =	True
              # print('Epoch: \n',epoch_count)
  						snake_case     :					int     =	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 			lowerCAmelCase							(			self							: str     ,  UpperCamelCase__							: Any			)	-> None:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				if len(self.sample			) == 0:
  						raise ValueError('''Sample data can not be empty'''			)
  				sample.insert(0     ,  self.bias			)
  				snake_case     :					str     =	0
  				for i in range(self.col_sample + 1			):
  						snake_case     :					Optional[Any]     =	u + self.weight[i] * sample[i]
  
  				snake_case     :					Optional[int]     =	self.sign(UpperCamelCase__			)
  
  				if y == -1:
  						print(('''Sample: ''', sample)			)
  						print('''classification: P1'''			)
  				else:
  						print(('''Sample: ''', sample)			)
  						print('''classification: P2'''			)
  
  
  
  		def 			lowerCAmelCase							(			self							: List[Any]     ,  UpperCamelCase__							: Optional[Any]			)	-> int:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				return 1 if u >= 0 else -1
  
  
  
  
  
  
  
  lowercase__						=			[
      [-0.65_08, 0.10_97, 4.00_09],
      [-1.44_92, 0.88_96, 4.40_05],
      [2.08_50, 0.68_76, 12.07_10],
      [0.26_26, 1.14_76, 7.79_85],
      [0.64_18, 1.02_34, 7.04_27],
      [0.25_69, 0.67_30, 8.32_65],
      [1.11_55, 0.60_43, 7.44_46],
      [0.09_14, 0.33_99, 7.06_77],
      [0.01_21, 0.52_56, 4.63_16],
      [-0.04_29, 0.46_60, 5.43_23],
      [0.43_40, 0.68_70, 8.22_87],
      [0.27_35, 1.02_87, 7.19_34],
      [0.48_39, 0.48_51, 7.48_50],
      [0.40_89, -0.12_67, 5.50_19],
      [1.43_91, 0.16_14, 8.58_43],
      [-0.91_15, -0.19_73, 2.19_62],
      [0.36_54, 1.04_75, 7.48_58],
      [0.21_44, 0.75_15, 7.16_99],
      [0.20_13, 1.00_14, 6.54_89],
      [0.64_83, 0.21_83, 5.89_91],
      [-0.11_47, 0.22_42, 7.24_35],
      [-0.79_70, 0.87_95, 3.87_62],
      [-1.06_25, 0.63_66, 2.47_07],
      [0.53_07, 0.12_85, 5.68_83],
      [-1.22_00, 0.77_77, 1.72_52],
      [0.39_57, 0.10_76, 5.66_23],
      [-0.10_13, 0.59_89, 7.18_12],
      [2.44_82, 0.94_55, 11.20_95],
      [2.01_49, 0.61_92, 10.92_63],
      [0.20_12, 0.26_11, 5.46_31],
  ]
  
  lowercase__						=			[
      -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()
  
  					lowercase__						=			Perceptron(
  					    sample=samples, target=target, learning_rate=0.01, epoch_number=1_0_0_0, bias=-1
  					)
  					network.training()
  					print("Finished training perceptron")
  					print("Enter values to predict or q to exit")
  					while True:
  										lowercase__						=			[]
  										for i in range(len(samples[0])):
  															lowercase__						=			input("value: ").strip()
  															if user_input == "q":
  																				break
  															lowercase__						=			float(user_input)
  															sample.insert(i, observation)
  										network.sort(sample)
  
  
  
style_context: 
  '''simple docstring'''
  def       _UpperCamelCase	(					SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ )     ->       int:
  
  
  		'''simple docstring'''
  
  
  		snake_case     :					Optional[Any]     =	0
  		for ele in arr:
  				total_sum += product_sum(SCREAMING_SNAKE_CASE__   ,					depth + 1 ) if isinstance(SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ ) else ele
  		return total_sum * depth
  
  
  
  
  def       _UpperCamelCase	(					SCREAMING_SNAKE_CASE__ )     ->       int:
  
  
  		'''simple docstring'''
  
  
  		return product_sum(SCREAMING_SNAKE_CASE__   ,					1 )
  
  
  if __name__ == "__main__":
  						import doctest
  
  						doctest.testmod()
  
  
  