The field of Artificial Intelligence (AI) has witnessed remarkable progress in recent years, driven by advances in machine learning and, in particular, deep learning. Within this landscape, Generative Adversarial Networks (GANs), introduced by Goodfellow et al. [1], have revolutionized the field of generative modeling. GANs offer a unique approach to learning complex data distributions by pitting two neural networks against each other: a generator and a discriminator. The generator aims to create synthetic data that is indistinguishable from real samples, while the discriminator learns to differentiate between real and generated data. This adversarial process drives both networks to improve, leading to the generation of increasingly realistic and high-quality samples.

Early GANs held immense promise but were hindered by several challenges. Mode collapse, a phenomenon where the generator produces only a limited variety of outputs, severely restricts the diversity of generated data. Training instability, characterized by oscillations and non-convergence of the loss functions, makes it difficult to achieve optimal performance. Furthermore, the perceptual quality of generated images often fell short of expectations, lacking the fine details and structural coherence of real images.

Over the years, researchers have proposed numerous techniques to address the limitations of traditional GANs. Wasserstein GAN (WGAN) (Arjovsky et al. [2]; Gulrajani et al. [3]) introduced the Wasserstein distance as a more robust metric for comparing distributions, leading to improved training stability. WGAN-GP Gulrajani et al. [3] further enhanced stability by adding a gradient penalty term to the loss function. Least Squares GAN (LSGAN) Mao et al. [4] employed a least squares loss function to penalize fake samples that lie far from the decision boundary, promoting more stable training. Spectral-Normalized GANs (SN-GANs) Miyato et al. [5] applied spectral normalization to the discriminator to control its Lipschitz constant, further improving stability. Self-Attention GAN (SAGAN) Zhang et al. [6] used self-attention mechanisms to capture long-range dependencies in images, enhancing the generation of fine-grained details.

These innovations have leading to more stable training and improved generated samples quality. However, balancing perceptual quality and diversity remains a central challenge, especially in image synthesis tasks. Traditional GAN loss functions often rely on pixel-wise differences, which fail to capture the complex structural and perceptual features that are critical for generating realistic images.

The Structural Similarity Index (SSIM) Wang et al. [7] has emerged as a powerful metric for assessing image quality by considering luminance, contrast, and structural information. Unlike pixel-based metrics, SSIM aligns more closely with human visual perception. Integrating SSIM into GAN training as a loss function encourages the generator to produce images that are structurally similar to real images, leading to improved perceptual quality.

Several studies have explored the use of SSIM-based losses in GANs for various image processing tasks. These methods have shown promising results in preserving textures, enhancing details, and generating more visually plausible images. By prioritizing perceptual metrics over pixel accuracy, SSIM-based losses offer a significant advantage over traditional GAN loss functions.

Fuzzy logic provides a powerful framework for modeling uncertainty and imprecise information. T-norms, which generalize the logical AND operation, allow for the aggregation of multiple criteria in a flexible and robust manner. By incorporating fuzzy logic t-norms into GAN loss functions, we can capture nuanced relationships between image regions, improve robustness to noise, and enhance the overall quality of generated images.

Recent research has explored the use of fuzzy logic in GANs, demonstrating its potential to improve training stability and sample quality. For example, Sugeno complement-based loss functions Farhadinia et al. [8] introduce non-linear interactions between training and generated data, leading to improved performance. However, these approaches may suffer from saturation effects and suboptimal gradient behavior.

This paper introduces a novel GAN loss function, termed SSIM_T, that combines the strengths of SSIM and fuzzy logic t-norms. SSIM_T leverages the perceptual sensitivity of SSIM to capture structural similarities between real and generated images while utilizing fuzzy logic t-norms to model the relationships between different aspects of the images. This combination allows for a more robust and flexible loss function that promotes both perceptual quality and training stability.

The novel contribution of this paper is using SSIM_T loss function for GANs that integrates structural similarity with fuzzy logic t-norms. A theoretical analysis demonstrating that SSIM_T outperforms existing loss functions, including Sugeno complement-based formulations. Extensive experimental results on benchmark datasets confirming that SSIM_T mitigates mode collapse, stabilizes training dynamics, and produces visually coherent outputs.

The remainder of this paper is organized as follows: Section 2 provides a background on GANs, including a discussion of the mathematical framework and common training challenges. Section 3 details the proposed SSIM_T loss function and provides a theoretical analysis of its properties. Section 4 presents the experimental results, comparing SSIM_T to our proposed GAN methods. Section 5 discusses the implications of the results and suggests directions for future research. Finally, Section 6 concludes the paper with a summary of the key

