oracle.tcc

Go to the documentation of this file.

 
#if !defined(ULTRA_ORACLE_H)
#  error "Don't include this file directly, include the specific .h instead"
#endif
 
#if !defined(ULTRA_ORACLE_TCC)
#define      ULTRA_ORACLE_TCC
 
// ***********************************************************************
// *  basic_reg_oracle                                                   *
// ***********************************************************************
 
template<Individual P, bool S>
const std::string basic_reg_oracle<P, S>::SERIALIZE_ID(
  gp::Team<P> ? "TEAM_REG_ORACLE" : "REG_ORACLE");

template<Individual P, bool S>
basic_reg_oracle<P, S>::basic_reg_oracle(const P &prg)
  : internal::reg_oracle_storage<P, S>(prg)
{
  Expects(!prg.empty());
 
  Ensures(is_valid());
}

template<Individual P, bool S>
basic_reg_oracle<P, S>::basic_reg_oracle(std::istream &in,
                                         const symbol_set &ss)
  : internal::reg_oracle_storage<P, S>(in, ss)
{
  static_assert(S, "reg_oracle requires storage for de-serialization");
 
  Ensures(is_valid());
}

template<Individual P, bool S>
value_t basic_reg_oracle<P, S>::operator()(const std::vector<value_t> &e) const
{
  if constexpr (!gp::Team<P>)
    return this->run(e);
  else
  {
    D_DOUBLE sum(0), count(0);
 
    for (const auto &core : this->team_)
    {
      const auto res(core.run(e));
 
      if (has_value(res))
      {
        sum += std::get<D_DOUBLE>(res);
        ++count;
      }
    }
 
    if (count > 0.0)
      return sum / count;
 
    return {};
  }
}

template<Individual P, bool S>
classification_result basic_reg_oracle<P, S>::tag(
  const std::vector<value_t> &) const
{
  throw std::logic_error("tag() called on regression oracle");
}

template<Individual P, bool S>
std::string basic_reg_oracle<P, S>::name(const value_t &a) const
{
  return lexical_cast<std::string>(a);
}

template<Individual P, bool S>
bool basic_reg_oracle<P, S>::is_valid() const
{
  return internal::reg_oracle_storage<P, S>::is_valid();
}

template<Individual P, bool S>
bool basic_reg_oracle<P, S>::save(std::ostream &out) const
{
  return internal::reg_oracle_storage<P, S>::save(out);
}
 
// ***********************************************************************
// *  reg_oracle_adaptor                                                 *
// ***********************************************************************

template<RegressionPredictor O>
reg_oracle_adaptor<O>::reg_oracle_adaptor(O oracle)
  : oracle_(std::move(oracle))
{
}

template<RegressionPredictor O>
value_t reg_oracle_adaptor<O>::operator()(const std::vector<value_t> &x) const
{
  return oracle_(x);
}

template<RegressionPredictor O>
std::string reg_oracle_adaptor<O>::name(const value_t &v) const
{
  return lexical_cast<std::string>(v);
}

template<RegressionPredictor O>
classification_result reg_oracle_adaptor<O>::tag(
  const std::vector<value_t> &) const
{
  throw std::logic_error("tag() called on regression oracle");
}

template<RegressionPredictor O>
std::string reg_oracle_adaptor<O>::serialize_id() const
{
  return "REG_ORACLE_ADAPTOR";
}

template<RegressionPredictor O>
bool reg_oracle_adaptor<O>::save(std::ostream &) const
{
  throw std::logic_error("reg_oracle_adaptor is not serializable");
}
 
// ***********************************************************************
// *  basic_gaussian_oracle                                              *
// ***********************************************************************
 
template<class I, bool S>
const std::string basic_gaussian_oracle<I, S>::SERIALIZE_ID(
  "GAUSSIAN_ORACLE");

template<class I, bool S>
basic_gaussian_oracle<I, S>::basic_gaussian_oracle(
  const I &ind, const dataframe &d, std::vector<std::string> names)
  : basic_class_oracle(std::move(names)), oracle_(ind), gauss_dist_(d.classes())
{
  static_assert(Individual<I>);
  Expects(!ind.empty());
  Expects(d.classes() > 1);
 
  fill_vector(d);
 
  Ensures(is_valid());
}

