Tantangan

Temukan jaringan neural feedforward terkecil sehingga, diberikan setiap vektor input 3 dimensi $(a,b,c)$ dengan entri integer di $[-10,10]$ , jaringan menghasilkan akar terbesar (yaitu, "paling positif") dari polinomial dengan kesalahan lebih kecil dari .$x^3+ax^2+bx+c$$0.1$

Tidak dapat diterima

Gagasan penerimaan dalam tantangan golf saraf saya sebelumnya tampak agak membatasi, jadi untuk tantangan ini, kami menggunakan definisi yang lebih liberal dari jaringan neural feedforward:

Sebuah neuron adalah fungsi $\nu\colon\mathbf{R}^n\to\mathbf{R}$ yang ditentukan oleh vektor $w\in\mathbf{R}^{n}$ dari bobot , sebuah Bias $b\in\mathbf{R}$ , dan fungsi aktivasi $f\colon\mathbf{R}\to\mathbf{R}$ dengan cara berikut:

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

Jaringan neural feedforward dengan input node $\{1,\ldots,n\}$ adalah fungsi dari $(x_1,\ldots,x_n)\in\mathbf{R}^n$ yang dapat dibangun dari urutan $(\nu_k)_{k=n+1}^N$ neuron, di mana setiap $\nu_k\colon\mathbf{R}^{k-1}\to\mathbf{R}$ mengambil input dari $(x_1,\ldots,x_{k-1})$dan menghasilkan skalar$x_k$ . Mengingat beberapa ditentukan set$S\subseteq\{1,\ldots,N\}$darioutput node, maka output dari jaringan saraf adalah vektor$(x_k)_{k\in S}$ .

Karena fungsi aktivasi dapat disetel untuk setiap tugas yang diberikan, kita perlu membatasi kelas fungsi aktivasi untuk membuat tantangan ini tetap menarik. Fungsi aktivasi berikut diizinkan:

• Identitas. $f(t)=t$

• ReLU. $f(t)=\operatorname{max}(t,0)$

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

• Sigmoid. $f(t)=\frac{e^t}{e^t+1}$

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

Secara keseluruhan, jaring saraf yang dapat diterima ditentukan oleh node input, urutan neuron, dan node output, sementara masing-masing neuron ditentukan oleh vektor bobot, bias, dan fungsi aktivasi dari daftar di atas. Misalnya, jaring saraf berikut ini dapat diterima, meskipun tidak memenuhi tujuan kinerja dari tantangan ini:

• Input node: $\{1,2\}$

• Neuron: $\nu_k(x_1,\ldots,x_{k-1}):=x_{k-2}+x_{k-1}$ untuk $k\in\{3,\ldots,10\}$

• Node keluaran: $\{5,9,10\}$

Jaringan ini terdiri dari 8 neuron, masing-masing dengan nol bias dan aktivasi identitas. Dengan kata lain, jaringan ini menghitung urutan Fibonacci umum yang dihasilkan oleh $x_1$ dan $x_2$ dan kemudian menampilkan angka 5, 9, dan 10 dari urutan ini, dalam urutan itu.

Mencetak gol

Mengingat bilangan real $x$ dengan mengakhiri ekspansi desimal, biarkan $p(x)$ menjadi yang terkecil non-negatif bilangan bulat $p$ yang $10^{-p}\cdot |x|<1$ , dan biarkan $q(x)$ menjadi yang terkecil bilangan bulat positif $q$ yang $10^q \cdot x$ adalah integer. Kemudian kita katakan $p(x)+q(x)$ adalah presisi dari $x$ .

Misalnya, $x=1.001$ memiliki ketepatan $4$ , sedangkan $x=0$ memiliki ketepatan $0$ .

Skor Anda adalah jumlah dari prasyarat bobot dan bias dalam jaringan saraf Anda.

(Misalnya, contoh di atas memiliki skor 16.)

Verifikasi

Meskipun akar dapat diekspresikan dengan rumus kubik , akar terbesar mungkin paling mudah diakses dengan cara numerik. Mengikuti saran xnor, saya menghitung root terbesar untuk setiap pilihan bilangan bulat $a,b,c\in[-10,10]$ , dan hasilnya dapat ditemukan di sini . Setiap baris file teks ini berbentuk a,b,c,root. Sebagai contoh, baris pertama melaporkan bahwa root terbesar $x^3-10x^2-10x-10$ adalah sekitar $10.99247140445449$ .

Sunting: File asli yang saya poskan memiliki kesalahan dalam kasus-kasus di mana polinomial memperlihatkan multi-root. Versi saat ini harus bebas dari kesalahan tersebut.

14674000667 5.436.050 5.403.448 10.385 5994 4447
3806 Total presisi

Untuk baseline, saya menyelidiki pendekatan berikut: Pilih $M,\delta,\epsilon>0$ sehingga jika kita sampel polinomial $p(x)=x^3+ax^2+bx+c$ di

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

