68

मैं इस समुदाय को एक अलग तरह की गोल्फ चुनौती देना चाहता हूं:

(कृत्रिम) तंत्रिका नेटवर्क बहुत लोकप्रिय मशीन लर्निंग मॉडल हैं जिन्हें किसी भी दिए गए (आमतौर पर अज्ञात) फ़ंक्शन के लिए डिज़ाइन और प्रशिक्षित किया जा सकता है। वे अक्सर अत्यधिक जटिल समस्याओं को हल करने के लिए उपयोग किए जाते हैं जो हम नहीं जानते कि एल्गोरिदम को भाषण मान्यता, कुछ प्रकार के छवि वर्गीकरण, स्वायत्त ड्राइविंग सिस्टम में विभिन्न कार्यों को कैसे हल किया जाए ... तंत्रिका नेटवर्क पर एक प्राइमर के लिए, इस उत्कृष्ट पर विचार करें। विकिपीडिया लेख ।

जैसा कि मैं गोल्फ सीखने की चुनौतियों की मशीन बनने की उम्मीद में यह पहला है, मैं चीजों को यथासंभव सरल रखना चाहूंगा:

अपनी पसंद की भाषा और रूपरेखा में, एक तंत्रिका नेटवर्क को डिज़ाइन और प्रशिक्षित करें, जो उनके उत्पाद गणना सभी पूर्णांक बीच (और शामिल) और । $(x_1, x_2)$ $x_1 \cdot x_2$ $x_1, x_2$ $-10$ $10$

प्रदर्शन लक्ष्य

अर्हता प्राप्त करने के लिए, आपका मॉडल उन प्रविष्टियों में से किसी पर भी सही परिणाम से से अधिक विचलन नहीं कर सकता है । $0.5$

नियम

आपका मॉडल

एक 'पारंपरिक' तंत्रिका नेटवर्क होना चाहिए (एक नोड का मान एक सक्रिय परत के बाद एक पिछली परत में कुछ नोड्स के भारित रैखिक संयोजन के रूप में गणना की जाती है)
केवल निम्नलिखित मानक सक्रियण कार्यों का उपयोग कर सकते हैं:
1. $\textrm{linear}(x) = x$ ,
2. $\textrm{softmax}(\vec{x})_i = \frac{e^{x_i}}{\sum_j e^{x_j}}$ ,
3. $\textrm{selu}_{\alpha, \beta}(x) = \begin{cases} \beta \cdot x & \text{, if } x > 0 \\ \alpha \cdot \beta (e^x -1 ) & \text{, otherwise} \end{cases}$ ,
4. $\textrm{softplus}(x) = \ln(e^x+1)$ ,
5. $\textrm{leaky-relu}_\alpha(x) = \begin{cases} x & \text{, if } x < 0 \\ \alpha \cdot x & \text{, otherwise} \end{cases}$ ,
6. $\tanh(x)$ ,
7. $\textrm{sigmoid}(x) = \frac{e^x}{e^x+1}$ ,
8. $\textrm{hard-sigmoid}(x) = \begin{cases} 0 & \text{, if } x < -2.5 \\ 1 & \text{, if } x > 2.5 \\ 0.2 \cdot x + 0.5 & \text{, otherwise} \end{cases}$ ,
9. $e^x$
एक / वेक्टर / सूची / ... पूर्णांक के रूप में या इसके एकमात्र इनपुट के रूप में तैरता है लेना चाहिए $(x_1, x_2)$
एक पूर्णांक, फ्लोट (या एक उपयुक्त कंटेनर, उदाहरण के लिए एक वेक्टर या सूची, जिसमें यह उत्तर होता है) के रूप में उत्तर लौटाएं।

आपके परिणाम की जाँच करने के लिए आपके उत्तर में (या लिंक) सभी कोड आवश्यक होने चाहिए - जिसमें आपके मॉडल के प्रशिक्षित वजन भी शामिल हों।

स्कोरिंग

सबसे कम संख्या में वजन (पूर्वाग्रह भार सहित) के साथ तंत्रिका नेटवर्क जीतता है।

का आनंद लें!

arithmetic atomic-code-golf neural-networks

— स्टीफन मेस्केन
स्रोत

9

