acrolinx errors and warnings, links, H2

Author: HeidiSteen

docs/advanced-analytics/r/how-to-do-realtime-scoring.md

@@ -1,5 +1,6 @@
 ---
-title: How to perform real-time scoring or native scoring in SQL Server Machine Learning | Microsoft Docs
+title: How to generate forecasts and predictions using machine learning models in SQL Server | Microsoft Docs
+description: Use rxPredict, or sp_rxPredict for real-time scoring, or PREDICT T-SQL for native scoring for predictions and forecasting in R and Pythin in SQL Server Machine Learning.
 ms.prod: sql
 ms.technology: machine-learning
 
@@ -9,20 +10,20 @@ author: HeidiSteen
 ms.author: heidist
 manager: cgronlun
 ---
-# How to perform real-time scoring or native scoring in SQL Server
+# How to generate forecasts and predictions using machine learning models in SQL Server
 [!INCLUDE[appliesto-ss-xxxx-xxxx-xxx-md-winonly](../../includes/appliesto-ss-xxxx-xxxx-xxx-md-winonly.md)]
 
-Using an existing model to forecast or predict outcomes for new data inputs is a core task in machine learning. This article enumerates the approaches for generating predictions in SQL Server. Among the approaches are internal processing methodologies for high speed predictions, where speed is based on incremental reductions of run time dependencies. Fewer dependencies means faster predictions.
+Using an existing model to forecast or predict outcomes for new data inputs is a core task in machine learning. This article enumerates the approaches for generating predictions in SQL Server. Among the approaches are internal processing methodologies for high-speed predictions, where speed is based on incremental reductions of run time dependencies. Fewer dependencies mean faster predictions.
 
 Using the internal processing infrastructure (real-time or native scoring) comes with library requirements. Functions must be from the Microsoft libraries. R or Python code calling open-source or third-party functions is not supported in CLR or C++ extensions.
 
 The following table summarizes the scoring frameworks for forecasting and predictions. 
 
 | Methodology           | Interface         | Library requirements | Processing speeds |
 |-----------------------|-------------------|----------------------|----------------------|
