## 4 Results
### Assessment-Test Generation (TG)
#### 4.3.2 TG Using Genetic Structures  
Related to test generation using genetic structures, we have determined two simulations related to a specific topic and run several trials for the model presented in previous sections. The first implementation was made in a laboratory-simulated experiment with randomly generated items and characteristics. The technical setup involved using a genetic algorithm to select and optimize a set of questions, with the goal of achieving an average difficulty of 0.4 and ensuring coverage of the desired keywords: [\"python\", \"algorithm\", \"data\", \"machine\", \"learning\"]. The algorithm operated with a population of 10 chromosomes (question sets), evolving for 50 generations, with a mutation rate of 0.1, to maximize fitness in relation to keyword difficulty and coverage. The evolution of the fitness values for the example is shown in Figure 8.  
The genetic algorithm achieved a running time of 0.19 s and a final fitness of 0.7054, improving the previous result (0.6961). The best chromosome was [74; 101; 465; 704; 662; 368; 582; 45; 117; 271], with an average difficulty of 0.4170. The statistics related to the best chromosome are shown in Table 7.  
The second implementation (Figure 9) was made as a web application using PHP scripting language for the backend, MySQL for the database component and the Laravel framework for the application model implementation, which uses an MVC architecture in order to take into account the scalability. Also, the set was closer to a real one. \begin{table}
\begin{tabular}{l c c c} \hline \hline
**ID** & **Keywords** & **Difficulty** & **Type** \\ \hline
75 & algorithm, python & 0.96 & m \\
102 & python, data & 0.34 & m \\
466 & data, python & 0.21 & e \\
705 & python, data & 0.43 & m \\
663 & data, algorithm & 0.44 & m \\
369 & python, algorithm & 0.68 & m \\
583 & python, data & 0.31 & m \\
46 & algorithm & 0.43 & s \\
118 & data, algorithm & 0.09 & s \\
272 & python, algorithm & 0.28 & s \\ \hline \hline \end{tabular}
\end{table} 
Table 7: The questions associated with the best chromosome. In order to assess the efficiency of the genetic algorithm, several runs of the implementation were made. The purpose of the result analysis was the direct observation of the fitness compared to an initial random generated test. Additionally, the genetic population was measured using a specific metric: the population variation, showing how the population varies after the genetic operators are applied and the performance of the genetic algorithm. The initial data used for the runs were the following:  
* the number of items in the database (N) was 800;
* the number of desired items in the sequence (m) was 10;
* three keywords were chosen (uKW = 3);
* a degree of difficulty of 0.4 was chosen (uD = 0.4);
* the desired type of question was chosen as multiple-choice (\(uT={}^{\prime}m^{\prime}\));
* the mutation rate was established at 0.1 (rm = 0.1);
* the crossover rate was established at 0.5 (rc = 0.5);
* the population size was established at 50 (NP = 50);
* the number of generations was established at 100 (NG = 100);
* the fitness function is the sigmoid average. Figure 8: The evolution of fitness value throughout the generations for the given example. Figure 9: Aspects of the GUI interface of the genetic-based method implementation: (**a**) test generation history (**b**) input data form. The obtained data after the implementation are presented in Table 8.  
Regarding the efficiency of the algorithm, one of the quantitative indicators is the run time related to the parameters of the genetic algorithm. The parameters that were considered to influence the run time were N (the number of questions), K (the number of questions within a test) and NG (the number of generations of genetic algorithms). The tests were conducted in a Java-based implementation on a system with the following parameters: a Windows 8 operating system, an i3-3217U 1.80 GHz microprocessor and 4 GB RAM.