ऑटोएन्कोडर्स का परिचय: आधारभूत से उन्नत अनुप्रयोगों तक PyTorch में

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

यह ट्यूटोरियल ऑटोएन्कोडर्स का एक व्यावहारिक परिचय प्रदान करता है, जिसमें PyTorch में एक हैंड्स-ऑन उदाहरण और कुछ संभावित उपयोग के मामले शामिल हैं।

आप इस DataLab वर्कबुक में ट्यूटोरियल का सारा कोड देखते हुए साथ चल सकते हैं।

ऑटोएन्कोडर्स क्या हैं?

ऑटोएन्कोडर्स असUPERVISED फीडफ़ॉरवर्ड न्यूरल नेटवर्क का एक विशेष प्रकार हैं (कोई लेबल आवश्यक नहीं!). ऑटोएन्कोडर्स का मुख्य उपयोग प्रदत्त डेटा के प्रमुख पहलुओं को सटीक रूप से कैप्चर करना है ताकि इनपुट डेटा का संपीड़ित संस्करण प्रदान किया जा सके, यथार्थपरक सिंथेटिक डेटा जनरेट किया जा सके, या विसंगतियों को चिह्नित किया जा सके।

ऑटोएन्कोडर्स दो मुख्य पूर्णत: संयोजित फीडफ़ॉरवर्ड न्यूरल नेटवर्क्स से मिलकर बने होते हैं (चित्र 1):

• एन्कोडर: इनपुट डेटा को संपीड़ित करता है ताकि किसी भी प्रकार के शोर को हटाया जा सके और एक लेटेंट स्पेस/बॉटलनेक उत्पन्न करता है। इसलिए, आउटपुट न्यूरल नेटवर्क के आयाम इनपुट से छोटे होते हैं और यह एक हाइपरपैरामीटर के रूप में समायोज्य है, जिससे हम तय कर सकते हैं कि हमारा संपीड़न कितना लॉसी होना चाहिए।
• डीकोडर: केवल लेटेंट स्पेस से मिली संपीड़ित डेटा अभिव्यक्ति का उपयोग करते हुए, मूल इनपुट डेटा का यथासंभव वफादारी के साथ पुनर्निर्माण करने की कोशिश करता है (इसलिए इस न्यूरल नेटवर्क की संरचना आमतौर पर एन्कोडर का दर्पण प्रतिबिंब होती है)। भविष्यवाणी की “उत्कृष्टता” को तब किसी लॉस फंक्शन का उपयोग कर इनपुट और आउटपुट डेटा के बीच रिकंस्ट्रक्शन एरर की गणना करके मापा जा सकता है।

इस प्रक्रिया को—डेटा को एन्कोडर और डीकोडर से गुजारना और त्रुटि मापकर बैकप्रोपेगेशन के माध्यम से पैरामीटर्स ट्यून करना—दोहराते हुए, ऑटोएन्कोडर समय के साथ अत्यंत जटिल प्रकार के डेटा पर भी सही ढंग से काम कर सकता है।

चित्र 1: ऑटोएन्कोडर आर्किटेक्चर (चित्र: लेखक)।

यदि किसी ऑटोएन्कोडर को ऐसे इनपुट फीचर्स का समूह दिया जाए जो एक-दूसरे से पूरी तरह स्वतंत्र हों, तो मॉडल के लिए बिना भारी सूचना हानि के एक अच्छा निम्न-आयामी प्रतिनिधित्व ढूँढना बहुत कठिन होगा (लॉसी कम्प्रेशन)।

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

इसके अलावा, मानक डेटा संपीड़न एल्गोरिद्म जैसे gzip की तुलना में, ऑटोएन्कोडर्स सामान्य-उद्देश्य के संपीड़न एल्गोरिद्म के रूप में उपयोग नहीं किए जा सकते, बल्कि उन्हें विशेष रूप से उसी प्रकार के डेटा पर श्रेष्ठ कार्य करने के लिए डिज़ाइन किया जाता है जिस पर उनका प्रशिक्षण हुआ है।

