From 7ae41d0b350b171791f55dca4d76161d44ef852e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C4=B0smail=20=C5=9Een=C3=B6z?= Date: Sun, 16 Mar 2025 19:40:19 +0100 Subject: [PATCH] add Lorenz example --- .../Lorenz Differential Equation.ipynb | 2495 +++++++++++++++++ .../delta_node_rules.jl | 57 + .../Lorenz Differential Equation/meta.jl | 7 + 3 files changed, 2559 insertions(+) create mode 100644 examples/Problem Specific/Lorenz Differential Equation/Lorenz Differential Equation.ipynb create mode 100644 examples/Problem Specific/Lorenz Differential Equation/delta_node_rules.jl create mode 100644 examples/Problem Specific/Lorenz Differential Equation/meta.jl diff --git a/examples/Problem Specific/Lorenz Differential Equation/Lorenz Differential Equation.ipynb b/examples/Problem Specific/Lorenz Differential Equation/Lorenz Differential Equation.ipynb new file mode 100644 index 00000000..292579e6 --- /dev/null +++ b/examples/Problem Specific/Lorenz Differential Equation/Lorenz Differential Equation.ipynb @@ -0,0 +1,2495 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Lorenz Differential Equation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this notebook we will explore online parameter and state estimation for Lorenz attractor using an adaptive solver that automatically determines the step-size." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "using LinearAlgebra, RxInfer, Plots, ExpectationApproximations,StableRNGs, ReactiveMP\n", + "import ExpectationApproximations: FromTo\n", + "include(\"delta_node_rules.jl\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction to Lorenz Differential Equation\n", + "The Lorenz differential equation is defined as the following system of equations \n", + "$$\\begin{aligned}\n", + "\\mathrm{d}x &= \\sigma (y - x) \\\\\n", + "\\mathrm{d}y &= x (\\rho - z) - y \\\\\n", + "\\mathrm{d}z &= x y - \\beta z \\\\\n", + "\\end{aligned}$$\n", + "where $\\sigma$, $\\rho$ and $\\beta$ are the parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "fitzhugh_nagumo_attractor (generic function with 1 method)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "function lorenz_attractor(ϕ, θ, t)\n", + " σ,ρ,β = θ\n", + " x,y,z = ϕ\n", + "\n", + " dx = σ*(y - x)\n", + " dy = x*(ρ -z) - y \n", + " dz = x*y - β*z \n", + "\n", + " return [dx,dy,dz]\n", + "end\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Adaptive Solvers\n", + "Some of the numerical solvers allow time step $dt$ to be estimated adaptively while solving the system of equations. In this notebook, we will use Runge–Kutta–Fehlberg (RKF) method. RKF45 method is a method of order $\\mathcal{O}(n^4)$ with an error estimate of order $\\mathcal{O}(n^5)$. The main idea is to simulatenously solve different order solutions and track the error between these solutions. In RKF45, we solve with 5th order and 4th order solvers. The next function defines this approximation by using the specified Buther tableau. Higher order methods are possible with a variety of Butcher tableau. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "rkf45_step (generic function with 1 method)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "function rkf45_step(f::Function, x, θ, t, dt; tol=1e-6, safety=0.9)\n", + " # Butcher tableau coefficients for RKF45\n", + " a21 = 1/4\n", + " a31, a32 = 3/32, 9/32\n", + " a41, a42, a43 = 1932/2197, -7200/2197, 7296/2197\n", + " a51, a52, a53, a54 = 439/216, -8, 3680/513, -845/4104\n", + " a61, a62, a63, a64, a65 = -8/27, 2, -3544/2565, 1859/4104, -11/40\n", + " \n", + " # Coefficients for 4th order solution\n", + " b41, b42, b43, b44, b45 = 25/216, 0, 1408/2565, 2197/4104, -1/5\n", + " \n", + " # Coefficients for 5th order solution\n", + " b51, b52, b53, b54, b55, b56 = 16/135, 0, 6656/12825, 28561/56430, -9/50, 2/55\n", + " \n", + " # Error estimation coefficients (difference between 5th and 4th order solutions)\n", + " e1 = b51 - b41\n", + " e2 = b52 - b42\n", + " e3 = b53 - b43\n", + " e4 = b54 - b44\n", + " e5 = b55 - b45\n", + " e6 = b56 - 0 # b46 is 0 since k6 is not used in the 4th order solution\n", + " \n", + " # Compute the six stages\n", + " k1 = f(x, θ, t)\n", + " k2 = f(x + dt*a21*k1, θ, t + dt/4)\n", + " k3 = f(x + dt*(a31*k1 + a32*k2), θ, t + 3dt/8)\n", + " k4 = f(x + dt*(a41*k1 + a42*k2 + a43*k3), θ, t + 12dt/13)\n", + " k5 = f(x + dt*(a51*k1 + a52*k2 + a53*k3 + a54*k4), θ, t + dt)\n", + " k6 = f(x + dt*(a61*k1 + a62*k2 + a63*k3 + a64*k4 + a65*k5), θ, t + dt/2)\n", + " \n", + " # 4th order solution\n", + " x4 = x + dt*(b41*k1 + b43*k3 + b44*k4 + b45*k5)\n", + " \n", + " # 5th order solution\n", + " x5 = x + dt*(b51*k1 + b53*k3 + b54*k4 + b55*k5 + b56*k6)\n", + " \n", + " # Error estimation\n", + " err = norm(x5 - x4)\n", + " err = max(err, eps())\n", + " if err >= tol\n", + " dt_next = dt * safety * (tol/err)^(1/5)\n", + " else\n", + " dt_next = dt * safety * (tol/err)^(1/4)\n", + " end\n", + "\n", + " return clamp.(x5, -100, 100), dt_next\n", + "end\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we will define some auxiliary functions that are needed for inference and data generation. These functions mainly serve as approximations of the integral of the differential equation in $dt$ interval. First function is a wrapper. The second function transforms the tuple output of the integrator to a vector for further processing with RxInfer. The third function, introduces exponential transformations of the parameters and the time step of the integrator so that we can model them in the log domain. " + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "lorenz_nonlinearity_logdt (generic function with 2 methods)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "lorenz_nonlinearity_data(x, θ, t, dt) = rkf45_step(lorenz_attractor, x, θ, t, dt)\n", + "lorenz_nonlinearity(x, θ, t, dt) = vcat(lorenz_nonlinearity_data(x,θ,t,dt)...)\n", + "lorenz_nonlinearity_logdt(x,logθ,t,logdt) = lorenz_nonlinearity(x,exp.(logθ),t,exp(logdt))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data Generation\n", + "\n", + "First we simulate the Lorenz system with known parameters. Then, we corrupt the states with noise. Then, we select a random set of indices as points of measurement at irregularly sampled interval. " + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Length of simulation: 59464\n", + "Number of observations: 4000\n" + ] + } + ], + "source": [ + "function generate_data(parameters, tspan, start; Σ = 2diageye(3), t = 0, dt = 0.001, rng = StableRNG(42))\n", + " solution = []\n", + " ts = []\n", + " dts = []\n", + " state = start\n", + " tstart, tend = tspan\n", + "\n", + " push!(ts, t)\n", + " push!(dts, dt)\n", + " push!(solution, state)\n", + " \n", + " while t <= tend\n", + " state, dt_new = lorenz_nonlinearity_data(state, parameters, t, dt)\n", + " t += dt_new\n", + " dt = dt_new\n", + " push!(solution , state)\n", + " push!(dts, dt)\n", + " push!(ts, t)\n", + " end\n", + "\n", + "\n", + " observations = [sol + sqrt(Σ)*randn(rng, 3) for sol in solution]\n", + "\n", + " return solution, observations, dts, ts\n", + "end\n", + "\n", + "start = [1.0, 0.0, 0.0]\n", + "tspan = (0.0, 800.0)\n", + "parameters = [10.0,29.0,2.66]\n", + "Nmeasurements = 4000\n", + "Σ = 5diageye(3)\n", + "rng = StableRNG(42)\n", + "\n", + "\n", + "simulation, observations,dts, ts = generate_data(parameters, tspan, start, Σ = Σ);\n", + "discrete_observations = Vector{Union{Missing, Vector{Float64}}}(missing, length(observations))\n", + "data_indices = rand(rng, 1:length(observations), Nmeasurements)\n", + "discrete_observations[data_indices] = observations[data_indices];\n", + "\n", + "println(\"Length of simulation: \", length(simulation))\n", + "println(\"Number of observations: \", Nmeasurements)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# RxInfer model definition\n", + "\n", + "Now we are ready to specify the RxInfer model that we are going to use to identify the Lorenz system. Since we are interested in online estimation and we do not know the length of the observations in advence, we will create a \"one-time-segment\" graph. The model will accept statistics from previous time steps and other relevant hyper-parameters such as $A$ and $\\Sigma$ matrices. We assume Gaussian priors for the parameters and the discretization intervals in log-domain. The function `lorenz_nonlinearity_logdt` will transform the parameters and the $dt$ to their respective domains. Since `lorenz_nonlinearity_logdt` outputs also the next time step, the state `x` defined below, will have extra dimension that records $\\log \\mathrm{d}t$. We need to extract the first three components from the output of this function as observations will be noisy realizations of those components. The matrix $A$ will allow us to do this. The matrix $\\Sigma$ is the noise covariance. " + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "@model function lorenz_model(Σ, mθ,Vθ, mx, Vx, obs, A, log_dt_m, log_dt_V)\n", + " logθ ~ MvNormalMeanCovariance(mθ, Vθ)\n", + " xprev ~ MvNormalMeanCovariance(mx, Vx)\n", + " log_dt ~ NormalMeanVariance(log_dt_m, log_dt_V)\n", + " x := lorenz_nonlinearity_logdt(xprev, logθ, 0.0, log_dt) \n", + " obs ~ MvNormalMeanCovariance(A*x, Σ)\n", + "end" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Meta specification\n", + "Due to non-linearity induced by `lorenz_nonlinearity_logdt`, we will resort to approximation methods around this function. For that purpose we will utilize Generalized Unscented Transform, which is an improved version of Unscented Transform. We will specify the Generalized Unscented Transform using `@meta` macro. " + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "lorenz_meta (generic function with 1 method)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "@meta function lorenz_meta()\n", + " lorenz_nonlinearity_logdt() -> DeltaMeta(\n", + " method = GenUnscented{FromTo(Multivariate, Multivariate)}(7, (4,)), \n", + " inverse = nothing\n", + " )\n", + "end" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Autoupdates and initializations \n", + "Because we are updating the parameters and states in an online fashion, we need to define how these updates will be defined on the parameters of the distributions. We will specify the form of these updates with `@initialization` macro. Since `x` encapsulates both states and $\\log \\mathrm{d}t$, we need to specify how to update the corresponding distributions. For the states, we pass the mean and covariance of all the dimensions except the last dimension of the posterior distribution to the next step as the prior statistics. For $\\log \\mathrm{d}t $, things are a bit more complicated. The reason is as follows. Non-linear node returns $\\mathrm{d}t$, however the update needs to happen in log domain. Luckily, we can easily perform this update if we recognize that $\\mathrm{d}t$ will be log-Normal distributed as it is defined as the exponential transform of a Gaussian distributed random variable $\\log \\mathrm{d}t$. Due to this we can take the statistics of the log-Normally distributed $\\mathrm{d}t$ from the last elements of $x$ and updated them in the log domain with `custom_mean_cov_dt` function." + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "log_normal_stats (generic function with 1 method)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "function custom_mean_cov_x(q)\n", + " mx = mean(q)[1:end-1]\n", + " Vx = cov(q)[1:end-1, 1:end-1]\n", + " return mx, Vx\n", + "end\n", + "function custom_mean_cov_dt(q)\n", + " mx = mean(q)[end] + 1e-12 ## in case of zero division\n", + " Vx = cov(q)[end,end]\n", + "\n", + " V = log(abs(Vx / mx^2 + 1))\n", + " m = log(abs(mx)) - V/2\n", + " return m, V\n", + "end\n", + "update = @autoupdates begin\n", + " mx, Vx = custom_mean_cov_x(q(x))\n", + " log_dt_m, log_dt_V = custom_mean_cov_dt(q(x))\n", + " mθ, Vθ = mean_cov(q(logθ))\n", + "end\n", + "\n", + "\n", + "@initialization function init()\n", + " q(x) = MvNormalMeanCovariance([start;0.01], 1e-4*diageye(4))\n", + " q(logθ) = MvNormalMeanCovariance(ones(3), diageye(3))\n", + "end\n", + "\n", + "#Mean and variance of log-normal distribution\n", + "function log_normal_stats(m,v)\n", + " return exp(m + v/2), (exp(v) -1)*(exp(2*m + v))\n", + "end\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Inference\n", + "\n", + "We are now ready to call the `infer` function. For that we pass the `discrete_observations` containing `missing` and actual values as data, alongside the `model`, `meta`, `autoupdates` and `initialization` functions we have defined." + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "RxInferenceEngine:\n", + " Posteriors stream | enabled for (anonymous_var_graphppl, logθ, log_dt, xprev, x)\n", + " Free Energy stream | disabled\n", + " Posteriors history | available for (anonymous_var_graphppl, logθ, log_dt, xprev, x)\n", + " Free Energy history | unavailable\n", + " Enabled events | [ ]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "A = [1 0 0 0; 0 1 0 0; 0 0 1 0]\n", + "\n", + "res = infer(\n", + " model = lorenz_model(Σ = Σ, A = A),\n", + " data = (obs =discrete_observations,),\n", + " meta = lorenz_meta(),\n", + " keephistory = length(discrete_observations),\n", + " autoupdates = update,\n", + " initialization = init(),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "logθ_posteriors = res.history[:logθ]\n", + "stat_tuples = map(d -> log_normal_stats.(mean(d),var(d)), logθ_posteriors)\n", + "ms = map(t -> [t[1][1], t[2][1], t[3][1]], stat_tuples)\n", + "vs = map(t -> [t[1][2], t[2][2], t[3][2]], stat_tuples)\n", + ";" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Create a comprehensive subplot layout with all parameters and states\n", + "# Parameter plots\n", + "param_names = [\"σ\", \"ρ\", \"β\"]\n", + "param_plots = []\n", + "\n", + "from_param = length(ms)-400\n", + "skip_param = 1\n", + "to_param = length(ms)\n", + "\n", + "for i in 1:3\n", + " p = plot(\n", + " ts[from_param:skip_param:to_param], \n", + " getindex.(ms,i)[from_param:skip_param:to_param], \n", + " ribbon = sqrt.(getindex.(vs,i)[from_param:skip_param:to_param]), \n", + " fillalpha = 0.3, \n", + " linewidth = 1.6, \n", + " color = :blue, \n", + " label = \"posterior\",\n", + " title = \"Parameter $(param_names[i]) Posterior\",\n", + " xlabel = \"Time\"\n", + " )\n", + " hline!(p, [parameters[i]], linewidth = 2, linecolor = :black, label = \"true parameter\")\n", + " push!(param_plots, p)\n", + "end\n", + "\n", + "# State component plots\n", + "state_component_names = [\"x\", \"y\", \"z\"]\n", + "state_plots = []\n", + "\n", + "from_state = length(ts)-400\n", + "skip_state = 1\n", + "to_state = length(ts)\n", + "\n", + "states_posterior = res.history[:x]\n", + "m_states = mean.(states_posterior)\n", + "v_states = var.(states_posterior)\n", + "\n", + "for i in 1:3\n", + " p = plot(\n", + " ts[from_state:skip_state:to_state],\n", + " getindex.(m_states,i)[from_state:skip_state:to_state],\n", + " ribbon = sqrt.(getindex.(v_states,i)[from_state:skip_state:to_state]), \n", + " fillalpha = 0.3, \n", + " linewidth = 1.6, \n", + " color = :blue,\n", + " label = \"posterior\",\n", + " title = \"State Component $(state_component_names[i]) Posterior\",\n", + " xlabel = \"Time\"\n", + " )\n", + " \n", + " # Filter non-missing observations and their corresponding timestamps\n", + " valid_indices = findall(j -> !ismissing(discrete_observations[j]), from_state:skip_state:to_state)\n", + " valid_ts = ts[from_state:skip_state:to_state][valid_indices]\n", + " valid_obs = discrete_observations[from_state:skip_state:to_state][valid_indices]\n", + " \n", + " # Plot only non-missing observations\n", + " scatter!(p, valid_ts, [obs[i] for obs in valid_obs], color = :black, ms = 2.8, label = \"observations\")\n", + " plot!(p, ts[from_state:skip_state:to_state], [sim[i] for sim in simulation[from_state:skip_state:to_state]], \n", + " color = :green, linewidth = 2, label = \"true simulation\")\n", + " \n", + " push!(state_plots, p)\n", + "end\n", + "\n", + "# Time step posterior plot\n", + "logdt_posteriors = res.history[:log_dt]\n", + "stat_tuples = map(d -> log_normal_stats(mean(d),var(d)), logdt_posteriors)\n", + "m_logdt = map(t -> t[1], stat_tuples)\n", + "v_logdt = map(t -> t[2], stat_tuples)\n", + "from_dt = length(ts)-400\n", + "to_dt = length(m_logdt)\n", + "skip_dt = 1\n", + "\n", + "dt_plot = plot(\n", + " ts[from_dt:skip_dt:to_dt], \n", + " m_logdt[from_dt:skip_dt:to_dt], \n", + " ribbon = sqrt.(v_logdt[from_dt:skip_dt:to_dt]), \n", + " fillalpha = 0.2, \n", + " linewidth = 1.6, \n", + " color = :blue,\n", + " label = \"posterior of dt\",\n", + " title = \"Time Step Posterior\",\n", + " xlabel = \"Time\"\n", + ")\n", + "\n", + "plot!(dt_plot, ts[from_dt:skip_dt:to_dt], [dts[i] for i in from_dt:skip_dt:to_dt], linewidth = 1.6,color = :green, label = \"true dt\")\n", + "\n", + "# Combine all plots into a single figure with layout\n", + "combined_plot = plot(\n", + " param_plots[1], param_plots[2], param_plots[3],\n", + " state_plots[1], state_plots[2], state_plots[3],\n", + " dt_plot,\n", + " layout = (6, 2), \n", + " size = (1200, 900), \n", + " legend = true\n", + ")\n", + "\n", + "display(combined_plot)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# BONUS: Same methodology applied to Fitz-Hugh-Nagumo attractor" + ] + }, + { + "cell_type": "code", + "execution_count": 224, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "fitzhugh_nagumo_nonlinearity_logdt (generic function with 1 method)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "function fitzhugh_nagumo_attractor(ϕ, θ, t)\n", + " v,w = ϕ\n", + " l,τinv,a,b = θ\n", + " dv = v - 0.33*v^3 -w + l\n", + " dw = τinv*(v + a - b*w)\n", + "\n", + " return [dv,dw]\n", + "end\n", + "\n", + "fitzhugh_nagumo_nonlinearity_data(x, θ, t, dt) = rkf45_step(fitzhugh_nagumo_attractor, x, θ, t, dt)\n", + "fitzhugh_nagumo_nonlinearity(x, θ, t, dt) = vcat(fitzhugh_nagumo_nonlinearity_data(x,θ,t,dt)...)\n", + "fitzhugh_nagumo_nonlinearity_logdt(x,logθ,t,logdt) = fitzhugh_nagumo_nonlinearity(x,exp.(logθ),t,exp(logdt))" + ] + }, + { + "cell_type": "code", + "execution_count": 225, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Length of simulation: 172\n" + ] + } + ], + "source": [ + "function generate_data_fitzhugh_nagumo(parameters, tspan, start; Σ = 2diageye(2), t = 0, dt = 0.001, rng = StableRNG(42))\n", + " solution = []\n", + " ts = []\n", + " dts = []\n", + " state = start\n", + " tstart, tend = tspan\n", + "\n", + " push!(ts, t)\n", + " push!(dts, dt)\n", + " push!(solution, state)\n", + " \n", + " while t <= tend\n", + " state, dt_new = fitzhugh_nagumo_nonlinearity_data(state, parameters, t, dt)\n", + " t += dt_new\n", + " dt = dt_new\n", + " push!(solution , state)\n", + " push!(dts, dt)\n", + " push!(ts, t)\n", + " end\n", + "\n", + "\n", + " observations = [sol + sqrt(Σ)*randn(rng, 2) for sol in solution]\n", + "\n", + " return solution, observations, dts, ts\n", + "end\n", + "\n", + "start = [1.0, 1.0]\n", + "tspan = (0.0, 40.0)\n", + "parameters = [0.7,0.8,0.08,0.5]\n", + "Nmeasurements = 200\n", + "Σ = 0.04diageye(2)\n", + "rng = StableRNG(42)\n", + "\n", + "\n", + "simulation, observations,dts, ts = generate_data_fitzhugh_nagumo(parameters, tspan, start, Σ = Σ);\n", + "discrete_observations = Vector{Union{Missing, Vector{Float64}}}(missing, length(observations))\n", + "data_indices = rand(rng, 1:length(observations),Nmeasurements)\n", + "discrete_observations[data_indices] = observations[data_indices];\n", + "\n", + "println(\"Length of simulation: \", length(simulation))\n", + "# println(\"Number of observations: \", Nmeasurements)" + ] + }, + { + "cell_type": "code", + "execution_count": 226, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "init_fitzhugh_nagumo (generic function with 1 method)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "@model function fitzhugh_nagumo_model(Σ, mθ,Vθ, mx, Vx, obs, A, log_dt_m, log_dt_V)\n", + " logθ ~ MvNormalMeanCovariance(mθ, Vθ)\n", + " xprev ~ MvNormalMeanCovariance(mx, Vx)\n", + " log_dt ~ NormalMeanVariance(log_dt_m, log_dt_V)\n", + " x := fitzhugh_nagumo_nonlinearity_logdt(xprev, logθ, 0.0, log_dt) \n", + " obs ~ MvNormalMeanCovariance(A*x, Σ)\n", + "end\n", + "\n", + "@meta function fitzhugh_nagumo_meta()\n", + " fitzhugh_nagumo_nonlinearity_logdt() -> DeltaMeta(\n", + " method = GenUnscented{FromTo(Multivariate, Multivariate)}(7, (3,)), \n", + " inverse = nothing\n", + " )\n", + "end\n", + "\n", + "\n", + "@initialization function init_fitzhugh_nagumo()\n", + " q(x) = MvNormalMeanCovariance([start;0.01], 1e-6*diageye(3))\n", + " q(logθ) = MvNormalMeanCovariance([0, 0,0,0], 5diageye(4))\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 227, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "RxInferenceEngine:\n", + " Posteriors stream | enabled for (anonymous_var_graphppl, logθ, log_dt, xprev, x)\n", + " Free Energy stream | disabled\n", + " Posteriors history | available for (anonymous_var_graphppl, logθ, log_dt, xprev, x)\n", + " Free Energy history | unavailable\n", + " Enabled events | [ ]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "A = [1 0 0 ; 0 1 0 ]\n", + "\n", + "res = infer(\n", + " model = fitzhugh_nagumo_model(Σ = Σ, A = A),\n", + " data = (obs =discrete_observations,),\n", + " meta = fitzhugh_nagumo_meta(),\n", + " keephistory = length(discrete_observations),\n", + " autoupdates = update,\n", + " initialization = init_fitzhugh_nagumo(),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 228, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "logθ_posteriors = res.history[:logθ]\n", + "stat_tuples = map(d -> log_normal_stats.(mean(d),var(d)), logθ_posteriors)\n", + "\n", + "ms = map(t -> [t[1][1], t[2][1], t[3][1], t[4][1]], stat_tuples)\n", + "vs = map(t -> [t[1][2], t[2][2], t[3][2], t[4][2]], stat_tuples)\n", + ";" + ] + }, + { + "cell_type": "code", + "execution_count": 229, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Create a comprehensive subplot layout with all parameters and states\n", + "# Parameter plots\n", + "param_names = [\"l\", \"invτ\", \"a\", \"b\"]\n", + "param_plots = []\n", + "\n", + "from_param = 10\n", + "skip_param = 1\n", + "to_param = length(ms)\n", + "\n", + "for i in 1:4\n", + " p = plot(\n", + " ts[from_param:skip_param:to_param], \n", + " getindex.(ms,i)[from_param:skip_param:to_param], \n", + " ribbon = sqrt.(getindex.(vs,i)[from_param:skip_param:to_param]), \n", + " fillalpha = 0.3, \n", + " linewidth = 1.6, \n", + " color = :blue, \n", + " label = \"posterior\",\n", + " title = \"Parameter $(param_names[i]) Posterior\",\n", + " xlabel = \"Time\"\n", + " )\n", + " hline!(p, [parameters[i]], linewidth = 2, linecolor = :black, label = \"true parameter\")\n", + " push!(param_plots, p)\n", + "end\n", + "\n", + "# State component plots\n", + "state_component_names = [\"x\", \"y\", \"z\"]\n", + "state_plots = []\n", + "\n", + "from_state = 10\n", + "skip_state = 1\n", + "to_state = length(ts)\n", + "\n", + "states_posterior = res.history[:x]\n", + "m_states = mean.(states_posterior)\n", + "v_states = var.(states_posterior)\n", + "\n", + "for i in 1:2\n", + " p = plot(\n", + " ts[from_state:skip_state:to_state],\n", + " getindex.(m_states,i)[from_state:skip_state:to_state],\n", + " ribbon = sqrt.(getindex.(v_states,i)[from_state:skip_state:to_state]), \n", + " fillalpha = 0.3, \n", + " linewidth = 1.6, \n", + " color = :blue,\n", + " label = \"posterior\",\n", + " title = \"State Component $(state_component_names[i]) Posterior\",\n", + " xlabel = \"Time\"\n", + " )\n", + " \n", + " # Filter non-missing observations and their corresponding timestamps\n", + " valid_indices = findall(j -> !ismissing(discrete_observations[j]), from_state:skip_state:to_state)\n", + " valid_ts = ts[from_state:skip_state:to_state][valid_indices]\n", + " valid_obs = discrete_observations[from_state:skip_state:to_state][valid_indices]\n", + " \n", + " # Plot only non-missing observations\n", + " scatter!(p, valid_ts, [obs[i] for obs in valid_obs], color = :black, ms = 2.8, label = \"observations\")\n", + " plot!(p, ts[from_state:skip_state:to_state], [sim[i] for sim in simulation[from_state:skip_state:to_state]], \n", + " color = :green, linewidth = 2, label = \"true simulation\")\n", + " \n", + " push!(state_plots, p)\n", + "end\n", + "\n", + "# Time step posterior plot\n", + "logdt_posteriors = res.history[:log_dt]\n", + "stat_tuples = map(d -> log_normal_stats(mean(d),var(d)), logdt_posteriors)\n", + "m_logdt = map(t -> t[1], stat_tuples)\n", + "v_logdt = map(t -> t[2], stat_tuples)\n", + "from_dt = 10\n", + "to_dt = length(m_logdt)\n", + "skip_dt = 1\n", + "\n", + "dt_plot = plot(\n", + " ts[from_dt:skip_dt:to_dt], \n", + " m_logdt[from_dt:skip_dt:to_dt], \n", + " ribbon = sqrt.(v_logdt[from_dt:skip_dt:to_dt]), \n", + " fillalpha = 0.2, \n", + " linewidth = 1.6, \n", + " color = :blue,\n", + " label = \"posterior of dt\",\n", + " title = \"Time Step Posterior\",\n", + " xlabel = \"Time\"\n", + ")\n", + "\n", + "plot!(dt_plot, ts[from_dt:skip_dt:to_dt], [dts[i] for i in from_dt:skip_dt:to_dt], linewidth = 1.6,color = :green, label = \"true dt\")\n", + "\n", + "# Combine all plots into a single figure with layout\n", + "combined_plot = plot(\n", + " param_plots[1], param_plots[2], param_plots[3], param_plots[4],\n", + " state_plots[1], state_plots[2],\n", + " dt_plot,\n", + " layout = (6, 2), \n", + " size = (1200, 900), \n", + " legend = true\n", + ")\n", + "\n", + "display(combined_plot)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.11.2", + "language": "julia", + "name": "julia-1.11" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/Problem Specific/Lorenz Differential Equation/delta_node_rules.jl b/examples/Problem Specific/Lorenz Differential Equation/delta_node_rules.jl new file mode 100644 index 00000000..6da9447f --- /dev/null +++ b/examples/Problem Specific/Lorenz Differential Equation/delta_node_rules.jl @@ -0,0 +1,57 @@ +using ReactiveMP +using ExpectationApproximations, ExponentialFamily, BayesBase +import ReactiveMP: getmethod, DeltaMeta +ReactiveMP.is_delta_node_compatible(::GenUnscented) = Val(true) + +ReactiveMP.deltafn_rule_layout(::DeltaFnNode, ::GenUnscented, inverse::Nothing) = ReactiveMP.DeltaFnDefaultRuleLayout() +ReactiveMP.deltafn_rule_layout(::DeltaFnNode, ::GenUnscented, inverse::Function) = ReactiveMP.DeltaFnDefaultKnownInverseRuleLayout() + +# # unknown inverse +@rule ReactiveMP.DeltaFn((:in, k), Marginalisation) (q_ins::JointNormal, m_in::NormalDistributionsFamily, meta::DeltaMeta{M, I}) where {M <: GenUnscented, I <: Nothing} = begin + # Divide marginal on inx by forward message + ξ_inx, Λ_inx = weightedmean_precision(component(q_ins, k)) + ξ_fw_inx, Λ_fw_inx = weightedmean_precision(m_in) + ξ_bw_inx = ξ_inx - ξ_fw_inx + Λ_bw_inx = Λ_inx - Λ_fw_inx # Note: subtraction might lead to posdef violations + return convert(promote_variate_type(typeof(ξ_inx), NormalWeightedMeanPrecision), ξ_bw_inx, Λ_bw_inx) +end + +# known inverse, single input +@rule DeltaFn((:in, _), Marginalisation) (m_out::NormalDistributionsFamily, m_ins::Nothing, meta::DeltaMeta{M, I}) where {M <: GenUnscented, I <: Function} = begin + return approximate(getmethod(meta), getnodefn(meta, Val(:in)), (m_out,)) +end + +@rule DeltaFn((:in, k), Marginalisation) ( + m_out::NormalDistributionsFamily, m_ins::ManyOf{N, NormalDistributionsFamily}, meta::DeltaMeta{M, I} +) where {N, M <: GenUnscented, L, I <: NTuple{L, Function}} = begin + return approximate(getmethod(meta), getnodefn(meta, Val(:in), k), (m_out, m_ins...)) +end + + + +@marginalrule ReactiveMP.DeltaFn(:ins) (m_out::NormalDistributionsFamily, m_ins::ManyOf{N, NormalDistributionsFamily}, meta::DeltaMeta{M}) where {N, M <: GenUnscented} = begin + # Approximate joint inbounds + statistics = mean_cov.(m_ins) + μs_fw_in = first.(statistics) + Σs_fw_in = last.(statistics) + sizes = size.(m_ins) + (μ_tilde, Σ_tilde,_, _, C_tilde) = ExpectationApproximations.unscented_statistics(getmethod(meta),m_ins, getnodefn(meta, Val(:out)), Val(true)) + + joint = convert(JointNormal, μs_fw_in, Σs_fw_in) + (μ_fw_in, Σ_fw_in) = mean_cov(joint) + ds = ExponentialFamily.dimensionalities(joint) + + # Apply the RTS smoother + (μ_bw_out, Σ_bw_out) = mean_cov(m_out) + + (μ_in, Σ_in) = ReactiveMP.smoothRTS(μ_tilde, Σ_tilde, C_tilde, μ_fw_in, Σ_fw_in, μ_bw_out, Σ_bw_out) + + dist = convert(promote_variate_type(typeof(μ_in), NormalMeanVariance), μ_in, Σ_in) + return JointNormal(dist, sizes) +end + + +@rule ReactiveMP.DeltaFn(:out, Marginalisation) (m_ins::ManyOf{N, NormalDistributionsFamily}, meta::DeltaMeta{M}) where {N, M <: GenUnscented} = begin + res = approximate(getmethod(meta), getnodefn(meta, Val(:out)), m_ins) + return res +end \ No newline at end of file diff --git a/examples/Problem Specific/Lorenz Differential Equation/meta.jl b/examples/Problem Specific/Lorenz Differential Equation/meta.jl new file mode 100644 index 00000000..102872cf --- /dev/null +++ b/examples/Problem Specific/Lorenz Differential Equation/meta.jl @@ -0,0 +1,7 @@ +return ( + title = "Lorenz Differential Equation", + description = """ + This example implements online state and parameter estimation for the Lorenz Differential Equation. + """, + tags = ["problem specific", "lorenz", "differential equation", "online", "parameter estimation", "system identification"] +) \ No newline at end of file