PyDLLib 1.0__py3-none-any.whl

DLL/DeepLearning/Layers/_Reshape.py

@@ -0,0 +1,52 @@
+import torch
+
+from ._BaseLayer import BaseLayer
+
+
+class Reshape(BaseLayer):
+    """
+    The reshape layer.
+
+    Args:
+        output_shape (int): The output_shape of the model not containing the batch_size dimension. Must be a positive integer or a tuple.
+    """
+    def __init__(self, output_shape, **kwargs):
+        output_shape = (output_shape,) if isinstance(output_shape, int) else output_shape
+
+        super().__init__(output_shape, **kwargs)
+        self.name = "Reshape"
+    
+    def forward(self, input, **kwargs):
+        """
+        Reshapes the input into the output_shape.
+
+        Args:
+            input (torch.Tensor of shape (n_samples, *layer.input_shape)): The input to the layer. Must be a torch.Tensor of the spesified shape given by layer.input_shape.
+
+        Returns:
+            torch.Tensor of shape (n_samples, *layer.output_shape): The output tensor after reshaping the input tensor.
+        """
+        if not isinstance(input, torch.Tensor):
+            raise TypeError("input must be a torch.Tensor.")
+        if input.shape[1:] != self.input_shape:
+            raise ValueError(f"input is not the same shape as the spesified input_shape ({input.shape[1:], self.input_shape}).")
+
+        self.input = input
+        return input.reshape(input.shape[0], *self.output_shape)
+    
+    def backward(self, dCdy, **kwargs):
+        """
+        Reshapes the gradient to the original shape.
+
+        Args:
+            dCdy (torch.Tensor of shape (n_samples, *layer.output_shape): The gradient given by the next layer.
+            
+        Returns:
+            torch.Tensor of shape (n_samples, *layer.input_shape): The reshaped gradient after backpropagation through the layer.
+        """
+        if not isinstance(dCdy, torch.Tensor):
+            raise TypeError("dCdy must be a torch.Tensor.")
+        if dCdy.shape[1:] != self.output_shape:
+            raise ValueError(f"dCdy is not the same shape as the spesified output_shape ({dCdy.shape[1:], self.output_shape}).")
+
+        return dCdy.reshape(*self.input.shape)

DLL/DeepLearning/Layers/__init__.py

@@ -0,0 +1,14 @@
+from ._Conv2D import Conv2D
+from ._Dense import Dense
+from ._Flatten import Flatten
+from ._Input import Input
+from ._LSTM import LSTM
+from ._MaxPooling2D import MaxPooling2D
+from ._Reshape import Reshape
+from ._RNN import RNN
+from ._Bidirectional import Bidirectional
+from ._Identity import Identity
+from ._Add import Add
+from ._LayerList import LayerList
+from ._Attention import MultiHeadAttention
+from ._DenseKAN import DenseKAN

DLL/DeepLearning/Losses/_BCE.py

