Problemas conhecidos para Python e R nos Serviços de Aprendizagem Automática do SQL Server

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

Este artigo descreve problemas ou limitações conhecidos com os componentes Python e R fornecidos nos Serviços de Aprendizagem Automática do SQL Server e nos Serviços R do SQL Server 2016.

Problemas de instalação e configuração

Para uma descrição dos processos relacionados com a configuração e configuração inicial, consulte Instalar Serviços de Aprendizagem Automática SQL Server. Contém informações sobre atualizações, instalação lado a lado e instalação de novos componentes em R ou Python.

Resultados inconsistentes nos cálculos MKL devido à falta de variável de ambiente

Aplica-se a: R_SERVER binários 9.0, 9.1, 9.2 ou 9.3.

R_SERVER utiliza a Intel Math Kernel Library (MKL). Para cálculos envolvendo MKL, podem ocorrer resultados inconsistentes se o seu sistema não tiver uma variável de ambiente.

Defina a variável 'MKL_CBWR'=AUTO ambiente para garantir a reprodutibilidade numérica condicional em R_SERVER. Para mais informações, consulte Introdução à Reprodutibilidade Numérica Condicional (CNR).

Solução

1. No Painel de Controle, selecione Sistema e Segurança>Sistema>Configurações Avançadas do Sistema>Variáveis de Ambiente.

2. Crie uma nova variável User ou System.

   • Defina a variável para MKL_CBWR.
   • Defina o valor para AUTO.

3. Reinicia R_SERVER. No SQL Server, pode reiniciar o serviço Launchpad do SQL Server.

Erro de tempo de execução do script R (regressão SQL Server 2017 CU 5 - CU 7)

Para o SQL Server 2017 (14.x), nas atualizações acumuladas 5 a 7, há uma regressão no ficheiro rlauncher.config onde o caminho do diretório temporário inclui um espaço. Esta regressão é corrigida no CU 8.

O erro que verá ao executar o script R inclui as seguintes mensagens:

Incapaz de comunicar com o ambiente de execução do script 'R'. Por favor, verifique os requisitos do runtime 'R'.

Mensagem(ões) STDERR a partir do script externo:

Erro fatal: não é possível criar 'R_TempDir'

Solução

Aplique o CU 8 quando estiver disponível. Alternativamente, pode recriar rlauncher.config executando registerrext com as opções de desinstalação/instalação num prompt de comandos elevado.

<SQLInstancePath>\R_SERVICES\library\RevoScaleR\rxLibs\x64\RegisterRExt.exe /uninstall /sqlbinnpath:<SQLInstanceBinnPath> /userpoolsize:0 /instance:<SQLInstanceName>

<SQLInstancePath>\R_SERVICES\library\RevoScaleR\rxLibs\x64\RegisterRExt.exe /install /sqlbinnpath:<SQLInstanceBinnPath> /userpoolsize:0 /instance:<SQLInstanceName>

O exemplo seguinte mostra os comandos com a instância padrão "MSSQL14. MSSQLSERVER" instalado em C:\Program Files\Microsoft SQL Server\:

"C:\Program Files\Microsoft SQL Server\MSSQL14.MSSQLSERVER\R_SERVICES\library\RevoScaleR\rxLibs\x64\RegisterRext.exe" /uninstall /sqlbinnpath:"C:\Program Files\Microsoft SQL Server\MSSQL14.MSSQLSERVER\MSSQL\Binn" /userpoolsize:0 /instance:MSSQLSERVER

"C:\Program Files\Microsoft SQL Server\MSSQL14.MSSQLSERVER\R_SERVICES\library\RevoScaleR\rxLibs\x64\RegisterRext.exe" /install /sqlbinnpath:"C:\Program Files\Microsoft SQL Server\MSSQL14.MSSQLSERVER\MSSQL\Binn" /userpoolsize:0 /instance:MSSQLSERVER

Não é possível instalar funcionalidades de aprendizagem automática do SQL Server num controlador de domínio

Se tentar instalar SQL Server 2016 (13.x) R Services ou SQL Server Machine Learning Services num controlador de domínio, a configuração falha, com estes erros:

Ocorreu um erro durante o processo de configuração da funcionalidade

Não é possível encontrar grupo com identidade

Código de erro do componente: 0x80131509

A falha ocorre porque, num controlador de domínio, o serviço não consegue criar as 20 contas locais necessárias para executar machine learning. Em geral, não recomendamos instalar SQL Server num controlador de domínio. Para mais informações, consulte o boletim de apoio 2032911.

Instale a versão mais recente do serviço para garantir compatibilidade com o Microsoft R Client

Se instalar a versão mais recente do Microsoft R Client e usá-la para executar o R no SQL Server num contexto de computação remota, pode receber um erro como o seguinte:

Está a executar a versão 9.x.x do Microsoft R Client no seu computador, que é incompatível com a versão 8.x.x do Microsoft R Server. Descarregue e instale uma versão compatível.

O SQL Server 2016 (13.x) exige que as bibliotecas R no cliente correspondam exatamente às bibliotecas R do servidor. A restrição foi removida para lançamentos posteriores ao R Server 9.0.1. No entanto, se encontrar este erro, verifique a versão das bibliotecas R usada pelo seu cliente e pelo servidor e, se necessário, atualize o cliente para corresponder à versão do servidor.

A versão do R instalada com os Serviços SQL Server R é atualizada sempre que uma versão de serviço SQL Server é instalada. Para garantir que tenha sempre as versões mais atualizadas dos componentes R, certifique-se de instalar todas as atualizações de serviço.

Pode receber uma mensagem de erro ao executar o R Server 8.0.3 no SQL Server 2016: You are running version 9.0.0 of Microsoft R client on your computer, which is incompatible with the Microsoft R server version 8.0.3. Download and install a compatible version. A compatibilidade com o Microsoft R Client 9.0.0 no SQL Server 2016 foi garantida nas seguintes atualizações:

• SQL Server 2016 SP1 MDS GDR
• SQL Server 2016 RTM MDS GDR
• SQL Server 2016 RTM COD MDS GDR

Para evitar problemas com os pacotes R, pode também atualizar a versão das bibliotecas R instaladas no servidor, alterando o seu acordo de manutenção para usar a política Modern Lifecycle Support, conforme descrito na secção seguinte. Quando o fazes, a versão do R instalada com o SQL Server é atualizada no mesmo calendário usado para as atualizações do Machine Learning Server (anteriormente Microsoft R Server).

Aplica-se a: SQL Server 2016 (13.x) R Services, com R Server versão 9.0.0 ou anterior

Componentes R em falta na configuração do SQL Server 2017 CU 3

Um número limitado de máquinas virtuais Azure foi provisionado sem os ficheiros de instalação R que deveriam ser incluídos no SQL Server. A questão aplica-se às máquinas virtuais provisionadas no período de 2018-01-05 a 2018-01-23. Este problema pode também afetar instalações locais, se aplicou a atualização CU 3 para o SQL Server 2017 (14.x) durante o período de 2018-01-05 a 2018-01-23.

