Använd Python med revoscalepy för att skapa en modell som körs via fjärranslutning på SQL Server

Gäller för: SQL Server 2017 (14.x) och senare versioner

Python-biblioteket revoscalepy från Microsoft tillhandahåller datavetenskapsalgoritmer för datautforskning, visualisering, omvandlingar och analys. Det här biblioteket har strategisk betydelse i Python-integreringsscenarier i SQL Server. På en server med flera kärnor kan revoscalepy-funktioner köras parallellt. I en distribuerad arkitektur med en central server och klientarbetsstationer (separata fysiska datorer, som alla har samma revoscalepy-bibliotek ) kan du skriva Python-kod som startar lokalt, men sedan flytta körningen till en sql server-fjärrinstans där data finns.

Du hittar revoscalepy i följande Microsoft-produkter och -distributioner:

Den här övningen visar hur du skapar en linjär regressionsmodell baserat på rx_lin_mod, en av algoritmerna i revoscalepy som accepterar beräkningskontexten som indata. Koden som du kör i den här övningen flyttar kodkörningen från en lokal till fjärrbaserad databehandlingsmiljö, som aktiveras av revoscalepy-funktioner som aktiverar en fjärrberäkningskontext.

Genom att slutföra den här självstudien får du lära dig hur du:

Använda revoscalepy för att skapa en linjär modell
Flytta åtgärder från lokal till fjärrberäkningskontext

Förutsättningar

Exempeldata som används i den här övningen är databasen flightdata .

Du behöver en IDE för att köra exempelkoden i den här artikeln och IDE:t måste vara länkad till python-körbar fil.

Om du vill öva på ett skift i beräkningskontexten behöver du en lokal arbetsstation och en SQL Server-databasmotorinstans med Machine Learning Services och Python aktiverat.

Tips/Råd

Om du inte har två datorer kan du simulera en fjärrberäkningskontext på en fysisk dator genom att installera relevanta program. Först fungerar en installation av SQL Server Machine Learning Services som "fjärrinstans". För det andra fungerar en installation av Python-klientbiblioteken som klient. Du kommer att ha två kopior av samma Python-distribution och Microsoft Python-bibliotek på samma dator. Du måste hålla reda på filsökvägar och vilken kopia av Python.exe du använder för att slutföra övningen.

Fjärrberäkningskontexter och revoscalepy

Det här exemplet visar processen att skapa en Python-modell i en fjärrberäkningskontext, vilket gör att du kan arbeta från en klient, men välja en fjärrmiljö, till exempel SQL Server eller Spark, där åtgärderna faktiskt utförs. Målet med fjärrberäkningskontexten är att ta beräkningen till den där data finns.

För att köra Python-kod i SQL Server krävs revoscalepy-paketet . Det här är ett särskilt Python-paket som tillhandahålls av Microsoft, ungefär som RevoScaleR-paketet för R-språket. Revoscalepy-paketet stöder skapandet av beräkningskontexter och tillhandahåller infrastrukturen för att skicka data och modeller mellan en lokal arbetsstation och en fjärrserver. Funktionen revoscalepy som stöder körning av kod i databasen är RxInSqlServer.

I den här lektionen använder du data i SQL Server för att träna en linjär modell baserat på rx_lin_mod, en funktion i revoscalepy som stöder regression över mycket stora datamängder.

Den här lektionen visar också grunderna i hur du konfigurerar och sedan använder en SQL Server-beräkningskontext i Python.

Kör exempelkoden

När du har förberett databasen och har data för träning lagrade i en tabell öppnar du en Python-utvecklingsmiljö och kör kodexemplet.

Koden utför följande steg:

Importerar nödvändiga bibliotek och funktioner.
Skapar en anslutning till SQL Server. Skapar datakällans objekt för att arbeta med data.
Ändrar data med transformeringar så att de kan användas av den logistiska regressionsalgoritmen.
Anropar rx_lin_mod och definierar formeln som används för att passa modellen.
Genererar en uppsättning förutsägelser baserat på de ursprungliga data.
Skapar en sammanfattning baserat på de förutsagda värdena.

Alla åtgärder utförs med en instans av SQL Server som beräkningskontext.

Anmärkning

En demonstration av det här exemplet som körs från kommandoraden finns i den här videon: SQL Server 2017 Advanced Analytics med Python

Exempelkod

from revoscalepy import RxComputeContext, RxInSqlServer, RxSqlServerData
from revoscalepy import rx_lin_mod, rx_predict, rx_summary
from revoscalepy import RxOptions, rx_import

