 TensorFlow.org पर देखें |  Google Colab में चलाएँ |  GitHub पर देखें |  नोटबुक डाउनलोड करें |  कागल में भागो |
यह उदाहरण EfficientNet के साथ फ़ाइन-ट्यूनिंग के माध्यम से छवि वर्गीकरण पर आधारित है, यह प्रदर्शित करने के लिए कि वितरित प्रशिक्षण का उपयोग करके बड़े पैमाने पर टेंसरफ़्लो_क्लाउड और Google क्लाउड प्लेटफ़ॉर्म का उपयोग करके एक नैसनेटमोबाइल मॉडल को कैसे प्रशिक्षित किया जाए।
आवश्यक मॉड्यूल आयात करें
import tensorflow as tf
tf.version.VERSION
'2.6.0'
! pip install -q tensorflow-cloud
import tensorflow_cloud as tfc
tfc.__version__
import sys
प्रोजेक्ट कॉन्फ़िगरेशन
प्रोजेक्ट पैरामीटर सेट करें. Google क्लाउड विशिष्ट पैरामीटर के लिए Google क्लाउड प्रोजेक्ट सेटअप निर्देश देखें।
# 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 = 'nasnet'
# 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 क्लाउड एसडीके" पर क्लिक करें।
# 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), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()
# Setting input specific parameters
# The model expects input of dimension (INPUT_IMG_SIZE, INPUT_IMG_SIZE, 3)
INPUT_IMG_SIZE = 32
NUM_CLASSES = 10
छवि संवर्द्धन के लिए प्रीप्रोसेसिंग लेयर्स एपीआई जोड़ें।
from tensorflow.keras.layers.experimental import preprocessing
from tensorflow.keras.models import Sequential
img_augmentation = Sequential(
[
# Resizing input to better match ImageNet size
preprocessing.Resizing(256, 256),
preprocessing.RandomRotation(factor=0.15),
preprocessing.RandomFlip(),
preprocessing.RandomContrast(factor=0.1),
],
name="img_augmentation",
)
मॉडल लोड करें और प्रशिक्षण के लिए तैयारी करें
हम एक NASNetMobile पूर्व-प्रशिक्षित मॉडल (वजन के साथ) लोड करेंगे और डेटासेट से बेहतर मिलान के लिए मॉडल को ठीक से ट्यून करने के लिए कुछ परतों को अनफ़्रीज़ करेंगे।
from tensorflow.keras import layers
def build_model(num_classes, input_image_size):
inputs = layers.Input(shape=(input_image_size, input_image_size, 3))
x = img_augmentation(inputs)
model = tf.keras.applications.NASNetMobile(
input_shape=None,
include_top=False,
weights="imagenet",
input_tensor=x,
pooling=None,
classes=num_classes,
)
# Freeze the pretrained weights
model.trainable = False
# We unfreeze the top 20 layers while leaving BatchNorm layers frozen
for layer in model.layers[-20:]:
if not isinstance(layer, layers.BatchNormalization):
layer.trainable = True
# Rebuild top
x = layers.GlobalAveragePooling2D(name="avg_pool")(model.output)
x = layers.BatchNormalization()(x)
x = layers.Dense(128, activation="relu")(x)
x = layers.Dense(64, activation="relu")(x)
outputs = layers.Dense(num_classes, activation="softmax", name="pred")(x)
# Compile
model = tf.keras.Model(inputs, outputs, name="NASNetMobile")
optimizer = tf.keras.optimizers.Adam(learning_rate=3e-4)
model.compile(
optimizer=optimizer,
loss="sparse_categorical_crossentropy",
metrics=["accuracy"]
)
return model
model = build_model(NUM_CLASSES, INPUT_IMG_SIZE)
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)
else:
# 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 क्लाउड प्लेटफ़ॉर्म पर दूरस्थ रूप से वितरित प्रशिक्षण शुरू करेगा। एक बार नौकरी सबमिट हो जाने के बाद आप टेन्सरबोर्ड के माध्यम से नौकरी की प्रगति की निगरानी करने के लिए अगले चरण पर जा सकते हैं।
# 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 distributed training job using GPUs.
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'],
worker_config=tfc.COMMON_MACHINE_CONFIGS['K80_1X'],
worker_count=3,
job_labels={'job': JOB_NAME}
)
प्रशिक्षण परिणाम
अपने Colab इंस्टेंस को पुनः कनेक्ट करें
अधिकांश दूरस्थ प्रशिक्षण नौकरियाँ लंबे समय तक चलने वाली होती हैं। यदि आप कोलाब का उपयोग कर रहे हैं, तो प्रशिक्षण परिणाम उपलब्ध होने से पहले इसका समय समाप्त हो सकता है। उस स्थिति में, प्रशिक्षण परिणामों तक पहुंचने के लिए अपने कोलाब इंस्टेंस को फिर से कनेक्ट और कॉन्फ़िगर करने के लिए निम्नलिखित अनुभागों को दोबारा चलाएं। निम्नलिखित अनुभागों को क्रम से चलाएँ:
- आवश्यक मॉड्यूल आयात करें
- प्रोजेक्ट कॉन्फ़िगरेशन
- आपके Google क्लाउड प्रोजेक्ट का उपयोग करने के लिए नोटबुक को प्रमाणित किया जा रहा है
टेंसरबोर्ड लोड करें
जब प्रशिक्षण चल रहा हो तो आप परिणाम देखने के लिए टेन्सरबोर्ड का उपयोग कर सकते हैं। ध्यान दें कि परिणाम आपका प्रशिक्षण शुरू होने के बाद ही दिखाई देंगे। इसमें कुछ मिनट का समय लगेगा।
%load_ext tensorboard
%tensorboard --logdir $TENSORBOARD_LOGS_DIR
अपना प्रशिक्षित मॉडल लोड करें
trained_model = tf.keras.models.load_model(SAVED_MODEL_DIR)
trained_model.summary()