मैं PyTorch का उपयोग करके तंत्रिका नेटवर्क के साथ कुछ प्रयोग करना चाहता हूं, इसलिए मैंने वार्म-अप अभ्यास के रूप में एक सरल प्रयास किया, और मैं परिणामों को समझ नहीं पाया।

यह अभ्यास विभिन्न आँकड़ों से 1000 टीपीटीपी समस्याओं की रेटिंग की भविष्यवाणी करने का प्रयास करता है जैसे कि चर की संख्या, अधिकतम खंड लंबाई आदि। डेटा फ़ाइल https://github.com/russellw/ml/blob/master/test.csv काफी सीधा है, 1000 पंक्तियां, अंतिम कॉलम रेटिंग है, शुरू कुछ दसियों इनपुट कॉलमों के साथ, सभी नंबरों को 0-1 की सीमा तक बढ़ाया गया, मैंने उत्तरोत्तर सुविधाओं को हटा दिया ताकि यह देखने के लिए कि परिणाम अभी भी आयोजित किया गया है, और यह एक इनपुट कॉलम तक सभी तरह से करता है; अन्य गिट इतिहास में पिछले संस्करणों में हैं।

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

इस डेटा सेट पर सरल रेखीय प्रतिगमन में लगभग 0.14 की औसत चुकता त्रुटि है।

मैंने https://github.com/ में एक साधारण फीडफॉरवर्ड न्यूरल नेटवर्क, कोड लागू किया russellw/ml/blob/master/test_nn.py और नीचे कॉपी किया गया है, कि कुछ सौ प्रशिक्षण युगों के बाद, 0.14 की औसत चुकता त्रुटि भी है।

इसलिए मैंने कुछ अलग-अलग ऑप्टिमाइज़र का उपयोग करके, कुछ अलग-अलग ऑप्टिमाइज़र का उपयोग करके, एक्टिवेशन फ़ंक्शंस को रिले से टैन में दोनों के मिश्रण में बदलकर, 1 से 2 से 3 तक छिपी हुई परतों की संख्या को बदलने की कोशिश की, युगों की संख्या बढ़ाकर 5000 कर दी। छिपी हुई इकाइयों की संख्या 1000 तक। इस बिंदु पर, इसमें आसानी से पूरे डेटा सेट को याद रखने की क्षमता होनी चाहिए। (इस बिंदु पर मैं ओवरफिटिंग के बारे में चिंतित नहीं हूं। मैं सिर्फ 0.14 के अलावा कुछ और होने के लिए प्रशिक्षण डेटा पर औसत चुकता त्रुटि प्राप्त करने की कोशिश कर रहा हूं।) कुछ भी कोई फर्क नहीं पड़ा। अभी भी 0.14. मैं कहूंगा कि इसे स्थानीय इष्टतम में फंसना चाहिए, लेकिन ऐसा तब नहीं होना चाहिए जब आपके पास कुछ मिलियन वजन हों; एक साथ सभी मापदंडों के लिए स्थानीय इष्टतम में होना व्यावहारिक रूप से असंभव माना जाता है। और मुझे प्रत्येक रन पर संख्याओं के थोड़े अलग क्रम मिलते हैं। लेकिन यह हमेशा 0.14 में परिवर्तित होता है।

अब स्पष्ट निष्कर्ष यह होगा कि 0.14 इस समस्या के लिए जितना अच्छा है, उतना ही अच्छा है, सिवाय इसके कि यह तब भी वैसा ही रहता है जब नेटवर्क के पास सभी डेटा को याद रखने के लिए पर्याप्त मेमोरी हो। लेकिन निर्णायक यह है कि मैंने एक यादृच्छिक वन की भी कोशिश की, https://github. com/russellw/ml/blob/master/test_rf.py

... और रैंडम फ़ॉरेस्ट में मूल डेटा सेट पर 0.01 की औसत चुकता त्रुटि है, सुविधाओं को हटाते ही इनायत से अपमानजनक, अभी भी केवल एक सुविधा के साथ डेटा पर 0.05 है।

मशीन लर्निंग की विद्या में कहीं भी यह नहीं कहा गया है कि 'यादृच्छिक वन तंत्रिका जाल से काफी बेहतर प्रदर्शन करते हैं', इसलिए मैं संभवतः कुछ गलत कर रहा हूं, लेकिन मैं यह नहीं देख सकता कि यह क्या है। हो सकता है कि यह कुछ उतना ही सरल हो जितना कि सिर्फ एक झंडा या कुछ ऐसा जो आपको PyTorch में सेट करने की आवश्यकता है। अगर कोई देख सकता है तो मैं इसकी सराहना करता हूं।

