तंत्रिका नेटवर्क के साथ बहुपद की सबसे बड़ी जड़ का पता लगाएं

Question

चुनौती

सबसे छोटा फीडफॉर्वर्ड न्यूरल नेटवर्क खोजें जैसे कि, [ - 10 , 10 ] में पूर्णांक प्रविष्टियों के साथ किसी भी 3-आयामी इनपुट वेक्टर $(a,b,c)$ को दिया गया है , नेटवर्क सबसे बड़ा (यानी, "सबसे सकारात्मक") रूट को आउटपुट करता है। बहुपद x 3 + a x 2 + b x + c त्रुटि के साथ कड़ाई से 0.1 से कम है ।$[-10,10]$$x^3+ax^2+bx+c$$0.1$

स्वीकार्यता

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

एक न्यूरॉन एक समारोह है $\nu\colon\mathbf{R}^n\to\mathbf{R}$ कि एक सदिश द्वारा निर्दिष्ट किया जाता $w\in\mathbf{R}^{n}$ के वजन , एक पूर्वाग्रह $b\in\mathbf{R}$ , और एक सक्रियण समारोह $f\colon\mathbf{R}\to\mathbf{R}$ निम्नलिखित तरीके से:

$$\nu(x) := f(w^\top x+b), \qquad x\in\mathbf{R}^n.$$

के साथ एक feedforward तंत्रिका नेटवर्क इनपुट नोड्स $\{1,\ldots,n\}$ की एक समारोह है $(x_1,\ldots,x_n)\in\mathbf{R}^n$ कि एक दृश्य से बनाया जा सकता है $(\nu_k)_{k=n+1}^N$ न्यूरॉन्स की, जहां प्रत्येक $\nu_k\colon\mathbf{R}^{k-1}\to\mathbf{R}$ इनपुट लेता है $(x_1,\ldots,x_{k-1})$और एक स्केलर$x_k$ आउटपुट करता है। कुछ निर्दिष्ट सेट को देखते हुए$S\subseteq\{1,\ldots,N\}$काउत्पादन नोड्स, तो तंत्रिका नेटवर्क के उत्पादन वेक्टर है$(x_k)_{k\in S}$ ।

चूंकि सक्रियण कार्यों को किसी भी कार्य के लिए ट्यून किया जा सकता है, इसलिए हमें इस चुनौती को दिलचस्प बनाए रखने के लिए सक्रियण कार्यों के वर्ग को प्रतिबंधित करना होगा। निम्नलिखित सक्रियण कार्यों की अनुमति है:

• पहचान। $f(t)=t$

• Relu। $f(t)=\operatorname{max}(t,0)$

• SoftPlus। $f(t)=\ln(e^t+1)$

• अवग्रह। $f(t)=\frac{e^t}{e^t+1}$

• Sinusoid। $f(t)=\sin t$

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

• इनपुट नोड्स: $\{1,2\}$

• न्यूरॉन्स: $\nu_k(x_1,\ldots,x_{k-1}):=x_{k-2}+x_{k-1}$ के लिए $k\in\{3,\ldots,10\}$

• आउटपुट नोड्स: $\{5,9,10\}$

इस नेटवर्क में 8 न्यूरॉन्स होते हैं, जिनमें से प्रत्येक में शून्य पूर्वाग्रह और पहचान सक्रियण होता है। शब्दों में, यह नेटवर्क $x_1$ और $x_2$ द्वारा उत्पन्न सामान्यीकृत फाइबोनैचि अनुक्रम की गणना करता है और फिर इस क्रम से 5 वें, 9 वें और 10 वें नंबर को आउटपुट करता है।

स्कोरिंग

