• Generating API client from the Swagger JSON file of the service
• Linking in the client as npm module package
• Adding Vue component with javascript code that leverages the generated client to make service consumption API calls

Creating a VueJS App

Setting up the Swagger Generated Javascript Client

Implementing the Login Screen

Implementing the Image Classification Screen

The Final Product

Create a web service for a TensorFlow image classification model in Python

•  Have access to a Python-enabled instance of Machine Learning Server that was properly configured to host web services.
• Authenticate with Machine Learning Server in Python as described in "Connecting to Machine Learning Server."
• Have Tensorflow installed on compute nodes.
• Have a trained TensorFlow image classification model.

1. We first put the trained model on each compute node
2. The below python script loads the model, builds the graph, and decodes image for classification
3. The below python script deploys the image classification model as a service and generates service swagger
4. We can use the swagger json file from previous step to generate clients in many languages. With the generated web service API, developers can easily consume the image classification model in their applications. In another blog, we will talk about how to consume the image classification web service in a JavaScript web application.

REFERENCES

1. Run R Shell
2. Run Python Shell
3. Run Jupyter Notebook
4. Run Onebox Configuration
5. Run R Web Service
6. Run Python Web Service

Prerequisites :

Step 0 :

docker build -f mlserver-dockerfile -t mlserver .

docker images

Run R Shell

docker run -it mlserver R

Run Python Shell :

docker run -it mlserver mlserver-python

Run Jupyter Notebook :

docker run -p 8888:8888 -it mlserver /opt/microsoft/mlserver/9.3.0/runtime/python/bin/jupyter notebook --no-browser --port=8888 --ip=0.0.0.0 --allow-root

Run One-box Configuration :

docker build -f mlserver-onebox-dockerfile -t mlserver-onebox .

docker images

docker run --name mlserver-onebox-container -dit mlserver-onebox

docker logs mlserver-onebox-container

docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' mlserver-onebox-container
'172.17.0.3'

az login --mls --mls-endpoint "https://172.17.0.3:12800" --username "admin" --password "Microsoft@2018"
az ml admin diagnostic run

Run R Web Service :

docker build -f r-manualtransmission-dockerfile -t rmanualtransmission .

docker images

docker run --name rmanualtransmission-container -dit rmanualtransmission

docker logs rmanualtransmission-container

docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' rmanualtransmission-container
'172.17.0.3'

apt-get -y install jq

curl -s --header "Content-Type: application/json" --request POST --data '{"username":"admin","password":"Microsoft@2018"}' https://172.17.0.3:12800/login | jq -r '.access_token'
<access token>

curl -s --header "Content-Type: application/json" --header "Authorization: Bearer <access token>" --request POST --data '{"hp":120,"wt":2.8}' https://172.17.0.3:12800/api/ManualTransmissionService/1.0.0
{"success":true,"errorMessage":"","outputParameters":{"answer":0.64181252840938208},"outputFiles":{},"consoleOutput":"","changedFiles":[]}

curl -s --header "Authorization: Bearer <access token>" --request GET https://172.17.0.3:12800/api/ManualTransmissionService/1.0.0/swagger.json -o swagger.json

Run Python Web Service :

docker build -f py-manualtransmission-dockerfile -t pymanualtransmission .

docker images

docker run --name pymanualtransmission-container -dit pymanualtransmission

docker logs pymanualtransmission-container

docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' pymanualtransmission-container
'172.17.0.3'

apt-get -y install jq

curl -s --header "Content-Type: application/json" --request POST --data '{"username":"admin","password":"Microsoft@2018"}' https://172.17.0.3:12800/login | jq -r '.access_token'
<access token>

curl -s --header "Content-Type: application/json" --header "Authorization: Bearer <access token>" --request POST --data '{"hp":120,"wt":2.8}' https://172.17.0.3:12800/api/ManualTransmissionService/1.0.0 
{"success":true,"errorMessage":"","outputParameters":{"answer":0.64181252840938208},"outputFiles":{},"consoleOutput":"","changedFiles":[]}