Foi fornecida uma versão de serviço que inclui a versão correta dos ficheiros de instalação do R.

• Pacote de Atualizações Cumulativas 3 para SQL Server 2017 KB4052987.

Para instalar os componentes e reparar o SQL Server 2017 (14.x) CU 3, deve desinstalar o CU 3 e reinstalar a versão atualizada:

1. Descarregue o ficheiro de instalação atualizado do CU 3, que inclui os instaladores do R.
2. Desinstalar o CU 3. No Painel de Controlo, procure por Desinstalar uma atualização e depois selecione "Hotfix 3015 for SQL Server 2017 (KB4052987) (64-bit)". Proceda com os passos de desinstalar.
3. Reinstale a atualização CU 3 clicando duas vezes na atualização para KB4052987 que descarregou: SQLServer2017-KB4052987-x64.exe. Siga as instruções de instalação.

Não é possível instalar componentes Python em instalações offline do SQL Server 2017 ou versões posteriores

Se instalar uma versão pré-lançamento do SQL Server 2017 (14.x) num computador sem acesso à internet, o instalador pode não mostrar a página que solicita a localização dos componentes Python descarregados. Nesse caso, pode instalar a funcionalidade Machine Learning Services, mas não os componentes em Python.

Este problema foi corrigido na versão de lançamento. Além disso, esta limitação não se aplica aos componentes R.

Aplica-se a: SQL Server 2017 (14.x) com Python

Avise sobre versões incompatíveis quando se ligar a uma versão antiga do SQL Server R Services a partir de um cliente usando o SQL Server 2017

Quando executa código R num contexto de computação SQL Server 2016 (13.x), pode ver o seguinte erro:

Está a executar a versão 9.0.0 do Microsoft R Client no seu computador, que é incompatível com a versão 8.0.3 do Microsoft R Server. Descarregue e instale uma versão compatível.

Esta mensagem é exibida se alguma das seguintes duas afirmações for verdadeira:

• Instalaste o R Server (Standalone) num computador cliente usando o assistente de configuração do SQL Server 2017 (14.x).
• Instalaste o Microsoft R Server usando o instalador separado do Windows.

Para garantir que o servidor e o cliente usam a mesma versão, poderá ser necessário usar binding, suportado para o Microsoft R Server 9.0 e versões posteriores, para atualizar os componentes R nas instâncias do SQL Server 2016 (13.x). Para determinar se há suporte para atualizações disponíveis para a sua versão dos Serviços R, veja Atualizar uma instância dos Serviços R usando SqlBindR.exe.

Aplica-se a: SQL Server 2016 (13.x) R Services, com R Server versão 9.0.0 ou anterior

A configuração dos lançamentos de serviço do SQL Server 2016 poderá falhar ao instalar versões mais recentes dos componentes do R

Quando instala uma atualização cumulativa ou um service pack para SQL Server 2016 (13.x) num computador que não está ligado à internet, o assistente de configuração pode falhar em mostrar o prompt que permite atualizar os componentes R usando ficheiros CAB descarregados. Esta falha ocorre normalmente quando vários componentes foram instalados em conjunto com o motor da base de dados.

Como solução alternativa, pode instalar a versão de serviço usando a linha de comandos e especificando o argumento MRCACHEDIRECTORY, como mostrado neste exemplo, que instala as atualizações CU 1.

C:\<path to installation media>\SQLServer2016-KB3164674-x64.exe /Action=Patch /IACCEPTROPENLICENSETERMS /MRCACHEDIRECTORY=<path to CU 1 CAB files>

Para obter os instaladores mais recentes, consulte Instalar componentes de aprendizagem automática sem acesso à internet.

Aplica-se a: SQL Server 2016 (13.x) R Services, com R Server versão 9.0.0 ou anterior

Os serviços de Launchpad falham ao iniciar se a versão for diferente da versão R

Se instalar o SQL Server R Services separadamente do motor de base de dados, e as versões de compilação forem diferentes, poderá ver o seguinte erro no registo de eventos do sistema:

O serviço SQL Server Launchpad falhou em arrancar devido ao seguinte erro: o serviço não respondeu ao pedido de início ou controlo de forma atempada.

Por exemplo, este erro pode ocorrer se instalar o motor de base de dados usando a versão de lançamento, aplicar um patch para atualizar o motor de base de dados e depois adicionar a funcionalidade R Services usando a versão de lançamento.

Para evitar este problema, utilize uma ferramenta como o File Manager para comparar as versões do Launchpad.exe com versões de binários SQL, como sqldk.dll. Todos os componentes devem ter o mesmo número de versão. Se atualizares um componente, certifica-te de aplicar a mesma atualização a todos os outros componentes instalados.

Procure o Launchpad na pasta Binn da instância. Por exemplo, numa instalação padrão do SQL Server 2016 (13.x), o caminho pode ser C:\Program Files\Microsoft SQL Server\MSSQL.13.InstanceNameMSSQL\Binn.

Os contextos de computação remota são bloqueados por um firewall nas instâncias do SQL Server que estão a correr em máquinas virtuais Azure

Se instalou SQL Server numa máquina virtual Azure, pode não conseguir usar contextos de computação que exijam o uso do espaço de trabalho da máquina virtual. A razão é que, por defeito, o firewall nas máquinas virtuais Azure inclui uma regra que bloqueia o acesso à rede para contas de utilizadores locais R.

Como solução alternativa, na VM Azure, abra o Windows Firewall com Segurança Avançada, selecione Regras de Saída e desative a seguinte regra: Bloqueie o acesso à rede para R contas de utilizador locais na instância SQL Server MSSQLSERVER. Também pode deixar a regra ativada, mas alterar a propriedade de segurança para Permitir se for seguro.

Autenticação implícita na edição Express do SQL Server 2016

Quando executa trabalhos R a partir de uma estação de trabalho remota de ciência de dados usando autenticação integrada do Windows, o SQL Server utiliza autenticação implícita para gerar quaisquer chamadas ODBC locais que possam ser exigidas pelo script. No entanto, esta funcionalidade não funcionava na versão RTM da edição Express do SQL Server 2016 (13.x).

Para resolver o problema, recomendamos que atualize para uma versão de serviço mais recente. Se a atualização não for viável, como solução alternativa, usa um login SQL para executar trabalhos remotos de R que possam exigir chamadas ODBC embutidas.

Aplica-se a: SQL Server 2016 (13.x) Edição Express do R Services

Limites de desempenho quando as bibliotecas usadas pelo SQL Server são chamadas a partir de outras ferramentas

É possível chamar as bibliotecas de aprendizagem automática instaladas para SQL Server a partir de uma aplicação externa, como o RGui. Fazer isso pode ser a forma mais conveniente de realizar certas tarefas, como instalar novos pacotes ou executar testes ad hoc em exemplos de código muito curtos. No entanto, fora do SQL Server, o desempenho pode ser limitado.

