Modeling root nodes separately.

This is the dumbest model. Each root node predict close to the average
of the observation series.

CMakeLists.txt

@@ -77,7 +77,7 @@ add_library(Delphi
   lib/format_output.cpp
   lib/database.cpp
   #lib/PybindTester.hpp
-)
+  lib/independent_nodes.cpp)
 
 target_link_libraries(Delphi
                       PRIVATE ${Boost_LIBRARIES}

lib/AnalysisGraph.hpp

@@ -243,6 +243,8 @@ class AnalysisGraph {
 
   std::unordered_set<int> dependent_nodes = {};
   std::unordered_set<int> independent_nodes = {};
+  std::vector<double> generated_latent_sequence;
+  int generated_concept;
 
   /*
    ============================================================================
@@ -419,6 +421,8 @@ class AnalysisGraph {
 
   std::vector<Eigen::MatrixXd> transition_matrix_collection;
   std::vector<Eigen::VectorXd> initial_latent_state_collection;
+  std::vector<std::vector<double>> latent_mean_collection;
+  std::vector<std::vector<double>> latent_std_collection;
 
   std::vector<Eigen::VectorXd> synthetic_latent_state_sequence;
   bool synthetic_data_experiment = false;
@@ -894,6 +898,24 @@ class AnalysisGraph {
 
   void revert_back_to_previous_state();
 
+
+  /*
+   ============================================================================
+   Private: Modeling independent nodes (in independent_nodes.cpp)
+   ============================================================================
+  */
+
+  void generate_from_data_mean_and_std_gussian(double mean,
+                                               double std,
+                                               int num_timesteps);
+
+  void generate_independent_node_latent_sequences(int samp, int num_timesteps);
+
+  void update_independent_node_latent_state_with_generated_derivatives(
+      int ts, int concept_id, std::vector<double>& latent_sequence);
+
+  void update_latent_state_with_generated_derivatives(int ts);
+
   /*
    ============================================================================
    Private: Prediction (in prediction.cpp)

lib/Node.hpp

@@ -9,6 +9,9 @@
 class Node {
   public:
   std::string name = "";
+  double mean = 0;
+  double std = 1;
+  std::vector<double> generated_latent_sequence = {};
   bool visited;
   LatentVar rv;
   std::string to_string() { return this->name; }

lib/independent_nodes.cpp

@@ -0,0 +1,60 @@
+// Modeling independent CAG nodes
+
+#include "AnalysisGraph.hpp"
+
+using namespace std;
+
+void AnalysisGraph::generate_from_data_mean_and_std_gussian(double mean,
+                                                            double std,
+                                                            int num_timesteps) {
+  this->generated_latent_sequence = vector<double>(num_timesteps);
+
+  for (int ts = 0; ts < num_timesteps; ts++) {
+    this->generated_latent_sequence[ts] = mean + std
+                                      * norm_dist(this->rand_num_generator);
+  }
+}
+
+void AnalysisGraph::generate_independent_node_latent_sequences(int samp, int num_timesteps) {
+  for (int v : this->independent_nodes) {
+    Node &n = (*this)[v];
+
+    double mean;
+    double std;
+
+    if (samp > -1) {
+      mean = this->latent_mean_collection[samp][v];
+      std = this->latent_std_collection[samp][v];
+    }
+    else {
+      mean = n.mean;
+      std = n.std;
+    }
+
+    this->generate_from_data_mean_and_std_gussian(mean,
+                                                  std,
+                                                  num_timesteps);
+    n.generated_latent_sequence.clear();
+    n.generated_latent_sequence = this->generated_latent_sequence;
+  }
+}
+
+void AnalysisGraph::
+    update_independent_node_latent_state_with_generated_derivatives(
+        int ts, int concept_id, vector<double>& latent_sequence) {
+  if (concept_id > -1 && ts < latent_sequence.size() - 1) {
+    this->current_latent_state[2 * concept_id + 1] = latent_sequence[ts + 1]
+                                                     - latent_sequence[ts];
+
+    if (ts == 0) {
+      this->current_latent_state[2 * concept_id] = latent_sequence[0];
+    }
+  }
+}
+
+void AnalysisGraph::update_latent_state_with_generated_derivatives(int ts) {
+  for (int v : this->independent_nodes) {
+    Node &n = (*this)[v];
+    this->update_independent_node_latent_state_with_generated_derivatives(ts, v, n.generated_latent_sequence);
+  }
+}

lib/parameter_initialization.cpp

@@ -34,13 +34,18 @@ void AnalysisGraph::initialize_parameters(int res,
     this->set_transition_matrix_from_betas();
     this->derivative_prior_variance = 0.1;
     this->set_default_initial_state(initial_derivative);
+    this->generate_independent_node_latent_sequences(-1, this->n_timesteps);
     this->set_log_likelihood();
 
     this->transition_matrix_collection.clear();
     this->initial_latent_state_collection.clear();
+    this->latent_mean_collection.clear();
+    this->latent_std_collection.clear();
 
     this->transition_matrix_collection = vector<Eigen::MatrixXd>(this->res);
     this->initial_latent_state_collection = vector<Eigen::VectorXd>(this->res);
+    this->latent_mean_collection = vector<vector<double>>(this->res);
+    this->latent_std_collection = vector<vector<double>>(this->res);
 }
 
 void AnalysisGraph::init_betas_to(InitialBeta ib) {
@@ -216,6 +221,20 @@ void AnalysisGraph::set_indicator_means_and_standard_deviations() {
               // To avoid division by zero error later on
               ind.set_mean(0.0001);
           }
+
+          // Set mean and standard deviation of the concept based on the mean
+          // and the standard deviation of the first indicator attached to it.
+          if (i == 0) {
+            n.mean = delphi::utils::mean(mean_sequence);
+
+            if (mean_sequence.size() > 1) {
+              n.std = delphi::utils::standard_deviation(n.mean, mean_sequence)
+                      / (n.indicators[0].mean * n.indicators[0].mean);
+            }
+
+            // Scale the mean to latent space
+            n.mean /= n.indicators[0].mean;
+          }
       }
   }
 }

lib/prediction.cpp

@@ -60,29 +60,34 @@ void AnalysisGraph::generate_latent_state_sequences(
           // length Δt
           A = this->transition_matrix_collection[samp];
 
+          this->generate_independent_node_latent_sequences(samp, initial_prediction_step
+                                                                 + this->pred_timesteps);
+
           // Evolving the system till the initial_prediction_step
-          this->predicted_latent_state_sequences[samp][0] =
-                                  this->initial_latent_state_collection[samp];
+          this->current_latent_state = this->initial_latent_state_collection[samp];
 
           for (int ts = 0; ts < initial_prediction_step; ts++) {
+            this->update_latent_state_with_generated_derivatives(ts);
 
             // Set derivatives for frozen nodes
             for (const auto & [ v, deriv_func ] : this->external_concepts) {
               const Indicator& ind = this->graph[v].indicators[0];
-              this->predicted_latent_state_sequences[samp][0][2 * v + 1] =
-                                                      deriv_func(ts, ind.mean);
+              this->current_latent_state[2 * v + 1] = deriv_func(ts, ind.mean);
             }
 
-            this->predicted_latent_state_sequences[samp][0] =
-                            A * this->predicted_latent_state_sequences[samp][0];
+            this->current_latent_state = A * this->current_latent_state;
           }
 
+          this->update_latent_state_with_generated_derivatives(initial_prediction_step);
+
           // Set derivatives for frozen nodes
           for (const auto & [ v, deriv_func ] : this->external_concepts) {
             const Indicator& ind = this->graph[v].indicators[0];
-            this->predicted_latent_state_sequences[samp][0][2 * v + 1] =
+            this->current_latent_state[2 * v + 1] =
                                   deriv_func(initial_prediction_step, ind.mean);
           }
+
+          this->predicted_latent_state_sequences[samp][0] = this->current_latent_state;
       }
 
       // Clear out perpetual constraints residual from previous sample
@@ -122,8 +127,9 @@ void AnalysisGraph::generate_latent_state_sequences(
           //                  The actual line of code represents,
           //                        s_t = e^{Ac * Δt } * s_{t-1}
           // When discrete  : s_t = Ad * s_{t-1}
-          this->predicted_latent_state_sequences[samp][ts] =
-              A * this->predicted_latent_state_sequences[samp][ts - 1];
+          this->current_latent_state = A * this->predicted_latent_state_sequences[samp][ts - 1];
+          this->update_latent_state_with_generated_derivatives(ts);
+          this->predicted_latent_state_sequences[samp][ts] = this->current_latent_state;
 
           // Set derivatives for frozen nodes
           for (const auto & [ v, deriv_func ] : this->external_concepts) {

lib/sampling.cpp

@@ -134,13 +134,21 @@ void AnalysisGraph::set_log_likelihood() {
         }
       }
       this->current_latent_state = this->s0;
-      set_log_likelihood_helper(0);
+
+//      this->update_independent_node_latent_state_with_generated_derivatives(
+//          0, this->generated_concept, this->generated_latent_sequence);
+      this->update_latent_state_with_generated_derivatives(0);
+
+      this->set_log_likelihood_helper(0);
 
       for (int ts = 1; ts < this->n_timesteps; ts++) {
         this->current_latent_state =
             this->e_A_ts[this->observation_timestep_gaps[ts]]
             * this->current_latent_state;
-        set_log_likelihood_helper(ts);
+//        this->update_independent_node_latent_state_with_generated_derivatives(
+//            ts, this->generated_concept, this->generated_latent_sequence);
+        this->update_latent_state_with_generated_derivatives(ts);
+        this->set_log_likelihood_helper(ts);
       }
   } else {
       // Discretized version
@@ -154,6 +162,9 @@ void AnalysisGraph::set_log_likelihood() {
               this->current_latent_state[2 * v + 1] = deriv_func(ts, ind.mean);
           }
 
+//          this->update_independent_node_latent_state_with_generated_derivatives(
+//              ts, this->generated_concept, this->generated_latent_sequence);
+          this->update_latent_state_with_generated_derivatives(ts);
           set_log_likelihood_helper(ts);
           this->current_latent_state = this->A_original * this->current_latent_state;
       }
@@ -176,13 +187,21 @@ void AnalysisGraph::sample_from_posterior() {
 
   if (acceptance_probability < this->uni_dist(this->rand_num_generator)) {
     // Reject the sample
-    this->revert_back_to_previous_state();
+    if (this->generated_concept == -1) {
+      this->revert_back_to_previous_state();
+    }
+    else {
+      Node &n = (*this)[this->generated_concept];
+      n.mean = delphi::utils::mean(this->generated_latent_sequence);
+      n.std = delphi::utils::standard_deviation(n.mean, this->generated_latent_sequence);
+    }
   }
 }
 
 void AnalysisGraph::sample_from_proposal() {
   // Flip a coin and decide whether to perturb a θ or a derivative
   this->coin_flip = this->uni_dist(this->rand_num_generator);
+  this->generated_concept = -1;
 
   if (this->coin_flip < this->coin_flip_thresh) {
     // Randomly pick an edge ≡ θ
@@ -202,11 +221,21 @@ void AnalysisGraph::sample_from_proposal() {
     this->update_transition_matrix_cells(e[0]);
   }
   else {
-    // Randomly select a concept to change the derivative
-    this->changed_derivative =
-        2 * this->concept_sample_pool[this->uni_disc_dist(this->rand_num_generator)] + 1;
-    this->previous_derivative = this->s0[this->changed_derivative];
-    this->s0[this->changed_derivative] += this->norm_dist(this->rand_num_generator);
+    // Randomly select a concept
+    int concept = this->concept_sample_pool[this->uni_disc_dist(this->rand_num_generator)];
+    this->changed_derivative = 2 * concept + 1;
+
+    if (this->independent_nodes.find(concept) != this->independent_nodes.end()) {
+      this->generated_concept = concept;
+      Node &n = (*this)[this->generated_concept];
+      this->generate_from_data_mean_and_std_gussian(n.mean, n.std, this->n_timesteps);
+    }
+    else {
+      // to change the derivative
+      this->previous_derivative = this->s0[this->changed_derivative];
+      this->s0[this->changed_derivative] +=
+          this->norm_dist(this->rand_num_generator);
+    }
   }
 }
 
@@ -247,14 +276,25 @@ double AnalysisGraph::calculate_delta_log_prior() {
            kde.logpdf(this->previous_theta.second);
   }
   else {
-    // A derivative  has been sampled
-    // We assume the prior for derivative is N(0, 0.1)
-    // We have to return: log( p(ẋ_new )) - log( p( ẋ_old ))
-    // After some mathematical simplifications we can derive
-    // (ẋ_old - ẋ_new)(ẋ_old + ẋ_new) / 2σ²
-    return (this->previous_derivative - this->s0[this->changed_derivative])
-           * (this->previous_derivative + this->s0[this->changed_derivative])
-           / (2 * this->derivative_prior_variance);
+    if (this->generated_concept == -1) {
+      // A derivative  has been sampled
+      // We assume the prior for derivative is N(0, 0.1)
+      // We have to return: log( p(ẋ_new )) - log( p( ẋ_old ))
+      // After some mathematical simplifications we can derive
+      // (ẋ_old - ẋ_new)(ẋ_old + ẋ_new) / 2σ²
+      return (this->previous_derivative - this->s0[this->changed_derivative]) *
+             (this->previous_derivative + this->s0[this->changed_derivative]) /
+             (2 * this->derivative_prior_variance);
+    }
+    else {
+      // A derivative sequence for an independent node has been generated
+      // When latent state at ts = 0 is 1, it makes the observation 0 the
+      // highest probable value.
+      // The standard deviation of ts = 0 latent state is set to 0.01
+      return (1 - this->generated_latent_sequence[0]) *
+             (1 + this->generated_latent_sequence[0]) /
+             (2 * 0.01);
+    }
   }
 }
 

lib/train_model.cpp

@@ -86,6 +86,8 @@ void AnalysisGraph::run_train_model(int res,
       this->sample_from_posterior();
     }
 
+    int num_verts = this->num_vertices();
+
     cout << "\nSampling " << this->res << " samples from posterior..." << endl;
     for (int i : trange(this->res)) {
       this->sample_from_posterior();
@@ -95,6 +97,15 @@ void AnalysisGraph::run_train_model(int res,
       for (auto e : this->edges()) {
         this->graph[e].sampled_thetas.push_back(this->graph[e].theta);
       }
+
+      this->latent_mean_collection[i] = vector<double>(num_verts);
+      this->latent_std_collection[i] = vector<double>(num_verts);
+
+      for (int v : this->node_indices()) {
+        Node &n = (*this)[v];
+        this->latent_mean_collection[i][v] = n.mean;
+        this->latent_std_collection[i][v] = n.std;
+      }
     }
 
     this->trained = true;

scripts/modeling_efforts.py

@@ -86,8 +86,9 @@ def draw_CAG(G, file_name):
                       use_continuous=False,
                       train_start_timestep=0,
                       train_timesteps=48,
-                      ext_concepts={'rain': get_rain_derivative})
-                      #ext_concepts={'test': lambda x, s : x*s })
+                      #ext_concepts={'rain': get_rain_derivative}
+                      #ext_concepts={'test': lambda x, s : x*s }
+                      )
 
     # try:
     G.generate_prediction(49, 24)
@@ -104,4 +105,4 @@ def draw_CAG(G, file_name):
     print(pred_range[1:])
 
     dp.delphi_plotter(model_state, num_bins=400, rotation=45,
-            out_dir='plots', file_name_prefix='')
+            out_dir='plots', file_name_prefix='', save_csv=True)