An efficient and straightforward online vector quantization method for a data stream through remove-birth updating

Metric for RB updating

Concept drift results in a change in the characteristics of a data stream. As a result of this change, some units representing the data with old characteristics may be outside the data distribution with new characteristics, as shown in Figs. 1A and 1B. RB updating addresses this problem by removing units that are far from the current data distribution and creating new units around the units on the distribution, as shown in Fig. 1C. Developing an effective metric for determining when and which unit to remove and where to create a unit is critical to RB updating.

Fritzke (1997) have proposed a metric based on error, which is the difference (distance) between a data point and its corresponding reference vector. However, the effectiveness of this error-based metric is affected by the value range of the dataset. Thus, this metric will face problems for data streams undergoing concept drift because there is no guarantee that the value range is static for data streams.

This study introduces win probability as an alternative metric. A win of a unit means that the unit is closest to an input data point. Unlike error-based metrics, win probability retains independence from the value range of the dataset, thereby enhancing its effectiveness in RB updating even as the value range of the dataset changes due to concept drift. This metric M_n(t) of unit n is expressed as (1)${\displaystyle M_n\left(t\right)=\frac{P_{\mathrm{win},n}\left(t\right)}{\underset{n}{max}{P}_{\mathrm{win},n}\left(t\right)}=\frac{c_n\left(t\right)}{\underset{n}{max}{c}_n\left(t\right)}.}$ Here, P_win,n(t) = c_n(t)/(∑_mc_m(t)) refers to the win probability of unit n, and c_n(t) refers to the number of wins of unit n. In this study, c_n(t) shows the decay over iteration as indicated: (2)${\displaystyle c_n\left(t+1\right)=c_n\left(t\right)-\beta c_n\left(t\right),}$ where β is a decay constant. This exponential decay mechanism limits the influence of old data characteristics, thus improving the overall effectiveness of the RB updating process.

Online k-means with RB updating

Online k-means with RB updating (OKRB) is a modification of the standard online k-means algorithm designed to quickly adapt to variations within a data stream. However, online k-means suffers from the problem of dead units. Dead units are units (centroids) to which no data points are assigned, often due to their initial placement far from the input dataset. When concept drift occurs, and results in units far from the data distribution, units close to the dataset may gradually move toward it, while those farther away remain static. When concept drift occurs and the data distribution changes, online k-means will generate dead units. OKRB mitigates this shortcoming through RB updating. The detailed procedure for the OKRB algorithm is described in Algorithm 1 .

Consider an input data sequence denoted by X = {x₁, x₂, …, x_t, …}, where each x_t belongs to a D-dimensional real space ℝ^D. The probability distribution generating X may change during data point generation due to concept drift.

OKRB contains N units, where each unit represents a centroid. Each unit i is associated with a reference vector w_n ∈ ℝ^D. To accommodate evolving data streams, OKRB iteratively adapts its reference vectors to the incoming data point x_t, eliminating less useful units through RB updating.

In the initialization phase described in Algorithm 1 (steps 2 and 3), we initialize the reference vector w_n and the win count c_n. Specifically, each reference vector w_n is constructed according to the following equation: (3)${\displaystyle {\mathit{w}}_n=\left({\xi }_1,\dots ,{\xi }_d,\dots ,{\xi }_D\right),}$ where each component ξ_d is sampled uniformly at random from the interval [0, 1). The win count c_n is initialized to zero.

In each iteration, OKRB processes a single data point x_t. Initially, the algorithm receives x_t ( Algorithm 1 , step 5) and identifies the winning unit n₁, which is the unit whose reference vector is closest to x_t ( Algorithm 1 , step 7). The reference vector of n₁ is updated by (4)${\displaystyle {\mathit{w}}_{n_1}\leftarrow {\mathit{w}}_{n_1}+\varepsilon \left({\mathit{x}}_t-{\mathit{w}}_{n_1}\right),}$ where ɛ is the learning rate ( Algorithm 1 , step 8). Unlike traditional online k-means, where the learning rate decays over time, in OKRB the learning rate remains static. This is because the data streams are unbounded, making the end of the iteration indeterminable.

RB updating in OKRB serves to prune less winning units while introducing new units near frequently winning units. Specifically, each iteration n₁’s win count c_n1 is incremented by one ( Algorithm 1 , step 10). The algorithm then identifies the unit with the maximum number of wins n_max ( Algorithm 1 , step 11) and the unit with the minimum number of wins n_min ( Algorithm 1 , step 12). If c_nmin/c_nmax exceeds a certain threshold TH_RB, RB updating is triggered ( Algorithm 1 , step 13): the unit n_min is discarded and a new unit n_new is added near n_max. In Algorithm 1 , n_new = n_min. The reference vector and the win count of n_new are determined by w_nnew = (w_nmax + w_f)/2 and c_nnew = (c_nmax + c_f)/2, respectively, where f is the unit closest to n_max ( Algorithm 1 , steps 14–16).

