dataframe.h

Go to the documentation of this file.

 
#if !defined(VITA_DATAFRAME_H)
#define      VITA_DATAFRAME_H
 
#include <filesystem>
#include <functional>
#include <map>
#include <optional>
#include <set>
#include <string>
#include <vector>
 
#include "kernel/distribution.h"
#include "kernel/problem.h"
#include "utility/pocket_csv.h"
 
namespace vita
{
using class_t = std::size_t;
 
class dataframe
{
public:
  // ---- Structures ----
  struct example;
  class params;
 
  // ---- Aliases ----
  using examples_t = std::vector<example>;
  using value_type = examples_t::value_type;
 
  using record_t = std::vector<std::string>;
 
  using filter_hook_t = std::function<bool (record_t &)>;
 
  class columns_info
  {
  public:
    struct column_info
    {
      std::string         name =     {};
      domain_t          domain = d_void;
      std::set<value_t> states =     {};
    };
 
    using size_type = std::size_t;
 
    columns_info();
 
    const column_info &operator[](size_type i) const { return cols_[i]; }
    column_info &operator[](size_type i) { return cols_[i]; }
 
    size_type size() const { return cols_.size(); }
    bool empty() const { return cols_.empty(); }
 
    auto begin() const { return cols_.begin(); }
    auto begin() { return cols_.begin(); }
    auto end() const { return cols_.end(); }
    auto end() { return cols_.end(); }
 
    const auto &front() const { return cols_.front(); }
    auto &front() { return cols_.front(); }
 
    const auto &back() const { return cols_.back(); }
    auto &back() { return cols_.back(); }
 
    void pop_back() { cols_.pop_back(); }
    void push_back(const column_info &);
    void push_front(const column_info &);
 
    void build(const record_t &, bool);
 
    bool is_valid() const;
 
  private:
    std::vector<column_info> cols_;
  };
 
  // ---- Constructors ----
  dataframe();
  explicit dataframe(std::istream &);
  dataframe(std::istream &, const params &);
  explicit dataframe(const std::filesystem::path &);
  dataframe(const std::filesystem::path &, const params &);
 
  // ---- Iterators ----
  using iterator = examples_t::iterator;
  using const_iterator = examples_t::const_iterator;
  using difference_type = examples_t::difference_type;
 
  iterator begin();
  const_iterator begin() const;
  iterator end();
  const_iterator end() const;
 
  value_type front() const;
  value_type &front();
 
  // ---- Modifiers ----
  void clear();
  iterator erase(iterator, iterator);
 
  // ---- Convenience ----
  std::size_t read(const std::filesystem::path &);
  std::size_t read(const std::filesystem::path &, const params &);
  std::size_t read_csv(std::istream &);
  std::size_t read_csv(std::istream &, params);
  std::size_t read_xrff(std::istream &);
  std::size_t read_xrff(std::istream &, const params &);
  bool operator!() const;
 
  void push_back(const example &);
 
  std::size_t size() const;
  bool empty() const;
 
  class_t classes() const;
  unsigned variables() const;
 
  std::string class_name(class_t) const;
 
  bool is_valid() const;
 
  columns_info columns;
 
private:
  bool read_record(const record_t &, bool);
  example to_example(const record_t &, bool);
 
  class_t encode(const std::string &);
 
  std::size_t read_csv(const std::filesystem::path &, const params &);
  std::size_t read_xrff(const std::filesystem::path &, const params &);
  std::size_t read_xrff(tinyxml2::XMLDocument &, const params &);
 
  // Integer are simpler to manage than textual data, so, when appropriate,
  // input strings are converted into integers by this map and the `encode`
  // static function.
  std::map<std::string, class_t> classes_map_;
 
  // Available data.
  examples_t dataset_;
};
 
domain_t from_weka(const std::string &);
 
struct dataframe::example
{
  std::vector<value_t> input = {};
  value_t             output = {};
 
  std::uintmax_t difficulty  =  0;
  unsigned              age  =  0;
 
  void clear() { *this = example(); }
};
 
template<class T>
T label_as(const dataframe::example &e)
{
  return lexical_cast<T>(e.output);
}
 
inline class_t label(const dataframe::example &e)
{
  Expects(std::holds_alternative<D_INT>(e.output));
  return std::get<D_INT>(e.output);
}
 
class dataframe::params
{
public:
  params &header()
  { dialect.has_header = pocket_csv::dialect::HAS_HEADER; return *this; }
  params &no_header()
  { dialect.has_header =  pocket_csv::dialect::NO_HEADER; return *this; }
 
  params &output(std::size_t o) { output_index =            o; return *this; }
  params &no_output()           { output_index = std::nullopt; return *this; }
 
  pocket_csv::dialect dialect = {};
 
  filter_hook_t filter = nullptr;
 
  std::optional<std::size_t> output_index = 0;
};
 
}  // namespace vita
 
#endif  // include guard