Partilhar via

Use Python com revoscalepy para criar um modelo que corra remotamente no SQL Server

Aplica-se a: SQL Server 2017 (14.x) e versões posteriores

A biblioteca Python revoscalepy da Microsoft fornece algoritmos de ciência de dados para exploração, visualização, transformações e análise de dados. Esta biblioteca tem importância estratégica em cenários de integração de Python no SQL Server. Num servidor multi-core, as funções revoscalepy podem correr em paralelo. Numa arquitetura distribuída com um servidor central e estações de trabalho cliente (computadores físicos separados, todos com a mesma biblioteca revoscalepy ), pode escrever código Python que começa localmente, mas depois transfere a execução para uma instância remota de SQL Server onde residem dados.

Pode encontrar revoscalepy nos seguintes produtos e distribuições Microsoft:

Este exercício demonstra como criar um modelo de regressão linear baseado no rx_lin_mod, um dos algoritmos da revoscalpy que aceita o contexto computado como entrada. O código que irá executar neste exercício desloca a execução do código de um ambiente de computação local para um ambiente remoto, possibilitado por funções revoscalepy que permitem um contexto de computação remota.

Ao completar este tutorial, aprenderá como:

  • Usar revoscalepy para criar um modelo linear
  • Deslocar operações do contexto de computação local para o remoto

Pré-requisitos

Os dados de exemplo utilizados neste exercício são a base de dados flightdata .

Precisas de um IDE para executar o código de exemplo neste artigo, e o IDE deve estar ligado ao executável em Python.

Para praticar uma mudança de contexto computacional, precisas de uma estação de trabalho local e de uma instância de motor de base de dados SQL Server com Serviços de Aprendizagem Automática e Python ativados.

Sugestão

Se não tiver dois computadores, pode simular um contexto de computação remota num computador físico instalando aplicações relevantes. Primeiro, uma instalação dos Serviços de Aprendizagem Automática do SQL Server funciona como a instância "remota". Em segundo lugar, uma instalação das bibliotecas cliente Python funciona como cliente. Terá duas cópias da mesma distribuição Python e das bibliotecas Microsoft Python na mesma máquina. Terá de acompanhar os caminhos dos ficheiros e qual cópia do Python.exe está a usar para completar o exercício com sucesso.

Contextos de computação remota e "revoscalepy"

Este exemplo demonstra o processo de criação de um modelo Python num contexto de computação remota, que permite trabalhar a partir de um cliente, mas escolher um ambiente remoto, como SQL Server ou Spark, onde as operações são efetivamente realizadas. O objetivo do contexto de computação remota é levar a computação para onde os dados residem.

Para executar código Python no SQL Server é necessário o pacote revoscalepy . Este é um pacote especial em Python fornecido pela Microsoft, semelhante ao pacote RevoScaleR para a linguagem R. O pacote revoscalepy suporta a criação de contextos de computação e fornece a infraestrutura para passar dados e modelos entre uma estação de trabalho local e um servidor remoto. A função revoscalepy que suporta a execução de código na base de dados é o RxInSqlServer.

Nesta lição, utiliza dados no SQL Server para treinar um modelo linear baseado em rx_lin_mod, uma função do revoscalepy que suporta regressão sobre conjuntos de dados muito grandes.

Esta lição também demonstra o básico de como configurar e depois usar um contexto de computação SQL Server em Python.

Execute o código de exemplo

Depois de preparares a base de dados e guardares os dados para treino numa tabela, abre um ambiente de desenvolvimento em Python e executa o exemplo de código.

O código executa os seguintes passos:

  1. Importa as bibliotecas e funções necessárias.
  2. Cria uma ligação ao SQL Server. Cria objetos fonte de dados para trabalhar com os dados.
  3. Modifica os dados usando transformações para que possam ser usados pelo algoritmo de regressão logística.
  4. Chama rx_lin_mod e define a fórmula usada para ajustar o modelo.
  5. Gera um conjunto de previsões com base nos dados originais.
  6. Cria um resumo com base nos valores previstos.

Todas as operações são realizadas utilizando uma instância do SQL Server como contexto de computação.

Observação

Para uma demonstração deste exemplo a partir da linha de comandos, veja este vídeo: SQL Server 2017 Advanced Analytics com Python

Código de exemplo

from revoscalepy import RxComputeContext, RxInSqlServer, RxSqlServerData
from revoscalepy import rx_lin_mod, rx_predict, rx_summary
from revoscalepy import RxOptions, rx_import