@@ -0,0 +1,96 @@
+import torch
+
+from ._BaseLoss import BaseLoss
+
+
+class BCE(BaseLoss):
+    """
+    The binary cross entropy loss. Used in binary classification. Identical to categorical cross entropy with 2 classes.
+
+    Args:
+        reduction (str, optional): The reduction method. Must be one of "mean" or "sum". Defaults to "mean".
+    """
+    def __init__(self, reduction="mean"):
+        if reduction not in ["mean", "sum"]:
+            raise ValueError('reduction must be in ["mean", "sum"].')
+
+        self.reduction = reduction
+
+    def loss(self, prediction, true_output):
+        """
+        Calculates the binary categorical cross entropy with the equations:
+
+        .. math::
+        
+            \\begin{align*}
+                l_i &= y_i\\cdot\\text{ln}(f(x_i)) + (1 - y_i)\\cdot\\text{ln}(1 - f(x_i)),\\\\
+                L_{sum} &= \\sum_{i=1}^n l_i \\text{ or } L_{mean} = \\frac{1}{n}\\sum_{i=1}^n l_i,
+            \\end{align*}
+
+        where :math:`f(x_i)` is the predicted value and :math:`y_i` is the true value.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values in range [0, 1]. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A tensor of true values labeled with 0 or 1. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor containing a single value with the loss.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+
+        if self.reduction == "mean":
+            return -torch.mean(true_output * torch.log(prediction + 1e-10) + (1 - true_output) * torch.log(1 - prediction + 1e-10))
+        return -torch.sum(true_output * torch.log(prediction + 1e-10) + (1 - true_output) * torch.log(1 - prediction + 1e-10))
+
+    def gradient(self, prediction, true_output):
+        """
+        Calculates the gradient of the binary categorical cross entropy.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values in range [0, 1]. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A tensor of true values labeled with 0 or 1. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor of the same shape as the inputs containing the gradients.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+        if set(torch.unique(true_output).numpy()) != {0, 1}:
+            raise ValueError("The classes must be labelled 0 and 1.")
+
+        if self.reduction == "mean":
+            return (prediction - true_output) / ((prediction * (1 - prediction) + 1e-10) * prediction.shape[0])
+        return (prediction - true_output) / (prediction * (1 - prediction) + 1e-10)
+    
+    def hessian(self, prediction, true_output):
+        """
+        Calculates the diagonal of the hessian matrix of the binary categorical cross entropy.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values in range [0, 1]. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A tensor of true values labeled with 0 or 1. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor of the same shape as the inputs containing the diagonal of the hessian matrix.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+        if set(torch.unique(true_output).numpy()) != {0, 1}:
+            raise ValueError("The classes must be labelled 0 and 1.")
+        
+        first_term = 1 / ((1 - prediction) * prediction + 1e-10)
+        second_term = (true_output - prediction) / ((1 - prediction) * prediction ** 2 + 1e-10)
+        third_term = (prediction - true_output) / ((1 - prediction) ** 2 * prediction + 1e-10)
+        hess = first_term + second_term + third_term
+
+        if self.reduction == "mean":
+            return hess / prediction.shape[0]
+        return hess
+        

DLL/DeepLearning/Losses/_BaseLoss.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+
+
+class BaseLoss(ABC):
+    """
+    :meta private:
+    """
+    @abstractmethod
+    def loss(self, prediction, true_output):
+        pass
+    
+    @abstractmethod
+    def gradient(self, prediction, true_output):
+        pass
+
+    @abstractmethod
+    def hessian(self, prediction, true_output):
+        pass

DLL/DeepLearning/Losses/_CCE.py

@@ -0,0 +1,87 @@
+import torch
+
+from ._BaseLoss import BaseLoss
+
+
+class CCE(BaseLoss):
+    """
+    The categorical cross entropy loss. Used in multi-class classification.
+
+    Args:
+        reduction (str, optional): The reduction method. Must be one of "mean" or "sum". Defaults to "mean".
+    """
+    def __init__(self, reduction="mean"):
+        if reduction not in ["mean", "sum"]:
+            raise ValueError('reduction must be in ["mean", "sum"].')
+
+        self.reduction = reduction
+
+    def loss(self, prediction, true_output):
+        """
+        Calculates the categorical categorical cross entropy with the equations:
+
+        .. math::
+
+            \\begin{align*}
+                l_i &= y_i\\cdot\\text{ln}(f(x_i)),\\\\
+                L_{sum} &= \\sum_{i=1}^n l_i \\text{ or } L_{mean} = \\frac{1}{n}\\sum_{i=1}^n l_i,
+            \\end{align*}
+
+        where :math:`f(x_i)` is the predicted value and :math:`y_i` is the true value.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values as a probability distribution. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A one-hot encoded tensor of true values. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor containing a single value with the loss.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+
+        if self.reduction == "mean":
+            return -torch.mean(torch.sum(true_output * torch.log(prediction + 1e-5), dim=1))
+        return -torch.sum(true_output * torch.log(prediction + 1e-5))
+
+    def gradient(self, prediction, true_output):
+        """
+        Calculates the gradient of the categorical categorical cross entropy.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values as a probability distribution. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A one-hot encoded tensor of true values. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor of the same shape as the inputs containing the gradients.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+        
+        if self.reduction == "mean":
+            return -true_output / ((prediction + 1e-5) * prediction.shape[0])
+        return -true_output / (prediction + 1e-5)
+    
+    def hessian(self, prediction, true_output):
+        """
+        Calculates the diagonal of the hessian matrix of the categorical cross entropy loss.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values in range [0, 1]. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A tensor of true values labeled with 0 or 1. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor of the same shape as the inputs containing the diagonal of the hessian matrix.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+
+        grad = true_output / (prediction ** 2 + 1e-5)
+        if self.reduction == "mean":
+            return grad / prediction.shape[0]
+        return grad

