docstr: PyTorch module implementing the basic building block of the N-HiTS architecture.
  
  The blocks produce outputs of size (target_length, nr_params); i.e.
  "one vector per parameter". The parameters are predicted only for forecast outputs.
  Backcast outputs are in the original "domain".
  
  Parameters
  ----------
  input_chunk_length
      The length of the input sequence fed to the model.
  output_chunk_length
      The length of the forecast of the model.
  num_layers
      The number of fully connected layers preceding the final forking layers.
  layer_width
      The number of neurons that make up each fully connected layer.
  nr_params
      The number of parameters of the likelihood (or 1 if no likelihood is used)
  pooling_kernel_size
      The kernel size for the initial pooling layer
  n_freq_downsample
      The factor by which to downsample time at the output (before interpolating)
  batch_norm
      Whether to use batch norm
  dropout
      Dropout probability
  activation
      The activation function of encoder/decoder intermediate layer.
  MaxPool1d
      Use MaxPool1d pooling. False uses AvgPool1d
  Inputs
  ------
  x of shape `(batch_size, input_chunk_length)`
      Tensor containing the input sequence.
  
  Outputs
  -------
  x_hat of shape `(batch_size, input_chunk_length)`
      Tensor containing the 'backcast' of the block, which represents an approximation of `x`
      given the constraints of the functional space determined by `g`.
  y_hat of shape `(batch_size, output_chunk_length)`
      Tensor containing the forward forecast of the block.
