सामग्री समीक्षा 
 
 
 
 
 
 केरस लेयर निर्माण कदम केरल मॉडल केरस मॉडल को बचाएं केरस मॉडल की जांच ध्यान दें कि इस बिंदु तक, केरास का कोई उल्लेख नहीं है. आप अपने स्वयं के उच्च स्तर के एपीआई को शीर्ष पर बना सकते हैं और लोगों के पास है। tf.Module इस अनुभाग में, आप देखेंगे कि Keras का उपयोग कैसे किया जाता है Keras मॉडल के लिए एक पूर्ण उपयोगकर्ता गाइड में पाया जा सकता है . tf.Module केरल गाइड केरास परतों और मॉडल में बहुत अधिक अतिरिक्त विशेषताएं हैं, जिनमें शामिल हैं: 
 
 
 
 
 
 विकल्प नुकसान Metrics के लिए समर्थन प्रशिक्षण और निष्कर्ष उपयोग के बीच अंतर करने के लिए एक वैकल्पिक प्रशिक्षण तर्क के लिए अंतर्निहित समर्थन केवल ब्लैक बॉक्स फ़ंक्शन के बजाय पिथन वस्तुओं को सहेजने और पुनर्स्थापित करना get_config और from_config विधियों जो आपको पियथन में मॉडल क्लोनिंग की अनुमति देने के लिए कॉन्फ़िगरेशन को सटीक रूप से संग्रहीत करने की अनुमति देते हैं ये विशेषताएं उपग्रेसिंग के माध्यम से बहुत अधिक जटिल मॉडल की अनुमति देती हैं, जैसे कि एक कस्टम जीएनए या एक वैरिएशनल ऑटोकोडर (वीएई) मॉडल। कस्टम लेयर और मॉडल। पूर्ण गाइड केरा मॉडल भी अतिरिक्त कार्यक्षमता के साथ आते हैं जो उन्हें प्रशिक्षित करने, मूल्यांकन करने, लोड करने, सहेजने और यहां तक कि कई मशीनों पर प्रशिक्षित करने के लिए आसान बनाता है। केरस लेयर यह सभी केरस परतों का आधार वर्ग है, और यह विरासत से है . tf.keras.layers.Layer tf.Module आप एक मॉड्यूल को केवल मातृ परत को बदलकर एक केरास परत में परिवर्तित कर सकते हैं और फिर बदल सकते हैं दो : __call__ call class MyDense(tf.keras.layers.Layer):
  # Adding **kwargs to support base Keras layer arguments
  def __init__(self, in_features, out_features, **kwargs):
    super().__init__(**kwargs)

    # This will soon move to the build step; see below
    self.w = tf.Variable(
      tf.random.normal([in_features, out_features]), name='w')
    self.b = tf.Variable(tf.zeros([out_features]), name='b')
  def call(self, x):
    y = tf.matmul(x, self.w) + self.b
    return tf.nn.relu(y)

simple_layer = MyDense(name="simple", in_features=3, out_features=3)
 केरस लेयर अपने हैं यह अगले भाग में वर्णित कुछ लेखांकन करता है और फिर कॉल करता है आपको कार्यात्मकता में कोई बदलाव नहीं देखना चाहिए। __call__ call() simple_layer([[2.0, 2.0, 2.0]])
 <tf.Tensor: shape=(1, 3), dtype=float32, numpy=array([[1.1688161, 0.       , 0.       ]], dtype=float32)>
 के कदम build जैसा कि उल्लेख किया गया है, कई मामलों में परिवर्तकों को बनाने के लिए इंतजार करना सुविधाजनक है जब तक कि आप इनपुट आकार के बारे में सुनिश्चित न हों। केरास परतों में एक अतिरिक्त जीवन चक्र चरण होता है जो आपको अपने परतों को परिभाषित करने में अधिक लचीलापन देता है। कार्य करता है। build इसे सटीक रूप से एक बार कहा जाता है, और इसे इनपुट के आकार के साथ कहा जाता है. इसे आमतौर पर परिवर्तनीय (वजन) बनाने के लिए उपयोग किया जाता है. build आप फिर से लिख सकते हैं ऊपर की परत अपने इनपुट के आकार के लिए लचीला होने के लिए है: MyDense class FlexibleDense(tf.keras.layers.Layer):
  # Note the added `**kwargs`, as Keras supports many arguments
  def __init__(self, out_features, **kwargs):
    super().__init__(**kwargs)
    self.out_features = out_features

  def build(self, input_shape):  # Create the state of the layer (weights)
    self.w = tf.Variable(
      tf.random.normal([input_shape[-1], self.out_features]), name='w')
    self.b = tf.Variable(tf.zeros([self.out_features]), name='b')

  def call(self, inputs):  # Defines the computation from inputs to outputs
    return tf.matmul(inputs, self.w) + self.b

