Merge pull request #72 from SciML/format

Format to SciML Style

Author: foldfelis

.JuliaFormatter.toml

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

.github/workflows/FormatCheck.yml

@@ -0,0 +1,42 @@
+name: format-check
+
+on:
+  push:
+    branches:
+      - 'master'
+      - 'release-'
+    tags: '*'
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        julia-version: [1]
+        julia-arch: [x86]
+        os: [ubuntu-latest]
+    steps:
+      - uses: julia-actions/setup-julia@latest
+        with:
+          version: ${{ matrix.julia-version }}
+
+      - uses: actions/checkout@v1
+      - name: Install JuliaFormatter and format
+        # This will use the latest version by default but you can set the version like so:
+        #
+        # julia  -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter", version="0.13.0"))'
+        run: |
+          julia  -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter"))'
+          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'

docs/make.jl

@@ -2,26 +2,23 @@ using NeuralOperators
 using Documenter
 using DocumenterCitations
 
-bib = CitationBibliography(joinpath(@__DIR__, "bibliography.bib"), sorting=:nyt)
+bib = CitationBibliography(joinpath(@__DIR__, "bibliography.bib"), sorting = :nyt)
 
-DocMeta.setdocmeta!(NeuralOperators, :DocTestSetup, :(using NeuralOperators); recursive=true)
+DocMeta.setdocmeta!(NeuralOperators, :DocTestSetup, :(using NeuralOperators);
+                    recursive = true)
 
 include("pages.jl")
 
-makedocs(
-    bib,
-    modules=[NeuralOperators],
-    authors="JingYu Ning <foldfelis@gmail.com> and contributors",
-    repo="https://github.com/SciML/NeuralOperators.jl/blob/{commit}{path}#{line}",
-    sitename="NeuralOperators.jl",
-    format=Documenter.HTML(;
-        prettyurls=get(ENV, "CI", "false") == "true",
-        canonical="http://neuraloperators.sciml.ai",
-        assets=String[],
-    ),
-    pages=pages,
-)
+makedocs(bib,
+         modules = [NeuralOperators],
+         authors = "JingYu Ning <foldfelis@gmail.com> and contributors",
+         repo = "https://github.com/SciML/NeuralOperators.jl/blob/{commit}{path}#{line}",
+         sitename = "NeuralOperators.jl",
+         format = Documenter.HTML(;
+                                  prettyurls = get(ENV, "CI", "false") == "true",
+                                  canonical = "http://neuraloperators.sciml.ai",
+                                  assets = String[]),
+         pages = pages)
 
 deploydocs(;
-    repo="github.com/SciML/NeuralOperators.jl",
-)
+           repo = "github.com/SciML/NeuralOperators.jl")

docs/pages.jl

@@ -1,8 +1,8 @@
 # Put in a separate page so it can be used by SciMLDocs.jl
 
 pages = [
-        "Home" => "index.md",
-        "Introduction" => "introduction.md",
-        "APIs" => "apis.md",
-        "References" => "references.md",
-    ]
+    "Home" => "index.md",
+    "Introduction" => "introduction.md",
+    "APIs" => "apis.md",
+    "References" => "references.md",
+]

example/Burgers/src/Burgers.jl

@@ -8,19 +8,17 @@ import Flux: params
 include("Burgers_deeponet.jl")
 
 function register_burgers()
-    register(DataDep(
-        "Burgers",
-        """
-        Burgers' equation dataset from
-        [fourier_neural_operator](https://github.com/zongyi-li/fourier_neural_operator)
-        """,
-        "http://www.med.cgu.edu.tw/NeuralOperators/Burgers_R10.zip",
-        "9cbbe5070556c777b1ba3bacd49da5c36ea8ed138ba51b6ee76a24b971066ecd",
-        post_fetch_method=unpack
-    ))
+    register(DataDep("Burgers",
+                     """
+                     Burgers' equation dataset from
+                     [fourier_neural_operator](https://github.com/zongyi-li/fourier_neural_operator)
+                     """,
+                     "http://www.med.cgu.edu.tw/NeuralOperators/Burgers_R10.zip",
+                     "9cbbe5070556c777b1ba3bacd49da5c36ea8ed138ba51b6ee76a24b971066ecd",
+                     post_fetch_method = unpack))
 end
 
