 TensorFlow.org पर देखें |  Google Colab में चलाएं |  GitHub पर स्रोत देखें |  नोटबुक डाउनलोड करें |
हम तंत्रिका नेटवर्क के निर्माण के लिए tf.keras को एक उच्च-स्तरीय API के रूप में उपयोग करने की सलाह देते हैं। उस ने कहा, अधिकांश TensorFlow API उत्सुक निष्पादन के साथ प्रयोग करने योग्य हैं।
import tensorflow as tf
print(tf.config.list_physical_devices('GPU'))
[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]
परतें: उपयोगी संचालन के सामान्य सेट
अधिकांश समय जब आप मशीन लर्निंग मॉडल के लिए कोड लिखते हैं तो आप व्यक्तिगत संचालन और व्यक्तिगत चर के हेरफेर की तुलना में उच्च स्तर के अमूर्तता पर काम करना चाहते हैं।
कई मशीन लर्निंग मॉडल अपेक्षाकृत सरल परतों की संरचना और स्टैकिंग के रूप में व्यक्त किए जा सकते हैं, और TensorFlow कई सामान्य परतों का एक सेट प्रदान करता है और साथ ही आपको अपने स्वयं के एप्लिकेशन-विशिष्ट परतों को खरोंच से या संरचना के रूप में लिखने के लिए आसान तरीके प्रदान करता है। मौजूदा परतें।
TensorFlow में tf.keras पैकेज में पूर्ण Keras API शामिल है, और आपके अपने मॉडल बनाते समय Keras परतें बहुत उपयोगी होती हैं।
# In the tf.keras.layers package, layers are objects. To construct a layer,
# simply construct the object. Most layers take as a first argument the number
# of output dimensions / channels.
layer = tf.keras.layers.Dense(100)
# The number of input dimensions is often unnecessary, as it can be inferred
# the first time the layer is used, but it can be provided if you want to
# specify it manually, which is useful in some complex models.
layer = tf.keras.layers.Dense(10, input_shape=(None, 5))
दस्तावेज़ीकरण में पहले से मौजूद परतों की पूरी सूची देखी जा सकती है। इसमें Dense (एक पूरी तरह से कनेक्टेड लेयर), Conv2D, LSTM, BatchNormalization, Dropout और कई अन्य शामिल हैं।
# To use a layer, simply call it.
layer(tf.zeros([10, 5]))
<tf.Tensor: shape=(10, 10), dtype=float32, numpy=
array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)>
# Layers have many useful methods. For example, you can inspect all variables
# in a layer using `layer.variables` and trainable variables using
# `layer.trainable_variables`. In this case a fully-connected layer
# will have variables for weights and biases.
layer.variables
[<tf.Variable 'dense_1/kernel:0' shape=(5, 10) dtype=float32, numpy=
array([[-0.4370762 , 0.6231566 , -0.44082257, -0.48535 , 0.17860883,
-0.521853 , -0.45774594, -0.5409817 , 0.29194772, -0.18690601],
[ 0.3304953 , -0.27142242, -0.48322448, -0.19328138, -0.14415592,
0.05973059, 0.56227285, 0.5323917 , -0.4914217 , 0.62182254],
[-0.5313885 , 0.54680306, 0.1632638 , -0.10741419, -0.04727739,
-0.35414204, 0.07529551, -0.06515282, -0.19732419, 0.25217015],
[ 0.49743277, 0.31172627, 0.04989761, 0.1200847 , 0.42642146,
0.5887727 , 0.5771937 , 0.08720696, 0.43024355, -0.17298424],
[-0.07610255, 0.04131562, 0.3136508 , -0.6197298 , 0.2331146 ,
0.04888463, -0.54215366, 0.41208786, 0.27439958, 0.08524591]],
dtype=float32)>,
<tf.Variable 'dense_1/bias:0' shape=(10,) dtype=float32, numpy=array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)>]
# The variables are also accessible through nice accessors
layer.kernel, layer.bias
(<tf.Variable 'dense_1/kernel:0' shape=(5, 10) dtype=float32, numpy=
array([[-0.4370762 , 0.6231566 , -0.44082257, -0.48535 , 0.17860883,
-0.521853 , -0.45774594, -0.5409817 , 0.29194772, -0.18690601],
[ 0.3304953 , -0.27142242, -0.48322448, -0.19328138, -0.14415592,
0.05973059, 0.56227285, 0.5323917 , -0.4914217 , 0.62182254],
[-0.5313885 , 0.54680306, 0.1632638 , -0.10741419, -0.04727739,
-0.35414204, 0.07529551, -0.06515282, -0.19732419, 0.25217015],
[ 0.49743277, 0.31172627, 0.04989761, 0.1200847 , 0.42642146,
0.5887727 , 0.5771937 , 0.08720696, 0.43024355, -0.17298424],
[-0.07610255, 0.04131562, 0.3136508 , -0.6197298 , 0.2331146 ,
0.04888463, -0.54215366, 0.41208786, 0.27439958, 0.08524591]],
dtype=float32)>,
<tf.Variable 'dense_1/bias:0' shape=(10,) dtype=float32, numpy=array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)>)
कस्टम परतों को लागू करना
अपनी खुद की परत को लागू करने का सबसे अच्छा तरीका tf.keras.Layer वर्ग का विस्तार करना और कार्यान्वयन करना है:
-
__init__, जहां आप सभी इनपुट-स्वतंत्र इनिशियलाइज़ेशन कर सकते हैं -
build, जहाँ आप इनपुट टेंसर के आकार को जानते हैं और बाकी इनिशियलाइज़ेशन कर सकते हैं -
call, जहां आप आगे की गणना करते हैं
ध्यान दें कि आपको अपने चर बनाने के लिए build को कॉल किए जाने तक प्रतीक्षा करने की आवश्यकता नहीं है, आप उन्हें __init__ में भी बना सकते हैं। हालाँकि, उन्हें बिल्ड में build का लाभ यह है कि यह उन इनपुट के आकार के आधार पर देर से परिवर्तनशील निर्माण को सक्षम बनाता है जिन पर परत संचालित होगी। दूसरी ओर, __init__ में चर बनाने का अर्थ यह होगा कि चर बनाने के लिए आवश्यक आकृतियों को स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता होगी।
class MyDenseLayer(tf.keras.layers.Layer):
def __init__(self, num_outputs):
super(MyDenseLayer, self).__init__()
self.num_outputs = num_outputs
def build(self, input_shape):
self.kernel = self.add_weight("kernel",
shape=[int(input_shape[-1]),
self.num_outputs])
def call(self, inputs):
return tf.matmul(inputs, self.kernel)
layer = MyDenseLayer(10)
_ = layer(tf.zeros([10, 5])) # Calling the layer `.builds` it.
print([var.name for var in layer.trainable_variables])
['my_dense_layer/kernel:0']
यदि संभव हो तो मानक परतों का उपयोग करने पर समग्र कोड को पढ़ना और बनाए रखना आसान होता है, क्योंकि अन्य पाठक मानक परतों के व्यवहार से परिचित होंगे। यदि आप एक ऐसी परत का उपयोग करना चाहते हैं जो tf.keras.layers में मौजूद नहीं है, तो एक गीथब समस्या दर्ज करने पर विचार करें, या इससे भी बेहतर, हमें एक पुल अनुरोध भेजें!
मॉडल: परतों की रचना
मशीन लर्निंग मॉडल में कई दिलचस्प परत जैसी चीजें मौजूदा परतों की रचना करके लागू की जाती हैं। उदाहरण के लिए, एक रेसनेट में प्रत्येक अवशिष्ट ब्लॉक कनवल्शन, बैच सामान्यीकरण और एक शॉर्टकट की एक संरचना है। परतों को अन्य परतों के अंदर नेस्ट किया जा सकता है।
आमतौर पर आप keras.Model से इनहेरिट करते हैं जब आपको मॉडल विधियों की आवश्यकता होती है जैसे: Model.fit , Model.evaluate , और Model.save (विवरण के लिए कस्टम केरस लेयर्स और मॉडल देखें)।
keras.Model ( keras.layers.Layer के बजाय) द्वारा प्रदान की गई एक अन्य विशेषता यह है कि ट्रैकिंग चर के अलावा, एक keras.Model अपनी आंतरिक परतों को भी ट्रैक करता है, जिससे उनका निरीक्षण करना आसान हो जाता है।
उदाहरण के लिए यहाँ एक ResNet ब्लॉक है:
class ResnetIdentityBlock(tf.keras.Model):
def __init__(self, kernel_size, filters):
super(ResnetIdentityBlock, self).__init__(name='')
filters1, filters2, filters3 = filters
self.conv2a = tf.keras.layers.Conv2D(filters1, (1, 1))
self.bn2a = tf.keras.layers.BatchNormalization()
self.conv2b = tf.keras.layers.Conv2D(filters2, kernel_size, padding='same')
self.bn2b = tf.keras.layers.BatchNormalization()
self.conv2c = tf.keras.layers.Conv2D(filters3, (1, 1))
self.bn2c = tf.keras.layers.BatchNormalization()
def call(self, input_tensor, training=False):
x = self.conv2a(input_tensor)
x = self.bn2a(x, training=training)
x = tf.nn.relu(x)
x = self.conv2b(x)
x = self.bn2b(x, training=training)
x = tf.nn.relu(x)
x = self.conv2c(x)
x = self.bn2c(x, training=training)
x += input_tensor
return tf.nn.relu(x)
block = ResnetIdentityBlock(1, [1, 2, 3])
_ = block(tf.zeros([1, 2, 3, 3]))
block.layers
[<keras.layers.convolutional.Conv2D at 0x7fc7e439bf90>, <keras.layers.normalization.batch_normalization.BatchNormalization at 0x7fc7dc1e5dd0>, <keras.layers.convolutional.Conv2D at 0x7fc7dc1a1cd0>, <keras.layers.normalization.batch_normalization.BatchNormalization at 0x7fc7dc12c490>, <keras.layers.convolutional.Conv2D at 0x7fc7dc12c8d0>, <keras.layers.normalization.batch_normalization.BatchNormalization at 0x7fc7dc12cf50>]
len(block.variables)
18
block.summary()
Model: ""
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
conv2d (Conv2D) multiple 4
batch_normalization (BatchN multiple 4
ormalization)
conv2d_1 (Conv2D) multiple 4
batch_normalization_1 (Batc multiple 8
hNormalization)
conv2d_2 (Conv2D) multiple 9
batch_normalization_2 (Batc multiple 12
hNormalization)
=================================================================
Total params: 41
Trainable params: 29
Non-trainable params: 12
_________________________________________________________________
हालांकि, ज्यादातर समय, मॉडल जो कई परतों की रचना करते हैं, बस एक के बाद एक परत कहते हैं। यह tf.keras.Sequential का उपयोग करके बहुत कम कोड में किया जा सकता है:
my_seq = tf.keras.Sequential([tf.keras.layers.Conv2D(1, (1, 1),
input_shape=(
None, None, 3)),
tf.keras.layers.BatchNormalization(),
tf.keras.layers.Conv2D(2, 1,
padding='same'),
tf.keras.layers.BatchNormalization(),
tf.keras.layers.Conv2D(3, (1, 1)),
tf.keras.layers.BatchNormalization()])
my_seq(tf.zeros([1, 2, 3, 3]))
<tf.Tensor: shape=(1, 2, 3, 3), dtype=float32, numpy=
array([[[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]]]], dtype=float32)>
my_seq.summary()
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
conv2d_3 (Conv2D) (None, None, None, 1) 4
batch_normalization_3 (Batc (None, None, None, 1) 4
hNormalization)
conv2d_4 (Conv2D) (None, None, None, 2) 4
batch_normalization_4 (Batc (None, None, None, 2) 8
hNormalization)
conv2d_5 (Conv2D) (None, None, None, 3) 9
batch_normalization_5 (Batc (None, None, None, 3) 12
hNormalization)
=================================================================
Total params: 41
Trainable params: 29
Non-trainable params: 12
_________________________________________________________________
अगले कदम
अब आप पिछली नोटबुक पर वापस जा सकते हैं और बेहतर संरचित होने के लिए परतों और मॉडलों का उपयोग करने के लिए रैखिक प्रतिगमन उदाहरण को अनुकूलित कर सकते हैं।