curl -s --header "Authorization: Bearer <access token>" --request GET https://172.17.0.3:12800/api/ManualTransmissionService/1.0.0/swagger.json -o swagger.json

Run on Kubernetes :

REFERENCES :

Environment Setup

1. To get revoscalepy, download and install Microsoft's Python Client. Documentation Page or Direct Download Link (for Windows). 
2. After downloading, open powershell as an administrator and navigate to the download folder.
3. Start the installation with this command (feel free to customize the install folder):
4. .\Install-PyForMLS.ps1 -InstallFolder "C:\Program Files\MicrosoftPythonClient"
5. Be patient while the installation can take a little while. Once installed navigate to the new path you installed in.
6. Let's make an empty folder and open Jupyter Notebooks:
7. mkdir JupyterNotebooks; cd JupyterNotebooks; ..\Scripts\jupyter-notebook
8. Create a new notebook with Python 3 interpreter:
9. 
10. To test if everything is setup, import revoscalepy in the first cell and execute.
11. 
12. If there are no error messages you are ready to move forward.

Database Setup

1. Create a database

import pyodbc

# creating a new db to load Iris sample in
new_db_name = "MLRemoteExec"
connection_string = "Driver=SQL Server;Server=localhost\MSSQLSERVER2017;Database={0};Trusted_Connection=Yes;" 
                        # you can also swap Trusted_Connection for UID={your username};PWD={your password}
cnxn = pyodbc.connect(connection_string.format("master"), autocommit=True)
cnxn.cursor().execute("IF EXISTS(SELECT * FROM sys.databases WHERE [name] = '{0}') DROP DATABASE {0}".format(new_db_name))
cnxn.cursor().execute("CREATE DATABASE " + new_db_name)
cnxn.close()

print("Database created")

2. Import Iris sample from SkLearn

from sklearn import datasets
import pandas as pd

# SkLearn has the Iris sample dataset built in to the package
iris = datasets.load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)

3. Use RecoscalePy APIs to create a table and load the Iris data

from revoscalepy import RxSqlServerData, rx_data_step

# Example of using RX APIs to load data into SQL table. You can also do this with pyodbc
table_ref = RxSqlServerData(connection_string=connection_string.format(new_db_name), table="Iris")
rx_data_step(input_data = df, output_file = table_ref, overwrite = True)

print("New Table Created: Iris")
print("Sklearn Iris sample loaded into Iris table")

Define Function to Send to SQL Server

def send_this_func_to_sql():
    from revoscalepy import RxSqlServerData, rx_import
    from pandas.tools.plotting import scatter_matrix
    import matplotlib.pyplot as plt
    import io
    
    # remember the scope of the variables in this func are within our SQL Server Python Runtime
    connection_string = "Driver=SQL Server;Server=localhost\MSSQLSERVER2017;Database=MLRemoteExec;Trusted_Connection=Yes;"
    
    # specify a query and load into pandas dataframe df
    sql_query = RxSqlServerData(connection_string=connection_string, sql_query = "select * from Iris")
    df = rx_import(sql_query)
    
    scatter_matrix(df)
    
    # return bytestream of image created by scatter_matrix
    buf = io.BytesIO()
    plt.savefig(buf, format="png")
    buf.seek(0)
    
    return buf.getvalue()

Send execution to SQL

from IPython import display
import matplotlib.pyplot as plt 
from revoscalepy import RxInSqlServer, rx_exec

# create a remote compute context with connection to SQL Server
sql_compute_context = RxInSqlServer(connection_string=connection_string.format(new_db_name))

# use rx_exec to send the function execution to SQL Server
image = rx_exec(send_this_func_to_sql, compute_context=sql_compute_context)[0]

# only an image was returned to my jupyter client. All data remained secure and was manipulated in my db.
display.Image(data=image)

Learn More

• How to Install SQL Server Machine Learning Services: https://aka.ms/InstallMLServices
• How to Enable SQL Server Machine Learning Services: https://aka.ms/EnableMLServices
• Basics of R and Python Execution in SQL: https://aka.ms/ExecuteMLServices