-| Extensibility framework | R: rxpredict <br/>Python: rx_predict | None. Models can be based on any R or Python function | Hundreds of milliseconds. <br/>Loading a runtime environment has a fixed cost, averaging three to six hundred milliseconds, before any new data is scored. |
-| Real-time scoring CLR extension | [sp_rxPredict](../../sql/relational-databases/system-stored-procedures/sp-rxpredict-transact-sql.md) on a binary model | R: RevoScaleR, MicrosoftML <br/>Python: revoscalepy, microsoftml | Tens of milliseconds, on average. |
-| Native scoring C++ extension| [PREDICT T-SQL function](../../sql/t-sql/queries/predict-transact-sql.md) on a binary model | R: RevoScaleR <br/>Python: revoscalepy | Less than 20 milliseconds, on average. | 
+| Extensibility framework | R: rxPredict <br/>Python: rx_predict | None. Models can be based on any R or Python function | Hundreds of milliseconds. <br/>Loading a runtime environment has a fixed cost, averaging three to six hundred milliseconds, before any new data is scored. |
+| Real-time scoring CLR extension | [sp_rxPredict](https://docs.microsoft.com//sql/relational-databases/system-stored-procedures/sp-rxpredict-transact-sql) on a binary model | R: RevoScaleR, MicrosoftML <br/>Python: revoscalepy, microsoftml | Tens of milliseconds, on average. |
+| Native scoring C++ extension| [PREDICT T-SQL function](https://docs.microsoft.com/sql/t-sql/queries/predict-transact-sql) on a binary model | R: RevoScaleR <br/>Python: revoscalepy | Less than 20 milliseconds, on average. | 
 
 Speed of processing and not substance of the output is the differentiating feature. Assuming the same functions and inputs, the scored output should not vary based on the approach you use.
 
@@ -45,17 +46,17 @@ Taking a step back, the overall process of preparing the model and then generati
 
 When the input includes many rows of data, it is usually faster to insert the prediction values into a table as part of the scoring process.  Generating a single score is more typical in a scenario where you get input values from a form or user request, and return the score to a client application. To improve performance when generating successive scores, SQL Server might cache the model so that it can be reloaded into memory.
 
-## Native and real-time scoring compared
+## Compare methods
 
 To preserve the integrity of core database engine processes, support for R and Python is enabled in a dual architecture that isolates language processing from RDBMS processing. Starting in SQL Server 2016, Microsoft added an extensibility framework that allows R scripts to be executed from T-SQL. In SQL Server 2017, Python integration was added. 
 
-The extensibility framework supports any operation you might perform in R or Python, ranging from simple functions to training complex machine learning models. However, the dual-process architecture requires invoking an external R or Python process for every call, regardless of the complexity of the operation. When the workload entails loading a pre-trained model from a table and scoring against it on data already in SQL Server, the overhead of calling the external processes adds latency that can be unacceptable in certain circumstances. For example, in a request-response pattern such as fraud detection, scores must be generated very quickly in order to be relevant.
+The extensibility framework supports any operation you might perform in R or Python, ranging from simple functions to training complex machine learning models. However, the dual-process architecture requires invoking an external R or Python process for every call, regardless of the complexity of the operation. When the workload entails loading a pre-trained model from a table and scoring against it on data already in SQL Server, the overhead of calling the external processes adds latency that can be unacceptable in certain circumstances. For example, in a request-response pattern such as fraud detection, scores must be generated quickly in order to be relevant.
 
 To support fast scoring, SQL Server added built-in scoring libraries as C++ and CLR extensions that eliminate the processing overhead of R and Python run times.
 
 **Real-time scoring** was the first solution for high-performance scoring. Introduced in early versions of SQL Server 2017 and later updates to SQL Server 2016, real-time scoring relies on CLR libraries that stand in for R and Python processing over Microsoft-controlled functions in RevoScaleR, MicrosoftML (R), revoscalepy, and microsoftml (Python). CLR libraries are invoked using the **sp_rxPredict** stored procedure to generates scores from any supported model type, without calling the R or Python runtime.
 
-**Native scoring** is a SQL Server 2017 feature, implemented as a native C++ library, but only for RevoScaleR and revoscalepy ,models. It is the fastest and more secure approach, but supports a smaller set of functions relative to other methodologies.
+**Native scoring** is a SQL Server 2017 feature, implemented as a native C++ library, but only for RevoScaleR and revoscalepy models. It is the fastest and more secure approach, but supports a smaller set of functions relative to other methodologies.
 
 ## Choose a scoring method
 
@@ -85,9 +86,9 @@ From R code, call the [rxWriteObject](https://docs.microsoft.com/machine-learnin
 
 If you use this function, be sure to serialize the model using [rxSerializeModel](https://docs.microsoft.com/r-server/r-reference/revoscaler/rxserializemodel) first. Then, set the *serialize* argument in `rxWriteObject` to FALSE, to avoid repeating the serialization step.
 
-Serialing a model to a binary format is useful, but not required if you are scoring predictions using R and Python run time environment in the extensibility framework. You can save a model in raw byte format to a file and then read from the file into SQL Server. This option might be useful if you are moving or copying models between environments.
+Serializing a model to a binary format is useful, but not required if you are scoring predictions using R and Python run time environment in the extensibility framework. You can save a model in raw byte format to a file and then read from the file into SQL Server. This option might be useful if you are moving or copying models between environments.
 
-## Scoring in related Microsoft products
+## Scoring in related products
 
 If you are using the [standalone server](r-server-standalone.md) or a [Microsoft Machine Learning Server](https://docs.microsoft.com/machine-learning-server/what-is-machine-learning-server), you have other options besides stored procedures and T-SQL functions for generating predictions quickly. Both the standalone server and Machine Learning Server support the concept of a *web service* for code deployment. You can bundle an R or Python pre-trained model as a web service, called at run time to evaluate new data inputs. For more information, see these articles:
 
@@ -96,3 +97,11 @@ If you are using the [standalone server](r-server-standalone.md) or a [Microsoft
 + [Deploy a Python model as a web service with azureml-model-management-sdk](https://docs.microsoft.com/machine-learning-server/operationalize/python/quickstart-deploy-python-web-service)
 + [Publish an R code block or a real-time model as a new web service](https://docs.microsoft.com/machine-learning-server/r-reference/mrsdeploy/publishservice)
 + [mrsdeploy package for R](https://docs.microsoft.com/machine-learning-server/r-reference/mrsdeploy/mrsdeploy-package)
+
+
+## See also
+
++ [rxSerializeModel](https://docs.microsoft.com/machine-learning-server/r-reference/revoscaler/rxserializemodel)  
++ [rxRealTimeScoring](https://docs.microsoft.com/machine-learning-server/r-reference/revoscaler/rxrealtimescoring)
++ [sp-rxPredict](https://docs.microsoft.com/sql/relational-databases/system-stored-procedures/sp-rxpredict-transact-sql)
++ [PREDICT T-SQL](https://docs.microsoft.com/sql/t-sql/queries/predict-transact-sql)

docs/advanced-analytics/real-time-scoring.md

@@ -1,6 +1,6 @@
 ---
 title: Real-time scoring in SQL Server machine learning | Microsoft Docs
-description: Generate predictions using sp_rxPredict, scoring dta inputs against a pre-trained model written in R on SQL Server.
+description: Generate predictions using sp_rxPredict, scoring data inputs against a pre-trained model written in R on SQL Server.
 ms.prod: sql
 ms.technology: machine-learning
 
@@ -42,18 +42,14 @@ Real-time scoring is a multi-step process:
 
 + Serialize the model using [rxSerialize](https://docs.microsoft.com/machine-learning-server/r-reference/revoscaler/rxserializemodel) for R, and [rx_serialize_model](https://docs.microsoft.com/machine-learning-server/python-reference/revoscalepy/rx-serialize-model) for Python. These serialization functions have been optimized to support fast scoring.
 
-Real-time scoring does not use an interpreter; therefore, any functionality that might require an interpreter is not supported during the scoring step.  These might include:
-
-  + Models using the `rxGlm` or `rxNaiveBayes` algorithms are not currently supported
-
-  + RevoScaleR models that use an R transformation function, or a formula that contains a transformation, such as <code>A ~ log(B)</code> are not supported in real-time scoring. To use a model of this type, we recommend that you perform the transformation on the to input data before passing the data to real-time scoring.
-
 > [!Note]
 > Real-time scoring is currently optimized for fast predictions on smaller data sets, ranging from a few rows to hundreds of thousands of rows. On big datasets, using [rxPredict](https://docs.microsoft.com/machine-learning-server/r-reference/revoscaler/rxpredict) might be faster.
 
 <a name="bkmk_py_supported_algos"></a>
 
-## Python algorithms using real-time scoring
+## Supported algorithms
+
+### Python algorithms using real-time scoring
 
 + revoscalepy models
 
@@ -84,7 +80,7 @@ Real-time scoring does not use an interpreter; therefore, any functionality that
 
 <a name="bkmk_rt_supported_algos"></a>
 
-## R algorithms using real-time scoring
+### R algorithms using real-time scoring
 
 + RevoScaleR models
 
@@ -113,19 +109,22 @@ Real-time scoring does not use an interpreter; therefore, any functionality that
   + [categoricalHash](https://docs.microsoft.com/machine-learning-server/r-reference/microsoftml/categoricalHash)
   + [selectFeatures](https://docs.microsoft.com/machine-learning-server/r-reference/microsoftml/selectFeatures)
 
-## Unsupported model types
+### Unsupported model types
+
+Real-time scoring does not use an interpreter; therefore, any functionality that might require an interpreter is not supported during the scoring step.  These might include:
+
+  + Models using the `rxGlm` or `rxNaiveBayes` algorithms are not supported.
 
-Real-time scoring is not supported for R transformations other than those explicitly listed in the previous section. 
+  + Models using a transformation function or formula containing a transformation, such as <code>A ~ log(B)</code> are not supported in real-time scoring. To use a model of this type, we recommend that you perform the transformation on input data before passing the data to real-time scoring.
 
-For developers accustomed to working with RevoScaleR and other Microsoft R-specific libraries, unsupported functions include 
- `rxGlm` or `rxNaiveBayes` algorithms in RevoScaleR, PMML models, and other models created using other R libraries from CRAN or other repositories.
 
+## Example: sp_rxPredict
 
-## Example (R): Real-time scoring with sp_rxPredict
+This section describes the steps required to set up **real-time** prediction, and provides an example in R of how to call the function from T-SQL.
 
-This section describes the steps required to set up **real-time** prediction, and provides an example of how to call the function from T-SQL.
+<a name ="bkmk_enableRtScoring"></a> 
 
-### <a name ="bkmk_enableRtScoring"></a> Step 1. Enable the real-time scoring procedure
+### Step 1. Enable the real-time scoring procedure
 
 You must enable this feature for each database that you want to use for scoring. The server administrator should run the command-line utility, RegisterRExt.exe, which is included with the RevoScaleR package.
 

docs/advanced-analytics/sql-native-scoring.md

@@ -20,7 +20,7 @@ Native scoring requires that you have an already trained model. In SQL Server 20
 
 ## How native scoring works
 
-Native scoring uses native C++ libraries from Microsoft that can read an already trained model, previosuly stored in a special binary format or saved to disk as raw byte stream, and generate scores for new data inputs that you provide. Because the model is trained, published, and stored, it can be used for scoring without having to call the R or Python interpreter. As such, the overhead of multiple process interactions is reduced, resulting in much faster prediction performance in enterprise production scenarios.
+Native scoring uses native C++ libraries from Microsoft that can read an already trained model, previously stored in a special binary format or saved to disk as raw byte stream, and generate scores for new data inputs that you provide. Because the model is trained, published, and stored, it can be used for scoring without having to call the R or Python interpreter. As such, the overhead of multiple process interactions is reduced, resulting in much faster prediction performance in enterprise production scenarios.
 
 To use native scoring, call the PREDICT T-SQL function and pass the following required inputs:
 
@@ -31,13 +31,11 @@ The function returns predictions for the input data, together with any columns o
 
 ## Prerequisites
 
-PREDICT is available on all editions of SQL Server 2017 database engine and enabled by default, including SQL Server 2017 Machine Learning Services on Windows, SQL Server 2017 (Windows), SQL Server 2017 (Linux) or Azure SQL Database. You do not need to install R, Python, or enable additional features.
-    
+PREDICT is available on all editions of SQL Server 2017 database engine and enabled by default, including SQL Server 2017 Machine Learning Services on Windows, SQL Server 2017 (Windows), SQL Server 2017 (Linux), or Azure SQL Database. You do not need to install R, Python, or enable additional features.
 
-## Model preparation
++ The model must be trained in advance using one of the supported **rx** algorithms listed below.
 
-+ The model must be trained in advance using one of the supported **rx** algorithms. For details, see [Supported algorithms](#bkmk_native_supported_algos).
-+ The model must be saved using the new serialization function provided in Microsoft R Server 9.1.0. The serialization function is optimized to support fast scoring.
++ Serialize the model using [rxSerialize](https://docs.microsoft.com/machine-learning-server/r-reference/revoscaler/rxserializemodel) for R, and [rx_serialize_model](https://docs.microsoft.com/machine-learning-server/python-reference/revoscalepy/rx-serialize-model) for Python. These serialization functions have been optimized to support fast scoring.
 
 <a name="bkmk_native_supported_algos"></a> 
 
@@ -63,13 +61,12 @@ If you need to use models from MicrosoftML or microsoftml, use [real-time scorin
 
 Unsupported model types include the following types:
 
-+ Models containing other, unsupported types of R transformations
-+ Models using the `rxGlm` or `rxNaiveBayes` algorithms in RevoScaleR
++ Models containing other transformations
++ Models using the `rxGlm` or `rxNaiveBayes` algorithms in RevoScaleR or revoscalepy equivalents
 + PMML models
-+ Models created using other R libraries from CRAN or other repositories
-+ Models containing any other R transformation
++ Models created using other open-source or third-party libraries
 
-## Example: Native scoring with PREDICT 
+## Example: PREDICT (T-SQL)
 
 In this example, you create a model, and then call the real-time prediction function from T-SQL.
 
@@ -168,8 +165,4 @@ If you get the error, "Error occurred during execution of the function PREDICT.
 For a complete solution that includes native scoring, see these samples from the SQL Server development team:
 
 + Deploy your ML script: [Using a Python model](https://microsoft.github.io/sql-ml-tutorials/python/rentalprediction/step/3.html)
-+ Deploy your ML script: [Using an R model](https://microsoft.github.io/sql-ml-tutorials/R/rentalprediction/step/3.html)
-
-## See also
-
-[Real-time scoring in SQL Server machine learning ](real-time-scoring.md)
++ Deploy your ML script: [Using an R model](https://microsoft.github.io/sql-ml-tutorials/R/rentalprediction/step/3.html)