在Perceptron Learning Model的Python实现中将数组传递给numpy.dot（）

Question

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:

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) >= 0.0, 1, -1)

The part I can't get my head around is why we define net_input() and predict() to take an array X rather than just a vector. Everything works out, since we're only passing the vector xi to predict() in the fit() function (and so therefore also only passing a vector to net_input() ), 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 net_input() or predict() .

Answer 1

Your concern seems to be why is X in net_input and predict defined as an array not a vector (I'm assuming your definitions are what i mentioned in the comment above--really though i would say that there is no distinction in this context)... What gives you the impression that X is an 'array' as opposed to a 'vector'?

The typing here is determined by what you pass the function, so if you pass it a vector, X is a vector (python uses what's called duck typing). So to answer the question, 'why are net_input and predict defined to take an array as opposed to a vector?'... They're not, they are simply defined to take parameter X, which is whatever type you pass it...

Maybe you are confused by his reuse of the variable name X as a 2d array of training data in the context of fit but as a single sample in the other functions... They may share a name but they are distinct from eachother, being in different scopes.