साइट पर आपका स्वागत है! मुझे लगता है कि यह चुनौती एक तंत्रिका नेटवर्क की अधिक मजबूत परिभाषा से एक अच्छे सौदे को लाभ दे सकती है। यहाँ कुछ बातें 1 हैं) आपके लिए यह बहुत अच्छा होगा कि आप इसे भाषा में बताएं जो पहले से ही NNs 2 का ज्ञान नहीं देता है) आपको वास्तव में बाहरी स्रोत से लिंक करने के बजाय अपने पोस्ट में सक्रियण कार्यों को सूचीबद्ध करना चाहिए ( बाहरी लिंक बदल सकते हैं या गायब हो सकते हैं)।

— गेहूं जादूगर

4

क्या हम वज़न का पुन: उपयोग कर सकते हैं / दृढ़ परतों का उपयोग कर सकते हैं? (मैं बोनस को हटाने की सलाह देता हूं, क्योंकि यह चुनौती के लिए कुछ भी नहीं जोड़ता है और मुख्य लक्ष्य से सिर्फ विचलित करता है।) क्या वजन वास्तविक होना चाहिए या क्या वे जटिल हो सकते हैं?

— दोष

4

आपके शब्द की परत 3 से नोड्स का तात्पर्य है परत 1 से इनपुट का उपयोग नहीं किया जा सकता है। क्या यह परत 2 नोड के लिए एक भार है जो आपके f(x) = xइनपुट को आगे बढ़ाने के लिए कर रहा है?

— ग्रिम जू

4

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

— पीटर टेलर

7

हर्गिज नहीं। इस तरह के मुद्दों को कई वर्षों के दौरान अन्य लोगों को देखने के अनुभव से पता चलता है कि वे एक ही तरह की गलतियाँ करते हैं। कुछ अस्पष्टताएं सैंडबॉक्स के पीछे खिसक जाती हैं, लेकिन कई और वहां पकड़े जाते हैं। और यह निश्चित रूप से पकड़ा गया होगा, क्योंकि जैसा कि मेरी पहली टिप्पणी में संकेत दिया गया था कि दो महीने पहले एक तंत्रिका शुद्ध प्रश्न के साथ हमारे पास बिल्कुल वही समस्याएं थीं।

— पीटर टेलर

37

21 13 11 9 वजन

यह बिलिनियर रूपों के ध्रुवीकरण पहचान पर आधारित है जो एक आयामी वास्तविक मामले में बहुपद पहचान को कम करता है:

x \cdot y = \frac{(x + y)^{2} - (x - y)^{2}}{4}

$x\cdot y = \frac{(x+y)^2 - (x-y)^2}{4}$

तो y1बस [x+y, x-y]एक रेखीय परिवर्तन का उपयोग कर गणना करता है , और अगले एक के लिए एक पूर्वसंयोजक कदम y3के y1रूप में बस का पूर्ण मूल्य है : फिर "कठिन" भाग उन वर्गों की गणना कर रहा है जिन्हें मैं नीचे समझाऊंगा, और उसके बाद बस एक अंतर और स्केलिंग की गणना करूंगा फिर से एक रैखिक ऑपरेशन है।

वर्गों का उपयोग मैं एक घातीय श्रृंखला की गणना करने के जो सभी पूर्णांकों के लिए सटीक होना चाहिए के आसपास के भीतर । यह श्रृंखला रूप की है $s$ $\{0,1,2,\ldots,20\}$ $0.5$

approx_square (x) = \sum_{i = 0}^{2} w_{i} \exp (0.0001 \cdot i \cdot x)

$\text{approx_square}(x) = \sum_{i=0}^2 w_i \exp(0.0001 \cdot i \cdot x)$

जहाँ मैं सिर्फ वज़न W2( ) के लिए अनुकूलित करता हूँ । इस पूरे सन्निकटन में फिर से शामिल होने वाले एक घातीय सक्रियण के साथ फिर से सिर्फ दो रैखिक परिवर्तन शामिल हैं। इस दृष्टिकोण के परिणामस्वरूप अधिकतम विचलन होता है । $=(w_i)_i$ 0.02

function p = net(x)
% 9 weights
one = 1; 
mone =-1;
zero = 0;
fourth = 0.25;
W1 = [1e-4, 2e-4];
W2  = [-199400468.100687;99700353.6313757];
b2 = 99700114.4299316;
leaky_relu = @(a,x)max(a*x,x); 


% Linear
y0 = [one, one; one, mone] * x;

% Linear + ReLU
y1 = mone * y0;
y2 = [leaky_relu(zero, y0), leaky_relu(zero, y1)];

% Linear
y3 = y2 * [one; one];

% Linear + exp
y4 = exp(y3 * W1); 

% Linear + Bias
y5 =  y4 * W2 + b2;

