Recursos de engenharia¶

O Snowflake ML permite que você transforme seus dados brutos em recursos, permitindo o uso eficiente por modelos de aprendizado de máquina. É possível transformar dados usando várias abordagens, cada uma adequada para diferentes escalas e requisitos:

Software de código aberto (OSS) pré-processadores - Para conjuntos de dados pequenos a médios e prototipagem rápida, use os conhecidos em Python ML Bibliotecas executadas localmente ou em nós únicos no Container Runtime.
Snowflake ML Pré-processadores – Para conjuntos de dados maiores, use Snowflake MLPré-processamento do APIs que são executadas nativamente na plataforma Snowflake. estas APIs distribuem o processamento pelos recursos computacionais do warehouse.
Ray map_batches – Para processamento em grande escala altamente personalizável, especialmente com dados não estruturados, use execução paralela gerenciada por recursos em ambientes Container Runtime de nó único ou vários nós.

Escolha a abordagem que melhor corresponde ao tamanho dos seus dados, requisitos de desempenho e necessidade de lógica de transformação personalizada.

A tabela a seguir mostra comparações detalhadas de três abordagens principais para engenharia de recursos no Snowflake ML:


Recurso/Aspeto	OSS (incluindo scikit-learn)	Pré-processadores do Snowflake ML	Ray `map_batches`
Escala	Conjuntos de dados pequenos e médios	Dados grandes/distribuídos	Dados grandes/distribuídos
Ambiente de execução	Na memória	Pushdown para o warehouse padrão que você está usando para executar SQL Consultas	Entre nós em um pool de computação
Recursos de computação	Snowpark Container Services (pool de computação)	Warehouse	Snowpark Container Services (pool de computação)
Integração	de Python padrão ML Ecossistema	Integra-se nativamente com o Snowflake ML	Ambos com Python ML e Snowflake
Desempenho	rápido para cargas de trabalho locais na memória; escala limitada e não distribuída	projetado para engenharia de recursos escalável e distribuído	Altamente paralelo e gerenciado de recursos, destaca-se em dados grandes/não estruturados
Compatibilidade de casos de uso	Prototipagem e experimentação rápidas	Fluxos de trabalho de produção com grandes conjuntos de dados	Grandes fluxos de trabalho de dados que exigem controles de recursos personalizados

Os exemplos a seguir demonstram como implementar transformações de recurso usando cada abordagem:

Use o código a seguir para implementar o scikit-learn para seus fluxos de trabalho de pré-processamento:

import pandas as pd
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer

# Load your data locally into a Pandas DataFrame
df = pd.DataFrame({
    'age': [34, 23, 54, 31],
    'city': ['SF', 'NY', 'SF', 'LA'],
    'income': [120000, 95000, 135000, 99000]
})

# Define preprocessing steps
numeric_features = ['age', 'income']
numeric_transformer = StandardScaler()

categorical_features = ['city']
categorical_transformer = OneHotEncoder()

preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)
    ]
)

pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor)
])

# Preprocess the data
X_processed = pipeline.fit_transform(df)
print(X_processed)

Os pré-processadores do Snowflake ML manipulam transformações distribuídas diretamente no Snowflake. Esses pré-processadores são reduzidos para escalar nos warehouses. Uso do Snowflake ML pré-processadores para grandes conjuntos de dados e cargas de trabalho de produção.

Nota

A Snowflake ML Os pré-processadores são um subconjunto dos pré-processadores disponíveis no sci-kit aprendizado, mas cobrem os casos de uso mais comuns. Para obter informações sobre os pré-processadores disponíveis, consulte `Pré-processamento de modelagem do Snowflake ML<https://docs.snowflake.com/en/developer-guide/snowpark-ml/reference/latest/modeling#snowflake-ml-modeling-preprocessing>`_.

O código a seguir usa o StandardScaler e OneHotEncoder Bibliotecas.

from snowflake.snowpark import Session
from snowflake.ml.modeling.preprocessing import StandardScaler, OneHotEncoder
from snowflake.ml.modeling.pipeline import Pipeline

# Assume your Snowflake connection details are configured
session = Session.builder.configs(...).create()

# Load your data from a Snowflake table as a DataFrame
df = session.table('CUSTOMER_DATA')

# Define Snowflake ML preprocessors
scaler = StandardScaler(input_cols=['AGE', 'INCOME'], output_cols=['AGE_SCALED', 'INCOME_SCALED'])
encoder = OneHotEncoder(input_cols=['CITY'], output_cols=['CITY_ENCODED'])

pipeline = Pipeline(steps=[
    ('scaling', scaler),
    ('encoding', encoder)
])

# Fit and transform data in Snowflake (distributed)
result = pipeline.fit_transform(df)
result.show()

Use Ray para processamento distribuído e paralelo com transformações personalizadas. Rey map_batches usa execução lenta, o que significa que o processamento não acontecerá até que você materialize os conjuntos de dados, o que ajuda a reduzir o uso de memória. Essa abordagem é ideal para processamento de dados em grande escala com lógica personalizada:

import ray
from snowflake.ml.ray.datasource.stage_parquet_file_datasource import SFStageParquetDataSource
from snowflake.ml.data.data_connector import DataConnector

# Example for data transform
def preprocess_batch(batch: pd.DataFrame) -> pd.DataFrame:
    batch['AGE_SCALED'] = (batch['age'] - batch['age'].mean()) / batch['age'].std()
    return batch

# Example of filtering
def filter_by_value(row):
    return row['city'] != 'LA'

# Build Ray dataset from provided datasources
ray_ds = ray.data.read_datasource(data_source)

# Setup filter operations, not executed yet
filtered_ds = ray_ds.filter(filter_by_value)

transformed_ds = filtered_ds.map_batches(example_transform_batch_function)

# Create DataConnector directly from ray dataset
data_connector = DataConnector.from_ray_dataset(transformed_ds)