Tutorial metadata

• Author: Manuel Castillo-Cara, PhD
• Affiliation: Dpt. of Artificial Intelligence, Universidad Nacional de Educación a Distancia (UNED), Spain
• Role: Researcher, Professor, and TINTOlib Python Library Developer
• License: CC BY-NC 4.0 unless otherwise stated.

Series note — Part IV of IV. This article closes the four-part technical series on the unsupervised representations available through the TINTOlib Clusters class.

• Part I — From Clusters to Pixels: Unsupervised Synthetic Image Generation in TINTOlib
• Part II — Distance-Based Encodings in TINTOlib: k-Means, k-Medoids and aggloKNN
• Part III — Probabilities, Densities and Latent Factors in TINTOlib: gaussianMix, KDE and Factor Analysis
• Part IV — RGB Fusion and Structural Stability in TINTOlib: mixMethod, channel composition and SSIM-based automatic selection — this article.

Video overview

The following short video summarizes the main concepts introduced in this final article.

From one representation to several complementary views

The first three articles in this series examined how a tabular sample can be converted into an image through different unsupervised intermediate representations:

• distances to synthetic centroids;
• distances to representative medoids;
• local KNN membership probabilities;
• Gaussian-mixture posterior responsibilities;
• feature-wise density estimates;
• latent Factor Analysis scores.

Each representation answers a different question about the same observation. A centroid-distance vector describes proximity to learned regions. A Gaussian-mixture vector describes soft component membership. A factor-score vector describes position in a latent covariance structure.

mixMethod introduces a different idea: instead of choosing only one description, it places several compatible representations into different colour channels of the same synthetic image.

Conceptually, for a tabular sample

three selected transformations may produce

After training-based scaling, padding and square reshaping, they become

where

The final RGB representation is the channel-wise stack

The key point is that colour is not decorative. It is the visible consequence of combining different statistical descriptions of the same tabular record.

(Figure 1. Conceptual workflow of mixMethod. The same standardized tabular sample is transformed by up to three compatible unsupervised methods. Each intermediate representation is independently scaled to pixel intensities, padded and reshaped, and the resulting matrices are assigned to the red, green and blue channels of one RGB synthetic image.)

1. mixMethod: multi-view synthetic images

The ensamMethod parameter determines which representations form the RGB image and, importantly, their order.

For example,

ensamMethod=["kmeans", "gaussianMix", "factor"]

means:

• R channel: k-means representation;
• G channel: Gaussian-mixture representation;
• B channel: Factor Analysis representation.

If fewer than three methods are supplied, TINTOlib fills the remaining higher channels with zero-valued matrices. Therefore,

ensamMethod=["kmeans", "factor"]

produces:

• R: k-means;
• G: factor;
• B: zeros.

Which algorithms can be combined?

The current mixMethod implementation accepts the following component methods:

ensamMethod must be a non-empty list containing at most three non-repeated methods. KDE is excluded because its representation dimension is tied to the number of original features rather than to the shared n_clusters value used to align compatible channels.

When factor is included, the number of latent factors must also respect the dimensionality constraints imposed by Factor Analysis.

Channel alignment matters

An important implementation detail appears when k-means or k-medoids are used as individual grayscale methods. In that case, TINTOlib can reorder the learned references according to proximity before reshaping the representation.

Inside mixMethod, this reordering is intentionally not applied. Independently reorganizing one channel would break the positional correspondence with the other channels. The RGB representation therefore prioritizes channel alignment over the grayscale reference-ordering heuristic.

This distinction is important when interpreting the resulting image: a position $(u,v)$ should be understood as a shared channel index, not as three independently optimized spatial layouts.

Actual channels versus the final RGB image

A useful way to understand mixMethod is to inspect the component channels separately before looking at the colour image.

For a configuration such as

ensamMethod=["kmeans", "gaussianMix", "factor"]

the three channel matrices represent different numerical objects. Their final intensities are comparable as image values only after each method-specific MinMaxScaler has been fitted on the corresponding training representation.

(Figure 2. Actual TINTOlib outputs for one tabular sample. The red, green and blue source matrices correspond to the methods specified in ensamMethod, while the final panel shows their RGB fusion. The component values are scaled independently from training-derived ranges before channel stacking; the final colour therefore reflects multi-view interaction rather than a single physical quantity.)

2. Interpreting colour without over-interpreting it

RGB fusion creates a visually richer image, but the colour itself must be interpreted carefully.

Consider a pixel at location $(u,v)$:

If the channels correspond to kmeans, gaussianMix and factor, the three values do not measure the same quantity:

• $R_{uv}$ may represent a centroid distance or RBF similarity;
• $G_{uv}$ may represent a posterior component responsibility;
• $B_{uv}$ may represent a latent-factor score after training-based scaling.

Consequently, a purple, cyan or yellow region should not be interpreted as a predefined semantic class. It emerges from the numerical interaction of the selected channel values.

Channel order is part of the experimental configuration

Because ensamMethod determines the channel assignment, changing the order changes the visible colours even when the same three component representations are used.

For example,

["kmeans", "gaussianMix", "factor"]

and

["factor", "kmeans", "gaussianMix"]

contain the same three representational families but assign them to different colour axes.

This does not automatically mean that the underlying information has changed. It means that the RGB encoding has changed. For reproducible experiments, the exact order of ensamMethod should therefore be reported together with the remaining hyperparameters.

(Figure 3. Channel interpretation in mixMethod. The order of ensamMethod determines which representation occupies R, G and B. Swapping channel assignments changes the visible colour composition even when the same underlying component representations are used. Channel order should therefore be treated as part of the documented experimental configuration.)

Practical implementation: a leakage-free RGB pipeline

The following example uses the Wine dataset and combines three complementary views:

• k-means with Gaussian RBF similarity;
• Gaussian-mixture responsibilities;
• Factor Analysis scores.

Nine components are used so that every channel forms a native $3\times3$ matrix without padding.

from pathlib import Path

import pandas as pd
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split

from TINTOlib.clusters import Clusters

# ---------------------------------------------------------
# 1. Load a reproducible tabular dataset
# ---------------------------------------------------------
raw_data = load_wine()

df = pd.DataFrame(
    raw_data.data,
    columns=raw_data.feature_names
)

# The target column must be the final column.
df["target"] = raw_data.target

# ---------------------------------------------------------
# 2. Split BEFORE fitting the transformation
# ---------------------------------------------------------
train_df, test_df = train_test_split(
    df,
    test_size=0.20,
    random_state=42,
    stratify=df["target"]
)

# ---------------------------------------------------------
# 3. Configure a three-view RGB representation
# ---------------------------------------------------------
model = Clusters(
    problem="classification",
    algorithm="mixMethod",
    n_clusters=9,
    ensamMethod=[
        "kmeans",
        "gaussianMix",
        "factor"
    ],
    random_seed=1,
    n_init=5,
    max_iter=300,
    algorithmMethod="lloyd",
    RBFKmeans=True,
    covariance_type="full"
)

# ---------------------------------------------------------
# 4. Fit ONLY on training data
# ---------------------------------------------------------
model.fit(train_df)

# ---------------------------------------------------------
# 5. Reuse the fitted transformation
# ---------------------------------------------------------
train_output = Path("synthetic_images/mixMethod/train")
test_output = Path("synthetic_images/mixMethod/test")

model.transform(
    train_df,
    str(train_output)
)

model.transform(
    test_df,
    str(test_output)
)

print("RGB synthetic images generated successfully.")

This workflow is leakage-free because the StandardScaler, the unsupervised component models and the channel-specific image scalers are learned from the training partition and reused for the test data.

Parameter compatibility in mixMethod

The admissible constructor parameters depend on the methods included in ensamMethod.

When aggloKNN or kmedoids is used inside mixMethod, the current shared metric validation for the combined method accepts euclidean or manhattan.

This illustrates a general design principle: mixMethod is not a free concatenation of arbitrary methods. The representations must remain dimensionally compatible and share a coherent image geometry.

3. Why automatically select n_clusters?

For most component-based methods, n_clusters controls more than the internal clustering model. It also controls the dimensionality of the representation and, indirectly, the image resolution.

For a representation with $k$ components,

Therefore:

Choosing $k$ therefore changes both the learned representation and the visual structure presented to the downstream neural network.

TINTOlib provides an automatic selection mechanism based on structural stability rather than only on an internal clustering objective.

4. SSIM as a structural-stability criterion

The Structural Similarity Index Measure (SSIM) compares two images by considering their luminance, contrast and structural organization.

Its interpretation in this context is straightforward:

• SSIM close to 1: the generated images remain structurally similar;
• SSIM close to 0: the image structures differ substantially;
• negative values: very strong structural disagreement may occur.

TINTOlib uses SSIM to ask a specific question:

If the unsupervised model is initialized differently, does a given representation size still produce structurally similar synthetic images?

This is different from asking whether a particular $k$ minimizes inertia, maximizes likelihood or achieves the best downstream predictive metric.

Current automatic-selection procedure

For a compatible algorithm, n_clusters can be:

n_clusters=25

a predefined list:

n_clusters=[9, 16, 25, 36, 49]

or:

n_clusters="auto"

When "auto" is used, the current candidate set is:

[9, 16, 25, 36, 49, 64, 81]

The procedure implemented in TINTOlib can be summarized as follows:

1. Define the candidate values of $k$.
2. For every candidate, fit the transformation under several random seeds.
3. Convert every run into synthetic images.
4. For every sample, compare all unique pairs of images obtained across seeds using SSIM.
5. Average the pairwise similarities to obtain a per-sample stability score.
6. Average across the evaluated samples.
7. Select the $k$ with the highest mean structural stability.

The current implementation calls this procedure with six random seeds during automatic fitting.

For computational reasons, the stability analysis uses at most the first:

• 10,000 training instances for individual compatible methods;
• 2,000 training instances for mixMethod.

When factor participates, candidate values are restricted by the maximum admissible latent dimensionality.

(Figure 4. SSIM-based selection of the representation dimension. For every candidate value of n_clusters, TINTOlib generates images under several random initializations, computes pairwise structural similarities for each sample, averages the stability scores and selects the candidate with the highest mean SSIM.)

Methods for which automatic selection is available

The current implementation enables SSIM-based automatic selection for:

• kmeans;
• kmedoids;
• gaussianMix;
• factor;
• mixMethod.

There are two important exceptions.

KDE

kde does not use n_clusters. Its representation dimension is determined directly by the number of original features. Therefore, there is no equivalent cluster-number hyperparameter to optimize through this procedure.

aggloKNN

When used individually, aggloKNN does not support automatic n_clusters selection in the current implementation. Its hierarchical/KNN procedure is not driven by the same random initialization mechanism required by this stability experiment.

However, aggloKNN can participate inside mixMethod. In that case, the shared representation dimension is determined by the combined configuration, allowing channel compatibility to be maintained.

Practical automatic selection

For a single k-means representation:

model = Clusters(
    problem="classification",
    algorithm="kmeans",
    n_clusters=[9, 16, 25, 36, 49],
    random_seed=1,
    n_init=5,
    max_iter=300,
    RBFKmeans=True
)

model.fit(train_df)

print(
    "Selected n_clusters:",
    model.n_clusters
)

The same interface can be used with "auto":

model = Clusters(
    problem="classification",
    algorithm="kmeans",
    n_clusters="auto",
    random_seed=1,
    n_init=5,
    max_iter=300,
    RBFKmeans=True
)

model.fit(train_df)

Automatic selection for an RGB representation

With Wine, including factor strongly constrains the admissible values because the number of latent factors is bounded by the number of input variables. To illustrate a wider SSIM candidate grid, the following example combines methods whose representation dimensionality can share the same candidate values:

model_rgb_auto = Clusters(
    problem="classification",
    algorithm="mixMethod",
    n_clusters=[9, 16, 25, 36, 49],
    ensamMethod=[
        "kmeans",
        "gaussianMix",
        "kmedoids"
    ],
    random_seed=1,
    n_init=5,
    max_iter=300,
    algorithmMethod="lloyd",
    RBFKmeans=True,
    covariance_type="full",
    metric="euclidean"
)

model_rgb_auto.fit(train_df)

print(
    "Selected RGB representation size:",
    model_rgb_auto.n_clusters
)

The selected value is the candidate that maximizes image stability under the SSIM procedure. It should not be interpreted automatically as the value that maximizes classification or regression performance.

Structural stability is not predictive performance

This distinction is central.

A high SSIM score indicates that an image representation is reproducible under variations in random initialization. It does not demonstrate that:

• a CNN will achieve higher accuracy;
• a Vision Transformer will generalize better;
• a hybrid network will obtain a lower error;
• or the representation preserves all information relevant to the target variable.

SSIM is therefore best interpreted as a representation-stability criterion.

A complete experimental design should distinguish:

Actual stability profiles should be inspected

The final decision should not be reduced to the selected integer alone. It is useful to inspect the full stability profile across candidate values.

(Figure 5. Example of a structural-stability analysis across candidate values of n_clusters. The plot should be generated from actual TINTOlib outputs using the same training partition and repeated random initializations. The selected value corresponds to the highest mean SSIM; the figure reports representation stability only and does not constitute a predictive-performance ranking.)

Methodological cautions

1. Automatic selection belongs inside the training pipeline

The SSIM procedure must operate exclusively on the training partition. Candidate selection performed before the train/test split would expose the transformation-design stage to future evaluation samples.

The correct sequence remains:

1. split the original tabular dataset;
2. fit Clusters on training data;
3. allow fit() to select n_clusters from training data when requested;
4. freeze the fitted transformation;
5. transform validation and test partitions without refitting;
6. evaluate the downstream architecture on untouched data.

2. Channel composition is itself a design choice

A three-channel image does not automatically contain more useful information than a grayscale image. The selected component methods may be complementary, partially redundant or poorly matched to the downstream architecture.

Channel composition should therefore be studied through controlled ablations such as:

• R only;
• R + G;
• R + B;
• G + B;
• R + G + B.

3. Channel ordering must be documented

The same methods in a different ensamMethod order produce a different RGB colour assignment. Reproducible experiments should report both the selected methods and their exact order.

4. Independent scaling changes the meaning of intensity

Every component method has its own training-derived scaling operation. Therefore, identical intensity values in two channels do not imply identical pre-scaling numerical meaning.

5. SSIM measures visual consistency, not semantic equivalence

Different unsupervised fits may produce representations that are mathematically related while differing in channel or component organization. SSIM quantifies the final image similarity and should therefore be interpreted specifically as a measure of output-image stability.

How should mixMethod be evaluated?

The most informative experiment is not to compare one RGB configuration against one grayscale method and declare a winner.

A stronger protocol would include:

1. each selected component method independently;
2. two-channel combinations;
3. the complete three-channel representation;
4. fixed versus SSIM-selected n_clusters;
5. repeated random seeds;
6. several downstream architectures;
7. classical tabular baselines and an MLP;
8. computational cost and storage requirements.

The experimental work that motivated the new Clusters family used regression, binary-classification and multiclass-classification datasets with a specific Vision Transformer evaluation pipeline. Those results provide evidence for that particular experimental setting, but they do not establish a universal ordering among transformations.

The same representation may behave differently with:

• CNNs;
• hybrid tabular–image architectures;
• alternative Vision Transformer configurations;
• different image resolutions;
• different optimizers or regularization strategies;
• datasets with different dimensionality and statistical structure.

For that reason, this series focuses on what each representation encodes, how it is generated and how it should be evaluated, rather than identifying a universally superior method.

Closing the four-part series

The four tutorials can now be read as a progression from single representations toward multi-view and stability-aware image generation.

Taken together, the Clusters family provides a common framework for transforming heterogeneous unsupervised descriptions into image-like representations suitable for experimentation with computer-vision and hybrid neural architectures.

Limitations and future directions

Several research directions remain open.

Automatic channel selection

mixMethod currently receives an explicit ensamMethod list. Future work could investigate whether the most informative combination of representations can itself be selected automatically.

Beyond fixed RGB fusion

RGB channels provide a convenient three-view interface, but they impose a fixed maximum of three simultaneous representations. Learned fusion layers, multi-branch networks or token-level fusion could combine a larger number of views without forcing them into conventional colour channels.

Stability and predictive utility

SSIM evaluates structural consistency across random initializations. A future selection criterion could combine representation stability with downstream predictive evidence while maintaining a strictly leakage-free validation protocol.

Component alignment

Probabilistic and latent models may contain ordering or orientation ambiguities across independent fits. Alignment strategies could be investigated before structural-comparison procedures in order to separate genuine instability from equivalent but differently indexed representations.

Broader neural evaluation

The experimental study behind these additions used a particular Vision Transformer architecture. Further work should systematically evaluate the methods with CNNs, hybrid tabular–image architectures, alternative ViTs and other visual backbones before drawing broad conclusions about their relative behaviour.

Explainable multi-view representations

Because each RGB channel has a known origin, attribution maps from the downstream visual model could potentially be decomposed by channel and connected back to centroid proximity, component responsibilities, medoid distances or latent factors. This creates a promising direction for explainable multi-view tabular learning.

Conclusion

mixMethod and SSIM-based automatic selection complete the conceptual framework introduced throughout this series.

mixMethod combines up to three compatible unsupervised descriptions of the same sample in a single RGB image. The resulting colours are not arbitrary decorations: each channel originates from a different learned representation and must be interpreted according to its own statistical meaning.

The SSIM procedure addresses another design question: how large should the learned representation be? Instead of selecting n_clusters only from an internal clustering objective, TINTOlib can evaluate how structurally stable the final synthetic images remain across different random initializations.

Neither mechanism guarantees better predictive performance. They provide additional tools for designing, controlling and analysing synthetic representations of tabular data. Their value must ultimately be established through leakage-free experiments across datasets, seeds and downstream architectures.

The broader message of the series is therefore simple: representation design is part of the learning problem. Once tabular data are transformed into images, the transformation itself should be studied with the same rigor as the neural architecture that consumes those images.

References and resources

1. Salvador Martínez Moreno. Generación de imágenes sintéticas mediante métodos no supervisados para la librería TINTOlib. Master’s Thesis, Universidad Nacional de Educación a Distancia (UNED), 2026.

2. TINTOlib documentation. Clusters. Read the current parameter and API documentation.

Research articles

1. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro, Luis Orozco-Barbosa. Interpretable Hybrid Vision Transformer Architectures for MIMO-Based Indoor Localization using Synthetic Spatial Representations. IEEE Internet of Things. DOI: 10.1109/JIOT.2026.3696106

2. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. A Comprehensive Benchmark of Spatial Encoding Methods for Tabular Data with Deep Neural Networks. Information Fusion. DOI: 10.1016/j.inffus.2025.104088

3. Giovanny Mondragon-Ruiz, Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. Interpretable CNN–KAN hybrid architectures for tabular data with synthetic image encoding. Information Processing and Management. DOI: 10.1016/j.ipm.2026.104954

4. Felipe Escalera-González, Manuel Castillo-Cara, Mariano Rincón-Zamorano, Luis Orozco-Barbosa. PermGrad: Interpretable Hybrid Neural Networks with synthetic images for tabular data. Knowledge-Based Systems. DOI: 10.1016/j.knosys.2026.116507

5. Manuel Castillo-Cara, Jesus Martínez-Gómez, Javier Ballesteros-Jerez, Ismael García-Varea, Raúl García-Castro, Luis Orozco-Barbosa. MIMO-Based Indoor Localisation with Hybrid Neural Networks. IEEE Journal of Selected Topics in Signal Processing. DOI: 10.1109/JSTSP.2025.3555067

