PyDLLib 1.0__py3-none-any.whl

DLL/MachineLearning/SupervisedLearning/LinearModels/_LogisticRegression.py

@@ -0,0 +1,182 @@
+import torch
+from math import floor
+
+from ....DeepLearning.Losses import BCE, CCE
+from ....DeepLearning.Layers.Activations import Sigmoid, SoftMax
+from ....Data.Metrics import calculate_metrics, _round_dictionary, prob_to_pred
+from ....Data import DataReader
+from ....DeepLearning.Optimisers import ADAM
+from ....DeepLearning.Optimisers._BaseOptimiser import BaseOptimiser
+from ....Exceptions import NotFittedError
+from ....Data.Preprocessing import OneHotEncoder
+
+
+class LogisticRegression:
+    """
+    Implements a logistic regression model for binary and multi-class classification.
+    
+    Args:
+        learning_rate (float, optional): The step size towards the negative gradient. Must be a positive real number. Defaults to 0.01.
+
+    Attributes:
+        n_features (int): The number of features. Available after fitting.
+        weights (torch.Tensor of shape (n_features,)): The weights of the logistic regression model. Available after fitting.
+        bias (torch.Tensor of shape (1,)): The constant of the model. Available after fitting.
+    """
+    def __init__(self, learning_rate=0.001):
+        if not isinstance(learning_rate, float) or learning_rate <= 0:
+            raise ValueError("learning_rate must be a positive real number.")
+
+        self.learning_rate = learning_rate
+
+    def fit(self, X, y, sample_weight=None, val_data=None, epochs=100, optimiser=None, callback_frequency=1, metrics=["loss"], batch_size=None, shuffle_every_epoch=True, shuffle_data=True, verbose=False):
+        """
+        Fits the LogisticRegression model to the input data by minimizing the cross entropy loss (logistic loss).
+
+        Args:
+            X (torch.Tensor of shape (n_samples, n_features)): The input data, where each row is a sample and each column is a feature.
+            y (torch.Tensor of shape (n_samples,)): The labels corresponding to each sample. Every element must be in [0, ..., n_classes - 1].
+            val_data (tuple[X_val, y_val] | None, optional): Optional validation samples. If None, no validation data is used. Defaults to None.
+            epochs (int, optional): The number of training iterations. Must be a positive integer. Defaults to 100.
+            optimiser (:ref:`optimisers_section_label` | None, optional): The optimiser used for training the model. If None, the Adam optimiser is used.
+            callback_frequency (int, optional): The number of iterations between printing info from training. Must be a positive integer. Defaults to 1, which means that every iteration, info is printed assuming verbose=True.
+            metrics (list[str], optional): The metrics that will be tracked during training. Defaults to ["loss"].
+            batch_size (int | None, optional): The batch size used in training. Must be a positive integer. If None, every sample is used for every gradient calculation. Defaults to None.
+            shuffle_every_epoch (bool, optional): If True, shuffles the order of the samples every epoch. Defaults to True.
+            shuffle_data (bool, optional): If True, shuffles data before the training.
+            verbose (bool, optional): If True, prints info of the chosen metrics during training. Defaults to False.
+        Returns:
+            history (dict[str, torch.Tensor], each tensor is floor(epochs / callback_frequency) long.): A dictionary tracking the evolution of selected metrics at intervals defined by callback_frequency.
+        Raises:
+            TypeError: If the input matrix or the target matrix is not a PyTorch tensor or if other parameters are of wrong type.
+            ValueError: If the input matrix or the target matrix is not the correct shape or if other parameters have incorrect values.
+        """
+        if not isinstance(X, torch.Tensor) or not isinstance(y, torch.Tensor):
+            raise TypeError("The input matrix and the target matrix must be a PyTorch tensor.")
+        if X.ndim != 2:
+            raise ValueError("The input matrix must be a 2 dimensional tensor.")
+        if y.ndim != 1 or len(y) != len(X):
+            raise ValueError("The targets must be 1 dimensional with the same number of samples as the input data")
+        if not isinstance(val_data, list | tuple) and val_data is not None:
+            raise TypeError("val_data must either be a tuple containing validation samples or None.")
+        if isinstance(val_data, list | tuple) and len(val_data) != 2:
+            raise ValueError("val_data must contain both X_val and y_val.")
+        if isinstance(val_data, list | tuple) and len(val_data) == 2 and (val_data[0].ndim != 2 or val_data[1].ndim != 1 or val_data[0].shape[1] != X.shape[1] or len(val_data[0]) != len(val_data[1])):
+            raise ValueError("X_val and y_val must be of correct shape.")
+        if not isinstance(epochs, int) or epochs <= 0:
+            raise ValueError("epochs must be a positive integer.")
+        if not isinstance(optimiser, BaseOptimiser) and optimiser is not None:
+            raise TypeError("optimiser must be from DLL.DeepLearning.Optimisers")
+        if not isinstance(callback_frequency, int) or callback_frequency <= 0:
+            raise ValueError("callback_frequency must be a positive integer.")
+        if not isinstance(metrics, list | tuple):
+            raise TypeError("metrics must be a list or a tuple containing the strings of wanted metrics.")
+        if (not isinstance(batch_size, int) or batch_size <= 0) and batch_size is not None:
+            raise ValueError("batch_size must be a positive integer.")
+        if not isinstance(shuffle_every_epoch, bool):
+            raise TypeError("shuffle_every_epoch must be a boolean.")
+        if not isinstance(shuffle_data, bool):
+            raise TypeError("shuffle_data must be a boolean.")
+        if not isinstance(verbose, bool):
+            raise TypeError("verbose must be a boolean.")
+        vals = torch.unique(y).numpy()
+        if set(vals) != {*range(len(vals))}:
+            raise ValueError("y must only contain the values in [0, ..., n_classes - 1].")
+        if not isinstance(sample_weight, torch.Tensor) and sample_weight is not None:
+            raise TypeError("sample_weight must be torch.Tensor or None.")
+        if isinstance(sample_weight, torch.Tensor) and (sample_weight.ndim != 1 or len(X) != len(sample_weight)):
+            raise ValueError("sample_weight must be of shape (n_samples,)")
+
+        n_samples, self.n_features = X.shape
+        if len(vals) == 2:
+            # normal logistic regression
+            self.loss = BCE()
+            self.activation = Sigmoid()
+            weight_shape = (self.n_features,)
+            self.multiclass = False
+        elif len(vals) > 2:
+            # multiple logistic regression
+            encoder = OneHotEncoder()
+            y = encoder.fit_encode(y)
+            self.multiclass = True
+            self.loss = CCE()
+            self.activation = SoftMax()
+            weight_shape = (self.n_features, y.shape[1])
+
+        history = {metric: torch.zeros(floor(epochs / callback_frequency)) for metric in metrics}
+        batch_size = len(X) if batch_size is None else n_samples
+        data_reader = DataReader(X, y, batch_size=batch_size, shuffle=shuffle_data, shuffle_every_epoch=shuffle_every_epoch)
+
+        if sample_weight is None:
+            sample_weight = torch.ones(n_samples)
+        sample_weight = sample_weight / torch.sum(sample_weight)
+
+        self.weights = torch.randn(weight_shape)
+        self.bias = torch.zeros((1,)) if len(weight_shape) == 1 else torch.zeros(y.shape[1])
+        optimiser = ADAM() if optimiser is None else optimiser
+        optimiser.learning_rate = self.learning_rate
+        optimiser.initialise_parameters([self.weights, self.bias])
+
+        for epoch in range(epochs):
+            for x_batch, y_batch in data_reader.get_data():
+                y_linear = x_batch @ self.weights + self.bias
+                predictions = self.activation.forward(y_linear)
+                bce_derivative = self.loss.gradient(predictions, y_batch)
+                dCdy = self.activation.backward(bce_derivative)
+                self.weights.grad = x_batch.T @ dCdy
+                self.bias.grad = torch.mean(dCdy, dim=0, keepdim=(y.ndim == 1))
+                optimiser.update_parameters()
+            if epoch % callback_frequency == 0:
+                values = calculate_metrics(data=(self.predict_proba(X), y), metrics=metrics, loss=self.loss.loss)
+                if val_data is not None:
+                    val_values = calculate_metrics(data=(self.predict_proba(val_data[0]), val_data[1]), metrics=metrics, loss=self.loss.loss, validation=True)
+                    values |= val_values
+                for metric, value in values.items():
+                    history[metric][int(epoch / callback_frequency)] = value
+                if verbose: print(f"Epoch: {epoch + 1} - Metrics: {_round_dictionary(values)}")
+        return history
+
+    def predict(self, X):
+        """
+        Applies the fitted LogisticRegression model to the input data, predicting the labels.
+
+        Args:
+            X (torch.Tensor of shape (n_samples, n_features)): The input data to be classified.
+        Returns:
+            target values (torch.Tensor of shape (n_samples,)): The predicted values corresponding to each sample.
+        Raises:
+            NotFittedError: If the LogisticRegression model has not been fitted before predicting.
+            TypeError: If the input matrix is not a PyTorch tensor.
+            ValueError: If the input matrix is not the correct shape.
+        """
+        if not hasattr(self, "weights"):
+            raise NotFittedError("LogisticRegression.fit() must be called before predicting.")
+        if not isinstance(X, torch.Tensor):
+            raise TypeError("The input matrix must be a PyTorch tensor.")
+        if X.ndim != 2 or X.shape[1] != self.n_features:
+            raise ValueError("The input matrix must be a 2 dimensional tensor with the same number of features as the fitted tensor.")
+
+        probs = self.activation.forward(X @ self.weights + self.bias)
+        return prob_to_pred(probs)
+    
+    def predict_proba(self, X):
+        """
+        Applies the fitted LogisticRegression model to the input data, predicting the probabilities of each class.
+
+        Args:
+            X (torch.Tensor of shape (n_samples, n_features)): The input data to be classified.
+        Returns:
+            target values (torch.Tensor of shape (n_samples,)): The predicted values corresponding to each sample.
+        Raises:
+            NotFittedError: If the LogisticRegression model has not been fitted before predicting.
+            TypeError: If the input matrix is not a PyTorch tensor.
+            ValueError: If the input matrix is not the correct shape.
+        """
+        if not hasattr(self, "weights"):
+            raise NotFittedError("LogisticRegression.fit() must be called before predicting.")
+        if not isinstance(X, torch.Tensor):
+            raise TypeError("The input matrix must be a PyTorch tensor.")
+        if X.ndim != 2 or X.shape[1] != self.n_features:
+            raise ValueError("The input matrix must be a 2 dimensional tensor with the same number of features as the fitted tensor.")
+
+        return self.activation.forward(X @ self.weights + self.bias)

