Merge pull request #116 from ArnoStrouwen/md

format markdown

Author: ChrisRackauckas

.JuliaFormatter.toml

@@ -1 +1,2 @@
 style = "sciml"
+format_markdown = true

README.md

@@ -7,11 +7,11 @@
 [![Build Status](https://github.com/SciML/NeuralOperators.jl/workflows/CI/badge.svg)](https://github.com/SciML/NeuralOperators.jl/actions?query=workflow%3ACI)
 [![Build status](https://badge.buildkite.com/be853055db9e309317157b7e2983e752b60705502e622a139e.svg?branch=main)](https://buildkite.com/julialang/neuraloperators-dot-jl)
 
-[![ColPrac: Contributor's Guide on Collaborative Practices for Community Packages](https://img.shields.io/badge/ColPrac-Contributor's%20Guide-blueviolet)](https://github.com/SciML/ColPrac)
+[![ColPrac: Contributor's Guide on Collaborative Practices for Community Packages](https://img.shields.io/badge/ColPrac-Contributor%27s%20Guide-blueviolet)](https://github.com/SciML/ColPrac)
 [![SciML Code Style](https://img.shields.io/static/v1?label=code%20style&message=SciML&color=9558b2&labelColor=389826)](https://github.com/SciML/SciMLStyle)
 
-| **Ground Truth** | **Inferenced** |
-|:----------------:|:--------------:|
+| **Ground Truth**                            | **Inferenced**                                     |
+|:-------------------------------------------:|:--------------------------------------------------:|
 | ![](example/FlowOverCircle/gallery/ans.gif) | ![](example/FlowOverCircle/gallery/inferenced.gif) |
 
 The demonstration showing above is Navier-Stokes equation learned by the `MarkovNeuralOperator` with only one time step information.
@@ -44,35 +44,32 @@ It is important that the output size of the branch and trunk subnets is same so
 
 ```julia
 model = Chain(
-    # lift (d + 1)-dimensional vector field to n-dimensional vector field
-    # here, d == 1 and n == 64
-    Dense(2, 64),
-    # map each hidden representation to the next by integral kernel operator
-    OperatorKernel(64=>64, (16, ), FourierTransform, gelu),
-    OperatorKernel(64=>64, (16, ), FourierTransform, gelu),
-    OperatorKernel(64=>64, (16, ), FourierTransform, gelu),
-    OperatorKernel(64=>64, (16, ), FourierTransform),
-    # project back to the scalar field of interest space
-    Dense(64, 128, gelu),
-    Dense(128, 1),
-)
+              # lift (d + 1)-dimensional vector field to n-dimensional vector field
+              # here, d == 1 and n == 64
+              Dense(2, 64),
+              # map each hidden representation to the next by integral kernel operator
+              OperatorKernel(64 => 64, (16,), FourierTransform, gelu),
+              OperatorKernel(64 => 64, (16,), FourierTransform, gelu),
+              OperatorKernel(64 => 64, (16,), FourierTransform, gelu),
+              OperatorKernel(64 => 64, (16,), FourierTransform),
+              # project back to the scalar field of interest space
+              Dense(64, 128, gelu),
+              Dense(128, 1))
 ```
 
 Or one can just call:
 
 ```julia
-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)
 ```
 
 And then train as a Flux model.
 
 ```julia
 loss(𝐱, 𝐲) = l₂loss(model(𝐱), 𝐲)
-opt = Flux.Optimiser(WeightDecay(1f-4), Flux.Adam(1f-3))
+opt = Flux.Optimiser(WeightDecay(1.0f-4), Flux.Adam(1.0f-3))
 Flux.@epochs 50 Flux.train!(loss, params(model), data, opt)
 ```
 
@@ -83,6 +80,7 @@ Flux.@epochs 50 Flux.train!(loss, params(model), data, opt)
 # followed by activations for branch and trunk respectively
 model = DeepONet((32, 64, 72), (24, 64, 72), σ, tanh)
 ```
+
 Or specify branch and trunk as separate `Chain` from Flux and pass to `DeepONet`
 
 ```julia
@@ -100,7 +98,7 @@ evalcb() = @show(loss(xval, yval, grid))
 learning_rate = 0.001
 opt = Adam(learning_rate)
 parameters = params(model)
-Flux.@epochs 400 Flux.train!(loss, parameters, [(xtrain, ytrain, grid)], opt, cb=evalcb)
+Flux.@epochs 400 Flux.train!(loss, parameters, [(xtrain, ytrain, grid)], opt, cb = evalcb)
 ```
 
 ## Examples
@@ -129,9 +127,12 @@ PDE training examples are provided in `example` folder.
 
 ## References
 
-- [Fourier Neural Operator for Parametric Partial Differential Equations](https://arxiv.org/abs/2010.08895)
-  - [zongyi-li/fourier_neural_operator](https://github.com/zongyi-li/fourier_neural_operator)
-- [Neural Operator: Graph Kernel Network for Partial Differential Equations](https://arxiv.org/abs/2003.03485)
-  - [zongyi-li/graph-pde](https://github.com/zongyi-li/graph-pde)
-- [Markov Neural Operators for Learning Chaotic Systems](https://arxiv.org/abs/2106.06898)
-- [DeepONet: Learning nonlinear operators for identifying  differential equations based on the universal approximation theorem of operators](https://arxiv.org/abs/1910.03193)
+  - [Fourier Neural Operator for Parametric Partial Differential Equations](https://arxiv.org/abs/2010.08895)
+    
+      + [zongyi-li/fourier_neural_operator](https://github.com/zongyi-li/fourier_neural_operator)
+
+  - [Neural Operator: Graph Kernel Network for Partial Differential Equations](https://arxiv.org/abs/2003.03485)
+    
+      + [zongyi-li/graph-pde](https://github.com/zongyi-li/graph-pde)
+  - [Markov Neural Operators for Learning Chaotic Systems](https://arxiv.org/abs/2106.06898)
+  - [DeepONet: Learning nonlinear operators for identifying  differential equations based on the universal approximation theorem of operators](https://arxiv.org/abs/1910.03193)

docs/src/apis.md

@@ -27,7 +27,7 @@ OperatorConv
 
 Reference: [FNO2021](@cite)
 
----
+* * *
 
 ### Operator kernel layer
 
@@ -45,7 +45,7 @@ OperatorKernel
 
 Reference: [FNO2021](@cite)
 
----
+* * *
 
 ### Graph kernel layer
 
@@ -64,7 +64,7 @@ GraphKernel
 
 Reference: [NO2020](@cite)
 
----
+* * *
 
 ## Models
 
@@ -76,7 +76,7 @@ FourierNeuralOperator
 
 Reference: [FNO2021](@cite)
 
----
+* * *
 
 ### Markov neural operator
 
@@ -86,7 +86,7 @@ MarkovNeuralOperator
 
 Reference: [MNO2021](@cite)
 
----
+* * *
 
 ### DeepONet
 
@@ -95,7 +95,7 @@ DeepONet
 NeuralOperators.construct_subnet
 ```
 
----
+* * *
 
 ### NOMAD
 

docs/src/index.md

@@ -5,18 +5,21 @@ CurrentModule = NeuralOperators
 # NeuralOperators
 
 | ![](https://github.com/foldfelis/NeuralOperators.jl/blob/main/example/FlowOverCircle/gallery/ans.gif?raw=true) | ![](https://github.com/foldfelis/NeuralOperators.jl/blob/main/example/FlowOverCircle/gallery/inferenced.gif?raw=true) |
-|:----------------:|:--------------:|
-| **Ground Truth** | **Inferred** |
+|:--------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------:|
+| **Ground Truth**                                                                                               | **Inferred**                                                                                                          |
 
 The demonstration shown above is the Navier-Stokes equation learned by the `MarkovNeuralOperator` with only one time step information.
 The example can be found in [`example/FlowOverCircle`](https://github.com/SciML/NeuralOperators.jl/tree/main/example/FlowOverCircle).
 
-## Quick start
+## Installation
 
-The package can be installed with the Julia package manager. From the Julia REPL, type `]` to enter the Pkg REPL mode and run:
+To install NeuralOperators.jl, use the Julia package manager:
+
+```julia
+using Pkg
+Pkg.add("NeuralOperators")
+```
 
-```julia-repl
-pkg> add NeuralOperators
 ```
 
 ## Usage
@@ -42,18 +45,16 @@ model = Chain(
 Or one can just call:
 
 ```julia
-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)
 ```
 
 And then train as a Flux model.
 
 ```julia
 loss(𝐱, 𝐲) = l₂loss(model(𝐱), 𝐲)
-opt = Flux.Optimiser(WeightDecay(1f-4), Flux.Adam(1f-3))
+opt = Flux.Optimiser(WeightDecay(1.0f-4), Flux.Adam(1.0f-3))
 Flux.@epochs 50 Flux.train!(loss, params(model), data, opt)
 ```
 
@@ -82,61 +83,94 @@ evalcb() = @show(loss(xval, yval, grid))
 learning_rate = 0.001
 opt = Adam(learning_rate)
 parameters = params(model)
-Flux.@epochs 400 Flux.train!(loss, parameters, [(xtrain, ytrain, grid)], opt, cb=evalcb)
+Flux.@epochs 400 Flux.train!(loss, parameters, [(xtrain, ytrain, grid)], opt, cb = evalcb)
 ```
+
 A more complete example using DeepONet architecture to solve Burgers' equation can be found in the [examples](https://github.com/SciML/NeuralOperators.jl/blob/main/example/Burgers/src/Burgers_deeponet.jl).
 
+## Contributing
+
+  - Please refer to the
+    [SciML ColPrac: Contributor's Guide on Collaborative Practices for Community Packages](https://github.com/SciML/ColPrac/blob/master/README.md)
+    for guidance on PRs, issues, and other matters relating to contributing to SciML.
+
+  - See the [SciML Style Guide](https://github.com/SciML/SciMLStyle) for common coding practices and other style decisions.
+  - There are a few community forums:
+    
+      + The #diffeq-bridged and #sciml-bridged channels in the
+        [Julia Slack](https://julialang.org/slack/)
+      + The #diffeq-bridged and #sciml-bridged channels in the
+        [Julia Zulip](https://julialang.zulipchat.com/#narrow/stream/279055-sciml-bridged)
+      + On the [Julia Discourse forums](https://discourse.julialang.org)
+      + See also [SciML Community page](https://sciml.ai/community/)
+
 ## Reproducibility
+
 ```@raw html
 <details><summary>The documentation of this SciML package was built using these direct dependencies,</summary>
 ```
+
 ```@example
 using Pkg # hide
 Pkg.status() # hide
 ```
+
 ```@raw html
 </details>
 ```
+
 ```@raw html
 <details><summary>and using this machine and Julia version.</summary>
 ```
+
 ```@example
 using InteractiveUtils # hide
 versioninfo() # hide
 ```
+
 ```@raw html
 </details>
 ```
+
 ```@raw html
 <details><summary>A more complete overview of all dependencies and their versions is also provided.</summary>
 ```
+
 ```@example
 using Pkg # hide
-Pkg.status(;mode = PKGMODE_MANIFEST) # hide
+Pkg.status(; mode = PKGMODE_MANIFEST) # hide
 ```
+
 ```@raw html
 </details>
 ```
+
 ```@raw html
 You can also download the 
 <a href="
 ```
+
 ```@eval
 using TOML
-version = TOML.parse(read("../../Project.toml",String))["version"]
-name = TOML.parse(read("../../Project.toml",String))["name"]
-link = "https://github.com/SciML/"*name*".jl/tree/gh-pages/v"*version*"/assets/Manifest.toml"
+version = TOML.parse(read("../../Project.toml", String))["version"]
+name = TOML.parse(read("../../Project.toml", String))["name"]
+link = "https://github.com/SciML/" * name * ".jl/tree/gh-pages/v" * version *
+       "/assets/Manifest.toml"
 ```
+
 ```@raw html
 ">manifest</a> file and the
 <a href="
 ```
+
 ```@eval
 using TOML
-version = TOML.parse(read("../../Project.toml",String))["version"]
-name = TOML.parse(read("../../Project.toml",String))["name"]
-link = "https://github.com/SciML/"*name*".jl/tree/gh-pages/v"*version*"/assets/Project.toml"
+version = TOML.parse(read("../../Project.toml", String))["version"]
+name = TOML.parse(read("../../Project.toml", String))["name"]
+link = "https://github.com/SciML/" * name * ".jl/tree/gh-pages/v" * version *
+       "/assets/Project.toml"
 ```
+
 ```@raw html
 ">project</a> file.
-```
+```

example/Burgers/README.md

@@ -3,18 +3,18 @@
 In this example, a [Burgers' equation](https://en.wikipedia.org/wiki/Burgers%27_equation)
 is learned by a one-dimensional Fourier neural operator network.
 
-there is learn the operator mapping the initial condition to last point of time evolition of equation in some function space : 
+there is learn the operator mapping the initial condition to last point of time evolition of equation in some function space :
 
 ```math
 u(x, 0) ->  u(x, t_end)\
 ```
 
-![](gallery/burgers.png) 
+![](gallery/burgers.png)
 
 Change directory to `example/Burgers` and use following commend to train model:
 
 ```julia
+julia> using Burgers;
+       Burgers.train();
 $ julia --proj
-
-julia> using Burgers; Burgers.train()
 ```

example/DoublePendulum/README.md

@@ -14,7 +14,7 @@ By inference the result recurrently, we can generate up to 150 steps with the fi
 Change directory to `example/DoublePendulum` and use following commend to train model:
 
 ```julia
+julia> using DoublePendulum;
+       DoublePendulum.train();
 $ julia --proj
-
-julia> using DoublePendulum; DoublePendulum.train()
 ```

example/FlowOverCircle/README.md

@@ -3,14 +3,14 @@
 The time dependent Navier-Stokes equation is learned by the `MarkovNeuralOperator` with only one time step information.
 The result of this example can be found [here](https://docs.sciml.ai/NeuralOperators/stable/assets/notebook/mno.jl.html).
 
-| **Ground Truth** | **Inferenced** |
-|:----------------:|:--------------:|
+| **Ground Truth**     | **Inferenced**              |
+|:--------------------:|:---------------------------:|
 | ![](gallery/ans.gif) | ![](gallery/inferenced.gif) |
 
 Change directory to `example/FlowOverCircle` and use following commend to train model:
 
 ```julia
+julia> using FlowOverCircle;
+       FlowOverCircle.train();
 $ julia --proj
-
-julia> using FlowOverCircle; FlowOverCircle.train()
 ```

example/SuperResolution/README.md

@@ -5,14 +5,14 @@ The result of this example can be found [here](https://docs.sciml.ai/NeuralOpera
 
 Apart from just training a MNO, here, we train the model with lower resolution (96x64) and inference result with higher resolution (192x128).
 
-| **Ground Truth** | **Inferenced** |
-|:----------------:|:--------------:|
+| **Ground Truth**     | **Inferenced**              |
+|:--------------------:|:---------------------------:|
 | ![](gallery/ans.gif) | ![](gallery/inferenced.gif) |
 
 Change directory to `example/SuperResolution` and use following commend to train model:
 
 ```julia
+julia> using SuperResolution;
+       SuperResolution.train();
 $ julia --proj
-
-julia> using SuperResolution; SuperResolution.train()
 ```