Finally, the winning counts of all units are exponentially decaying ( Algorithm 1 , step 18), according to (5)${\displaystyle c_n\leftarrow c_n-\beta c_n,}$ with β as the decay rate.

 
___________________________________________________________ 
Algorithm 1 Online k-means with RBirth updating (OKRB)______________________________________________________________________________________________________________________________________________________________________________________________ 
Require: X = {x1,...,xt,...}, N 
 1:  Initialize: 
 2:      wn = (ξ1,...,ξd,...,ξD),n=1,...,N, where ξd = [0,1) is uniformed random 
  3:      cn = 0,n=1,...,N 
 4:  loop 
 5:       Receive input xt at iteration t 
 6:       {Update reference vectors:} 
 7:       n1 = arg min 
     n     ∥xt −wn∥ 
 8:       wn1  ← wn1 + ɛ(xt −wn1) 
  9:       {RB updating:} 
10:       cn1  ← cn1 + 1 
11:       nmax = arg max 
     n     cn 
12:       nmin = arg min 
     n     cn 
13:       if cnmin/cnmax  < THRB then 
14:            f = arg min 
     n     ∥wn −wnmax∥ 
15:            wnmin  = (wnmax + wf)/2. 
16:            cnmin  = (cnmax + cf)/2. 
17:       end if 
18:       cn ← cn − βcn,n=1,...,N 
19:  end loop_____________________________________________________________________________________________________________________________________________________________________________________________________________________________    

SOM with RB updating

Self-Organizing Map with RB updating (SOMRB) is based on standard SOM, but with improved adaptation to changes in the data stream through RB updating. SOMRB projects high-dimensional input data onto a low-dimensional map that can be used for clustering, visualization, and dimension reduction. The detailed SOMRB algorithm is given in Algorithm 2 .

SOMRB contains N units, each with a reference vector w_n in ℝ^d. These units, positioned at p_n = (p_n1, p_n2) ∈ ℝ² on a two-dimensional map, form a grid structure with p_n1 and p_n2 as integers. First, unit n is positioned at p_n = (⌊n/L⌋, (modL)), where $L=\lfloor \sqrt{N}\rfloor$ ( Algorithm 2 , steps 2 and 3). Units are connected to their nearest neighbors, forming a 2-dimensional grid (Algorithm 2, step 4). The reference vector is initialized as w_n = (n/L, (modL)/L, 0, …, 0) ( Algorithm 2 , step 5). Such an initialization strategy mitigates the distortion of SOMRB’s mesh topology. The win count c_n are set to 0 ( Algorithm 2 , step 6).

In each iteration, SOMRB receives a single data point x_t ( Algorithm 2 , step 8) and adjusts its reference vectors. The winning unit, n₁, with the reference vector closest to x_t, is identified ( Algorithm 2 , step 10). Then, all reference vectors are updated according to (6)${\displaystyle {\mathit{w}}_n\leftarrow {\mathit{w}}_n+\varepsilon h\left(\parallel {\mathit{p}}_n-{\mathit{p}}_{n_1}\parallel \right)\left({\mathit{x}}_t-{\mathit{w}}_n\right),}$ where ɛ is the learning rate and h(⋅) is the neighborhood function defined as $h\left(d\right)=exp\left(-\frac{d^2}{2{\sigma }^2}\right)$ ( Algorithm 2 , step 11).

RB updating is used to remove units that rarely win (dead units) and to add new units around units that frequently win. The win count of unit n₁, denoted by c_n1, is incremented at each iteration ( Algorithm 2 , step 13). The unit with the maximum count c_nmax is identified from the units with neighboring empty vertices (Algorithm 2, steps 14 and 15). Note that n_max must have neighboring empty vertices on the grid. The number of edges of the unit with neighboring empty vertices e_n is less than four, because a unit on the grid can have a maximum of four edges ( Algorithm 2 , step 14). The unit with the minimum count c_nmin is also identified ( Algorithm 2 , step 16). When c_nmin/c_nmax exceeds the threshold TH_RB, an RB update is performed ( Algorithm 2 , step 17). This involves removing the minimum winning unit n_min ( Algorithm 2 , step 18) and adding a new unit n_new near the maximum winning unit n_max ( Algorithm 2 , step 19). In Algorithm 2 , n_new = n_min.n_new is placed on an empty vertex neighboring n_max, which is chosen randomly if there is more than one empty vertex. n_new is connected to the neighboring units on the grid ( Algorithm 2 , step 20). The reference vector w_nnew of n_new is computed based on the average of the reference vectors of the neighboring units if it has more than one neighbor ( Algorithm 2 , steps 21–23). c_nnew is the average win count of the neighboring units. Conversely, if n_new has only one neighbor (i.e., n_new connects only to n_max), the reference vector of n_new is the average of the reference vectors of n_max and its neighbors ( Algorithm 2 , steps 26–29). In scenarios in which n_max connects only to n_new, the reference vector w_nnew is the average of the reference vectors of n_max and its nearest unit f ( Algorithm 2 , steps 30–33).

