न्यूरलनेट - कंप्यूट लगातार जवाब देते हैं

मैं भविष्यवाणी के लिए आर के neuralnetपैकेज ( यहां प्रलेखन ) का उपयोग करने की कोशिश कर रहा हूं ।

यहाँ मैं क्या करने की कोशिश कर रहा हूँ:

library(neuralnet)
x <- cbind(runif(50, min=1, max=500), runif(50, min=1, max=500))
y <- x[, 1] * x[, 2]
train <- data.frame(x, y)
n <- names(train)
f <- as.formula(paste('y ~', paste(n[!n %in% 'y'], collapse = ' + ')))
net <- neuralnet(f, train, hidden = c(5, 5), threshold=0.01)
print(net)

all: neuralnet(formula = f, data = train, hidden = c(5, 5), threshold = 0.01)

1 repetition was calculated.

    Error Reached Threshold Steps
1 66136930789    0.004658283648 97938

test <- cbind(runif(10, min=1, max=500), runif(10, min=1, max=500))
res <- compute(net, test)
res$net.result
         [,1]
[1,] 58749.01798
[2,] 58749.01798
[3,] 58749.01798
[4,] 58749.01798
[5,] 58749.01798
[6,] 58749.01798
[7,] 58749.01798
[8,] 58749.01798
[9,] 58749.01798
[10,] 58749.01798

क्या कोई मुझे समझा सकता है कि त्रुटियां इतनी बड़ी क्यों हैं और सभी अनुमानित मूल्य लगभग स्थिर क्यों हैं?

r neural-networks prediction error

— luckyi
स्रोत

मैं तंत्रिका जाल में विशेषज्ञ नहीं हूं, लेकिन मुझे लगता है कि निम्नलिखित बिंदु आपके लिए उपयोगी हो सकते हैं। कुछ अच्छी पोस्टें भी हैं, उदाहरण के लिए छिपी हुई इकाइयाँ , जो आप इस साइट पर खोज सकते हैं कि तंत्रिका जाल क्या करते हैं जो आपको उपयोगी लग सकते हैं।

1 बड़ी त्रुटियां: आपका उदाहरण बिल्कुल काम नहीं आया

त्रुटियां इतनी बड़ी क्यों हैं और सभी अनुमानित मूल्य लगभग स्थिर क्यों हैं?

इसका कारण यह है कि तंत्रिका नेटवर्क आपके द्वारा दिए गए गुणन फ़ंक्शन की गणना करने में असमर्थ था और इसकी yपरवाह किए बिना, रेंज के बीच में एक निरंतर संख्या को आउटपुट करता xथा, प्रशिक्षण के दौरान त्रुटियों को कम करने का सबसे अच्छा तरीका था। (ध्यान दें कि कैसे 58749 एक साथ दो संख्याओं को 1 और 500 के बीच गुणा करने के मतलब के बहुत करीब है।)

$-1$ $1$

2 स्थानीय मिनीमाता: सैद्धांतिक रूप से उचित उदाहरण क्यों काम नहीं कर सकता है

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

x <- cbind(runif(50, min=1, max=500), runif(50, min=1, max=500))
y <- x[, 1] + x[, 2]
train <- data.frame(x, y)
n <- names(train)
f <- as.formula(paste('y ~', paste(n[!n %in% 'y'], collapse = ' + ')))
net <- neuralnet(f, train, hidden = 0, threshold=0.01)
print(net) # Error 0.00000001893602844

बेशक, आप लॉग्स लेकर अपनी मूल समस्या को एक अतिरिक्त समस्या में बदल सकते हैं, लेकिन मुझे नहीं लगता कि आप यही चाहते हैं, इसलिए आगे ...

अनुमान लगाने के लिए मापदंडों की संख्या की तुलना में 3 प्रशिक्षण उदाहरणों की संख्या

$\mathbf{x}\cdot\mathbf{k} > c$ $\mathbf{k} = (1, 2, 3, 4, 5)$ $c = 3750$

नीचे दिए गए कोड में मैं आपका एक समान दृष्टिकोण लेता हूं, सिवाय इसके कि मैं दो तंत्रिका जालों को प्रशिक्षित करता हूं, एक प्रशिक्षण सेट से 50 उदाहरणों के साथ, और एक 500 के साथ।

library(neuralnet)
set.seed(1) # make results reproducible
N=500
x <- cbind(runif(N, min=1, max=500), runif(N, min=1, max=500), runif(N, min=1, max=500), runif(N, min=1, max=500), runif(N, min=1, max=500))
y <- ifelse(x[,1] + 2*x[,1] + 3*x[,1] + 4*x[,1] + 5*x[,1] > 3750, 1, 0)
trainSMALL <- data.frame(x[1:(N/10),], y=y[1:(N/10)])
trainALL <- data.frame(x, y)
n <- names(trainSMALL)
f <- as.formula(paste('y ~', paste(n[!n %in% 'y'], collapse = ' + ')))
netSMALL <- neuralnet(f, trainSMALL, hidden = c(5,5), threshold = 0.01)
netALL <- neuralnet(f, trainALL, hidden = c(5,5), threshold = 0.01)
print(netSMALL) # error 4.117671763
print(netALL) # error 0.009598461875

# get a sense of accuracy w.r.t small training set (in-sample)
cbind(y, compute(netSMALL,x)$net.result)[1:10,]
      y                 
 [1,] 1  0.587903899825
 [2,] 0  0.001158500142
 [3,] 1  0.587903899825
 [4,] 0  0.001158500281
 [5,] 0 -0.003770868805
 [6,] 0  0.587903899825
 [7,] 1  0.587903899825
 [8,] 0  0.001158500142
 [9,] 0  0.587903899825
[10,] 1  0.587903899825

# get a sense of accuracy w.r.t full training set (in-sample)
cbind(y, compute(netALL,x)$net.result)[1:10,]
      y                 
 [1,] 1  1.0003618092051
 [2,] 0 -0.0025677656844
 [3,] 1  0.9999590121059
 [4,] 0 -0.0003835722682
 [5,] 0 -0.0003835722682
 [6,] 0 -0.0003835722199
 [7,] 1  1.0003618092051
 [8,] 0 -0.0025677656844
 [9,] 0 -0.0003835722682
[10,] 1  1.0003618092051

यह स्पष्ट है कि netALLबहुत बेहतर करता है! ऐसा क्यों है? एक plot(netALL)आदेश के साथ आपको क्या मिलता है, इस पर एक नज़र डालें :

यहाँ छवि विवरण दर्ज करें

मैं इसे 66 पैरामीटर बनाता हूं जो प्रशिक्षण के दौरान अनुमानित हैं (प्रत्येक 11 नोड्स में 5 इनपुट और 1 पूर्वाग्रह इनपुट)। आप 50 प्रशिक्षण उदाहरणों के साथ 66 मापदंडों का विश्वसनीय रूप से अनुमान नहीं लगा सकते। मुझे इस मामले में संदेह है कि आप इकाइयों की संख्या में कटौती करके अनुमानों की संख्या में कटौती करने में सक्षम हो सकते हैं। और आप एक तंत्रिका नेटवर्क के निर्माण से जोड़कर देख सकते हैं कि एक सरल तंत्रिका नेटवर्क को प्रशिक्षण के दौरान समस्याओं में चलाने की संभावना कम हो सकती है।

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

— TooTone
स्रोत

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

— भाग्य