डेटा ऑग्मेंटेशन पर एक संपूर्ण मार्गदर्शिका

डेटा ऑग्मेंटेशन तकनीकें

इस खंड में, हम ऑडियो, टेक्स्ट, इमेज और एडवांस्ड डेटा ऑग्मेंटेशन तकनीकों के बारे में जानेंगे। 

ऑडियो डेटा ऑग्मेंटेशन

1. नॉइज़ इंजेक्शन: मॉडल के प्रदर्शन में सुधार के लिए ऑडियो डेटासेट में Gaussian या रैंडम नॉइज़ जोड़ें। 
2. शिफ्टिंग: ऑडियो को बाएँ (फास्ट फॉरवर्ड) या दाएँ यादृच्छिक सेकंडों से शिफ्ट करें।
3. स्पीड बदलना: समय-श्रृंखला को एक निश्चित दर से स्ट्रेच करता है।
4. पिच बदलना: ऑडियो की पिच को यादृच्छिक रूप से बदलें। 

टेक्स्ट डेटा ऑग्मेंटेशन

1. शब्द या वाक्य शफ़लिंग: किसी शब्द या वाक्य की स्थिति को यादृच्छिक रूप से बदलना। 
2. शब्द प्रतिस्थापन: शब्दों को समानार्थक शब्दों से बदलें।
3. सिंटैक्स-ट्री मैनिपुलेशन: उसी शब्दावली का उपयोग करके वाक्य का पैराफ्रेज़ करें।
4. रैंडम शब्द इंसर्शन: शब्दों को यादृच्छिक रूप से जोड़ना। 
5. रैंडम शब्द डिलीशन: शब्दों को यादृच्छिक रूप से हटाना। 

इमेज ऑग्मेंटेशन

हैंड्स-ऑन अभ्यासों के साथ इमेज ट्रांसफॉर्मेशन और मैनिपुलेशन के बारे में अधिक जानें हमारे Image Processing with Python स्किल ट्रैक में।

1. ज्योमेट्रिक ट्रांसफॉर्मेशन: इमेज को यादृच्छिक रूप से फ्लिप, क्रॉप, रोटेट, स्ट्रेच और ज़ूम करें। आपको एक ही इमेज पर कई ट्रांसफॉर्मेशन लागू करने में सावधानी बरतने की आवश्यकता है, क्योंकि इससे मॉडल का प्रदर्शन कम हो सकता है। 
2. कलर स्पेस ट्रांसफॉर्मेशन: RGB कलर चैनल, कॉन्ट्रास्ट और ब्राइटनेस को यादृच्छिक रूप से बदलें।
3. कर्नेल फ़िल्टर: इमेज की शार्पनेस या ब्लरिंग को यादृच्छिक रूप से बदलें। 
4. रैंडम इरेज़िंग: प्रारंभिक इमेज के कुछ हिस्से हटाएँ।
5. इमेज मिक्सिंग: एक से अधिक इमेज को ब्लेंड और मिक्स करें। 

एडवांस्ड तकनीकें

1. जनरेटिव एडवर्सेरियल नेटवर्क (GANs): नए डेटा पॉइंट्स या इमेज जनरेट करने के लिए उपयोग किया जाता है। सिंथेटिक डेटा बनाने के लिए इसे मौजूदा डेटा की आवश्यकता नहीं होती। 
2. न्यूरल स्टाइल ट्रांसफर: कन्वॉल्यूशनल लेयर्स की एक श्रृंखला जो इमेज को डीकंस्ट्रक्ट करके संदर्भ और स्टाइल को अलग करना सीखती है।

डेटा ऑग्मेंटेशन के अनुप्रयोग

डेटा ऑग्मेंटेशन उन सभी मशीन लर्निंग अनुप्रयोगों पर लागू हो सकता है जहाँ गुणवत्तापूर्ण डेटा प्राप्त करना चुनौतीपूर्ण है। इसके अलावा, यह सभी अध्ययन क्षेत्रों में मॉडल की मज़बूती और प्रदर्शन में सुधार करने में मदद कर सकता है। 

स्वास्थ्य सेवा

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

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

छवि स्रोत ibrahimsobh.github.io | kaggle-COVID19-Classification

