Rövid útmutató: Prediktív modell létrehozása és pontszáma Pythonban SQL machine learning használatával

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

Ebben a rövid útmutatóban létrehoz és betanít egy prediktív modellt a Python használatával. A modellt menti az SQL Server-példány egyik táblájába, majd a modellt felhasználva előrejelzi az új adatok értékeit az SQL Server Machine Learning Services, az Azure SQL Managed Instance Machine Learning Services vagy az SQL Server big data-fürtök segítségével.

Két, SQL-ben futó tárolt eljárást fog létrehozni és végrehajtani. Az első a klasszikus Írisz virág adatkészletet használja, és létrehoz egy Naivve Bayes-modellt, amely egy íriszfajt jelez előre a virág jellemzői alapján. A második eljárás a pontozás – meghívja az első eljárásban létrehozott modellt, hogy új adatokon alapuló előrejelzéseket adjon ki. A Python-kód SQL-ben tárolt eljárásban való elhelyezésével a műveletek az SQL-ben találhatók, újrafelhasználhatók, és más tárolt eljárások és ügyfélalkalmazások is meghívhatók.

A rövid útmutató végrehajtásával a következőt fogja elsajátítani:

  • Python-kód beágyazása tárolt eljárásba
  • Bemeneti adatok átadása a kódnak a tárolt eljárás beviteli paraméterei révén
  • Hogyan használják a tárolt eljárásokat a modellek üzembe helyezésekor?

Előfeltételek

A rövid útmutató futtatásához a következő előfeltételekre lesz szüksége.

Modelleket létrehozó tárolt eljárás létrehozása

Ebben a lépésben létrehoz egy tárolt eljárást, amely létrehoz egy modellt az eredmények előrejelzéséhez.

  1. Csatlakozzon az SQL-példányhoz a Visual Studio Code MSSQL-bővítményével, és nyisson meg egy új lekérdezési ablakot.

  2. Csatlakozzon az irissql-adatbázishoz.

    USE irissql
GO

  3. Másolja a következő kódba egy új tárolt eljárás létrehozásához.

    A végrehajtáskor ez az eljárás meghívja sp_execute_external_script egy Python-munkamenet indítására.

    A Python-kódhoz szükséges bemenetek bemeneti paraméterekként lesznek átadva ezen a tárolt eljáráson. A kimenet egy betanított modell lesz, amely a Python scikit-learn kódtárán alapul a gépi tanulási algoritmushoz.

    Ez a kód pickle használatával szerializálja a modellt. A modell betanítása a iris_data tábla 0–4. oszlopának adataival történik.

    Az eljárás második részében látható paraméterek az adatbemeneteket és a modellkimeneteket ismertetik. A lehető legnagyobb mértékben azt szeretné, hogy a tárolt eljárásban futó Python-kód egyértelműen definiált bemenetekkel és kimenetekkel rendelkezzen, amelyek leképezik a tárolt eljárás bemeneteit és kimeneteit a futásidőben.

    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

  4. Ellenőrizze, hogy létezik-e a tárolt eljárás.

    Ha az előző lépés T-SQL-szkriptje hiba nélkül futott, a rendszer létrehoz egy új, generate_iris_model nevű tárolt eljárást, és hozzáadja az irissql-adatbázishoz . A tárolt eljárásokat a Visual Studio Code Object Explorerprogramozhatóság területén találja.

Modellek létrehozására és betanításaira vonatkozó eljárás végrehajtása

Ebben a lépésben végrehajtja a beágyazott kód futtatásához szükséges eljárást, és kimenetként létrehoz egy betanított és szerializált modellt.

Az adatbázisban újrafelhasználásra tárolt modellek bájtfolyamként szerializálva vannak, és egy adatbázistábla VARBINARY(MAX) oszlopában vannak tárolva. A modell létrehozása, betanítása, szerializálása és adatbázisba való mentése után más eljárások vagy a PREDICT T-SQL függvény meghívhatja a számítási feladatok pontozása során.

  1. Futtassa a következő szkriptet az eljárás végrehajtásához. A tárolt eljárás végrehajtására vonatkozó konkrét utasítás a negyedik sorban található EXECUTE .

    Ez az adott szkript törli az azonos nevű meglévő modellt ("Naive Bayes"), hogy helyet adjon az újaknak, amelyeket ugyanazzal az eljárással hozott létre. A modell törlése nélkül hiba történik, amely szerint az objektum már létezik. A modell egy iris_models nevű táblában van tárolva, amely az irissql-adatbázis létrehozásakor lesz kiépítve.

    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

  2. Ellenőrizze, hogy a modell be lett-e szúrva.

    SELECT * FROM dbo.iris_models

    Results

    model_name modell
    Naiv Bayes 0x800363736B6C6561726E2E6E616976655F62617965730A...

