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

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

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

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

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

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

import tensorflow as tf

टेंसर

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

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 और एक 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> साथ समाप्त होती 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: 93.77ms
On GPU:
10 loops: 397.49ms

डेटासेट

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

एक स्रोत 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([4 9], shape=(2,), dtype=int32)
tf.Tensor([ 1 16], 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)