All winning counts are exponentially decaying according to the following formula ( Algorithm 2 , step 37): (7)${\displaystyle c_n\leftarrow c_n-\beta c_n,}$ where β is the decay rate.

 
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________ 
Algorithm 2 Self-Organizing Map with RB updating (SOMRB)__________________________________________________________________________________________________________________________________________________________________________________________ 
Require: X = {x1,...,xt,...}, N 
 1:  Initialize: 
 2:      L = ⌊√ 
 _N⌋ 
 3:      pn = (⌊n/L⌋,(n mod L)),n=0,...,N − 1 
  4:      Connect each pair of neighboring units 
  5:      wn = (⌊n/L⌋/L,(n mod L)/L,0,...,0),n=0,...,N − 1 
  6:      cn = 0,n=0,...,N − 1 
  7:  loop 
 8:       Receive input xt at iteration t 
 9:       {Update reference vectors:} 
10:       n1 = arg min 
     n     ∥xt −wn∥ 
11:       wn ← wn + ɛh(∥pn −pn1∥)(x−wn),n=0,...,N − 1 
12:       {RB updating:} 
13:       cn1  ← cn1 + 1 
14:       M = {n | en < 4}, where en is the number of edges connected to unit n 
15:       nmax = arg max 
   n∈M   cn 
16:       nmin = arg min 
     n     cn 
17:       if cnmin/cnmax  < THRB then 
18:            Remove unit nmin 
19:            Add new unit nmin on the empty vertex neighboring unit nmax 
20:            Establish edges between unit nmin and its neighboring units 
21:            Mmin = {n | n is a neighbor of nmin} 
22:            if |Mmin| > 1 then 
23:                  wnmin  =    1 ____ 
|Mmin|∑ 
      n∈M 
min wn. 
24:                  cnmin  =    1 ____ 
|Mmin|∑ 
      n∈M 
min cn. 
25:            else                                                                                                                                                          ⊳ |Mmin| = 1 and unit nmin connects with only unit nmax 
26:                  Mmax = {n | n is a neighbor of nmax excluding nmin}∪{nmax} 
27:                  if |Mmax| > 1 then 
28:                       wnmin  =    1 ____ 
|Mmax|∑ 
      n∈M 
max wn. 
29:                       cnmin  =    1 ____ 
|Mmax|∑  
      n∈M 
max cn. 
30:                  else                                                                                                                                                      ⊳ |Mmax| = 1 and unit nmax connects with only unit nmin 
31:                       f = arg min 
     n     ∥wn −wnmax∥ 
32:                       wnmin  = (wnmax + wf)/2. 
33:                       cnmin  = (cnmax + cf)/2. 
34:                  end if 
35:            end if 
36:       end if 
37:       cn ← cn − βcn,n=0,...,N − 1 
38:  end loop_____________________________________________________________________________________________________________________________________________________________________________________________________________________________    

Neural gas with RB updating

Neural gas with remove-birth updating (NGRB) is an alternative to Self-Organizing Map (SOM) for data streams based on neural gas (NG). NGRB quantizes the input data and generates a network like NG. In addition, NGRB can reconfigure its network structure more quickly through RB updating. The complete NGRB algorithm is given in Algorithm 3 .

The network generated by NGRB consists of N units, with edges connecting pairs of units. Each unit i has a reference vector w_i and a winning counter c_n. Edges between units are neither weighted nor directed. The edge is represented by C_nm, which is 0 or 1. If C_nm = 1, unit n is connected to unit m, and vice versa. In Algorithm 3 , C_nm = C_mn. Each edge has an age variable, denoted by a_nm, which informs the decision to keep or discard the edge. In NGRB, data points are represented iteratively, and the reference vectors are refined at each iteration.

