saikit-learn 0.1.0__tar.gz

saikit_learn-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 saikit-learn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy 
+of this software and associated documentation files (the “Software”), to deal 
+in the Software without restriction, including without limitation the rights 
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+copies of the Software, and to permit persons to whom the Software is 
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+IABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.

saikit_learn-0.1.0/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.5
+Name: saikit-learn
+Version: 0.1.0
+Summary: Biblioteca de aprendizado de máquina (projeto final de Aprendizado de Máquina I, IMPA Tech)
+Author-email: André Oliveira <al.andre.oliveira@impatech.edu.br>, Davi Pestana <al.davi.campos@impatech.edu.br>, Felipe Ribeiro <al.felipe.mendonca@impatech.edu.br>, Gabriel Krauss <al.gabriel.dias@impatech.edu.br>, Huann Vicente <al.huann.silva@impatech.edu.br>, Lucas Corazza <al.lucas.corazza@impatech.edu.br>, Nicole Freire <al.nicole.freire@impatech.edu.br>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pytest ; extra == "dev"
+Project-URL: Repository, https://github.com/feliperibeiro-impatech/saikit_learn
+Provides-Extra: dev
+Import-Name: saikit_learn
+
+# Saikit-learn
+
+Biblioteca com ferramentas de aprendizado de máquina, desenvolvida como projeto final da disciplina de Aprendizado de Máquina I do IMPA Tech.
+
+## Instalação
+
+Para instalar a biblioteca, execute:
+
+```bash
+pip install saikit-learn
+```
+
+## Funcionalidades
+
+A biblioteca reúne implementações de algoritmos de aprendizado de máquina e ferramentas relacionadas, com o objetivo de facilitar sua utilização e experimentação.
+
+## Autores
+
+- André Oliveira
+- Davi Pestana
+- Felipe Ribeiro
+- Gabriel Krauss
+- Huann Vicente
+- Lucas Corazza
+- Nicole Freire
+
+## Licença
+
+Este projeto está licenciado sob a licença MIT. Consulte o arquivo [LICENSE](LICENSE) para mais informações.
+

saikit_learn-0.1.0/README.md

@@ -0,0 +1,29 @@
+# Saikit-learn
+
+Biblioteca com ferramentas de aprendizado de máquina, desenvolvida como projeto final da disciplina de Aprendizado de Máquina I do IMPA Tech.
+
+## Instalação
+
+Para instalar a biblioteca, execute:
+
+```bash
+pip install saikit-learn
+```
+
+## Funcionalidades
+
+A biblioteca reúne implementações de algoritmos de aprendizado de máquina e ferramentas relacionadas, com o objetivo de facilitar sua utilização e experimentação.
+
+## Autores
+
+- André Oliveira
+- Davi Pestana
+- Felipe Ribeiro
+- Gabriel Krauss
+- Huann Vicente
+- Lucas Corazza
+- Nicole Freire
+
+## Licença
+
+Este projeto está licenciado sob a licença MIT. Consulte o arquivo [LICENSE](LICENSE) para mais informações.

