Introduce JuliaFormatter with style=blue

.JuliaFormatter.toml

@@ -0,0 +1 @@
+style = "blue"

.github/workflows/ci.yml

@@ -47,3 +47,29 @@ jobs:
         with:
             github-token: ${{ secrets.GITHUB_TOKEN }}
             path-to-lcov: ./lcov.info
+
+  format:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: julia-actions/setup-julia@latest
+        with:
+          version: 1
+
+      - uses: actions/checkout@v1
+      - name: Install JuliaFormatter and format
+        # The version of JuliaFormatter used is just to show how to specify the version. The latest
+        # version would be preferrable.
+        run: |
+          julia  -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter", version="0.12.2"))'
+          julia  -e 'using JuliaFormatter; format(".", verbose=true)'
+      - name: Format check
+        run: |
+          julia -e '
+          out = Cmd(`git diff --name-only`) |> read |> String
+          if out == ""
+              exit(0)
+          else
+              @error "Some files have not been formatted !!!"
+              write(stdout, out)
+              exit(1)
+          end'

benchmark/MLKernels.jl

@@ -3,16 +3,18 @@ using MLKernels
 SUITE["MLKernels"] = BenchmarkGroup()
 
 mlkernelnames = ["SquaredExponentialKernel"]
-kernels=Dict{String,MLKernels.Kernel}()
+kernels = Dict{String,MLKernels.Kernel}()
 for k in mlkernelnames
     SUITE["MLKernels"][k] = BenchmarkGroup()
-    kernels[k] = eval(Meta.parse("MLKernels."*k*"(alpha)"))
+    kernels[k] = eval(Meta.parse("MLKernels." * k * "(alpha)"))
 end
 
 for k in mlkernelnames
-    SUITE["MLKernels"][k]["k(X,Y)"] = @benchmarkable MLKernels.kernelmatrix($(kernels[k]),$X,$Y)
+    SUITE["MLKernels"][k]["k(X,Y)"] = @benchmarkable MLKernels.kernelmatrix(
+        $(kernels[k]), $X, $Y
+    )
     # SUITE["MLKernels"][k][kt]["k!(X,Y)"] = @benchmarkable MLKernels.kernelmatrix!(KXY,$(kernels[k][kt]),$X,$Y) setup=(KXY=copy($KXY))
-    SUITE["MLKernels"][k]["k(X)"] = @benchmarkable MLKernels.kernelmatrix($(kernels[k]),$X)
+    SUITE["MLKernels"][k]["k(X)"] = @benchmarkable MLKernels.kernelmatrix($(kernels[k]), $X)
     # SUITE["MLKernels"][k][kt]["k!(X)"] = @benchmarkable MLKernels.kernelmatrix!(KX,$(kernels[k][kt]),$X) setup=(KX=copy($KX))
     # SUITE["MLKernels"][k][kt]["kdiag(X)"] = @benchmarkable MLKernels.kerneldiagmatrix($(kernels[k][kt]),$X)
     # SUITE["MLKernels"][k][kt]["kdiag!(X)"] = @benchmarkable MLKernels.kerneldiagmatrix!(kX,$(kernels[k][kt]),$X) setup=(kX=copy($kX))

benchmark/benchmarks.jl

@@ -7,16 +7,17 @@ const SUITE = BenchmarkGroup()
 Random.seed!(1234)
 
 dim = 50
-N1 = 1000; N2 = 500;
+N1 = 1000;
+N2 = 500;
 alpha = 2.0
 
-X = rand(Float64,N1,dim)
-Y = rand(Float64,N2,dim)
+X = rand(Float64, N1, dim)
+Y = rand(Float64, N2, dim)
 
-KXY = rand(Float64,N1,N2)
-KX = rand(Float64,N1,N1)
-sKX = Symmetric(rand(Float64,N1,N1))
-kX = rand(Float64,N1)
+KXY = rand(Float64, N1, N2)
+KX = rand(Float64, N1, N1)
+sKX = Symmetric(rand(Float64, N1, N1))
+kX = rand(Float64, N1)
 
 include("kernelmatrix.jl")
 include("MLKernels.jl")

benchmark/kernelmatrix.jl

