La sfida

Trova la più piccola rete neurale feedforward tale che, dato qualsiasi vettore di input tridimensionale $(a,b,c)$ con voci intere in , la rete emette la radice più grande (cioè "più positiva") della polinomiale con errore strettamente inferiore a .$[-10,10]$$x^3+ax^2+bx+c$$0.1$

ammissibilità

La nozione di ammissibilità nella mia precedente sfida sul golf della rete neurale sembrava un po 'restrittiva, quindi per questa sfida, stiamo usando una definizione più liberale di rete neurale feedforward:

Un neurone è una funzione che è specificata da un vettore di pesi , una tendenza e una funzione di attivazione nel modo seguente:$\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.$$

Una rete neurale feedforward con nodi di input è una funzione di che può essere costruita da una sequenza di neuroni, dove ogni riceve input da e genera un scalare . Dato un determinato set S \ subseteq \ {1, \ ldots, N \} dei nodi di output , l'output della rete neurale è il vettore (x_k) _ {k \ in S} .$\{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}$

Poiché le funzioni di attivazione possono essere regolate per qualsiasi attività, è necessario limitare la classe di funzioni di attivazione per mantenere interessante questa sfida. Sono consentite le seguenti funzioni di attivazione:

• Identità. $f(t)=t$

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

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

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

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

Nel complesso, una rete neurale ammissibile è specificata da nodi di input, una sequenza di neuroni e nodi di output, mentre ogni neurone è specificato da un vettore di pesi, una distorsione e una funzione di attivazione dall'elenco precedente. Ad esempio, la seguente rete neurale è ammissibile, sebbene non soddisfi l'obiettivo prestazionale di questa sfida:

• Nodi di input: $\{1,2\}$

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

• Nodi di output: $\{5,9,10\}$

Questa rete è composta da 8 neuroni, ciascuno con zero pregiudizi e attivazione dell'identità. In parole, questa rete calcola la sequenza di Fibonacci generalizzata generata da e e quindi emette i numeri 5, 9 e 10 da questa sequenza, in quell'ordine.$x_1$$x_2$

punteggio

Dato un numero reale con l'espansione decimale finale, lascia che sia il numero intero non negativo più piccolo per il quale e che sia il numero intero non negativo più piccolo per quale è intero. Quindi diciamo che è la precisione di .$x$$p(x)$$p$$10^{-p}\cdot |x|<1$$q(x)$$q$$10^q \cdot x$$p(x)+q(x)$$x$

Ad esempio, ha una precisione di , mentre ha una precisione di .$x=1.001$$4$$x=0$$0$

Il tuo punteggio è la somma delle precisioni dei pesi e dei pregiudizi nella tua rete neurale.

(Ad esempio, l'esempio sopra ha un punteggio di 16.)

Verifica

Mentre le radici possono essere espresse in termini di formula cubica , la radice più grande è forse più facilmente accessibile con mezzi numerici. Seguendo il suggerimento di @ xnor, ho calcolato la radice più grande per ogni scelta di numeri interi , e i risultati possono essere trovati qui . Ogni riga di questo file di testo è nel modulo . Ad esempio, la prima riga riporta che la radice più grande di è circa .$a,b,c\in[-10,10]$x 3 - 10 x 2 - 10 x - 10 10.99247140445449a,b,c,root$x^3-10x^2-10x-10$$10.99247140445449$

Modifica: il file originale che ho pubblicato conteneva errori nei casi in cui il polinomio presentava una radice multipla. La versione corrente dovrebbe essere priva di tali errori.

14.674.000.667 5.436.050 5.403.448 10.385 5.994 4.447
3.806 di precisione totale

Per una linea di base, ho studiato il seguente approccio: selezionare tale che se campioniamo il polinomio at$M,\delta,\epsilon>0$$p(x)=x^3+ax^2+bx+c$

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

quindi il punto di campionamento più grande soddisfa esiste necessariamente e risiede necessariamente entro dalla radice più grande di . Si può dimostrare che per la nostra raccolta di polinomi, si può prendere , e .$s^\star\in S$$p(s^\star)<\epsilon$$0.1$$p$$M=11$$\delta=0.1$$\epsilon=10^{-4}$

Per progettare una rete neurale che implementa questa logica, si inizia con uno strato di neuroni che il polinomio campione su . Per ogni , prendiamo$S$$s\in S$

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

Successivamente, identifichiamo quali di questi sono inferiori a . Si scopre che per , sostiene che solo se . Pertanto, possiamo usare le attivazioni relu per identificare esattamente i nostri campioni:$\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.$$

Lo implementiamo con alcuni strati di neuroni:

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

A questo punto, abbiamo quando , e altrimenti . Ricordiamo che cerchiamo la più grande per cui . A tal fine, etichettiamo come (per comodità notazionale) e per ogni , definiamo iterativamente$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}.$$

Grazie a questa trasformazione, ogni è un numero intero non negativo e è la unica per la quale . Ora possiamo identificare con un'altra applicazione delle attivazioni relu:$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.$$

In modo esplicito, definiamo i neuroni per

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

Quindi se e altrimenti . Le combiniamo linearmente per produrre il nostro nodo di output:$x_{8,s}=1$$s=s^\star$$x_{8,s}=0$

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

Per il punteggio, ogni strato ha neuroni con diversi livelli di precisione: (1) , (2) , (3) , (4) , (5) , (6) , (7) , (8) , (9). Inoltre, tutti gli strati tranne due hanno neuroni; lo strato 5 ha neuroni e lo strato 9 ha neurone.$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$

Modifica: Miglioramenti: (1) Possiamo campionare il polinomio in modo molto più efficiente usando differenze finite. (2) Possiamo bypassare i livelli da 2 a 4 usando invece un'attivazione sigmoid. (3) I problemi di overflow nello strato 5 possono essere evitati (e gli strati successivi possono essere combinati) applicando più attentamente le attivazioni relu. (4) La somma finale è più economica con la somma per parti .

Quello che segue è il codice MATLAB. Per essere chiari, precè una funzione (che si trova qui ) che calcola la precisione di un vettore di pesi o distorsioni.

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 precisione totale

La comunicazione privata con @ A.Rex ha portato a questa soluzione, in cui costruiamo una rete neurale che memorizza le risposte. L'idea principale è che ogni funzione su un set finito gode della decomposizione$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\}.$$

Come tale, si può costruire un'implementazione di rete neurale di trasformando prima l'input in una funzione indicatore dell'input, e quindi combinando linearmente usando gli output desiderati come pesi. Inoltre, le attivazioni relu rendono possibile questa trasformazione:$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.$$

Ciò che segue è un'implementazione MATLAB di questo approccio. Per essere chiari, roots.txtè il file root pubblicato sopra (trovato qui ) ed precè una funzione (trovata qui ) che calcola la precisione totale di un vettore di pesi o distorsioni.

Modifica 1: Due miglioramenti rispetto all'originale: (1) Ho preso in considerazione alcuni neuroni dai loop for. (2) Ho implementato " integrazione di Lebesgue " nella somma finale combinando prima i termini dello stesso livello impostato. In questo modo, pago per il valore di precisione superiore di un'uscita solo una volta ogni livello impostato. Inoltre, è sicuro arrotondare le uscite al quinto più vicino con il teorema della radice razionale .

Modifica 2: miglioramenti minori aggiuntivi: (1) ho preso in considerazione più neuroni da un ciclo for. (2) Non mi preoccupo di calcolare il termine nella somma finale per cui l'output è già zero.

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