Desenvolvimento do modelo Snowflake ML¶

Desenvolvimento de modelos¶

Com o Container Runtime para ML, disponível nos Notebooks no Container Runtime, é possível usar pacotes de ML populares de código aberto com seus dados Snowflake, aproveitando um ou mais nós de GPU, dentro da nuvem do Snowflake, garantindo segurança e governança para todo o fluxo de trabalho do ML. As APIs de carregamento de dados e treinamento inclusas são distribuídas automaticamente por todas as CPUs ou GPUs disponíveis em um nó, acelerando o treinamento do modelo com grandes conjuntos de dados.

Para obter mais informações, consulte Introdução ao Container Runtime dos notebooks Snowflake, que apresenta um fluxo de trabalho de ML simples aproveitando os recursos do Container Runtime para ML.

Junto com a flexibilidade e o poder do Container Runtime para ML, a Snowflake ML Modeling API fornece estimadores e transformadores que têm APIs semelhantes aos das bibliotecas scikit-learn, xgboost e lightgbm. É possível usar essas APIs para criar e treinar modelos de aprendizado de máquina que podem ser usados com o Snowflake ML Operations, como o Snowpark Model Registry.

Exemplos¶

Revise os exemplos a seguir para ter uma ideia das semelhanças da Snowflake Modeling API com as bibliotecas de aprendizado de máquina com as quais você pode estar familiarizado.

import numpy as np
import pandas as pd
import random
import string

from sklearn.datasets import make_regression
from snowflake.ml.modeling.preprocessing import MinMaxScaler, OrdinalEncoder
from snowflake.ml.modeling.pipeline import Pipeline
from snowflake.snowpark import Session

# Create a session with your preferred method
# session =

NUMERICAL_COLS = ["X1", "X2", "X3"]
CATEGORICAL_COLS = ["C1", "C2", "C3"]
FEATURE_COLS = NUMERICAL_COLS + CATEGORICAL_COLS
CATEGORICAL_OUTPUT_COLS = ["C1_OUT", "C2_OUT", "C3_OUT"]
FEATURE_OUTPUT_COLS = ["X1_FEAT_OUT", "X2_FEAT_OUT", "X3_FEAT_OUT", "C1_FEAT_OUT", "C2_FEAT_OUT", "C3_FEAT_OUT"]

# Create a dataset with numerical and categorical features
X, _ = make_regression(
    n_samples=1000,
    n_features=3,
    noise=0.1,
    random_state=0,
)
X = pd.DataFrame(X, columns=NUMERICAL_COLS)

def generate_random_string(length):
    return "".join(random.choices(string.ascii_uppercase, k=length))

categorical_feature_length = 2
categorical_features = {}
for c in CATEGORICAL_COLS:
    categorical_column = [generate_random_string(categorical_feature_length) for _ in range(X.shape[0])]
    categorical_features[c] = categorical_column

X = X.assign(**categorical_features)

features_df = session.create_dataframe(X)

# Fit a pipeline with OrdinalEncoder and MinMaxScaler on Snowflake
pipeline = Pipeline(
    steps=[
        (
            "OE",
            OrdinalEncoder(
                input_cols=CATEGORICAL_COLS,
                output_cols=CATEGORICAL_OUTPUT_COLS,
            )
        ),
        (
            "MMS",
            MinMaxScaler(
                input_cols=NUMERICAL_COLS + CATEGORICAL_OUTPUT_COLS,
                output_cols=FEATURE_OUTPUT_COLS,
            )
        ),
    ]
)

pipeline.fit(features_df)

# Use the pipeline to transform a dataset.
result = pipeline.transform(features_df)

from snowflake.ml.data.data_connector import DataConnector

# Retrieve data from a snowflake table
table_name = 'LARGE_TABLE_MULTIPLE_GBs'
snowpark_df = session.table(table_name)

# Materialize it into a pandas dataframe using DataConnector
pandas_df = DataConnector.from_dataframe(snowpark_df).to_pandas()

