Optimizing PROAFTN classifier with ant colony algorithm: enhanced diabetes detection benchmarking

PROAFTN notations

Table 1 summarizes the PROAFTN notations used in this study, clearly understanding the mathematical symbols and variables integral to the PROAFTN method.

In the context of the PROAFTN method, these notations quantitatively represent the objects to be classified, the defining attributes, the prototypes for each class, and the preference thresholds and attribute weights within each category. Together, these elements form the mathematical framework that underpins the PROAFTN classifier and allows its effective operation.

Fuzzy intervals

Fuzzy intervals are crucial in data mining, particularly in the rule-induction process. Standard data mining systems, such as those for rule induction and decision tree construction, discretize numerical domains into intervals when dealing with both numerical and nominal attributes. The resultant discretized intervals are then processed like nominal values during the rule induction phase. This document introduces a type of fuzzy interval used in the HCV version 2.0 rule-induction software, which helps interpret rule-induction outcomes when rules with sharply defined intervals cannot provide a precise application path for a given test example. The utility of these fuzzy intervals is underscored by a series of experimental results obtained through the application of HCV.

Assuming a set of $n$ objects, denoted as a training set, we consider an object $a\in n$ that is yet to be classified. This object $a$ is characterized by a set of $m$ attributes $\{g_1,g_2,\dots ,g_m\}$, and is to be classified into one of $k$ classes $\{C^1,C^2,\dots ,C^k\}$. The procedure is broken down into the following steps:

For each class $C^h$, a set of $L_h$ prototypes is identified. For every prototype $b_i^h$ and each attribute $g_j$, an interval $[S_j^1(b_i^h)$, $S_j^2(b_i^h)]$ is specified such that $S_j^2(b_i^h)\ge S_j^1(b_i^h)$. The introduction of two thresholds, $d_j^1(b_i^h)$ and $d_j^2(b_i^h)$, allows us to define the fuzzy intervals: the pessimistic interval $[S_j^1(b_i^h),S_j^2(b_i^h)]$ and the optimistic interval $[S_j^1(b_i^h)-d_j^1(b_i^h),S_j^2(b_i^h)+d_j^2(b_i^h)]$. Optimistic assessments reduce the strictness of the interval boundaries, thereby narrowing the gap between the borderline and typical cases. For example, a slightly elevated glucose level can still contribute to positive membership in the diabetic class under the optimistic view, improving sensitivity.

Figure 1 visually presents the interval representation within PROAFTN. For the implementation of PROAFTN, both the pessimistic interval $[S_{jh}^1,S_{jh}^2]$ and the optimistic interval $[q_{jh}^1,q_{jh}^2]$ (Belacel, Raval & Punnen, 2007) for each attribute in each class. Figure 1 also underscores the importance of avoiding extreme cases in evaluating specific measures or quantities with a crisp interval, namely, overestimating or underestimating the interval. Using crisp intervals risks excluding borderline patients or overfitting to outliers. By avoiding extreme cases and employing fuzzy intervals, PROAFTN ensures a balance between conservative and optimistic assessments, enabling more robust medical predictions.

In contrast, a pessimistic evaluation can widen the interval, leading to a conservative estimate that might overlook some potentially significant observations. However, an overly optimistic assessment can narrow the gap, potentially managing outliers and leading to excessively narrow generalizations.

Therefore, PROAFTN employs fuzzy intervals to balance pessimistic and optimistic extremes. This allows for a more nuanced evaluation that can effectively handle the uncertainty and vagueness present in the data. The adoption of fuzzy intervals in PROAFTN accommodates a broader range of values, enhancing its applicability and flexibility in different contexts. In addition, these intervals are determined based on expert knowledge or data-driven methods, strengthening the interpretability and robustness of the model.

In the context of the implementation of PROAFTN, the fuzzy intervals provide a more dynamic representation that accommodates the inherent uncertainties and variations within the data, thus creating an adaptable and resilient model. This nuanced approach further bolsters PROAFTN’s ability to handle complex classification tasks and yield insightful results effectively.

(1a) $$q_{jh}^1=S_{jh}^1-d_{jh}^1$$

(1b) $$q_{jh}^2=S_{jh}^2+d_{jh}^2$$applied to:

(2a) $$q_{jh}^1\le S_{jh}^1.$$

(2b) $$q_{jh}^2\ge S_{jh}^2.$$

Hence, $S_{jh}^1$ = $S_j^1(b_i^h)$, $S_{jh}^2$ = $S_j^2(b_i^h)$, $q_{jh}^1$ = $q_j^1(b_i^h)$, $q_{jh}^2$ = $q_j^2(b_i^h)$, $d_{jh}^1$ = $d_j^1(b_i^h)$, and $d_{jh}^2$ = $d_j^2(b_i^h)$. The following subsections explain the stages required to classify object $a$ to class $C^h$ using PROAFTN. Here, $[S_{jh}^1,S_{jh}^2]$ denote lower and upper fuzzy bounds for attribute j in class h; $[d{1}_{jh}]$ and $[d{1}_{jh}]$ are expansion thresholds; wjh represents attribute weights. Together, these parameters define class prototypes and guide membership calculation.

In this way, the performance matrix captures the comparative relationship between each attribute $g_j$ of the object $a$ and the corresponding attribute in each prototype $b_i^h$ from each class $C^h$. This comparison based on individual attributes facilitates a detailed and comprehensive evaluation of the object’s relationship with the prototypes, further aiding the subsequent classification process.

As a note, the degree of partial fuzzy indifference $C_{jh}^i(a,b_i^h)$ is a number that falls within the range [0, 1], where 0 indicates no similarity between the attribute value of the object and the prototype, and 1 indicates complete similarity or ‘indifference’ A value between 0 and 1 indicates partial similarity or ‘weak indifference.’

To illustrate this process, let us consider a hypothetical case where we have a set of attributes $\{g_1,g_2,g_3\}$ and two prototypes $b_1^1$ and $b_2^1$, from the same class. If we denote the attribute values for object $a$ by $a=\{a_1,a_2,a_3\}$, the calculation of the degree of partial fuzzy indifference between object $a$ and each prototype would be carried out as follows:

For prototype $b_1^1$, we calculate $C_{11}^1(a,b_1^1)$, $C_{21}^1(a,b_1^1)$, and $C_{31}^1(a,b_1^1)$ based on attribute values $g_1$, $g_2$, and $g_3$ respectively. Similarly, for prototype $b_2^1$, we calculate $C_{12}^1(a,b_2^1)$, $C_{22}^1(a,b_2^1)$, and $C_{32}^1(a,b_2^1)$.

This process is repeated for all prototypes across all classes, resulting in a comprehensive performance matrix that contains the degree of partial fuzzy indifference for each prototype against each attribute of the object $a$.

Once the performance matrix is calculated, the next step in the classification process involves calculating the total fuzzy indifference relation $I(a,b_i^h)$ for each prototype, which involves a weighted summation of the individual attribute-based fuzzy indifference degrees as given by Eq. (5).

Applying the fuzzy indifference concept within the framework of the PROAFTN algorithm allows effective handling of uncertainty, making it a potent tool for tackling complex classification tasks in areas such as data mining and machine learning.

Calculation of the fuzzy indifference relation: $I(a,b_i^h)$

The classification procedure begins with the computation of the fuzzy indifference relation, $I(a,b_i^h)$. This is a concept derived from the principles of concordance and non-discordance, serving to quantify the relationship, or the degree of membership, between an object to be assigned and a prototype (Belacel, 1999; Belacel, Raval & Punnen, 2007). The fuzzy indifference relation is formulated as follows:

(3) $$I(a,b_i^h)=\left(\sum _{j=1}^m{w}_{jh}{C}_{jh}^i(a,b_i^h)\right)\prod _{j=1}^m\left(1-D_{jh}^i{(a,b_i^h)}^{w_{jh}}\right).$$

Here, $w_{jh}$ is the weight that signifies the relevance of an attribute $g_j$ for a specific class $C^h$ and is constrained as follows:

$$w_{jh}\in [0,1],\mathrm{a}\mathrm{n}\mathrm{d}\sum _{j=1}^m{w}_{jh}=1.$$

The term $C_{jh}^i(a,b_i^h)$ denotes the degree to which the object $a$ is close to the prototype $b_i^h$ based on the attribute $g_j$ and is computed as:

(4) $$C_{jh}^i(a,b_i^h)=min\{C_{jh}^{i1}(a,b_i^h),C_{jh}^{i2}(a,b_i^h)\},$$where

$$C_{jh}^{i1}(a,b_i^h)=\frac{d_j^1(b_i^h)-min\{S_j^1(b_i^h)-g_j(a),d_j^1(b_i^h)\}}{d_j^1(b_i^h)-min\{S_j^1(b_i^h)-g_j(a),0\}}$$and

$$C_{jh}^{i2}(a,b_i^h)=\frac{d_j^2(b_i^h)-min\{g_j(a)-S_j^2(b_i^h),d_j^2(b_i^h)\}}{d_j^2(b_i^h)-min\{g_j(a)-S_j^2(b_i^h),0\}}.$$

The discordance index, $D_{jh}^i(a,b_i^h)$, measures the dissimilarity between the object $a$ and the prototype $b_i^h$ based on the attribute $g_j$. This index employs two veto thresholds ${\epsilon }_j^1(b_i^h)$ and ${\epsilon }_j^2(b_i^h)$ (Belacel, 2000). The object $a$ is considered perfectly distinct from the prototype $b_i^h$ if the attribute $g_j$ reaches these veto thresholds. However, as defining veto thresholds via inductive learning can be risky and requires expert input, this study focuses on an automatic approach, thus setting the veto thresholds to infinity, effectively eliminating their impact. As a result, the computation simplifies to relying solely on the concordance principle, which can be expressed as:

(5) $$I(a,b_i^h)=\sum _{j=1}^m{w}_{jh}{C}_{jh}^i(a,b_i^h).$$

Three comparative scenarios between object $a$ and prototype $b_i^h$ based on attribute $g_j$ can be outlined (Fig. 1):

• Strong Indifference:

  $C_{jh}^i(a,b_i^h)=1$ $\iff g_j(a)\in [S_{jh}^1,S_{jh}^2]$; (i.e., $S_{jh}^1\le g_j(a)\le S_{jh}^2$)

• No Indifference:

  $C_{jh}^i(a,b_i^h)=0$ $\iff g_j(a)\le q_{jh}^1$, or $g_j(a)\ge q_{jh}^2$

• Weak Indifference:

  The value of $C_{jh}^i(a,b_i^h)\in (0,1)$ is derived from Eq. (4). (i.e., $g_j(a)$ $\in$ $[q_{jh}^1,S_{jh}^1]$ or $g_j(a)$ $\in$ $[S_{jh}^2,q_{jh}^2]$)

The study and application of such functions are well documented in Marchant (2007) and Ban & Coroianu (2015).

By encapsulating the concept of fuzzy indifference, the PROAFTN classification algorithm adeptly manages the inherent uncertainty in data, providing a robust solution to complex classification tasks in fields such as data mining and machine learning.

Estimation of membership degree: $\delta (a,C^h)$

To determine the degree of membership, $\delta (a,C^h)$, between an object $a$ and a class $C^h$, the PROAFTN classification algorithm takes advantage of the degrees of difference between $a$ and its closest prototype within the class $C^h$. This approach helps to quantify the degree to which the object $a$ aligns with a specific class based on its similarity to its representative prototypes.

The determination of the nearest prototype is achieved through an exhaustive comparison of the indifference degrees of $a$ with all prototypes $b_i^h$ within $B^h$. Thus, the maximum indifference degree acquired will denote the most similar or ‘nearest’ prototype. This can be mathematically represented as:

(6) $$\delta (a,C^h)=max\{I(a,b_1^h),I(a,b_2^h),\dots ,I(a,b_{L_h}^h)\}.$$

The resultant $\delta (a,C^h)$ measures the object’s affinity to class $C^h$, a higher value indicating a stronger association.

Classification of an object: assignment to the appropriate class

Upon computing the membership degrees between the object $a$ and all classes, the final step is to assign $a$ to the class that maximizes this degree. This step effectively assigns the object to the class with the highest similarity based on the calculated indifference degrees.

The assignment is executed via the following decision rule:

(7) $$a\in C^h\iff \delta (a,C^h)=max\{\delta (a,C^i)/i\in \{1,\dots ,k\}\}.$$

This rule asserts that an object $a$ belongs to a class $C^h$ if and only if the membership degree $\delta (a,C^h)$ is the highest among all the membership degrees calculated in the set of all classes $\{1,\dots ,k\}$.

Through this comprehensive process, PROAFTN ensures robust and reliable object classification, considering the inherent uncertainty and ambiguity present in the data. As such, the algorithm’s results provide valuable insight for various applications in fields such as data mining, machine learning, and decision analysis.

The classification process in PROAnt begins by estimating the degree to which each input attribute value belongs to class-specific fuzzy intervals. These intervals are represented using triangular membership functions defined by three parameters: the lower bound ( $l$), modal point ( $m$), and upper bound ( $u$). Each input instance $x=[x_1,x_2,\dots ,x_n]$ is evaluated against each class prototype $p_c$ composed of attribute-specific intervals $I_{jc}$.

For a given attribute $x_j$ and class $c$, the membership degree ${\mu }_{jc}(x_j)$ is calculated using Eq. (8), which applies a piecewise linear function to assess the closeness of $x_j$ to the modal point $m_{jc}$ of the fuzzy interval. The resulting degree, in the range [0, 1], represents how well the attribute value aligns with the prototype.

To reach a classification decision, PROAnt aggregates the membership degrees across all attributes using a weighted summation:

(8) $$S(p_c,x)=\sum _{j=1}^n{w}_j\cdot {\mu }_{jc}(x_j).$$

Here, $w_j$ represents the relative importance of attribute $j$, also learned using the ACO process. The target class label is determined by selecting the prototype $p_c$ with the highest aggregated score $S(p_c,x)$. This method allows for a transparent and interpretable decision-making process, where each classification is the result of systematically comparing attribute values to fuzzy interval definitions tailored for each class.

The characteristics considered in this classification process include: the fuzzy boundaries of each attribute per class (capturing uncertainty); attribute importance (weights); the overall similarity score (preference score) between the object and each class prototype.

These elements collectively enable the model to map input features to class labels (e.g., diabetes-positive or diabetes-negative) with high precision and interpretability.

Augmenting PROAFTN learning with ant colony optimization

As discussed previously, ACO is inspired by the food search behavior of ants and is a probabilistic method designed to solve computational problems by identifying the optimal path in the search space. The algorithm is based on how ants communicate through pheromones, depositing them along their paths. Over time and after several iterations, the hottest route accumulates the most pheromones, as ants travelling this path return more quickly to reinforce it. This natural process is a powerful optimization approach that allows ACO to effectively identify practical solutions to complex problems.

Let us outline a high-level presentation of an ACO algorithm as represented in Fig. 2:

• Start: Begin.

• Initialize parameters: parameters initialization including number of ants, pheromone evaporation rate, etc.

• Create ants: Generate ants to start the search process. Each ant will be part of the problem space and construct a potential solution.

• Perform ant movements: Each ant navigates the problem space by combining pheromone trail information with a heuristic search until the tour is complete.

• Update pheromone trails: Once all ants finish their tours, pheromone trails are updated with stronger trails assigned to better solutions

• Termination condition: Check if the termination condition is met, such as the number of iterations or the target improvement.

• Yes: The algorithm ends if the termination condition is met and the best solution is returned as the output.

• No: If the termination condition is not met, repeat the movements of the ants and continue the process.

• Output best solution: Output the best solutions identified by the ants after the algorithm is over.

• End: The algorithm ends.

ACO is inspired by the foraging behavior of real ants that deposit and follow pheromone trails. ACO is generally used to find the optimal path in a graph. Ants traverse the graph and deposit a chemical, called a pheromone, on the paths they take. The amount of pheromone on a path is a probabilistic indicator of its shortness, and ants prefer to move along paths with more pheromone.

In PROAnt we map this behavior to parameter search as follows: each artificial ant represents a candidate PROAFTN parameter vector (interval bounds and weights); an ant tour constructs a candidate prototype set by selecting parameter values probabilistically using the transition rule that combines pheromone intensity and heuristic desirability; pheromone deposit increases probability for parameter choices that produced higher classification fitness, while pheromone evaporation prevents premature convergence. This mapping allows ACO to favor high-quality parameter regions (exploitation) while retaining exploration via stochastic choices and evaporation, enabling efficient navigation of the continuous PROAFTN parameter space. Over time, shorter paths have more pheromones and are more attractive to ants, as described in the Algorithm 2.

Explanations of the algorithm:

• Initialization of pheromones: setting initial values for the pheromones on all paths.

• $t\leftarrow 0$: initializes iteration to zero. It is used to keep track of the number of iterations or generations in the algorithm.

• Termination condition: The loop continues until a termination condition is met and no further improvements are found.

• Increment in the time step $t\leftarrow t+1$: This increments the iteration counter.

• Place each ant in a starting position: each ant is placed at a starting point, which could be random or fixed, depending on the specific implementation of the algorithm.

• For each ant $k$: The algorithm iterates over each ant in the colony. Each ant builds its solution independently.

• Ant completes its solution: Each ant repeatedly chooses the next position within this loop based on a probabilistic decision rule until it completes a tour or a solution.

• Choose the next position using rule $p$: The rule $p$ typically depends on the amount of pheromone on the trail and the local heuristic information.

• Move the ant $k$ to the new position: the ant moves to that position, effectively constructing part of its solution.

• Update pheromones ${\tau }_{ij}\leftarrow (1-\rho )\cdot {\tau }_{ij}+\mathrm{\Delta }{\tau }_{ij}$: After all ants have completed their solutions, the pheromones are updated. The formula here shows two components: - $(1-\rho )\cdot {\tau }_{ij}$: represents the evaporation of the existing pheromone, where $\rho$, ( $0<\rho <1$) is the rate of evaporation of the pheromone.

  - $\mathrm{\Delta }{\tau }_{ij}$: This is the amount of pheromone deposited, which is typically a function of the quality of the solution that an ant has found (better solutions contribute more pheromones).

• Pheromone evaporation: Pheromones, over time, trail and evaporate, reducing their strength. This prevents the algorithm from converging prematurely to a local optimum.