In the initialization phase described in Algorithm 3 (steps 2-4), we initialize the reference vector w_n, the win count c_n, and C_nm. Specifically, each reference vector w_n is constructed according to the following equation: (8)${\displaystyle {\mathit{w}}_n=\left({\xi }_1,\dots ,{\xi }_d,\dots ,{\xi }_D\right),}$ where each component ξ_d is sampled uniformly at random from the interval [0, 1).c_n and C_nm is initialized to zero.

In each iteration, NGRB processes a single data point. After receiving x_t ( Algorithm 3 , step 6), NGRB refines its reference vectors and changes the network topology. The reference vector update procedure is identical to that of NG. We determine the neighborhood ranking k_n of unit n based on the distance between w_n and x_t ( Algorithm 3 , step 8). This results in a sequence of unit rankings (n₀, n₁, …, n_k, …, n_M−1) determined by (9)${\displaystyle \parallel \mathit{x}-{\mathit{w}}_{n_0}\parallel <\parallel \mathit{x}-{\mathit{w}}_{n_1}\parallel <...<\parallel \mathit{x}-{\mathit{w}}_{n_k}\parallel <...<\parallel \mathit{x}-{\mathit{w}}_{n_{N-1}}\parallel .}$ Then, the reference vectors of all units are updated according to (10)${\displaystyle {\mathit{w}}_n\leftarrow {\mathit{w}}_n+\varepsilon e^{-k_n/\lambda }\left({\mathit{x}}_t-{\mathit{w}}_n\right),n=1,\dots ,N,}$ where e^−k_n/λ is a neighborhood function ( Algorithm 3 , step 9). λ determines the number of units that significantly change their reference vectors at each iteration.

At the same time, the network topology evolves in response to the input data through iterative adaptation. The adaptation procedure of the network topology is also identical to that of NG. The winning unit n₀ and the second nearest unit n₁ are identified. If C_n0n1 = 0, we set C_n0n1 = 1 and a_n0n1 = 0 ( Algorithm 3 , steps 11–13). If C_n0n1 = 1, we set a_n0n1 = 0 ( Algorithm 3 , steps 14 and 15). The age of all edges connected to n₀ is incremented by 1 ( Algorithm 3 , step 17), and links exceeding the prescribed lifetime are removed ( Algorithm 3 , step 18).

In addition, NGRB dynamically restructures its network using RB updating, which involves removing infrequently winning units and introducing new units around those that win frequently. The win count of the winning unit, denoted by c_n0, is incremented at each iteration ( Algorithm 3 , step 20). The algorithm then identifies the unit with the maximum wins n_max, and the unit with the minimum wins n_min ( Algorithm 3 , steps 21 and 22). When c_nmin/c_nmax exceeds the threshold TH_RB, n_min is eliminated and a new unit n_new is added around n_max ( Algorithm 3 , steps 23–25). In Algorithm 3 , n_new = n_min. The reference vector and the win count of n_new are respectively determined by w_nnew = (w_nmax + w_f)/2 and c_nnew = (c_nmax + c_f)/2, where f is the neighboring unit of n_max that has the maximum wins ( Algorithm 3 , steps 26-33). If n_max has no neighbors, the closest unit to n_max is taken as unit f ( Algorithm 3 , step 30). Consequently, n_new is connected to n_max and f, setting C_nnewnmax = 1 and C_nnewnf = 1 ( Algorithm 3 , steps 34). The ages of these new edges, a_nminnmax and a_nminf, are set to 0 ( Algorithm 3 , step 35).

All winning counters are subject to exponential decay, calculated as follows (11)${\displaystyle c_n\leftarrow c_n-\beta c_n,}$ where β is the decay rate ( Algorithm 3 , step 37).

 
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________ 
Algorithm 3 Neural Gas with RB updating (NGRB)________________________________________________________________________________________________________________________________________________________________________________________________________ 
Require: X = {x1,...,xt,...}, N 
 1:  Initialize: 
 2:      wn ← (ξ1,...,ξd,...,ξD),n=1,...,N, where ξd = [0,1) is uniformed random value 
  3:      cn ← 0,n=1,...,N 
 4:      Cnm ← 0 for all n = 1 to N and m = 1 to N 
 5:  loop 
 6:       Receive input xt at iteration t 
 7:       {Adaptation of reference vectors:} 
 8:       Determine the neighborhood-ranking kn 
  9:       wn ← wn + ɛe−kn/λ(xn −wn),n=1,...,N 
10:       {Training the network topology:} 
11:       if Cn0n1  = 0 then 
12:            Cn0n1  = 1 
13:            an0n1  = 0 
14:       else 
15:            an0n1  = 0 
16:       end if 
17:       Increment all the ages of the edge emerging from the unit n1 
18:       Remove the edge with anm > amax 
19:       {RB updating:} 
20:       cn0  ← cn0 + 1 
21:       nmax = arg max 
     n     cn 
