Python-oktatóanyag: Előrejelzések futtatása tárolt eljárásba beágyazott Python használatával

A következőkre vonatkozik: Sql Server 2017 (14.x) és újabb verziók Felügyelt Azure SQL-példány

Az ötrészes oktatóanyag-sorozat ötödik részében megtanulhatja, hogyan lehet üzembe helyezni az előző részben betanított és mentett modelleket.

Ebben a forgatókönyvben az operationalizálás azt jelenti, hogy a modellt éles környezetben üzembe helyezik pontozás céljából. Az SQL Serverrel való integráció meglehetősen egyszerűvé teszi ezt, mivel Python-kódot ágyazhat be egy tárolt eljárásba. Ha új bemenetek alapján szeretne előrejelzéseket lekérni a modellből, egyszerűen hívja meg a tárolt eljárást egy alkalmazásból, és adja át az új adatokat.

Az oktatóanyag ezen része két módszert mutat be az előrejelzések Python-modellen alapuló létrehozására: kötegelt pontozást és sorról sorra történő pontozást.

Kötegelt pontozás: Több sornyi bemeneti adat megadásához adjon át egy SELECT lekérdezést argumentumként a tárolt eljárásnak. Az eredmény a bemeneti eseteknek megfelelő megfigyelési táblázat.
Egyéni pontozás: Adjon meg egy sor egyedi paraméterértéket bemenetként. A tárolt eljárás egyetlen sort vagy értéket ad vissza.

A pontozáshoz szükséges összes Python-kód a tárolt eljárások részeként van megadva.

Ebben a cikkben a következőket fogja megismerni:

Tárolt eljárások létrehozása és használata kötegelt értékeléshez
Tárolt eljárások létrehozása és használata egyetlen sor pontozásához

Az első részben telepítette az előfeltételeket, és visszaállította a mintaadatbázist.

A második részben megvizsgálta a mintaadatokat, és létrehozott néhány diagramot.

A harmadik részben megtanulta, hogyan hozhat létre funkciókat nyers adatokból egy Transact-SQL függvény használatával. Ezt követően egy tárolt eljárásból meghívta ezt a függvényt, hogy létrehozhasson egy táblát, amely tartalmazza a funkcióértékeket.

A negyedik részben betöltötte a modulokat, és meghívta a modell sql serverrel tárolt eljárás használatával történő létrehozásához és betanítása szükséges függvényeket.

Kötegelt kiértékelés

Az alábbi szkriptek használatával létrehozott első két tárolt eljárás a Python-előrejelzési hívások tárolt eljárásban történő burkolásának alapszintaxisát szemlélteti. Mindkét tárolt eljáráshoz adattáblára van szükség bemenetként.

A használni kívánt modell neve a tárolt eljárás bemeneti paramétereként van megadva. A tárolt eljárás betölti a szerializált modellt az adatbázistábla nyc_taxi_models.táblájából a tárolt eljárás SELECT utasításával.
A szerializált modellt a Python-változó mod tárolja további feldolgozás céljából a Python használatával.
A pontszámot igénylő új esetek a megadott Transact-SQL lekérdezésből @input_data_1származnak. A lekérdezési adatok olvasása során a sorok az alapértelmezett adatkeretbe lesznek mentve. InputDataSet
Mindkét tárolt eljárás függvényeket sklearn használ a pontossági metrika, az AUC (görbe alatti terület) kiszámításához. Pontossági metrikák, például az AUC csak akkor hozhatók létre, ha a célcímkét (a billentött oszlopot ) is megadja. Az előrejelzésekhez nincs szükség a célcímkére (változó y), de a pontossági metrika számítása igen.

Ezért ha nem rendelkezik célcímkékkel a kiértékelt adathoz, módosíthatja a tárolt eljárást az AUC-számítások eltávolításához, és csak a jellemzők valószínűségeit adja vissza (a tárolt eljárás változója X ).

PredictTipSciKitPy

Futtassa a következő T-SQL-utasításokat a tárolt eljárás PredictTipSciKitPylétrehozásához. Ehhez a tárolt eljáráshoz a scikit-learn csomagon alapuló modellre van szükség, mivel az adott csomagra jellemző függvényeket használ.

A bemeneteket tartalmazó adatkeretet a predict_proba rendszer a logisztikai regressziós modell függvényének továbbítja. mod A predict_proba függvény (probArray = mod.predict_proba(X)) egy lebegőpont értéket ad vissza, amely annak a valószínűségét jelzi, hogy egy tipp (bármilyen összegű) lesz adva.

DROP PROCEDURE IF EXISTS PredictTipSciKitPy;
GO