Por exemplo, mesmo que esteja a usar a edição Enterprise do SQL Server, o R corre em modo single-threaded quando executa o seu código R usando ferramentas externas. Para obter os benefícios do desempenho no SQL Server, inicie uma ligação SQL Server e use sp_execute_external_script para chamar o script de execução externo.

De um modo geral, evite chamar as bibliotecas de machine learning usadas pelo SQL Server a partir de ferramentas externas. Se precisares de depurar código em R ou Python, normalmente é mais fácil fazê-lo fora do SQL Server. Para obter as mesmas bibliotecas que estão no SQL Server, pode instalar o Microsoft R Client ou o SQL Server 2017 Machine Learning Server (Standalone).

O SQL Server Data Tools não suporta permissões exigidas por scripts externos

Quando usa o Visual Studio ou SQL Server Data Tools para publicar um projeto de base de dados, se algum principal tiver permissões específicas para execução de scripts externos, pode receber um erro como este:

Modelo TSQL: Erro detetado ao fazer engenharia inversa da base de dados. A permissão não foi reconhecida e não foi importada.

Atualmente, o modelo DACPAC não suporta as permissões usadas por Serviços R ou Serviços de Aprendizagem Automática, como GRANT ANY EXTERNAL SCRIPT, ou EXECUTE ANY EXTERNAL SCRIPT. Este problema será corrigido numa versão futura.

Como solução alternativa, execute as instruções adicionais GRANT num script pós-implementação.

A execução de scripts externos é limitada devido aos valores padrão da governação de recursos

Na edição Enterprise, pode usar pools de recursos para gerir processos de scripts externos. Em algumas versões iniciais, a memória máxima que podia ser alocada aos processos R era de 20 por cento. Portanto, se o servidor tivesse 32 GB de RAM, os executáveis R (RTerm.exe e BxlServer.exe) podiam usar no máximo 6,4 GB num único pedido.

Se encontrares limitações de recursos, verifica o padrão atual. Se 20 por cento não for suficiente, vê a documentação do SQL Server sobre como alterar este valor.

Aplica-se a: SQL Server 2016 (13.x) R Services, edição Enterprise

Erro ao usar sp_execute_external_script without libc++.so no Linux

Numa máquina Linux limpa que não tenha libc++.so instalado, executar uma sp_execute_external_script consulta (SPEES) com Java ou uma linguagem externa falha porque commonlauncher.so não carrega libc++.so.

Por exemplo:

EXECUTE sp_execute_external_script @language = N'Java'
    , @script = N'JavaTestPackage.PassThrough'
    , @parallel = 0
    , @input_data_1 = N'select 1'
WITH RESULT SETS((col1 INT NOT NULL));
GO

Este procedimento falha com uma mensagem semelhante à seguinte:

Msg 39012, Level 16, State 14, Line 0

Unable to communicate with the runtime for 'Java' script for request id: 94257840-1704-45E8-83D2-2F74AEB46CF7. Please check the requirements of 'Java' runtime.

Os mssql-launchpadd registos irão mostrar uma mensagem de erro semelhante à seguinte:

Oct 18 14:03:21 sqlextmls launchpadd[57471]: [launchpad] 2019/10/18 14:03:21 WARNING: PopulateLauncher failed: Library /opt/mssql-extensibility/lib/commonlauncher.so not loaded. Error: libc++.so.1: cannot open shared object file: No such file or directory

Solução

Pode realizar uma das seguintes soluções alternativas:

1. Copiar libc++* de /opt/mssql/lib para o caminho padrão do sistema /lib64

2. Adicione as seguintes entradas a /var/opt/mssql/mssql.conf para expor o caminho:

   [extensibility]
   readabledirectories = /opt/mssql
   

Aplica-se a: SQL Server 2019 (15.x) no Linux

Erro de instalação ou atualização em servidores habilitados pelo FIPS

Se instalar o SQL Server 2019 (15.x) com a funcionalidade Machine Learning Services and Language Extensions ou atualizar a instância do SQL Server num servidor habilitado pelo Federal Information Processing Standard (FIPS ), receberá o seguinte erro:

Ocorreu um erro durante a instalação da funcionalidade de extensibilidade com mensagem de erro: AppContainer Creation Failed with error message NONE, state Esta implementação não faz parte dos algoritmos criptográficos validados FIPS da Plataforma Windows.

Solução

Desative o FIPS antes da instalação do SQL Server 2019 (15.x) com a funcionalidade Machine Learning Services and Language Extensions ou da atualização da instância do SQL Server. Uma vez concluída a instalação ou atualização, pode reativar o FIPS.

Aplica-se a: SQL Server 2019 (15.x)

R bibliotecas usando algoritmos específicos, streaming ou particionamento

Questão

As seguintes limitações aplicam-se ao SQL Server 2017 (14.x) com atualização em tempo de execução. Este problema aplica-se à edição Enterprise.

• Paralelismo: o paralelismo de threads de algoritmo RevoScaleR e MicrosoftML para cenários está limitado a um máximo de dois encadeamentos.
• Streaming e partição: Cenários em que o parâmetro @r_rowsPerRead passado para o T-SQL sp_execute_external_script não é aplicado.
• Streaming & Particionamento: as fontes de dados e (ou seja, , ) não suportam a leitura de linhas em blocos para cenários de treino ou pontuação. Esses cenários sempre trazem todos os dados para a memória para computação e as operações são ligadas à memória

Solução

A melhor solução é atualizar para o SQL Server 2019 (15.x). Em alternativa, pode continuar a usar o SQL Server 2017 (14.x) com a atualização em tempo de execução configurada usando RegisterRext.exe /configure, depois de concluir as seguintes tarefas.

1. Editar o registo para criar uma chave Computer\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SQL Server\150 e adicionar um valor SharedCode com dados C:\Program Files\Microsoft SQL Server\150\Shared ou o diretório partilhado da instância, conforme configurado.
2. Crie uma pasta C:\Program Files\Microsoft SQL Server\150\Shared and copy instapi140.dll da pasta C:\Program Files\Microsoft SQL Server\140\Shared para a pasta recém-criada.
3. Renomeie o instapi140.dll para instapi150.dll na nova pasta C:\Program Files\Microsoft SQL Server\150\Shared.

Problemas de desempenho do Pool de Processos em Serviços de ML (R e Python)

Esta secção contém problemas conhecidos e soluções alternativas para o uso de serviços de ML (R e Python) no SQL Server.

Desempenho de Inicialização a Frio do Pool de Processos em Serviços de Aprendizagem Automática

Após a execução de sp_execute_external_script, o serviço de lançamento inicia processos satélite que inicializam os ambientes de execução externos, como R e Python. Para amortizar o custo inicial, é criado um conjunto de processos que podem ser usados na execução subsequente de sp_execute_external_script. Este conjunto de processos é específico para este utilizador, base de dados e a linguagem utilizada (R ou Python em Serviços de ML).

Primeira execução de consulta

Os processos satélite precisam de ser aquecidos quando sp_execute_external_script são executados pela primeira vez ou após um período de inatividade (os processos são terminados através de uma tarefa de limpeza se não forem usados durante algum tempo). O arranque a frio destes processos agrupados pode ser lento (por exemplo, devido a limitações de recursos).