6. Reewos Talla-Chumpitaz, Manuel Castillo-Cara, Luis Orozco-Barbosa, Raúl García-Castro. Blurring Image Techniques for Bluetooth-based Indoor Localisation. Information Fusion. DOI: 10.1016/j.inffus.2022.10.011

Software articles

1. Jiayun Liu, David González-Fernández, Manuel Castillo-Cara, Raúl García-Castro. TINTOlib: A Python library for transforming tabular data into synthetic images for deep neural networks. SoftwareX. DOI: 10.1016/j.softx.2025.102444

2. Manuel Castillo-Cara, Reewos Talla-Chumpitaz, Raúl García-Castro, Luis Orozco-Barbosa. TINTO: Converting Tidy Data into Image for Classification with 2-Dimensional Convolutional Neural Networks. SoftwareX. DOI: 10.1016/j.softx.2023.101391

Continue learning Artificial Intelligence

Explore practical courses on AI, Machine Learning, Deep Learning, Python, R and applied data science.

View AI Courses →

Manuel Castillo-Cara, PhD

TINTOlib Python Library Developer

Researcher & Professor

Department of Artificial Intelligence

Universidad Nacional de Educación a Distancia (UNED)

Almerimar (Almería), Spain

© Manuel Castillo-Cara, PhD. Content licensed under CC BY-NC 4.0 unless otherwise stated.

🖨️ Print / Save as PDF 💾 Save as HTML 🐍 Download Python 📓 Notebook (.ipynb)

You may also enjoy

06 Aug 2026 TINTOlib

Part 3 — Probabilities, Densities and Latent Factors in TINTOlib: gaussianMix, KDE and Factor Analysis

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

24 Jul 2026 TINTOlib

Part 2 — Distance-Based Encodings in TINTOlib: k-Means, k-Medoids and aggloKNN

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

20 Jul 2026 TINTOlib

Part 1 - From Clusters to Pixels: Unsupervised Synthetic Image Generation in TINTOlib

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

Tutorial metadata

• Author: Manuel Castillo-Cara, PhD
• Affiliation: Dpt. of Artificial Intelligence, Universidad Nacional de Educación a Distancia (UNED), Spain
• Role: Researcher, Professor, and TINTOlib Python Library Developer
• License: CC BY-NC 4.0 unless otherwise stated.

Series note — Part III of IV. This article is the third entry in a four-part technical series on the unsupervised representations available through the TINTOlib Clusters class.

• Part I — From Clusters to Pixels: Unsupervised Synthetic Image Generation in TINTOlib
• Part II — Distance-Based Encodings in TINTOlib: k-Means, k-Medoids and aggloKNN
• Part III — Probabilities, Densities and Latent Factors in TINTOlib: gaussianMix, kde and factor — this article.

The fourth and final article will examine RGB fusion through mixMethod, channel interpretation and SSIM-based structural stability.

Video overview

The following short video summarizes the main concepts introduced in this article.

Beyond distances: three alternative views of tabular structure

The distance-oriented methods discussed in Part II describe a sample through its proximity to centroids, medoids or locally constrained groups. The methods examined here answer different questions:

• gaussianMix: how strongly does the sample belong to each probabilistic component?
• kde: how common or unusual is each observed feature value under its training distribution?
• factor: where is the sample located in a lower-dimensional latent space that explains shared variation among the original variables?

These representations should not be interpreted as interchangeable. Their intermediate vectors have different dimensions, scales and semantics:

For gaussianMix, the representation dimension is the number of Gaussian components, $q=k$. For factor, it is the number of latent factors, $q$. For kde, one estimator is fitted per original feature, so the representation remains $p$-dimensional.

The square side is calculated as

and zero-padding is added when the representation does not fill the complete $d \times d$ matrix.

A crucial interpretability distinction must be made. TINTOlib scales the intermediate values to $[0,255]$ using a MinMaxScaler fitted on the training representation. Therefore, the final pixel intensities preserve a relative encoding of the learned representation, but they are not raw calibrated probabilities, densities or signed factor scores.

(Figure 1. Three complementary mechanisms for constructing synthetic images from tabular data. gaussianMix represents a sample through posterior component responsibilities, kde replaces each feature value with its estimated density under the training distribution, and factor projects the sample onto a lower-dimensional latent space before pixel scaling and reshaping.)

1. gaussianMix: posterior responsibilities as pixels

A Gaussian Mixture Model assumes that the observed data distribution can be approximated by a weighted combination of $k$ multivariate Gaussian components:

where:

• $\pi_j$ is the mixing weight of component $j$;
• $\boldsymbol{\mu}_j$ is its mean vector;
• $\boldsymbol{\Sigma}_j$ is its covariance structure;
• $\sum_{j=1}^{k}\pi_j=1$.

Instead of assigning each sample to only one component, gaussianMix uses the complete posterior responsibility vector:

with

Before pixel scaling,

The vector therefore describes both component affinity and assignment uncertainty. A sample near the centre of one Gaussian may have one dominant responsibility, whereas a sample near a boundary may distribute its probability mass across several components.

Main parameters

Implementation note. In the current implementation, n_init="auto" is converted internally to one Gaussian-mixture initialization. Use an explicit integer such as n_init=5 when several EM restarts are required.

Covariance structures

The selected structure changes the learned component geometry and therefore the responsibility vector assigned to each sample.

(Figure 2. Synthetic images generated from the same tabular sample using gaussianMix with full, tied, diag and spherical covariance structures. Every panel encodes posterior component responsibilities under a different geometric assumption; no configuration should be interpreted as universally preferable.)

Why can Gaussian-mixture images look highly discrete?

It is common for a fitted mixture to assign almost all posterior mass to one component:

After training-based MinMax scaling, this may produce images dominated by very dark pixels and one or a few bright regions. This is not necessarily an implementation error. It may indicate:

• well-separated Gaussian components;
• a sample located far from component boundaries;
• a covariance constraint that creates confident assignments;
• or an excessive number of components relative to the available data.

Conversely, a more graded image can indicate overlapping components or greater assignment ambiguity. Neither visual pattern guarantees better downstream prediction. The representation must be evaluated together with the dataset and neural architecture.

Another methodological issue is component ordering. Gaussian component indices have no intrinsic semantic order and may be permuted across independently fitted models. Train, validation and test images remain consistent when they are transformed with the same fitted model, but comparisons across independent runs require care.

2. kde: one density estimator per feature

Kernel Density Estimation provides a non-parametric alternative. In the current TINTOlib implementation, a separate one-dimensional KDE model is fitted for every standardized input feature.

For feature $j$, containing training observations

the estimated density can be written as

where:

• $K$ is the selected kernel;
• $h>0$ is the bandwidth;
• $n$ is the number of training samples.

For sample $\mathbf{x}_i$, the intermediate representation is

Each component answers a feature-specific question: how dense is the training distribution around this observed value?

This is not a joint multivariate probability for the complete sample. It is a collection of independent univariate density evaluations.

Main parameters

Supported kernels are:

• gaussian;
• tophat;
• epanechnikov;
• exponential;
• linear;
• cosine.

Supported metrics are:

• euclidean;
• manhattan;
• chebyshev.

The implementation obtains log-density scores through score_samples, applies the exponential function and fits a MinMaxScaler on the resulting training densities.

Bandwidth controls the representation scale

The bandwidth is usually the most influential KDE parameter.

• Small bandwidth: narrow local peaks, greater sensitivity to individual observations and potentially fragmented representations.
• Large bandwidth: smoother densities, less local detail and more similar values across broad regions.

A very small bandwidth may classify many test values as lying in low-density regions. A very large bandwidth may suppress potentially meaningful local structure.

(Figure 3. Effect of kernel shape and bandwidth on the density representation used by kde. The curves must be estimated from the same standardized training feature. The associated synthetic-image panels show how local versus smooth density estimates alter the pixel intensities assigned to the same tabular sample.)

Why KDE has a different image size

Unlike the component-based methods, kde does not use n_clusters. Its intermediate vector contains one density value per original feature:

For the Wine dataset, which contains 13 input features,

so the resulting image has size $4\times4$, with three padded positions.

This property also explains why kde is not currently available as a channel inside mixMethod: its output dimensionality is determined by the dataset rather than by a shared number of components.

Interpreting KDE pixels

Before scaling:

• a high density indicates that the feature value lies in a common region of its training distribution;
• a low density indicates a locally uncommon or potentially atypical value.

After MinMax scaling, brightness expresses relative density according to the training-derived scaling range. It should not be interpreted as a probability that the complete sample is normal or anomalous.

3. factor: latent scores as a compact image representation

Factor Analysis does not create groups or estimate feature-wise densities. It models the covariance structure of the observed variables through a smaller set of latent factors.

A standard formulation is

where:

• $\mathbf{x}_i\in\mathbb{R}^{p}$ is the observed sample;
• $\boldsymbol{\mu}$ is the feature mean vector;
• $\mathbf{z}_i\in\mathbb{R}^{q}$ is the latent-factor score vector;
• $\mathbf{\Lambda}\in\mathbb{R}^{p\times q}$ is the loading matrix;
• $\boldsymbol{\varepsilon}_i$ represents feature-specific variation not explained by the common factors.

TINTOlib uses the transformed factor scores as the intermediate representation:

The API retains the parameter name n_clusters, but for factor it means the number of latent factors, not the number of clusters.

Main parameters

The current implementation requires

For example, a dataset with 13 original features can use at most 12 factors in the current Clusters implementation.

(Figure 4. Factor Analysis representation used by TINTOlib. The fitted loading matrix relates original variables to latent factors, every sample is projected into the factor-score space, and the resulting score vector is scaled and reshaped into a grayscale synthetic image.)

Scores, loadings and pixel meaning

Two quantities must be distinguished:

• factor loadings: describe how the original variables contribute to the latent factors;
• factor scores: describe where each sample lies in the learned latent space.

The image is generated from the factor scores, not directly from the loading matrix. The loadings can nevertheless support interpretation by relating each pixel/factor back to influential original variables.

Raw factor scores may be positive or negative. After MinMax scaling, a pixel value of 0 or 255 represents an extreme relative to the training score range; it does not directly mean negative or positive contribution. The original sign and zero reference are not visually preserved by the final unsigned 8-bit image.

Factor models also have orientation ambiguities: independently fitted solutions can differ in factor sign or ordering while describing an equivalent latent structure. Consequently, comparisons should reuse the same fitted model for train, validation and test data.

Comparative view

This table describes representational differences, not a performance ranking.

Practical implementation with a leakage-free split

The following example generates the three representations from the same Wine dataset split.

from pathlib import Path

import pandas as pd
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split

from TINTOlib.clusters import Clusters

# ---------------------------------------------------------
# 1. Load a reproducible tabular dataset
# ---------------------------------------------------------
raw_data = load_wine()

df = pd.DataFrame(
    raw_data.data,
    columns=raw_data.feature_names
)

# The target column must be the final column.
df["target"] = raw_data.target

# ---------------------------------------------------------
# 2. Split before fitting any unsupervised transformation
# ---------------------------------------------------------
train_df, test_df = train_test_split(
    df,
    test_size=0.20,
    random_state=42,
    stratify=df["target"]
)

# ---------------------------------------------------------
# 3. Configure the three representations
# ---------------------------------------------------------
models = {
    "gaussianMix_full": Clusters(
        problem="classification",
        algorithm="gaussianMix",
        n_clusters=9,
        random_seed=1,
        n_init=5,
        max_iter=300,
        covariance_type="full"
    ),

    "kde_gaussian": Clusters(
        problem="classification",
        algorithm="kde",
        kernel="gaussian",
        bandwidth=0.5,
        metric="euclidean"
    ),

    "factor_9": Clusters(
        problem="classification",
        algorithm="factor",
        n_clusters=9,
        random_seed=1
    )
}

# ---------------------------------------------------------
# 4. Fit only on training data and reuse each fitted model
# ---------------------------------------------------------
for name, model in models.items():
    print(f"Generating images with {name}...")

    model.fit(train_df)

    train_folder = Path("synthetic_images") / name / "train"
    test_folder = Path("synthetic_images") / name / "test"

    model.transform(train_df, str(train_folder))
    model.transform(test_df, str(test_folder))

print("Probabilistic, density and latent images generated successfully.")

With these configurations:

• gaussianMix generates nine responsibilities and therefore a $3\times3$ image;
• factor generates nine latent scores and therefore a $3\times3$ image;
• kde generates 13 density values for Wine and therefore a padded $4\times4$ image.

The image sizes are not automatically equivalent. A visual or predictive comparison must acknowledge this difference rather than resize or crop the representations without documenting the operation.

Exploring Gaussian covariance structures

Use the same split, sample and number of components when comparing covariance assumptions:

covariance_models = {
    covariance_type: Clusters(
        problem="classification",
        algorithm="gaussianMix",
        n_clusters=9,
        random_seed=1,
        n_init=5,
        max_iter=300,
        covariance_type=covariance_type
    )
    for covariance_type in [
        "full",
        "tied",
        "diag",
        "spherical"
    ]
}

for covariance_type, model in covariance_models.items():
    model.fit(train_df)

    model.transform(
        test_df,
        f"synthetic_images/gaussianMix_{covariance_type}/test"
    )

Do not compare images generated from independently changed splits or sample indices. Otherwise, visual differences cannot be attributed specifically to covariance_type.

Exploring KDE kernels and bandwidth

A controlled KDE experiment should vary one parameter at a time:

bandwidth_models = {
    f"gaussian_bw_{bandwidth}": Clusters(
        problem="classification",
        algorithm="kde",
        kernel="gaussian",
        bandwidth=bandwidth,
        metric="euclidean"
    )
    for bandwidth in [0.2, 0.5, 1.0, 2.0]
}

for name, model in bandwidth_models.items():
    model.fit(train_df)
    model.transform(
        test_df,
        f"synthetic_images/{name}/test"
    )

A separate kernel comparison can keep bandwidth=0.5 fixed and vary:

kernels = [
    "gaussian",
    "tophat",
    "epanechnikov",
    "exponential",
    "linear",
    "cosine"
]

Because KDE is applied separately to standardized one-dimensional features, bandwidth effects should be examined alongside the feature distributions rather than inferred only from the final image.

Exploring the number of latent factors

The factor count controls compression and image size:

factor_models = {
    f"factor_{n_factors}": Clusters(
        problem="classification",
        algorithm="factor",
        n_clusters=n_factors,
        random_seed=1
    )
    for n_factors in [4, 9, 12]
}

for name, model in factor_models.items():
    model.fit(train_df)
    model.transform(
        test_df,
        f"synthetic_images/{name}/test"
    )

For Wine, 12 is the maximum allowed value in the current implementation because the dataset contains 13 input features.

Same sample, different pixel semantics

(Figure 5. Actual TINTOlib outputs generated from the same tabular sample using gaussianMix, kde and factor. The panels must preserve their native image dimensions and pixel values. Their visual patterns are not directly equivalent because they encode component responsibilities, feature-wise density estimates and latent-factor scores, respectively.)

A bright pixel has a method-dependent meaning:

The same grayscale value therefore cannot be interpreted identically across methods.

Sparse, discrete and low-contrast images

Synthetic images generated by these methods can appear visually unusual.

gaussianMix

A nearly one-hot responsibility vector produces a highly discrete image. This may be a faithful representation of confident component assignment rather than a defective image.

kde

If several values lie in similarly dense regions, the image may have low contrast. Conversely, rare feature values can create sharp dark or bright differences after scaling, depending on the training density range.

factor

A small number of factors produces very compact images and potentially substantial padding. Increasing the number of factors changes both representational capacity and spatial dimensions.

Visual texture alone is not a sufficient quality criterion. Evaluation should include the intermediate numerical representation, image stability, predictive performance and computational cost.

Methodological checklist

Before comparing the three methods, verify that:

• the train/test split is created before fitting Clusters;
• StandardScaler, Gaussian components, KDE estimators, factor projections and MinMax scalers are learned only from training data;
• validation and test data are transformed without refitting;
• the same split and test sample are used in all visual comparisons;
• native image dimensions are reported;
• GMM covariance type, KDE kernel/bandwidth and factor count are documented;
• results are repeated across seeds when the method is stochastic;
• classical tabular baselines and an MLP remain part of the evaluation;
• CNN, ViT and hybrid models are compared under controlled settings;
• conclusions are conditional on the dataset and downstream architecture.

How should these representations be evaluated?

The experimental study that motivated these additions used regression, binary-classification and multiclass-classification datasets together with a particular Vision Transformer evaluation pipeline. Those results provide evidence for that experimental setting, but they do not establish a universal ordering among gaussianMix, kde, factor or the other transformations.

A representation may behave differently with:

• a convolutional neural network;
• a hybrid tabular–image architecture;
• another Vision Transformer configuration;
• a different image-resolution policy;
• another optimizer or regularization strategy;
• or a dataset with different dimensionality and distributional structure.

A rigorous comparison should therefore report:

1. predictive metrics under identical data partitions;
2. repeated runs and uncertainty estimates;
3. transformation fit and generation time;
4. memory and storage requirements;
5. sensitivity to the main parameters;
6. strong classical tabular and MLP baselines;
7. results from more than one downstream visual architecture.

The objective of this tutorial is to explain what each method encodes, not to declare a universally superior transformation.

When should each representation be considered?

These are practical starting points rather than performance guarantees:

• gaussianMix when soft membership, overlapping regions and component uncertainty are central to the analysis;
• kde when feature-wise commonness, rarity or local distributional structure is relevant;
• factor when a compact representation of shared covariance and latent structure is desired.

The choice should be validated empirically under the intended model and dataset.

Conclusion

gaussianMix, kde and factor transform the same tabular sample into three fundamentally different descriptions.

• gaussianMix produces posterior responsibilities over probabilistic components.
• kde evaluates every feature value under its training distribution.
• factor projects the sample onto latent dimensions that summarize shared variation.

TINTOlib converts all three representations into a common visual interface through training-based scaling, padding and square reshaping. That common output format should not obscure the fact that their pixels have different statistical meanings.

The final article in this series will examine RGB fusion through mixMethod, channel composition, interpretability and automatic structural-stability analysis using SSIM.

References and resources

1. Salvador Martínez Moreno. Generación de imágenes sintéticas mediante métodos no supervisados para la librería TINTOlib. Master’s Thesis, Universidad Nacional de Educación a Distancia (UNED), 2026.

2. TINTOlib documentation. Clusters. Read the current parameter and API documentation.

Research articles

1. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro, Luis Orozco-Barbosa. Interpretable Hybrid Vision Transformer Architectures for MIMO-Based Indoor Localization using Synthetic Spatial Representations. IEEE Internet of Things. DOI: 10.1109/JIOT.2026.3696106

2. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. A Comprehensive Benchmark of Spatial Encoding Methods for Tabular Data with Deep Neural Networks. Information Fusion. DOI: 10.1016/j.inffus.2025.104088

3. Giovanny Mondragon-Ruiz, Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. Interpretable CNN–KAN hybrid architectures for tabular data with synthetic image encoding. Information Processing and Management. DOI: 10.1016/j.ipm.2026.104954

4. Felipe Escalera-González, Manuel Castillo-Cara, Mariano Rincón-Zamorano, Luis Orozco-Barbosa. PermGrad: Interpretable Hybrid Neural Networks with synthetic images for tabular data. Knowledge-Based Systems. DOI: 10.1016/j.knosys.2026.116507

5. Manuel Castillo-Cara, Jesus Martínez-Gómez, Javier Ballesteros-Jerez, Ismael García-Varea, Raúl García-Castro, Luis Orozco-Barbosa. MIMO-Based Indoor Localisation with Hybrid Neural Networks. IEEE Journal of Selected Topics in Signal Processing. DOI: 10.1109/JSTSP.2025.3555067

