Implement the Perceptron Algorithm from Scratch in Python

class Perceptron(object):
    """
    Class to encapsulate the Perceptron algorithm
    """
    
    def __init__(self, lr: float=1e-2, max_epochs: int=100, tol: float=1e-3, verbose: bool=False) -> None:
        """
        Initialiser function for a class instance
        
        Inputs:
            lr         -> learning rate; factor to determine how much weights are updated at each pass
            max_epochs -> maximum number of epochs the algorithm is allowed to run before stopping
            tol        -> tolerance to stop training procedure
            verbose    -> boolean to determine if extra information is printed out
        """
        if lr <= 0:
            raise ValueError(f'Input argument lr must be a positive number, got: {lr}')
        if max_epochs <= 0:
            raise ValueError(f'Input argument max_epochs must be a positive integer, got: {max_epochs}')
        if tol <= 0:
            raise ValueError(f'Input argument tol must be a positive number, got: {tol}')
        self.lr            = lr
        self.epochs        = max_epochs
        self.tol           = tol
        self.w             = np.array([])
        self.verbose       = verbose
        self.training_loss = []
        if self.verbose:
            print(f'Creating instance with parameters: lr = {self.lr}, max_epochs = {self.epochs}, and tol = {self.tol}')
        
    def __del__(self) -> None:
        """
        Destructor function for class instance
        """
        del self.lr
        del self.epochs
        del self.tol
        del self.w
        del self.verbose
        del self.training_loss
        
    def fit(self, X : np.array, y : np.array) -> None:
        """
        Training function for the class. Runs the training algorithm for the number of epochs set in the initialiser 
        
        Inputs:
            X -> numpy array of input features of assumed shape [number_samples, number_features]
            y -> numpy array of binary labels of assumed shape [number_samples]
        """    
        # add column for bias
        X = np.insert(X, 0, 1, axis=1)
        # initialise the weights
        self.w = np.zeros(X.shape[1])
        # initialise loss
        loss = 1e8
        
        # loop through the training procedure for the specified number of epochs
        for e in range(self.epochs):
            
            epoch_loss = 0
            
            # loop through each training sample
            for x_i,y_i in zip(X,y):
    
                # compute activation 
                z  = np.dot(x_i,self.w)
                yp = np.round(z >= 0)
                # update weights
                self.w += self.lr*(y_i-yp)*x_i
                # record the loss
                epoch_loss += np.abs(y_i-yp)
                
            # check for early stopping
            new_loss = (1/X.shape[0])*epoch_loss
            if (loss < (new_loss - self.tol)) or (new_loss < self.tol):
                if self.verbose:
                    print(f'Early stopping training procedure at Epoch: {e}, Loss: {new_loss}')
                break
            else:
                loss = new_loss
                self.training_loss.append(loss)
                if self.verbose:
                    print(f'Epoch: {e}, Loss: {loss}')
            
    def predict(self, X : np.array) -> np.array:
        """
        Predict function for the class. Assigns class label based on learned weights and the binary threshold 
        activation
        
        Input:
            X -> numpy array of input features of assumed shape [number_samples, number_features]
        Output:
            numpy array indicating class assignment per sample with shape: [number_samples,]
        """
        if self.w.size == 0:
            raise Exception("It doesn't look like you have trained this model yet!")
        # add column for bias
        X = np.insert(X, 0, 1, axis=1)
        # compute dot products for all training samples
        z = np.einsum('ij,j->i', X, self.w)
        # pass through activation function, and return
        yp = np.round(z >= 0)
        return yp
    
    def get_weights(self) -> np.array:
        """
        Function to return model weights
        
        Output:
            numpy array containing the model weights
        """
        return self.w
    
    def get_training_loss(self) -> List:
        """
        Function to return training loss 
        
        Output:
            list containing the training loss, one entry per epoch
        """
        return self.training_loss
    
    def get_params(self, deep : bool = False) -> Dict:
        """
        Public function to return model parameters
        Inputs:
            deep -> boolean input parameter
        Outputs:
            Dict -> dictionary of stored class input parameters
        """
        return {'lr':self.lr,
                'max_epochs':self.epochs,
                'tol':self.tol,
                'verbose':self.verbose}