-function get_data(; n=2048, Δsamples=2^3, grid_size=div(2^13, Δsamples), T=Float32)
+function get_data(; n = 2048, Δsamples = 2^3, grid_size = div(2^13, Δsamples), T = Float32)
     file = matopen(joinpath(datadep"Burgers", "burgers_data_R10.mat"))
     x_data = T.(collect(read(file, "a")[1:n, 1:Δsamples:end]'))
     y_data = T.(collect(read(file, "u")[1:n, 1:Δsamples:end]'))
@@ -33,19 +31,19 @@ function get_data(; n=2048, Δsamples=2^3, grid_size=div(2^13, Δsamples), T=Flo
     return x_loc_data, reshape(y_data, 1, :, n)
 end
 
-function get_dataloader(; ratio::Float64=0.9, batchsize=100)
-    𝐱, 𝐲 = get_data(n=2048)
-    data_train, data_test = splitobs((𝐱, 𝐲), at=ratio)
+function get_dataloader(; ratio::Float64 = 0.9, batchsize = 100)
+    𝐱, 𝐲 = get_data(n = 2048)
+    data_train, data_test = splitobs((𝐱, 𝐲), at = ratio)
 
-    loader_train = DataLoader(data_train, batchsize=batchsize, shuffle=true)
-    loader_test = DataLoader(data_test, batchsize=batchsize, shuffle=false)
+    loader_train = DataLoader(data_train, batchsize = batchsize, shuffle = true)
+    loader_test = DataLoader(data_test, batchsize = batchsize, shuffle = false)
 
     return loader_train, loader_test
 end
 
 __init__() = register_burgers()
 
-function train(; cuda=true, η₀=1f-3, λ=1f-4, epochs=500)
+function train(; cuda = true, η₀ = 1.0f-3, λ = 1.0f-4, epochs = 500)
     if cuda && CUDA.has_cuda()
         device = gpu
         CUDA.allowscalar(false)
@@ -55,22 +53,21 @@ function train(; cuda=true, η₀=1f-3, λ=1f-4, epochs=500)
         @info "Training on CPU"
     end
 
-    model = FourierNeuralOperator(ch=(2, 64, 64, 64, 64, 64, 128, 1), modes=(16, ), σ=gelu)
+    model = FourierNeuralOperator(ch = (2, 64, 64, 64, 64, 64, 128, 1), modes = (16,),
+                                  σ = gelu)
     data = get_dataloader()
     optimiser = Flux.Optimiser(WeightDecay(λ), Flux.ADAM(η₀))
     loss_func = l₂loss
 
-    learner = Learner(
-        model, data, optimiser, loss_func,
-        ToDevice(device, device),
-    )
+    learner = Learner(model, data, optimiser, loss_func,
+                      ToDevice(device, device))
 
     fit!(learner, epochs)
 
     return learner
 end
 
-function train_nomad(; n=300, cuda=true, learning_rate=0.001, epochs=400)
+function train_nomad(; n = 300, cuda = true, learning_rate = 0.001, epochs = 400)
     if cuda && has_cuda()
         @info "Training on GPU"
         device = gpu
@@ -79,32 +76,31 @@ function train_nomad(; n=300, cuda=true, learning_rate=0.001, epochs=400)
         device = cpu
     end
 
-    x, y = get_data_don(n=n)
+    x, y = get_data_don(n = n)
 
     xtrain = x[1:280, :]'
     ytrain = y[1:280, :]
 
-    xval = x[end-19:end, :]' |> device
-    yval = y[end-19:end, :] |> device
+    xval = x[(end - 19):end, :]' |> device
+    yval = y[(end - 19):end, :] |> device
 
     # grid = collect(range(0, 1, length=1024)') |> device
     grid = rand(collect(0:0.001:1), (280, 1024)) |> device
     gridval = rand(collect(0:0.001:1), (20, 1024)) |> device
 
-
     opt = ADAM(learning_rate)
 
-    m = NOMAD((1024,1024), (2048,1024), gelu, gelu) |> device
+    m = NOMAD((1024, 1024), (2048, 1024), gelu, gelu) |> device
 
     loss(X, y, sensor) = Flux.Losses.mse(m(X, sensor), y)
     evalcb() = @show(loss(xval, yval, gridval))
 
     data = [(xtrain, ytrain, grid)] |> device
-    Flux.@epochs epochs Flux.train!(loss, params(m), data, opt, cb=evalcb)
+    Flux.@epochs epochs Flux.train!(loss, params(m), data, opt, cb = evalcb)
     ỹ = m(xval |> device, gridval |> device)
 
     diffvec = vec(abs.(cpu(yval) .- cpu(ỹ)))
-    mean_diff = sum(diffvec)/length(diffvec)
+    mean_diff = sum(diffvec) / length(diffvec)
     return mean_diff
 end
 

example/Burgers/src/Burgers_deeponet.jl

@@ -1,4 +1,4 @@
-function get_data_don(; n=2048, Δsamples=2^3, grid_size=div(2^13, Δsamples))
+function get_data_don(; n = 2048, Δsamples = 2^3, grid_size = div(2^13, Δsamples))
     file = matopen(joinpath(datadep"Burgers", "burgers_data_R10.mat"))
     x_data = collect(read(file, "a")[1:n, 1:Δsamples:end])
     y_data = collect(read(file, "u")[1:n, 1:Δsamples:end])
@@ -7,7 +7,7 @@ function get_data_don(; n=2048, Δsamples=2^3, grid_size=div(2^13, Δsamples))
     return x_data, y_data
 end
 
-function train_don(; n=300, cuda=true, learning_rate=0.001, epochs=400)
+function train_don(; n = 300, cuda = true, learning_rate = 0.001, epochs = 400)
     if cuda && has_cuda()
         @info "Training on GPU"
         device = gpu
@@ -16,28 +16,28 @@ function train_don(; n=300, cuda=true, learning_rate=0.001, epochs=400)
         device = cpu
     end
 
-    x, y = get_data_don(n=n)
+    x, y = get_data_don(n = n)
 
     xtrain = x[1:280, :]'
     ytrain = y[1:280, :]
 
-    xval = x[end-19:end, :]' |> device
-    yval = y[end-19:end, :] |> device
+    xval = x[(end - 19):end, :]' |> device
+    yval = y[(end - 19):end, :] |> device
 
-    grid = collect(range(0, 1, length=1024)') |> device
+    grid = collect(range(0, 1, length = 1024)') |> device
 
     opt = ADAM(learning_rate)
 
-    m = DeepONet((1024,1024,1024), (1,1024,1024), gelu, gelu) |> device
+    m = DeepONet((1024, 1024, 1024), (1, 1024, 1024), gelu, gelu) |> device
 
     loss(X, y, sensor) = Flux.Losses.mse(m(X, sensor), y)
     evalcb() = @show(loss(xval, yval, grid))
 
     data = [(xtrain, ytrain, grid)] |> device
-    Flux.@epochs epochs Flux.train!(loss, params(m), data, opt, cb=evalcb)
+    Flux.@epochs epochs Flux.train!(loss, params(m), data, opt, cb = evalcb)
     ỹ = m(xval |> device, grid |> device)
 
     diffvec = vec(abs.(cpu(yval) .- cpu(ỹ)))
-    mean_diff = sum(diffvec)/length(diffvec)
+    mean_diff = sum(diffvec) / length(diffvec)
     return mean_diff
 end

example/Burgers/test/runtests.jl

@@ -2,19 +2,19 @@ using Burgers
 using Test
 
 @testset "Burgers" begin
-    xs, ys = Burgers.get_data(n=1000)
+    xs, ys = Burgers.get_data(n = 1000)
 
     @test size(xs) == (2, 1024, 1000)
     @test size(ys) == (1, 1024, 1000)
 
-    learner = Burgers.train(epochs=10)
+    learner = Burgers.train(epochs = 10)
     loss = learner.cbstate.metricsepoch[ValidationPhase()][:Loss].values[end]
     @test loss < 0.1
 
     # include("deeponet.jl")
 end
 
 @testset "Burger: NOMAD Training Accuracy" begin
-    ϵ = Burgers.train_nomad(; cuda=true, epochs=100)
+    ϵ = Burgers.train_nomad(; cuda = true, epochs = 100)
     @test ϵ < 0.4 # epoch=100 returns 0.233
-end
+end