Beth editorial of home & installation (#128)

Provided editorial comments for the Home and Installation sections.

Author: Beth-Kosis

src/content/get-started/install.mdx

@@ -7,19 +7,21 @@ index: 0
 
 # Installation
 
-The Deep Sparse Platform is made up of core libraries that are available as Python APIs and CLIs.
+The Neural Magic Platform is made up of core libraries that are available as Python APIs and CLIs.
 All Python APIs and CLIs are installed through pip utilizing [PyPI](https://pypi.org/user/neuralmagic/).
-It is recommended to install in a [virtual environment](https://docs.python.org/3/library/venv.html) to encapsulate your local environment.
+We recommend you install in a [virtual environment](https://docs.python.org/3/library/venv.html) to encapsulate your local environment.
 
-## Quick Start
+## Installing the Neural Magic Platform
 
-To begin using the Deep Sparse Platform, run the following commands which install standard setups for deployment with the [DeepSparse Engine](../../products/deepsparse) and model training/optimization with [SparseML](../../products/sparseml):
+To begin using the Neural Magic Platform, run the following command, which installs standard setups for deployment with [DeepSparse](../../products/deepsparse) and model training/optimization with [SparseML](../../products/sparseml):
 
 ```bash
 pip install deepsparse[server] sparseml[torch,torchvision]
 ```
 
-## Package Installations
+Now, you are ready to install one of the Neural Magic products.
+
+## Installing Products
 
 <LinkCards>
   <LinkCard href="./deepsparse" heading="DeepSparse">

src/content/get-started/install/deepsparse-ent.mdx

@@ -13,19 +13,15 @@ The engine accepts models in the open-source [ONNX format](https://onnx.ai/), wh
 Currently, DeepSparse is tested on Python 3.7-3.10, ONNX 1.5.0-1.10.1, ONNX opset version 11+ and is [manylinux compliant](https://peps.python.org/pep-0513/).
 It is limited to Linux systems running on x86 CPU architectures.
 
-The DeepSparse Engine is available in two editions:
-1. [**The Community Edition**](/products/deepsparse) is open-source and free for evaluation, research, and non-production use with our [Engine Community License](https://neuralmagic.com/legal/engine-license-agreement/).
-2. [**The Enterprise Edition**](/products/deepsparse-ent) requires a Trial License or [can be fully licensed](https://neuralmagic.com/legal/master-software-license-and-service-agreement/) for production, commercial applications.
-
-## General Install
+## Installing DeepSparse Enterprise
 
 Use the following command to install with pip:
 
 ```bash
 pip install deepsparse-ent
 ```
 
-## Server Install
+## Installing the Server
 
 The [DeepSparse Server](/use-cases/deploying-deepsparse/deepsparse-server) allows you to serve models and pipelines through an HTTP interface using the deepsparse.server CLI.
 To install, use the following extra option:
@@ -34,7 +30,7 @@ To install, use the following extra option:
 pip install deepsparse-ent[server]
 ```
 
-## YOLO Install
+## Installing YOLO
 
 The [Ultralytics YOLOv5](/use-cases/object-detection/deploying) models require extra dependencies for deployment.
 To use YOLO models, install with the following extra option:
@@ -43,3 +39,4 @@ To use YOLO models, install with the following extra option:
 pip install deepsparse-ent[yolo]         # just yolo requirements
 pip install deepsparse-ent[yolo,server] # both yolo + server requirements
 ```
+ 

src/content/get-started/install/deepsparse.mdx

@@ -10,22 +10,18 @@ index: 1000
 The [DeepSparse Engine](/products/deepsparse) enables GPU-class performance on CPUs, leveraging sparsity within models to reduce FLOPs and the unique cache hierarchy on CPUs to reduce memory movement.
 The engine accepts models in the open-source [ONNX format](https://onnx.ai/), which are easily created from PyTorch and TensorFlow models.
 
-Currently, DeepSparse is tested on Python 3.7-3.10, ONNX 1.5.0-1.10.1, ONNX opset version 11+ and is [manylinux compliant](https://peps.python.org/pep-0513/).
-It is limited to Linux systems running on x86 CPU architectures.
+Currently, DeepSparse is tested on Python 3.7-3.10, ONNX 1.5.0-1.10.1, and ONNX opset version 11+. It is [manylinux compliant](https://peps.python.org/pep-0513/).
+DeepSparse is limited to Linux systems running on x86 CPU architectures.
 
-The DeepSparse Engine is available in two editions:
-1. [**The Community Edition**](/products/deepsparse) is open-source and free for evaluation, research, and non-production use with our [Engine Community License](https://neuralmagic.com/legal/engine-license-agreement/).
-2. [**The Enterprise Edition**](/products/deepsparse-ent) requires a Trial License or [can be fully licensed](https://neuralmagic.com/legal/master-software-license-and-service-agreement/) for production, commercial applications.
-
-## General Installation
+## Installing DeepSparse Community
 
 Use the following command to install the Community Edition with pip:
 
 ```bash
 pip install deepsparse
 ```
 
-## Server Install
+## Installing the Server
 
 The [DeepSparse Server](/use-cases/deploying-deepsparse/deepsparse-server) allows you to serve models and pipelines through an HTTP interface using the deepsparse.server CLI.
 To install, use the following extra option:
@@ -34,7 +30,7 @@ To install, use the following extra option:
 pip install deepsparse[server]
 ```
 
-## YOLO Install
+## Installing YOLO
 
 The [Ultralytics YOLOv5](/use-cases/object-detection/deploying) models require extra dependencies for deployment.
 To use YOLO models, install with the following extra option:
@@ -43,3 +39,4 @@ To use YOLO models, install with the following extra option:
 pip install deepsparse[yolo]         # just yolo requirements
 pip install deepsparse[yolo,server] # both yolo + server requirements
 ```
+ 

src/content/get-started/try-a-model.mdx

@@ -10,9 +10,9 @@ index: 2000
 DeepSparse Engine supports fast inference on CPUs for sparse and dense models. For sparse models in particular, it achieves GPU-level performance in many use cases.
 
 Around the engine, the DeepSparse package includes various utilities to simplify benchmarking performance and model deployment. For instance:
-1. Trained models are passed in the open ONNX file format, enabling easy exporting from common packages like PyTorch, Keras, and TensorFlow.
-2. Benchmaking latency and performance is available via a single CLI call, with various arguments to test scenarios.
-3. `Pipelines` utilities wrap the model execution with input pre-processing and output post-processing, simplifying deployment and adding functionality like multi-stream, bucketing and dynamic shape.
+- Trained models are passed in the open ONNX file format, enabling easy exporting from common packages like PyTorch, Keras, and TensorFlow.
+- Benchmaking latency and performance is available via a single CLI call, with various arguments to test scenarios.
+- Pipelines utilities wrap the model execution with input pre-processing and output post-processing, simplifying deployment and adding functionality like multi-stream, bucketing, and dynamic shape.
 
 ## Use Case Examples
 
@@ -35,4 +35,4 @@ The examples below walk through use cases leveraging DeepSparse for testing and
 ## Other Use Cases
 
 More documentation, models, use cases, and examples are continually being added.
-If you don't see one you're interested in, search the [DeepSparse Github repo](https://github.com/neuralmagic/deepsparse), the [SparseML Github repo](https://github.com/neuralmagic/sparseml), the [SparseZoo website](https://sparsezoo.neuralmagic.com/), or ask in the [Neural Magic Slack](https://join.slack.com/t/discuss-neuralmagic/shared_invite/zt-q1a1cnvo-YBoICSIw3L1dmQpjBeDurQ).
+If you don't see one you're interested in, search the [DeepSparse Github repo](https://github.com/neuralmagic/deepsparse), [SparseML Github repo](https://github.com/neuralmagic/sparseml), or [SparseZoo website](https://sparsezoo.neuralmagic.com/). Or, ask in the [Neural Magic Slack](https://join.slack.com/t/discuss-neuralmagic/shared_invite/zt-q1a1cnvo-YBoICSIw3L1dmQpjBeDurQ).

src/content/get-started/try-a-model/custom-use-case.mdx

@@ -9,19 +9,19 @@ index: 3000
 
 This page explains how to run a model on the DeepSparse Engine for a custom task inside a Python API called `Pipelines.`
 
-`Pipelines` wrap key utilities around the DeepSparse Engine for easy testing and deployment.
+`Pipelines` wraps key utilities around the DeepSparse Engine for easy testing and deployment.
 
 The DeepSparse Engine supports many operators within ONNX, enabling performance for most models and use cases outside of the ones available on the SparseZoo.
-The `CustomTaskPipeline` enables you to wrap your model with custom pre and post-processing functions for simple deployment and benchmarking.
+The `CustomTaskPipeline` enables you to wrap your model with custom pre-processing and post-processing functions for simple deployment and benchmarking.
 In this way, the simplicity of `Pipelines` is combined with the performance of DeepSparse for arbitrary use cases.
 
-## Install Requirements
+## Installation Requirements
 
-This example requires [DeepSparse General Install](/get-started/install/deepsparse) and [SparseML Torchvision Install](/get-started/install/sparseml).
+This example requires [DeepSparse General Installation](/get-started/install/deepsparse) and [SparseML Torchvision Installation](/get-started/install/sparseml).
 
 ## Model Setup
 
-For custom model deployment, first export your model to the ONNX model format (create a `model.onnx` file).
+For custom model deployment, export your model to the ONNX model format (create a `model.onnx` file).
 SparseML has available wrappers for ONNX export classes and APIs for a more straightforward export process.
 A sample export utilizing this API for a MobileNetV2 TorchVision model is given below.
 
@@ -41,15 +41,15 @@ Examples for both are given below.
 
 ## Inference Pipelines
 
-The `model.onnx` file can be passed into a DeepSparse `CustomTaskPipeline` utilizing the `model_path` argument alongside optional pre and post-processing functions.
+The `model.onnx` file can be passed into a DeepSparse `CustomTaskPipeline` utilizing the `model_path` argument alongside optional pre-processing and post-processing functions.
 
 A sample image is downloaded that will be run through the example to test the `Pipeline`.
 
 ```bash
 wget -O basilica.jpg https://raw.githubusercontent.com/neuralmagic/deepsparse/main/src/deepsparse/yolo/sample_images/basilica.jpg
 ```
 
-Next, the pre and post-processing functions are defined, and the pipeline enabling the classification of the image file is instantiated:
+Next, the pre-processing and post-processing functions are defined, and the pipeline enabling the classification of the image file is instantiated:
 
 ```python
 from deepsparse.pipelines.custom_pipeline import CustomTaskPipeline
@@ -90,7 +90,7 @@ print(inference)
 
 ## Benchmarking
 
-The DeepSparse install includes a benchmark CLI for convenient and easy inference performance benchmarking: `deepsparse.benchmark`.
+The DeepSparse installation includes a benchmark CLI for convenient and easy inference performance benchmarking: `deepsparse.benchmark`.
 The CLI takes in both SparseZoo stubs or paths to a local `model.onnx` file.
 
 The code below provides an example for benchmarking the previously exported MobileNetV2 model.

src/content/get-started/try-a-model/cv-object-detection.mdx

@@ -9,33 +9,33 @@ index: 2000
 
 This page explains how to run a trained model on the DeepSparse Engine for Object Detection inside a Python API called `Pipelines.`
 
-`Pipelines` wrap key utilities around the DeepSparse Engine for easy testing and deployment.
+`Pipelines` wraps key utilities around the DeepSparse Engine for easy testing and deployment.
 
-The object detection `Pipeline`, for example, wraps a trained model with the proper preprocessing and postprocessing pipelines such as NMS.
-This enables the passing of raw images and receiving the bounding boxes from the DeepSparse Engine without any extra effort.
-With all of this built on top of the DeepSparse Engine, the simplicity of `Pipelines` is combined with GPU-class performance on CPUs for sparse models.
+The object detection `Pipeline`, for example, wraps a trained model with the proper pre-processing and post-processing pipelines such as NMS.
+This enables the passing of raw images and receiving the bounding boxes from DeepSparse without any extra effort.
+With all of this built on top of DeepSparse, the simplicity of `Pipelines` is combined with GPU-class performance on CPUs for sparse models.
 
-## Install Requirements
+## Installation Requirements
 
-This example requires [DeepSparse YOLO Install](/get-started/install/deepsparse).
+This example requires [DeepSparse YOLO Installation](/get-started/install/deepsparse).
 
 ## Model Setup
 
 The object detection `Pipeline` uses Ultralytics YOLOv5 standards and configurations for model setup.
-The possible files/variables that can be passed in are the following:
-- `model.onnx` - The exported YOLOv5 model in the ONNX format.
-- `model.yaml` - The Ultralytics model config file containing configuration information about the model and its post-processing.
+The possible files/variables that can be passed in are:
+- `model.onnx` - Exported YOLOv5 model in the ONNX format.
+- `model.yaml` - Ultralytics model configuration file containing configuration information about the model and its post-processing.
 - `class_names` - A list, dictionary, or file containing the index to class name mappings for the trained model.
 
 `model.onnx` is the only required file.
-The pipeline will default to a standard setup for the COCO dataset if the model config file or class names are not provided.
+The pipeline will default to a standard setup for the COCO dataset if the model configuration file or class names are not provided.
 
 There are two options for passing these files to DeepSparse:
 
 <details>
-<summary><b>1) Using The SparseZoo</b></summary>
+<summary><b>1) Using the SparseZoo</b></summary>
 
-This pathway is relevant if you want to use a pre-sparsified state-of-the-art model off the shelpf.
+This pathway is relevant if you want to use a pre-sparsified state-of-the-art model off the shelf.
 
 SparseZoo is a repository of pre-trained and pre-sparsified models. DeepSparse supports SparseZoo stubs as inputs for automatic download and inclusion into easy testing and deployment.
 These models include dense and sparsified versions of YOLOv5 trained on the COCO dataset for performant and general detection, among others.
@@ -54,12 +54,12 @@ These SparseZoo stubs can be passed as arguments to the `Pipeline` constructor i
 </details>
 
 <details>
-<summary><b>2) Using a Custom Local Model</b></summary>
+<summary><b>2) Using a custom local model</b></summary>
 
 This pathway is relevant if you want to use a model fine-tuned on your data with SparseML or a custom model.
 
 There are three steps to using a local model with `Pipelines`:
-1. Create the `model.onnx` file (if you trained with SparseML, use the [ONNX export script](https://github.com/neuralmagic/sparseml/tree/main/integrations/ultralytics-yolov5#exporting-the-sparse-model-to-onnx))
+1. Create the `model.onnx` file (if you trained with SparseML, use the [ONNX export script](https://github.com/neuralmagic/sparseml/tree/main/integrations/ultralytics-yolov5#exporting-the-sparse-model-to-onnx)).
 2. Collect the `model.yaml` file and `class_names` listed above.
 3. Pass the local paths of the files in place of the SparseZoo stubs.
 
@@ -69,9 +69,9 @@ The examples below use the SparseZoo stubs. Pass the path to the local model in
 
 ## Inference Pipelines
 
-With the object detection model setup, it can then be passed into a DeepSparse `Pipeline` utilizing the `model_path` argument.
+With the object detection model set up, the model can be passed into a DeepSparse `Pipeline` utilizing the `model_path` argument.
 The SparseZoo stub for the sparse-quantized YOLOv5l model given at the beginning is used in the sample code below.
-It will automatically download the necessary files for the model from the SparseZoo and then compile them on your local machine in the DeepSparse engine.
+It will automatically download the necessary files for the model from the SparseZoo and then compile them on your local machine in DeepSparse.
 Once compiled, the model `Pipeline` is ready for inference with images.
 
 First, a sample image is downloaded that will be run through the example to test the pipeline.
@@ -80,7 +80,7 @@ First, a sample image is downloaded that will be run through the example to test
 wget -O basilica.jpg https://raw.githubusercontent.com/neuralmagic/deepsparse/main/src/deepsparse/yolo/sample_images/basilica.jpg
 ```
 
-Next, instantiate the `Pipeline` and pass the image in using the images argument:
+Next, instantiate the `Pipeline` and pass in the image using the images argument:
 
 ```python
 from deepsparse import Pipeline
@@ -99,7 +99,7 @@ print(inference)
 
 ## Benchmarking
 
-The DeepSparse install includes a CLI for convenient performance benchmarking.
+The DeepSparse installation includes a CLI for convenient performance benchmarking.
 You can pass a SparseZoo stub or a local `model.onnx` file.
 
 ### Dense YOLOv5l