S40L12 – एक सरल अंक वर्गीकारक

html
Keras और MNIST के साथ अंक वर्गीकरण के लिए एक सरल न्यूरल नेटवर्क बनाना

विषय सूचि

    अंक वर्गीकरण के लिए न्यूरल नेटवर्क का परिचय
    MNIST डाटासेट को समझना
    पर्यावरण सेट करना
    MNIST डाटासेट लोड करना और उसका पता लगाना
    डेटा प्रीप्रोसेसिंग: पुनःआकार देना और वन-हॉट एन्कोडिंग
    Keras के साथ न्यूरल नेटवर्क मॉडल बनाना
        
            मॉडल आर्किटेक्चर
            लेयरों की व्याख्या
        
    
    मॉडल कंपाइल करना: लॉस फंक्शन और ऑप्टिमाइज़र
    मॉडल को प्रशिक्षित करना: फिटिंग और वैधता
    मॉडल का मूल्यांकन: सटीकता और भविष्यवाणियाँ
    न्यूरल नेटवर्क संरचना का विज़ुअलाइज़ेशन
    प्रशिक्षण का अनुकूलन: GPUs का उपयोग करना
    निष्कर्ष




अंक वर्गीकरण के लिए न्यूरल नेटवर्क का परिचय 
न्यूरल नेटवर्कों ने मशीनों के डेटा की व्याख्या और विश्लेषण करने के तरीके में क्रांति ला दी है, विशेष रूप से छवि मान्यता के क्षेत्र में। अंक वर्गीकरण, जिसका लक्ष्य हस्तलिखित अंकों की सटीक पहचान करना होता है, शुरुआती लोगों के लिए न्यूरल नेटवर्क के मूल सिद्धांतों को समझने के लिए एक आदर्श उदाहरण के रूप में कार्य करता है। Keras जैसी लोकप्रिय लाइब्रेरीज़ और MNIST जैसी डाटासेट्स का उपयोग करके, एक प्रभावी अंक वर्गीकर्ता बनाना सुलभ और शैक्षिक दोनों बन जाता है।

MNIST डाटासेट को समझना 
MNIST (Modified National Institute of Standards and Technology) डाटासेट मशीन लर्निंग समुदाय में एक आधारशिला है। इसमें 70,000 ग्रेस्केल छवियाँ हैं जो हस्तलिखित अंकों (0-9) की हैं, जिनका आकार प्रत्येक 28x28 पिक्सेल है। इस डाटासेट को 60,000 प्रशिक्षण छवियों और 10,000 परीक्षण छवियों में विभाजित किया गया है, जिससे यह मशीन लर्निंग मॉडलों को प्रशिक्षित करने और मान्य करने के लिए आदर्श बनाता है।

MNIST की मुख्य विशेषताएँ:

    आकार: 70,000 छवियाँ (60k प्रशिक्षण, 10k परीक्षण)
    छवि आयाम: 28x28 पिक्सेल
    श्रेणियाँ: 10 (अंक 0 से 9 तक)
    ग्रेस्केल: प्रत्येक पिक्सेल मान 0 (काला) से 255 (सफेद) तक होता है


पर्यावरण सेट करना 
मॉडल बनाने की प्रक्रिया में गोता लगाने से पहले, विकास पर्यावरण सेट करना आवश्यक है। सुनिश्चित करें कि आपके पास Python स्थापित है, और पैकेजों और निर्भरताओं को सहजता से प्रबंधित करने के लिए Anaconda जैसी एनवायरनमेंट का उपयोग करने पर विचार करें।

आवश्यक लाइब्रेरीज़:

    NumPy: संख्यात्मक संचालन के लिए
    Matplotlib: डेटा विज़ुअलाइज़ेशन के लिए
    Keras: न्यूरल नेटवर्क बनाने और प्रशिक्षित करने के लिए
    Scikit-learn: प्रीप्रोसेसिंग यूटिलिटीज़ के लिए
    Pandas: डेटा मैनिपुलेशन के लिए


स्थापना कमांड्स:




		
		
			
			
Java
			
			pip install numpy matplotlib keras scikit-learn pandas
			
				
					
				
					1
				
						pip install numpy matplotlib keras scikit-learn pandas
					
				
			
		



MNIST डाटासेट लोड करना और उसका पता लगाना 
Keras अपने datasets मॉड्यूल के माध्यम से MNIST डाटासेट तक पहुंचने की प्रक्रिया को सरल बनाता है। यहां बताया गया है कि आप डेटा कैसे लोड और निरीक्षण कर सकते हैं:





		
		
			
			
