सहायता Kaggle पर TensorFlow साथ ग्रेट बैरियर रीफ की रक्षा चैलेंज में शामिल हों

TensorFlow Cloud के साथ केरस मॉडल का प्रशिक्षण

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

परिचय

TensorFlow बादल एक अजगर पैकेज है कि एक सहज Google मेघ में वितरित प्रशिक्षण के लिए स्थानीय डिबगिंग से संक्रमण के लिए एपीआई प्रदान करता है। यह क्लाउड पर TensorFlow मॉडल को एकल, सरल फ़ंक्शन कॉल में प्रशिक्षित करने की प्रक्रिया को सरल करता है, जिसमें न्यूनतम सेटअप की आवश्यकता होती है और आपके मॉडल में कोई बदलाव नहीं होता है। TensorFlow Cloud क्लाउड-विशिष्ट कार्यों को संभालता है जैसे कि VM इंस्टेंस बनाना और आपके मॉडल के लिए वितरण रणनीतियाँ स्वचालित रूप से। यह मार्गदर्शिका प्रदर्शित करेगी कि कैसे TensorFlow Cloud के माध्यम से Google क्लाउड के साथ इंटरफ़ेस किया जाए, और TensorFlow Cloud के भीतर प्रदान की जाने वाली कार्यक्षमता की विस्तृत श्रृंखला। हम सबसे सरल उपयोग-मामले से शुरू करेंगे।

सेट अप

हम TensorFlow Cloud को स्थापित करके और इस गाइड में आवश्यक पैकेजों को आयात करके शुरू करेंगे।

pip install -q tensorflow_cloud
import tensorflow as tf
import tensorflow_cloud as tfc

from tensorflow import keras
from tensorflow.keras import layers
2021-07-27 22:07:16.348453: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0

एपीआई अवलोकन: पहला एंड-टू-एंड उदाहरण

आइए एक केरस मॉडल प्रशिक्षण स्क्रिप्ट से शुरू करें, जैसे कि निम्नलिखित सीएनएन:

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

model = keras.Sequential(
    [
        keras.Input(shape=(28, 28)),
        # Use a Rescaling layer to make sure input values are in the [0, 1] range.
        layers.experimental.preprocessing.Rescaling(1.0 / 255),
        # The original images have shape (28, 28), so we reshape them to (28, 28, 1)
        layers.Reshape(target_shape=(28, 28, 1)),
        # Follow-up with a classic small convnet
        layers.Conv2D(32, 3, activation="relu"),
        layers.MaxPooling2D(2),
        layers.Conv2D(32, 3, activation="relu"),
        layers.MaxPooling2D(2),
        layers.Conv2D(32, 3, activation="relu"),
        layers.Flatten(),
        layers.Dense(128, activation="relu"),
        layers.Dense(10),
    ]
)

model.compile(
    optimizer=keras.optimizers.Adam(),
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics=keras.metrics.SparseCategoricalAccuracy(),
)

model.fit(x_train, y_train, epochs=20, batch_size=128, validation_split=0.1)

इस मॉडल को Google मेघ पर हम सिर्फ करने के लिए एक फोन जोड़ने की जरूरत प्रशिक्षित करने के लिए run() स्क्रिप्ट की शुरुआत में, आयात से पहले:

tfc.run()

आपको TensorFlow Cloud का उपयोग करते समय VM इंस्टेंस और वितरण रणनीतियों जैसे क्लाउड-विशिष्ट कार्यों के बारे में चिंता करने की आवश्यकता नहीं है। एपीआई में सभी मापदंडों के लिए बुद्धिमान डिफ़ॉल्ट शामिल हैं - सब कुछ विन्यास योग्य है, लेकिन कई मॉडल इन डिफ़ॉल्ट पर भरोसा कर सकते हैं।

