Как использовать функцию-член шаблона базового класса в производном?

std::function довольно дорог в использовании и мало гибок — если вы согласитесь с еще одним параметром шаблона, вы станете более эффективным, более гибким и даже получите более простой код:

class A
{
protected:
    template<typename F, typename... Args>
    std::vector<torch::Tensor> generate_value
    (
        size_t generated_points, // no benefit from reference...
        F&& f // the function/functor to execute
        Args&&... args // allows perfect forwarding
    )
    {
        f(std::forward<Args>(args)...);
    } 
};

std::vector<torch::Tensor> B::generate_values(size_t generated_points, size_t column)
{
    return generate_values
    (
        generated_points,
        // simply use a lambda, it's just more convenient:
        [this](size_t column) { return inner_generation(column); },
        // though the result of `bind` would be just as valid...
        column // and the parameter...
    );
}

Хотя при использовании лямбда-выражений (или std::bind, если вы привязываете значения напрямую вместо использования заполнителей), вам даже не нужны дополнительные параметры:

template<typename F>
std::vector<torch::Tensor> A::generate_value(size_t generated_points, F&& f)
{
    f();
}

std::vector<torch::Tensor> B::generate_values(size_t generated_points, size_t column)
{
    return generate_values
    (
        generated_points,
        [this, column] { return inner_generation(column); }
        // alternatively with default bindings:
        //[=] { return inner_generation(column); }
    );
}

Какой выбрать? Что ж, в основном дело личного вкуса — если вы не хотите делать одно и то же несколько раз с разными переменными, то первый вариант предпочтительнее, поскольку вам не нужно создавать несколько лямбда-выражений:

std::vector<torch::Tensor> B::generate_values
(
    size_t generated_points,
    size_t column1,
    size_t column2 // now one more...
)
{
    auto gen = [this](size_t column) { return inner_generation(column); };
    auto v1 = generate_values(generated_points, gen, column1);
    auto v2 = generate_values(generated_points, gen, column2);
    // union both, create difference or do whatever is appropriate...
    return ...;
}

Этот последний пример может не иметь смысла в вашем конкретном случае, но может сыграть роль в других сценариях;)

Боковое примечание: просто для объяснения: исходный вариант не работает ни из-за результата bind, ни из-за того, что лямбда на самом деле является объектом std::function, поэтому не соответствует параметру вашего шаблона. Вы можете решить, создав объект std::function явно:

return A::generate_values
(
    generated_points,
    std::function([this](size_t const& column) { return inner_generation(column); }),
    // alternatively with `bind`ing, though the place holder makes
    // explicitly specifying the template argument necessary:
    //std::function<torch::Tensor(size_t const&)>
    //(
    //    std::bind(&B::inner_generation, this, std::placeholders::_1)
    //),
    column
);

Также обратите внимание, что в исходном коде вопроса возвращаемые типы экземпляров std::function также не совпадают (сначала int, затем torch::Tensor — если только torch::Tensor не является typedef для int…).