title: Passing an array to numpy.dot() in Python implementation of Perceptron Learning Model
body: <p>I'm trying to put together a Python implementation of a single-layer Perceptron classifier. I've found the example in Sebastian Raschka's book 'Python Machine Learning' very useful, but I have a question about one small part of his implementation. This is the code:</p>
  
  <pre><code>import numpy as np    
  class Perceptron(object):
      """Perceptron classifier.
  
      Parameters
      ------------
      eta : float
          Learning rate (between 0.0 and 1.0)
      n_iter : int
          Passes over the training dataset.
  
      Attributes
      -----------
      w_ : 1d-array
          Weights after fitting.
      errors_ : list
          Number of misclassifications in every epoch.
  
      """
      def __init__(self, eta=0.01, n_iter=10):
          self.eta = eta
          self.n_iter = n_iter
  
      def fit(self, X, y):
          """Fit training data.
  
          Parameters
          ----------
          X : {array-like}, shape = [n_samples, n_features]
              Training vectors, where n_samples 
              is the number of samples and
              n_features is the number of features.
          y : array-like, shape = [n_samples]
              Target values.
  
          Returns
          -------
          self : object
  
          """
          self.w_ = np.zeros(1 + X.shape[1])
          self.errors_ = []
  
          for _ in range(self.n_iter):
              errors = 0
              for xi, target in zip(X, y):
                  update = self.eta * (target - self.predict(xi))
                  self.w_[1:] += update * xi
                  self.w_[0] += update
                  errors += int(update != 0.0)
              self.errors_.append(errors)
          return self
  
      def net_input(self, X):
          """Calculate net input"""
          return np.dot(X, self.w_[1:]) + self.w_[0]
  
      def predict(self, X):
          """Return class label after unit step"""
          return np.where(self.net_input(X) &gt;= 0.0, 1, -1)
  </code></pre>
  
  <p>The part I can't get my head around is why we define <code>net_input()</code> and <code>predict()</code> to take an array <code>X</code> rather than just a vector. Everything works out, since we're only passing the vector <code>xi</code> to <code>predict()</code> in the <code>fit()</code> function (and so therefore also only passing a vector to <code>net_input()</code>), but what is the logic behind defining the functions to take an array? If I understand the model correctly, we are only taking one sample at a time, calculating the dot product of the weights vector and the feature vector associated with the sample, and we never need to pass an entire array to <code>net_input()</code> or <code>predict()</code>.</p>