# Materialize it into a pytroch dataset using DataConnector
torch_dataset = data.to_torch_dataset(batch_size=1024)

import pandas as pd
from sklearn.datasets import make_classification

from snowflake.ml.modeling.xgboost import XGBClassifier
from snowflake.ml.utils.connection_params import SnowflakeLoginOptions
from snowflake.snowpark import Session

# Create a session with your preferred method
# session =

FEATURE_COLS = ["X1", "X2", "X3", "X4", "X5", "X6"]
LABEL_COLS = ["Y"]
OUTPUT_COLS = ["PREDICTIONS"]

# Set up data.
X, y = make_classification(
    n_samples=40000,
    n_features=6,
    n_informative=4,
    n_redundant=1,
    random_state=0,
    shuffle=True,
)

X = pd.DataFrame(X, columns=FEATURE_COLS)
y = pd.DataFrame(y, columns=LABEL_COLS)

features_pandas = pd.concat([X, y], axis=1)
features_df = session.create_dataframe(features_pandas)

# Train an XGBoost model on snowflake.
xgboost_model = XGBClassifier(
    input_cols=FEATURE_COLS,
    label_cols=LABEL_COLS,
    output_cols=OUTPUT_COLS
)

xgboost_model.fit(features_df)

# Use the model to make predictions.
predictions = xgboost_model.predict(features_df)
predictions[OUTPUT_COLS].show()

DATA_FILE_PATH = "~/Downloads/magic+gamma+telescope/magic04.data"

# Setup
from snowflake.ml.utils.connection_params import SnowflakeLoginOptions
from snowflake.snowpark import Session
import posixpath
import os

##
# Note: Create session https://docs.snowflake.com/en/developer-guide/snowpark/reference/python/latest/api/snowflake.snowpark.Session
##
session = Session.builder.configs(SnowflakeLoginOptions()).create()

session.sql("""
CREATE OR REPLACE TABLE Gamma_Telescope_Data(
    F_LENGTH FLOAT,
    F_WIDTH FLOAT,
    F_SIZE FLOAT,
    F_CONC FLOAT,
    F_CONC1 FLOAT,
    F_ASYM FLOAT,
    F_M3_LONG FLOAT,
    F_M3_TRANS FLOAT,
    F_ALPHA FLOAT,
    F_DIST FLOAT,
    CLASS VARCHAR(10))
""").collect()
session.sql("CREATE OR REPLACE STAGE SNOWPARK_ML_TEST_DATA_STAGE").collect()
session.file.put(
    DATA_FILE_PATH,
    "SNOWPARK_ML_TEST_DATA_STAGE/magic04.data",
    auto_compress=False,
    overwrite=True,
)

session.sql("""
COPY INTO Gamma_Telescope_Data FROM @SNOWPARK_ML_TEST_DATA_STAGE/magic04.data
FILE_FORMAT = (TYPE = 'CSV' field_optionally_enclosed_by='"',SKIP_HEADER = 0);
""").collect()

session.sql("select * from Gamma_Telescope_Data limit 5").collect()

from snowflake.ml.utils.connection_params import SnowflakeLoginOptions
from snowflake.snowpark import Session, DataFrame

from snowflake.ml.modeling.preprocessing import StandardScaler
from snowflake.ml.modeling.impute import SimpleImputer
from snowflake.ml.modeling.pipeline import Pipeline
from snowflake.ml.modeling.xgboost import XGBClassifier

from snowflake.ml.modeling.metrics import accuracy_score

##
# Note: Create session https://docs.snowflake.com/en/developer-guide/snowpark/reference/python/latest/api/snowflake.snowpark.Session
##
session = Session.builder.configs(SnowflakeLoginOptions()).create()

# Step 1: Create train and test dataframes
all_data = session.sql("select *, IFF(CLASS = 'g', 1.0, 0.0) as LABEL from Gamma_Telescope_Data").drop("CLASS")
train_data, test_data = all_data.random_split(weights=[0.9, 0.1], seed=0)