यह देखते हुए एक वास्तविक संख्या $x$ समाप्त दशमलव विस्तार के साथ, चलो $p(x)$ सबसे छोटी गैर नकारात्मक पूर्णांक होने $p$ जिसके लिए $10^{-p}\cdot |x|<1$ , और $q(x)$ होना सबसे छोटी ग़ैर-ऋणात्मक पूर्णांक $q$ जिसके लिए $10^q \cdot x$ पूर्णांक है। फिर हम कहते हैं कि $p(x)+q(x)$ है परिशुद्धता के $x$ ।

उदाहरण के लिए, $x=1.001$ में $4$ सटीकता है , जबकि $x=0$ की परिशुद्धता में $0$ ।

आपका स्कोर आपके तंत्रिका नेटवर्क में भार और पूर्वाग्रहों के पूर्वाभास का योग है।

(उदाहरण, उपरोक्त उदाहरण में 16 का स्कोर है।)

सत्यापन

जबकि जड़ों को घन सूत्र के रूप में व्यक्त किया जा सकता है , सबसे बड़ी जड़ संभवतः संख्यात्मक साधनों द्वारा आसानी से प्राप्त की जाती है। @ Xnor के सुझाव के बाद, मैंने पूर्णांक $a,b,c\in[-10,10]$ की हर पसंद के लिए सबसे बड़ी जड़ की गणना की , और परिणाम यहां देखे जा सकते हैं । इस पाठ फ़ाइल की प्रत्येक पंक्ति प्रपत्र की है a,b,c,root। उदाहरण के लिए, पहली पंक्ति रिपोर्ट करती है कि $x^3-10x^2-10x-10$ की सबसे बड़ी जड़ - 10 x 2 - 10 x - 10 लगभग $10.99247140445449$ ।

संपादित करें: मेरे द्वारा पोस्ट की गई मूल फ़ाइल में उन मामलों में त्रुटियां थीं, जहां बहुपद एक बहु रूट प्रदर्शित करता है। वर्तमान संस्करण ऐसी त्रुटियों से मुक्त होना चाहिए।

Comments

क्या होता है इनपुट बहुपद में कोई वास्तविक जड़ें नहीं होती हैं, जैसे a=0कि द्विघात और दो जटिल जड़ें कब होती हैं?

— xnor

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

— xnor

मुझे नए प्रवेश के नियम पसंद हैं। ऐसा लगता है कि नया साइनसॉइड फ़ंक्शन हालांकि बेहद शोषक है। मेरे पास एक संक्षिप्त साक्ष्य है कि प्रपत्र का एक फ़ंक्शन x -> a * sin(b * softplus(x) + c)किसी भी परिमित संख्या के डेटा बिंदुओं को पूर्णांक के साथ xएक बहुत बड़ी और सटीक आवृत्ति का उपयोग करके मनमाना परिशुद्धता के साथ ओवरफिट कर सकता है ।

— xnor

यह सुनिश्चित नहीं है कि यह भविष्य की चुनौतियों के लिए कितना उपयोगी होगा: संख्या सिद्धांत में हम संख्या की जटिलता को मापने के लिए ऊंचाई के कार्यों का उपयोग करते हैं। उदाहरण के लिए एक (कम) अंश के अनुभवहीन ऊंचाई द्वारा दिया जाता है ज = लॉग ऑन अधिकतम { | पी | , | क्ष | } और बहुत सारे सामान्यीकरण हैं)। शायद यह एक वैकल्पिक उपाय के रूप में इस्तेमाल किया जा सकता है। $p/q$$h=\log\max\{|p|,|q|\}$

— दोष

@ DustinG.Mixon मुझे यकीन है कि अगर आपका बारे में पता नहीं कर रहा हूँ, लेकिन हम करते हैं एक है सैंडबॉक्स एक चुनौती एक अच्छी तरह से एक की पोस्टिंग ड्राफ्ट के लिए और चर्चा कर विवरण चैट ।

— दोष

Answer 1

14,674,000,667 5,436,050 5,403,448 10,385 5,994 4,447
3,806 कुल परिशुद्धता