1. Use the pretrained model (ResNet-18) as a featurizer to transform the images into features
2. Train a multi-class classifier on the features of training images. A 3-layer neural network from MicrosoftML package is used here.
3. The Trained model is used to predict the class probabilities of each image.
4. Calculate the distance (e.g., L1, L2, Cosine) between the predicted class probabilities of image pairs.
5. Rank order image pairs based on the distance: the smaller the distance, the more similar of the image pairs.

This script will download all images listed in "c:\Solutions\ImageSimilarity\fashion_texture_urls.tsv"
onto your machine, upload them to SQL and execute the end-to-end workflow to train an image similarity model.
This portion of the script will take about 6 minutes to complete.

Please respond YES to continue

Create a web service for Keras models in Python

•  Have access to a Python-enabled instance of Machine Learning Server that was properly configured to host web services.
• Authenticate with Machine Learning Server in Python as described in "Connecting to Machine Learning Server."
• Have Keras, Tensorflow, and keras-pickle-wrapper installed.
• Have a trained Keras model.

For fast web service connections in Python, you can create sessions and load dependencies in advance by using dedicated session pool.

Create a web service for Keras models in R

• Have access to a Machine Learning Server instance that was properly configured to host web services.
• Authenticate with Machine Learning Server using the remoteLogin() or remoteLoginAAD() functions in the mrsdeploy package.
• Install Keras and Tensorflow backend described here.
• Have a trained Keras model.

REFERENCES

How to Execute R/Python Code in SQL Server

Basics

1. Open up SQL Server Management Studio and make a connection to your server.
2. Open a new query.
3. Paste this basic example:
4. EXEC sp_execute_external_script @language = N'Python', @script = N'print(3+4)'
5. Sp_execute_external_script is a special system stored procedure that enables R and Python execution in SQL Server.
6. There is a "language" parameter that allows us to choose between Python and R.
7. There is a "script" parameter where we can paste R or Python code.

Parameter introduction

1. Machine Learning Services provides more natural communications between SQL and R or Python with an input data parameter that accept any SQL query. The input parameter name is called "input_data_1".
2. You can see in the python code that there are default variables defined to pass data between Python and SQL. The default variable names are "OutputDataSet" and "InputDataSet"
3. You can change these default names like this example:
4. EXEC sp_execute_external_script  @language =N'Python', @script = N' MyOutput = MyInput; ', @input_data_1_name = N'MyInput', @input_data_1 =N'SELECT 1 AS foo', @output_data_1_name =N'MyOutput';
5. As you executed these examples, you might have noticed that they each return a result with "(No column name)"? You can specify a name for the columns that are returned by adding "WITH RESULT SETS" to the end of the statement:
6. EXEC sp_execute_external_script  @language =N'Python', @script=N' MyOutput = MyInput; ', @input_data_1_name = N'MyInput', @input_data_1 =N' SELECT 1 AS foo, 2 AS bar ', @output_data_1_name =N'MyOutput' WITH RESULT SETS ((MyColName int, MyColName2 int));
7. WITH RESULT SETS is a comma separated list of column names and their datatypes.

Input/Output DataTypes

1. Your input SQL SELECT statement passes a "Dataframe" to python relying on the Python Pandas package.
2. Your output from Python back to SQL also needs to be in a Pandas Dataframe object. If you need to convert scalar values into a dataframe here is an example:
3. EXEC sp_execute_external_script  @language =N'Python', @script=N' import pandas as pd c = 1/2 d = 1*2 s = pd.Series([c,d]) df = pd.DataFrame(s) OutputDataSet = df '
4. Variables c and d are both scalar values, which you can add to a pandas Series if you like, and then convert them to a pandas dataframe.
5. This one shows a little bit more complicated example, go read up on the python pandas package documentation for more details and examples.
6. EXEC sp_execute_external_script  @language =N'Python', @script=N' import pandas as pd s = {"col1": [1, 2], "col2": [3, 4]} df = pd.DataFrame(s) OutputDataSet = df '