machinelearning-mnpkllps 0.1.3__py3-none-any.whl

machinelearning_mnpkllps/Nao_Supervisionado.py

@@ -0,0 +1,181 @@
+import numpy as np 
+
+
+def validade_matrix(X): #função auxiliar para verificar se os dados da amostra é válido
+    X = np.asarray(X, dtype=float)
+    if X.ndim != 2 or X.shape[0] == 0 or X.shape[1] == 0: #número de linha e Núemrod de colunas, dimensão dois porque temos as observações e também temos os atributos de cada observação
+        raise TypeError("X deve ser 2D e não vazio: (n_amostras, n_atributos)")
+        
+    if not np.all(np.isfinite(X)): #np.all verifica todos os valores são verdadeiros, np.infinite retorna veradeiro ou falso para cada valor, vendp se não é Nan ou infinito
+        raise ValueError("X contém NaN ou infinito")
+    return X
+
+
+def validate_positive_integer(valor, nome): #função auxiliar para verificar se o valor é válido
+    if not isinstance(valor, (int, np.integer)) or isinstance(valor, bool): #verifica se o valor é um inteiro
+        raise ValueError(f"{nome} deve ser um inteiro positivo.")
+
+    if valor < 1:
+        raise ValueError(f"{nome} deve ser >= 1.") # verifica se o valor é maior ou igual 1
+
+    return int(valor)
+
+
+class KMeans:
+    """
+    `Kmeans(k, max_iteracao=100)`
+
+    Agrupa as amostras em `k` clusters (algoritmo de Lloyd): sorteia `k` pontos distintos como centroides, atribui cada amostra ao centroide mais próximo e recalcula cada centroide como a média do seu cluster, até convergir ou atingir `max_iteracao`.
+
+    | Parâmetro | Descrição |
+    |---|---|
+    | `k` | Número de clusters (inteiro >= 1) |
+    | `max_iteracao` | Limite de iterações (inteiro >= 1) |
+
+    | Método | O que faz |
+    |---|---|
+    | `fit(X)` | Ajusta o modelo e guarda `centroides` `(k, n_atributos)`. Retorna `self`. Erro se `k` > nº de amostras ou nº de pontos distintos |
+    | `estimar(X)` | Retorna o índice do centroide mais próximo de cada amostra, formato `(n_amostras,)` |
+
+    Observação: a inicialização é aleatória (sem semente), então a numeração dos clusters pode mudar entre execuções.
+    """
+    def __init__(self, k, max_iterations=100):
+        self.k = validate_positive_integer(k, "k")
+        self.max_iterations = validate_positive_integer(max_iterations, "max_iterations") #verificando se o valor é válido
+        self.centroids = None # vetor que vai armazemar os centroids (vetor)
+
+    def predict(self, X):
+        if self.centroids is None:
+            raise RuntimeError("chame fit antes de estimar")
+
+        X = validate_matrix(X)
+
+        if X.shape[1] != self.centroids.shape[1]: # shape seria: X.shape = (qnt_amostra, qnt_atributos), shape[1] é o número de colunas, ou seja, o número de atributos
+            raise ValueError(f"X tem {X.shape[1]} atributos, mas o modelo foi treinado com {self.centroids.shape[1]} atributos")
+
+        distancias = np.sum((X[:, None, :] - self.centroids[None, :, :]) ** 2, axis=2) # (amostra, centroide, coordenada)
+        # Com sum(axis=2), somamos as coordenadas: (amostra, centroide), contendo as distâncias euclidianas ao quadrado  
+    
+        return np.argmin(distancias, axis=1) # Para cada amostra, retorna o índice do centroide mais próximo. Formato: (amostra) contendo o índice do centróide mais próximo.
+               
+    def fit(self, X):
+        X = validate_matrix(X)
+
+        if self.k > len(X):       #verifica se o número de clusters é maior que o número de amostras
+            raise ValueError(f"k={self.k} é maior que o número de amostras ({len(X)})")
+
+        distintos = np.unique(X, axis=0) #verifica se o número de clusters é maior que o núemor de amostras distintos
+        if self.k > len(distintos):
+            raise ValueError(f"há apenas {len(distintos)} pontos distintos em X, menos que k={self.k}")
+
+        rng = np.random.default_rng()                   # gerador de números aleatórios
+        indices = rng.choice(len(distintos), self.k, replace=False) # seleciona k índices aleatórios (índices distintos)
+        self.centroids = distintos[indices].copy()     #copiando os centroids escolhidos
+
+        for _ in range(self.max_iterations):
+            conjunto = self.predict(X)          # atribuindo cada amostra ao centroide mais próximo
+            novos = self.centroids.copy()      # inicializando os valores dos novos centroids da iteração
+
+            for i in range(self.k):             # para cada centroide calcular seu novo valor como a média dos pontos do seu conjunto
+                pontos = X[conjunto == i]       # selecionar todos os X[j] cuja conjunto[j] = i
+                if len(pontos) > 0:
+                    novos[i] = pontos.mean(axis=0)
+
+            if np.array_equal(self.centroids, novos): # se o valor dos novos centroids não alterou, então convergiu
+                break
+
+            self.centroids = novos             #atualizando o valor dos centroids
+        return self
+
+
+class PCA:
+    """
+    ## `Pca()`
+
+    Encontra as direções de maior variância: centraliza os dados, calcula a covariância amostral e usa `np.linalg.eigh` para obter autovalores e autovetores, ordenados do maior para o menor.
+
+    | Atributo | Descrição |
+    |---|---|
+    | `media` | Média de cada atributo `(n_atributos,)` |
+    | `componentes` | Autovetores nas colunas `(n_atributos, n_atributos)` |
+    | `autovalores` | Variância de cada componente, em ordem decrescente |
+
+    | Método | O que faz |
+    |---|---|
+    | `fit(X)` | Calcula `media`, `componentes` e `autovalores`. Exige >= 2 amostras. Retorna `self` |
+    | `transformar(X, n_componentes=None)` | Centraliza e projeta nos primeiros `n_componentes` (todos se `None`). Retorna `(n_amostras, n_componentes)` |
+    | `fit_transform(X, n_componentes=None)` | `fit` seguido de `transformar` |
+
+    Observações: o sinal de cada componente é arbitrário, e o PCA não padroniza os dados (use o pré-processamento se os atributos tiverem escalas diferentes).
+    """
+    def __init__(self):
+        self.mean = None                   # média de cada atributo original
+        self.components = None             # autovetores ordenados
+        self.eigenvalues = None             # variâncias associados aos autovetores (as direções)
+
+    def fit(self, X):
+        X = validate_matrix(X)
+        if len(X) < 2:                      # se a dimensão for <=1 não temos dimensão para reduzir, calcular covariância usa n - 1.
+            raise ValueError("PCA precisa de pelo menos 2 amostras")
+
+        self.mean = X.mean(axis=0)                 #média dos vetores colunas (amostra)
+        X_centralizado = X - self.mean   #centralizando os dados
+
+        cov = X_centralizado.T @ X_centralizado / (len(X) - 1)  #calculando a matriz de covariância amostral
+        valores, vetores = np.linalg.eigh(cov)                                      #calculando os auto valores e os autovetores (padronizados)
+
+        indices = np.argsort(valores)[::-1]                     #pegando os índices dos eigenvalues em ordem decrescente
+        self.eigenvalues = np.maximum(valores[indices], 0.0)    #substituindo os autovalroes negativos por 0, que podem surgir a instabilidade numérica do ponto flutuante (variância negativo não exite)
+        self.components = vetores[:, indices]                  #reordenando as colunas (veotres colunas)
+
+        return self
+
+    def transform(self, X, n_components=None):
+        if self.mean is None:
+            raise RuntimeError("chame fit antes de transformar")
+
+        X = validate_matrix(X)
+        if X.shape[1] != len(self.mean):       # compatibilidade entre a dimensão dos dados e a média
+            raise ValueError(
+                f"X tem {X.shape[1]} atributos, esperado {len(self.mean)}"
+            )
+
+        n = self.components.shape[1] if n_components is None else validate_positive_integer(
+            n_components, "n_components"      #usar todos os components se None, se não verificar se o valor dado é válido
+        )
+        if n > self.components.shape[1]:       #se o número o n for maior que o número de atributos
+            raise ValueError(f"n_components={n} excede o número de atributos : {self.components.shape[1]}")
+
+        return (X - self.mean) @ self.components[:, :n]
+
+    def fit_transform(self, X, n_components=None):
+        return self.fit(X).transform(X, n_components)
+
+# ====================================TESTES=======================================================================================================
+if __name__ == "__main__":
+    rng = np.random.default_rng(0)
+
+    # KMeans
+    # dois grupos bem separados: um perto de (0,0) e outro perto de (10,10)
+    X = np.vstack([rng.normal(0, 0.5, (50, 2)), rng.normal(10, 0.5, (50, 2))])
+
+    modelo = KMeans(2).fit(X)
+    rotulos = modelo.predict(X)
+
+    assert len(set(rotulos[:50])) == 1   # primeiro grupo todo no mesmo cluster
+    assert len(set(rotulos[50:])) == 1   # segundo grupo todo no mesmo cluster
+    assert rotulos[0] != rotulos[50]     # clusters diferentes
+    print("KMeans OK")
+
+    # PCA
+    # dados quase sobre a reta y = 2x
+    t = rng.normal(size=200) 
+    X = np.column_stack([t, 2 * t]) + 0.01 * rng.normal(size=(200, 2))
+
+    PCA = PCA()
+    Z = PCA.fit_transform(X, n_components=1)
+
+    esperado = np.array([1, 2]) / np.sqrt(5)                           # direção da reta
+    assert np.isclose(abs(PCA.components[:, 0] @ esperado), 1, atol=1e-3)  # abs: sinal é arbitrário
+    assert Z.shape == (200, 1)
+    print("PCA OK")

