 TensorFlow.org पर देखें |  Google Colab में चलाएं |  GitHub पर स्रोत देखें |  नोटबुक डाउनलोड करें |
यह संक्षिप्त परिचय केरस का उपयोग करता है:
- एक पूर्वनिर्मित डेटासेट लोड करें।
- छवियों को वर्गीकृत करने वाला एक तंत्रिका नेटवर्क मशीन लर्निंग मॉडल बनाएं।
- इस तंत्रिका नेटवर्क को प्रशिक्षित करें।
- मॉडल की सटीकता का मूल्यांकन करें।
यह ट्यूटोरियल एक Google सहयोगी नोटबुक है। पायथन प्रोग्राम सीधे ब्राउज़र में चलाए जाते हैं - TensorFlow को सीखने और उपयोग करने का एक शानदार तरीका। इस ट्यूटोरियल का अनुसरण करने के लिए, इस पृष्ठ के शीर्ष पर स्थित बटन पर क्लिक करके नोटबुक को Google Colab में चलाएँ।
- Colab में, Python रनटाइम से कनेक्ट करें: मेन्यू बार में सबसे ऊपर दाईं ओर, कनेक्ट करें चुनें.
- सभी नोटबुक कोड सेल चलाएँ: रनटाइम > सभी चलाएँ चुनें।
TensorFlow सेट करें
शुरू करने के लिए अपने प्रोग्राम में TensorFlow आयात करें:
import tensorflow as tf
print("TensorFlow version:", tf.__version__)
TensorFlow version: 2.8.0-rc1
यदि आप Colab के बजाय अपने स्वयं के विकास परिवेश में अनुसरण कर रहे हैं, तो विकास के लिए TensorFlow की स्थापना के लिए स्थापित मार्गदर्शिका देखें।
डेटासेट लोड करें
लोड करें और 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 .अनुक्रमिक मॉडल बनाएं।
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([[ 0.2760778 , -0.39324787, -0.17098302, 1.2016621 , -0.03416392,
0.5461229 , -0.7203061 , -0.41886678, -0.59480035, -0.7580608 ]],
dtype=float32)
tf.nn.softmax फ़ंक्शन इन लॉग को प्रत्येक वर्ग के लिए संभावनाओं में परिवर्तित करता है:
tf.nn.softmax(predictions).numpy()
array([[0.11960829, 0.06124588, 0.0764901 , 0.30181262, 0.08770514,
0.15668967, 0.04416083, 0.05969675, 0.05006609, 0.04252464]],
dtype=float32)
नुकसान का उपयोग करके प्रशिक्षण के लिए एक हानि फ़ंक्शन को परिभाषित करें। 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()
1.8534881
प्रशिक्षण शुरू करने से पहले, Model.compile का उपयोग करके मॉडल को कॉन्फ़िगर और संकलित करें। optimizer वर्ग को adam पर सेट करें, loss को आपके द्वारा पहले परिभाषित किए गए loss_fn फ़ंक्शन पर सेट करें, और metrics पैरामीटर को accuracy पर सेट करके मॉडल के मूल्यांकन के लिए एक मीट्रिक निर्दिष्ट करें।
model.compile(optimizer='adam',
loss=loss_fn,
metrics=['accuracy'])
अपने मॉडल को प्रशिक्षित और मूल्यांकन करें
अपने मॉडल मापदंडों को समायोजित करने और नुकसान को कम करने के लिए Model.fit पद्धति का उपयोग करें:
model.fit(x_train, y_train, epochs=5)
Epoch 1/5 1875/1875 [==============================] - 4s 2ms/step - loss: 0.2950 - accuracy: 0.9143 Epoch 2/5 1875/1875 [==============================] - 3s 2ms/step - loss: 0.1451 - accuracy: 0.9567 Epoch 3/5 1875/1875 [==============================] - 4s 2ms/step - loss: 0.1080 - accuracy: 0.9668 Epoch 4/5 1875/1875 [==============================] - 4s 2ms/step - loss: 0.0906 - accuracy: 0.9717 Epoch 5/5 1875/1875 [==============================] - 4s 2ms/step - loss: 0.0749 - accuracy: 0.9761 <keras.callbacks.History at 0x7f062c606850>
Model.evaluate विधि मॉडल के प्रदर्शन की जांच करती है, आमतौर पर " सत्यापन-सेट " या " टेस्ट-सेट " पर।
model.evaluate(x_test, y_test, verbose=2)
313/313 - 1s - loss: 0.0783 - accuracy: 0.9755 - 588ms/epoch - 2ms/step [0.07825208455324173, 0.9754999876022339]
इमेज क्लासिफायरियर को अब इस डेटासेट पर ~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([[2.72807270e-08, 2.42517650e-08, 7.75602894e-06, 1.28684027e-04,
7.66215633e-11, 3.54162950e-07, 3.04894151e-14, 9.99857187e-01,
2.32766553e-08, 5.97762892e-06],
[7.37396704e-08, 4.73638036e-04, 9.99523997e-01, 7.20633352e-07,
4.54133671e-17, 1.42298268e-06, 5.96959016e-09, 1.23534145e-13,
7.77225608e-08, 6.98619169e-16],
[1.95462448e-07, 9.99295831e-01, 1.02249986e-04, 1.86699708e-05,
5.65737491e-06, 1.12115902e-06, 5.32719559e-06, 5.22767776e-04,
4.79981136e-05, 1.76624681e-07],
[9.99649286e-01, 1.80224735e-09, 3.73612856e-05, 1.52324446e-07,
1.30824594e-06, 2.82781020e-05, 6.99703523e-05, 3.30940424e-07,
2.13184350e-07, 2.13106396e-04],
[1.53770895e-06, 1.72272063e-08, 1.98980865e-06, 3.97882580e-08,
9.97192323e-01, 1.10544443e-05, 1.54713348e-06, 2.81727880e-05,
3.48721733e-06, 2.75991508e-03]], dtype=float32)>
निष्कर्ष
बधाई हो! आपने केरस एपीआई का उपयोग करके प्रीबिल्ट डेटासेट का उपयोग करके मशीन लर्निंग मॉडल को प्रशिक्षित किया है।
केरस का उपयोग करने के अधिक उदाहरणों के लिए, ट्यूटोरियल देखें। केरस के साथ मॉडल बनाने के बारे में अधिक जानने के लिए गाइड पढ़ें। यदि आप डेटा लोड करने और तैयार करने के बारे में अधिक जानना चाहते हैं, तो छवि डेटा लोडिंग या सीएसवी डेटा लोडिंग पर ट्यूटोरियल देखें।