Merge pull request #114 from ArnoStrouwen/md

[skip ci] LanguageTool

Author: ChrisRackauckas

docs/src/apis.md

@@ -17,8 +17,8 @@ v'(x) = \mathcal{F}^{-1} \{ F'(s) \}
 ```
 
 where ``v(x)`` and ``v'(x)`` denotes input and output function,
-``\mathcal{F} \{ \cdot \}``, ``\mathcal{F}^{-1} \{ \cdot \}`` are transform,
-inverse transform, respectively.
+``\mathcal{F} \{ \cdot \}``, ``\mathcal{F}^{-1} \{ \cdot \}`` are the transform and
+the inverse transform, respectively.
 Function ``g`` is a linear transform for lowering spectrum modes.
 
 ```@docs
@@ -35,9 +35,9 @@ Reference: [FNO2021](@cite)
 v_{t+1}(x) = \sigma(W v_t(x) + \mathcal{K} \{ v_t(x) \} )
 ```
 
-where ``v_t(x)`` is the input function for ``t``-th layer and
+where ``v_t(x)`` is the input function for the ``t``'th layer and
 ``\mathcal{K} \{ \cdot \}`` denotes spectral convolutional layer.
-Activation function ``\sigma`` can be arbitrary non-linear function.
+Activation function ``\sigma`` can be an arbitrary non-linear function.
 
 ```@docs
 OperatorKernel