DLL/MachineLearning/SupervisedLearning/LinearModels/_RANSAC.py

@@ -0,0 +1,97 @@
+import torch
+from math import ceil
+from copy import deepcopy
+
+from . import LinearRegression
+from ....Exceptions import NotFittedError
+
+
+class RANSACRegression:
+    """
+    Implements the random sample consensus (RANSAC) regression model.
+
+    Args:
+        estimator (A regression model with fit and predict methods): A base model which is fit to random samples of the data. Defaults to LinearRegression.
+
+    Attributes:
+        best_estimator (estimator): The best model. Available after fitting.
+    """
+    def __init__(self, estimator=LinearRegression()):
+        if not hasattr(estimator, "fit") or not hasattr(estimator, "predict"):
+            raise TypeError("estimator must have fit and predict functions.")
+
+        self.estimator = estimator
+
+    def fit(self, X, y, min_samples=None, residual_threshold=None, max_trials=100, stop_inliers_prob=1, **kwargs):
+        """
+        Samples random subsamples of the datapoints and fits base estimators to the subsamples.
+
+        Args:
+            X (torch.Tensor of shape (n_samples, n_features)): The input data, where each row is a sample and each column is a feature.
+            y (torch.Tensor of shape (n_samples,)): The target values corresponding to each sample.
+            min_samples (int | float | None, optional): The number of samples used to fit the base estimators. If float, ceil(n_samples * min_samples) is used and if None, n_features + 1 is used. Defaults to None
+            residual_threshold (int | float | None, optional): The threshold for which larger absolute errors are considered outliers. If None, the median absolute deviation of y is used. Defaults to None.
+            max_trials (int, optional): The number of tries to sample the data. Must be a positive integer. Defaults to 100.
+            stop_inliers_prob (int | float, optional): If the proportion of inliers on an iteration exceeds this value, the random sampling is stopped early. Defaults to 1, i.e. the process is never stopped early as the max(n_inliers / number_of_samples_in_subsample) == 1.
+            kwargs: Other parameters are passed to estimator.fit()
+        """
+        if not isinstance(X, torch.Tensor) or not isinstance(y, torch.Tensor):
+            raise TypeError("The input matrix and the target matrix must be a PyTorch tensor.")
+        if X.ndim != 2:
+            raise ValueError("The input matrix must be a 2 dimensional tensor.")
+        if y.ndim != 1 or y.shape[0] != X.shape[0]:
+            raise ValueError("The targets must be 1 dimensional with the same number of samples as the input data")
+        if min_samples is not None and not isinstance(min_samples, float) and not isinstance(min_samples, int):
+            raise TypeError("min_samples must be one of None, float or int.")
+        if isinstance(min_samples, float) and (min_samples < 0 or min_samples > 1):
+            raise ValueError("If min_samples is a float, it must be in range [0, 1].")
+        if residual_threshold is not None and not isinstance(residual_threshold, float) and not isinstance(residual_threshold, int):
+            raise TypeError("residual_threshold must be one of None, float or int.")
+        if not isinstance(max_trials, int) or max_trials < 1:
+            raise ValueError("max_trials must be a positive integer.")
+        if not isinstance(stop_inliers_prob, float | int) or (stop_inliers_prob < 0 or stop_inliers_prob > 1):
+            raise ValueError("stop_inliers_prob must be a float in range [0, 1].")
+
+        n_samples, self.n_features = X.shape
+
+        if isinstance(min_samples, float):
+            min_samples = ceil(n_samples * min_samples)
+        min_samples = X.shape[1] + 1 if min_samples is None else min_samples
+
+        residual_threshold = torch.median(torch.abs(y - torch.median(y))) if residual_threshold is None else residual_threshold
+
+        max_inliers = -1
+
+        for _ in range(max_trials):
+            indicies = torch.randperm(n_samples)[:min_samples]
+            X_ = X[indicies]
+            y_ = y[indicies]
+
+            self.estimator.fit(X_, y_, **kwargs)
+            preds = self.estimator.predict(X_)
+            n_inliers = torch.sum(torch.abs(y_ - preds) < residual_threshold)
+            if n_inliers > max_inliers:
+                max_inliers = n_inliers
+                best_model = deepcopy(self.estimator)
+            
+            if n_inliers / min_samples > stop_inliers_prob:
+                break
+        
+        self.best_estimator = best_model
+    
+    def predict(self, X, **kwargs):
+        """
+        Predicts the values of the samples using the best estimator determined in the fit method.
+
+        Args:
+            X (torch.Tensor of shape (n_samples, n_features)): The input data, where each row is a sample and each column is a feature.
+            kwargs: Other parameters are passed to estimator.predict()
+        """
+        if not hasattr(self, "best_estimator"):
+            raise NotFittedError("RANSACRegression.predict() must be called before predicting.")
+        if not isinstance(X, torch.Tensor):
+            raise TypeError("The input matrix must be a PyTorch tensor.")
+        if X.ndim != 2 or X.shape[1] != self.n_features:
+            raise ValueError("The input matrix must be a 2 dimensional tensor with the same number of features as the fitted tensor.")
+
+        return self.best_estimator.predict(X, **kwargs)