22:       nmin = arg min 
     n     cn 
23:       if cnmin/cnmax  < THRB then 
24:            Remove unit nmin 
25:            Create a new unit at nmin 
26:            M = {n | n is a neighbor of nmax} 
27:            if |M| > 0 then 
28:                  f = arg max 
   n∈M   cn 
29:            else 
30:                  f = arg min 
  n⁄=nmax  ∥wn −wnmax∥ 
31:            end if 
32:            wnmin  = (wnmax + wf)/2. 
33:            cnmin  = (cnmax + cf)/2. 
34:            Connect nmin with nmax and f 
35:            anminnmax  = anminf = 0 
36:       end if 
37:       cn ← cn − βcn,n=1,...,N 
38:  end loop_____________________________________________________________________________________________________________________________________________________________________________________________________________________________    

Parameters

In this study, online k-means, SOM, NG, and GNG are used as comparison methods. To investigate the efficiency of the win probability based metric on RB updating, OKRB, SOMRB, and NGRB using the error-based metric were evaluated. For details on RB updating using the error-based metric, see ‘RB updating using error-based metric’ in the Appendix. The parameters for all methods except N = 100 are determined using a grid search technique, details of which can be found in ‘Parameter optimization’ in the Appendix. The parameters for OKRB, OKRB using the error-based metric, and online k-means are shown in Table 1. The parameters for SOMRB, SOMRB using the error-based metric, and SOM are shown in Table 2. The parameters for NGRB, NGRB using the error-based metric, and NG are shown in Table 3. For GNG, the following parameters were used: ɛ_w = 0.1, ɛ_n = 0.0005, λ = 50, α = 0.25, β = 0.999, and a_max = 25.

Comparison methods

The proposed methods are compared with four other methods: online k-means, SOM, NG, and GNG. The algorithm of online k-means is referred to in the Appendix section labeled ‘Online k-means’. The detailed descriptions of SOM, NG, and GNG are covered in Fujita (2021). Notably, online k-means, SOM, and NG have parameters that decay over iterations, but in this study they were kept static in order to process data streams. For example, in the case of NG, the learning rate is kept constant so that ɛ = ɛ_i = ɛ_f, where ɛ_i and ɛ_f are the initial and final learning rates, respectively.

Initialization

The initialization for OKRB, SOMRB, and NGRB is described in the Algorithms 1 , 2 , and 3 , respectively. For all comparison methods except SOM, the elements of the reference vectors are initialized uniformly at random in the range [0, 1). For SOM, the reference vector is initialized as w_n = (⌊n/L⌋/L, (modL)/L, 0, …, 0), where $L=\lfloor \sqrt{N}\rfloor$. The units of SOM on the 2D feature map are placed at p_n = (p_n1, p_n2) = (⌊n/L⌋, modL). Such an initialization strategy strengthens the network topology of the SOM against map distortions. Traditionally, reference vectors are either randomly selected data points or derived using an efficient initialization algorithm such as k-means++ because random initialization often creates dead units. However, in the context of a data stream, data points are continuously fed into the system. Furthermore, their characteristics will change due to concept drift, requiring methods to adapt to the data regardless of the state of the reference vectors. Consequently, any method designed for a data stream must not only extract relevant features from the data, but also strive to minimize the generation of dead units, regardless of how the initial reference vectors are set.

Evaluation metrics

In this study, the performance of vector quantization algorithms is evaluated using two metrics: the mean squared error (MSE) and the number of dead units N_dead. The MSE quantifies the average squared distance between each data point and its nearest unit, expressed as follows (12)${\displaystyle \mathrm{MSE}=\frac{1}{M}\sum _{i=1}^M\sum _{n=1}^N{k}_{in}\parallel {\mathbf{x}}_i-{\mathbf{w}}_n{\parallel }^2,}$ where M is the number of data points. The data point x_i is assigned to the unit s if s = argmin_n ∥ x_i − w_n∥², and as a result k_is = 1. Otherwise k_in = 0. The unit n is considered a dead unit if $M_n={\sum }_{i=1}^M{k}_{in}=0$. So N_dead = |{n|M_n = 0}|.|⋅| is the number of elements in a set.

