Encoder improvement using staticCheckIfImpactPhenotype()

Author: MohsenTaheriShalmani

core-it/src/test/kotlin/org/evomaster/core/problem/rest/aiclassification/AIModelsCheck.kt

@@ -50,15 +50,15 @@ class AIModelsCheck : IntegrationTestRestBase() {
 //            initClass(MultiTypeController())
 
 
-//             initClass(AllOrNoneController())
+             initClass(AllOrNoneController())
 //            initClass(ArithmeticController())
 //             initClass(BasicController())
 //            initClass(ImplyController())
 //             initClass(MixedController())
 //             initClass(OnlyOneController())
 //             initClass(OrController())
 //             initClass(RequiredController())
-             initClass(ZeroOrOneController())
+//             initClass(ZeroOrOneController())
         }
 
         @JvmStatic
@@ -75,7 +75,7 @@ class AIModelsCheck : IntegrationTestRestBase() {
         }
     }
 
-    val modelName = "KNN" // Choose "GAUSSIAN", "KNN", "GLM", "KDE", "NN", etc.
+    val modelName = "KNN" // Choose "GAUSSIAN", "GLM", "KDE", "KNN", "NN", etc.
     val runIterations = 5000
     val encoderType4Test = EMConfig.EncoderType.RAW
 