अपने ऑटोएन्कोडर का अनुकूलन करते समय जिन सबसे सामान्य हाइपरपैरामीटर्स को ट्यून किया जा सकता है, वे हैं:

• एन्कोडर और डीकोडर न्यूरल नेटवर्क्स के लिए परतों की संख्या
• इन प्रत्येक परतों के लिए नोड्स की संख्या
• अनुकूलन प्रक्रिया के लिए उपयोग होने वाला लॉस फंक्शन (जैसे बाइनरी क्रॉस-एंट्रॉपी या मीन स्क्वेयर्ड एरर)
• लेटेंट स्पेस का आकार (जितना छोटा, उतना अधिक संपीड़न; अतः यह एक रेग्युलराइजेशन तंत्र के रूप में कार्य करता है)

अंततः, ऑटोएन्कोडर्स को टैब्यूलर, टाइम-सीरीज़, या इमेज डेटा जैसे विभिन्न प्रकार के डेटा के साथ काम करने के लिए डिज़ाइन किया जा सकता है, और इसलिए विभिन्न प्रकार की परतों—जैसे कॉन्वॉल्यूशनल लेयर्स—का उपयोग किया जा सकता है, विशेषकर इमेज विश्लेषण के लिए।

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

ऑटोएन्कोडर्स के प्रकार

वर्षों में, ऑटोएन्कोडर्स के विभिन्न प्रकार विकसित किए गए हैं:

• अंडरकम्प्लीट ऑटोएन्कोडर
• स्पार्स ऑटोएन्कोडर
• कॉन्ट्रैक्टिव ऑटोएन्कोडर
• डीनॉइज़िंग ऑटोएन्कोडर
• कॉन्वॉल्यूशनल ऑटोएन्कोडर
• वैरिएशनल ऑटोएन्कोडर

आइए प्रत्येक को थोड़ी और विस्तार से देखें।

अंडरकम्प्लीट ऑटोएन्कोडर

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

स्पार्स ऑटोएन्कोडर

स्पार्स ऑटोएन्कोडर अंडरकम्प्लीट ऑटोएन्कोडर से काफी मिलता-जुलता है, पर मुख्य अंतर रेग्युलराइजेशन लागू करने के तरीके में है। दरअसल, स्पार्स ऑटोएन्कोडर्स में हमें अनिवार्य रूप से बॉटलनेक के आयाम घटाने की आवश्यकता नहीं होती; बल्कि हम ऐसा लॉस फंक्शन उपयोग करते हैं जो विभिन्न हिडन लेयर्स में मॉडल को अपनी सभी न्यूरॉन्स का उपयोग करने से हतोत्साहित करता है (चित्र 2)।

इस दंड को सामान्यतः स्पार्सिटी फंक्शन कहा जाता है, और यह पारंपरिक रेग्युलराइजेशन तकनीकों से काफी अलग है क्योंकि यह वेट्स के आकार को दंडित करने के बजाय सक्रियित नोड्स की संख्या पर ध्यान केंद्रित करता है।

इस तरह, अलग-अलग नोड्स विभिन्न इनपुट प्रकारों में विशेषज्ञता विकसित कर सकते हैं और इनपुट डेटा की विशिष्टताओं के अनुसार सक्रिय/निष्क्रिय हो सकते हैं। इस स्पार्सिटी बाधा को L1 रेग्युलराइजेशन और KL डाइवर्जेन्स का उपयोग करके प्रेरित किया जा सकता है, जिससे मॉडल को प्रभावी ढंग से ओवरफिटिंग से रोका जा सके।

कॉन्ट्रैक्टिव ऑटोएन्कोडर