Java
			
			import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist

# Load MNIST handwritten digit data
(X_train, y_train), (X_test, y_test) = mnist.load_data()

print(X_train.shape)  # Output: (60000, 28, 28)
print(X_test.shape)   # Output: (10000, 28, 28)
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
 
# Load MNIST handwritten digit data
(X_train, y_train), (X_test, y_test) = mnist.load_data()
 
print(X_train.shape)  # Output: (60000, 28, 28)
print(X_test.shape)   # Output: (10000, 28, 28)
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			(60000, 28, 28)
(10000, 28, 28)
			
				
					
				
					1
2
				
						(60000, 28, 28)
(10000, 28, 28)
					
				
			
		



यह स्पष्ट करता है कि 60,000 प्रशिक्षण छवियाँ और 10,000 परीक्षण छवियाँ हैं, प्रत्येक का आकार 28x28 पिक्सेल है।

नमूना छवियों का विज़ुअलाइज़ेशन
डेटा की समझ प्राप्त करने के लिए, आइए एक नमूना छवि को विज़ुअलाइज़ करें:





		
		
			
			
Java
			
			img = X_train[250].reshape(28,28)
plt.imshow(img, cmap="gray")
plt.title(f"Sample Digit Label: {y_train[250]}")
plt.show()
			
				
					
				
					1
2
3
4
				
						img = X_train[250].reshape(28,28)
plt.imshow(img, cmap="gray")
plt.title(f"Sample Digit Label: {y_train[250]}")
plt.show()
					
				
			
		



आउटपुट:


नोट: वास्तविक छवि लेबल के अनुरूप एक हस्तलिखित अंक प्रदर्शित करेगी।

डेटा प्रीप्रोसेसिंग: पुनःआकार देना और वन-हॉट एन्कोडिंग 
डेटा प्रीप्रोसेसिंग मशीन लर्निंग वर्कफ़्लोज़ में एक महत्वपूर्ण चरण है। न्यूरल नेटवर्क के लिए, डेटा को उचित रूप से फ़ॉर्मेट करना और लेबल्स को एन्कोड करना आवश्यक है।

डेटा का पुनःआकार देना
न्यूरल नेटवर्क्स को इनपुट डेटा एक विशेष आकार में चाहिए होता है। MNIST डाटासेट के लिए, हम 28x28 पिक्सेल छवियों को 784 तत्वों की 1D सरणी में फ्लैट करेंगे।





		
		
			
			
Java
			
			from keras.utils import to_categorical

# Reshape and normalize the image data
X_train = X_train.reshape(60000, 28, 28).astype('float32') / 255
X_test = X_test.reshape(10000, 28, 28).astype('float32') / 255
			
				
					
				
					1
2
3
4
5
				
						from keras.utils import to_categorical
 
# Reshape and normalize the image data
X_train = X_train.reshape(60000, 28, 28).astype('float32') / 255
X_test = X_test.reshape(10000, 28, 28).astype('float32') / 255
					
				
			
		



लेबल्स का वन-हॉट एन्कोडिंग
वन-हॉट एन्कोडिंग श्रेणात्मक लेबल्स को बाइनरी मैट्रिक्स में परिवर्तित करता है, जो प्रशिक्षण के लिए अधिक उपयुक्त होता है।





		
		
			
			
Java
			
			# One-hot encode the labels
y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)

print(y_train.shape)  # Output: (60000, 10)
print(y_test.shape)   # Output: (10000, 10)
			
				
					
				
					1
2
3
4
5
6
				
						# One-hot encode the labels
y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)
 
print(y_train.shape)  # Output: (60000, 10)
print(y_test.shape)   # Output: (10000, 10)
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			(60000, 10)
(10000, 10)
			
				
					
				
					1
2
				
						(60000, 10)
(10000, 10)
					
				
			
		



यह इंगित करता है कि प्रत्येक लेबल अब 10-आयामी बाइनरी वेक्टर के रूप में प्रतिनिधित्व किया गया है।

Keras के साथ न्यूरल नेटवर्क मॉडल बनाना 
Keras एक उपयोगकर्ता-मित्रवत API प्रदान करता है जिससे न्यूरल नेटवर्क्स का निर्माण और प्रशिक्षण किया जा सकता है। हम कई डेंस लेयरों से मिलकर एक सरल Sequential मॉडल बनाएंगे।

