





import random




class 			_lowerCamelCase	:



      """simple docstring"""






      def __init__(	self			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase = 0.01			,  UpperCAmelCase = 1000			,  UpperCAmelCase = -1			,  )    ->				None:






        '''simple docstring'''






        __snake_case				:			str            =    sample
        if len(self.sample				) == 0:
          raise ValueError("Sample data can not be empty"				)
        __snake_case				:			Optional[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				:			Union[str, Any]            =    learning_rate
        __snake_case				:			int            =    epoch_number
        __snake_case				:			Union[str, Any]            =    bias
        __snake_case				:			List[str]            =    len(UpperCAmelCase				)
        __snake_case				:			List[str]            =    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				:			Optional[Any]            =    0

        while True:
          __snake_case				:			int            =    False
          for i in range(self.number_sample				):
            __snake_case				:			Tuple            =    0
            for j in range(self.col_sample + 1				):
              __snake_case				:			Optional[int]            =    u + self.weight[j] * self.sample[i][j]
            __snake_case				:			Any            =    self.sign(UpperCAmelCase				)
            if y != self.target[i]:
              for j in range(self.col_sample + 1				):
                __snake_case				:			Tuple            =    (
                    self.weight[j]
                    + self.learning_rate
                    * (self.target[i] - y)
                    * self.sample[i][j]
                )
              __snake_case				:			Optional[Any]            =    True
            # print('Epoch: \n',epoch_count)
          __snake_case				:			List[str]            =    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				:			Optional[int]            =    0
        for i in range(self.col_sample + 1				):
          __snake_case				:			Optional[Any]            =    u + self.weight[i] * sample[i]

        __snake_case				:			int            =    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)








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_UpperCamelCase    =	{
    '''configuration_dpr''': ['''DPR_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DPRConfig'''],
    '''tokenization_dpr''': [
        '''DPRContextEncoderTokenizer''',
        '''DPRQuestionEncoderTokenizer''',
        '''DPRReaderOutput''',
        '''DPRReaderTokenizer''',
    ],
}


try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _UpperCamelCase    =	[
         '''DPRContextEncoderTokenizerFast''',
         '''DPRQuestionEncoderTokenizerFast''',
         '''DPRReaderTokenizerFast''',
     ]

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _UpperCamelCase    =	[
         '''DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
         '''DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
         '''DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST''',
         '''DPRContextEncoder''',
         '''DPRPretrainedContextEncoder''',
         '''DPRPreTrainedModel''',
         '''DPRPretrainedQuestionEncoder''',
         '''DPRPretrainedReader''',
         '''DPRQuestionEncoder''',
         '''DPRReader''',
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _UpperCamelCase    =	[
         '''TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
         '''TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
         '''TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST''',
         '''TFDPRContextEncoder''',
         '''TFDPRPretrainedContextEncoder''',
         '''TFDPRPretrainedQuestionEncoder''',
         '''TFDPRPretrainedReader''',
         '''TFDPRQuestionEncoder''',
         '''TFDPRReader''',
     ]


if TYPE_CHECKING:
     from .configuration_dpr import DPR_PRETRAINED_CONFIG_ARCHIVE_MAP, DPRConfig
     from .tokenization_dpr import (
         DPRContextEncoderTokenizer,
         DPRQuestionEncoderTokenizer,
         DPRReaderOutput,
         DPRReaderTokenizer,
     )

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_dpr_fast import (
              DPRContextEncoderTokenizerFast,
              DPRQuestionEncoderTokenizerFast,
              DPRReaderTokenizerFast,
          )

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_dpr import (
              DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
              DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
              DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
              DPRContextEncoder,
              DPRPretrainedContextEncoder,
              DPRPreTrainedModel,
              DPRPretrainedQuestionEncoder,
              DPRPretrainedReader,
              DPRQuestionEncoder,
              DPRReader,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_dpr import (
              TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
              TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
              TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFDPRContextEncoder,
              TFDPRPretrainedContextEncoder,
              TFDPRPretrainedQuestionEncoder,
              TFDPRPretrainedReader,
              TFDPRQuestionEncoder,
              TFDPRReader,
          )

else:
     import sys

     _UpperCamelCase    =	_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

