Entraîner et enregistrer un modèle Python à l’aide de T-SQLTrain and save a Python model using T-SQL

S’APPLIQUE À : ouiSQL Server nonAzure SQL Database nonAzure Synapse Analytics (SQL DW) nonParallel Data Warehouse APPLIES TO: yesSQL Server noAzure SQL Database noAzure Synapse Analytics (SQL DW) noParallel Data Warehouse

Cet article fait partie d’un tutoriel, Analytique Python en base de données pour développeur SQL.This article is part of a tutorial, In-database Python analytics for SQL developers.

Dans cette étape, vous allez apprendre à entraîner un modèle de Machine Learning à l’aide des packages Python scikit-Learn et revoscalepy.In this step, you learn how to train a machine learning model using the Python packages scikit-learn and revoscalepy. Ces bibliothèques Python sont déjà installées avec SQL Server Machine Learning Services.These Python libraries are already installed with SQL Server Machine Learning Services.

Vous chargez les modules et appelez les fonctions nécessaires pour créer et entraîner le modèle à l’aide d’une procédure stockée SQL Server.You load the modules and call the necessary functions to create and train the model using a SQL Server stored procedure. Le modèle nécessite les fonctionnalités de données que vous avez développées dans les leçons précédentes.The model requires the data features you engineered in earlier lessons. Enfin, vous enregistrez le modèle formé dans une table SQL ServerSQL Server.Finally, you save the trained model to a SQL ServerSQL Server table.

Diviser les exemples de données dans des jeux d'apprentissage et de testSplit the sample data into training and testing sets

  1. Créez une procédure stockée appelée PyTrainTestSplit pour diviser les données de la table nyctaxi_sample en deux parties : nyctaxi_sample_training et nyctaxi_sample_testing.Create a stored procedure called PyTrainTestSplit to divide the data in the nyctaxi_sample table into two parts: nyctaxi_sample_training and nyctaxi_sample_testing.

    Cette procédure stockée doit déjà être créée pour vous, mais vous pouvez exécuter le code suivant pour la créer :This stored procedure should already be created for you, but you can run the following code to create it:

    DROP PROCEDURE IF EXISTS PyTrainTestSplit;
    GO
    
    CREATE PROCEDURE [dbo].[PyTrainTestSplit] (@pct int)
    AS
    
    DROP TABLE IF EXISTS dbo.nyctaxi_sample_training
    SELECT * into nyctaxi_sample_training FROM nyctaxi_sample WHERE (ABS(CAST(BINARY_CHECKSUM(medallion,hack_license)  as int)) % 100) < @pct
    
    DROP TABLE IF EXISTS dbo.nyctaxi_sample_testing
    SELECT * into nyctaxi_sample_testing FROM nyctaxi_sample
    WHERE (ABS(CAST(BINARY_CHECKSUM(medallion,hack_license)  as int)) % 100) > @pct
    GO
    
  2. Pour diviser vos données à l’aide d’un fractionnement personnalisé, exécutez la procédure stockée et saisissez un entier qui représente le pourcentage de données allouées au jeu d’apprentissage.To divide your data using a custom split, run the stored procedure, and type an integer that represents the percentage of data allocated to the training set. Par exemple, l’instruction suivante alloue 60 % des données au jeu d’apprentissage.For example, the following statement would allocate 60% of data to the training set.

    EXEC PyTrainTestSplit 60
    GO
    

Créer un modèle de régression logistiqueBuild a logistic regression model

Une fois les données préparées, vous pouvez les utiliser pour entraîner un modèle.After the data has been prepared, you can use it to train a model. Pour ce faire, vous devez appeler une procédure stockée qui exécute du code Python, en prenant comme entrée la table de données d’apprentissage.You do this by calling a stored procedure that runs some Python code, taking as input the training data table. Pour ce didacticiel, vous créez deux modèles, tous deux modèles de classification binaire :For this tutorial, you create two models, both binary classification models:

  • La procédure stockée PyTrainScikit crée un modèle de prédiction de conseil à l’aide du package scikit-Learn.The stored procedure PyTrainScikit creates a tip prediction model using the scikit-learn package.
  • La procédure stockée TrainTipPredictionModelRxPy crée un modèle de prédiction de conseil à l’aide du package revoscalepy.The stored procedure TrainTipPredictionModelRxPy creates a tip prediction model using the revoscalepy package.

Chaque procédure stockée utilise les données d’entrée que vous fournissez pour créer et entraîner un modèle de régression logistique.Each stored procedure uses the input data you provide to create and train a logistic regression model. Tout le code Python est encapsulé dans la procédure stockée système, sp_execute_external_script.All Python code is wrapped in the system stored procedure, sp_execute_external_script.

