Delen via

Python gebruiken met revoscalepy om een model te maken dat op afstand wordt uitgevoerd op SQL Server

Van toepassing op: SQL Server 2017 (14.x) en latere versies

De python-bibliotheek voor revoscalepy van Microsoft biedt gegevenswetenschapalgoritmen voor gegevensverkenning, visualisatie, transformaties en analyse. Deze bibliotheek heeft strategisch belang in Python-integratiescenario's in SQL Server. Op een multi-core-server kunnen revoscalepy-functies parallel worden uitgevoerd. In een gedistribueerde architectuur met een centrale server en clientwerkstations (afzonderlijke fysieke computers, allemaal met dezelfde revoscalepy-bibliotheek ), kunt u Python-code schrijven die lokaal wordt gestart, maar vervolgens wordt de uitvoering verplaatst naar een extern SQL Server-exemplaar waarin gegevens zich bevinden.

U vindt revoscalepy in de volgende Microsoft-producten en -distributies:

In deze oefening ziet u hoe u een lineair regressiemodel maakt op basis van rx_lin_mod, een van de algoritmen in revoscalepy die rekencontext accepteert als invoer. De code die u in deze oefening uitvoert, verschuift de uitvoering van code van een lokale naar een externe computeromgeving, ingeschakeld door revoscalepy-functies die een externe rekencontext mogelijk maken.

Door deze zelfstudie te voltooien, leert u het volgende:

  • Revoscalepy gebruiken om een lineair model te maken
  • Bewerkingen verplaatsen van lokale naar externe rekencontext

Vereiste voorwaarden

Voorbeeldgegevens die in deze oefening worden gebruikt, zijn de flightdata-database .

U hebt een IDE nodig om de voorbeeldcode in dit artikel uit te voeren en de IDE moet worden gekoppeld aan het uitvoerbare Python-bestand.

Als u wilt oefenen met een verschuiving van rekencontext, hebt u een lokaal werkstation en een EXEMPLAAR van de SQL Server-database-engine nodig waarvoor Machine Learning Services en Python zijn ingeschakeld.

Aanbeveling

Als u geen twee computers hebt, kunt u een externe rekencontext op één fysieke computer simuleren door relevante toepassingen te installeren. Eerst werkt een installatie van SQL Server Machine Learning Services als het externe exemplaar. Ten tweede werkt een installatie van de Python-clientbibliotheken als de client. U hebt twee kopieën van dezelfde Python-distributie en Microsoft Python-bibliotheken op dezelfde computer. U moet bestandspaden bijhouden en welke kopie van de Python.exe u gebruikt om de oefening te voltooien.

Externe rekenomgevingen en revoscalepy

In dit voorbeeld ziet u hoe u een Python-model maakt in een externe rekencontext, waarmee u vanuit een client kunt werken, maar een externe omgeving kunt kiezen, zoals SQL Server of Spark, waar de bewerkingen daadwerkelijk worden uitgevoerd. Het doel van externe rekencontext is om berekeningen naar de locatie van de gegevens te brengen.

Voor het uitvoeren van Python-code in SQL Server is het revoscalepy-pakket vereist. Dit is een speciaal Python-pakket dat door Microsoft wordt geleverd, vergelijkbaar met het RevoScaleR-pakket voor de R-taal. Het revoscalepy-pakket ondersteunt het maken van rekencontexten en biedt de infrastructuur voor het doorgeven van gegevens en modellen tussen een lokaal werkstation en een externe server. De revoscalepy-functie die ondersteuning biedt voor het uitvoeren van code in de database, is RxInSqlServer.

In deze les gebruikt u gegevens in SQL Server om een lineair model te trainen op basis van rx_lin_mod, een functie in revoscalepy die regressie ondersteunt over zeer grote gegevenssets.

Deze les laat ook de basisbeginselen zien van het instellen en vervolgens gebruiken van een SQL Server-rekencontext in Python.

De voorbeeldcode uitvoeren

Nadat u de database hebt voorbereid en de gegevens hebt opgeslagen voor training in een tabel, opent u een Python-ontwikkelomgeving en voert u het codevoorbeeld uit.