DLL/MachineLearning/SupervisedLearning/LinearModels/_RidgeRegression.py

@@ -0,0 +1,78 @@
+import torch
+
+from ....Exceptions import NotFittedError
+
+
+class RidgeRegression:
+    """
+    Implements a linear regression model with L2 regularization.
+    
+    Args:
+        alpha (int | float, optional): The regularization parameter. Larger alpha will force the l2 norm of the weights to be lower. Must be a positive real number. Defaults to 1.
+
+    Attributes:
+        n_features (int): The number of features. Available after fitting.
+        beta (torch.Tensor of shape (n_features + 1,)): The weights of the linear regression model. Available after fitting.
+        residuals (torch.Tensor of shape (n_samples,)): The residuals of the fitted model. For a good fit, the residuals should be normally distributed with zero mean and constant variance. Available after fitting.
+    """
+    def __init__(self, alpha=1.0):
+        if not isinstance(alpha, int | float) or alpha <= 0:
+            raise ValueError("Alpha must be a positive integer.")
+        
+        self.alpha = alpha
+
+    def fit(self, X, y, sample_weight=None):
+        """
+        Fits the RidgeRegression model to the input data by minimizing the squared error.
+
+        Args:
+            X (torch.Tensor of shape (n_samples, n_features)): The input data, where each row is a sample and each column is a feature.
+            y (torch.Tensor of shape (n_samples,)): The target values corresponding to each sample.
+            sample_weight (torch.Tensor of shape (n_samples,) or None): A weight given to each sample in the regression. If None, this parameter is ignored.
+        Returns:
+            None
+        Raises:
+            TypeError: If the input matrix or the target matrix is not a PyTorch tensor.
+            ValueError: If the input matrix or the target matrix is not the correct shape.
+        """
+        if not isinstance(X, torch.Tensor) or not isinstance(y, torch.Tensor):
+            raise TypeError("The input matrix and the target matrix must be a PyTorch tensor.")
+        if X.ndim != 2:
+            raise ValueError("The input matrix must be a 2 dimensional tensor.")
+        if y.ndim != 1 or y.shape[0] != X.shape[0]:
+            raise ValueError("The targets must be 1 dimensional with the same number of samples as the input data")
+        if not isinstance(sample_weight, torch.Tensor) and sample_weight is not None:
+            raise TypeError("sample_weight must be torch.Tensor or None.")
+        if isinstance(sample_weight, torch.Tensor) and (sample_weight.ndim != 1 or len(X) != len(sample_weight)):
+            raise ValueError("sample_weight must be of shape (n_samples,)")
+
+        self.n_features = X.shape[1]
+        X_with_const = torch.cat((torch.ones(size=(X.shape[0], 1)), X), dim=1)
+        identity = torch.eye(X_with_const.shape[1])
+        # identity[0, 0] = 0  # Should regularisation be applied to the constant as well?
+        sample_weight = torch.diag(sample_weight) if sample_weight is not None else torch.eye(len(X))
+        self.beta = torch.linalg.lstsq(X_with_const.T @ sample_weight @ X_with_const + self.alpha * identity, X_with_const.T @ sample_weight @ y).solution
+        self.residuals = y - self.predict(X)
+
+    def predict(self, X):
+        """
+        Applies the fitted RidgeRegression model to the input data, predicting the correct values.
+
+        Args:
+            X (torch.Tensor of shape (n_samples, n_features)): The input data to be regressed.
+        Returns:
+            target values (torch.Tensor of shape (n_samples,)): The predicted values corresponding to each sample.
+        Raises:
+            NotFittedError: If the RidgeRegression model has not been fitted before predicting.
+            TypeError: If the input matrix is not a PyTorch tensor.
+            ValueError: If the input matrix is not the correct shape.
+        """
+        if not hasattr(self, "beta"):
+            raise NotFittedError("RidgeRegression.fit() must be called before predicting.")
+        if not isinstance(X, torch.Tensor):
+            raise TypeError("The input matrix must be a PyTorch tensor.")
+        if X.ndim != 2 or X.shape[1] != self.n_features:
+            raise ValueError("The input matrix must be a 2 dimensional tensor with the same number of features as the fitted tensor.")
+        
+        X = torch.cat((torch.ones(size=(X.shape[0], 1)), X), dim=1)
+        return X @ self.beta

