Python e R in SQL in remoto

Introduzione

Sapevi che puoi eseguire codice R e Python in remoto in SQL Server da Jupyter Notebooks o da qualsiasi IDE? Machine Learning Services in SQL Server elimina la necessità di spostare i dati. Invece di trasferire grandi quantità di dati sensibili sulla rete o perdere accuratezza nell'addestramento ML con file CSV di esempio, puoi eseguire il tuo codice R/Python direttamente nel database. Puoi lavorare in Jupyter Notebooks, RStudio, PyCharm, VSCode, Visual Studio, dove preferisci, e poi inviare l'esecuzione delle funzioni a SQL Server portando l'intelligenza dove risiedono i tuoi dati.

Questo tutorial mostra un esempio di come inviare il tuo codice Python da Jupyter Notebooks per l'esecuzione all'interno di SQL Server. Gli stessi principi valgono per R e per qualsiasi altro IDE. Se preferisci imparare con i video, questo tutorial è pubblicato anche su YouTube qui:

https://youtu.be/D5erljpJDjE

Prerequisiti per la configurazione dell'ambiente

1. Installa ML Services su SQL Server

Perché R o Python possano essere eseguiti all'interno di SQL, è necessario che la funzionalità Machine Learning Services sia installata e configurata. Vedi questa guida operativa.

2. Installa RevoscalePy tramite il client Python di Microsoft

Per inviare l'esecuzione di Python a SQL da Jupyter Notebooks, devi usare il pacchetto RevoscalePy di Microsoft. Per ottenere RevoscalePy, scarica e installa il client Python di ML Services di Microsoft. Pagina di documentazione oppure link per il download diretto (per Windows).

Dopo il download, apri PowerShell come amministratore e vai alla cartella di download. Avvia l'installazione con questo comando (puoi personalizzare la cartella di installazione): .\\Install-PyForMLS.ps1 -InstallFolder "C:\\Program Files\\MicrosoftPythonClient"

Abbi pazienza: l'installazione può richiedere un po' di tempo. Una volta installato, vai nel nuovo percorso in cui hai effettuato l'installazione. Creiamo una cartella vuota e apriamo Jupyter Notebooks: mkdir JupyterNotebooks; cd JupyterNotebooks; ..\\Scripts\\jupyter-notebook

Crea un nuovo notebook con l'interprete Python 3:

Per verificare che tutto sia configurato, importa revoscalepy nella prima cella ed esegui. Se non compaiono messaggi di errore, sei pronto per procedere.

Configurazione del database (necessaria solo per questo tutorial)

Per il resto del tutorial, puoi clonare questo Jupyter Notebook da GitHub se non vuoi copiare e incollare tutto il codice. Questa configurazione del database è un passaggio una tantum per assicurarti di avere gli stessi dati di questo tutorial. Non devi eseguire questi passaggi di configurazione se usi i tuoi dati.

1. Crea un database

Modifica la stringa di connessione per il tuo server e usa pyodbc per creare un nuovo 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;"
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")Offerto da

2. Importa il campione Iris da SkLearn

Iris è un dataset molto usato nei tutorial introduttivi di data science. È incluso di default nel pacchetto sklearn.

from sklearn import datasets
import pandas as pd

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

3. Usa le API RecoscalePy per creare una tabella e caricare i dati Iris

(Puoi farlo anche con pyodbc, sqlalchemy o altri pacchetti)

 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")Offerto da

Definisci una funzione da inviare a SQL Server

Scrivi qualsiasi codice Python vuoi eseguire in SQL. In questo esempio, creiamo una scatter matrix sul dataset Iris e restituiamo solo il flusso di byte del file .png a Jupyter Notebooks per il rendering sul client.

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()Offerto da

Invia l'esecuzione a SQL

Ora che abbiamo finalmente configurato tutto, guarda quanto è facile inviare davvero l'esecuzione remota! Per prima cosa, import revoscalepy. Crea un sql_compute_context e poi invia l'esecuzione di qualsiasi funzione in modo trasparente a SQL Server con RxExec. Nessun dato grezzo è stato trasferito da SQL al Jupyter Notebook. Tutto il calcolo è avvenuto nel database e solo il file immagine è stato restituito per essere visualizzato.

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)Offerto da

Anche se questo esempio è banale con il dataset Iris, immagina le capacità aggiuntive di scalabilità, prestazioni e sicurezza che ora hai sbloccato. Puoi usare gli ultimi pacchetti open source R/Python per creare applicazioni di Deep Learning e AI su grandi quantità di dati in SQL Server. Offriamo anche algoritmi all'avanguardia e ad alte prestazioni nelle API RevoScaleR e RevoScalePy di Microsoft. Usarle insieme alle innovazioni più recenti del mondo open source ti permette di portare una selezione, prestazioni e scalabilità senza pari nelle tue applicazioni.

Per saperne di più

Dai un'occhiata al tutorial di DataCamp su come eseguire Python/R in SQL.

Consulta la documentazione di SQL Machine Learning Services per scoprire come distribuire facilmente il tuo codice R/Python con stored procedure SQL, rendendolo accessibile nei processi ETL o a qualsiasi applicazione. Addestra e archivia modelli di machine learning nel tuo database portando l'intelligenza dove risiedono i dati.

Esecuzione di base di R e Python in SQL Server: https://aka.ms/BasicMLServicesExecution

Configura Machine Learning Services in SQL Server: https://aka.ms/SetupMLServices

Soluzioni tutorial end-to-end su GitHub: https://microsoft.github.io/sql-ml-tutorials/

Altri tutorial su YouTube:

• Come installare SQL Server Machine Learning Services: https://aka.ms/InstallMLServices
• Come abilitare SQL Server Machine Learning Services: https://aka.ms/EnableMLServices
• Nozioni di base sull'esecuzione di R e Python in SQL: https://aka.ms/ExecuteMLServices

Se ti interessa approfondire, dai un'occhiata ai corsi introduttivi di DataCamp.

• Introduzione a Python per la Data Science
• Introduzione a R
• Introduzione a SQL per la Data Science