Perceptron

import numpy as np

class Perceptron:
    """
    Implementação do Perceptron

    Parâmetros
    ----------
    learning_rate : float
        A taxa de aprendizado (entre 0.0 e 1.0)
    n_iters : int
        O número de passagens (épocas)

    Atributos
    ---------
    weights
    bias
    """
    def __init__(self, learning_rate=0.01, n_iters=10):
        self.learning_rate = learning_rate
        self.n_iters = n_iters
        self.weights = None
        self.bias = None

    def _activation_function(self, x):
        """
        Função de Ativação Degrau (Heaviside Step Function).
        Retorna 1 se x >= 0, senão retorna 0.
        """
        return np.where(x >= 0, 1, 0)

    def fit(self, X, y):
        """
        Ajusta o modelo aos dados de treinamento.

        Parâmetros
        ----------
        X : array-like, shape = [n_samples, n_features]
            Vetor de treinamento, onde n_samples é o número de amostras
            e n_features é o número de características.
        y : array-like, shape = [n_samples]
            Vetor com os rótulos (labels) alvo.
        """
        n_samples, n_features = X.shape

        # Inicialização dos pesos e bias
        self.weights = np.zeros(n_features)
        self.bias = 0

        y_ = np.array(y)

        for _ in range(self.n_iters):
            for idx, x_i in enumerate(X):
                linear_output = np.dot(x_i, self.weights) + self.bias
                y_predicted = self._activation_function(linear_output)
                # Cálculo do Erro e Atualização dos Pesos
                # A atualização só acontece se houver erro
                error = y_[idx] - y_predicted
                update = self.learning_rate * error

                self.weights += update * x_i
                self.bias += update

    def predict(self, X):
        linear_output = np.dot(X, self.weights) + self.bias
        y_predicted = self._activation_function(linear_output)
        return y_predicted

# data_generation.py
mean0 = [1.5, 1.5]
cov0 = [[0.5, 0], [0, 0.5]]
mean1 = [5, 5]
cov1 = [[0.5, 0], [0, 0.5]]

# Trecho de test_perceptron.py
# ...
p = Perceptron(learning_rate=0.01, n_iters=10)
p.fit(X_train, y_train)

# Trecho de test_perceptron.py
predictions = p.predict(X_test)
print(f"Acurácia do Perceptron no conjunto de teste: {accuracy(y_test, predictions):.2f}")

# data_generation2.py
mean0 = [3, 3]
cov0 = [[1.5, 0], [0, 1.5]]
mean1 = [4, 4]
cov1 = [[1.5, 0], [0, 1.5]]