 TensorFlow.org पर देखें |  Google Colab में चलाएं |  गिटहब पर देखें |  नोटबुक डाउनलोड करें |  Kaggle . में भागो |
TensorFlow Cloud एक लाइब्रेरी है जो Google क्लाउड पर Keras मॉडल का प्रशिक्षण और हाइपरपैरामीटर ट्यूनिंग करना आसान बनाती है।
TensorFlow Cloud के run API का उपयोग करके, आप अपना मॉडल कोड सीधे अपने Google क्लाउड खाते में भेज सकते हैं, और क्लाउड UI के साथ लॉगिन और इंटरैक्ट करने की आवश्यकता के बिना Google क्लाउड कंप्यूट संसाधनों का उपयोग कर सकते हैं (एक बार जब आप कंसोल में अपना प्रोजेक्ट सेट कर लेते हैं)।
इसका मतलब है कि आप अपने Google क्लाउड कंप्यूट संसाधनों का उपयोग सीधे एक पायथन नोटबुक के अंदर से कर सकते हैं: इस तरह की एक नोटबुक! आप सादे .py Python स्क्रिप्ट से Google क्लाउड पर मॉडल भी भेज सकते हैं।
सरल उदाहरण
TensorFlow Cloud और Google Cloud का उपयोग करके किसी मॉडल को दूरस्थ रूप से प्रशिक्षित करने का तरीका दिखाने के लिए यह एक सरल परिचयात्मक उदाहरण है।
यह कैसे काम करता है, इसका अंदाजा लगाने के लिए आप इसे पढ़ सकते हैं, या आप Google Colab में नोटबुक चला सकते हैं। नोटबुक चलाने के लिए Google क्लाउड खाते से कनेक्ट होने और अपनी साख और प्रोजेक्ट आईडी दर्ज करने की आवश्यकता होती है। यदि आपके पास अभी तक कोई खाता नहीं है या यह सुनिश्चित नहीं है कि कंसोल में प्रोजेक्ट कैसे सेट किया जाए, तो अपने Google क्लाउड खाते को सेट अप और कनेक्ट करना देखें।
आवश्यक मॉड्यूल आयात करें
import tensorflow as tf
tf.version.VERSION
'2.6.0'
! pip install -q tensorflow-cloud
import tensorflow_cloud as tfc
print(tfc.__version__)
import sys
परियोजना विन्यास
प्रोजेक्ट पैरामीटर सेट करें। यदि आप नहीं जानते कि आपका GCP_PROJECT_ID या GCS_BUCKET क्या होना चाहिए, तो अपने Google क्लाउड खाते को सेट अप और कनेक्ट करना देखें।
JOB_NAME वैकल्पिक है, और आप इसे किसी भी स्ट्रिंग पर सेट कर सकते हैं। यदि आप एक बड़ी परियोजना के हिस्से के रूप में कई प्रशिक्षण प्रयोग (उदाहरण के लिए) कर रहे हैं, तो आप उनमें से प्रत्येक को एक अद्वितीय JOB_NAME देना चाह सकते हैं।
# Set Google Cloud Specific parameters
# TODO: Please set GCP_PROJECT_ID to your own Google Cloud project ID.
GCP_PROJECT_ID = 'YOUR_PROJECT_ID'
# TODO: set GCS_BUCKET to your own Google Cloud Storage (GCS) bucket.
GCS_BUCKET = 'YOUR_GCS_BUCKET_NAME'
# DO NOT CHANGE: Currently only the 'us-central1' region is supported.
REGION = 'us-central1'
# OPTIONAL: You can change the job name to any string.
JOB_NAME = 'mnist'
# Setting location were training logs and checkpoints will be stored
GCS_BASE_PATH = f'gs://{GCS_BUCKET}/{JOB_NAME}'
TENSORBOARD_LOGS_DIR = os.path.join(GCS_BASE_PATH,"logs")
MODEL_CHECKPOINT_DIR = os.path.join(GCS_BASE_PATH,"checkpoints")
SAVED_MODEL_DIR = os.path.join(GCS_BASE_PATH,"saved_model")
अपने Google क्लाउड प्रोजेक्ट का उपयोग करने के लिए नोटबुक को प्रमाणित करना
यह कोड आपके मान्य Google क्लाउड क्रेडेंशियल्स और पहचान की जाँच करते हुए, नोटबुक को प्रमाणित करता है। यह सुनिश्चित करने के लिए if not tfc.remote() ब्लॉक के अंदर है कि यह केवल नोटबुक में चलाया जाता है, और Google क्लाउड पर नोटबुक कोड भेजे जाने पर नहीं चलाया जाएगा।
# Using tfc.remote() to ensure this code only runs in notebook
if not tfc.remote():
# Authentication for Kaggle Notebooks
if "kaggle_secrets" in sys.modules:
from kaggle_secrets import UserSecretsClient
UserSecretsClient().set_gcloud_credentials(project=GCP_PROJECT_ID)
# Authentication for Colab Notebooks
if "google.colab" in sys.modules:
from google.colab import auth
auth.authenticate_user()
os.environ["GOOGLE_CLOUD_PROJECT"] = GCP_PROJECT_ID
मॉडल और डेटा सेटअप
यहां से हम एमएनआईएसटी डेटासेट पर वर्गीकरण चलाने के लिए एक साधारण केरस मॉडल स्थापित करने की मूल प्रक्रिया का पालन कर रहे हैं।
डेटा लोड और विभाजित करें
कच्चे डेटा को पढ़ें और डेटा सेट को प्रशिक्षित और परीक्षण करने के लिए विभाजित करें।
(x_train, y_train), (_, _) = tf.keras.datasets.mnist.load_data()
x_train = x_train.reshape((60000, 28 * 28))
x_train = x_train.astype('float32') / 255
एक मॉडल बनाएं और प्रशिक्षण की तैयारी करें
एक साधारण मॉडल बनाएं और इसके लिए कुछ कॉलबैक सेट करें।
from tensorflow.keras import layers
model = tf.keras.Sequential([
tf.keras.layers.Dense(512, activation='relu', input_shape=(28 * 28,)),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(loss='sparse_categorical_crossentropy',
optimizer=tf.keras.optimizers.Adam(),
metrics=['accuracy'])
त्वरित सत्यापन प्रशिक्षण
हम यह सुनिश्चित करने के लिए मॉडल को एक (1) युग के लिए प्रशिक्षित करेंगे कि सब कुछ सही ढंग से सेट किया गया है, और हम उस प्रशिक्षण कमांड को if not में tfc.remote , ताकि यह केवल रनटाइम वातावरण में हो, जिसमें आप इसे पढ़ रहे हैं, तब नहीं जब इसे Google क्लाउड पर भेजा जाता है।
if not tfc.remote():
# Run the training for 1 epoch and a small subset of the data to validate setup
model.fit(x=x_train[:100], y=y_train[:100], validation_split=0.2, epochs=1)
दूरस्थ प्रशिक्षण के लिए तैयार करें
नीचे दिया गया कोड केवल तभी चलेगा जब नोटबुक कोड Google क्लाउड को भेजा जाएगा, न कि उस रनटाइम के अंदर जिसमें आप इसे पढ़ रहे हैं।
सबसे पहले, हम कॉलबैक सेट करते हैं जो:
- TensorBoard के लिए लॉग बनाएँ।
- चौकियां बनाएं और उन्हें ऊपर निर्दिष्ट चेकपॉइंट निर्देशिका में सहेजें।
- यदि नुकसान में पर्याप्त रूप से सुधार नहीं हो रहा है तो मॉडल प्रशिक्षण बंद कर दें।
फिर हम model.fit और model.save को कॉल करते हैं, जो (जब यह कोड Google क्लाउड पर चल रहा होता है) जो वास्तव में पूर्ण प्रशिक्षण (100 युग) चलाते हैं और फिर प्रशिक्षित मॉडल को ऊपर परिभाषित GCS बकेट और निर्देशिका में सहेजते हैं।
if tfc.remote():
# Configure Tensorboard logs
callbacks=[
tf.keras.callbacks.TensorBoard(log_dir=TENSORBOARD_LOGS_DIR),
tf.keras.callbacks.ModelCheckpoint(
MODEL_CHECKPOINT_DIR,
save_best_only=True),
tf.keras.callbacks.EarlyStopping(
monitor='loss',
min_delta =0.001,
patience=3)]
model.fit(x=x_train, y=y_train, epochs=100,
validation_split=0.2, callbacks=callbacks)
model.save(SAVED_MODEL_DIR)
दूरस्थ प्रशिक्षण शुरू करें
TensorFlow Cloud अपने स्थानीय निष्पादन वातावरण (इस नोटबुक) से सभी कोड लेता है, इसे लपेटता है, और निष्पादन के लिए Google क्लाउड को भेजता है। (इसीलिए if और if not tfc.remote रैपर महत्वपूर्ण हैं।)
यह चरण दूरस्थ निष्पादन के लिए इस नोटबुक से आपका कोड तैयार करेगा और फिर मॉडल को प्रशिक्षित करने के लिए Google क्लाउड प्लेटफ़ॉर्म पर दूरस्थ प्रशिक्षण कार्य प्रारंभ करेगा।
सबसे पहले हम tensorflow-cloud Python पैकेज को एक requirements.txt .txt फ़ाइल में जोड़ते हैं, जिसे इस नोटबुक में कोड के साथ भेजा जाएगा। आप यहां आवश्यकतानुसार अन्य पैकेज जोड़ सकते हैं।
फिर एक GPU और एक CPU छवि निर्दिष्ट की जाती है। आपको केवल एक या दूसरे को निर्दिष्ट करने की आवश्यकता है; GPU का उपयोग निम्नलिखित कोड में किया जाता है।
अंत में, TensorFlow क्लाउड का दिल: tfc.run पर कॉल करें। जब इसे इस नोटबुक के अंदर निष्पादित किया जाता है, तो इस नोटबुक के सभी कोड और इस निर्देशिका की शेष फ़ाइलों को पैक किया जाएगा और निष्पादन के लिए Google क्लाउड पर भेजा जाएगा। run विधि पर पैरामीटर निर्दिष्ट करते हैं कि GPU CPU छवियों का विवरण निर्दिष्ट किया गया है। आपको केवल एक या दूसरे को निर्दिष्ट करने की आवश्यकता है; GPU का उपयोग निम्नलिखित कोड में किया जाता है।
अंत में, TensorFlow क्लाउड का दिल: tfc.run पर कॉल करें। जब इसे इस नोटबुक के अंदर निष्पादित किया जाता है, तो इस नोटबुक के सभी कोड और इस निर्देशिका की शेष फ़ाइलों को पैक किया जाएगा और निष्पादन के लिए Google क्लाउड पर भेजा जाएगा। run विधि के पैरामीटर GPU और CPU छवियों का विवरण निर्दिष्ट करते हैं। आपको केवल एक या दूसरे को निर्दिष्ट करने की आवश्यकता है; GPU का उपयोग निम्नलिखित कोड में किया जाता है।
अंत में, TensorFlow क्लाउड का दिल: tfc.run पर कॉल करें। जब इसे इस नोटबुक के अंदर निष्पादित किया जाता है, तो इस नोटबुक के सभी कोड और इस निर्देशिका की शेष फ़ाइलों को पैक किया जाएगा और निष्पादन के लिए Google क्लाउड पर भेजा जाएगा। run विधि पर पैरामीटर निष्पादन पर्यावरण और उपयोग की जाने वाली वितरण रणनीति (यदि कोई हो) का विवरण निर्दिष्ट करते हैं।
एक बार जॉब सबमिट हो जाने के बाद आप Tensorboard के माध्यम से जॉब की प्रगति की निगरानी के लिए अगले चरण पर जा सकते हैं।
# If you are using a custom image you can install modules via requirements
# txt file.
with open('requirements.txt','w') as f:
f.write('tensorflow-cloud\n')
# Optional: Some recommended base images. If you provide none the system
# will choose one for you.
TF_GPU_IMAGE= "tensorflow/tensorflow:latest-gpu"
TF_CPU_IMAGE= "tensorflow/tensorflow:latest"
# Submit a single node training job using GPU.
tfc.run(
distribution_strategy='auto',
requirements_txt='requirements.txt',
docker_config=tfc.DockerConfig(
parent_image=TF_GPU_IMAGE,
image_build_bucket=GCS_BUCKET
),
chief_config=tfc.COMMON_MACHINE_CONFIGS['K80_1X'],
job_labels={'job': JOB_NAME}
)
प्रशिक्षण परिणाम
अपना Colab इंस्टेंस फिर से कनेक्ट करें
अधिकांश दूरस्थ प्रशिक्षण कार्य लंबे समय से चल रहे हैं। यदि आप Colab का उपयोग कर रहे हैं, तो प्रशिक्षण परिणाम उपलब्ध होने से पहले समय समाप्त हो सकता है।
उस स्थिति में, प्रशिक्षण परिणामों तक पहुँचने के लिए अपने Colab इंस्टेंस को फिर से जोड़ने और कॉन्फ़िगर करने के लिए निम्नलिखित अनुभागों को फिर से चलाएँ ।
- आवश्यक मॉड्यूल आयात करें
- परियोजना विन्यास
- अपने Google क्लाउड प्रोजेक्ट का उपयोग करने के लिए नोटबुक को प्रमाणित करना
शेष कोड को दोबारा न चलाएं।
लोड टेंसरबोर्ड
जबकि प्रशिक्षण जारी है, आप परिणाम देखने के लिए Tensorboard का उपयोग कर सकते हैं। ध्यान दें कि आपका प्रशिक्षण शुरू होने के बाद ही परिणाम दिखाई देंगे। इसमें कुछ मिनट लग सकते हैं।
%load_ext tensorboard
%tensorboard --logdir $TENSORBOARD_LOGS_DIR
अपना प्रशिक्षित मॉडल लोड करें
एक बार प्रशिक्षण पूरा हो जाने पर, आप ऊपर निर्दिष्ट जीसीएस बकेट से अपना मॉडल पुनः प्राप्त कर सकते हैं।
trained_model = tf.keras.models.load_model(SAVED_MODEL_DIR)
trained_model.summary()