At its core, a GAN consists of two neural networks locked in an adversarial game: the Generator (G) and the Discriminator (D). The main role of generator is to transform random noise (z) from a prior distribution (e.g., a Gaussian distribution) into synthetic data that resembles real data (x) from a target distribution. The discriminator, on the other hand, learns to distinguish between real data and the fake data produced by the generator.

Mathematically, the GAN objective can be expressed as a minimax problem:

min_G max_D V(D, G) = E_{x~p_data(x)}[log D(x)] + E_{z~p_z(z)}[log(1 − D(G(z)))], where E denotes the expected value, p_data(x) is the distribution of real data, p_z(z) is the distribution of the input noise, D(x) is the probability that the discriminator assigns to a real data sample x, G(z) is the generated data sample from input noise z and D(G(z)) is the probability that the discriminator assigns to a generated data sample G(z).

The discriminator aims to maximize V(D, G), correctly classifying both real and fake data. The generator aims to minimize V(D, G), producing fake data that fools the discriminator. The goal of training is to find a Nash equilibrium where neither the generator nor the discriminator can improve their performance by unilaterally changing their strategy.

Training GANs effectively remains a significant challenge due to several factors. Mode Collapse is the first and most common issue. In this case, the generator may learn to produce only a limited set of outputs, failing to capture the full diversity of the real data distribution. Vanishing Gradients is the second challenge and occurs when the discriminator becomes too good at distinguishing real and fake data and the gradients passed back to the generator may become very small, hindering its learning process. The third challenge is non-convergence of training procedure and may cuase the adversarial training process can lead to oscillations and non-convergence, making it difficult to find a stable equilibrium. The loss functions of the generator and discriminator may fluctuate wildly during training. The fifth issue is Sensitivity to Hyperparameters. GAN performance is highly sensitive to the choice of hyperparameters, such as learning rates, batch sizes, and network architectures. Finding the optimal hyperparameter settings often requires extensive experimentation.

The SSIM Wang et al. [7] is a perceptual metric that assesses image quality by comparing local patterns of luminance, contrast, and structure between two images:

SSIM(x, y) = l(x, y) × c(x, y) × s(x, y).

Where x and y are the two image patches being compared, l(x, y) is the luminance comparison function, c(x, y) is the contrast comparison function and s(x, y) is the structure comparison function. The SSIM value ranges from -1 to 1, with 1 indicating perfect similarity. SSIM is more robust than pixel-based metrics because it takes into account the spatial relationships between pixels and the overall structural information of the image.

Fuzzy logic provides a way to represent and reason with uncertain or imprecise information. T-norms are fuzzy logic operators that generalize the logical AND operation, allowing for the aggregation of multiple criteria in a flexible manner. Common t-norms include:

I. Minimum t-norm: T(a, b) = min(a, b).

II. Product t-norm: T(a, b) = a * b.

III. Lukasiewicz t-norm: T(a, b) = max(0, a + b - 1).

The choice of t-norm can significantly impact the performance of the SSIM_T loss function. The product t-norm is often a good choice because it is differentiable and provides a smooth aggregation of the SSIM and norm proportionality terms.

The SSIM_T loss function is defined as:

Let lum, cont and struct denote the luminance, contrast and structure similarity maps between the real and generated images, respectively. The loss function for each component is defined as:

Lumnew = 1 − prod(lum, lum),

Contnew = 1 − prod(cont, cont),

Structnew = 1 − prod(struct, struct).

Thus the overall loss is computed as the average of the three component losses as below:

lumnew + contnew + structnew Totalloss = .

This new loss function in comparison to SSIM based loss functions have several advantages as mentioned below:

Consider the following example to illustrate the difference between SSIM-based loss and ours:

Let lum=0.9, cont=0.1 and struct=0.9 then the SSIM-based loss computed as below:

Loss = 1 – (0.9 × 0.1 × 0.9) = 1 − 0.081 = 0.919.

and the proposed loss function computed as:

lumnew = 1 − 0.81 = 0.19,

contnew = 1 − 0.01 = 0.99,

structnew = 1 – 0.81 = 0.19,

0.19 + 0.99 + 0.19 totalloss = ≈ 0.46.

This example demonstrated that the SSIM-based losses is dominated by the smallest component, while our loss more accurately refelects the indivisual performance of each attribute, providing more informative gradients and facilitating balanced learning.