docstr_tok: ["PyTorch","module","implementing","the","basic","building","block","of","the","N-HiTS","architecture",".","The","blocks","produce","outputs","of","size","(","target_length",",","nr_params",")",";","i.e",".","``","one","vector","per","parameter","''",".","The","parameters","are","predicted","only","for","forecast","outputs",".","Backcast","outputs","are","in","the","original","``","domain","''",".","Parameters","--","--","--","--","--","input_chunk_length","The","length","of","the","input","sequence","fed","to","the","model",".","output_chunk_length","The","length","of","the","forecast","of","the","model",".","num_layers","The","number","of","fully","connected","layers","preceding","the","final","forking","layers",".","layer_width","The","number","of","neurons","that","make","up","each","fully","connected","layer",".","nr_params","The","number","of","parameters","of","the","likelihood","(","or","1","if","no","likelihood","is","used",")","pooling_kernel_size","The","kernel","size","for","the","initial","pooling","layer","n_freq_downsample","The","factor","by","which","to","downsample","time","at","the","output","(","before","interpolating",")","batch_norm","Whether","to","use","batch","norm","dropout","Dropout","probability","activation","The","activation","function","of","encoder\/decoder","intermediate","layer",".","MaxPool1d","Use","MaxPool1d","pooling",".","False","uses","AvgPool1d","Inputs","--","--","--","x","of","shape","`","(","batch_size",",","input_chunk_length",")","`","Tensor","containing","the","input","sequence",".","Outputs","--","--","--","-","x_hat","of","shape","`","(","batch_size",",","input_chunk_length",")","`","Tensor","containing","the","'backcast","'","of","the","block",",","which","represents","an","approximation","of","`","x","`","given","the","constraints","of","the","functional","space","determined","by","`","g","`",".","y_hat","of","shape","`","(","batch_size",",","output_chunk_length",")","`","Tensor","containing","the","forward","forecast","of","the","block","."]
code: def __init__(
      self,
      input_chunk_length: int,
      output_chunk_length: int,
      num_layers: int,
      layer_width: int,
      nr_params: int,
      pooling_kernel_size: int,
      n_freq_downsample: int,
      batch_norm: bool,
      dropout: float,
      activation: str,
      MaxPool1d: bool,
  ):
      """PyTorch module implementing the basic building block of the N-HiTS architecture.
  
      The blocks produce outputs of size (target_length, nr_params); i.e.
      "one vector per parameter". The parameters are predicted only for forecast outputs.
      Backcast outputs are in the original "domain".
  
      Parameters
      ----------
      input_chunk_length
          The length of the input sequence fed to the model.
      output_chunk_length
          The length of the forecast of the model.
      num_layers
          The number of fully connected layers preceding the final forking layers.
      layer_width
          The number of neurons that make up each fully connected layer.
      nr_params
          The number of parameters of the likelihood (or 1 if no likelihood is used)
      pooling_kernel_size
          The kernel size for the initial pooling layer
      n_freq_downsample
          The factor by which to downsample time at the output (before interpolating)
      batch_norm
          Whether to use batch norm
      dropout
          Dropout probability
      activation
          The activation function of encoder/decoder intermediate layer.
      MaxPool1d
          Use MaxPool1d pooling. False uses AvgPool1d
      Inputs
      ------
      x of shape `(batch_size, input_chunk_length)`
          Tensor containing the input sequence.
  
      Outputs
      -------
      x_hat of shape `(batch_size, input_chunk_length)`
          Tensor containing the 'backcast' of the block, which represents an approximation of `x`
          given the constraints of the functional space determined by `g`.
      y_hat of shape `(batch_size, output_chunk_length)`
          Tensor containing the forward forecast of the block.
  
      """
      super().__init__()
  
      self.num_layers = num_layers
      self.layer_width = layer_width
      self.input_chunk_length = input_chunk_length
      self.output_chunk_length = output_chunk_length
      self.nr_params = nr_params
      self.pooling_kernel_size = pooling_kernel_size
      self.n_freq_downsample = n_freq_downsample
      self.batch_norm = batch_norm
      self.dropout = dropout
      self.MaxPool1d = MaxPool1d
  
      raise_if_not(
          activation in ACTIVATIONS,
          f"'{activation}' is not in {ACTIVATIONS}",
      )
      self.activation = getattr(nn, activation)()
  
      # number of parameters theta for backcast and forecast
      """
          Note:
          -----
          We use two "last" layers, one for the backcast yielding n_theta_backcast outputs,
          and one for the forecast yielding n_theta_forecast outputs.
  
          In the original code, only one last layer yielding "input_chunk_length + n_theta_forecast" [1]
          outputs is used. So they don't use interpolation for the backcast [2], contrary to what is
          explained in the paper. Here we use what is explained in the paper.
  
          [1] https://github.com/cchallu/n-hits/blob/4e929ed31e1d3ff5169b4aa0d3762a0040abb8db/
          src/models/nhits/nhits.py#L263
          [2] https://github.com/cchallu/n-hits/blob/4e929ed31e1d3ff5169b4aa0d3762a0040abb8db/
          src/models/nhits/nhits.py#L66
          """
      n_theta_backcast = max(input_chunk_length // n_freq_downsample, 1)
      n_theta_forecast = max(
          output_chunk_length // n_freq_downsample, 1
      )
  
      # entry pooling layer
      pool1d = nn.MaxPool1d if self.MaxPool1d else nn.AvgPool1d
      self.pooling_layer = pool1d(
          kernel_size=self.pooling_kernel_size,
          stride=self.pooling_kernel_size,
          ceil_mode=True,
      )
  
      # layer widths
      in_len = int(np.ceil(input_chunk_length / pooling_kernel_size))
      self.layer_widths = [in_len] + [
          self.layer_width
      ] * self.num_layers
  
      # FC layers
      layers = []
      for i in range(self.num_layers):
          layers.append(
              nn.Linear(
                  in_features=self.layer_widths[i],
                  out_features=self.layer_widths[i + 1],
              )
          )
          layers.append(self.activation)
  
          if self.batch_norm:
              layers.append(
                  nn.BatchNorm1d(num_features=self.layer_widths[i + 1])
              )
  
          if self.dropout > 0:
              layers.append(MonteCarloDropout(p=self.dropout))
  
      self.layers = nn.Sequential(*layers)
  
      # Fully connected layer producing forecast/backcast expansion coefficients (waveform generator parameters).
      # The coefficients are emitted for each parameter of the likelihood for the forecast.
      self.backcast_linear_layer = nn.Linear(
          in_features=layer_width, out_features=n_theta_backcast
      )
      self.forecast_linear_layer = nn.Linear(
          in_features=layer_width,
          out_features=nr_params * n_theta_forecast,
      )
  
imports: from typing import List, Optional, Tuple, Union
  import numpy
  import torch
  import torch.nn
  import torch.nn.functional
  from darts.logging import get_logger, raise_if_not
  from darts.models.forecasting.pl_forecasting_module import PLPastCovariatesModule, io_processor
  from darts.models.forecasting.torch_forecasting_model import PastCovariatesTorchModel
  from darts.utils.torch import MonteCarloDropout
label_desc: Use image node_id 1 to create a new _Block object from inherited base classes: nn with example: obj = _Block(input_chunk_length, output_chunk_length, num_layers, layer_width, nr_params, pooling_kernel_size, n_freq_downsample, batch_norm, dropout, activation, MaxPool1d)