Solução

Se o desempenho da primeira chamada for importante, recomenda-se manter as consultas quentes. Por exemplo, pode ser executada uma tarefa em segundo plano que lança uma consulta simples sp_execute_external_script antes de os processos expirarem. Por exemplo, para manter as consultas R quentes, pode executar a seguinte consulta periodicamente.

EXECUTE sp_execute_external_script @language = N'R', @script = N'';
GO

Elevado número de consultas simultâneas

Se o número de execuções concorrentes de sp_execute_external_script for superior ao dos processos R/Python ativos no pool, o arranque a frio de adicionar processos adicionais ao pool pode ser lento (por exemplo, devido a restrições de recursos).

Solução

Para ultrapassar o problema de desempenho de escalabilidade, múltiplos pedidos podem ser agrupados (por exemplo, através de ligações de loopback ou reescrevendo o script para lidar com múltiplos pedidos). Além disso, para cenários em tempo real, pode ser utilizado o SQL PREDICT .

Problemas de execução de scripts R

Esta secção contém problemas conhecidos que são específicos para executar o R no SQL Server, bem como alguns problemas relacionados com as bibliotecas e ferramentas R publicadas pela Microsoft, incluindo o RevoScaleR.

Para problemas adicionais conhecidos que possam afetar soluções R, consulte o site Machine Learning Server .

Aviso de acesso negado ao executar scripts R no SQL Server numa localização não padrão

Se a instância do SQL Server foi instalada num local não predefinido, como fora da Program Files pasta, o aviso ACCESS_DENIED é ativado quando tentas executar scripts que instalam um pacote. Por exemplo:

Em normalizePath(path.expand(path), winslash, mustWork) : path[2]="~ExternalLibraries/R/8/1": O acesso é negado

A razão é que uma função R tenta ler o caminho e falha se o grupo de utilizadores incorporado SQLRUserGroup não tiver acesso à leitura. O aviso que é levantado não bloqueia a execução do script R atual, mas o aviso pode repetir-se repetidamente sempre que o utilizador executa qualquer outro script R.

Se tiver instalado o SQL Server na localização predefinida, este erro não ocorre, porque todos os utilizadores do Windows têm permissões de leitura na Program Files pasta.

Esta questão será abordada numa próxima versão de serviço. Como solução alternativa, forneça ao grupo, SQLRUserGroup, acesso de leitura para todas as pastas pais de ExternalLibraries.

Erro de serialização entre as versões antiga e nova do RevoScaleR

Quando passa um modelo usando um formato serializado para uma instância remota do SQL Server, pode aparecer o erro:

Erro em memDecompress(dados, tipo = decompress) erro interno -3 em memDecompress(2).

Este erro surge se tiver guardado o modelo usando uma versão recente da função de serialização, rxSerializeModel, mas a instância do SQL Server onde se desserializa o modelo tem uma versão mais antiga das APIs RevoScaleR, do SQL Server 2017 (14.x) 2 ou anterior.

Como solução alternativa, pode atualizar a instância SQL Server 2017 (14.x) para CU 3 ou posterior.

O erro não aparece se a versão da API for a mesma, ou se estiver a mover um modelo guardado com uma função de serialização mais antiga para um servidor que usa uma versão mais recente da API de serialização.

Por outras palavras, usar a mesma versão do RevoScaleR tanto para operações de serialização como de desserialização.

A pontuação em tempo real não lida corretamente com o parâmetro LearningRate em modelos de árvore e floresta

Se criar um modelo usando uma árvore de decisão ou método de floresta de decisão e especificar a taxa de aprendizagem, poderá ver resultados inconsistentes ao usar sp_rxpredict ou a função SQL PREDICT , em comparação com usar rxPredict.

A causa é um erro na API que processa modelos serializados, limitada ao learningRate parâmetro: por exemplo, em rxBTrees, ou

Esta questão será abordada numa próxima versão de serviço.

Limitações na afinidade do processador para trabalhos R

Na versão inicial do SQL Server 2016 (13.x), podia definir a afinidade do processador apenas para CPUs no primeiro k-group. Por exemplo, se o servidor for uma máquina de 2 soquetes com dois k-grupos, apenas os processadores do primeiro k-grupo são usados para os processos R. A mesma limitação aplica-se quando configuras a governação de recursos para trabalhos de script R.

Este problema está resolvido no SQL Server 2016 (13.x) Service Pack 1. Recomendamos que atualize para a versão mais recente do serviço.

Aplica-se a: SQL Server 2016 (13.x) R Services (versão RTM)

Alterações nos tipos de colunas não podem ser realizadas ao ler dados num contexto de computação SQL Server

Se o teu contexto de computação estiver definido para a instância do SQL Server, não podes usar o argumento colClasses (ou outros argumentos semelhantes) para alterar o tipo de dados das colunas no teu código R.

Por exemplo, a seguinte instrução resultaria num erro se a coluna CRSDepTimeStr não for já um inteiro:

data <- RxSqlServerData(
  sqlQuery = "SELECT CRSDepTimeStr, ArrDelay FROM AirlineDemoSmall",
  connectionString = connectionString,
  colClasses = c(CRSDepTimeStr = "integer"))

Como solução alternativa, podes reescrever a consulta SQL para usar CAST ou CONVERT apresentar os dados ao R usando o tipo de dado correto. Em geral, o desempenho é melhor quando se trabalha com dados usando SQL em vez de alterar dados no código R.

Aplica-se a: SQL Server 2016 (13.x) R Services

Limites de tamanho dos modelos serializados

Quando guarda um modelo numa tabela SQL Server, tem de serializar o modelo e guardá-lo num formato binário. Teoricamente, o tamanho máximo de um modelo que pode ser armazenado com este método é de 2 GB, que é o tamanho máximo das colunas varbinary no SQL Server.

Se precisar de usar modelos maiores, estão disponíveis as seguintes soluções alternativas:

• Tome medidas para reduzir o tamanho do seu modelo. Alguns pacotes R open source incluem uma grande quantidade de informação no objeto modelo, e grande parte dessa informação pode ser removida para implementação.

• Use a seleção de funcionalidades para remover colunas desnecessárias.

• Se estiver a usar um algoritmo open source, considere uma implementação semelhante usando o algoritmo correspondente em MicrosoftML ou RevoScaleR. Estes pacotes foram otimizados para cenários de implementação.

• Depois de o modelo ser racionalizado e o tamanho reduzido usando os passos anteriores, veja se a função memCompress na base R pode ser usada para reduzir o tamanho do modelo antes de o passar para o SQL Server. Esta opção é melhor quando o modelo está perto do limite de 2 GB.

