अपना AI रेडियोलॉजिस्ट तैयार करें: VGG16 के साथ न्यूमोनिया डिटेक्टर बनाने के लिए एक मजेदार गाइड

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

चरण 1: अपना वातावरण स्थापित करना

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

 %pip install --upgrade tensorflow keras numpy pandas sklearn pillow

ये लाइब्रेरीज़ हमारे मॉडल के निर्माण और प्रशिक्षण के लिए आवश्यक हैं:

• तंत्रिका नेटवर्क बनाने और प्रशिक्षण के लिए tensorflow और keras ।
• संख्यात्मक कार्यों के लिए numpy .
• डेटा हेरफेर के लिए pandas .
• डेटा प्रीप्रोसेसिंग के लिए sklearn .
• छवि प्रसंस्करण के लिए pillow .

चरण 2: लाइब्रेरीज़ आयात करना

लाइब्रेरीज़ स्थापित होने के बाद, आइए उन्हें आयात करें:

 import os from tensorflow import keras from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Conv2D, MaxPool2D, Flatten from tensorflow.keras.preprocessing.image import ImageDataGenerator import numpy as np

हम इमेज प्रोसेसिंग कार्यों के लिए न्यूरल नेटवर्क मॉडल बनाने और उसे प्रशिक्षित करने के लिए आवश्यक कई आवश्यक लाइब्रेरी और मॉड्यूल आयात करके शुरू करते हैं। हम अपने डीप लर्निंग मॉडल बनाने और प्रबंधित करने के लिए TensorFlow और उसके सबमॉड्यूल का उपयोग करेंगे। विशेष रूप से, हम अपने उच्च-स्तरीय API के रूप में उपयोग करने के लिए Keras, परतों के रैखिक स्टैक के निर्माण के लिए Sequential, और विभिन्न न्यूरल नेटवर्क परतों के निर्माण और कॉन्फ़िगर करने के लिए Dense, Conv2D, MaxPool2D और Flatten जैसे मॉड्यूल आयात करेंगे। इसके अतिरिक्त, ImageDataGenerator हमें अपने इमेज डेटा को बढ़ाने में मदद करेगा, जिससे मॉडल की सामान्यीकरण करने की क्षमता बढ़ेगी। अंत में, हम इसके संख्यात्मक संचालन समर्थन के लिए numpy आयात करेंगे, जो विशेष रूप से सरणियों को संभालने और गणितीय कार्यों को करने के लिए उपयोगी है।

चरण 3: डेटा तैयार करना

हमारे AI रेडियोलॉजिस्ट को सीखने के लिए डेटा की आवश्यकता है। हम अपने प्रशिक्षण और सत्यापन डेटा को लोड करने और बढ़ाने के लिए ImageDataGenerator का उपयोग करेंगे: डेटा डाउनलोड करने के लिए, हम अपने ओपन-सोर्स डेटा मित्र Kaggle का उपयोग करेंगे, यहाँ दिए गए लिंक से लेबल किए गए डेटासेट को डाउनलोड करें।

यहां पर्यवेक्षित शिक्षण के संदर्भ में, लेबल किया गया डेटासेट वह आधारभूत सत्य होगा, जिसका पूर्वानुमान मशीन लर्निंग मॉडल को करना होगा।

 trdata = ImageDataGenerator() traindata = trdata.flow_from_directory(directory="data-task1/train", target_size=(224, 224)) tsdata = ImageDataGenerator() testdata = tsdata.flow_from_directory(directory="data-task1/val", target_size=(224, 224))

यह कोड स्निपेट हमारे प्रशिक्षण और सत्यापन डेटासेट के लिए डेटा जनरेटर सेट करता है। छवियों का आकार 224x224 पिक्सेल में बदल दिया जाता है, जो VGG16 मॉडल के लिए मानक इनपुट आकार है।

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

अब आता है मज़ेदार हिस्सा: VGG16 मॉडल बनाना। VGG16 एक लोकप्रिय कन्वोल्यूशनल न्यूरल नेटवर्क (CNN) आर्किटेक्चर है जो अपनी सादगी और प्रभावशीलता के लिए जाना जाता है, इसकी अनूठी आर्किटेक्चर की बदौलत जो मुख्य रूप से 13 कन्वोल्यूशनल लेयर्स और 3 पूरी तरह से कनेक्टेड लेयर्स पर बनी है। VGG16 को जो चीज़ अलग बनाती है, वह है डीप नेटवर्क के भीतर छोटे 3x3 कन्वोल्यूशनल फ़िल्टर का उपयोग। यह डिज़ाइन कम्प्यूटेशनल दक्षता सुनिश्चित करते हुए छवियों में जटिल पैटर्न को कैप्चर करता है। यहाँ बताया गया है कि हम इसे कैसे बनाते हैं:

 model = Sequential() model.add(Conv2D(input_shape=(224,224,3), filters=64, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=64, kernel_size=(3,3), padding="same", activation="relu")) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) model.add(Conv2D(filters=128, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=128, kernel_size=(3,3), padding="same", activation="relu")) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) model.add(Conv2D(filters=256, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=256, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=256, kernel_size=(3,3), padding="same", activation="relu")) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) model.add(Flatten()) model.add(Dense(units=4096, activation="relu")) model.add(Dense(units=4096, activation="relu")) model.add(Dense(units=2, activation="softmax")) model.summary()