# Create the instance of the layer
flexible_dense = FlexibleDense(out_features=3)
 इस बिंदु पर, मॉडल का निर्माण नहीं किया गया है, इसलिए कोई परिवर्तक नहीं है: flexible_dense.variables
 []
 फ़ंक्शन को कॉल करने से उचित आकार के परिवर्तकों को आवंटित किया जाता है: # Call it, with predictably random results
print("Model results:", flexible_dense(tf.constant([[2.0, 2.0, 2.0], [3.0, 3.0, 3.0]])))
 Model results: tf.Tensor(
[[-2.531786  -5.5550847 -0.4248762]
 [-3.7976792 -8.332626  -0.6373143]], shape=(2, 3), dtype=float32)
 flexible_dense.variables
 [<tf.Variable 'flexible_dense/w:0' shape=(3, 3) dtype=float32, numpy=
 array([[-0.77719826, -1.9281565 ,  0.82326293],
        [ 0.85628736, -0.31845194,  0.10916236],
        [-1.3449821 , -0.5309338 , -1.1448634 ]], dtype=float32)>,
 <tf.Variable 'flexible_dense/b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>]
 के बाद केवल एक बार बुलाया जाता है, इनपुट को अस्वीकार किया जाएगा यदि इनपुट आकार परत के परिवर्तकों के साथ संगत नहीं है: build try:
  print("Model results:", flexible_dense(tf.constant([[2.0, 2.0, 2.0, 2.0]])))
except tf.errors.InvalidArgumentError as e:
  print("Failed:", e)
 Failed: Exception encountered when calling layer 'flexible_dense' (type FlexibleDense).

{ {function_node __wrapped__MatMul_device_/job:localhost/replica:0/task:0/device:CPU:0} } Matrix size-incompatible: In[0]: [1,4], In[1]: [3,3] [Op:MatMul] name: 

Call arguments received by layer 'flexible_dense' (type FlexibleDense):
  • inputs=tf.Tensor(shape=(1, 4), dtype=float32)
 केरल मॉडल आप अपने मॉडल को Nested Keras Layers के रूप में परिभाषित कर सकते हैं। हालांकि, केरास एक पूर्ण सुविधा वाले मॉडल वर्ग भी प्रदान करता है जिसे वह विरासत से , इसलिए एक केरास मॉडल का उपयोग और केरास परतों के समान तरीके से निहित किया जा सकता है. केरास मॉडल अतिरिक्त कार्यक्षमता के साथ आते हैं जो उन्हें प्रशिक्षित करना, मूल्यांकन करना, लोड करना, सहेजना और यहां तक कि कई मशीनों पर प्रशिक्षित करना आसान बनाता है। tf.keras.Model tf.keras.layers.Layer आप इसे परिभाषित कर सकते हैं ऊपर से लगभग समान कोड के साथ, फिर से परिवर्तित दो माता-पिता को बदलने के लिए: SequentialModule __call__ call() @keras.saving.register_keras_serializable()
class MySequentialModel(tf.keras.Model):
  def __init__(self, name=None, **kwargs):
    super().__init__(**kwargs)

    self.dense_1 = FlexibleDense(out_features=3)
    self.dense_2 = FlexibleDense(out_features=2)
  def call(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

# You have made a Keras model!
my_sequential_model = MySequentialModel(name="the_model")

# Call it on a tensor, with random results
print("Model results:", my_sequential_model(tf.constant([[2.0, 2.0, 2.0]])))
 Model results: tf.Tensor([[ 0.26034355 16.431221  ]], shape=(1, 2), dtype=float32)
 सभी समान सुविधाएं उपलब्ध हैं, जिसमें ट्रैकिंग परिवर्तनीय और उप-मोड्यूल शामिल हैं। 
 
 नोट: एक केरास परत या मॉडल के अंदर निहित एक कच्चे tf.Module को प्रशिक्षण या बचत के लिए अपने परिवर्तकों को एकत्र नहीं किया जाएगा. इसके बजाय, केरास परतों के केरास परतों के अंदर निहित। नोट: एक केरास परत या मॉडल के अंदर निहित एक कच्चे tf.Module को प्रशिक्षण या बचत के लिए अपने परिवर्तकों को एकत्र नहीं किया जाएगा. इसके बजाय, केरास परतों के केरास परतों के अंदर निहित। my_sequential_model.variables
 [<tf.Variable 'my_sequential_model/flexible_dense_1/w:0' shape=(3, 3) dtype=float32, numpy=
 array([[ 1.4749854 ,  0.16090827,  2.2669017 ],
        [ 1.6850946 ,  1.1545411 ,  0.1707306 ],
        [ 0.8753734 , -0.13549292,  0.08751986]], dtype=float32)>,
 <tf.Variable 'my_sequential_model/flexible_dense_1/b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>,
 <tf.Variable 'my_sequential_model/flexible_dense_2/w:0' shape=(3, 2) dtype=float32, numpy=
 array([[-0.8022977 ,  1.9773549 ],
        [-0.76657015, -0.8485579 ],
        [ 1.6919082 ,  0.49000967]], dtype=float32)>,
 <tf.Variable 'my_sequential_model/flexible_dense_2/b:0' shape=(2,) dtype=float32, numpy=array([0., 0.], dtype=float32)>]
 my_sequential_model.submodules
 (<__main__.FlexibleDense at 0x7f790c7e0e80>,
 <__main__.FlexibleDense at 0x7f790c7e6940>)
 चढ़ाना यह TensorFlow मॉडल बनाने के लिए एक बहुत ही पिथोनिक दृष्टिकोण है. यदि आप अन्य फ्रेमवर्क से मॉडल स्थानांतरित कर रहे हैं, तो यह बहुत सरल हो सकता है. tf.keras.Model यदि आप उन मॉडल का निर्माण कर रहे हैं जो मौजूदा परतों और इनपुट के सरल विधानसभा हैं, तो आप उपयोग करके समय और स्थान बचा सकते हैं , जो मॉडल पुनर्निर्माण और वास्तुकला के आसपास अतिरिक्त विशेषताओं के साथ आता है। कामकाजी API यहां कार्यात्मक API के साथ एक ही मॉडल है: inputs = tf.keras.Input(shape=[3,])

x = FlexibleDense(3)(inputs)
x = FlexibleDense(2)(x)

my_functional_model = tf.keras.Model(inputs=inputs, outputs=x)

my_functional_model.summary()
 Model: "model"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 input_1 (InputLayer)        [(None, 3)]               0         
                                                                 
 flexible_dense_3 (Flexible  (None, 3)                 12        
 Dense)                                                          
                                                                 
 flexible_dense_4 (Flexible  (None, 2)                 8         
 Dense)                                                          
                                                                 
=================================================================
Total params: 20 (80.00 Byte)
Trainable params: 20 (80.00 Byte)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________
 my_functional_model(tf.constant([[2.0, 2.0, 2.0]]))
 <tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[3.4276495, 2.937252 ]], dtype=float32)>
 यहां मुख्य अंतर यह है कि इनपुट आकार कार्यात्मक निर्माण प्रक्रिया के हिस्से के रूप में सामने से निर्दिष्ट है। इस मामले में, तर्क को पूरी तरह से निर्दिष्ट नहीं किया जाना चाहिए; आप कुछ आयामों को छोड़ सकते हैं . input_shape None 
 
 नोट: आपको एक उपग्रेड मॉडल में input_shape या InputLayer निर्दिष्ट करने की आवश्यकता नहीं है; इन तर्कों और परतों को अनदेखा किया जाएगा। नोट: आपको एक उपग्रेड मॉडल में input_shape या InputLayer निर्दिष्ट करने की आवश्यकता नहीं है; इन तर्कों और परतों को अनदेखा किया जाएगा। केरस मॉडल को बचाएं केरास मॉडल अपने स्वयं के विशेष zip archive saving format, द्वारा चिह्नित है लंबे समय तक कॉल करते समय जोड़ें A फ़ाइल का उपयोग करें. उदाहरण के लिए: .keras tf.keras.Model.save .keras my_sequential_model.save("exname_of_file.keras")
 उतना ही आसानी से, उन्हें वापस लोड किया जा सकता है: reconstructed_model = tf.keras.models.load_model("exname_of_file.keras")
 ZIP फ़ाइलों के बारे में - फ़ाइलें - भी मीट्रिक, नुकसान, और अनुकूलक राज्यों को सहेजें। .keras इस पुनर्निर्माण मॉडल का उपयोग किया जा सकता है और एक ही डेटा पर कॉल करते समय एक ही परिणाम का उत्पादन करेगा: reconstructed_model(tf.constant([[2.0, 2.0, 2.0]]))
 <tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[ 0.26034355, 16.431221  ]], dtype=float32)>
 केरस मॉडल की जांच केरास मॉडल भी चेकपॉइंट किया जा सकता है, और यह उसी तरह दिख जाएगा . tf.Module केरास मॉडल को सहेजने और श्रृंखलाकरण के बारे में अधिक जानने के लिए, जिसमें सुविधाओं का समर्थन करने के लिए कस्टम परतों के लिए कॉन्फ़िगरेशन विधियों को प्रदान करना शामिल है। . बचत और श्रृंखलाकरण के लिए गाइड क्या है अगला यदि आप केरास के बारे में अधिक जानकारी जानना चाहते हैं, तो आप मौजूदा केरास गाइड का पालन कर सकते हैं . यहां एक उच्च स्तर की API का एक और उदाहरण गौरतलब है कि गौरतलब है कि गौरतलब है कि . tf.module उनकी साइट 
 
 मूल रूप से TensorFlow वेबसाइट पर प्रकाशित, यह लेख यहां एक नए शीर्षक के तहत दिखाई देता है और CC BY 4.0 के तहत लाइसेंस दिया गया है। मूल रूप से TensorFlow वेबसाइट पर प्रकाशित, यह लेख यहां एक नए शीर्षक के तहत दिखाई देता है और CC BY 4.0 के तहत लाइसेंस दिया गया है। TensorFlow के लिए

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

