Paper deep dive
GERIS: A Game-Theoretic Framework for Filtering Instance-Dependent Label Noise in License Plate Data Augmentation
Seyedeh Sara Jalili Shani, Rouhollah Ahmadian, Amin Rahmani, Mahdi Bideh, Mehdi Ghatee
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 89%
Last extracted: 9/29/2026, 11:30:26 AM
Summary
The paper introduces GERIS, a game-theoretic framework designed to filter instance-dependent label noise during the data augmentation phase of license plate recognition systems. GERIS treats noise vectors as players in a non-cooperative game, selecting high-quality instances based on similarity to labeled data and contribution to model reliability, thereby improving classification accuracy and robustness compared to traditional black-box methods.
Entities (13)
Relation Signals (9)
Seyedeh Sara Jalili Shani → affiliatedwith → University of Alberta
confidence 95% · Seyedeh Sara Jalili Shani Affiliation: Department of Computer Science, University of Alberta
Rouhollah Ahmadian → affiliatedwith → Amirkabir University of Technology
confidence 95% · Rouhollah Ahmadian Affiliation: Department of Mathematics & Computer Science, Amirkabir University of Technology
GERIS → uses → Game Theory
confidence 95% · GERIS, a game-theoretic framework for instance selection
GERIS → solves → Instance-Dependent Label Noise
confidence 92% · Filtering Instance-Dependent Label Noise in License Plate Data Augmentation
GERIS → appliesto → License Plate Recognition
confidence 90% · data augmentation phase of license plate recognition systems
GERIS → modelsas → Non-cooperative Game
confidence 90% · GERIS formulates a non-cooperative game in which each noise vector competes
GERIS → usesmetric → Mahalanobis distance
confidence 88% · payoff for each player is calculated based on its Mahalanobis distance
GERIS → outperforms → AutoAugment
confidence 85% · GERIS outperforms existing instance selection methods in terms of classification accuracy and robustness
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:In this paper, we propose GERIS, a game-theoretic framework for instance selection in the data augmentation phase of license plate recognition systems. During augmentation, synthetic license plate images are generated and transformed using stochastic noise to simulate real-world conditions. However, certain noise configurations lead to highly distorted, unreadable images that degrade model performance by introducing instance-dependent label noise. GERIS formulates a non-cooperative game in which each noise vector competes for inclusion in the training set based on its similarity to labeled data and its contribution to model reliability. By identifying and pruning low-quality instances, GERIS improves the overall quality of the augmented dataset. Unlike traditional black-box learning methods, GERIS offers a transparent, theoretically grounded mechanism for data filtering. Experimental results demonstrate that GERIS outperforms existing instance selection methods in terms of classification accuracy and robustness.
Tags
Links
- Source: https://arxiv.org/abs/2609.31731v1
- Canonical: https://arxiv.org/abs/2609.31731v1
Trouble viewing inline? Open PDF directly →
Full Text
72,288 characters extracted from source content.
Expand or collapse full text
GERIS: A Game-Theoretic Framework for Filtering Instance-Dependent Label Noise in License Plate Data Augmentation Seyedeh Sara Jalili Shani Affiliation: Department of Computer Science, University of Alberta Edmonton, Alberta, Canada sjalilis@ualberta.ca Rouhollah Ahmadian Affiliation: Department of Mathematics & Computer Science, Amirkabir University of Technology Tehran, Iran rahmadian, amin.rahmani, mahdi.bideh, ghatee@aut.ac.ir Amin Rahmani Affiliation: Department of Mathematics & Computer Science, Amirkabir University of Technology Tehran, Iran rahmadian, amin.rahmani, mahdi.bideh, ghatee@aut.ac.ir Mahdi Bideh Affiliation: Department of Mathematics & Computer Science, Amirkabir University of Technology Tehran, Iran rahmadian, amin.rahmani, mahdi.bideh, ghatee@aut.ac.ir Mehdi Ghatee Affiliation: Department of Mathematics & Computer Science, Amirkabir University of Technology Tehran, Iran rahmadian, amin.rahmani, mahdi.bideh, ghatee@aut.ac.ir Abstract In this paper, we propose GERIS, a game-theoretic framework for instance selection in the data augmentation phase of license plate recognition systems. During augmentation, synthetic license plate images are generated and transformed using stochastic noise to simulate real-world conditions. However, certain noise configurations lead to highly distorted, unreadable images that degrade model performance by introducing instance-dependent label noise. GERIS formulates a non-cooperative game in which each noise vector competes for inclusion in the training set based on its similarity to labeled data and its contribution to model reliability. By identifying and pruning low-quality instances, GERIS improves the overall quality of the augmented dataset. Unlike traditional black-box learning methods, GERIS offers a transparent, theoretically grounded mechanism for data filtering. Experimental results demonstrate that GERIS outperforms existing instance selection methods in terms of classification accuracy and robustness. **footnotetext: Corresponding author: ghatee@aut.ac.ir Keywords: License Plate Recognition; Data Augmentation; Instance-dependent Noisy Label; Non-cooperative Game; Instance Selection 1 Introduction Instance selection is a vital step in data pre-processing for machine learning problems. As datasets become big, the effect of noisy data increases on the training process [1]. Instance selection algorithms aim to mitigate these issues by identifying and removing noisy data from a dataset, resulting in a smaller, more focused training set. Precisely, given a dataset D composed of a training set T and a testing set U, let S⊂TS⊂ T be the subset of selected instances resulting from the execution of an instance selection algorithm. Then, the model is trained by S, the reduced dataset. Training models on these reduced datasets can be beneficial in several ways. According to the research results of [2], the potential benefits of data set filtering and learning include improving the quality of a model, reducing the number of input variables when developing a predictive model, and minimizing empirical error. Identifying detrimental instances and searching for an optimal subset of the training data that minimizes empirical error can also improve the quality of a model. Additionally, data filtering can increase the quality of species records and reduce sample size [3]. Therefore, dataset filtering can improve model quality by training the model on a reliable dataset. A license plate recognition (LPR) system is a technology that uses optical character recognition (OCR) to read and recognize license plate numbers from still images or video footage [4]. The first step in a license plate recognition system is detecting and localizing vehicles in an image or a video. There are various techniques to this end. For example, several papers localize vehicle and license plates by object detection models based on CNNs like YOLO [5]. The next step is to locate the license plate region in the pre-processed image. This step can be done using edge detection, morphological operations, and color segmentation techniques [6]. Once the license plate region is located, individual characters must be segmented from the plate. The valuable methods in this step include connected component analysis and contour analysis to extract the characters [7, 8]. The final step is to recognize the characters on the license plate using OCR algorithms that match the segmented characters against a database of known characters. The recognition accuracy can be improved using machine learning techniques such as neural networks and deep learning to train the system on a large dataset of license plate images [9, 10]. This paper concentrates only on the fourth step to evaluate the proposed model. Our problem is confined to a specific dataset used for license plate recognition. Since accessing real data from traffic cameras is challenging due to legal barriers, it is reasonable to develop an augmentation framework before model training. Typically, augmentation frameworks introduce various types of noise to the images. However, the synthetic data generated is often unsuitable for training the model directly, as it lacks the realistic variations typically seen in real-world data, such as lighting changes, rotation, shadows, and other environmental factors. Without these features, the generated images contain corrupt examples that resemble instance-dependent noisy labels (IDN) [11]. In this context, instance-dependent noisy labels refer to situations where the noise or distortion introduced during augmentation makes the data instance less reliable for model training, similar to how noisy labels can mislead a model [2]. Training the model on such noisy instances can lead to inaccurate recognition models [12]. Thus, it is crucial to generate noisy instances that are more realistic, reflecting the true variability encountered in real-world scenarios, while minimizing the introduction of instance-dependent noise that could impair model performance. The main challenge surrounding data augmentation is ensuring that the augmented data is representative of the real-world data with which the model will encounter during deployment. Suppose the augmented data is distinct from the real-world data. In that case, since the model lacks generalization, it will perform poorly when facing new and unseen data. Two common methods are followed to address the above challenge. One approach involves applying filtering algorithms to prune synthetic data. The second approach includes methods that are based on gradient policy. 2 Literature Review To provide an overview of the research conducted in the field of data augmentation, this section focuses on two distinct lines of work. The first line of research addresses the challenge of augmenting data through the application of filtering algorithms. Various filtering techniques have been explored in different domains. Thus, to maintain relevance to the research objective, this review highlights key algorithms categorized into two main classes: filtering-based instance selection techniques and learning models. While this categorization may become nuanced in some cases, its sole purpose is to provide an overview of counterpart algorithms relevant to our proposed approach. Table 1 presents a high-level comparison of representative algorithms from each category, offering a concise summary of their characteristics and usage. In the subsequent subsections, we provide a more detailed discussion of these techniques, elaborating on the rationale behind each method, its applicability to noise filtering or instance selection, and its connection to the problem addressed in this work. 2.1 Filtering-based Instance Selection Filtering-based instance selection algorithms aim to enhance model performance by selecting a subset of instances that are most informative and representative of the underlying data distribution. These methods can be categorized into three main types, each with implications for handling noisy labels, especially those that are instance-dependent. 2.1.1 Distance-based Filtering Methods Distance-based filtering methods select instances based on their proximity to other instances in the feature space. These methods are effective in identifying and removing redundant or outlier instances, which can help mitigate the impact of noisy labels. Notable algorithms in this category include DBSCAN [2], K-nearest Neighbors (KNN) [13], Isolation Forest [14], K-means [15], and Condensed Nearest Neighbor (CNN) [16]. By focusing on the spatial relationships between instances, these methods can indirectly address instance-dependent noise by removing instances that are distant from dense regions of the data, which are more likely to be mislabeled. 2.1.2 Class Distribution Filtering Methods Class distribution filtering methods aim to ensure that the selected instances are representative of the underlying class distribution in the dataset. These methods help preserve the diversity of the dataset and can be particularly useful in identifying and removing instances with noisy labels. Key algorithms in this category include Edited Nearest Neighbor (ENN) [17], Neighborhood Cleaning Rule (NCR) [18], and Naive Bayes [19]. 2.1.3 Consistency-based Filtering Methods The third category comprises Consistency-based Filtering methods. These approaches assess the consistency or stability of instances concerning the training data or a learning model. Instances that are more consistent or less susceptible to noise or model variations are considered important and retained, while instances that introduce instability or are less reliable are filtered out. Key algorithms in this class include Cross-Validation [20] and One-Class Support Vector Machine [21]. 2.1.4 Noisy Label Detection Methods Label noise falls into two categories: instance-independent noise (IIN) (e.g., symmetric/asymmetric noise) and instance-dependent noise (IDN), where errors correlate with features, posing unique generalization challenges [2, 22]. Sample selection methods exploit the memorization effect, filtering unreliable data using distance-based criteria (e.g., MentorNet [23]) or neighborhood consistency checks (e.g., ConFrag [24]). Label correction techniques instead modify annotations via prediction confidence [25] or clean subset agreement [26], while hybrid methods combine both approaches [27]. Alternative solutions include robust loss functions [28], regularization (e.g., adaptive checkpointing [12]), meta-learning for sample reweighting [29], and contrastive learning [30], though the latter may conflate semantic similarity with noise. 2.2 Learning Models Learning models are typically employed to perform classifications and predict patterns, which, in our context, can assist in classifying redundant transformation functions and removing them from our instances. Some applicable learning models in our setting are Multilayer Perceptron (MLP) and Support Vector Machines (SVM). 2.3 Policy-gradient Methods The second line of research falls under policy-gradient methods which focus on determining the optimal combination and parameters for data augmentation transformations. These studies aim to identify the most effective and efficient ways to transform the existing data, enhancing its diversity and generalization capabilities. Regarding this line of work, the principal augmentation method to discuss is AutoAugment. In contrast to traditional manual data augmentation methods, AutoAugment is an automated procedure that searches for improved data augmentation policies. One limitation of AutoAugment is that it requires powerful computational resources [31]. Several versions of AutoAugment have been proposed as an enhancement of this data augmentation method such as RandAugment, AugMix, TrivialAugment, and DeepAugment [32]. The remainder of this paper is structured as follows: Initially, we will give a brief description of the data generating framework. Then the underlying concepts of game theory will be introduced. Next, we will give an overall explanation of the applied game to further elaborate on how we derive an ideal instance of data with it. Finally, we will test the algorithm via two evaluation methods and compare our method with its counterparts. To clearly differentiate our work from existing techniques, we have conducted an extensive performance comparison, as outlined in Section 4. However, through a comprehensive analysis, our work stands out from its counterparts in several key aspects, which are highlighted below: • Novel Methodology: We are the first to apply a game theory approach to dataset pruning, which sets our work apart from other filtering techniques. By leveraging game theory principles, we introduce a novel methodology that optimizes the dataset pruning process, resulting in superior accuracy compared to alternative approaches. • Computational Efficiency: Our approach exhibits lower computational cost compared to gradient policy-based methods. Unlike those methods that require training a given model in each iteration, our approach streamlines the computational requirements, enabling faster and more efficient dataset pruning without sacrificing accuracy. • Dimensionality Reduction: We have significantly reduced the dimensionality of the problem by leveraging noise vectors as the primary input and eliminating the reliance on complete images. This strategic decision was made to mitigate the challenges associated with the curse of dimensionality. By reducing the dimensionality, our approach achieves improved efficiency and scalability while maintaining the effectiveness of dataset pruning. Table 1: A review of algorithms used for instance selection. Instance Selection Methods Description Ref. Filtering-based Instance Selection Distance-based filtering selects instances by their proximity to others. DBSCAN A density-based clustering algorithm groups data points without requiring a preset cluster count, selecting representatives from dense regions. [2] K-nearest Neighbors (KNN) KNN classifies data points by their nearest neighbors’ majority class. K-means clusters data by similarity, selecting centroids as representatives. [13] Isolation Forest An isolation forest detects anomalies by isolating rare, distinct instances using random forests. [14] K-means K-means clusters data into k groups by minimizing squared distances to centroids, using them as representatives. [15] Condensed Nearest Neighbor A method that iteratively selects only correctly classified, essential instances for an accurate reduced dataset. [16] Class distribution filtering selects instances to represent the dataset’s class diversity. Edited Nearest Neighbor (ENN) A method that removes misclassified or redundant instances by comparing them to their nearest neighbors, boosting model performance. [17] Neighborhood Cleaning Rule (NCR) An ENN extension that removes Tomek links—mutual nearest neighbors of different classes—to enhance class separability. [18] Naive Bayes A probabilistic classifier that estimates the probability of an instance belonging to each class based on the class distribution in the training data. [19] Uncertainty Quantification Measures labeling uncertainty by modeling noisy vs. true label distributions, improving noise robustness across domains and models. [33, 34] Consistency-based filtering keeps instances that are stable and reliable, removing noisy or inconsistent ones. Cross-Validation (CV) Evaluate the stability or consistency of instances by performing repeated cross-validation and removing instances that show high variance in their performance across different folds. [20] One-Class Support Vector Machine A machine learning algorithm that learns a decision boundary around a set of instances, identifying regions where most instances belong, and enabling the detection of outliers or instances that deviate from the majority. [21] Learning Models They classify and predict patterns, helping identify and remove redundant transformation functions. Multilayer Perceptron (MLP) A feedforward artificial neural network model consisting of multiple layers of interconnected nodes (neurons) that learn to classify or predict patterns by adjusting the weights associated with each connection. [35] Support Vector Machines (SVM) Supervised machine learning algorithm that finds an optimal hyperplane to separate data points of different classes by maximizing the margin between them, achieving high classification accuracy. [36] Fusion Function This approach focuses on noise filtering using fusion functions, such as majority voting and averaging filters. It requires that a label is agreed upon by the majority of classifiers. Experiments conducted on noisy datasets have shown that majority vote filters are more effective in detecting incorrectly labeled instances compared to consensus filters or individual classifiers. This method significantly enhances learning performance. [37, 38, 39] 3 Proposed methodology This section consists of two parts. Firstly, the framework for generating artificial license plates is described. To this end, the various noises applied to the simple plates are listed. Then, the game of pruning corrupt generated instances is informed. This part explains the underlined theory and the method which with the proposed game is evaluated. 3.1 Data generator framework Generating license plates needs a straightforward framework. Thus, we propose a data generation framework with different steps that help us produce an authentic replica of an actual license plate image. We entitled our framework as ”Synthetic license plate data generator via a non-cooperative game” or shortly GERIS. Figure 1: The architecture of generating license plate. Table 2: Transformation Functions Transformation Description Salt and Pepper The Salt and Pepper noise is a simple noise that simulates dead pixels in a camera and digital noise. This noise uses two values corresponding to salt and pepper, respectively, vsv_s and vpv_p. Blur The Blur noise uses Gaussian and median filters to add a blur effect to the images. This noise uses two parameters, filter size, and variance. An increase in filter size or variance will increase the blur. Circular Light The circular light noise is the simulation of the reflection of light in some images in the form of fuzzy circles. To obtain such noise, first, we apply a median filter to smooth it out and prevent unwanted circular lights. After that, we convert the image format from RGB to YUV and add noise to its Y channel. The noise is a Gaussian kernel amplified by a factor lpl_p. Light The light noise is the replica of high exposure in images that adds extra brightness to an image. This phenomenon makes text to be less readable. To construct such noise, we proceed as the Circular light noise and convert the image format to YUV after applying median smoothing. Following these steps, we add light noise as a constant to the Y channel of the image. Gradient Light The gradient light noise is another light noise that can produce noises similar to light beams. This noise occurs when a light source is in the environment and the camera’s lens is not clean. The initial steps for producing this noise are similar to other light noises. After obtaining YUV channels, we select a linear path and add a constant to the Y channel. In the last step, we convert the image to RGB channels and obtain a noisy image. Negative The negative noise works the opposite way of the light noises. This noise lowers the exposure and light in the image by deducting a constant from the Y channel of the YUV format of the image. YUV format of the image and reverse conversions are similar to light noises, and the only difference is the subtraction part. Mixture Since a license plate can have multiple corrupting noises simultaneously, these types of noisy plates must be included in the dataset. In order to generate such images, we apply some of our previously defined noises to an image and obtain a mixture of noises, as seen in Figure 1. However, these mixtures can cause a plate to become unreadable to both humans and machines. Thus, further procedures are required to avoid such data samples. Perspective The angle that a camera has toward a scene can cause perspective. Perspective makes objects in an image have different widths and heights from their actual dimensions. To mimic this phenomenon, we apply a perspective transformation to an image. Our transformation uses four control points. We also consider four directions in each control point and randomly select a direction for each of the points to obtain a transformation. First, we load some background images, called templates, that act as the plate, then we randomly generate characters of the license plate and place them on the loaded template. For further details, we add different non-perspective and perspective noises that help replicate a detected license plate in an actual image. Figure 1 illustrates the proposed framework steps. Each license plate consists of different layers. The first layer is the template layer that acts as the metal plate used in an actual license plate. To obtain realistic templates, we investigated all the different license plates installed on vehicles. Then we carefully designed each template using additional software and, as a result, produced 13 different templates equal to the number of all categories of license plates in Iran. We use two general categories of noises. The two categories are computed noises and overlay noises. The first category contains noises that can be computed using a formula in real-time, e.g., salt and pepper noise. In Table 2, we described the computed noises. In the noise vectors, illustrated in Fig 1.e, the 10th to 30th components are associated with the first category of noises. The noises in the second category are in the form of transparent images, e.g., scratch marks. In the noise vectors, illustrated in Fig 1.e, the 0th to 9th components are associated with the second category of noises. 3.2 Instance selection This section explains how game theory is applied for pruning the corrupt instances generated by the framework. The utilized game is a non-cooperative game in which the players, i.e. noise vectors, have to choose a strategy between correct or corrupt. The proposed labeling algorithm consists of a game played between an unlabeled data point and its neighbors. The payoff for each player is calculated based on its Mahalanobis distance from its neighboring vectors. In the remainder of this section, we will thoroughly explain how this technique enables labeling the whole dataset by manually labeling a small fraction. 3.2.1 Game theory In general, game theory is known to study the interaction of decision-makers in situations of conflict or cooperation. A game is a description of strategic interaction that includes at least two players, each of which poses a set of possible strategies. The strategies that the players end up picking will determine the outcome of the game. Each possible outcome obtained by playing a set of strategies establishes the payoffs for the players. These payoffs indicate the players’ gain of the reached outcome [40]. The game involves mutual influence among participants, as each participant’s decisions affect the choices of others. Its overall objective is for every participant to strategically balance their own interests while maximizing collective gains, assuming full rationality. Game theory allows us to model such phenomena in a game. It provides us with the analytical tools to find possible solutions for them. Thus, its use has become increasingly prevalent in solving problems in economics, biology, and politics. 3.2.2 Non-cooperative games The game we attempt to describe is based on the game proposed in [41], which is called NEATER, for balancing the dataset. However, by applying some changes in the original game, this study tends to prune the corrupt instances generated in the data augmentation process. The proposed game is classified as a non-cooperative game. We first introduce the notions of such games and then represent how we modeled our problem into one. The further brought terminology is highly similar to what is used in [42] and is close to the notions used in [41] to further facilitate the appliance of their method in our context. A normal form game consists of a set of players i∈Ni∈ N, in which the set N=1,2,⋯,nN=\1,2,·s,n\ is finite. Each player i chooses a strategy from the pure strategy space Si=1,2,⋯,kiS_i=1,2,·s,k_i, which is the set of pure strategies available to player i. Moreover, we have a collection of payoff functions uiu_i, each of which maps an n-tuple known as the pure strategy profile s=(s1,s2,⋯,sn)s=(s_1,s_2,·s,s_n), si∈Sis_i∈ S_i being the pure strategy for player i, into the player i’s utility. This means that a player’s payoff depends both on their and their opponent’s strategies. The opponents of player i are referred to as −i-i. In a normal-form game, players play only to maximize their utility based on a detailed description of the moves and information available to them. In a non-cooperative game, these self-interests pursuing individuals cannot cooperate or form coalitions. Another important class of strategies in a game is mixed strategies. A mixed strategy xix_i for any player i is a probability distribution over their pure strategies, i.e., SiS_i. This randomization process for each player takes place independently of others. A mixed strategy xix_i can be represented by a vector with its d-th component being the probability of assigning the pure strategy d∈Sid∈ S_i to player i. The dimension of this vector is the number of possible pure strategies that the player can choose. Note that all the probabilities are positive, and they sum to one: ∑j=1|Si|xij=1 _j=1 |S_i |x_ij=1 for all i∈Ni∈ N. Assuming the vector x=(x1,x2,⋯,xN)x=(x_1,x_2,·s,x_N) is the mixed strategy profile with each xix_i being the mixed strategy followed by the player i, the payoffs to a profile of mixed strategies are the expected values of the corresponding pure-strategy payoffs. Suppose S is the pure strategy space for each pure strategy profile s and s∈Ss∈ S. The expected value of the payoff to player i with the mixed strategy xix_i is given by: ui(x)=∑s∈Sx(s)ui(s)u_i(x)= _s∈ Sx(s)u_i(s). Remember that ui(s)u_i(s) is the payoff player i obtains if all the agents follow the pure strategy profile s. Furthermore, x(s)x(s) is the probability of choosing pure strategy profile s, i.e. the product of probabilities or ∏i=1Nxj(sj) _i=1^Nx_j(s_j). A pure strategy sis_i for the i-th player can also be represented as a mixed strategy vector. If si=ds_i=d and assuming that d∈Sid∈ S_i, then we can show sis_i by assigning 1 to xix_i’s d-the component and zero to the rest of the components. From now on, we will denote this representation by eide_i^d. Another important notion to introduce is (xi,x−i)(x_i,x_-i). The term x−ix_-i is the mixed strategy profile x without its i-th component. Thus, the tuple (xi,x−i)(x_i,x_-i) indicates adding xix_i back to x−ix_-i. This notion is used while defining Nash equilibrium as we want to compare the utility of player i with different sets of mixed strategy vectors. According to [42], a mixed strategy profile x∗x^* is a Nash equilibrium, if for all players i, ui(xi∗,x−i∗)≥ui(xi′,x−i∗)u_i(x_i^*,x_-i^*)≥ u_i(x _i,x_-i^*) for all possible xi′x _i in the mixed strategy space. The same definition holds for pure strategies. Nash equilibrium conveys that a game reaches equilibrium if all the players act by a strategy profile in which each player’s strategy is an optimal response to the other players’ strategies. A game might have a more complex strategy profile that results in a Nash equilibrium. However, in a normal-form game with finite players and a finite set of actions or strategies, we will at least have a Nash equilibrium of mixed strategies. Figure 2: Four samples of correct and corrupt noise vectors. (a) refers to the correct samples, and (b) refers to the corrupt samples. 3.2.3 Modeling the problem into a normal form game Consider having a dataset consisting of noise vectors. This dataset is formed of two classes of noise vectors dubbed correct and corrupt. The correct noise vectors, as shown in Figure 2.a, when added to the image of a license plate, will result in a recognizable yet more natural image. On the other hand, the corrupt noise vectors, as shown in Figure 2.b, will ruin the image and make it unrecognizable for the model. Thus, having a dataset of noise vectors D, we have a set of correct vectors DcD_c and a set of corrupt vectors DpD_p. The corrupt noise vectors must be removed from the dataset since their inclusion leads to training an inaccurate model. However, labeling these noise vectors is quite challenging when we have an extremely large dataset. To tackle this problem, we suggest manually labeling a random minor subset of the dataset, with the help of which we can classify the rest of the dataset as correct or corrupt using the proposed game. This way, we can label the whole dataset by only labeling a tiny fraction of it. The labeling algorithm is formulated as a non-cooperative normal-form game. The game is symmetric with two players, and given that its purpose is establishing the label of a noise vector, it is played among an unlabeled vector and a group of its neighbors with size h. To determine the neighborhood set we use a k-nearest neighbors approach based on Mahalanobis distance. For each unlabeled noise vector, the h closest vectors in the labeled and unlabeled sets are selected. Suppose that the set of all neighboring vectors of an unlabeled data point is shown by the set R. This set can comprise both labeled vectors, denoted by the RlR_l, and unlabeled ones, denoted by RuR_u. Note that Rl∪Ru=R_l∪ R_u=R. The game occurs between the unlabeled data and one neighbor at a time. The strategy space for each player i is to be either labeled as corrupt or correct or in other words, Si=p,cS_i=\p,c\ (p stands for corruPt and c for correCt). The payoff for each player is the sum of the payoffs they receive by playing each of the two-player games with their neighbors. Considering that a matrix can represent the payoff function of a game and there are two actions available for each player, each game played between players i and j will have a two-by-two matrix AijA_ij as its payoff function. The matrix AijA_ij is formulated as Aij=mij×I2A_ij=m_ij I_2, where mijm_ij is the inverse of the Mahalanobis distance between the noise vectors i and j. Hence, for a mixed strategy profile x=(x1,x2,⋯,xh)x=(x_1,x_2,·s,x_h) the utility of player i can be derived from: ui(x)=∑j=1hxiTAijxju_i(x)= _j=1^hx_i^TA_ijx_j. As mentioned before, the neighboring vectors of unlabeled noise vectors can either belong to RlR_l or RuR_u. Since the vectors in RlR_l are already labeled, they can only play the pure strategies p or c. These pure strategies are shown by eic=ei1=(1,0)e_i^c=e_i^1=(1,0) and eip=ei2=(0,1)e_i^p=e_i^2=(0,1). With R being the opponents of player i in the game, the above summation can be written as: ui(x)=∑j∈RuxiTAijxj+∑d=12∑j∈RlxiTAijejd u_i(x)= _j∈ R_ux_i^TA_ijx_j+ _d=1^2 _j∈ R_lx_i^TA_ije_j^d (1) Having formulated the problem set as a game, all that is left to do is compute the outcome of the game that results in classifying all the unlabeled noise vectors. 3.2.4 Replicator dynamics Replicator dynamics is an evolutionary selection model used in game theory to study how the frequency of different strategies in a population changes over time, and can help to calculate the Nash equilibrium of a symmetric game [43]. In replicator dynamics, the population is represented by a distribution of strategies, where each strategy has a particular frequency or proportion in the population. The system’s dynamics are governed by the fitness of each strategy, which measures how well it performs relative to other strategies in the population. The fitness of a strategy is typically defined in terms of the payoff it receives in a game against other strategies. Since the game we described in the previous section has a finite set of players and strategies and, more importantly, is symmetric, meaning players earn the same payoff when making the same choice against similar choices of their competitors, we can use replicator dynamics as a tool to reach its Nash equilibrium. According to [43], replicator dynamics presumes that individuals can only be programmed to pure strategies. So in such case, a mixed strategy x is regarded as the population state with each xix_i demonstrating the share of individuals in our population that are following the pure strategy i. In modeling the population’s evolution, its state must change over time to demonstrate the supremacy of a strategy over others. Since in our environment, the population was non-overlapping, we could use the discrete-time model with each period t=0,1,2,⋯t=0,1,2,·s representing a generation rather than its continuous-time counterpart. Non-overlapping populations refer to a situation where the individuals in a population are divided into separate, distinct groups that do not interact or compete with each other. Each group represents a separate sub-population, and the dynamics of each sub-population is modeled independently of the others. In the discrete-time replicator dynamics, x(t)=(x1,x2,⋯,xk)x(t)=(x_1,x_2,·s,x_k) with k being the number of available strategies, is the t-th generation’s distribution over the available pure strategies. Now suppose that payoffs represent the number of offspring each sub-population will have in the next generation and pip_i (t) is the number of individuals of type i in a population. Evidently, the size of population is p(t)=∑i=1kpi(t)>0p(t)= _i=1^kp_i(t)>0. The size of the sub-population playing strategy i in the next generation relies on the size of the sub-population in the current generation and the number of offspring it is allowed. Hence, as shown in [43] the dynamics is obtained by: pi(t+1)=[α+u(ei,x(t))]pi(t) p_i(t+1)=[α+u(e^i,x(t))]~p_i(t) (2) where α is the birthrate, a parameter that regulates the growth or decay rate of strategies. Large values of α will lead to slower convergence, and smaller values give faster but less stable convergence. Moreover, ui(ei,x(t))u_i(e^i,x(t)) is the expected payoff of playing the pure strategy i when the population is in state x(t)x(t). Consider that in our game, since the utility is computed by summing all the payoffs of two-person games played among neighbors, the population state x(t)x(t) must include the population states of all the neighbors. Thus, to avoid confusion, we reformulate the population state as x¯(t)=(x1(t),x2(t),⋯,xh(t)) x(t)=(x_1(t),x_2(t),·s,x_h(t)). Then we will have: pid(t+1)=[α+ui(eid,x¯−i(t))]pid(t) p_i^d(t+1)=[α+u_i(e_i^d, x_-i(t))]p_i^d(t) (3) where i is the player in a set R and d∈c,pd∈\c,p\. Now summing over all of the pure strategies will leave us with the following: pi(t+1)=[α+ui(x¯(t))]pi(t) p_i(t+1)=[α+u_i( x(t))]p_i(t) (4) where ui(x¯(t))=∑d=12xid(t)ui(eid,x¯−i(t))u_i( x(t))= _d=1^2x_i^d(t)u_i(e_i^d, x_-i(t)). In replicator dynamics, the probability of playing a strategy is equivalent to the proportion of individuals with that strategy in the population. Accordingly, xid(t)x_i^d(t) or the probability of playing the strategy d, is also determined by: xid(t)=(pid(t))/(pi(t))x_i^d(t)=(p_i^d(t))/(p_i(t)). Now in order to calculate the frequency of a strategy for a play i, for instance, the c or correct strategy, we have to divide the two above equations, which gives us the following: xic(t+1)=α+ui(eic,x¯−i(t))α+ui(x¯(t))xic(t) x_i^c(t+1)= α+u_i(e_i^c, x_-i(t))α+u_i( x(t))x_i^c(t) (5) More precisely, we have: xic(t+1)=α+∑j=1heicTAijxjα+∑j=1hxiT(t)Aijxj(t)xic(t) x_i^c(t+1)= α+ _j=1^he_i^c^TA_ijx_jα+ _j=1^hx_i^T(t)A_ijx_j(t)x_i^c(t) (6) Taking into consideration that we have two strategies, thus two frequencies, the probability of playing the p or corrupt strategy is calculated by: xip(t+1)=1−xic(t+1)x_i^p(t+1)=1-x_i^c(t+1). The above dynamics will lead to the growth of sub-populations associated with better-than-average strategies and the decline of worse-than-average strategies. In the long run, this process will converge to a Nash equilibrium [44]. Eventually, after enough execution of the above algorithm, the probability of belonging to a specific class for each unlabeled data point can be used for labeling these data points. This means that after reaching convergence, the label associated with a higher probability will be assigned to the unlabeled noise vector. For a more explicit description of the GERIS, one can refer to Algorithm 1. Algorithm 1 Labeling noise vectors with GERIS input : A set S of random noise vectors, 1/n1/n of which are labeled. for each unlabeled noise vector i in S do // set initial probabilities of each label to 0.50.5 xip,xic←0.5,0.5x_i^p,x_i^c← 0.5,0.5 // probabilities of labeled vectors are given in accordance with their labels while convergence condition is not reached do for each unlabeled noise vector i in S do // ucu_c and upu_p are the utility of pure strategies c and p // utu_t is the utility of the whole population uc,up,ut←0,0,0u_c,u_p,u_t← 0,0,0; R←hR← h number of i’s neighbors for each neighbor j in H do uc/p←uc/p+eic/pTAijxju_c/p← u_c/p+e_i^c/p^TA_ijx_j; ut←ut+xiTAijxju_t← u_t+x_i^TA_ijx_j; xic/p←α+uc/pα+utx_i^c/p← α+u_c/pα+u_t; for each unlabeled vector i in S do if xicx_i^c is bigger than 0.50.5 then label i as c; else label i as p; 3.3 Evaluation methodology The proposed model’s performance is evaluated through two stages. In the first stage, a direct evaluation was carried out by comparing manually labeled data to the labels achieved by our algorithm. The second stage aims to measure the accuracy of an Image-To-Text model that was trained with the generated license plates after being filtered by our algorithm. Figure 3 shows the evaluation pipeline of the proposed game. Figure 3: Two stages of evaluation methodology. 3.3.1 Measurement The proposed model was evaluated by F-measure. This is due to the fact that the portions of correct and corrupt data are significantly different, and the dataset is imbalanced. Thus, using metrics like accuracy will not provide us with a precise demonstration of the model’s performance in classifying the minority class. Furthermore, based on the types of noises incorporated in a noise vector, two classes of corruption could take place. The first class is the corrupt perspective and the second class is the corrupt non-perspective. This division was crucial due to the distinct nature of these noise types. For instance, rotating a license plate that contains a 6, might transform it to an image with a 9. In this case and other similar situations, the perspective noises might lead to the corruption of an image while the addition of other non-perspective noises could maintain the image’s readability. The opposite of the above example is also probable. For instance, a generated image of a license plate with the proper perspective could be impossible to read because of its blurriness. Therefore, each noise vector has two labels, one is chosen between correct perspective and corrupt perspective, and the other one can either be correct non-perspective or corrupt non-perspective. In addition, since the number of corrupt noise vectors being formed of perspective noises is not equal to the number of those being formed of non-perspective noises, the F-measure is calculated for each class separately. Otherwise, the evaluation of the model’s performance at detecting the two mentioned corruptions will be ambiguous. As a result, the following equations are used for evaluating the pruning mechanism: F1 F1 =(F1p+F1np)/2 =(F1_p+F1_np)/2 (7) Precision Precision =(Precisionp+Precisionp)/2 =(Precision_np+Precision_p)/2 (8) Recall Recall =(Recallp+Recallnp)/2 =(Recall_p+Recall_np)/2 (9) where the notation of npnp refers to the F-measure of labeling vectors with non-perspective noises and p refers to the F-measure of labeling perspective noises. Finally, the label of the i-th noise vector is calculated by the following equation: Label(i)=Labelp(i)∗Labelnp(i) Label^(i)=Label_p^(i)*Label_np^(i) (10) A noise vector is labeled as corrupt if either one of the perspective or non-perspective labels is determined as corrupt. 3.3.2 First stage methodology In this approach, a small fraction of generated noise vectors are labeled manually. To this end, we generate license plates via the framework, and add random noise vectors to it. If after adding each noise vector the quality of the image is maintained, the correct label is assigned to that vector. Subsequently, the labeled noise vectors are divided into three sets called train, validation, and test. The optimal values for hyperparameters of the game are obtained via a grid search using the validation set. These values are also employed for pruning license plates in the second stage. The train part of the dataset is given as a labeled sample for GERIS in order to predict labels of the data points in the test set. As labels of the test set are known previously, the computed F-measures can be evidence of the model’s performance. 3.3.3 Second stage methodology This stage is more important as compared with the previous stage, since alongside indicating the model’s performance it is also in accordance with our main purpose, i.e., training the recognition model. Initially, a large number of noise vectors are generated randomly. Then, the noise vectors are divided into m subsets, as labeling all of them in one process requires large memory usage. Therefore, GERIS is utilized with the previously computed hyperparameters to label the noise vectors in m chunks. Next, the noise vectors labeled as corrupt are removed, and license plates are generated based on the correct noise vectors. Since DenseNet [45] is a well-known model for classifying characters, it was chosen and trained by our generated license plates. DenseNet’s performance can prove the reliability of applying GERIS to filter the dataset. For this aim, a real-world license plate dataset is then used to evaluate DenseNet. 4 Experimental results In order to create a dataset that accurately reflects inputs of traffic cameras, our framework produces a noise vector by combining one to three randomly selected noise types from Table 2. This is because the experiments found that incorporating more than three noise types ensures the corruption of an image. In addition, a grid search for finding the optimal hyperparameters for the proposed game revealed the following optimal values: h=40h=40, α=0.999999α=0.999999, and 20 iterations for convergence. Experiments were conducted on an Apple MacBook Pro (M1 Pro chip, 16GB RAM) running macOS Monterey 12.6. The code utilized Python 3.9.2 with PyTorch 2.0.0 (compiled for Metal GPU acceleration), scikit-learn 1.2.2, and NumPy 1.26.4. PyTorch leveraged the M1 GPU via the Metal Performance Shaders (MPS) backend for hardware-accelerated training. 4.1 Sensivity Analysis of Training Data Ratio Regarding the algorithm’s sensitivity to the ratio of the train set to the test set, Figure 4 shows the mean F1 score computed for several arbitrary ratios based on the test set given in the first stage. The means calculated from the F1 scores were obtained from 100 experiments in which the testing data was picked randomly. The figure demonstrates that as the proportion of manually labeled noise vectors decreases from 80% down to 10%, the overall mean F1-score of the GERIS framework remains remarkably stable around 79%, indicating a high degree of robustness to reduced labeling effort. While the recall for corrupt instances (RecallcorruptRecall_corrupt) drops modestly from approximately 87.9% at 80% labeling to 69.7% at 10%, and PrecisioncorrectPrecision_correct declines slightly from 99.2% to 98.3%, the complementary metrics (RecallcorrectRecall_correct and PrecisioncorruptPrecision_corrupt) actually improve or remain flat as labeling is reduced. This suggests that GERIS can maintain balanced performance even when only a small fraction of noise vectors are labeled. From a scalability standpoint, requiring as little as 10% labeled data yields near-optimal F1 performance, substantially lowering manual annotation cost without sacrificing model effectiveness, and thus supports deployment on larger datasets with limited labeling budgets. 1010202030304040505060607070808060608080100100Ratio of training data (%)Mean F1 score (%)RecallcorruptRecall_corruptRecallcorrectRecall_correctF1F1PrecisioncorruptPrecision_corruptPrecisioncorrectPrecision_correct Figure 4: Analysis of training size ratio in terms of mean F1 score. 4.2 Experimental results of the first stage In the final step of this stage, we compared the proposed method with several well-known classification algorithms, given that GERIS, too, performs a classification task over noise vectors. To evaluate the performance of the proposed scheme, 2000 random noise vectors were generated. Our benchmarks included classical machine learning methods such as KNN, MLP, Naive Bayes, SVM, and Random Forest, as well as two modern deep learning baselines: Transformer-based models and Squeeze-and-Excitation (SE) networks. Transformer architectures leverage self-attention mechanisms to capture long-range dependencies and global feature interactions, making them particularly effective for learning complex data relationships [46]. In contrast, SE networks introduce channel-wise attention through a two-step process of “squeeze” (global information aggregation) and “excitation” (adaptive feature recalibration), allowing the model to emphasize more informative features while suppressing noise [47]. While Transformers are adept at modeling global context, SE networks focus on refining local discriminative features—both offering complementary advantages in representation learning. In the context of tabular noise vectors, Transformers help uncover high-level correlations, whereas SE modules enhance signal-to-noise discrimination. Table 3 shows the benchmark results. Each experiment was repeated 100 times, and the average result is reported in the table. It is crucial to note that PrecisioncorruptPrecision_corrupt and RecallcorruptRecall_corrupt are of more importance, as keeping a corrupt noise vector in the dataset is more detrimental than removing a correct noise vector. As evident in Table 3, the F-measures of GERIS are higher than those of other stated classification algorithms. Three critical findings emerge from Tables 3 and 4: • Detection Superiority: GERIS achieves 85.84% corrupt recall (±0.002± 0.002) — 31.16 p higher than SE Networks (54.68%±0.00354.68\%± 0.003), 33.04 p higher than Transformers (52.80%±0.00252.80\%± 0.002), and 1.57 p higher than Naïve Bayes (84.27%±0.00284.27\%± 0.002). This comes while maintaining near-perfect correct label precision (99.04% vs. Naïve Bayes’ 99.15%), reducing false positives by 2.1× compared to SE Networks. • Stability-Accuracy Tradeoff: While Naïve Bayes shows competitive corrupt recall (84.27%), its corrupt precision is 55.07% — 2.28 p lower than GERIS (57.35%). The SE Network’s high corrupt precision (62.01±0.01862.01± 0.018) proves brittle, suffering 31.16 p lower recall than GERIS. Transformers show similar limitations, with precision-recall imbalance (61.7261.72 vs. 52.8052.80). • Operational Efficiency: GERIS runs 1.15× faster than Naïve Bayes (2.662.66s vs. 3.073.07s) while achieving 1.17 p higher F1 (79.6679.66 vs. 78.4978.49). Compared to deep learning methods, GERIS is 4.9× faster than SE Networks (12.9912.99s) and 12.9× faster than Transformers (34.3534.35s). The results demonstrate that GERIS successfully balances: • Effectiveness: Outperforms all baselines in F1, including +1.17 p over Naïve Bayes (79.6679.66 vs. 78.4978.49) • Reliability: 1.2× lower F1 variance than Naïve Bayes (±0.013± 0.013 vs. ±0.015± 0.015) • Safety: 99.04% correct precision vs. Naïve Bayes’ 99.15% (marginally lower by 0.11 p but with 1.57 p higher corrupt recall) • Speed: Processes 377 samples/second vs. Transformers’ 29 samples/second. This combination proves particularly effective for noise filtering in class-imbalanced scenarios (29.8%29.8\% corrupt labels). While Naïve Bayes achieves marginally higher correct precision (99.15%99.15\%), GERIS provides better balance with 1.57 p higher corrupt recall and 1.15× faster execution. The explicit pattern storage architecture, while memory-intensive (12891289MB), enables auditability absent in both traditional statistical methods and modern neural approaches. Table 3: Benchmark of Filtering Methods (Mean ± Std over 100 Trials) Method F1 Precisioncorrupt Precision_ corrupt PrecisioncorrectPrecision_correct RecallcorruptRecall_corrupt RecallcorrectRecall_correct KNN 73.61 (± 0.002) 48.62 (± 0.000) 97.72 (± 0.000) 48.69 (± 0.000) 99.48 (± 0.0) MLP 73.28 (± 0.003) 49.54 (± 0.000) 97.04 (± 0.000) 46.85 (± 0.000) 99.84 (± 0.000) Naïve Bayes 78.49 (± 0.015) 55.07 (± 0.000) 99.15 (± 0.000) 84.27 (± 0.002) 92.11 (± 0.0) SVM 73.67 (± 0.003) 49.16 (± 0.000) 97.61 (± 0.000) 48.27 (± 0.000) 99.69 (± 0.000) Rand Forest 73.80 (± 0.002) 49.05 (± 0.000) 97.76 (± 0.000) 48.78 (± 0.000) 99.64 (± 0.000) One Class SVM 56.45 (± 0.023) 29.60 (± 0.002) 87.06 (± 0.001) 39.63 (± 0.003) 87.75 (± 0.001) Isolation Forest 60.49 (± 0.016) 37.09 (± 0.001) 88.71 (± 0.001) 44.98 (± 0.003) 88.87 (± 0.001) KMeans 39.61 (± 0.168) 20.86 (± 0.021) 81.41 (± 0.016) 53.17 (± 0.038) 49.46 (± 0.064) SE Network 77.27 (± 0.035) 62.01 (± 0.018) 97.97 (± 0.000) 54.68 (± 0.003) 99.02 (± 0.000) Transformer 76.45 (± 0.033) 61.72 (± 0.023) 97.88 (± 0.000) 52.80 (± 0.002) 99.21 (± 0.000) GERIS 79.66 (± 0.013) 57.35 (± 0.000) 99.04 (± 0.000) 85.84 (± 0.002) 93.20 (± 0.000) Table 4: Resource Usage Profile of Filtering Methods (Mean ± Std over 100 Trials) Method Run Time (s) Memory Usage (MB) KNN 2.09 (± 0.58) 212.38 (± 18.29) MLP 6.18 (± 1.58) 194.34 (± 26.57) Naïve Bayes 3.07 (± 0.05) 183.33 (± 5.65) SVM 2.13 (± 0.05) 210.71 (± 8.67) Rand Forest 1.80 (± 0.02) 241.83 (± 9.57) One Class SVM 2.17 (± 0.06) 203.37 (± 21.27) Isolation Forest 1.29 (± 0.03) 215.09 (± 3.88) KMeans 1.96 (± 0.60) 224.98 (± 4.00) SE Network 12.99 (± 1.20) 186.80 (± 16.93) Transformer 34.35 (± 0.48) 234.89 (± 69.66) GERIS 2.66 (± 0.05) 1289.59 (± 84.08) 4.3 Experimental results of the second stage In this stage, a real-world license plate dataset is used as a touchstone to assess the model’s performance in character recognition. Doing so, 50000 random noise vectors are produced by the previously introduced generator to train the model with different input datasets. Table 5 demonstrates the result of the experiments. In these experiments, six approaches were pursued. 1. A character recognition process takes place based on an unfiltered real input dataset. 2. The model is trained with the unfiltered data produced by the framework. 3. The same dataset in the previous approach was used, but it was filtered with Naive Bayes. 4. Both real and augmented data, which was filtered by Naive Bayes, were involved in the training of the character recognition model. 5. The data generated by the framework and filtered by GERIS was given as an input to the model. 6. Both real and augmented data, which was filtered by GERIS, were involved in the training of the character recognition model. To conduct these experiments, the dataset is divided into two subsets of digits and alphabets. We split the dataset to carry out the detection of each group of characters with their own specialized models. This division was easily done due to the fact that in a license plate, alphabets always appear once and are located in a fixed position. Accordingly, the two DenseNet models, one for digits and the other for alphabets are trained and evaluated separately. The illustrated data in Table 5 proves that using the introduced framework to augment data along with GERIS as a filtering method causes a significant improvement in the overall performance of the model. We specifically compared the impact of our method to that of Naive Bayes, as it achieved the highest performance among the benchmark models presented in Table 3. As seen in the obtained results, regarding the dataset of digits, the accuracy, F1 score, precision, and recall of the baseline model were increased by 10.05%, 17%, 17.85%, and 15.32% respectively. Regarding the dataset of alphabets, an increase of 26.78%, 31.09%, 26.24%, and 33.13% was seen for the same mentioned measures respectively. Table 5: Benchmark of Character Recognition Training Data Filtering Method Digits Alphabets Real Data Synthetic Accuracy F1 Precision Recall Accuracy F1 Precision Recall ✓ ✗ ✗ 87.23 79.79 79.56 80.99 70.5 57.75 62.25 58.32 ✗ ✓ ✗ 94.95 94.84 95.67 94.5 92.71 82.61 82.53 87.79 ✗ ✓ Naive Bayes 96.21 96.21 96.4 96.07 94.52 86.62 86.91 88.28 ✓ ✓ Naive Bayes 96.21 96.21 96.4 96.07 95.75 87.61 86.8 90.59 ✗ ✓ GERIS 96.64 96.26 96.67 95.93 96.41 87.98 89.06 88.04 ✓ ✓ GERIS 97.28 96.79 97.41 96.31 97.28 88.84 88.49 91.45 5 Discussion In this study, the k-nearest neighbor graph is central to the GERIS framework. To find the optimal value for h, we used a grid search strategy. For each candidate value of h, we constructed the k-nearest neighbor graph and ran the GERIS model on the validation set. The value of h that yielded the highest F1-score on the validation data was chosen as the optimal neighborhood size. This method ensures that the graph structure is adaptively adjusted to maximize the accuracy of noise vector classification. 5.1 Computational Complexity Let n represent the number of noise vectors and d the dimensionality of the feature space. The process of building a k-nearest neighbor graph using the brute-force Mahalanobis distance involves computing all pairwise distances between the noise vectors, which has a time complexity of: O(n2d) O(n^2d) (11) Since this process is repeated for each candidate value of h during the grid search (denoted as H possible values), and assuming the computational cost of label propagation via GERIS is T, the overall time complexity becomes: O(H⋅(n2d+T)) O(H·(n^2d+T)) (12) This complexity is manageable for small datasets. In our experiments, the dataset contained a relatively small number of synthetic noise vectors (e.g., 2000 in the first stage and 50000 in the second), which allowed us to use the exact brute-force method for neighbor retrieval without incurring significant computational overhead. However, scaling this approach to large datasets would result in prohibitive computational costs, especially when graph construction needs to be repeated during the hyperparameter optimization process. To address this challenge, Approximate Nearest Neighbor (ANN) search methods present a promising alternative [48]. 5.2 Future Work: Accelerating Neighbor Search with ANN As a direction for future research, we propose replacing the brute-force k-N graph construction with ANN search methods. These methods aim to identify approximate neighbors for each point, achieving substantially reduced computational cost while sacrificing only a small amount of accuracy. ANN search techniques are particularly useful in high-dimensional or large-scale settings, where exact k-N search becomes computationally expensive. ANN algorithms such as Hierarchical Navigable Small Worlds (HNSW), Locality-Sensitive Hashing (LSH), and Product Quantization offer favorable trade-offs between search speed and accuracy. Among available tools, Facebook AI Similarity Search (FAISS) is particularly notable for its performance and ease of use [49]. FAISS provides implementations of several ANN methods and supports GPU-accelerated and CPU-based indexing, batch querying, and memory mapping. It is well-suited for scaling the neighbor search process and can handle large datasets with sub-second query latency. In the ANN-based extension of GERIS, the framework would be modified as follows: • The k-nearest neighbor graph is constructed once using ANN methods, and the optimal number of neighbors is determined by search results. • We would select the optimal number of similar records for each query. This eliminates the need for iterative graph construction during hyperparameter optimization. • Owing to the efficiency of ANN search, this extension enables scalable graph construction, making it applicable to larger datasets without sacrificing computational efficiency. 5.3 Time Complexity of ANN-Based Graph Construction For ANN methods such as HNSW, the time complexity for index construction is approximately: O(nlogn)O(n n) and the query time for each data point is sublinear, typically: O(logn)O( n). Therefore, constructing a neighborhood graph over all n points using ANN would have a total time complexity of: O(nlogn)⏟indexing+O(nlogn)⏟querying=O(nlogn) O(n n)_indexing+ O(n n)_querying=O(n n) (13) This is a significant improvement over the O(n2d)O(n^2d) complexity of the exact k-N search, particularly when n is large and d is moderate to high. By incorporating ANN-based neighbor search into GERIS, we significantly reduce runtime while maintaining the model’s effectiveness in label propagation and noise filtering, making it suitable for deployment on large-scale datasets. 6 Potential Applications Beyond License Plates While our experiments focus primarily on license plate recognition, GERIS’s semi-supervised, graph-pruning approach within the IDN model can easily be applied to other fields: • Medical Imaging: In areas such as histopathology and radiology, subtle variations in texture, illumination, or artifacts can lead to instance-dependent mislabeling (e.g., distinguishing between benign and borderline lesions). By acquiring a small set of confirmed noisy labels—either through expert consensus or known imaging artifacts—GERIS can identify and prune additional mislabeled scans or tiles using a Mahalanobis-distance k-N graph. • Remote Sensing: Satellite imagery frequently suffers from occlusions (such as cloud cover or shadows) that introduce labeling noise in each scene (e.g., misclassifying land-cover types). A limited selection of manually reviewed "noisy" patches can serve as a starting point for GERIS to detect similar mislabeled pixels or segments on a larger scale. These examples illustrate how GERIS can be effectively utilized under the IDN framework to enhance data quality across various pattern-recognition tasks, especially when a modest number of seed noisy instances is available. 7 Conclusion In this study, we addressed the challenge of data augmentation in license plate recognition by introducing GERIS, a game-theoretic framework for filtering synthetic noise vectors. GERIS proficiently differentiates between useful and corrupt noise vectors, specifically addressing the critical issue of augmentation-induced noise, which frequently presents itself as instance-dependent label noise (IDN). By modeling the instance selection process as a non-cooperative game and using replicator dynamics to reach Nash equilibrium, GERIS effectively classifies noise vectors as either useful or corrupt. Our two-stage empirical evaluation demonstrates that GERIS outperforms classical filtering methods in detecting corrupt instances and leads to improved performance in downstream recognition tasks. While this study focused on license plate recognition, the underlying framework of GERIS could be adapted for other domains such as medical imaging, where instance selection is equally critical. These domains, however, may pose additional challenges due to subtler distinctions between noise types and increased difficulty in manual labeling. Exploring such adaptations remains a promising avenue for future research. From a scalability perspective, although our current implementation uses exact k-N search, future work should explore approximate nearest neighbor (ANN) methods to enable efficient deployment on large-scale datasets. Additional improvements may involve refining the payoff structure or incorporating alternative game-theoretic dynamics. Overall, GERIS offers a principled and adaptable approach to improving the quality of augmented datasets across a variety of machine learning applications. References [1] Z. Nematzadeh, R. Ibrahim, and A. Selamat (2020) Improving class noise detection and classification performance: a new two-filter cndc model. Applied Soft Computing 94, p. 106428. Cited by: §1. [2] H. Song, M. Kim, D. Park, Y. Shin, and J. Lee (2022) Learning from noisy labels with deep neural networks: a survey. IEEE transactions on neural networks and learning systems. Cited by: §1, §1, §2.1.1, §2.1.4, Table 1. [3] C. Van Eupen, D. Maes, M. Herremans, K. R. Swinnen, B. Somers, and S. Luca (2021) The impact of data quality filtering of opportunistic citizen science data on species distribution model performance. Ecological Modelling 444, p. 109453. Cited by: §1. [4] M. S. Al-Shemarry, Y. Li, and S. Abdulla (2023) Identifying license plates in distorted vehicle images: detecting distorted vehicle licence plates using a novel preprocessing methods with hybrid feature descriptors. IEEE Intelligent Transportation Systems Magazine 15 (2), p. 6–25. External Links: Document Cited by: §1. [5] H. Shi and D. Zhao (2023) License plate recognition system based on improved yolov5 and gru. IEEE Access 11, p. 10429–10439. Cited by: §1. [6] C. E. Anagnostopoulos (2014) License plate recognition: a brief tutorial. IEEE Intelligent Transportation Systems Magazine 6 (1), p. 59–67. External Links: Document Cited by: §1. [7] X. Fan and W. Zhao (2022) Improving robustness of license plates automatic recognition in natural scenes. IEEE Transactions on Intelligent Transportation Systems 23 (10), p. 18845–18854. Cited by: §1. [8] Q. Huang, Z. Cai, and T. Lan (2020) A new approach for character recognition of multi-style vehicle license plates. IEEE Transactions on multimedia 23, p. 3768–3777. Cited by: §1. [9] N. Omar, A. Sengur, and S. G. S. Al-Ali (2020) Cascaded deep learning-based efficient approach for license plate detection and recognition. Expert Systems with Applications 149, p. 113280. Cited by: §1. [10] N. Duan, J. Cui, L. Liu, and L. Zheng (2021) An end to end recognition for license plates using convolutional neural networks. IEEE Intelligent Transportation Systems Magazine 13 (2), p. 177–188. External Links: Document Cited by: §1. [11] C. Shorten and T. M. Khoshgoftaar (2019) A survey on image data augmentation for deep learning. Journal of big data 6 (1), p. 1–48. Cited by: §1. [12] A. Azizian, R. Ahmadian, M. Ghatee, and M. Shamsi (2024) Preventing overfitting on noisy labels through adaptive checkpointing. In 2024 10th International Conference on Signal Processing and Intelligent Systems (ICSPIS), p. 150–154. Cited by: §1, §2.1.4. [13] V. Herrera-Semenets, R. Hernández-León, and J. van den Berg (2022) A fast instance reduction algorithm for intrusion detection scenarios. Computers and Electrical Engineering 101, p. 107963. Cited by: §2.1.1, Table 1. [14] F. T. Liu, K. M. Ting, and Z. Zhou (2008) Isolation forest. In 2008 Eighth IEEE International Conference on Data Mining, Vol. , p. 413–422. External Links: Document Cited by: §2.1.1, Table 1. [15] J. A. Hartigan and M. A. Wong (1979) Algorithm as 136: a k-means clustering algorithm. Journal of the royal statistical society. series c (applied statistics) 28 (1), p. 100–108. Cited by: §2.1.1, Table 1. [16] P. Hart (1968) The condensed nearest neighbor rule (corresp.). IEEE transactions on information theory 14 (3), p. 515–516. Cited by: §2.1.1, Table 1. [17] D. R. Wilson and T. R. Martinez (2000) Reduction techniques for instance-based learning algorithms. Machine learning 38 (3), p. 257–286. Cited by: §2.1.2, Table 1. [18] M. Koziarski (2020) Radial-based undersampling for imbalanced data classification. Pattern Recognition 102, p. 107262. Cited by: §2.1.2, Table 1. [19] C. K. Aridas, S. Karlos, V. G. Kanas, N. Fazakis, and S. B. Kotsiantis (2019) Uncertainty based under-sampling for learning naive bayes classifiers under imbalanced data sets. IEEE Access 8, p. 2122–2133. Cited by: §2.1.2, Table 1. [20] S. Garcia and F. Herrera (2008) An extension on" statistical comparisons of classifiers over multiple data sets" for all pairwise comparisons.. Journal of machine learning research 9 (12). Cited by: §2.1.3, Table 1. [21] I. Razzak, K. Zafar, M. Imran, and G. Xu (2020) Randomized nonlinear one-class support vector machines with bounded loss function to detect of outliers for large scale iot data. Future Generation Computer Systems 112, p. 715–723. Cited by: §2.1.3, Table 1. [22] Y. Zhu, J. Zhang, A. Gangrade, and C. Scott (2024) Label noise: ignorance is bliss. Advances in Neural Information Processing Systems 37, p. 116575–116616. Cited by: §2.1.4. [23] L. Jiang, Z. Zhou, T. Leung, L. Li, and L. Fei-Fei (2018) Mentornet: learning data-driven curriculum for very deep neural networks on corrupted labels. In International conference on machine learning, p. 2304–2313. Cited by: §2.1.4. [24] C. D. Kim, S. Moon, J. Moon, D. Woo, and G. Kim (2024) Sample selection via contrastive fragmentation for noisy label regression. Advances in Neural Information Processing Systems 37, p. 127561–127609. Cited by: §2.1.4. [25] M. Chen, H. Cheng, Y. Du, M. Xu, W. Jiang, and C. Wang (2023) Two wrongs don’t make a right: combating confirmation bias in learning with label noise. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 37, p. 14765–14773. Cited by: §2.1.4. [26] G. Zheng, A. H. Awadallah, and S. Dumais (2021) Meta label correction for noisy label learning. In Proceedings of the AAAI conference on artificial intelligence, Vol. 35, p. 11053–11061. Cited by: §2.1.4. [27] W. Chang, Y. Shi, and J. Wang (2023) Csot: curriculum and structure-aware optimal transport for learning with noisy labels. Advances in Neural Information Processing Systems 36, p. 8528–8541. Cited by: §2.1.4. [28] Y. Liu and H. Guo (2020) Peer loss functions: learning from noisy labels without knowing noise rates. In International conference on machine learning, p. 6226–6236. Cited by: §2.1.4. [29] Z. Wang, G. Hu, and Q. Hu (2020) Training noise-robust deep neural networks via meta-learning. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, p. 4524–4533. Cited by: §2.1.4. [30] Y. Yao, Z. Sun, C. Zhang, F. Shen, Q. Wu, J. Zhang, and Z. Tang (2021) Jo-src: a contrastive approach for combating noisy labels. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, p. 5192–5201. Cited by: §2.1.4. [31] M. Xu, S. Yoon, A. Fuentes, and D. S. Park (2023) A comprehensive survey of image augmentation techniques for deep learning. Pattern Recognition, p. 109347. Cited by: §2.3. [32] A. Mumuni and F. Mumuni (2022) Data augmentation: a comprehensive survey of modern approaches. Array, p. 100258. Cited by: §2.3. [33] M. Rottmann and M. Reese (2023) Automated detection of label errors in semantic segmentation datasets via deep learning and uncertainty quantification. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, p. 3214–3223. Cited by: Table 1. [34] R. Ahmadian, M. Ghatee, J. Wahlström, and H. Zare (2024) Uncertainty quantification to enhance probabilistic fusion based user identification using smartphones. IEEE Internet of Things Journal. Cited by: Table 1. [35] D. E. Rumelhart, G. E. Hinton, and R. J. Williams (1986) Learning representations by back-propagating errors. nature 323 (6088), p. 533–536. Cited by: Table 1. [36] A. Roy and R. H. Laskar (2019) Fuzzy svm based fuzzy adaptive filter for denoising impulse noise from color images. Multimedia Tools and Applications 78, p. 1785–1804. Cited by: Table 1. [37] R. Ahmadian, M. Ghatee, and J. Wahlström (2025) Enhancing user identification through batch averaging of independent window subsequences using smartphone and wearable data. Computers & Security 150, p. 104265. Cited by: Table 1. [38] R. Ahmadian, M. Ghatee, and J. Wahlström (2024) Improved user identification through calibrated monte-carlo dropout. Knowledge-Based Systems 305, p. 112581. Cited by: Table 1. [39] R. Ahmadian, M. Ghatee, and J. Wahlström (2023) Driver identification by an ensemble of cnns obtained from majority-voting model selection. In International Conference on Artificial Intelligence and Smart Vehicles, p. 120–136. Cited by: Table 1. [40] P. D. Straffin (1993) Game theory and strategy. Vol. 36, MAA. Cited by: §3.2.1. [41] B. A. Almogahed and I. A. Kakadiaris (2015) NEATER: filtering of over-sampled data using non-cooperative game theory. Soft Computing 19, p. 3301–3322. Cited by: §3.2.2. [42] J. Nash Jr (1996) Non-cooperative games. In Essays on Game Theory, p. 22–33. Cited by: §3.2.2, §3.2.2. [43] J. W. Weibull (1997) Evolutionary game theory. MIT press. Cited by: §3.2.4. [44] R. Cressman and Y. Tao (2014) The replicator equation and other game dynamics. Proceedings of the National Academy of Sciences 111 (supplement_3), p. 10810–10817. Cited by: §3.2.4. [45] G. Huang, Z. Liu, L. Van Der Maaten, and K. Q. Weinberger (2017) Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, p. 4700–4708. Cited by: §3.3.3. [46] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin (2017) Attention is all you need. Advances in neural information processing systems 30. Cited by: §4.2. [47] J. Hu, L. Shen, and G. Sun (2018) Squeeze-and-excitation networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, p. 7132–7141. Cited by: §4.2. [48] M. Wang, X. Xu, Q. Yue, and Y. Wang (2021) A comprehensive survey and experimental comparison of graph-based approximate nearest neighbor search. arXiv preprint arXiv:2101.12631. Cited by: §5.1. [49] J. Johnson, M. Douze, and H. Jégou (2019) Billion-scale similarity search with gpus. IEEE Transactions on Big Data 7 (3), p. 535–547. Cited by: §5.2.