Skip to main content
Learn how to create and deploy a custom Encoder-Combiner-Decoder (ECD) model on Simplismart. This guide covers the complete workflow from initiating a training job to deploying your trained model.
ECD models are particularly effective for tabular data and feature engineering tasks, using the TabNet architecture for superior performance on structured datasets.

​
Prerequisites

Before starting, ensure you have:
  • A Simplismart account with access to the Training Suite
  • A publicly accessible dataset URL
  • Your training configuration prepared (see configuration schema below)

​
Creating a Training Job

1

Initiate Training Job

  1. Navigate to My Trainings from the left sidebar
  2. Click Add a Training Job
  3. Select ECD as the model type from the available options Add training job interface
2

Configure Training Parameters

Provide the following details:
  1. Experiment Name: Enter a descriptive name for your training experiment
  2. Dataset URL: Provide the publicly accessible URL to your dataset
  3. Training Configuration: Add your ECD model configuration
See the ECD Model Configuration Schema section below for detailed configuration options and examples.
  1. Review all settings and click Create Job to start training Create training job with configuration
3

Monitor Training Progress

Once submitted, your training job will begin processing. You can:
  • Monitor training progress in real-time
  • View training metrics and logs
  • Track loss curves and validation performance
When training completes successfully, you’ll see a Compile button.Training complete screen

​
Compiling Your Trained Model

After training completes, compile your model to prepare it for deployment.
1

Navigate to Model Compilation

  1. Click the Compile button on your completed training job
  2. You’ll be redirected to the model compilation page
  3. The page shows your model ready to be added to My Models Model compilation interface
2

Configure Model Details

Provide the following information:
  1. Model Name: Enter a descriptive name for your compiled model
  2. Infrastructure: Choose your deployment infrastructure:
    • Simplismart Cloud: Deploy on Simplismart’s managed infrastructure
    • Your Own Cloud: Use your own infrastructure (BYOC guide)
Most configuration options will be auto-populated based on your model class. Review them before proceeding.
  1. Click Deploy Model to proceed to deployment configuration Model deployment configuration

​
Deploying Your ECD Model

Once your model is compiled, create a deployment to make it accessible via API.
1

Configure Basic Deployment Settings

Set up your deployment with these parameters:

​
Basic Details

  • Deployment Name: Choose a unique, descriptive name
  • Model: Auto-populated with your compiled model
  • Cloud: Select your infrastructure (Simplismart Cloud or your own)
  • Accelerator Type: Choose the GPU type for inference
2

Set Up Auto-Scaling

Configure auto-scaling to handle variable workloads:

​
Scaling Range

  • Minimum: 1 instance
  • Maximum: Up to 8 instances (adjust based on your needs)

​
Scaling Metrics

Add metrics that trigger scaling actions:
  1. GPU Utilization: Set threshold at 80% to scale up
  2. CPU Utilization: Set threshold at 80% for additional scaling control
Click Add Metrics to include additional scaling triggers.
Set appropriate thresholds to balance performance and cost. Too low may cause unnecessary scaling; too high may impact response times.
3

Add Deployment Tags

Organize your deployments with tags (optional but recommended):Example tags:
  • Key: env, Value: staging
  • Key: model-type, Value: ecd
  • Key: version, Value: v1.0
Tags help filter and manage deployments in production environments.Deployment configuration screen
4

Deploy and Verify

  1. Review all configuration settings
  2. Click Add Deployment to start the deployment process
  3. Monitor the deployment status on the right side of the screen
The deployment typically takes 1-2 minutes to complete.Successfully deployed model
When the status shows Deployed, your model is ready to serve inference requests!
5

Access Your Model Endpoint

Once deployed, you can find your model endpoint:
  1. Navigate to Deployments in the left sidebar
  2. Click on your deployment name
  3. In the Details tab, find the Model Endpoint URL
  4. Copy this endpoint to use in your applications
The endpoint is OpenAI-compatible and can be used with standard HTTP clients.

​
ECD Model Configuration Schema

Understanding the ECD model configuration is crucial for training effective models. This section breaks down each component of the configuration.

​
Configuration Overview

The ECD model configuration consists of several key components: 
model_type: ecd
input_features: []
output_features: []
combiner: {}
preprocessing: {}
trainer: {}

​
Input Features

Input features define how your dataset columns are processed. Each feature is a dictionary with three fields:
  • name: Field name used during model inference
  • type: Feature type - supports the following types:
    • binary - Binary features (0/1, True/False)
    • number - Numerical/continuous features
    • category - Categorical features
    • bag - Bag-of-words features
    • set - Set features (unordered collections)
    • sequence - Sequence features (ordered lists)
    • text - Text features (natural language)
    • vector - Vector features (dense embeddings)
  • column: Column name in your dataset
"input_features": [
  {
    "name": "device_name",
    "type": "category",
    "column": "device_name"
  },
  {
    "name": "hour_sin",
    "type": "numerical",
    "column": "hour_sin"
  }
]

​
Output Features

Output features define your model’s prediction targets. You can specify multiple outputs with custom loss functions. Supported Output Feature Types:
  • binary - Binary classification (0/1, True/False)
  • number - Regression/numerical predictions
  • category - Multi-class classification
  • bag - Bag-of-words predictions
  • set - Set predictions (unordered collections)
  • sequence - Sequence predictions (ordered lists)
  • text - Text generation
  • vector - Vector predictions (dense embeddings)

​
Example Configuration

"output_features": [
  {
    "loss": {
      "type": "binary_weighted_cross_entropy",
      "weight": 1,
      "class_weights": {
        "0": 0.66,
        "1": 2
      }
    },
    "name": "target",
    "type": "binary",
    "column": "target"
  }
]