6. Reewos Talla-Chumpitaz, Manuel Castillo-Cara, Luis Orozco-Barbosa, Raúl García-Castro. Blurring Image Techniques for Bluetooth-based Indoor Localisation. Information Fusion. DOI: 10.1016/j.inffus.2022.10.011

Software articles

1. Jiayun Liu, David González-Fernández, Manuel Castillo-Cara, Raúl García-Castro. TINTOlib: A Python library for transforming tabular data into synthetic images for deep neural networks. SoftwareX. DOI: 10.1016/j.softx.2025.102444

2. Manuel Castillo-Cara, Reewos Talla-Chumpitaz, Raúl García-Castro, Luis Orozco-Barbosa. TINTO: Converting Tidy Data into Image for Classification with 2-Dimensional Convolutional Neural Networks. SoftwareX. DOI: 10.1016/j.softx.2023.101391

Continue learning Artificial Intelligence

Explore practical courses on AI, Machine Learning, Deep Learning, Python, R and applied data science.

View AI Courses →

Manuel Castillo-Cara, PhD

TINTOlib Python Library Developer

Researcher & Professor

Department of Artificial Intelligence

Universidad Nacional de Educación a Distancia (UNED)

Almerimar (Almería), Spain

© Manuel Castillo-Cara, PhD. Content licensed under CC BY-NC 4.0 unless otherwise stated.

🖨️ Print / Save as PDF 💾 Save as HTML 🐍 Download Python 📓 Notebook (.ipynb)

You may also enjoy

08 Aug 2026 TINTOlib

Part 4 — RGB Fusion and Structural Stability in TINTOlib: mixMethod and SSIM-Based Automatic Selection

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

24 Jul 2026 TINTOlib

Part 2 — Distance-Based Encodings in TINTOlib: k-Means, k-Medoids and aggloKNN

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

20 Jul 2026 TINTOlib

Part 1 - From Clusters to Pixels: Unsupervised Synthetic Image Generation in TINTOlib

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

Tutorial metadata

• Author: Manuel Castillo-Cara, PhD
• Affiliation: Dpt. of Artificial Intelligence, Universidad Nacional de Educación a Distancia (UNED), Spain
• Role: Researcher, Professor, and TINTOlib Python Library Developer
• License: CC BY-NC 4.0 unless otherwise stated.

Series note. This is the second article in a four-part series on the unsupervised representations available through the Clusters class in TINTOlib. Part I introduces the complete family of methods. This post focuses on kmeans, kmedoids and aggloKNN, while Parts III and IV will examine probabilistic and latent representations, RGB fusion and SSIM-based stability.

Video overview

The following short video summarizes the main concepts introduced in this article.

From cluster assignments to image-ready representations

Clustering algorithms are usually introduced as methods that assign observations to groups. For synthetic image generation, however, a single discrete label contains too little information. If one sample is assigned to cluster 2 and another to cluster 3, the labels alone do not reveal whether the samples are almost identical or located in distant regions of the feature space.

The Clusters class therefore uses richer intermediate representations:

• kmeans represents each sample through its distances to all learned centroids;
• kmedoids uses distances to representative observations selected from the training data;
• aggloKNN first constructs locally constrained hierarchical groups and then converts their pseudo-labels into KNN membership probabilities.

The first two are direct distance encodings. The third is a bridge between distance-based grouping and probabilistic representation: distances define the local graph and the KNN model, while the image pixels contain probabilities rather than raw distances.

This common principle can be expressed as

where $p$ is the number of original variables, $k$ is the number of learned references or groups, and

The vector $\mathbf{r}_i$ is scaled to $[0,255]$, padded when necessary and reshaped into the grayscale image $\mathbf{I}_i$.

(Figure 1. Three mechanisms for constructing an intermediate representation from tabular samples. k-means uses synthetic centroids, k-medoids selects representative observations from the training data, and aggloKNN combines a local connectivity graph, hierarchical grouping and KNN membership probabilities.)

1. k-Means: distances to synthetic centroids

Let the standardized training set be

After fitting k-means with $k$ clusters, the method learns centroids

For a cluster $C_j$, its centroid is the arithmetic mean of the samples assigned to that group:

TINTOlib does not use only the final cluster label. Instead, every sample is transformed into the complete distance profile

This vector describes how the sample relates simultaneously to all regions represented by the centroids. Two samples assigned to different clusters can still have similar distance profiles, while two samples in the same cluster may relate differently to the remaining centroids.

Main parameters

In the current implementation, k-means follows its standard Euclidean geometry. Unlike kmedoids and aggloKNN, it does not expose the general metric parameter.

2. k-Medoids: distances to real observations

k-medoids follows the same representational idea but changes the nature of the references. Instead of using arithmetic means, it selects actual observations from the training set:

Within a cluster $C_j$, the medoid is the observation minimizing the total distance to the other elements in that group:

Every sample is then represented by

Because each medoid is a real training observation, the references can be inspected directly. This can improve the semantic traceability of the representation and may reduce the influence of extreme values compared with mean-based centroids. The trade-off is that the PAM-like iterative search is generally more computationally demanding than k-means.

TINTOlib implements its own PAM-style procedure:

1. Select initial medoids from the training observations.
2. Assign every sample to the nearest medoid.
3. Within each group, identify the observation minimizing the total intra-cluster distance.
4. Replace the medoid when a better representative is found.
5. Repeat until the medoids remain unchanged or max_iter is reached.

Supported metrics

The current implementation accepts:

• euclidean;
• manhattan;
• chebyshev.

The metric affects both cluster construction and the distance profile later converted into the synthetic image.

(Figure 2. Distance-vector construction and grayscale image generation for k-means and k-medoids. After learning the references, each sample is represented by its distances to all centroids or medoids. In single-channel mode, TINTOlib reorders these dimensions according to reference proximity before scaling, padding and reshaping the vector into an image.)

Reference ordering and spatial coherence

A list of centroid or medoid distances has no natural two-dimensional order. If its components were reshaped directly, adjacent pixels could correspond to unrelated references.

In grayscale mode, TINTOlib therefore constructs a proximity-based ordering of the learned centroids or medoids before image generation. The procedure starts from a close pair of references and progressively builds a sequence that keeps nearby references close in the one-dimensional vector. The reordered vector is then reshaped into the square image.

This operation does not create a perfect two-dimensional embedding, but it reduces purely arbitrary adjacency and introduces a degree of spatial coherence into the image.

Implementation note. This reference ordering is applied when kmeans or kmedoids is used as an individual grayscale method. It is not applied to those methods inside mixMethod, because independently reordering the channels could interfere with their alignment.

RBF smoothing: distances become similarities

Raw distances and local similarities express opposite concepts:

• a small distance indicates proximity;
• a large similarity indicates proximity.

When RBFKmeans=True, TINTOlib transforms the k-means distances using a Gaussian radial basis function:

The implementation estimates $\sigma$ as the global mean of the distance matrix obtained during transformation. Nearby centroids therefore produce values close to one, while distant centroids are progressively attenuated.

The RBF operation changes the representation in three relevant ways:

1. Direction of meaning: brighter or larger values can now indicate stronger local affinity rather than greater distance.
2. Non-linearity: differences among nearby references are emphasized differently from large-distance differences.
3. Visual continuity: the resulting image may show smoother transitions after scaling to pixel intensities.

RBF should not be treated as universally beneficial. It introduces a different inductive assumption and must be assessed as an experimental choice.

(Figure 3. The same tabular sample represented with k-means before and after Gaussian RBF transformation. The distance image encodes proximity inversely, whereas the RBF image converts distances into bounded similarities that emphasize nearby centroids and attenuate distant references.)

3. aggloKNN: local connectivity followed by soft membership

aggloKNN requires a more precise interpretation. It does not generate pixels directly from the hierarchical-clustering labels. Instead, it combines two stages.

Stage 1: locally constrained agglomerative clustering

The standardized data are first normalized with the L2 norm. A nearest-neighbour connectivity graph is then constructed. In the current implementation, the number of graph neighbours is

The graph restricts which observations or groups may be merged during agglomerative clustering. This changes the focus from unrestricted global comparisons to locally admissible connections.

TINTOlib uses complete linkage, where the distance between two groups is determined by the most distant pair of observations across them. The resulting partition provides one pseudo-label for every training sample.

Stage 2: KNN probabilities

The hierarchical model itself does not naturally provide a predict_proba operation for new observations. TINTOlib therefore trains a KNN classifier using the agglomerative labels as pseudo-labels.

The number of neighbours used by this classifier is

The KNN classifier uses:

• uniform neighbour weights;
• the same selected distance metric;
• brute-force neighbour search.

For each sample, it produces a probability vector

Consequently, the final pixels encode soft membership estimates derived from a locally constrained hierarchical partition. This can represent ambiguity near group boundaries more effectively than a single hard cluster label.

(Figure 4. aggloKNN pipeline. Standardized samples are L2-normalized, connected through a nearest-neighbour graph and grouped with complete-linkage agglomerative clustering. The resulting pseudo-labels train a KNN classifier, whose membership probabilities form the intermediate vector converted into a grayscale synthetic image.)

Supported metrics and current restriction

aggloKNN accepts:

• euclidean;
• manhattan;
• cosine.

The selected metric is used in the connectivity graph, the agglomerative model and the subsequent KNN classifier.

Unlike kmeans and kmedoids, the current implementation requires an explicit integer for n_clusters. Automatic selection through "auto" or a list of candidates is not currently enabled for aggloKNN.

Comparative view

The table should not be interpreted as a ranking. Each method exposes a different relationship between the original sample and the learned structure of the training set.

Practical implementation with a leakage-free split

The following example generates four representations from the Wine dataset:

• k-means distances;
• k-means RBF similarities;
• k-medoids with Euclidean distance;
• aggloKNN with cosine distance.

The original dataset is split before fitting any transformation.

from pathlib import Path

import pandas as pd
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split

from TINTOlib.clusters import Clusters

# ---------------------------------------------------------
# 1. Load a reproducible tabular dataset
# ---------------------------------------------------------
raw_data = load_wine()

df = pd.DataFrame(
    raw_data.data,
    columns=raw_data.feature_names
)

# The target column must be the final column.
df["target"] = raw_data.target

# ---------------------------------------------------------
# 2. Split before fitting the image transformation
# ---------------------------------------------------------
train_df, test_df = train_test_split(
    df,
    test_size=0.20,
    random_state=42,
    stratify=df["target"]
)

# ---------------------------------------------------------
# 3. Define comparable configurations
#    25 references/components -> 5 x 5 images
# ---------------------------------------------------------
models = {
    "kmeans_distances": Clusters(
        problem="classification",
        algorithm="kmeans",
        n_clusters=25,
        random_seed=1,
        n_init="auto",
        max_iter=300,
        algorithmMethod="lloyd",
        RBFKmeans=False
    ),

    "kmeans_rbf": Clusters(
        problem="classification",
        algorithm="kmeans",
        n_clusters=25,
        random_seed=1,
        n_init="auto",
        max_iter=300,
        algorithmMethod="lloyd",
        RBFKmeans=True
    ),

    "kmedoids_euclidean": Clusters(
        problem="classification",
        algorithm="kmedoids",
        n_clusters=25,
        random_seed=1,
        max_iter=300,
        metric="euclidean"
    ),

    "aggloknn_cosine": Clusters(
        problem="classification",
        algorithm="aggloKNN",
        n_clusters=25,
        metric="cosine"
    )
}

# ---------------------------------------------------------
# 4. Fit only on training data and reuse every fitted model
# ---------------------------------------------------------
for name, model in models.items():
    print(f"Generating images with {name}...")

    model.fit(train_df)

    train_folder = Path("synthetic_images") / name / "train"
    test_folder = Path("synthetic_images") / name / "test"

    model.transform(train_df, str(train_folder))
    model.transform(test_df, str(test_folder))

print("Distance-based synthetic images generated successfully.")

With n_clusters=25, each intermediate representation contains 25 values and can therefore be reshaped directly into a $5\times5$ image without zero-padding.

Comparing distance metrics

The metric parameter should be treated as part of the representation design, not merely as an implementation detail.

k-medoids

• Euclidean: emphasizes straight-line geometric distance.
• Manhattan: accumulates absolute coordinate differences and may be appropriate in high-dimensional spaces where axis-wise changes are meaningful.
• Chebyshev: uses the maximum coordinate difference and is therefore controlled by the most discrepant feature.

aggloKNN

• Euclidean: geometric neighbourhoods under L2 distance.
• Manhattan: neighbourhoods based on cumulative absolute differences.
• Cosine: neighbourhoods based primarily on vector orientation after L2 normalization.

Changing the metric may alter:

1. the selected medoids;
2. the local connectivity graph;
3. the agglomerative pseudo-labels;
4. the KNN neighbourhoods;
5. the final pixel intensities.

A valid metric comparison must therefore refit the transformation independently for every metric while preserving the same train/test partitions.

What should the experiment compare?

The purpose of this post is to explain the representations rather than identify a universally superior method. A rigorous experiment should separate at least four dimensions.

The Master’s Thesis used a specific Vision Transformer evaluation architecture. Its results provide evidence for that experimental setting, but they should not be extrapolated directly to CNNs, hybrid tabular–image models or alternative ViT configurations. For that reason, this series does not establish a general ranking among methods.

(Figure 5. Synthetic images generated from the same tabular sample using k-means distances, k-means with RBF similarities, k-medoids and aggloKNN. The panels use a common image size, but their pixel semantics differ: centroid distance, centroid similarity, medoid distance and soft membership probability.)

Methodological checklist

Before comparing these transformations, verify that:

• the original split is created before fitting Clusters;
• standardization and all representation models are learned only from training data;
• the same split is reused across methods and metrics;
• image dimensions are controlled through a comparable n_clusters value;
• architecture and optimization settings are held constant within each downstream comparison;
• results are repeated across several seeds;
• classical tabular baselines and an MLP remain part of the evaluation;
• conclusions are reported conditionally on the dataset and downstream architecture.

When should each representation be considered?

A reasonable initial interpretation is:

• k-means distances when a computationally efficient reference map based on synthetic centroids is required;
• k-means with RBF when the experiment aims to emphasize local centroid similarity rather than raw distance;
• k-medoids when references tied to real training observations and alternative metrics are relevant;
• aggloKNN when local connectivity, hierarchical grouping and soft membership probabilities are central to the representation.

These are methodological starting points, not performance guarantees.

Conclusion

k-means, k-medoids and aggloKNN begin with a related idea: a tabular sample can be described through its relationship with structures learned from the training set. The nature of that relationship is nevertheless different.

k-means uses distances to synthetic centroids. k-medoids uses distances to representative observations. aggloKNN uses local geometry to construct hierarchical pseudo-labels and then converts those labels into soft KNN probabilities.

These distinctions determine what every pixel means, how the representation responds to distance metrics, whether RBF smoothing is available and how the final image should be interpreted. The correct choice therefore depends on the dataset, the downstream architecture and the experimental objective.

The next post in this series will move from distance-oriented representations to Gaussian Mixtures, Kernel Density Estimation and Factor Analysis, examining probabilities, densities and latent factors as alternative sources of image pixels.

References and resources

1. Salvador Martínez Moreno. Generación de imágenes sintéticas mediante métodos no supervisados para la librería TINTOlib. Master’s Thesis, Universidad Nacional de Educación a Distancia (UNED), 2026.

2. TINTOlib documentation. Clusters. Read the current parameter and API documentation.

Research articles

1. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro, Luis Orozco-Barbosa. Interpretable Hybrid Vision Transformer Architectures for MIMO-Based Indoor Localization using Synthetic Spatial Representations. IEEE Internet of Things. DOI: 10.1109/JIOT.2026.3696106

2. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. A Comprehensive Benchmark of Spatial Encoding Methods for Tabular Data with Deep Neural Networks. Information Fusion. DOI: 10.1016/j.inffus.2025.104088

3. Giovanny Mondragon-Ruiz, Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. Interpretable CNN–KAN hybrid architectures for tabular data with synthetic image encoding. Information Processing and Management. DOI: 10.1016/j.ipm.2026.104954

4. Felipe Escalera-González, Manuel Castillo-Cara, Mariano Rincón-Zamorano, Luis Orozco-Barbosa. PermGrad: Interpretable Hybrid Neural Networks with synthetic images for tabular data. Knowledge-Based Systems. DOI: 10.1016/j.knosys.2026.116507

5. Manuel Castillo-Cara, Jesus Martínez-Gómez, Javier Ballesteros-Jerez, Ismael García-Varea, Raúl García-Castro, Luis Orozco-Barbosa. MIMO-Based Indoor Localisation with Hybrid Neural Networks. IEEE Journal of Selected Topics in Signal Processing. DOI: 10.1109/JSTSP.2025.3555067

6. Reewos Talla-Chumpitaz, Manuel Castillo-Cara, Luis Orozco-Barbosa, Raúl García-Castro. Blurring Image Techniques for Bluetooth-based Indoor Localisation. Information Fusion. DOI: 10.1016/j.inffus.2022.10.011

Software articles

1. Jiayun Liu, David González-Fernández, Manuel Castillo-Cara, Raúl García-Castro. TINTOlib: A Python library for transforming tabular data into synthetic images for deep neural networks. SoftwareX. DOI: 10.1016/j.softx.2025.102444

2. Manuel Castillo-Cara, Reewos Talla-Chumpitaz, Raúl García-Castro, Luis Orozco-Barbosa. TINTO: Converting Tidy Data into Image for Classification with 2-Dimensional Convolutional Neural Networks. SoftwareX. DOI: 10.1016/j.softx.2023.101391

Continue learning Artificial Intelligence

Explore practical courses on AI, Machine Learning, Deep Learning, Python, R and applied data science.

View AI Courses →

Manuel Castillo-Cara, PhD

TINTOlib Python Library Developer

Researcher & Professor

Department of Artificial Intelligence

Universidad Nacional de Educación a Distancia (UNED)

Almerimar (Almería), Spain

© Manuel Castillo-Cara, PhD. Content licensed under CC BY-NC 4.0 unless otherwise stated.

🖨️ Print / Save as PDF 💾 Save as HTML 🐍 Download Python 📓 Notebook (.ipynb)

You may also enjoy

08 Aug 2026 TINTOlib

Part 4 — RGB Fusion and Structural Stability in TINTOlib: mixMethod and SSIM-Based Automatic Selection

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

06 Aug 2026 TINTOlib

Part 3 — Probabilities, Densities and Latent Factors in TINTOlib: gaussianMix, KDE and Factor Analysis

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

20 Jul 2026 TINTOlib

Part 1 - From Clusters to Pixels: Unsupervised Synthetic Image Generation in TINTOlib

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

TINTOlib · Unsupervised Learning · Synthetic Images

From Clusters to Pixels

How distances, membership probabilities, density estimates and latent factors can be converted into synthetic images for vision-based deep learning.

Clusters K-Means K-Medoids RGB Fusion

Tutorial metadata

• Author: Manuel Castillo-Cara, PhD
• Affiliation: Dpt. of Artificial Intelligence, Universidad Nacional de Educación a Distancia (UNED), Spain
• Role: Researcher, Professor, and TINTOlib Python Library Developer
• License: CC BY-NC 4.0 unless otherwise stated.

Series note. This is the first article in a four-part series on the new unsupervised representation methods available through the Clusters class in TINTOlib. The series covers distance-based encodings, probabilistic and latent representations, RGB fusion through mixMethod, and automatic cluster-number selection using SSIM.

Video overview

The following short video summarizes the main concepts introduced in this article.

A new representation family in TINTOlib