# Step 2: Construct training pipeline with preprocessing and modeling steps
FEATURE_COLS = [c for c in train_data.columns if c != "LABEL"]
LABEL_COLS = ["LABEL"]

pipeline = Pipeline(steps = [
    ("impute", SimpleImputer(input_cols=FEATURE_COLS, output_cols=FEATURE_COLS)),
    ("scaler", StandardScaler(input_cols=FEATURE_COLS, output_cols=FEATURE_COLS)),
    ("model", XGBClassifier(input_cols=FEATURE_COLS, label_cols=LABEL_COLS))
])

# Step 3: Train
pipeline.fit(train_data)

# Step 4: Eval
predict_on_training_data = pipeline.predict(train_data)
training_accuracy = accuracy_score(df=predict_on_training_data, y_true_col_names=["LABEL"], y_pred_col_names=["OUTPUT_LABEL"])

predict_on_test_data = pipeline.predict(test_data)
eval_accuracy = accuracy_score(df=predict_on_test_data, y_true_col_names=["LABEL"], y_pred_col_names=["OUTPUT_LABEL"])

print(f"Training accuracy: {training_accuracy} \nEval accuracy: {eval_accuracy}")

from snowflake.snowpark import Session, DataFrame
from snowflake.ml.utils.connection_params import SnowflakeLoginOptions

from sklearn.datasets import make_classification
from snowflake.snowpark import Session, DataFrame
from snowflake.ml.modeling.xgboost import XGBClassifier
from snowflake.ml.modeling.model_selection.grid_search_cv import GridSearchCV

FEATURE_COLS = ["X1", "X2", "X3", "X4", "X5", "X6"]
LABEL_COLS = ["Y"]
OUTPUT_COLS = ["PREDICTIONS"]

# Create a session using your favorite login option.
# In this example we use a session builder with `SnowflakeLoginOptions`.
session = Session.builder.configs(SnowflakeLoginOptions()).create()

# Set up data.
def set_up_data(session: Session, n_samples: int) -> DataFrame:
    X, y = make_classification(
        n_samples=n_samples,
        n_features=6,
        n_informative=2,
        n_redundant=0,
        random_state=0,
        shuffle=True,
    )

    X = pd.DataFrame(X, columns=FEATURE_COLS)
    y = pd.DataFrame(y, columns=LABEL_COLS)

    features_pandas = pd.concat([X, y], axis=1)
    features_pandas.head()

    features_df = session.create_dataframe(features_pandas)
    return features_df

features_df = set_up_data(session, 10**4)

# Create a warehouse to use for the tuning job.
session.sql(
    """
CREATE or replace warehouse HYPERPARAM_WH
    WITH WAREHOUSE_SIZE = 'X-SMALL'
    WAREHOUSE_TYPE = 'Standard'
    AUTO_SUSPEND = 60
    AUTO_RESUME = TRUE
    INITIALLY_SUSPENDED = FALSE;"""
).collect()
session.use_warehouse("HYPERPARAM_WH")

# Tune an XGB Classifier model using sklearn GridSearchCV.
DISTRIBUTIONS = dict(
    n_estimators=[10, 50],
    learning_rate=[0.01, 0.1, 0.2],
)
estimator = XGBClassifier()
grid_search_cv = GridSearchCV(estimator=estimator, param_grid=DISTRIBUTIONS, input_cols=FEATURE_COLS, label_cols=LABEL_COLS, output_cols=OUTPUT_COLS)

grid_search_cv.fit(features_df)

# Use the best model to make predictions.
predictions = grid_search_cv.predict(features_df)
predictions[OUTPUT_COLS].show()

# Retrieve sklearn model, and print the best score
sklearn_grid_search_cv = grid_search_cv.to_sklearn()
print(sklearn_grid_search_cv.best_score_)

large_features_df = set_up_data(session, 10**6)

# Scale up the warehouse for a faster fit. This takes 2m15s to run on an L warehouse versus 4m5s on a XS warehouse.
session.sql(f"ALTER WAREHOUSE {session.get_current_warehouse()} SET WAREHOUSE_SIZE='LARGE'").collect()