यह ऑडियो कहानी की मूल भाषा में निर्मित है!

Keras और tf.Module का उपयोग करके मॉडल का निर्माण, प्रशिक्षण और सहेजें

About Author

टिप्पणियाँ

लेबल

इस लेख में चित्रित किया गया था

Related Stories

टेलीग्राम: क्रिप्टो द्वीप का मुख्य भूमि से पुल

फ़ोरम से फ़ीड तक: सोशल मीडिया एल्गोरिदम डिजिटल इंटरैक्शन को कैसे आकार देते हैं

सफल क्लाउड माइग्रेशन के लिए संपूर्ण गाइड: रणनीतियाँ और सर्वोत्तम अभ्यास

AI की शक्ति को उन्मुक्त करना। अत्याधुनिक तकनीकों की एक व्यवस्थित समीक्षा: सार और परिचय

टेलीग्राम: क्रिप्टो द्वीप का मुख्य भूमि से पुल

फ़ोरम से फ़ीड तक: सोशल मीडिया एल्गोरिदम डिजिटल इंटरैक्शन को कैसे आकार देते हैं

सफल क्लाउड माइग्रेशन के लिए संपूर्ण गाइड: रणनीतियाँ और सर्वोत्तम अभ्यास

AI की शक्ति को उन्मुक्त करना। अत्याधुनिक तकनीकों की एक व्यवस्थित समीक्षा: सार और परिचय

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps