शुरुआती के लिए TensorFlow 2 क्विकस्टार्ट

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

यह संक्षिप्त परिचय केरस का उपयोग करता है:

  1. छवियों को वर्गीकृत करने वाला एक तंत्रिका नेटवर्क बनाएं।
  2. इस तंत्रिका नेटवर्क को प्रशिक्षित करें।
  3. और, अंत में, मॉडल की सटीकता का मूल्यांकन करें।

यह एक Google सहयोगी नोटबुक फ़ाइल है। पायथन प्रोग्राम सीधे ब्राउज़र में चलाए जाते हैं - TensorFlow को सीखने और उपयोग करने का एक शानदार तरीका। इस ट्यूटोरियल का अनुसरण करने के लिए, इस पृष्ठ के शीर्ष पर स्थित बटन पर क्लिक करके नोटबुक को Google Colab में चलाएँ।

  1. Colab में, Python रनटाइम से कनेक्ट करें: मेन्यू बार में सबसे ऊपर दाईं ओर, कनेक्ट करें चुनें.
  2. सभी नोटबुक कोड सेल चलाएँ : रनटाइम > सभी चलाएँ चुनें।

TensorFlow 2 डाउनलोड और इंस्टॉल करें। अपने प्रोग्राम में TensorFlow आयात करें:

import tensorflow as tf

लोड करें और MNIST डेटासेट तैयार करें। नमूनों को पूर्णांकों से फ़्लोटिंग-पॉइंट नंबरों में बदलें:

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

परतों को ढेर करके tf.keras.Sequential . tf.keras.Sequential मॉडल tf.keras.Sequential । प्रशिक्षण के लिए एक अनुकूलक और हानि फ़ंक्शन चुनें:

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10)
])

प्रत्येक उदाहरण के लिए मॉडल " लॉगिट " या " लॉग-ऑड्स " स्कोर का एक वेक्टर देता है, प्रत्येक वर्ग के लिए एक।

predictions = model(x_train[:1]).numpy()
predictions
array([[ 8.1478250e-01, -4.9710822e-01, -4.4540316e-04,  8.0338269e-02,
        -1.2498328e-01, -2.8269893e-01,  4.8158792e-01, -2.3113336e-01,
        -6.4444810e-02,  2.9273060e-01]], dtype=float32)

tf.nn.softmax फ़ंक्शन इन लॉग को प्रत्येक वर्ग के लिए "संभावनाओं" में परिवर्तित करता है:

tf.nn.softmax(predictions).numpy()
array([[0.2003022 , 0.05394346, 0.08864142, 0.09609938, 0.07826194,
        0.06684294, 0.14354272, 0.07038016, 0.08314615, 0.11883967]],
      dtype=float32)

नुकसान। losses.SparseCategoricalCrossentropy नुकसान losses.SparseCategoricalCrossentropy का एक वेक्टर और एक True इंडेक्स लेता है और प्रत्येक उदाहरण के लिए एक स्केलर लॉस देता है।

loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

यह नुकसान वास्तविक वर्ग की नकारात्मक लॉग संभावना के बराबर है: यदि मॉडल सही वर्ग के बारे में सुनिश्चित है तो यह शून्य है।

यह अप्रशिक्षित मॉडल यादृच्छिक (प्रत्येक वर्ग के लिए 1/10) के करीब संभावनाएं देता है, इसलिए प्रारंभिक नुकसान -tf.math.log(1/10) ~= 2.3 करीब होना चाहिए।

loss_fn(y_train[:1], predictions).numpy()
2.7054095
model.compile(optimizer='adam',
              loss=loss_fn,
              metrics=['accuracy'])

Model.fit विधि नुकसान को कम करने के लिए मॉडल मापदंडों को समायोजित करती है:

model.fit(x_train, y_train, epochs=5)
Epoch 1/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2913 - accuracy: 0.9147
Epoch 2/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.1418 - accuracy: 0.9584
Epoch 3/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.1058 - accuracy: 0.9681
Epoch 4/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.0879 - accuracy: 0.9730
Epoch 5/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.0744 - accuracy: 0.9765
<tensorflow.python.keras.callbacks.History at 0x7fc99a051290>

Model.evaluate विधि मॉडल के प्रदर्शन की जांच करती है, आमतौर पर " सत्यापन-सेट " या " टेस्ट-सेट " पर।

model.evaluate(x_test,  y_test, verbose=2)
313/313 - 0s - loss: 0.0737 - accuracy: 0.9784
[0.07365398108959198, 0.9783999919891357]
f

इमेज क्लासिफायरियर को अब इस डेटासेट पर ~98% सटीकता के लिए प्रशिक्षित किया गया है। अधिक जानने के लिए, TensorFlow ट्यूटोरियल पढ़ें।

यदि आप चाहते हैं कि आपका मॉडल एक प्रायिकता लौटाए, तो आप प्रशिक्षित मॉडल को लपेट सकते हैं, और उसमें सॉफ्टमैक्स संलग्न कर सकते हैं:

probability_model = tf.keras.Sequential([
  model,
  tf.keras.layers.Softmax()
])
probability_model(x_test[:5])
<tf.Tensor: shape=(5, 10), dtype=float32, numpy=
array([[1.7845143e-09, 6.2416250e-09, 8.8993971e-07, 5.0938579e-05,
        6.9239370e-10, 9.1531788e-08, 3.0702079e-12, 9.9993479e-01,
        1.6381224e-06, 1.1627582e-05],
       [1.6608839e-08, 6.1237602e-04, 9.9933952e-01, 4.5319266e-05,
        4.2082616e-14, 6.8845372e-07, 1.2797722e-08, 1.6431847e-12,
        2.0782168e-06, 2.8262946e-11],
       [1.3514825e-06, 9.9640971e-01, 1.8868307e-04, 2.4645233e-05,
        8.3467271e-04, 1.7597053e-05, 5.1044153e-05, 1.7571129e-03,
        6.8748201e-04, 2.7744498e-05],
       [9.9969614e-01, 3.3471906e-08, 1.3097884e-05, 3.4203765e-08,
        2.6330403e-07, 6.6318894e-06, 2.1209409e-04, 4.3179925e-06,
        1.5615402e-07, 6.7310575e-05],
       [4.4438386e-07, 5.8649330e-09, 6.7045465e-07, 6.9524458e-10,
        9.9840516e-01, 1.0503891e-07, 3.2713297e-07, 3.2584390e-05,
        3.4801921e-08, 1.5606619e-03]], dtype=float32)>