SGVector< float64_t > CFactorGraphModel::get_joint_feature_vector(int32_t feat_idx, CStructuredData* y) { // factor graph instance CFactorGraphFeatures* mf = CFactorGraphFeatures::obtain_from_generic(m_features); CFactorGraph* fg = mf->get_sample(feat_idx); // ground truth states CFactorGraphObservation* fg_states = CFactorGraphObservation::obtain_from_generic(y); SGVector<int32_t> states = fg_states->get_data(); // initialize psi SGVector<float64_t> psi(get_dim()); psi.zero(); // construct unnormalized psi CDynamicObjectArray* facs = fg->get_factors(); for (int32_t fi = 0; fi < facs->get_num_elements(); ++fi) { CFactor* fac = dynamic_cast<CFactor*>(facs->get_element(fi)); CTableFactorType* ftype = fac->get_factor_type(); int32_t id = ftype->get_type_id(); SGVector<int32_t> w_map = get_params_mapping(id); ASSERT(w_map.size() == ftype->get_w_dim()); SGVector<float64_t> dat = fac->get_data(); int32_t dat_size = dat.size(); ASSERT(w_map.size() == dat_size * ftype->get_num_assignments()); int32_t ei = ftype->index_from_universe_assignment(states, fac->get_variables()); for (int32_t di = 0; di < dat_size; di++) psi[w_map[ei*dat_size + di]] += dat[di]; SG_UNREF(ftype); SG_UNREF(fac); } // negation (-E(x,y) = <w,phi(x,y)>) psi.scale(-1.0); SG_UNREF(facs); SG_UNREF(fg); return psi; }
SGMatrix<float64_t> CLogDetEstimator::sample_without_averaging( index_t num_estimates) { SG_DEBUG("Entering...\n") REQUIRE(m_operator_log, "Operator function is NULL\n"); // call the precompute of operator function to compute all prerequisites m_operator_log->precompute(); REQUIRE(m_trace_sampler, "Trace sampler is NULL\n"); // call the precompute of the sampler m_trace_sampler->precompute(); // for storing the aggregators that submit_jobs return CDynamicObjectArray aggregators; index_t num_trace_samples=m_trace_sampler->get_num_samples(); for (index_t i=0; i<num_estimates; ++i) { for (index_t j=0; j<num_trace_samples; ++j) { // get the trace sampler vector SGVector<float64_t> s=m_trace_sampler->sample(j); // create jobs with the sample vector and store the aggregator CJobResultAggregator* agg=m_operator_log->submit_jobs(s); aggregators.append_element(agg); SG_UNREF(agg); } } REQUIRE(m_computation_engine, "Computation engine is NULL\n"); // wait for all the jobs to be completed m_computation_engine->wait_for_all(); // the samples matrix which stores the estimates without averaging // dimension: number of trace samples x number of log-det estimates SGMatrix<float64_t> samples(num_trace_samples, num_estimates); // use the aggregators to find the final result int32_t num_aggregates=aggregators.get_num_elements(); for (int32_t i=0; i<num_aggregates; ++i) { CJobResultAggregator* agg=dynamic_cast<CJobResultAggregator*> (aggregators.get_element(i)); if (!agg) SG_ERROR("Element is not CJobResultAggregator type!\n"); // call finalize on all the aggregators agg->finalize(); CScalarResult<float64_t>* r=dynamic_cast<CScalarResult<float64_t>*> (agg->get_final_result()); if (!r) SG_ERROR("Result is not CScalarResult type!\n"); // its important that we don't just unref the result here index_t idx_row=i%num_trace_samples; index_t idx_col=i/num_trace_samples; samples(idx_row, idx_col)=r->get_result(); SG_UNREF(agg); } // clear all aggregators aggregators.clear_array(); SG_DEBUG("Leaving\n") return samples; }