​
Loss Configuration

For classification tasks, configure the loss function: 
"loss": {
  "type": "softmax_cross_entropy",  // or "binary_weighted_cross_entropy"
  "class_weights": null,              // or {"0": 0.75, "1": 0.25}
  "weight": 1.0
}
Parameters:
  • class_weights (default: null): Weights for each class. Use null for equal weighting
  • weight (default: 1.0): Overall loss weight for multi-task learning

​
Combiner Configuration

The combiner merges features before making predictions. ECD uses the TabNet architecture.

​
Example Configuration

"combiner": {
  "type": "tabnet",
  "size": 64,
  "output_size": 64,
  "num_steps": 4,
  "num_total_blocks": 4,
  "num_shared_blocks": 2,
  "relaxation_factor": 1.3,
  "bn_epsilon": 0.001,
  "bn_momentum": 0.98,
  "bn_virtual_bs": 128,
  "sparsity": 0.001,
  "dropout": 0
}

​
TabNet Combiner Parameters

  • size (default: 32): Hidden layer size (N_a in TabNet paper)
  • output_size (default: 128): Fully connected layer output size (N_d in TabNet paper)
  • num_steps (default: 3): Number of attention steps (N_steps in TabNet paper)
  • num_total_blocks (default: 4): Total feature transformer blocks per step
  • num_shared_blocks (default: 2): Shared feature transformer blocks across steps
  • dropout (default: 0.05): Dropout rate for transformer blocks
  • sparsity (default: 0.0001): Sparsity loss multiplier (lambda_sparse in TabNet paper)
  • relaxation_factor (default: 1.5): Feature reuse factor (gamma in TabNet paper)
    • Value of 1.0 means each feature used once
    • Higher values allow multiple feature usages
  • bn_epsilon (default: 0.001): Epsilon added to batch norm denominator
  • bn_momentum (default: 0.05): Batch norm momentum (1 - m_B from TabNet paper)
  • bn_virtual_bs (default: 128): Virtual batch size for batch normalization

​
Trainer Configuration

Configure the training process with optimization and validation settings.
  • optimizer: {"type": "adam"} - Adam optimizer for gradient descent
  • learning_rate (default: 0.001): Initial learning rate
  • learning_rate_scaling (default: "sqrt"): LR scaling strategy
  • decay (default: true): Enable learning rate decay
  • decay_rate (default: 0.8): Rate of learning rate decay
  • decay_steps (default: 20000): Steps between decay applications
  • epochs (default: 100): Maximum training epochs
  • batch_size (default: "auto"): Batch size (auto-calculated or specify manually)
  • early_stop (default: 10): Stop if no improvement for N epochs
  • validation_field: Field name to validate on (e.g., "target")
  • validation_metric: Metric for validation (e.g., "roc_auc", "accuracy")
  • sample_ratio: Ratio of data to sample (e.g., 0.01 for 1%)
  • sample_size: Absolute number of samples to use
  • oversample_minority: Oversample minority class for imbalanced data
  • undersample_majority: Undersample majority class
  • split: Configure train/validation/test split
    • type: "stratify" to maintain class distributions
    • column: Column to stratify on
    • probabilities: Split ratios (e.g., [0.8, 0.1, 0.1] for 80/10/10)

​
Complete Configuration Example

Here’s a complete end-to-end ECD model configuration for a binary classification task: 
{
  "model_type": "ecd",
  "infra_type": "gpu",
  "trainer": {
    "early_stop": 5,
    "decay": true,
    "batch_size": 512,
    "epochs": 50,
    "optimizer": {
      "type": "adam"
    },
    "decay_rate": 0.8,
    "decay_steps": 20000,
    "learning_rate": 0.02,
    "validation_field": "target",
    "validation_metric": "roc_auc",
    "learning_rate_scaling": "sqrt"
  },
  "preprocessing": {
    "sample_ratio": 0.01,
    "sample_size": null,
    "oversample_minority": null,
    "undersample_majority": null,
    "global_max_sequence_length": null,
    "split": {
      "type": "stratify",
      "column": "target",
      "probabilities": [0.8, 0.1, 0.1]
    }
  },
  "combiner": {
    "type": "tabnet",
    "size": 64,
    "output_size": 64,
    "num_steps": 4,
    "num_total_blocks": 4,
    "num_shared_blocks": 2,
    "relaxation_factor": 1.3,
    "bn_epsilon": 0.001,
    "bn_momentum": 0.98,
    "bn_virtual_bs": 128,
    "sparsity": 0.001,
    "dropout": 0
  },
  "input_features": [
    {
      "name": "input_1",
      "type": "category",
      "column": "input_1"
    },
    {
      "name": "input_2",
      "type": "text",
      "column": "input_2"
    }
  ],
  "output_features": [
    {
      "name": "target",
      "type": "binary",
      "column": "target",
      "loss": {
        "type": "binary_weighted_cross_entropy",
        "class_weights": {
          "0": 0.66,
          "1": 2
        },
        "weight": 1
      }
    }
  ]
}
Quick Start Tips:
  • Start with default parameters for your first training run
  • Adjust class_weights if you have imbalanced classes
  • Increase num_steps (3-7) for more complex feature interactions
  • Use early_stop to prevent overfitting
  • Set sample_ratio to a small value (0.01) for faster experimentation with large datasets

​
Next Steps

After successfully training and deploying your ECD model:

Monitor Performance

Track your model’s inference performance and usage metrics

Benchmarking

Evaluate your model’s quality and performance against baselines

Optimization Guide

Learn techniques to improve model latency and throughput

API Integration

Integrate your deployed model into your applications
⌘I