• Para modelos maiores, pode usar a funcionalidade SQL Server FileTable para armazenar os modelos, em vez de usar uma coluna varbinary.

  Para usar FileTables, deve adicionar uma exceção de firewall, porque os dados armazenados nas FileTables são geridos pelo driver do sistema de ficheiros Filestream no SQL Server, e as regras de firewall padrão bloqueiam o acesso a ficheiros de rede. Para mais informações, consulte Ativar Pré-requisitos para o FileTable.

  Depois de ativares o FileTable para escrever o modelo, obténs um caminho do SQL usando a API do FileTable e depois escreves o modelo nessa localização a partir do teu código. Quando precisas de ler o modelo, obténs o path do SQL Server e depois chamas o modelo usando o path do teu script. Para mais informações, consulte Aceder às Tabelas de Ficheiros com APIs de Entrada/Saída de Ficheiros.

Evite limpar espaços de trabalho quando executar código R num contexto de computação SQL Server

Se usar um comando R para limpar o seu espaço de trabalho de objetos enquanto executa código R num contexto de computação SQL Server, ou se limpar o espaço de trabalho como parte de um script R chamado usando sp_execute_external_script, pode obter este erro: objeto workspace revoScriptConnection não encontrado

revoScriptConnection é um objeto no espaço de trabalho R que contém informação sobre uma sessão R chamada a partir do SQL Server. No entanto, se o seu código R incluir um comando para limpar o espaço de trabalho (como rm(list=ls()))), toda a informação sobre a sessão e outros objetos no espaço de trabalho R também é apagada.

Como solução alternativa, evita limpar indiscriminadamente variáveis e outros objetos enquanto estás a correr o R no SQL Server. Embora limpar o espaço de trabalho seja comum ao trabalhar na consola R, pode ter consequências indesejadas.

• Para eliminar variáveis específicas, use a função R remove : por exemplo, remove('name1', 'name2', ...)
• Se houver várias variáveis a eliminar, guarde os nomes das variáveis temporárias numa lista e realize a recolha periódica de lixo.

Restrições aos dados que podem ser fornecidos como entrada a um script R

Não pode usar num script R os seguintes tipos de resultados de consulta:

• Dados de uma consulta Transact-SQL que faz referência às colunas AlwaysEncripted.

• Dados de uma consulta Transact-SQL que faz referência a colunas mascaradas.

  Se precisares de usar dados mascarados num script R, uma possível solução alternativa é fazer uma cópia dos dados numa tabela temporária e usar esses dados em vez disso.

A utilização de cordas como fatores pode levar à degradação do desempenho

A utilização de variáveis de tipo de cadeia como fatores pode aumentar significativamente a quantidade de memória usada para operações R. Este é um problema conhecido com o R em geral, e existem muitos artigos sobre o assunto. Por exemplo, veja Factors não são cidadãos de primeira classe em R, de John Mount, em R-bloggers) ou stringsAsFactors: Uma biografia não autorizada, de Roger Peng.

Embora o problema não seja específico do SQL Server, pode afetar bastante o desempenho do código R executado no SQL Server. As cadeias são normalmente armazenadas como varchar ou nvarchar, e se uma coluna de dados de cadeias tiver muitos valores únicos, o processo de convertê-los internamente em inteiros e voltar a cadeias por R pode até levar a erros de alocação de memória.

Se não exigir absolutamente um tipo de dado de cadeia para outras operações, mapear os valores da cadeia para um tipo de dado numérico (inteiro) como parte da preparação de dados seria benéfico do ponto de vista de desempenho e escala.

Para uma discussão sobre esta questão e outras dicas, veja Performance for R Services - otimização de dados.

Argumentos varsToKeep e varsToDrop não são suportados para fontes de dados SQL Server

Quando usa a função rxDataStep para escrever resultados numa tabela, usar varsToKeep e varsToDrop é uma forma prática de especificar as colunas a incluir ou excluir como parte da operação. No entanto, estes argumentos não são suportados para fontes de dados SQL Server.

Suporte limitado para tipos de dados SQL em sp_execute_external_script

Nem todos os tipos de dados suportados em SQL podem ser usados em R. Como solução alternativa, considere lançar o tipo de dado não suportado para um tipo de dado suportado antes de passar os dados para sp_execute_external_script.

Para mais informações, consulte R bibliotecas e tipos de dados.

Possível corrupção de dados de strings ao usar strings Unicode em colunas varchar

Passar dados Unicode em colunas varchar do SQL Server para R/Python pode resultar em corrupção de strings. Isto deve-se ao facto de a codificação destas strings Unicode nas colações do SQL Server pode não coincidir com a codificação UTF-8 padrão usada no R/Python.

Para enviar quaisquer dados de string não ASCII do SQL Server para R/Python, use a codificação UTF-8 (disponível no SQL Server 2019 (15.x)) ou use o tipo nvarchar para o mesmo.

Apenas um valor de tipo raw pode ser devolvido de sp_execute_external_script

Quando um tipo de dado binário (o tipo de dados bruto R) é devolvido por R, o valor deve ser enviado no quadro de dados de saída.

Com tipos de dados diferentes do raw, pode devolver valores de parâmetros juntamente com os resultados do procedimento armazenado adicionando a palavra-chave OUTPUT. Para obter mais informações, consulte Parâmetros.

Se quiser usar múltiplos conjuntos de saída que incluam valores de tipo raw, uma possível solução alternativa é fazer múltiplas chamadas ao procedimento armazenado, ou enviar os conjuntos de resultados de volta para o SQL Server usando ODBC.

Perda de precisão

Como Transact-SQL e R suportam vários tipos de dados, os tipos de dados numéricos podem sofrer perda de precisão durante a conversão.

Para mais informações sobre conversão implícita de tipos de dados, veja R bibliotecas e tipos de dados.

Erro de escopo de variáveis ao usar o parâmetro transformFunc

Para transformar dados enquanto está a modelar, pode passar um argumento transformFunc numa função como rxLinmod ou rxLogit. No entanto, chamadas de função aninhadas podem levar a erros de definição de âmbito no contexto de computação do SQL Server, mesmo que as chamadas funcionem corretamente no contexto local de computação.

O conjunto de dados amostrais para a análise não tem variáveis

Por exemplo, suponha que definiu duas funções, f e g, no seu ambiente global local, e g chama f. Em chamadas distribuídas ou remotas envolvendo g, a chamada para g pode falhar com este erro, porque f não pode ser encontrada, mesmo que tenha fornecido ambos f e g para a chamada remota.

Se encontrar este problema, pode contorná-lo ao incorporar a definição de f dentro da sua definição de g, em qualquer lugar antes de g chamar normalmente f.

Por exemplo:

f <- function(x) { 2*x * 3 }
g <- function(y) {
              a <- 10 * y
               f(a)
}

Para evitar o erro, reescreva a definição da seguinte forma:

g <- function(y){
              f <- function(x) { 2*x +3}
              a <- 10 * y
              f(a)
}

Importação e manipulação de dados usando o RevoScaleR

Quando as colunas varchar são lidas a partir de uma base de dados, o espaço em branco é cortado. Para evitar isto, inclua as cadeias em caracteres que não sejam espaços em branco.

