Package {daltoolboxdp}

Title:	Deep Python Extensions for 'daltoolbox'
Version:	1.3.737
Description:	Extends 'daltoolbox' with Python-backed components for deep learning, scikit-learn classification, and time-series forecasting through 'reticulate'. The package provides objects that follow the 'daltoolbox' architecture while delegating model creation, fitting, encoding, and prediction to Python libraries such as 'torch' and 'scikit-learn'. In the package name, 'dp' stands for 'Deep Python'. The overall workflow is inspired by the Experiment Lines approach described in Ogasawara et al. (2009) <doi:10.1007/978-3-642-02279-1_20>.
License:	MIT + file LICENSE
URL:	https://cefet-rj-dal.github.io/daltoolboxdp/, https://github.com/cefet-rj-dal/daltoolboxdp
BugReports:	https://github.com/cefet-rj-dal/daltoolboxdp/issues
Encoding:	UTF-8
RoxygenNote:	8.0.0
Depends:	R (≥ 4.1.0)
Imports:	tspredit, daltoolbox, reticulate
Suggests:	testthat (≥ 3.0.0)
Config/testthat/edition:	3
Config/reticulate:	list( packages = list( list(package = "scipy"), list(package = "torch"), list(package = "pandas"), list(package = "numpy"), list(package = "matplotlib"), list(package = "scikit-learn") ) )
NeedsCompilation:	no
Packaged:	2026-05-14 04:12:21 UTC; gpca
Author:	Eduardo Ogasawara [aut, ths, cre], Diego Salles [aut], Erich Carvalho [aut], Janio Lima [aut], Joao Kongevold [aut], Lucas Tavares [aut], Eduardo Bezerra [ctb], CEFET/RJ [cph]
Maintainer:	Eduardo Ogasawara <eogasawara@ieee.org>
Repository:	CRAN
Date/Publication:	2026-05-14 13:10:16 UTC

Adversarial Autoencoder - Encode

Description

Creates an adversarial autoencoder (AAE) with configurable encoder, decoder and discriminator topologies through a Python/PyTorch backend.

Usage