template<class I, bool S>
basic_gaussian_oracle<I, S>::basic_gaussian_oracle(std::istream &in,
                                                   const symbol_set &ss)
  : basic_class_oracle(), oracle_(in, ss)
{
  static_assert(
    S, "gaussian_oracle requires storage space for de-serialization");
 
  std::size_t n;
  if (!(in >> n))
    throw exception::data_format("Cannot read gaussian_oracle size component");
 
  for (std::size_t i(0); i < n; ++i)
  {
    distribution<double> d;
    if (!d.load(in))
      throw exception::data_format(
        "Cannot read gaussian_oracle distribution component");
 
    gauss_dist_.push_back(d);
  }
 
  if (!load_names(in))
    throw exception::data_format(
      "Cannot read gaussian_oracle class_names component");
 
  Ensures(is_valid());
}

template<class I, bool S>
void basic_gaussian_oracle<I, S>::fill_vector(const dataframe &d)
{
  Expects(d.classes() > 1);
 
  std::vector<unsigned> unknown_in_class(d.classes(), 0);
 
  constexpr double cut(100000000.0);
 
  for (const auto &ex : d)
  {
    const auto cl(label(ex));
 
    if (const auto res(oracle_(ex.input)); has_value(res))
    {
      auto val(std::get<D_DOUBLE>(res));
      val = std::clamp(val, -cut, cut);
 
      gauss_dist_[cl].add(val);
    }
    else
      ++unknown_in_class[cl];
  }
 
  constexpr double min_variance(1e-6);
  constexpr unsigned missing_per_inflation(2);
 
  for (std::size_t cl(0); cl < d.classes(); ++cl)
  {
    auto &g(gauss_dist_[cl]);
 
    if (const unsigned k(unknown_in_class[cl] / missing_per_inflation);
        g.size() > 0)
    {
      const double mean(g.mean());
      const double var(std::max(g.variance(), min_variance));
      const double delta(2.0 * std::sqrt(var));
 
      for (std::size_t i(0); i < k; ++i)
      {
        g.add(mean + delta);
        g.add(mean - delta);
      }
    }
    else  // no valid outputs: maximally uninformative distribution
    {
      for (std::size_t i(0); i < std::max(1u, k); ++i)
      {
        g.add(+cut);
        g.add(-cut);
      }
    }
 
    Ensures(g.size() > 0);
    Ensures(std::isfinite(g.mean()));
    Ensures(g.variance() >= 0.0);
    Ensures(std::isfinite(g.variance()));
  }
}

template<class I, bool S>
classification_result basic_gaussian_oracle<I, S>::tag(
  const std::vector<value_t> &ex) const
{
  const std::size_t classes(gauss_dist_.size());
 
  if (classes == 1)
    return {0, 1.0};
 
  const auto res(oracle_(ex));
 
  // Missing inference: fall back to class priors.
  if (!has_value(res))
  {
    std::size_t best(0);
    double best_count(0.0), total(0.0);
 
    for (std::size_t i(0); i < classes; ++i)
    {
      // Effective sample count, including variance inflation.
      const auto n(static_cast<double>(gauss_dist_[i].size()));
      total += n;
 
      if (n > best_count)
      {
        best_count = n;
        best = i;
      }
    }
 
    const double confidence(total > 0.0 ? best_count / total : 0.0);
    return {best, confidence};
  }
 
  // Normal likelihood-based inference.
  const auto x(std::get<D_DOUBLE>(res));
 
  double best_p(0.0), sum_p(0.0);
  src::class_t probable_class(0);
 
  for (std::size_t i(0); i < classes; ++i)
  {
    const auto mean(gauss_dist_[i].mean());
    const auto variance(gauss_dist_[i].variance());
    const auto distance(std::fabs(x - mean));
 
    double p(0.0);
    if (issmall(variance))                // degenerate or nearly-degenerate
    {                                     // distribution: treat as a point
      p = issmall(distance) ? 1.0 : 0.0;  // mass at the mean
    }
    else                                  // standard case
      p = std::exp(-distance * distance / variance);
          // std::exp(-0.5 * distance * distance / variance)
          // / std::sqrt(2.0 * std::numbers::pi_v<double> * variance);
 
    if (p > best_p)
    {
      best_p = p;
      probable_class = i;
    }
 
    sum_p += p;
  }
 
  // Normalized confidence value.
  // Do not change `sum_p > 0.0` with
  // - `issmall(sum_p)` => when `sum_p` is small, `best_p` is smaller and the
  //   division works well.
  // - `sum_p` => it's the same thing but will produce a warning with
  //   `-Wfloat-equal`
  const double confidence(sum_p > 0.0 ? best_p / sum_p : 0.0);
 
  return {probable_class, confidence};
}

