Fix Typos in Documentation from Eric

Co-authored-by: Eric Gustin <[email protected]>

Author: Sam Partee

CITATION.cff

@@ -13,17 +13,17 @@ authors:
   - family-names: Bachman
     given-names: Scott
     orcid: https://orcid.org/0000-0002-6479-4300
-  - family-names: Gustavo
-    given-names: Marques
+  - family-names: Marques
+    given-names: Gustavo
     orcid: https://orcid.org/0000-0001-7238-0290
-  - family-names: Andrew
-    given-names: Shao
+  - family-names: Shao
+    given-names: Andrew
     orcid: https://orcid.org/0000-0003-3658-512X
   - family-names: Benjamin
     given-names: Robbins
     orcid: https://orcid.org/0000-0003-3658-512X
 
-title: "Using Machine Learning at Scale in HPCSimulations with SmartSim: An Application to Ocean Climate Modeling"
+title: "Using Machine Learning at Scale in HPC Simulations with SmartSim: An Application to Ocean Climate Modeling"
 doi: 10.5281/zenodo.4682270
 date-released: 2021-4-12
-license: "BSD-2-Clause"
+license: "BSD-2-Clause"

doc/tutorials/inference.rst

@@ -5,16 +5,16 @@ Online Inference
 
 Compiling TensorFlow or PyTorch runtimes into each existing simulation is
 difficult. Maintaining that type of integration with the rapidly growing and changing
-APIs of libaries like TensorFlow and PyTorch is even more difficult.
+APIs of libraries like TensorFlow and PyTorch is even more difficult.
 
 Instead of forcing dependencies on the simulation code, SmartSim itself maintains those dependencies
 and provides them in the ``Orchestrator`` database through RedisAI.
 
-Because of this, Simulations in Fortran, C, C++ and Python can call into PyTorch, TensorFlow,
+Because of this, simulations in Fortran, C, C++ and Python can call into PyTorch, TensorFlow,
 and any library that supports the ONNX format without having to compile in those libraries.
 
 Therefore we define *Online Inference* as the execution of machine learning models via
-requests to an application (Orchestrator) running seperately from the client program (Simulation)
+requests to an application (Orchestrator) running separately from the client program (Simulation)
 without exchanging data over the filesystem.
 
 
@@ -51,10 +51,10 @@ script that uses the SmartRedis Python client to perform innovations of the ML r
 The above script will first launch the database, and then the script
 containing the SmartRedis client code Python script. The code here could
 easily be adapted to launch a C, C++, or Fortran application containing
-the SmartRedis clients in those langugages as well.
+the SmartRedis clients in those languages as well.
 
 Below are a few examples of scripts that could be used with the above
-code to perform online inference in with various ML backends supported
+code to perform online inference with various ML backends supported
 by SmartSim.
 
 
@@ -71,7 +71,7 @@ by SmartSim.
 .. _trace: https://pytorch.org/docs/stable/generated/torch.jit.trace.html#torch.jit.trace
 
 The Orchestrator supports both `PyTorch`_ models and `TorchScript`_ functions and scripts
-in `PyTorch`_ 1.7.1. To use onnx in SmartSim, specify
+in `PyTorch`_ 1.7.1. To use ONNX in SmartSim, specify
 ``TORCH`` as the argument for *backend* in the call to ``client.set_model`` or
 ``client.set_model_from_file``.
 
@@ -135,7 +135,7 @@ Torch documentation for `trace`_.
         torch.jit.save(module, model_buffer)
         return model_buffer.getvalue()
 
-Lastly, we use the SmartRedis Python client to connect to
+Lastly, we use the SmartRedis Python client to
   1. Connect to the database
   2. Put a batch of 20 tensors into the database  (``put_tensor``)
   3. Set the Torch model in the database (``set_model``)
@@ -185,7 +185,7 @@ SmartSim include a utility to freeze the graph of a TensorFlow or Keras model in
 ``TF`` as the argument for *backend* in the call to ``client.set_model`` or
 ``client.set_model_from_file``.
 
-The example below shows how to use the utility to freeze an mnist model created in
+The example below shows how to use the utility to freeze an MNIST model created in
 Keras. This script can be used with the :ref:`SmartSim code <infrastructure_code>`
 above to launch an inference session with a TensorFlow or Keras model.
 
@@ -221,9 +221,9 @@ method ``client.set_model_from_file`` can load it into the database.
 
 Note that TensorFlow and Keras, unlike the other ML libraries supported by
 SmartSim, requires an ``input`` and ``output`` argument in the call to
-``set_model``. These arguments correspond the the layer names of the
+``set_model``. These arguments correspond to the layer names of the
 created model. The ``smartsim.tf.freeze_model`` utility returns these
-values for convienence as shown below.
+values for convenience as shown below.
 
 .. code-block:: python
 
@@ -287,7 +287,7 @@ models to ONNX.
 And PyTorch has it's own converter.
 
 Below are some examples of a few models in `Scikit-learn`_ that are converted
