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 et al. 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 et al. 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 et al. Interpretable CNN–KAN hybrid architectures for tabular data with synthetic image encoding. Information Processing and Management. DOI: 10.1016/j.ipm.2026.104954

4. Manuel Castillo-Cara et al. MIMO-Based Indoor Localisation with Hybrid Neural Networks. IEEE Journal of Selected Topics in Signal Processing. DOI: 10.1109/JSTSP.2025.3555067

5. Reewos Talla-Chumpitaz, Manuel Castillo-Cara et al. Blurring Image Techniques for Bluetooth-based Indoor Localisation. Information Fusion. DOI: 10.1016/j.inffus.2022.10.011

Software articles

1. Jiayun Liu et al. 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 et al. 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

02 Jun 2026 TINTOlib

Improving Deep Learning by Exploiting Synthetic Images — Part I: Why Tabular Data Needs Spatial Representations

TINTOlib Synthetic Images Tabular-to-Image Tabular Data

Read article →

28 May 2026 TINTOlib

What is TINTOlib and why should we transform tabular data into synthetic images?

TINTOlib Tabular Data Synthetic Images Deep Learning

Read article →

27 May 2026 TINTOlib

Introduction to TINTOlib: Unlocking the Power of Vision Architectures for Tabular Data

TINTOlib Tabular-to-Image Synthetic Images Deep Learning

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 et al. 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 et al. 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 et al. Interpretable CNN–KAN hybrid architectures for tabular data with synthetic image encoding. Information Processing and Management. DOI: 10.1016/j.ipm.2026.104954

4. Manuel Castillo-Cara et al. MIMO-Based Indoor Localisation with Hybrid Neural Networks. IEEE Journal of Selected Topics in Signal Processing. DOI: 10.1109/JSTSP.2025.3555067

5. Reewos Talla-Chumpitaz, Manuel Castillo-Cara et al. Blurring Image Techniques for Bluetooth-based Indoor Localisation. Information Fusion. DOI: 10.1016/j.inffus.2022.10.011

Software articles

1. Jiayun Liu et al. 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 et al. 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

03 Jun 2026 TINTOlib

Improving Deep Learning by Exploiting Synthetic Images — Part II: From Synthetic Images to Hybrid Neural Networks

TINTOlib Synthetic Images Tabular-to-Image Hybrid Neural Networks

Read article →

28 May 2026 TINTOlib

What is TINTOlib and why should we transform tabular data into synthetic images?

TINTOlib Tabular Data Synthetic Images Deep Learning

Read article →

27 May 2026 TINTOlib

Introduction to TINTOlib: Unlocking the Power of Vision Architectures for Tabular Data

TINTOlib Tabular-to-Image Synthetic Images Deep Learning

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 et al. 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 et al. 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 et al. Interpretable CNN–KAN hybrid architectures for tabular data with synthetic image encoding. Information Processing and Management. DOI: 10.1016/j.ipm.2026.104954

4. Manuel Castillo-Cara et al. MIMO-Based Indoor Localisation with Hybrid Neural Networks. IEEE Journal of Selected Topics in Signal Processing. DOI: 10.1109/JSTSP.2025.3555067

5. Reewos Talla-Chumpitaz, Manuel Castillo-Cara et al. Blurring Image Techniques for Bluetooth-based Indoor Localisation. Information Fusion. DOI: 10.1016/j.inffus.2022.10.011

Software articles

1. Jiayun Liu et al. 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 et al. 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

03 Jun 2026 TINTOlib

Improving Deep Learning by Exploiting Synthetic Images — Part II: From Synthetic Images to Hybrid Neural Networks

TINTOlib Synthetic Images Tabular-to-Image Hybrid Neural Networks

Read article →

02 Jun 2026 TINTOlib

Improving Deep Learning by Exploiting Synthetic Images — Part I: Why Tabular Data Needs Spatial Representations

TINTOlib Synthetic Images Tabular-to-Image Tabular Data

Read article →

27 May 2026 TINTOlib

Introduction to TINTOlib: Unlocking the Power of Vision Architectures for Tabular Data

TINTOlib Tabular-to-Image Synthetic Images Deep Learning

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 et al. 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 et al. 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 et al. Interpretable CNN–KAN hybrid architectures for tabular data with synthetic image encoding. Information Processing and Management. DOI: 10.1016/j.ipm.2026.104954

4. Manuel Castillo-Cara et al. MIMO-Based Indoor Localisation with Hybrid Neural Networks. IEEE Journal of Selected Topics in Signal Processing. DOI: 10.1109/JSTSP.2025.3555067

5. Reewos Talla-Chumpitaz, Manuel Castillo-Cara et al. Blurring Image Techniques for Bluetooth-based Indoor Localisation. Information Fusion. DOI: 10.1016/j.inffus.2022.10.011

Software articles

1. Jiayun Liu et al. 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 et al. 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

03 Jun 2026 TINTOlib

Improving Deep Learning by Exploiting Synthetic Images — Part II: From Synthetic Images to Hybrid Neural Networks

TINTOlib Synthetic Images Tabular-to-Image Hybrid Neural Networks

Read article →

02 Jun 2026 TINTOlib

Improving Deep Learning by Exploiting Synthetic Images — Part I: Why Tabular Data Needs Spatial Representations

TINTOlib Synthetic Images Tabular-to-Image Tabular Data

Read article →

28 May 2026 TINTOlib

What is TINTOlib and why should we transform tabular data into synthetic images?

TINTOlib Tabular Data Synthetic Images Deep Learning

Read article →