Microsimulation of Space Time Trellis Code
Abstract — This letter explores the possibility of using microsimulation in space time trellis code. Performing a pairwise comparison between generator matrices is essential in the validation of optimality. This is often done with simulation, which can be a time consuming process altogether. Microsimulation considerably cuts down the computational cost of simulation by employing smaller data and iteration. The effort is feasible with the assistance of a machine learning model known as multilayer perceptron. When properly conducted, it can offer 93.86% accuracy and 98.25% reduction in temporal cost.
Index Terms — Microsimulation, STTC, Code Design, Machine Learning, Multilayer Perceptron I. I NTRODUCTION n Space Time Trellis Code (STTC), one of the most basic tasks in code design optimization is verifying the performance of a proposed code against those already established in the literature [1]. This is often done by simulating the codes in question, followed by a comparison of their error curve performance. Comparison can be done concurrently where the performance of the codes is competed against each other all at once. On the other hand, it is also possible to compare the codes, one pair at a time, until the best is found. The latter is called a pairwise comparison. In the case where a set of N optimal generator matrices {G .. G K .. G N } are found in the literature and the best one is known (G K ), it is hypothetically sufficient to do a pairwise comparison between G and G K to know whether the newly proposed code G is better than the rest. Given the necessity of the task, it is chosen as the context of the study. II. M ICROSIMULATION
Before delving into the process of microsimulation [2], it is beneficial to look back upon the common practice of simulation [3]. With regard to deciding whether a particular generator matrix G is better than G , the usual approach is to perform simulations for both [1]. Normally, the simulation is repeated a number of times (ie 1000 iterations) and the average performance is calculated, often in terms of the BER vs SNR curve. This is followed by a comparative analysis to decide the superior one between them (Figure 1). From the diagram, it is not difficult to hypothesize where the computationally expensive process lies. Evidently, the number of iterations contributes significantly to the overall duration. In light of this, the microsimulation in this study proposes an entirely different approach to the scenario (Figure 2). Instead of iterating the simulation for a substantial number of times, only a single iteration is attempted. At first glance, this might appear rather extreme. Manuscript received April XX, 20XX; revised July XX, 20XX. .
However, this study borrows a concept known as representative sample [4] from statistics. It basically posits the existence of a few samples that can approximate the behavior of a large group of samples. The idea of representative sample is not entirely a foreign idea in simulation. To cite an example, for the prediction of irreducible error floor in STTC [5], elementary input bits are used as the representative sample instead of the commonly employed random input bits in simulation.
Fig. 1. Competition between two generator matrices via simulation
Fig. 2. Competition between two generator matrices via microsimulation
Consider a simulation with the system model y = hx + n composed of the transmitted signal x , received signal y , channel matrix h and noise n . In this particular setting, it is possible to elect a single channel h r as the representative Microsimulation of Space Time Trellis Code
U. A. N. Ungku Chulan,
M.T. Islam , N. Misran I Competition
Winning G Simulation(G ) (1 iteration) G Simulation(G ) (1 iteration) G Majority vote Optimal G Comparative Analysis Optimal G Simulation(G ) (1000 iteration) G Simulation(G ) (1000 iteration) G sample among a collection of randomly generated channel matrix. The prediction of the representative channel matrix h r can be done with a machine learning model known as the multilayer perceptron (MLP) [6]. MLP relies on supervised learning. Therefore, the right input-output pair must be provided. Data preparation [7] for the training portion of machine learning involves a number of stages. To begin, two datasets that correspond to two optimal generator matrices from the literature [8, 9] : [0 0 2 1; 2 1 0 0] and [2 0 1 3 ; 2 2 0 1] are taken to generate the training data. Each optimal generator matrix is paired with 100 random generator matrices. Initially, a competition is performed via simulation to figure out the base of comparison of which the actual winner is established. Afterwards, the competition is done via microsimulation. Here, the competition between an optimal generator matrix with a random generator matrix is done three times where the generator matrix with most wins is selected as the winner via the majority vote algorithm [10]. Microsimulation competition is repeated 100 times with different channel matrix h [11]. Given that 100 competitions are held and each competition is repeated 100 times, a total of 10,000 data (100 x 100) is generated for each dataset, giving a sum of 20,000 data for both datasets. Apart from that, it must also be pointed out that the transmission data for microsimulation is not similar to simulation. Simulation normally requires 260 bits of random data as per the IS-136 standard [12]. Microsimulation on the other hand, uses the same data for transmission. This data is derived by concatenating all the possible variations of elementary input bits [5] for a particular modulation M. Thus, when M = 4, the transmission data would be u = [0 0 0 0 0 1 1 0 1 1 0 0] including the preceding and succeeding zeros. Concerning feature extraction [13], the information gathered at the data preparation stage of the microsimulation is enumerated in the table below (Table 1). The result of classification is determined by comparing the verdict of microsimulation against simulation. If they are agreeable, such that both microsimulation and simulation choose the same winner, then the classification result is set to 1. However, if the microsimulation yields a different verdict from simulation, then the result is set to 0. TABLE
I F
EATURE EXTRACTION F EATURE
CODE D ESCRIPTION
1 G G ENERATOR MATRIX G ENERATOR MATRIX
I 3 H C
HANNEL MATRIX
4 N A VERAGE NOISE (G ) 5 N A VERAGE NOISE (G ) 6 B A VERAGE BER (G ) 7 B A VERAGE BER (G1) 8 Z A VERAGE SNR WHERE BER REACHES ZERO (G1) 9 Z A VERAGE SNR WHERE BER REACHES ZERO (G2) 10 R R
ESULT OF CLASSIFICATION
The competition is based on three factors: average SNR where BER reaches zero [14], average BER [15] and minimum BER [16]. A series of competition is facilitated by using one factor after another. First, a comparison is held in terms of the SNR of which the BER reaches zero. The generator matrix that reaches zero earliest is the winner. Thus, select_G_with_min_value() denotes a function that returns the generator matrix with the least value. If the BER does not reach zero within the stipulated range of the SNR, then the value of ber_zero(G) = ∞. Now, if there is a tie, then a second comparison is executed in terms of the average BER. The generator matrix where the average BER is minimal would be the winner. Again, if there is tie, then a third comparison is made from the aspect of minimum BER. The generator matrix with the lowest minimum BER is the winner. Should there be a tie after the third comparison, the winner is chosen randomly. function microsimulation_compete(G , G , h) winner = {} iteration = 1 ber(G ) = simulation(G , h, iteration) ber(G ) = simulation(G , h, iteration) ber_zero(G ) = get_snr_where_ber_reaches_zero(ber(G )) ber_zero(G ) = get_snr_where_ber_reaches_zero(ber(G )) ber_ave(G ) = get_average(ber(G )) ber_ave(G ) = get_average(ber(G )) ber_min(G ) = get_mininum(ber(G )) ber_min(G ) = get_minimum(ber(G )) if ber_zero (G ) != ber_zero(G ) then winner = select_G_of_min_value(ber_zero(G1), ber_zero(G )) else if ber_ave(G ) != ber_ave(G ) winner = select_G_of_min_value(ber_ave(G ), ber_ave(G )) else if ber_min(G ) != ber_min(G ) winner = select_G_of_min_value(ber_min(G ), ber_min(G )) else winner = random(G , G ) endif endif endif return winner endfunction Fig. 1. Competition algorithm function microsimulation_compete_and_vote(G , G , h) for k=1 to 3 G(k) = microsimulation_compete(G , G , h) endfor G = mod(G(1) .. G(3)) return G endfunction Fig. 2. Majority vote algorithm function microsimulation_data(G , {G , .. , G N }) data = {} for k=1 to N for i = 1 to 100 h i = generate_channel_matrix() G_sim = simulation(G , G k ) G_mic = microsimulation_compete_and_vote(G , G k , h i ) if G_mic == G_sim then result = 1 else result = 0 endif D k = feature_extraction(G_mic) D k (R) = result data = data ∪ D k endfor endfor return data endfunction Fig. 3. Data preparation for training The process of preparing the microsimulation data is given in Figure 3. G signifies the optimal generator matrix that is chosen from the literature. {G .. G N } are the random and unique generator matrices. G will compete with {G , … , G N } where each competition (G vs G k ) is held 100 times with a randomly generated channel matrix h . The winner of microsimulation and simulation is G_mic and G_sim respectively. If the winners are congruent G_mic==G_sim then result R = 1. The extracted features D K from a particular competition is updated with R and integrated with the overall data. As for the architecture [17] of the multilayer perceptron (MLP), the model contains one input layer, three hidden layers where the number of nodes for each layer is (10, 6, 5), and one output layer. There is no definite way of deciding the total number of hidden layers as well as the number of nodes within them [18]. As such, the network is empirically constructed. For training, a 70 – 30 train-test split is imposed on the data. Optimization is achieved with the LBFGS algorithm and the maximum iteration is confined to 1000 to ensure proper convergence. In order to speed up the convergence process, the network relies on the ReLU activation function [19]. Result from the testing stage of MLP indicates that the prediction can achieve 0.8982 accuracy. After the training is completed, microsimulation can be performed (Figure 4) on the competing generator matrix G and G . To do so, a random channel matrix h is generated. This is followed by a microsimulation competition between the two generator matrices. The features D are then relayed to the function predict( D ) to predict as to whether the winner of the competition G_mic should be accepted or not. If result == 1 then the winner is returned. Else, another random channel matrix h is generated and the process repeats itself. Obviously, this is a form of lazy search as the effort is halted once the first solution is found. Additionally, the search is limited by the number of trials T. In this case, T = 100 ie microsimulation would only make 100 attempts to determine the winner. function microsimulation(G , G ) G = {} T = 100 for k = 1 to T h = generate_random_channel_matrix( ) G_mic = microsimulation_compete_and_vote(G , G , h) D = feature_extraction(G_mic) result = predict(D) if result == 1 G = G_mic break endif endfor return G endfunction Fig. 4. Microsimulation algorithm III. E XPERIMENTATION
The experimentation parameters are given in Table I. MATLAB is used to develop the STTC portion of the code while Python and scikit-learn [20] are leveraged to develop the machine learning part. The study follows the conventional system model of y = hx + n , which involve the transmitted signal x , received signal y , channel matrix h and noise n . To observe the extent of generalizability, the research employs completely different dataset of generator matrices for training and experimentation. Seven optimal generator matrices are gathered from the literature for the experimentation (Table II). Each optimal generator matrix is competed against 100 random and unique generator matrices. Competition is first performed with simulation and then with microsimulation. The former provides a benchmark for the latter. Furthermore, two forms of microsimulation are carried out: microsimulation and microsimulation+MLP to ascertain the impact of integrating MLP into the approach. TABLE
I E
XPERIMENTATION P ARAMETERS
Aspect Parameter Value
Machine Processor Core2Duo E8400 @ 3.00 GHz RAM 8Gb Software MATLAB Python Scikit-learn version R2015a (8.5.0) version 2.7.15 version 0.20.4 System Model Transmitter Receiver 2 1 SNR Range [0, 24] Channel Equation Slow & Flat Rayleigh y = hx + n Modulation QPSK 4 STTC Total State 4 Generator Matrix 4x2 Data Input bits Total Sample Sample / Case Total case Each case 260 bits (130 symbols) 707 generator matrix G 101 generator matrix G 7 cases (7 x 101 G) (1 optimal G ) vs (100 random G) TABLE
II D
ATASET FOR E XPERIMENTATION C ASE
NAME G ENERATOR MATRIX T
1 B
ANARJEE [1] [ ; ] 2 I LHAN [21] [ ; ] 3 C HEN [22] [ 0 2 1 0 ; 2 2 0 1 ] 4 I
NOUE [23] [ 2 3 2 0 ; 0 2 1 2 ] 5 B
LUM [24] [ 2 0 1 2 ; 2 2 2 1 ] 6 L
IAO [25] [ 0 0 1 2 ; 2 1 0 0 ] 7 H
ONG [26] [ 0 2 2 3 ; 2 2 1 2 ]
Regarding the visible impact of random vs representative channel matrix, illustrations of the results can be seen in Figure 5 and Figure 6 where the optimal generator matrix G = [0 2 2 3; 2 2 1 2] from Hong [26] competes with a random generator matrix G = [2 2 0 1; 0 0 2 2]. Clearly, when a random channel matrix is used (Figure 5), it is quite difficult to discern the error curve performance between them. Contrast this with the second case (Figure 6). Although only a single iteration is instigated, the difference between the error curves of G and G is rather apparent. Without a doubt, microsimulation lacks the accuracy of simulation when it comes to detailing the error curve. Still, it manages to distinguish the overall BER-vs-SNR performance between the generator matrices in question. Fig. 5. Microsimulation (single iteration) with random channel matrix
Fig. 6. Microsimulation+MLP (single iteration) with representative channel matrix
The mean accuracy of microsimulation and microsimulation+MLP is 0.5914 and 0.9386 respectively (Table III). This implies that MLP affords an improvement of 62.11% for accuracy. Upon a closer examination, it is also discovered that the accuracy of microsimulation+MLP is more stable than its counterpart. Its standard deviation (s) and variance (s ) are both significantly lower than microsimulation. TABLE
III A
CCURACY OF M ICROSIMULATION C ASE M ICROSIMULATION M ICROSIMULATION +MLP I
MPROVEMENT (%) 1 0.5800 0.9500 63.79 2 0.6500 0.9900 52.30 3 0.4900 0.9600 95.91 4 0.6600 0.9500 43.94 5 0.5200 0.8800 69.23 6 0.7400 0.9000 21.62 7 0.5000 0.9400 88.00 M
EAN S - S - From the aspect of performance (Table IV), microsimulation+MLP allow a reduction of temporal cost from 82.0672s to 1.4382s when compared with simulation. This denotes an improvement of 98.25%. Unfortunately, the performance of microsimulation+MLP is unstable as compared to simulation. Exhibiting a high standard deviation (s) at 0.9137, it requires at least 0.3259 seconds and at most 2.5734 seconds to perform microsimulation+MLP. This includes the time to search for the representative channel matrix. It is reasoned that the duration instability is caused by the random nature of the search.
TABLE
IV P
ERFORMANCE OF M ICROSIMULATION C ASE S IMULATION ( SECOND ) M
ICROSIMULATION +MLP ( SECOND ) I
MPROVEMENT (%) 1 81.3207 0.4845 99.40 2 83.0385 1.8879 97.73 3 81.7811 2.5734 96.85 4 81.9344 1.8822 97.70 5 82.1167 0.6907 99.16 6 82.2535 0.3259 99.60 7 82.0258 2.2226 97.29 M
EAN S - S - IV. C ONCLUSION
Microsimulation is a viable alternative in conducting a pairwise comparison between competing generator matrices in space time trellis code. It helps to accelerate the process. It can reduce the cost of simulation significantly and still achieve a reasonably acceptable level of accuracy. This is feasible with the usage of a representative channel found with multilayer perceptron (MLP). R
EFERENCES [1]
S. Banerjee and M. Agrawal, “A Simple Analytical Design Approach to Space Time Trellis Codes,” Wireless Personal Communication, vol. 75, no. 2, pp. 1141–1154, 2014 [2]
V. Mladenovic, D. Milosevic, M. Lutovac, Y. Cen, M. Debevc, “An Operation Reduction Using Fast Computation of an Iteration-Based Simulation Method with Microsimulation-Semi-Symbolic Analysis,” Entropy 2018, 20, 62. [3]
A. Kudeshia, M. A. Zaidi, A. K. Jagannatham and C. Prakash, “Hierarchical Trellis Based Decoder for Total Variation Sequence Detection (TVSD) in Space-Time Trellis Coded (STTC) Wireless Image/Video Communication," in IEEE Access, vol. 8, pp. 79383-79396, 2020, [4]
Y. An, L. Yang, A. X. Zhu, C. Qin and J. J. Shi, "Identification of representative samples from existing samples for digital soil mapping," Geoderma, Volume 311, 2018. [5]
U. A. Ungku Chulan, M. Abdullah and N. F. Abdullah, “Towards the Prediction of Irreducible Error Floor in Space Time Trellis Code,” IEEE Communications Letters, Vol. 21, No. 4, January 2017. [6]
S. Peñafiel, N. Baloian, H. Sanson and J. A. Pino, "Predicting Stroke Risk With an Interpretable Classifier," in IEEE Access, vol. 9, pp. 1154-1166, 2021. [7]
P. Yang, J. Wang, H. Zhao and R. Li, "MLP With Riemannian Covariance for Motor Imagery Based EEG Analysis," in IEEE Access, vol. 8, pp. 139974-139982, 2020 [8]
V. Tarokh, N. Seshadri and A. Calderbank, “Space-time codes for high data rate wireless communication: Performance criterion and code construction,” IEEE Transactions on Information Theory, vol. 44, no. 2, pp. 744–765, 1998. [9]
S. Bäro, G. Bauch, and A. Hansmann, “Improved codes for space-time trellis-coded modulation,” IEEE Communication Letters, vol. 4, no. 1, pp. 20–22, 2000. [10]
T. B. Chandra, K. Verna, B. K. Singh, D. Jain and S. S. Netam, "Coronavirus disease (COVID-19) detection in Chest X-Ray images using majority voting based classifier ensemble," Expert Systems with Applications, Vol. 165, March 2021. [11]
K. K. Sarma and A. Mitra, "Multiple-input-multiple-output channel modelling using multi-layer perceptron with finite impulse response and infinite impulse response synapses," IET Communications, 7, 1540-1549, 2013. [12]
A. F. Naguib, V. Tarokh , N. Seshadri and A. R. Calderbank, "A space-time coding modem for high-data-rate wireless communications," IEEE Journal on Selected Areas in Communications, vol. 16, no. 8, October 1998. [13]
P. Yang, J. Wang, H. Zhao and R. Li, "MLP With Riemannian Covariance for Motor Imagery Based EEG Analysis," in IEEE Access, vol. 8, pp. 139974-139982, 2020. [14]
A. Siddiqua, A. Ansari, A. M. Fundóle and R. Jamadar, "8-Channel wavelength division multiplexing (WDM) with zero BER," 2016 IEEE International Conference on Recent Trends in Electronics, Information & Communication Technology (RTEICT), Bangalore, 2016, pp. 2117-2120. [15]
A. Goswami and A. Kumar, "An Inequality on Source-to-Sink Average BER and Its Application on Wireless Sensor Networks," in IEEE Communications Letters, vol. 21, no. 9, pp. 2077-2080, Sept. 2017. [16]
Z. Luo, Y. Chen, C. Li, X. Xiong and L. Zhu, "Minimum BER Criterion and Adaptive Moment Estimation Based Enhanced ICA for Wireless Communications," in IEEE Access, vol. 8, pp. 152071-152080, 2020. [17]
H. J. Chiu, T. -H. S. Li and P. -H. Kuo, "Breast Cancer–Detection System Using PCA, Multilayer Perceptron, Transfer Learning, and Support Vector Machine," in IEEE Access, vol. 8, pp. 204309-204324, 2020. [18]
D. Stathakis, "How many hidden layers and nodes?," International Journal of Remote Sensing, Vol. 30, No. 8, 20 April 2009, 2133–2147. [19]
G. Wang, G. B. Giannakis and J. Chen, "Learning ReLU Networks on Linearly Separable Data: Algorithm, Optimality, and Generalization," in IEEE Transactions on Signal Processing, vol. 67, no. 9, pp. 2357-2370, 1 May1, 2019. [20]
D. Utyamishev and I. Partin-Vaisband, "Real-Time Detection of Power Analysis Attacks by Machine Learning of Power Supply Variations On-Chip," in IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 39, no. 1, pp. 45-55, Jan. 2020. [21]
H. Ilhan, I. Altunbaş, and M. Uysal, “Novel distributed space-time trellis codes for relay systems over cascaded Rayleigh fading,” IEEE Commun. Lett., vol. 14, no. 12, pp. 1140–1142, 2010. [22]
Z. Chen, B. Vucetic, J. Yuan and K. L. Lo,” Space-time trellis codes with two, three and four transmit antennas in quasi-static flat fading channels,”
In IEEE international conference on communications in New York USA, 2002 (ICC 2002) ,vol. 3, pp. 1589–1595, 2002 [23]
A. Inoue & T. Ohtsuki, “Performance factors for space-time trellis codes in block fading channels”,In 15th IEEE international symposium on personal, indoor and mobile radio communications, PIMRC 2004 ,Vol. 4, pp. 2616–2620, 2004. [24]
Q. Yan and R. S. Blum,” Optimum space-time convolutional codes,” In IEEE wireless communications and networking conference, WCNC, vol. 3, pp. 1351–1355, 2000. [25]
C. Liao and V. K. Prabhu, “Improved code design criteria for space-time trellis codes over quasi-static flat fading channels,” IEEE Work. Signal Process. Adv. Wirel. Commun. SPAWC, vol. 2005, no. 1, pp. 7–11, 2005. [26]