Snabbstart: Skapa och poängsätta en förutsägelsemodell i Python med SQL-maskininlärning

2025-10-31

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

I den här snabbstarten skapar och tränar du en förutsägelsemodell med Hjälp av Python. Du sparar modellen i en tabell i SQL Server-instansen och använder sedan modellen för att förutsäga värden från nya data med hjälp av SQL Server Machine Learning Services, Azure SQL Managed Instance Machine Learning Services eller SQL Server Big Data Clusters.

Du skapar och kör två lagrade procedurer som körs i SQL. Den första använder den klassiska Iris-blomdatauppsättningen och genererar en naiv Bayes-modell för att förutsäga en Iris-art baserat på blomegenskaper. Den andra proceduren är för bedömning – den anropar modellen som genererades i den första proceduren för att mata ut en uppsättning förutsägelser baserat på nya data. Genom att placera Python-kod i en SQL-lagrad procedur finns åtgärder i SQL, kan återanvändas och kan anropas av andra lagrade procedurer och klientprogram.

Genom att slutföra den här snabbstarten får du lära dig:

Hur man bäddar in Python-kod i en lagrad procedur
Överföra indata till din kod genom inmatningar i den lagrade proceduren.
Hur lagrade procedurer används för att operationalisera modeller

Förutsättningar

Du behöver följande förutsättningar för att köra den här snabbstarten.

En SQL-databas på någon av dessa plattformar:
- SQL Server Machine Learning Services. Information om hur du installerar finns i installationsguiden för Windows eller installationsguiden för Linux.
- SQL Server-stordatakluster. Se hur du aktiverar Machine Learning Services på SQL Server Big Data Clusters.
- Azure SQL Managed Instance Machine Learning Services. Mer information finns i Översikt över Azure SQL Managed Instance Machine Learning Services.
Ett verktyg för att köra SQL-frågor som innehåller Python-skript. Den här snabbstarten använder Azure Data Studio.
Exempeldata som används i den här övningen är Iris-exempeldata. Följ anvisningarna i Iris demodata för att skapa exempeldatabasen irissql.

Skapa en lagrad procedur som genererar modeller

I det här steget skapar du en lagrad procedur som genererar en modell för att förutsäga resultat.

Öppna Azure Data Studio, anslut till din SQL-instans och öppna ett nytt frågefönster.
Anslut till irissql-databasen.
```
USE irissql
GO
```
Kopiera i följande kod för att skapa en ny lagrad procedur.

När den här proceduren körs anropas sp_execute_external_script för att starta en Python-session.

Indata som behövs av Python-koden överförs som indataparametrar i den här lagrade proceduren. Utdata är en tränad modell som baseras på Python scikit-learn-biblioteket för maskininlärningsalgoritmen.

Den här koden använder pickle för att serialisera modellen. Modellen tränas med data från kolumnerna 0 till 4 från tabellen iris_data .

Parametrarna som du ser i den andra delen av proceduren uttrycker dataindata och modellutdata. Så mycket som möjligt vill du att Python-koden som körs i en lagrad procedur ska ha tydligt definierade indata och utdata som mappar till lagrade indata och utdata som skickas vid körning.
```
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
```
Kontrollera att den lagrade proceduren finns.

Om T-SQL-skriptet från föregående steg kördes utan fel skapas en ny lagrad procedur med namnet generate_iris_model och läggs till i irissql-databasen . Du hittar lagrade procedurer i Azure Data Studio Object Explorer under Programmering.

Kör proceduren för att skapa och träna modeller

I det här steget kör du proceduren för att köra den inbäddade koden och skapar en tränad och serialiserad modell som utdata.

Modeller som lagras för återanvändning i databasen serialiseras som en byteström och lagras i en VARBINARY-kolumn (MAX) i en databastabell. När modellen har skapats, tränats, serialiserats och sparats i en databas kan den anropas av andra procedurer eller av funktionen PREDICT T-SQL i bedömningsarbetsbelastningar.