बुला पर run() , TensorFlow बादल करेंगे:

  • अपनी पायथन लिपि या नोटबुक वितरण के लिए तैयार करें।
  • इसे आवश्यक निर्भरताओं के साथ डॉकर छवि में परिवर्तित करें।
  • GCP GPU-संचालित VM पर प्रशिक्षण कार्य चलाएँ।
  • प्रासंगिक लॉग और नौकरी की जानकारी स्ट्रीम करें।

डिफ़ॉल्ट वीएम कॉन्फ़िगरेशन 8 सीपीयू कोर और 1 टेस्ला टी 4 जीपीयू के साथ 1 प्रमुख और 0 कर्मचारी हैं।

Google क्लाउड कॉन्फ़िगरेशन

क्लाउड प्रशिक्षण के लिए उचित मार्ग की सुविधा के लिए, आपको कुछ पहली बार सेटअप करने की आवश्यकता होगी। यदि आप एक नए Google क्लाउड उपयोगकर्ता हैं, तो आपको कुछ प्रारंभिक कदम उठाने होंगे:

  1. एक GCP प्रोजेक्ट बनाएं;
  2. एआई प्लेटफॉर्म सेवाओं को सक्षम करें;
  3. एक सेवा खाता बनाएँ;
  4. एक प्राधिकरण कुंजी डाउनलोड करें;
  5. क्लाउड स्टोरेज बकेट बनाएं।

विस्तृत पहली बार सेटअप निर्देशों में पाया जा सकता TensorFlow बादल README , और एक अतिरिक्त सेटअप उदाहरण पर दिखाया जाता है TensorFlow ब्लॉग

सामान्य कार्यप्रवाह और क्लाउड स्टोरेज

ज्यादातर मामलों में, आप Google क्लाउड पर प्रशिक्षण के बाद अपना मॉडल पुनः प्राप्त करना चाहेंगे। इसके लिए, दूरस्थ रूप से प्रशिक्षण के दौरान बचत और लोडिंग को क्लाउड स्टोरेज पर पुनर्निर्देशित करना महत्वपूर्ण है। हम विभिन्न कार्यों के लिए TensorFlow Cloud को अपने Cloud Storage बकेट पर निर्देशित कर सकते हैं। स्टोरेज बकेट का उपयोग बड़े प्रशिक्षण डेटासेट को सहेजने और लोड करने, कॉलबैक लॉग या मॉडल वेट को स्टोर करने और प्रशिक्षित मॉडल फ़ाइलों को सहेजने के लिए किया जा सकता है। शुरू करने के लिए, के लिए कॉन्फ़िगर करते हैं fit() प्रशिक्षण प्रगति को ट्रैक करने की निगरानी के लिए एक क्लाउड संग्रहण में मॉडल, और ऊपर TensorBoard सेट को बचाने के लिए।

def create_model():
    model = keras.Sequential(
        [
            keras.Input(shape=(28, 28)),
            layers.experimental.preprocessing.Rescaling(1.0 / 255),
            layers.Reshape(target_shape=(28, 28, 1)),
            layers.Conv2D(32, 3, activation="relu"),
            layers.MaxPooling2D(2),
            layers.Conv2D(32, 3, activation="relu"),
            layers.MaxPooling2D(2),
            layers.Conv2D(32, 3, activation="relu"),
            layers.Flatten(),
            layers.Dense(128, activation="relu"),
            layers.Dense(10),
        ]
    )

    model.compile(
        optimizer=keras.optimizers.Adam(),
        loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
        metrics=keras.metrics.SparseCategoricalAccuracy(),
    )
    return model

आइए हमारे क्लाउड स्टोरेज बकेट में प्रशिक्षण के दौरान उत्पन्न TensorBoard लॉग और मॉडल चौकियों को सहेजें।

import datetime
import os

# Note: Please change the gcp_bucket to your bucket name.
gcp_bucket = "keras-examples"

checkpoint_path = os.path.join("gs://", gcp_bucket, "mnist_example", "save_at_{epoch}")

