Batch.hpp

Go to the documentation of this file.

#ifndef SRC_TYPES_BATCH_HPP_
#define SRC_TYPES_BATCH_HPP_

#include <types/Sample.hpp>

#include <random>

#include <list>


namespace mic {
namespace types {

template<typename DataType, typename LabelType>
class Batch {
public:
    Batch(size_t batch_size_ = 1) :
        next_sample_index(0),
        batch_size(batch_size_),
        rng_mt19937_64(rd())
    {

    }

    Batch(const mic::types::Batch<DataType, LabelType>& batch_) :
        rng_mt19937_64(rd())
    {
        // Copy parameters.
        next_sample_index = batch_.next_sample_index;
        batch_size = batch_.batch_size;

        // Copy "samples".
        this->sample_data = batch_.sample_data;
        this->sample_labels = batch_.sample_labels;
        this->sample_indices = batch_.sample_indices;
        // And number of classes.
        this->number_of_classes = batch_.number_of_classes;
    }

    mic::types::Batch<DataType, LabelType>& operator =(const mic::types::Batch<DataType, LabelType>& batch_) {
        // Copy "samples".
        this->sample_data = batch_.sample_data;
        this->sample_labels = batch_.sample_labels;
        this->sample_indices = batch_.sample_indices;
        // And number of classes.
        this->number_of_classes = batch_.number_of_classes;
        // Return the object.
        return *this;
    }

    virtual ~Batch() { };

    std::vector <std::shared_ptr<DataType> > & data() {
        return sample_data;
    }

    std::vector <std::shared_ptr<LabelType> > & labels() {
        return sample_labels;
    }

    std::vector <size_t> & indices() {
        return sample_indices;
    }

    std::shared_ptr<DataType> data(size_t index_) {
        return sample_data[index_];
    }

    std::shared_ptr<LabelType> labels(size_t index_) {
        return sample_labels[index_];
    }

    std::vector <size_t> indices(size_t index_) {
        return sample_indices[index_];
    }

    size_t size() {
        return sample_data.size();
    }

    void setBatchSize(size_t batch_size_) {
        batch_size = batch_size_;
    }


    size_t getBatchSize() {
        return batch_size;
    }


    mic::types::Batch<DataType, LabelType> getRandomBatch() {

        // Initialize uniform index distribution - integers.
        std::uniform_int_distribution<> index_dist(0, this->sample_data.size()-1);

        std::vector<size_t> tmp_indices;
        for (size_t i=0; i<batch_size; i++) {
            // Pick an index.
            tmp_indices.push_back((size_t)index_dist(rng_mt19937_64));

        }//: batch_size

        // Return data.
        return this->getBatchDirect(tmp_indices);
    }


    mic::types::Batch<DataType, LabelType> getNextBatch() {

        // Check index.
        if((next_sample_index+batch_size) > this->sample_data.size()){
            // Reset index.
            next_sample_index = 0;
        }
        // Generate list of indices.
        std::vector<size_t> indices;
        for (size_t i=0; i<batch_size; i++) {
            // Pick an index.
            indices.push_back((size_t)(next_sample_index+i));

        }//: batch_size

        // Increment index.
        next_sample_index = (size_t)next_sample_index + (size_t)batch_size;
        // Return data.
        return this->getBatchDirect(indices);
    }


    mic::types::Batch<DataType, LabelType> getBatch(std::vector<size_t> indices_) {

        // New empty batch.
        mic::types::Batch<DataType, LabelType> batch;
        // Set number of classes.
        batch.number_of_classes = number_of_classes;

        // For all indices.
        for (size_t local_index: indices_) {
            // Try to add sample to batch.
            batch.add(getSample(local_index));
        }
        // Return batch.
        return batch;
    }


    mic::types::Batch<DataType, LabelType> getBatchDirect(std::vector<size_t> indices_) {

        // New empty batch.
        mic::types::Batch<DataType, LabelType> batch;

        // For all indices.
        for (size_t local_index: indices_) {
            // Try to add sample to batch.
            batch.add(getSampleDirect(local_index));
        }
        // Return batch.
        return batch;
    }