import numpy as np
import pandas as pd
import torch
import torch.nn as nn

# data
df = pd.read_csv("test.csv")
print(df)
print()

# separate the output column
y_name = df.columns[-1]
y_df = df[y_name]
X_df = df.drop(y_name, axis=1)

# numpy arrays
X_ar = np.array(X_df, dtype=np.float32)
y_ar = np.array(y_df, dtype=np.float32)

# torch tensors
X_tensor = torch.from_numpy(X_ar)
y_tensor = torch.from_numpy(y_ar)

# hyperparameters
in_features = X_ar.shape[1]
hidden_size = 100
out_features = 1
epochs = 500

# model
class Net(nn.Module):
    def __init__(self, hidden_size):
        super(Net, self).__init__()
        self.L0 = nn.Linear(in_features, hidden_size)
        self.N0 = nn.ReLU()
        self.L1 = nn.Linear(hidden_size, hidden_size)
        self.N1 = nn.Tanh()
        self.L2 = nn.Linear(hidden_size, hidden_size)
        self.N2 = nn.ReLU()
        self.L3 = nn.Linear(hidden_size, 1)

    def forward(self, x):
        x = self.L0(x)
        x = self.N0(x)
        x = self.L1(x)
        x = self.N1(x)
        x = self.L2(x)
        x = self.N2(x)
        x = self.L3(x)
        return x


model = Net(hidden_size)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.1)

# train
print("training")
for epoch in range(1, epochs + 1):
    # forward
    output = model(X_tensor)
    cost = criterion(output, y_tensor)

    # backward
    optimizer.zero_grad()
    cost.backward()
    optimizer.step()

    # print progress
    if epoch % (epochs // 10) == 0:
        print(f"{epoch:6d} {cost.item():10f}")
print()

output = model(X_tensor)
cost = criterion(output, y_tensor)
print("mean squared error:", cost.item())
1
rwallace 11 पद 2019, 18:08

1 उत्तर

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

क्या आप कृपया अपने इनपुट का आकार प्रिंट कर सकते हैं? मैं कहूंगा कि पहले उन चीजों की जांच करें:

  • कि आपके लक्ष्य y का आकार (-1, 1) है, मुझे नहीं पता कि इस मामले में pytorch कोई त्रुटि फेंकता है या नहीं। आप y.reshape(-1, 1) का उपयोग कर सकते हैं यदि यह 2 मंद नहीं है
  • आपकी सीखने की दर उच्च है। आमतौर पर एडम का उपयोग करते समय डिफ़ॉल्ट मान काफी अच्छा होता है या बस अपनी सीखने की दर को कम करने का प्रयास करें। 0.1 सीखने की दर के साथ शुरू करने के लिए एक उच्च मूल्य है
  • ऑप्टिमाइज़र.zero_grad को लूप के अंदर पहली पंक्ति में रखें
  • अपने डेटा को सामान्य/मानकीकृत करें (यह आमतौर पर एनएन के लिए अच्छा है)
  • अपने डेटा में आउटलेर्स को हटा दें (मेरी राय: मुझे लगता है कि यह रैंडम फ़ॉरेस्ट को इतना प्रभावित नहीं कर सकता है लेकिन यह एनएन को बुरी तरह प्रभावित कर सकता है)
  • क्रॉस सत्यापन का उपयोग करें (शायद scorch यहां आपकी मदद कर सकता है। यह पाइटोरच के लिए एक स्किकिट लर्न रैपर है और यदि आप केरस जानते हैं तो इसका उपयोग करना आसान है)

ध्यान दें कि रैंडम फ़ॉरेस्ट रेजिस्टर या कोई अन्य रजिस्ट्रार कुछ मामलों में तंत्रिका जाल से बेहतर प्रदर्शन कर सकता है। कुछ ऐसे क्षेत्र हैं जहां तंत्रिका जाल छवि वर्गीकरण या एनएलपी जैसे नायक हैं लेकिन आपको इस बात से अवगत होना चाहिए कि एक साधारण प्रतिगमन एल्गोरिदम उन्हें बेहतर प्रदर्शन कर सकता है। आमतौर पर जब आपका डेटा काफी बड़ा नहीं होता है।

4
basilisk 11 पद 2019, 19:40