Observations
MultivariateModel
::SimulateData(io::DataSettings &DS)
{
/// This function simulates observations (Patients and their measurements y_ij at different time points t_ij)
/// according to the model, with a given noise level e_ij, such that y_ij = f(t_ij) + e_ij
/// Their is two option:
/// 1) The model is not initialized (neither random variables of number of realizations) and it has to be
/// This case corresponds to simulated data used to test the model, meaning if it can recover the random variables
/// used to simulate the data
/// 2) The model is already initialized, thus it should rely on its current state (random variables, realizations, ...)
/// This case corresponds to new data, for a dataset augmentation for instance
// TODO :
/// PITFALL : As for now, only the first option is implemented
/// PITFALL2 : Take a closer look at / merge with InitializeFakeRandomVariables
/// Initialize the model
m_ManifoldDimension = DS.GetCognitiveScoresDimension();
m_NumberOfSubjects = DS.GetNumberOfSimulatedSubjects();
m_RealizationsPerRandomVariable["G"] = 1;
for(size_t i = 1; i < m_ManifoldDimension; ++i)
m_RealizationsPerRandomVariable["Delta#" + std::to_string(i)] = 1;
for(size_t i = 0; i < m_NbIndependentSources*(m_ManifoldDimension - 1); ++i)
m_RealizationsPerRandomVariable["Beta#" + std::to_string(i)] = 1;
m_RealizationsPerRandomVariable["Ksi"] = m_NumberOfSubjects;
m_RealizationsPerRandomVariable["Tau"] = m_NumberOfSubjects;
for(int i = 0; i < m_NbIndependentSources; ++i)
m_RealizationsPerRandomVariable["S#" + std::to_string(i)] = m_NumberOfSubjects;
auto R = SimulateRealizations();
/// Update the model
m_G = exp(R.at("G", 0));
ComputeDeltas(R);
ComputeOrthonormalBasis();
ComputeAMatrix(R);
ComputeSpaceShifts(R);
ComputeBlock(R);
/// Simulate the data
std::random_device RD;
std::mt19937 RNG(RD());
std::uniform_int_distribution<int> Uni(DS.GetMinimumNumberOfObservations(), DS.GetMaximumNumberOfObservations());
UniformRandomVariable NumberOfTimePoints(60, 95);
GaussianRandomVariable Noise(0, m_Noise->GetVariance());
/// Simulate the data
Observations Obs;
for(int i = 0; i < m_NumberOfSubjects; ++i)
{
/// Get a random number of timepoints and sort them
VectorType T = NumberOfTimePoints.Samples(Uni(RNG));
T.sort();
m_SubjectTimePoints.push_back(T);
/// Simulate the data base on the time-points
IndividualObservations IO(T);
std::vector<VectorType> Landmarks;
for(size_t j = 0; j < T.size(); ++j)
{
Landmarks.push_back(ComputeParallelCurve(i, j) + Noise.Samples(m_ManifoldDimension));
}
IO.AddLandmarks(Landmarks);
Obs.AddIndividualData(IO);
}
/// Initialize the observation and model attributes
Obs.InitializeGlobalAttributes();
m_IndividualObservationDate = Obs.GetObservations();
m_SumObservations = Obs.GetTotalSumOfLandmarks();
m_NbTotalOfObservations = Obs.GetTotalNumberOfObservations();
return Obs;
}
void
MultivariateModel
::Initialize(const Observations& Obs)
{
/// The function initialize different attributes of the model
/// As well as the specific random variables and their realizations used by the model
// TODO : Pitfall : How to have a smart initialization, that may come out of a .txt / .csv file
// TODO : instead of using the same initialization or modifiying it in the code
// TODO : Some cases may fall in between the two cases (default values needed)
/// Data-related attributes
m_ManifoldDimension = Obs.GetSubjectObservations(0).GetCognitiveScore(0).size();
m_NumberOfSubjects = Obs.GetNumberOfSubjects();
m_IndividualObservationDate = Obs.GetObservations();
m_SubjectTimePoints = Obs.GetObservations();
m_NbTotalOfObservations = Obs.GetTotalNumberOfObservations();
m_SumObservations = Obs.GetTotalSumOfCognitiveScores();
/// Initialize the size of some parameters
m_Deltas.set_size(m_ManifoldDimension);
m_Block.set_size(m_ManifoldDimension);
/// Population variables
/// (Initialization of the random variable m_Random Variable
/// and the associated number of realizations m_RealizationPerRandomVariable)
m_Noise = std::make_shared<GaussianRandomVariable>(0.0, 0.00001);
m_RandomVariables.AddRandomVariable("G", "Gaussian", {0.12, 0.0001 * 0.0001});
m_RealizationsPerRandomVariable["G"] = 1;
for(size_t i = 1; i < m_ManifoldDimension; ++i)
{
std::string NameDelta = "Delta#" + std::to_string(i);
m_RandomVariables.AddRandomVariable(NameDelta, "Gaussian", {0, 0.003 * 0.003});
m_RealizationsPerRandomVariable[NameDelta] = 1;
}
for(int i = 0; i < m_NbIndependentSources*(m_ManifoldDimension - 1); ++i)
{
std::string Name = "Beta#" + std::to_string(i);
m_RandomVariables.AddRandomVariable(Name, "Gaussian", {0, 0.001*0.001});
m_RealizationsPerRandomVariable[Name] = 1;
}
/// Individual realizations
/// (Initialization of the random variable m_Random Variable
/// and the associated number of realizations m_RealizationPerRandomVariable)
m_RandomVariables.AddRandomVariable("Ksi", "Gaussian", {0.13, 0.0004});
m_RealizationsPerRandomVariable["Ksi"] = m_NumberOfSubjects;
m_RandomVariables.AddRandomVariable("Tau", "Gaussian", {75, 0.025});
m_RealizationsPerRandomVariable["Tau"] = m_NumberOfSubjects;
for(int i = 0; i < m_NbIndependentSources; ++i)
{
std::string Name = "S#" + std::to_string(i);
m_RandomVariables.AddRandomVariable(Name, "Gaussian", {0.0, 1});
m_RealizationsPerRandomVariable[Name] = m_NumberOfSubjects;
}
}
