Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Generazione di grandi insiemi di dati con Apache Fascio

Alcuni gruppi di dati sono troppo grandi per essere elaborati su una singola macchina. tfds supporti la generazione di dati attraverso molte macchine utilizzando Apache fascio .

Questo documento ha due sezioni:

  • Per gli utenti che vogliono generare un set di dati esistente Fascio
  • Per developper che vogliono creare un nuovo set di dati del fascio

Tabella dei contenuti:

Generazione di un set di dati del fascio

Questi sono esempi diversi di generare un insieme di dati di fascio, sia sulla nuvola o localmente.

Su Google Cloud Dataflow

Per eseguire la pipeline utilizzando Google Cloud flusso di dati e approfittare di calcolo distribuito, in primo luogo seguire le istruzioni Quickstart .

Una volta che il vostro ambiente è impostato, è possibile eseguire il download_and_prepare script usando una directory di dati su GCS e specificando le opzioni necessarie per la --beam_pipeline_options bandiera.

Per rendere più facile per lanciare lo script, è utile per definire le seguenti variabili con i valori effettivi per la vostra GCP / setup GCS e il set di dati che si desidera generare:

 DATASET_NAME=<dataset-name>
DATASET_CONFIG=<dataset-config>
GCP_PROJECT=my-project-id
GCS_BUCKET=gs://my-gcs-bucket
 

Sarà quindi necessario creare un file di dire flusso di dati da installare tfds sui lavoratori:

 echo "tensorflow_datasets[$DATASET_NAME]" > /tmp/beam_requirements.txt
 

Se stai usando tfds-nightly , assicurarsi di echeggiare da tfds-nightly nel caso in cui l'insieme di dati è stata aggiornata dall'ultima release.

 echo "tfds-nightly[$DATASET_NAME]" > /tmp/beam_requirements.txt
 

Infine, è possibile avviare il processo utilizzando il seguente comando:

 python -m tensorflow_datasets.scripts.download_and_prepare \
  --datasets=$DATASET_NAME/$DATASET_CONFIG \
  --data_dir=$GCS_BUCKET/tensorflow_datasets \
  --beam_pipeline_options=\
"runner=DataflowRunner,project=$GCP_PROJECT,job_name=$DATASET_NAME-gen,"\
"staging_location=$GCS_BUCKET/binaries,temp_location=$GCS_BUCKET/temp,"\
"requirements_file=/tmp/beam_requirements.txt"
 

localmente

Per eseguire lo script in locale utilizzando il corridore di default di Apache Beam, il comando è lo stesso che per altri insiemi di dati:

 python -m tensorflow_datasets.scripts.download_and_prepare \
  --datasets=my_new_dataset
 

Con uno script personalizzato

Per generare il set di dati sul fascio, l'API è lo stesso che per gli altri insiemi di dati, ma è necessario passare le opzioni trave o corridore al DownloadConfig .

 # If you are running on Dataflow, Spark,..., you may have to set-up runtime
# flags. Otherwise, you can leave flags empty [].
flags = ['--runner=DataflowRunner', '--project=<project-name>', ...]

# To use Beam, you have to set at least one of `beam_options` or `beam_runner`
dl_config = tfds.download.DownloadConfig(
    beam_options=beam.options.pipeline_options.PipelineOptions(flags=flags)
)

data_dir = 'gs://my-gcs-bucket/tensorflow_datasets'
builder = tfds.builder('wikipedia/20190301.en', data_dir=data_dir)
builder.download_and_prepare(
    download_dir=FLAGS.download_dir,
    download_config=dl_config,
)
 

L'implementazione di un set di dati del fascio

Prerequisiti

Per scrivere set di dati Apache fascio, è necessario avere familiarità con i seguenti concetti:

Istruzioni

Se si ha familiarità con la Guida alla creazione di set di dati , l'aggiunta di un set di dati del fascio richiede solo poche modifiche:

  • Il tuo DatasetBuilder erediterà da tfds.core.BeamBasedBuilder invece di tfds.core.GeneratorBasedBuilder .
  • Dataset fascio devono implementare il metodo astratto _build_pcollection(self, **kwargs) invece del metodo _generate_examples(self, **kwargs) . _build_pcollection dovrebbe restituire un beam.PCollection con gli esempi associati con la scissione.
  • Scrivendo un test di unità per il set di dati del fascio è la stessa con altri insiemi di dati.

Alcune considerazioni aggiuntive:

  • Utilizzare tfds.core.lazy_imports importare Apache Beam. Utilizzando una dipendenza pigro, gli utenti possono comunque leggere il set di dati dopo che è stato generato senza dover installare Beam.
  • Fate attenzione con le chiusure Python. Quando si esegue la pipeline, le beam.Map e beam.DoFn funzioni vengono serializzati mediante pickle e inviato a tutti i lavoratori. Questo può creare bug; per esempio, se si utilizza un oggetto mutabile nelle funzioni che è stata dichiarata al di fuori della funzione, è possibile riscontrare pickle errori o comportamenti imprevisti. La correzione è in genere per evitare mutanti oggetti chiusi-over.
  • Utilizzando metodi sulla DatasetBuilder in cantiere Beam è bene. Tuttavia, il modo in cui la classe è serializzato durante salamoia, modifiche apportate alle funzioni durante la creazione verrà ignorato nella migliore delle ipotesi.

Esempio

Ecco un esempio di un insieme di dati Beam. Per un esempio vero e più complicata, hanno uno sguardo alla Wikipedia set di dati .

 class DummyBeamDataset(tfds.core.BeamBasedBuilder):

  VERSION = tfds.core.Version('1.0.0')

  def _info(self):
    return tfds.core.DatasetInfo(
        builder=self,
        features=tfds.features.FeaturesDict({
            'image': tfds.features.Image(shape=(16, 16, 1)),
            'label': tfds.features.ClassLabel(names=['dog', 'cat']),
        }),
    )

  def _split_generators(self, dl_manager):
    ...
    return [
        tfds.core.SplitGenerator(
            name=tfds.Split.TRAIN,
            gen_kwargs=dict(file_dir='path/to/train_data/'),
        ),
        splits_lib.SplitGenerator(
            name=tfds.Split.TEST,
            gen_kwargs=dict(file_dir='path/to/test_data/'),
        ),
    ]

  def _build_pcollection(self, pipeline, file_dir):
    """Generate examples as dicts."""
    beam = tfds.core.lazy_imports.apache_beam

    def _process_example(filename):
      # Use filename as key
      return filename, {
          'image': os.path.join(file_dir, filename),
          'label': filename.split('.')[1],  # Extract label: "0010102.dog.jpeg"
      }

    return (
        pipeline
        | beam.Create(tf.io.gfile.listdir(file_dir))
        | beam.Map(_process_example)
    )

 

Il funzionamento del vostro gasdotto

Per eseguire la pipeline, dare un'occhiata alla sezione precedente.

 python -m tensorflow_datasets.scripts.download_and_prepare \
  --register_checksums \
  --datasets=my_new_dataset