    bool isLastBatch() {
        return ((next_sample_index+batch_size) >= this->sample_data.size());
    }


    mic::types::Sample<DataType, LabelType> getRandomSample() {

        // Initialize uniform index distribution - integers.
        std::uniform_int_distribution<> index_dist(0, this->sample_data.size()-1);

        // Pick an index.
        unsigned int tmp_index= index_dist(rng_mt19937_64);

        //LOG(LDEBUG) << "data size = " << this->sample_data.size() << " labels size = " << this->sample_labels.size() << " index = " << tmp_index;

        // Return data.
        return this->getSampleDirect(tmp_index);
    }

    mic::types::Sample<DataType, LabelType> getNextSample() {

        // Check index.
        if(next_sample_index >= this->sample_data.size()){
            // Reset index.
            next_sample_index = 0;
        }
        // Return given sample and increment index afterwards.
        mic::types::Sample<DataType, LabelType > sample = this->getSampleDirect(next_sample_index);
        next_sample_index += 1;
        return sample;
    }


    mic::types::Sample<DataType, LabelType> getSample(size_t index_) {

        // Check index.
        if ((index_ < 0) || (index_ >= sample_data.size())){
            // Reset index.
            throw std::out_of_range("Sample index out of range!");
        }//: if

        // Check sample index.
        size_t sample_index = sample_indices[index_];
        if ((sample_index < 0) || (sample_index >= sample_data.size())){
            // Reset index.
            throw std::out_of_range("Invalid sample index!");
        }//: if

        // Get data
        std::shared_ptr<DataType> data_ptr = sample_data[sample_index];
        std::shared_ptr<LabelType> label_ptr = sample_labels[sample_index];

        // Return data.
        return Sample<DataType, LabelType> (data_ptr, label_ptr, sample_index);
    }

    mic::types::Sample<DataType, LabelType> getSampleDirect(size_t index_) {

        // Check index.
        if (index_ >= sample_data.size()){
            // Reset index.
            throw std::out_of_range("Sample index out of range!");
        }//: if

        // Get data
        std::shared_ptr<DataType> data_ptr = sample_data[index_];
        std::shared_ptr<LabelType> label_ptr = sample_labels[index_];
        size_t sample_index = sample_indices[index_];

        // Return data.
        return Sample<DataType, LabelType> (data_ptr, label_ptr, sample_index);
    }


    void setNextSampleIndex(size_t index_ = 0) {
        next_sample_index = index_;
    }

    bool isLastSample() {
        return (next_sample_index >= this->sample_data.size());
    }


    virtual void add(mic::types::Sample<DataType, LabelType> sample_) {
        // Add sample to vectors.
        sample_data.push_back(sample_.data());
        sample_labels.push_back(sample_.label());
        sample_indices.push_back(sample_.index());
    }

    virtual void add(std::shared_ptr<DataType> data_, std::shared_ptr<LabelType> label_, size_t index_) {
        // Add sample to vectors.
        sample_data.push_back(data_);
        sample_labels.push_back(label_);
        sample_indices.push_back(index_);
    }

    virtual void add(std::shared_ptr<DataType> data_, std::shared_ptr<LabelType> label_) {
        // Add sample to vectors.
        sample_data.push_back(data_);
        sample_labels.push_back(label_);
        sample_indices.push_back(sample_indices.size());
    }

    void countClasses() {
        std::list<LabelType> classes;
        for(auto label: this->sample_labels) {
            classes.push_back(*label);
        }//: for
        classes.sort();
        classes.unique();
        this->number_of_classes = classes.size();
    }

    size_t classes() {
        return number_of_classes;
    }

protected:
    size_t next_sample_index;

    size_t batch_size;

    std::random_device rd;

    std::mt19937_64 rng_mt19937_64;


    std::vector <std::shared_ptr<DataType> > sample_data;

    std::vector <std::shared_ptr<LabelType> > sample_labels;

    std::vector <size_t> sample_indices;

    size_t number_of_classes;

};


} /* namespace types */
} /* namespace mic */




#endif /* SRC_TYPES_BATCH_HPP_ */