pdp.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "pulsatrix/assert.hpp"
#include "pulsatrix/attribution.hpp"
#include "pulsatrix/device_backend.hpp"
#include "pulsatrix/tensor.hpp"
 
namespace pulsatrix {
 
class PDP {
public:
    [[nodiscard]] Attribution explain(const std::function<Tensor(const Tensor&)>& predict,
                                       const std::vector<Tensor>& background, int64_t feature_index,
                                       int64_t target_index, float grid_min, float grid_max, int64_t grid_size,
                                       DeviceBackend* backend) const {
        if (background.empty()) {
            throw std::invalid_argument("PDP::explain: background must not be empty");
        }
        PULSATRIX_ASSERT(grid_size >= 1);
        PULSATRIX_ASSERT(feature_index >= 0 && feature_index < background[0].numel());
 
        std::vector<std::vector<float>> background_values;
        background_values.reserve(background.size());
        for (const Tensor& instance : background) {
            background_values.push_back(instance.to_host_vector());
        }
        std::vector<float> curve(static_cast<size_t>(grid_size));
 
        for (int64_t k = 0; k < grid_size; ++k) {
            float v = (grid_size == 1) ? grid_min : grid_min + static_cast<float>(k) * (grid_max - grid_min) /
                                                                    static_cast<float>(grid_size - 1);
 
            float sum = 0.0f;
            for (size_t b = 0; b < background.size(); ++b) {
                const Tensor& instance = background[b];
                std::vector<float> perturbed_values = background_values[b];
                perturbed_values[static_cast<size_t>(feature_index)] = v;
                Tensor perturbed(instance.shape(), instance.backend(), perturbed_values, instance.device());
                Tensor output = predict(perturbed);
                sum += output.read_element(target_index);
            }
            curve[static_cast<size_t>(k)] = sum / static_cast<float>(background.size());
        }
 
        Tensor curve_tensor(Shape({grid_size}), explainer_detail::backend_beside(background[0], backend), curve,
                            background[0].device());
        return Attribution{"pdp", std::move(curve_tensor),
                            {{"feature_index", std::to_string(feature_index)},
                             {"target_index", std::to_string(target_index)},
                             {"grid_size", std::to_string(grid_size)}}};
    }
};
 
}  // namespace pulsatrix