Como usar pacotes de terceiros¶

Introdução¶

Usar o repositório de artefatos padrão do Snowflake (snowflake.snowpark.pypi_shared_repository) para conectar e instalar o PyPI Pacotes dentro do Snowpark UDFs e procedimentos.

Antes de usar este repositório, o administrador da conta (um usuário que recebeu a função ACCOUNTADMIN) deve conceder a função de banco de dados SNOWFLAKE.PYPI_REPOSITORY_USER para sua função:

GRANT DATABASE ROLE SNOWFLAKE.PYPI_REPOSITORY_USER TO ROLE some_user_role;

O administrador da conta também pode conceder essa função de banco de dados a todos os usuários da conta:

GRANT DATABASE ROLE SNOWFLAKE.PYPI_REPOSITORY_USER TO ROLE PUBLIC;

Com essa função, você pode instalar o pacote do repositório. Quando você cria a UDF, você define o parâmetro ARTIFACT_REPOSITORY para o nome do repositório de artefatos. Você também define o parâmetro PACKAGES para a lista dos nomes dos pacotes que virão do repositório de artefatos. No exemplo a seguir, como o repositório de artefatos está configurado com PyPI, o pacote scikit-learn é originado de PyPI:

CREATE OR REPLACE FUNCTION sklearn_udf()
  RETURNS FLOAT
  LANGUAGE PYTHON
  RUNTIME_VERSION = 3.12
  ARTIFACT_REPOSITORY = snowflake.snowpark.pypi_shared_repository
  PACKAGES = ('scikit-learn')
  HANDLER = 'udf'
  AS
$$
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

def udf():
  X, y = load_iris(return_X_y=True)
  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)

  model = RandomForestClassifier()
  model.fit(X_train, y_train)
  return model.score(X_test, y_test)
$$;

SELECT sklearn_udf();

PACKAGES = ('scikit-learn==1.5')

Pacotes criados somente para x86¶

Se um pacote for criado apenas para x86, escolha um dos warehouses que use a arquitetura de CPU x86 — MEMORY_1X_x86 ou MEMORY_16X_x86 — e depois especifique RESOURCE_CONSTRAINT=(architecture='x86'), como no exemplo a seguir:

CREATE OR REPLACE FUNCTION pymeos_example()
RETURNS STRING
LANGUAGE PYTHON
HANDLER='main'
RUNTIME_VERSION='3.11'
ARTIFACT_REPOSITORY=snowflake.snowpark.pypi_shared_repository
PACKAGES=('pymeos') -- dependency pymeos-cffi is x86 only
RESOURCE_CONSTRAINT=(architecture='x86')
AS $$
def main() -> str:
   from pymeos import pymeos_initialize, pymeos_finalize, TGeogPointInst, TGeogPointSeq

   # Always initialize MEOS library
   pymeos_initialize()

   sequence_from_string = TGeogPointSeq(
      string='[Point(10.0 10.0)@2019-09-01 00:00:00+01, Point(20.0 20.0)@2019-09-02 00:00:00+01, Point(10.0 10.0)@2019-09-03 00:00:00+01]')

   sequence_from_points = TGeogPointSeq(instant_list=[TGeogPointInst(string='Point(10.0 10.0)@2019-09-01 00:00:00+01'),
        TGeogPointInst(string='Point(20.0 20.0)@2019-09-02 00:00:00+01'),
        TGeogPointInst(string='Point(10.0 10.0)@2019-09-03 00:00:00+01')],
          lower_inc=True, upper_inc=True)
   speed = sequence_from_points.speed()

   # Call finish at the end of your code
   pymeos_finalize()

   return speed
$$;

SELECT pymeos_example();

Para obter mais informações, consulte Warehouses otimizados para Snowpark.

Você pode usar o repositório de artefatos com APIs de cliente de procedimento armazenado e UDF, como as seguintes:

• snowflake.snowpark.udf.UDFRegistration

• snowflake.snowpark.functions.sproc

Ao usá-las, especifique os seguintes parâmetros:

• ARTIFACT_REPOSITORY

• PACKAGES

e fornecem o nome do pacote no campo PACKAGES.

Veja o exemplo a seguir:

...
ARTIFACT_REPOSITORY="snowflake.snowpark.pypi_shared_repository",
PACKAGES=["urllib3", "requests"],
...

