Commit 54858e9

This example demonstrates how you can create a linear regression model in SQL Server, using an algorithm from the **revoscalepy** package. The code in this sample uses data that is in SQL Server, but the code is executed from a remote Python development client.

+ To run Python code in SQL Server, you must have installed SQL Server 2017, and you must install and enable the feature, **Machine Learning Services** with Python. Other versions of SQL Server do not support Python integration.

If you installed a pre-release version of SQL Server 2017, we strongly recommend that you update to at least the RTM version. Later service releases continue to upgrade and expand on Python functionality, so we recommend getting the latest version whenever possible.

+ This sample uses the Airline dataset, which is available in both R and Python. You should create a database for your Python samples, and populate a table with the data before running this code.

This article provides information about the sample datasets, and how you can import the data from a CSV file into SQL Server: [Sample data in RevoScaleR](https://docs.microsoft.com/machine-learning-server/r/sample-built-in-data).

The **revoscalepy** package for Python contains objects, transformations, and algorithms similar to those provided for the **RevoScaleR** package for the R language.

For more information, see [What is revoscalepy?](../python/what-is-revoscalepy.md) and the [Python function reference](https://docs.microsoft.com/machine-learning-server/python-reference/introducing-python-package-reference)

This library also supports the notion of a _compute context_, which lets you work from a client, but specify a remote environment, such as SQL Server, Spark, or Machine Learning Server, where the operations are actually performed. Functions that can be run in remote compute context include moving data between compute contexts, transforming data, and training predictive models using popular algorithms such as logistic and linear regression, decision trees, and neural networks.

This sample demonstrates how to set up and then use a SQL Server compute context. For a discussion of how compute contexts work with other platforms, and which compute contexts are supported, see [Compute context for script execution in Machine Learning Server](https://docs.microsoft.com/machine-learning-server/r/concept-what-is-compute-context)

This code performs the following steps:

In general, the process of calling Python in a remote compute context is similar to the way you use R in a remote compute context.

You can execute the sample either as a Python script from the command line, or by using a Python development environment that includes the Python integration components provided in this release.

In your code, you create and use a compute context object to indicate where you want specific computations to be performed.

Let's review the code and highlight some key steps.

A data source is different from a compute context. The _data source_ defines the data used in your code. The _compute context_ defines where the code will be executed.

1. Create Python variables, such as `sql_query` and `sql_connection_string`, that define the source and the data you want to use. Pass these variables to the [RxSqlServerData](https://docs.microsoft.com/r-server/python-reference/revoscalepy/rxsqlserverdata) constructor to implement the **data source object** named `data_source`.

2. Create a compute context object by using the [RxInSqlServer](https://docs.microsoft.com/r-server/python-reference/revoscalepy/rxinsqlserverdata) constructor. In this example, you pass the same connection string you defined earlier, on the assumption that the data is on the same SQL Server instance that you will be using as the compute context. However, the data source and the compute context could be on different servers. The resulting **compute context object** is named `sql_cc`.

3. Choose the active compute context. By default, operations are run locally, which means that if you don't specify a different compute context, the data will be fetched from the data source, and the model-fitting will run in your current Python environment.

In this example, you set the compute context by using an argument of the individual **rx** function.

You can also use the function [rx_set_computecontext](https://docs.microsoft.com/r-server/python-reference/revoscalepy/rx-set-compute-context) to toggle between compute contexts that have already been defined.

The sample was run on a computer with four processors, so we set the *num_tasks* parameter to 4. If you set this value to 0, SQL Server uses the default, which is to run as many tasks in parallel as possible, under the current MAXDOP settings for the server.However, even in servers with many processors, the exact number of tasks that might be allocated depends on many other factors, such as server settings, and other jobs that are running.