DLL/MachineLearning/SupervisedLearning/LinearModels/__init__.py

@@ -0,0 +1,6 @@
+from ._Elasticnet import ElasticNetRegression
+from ._LassoRegression import LASSORegression
+from ._LinearRegression import LinearRegression
+from ._RidgeRegression import RidgeRegression
+from ._LogisticRegression import LogisticRegression
+from ._RANSAC import RANSACRegression

DLL/MachineLearning/SupervisedLearning/NaiveBayes/_BernoulliNaiveBayes.py

@@ -0,0 +1,115 @@
+import torch
+
+from ....Exceptions import NotFittedError
+
+
+class BernoulliNaiveBayes:
+    """
+    The BernoulliNaiveBayes classifier model. Applies the Bayes theorem to classify samples with binary features.
+
+    Attributes:
+        n_features (int): The number of features. Available after fitting.
+        n_classes (int): The number of classes. Available after fitting.
+    """
+    def fit(self, X, y, alpha=1):
+        """
+        Fits the BernoulliNaiveBayes model to the input data by calculating the prior probabilities and likelihoods.
+
+        Args:
+            X (torch.Tensor of shape (n_samples, n_features)): The input data, where each row is a sample and each column is a feature. Must contain only binary values.
+            y (torch.Tensor of shape (n_samples,)): The labels corresponding to each sample. Every element must be in [0, ..., n_classes - 1].
+            alpha (float | int): Laplacian smoothing parameter. Must be non-negative. For no smoothing, alpha is set to zero. Defaults to 1.
+        Returns:
+            None
+        Raises:
+            TypeError: If the input matrix or the label matrix is not a PyTorch tensor.
+            ValueError: If the input matrix or the label matrix is not the correct shape.
+        """
+        if not isinstance(X, torch.Tensor) or not isinstance(y, torch.Tensor):
+            raise TypeError("The input matrix and the label matrix must be PyTorch tensors.")
+        if X.ndim != 2:
+            raise ValueError("The input matrix must be a 2 dimensional tensor.")
+        if y.ndim != 1 or y.shape[0] != X.shape[0]:
+            raise ValueError("The labels must be 1 dimensional with the same number of samples as the input data")
+        vals = torch.unique(y).numpy()
+        if set(vals) != {*range(len(vals))}:
+            raise ValueError("y must only contain the values in [0, ..., n_classes - 1].")
+        if set(torch.unique(X).numpy()) != {0, 1}:
+            raise ValueError("The features must be labeled 0 and 1. If your features are not binary, consider other NaiveBayes models.")
+        if not isinstance(alpha, int | float) or alpha < 0:
+            raise ValueError("alpha must be a non-negative real number.")
+
+        self.n_features = X.shape[1]
+        self.n_classes = len(vals)
+        self.priors = torch.zeros((self.n_classes,), dtype=torch.float32)
+        self.likelihoods = torch.zeros((self.n_classes, X.shape[1]), dtype=torch.float32)
+
+        for i in range(self.n_classes):
+            X_cls = X[y == i]
+            self.priors[i] = len(X_cls) / len(y)
+            self.likelihoods[i] = (X_cls.sum(dim=0) + alpha) / (len(X_cls) + alpha * X.shape[1]) # laplace smoothing
+
+    def predict(self, X):
+        """
+        Applies the fitted BernoulliNaiveBayes model to the input data, predicting the labels.
+
+        Args:
+            X (torch.Tensor of shape (n_samples, n_features)): The input data to be classified.
+        Returns:
+            labels (torch.Tensor of shape (n_samples,)): The predicted target values corresponding to each sample.
+        Raises:
+            NotFittedError: If the BernoulliNaiveBayes model has not been fitted before predicting.
+            TypeError: If the input matrix is not a PyTorch tensor.
+            ValueError: If the input matrix is not the correct shape.
+        """
+        if not hasattr(self, "priors"):
+            raise NotFittedError("BernoulliNaiveBayes.fit() must be called before predicting.")
+        if not isinstance(X, torch.Tensor):
+            raise TypeError("The input matrix must be a PyTorch tensor.")
+        if X.ndim != 2 or X.shape[1] != self.n_features:
+            raise ValueError("The input matrix must be a 2 dimensional tensor with the same number of features as the fitted tensor.")
+        if set(torch.unique(X).numpy()) != {0, 1}:
+            raise ValueError("The features must be labeled 0 and 1. If your features are not binary, consider other NaiveBayes models.")
+        
+        posteriors = torch.zeros((self.n_classes, len(X)), dtype=torch.float32)
+
+        for i in range(self.n_classes):
+            prior = torch.log(self.priors[i])
+            posterior = (X * torch.log(self.likelihoods[i]) + (1 - X) * torch.log(1 - self.likelihoods[i])).sum(dim=1) + prior
+            posteriors[i] = posterior
+        return torch.argmax(posteriors, dim=0)
+
+    def predict_proba(self, X):
+        """
+        Applies the fitted BernoulliNaiveBayes model to the input data, predicting the labels.
+
+        Args:
+            X (torch.Tensor of shape (n_samples, n_features)): The input data to be classified.
+        Returns:
+            labels (torch.Tensor of shape (n_samples,)): The predicted target values corresponding to each sample.
+        Raises:
+            NotFittedError: If the BernoulliNaiveBayes model has not been fitted before predicting.
+            TypeError: If the input matrix is not a PyTorch tensor.
+            ValueError: If the input matrix is not the correct shape.
+        """
+        if not hasattr(self, "priors"):
+            raise NotFittedError("BernoulliNaiveBayes.fit() must be called before predicting.")
+        if not isinstance(X, torch.Tensor):
+            raise TypeError("The input matrix must be a PyTorch tensor.")
+        if X.ndim != 2 or X.shape[1] != self.n_features:
+            raise ValueError("The input matrix must be a 2 dimensional tensor with the same number of features as the fitted tensor.")
+        if set(torch.unique(X).numpy()) != {0, 1}:
+            raise ValueError("The features must be labeled 0 and 1. If your features are not binary, consider other NaiveBayes models.")
+
+        posteriors = torch.zeros((self.n_classes, len(X)), dtype=torch.float32)
+
+        for i in range(self.n_classes):
+            prior = torch.log(self.priors[i])
+            posterior = (X * torch.log(self.likelihoods[i]) + (1 - X) * torch.log(1 - self.likelihoods[i])).sum(dim=1) + prior
+            posteriors[i] = posterior
+        prob_normalizers = torch.logsumexp(posteriors, dim=0)
+        log_probs = posteriors - prob_normalizers
+        probs = torch.exp(log_probs).T
+        if self.n_classes == 2:  # binary classification
+            probs = probs[:, 1]
+        return probs