To evaluate the topological properties of the networks generated by SOMRB and NGRB, the average degree and the average clustering coefficient are used. The average degree $\bar{k}$ is the average number of edges per unit and can be expressed as (13)${\displaystyle \bar{k}=\frac{2L}{N},}$ where L is the total number of edges and N is the number of units. The average clustering coefficient C is defined as $C=\frac{1}{N}{\sum }_{n=0}^N{c}_n$, where c_n is the clustering coefficient of the unit n. The clustering coefficient c_n is calculated as $c_n=\frac{2t_n}{k_n\left(k_n-1\right)}$, where t_n is the number of triangles around the unit n and k_n is the number of edges formed by the unit n. If k_n < 2, then c_n = 0.

The RB updating frequency indicates the number of RB updating occurrences. It is a candidate metric for concept drift detection because RB updating is assumed to occur in response to dynamic changes in a data stream caused by concept drift.

Software

The implementation of OKRB, SOMRB, NGRB, online k-means, SOM, NG, and GNG was done in Python using several Python libraries including NumPy, NetworkX, and scikit-learn. NumPy facilitated linear algebra computations, while NetworkX aided in network manipulation and network coefficient computations. Scikit-learn was used to generate synthetic data. The source code used in this study is publicly available and can be found at https://github.com/KazuhisaFujita/RemoveBirthUpdating.

Datasets

In this study, six synthetic datasets and three real-world datasets are used to evaluate the proposed methods. The synthetic datasets include Blobs, Circles, Moons, Aggregation (Gionis, Mannila & Tsaparas, 2007), Compound, t7.8k (Karypis, Han & Kumar, 1999), and t8.8k (Karypis, Han & Kumar, 1999). Blobs, Circles, and Moons are generated using the make_blobs, make_circles, and datasets.make_moons functions from the scikit-learn library, respectively. Blobs are derived from three isotropic Gaussian distributions with default parameters for mean and standard deviation. Circles are composed of two concentric circles generated with noise and scale parameters set to 0.05 and 0.5, respectively. Moons are composed of two moon-shaped distributions generated with the noise parameter set to 0.05. Aggregation, Compound, t4.8k, and t7.10k serve as representative synthetic datasets commonly used to evaluate clustering methods. In addition to the synthetic datasets, three real-world datasets from the UCI Machine Learning Repository are used, including Iris, Wine, and Digits. Table 4 details the characteristics of each dataset, showing the number of data points (N), dimensions (D), standard deviation (STD), maximum values (MAX), and minimum values (MIN). Note that the STD, MAX, and MIN are not explicitly defined for Blobs, Circles, and Moons due to the random nature of data point generation.

Comparison of network structures from synthetic datasets

Figure 2 shows the distributions of the reference vectors of OKRB, SOMRB, NGRB, online k-means, SOM, NG, and GNG for synthetic datasets; Blobs, Circles, Aggregation, Compound, t4.8k, and t8.8k. The reference vectors are trained by each algorithm over 5 × 10⁴ iterations. An input is a data point randomly selected from the dataset at each iteration. In this experiment, the random generator uses the same seed. These visualizations provide insight into the structure of the reference vectors and the generated networks.

The figure shows that OKRB, SOMRB, NGRB, and GNG successfully extract the topologies of all datasets. While the SOM-generated network contains some dead units, most of its reference vectors accurately capture the topologies of the datasets. The SOM network topology is a two-dimensional lattice, which often leads to the creation of dead units between clusters. In contrast, online k-means and NG tend to generate dead units when the initial position of the units is significantly away from the dataset. While this dead unit problem could be mitigated by refining the initial value, such a solution is not feasible for data streams, given their unbounded nature and the potential for changing ranges of values in the dataset. This suggests that methods other than online k-means and NG may be more appropriate for dealing with data streams.

Evaluating method performances on static datasets

Figure 3 shows the evolution of the Mean Squared Error (MSE) over iterations for the static datasets: Blobs, Circles, Aggregation, Compound, t4.8k, t7.10k, Iris, Wine, and Digits. At each iteration, MSE is calculated between all data points in the dataset and the current reference vectors. All four methods (OKRB, SOMRB, NGRB, and GNG) can maintain low MSEs from the 10⁴ iterations. In particular, the MSEs of OKRB and NGRB decay rapidly. The performance of OKRB and NGRB is equal to that of GNG and better than other methods. The MSE of SOMRB is slightly larger than those of OKRB, NGRB, and GNG, but smaller than that of SOM. Despite the lack of parameter decay and possibility to generate dead units, SOM shows a respectable performance. On the other hand, both NG and Online k-means show bad performance, mainly due to the lack of optimal initial reference vector values and a step decay mechanism. However, for the Circle dataset, NG and Online k-means perform well because the initial values are within the data distribution (the range of values for Circle is from −1 to 1).