% Linear
y6 = [one, mone]*y5;
p = y6 * fourth;

end

इसे ऑनलाइन आज़माएं!

— flawr
स्रोत

मुझे लगता है कि TIO लिंक के पाद लेख में आपका चेकिंग कोड एक एप्लिकेशन को याद करता है abs। लेकिन सब कुछ वैसे भी ठीक है।

— क्रिश्चियन सेवर्स

@ChristianSievers धन्यवाद, मैंने TIO लिंक अपडेट किया!

— दोष

मैं एनएन पर एक विशेषज्ञ नहीं हूं, जिज्ञासा से बाहर, वजन कैसे किया जाता है? y04 की जरूरत है, y12 की जरूरत है , 2 की y3जरूरत है, y41 की y5जरूरत है , 1 की y6जरूरत है और 2। वह 12 है?

— मार्गरेट ब्लूम

3

@MargaretBloom हां यह वास्तव में थोड़ा असामान्य है, लेकिन ओपी ने टिप्पणियों में कहा कि हम वजन का पुन: उपयोग कर सकते हैं और केवल एक बार उन्हें गिनना होगा, भले ही हम एक ही वजन का कई बार उपयोग करें। इसलिए मेरे द्वारा उपयोग किए जा रहे सभी भार फ़ंक्शन के पहले भाग में परिभाषित किए गए हैं।

— दोष

31

7 वज़न

eps = 1e-6
c = 1 / (2 * eps * eps)

def f(A, B):
	e_s = exp(eps * A + eps * B)  # 2 weights, exp activation
	e_d = exp(eps * A - eps * B)  # 2 weights, exp activation
	return c * e_s + (-c) * e_d + (-1 / eps) * B  # 3 weights, linear activation

इसे ऑनलाइन आज़माएं!

$\epsilon$ $e^x \approx 1 + x + \frac{x^2}{2}$

A B \approx \frac{e^{ϵ A + ϵ B} - e^{ϵ A - ϵ B}}{2 ϵ^{2}} - \frac{B}{ϵ}

$AB \approx \frac{e^{\epsilon A+\epsilon B} - e^{\epsilon A-\epsilon B}}{2 \epsilon^2} - \frac{B}{\epsilon}$

$\epsilon$ epsc

— XNOR
स्रोत

1

यकीन नहीं है कि यह एक 'पारंपरिक तंत्रिका नेटवर्क' (नियम # 1) के रूप में गिना जाता है, लेकिन यह स्पष्ट है कि इसे एक में पुन: स्वरूपित किया जा सकता है, इसलिए मुझे इसके साथ कोई समस्या नहीं है। अच्छा समाधान!

— स्टीफन मेस्केन

1

आप C = -B(1 वजन) को परिभाषित कर सकते हैं और फिर [e_s, e_d] = conv([A,B,C], [eps, eps])एक वजन बचाने के लिए (2 वजन) :) (BTW: बहुत चालाक दृष्टिकोण!)

— दोष

(मैं जोड़ना भूल गया exp)

— दोष

4

आप वजन को कम करके भी बहुत कम प्राप्त कर सकते हैं - आपको कई बार एक ही वजन की गणना करने की आवश्यकता नहीं है।

— दोष

2

@flawr यह एक अच्छी चाल है, लेकिन मुझे लगता है कि टिप्पणियों में दीक्षांत और पुन: उपयोग के लिए भत्ते यह इतना अलग चुनौती है कि मैं इस उत्तर को रखने जा रहा हूं।

— xnor

22

३३ ३१ वज़न

# Activation functions
sub hard { $_[0] < -2.5 ? 0 : $_[0] > 2.5 ? 1 : 0.2 * $_[0] + 0.5 }
sub linear { $_[0] }

# Layer 0
sub inputA() { $a }
sub inputB() { $b }

# Layer 1
sub a15() { hard(5*inputA) }

# Layer 2
sub a8()  { hard(-5*inputA + 75*a15 - 37.5) }

# Layer 3
sub aa()  { linear(-5*inputA + 75*a15 - 40*a8) }

# Layer 4
sub a4()  { hard(aa - 17.5) }

# Layer 5
sub a2()  { hard(aa - 20*a4 - 7.5) }

# Layer 6
sub a1()  { linear(0.2*aa - 4*a4 - 2*a2) }