मॉडल आर्किटेक्चर 
मॉडल संरचना का यहां एक उच्च-स्तरीय अवलोकन है:

    Flatten Layer: 2D छवि डेटा को 1D सरणी में परिवर्तित करता है।
    Dense Layer 1: सिग्मॉइड सक्रियता के साथ 100 न्यूरॉन्स।
    Dense Layer 2: सिग्मॉइड सक्रियता के साथ 144 न्यूरॉन्स।
    Output Layer: 10 न्यूरॉन्स (प्रत्येक अंक के लिए एक) सॉफ्टमैक्स सक्रियता के साथ।


लेयरों की व्याख्या 

    Flatten Layer: इनपुट डेटा को 2D मैट्रिक्स (28x28) से 1D वेक्टर (784) में परिवर्तित करता है ताकि इसे डेंस लेयरों में फीड किया जा सके।
    Dense Layers: ये पूर्ण रूप से जुड़े लेयर होते हैं जहां प्रत्येक न्यूरॉन को पिछले लेयर के सभी न्यूरॉन्स से इनपुट प्राप्त होता है। सक्रियण फ़ंक्शन्स गैर-रेखीयता पेश करते हैं:
        
            Sigmoid Activation: 0 और 1 के बीच मान उत्पन्न करता है, बाइनरी वर्गीकरण के लिए उपयोगी है लेकिन मल्टी-क्लास समस्याओं के लिए गुप्त लेयरों में कम सामान्य है।
            Softmax Activation: अंतिम लेयर के आउटपुट को 10 श्रेणियों पर प्रायिकता वितरण में परिवर्तित करता है।
        
    


मॉडल का निर्माण:




		
		
			
			
Java
			
			from keras.models import Sequential
from keras.layers import Dense, Flatten

# Create a simple Neural Network model
model = Sequential()
model.add(Flatten(input_shape=(28,28)))
model.add(Dense(100, activation='sigmoid'))
model.add(Dense(144, activation='sigmoid'))
model.add(Dense(10, activation='softmax'))
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						from keras.models import Sequential
from keras.layers import Dense, Flatten
 
# Create a simple Neural Network model
model = Sequential()
model.add(Flatten(input_shape=(28,28)))
model.add(Dense(100, activation='sigmoid'))
model.add(Dense(144, activation='sigmoid'))
model.add(Dense(10, activation='softmax'))
					
				
			
		



मॉडल समरी
मॉडल संरचना और पैरामीटर्स को विज़ुअलाइज़ करने के लिए:





		
		
			
			
Java
			
			model.summary()
			
				
					
				
					1
				
						model.summary()
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			Model: "sequential_1"
_______________________________________________________________
Layer (type)                 Output Shape              Param #   
===============================================================
flatten_1 (Flatten)          (None, 784)               0         
_______________________________________________________________
dense_3 (Dense)              (None, 100)               78500     
_______________________________________________________________
dense_4 (Dense)              (None, 144)               14444     
_______________________________________________________________
dense_5 (Dense)              (None, 10)                1450      
===============================================================
Total params: 94,494
Trainable params: 94,494
Non-trainable params: 0
_______________________________________________________________
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						Model: "sequential_1"
_______________________________________________________________
Layer (type)                 Output Shape              Param #   
===============================================================
flatten_1 (Flatten)          (None, 784)               0         
_______________________________________________________________
dense_3 (Dense)              (None, 100)               78500     
_______________________________________________________________
dense_4 (Dense)              (None, 144)               14444     
_______________________________________________________________
dense_5 (Dense)              (None, 10)                1450      
===============================================================
Total params: 94,494
Trainable params: 94,494
Non-trainable params: 0
_______________________________________________________________
					
				
			
		



यह समरी प्रत्येक लेयर के आउटपुट आकार और प्रशिक्षित किए जाने वाले पैरामीटर्स की संख्या के बारे में अंतर्दृष्टि प्रदान करती है।

मॉडल कंपाइल करना: लॉस फंक्शन और ऑप्टिमाइज़र 
प्रशिक्षण से पहले, मॉडल को निर्दिष्ट लॉस फंक्शन और ऑप्टिमाइज़र के साथ कंपाइल करना आवश्यक है।

    Loss Function: मापता है कि मॉडल की भविष्यवाणियाँ वास्तविक लेबल्स से कितनी मेल खाती हैं।
        
            Categorical Crossentropy: मल्टी-क्लास वर्गीकरण समस्याओं के लिए उपयुक्त।
        
    
    Optimizer: मॉडल के वेट्स को अपडेट करता है ताकि लॉस फंक्शन को न्यूनतम किया जा सके।
        
            Adam Optimizer: एक प्रभावी स्टोकास्टिक ग्रेडियंट डिसेंट विधि है जो लर्निंग रेट को अनुकूलित करती है।
        
    