सेल्फ-ड्राइविंग कारें

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

छवि: David Silver | Autonomous Visualization System from Uber ATG

सिम्युलेशन के रूप में ऑग्मेंटेड डेटा की संभावनाएँ अनंत हैं, क्योंकि इसका उपयोग वास्तविक दुनिया के परिदृश्यों को जनरेट करने में किया जा सकता है। 

नेचुरल लैंग्वेज प्रोसेसिंग

टेक्स्ट डेटा ऑग्मेंटेशन आम तौर पर ऐसी स्थितियों में उपयोग किया जाता है जहाँ गुणवत्तापूर्ण डेटा सीमित हो और प्रदर्शन मीट्रिक में सुधार प्राथमिकता हो। आप सिनोनिम ऑग्मेंटेशन, वर्ड एम्बेडिंग, कैरेक्टर स्वैप, और रैंडम इंसर्शन व डिलीशन लागू कर सकते हैं। ये तकनीकें लो-रिसोर्स भाषाओं के लिए भी मूल्यवान हैं। 

छवि स्रोत Papers With Code | Selective Text Augmentation with Word Roles for Low-Resource Text Classification.

शोधकर्ता उच्च त्रुटि पहचान वाले परिदृश्यों, सीक्वेंस-टू-सीक्वेंस डेटा जेनरेशन और टेक्स्ट क्लासिफिकेशन में भाषा मॉडलों के लिए टेक्स्ट ऑग्मेंटेशन का उपयोग करते हैं। 

स्वचालित स्पीच रिकग्निशन

साउंड क्लासिफिकेशन और स्पीच रिकग्निशन में डेटा ऑग्मेंटेशन कमाल करता है। यह लो-रिसोर्स भाषाओं पर भी मॉडल के प्रदर्शन में सुधार करता है। 

छवि: Edward Ma | Noise Injection

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

डेटा ऑग्मेंटेशन के नैतिक निहितार्थ

हालाँकि डेटा ऑग्मेंटेशन मशीन लर्निंग मॉडलों को सशक्त बनाने का एक शक्तिशाली उपकरण है, यह कई नैतिक चिंताएँ भी उठाता है जिन पर सावधानीपूर्वक विचार आवश्यक है:

1. पक्षपात की वृद्धि: पक्षपाती डेटासेट का ऑग्मेंटेशन मौजूदा असमानताओं को दोहरा और बढ़ा सकता है, जिससे कम प्रतिनिधित्व वाले समूहों के लिए मॉडल का प्रदर्शन खराब हो सकता है।
2. गोपनीयता जोखिम: सिंथेटिक डेटा जेनरेशन अनजाने में मूल डेटासेट के संवेदनशील विवरणों को बनाए रख सकता है, जिससे गोपनीयता नियमों का उल्लंघन होने का जोखिम रहता है।
3. डेटा की प्रामाणिकता: गलत तरीके से लागू ऑग्मेंटेशन अवास्तविक या भ्रामक डेटा पॉइंट्स उत्पन्न कर सकते हैं, जो मॉडल के प्रदर्शन और भरोसे को प्रभावित कर सकते हैं।
4. पारदर्शिता: ऑग्मेंटेशन तकनीकों का स्पष्ट दस्तावेज़ीकरण करना और यह सुनिश्चित करना महत्वपूर्ण है कि हितधारक समझें कि डेटा को कैसे रूपांतरित या जनरेट किया जा रहा है।
5. न्याय और समानता: ऑग्मेंटेड डेटा में विविध जनसंख्या और परिदृश्यों का प्रतिबिंब होना आवश्यक है ताकि अनपेक्षित पक्षपात से बचा जा सके और मज़बूत मॉडल प्रदर्शन सुनिश्चित किया जा सके।
6. नियामक अनुपालन: ऑग्मेंटेड डेटासेट को डेटा संरक्षण कानूनों और नैतिक दिशानिर्देशों का पालन करना चाहिए ताकि कानूनी और प्रतिष्ठित जोखिमों से बचा जा सके।

