Snowpark ML FileSystem e FileSet — Obsoleto¶

Instalação¶

O FileSystem e FileSet APIs fazem parte do pacote Snowpark ML Python, snowflake-ml-python. Consulte Como usar o Snowflake ML localmente para obter instruções de instalação.

Criação e utilização de um sistema de arquivos¶

A criação de um sistema de arquivos Snowpark ML exige um objeto do conector Snowflake para Python Connection ou um Snowpark Python Session. Consulte Conexão ao Snowflake para obter instruções.

Depois de ter uma conexão ou uma sessão, você poderá criar uma instância do Snowpark ML SFFileSystem por meio da qual poderá acessar dados em seu estágio interno.

Se você tiver uma conexão do conector Snowflake para Python, passe-a como o argumento sf_connection:

import fsspec
from snowflake.ml.fileset import sfcfs

sf_fs1 = sfcfs.SFFileSystem(sf_connection=sf_connection)

Se você tiver uma sessão Snowpark Python, passe-a como o argumento snowpark_session:

import fsspec
from snowflake.ml.fileset import sfcfs

sf_fs2 = sfcfs.SFFileSystem(snowpark_session=sp_session)

SFFileSystem herda muitos recursos de fsspec.FileSystem, como armazenamento em cache local de arquivos. Você pode ativar esse e outros recursos instanciando um sistema de arquivos Snowflake por meio da função de fábrica fsspec.filesystem, passando target_protocol="sfc" para usar a implementação do FileSystem do Snowflake:

local_cache_path = "/tmp/sf_files/"
cached_fs = fsspec.filesystem("cached", target_protocol="sfc",
                    target_options={"sf_connection": sf_connection,
                                    "cache_types": "bytes",
                                    "block_size": 32 * 2**20},
                    cache_storage=local_cache_path)

O sistema de arquivos do Snowflake oferece suporte à maioria dos métodos somente leitura definidos para um fsspec FileSystem, incluindo find, info, isdir, isfile e exists.

print(*cached_fs.ls("@ML_DATASETS.public.my_models/sales_predict/"), end='\n')

path = '@ML_DATASETS.public.my_models/test/data_7_7_3.snappy.parquet'

with sf_fs1.open(path, mode='rb') as f:
    print(f.read(16))

import pyarrow.parquet as pq

table = pq.read_table(path, filesystem=sf_fs1)
table.take([1, 3])

path = "sfc://@ML_DATASETS.public.my_models/dataset.csv.gz"

with cached_fs.open(path, mode='rb', sf_connection=sf_connection) as f:
    g = gzip.GzipFile(fileobj=f)
    for i in range(3):
        print(g.readline())

Criação e utilização de um FileSet¶

Um FileSet do Snowflake representa um instantâneo imutável do resultado de uma consulta SQL na forma de arquivos em um estágio criptografado interno do lado do servidor. Esses arquivos podem ser acessados por meio de um FileSystem para alimentar dados em ferramentas como PyTorch e TensorFlow para que você possa treinar modelos em escala e dentro do seu modelo de governança de dados existente. Para criar um FileSet, use o método FileSet.make.

Você precisa de uma conexão Snowflake Python ou de uma sessão Snowpark para criar um FileSet. Consulte Conexão ao Snowflake para obter instruções. Você também deve fornecer o caminho para um estágio criptografado interno do servidor existente ou um subdiretório nesse estágio, onde o FileSet será armazenado.

Para criar um FileSet a partir de um DataFrame do Snowpark, construa um DataFrame e passe-o para FileSet.make como snowpark_dataframe; não chame o método collect do DataFrame:

# Snowpark Python equivalent of "SELECT * FROM MYDATA LIMIT 5000000"
df = snowpark_session.table('mydata').limit(5000000)
fileset_df = fileset.FileSet.make(
    target_stage_loc="@ML_DATASETS.public.my_models/",
    name="from_dataframe",
    snowpark_dataframe=df,
    shuffle=True,
)

