Quickstart: Een voorspellend model maken en beoordelen in Python met SQL Machine Learning

2025-10-31

Van toepassing op: SQL Server 2017 (14.x) en latere versies van Azure SQL Managed Instance

In deze quickstart maakt en traint u een voorspellend model met behulp van Python. U slaat het model op in een tabel in uw SQL Server-exemplaar en gebruikt vervolgens het model om waarden van nieuwe gegevens te voorspellen met behulp van SQL Server Machine Learning Services, Azure SQL Managed Instance Machine Learning Services of SQL Server Big Data Clusters.

U maakt en voert twee opgeslagen procedures uit die worden uitgevoerd in SQL. De eerste maakt gebruik van de klassieke irisbloemgegevensset en genereert een Naïve Bayes-model om een Iris-soort te voorspellen op basis van bloemkenmerken. De tweede procedure is voor scoren. Hiermee wordt het model aanroepen dat in de eerste procedure is gegenereerd om een set voorspellingen uit te voeren op basis van nieuwe gegevens. Door Python-code in een opgeslagen SQL-procedure te plaatsen, bevinden bewerkingen zich in SQL, zijn ze herbruikbaar en kunnen ze worden aangeroepen door andere opgeslagen procedures en clienttoepassingen.

Door deze quickstart te voltooien, leert u het volgende:

Python-code insluiten in een opgeslagen procedure
Hoe u invoer naar uw code kunt doorgeven via invoer in de opgeslagen procedure.
Hoe opgeslagen procedures worden gebruikt om modellen operationeel te maken

Vereiste voorwaarden

U hebt de volgende vereisten nodig om deze quickstart uit te voeren.

Een SQL-database op een van deze platforms:
- SQL Server Machine Learning Services-. Zie de Windows-installatiehandleiding of de Linux-installatiehandleiding om te installeren.
- BIG Data-clusters van SQL Server. Lees hoe u Machine Learning Services inschakelt op BIG Data-clusters van SQL Server.
- Azure SQL Managed Instance Machine Learning Services. Zie het overzicht van Azure SQL Managed Instance Machine Learning Services voor meer informatie.
Een hulpprogramma voor het uitvoeren van SQL-query's die Python-scripts bevatten. In deze quickstart wordt Gebruikgemaakt van Azure Data Studio.
De voorbeeldgegevens die in deze oefening worden gebruikt, zijn de Iris-voorbeeldgegevens. Volg de instructies in Iris demogegevens om de voorbeeldendatabase irissql te maken.

Een opgeslagen procedure maken waarmee modellen worden gegenereerd

In deze stap maakt u een opgeslagen procedure waarmee een model wordt gegenereerd voor het voorspellen van resultaten.

Open Azure Data Studio, maak verbinding met uw SQL-exemplaar en open een nieuw queryvenster.
Maak verbinding met de irissql-database.
```
USE irissql
GO
```
Kopieer de volgende code om een nieuwe opgeslagen procedure te maken.

Wanneer deze procedure wordt uitgevoerd, roept deze procedure sp_execute_external_script aan om een Python-sessie te starten.

Invoer die nodig is voor uw Python-code, worden doorgegeven als invoerparameters voor deze opgeslagen procedure. Uitvoer zal een getraind model zijn, gebaseerd op de Python scikit-learn-bibliotheek voor machine learning-algoritmes.

Deze code maakt gebruik van pickle om het model te serialiseren. Het model wordt getraind met behulp van gegevens uit kolommen 0 tot en met 4 uit de iris_data tabel.

