feat(Helpers): create inference helpers.

Author: francoisbonneau

bindings/python/src/stochastic/sampling/mcmc/helpers/fracture_simulation_runner.hpp

@@ -88,7 +88,7 @@ namespace geode
             //                pybind11::arg( "engine" ), pybind11::arg( "steps"
             //                ), "Run simulation for a fixed number of steps." )
             .def( "run",
-                static_cast< StatisticsMonitor ( FractureSimulationRunner::* )(
+                static_cast< StatisticsTracker ( FractureSimulationRunner::* )(
                     RandomEngine&, const SimulationConfigurator& ) >(
                     &FractureSimulationRunner::run ),
                 pybind11::arg( "engine" ), pybind11::arg( "config" ),

bindings/python/src/stochastic/sampling/mcmc/helpers/simulation_monitor.hpp

@@ -21,30 +21,30 @@
  *
  */
 
-#include <geode/stochastic/sampling/mcmc/helpers/simulation_monitor.hpp>
+#include <geode/stochastic/inference/statistics_tracker.hpp>
 
 namespace geode
 {
     void define_simulation_monitor( pybind11::module &module )
     {
-        pybind11::class_< geode::StatisticsMonitor >(
-            module, "StatisticsMonitor" )
+        pybind11::class_< geode::StatisticsTracker >(
+            module, "StatisticsTracker" )
             .def( pybind11::init< geode::index_t >(),
                 pybind11::arg( "nb_energy_terms" ),
-                "Create a StatisticsMonitor for a given number of energy "
+                "Create a StatisticsTracker for a given number of energy "
                 "terms" )
-            .def( "add_realization", &geode::StatisticsMonitor::add_realization,
+            .def( "add_realization", &geode::StatisticsTracker::add_realization,
                 pybind11::arg( "values" ),
                 "Add a realization (vector of doubles) to update statistics" )
-            .def( "statiscal_count", &geode::StatisticsMonitor::statiscal_count,
+            .def( "statiscal_count", &geode::StatisticsTracker::statiscal_count,
                 "Return the number of realizations added" )
-            .def_property_readonly( "means", &geode::StatisticsMonitor::means,
+            .def_property_readonly( "means", &geode::StatisticsTracker::means,
                 "Return the computed mean values for each energy term" )
             .def_property_readonly( "variances",
-                &geode::StatisticsMonitor::variances,
+                &geode::StatisticsTracker::variances,
                 "Return the computed variances for each energy term" )
-            .def( "__repr__", []( const geode::StatisticsMonitor &self ) {
-                return "<StatisticsMonitor count="
+            .def( "__repr__", []( const geode::StatisticsTracker &self ) {
+                return "<StatisticsTracker count="
                        + std::to_string( self.statiscal_count() ) + ">";
             } );
     }

bindings/python/src/stochastic/sampling/mcmc/helpers/simulation_printer.hpp

@@ -64,7 +64,7 @@ namespace geode
         //                &SimulationPrinter::print_statistics_summary,
         //                pybind11::arg( "monitor" ),
         //                pybind11::arg( "energy_term_names" ) = "",
-        //                "Print statistics summary from a StatisticsMonitor."
+        //                "Print statistics summary from a StatisticsTracker."
         //                );
     }
 } // namespace geode

bindings/python/src/stochastic/stochastic.cpp

@@ -27,7 +27,7 @@
 #include "sampling/direct/double_sampler.hpp"
 
 // #include "sampling/mcmc/helpers/fracture_simulation_runner.hpp"
-#include "sampling/mcmc/helpers/simulation_monitor.hpp"
+// #include "sampling/mcmc/helpers/simulation_monitor.hpp"
 #include "sampling/mcmc/helpers/simulation_printer.hpp"
 #include "sampling/mcmc/simulation_runner.hpp"
 
@@ -47,7 +47,7 @@ PYBIND11_MODULE( opengeode_stochastic_py_stochastic, module )
     geode::define_random_engine( module );
     geode::define_double_sampler( module );
 
-    geode::define_simulation_monitor( module );
+    // geode::define_simulation_monitor( module );
     geode::define_simulation_printer( module );
     geode::define_simulation_runner( module );
     // geode::define_fracture_simulation( module );

include/geode/stochastic/inference/statistic_monitor.hpp

@@ -23,7 +23,7 @@
 #pragma once
 
 #include <absl/container/flat_hash_map.h>
-#include <geode/stochastic/inference/statistic_monitor.hpp>
+#include <geode/stochastic/inference/statistics_tracker.hpp>
 #include <geode/stochastic/inference/target_statistic.hpp>
 
 namespace geode
@@ -33,7 +33,7 @@ namespace geode
     class StatisticObjective
     {
     public:
-        double compute_loss( const StatMonitor& monitor,
+        double compute_loss( const StatisticsTracker< ObjectType >& monitor,
             const std::vector< TargetStatistic >& targets ) const
         {
             double loss = 0.0;

include/geode/stochastic/inference/statistic_objective.hpp

@@ -24,7 +24,7 @@
 
 #include <absl/container/flat_hash_map.h>
 
-#include <geode/stochastic/inference/statistic_monitor.hpp>
+#include <geode/stochastic/inference/statistics_tracker.hpp>
 #include <geode/stochastic/inference/target_statistic.hpp>
 
 namespace geode
@@ -33,7 +33,7 @@ namespace geode
     class StatisticsValidator
     {
     public:
-        void check( const StatisticsMonitor& monitor,
+        void check( const StatisticsTracker& monitor,
             const std::vector< TargetStatistic >& targets ) const
         {
             for( const auto& target : targets )

include/geode/stochastic/inference/statistic_validator.hpp

@@ -0,0 +1,86 @@
+#pragma once
+
+// #include <absl/container/flat_hash_map.h>
+#include <geode/basic/common.hpp>
+#include <geode/basic/uuid.hpp>
+
+#include <geode/stochastic/common.hpp>
+#include <geode/stochastic/models/model.hpp>
+
+namespace geode
+{
+    template < typename ObjectType >
+    class StatisticsTracker
+    {
+    public:
+        StatisticsTracker( const Model< ObjectType >& model ) : model_{ model }
+        {
+            means_.resize( model.nb_terms(), 0.0 );
+            m2_.resize( model.nb_terms(), 0.0 );
+        }
+
+        [[nodiscard]] index_t statiscal_count() const
+        {
+            return count_;
+        }
+
+        void add_realization( const std::vector< double >& values )
+        {
+            ++count_;
+            for( const auto value_id : geode::Range{ values.size() } )
+            {
+                auto& value = values[value_id];
+                auto& mean = means_[value_id];
+                auto& m2 = m2_[value_id]; // somme des carrés
+
+                double delta = value - mean;
+                mean += delta / count_;
+                double delta2 = value - mean;
+                m2 += delta * delta2;
+            }
+        }
+
+        [[nodiscard]] double mean( const uuid& term_uuid ) const
+        {
+            return means_[model_.term_index( term_uuid )];
+        }
+
+        [[nodiscard]] const std::vector< double >& means() const
+        {
+            return means_;
+        }
+
+        [[nodiscard]] double variance( const uuid& term_uuid ) const
+        {
+            return variance( model_.term_index( term_uuid ) );
+        }
+
+        [[nodiscard]] std::vector< double > variances() const
+        {
+            std::vector< double > variances;
+            variances.reserve( model_.nb_terms() );
+            for( const auto variance_id : geode::Range{ model_.nb_terms() } )
+            {
+                variances.emplace_back( this->variance( variance_id ) );
+            }
+            return variances;
+        }
+
+    private:
+        [[nodiscard]] double variance( index_t term_index ) const
+        {
+            if( count_ < 2 )
+            {
+                return 0.0;
+            }
+            return m2_[term_index] / ( count_ - 1 );
+        }
+
+    private:
+        const Model< ObjectType >& model_;
+
+        std::vector< double > means_{};
+        std::vector< double > m2_{};
+        index_t count_{ 0 };
+    };
+} // namespace geode

include/geode/stochastic/inference/statistics_tracker.hpp

@@ -21,6 +21,7 @@
  *
  */
 #pragma once
+#include <geode/basic/uuid.hpp>
 
 namespace geode
 {

include/geode/stochastic/inference/target_statistic.hpp

@@ -1,3 +1,26 @@
+/*
+ * Copyright (c) 2019 - 2026 Geode-solutions
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
 #pragma once
 
 #include <absl/container/flat_hash_map.h>
@@ -49,14 +72,19 @@ namespace geode
             return energy_terms_.size();
         }
 
-        [[nodiscard]] const EnergyTerm< ObjectType >& get(
-            const uuid& term_id ) const
+        [[nodiscard]] index_t get_term_index( const uuid& term_uuid ) const
         {
-            auto term_it = uuid_to_index_.find( term_id );
+            auto term_it = uuid_to_index_.find( term_uuid );
             OPENGEODE_EXCEPTION( term_it != uuid_to_index_.end(),
                 absl::StrCat( "[EnergyTermCollection] Unknown energy term: ",
-                    term_id.string() ) );
-            return *energy_terms_[term_it->second];
+                    term_uuid.string() ) );
+            return term_it->second;
+        }
+
+        [[nodiscard]] const EnergyTerm< ObjectType >& get(
+            const uuid& term_uuid ) const
+        {
+            return *energy_terms_[get_term_index( term_uuid )];
         }
 
         [[nodiscard]] uuid get_term_uuid( std::string_view name ) const