डेटा ऑग्मेंटेशन का जिम्मेदारी से उपयोग करने के लिए, प्रैक्टिशनर्स को ऑग्मेंटेड डेटा का सत्यापन करना चाहिए, पक्षपात का समाधान करना चाहिए, और प्रासंगिक नैतिक और कानूनी मानकों का अनुपालन सुनिश्चित करना चाहिए।

Keras और TensorFlow के साथ डेटा ऑग्मेंटेशन

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

हम अनुशंसा करते हैं कि आप स्वयं अभ्यास करके कोडिंग ट्यूटोरियल का पालन करें। आउटपुट सहित कोड स्रोत इस DataLab वर्कबुक में उपलब्ध है। 

शुरू करना 

हम डेटा ऑग्मेंटेशन के लिए TensorFlow और Keras का उपयोग करेंगे और इमेज प्रदर्शित करने के लिए matplotlib का।  

%%capture
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
from tensorflow.keras import layers
from tensorflow.keras.models import Sequential

डेटा लोड करना

TensorFlow Dataset संग्रह बहुत बड़ा है। आपको टेक्स्ट, ऑडियो, वीडियो, ग्राफ, टाइम-सीरीज़ और इमेज डेटासेट मिलेंगे। इस ट्यूटोरियल में, हम cats_vs_dogs डेटासेट का उपयोग करेंगे। डेटासेट का आकार 786.68 MiB है, और हम विभिन्न इमेज ऑग्मेंटेशन लागू करेंगे और बाइनरी क्लासिफायर को प्रशिक्षित करेंगे।

नीचे दिए गए कोड में, हमने 80% ट्रेनिंग, 10% वैलिडेशन और 10% टेस्ट सेट को लेबल और मेटाडेटा सहित लोड किया है।

%%capture
(train_ds, val_ds, test_ds), metadata = tfds.load(
    'cats_vs_dogs',
    split=['train[:80%]', 'train[80%:90%]', 'train[90%:]'],
    with_info=True,
    as_supervised=True,
)

डेटा विश्लेषण

डेटासेट में दो क्लास हैं—‘cat’ और ‘dog’।

num_classes = metadata.features['label'].num_classes
print(num_classes)

2

हम इटरेटर्स का उपयोग करके ट्रेनिंग सेट से केवल चार रैंडम इमेज और उनके लेबल निकालेंगे और matplotlib की `.imshow()` फ़ंक्शन से प्रदर्शित करेंगे। 

try:
    get_label_name = metadata.features['label'].int2str
    train_iter = iter(train_ds)
    fig = plt.figure(figsize=(7, 8))
    for x in range(4):
        image, label = next(train_iter)
        fig.add_subplot(1, 4, x + 1)
        plt.imshow(image)
        plt.axis('off')
        plt.title(get_label_name(label))
except StopIteration:
    print("Dataset iterator is empty!")

जैसा कि हम देख सकते हैं, हमें विभिन्न कुत्तों की इमेज और एक बिल्ली की इमेज मिली हैं। 

keras.Sequential() के साथ डेटा ऑग्मेंटेशन

हम आमतौर पर keras.Sequential() का उपयोग मॉडल बनाने के लिए करते हैं, लेकिन हम इसे ऑग्मेंटेशन लेयर्स जोड़ने के लिए भी इस्तेमाल कर सकते हैं।  

रिसाइज़ और रिस्केल 

उदाहरण में, हम Keras Sequential और इमेज ऑग्मेंटेशन लेयर्स का उपयोग करके इमेज को रिसाइज़ और रिस्केल कर रहे हैं। हम पहले इमेज को 180X180 में रिसाइज़ करेंगे और फिर 1/255 से रिस्केल करेंगे। छोटा इमेज आकार समय, मेमोरी और कंप्यूटिंग बचाने में मदद करेगा। 

जैसा कि हम देख सकते हैं, हमने इमेज को सफलतापूर्वक ऑग्मेंटेशन लेयर से पास किया है, और अंतिम आउटपुट रिसाइज़ और रिस्केल हो गया है। 

IMG_SIZE = 180

resize_and_rescale = keras.Sequential([
  layers.Resizing(IMG_SIZE, IMG_SIZE),
  layers.Rescaling(1./255)
])

result = resize_and_rescale(image)
plt.axis('off')
plt.imshow(result);