grid_search_cv.fit(large_features_df)
print(grid_search_cv.to_sklearn().best_score_)

Classes Snowflake Modeling¶

Todas as classes de modelagem e pré-processamento do Snowflake estão no namespace snowflake.ml.modeling. Os módulos snowflake-ml-python têm o mesmo nome que os módulos correspondentes do namespace sklearn. Por exemplo, o módulo correspondente a sklearn.calibration é snowflake.ml.modeling.calibration. O módulos xgboost e lightgbm correspondem a snowflake.ml.modeling.xgboost e snowflake.ml.modeling.lightgbm, respectivamente.

A API de modelagem fornece wrappers para classes scikit-learn, xgboost e lightgbm subjacentes, a maioria das quais são executadas como procedimentos armazenados (executados em um único nó de warehouse) no warehouse virtual. Nem todas as classes do scikit-learn são compatíveis. Consulte a Referência da API Python para obter uma lista das classes disponíveis atualmente.

Algumas classes (incluindo classes de pré-processamento e métricas) suportam a execução distribuída e podem fornecer benefícios significativos de desempenho em comparação com a execução local das mesmas operações. Para obter mais informações, consulte Pré-processamento distribuído e Otimização de hiperparâmetros distribuídos. A tabela abaixo lista as classes específicas que oferecem suporte à execução distribuída.

Diferenças gerais da API¶

As classes de modelagem do Snowflake incluem algoritmos de pré-processamento, transformação e previsão de dados baseados em scikit-learn, xgboost e lightgbm. As classes Snowpark Python são substituições para as classes correspondentes dos pacotes originais, com assinaturas semelhantes. No entanto, estas APIs são projetadas para funcionar com o Snowpark DataFrames em vez das matrizes NumPy.

Embora a API seja semelhante ao scikit-learn, existem algumas diferenças importantes. Esta seção explica como chamar os métodos __init__ (construtor), fit e predict para as classes estimadoras e transformadoras do Snowflake.

• O construtor de todas as classes do modelo Snowflake aceita cinco parâmetros adicionais (input_cols, output_cols, sample_weight_col, label_cols e drop_input_cols) além dos parâmetros aceitos pelas classes equivalentes em scikit-learn, xgboost ou lightgbm. São cadeias de caracteres, ou sequências de cadeias de caracteres, que especificam os nomes das colunas de entrada, colunas de saída, coluna de peso de amostra e colunas de rótulo em um DataFrame do Snowpark ou Pandas. Se alguns dos conjuntos de dados que você usa tiverem nomes diferentes, você pode alterar esses nomes após a instanciação usando um dos métodos setter fornecidos, como set_input_cols.

• Como você especifica nomes de colunas ao instanciar a classe (ou depois, usando métodos setter), os métodos fit e predict aceitam um único DataFrame em vez de matrizes separadas para entradas, pesos e rótulos. Os nomes das colunas fornecidos são usados para acessar a coluna apropriada do DataFrame em fit ou predict. Consulte fit e predict.

• Por padrão, os métodos transform e predict retornam um DataFrame com todas as colunas do DataFrame passado ao método, com a saída da previsão armazenada em colunas adicionais. Você pode transformar no local especificando os nomes das colunas de saída que correspondem aos nomes das colunas de entrada ou descartar as colunas de entrada passando drop_input_cols = True.) Os equivalentes scikit-learn, xgboost e lightgbm retornam matrizes contendo apenas os resultados.

• Os transformadores Snowpark Python não têm um método fit_transform. No entanto, como no scikit-learn, a validação de parâmetros é realizada apenas no método fit, então você deve chamar fit em algum momento antes de transform, mesmo quando o transformador não tem nenhum encaixe. fit retorna o transformador, então as chamadas de método podem ser encadeadas; por exemplo, Binarizer(threshold=0.5).fit(df).transform(df).