DLL/DeepLearning/Losses/_Exponential.py

@@ -0,0 +1,101 @@
+import torch
+
+from ._BaseLoss import BaseLoss
+
+
+class Exponential(BaseLoss):
+    """
+    The exponential loss. Used for binary classification.
+
+    Args:
+        reduction (str, optional): The reduction method. Must be one of "mean" or "sum". Defaults to "mean".
+    """
+    def __init__(self, reduction="mean"):
+        if reduction not in ["mean", "sum"]:
+            raise ValueError('reduction must be in ["mean", "sum"].')
+
+        self.reduction = reduction
+
+    def loss(self, prediction, true_output):
+        """
+        Calculates the exponential loss with the equations:
+
+        .. math::
+
+            \\begin{align*}
+                l_i &= y_i\\cdot e^{-f(x_i)} + (1 - y_i)\\cdot e^{f(x_i)},\\\\
+                L_{sum} &= \\sum_{i=1}^n l_i \\text{ or } L_{mean} = \\frac{1}{n}\\sum_{i=1}^n l_i,
+            \\end{align*}
+
+        where :math:`f(x_i)` is the predicted value and :math:`y_i` is the true value.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values as a probability distribution. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A one-hot encoded tensor of true values. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor containing a single value with the loss.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+        if set(torch.unique(true_output).numpy()) != {0, 1}:
+            raise ValueError("The classes must be labelled 0 and 1.")
+
+        prediction = 2 * prediction - 1
+        true_output = 2 * true_output - 1
+        loss = torch.exp(-prediction * true_output)
+        if self.reduction == "mean":
+            return loss.mean()
+        return loss.sum()
+
+    def gradient(self, prediction, true_output):
+        """
+        Calculates the gradient of the exponential loss.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values in range [0, 1]. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A tensor of true values labeled with 0 or 1. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor of the same shape as the inputs containing the gradients.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+        if set(torch.unique(true_output).numpy()) != {0, 1}:
+            raise ValueError("The classes must be labelled 0 and 1.")
+        
+        prediction = 2 * prediction - 1
+        true_output = 2 * true_output - 1
+        grad = -2 * true_output * torch.exp(-prediction * true_output)
+        if self.reduction == "mean":
+            return grad / prediction.shape[0]
+        return grad
+    
+    def hessian(self, prediction, true_output):
+        """
+        Calculates the diagonal of the hessian matrix of the exponential loss.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values in range [0, 1]. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A tensor of true values labeled with 0 or 1. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor of the same shape as the inputs containing the diagonal of the hessian matrix.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+        if set(torch.unique(true_output).numpy()) != {0, 1}:
+            raise ValueError("The classes must be labelled 0 and 1.")
+        
+        prediction = 2 * prediction - 1
+        true_output = 2 * true_output - 1
+        grad = 4 * true_output ** 2 * torch.exp(-prediction * true_output)
+        if self.reduction == "mean":
+            return grad / prediction.shape[0]
+        return grad

DLL/DeepLearning/Losses/_Huber.py

@@ -0,0 +1,104 @@
+import torch
+
+from ._BaseLoss import BaseLoss
+
+
+class Huber(BaseLoss):
+    """
+    The huber loss. Used for regression. Is a combination of squared error and absolute error.
+
+    Args:
+        delta (int | float, optional): The radius around the true value that uses the squared error. If the difference is larger than delta, the absolute error is used. Must be a positive real number. Defaults to 1.
+        reduction (str, optional): The reduction method. Must be one of "mean" or "sum".
+    """
+    def __init__(self, delta=1.0, reduction="mean"):
+        if not isinstance(delta, int | float) or delta <= 0:
+            raise ValueError("delta must be a positive real number.")
+        if reduction not in ["mean", "sum"]:
+            raise ValueError('reduction must be in ["mean", "sum"].')
+        
+        self.delta = delta
+        self.reduction = reduction
+
+    def loss(self, prediction, true_output):
+        """
+        Calculates the huber loss with the equations:
+
+        .. math::
+        
+            \\begin{align*}
+                l_i &= \\begin{cases}
+                    \\frac{1}{2}(y_i - f(x_i))^2 & \\text{if } |y_i - f(x_i)| \\leq \\delta,\\\\
+                    \\delta|y_i - f(x_i)| - \\frac{1}{2}\\delta^2 & \\text{otherwise},
+                \end{cases}\\\\
+                L_{sum} &= \\sum_{i=1}^n l_i \\text{ or } L_{mean} = \\frac{1}{n}\\sum_{i=1}^n l_i,
+            \\end{align*}
+
+        where :math:`f(x_i)` is the predicted value and :math:`y_i` is the true value.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A tensor of true values. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor containing a single value with the loss.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+        
+        error = prediction - true_output
+        abs_error = torch.abs(error)
+        quadratic = 0.5 * error ** 2
+        linear = self.delta * (abs_error - 0.5 * self.delta)
+        if self.reduction == "mean":
+            return torch.where(abs_error <= self.delta, quadratic, linear).mean()
+        return torch.where(abs_error <= self.delta, quadratic, linear).sum()
+
+    def gradient(self, prediction, true_output):
+        """
+        Calculates the gradient of the huber loss.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A tensor of true values. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor of the same shape as the inputs containing the gradients.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+        
+        error = prediction - true_output
+        abs_error = torch.abs(error)
+        quadratic_grad = error
+        linear_grad = self.delta * torch.sign(error)
+        if self.reduction == "mean":
+            return torch.where(abs_error <= self.delta, quadratic_grad, linear_grad) / prediction.shape[0]
+        return torch.where(abs_error <= self.delta, quadratic_grad, linear_grad)
+    
+    def hessian(self, prediction, true_output):
+        """
+        Calculates the diagonal of the hessian matrix of the huber loss.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A tensor of true values. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor of the same shape as the inputs containing the diagonal of the hessian matrix.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+        
+        abs_error = torch.abs(prediction - true_output)
+        quadratic_grad = torch.full((len(true_output),), 1)
+        linear_grad = torch.full((len(true_output),), 0)
+        if self.reduction == "mean":
+            return torch.where(abs_error <= self.delta, quadratic_grad, linear_grad) / prediction.shape[0]
+        return torch.where(abs_error <= self.delta, quadratic_grad, linear_grad)