tensorboard_path = os.path.join(  # Timestamp included to enable timeseries graphs
    "gs://", gcp_bucket, "logs", datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
)

callbacks = [
    # TensorBoard will store logs for each epoch and graph performance for us.
    keras.callbacks.TensorBoard(log_dir=tensorboard_path, histogram_freq=1),
    # ModelCheckpoint will save models after each epoch for retrieval later.
    keras.callbacks.ModelCheckpoint(checkpoint_path),
    # EarlyStopping will terminate training when val_loss ceases to improve.
    keras.callbacks.EarlyStopping(monitor="val_loss", patience=3),
]

model = create_model()
2021-07-27 22:07:18.825259: I tensorflow/core/profiler/lib/profiler_session.cc:126] Profiler session initializing.
2021-07-27 22:07:18.825306: I tensorflow/core/profiler/lib/profiler_session.cc:141] Profiler session started.
2021-07-27 22:07:18.826514: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcuda.so.1
2021-07-27 22:07:19.524654: I tensorflow/core/profiler/internal/gpu/cupti_tracer.cc:1611] Profiler found 1 GPUs
2021-07-27 22:07:19.569799: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcupti.so.11.2
2021-07-27 22:07:19.574795: I tensorflow/core/profiler/lib/profiler_session.cc:159] Profiler session tear down.
2021-07-27 22:07:19.574958: I tensorflow/core/profiler/internal/gpu/cupti_tracer.cc:1743] CUPTI activity buffer flushed
2021-07-27 22:07:19.590994: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:19.592061: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-07-27 22:07:19.592100: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-07-27 22:07:19.595897: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublas.so.11
2021-07-27 22:07:19.595991: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublasLt.so.11
2021-07-27 22:07:19.597230: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcufft.so.10
2021-07-27 22:07:19.597581: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcurand.so.10
2021-07-27 22:07:19.598756: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusolver.so.11
2021-07-27 22:07:19.599746: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusparse.so.11
2021-07-27 22:07:19.599930: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudnn.so.8
2021-07-27 22:07:19.600043: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:19.601088: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:19.602037: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-07-27 22:07:19.602416: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2021-07-27 22:07:19.603033: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:19.604024: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-07-27 22:07:19.604096: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:19.605089: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:19.606005: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-07-27 22:07:19.606052: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-07-27 22:07:20.242028: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1258] Device interconnect StreamExecutor with strength 1 edge matrix:
2021-07-27 22:07:20.242067: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1264]      0 
2021-07-27 22:07:20.242076: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1277] 0:   N 
2021-07-27 22:07:20.242317: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:20.243478: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:20.244412: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-27 22:07:20.245277: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1418] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 14646 MB memory) -> physical GPU (device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0)
WARNING:tensorflow:Please add `keras.layers.InputLayer` instead of `keras.Input` to Sequential model. `keras.Input` is intended to be used by Functional model.
WARNING:tensorflow:Please add `keras.layers.InputLayer` instead of `keras.Input` to Sequential model. `keras.Input` is intended to be used by Functional model.

यहां, हम अपना डेटा सीधे केरस से लोड करेंगे। सामान्य तौर पर, अपने डेटासेट को अपने क्लाउड स्टोरेज बकेट में स्टोर करना सबसे अच्छा अभ्यास है, हालांकि TensorFlow Cloud स्थानीय रूप से संग्रहीत डेटासेट को भी समायोजित कर सकता है। यह इस गाइड के मल्टी-फाइल सेक्शन में शामिल है।

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

TensorFlow बादल एपीआई प्रदान करता है remote() समारोह का निर्धारण करने के कोड स्थानीय या बादल पर निष्पादित किया जा रहा है या नहीं। इस के अलग-अलग पद के लिए अनुमति देता है fit() मापदंडों स्थानीय और दूरस्थ निष्पादन के लिए, और अपने स्थानीय मशीन अधिक भार के बिना आसान डिबगिंग के लिए साधन प्रदान करता है।