Most tabular-to-image methods begin by asking where the original variables should be placed in a two-dimensional canvas. Methods such as TINTO, REFINED and IGTD construct a spatial organization of features and then project the value of each sample onto that layout.

The new Clusters method introduces a complementary perspective. Instead of directly assigning the original variables to image coordinates, it first learns an intermediate unsupervised representation of every sample. This representation may contain:

• distances to learned centroids;
• distances to representative medoids;
• probabilities of belonging to latent groups;
• estimated probability densities;
• latent factor scores;
• or several of these representations combined across RGB channels.

The resulting numerical vector is subsequently scaled, padded when necessary and reshaped into a square image. Therefore, the image does not directly encode the original columns. It encodes how a sample relates to a set of learned references, distributions or latent structures.

This distinction is important. The method is called Clusters, but not all its internal algorithms are conventional clustering procedures. The class also includes density estimation and latent-factor transformations because all of them can produce structured intermediate representations suitable for image generation.

(Figure 1. General workflow of the TINTOlib Clusters method. The original tabular data are standardized, transformed into an unsupervised intermediate representation based on distances, probabilities, densities or latent factors, scaled to pixel intensities and reshaped into grayscale or multi-channel synthetic images.)

The central idea: learn a representation before building the image

Let an original tabular sample be represented by

where $p$ is the number of original variables. The selected unsupervised model learns a transformation

and produces an intermediate vector

The meaning of $q$ depends on the selected algorithm. For example, it may be the number of centroids, medoids, Gaussian components or latent factors. In KDE, the dimensionality is tied to the original features because one density estimator is fitted per variable.

The representation $\mathbf{r}_i$ is then transformed into an image through the following operations:

1. Scale the representation to the range $[0,255]$.

2. Compute the smallest square side capable of containing all values:

   \[d = \left\lceil \sqrt{q} \right\rceil.\]

3. Add zero-padding when $d^2 > q$.

4. Reshape the vector into a $d \times d$ matrix.

5. Convert the matrix to an unsigned 8-bit image.

6. In mixMethod, repeat the process independently for each selected method and stack the results into the RGB channels.

This design creates a common visual interface for heterogeneous unsupervised models.

Seven algorithms, four representation families

The current implementation supports seven strategies. They can be organized into four conceptual families.

(Figure 2. Conceptual organization of the seven strategies supported by the Clusters class. Distance-based, probabilistic, density-based and latent representations provide different views of the internal structure of tabular data, while mixMethod integrates complementary views into a single RGB image.)

Distance-based representations

The kmeans and kmedoids variants describe a sample through its distance to a set of learned references. In kmeans, those references are synthetic centroids. In kmedoids, they are real observations selected from the training data.

A distance vector carries more information than a hard cluster label. Two samples assigned to different groups can still have similar distance profiles, and two samples assigned to the same group may relate differently to the remaining clusters.

In grayscale mode, TINTOlib reorders the centroid- or medoid-based dimensions according to reference proximity before reshaping them. The goal is to place related reference regions close to each other in the generated image.

Probabilistic representations

The gaussianMix method replaces distances with posterior membership probabilities. Each pixel indicates the degree to which a sample belongs to one Gaussian component.

The aggloKNN method follows a two-stage procedure. It first applies agglomerative clustering constrained by a nearest-neighbour connectivity graph. The resulting cluster assignments are then treated as pseudo-labels for a KNN classifier, whose probability output becomes the intermediate representation.

Probabilities provide a softer description than hard labels and can capture uncertainty near cluster boundaries.

Density and latent representations

The kde method fits a one-dimensional kernel-density estimator to every feature. Each original value is replaced by its estimated density under the training distribution. The resulting image therefore encodes how common or unusual the values of a sample are, rather than their raw magnitudes.

The factor method projects the original data into a lower-dimensional latent space using Factor Analysis. Its pixels correspond to factor scores that summarize shared variation among the original variables.

Multi-channel representations

The mixMethod strategy combines between one and three non-repeated methods in an RGB image. Each method fills one colour channel. If fewer than three representations are selected, the remaining channels are filled with zeros.

For example:

• red channel: distances to k-means centroids;
• green channel: Gaussian-mixture membership probabilities;
• blue channel: latent factor scores.

This produces a multi-view image in which colour reflects the interaction among different unsupervised descriptions of the same sample.

(Figure 3. Comparison between single-channel and multi-channel image generation. Individual methods produce grayscale images, whereas mixMethod assigns complementary unsupervised representations to the red, green and blue channels of one synthetic image.)

Why this is different from direct feature-to-pixel mapping

The distinction between spatial feature mapping and cluster-based representation can be summarized as follows.

Neither paradigm is universally preferable. They encode different inductive assumptions and should be compared under the same leakage-free experimental protocol.

First practical example: k-means with RBF smoothing

The following example uses the Wine dataset from Scikit-Learn. We first divide the data into training and test partitions. The Clusters transformation is then fitted only on the training partition, and the learned model is reused to transform both sets.

from pathlib import Path

import pandas as pd
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split

from TINTOlib.clusters import Clusters

# ---------------------------------------------------------
# 1. Load the tabular dataset
# ---------------------------------------------------------
raw_data = load_wine()

df = pd.DataFrame(
    raw_data.data,
    columns=raw_data.feature_names
)

# The target column must be the final column.
df["target"] = raw_data.target

# ---------------------------------------------------------
# 2. Split before fitting the transformation
# ---------------------------------------------------------
train_df, test_df = train_test_split(
    df,
    test_size=0.20,
    random_state=42,
    stratify=df["target"]
)

# ---------------------------------------------------------
# 3. Configure the cluster-based image transformation
# ---------------------------------------------------------
model = Clusters(
    problem="classification",
    algorithm="kmeans",
    n_clusters=25,
    random_seed=1,
    n_init="auto",
    max_iter=300,
    algorithmMethod="lloyd",
    RBFKmeans=True
)

# ---------------------------------------------------------
# 4. Learn the representation from training data only
# ---------------------------------------------------------
model.fit(train_df)

# ---------------------------------------------------------
# 5. Generate training and test images consistently
# ---------------------------------------------------------
train_output = Path("synthetic_images/clusters_kmeans/train")
test_output = Path("synthetic_images/clusters_kmeans/test")

model.transform(train_df, str(train_output))
model.transform(test_df, str(test_output))

print("Cluster-based synthetic images generated successfully.")

With n_clusters=25, every sample is initially represented by 25 distances to the learned centroids. These values fit naturally into a (5 \times 5) image. When RBFKmeans=True, the distance representation is converted into Gaussian radial similarities before pixel scaling, emphasizing nearby centroids and attenuating distant ones.

A useful comparison is to generate the same sample both with and without RBF:

plain_kmeans = Clusters(
    problem="classification",
    algorithm="kmeans",
    n_clusters=25,
    random_seed=1,
    RBFKmeans=False
)

rbf_kmeans = Clusters(
    problem="classification",
    algorithm="kmeans",
    n_clusters=25,
    random_seed=1,
    RBFKmeans=True
)

The first image encodes distances directly; the second emphasizes local similarities.

(Figure 4. Representative synthetic images generated from the same tabular sample using kmeans, kmedoids, aggloKNN, gaussianMix, kde, factor and mixMethod. The visual differences arise because each algorithm encodes a different intermediate property of the sample: proximity, membership probability, statistical density, latent structure or multi-view fusion.)

Switching between algorithms

TINTOlib uses one class and a common fit/transform workflow. The main change is the algorithm-specific configuration.

models = {
    "kmeans": Clusters(
        problem="classification",
        algorithm="kmeans",
        n_clusters=25,
        RBFKmeans=True
    ),

    "kmedoids": Clusters(
        problem="classification",
        algorithm="kmedoids",
        n_clusters=25,
        metric="euclidean"
    ),

    "gaussianMix": Clusters(
        problem="classification",
        algorithm="gaussianMix",
        n_clusters=25,
        covariance_type="full"
    ),

    "aggloKNN": Clusters(
        problem="classification",
        algorithm="aggloKNN",
        n_clusters=25,
        metric="cosine"
    ),

    "kde": Clusters(
        problem="classification",
        algorithm="kde",
        kernel="gaussian",
        bandwidth=1.0,
        metric="euclidean"
    ),

    "factor": Clusters(
        problem="classification",
        algorithm="factor",
        n_clusters=9,
        random_seed=1
    ),

    "mixMethod": Clusters(
        problem="classification",
        algorithm="mixMethod",
        n_clusters=25,
        ensamMethod=["kmeans", "gaussianMix", "factor"],
        RBFKmeans=True,
        covariance_type="full"
    )
}

Not every parameter applies to every algorithm. The constructor validates incompatible combinations so that configuration errors are detected early.

Parameter compatibility at a glance

Current implementation note. Automatic cluster-number selection is not available for kde or aggloKNN. KDE does not use n_clusters, and aggloKNN currently requires an explicit integer value.

Automatic cluster-number selection with SSIM

For compatible algorithms, n_clusters may be:

• a fixed integer;
• the string "auto";
• or a list of candidate integers.

When automatic selection is requested, TINTOlib generates representations under several random initializations and evaluates their structural stability using the Structural Similarity Index Measure (SSIM). The selected number of clusters is the one that produces the most stable synthetic images across runs.

For example:

model = Clusters(
    problem="classification",
    algorithm="kmeans",
    n_clusters=[9, 16, 25, 36, 49],
    random_seed=1,
    RBFKmeans=True
)

This is not simply a search for the clustering solution with the lowest internal objective. It evaluates the model from the perspective of the final artifact: the structural consistency of the generated images.

The complete SSIM procedure will be examined in the fourth post of this series.

Methodological note: prevent data leakage

The cluster model, scaling objects, density estimators and latent projections must be learned exclusively from the training partition.

The correct sequence is:

1. Split the original tabular data.
2. Fit Clusters on the training set.
3. Generate training images using the fitted transformation.
4. Transform validation and test samples with exactly the same learned objects.
5. Train the visual model only on the training images.
6. Report performance on untouched validation or test images.

Using fit_transform on the complete dataset before splitting would expose the transformation to the evaluation samples. That can leak information through centroids, medoids, density estimates, Gaussian components, latent factors or scaling ranges.

(Figure 5. Leakage-free experimental workflow. The unsupervised representation and its associated scaling operations are fitted only on the training partition and then reused without refitting to generate validation and test images.)

Which representation should I try first?

The following table provides an initial decision guide. It should be treated as a practical starting point, not as a universal ranking.

The transformation should always be assessed together with:

• strong tabular baselines such as XGBoost, LightGBM, CatBoost and Random Forest;
• an MLP trained on the original features;
• several image-based architectures;
• repeated runs and uncertainty estimates;
• computational cost;
• and ablation studies over the main transformation parameters.

How should these methods be evaluated?

The experimental study that motivated these additions evaluated the proposed transformations on regression, binary-classification and multiclass-classification datasets using a specific Vision Transformer architecture. These experiments provide an initial validation of the feasibility of converting unsupervised representations into synthetic images, but they should not be interpreted as a definitive ranking among transformation methods.

A transformation that behaves well with a particular Vision Transformer configuration may exhibit a different behaviour when combined with:

• convolutional neural networks;
• hybrid tabular–image architectures;
• alternative Vision Transformer designs;
• different image resolutions;
• other optimization strategies;
• or datasets with different dimensionality, sample size and feature distributions.

For this reason, the purpose of this series is to present the assumptions, representations, parameters and practical implementation of each method rather than to identify a universally superior alternative.

A rigorous comparison should evaluate every transformation under comparable conditions, include several downstream architectures, report repeated runs and uncertainty estimates, and retain strong classical tabular baselines. The relevant question is therefore not which method is always best, but which representation is most appropriate for a specific dataset, neural architecture and experimental objective.

Roadmap for this four-part series

Part I — From Clusters to Pixels

• Unified conceptual framework.
• Seven supported algorithms.
• Grayscale and RGB image generation.
• First implementation with k-means.
• Leakage-free experimental design.

Part II — Distance-Based Encodings

• kmeans, kmedoids and aggloKNN.
• Centroids versus medoids.
• Distance metrics and local connectivity.
• RBF smoothing.
• Side-by-side image and performance comparisons.

Part III — Probabilities, Densities and Latent Factors

• gaussianMix, kde and factor.
• Membership probabilities and covariance structures.
• KDE kernels and bandwidth.
• Factor scores and latent representations.
• When probabilistic encodings become sparse or highly discrete.

Part IV — RGB Fusion and Structural Stability

• mixMethod and multi-channel images.
• Channel selection and interpretability.
• Automatic n_clusters selection.
• SSIM stability.
• Experimental conclusions, limitations and future directions.

Conclusion

The new Clusters method expands TINTOlib beyond direct feature-layout strategies. Its main contribution is a unified mechanism for turning heterogeneous unsupervised representations into synthetic images.

Distances, membership probabilities, density estimates and latent factors emphasize different aspects of the same tabular sample. Once converted into pixels, these representations can be processed by CNNs, Vision Transformers or hybrid neural networks. However, the transformation itself becomes part of the learning pipeline and must therefore be selected, fitted and evaluated with the same methodological rigor as the downstream predictive model.

The most relevant question is not whether clustering can produce an image. It is whether a particular unsupervised representation preserves information that a visual architecture can exploit more effectively, robustly or interpretably than alternative tabular representations.

References and resources

1. Salvador Martínez Moreno. Generación de imágenes sintéticas mediante métodos no supervisados para la librería TINTOlib. Master’s Thesis, Universidad Nacional de Educación a Distancia (UNED), 2026.

2. TINTOlib documentation. Clusters. Read the current parameter and API documentation.

Research articles

1. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro, Luis Orozco-Barbosa. Interpretable Hybrid Vision Transformer Architectures for MIMO-Based Indoor Localization using Synthetic Spatial Representations. IEEE Internet of Things. DOI: 10.1109/JIOT.2026.3696106

2. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. A Comprehensive Benchmark of Spatial Encoding Methods for Tabular Data with Deep Neural Networks. Information Fusion. DOI: 10.1016/j.inffus.2025.104088

3. Giovanny Mondragon-Ruiz, Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. Interpretable CNN–KAN hybrid architectures for tabular data with synthetic image encoding. Information Processing and Management. DOI: 10.1016/j.ipm.2026.104954

4. Felipe Escalera-González, Manuel Castillo-Cara, Mariano Rincón-Zamorano, Luis Orozco-Barbosa. PermGrad: Interpretable Hybrid Neural Networks with synthetic images for tabular data. Knowledge-Based Systems. DOI: 10.1016/j.knosys.2026.116507

5. Manuel Castillo-Cara, Jesus Martínez-Gómez, Javier Ballesteros-Jerez, Ismael García-Varea, Raúl García-Castro, Luis Orozco-Barbosa. MIMO-Based Indoor Localisation with Hybrid Neural Networks. IEEE Journal of Selected Topics in Signal Processing. DOI: 10.1109/JSTSP.2025.3555067

6. Reewos Talla-Chumpitaz, Manuel Castillo-Cara, Luis Orozco-Barbosa, Raúl García-Castro. Blurring Image Techniques for Bluetooth-based Indoor Localisation. Information Fusion. DOI: 10.1016/j.inffus.2022.10.011

Software articles

1. Jiayun Liu, David González-Fernández, Manuel Castillo-Cara, Raúl García-Castro. TINTOlib: A Python library for transforming tabular data into synthetic images for deep neural networks. SoftwareX. DOI: 10.1016/j.softx.2025.102444

2. Manuel Castillo-Cara, Reewos Talla-Chumpitaz, Raúl García-Castro, Luis Orozco-Barbosa. TINTO: Converting Tidy Data into Image for Classification with 2-Dimensional Convolutional Neural Networks. SoftwareX. DOI: 10.1016/j.softx.2023.101391

Continue learning Artificial Intelligence

Explore practical courses on AI, Machine Learning, Deep Learning, Python, R and applied data science.

View AI Courses →

Manuel Castillo-Cara, PhD

TINTOlib Python Library Developer

Researcher & Professor

Department of Artificial Intelligence

Universidad Nacional de Educación a Distancia (UNED)

Almerimar (Almería), Spain

© Manuel Castillo-Cara, PhD. Content licensed under CC BY-NC 4.0 unless otherwise stated.

🖨️ Print / Save as PDF 💾 Save as HTML 🐍 Download Python 📓 Notebook (.ipynb)

You may also enjoy

08 Aug 2026 TINTOlib

Part 4 — RGB Fusion and Structural Stability in TINTOlib: mixMethod and SSIM-Based Automatic Selection

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

06 Aug 2026 TINTOlib

Part 3 — Probabilities, Densities and Latent Factors in TINTOlib: gaussianMix, KDE and Factor Analysis

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

24 Jul 2026 TINTOlib

Part 2 — Distance-Based Encodings in TINTOlib: k-Means, k-Medoids and aggloKNN

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

TINTOlib · Synthetic Images · Tabular Data

TINTO vs REFINED vs IGTD

A methodological comparison of three representative tabular data into synthetic image methods for generating synthetic images from tabular data.

TINTO REFINED IGTD TINTOlib

Tutorial metadata

• Author: Manuel Castillo-Cara, PhD
• Affiliation: Dpt. of Artificial Intelligence, Universidad Nacional de Educación a Distancia (UNED), Spain
• Role: Researcher, Professor, and TINTOlib Python Library Developer
• License: CC BY-NC 4.0 unless otherwise stated.

Video overview

This post provides a comprehensive methodological comparison derived from our ongoing research on spatial encoding strategies within the TINTOlib ecosystem.

The following short video provides an English overview of the core architectural paradigms compared across this tutorial: how different parametric mapping techniques—namely TINTO, REFINED, and IGTD—construct entirely distinct spatial layouts from the same underlying tabular dataset, and how these unique image topologies influence downstream deep learning pipelines, hybrid neural networks, and visual explainability (XAI) frameworks.

Additional material. The original technical workflow and benchmark code are fully documented in our open-source repositories. This blog post provides the corresponding English technical synthesis, pipeline formalization, and a decision map to help you select the optimal transformation method for your tabular data.

The challenge of organizing tabular space

As discussed in previous posts, applying computer vision architectures —such as Convolutional Neural Networks (CNNs) or Vision Transformers (ViTs)— to classical tabular datasets is not straightforward. The main reason is methodological: tabular data do not have an intrinsic spatial structure.

In natural images, neighbouring pixels usually encode meaningful local relationships: edges, textures, shapes or spatial continuity. In tabular data, however, the order of the columns is often arbitrary. If we simply reshape a row of numerical values into a square matrix, we are imposing a spatial topology that may not correspond to any real relationship among the original variables.

This is precisely the problem addressed by tabular data into synthetic image transformation methods. These algorithms aim to arrange tabular features on a two-dimensional grid so that spatial proximity reflects some form of statistical, geometric or relational similarity among variables.

(Figure 1. Conceptual illustration of the core problem in tabular data into synthetic image transformation. A raw tabular vector has no intrinsic spatial neighbourhood, so directly reshaping it into a matrix may impose arbitrary local relationships. Spatial encoding methods aim to construct a more meaningful two-dimensional layout before applying vision-based models.)

In this post, we compare three representative methods implemented in TINTOlib:

• TINTO, based on dimensionality reduction and optional blurring.
• REFINED, based on distance-preserving geometric optimization.
• IGTD, based on preserving the ranking of feature relationships in a dense image layout.

The objective is not to claim that one method is universally superior, but to understand their different assumptions, strengths, computational costs and practical use cases.