1

रोटेट और फ्लिप

आइए उसी इमेज पर रैंडम फ्लिप और रोटेशन लागू करें। हम छह इमेज को रैंडम ज्योमेट्रिक ऑग्मेंटेशन के साथ प्रदर्शित करने के लिए लूप, सबप्लॉट और imshow का उपयोग करेंगे।

data_augmentation = keras.Sequential([
  layers.RandomFlip("horizontal_and_vertical"),
  layers.RandomRotation(0.4),
])


plt.figure(figsize=(8, 7))
for i in range(6):
  augmented_image = data_augmentation(image)
  ax = plt.subplot(2, 3, i + 1)
  plt.imshow(augmented_image.numpy()/255)
  plt.axis("off")

ध्यान दें: यदि आपको यह चेतावनी मिल रही है—“WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).”—तो अपनी इमेज को numpy में बदलकर 255 से विभाजित करने का प्रयास करें। इससे धुंधली इमेज के बजाय स्पष्ट आउटपुट दिखेगा। 

सरल ऑग्मेंटेशन के अलावा, आप RandomContrast, RandomCrop, CenterCrop और RandomZoom भी इमेज पर लागू कर सकते हैं। 

मॉडल लेयर में सीधे जोड़ना 

इमेज पर ऑग्मेंटेशन लागू करने के दो तरीके हैं। पहला तरीका है ऑग्मेंटेशन लेयर्स को सीधे मॉडल में जोड़ना।

model = keras.Sequential([
  # Add the preprocessing layers you created earlier.
  resize_and_rescale,
  data_augmentation,
  # Add the model layers
  layers.Conv2D(16, 3, padding='same', activation='relu'),
  layers.MaxPooling2D(),
  layers.Flatten(),
  layers.Dense(128, activation='relu'),
  layers.Dense(64, activation='relu'),
  layers.Dense(1,activation='sigmoid')
])

ध्यान दें: परीक्षण चरण के दौरान डेटा ऑग्मेंटेशन निष्क्रिय रहता है। यह केवल Model.fit के लिए काम करेगा, Model.evaluate या Model.predict के लिए नहीं।

.map का उपयोग करके ऑग्मेंटेशन फ़ंक्शन लागू करना

दूसरा तरीका है Dataset.map का उपयोग करके पूरे ट्रेन सेट पर डेटा ऑग्मेंटेशन लागू करना।

aug_ds = train_ds.map(lambda x, y: (data_augmentation(x, training=True), y))

डेटा प्री-प्रोसेसिंग 

हम ट्रेन, वैलिड और टेस्ट सेट्स को प्रोसेस करने के लिए एक डेटा प्री-प्रोसेसिंग फ़ंक्शन बनाएँगे। 

फ़ंक्शन यह करेगा:

1. पूरे डेटासेट पर रिसाइज़ और रिस्केल लागू करेगा।
2. यदि shuffle True है, तो यह डेटासेट को शफ़ल करेगा।
3. डेटा को 32 के बैच आकार का उपयोग करके बैचों में बदलेगा। 
4. यदि augment True है, तो यह सभी डेटासेट पर डेटा ऑग्मेंटेशन फ़ंक्शन लागू करेगा। 
5. अंत में, Dataset.prefetch का उपयोग करके GPU पर आपके मॉडल के प्रशिक्षण को डेटा प्रोसेसिंग के साथ ओवरलैप करेगा।

batch_size = 32
AUTOTUNE = tf.data.AUTOTUNE

def prepare(ds, shuffle=False, augment=False):
  # Resize and rescale all datasets.
  ds = ds.map(lambda x, y: (resize_and_rescale(x), y),
              num_parallel_calls=AUTOTUNE)

  if shuffle:
    ds = ds.shuffle(1000)

  # Batch all datasets.
  ds = ds.batch(batch_size)

  # Use data augmentation only on the training set.
  if augment:
    ds = ds.map(lambda x, y: (data_augmentation(x, training=True), y),
                num_parallel_calls=AUTOTUNE)

  # Use buffered prefetching on all datasets.
  return ds.prefetch(buffer_size=AUTOTUNE)