maka titik sampel terbesar $s^\star\in S$ memuaskan $p(s^\star)<\epsilon$ tentu ada dan selalu berada dalam $0.1$ dari akar $p$ . Kita dapat menunjukkan bahwa untuk koleksi polinomial kita, kita dapat mengambil $M=11$ , $\delta=0.1$ , dan $\epsilon=10^{-4}$ .

Untuk merancang jaringan saraf yang mengimplementasikan logika ini, kita mulai dengan lapisan neuron bahwa sampel polinomial pada $S$ . Untuk setiap $s\in S$ , kami ambil

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

Selanjutnya, kami mengidentifikasi yang mana yang kurang dari $\epsilon=10^{-4}$ . Ternyata untuk $s\in S$ , ia menyatakan bahwa $p(s)<10^{-4}$ hanya jika $p(s)\leq 0$ . Dengan demikian, kita dapat menggunakan aktivasi relu untuk mengidentifikasi sampel kami dengan tepat:

$$\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.$$

Kami menerapkan ini dengan beberapa lapisan neuron:

$$\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}$$

Pada titik ini, kita memiliki $x_{4,s}=1$ ketika $p(s)<10^{-4}$ , dan sebaliknya $x_{4,s}=0$ . Ingat bahwa kita mencari terbesar $s^\star$ yang $x_{4,s^\star}=1$ . Untuk tujuan ini, kami memberi label $x_{4,M}$ sebagai $x_{5,M}$ (untuk kenyamanan notasi), dan untuk setiap $k\geq 1$, kami mendefinisikan secara iteratif

$$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}.$$

Berkat transformasi ini, setiap $x_{5,s}$ adalah bilangan bulat tidak negatif, dan $s^\star$ adalah $s$ unik yang $x_{5,s}=1$ . Kami sekarang dapat mengidentifikasi $s^\star$ dengan aplikasi lain dari aktivasi relu:

$$\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.$$

Secara eksplisit, kami mendefinisikan neuron dengan

$$\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}$$

Kemudian $x_{8,s}=1$ jika $s=s^\star$ dan sebaliknya $x_{8,s}=0$ . Kami menggabungkan ini secara linear untuk menghasilkan simpul keluaran kami:

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

Untuk skor, setiap lapisan memiliki neuron dengan tingkat presisi berbeda: (1) $6+3+1+9=19$ , (2) $1+4=5$ , (3) $1$ , (4) $5+5=10$ , (5) $1+1=2$ , (6) $1+1=2$ , (7) $1+1=2$ , (8) $1+1+1=3$ , (9) $3|S|$. Selanjutnya, semua kecuali dua lapisan memiliki$|S|=221$ neuron; layer 5 memiliki$|S|-1$ neuron dan layer 9 memiliki$1$ neuron.

Sunting: Perbaikan: (1) Kami dapat mengambil sampel polinomial dengan lebih efisien menggunakan perbedaan hingga. (2) Kita dapat memotong lapisan 2 hingga 4 dengan menggunakan aktivasi sigmoid. (3) Masalah kelebihan pada lapisan 5 dapat dihindari (dan lapisan berikutnya dapat digabungkan) dengan lebih hati-hati menerapkan aktivasi relu. (4) Jumlah akhir lebih murah dengan penjumlahan per bagian .

Berikut ini adalah kode MATLAB. Agar jelas, precadalah fungsi (ditemukan di sini ) yang menghitung ketepatan vektor bobot atau bias.

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

53.268 29.596 29.306 total presisi

Komunikasi pribadi dengan @ A.Rex mengarah ke solusi ini, di mana kami membangun jaringan saraf yang mengingat jawaban. Gagasan intinya adalah bahwa setiap fungsi $f\colon S\to\mathbf{R}$ pada himpunan terbatas $S$ menikmati dekomposisi

$$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.$$

Berikut ini adalah implementasi MATLAB dari pendekatan ini. Yang jelas, roots.txtadalah file root yang diposting di atas (ditemukan di sini ), dan precmerupakan fungsi (ditemukan di sini ) yang menghitung presisi total dari vektor bobot atau bias.

Sunting 1: Dua peningkatan dibandingkan yang asli: (1) Saya memfaktorkan beberapa neuron untuk loop. (2) Saya menerapkan " integrasi Lebesgue " dalam jumlah akhir dengan terlebih dahulu menggabungkan istilah dari set level yang sama. Dengan cara ini, saya membayar nilai presisi yang lebih tinggi dari suatu output hanya sekali setiap level yang ditetapkan. Juga, aman untuk membulatkan output ke kelima terdekat dengan teorema akar rasional .

Sunting 2: Tambahan kecil tambahan: (1) Saya memfaktorkan lebih banyak neuron dari perulangan for. (2) Saya tidak repot menghitung istilah dalam jumlah akhir yang hasilnya sudah nol.

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