import os

def test_linmod_sql():
    sql_server = os.getenv('PYTEST_SQL_SERVER', '.')
    
    sql_connection_string = 'Driver=SQL Server;Server=' + sqlServer + ';Database=sqlpy;Trusted_Connection=True;'
    print("connectionString={0!s}".format(sql_connection_string))

    data_source = RxSqlServerData(
        sql_query = "select top 10 * from airlinedemosmall",
        connection_string = sql_connection_string,

        column_info = {
            "ArrDelay" : { "type" : "integer" },
            "DayOfWeek" : {
                "type" : "factor",
                "levels" : [ "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" ]
            }
        })

    sql_compute_context = RxInSqlServer(
        connection_string = sql_connection_string,
        num_tasks = 4,
        auto_cleanup = False
        )

    #
    # Run linmod locally
    #
    linmod_local = rx_lin_mod("ArrDelay ~ DayOfWeek", data = data_source)
    #
    # Run linmod remotely
    #
    linmod = rx_lin_mod("ArrDelay ~ DayOfWeek", data = data_source, compute_context = sql_compute_context)

    # Predict results
    # 
    predict = rx_predict(linmod, data = rx_import(input_data = data_source))
    summary = rx_summary("ArrDelay ~ DayOfWeek", data = data_source, compute_context = sql_compute_context)

Definiera en datakälla jämfört med att definiera en beräkningskontext

En datakälla skiljer sig från en beräkningskontext. Datakällan definierar de data som används i koden. Beräkningskontexten definierar var koden ska köras. De använder dock en del av samma information:

Python-variabler, till exempel sql_query och sql_connection_string, definierar datakällan.

Skicka dessa variabler till RxSqlServerData-konstruktorn för att implementera datakällobjektet med namnet data_source.
Du skapar ett beräkningskontextobjekt med hjälp av konstruktorn RxInSqlServer . Det resulterande beräkningskontextobjektet heter sql_cc.

I det här exemplet återanvänds samma anslutningssträng som du använde i datakällan, med antagandet att data finns på samma SQL Server-instans som du kommer att använda som beräkningskontext.

Datakällan och beräkningskontexten kan dock finnas på olika servrar.

Ändra beräkningskontexter

När du har definierat en beräkningskontext måste du ange den aktiva beräkningskontexten.

Som standard körs de flesta åtgärder lokalt, vilket innebär att om du inte anger en annan beräkningskontext hämtas data från datakällan och koden körs i din aktuella Python-miljö.

Det finns två sätt att ange den aktiva beräkningskontexten:

Som argument för en metod eller funktion
Genom att ringa rx_set_computecontext

Ange beräkningskontext som ett argument för en metod eller funktion

I det här exemplet anger du beräkningskontexten med hjälp av ett argument för den enskilda rx-funktionen .

linmod = rx_lin_mod_ex("ArrDelay ~ DayOfWeek", data = data, compute_context = sql_compute_context)

Den här beräkningskontexten återanvänds i anropet till rxsummary:

summary = rx_summary("ArrDelay ~ DayOfWeek", data = data_source, compute_context = sql_compute_context)

Ange en beräkningskontext explicit med hjälp av rx_set_compute_context

Med funktionen rx_set_compute_context kan du växla mellan beräkningskontexter som redan har definierats.

När du har angett den aktiva beräkningskontexten förblir den aktiv tills du ändrar den.

Använda parallell bearbetning och direktuppspelning

När du definierar beräkningskontexten kan du också ange parametrar som styr hur data hanteras av beräkningskontexten. Dessa parametrar skiljer sig åt beroende på datakällans typ.

För SQL Server-beräkningskontexter kan du ange batchstorleken eller ge tips om graden av parallellitet som ska användas i aktiviteter som körs.

Exemplet kördes på en dator med fyra processorer, så parametern num_tasks är inställd på 4 för att tillåta maximal användning av resurser.
Om du anger det här värdet till 0 använder SQL Server standardvärdet, som är att köra så många uppgifter som möjligt parallellt under de aktuella MAXDOP-inställningarna för servern. Det exakta antalet uppgifter som kan allokeras beror dock på många andra faktorer, till exempel serverinställningar och andra jobb som körs.

Nästa steg

Dessa ytterligare Python-exempel och självstudier visar scenarier från slutpunkt till slutpunkt med mer komplexa datakällor, samt användning av fjärrberäkningskontexter.

Feedback

Var den här sidan till hjälp?

Last updated on 2025-12-08