From 6f9a8a089cd5bd54ca91d0d5c57231d75519af2d Mon Sep 17 00:00:00 2001 From: Yinon Polak Date: Sun, 19 Mar 2023 17:45:30 +0200 Subject: [PATCH] add mlp documentation --- .../prediction_models/PyTorchMLPModel.py | 54 ++++++++++++++++--- 1 file changed, 48 insertions(+), 6 deletions(-) diff --git a/freqtrade/freqai/prediction_models/PyTorchMLPModel.py b/freqtrade/freqai/prediction_models/PyTorchMLPModel.py index 482b3f889..07056e930 100644 --- a/freqtrade/freqai/prediction_models/PyTorchMLPModel.py +++ b/freqtrade/freqai/prediction_models/PyTorchMLPModel.py @@ -1,16 +1,42 @@ import logging import torch.nn as nn -from torch import Tensor - +import torch logger = logging.getLogger(__name__) class PyTorchMLPModel(nn.Module): + """ + A multi-layer perceptron (MLP) model implemented using PyTorch. + + :param input_dim: The number of input features. + :param output_dim: The number of output classes. + :param hidden_dim: The number of hidden units in each layer. Default: 256 + :param dropout_percent: The dropout rate for regularization. Default: 0.2 + :param n_layer: The number of layers in the MLP. Default: 1 + + :returns: The output of the MLP, with shape (batch_size, output_dim) + + + A neural network typically consists of input, output, and hidden layers, where the + information flows from the input layer through the hidden layers to the output layer. + In a feedforward neural network, also known as a multilayer perceptron (MLP), the + information flows in one direction only. Each hidden layer contains multiple units + or nodes that take input from the previous layer and produce output that goes to the + next layer. + + The hidden_dim parameter in the FeedForward class refers to the number of units + (or nodes) in the hidden layer. This parameter controls the complexity of the neural + network and determines how many nonlinear relationships the network can represent. + A higher value of hidden_dim allows the network to represent more complex functions + but may also make the network more prone to overfitting, where the model memorizes + the training data instead of learning general patterns. + """ + def __init__(self, input_dim: int, output_dim: int, **kwargs): super(PyTorchMLPModel, self).__init__() - hidden_dim: int = kwargs.get("hidden_dim", 1024) + hidden_dim: int = kwargs.get("hidden_dim", 256) dropout_percent: int = kwargs.get("dropout_percent", 0.2) n_layer: int = kwargs.get("n_layer", 1) self.input_layer = nn.Linear(input_dim, hidden_dim) @@ -19,7 +45,7 @@ class PyTorchMLPModel(nn.Module): self.relu = nn.ReLU() self.dropout = nn.Dropout(p=dropout_percent) - def forward(self, x: Tensor) -> Tensor: + def forward(self, x: torch.Tensor) -> torch.Tensor: x = self.relu(self.input_layer(x)) x = self.dropout(x) x = self.blocks(x) @@ -28,19 +54,35 @@ class PyTorchMLPModel(nn.Module): class Block(nn.Module): + """ + A building block for a multi-layer perceptron (MLP) implemented using PyTorch. + + :param hidden_dim: The number of hidden units in the feedforward network. + :param dropout_percent: The dropout rate for regularization. + + :returns: torch.Tensor. with shape (batch_size, hidden_dim) + """ + def __init__(self, hidden_dim: int, dropout_percent: int): super(Block, self).__init__() self.ff = FeedForward(hidden_dim) self.dropout = nn.Dropout(p=dropout_percent) self.ln = nn.LayerNorm(hidden_dim) - def forward(self, x): + def forward(self, x: torch.Tensor) -> torch.Tensor: x = self.ff(self.ln(x)) x = self.dropout(x) return x class FeedForward(nn.Module): + """ + A fully-connected feedforward neural network block. + + :param hidden_dim: The number of hidden units in the block. + :return: torch.Tensor. with shape (batch_size, hidden_dim) + """ + def __init__(self, hidden_dim: int): super(FeedForward, self).__init__() self.net = nn.Sequential( @@ -48,5 +90,5 @@ class FeedForward(nn.Module): nn.ReLU(), ) - def forward(self, x): + def forward(self, x: torch.Tensor) -> torch.Tensor: return self.net(x)