도전

임의의 3 차원 입력 벡터 주어진 그에 따라, 작은 피드 포워드 신경망 찾기 $(a,b,c)$ 에서 정수 항목과를 $[-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.$$

입력 노드 $\{1,\ldots,n\}$ 이있는 피드 포워드 신경망은 뉴런 의 시퀀스 ( ν k ) N k = n + 1 에서 생성 될 수있는 $(x_1,\ldots,x_n)\in\mathbf{R}^n$ 의 함수입니다 . 여기서 각 ν k : R k - 1 → R 은 ( x 1 , … , x$(\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)$

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

• 정현파. $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)$ 는 IS정밀의$x$ .

예를 들어, $x=1.001$ 의 정밀도는 $4$ 이고 $x=0$ 의 정밀도는 $0$ 입니다.

당신의 점수는 신경 네트워크에서 가중치와 바이어스의 정밀도의 합계입니다.

(예를 들어, 위 예제의 점수는 16입니다.)

확인

뿌리는 입방 공식 으로 표현할 수 있지만 가장 큰 뿌리는 아마도 숫자로 가장 쉽게 접근 할 수 있습니다. XNOR의 제안 @ 다음, 나는 정수의 모든 선택에 대한 가장 큰 루트를 계산 , B , C ∈ [ - 10 , 10 ] , 그리고 결과는 여기에서 찾을 수 있습니다 . 이 텍스트 파일의 각 줄은 형식 입니다. 예를 들어, 가장 큰 루트 첫 번째 줄의 보고서 것을 X 3 - 10 X 2 - 10 X - 10은 약 10.99247140445449 .$a,b,c\in[-10,10]$a,b,c,root$x^3-10x^2-10x-10$$10.99247140445449$

편집 : 다항식이 다중 루트를 나타내는 경우 게시 한 원본 파일에 오류가 발생했습니다. 현재 버전에는 이러한 오류가 없어야합니다.

14,674,000,667 5,436,050 5,403,448 10,385 5,994 4,447
3,806 총 정밀도

기준선에 대해 다음 접근법을 조사했습니다 . 다항식 p ( x )를 샘플링하면 $M,\delta,\epsilon>0$ 선택하십시오.$p(x)=x^3+ax^2+bx+c$ 를.

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

p ( s ⋆ ) < ϵ를 만족 하는 가장 큰 샘플 포인트 $s^\star\in S$ 반드시 존재하며 반드시 p 의 가장 큰 루트의 0.1 내에 있어야합니다 . 우리는 다항식 모음에 대해 M = 11을 취할 수 있음을 보여줄 수 있습니다.$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$ . 따라서 relu 활성화를 사용하여 샘플을 정확하게 식별 할 수 있습니다.

$$\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$ . x 4 , s ⋆ = 1 에서 가장 큰 $s^\star$ 를 찾습니다 . 이를 위해 우리는 x 4 , M 을 x 5 , M (표기법 편의상)으로 그리고 각 k ≥ 1 로 레이블을 붙입니다.$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$ 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.$$

명시 적으로 우리는 뉴런을

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

점수의 경우, 각 레이어에는 (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|$. 또한 두 층을 제외한 모든 층에는$|S|=221$ 뉴런; 층 5는$|S|-1$ 뉴런과 9 층에는$1$ 뉴런이 있습니다.

편집 : 개선 사항 : (1) 유한 차분을 사용하여 다항식을 훨씬 효율적으로 샘플링 할 수 있습니다. (2) 대신 시그 모이 드 활성화를 사용하여 레이어 2 ~ 4를 우회 할 수 있습니다. (3) relu 활성화를보다 신중하게 적용하여 레이어 5의 오버플로 문제를 피할 수 있습니다 (그리고 후속 레이어를 결합 할 수 있음). (4) 최종 합계는 부품 별 합계로 저렴 합니다.

다음은 MATLAB 코드입니다. 명확하게하기 위해 가중치 또는 바이어스 벡터의 정밀도를 계산 prec하는 함수 ( here )가 있습니다.

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 총 정밀도

@ A.Rex와의 개인 커뮤니케이션은이 솔루션으로 이어졌으며,이를 통해 답을 기억하는 신경망을 구성합니다. 핵심 아이디어는 유한 집합 S에 대한 모든 함수 $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.$$

What follows is a MATLAB implementation of this approach. To be clear, roots.txt is the roots file posted above (found here), and prec is a function (found here) that computes the total precision of a vector of weights or biases.

Edit 1: Two improvements over the original: (1) I factored some neurons out of the for loops. (2) I implemented "Lebesgue integration" in the final sum by first combining terms from the same level set. This way, I pay for the higher-precision value of an output only once every level set. Also, it is safe to round outputs to the nearest fifth by the rational root theorem.

Edit 2: Additional minor improvements: (1) I factored more neurons out of a for loop. (2) I don't bother computing the term in the final sum for which the output is already 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