if tfc.remote():
    epochs = 100
    callbacks = callbacks
    batch_size = 128
else:
    epochs = 5
    batch_size = 64
    callbacks = None

model.fit(x_train, y_train, epochs=epochs, callbacks=callbacks, batch_size=batch_size)
2021-07-27 22:07:21.458608: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:176] None of the MLIR Optimization Passes are enabled (registered 2)
2021-07-27 22:07:21.459072: I tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 2000170000 Hz
Epoch 1/5
2021-07-27 22:07:21.885085: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudnn.so.8
2021-07-27 22:07:23.986122: I tensorflow/stream_executor/cuda/cuda_dnn.cc:359] Loaded cuDNN version 8100
2021-07-27 22:07:29.307903: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublas.so.11
2021-07-27 22:07:29.684317: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublasLt.so.11
938/938 [==============================] - 12s 3ms/step - loss: 0.2065 - sparse_categorical_accuracy: 0.9374
Epoch 2/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0577 - sparse_categorical_accuracy: 0.9822
Epoch 3/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0415 - sparse_categorical_accuracy: 0.9868
Epoch 4/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0332 - sparse_categorical_accuracy: 0.9893
Epoch 5/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0275 - sparse_categorical_accuracy: 0.9915
<tensorflow.python.keras.callbacks.History at 0x7f7b0c66a390>

आइए प्रशिक्षण पूरा होने के बाद मॉडल को GCS में सहेजें।

save_path = os.path.join("gs://", gcp_bucket, "mnist_example")

if tfc.remote():
    model.save(save_path)

हम इस स्टोरेज बकेट का उपयोग आपके स्थानीय डॉकर इंस्टेंस के बजाय डॉकर इमेज बिल्डिंग के लिए भी कर सकते हैं। इस के लिए, बस करने के लिए अपने बाल्टी जोड़ने docker_image_bucket_name पैरामीटर।

tfc.run(docker_image_bucket_name=gcp_bucket)

मॉडल को प्रशिक्षित करने के बाद, हम सहेजे गए मॉडल को लोड कर सकते हैं और प्रदर्शन की निगरानी के लिए हमारे TensorBoard लॉग देख सकते हैं।

model = keras.models.load_model(save_path)
!tensorboard dev upload --logdir "gs://keras-examples-jonah/logs/fit" --name "Guide MNIST"

बड़े पैमाने पर परियोजनाएं

कई मामलों में, केरस मॉडल वाली आपकी परियोजना में एक से अधिक पायथन स्क्रिप्ट शामिल हो सकती हैं, या इसमें बाहरी डेटा या विशिष्ट निर्भरताएं शामिल हो सकती हैं। TensorFlow Cloud बड़े पैमाने पर परिनियोजन के लिए पूरी तरह से लचीला है, और आपकी परियोजनाओं की सहायता के लिए कई बुद्धिमान कार्यात्मकता प्रदान करता है।

प्रवेश बिंदु: पायथन लिपियों और ज्यूपिटर नोटबुक के लिए समर्थन

आपकी कॉल-टू run() एपीआई हमेशा अपने मॉडल प्रशिक्षण कोड के रूप में ही अजगर स्क्रिप्ट के अंदर निहित नहीं किया जाएगा। इस प्रयोजन के लिए, हम एक प्रदान entry_point पैरामीटर। entry_point पैरामीटर जो अपने मॉडल प्रशिक्षण कोड जीवन में अजगर स्क्रिप्ट या नोटबुक निर्दिष्ट करने के लिए इस्तेमाल किया जा सकता। जब बुला run() अपने मॉडल के रूप में एक ही स्क्रिप्ट से, का उपयोग entry_point के डिफ़ॉल्ट None

pip निर्भरता