template<class I, bool S>
bool basic_gaussian_oracle<I, S>::save(std::ostream &out) const
{
  if (!oracle_.save(out))
    return false;
 
  if (!(out << gauss_dist_.size() << '\n'))
    return false;
 
  for (const auto &g : gauss_dist_)
    if (!g.save(out))
      return false;
 
  return save_names(out);
}

template<class I, bool S>
bool basic_gaussian_oracle<I, S>::is_valid() const
{
  return oracle_.is_valid() && !gauss_dist_.empty();
}
 
// ***********************************************************************
// *  basic_binary_oracle                                                *
// ***********************************************************************
 
template<class I, bool S>
const std::string basic_binary_oracle<I, S>::SERIALIZE_ID(
  "BINARY_ORACLE");

template<class I, bool S>
basic_binary_oracle<I, S>::basic_binary_oracle(
  const I &ind, [[maybe_unused]] const dataframe &d,
  std::vector<std::string> names)
  : basic_class_oracle(std::move(names)), oracle_(ind)
{
  static_assert(Individual<I>);
  Expects(!ind.empty());
  Expects(d.classes() == 2);
 
  Ensures(is_valid());
}

template<class I, bool S>
basic_binary_oracle<I, S>::basic_binary_oracle(std::istream &in,
                                             const symbol_set &ss)
  : basic_class_oracle(), oracle_(in, ss)
{
  static_assert(
    S, "binary_oracle requires storage space for de-serialization");
 
  if (!load_names(in))
    throw exception::data_format(
      "Cannot read binary_oracle class_names component");
 
  Ensures(is_valid());
}

template<class I, bool S>
classification_result basic_binary_oracle<I, S>::tag(
  const std::vector<value_t> &ex) const
{
  const auto res(oracle_(ex));
  const double val(has_value(res) ? std::get<D_DOUBLE>(res) : 0.0);
 
  return {val > 0.0 ? 1u : 0u,
          std::fabs(2.0 * std::numbers::inv_pi * std::atan(val))};
}

template<class I, bool S>
bool basic_binary_oracle<I, S>::is_valid() const
{
  return oracle_.is_valid();
}

template<class I, bool S>
bool basic_binary_oracle<I, S>::save(std::ostream &out) const
{
  if (!oracle_.save(out))
    return false;
 
  return save_names(out);
}
 
// ***********************************************************************
// *  class_oracle_adaptor                                               *
// ***********************************************************************

template<ClassificationPredictor O>
class_oracle_adaptor<O>::class_oracle_adaptor(O oracle,
                                              std::vector<std::string> names)
  : basic_class_oracle(std::move(names)), oracle_(std::move(oracle))
{
}

template<ClassificationPredictor O>
classification_result class_oracle_adaptor<O>::tag(
  const std::vector<value_t> &x) const
{
  return oracle_.tag(x);
}

template<ClassificationPredictor O>
std::string class_oracle_adaptor<O>::serialize_id() const
{
  return "CLASS_ORACLE_ADAPTOR";
}

template<ClassificationPredictor O>
bool class_oracle_adaptor<O>::save(std::ostream &) const
{
  throw std::logic_error("class_oracle_adaptor is not serializable");
}
 
// ***********************************************************************
// *  team_class_oracle                                                  *
// ***********************************************************************
 
template<ClassificationPredictor O, team_composition C>
const std::string team_class_oracle<O, C>::SERIALIZE_ID(
  "TEAM_" + O::SERIALIZE_ID);

template<ClassificationPredictor O, team_composition C>
template<Individual I>
team_class_oracle<O, C>::team_class_oracle(
  const gp::team<I> &t, const dataframe &d, std::vector<std::string> names)
  : basic_class_oracle(std::move(names)), classes_(d.classes())
{
  team_.reserve(t.size());
  for (const auto &ind : t)
    team_.emplace_back(ind, d);
}

template<ClassificationPredictor O, team_composition C>
team_class_oracle<O, C>::team_class_oracle(std::istream &in,
                                         const symbol_set &ss)
  : basic_class_oracle()
{
  if (!(in >> classes_))
    throw exception::data_format("Cannot read number of classes");
 
  std::size_t s;
  if (!(in >> s))
    throw exception::data_format("Cannot read team size");
 
  team_.reserve(s);
  for (std::size_t i(0); i < s; ++i)
    team_.emplace_back(in, ss);
 
  if (!load_names(in))
    throw exception::data_format("Cannot read class_names");
}

template<ClassificationPredictor O, team_composition C>
classification_result team_class_oracle<O, C>::tag(
  const std::vector<value_t> &instance) const
{
  Expects(team_.size());
 
  if constexpr (C == team_composition::wta)
  {
    const auto size(team_.size());
    auto best(team_[0].tag(instance));
 
    for (std::size_t i(1); i < size; ++i)
    {
      const auto res(team_[i].tag(instance));
 
      if (res.sureness > best.sureness)
        best = res;
    }
 
    return best;
  }
  else if constexpr (C == team_composition::mv)
  {
    std::vector<unsigned> votes(classes_);
 
    for (const auto &oracle : team_)
      ++votes[oracle.tag(instance).label];
 
    src::class_t max(0);
    for (auto i(max + 1); i < classes_; ++i)
      if (votes[i] > votes[max])
        max = i;
 
    return {max, static_cast<double>(votes[max])
                 / static_cast<double>(team_.size())};
  }
}

template<ClassificationPredictor O, team_composition C>
bool team_class_oracle<O, C>::save(std::ostream &out) const
{
  if (!(out << classes_ << '\n'))
    return false;
 
  if (!(out << team_.size() << '\n'))
    return false;
 
  for (const auto &i : team_)
    if (!i.save(out))
      return false;
 
  return save_names(out);
}

template<ClassificationPredictor O, team_composition C>
std::string team_class_oracle<O, C>::serialize_id() const noexcept
{
  return SERIALIZE_ID;
}

template<ClassificationPredictor O, team_composition C>
bool team_class_oracle<O, C>::is_valid() const
{
  return classes_ > 1;
}
 
namespace serialize::oracle
{
 
namespace internal
{
using build_func = std::unique_ptr<basic_oracle> (*)(std::istream &,
                                                     const symbol_set &);
 
template<class U>
std::unique_ptr<basic_oracle> build(std::istream &in, const symbol_set &ss)
{
  return std::make_unique<U>(in, ss);
}
 
extern std::map<std::string, build_func> factory_;
}  // namespace internal

template<class U>
bool insert(const std::string &id)
{
  Expects(!id.empty());
  return internal::factory_.insert({id, internal::build<U>}).second;
}
 
template<Individual T>
std::unique_ptr<basic_oracle> load(std::istream &in, const symbol_set &ss)
{
  if (internal::factory_.find(reg_oracle<T>::SERIALIZE_ID)
      == internal::factory_.end())
  {
    insert<reg_oracle<T>>(reg_oracle<T>::SERIALIZE_ID);
    //insert<dyn_slot_lambda_f<T>>(dyn_slot_lambda_f<T>::SERIALIZE_ID);
    insert<gaussian_oracle<T>>(gaussian_oracle<T>::SERIALIZE_ID);
    insert<binary_oracle<T>>(binary_oracle<T>::SERIALIZE_ID);
  }
 
  std::string id;
  if (!(in >> id))
    return nullptr;
 
  const auto iter(internal::factory_.find(id));
  if (iter != internal::factory_.end())
    return iter->second(in, ss);
 
  return nullptr;
}
 
}  // namespace serialize::oracle
 
#endif  // include guard