Synthetic Ocean AI - Data Generation

Synthetic Ocean AI (SynDataGen)

An advanced Python framework for generating and evaluating synthetic tabular datasets using modern generative models, including diffusion and adversarial architectures. Designed for researchers and practitioners, it provides reproducible pipelines, fine-grained control over model configuration, and integrated evaluation metrics for realistic data synthesis.

🧠 Architectures Supported

Model	Description	Use Case
CGAN	Conditional GANs conditioned on labels or attributes	Class balancing, controlled generation
WGAN-GP	Wasserstein GAN with gradient penalty for stable training	Imbalanced datasets, complex distributions
Autoencoder	Latent-space learning through compression-reconstruction	Feature extraction, denoising
VAE	Probabilistic Autoencoder with latent sampling	Probabilistic generation and imputation
Denoising Diffusion	Progressive noise-based generative model	Robust generation with high-quality samples
VQ-VAE	Discrete latent-space via quantization	Categorical and mixed-type data
Copy/Paste	Simple sample replication baseline	Sanity checks, baseline comparison
Kernel Diffusion	Experimental kernelized diffusion process (WIP)	Future work

Architecture Overview

The Synthetic Ocean AI library provides several generative architectures:

Architecture	Key Characteristics	Typical Use Cases
Denoising Probabilistic Diffusion	Iterative denoising process, high-quality outputs	High-fidelity data generation
Conditional GAN (CGAN)	Label-guided generation	Conditional data augmentation
Wasserstein GAN-GP	Stable training with gradient penalty	Robust generation tasks
Conditional Autoencoder	Deterministic reconstruction	Data compression, denoising
Variational Autoencoder	Probabilistic latent space	Diverse sample generation

Example Workflows

Denoising Probabilistic Diffusion

import numpy
import tensorflow
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.utils import to_categorical
from SynDataGen.Engine.Models.Diffusion.DiffusionModelUnet import UNetModel
from SynDataGen.Engine.Algorithms.Diffusion.AlgorithmDiffusion import DiffusionModel
from SynDataGen.Engine.Algorithms.Diffusion.GaussianDiffusion import GaussianDiffusion
from SynDataGen.Engine.Models.Diffusion.VariationalAutoencoderModel import VariationalModelDiffusion
from SynDataGen.Engine.Algorithms.Diffusion.AlgorithmVariationalAutoencoderDiffusion import VariationalAlgorithmDiffusion

number_samples_per_class = {
    "classes": {1: 100, 2: 200, 3: 150},
    "number_classes": 3
}
input_shape = (1200, )

# Initialize UNet models
first_instance_unet = UNetModel(
    embedding_dimension=128,
    embedding_channels=1,
    list_neurons_per_level=[1, 2, 4],
    list_attentions=[False,True, True],
    number_residual_blocks=2,
    normalization_groups=1,
    intermediary_activation_function='swish',
    intermediary_activation_alpha=0.05,
    last_layer_activation='linear',
    number_samples_per_class=number_samples_per_class
)

second_instance_unet = UNetModel(
    embedding_dimension=128,
    embedding_channels=1,
    list_neurons_per_level=[1, 2, 4],
    list_attentions=[False, False, True, True],
    number_residual_blocks=2,
    normalization_groups=1,
    intermediary_activation_function='swish',
    intermediary_activation_alpha=0.05,
    last_layer_activation='linear',
    number_samples_per_class=number_samples_per_class
)

# Initialize Gaussian Diffusion
gaussian_diffusion_util = GaussianDiffusion(
    beta_start=1e-4,
    beta_end=0.02,
    time_steps=1000,
    clip_min=-1.0,
    clip_max=1.0
)

# Initialize Variational Autoencoder
variation_model_diffusion = VariationalModelDiffusion(
    latent_dimension=128,
    output_shape=input_shape,
    activation_function='swish',
    initializer_mean=0.0,
    initializer_deviation=0.02,
    dropout_decay_encoder=0.2,
    dropout_decay_decoder=0.4,
    last_layer_activation='sigmoid',
    number_neurons_encoder=[128, 64],
    number_neurons_decoder=[64, 128],
    dataset_type=numpy.float32,
    number_samples_per_class=number_samples_per_class
)