• Atualmente, os transformadores Snowflake não têm um método inverse_transform. Em muitos casos de uso, esse método é desnecessário porque as colunas de entrada são retidas no dataframe de saída por padrão.

É possível converter qualquer objeto de modelagem Snowflake no objeto scikit-learn, xgboost ou lightgbm correspondente, permitindo que você use todos os métodos e atributos do tipo subjacente. Consulte Recuperação do modelo subjacente.

from snowflake.ml.modeling.preprocessing import MinMaxScaler
from snowflake.snowpark import Session

# Snowflake identifiers are not case sensitive by default.
# These column names will be automatically updated to ["COLUMN_1", "COLUMN_2", "COLUMN_3"] by the Snowpark DataFrame.
schema = ["column_1", "column_2", "column_3"]
df = session.create_dataframe([[1, 2, 3]], schema = schema)
df.show()

--------------------------------------
|"COLUMN_1"  |"COLUMN_2"  |"COLUMN_3"|
--------------------------------------
|1           |2          |3          |
--------------------------------------

# Identify the column names using the Snowflake identifier.
input_cols = ["COLUMN_1", "COLUMN_2", "COLUMN_3"]
mms = MinMaxScaler(input_cols=input_cols)
mms.fit(df)

# To maintain lower case column names, include a double quote within the string.
schema = ['"column_1"', '"column_2"', '"column_3"']
df = session.create_dataframe([[1, 2, 3]], schema = schema)
df.show()

----------------------------------------
|'"column_1"'|'"column_2"'|'"column_3"'|
----------------------------------------
|1           |2           |3           |
----------------------------------------

# Since no conversion took place, the schema labels can be used as the column identifiers.
mms = MinMaxScaler(input_cols=schema)
mms.fit(df)

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier()

model.fit(
    X=df[feature_column_names], y=df[label_column_names], sample_weight=df[weight_column_name]
)

model.fit(df)

prediction_results = model.predict(X=df[feature_column_names])

prediction_results = model.predict(df)[output_column_names]

Treinamento distribuído e inferência com SPCS¶

Ao executar em um notebook Snowflake no Snowpark Container Services (SPCS), o treinamento e a inferência do modelo para essas classes de modelagem são executados no cluster de computação subjacente, não em um warehouse, e são distribuídos de forma transparente em todos os nós do cluster para empregar toda a capacidade de computação disponível.

As operações de pré-processamento e métricas são enviadas ao warehouse. Muitas classes de pré-processamento oferecem suporte à execução distribuída quando executadas no warehouse; consulte Pré-processamento distribuído.

Pré-processamento distribuído¶

Muitas funções de pré-processamento e transformação de dados do Snowflake são implementadas usando o mecanismo de execução distribuída do Snowflake, o que gera benefícios significativos de desempenho em comparação à execução de nó único (ou seja, procedimentos armazenados). Para descobrir quais funções oferecem suporte à execução distribuída, consulte Classes Snowflake Modeling.

O gráfico abaixo mostra números ilustrativos de desempenho em grandes conjuntos de dados públicos, executados em um warehouse médio otimizado pelo Snowpark, comparando o scikit-learn executado em procedimentos armazenados com as implementações distribuídas do Snowflake. Em muitos cenários, seu código pode ser executado de 25 a 50 vezes mais rápido ao usar classes de modelagem Snowflake.

Otimização de hiperparâmetros distribuídos¶

O ajuste de hiperparâmetros é parte integrante do fluxo de trabalho da ciência de dados. A API Snowflake fornece implementações distribuídas do scikit-learn GridSearchCV e APIs RandomizedSearchCV para permitir o ajuste eficiente de hiperparâmetros em warehouses de nó único e de vários nós.

import snowflake.ml.modeling.parameters.disable_distributed_hpo

O menor warehouse virtual Snowflake (XS) ou warehouse otimizado para Snowpark (M) tem um nó. Cada tamanho sucessivamente maior duplica o número de nós.

