void
StatisticalInverseProblem<P_V,P_M>::solveWithBayesMetropolisHastings(
const MhOptionsValues* alternativeOptionsValues, // dakota
const P_V& initialValues,
const P_M* initialProposalCovMatrix)
{
//grvy_timer_begin("BayesMetropolisHastings"); TODO: revisit timing output
//std::cout << "proc " << m_env.fullRank() << ", HERE sip 000" << std::endl;
m_env.fullComm().Barrier();
//std::cout << "proc " << m_env.fullRank() << ", HERE sip 001" << std::endl;
m_env.fullComm().syncPrintDebugMsg("Entering StatisticalInverseProblem<P_V,P_M>::solveWithBayesMetropolisHastings()",1,3000000);
if (m_optionsObj->m_computeSolution == false) {
if ((m_env.subDisplayFile())) {
*m_env.subDisplayFile() << "In StatisticalInverseProblem<P_V,P_M>::solveWithBayesMetropolisHastings()"
<< ": avoiding solution, as requested by user"
<< std::endl;
}
return;
}
if ((m_env.subDisplayFile())) {
*m_env.subDisplayFile() << "In StatisticalInverseProblem<P_V,P_M>::solveWithBayesMetropolisHastings()"
<< ": computing solution, as requested by user"
<< std::endl;
}
queso_require_equal_to_msg(m_priorRv.imageSet().vectorSpace().dimLocal(), initialValues.sizeLocal(), "'m_priorRv' and 'initialValues' should have equal dimensions");
if (initialProposalCovMatrix) {
queso_require_equal_to_msg(m_priorRv.imageSet().vectorSpace().dimLocal(), initialProposalCovMatrix->numRowsLocal(), "'m_priorRv' and 'initialProposalCovMatrix' should have equal dimensions");
queso_require_equal_to_msg(initialProposalCovMatrix->numCols(), initialProposalCovMatrix->numRowsGlobal(), "'initialProposalCovMatrix' should be a square matrix");
}
if (m_mlSampler ) delete m_mlSampler;
if (m_mhSeqGenerator ) delete m_mhSeqGenerator;
if (m_solutionRealizer) delete m_solutionRealizer;
if (m_subSolutionCdf ) delete m_subSolutionCdf;
if (m_subSolutionMdf ) delete m_subSolutionMdf;
if (m_solutionPdf ) delete m_solutionPdf;
if (m_solutionDomain ) delete m_solutionDomain;
P_V numEvaluationPointsVec(m_priorRv.imageSet().vectorSpace().zeroVector());
numEvaluationPointsVec.cwSet(250.);
// Compute output pdf up to a multiplicative constant: Bayesian approach
m_solutionDomain = InstantiateIntersection(m_priorRv.pdf().domainSet(),m_likelihoodFunction.domainSet());
m_solutionPdf = new BayesianJointPdf<P_V,P_M>(m_optionsObj->m_prefix.c_str(),
m_priorRv.pdf(),
m_likelihoodFunction,
1.,
*m_solutionDomain);
m_postRv.setPdf(*m_solutionPdf);
m_chain = new SequenceOfVectors<P_V,P_M>(m_postRv.imageSet().vectorSpace(),0,m_optionsObj->m_prefix+"chain");
// Decide whether or not to create a MetropolisHastingsSG instance from the
// user-provided initial seed, or use the user-provided seed for a
// deterministic optimisation instead and seed the chain with the result of
// the optimisation
if (this->m_seedWithMAPEstimator) {
// Do optimisation before sampling
GslOptimizer optimizer(*m_solutionPdf);
optimizer.setInitialPoint(dynamic_cast<const GslVector &>(initialValues));
optimizer.minimize();
// Compute output realizer: Metropolis-Hastings approach
m_mhSeqGenerator = new MetropolisHastingsSG<P_V, P_M>(
m_optionsObj->m_prefix.c_str(), alternativeOptionsValues,
m_postRv, optimizer.minimizer(), initialProposalCovMatrix);
}
else {
// Compute output realizer: Metropolis-Hastings approach
m_mhSeqGenerator = new MetropolisHastingsSG<P_V, P_M>(
m_optionsObj->m_prefix.c_str(), alternativeOptionsValues, m_postRv,
initialValues, initialProposalCovMatrix);
}
m_logLikelihoodValues = new ScalarSequence<double>(m_env, 0,
m_optionsObj->m_prefix +
"logLike");
m_logTargetValues = new ScalarSequence<double>(m_env, 0,
m_optionsObj->m_prefix +
"logTarget");
// m_logLikelihoodValues and m_logTargetValues may be NULL
m_mhSeqGenerator->generateSequence(*m_chain, m_logLikelihoodValues,
m_logTargetValues);
m_solutionRealizer = new SequentialVectorRealizer<P_V,P_M>(m_optionsObj->m_prefix.c_str(),
*m_chain);
m_postRv.setRealizer(*m_solutionRealizer);
m_env.fullComm().syncPrintDebugMsg("In StatisticalInverseProblem<P_V,P_M>::solveWithBayesMetropolisHastings(), code place 1",3,3000000);
//m_env.fullComm().Barrier();
// Compute output mdf: uniform sampling approach
#ifdef UQ_ALSO_COMPUTE_MDFS_WITHOUT_KDE
m_subMdfGrids = new ArrayOfOneDGrids <P_V,P_M>((m_optionsObj->m_prefix+"Mdf_").c_str(),m_postRv.imageSet().vectorSpace());
m_subMdfValues = new ArrayOfOneDTables<P_V,P_M>((m_optionsObj->m_prefix+"Mdf_").c_str(),m_postRv.imageSet().vectorSpace());
m_chain->subUniformlySampledMdf(numEvaluationPointsVec, // input
*m_subMdfGrids, // output
*m_subMdfValues); // output
m_subSolutionMdf = new SampledVectorMdf<P_V,P_M>(m_optionsObj->m_prefix.c_str(),
*m_subMdfGrids,
*m_subMdfValues);
m_postRv.setMdf(*m_subSolutionMdf);
if ((m_optionsObj->m_dataOutputFileName != UQ_SIP_FILENAME_FOR_NO_FILE ) &&
(m_optionsObj->m_dataOutputAllowedSet.find(m_env.subId()) != m_optionsObj->m_dataOutputAllowedSet.end())) {
if (m_env.subRank() == 0) {
// Write data output file
if (m_env.subDisplayFile()) {
*m_env.subDisplayFile() << "Opening data output file '" << m_optionsObj->m_dataOutputFileName
<< "' for calibration problem with problem with prefix = " << m_optionsObj->m_prefix
<< std::endl;
}
// Open file
// Always write at the end of an eventual pre-existing file
std::ofstream* ofsvar = new std::ofstream((m_optionsObj->m_dataOutputFileName+"_sub"+m_env.subIdString()+".m").c_str(), std::ofstream::out | std::ofstream::in | std::ofstream::ate);
if ((ofsvar == NULL ) ||
(ofsvar->is_open() == false)) {
delete ofsvar;
ofsvar = new std::ofstream((m_optionsObj->m_dataOutputFileName+"_sub"+m_env.subIdString()+".m").c_str(), std::ofstream::out | std::ofstream::trunc);
}
queso_require_msg((ofsvar && ofsvar->is_open()), "failed to open file");
m_postRv.mdf().print(*ofsvar);
// Close file
//ofsvar->close();
delete ofsvar;
if (m_env.subDisplayFile()) {
*m_env.subDisplayFile() << "Closed data output file '" << m_optionsObj->m_dataOutputFileName
<< "' for calibration problem with problem with prefix = " << m_optionsObj->m_prefix
<< std::endl;
}
}
}
#endif
if (m_env.subDisplayFile()) {
*m_env.subDisplayFile() << std::endl;
}
m_env.fullComm().syncPrintDebugMsg("Leaving StatisticalInverseProblem<P_V,P_M>::solveWithBayesMetropolisHastings()",1,3000000);
m_env.fullComm().Barrier();
// grvy_timer_end("BayesMetropolisHastings"); TODO: revisit timers
return;
}
void
StatisticalInverseProblem<P_V,P_M>::solveWithBayesMLSampling()
{
m_env.fullComm().Barrier();
m_env.fullComm().syncPrintDebugMsg("Entering StatisticalInverseProblem<P_V,P_M>::solveWithBayesMLSampling()",1,3000000);
if (m_optionsObj->m_computeSolution == false) {
if ((m_env.subDisplayFile())) {
*m_env.subDisplayFile() << "In StatisticalInverseProblem<P_V,P_M>::solveWithBayesMLSampling()"
<< ": avoiding solution, as requested by user"
<< std::endl;
}
return;
}
if ((m_env.subDisplayFile())) {
*m_env.subDisplayFile() << "In StatisticalInverseProblem<P_V,P_M>::solveWithBayesMLSampling()"
<< ": computing solution, as requested by user"
<< std::endl;
}
if (m_mlSampler ) delete m_mlSampler;
if (m_mhSeqGenerator ) delete m_mhSeqGenerator;
if (m_solutionRealizer) delete m_solutionRealizer;
if (m_subSolutionCdf ) delete m_subSolutionCdf;
if (m_subSolutionMdf ) delete m_subSolutionMdf;
if (m_solutionPdf ) delete m_solutionPdf;
if (m_solutionDomain ) delete m_solutionDomain;
P_V numEvaluationPointsVec(m_priorRv.imageSet().vectorSpace().zeroVector());
numEvaluationPointsVec.cwSet(250.);
// Compute output pdf up to a multiplicative constant: Bayesian approach
m_solutionDomain = InstantiateIntersection(m_priorRv.pdf().domainSet(),m_likelihoodFunction.domainSet());
m_solutionPdf = new BayesianJointPdf<P_V,P_M>(m_optionsObj->m_prefix.c_str(),
m_priorRv.pdf(),
m_likelihoodFunction,
1.,
*m_solutionDomain);
m_postRv.setPdf(*m_solutionPdf);
// Compute output realizer: ML approach
m_chain = new SequenceOfVectors<P_V,P_M>(m_postRv.imageSet().vectorSpace(),0,m_optionsObj->m_prefix+"chain");
m_mlSampler = new MLSampling<P_V,P_M>(m_optionsObj->m_prefix.c_str(),
//m_postRv,
m_priorRv,
m_likelihoodFunction);
// initialValues,
// initialProposalCovMatrix);
m_mlSampler->generateSequence(*m_chain,
NULL,
NULL);
m_solutionRealizer = new SequentialVectorRealizer<P_V,P_M>(m_optionsObj->m_prefix.c_str(),
*m_chain);
m_postRv.setRealizer(*m_solutionRealizer);
if (m_env.subDisplayFile()) {
*m_env.subDisplayFile() << std::endl;
}
m_env.fullComm().syncPrintDebugMsg("Leaving StatisticalInverseProblem<P_V,P_M>::solveWithBayesMLSampling()",1,3000000);
m_env.fullComm().Barrier();
return;
}
void
StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo(
const McOptionsValues* alternativeOptionsValues)
{
m_env.fullComm().Barrier();
m_env.fullComm().syncPrintDebugMsg("Entering StatisticalForwardProblem<P_V,P_M>::solveWithMonteCarlo()",1,3000000);
if (m_optionsObj->m_computeSolution == false) {
if ((m_env.subDisplayFile())) {
*m_env.subDisplayFile() << "In StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo()"
<< ": avoiding solution, as requested by user"
<< std::endl;
}
return;
}
if ((m_env.subDisplayFile())) {
*m_env.subDisplayFile() << "In StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo()"
<< ": computing solution, as requested by user"
<< std::endl;
}
if (m_solutionPdf ) delete m_solutionPdf;
#ifdef QUESO_COMPUTES_EXTRA_POST_PROCESSING_STATISTICS
if (m_unifiedSolutionCdf) delete m_unifiedSolutionCdf;
if (m_unifiedCdfValues ) delete m_unifiedCdfValues;
if (m_unifiedCdfGrids ) delete m_unifiedCdfGrids;
if (m_subSolutionCdf ) delete m_subSolutionCdf;
if (m_subCdfValues ) delete m_subCdfValues;
if (m_subCdfGrids ) delete m_subCdfGrids;
if (m_subSolutionMdf ) delete m_subSolutionMdf;
#endif
#ifdef UQ_ALSO_COMPUTE_MDFS_WITHOUT_KDE
if (m_subMdfValues ) delete m_subMdfValues;
if (m_subMdfGrids ) delete m_subMdfGrids;
#endif
if (m_solutionRealizer ) delete m_solutionRealizer;
if (m_mcSeqGenerator ) delete m_mcSeqGenerator;
if (m_qoiChain) {
m_qoiChain->clear();
delete m_qoiChain;
}
if (m_paramChain) {
m_paramChain->clear();
delete m_paramChain;
}
Q_V numEvaluationPointsVec(m_qoiRv.imageSet().vectorSpace().zeroVector());
numEvaluationPointsVec.cwSet(250.);
// Compute output realizer: Monte Carlo approach
m_paramChain = new SequenceOfVectors<P_V,P_M>(m_paramRv.imageSet().vectorSpace(),0,m_optionsObj->m_prefix+"paramChain");
m_qoiChain = new SequenceOfVectors<Q_V,Q_M>(m_qoiRv.imageSet().vectorSpace(), 0,m_optionsObj->m_prefix+"qoiChain" );
m_mcSeqGenerator = new MonteCarloSG<P_V,P_M,Q_V,Q_M>(m_optionsObj->m_prefix.c_str(),
alternativeOptionsValues,
m_paramRv,
m_qoiFunction);
//m_qoiRv);
m_mcSeqGenerator->generateSequence(*m_paramChain,
*m_qoiChain);
m_solutionRealizer = new SequentialVectorRealizer<Q_V,Q_M>((m_optionsObj->m_prefix+"Qoi").c_str(),
*m_qoiChain);
m_qoiRv.setRealizer(*m_solutionRealizer);
// Compute output mdf: uniform sampling approach
#ifdef UQ_ALSO_COMPUTE_MDFS_WITHOUT_KDE
m_subMdfGrids = new ArrayOfOneDGrids <Q_V,Q_M>((m_optionsObj->m_prefix+"QoiMdf_").c_str(),m_qoiRv.imageSet().vectorSpace());
m_subMdfValues = new ArrayOfOneDTables<Q_V,Q_M>((m_optionsObj->m_prefix+"QoiMdf_").c_str(),m_qoiRv.imageSet().vectorSpace());
m_qoiChain->subUniformlySampledMdf(numEvaluationPointsVec, // input
*m_subMdfGrids, // output
*m_subMdfValues); // output
m_subSolutionMdf = new SampledVectorMdf<Q_V,Q_M>((m_optionsObj->m_prefix+"Qoi").c_str(),
*m_subMdfGrids,
*m_subMdfValues);
m_qoiRv.setMdf(*m_subSolutionMdf);
#endif
// Compute output cdf: uniform sampling approach
#ifdef QUESO_COMPUTES_EXTRA_POST_PROCESSING_STATISTICS
std::string subCoreName_qoiCdf(m_optionsObj->m_prefix+ "QoiCdf_");
std::string uniCoreName_qoiCdf(m_optionsObj->m_prefix+"unifQoiCdf_");
if (m_env.numSubEnvironments() == 1) subCoreName_qoiCdf = uniCoreName_qoiCdf;
std::string subCoreName_solutionCdf(m_optionsObj->m_prefix+ "Qoi");
std::string uniCoreName_solutionCdf(m_optionsObj->m_prefix+"unifQoi");
if (m_env.numSubEnvironments() == 1) subCoreName_solutionCdf = uniCoreName_solutionCdf;
m_subCdfGrids = new ArrayOfOneDGrids <Q_V,Q_M>(subCoreName_qoiCdf.c_str(),m_qoiRv.imageSet().vectorSpace());
m_subCdfValues = new ArrayOfOneDTables<Q_V,Q_M>(subCoreName_qoiCdf.c_str(),m_qoiRv.imageSet().vectorSpace());
m_qoiChain->subUniformlySampledCdf(numEvaluationPointsVec, // input
*m_subCdfGrids, // output
*m_subCdfValues); // output
m_subSolutionCdf = new SampledVectorCdf<Q_V,Q_M>(subCoreName_solutionCdf.c_str(),
*m_subCdfGrids,
*m_subCdfValues);
m_qoiRv.setSubCdf(*m_subSolutionCdf);
// Compute unified cdf if necessary
if (m_env.numSubEnvironments() == 1) {
m_qoiRv.setUnifiedCdf(*m_subSolutionCdf);
}
else {
m_unifiedCdfGrids = new ArrayOfOneDGrids <Q_V,Q_M>(uniCoreName_qoiCdf.c_str(),m_qoiRv.imageSet().vectorSpace());
m_unifiedCdfValues = new ArrayOfOneDTables<Q_V,Q_M>(uniCoreName_qoiCdf.c_str(),m_qoiRv.imageSet().vectorSpace());
m_qoiChain->unifiedUniformlySampledCdf(numEvaluationPointsVec, // input
*m_unifiedCdfGrids, // output
*m_unifiedCdfValues); // output
m_unifiedSolutionCdf = new SampledVectorCdf<Q_V,Q_M>(uniCoreName_solutionCdf.c_str(),
*m_unifiedCdfGrids,
*m_unifiedCdfValues);
m_qoiRv.setUnifiedCdf(*m_unifiedSolutionCdf);
}
#endif
// Compute (just unified one) covariance matrix, if requested
// Compute (just unified one) correlation matrix, if requested
P_M* pqCovarianceMatrix = NULL;
P_M* pqCorrelationMatrix = NULL;
if (m_optionsObj->m_computeCovariances || m_optionsObj->m_computeCorrelations) {
if (m_env.subDisplayFile()) {
*m_env.subDisplayFile() << "In StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo()"
<< ", prefix = " << m_optionsObj->m_prefix
<< ": instantiating cov and corr matrices"
<< std::endl;
}
// Only compute correlations on the inter0Comm communicator
if (m_env.subRank() == 0) {
pqCovarianceMatrix = new P_M(m_env,
m_paramRv.imageSet().vectorSpace().map(), // number of rows
m_qoiRv.imageSet().vectorSpace().dimGlobal()); // number of cols
pqCorrelationMatrix = new P_M(m_env,
m_paramRv.imageSet().vectorSpace().map(), // number of rows
m_qoiRv.imageSet().vectorSpace().dimGlobal()); // number of cols
ComputeCovCorrMatricesBetweenVectorSequences(*m_paramChain,
*m_qoiChain,
std::min(m_paramRv.realizer().subPeriod(),m_qoiRv.realizer().subPeriod()), // FIX ME: might be INFINITY
*pqCovarianceMatrix,
*pqCorrelationMatrix);
}
}
// Write data out
if (m_env.subDisplayFile()) {
if (pqCovarianceMatrix ) {
*m_env.subDisplayFile() << "In StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo()"
<< ", prefix = " << m_optionsObj->m_prefix
<< ": contents of covariance matrix are\n" << *pqCovarianceMatrix
<< std::endl;
}
if (pqCorrelationMatrix) {
*m_env.subDisplayFile() << "In StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo()"
<< ", prefix = " << m_optionsObj->m_prefix
<< ": contents of correlation matrix are\n" << *pqCorrelationMatrix
<< std::endl;
}
}
// Open data output file
if (m_env.subDisplayFile()) {
*m_env.subDisplayFile() << "In StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo()"
<< ", prefix = " << m_optionsObj->m_prefix
<< ": checking necessity of opening data output file '" << m_optionsObj->m_dataOutputFileName
<< "'"
<< std::endl;
}
FilePtrSetStruct filePtrSet;
if (m_env.openOutputFile(m_optionsObj->m_dataOutputFileName,
UQ_FILE_EXTENSION_FOR_MATLAB_FORMAT, // Yes, always ".m"
m_optionsObj->m_dataOutputAllowedSet,
false,
filePtrSet)) {
#ifdef UQ_ALSO_COMPUTE_MDFS_WITHOUT_KDE
m_qoiRv.mdf().print(*filePtrSet.ofsVar);
#endif
#ifdef QUESO_COMPUTES_EXTRA_POST_PROCESSING_STATISTICS
*filePtrSet.ofsVar << m_qoiRv.subCdf();
#endif
//if (pqCovarianceMatrix ) *filePtrSet.ofsVar << *pqCovarianceMatrix; // FIX ME: output matrix in matlab format
//if (pqCorrelationMatrix) *filePtrSet.ofsVar << *pqCorrelationMatrix; // FIX ME: output matrix in matlab format
// Write unified cdf if necessary
#ifdef QUESO_COMPUTES_EXTRA_POST_PROCESSING_STATISTICS
if (m_env.numSubEnvironments() > 1) {
if (m_qoiRv.imageSet().vectorSpace().numOfProcsForStorage() == 1) {
if (m_env.inter0Rank() == 0) {
*filePtrSet.ofsVar << m_qoiRv.unifiedCdf(); //*m_unifiedSolutionCdf;
}
}
else {
queso_error_msg("unified cdf writing, parallel vectors not supported yet");
}
}
#endif
// Close data output file
m_env.closeFile(filePtrSet,UQ_FILE_EXTENSION_FOR_MATLAB_FORMAT);
if (m_env.subDisplayFile()) {
*m_env.subDisplayFile() << "In StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo()"
<< ", prefix = " << m_optionsObj->m_prefix
<< ": closed data output file '" << m_optionsObj->m_dataOutputFileName
<< "'"
<< std::endl;
}
}
if (m_env.subDisplayFile()) {
*m_env.subDisplayFile() << std::endl;
}
if (pqCovarianceMatrix ) delete pqCovarianceMatrix;
if (pqCorrelationMatrix) delete pqCorrelationMatrix;
m_env.fullComm().syncPrintDebugMsg("Leaving StatisticalForwardProblem<P_V,P_M>::solveWithMonteCarlo()",1,3000000);
m_env.fullComm().Barrier();
return;
}
