7 दिसंबर को महिला एमएल संगोष्ठी में भाग लें अभी पंजीकरण करें

अनुकूलन मूल बातें: टेंसर और संचालन

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

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

यह एक परिचयात्मक TensorFlow ट्यूटोरियल है जो दिखाता है कि कैसे:

  • आवश्यक पैकेज आयात करें
  • टेंसर बनाएं और उपयोग करें
  • GPU त्वरण का उपयोग करें
  • प्रदर्शन tf.data.Dataset

टेंसरफ्लो आयात करें

आरंभ करने के लिए, tensorflow मॉड्यूल आयात करें। TensorFlow 2 के अनुसार, उत्सुक निष्पादन डिफ़ॉल्ट रूप से चालू होता है। यह TensorFlow के लिए एक अधिक इंटरैक्टिव फ्रंटएंड सक्षम करता है, जिसके विवरण पर हम बहुत बाद में चर्चा करेंगे।

import tensorflow as tf

टेंसर

टेंसर एक बहुआयामी सरणी है। NumPy ndarray ऑब्जेक्ट्स के समान, tf.Tensor ऑब्जेक्ट्स में डेटा प्रकार और आकार होता है। इसके अतिरिक्त, tf.Tensor एस एक्सेलेरेटर मेमोरी (जैसे GPU) में रह सकता है। TensorFlow संचालन का एक समृद्ध पुस्तकालय प्रदान करता है ( tf.add , tf.matmul , tf.linalg.inv आदि) जो tf.Tensor s का उपभोग और उत्पादन करता है। ये ऑपरेशन स्वचालित रूप से देशी पायथन प्रकारों को परिवर्तित करते हैं, उदाहरण के लिए:

print(tf.add(1, 2))
print(tf.add([1, 2], [3, 4]))
print(tf.square(5))
print(tf.reduce_sum([1, 2, 3]))

# Operator overloading is also supported
print(tf.square(2) + tf.square(3))
tf.Tensor(3, shape=(), dtype=int32)
tf.Tensor([4 6], shape=(2,), dtype=int32)
tf.Tensor(25, shape=(), dtype=int32)
tf.Tensor(6, shape=(), dtype=int32)
tf.Tensor(13, shape=(), dtype=int32)

प्रत्येक tf.Tensor का एक आकार और एक डेटाटाइप होता है:

x = tf.matmul([[1]], [[2, 3]])
print(x)
print(x.shape)
print(x.dtype)
tf.Tensor([[2 3]], shape=(1, 2), dtype=int32)
(1, 2)
<dtype: 'int32'>

NumPy सरणियों और tf.Tensor s के बीच सबसे स्पष्ट अंतर हैं:

  1. Tensors को त्वरक मेमोरी (जैसे GPU, TPU) द्वारा समर्थित किया जा सकता है।
  2. टेंसर अपरिवर्तनीय हैं।

NumPy संगतता

TensorFlow tf.Tensor s और NumPy ndarray के बीच कनवर्ट करना आसान है:

  • TensorFlow संचालन स्वचालित रूप से NumPy ndarrays को Tensors में बदल देता है।
  • NumPy ऑपरेशन स्वचालित रूप से Tensors को NumPy ndarrays में बदल देता है।

टेंसर को उनकी .numpy() विधि का उपयोग करके स्पष्ट रूप से NumPy ndarrays में परिवर्तित किया जाता है। ये रूपांतरण आम तौर पर सस्ते होते हैं क्योंकि सरणी और tf.Tensor यदि संभव हो तो अंतर्निहित स्मृति प्रतिनिधित्व साझा करते हैं। हालाँकि, अंतर्निहित प्रतिनिधित्व को साझा करना हमेशा संभव नहीं होता है क्योंकि tf.Tensor को GPU मेमोरी में होस्ट किया जा सकता है, जबकि NumPy सरणियों को हमेशा होस्ट मेमोरी द्वारा समर्थित किया जाता है, और रूपांतरण में GPU से होस्ट मेमोरी की एक कॉपी शामिल होती है।

import numpy as np

ndarray = np.ones([3, 3])

print("TensorFlow operations convert numpy arrays to Tensors automatically")
tensor = tf.multiply(ndarray, 42)
print(tensor)


print("And NumPy operations convert Tensors to numpy arrays automatically")
print(np.add(tensor, 1))

print("The .numpy() method explicitly converts a Tensor to a numpy array")
print(tensor.numpy())
TensorFlow operations convert numpy arrays to Tensors automatically
tf.Tensor(
[[42. 42. 42.]
 [42. 42. 42.]
 [42. 42. 42.]], shape=(3, 3), dtype=float64)
And NumPy operations convert Tensors to numpy arrays automatically
[[43. 43. 43.]
 [43. 43. 43.]
 [43. 43. 43.]]
The .numpy() method explicitly converts a Tensor to a numpy array
[[42. 42. 42.]
 [42. 42. 42.]
 [42. 42. 42.]]

GPU त्वरण

गणना के लिए GPU का उपयोग करके कई TensorFlow संचालन को तेज किया जाता है। किसी भी एनोटेशन के बिना, TensorFlow स्वचालित रूप से यह तय करता है कि ऑपरेशन के लिए GPU या CPU का उपयोग करना है या नहीं - यदि आवश्यक हो तो CPU और GPU मेमोरी के बीच टेंसर की प्रतिलिपि बनाना। एक ऑपरेशन द्वारा निर्मित टेंसर आमतौर पर उस डिवाइस की मेमोरी द्वारा समर्थित होते हैं जिस पर ऑपरेशन निष्पादित होता है, उदाहरण के लिए:

x = tf.random.uniform([3, 3])

print("Is there a GPU available: "),
print(tf.config.list_physical_devices("GPU"))

print("Is the Tensor on GPU #0:  "),
print(x.device.endswith('GPU:0'))
Is there a GPU available: 
[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]
Is the Tensor on GPU #0:  
True

डिवाइस के नाम

Tensor.device प्रॉपर्टी टेंसर की सामग्री को होस्ट करने वाले डिवाइस का पूरी तरह से योग्य स्ट्रिंग नाम प्रदान करती है। यह नाम कई विवरणों को एन्कोड करता है, जैसे होस्ट के नेटवर्क पते का पहचानकर्ता जिस पर यह प्रोग्राम निष्पादित हो रहा है और उस होस्ट के भीतर डिवाइस। TensorFlow प्रोग्राम के वितरित निष्पादन के लिए यह आवश्यक है। स्ट्रिंग GPU:<N> यदि होस्ट पर N -th GPU पर टेंसर रखा जाता है।

स्पष्ट डिवाइस प्लेसमेंट

TensorFlow में, प्लेसमेंट से तात्पर्य है कि निष्पादन के लिए एक डिवाइस को अलग-अलग संचालन कैसे सौंपा जाता है (पर रखा जाता है)। जैसा कि उल्लेख किया गया है, जब कोई स्पष्ट मार्गदर्शन प्रदान नहीं किया जाता है, तो TensorFlow स्वचालित रूप से यह तय करता है कि कौन सा उपकरण किसी ऑपरेशन को निष्पादित करना है और यदि आवश्यक हो तो उस डिवाइस पर टेंसर की प्रतिलिपि बनाता है। हालाँकि, TensorFlow संचालन स्पष्ट रूप से tf.device संदर्भ प्रबंधक का उपयोग करके विशिष्ट उपकरणों पर रखा जा सकता है, उदाहरण के लिए:

import time

def time_matmul(x):
  start = time.time()
  for loop in range(10):
    tf.matmul(x, x)

  result = time.time()-start

  print("10 loops: {:0.2f}ms".format(1000*result))

# Force execution on CPU
print("On CPU:")
with tf.device("CPU:0"):
  x = tf.random.uniform([1000, 1000])
  assert x.device.endswith("CPU:0")
  time_matmul(x)

# Force execution on GPU #0 if available
if tf.config.list_physical_devices("GPU"):
  print("On GPU:")
  with tf.device("GPU:0"): # Or GPU:1 for the 2nd GPU, GPU:2 for the 3rd etc.
    x = tf.random.uniform([1000, 1000])
    assert x.device.endswith("GPU:0")
    time_matmul(x)
On CPU:
10 loops: 91.47ms
On GPU:
10 loops: 388.16ms

डेटासेट

यह अनुभाग आपके मॉडल को डेटा फीड करने के लिए एक पाइपलाइन बनाने के लिए tf.data.Dataset API का उपयोग करता है। tf.data.Dataset API का उपयोग सरल, पुन: प्रयोज्य टुकड़ों से निष्पादक, जटिल इनपुट पाइपलाइन बनाने के लिए किया जाता है जो आपके मॉडल के प्रशिक्षण या मूल्यांकन लूप को खिलाएगा।

एक स्रोत Dataset बनाएं

Dataset.from_tensors , Dataset.from_tensor_slices जैसे फ़ैक्टरी कार्यों में से किसी एक का उपयोग करके या TextLineDataset या TFRecordDataset जैसी फ़ाइलों से पढ़ने वाली वस्तुओं का उपयोग करके एक स्रोत डेटासेट बनाएं। अधिक जानकारी के लिए TensorFlow डेटासेट गाइड देखें।

ds_tensors = tf.data.Dataset.from_tensor_slices([1, 2, 3, 4, 5, 6])

# Create a CSV file
import tempfile
_, filename = tempfile.mkstemp()

with open(filename, 'w') as f:
  f.write("""Line 1
Line 2
Line 3
  """)

ds_file = tf.data.TextLineDataset(filename)

परिवर्तन लागू करें

डेटासेट रिकॉर्ड में परिवर्तन लागू करने के लिए map , batch और shuffle जैसे रूपांतरण कार्यों का उपयोग करें।

ds_tensors = ds_tensors.map(tf.square).shuffle(2).batch(2)

ds_file = ds_file.batch(2)

दोहराएं

tf.data.Dataset ऑब्जेक्ट रिकॉर्ड पर लूप करने के लिए पुनरावृत्ति का समर्थन करते हैं:

print('Elements of ds_tensors:')
for x in ds_tensors:
  print(x)

print('\nElements in ds_file:')
for x in ds_file:
  print(x)
Elements of ds_tensors:
tf.Tensor([1 9], shape=(2,), dtype=int32)
tf.Tensor([16  4], shape=(2,), dtype=int32)
tf.Tensor([25 36], shape=(2,), dtype=int32)

Elements in ds_file:
tf.Tensor([b'Line 1' b'Line 2'], shape=(2,), dtype=string)
tf.Tensor([b'Line 3' b'  '], shape=(2,), dtype=string)