एक आधार रेखा के लिए, मैं निम्नलिखित दृष्टिकोण की जांच की: चयन $M,\delta,\epsilon>0$ ऐसी है कि हम बहुपद नमूना अगर $p(x)=x^3+ax^2+bx+c$ में

$$S:=\{-M,-M+\delta,-M+2\delta,\ldots,M\},$$

तो सबसे बड़ा नमूना बिंदु $s^\star\in S$ संतोषजनक $p(s^\star)<\epsilon$ जरूरी मौजूद है और जरूरी भीतर रहता है $0.1$ की सबसे बड़ी जड़ की $p$ । एक दिखा सकते हैं कि बहुपद के हमारे संग्रह के लिए, एक समय लग सकता है $M=11$ , $\delta=0.1$ , और $\epsilon=10^{-4}$ ।

एक तंत्रिका जाल डिजाइन करने के लिए जो इस तर्क को लागू करता है, हम न्यूरॉन्स की एक परत के साथ शुरू करते हैं जो $S$ पर बहुपद का नमूना लेते हैं । प्रत्येक के लिए $s\in S$ , हम ले

$$x_{1,s} = s^2\cdot a + s\cdot b + 1\cdot c + s^3.$$

इसके बाद, हम की पहचान है जो इन की तुलना में कम कर रहे हैं $\epsilon=10^{-4}$ । ऐसा लगता है कि के लिए $s\in S$ , यह उस रखती $p(s)<10^{-4}$ ही अगर $p(s)\leq 0$ । इस प्रकार, हम अपने नमूनों की पहचान करने के लिए पुनः सक्रियण क्रियाओं का उपयोग कर सकते हैं:

$$\frac{\mathrm{relu}(10^{-4}-t) - \mathrm{relu}(-t)}{10^{-4}} = \left\{\begin{array}{cl}1&\text{if }t\leq 0\\0&\text{if }t\geq 10^{-4}.\end{array}\right.$$

हम इसे न्यूरॉन्स की कुछ परतों के साथ लागू करते हैं:

$$\begin{aligned} x_{2,s} &= \mathrm{relu}(-1\cdot x_{1,s}+10^{-4}), \\ x_{3,s} & = \mathrm{relu}(-1\cdot x_{1,s}), \\ x_{4,s} &= 10^{4}\cdot x_{2,s}-10^{4}\cdot x_{3,s}. \end{aligned}$$

$x_{4,s}=1$$p(s)<10^{-4}$$x_{4,s}=0$$s^\star$$x_{4,s^\star}=1$$x_{4,M}$$x_{5,M}$$k\geq 1$, हम इसे परिभाषित करते हैं

$$x_{5,M-k\delta} = 1\cdot x_{4,M-k\delta}+2\cdot x_{5,M-(k-1)\delta} = \sum_{j=0}^k 2^{k-j}x_{4,M-j\delta}.$$

$x_{5,s}$$s^\star$$s$$x_{5,s}=1$$s^\star$

$$\mathrm{relu}(t-2)-2\cdot\mathrm{relu}(t-1)+t = \left\{\begin{array}{cl}1&\text{if }t=1\\0&\text{if }t\in\mathbf{Z}_{\geq 0}\setminus\{1\}.\end{array}\right.$$

स्पष्ट रूप से, हम न्यूरॉन्स को परिभाषित करते हैं

$$\begin{aligned} x_{6,s} &= \mathrm{relu}(1\cdot x_{5,s} - 2), \\ x_{7,s} &= \mathrm{relu}(1\cdot x_{5,s} - 1), \\ x_{8,s} &= 1\cdot x_{6,s} - 2\cdot x_{7,s} + 1\cdot x_{5s}. \end{aligned}$$

$x_{8,s}=1$$s=s^\star$$x_{8,s}=0$

$$x_9 = \sum_{s\in S} s\cdot x_{8,s} = s^\star.$$

$6+3+1+9=19$$1+4=5$$1$$5+5=10$$1+1=2$$1+1=2$$1+1=2$$1+1+1=3$$3|S|$$|S|=221$$|S|-1$$1$

संपादित करें: सुधार: (1) हम परिमित अंतरों का उपयोग करके बहुपद को अधिक कुशलता से नमूना कर सकते हैं। (2) हम सिग्मॉइड सक्रियण का उपयोग करके 4 के माध्यम से 2 परतों को बायपास कर सकते हैं। (3) परत 5 में अतिप्रवाह के मुद्दों को अधिक सावधानी से लागू करने वाली रिलेयू क्रियाओं द्वारा रोका जा सकता है (और बाद की परतों को जोड़ा जा सकता है)। (४) अंतिम योग भागों के योग से सस्ता है ।

MATLAB कोड इस प्रकार है। स्पष्ट होने के लिए, precएक फ़ंक्शन ( यहां पाया गया ) है जो वजन या गैसों के एक वेक्टर की सटीकता की गणना करता है।

function sstar = findsstar2(a,b,c)

relu = @(x) x .* (x>0);

totprec = 0;

% x1 samples the polynomial on -11:0.1:11
x1=[];
for s = -11:0.1:11
    if length(x1) < 5
        w1 = [s^2 s 1];
        b1 = s^3;
        x1(end+1,:) = w1 * [a; b; c] + b1;
        totprec = totprec + prec(w1) + prec(b1);
    else
        w1 = [-1 4 -6 4];
        x1(end+1,:) = w1 * x1(end-3:end,:);
        totprec = totprec + prec(w1);
    end
end

% x4 indicates whether the polynomial is nonpositive
w4 = -6e5;
b4 = 60;
x4=[];
for ii=1:length(x1)
    x4(end+1) = sigmf(w4 * x1(ii) + b4, [1,0]);
    totprec = totprec + prec(w4) + prec(b4);
end

% x6 indicates which entries are less than or equal to sstar
x5 = zeros(size(x1));
x6 = zeros(size(x1));
x5(end) = 0;
x6(end) = 0;
for ii = 1:length(x5)-1
    w5 = [-1 -1];
    b5 = 1;
    x5(end-ii) = relu(w5 * [x4(end-ii); x6(end-ii+1)] + b5);
    totprec = totprec + prec(w5) + prec(b5);
    w6 = -1;
    b6 = 1;
    x6(end-ii) = w6 * x5(end-ii) + b6;
    totprec = totprec + prec(w6) + prec(b6);
end

% a linear combination produces sstar
w7 = 0.1*ones(1,length(x1));
w7(1) = -11;
sstar = w7 * x6;

%disp(totprec) % uncomment to display score

end

Answer 2

53,268 29,596 29,306 कुल परिशुद्धता

$f\colon S\to\mathbf{R}$$S$

$$f(x) = \sum_{s\in S}f(s)\cdot \left\{\begin{array}{cl}1&\text{if }x=s\\0&\text{else}\end{array}\right\}.$$

$f$

$$\mathrm{relu}(t-1)-2\cdot\mathrm{relu}(t)+\mathrm{relu}(t+1) = \left\{\begin{array}{cl}1&\text{if } t=0\\0&\text{if }t\in\mathbf{Z}\setminus\{0\}.\end{array}\right.$$

इस दृष्टिकोण का MATLAB कार्यान्वयन क्या है। स्पष्ट होने के लिए, roots.txtमूल फ़ाइल ऊपर पोस्ट की गई है ( यहां पाया गया है ), और precएक फ़ंक्शन ( यहां पाया गया ) है जो वेट या बायसे के वेक्टर की कुल परिशुद्धता की गणना करता है।

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

संपादित करें 2: अतिरिक्त मामूली सुधार: (1) मैंने लूप के लिए अधिक न्यूरॉन्स को फैक्टर किया। (2) मैं अंतिम राशि में उस शब्द की गणना करने से परेशान नहीं होता जिसके लिए आउटपुट पहले से ही शून्य है।

function r = approxroot(a,b,c)

relu = @(x)x .* (x>0);

totalprec=0;

% x4 indicates which entry of (-10:10) is a
w1 = ones(21,1);   b1 = -(-10:10)'-1;    x1 = relu(w1 * a + b1);
w2 = ones(21,1);   b2 = -(-10:10)';      x2 = relu(w2 * a + b2);
w3 = ones(21,1);   b3 = -(-10:10)'+1;    x3 = relu(w3 * a + b3);
w4p1 = ones(21,1); w4p2 = -2*ones(21,1); w4p3 = ones(21,1);
x4 = w4p1 .* x1 + w4p2 .* x2 + w4p3 .* x3;
totalprec = totalprec + prec(w1) + prec(w2) + prec(w3) + prec(b1) + prec(b2) + prec(b3) + prec(w4p1) + prec(w4p2) + prec(w4p3);

% x8 indicates which entry of (-10:10) is b
w5 = ones(21,1);   b5 = -(-10:10)'-1;    x5 = relu(w5 * b + b5);
w6 = ones(21,1);   b6 = -(-10:10)';      x6 = relu(w6 * b + b6);
w7 = ones(21,1);   b7 = -(-10:10)'+1;    x7 = relu(w7 * b + b7);
w8p1 = ones(21,1); w8p2 = -2*ones(21,1); w8p3 = ones(21,1);
x8 = w8p1 .* x5 + w8p2 .* x6 + w8p3 .* x7;
totalprec = totalprec + prec(w5) + prec(w6) + prec(w7) + prec(b5) + prec(b6) + prec(b7) + prec(w8p1) + prec(w8p2) + prec(w8p3);

% x12 indicates which entry of (-10:10) is c
w9 = ones(21,1);    b9 = -(-10:10)'-1;     x9 = relu(w9 * c + b9);
w10 = ones(21,1);   b10 = -(-10:10)';      x10 = relu(w10 * c + b10);
w11 = ones(21,1);   b11 = -(-10:10)'+1;    x11 = relu(w11 * c + b11);
w12p1 = ones(21,1); w12p2 = -2*ones(21,1); w12p3 = ones(21,1);
x12 = w12p1 .* x9 + w12p2 .* x10 + w12p3 .* x11;
totalprec = totalprec + prec(w9) + prec(w10) + prec(w11) + prec(b9) + prec(b10) + prec(b11) + prec(w12p1) + prec(w12p2) + prec(w12p3);

% x15 indicates which row of the roots file is relevant
x15=[];
for aa=-10:10
    w13 = 1;
    b13 = -2;
    x13 = w13 * x4(aa+11) + b13;
    totalprec = totalprec + prec(w13) + prec(b13);
    for bb=-10:10
        w14p1 = 1;
        w14p2 = 1;
        x14 = w14p1 * x13 + w14p2 * x8(bb+11);
        totalprec = totalprec + prec(w14p1) + prec(w14p2);
        for cc=-10:10
            w15p1 = 1;
            w15p2 = 1;
            x15(end+1,1) = relu(w15p1 * x14 + w15p2 * x12(cc+11));
            totalprec = totalprec + prec(w15p1) + prec(w15p2);
        end
    end
end

% r is the desired root, rounded to the nearest fifth
A = importdata('roots.txt');
outputs = 0.2 * round(5 * A(:,4)');
uniqueoutputs = unique(outputs);
x16 = [];
for rr = uniqueoutputs
    if rr == 0
        x16(end+1,:) = 0;
    else
        lvlset = find(outputs == rr);
        w16 = ones(1,length(lvlset));
        x16(end+1,:) = w16 * x15(lvlset);
        totalprec = totalprec + prec(w16);
    end
end
w17 = uniqueoutputs;
r = w17 * x16;
totalprec = totalprec + prec(w17);

%disp(totalprec) % uncomment to display score

end