Pour faciliter la reformation du modèle sur les nouvelles données, vous encapsulez l’appel à sp_execute_external_script dans une autre procédure stockée et transmettez les nouvelles données d’apprentissage en tant que paramètre.To make it easier to retrain the model on new data, you wrap the call to sp_execute_external_script in another stored procedure, and pass in the new training data as a parameter. Cette section vous guidera tout au long du processus.This section will walk you through that process.

PyTrainScikitPyTrainScikit

  1. Dans Management StudioManagement Studio, ouvrez une nouvelle fenêtre de Requête et exécutez l’instruction suivante pour créer la procédure stockée PyTrainScikit.In Management StudioManagement Studio, open a new Query window and run the following statement to create the stored procedure PyTrainScikit. La procédure stockée contient une définition des données d’entrée, vous n’avez pas besoin de fournir de requête d’entrée.The stored procedure contains a definition of the input data, so you don't need to provide an input query.

    DROP PROCEDURE IF EXISTS PyTrainScikit;
    GO
    
    CREATE PROCEDURE [dbo].[PyTrainScikit] (@trained_model varbinary(max) OUTPUT)
    AS
    BEGIN
    EXEC sp_execute_external_script
      @language = N'Python',
      @script = N'
    import numpy
    import pickle
    from sklearn.linear_model import LogisticRegression
    
    ##Create SciKit-Learn logistic regression model
    X = InputDataSet[["passenger_count", "trip_distance", "trip_time_in_secs", "direct_distance"]]
    y = numpy.ravel(InputDataSet[["tipped"]])
    
    SKLalgo = LogisticRegression()
    logitObj = SKLalgo.fit(X, y)
    
    ##Serialize model
    trained_model = pickle.dumps(logitObj)
    ',
    @input_data_1 = N'
    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_training
    ',
    @input_data_1_name = N'InputDataSet',
    @params = N'@trained_model varbinary(max) OUTPUT',
    @trained_model = @trained_model OUTPUT;
    ;
    END;
    GO
    
  2. Exécutez les instructions SQL suivantes pour insérer le modèle formé dans la table _nyctaxi_models.Run the following SQL statements to insert the trained model into table nyc_taxi_models.

    DECLARE @model VARBINARY(MAX);
    EXEC PyTrainScikit @model OUTPUT;
    INSERT INTO nyc_taxi_models (name, model) VALUES('SciKit_model', @model);
    

    Le traitement des données et l’ajustement du modèle peuvent prendre quelques minutes.Processing of the data and fitting the model might take a couple of mins. Les messages éventuellement redirigés vers le flux stdout de Python sont affichés dans la fenêtre Messages de Management StudioManagement Studio.Messages that would be piped to Python's stdout stream are displayed in the Messages window of Management StudioManagement Studio. Par exemple : For example:

    Message(s) STDOUT provenant du script externe : C:\Program Files\Microsoft SQL Server\MSSQL14. MSSQLSERVER \ PYTHON_SERVICES \lib\site-packages\revoscalepySTDOUT message(s) from external script: C:\Program Files\Microsoft SQL Server\MSSQL14.MSSQLSERVER\PYTHON_SERVICES\lib\site-packages\revoscalepy

  3. Ouvrez la table nyc_taxi_models.Open the table nyc_taxi_models. Vous pouvez voir qu’une nouvelle ligne a été ajoutée, avec le modèle sérialisé dans la colonne model.You can see that one new row has been added, which contains the serialized model in the column model.

    SciKit_model 0x800363736B6C6561726E2E6C696E6561....SciKit_model 0x800363736B6C6561726E2E6C696E6561....

TrainTipPredictionModelRxPyTrainTipPredictionModelRxPy

Cette procédure stockée utilise le nouveau package revoscalepy, qui est un nouveau package pour Python.This stored procedure uses the new revoscalepy package, which is a new package for Python. Elle contient des objets, des transformations et des algorithmes similaires à ceux fournis pour le package RevoScaleR du langage R.It contains objects, transformation, and algorithms similar to those provided for the R language's RevoScaleR package.