कॉन्ट्रैक्टिव ऑटोएन्कोडर्स के पीछे मुख्य विचार यह है कि यदि कुछ इनपुट एक-दूसरे के समान हों, तो उनकी संपीड़ित अभिव्यक्तियाँ भी काफी समान होनी चाहिए (इनपुट के पड़ोसी छोटे आउटपुट पड़ोसों में सिमटें)। गणितीय रूप में, इसे इस प्रकार लागू किया जा सकता है कि समान इनपुट दिए जाने पर इनपुट-हिडन लेयर एक्टिवेशन्स के डेरिवेटिव्स छोटे रखे जाएँ।

डीनॉइज़िंग ऑटोएन्कोडर

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

कॉन्वॉल्यूशनल ऑटोएन्कोडर

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

वैरिएशनल ऑटोएन्कोडर

अब तक विचार किए गए प्रत्येक प्रकार के ऑटोएन्कोडर में, एन्कोडर प्रत्येक आयाम के लिए एक एकल मान आउटपुट करता है। वैरिएशनल ऑटोएन्कोडर्स (VAE) के साथ, हम इस प्रक्रिया को प्रायिकतामूलक बना देते हैं, प्रत्येक आयाम के लिए एक प्रायिकता वितरण निर्मित करते हैं। डीकोडर तब विभिन्न आयामों का वर्णन करने वाले प्रत्येक वितरण से एक मान सैंपल कर सकता है और इनपुट वेक्टर का निर्माण कर सकता है, जिसे आगे मूल इनपुट डेटा के पुनर्निर्माण में उपयोग किया जा सकता है।

वैरिएशनल ऑटोएन्कोडर्स के मुख्य अनुप्रयोगों में से एक जनरेटिव कार्य हैं। वास्तव में, वितरणों से लेटेंट मॉडल का सैंपल लेना डीकोडर को आउटपुट के नए प्रकार बनाने में सक्षम बना सकता है, जो पहले निर्धारक (डिटरमिनिस्टिक) दृष्टिकोण का उपयोग करते हुए संभव नहीं थे।

यदि आप MNIST डेटासेट पर प्रशिक्षित वैरिएशनल ऑटोएन्कोडर को ऑनलाइन परखने में रुचि रखते हैं, तो एक लाइव उदाहरण उपलब्ध है।

ऑटोएन्कोडर हैंड्स-ऑन उदाहरण

अब हम एक व्यावहारिक डेमोंस्ट्रेशन के लिए तैयार हैं कि आयाम-अपचयन में ऑटोएन्कोडर्स का उपयोग कैसे किया जा सकता है। इस अभ्यास के लिए हमारा डीप लर्निंग फ्रेमवर्क PyTorch होगा।

Kaggle Rain in Australia डेटासेट इस प्रदर्शन के लिए उपयोग किया जाएगा। इस लेख का सारा कोड इस DataLab वर्कबुक में उपलब्ध है।

सबसे पहले, हम सभी आवश्यक लाइब्रेरी इम्पोर्ट करते हैं और कोई भी मिसिंग वैल्यू और गैर-संख्यात्मक कॉलम हटाते हैं (चित्र 3)।

import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler, LabelEncoder
from mpl_toolkits.mplot3d import Axes3D

df = pd.read_csv("../input/weather-dataset-rattle-package/weatherAUS.csv")
df = df.drop(['Date', 'Location', 'WindDir9am',
             'WindGustDir', 'WindDir3pm'], axis=1)
df = df.dropna(how = 'any')
df.loc[df['RainToday'] == 'No', 'RainToday'] = 0
df.loc[df['RainToday'] == 'Yes', 'RainToday'] = 1
df.head()संचालित द्वारा

चित्र 3: डेटासेट कॉलम का नमूना (चित्र: लेखक)।

इस बिंदु पर, हम डेटा को फीचर्स और लेबल्स में विभाजित करने, फीचर्स को सामान्यीकृत करने और लेबल्स को संख्यात्मक स्वरूप में बदलने के लिए तैयार हैं।

इस मामले में, हमारे पास 17 कॉलमों से बना एक प्रारंभिक फीचर सेट है। विश्लेषण का समग्र उद्देश्य तब यह सही ढंग से भविष्यवाणी करना होगा कि अगले दिन वर्षा होगी या नहीं।