Figure 4 shows the evolution of dead units over iterations for the static datasets. At each iteration, the number of dead units is calculated between all data points in the dataset and the current reference vectors. OKRB and NGRB keep the number of dead units close to zero from the 10⁴ iterations. SOMRB’s rate of decrease in dead units is slower than OKRB and NGRB. Interestingly, despite the 2-dimensional lattice bias and the lack of parameter decay, SOM generates a relatively limited number of dead units. However, compared to methods that use RB updating, the number of dead units produced by SOM is higher. For the Blobs, Circles, Aggregation, t4.8k, t8.8k, and Digits datasets, the number of dead units generated by GNG is approximately zero across all iterations. Conversely, NG and Online k-means have a higher number of dead units and a slower rate of decay of the number of dead units.

These results suggest that the proposed methods, namely OKRB, SOMRB, and NGRB, show sufficient performance with static data. However, due to the constraints of the network topology, SOMRB and SOM show relatively inferior performance compared to OKRB and NGRB. Online k-means and NG, in the absence of parameter decay and efficient initialization algorithms, provide inferior results even with static data. It is suggested that online k-means and NG without decay parameters are also likely unsuitable for stream data.

Performance for data stream

In this subsection, the proposed methods with RB updating are evaluated for data streams. We consider three types of concept drifts: sudden, gradual, and recurring concept drifts, as shown in Fig. 5. The data stream consists of several different datasets. A concept drift event, which occurs every 100,000 iteration, causes a change from one dataset to another.

For sudden concept drift, the dataset responsible for generating the input undergoes an abrupt change. For gradual concept drift, the dataset generating the input gradually shifts from the old dataset to the new dataset. To elaborate, at each iteration, a dataset generating an input is probabilistically selected, and an input is uniformly and randomly chosen from the selected dataset. The selection probabilities of the old and the new datasets are represented by p_old = (T_driftstart + T_dur − t)/T_dur and p_new = 1 − p_old, where t is the number of iterations, T_dur is the duration of the drift, and T_driftstart is the start iteration of the drift. In this experiment we set T_dur = 10000 and the initial T_driftstart to 90,000. For the recurring concept drift, two datasets alternately generate the input, switching every 100,000 iteration.

The experiments in this subsection compute the Mean Squared Error (MSE), the number of dead units, the average degree, and the average clustering coefficient. At each iteration t, the MSE and the number of dead units are calculated using the data points collected from iteration steps t − 1000 to t and the current reference vectors. Additionally, the RB updating frequency at iteration t is defined as the number of RB updating occurrences from iteration steps t − 1000 to t.

Figures 6A, 6B, and 6C show the MSE evolution of OKRB, SOMRB, NGRB, SOM, and GNG for all types of concept drifts. OKRB, SOMRB, NGRB, and SOM quickly converge to low MSE values. However, the MSE of SOM is consistently higher than that of the proposed method with RB updating. Although GNG converges quickly to a low MSE value after the arrival of the first stream, it converges to a high MSE value after any concept drift. Figure 6C shows a rapid convergence of GNG’s MSE between steps 200,000 and 300,000. This rapid convergence is due to the fact that the third dataset active during this interval is identical to the first. Therefore, GNG maintains its reference vectors that adapt to data1 after the first concept drift. Examples of the reference vector distributions of OKRB, SOMRB, and NGRB during gradual concept drift can be found in ‘Evolution of the reference vectors’ of the Appendix.

Figures 6D, 6E, and 6F illustrate the progression of dead units for OKRB, SOMRB, NGRB, SOM, and GNG. In all scenarios, the dead units of OKRB and NGRB quickly converge to zero after the concept drift. SOMRB’s dead units decrease more slowly than OKRB and NGRB. SOM’s dead units decrease more slowly than the proposed methods, and its amount also converges higher than the proposed methods. For sudden concept drift and gradual concept drift, OKRB, SOMRB, NGRB, and SOM have few dead units between data5 (t4.8k) and data6 (t7.10k) because Data5 and Data6 are widely distributed with noise. GNG has more dead units than other methods after the first concept drift.

These observations suggest that OKRB, SOMRB, and NGRB deal with concept drift efficiently. Significantly, OKRB, SOMRB, and NGRB are not affected by changes in the value range of the data due to concept drift. This range independence is attributed not only to RB updating but also to a property of online k-means, SOM, and NG, namely the independence of the hyperparameters on the value range of the data. The learning rates of online k-means, SOM, and NG, as well as the parameters of the neighborhood functions of NG and SOM, do not need to be adjusted based on the value range of the data, despite changes in the characteristics of a dataset. For example, we typically do not change the learning rate whether the maximum value of the data is 100 or 1. In addition, the hyperparameters of the neighborhood functions of SOM and NG depend on the location of the units on the feature map and the neighborhood ranking, respectively.