• Output best solution found: At the end of the algorithm, the best solution any ant finds is reported as the algorithm’s output.

These steps collectively describe the typical flow of the ACO algorithm, emphasizing how ants collectively solve complex problems through simple rules and indirect communication via pheromones.

Please note that ACO algorithms can vary quite a bit in detail, so this version is somewhat simplified and general. Different problems might require different variations of ACO. However, the general principle remains the same: ants construct solutions, and then the pheromone trails are updated to reflect the quality of these solutions, guiding the search for promising regions of the space. For more extensive elaboration, the methodology and its application are detailed in Dorigo & Stützle (2004).

Learning PROAFTN using ant colony optimization (PROAnt)

Based on the ACO algorithm, a novel approach was proposed to train the MCDA fuzzy classifier PROAFTN named PROAnt. Inspired by the foraging behaviour of ants, ACO was used to induce a high-performance classification model for PROAFTN. The exploration and exploitation capabilities of ACO and implicit parallelism make it a stable choice for this task (Dorigo & Stützle, 2004).

The methodology was initiated by formulating an optimization model, which the ACO algorithm subsequently used to solve. ACO uses training samples to iteratively adjust the parameters of PROAFTN, shaping the so-called “prototypes.” These prototypes embody the classification model and are used to classify unknown samples. The ultimate goal of this learning process is to discover the prototype set that maximizes the classification accuracy for each dataset.

The performance of PROAnt applied to different classification datasets underscores the efficacy of this approach. Comparative analyzes demonstrated that PROAnt consistently outperforms other well-established classification methods, demonstrating its value in data classification.

In our work, ACO can be employed to find the optimal values for the parameters: the intervals $[S_j^1(b_i^h)$, $S_j^2(b_i^h)]$, thresholds $[d_j^1(b_i^h)$, $d_j^2(b_i^h)]$ and $w$, it is necessary to find the most suitable values for these parameters to construct the best PROAFTN prototypes.

To frame this as an optimization problem, we aim to maximize the classification accuracy. The formulation can be stated as follows:

In this case, the objective or fitness function $f$ depends on the precision of classification, and $n$ is the set of training samples. The procedure for calculating the fitness function $f$ is described in Eq. (15). The result of the optimization problem can vary within the interval [0, 100].

Here, the algorithm starts by initializing pheromone trails and then constructs solutions using a probabilistic rule in a loop until the termination condition is met. A local search is optionally applied to find better solutions in the neighbourhood of the current solutions. After that, pheromones are updated, increasing for reasonable solutions and evaporating over time. Finally, the algorithm returns the best solution found.

In the context of this work, the ants in the algorithm represent possible solutions, each characterized by particular parameters: values of $[S_j^1(b_i^h)$, $S_j^2(b_i^h)]$ and thresholds $[d_j^1(b_i^h)$, $d_j^2(b_i^h)]$. Ants traverse the solution space guided by pheromone trails and heuristic information, which, in our case, could be derived from the dataset characteristics. During the solution construction phase, each ant probabilistically chooses the following parameters based on the intensity of the pheromone trail and the heuristic information. After all, ants have built their solutions; a local search can be applied to exploit promising regions of the solution space. The pheromone trails are then updated to guide the next generation of solutions: The intensity increases if the associated solution is good (i.e., it leads to higher classification accuracy) and gradually evaporates otherwise. The process is repeated until the termination condition is met, which could be a predetermined number of iterations, a stagnation condition, or a satisfactory quality of the solution. The final output is the best solution found during the iterations, giving the optimal $[S_j^1(b_i^h)$, $S_j^2(b_i^h)]$ and threshold values $[d_j^1(b_i^h)$, $d_j^2(b_i^h)]$ for the PROAFTN methodology.

When applied to our problem of finding optimal values $[S_j^1(b_i^h)$, $S_j^2(b_i^h)]$ and thresholds $[d_j^1(b_i^h)$, $d_j^2(b_i^h)]$, each ant constructs a solution by traversing the space of potential combinations. The pheromone trail is updated based on the fitness of the solutions found, promoting the regions of the search space that led to better classification results.

As previously discussed, for implementing PROAFTN, the pessimistic interval $[S_{jh}^1,S_{jh}^2]$ and the optimistic interval $[q_{jh}^1,q_{jh}^2]$ for each attribute in each class must be established, where:

(13) $$q_{jh}^1=S_{jh}^1-d_{jh}^1{q}_{jh}^2=S_{jh}^2+d_{jh}^2$$

Such that:

(14) $$q_{jh}^1\le S_{jh}^1{q}_{jh}^2\ge S_{jh}^2$$

Therefore, $S_{jh}^1=S_j^1(b_i^h)$, $S_{jh}^2=S_j^2(b_i^h)$, $q_{jh}^1=q_j^1(b_i^h)$, $q_{jh}^2=q_j^2(b_i^h)$, $d_{jh}^1=d_j^1(b_i^h)$, and $d_{jh}^2=d_j^2(b_i^h)$.

As noted, to implement PROAFTN, the intervals $[S_{jh}^1$, $S_{jh}^2]$ and $[q_{jh}^1,q_{jh}^2]$ must meet the constraints in Eq. (14), and weights $w_{jh}$ must be obtained for each attribute $g_j$ in class $C^h$. To simplify the constraints in Eq. (14), variable substitution based on Eq. (13) is employed. As a result, the parameters $d_{jh}^1$ and $d_{jh}^2$ are used instead of $q_{jh}^1$ and $q_{jh}^2$, respectively. Consequently, the optimization problem, grounded on maximizing classification accuracy by providing the optimal parameters $S_{jh}^1,S_{jh}^2,d_{jh}^1,d_{jh}^2$ and $w_{jh}$, is defined here:

(15) $$\begin{array}{rl}P:\mathrm{M}\mathrm{a}\mathrm{x}\mathrm{i}\mathrm{m}\mathrm{i}\mathrm{z}\mathrm{e}& f(S_{jh}^1,S_{jh}^2,d_{jh}^1,d_{jh}^2,w_{jh})\\ \mathrm{S}\mathrm{u}\mathrm{b}\mathrm{j}\mathrm{e}\mathrm{c}\mathrm{t}\mathrm{t}\mathrm{o}:& S_{jh}^1\le S_{jh}^2;d_{jh}^1,d_{jh}^2\ge 0\\ & \sum _{j=1}^m{w}_{jh}=1\\ & 0\le w_{jh}\le 1\end{array}$$where $f$ is the function that calculates classification accuracy, and $n$ signifies the number of training samples used during optimization. The procedure for calculating the fitness function $f(S_{jh}^1,S_{jh}^2,d_{jh}^1,d_{jh}^2,w_{jh})$ is depicted in Table 2.