Kör följande skript för att köra proceduren. Den specifika instruktionen för att köra en lagrad procedur finns EXECUTE på den fjärde raden.

Det här skriptet tar bort en befintlig modell med samma namn ("Naive Bayes") för att göra plats för nya som skapats genom att köra samma procedur igen. Utan modellborttagning uppstår ett fel som anger att objektet redan finns. Modellen lagras i en tabell med namnet iris_models, som etablerades när du skapade irissql-databasen .
```
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
```
Kontrollera att modellen har infogats.
```
SELECT * FROM dbo.iris_models
```
Results

model_name model

Naive Bayes 0x800363736B6C6561726E2E6E616976655F62617965730A...

model_name	model
Naive Bayes	0x800363736B6C6561726E2E6E616976655F62617965730A...

Skapa och köra en lagrad procedur för att generera förutsägelser

Nu när du har skapat, tränat och sparat en modell går du vidare till nästa steg: skapa en lagrad procedur som genererar förutsägelser. Du gör detta genom att anropa sp_execute_external_script för att köra ett Python-skript som läser in den serialiserade modellen och ger den nya dataindata att poängsätta.

Kör följande kod för att skapa den lagrade proceduren som utför bedömning. Vid körning läser den här proceduren in en binär modell, använder kolumner [1,2,3,4] som indata och anger kolumner [0,5,6] som utdata.

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

Kör den lagrade proceduren och ge modellnamnet "Naive Bayes" så att proceduren vet vilken modell som ska användas.
```
EXECUTE predict_species 'Naive Bayes';
GO
```
När du kör den lagrade proceduren returneras en Python-data.frame. Den här raden i T-SQL anger schemat för de returnerade resultaten: WITH RESULT SETS ( ("id" int, "SpeciesId" int, "SpeciesId.Predicted" int));. Du kan infoga resultatet i en ny tabell eller returnera dem till ett program.

Resultaten är 150 förutsägelser om arter som använder blommiga egenskaper som indata. För majoriteten av observationerna matchar den förutsagda arten den faktiska arten.

Det här exemplet har gjorts enkelt genom att använda Python iris-datauppsättningen för både träning och bedömning. En mer typisk metod skulle innebära att köra en SQL-fråga för att hämta nya data och skicka dem till Python som InputDataSet.

Conclusion

I den här övningen har du lärt dig hur du skapar lagrade procedurer som är dedikerade till olika uppgifter, där varje lagrad procedur använde den system lagrade proceduren sp_execute_external_script för att starta en Python-process. Indata till Python-processen skickas till sp_execute_external som parametrar. Både själva Python-skriptet och datavariablerna i en databas skickas som indata.

I allmänhet bör du bara planera att använda Azure Data Studio med polerad Python-kod eller enkel Python-kod som returnerar radbaserade utdata. Som ett verktyg stöder Azure Data Studio frågespråk som T-SQL och returnerar utplattade rader. Om koden genererar visuella utdata som ett punktdiagram eller histogram behöver du ett separat verktyg eller slutanvändarprogram som kan återge bilden utanför den lagrade proceduren.

För vissa Python-utvecklare som är vana vid att skriva allomfattande skript som hanterar en rad åtgärder kan det verka onödigt att organisera uppgifter i separata procedurer. Men träning och bedömning har olika användningsfall. Genom att avgränsa dem kan du placera varje aktivitet enligt ett annat schema och omfångsbehörigheter för varje åtgärd.

En slutlig fördel är att processerna kan ändras med hjälp av parametrar. I den här övningen skickades Python-kod som skapade modellen (med namnet "Naive Bayes" i det här exemplet) som indata till en andra lagrad procedur som anropar modellen i en bedömningsprocess. Den här övningen använder bara en modell, men du kan föreställa dig hur parameterisering av modellen i en bedömningsuppgift skulle göra skriptet mer användbart.

Nästa steg

Mer information om självstudier för Python med SQL-maskininlärning finns i:

Python-självstudier

Feedback

Var den här sidan till hjälp?