Interestingly, SOM does not show poor performance with concept drift. In general, SOM can only learn static datasets because once a map learns and stabilizes, it loses its ability to reshape itself as new structures manifest in the input data (Smith & Alahakoon, 2009). The decay parameters provide this stability by giving the SOM the flexibility to adapt to a static dataset in the early stages of training while maintaining stable reference vectors. On the other hand, the static parameters derive the SOM’s flexibility for concept drift because the static parameters provide a continuous learning capability. In addition, when concept drift occurs, and the SOM’s reference vectors diverge significantly from the input vectors generated by a data stream with new characteristics, multiple reference vectors are simultaneously adapted to the input vectors through the neighborhood function. As a result, SOM without decay can quickly adapt to the new characteristics and maintain flexible learning even as data characteristics change.

Figures 7A, 7B, and 7C show the evolution of the average degree of SOMRB and NGRB. The average degree at each iteration is calculated from the network obtained at that time. For sudden and gradual concept drifts, the average degree of SOMRB shows a rapid change at each drift event, except for the transition from data5 to data6. It shows a continuous decay that does not stabilize within each period. The average degree of NGRB peaks at each drift event. However, it does not occur during the transition from data2 to data3 in the gradual concept drift. The average degree of NGRB shows a rapid decay and stabilizes within each drift period. Furthermore, its convergence value is different for each dataset.

Figures 7D, 7E, and 7F show the evolution of the average clustering coefficient of SOMRB and NGRB. The average clustering coefficient at each iteration is calculated from the network obtained at that time. Since the units of SOMRB are placed on vertices of the 2D grid, they cannot form triangular clusters, resulting in a clustering coefficient of zero. On the other hand, NGRB’s clustering coefficient shows a peak at each drift, except for the transition from data5 to data6 for the gradual concept drift. Similar to its degree, NGRB’s clustering coefficient decays rapidly and stabilizes within each drift period. Furthermore, these convergence values are different for each dataset.

While the value ranges for data5 (t4.8k) and data6 (t7.10k) are similar, and the MSEs for these data are also similar, there are differences in the convergence values of the average degree and the average clustering coefficient. These results suggest that these two metrics can effectively identify shifts in data stream characteristics (concept drift occurrences) when using SOMRB and NGRB.

Figure 8 shows the evolution of RB updating frequency in OKRB, SOMRB, and NGRB. A strong peak in update frequency is observed coinciding with the onset of each concept drift. However, the peaks for the gradual concept drift are lower than for the other drifts. In particular, the peak observed during the transition from data5 to data6 shows a significant reduction. Figures 8D, 8E and 8F show that the peak shapes for OKRB and NGRB are almost identical. Conversely, the peaks for SOMRB are lower in height and broader in width than those for OKRB and NGRB. In addition, the peaks for SOMRB are delayed from the onset of drift. These findings suggest the potential of RB update frequency as an effective indicator for detecting the occurrence of concept drift.

The proposed methods may also be useful for drift detection. As shown in Fig. 6, both the Mean Squared Error (MSE) and the number of dead units increase significantly with concept drift. Similarly, Fig. 7 shows significant changes in the average degree and clustering coefficient when concept drift occurs. Furthermore, these two measures show different values for each data characteristic. Figure 8 shows that the frequency of RB updates shows spike-like fluctuations in response to concept drift. Therefore, these measures could be effectively used to detect concept drift. Moreover, if we use these measures and the proposed methods multiply and simultaneously, we will be able to detect drift even more accurately.

Figures 9A, 9B, and 9C show the evolution of the MSEs for OKRB, SOMRB, and NGRB using the error-based metric. For details on RB updating using the error-based metric, see ‘RB updating using error-based metric’ in the Appendix. The MSEs of the methods using the error-based metric show rapid convergence. However, for gradual concept drift, the MSEs of OKRB and NGRB using the error-based metric are larger than those of OKRB and NGRB using the win probability based metric during the data4, data5, and data6 phases.

Figures 9D, 9E, and 9F show the evolution of the number of dead units of OKRB, SOMRB, and NGRB using the error-based metric. In all tested scenarios, the number of dead units fluctuates significantly. Furthermore, these methods show a larger number of dead units when using the error-based metric compared to the win probability based metric. Strikingly, NGRB shows an exceptionally high number of dead units for gradual concept drift.

These results suggest that the proposed methods using the win probability based metric demonstrate proficiency in dealing with concept drift. In addition, they significantly mitigate the occurrence of dead units.