import os

def test_linmod_sql():
    sql_server = os.getenv('PYTEST_SQL_SERVER', '.')
    
    sql_connection_string = 'Driver=SQL Server;Server=' + sqlServer + ';Database=sqlpy;Trusted_Connection=True;'
    print("connectionString={0!s}".format(sql_connection_string))

    data_source = RxSqlServerData(
        sql_query = "select top 10 * from airlinedemosmall",
        connection_string = sql_connection_string,

        column_info = {
            "ArrDelay" : { "type" : "integer" },
            "DayOfWeek" : {
                "type" : "factor",
                "levels" : [ "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" ]
            }
        })

    sql_compute_context = RxInSqlServer(
        connection_string = sql_connection_string,
        num_tasks = 4,
        auto_cleanup = False
        )

    #
    # Run linmod locally
    #
    linmod_local = rx_lin_mod("ArrDelay ~ DayOfWeek", data = data_source)
    #
    # Run linmod remotely
    #
    linmod = rx_lin_mod("ArrDelay ~ DayOfWeek", data = data_source, compute_context = sql_compute_context)

    # Predict results
    # 
    predict = rx_predict(linmod, data = rx_import(input_data = data_source))
    summary = rx_summary("ArrDelay ~ DayOfWeek", data = data_source, compute_context = sql_compute_context)

Definir uma fonte de dados vs. definir um contexto computacional

Uma fonte de dados é diferente de um contexto computacional. A fonte de dados define os dados usados no seu código. O contexto de computação define onde o código será executado. No entanto, usam algumas das mesmas informações:

  • Variáveis Python, como sql_query e sql_connection_string, definem a origem dos dados.

    Passe estas variáveis ao construtor RxSqlServerData para implementar o objeto fonte de dados chamado data_source.

  • Cria-se um objeto de contexto de computação usando o construtor RxInSqlServer . O objeto de contexto de computação resultante é chamado sql_cc.

    Este exemplo reutiliza a mesma cadeia de ligação que usaste na fonte de dados, assumindo que os dados estão na mesma instância do SQL Server que vais usar como contexto de computação.

    No entanto, a fonte de dados e o contexto de computação podem estar em servidores diferentes.

Alteração de contextos computacionais

Depois de definir um contexto de computação, deve definir o contexto de computação ativo.

Por defeito, a maioria das operações é executada localmente, o que significa que, se não especificar um contexto de computação diferente, os dados serão recolhidos da fonte de dados e o código será executado no seu ambiente Python atual.

Existem duas formas de definir o contexto de computação ativa:

  • Como argumento de um método ou função
  • Chamando rx_set_computecontext

Defina o contexto computado como argumento de um método ou função

Neste exemplo, defines o contexto de cálculo usando um argumento da função rx individual.

linmod = rx_lin_mod_ex("ArrDelay ~ DayOfWeek", data = data, compute_context = sql_compute_context)

Este contexto de computação é reutilizado na chamada para rxsummary:

summary = rx_summary("ArrDelay ~ DayOfWeek", data = data_source, compute_context = sql_compute_context)

Defina explicitamente um contexto de computação usando rx_set_compute_context

A função rx_set_compute_context permite alternar entre contextos de computação que já foram definidos.

Depois de definir o contexto de computação ativa, ele permanece ativo até o alterar.

Utilização de processamento paralelo e streaming

Quando defines o contexto de computação, também podes definir parâmetros que controlem como os dados são tratados pelo contexto de computação. Estes parâmetros diferem consoante o tipo de fonte de dados.

Para contextos de computação SQL Server, pode definir o tamanho do lote ou fornecer dicas sobre o grau de paralelismo a usar nas tarefas em execução.

  • A amostra foi executada num computador com quatro processadores, pelo que o num_tasks parâmetro é definido para 4 para permitir o máximo uso dos recursos.
  • Se definir este valor para 0, o SQL Server usa o padrão, que é executar o maior número possível de tarefas em paralelo, sob as definições atuais do MAXDOP para o servidor. No entanto, o número exato de tarefas que podem ser atribuídas depende de muitos outros fatores, como as definições do servidor e outros trabalhos em execução.

Próximos passos

Estes exemplos e tutoriais adicionais de Python demonstram cenários de ponta a ponta usando fontes de dados mais complexas, bem como o uso de contextos de computação remota.

  • Last updated on