General clean-up of ML.NET docs (#43970)

.openpublishing.redirection.machine-learning.json

@@ -9,6 +9,11 @@
             "redirect_url": "/dotnet/machine-learning/how-does-mldotnet-work",
             "redirect_document_id": true
         },
+        {
+            "source_path_from_root": "/docs/machine-learning/how-does-mldotnet-work.md",
+            "redirect_url": "/dotnet/machine-learning/mldotnet-api",
+            "redirect_document_id": true
+        },
         {
             "source_path_from_root": "/docs/machine-learning/how-to-guides/consuming-model-ml-net.md",
             "redirect_url": "/dotnet/machine-learning/how-to-guides/save-load-machine-learning-models-ml-net",
@@ -80,6 +85,11 @@
             "source_path_from_root": "/docs/machine-learning/resources/what-is-mldotnet.md",
             "redirect_url": "/dotnet/machine-learning/how-does-mldotnet-work"
         },
+        {
+            "source_path_from_root": "/docs/machine-learning/resources/index.md",
+            "redirect_url": "/dotnet/machine-learning/resources/glossary",
+            "redirect_document_id": true
+        },
         {
             "source_path_from_root": "/docs/machine-learning/tutorials/ml-cli.md",
             "redirect_url": "/dotnet/machine-learning/tutorials/sentiment-analysis-cli",

docs/csharp/language-reference/builtin-types/floating-point-numeric-types.md

@@ -26,7 +26,7 @@ The *floating-point numeric types* represent real numbers. All floating-point nu
 ## Characteristics of the floating-point types
 
 C# supports the following predefined floating-point types:
-  
+
 |C# type/keyword|Approximate range|Precision|Size|.NET type|
 |----------|-----------------------|---------------|--------------|--------------|
 |`float`|±1.5 x 10<sup>−45</sup> to ±3.4 x 10<sup>38</sup>|~6-9 digits|4 bytes|<xref:System.Single?displayProperty=nameWithType>|
@@ -42,7 +42,7 @@ System.Double b = 12.3;
 
 The default value of each floating-point type is zero, `0`. Each of the floating-point types has the `MinValue` and `MaxValue` constants that provide the minimum and maximum finite value of that type. The `float` and `double` types also provide constants that represent not-a-number and infinity values. For example, the `double` type provides the following constants: <xref:System.Double.NaN?displayProperty=nameWithType>, <xref:System.Double.NegativeInfinity?displayProperty=nameWithType>, and <xref:System.Double.PositiveInfinity?displayProperty=nameWithType>.
 
-The `decimal` type is appropriate when the required degree of precision is determined by the number of digits to the right of the decimal point. Such numbers are commonly used in financial applications, for currency amounts (for example, $1.00), interest rates (for example, 2.625%), and so forth. Even numbers that are precise to only one decimal digit are handled more accurately by the `decimal` type: 0.1, for example, can be exactly represented by a `decimal` instance, while there's no `double` or `float` instance that exactly represents 0.1. Because of this difference in numeric types, unexpected rounding errors can occur in arithmetic calculations when you use `double` or `float` for decimal data. You can use `double` instead of `decimal` when optimizing performance is more important than ensuring accuracy. However, any difference in performance would go unnoticed by all but the most calculation-intensive applications. Another possible reason to avoid `decimal` is to minimize storage requirements. For example, [ML.NET](../../../machine-learning/how-does-mldotnet-work.md) uses `float` because the difference between 4 bytes and 16 bytes adds up for very large data sets. For more information, see <xref:System.Decimal?displayProperty=nameWithType>.
+The `decimal` type is appropriate when the required degree of precision is determined by the number of digits to the right of the decimal point. Such numbers are commonly used in financial applications, for currency amounts (for example, $1.00), interest rates (for example, 2.625%), and so forth. Even numbers that are precise to only one decimal digit are handled more accurately by the `decimal` type: 0.1, for example, can be exactly represented by a `decimal` instance, while there's no `double` or `float` instance that exactly represents 0.1. Because of this difference in numeric types, unexpected rounding errors can occur in arithmetic calculations when you use `double` or `float` for decimal data. You can use `double` instead of `decimal` when optimizing performance is more important than ensuring accuracy. However, any difference in performance would go unnoticed by all but the most calculation-intensive applications. Another possible reason to avoid `decimal` is to minimize storage requirements. For example, [ML.NET](../../../machine-learning/mldotnet-api.md) uses `float` because the difference between 4 bytes and 16 bytes adds up for very large data sets. For more information, see <xref:System.Decimal?displayProperty=nameWithType>.
 
 You can mix [integral](integral-numeric-types.md) types and the `float` and `double` types in an expression. In this case, integral types are implicitly converted to one of the floating-point types and, if necessary, the `float` type is implicitly converted to `double`. The expression is evaluated as follows:
 

docs/machine-learning/automate-training-with-cli.md

@@ -14,7 +14,7 @@ To use the ML.NET API by itself, (without the ML.NET AutoML CLI) you need to cho
 The ML.NET CLI simplifies this process using automated machine learning (AutoML).
 
 > [!NOTE]
-> This article refers to ML.NET **CLI** and ML.NET **AutoML**, which are currently in Preview, and material may be subject to change.
+> This article refers to ML.NET **CLI** and ML.NET **AutoML**, which are currently in preview, and material is subject to change.
 
 ## What is the ML.NET command-line interface (CLI)?
 

docs/machine-learning/automated-machine-learning-mlnet.md

@@ -11,7 +11,7 @@ ms.custom: mvc
 Automated machine learning (AutoML) automates the process of applying machine learning to data. Given a dataset, you can run AutoML to iterate over different data transformations, machine learning algorithms, and hyperparameters to select the best model.
 
 > [!NOTE]
-> This article refers to the ML.NET AutoML API, which is currently in preview. Material may be subject to change.
+> This article refers to the ML.NET AutoML API, which is currently in preview. Material is subject to change.
 
 ## How does AutoML work?
 
@@ -37,11 +37,11 @@ Whether you're just getting started with machine learning or you're an experienc
 ## AutoML in ML.NET
 
 - **Featurizer** - Convenience API to automate data preprocessing.
-- **Trial** - A single hyperparamters optimization run.
+- **Trial** - A single hyperparameters optimization run.
 - **Experiment** - A collection of AutoML trials. ML.NET provides a high-level API for creating experiments which sets defaults for the individual Sweepable Pipeline, Search Space, and Tuner components.
 - **Search Space** - The range of available options to choose hyperparameters from.
 - **Tuner** - The algorithms used to optimize hyperparameters. ML.NET supports the following tuners:
-  - **Cost Frugal Tuner** - Implementation of [Frugal Optimization for Cost-related Hyperparameters](https://arxiv.org/abs/2005.01571) which takes training cost into consideration
+  - **Cost Frugal Tuner** - Implementation of [Frugal Optimization for Cost-related Hyperparameters](https://arxiv.org/abs/2005.01571), which takes training cost into consideration
   - **Eci Cost Frugal Tuner** - Implementation of Cost Frugal Tuner for hierarchical search spaces. Default tuner used by AutoML.
   - **SMAC** - Tuner that uses random forests to apply Bayesian optimization.
   - **Grid Search** - Tuner that works best for small search spaces.
@@ -50,7 +50,7 @@ Whether you're just getting started with machine learning or you're an experienc
 - **Sweepable Pipeline** - An ML.NET pipeline that contains one or more Sweepable Estimators.
 - **Trial Runner** - AutoML component that uses sweepable pipelines and trial settings to generate trial results from model training and evaluation.
 
-It's recommended for beginners to start with the defaults provided by the high-level experiment API. For more experienced users looking for customization options, use the sweepable estimator, sweepable pipeline, search space, trial runner and tuner components.
+It's recommended for beginners to start with the defaults provided by the high-level experiment API. For more experienced users looking for customization options, use the sweepable estimator, sweepable pipeline, search space, trial runner, and tuner components.
 
 For more information on getting started with the AutoML API, see the [How to use the ML.NET Automated Machine Learning (AutoML) API](how-to-guides/how-to-use-the-automl-api.md) guide.