@@ -3,22 +3,34 @@ using KernelFunctions
 SUITE["KernelFunctions"] = BenchmarkGroup()
 
 kernelnames = ["SqExponentialKernel"]
-kerneltypes = ["ARD","ISO"]
-kernels=Dict{String,Dict{String,KernelFunctions.Kernel}}()
+kerneltypes = ["ARD", "ISO"]
+kernels = Dict{String,Dict{String,KernelFunctions.Kernel}}()
 for k in kernelnames
     kernels[k] = Dict{String,KernelFunctions.Kernel}()
     SUITE["KernelFunctions"][k] = BenchmarkGroup()
     for kt in kerneltypes
         SUITE["KernelFunctions"][k][kt] = BenchmarkGroup()
-        kernels[k][kt] = eval(Meta.parse("KernelFunctions."*k*"("*(kt == "ARD" ? "alpha*ones(Float64,dim)" : "alpha" )*")"))
+        kernels[k][kt] = eval(
+            Meta.parse(
+                "KernelFunctions." *
+                k *
+                "(" *
+                (kt == "ARD" ? "alpha*ones(Float64,dim)" : "alpha") *
+                ")",
+            ),
+        )
     end
 end
 
 for k in kernelnames
     for kt in kerneltypes
-        SUITE["KernelFunctions"][k][kt]["k(X,Y)"] = @benchmarkable KernelFunctions.kernelmatrix($(kernels[k][kt]),$X,$Y,obsdim=1)
+        SUITE["KernelFunctions"][k][kt]["k(X,Y)"] = @benchmarkable KernelFunctions.kernelmatrix(
+            $(kernels[k][kt]), $X, $Y; obsdim=1
+        )
         # SUITE["KernelFunctions"][k][kt]["k!(X,Y)"] = @benchmarkable KernelFunctions.kernelmatrix!(KXY,$(kernels[k][kt]),$X,$Y) setup=(KXY=copy($KXY))
-        SUITE["KernelFunctions"][k][kt]["k(X)"] = @benchmarkable KernelFunctions.kernelmatrix($(kernels[k][kt]),$X,obsdim=1)
+        SUITE["KernelFunctions"][k][kt]["k(X)"] = @benchmarkable KernelFunctions.kernelmatrix(
+            $(kernels[k][kt]), $X; obsdim=1
+        )
         # SUITE["KernelFunctions"][k][kt]["k!(X)"] = @benchmarkable KernelFunctions.kernelmatrix!(KX,$(kernels[k][kt]),$X) setup=(KX=copy($KX))
         # SUITE["KernelFunctions"][k][kt]["kdiag(X)"] = @benchmarkable KernelFunctions.kerneldiagmatrix($(kernels[k][kt]),$X)
         # SUITE["KernelFunctions"][k][kt]["kdiag!(X)"] = @benchmarkable KernelFunctions.kerneldiagmatrix!(kX,$(kernels[k][kt]),$X) setup=(kX=copy($kX))

docs/create_kernel_plots.jl

@@ -1,77 +1,106 @@
-using Plots; pyplot();
+using Plots;
+pyplot();
 using Distributions
 using LinearAlgebra
 using KernelFunctions
 # Translational invariants kernels
 
-default(lw=3.0,titlefontsize=28,tickfontsize=18)
+default(; lw=3.0, titlefontsize=28, tickfontsize=18)
 
-x₀ = 0.0; l = 0.1
+x₀ = 0.0;
+l = 0.1;
 n_grid = 101
-fill(x₀,n_grid,1)
-xrange = reshape(collect(range(-3,3,length=n_grid)),:,1)
+fill(x₀, n_grid, 1)
+xrange = reshape(collect(range(-3, 3; length=n_grid)), :, 1)
 
-k = transform(SqExponentialKernel(),1.0)
-K1 = kernelmatrix(k,xrange,obsdim=1)
-p = heatmap(K1,yflip=true,colorbar=false,framestyle=:none,background_color=RGBA(0.0,0.0,0.0,0.0))
-savefig(joinpath(@__DIR__,"src","assets","heatmap_sqexp.png"))
+k = transform(SqExponentialKernel(), 1.0)
+K1 = kernelmatrix(k, xrange; obsdim=1)
+p = heatmap(
+    K1;
+    yflip=true,
+    colorbar=false,
+    framestyle=:none,
+    background_color=RGBA(0.0, 0.0, 0.0, 0.0),
+)
+savefig(joinpath(@__DIR__, "src", "assets", "heatmap_sqexp.png"))
 
