Deploying to gh-pages from @ 3811de8 🚀

Author: fonsp

.gitignore

@@ -0,0 +1,3 @@
+
+.DS_Store
+**/* backup *.jl

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Bayesian Machine Learning for Information Processing
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,67 @@
+# Software installation _(for students)_
+
+Welcome to Bayesian Machine Learning for Information Processing! This course combines mathematical theory and **software implementation**, so that you can _learn by doing_. 
+
+A bit of **background information** about the software we are using:
+
+## Julia and RxInfer
+For the coding, we use the [Julia programming language](https://julialang.org/). Julia is a high-level programming language (like Python, Matlab, R, JavaScript, etc) which makes it easy to use for complex tasks, but it has the advantage that you can write very fast numerical code (like C++, Rust, Fortran, etc). Not convinced? _Learning Julia is also a [good way to get better at other languages like Python](https://plutojl.org/en/docs/education/#why-julia-for-education)!_
+
+At the [BIASLab](https://biaslab.github.io/), we have developed a specialized package for probabilistic programming and Bayesian inference in Julia: [RxInfer.jl](https://rxinfer.com/). We will use RxInfer in the later lectures, in the Probabilistic Programming lectures and in the assignments. You don't need to install RxInfer manually, it will be loaded automatically when you open a lecture/assignment that uses it.
+
+## Pluto
+We use the [Pluto programming environment](https://plutojl.org) for course materials and for assignments. Pluto is an educational notebook environment, which makes it ideal for interactive lectures (with buttons and sliders), and for your assignments (with easy setup, improved error messages, live documentation, and more). 
+
+Pluto was developed at MIT to teach the course [Computational Thinking](https://computationalthinking.mit.edu/), the first interactive Julia course website. Pluto is now being developed at TU/e, specifically for this course! So if you have any feedback about Pluto, or you would like to contribute, contact [Fons](github.com/fonsp)!
+
+# How to install
+
+## 1️⃣ Julia
+First, start by installing Julia. Follow the instructions on https://julialang.org/install/ . We recommend reading this page carefully. 
+
+Now you have Julia installed! Check that you know **how to start Julia**, and run `1 + 1` (should give `2`). You need at least Julia 1.10 for this course.
+
+## 2️⃣ Pluto
+Next, you can install and run **Pluto**. This is easy, because Julia has an easy built-in package manager. 
+
+👉 Follow the instructions on https://plutojl.org/#install
+
+## 3️⃣ That's it
+Because Pluto has a built-in package manager, this is all you need to do for now. 🌟 When you open a lecture or assignment, Pluto will automatically make sure that the right packages are installed. When a package has not been used for a while, Julia will automatically delete it.
+
+
+
+
+# ⚠️ Not working?
+If you encounter **any problems**, please contact us in class or on Piazza.
+
+# 🙋 Feedback
+If you have feedback about Pluto, RxInfer or Julia (positive, negative, ideas), please write something in Piazza or tell us in class. Feedback is really valuable for me (Fons), to guide the development of Pluto! 
+
+
+
+
+# 🗑️ Uninstall
+To uninstall Julia and all the packages that you used, you can run the following commands in your terminal:
+
+Linux/MacOS:
+
+```
+# Uninstall Julia and juliaup
+juliaup self uninstall
+
+# Remove the Julia installation caches
+rm -rf ~/.julia
+```
+
+For Windows Powershell, replace the last command with:
+
+```
+Remove-Item -Recurse -Force "$env:USERPROFILE\.julia"
+```
+
+For Windows Command Prompt, replace the last command with:
+
+```
+rmdir /s /q %USERPROFILE%\.julia
+```

Software installation.md

@@ -0,0 +1,27 @@
+function initializeAgent()
+    m_s_t_min = s_0 # Set initial brain state prior
+    v_s_t_min = 0.01
+
+    # Initialize messages and marginals dictionary
+    messages = Vector{Message}(undef, 59)
+    marginals = Dict{Symbol, ProbabilityDistribution}()
+    function infer(u_t::Float64, o_t::Float64)
+        data = Dict(:o_t       => o_t, 
+                    :u_t       => u_t, 
+                    :m_o       => zeros(T-1), 
+                    :v_o       => sigma*ones(T-1),
+                    :m_s_t_min => m_s_t_min,
+                    :v_s_t_min => v_s_t_min)
+
+        step!(data, marginals, messages)
+    end
+
+    marginals[:u_2] = ProbabilityDistribution(Univariate, GaussianMeanVariance, m=0.0, v=tiny) # Register initial action
+    act() = mode(marginals[:u_2]) # Choose the mode of the current control state as action
+
+    function slide(slide_msg_idx=7)
+        (m_s_t_min, V_s_t_min) = ForneyLab.unsafeMeanCov(messages[slide_msg_idx].dist) # Reset prior state statistics
+    end
+
+    return (infer, act, slide)    
+end

assets/ai_agent/ Mountain Car Problem

@@ -0,0 +1,101 @@
+# Internal dynamic model
+function g(s_t_min::Vector{Float64}, u_t::Vector{Float64}) # Transition function
+    ϕ_t_min = s_t_min[1]
+    x_t_min = s_t_min[2]
+    y_t_min = s_t_min[3]
+
+    Δϕ_t = u_t[1]
+    r_t = u_t[2]
+
+    # Compute next state
+    ϕ_t = ϕ_t_min + Δϕ_t
+    x_t = x_t_min + r_t*cos(ϕ_t)
+    y_t = y_t_min + r_t*sin(ϕ_t)
+
+    s_t = [ϕ_t, x_t, y_t]
+
+    return s_t
+end
+
+function g_inv_in1(s_t::Vector{Float64}, u_t::Vector{Float64}) # Inverse transition function towards previous state
+    ϕ_t = s_t[1]
+    x_t = s_t[2]
+    y_t = s_t[3]
+
+    Δϕ_t = u_t[1]
+    r_t = u_t[2]
+
+    # Compute previous state
+    ϕ_t_min = ϕ_t - Δϕ_t
+    x_t_min = x_t - r_t*cos(ϕ_t)
+    y_t_min = y_t - r_t*sin(ϕ_t)
+
+    s_t_min = [ϕ_t_min, x_t_min, y_t_min]
+
+    return s_t_min    
+end
+
+function g_inv_in2(s_t::Vector{Float64}, s_t_min::Vector{Float64}) # Inverse transition function towards control
+    ϕ_t_min = s_t_min[1]
+    x_t_min = s_t_min[2]
+    y_t_min = s_t_min[3]
+
+    ϕ_t = s_t[1]
+    x_t = s_t[2]
+    y_t = s_t[3]
+
+    # Compute corresponding control
+    Δϕ_t = ϕ_t - ϕ_t_min
+    if Δϕ_t > 0.0
+        Δϕ_t_tor = Δϕ_t - 2*pi
+    else
+        Δϕ_t_tor = Δϕ_t + 2*pi
+    end
+    if abs(Δϕ_t_tor) < abs(Δϕ_t)
+        Δϕ_t = Δϕ_t_tor
+    end
+    Δx_t = x_t - x_t_min
+    Δy_t = y_t - y_t_min
+    r_t = sign(Δx_t*cos(ϕ_t) + Δy_t*sin(ϕ_t))*sqrt(Δx_t^2 + Δy_t^2)
+    
+    u_t = [Δϕ_t, r_t]
+
+    return u_t
+end
+
+function initializeAgent()
+    m_s_t_min = [ϕ_0, x_0, y_0] # Set initial brain state prior
+    V_s_t_min = 0.01*diageye(3)
+
+    # Initialize messages and marginals dictionary
+    messages = Vector{Message}(undef, 59)
+    marginals = Dict{Symbol, ProbabilityDistribution}()
+    function infer(u_t::Vector{Float64}, o_t::Vector{Float64})
+        x_t_c = m_s_t_min[2]
+        y_t_c = m_s_t_min[3]
+        θ_t = atan(y_t_c, x_t_c)
+        if θ_t < 0
+            m = [θ_t + pi, 0.0, 0.0] # Goal prior mean with orientation against polar angle
+        else
+            m = [θ_t - pi, 0.0, 0.0]
+        end
+
+        data = Dict(:o_t       => o_t, 
+                    :u_t       => u_t, 
+                    :m_o       => [m for k=2:T], 
+                    :V_o       => [Sigma for k=2:T],
+                    :m_s_t_min => m_s_t_min,
+                    :V_s_t_min => V_s_t_min)
+
+        step!(data, marginals, messages)
+    end
+
+    marginals[:u_2] = ProbabilityDistribution(Multivariate, GaussianMeanVariance, m=zeros(2), v=tiny*diageye(2)) # Register initial action
+    act() = mode(marginals[:u_2]) # Choose the mode of the current control state as action
+
+    function slide(slide_msg_idx=7)
+        (m_s_t_min, V_s_t_min) = ForneyLab.unsafeMeanCov(messages[slide_msg_idx].dist) # Reset prior state statistics
+    end
+
+    return (infer, act, slide)    
+end