it.unibo.alchemist.boundary.extractors.MeanSquaredError.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of alchemist-loading Show documentation
Alchemist Machinery to load from files
The newest version!
/*
 * Copyright (C) 2010-2023, Danilo Pianini and contributors
 * listed, for each module, in the respective subproject's build.gradle.kts file.
 *
 * This file is part of Alchemist, and is distributed under the terms of the
 * GNU General Public License, with a linking exception,
 * as described in the file LICENSE in the Alchemist distribution's top directory.
 */

package it.unibo.alchemist.boundary.extractors

import it.unibo.alchemist.model.Actionable
import it.unibo.alchemist.model.Environment
import it.unibo.alchemist.model.Incarnation
import it.unibo.alchemist.model.Molecule
import it.unibo.alchemist.model.Time
import it.unibo.alchemist.util.StatUtil
import org.apache.commons.math3.stat.descriptive.UnivariateStatistic

/**
 * Exports the Mean Squared Error for the concentration of some molecule, given
 * another molecule that carries the correct result. The correct value is
 * extracted from every node, then the provided {@link UnivariateStatistic} is
 * applied to get a single, global correct value. Then, the actual value is
 * extracted from every node, its value is compared (subtracted) to the computed
 * correct value, it gets squared, and then logged.
 *
 * @param  concentration type
 */
class MeanSquaredError @JvmOverloads constructor(
    incarnation: Incarnation,
    localCorrectValueMolecule: String,
    localCorrectValueProperty: String = "",
    statistics: String,
    localValueMolecule: String,
    localValueProperty: String = "",
    precision: Int? = null,
) : AbstractDoubleExporter(precision) {

    constructor(
        incarnation: Incarnation,
        localCorrectValueMolecule: String,
        statistics: String,
        localValueMolecule: String,
        precision: Int,
    ) : this(
        incarnation = incarnation,
        localCorrectValueMolecule = localCorrectValueMolecule,
        statistics = statistics,
        localValueMolecule = localValueMolecule,
        localValueProperty = "",
        precision = precision,
    )

    private val statistic: UnivariateStatistic = StatUtil.makeUnivariateStatistic(statistics)
        .orElseThrow { IllegalArgumentException("Could not create univariate statistic $statistics") }
    private val mReference: Molecule = incarnation.createMolecule(localCorrectValueMolecule)
    private val pReference: String = localCorrectValueProperty
    private val pActual: String = localValueProperty
    private val mActual: Molecule = incarnation.createMolecule(localValueMolecule)
    private val name: String = with(StringBuilder("MSE(")) {
        append(statistics)
        append('(')
        if (pReference.isNotEmpty()) {
            append(pReference).append('@')
        }
        append(localCorrectValueMolecule).append("),")
        if (pActual.isNotEmpty()) {
            append(pActual).append('@')
        }
        append(localValueMolecule).append(')')
        toString()
    }
    override val columnNames = listOf(name)

    override fun  extractData(
        environment: Environment,
        reaction: Actionable?,
        time: Time,
        step: Long,
    ): Map {
        val incarnation: Incarnation = environment.incarnation
        val value: Double = statistic
            .evaluate(environment.nodes.map { incarnation.getProperty(it, mReference, pReference) }.toDoubleArray())
        val mse: Double = environment.nodes.parallelStream()
            .mapToDouble { incarnation.getProperty(it, mActual, pActual) - value }
            .map { it * it }
            .average()
            .orElse(Double.NaN)
        return mapOf(name to mse)
    }
}