DLL/MachineLearning/SupervisedLearning/NaiveBayes/_GaussianNaiveBayes.py

@@ -0,0 +1,111 @@
+import torch
+
+from ....Exceptions import NotFittedError
+
+
+class GaussianNaiveBayes:
+    """
+    The GaussianNaiveBayes classifier model. Applies the Bayes theorem to classify samples with real number features.
+
+    Attributes:
+        n_features (int): The number of features. Available after fitting.
+        n_classes (int): The number of classes. Available after fitting.
+    """
+    def fit(self, X, y):
+        """
+        Fits the GaussianNaiveBayes model to the input data by calculating the prior probabilities and likelihoods.
+
+        Args:
+            X (torch.Tensor of shape (n_samples, n_features)): The input data, where each row is a sample and each column is a feature.
+            y (torch.Tensor of shape (n_samples,)): The labels corresponding to each sample. Every element must be in [0, ..., n_classes - 1].
+        Returns:
+            None
+        Raises:
+            TypeError: If the input matrix or the label matrix is not a PyTorch tensor.
+            ValueError: If the input matrix or the label matrix is not the correct shape.
+        """
+        if not isinstance(X, torch.Tensor) or not isinstance(y, torch.Tensor):
+            raise TypeError("The input matrix and the label matrix must be PyTorch tensors.")
+        if X.ndim != 2:
+            raise ValueError("The input matrix must be a 2 dimensional tensor.")
+        if y.ndim != 1 or y.shape[0] != X.shape[0]:
+            raise ValueError("The labels must be 1 dimensional with the same number of samples as the input data")
+        vals = torch.unique(y).numpy()
+        if set(vals) != {*range(len(vals))}:
+            raise ValueError("y must only contain the values in [0, ..., n_classes - 1].")
+
+        n, self.n_features = X.shape
+        self.n_classes = len(vals)
+        self.means = torch.zeros((self.n_classes, self.n_features), dtype=X.dtype)
+        self.vars = torch.zeros_like(self.means, dtype=X.dtype)
+        self.priors = torch.zeros((self.n_classes,), dtype=X.dtype)
+
+        for i in range(self.n_classes):
+            X_cls = X[y == i]
+            self.means[i] = X_cls.mean(dim=0)
+            self.vars[i] = X_cls.var(dim=0)
+            self.priors[i] = len(X_cls) / n
+
+    def predict(self, X):
+        """
+        Applies the fitted GaussianNaiveBayes model to the input data, predicting the labels.
+
+        Args:
+            X (torch.Tensor of shape (n_samples, n_features)): The input data to be classified.
+        Returns:
+            labels (torch.Tensor of shape (n_samples,)): The predicted target values corresponding to each sample.
+        Raises:
+            NotFittedError: If the GaussianNaiveBayes model has not been fitted before predicting.
+            TypeError: If the input matrix is not a PyTorch tensor.
+            ValueError: If the input matrix is not the correct shape.
+        """
+        if not hasattr(self, "priors"):
+            raise NotFittedError("GaussianNaiveBayes.fit() must be called before predicting.")
+        if not isinstance(X, torch.Tensor):
+            raise TypeError("The input matrix must be a PyTorch tensor.")
+        if X.ndim != 2 or X.shape[1] != self.n_features:
+            raise ValueError("The input matrix must be a 2 dimensional tensor with the same number of features as the fitted tensor.")
+
+        posteriors = torch.zeros((self.n_classes, len(X)), dtype=X.dtype)
+
+        for i in range(self.n_classes):
+            prior = torch.log(self.priors[i])
+            posterior = torch.log(self._pdf(X, self.means[i], self.vars[i])).sum(dim=1) + prior
+            posteriors[i] = posterior
+        return torch.argmax(posteriors, dim=0)
+
+    def predict_proba(self, X):
+        """
+        Applies the fitted GaussianNaiveBayes model to the input data, predicting the probabilities.
+
+        Args:
+            X (torch.Tensor of shape (n_samples, n_features)): The input data to be classified.
+        Returns:
+            labels (torch.Tensor of shape (n_samples,)): The predicted target values corresponding to each sample.
+        Raises:
+            NotFittedError: If the GaussianNaiveBayes model has not been fitted before predicting.
+            TypeError: If the input matrix is not a PyTorch tensor.
+            ValueError: If the input matrix is not the correct shape.
+        """
+        if not hasattr(self, "priors"):
+            raise NotFittedError("GaussianNaiveBayes.fit() must be called before predicting.")
+        if not isinstance(X, torch.Tensor):
+            raise TypeError("The input matrix must be a PyTorch tensor.")
+        if X.ndim != 2 or X.shape[1] != self.n_features:
+            raise ValueError("The input matrix must be a 2 dimensional tensor with the same number of features as the fitted tensor.")
+
+        posteriors = torch.zeros((self.n_classes, len(X)), dtype=X.dtype)
+
+        for i in range(self.n_classes):
+            prior = torch.log(self.priors[i])
+            posterior = torch.log(self._pdf(X, self.means[i], self.vars[i])).sum(dim=1) + prior
+            posteriors[i] = posterior
+        prob_normalizers = torch.logsumexp(posteriors, dim=0)
+        log_probs = posteriors - prob_normalizers
+        probs = torch.exp(log_probs).T
+        if self.n_classes == 2:  # binary classification
+            probs = probs[:, 1]
+        return probs
+
+    def _pdf(self, x, mean, var):
+        return torch.exp(-(x - mean) ** 2 / (2 * var)) / torch.sqrt(2 * torch.pi * var)