(Figure 2. Synthetic image representations generated from the same tabular sample using TINTO, REFINED and IGTD. Although all three methods pursue the same objective —constructing a spatial representation from tabular features— they produce different image topologies due to their distinct optimization criteria and spatial encoding assumptions.)

1. TINTO: dimensionality reduction and blurring

TINTO addresses the tabular data into synthetic image problem by projecting the features of the dataset into a two-dimensional space using dimensionality-reduction techniques such as PCA or t-SNE. Once the features have been located in a continuous coordinate space, their positions are mapped to a discrete image grid.

How it works

The general workflow followed by TINTO can be summarized as follows:

1. A feature-level representation is constructed from the original tabular dataset.
2. Dimensionality reduction is applied to obtain two-dimensional coordinates for the features.
3. These coordinates are scaled and mapped onto an image grid of size (N \times N).
4. Each tabular sample is converted into an image by placing the feature values in their corresponding spatial positions.
5. Optional blurring is applied to diffuse feature intensities across neighbouring pixels.

The blurring step is particularly relevant. When two or more features are projected into nearby or overlapping coordinates, direct pixel assignment can produce sparse or unstable representations. Blurring spreads the feature intensity over local neighbourhoods, creating smoother synthetic images and making local patterns more accessible to convolutional filters.

(Figure 3. TINTO transformation pipeline. Features are projected into a two-dimensional space using PCA or t-SNE, mapped onto a discrete image grid, and optionally smoothed through blurring to generate synthetic images with local spatial continuity.)

Strengths and limitations

TINTO is especially useful when the objective is to generate visually interpretable synthetic images and to experiment rapidly with different spatial configurations. It is flexible, relatively efficient, and well suited for hybrid neural architectures that combine the original tabular vector with the generated synthetic image.

However, the final representation depends on the selected dimensionality-reduction algorithm, the image size, the blurring configuration and the characteristics of the dataset. As with any tabular data into synthetic image method, these hyperparameters should be evaluated under a rigorous validation protocol.

2. REFINED: geometric mapping and neighbourhood dependencies

REFINED stands for REpresentation of Features as Images with NEighborhood Dependencies. It was originally proposed as a way to represent high-dimensional tabular data as images by preserving feature relationships in a spatial layout.

Unlike direct reshaping approaches, REFINED tries to construct a meaningful feature map where spatial proximity reflects similarity or dependency among variables. It has been especially influential in biomedical, chemical and omics-related datasets, where high-dimensional feature spaces are common.

How it works

A simplified REFINED workflow can be described as follows:

1. A dissimilarity or distance matrix is computed among features.
2. A dimensionality-reduction or multidimensional-scaling step is used to generate an initial two-dimensional feature map.
3. An iterative optimization process adjusts the location of features on the grid.
4. The objective is to preserve the original feature relationships as faithfully as possible in the image space.
5. Each sample is converted into an image by filling the feature positions with the corresponding sample values.

The optimization process used by REFINED is more computationally demanding than a simple projection, but it can produce layouts that better preserve both local and global relationships among variables.

(Figure 4. REFINED transformation pipeline. Feature relationships are first represented through a distance or dissimilarity matrix. A two-dimensional map is then optimized so that neighbouring pixels encode variables with strong statistical or geometric relationships.)

Strengths and limitations

REFINED is particularly attractive when the preservation of distance relationships among features is important. It can be useful in domains where variables have complex dependency structures and where a carefully optimized spatial map may improve the behaviour of convolutional architectures.

Its main limitation is computational cost. For datasets with thousands of features, the optimization process can become expensive. In addition, the quality of the resulting representation depends on the distance metric, the optimization strategy and the resolution of the image grid.

3. IGTD: Image Generator for Tabular Data

IGTD (Image Generator for Tabular Data) follows a different strategy. Instead of relying mainly on dimensionality reduction or geometric projection, IGTD aims to preserve the ranking of feature relationships when assigning features to image pixels.

The central idea is that if two features are highly similar in the original tabular space, they should be placed close to each other in the image grid. Conversely, features that are less related should be placed farther apart.

How it works

The IGTD workflow can be summarized as follows:

1. A feature-similarity or feature-distance matrix is computed from the tabular dataset.
2. A target image grid is defined.
3. Each feature is assigned to a unique pixel in the grid.
4. The method iteratively swaps feature positions to reduce the discrepancy between:
   • the ranking of feature distances in the original tabular space;
   • the ranking of pixel distances in the image space.
5. The final image representation is dense: each selected feature occupies one pixel.

This makes IGTD especially suitable when compact image representations are desired. Unlike methods that may create sparse images or require blurring, IGTD tends to generate dense grids where most pixels carry feature information.

(Figure 5. IGTD transformation pipeline. The method searches for a dense assignment of features to pixels by minimizing the discrepancy between feature-distance rankings in the original tabular space and spatial-distance rankings in the generated image.)

Strengths and limitations

IGTD is useful when the objective is to create compact synthetic images with a direct relationship between features and pixels. This can reduce the input size required by CNNs and improve computational efficiency during neural training.

However, the optimization process can still be costly for high-dimensional datasets. In addition, the resulting images may be less visually intuitive than TINTO representations, especially when the grid is very dense or when feature relationships are complex.

Comparative pipeline overview

Although TINTO, REFINED and IGTD all transform tabular samples into images, their assumptions are different. TINTO emphasizes projection and optional smoothing. REFINED emphasizes distance-preserving spatial optimization. IGTD emphasizes dense pixel assignment based on ranking preservation.

Comparative summary

(Figure 6. Practical decision map for selecting among TINTO, REFINED and IGTD depending on the experimental objective. The choice depends on whether the priority is fast experimentation, distance-preserving spatial optimization, dense image construction, interpretability, or computational efficiency.)

Methodological note: avoid data leakage

A critical issue in tabular data into synthetic image transformation is data leakage.

If the spatial layout of the features is learned using the full dataset before splitting into training and test partitions, information from the test set may influence the generated image representation. This can lead to overly optimistic results and invalid generalization estimates.

For rigorous experimentation, the recommended workflow is:

1. Split the original tabular dataset into training and test partitions.
2. Fit the tabular data into synthetic images transformation only on the training data.
3. Apply the learned transformation to both training and test data.
4. Train the neural model using only the generated training images.
5. Evaluate the final model on the generated test images.

This principle is especially important when comparing TINTO, REFINED and IGTD, because the comparison should reflect the generalization capacity of each representation, not hidden information transferred from the test set.

Practical implementation in Python with TINTOlib

One of the main advantages of TINTOlib is that it provides a unified interface for different tabular data into synthetic image transformation methods. This makes it possible to compare TINTO, REFINED and IGTD within a common experimental workflow.

The following example uses the Breast Cancer Wisconsin dataset from Scikit-Learn. The key methodological point is that the train/test split is performed before fitting any transformation.

import os
import pandas as pd

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

from TINTOlib.tinto import TINTO
from TINTOlib.igtd import IGTD
from TINTOlib.refined import REFINED

# ---------------------------------------------------------
# 1. Load a reproducible tabular dataset
# ---------------------------------------------------------
raw_data = load_breast_cancer()

df = pd.DataFrame(raw_data.data, columns=raw_data.feature_names)
df["target"] = raw_data.target

# ---------------------------------------------------------
# 2. Split before fitting any tabular data into synthetic images transformation
# ---------------------------------------------------------
train_df, test_df = train_test_split(
    df,
    test_size=0.2,
    random_state=42,
    stratify=df["target"]
)

# ---------------------------------------------------------
# 3. Create output folders
# ---------------------------------------------------------
output_dirs = {
    "TINTO": {
        "train": "synthetic_images/tinto/train",
        "test": "synthetic_images/tinto/test"
    },
    "IGTD": {
        "train": "synthetic_images/igtd/train",
        "test": "synthetic_images/igtd/test"
    },
    "REFINED": {
        "train": "synthetic_images/refined/train",
        "test": "synthetic_images/refined/test"
    }
}

for method_dirs in output_dirs.values():
    os.makedirs(method_dirs["train"], exist_ok=True)
    os.makedirs(method_dirs["test"], exist_ok=True)

# ---------------------------------------------------------
# 4. Define the transformation methods
# ---------------------------------------------------------
methods = {
    "TINTO": TINTO(
        problem="supervised",
        algorithm="t-SNE",
        pixels=30,
        blur=True
    ),
    "IGTD": IGTD(
        problem="supervised"
    ),
    "REFINED": REFINED(
        problem="supervised"
    )
}

# ---------------------------------------------------------
# 5. Fit each method only on the training partition
#    and then transform both train and test partitions
# ---------------------------------------------------------
for method_name, model in methods.items():
    print(f"Generating synthetic images with {method_name}...")

    model.fit(train_df)

    model.transform(
        train_df,
        output_dirs[method_name]["train"]
    )

    model.transform(
        test_df,
        output_dirs[method_name]["test"]
    )

print("Synthetic image generation completed successfully.")

The generated image folders can then be used with standard PyTorch or TensorFlow pipelines, for example through torchvision.datasets.ImageFolder or custom dataset loaders.

After executing the transformation pipeline, each method generates a different synthetic image representation from the original tabular samples. Although the input data are the same, the resulting images are not visually equivalent, because each method follows a different criterion to organize the features in the image space.

• IGTD produces compact grid-like representations where the feature-to-pixel assignment is guided by the preservation of distance relationships.
• REFINED generates spatial layouts where the arrangement of features is optimized according to pairwise relationships among variables.
• TINTO creates structured synthetic images with an explicit visual encoding, where dimensionality reduction and optional blurring help introduce spatial continuity.

The following figure illustrates these differences by showing representative synthetic images generated with the three methods. The goal is not to decide which image is visually more appealing, but to highlight that each method creates a different spatial topology. These topologies may affect how CNNs, Vision Transformers or hybrid neural networks learn from the transformed tabular data.

(Figure 7. Visual comparison of synthetic images generated with IGTD, REFINED and TINTO. Each method transforms the same type of tabular data into a different image topology, reflecting its own spatial encoding criterion and potentially influencing how vision-based neural models learn from the generated representations.)

Practical interpretation

From a practical point of view, the three methods should be seen as complementary rather than mutually exclusive:

• Use TINTO when the objective is fast experimentation, visual interpretability and flexible synthetic image generation.
• Use REFINED when the dataset contains complex feature relationships and the preservation of geometric distances is central to the experiment.
• Use IGTD when dense and compact image representations are needed, especially for efficient CNN-based training.

In all cases, the generated images should be evaluated against strong tabular baselines such as Random Forest, XGBoost, LightGBM or CatBoost. Synthetic images are not automatically superior to classical models; their value depends on whether the spatial representation helps the neural architecture exploit meaningful feature interactions.

Conclusion

TINTO, REFINED and IGTD represent three different ways of addressing the same fundamental question: how can we construct a meaningful spatial representation from tabular data?

TINTO provides a flexible and visually intuitive transformation based on dimensionality reduction and optional blurring. REFINED focuses on preserving feature relationships through geometric optimization. IGTD generates dense image layouts by aligning feature-similarity rankings with pixel-distance rankings.

The key point is that these methods should not be evaluated only by the visual appearance of the generated images. They must be assessed through rigorous experimental protocols, strong tabular baselines, leakage-free validation, and downstream performance using CNNs, Vision Transformers or hybrid neural architectures.

TINTOlib makes this comparison practical by providing a unified framework where different tabular data into synthetic image methods can be tested under comparable conditions. This is essential for understanding when synthetic images are genuinely useful, when they provide interpretable spatial structure, and when classical tabular models may still remain the strongest baseline.

References and related publications

The concepts discussed in this tutorial are connected to the following research and software publications on TINTO, TINTOlib, tabular data into synthetic images transformation, synthetic spatial representations, hybrid neural networks and indoor localisation.

Research articles

1. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro, Luis Orozco-Barbosa. Interpretable Hybrid Vision Transformer Architectures for MIMO-Based Indoor Localization using Synthetic Spatial Representations. IEEE Internet of Things. DOI: 10.1109/JIOT.2026.3696106

2. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. A Comprehensive Benchmark of Spatial Encoding Methods for Tabular Data with Deep Neural Networks. Information Fusion. DOI: 10.1016/j.inffus.2025.104088

3. Giovanny Mondragon-Ruiz, Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. Interpretable CNN–KAN hybrid architectures for tabular data with synthetic image encoding. Information Processing and Management. DOI: 10.1016/j.ipm.2026.104954

4. Felipe Escalera-González, Manuel Castillo-Cara, Mariano Rincón-Zamorano, Luis Orozco-Barbosa. PermGrad: Interpretable Hybrid Neural Networks with synthetic images for tabular data. Knowledge-Based Systems. DOI: 10.1016/j.knosys.2026.116507

5. Manuel Castillo-Cara, Jesus Martínez-Gómez, Javier Ballesteros-Jerez, Ismael García-Varea, Raúl García-Castro, Luis Orozco-Barbosa. MIMO-Based Indoor Localisation with Hybrid Neural Networks. IEEE Journal of Selected Topics in Signal Processing. DOI: 10.1109/JSTSP.2025.3555067

6. Reewos Talla-Chumpitaz, Manuel Castillo-Cara, Luis Orozco-Barbosa, Raúl García-Castro. Blurring Image Techniques for Bluetooth-based Indoor Localisation. Information Fusion. DOI: 10.1016/j.inffus.2022.10.011

Software articles

1. Jiayun Liu, David González-Fernández, Manuel Castillo-Cara, Raúl García-Castro. TINTOlib: A Python library for transforming tabular data into synthetic images for deep neural networks. SoftwareX. DOI: 10.1016/j.softx.2025.102444

2. Manuel Castillo-Cara, Reewos Talla-Chumpitaz, Raúl García-Castro, Luis Orozco-Barbosa. TINTO: Converting Tidy Data into Image for Classification with 2-Dimensional Convolutional Neural Networks. SoftwareX. DOI: 10.1016/j.softx.2023.101391

Continue learning Artificial Intelligence

Explore practical courses on AI, Machine Learning, Deep Learning, Python, R and applied data science.

View AI Courses →

Manuel Castillo-Cara, PhD

TINTOlib Python Library Developer

Researcher & Professor

Department of Artificial Intelligence

Universidad Nacional de Educación a Distancia (UNED)

Almerimar (Almería), Spain

© Manuel Castillo-Cara, PhD. Content licensed under CC BY-NC 4.0 unless otherwise stated.

🖨️ Print / Save as PDF 💾 Save as HTML 🐍 Download Python 📓 Notebook (.ipynb)

You may also enjoy

08 Aug 2026 TINTOlib

Part 4 — RGB Fusion and Structural Stability in TINTOlib: mixMethod and SSIM-Based Automatic Selection

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

06 Aug 2026 TINTOlib

Part 3 — Probabilities, Densities and Latent Factors in TINTOlib: gaussianMix, KDE and Factor Analysis

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

24 Jul 2026 TINTOlib

Part 2 — Distance-Based Encodings in TINTOlib: k-Means, k-Medoids and aggloKNN

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

TINTOlib · Hybrid Neural Networks · Explainable AI

From Synthetic Images to Hybrid Neural Networks

Part II — How TINTOlib transforms tabular data into spatial representations, which methods should be preferred, and how CNNs, ViTs and XAI fit into the pipeline.

Synthetic Images CNN Vision Transformer XAI

• Author: Manuel Castillo-Cara, PhD
• Affiliation: Dpt. of Artificial Intelligence, Universidad Nacional de Educación a Distancia (UNED), Spain
• Role: Researcher, Professor, and TINTOlib Python Library Developer
• License: CC BY-NC 4.0 unless otherwise stated.

Video overview

This post is part of a two-part technical summary derived from the conference Improving Deep Learning by Exploiting Synthetic Images, delivered in Peru.

The following short video provides an English overview of the main ideas discussed across both posts: why tabular data remains challenging for deep learning, how synthetic images can introduce spatial representations, and how TINTOlib connects structured data with computer vision, hybrid neural networks and explainable AI.

Additional material. The original conference recording is available in Spanish. The two blog posts provide an English technical synthesis and discussion based on that conference.

Open the original conference recording in SharePoint

From theory to modelling

Part I introduced the theoretical motivation behind synthetic images for tabular data. The central point was that deep learning does not fail on tabular data because it is weak, but because many of its most successful architectures require structural assumptions that tables do not naturally provide.

This second part moves from the theoretical problem to the modelling pipeline. Once we accept that representation is central, the next questions are more practical:

• How should the spatial representation be constructed?
• Which transformation methods are methodologically preferable?
• How can synthetic images be connected with CNNs, Vision Transformers and hybrid neural networks?
• How can visual explainability be mapped back to original tabular variables?

These questions define the practical contribution of TINTOlib.

TINTOlib as an experimental framework

TINTOlib is not only a library for generating images. It is a framework for experimenting with a family of spatial representations for tabular data.

The value of a unified framework is methodological. Before TINTOlib, many tabular-to-image methods were implemented in separate repositories, with different APIs, assumptions and preprocessing requirements. This made systematic comparison difficult. TINTOlib provides a common interface that allows researchers to instantiate different methods, generate synthetic datasets and evaluate downstream architectures under more controlled conditions.

A typical experimental pipeline contains four stages:

Original tabular dataset
      |
      | train / validation / test split
      v
Fit spatial transformation only on training data
      |
      | transform each split
      v
Synthetic image dataset
      |
      | CNN / ViT / HyNN / XAI
      v
Evaluation and interpretation

The separation between fitting and transforming is essential. The spatial layout must be learned only from the training data. If the validation or test set participates in the construction of the feature layout, data leakage occurs. The model would indirectly access information from the evaluation split before prediction.

Preferred families of spatial encodings

The most important methodological distinction is between methods that learn or optimize the spatial structure of the features and methods that remain dependent on the arbitrary column order.

Methods such as TINTO, DeepInsight, IGTD, REFINED, Fotomics and recent unsupervised learning-based approaches such as Clusters are preferable when the goal is to build a spatial representation that reflects relationships in the data. They attempt to place related features close to one another through dimensionality reduction, similarity preservation, manifold learning, optimization or unsupervised representation learning.

This is the family of methods that best addresses the original problem. If tabular data have no natural spatial structure, the transformation method should construct one from the data, not inherit one from the arbitrary table layout.

By contrast, BarGraph, DistanceMatrix, Combination, SuperTML, BIE and FeatureWrap are more dependent on the original feature arrangement or on encoding schemes that can be influenced by how variables are ordered. These approaches can still be useful for comparison, teaching or specific datasets with meaningful order, but they should not be the first choice when working with generic tabular data whose column order is arbitrary.

The distinction can be summarized as follows:

Order-dependent encodings
    |
    | risk: inherit arbitrary column order
    v
Useful as baselines, but not recommended as primary methods for unordered tables

Data-driven spatial encodings
    |
    | objective: learn or optimize feature geometry
    v
Recommended for rigorous tabular-to-image experimentation

The methodological distinction becomes clearer when we compare the visual outputs of different transformation families. Some approaches generate images by imposing relatively direct or handcrafted encodings over the original feature arrangement. These methods can be useful for comparison, teaching, or specific datasets with meaningful feature order, but they may remain sensitive to the arbitrary ordering of the tabular columns.

Other methods attempt to construct a spatial representation from the data structure itself. In this second family, the image is not merely a visual formatting of the table; it is the result of a projection, optimization, similarity-preserving transformation, or unsupervised representation learning process. This distinction is central when synthetic images are used as input to CNNs, Vision Transformers, or hybrid neural architectures.

(Figure 1. Examples of supervised tabular-to-image transformation methods available in the TINTOlib ecosystem. These methods generate synthetic image representations from structured data, but they differ substantially in how they define or learn the spatial arrangement of the original variables. The methodological relevance of each image depends not only on its visual appearance, but also on whether its spatial structure reflects meaningful relationships between features.)