-into onnx format for use with SmartSim. To use onnx in SmartSim, specify
+into ONNX format for use with SmartSim. To use ONNX in SmartSim, specify
 ``ONNX`` as the argument for *backend* in the call to ``client.set_model`` or
 ``client.set_model_from_file``.
 
@@ -327,7 +327,7 @@ with two ``outputs``.
 Random Forest
 -------------
 
-The Random Forest example uses the Iris datset from Scikit Learn to train a
+The Random Forest example uses the Iris dataset from Scikit Learn to train a
 RandomForestRegressor. As with the other examples, the skl2onnx function
 `skl2onnx.to_onnx`_ is used to convert the model to ONNX format.
 
@@ -348,4 +348,3 @@ RandomForestRegressor. As with the other examples, the skl2onnx function
     client.set_model("rf_regressor", model, "ONNX", device="CPU")
     client.run_model("rf_regressor", inputs="input", outputs="output")
     print(client.get_tensor("output"))
-

doc/tutorials/lattice_boltz_analysis.rst

@@ -5,8 +5,8 @@ Online Analysis
 Being able to visualize and interpret simulation data in real time is
 invaluable for understanding the behavior of a physical system.
 
-SmartSim can be used to stream data from and Fortran, C, C++ simulations
-to Python where visualization is signifigantly easier and more interactive.
+SmartSim can be used to stream data from Fortran, C, and C++ simulations
+to Python where visualization is significantly easier and more interactive.
 
 3.1 Lattice Boltzmann Simulation
 --------------------------------
@@ -33,14 +33,14 @@ Philip also wrote a great medium `article`_ explaining the simulation in detail.
 .. _Dataset: https://www.craylabs.org/docs/sr_data_structures.html#dataset
 
 Typically HPC simulations are written in C, C++, Fortran or other high performance
-languages. Embedding the SmartRedis client usually invovles compiling in the
+languages. Embedding the SmartRedis client usually involves compiling in the
 SmartRedis library into the simulation.
 
 Because this simulation is written in Python, we can use the SmartRedis
 Python client to stream data to the database.
 
 To make the visualization easier, we use the SmartRedis `Dataset`_ object
-to hold two 2D NumPy arrays. A convience function is provided to convert
+to hold two 2D NumPy arrays. A convenience function is provided to convert
 the fields into a dataset object.
 
 
@@ -67,7 +67,7 @@ the fields into a dataset object.
         return dataset
 
 This is all the SmartRedis code needed to stream the simulation data. Note that
-the client does not need to have an address explictly stated because we
+the client does not need to have an address explicitly stated because we
 are going to be launching the simulation through SmartSim.
 
 The full simulation code can be found here # PUT IN LINK
@@ -77,12 +77,12 @@ The full simulation code can be found here # PUT IN LINK
 
 
 SmartSim, the infrastructure library, is used here to launch both the
-database and the simulation locally, but in seperate processes. The example
+database and the simulation locally, but in separate processes. The example
 is designed to run on laptops, so the local launcher is used.
 
 
-First the necessary libraries are imported and and `Experiment` instance is created.
-Also defined is an `Orchestrator` which is the refrence to the in-memory database
+First the necessary libraries are imported and an `Experiment` instance is created.
+Also defined is an `Orchestrator` which is the reference to the in-memory database
 to be launched and used to stage data between the simulation and analysis code.
 
 .. code-block:: python
@@ -102,7 +102,7 @@ The reference to the simulation is created through a call to `Experiment.create_
 The python script is "attached" to the model, such that when run directories are
 created for it, the python script will be placed in that run directory.
 
-Executable arguments are used to pass the simulation parameters to the to simulation.
+Executable arguments are used to pass the simulation parameters to the simulation.
 
 .. code-block:: python
 
@@ -136,20 +136,20 @@ being streamed from the simulation can be analyzed in real time.
     exp.start(db)
     client = Client(address="127.0.0.1:6780", cluster=False)
 
-    # start simulation without blocking so data can be analyized in real time
+    # start simulation without blocking so data can be analyzed in real time
     exp.start(model, block=False, summary=True)
 
 
-SmartRedis is used  to pull the Datasets created by
+SmartRedis is used to pull the Datasets created by
 the simulation and use matplotlib to plot the results.
 
 Another `Model` could have been created to plot the results and launched
 in a similar manner to the simulation.
 
 Doing so would enable the analysis application to be executed on different
-resources such as GPU enabled nodes, or distributed accross nodes.
+resources such as GPU enabled nodes, or distributed across nodes.
 
-This version, where the driver and anaylsis code coexist in the same
+This version, where the driver and analysis code coexist in the same
 script, is shown for simplicity.
 
 .. code-block:: python
@@ -231,4 +231,3 @@ online analysis example
         └── fv_simulation.out
 
     2 directories, 6 files
-

tutorials/03_online_analysis/lattice/driver.py

@@ -30,7 +30,7 @@
 exp.start(db)
 client = Client(address="127.0.0.1:6780", cluster=False)
 
-# start simulation without blocking so data can be analyized in real time
+# start simulation without blocking so data can be analyzed in real time
 exp.start(model, block=False, summary=True)
 
 # poll until data is available