scores.h

Go to the documentation of this file.

/* This file is part of SOMHunter.
 *
 * Copyright (C) 2021 Frantisek Mejzlik <frankmejzlik@protonmail.com>
 *                    Mirek Kratochvil <exa.exa@gmail.com>
 *                    Patrik Vesely <prtrikvesely@gmail.com>
 *
 * SOMHunter is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free
 * Software Foundation, either version 2 of the License, or (at your option)
 * any later version.
 *
 * SOMHunter is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * SOMHunter. If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef scores_h
#define scores_h
 
#include <map>
#include <set>
#include <vector>
 
#include "common.h"
 
#include "dataset-features.h"
#include "dataset-frames.h"
 
namespace sh {
class ScoreModel {
    std::vector<float> _scores;
 
    StdMatrix<float> _temporal_scores;
 
    std::vector<bool> _mask;
 
    // *** CACHING VARIABLES ***
    mutable std::vector<FrameId> _topn_cache;
    mutable bool _cache_dirty;
    mutable std::vector<FrameId> _topn_ctx_cache;
    mutable bool _cache_ctx_dirty;
 
public:
    ScoreModel(const DatasetFrames& p)
        : _scores(p.size(), 1.0F),
          _temporal_scores(MAX_TEMPORAL_SIZE, _scores),
          _mask(p.size(), true),
          _cache_dirty{ true },
          _cache_ctx_dirty{ true } {}
 
    bool operator==(const ScoreModel& other) const;
    float operator[](FrameId i) const { return _scores[i]; }
 
    void reset(float val = 1.0F);
 
    float adjust(FrameId i, float prob);
 
    float adjust(size_t temp, FrameId i, float prob);
 
    float set(FrameId i, float prob);
 
    const float* v() const { return _scores.data(); }
 
    const float* temp(size_t temp) const { return _temporal_scores[temp].data(); }
 
    size_t size() const { return _scores.size(); }
 
    void apply_temporals(size_t depth, const DatasetFrames& _dataset_frames, const float power);
 
    void normalize(size_t depth = MAX_TEMPORAL_SIZE);
    void normalize(float* scores, size_t size);
 
    void invalidate_cache() {
        _cache_dirty = true;
        _cache_ctx_dirty = true;
    }
 
    void reset_mask() {
        invalidate_cache();
        std::transform(_mask.begin(), _mask.end(), _mask.begin(), [](const bool&) { return true; });
    };
 
    bool is_masked(FrameId ID) const { return _mask[ID]; }
 
    bool set_mask(FrameId ID, bool val) {
        invalidate_cache();
        return _mask[ID] = val;
    }
 
    void apply_bayes(std::set<FrameId> likes, const std::set<FrameId>& screen, const PrimaryFrameFeatures& features);
 
    const std::vector<FrameId>& top_n(const DatasetFrames& _dataset_frames, size_t _size, size_t from_vid_limit = 0,
                                      size_t from_shot_limit = 0) const;
 
    std::vector<FrameId> top_n_with_context(const DatasetFrames& _dataset_frames, size_t _size, size_t from_vid_limit,
                                            size_t from_shot_limit) const;
 
    std::vector<FrameId> weighted_sample(size_t _size, float pow = 1) const;
 
    FrameId weighted_example(const std::vector<FrameId>& subset) const;
 
    size_t frame_rank(FrameId i) const;
 
    static StdVector<std::pair<FrameId, float>> sort_by_score(const StdVector<float>& scores);
};
 
};  // namespace sh
#endif