model.hpp

Go to the documentation of this file.

 
#ifndef PLSSVM_MODEL_HPP_
#define PLSSVM_MODEL_HPP_
#pragma once
 
#include "plssvm/data_set.hpp"                        // plssvm::data_set
#include "plssvm/detail/assert.hpp"                   // PLSSVM_ASSERT
#include "plssvm/detail/io/libsvm_model_parsing.hpp"  // plssvm::detail::io::{parse_libsvm_model_header, write_libsvm_model_data}
#include "plssvm/detail/io/libsvm_parsing.hpp"        // plssvm::detail::io::parse_libsvm_data
#include "plssvm/detail/logger.hpp"                   // plssvm::detail::log, plssvm::verbosity_level
#include "plssvm/detail/performance_tracker.hpp"      // plssvm::detail::tracking_entry
#include "plssvm/detail/type_list.hpp"                // plssvm::detail::{real_type_list, label_type_list, type_list_contains_v}
#include "plssvm/parameter.hpp"                       // plssvm::parameter
 
#include "fmt/chrono.h"                               // format std::chrono types using fmt
#include "fmt/core.h"                                 // fmt::format
 
#include <chrono>                                     // std::chrono::{time_point, steady_clock, duration_cast, milliseconds}
#include <cstddef>                                    // std::size_t
#include <iostream>                                   // std::cout, std::endl
#include <memory>                                     // std::shared_ptr, std::make_shared
#include <string>                                     // std::string
#include <tuple>                                      // std::tie
#include <utility>                                    // std::move
#include <vector>                                     // std::vector
 
namespace plssvm {
 
template <typename T, typename U = int>
class model {
    // make sure only valid template types are used
    static_assert(detail::type_list_contains_v<T, detail::real_type_list>, "Illegal real type provided! See the 'real_type_list' in the type_list.hpp header for a list of the allowed types.");
    static_assert(detail::type_list_contains_v<U, detail::label_type_list>, "Illegal label type provided! See the 'label_type_list' in the type_list.hpp header for a list of the allowed types.");
 
    // plssvm::csvm needs the private constructor
    friend class csvm;
 
  public:
    using real_type = T;
    using label_type = U;
    using size_type = std::size_t;
 
    explicit model(const std::string &filename);
 
    void save(const std::string &filename) const;
 
    [[nodiscard]] size_type num_support_vectors() const noexcept { return num_support_vectors_; }
    [[nodiscard]] size_type num_features() const noexcept { return num_features_; }
 
    [[nodiscard]] const parameter &get_params() const noexcept { return params_; }
    [[nodiscard]] const std::vector<std::vector<real_type>> &support_vectors() const noexcept { return data_.data(); }
 
    [[nodiscard]] const std::vector<label_type> &labels() const noexcept { return data_.labels()->get(); }
    [[nodiscard]] size_type num_different_labels() const noexcept { return data_.num_different_labels(); }
    [[nodiscard]] std::vector<label_type> different_labels() const { return data_.different_labels().value(); }
 
    [[nodiscard]] const std::vector<real_type> &weights() const noexcept {
        PLSSVM_ASSERT(alpha_ptr_ != nullptr, "The alpha_ptr may never be a nullptr!");
        return *alpha_ptr_;
    }
    [[nodiscard]] real_type rho() const noexcept { return rho_; }
 
  private:
    model(parameter params, data_set<real_type, label_type> data);
 
    parameter params_{};
    data_set<real_type, label_type> data_{};
    size_type num_support_vectors_{ 0 };
    size_type num_features_{ 0 };
 
    std::shared_ptr<std::vector<real_type>> alpha_ptr_{ nullptr };
    real_type rho_{ 0.0 };
 
    std::shared_ptr<std::vector<real_type>> w_{ std::make_shared<std::vector<real_type>>() };
};
 
template <typename T, typename U>
model<T, U>::model(const std::string &filename) {
    const std::chrono::time_point start_time = std::chrono::steady_clock::now();
 
    // open the file
    detail::io::file_reader reader{ filename };
    reader.read_lines('#');
 
    // parse the libsvm model header
    std::vector<label_type> labels{};
    std::size_t num_header_lines{};
    std::tie(params_, rho_, labels, num_header_lines) = detail::io::parse_libsvm_model_header<real_type, label_type, size_type>(reader.lines());
 
    // create empty support vectors and alpha vector
    std::vector<std::vector<real_type>> support_vectors;
    std::vector<real_type> alphas;
 
    // parse libsvm model data
    std::tie(num_support_vectors_, num_features_, support_vectors, alphas) = detail::io::parse_libsvm_data<real_type, real_type>(reader, num_header_lines);
 
    // create data set
    data_ = data_set<real_type, label_type>{ std::move(support_vectors), std::move(labels) };
    alpha_ptr_ = std::make_shared<decltype(alphas)>(std::move(alphas));
 
    const std::chrono::time_point end_time = std::chrono::steady_clock::now();
    detail::log(verbosity_level::full | verbosity_level::timing,
                "Read {} support vectors with {} features in {} using the libsvm model parser from file '{}'.\n\n",
                detail::tracking_entry{ "model_read", "num_support_vectors", num_support_vectors_ },
                detail::tracking_entry{ "model_read", "num_features", num_features_ },
                detail::tracking_entry{ "model_read", "time",  std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time) },
                detail::tracking_entry{ "model_read", "filename", filename });
    PLSSVM_DETAIL_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking_entry{ "model_read", "rho", rho_ }));
}
 
template <typename T, typename U>
model<T, U>::model(parameter params, data_set<real_type, label_type> data) :
    params_{ std::move(params) }, data_{ std::move(data) }, num_support_vectors_{ data_.num_data_points() }, num_features_{ data_.num_features() }, alpha_ptr_{ std::make_shared<std::vector<real_type>>(data_.num_data_points()) } {}
 
template <typename T, typename U>
void model<T, U>::save(const std::string &filename) const {
    const std::chrono::time_point start_time = std::chrono::steady_clock::now();
 
    // save model file header and support vectors
    detail::io::write_libsvm_model_data(filename, params_, rho_, *alpha_ptr_, data_);
 
    const std::chrono::time_point end_time = std::chrono::steady_clock::now();
    detail::log(verbosity_level::full | verbosity_level::timing,
                "Write {} support vectors with {} features in {} to the libsvm model file '{}'.\n",
                detail::tracking_entry{ "model_write", "num_support_vectors", num_support_vectors_ },
                detail::tracking_entry{ "model_write", "num_features", num_features_ },
                detail::tracking_entry{ "model_write", "time",  std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time) },
                detail::tracking_entry{ "model_write", "filename", filename });
    PLSSVM_DETAIL_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY((plssvm::detail::tracking_entry{ "model_write", "rho", rho_ }));
}
 
}  // namespace plssvm
 
#endif  // PLSSVM_MODEL_HPP_