इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

अपाचे बीम के साथ बड़े डेटासेट बनाना

कुछ डेटासेट एक मशीन पर संसाधित होने के लिए बहुत बड़े हैं। tfds अपाचे बीम का उपयोग करके कई मशीनों में डेटा उत्पन्न करने का समर्थन करता है।

इस दस्तावेज़ के दो भाग हैं:

  • उपयोगकर्ता के लिए जो एक मौजूदा बीम डेटासेट उत्पन्न करना चाहते हैं
  • डेवलपर के लिए जो एक नया बीम डेटासेट बनाना चाहते हैं

विषयसूची:

एक बीम डेटासेट उत्पन्न करना

नीचे बादल या स्थानीय रूप से बीम डेटासेट उत्पन्न करने के विभिन्न उदाहरण हैं।

Google क्लाउड डेटाफ़्लो पर

Google क्लाउड डेटाफ़्लो का उपयोग करके पाइपलाइन चलाने और वितरित संगणना का लाभ उठाने के लिए, पहले Quickstart निर्देशों का पालन करें

एक बार जब आपका वातावरण सेट हो जाता है, तो आप GCS पर डेटा डायरेक्टरी का उपयोग करके --beam_pipeline_options ध्वज के लिए आवश्यक विकल्पों को निर्दिष्ट करके download_and_prepare स्क्रिप्ट चला सकते हैं।

स्क्रिप्ट को लॉन्च करना आसान बनाने के लिए, यह आपके GCP / GCS सेटअप के लिए वास्तविक मानों और उन डेटासेटों का उपयोग करने में निम्नलिखित चर को परिभाषित करने में मददगार है, जो आप उत्पन्न करना चाहते हैं:

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

फिर आपको श्रमिकों पर tfds स्थापित करने के लिए tfds बताने के लिए एक फ़ाइल बनाने की आवश्यकता होगी:

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

यदि आप tfds-nightly का उपयोग कर रहे हैं, तो सुनिश्चित करें कि अंतिम रिलीज के बाद से डेटासेट अपडेट होने पर tfds-nightly से tfds-nightly सुनिश्चित करें।

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

अंत में, आप नीचे दिए गए आदेश का उपयोग करके कार्य लॉन्च कर सकते हैं:

 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"
 

स्थानीय स्तर पर

डिफ़ॉल्ट रूप से अपाचे बीम रनर का उपयोग करके अपनी स्क्रिप्ट चलाने के लिए, कमांड अन्य डेटासेट के समान है:

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

एक कस्टम स्क्रिप्ट के साथ

बीम पर डेटासेट उत्पन्न करने के लिए, API अन्य डेटासेट के समान है, लेकिन आपको बीम विकल्प या रनर को 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,
)
 

बीम डेटासेट लागू करना

आवश्यक शर्तें

अपाचे बीम डेटासेट लिखने के लिए, आपको निम्नलिखित अवधारणाओं से परिचित होना चाहिए:

अनुदेश

यदि आप डेटासेट निर्माण मार्गदर्शिका से परिचित हैं , तो बीम डेटासेट जोड़ने से केवल कुछ संशोधनों की आवश्यकता होती है:

  • आपका DatasetBuilder से प्राप्त कर लेंगे tfds.core.BeamBasedBuilder बजाय tfds.core.GeneratorBasedBuilder
  • बीम डेटासेट सार विधि को लागू करना चाहिए _build_pcollection(self, **kwargs) के बजाय विधि _generate_examples(self, **kwargs)_build_pcollection को एक beam.PCollection लौटना चाहिए। विभाजन के साथ जुड़े उदाहरणों के साथ।
  • आपके बीम डेटासेट के लिए एक यूनिट टेस्ट लिखना अन्य डेटासेट के समान है।

कुछ अतिरिक्त विचार:

  • Apache Beam को आयात करने के लिए tfds.core.lazy_imports का उपयोग करें। आलसी निर्भरता का उपयोग करके, उपयोगकर्ता बीम को स्थापित किए बिना उत्पन्न होने के बाद भी डेटासेट पढ़ सकते हैं।
  • पायथन क्लोजर से सावधान रहें। पाइपलाइन चलाते समय, beam.Map और beam.DoFn कार्यों को pickle का उपयोग करके क्रमबद्ध किया जाता है और सभी श्रमिकों को भेजा जाता है। यह कीड़े पैदा कर सकता है; उदाहरण के लिए, यदि आप अपने कार्यों में एक परिवर्तनशील वस्तु का उपयोग कर रहे हैं, जिसे फ़ंक्शन के बाहर घोषित किया गया है, तो आप pickle त्रुटियों या अप्रत्याशित व्यवहार का सामना कर सकते हैं। फिक्स आमतौर पर बंद-ओवर ऑब्जेक्ट्स को म्यूट करने से बचने के लिए होता है।
  • बीम पाइपलाइन में DatasetBuilder पर विधियों का उपयोग करना ठीक है। हालांकि, अचार के दौरान जिस तरह से वर्ग को क्रमबद्ध किया जाता है, सृजन के दौरान सुविधाओं में किए गए बदलावों को सबसे अच्छा नजरअंदाज किया जाएगा।

उदाहरण

यहाँ बीम डेटासेट का एक उदाहरण दिया गया है। अधिक जटिल वास्तविक उदाहरण के लिए, Wikipedia डेटासेट पर एक नज़र डालें।

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

 

अपनी पाइपलाइन चला रहा है

पाइपलाइन चलाने के लिए, उपरोक्त अनुभाग पर एक नज़र डालें।

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