Para warehouses de nó único (XS), a capacidade total do nó é utilizada por padrão usando a estrutura de multiprocessamento joblib do scikit-learn.

Para warehouses com vários nós, as operações fit dentro do trabalho de ajuste de validação cruzada são distribuídas entre os nós. Nenhuma alteração de código é necessária para aumentar a escala. Os ajustes do estimador são executados em paralelo em todos os núcleos disponíveis em todos os nós do warehouse.

Como ilustração, considere o conjunto de dados habitacionais da Califórnia fornecido com a biblioteca scikit-learn. Os dados incluem 20.640 linhas de dados com as seguintes informações:

• MedInc: renda mediana no grupo de quarteirões

• HouseAge: idade média da residência no grupo de quarteirões

• AveRooms: número médio de cômodos por domicílio

• AveBedrms: número médio de quartos por domicílio

• População: a população do grupo de quarteirões

• AveOccup: número médio de membros da família

• Latitude e Longitude

O alvo do conjunto de dados é a renda média, expressa em centenas de milhares de dólares.

Neste exemplo, fazemos a validação cruzada de pesquisa em grade em um regressor aleatório para encontrar a melhor combinação de hiperparâmetros para prever a renda mediana.

from snowflake.ml.modeling.ensemble.random_forest_regressor import RandomForestRegressor
from snowflake.ml.modeling.model_selection.grid_search_cv import GridSearchCV
from sklearn import datasets

def load_housing_data() -> DataFrame:
    input_df_pandas = datasets.fetch_california_housing(as_frame=True).frame
    # Set the columns to be upper case for consistency with Snowflake identifiers.
    input_df_pandas.columns = [c.upper() for c in input_df_pandas.columns]
    input_df = session.create_dataframe(input_df_pandas)

    return input_df

input_df = load_housing_data()

# Use all the columns besides the median value as the features
input_cols = [c for c in input_df.columns if not c.startswith("MEDHOUSEVAL")]
# Set the target median value as the only label columns
label_cols = [c for c in input_df.columns if c.startswith("MEDHOUSEVAL")]


DISTRIBUTIONS = dict(
            max_depth=[80, 90, 100, 110],
            min_samples_leaf=[1,3,10],
            min_samples_split=[1.0, 3,10],
            n_estimators=[100,200,400]
        )
estimator = RandomForestRegressor()
n_folds = 5

clf = GridSearchCV(estimator=estimator, param_grid=DISTRIBUTIONS, cv=n_folds, input_cols=input_cols, label_cols=label_col)
clf.fit(input_df)

Este exemplo é executado em pouco mais de 7 minutos em um warehouse Medium (nó único) otimizado para Snowpark e leva apenas 3 minutos para ser executado em um warehouse X-Large.

Como implantar e executar seu modelo¶

O resultado do treinamento de um modelo é um objeto de modelo Python. Você pode usar o modelo treinado para fazer previsões chamando o método predict do modelo. Isso cria uma função temporária definida pelo usuário para executar o modelo em seu warehouse virtual Snowflake. Esta função é excluída automaticamente no final da sua sessão Snowflake (por exemplo, quando seu script termina ou quando você fecha seu notebook).

Para manter a função definida pelo usuário após o término da sessão, você pode criá-la manualmente. Consulte o Guia de início rápido sobre o tópico para obter mais informações.

O registro do modelo Snowflake também oferece suporte a modelos persistentes e facilita sua localização e implantação. Consulte Registro de modelo Snowflake.

Modelos personalizados particionados¶

O registro do modelo também oferece suporte a um tipo especial de modelo personalizado em que o ajuste e a inferência são executados em paralelo para um conjunto de partições. Essa pode ser uma maneira eficiente de criar muitos modelos de uma só vez a partir de um conjunto de dados e executar inferências imediatamente. Consulte Snowflake Model Registry: modelos personalizados particionados para obter mais detalhes.

Pipeline para múltiplas transformações¶