अतिरिक्त पर अपनी परियोजना कॉल तो pip निर्भरता, यह एक को शामिल करके अतिरिक्त आवश्यक पुस्तकालयों निर्दिष्ट करने के लिए संभव है requirements.txt फ़ाइल। इस फ़ाइल में, बस सभी आवश्यक निर्भरताओं की एक सूची डालें और TensorFlow Cloud इन्हें आपके क्लाउड बिल्ड में एकीकृत करने का काम संभालेगा।

पायथन नोटबुक

TensorFlow Cloud को Python नोटबुक से भी चलाया जा सकता है। साथ ही, आपके द्वारा निर्दिष्ट entry_point एक नोटबुक अगर जरूरत हो सकता है। स्क्रिप्ट की तुलना में नोटबुक्स पर TensorFlow Cloud के बीच ध्यान रखने योग्य दो प्रमुख अंतर हैं:

  • जब बुला run() एक नोटबुक के भीतर से, एक क्लाउड मेमोरी बकेट के निर्माण और अपने डोकर छवि भंडारण के लिए निर्दिष्ट किया जाना चाहिए।
  • GCloud प्रमाणीकरण पूरी तरह से आपकी प्रमाणीकरण कुंजी के माध्यम से होता है, बिना प्रोजेक्ट विनिर्देश के। नोटबुक से TensorFlow Cloud का उपयोग करने वाले वर्कफ़्लो का एक उदाहरण इस मार्गदर्शिका के "सभी को एक साथ रखना" अनुभाग में प्रदान किया गया है।

मल्टी-फाइल प्रोजेक्ट

यदि आपका मॉडल अतिरिक्त फ़ाइलों पर निर्भर करता है, तो आपको केवल यह सुनिश्चित करने की आवश्यकता है कि ये फ़ाइलें निर्दिष्ट प्रविष्टि बिंदु की एक ही निर्देशिका (या उपनिर्देशिका) में रहती हैं। कि निर्दिष्ट उसी निर्देशिका में संग्रहीत किया जाता है हर फ़ाइल entry_point डोकर छवि है, साथ ही के निकट उपनिर्देशिका में संग्रहीत किसी भी फाइल में शामिल किया जाएगा entry_point । इस निर्भरता के माध्यम से हासिल नहीं किया जा सकता है जो आप की आवश्यकता हो सकती के लिए भी सच है pip

एक कस्टम प्रवेश बिंदु और अतिरिक्त पिप निर्भरता के साथ बहु फ़ाइल परियोजना का एक उदाहरण के लिए, पर इस बहु-फ़ाइल उदाहरण पर एक नज़र डालें TensorFlow बादल भंडार । संक्षिप्तता के लिए, हम सिर्फ उदाहरण के शामिल करेंगे run() कॉल:

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    entry_point="train_model.py",
    requirements="requirements.txt"
)

मशीन विन्यास और वितरित प्रशिक्षण

मॉडल या डेटासेट के आकार के आधार पर मॉडल प्रशिक्षण के लिए विभिन्न संसाधनों की एक विस्तृत श्रृंखला की आवश्यकता हो सकती है। जब कई GPUs के साथ विन्यास के लिए लेखांकन, यह एक फिटिंग का चयन करने के लिए महत्वपूर्ण हो जाता है वितरण रणनीति । यहां, हम कुछ संभावित कॉन्फ़िगरेशन की रूपरेखा तैयार करते हैं:

बहु-कार्यकर्ता वितरण

यहाँ, हम उपयोग कर सकते हैं COMMON_MACHINE_CONFIGS 1 मुख्य सीपीयू और 4 कार्यकर्ता GPUs नामित करने के लिए।

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    chief_config=tfc.COMMON_MACHINE_CONFIGS['CPU'],
    worker_count=2,
    worker_config=tfc.COMMON_MACHINE_CONFIGS['T4_4X']
)