train_ds = prepare(train_ds, shuffle=True, augment=True)
val_ds = prepare(val_ds)
test_ds = prepare(test_ds)

मॉडल बिल्डिंग

हम कन्वॉल्यूशन और डेंस लेयर्स के साथ एक साधारण मॉडल बनाएँगे। सुनिश्चित करें कि इनपुट शेप इमेज शेप के समान हो। 

model = keras.Sequential([
    layers.Conv2D(32, (3, 3), input_shape=(180,180,3), padding='same', activation='relu'),
    layers.MaxPooling2D(pool_size=(2, 2)),
    layers.Flatten(),
    layers.Dense(32, activation='relu'),
    layers.Dense(1,activation='softmax')
])

ट्रेनिंग और इवैल्युएशन

अब हम मॉडल को कॉम्पाइल करेंगे और एक epoch के लिए ट्रेन करेंगे। Optimizer Adam है, लॉस फ़ंक्शन Binary Cross Entropy है, और मेट्रिक accuracy है। 

जैसा कि हम देख सकते हैं, एकल रन पर हमें 51% वैलिडेशन सटीकता मिली। आप अधिक epochs के लिए ट्रेन कर सकते हैं और बेहतर परिणाम पाने के लिए हाइपर-पैरामीटर्स को ऑप्टिमाइज़ कर सकते हैं।

मॉडल बिल्डिंग और ट्रेनिंग भाग का उद्देश्य केवल यह बताना है कि आप इमेज को कैसे ऑग्मेंट करें और मॉडल को कैसे प्रशिक्षित करें।  

model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])
epochs=1
history = model.fit(
  train_ds,
  validation_data=val_ds,
  epochs=epochs
)

582/582 [==============================] - 98s 147ms/step - loss: 0.6993 - accuracy: 0.4961 - val_loss: 0.6934 - val_accuracy: 0.5185

loss, acc = model.evaluate(test_ds)

73/73 [==============================] - 4s 48ms/step - loss: 0.6932 - accuracy: 0.5013

इमेज विश्लेषण करना, और कन्वॉल्यूशन नेटवर्क का निर्माण, प्रशिक्षण और मूल्यांकन सीखें Image Processing with Keras कोर्स लेकर। 

tf.image() का उपयोग करके डेटा ऑग्मेंटेशन

इस खंड में, हम डेटा ऑग्मेंटेशन पर अधिक सूक्ष्म नियंत्रण के लिए TensorFlow का उपयोग करके इमेज को ऑग्मेंट करना सीखेंगे।

डेटा लोडिंग

हम cats_vs_dogs डेटासेट को फिर से लेबल और मेटाडेटा सहित लोड करेंगे।

%%capture
(train_ds, val_ds, test_ds), metadata = tfds.load(
    'cats_vs_dogs',
    split=['train[:80%]', 'train[80%:90%]', 'train[90%:]'],
    with_info=True,
    as_supervised=True,
)

बिल्ली की इमेज के बजाय, हम कुत्ते की इमेज का उपयोग करेंगे और विभिन्न ऑग्मेंटेशन तकनीकें लागू करेंगे। 

image, label = next(iter(train_ds))
plt.imshow(image)
plt.title(get_label_name(label));

1

लेफ्ट-टू-राइट फ्लिप

हम मूल और ऑग्मेंटेड इमेज के बीच का अंतर दिखाने के लिए visualize() फ़ंक्शन बनाएँगे। 

फ़ंक्शन काफी सरल है। यह मूल इमेज और ऑग्मेंटेशन फ़ंक्शन को इनपुट के रूप में लेता है और matplotlib का उपयोग करके अंतर दिखाता है।

def visualize(original, augmented):
    fig = plt.figure()
    plt.subplot(1,2,1)
    plt.title('Original image')
    plt.imshow(original)
    plt.axis("off")
 
    plt.subplot(1,2,2)
    plt.title('Augmented image')
    plt.imshow(augmented)
    plt.axis("off")

जैसा कि हम देख सकते हैं, हमने tf.image फ़ंक्शन का उपयोग करके इमेज को बाएँ से दाएँ फ्लिप किया है। यह keras.Sequential() से भी सरल है। 