Tárolt eljárás létrehozása és végrehajtása előrejelzések létrehozásához

Most, hogy létrehozott, betanított és mentett egy modellt, lépjen tovább a következő lépésre: hozzon létre egy tárolt eljárást, amely előrejelzéseket hoz létre. Ezt úgy teheti meg, hogy meghívja a sp_execute_external_script, hogy elindítson egy Python-szkriptet, amely betölti a szerializált modellt, és új adatokat ad meg a kiértékeléshez.

  1. Futtassa a következő kódot a pontozást végrehajtó tárolt eljárás létrehozásához. Futásidőben ez az eljárás betölt egy bináris modellt, bemenetként oszlopokat [1,2,3,4] használ, és kimenetként adja meg az oszlopokat [0,5,6] .

    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

  2. Hajtsa végre a tárolt eljárást, és adja meg a modell "Naive Bayes" nevét, hogy az eljárás tudja, melyik modellt használja.

    EXECUTE predict_species 'Naive Bayes';
GO

    A tárolt eljárás futtatásakor a rendszer egy Python data.frame-et ad vissza. A T-SQL ezen sora adja meg a visszaadott eredmények sémáját: WITH RESULT SETS ( ("id" int, "SpeciesId" int, "SpeciesId.Predicted" int));. Az eredményeket beszúrhatja egy új táblába, vagy visszaküldheti őket egy alkalmazásnak.

    Tárolt eljárás futtatásának eredménye

    Az eredmények 150 előrejelzést adnak a fajokról, amelyek virágjellemzőket használnak bemenetként. A megfigyelések többsége esetében az előrejelzett fajok megegyeznek a tényleges fajokkal.

    Ez a példa a Python írisz adatkészletének betanításhoz és pontozáshoz való használatával lett egyszerűbb. Egy tipikusabb megközelítés egy SQL-lekérdezés futtatásával lekérné az új adatokat, és ezt a Pythonba adná át.InputDataSet

Conclusion

Ebben a gyakorlatban megtanulta, hogyan hozhat létre különböző feladatokhoz dedikált tárolt eljárásokat, ahol minden tárolt eljárás a rendszer által tárolt eljárást sp_execute_external_script használta egy Python-folyamat elindításához. A Python-folyamat bemenetei paraméterként lesznek átadva sp_execute_external . A Python-szkript és az adatbázis adatváltozói is bemenetként lesznek átadva.

Általában érdemes csak letisztult vagy egyszerű, soralapú kimenetet adó Python-kóddal használni a Visual Studio Code-ot. Eszközként a Visual Studio Code támogatja az olyan lekérdezési nyelveket, mint a T-SQL, és lapított sorkészleteket ad vissza. Ha a kód olyan vizuális kimenetet hoz létre, mint a pontdiagram vagy a hisztogram, külön eszközre vagy végfelhasználói alkalmazásra van szükség, amely a tárolt eljáráson kívül is megjelenítheti a képet.

Egyes Python-fejlesztők számára, akik a műveletek egy sorát kezelő all-inclusive szkriptek írására használják, szükségtelennek tűnhet a feladatok külön eljárásokba szervezése. Az oktatásnak és a pontozásnak azonban különböző alkalmazási területei vannak. Ha különválasztja őket, az egyes tevékenységeket különböző ütemezési és hatóköri engedélyekre helyezheti az egyes műveletekre.

Végső előnye, hogy a folyamatok paraméterekkel módosíthatók. Ebben a gyakorlatban a modellt létrehozó Python-kód (ebben a példában "Naive Bayes" néven) egy második tárolt eljárás bemeneteként lett átadva, amely pontozási folyamatban hívja meg a modellt. Ez a gyakorlat csak egy modellt használ, de el tudja képzelni, hogy a modell paraméterezése egy pontozási feladatban hogyan tenné hasznosabbá a szkriptet.

Kapcsolódó tartalom

  • Last updated on