+k = @kernel Matern32Kernel FunctionTransform(x -> (sin.(x)) .^ 2)
+K2 = kernelmatrix(k, xrange; obsdim=1)
+p = heatmap(
+    K2;
+    yflip=true,
+    colorbar=false,
+    framestyle=:none,
+    background_color=RGBA(0.0, 0.0, 0.0, 0.0),
+)
+savefig(joinpath(@__DIR__, "src", "assets", "heatmap_matern.png"))
 
-k = @kernel Matern32Kernel FunctionTransform(x->(sin.(x)).^2)
-K2 = kernelmatrix(k,xrange,obsdim=1)
-p = heatmap(K2,yflip=true,colorbar=false,framestyle=:none,background_color=RGBA(0.0,0.0,0.0,0.0))
-savefig(joinpath(@__DIR__,"src","assets","heatmap_matern.png"))
+k = transform(PolynomialKernel(; c=0.0, d=2.0), LinearTransform(randn(3, 1)))
+K3 = kernelmatrix(k, xrange; obsdim=1)
+p = heatmap(
+    K3;
+    yflip=true,
+    colorbar=false,
+    framestyle=:none,
+    background_color=RGBA(0.0, 0.0, 0.0, 0.0),
+)
+savefig(joinpath(@__DIR__, "src", "assets", "heatmap_poly.png"))
 
+k =
+    0.5 * SqExponentialKernel() * transform(LinearKernel(), 0.5) +
+    0.4 * (@kernel Matern32Kernel() FunctionTransform(x -> sin.(x)))
+K4 = kernelmatrix(k, xrange; obsdim=1)
+p = heatmap(
+    K4;
+    yflip=true,
+    colorbar=false,
+    framestyle=:none,
+    background_color=RGBA(0.0, 0.0, 0.0, 0.0),
+)
+savefig(joinpath(@__DIR__, "src", "assets", "heatmap_prodsum.png"))
 
-k = transform(PolynomialKernel(c=0.0,d=2.0), LinearTransform(randn(3,1)))
-K3 = kernelmatrix(k,xrange,obsdim=1)
-p = heatmap(K3,yflip=true,colorbar=false,framestyle=:none,background_color=RGBA(0.0,0.0,0.0,0.0))
-savefig(joinpath(@__DIR__,"src","assets","heatmap_poly.png"))
-
-k = 0.5*SqExponentialKernel()*transform(LinearKernel(),0.5) + 0.4*(@kernel Matern32Kernel() FunctionTransform(x->sin.(x)))
-K4 = kernelmatrix(k,xrange,obsdim=1)
-p = heatmap(K4,yflip=true,colorbar=false,framestyle=:none,background_color=RGBA(0.0,0.0,0.0,0.0))
-savefig(joinpath(@__DIR__,"src","assets","heatmap_prodsum.png"))
-
-plot(heatmap.([K1,K2,K3,K4],yflip=true,colorbar=false)...,layout=(2,2))
-savefig(joinpath(@__DIR__,"src","assets","heatmap_combination.png"))
+plot(heatmap.([K1, K2, K3, K4], yflip=true, colorbar=false)...; layout=(2, 2))
+savefig(joinpath(@__DIR__, "src", "assets", "heatmap_combination.png"))
 
 ##
 
-for k in [SqExponentialKernel,ExponentialKernel]
-    K = kernelmatrix(k(),xrange,obsdim=1)
-    v = rand(MvNormal(K+1e-7I))
-    plot(xrange,v,lab="",title="f(x)",framestyle=:none) |> display
-    savefig(joinpath(@__DIR__,"src","assets","GP_sample_$(k).png"))
-    plot(xrange,kernel.(k(),x₀,xrange),lab="",ylims=(0,1.1),title="k(0,x)") |> display
-    savefig(joinpath(@__DIR__,"src","assets","kappa_function_$(k).png"))
+for k in [SqExponentialKernel, ExponentialKernel]
+    K = kernelmatrix(k(), xrange; obsdim=1)
+    v = rand(MvNormal(K + 1e-7I))
+    display(plot(xrange, v; lab="", title="f(x)", framestyle=:none))
+    savefig(joinpath(@__DIR__, "src", "assets", "GP_sample_$(k).png"))
+    display(plot(xrange, kernel.(k(), x₀, xrange); lab="", ylims=(0, 1.1), title="k(0,x)"))
+    savefig(joinpath(@__DIR__, "src", "assets", "kappa_function_$(k).png"))
 end
 
