Entwickeln von Features¶

Snowflake ML ermöglicht es Ihnen, Ihre Rohdaten in Features umzuwandeln, was eine effiziente Nutzung durch Machine Learning-Modelle ermöglicht. Sie können Daten mit verschiedenen Ansätzen transformieren, die jeweils für unterschiedliche Umfänge und Anforderungen geeignet sind:

Open Source-Software(OSS)-Präprozessoren – Für kleine bis mittelgroße Datensets und schnelles Prototyping verwenden Sie vertraute Python ML-Bibliotheken, die lokal oder auf einzelnen Knoten innerhalb von Container Runtime ausgeführt werden.
Snowflake ML-Präprozessoren – Für größere Datensets verwenden Sie Vorverarbeitungs-APIs von Snowflake ML, die nativ auf der Snowflake-Plattform ausgeführt werden. Diese APIs verteilen der Verarbeitung auf die Computeressourcen des Warehouses.
Ray map_batches – Für eine hochgradig anpassbare, umfangreiche Verarbeitung, insbesondere mit unstrukturierten Daten, verwenden Sie eine parallele, ressourcenverwaltete Ausführung in Container Runtime-Umgebungen mit einem oder mehreren Knoten.

Wählen Sie den Ansatz, der Ihrem Datenumfang, Ihren Leistungsanforderungen und Ihrem Bedarf an kundenspezifischer Transformationslogik am besten entspricht.

Die folgende Tabelle zeigt einen detaillierten Vergleich der drei Hauptansätze für das Feature-Engineering in Snowflake ML:

Feature/Aspekt	OSS (einschließlich scikit-learn)	Snowflake ML-Präprozessoren	Ray `map_batches`
Skalierung	Kleine und mittelgroße Datensets	Große/verteilte Daten	Große/verteilte Daten
Ausführungsumgebung	Im Speicher	Pushdown zu dem Standard-Warehouse, das Sie für die Ausführung von SQL-Abfragen verwenden	Über mehrere Knoten in einem Computepool hinweg
Computeressourcen	Snowpark Container Services (Computepool)	Warehouse	Snowpark Container Services (Computepool)
Integration	Standardmäßiges Python ML-Ökosystem	Lässt sich nativ in Snowflake ML integrieren	Beide mit Python ML und Snowflake
Verarbeitungsleistung	Schnell für lokale, speicherinterne Workloads; Skalierung eingeschränkt und nicht verteilt	Für skalierbares, verteiltes Feature-Engineering entwickelt	Hochgradig parallel und ressourcenverwaltet, bietet hervorragende Leistung bei umfangreichen/unstrukturierten Daten
Eignung für Anwendungsfälle	Schnelles Prototyping und Experimentieren	Produktions-Workflows mit großen Datensets	Große Daten-Workflows, die benutzerdefinierte Ressourcenkontrollen erfordern

Die folgenden Beispiele zeigen, wie Sie Feature-Transformationen mit den einzelnen Ansätzen implementieren können:

Verwenden Sie den folgenden Code, um scikit-learn für Ihre Vorverarbeitungs-Workflows zu implementieren:

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

Snowflake ML-Präprozessoren verarbeiten verteilte Transformationen direkt in Snowflake. Diese Präprozessoren werden übergeben, um sie über Warehouses hinweg zu skalieren. Verwenden Sie Snowflake ML-Präprozessoren für große Datensets und Produktions-Workloads.

Bemerkung

Die Snowflake ML-Präprozessoren sind eine Teilmenge der in scikit-learn verfügbaren Präprozessoren, decken aber die gängigsten Anwendungsfälle ab. Informationen zu den verfügbaren Präprozessoren finden Sie unter Snowflake ML-Modellierungs-Vorverarbeitung.

Der folgende Code verwendet die StandardScaler- und OneHotEncoder-Bibliotheken.

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

Verwenden Sie Ray für die verteilte, parallele Verarbeitung mit benutzerdefinierten Transformationen. Ray map_batches verwendet die Ausführung im Lazy-Modus, d. h. die Verarbeitung erfolgt erst, wenn Sie die Datensets materialisieren, wodurch der Verbrauch an Arbeitsspeicher reduziert werden kann. Dieser Ansatz ist ideal für die Verarbeitung großer Datenmengen mit kundenspezifischer Logik:

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