डिफ़ॉल्ट रूप से, TensorFlow बादल एक सरल सूत्र का उपयोग कर के साथ अपने मशीन विन्यास के लिए सबसे अच्छा वितरण रणनीति चुनता chief_config , worker_config और worker_count मापदंडों प्रदान की है।

टीपीयू वितरण

आइए टीपीयू पर उसी मॉडल को प्रशिक्षित करें, जैसा कि दिखाया गया है:

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    chief_config=tfc.COMMON_MACHINE_CONFIGS["CPU"],
    worker_count=1,
    worker_config=tfc.COMMON_MACHINE_CONFIGS["TPU"]
)

कस्टम वितरण रणनीति

एक कस्टम वितरण रणनीति निर्दिष्ट करने के लिए, सामान्य रूप से अपने कोड प्रारूप के रूप में आप के अनुसार होगा वितरित प्रशिक्षण गाइड और सेट distribution_strategy को None । नीचे, हम उसी MNIST मॉडल के लिए अपनी स्वयं की वितरण रणनीति निर्दिष्ट करेंगे।

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

mirrored_strategy = tf.distribute.MirroredStrategy()
with mirrored_strategy.scope():
  model = create_model()

if tfc.remote():
    epochs = 100
    batch_size = 128
else:
    epochs = 10
    batch_size = 64
    callbacks = None

model.fit(
    x_train, y_train, epochs=epochs, callbacks=callbacks, batch_size=batch_size
)

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    chief_config=tfc.COMMON_MACHINE_CONFIGS['CPU'],
    worker_count=2,
    worker_config=tfc.COMMON_MACHINE_CONFIGS['T4_4X'],
    distribution_strategy=None
)

कस्टम डॉकर छवियां

डिफ़ॉल्ट रूप से, TensorFlow बादल एक का उपयोग करता है डोकर आधार छवि Google द्वारा उपलब्ध कराए और अपने वर्तमान TensorFlow संस्करण के लिए इसी। हालाँकि, यदि आवश्यक हो, तो आप अपनी बिल्ड आवश्यकताओं को पूरा करने के लिए एक कस्टम डॉकर छवि भी निर्दिष्ट कर सकते हैं। इस उदाहरण के लिए, हम TensorFlow के पुराने संस्करण से डॉकर छवि निर्दिष्ट करेंगे:

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    base_docker_image="tensorflow/tensorflow:2.1.0-gpu"
)

अतिरिक्त मीट्रिक

आपको अपने क्लाउड जॉब को विशिष्ट लेबल के साथ टैग करना या क्लाउड प्रशिक्षण के दौरान अपने मॉडल के लॉग को स्ट्रीम करना उपयोगी लग सकता है। रिकॉर्ड रखने के लिए, सभी क्लाउड नौकरियों पर उचित लेबलिंग बनाए रखना एक अच्छा अभ्यास है। इस प्रयोजन के लिए run() 64 कुंजी-मान जोड़ों, जो बादल का निर्माण लॉग से दिखाई दे रहे हैं अप करने के लिए लेबल का एक शब्दकोश स्वीकार करता है। ऐसे युग प्रदर्शन और मॉडल की बचत आंतरिक रूप लॉग्स को क्रियान्वित करते हुए लिंक का उपयोग करके पहुँचा जा सकता है tfc.run या अपने स्थानीय का उपयोग कर टर्मिनल के लिए मुद्रित stream_logs झंडा।

job_labels = {"job": "mnist-example", "team": "keras-io", "user": "jonah"}

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    job_labels=job_labels,
    stream_logs=True
)

यह सब एक साथ डालें

बारे में गहराई से Colab जो इस गाइड में वर्णित सुविधाओं में से कई का उपयोग करता है के लिए, आगे बढ़ने के इस उदाहरण एक राज्य के अत्याधुनिक मॉडल को प्रशिक्षित करने की सुविधा निष्कर्षण का उपयोग करके फ़ोटो से कुत्ते नस्लों पहचान करने के लिए।