Function make_flow_input

src/models/heartmula/codec.cpp:1502–1537

    return out;
}

std::vector<float> solve_euler(
    const HeartCodecWeightsRuntime & runtime,
    std::vector<float> x,
    const std::vector<float> & incontext_x,
    int64_t incontext_length,
    const std::vector<float> & mu,
    int64_t num_steps,
    float guidance_scale) {
    const auto & config = runtime.assets().codec_config;
    const int64_t batch = 1;
    const int64_t frames = static_cast<int64_t>(mu.size()) / config.dim;
    const int64_t latent_dim = config.out_channels;
    if (num_steps <= 0 || frames <= 0 ||
        static_cast<int64_t>(x.size()) != batch * frames * latent_dim ||
        static_cast<int64_t>(incontext_x.size()) != batch * frames * latent_dim) {
        throw std::runtime_error("HeartCodec Euler solver shape mismatch");
    }
    const std::vector<float> noise = x;
    float t = 0.0F;
    float dt = 1.0F / static_cast<float>(num_steps);
    for (int64_t step = 1; step <= num_steps; ++step) {
        for (int64_t frame = 0; frame < incontext_length; ++frame) {
            for (int64_t channel = 0; channel < latent_dim; ++channel) {
                const size_t index = static_cast<size_t>(frame * latent_dim + channel);
                x[index] = (1.0F - (1.0F - 1.0e-6F) * t) * noise[index] + t * incontext_x[index];
            }
        }
        std::vector<float> dphi;
        if (guidance_scale > 1.0F) {
            auto uncond = make_flow_input(x, incontext_x, mu, batch, frames, latent_dim, config.dim, false);
            auto cond = make_flow_input(x, incontext_x, mu, batch, frames, latent_dim, config.dim, true);
            uncond.insert(uncond.end(), cond.begin(), cond.end());
            const std::vector<float> timesteps = {t, t};
            auto estimate = runtime.estimate_flow(uncond, 2, frames, timesteps);
            dphi.resize(static_cast<size_t>(frames * latent_dim), 0.0F);
            const size_t row_elems = static_cast<size_t>(frames * latent_dim);
            for (size_t i = 0; i < row_elems; ++i) {
                const float uncond_value = estimate.values[i];