Tôi muốn đề xuất một loại thử thách chơi gôn khác cho cộng đồng này:

(Nhân tạo) Mạng nơ-ron là mô hình học máy rất phổ biến có thể được thiết kế và đào tạo để xấp xỉ bất kỳ chức năng nào (thường không biết). Chúng thường được sử dụng để giải quyết các vấn đề rất phức tạp mà chúng ta không biết cách giải quyết bằng thuật toán như nhận dạng giọng nói, một số loại phân loại hình ảnh, các tác vụ khác nhau trong các hệ thống lái xe tự trị, ... Đối với một mạng lưới thần kinh, hãy xem xét điều này tuyệt vời Wikipedia bài viết .

Vì đây là lần đầu tiên trong những gì tôi hy vọng sẽ là một loạt các thử thách chơi gôn máy, tôi muốn giữ mọi thứ đơn giản nhất có thể:

Trong ngôn ngữ và khung bạn chọn, thiết kế và huấn luyện một mạng nơ ron, được đưa ra $(x_1, x_2)$ tính sản phẩm của họ $x_1 \cdot x_2$ cho tất cả các số nguyên $x_1, x_2$ giữa (và bao gồm) $-10$ và $10$ .

Mục tiêu hoạt động

Để đủ điều kiện, mô hình của bạn không được sai lệch quá $0.5$ so với kết quả chính xác trên bất kỳ mục nào trong số đó.

Quy tắc

Mô hình của bạn

• phải là mạng thần kinh 'truyền thống' (giá trị của một nút được tính như một tổ hợp tuyến tính có trọng số của một số nút trong lớp trước theo sau là hàm kích hoạt),
• chỉ có thể sử dụng các chức năng kích hoạt tiêu chuẩn sau:
  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$
• phải lấy $(x_1, x_2)$ làm tupel / vector / list / ... của số nguyên hoặc số float làm đầu vào duy nhất của nó,
• trả về câu trả lời dưới dạng một số nguyên, float (hoặc một thùng chứa phù hợp, ví dụ như một vectơ hoặc danh sách, có chứa câu trả lời này).

Câu trả lời của bạn phải bao gồm (hoặc liên kết đến) tất cả các mã cần thiết để kiểm tra kết quả của bạn - bao gồm các trọng số được đào tạo của mô hình của bạn.

Chấm điểm

Mạng thần kinh có số lượng trọng lượng nhỏ nhất (bao gồm cả trọng số sai lệch) sẽ thắng.

Thưởng thức!

21 13 11 9 trọng lượng

Điều này dựa trên danh tính phân cực của các dạng song tuyến mà trong trường hợp thực một chiều làm giảm nhận dạng đa thức:

Vì vậy, y1chỉ cần tính toán [x+y, x-y]bằng cách sử dụng một phép biến đổi tuyến tính và y3chỉ là giá trị tuyệt đối của y1bước tiền xử lý cho bước tiếp theo: Sau đó, phần "cứng" là tính toán các hình vuông mà tôi sẽ giải thích bên dưới, và sau đó chỉ tính toán một sự khác biệt và chia tỷ lệ lại là một hoạt động tuyến tính.

$s$$\{0,1,2,\ldots,20\}$$0.5$

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

Hãy thử trực tuyến!

7 trọng lượng

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

Hãy thử trực tuyến!

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

$\epsilon$epsc

33 31 trọng lượng

# 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";

Hãy thử trực tuyến!

Điều này không nhân dài trong nhị phân (sorta), và do đó trả về kết quả chính xác. Có thể tận dụng cửa sổ lỗi 0,5 để chơi golf thêm một số điều này, nhưng tôi không biết làm thế nào.

Các lớp 1 đến 6 phân tách đầu vào đầu tiên trong 5 "bit". Vì lý do chơi gôn, chúng tôi không sử dụng nhị phân thực tế. "Bit" đáng kể nhất có trọng số -15 thay vì 16 và khi đầu vào bằng 0, tất cả các "bit" là 0,5 (vẫn hoạt động tốt, vì nó giữ nguyên danh tính inputA = -15*a15 + 8*a8 + 4*a4 + 2*a2 + 1*a1).

43 trọng lượng

Hai giải pháp được đăng cho đến nay rất thông minh nhưng cách tiếp cận của chúng có thể sẽ không hiệu quả đối với các tác vụ truyền thống hơn trong học máy (như OCR). Do đó, tôi muốn gửi một giải pháp 'chung chung' (không có thủ thuật thông minh) cho nhiệm vụ này, hy vọng sẽ truyền cảm hứng cho những người khác để cải thiện nó và bị cuốn vào thế giới của máy học:

Mô hình của tôi là một mạng thần kinh rất đơn giản với 2 lớp ẩn được xây dựng trong TensorFlow 2.0 (nhưng bất kỳ khung nào khác cũng sẽ hoạt động tốt):

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')
])

Như bạn có thể thấy, tất cả các lớp đều dày đặc (điều chắc chắn là không tối ưu), chức năng kích hoạt là tanh (có thể thực sự ổn cho nhiệm vụ này), ngoại trừ lớp đầu ra, do tính chất của nhiệm vụ này, có chức năng kích hoạt tuyến tính.

Có 43 trọng lượng:

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

$-10$$10$

Tiếp theo, tôi đã tinh chỉnh chúng - tối ưu hóa cho độ lệch tối đa trên bất kỳ tác vụ nhân số nguyên nào. Thật không may, các ghi chú của tôi không hiển thị nhiều tinh chỉnh tôi đã kết thúc, nhưng nó rất nhỏ. Trong vùng lân cận 100 epoch trên 441 mẫu đào tạo đó, với cỡ lô là 441.

Đây là những trọng lượng tôi đã kết thúc với:

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

Mô hình của tôi có thể được tìm thấy ở đây và bạn cũng có thể dùng thử trực tuyến! trong môi trường Google Colab.

2 trọng lượng

$\epsilon>0$

$\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}$. Như tôi đã đề cập trong một nhận xét ở trên, mọi mạng lưới thần kinh có trọng lượng chính xác của máy có thể được đánh vào một mạng lưới thần kinh (rất lớn!) Chỉ với hai trọng số riêng biệt. Tôi đã áp dụng quy trình này để viết mã MATLAB sau:

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

Làm thế nào để thoát khỏi chỉ với 1 trọng lượng (!)

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

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

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

(Có lẽ chúng ta nên sửa đổi cách ghi lại trọng lượng được sử dụng trong các thử thách chơi gôn thần kinh trong tương lai.)