De parameters die u in het tweede deel van de procedure ziet, geven gegevensinvoer en modeluitvoer weer. U wilt zo veel mogelijk dat de Python-code die wordt uitgevoerd in een opgeslagen procedure, duidelijk gedefinieerde invoer en uitvoer heeft die corresponderen met de invoer en uitvoer die tijdens runtime aan de opgeslagen procedure worden doorgegeven.
```
CREATE PROCEDURE generate_iris_model (@trained_model VARBINARY(max) OUTPUT)
AS
BEGIN
    EXECUTE sp_execute_external_script @language = N'Python'
        , @script = N'
import pickle
from sklearn.naive_bayes import GaussianNB
GNB = GaussianNB()
trained_model = pickle.dumps(GNB.fit(iris_data[["Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width"]], iris_data[["SpeciesId"]].values.ravel()))
'
        , @input_data_1 = N'select "Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width", "SpeciesId" from iris_data'
        , @input_data_1_name = N'iris_data'
        , @params = N'@trained_model varbinary(max) OUTPUT'
        , @trained_model = @trained_model OUTPUT;
END;
GO
```
Controleer of de opgeslagen procedure bestaat.

Als het T-SQL-script uit de vorige stap zonder fouten is uitgevoerd, wordt een nieuwe opgeslagen procedure met de naam generate_iris_model gemaakt en toegevoegd aan de irissql-database . U vindt opgeslagen procedures in Azure Data Studio Object Explorer, onder Programmeerbaarheid.

De procedure uitvoeren om modellen te maken en te trainen

In deze stap voert u de procedure uit om de ingesloten code uit te voeren, waarbij u een getraind en geserialiseerd model maakt als uitvoer.

Modellen die zijn opgeslagen voor hergebruik in uw database, worden geserialiseerd als een bytestroom en opgeslagen in een KOLOM VARBINARY(MAX) in een databasetabel. Zodra het model is gemaakt, getraind, geserialiseerd en opgeslagen in een database, kan het worden aangeroepen door andere procedures of door de functie PREDICT T-SQL in scoreworkloads.

Voer het volgende script uit om de procedure uit te voeren. De specifieke instructie voor het uitvoeren van een opgeslagen procedure staat EXECUTE op de vierde regel.

Met dit specifieke script wordt een bestaand model met dezelfde naam ('Naive Bayes') verwijderd om ruimte te maken voor nieuwe modellen die zijn gemaakt door dezelfde procedure opnieuw uit te voeren. Zonder modelverwijdering treedt er een fout op waarin wordt aangegeven dat het object al bestaat. Het model wordt opgeslagen in een tabel met de naam iris_models, ingericht toen u de irissql-database maakte.
```
DECLARE @model varbinary(max);
DECLARE @new_model_name varchar(50)
SET @new_model_name = 'Naive Bayes'
EXECUTE generate_iris_model @model OUTPUT;
DELETE iris_models WHERE model_name = @new_model_name;
INSERT INTO iris_models (model_name, model) values(@new_model_name, @model);
GO
```
Controleer of het model is ingevoegd.
```
SELECT * FROM dbo.iris_models
```
resultaten

model_name model

Naïve Bayes 0x800363736B6C6561726E2E6E616976655F62617965730A...

model_name	model
Naïve Bayes	0x800363736B6C6561726E2E6E616976655F62617965730A...

Een opgeslagen procedure maken en uitvoeren voor het genereren van voorspellingen

Nu u een model hebt gemaakt, getraind en opgeslagen, gaat u verder met de volgende stap: een opgeslagen procedure maken waarmee voorspellingen worden gegenereerd. U doet dit door een Python-script uit te voeren sp_execute_external_script dat het geserialiseerde model laadt en nieuwe gegevensinvoer geeft om te scoren.

Voer de volgende code uit om de opgeslagen procedure te maken die scoren uitvoert. Tijdens runtime wordt met deze procedure een binair model geladen, worden kolommen [1,2,3,4] als invoer gebruikt en worden kolommen [0,5,6] opgegeven als uitvoer.

CREATE PROCEDURE predict_species (@model VARCHAR(100))
AS
BEGIN
    DECLARE @nb_model VARBINARY(max) = (
            SELECT model
            FROM iris_models
            WHERE model_name = @model
            );

    EXECUTE sp_execute_external_script @language = N'Python'
        , @script = N'