ACO is used to solve the optimization problem presented in Eq. (15). The dimension of the problem D (i.e., the number of parameters in the optimization problem) is described as follows: Each ant $\mathbf{x}$ consists of parameters $S_{jh}^1,S_{jh}^2,d_{jh}^1,d_{jh}^2$ and $w_{jh}$, for all $j=1,2,\dots ,m$ and $h=1,2,\dots ,k$. Thus, each ant in the colony comprises $D=5\times m\times k$ real values (i.e., $\mathbf{x}$ $D=dim(\mathbf{x})$).

The procedure for calculating the fitness function $f(S_{jh}^1,S_{jh}^2,d_{jh}^1,d_{jh}^2,w_{jh})$ is detailed in Table 2.

In the ACO algorithm, the procedure to update the components (parameters) of an individual ant ${\mathbf{v}}_i$ is based on pheromone trails and heuristic information, as presented below:

An ant ${\mathbf{v}}_i$ chooses the next parameter $S_{jh}^1,S_{jh}^2,d_{jh}^1,d_{jh}^2$ or $w_{jh}$ to include in its solution based on pheromone trails and heuristic information such that:

(16) $$p_{ihj\tau }=\{\begin{array}{cc}\frac{[{\tau }_{ihj}{]}^{\alpha }\cdot [{\eta }_{ihj}{]}^{\beta }}{\sum _{l\in J_{ih}}[{\tau }_{il}{]}^{\alpha }\cdot [{\eta }_{il}{]}^{\beta }},\hfill & \text{i}fh\in J_{ih}\hfill \\ 0,\hfill & \text{otherwise.}\hfill \end{array}$$

Here, $p_{ihj\tau }$ is the probability that ant ${\mathbf{v}}_i$ chooses to move from parameter $hj$ to $\tau$; ${\tau }_{ihj}$ is the amount of pheromone trail on the move from $hj$ to $\tau$; ${\eta }_{ihj}$ is the heuristic information, which is the reciprocal of the distance between parameters $hj$ and $\tau$; $J_{ih}$ is the feasible set of moves for ant ${\mathbf{v}}_i$ at parameter $hj$; $\alpha$ and $\beta$ are parameters controlling the relative importance of the pheromone trail and the heuristic information.

This is in line with the principle of ACO, where the chance of selecting a particular parameter is influenced by the amount of pheromone deposited on it, reflecting the quality of solutions found in previous iterations. This operation forces the process to be applied to each gene selected $\tau$ randomly for each set of five parameters $S_{jh}^1,S_{jh}^2,d_{jh}^1,d_{jh}^2$ and $w_{jh}$ in ${\mathbf{v}}_i$ for all $j=1,2,\dots ,m$ and $h=1,2,\dots ,k$.

In this ACO run, each ant constructs a solution to the problem and evaluates the fitness of that solution in each iteration. In your case, this solution is a set of parameters defining prototypes for each class in a 5-dimensional space. The fitness represents how well that specific set of parameters classifies the Iris dataset, measured as the percentage of correctly classified instances.

ACO mimics the behavior of ants that find the shortest route from their colony to a food source. In this context, an ant is a simple computational agent in the algorithm that probabilistically builds a solution by moving through the problem’s search space. The algorithm maintains a “pheromone trail,” a value associated with each possible decision the ants can make. Ants preferentially choose decisions with higher pheromone values and update the pheromone trail to reflect their success, biasing future ants towards their successful decision.

The ants traverse the search space, updating the pheromone trail until the termination condition is met (in this case, a certain number of iterations). Ultimately, the best solution is chosen based on the highest fitness score.

In the provided code, pheromones influence ants’ movement in the Ant Colony Optimization (ACO) algorithm. The pheromone matrix $pheromones$ is initialized using the $initializePheromones$ method, which sets all the pheromone values to 1.0.

During the movement phase of the ant, the $generateRandomParams$ method generates random parameter values for each ant. Within this method, the pheromones are considered to influence the parameter selection. The $calculateTotalPheromone$ method calculates the total value of pheromones for a specific class, prototype, and combination of attributes. This total pheromone value is compared with a random value, and on the basis of the comparison, the parameter value is selected. Suppose that the random value is greater than the proportion of the pheromone value to the total pheromone value. A random value is chosen for the parameter within the specified bounds (L and H). Otherwise, the value of the existing parameter is modified slightly by adding a small random value and ensuring that it stays within the bounds.

After generating the parameter values for each ant, the fitness is evaluated using the $evaluateFitness$ method. The fitness value is then used to update the pheromones in the $depositPheromones$ method. The increment in pheromone is calculated as ‘Q/fitness,’ and the pheromones are updated by applying the evaporation rate ‘RHO‘ and adding the increment in pheromone.

The pheromones are also evaporated after each iteration in the $evaporatePheromones$ method, where all pheromone values are multiplied by ‘(1.0-RHO)’.

In general, on the basis of the provided code, pheromones appear to influence ants’ movement in the ACO algorithm by guiding the selection of parameter values. In PROAnt, each ant represents a candidate configuration of PROAFTN’s fuzzy parameters. The quality of each configuration is evaluated using classification accuracy as a fitness function. Through pheromone reinforcement, promising parameter combinations receive higher probabilities of selection in subsequent iterations. This iterative process enables ACO to inductively infer optimal intervals and weights directly from the training data, replacing manual parameter tuning.

The provided code initializes and sets the lower (L) and upper (H) boundaries for each class attribute. The boundaries are defined based on some given threshold values (thresholds). The code uses these boundaries later to constrain the ant colony algorithm’s search space, ensuring that solutions do not exceed specified ranges.

Interpretable fuzzy classification with PROAFTN: membership function design and application to iris data

In fuzzy multicriteria classification, the PROAFTN model relies on a set of key parameters that govern its decision rules. For every attribute in each class, four fuzzy thresholds—S1, S2, q1 and q2—define the pessimistic and optimistic boundaries of the membership function, while the weight (w) expresses the relative importance of that attribute in the overall decision process. In addition to these parameters, PROAFTN requires prototypes, which serve as representative profiles for each class. Each prototype encapsulates the corresponding fuzzy thresholds and weights for all attributes; thus, a prototype is not a single training sample but a structured entity that integrates the values (S1, S2, q1, q2, w) across all attributes of a class. These prototypes collectively form the core of the classifier, and their quality directly determines performance.

These prototypes collectively form the core of the PROAFTN classification model, and their quality directly affects the performance of the classifier. During inference, new instances are compared against the set of learned prototypes to determine their most suitable class, based on similarity measures derived from fuzzy membership degrees. Thus, the process of learning effective prototypes is equivalent to learning the classification model itself and is essential to ensure accurate and robust decision making in fuzzy environments.

To illustrate the concept of PROAFTN classification, we use an example in Python with the Iris data. Iris contains 150 samples, each belonging to one of three sets of classes setosa, versicolor, and virginica. The goal is to obtain a prototype for each class and to perform the work of the ant colony during learning by obtaining the value of s1 and s2 and then d1 and d2. Suppose that the ant colony produced the following prototypes as mentioned in the code here. For simplicity, this example assumes that all attributes have equal weight (i.e., $w=1$). However, in the full implementation of PROAnt, attribute weights are also automatically optimized as part of the learning process.

This procedure constitutes the defuzzification step, as it translates the fuzzy relationships (degrees of membership) into a crisp class label. This approach maintains interpretability while enabling high adaptability to uncertain or overlapping data regions.

To aid reproducibility and clarity, we included an illustrative Python code snippet using the Iris dataset as an example just for clear understanding.

• 1.

  Calculation of the indifference relation between the object $a$ and the prototype $b_i^h$: This step is performed using Eq. (9), which relies on the definition of the degree of membership given in Eq. (11). In the code, this logic is implemented in the functions def membership and def calculate_ip.

• 2.

  Evaluation of the membership degree: The membership degree of the object with respect to each prototype is calculated directly using Eq. (11). In the code, this is represented in the section labeled # --- Calculate I[p] ---.

• 3.

  Object assignment to the most suitable class: Finally, the object is assigned to the most appropriate class using Eq. (12), based on the highest membership value. In the code, this corresponds to the section labeled # --- Final Prediction ---.

The results of the previously mentioned code which is generating the sample of prototype for each class related to dataset (iris).

Description of the algorithm:

The main algorithm: The primary function provided initializes the ant colony parameters. The function then reads the data from the file and randomizes it. The algorithm then performs a 10-fold cross-validation process to train and test the model. The high-level algorithmic description.

This algorithm begins by instantiating two ‘individual’ objects: $populationTestingData$ and $populationTrainingData$. These objects represent the algorithm’s initial state and are constructed with initial threshold values ( $Thresholds$) and actual discrete events (‘TestRealDE’ and ‘TrainRealDE’). The fitness of these initial populations on both the testing and training data is then printed on the console for reference.

Subsequently, the algorithm initializes L and H, which act as lower and upper bounds. The dimensions are determined by the number of classes and attributes and a predefined constant D, representing the number of parameters.

The algorithm then enters a nested loop to populate the L and H arrays based on the initial threshold values. This is crucial as these arrays define the boundaries that the algorithm will operate to optimize the parameters. Specifically, the algorithm ensures that the lower bounds (L) are not less than zero and that the upper bounds (H) are not less than the respective lower bounds.

This algorithm can be seen as implementing an optimization problem to find the optimal set of parameters that yield the best fitness score on a given data set under the constraints defined by the boundaries L and H.

Following the initialization of the boundaries, a $initialThresholds$5D array is created. This array represents the starting point for the parameter optimization process.

The function $optimizeParameters$ performs the core optimization process, which inputs the $initialThresholds$, $TestRealDE$, and the L and H arrays. This function is assumed to implement a specific optimization routine, presumably the ACO algorithm, to obtain the optimal parameters stored in $bestParams$.

Finally, the algorithm prints these optimal parameters, calculates their fitness using the function $evaluateFitness$, and prints the resultant $bestFitness$. The $bestFitness$ value is then returned, marking the completion of the algorithm. This value $bestFitness$ is a performance indicator of the optimized parameters compared to the $TestRealDE$ data.

Now, let us analyze the code further:

The $optimizeParameters$ function seems to be the main optimization loop. It initializes the pheromone matrix, defines variables to store the best parameters and fitness, and then proceeds with iterations.

The function $initializePheromones$ initializes the pheromone matrix with a constant value of 1.0 for all elements. This seems acceptable as an initial starting point.

The function $generateRandomParams$ generates random parameters based on the pheromone matrix. Calculate the total pheromone for a specific position and use the roulette wheel selection method to select a random offset based on the proportions of the pheromone. However, it should be noted that the random selection process might not yield optimal results. Consider exploring other selection strategies, such as rank-based or tournament selection, to enhance the exploration and exploitation of the search space.

The function $evaluateFitness$ evaluates the fitness of a set of parameters using the PROAnt class. Since the details of the PROAnt class are not provided, I cannot comment on its correctness. Ensure that the fitness evaluation accurately reflects your target objective or optimization criteria.

The function $depositPheromones$ updates the pheromone matrix based on the parameters and fitness of an ant. Increases pheromone levels for each element of the matrix. However, the method used to calculate the pheromone increment ( $calculatePheromoneIncrement$) references $bestFitnessSoFar$, which is not updated within this function. Consider passing $bestFitnessSoFar$ as a parameter to the $depositPheromones$ function or making it a class-level variable if it needs to be shared between multiple functions.

The function $evaporatePheromones$ reduces the levels of pheromones in the matrix by applying a base evaporation rate. The evaporation rate of 0.9 seems reasonable, but you can experiment with different values to find the best balance between exploration and exploitation.

The function $calculateTotalPheromone$ calculates the total value of pheromones for a given position in the pheromone matrix. Sums up all the pheromone values for the specified position. This function appears to be correctly implemented.

The printParameters function outputs the parameters stored in the $params$ matrix. It prints the class, prototype, attribute, and corresponding values. This function can help to debug and verify the accuracy of the optimization process. However, further analysis and testing are necessary to assess its performance and determine if adjustments or improvements are required.

Here is a high-level representation of the optimization approach.

This algorithm runs an optimization loop for a predefined number of iterations $NU{M}_{I}TERATIONS$. Each iteration generates a set of parameters for each ant, and the fitness of these parameters is evaluated. The pheromone trail is updated based on these parameters and their corresponding fitness scores. If the fitness of a particular set of parameters exceeds the current best fitness, the best parameters are updated. Once all ants have moved and the pheromones have been deposited, the pheromone trail evaporates slightly to prevent stagnation and ensure exploration of the search space. After completing all iterations, the algorithm returns the set of parameters with the highest observed fitness.

In this function, a five-dimensional array of pheromones is initialized to have the dimensions specified by $numOfClasses$, $numOfPrototypes$, $numOfAttributes$, and D. Then, every element of this array is initialized to 1.0. The array is then returned as the result of the function.

This function generates 5D params with random values for each entry. These random values are generated in the range ‘[L[cl][k][l], H[cl][k][l]]’ for each $cl$, $k$, $l$ combination. The array ‘params’ is then returned by the function.

This algorithm updates the pheromone matrix according to the fitness of the current solution. If the fitness of the solution is better than the best, it updates the entire pheromone matrix; otherwise, it only updates the part corresponding to the current solution. In your original code, $bestFitnessSoFar$ is assumed to be a global variable, so it should be initialized outside of this function in your main program.

This algorithm iterates the entire pheromone matrix and applies an evaporation effect to every level. The result is modeled by multiplying by factor (1– $baseEvaporationRate$) and (1– $decayRate$), thus reducing the level of pheromones with each pass.

Dataset description

The dataset in discussion comprises 100,000 data entries from diabetes patients, covering medical and demographic information. Each sample is labeled to indicate the absence (0) or the presence (1) of diabetes. This dataset was recently made available on Kaggle’s public dataset repository in conjunction with a ML competition held in June 2023. Data were collected as described in Mustafa (2022). This data has potential for healthcare professionals, providing information on patients at increased risk of diabetes and helping to create individualized treatment strategies. The dataset spans nine columns: four have integer attributes, three are of a decision type, and the remaining two, including the class label, are string attributes. A detailed statistical overview of this dataset can be found in Table 3.

Exploratory data visualization

Exploratory data visualization (EDA) creates a visualization of the insights of the data set and helps the reader to understand the data by summarizing a large amount of data in a single figure. This is essential when exploring and trying to become familiar with our dataset. The Pairplot is an integral part of EDA that allows us to plot pairwise relationships between variables within a dataset. Figure 2 illustrates the pair plot of the subject target. This visualization (see 2) shows the pairwise relationships between the four main numerical variables in the diabetes dataset:

A heat map is a two-dimensional graphical representation of data in which the individual values in a matrix are represented as colours. A heat map is a matrix representation of the variables that are coloured on the basis of the intensity of the value. Hence, it provides an excellent visual tool for comparing various entities (Pham, Nguyen & Dang, 2021). Figure 3 visualizes the correlation between the attributes of the target dataset. This heatmap (see 3) shows the correlation coefficients between all features in the dataset. The correlation values range from −1 (perfect negative correlation) to +1 (perfect positive correlation).

• The gender attribute can play a role in the risk of diabetes. However, the effect may vary because women with a history of gestational diabetes (diabetes during pregnancy) are at increased risk of developing type 2 diabetes later in life.

• The age attribute is an important factor in predicting the risk of diabetes. As individuals get older, their risk of developing diabetes increases.

• Hypertension, or high blood pressure, is a condition that often coexists with diabetes. The two conditions share common risk factors and can contribute to each other’s development.

• Heart disease, including coronary artery disease and heart failure, is associated with an increased risk of diabetes.

• Smoking is a modifiable risk factor for diabetes. Cigarette smoking has been found to increase the risk of developing type 2 diabetes.

• Body mass index (BMI) measures body fat according to height and weight. It is commonly used to indicate general weight status and can help predict the risk of diabetes.

• HbA1c (glycated hemoglobin) measures the mean blood glucose level in the last 2–3 months.

• The blood glucose level refers to the amount of glucose (sugar) in the blood at a given time.

• Diabetes is the predicted target variable, with 1 indicating the presence of diabetes and 0 indicating the absence of diabetes.

Data preprocessing

Data preprocessing is a crucial phase in the development of machine learning models, particularly when handling large and heterogeneous datasets. In this study, the original dataset consisted of 100,000 medical records. Upon examination, 3,854 duplicated samples were identified and removed, resulting in 96,128 unique entries used for model building. Additionally, instances containing the value "other" in the "gender" attribute—representing only 0.00195% of the population—were excluded due to their negligible and ambiguous contribution to the classification task.

The dataset also contained missing values across several attributes. For numerical variables, missing entries were imputed using mean substitution, while for categorical variables, the mode was used. All categorical variables were then transformed into numerical form using label encoding. For example, the gender attribute was encoded as one for male and two for female. Similarly, the smoking history attribute was encoded as shown in Table 4.

To ensure feature scale consistency, especially for algorithms sensitive to magnitude differences, all numerical attributes were normalized using Min-Max scaling. Furthermore, class distribution was analyzed for imbalance. While minor skewness was detected, the distribution remained statistically manageable, and no over- or under-sampling techniques were applied. Finally, to validate the model performance reliably, stratified 10-fold cross-validation was used, preserving the class proportions across training and testing subsets. This preprocessing pipeline ensured that the dataset was clean, well-structured, and suitable for robust classification analysis.

Baseline classifier configuration

To ensure a fair and reproducible comparison, all baseline classifiers were configured using standard and empirically validated parameter settings. For the k-NN model, we used $k=5$ with the Euclidean distance metric. The Decision Tree classifier (C4.5) was implemented with a confidence factor of 0.25 and a minimum of two instances per leaf. The logistic regression model employed L2 regularization with a regularization strength $C=1.0$, using the liblinear solver. The Naive Bayes classifier was used in its standard Gaussian form, without the need for hyperparameter tuning. For the neural network (multilayer perceptron), we used one hidden layer containing 100 neurons with ReLU activation, trained using the Adam optimizer and a learning rate of 0.001. On the other hand, the DL model comprised a feedforward neural network [x] with three hidden layers (128, 64, and 32 neurons, respectively), ReLU activation functions, a dropout rate of 0.5 to prevent overfitting, a batch size of 64, and a training duration of 50 epochs. These configurations were selected based on initial experimentation and established practices in the literature to ensure optimal performance and consistency across all comparative models.

These parameter values were selected based on preliminary tuning experiments and best practices reported in the literature to ensure optimal performance and consistency across models.

Based on what has been discussed above, PROAFTN and DT share a fundamental property: they use the white-box model. Table 5 presents a performance-based comparison across seven classifiers, including Decision Tree (C4.5), Naive Bayes, DL, k-NN, NNs, logistic regression, and the proposed PROAnt. This table reports metrics such as precision, weighted recall, weighted kappa, overall accuracy, and standard deviation. As shown, PROAnt achieves the highest precision (98.42%) and weighted accuracy (97.28%), and matches the top-performing models in kappa score, indicating both robustness and reliability. Recent studies have explored hybrid deep learning approaches for diabetes prediction. Abgeena & Garg (2023) proposed an S-LSTM-ATT model combining long short-term memory (LSTM) networks with firefly optimization. While these methods yield competitive accuracy, they often lack interpretability and transparency, which are critical in medical decision-making. In contrast, PROAnt achieves comparable accuracy (e.g., 98.42% weighted precision) while maintaining interpretability through fuzzy rule-based modeling. This balance of performance and explainability substantiates PROAnt as a state-of-the-art alternative, especially in domains where transparent decision rationale is essential.

DT and PROAFTN can generate classification models which can be easily explained and interpreted. However, classification accuracy is another essential factor when evaluating any classification method. Based on the experimental study presented in ‘PROAFTN Method’, the PROAFTN method has been shown to generate a higher classification accuracy than decision trees such as C4.5 (Quinlan, 1996) and other well-known classifier learning algorithms, including Naive Bayes, DL, NN, k-NN and logistic regression. That can be explained by the fact that PROAFTN uses fuzzy intervals.

Table 6 presents the comparative results of PROAnt against baseline models, demonstrating the superior accuracy and balanced trade-off achieved by the proposed framework, where accuracy reflects the overall proportion of correctly classified cases, while precision emphasizes the reliability of positive diabetes predictions. Recall highlights the model’s ability to detect diabetic cases, and Cohen’s kappa accounts for agreement beyond chance. Together, these measures provide a comprehensive assessment of model robustness in medical diagnosis. The observations in this table are based on the results obtained using the learning methodology developed for this research study.

In this work, the use of machine learning and metaheuristic algorithms to obtain PROAFTN parameters proved to be a successful approach to optimize PROAFTN’s training and thus significantly improve its performance.

As has been demonstrated, every classification algorithm has its strengths and limitations. More particularly, the characteristics of the method and whether it is strong or weak depending on the situation or the problem. For example, assume that the issue at hand is a medical dataset and that the interest is to look for a classification method for medical diagnostics. Suppose that executives and experts are looking for a high level of classification accuracy. At the same time, they are very interested in more details about the classification process (e.g., why the patient is classified into this disease category). In such circumstances, classifiers such as neural networks, $k$-NN, or deep learning may not be an appropriate choice due to the limited interpretability of their classification models. Thus, it is necessary to look for other classifiers that reason about their output and can generate good classification accuracies, such as DT (C4.5, ID3), NB or PROAFTN.

Based on the summary provided, PROAnt demonstrates superior performance across a range of important classifier properties compared to well-known classifiers such as Decision Trees (DT C4.5), Naive Bayes (NB), DL, NN, k-NN and logistic regression.

Here is a detailed comparison: The PROAnt model exhibits exceptional performance across a comprehensive range of evaluation criteria, positioning it as a highly competitive and reliable classifier. In terms of general classification accuracy, PROAnt matches the highest ratings achieved by established models such as Decision Tree C4.5, DL and NN, while outperforming Naive Bayes (NB), k-NN and logistic regression.

Regarding the ability to handle diverse data types, PROAnt shares the top rating with DT C4.5, demonstrating superior adaptability over NB, DL, NN, k-NN, and logistic regression. When evaluated for precision under noisy data conditions, PROAnt again reaches the top tier alongside DT C4.5 and NN, showing better resilience than NB, DL, k-NN, and logistic regression.

In terms of training time, PROAnt demonstrates efficiency comparable to DT C4.5 and logistic regression. It is significantly faster than DL, NN, and k-NN, though it is slightly slower than NB. For testing time (classification phase), PROAnt achieves the highest rating, matching DT C4.5, NB, and logistic regression, and surpassing DL, NN, and k-NN in computational efficiency.

A particularly notable strength of PROAnt is its superior capability in handling overfitting, where it stands alone at the top rating. It clearly outperforms DT C4.5, DL, NN, k-NN, NB, and logistic regression in this aspect. The model also scores highest in terms of parameter efficiency, reflecting its design simplicity and optimization—outperforming NB, k-NN, and logistic regression, and equaling DL and NN in this regard.

On the metric of interpretability, PROAnt shares the top rating with DT C4.5 and NB, offering greater transparency than more complex models like DL, NN, and k-NN. Similarly, in terms of transparency, PROAnt performs comparably to k-NN, DT C4.5, NB, and logistic regression, and more transparently than DL and NN.

The only area where PROAnt shows a marginal shortfall is in data requirements. It receives a slightly lower rating than DT C4.5, NN, and k-NN but is on par with DL and logistic regression, and requires more data than NB.

Overall, PROAnt demonstrates strong and consistent performance across the majority of key evaluation dimensions, including classification accuracy, adaptability to data types, robustness to noise, fast classification time, overfitting control, and model interpretability. Its simplicity in terms of the number of required parameters and its transparency further contribute to its robustness. These qualities make PROAnt a versatile and competitive classifier, well-suited for a wide range of machine learning tasks and real-world applications, especially in domains demanding both high accuracy and model interpretability.