flipped = tf.image.flip_left_right(image)
visualize(image, flipped)

1

ग्रे-स्केल

आइए tf.image.rgb_to_grayscale() का उपयोग करके इमेज को ग्रे-स्केल में बदलें।

grayscaled = tf.image.rgb_to_grayscale(image)
visualize(image,  tf.squeeze(grayscaled))

1

सैचुरेशन समायोजित करना

आप सैचुरेशन को 3 के फैक्टर से भी समायोजित कर सकते हैं। 

saturated = tf.image.adjust_saturation(image, 3)
visualize(image, saturated)

1

ब्राइटनेस समायोजित करना

ब्राइटनेस को एक ब्राइटनेस फैक्टर देकर समायोजित करें। 

bright = tf.image.adjust_brightness(image, 0.4)
visualize(image, bright)

1

सेंट्रल क्रॉप

0.5 के सेंट्रल फ़्रैक्शन का उपयोग करके इमेज को केंद्र से क्रॉप करें। 

cropped = tf.image.central_crop(image, central_fraction=0.5)
visualize(image, cropped)

1

90-डिग्री रोटेशन

tf.image.rot90() फ़ंक्शन का उपयोग करके इमेज को 90 डिग्री घुमाएँ।

rotated = tf.image.rot90(image)
visualize(image, rotated)

1

रैंडम ब्राइटनेस लागू करना

Keras लेयर्स की तरह, tf.image() में भी रैंडम ऑग्मेंटेशन फ़ंक्शन होते हैं। नीचे दिए उदाहरण में, हम इमेज पर रैंडम ब्राइटनेस लागू करेंगे और कई परिणाम प्रदर्शित करेंगे। 

जैसा कि हम देख सकते हैं, पहली इमेज थोड़ी गहरी है, और अगली दो इमेज अधिक उजली हैं। 

for i in range(3):
  seed = (i, 0)  # tuple of size (2,)
  stateless_random_brightness = tf.image.stateless_random_brightness(
      image, max_delta=0.95, seed=seed)
  visualize(image, stateless_random_brightness)

ऑग्मेंटेशन फ़ंक्शन लागू करना

ठीक Keras की तरह, हम Dataset.map() का उपयोग करके पूरे डेटासेट पर डेटा ऑग्मेंटेशन फ़ंक्शन लागू कर सकते हैं। 

def augment(image, label):
  image = tf.cast(image, tf.float32)
  image = tf.image.resize(image, [IMG_SIZE, IMG_SIZE])
  image = (image / 255.0)
  image = tf.image.random_crop(image, size=[IMG_SIZE, IMG_SIZE, 3])
  image = tf.image.random_brightness(image, max_delta=0.5)
  return image, label


train_ds = (
    train_ds
    .shuffle(1000)
    .map(augment, num_parallel_calls=AUTOTUNE)
    .batch(batch_size)
    .prefetch(AUTOTUNE)
)

ImageDataGenerator के साथ डेटा ऑग्मेंटेशन

Keras का ImageDataGenerator() और भी सरल है। यह तब सबसे अच्छा काम करता है जब आप लोकल डायरेक्टरी या CSV से डेटा लोड कर रहे हों। 

उदाहरण में, हम Keras की डिफ़ॉल्ट डेटासेट लाइब्रेरी से एक छोटा CIFAR10 डेटासेट डाउनलोड और लोड करेंगे। 

उसके बाद, हम keras.preprocessing.image.ImageDataGenerator() का उपयोग करके ऑग्मेंटेशन लागू करेंगे। फ़ंक्शन इमेज को यादृच्छिक रूप से घुमाएगा, ऊँचाई और चौड़ाई बदलेगा, और क्षैतिज रूप से फ्लिप करेगा। 

अंत में, हम ImageDataGenerator() को ट्रेनिंग डेटासेट पर फिट करेंगे और यादृच्छिक ऑग्मेंटेशन के साथ छह इमेज प्रदर्शित करेंगे। 

ध्यान दें: इमेज का आकार 32x32 है, इसलिए हमारा डिस्प्ले लो-रिज़ॉल्यूशन होगा। 