autoenc_adv_e(
  input_size,
  encoding_size,
  encoder_hidden_sizes = c(60L, 60L),
  decoder_hidden_sizes = c(60L, 60L),
  discriminator_hidden_sizes = c(60L, 60L),
  activation = c("relu", "leaky_relu", "elu", "gelu", "tanh"),
  dropout = 0.4,
  latent_prior_scale = 5,
  lr_encoder = NULL,
  lr_decoder = NULL,
  lr_generator = NULL,
  lr_discriminator = NULL,
  batch_size = 350,
  epochs = 100L,
  num_epochs = NULL,
  learning_rate = 0.001,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.3,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Details

The adversarial autoencoder exposes the latent prior scale, dropout, activation family, and optimizer learning rates for each adversarial component. If the component-specific learning rates are left as NULL, the wrapper derives them from learning_rate using the training defaults of the Python implementation.

Value

A autoenc_adv_e object.

References

Makhzani, A., Shlens, J., Jaitly, N., Goodfellow, I., & Frey, B. (2016). Adversarial Autoencoders.

Examples

## Not run: 
X <- matrix(rnorm(1000), nrow = 50, ncol = 20)
ae <- autoenc_adv_e(
  input_size = 20,
  encoding_size = 5,
  encoder_hidden_sizes = c(128L, 64L),
  discriminator_hidden_sizes = c(64L, 32L),
  latent_prior_scale = 2
)
ae <- daltoolbox::fit(ae, X)
Z <- daltoolbox::transform(ae, X)

## End(Not run)

Adversarial Autoencoder - Encode-Decode

Description

Creates an adversarial autoencoder (AAE) that reconstructs observations while regularizing the latent space through a discriminator, using a Python/PyTorch backend.

Usage

autoenc_adv_ed(
  input_size,
  encoding_size,
  encoder_hidden_sizes = c(60L, 60L),
  decoder_hidden_sizes = c(60L, 60L),
  discriminator_hidden_sizes = c(60L, 60L),
  activation = c("relu", "leaky_relu", "elu", "gelu", "tanh"),
  dropout = 0.4,
  latent_prior_scale = 5,
  lr_encoder = NULL,
  lr_decoder = NULL,
  lr_generator = NULL,
  lr_discriminator = NULL,
  batch_size = 350,
  epochs = 100L,
  num_epochs = NULL,
  learning_rate = 0.001,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.3,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Value

A autoenc_adv_ed object.

References

Makhzani, A. et al. (2016). Adversarial Autoencoders.

Examples

## Not run: 
X <- matrix(rnorm(1000), nrow = 50, ncol = 20)
ae <- autoenc_adv_ed(
  input_size = 20,
  encoding_size = 5,
  encoder_hidden_sizes = c(128L, 64L),
  discriminator_hidden_sizes = c(64L, 32L),
  latent_prior_scale = 2
)
ae <- daltoolbox::fit(ae, X)
X_hat <- daltoolbox::transform(ae, X)

## End(Not run)

Convolutional Autoencoder - Encode

Description

Creates a deep learning convolutional autoencoder (ConvAE) to encode sequences of observations. Wraps a PyTorch implementation.

Usage

autoenc_conv_e(
  input_size,
  encoding_size,
  batch_size = 32,
  epochs = 100L,
  num_epochs = NULL,
  learning_rate = 0.001,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.3,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Value

A autoenc_conv_e object.

References

Masci, J., Meier, U., Ciresan, D., & Schmidhuber, J. (2011). Stacked Convolutional Auto-Encoders.

Examples

## Not run: 
# Conv1D-based encoder expects data reshaped internally to (n, input_size, 1)
X <- matrix(rnorm(1000), nrow = 50, ncol = 20)
ae <- autoenc_conv_e(input_size = 20, encoding_size = 5, epochs = 100)
ae <- daltoolbox::fit(ae, X)
Z  <- daltoolbox::transform(ae, X)   # 50 x 5 encodings

## End(Not run)

# See:
# https://github.com/cefet-rj-dal/daltoolbox/blob/main/autoencoder/autoenc_conv_e.md

Convolutional Autoencoder - Encode-Decode

Description

Creates a deep learning convolutional autoencoder (ConvAE) to encode and decode sequences of observations. Wraps a PyTorch implementation.

Usage

autoenc_conv_ed(
  input_size,
  encoding_size,
  batch_size = 32,
  epochs = 100L,
  num_epochs = NULL,
  learning_rate = 0.001,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.3,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Value

A autoenc_conv_ed object.

Examples

## Not run: 
X <- matrix(rnorm(1000), nrow = 50, ncol = 20)
ae <- autoenc_conv_ed(input_size = 20, encoding_size = 5, epochs = 100)
ae <- daltoolbox::fit(ae, X)
X_hat <- daltoolbox::transform(ae, X)  # same dims as X
mean((X - X_hat)^2)

## End(Not run)

# See:
# https://github.com/cefet-rj-dal/daltoolbox/blob/main/autoencoder/autoenc_conv_ed.md

Denoising Autoencoder - Encode

Description

Creates a denoising autoencoder that learns robust latent representations from corrupted inputs through a Python/PyTorch backend.

Usage

autoenc_denoise_e(
  input_size,
  encoding_size,
  encoder_hidden_sizes = 64L,
  decoder_hidden_sizes = NULL,
  activation = c("relu", "leaky_relu", "elu", "gelu", "selu", "tanh"),
  output_activation = c("none", "relu", "sigmoid", "tanh", "softplus"),
  negative_slope = 0.2,
  batch_size = 32,
  epochs = 100L,
  num_epochs = NULL,
  learning_rate = 0.001,
  noise_factor = 0.3,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.3,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Details

Besides the denoising factor, this constructor exposes the same encoder/decoder customization available in autoenc_e(). This allows the user to combine shallow or deep dense architectures with stochastic input corruption.

Value

A autoenc_denoise_e object.

References

Vincent, P., Larochelle, H., Bengio, Y., & Manzagol, P. A. (2008). Extracting and Composing Robust Features with Denoising Autoencoders.

Examples

## Not run: 
X <- matrix(rnorm(1000), nrow = 50, ncol = 20)
ae <- autoenc_denoise_e(
  input_size = 20,
  encoding_size = 5,
  encoder_hidden_sizes = c(128L, 64L),
  noise_factor = 0.2
)
ae <- daltoolbox::fit(ae, X)
Z <- daltoolbox::transform(ae, X)
dim(Z)

## End(Not run)

Denoising Autoencoder - Encode-Decode

Description

Creates a denoising autoencoder that reconstructs observations after learning from corrupted inputs through a Python/PyTorch backend.

Usage

autoenc_denoise_ed(
  input_size,
  encoding_size,
  encoder_hidden_sizes = 64L,
  decoder_hidden_sizes = NULL,
  activation = c("relu", "leaky_relu", "elu", "gelu", "selu", "tanh"),
  output_activation = c("none", "relu", "sigmoid", "tanh", "softplus"),
  negative_slope = 0.2,
  batch_size = 32,
  epochs = 100L,
  num_epochs = NULL,
  learning_rate = 0.001,
  noise_factor = 0.3,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.3,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Value

A autoenc_denoise_ed object.

References

Vincent, P., Larochelle, H., Bengio, Y., & Manzagol, P. A. (2008). Extracting and Composing Robust Features with Denoising Autoencoders.

Examples

## Not run: 
X <- matrix(rnorm(1000), nrow = 50, ncol = 20)
ae <- autoenc_denoise_ed(
  input_size = 20,
  encoding_size = 5,
  encoder_hidden_sizes = c(128L, 64L),
  noise_factor = 0.2
)
ae <- daltoolbox::fit(ae, X)
X_hat <- daltoolbox::transform(ae, X)
mean((X - X_hat)^2)

## End(Not run)

Autoencoder - Encode

Description

Creates a dense autoencoder that learns a latent representation for a sequence of observations through a Python/PyTorch backend.

Usage

autoenc_e(
  input_size,
  encoding_size,
  encoder_hidden_sizes = 64L,
  decoder_hidden_sizes = NULL,
  activation = c("relu", "leaky_relu", "elu", "gelu", "selu", "tanh"),
  output_activation = c("none", "relu", "sigmoid", "tanh", "softplus"),
  negative_slope = 0.2,
  batch_size = 32,
  epochs = 100L,
  num_epochs = NULL,
  learning_rate = 0.001,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.3,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Details

The dense autoencoder is now architecture-configurable. You can keep the original single hidden layer with encoder_hidden_sizes = 64, or define deeper asymmetric encoder/decoder stacks such as encoder_hidden_sizes = c(128L, 64L, 32L) and decoder_hidden_sizes = c(32L, 64L, 128L).

Value

A autoenc_e object.

References

Hinton, G. E., & Salakhutdinov, R. R. (2006). Reducing the Dimensionality of Data with Neural Networks. Paszke, A., et al. (2019). PyTorch: An Imperative Style, High-Performance Deep Learning Library.

Examples

## Not run: 
X <- matrix(rnorm(2000), nrow = 100, ncol = 20)

ae <- autoenc_e(
  input_size = 20,
  encoding_size = 5,
  encoder_hidden_sizes = c(128L, 64L),
  activation = "relu"
)
ae <- daltoolbox::fit(ae, X)
Z <- daltoolbox::transform(ae, X)
dim(Z)

## End(Not run)

Autoencoder - Encode-Decode

Description

Creates a dense autoencoder that compresses and reconstructs observations through a Python/PyTorch backend.

Usage

autoenc_ed(
  input_size,
  encoding_size,
  encoder_hidden_sizes = 64L,
  decoder_hidden_sizes = NULL,
  activation = c("relu", "leaky_relu", "elu", "gelu", "selu", "tanh"),
  output_activation = c("none", "relu", "sigmoid", "tanh", "softplus"),
  negative_slope = 0.2,
  batch_size = 32,
  epochs = 100L,
  num_epochs = NULL,
  learning_rate = 0.001,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.3,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Details

This variant exposes the same architecture controls as autoenc_e(), but the transformation returns reconstructions in the original input space. Use it when reconstruction quality is part of the analysis or when the autoencoder is used for anomaly detection.

Value

A autoenc_ed object.

References

Hinton, G. E., & Salakhutdinov, R. R. (2006). Reducing the Dimensionality of Data with Neural Networks. Paszke, A., et al. (2019). PyTorch: An Imperative Style, High-Performance Deep Learning Library.

Examples

## Not run: 
X <- matrix(rnorm(1000), nrow = 50, ncol = 20)
ae <- autoenc_ed(
  input_size = 20,
  encoding_size = 5,
  encoder_hidden_sizes = c(128L, 64L),
  decoder_hidden_sizes = c(64L, 128L)
)
ae <- daltoolbox::fit(ae, X)
X_hat <- daltoolbox::transform(ae, X)
mean((X - X_hat)^2)

## End(Not run)

LSTM Autoencoder - Encode

Description

Creates an LSTM-based autoencoder with configurable recurrent depth and latent projection through a Python/PyTorch backend.

Usage

autoenc_lstm_e(
  input_size,
  encoding_size,
  lstm_hidden_size = NULL,
  sequence_length = 1L,
  num_layers = 1L,
  dropout = 0,
  batch_size = 32,
  epochs = 100L,
  num_epochs = NULL,
  learning_rate = 0.001,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.3,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Details

encoding_size remains the latent bottleneck exposed to the user. The recurrent body can now use a different lstm_hidden_size, multiple layers, dropout between recurrent layers, and a configurable sequence_length to reshape each row into a sequence before encoding.

Value

A autoenc_lstm_e object.

References

Hochreiter, S., & Schmidhuber, J. (1997). Long Short-Term Memory.

Examples

## Not run: 
X <- matrix(rnorm(1000), nrow = 50, ncol = 20)
ae <- autoenc_lstm_e(
  input_size = 20,
  encoding_size = 5,
  lstm_hidden_size = 16,
  sequence_length = 4,
  num_layers = 2,
  dropout = 0.1
)
ae <- daltoolbox::fit(ae, X)
Z <- daltoolbox::transform(ae, X)
dim(Z)

## End(Not run)

LSTM Autoencoder - Encode-Decode

Description

Creates an LSTM-based autoencoder that reconstructs observations after sequence-aware compression through a Python/PyTorch backend.

Usage

autoenc_lstm_ed(
  input_size,
  encoding_size,
  lstm_hidden_size = NULL,
  sequence_length = 1L,
  num_layers = 1L,
  dropout = 0,
  batch_size = 32,
  epochs = 100L,
  num_epochs = NULL,
  learning_rate = 0.001,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.3,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Value

A autoenc_lstm_ed object.

References

Hochreiter, S., & Schmidhuber, J. (1997). Long Short-Term Memory.

Examples

## Not run: 
X <- matrix(rnorm(1000), nrow = 50, ncol = 20)
ae <- autoenc_lstm_ed(
  input_size = 20,
  encoding_size = 5,
  lstm_hidden_size = 16,
  sequence_length = 4,
  num_layers = 2,
  dropout = 0.1
)
ae <- daltoolbox::fit(ae, X)
X_hat <- daltoolbox::transform(ae, X)

## End(Not run)

Stacked Autoencoder - Encode

Description

Creates a stacked autoencoder with stage-wise configurable latent sizes and dense sub-architectures through a Python/PyTorch backend.

Usage

autoenc_stacked_e(
  input_size,
  encoding_size,
  encoding_sizes = NULL,
  encoder_hidden_sizes = 64L,
  decoder_hidden_sizes = NULL,
  activation = c("relu", "leaky_relu", "elu", "gelu", "selu", "tanh"),
  output_activation = c("none", "relu", "sigmoid", "tanh", "softplus"),
  negative_slope = 0.2,
  batch_size = 32,
  epochs = 100L,
  num_epochs = NULL,
  learning_rate = 0.001,
  k = 3,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.3,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Details

The stacked autoencoder now supports progressively different latent widths across stages. Keep k = 3 and encoding_sizes = NULL to repeat the original bottleneck, or use encoding_sizes = c(16L, 8L, 4L) to progressively compress the representation. encoder_hidden_sizes and decoder_hidden_sizes may be either a single integer vector shared by all stages or an R list with one integer vector per stage.

Value

A autoenc_stacked_e object.

References

Vincent, P., Larochelle, H., Lajoie, I., Bengio, Y., & Manzagol, P.-A. (2010). Stacked Denoising Autoencoders: Learning Useful Representations in a Deep Network with a Local Denoising Criterion.

Examples

## Not run: 
X <- matrix(rnorm(1000), nrow = 50, ncol = 20)
ae <- autoenc_stacked_e(
  input_size = 20,
  encoding_size = 5,
  encoding_sizes = c(12L, 8L, 5L),
  encoder_hidden_sizes = list(c(64L), c(32L), c(16L))
)
ae <- daltoolbox::fit(ae, X)
Z <- daltoolbox::transform(ae, X)

## End(Not run)

Stacked Autoencoder - Encode-Decode

Description

Creates a stacked autoencoder that compresses through multiple stages and reconstructs back to the original input space through a Python/PyTorch backend.

Usage

autoenc_stacked_ed(
  input_size,
  encoding_size,
  encoding_sizes = NULL,
  encoder_hidden_sizes = 64L,
  decoder_hidden_sizes = NULL,
  activation = c("relu", "leaky_relu", "elu", "gelu", "selu", "tanh"),
  output_activation = c("none", "relu", "sigmoid", "tanh", "softplus"),
  negative_slope = 0.2,
  batch_size = 32,
  epochs = 100L,
  num_epochs = NULL,
  learning_rate = 0.001,
  k = 3,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.3,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Value

A autoenc_stacked_ed object.

References

Vincent, P. et al. (2010). Stacked Denoising Autoencoders.

Examples

## Not run: 
X <- matrix(rnorm(1000), nrow = 50, ncol = 20)
ae <- autoenc_stacked_ed(
  input_size = 20,
  encoding_size = 5,
  encoding_sizes = c(12L, 8L, 5L),
  encoder_hidden_sizes = list(c(64L), c(32L), c(16L))
)
ae <- daltoolbox::fit(ae, X)
X_hat <- daltoolbox::transform(ae, X)

## End(Not run)

Variational Autoencoder - Encode

Description

Creates a variational autoencoder (VAE) with configurable dense encoder/decoder blocks through a Python/PyTorch backend.

Usage

autoenc_variational_e(
  input_size,
  encoding_size,
  encoder_hidden_sizes = c(64L, 32L),
  decoder_hidden_sizes = NULL,
  activation = c("leaky_relu", "relu", "elu", "gelu", "tanh"),
  negative_slope = 0.2,
  output_activation = c("sigmoid", "none", "relu", "tanh", "softplus"),
  reconstruction_loss = c("bce", "mse"),
  batch_size = 32,
  epochs = 100L,
  num_epochs = NULL,
  learning_rate = 0.001,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.3,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Details

The VAE now exposes the hidden layout of both encoder and decoder, the activation family, the latent reconstruction head, and the reconstruction loss. This makes it possible to move from the original 64 -> 32 -> latent structure to deeper or shallower alternatives.

Value

A autoenc_variational_e object.

References

Kingma, D. P., & Welling, M. (2014). Auto-Encoding Variational Bayes.

Examples

## Not run: 
X <- matrix(rnorm(1000), nrow = 50, ncol = 20)
ae <- autoenc_variational_e(
  input_size = 20,
  encoding_size = 5,
  encoder_hidden_sizes = c(128L, 64L, 32L),
  reconstruction_loss = "mse"
)
ae <- daltoolbox::fit(ae, X)
Z <- daltoolbox::transform(ae, X)
dim(Z)

## End(Not run)

Variational Autoencoder - Encode-Decode

Description

Creates a variational autoencoder (VAE) that reconstructs observations from a probabilistic latent space through a Python/PyTorch backend.

Usage

autoenc_variational_ed(
  input_size,
  encoding_size,
  encoder_hidden_sizes = c(64L, 32L),
  decoder_hidden_sizes = NULL,
  activation = c("leaky_relu", "relu", "elu", "gelu", "tanh"),
  negative_slope = 0.2,
  output_activation = c("sigmoid", "none", "relu", "tanh", "softplus"),
  reconstruction_loss = c("bce", "mse"),
  batch_size = 32,
  epochs = 100L,
  num_epochs = NULL,
  learning_rate = 0.001,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.3,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Value

A autoenc_variational_ed object.

References

Kingma, D. P., & Welling, M. (2014). Auto-Encoding Variational Bayes.

Examples

## Not run: 
X <- matrix(rnorm(1000), nrow = 50, ncol = 20)
ae <- autoenc_variational_ed(
  input_size = 20,
  encoding_size = 5,
  encoder_hidden_sizes = c(128L, 64L, 32L),
  reconstruction_loss = "mse"
)
ae <- daltoolbox::fit(ae, X)
X_hat <- daltoolbox::transform(ae, X)

## End(Not run)

Gradient Boosting Classifier

Description

Implements a classifier using the Gradient Boosting algorithm. Wraps scikit-learn's GradientBoostingClassifier through reticulate.

Usage

skcla_gb(
  attribute,
  slevels,
  n_estimators = 100,
  learning_rate = 0.1,
  max_depth = 3,
  subsample = 1,
  min_samples_split = 2,
  min_samples_leaf = 1,
  loss = c("log_loss", "exponential")
)

Arguments

Details

Tree Boosting

Value

A skcla_gb classifier object.

References

Friedman, J. H. (2001). Greedy Function Approximation: A Gradient Boosting Machine.

Examples

## Not run: 
data(iris)
clf <- skcla_gb(
  attribute = "Species",
  slevels = levels(iris$Species),
  n_estimators = 150,
  learning_rate = 0.05
)
clf <- daltoolbox::fit(clf, iris)
pred <- predict(clf, iris)
table(pred, iris$Species)

## End(Not run)

K-Nearest Neighbors Classifier

Description

Implements classification using the k-Nearest Neighbors algorithm. Wraps scikit-learn's KNeighborsClassifier through reticulate.

Usage

skcla_knn(
  attribute,
  slevels,
  n_neighbors = 5,
  weights = c("uniform", "distance"),
  metric = c("euclidean", "manhattan", "chebyshev", "minkowski")
)

Arguments

Details

K-Nearest Neighbors Classifier

Value

A skcla_knn classifier object.

References

Cover, T., & Hart, P. (1967). Nearest neighbor pattern classification.

Examples

## Not run: 
data(iris)
clf <- skcla_knn(
  attribute = "Species",
  slevels = levels(iris$Species),
  n_neighbors = 7,
  weights = "distance"
)
clf <- daltoolbox::fit(clf, iris)
pred <- predict(clf, iris)
table(pred, iris$Species)

## End(Not run)

Multi-layer Perceptron Classifier

Description

Implements classification using a multi-layer perceptron (MLP). Wraps scikit-learn's MLPClassifier through reticulate.

Usage

skcla_mlp(
  attribute,
  slevels,
  hidden_layer_sizes = c(100),
  activation = c("relu", "identity", "logistic", "tanh"),
  solver = c("adam", "lbfgs", "sgd"),
  alpha = 1e-04,
  batch_size = "auto",
  learning_rate_init = 0.001,
  max_iter = 200,
  early_stopping = FALSE
)

Arguments

Details

Neural Network Classifier

Value

A skcla_mlp classifier object.

References

Bishop, C. M. (1995). Neural Networks for Pattern Recognition.

Examples

## Not run: 
data(iris)
clf <- skcla_mlp(
  attribute = "Species",
  slevels = levels(iris$Species),
  hidden_layer_sizes = c(32, 16),
  activation = "relu"
)
clf <- daltoolbox::fit(clf, iris)
pred <- predict(clf, iris)
table(pred, iris$Species)

## End(Not run)

Gaussian Naive Bayes Classifier

Description

Implements classification using Gaussian Naive Bayes. Wraps scikit-learn's GaussianNB through reticulate.

Usage

skcla_nb(attribute, slevels, var_smoothing = 1e-09)

Arguments

Details

Naive Bayes Classifier

Value

A skcla_nb classifier object.

References

Murphy, K. P. (2012). Machine Learning: A Probabilistic Perspective. (Gaussian Naive Bayes)

Examples

## Not run: 
data(iris)

# Gaussian Naive Bayes for multi-class iris
clf <- skcla_nb(attribute = 'Species', slevels = levels(iris$Species))
clf <- daltoolbox::fit(clf, iris)
pred <- predict(clf, iris)
table(pred, iris$Species)

## End(Not run)

# More examples:
# https://github.com/cefet-rj-dal/daltoolboxdp/blob/main/examples/skcla_nb.md

Random Forest Classifier

Description

Implements classification using the Random Forest algorithm. Wraps scikit-learn's RandomForestClassifier through reticulate.

Usage

skcla_rf(
  attribute,
  slevels,
  n_estimators = 100,
  max_depth = NULL,
  min_samples_split = 2,
  min_samples_leaf = 1,
  max_features = "sqrt",
  class_weight = NULL
)

Arguments

Details

Tree Ensemble

Value

A skcla_rf classifier object.

References

Breiman, L. (2001). Random Forests. Machine Learning.

Examples

## Not run: 
data(iris)
clf <- skcla_rf(
  attribute = "Species",
  slevels = levels(iris$Species),
  n_estimators = 200,
  max_features = "sqrt"
)
clf <- daltoolbox::fit(clf, iris)
pred <- predict(clf, iris)
table(pred, iris$Species)

## End(Not run)

Support Vector Machine Classification

Description

Implements classification using support vector machines. Wraps scikit-learn's SVC through reticulate.

Usage

skcla_svc(
  attribute,
  slevels,
  C = 1,
  kernel = c("rbf", "linear", "poly", "sigmoid"),
  gamma = "scale",
  degree = 3,
  coef0 = 0,
  probability = FALSE,
  class_weight = NULL
)

Arguments

Details

SVM Classifier

Value

A skcla_svc classifier object.

References

Cortes, C., & Vapnik, V. (1995). Support-Vector Networks.

Examples

## Not run: 
data(iris)
clf <- skcla_svc(
  attribute = "Species",
  slevels = levels(iris$Species),
  kernel = "rbf",
  C = 1
)
clf <- daltoolbox::fit(clf, iris)
pred <- predict(clf, iris)
table(pred, iris$Species)

## End(Not run)

PyTorch MLP Classifier

Description

Classification model backed by a configurable PyTorch MLP with unified training strategies.

Usage

torch_cla_mlp(
  attribute,
  slevels,
  preprocess = NA,
  input_size,
  hidden_sizes,
  num_classes = length(slevels),
  dropout = 0,
  activation = c("relu", "leaky_relu", "elu", "gelu", "tanh"),
  normalization = c("none", "batch", "layer"),
  init_method = c("default", "xavier_uniform", "xavier_normal", "kaiming_uniform",
    "kaiming_normal"),
  epochs = 100L,
  lr = 0.001,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.2,
  batch_size = 64L,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05,
  weight_decay = 0
)

Arguments

Examples

## Not run: 
library(daltoolboxdp)
model <- torch_cla_mlp(
  attribute = "class",
  slevels = c("A", "B"),
  input_size = 10,
  hidden_sizes = c(64L, 32L),
  normalization = "batch",
  init_method = "kaiming_uniform",
  epochs = 1000L
)

## End(Not run)

PyTorch MLP Regressor

Description

Regression model backed by a configurable PyTorch MLP with unified training strategies.

Usage

torch_reg_mlp(
  attribute,
  preprocess = NA,
  input_size,
  hidden_sizes,
  dropout = 0,
  activation = c("relu", "leaky_relu", "elu", "gelu", "tanh"),
  output_activation = c("none", "relu", "sigmoid", "tanh", "softplus"),
  normalization = c("none", "batch", "layer"),
  init_method = c("default", "xavier_uniform", "xavier_normal", "kaiming_uniform",
    "kaiming_normal"),
  epochs = 100L,
  lr = 0.001,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.2,
  batch_size = 64L,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Examples

## Not run: 
library(daltoolboxdp)
model <- torch_reg_mlp(
  attribute = "target",
  input_size = 10,
  hidden_sizes = c(64L, 32L),
  normalization = "layer",
  output_activation = "none",
  epochs = 1000L
)

## End(Not run)

PyTorch Time-Series MLP

Description

Time-series forecaster using a configurable feedforward PyTorch MLP with unified training strategies and a Python backend.

Usage

torch_ts_mlp(
  preprocess = NA,
  input_size = NA,
  hidden_sizes = c(16L, 8L),
  dropout = 0,
  activation = c("relu", "leaky_relu", "elu", "gelu", "tanh"),
  output_activation = c("none", "relu", "sigmoid", "tanh", "softplus"),
  normalization = c("none", "batch", "layer"),
  init_method = c("default", "xavier_uniform", "xavier_normal", "kaiming_uniform",
    "kaiming_normal"),
  epochs = 100L,
  lr = 0.001,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.2,
  batch_size = 32L,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Value

A torch_ts_mlp object.

Examples

## Not run: 
library(daltoolboxdp)
model <- torch_ts_mlp(
  input_size = 12,
  hidden_sizes = c(32L, 16L),
  normalization = "batch",
  init_method = "kaiming_uniform",
  epochs = 100L
)

## End(Not run)

Conv1D

Description

Time-series forecaster using a configurable 1D convolutional neural network with unified training strategies and a Python/PyTorch backend.

Usage

ts_conv1d(
  preprocess = NA,
  input_size = NA,
  in_channels = 1L,
  sequence_length = NULL,
  conv_channels = 64L,
  kernel_sizes = NULL,
  strides = 1L,
  pooling = c("none", "max", "avg"),
  pool_kernel_size = 2L,
  dense_hidden_sizes = 50L,
  activation = c("relu", "leaky_relu", "elu", "gelu", "tanh"),
  epochs = 100L,
  lr = 0.001,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.2,
  batch_size = 8L,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Details

The Conv1D forecaster now supports multiple convolutional blocks, explicit channel/sequence reshaping, optional pooling, and a configurable dense prediction head. Keep the defaults to preserve the original single-channel behavior, or define architectures such as conv_channels = c(32L, 64L) and dense_hidden_sizes = c(64L, 16L).

Value

A ts_conv1d object.

Examples

## Not run: 
library(daltoolboxdp)
model <- ts_conv1d(
  input_size = 12,
  in_channels = 1L,
  conv_channels = c(32L, 64L),
  dense_hidden_sizes = c(64L, 16L),
  epochs = 100L
)

## End(Not run)

LSTM

Description

Time-series forecaster using a configurable LSTM neural network with unified training strategies and a Python/PyTorch backend.

Usage

ts_lstm(
  preprocess = NA,
  input_size = NA,
  hidden_size = NULL,
  sequence_length = 1L,
  num_layers = 1L,
  dropout = 0,
  bidirectional = FALSE,
  mlp_hidden_sizes = integer(0),
  activation = c("relu", "leaky_relu", "elu", "gelu", "tanh"),
  epochs = 100L,
  lr = 0.001,
  validation_strategy = c("static", "dynamic"),
  stopping_rule = c("none", "patience", "sma", "ema", "h"),
  val_ratio = 0.2,
  batch_size = 8L,
  patience = 100L,
  min_delta = 1e-04,
  sma_window = 5L,
  ema_alpha = 0.2,
  test_window = 30L,
  p_value = 0.05
)

Arguments

Details

The LSTM forecaster now supports multiple recurrent layers, dropout, bidirectionality, an optional dense head after the recurrent block, and explicit reshaping of each row into a sequence via sequence_length. Keeping sequence_length = 1L reproduces the previous behavior.

Value

A ts_lstm object.

Examples

## Not run: 
library(daltoolboxdp)
model <- ts_lstm(
  input_size = 12,
  hidden_size = 16L,
  sequence_length = 3L,
  num_layers = 2L,
  dropout = 0.1,
  mlp_hidden_sizes = c(16L, 8L),
  epochs = 100L
)

## End(Not run)