मैं पाइटोरच सीख रहा हूं, कि इस डेटा पर एक बुनियादी रेखीय प्रतिगमन करने के लिए यहां इस तरह बनाया गया है:

from sklearn.datasets import make_regression

x, y = make_regression(n_samples=100, n_features=1, noise=15, random_state=42)
y = y.reshape(-1, 1)
print(x.shape, y.shape)

plt.scatter(x, y)

मुझे पता है कि टेंसरफ़्लो का उपयोग करके यह कोड हल कर सकता है:

model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Dense(units=1, activation='linear', input_shape=(x.shape[1], )))

model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.05), loss='mse')

hist = model.fit(x, y, epochs=15, verbose=0)

लेकिन मुझे यह जानने की जरूरत है कि पाइटोरच समकक्ष कैसा होगा, मैंने जो करने की कोशिश की वह यह था:

# Model Class
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.linear = nn.Linear(1,1)
        
    def forward(self, x):
        x = self.linear(x)
        return x
    
    def predict(self, x):
        return self.forward(x)
    
model = Net()

loss_fn = F.mse_loss
opt = torch.optim.SGD(modelo.parameters(), lr=0.05)

# Funcao para treinar
def fit(num_epochs, model, loss_fn, opt, train_dl):
    
    
    # Repeat for given number of epochs
    for epoch in range(num_epochs):
        
        # Train with batches of data
        for xb, yb in train_dl:
            
            # 1. Generate predictions
            pred = model(xb)
            
            # 2. Calculate Loss
            loss = loss_fn(pred, yb)
            
            # 3. Campute gradients
            loss.backward()
            
            # 4. Update parameters using gradients
            opt.step()
            
            # 5. Reset the gradients to zero
            opt.zero_grad()
            
        # Print the progress
        if (epoch+1) % 10 == 0:
            print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

# Training
fit(200, model, loss_fn, opt, data_loader)

लेकिन मॉडल कुछ नहीं सीखता, मुझे नहीं पता कि मैं अब और क्या कर सकती हूं।

इनपुट/आउटपुट आयाम है (1/1)

5
manynothing 10 सितंबर 2020, 16:10

1 उत्तर

सबसे बढ़िया उत्तर

डेटासेट

सबसे पहले, आपको torch.utils.data.Dataset

import torch
from sklearn.datasets import make_regression


class RegressionDataset(torch.utils.data.Dataset):
    def __init__(self):
        data = make_regression(n_samples=100, n_features=1, noise=0.1, random_state=42)
        self.x = torch.from_numpy(data[0]).float()
        self.y = torch.from_numpy(data[1]).float()

    def __len__(self):
        return len(self.x)

    def __getitem__(self, index):
        return self.x[index], self.y[index]

यह numpy डेटा को __init__ के अंदर PyTorch के tensor में कनवर्ट करता है और डेटा को float (numpy में डिफ़ॉल्ट रूप से डबल होता है जबकि कम मेमोरी का उपयोग करने के लिए PyTorch का डिफ़ॉल्ट float होता है)।

इसके अलावा यह केवल tuple सुविधाओं और संबंधित प्रतिगमन लक्ष्यों को लौटाएगा।

फ़िट

लगभग वहाँ, लेकिन आपको मॉडल से आउटपुट को समतल करना होगा (नीचे वर्णित)। torch.nn.Linear आकार के टेंसर (batch, 1) लौटाएगा, जबकि आपके लक्ष्य (batch,) आकार के होंगे। flatten() अनावश्यक 1 आयाम को हटा देगा।

# 2. Calculate Loss
loss = criterion(pred.flatten(), yb)

आदर्श

वास्तव में आपको बस इतना ही चाहिए:

model = torch.nn.Linear(1, 1)

किसी भी परत को सीधे कहा जा सकता है, forward और साधारण मॉडल के लिए विरासत की कोई आवश्यकता नहीं है।

कॉलिंग

बाकी लगभग ठीक है, आपको बस torch बनाना है .utils.data.DataLoader और हमारे डेटासेट का उदाहरण पास करें। DataLoader क्या करता है, यह डेटासेट के __getitem__ को कई बार जारी करता है और निर्दिष्ट आकार का एक बैच बनाता है (कुछ अन्य मज़ेदार व्यवसाय है, लेकिन वह है विचार):

dataset = RegressionDataset()
dataloader = torch.utils.data.DataLoader(dataset, batch_size=32)
model = torch.nn.Linear(1, 1)
criterion = torch.nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=3e-4)

fit(5000, model, criterion, optimizer, dataloader)

यह भी ध्यान दें कि मैंने torch.nn.MSELoss() का उपयोग किया है, क्योंकि हम ऑब्जेक्ट पास कर रहे हैं, यह इस मामले में फ़ंक्शन से बेहतर दिखता है।

पूरा कोड

इसे आसान बनाने के लिए:

import torch
from sklearn.datasets import make_regression


class RegressionDataset(torch.utils.data.Dataset):
    def __init__(self):
        data = make_regression(n_samples=100, n_features=1, noise=0.1, random_state=42)
        self.x = torch.from_numpy(data[0]).float()
        self.y = torch.from_numpy(data[1]).float()

    def __len__(self):
        return len(self.x)

    def __getitem__(self, index):
        return self.x[index], self.y[index]


# Funcao para treinar
def fit(num_epochs, model, criterion, optimizer, train_dl):
    # Repeat for given number of epochs
    for epoch in range(num_epochs):

        # Train with batches of data
        for xb, yb in train_dl:

            # 1. Generate predictions
            pred = model(xb)

            # 2. Calculate Loss
            loss = criterion(pred.flatten(), yb)

            # 3. Compute gradients
            loss.backward()

            # 4. Update parameters using gradients
            optimizer.step()

            # 5. Reset the gradients to zero
            optimizer.zero_grad()

        # Print the progress
        if (epoch + 1) % 10 == 0:
            print(
                "Epoch [{}/{}], Loss: {:.4f}".format(epoch + 1, num_epochs, loss.item())
            )


dataset = RegressionDataset()
dataloader = torch.utils.data.DataLoader(dataset, batch_size=32)
model = torch.nn.Linear(1, 1)
criterion = torch.nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=3e-4)

fit(5000, model, criterion, optimizer, dataloader)

कठिन/आसान प्रतिगमन कार्य के लिए आपको लगभग 0.053 हानि या तो, भिन्न noise या अन्य पैरामीटर प्राप्त करने चाहिए।

7
Szymon Maszke 10 सितंबर 2020, 16:46