(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()

datagen = keras.preprocessing.image.ImageDataGenerator(rotation_range=20,
    width_shift_range=0.2,
    height_shift_range=0.2,
    horizontal_flip=True,
    validation_split=0.2)

datagen.fit(x_train)

for X_batch, y_batch in datagen.flow(x_train,y_train, batch_size=6):
    for i in range(0, 6):
        plt.subplot(2,3,i+1)
        plt.imshow(X_batch[i]/255)
        plt.axis('off')
    break

डेटा ऑग्मेंटेशन टूल्स

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

Pytorch

इमेज ट्रांसफॉर्मेशन torchvision.transforms मॉड्यूल में उपलब्ध हैं। Keras की तरह, आप ट्रांसफॉर्म लेयर्स को torch.nn.Sequential के भीतर जोड़ सकते हैं या किसी अलग ऑग्मेंटेशन फ़ंक्शन को डेटासेट पर लागू कर सकते हैं। 

Augmentor

Augmentor इमेज ऑग्मेंटेशन और कृत्रिम इमेज जेनरेशन के लिए एक Python पैकेज है। आप Perspective Skewing, Elastic Distortions, Rotating, Shearing, Cropping और Mirroring कर सकते हैं। Augmentor बेसिक इमेज प्री-प्रोसेसिंग फ़ंक्शनलिटी के साथ भी आता है।

Albumentations

Albumentations इमेज ऑग्मेंटेशन के लिए एक तेज़ और लचीला Python टूल है। यह मशीन लर्निंग प्रतियोगिताओं, उद्योग और शोध में डीप कन्वॉल्यूशनल न्यूरल नेटवर्क के प्रदर्शन में सुधार करने के लिए व्यापक रूप से उपयोग किया जाता है। 

Imgaug

Imgaug इमेज ऑग्मेंटेशन के लिए एक ओपन-सोर्स टूल है। यह Gaussian नॉइज़, कॉन्ट्रास्ट, शार्पनेस, क्रॉप, एफाइन और फ्लिप जैसी कई ऑग्मेंटेशन तकनीकों का समर्थन करता है। इसका इंटरफ़ेस सरल लेकिन शक्तिशाली स्टोकेस्टिक है, और यह कीपॉइंट्स, बाउंडिंग बॉक्स, हीटमैप्स और सेगमेंटेशन मैप्स के साथ आता है।

OpenCV

OpenCV कंप्यूटर विज़न, मशीन लर्निंग और इमेज प्रोसेसिंग के लिए एक विशाल ओपन-सोर्स लाइब्रेरी है। इसे आमतौर पर रियल-टाइम अनुप्रयोग बनाने में उपयोग किया जाता है। आप OpenCV का उपयोग करके इमेज और वीडियो को बिना झंझट ऑग्मेंट कर सकते हैं।  

निष्कर्ष

TensorFlow और Keras द्वारा प्रदान किए गए इमेज ऑग्मेंटेशन फ़ंक्शन सुविधाजनक हैं। ऑग्मेंटेशन करने के लिए आपको बस एक ऑग्मेंटेशन लेयर, tf.image(), या ImageDataGenerator() जोड़ना होता है। डीप लर्निंग फ्रेमवर्क्स के अलावा, आप डेटा ऑग्मेंटेशन करने के लिए Augmentor, Albumentations, OpenCV और Imgaug जैसे स्टैंडअलोन टूल्स का उपयोग कर सकते हैं।

इस ट्यूटोरियल में, हमने डेटा ऑग्मेंटेशन के फायदे, सीमाएँ, अनुप्रयोग और तकनीकों के बारे में सीखा। इसके अलावा, हमने Keras और TensorFlow का उपयोग करके cats_vs_dogs डेटासेट पर इमेज ऑग्मेंटेशन लागू करना सीखा। यदि आप इमेज प्रोसेसिंग के बारे में और सीखने में रुचि रखते हैं, तो हमारे Image Processing with Python स्किल ट्रैक पर नज़र डालें। यह आपको इमेज ट्रांसफॉर्मेशन और मैनिपुलेशन की मूल बातें, मेडिकल इमेज विश्लेषण, और Keras का उपयोग करके उन्नत इमेज प्रोसेसिंग सिखाएगा।