# Initialize Diffusion Algorithm
diffusion_algorithm = DiffusionModel(
    first_unet_model=first_instance_unet.build_model(),
    second_unet_model=second_instance_unet.build_model(),
    encoder_model_image=variation_model_diffusion.get_encoder(),
    decoder_model_image=variation_model_diffusion.get_decoder(),
    gdf_util=gaussian_diffusion_util,
    optimizer_autoencoder=Adam(learning_rate=0.0002),
    optimizer_diffusion=Adam(learning_rate=0.0002),
    time_steps=1000,
    ema=0.9999,
    margin=0.001,
    embedding_dimension=128
)

# Train and generate samples
diffusion_algorithm.compile(loss='mse', optimizer=Adam(learning_rate=0.002))
data_embedding = variation_model_diffusion.create_embedding([x_real_samples, to_categorical(y_real_samples)])
diffusion_algorithm.fit(data_embedding, epochs=1000, batch_size=32)
samples = diffusion_algorithm.get_samples(number_samples_per_class)

Diffusion Model Parameters

Parameter	Description
--diffusion_unet_last_layer_activation	Activation for last layer of U-Net
--diffusion_latent_dimension	Dimension of latent space
--diffusion_unet_num_embedding_channels	Number of embedding channels
--diffusion_unet_channels_per_level	Channels per level in U-Net
--diffusion_unet_batch_size	Batch size for U-Net training
--diffusion_unet_attention_mode	Attention mode for U-Net
--diffusion_unet_num_residual_blocks	Number of residual blocks
--diffusion_unet_group_normalization	Group normalization value
--diffusion_unet_intermediary_activation	Intermediary activation
--diffusion_unet_intermediary_activation_alpha	Alpha for activation
--diffusion_unet_epochs	Training epochs
--diffusion_gaussian_beta_start	Starting beta value
--diffusion_gaussian_beta_end	Ending beta value
--diffusion_gaussian_time_steps	Number of time steps
--diffusion_gaussian_clip_min	Minimum clipping value
--diffusion_gaussian_clip_max	Maximum clipping value

Conditional GAN (CGAN)

import numpy
import tensorflow
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.utils import to_categorical
from SynDataGen.Engine.Models.Adversarial.AdversarialModel import AdversarialModel
from SynDataGen.Engine.Algorithms.Adversarial.AdversarialAlgorithm import AdversarialAlgorithm

number_samples_per_class = {
    "classes": {1: 100, 2: 200, 3: 150},
    "number_classes": 3
}
input_shape = (1200, )

# Initialize Adversarial Model
adversarial_model = AdversarialModel(
    latent_dimension=128,
    output_shape=input_shape,
    activation_function="LeakyReLU",
    initializer_mean=0.0,
    initializer_deviation=0.5,
    dropout_decay_rate_g=0.2,
    dropout_decay_rate_d=0.4,
    last_layer_activation="Sigmoid",
    dense_layer_sizes_g=[128],
    dense_layer_sizes_d=[128],
    dataset_type=numpy.float32,
    number_samples_per_class=number_samples_per_class
)

# Initialize Adversarial Algorithm
adversarial_algorithm = AdversarialAlgorithm(
    generator_model=adversarial_model.get_generator(),
    discriminator_model=adversarial_model.get_discriminator(),
    latent_dimension=128,
    loss_generator='binary_crossentropy',
    loss_discriminator='binary_crossentropy',
    file_name_discriminator="discriminator_model",
    file_name_generator="generator_model",
    models_saved_path="models_saved/",
    latent_mean_distribution=0.0,
    latent_stander_deviation=1.0,
    smoothing_rate=0.15
)

# Train and generate samples
adversarial_algorithm.compile(
    Adam(learning_rate=0.0002, beta_1=0.5),
    Adam(learning_rate=0.0002, beta_1=0.5),
    'binary_crossentropy',
    'binary_crossentropy'
)
adversarial_algorithm.fit(
    x_real_samples,
    to_categorical(y_real_samples, num_classes=number_samples_per_class["number_classes"]),
    epochs=1000,
    batch_size=32
)
samples = adversarial_algorithm.get_samples(number_samples_per_class)

CGAN Parameters