DLL/DeepLearning/Losses/_MAE.py

@@ -0,0 +1,85 @@
+import torch
+
+from ._BaseLoss import BaseLoss
+
+
+class MAE(BaseLoss):
+    """
+    The absolute error loss. Used for regression.
+
+    Args:
+        reduction (str, optional): The reduction method. Must be one of "mean" or "sum".
+    """
+    def __init__(self, reduction="mean"):
+        if reduction not in ["mean", "sum"]:
+            raise ValueError('reduction must be in ["mean", "sum"].')
+        
+        self.reduction = reduction
+
+    def loss(self, prediction, true_output):
+        """
+        Calculates the absolute error loss with the equations:
+
+        .. math::
+        
+            \\begin{align*}
+                l_i &= |y_i - f(x_i)|,\\\\
+                L_{sum} &= \\sum_{i=1}^n l_i \\text{ or } L_{mean} = \\frac{1}{n}\\sum_{i=1}^n l_i,
+            \\end{align*}
+        
+        where :math:`f(x_i)` is the predicted value and :math:`y_i` is the true value.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A tensor of true values. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor containing a single value with the loss.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+        
+        if self.reduction == "mean":
+            return torch.abs(prediction - true_output).mean()
+        return torch.abs(prediction - true_output).sum()
+        
+
+    def gradient(self, prediction, true_output):
+        """
+        Calculates the gradient of the absolute error loss.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A tensor of true values. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor of the same shape as the inputs containing the gradients.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+        
+        if self.reduction == "mean":
+            return torch.sign(prediction - true_output) / prediction.shape[0]
+        return torch.sign(prediction - true_output)
+    
+    def hessian(self, prediction, true_output):
+        """
+        Calculates the diagonal of the hessian matrix of the absolute error loss.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A tensor of true values. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor of the same shape as the inputs containing the diagonal of the hessian matrix.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+        
+        return torch.full((len(true_output),), 0)

DLL/DeepLearning/Losses/_MSE.py

@@ -0,0 +1,86 @@
+import torch
+
+from ._BaseLoss import BaseLoss
+
+
+class MSE(BaseLoss):
+    """
+    The squared error loss. Used for regression.
+
+    Args:
+        reduction (str, optional): The reduction method. Must be one of "mean" or "sum".
+    """
+    def __init__(self, reduction="mean"):
+        if reduction not in ["mean", "sum"]:
+            raise ValueError('reduction must be in ["mean", "sum"].')
+        
+        self.reduction = reduction
+
+    def loss(self, prediction, true_output):
+        """
+        Calculates the squared error loss with the equations:
+
+        .. math::
+
+            \\begin{align*}
+                l_i &= (y_i - f(x_i))^2,\\\\
+                L_{sum} &= \\sum_{i=1}^n l_i \\text{ or } L_{mean} = \\frac{1}{n}\\sum_{i=1}^n l_i,
+            \\end{align*}
+        
+        where :math:`f(x_i)` is the predicted value and :math:`y_i` is the true value.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A tensor of true values. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor containing a single value with the loss.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+        
+        if self.reduction == "mean":
+            return torch.mean((prediction - true_output) ** 2)
+        return torch.sum((prediction - true_output) ** 2)
+
+    def gradient(self, prediction, true_output):
+        """
+        Calculates the gradient of the squared error loss.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A tensor of true values. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor of the same shape as the inputs containing the gradients.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+        
+        if self.reduction == "mean":
+            return 2 * (prediction - true_output) / prediction.shape[0]
+        return 2 * (prediction - true_output)
+    
+    def hessian(self, prediction, true_output):
+        """
+        Calculates the diagonal of the hessian matrix of the squared error loss.
+
+        Args:
+            prediction (torch.Tensor): A tensor of predicted values. Must be the same shape as the true_output.
+            true_output (torch.Tensor): A tensor of true values. Must be the same shape as the prediction.
+
+        Returns:
+            torch.Tensor: A tensor of the same shape as the inputs containing the diagonal of the hessian matrix.
+        """
+        if not isinstance(prediction, torch.Tensor) or not isinstance(true_output, torch.Tensor):
+            raise TypeError("prediction and true_output must be torch tensors.")
+        if prediction.shape != true_output.shape:
+            raise ValueError("prediction and true_output must have the same shape.")
+        
+        if self.reduction == "mean":
+            return torch.full((len(true_output),), 2 / prediction.shape[0])
+        return torch.full((len(true_output),), 2)

DLL/DeepLearning/Losses/__init__.py

@@ -0,0 +1,6 @@
+from ._MSE import MSE
+from ._MAE import MAE
+from ._BCE import BCE
+from ._CCE import CCE
+from ._Huber import Huber
+from ._Exponential import Exponential