(Figure 2. Examples of unsupervised tabular-to-image transformation methods. Unlike encodings that directly inherit the original column order, data-driven spatial methods aim to construct image-like representations from statistical, geometric or neighbourhood relationships among variables. This is essential when the original table has no natural spatial layout.)

Why blurring matters

One of the distinctive aspects of the TINTO method is the use of blurring. Blurring should not be understood as a cosmetic operation. It has a representational role.

When a feature value is projected into a pixel grid, the resulting image may be sparse or discontinuous. Blurring smooths local regions and can create more continuous spatial patterns. This may help convolutional filters detect local structures more effectively, because the information is not restricted to isolated pixels.

From a neural network perspective, blurring can be understood as a way of inducing local continuity. It transforms a discrete feature placement into a smoother visual signal. This does not guarantee better performance, but it creates a representation that is more aligned with the assumptions of convolutional processing.

The important point is that blurring must be evaluated empirically. Its usefulness may depend on the dataset, the image size, the density of the feature layout and the architecture used downstream.

Connecting synthetic images with CNNs and Vision Transformers

Once the tabular dataset has been transformed into synthetic images, several visual architectures become available.

A CNN processes the synthetic image through convolutional filters. If the feature layout has been constructed properly, nearby pixels may correspond to related variables, and local filters may capture interactions between them.

A Vision Transformer processes the image as a set of patches. This makes it possible to model longer-range relationships between regions of the synthetic image. For larger synthetic images or richer feature layouts, attention mechanisms may capture interactions that are not strictly local.

However, neither CNNs nor ViTs should be used as black-box replacements for classical models. The correct experimental design should include strong baselines:

• tree-based models such as Random Forest, XGBoost, LightGBM or CatBoost;
• an MLP trained directly on the original tabular data;
• several tabular-to-image methods;
• several image sizes;
• CNN, ViT and hybrid architectures;
• ablation studies with and without blurring;
• validation protocols that prevent data leakage.

Only under this type of comparison can we determine whether the synthetic image representation adds value.

Hybrid Neural Networks

A particularly relevant architecture is the Hybrid Neural Network. Instead of choosing between the original tabular data and the synthetic image, a hybrid model uses both.

A typical design includes:

1. a tabular branch, usually an MLP that receives the original feature vector;
2. an image branch, usually a CNN or ViT that receives the synthetic image;
3. a fusion layer, where both representations are concatenated or combined;
4. a prediction head for classification or regression.

This architecture is conceptually attractive because it avoids discarding the original tabular representation. The tabular branch can learn direct variable-level patterns, while the image branch can learn spatial interactions produced by the transformation method.

Since the main image of this post already summarizes the hybrid-neural-network idea, we will not duplicate that slide here. The important point is architectural: the hybrid model preserves the original tabular information while simultaneously exploiting a synthetic image representation derived from TINTOlib.

In indoor localisation, this design is especially meaningful. Wireless measurements can be represented as tabular features, but they may also contain latent spatial or structural patterns. A hybrid architecture can exploit both perspectives simultaneously.

(Figure 3. A simplified illustration of the HyNN architecture. This figure shows that either CNN or ViT can be used as the vision component, while the MLP component processes tabular data directly. It also highlights the flexibility of the model, which allows for using only the vision or MLP part, illustrating the different architectures evaluated in this study.)

Explainable AI over synthetic images

Interpretability is one of the most important motivations for the synthetic image paradigm.

In a conventional neural network trained on tabular data, explanations are usually produced at the variable level. In a CNN trained on synthetic images, explanations can be produced visually. For example, methods such as Grad-CAM or saliency maps can identify regions of the synthetic image that were influential for the prediction.

The key step is to map those regions back to the original variables. Since the synthetic image is generated from a known feature layout, each pixel or region can be associated with one or more original tabular features. This allows a visual explanation to be translated back into the structured-data domain.

The first level of interpretation operates directly over the synthetic image. Since each region of the image is generated from a known spatial encoding of the original variables, visual attribution maps can be inspected not only as image explanations, but also as indirect explanations over the tabular feature space.

(Figure 4. AIX-based interpretation of synthetic tabular images in TINTOlib. Visual attribution maps can identify relevant regions of the synthetic image, which can then be related back to the original tabular variables through the known spatial encoding. This provides a bridge between image-based explainability and feature-level interpretation in structured data problems.)

In hybrid architectures, this interpretability layer becomes even more relevant. The model can be analysed from two complementary perspectives: the tabular branch, which operates over the original feature vector, and the image branch, which operates over the synthetic spatial representation. This makes it possible to study whether both branches rely on consistent information or whether each one captures different aspects of the problem.

(Figure 5. Explainable AI workflow for hybrid neural networks combining tabular and synthetic image representations. The image branch enables visual attribution over the generated synthetic representation, while the tabular branch preserves direct access to the original variables. This makes it possible to connect spatial explanations with feature-level reasoning in hybrid deep learning models.)

This is one of the reasons why the method is not only useful for prediction. It also creates a framework for studying how neural networks use transformed tabular information.

Indoor localisation as a representative use case

The conference used indoor localisation as one of the representative domains for this paradigm. In MIMO-based and Bluetooth-based localisation problems, the input may consist of signal measurements, antenna-related variables or channel-state information. These variables are usually stored as tables, but they may contain complex structural dependencies.

Transforming these signals into synthetic images makes it possible to evaluate whether spatial encodings expose patterns that are difficult to exploit from the raw tabular representation. CNNs and ViTs can then process those patterns, while hybrid architectures can combine them with the original signal vector.

This does not mean that indoor localisation is the only application. The same idea can be applied to biomedical data, industrial monitoring, educational analytics, cybersecurity, financial risk modelling, sensor networks and many other domains where the input is tabular but the relationships between variables are complex.

What the paradigm does not claim

A rigorous interpretation of synthetic images for tabular data must avoid exaggerated claims.

The method does not claim that every table should become an image. It does not claim that CNNs will always outperform XGBoost. It does not claim that a synthetic image is semantically equivalent to a natural image.

The claim is more precise:

If the feature layout is constructed in a meaningful way, synthetic images can provide a spatial representation that allows visual and hybrid neural architectures to exploit relationships in tabular data.

This statement is testable. It requires benchmarks, ablations, strong baselines and careful validation.

Practical recommendations

For researchers and students working with TINTOlib, the following recommendations are important.

First, always split the data before fitting the transformation. Data leakage at the representation stage invalidates the evaluation.

Second, do not rely on order-dependent encodings as primary methods when the original feature order is arbitrary. Use them as baselines or teaching tools, but prioritize data-driven spatial encodings such as TINTO, DeepInsight, IGTD, REFINED, Fotomics and Clusters.

Third, compare against strong classical baselines. A synthetic image pipeline should not be evaluated only against weak neural models.

Fourth, evaluate several image sizes and architectures. The optimal spatial resolution may depend on the number of variables and the density of the feature layout.

Fifth, include interpretability analyses. One of the strengths of synthetic images is that they create a bridge between visual explanations and tabular variables.

Conclusion

Synthetic image generation from tabular data is not a superficial visualization technique. It is a representational strategy for connecting structured data with computer vision and hybrid neural architectures.

The central methodological requirement is that the image must have a meaningful spatial structure. If the image merely reflects the arbitrary order of the columns, the transformation reproduces the original limitation of tabular data. If, however, the spatial layout is learned or optimized from the relationships between variables, the resulting representation can provide a useful bridge toward deep learning.

TINTOlib provides the practical environment for exploring this idea. It enables systematic comparison of spatial encodings, integration with CNNs and Vision Transformers, development of hybrid neural networks and application of explainability techniques to synthetic tabular images.

The broader lesson is that deep learning performance depends not only on the architecture, but also on the representation. For tabular data, representation may be the decisive step.

References and related publications

The concepts presented in this tutorial are connected to the following research and software publications on TINTO, TINTOlib, tabular-to-image transformation, synthetic spatial representations, hybrid neural networks, indoor localisation and explainable artificial intelligence.

Research articles

1. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro, Luis Orozco-Barbosa. Interpretable Hybrid Vision Transformer Architectures for MIMO-Based Indoor Localization using Synthetic Spatial Representations. IEEE Internet of Things. DOI: 10.1109/JIOT.2026.3696106

2. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. A Comprehensive Benchmark of Spatial Encoding Methods for Tabular Data with Deep Neural Networks. Information Fusion. DOI: 10.1016/j.inffus.2025.104088

3. Giovanny Mondragon-Ruiz, Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. Interpretable CNN–KAN hybrid architectures for tabular data with synthetic image encoding. Information Processing and Management. DOI: 10.1016/j.ipm.2026.104954

4. Felipe Escalera-González, Manuel Castillo-Cara, Mariano Rincón-Zamorano, Luis Orozco-Barbosa. PermGrad: Interpretable Hybrid Neural Networks with synthetic images for tabular data. Knowledge-Based Systems. DOI: 10.1016/j.knosys.2026.116507

5. Manuel Castillo-Cara, Jesus Martínez-Gómez, Javier Ballesteros-Jerez, Ismael García-Varea, Raúl García-Castro, Luis Orozco-Barbosa. MIMO-Based Indoor Localisation with Hybrid Neural Networks. IEEE Journal of Selected Topics in Signal Processing. DOI: 10.1109/JSTSP.2025.3555067

6. Reewos Talla-Chumpitaz, Manuel Castillo-Cara, Luis Orozco-Barbosa, Raúl García-Castro. Blurring Image Techniques for Bluetooth-based Indoor Localisation. Information Fusion. DOI: 10.1016/j.inffus.2022.10.011

Software articles

1. Jiayun Liu, David González-Fernández, Manuel Castillo-Cara, Raúl García-Castro. TINTOlib: A Python library for transforming tabular data into synthetic images for deep neural networks. SoftwareX. DOI: 10.1016/j.softx.2025.102444

2. Manuel Castillo-Cara, Reewos Talla-Chumpitaz, Raúl García-Castro, Luis Orozco-Barbosa. TINTO: Converting Tidy Data into Image for Classification with 2-Dimensional Convolutional Neural Networks. SoftwareX. DOI: 10.1016/j.softx.2023.101391

Continue learning Artificial Intelligence

Explore practical courses on AI, Machine Learning, Deep Learning, Python, R and applied data science.

View AI Courses →

Manuel Castillo-Cara, PhD

TINTOlib Python Library Developer

Researcher & Professor

Department of Artificial Intelligence

Universidad Nacional de Educación a Distancia (UNED)

Almerimar (Almería), Spain

© Manuel Castillo-Cara, PhD. Content licensed under CC BY-NC 4.0 unless otherwise stated.

🖨️ Print / Save as PDF 💾 Save as HTML 🐍 Download Python 📓 Notebook (.ipynb)

You may also enjoy

08 Aug 2026 TINTOlib

Part 4 — RGB Fusion and Structural Stability in TINTOlib: mixMethod and SSIM-Based Automatic Selection

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

06 Aug 2026 TINTOlib

Part 3 — Probabilities, Densities and Latent Factors in TINTOlib: gaussianMix, KDE and Factor Analysis

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

24 Jul 2026 TINTOlib

Part 2 — Distance-Based Encodings in TINTOlib: k-Means, k-Medoids and aggloKNN

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

TINTOlib · Synthetic Images · Tabular Data

Improving Deep Learning by Exploiting Synthetic Images

Part I — Why tabular data remains a difficult domain for deep learning, and why representation is the central methodological problem.

Tabular Data Deep Learning Spatial Encoding TINTOlib

• Author: Manuel Castillo-Cara, PhD
• Affiliation: Dpt. of Artificial Intelligence, Universidad Nacional de Educación a Distancia (UNED), Spain
• Role: Researcher, Professor, and TINTOlib Python Library Developer
• License: CC BY-NC 4.0 unless otherwise stated.

Video overview

This post is part of a two-part technical summary derived from the conference Improving Deep Learning by Exploiting Synthetic Images, delivered in Peru.

The following short video provides an English overview of the main ideas discussed across both posts: why tabular data remains challenging for deep learning, how synthetic images can introduce spatial representations, and how TINTOlib connects structured data with computer vision, hybrid neural networks and explainable AI.

Additional material. The original conference recording is available in Spanish. The two blog posts provide an English technical synthesis and discussion based on that conference.

Open the original conference recording in SharePoint

Introduction: why another post on synthetic images?

Most introductions to deep learning start from domains where the data already have a rich native structure: images, text, audio, video or graphs. In those domains, the input representation is not merely a container of values; it already carries some form of organization. Pixels are arranged in a plane. Words appear in sequences. Audio samples evolve over time. Graphs encode nodes and edges.

Tabular data are different. A table is one of the most common data structures in science, industry and public administration, but its geometry is weakly defined. Rows represent samples and columns represent variables, yet the order of those variables is usually arbitrary. A tabular dataset may contain age, sex, income, biomarkers, signal measurements, sensor values or derived indicators, but the fact that one column appears before another rarely means that both variables are spatial neighbours.

This creates a paradox. Deep learning has transformed computer vision, natural language processing and generative modelling, but for many tabular problems classical machine learning models remain extremely strong. Random Forest, XGBoost, LightGBM and CatBoost are still difficult baselines to beat. The problem is not simply that deep learning is less powerful. The problem is that many of its most successful architectures are designed to exploit structure that tabular data do not naturally provide.

The theoretical question addressed in the conference, and in this post, is therefore the following:

Can we improve deep learning on tabular data by constructing a meaningful spatial representation before applying the neural architecture?

This question is the starting point for tabular-to-image transformation, synthetic image generation from structured data and the TINTOlib framework.

Data science as a transformation from data to knowledge

A useful way to frame data science is to see it as a transformation pipeline: data are collected, curated, represented, modelled and interpreted in order to produce knowledge. This knowledge should not be limited to a numerical prediction. It should be reproducible, generalizable and sufficiently interpretable to support scientific or operational decisions.

In practice, the first difficulty is that real-world data are heterogeneous. Data may arrive as images, time series, text, graphs or tables. In many institutional and industrial scenarios, however, the dominant format is tabular. Corporate databases, biomedical registries, educational records, indoor localisation measurements, sensor logs and many scientific datasets are naturally stored as tables.

This is why the tabular domain is so important. A method that improves learning from tabular data can have impact across many applied areas. At the same time, this is why the problem is difficult. Tabular datasets often combine numerical and categorical variables, heterogeneous scales, missing values, non-linear dependencies, interactions between variables and relatively small sample sizes compared with modern image or language datasets.

(Figure 1. Motivation of the tabular data bottleneck. A large fraction of real-world organisational and scientific data is stored in tabular form, yet standard deep learning architectures do not naturally exploit this representation. The key methodological challenge is to transform structured data into representations that preserve variable relationships while remaining suitable for modern neural architectures.)

The central claim of this post is that representation is not a secondary detail. It is a fundamental modelling decision. If the representation is inadequate, even a powerful neural architecture may fail to exploit the relevant structure of the problem.

Why CNNs and ViTs work so well on images

To understand why tabular data are difficult, it is useful to recall why deep learning works so well in computer vision.

A natural image has spatial locality. Neighbouring pixels tend to be related. They may belong to the same edge, texture, object or background region. CNNs exploit this property through convolutional filters that slide across the image. These filters detect local patterns and reuse them across different spatial positions. This creates an architectural prior: the model assumes that local structures matter and that patterns can appear in different parts of the image.

Vision Transformers follow a different strategy, but they also assume an organized visual representation. An image is divided into patches, each patch is embedded, and attention mechanisms learn relationships between patches. The model is not restricted to local filters in the same way as a CNN, but it still begins from a spatially arranged representation.

In both cases, the input representation supports the architecture. The image is not just a vector. It is a structured object.

A raw tabular dataset does not provide this kind of support. If a table is treated as an image by simply reshaping columns into a matrix, the resulting arrangement may be arbitrary. The position of a feature in the synthetic grid may depend on column order rather than on meaningful relationships. This is precisely the problem that tabular-to-image methods attempt to solve.

(Figure 2. Visual metaphor illustrating why CNNs are not directly suited to raw tabular matrices. In natural images, neighbouring pixels encode meaningful local and spatial correlations, allowing convolutional filters to detect edges, textures and shapes. In tabular data, however, column order is usually arbitrary: reordering variables such as age, salary or sex changes the apparent pixel arrangement while preserving the semantic content of the sample. A CNN applied directly to such a matrix may therefore learn artefacts induced by column order rather than meaningful feature interactions.)

This visual metaphor is also important when evaluating tabular-to-image transformation methods. A method that simply converts a table into an image without solving the ordering problem may still expose a CNN to an arbitrary geometry. The objective is not only to obtain an image, but to construct a spatial representation whose neighbourhoods have methodological meaning.

Why tabular data remains the difficult domain

Deep learning on tabular data is not impossible. There are many neural architectures for structured data, including MLPs, attention-based models, entity embeddings, differentiable trees and transformer variants for tables. However, the empirical picture remains complex. In many benchmarks, strong ensemble models still outperform standard neural networks.

There are several reasons for this.

First, tabular datasets are often small or medium-sized. Deep neural networks usually benefit from large-scale data, while many tabular problems contain hundreds, thousands or tens of thousands of samples rather than millions.

Second, tabular features are heterogeneous. Some are continuous, others categorical, ordinal, binary or derived. Their scales and distributions may differ substantially.

Third, interactions between variables can be sparse, non-linear and dataset-specific. A variable may be informative only in combination with another variable, or only for a subset of the population.

Fourth, tabular data have no canonical spatial arrangement. Unlike images, tables do not tell us which variables should be neighbours.

This fourth point is especially relevant for the synthetic image paradigm. If a CNN is to process a tabular sample as an image, the image must not be an arbitrary reshaping of the table. It must be a constructed representation in which spatial proximity has methodological meaning.

(Figure 3. Deep learning for tabular data as an open research problem. Although deep neural networks have achieved remarkable success in computer vision, natural language processing and generative AI, tabular data remain a challenging domain where ensemble methods are still strong baselines. This motivates the search for alternative representations rather than naive applications of generic neural architectures.)

The central problem is not the model; it is the representation

A frequent mistake is to treat model selection and data representation as independent decisions. In reality, architecture and representation are deeply coupled.

A CNN is not simply a classifier. It is a classifier designed for spatially organized data. A ViT is not simply an attention mechanism. It assumes a patch-based visual input. A recurrent neural network assumes a sequence. A graph neural network assumes a graph.

Therefore, when applying deep learning to tabular data, we must ask what structure the model is expected to exploit. If no structure is provided, the model must infer everything from scratch. If an arbitrary structure is imposed, the model may learn artifacts.

Synthetic image generation is a representation strategy. It proposes that instead of forcing a neural network to process a raw table, we first map the table into a spatial domain. Then we can use visual architectures in a more coherent way.

The resulting image is not natural. It is synthetic. It does not represent a physical scene. It represents the values of a tabular instance arranged according to a spatial encoding of the variables.

From tabular vectors to synthetic images

The transformation can be understood in two stages.

First, the method learns or defines a spatial layout of the features. Each feature is assigned a position in a two-dimensional grid. Ideally, features that are statistically, geometrically or semantically related should be placed close to one another.

Second, each sample is projected into that grid. The feature values of the sample become pixel intensities or spatial patterns, producing a synthetic image.

Tabular dataset
    |
    | learn feature layout
    v
2D feature map
    |
    | project each sample
    v
Synthetic image dataset
    |
    | CNN / ViT / hybrid neural network
    v
Prediction and explanation

