Add linearStateRewardPredictor and fix names (#302)

Add linearStateRewardPredictor and fix names

Author: Atos1337

docs/jlearch/jlearch-architecture.md

@@ -37,7 +37,7 @@ classDiagram
     UtBotSymbolicEngine *-- InterproceduralUnitGraph
 
     class Predictors 
-    class NNStateRewardPredictor
+    class StateRewardPredictor
     class NNRewardGuidedSelector
 
    
@@ -50,12 +50,13 @@ classDiagram
 
     UtBotSymbolicEngine *-- BasePathSelector  
     
-    Predictors o-- NNStateRewardPredictor
+    Predictors o-- StateRewardPredictor
     NNRewardGuidedSelector ..> Predictors
     NNRewardGuidedSelector *-- FeatureExtractor
     
-    NNStateRewardPredictorSmile --|> NNStateRewardPredictor
-    NNStateRewardPredictorTorch --|> NNStateRewardPredictor
+    NNStateRewardPredictorSmile --|> StateRewardPredictor
+    StateRewardPredictorTorch --|> StateRewardPredictor
+    LinearStateRewardPredictor --|> StateRewardPredictor
     
     NNStateRewardGuidedSelectorWithRecalculationWeight --|> NNRewardGuidedSelector
     NNStateRewardGuidedSelectorWithoutRecalculationWeight --|> NNRewardGuidedSelector      
@@ -129,12 +130,13 @@ For creating `FeatureExtractor`, it uses `FeatureExtractorFactory` from `EngineA
 It is interface in framework-module, that allows to use implementation from analytics module.
 * `extractFeatures(state: ExecutionState)` - create features list for state and store it in `state.features`. Now we extract all features, which were described in [paper](https://files.sri.inf.ethz.ch/website/papers/ccs21-learch.pdf). In feature, we can extend the feature list by other features, for example, NeuroSMT.
 
-# NNStateRewardPredictor
+# StateRewardPredictor
 
-Interface for reward predictors. Now it has two implementations in `analytics` module:
+Interface for reward predictors. Now it has three implementations in `analytics` module:
 
 * `NNStateRewardPredictorSmile`: it uses our own format to store feedforward neural network, and it uses `Smile` library to do multiplication of matrix.
 * `NNStateRewardPredictorTorch`: it assumed that a model is any type of model in `pt` format. It uses the `Deep Java library` to use such models.
+* `LinearStateRewardPredictor`: it uses our own format to store weights vector: line of doubles, separated by comma with bias as last weight.
 
 It should be created at the beginning of work and stored at `Predictors` class to be used in `NNRewardGuidedSelector` from the `framework` module.
 

utbot-analytics/src/main/kotlin/org/utbot/predictors/FeedForwardNetwork.kt

@@ -1,5 +1,6 @@
 package org.utbot.predictors
 
+import org.utbot.predictors.util.ModelBuildingException
 import smile.math.matrix.Matrix
 import kotlin.math.max
 
@@ -26,7 +27,7 @@ internal fun buildModel(nnJson: NNJson): FeedForwardNetwork {
             operations.add {
                 when (nnJson.activationLayers[i]) {
                     ActivationFunctions.ReLU -> reLU(it)
-                    else -> error("Unsupported activation")
+                    else -> throw ModelBuildingException("Unsupported activation")
                 }
             }
         }

utbot-analytics/src/main/kotlin/org/utbot/predictors/LinearStateRewardPredictor.kt

@@ -1,9 +1,13 @@
 package org.utbot.predictors
 
+import org.utbot.analytics.StateRewardPredictor
 import mu.KotlinLogging
-import org.utbot.analytics.UtBotAbstractPredictor
 import org.utbot.framework.PathSelectorType
 import org.utbot.framework.UtSettings
+import org.utbot.predictors.util.PredictorLoadingException
+import org.utbot.predictors.util.WeightsLoadingException
+import org.utbot.predictors.util.splitByCommaIntoDoubleArray
+import smile.math.MathEx.dot
 import smile.math.matrix.Matrix
 import java.io.File
 
@@ -16,32 +20,39 @@ private val logger = KotlinLogging.logger {}
  */
 private fun loadWeights(path: String): Matrix {
     val weightsFile = File("${UtSettings.rewardModelPath}/${path}")
+    lateinit var weightsArray: DoubleArray
 
-    if (!weightsFile.exists()) {
-        error("There is no file with weights with path: ${weightsFile.absolutePath}")
-    }
+    try {
+        if (!weightsFile.exists()) {
+            error("There is no file with weights with path: ${weightsFile.absolutePath}")
+        }
 
-    val weightsArray = weightsFile.readText().splitByCommaIntoDoubleArray()
+        weightsArray = weightsFile.readText().splitByCommaIntoDoubleArray()
+    } catch (e: Exception) {
+        throw WeightsLoadingException(e)
+    }
 
     return Matrix(weightsArray)
 }
 
-class LinearStateRewardPredictor(weightsPath: String = DEFAULT_WEIGHT_PATH) :
-    UtBotAbstractPredictor<List<List<Double>>, List<Double>> {
+class LinearStateRewardPredictor(weightsPath: String = DEFAULT_WEIGHT_PATH, scalerPath: String = DEFAULT_SCALER_PATH) :
+    StateRewardPredictor {
     private lateinit var weights: Matrix
+    private lateinit var scaler: StandardScaler
 
     init {
         try {
             weights = loadWeights(weightsPath)
-        } catch (e: Exception) {
+            scaler = loadScaler(scalerPath)
+        } catch (e: PredictorLoadingException) {
             logger.info(e) {
                 "Error while initialization of LinearStateRewardPredictor. Changing pathSelectorType on INHERITORS_SELECTOR"
             }
             UtSettings.pathSelectorType = PathSelectorType.INHERITORS_SELECTOR
         }
     }
 
-    override fun predict(input: List<List<Double>>): List<Double> {
+    fun predict(input: List<List<Double>>): List<Double> {
         // add 1 to each feature vector
         val matrixValues = input
             .map { (it + 1.0).toDoubleArray() }
@@ -51,4 +62,11 @@ class LinearStateRewardPredictor(weightsPath: String = DEFAULT_WEIGHT_PATH) :
 
         return X.mm(weights).col(0).toList()
     }
+
+    override fun predict(input: List<Double>): Double {
+        var inputArray =  Matrix(input.toDoubleArray()).sub(scaler.mean).div(scaler.variance).col(0)
+        inputArray += 1.0
+
+        return dot(inputArray, weights.col(0))
+    }
 }

utbot-analytics/src/main/kotlin/org/utbot/predictors/NNJson.kt

@@ -2,6 +2,7 @@ package org.utbot.predictors
 
 import com.google.gson.Gson
 import org.utbot.framework.UtSettings
+import org.utbot.predictors.util.ModelLoadingException
 import java.io.FileReader
 import java.nio.file.Paths
 
@@ -33,10 +34,16 @@ data class NNJson(
 
 internal fun loadModel(path: String): NNJson {
     val modelFile = Paths.get(UtSettings.rewardModelPath, path).toFile()
-    val nnJson: NNJson =
-        Gson().fromJson(FileReader(modelFile), NNJson::class.java) ?: run {
-            error("Empty model")
-        }
+    lateinit var nnJson: NNJson
+
+    try {
+        nnJson =
+            Gson().fromJson(FileReader(modelFile), NNJson::class.java) ?: run {
+                error("Empty model")
+            }
+    } catch (e: Exception) {
+        throw ModelLoadingException(e)
+    }
 
     return nnJson
 }

utbot-analytics/src/main/kotlin/org/utbot/predictors/NNStateRewardPredictor.kt

@@ -1,27 +1,28 @@
 package org.utbot.predictors
 
 import mu.KotlinLogging
+import org.utbot.analytics.StateRewardPredictor
 import org.utbot.framework.PathSelectorType
 import org.utbot.framework.UtSettings
+import org.utbot.predictors.util.PredictorLoadingException
 import smile.math.matrix.Matrix
 
 private const val DEFAULT_MODEL_PATH = "nn.json"
-private const val DEFAULT_SCALER_PATH = "scaler.txt"
 
 private val logger = KotlinLogging.logger {}
 
 private fun getModel(path: String) = buildModel(loadModel(path))
 
 class NNStateRewardPredictorBase(modelPath: String = DEFAULT_MODEL_PATH, scalerPath: String = DEFAULT_SCALER_PATH) :
-    NNStateRewardPredictor {
+    StateRewardPredictor {
     private lateinit var nn: FeedForwardNetwork
     private lateinit var scaler: StandardScaler
 
     init {
         try {
             nn = getModel(modelPath)
             scaler = loadScaler(scalerPath)
-        } catch (e: Exception) {
+        } catch (e: PredictorLoadingException) {
             logger.info(e) {
                 "Error while initialization of NNStateRewardPredictorBase. Changing pathSelectorType on INHERITORS_SELECTOR"
             }

utbot-analytics/src/main/kotlin/org/utbot/predictors/NNStateRewardPredictorBase.kt

@@ -0,0 +1,16 @@
+package org.utbot.predictors
+
+import org.utbot.analytics.StateRewardPredictorFactory
+import org.utbot.framework.StateRewardPredictorType
+import org.utbot.framework.UtSettings
+
+/**
+ * Creates [StateRewardPredictor], by checking the [UtSettings] configuration.
+ */
+class StateRewardPredictorFactoryImpl : StateRewardPredictorFactory {
+    override operator fun invoke() = when (UtSettings.stateRewardPredictorType) {
+        StateRewardPredictorType.BASE -> NNStateRewardPredictorBase()
+        StateRewardPredictorType.TORCH -> StateRewardPredictorTorch()
+        StateRewardPredictorType.LINEAR -> LinearStateRewardPredictor()
+    }
+}

utbot-analytics/src/main/kotlin/org/utbot/predictors/StateRewardPredictorFactory.kt

@@ -6,11 +6,12 @@ import ai.djl.ndarray.NDArray
 import ai.djl.ndarray.NDList
 import ai.djl.translate.Translator
 import ai.djl.translate.TranslatorContext
+import org.utbot.analytics.StateRewardPredictor
 import org.utbot.framework.UtSettings
 import java.io.Closeable
 import java.nio.file.Paths
 
-class NNStateRewardPredictorTorch : NNStateRewardPredictor, Closeable {
+class StateRewardPredictorTorch : StateRewardPredictor, Closeable {
     val model: Model = Model.newInstance("model")
 
     init {

…redictors/NNStateRewardPredictorTorch.kt …/predictors/StateRewardPredictorTorch.ktutbot-analytics/src/main/kotlin/org/utbot/predictors/NNStateRewardPredictorTorch.kt renamed to utbot-analytics/src/main/kotlin/org/utbot/predictors/StateRewardPredictorTorch.kt utbot-analytics/src/main/kotlin/org/utbot/predictors/NNStateRewardPredictorTorch.kt renamed to utbot-analytics/src/main/kotlin/org/utbot/predictors/StateRewardPredictorTorch.kt

@@ -1,14 +1,23 @@
 package org.utbot.predictors
 
 import org.utbot.framework.UtSettings
+import org.utbot.predictors.util.ScalerLoadingException
+import org.utbot.predictors.util.splitByCommaIntoDoubleArray
 import smile.math.matrix.Matrix
 import java.nio.file.Paths
 
+
+internal const val DEFAULT_SCALER_PATH = "scaler.txt"
+
 data class StandardScaler(val mean: Matrix?, val variance: Matrix?)
 
 internal fun loadScaler(path: String): StandardScaler =
-    Paths.get(UtSettings.rewardModelPath, path).toFile().bufferedReader().use {
-        val mean = it.readLine()?.splitByCommaIntoDoubleArray() ?: error("There is not mean in $path")
-        val variance = it.readLine()?.splitByCommaIntoDoubleArray() ?: error("There is not variance in $path")
-        StandardScaler(Matrix(mean), Matrix(variance))
+    try {
+        Paths.get(UtSettings.rewardModelPath, path).toFile().bufferedReader().use {
+            val mean = it.readLine()?.splitByCommaIntoDoubleArray() ?: error("There is not mean in $path")
+            val variance = it.readLine()?.splitByCommaIntoDoubleArray() ?: error("There is not variance in $path")
+            StandardScaler(Matrix(mean), Matrix(variance))
+        }
+    } catch (e: Exception) {
+        throw ScalerLoadingException(e)
     }

utbot-analytics/src/main/kotlin/org/utbot/predictors/scalers.kt

@@ -0,0 +1,11 @@
+package org.utbot.predictors.util
+
+sealed class PredictorLoadingException(msg: String?, cause: Throwable? = null) : Exception(msg, cause)
+
+class WeightsLoadingException(e: Throwable) : PredictorLoadingException("Error while loading weights", e)
+
+class ModelLoadingException(e: Throwable) : PredictorLoadingException("Error while loading model", e)
+
+class ScalerLoadingException(e: Throwable) : PredictorLoadingException("Error while loading scaler", e)
+
+class ModelBuildingException(msg: String) : PredictorLoadingException(msg)