Parameter	Description
--adversarial_number_epochs	Number of training epochs
--adversarial_batch_size	Training batch size
--adversarial_initializer_mean	Mean for weight initialization
--adversarial_initializer_deviation	Std dev for weight initialization
--adversarial_latent_dimension	Latent space dimension
--adversarial_training_algorithm	Training algorithm
--adversarial_activation_function	Activation function
--adversarial_dropout_decay_rate_g	Generator dropout rate
--adversarial_dropout_decay_rate_d	Discriminator dropout rate
--adversarial_dense_layer_sizes_g	Generator layer sizes
--adversarial_dense_layer_sizes_d	Discriminator layer sizes
--adversarial_latent_mean_distribution	Latent space mean
--adversarial_latent_stander_deviation	Latent space std dev
--adversarial_loss_generator	Generator loss function
--adversarial_loss_discriminator	Discriminator loss function
--adversarial_smoothing_rate	Label smoothing rate

Wasserstein GAN-GP

import numpy
import tensorflow
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.utils import to_categorical
from SynDataGen.Engine.Models.Wasserstein.ModelWassersteinGAN import WassersteinModel
from SynDataGen.Engine.Algorithms.Wasserstein.AlgorithmWassersteinGan import WassersteinAlgorithm

number_samples_per_class = {
    "classes": {1: 100, 2: 200, 3: 150},
    "number_classes": 3
}
input_shape = (1200, )

# Initialize Wasserstein Model
wasserstein_model = WassersteinModel(
    latent_dimension=128,
    output_shape=input_shape,
    activation_function="LeakyReLU",
    initializer_mean=0.0,
    initializer_deviation=0.02,
    dropout_decay_rate_g=0.2,
    dropout_decay_rate_d=0.4,
    last_layer_activation="sigmoid",
    dense_layer_sizes_g=[128],
    dense_layer_sizes_d=[128],
    dataset_type=numpy.float32,
    number_samples_per_class=number_samples_per_class
)

# Initialize Wasserstein Algorithm
wasserstein_algorithm = WassersteinAlgorithm(
    generator_model=wasserstein_model.get_generator(),
    discriminator_model=wasserstein_model.get_discriminator(),
    latent_dimension=128,
    generator_loss_fn="binary_crossentropy",
    discriminator_loss_fn="binary_crossentropy",
    file_name_discriminator="discriminator_model",
    file_name_generator="generator_model",
    models_saved_path="models_saved/",
    latent_mean_distribution=0.0,
    latent_stander_deviation=1.0,
    smoothing_rate=0.15,
    gradient_penalty_weight=10.0,
    discriminator_steps=3
)

# Train and generate samples
wasserstein_algorithm.compile(
    Adam(learning_rate=0.0002, beta_1=0.5),
    Adam(learning_rate=0.0002, beta_1=0.5),
    generator_loss,
    discriminator_loss
)
wasserstein_algorithm.fit(
    x_real_samples,
    to_categorical(y_real_samples, num_classes=number_samples_per_class["number_classes"]),
    epochs=1000,
    batch_size=32
)
samples = wasserstein_algorithm.get_samples(number_samples_per_class)

WGAN-GP Parameters

Parameter	Description
--wasserstein_latent_dimension	Latent space dimension
--wasserstein_training_algorithm	Training algorithm
--wasserstein_activation_function	Activation function
--wasserstein_dropout_decay_rate_g	Generator dropout rate
--wasserstein_dropout_decay_rate_d	Discriminator dropout rate
--wasserstein_dense_layer_sizes_generator	Generator layer sizes
--wasserstein_dense_layer_sizes_discriminator	Discriminator layer sizes
--wasserstein_batch_size	Training batch size
--wasserstein_number_epochs	Number of training epochs
--wasserstein_number_classes	Number of classes
--wasserstein_loss_function	Loss function
--wasserstein_momentum	Optimizer momentum
--wasserstein_last_activation_layer	Last layer activation
--wasserstein_initializer_mean	Weight initialization mean
--wasserstein_initializer_deviation	Weight initialization std dev
--wasserstein_gradient_penalty	Gradient penalty weight

Conditional Autoencoder (CAE)

import numpy
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.utils import to_categorical
from SynDataGen.Engine.Models.Autoencoder.ModelAutoencoder import AutoencoderModel
from SynDataGen.Engine.Algorithms.Autoencoder.AutoencoderAlgorithm import AutoencoderAlgorithm

number_samples_per_class = {
    "classes": {1: 100, 2: 200, 3: 150},
    "number_classes": 3
}
input_shape = (1200, )

# Initialize Autoencoder Model
autoencoder_model = AutoencoderModel(
    latent_dimension=64,
    output_shape=input_shape,
    activation_function="LeakyReLU",
    initializer_mean=0.0,
    initializer_deviation=0.50,
    dropout_decay_encoder=0.2,
    dropout_decay_decoder=0.2,
    last_layer_activation="sigmoid",
    number_neurons_encoder=[256, 128],
    number_neurons_decoder=[128, 256],
    dataset_type=numpy.float32,
    number_samples_per_class=2
)