-for k in [GammaExponentialKernel(1.0,1.5)]
-    sparse =1
-    while !isposdef(kernelmatrix(k,xrange*sparse,obsdim=1) + 1e-5I); sparse += 1; end
-    v = rand(MvNormal(kernelmatrix(k,xrange*sparse,obsdim=1)+1e-7I))
-    plot(xrange,v,lab="",title="f(x)",framestyle=:none) |> display
-    savefig(joinpath(@__DIR__,"src","assets","GP_sample_GammaExponentialKernel.png"))
-    plot(xrange,kernel.(k,x₀,xrange),lab="",ylims=(0,1.1),title="k(0,x)") |> display
-    savefig(joinpath(@__DIR__,"src","assets","kappa_function_GammaExponentialKernel.png"))
+for k in [GammaExponentialKernel(1.0, 1.5)]
+    sparse = 1
+    while !isposdef(kernelmatrix(k, xrange * sparse; obsdim=1) + 1e-5I)
+        sparse += 1
+    end
+    v = rand(MvNormal(kernelmatrix(k, xrange * sparse; obsdim=1) + 1e-7I))
+    display(plot(xrange, v; lab="", title="f(x)", framestyle=:none))
+    savefig(joinpath(@__DIR__, "src", "assets", "GP_sample_GammaExponentialKernel.png"))
+    display(plot(xrange, kernel.(k, x₀, xrange); lab="", ylims=(0, 1.1), title="k(0,x)"))
+    savefig(
+        joinpath(@__DIR__, "src", "assets", "kappa_function_GammaExponentialKernel.png")
+    )
 end
 
-for k in [MaternKernel,Matern32Kernel,Matern52Kernel]
-    K = kernelmatrix(k(),xrange,obsdim=1)
-    v = rand(MvNormal(K+1e-7I))
-    plot(xrange,v,lab="",title="f(x)",framestyle=:none) |> display
-    savefig(joinpath(@__DIR__,"src","assets","GP_sample_$(k).png"))
-    plot(xrange,kernel.(k(),x₀,xrange),lab="",ylims=(0,1.1),title="k(0,x)") |> display
-    savefig(joinpath(@__DIR__,"src","assets","kappa_function_$(k).png"))
+for k in [MaternKernel, Matern32Kernel, Matern52Kernel]
+    K = kernelmatrix(k(), xrange; obsdim=1)
+    v = rand(MvNormal(K + 1e-7I))
+    display(plot(xrange, v; lab="", title="f(x)", framestyle=:none))
+    savefig(joinpath(@__DIR__, "src", "assets", "GP_sample_$(k).png"))
+    display(plot(xrange, kernel.(k(), x₀, xrange); lab="", ylims=(0, 1.1), title="k(0,x)"))
+    savefig(joinpath(@__DIR__, "src", "assets", "kappa_function_$(k).png"))
 end
 
-
 for k in [RationalQuadraticKernel]
-    K = kernelmatrix(k(),xrange,obsdim=1)
-    v = rand(MvNormal(K+1e-7I))
-    plot(xrange,v,lab="",title="f(x)",framestyle=:none) |> display
-    savefig(joinpath(@__DIR__,"src","assets","GP_sample_$(k).png"))
-    plot(xrange,kernel.(k(),x₀,xrange),lab="",ylims=(0,1.1),title="k(0,x)") |> display
-    savefig(joinpath(@__DIR__,"src","assets","kappa_function_$(k).png"))
+    K = kernelmatrix(k(), xrange; obsdim=1)
+    v = rand(MvNormal(K + 1e-7I))
+    display(plot(xrange, v; lab="", title="f(x)", framestyle=:none))
+    savefig(joinpath(@__DIR__, "src", "assets", "GP_sample_$(k).png"))
+    display(plot(xrange, kernel.(k(), x₀, xrange); lab="", ylims=(0, 1.1), title="k(0,x)"))
+    savefig(joinpath(@__DIR__, "src", "assets", "kappa_function_$(k).png"))
 end