import pickle
irismodel = pickle.loads(nb_model)
species_pred = irismodel.predict(iris_data[["Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width"]])
iris_data["PredictedSpecies"] = species_pred
OutputDataSet = iris_data[["id","SpeciesId","PredictedSpecies"]] 
print(OutputDataSet)
'
        , @input_data_1 = N'select id, "Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width", "SpeciesId" from iris_data'
        , @input_data_1_name = N'iris_data'
        , @params = N'@nb_model varbinary(max)'
        , @nb_model = @nb_model
    WITH RESULT SETS((
                "id" INT
              , "SpeciesId" INT
              , "SpeciesId.Predicted" INT
                ));
END;
GO

Voer de opgeslagen procedure uit, waarbij u de modelnaam 'Naive Bayes' geeft, zodat de procedure weet welk model moet worden gebruikt.
```
EXECUTE predict_species 'Naive Bayes';
GO
```
Wanneer u de opgeslagen procedure uitvoert, wordt een Python data.frame geretourneerd. Deze regel van T-SQL geeft het schema op voor de geretourneerde resultaten: WITH RESULT SETS ( ("id" int, "SpeciesId" int, "SpeciesId.Predicted" int));. U kunt de resultaten invoegen in een nieuwe tabel of ze retourneren aan een toepassing.

De resultaten zijn 150 voorspellingen over soorten met behulp van bloemenkenmerken als invoer. Voor het merendeel van de waarnemingen komt de voorspelde soort overeen met de werkelijke soorten.

Dit voorbeeld is eenvoudig gemaakt met behulp van de Python-irisgegevensset voor training en scoren. Een meer gebruikelijke benadering is het uitvoeren van een SQL-query om de nieuwe gegevens op te halen en die door te geven aan Python als InputDataSet.

Conclusion

In deze oefening hebt u geleerd hoe u opgeslagen procedures maakt die zijn toegewezen aan verschillende taken, waarbij elke opgeslagen procedure de opgeslagen procedure sp_execute_external_script van het systeem gebruikte om een Python-proces te starten. Invoer voor het Python-proces wordt doorgegeven aan sp_execute_external als parameters. Zowel het Python-script zelf als de gegevensvariabelen in een database worden doorgegeven als invoer.

Over het algemeen moet u alleen azure Data Studio gebruiken met professionele Python-code of eenvoudige Python-code die op rijen gebaseerde uitvoer retourneert. Azure Data Studio biedt ondersteuning voor querytalen zoals T-SQL en retourneert platte rijensets. Als uw code visuele uitvoer genereert, zoals een spreidingsdiagram of histogram, hebt u een afzonderlijk hulpprogramma of een afzonderlijke toepassing voor eindgebruikers nodig waarmee de afbeelding buiten de opgeslagen procedure kan worden weergegeven.

Voor sommige Python-ontwikkelaars die gewend zijn om all-inclusive scripts te schrijven die een reeks bewerkingen verwerken, lijken het organiseren van taken in afzonderlijke procedures mogelijk onnodig. Maar training en scoring hebben verschillende toepassingsgevallen. Door ze te scheiden, kunt u elke taak in een andere planning plaatsen en voor elke operatie afzonderlijke machtigingen instellen.

Een laatste voordeel is dat de processen kunnen worden gewijzigd met behulp van parameters. In deze oefening is Python-code die het model (in dit voorbeeld 'Naive Bayes' genoemd) heeft gemaakt, doorgegeven als invoer voor een tweede opgeslagen procedure die het model aanroept in een scoreproces. In deze oefening wordt slechts één model gebruikt, maar u kunt zich voorstellen hoe parameteriseren van het model in een scoretaak dat script nuttiger maakt.

Volgende stappen

Zie voor meer informatie over zelfstudies voor Python met SQL Machine Learning:

Python-tutorials

Feedback

Is deze pagina nuttig?