Sample Steps to be followed for Model deployment

• Check for the feasibility of the process using the table reference above. The approach works very well for prediction and clustering algorithms. 
• Create and train the model.

Steps 4,5 and 6 outline the steps using R

CREATE PROCEDURE procedure name (@trained_model varbinary(max) OUTPUT)
 AS
 BEGIN
EXECUTE sp_execute_external_script 
@language = N’R’ 
, @script = N’ 
require(“RevoScaleR”); 
#Create a model and train it using the training data set
< model > <- <algorithm>( <independentvariable1>  
 <independentvariable2> + <independentvariable4> + <independentvariable5> + 
 <independentvariablen>, data = <train dataset> 
#Before saving the model to the DB table, we need to serialize it 
<trainedmodel> <- as.raw(serialize(<model>, connection=NULL));’ 
,@input_data_1 = N’select “dependent variable”, “independentvariable1”, 
“independentvariable2”,“independentvariable3”, “independentvariable4”, 
“independentvariable5”, …,”independentvariablen” from  where 
 <condition>[optional] 
, @input_data_1_name = N’’ 
, @params = N’@ <trained_model> varbinary(max) OUTPUT’
,  <@trained_model> = @ OUTPUT; 
END; 
GO

Deploy a model, you need to store the model in a hosting environment (like a database) and implement a prediction function that uses the model to predict. That function can then be called from individual applications.

 Steps outlined below:

Store the model in the database

/*create table to store the model 
CREATE TABLE<table name>
(
model_name <datatype> not null default(‘default model’) primary key,
model varbinary(max) not null ); /*Call the stored procedure, generate the model, and save it to the table we created DECLARE @model VARBINARY(MAX); EXEC  <procedure name> @model OUTPUT; INSERT INTO  ( model_name, model) VALUES(‘’, <@modelname>););

Create a stored procedure that predicts using our model

CREATE PROCEDURE  <procedure name_predict_model>  
(@model VARCHAR(100),@q NVARCHAR(MAX)) 
AS 
BEGIN 
DECLARE @ <modelto work on> VARBINARY(MAX) = (SELECT model FROM  <table name> 
"created in step 4 above" WHERE model_name = @model ; 
EXECUTE sp_execute_external_script 
@language = N’R’ 
, @script = N’ 
require(“RevoScaleR”);AS 
#The InputDataSet contains the new data passed to this stored proc.  
<input dataset> = InputDataSet;We will use this data to predict.

#Convert types to factors if required 
#Before using the model to predict, we need to unserialize it 
"model_unserialize" = unserialize(); 
#Call prediction function 
<predictions> = rxPredict(<model_unserialize>, <input dataset>’ 
, @input_data_1 = @q 
, @output_data_1_name = N’<model name>’ 
, @params = N’@<modelto work on> varbinary(max)’ 
, @<modelto work on> = @<modelto work on> 
WITH RESULT SETS ((“<name_predicted model name>” <data type>)); 
END; 
GO

Predict for new data to Execute the stored procedure

/*Execute the prediction stored procedure created in step 5 above 
 and pass the modelname and a query string with a set of features 
 we want to use to perform prediction 
EXEC dbo.<procedure name_predict_model> @model = ‘<model name’,
@q =’SELECT statement for the input data values’; GO

Steps 4,5 and 6 outline the steps using Python

-Stored procedure that trains and generates a Python model
CREATE PROCEDURE <procedure name>(@trained_model varbinary(max) OUTPUT) 
AS 
BEGIN 
EXECUTE sp_execute_external_script 
@language = N’Python’ 
, @script = N’ 
from sklearn.linear_model import LinearRegression 
import pickle 
<dataframe> = <training data> 
# Get all the columns from the dataframe. 
columns = <dataframe>columns.tolist() 
# Store the variable well be predicting on. 
target = <dependent variable>

# Initialize the model class. 
lin_model = LinearRegression() 
# Fit the model to the training data.
lin_model.fit(dataframe[columns], <dataframe>[target]) 
#Before saving the model to the DB table, we need to convert it to a binary object 
<trained_model> = pickle.dumps(lin_model)‘ 
, @input_data_1 = N’select “”, “independentvariable1”,  
<independentvariable2>, <independentvariable3>, <independentvariable4>, 
<independentvariable5&gt,…, <independentvariablen> from 
<dataset> where <condition>[optional] 
, @input_data_1_name = N’<training data>’ 
, @params = N’@trained_model varbinary(max) OUTPUT’ 
, @trained_model = @trained_model OUTPUT; 
END; 
GO

deploy a model, you need to store the model in a hosting environment (like a database) and implement a prediction function that uses the model to predict. That function can then be called from individual applications.

Steps outlined below:

Store the model in the database

/*create table to store the model CREATE TABLE<table name> ( model_name  not null default(‘default model’) primary key, model varbinary(max) not null );
/*Call the stored procedure, generate the model, and save it to the table we created DECLARE @model VARBINARY(MAX); EXEC <procedure name> @model OUTPUT; INSERT INTO <table name> (model_name, model) VALUES(‘model name’,< @modelname>);

Create a stored procedure that predicts using our model-machine learning

CREATE PROCEDURE <procedure name_predict_model> (@model varchar(100)) 
AS 
BEGIN 
DECLARE @ varbinary(max) = (select model 
\from <table name>[created in step 4 above] where model_name = @model); 
EXEC sp_execute_external_script 
@language = N’Python’, 
@script = N’ 
# Import the scikit-learn function to compute error. 
from sklearn.metrics import mean_squared_error 
import pickle 
import pandas as pd 
<model_unserialize> = pickle.loads()
<dataframegt; = <InputDataSet> 
# Get all the columns from the dataframe. 
columns = <dataframe>.columns.tolist() 
# variable we will be predicting on. 
target = “Dependent Variable” 
# Generate our predictions for the test set. 
lin_predictions = .predict([columns]) 
print(lin_predictions)

# Compute error between our test predictions and the actual values. 
lin_mse = mean_squared_error(lin_predictions, "dataframe"[target]) 
#print(lin_mse) 
predictions_ = pd.DataFrame(lin_predictions) 
OutputDataSet = pd.concat([predictions_<dataframe>, <dataframe> 
[<Dependent Variable>], <dataframe>[<IndependentVariable1>], <dataframe> 
[<IndependentVariable2>], <dataframe>[<IndependentVariable3>], <dataframe> 
[<IndependentVariable4>], <dataframe>[<IndependentVariable5>], <dataframe> 
[<IndependentVariablen>]], axis=1) 
, @input_data_1 = N’Select "<Dependent Variable&gt";, “<IndependentVariable1” >,”
"<IndependentVariable2”>, “<IndependentVariable3>”, “<IndependentVariable4>”, 
“<IndependentVariable5>”, “<IndependentVariablen>” from InputDataSet 
 where [optional]‘ 
, @input_data_1_name = N’InputDataSet’ 
,@params = N’@“<modelto work on> varbinary(max)‘ 
, <@modelto work on> = @modelto work on 
with result sets ((““&ltDependent Variable_Predicted>” 

float, ““&ltDependent Variable>” float,  
“&ltIndependentVariable1>” 
float,“&ltIndependentVariable2>” float,“&ltIndependentVariable3>” 
float,”“&ltIndependentVariable4>” float,”“&ltIndependentVariable5>” float, 
 ““&ltIndependentVariablen>” float)); 
END; 
GO

Predict for new data to Execute the stored procedure

/*Execute the prediction stored procedure created in step 5 above and pass
 the modelname here we do not pass a query string as we handle the inputs  within the stored procedure(compare it with the query parameter in R models  above just two means to write the stored procedure) EXEC dbo.<procedure name_predict_model&amp>@model = ‘<model name’, GO