The message-passing process seems to go into endless cycle in RxInfer.

[Flawless1202]

I have tried to solve a trajectory planning problem using RxInfer. I use the following code:

import BayesBase: prod
import ReactiveMP: apply_pipeline_stage
using LinearAlgebra, RxInfer, Plots, PGFPlotsX, Distributions

ReactiveMP.prod(::GenericProd, left::Distribution, right::PointMass) = right
ReactiveMP.prod(::GenericProd, left::PointMass, right::Distribution) = left

function BayesBase.prod(
    ::PreserveTypeProd{Distribution},
    left::MvNormalMeanCovariance{T1},
    right::MvNormalMeanCovariance{T2}
) where {T1<:LinearAlgebra.BlasFloat,T2<:LinearAlgebra.BlasFloat}
    xi_left, W_left = weightedmean_precision(left)
    xi_right, W_right = weightedmean_precision(right)
    return MvNormalWeightedMeanPrecision(xi_left + xi_right, W_left + W_right)
end

apply_pipeline_stage(stage::LoggerPipelineStage, factornode, tag::Val{T}, stream) where {T} = stream |> tap((v) -> println(stage, "[$(functionalform(factornode))][$(T)]: $(as_message(v))"))
apply_pipeline_stage(stage::LoggerPipelineStage, factornode, tag::Tuple{Val{T},Int}, stream) where {T} = stream |> tap((v) -> println(stage, "[$(functionalform(factornode))][$(T):$(tag[2])]: $(as_message(v))"))

# node specification
struct Halfspace end
@node Halfspace Stochastic [out, a, σ², γ]

# rule specification
@rule Halfspace(:out, Marginalisation) (q_a::PointMass, q_σ²::PointMass, q_γ::PointMass) = begin
    return NormalMeanVariance(mean(q_a) + mean(q_γ) * mean(q_σ²), mean(q_σ²))
end

@rule Halfspace(:σ², Marginalisation) (q_out::UnivariateNormalDistributionsFamily, q_a::PointMass, q_γ::PointMass) = begin
    return PointMass(1 / mean(q_γ) * sqrt(abs2(mean(q_out) - mean(q_a)) + var(q_out)))
end

function h(y1, y0, r1, r2)
    return norm(y1 - y0) - r1 - r2
end

@model function single_agent_model(goals, nr_steps, γ, ΔT)
    # transition model
    A = Matrix([
        1 ΔT 0 0;
        0 1 0 0;
        0 0 1 ΔT;
        0 0 0 1
    ])
    B = Matrix([
        0 0;
        ΔT 0;
        0 0;
        0 ΔT
    ])
    C = Matrix([
        1 0 0 0;
        0 0 1 0
    ])

    x[1] ~ MvNormalMeanCovariance(zeros(4), 1e2I) where {pipeline=LoggerPipelineStage("x[1]")}

    local u, y

    for t in 1:nr_steps
        u[t] ~ MvNormalMeanCovariance(zeros(2), 1e-2I) where {pipeline=LoggerPipelineStage("u[$t]")}
        x[t+1] ~ (A * x[t] + B * u[t]) where {pipeline=LoggerPipelineStage("x[$(t+1)]")}
        y[t] ~ (C * x[t+1]) where {pipeline=LoggerPipelineStage("y[$t]")}
        σ²[t] ~ GammaShapeRate(3 / 2, γ^2 / 2) where {pipeline=LoggerPipelineStage("σ²[$t]")}
        # d[t] := h(y[t], MvNormalMeanCovariance([0.0, 25.0], 1e-2I), 15, 15) where {pipeline=LoggerPipelineStage("d[$t]")}
        d[t] := h(y[t], [5.0, 25.0], 15.0, 5.0) where {pipeline=LoggerPipelineStage("d[$t](h)")}
        d[t] ~ Halfspace(0, σ²[t], γ) where {pipeline=LoggerPipelineStage("d[$t](Halfspace)")}
    end

    goals[1] ~ MvNormalMeanCovariance(x[1], 1e-5I)
    goals[2] ~ MvNormalMeanCovariance(x[nr_steps+1], 1e-5I)

end

nr_iterations = 20
nr_steps = 20

constraints = @constraints begin
    q(d, σ²) = q(d)q(σ²)
end;

metas = @meta begin
    h() -> Linearization()
end;

initm = @initialization begin
    q(σ²) = repeat([PointMass(1)], nr_steps)
    q(u) = repeat([PointMass(0)], nr_steps)
    μ(x) = MvNormalMeanCovariance(randn(4), 100I)
end

goals = [
    [0, 0, 0, 0],
    [0, 0, 50, 0],
]

# A callback that will be called every time before a variational iteration starts
function before_iteration_callback(model, iteration)
    println("Start iteration ", iteration)
end

# A callback that will be called every time after a variational iteration finishes
function after_iteration_callback(model, iteration)
    println("Iteration ", iteration, " has been finished")
end

# A callback that will be called every time a posterior is updated
function on_marginal_update_callback(model, variable_name, posterior)
    println("Latent variable ", variable_name, " has been updated. Posterior is ", posterior)
end

function before_data_update_callback(model::ProbabilisticModel, data)
    println("Start updating data: ", data)
end

function after_data_update_callback(model::ProbabilisticModel, data)
    println("Finish updating data: ", data)
end

results = infer(
    model=single_agent_model(nr_steps=nr_steps, γ=200, ΔT=1),
    data=(goals=goals,),
    constraints=constraints,
    meta=metas,
    iterations=nr_iterations,
    returnvars=KeepLast(),
    initialization=initm,
    showprogress=true,
    # addons=(AddonMemory(),),
    callbacks=(
        on_marginal_update=on_marginal_update_callback,
        before_iteration=before_iteration_callback,
        after_iteration=after_iteration_callback,
        before_data_update=before_data_update_callback,
        after_data_update=after_data_update_callback
    )
)

when nr_steps is less than 10, the code runs well. But when it becomes larger, e.g. 20, the code runs forever without stopping. I try to find the reason from the output (terminated while running) as follows.
output.zip

It seems that the message-passing process went into an endless cycle, which is not expected. I am not familiar with the source code of RxInfer and I really need your help! Is there any way to solve it?

The reference paper is here

Originally posted by @Flawless1202 in biaslab/MultiAgentTrajectoryPlanning#4 (comment)

[albertpod]

@bvdmitri, @bartvanerp wasn't this resolved?

[bartvanerp]

Yes, was resolved in latest release. For more information check out the discussion in biaslab/MultiAgentTrajectoryPlanning#4

[bvdmitri]

Thanks for noticing this @albertpod !