pybind11绑定C++优化库：Python函数迭代持久化问题修复请求

问题背景 #

用pybind11为C优化库开发Python包装器时，optimize方法可正常调用Python目标函数完成一次性优化，但使用initialize+iterate的分步运行模式时，脚本会挂起或崩溃。排查发现是Python函数和边界数组在C对象中未正确持久化，导致后续iterate调用时引用失效。

核心原因 #

1. Python函数生命周期问题：initialize绑定的lambda中，multivariate捕获的是局部变量py_f的引用，当initialize执行完毕返回Python解释器后，py_f被销毁，后续iterate调用时函数引用失效。而optimize方法中整个优化过程在C++侧一次性完成，py_f生命周期覆盖所有迭代，因此无问题。
2. 边界数组指针失效：multivariate_problem直接保存Python数组的指针，若Python侧数组被GC回收，C++侧指针将指向无效内存。

修复方案 #

修改后的绑定代码（multivariate_py.cpp） #

// wrap the function expressions
typedef std::function<double(const py::array_t<double>&)> py_multivariate;

// 持久化问题数据：保存Python函数和拷贝后的边界，确保生命周期与优化器一致
struct PersistentProblemData {
    py_multivariate py_f;
    int n;
    std::vector<double> lower;
    std::vector<double> upper;

    PersistentProblemData(py_multivariate f, int dim, const py::array_t<double>& py_lower, const py::array_t<double>& py_upper)
        : py_f(std::move(f)), n(dim), lower(py_lower.begin(), py_lower.end()), upper(py_upper.begin(), py_upper.end()) {}
};

// wrap the multivariable optimizer
void build_multivariate(py::module_ &m) {

// wrap the solution object
py::class_<multivariate_solution> solution(m, "MultivariateSolution");
// ... 保留原有solution包装代码

// wrap the solver：为抽象类添加持久化数据存储
py::class_<MultivariateOptimizer, std::shared_ptr<MultivariateOptimizer>> solver(m, "MultivariateSearch");

// 添加私有成员保存持久化数据
solver.def_readwrite("_persistent_data", std::unique_ptr<PersistentProblemData>(), py::return_value_policy::reference_internal);

// corresponds to MultivariateSearch::optimize()
solver.def("optimize",
        [](MultivariateOptimizer &self, py_multivariate py_f,
                py::array_t<double> &py_lower,
                py::array_t<double> &py_upper,
                py::array_t<double> &py_guess) {
            const int n = py_lower.size();
            // 拷贝边界到C++向量，避免依赖Python数组生命周期
            std::vector<double> lower(py_lower.begin(), py_lower.end());
            std::vector<double> upper(py_upper.begin(), py_upper.end());

            // 拷贝Python函数，避免引用局部变量
            multivariate f = [py_f, n](const double *x) -> double {
                const auto &py_x = py::array_t<double>(n, x);
                return py_f(py_x);
            };

            multivariate_problem prob { f, n, lower.data(), upper.data() };
            double *guess = static_cast<double*>(py_guess.request().ptr);
            return self.optimize(prob, guess);
        }, "f"_a, "lower"_a, "upper"_a, "guess"_a,
        py::call_guard<py::scoped_ostream_redirect,
                py::scoped_estream_redirect>());

// corresponds to MultivariateSearch::init()
solver.def("initialize",
        [](MultivariateOptimizer &self, py_multivariate py_f,
                py::array_t<double> &py_lower,
                py::array_t<double> &py_upper,
                py::array_t<double> &py_guess) {
            const int n = py_lower.size();
            // 创建持久化数据，保存Python函数和拷贝后的边界
            auto persistent_data = std::make_unique<PersistentProblemData>(std::move(py_f), n, py_lower, py_upper);

            // lambda捕获持久化数据的指针，确保迭代时能访问有效数据
            multivariate f = [data_ptr = persistent_data.get()](const double *x) -> double {
                const auto &py_x = py::array_t<double>(data_ptr->n, x);
                return data_ptr->py_f(py_x);
            };

            multivariate_problem prob { f, n, persistent_data->lower.data(), persistent_data->upper.data() };
            double *guess = static_cast<double*>(py_guess.request().ptr);
            self.init(prob, guess);

            // 将持久化数据绑定到优化器实例，确保生命周期一致
            static_cast<decltype(solver)::type&>(self)._persistent_data = std::move(persistent_data);
        }, "f"_a, "lower"_a, "upper"_a, "guess"_a,
        py::call_guard<py::scoped_ostream_redirect,
                py::scoped_estream_redirect>(),
        // keep_alive：让优化器实例持有Python函数的引用，防止被GC回收
        py::keep_alive<1, 2>());

// corresponds to MultivariateSearch::iterate()
solver.def("iterate", &MultivariateOptimizer::iterate);

// corresponds to MultivariateSearch::solution()
solver.def("solution", &MultivariateOptimizer::solution);

// put algorithm-specific bindings here
build_acd(m);
build_amalgam(m);
build_basin_hopping(m);
// ... 保留原有算法绑定代码
}

关键修改说明 #

1. PersistentProblemData结构体：统一管理Python函数和边界数组的拷贝，确保数据生命周期与优化器实例绑定。
2. 优化器添加持久化存储：通过pybind11给抽象类添加_persistent_data成员，保存PersistentProblemData的智能指针，避免局部变量被销毁。
3. lambda捕获方式调整：捕获PersistentProblemData的指针，而非局部变量引用，确保iterate调用时能访问有效数据。
4. py::keep_alive机制：让优化器实例持有Python函数的引用，防止Python解释器将其GC回收。
5. 边界数组拷贝：将Python数组拷贝到C++std::vector中，避免直接使用Python数组指针，防止指针失效。

验证代码 #

import numpy as np
from mylibrary import MySolverName


# function to optimize
def fx(x):
    total = 0.0
    for x1, x2 in zip(x[:-1], x[1:]):
        total += 100 * (x2 - x1 ** 2) ** 2 + (1 - x1) ** 2
    return total


n = 10  # dimension of problem
alg = MySolverName(some_args_to_pass...)
alg.initialize(f=fx,
               lower=-10 * np.ones(n),
               upper=10 * np.ones(n),
               guess=np.random.uniform(low=-10., high=10., size=n))
for _ in range(100):
    alg.iterate()
print(alg.solution())

修改后initialize+iterate模式可正常运行，Python函数和边界数据均能正确持久化。

内容的提问来源于stack exchange，提问作者mgim