# Initialize Autoencoder Algorithm
autoencoder_algorithm = AutoencoderAlgorithm(
    encoder_model=autoencoder_model.get_encoder(input_shape),
    decoder_model=autoencoder_model.get_decoder(input_shape),
    loss_function="binary_crossentropy",
    file_name_encoder="encoder_model",
    file_name_decoder="decoder_model",
    models_saved_path="models_saved/",
    latent_mean_distribution=0.5,
    latent_stander_deviation=0.5,
    latent_dimension=64
)

# Train and generate samples
autoencoder_algorithm.compile(loss='mse')
autoencoder_algorithm.fit(
    (x_real_samples, to_categorical(y_real_samples, num_classes=number_samples_per_class["number_classes"])),
    x_real_samples,
    epochs=1000,
    batch_size=32
)
samples = autoencoder_algorithm.get_samples(number_samples_per_class)

CAE Parameters

Parameter	Description
--autoencoder_latent_dimension	Latent space dimension
--autoencoder_training_algorithm	Training algorithm
--autoencoder_activation_function	Activation function
--autoencoder_dropout_decay_rate_encoder	Encoder dropout rate
--autoencoder_dropout_decay_rate_decoder	Decoder dropout rate
--autoencoder_dense_layer_sizes_encoder	Encoder layer sizes
--autoencoder_dense_layer_sizes_decoder	Decoder layer sizes
--autoencoder_batch_size	Training batch size
--autoencoder_number_classes	Number of classes
--autoencoder_number_epochs	Number of training epochs
--autoencoder_loss_function	Loss function
--autoencoder_momentum	Optimizer momentum
--autoencoder_last_activation_layer	Last layer activation
--autoencoder_initializer_mean	Weight initialization mean
--autoencoder_initializer_deviation	Weight initialization std dev

Variational Autoencoder (VAE)

import numpy
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.utils import to_categorical
from SynDataGen.Engine.Models.VariationalAutoencoder.VariationalAutoencoderModel import VariationalModel
from SynDataGen.Engine.Algorithms.VariationalAutoencoder.AlgorithmVariationalAutoencoder import VariationalAlgorithm

number_samples_per_class = {
    "classes": {1: 100, 2: 200, 3: 150},
    "number_classes": 3
}
input_shape = (1200, )

# Initialize Variational Model
variation_model = VariationalModel(
    latent_dimension=128,
    output_shape=input_shape,
    activation_function="LeakyReLU",
    initializer_mean=0.0,
    initializer_deviation=0.02,
    dropout_decay_encoder=0.2,
    dropout_decay_decoder=0.4,
    last_layer_activation="sigmoid",
    number_neurons_encoder=[128],
    number_neurons_decoder=[128],
    dataset_type=numpy.float32,
    number_samples_per_class=2
)

# Initialize Variational Algorithm
variational_algorithm = VariationalAlgorithm(
    encoder_model=variation_model.get_encoder(),
    decoder_model=variation_model.get_decoder(),
    loss_function="binary_crossentropy",
    latent_dimension=64,
    decoder_latent_dimension=128,
    latent_mean_distribution=0.0,
    latent_stander_deviation=0.5,
    file_name_encoder="encoder_model",
    file_name_decoder="decoder_model",
    models_saved_path="models_saved/"
)

# Train and generate samples
variational_algorithm.compile()
variational_algorithm.fit(
    (x_real_samples, to_categorical(y_real_samples, num_classes=number_samples_per_class["number_classes"])),
    epochs=1000,
    batch_size=32
)
samples = variational_algorithm.get_samples(number_samples_per_class)

VAE Parameters

Parameter	Description
--variational_autoencoder_latent_dimension	Latent space dimension
--variational_autoencoder_training_algorithm	Training algorithm
--variational_autoencoder_activation_function	Activation function
--variational_autoencoder_dropout_decay_rate_encoder	Encoder dropout rate
--variational_autoencoder_dropout_decay_rate_decoder	Decoder dropout rate
--variational_autoencoder_dense_layer_sizes_encoder	Encoder layer sizes
--variational_autoencoder_dense_layer_sizes_decoder	Decoder layer sizes
--variational_autoencoder_number_epochs	Number of training epochs
--variational_autoencoder_batch_size	Training batch size
--variational_autoencoder_number_classes	Number of classes
--variational_autoencoder_loss_function	Loss function
--variational_autoencoder_momentum	Optimizer momentum
--variational_autoencoder_last_activation_layer	Last layer activation
--variational_autoencoder_initializer_mean	Weight initialization mean
--variational_autoencoder_initializer_deviation	Weight initialization std dev
--variational_autoencoder_mean_distribution	Latent space mean
--variational_autoencoder_stander_deviation	Latent space std dev