CREATE PROCEDURE [dbo].[PredictTipSciKitPy] (@model varchar(50), @inquery nvarchar(max))
AS
BEGIN
DECLARE @lmodel2 varbinary(max) = (select model from nyc_taxi_models where name = @model);
EXEC sp_execute_external_script
  @language = N'Python',
  @script = N'
import pickle;
import numpy;
from sklearn import metrics

mod = pickle.loads(lmodel2)
X = InputDataSet[["passenger_count", "trip_distance", "trip_time_in_secs", "direct_distance"]]
y = numpy.ravel(InputDataSet[["tipped"]])

probArray = mod.predict_proba(X)
probList = []
for i in range(len(probArray)):
  probList.append((probArray[i])[1])

probArray = numpy.asarray(probList)
fpr, tpr, thresholds = metrics.roc_curve(y, probArray)
aucResult = metrics.auc(fpr, tpr)
print ("AUC on testing data is: " + str(aucResult))

OutputDataSet = pandas.DataFrame(data = probList, columns = ["predictions"])
',	
  @input_data_1 = @inquery,
  @input_data_1_name = N'InputDataSet',
  @params = N'@lmodel2 varbinary(max)',
  @lmodel2 = @lmodel2
WITH RESULT SETS ((Score float));
END
GO

PredictTipRxPy

Futtassa a következő T-SQL-utasításokat a tárolt eljárás PredictTipRxPylétrehozásához. Ez a tárolt eljárás ugyanazokat a bemeneteket használja, és ugyanazokat a pontszámtípusokat hozza létre, mint az előző tárolt eljárás, de az SQL Server gépi tanuláshoz biztosított revoscalepy-csomag függvényeit használja.

DROP PROCEDURE IF EXISTS PredictTipRxPy;
GO

CREATE PROCEDURE [dbo].[PredictTipRxPy] (@model varchar(50), @inquery nvarchar(max))
AS
BEGIN
DECLARE @lmodel2 varbinary(max) = (select model from nyc_taxi_models where name = @model);
EXEC sp_execute_external_script 
  @language = N'Python',
  @script = N'
import pickle;
import numpy;
from sklearn import metrics
from revoscalepy.functions.RxPredict import rx_predict;

mod = pickle.loads(lmodel2)
X = InputDataSet[["passenger_count", "trip_distance", "trip_time_in_secs", "direct_distance"]]
y = numpy.ravel(InputDataSet[["tipped"]])

probArray = rx_predict(mod, X)
probList = probArray["tipped_Pred"].values 

probArray = numpy.asarray(probList)
fpr, tpr, thresholds = metrics.roc_curve(y, probArray)
aucResult = metrics.auc(fpr, tpr)
print ("AUC on testing data is: " + str(aucResult))

OutputDataSet = pandas.DataFrame(data = probList, columns = ["predictions"])
',
  @input_data_1 = @inquery,
  @input_data_1_name = N'InputDataSet',
  @params = N'@lmodel2 varbinary(max)',
  @lmodel2 = @lmodel2
WITH RESULT SETS ((Score float));
END
GO

Kötegelt pontozás futtatása SELECT-lekérdezéssel

A tárolt eljárásokhoz a PredictTipSciKitPy és a PredictTipRxPy két bemeneti paramétert igényel:

A pontozáshoz szükséges adatokat lekérő lekérdezés
Betanított modell neve

Ha ezeket az argumentumokat átadja a tárolt eljárásnak, kiválaszthat egy adott modellt, vagy módosíthatja a pontozáshoz használt adatokat.

A scikit-learn modell pontozáshoz való használatához hívja meg a PredictTipSciKitPy tárolt eljárást, és adja meg bemenetként a modell nevét és a lekérdezési sztringet.
```
DECLARE @query_string nvarchar(max) -- Specify input query
  SET @query_string='
  select tipped, fare_amount, passenger_count, trip_time_in_secs, trip_distance,
  dbo.fnCalculateDistance(pickup_latitude, pickup_longitude,  dropoff_latitude, dropoff_longitude) as direct_distance
  from nyctaxi_sample_testing'
EXEC [dbo].[PredictTipSciKitPy] 'SciKit_model', @query_string;
```
A tárolt eljárás előrejelzett valószínűségeket ad vissza a bemeneti lekérdezés részeként átadott minden egyes úthoz.

Ha SSMS-t (SQL Server Management Studio) használ a lekérdezések futtatásához, a valószínűségek táblázatként jelennek meg az Eredmények panelen. Az Üzenetek panel a pontossági metrikát (AUC vagy a görbe alatti területet) adja ki 0,56 körüli értékkel.

