TensorFlow 2.0 alpha अब जारी हो चुका है। इस फ्रेमवर्क का डीप लर्निंग समुदाय पर उल्लेखनीय प्रभाव है। प्रैक्टिशनर्स, शोधकर्ता और डेवलपर्स ने इसे बहुत पसंद किया है और पहले से कहीं अधिक तेजी से अपनाया है। यह उन मुख्य कारणों में से एक है जिनकी वजह से आज हम इतने शानदार डीप लर्निंग-सक्षम अनुप्रयोग देखते हैं। इसके साथ ही, TensorFlow 1.x के भी कुछ नकारात्मक पक्ष रहे हैं (अन्य कई फ्रेमवर्क्स की तरह)। जैसा कि Martin Wicke (TensorFlow टीम के सॉफ्टवेयर इंजीनियर) ने TF Dev Summit '19 के दौरान कहा -
हमने 1.0 के बाद से बहुत कुछ सीखा है।
विस्तृत यूज़र-बेस, GitHub इश्यूज़ आदि से मिली सीख के आधार पर TensorFlow टीम ने TensorFlow 2.0 alpha जारी किया, जिसमें प्रदर्शन, यूज़र अनुभव आदि के लिए कई महत्वपूर्ण सुधार शामिल हैं। यह आपको रैपिड प्रोटोटाइपिंग सक्षम करता है और कई आधुनिक डीप लर्निंग प्रैक्टिसेस को समेटे हुए है। इस लेख में, आप इन बदलावों में से कुछ को संक्षिप्त इम्प्लीमेंटेशन्स के ज़रिए समझेंगे।
ध्यान दें कि यहाँ चर्चा किए गए अपडेट लेखक के अनुसार सबसे महत्वपूर्ण हैं। इस लेख का अनुसरण करने के लिए आपको TensorFlow और Keras का कुछ पूर्व अनुभव चाहिए होगा। यदि आप TensorFlow और Keras पर रिफ्रेशर ढूंढ रहे हैं, तो ये संसाधन उपयोगी हो सकते हैं -
TensorFlow 2.0 में अपडेट करने के लिए Jupyter Notebook में यह लाइन चलाएँ:
!pip install tensorflow==2.0.0-alpha0
GPU वेरिएंट भी इसी तरह इंस्टॉल किया जा सकता है (पहले CUDA आवश्यक):
!pip install tensorflow-gpu==2.0.0-alpha0
इंस्टॉलेशन प्रक्रिया के बारे में और जानकारी आपको यहाँ मिलेगी।
जिन अपडेट्स का आप अध्ययन करेंगे, उनमें से कुछ में कोड इम्प्लीमेंटेशन शामिल हैं। ऐसे मामलों में आपको एक डेटासेट चाहिए होगा। इस लेख में आप UCI आर्काइव के Adult डेटासेट का उपयोग करेंगे।
import pandas as pd
columns =["Age","WorkClass","fnlwgt","Education","EducationNum","MaritalStatus","Occupation","Relationship","Race","Gender","CapitalGain","CapitalLoss","HoursPerWeek","NativeCountry","Income"]
data = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data',
header=None,
names=columns)
data.head()संचालित द्वारा
Age
WorkClass
fnlwgt
Education
EducationNum
MaritalStatus
Occupation
Relationship
Race
Gender
CapitalGain
CapitalLoss
HoursPerWeek
NativeCountry
Income
0
39
State-gov
77516
Bachelors
13
Never-married
Adm-clerical
Not-in-family
White
Male
2174
0
40
United-States
<=50K
1
50
Self-emp-not-inc
83311
Bachelors
13
Married-civ-spouse
Exec-managerial
Husband
White
Male
0
0
13
United-States
<=50K
2
38
Private
215646
HS-grad
9
Divorced
Handlers-cleaners
Not-in-family
White
Male
0
0
40
United-States
<=50K
3
53
Private
234721
11th
7
Married-civ-spouse
Handlers-cleaners
Husband
Black
Male
0
0
40
United-States
<=50K
4
28
Private
338409
Bachelors
13
Married-civ-spouse
Prof-specialty
Wife
Black
Female
0
0
40
Cuba
<=50K
यह डेटासेट एक बाइनरी क्लासिफिकेशन टास्क दर्शाता है: व्यक्तिगत विवरणों के आधार पर यह अनुमान लगाना कि कोई व्यक्ति सालाना $50k से अधिक कमाएगा या नहीं।
आइए कुछ बेसिक डेटा प्रीप्रोसेसिंग करते हैं और फिर 80:20 अनुपात में डेटा स्प्लिट सेट करते हैं:
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
import numpy as np
# Label Encode
le = LabelEncoder()
data = data.apply(le.fit_transform)# Segregate data features & convert into NumPy arrays
X = data.iloc[:,0:-1].values
y = data['Income'].values
# Split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=7)संचालित द्वारा
अब तक, आपके पास TensorFlow 2.0 इंस्टॉल के साथ एक कार्यशील वातावरण होना चाहिए और आपका डेटासेट वर्कस्पेस में लोड हो जाना चाहिए। अब आप अपडेट्स की ओर बढ़ सकते हैं।
1. डिफ़ॉल्ट रूप से ईगर एक्ज़ीक्यूशन
TensorFlow 2.0 में अब आपको सेशन बनाने और उसके भीतर कम्प्यूटेशनल ग्राफ चलाने की ज़रूरत नहीं है। 2.0 रिलीज़ में Eager execution डिफ़ॉल्ट रूप से सक्षम है ताकि आप अपने मॉडल तुरंत बना और चला सकें। आप चाहें तो eager execution को इस तरह डिसेबल कर सकते हैं:
tf.compat.v1.disable_eager_execution() (बशर्ते tensorflow को tf उपनाम के साथ इम्पोर्ट किया गया हो।)
यहाँ एक छोटा कोड-आधारित तुलना दी गई है जो यह अंतर दिखाती है -
2. tf.function और AutoGraph
जहाँ eager execution आपको इम्पेरेटिव प्रोग्रामिंग देता है, वहीं डिस्ट्रीब्यूटेड ट्रेनिंग, फुल-स्केल ऑप्टिमाइज़ेशन और प्रोडक्शन वातावरण में TensorFlow 1.x शैली का ग्राफ एक्ज़ीक्यूशन eager execution पर कुछ बढ़त देता है। TensorFlow 2.0 में आप ग्राफ-आधारित एक्ज़ीक्यूशन को और लचीले ढंग से बनाए रखते हैं। यह tf.function और AutoGraph से हासिल होता है।
tf.function अपने AutoGraph फीचर के माध्यम से Python-स्टाइल सिंटैक्स के साथ TensorFlow ग्राफ परिभाषित करने देता है। AutoGraph में if-statement, for-loop, while-loop, Iterators आदि सहित अच्छी-खासी Python संगतता है। हालांकि, कुछ सीमाएँ भी हैं। यहाँ आपको मौजूदा सपोर्ट्स की पूरी सूची मिलेगी। नीचे एक उदाहरण है जो दिखाता है कि केवल एक decorator के साथ TensorFlow ग्राफ परिभाषित करना कितना आसान है।
import tensorflow as tf
# Define the forward pass@tf.functiondefsingle_layer(x, y):return tf.nn.relu(tf.matmul(x, y))# Generate random data drawn from a uniform distribution
x = tf.random.uniform((2,3))
y = tf.random.uniform((3,5))
single_layer(x, y)संचालित द्वारा
<tf.Tensor: id=73, shape=(2,5), dtype=float32, numpy=array([[0.5779363,0.11255255,0.26296678,0.12809312,0.23484911],[0.5932371,0.1793559,0.2845083,0.23249313,0.21367362]],
dtype=float32)>संचालित द्वारा
ध्यान दें कि आपको फ़ंक्शन single_layer() चलाने के लिए कोई सेशन या प्लेसहोल्डर बनाने की ज़रूरत नहीं पड़ी। यह tf.function की उपयोगी खूबियों में से एक है। अंदर ही अंदर यह सभी आवश्यक ऑप्टिमाइज़ेशन करता है ताकि आपका कोड तेज़ी से चले।
3. tf.variable_scope की अब ज़रूरत नहीं
TensorFlow 1.x में, tf.layers को वेरिएबल्स की तरह इस्तेमाल करने और री-यूज़ करने के लिए आपको tf.variable ब्लॉक का उपयोग करना पड़ता था। लेकिन TensorFlow 2.0 में इसकी ज़रूरत नहीं रही। क्योंकि TensorFlow 2.0 में हाई-लेवल API के केंद्र में keras है, tf.layers से बनाए गए सभी लेयर्स को आसानी से tf.keras.Sequential डेफिनिशन में रखा जा सकता है। इससे कोड पढ़ना आसान हो जाता है और आप वेरिएबल्स व लॉसेज़ पर भी नज़र रख सकते हैं।
यहाँ एक उदाहरण है:
# Define the model
model = tf.keras.Sequential([
tf.keras.layers.Dropout(rate=0.2, input_shape=X_train.shape[1:]),
tf.keras.layers.Dense(units=64, activation='relu'),
tf.keras.layers.Dropout(rate=0.2),
tf.keras.layers.Dense(units=64, activation='relu'),
tf.keras.layers.Dropout(rate=0.2),
tf.keras.layers.Dense(units=1, activation='sigmoid')])# Get the output probabilities
out_probs = model(X_train.astype(np.float32), training=True)print(out_probs)संचालित द्वारा
tf.Tensor([[1.][0.12573627][1.]...[1.][1.][1.]], shape=(26048,1), dtype=float32)संचालित द्वारा
ऊपर के उदाहरण में, आपने केवल कच्ची आउटपुट प्रायिकताओं को पाने के लिए ट्रेनिंग डेटा को model से गुज़ारा। ध्यान दें कि यह केवल एक फॉरवर्ड पास है। आप, बेशक, अपना मॉडल ट्रेन भी कर सकते हैं -
model.compile(loss='binary_crossentropy', optimizer='adam')
model.fit(X_train, y_train,
validation_data=(X_test, y_test),
epochs=5, batch_size=64)संचालित द्वारा
मशीन लर्निंग शोध या औद्योगिक अनुप्रयोगों में अक्सर विशेष उपयोग मामलों के लिए कस्टम लेयर्स लिखने की आवश्यकता होती है। TensorFlow 2.0 कस्टम लेयर लिखना और मौजूदा लेयर्स के साथ उपयोग करना बेहद आसान बना देता है। आप अपने मॉडल के फॉरवर्ड पास को भी मनचाहे तरीके से कस्टमाइज़ कर सकते हैं।
कस्टम लेयर बनाने के लिए सबसे आसान विकल्प है tf.keras.layers की Layer क्लास को एक्सटेंड करना और फिर उसे अनुसार परिभाषित करना। आप एक कस्टम लेयर बनाएँगे और फिर उसकी फॉरवर्ड कम्प्यूटेशंस परिभाषित करेंगे। नीचे help(tf.keras.layers.Layer) चलाने का आउटपुट है। यह बताता है कि इसे पूरा करने के लिए आपको क्या-क्या निर्दिष्ट करना होगा:
ऊपर दिए स्निपेट से संकेत लेते हुए, आप -
कंस्ट्रक्टर में आउटपुट्स की संख्या परिभाषित करेंगे
build() मेथड में आप अपनी लेयर के लिए वेट्स जोड़ेंगे
अंत में call() मेथड में आप मैट्रिक्स मल्टिप्लिकेशन और relu() को चेन करके फॉरवर्ड पास परिभाषित करेंगे
classMyDenseLayer(tf.keras.layers.Layer):# Define the constructordef__init__(self, num_outputs):super(MyDenseLayer, self).__init__()
self.num_outputs = num_outputs
# Define the build function to add the weightsdefbuild(self, input_shape):
self.kernel = self.add_variable("kernel",
shape=[input_shape[-1],
self.num_outputs])# Define the forward passdefcall(self,input):
matmul = tf.matmul(input, self.kernel)return tf.nn.relu(matmul)# Initialize the layer with 10 output units
layer = MyDenseLayer(10)# Supply the input shape
layer(tf.random.uniform((10,3)))# Display the trainable parameters of the layerprint(layer.trainable_variables)संचालित द्वारा
[<tf.Variable 'my_dense_layer_7/kernel:0' shape=(3,10) dtype=float32, numpy=array([[0.43613756,0.21344548,0.37803996,0.65583944,0.11884308,0.13909656,0.30802298,0.5313586,0.04967308,0.32889426],[0.1680265,-0.59944266,-0.4014195,0.14887196,0.07071263,0.37862527,-0.5822403,-0.5963166,0.3106798,0.05353856],[-0.44345278,-0.23122305,-0.62959856,-0.43062705,0.13194847,-0.60124606,-0.62745696,0.12254918,-0.09806103,-0.45324165]],
dtype=float32)>]संचालित द्वारा
आप tf.keras की Model क्लास को एक्सटेंड करके एक से अधिक लेयर्स को कंपोज़ कर सकते हैं। मॉडल्स को कंपोज़ करने के बारे में अधिक आप यहाँ पढ़ सकते हैं।
5. मॉडल ट्रेनिंग में लचीलापन
TensorFlow लॉस फ़ंक्शन के संबंध में मॉडल पैरामीटर्स के ग्रेडिएंट्स की गणना करने के लिए ऑटोमैटिक डिफरेंशिएशन का उपयोग कर सकता है। tf.GradientTape एक संदर्भ में टेप बनाता है जिसका उपयोग TensorFlow उस टेप में प्रत्येक कम्प्यूटेशन से रिकॉर्ड किए गए ग्रेडिएंट्स का ट्रैक रखने के लिए करता है। इसे समझने के लिए, tf.keras.Model क्लास को एक्सटेंड करके थोड़ा लो-लेवल तरीके से एक मॉडल परिभाषित करते हैं।
from tensorflow.keras import Model
classCustomModel(Model):def__init__(self):super(CustomModel, self).__init__()
self.do1 = tf.keras.layers.Dropout(rate=0.2, input_shape=(14,))
self.fc1 = tf.keras.layers.Dense(units=64, activation='relu')
self.do2 = tf.keras.layers.Dropout(rate=0.2)
self.fc2 = tf.keras.layers.Dense(units=64, activation='relu')
self.do3 = tf.keras.layers.Dropout(rate=0.2)
self.out = tf.keras.layers.Dense(units=1, activation='sigmoid')defcall(self, x):
x = self.do1(x)
x = self.fc1(x)
x = self.do2(x)
x = self.fc2(x)
x = self.do3(x)return self.out(x)
model = CustomModel()संचालित द्वारा
ध्यान दें कि इस मॉडल की टोपोलॉजी बिल्कुल वैसी ही है जैसी आपने पहले परिभाषित की थी। ऑटोमैटिक डिफरेंशिएशन के साथ इस मॉडल को प्रशिक्षित करने के लिए, आपको लॉस फ़ंक्शन और ऑप्टिमाइज़र को अलग तरह से परिभाषित करना होगा -
loss_func = tf.keras.losses.BinaryCrossentropy()
optimizer = tf.keras.optimizers.Adam()संचालित द्वारा
अब आप वे मेट्रिक्स परिभाषित करेंगे जिनका उपयोग ट्रेनिंग के दौरान नेटवर्क के प्रदर्शन को मापने के लिए किया जाएगा। यहाँ प्रदर्शन से तात्पर्य मॉडल के लॉस और एक्यूरेसी से है।
# Average the loss across the batch size within an epoch
train_loss = tf.keras.metrics.Mean(name='train_loss')
train_acc = tf.keras.metrics.BinaryAccuracy(name='train_acc')
valid_loss = tf.keras.metrics.Mean(name='test_loss')
valid_acc = tf.keras.metrics.BinaryAccuracy(name='valid_acc')संचालित द्वारा
tf.data इनपुट डेटा पाइपलाइंस परिभाषित करने के लिए उपयोगिताएँ प्रदान करता है। जब आप बड़े डेटा वॉल्यूम से निपटते हैं तो यह विशेष रूप से उपयोगी होता है।
अब आप डेटा जेनरेटर परिभाषित करेंगे, जो मॉडल की ट्रेनिंग के दौरान बैचेज़ जेनरेट करेगा।
अब आप tf.GradientTape का उपयोग करके मॉडल ट्रेन करने के लिए तैयार हैं। सबसे पहले, आप एक मेथड परिभाषित करेंगे जो tf.data.DataSet का उपयोग करके अभी परिभाषित डेटा के साथ मॉडल ट्रेन करेगा। आप कम्प्यूटेशन में मिलने वाली स्पीडअप का लाभ लेने के लिए मॉडल ट्रेनिंग स्टेप्स को tf.function डेकोरेटर से भी रैप करेंगे।
मॉडल ट्रेनिंग और वैलिडेशन
# Train the model@tf.functiondefmodel_train(features, labels):# Define the GradientTape contextwith tf.GradientTape()as tape:# Get the probabilities
predictions = model(features)# Calculate the loss
loss = loss_func(labels, predictions)# Get the gradients
gradients = tape.gradient(loss, model.trainable_variables)# Update the weights
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
train_loss(loss)
train_acc(labels, predictions)संचालित द्वारा
# Validating the model@tf.functiondefmodel_validate(features, labels):
predictions = model(features)
t_loss = loss_func(labels, predictions)
valid_loss(t_loss)
valid_acc(labels, predictions)संचालित द्वारा
ऊपर दिए गए दोनों मेथड का उपयोग करके मॉडल को 5 epochs के लिए ट्रेन और वैलिडेट करें।
for epoch inrange(5):for features, labels in train_ds:
model_train(features, labels)for test_features, test_labels in test_ds:
model_validate(test_features, test_labels)
template ='Epoch {}, train_loss: {}, train_acc: {}, train_loss: {}, test_acc: {}'print(template.format(epoch+1,
train_loss.result(),
train_acc.result()*100,
valid_loss.result(),
valid_acc.result()*100))संचालित द्वारा
यह उदाहरण TensorFlow 2.0 के लेखकों के इस उदाहरण से प्रेरित है।
6. TensorFlow Datasets
नेटवर्क मॉडल के साथ सुरुचिपूर्ण ढंग से काम करने के लिए DataSets नाम का एक अलग मॉड्यूल उपयोग होता है। आप इसे पहले के उदाहरण में देख चुके हैं। इस सेक्शन में, आप देखेंगे कि MNIST डेटासेट को अपनी मनचाही तरह से कैसे लोड किया जा सकता है।
आप pip से tensorflow_datasets लाइब्रेरी इंस्टॉल कर सकते हैं। इंस्टॉल होने के बाद, आप तैयार हैं। यह आपकी डेटासेट कंस्ट्रक्शन पाइपलाइन को लचीले ढंग से तैयार करने में मदद करने के लिए कई यूटिलिटी फ़ंक्शंस देता है। इनके बारे में आप यहाँ और यहाँ और सीख सकते हैं। अब देखते हैं कि MNIST डेटासेट लोड करने के लिए डेटा इनपुट पाइपलाइन कैसे बनाई जा सकती है।
import tensorflow_datasets as tfds
# You can fetch the DatasetBuilder class by string
mnist_builder = tfds.builder("mnist")# Download the dataset
mnist_builder.download_and_prepare()# Construct a tf.data.Dataset: train and test
ds_train, ds_test = mnist_builder.as_dataset(split=[tfds.Split.TRAIN, tfds.Split.TEST])संचालित द्वारा
आप वार्निंग को नज़रअंदाज कर सकते हैं। देखें कि tensorflow_datasets ने पाइपलाइन को कितनी सहजता से संभाला।
# Prepare batches of 128 from the training set
ds_train = ds_train.batch(128)# Load in the dataset in the simplest way possiblefor features in ds_train:
image, label = features["image"], features["label"]संचालित द्वारा
अब आप लोड की गई इमेजेस के संग्रह में से पहली इमेज प्रदर्शित कर सकते हैं। ध्यान दें कि tensorflow_datasets eager मोड और ग्राफ-आधारित सेटिंग दोनों में काम करता है।
import matplotlib.pyplot as plt
%matplotlib inline
# You can convert a TensorFlow tensor just by using# .numpy()
plt.imshow(image[0].numpy().reshape(28,28), cmap=plt.cm.binary)
plt.show()संचालित द्वारा
7. ऑटोमैटिक मिक्स्ड प्रिसीजन पॉलिसी
मिक्स्ड प्रिसीजन पॉलिसी का प्रस्ताव NVIDIA ने पिछले वर्ष रखा था। मूल पेपर आपको यहाँ मिलेगा। मिक्स्ड प्रिसीजन का संक्षिप्त विचार है कि हाफ (FP16) और फुल प्रिसीजन (FP32) का मिश्रण इस्तेमाल कर दोनों दुनिया के फ़ायदों को लिया जाए। बहुत गहरे न्यूरल नेटवर्क्स के ट्रेनिंग में (समय और स्कोर दोनों के लिहाज़ से) इसने शानदार परिणाम दिखाए हैं।
यदि आप CUDA-सक्षम GPU वातावरण (उदाहरण: Volta जेनरेशन, Tesla T4) पर हैं और आपने TensorFlow 2.0 का GPU वेरिएंट इंस्टॉल किया है, तो आप TensorFlow को इस तरह मिक्स्ड प्रिसीजन में ट्रेन करने का निर्देश दे सकते हैं -
यह स्वचालित रूप से TensorFlow ग्राफ के ऑपरेशंस को उपयुक्त रूप से कास्ट कर देगा। आपको अपने मॉडल के प्रदर्शन में अच्छा-खासा बूस्ट दिखेगा। आप TensorFlow के कोर ऑपरेशंस को भी मिक्स्ड प्रिसीजन पॉलिसी से ऑप्टिमाइज़ कर सकते हैं। इसके बारे में और जानने के लिए यह लेख देखें।
कृपया ध्यान दें यह फीचर केवल NVIDIA के TensorFlow Docker कंटेनर में समर्थित है। tf.keras के भीतर मिक्स्ड-प्रिसीजन ट्रेनिंग को नेटिव रूप से एकीकृत करने के लिए, मैं यह लेख देखने की सलाह देता हूँ। इस ओर ध्यान दिलाने के लिए मैं Abhishek Thanki का आभारी हूँ।
8. डिस्ट्रीब्यूटेड ट्रेनिंग
TensorFlow 2.0 कई GPUs पर ट्रेनिंग प्रक्रिया को वितरित करना बेहद आसान बना देता है। जब आपको भारी-भरकम लोड संभालना हो, तो यह प्रोडक्शन के लिए विशेष रूप से उपयोगी है। यह उतना ही आसान है जितना कि अपने मॉडल ट्रेनिंग ब्लॉक को एक with ब्लॉक के अंदर रखना।
पहले, आप इस तरह एक डिस्ट्रीब्यूशन स्ट्रैटेजी स्पेसिफाई करें:
एक mirrored स्ट्रैटेजी प्रति GPU एक रेप्लिका बनाती है और मॉडल वेरिएबल्स GPUs पर बराबर-बराबर मिरर होते हैं। अब आप परिभाषित स्ट्रैटेजी को इस तरह उपयोग कर सकते हैं:
with mirrored_strategy.scope():
model = tf.keras.Sequential([tf.keras.layers.Dense(1, input_shape=(1,))])
model.compile(loss='mse', optimizer='sgd')
model.fit(X_train, y_train,
validation_data=(X_test, y_test),
batch_size=128,
epochs=10)संचालित द्वारा
ध्यान दें कि ऊपर का कोड तभी उपयोगी होगा जब एक ही सिस्टम पर कई GPUs कॉन्फ़िगर हों। आप कई तरह की डिस्ट्रीब्यूशन स्ट्रैटेजीज़ कॉन्फ़िगर कर सकते हैं। इसके बारे में अधिक यहाँ जानें।
9. Jupyter Notebook के भीतर TensorBoard
यह अपडेट का शायद सबसे रोमांचक हिस्सा है। आप TensorBoard के ज़रिए सीधे अपने Jupyter Notebook के भीतर मॉडल ट्रेनिंग को विज़ुअलाइज़ कर सकते हैं। नया TensorBoard कई शानदार फीचर्स से लैस है, जैसे मेमोरी प्रोफाइलिंग, इमेज डेटा (कन्फ्यूज़न मैट्रिक्स सहित) देखना, कॉन्सेप्चुअल मॉडल ग्राफ आदि। इसके बारे में अधिक यहाँ जानें।
इस सेक्शन में, आप अपने वातावरण को इस तरह कॉन्फ़िगर करेंगे कि TensorBoard Jupyter Notebook के अंदर दिखाई दे। सबसे पहले tensorboard.notebook नोटबुक एक्सटेंशन लोड करें -
अब आप tf.keras.callbacks मॉड्यूल का उपयोग करके TensorBoard कॉलबैक परिभाषित करेंगे।
from datetime import datetime
import os
# Make a directory to keep the training logs
os.mkdir("logs")# Set the callback
logdir ="logs"
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=logdir)संचालित द्वारा
tf.keras के Sequential API का उपयोग करके मॉडल को दोबारा बनाइए -
# Define the model
model = tf.keras.Sequential([
tf.keras.layers.Dropout(rate=0.2, input_shape=X_train.shape[1:]),
tf.keras.layers.Dense(units=64, activation='relu'),
tf.keras.layers.Dropout(rate=0.2),
tf.keras.layers.Dense(units=64, activation='relu'),
tf.keras.layers.Dropout(rate=0.2),
tf.keras.layers.Dense(units=1, activation='sigmoid')])# Compile the model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])संचालित द्वारा
ट्रेन और टेस्ट सेट्स को अलग-अलग उपयोगों के लिए बदला गया था। इसलिए इन्हें फिर से स्प्लिट करना अच्छा विचार होगा -
# Split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=7)संचालित द्वारा
अब आप मॉडल ट्रेन करने के लिए पूरी तरह तैयार हैं -
# The TensorBoard extension%tensorboard --logdir logs/# Pass the TensorBoard callback you defined
model.fit(X_train, y_train,
validation_data=(X_test, y_test),
batch_size=64,
epochs=10,
callbacks=[tensorboard_callback],
verbose=False)संचालित द्वारा
<iframe
width="100%"
height="800"
src="http://localhost:6006"
frameborder="0"
allowfullscreen
></iframe><tensorflow.python.keras.callbacks.History at 0x7fc215b69400>संचालित द्वारा
TensorBoard डैशबोर्ड आपके Jupyter Notebook में लोड होना चाहिए और आप ट्रेनिंग व वैलिडेशन मेट्रिक्स ट्रेस कर सकेंगे।
10. Swift के लिए TensorFlow
बेहद अद्भुत सफलता के बावजूद Python की एक खटकने वाली बात यह है कि यह धीमा है। शोधकर्ताओं, प्रैक्टिशनर्स और शुरुआती लोगों की मदद के लिए TensorFlow टीम ने Swift के लिए एक संस्करण विकसित किया है। यद्यपि यह Python वेरिएंट जितना प्रोडक्शन-रेडी नहीं है, फिर भी इसकी काफ़ी क्षमता है। Swift अधिक लो-लेवल इंटरेक्शन्स और एडवांस्ड कम्पाइलेशन मॉड्यूल्स की अनुमति देता है। यहीं आपको TensorFlow के Swift वेरिएंट से संबंधित सब कुछ मिलेगा। आप यह इंटरव्यू भी देखें जिसमें Jeremy Howard ने Josh Gordon से इस दिशा पर अपने विचार साझा किए हैं।
आगे क्या?
आप इस लेख के अंत तक पहुँच गए हैं। डीप लर्निंग की खूबसूरती इसके अनुप्रयोग में है। आपका अगला कदम होना चाहिए कि इस लेख में चर्चा किए गए विचारों को आज़माएँ और उन्हें लागू करें। यह TensorFlow अपडेट निश्चित रूप से सबसे व्यापक और डेवलपर-फ्रेंडली अपडेट्स में से एक है। आप इस वर्ष के TensorFlow Dev Summit की इस YouTube वॉचलिस्ट को देखें, जिसमें TensorFlow lattice, TensorFlow probability, TensorFlow lite आदि पर अतिरिक्त अपडेट्स मिलेंगे।
यदि आप अपनी डीप लर्निंग जानकारी को मजबूत करना चाहते हैं, तो निम्नलिखित कोर्सेज़ देख सकते हैं:
%22%3E%3Cpath%20d%3D%22m-369%200h408v79h-408z%22%20fill%3D%22%237933ff%22%2F%3E%3Cpath%20d%3D%22m-148%200h306v45h-306z%22%20fill%3D%22%23974dff%22%2F%3E%3C%2Fg%3E%3C%2Fsvg%3E)
%22%2F%3E%3C%2FclipPath%3E%3Cg%20clip-path%3D%22url(%23a)%22%3E%3Cpath%20d%3D%22m76%200h484v36h-484z%22%20fill%3D%22%23974dff%22%2F%3E%3Cpath%20d%3D%22m0%200h384v24h-384z%22%20fill%3D%22%2306bdfc%22%20transform%3D%22matrix(1%200%200%20-1%200%2060)%22%2F%3E%3C%2Fg%3E%3C%2Fsvg%3E)
TensorFlow 2.0 alphaअब जारी हो चुका है। इस फ्रेमवर्क का डीप लर्निंग समुदाय पर उल्लेखनीय प्रभाव है। प्रैक्टिशनर्स, शोधकर्ता और डेवलपर्स ने इसे बहुत पसंद किया है और पहले से कहीं अधिक तेजी से अपनाया है। यह उन मुख्य कारणों में से एक है जिनकी वजह से आज हम इतने शानदार डीप लर्निंग-सक्षम अनुप्रयोग देखते हैं। इसके साथ ही,TensorFlow 1.xके भी कुछ नकारात्मक पक्ष रहे हैं (अन्य कई फ्रेमवर्क्स की तरह)। जैसा कि Martin Wicke (TensorFlowटीम के सॉफ्टवेयर इंजीनियर) ने TF Dev Summit '19 के दौरान कहा -विस्तृत यूज़र-बेस, GitHub इश्यूज़ आदि से मिली सीख के आधार पर
TensorFlowटीम नेTensorFlow 2.0 alphaजारी किया, जिसमें प्रदर्शन, यूज़र अनुभव आदि के लिए कई महत्वपूर्ण सुधार शामिल हैं। यह आपको रैपिड प्रोटोटाइपिंग सक्षम करता है और कई आधुनिक डीप लर्निंग प्रैक्टिसेस को समेटे हुए है। इस लेख में, आप इन बदलावों में से कुछ को संक्षिप्त इम्प्लीमेंटेशन्स के ज़रिए समझेंगे।ध्यान दें कि यहाँ चर्चा किए गए अपडेट लेखक के अनुसार सबसे महत्वपूर्ण हैं। इस लेख का अनुसरण करने के लिए आपको
TensorFlowऔरKerasका कुछ पूर्व अनुभव चाहिए होगा। यदि आपTensorFlowऔरKerasपर रिफ्रेशर ढूंढ रहे हैं, तो ये संसाधन उपयोगी हो सकते हैं -इंस्टॉलेशन और एक डेमो डेटासेट
TensorFlow 2.0में अपडेट करने के लिए Jupyter Notebook में यह लाइन चलाएँ:!pip install tensorflow==2.0.0-alpha0GPU वेरिएंट भी इसी तरह इंस्टॉल किया जा सकता है (पहले CUDA आवश्यक):
!pip install tensorflow-gpu==2.0.0-alpha0इंस्टॉलेशन प्रक्रिया के बारे में और जानकारी आपको यहाँ मिलेगी।
जिन अपडेट्स का आप अध्ययन करेंगे, उनमें से कुछ में कोड इम्प्लीमेंटेशन शामिल हैं। ऐसे मामलों में आपको एक डेटासेट चाहिए होगा। इस लेख में आप UCI आर्काइव के Adult डेटासेट का उपयोग करेंगे।
यह डेटासेट एक बाइनरी क्लासिफिकेशन टास्क दर्शाता है: व्यक्तिगत विवरणों के आधार पर यह अनुमान लगाना कि कोई व्यक्ति सालाना $50k से अधिक कमाएगा या नहीं।
आइए कुछ बेसिक डेटा प्रीप्रोसेसिंग करते हैं और फिर 80:20 अनुपात में डेटा स्प्लिट सेट करते हैं:
अब तक, आपके पास
TensorFlow 2.0इंस्टॉल के साथ एक कार्यशील वातावरण होना चाहिए और आपका डेटासेट वर्कस्पेस में लोड हो जाना चाहिए। अब आप अपडेट्स की ओर बढ़ सकते हैं।1. डिफ़ॉल्ट रूप से ईगर एक्ज़ीक्यूशन
TensorFlow 2.0में अब आपको सेशन बनाने और उसके भीतर कम्प्यूटेशनल ग्राफ चलाने की ज़रूरत नहीं है। 2.0 रिलीज़ में Eager execution डिफ़ॉल्ट रूप से सक्षम है ताकि आप अपने मॉडल तुरंत बना और चला सकें। आप चाहें तो eager execution को इस तरह डिसेबल कर सकते हैं:tf.compat.v1.disable_eager_execution()(बशर्तेtensorflowकोtfउपनाम के साथ इम्पोर्ट किया गया हो।)यहाँ एक छोटा कोड-आधारित तुलना दी गई है जो यह अंतर दिखाती है -
2. tf.function और AutoGraph
जहाँ eager execution आपको इम्पेरेटिव प्रोग्रामिंग देता है, वहीं डिस्ट्रीब्यूटेड ट्रेनिंग, फुल-स्केल ऑप्टिमाइज़ेशन और प्रोडक्शन वातावरण में
TensorFlow 1.xशैली का ग्राफ एक्ज़ीक्यूशन eager execution पर कुछ बढ़त देता है।TensorFlow 2.0में आप ग्राफ-आधारित एक्ज़ीक्यूशन को और लचीले ढंग से बनाए रखते हैं। यहtf.functionऔरAutoGraphसे हासिल होता है।tf.functionअपनेAutoGraphफीचर के माध्यम से Python-स्टाइल सिंटैक्स के साथTensorFlowग्राफ परिभाषित करने देता है।AutoGraphमेंif-statement,for-loop,while-loop,Iteratorsआदि सहित अच्छी-खासी Python संगतता है। हालांकि, कुछ सीमाएँ भी हैं। यहाँ आपको मौजूदा सपोर्ट्स की पूरी सूची मिलेगी। नीचे एक उदाहरण है जो दिखाता है कि केवल एकdecoratorके साथTensorFlowग्राफ परिभाषित करना कितना आसान है।ध्यान दें कि आपको फ़ंक्शन
single_layer()चलाने के लिए कोई सेशन या प्लेसहोल्डर बनाने की ज़रूरत नहीं पड़ी। यहtf.functionकी उपयोगी खूबियों में से एक है। अंदर ही अंदर यह सभी आवश्यक ऑप्टिमाइज़ेशन करता है ताकि आपका कोड तेज़ी से चले।3.
tf.variable_scopeकी अब ज़रूरत नहींTensorFlow 1.xमें,tf.layersको वेरिएबल्स की तरह इस्तेमाल करने और री-यूज़ करने के लिए आपकोtf.variableब्लॉक का उपयोग करना पड़ता था। लेकिनTensorFlow 2.0में इसकी ज़रूरत नहीं रही। क्योंकिTensorFlow 2.0में हाई-लेवल API के केंद्र मेंkerasहै,tf.layersसे बनाए गए सभी लेयर्स को आसानी सेtf.keras.Sequentialडेफिनिशन में रखा जा सकता है। इससे कोड पढ़ना आसान हो जाता है और आप वेरिएबल्स व लॉसेज़ पर भी नज़र रख सकते हैं।यहाँ एक उदाहरण है:
ऊपर के उदाहरण में, आपने केवल कच्ची आउटपुट प्रायिकताओं को पाने के लिए ट्रेनिंग डेटा को
modelसे गुज़ारा। ध्यान दें कि यह केवल एक फॉरवर्ड पास है। आप, बेशक, अपना मॉडल ट्रेन भी कर सकते हैं -आप लेयर-दर-लेयर तरीके से मॉडल के ट्रेन होने योग्य पैरामीटर्स की सूची इस तरह प्राप्त कर सकते हैं -
4. कस्टम लेयर्स अब बहुत आसान
मशीन लर्निंग शोध या औद्योगिक अनुप्रयोगों में अक्सर विशेष उपयोग मामलों के लिए कस्टम लेयर्स लिखने की आवश्यकता होती है।
TensorFlow 2.0कस्टम लेयर लिखना और मौजूदा लेयर्स के साथ उपयोग करना बेहद आसान बना देता है। आप अपने मॉडल के फॉरवर्ड पास को भी मनचाहे तरीके से कस्टमाइज़ कर सकते हैं।कस्टम लेयर बनाने के लिए सबसे आसान विकल्प है
tf.keras.layersकीLayerक्लास को एक्सटेंड करना और फिर उसे अनुसार परिभाषित करना। आप एक कस्टम लेयर बनाएँगे और फिर उसकी फॉरवर्ड कम्प्यूटेशंस परिभाषित करेंगे। नीचेhelp(tf.keras.layers.Layer)चलाने का आउटपुट है। यह बताता है कि इसे पूरा करने के लिए आपको क्या-क्या निर्दिष्ट करना होगा:ऊपर दिए स्निपेट से संकेत लेते हुए, आप -
build()मेथड में आप अपनी लेयर के लिए वेट्स जोड़ेंगेcall()मेथड में आप मैट्रिक्स मल्टिप्लिकेशन औरrelu()को चेन करके फॉरवर्ड पास परिभाषित करेंगेआप
tf.kerasकीModelक्लास को एक्सटेंड करके एक से अधिक लेयर्स को कंपोज़ कर सकते हैं। मॉडल्स को कंपोज़ करने के बारे में अधिक आप यहाँ पढ़ सकते हैं।5. मॉडल ट्रेनिंग में लचीलापन
TensorFlowलॉस फ़ंक्शन के संबंध में मॉडल पैरामीटर्स के ग्रेडिएंट्स की गणना करने के लिए ऑटोमैटिक डिफरेंशिएशन का उपयोग कर सकता है।tf.GradientTapeएक संदर्भ में टेप बनाता है जिसका उपयोगTensorFlowउस टेप में प्रत्येक कम्प्यूटेशन से रिकॉर्ड किए गए ग्रेडिएंट्स का ट्रैक रखने के लिए करता है। इसे समझने के लिए,tf.keras.Modelक्लास को एक्सटेंड करके थोड़ा लो-लेवल तरीके से एक मॉडल परिभाषित करते हैं।ध्यान दें कि इस मॉडल की टोपोलॉजी बिल्कुल वैसी ही है जैसी आपने पहले परिभाषित की थी। ऑटोमैटिक डिफरेंशिएशन के साथ इस मॉडल को प्रशिक्षित करने के लिए, आपको लॉस फ़ंक्शन और ऑप्टिमाइज़र को अलग तरह से परिभाषित करना होगा -
अब आप वे मेट्रिक्स परिभाषित करेंगे जिनका उपयोग ट्रेनिंग के दौरान नेटवर्क के प्रदर्शन को मापने के लिए किया जाएगा। यहाँ प्रदर्शन से तात्पर्य मॉडल के लॉस और एक्यूरेसी से है।
tf.dataइनपुट डेटा पाइपलाइंस परिभाषित करने के लिए उपयोगिताएँ प्रदान करता है। जब आप बड़े डेटा वॉल्यूम से निपटते हैं तो यह विशेष रूप से उपयोगी होता है।अब आप डेटा जेनरेटर परिभाषित करेंगे, जो मॉडल की ट्रेनिंग के दौरान बैचेज़ जेनरेट करेगा।
अब आप
tf.GradientTapeका उपयोग करके मॉडल ट्रेन करने के लिए तैयार हैं। सबसे पहले, आप एक मेथड परिभाषित करेंगे जोtf.data.DataSetका उपयोग करके अभी परिभाषित डेटा के साथ मॉडल ट्रेन करेगा। आप कम्प्यूटेशन में मिलने वाली स्पीडअप का लाभ लेने के लिए मॉडल ट्रेनिंग स्टेप्स कोtf.functionडेकोरेटर से भी रैप करेंगे।मॉडल ट्रेनिंग और वैलिडेशन
ऊपर दिए गए दोनों मेथड का उपयोग करके मॉडल को 5 epochs के लिए ट्रेन और वैलिडेट करें।
यह उदाहरण
TensorFlow 2.0के लेखकों के इस उदाहरण से प्रेरित है।6. TensorFlow Datasets
नेटवर्क मॉडल के साथ सुरुचिपूर्ण ढंग से काम करने के लिए
DataSetsनाम का एक अलग मॉड्यूल उपयोग होता है। आप इसे पहले के उदाहरण में देख चुके हैं। इस सेक्शन में, आप देखेंगे कि MNIST डेटासेट को अपनी मनचाही तरह से कैसे लोड किया जा सकता है।आप
pipसेtensorflow_datasetsलाइब्रेरी इंस्टॉल कर सकते हैं। इंस्टॉल होने के बाद, आप तैयार हैं। यह आपकी डेटासेट कंस्ट्रक्शन पाइपलाइन को लचीले ढंग से तैयार करने में मदद करने के लिए कई यूटिलिटी फ़ंक्शंस देता है। इनके बारे में आप यहाँ और यहाँ और सीख सकते हैं। अब देखते हैं कि MNIST डेटासेट लोड करने के लिए डेटा इनपुट पाइपलाइन कैसे बनाई जा सकती है।आप वार्निंग को नज़रअंदाज कर सकते हैं। देखें कि
tensorflow_datasetsने पाइपलाइन को कितनी सहजता से संभाला।अब आप लोड की गई इमेजेस के संग्रह में से पहली इमेज प्रदर्शित कर सकते हैं। ध्यान दें कि
tensorflow_datasetseager मोड और ग्राफ-आधारित सेटिंग दोनों में काम करता है।7. ऑटोमैटिक मिक्स्ड प्रिसीजन पॉलिसी
मिक्स्ड प्रिसीजन पॉलिसी का प्रस्ताव NVIDIA ने पिछले वर्ष रखा था। मूल पेपर आपको यहाँ मिलेगा। मिक्स्ड प्रिसीजन का संक्षिप्त विचार है कि हाफ (FP16) और फुल प्रिसीजन (FP32) का मिश्रण इस्तेमाल कर दोनों दुनिया के फ़ायदों को लिया जाए। बहुत गहरे न्यूरल नेटवर्क्स के ट्रेनिंग में (समय और स्कोर दोनों के लिहाज़ से) इसने शानदार परिणाम दिखाए हैं।
यदि आप CUDA-सक्षम GPU वातावरण (उदाहरण: Volta जेनरेशन, Tesla T4) पर हैं और आपने
TensorFlow 2.0का GPU वेरिएंट इंस्टॉल किया है, तो आपTensorFlowको इस तरह मिक्स्ड प्रिसीजन में ट्रेन करने का निर्देश दे सकते हैं -os.environ['TF_ENABLE_AUTO_MIXED_PRECISION'] = '1'यह स्वचालित रूप से TensorFlow ग्राफ के ऑपरेशंस को उपयुक्त रूप से कास्ट कर देगा। आपको अपने मॉडल के प्रदर्शन में अच्छा-खासा बूस्ट दिखेगा। आप TensorFlow के कोर ऑपरेशंस को भी मिक्स्ड प्रिसीजन पॉलिसी से ऑप्टिमाइज़ कर सकते हैं। इसके बारे में और जानने के लिए यह लेख देखें।
कृपया ध्यान दें यह फीचर केवल NVIDIA के TensorFlow Docker कंटेनर में समर्थित है। tf.keras के भीतर मिक्स्ड-प्रिसीजन ट्रेनिंग को नेटिव रूप से एकीकृत करने के लिए, मैं यह लेख देखने की सलाह देता हूँ। इस ओर ध्यान दिलाने के लिए मैं Abhishek Thanki का आभारी हूँ।
8. डिस्ट्रीब्यूटेड ट्रेनिंग
TensorFlow 2.0कई GPUs पर ट्रेनिंग प्रक्रिया को वितरित करना बेहद आसान बना देता है। जब आपको भारी-भरकम लोड संभालना हो, तो यह प्रोडक्शन के लिए विशेष रूप से उपयोगी है। यह उतना ही आसान है जितना कि अपने मॉडल ट्रेनिंग ब्लॉक को एकwithब्लॉक के अंदर रखना।पहले, आप इस तरह एक डिस्ट्रीब्यूशन स्ट्रैटेजी स्पेसिफाई करें:
mirrored_strategy = tf.distribute.MirroredStrategy()एक mirrored स्ट्रैटेजी प्रति GPU एक रेप्लिका बनाती है और मॉडल वेरिएबल्स GPUs पर बराबर-बराबर मिरर होते हैं। अब आप परिभाषित स्ट्रैटेजी को इस तरह उपयोग कर सकते हैं:
ध्यान दें कि ऊपर का कोड तभी उपयोगी होगा जब एक ही सिस्टम पर कई GPUs कॉन्फ़िगर हों। आप कई तरह की डिस्ट्रीब्यूशन स्ट्रैटेजीज़ कॉन्फ़िगर कर सकते हैं। इसके बारे में अधिक यहाँ जानें।
9. Jupyter Notebook के भीतर TensorBoard
यह अपडेट का शायद सबसे रोमांचक हिस्सा है। आप
TensorBoardके ज़रिए सीधे अपने Jupyter Notebook के भीतर मॉडल ट्रेनिंग को विज़ुअलाइज़ कर सकते हैं। नयाTensorBoardकई शानदार फीचर्स से लैस है, जैसे मेमोरी प्रोफाइलिंग, इमेज डेटा (कन्फ्यूज़न मैट्रिक्स सहित) देखना, कॉन्सेप्चुअल मॉडल ग्राफ आदि। इसके बारे में अधिक यहाँ जानें।इस सेक्शन में, आप अपने वातावरण को इस तरह कॉन्फ़िगर करेंगे कि
TensorBoardJupyter Notebook के अंदर दिखाई दे। सबसे पहलेtensorboard.notebookनोटबुक एक्सटेंशन लोड करें -अब आप
tf.keras.callbacksमॉड्यूल का उपयोग करकेTensorBoardकॉलबैक परिभाषित करेंगे।tf.kerasकेSequentialAPI का उपयोग करके मॉडल को दोबारा बनाइए -ट्रेन और टेस्ट सेट्स को अलग-अलग उपयोगों के लिए बदला गया था। इसलिए इन्हें फिर से स्प्लिट करना अच्छा विचार होगा -
अब आप मॉडल ट्रेन करने के लिए पूरी तरह तैयार हैं -
TensorBoardडैशबोर्ड आपके Jupyter Notebook में लोड होना चाहिए और आप ट्रेनिंग व वैलिडेशन मेट्रिक्स ट्रेस कर सकेंगे।10. Swift के लिए TensorFlow
बेहद अद्भुत सफलता के बावजूद Python की एक खटकने वाली बात यह है कि यह धीमा है। शोधकर्ताओं, प्रैक्टिशनर्स और शुरुआती लोगों की मदद के लिए
TensorFlowटीम ने Swift के लिए एक संस्करण विकसित किया है। यद्यपि यह Python वेरिएंट जितना प्रोडक्शन-रेडी नहीं है, फिर भी इसकी काफ़ी क्षमता है। Swift अधिक लो-लेवल इंटरेक्शन्स और एडवांस्ड कम्पाइलेशन मॉड्यूल्स की अनुमति देता है। यहीं आपको TensorFlow के Swift वेरिएंट से संबंधित सब कुछ मिलेगा। आप यह इंटरव्यू भी देखें जिसमें Jeremy Howard ने Josh Gordon से इस दिशा पर अपने विचार साझा किए हैं।आगे क्या?
आप इस लेख के अंत तक पहुँच गए हैं। डीप लर्निंग की खूबसूरती इसके अनुप्रयोग में है। आपका अगला कदम होना चाहिए कि इस लेख में चर्चा किए गए विचारों को आज़माएँ और उन्हें लागू करें। यह
TensorFlowअपडेट निश्चित रूप से सबसे व्यापक और डेवलपर-फ्रेंडली अपडेट्स में से एक है। आप इस वर्ष केTensorFlowDev Summit की इस YouTube वॉचलिस्ट को देखें, जिसमेंTensorFlow lattice,TensorFlow probability,TensorFlow liteआदि पर अतिरिक्त अपडेट्स मिलेंगे।यदि आप अपनी डीप लर्निंग जानकारी को मजबूत करना चाहते हैं, तो निम्नलिखित कोर्सेज़ देख सकते हैं:
शुभ
eager_executing!