Com o scikit-learn, é comum executar uma série de transformações usando um pipeline. Os pipelines do scikit-learn não funcionam com classes Snowflake, portanto, uma versão Snowflake de sklearn.pipeline.Pipeline é fornecida para executar uma série de transformações. Esta classe está no pacote snowflake.ml.modeling.pipeline e funciona da mesma forma que a versão scikit-learn.

Recuperação do modelo subjacente¶

Os modelos de ML do Snowflake podem ser “desembrulhados”, ou seja, convertidos em tipos de modelo de terceiros subjacentes, com os seguintes métodos (dependendo da biblioteca):

• to_sklearn

• to_xgboost

• to_lightgbm

Todos os atributos e métodos do modelo subjacente podem então ser acessados e executados localmente no estimador. Por exemplo, no exemplo GridSearchCV, convertemos o estimador de pesquisa em grade em um objeto scikit-learn para recuperar a melhor pontuação.

best_score = grid_search_cv.to_sklearn().best_score_

Limitações conhecidas¶

• Atualmente, os estimadores e transformadores Snowflake não oferecem suporte a entradas ou respostas esparsas. Se você tiver dados esparsos, converta-os para um formato denso antes de passá-los aos estimadores ou transformadores do Snowflake.

• Atualmente, o pacote snowflake-ml-python não oferece suporte a tipos de dados de matriz. Qualquer operação em estimadores e transformadores que produzam uma matriz como resultado falha.

• Não há garantia de que a ordem das linhas nos dados de resultado corresponda à ordem das linhas nos dados de entrada.

• O ML do Snowflake ainda não oferece suporte ao DataFrames pandas on Snowflake. Converta o DataFrame pandas on Snowflake em um DataFrame Snowpark para usá-lo com as classes de modelagem Snowflake. O exemplo a seguir converte um DataFrame cuja leitura foi realizada a partir de uma tabela Snowflake:

  import modin.pandas as pd
  import snowflake.snowpark.modin.plugin
  from snowflake.ml.modeling.xgboost import XGBClassifier
  
  snowpark_pandas_df: modin.pandas.DataFrame = read_snowflake('MY_TABLE')
  # converting to Snowpark DataFrame adds an index column
  index_label_name = "_INDEX"
  snowpark_df = snowpark_pandas_df.to_snowpark(index=True, index_label=index_label_name)
  snowpark_df.show()
  

  Copy

  O DataFrame Snowpark resultante é o seguinte:

  --------------------------------------------------
  |"COLUMN_1"  |"COLUMN_2" |"TARGET"   |  "_INDEX" |
  --------------------------------------------------
  |1           |2          |3          |1          |
  --------------------------------------------------
  

  Copy

  O DataFrame pode então ser usado para treinar um classificador XGBoost da seguinte forma:

  # Identify the column names using the Snowflake identifier
  input_cols = ["COLUMN_1", "COLUMN_2", "COLUMN_3"]
  # Pass through the _INDEX column rather than using it for training
  xgb_clf = XGBClassifier(input_cols=input_cols, passthrough_cols=index_label_name, label_cols="TARGET")
  xgb_clf.fit(snowpark_df)
  

  Copy

Solução de problemas¶

import logging, sys

logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)

def fix_values(F, column):
    return F.upper(F.regexp_replace(F.col(column), "[^a-zA-Z0-9]+", "_"))

Leitura adicional¶

Consulte a documentação das bibliotecas originais para obter informações completas sobre sua funcionalidade.

• Scikit-Learn

• XGBoost

• LightGBM

Aviso¶

Algumas partes deste documento são derivadas da documentação do Scikit-learn, que é licenciada sob a licença BSD-3 «Nova» ou «Revisada» e Copyright © 2007-2023 The scikit-learn developers. Todos os direitos reservados.

Algumas partes deste documento são derivadas da documentação XGboost, que é coberta pela licença Apache 2.0, janeiro de 2004 e Copyright © 2019. Todos os direitos reservados.

Algumas partes deste documento são derivadas da documentação LightGBM, que é licenciado para MIT e Copyright © Microsoft Corp. Todos os direitos reservados.