Quando funções como rxDataStep as são usadas para criar tabelas de base de dados que têm colunas varchar , a largura da coluna é estimada com base numa amostra dos dados. Se a largura puder variar, pode ser necessário acolchoar todas as cordas para um comprimento comum.

Usar uma transformação para alterar o tipo de dado de uma variável não é suportado quando chamadas repetidas para rxImport ou rxTextToXdf são usadas para importar e adicionar linhas, combinando múltiplos ficheiros de entrada num único ficheiro .xdf.

Apoio limitado para rxExec

No SQL Server 2016 (13.x), a função rxExec fornecida pelo pacote RevoScaleR só pode ser usada em modo monothread.

Aumentar o tamanho máximo dos parâmetros para suportar o rxGetVarInfo

Se usar conjuntos de dados com um número extremamente grande de variáveis (por exemplo, mais de 40.000), defina o max-ppsize flag ao iniciar R para usar funções como rxGetVarInfo. A max-ppsize bandeira especifica o tamanho máximo da pilha de proteção do ponteiro.

Se estiveres a usar a consola R (por exemplo, RGui.exe ou RTerm.exe), podes definir o valor de max-ppsize para 500000 digitando:

R --max-ppsize=500000

Problemas com a função rxDTree

Atualmente, a rxDTree função não suporta transformações dentro da fórmula. Em particular, não é suportado usar a sintaxe F() para criar fatores no local. No entanto, os dados numéricos são automaticamente descartados.

Os fatores ordenados são tratados da mesma forma que os fatores em todas as funções de análise do RevoScaleR, exceto rxDTree.

data.table como um conjunto de dados de saída em R

Usar data.table como um OutputDataSet no R não é suportado no SQL Server 2017 (14.x) Cumulative Update 13 (CU 13) e anteriores. A seguinte mensagem pode aparecer:

Msg 39004, Level 16, State 20, Line 2
A 'R' script error occurred during execution of
'sp_execute_external_script' with HRESULT 0x80004004.
Msg 39019, Level 16, State 2, Line 2
An external script error occurred:
Error in alloc.col(newx) :
  Internal error: length of names (0) is not length of dt (11)
Calls: data.frame ... as.data.frame -> as.data.frame.data.table -> copy -> alloc.col

Error in execution.  Check the output for more information.
Error in eval(expr, envir, enclos) :
  Error in execution.  Check the output for more information.
Calls: source -> withVisible -> eval -> eval -> .Call
Execution halted

data.table como um OutputDataSet em R é suportado no SQL Server 2017 (14.x) Cumulative Update 14 (CU 14) e posteriores.

Executar um script longo falha durante a instalação de uma biblioteca

Executar uma sessão de script externa de longa duração enquanto o dbo está a tentar em paralelo instalar uma biblioteca numa base de dados diferente pode interromper o script.

Por exemplo, ao executar este script externo contra a master base de dados:

USE MASTER
DECLARE @language nvarchar(1) = N'R'
DECLARE @script nvarchar(max) = N'Sys.sleep(100)'
DECLARE @input_data_1 nvarchar(max) = N'select 1'
EXEC sp_execute_external_script @language = @language, @script = @script, @input_data_1 = @input_data_1 with result sets none
go

Enquanto o dbo instala em paralelo uma biblioteca em LibraryManagementFunctional:

USE [LibraryManagementFunctional]
go

CREATE EXTERNAL LIBRARY [RODBC] FROM (CONTENT = N'/home/ani/var/opt/mssql/data/RODBC_1.3-16.tar.gz') WITH (LANGUAGE = 'R')
go

DECLARE @language nvarchar(1) = N'R'
DECLARE @script nvarchar(14) = N'library(RODBC)'
DECLARE @input_data_1 nvarchar(8) = N'select 1'
EXEC sp_execute_external_script @language = @language, @script = @script, @input_data_1 = @input_data_1
go

O script externo de longa duração anterior contra a master base de dados terminará com a seguinte mensagem de erro:

Ocorreu um erro de script 'R' durante a execução do 'sp_execute_external_script' com o HRESULT 0x800704d4.

Solução

Não execute a instalação da biblioteca em paralelo com a consulta de longa duração. Ou refazer a consulta prolongada depois da instalação estar concluída.

Aplica-se a: SQL Server 2019 (15.x) apenas em Linux e clusters de Big Data.

O SQL Server deixa de responder ao executar scripts R que contêm execução paralela

O SQL Server 2019 (15.x) contém uma regressão que afeta scripts R que usam execução paralela. Exemplos incluem o uso de rxExec com o contexto de computação RxLocalPar e scripts que utilizam o pacote paralelo. Este problema é causado por erros que o pacote paralelo encontra ao escrever no dispositivo nulo enquanto executa no SQL Server.

Aplica-se a: SQL Server 2019 (15.x).

Perda de precisão para tipos de dados monetários/numéricos/decimais/bigint

Executar um script R com sp_execute_external_script permite utilizar tipos de dados money, numérico, decimal e bigint como dados de entrada. No entanto, por serem convertidos para o tipo numérico de R, sofrem uma perda de precisão com valores muito elevados ou com valores decimais.

• dinheiro: Por vezes os valores dos cêntimos eram imprecisos e era emitido um aviso: Aviso: não se conseguia representar com precisão os valores dos cêntimos.
• numérico/decimal: sp_execute_external_script com um script R, não suporta toda a gama desses tipos de dados e alteraria os últimos dígitos decimais, especialmente aqueles com fração.
• bigint: R só suporta inteiros até 53 bits e depois começa a ter perda de precisão.

Problemas com a função rxExecBy - a função rxExecBy não consegue encontrar o pacote instalado

Quando a rxExecBy função é chamada, inicia-se um novo processo em tempo de execução R. Este novo processo não tem caminhos de biblioteca atualizados, pelo que pacotes instalados em locais diferentes do caminho padrão da biblioteca não são encontrados durante a execução.

Solução

O caminho para os pacotes R precisa ser atualizado explicitamente. Suponha que os pacotes são instalados no caminho das bibliotecas externas, o seguinte script R poderia ser usado para atualizar o caminho da biblioteca: .libPaths(c(Sys.getenv("MRS_EXTLIB_USER_PATH"), Sys.getenv("MRS_EXTLIB_SHARED_PATH"), .libPaths()))

Problemas de execução de scripts em Python

Esta secção contém problemas conhecidos específicos para correr Python no SQL Server, bem como problemas relacionados com os pacotes Python publicados pela Microsoft, incluindo revoscalepy e microsoftml.

A chamada ao modelo pré-treinado falha se o caminho para o modelo for demasiado longo

Se instalou os modelos pré-treinados numa versão inicial do SQL Server 2017 (14.x), o caminho completo até ao ficheiro do modelo treinado pode ser demasiado longo para o Python ler. Esta limitação é corrigida numa versão de serviço posterior.

Existem várias alternativas potenciais:

• Quando instalar os modelos pré-treinados, escolha um local personalizado.
• Se possível, instale a instância do SQL Server num caminho de instalação personalizado com um caminho mais curto, como C:\SQL\MSSQL14.MSSQLSERVER.
• Use a utilidade Windows Fsutil para criar uma ligação física que mapeie o ficheiro do modelo para um caminho mais curto.
• Atualização para a versão mais recente do serviço.

Erro ao gravar um modelo serializado no SQL Server

Quando passa um modelo para uma instância remota do SQL Server e tenta ler o modelo binário usando a rx_unserialize função em revoscalepy, pode aparecer o erro:

NameError: nome 'rx_unserialize_model' não está definido

Este erro surge se guardaste o modelo usando uma versão recente da função de serialização, mas a instância do SQL Server onde desserializas o modelo não reconhece a API de serialização.

Para resolver o problema, atualize a instância do SQL Server 2017 (14.x) para 3 ou mais recente.

A falha em inicializar uma variável varbinária causa um erro em BxlServer

Se executares código Python no SQL Server usando sp_execute_external_script, e o código tiver variáveis de saída do tipo varbinary(max), varchar(max) ou tipos semelhantes, a variável deve ser inicializada ou definida como parte do teu script. Caso contrário, o componente de troca de dados, BxlServer, gera um erro e deixa de funcionar.

Esta limitação será corrigida numa próxima versão de serviço. Como solução alternativa, certifique-se de que a variável está inicializada dentro do script Python. Qualquer valor válido pode ser usado, como nos seguintes exemplos:

declare @b varbinary(max);
exec sp_execute_external_script
  @language = N'Python'
  , @script = N'b = 0x0'
  , @params = N'@b varbinary(max) OUTPUT'
  , @b = @b OUTPUT;
go

declare @b varchar(30);
exec sp_execute_external_script
  @language = N'Python'
  , @script = N' b = ""  '
  , @params = N'@b varchar(30) OUTPUT'
  , @b = @b OUTPUT;
go

Aviso de telemetria após a execução bem-sucedida de um código em Python

A partir do SQL Server 2017 (14.x) 2, a seguinte mensagem pode aparecer mesmo que o código Python corra com sucesso:

Mensagem(ões) STDERR do script externo:~PYTHON_SERVICES\lib\site-packages\revoscalepy\utils\RxTelemetryLoggerAviso de Sintaxe: telemetry_state é usado antes da declaração global

Este problema foi corrigido no SQL Server 2017 (14.x) Cumulative Update 3 (3).

Tipos de dados numéricos, decimais e monetários não suportados

A partir do SQL Server 2017 (14.x) Cumulative Update 12 (CU 12), os tipos de dados numéricos, decimais e monetários em WITH RESULT SETS não são suportados quando se utiliza Python com sp_execute_external_script. Podem aparecer as seguintes mensagens:

[Código: 39004, Estado SQL: S1000] Um erro de script em 'Python' ocorreu durante a execução de 'sp_execute_external_script' com o HRESULT 0x80004004.

[Código: 39019, Estado SQL: S1000] Ocorreu um erro de script externo:

Erro SqlSatelliteCall: Tipo não suportado no esquema de saída. Tipos suportados: bit, smallint, int, datetime, smallmoney, real e float. Char e Varchar estão parcialmente apoiados.

Isto foi corrigido no SQL Server 2017 (14.x) Atualização Cumulativa 14 (14).

Erro de interpretador mau ao instalar pacotes Python com pip no Linux

No SQL Server 2019 (15.x), se tentares usar pip. Por exemplo:

/opt/mssql/mlservices/runtime/python/bin/pip -h

Vai então receber este erro:

bash: /opt/mssql/mlservices/runtime/python/bin/pip: /opt/microsoft/mlserver/9.4.7/bin/python/python: interpretador mau: Não existe esse ficheiro ou diretório

Solução

Instale pip a partir da Python Package Authority (PyPA):

wget 'https://bootstrap.pypa.io/get-pip.py'
/opt/mssql/mlservices/bin/python/python ./get-pip.py

Aplica-se a: SQL Server 2019 (15.x) no Linux

Não é possível instalar pacotes Python utilizando pip depois de instalar o SQL Server 2019 no Windows.

Após instalar o SQL Server 2019 (15.x) no Windows, tentar instalar um pacote python via pip a partir de uma linha de comandos DOS falhará. Por exemplo:

pip install quantfolio

Isto devolverá o seguinte erro:

pip está configurado com localizações que requerem TLS/SSL, no entanto o módulo ssl em Python não está disponível.

Este é um problema específico do pacote Anaconda. Será corrigido numa próxima atualização de serviço.

Solução

Copie os seguintes ficheiros:

• libssl-1_1-x64.dll
• libcrypto-1_1-x64.dll

da pasta
C:\Program Files\Microsoft SQL Server\MSSSQL15.MSSQLSERVER\PYTHON_SERVICES\Library\bin

para a pasta
C:\Program Files\Microsoft SQL Server\MSSSQL15.MSSQLSERVER\PYTHON_SERVICES\DLLs

Depois abre um novo prompt de comando do DOS.

Aplica-se a: SQL Server 2019 (15.x) no sistema Windows

Erro ao usar sp_execute_external_script without libc++abo.so no Linux

Numa máquina Linux limpa que não tenha libc++abi.so instalado, executar uma sp_execute_external_script consulta (SPEES) falha com um erro "Nenhum ficheiro ou diretório desse tipo".

Por exemplo:

EXEC sp_execute_external_script
    @language = N'Python'
    , @script = N'
OutputDataSet = InputDataSet'
    , @input_data_1 = N'select 1'
    , @input_data_1_name = N'InputDataSet'
    , @output_data_1_name = N'OutputDataSet'
    WITH RESULT SETS (([output] int not null));

Msg 39012, Level 16, State 14, Line 0
Unable to communicate with the runtime for 'Python' script for request id: 94257840-1704-45E8-83D2-2F74AEB46CF7. Please check the requirements of 'Python' runtime.
STDERR message(s) from external script:

Failed to load library /opt/mssql-extensibility/lib/sqlsatellite.so with error libc++abi.so.1: cannot open shared object file: No such file or directory.

SqlSatelliteCall error: Failed to load library /opt/mssql-extensibility/lib/sqlsatellite.so with error libc++abi.so.1: cannot open shared object file: No such file or directory.
STDOUT message(s) from external script:
SqlSatelliteCall function failed. Please see the console output for more information.
Traceback (most recent call last):
  File "/opt/mssql/mlservices/libraries/PythonServer/revoscalepy/computecontext/RxInSqlServer.py", line 605, in rx_sql_satellite_call
    rx_native_call("SqlSatelliteCall", params)
  File "/opt/mssql/mlservices/libraries/PythonServer/revoscalepy/RxSerializable.py", line 375, in rx_native_call
    ret = px_call(functionname, params)
RuntimeError: revoscalepy function failed.
Total execution time: 00:01:00.387

Solução

Execute o seguinte comando:

sudo cp /opt/mssql/lib/libc++abi.so.1 /opt/mssql-extensibility/lib/

Aplica-se a: SQL Server 2019 (15.x) no Linux