मॉडल कंपाइल करना:




		
		
			
			
Java
			
			model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc'])
			
				
					
				
					1
				
						model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc'])
					
				
			
		



मॉडल को प्रशिक्षित करना: फिटिंग और वैधता 
प्रशिक्षण में मॉडल को डेटा प्रदान करना और इसे कई epochs के माध्यम से पैटर्न सीखने देना शामिल है।

    Epochs: पूरे डाटासेट को नेटवर्क के माध्यम से पारित करने की संख्या।
    Validation Data: प्रत्येक epoch के बाद अनदेखे डेटा पर मॉडल के प्रदर्शन का मूल्यांकन करने के लिए उपयोग किया जाता है।


प्रशिक्षण प्रक्रिया:




		
		
			
			
Java
			
			history = model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))
			
				
					
				
					1
				
						history = model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))
					
				
			
		



नमूना आउटपुट:




		
		
			
			
Java
			
			Epoch 1/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.9009 - acc: 0.7596 - val_loss: 0.3685 - val_acc: 0.8892
...
Epoch 10/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.2251 - acc: 0.9314 - val_loss: 0.2267 - val_acc: 0.9303
			
				
					
				
					1
2
3
4
5
				
						Epoch 1/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.9009 - acc: 0.7596 - val_loss: 0.3685 - val_acc: 0.8892
...
Epoch 10/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.2251 - acc: 0.9314 - val_loss: 0.2267 - val_acc: 0.9303
					
				
			
		



10 epochs के अंत तक, मॉडल ने प्रशिक्षण और वैधता दोनों डाटासेट पर लगभग 93% सटीकता प्राप्त की, जो एक अच्छा प्रदर्शन करने वाला मॉडल दर्शाती है।

मॉडल का मूल्यांकन: सटीकता और भविष्यवाणियाँ 
प्रशिक्षण के बाद, मॉडल के प्रदर्शन का मूल्यांकन करना और नए डेटा पर भविष्यवाणियाँ करना महत्वपूर्ण है।

भविष्यवाणियाँ करना




		
		
			
			
Java
			
			# Predicting on the test set
predictions = model.predict(X_test)
			
				
					
				
					1
2
				
						# Predicting on the test set
predictions = model.predict(X_test)
					
				
			
		



प्रत्येक भविष्यवाणी 10 श्रेणियों पर एक प्रायिकता वितरण से मिलकर होती है। भविष्यवाणी की गई श्रेणी निर्धारित करने के लिए:





		
		
			
			
Java
			
			import numpy as np

# Convert probabilities to class labels
predicted_classes = np.argmax(predictions, axis=1)
true_classes = np.argmax(y_test, axis=1)
			
				
					
				
					1
2
3
4
5
				
						import numpy as np
 
# Convert probabilities to class labels
predicted_classes = np.argmax(predictions, axis=1)
true_classes = np.argmax(y_test, axis=1)
					
				
			
		



भविष्यवाणियों का विज़ुअलाइज़ेशन
आइए कुछ परीक्षण छवियों को उनकी भविष्यवाणी और वास्तविक लेबल्स के साथ विज़ुअलाइज़ करें:





		
		
			
			
Java
			
			import matplotlib.pyplot as plt

def plot_prediction(index):
    img = X_test[index].reshape(28,28)
    plt.imshow(img, cmap="gray")
    plt.title(f"True Label: {true_classes[index]} | Predicted: {predicted_classes[index]}")
    plt.show()

# Plotting the first test image
plot_prediction(0)

# Plotting another sample
plot_prediction(25)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						import matplotlib.pyplot as plt
 
def plot_prediction(index):
    img = X_test[index].reshape(28,28)
    plt.imshow(img, cmap="gray")
    plt.title(f"True Label: {true_classes[index]} | Predicted: {predicted_classes[index]}")
    plt.show()
 
# Plotting the first test image
plot_prediction(0)
 
# Plotting another sample
plot_prediction(25)
					
				
			
		



आउटपुट:
छवि प्रदर्शित करती है जिसमें वास्तविक लेबल और मॉडल की भविष्यवाणी दोनों को संकेत करने वाले शीर्षक होते हैं।