# Layer 7
sub b15() { hard(0.25*inputB - 5*a15) }
sub b8()  { hard(0.25*inputB - 5*a8) }
sub b4()  { hard(0.25*inputB - 5*a4) }
sub b2()  { hard(0.25*inputB - 5*a2) }
sub b1()  { hard(0.25*inputB - 5*a1) }

# Layer 8
sub output() { linear(-300*b15 + 160*b8 + 80*b4 + 40*b2 + 20*b1 - 10*inputA) }

# Test
for $a (-10..10) {
        for $b (-10..10) {
                die if abs($a * $b - output) >= 0.5;
        }
}

print "All OK";

इसे ऑनलाइन आज़माएं!

यह (सॉर्टा) बाइनरी में लंबी गुणा करता है, और इस तरह सटीक परिणाम देता है। यह कुछ और अधिक गोल्फ के लिए 0.5 त्रुटि विंडो का लाभ उठाना संभव होना चाहिए, लेकिन मुझे यकीन नहीं है कि कैसे।

परतों 1 से 6 में 5 "बिट्स" में पहला इनपुट विघटित होता है। गोल्फ कारणों से, हम वास्तविक बाइनरी का उपयोग नहीं करते हैं। सबसे महत्वपूर्ण "बिट" का वजन 16 के बजाय -15 है, और जब इनपुट 0 होता है, तो सभी "बिट्स" 0.5 होते हैं (जो अभी भी ठीक काम करता है, क्योंकि यह पहचान को संरक्षित करता है inputA = -15*a15 + 8*a8 + 4*a4 + 2*a2 + 1*a1)।

— साँवला
स्रोत

1

मुझे उम्मीद थी कि कोई व्यक्ति हार्ड-कोडित, ANN-ified गुणा एल्गोरिथ्म के साथ आएगा। लेकिन मुझे नहीं लगा कि यह पहली प्रतिक्रिया होगी। बहुत बढ़िया! (मैं यह देखने के लिए भी उत्सुक हूं कि क्या आप एमएनआईएसटी डेटासेट या कुछ अन्य, अधिक सापेक्ष समस्या के साथ इस तरह से कुछ खींचने में सक्षम होंगे: डी।)

— स्टीफन मेस्केन

14

43 वजन

अब तक पोस्ट किए गए दो समाधान बहुत ही चतुर हैं, लेकिन उनके दृष्टिकोण मशीन लर्निंग (जैसे ओसीआर) में अधिक पारंपरिक कार्यों के लिए काम नहीं करेंगे। इसलिए मैं इस कार्य के लिए एक 'जेनेरिक' (कोई चालाक चाल नहीं) समाधान प्रस्तुत करना चाहता हूं जो उम्मीद करता है कि अन्य लोगों को इस पर सुधार करने और मशीन सीखने की दुनिया में जाने के लिए प्रेरित करें:

मेरा मॉडल TensorFlow 2.0 में निर्मित 2 छिपी हुई परतों के साथ एक बहुत ही सरल तंत्रिका नेटवर्क है (लेकिन कोई अन्य ढांचा भी काम करेगा):

model = tf.keras.models.Sequential([
tf.keras.layers.Dense(6, activation='tanh', input_shape=(2,)),
tf.keras.layers.Dense(3, activation='tanh'),
tf.keras.layers.Dense(1, activation='linear')
])

जैसा कि आप देख सकते हैं, सभी परतें घनी हैं (जो निश्चित रूप से इष्टतम नहीं है), सक्रियण कार्य तन (जो वास्तव में इस कार्य के लिए ठीक हो सकता है), आउटपुट परत को छोड़कर, इस कार्य की प्रकृति के कारण, एक रैखिक सक्रियण समारोह है।

43 वज़न हैं:

$(2+1) \cdot 6 = 18$
$(6+1) \cdot 3 = 21$
$(3+1) \cdot 1 = 4$

$-10$ $10$

अगला, मैंने उन्हें ठीक से ट्यून किया है - पूर्णांक गुणन कार्यों में से किसी पर अधिकतम विचलन के लिए अनुकूलन। दुर्भाग्य से, मेरे नोट्स बहुत अच्छा ट्यूनिंग नहीं दिखाते हैं जो मैंने करना समाप्त कर दिया है, लेकिन यह बहुत मामूली था। उन 441 प्रशिक्षण नमूनों पर 100 युगों के पड़ोस में, जिनका बैच आकार 441 है।

ये वे भार हैं जिनके साथ मैं समाप्त हुआ:

[<tf.Variable 'dense/kernel:0' shape=(2, 6) dtype=float32, numpy=
 array([[ 0.10697944,  0.05394982,  0.05479664, -0.04538541,  0.05369904,
         -0.0728976 ],
        [ 0.10571832,  0.05576797, -0.04670485, -0.04466859, -0.05855528,
         -0.07390639]], dtype=float32)>,
 <tf.Variable 'dense/bias:0' shape=(6,) dtype=float32, numpy=
 array([-3.4242163, -0.8875816, -1.7694025, -1.9409281,  1.7825342,
         1.1364107], dtype=float32)>,
 <tf.Variable 'dense_1/kernel:0' shape=(6, 3) dtype=float32, numpy=
 array([[-3.0665843 ,  0.64912266,  3.7107112 ],
        [ 0.4914808 ,  2.1569328 ,  0.65417236],
        [ 3.461693  ,  1.2072319 , -4.181983  ],
        [-2.8746269 , -4.9959164 ,  4.505049  ],
        [-2.920127  , -0.0665407 ,  4.1409926 ],
        [ 1.3777553 , -3.3750365 , -0.10507642]], dtype=float32)>,
 <tf.Variable 'dense_1/bias:0' shape=(3,) dtype=float32, numpy=array([-1.376577  ,  2.8885336 ,  0.19852689], dtype=float32)>,
 <tf.Variable 'dense_2/kernel:0' shape=(3, 1) dtype=float32, numpy=
 array([[-78.7569  ],
        [-23.602606],
        [ 84.29587 ]], dtype=float32)>,
 <tf.Variable 'dense_2/bias:0' shape=(1,) dtype=float32, numpy=array([8.521169], dtype=float32)>]

$0.44350433$ $9 \cdot 10 = 90.443504$

मेरा मॉडल यहां पाया जा सकता है और आप इसे ऑनलाइन भी आज़मा सकते हैं ! एक Google Colab वातावरण में।

— स्टीफन मेस्केन
स्रोत

6

2 वजन

$\epsilon>0$

x y \approx \frac{e^{ϵ x + ϵ y} + e^{- ϵ x - ϵ y} - e^{ϵ x - ϵ y} - e^{- ϵ x + ϵ y}}{4 ϵ^{2}} .

$xy \approx \frac{e^{\epsilon x+\epsilon y}+e^{-\epsilon x-\epsilon y}-e^{\epsilon x-\epsilon y}-e^{-\epsilon x+\epsilon y}}{4\epsilon^2}.$

$\epsilon=0.01$

$\{\pm\epsilon,\pm(4\epsilon^2)^{-1}\}$ $\{\pm\epsilon,(4\epsilon^3)^{-1}\}$ $\pm(4\epsilon^2)^{-1}=\pm\epsilon\cdot(4\epsilon^3)^{-1}$ । जैसा कि मैंने ऊपर एक टिप्पणी में उल्लेख किया है, मशीन परिशुद्धता में वजन के साथ प्रत्येक तंत्रिका जाल को केवल दो अलग-अलग भार के साथ एक (विशाल!) तंत्रिका जाल में लगाया जा सकता है। मैंने इस प्रक्रिया को निम्नलिखित MATLAB कोड लिखने के लिए लागू किया है:

function z=approxmultgolfed(x,y)

w1 = 0.1;   % first weight
w2 = -w1;   % second weight

k  = 250000;
v1 = w1*ones(k,1);
v2 = w2*ones(k,1);

L1 = w1*eye(2);
L2 = [ w1 w1; w2 w2; w1 w2; w2 w1 ];
L3 = [ v1 v1 v2 v2 ];
L4 = v1';

z = L4 * L3 * exp( L2 * L1 * [ x; y ] );

$\{\pm0.1\}$

सिर्फ 1 वजन (!) के साथ कैसे दूर हो

$\{\pm0.1\}$ $-0.1$ $0.1$

0.1 x = w^{⊤} w x,

$0.1x = w^\top wx,$

$w$ $10$ $-0.1$ $10.5$

$\{\pm 10^{-k}\}$ $-10^{-k}$

(शायद हमें संशोधित करना चाहिए कि भविष्य में तंत्रिका शुद्ध गोल्फिंग चुनौतियों में वजन का पुन: उपयोग कैसे किया जाता है।)

— डस्टिन जी। मिक्सॉन
स्रोत

मशीन लर्निंग गोल्फ: गुणा

21 13 11 9 वजन

7 वज़न

३३ ३१ वज़न

43 वजन

2 वजन

सिर्फ 1 वजन (!) के साथ कैसे दूर हो