आइये इसका विश्लेषण करें:

• Conv2D परतें: ये कन्वोल्यूशनल परतें हैं जो किनारों और बनावट जैसी विशेषताओं का पता लगाना सीखती हैं।
• MaxPool2D परतें: ये स्थानिक आयामों को कम करती हैं, तथा महत्वपूर्ण विशेषताओं को बरकरार रखती हैं।
• समतल परत: यह 2D फीचर मानचित्रों को 1D वेक्टर में परिवर्तित करता है।
• सघन परतें: ये वर्गीकरण के लिए पूर्णतः जुड़ी हुई परतें हैं।

चरण 5: मॉडल संकलित करना

हमारे मॉडल आर्किटेक्चर को परिभाषित करने के बाद, हमें इसे संकलित करने की आवश्यकता है:

 opt = keras.optimizers.Adam(learning_rate=0.001) model.compile(optimizer=opt, loss=keras.losses.binary_crossentropy, metrics=['accuracy'])

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

विभिन्न अनुकूलकों, सीखने की दरों और हानि कार्यों के साथ प्रयोग करने में संकोच न करें, क्योंकि यह अनुभव प्राप्त करने का एक शानदार तरीका है।

चरण 6: मॉडल का प्रशिक्षण

अब हमारे AI रेडियोलॉजिस्ट को प्रशिक्षित करने का समय आ गया है! हम सर्वश्रेष्ठ मॉडल को सहेजने के लिए कॉलबैक सेट करते हैं और यदि सत्यापन सटीकता में सुधार नहीं होता है तो जल्दी रोक देते हैं:

 from keras.callbacks import ModelCheckpoint, EarlyStopping checkpoint = ModelCheckpoint("vgg16_1.h5", monitor='val_accuracy', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1) early = EarlyStopping(monitor='val_accuracy', min_delta=0, patience=20, verbose=1, mode='auto') hist = model.fit_generator(steps_per_epoch=20, generator=traindata, validation_data=testdata, validation_steps=10, epochs=10, callbacks=[checkpoint, early])

• मॉडलचेकपॉइंट: सत्यापन सटीकता के आधार पर सर्वोत्तम मॉडल को सहेजता है।
• प्रारंभिक रोक: यदि मॉडल का प्रदर्शन निर्दिष्ट युगों तक नहीं सुधरता है तो प्रशिक्षण रोक दिया जाता है।

चरण 7: प्रशिक्षण प्रगति की कल्पना करना

यह देखने के लिए कि हमारा मॉडल कैसा प्रदर्शन कर रहा है, हम प्रशिक्षण और सत्यापन हानि और सटीकता का ग्राफ बना सकते हैं:

 import matplotlib.pyplot as plt # Training loss plt.plot(hist.history['loss']) plt.legend(['Training']) plt.title('Training loss') plt.ylabel('loss') plt.xlabel('epoch') plt.show() # Validation loss plt.plot(hist.history['val_loss']) plt.legend(['Validation']) plt.title('Validation loss') plt.ylabel('validation loss') plt.xlabel('epoch') plt.show() # Training and validation accuracy plt.plot(hist.history['accuracy']) plt.plot(hist.history['val_accuracy']) plt.legend(['Training', 'Validation']) plt.title('Training & Validation accuracy') plt.xlabel('epoch') plt.show()

ये रेखाचित्र हमें यह समझने में मदद करेंगे कि हमारा मॉडल कितनी अच्छी तरह सीख रहा है और क्या यह ओवरफिटिंग या अंडरफिटिंग है।

चरण 8: भविष्यवाणियां करना

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

 from tensorflow.keras.preprocessing import image # Load and preprocess image img_path = 'path_to_your_image.jpg' img = image.load_img(img_path, target_size=(224, 224)) img_array = image.img_to_array(img) img_array = np.expand_dims(img_array, axis=0) # Create batch axis # Make prediction prediction = model.predict(img_array) print('Prediction:', prediction)

चरण 9: फाइन-ट्यूनिंग और प्रयोग

एआई रेडियोलॉजिस्ट बनाना तो बस शुरुआत है। अपने मॉडल को बेहतर बनाने और उसे बेहतर बनाने के लिए यहां कुछ सुझाव दिए गए हैं:

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

निष्कर्ष

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