De code voert de volgende stappen uit:

  1. Hiermee importeert u de vereiste bibliotheken en functies.
  2. Hiermee maakt u een verbinding met SQL Server. Hiermee maakt u gegevensbronobjecten voor het werken met de gegevens.
  3. Wijzigt de gegevens met behulp van transformaties , zodat deze kunnen worden gebruikt door het logistieke regressie-algoritme.
  4. Roep rx_lin_mod aan en definieert de formule die wordt gebruikt om het model te passen.
  5. Hiermee wordt een set voorspellingen gegenereerd op basis van de oorspronkelijke gegevens.
  6. Hiermee maakt u een samenvatting op basis van de voorspelde waarden.

Alle bewerkingen worden uitgevoerd met behulp van een exemplaar van SQL Server als rekencontext.

Opmerking

Zie deze video voor een demonstratie van dit voorbeeld dat vanaf de opdrachtregel wordt uitgevoerd: SQL Server 2017 Advanced Analytics met Python

Voorbeeldcode

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)

Een gegevensbron definiëren versus een rekencontext definiëren

Een gegevensbron verschilt van een rekencontext. De gegevensbron definieert de gegevens die in uw code worden gebruikt. De rekencontext bepaalt waar de code wordt uitgevoerd. Ze gebruiken echter een aantal van dezelfde informatie:

  • Python-variabelen, zoals sql_query en sql_connection_string, definiëren de bron van de gegevens.

    Geef deze variabelen door aan de RxSqlServerData-constructor om het gegevensbronobject met de naam data_sourcete implementeren.

  • U maakt een compute-contextobject met behulp van de RxInSqlServer-constructor . Het resulterende rekencontextobject heeft de naam sql_cc.

    In dit voorbeeld wordt dezelfde verbindingsreeks gebruikt die u in de gegevensbron hebt gebruikt, waarbij wordt aangenomen dat de gegevens zich in hetzelfde SQL Server-exemplaar bevinden dat u gaat gebruiken als de rekencontext.

    De gegevensbron en de rekencontext kunnen zich echter op verschillende servers bevinden.

Compute-contexten wijzigen

Nadat u een rekencontext hebt gedefinieerd, moet u de actieve rekencontext instellen.

De meeste bewerkingen worden standaard lokaal uitgevoerd, wat betekent dat als u geen andere rekencontext opgeeft, de gegevens worden opgehaald uit de gegevensbron en de code wordt uitgevoerd in uw huidige Python-omgeving.

Er zijn twee manieren om de actieve rekencontext in te stellen:

  • Als argument van een methode of functie
  • Door te bellen rx_set_computecontext

Compute-context instellen als een argument van een methode of functie

In dit voorbeeld stelt u de rekencontext in met behulp van een argument van de afzonderlijke rxfunctie .

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

Deze rekencontext wordt opnieuw gebruikt in de aanroep naar rxsummary:

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

Een rekencontext expliciet instellen met behulp van rx_set_compute_context

Met de functie rx_set_compute_context kunt u schakelen tussen rekencontexten die al zijn gedefinieerd.

Nadat u de actieve rekencontext hebt ingesteld, blijft deze actief totdat u deze wijzigt.

Parallelle verwerking en streaming gebruiken

Wanneer u de rekencontext definieert, kunt u ook parameters instellen die bepalen hoe de gegevens worden verwerkt door de rekencontext. Deze parameters verschillen, afhankelijk van het gegevensbrontype.

Voor SQL Server-rekencontexten kunt u de batchgrootte instellen of hints geven over de mate van parallelle uitvoering die moet worden gebruikt in actieve taken.

  • Het voorbeeld is uitgevoerd op een computer met vier processors, dus de num_tasks parameter is ingesteld op 4 om maximaal gebruik van resources toe te staan.
  • Als u deze waarde instelt op 0, gebruikt SQL Server de standaardwaarde. Dit is om zoveel mogelijk taken parallel uit te voeren, onder de huidige MAXDOP-instellingen voor de server. Het exacte aantal taken dat kan worden toegewezen, is echter afhankelijk van veel andere factoren, zoals serverinstellingen en andere taken die worden uitgevoerd.

Volgende stappen

Deze aanvullende Python-voorbeelden en zelfstudies laten end-to-end scenario's zien met behulp van complexere gegevensbronnen, evenals het gebruik van externe rekencontexten.

  • Last updated on