Para criar um FileSet usando uma conexão do conector Snowflake para Python, transmita a conexão para Fileset.make como sf_connection e transmita a consulta SQL como query:

fileset_sf = fileset.FileSet.make(
    target_stage_loc="@ML_DATASETS.public.my_models/",
    name="from_connector",
    sf_connection=sf_connection,
    query="SELECT * FROM MYDATA LIMIT 5000000",
    shuffle=True,           # see later section about shuffling
)

Use o método files para obter uma lista dos arquivos no FileSet:

print(*fileset_df.files())

Para obter informações sobre como alimentar os dados em FileSet para PyTorch ou TensorFlow, consulte Alimentação de um FileSet para PyTorch ou Alimentação de um FileSet para TensorFlow, respectivamente.

Alimentação de um FileSet para PyTorch¶

A partir de um FileSet do Snowflake, você pode obter um PyTorch DataPipe, que pode ser passado para um PyTorch DataLoader. O DataLoader itera sobre os dados FileSet e produz tensores PyTorch em lote. Crie o DataPipe usando o método to_torch_datapipe de FileSet e depois passe o DataPipe para o DataLoader do PyTorch:

from torch.utils.data import DataLoader

# See later sections about shuffling and batching
pipe = fileset_df.to_torch_datapipe(
    batch_size=4,
    shuffle=True,
    drop_last_batch=True)

for batch in DataLoader(pipe, batch_size=None, num_workers=0):
    print(batch)
    break

Alimentação de um FileSet para TensorFlow¶

Você pode obter um conjunto de dados TensorFlow de um FileSet do Snowflake usando o método to_tf_dataset do FileSet:

import tensorflow as tf

# See following sections about shuffling and batching
ds = fileset_df.to_tf_dataset(
    batch_size=4,
    shuffle=True,
    drop_last_batch=True)

for batch in ds:
    print(batch)
    break

A iteração sobre o conjunto de dados produz tensores em lote.

Embaralhamento de dados em FileSets¶

Muitas vezes vale a pena embaralhar os dados de treinamento para evitar o sobreajuste e outros problemas. Para uma discussão sobre o valor do embaralhamento, consulte Por que os dados deveriam ser embaralhados para tarefas de machine learning?

Se sua consulta ainda não embaralhar seus dados o suficiente, um FileSet poderá embaralhar os dados em dois momentos:

• Quando o FileSet é criado usando FileSet.make.

  Todas as linhas da sua consulta são embaralhadas antes de serem gravadas no FileSet. Este é um embaralhamento global de alta qualidade e pode ser caro com conjuntos de dados grandes. Portanto, ele é realizado apenas uma vez, ao materializar o FileSet. Passe shuffle=True como argumento de palavra-chave para FileSet.make.

• Quando você cria um conjunto de dados PyTorch DataPipe ou TensorFlow a partir de um FileSet.

  Neste ponto, a ordem dos arquivos no FileSet é aleatória, assim como a ordem das linhas em cada arquivo. Isto pode ser considerado um embaralhamento global “aproximado”. Ele tem uma qualidade inferior em comparação com um verdadeiro embaralhamento global, mas é muito mais barato. Para embaralhar neste estágio, passe shuffle=True como um argumento de palavra-chave para o método to_torch_datapipe ou to_tf_dataset do FileSet.

Para obter melhores resultados, embaralhe duas vezes: ao criar o FileSet e ao alimentar os dados para PyTorch ou TensorFlow.

Colocação de dados em lote em FileSets¶

FileSets têm um recurso de lote que funciona da mesma forma que a funcionalidade de lote no PyTorch e TensorFlow, mas é mais eficiente. Snowflake recomenda que você use o parâmetro batch_size nos métodos to_torch_datapipe e to_tf_dataset de FileSet em vez de o PyTorch ou TensorFlow fazer a colocação em lote. Com PyTorch, para desativar sua funcionalidade de lote, você deve passar explicitamente batch_size=None ao instanciar DataLoader.

Você também pode descartar o último lote se ele estiver incompleto, passando drop_last_batch=True para to_torch_datapipe ou para to_tf_dataset.