X, Y = df.drop('RainTomorrow', axis=1, inplace=False), df[['RainTomorrow']]
# Normalizing Data
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Converting to PyTorch tensor
X_tensor = torch.FloatTensor(X_scaled)

# Converting string labels to numerical labels
label_encoder = LabelEncoder()
Y_numerical = label_encoder.fit_transform(Y.values.ravel())संचालित द्वारा

PyTorch में, अब हम ऑटोएन्कोडर मॉडल को एक क्लास के रूप में परिभाषित कर सकते हैं और एन्कोडर व डीकोडर मॉडलों को दो लीनियर लेयर्स से निर्दिष्ट कर सकते हैं।

# Defining Autoencoder model
class Autoencoder(nn.Module):
   def __init__(self, input_size, encoding_dim):
       super(Autoencoder, self).__init__()
       self.encoder = nn.Sequential(
           nn.Linear(input_size, 16),
           nn.ReLU(),
           nn.Linear(16, encoding_dim),
           nn.ReLU()
       )
       self.decoder = nn.Sequential(
           nn.Linear(encoding_dim, 16),
           nn.ReLU(),
           nn.Linear(16, input_size),
           nn.Sigmoid()
       )

   def forward(self, x):
       x = self.encoder(x)
       x = self.decoder(x)
       return xसंचालित द्वारा

अब जब मॉडल सेट हो गया है, तो हम अपने एन्कोडिंग आयामों को 3 के बराबर निर्दिष्ट कर सकते हैं (ताकि बाद में उन्हें प्लॉट करना आसान हो) और प्रशिक्षण प्रक्रिया चलाएँ।

# Setting random seed for reproducibility
torch.manual_seed(42)

input_size = X.shape[1]  # Number of input features
encoding_dim = 3  # Desired number of output dimensions
model = Autoencoder(input_size, encoding_dim)

# Loss function and optimizer
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.003)

# Training the autoencoder
num_epochs = 20
for epoch in range(num_epochs):
   # Forward pass
   outputs = model(X_tensor)
   loss = criterion(outputs, X_tensor)

   # Backward pass and optimization
   optimizer.zero_grad()
   loss.backward()
   optimizer.step()

   # Loss for each epoch
   print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')

# Encoding the data using the trained autoencoder
encoded_data = model.encoder(X_tensor).detach().numpy()संचालित द्वारा

Epoch [1/20], Loss: 1.2443
Epoch [2/20], Loss: 1.2410
Epoch [3/20], Loss: 1.2376
Epoch [4/20], Loss: 1.2342
Epoch [5/20], Loss: 1.2307
Epoch [6/20], Loss: 1.2271
Epoch [7/20], Loss: 1.2234
Epoch [8/20], Loss: 1.2196
Epoch [9/20], Loss: 1.2156
Epoch [10/20], Loss: 1.2114
Epoch [11/20], Loss: 1.2070
Epoch [12/20], Loss: 1.2023
Epoch [13/20], Loss: 1.1974
Epoch [14/20], Loss: 1.1923
Epoch [15/20], Loss: 1.1868
Epoch [16/20], Loss: 1.1811
Epoch [17/20], Loss: 1.1751
Epoch [18/20], Loss: 1.1688
Epoch [19/20], Loss: 1.1622
Epoch [20/20], Loss: 1.1554संचालित द्वारा

अंततः, अब हम प्राप्त एम्बेडिंग आयामों को प्लॉट कर सकते हैं (चित्र 4)। जैसा कि नीचे दी गई छवि में देखा जा सकता है, हमने अपने फीचर सेट की आयामिकता 17 से घटाकर मात्र 3 कर दी, और फिर भी हम अपने 3-आयामी स्पेस में विभिन्न वर्गों के नमूनों को काफ़ी हद तक ठीक से अलग करने में सक्षम रहे।