मॉडल की सटीकता
मॉडल ने वैधता सेट पर 93% सटीकता प्राप्त की, जो अनदेखे डेटा पर अच्छी तरह से सामान्यीकरण करने की इसकी क्षमता को दर्शाता है। बेहतर प्रदर्शन के लिए, आगे की ट्यूनिंग और अधिक जटिल आर्किटेक्चर की खोज की जा सकती है।

न्यूरल नेटवर्क संरचना का विज़ुअलाइज़ेशन 
न्यूरल नेटवर्क की संरचना को समझना यह समझने में मदद कर सकता है कि डेटा कैसे प्रवाहित होता है और परिवर्तनों का क्रम कैसे होता है। नीचे निर्मित न्यूरल नेटवर्क का एक विज़ुअल प्रतिनिधित्व है:





		
		
			
			
Java
			
			import matplotlib.pyplot as plt

def draw_neural_net(ax, left, right, bottom, top, layer_sizes):
    '''
    Draws a neural network diagram.
    
    :param ax: Matplotlib Axes object
    :param left: Left boundary
    :param right: Right boundary
    :param bottom: Bottom boundary
    :param top: Top boundary
    :param layer_sizes: List containing the number of neurons in each layer
    '''
    n_layers = len(layer_sizes)
    v_spacing = (top - bottom)/float(max(layer_sizes))
    h_spacing = (right - left)/float(n_layers - 1)
    
    # Draw neurons
    for n, layer_size in enumerate(layer_sizes):
        layer_top = v_spacing*(layer_size - 1)/2. + (top + bottom)/2.
        for m in range(layer_size):
            circle = plt.Circle((n*h_spacing + left, layer_top - m*v_spacing), v_spacing/4.,
                                color='w', ec='k', zorder=4)
            ax.add_artist(circle)
    
    # Draw edges
    for n, (layer_size_a, layer_size_b) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])):
        layer_top_a = v_spacing*(layer_size_a - 1)/2. + (top + bottom)/2.
        layer_top_b = v_spacing*(layer_size_b - 1)/2. + (top + bottom)/2.
        for m in range(layer_size_a):
            for o in range(layer_size_b):
                line = plt.Line2D([n*h_spacing + left, (n + 1)*h_spacing + left],
                                  [layer_top_a - m*v_spacing, layer_top_b - o*v_spacing], c='k')
                ax.add_artist(line)

# Drawing the neural network
fig = plt.figure(figsize=(12, 12))
ax = fig.gca()
ax.axis('off')
draw_neural_net(ax, .1, .9, .1, .9, [784, 100, 144, 10])
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
				
						import matplotlib.pyplot as plt
 
def draw_neural_net(ax, left, right, bottom, top, layer_sizes):
    '''
    Draws a neural network diagram.
    
    :param ax: Matplotlib Axes object
    :param left: Left boundary
    :param right: Right boundary
    :param bottom: Bottom boundary
    :param top: Top boundary
    :param layer_sizes: List containing the number of neurons in each layer
    '''
    n_layers = len(layer_sizes)
    v_spacing = (top - bottom)/float(max(layer_sizes))
    h_spacing = (right - left)/float(n_layers - 1)
    
    # Draw neurons
    for n, layer_size in enumerate(layer_sizes):
        layer_top = v_spacing*(layer_size - 1)/2. + (top + bottom)/2.
        for m in range(layer_size):
            circle = plt.Circle((n*h_spacing + left, layer_top - m*v_spacing), v_spacing/4.,
                                color='w', ec='k', zorder=4)
            ax.add_artist(circle)
    
    # Draw edges
    for n, (layer_size_a, layer_size_b) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])):
        layer_top_a = v_spacing*(layer_size_a - 1)/2. + (top + bottom)/2.
        layer_top_b = v_spacing*(layer_size_b - 1)/2. + (top + bottom)/2.
        for m in range(layer_size_a):
            for o in range(layer_size_b):
                line = plt.Line2D([n*h_spacing + left, (n + 1)*h_spacing + left],
                                  [layer_top_a - m*v_spacing, layer_top_b - o*v_spacing], c='k')
                ax.add_artist(line)
 
# Drawing the neural network
fig = plt.figure(figsize=(12, 12))
ax = fig.gca()
ax.axis('off')
draw_neural_net(ax, .1, .9, .1, .9, [784, 100, 144, 10])
plt.show()
					
				
			
		



आउटपुट:


यह आरेख इनपुट न्यूरॉन्स (784) से गुप्त लेयरों के माध्यम से आउटपुट न्यूरॉन्स (10) तक प्रवाह को दर्शाता है।

