Fonctionnalités d’ingénierie¶

Snowflake ML vous permet de transformer vos données brutes en fonctionnalités, pour une utilisation efficace par les modèles de machine learning. Vous pouvez transformer des données selon plusieurs approches, chacune adaptée à différentes échelles et exigences :

Prétraitements Open Source Software (OSS) - Pour les ensembles de données de petite à moyenne taille et le prototypage rapide, utilisez des bibliothèques ML Python courantes qui s’exécutent localement ou sur des nœuds uniques dans Container Runtime.
Prétraitements Snowflake ML - Pour les ensembles de données plus importants, utilisez les APIs de prétraitement Snowflake ML qui s’exécutent nativement sur la plateforme Snowflake. Ces APIs répartissent le traitement entre les ressources informatiques de l’entrepôt.
map_batches Ray - Pour le traitement à grande échelle hautement personnalisable, en particulier avec des données non structurées, utilisez une exécution parallèle, gérée par les ressources, dans des environnements Container Runtime à un ou plusieurs nœuds.

Choisissez l’approche qui correspond le mieux à la taille de vos données, à vos exigences de performance et à la nécessité d’une logique de transformation personnalisée.

Le tableau suivant présente des comparaisons détaillées des trois principales approches de l’ingénierie des fonctionnalités dans Snowflake ML :

Fonctionnalité/Aspect	OSS (y compris scikit-learn)	Prétraitements Snowflake ML	`map_batches` Ray
Échelle	Ensembles de données de petite et moyenne taille	Données importantes/distribuées	Données importantes/distribuées
Environnement d’exécution	En mémoire	Pushdown vers l’entrepôt par défaut que vous utilisez pour exécuter des requêtes SQL	Sur les nœuds d’un pool de calcul
Ressources de calcul	Snowpark Container Services (pool de calcul)	Entrepôt	Snowpark Container Services (pool de calcul)
Intégration	Écosystème Python ML standard	S’intègre nativement à Snowflake ML	Les deux avec Python ML et Snowflake
Performance	Rapide pour les charges de travail locales et en mémoire ; échelle limitée et non distribuée	Conçu pour une ingénierie des fonctionnalités évolutive et distribuée	Hautement parallèle et géré en ressources, excelle dans les données volumineuses/non structurées
Adaptation du cas d’utilisation	Prototypage et expérimentation rapides	Workflows de production avec de grands ensembles de données	Workflows de grandes quantités de données nécessitant des contrôles personnalisés des ressources

Les exemples suivants montrent comment mettre en œuvre des transformations de fonctionnalités à l’aide de chaque approche :

Utilisez le code suivant pour mettre en œuvre scikit-learn pour vos workflows de prétraitement :

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)

Copy

Les prétraitements Snowflake ML gèrent les transformations distribuées directement dans Snowflake. Ces prétraitements sont déployés à grande échelle dans tous les entrepôts. Utilisez les prétraitements Snowflake ML pour les grands ensembles de données et les charges de travail de production.

Note

Les prétraitements Snowflake ML correspondent à un sous-ensemble des prétraitements disponibles dans sci-kit learn, mais ils couvrent les cas d’utilisation les plus courants. Pour plus d’informations sur les prétraitements disponibles, voir Prétraitement de modélisation Snowflake ML.

Le code suivant utilise les bibliothèques StandardScaler et OneHotEncoder.

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()

Copy

Utilisez Ray pour un traitement distribué et parallèle avec des transformations personnalisées. map_batches Ray utilise une exécution paresseuse, ce qui signifie que le traitement ne se produira pas tant que vous n’aurez pas matérialisé les ensembles de données, ce qui permet de réduire l’utilisation de la mémoire. Cette approche est idéale pour le traitement de données à grande échelle avec une logique personnalisée :

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)

Copy