Erro genérico ao correr sp_execute_external_script em Ubuntu 20.04 com SQL Server 2022 CU6 em Linux

Instalar SQL Server 2022 CU6 para Linux no Ubuntu 20.04 pode resultar no seguinte erro ao executar scripts de R e Python sp_execute_external_script:

Msg 39012, Level 16, State 14, Line 0
Unable to communicate with the runtime for 'R' script for request id: 94257840-1704-45E8-83D2-2F74AEB46CF7. Please check the requirements of 'R' runtime.

STDERR message(s) from external script: 
/usr/lib/R/library/RevoScaleR/rxLibs/x64/libExaCore.so.2(_Z21CriticalSignalHandleri+0x29)[0x7f2568289d89]
/usr/lib/x86_64-linux-gnu/libc.so.6(+0x43090)[0x7f2568d66090]

Solução

Execute o seguinte comando para instalar a dependência do pacote libssl-dev, que permite ao SQL Server solucionar as bibliotecas partilhadas libssl e libcrypto fornecidas pelo sistema.

sudo apt-get update
sudo apt-get install libssl-dev

Erro na criação de regras de firewall em modprobe ao executar mssql-launchpadd no Linux

Ao visualizar os registos de mssql-launchpadd ao usar sudo journalctl -a -u mssql-launchpadd, pode ver um erro de criação de regras de firewall semelhante à saída seguinte.

-- Logs begin at Sun 2021-03-28 12:03:30 PDT, end at Wed 2022-10-12 13:20:17 PDT. --
Mar 22 16:57:51 sqlVm systemd[1]: Started Microsoft SQL Server Extensibility Launchpad Daemon.
Mar 22 16:57:51 sqlVm launchpadd[195658]: 2022/03/22 16:57:51 [launchpadd] INFO: Extensibility Log Header: <timestamp> <process> <sandboxId> <sessionId> <message>
Mar 22 16:57:51 sqlVm launchpadd[195658]: 2022/03/22 16:57:51 [launchpadd] INFO: No extensibility section in /var/opt/mssql/mssql.conf file. Using default settings.
Mar 22 16:57:51 sqlVm launchpadd[195658]: 2022/03/22 16:57:51 [launchpadd] INFO: DataDirectories =  /bin:/etc:/lib:/lib32:/lib64:/sbin:/usr/bin:/usr/include:/usr/lib:/usr/lib32:/usr/lib64:/usr/libexec/gcc:/usr/sbin:/usr/share:/var/lib:/opt/microsoft:/opt/mssql-extensibility:/opt/mssql/mlservices:/opt/mssql/lib/zulu-jre-11:/opt/mssql-tools
Mar 22 16:57:51 sqlVm launchpadd[195658]: 2022/03/22 16:57:51 [launchpadd] INFO: [RG] SQL Extensibility Cgroup initialization is done.
Mar 22 16:57:51 sqlVm launchpadd[195658]: 2022/03/22 16:57:51 [launchpadd] INFO: Found 1 IP address(es) from the bridge.
Mar 22 16:57:51 sqlVm launchpadd[195676]: modprobe: ERROR: could not insert 'ip6_tables': Operation not permitted
Mar 22 16:57:51 sqlVm launchpadd[195673]: ip6tables v1.8.4 (legacy): can't initialize ip6tables table `filter': Table does not exist (do you need to insmod?)
Mar 22 16:57:51 sqlVm launchpadd[195673]: Perhaps ip6tables or your kernel needs to be upgraded.
Mar 22 16:57:51 sqlVm launchpadd[195678]: modprobe: ERROR: could not insert 'ip6_tables': Operation not permitted
Mar 22 16:57:51 sqlVm launchpadd[195677]: ip6tables v1.8.4 (legacy): can't initialize ip6tables table `filter': Table does not exist (do you need to insmod?)
Mar 22 16:57:51 sqlVm launchpadd[195677]: Perhaps ip6tables or your kernel needs to be upgraded.
Mar 22 16:57:51 sqlVm launchpadd[195670]: 2022/03/22 16:57:51 [setnetbr] ERROR: Failed to set firewall rules: exit status 3

Solução

Execute os seguintes comandos para configurar modprobe, e reinicie o serviço SQL Server Launchpad:

sudo modprobe ip6_tables
sudo systemctl restart mssql-launchpadd

Aplica-se a: SQL Server 2019 (15.x) e posteriormente no Linux

Não é possível instalar o pacote tensorflow usando sqlmlutils

O sqlmlutils pacote é utilizado para instalar pacotes Python no SQL Server 2019 (15.x). Precisa de descarregar, instalar e atualizar o Microsoft Visual C++ 2015-2019 Redistributable (x64). No entanto, o tensorflow pacote não pode ser instalado usando sqlmlutils. O tensorflow pacote depende de uma versão mais recente do numpy que a versão instalada no SQL Server. No entanto, numpy é um pacote de sistema pré-instalado que sqlmlutils não consegue atualizar ao tentar instalar tensorflow.

Solução

Usando um prompt de comandos em modo administrador, execute o seguinte comando, substituindo "MSSQLSERVER" pelo nome da sua instância SQL Server:

"C:\Program Files\Microsoft SQL Server\MSSQL15.MSSQLSERVER\PYTHON_SERVICES\python.exe" -m pip install --upgrade tensorflow

Se aparecer um erro "TLS/SSL", veja 7. Não é possível instalar pacotes Python usando pip anteriormente neste artigo.

Aplica-se a: SQL Server 2019 (15.x) no Windows

Revolution R Enterprise e Microsoft R Open

Esta secção lista questões específicas das ferramentas de conectividade, desenvolvimento e desempenho em R fornecidas pela Revolution Analytics. Estas ferramentas foram fornecidas em versões pré-lançamento anteriores do SQL Server.

De um modo geral, recomendamos que desinstale estas versões anteriores e instale a versão mais recente do SQL Server ou do Microsoft R Server.

O Revolution R Enterprise não é suportado

Instalar o Revolution R Enterprise lado a lado com qualquer versão do R Services (In-Database) não é suportado.

Se tiver uma licença existente para o Revolution R Enterprise, deve colocá-la num computador separado tanto da instância SQL Server como de qualquer estação de trabalho que queira usar para se ligar à instância SQL Server.

Algumas versões pré-lançamento do R Services (In-Database) incluíam um ambiente de desenvolvimento R para Windows criado pela Revolution Analytics. Esta ferramenta já não é fornecida e não é suportada.

Para compatibilidade com os Serviços R (In-Database), recomendamos que instale o Microsoft R Client em vez disso. O R Tools para Visual Studio e Visual Studio Code também suporta soluções Microsoft R.

Problemas de compatibilidade com o driver SQLite ODBC e o RevoScaleR

A Revisão 0.92 do driver ODBC SQLite é incompatível com o RevoScaleR. As revisões 0.88-0.91 e 0.93 e posteriores são conhecidas por serem compatíveis.

Próximos passos

• Recolha de dados para resolver problemas nos Serviços de Aprendizagem Automática do SQL Server