docs/make.jl

@@ -8,22 +8,23 @@ DocMeta.setdocmeta!(
     recursive=true,
 )
 
-makedocs(
-    sitename = "KernelFunctions",
-    format = Documenter.HTML(),
-    modules = [KernelFunctions],
-    pages = ["Home"=>"index.md",
-             "User Guide" => "userguide.md",
-             "Examples"=>"example.md",
-             "Kernel Functions"=>"kernels.md",
-             "Input Transforms"=>"transform.md",
-             "Metrics"=>"metrics.md",
-             "Theory"=>"theory.md",
-             "Custom Kernels"=>"create_kernel.md",
-             "API"=>"api.md"]
+makedocs(;
+    sitename="KernelFunctions",
+    format=Documenter.HTML(),
+    modules=[KernelFunctions],
+    pages=[
+        "Home" => "index.md",
+        "User Guide" => "userguide.md",
+        "Examples" => "example.md",
+        "Kernel Functions" => "kernels.md",
+        "Input Transforms" => "transform.md",
+        "Metrics" => "metrics.md",
+        "Theory" => "theory.md",
+        "Custom Kernels" => "create_kernel.md",
+        "API" => "api.md",
+    ],
 )
 
 deploydocs(;
-    repo = "github.com/JuliaGaussianProcesses/KernelFunctions.jl.git",
-    push_preview = true,
+    repo="github.com/JuliaGaussianProcesses/KernelFunctions.jl.git", push_preview=true
 )

examples/deepkernellearning.jl

@@ -10,26 +10,31 @@ Flux.@functor KernelSum
 Flux.@functor Matern32Kernel
 Flux.@functor FunctionTransform
 
-neuralnet = Chain(Dense(1,3),Dense(3,2))
+neuralnet = Chain(Dense(1, 3), Dense(3, 2))
 k = SqExponentialKernel(FunctionTransform(neuralnet))
-xmin = -3; xmax = 3
-x = range(xmin,xmax,length=100)
-x_test = rand(Uniform(xmin,xmax),200)
-x,y = noisy_function(sinc,x;noise=0.1)
-X = reshape(x,:,1)
+xmin = -3;
+xmax = 3;
+x = range(xmin, xmax; length=100)
+x_test = rand(Uniform(xmin, xmax), 200)
+x, y = noisy_function(sinc, x; noise=0.1)
+X = reshape(x, :, 1)
 λ = [0.1]
-f(x,k,λ) = kernelmatrix(k,X,x,obsdim=1)*inv(kernelmatrix(k,X,obsdim=1)+exp(λ[1])*I)*y
-f(X,k,1.0)
-loss(k,λ) = f(X,k,λ) |> ŷ ->sum(y-ŷ)/length(y)+exp(λ[1])*norm(ŷ)
-loss(k,λ)
+function f(x, k, λ)
+    return kernelmatrix(k, X, x; obsdim=1) *
+           inv(kernelmatrix(k, X; obsdim=1) + exp(λ[1]) * I) *
+           y
+end
+f(X, k, 1.0)
+loss(k, λ) = ŷ -> sum(y - ŷ) / length(y) + exp(λ[1]) * norm(ŷ)(f(X, k, λ))
+loss(k, λ)
 ps = Flux.params(k)
 # push!(ps,λ)
 opt = Flux.Momentum(1.0)
 ##
 for i in 1:10
-    grads = Zygote.gradient(()->loss(k,λ),ps)
-    Flux.Optimise.update!(opt,ps,grads)
-    p = Plots.scatter(x,y,lab="data",title="Loss = $(loss(k,λ))")
-    Plots.plot!(x,f(X,k,λ),lab="Prediction",lw=3.0)
+    grads = Zygote.gradient(() -> loss(k, λ), ps)
+    Flux.Optimise.update!(opt, ps, grads)
+    p = Plots.scatter(x, y; lab="data", title="Loss = $(loss(k,λ))")
+    Plots.plot!(x, f(X, k, λ); lab="Prediction", lw=3.0)
     display(p)
 end