Ha a revoscalepy modellt szeretné használni a pontozáshoz, hívja meg a PredictTipRxPy tárolt eljárást, és adja meg bemenetként a modell nevét és a lekérdezési sztringet.

DECLARE @query_string nvarchar(max) -- Specify input query
  SET @query_string='
  select tipped, fare_amount, passenger_count, trip_time_in_secs, trip_distance,
  dbo.fnCalculateDistance(pickup_latitude, pickup_longitude,  dropoff_latitude, dropoff_longitude) as direct_distance
  from nyctaxi_sample_testing'
EXEC [dbo].[PredictTipRxPy] 'revoscalepy_model', @query_string;

Egysoros pontozás

Előfordulhat, hogy a kötegelt pontozás helyett érdemes lehet egyetlen esetet megadni, értékeket lekérni egy alkalmazásból, és egyetlen eredményt visszaadni ezek alapján. Beállíthatja például egy Excel-munkalapot, webalkalmazást vagy jelentést, hogy meghívja a tárolt eljárást, és átadja neki a felhasználók által beírt vagy kiválasztott bemeneteket.

Ebben a szakaszban megtanulhatja, hogyan hozhat létre egyetlen előrejelzést két tárolt eljárás meghívásával:

A PredictTipSingleModeSciKitPy egysoros kiértékelésre lett tervezve a scikit-learn modell használatával.
A PredictTipSingleModeRxPy egysoros pontozásra lett tervezve a revoscalepy modell használatával.
Ha még nem tanított be egy modellt, menjen vissza az ötödik részhez!

Mindkét modell egyetlen érték sorozatát veszi bemenetként, például az utasok számát, az utazási távolságot és így tovább. A táblaértékű függvények fnEngineerFeaturesa bemenetek szélességi és hosszúsági értékeit egy új, közvetlen távolságú funkcióvá alakítják át. A negyedik rész ennek a táblaértékű függvénynek a leírását tartalmazza.

Mindkét tárolt eljárás létrehoz egy pontszámot a Python-modell alapján.

Megjegyzés:

Fontos, hogy megadja a Python-modell által megkövetelt összes bemeneti funkciót, amikor külső alkalmazásból hívja meg a tárolt eljárást. A hibák elkerülése érdekében előfordulhat, hogy a bemeneti adatokat Python-adattípussá kell alakítania vagy át kell alakítania az adattípus és az adathossz ellenőrzése mellett.

PredictTipSingleModeSciKitPy

Az alábbi tárolt eljárás PredictTipSingleModeSciKitPy a scikit-learn modell használatával végez pontozást.

DROP PROCEDURE IF EXISTS PredictTipSingleModeSciKitPy;
GO

CREATE PROCEDURE [dbo].[PredictTipSingleModeSciKitPy] (@model varchar(50), @passenger_count int = 0,
  @trip_distance float = 0,
  @trip_time_in_secs int = 0,
  @pickup_latitude float = 0,
  @pickup_longitude float = 0,
  @dropoff_latitude float = 0,
  @dropoff_longitude float = 0)
AS
BEGIN
  DECLARE @inquery nvarchar(max) = N'
  SELECT * FROM [dbo].[fnEngineerFeatures]( 
    @passenger_count,
    @trip_distance,
    @trip_time_in_secs,
    @pickup_latitude,
    @pickup_longitude,
    @dropoff_latitude,
    @dropoff_longitude)
    '
DECLARE @lmodel2 varbinary(max) = (select model from nyc_taxi_models where name = @model);
EXEC sp_execute_external_script 
  @language = N'Python',
  @script = N'
import pickle;
import numpy;

# Load model and unserialize
mod = pickle.loads(model)

# Get features for scoring from input data
X = InputDataSet[["passenger_count", "trip_distance", "trip_time_in_secs", "direct_distance"]]

# Score data to get tip prediction probability as a list (of float)
probList = []
probList.append((mod.predict_proba(X)[0])[1])

# Create output data frame
OutputDataSet = pandas.DataFrame(data = probList, columns = ["predictions"])
',
  @input_data_1 = @inquery,
  @params = N'@model varbinary(max),@passenger_count int,@trip_distance float,
    @trip_time_in_secs int ,
    @pickup_latitude float ,
    @pickup_longitude float ,
    @dropoff_latitude float ,
    @dropoff_longitude float',
    @model = @lmodel2,
    @passenger_count =@passenger_count ,
    @trip_distance=@trip_distance,
    @trip_time_in_secs=@trip_time_in_secs,
    @pickup_latitude=@pickup_latitude,
    @pickup_longitude=@pickup_longitude,
    @dropoff_latitude=@dropoff_latitude,
    @dropoff_longitude=@dropoff_longitude