À l’aide du package revoscalepy, vous pouvez créer des contextes de calcul distants, déplacer des données entre des contextes de calcul, transformer des données et entraîner des modèles prédictifs à l’aide d’algorithmes populaires tels que la régression logistique et linéaire, les arbres de décision, etc.By using revoscalepy, you can create remote compute contexts, move data between compute contexts, transform data, and train predictive models using popular algorithms such as logistic and linear regression, decision trees, and more. Pour plus d’informations, consultez le module revoscalepy dans SQL Server et la référence de fonction revoscalepy.For more information, see revoscalepy module in SQL Server and revoscalepy function reference.

  1. Dans Management StudioManagement Studio, ouvrez une nouvelle fenêtre de Requête et exécutez l’instruction suivante pour créer la procédure stockée TrainTipPredictionModelRxPy.In Management StudioManagement Studio, open a new Query window and run the following statement to create the stored procedure TrainTipPredictionModelRxPy. Étant donné que la procédure stockée contient déjà une définition des données d’entrée, vous n’avez pas besoin de fournir de requête d’entrée.Because the stored procedure already includes a definition of the input data, you don't need to provide an input query.

    DROP PROCEDURE IF EXISTS TrainTipPredictionModelRxPy;
    GO
    
    CREATE PROCEDURE [dbo].[TrainTipPredictionModelRxPy] (@trained_model varbinary(max) OUTPUT)
    AS
    BEGIN
    EXEC sp_execute_external_script 
      @language = N'Python',
      @script = N'
    import numpy
    import pickle
    from revoscalepy.functions.RxLogit import rx_logit
    
    ## Create a logistic regression model using rx_logit function from revoscalepy package
    logitObj = rx_logit("tipped ~ passenger_count + trip_distance + trip_time_in_secs + direct_distance", data = InputDataSet);
    
    ## Serialize model
    trained_model = pickle.dumps(logitObj)
    ',
    @input_data_1 = N'
    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_training
    ',
    @input_data_1_name = N'InputDataSet',
    @params = N'@trained_model varbinary(max) OUTPUT',
    @trained_model = @trained_model OUTPUT;
    ;
    END;
    GO
    

    Cette procédure stockée exécute les étapes suivantes dans le cadre de la formation du modèle :This stored procedure performs the following steps as part of model training:

    • La requête SELECT applique la fonction scalaire personnalisée fnCalculateDistance pour calculer la distance directe entre les points de prise en charge et de dépose.The SELECT query applies the custom scalar function fnCalculateDistance to calculate the direct distance between the pick-up and drop-off locations. Les résultats de la requête sont stockés dans la variable d’entrée Python par défaut, InputDataset.The results of the query are stored in the default Python input variable, InputDataset.
    • La variable binaire tipped est utilisée comme étiquette ou colonne de résultat, et le modèle est adapté à l’aide de ces colonnes de caractéristiques : passenger_count, trip_distance, _trip_time_in_secs_et direct_distance.The binary variable tipped is used as the label or outcome column, and the model is fit using these feature columns: passenger_count, trip_distance, trip_time_in_secs, and direct_distance.
    • Le modèle formé est sérialisé et stocké dans la variable Python logitObj.The trained model is serialized and stored in the Python variable logitObj. En ajoutant le mot-clé T-SQL OUTPUT, vous pouvez ajouter la variable en tant que sortie de la procédure stockée.By adding the T-SQL keyword OUTPUT, you can add the variable as an output of the stored procedure. À l’étape suivante, cette variable est utilisée pour insérer le code binaire du modèle dans une table de base de données nyc_taxi_models.In the next step, that variable is used to insert the binary code of the model into a database table nyc_taxi_models. Ce mécanisme facilite le stockage et la réutilisation des modèles.This mechanism makes it easy to store and re-use models.
  2. Exécutez la procédure stockée comme suit pour insérer le modèle formé revoscalepy dans la table nyc_taxi_models.Run the stored procedure as follows to insert the trained revoscalepy model into the table nyc_taxi_models.

    DECLARE @model VARBINARY(MAX);
    EXEC TrainTipPredictionModelRxPy @model OUTPUT;
    INSERT INTO nyc_taxi_models (name, model) VALUES('revoscalepy_model', @model);
    

    Le traitement des données et l’ajustement du modèle peuvent prendre un certain temps.Processing of the data and fitting the model might take a while. Les messages éventuellement redirigés vers le flux stdout de Python sont affichés dans la fenêtre Messages de Management StudioManagement Studio.Messages that would be piped to Python's stdout stream are displayed in the Messages window of Management StudioManagement Studio. Par exemple : For example:

    Message(s) STDOUT provenant du script externe : C:\Program Files\Microsoft SQL Server\MSSQL14. MSSQLSERVER \ PYTHON_SERVICES \lib\site-packages\revoscalepySTDOUT message(s) from external script: C:\Program Files\Microsoft SQL Server\MSSQL14.MSSQLSERVER\PYTHON_SERVICES\lib\site-packages\revoscalepy

  3. Ouvrez la table nyc_taxi_models.Open the table nyc_taxi_models. Vous pouvez voir qu’une nouvelle ligne a été ajoutée, avec le modèle sérialisé dans la colonne model.You can see that one new row has been added, which contains the serialized model in the column model.

    revoscalepy_model 0x8003637265766F7363616c....revoscalepy_model 0x8003637265766F7363616c....

À l’étape suivante, vous allez utiliser le modèle formé pour créer des prédictions.In the next step, you use the trained models to create predictions.

Étape suivanteNext step

Exécuter des prédictions avec un script Python incorporé dans une procédure stockéeRun predictions using Python embedded in a stored procedure

Étape précédentePrevious step

Créer des caractéristiques de données à l’aide de T-SQLCreate data features using T-SQL