@@ -56,7 +56,7 @@ v_{t+1}(x_i) = \sigma(W v_t(x_i) + \frac{1}{|\mathcal{N}(x_i)|} \sum_{x_j \in \m
 where ``v_t(x_i)`` is the input function for ``t``-th layer,
 ``x_i`` is the node feature for ``i``-th node and
 ``\mathcal{N}(x_i)`` represents the neighbors for ``x_i``.
-Activation function ``\sigma`` can be arbitrary non-linear function.
+Activation function ``\sigma`` can be an arbitrary non-linear function.
 
 ```@docs
 GraphKernel

docs/src/index.md

@@ -6,10 +6,10 @@ CurrentModule = 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** | **Inferenced** |
+| **Ground Truth** | **Inferred** |
 
-The demonstration shown above is Navier-Stokes equation learned by the `MarkovNeuralOperator` with only one time step information.
-Example can be found in [`example/FlowOverCircle`](https://github.com/SciML/NeuralOperators.jl/tree/main/example/FlowOverCircle).
+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
 
@@ -73,7 +73,7 @@ trunk = Chain(Dense(24, 64, tanh), Dense(64, 72, tanh))
 model = DeepONet(branch, trunk)
 ```
 
-You can again specify loss, optimization and training parameters just as you would for a simple neural network with Flux.
+You can again specify loss, optimization, and training parameters just as you would for a simple neural network with Flux.
 
 ```julia
 loss(xtrain, ytrain, sensor) = Flux.Losses.mse(model(xtrain, sensor), ytrain)

docs/src/introduction.md

@@ -21,11 +21,11 @@ by linking the operators into a Markov chain.
 
 ## [Deep Operator Network](https://github.com/SciML/NeuralOperators.jl/blob/main/src/DeepONet/DeepONet.jl)
 
-Deep operator network (DeepONet) learns a neural operator with the help of two sub-neural network structures described as the branch and the trunk network.
-The branch network is fed the initial conditions data, whereas the trunk is fed with the locations where the target(output) is evaluated from the corresponding initial conditions.
-It is important that the output size of the branch and trunk subnets is same so that a dot product can be performed between them.
+Deep operator network (DeepONet) learns a neural operator with the help of two sub-neural network structures, described as the branch and the trunk network.
+The branch network is fed the initial condition data, whereas the trunk is fed with the locations where the target (output) is evaluated from the corresponding initial conditions.
+It is important that the output size of the branch and trunk subnets is the same so that a dot product can be performed between them.
 
 ## [Nonlinear Manifold Decoders for Operator Learning](https://github.com/SciML/NeuralOperators.jl/blob/main/src/NOMAD/NOMAD.jl)
 
-Nonlinear Manifold Decoders for Operator Learning (NOMAD) learns a neural operator with a nonlinear decoder parameterized by a deep neural network which jointly takes output of approximator and the locations as parameters.
-The approximator network is fed with the initial conditions data. The output-of-approximator and the locations are then passed to a decoder neural network to get the target (output). It is important that the input size of the decoder subnet is sum of size of the output-of-approximator and number of locations.
+Nonlinear Manifold Decoders for Operator Learning (NOMAD) learns a neural operator with a nonlinear decoder parameterized by a deep neural network which jointly takes the output of the approximator and the locations as parameters.
+The approximator network is fed with the initial condition data. The output-of-approximator and the locations are then passed to a decoder neural network to get the target (output). It is important that the input size of the decoder subnet is the sum of size of the output-of-approximator and number of locations.

src/DeepONet/DeepONet.jl

@@ -22,7 +22,7 @@ x --- branch --
 y --- trunk ---
 
 Where `x` represents the input function, discretely evaluated at its respective sensors.
-So the ipnut is of shape [m] for one instance or [m x b] for a training set.
+So, the input is of shape [m] for one instance or [m x b] for a training set.
 `y` are the probing locations for the operator to be trained. It has shape [N x n] for
 N different variables in the PDE (i.e. spatial and temporal coordinates) with each n distinct evaluation points.
 `u` is the solution of the queried instance of the PDE, given by the specific choice of parameters.
@@ -38,16 +38,16 @@ You can set up this architecture in two ways:
 flexibility and e.g. use an RNN or CNN instead of simple `Dense` layers.
 
 Strictly speaking, DeepONet does not imply either of the branch or trunk net to be a simple
- DNN. Usually though, this is the case which is why it's treated as the default case here.
+ DNN. Usually this is the case, which is why it's treated as the default case here.
 
 # Example
 
 Consider a transient 1D advection problem ∂ₜu + u ⋅ ∇u = 0, with an IC u(x,0) = g(x).
-We are given several (b = 200) instances of the IC, discretized at 50 points each and want
+We are given several (b = 200) instances of the IC, discretized at 50 points each, and want
  to query the solution for 100 different locations and times [0;1].
 
-That makes the branch input of shape [50 x 200] and the trunk input of shape [2 x 100]. So the
- input for the branch net is 50 and 100 for the trunk net.
+That makes the branch input of shape [50 x 200] and the trunk input of shape [2 x 100]. So, the
+input for the branch net is 50 and 100 for the trunk net.
 
 # Usage
 

src/DeepONet/subnets.jl

@@ -2,7 +2,7 @@
 Construct a Chain of `Dense` layers from a given tuple of integers.
 
 Input:
-A tuple (m,n,o,p) of integer type numbers that each describe the width of the i-th Dense layer to Construct
+A tuple (m,n,o,p) of integer type numbers that each describe the width of the i'th Dense layer to Construct
 
 Output:
 A `Flux` Chain with length of the input tuple and individual width given by the tuple elements

src/FNO/FNO.jl

@@ -18,14 +18,14 @@ Flux.@functor FourierNeuralOperator
 
 Fourier neural operator is a operator learning model that uses Fourier kernel to perform
 spectral convolutions.
-It is a promissing way for surrogate methods, and can be regarded as a physics operator.
+It is a promising way for surrogate methods, and can be regarded as a physics operator.
 
 The model is comprised of
 a `Dense` layer to lift (d + 1)-dimensional vector field to n-dimensional vector field,
 and an integral kernel operator which consists of four Fourier kernels,
 and two `Dense` layers to project data back to the scalar field of interest space.
 
-The role of each channel size described as follow:
+The role of each channel size described as follows:
 
 ```
 [1] input channel number
@@ -133,7 +133,7 @@ a `Dense` layer to lift d-dimensional vector field to n-dimensional vector field
 and an integral kernel operator which consists of four Fourier kernels,
 and a `Dense` layers to project data back to the scalar field of interest space.
 
-The role of each channel size described as follow:
+The role of each channel size described as follows:
 
 ```
 [1] input channel number

src/operator_kernel.jl

@@ -31,10 +31,10 @@ end
 ## Keyword Arguments
 
 * `init`: Initial function to initialize parameters.
-* `permuted`: Whether the dim is permuted. If `permuted=true`, layer accepts
-    data in the order of `(ch, x_1, ... , x_d , batch)`,
-    otherwise the order is `(x_1, ... , x_d, ch, batch)`.
-* `T`: Data type of parameters.
+* `permuted`: Whether the dim is permuted. If `permuted=true`, the layer accepts
+    data in the order of `(ch, x_1, ... , x_d , batch)`.
+    Otherwise the order is `(x_1, ... , x_d, ch, batch)`.
+* `T`: Datatype of parameters.
 
 ## Example
 
@@ -132,7 +132,7 @@ end
 
 ## Keyword Arguments
 
-* `permuted`: Whether the dim is permuted. If `permuted=true`, layer accepts
+* `permuted`: Whether the dim is permuted. If `permuted=true`, the layer accepts
     data in the order of `(ch, x_1, ... , x_d , batch)`,
     otherwise the order is `(x_1, ... , x_d, ch, batch)`.