@@ -258,9 +258,13 @@ class AIModelsCheck : IntegrationTestRestBase() {
             val encoderTemp = InputEncoderUtilWrapper(action, encoderType = config.aiEncoderType)
 
             //print gene types
-            println("Expanded genes are: " +
-                    encoderTemp.endPointToGeneList()
-                        .joinToString(", ") { it.getLeafGene()::class.simpleName ?: "Unknown" })
+            println(
+                "Expanded genes are: " +
+                        encoderTemp.endPointToGeneList()
+                            .joinToString(", ") { ng ->
+                                "${ng.gene.name}:${ng.gene::class.simpleName ?: "Unknown"}"
+                            }
+            )
 
             val hasUnsupportedGene = !encoderTemp.areAllGenesSupported()
             if (hasUnsupportedGene) {

core-it/src/test/kotlin/org/evomaster/core/problem/rest/aiclassification/AIMoldelsCheckWFD.kt

@@ -25,7 +25,9 @@ import org.evomaster.core.problem.rest.data.Endpoint
 import org.evomaster.core.problem.rest.schema.OpenApiAccess
 import org.evomaster.core.problem.rest.service.sampler.AbstractRestSampler
 import org.evomaster.core.search.action.Action
+import org.evomaster.core.search.gene.ObjectGene
 import org.evomaster.core.search.service.Randomness
+import org.jetbrains.kotlin.fir.builder.escapedStringToCharacter
 import java.net.HttpURLConnection
 import java.net.URL
 import javax.ws.rs.core.MediaType
@@ -49,17 +51,18 @@ class AIModelsCheckWFD : IntegrationTestRestBase() {
         }
     }
 
-    val modelName = "KNN" // Choose "GAUSSIAN", "KNN", "GLM", "KDE", "NN", etc.
-    val runIterations = 5000
+    val modelName = "KNN" // Choose "GAUSSIAN", "GLM", "KDE", "KNN", "NN", etc.
+    val runIterations = 200
     val encoderType4Test = EMConfig.EncoderType.RAW
     val saveReport: Boolean = false
 
     val decisionMaking = "sendAnyway" // choose "probabilistic" to make the machine decide weather to send the request or not
 
     val baseUrlOfSut = "http://localhost:8080"
-    val v2orV3 = "v2"
 
-    val swaggerUrl = "$baseUrlOfSut/$v2orV3/api-docs"
+//    val v2orV3 = "v2"
+//    val swaggerUrl = "$baseUrlOfSut/$v2orV3/api-docs"
+    val swaggerUrl = "http://localhost:8080/api/v3/openapi.json"
 
 
     @Inject
@@ -209,8 +212,7 @@ class AIModelsCheckWFD : IntegrationTestRestBase() {
     }
 
     fun runClassifierExample() {
-        val schema = OpenApiAccess.getOpenAPIFromLocation("$baseUrlOfSut/v2/api-docs")
-//        val schema = OpenApiAccess.getOpenAPIFromLocation("$baseUrlOfSut/v3/api-docs")
+        val schema = OpenApiAccess.getOpenAPIFromLocation(swaggerUrl)
         val restSchema = RestSchema(schema)
 
         val options = RestActionBuilderV3.Options(config)
@@ -242,9 +244,12 @@ class AIModelsCheckWFD : IntegrationTestRestBase() {
             println("*************************************************")
             println("Path: $endPoint")
 
+            println(sampledAction.parameters.joinToString(", ") {
+                    "${it.name}=${it.primaryGene().getValueAsRawString()}" })
+
             val geneValues = sampledAction.parameters
                 .map { it.primaryGene().getValueAsRawString().replace("EVOMASTER", "") }
-            println("Input Genes: ${geneValues.joinToString(", ")}")
+            println("Input Gene: ${geneValues.joinToString(", ")}")
             println("Genes Size: ${geneValues.size}")
 
             val individual =
@@ -253,14 +258,24 @@ class AIModelsCheckWFD : IntegrationTestRestBase() {
 
             val encoderTemp = InputEncoderUtilWrapper(action, encoderType = config.aiEncoderType)
 
-            //print gene types
-            println("Expanded genes are: " +
-                    encoderTemp.endPointToGeneList()
-                        .joinToString(", ") { it.getLeafGene()::class.simpleName ?: "Unknown" })
-
-            val geneList = encoderTemp.endPointToGeneList()
-            val typesRow = geneList.joinToString(", ") { gene -> gene.javaClass.simpleName }
-            println("Genes type in the gene list: $typesRow")
+            println(
+                "Expanded genes are: " +
+                        encoderTemp.endPointToGeneList()
+                            .joinToString(", ") { ng ->
+                                "[Name:${ng.gene.name}, Value:${ng.gene.getValueAsRawString()}, Class:${ng.gene::class.simpleName ?: "Unknown"}]"
+                            }
+            )
+
+//            println(
+//                "Expanded genes are: " +
+//                        encoderTemp.endPointToGeneList()
+//                            .onEach { ng ->
+//                                println("Is ${ng.gene.name} an ObjectGene? ${ng.gene is ObjectGene}")
+//                            }
+//                            .joinToString(", ") { ng ->
+//                                "${ng.gene.name}:${ng.gene.getLeafGene()::class.simpleName ?: "Unknown"}"
+//                            }
+//            )
 
             val hasUnsupportedGene = !encoderTemp.areAllGenesSupported()
             if (hasUnsupportedGene) {

core/src/main/kotlin/org/evomaster/core/problem/rest/classifier/deterministic/Deterministic400EndpointModel.kt

@@ -22,7 +22,7 @@ class Deterministic400EndpointModel(
 
     private val constraints: MutableList<ConstraintFor400> = mutableListOf()
 
-    private val modelMetrics: ModelMetrics = ModelMetricsWithTimeWindow(20)
+    private val modelMetrics: ModelMetrics = ModelMetricsWithTimeWindow(100)
 
     override fun updateModel(
         input: RestCallAction,

core/src/main/kotlin/org/evomaster/core/problem/rest/classifier/probabilistic/AbstractProbabilistic400Classifier.kt

@@ -45,7 +45,7 @@ abstract class AbstractProbabilistic400Classifier<T : AIModel>(
                 return@getOrPut null
             }
 
-            val listGenes = encoder.endPointToGeneList().map { it.getLeafGene() }
+            val listGenes = encoder.endPointToGeneList().map { it.gene.getLeafGene() }
             createEndpointModel(endpoint, warmup, listGenes.size, encoderType, randomness)
         }
 

core/src/main/kotlin/org/evomaster/core/problem/rest/classifier/probabilistic/AbstractProbabilistic400EndpointModel.kt

@@ -29,7 +29,7 @@ abstract class AbstractProbabilistic400EndpointModel(
     protected var initialized: Boolean = false
 
     val modelMetricsFullHistory: ModelMetricsFullHistory = ModelMetricsFullHistory()
-    val modelMetricsWithTimeWindow: ModelMetrics = ModelMetricsWithTimeWindow(1000)
+    val modelMetricsWithTimeWindow: ModelMetrics = ModelMetricsWithTimeWindow(100)
 
     /** Ensure endpoint matches this model */
     protected fun verifyEndpoint(inputEndpoint: Endpoint) {

core/src/main/kotlin/org/evomaster/core/problem/rest/classifier/probabilistic/InputEncoderUtilWrapper.kt

@@ -47,28 +47,36 @@ class InputEncoderUtilWrapper(
         ArrayGene::class
     )
 
+    data class ParamAndGene(
+        val paramName: String,
+        val gene: Gene
+    )
+
     fun isSupported(g: Gene): Boolean =
         supportedGeneTypes.any { it.isInstance(g) }
 
-    fun areAllGenesSupported(): Boolean {
-        val leafs = endPointToGeneList().map { gene -> gene.getLeafGene() }
-        return leafs.all { isSupported(it) }
-    }
+    fun areAllGenesSupported(): Boolean =
+        endPointToGeneList().all { isSupported(it.gene.getLeafGene()) }
+
+    private fun expandGene(g: Gene): List<Gene> {
+
+        val gene = g.getLeafGene()
 
-    fun expandGene(g: Gene): List<Gene> = when (g) {
-        is ObjectGene -> {
+        if (gene is ObjectGene) {
             val expanded = mutableListOf<Gene>()
-            g.fixedFields.forEach { expanded.addAll(expandGene(it)) }
-            g.additionalFields?.forEach { pair ->
+            gene.fixedFields.forEach { expanded.addAll(expandGene(it)) }
+            gene.additionalFields?.forEach { pair ->
                 expanded.addAll(expandGene(pair.second))
             }
-            expanded
+            return expanded
         }
-        else -> listOf(g)
+
+        return listOf(gene)
     }
 
-    fun endPointToGeneList(): List<Gene> {
-        val listGenes = mutableListOf<Gene>()
+    fun endPointToGeneList(): List<ParamAndGene> {
+        val paramAndGenes = mutableListOf<ParamAndGene>()
+
         action.parameters
             .filter { p ->
                 val name = p.name
@@ -77,9 +85,13 @@ class InputEncoderUtilWrapper(
             }
             .forEach { p ->
                 val g = p.primaryGene()
-                listGenes.addAll(expandGene(g))
+                val expanded = expandGene(g)
+                expanded.forEach { subGene ->
+                    paramAndGenes.add(ParamAndGene(subGene.name, subGene))
+                }
             }
-        return listGenes
+
+        return paramAndGenes
     }
 
 
@@ -102,12 +114,12 @@ class InputEncoderUtilWrapper(
      */
     fun encode(): List<Double> {
         val sentinel = -1e6 // for null handling
-        val listGenes = endPointToGeneList()
+        val listGenes = endPointToGeneList().map { it.gene }
         val rawEncodedFeatures = mutableListOf<Double>()
 
         for (g in listGenes) {
 
-            if(g.getValueAsPrintableString()==""){
+            if(!g.staticCheckIfImpactPhenotype() || g.getValueAsPrintableString()==""){
                 rawEncodedFeatures.add(sentinel)
                 continue
             }
@@ -150,8 +162,13 @@ class InputEncoderUtilWrapper(
                  * its effective size.
                  */
                 is ArrayGene<*> -> {
-                    val count = leaf.getViewOfElements()
-                        .count { e -> e.getValueAsPrintableString().isNotBlank() }
+                    val elements = leaf.getViewOfElements()
+                    // If the array is empty, encode as sentinel
+                    val count = if (elements.isEmpty()) {
+                        sentinel
+                    } else {
+                        elements.count { e -> e.getValueAsPrintableString().isNotBlank()}
+                    }
                     rawEncodedFeatures.add(count.toDouble())
                 }
 

core/src/main/kotlin/org/evomaster/core/problem/rest/classifier/probabilistic/kde/KDE400EndpointModel.kt

@@ -33,11 +33,8 @@ class KDE400EndpointModel (
     private var density400: KDE? = null
     private var densityNot400: KDE? = null
 
-    /**
-     * Optional cap on stored samples per class (0 = unlimited).
-     * If >0, uses reservoir-style uniform downsampling.
-     */
-    var maxSamplesPerClass: Int = 0
+    /** Cap on stored samples per class based on the reservoir-style uniform downsampling.*/
+    var maxSamplesPerClass: Int = 10000
 
     /** Must be called once to initialize the model properties */
     override fun initializeIfNeeded(inputVector: List<Double>) {
@@ -148,7 +145,7 @@ class KDE400EndpointModel (
      * Represents a Kernel Density Estimator (KDE) that approximates the distribution of a dataset
      * using Gaussian kernels with diagonal bandwidth.
      * @property d Dimensionality of the data points.
-     * @property maxStored Maximum number of samples to store in memory. If the value is <= 0, all samples are stored.
+     * @property maxStored Maximum number of samples to store in memory.
      */
     class KDE(private val d: Int, private val maxStored: Int = 0) {
 
@@ -174,18 +171,19 @@ class KDE400EndpointModel (
                 M2[j] += delta * delta2
             }
 
-            // Store sample (unbounded or reservoir downsample)
-            if (maxStored <= 0) {
+            /**
+             * Reservoir-style replacement to avoid memory issue
+             *  - Fill up until we reach maxStored.
+             *  - After that, replace existing samples with decreasing probability
+             *    to maintain a uniform random subset of all seen data.
+             */
+            if (samples.size < maxStored) {
                 samples.add(x)
             } else {
-                if (samples.size < maxStored) {
-                    samples.add(x)
-                } else {
-                    // reservoir: replace with decreasing probability
-                    val r = kotlin.random.Random.nextLong(seen)
-                    if (r < maxStored) {
-                        samples[r.toInt()] = x
-                    }
+                // reservoir: replace with decreasing probability
+                val r = kotlin.random.Random.nextLong(seen)
+                if (r < maxStored) {
+                    samples[r.toInt()] = x
                 }
             }
         }

core/src/main/kotlin/org/evomaster/core/problem/rest/classifier/probabilistic/knn/KNN400EndpointModel.kt

@@ -28,6 +28,7 @@ class KNN400EndpointModel (
 
     companion object {
         private const val NOT_400 = 200
+        private const val MAX_SAMPLES = 10_000    // Fixed-size buffer for samples to avoid memory overload
     }
 
     /**
@@ -38,6 +39,9 @@ class KNN400EndpointModel (
      */
     val samples = mutableListOf<Pair<List<Double>, Int>>()
 
+    /** Total number of samples observed so far (including discarded ones). */
+    private var seen: Long = 0L
+
     // Euclidean distance between two points in the feature space
     private fun distance(a: List<Double>, b: List<Double>): Double {
         return sqrt(a.zip(b).sumOf { (ai, bi) -> (ai - bi) * (ai - bi) })
@@ -112,12 +116,26 @@ class KNN400EndpointModel (
          * Store only classes of interest (i.e., 400 and not 400 groups)
          */
         val trueStatusCode = output.getStatusCode()
-        if (trueStatusCode == 400) {
-            samples.add(inputVector to 400)
+        val label = if (trueStatusCode == 400) 400 else NOT_400
+
+        /**
+         * Keep the sample list bounded using reservoir sampling.
+         *
+         * - If we have not yet filled the reservoir (samples.size < MAX_SAMPLES), add the new sample.
+         * - Otherwise, replace an existing sample with decreasing probability to maintain
+         *   a uniform random subset of all seen data.
+         */
+        seen++
+        if (samples.size < MAX_SAMPLES) {
+            samples.add(inputVector to label)
         } else {
-            samples.add(inputVector to NOT_400)
+            val r = kotlin.random.Random.nextLong(seen)
+            if (r < MAX_SAMPLES) {
+                samples[r.toInt()] = inputVector to label
+            }
         }
 
+
     }
 
 }