Copy

Solução de problemas¶

Se a instalação do pacote falhar para a parte de criação da função ou procedimento, execute o seguinte comando pip localmente para verificar se a especificação do pacote é válida:

pip install <package name> --only-binary=:all: --python-version 3.12 –platform <platform_tag>

Limitações¶

• Não há suporte para o acesso a repositórios privados.

• Você não pode usar esse recurso diretamente no Notebooks. No entanto, você pode usar um UDF ou procedimento armazenado que usa pacotes PyPI dentro de um notebook.

• Você não pode usar o repositório de artefatos em procedimentos armazenados anônimos.

Termos de licenciamento¶

• No Snowflake: regido por seu contrato de cliente existente do Snowflake, incluindo as restrições de uso do Anaconda descritas nesta documentação. Nenhum termo separado do Anaconda se aplica para uso no Snowflake.

• Desenvolvimento local: da de Snowflake Repositório dedicado do Anaconda : Sujeito aos Termos de cliente final incorporado do Anaconda e aos Termos de serviço do Anaconda publicados no repositório. O uso local é limitado ao desenvolvimento/teste de cargas de trabalho destinadas à implantação no Snowflake.

Diretrizes do usuário¶

Como encontrar e gerenciar pacotes¶

Não consegue encontrar um pacote de que precisa?

• Envio de solicitações por meio da Fórum de ideias do Snowflake.

• Os pacotes Python puros (sem extensões compiladas) podem ser carregado diretamente em um estágio do Snowflake.

Suporte e segurança¶

Exibição e utilização de pacotes¶

select * from information_schema.packages where language = 'python';

select * from information_schema.packages where (package_name = 'numpy' and language = 'python');

desc function stock_sale_average(varchar, number, number);

Desempenho em warehouses frios¶

Para uma gestão mais eficiente dos recursos, warehouse virtuais recém-provisionados não pré-instalam pacotes do Anaconda. Em vez disso, pacotes do Anaconda são instalados sob demanda na primeira vez que uma UDF é usada. Os pacotes ficam estão em cache para futura execução da UDF no mesmo warehouse. O cache é abandonado quando o warehouse é suspenso. Isso pode resultar em um desempenho mais lento na primeira vez que uma UDF é usado ou depois que o warehouse volta a funcionar. A latência adicional pode ser de aproximadamente 30 segundos.

Desempenho com previsão de linha única¶

Alguns frameworks de ciência de dados, como Scikit-learn e TensorFlow, podem ser lentos ao fazer previsões de linha única com ML. Para melhorar o desempenho, faça uma previsão em lotes em vez da previsão de linha única. Para fazer isso, você pode usar UDFs Python vetorizadas, com as quais poderá definir funções Python que recebem linhas de entrada em lotes, nas quais bibliotecas de aprendizado de máquina ou ciência de dados são otimizadas para operar. Para obter mais informações, consulte UDFs vetorizadas de Python.

Download de dados sob demanda de bibliotecas de ciência de dados¶

Algumas bibliotecas de ciência de dados, tais como NLTK, Keras e spaCy fornecem funcionalidade para download de corpora, dados ou modelos adicionais sob demanda.

Entretanto, o download sob demanda não funciona com UDFs de Python devido às restrições de segurança do Snowflake, que desativam algumas capacidades, como acesso à rede e escrita em arquivos.

Para contornar esse problema, baixe os dados para seu ambiente local e depois forneça-os para a UDF através de um estágio do Snowflake.

XGBoost¶

Ao usar XGBoost em UDF ou UDTF para previsão paralela ou treinamento, a concorrência para cada instância XGBoost deve ser definida como 1. Isso assegura que o XGBoost esteja configurado para um ótimo desempenho ao ser executado no ambiente Snowflake.

Exemplos:

import xgboost as xgb
model = xgb.Booster()
model.set_param('nthread', 1)
model.load_model(...)

import xgboost as xgb
model = xgb.XGBRegressor(n_jobs=1)

TensorFlow/Keras¶

Ao usar o Tensorflow/Keras para previsão, use Model.predict_on_batch e não Model.predict.

Exemplo:

import keras
model = keras.models.load_model(...)
model.predict_on_batch(np.array([input]))