पायटॉर्च (PyTorch) का उपयोग करके रैखिक प्रतिगमन

रैखिक प्रतिगमन के बारे में

सरल रैखिक प्रतिगमन की मूल बातें

• दो सतत चरों के बीच संबंध को समझने की अनुमति देता है।
• उदाहरण:
  • x = स्वतंत्र चर
    • वजन
  • y = आश्रित चर
    • ऊंचाई
• y = αx + β

आइए एक प्रोग्राम के माध्यम से सरल रैखिक प्रतिगमन को समझते हैं:

# सरल रैखिक प्रतिगमन
import numpy as np
import matplotlib.pyplot as plt
np.random.seed(1)
n = 70
x = np.random.randn(n)
y = x * np.random.randn(n)
colors = np.random.rand(n)
plt.plot(np.unique(x), np.poly1d(np.polyfit(x, y, 1))(np.unique(x)))
plt.scatter(x, y, c=colors, alpha=0.5)
plt.show()

आउटपुट

रैखिक प्रतिगमन का उद्देश्य:

• बिंदुओं और रेखा (y = αx + β) के बीच की दूरी को न्यूनतम करना
• समायोजन:
  • गुणांक: α
  • इंटरसेप्ट/बायस: β

पायटॉर्च के साथ रैखिक प्रतिगमन मॉडल बनाना

मान लीजिए हमारा गुणांक (α) 2 है और इंटरसेप्ट (β) 1 है, तो हमारा समीकरण बनेगा:

y = 2x + 1 # रैखिक मॉडल

डेटासेट बनाना

x_values = [i for i in range(11)]
x_values

आउटपुट

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# नम्पाई में कनवर्ट करें

x_train = np.array(x_values, dtype=np.float32)
x_train.shape

आउटपुट

(11,)

# महत्वपूर्ण: 2D आवश्यक
x_train = x_train.reshape(-1, 1)
x_train.shape

आउटपुट

(11, 1)

y_values = [2*i + 1 for i in x_values]
y_values

आउटपुट

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21]

# सूची पुनरावृत्ति
y_values = []
for i in x_values:
    result = 2*i + 1
    y_values.append(result)
y_values

आउटपुट

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21]

y_train = np.array(y_values, dtype=np.float32)
y_train.shape

आउटपुट

(11,)

# 2D आवश्यक
y_train = y_train.reshape(-1, 1)
y_train.shape

आउटपुट

(11, 1)

मॉडल बनाना

# लाइब्रेरी आयात करें
import torch
import torch.nn as nn
from torch.autograd import Variable

# मॉडल वर्ग बनाएं
class LinearRegModel(nn.Module):
    def __init__(self, input_size, output_size):
        super(LinearRegModel, self).__init__()
        self.linear = nn.Linear(input_dim, output_dim)
    def forward(self, x):
        out = self.linear(x)
        return out

input_dim = 1
output_dim = 1
model = LinearRegModel(input_dim, output_dim)
criterion = nn.MSELoss()
learning_rate = 0.01
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
epochs = 100

for epoch in range(epochs):
    epoch += 1
    # नम्पाई सरणी को टॉर्च वेरिएबल में बदलें
    inputs = Variable(torch.from_numpy(x_train))
    labels = Variable(torch.from_numpy(y_train))
    # पैरामीटर्स के सापेक्ष ग्रेडिएंट्स साफ़ करें
    optimizer.zero_grad()
    # आउटपुट प्राप्त करने के लिए फॉरवर्ड
    outputs = model.forward(inputs)
    # नुकसान की गणना करें
    loss = criterion(outputs, labels)
    # पैरामीटर्स के सापेक्ष ग्रेडिएंट्स प्राप्त करें
    loss.backward()
    # पैरामीटर्स अपडेट करें
    optimizer.step()
    print('epoch {}, loss {}'.format(epoch, loss.data[0]))

आउटपुट

epoch 1, loss 276.7417907714844
epoch 2, loss 22.601360321044922
epoch 3, loss 1.8716105222702026
epoch 4, loss 0.18043726682662964
epoch 5, loss 0.04218350350856781
epoch 6, loss 0.03060017339885235
epoch 7, loss 0.02935197949409485
epoch 8, loss 0.02895027957856655
epoch 9, loss 0.028620922937989235
epoch 10, loss 0.02830091118812561
......
......
epoch 94, loss 0.011018744669854641
epoch 95, loss 0.010895680636167526
epoch 96, loss 0.010774039663374424
epoch 97, loss 0.010653747245669365
epoch 98, loss 0.010534750297665596
epoch 99, loss 0.010417098179459572
epoch 100, loss 0.010300817899405956

तो हम देख सकते हैं कि नुकसान एपोक 1 से एपोक 100 तक काफी कम हो गया है।

ग्राफ प्लॉट करें

# विशुद्ध रूप से अनुमान
predicted = model(Variable(torch.from_numpy(x_train))).data.numpy()
predicted
y_train

# ग्राफ प्लॉट करें
# फिगर साफ़ करें
plt.clf()
# भविष्यवाणियाँ प्राप्त करें
predicted = model(Variable(torch.from_numpy(x_train))).data.numpy()
# वास्तविक डेटा प्लॉट करें
plt.plot(x_train, y_train, 'go', label='True data', alpha=0.5)
# भविष्यवाणियाँ प्लॉट करें
plt.plot(x_train, predicted, '--', label='Predictions', alpha=0.5)
# लीजेंड और प्लॉट
plt.legend(loc='best')
plt.show()

आउटपुट

तो हम ग्राफ से देख सकते हैं - हमारे वास्तविक और अनुमानित मान लगभग समान हैं।