# Plotting the encoded data in 3D space
fig = plt.figure(figsize=(8, 8))
ax = fig.add_subplot(111, projection='3d')
scatter = ax.scatter(encoded_data[:, 0], encoded_data[:, 1],
                    encoded_data[:, 2], c=Y_numerical, cmap='viridis')

# Mapping numerical labels back to original string labels for the legend
labels = label_encoder.inverse_transform(np.unique(Y_numerical))
legend_labels = {num: label for num, label in zip(np.unique(Y_numerical),
                                                 labels)}

# Creating a custom legend with original string labels
handles = [plt.Line2D([0], [0], marker='o', color='w',
                    markerfacecolor=scatter.to_rgba(num),
                    markersize=10,
                    label=legend_labels[num]) for num in np.unique(Y_numerical)]
ax.legend(handles=handles, title="Raining Tomorrow?")

# Adjusting the layout to provide more space for labels
ax.xaxis.labelpad = 20
ax.yaxis.labelpad = 20

ax.set_xticks([])
ax.set_yticks([])
ax.set_zticks([])

# Manually adding z-axis label for better visibility
ax.text2D(0.05, 0.95, 'Encoded Dimension 3', transform=ax.transAxes,
         fontsize=12, color='black')

ax.set_xlabel('Encoded Dimension 1')
ax.set_ylabel('Encoded Dimension 2')
ax.set_title('Autoencoder Dimensionality Reduction')

plt.tight_layout()

plt.savefig('Rain_Prediction_Autoencoder.png')

plt.show()संचालित द्वारा

चित्र 4: प्राप्त एन्कोडेड आयाम (चित्र: लेखक)।

ऑटोएन्कोडर्स के वास्तविक जीवन में अनुप्रयोग

इमेज संपीड़न/डीनॉइज़िंग

ऑटोएन्कोडर्स के मुख्य अनुप्रयोगों में से एक है छवियों को संपीड़ित करके उनकी कुल फ़ाइल आकार को कम करना, जबकि यथासंभव अधिक मूल्यवान जानकारी को बनाए रखना, या समय के साथ क्षीण हुई छवियों को बहाल करना।

विसंगति पहचान

क्योंकि ऑटोएन्कोडर्स डेटा की मूलभूत विशेषताओं को शोर से अलग करने में अच्छे होते हैं, वे विसंगतियों का पता लगाने के लिए उपयोग किए जा सकते हैं (उदा., यदि किसी छवि में फ़ोटोशॉप किया गया है, नेटवर्क में असामान्य गतिविधियाँ हैं, आदि)।

डेटा जनरेशन

वैरिएशनल ऑटोएन्कोडर्स और जनरेटिव एड्वर्सैरियल नेटवर्क्स (GAN) का अक्सर सिंथेटिक डेटा उत्पन्न करने के लिए उपयोग किया जाता है (उदा., लोगों की यथार्थपरक छवियाँ)।

निष्कर्ष

निष्कर्षतः, ऑटोएन्कोडर्स विभिन्न प्रकार के उपयोग मामलों को सशक्त बनाने के लिए एक अत्यंत लचीला उपकरण हो सकते हैं। विशेष रूप से, वैरिएशनल ऑटोएन्कोडर्स और GANs के निर्माण ने जेनेरेटिव AI के विकास का मार्ग प्रशस्त किया, जिसने हमें यह दिखाने की पहली झलक दी कि AI का उपयोग पहले कभी न देखे गए नए प्रकार की सामग्री उत्पन्न करने में कैसे किया जा सकता है।

यह ट्यूटोरियल ऑटोएन्कोडर्स के क्षेत्र का एक परिचय था, यद्यपि सीखने के लिए अभी बहुत कुछ है! DataCamp के पास इस विषय पर कई संसाधन हैं, जैसे Keras में ऑटोएन्कोडर्स को कैसे लागू करें या उन्हें क्लासिफ़ायर के रूप में उपयोग करें!