Common Parameters

Data Loading Parameters

Parameter	Description
-i, --data_load_path_file_input	Path to input CSV file
--data_load_label_column	Index of label column
--data_load_max_samples	Maximum samples to load
--data_load_max_columns	Maximum columns to consider
--data_load_start_column	First column index
--data_load_end_column	Last column index
--data_load_path_file_output	Output CSV path
--data_load_exclude_columns	Columns to exclude

Classifier Parameters

Support Vector Machine

Parameter	Description
--support_vector_machine_regularization	Regularization parameter
--support_vector_machine_kernel	Kernel type
--support_vector_machine_kernel_degree	Polynomial kernel degree
--support_vector_machine_gamma	Kernel coefficient

Stochastic Gradient Descent

Parameter	Description
--stochastic_gradient_descent_loss	Loss function
--stochastic_gradient_descent_penalty	Regularization penalty
--stochastic_gradient_descent_alpha	Regularization term
--stochastic_gradient_descent_max_iterations	Maximum iterations
--stochastic_gradient_descent_tolerance	Stopping criteria tolerance

Random Forest

Parameter	Description
--random_forest_number_estimators	Number of trees
--random_forest_max_depth	Maximum tree depth
--random_forest_max_leaf_nodes	Maximum leaf nodes

Quadratic Discriminant Analysis

Parameter	Description
--quadratic_discriminant_analysis_priors	Class probabilities
--quadratic_discriminant_analysis_regularization	Regularization parameter
--quadratic_discriminant_analysis_threshold	Threshold value

Multilayer Perceptron

Parameter	Description
--perceptron_training_algorithm	Training algorithm
--perceptron_training_loss	Loss function
--perceptron_layers_settings	Layer configurations
--perceptron_dropout_decay_rate	Dropout rate
--perceptron_training_metric	Evaluation metrics
--perceptron_layer_activation	Layer activation
--perceptron_last_layer_activation	Output activation
--perceptron_number_epochs	Training epochs

Spectral Clustering

Parameter	Description
--spectral_number_clusters	Number of clusters
--spectral_eigen_solver	Eigenvalue decomposition method
--spectral_affinity	Affinity matrix construction
--spectral_assign_labels	Label assignment strategy
--spectral_random_state	Random seed

Linear Regression

Parameter	Description
--linear_regression_fit_intercept	Whether to calculate intercept
--linear_regression_normalize	Normalize features
--linear_regression_copy_X	Copy input data
--linear_regression_number_jobs	Number of parallel jobs

Naive Bayes

Parameter	Description
--naive_bayes_priors	Class probabilities
--naive_bayes_variation_smoothing	Smoothing parameter

K-Nearest Neighbors

Parameter	Description
--knn_number_neighbors	Number of neighbors
--knn_weights	Weight function
--knn_algorithm	Algorithm used
--knn_leaf_size	Leaf size for tree algorithms
--knn_metric	Distance metric

K-Means

Parameter	Description
--k_means_number_clusters	Number of clusters
--k_means_init	Initialization method
--k_means_max_iterations	Maximum iterations
--k_means_tolerance	Convergence tolerance
--k_means_random_state	Random seed

Gradient Boosting

Parameter	Description
--gradient_boosting_loss	Loss function
--gradient_boosting_learning_rate	Learning rate
--gradient_boosting_number_estimators	Number of estimators
--gradient_boosting_subsample	Subsample ratio
--gradient_boosting_criterion	Split quality measure

Gaussian Process

Parameter	Description
--gaussian_process_kernel	Kernel function
--gaussian_process_max_iterations	Maximum iterations
--gaussian_process_optimizer	Optimizer method

Decision Tree

Parameter	Description
--decision_tree_criterion	Split quality measure
--decision_tree_max_depth	Maximum tree depth
--decision_tree_max_features	Features to consider
--decision_tree_max_leaf_nodes	Maximum leaf nodes