प्रशिक्षण का अनुकूलन: GPUs का उपयोग करना 
न्यूरल नेटवर्क्स का प्रशिक्षण, विशेष रूप से गहरे न्यूरल नेटवर्क्स, गणनात्मक रूप से भारी और समय लेने वाला हो सकता है। ग्राफ़िक्स प्रोसेसिंग यूनिट्स (GPUs) का उपयोग करके प्रशिक्षण प्रक्रिया को काफी तेज किया जा सकता है। यहां बताया गया है कि आप Keras के साथ GPUs का उपयोग कैसे कर सकते हैं:

    GPU संगतता सुनिश्चित करें:
        
            NVIDIA CUDA Toolkit और cuDNN स्थापित करें।
            सुनिश्चित करें कि आपका GPU TensorFlow (Keras के बैकएंड) के साथ संगत है।
        
    
    GPU-संगत TensorFlow स्थापित करें:
        



		
		
			
			
Java
			
			pip install tensorflow-gpu
			
				
					
				
					1
				
						pip install tensorflow-gpu
					
				
			
		


    
    GPU का उपयोग करने के लिए TensorFlow को कॉन्फ़िगर करें:
        TensorFlow स्वचालित रूप से GPUs का पता लगाता है और उनका उपयोग करता है। हालांकि, यदि आवश्यक हो तो आप स्पष्ट रूप से GPU सेटिंग्स निर्दिष्ट कर सकते हैं।
        



		
		
			
			
Java
			
			import tensorflow as tf

gpus = tf.config.list_physical_devices('GPU')
if gpus:
    try:
        # TensorFlow को केवल पहले GPU का उपयोग करने के लिए प्रतिबंधित करें
        tf.config.set_visible_devices(gpus[0], 'GPU')
        tf.config.experimental.set_memory_growth(gpus[0], True)
    except RuntimeError as e:
        print(e)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						import tensorflow as tf
 
gpus = tf.config.list_physical_devices('GPU')
if gpus:
    try:
        # TensorFlow को केवल पहले GPU का उपयोग करने के लिए प्रतिबंधित करें
        tf.config.set_visible_devices(gpus[0], 'GPU')
        tf.config.experimental.set_memory_growth(gpus[0], True)
    except RuntimeError as e:
        print(e)
					
				
			
		


    


GPUs का उपयोग करने के लाभ:

    पैरेलल प्रोसेसिंग: GPUs कई गणनाओं को एक साथ संभाल सकते हैं, जो न्यूरल नेटवर्क्स में मैट्रिक्स संचालन के लिए आदर्श हैं।
    तेज़ प्रशिक्षण: मॉडल काफी तेजी से प्रशिक्षित होते हैं, जिससे अधिक प्रयोग और तेज पुनरावृत्तियाँ संभव होती हैं।


नोट: GPU उपयोग को अनुकूलित करने के लिए विशिष्ट सिस्टम सेटअप के आधार पर अतिरिक्त कॉन्फ़िगरेशन की आवश्यकता हो सकती है।

निष्कर्ष 
Keras और MNIST डाटासेट का उपयोग करके अंक वर्गीकरण के लिए एक सरल न्यूरल नेटवर्क बनाना मशीन लर्निंग और डीप लर्निंग की दुनिया में एक उत्कृष्ट परिचय है। इस गाइड का अनुसरण करके, आपने यह सीखा है कि:

    MNIST डाटासेट को समझें और प्रीप्रोसेस करें।
    Keras के साथ एक न्यूरल नेटवर्क मॉडल का निर्माण करें।
    मॉडल के प्रदर्शन को प्रशिक्षित और मूल्यांकन करें।
    नेटवर्क आर्किटेक्चर को विज़ुअलाइज़ करें।
    GPUs का उपयोग करके प्रशिक्षण को अनुकूलित करें।


हालांकि चर्चा किए गए मॉडल ने सम्मानजनक सटीकता प्राप्त की है, इसमें सुधार की पर्याप्त गुंजाइश है। अधिक जटिल आर्किटेक्चर की खोज, विभिन्न सक्रियण फ़ंक्शन्स के साथ प्रयोग, या नियमितीकरण तकनीकों को लागू करना बेहतर प्रदर्शन की ओर ले जा सकता है। जैसे-जैसे आप अपनी मशीन लर्निंग यात्रा जारी रखते हैं, इन मूल तत्वों पर निर्माण करना आपको और अधिक जटिल और प्रभावशाली परियोजनाओं को संभालने में सक्षम करेगा।

कोडिंग शुभकामनाएँ!