get_cross_val_splits.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef cMHN_UTILITY_GET_CROSS_VAL_SPLITS_H
#define cMHN_UTILITY_GET_CROSS_VAL_SPLITS_H
 
#include <fstream>
#include <map>
#include <random>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
 
#include <prc.hpp>
 
namespace cMHN
{
    template<class T, pRC::Size D>
    static inline auto getCrossValSplits(std::string const &filename,
        pRC::Index const &k)
    {
        std::ifstream file(filename);
 
        using Subscripts =
            decltype(expand(pRC::makeConstantSequence<pRC::Size, D, 2>(),
                [](auto const... seq)
                {
                    return pRC::Subscripts<seq...>();
                }));
 
        if(!file.is_open())
        {
            pRC::Logging::error("Unable to open input file!");
        }
 
        std::vector<std::string> lines;
 
        // number of samples
        pRC::UnsignedInteger<64> totalSum = 0;
 
        std::string line;
 
        // first line contains header (event names)
        std::getline(file, line);
 
        // write samples to lines
        while(std::getline(file, line))
        {
            lines.push_back(line);
 
            totalSum += pRC::unit<decltype(totalSum)>();
        }
 
        // shuffle data
        std::random_device rd;
        std::mt19937 g(rd());
        std::shuffle(lines.begin(), lines.end(), g);
 
        std::vector<std::map<Subscripts, T>> pDs;
        pRC::Index length = totalSum() / k;
        pRC::Index remainder = totalSum() % k;
 
        std::vector<pRC::Index> lengths(k, length);
 
        while(remainder > 0)
        {
            ++lengths[remainder - 1];
            --remainder;
        }
 
        pRC::Index minInd = 0;
 
        // write the maps in pDs
        for(pRC::Index ind = 0; ind < k; ++ind)
        {
            std::map<Subscripts, T> pD;
            pRC::UnsignedInteger<64> sum = 0;
 
            std::string line;
            for(pRC::Index innerInd = 0; innerInd < lengths[ind]; ++innerInd)
            {
                line = lines[minInd + innerInd];
 
                // turn commas into spaces
                std::replace(line.begin(), line.end(), ',', ' ');
 
                std::istringstream iss(line);
 
                // store event data for current sample in 'bits'
                Subscripts bits;
                std::size_t i = 0;
                unsigned v;
                while(iss >> v)
                {
                    bits[i++] = v;
                }
                if constexpr(pRC::cDebugLevel >= pRC::DebugLevel::Low)
                {
                    if(i != D)
                    {
                        pRC::Logging::error(
                            "Number of events differs for input file and "
                            "binary. "
                            "File:",
                            i, "Binary:", D);
                    }
                }
 
                pD.try_emplace(bits, pRC::zero<T>());
                pD[bits] += pRC::unit<T>();
 
                sum += pRC::unit<decltype(sum)>();
            }
 
            minInd += lengths[ind];
 
            // normalize pD
            for(auto &[k, v] : pD)
            {
                v /= sum;
            }
            pDs.push_back(pD);
        }
 
        return std::make_tuple(pDs, lengths);
    }
} // namespace cMHN
 
#endif // cMHN_UTILITY_GET_CROSS_VAL_SPLITS_H