// Return a TF-IDF sparse vector for some column (phenotype).
sparse_document_vector PhenomatrixBase::document_vector(uint j, const PhenomatrixPair* const idf_owner) const {
id_set j_obs = observations(j);
// This is not the cleanest container type to use here. Initially, I had set
// the size to row_ids_.size(), but that was problematic because certain genes (esp. for At)
// had IDs way above that size. These were getting lost! Now, it sets size
// as the maximum row id.
// compressed_vector is a component of compressed_matrix, which uses "Compressed Row Storage"
// from NetLib: http://www.netlib.org/linalg/html_templates/node91.html
// Based on that piece of information, it looks as if empty rows do not matter
// at all. As such, it should be perfectly safe to set an insanely high size,
// though I wonder why this type needs one at all.
// Oops. What is the type on unbounded_array? I have a question pending on stackoverflow,
// but for now I'll leave this as is.
sparse_document_vector v(*(row_ids_.rbegin()) + 1, j_obs.size());
for (id_set::const_iterator it = j_obs.begin(); it != j_obs.end(); ++it) {
//cerr << "phenomatrix_base.cpp: document_vector: IDF for " << *it << "\t" << idf_owner->inverse_document_frequency(*it) << "\tdenom: " << j_obs.size() << endl;
double d = idf_owner->inverse_document_frequency(*it) / (double)(j_obs.size());
if (d > 0.0) v.insert_element(*it, d); // faster than v[*it], I speculate based on: http://www.guwi17.de/ublas/matrix_sparse_usage.html
// cerr << "v: " << *it << "\t" << const_castv[*it] << endl; // REMOVE ME
}
/* cerr << "Next:" << endl;
for (sparse_document_vector::const_iterator it = v.begin(); it != v.end(); ++it) {
cerr << "v: " << it.index() << "\t" << *it << endl; // REMOVE ME
}
cerr << "j_obs size = " << j_obs.size() << endl; */
return v;
}
void
cluster::seeder::forgy(size_t k, InIt begin, InIt end, OutIt out)
{
std::vector<Vector<T, D>> result(k);
std::vector<Vector<T, D>> observations(begin, end);
const size_t n = observations.size();
for (size_t i = 0; i < k; ++i)
{
result.at(i) = observations[random::int_in_range<size_t>(0, n - 1)];
}
std::copy_n(result.begin(), k, out);
}
void
cluster::seeder::random_partition(size_t k, InIt begin, InIt end, OutIt out)
{
std::vector<Vector<T, D>> result(k);
std::vector<size_t> assigned_observation_counts(k);
std::vector<Vector<T, D>> observations(begin, end);
const size_t n = observations.size();
for (size_t i = 0; i < n; ++i)
{
const size_t cls = random::int_in_range<size_t>(0, k - 1);
result.at(cls) += observations.at(i);
++ assigned_observation_counts.at(cls);
}
for (size_t i = 0; i < k; ++i)
{
result.at(i) = result.at(i).scale
(
1.0f /
static_cast<float>(assigned_observation_counts.at(i))
);
}
std::copy_n(result.begin(), k, out);
}
//------------------------------------------------------------------------------------------------------------------
bool Strategy::observe(Arena* _a, std::vector<Target::Desc>& _dst, float _dt) {
// Gather observations
std::vector<TargetEstimator::Observation> observations(_a->agents().size());
bool found = false;
for (unsigned i = 0; i < _a->agents().size(); ++i) {
auto& o = observations[i];
auto r = _a->agents()[i];
o.seenTargets.clear();
o.area = r->viewArea();
if(r->scanTerrain(o.seenTargets) > 0) { // target found
found = true;
_dst.insert(_dst.end(), o.seenTargets.begin(), o.seenTargets.end());
}
}
// Process observations
for(auto estimator : mEstimators) {
for(auto o : observations)
estimator->processObservation(o);
// Update estimates
estimator->updateEstimates(_dt);
}
return found;
}
int main(int argc, char ** argv) {
MPI_Init(&argc, &argv);
QUESO::FullEnvironment env(MPI_COMM_WORLD, argv[1], "", NULL);
QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env,
"param_", 2, NULL);
double min_val = 0.0;
double max_val = 1.0;
QUESO::GslVector paramMins(paramSpace.zeroVector());
QUESO::GslVector paramMaxs(paramSpace.zeroVector());
// Model parameter between 0 and 1
paramMins[0] = 0.0;
paramMaxs[0] = 1.0;
// Hyperparameter (multiplicative coefficient of observational error
// covariance matrix) between 0.0 and \infty
paramMins[1] = 0.0;
paramMaxs[1] = INFINITY;
QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_",
paramSpace, paramMins, paramMaxs);
QUESO::UniformVectorRV<QUESO::GslVector, QUESO::GslMatrix> priorRv("prior_",
paramDomain);
// Set up observation space
QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> obsSpace(env,
"obs_", 2, NULL);
// Fill up observation vector
QUESO::GslVector observations(obsSpace.zeroVector());
observations[0] = 1.0;
observations[1] = 1.0;
// Fill up covariance 'matrix'
QUESO::GslMatrix covariance(obsSpace.zeroVector());
covariance(0, 0) = 1.0;
covariance(0, 1) = 0.0;
covariance(1, 0) = 0.0;
covariance(1, 1) = 1.0;
// Pass in observations to Gaussian likelihood object
Likelihood<QUESO::GslVector, QUESO::GslMatrix> lhood("llhd_", paramDomain,
observations, covariance);
QUESO::GenericVectorRV<QUESO::GslVector, QUESO::GslMatrix>
postRv("post_", paramSpace);
QUESO::StatisticalInverseProblem<QUESO::GslVector, QUESO::GslMatrix>
ip("", NULL, priorRv, lhood, postRv);
QUESO::GslVector paramInitials(paramSpace.zeroVector());
paramInitials[0] = 0.0;
QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector());
for (unsigned int i = 0; i < 1; i++) {
proposalCovMatrix(i, i) = 0.1;
}
ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix);
MPI_Finalize();
return 0;
}
int main(int argc, char ** argv) {
MPI_Init(&argc, &argv);
QUESO::FullEnvironment env(MPI_COMM_WORLD, "test_gaussian_likelihoods/queso_input.txt", "", NULL);
QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env,
"param_", 1, NULL);
double min_val = -INFINITY;
double max_val = INFINITY;
QUESO::GslVector paramMins(paramSpace.zeroVector());
paramMins.cwSet(min_val);
QUESO::GslVector paramMaxs(paramSpace.zeroVector());
paramMaxs.cwSet(max_val);
QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_",
paramSpace, paramMins, paramMaxs);
// Set up observation space
QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> obsSpace(env,
"obs_", 2, NULL);
// Fill up observation vector
QUESO::GslVector observations(obsSpace.zeroVector());
observations[0] = 1.0;
observations[1] = 1.0;
// Fill up covariance 'matrix'
QUESO::GslVector covariance(obsSpace.zeroVector());
covariance[0] = 1.0;
covariance[1] = 2.0;
// Pass in observations to Gaussian likelihood object
Likelihood<QUESO::GslVector, QUESO::GslMatrix> lhood("llhd_", paramDomain,
observations, covariance);
double lhood_value;
double truth_value;
QUESO::GslVector point(paramSpace.zeroVector());
point[0] = 0.0;
lhood_value = lhood.actualValue(point, NULL, NULL, NULL, NULL);
truth_value = std::exp(-3.0);
if (std::abs(lhood_value - truth_value) > TOL) {
std::cerr << "Scalar Gaussian test case failure." << std::endl;
std::cerr << "Computed likelihood value is: " << lhood_value << std::endl;
std::cerr << "Likelihood value should be: " << truth_value << std::endl;
queso_error();
}
point[0] = -2.0;
lhood_value = lhood.actualValue(point, NULL, NULL, NULL, NULL);
truth_value = 1.0;
if (std::abs(lhood_value - truth_value) > TOL) {
std::cerr << "Scalar Gaussian test case failure." << std::endl;
std::cerr << "Computed likelihood value is: " << lhood_value << std::endl;
std::cerr << "Likelihood value should be: " << truth_value << std::endl;
queso_error();
}
MPI_Finalize();
return 0;
}
int main(int argc, char ** argv) {
#ifdef QUESO_HAS_MPI
MPI_Init(&argc, &argv);
QUESO::FullEnvironment env(MPI_COMM_WORLD, argv[1], "", NULL);
#else
QUESO::FullEnvironment env(argv[1], "", NULL);
#endif
QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env,
"param_", 1, NULL);
double min_val = 0.0;
double max_val = 1.0;
QUESO::GslVector paramMins(paramSpace.zeroVector());
paramMins.cwSet(min_val);
QUESO::GslVector paramMaxs(paramSpace.zeroVector());
paramMaxs.cwSet(max_val);
QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_",
paramSpace, paramMins, paramMaxs);
QUESO::UniformVectorRV<QUESO::GslVector, QUESO::GslMatrix> priorRv("prior_",
paramDomain);
// Set up observation space
QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> obsSpace(env,
"obs_", 2, NULL);
// Fill up observation vector
QUESO::GslVector observations(obsSpace.zeroVector());
observations[0] = 1.0;
observations[1] = 1.0;
// Pass in observations to Gaussian likelihood object
Likelihood<QUESO::GslVector, QUESO::GslMatrix> lhood("llhd_", paramDomain,
observations, 1.0);
QUESO::GenericVectorRV<QUESO::GslVector, QUESO::GslMatrix>
postRv("post_", paramSpace);
QUESO::StatisticalInverseProblem<QUESO::GslVector, QUESO::GslMatrix>
ip("", NULL, priorRv, lhood, postRv);
QUESO::GslVector paramInitials(paramSpace.zeroVector());
paramInitials[0] = 0.0;
QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector());
for (unsigned int i = 0; i < 1; i++) {
proposalCovMatrix(i, i) = 0.1;
}
ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix);
#ifdef QUESO_HAS_MPI
MPI_Finalize();
#endif
return 0;
}
int main(int argc, char ** argv) {
std::string inputFileName = "test_gaussian_likelihoods/queso_input.txt";
const char * test_srcdir = std::getenv("srcdir");
if (test_srcdir)
inputFileName = test_srcdir + ('/' + inputFileName);
#ifdef QUESO_HAS_MPI
MPI_Init(&argc, &argv);
QUESO::FullEnvironment env(MPI_COMM_WORLD, inputFileName, "", NULL);
#else
QUESO::FullEnvironment env(inputFileName, "", NULL);
#endif
QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> paramSpace(env,
"param_", 1, NULL);
double min_val = -INFINITY;
double max_val = INFINITY;
QUESO::GslVector paramMins(paramSpace.zeroVector());
paramMins.cwSet(min_val);
QUESO::GslVector paramMaxs(paramSpace.zeroVector());
paramMaxs.cwSet(max_val);
QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> paramDomain("param_",
paramSpace, paramMins, paramMaxs);
// Set up observation space
QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> obsSpace(env,
"obs_", 1, NULL);
// Fill up observation vector
QUESO::GslVector observations(obsSpace.zeroVector());
observations[0] = 1.0;
// Pass in observations to Gaussian likelihood object
Likelihood<QUESO::GslVector, QUESO::GslMatrix> lhood("llhd_", paramDomain,
observations, 1.0);
double lhood_value;
double truth_value;
QUESO::GslVector point(paramSpace.zeroVector());
point[0] = 0.0;
lhood_value = lhood.actualValue(point, NULL, NULL, NULL, NULL);
truth_value = std::exp(-2.0);
if (std::abs(lhood_value - truth_value) > TOL) {
std::cerr << "Scalar Gaussian test case failure." << std::endl;
std::cerr << "Computed likelihood value is: " << lhood_value << std::endl;
std::cerr << "Likelihood value should be: " << truth_value << std::endl;
queso_error();
}
point[0] = -2.0;
lhood_value = lhood.actualValue(point, NULL, NULL, NULL, NULL);
truth_value = 1.0;
if (std::abs(lhood_value - truth_value) > TOL) {
std::cerr << "Scalar Gaussian test case failure." << std::endl;
std::cerr << "Computed likelihood value is: " << lhood_value << std::endl;
std::cerr << "Likelihood value should be: " << truth_value << std::endl;
queso_error();
}
#ifdef QUESO_HAS_MPI
MPI_Finalize();
#endif
return 0;
}
