Merge pull request #5 from willtebbutt/wct/stheno-0.7-upgrades

Upgrade to AbstractGPs API

Project.toml

@@ -1,13 +1,13 @@
 name = "GPARs"
 uuid = "86ee5ac1-314e-4b70-9100-2b12109404ad"
-authors = ["WT <wt0881@my.bristol.ac.uk> and contributors"]
-version = "0.1.0"
+authors = ["Will Tebbutt and contributors"]
+version = "0.2.0"
 
 [deps]
+AbstractGPs = "99985d1d-32ba-4be9-9821-2ec096f28918"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
-Stheno = "8188c328-b5d6-583d-959b-9690869a5511"
 
 [compat]
+AbstractGPs = "0.2.25"
 julia = "1.5"
-Stheno = "0.6"

README.md

@@ -12,13 +12,15 @@ We also maintain a [Python version of this package](https://github.com/wesselb/g
 ## Basic Usage
 
 ```julia
+using AbstractGPs
 using GPARs
 using Random
-using Stheno
 
 # Build a GPAR from a collection of GPs. For more info on how to specify particular
-# kernels and their parameters, please see [Stheno.jl](https://github.com/willtebbutt/Stheno.jl). You should think of this as a vector-valued regressor.
-f = GPAR([GP(EQ(), GPC()) for _ in 1:3])
+# kernels and their parameters, please see [AbstractGPs.jl](https://github.com/willtebbutt/AbstractGPs.jl) or
+# [Stheno.jl](https://github.com/willtebbutt/Stheno.jl)
+# You should think of this as a vector-valued regressor.
+f = GPAR([GP(SEKernel()) for _ in 1:3])
 
 # Specify inputs. `ColVecs` says "interpret this matrix as a vector of column-vecrors".
 # Inputs are 2 dimensional, and there are 10 of them. This means that the pth GP in f
@@ -40,14 +42,16 @@ logpdf(f(x, Σs), y)
 
 # Generate a new GPAR that is conditioned on these observations. This is just another
 # GPAR object (in the simplest case, GPARs are closed under conditioning).
-f_post = GPARs.posterior(f(x, Σs), y)
+f_post = posterior(f(x, Σs), y)
 
 # Since `f_post` is just another GPAR, we can use it to generate posterior samples
 # and to compute log posterior predictive probabilities in the same way as the prior.
 x_post = ColVecs(randn(2, 15))
+rng = MersenneTwister(123456)
 y_post = rand(rng, f_post(x, Σs))
 logpdf(f_post(x, Σs), y_post)
 ```
 
 Using this functionality, you have everything you need to do learning using standard
 off-the-shelf functionality ([Zygote.jl](https://github.com/FluxML/Zygote.jl/) to get gradients, [Optim.jl](https://github.com/JuliaNLSolvers/Optim.jl) to get optimisers such as (L-)BFGS, and [ParameterHandling.jl](https://github.com/invenia/ParameterHandling.jl/) to make dealing with large numbers of model parameters more straightforward.
+See the examples in [Stheno.jl](https://github.com/willtebbutt/Stheno.jl)'s docs for inspiration.

src/GPARs.jl

@@ -1,7 +1,7 @@
 module GPARs
 
 using LinearAlgebra
-using Stheno
+using AbstractGPs
 using Random
 
 include("gpar.jl")

src/gpar.jl

@@ -3,19 +3,19 @@
 
 
 """
-struct GPAR{Tfs} <: Stheno.AbstractGP # this is a bit of a hack, as a GPAR isn't a GP.
+struct GPAR{Tfs} <: AbstractGPs.AbstractGP # this is a bit of a hack, as a GPAR isn't a GP.
     fs::Tfs
 end
 
 dim_out(f::GPAR) = length(f.fs)
 
-(f::GPAR)(x::ColVecs, Σs) = Stheno.FiniteGP(f, x, Σs)
+(f::GPAR)(x::ColVecs, Σs) = AbstractGPs.FiniteGP(f, x, Σs)
 
-const FiniteGPAR = Stheno.FiniteGP{<:GPAR}
+const FiniteGPAR = AbstractGPs.FiniteGP{<:GPAR}
 
 extract_data(fx::FiniteGPAR) = fx.f, fx.x.X, fx.Σy
 
-function Stheno.rand(rng::AbstractRNG, fx::FiniteGPAR)
+function AbstractGPs.rand(rng::AbstractRNG, fx::FiniteGPAR)
     f, X, Σs = extract_data(fx)
     Y = Matrix{Float64}(undef, 0, length(fx.x))
 
@@ -27,7 +27,7 @@ function Stheno.rand(rng::AbstractRNG, fx::FiniteGPAR)
     return ColVecs(Y)
 end
 
-function Stheno.logpdf(fx::FiniteGPAR, y::ColVecs)
+function AbstractGPs.logpdf(fx::FiniteGPAR, y::ColVecs)
     f, X, Σs = extract_data(fx)
     Y = y.X
 
@@ -39,12 +39,12 @@ function Stheno.logpdf(fx::FiniteGPAR, y::ColVecs)
     return l
 end
 
-function posterior(fx::FiniteGPAR, y::ColVecs)
+function AbstractGPs.posterior(fx::FiniteGPAR, y::ColVecs)
     f, X, Σs = extract_data(fx)
     Y = y.X
     fs_post = map(enumerate(f.fs)) do (p, f_p)
         x_p = ColVecs(vcat(X, Y[1:p-1, :]))
-        return f_p | (f_p(x_p, Σs[p]) ← Y[p, :])
+        return posterior(f_p(x_p, Σs[p]), Y[p, :])
     end
     return GPAR(fs_post)
 end

test/Project.toml

@@ -1,4 +1,4 @@
 [deps]
+AbstractGPs = "99985d1d-32ba-4be9-9821-2ec096f28918"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
-Stheno = "8188c328-b5d6-583d-959b-9690869a5511"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

test/gpar.jl

@@ -4,7 +4,7 @@
     D_out = 3
 
     rng = MersenneTwister(123456)
-    f = GPAR([GP(EQ(), GPC()) for _ in 1:D_out])
+    f = GPAR([GP(SEKernel()) for _ in 1:D_out])
     x = ColVecs(randn(D_in, N))
     Σs = [rand(rng) + 0.1 for _ in 1:D_out]
 

test/runtests.jl

@@ -1,6 +1,6 @@
+using AbstractGPs
 using GPARs
 using Random
-using Stheno
 using Test
 
 using GPARs: posterior