code: 
  
  
  
  
  
  import random
  
  
  
  
  class 				_lowerCamelCase :
  
  
  
        """simple docstring"""
  
  
  
  
  
  
        def __init__( self				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase = 0.01				,						UpperCAmelCase = 1000				,						UpperCAmelCase = -1				,						)       ->   None:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				Optional[Any]        =       sample
          if len(self.sample   ) == 0:
            raise ValueError("Sample data can not be empty"   )
          __snake_case   :				Union[str, Any]        =       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[str]        =       learning_rate
          __snake_case   :				Dict        =       epoch_number
          __snake_case   :				List[Any]        =       bias
          __snake_case   :				Dict        =       len(UpperCAmelCase   )
          __snake_case   :				int        =       len(sample[0]   )  # number of columns in dataset
          __snake_case   :				list        =       []
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   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[Any]        =       0
  
          while True:
            __snake_case   :				List[str]        =       False
            for i in range(self.number_sample   ):
              __snake_case   :				Union[str, 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(UpperCAmelCase   )
              if y != self.target[i]:
                for j in range(self.col_sample + 1   ):
                  __snake_case   :				Optional[int]        =       (
                      self.weight[j]
                      + self.learning_rate
                      * (self.target[i] - y)
                      * self.sample[i][j]
                  )
                __snake_case   :				List[str]        =       True
              # print('Epoch: \n',epoch_count)
            __snake_case   :				Optional[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 						UpperCAmelCase		( self				,						UpperCAmelCase   )       ->   None:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          if len(self.sample   ) == 0:
            raise ValueError("Sample data can not be empty"   )
          sample.insert(0				,						self.bias   )
          __snake_case   :				List[Any]        =       0
          for i in range(self.col_sample + 1   ):
            __snake_case   :				Optional[int]        =       u + self.weight[i] * sample[i]
  
          __snake_case   :				Tuple        =       self.sign(UpperCAmelCase   )
  
          if y == -1:
            print(("Sample: ", sample)   )
            print("classification: P1"   )
          else:
            print(("Sample: ", sample)   )
            print("classification: P2"   )
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self				,						UpperCAmelCase   )       ->   int:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          return 1 if u >= 0 else -1
  
  
  
  
  _UpperCamelCase       = [
      [-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],
  ]
  
  _UpperCamelCase       = [
      -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()
  
       _UpperCamelCase       = Perceptron(
           sample=samples, target=target, learning_rate=0.01, epoch_number=1000, bias=-1
       )
       network.training()
       print('''Finished training perceptron''')
       print('''Enter values to predict or q to exit''')
       while True:
            _UpperCamelCase       = []
            for i in range(len(samples[0])):
                 _UpperCamelCase       = input('''value: ''').strip()
                 if user_input == "q":
                      break
                 _UpperCamelCase       = float(user_input)
                 sample.insert(i, observation)
            network.sort(sample)
  
  
style_context: 
  
  
  
  
  
  import torch
  from torch import autograd
  
  
  
  
  class 				_lowerCamelCase (    autograd.Function    ):
  
  
  
        """simple docstring"""
  
  
  
  
  
  
        @staticmethod
        def 						UpperCAmelCase		( UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase   )       ->   str:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				Dict        =       inputs.numel()
          __snake_case   :				Optional[int]        =       int(0.005 * nb_elems   ) + 1
          if sigmoid:
            __snake_case   :				Any        =       (torch.sigmoid(UpperCAmelCase   ) > threshold).type(inputs.type()   )
          else:
            __snake_case   :				Optional[int]        =       (inputs > threshold).type(inputs.type()   )
          if mask.sum() < nb_min:
            # We limit the pruning so that at least 0.5% (half a percent) of the weights are remaining
            __snake_case   :				List[str]        =       inputs.flatten().kthvalue(max(nb_elems - nb_min				,						1   )   ).values
            __snake_case   :				Union[str, Any]        =       (inputs > k_threshold).type(inputs.type()   )
          return mask
  
  
  
  
  
  
  
        @staticmethod
        def 						UpperCAmelCase		( UpperCAmelCase				,						UpperCAmelCase   )       ->   Optional[int]:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          return gradOutput, None, None
  
  
  
  
  class 				_lowerCamelCase (    autograd.Function    ):
  
  
  
        """simple docstring"""
  
  
  
  
  
  
        @staticmethod
        def 						UpperCAmelCase		( UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase   )       ->   Optional[int]:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				Optional[int]        =       inputs.clone()
          __snake_case    ,   __snake_case   :				int        =       inputs.flatten().sort(descending=UpperCAmelCase   )
          __snake_case   :				Tuple        =       int(threshold * inputs.numel()   )
  
          # flat_out and mask access the same memory.
          __snake_case   :				Optional[int]        =       mask.flatten()
          __snake_case   :				Union[str, Any]        =       0
          __snake_case   :				Any        =       1
          return mask
  
  
  
  
  
  
  
        @staticmethod
        def 						UpperCAmelCase		( UpperCAmelCase				,						UpperCAmelCase   )       ->   List[str]:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          return gradOutput, None
  
  
  
  
  class 				_lowerCamelCase (    a    ):
  
  
  
        """simple docstring"""
  
  
  
  
  
  
        @staticmethod
        def 						UpperCAmelCase		( UpperCAmelCase				,						UpperCAmelCase   )       ->   Any:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				Union[str, Any]        =       inputs.clone()
          __snake_case    ,   __snake_case   :				Optional[Any]        =       inputs.abs().flatten().sort(descending=UpperCAmelCase   )
          __snake_case   :				List[Any]        =       int(threshold * inputs.numel()   )
  
          # flat_out and mask access the same memory.
          __snake_case   :				Optional[Any]        =       mask.flatten()
          __snake_case   :				Tuple        =       0
          __snake_case   :				Any        =       1
          return mask
  
  