WITH RESULT SETS ((Score float));
END
GO

PredictTipSingleModeRxPy

Az alábbi tárolt eljárás PredictTipSingleModeRxPy a revoscalepy-modell használatával végez pontozást.

DROP PROCEDURE IF EXISTS PredictTipSingleModeRxPy;
GO

CREATE PROCEDURE [dbo].[PredictTipSingleModeRxPy] (@model varchar(50), @passenger_count int = 0,
  @trip_distance float = 0,
  @trip_time_in_secs int = 0,
  @pickup_latitude float = 0,
  @pickup_longitude float = 0,
  @dropoff_latitude float = 0,
  @dropoff_longitude float = 0)
AS
BEGIN
DECLARE @inquery nvarchar(max) = N'
  SELECT * FROM [dbo].[fnEngineerFeatures]( 
    @passenger_count,
    @trip_distance,
    @trip_time_in_secs,
    @pickup_latitude,
    @pickup_longitude,
    @dropoff_latitude,
    @dropoff_longitude)
  '
DECLARE @lmodel2 varbinary(max) = (select model from nyc_taxi_models where name = @model);
EXEC sp_execute_external_script 
  @language = N'Python',
  @script = N'
import pickle;
import numpy;
from revoscalepy.functions.RxPredict import rx_predict;

# Load model and unserialize
mod = pickle.loads(model)

# Get features for scoring from input data
X = InputDataSet[["passenger_count", "trip_distance", "trip_time_in_secs", "direct_distance"]]

# Score data to get tip prediction probability as a list (of float)

probArray = rx_predict(mod, X)

probList = []
probList = probArray["tipped_Pred"].values

# Create output data frame
OutputDataSet = pandas.DataFrame(data = probList, columns = ["predictions"])
',
  @input_data_1 = @inquery,
  @params = N'@model varbinary(max),@passenger_count int,@trip_distance float,
    @trip_time_in_secs int ,
    @pickup_latitude float ,
    @pickup_longitude float ,
    @dropoff_latitude float ,
    @dropoff_longitude float',
    @model = @lmodel2,
    @passenger_count =@passenger_count ,
    @trip_distance=@trip_distance,
    @trip_time_in_secs=@trip_time_in_secs,
    @pickup_latitude=@pickup_latitude,
    @pickup_longitude=@pickup_longitude,
    @dropoff_latitude=@dropoff_latitude,
    @dropoff_longitude=@dropoff_longitude
WITH RESULT SETS ((Score float));
END
GO

Pontszámok létrehozása modellekből

A tárolt eljárások létrehozása után könnyen létrehozhat pontszámot bármelyik modell alapján. Nyisson meg egy új lekérdezési ablakot, és adjon meg paramétereket az egyes funkcióoszlopokhoz.

A funkcióoszlopok hét kötelező értéke a következő sorrendben van:

passenger_count
trip_distance
utazási_idő_másodpercben
pickup_latitude
pickup_longitude
dropoff_latitude
dropoff_longitude

Például:

Ha előrejelzést szeretne generálni a revoscalepy-modell használatával, futtassa ezt az utasítást:

EXEC [dbo].[PredictTipSingleModeRxPy] 'revoscalepy_model', 1, 2.5, 631, 40.763958,-73.973373, 40.782139,-73.977303

Ha pontszámot szeretne létrehozni a scikit-learn modellel, futtassa ezt az utasítást:

EXEC [dbo].[PredictTipSingleModeSciKitPy] 'SciKit_model', 1, 2.5, 631, 40.763958,-73.973373, 40.782139,-73.977303

Mindkét eljárás kimenete annak a valószínűsége, hogy borravalót fizetnek a taxiútra a megadott paraméterekkel vagy jellemzőkkel.

Conclusion

Ebben az oktatóanyag-sorozatban megtanulta, hogyan dolgozhat a tárolt eljárásokba beágyazott Python-kódokkal. A Transact-SQL integrációja sokkal egyszerűbbé teszi a Python-modellek üzembe helyezését előrejelzés céljából, valamint a modellek újratanítását egy vállalati adat-munkafolyamat részeként.

Következő lépések

Ebben a cikkben a következőt találja:

Tárolt eljárásokat hoztam létre és használtam kötegelt pontszámításhoz.
Tárolt eljárások létrehozása és használata egyetlen sor pontozásához

A Pythonról további információt az SQL Server Python-bővítményében talál.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-10-31