saikit_learn-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["flit_core >=3.11,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "saikit-learn"
+authors = [
+    {name = "André Oliveira", email = "al.andre.oliveira@impatech.edu.br"},
+    {name = "Davi Pestana", email = "al.davi.campos@impatech.edu.br"},
+    {name = "Felipe Ribeiro", email = "al.felipe.mendonca@impatech.edu.br"},
+    {name = "Gabriel Krauss", email = "al.gabriel.dias@impatech.edu.br"},
+    {name = "Huann Vicente", email = "al.huann.silva@impatech.edu.br"},
+    {name = "Lucas Corazza", email = "al.lucas.corazza@impatech.edu.br"},
+    {name = "Nicole Freire", email = "al.nicole.freire@impatech.edu.br"}
+]
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+dynamic = ["version", "description"]
+dependencies = ["numpy"]
+requires-python = ">=3.8"
+
+[project.urls]
+Repository = "https://github.com/feliperibeiro-impatech/saikit_learn"
+
+[project.optional-dependencies]
+dev = ["pytest"]
+
+[tool.pytest.ini_options]
+pythonpath = ["."]

saikit_learn-0.1.0/saikit_learn/__init__.py

@@ -0,0 +1,3 @@
+"""Biblioteca de aprendizado de máquina (projeto final de Aprendizado de Máquina I, IMPA Tech)"""
+
+__version__ = "0.1.0"

saikit_learn-0.1.0/saikit_learn/discriminant_analysis/__init__.py

@@ -0,0 +1,4 @@
+from .lda import LDA
+from .qda import QDA
+
+__all__ = ['QDA','LDA']

saikit_learn-0.1.0/saikit_learn/discriminant_analysis/base.py

@@ -0,0 +1,54 @@
+import numpy as np
+
+class _BaseDiscriminant:
+    def __init__(self):
+        self._classes = None
+        self._priors = None   # shape (K,)
+        self._means = None    # shape (K, d)
+        self._n_features = None
+        self._covariance = None
+
+    def fit(self, X: np.ndarray, y: np.ndarray):
+        """Ajusta o modelo aos dados de treino.
+
+        Args:
+            X (np.ndarray): Matriz de atributos
+            y (np.ndarray): Vetor com os resultados 
+
+        Returns:
+            self: LDA ou QDA
+        """        
+
+        if not isinstance(X, np.ndarray):
+            raise TypeError(f"X deve ser np.ndarray, recebeu {type(X).__name__}")
+        if not isinstance(y, np.ndarray):
+            raise TypeError(f"y deve ser np.ndarray, recebeu {type(y).__name__}")
+                
+        if X.ndim != 2:
+            raise ValueError("X deve ser 2D, com shape (n_samples, n_features).")
+        if y.ndim != 1 or len(y) != X.shape[0]:
+            raise ValueError("y deve ser 1D e ter o mesmo número de amostras que X.")
+        
+        if np.isnan(X).any():
+            raise ValueError("X contém NaN.")
+
+        n_samples, self._n_features = X.shape
+        self._classes = np.unique(y)
+        n_classes = len(self._classes)
+
+        if n_samples <= n_classes:
+            raise ValueError("É preciso ter mais amostras do que classes.")
+
+        self._priors = np.zeros(n_classes)
+        self._means = np.zeros((n_classes, self._n_features))
+
+        for k, c in enumerate(self._classes):
+            X_c = X[y == c]
+            self._priors[k] = len(X_c) / n_samples
+            self._means[k] = X_c.mean(axis=0)
+
+        self._fit_covariance(X, y)
+        return self
+
+    def _fit_covariance(self, X: np.ndarray, y: np.ndarray):
+        raise NotImplementedError("Implemente no LDA ou QDA")

saikit_learn-0.1.0/saikit_learn/discriminant_analysis/lda.py

@@ -0,0 +1,58 @@
+from saikit_learn.discriminant_analysis.base import _BaseDiscriminant
+import numpy as np
+
+class LDA(_BaseDiscriminant):
+    def _fit_covariance(self, X : np.ndarray, Y : np.ndarray) -> None:
+        """Calcula covariância do LDA
+
+        Args:
+            X (np.ndarray): Matriz de atributos
+            Y (np.ndarray): Vetor dos valores
+        """        
+
+        n_samples, n_features = X.shape
+        n_classes = len(self._classes)
+
+        scatter = np.zeros((n_features, n_features))
+        for k, c in enumerate(self._classes):
+            centro = X[Y == c] - self._means[k]
+            scatter += centro.T @ centro
+
+        self._covariance = scatter / (n_samples - n_classes)
+
+    def predict(self, X : np.ndarray) -> np.ndarray:
+        """Estima valores de acordo com a covariância calculada
+
+        Args:
+            X (np.ndarray): Matriz de atributos
+
+        Returns:
+            np.ndarray: Vetor dos valores calculados
+        """   
+             
+        if self._covariance is None:
+            raise RuntimeError("Chame fit antes de predict.")
+
+        X = np.asarray(X, dtype=np.float64)
+        if X.ndim == 1:
+            X = X.reshape(1, -1)
+        if X.ndim != 2 or X.shape[1] != self._n_features:
+            raise ValueError(f"X deve ter shape (n_samples, {self._n_features}).")
+        
+        cov_inv = np.linalg.inv(self._covariance)
+        n_classes = len(self._classes)
+
+        predictions = []
+
+        for x in X:
+            score = np.zeros(n_classes)
+
+            for k in range(n_classes):
+                m = self._means[k]
+                p = self._priors[k]
+                score[k] = x @ cov_inv @ m - 0.5 * m @ cov_inv @ m + np.log(p)
+
+            predictions.append(self._classes[np.argmax(score)])
+ 
+        return np.array(predictions)
+

saikit_learn-0.1.0/saikit_learn/discriminant_analysis/qda.py

@@ -0,0 +1,97 @@
+from saikit_learn.discriminant_analysis.base import _BaseDiscriminant
+import numpy as np
+
+class QDA(_BaseDiscriminant):
+    def __init__(self, reg_param : float = 0.0):
+        """Inicializa o QDA
+
+        Args:
+            reg_param (float): Valor somado à diagonal de cada matriz de covariância
+                para evitar matrizes singulares. Deve ser maior ou igual a 0.
+                Com 0.0 não aplica regularização.
+        """
+        super().__init__()
+
+        if not np.isfinite(reg_param) or reg_param < 0:
+            raise ValueError("reg_param deve ser finito e não negativo.")
+
+        self.reg_param = reg_param
+
+    def _fit_covariance(self, X : np.ndarray, Y : np.ndarray) -> None:
+        """Calcula uma covariância para cada classe do QDA
+
+        Args:
+            X (np.ndarray): Matriz de atributos
+            Y (np.ndarray): Vetor dos valores
+        """
+
+        self._covariance = None
+
+        n_features = X.shape[1]
+        n_classes = len(self._classes)
+
+        covariance = np.zeros((n_classes, n_features, n_features))
+
+        for k, c in enumerate(self._classes):
+            X_c = X[Y == c]
+            n_c = len(X_c)
+
+            if n_c < 2:
+                raise ValueError(f"A classe {c!r} tem {n_c} amostra(s); o QDA precisa de pelo menos 2 por classe.")
+
+            centro = X_c - self._means[k]
+            cov = centro.T @ centro / (n_c - 1) + self.reg_param * np.eye(n_features)
+
+            try:
+                np.linalg.cholesky(cov)
+            except np.linalg.LinAlgError:
+                raise ValueError(f"Covariância da classe {c!r} é singular. Use reg_param > 0 ou remova atributos colineares.")
+
+            covariance[k] = cov
+
+        self._covariance = covariance
+
+    def predict(self, X : np.ndarray) -> np.ndarray:
+        """Estima valores de acordo com as covariâncias calculadas
+
+        Args:
+            X (np.ndarray): Matriz de atributos
+
+        Returns:
+            np.ndarray: Vetor dos valores calculados
+        """
+
+        if self._covariance is None:
+            raise RuntimeError("Chame fit antes de predict.")
+
+        if not isinstance(X, np.ndarray):
+            raise TypeError(f"X deve ser np.ndarray, recebeu {type(X).__name__}")
+
+        X = X.astype(np.float64, copy=False)
+
+        if X.ndim == 1:
+            X = X.reshape(1, -1)
+        if X.ndim != 2 or X.shape[1] != self._n_features:
+            raise ValueError(f"X deve ter shape (n_samples, {self._n_features}).")
+        if not np.isfinite(X).all():
+            raise ValueError("X contém valores não finitos.")
+
+        n_samples = X.shape[0]
+        n_classes = len(self._classes)
+
+        score = np.zeros((n_samples, n_classes))
+
+        for k in range(n_classes):
+            cov = self._covariance[k]
+            m = self._means[k]
+            p = self._priors[k]
+
+            _, logdet = np.linalg.slogdet(cov)
+
+            centro = X - m 
+            sol = np.linalg.solve(cov, centro.T).T
+            mahalanobis = np.sum(centro * sol, axis=1)
+
+            score[:, k] = -0.5 * logdet - 0.5 * mahalanobis + np.log(p)
+
+        return self._classes[np.argmax(score, axis=1)]

saikit_learn-0.1.0/saikit_learn/linear_model/__init__.py

@@ -0,0 +1,3 @@
+from .logistic_regression import LogisticRegression
+
+__all__ = ['LogisticRegression']

saikit_learn-0.1.0/saikit_learn/linear_model/logistic_regression.py

@@ -0,0 +1,322 @@
+import numpy as np
+
+
+class LogisticRegression:
+    """Regressão Logística treinada por Gradient Descent.
+
+    Com duas classes, treina um único classificador, que estima a probabilidade
+    da classe positiva (classes_[1]). Com mais de duas classes, treina um classificador 
+    binário por classe, que distingue essa classe de todas as demais (One Vs Rest).
+    Como o Gradient Descent é sensível à escala dos atributos, padronize X antes do fit
+
+    Cada classificador minimiza a Binary Cross-Entropy média, com penalidade
+    L2 opcional nos coeficientes (o intercepto não é penalizado):
+
+        J(w, b) = BCE(w, b) + (alpha / 2) * ||w||^2
+
+    No caso de ter mais de 2 classes, as probabilidades são os scores 
+    dos classificadores normalizados para somar 1. 
+
+    Attributes:
+        classes_ (np.ndarray): Classes vistas no treino, em ordem crescente.
+        coef_ (np.ndarray): Coeficientes dos classificadores, com shape
+            (n_classifiers, n_features). Cada linha é um classificador:
+            n_classifiers é 1 com duas classes e n_classes com mais de duas.
+        intercept_ (np.ndarray): Interceptos, com shape (n_classifiers,).
+        n_features_in_ (int): Número de atributos vistos no fit.
+        n_iter_ (np.ndarray): Iterações realizadas por cada classificador.
+        converged_ (np.ndarray): Indica se cada classificador atingiu o
+            critério de parada pelo gradiente antes de max_iter. Use
+            converged_.all() para saber se todos convergiram.
+        loss_history (list[list[float]]): Valor de J em cada iteração, uma
+            lista por classificador, calculado com os parâmetros anteriores
+            à atualização daquela iteração.
+    """
+
+    def __init__(self, learning_rate: float = 0.5, max_iter: int = 10000, tol: float = 1e-6, alpha: float = 0.0):
+        """Inicializa a Regressão Logística.
+
+        Args:
+            learning_rate (float): Taxa de aprendizado do Gradient Descent.
+            max_iter (int): Número máximo de iterações de cada classificador.
+            tol (float): Tolerância para o critério de parada. O treino de
+                cada classificador termina quando a norma do gradiente fica
+                abaixo de tol.
+            alpha (float): Força da regularização L2. Com 0.0 (padrão), não há
+                regularização. Quanto maior o alpha, menor deve ser a
+                learning_rate para o treino não divergir.
+        """
+
+        if isinstance(learning_rate, bool) or not isinstance(learning_rate, (int, float, np.integer, np.floating)):
+            raise ValueError("learning_rate deve ser um número.")
+
+        if not np.isfinite(learning_rate) or learning_rate <= 0:
+            raise ValueError("learning_rate deve ser finito e positivo.")
+
+        if isinstance(max_iter, bool) or not isinstance(max_iter, (int, np.integer)):
+            raise ValueError("max_iter deve ser um inteiro.")
+
+        if max_iter <= 0:
+            raise ValueError("max_iter deve ser um inteiro positivo.")
+
+        if isinstance(tol, bool) or not isinstance(tol, (int, float, np.integer, np.floating)):
+            raise ValueError("tol deve ser um número.")
+
+        if not np.isfinite(tol) or tol < 0:
+            raise ValueError("tol deve ser finito e não negativo.")
+
+        if isinstance(alpha, bool) or not isinstance(alpha, (int, float, np.integer, np.floating)):
+            raise ValueError("alpha deve ser um número.")
+
+        if not np.isfinite(alpha) or alpha < 0:
+            raise ValueError("alpha deve ser finito e não negativo.")
+
+        self.learning_rate = learning_rate
+        self.max_iter = int(max_iter)
+        self.tol = tol
+        self.alpha = alpha
+
+        self.classes_ = None
+        self.coef_ = None
+        self.intercept_ = None
+        self.n_features_in_ = None
+        self.n_iter_ = None
+        self.converged_ = None
+        self.loss_history = []
+
+    def _sigmoid(self, z: np.ndarray) -> np.ndarray:
+        """Calcula a função sigmoid de forma numericamente estável."""
+
+        result = np.empty_like(z, dtype=np.float64)
+
+        positive = z >= 0
+        negative = ~positive
+
+        result[positive] = 1 / (1 + np.exp(-z[positive]))
+
+        exp_z = np.exp(z[negative])
+        result[negative] = exp_z / (1 + exp_z)
+
+        return result
+
+    def _loss(self, y: np.ndarray, probabilities: np.ndarray) -> float:
+        """Calcula a Binary Cross-Entropy média."""
+
+        probabilities = np.clip(probabilities, 1e-15, 1 - 1e-15)
+
+        return -np.mean(y * np.log(probabilities) + (1 - y) * np.log(1 - probabilities))
+
+    def _check_X(self, X: np.ndarray) -> np.ndarray:
+        """Valida o tipo de X e o converte para float64.
+
+        Usada por fit e predict_proba para que os dois métodos aceitem e rejeitem
+        exatamente as mesmas entradas.
+
+        Args:
+            X (np.ndarray): Matriz de atributos.
+
+        Returns:
+            np.ndarray: X convertido para dtype float64.
+        """
+
+        if not isinstance(X, np.ndarray):
+            raise TypeError(f"X deve ser np.ndarray, recebeu {type(X).__name__}")
+
+        if X.dtype.kind not in "biufO":
+            raise ValueError("X deve conter apenas valores numéricos.")
+
+        try:
+            return X.astype(np.float64)
+        except (TypeError, ValueError):
+            raise ValueError("X deve conter apenas valores numéricos.") from None
+
+    def _fit_binary(self, X: np.ndarray, y: np.ndarray):
+        """Treina um classificador binário por Gradient Descent.
+
+        Args:
+            X (np.ndarray): Matriz de atributos, já validada.
+            y (np.ndarray): Vetor com 0.0 e 1.0 (1.0 é a classe positiva).
+
+        Returns:
+            tuple: (coef, intercept, n_iter, converged, loss_history).
+        """
+
+        n_samples, n_features = X.shape
+
+        coef = np.zeros(n_features, dtype=np.float64)
+        intercept = 0.0
+
+        loss_history = []
+        converged = False
+        n_iter = 0
+
+        for n_iter in range(1, self.max_iter + 1):
+            z = X @ coef + intercept
+            probabilities = self._sigmoid(z)
+
+            # Função objetivo J (entropia cruzada + penalidade L2) calculada
+            # com os parâmetros anteriores à atualização desta iteração.
+            loss = self._loss(y, probabilities) + 0.5 * self.alpha * np.sum(coef ** 2)
+            loss_history.append(loss)
+
+            error = probabilities - y
+
+            # A penalidade L2 soma alpha * coef ao gradiente dos
+            # coeficientes. O intercepto não é penalizado.
+            gradient_coef = X.T @ error / n_samples + self.alpha * coef
+            gradient_intercept = np.mean(error)
+
+            # Critério de parada pela norma do gradiente: não depende da
+            # learning_rate, ao contrário da mudança nos parâmetros.
+            gradient_norm = max(np.linalg.norm(gradient_coef), abs(gradient_intercept))
+
+            if gradient_norm < self.tol:
+                converged = True
+                break
+
+            coef -= self.learning_rate * gradient_coef
+            intercept -= self.learning_rate * gradient_intercept
+
+        return coef, intercept, n_iter, converged, loss_history
+
+    def fit(self, X: np.ndarray, y: np.ndarray):
+        """Ajusta o modelo aos dados de treino.
+
+        Com duas classes, treina um classificador para a classe positiva
+        (classes_[1]). Com mais de duas, treina um por classe (One-vs-Rest).
+
+        Args:
+            X (np.ndarray): Matriz de atributos.
+            y (np.ndarray): Vetor com as classes.
+
+        Returns:
+            self: Modelo ajustado.
+        """
+
+        X = self._check_X(X)
+
+        if not isinstance(y, np.ndarray):
+            raise TypeError(f"y deve ser np.ndarray, recebeu {type(y).__name__}")
+
+        if X.ndim != 2:
+            raise ValueError("X deve ser 2D, com shape (n_samples, n_features).")
+
+        if X.shape[0] == 0 or X.shape[1] == 0:
+            raise ValueError("X não pode ser vazio.")
+
+        if y.ndim != 1 or len(y) != X.shape[0]:
+            raise ValueError("y deve ser 1D e ter o mesmo número de amostras que X.")
+
+        if not np.isfinite(X).all():
+            raise ValueError("X contém valores não finitos.")
+
+        if y.dtype.kind == "f" and not np.isfinite(y).all():
+            raise ValueError("y contém valores não finitos.")
+
+        # Todo o treino usa variáveis locais. Os atributos do modelo só
+        # são atribuídos no final, para que um fit que falha não deixe
+        # o modelo num estado inconsistente.
+        n_features = X.shape[1]
+        classes = np.unique(y)
+
+        if len(classes) < 2:
+            raise ValueError("LogisticRegression requer pelo menos duas classes.")
+
+        # Com duas classes, os dois classificadores OvR seriam espelhos um do
+        # outro, então basta treinar o da classe positiva.
+        targets = classes[1:] if len(classes) == 2 else classes
+        n_classifiers = len(targets)
+
+        coef = np.zeros((n_classifiers, n_features), dtype=np.float64)
+        intercept = np.zeros(n_classifiers, dtype=np.float64)
+        n_iter = np.zeros(n_classifiers, dtype=int)
+        converged = np.zeros(n_classifiers, dtype=bool)
+        loss_history = []
+
+        for i, current_class in enumerate(targets):
+            y_binary = (y == current_class).astype(np.float64)
+
+            coef[i], intercept[i], n_iter[i], converged[i], current_loss_history = self._fit_binary(X, y_binary)
+            loss_history.append(current_loss_history)
+
+        self.classes_ = classes
+        self.n_features_in_ = n_features
+        self.coef_ = coef
+        self.intercept_ = intercept
+        self.n_iter_ = n_iter
+        self.converged_ = converged
+        self.loss_history = loss_history
+
+        return self
+
+    def predict_proba(self, X: np.ndarray) -> np.ndarray:
+        """Calcula as probabilidades previstas para cada classe.
+
+        Com duas classes, as probabilidades vêm do classificador da classe
+        positiva. Com mais de duas, são os scores dos classificadores
+        One-vs-Rest normalizados para que cada linha some 1.
+
+        Args:
+            X (np.ndarray): Matriz de atributos. Um vetor 1D é tratado como
+                uma única amostra.
+
+        Returns:
+            np.ndarray: Probabilidades com shape (n_samples, n_classes), com
+                as colunas na ordem de classes_.
+        """
+
+        if self.coef_ is None:
+            raise RuntimeError("Chame fit antes de predict_proba.")
+
+        X = self._check_X(X)
+
+        if X.ndim == 1:
+            X = X.reshape(1, -1)
+
+        if X.ndim != 2 or X.shape[1] != self.n_features_in_:
+            raise ValueError(f"X deve ter shape (n_samples, {self.n_features_in_}).")
+
+        if not np.isfinite(X).all():
+            raise ValueError("X contém valores não finitos.")
+
+        z = X @ self.coef_.T + self.intercept_
+
+        if len(self.classes_) == 2:
+            probabilities_class_1 = self._sigmoid(z[:, 0])
+
+            return np.column_stack((1 - probabilities_class_1, probabilities_class_1))
+
+        # Normaliza os scores sigmoid em escala log. Dividir os sigmoids
+        # diretamente daria 0 / 0 quando todos fossem arredondados para 0.
+        log_scores = -np.logaddexp(0, -z)
+        log_scores -= log_scores.max(axis=1, keepdims=True)
+
+        probabilities = np.exp(log_scores)
+        probabilities /= probabilities.sum(axis=1, keepdims=True)
+
+        return probabilities
+
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        """Prevê as classes dos dados fornecidos.
+
+        Com duas classes, prevê a positiva se sua probabilidade for >= 0.5.
+        Com mais de duas, prevê a de maior probabilidade.
+
+        Args:
+            X (np.ndarray): Matriz de atributos.
+
+        Returns:
+            np.ndarray: Classes previstas.
+        """
+
+        if self.coef_ is None:
+            raise RuntimeError("Chame fit antes de predict.")
+
+        probabilities = self.predict_proba(X)
+
+        if len(self.classes_) == 2:
+            indices = (probabilities[:, 1] >= 0.5).astype(int)
+        else:
+            indices = np.argmax(probabilities, axis=1)
+
+        return self.classes_[indices]

saikit_learn-0.1.0/saikit_learn/neighbors/__init__.py

@@ -0,0 +1,3 @@
+from .knn import KNN
+
+__all__ = ['KNN']

saikit_learn-0.1.0/saikit_learn/neighbors/knn.py

@@ -0,0 +1,89 @@
+import numpy as np
+
+class KNN:
+    def __init__(self, k: int, p: int = 2) -> None:
+        """Inicializa o classificador KNN.
+
+        Args:
+            k (int): Número de base para a comparação
+            p (int, opcional): Parâmetro que define a métrica da distância. Default: 2.
+        """     
+
+        if k < 1:
+            raise ValueError("k deve ser maior ou igual a 1.")
+        if p not in [1,2]:
+            raise ValueError("p deve ser 1 ou 2.")
+        
+        self._k = k
+        self._p = p
+        self._X = None
+        self._y = None
+
+    def fit(self, X: np.ndarray, y: np.ndarray):
+        """Treina o modelo de classificação KNN.
+
+        Args:
+            X (np.ndarray): Matriz dos atributos
+            y (np.ndarray): Vetor com os resultados
+
+        Returns:
+            self: KNN
+        """   
+
+        if not isinstance(X, np.ndarray):
+            raise TypeError(f"X deve ser np.ndarray, recebeu {type(X).__name__}")
+        if not isinstance(y, np.ndarray):
+            raise TypeError(f"y deve ser np.ndarray, recebeu {type(y).__name__}")
+        
+        if len(X) != len(y):
+            raise ValueError("X e y devem ser de mesmo tamanho") 
+
+        self._X = X
+        self._y = y
+
+        return self
+
+    def _get_distances_with_labels(self, x: np.ndarray) -> np.ndarray:
+        """Ordena os rótulos de treino pela distância até um ponto.
+
+        Args:
+            x (np.ndarray): Ponto a ser comparado.
+
+        Returns:
+            np.ndarray:  Rótulos de treino ordenados por distância crescente
+            até x.
+        """    
+
+        diff = np.abs(self._X - x)
+        distances = np.sum(diff ** self._p, axis=1) ** (1 / self._p)
+
+        result = np.argsort(distances, kind='stable')
+        
+        return self._y[result]
+
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        """Estima a classificação de cada rótulo pelos k vizinhos mais próximos.
+
+        Args:
+            X (np.ndarray): Amostras pendentes de classificação.
+
+        Returns:
+            np.ndarray: Resultado da estimativa. 
+        """        
+
+        if not isinstance(X, np.ndarray):
+            raise TypeError(f"X deve ser np.ndarray, recebeu {type(X).__name__}")        
+        
+        predicted_labels = []
+
+        for x in X:
+            sorted_labels = self._get_distances_with_labels(x)
+
+            k_neighbors = sorted_labels[:self._k]
+
+            # Escolhe o primero rótulo por ser a dos pontos mais próximos
+            label, first_pos, count = np.unique(k_neighbors, return_index=True, return_counts=True)
+            candidates = count == count.max()
+            predicted_labels.append(label[np.argmin(first_pos[candidates])])
+
+        return np.array(predicted_labels)

saikit_learn-0.1.0/saikit_learn/neural_network/__init__.py

@@ -0,0 +1,3 @@
+from .mlp_regressor import MLPRegressor
+
+__all__ = ['MLPRegressor']

saikit_learn-0.1.0/saikit_learn/neural_network/mlp_regressor.py

@@ -0,0 +1,175 @@
+import numpy as np
+
+class MLPRegressor:
+    def __init__(self, hidden_layers: tuple=(10,), learning_rate: float=0.01, n_epochs: int=1000, random_state: int = None):
+        """Inicializa o regressor MLP.
+
+        Args:
+            hidden_layers (tuple, opcional): Tamanhos das camadas ocultas. Padrão é (10,).
+            learning_rate (float, opcional): Passo do gradiente descende. Padrão é 0.01.
+            n_epochs (int, opcional): Vezes que o conjunto de treino é percorrido. Padrão é 1000.
+            random_state (int, opcional): Seed geradora dos pesos inciais. Padrão é None.
+        """
+        
+        if not isinstance(hidden_layers, (tuple, list)):
+            raise TypeError("hidden_layers deve ser uma tupla de inteiros.")
+        
+        if any((not isinstance(h, (int, np.integer))) or h <= 0 for h in hidden_layers):
+            raise ValueError("Cada camada oculta deve ter um número inteiro positivo de neurônios.")
+        
+        if learning_rate <= 0:
+            raise ValueError("learning_rate deve ser positivo.")
+        
+        if not isinstance(n_epochs, (int, np.integer)) or n_epochs <= 0:
+            raise TypeError("n_epochs deve ser um inteiro positivo.")
+
+        self._hidden = hidden_layers
+        self._lr = learning_rate
+        self._n_epochs = n_epochs
+        self._rng = np.random.default_rng(random_state)
+        self._weights, self._biases, self._n_features = None, None, None
+
+    def _init_parameters(self, sizes: list):
+        """Inicializa os pesos e vieses de cada camada.
+
+        Args:
+            sizes (list): Matriz com o tamanho das camadas de entrada, oculta e de saída.
+        """        
+        self._weights, self._biases = [], [] 
+        for layer in range(len(sizes)-1):
+            n_in, n_out = sizes[layer], sizes[layer + 1]
+
+            # Desvio He para ReLU
+            W = self._rng.normal(0, np.sqrt(2/n_in), size=(n_in, n_out))   
+            b = np.zeros(n_out)
+            self._weights.append(W)
+            self._biases.append(b)
+
+    def _forward(self, X: np.ndarray) ->  tuple[np.ndarray, np.ndarray]:
+        """Propaga o X pela rede neural. 
+
+        Args:
+            X (np.ndarray): _description_
+
+        Returns:
+            np.ndarray: Lista com L+1 arrays; activations[0] é X e activations[-1] é a saída (n, 1).
+            np.ndarray: Lista com L arrays com os valores antes da ativação de cada camada.
+        """        
+        activations, zs = [X], []
+        n_layers = len(self._weights)
+
+        for l in range(n_layers):
+            z = activations[-1] @ self._weights[l] + self._biases[l]
+            zs.append(z)
+
+            if l < n_layers- 1:
+                a = np.maximum(0, z)
+            else:
+                a = z
+
+            activations.append(a)
+
+        return activations, zs
+
+    def _backward(self, y: np.ndarray, activations: np.ndarray, z: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+        """Calcula os gradientes da perda em relação a pesos e vieses.
+
+        Args:
+            y (np.ndarray): _description_
+            activations (np.ndarray): _description_
+            z (np.ndarray): _description_
+
+        Returns:
+            np.ndarray:Gradientes dos pesos, com os mesmos tamanhos de self._weights.
+            np.ndarray: Gradientes dos vieses, com os mesmos tamanhos de self._biases.
+        """
+        n_samples = y.shape[0]    
+        n_layers = len(self._weights)
+
+        y_pred = activations[-1]
+        delta = (y_pred-y) / n_samples
+        grads_W, grads_b = [None] * n_layers, [None] * n_layers
+
+        for l in reversed(range(n_layers)):
+            grads_W[l] = activations[l].T @ delta
+            grads_b[l] = np.sum(delta, axis=0)
+            if l > 0: 
+                reLU_deriv = (z[l - 1] > 0)
+                delta = delta @ self._weights[l].T * reLU_deriv
+
+        return grads_W, grads_b
+
+    def fit(self, X: np.ndarray, y: np.ndarray):
+        """Treina o regressor MLP por gradiente descendente.
+
+        Args:
+            X (np.ndarray): Atributos de treino.
+            y (np.ndarray): Valores-alvo contínuos.
+        """      
+        if not isinstance(X, np.ndarray):
+            raise TypeError(f"X deve ser np.ndarray, recebeu {type(X).__name__}")
+        if not isinstance(y, np.ndarray):
+            raise TypeError(f"y deve ser np.ndarray, recebeu {type(y).__name__}")
+            
+        if X.ndim != 2:
+            raise ValueError("X deve ser 2D")
+        if y.ndim != 1 or len(y) != X.shape[0]:
+            raise ValueError("y deve ser 1D e ter o mesmo número de amostras que X.")
+        if X.shape[0] == 0:
+            raise ValueError("X não pode ser vazio.")
+        if not np.isfinite(X).all():
+            raise ValueError("X contém NaN ou infinito.")
+        if not np.isfinite(y).all():
+            raise ValueError("y contém NaN ou infinito.")
+
+        n_samples, self._n_features = X.shape
+        y = y.reshape(-1, 1)
+
+        size = [self._n_features, *self._hidden, 1]
+        self._init_parameters(size)
+
+        self._loss_history = []
+        for epoch in range(self._n_epochs):
+            activations, zs = self._forward(X)
+            y_pred = activations[-1]
+
+            loss = np.mean((y_pred - y)**2) / 2
+
+            if not np.isfinite(loss):
+                raise FloatingPointError("A perda divergiu; reduza learning_rate ou padronize X.")
+            self._loss_history.append(loss)
+
+            grads_W, grads_b = self._backward(y, activations, zs)
+
+            for l in range(len(self._weights)):
+                self._weights[l] -= self._lr * grads_W[l]
+                self._biases[l] -= self._lr * grads_b[l]
+
+        return self
+
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        """Prediz o valor contínuo de cada amostra.
+
+        Args:
+            X (np.ndarray): Valores a prever, de tamanho (n_samples, n_features).
+
+        Returns:
+            np.ndarray: Valores preditos, de tamanho (n_samples,).
+        """        
+        if self._weights is None:
+            raise RuntimeError("Chame fit antes de predict.")
+
+        if not isinstance(X, np.ndarray):
+            raise TypeError(f"X deve ser np.ndarray, recebeu {type(X).__name__}.")
+        if X.ndim == 1:
+            X = X.reshape(1, -1)
+        if X.ndim != 2 or X.shape[1] != self._n_features:
+            raise ValueError(f"X deve ter shape (n_samples, {self._n_features}).")
+        if not np.isfinite(X).all():
+            raise ValueError("X contém NaN ou infinito.")
+
+        activations, _ = self._forward(X)
+        return activations[-1].ravel()
+    
+    
+    

saikit_learn-0.1.0/saikit_learn/regression/__init__.py

@@ -0,0 +1,6 @@
+from saikit_learn.regression.minimos_quadrados import OLS
+from saikit_learn.regression.ridge import Ridge
+from saikit_learn.regression.lasso import Lasso
+from saikit_learn.regression.regressao_polinomial import PolReg
+
+__all__ = ['OLS', 'Ridge', 'Lasso', 'PolReg']

saikit_learn-0.1.0/saikit_learn/regression/lasso.py

@@ -0,0 +1,82 @@
+from saikit_learn.regression.utils.validacao import verify_X_y, verify_array, NotFittedError
+import numpy as np
+
+class Lasso:
+    def __init__(self, lmbd : float = 1.0, intercepto : bool = True):
+        """Regressão Lasso por descida por coordenadas.
+
+        Args:
+            lmbd (float, opcional): Força da penalidade L1 (>= 0).. Padrão é 1.0.
+            intercepto (bool, opcional): Se True, ajusta um intercepto não penalizado. Padrão é True.
+        """
+        if (isinstance(lmbd, bool) 
+                or not isinstance(lmbd, (int, float, np.integer, np.floating))
+                or not np.isfinite(lmbd) or lmbd < 0):
+            raise ValueError("lmbd deve ser um número real finito e não negativo.")
+        
+        self.lmbd = lmbd
+        self.intercepto = intercepto
+        self._fitted = False
+
+    def fit(self, X: np.ndarray, y: np.ndarray):
+        """Treina o modelo dos X de acordo com os valores y dados.
+
+        Args:
+            X (np.ndarray): Atributos com tamanho (n_samples, n_features)
+            y (np.ndarray): Valores alvos de tamanho (n_sample)
+        """        
+        X, y = verify_X_y(X, y)
+        n, d = X.shape
+        self.n_features_in_ = d
+
+        if self.intercepto:
+            x_mean, y_mean = X.mean(axis=0), y.mean()
+        else:
+            x_mean, y_mean = np.zeros(d), 0.0
+        Xc, yc = X - x_mean, y - y_mean
+
+        col_sq = (Xc ** 2).sum(axis=0) / n
+        w = np.zeros(d)
+        residual = yc.copy()
+
+        for _ in range(1000):
+            w_original = w.copy()
+            for j in range(d):
+                if col_sq[j] == 0:
+                    continue
+                w_old = w[j]
+                rho = Xc[:, j] @ residual / n + col_sq[j] * w_old
+                w_new = np.sign(rho) * max(abs(rho) - self.lmbd, 0.0) / col_sq[j]
+                if w_new != w_old:
+                    residual -= Xc[:, j] * (w_new - w_old)
+                    w[j] = w_new
+            if np.allclose(w, w_original, atol=1e-8, rtol=0):
+                break
+
+        self.coef_ = w
+        self.intercept_ = float(y_mean - x_mean @ w)
+        self._fitted = True
+
+        return self
+    
+    def predict(self, X : np.ndarray):
+        """Estima os alvos para X de tamanho (n_samples, n_features).
+
+        Args:
+            X (np.ndarray): Atributos, shape (n_samples, n_features).
+
+        Returns:
+            np.ndarray: Valores estimados, shape (n_samples,).
+        """
+        if not self._fitted:
+            raise NotFittedError(f"{self.__class__.__name__} não foi ajustado ainda.")
+
+        X = verify_array(X)
+
+        if X.shape[1] != self.n_features_in_:
+            raise ValueError(
+                f"Número de features difere: esperado {self.n_features_in_}, obtido {X.shape[1]}."
+            )
+
+        return X @ self.coef_ + self.intercept_
+

saikit_learn-0.1.0/saikit_learn/regression/minimos_quadrados.py

@@ -0,0 +1,63 @@
+from saikit_learn.regression.utils.validacao import verify_array, verify_X_y, NotFittedError
+import numpy as np
+
+class OLS:    
+    def __init__(self, intercepto: bool = True):
+        self.intercepto = intercepto
+        self._fitted = False
+
+    def _design(self, x: np.ndarray) -> np.ndarray:
+        """Monta a matriz de design usada no ajuste.
+
+        Args:
+            x (np.ndarray): Matriz de atributos, de tamanho (n_samples, n_features).
+
+        Returns:
+            np.ndarray: Matriz de design, de tamanho (n_samples, n_features + 1) com intercepto ou (n_samples, n_features) sem intercepto.
+        """        
+        if self.intercepto:
+            X = np.column_stack([np.ones(x.shape[0]), x])
+            return X
+        return x
+
+    def fit(self, X: np.ndarray, y:np.ndarray):
+        """Treina o modelo dos X de acordo com os valores y dados.
+
+        Args:
+            X (np.ndarray): Atributos de treino, de shape (n_samples, n_features).
+            y (np.ndarray): Valores-alvo, de shape (n_samples,).
+        """           
+        X, y =  verify_X_y(X, y)
+        self.n_features_in_ = X.shape[1]
+        X = self._design(X)
+        try:
+            beta = np.linalg.solve(X.T @ X, X.T @ y)
+        except np.linalg.LinAlgError:
+            raise ValueError("X tem colunas linearmente dependentes; OLS não tem solução única.")
+        
+        self.intercept_ = float(beta[0]) if self.intercepto else 0.0
+        self.coef_ = beta[1:] if self.intercepto else beta
+        self._fitted = True
+        return self
+
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        """Estima os valores de X 
+
+        Args:
+            X (np.ndarray): Valores a serem estimados, de tamanho (n_samples, n_features).
+
+        Returns:
+            np.ndarray: Valores estimados pelo método, de tamanho (n_samples,).
+        """  
+        if not self._fitted:
+            raise NotFittedError(
+                f'{self.__class__.__name__} não foi treinado ainda, chame fit.'
+                )
+        
+        X = verify_array(X)
+
+        if self.n_features_in_ != X.shape[1]:
+            raise ValueError(
+                f'a dimensão das features difere; necessário: {self.n_features_in_}; obtido: {X.shape[1]}'
+                             )
+        return X @ self.coef_ + self.intercept_

saikit_learn-0.1.0/saikit_learn/regression/regressao_polinomial.py

@@ -0,0 +1,70 @@
+from saikit_learn.regression.utils.validacao import verify_array, verify_X_y, NotFittedError
+from saikit_learn.regression.minimos_quadrados import OLS
+import numpy as np
+
+class PolReg:
+    def __init__(self, d : int, intercepto: bool = True):
+        """Inicializa o modelo de regressão polinomial.
+
+        Args:
+            d (int): Grau do polinômio ajustado.
+            intercepto (bool, opcional): Se True, inclui o termo constante (intercepto) no modelo. Padrão é True.
+        """        
+        self.d = d
+        self.intercepto = intercepto
+        self._fitted = False
+
+    def _design(self, X : np.ndarray) -> np.ndarray:
+        """Monta a matriz de potências usada no ajuste.
+
+        Args:
+            X (np.ndarray): Atributo de entrada, de tamanho (n_samples, 1).
+
+        Returns:
+            np.ndarray: Matriz de potências, de tamanho (n_samples, d).
+        """        
+        return np.hstack([X ** k for k in range(1, self.d + 1)])
+
+    def fit(self, X : np.ndarray, y : np.ndarray):
+        """Treina o modelo polinomial de grau d com os dados fornecidos.
+
+        Args:
+            X (np.ndarray): Atributo de treino, de tamanho (n_samples, 1).
+            y (np.ndarray): Valores-alvo, de tamanho (n_samples,).
+        """        
+        if not isinstance(self.d, (int, np.integer)) or isinstance(self.d, bool) or self.d < 1:
+            raise ValueError(
+                f'd deve ser um número inteiro positivo; obtido: {self.d}'
+            )
+        
+        X, y = verify_X_y(X, y)
+        self.n_features_in_ = X.shape[1]
+
+        if X.shape[1] != 1:
+            raise ValueError(
+                f'a dimensão das features está incorreta; necessário: 1; obtido: {self.n_features_in_}'
+            )
+
+        self.model_ = OLS(intercepto=self.intercepto).fit(self._design(X), y)
+        self._fitted = True
+        return self
+
+    def predict(self, X : np.ndarray) -> np.ndarray:
+        """Estima os valores de saída para os valores de X.
+
+        Args:
+            X (np.ndarray): Valores a serem estimados, de shape (n_samples, 1).
+
+        Returns:
+            np.ndarray: Valores estimados pelo polinômio ajustado, de tamanho (n_samples,).
+        """        
+        if not self._fitted:
+            raise NotFittedError(
+                f'{self.__class__.__name__} não foi fittado ainda'
+                )
+        X = verify_array(X)
+        if self.n_features_in_ != X.shape[1]:
+            ValueError(
+                f'a dimensão das features distingue; necessário: {self.n_features_in_}; obtido: {X.shape[1]}'
+            )
+        return self.model_.predict(self._design(X))

saikit_learn-0.1.0/saikit_learn/regression/ridge.py

@@ -0,0 +1,79 @@
+from saikit_learn.regression.utils.validacao import verify_array, verify_X_y, NotFittedError
+import numpy as np
+
+class Ridge:
+    def __init__(self, lmbd: float = 1.0, intercepto : bool = True):
+        """Inicializa o modelo de regressão Ridge.
+
+        Args:
+            lmbd (float, opcional): Força da penalização L2 aplicada aos coeficientes. Valores maiores encolhem mais e 0 equivale ao OLS. Padrão é 1.0.
+            intercepto (bool, opcional): Se True, inclui o termo constante (intercepto) no modelo, sem penalizá-lo. Padrão é True.
+        """        
+        self.lmbd = lmbd
+        self.intercepto = intercepto
+        self._fitted = False
+
+    def fit(self, X: np.ndarray, y: np.ndarray):
+        """Treina o modelo Ridge com os dados fornecidos.
+
+        Args:
+            X (np.ndarray): Atributos de treino, de shape (n_samples, n_features).
+            y (np.ndarray): Valores-alvo, de shape (n_samples,).
+        """        
+        if isinstance(self.lmbd, bool):
+            raise ValueError(
+                f'lambda deve ser um número; obtido: {type(self.lmbd)}'
+            )
+
+        try:
+            lmbd = float(self.lmbd)
+
+        except (TypeError, ValueError):
+            raise ValueError(
+                f'lambda deve ser um número; obtido: {type(self.lmbd)}'
+            )
+
+        if not np.isfinite(lmbd) or isinstance(lmbd, bool) or lmbd < 0:
+            raise ValueError(
+                f'lambda deve ser um número real não negativo; obtido: {self.lmbd}'
+            )
+
+        X, y = verify_X_y(X, y)
+        self.n_features_in_ = X.shape[1]
+
+        if self.intercepto:
+            # não podemos penalizar o intercepto, então devemos cetralizar,
+            # treinar, e depois encontrar o intercepto
+            X_mean = X.mean(axis=0)
+            y_mean = y.mean()
+            Xprime = X - X_mean
+            yprime = y - y_mean
+
+        else:
+            Xprime, yprime = X, y
+
+        self.coef_ = np.linalg.solve(Xprime.T @ Xprime + self.lmbd * np.eye(self.n_features_in_), Xprime.T @ yprime)
+        self.intercept_ = float(y_mean - X_mean @ self.coef_) if self.intercepto else 0.0
+        self._fitted = True
+        return self
+        
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        """Estima os valores de saída para os valores de X.
+
+        Args:
+            X (np.ndarray): Valores a serem estimados, de tamanho n_samples, n_features).
+
+        Returns:
+            np.ndarray: Valores estimados pelo modelo, de tamanho (n_samples,).
+        """        
+        X = verify_array(X)
+
+        if not self._fitted:
+            raise NotFittedError(f'{self.__class__.__name__} não foi fittada ainda')
+
+        if self.n_features_in_ != X.shape[1]:
+            raise ValueError(
+                f'a dimensão das features está incorreta; necessário: {self.n_features_in_}; obtido: {X.shape[1]}'
+            )
+
+        return X @ self.coef_ + self.intercept_

saikit_learn-0.1.0/saikit_learn/regression/utils/validacao.py

@@ -0,0 +1,54 @@
+import numpy as np
+
+def verify_array(X, name='X'):
+    '''Converts the entry to a ndarray float 2D and verify its content
+    
+    Raises:
+
+        ValueError: If X is not 2D, or is empty or contains NaN/inf.
+    '''
+    X = np.asarray(X, dtype=float)
+    if X.ndim != 2:
+        raise ValueError(
+            f'{name} must be 2D (n_sample, n_features); receive {X.ndim}D. '
+            'If there is only one feature, use X.reshape(-1, 1).'
+            )
+
+    if X.shape[0] == 0 or X.shape[1] == 0:
+        raise ValueError(
+            f'{name} is empty; shape {X.shape}.'
+        )
+
+    if not np.all(np.isfinite(X)):
+        raise ValueError(
+            f'{name} contains NaN or inf.'
+        )
+    return X
+
+def verify_X_y(X, y):
+    '''Verify the content of the ndarrays and validate if they have the same sample size'''
+    X = verify_array(X, "X")
+    y = np.asarray(y, dtype=float)
+    # if y is a column matrix, converts to an column vector
+    if y.ndim == 2 and y.shape[1] == 1:
+        y = y.ravel()
+
+    if y.ndim != 1:
+        raise ValueError(
+            f'y must be 1D; receive {y.ndim}D.'
+        )
+
+    if not np.all(np.isfinite(y)):
+        raise ValueError(
+            f'y contains NaN or inf'
+            )
+    
+    if X.shape[0] != y.shape[0]:
+        raise ValueError(
+            f'X and y must have the same sample number; {X.shape[0]} != {y.shape[0]}'
+        )
+
+    return X, y
+
+class NotFittedError(ValueError, AttributeError):
+    '''Raised when use a model (predict) before call fit'''