Conjuntos de dados do Snowflake¶
Conjuntos de dados são novos objetos de nível de esquema do Snowflake especialmente projetados para fluxos de trabalho de aprendizado de máquina. Os conjuntos de dados Snowflake contêm coleções de dados organizados em versões. Cada versão contém um instantâneo materializado de seus dados com imutabilidade garantida, acesso eficiente aos dados e interoperabilidade com estruturas populares de aprendizado profundo.
Use os conjuntos de dados Snowflake nas seguintes situações:
Você precisa gerenciar e versionar grandes conjuntos de dados para treinamento e teste reproduzíveis de modelos de aprendizado de máquina.
Você precisa de acesso detalhado em nível de arquivo e/ou embaralhamento de dados para treinamento distribuído ou streaming de dados.
Você precisa integrar com ferramentas e estruturas externas de aprendizado de máquina.
Você precisa rastrear a linhagem usada para criar um modelo de ML.
Os conjuntos de dados são objetos de dados materializados. Você pode usar os comandos do Snowflake ML ou comandos SQL para interagir com eles. Eles não aparecem no explorador de objetos do banco de dados do Snowsight.
Nota
Os conjuntos de dados geram custos de armazenamento. Exclua conjuntos de dados não utilizados para minimizar os custos.
Os conjuntos de dados criados antes do lançamento da disponibilidade geral em 20 de março de 2025 não são compatíveis com a replicação. Para obter mais informações, consulte Introdução à replicação e failover em várias contas.
Instalação¶
O conjunto de dados Python SDK está incluído no Snowpark ML (pacote Python snowflake-ml-python
) a partir da versão 1.7.5. Para instruções de instalação, consulte Como usar o Snowflake ML localmente.
Privilégios obrigatórios¶
A criação de conjuntos de dados requer o privilégio CREATE DATASET no nível de esquema. A modificação de conjuntos de dados, por exemplo, adicionando ou excluindo versões de conjuntos de dados, exige OWNERSHIP no conjunto de dados. A leitura de um conjunto de dados requer apenas o privilégio USAGE no conjunto de dados (ou OWNERSHIP). Para obter mais informações sobre como conceder privilégios no Snowflake, consulte GRANT <privilégios> … TO ROLE.
Dica
A configuração de privilégios para a Snowflake Feature Store usando o método setup_feature_store
ou o script SQL de configuração de privilégio também configura os privilégios do conjunto de dados. Se você já configurou privilégios de armazenamento de recursos por um desses métodos, nenhuma outra ação será necessária.
Criação e uso do conjuntos de dados¶
Você pode criar e gerenciar conjuntos de dados com SQL ou Python. Para obter informações sobre como usar os comandos SQL, consulte Comandos SQL. Para obter informações sobre como usar a Python API, consulte snowflake.ml.dataset.
Crie um conjunto de dados passando um Snowpark DataFrame para a função snowflake.ml.dataset.create_from_dataframe
.
from snowflake import snowpark
from snowflake.ml import dataset
# Create Snowpark Session
# See https://docs.snowflake.com/en/developer-guide/snowpark/python/creating-session
session = snowpark.Session.builder.configs(connection_parameters).create()
# Create a Snowpark DataFrame to serve as a data source
# In this example, we generate a random table with 100 rows and 1 column
df = session.sql(
"select uniform(0, 10, random(1)) as x, uniform(0, 10, random(2)) as y from table(generator(rowcount => 100))"
)
# Materialize DataFrame contents into a Dataset
ds1 = dataset.create_from_dataframe(
session,
"my_dataset",
"version1",
input_dataframe=df)
Os conjuntos de dados possuem versão. Cada versão é um instantâneo imutável e pontual dos dados gerenciados pelo conjunto de dados. A API de Python inclui uma propriedade Dataset.selected_version
que indica se um determinado conjunto de dados está selecionado para uso. Essa propriedade é definida automaticamente pelos métodos de fábrica dataset.create_from_dataframe
e dataset.load_dataset
, portanto, a criação de um conjunto de dados seleciona automaticamente a versão criada. Os métodos Dataset.select_version
e Dataset.create_version
também podem ser usados para alternar explicitamente entre versões. A leitura a partir de um conjunto de dados lê a versão selecionada ativa.
# Inspect currently selected version
print(ds1.selected_version) # DatasetVersion(dataset='my_dataset', version='version1')
print(ds1.selected_version.created_on) # Prints creation timestamp
# List all versions in the Dataset
print(ds1.list_versions()) # ["version1"]
# Create a new version
ds2 = ds1.create_version("version2", df)
print(ds1.selected_version.name) # "version1"
print(ds2.selected_version.name) # "version2"
print(ds1.list_versions()) # ["version1", "version2"]
# selected_version is immutable, meaning switching versions with
# ds1.select_version() returns a new Dataset object without
# affecting ds1.selected_version
ds3 = ds1.select_version("version2")
print(ds1.selected_version.name) # "version1"
print(ds3.selected_version.name) # "version2"
Leitura de dados de conjuntos de dados¶
Os dados da versão do conjunto de dados são armazenados como arquivos de tamanho uniforme no formato Apache Parquet. A classe Dataset
fornece uma API semelhante ao de FileSet para leitura de dados de conjuntos de dados Snowflake, incluindo conectores integrados para TensorFlow e PyTorch. A API é extensível para oferecer suporte a conectores de estrutura personalizados.
Ler um conjunto de dados requer uma versão selecionada ativa.
Conexão ao TensorFlow¶
Os conjuntos de dados podem ser convertidos em tf.data.Dataset
do TensorFlow e transmitidos em lotes para treinamento e avaliação eficientes.
import tensorflow as tf
# Convert Snowflake Dataset to TensorFlow Dataset
tf_dataset = ds1.read.to_tf_dataset(batch_size=32)
# Train a TensorFlow model
for batch in tf_dataset:
# Extract and build tensors as needed
input_tensor = tf.stack(list(batch.values()), axis=-1)
# Forward pass (details not included for brevity)
outputs = model(input_tensor)
Conexão ao PyTorch¶
Os conjuntos de dados também oferecem suporte à conversão em DataPipes do PyTorch e podem ser transmitidos em lotes para treinamento e avaliação eficientes.
import torch
# Convert Snowflake Dataset to PyTorch DataPipe
pt_datapipe = ds1.read.to_torch_datapipe(batch_size=32)
# Train a PyTorch model
for batch in pt_datapipe:
# Extract and build tensors as needed
input_tensor = torch.stack([torch.from_numpy(v) for v in batch.values()], dim=-1)
# Forward pass (details not included for brevity)
outputs = model(input_tensor)
Conexão ao Snowpark ML¶
Os conjuntos de dados também podem ser convertidos de volta em DataFrames Snowpark para integração com a modelagem do Snowpark ML. O DataFrame Snowpark convertido não é o mesmo DataFrame fornecido durante a criação do conjunto de dados, mas aponta para os dados materializados na versão do conjunto de dados.
from snowflake.ml.modeling.ensemble import random_forest_regressor
# Get a Snowpark DataFrame
ds_df = ds1.read.to_snowpark_dataframe()
# Note ds_df != df
ds_df.explain()
df.explain()
# Train a model in Snowpark ML
xgboost_model = random_forest_regressor.RandomForestRegressor(
n_estimators=100,
random_state=42,
input_cols=["X"],
label_cols=["Y"],
)
xgboost_model.fit(ds_df)
Acesso direto ao arquivo¶
A API do conjunto de dados também expõe uma interface fsspec, que pode ser usada para construir integrações personalizadas com bibliotecas externas como PyArrow, Dask ou qualquer outro pacote que suporte fsspec
e permite treinamento de modelos distribuídos e/ou baseados em fluxo.
print(ds1.read.files()) # ['snow://dataset/my_dataset/versions/version1/data_0_0_0.snappy.parquet']
import pyarrow.parquet as pq
pd_ds = pq.ParquetDataset(ds1.read.files(), filesystem=ds1.read.filesystem())
import dask.dataframe as dd
dd_df = dd.read_parquet(ds1.read.files(), filesystem=ds1.read.filesystem())
Usar SQL para ler a partir de uma versão de conjunto de dados¶
Você pode usar os comandos SQL padrão do Snowflake para ler os dados de uma versão de conjunto de dados. Você pode usar os comandos SQL para realizar as seguintes operações:
Listar arquivos
Inferir o esquema
Consultar dados diretamente do estágio.
Importante
Você deve ter o privilégio USAGE ou OWNERSHIP no conjunto de dados para ler a partir dele.
Listar arquivos a partir de uma versão de conjunto de dados¶
Use o comando LIST snow_url
para listar os arquivos em uma versão de conjunto de dados. Use a seguinte sintaxe SQL para listar todos os arquivos em uma versão de conjunto de dados:
LIST 'snow://dataset/<dataset_name>/versions/<dataset_version>'
Analisar arquivos e obter definições de colunas¶
Use a função INFER_SCHEMA para analisar arquivos em uma versão de conjunto de dados e recuperar definições de coluna. Use o seguinte exemplo SQL para listar todos os arquivos em uma versão de conjunto de dados:
INFER_SCHEMA(
LOCATION => 'snow://dataset/<dataset_name>/versions/<dataset_version>',
FILE_FORMAT => '<file_format_name>'
)
Você deve usar o padrão especificado no exemplo para obter o local da versão do conjunto de dados.
Para FILE_FORMAT
, especifique PARQUET
.
O exemplo a seguir cria um formato de arquivo e executa a função INFER_SCHEMA:
CREATE FILE FORMAT my_parquet_format TYPE = PARQUET;
SELECT *
FROM TABLE(
INFER_SCHEMA(
FILE_FORMAT => 'snow://dataset/MYDS/versions/v1,
FILE_FORMAT => 'my_parquet_format'
)
);
Consulta de estágio¶
Consulte dados diretamente dos arquivos armazenados em uma versão de conjunto de dados, de forma semelhante à consulta de uma tabela externa. Use o seguinte exemplo SQL para ajudar você a começar:
SELECT $1
FROM 'snow://dataset/foo/versions/V1'
( FILE_FORMAT => 'my_parquet_format',
PATTERN => '.*data.*' ) t;
Comandos SQL¶
Você pode usar os comandos SQL para criar e gerenciar conjuntos de dados. Para obter mais informações, consulte:
Limitações atuais e problemas conhecidos¶
Os nomes dos conjuntos de dados são identificadores SQL e sujeitos a requisitos do identificador Snowflake.
As versões do conjunto de dados são cadeias de caracteres e têm um comprimento máximo de 128 caracteres. Alguns caracteres não são permitidos e produzirão uma mensagem de erro.
Certas operações de consulta em conjuntos de dados com esquemas amplos (mais de 4.000 colunas) não são totalmente otimizadas. Isso deve melhorar nas próximas versões.