This transformation does not claim that tabular data are images. Rather, it constructs an image-like representation that allows the use of architectures developed for the visual domain.

The methodological quality of the approach depends heavily on how the feature layout is constructed. A good transformation should reduce arbitrariness. A poor transformation may simply reproduce the arbitrary ordering of the original table.

A necessary distinction: spatially informed methods vs. order-dependent methods

This distinction is crucial.

Some tabular-to-image methods are strongly influenced by the original order or structure of the table. Examples include BarGraph, DistanceMatrix, Combination, SuperTML, BIE and FeatureWrap. These methods may be useful as baselines or didactic examples, but they should be used with caution as primary transformation strategies when the feature order is arbitrary.

The reason is methodological. If the generated image depends on whether age appears before or after sex, then the transformation inherits the same limitation that motivated the problem in the first place: tabular data do not possess a natural spatial order. In that case, the synthetic image may encode artifacts of the column arrangement rather than meaningful relationships between variables.

This does not mean that these methods are never useful. They can be relevant when the input table has a meaningful pre-existing order, when the objective is educational, or when they are included as comparative baselines. However, for rigorous tabular-to-image modelling, they should not be treated as the preferred family of methods if the feature ordering is arbitrary.

In contrast, methods such as TINTO, DeepInsight, IGTD, REFINED, Fotomics and recent unsupervised learning-based approaches such as ILUSTRE/ILUSTRES aim to construct the spatial representation from the data structure itself. These methods attempt to reduce dependence on the original column order by learning or optimizing the spatial arrangement of features. Their goal is precisely to create a meaningful visual representation where the geometry reflects relationships in the data, not the accidental ordering of the spreadsheet.

This distinction should be made explicit in any serious discussion of synthetic images for tabular data. The key question is not only whether a method produces an image. The key question is whether the image has a defensible spatial structure.

The paradigm shift

The paradigm shift introduced by TINTOlib can therefore be understood as a representational shift. Instead of applying deep learning directly to unordered tabular vectors, the method first constructs a spatial representation where feature relationships can be expressed geometrically. Once this representation exists, computer vision architectures can be applied under assumptions that are more coherent with their original design.

This does not mean that synthetic images are universally superior to classical tabular models. Rather, it means that they create a new experimental space: one in which tabular data can be studied through visual, hybrid and explainable neural architectures.

From a teaching perspective, this paradigm is also useful because it makes the problem visible. Students can compare different spatial encodings, inspect the resulting images and observe how representation affects the behaviour of the model.

What Part II will cover

This first part has focused on the theoretical motivation: why tabular data remain difficult for deep learning, why representation matters, and why spatially meaningful synthetic images are different from arbitrary reshaping.

In the second part, we will move from the conceptual problem to the modelling pipeline. We will discuss how TINTOlib operationalizes this paradigm, how different transformation methods should be compared, how hybrid neural networks combine tabular and visual branches, and how visual explainability methods can be adapted to synthetic tabular images.

Continue with Part II: From Synthetic Images to Hybrid Neural Networks

References and related publications

The concepts presented in this tutorial are connected to the following research and software publications on TINTO, TINTOlib, tabular-to-image transformation, synthetic spatial representations, hybrid neural networks, indoor localisation and explainable artificial intelligence.

Research articles

1. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro, Luis Orozco-Barbosa. Interpretable Hybrid Vision Transformer Architectures for MIMO-Based Indoor Localization using Synthetic Spatial Representations. IEEE Internet of Things. DOI: 10.1109/JIOT.2026.3696106

2. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. A Comprehensive Benchmark of Spatial Encoding Methods for Tabular Data with Deep Neural Networks. Information Fusion. DOI: 10.1016/j.inffus.2025.104088

3. Giovanny Mondragon-Ruiz, Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. Interpretable CNN–KAN hybrid architectures for tabular data with synthetic image encoding. Information Processing and Management. DOI: 10.1016/j.ipm.2026.104954

4. Felipe Escalera-González, Manuel Castillo-Cara, Mariano Rincón-Zamorano, Luis Orozco-Barbosa. PermGrad: Interpretable Hybrid Neural Networks with synthetic images for tabular data. Knowledge-Based Systems. DOI: 10.1016/j.knosys.2026.116507

5. Manuel Castillo-Cara, Jesus Martínez-Gómez, Javier Ballesteros-Jerez, Ismael García-Varea, Raúl García-Castro, Luis Orozco-Barbosa. MIMO-Based Indoor Localisation with Hybrid Neural Networks. IEEE Journal of Selected Topics in Signal Processing. DOI: 10.1109/JSTSP.2025.3555067

6. Reewos Talla-Chumpitaz, Manuel Castillo-Cara, Luis Orozco-Barbosa, Raúl García-Castro. Blurring Image Techniques for Bluetooth-based Indoor Localisation. Information Fusion. DOI: 10.1016/j.inffus.2022.10.011

Software articles

1. Jiayun Liu, David González-Fernández, Manuel Castillo-Cara, Raúl García-Castro. TINTOlib: A Python library for transforming tabular data into synthetic images for deep neural networks. SoftwareX. DOI: 10.1016/j.softx.2025.102444

2. Manuel Castillo-Cara, Reewos Talla-Chumpitaz, Raúl García-Castro, Luis Orozco-Barbosa. TINTO: Converting Tidy Data into Image for Classification with 2-Dimensional Convolutional Neural Networks. SoftwareX. DOI: 10.1016/j.softx.2023.101391

Continue learning Artificial Intelligence

Explore practical courses on AI, Machine Learning, Deep Learning, Python, R and applied data science.

View AI Courses →

Manuel Castillo-Cara, PhD

TINTOlib Python Library Developer

Researcher & Professor

Department of Artificial Intelligence

Universidad Nacional de Educación a Distancia (UNED)

Almerimar (Almería), Spain

© Manuel Castillo-Cara, PhD. Content licensed under CC BY-NC 4.0 unless otherwise stated.

🖨️ Print / Save as PDF 💾 Save as HTML 🐍 Download Python 📓 Notebook (.ipynb)

You may also enjoy

08 Aug 2026 TINTOlib

Part 4 — RGB Fusion and Structural Stability in TINTOlib: mixMethod and SSIM-Based Automatic Selection

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

06 Aug 2026 TINTOlib

Part 3 — Probabilities, Densities and Latent Factors in TINTOlib: gaussianMix, KDE and Factor Analysis

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

24 Jul 2026 TINTOlib

Part 2 — Distance-Based Encodings in TINTOlib: k-Means, k-Medoids and aggloKNN

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

TINTOlib · Synthetic Images · Tabular-to-Image

What is TINTOlib?

Why does tabular data need spatial encoding? How are synthetic images generated — and what does blurring do? A complete introduction with a first end-to-end CNN pipeline in PyTorch.

TINTOlib Synthetic Images Blurring Tabular-to-Image Deep Learning

• Author: Manuel Castillo-Cara, PhD
• Affiliation: Dpt. of Artificial Intelligence, Universidad Nacional de Educación a Distancia (UNED), Spain
• Role: Researcher, Professor, and TINTOlib Python Library Developer
• License: CC BY-NC 4.0 unless otherwise stated.

In many applied machine learning problems, there is a recurrent practical distinction: for images, text, or audio, we often use Deep Learning; for tabular data, tree-based models and ensembles such as Random Forest, XGBoost, LightGBM, or CatBoost remain extremely competitive.

This distinction is not accidental. Convolutional neural networks were designed to exploit spatial structure: local neighborhoods, edges, textures, shapes, and patterns that repeat across an image. A tabular dataset, however, does not naturally have this type of geometry. The fact that one variable appears in column 2 and another in column 3 does not imply that both variables are semantically or statistically close.

This leads to a relevant research question:

Can we transform each tabular instance into a synthetic image so that computer vision architectures can exploit relationships between variables?

This question motivates the field of tabular-to-image transformation, also referred to as tabular2image, spatial encoding for tabular data, or synthetic image generation from tabular data. In this post, we introduce the main idea, explain where TINTOlib fits, and build a simple convolutional neural network in PyTorch to classify synthetic images generated from tabular data.

The problem: tabular data has no natural spatial locality

A digital image can be represented as a matrix of pixels. In a natural image, nearby pixels usually belong to the same visual region: an edge, a texture, a shadow, or an object. This property allows CNNs to apply local filters and learn reusable spatial patterns.

A tabular instance is different. It is usually represented as a vector:

x = [age, blood_pressure, cholesterol, glucose, ...]

The order of the columns is often arbitrary. If two variables are swapped, the semantic meaning of the sample does not necessarily change. For a CNN, however, that change would modify the input geometry. This is one of the reasons why applying convolutions directly to tabular vectors is usually problematic: the model would assume a local neighborhood structure that is not explicitly present.

Tabular-to-image transformation addresses this limitation by constructing an artificial spatial layout. The idea is to place the original variables on a 2D grid so that related variables are positioned close to each other. Then, for each row in the dataset, the values of those variables are projected onto the grid, producing a synthetic image.

Tabular data                    Synthetic image

+--------+--------+--------+       +----+----+----+----+
| feat_1 | feat_2 | feat_3 |  -->  |    | f2 |    | f8 |
| feat_4 | feat_5 | feat_6 |       +----+----+----+----+
|  ...   |  ...   |  ...   |       | f1 |    | f5 |    |
+--------+--------+--------+       +----+----+----+----+
                                   |    | f3 | f4 |    |
                                   +----+----+----+----+

(Conceptual schematic of the transformation from tabular data to a synthetic 2D image. Each feature is mapped to a grid position such that related variables are placed close to each other.)

This image is not a natural image. It does not represent a real-world scene. It is a spatial representation of a tabular vector. The important point is not whether the image is visually meaningful to a human observer, but whether the representation encodes useful relationships for a vision-based model.

(Figure 1. Conceptual workflow of TINTOlib for transforming tabular data into synthetic images. The original tabular features are spatially encoded into a two-dimensional grid, producing image-like representations that preserve feature relationships and can be processed by computer vision models such as convolutional neural networks.)

Why transform tabular data into images?

The transformation of tabular data into synthetic images opens at least three relevant possibilities.

First, it allows us to use computer vision architectures on structured data. Once each tabular instance has been transformed into an image, we can use CNNs, Vision Transformers, pretrained backbones, or hybrid neural architectures.

Second, it introduces a spatial inductive bias. If the transformation method places related variables close to each other, convolutional filters can learn local interactions between features.

Third, it enables visual explainability techniques. Methods such as saliency maps, activation maps, or Grad-CAM can be adapted to study which regions of the synthetic image — and therefore which original variables — contributed most to the prediction.

This does not mean that tabular-to-image transformation will always outperform classical machine learning models. Tree-based models remain strong baselines for tabular data. The value of this approach depends on the dataset, the number of samples, the number of features, the transformation method, the neural architecture, and the evaluation protocol. Its main interest is that it provides an alternative representation that can be combined with modern vision-based deep learning methods.

What is TINTOlib?

TINTOlib is a Python library for transforming tabular data into synthetic images in a systematic, modular, and reproducible way. Its main goal is to provide a unified interface for different state-of-the-art tabular-to-image transformation methods that were previously scattered across independent implementations, often with heterogeneous APIs.

The library follows a Scikit-Learn-like design, including methods such as fit, transform, and fit_transform. This is particularly useful when designing machine learning pipelines, because it allows us to separate the learning of the spatial representation from the transformation of new data.

TINTOlib includes both parametric and non-parametric methods. Some examples are:

• TINTO, based on dimensionality reduction techniques such as PCA or t-SNE, with optional image blurring.
• IGTD, which optimizes the feature arrangement to preserve similarity relationships.
• REFINED, which relies on multidimensional scaling and optimization to preserve feature-neighborhood information.
• DeepInsight, another projection-based method that arranges features in a 2D space.
• BarGraph, DistanceMatrix, Combination, FeatureWrap, SuperTML, and BIE, among others.

The documentation is available at tintolib.readthedocs.io.
The source code and examples are available at github.com/oeg-upm/TINTOlib.

In practice, TINTOlib allows us to move from this representation:

samples x features

to this one:

samples x channels x height x width

which is the natural input format for computer vision models in PyTorch.

Avoiding data leakage: fit only on the training data

A critical point when using tabular-to-image methods is data leakage.

The spatial arrangement of the variables must be learned only from the training data. If we use the full dataset to learn the transformation — including validation or test samples — information from the evaluation split can indirectly influence the representation. This would lead to an optimistic and methodologically incorrect estimate of model performance.

Therefore, even though TINTOlib provides fit_transform for convenience, in a proper experimental pipeline we should use:

1. fit on the training set only;
2. transform on the training set;
3. transform on the validation and test sets using the already-fitted transformation.

Conceptually, the workflow should be:

Train tabular data  ---- fit ----> learned spatial layout
Train tabular data  -- transform -> train images
Validation data     -- transform -> validation images
Test data           -- transform -> test images

This is the same principle used with scalers, imputers, PCA, feature selectors, and other preprocessing methods in standard machine learning pipelines.

First practical example: generating synthetic images with TINTOlib

For this example, we consider a multiclass classification problem using the Wine dataset from Scikit-Learn. Each row represents a sample, the input columns are numerical features, and the target column identifies the class label.

Install TINTOlib with:

pip install TINTOlib

Then, we prepare the train, validation, and test splits before fitting the tabular-to-image transformation.

from pathlib import Path

import pandas as pd
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder

from TINTOlib.tinto import TINTO

# Reproducibility
seed = 42

# Load multiclass tabular dataset
raw_data = load_wine()

# Build dataframe
df = pd.DataFrame(raw_data.data, columns=raw_data.feature_names)
df["target"] = raw_data.target

# Separate features and target
target_col = "target"
X = df.drop(columns=[target_col])
y = df[target_col]

# Encode labels if needed
label_encoder = LabelEncoder()
y_encoded = label_encoder.fit_transform(y)

# First split: train + temporary set
X_train, X_tmp, y_train, y_tmp = train_test_split(
    X,
    y_encoded,
    test_size=0.30,
    random_state=seed,
    stratify=y_encoded
)

# Second split: validation + test
X_val, X_test, y_val, y_test = train_test_split(
    X_tmp,
    y_tmp,
    test_size=0.50,
    random_state=seed,
    stratify=y_tmp
)

# Rebuild dataframes because TINTOlib expects the target column together with the features
train_df = X_train.copy()
train_df[target_col] = y_train

val_df = X_val.copy()
val_df[target_col] = y_val

test_df = X_test.copy()
test_df[target_col] = y_test

Now we instantiate the TINTO transformation. In this example we use the TINTO method, but the same structure can be used with other TINTOlib methods such as IGTD, REFINED, DeepInsight, BarGraph, DistanceMatrix, SuperTML, or BIE.

# Output folders
output_root = Path("tinto_images")
train_folder = output_root / "train"
val_folder = output_root / "val"
test_folder = output_root / "test"

# TINTO model
# pixels defines the image size: pixels x pixels
image_model = TINTO(
    problem="supervised",
    algorithm="PCA",
    pixels=20,
    blur=True,
    random_seed=seed
)

# Learn the spatial layout ONLY from the training data
image_model.fit(train_df)

# Transform each split using the same fitted representation
image_model.transform(train_df, folder=str(train_folder))
image_model.transform(val_df, folder=str(val_folder))
image_model.transform(test_df, folder=str(test_folder))

print("Synthetic images generated successfully.")

This separation is essential. The validation and test sets are transformed using the spatial layout learned from the training data, but they do not participate in learning that layout.

(Figure 2. Synthetic image samples generated with TINTOlib using the TINTO method with blurring, showing one representative instance from each class of the Wine multiclass dataset. Each image corresponds to a different class and encodes the original tabular feature values into a two-dimensional spatial representation, where local smoothing enhances spatial continuity while preserving class-dependent patterns that can be exploited by CNN-based and hybrid deep learning models.)

Can we use another method instead of TINTO?

Yes. One of the main advantages of TINTOlib is that the same general workflow can be reused with different transformation methods. For example, depending on the method available in your installation, you could replace the import and model definition with another transformer:

# Example: using another TINTOlib method instead of TINTO
# from TINTOlib.igtd import IGTD
# image_model = IGTD(problem="supervised", pixels=20)

# from TINTOlib.refined import REFINED
# image_model = REFINED(problem="supervised", pixels=20)

The high-level logic remains the same:

image_model.fit(train_df)
image_model.transform(train_df, folder="...")
image_model.transform(val_df, folder="...")
image_model.transform(test_df, folder="...")

For an experimental paper or benchmark, this is particularly useful because it allows us to compare different spatial encodings while keeping the same downstream neural architecture.

Loading the generated images in PyTorch

Once the images have been generated, we can load them in PyTorch. The exact folder structure may depend on the selected TINTOlib method and configuration. For a simple classification pipeline, it is convenient to organize the images using the structure expected by torchvision.datasets.ImageFolder:

tinto_images/
├── train/
│   ├── class_0/
│   ├── class_1/
│   └── class_2/
├── val/
│   ├── class_0/
│   ├── class_1/
│   └── class_2/
└── test/
    ├── class_0/
    ├── class_1/
    └── class_2/

If your generated files are stored differently, you can either reorganize them into this structure or implement a custom PyTorch Dataset.

import torch
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

batch_size = 32
img_size = 20

transform = transforms.Compose([
    transforms.Grayscale(num_output_channels=1),
    transforms.Resize((img_size, img_size)),
    transforms.ToTensor(),
])

train_dataset = datasets.ImageFolder(root=train_folder, transform=transform)
val_dataset = datasets.ImageFolder(root=val_folder, transform=transform)
test_dataset = datasets.ImageFolder(root=test_folder, transform=transform)

num_classes = len(train_dataset.classes)

train_loader = DataLoader(
    train_dataset,
    batch_size=batch_size,
    shuffle=True,
    num_workers=2
)

val_loader = DataLoader(
    val_dataset,
    batch_size=batch_size,
    shuffle=False,
    num_workers=2
)

test_loader = DataLoader(
    test_dataset,
    batch_size=batch_size,
    shuffle=False,
    num_workers=2
)

print("Classes:", train_dataset.classes)
print("Number of classes:", num_classes)
print("Training images:", len(train_dataset))
print("Validation images:", len(val_dataset))
print("Test images:", len(test_dataset))

A simple CNN in PyTorch

The following network defines a compact CNN baseline for verifying that the synthetic images generated by TINTOlib can be loaded, processed, and classified within a standard PyTorch workflow.

We assume grayscale images of size 20 x 20 pixels.

import torch
import torch.nn as nn


class SimpleTINTOCNN(nn.Module):
    def __init__(self, num_classes: int, img_size: int = 20):
        super().__init__()

        self.features = nn.Sequential(
            nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),

            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),
        )

        # For img_size=20: 20 -> 10 -> 5 after two MaxPool2d layers
        reduced_size = img_size // 4

        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * reduced_size * reduced_size, 128),
            nn.ReLU(),
            nn.Dropout(p=0.3),
            nn.Linear(128, num_classes)
        )

    def forward(self, x):
        x = self.features(x)
        x = self.classifier(x)
        return x


device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

model = SimpleTINTOCNN(num_classes=num_classes, img_size=img_size).to(device)
print(model)

Training the model

For multiclass classification, we use CrossEntropyLoss. In PyTorch, this loss expects raw logits, so the final layer should not include a softmax activation.

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)


def train_one_epoch(model, dataloader, criterion, optimizer, device):
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0

    for images, labels in dataloader:
        images = images.to(device)
        labels = labels.to(device)

        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item() * images.size(0)
        predictions = outputs.argmax(dim=1)
        correct += (predictions == labels).sum().item()
        total += labels.size(0)

    epoch_loss = running_loss / total
    epoch_acc = correct / total

    return epoch_loss, epoch_acc