machinelearning_mnpkllps/NeuralNetwork.py

@@ -0,0 +1,292 @@
+import numpy as np
+from . import Functions
+from . import metricas
+from typing import Callable
+
+
+class NeuralNetwork:
+    def __init__(self, layers: list[int], activate_function: Functions.functions_name | list[Functions.functions_name], 
+                 output_activation: Functions.functions_name = 'identity', function_dictionary: dict[str, tuple[Callable, Callable]] = Functions.functions,  
+                 bias_interval: tuple[float, float] = (0, 1), weight_interval: tuple[float, float] = (0, 1), 
+                 seed:int = 782) -> None:
+        """
+            Intancia um elemento a classe NeuralNetwork com pesos e vieses aleatórios dentro do intervalo estipulado.
+            
+            Parâmetros
+            -----------
+            layers list[int] : Quantas layers tem e qual a largura de cada;
+            activate_function str | list[str] : Quais funções de ativação serão usadas a cada camada oculta;
+            output_activation str | list[str] : Qual a função ativação da camada de saida (identidade por padrão);
+            function_dictionary dict[str, tuple[Callable, Callable]] : Mapa de funções de ativação e suas derivadas;
+            baias_interval tuple[float, float] : Qual intervalo os vieses serão gerado ((0, 1) por padrão);
+            weight_interval tuple[float, float] : Qual intervalo os pesos serão gerado ((0, 1) por padrão);
+            seed int : Seed usada para gerar os vieses e pesos
+        """
+
+        self.original_seed = seed
+        self._rng = np.random.default_rng(seed)
+        self.layers = layers
+
+        self._state_linear: list[np.ndarray] = [np.array([]) for _ in range(1, len(layers))]
+        self._state_layers: list[np.ndarray] = [np.array([]) for _ in range(len(layers))]
+
+        self.bias: list[np.ndarray] = [self.random_bias(i, *bias_interval) for i in range(1, len(layers))]
+        self.weight: list[np.ndarray] = [self.random_weight(i, *weight_interval) for i in range(1, len(layers))]
+
+        if isinstance(activate_function, list):
+            if len(activate_function) != len(layers)-2:
+                raise ValueError("ERROR: Quantidade de funções diferente dos layers ocultos")
+            self.activate_functions: list[str] = activate_function.copy()
+        elif isinstance(activate_function, str):
+            self.activate_functions: list[str] = [activate_function] * (len(layers) - 2)
+        else :
+            raise TypeError("ERROR: Tipo da activete_function está incorreto")
+
+        self.activate_functions += [output_activation]
+        self._function_dictionary = function_dictionary.copy()
+
+        self._check_activate(self.activate_functions, self._function_dictionary)
+
+    @staticmethod
+    def _check_activate(activate_functions: list[str], function_dictionary: dict[str, tuple[Callable, Callable]]) -> None:
+        """
+            Verifica se todas as funções de ativação usadas estão no mapa
+            
+            Parâmetros
+            -----------
+            activate_function list[str] : Quais funções de ativação serão usadas a cada camada oculta;
+            function_dictionary dict[str, tuple[Callable, Callable]] : Mapa de funções de ativação e suas derivadas.
+        """
+        for function_name in activate_functions:
+            if function_name not in function_dictionary:
+                raise KeyError(f"ERROR: Função de ativação inválida: {function_name}")
+
+    @staticmethod
+    def _check_input(x: np.ndarray) -> np.ndarray:
+        """
+            Verifica se x é valido e arruma suas dimenções 
+            
+            Parâmetros
+            -----------
+            x np.ndarray : Array a se verificar.
+
+            Retorna
+            -----------
+            x com as dimenções atualizadas
+        """
+
+        if isinstance(x, float) or isinstance(x, int):
+            x = np.array([x])
+        elif isinstance(x, list) or isinstance(x, tuple):
+            x = np.array(x)
+
+        if x.ndim > 2:
+            raise ValueError("Entrada invalida, x deve ser um vetor ou matriz")
+        elif x.ndim == 1:
+            if len(x) == 1:
+                x = x.reshape(-1, 1) 
+            else:
+                x = x.reshape(1, -1)
+
+        return x
+
+    def random_bias(self, level: int, low: float = 0, high: float = 1) -> np.ndarray:
+        """
+            Gera um vetor viés uniformemente aleatório entre [low, high]
+            
+            Parâmetros
+            -----------
+            level int : Para qual layer será gerado o viés;
+            low float : Valor mínimo dos vieses (0 por padrão);
+            high float : Valor maximo dos vieses (1 por padrão).
+
+            Retorna
+            -----------
+            Vetor dos vieses com o mesma largura do layer[nivel]
+        """
+
+        array = self._rng.uniform(low, high, (self.layers[level], 1))
+        
+        return array
+
+    def random_weight(self, level: int, low: float = 0, high: float = 1) -> np.ndarray:
+        """
+            Gera uma matriz peso uniformemente  aleatória entre [low, high]
+            
+            Parâmetros
+            -----------
+            level int : Para qual layer será gerado o peso;
+            low float : Valor mínimo dos pesos (0 por padrão);
+            high float : Valor maximo dos pesos (1 por padrão).
+
+            Retorna
+            -----------
+            matriz dos pesos com dimenção da largura do layer[nivel] x layer[nivel-1]
+        """
+
+        array = self._rng.uniform(low, high, (self.layers[level], self.layers[level-1]))
+        
+        return array
+
+    def train(self, X: np.ndarray, y: np.ndarray, loss: Callable = metricas.MSE, loss_diff: Callable = metricas.DMSE, learn_rate: float = 0.1, 
+              batch: int = 10, epochs: int = 1000, tol = 1e-9) -> None:
+        """
+            Treina a rede neural a partir dos dados X, y
+            
+            Parâmetros
+            -----------
+            X np.ndarray : Matriz P x N dos dados de treino;
+            y np.ndarray : Matriz S x N das saidas de treino;
+            loss Callable : Função perda para aprendizado;
+            loss_diff Callable : Derivada da função perda para backpropagation;
+            learn_rate float : Taxa de aprendizado (0.1 por padrão);
+            batch int : Quantidade esperada de elementos por balde (10 por padrão);
+            epochs int : Quantidade de interações nos dados de treino (1000 por padrão).
+        """
+
+        self.loss = loss
+        self.loss_diff = loss_diff
+
+        loss_function: str = 'MSE' #COLOCAR PARA PARAMETROS
+
+        X = self._check_input(X)
+        y = self._check_input(y)
+
+
+        index: np.ndarray = np.arange(X.shape[1])
+
+        loss = self.loss(y, self.prevision(X))
+        for epoch in range(epochs):
+            self._rng.shuffle(index)
+
+            for i in range(0, X.shape[1], batch):
+                if X.shape[1] - i < 2*batch:
+                    B = index[i:]
+                else:
+                    B = index[i: i+batch]
+
+                self._backpropagation(X[:, B], y[:, B], loss_function = loss_function, learn_rate = learn_rate)
+
+            loss_aux = self.loss(y, self.prevision(X))
+
+            if abs(loss - loss_aux) < tol:
+                break
+            else:
+                loss = loss_aux
+
+    def _backpropagation(self, x: np.ndarray, y: np.ndarray, loss_function: str = 'MSE', learn_rate: float = 0.1) -> None:
+        """
+            Calcula as decidas de gradiente para cada peso e viés.
+            
+            Parâmetros
+            -----------
+            x np.ndarray : Matriz P x N dos dados de treino;
+            y np.ndarray : Matriz S x N das saidas de treino;
+            loss_function str : Função perda utilizada para calcular o gradiente;
+            learn_rate float : Taxa de aprendizado (0.1 por padrão);
+        """
+
+
+        self.prevision(x, save_states=True)
+        cost: list[np.ndarray] = [np.array([]) for _ in range(1, len(self.layers))]
+
+        activate_function = self.activate_functions[-1]
+        cost[-1] = self.loss_diff(y, self._state_layers[-1]) * self._function_dictionary[activate_function][1](self._state_linear[-1])
+
+        for level in range(len(self.layers)-3, -1, -1):
+            activate_function = self.activate_functions[level]
+            cost[level] =  self.weight[level+1].T @ cost[level+1] * self._function_dictionary[activate_function][1](self._state_linear[level])
+
+        for level in range(len(self.layers)-1):
+            self.weight[level] -= learn_rate * (cost[level] @ self._state_layers[level].T)
+            self.bias[level] -= learn_rate * np.sum(cost[level], axis=1, keepdims=True)
+
+
+    def prevision(self, x: float | np.ndarray, save_states: bool = False, classify: bool = False) -> np.ndarray:
+        """
+            Calcula o valor de saida da rede neural com pesos e vieses atuais
+            
+            Parâmetros
+            -----------
+            x float | np.ndarray : Vetor ou matriz que queremos prever o resultado;
+            save_states bool : Define se queremos salvar os valores de cada layer ou não;
+            classify bool : Define se queremos retornar o vetor de probabilidade ou atribuir o elemento a uma classe.
+
+            Retorna
+            -----------
+            Valor de saida da rede neural com entrada x
+        """
+
+        x = self._check_input(x)
+
+        y: np.ndarray = x.copy()
+
+        if save_states:
+            self._state_layers[0] = y.copy()
+
+        for level in range(len(self.layers)-1):
+            bayes: np.ndarray = self.bias[level]
+            weight: np.ndarray = self.weight[level]
+            activate_func = self._function_dictionary[self.activate_functions[level]][0]
+
+            linear = bayes + weight @ y
+            layer = activate_func(linear)
+            if save_states:
+                self._state_linear[level] = linear
+                self._state_layers[level + 1] = layer
+
+            y = layer
+
+        if classify:
+            return np.argmax(y)
+
+        return y
+
+
+if __name__ == "__main__":
+
+    print('-'*100)
+    print('Teste 1')
+    print('-'*100)
+    rn1 = NeuralNetwork([2, 4, 5, 2], activate_function="sigmoid", output_activation="sigmoid", bias_interval = (-1, 1), weight_interval = (-1, 1))
+
+    rng = np.random.default_rng(1)
+    X = rng.uniform(-4, 4, (2, 1000))
+    y = np.zeros(X.shape)
+
+    for i, x in enumerate(X.T):
+        if x[0]**2 + x[1]**2 <= 9:
+            y[:, i] = [1, 0]
+        else:
+            y[:, i] = [0, 1]
+
+    rn1.train(X, y, batch=50)
+
+    x1 = np.array([[1], [0]])
+    x2 = np.array([[3], [3]])
+    x3 = np.array([[5], [5]])
+
+    print(f"\nx_1=({x1[0]}, {x1[1]}) y_1 = {rn1.prevision(x1)}")
+    print(f"\ny_2 = {rn1.prevision(x2)}")
+    print(f"\ny_3 = {rn1.prevision(x3)}")
+
+    print(f"\nx_1=({x1[0]}, {x1[1]}) y_1 = {rn1.prevision(x1, classify=True)}")
+    print(f"\ny_2 = {rn1.prevision(x2, classify=True)}")
+    print(f"\ny_3 = {rn1.prevision(x3, classify=True)}")
+
+    print('-'*100)
+    print('Teste 2')
+    print('-'*100)
+
+    rn2 = NeuralNetwork([1, 4, 5, 1], activate_function="ReLU", output_activation="identity", bias_interval = (-0.1, 0.1), weight_interval = (-0.1, 0.1))
+
+    f = lambda x: np.exp(x)
+
+    X = np.linspace(-2, 3, 10000).reshape(1, -1)
+    y = f(X)
+
+    rn2.train(X, y, batch=50, learn_rate=0.001, epochs=10000)
+
+    for x1 in range(20):
+        print(f"\nx_1={x1}, y_1={rn2.prevision(x1)}")
+