@torch.no_grad()
def evaluate(model, dataloader, criterion, device):
    model.eval()
    running_loss = 0.0
    correct = 0
    total = 0

    for images, labels in dataloader:
        images = images.to(device)
        labels = labels.to(device)

        outputs = model(images)
        loss = criterion(outputs, labels)

        running_loss += loss.item() * images.size(0)
        predictions = outputs.argmax(dim=1)
        correct += (predictions == labels).sum().item()
        total += labels.size(0)

    epoch_loss = running_loss / total
    epoch_acc = correct / total

    return epoch_loss, epoch_acc

Now we train the network.

num_epochs = 20

history = {
    "train_loss": [],
    "train_acc": [],
    "val_loss": [],
    "val_acc": [],
}

for epoch in range(num_epochs):
    train_loss, train_acc = train_one_epoch(
        model,
        train_loader,
        criterion,
        optimizer,
        device
    )

    val_loss, val_acc = evaluate(
        model,
        val_loader,
        criterion,
        device
    )

    history["train_loss"].append(train_loss)
    history["train_acc"].append(train_acc)
    history["val_loss"].append(val_loss)
    history["val_acc"].append(val_acc)

    print(
        f"Epoch [{epoch + 1:02d}/{num_epochs}] "
        f"Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.4f} | "
        f"Val Loss: {val_loss:.4f} | Val Acc: {val_acc:.4f}"
    )

Evaluating on the test set

The test set should only be used once the model selection process has finished. Here we report the final test performance using the model selected during validation.

test_loss, test_acc = evaluate(model, test_loader, criterion, device)

print(f"Test Loss: {test_loss:.4f}")
print(f"Test Accuracy: {test_acc:.4f}")

Visualizing the training curves

In a Jupyter notebook, it is useful to visualize the learning curves to check whether the model is learning and whether overfitting appears.

import matplotlib.pyplot as plt

plt.figure(figsize=(7, 4))
plt.plot(history["train_loss"], label="Train loss")
plt.plot(history["val_loss"], label="Validation loss")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.title("Training and validation loss")
plt.legend()
plt.grid(True)
plt.show()

plt.figure(figsize=(7, 4))
plt.plot(history["train_acc"], label="Train accuracy")
plt.plot(history["val_acc"], label="Validation accuracy")
plt.xlabel("Epoch")
plt.ylabel("Accuracy")
plt.title("Training and validation accuracy")
plt.legend()
plt.grid(True)
plt.show()

Visualizing synthetic images

It is also useful to inspect some generated images. This helps to emphasize that these are not natural images, but artificial spatial encodings of tabular samples.

images, labels = next(iter(train_loader))

plt.figure(figsize=(10, 4))
for i in range(min(8, images.size(0))):
    plt.subplot(2, 4, i + 1)
    plt.imshow(images[i].squeeze(0), cmap="gray")
    plt.title(f"Class: {labels[i].item()}")
    plt.axis("off")

plt.tight_layout()
plt.show()

(Figure 3. Visualization of a batch of synthetic images generated with TINTOlib using the TINTO method with blurring. Each panel represents an individual tabular sample from the Wine dataset, encoded as a grayscale two-dimensional image and labeled according to its class. The observed spatial intensity patterns illustrate how different classes may produce distinguishable synthetic representations that can be processed by CNN-based models.)

What should we compare next?

This first experiment trains a simple CNN, but a rigorous evaluation should include additional baselines and ablations:

• a classical machine learning baseline, such as Random Forest, XGBoost, LightGBM, or CatBoost;
• a multilayer perceptron trained on the original tabular data;
• different tabular-to-image transformations, such as TINTO, IGTD, REFINED, DeepInsight, and SuperTML;
• different image sizes;
• deeper CNNs or Vision Transformers;
• hybrid architectures combining a tabular branch and an image branch.

The main question is not only whether a CNN can outperform a tree-based model. The scientifically relevant question is when, why, and under which conditions a spatial representation of tabular data is beneficial.

Conclusion

TINTOlib makes it easier to experiment with a powerful idea: transforming tabular data into visual representations that can be processed by computer vision architectures. This transformation does not automatically make a tabular problem easier, but it provides a different representation where spatial inductive biases can be exploited.

The key element is the spatial arrangement of the features. If related variables are placed close to each other, CNN filters can learn local interactions that are not directly available in the original table. In addition, this representation enables hybrid architectures, Vision Transformers, and visual explainability methods for structured data.

In this post, we introduced the motivation behind tabular-to-image transformation, the role of TINTOlib, the importance of avoiding data leakage, and a first CNN implementation in PyTorch. In future posts, we will compare different TINTOlib methods, build hybrid tabular-image neural networks, and apply explainability techniques to recover the relevance of the original variables.

References and related publications

The concepts presented in this tutorial are connected to the following research and software publications on TINTO, TINTOlib, tabular-to-image transformation, synthetic spatial representations, hybrid neural networks, and indoor localisation.

Research articles

1. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro, Luis Orozco-Barbosa. Interpretable Hybrid Vision Transformer Architectures for MIMO-Based Indoor Localization using Synthetic Spatial Representations. IEEE Internet of Things. DOI: 10.1109/JIOT.2026.3696106

2. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. A Comprehensive Benchmark of Spatial Encoding Methods for Tabular Data with Deep Neural Networks. Information Fusion. DOI: 10.1016/j.inffus.2025.104088

3. Giovanny Mondragon-Ruiz, Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. Interpretable CNN–KAN hybrid architectures for tabular data with synthetic image encoding. Information Processing and Management. DOI: 10.1016/j.ipm.2026.104954

4. Felipe Escalera-González, Manuel Castillo-Cara, Mariano Rincón-Zamorano, Luis Orozco-Barbosa. PermGrad: Interpretable Hybrid Neural Networks with synthetic images for tabular data. Knowledge-Based Systems. DOI: 10.1016/j.knosys.2026.116507

5. Manuel Castillo-Cara, Jesus Martínez-Gómez, Javier Ballesteros-Jerez, Ismael García-Varea, Raúl García-Castro, Luis Orozco-Barbosa. MIMO-Based Indoor Localisation with Hybrid Neural Networks. IEEE Journal of Selected Topics in Signal Processing. DOI: 10.1109/JSTSP.2025.3555067

6. Reewos Talla-Chumpitaz, Manuel Castillo-Cara, Luis Orozco-Barbosa, Raúl García-Castro. Blurring Image Techniques for Bluetooth-based Indoor Localisation. Information Fusion. DOI: 10.1016/j.inffus.2022.10.011

Software articles

1. Jiayun Liu, David González-Fernández, Manuel Castillo-Cara, Raúl García-Castro. TINTOlib: A Python library for transforming tabular data into synthetic images for deep neural networks. SoftwareX. DOI: 10.1016/j.softx.2025.102444

2. Manuel Castillo-Cara, Reewos Talla-Chumpitaz, Raúl García-Castro, Luis Orozco-Barbosa. TINTO: Converting Tidy Data into Image for Classification with 2-Dimensional Convolutional Neural Networks. SoftwareX. DOI: 10.1016/j.softx.2023.101391

Continue learning Artificial Intelligence

Explore practical courses on AI, Machine Learning, Deep Learning, Python, R and applied data science.

View AI Courses →

Manuel Castillo-Cara, PhD

TINTOlib Python Library Developer

Researcher & Professor

Department of Artificial Intelligence

Universidad Nacional de Educación a Distancia (UNED)

Almerimar (Almería), Spain

© Manuel Castillo-Cara, PhD. Content licensed under CC BY-NC 4.0 unless otherwise stated.

🖨️ Print / Save as PDF 💾 Save as HTML 🐍 Download Python 📓 Notebook (.ipynb)

You may also enjoy

08 Aug 2026 TINTOlib

Part 4 — RGB Fusion and Structural Stability in TINTOlib: mixMethod and SSIM-Based Automatic Selection

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

06 Aug 2026 TINTOlib

Part 3 — Probabilities, Densities and Latent Factors in TINTOlib: gaussianMix, KDE and Factor Analysis

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

24 Jul 2026 TINTOlib

Part 2 — Distance-Based Encodings in TINTOlib: k-Means, k-Medoids and aggloKNN

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

TINTOlib · Deep Learning · Tabular-to-Image

Introduction to TINTOlib

A Python framework for transforming tabular data into synthetic images and applying CNN-based vision architectures — bridging the gap between structured data and deep learning.

PyTorch CNN Tabular Data Synthetic Images

• Author: Manuel Castillo-Cara, PhD
• Affiliation: Dpt. of Artificial Intelligence, Universidad Nacional de Educación a Distancia (UNED), Spain
• Role: Researcher, Professor, and TINTOlib Python Library Developer
• License: CC BY-NC 4.0 unless otherwise stated.

In contemporary Data Science, an established paradigm governs model selection: Deep Learning architectures dominate unstructured modalities such as computer vision and natural language processing, whereas gradient-boosted decision trees (GBDTs)—including XGBoost, LightGBM, and CatBoost—remain the gold standard for structured tabular datasets.

However, recent advancements in deep learning have challenged this dichotomy through the introduction of spatial encoding techniques. By transforming tabular features into synthetic multi-dimensional images, researchers can leverage the structural inductive biases of advanced computer vision networks, such as Convolutional Neural Networks (CNNs) and Vision Transformers (ViTs). This article provides a comprehensive theoretical and practical introduction to TINTOlib, the state-of-the-art Python library designed to streamline this transformation pipeline.

The Theoretical Framework: Why Map Tables to Images?

The primary impediment to directly applying CNNs to tabular datasets is the absence of spatial locality. In natural images, adjacent pixels exhibit strong semantic and structural correlations (e.g., forming edges, textures, and continuous geometric shapes). Conversely, rows and columns in a standard tabular matrix possess an arbitrary ordering; swapping column 2 and column $d$ changes the array indices but preserves the underlying data semantics. This structural format violates the spatial inductive bias—specifically, translation invariance and locality—upon which convolutional filters rely.

To overcome this limitation, spatial encoding methodologies project the feature space onto a discrete 2D coordinate system. Features that exhibit strong statistical correlations or mutual dependencies are mapped to proximal spatial coordinates within a synthetic “canvas,” generating a synthetic pseudo-image.

(Figure 1: Conceptual diagram illustrating the topological mapping of tabular feature vectors into a structured 2D pixel grid via TINTOlib spatial encoding).

Through this transformation, the vision model’s convolutional kernels can extract higher-order hierarchical feature interactions. Furthermore, this paradigm shifts tabular analysis from black-box numeric mapping to a visual space, enabling the direct integration of post-hoc Explainable AI (XAI) frameworks—such as Grad-CAM, SHAP, or PermGrad—to visually interpret feature attributions via saliency maps.

What is TINTOlib?

TINTOlib is an open-source Python framework that unifies a comprehensive suite of state-of-the-art tabular-to-image transformation algorithms under a single, cohesive, Scikit-Learn-compliant interface. For a comprehensive overview of the framework’s capabilities, consult the official TINTOlib Documentation.

Historically, evaluating different spatial encoding strategies required integrating disjointed, unstandardized repositories written across varying programming languages. TINTOlib resolves this fragmentation by categorizing and implementing both parametric and non-parametric approaches. While this tutorial focuses on the TINTO method (which utilizes manifold learning techniques like t-SNE or Principal Component Analysis to determine spatial feature positions), the library allows researchers to pivot to any other methodology—such as IGTD, REFINED, SuperTML, BarGraph, or Binary Image Encoding (BIE)—by modifying a single line of code, ensuring a seamless benchmarking experience.

Practical Implementation: Building Your First PyTorch CNN Pipeline

To demonstrate the efficacy of this paradigm, we will construct an end-to-end classification pipeline. To ensure strict reproducibility, we will utilize the standard Breast Cancer Wisconsin dataset from Scikit-Learn.

1. Spatial Encoding and Data Leakage Mitigation

A critical methodological vulnerability in spatial encoding is Data Leakage. Algorithms that learn the optimal spatial arrangement of pixels based on feature similarities (such as t-SNE, PCA, or distance-matrix optimizations) must never be exposed to the validation or testing partitions during the fitting phase. Doing so allows the topological properties of the unseen test data to influence the coordinate mapping, invalidating subsequent generalization metrics.

To ensure rigorous validation, the pipeline must strictly segregate data prior to mapping: call .fit() exclusively on the training partition to define the spatial configuration, and subsequently apply .transform() to generate the synthetic images for both sets independently.

import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from TINTOlib.tinto import TINTO

# 1. Load the structured tabular dataset (Breast Cancer - 30 numeric features)
raw_data = load_breast_cancer()
df = pd.DataFrame(raw_data.data, columns=raw_data.feature_names)
# Append the target variable as the final column, conforming to tidy data standards
df['target'] = raw_data.target 

# 2. Partition the dataset to guarantee strict validation boundaries
X_train, X_test = train_test_split(df, test_size=0.2, random_state=42)

# 3. Instantiate the spatial encoder (TINTO via t-SNE optimization, outputting a 20x20 canvas)
# Note: To alternate methods, simply import and instantiate IGTD or REFINED here.
encoder = TINTO(problem="supervised", algorithm="t-SNE", pixels=20, blur=True)

# 4. Fit the spatial coordinate mapping matrix ONLY using the training split
encoder.fit(X_train)

# 5. Transform the tabular matrices into synthetic image repositories
encoder.transform(X_train, "synthetic_dataset/train/")
encoder.transform(X_test, "synthetic_dataset/test/")
print("Transformation completed successfully. Spatial representations isolated.")

(Figure 2. Synthetic image samples generated with TINTOlib using the TINTO method with blurring. Each image corresponds to an individual tabular instance from the Breast Cancer Wisconsin dataset and encodes its feature values into a two-dimensional spatial representation. The resulting intensity patterns can be processed by CNN-based and hybrid neural architectures.)

2. Architectural Specification in PyTorch

Following image generation, we construct a standard Convolutional Neural Network tailored to ingest the single-channel (grayscale) $20 \times 20$ pixel representations yielded by TINTOlib.

import torch
import torch.nn as nn
import torch.nn.functional as F

class TabularCNN(nn.Module):
    def __init__(self, num_classes=2):
        super(TabularCNN, self).__init__()
        
        # Convolutional Block 1: Input channels = 1, Output feature maps = 32
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, padding=1)
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        
        # Convolutional Block 2: Input channels = 32, Output feature maps = 64
        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1)
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        
        # Given a 20x20 input, two successive MaxPool reductions yield a 5x5 spatial size
        self.flatten = nn.Flatten()
        self.fc1 = nn.Linear(64 * 5 * 5, 128)
        self.fc2 = nn.Linear(128, num_classes)

    def forward(self, x):
        # Block 1 forward pass
        x = self.pool1(F.relu(self.conv1(x)))
        # Block 2 forward pass
        x = self.pool2(F.relu(self.conv2(x)))
        # Classification head
        x = self.flatten(x)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# Instantiate the model architecture for binary classification
vision_model = TabularCNN(num_classes=2)
print(vision_model)

The generated synthetic images stored in synthetic_dataset/ can be seamlessly loaded via PyTorch’s standard torchvision.datasets.ImageFolder class combined with a DataLoader loop, optimizing models using typical criteria like CrossEntropyLoss or BCEWithLogitsLoss.

Conclusion and Open Horizons

Transforming tabular features into synthetic spatial layouts offers a compelling methodology to bridge classical data problems with state-of-the-art visual architectures. Utilizing TINTOlib provides data scientists with a rigorous, reproducible, and standardized framework to systematically test, compare, and scale these transformations while avoiding common pitfalls such as data leakage.

In subsequent entries, we will delve deeper into benchmarking comparative analysis (e.g., non-parametric IGTD vs. parallelized REFINED), evaluating performance shifts when deploying Vision Transformers (ViTs), and rendering feature importance maps through advanced XAI methods.

References and related publications

The concepts presented in this tutorial are connected to the following research and software publications on TINTO, TINTOlib, tabular-to-image transformation, synthetic spatial representations, hybrid neural networks, and indoor localisation.

Research articles

1. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro, Luis Orozco-Barbosa. Interpretable Hybrid Vision Transformer Architectures for MIMO-Based Indoor Localization using Synthetic Spatial Representations. IEEE Internet of Things. DOI: 10.1109/JIOT.2026.3696106

2. Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. A Comprehensive Benchmark of Spatial Encoding Methods for Tabular Data with Deep Neural Networks. Information Fusion. DOI: 10.1016/j.inffus.2025.104088

3. Giovanny Mondragon-Ruiz, Jiayun Liu, Manuel Castillo-Cara, Raúl García-Castro. Interpretable CNN–KAN hybrid architectures for tabular data with synthetic image encoding. Information Processing and Management. DOI: 10.1016/j.ipm.2026.104954

4. Felipe Escalera-González, Manuel Castillo-Cara, Mariano Rincón-Zamorano, Luis Orozco-Barbosa. PermGrad: Interpretable Hybrid Neural Networks with synthetic images for tabular data. Knowledge-Based Systems. DOI: 10.1016/j.knosys.2026.116507

5. Manuel Castillo-Cara, Jesus Martínez-Gómez, Javier Ballesteros-Jerez, Ismael García-Varea, Raúl García-Castro, Luis Orozco-Barbosa. MIMO-Based Indoor Localisation with Hybrid Neural Networks. IEEE Journal of Selected Topics in Signal Processing. DOI: 10.1109/JSTSP.2025.3555067

6. Reewos Talla-Chumpitaz, Manuel Castillo-Cara, Luis Orozco-Barbosa, Raúl García-Castro. Blurring Image Techniques for Bluetooth-based Indoor Localisation. Information Fusion. DOI: 10.1016/j.inffus.2022.10.011

Software articles

1. Jiayun Liu, David González-Fernández, Manuel Castillo-Cara, Raúl García-Castro. TINTOlib: A Python library for transforming tabular data into synthetic images for deep neural networks. SoftwareX. DOI: 10.1016/j.softx.2025.102444

2. Manuel Castillo-Cara, Reewos Talla-Chumpitaz, Raúl García-Castro, Luis Orozco-Barbosa. TINTO: Converting Tidy Data into Image for Classification with 2-Dimensional Convolutional Neural Networks. SoftwareX. DOI: 10.1016/j.softx.2023.101391

Continue learning Artificial Intelligence

Explore practical courses on AI, Machine Learning, Deep Learning, Python, R and applied data science.

View AI Courses →

Manuel Castillo-Cara, PhD

TINTOlib Python Library Developer

Researcher & Professor

Department of Artificial Intelligence

Universidad Nacional de Educación a Distancia (UNED)

Almerimar (Almería), Spain

© Manuel Castillo-Cara, PhD. Content licensed under CC BY-NC 4.0 unless otherwise stated.

🖨️ Print / Save as PDF 💾 Save as HTML 🐍 Download Python 📓 Notebook (.ipynb)

You may also enjoy

08 Aug 2026 TINTOlib

Part 4 — RGB Fusion and Structural Stability in TINTOlib: mixMethod and SSIM-Based Automatic Selection

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

06 Aug 2026 TINTOlib

Part 3 — Probabilities, Densities and Latent Factors in TINTOlib: gaussianMix, KDE and Factor Analysis

TINTOlib Clusters Synthetic Images Tabular Data

Read article →

24 Jul 2026 TINTOlib

Part 2 — Distance-Based Encodings in TINTOlib: k-Means, k-Medoids and aggloKNN

TINTOlib Clusters Synthetic Images Tabular Data

Read article →