Я хотел бы предложить другой вид игры в гольф для этого сообщества:

(Искусственные) нейронные сети являются очень популярными моделями машинного обучения, которые могут быть разработаны и обучены для приближения к любой заданной (обычно неизвестной) функции. Они часто используются для решения очень сложных задач, которые мы не знаем, как решать алгоритмически, такие как распознавание речи, определенные виды классификации изображений, различные задачи в автономных системах вождения, ... Для начинающих в нейронных сетях посчитайте это превосходным Статья в Википедии .

Поскольку это первая из серии задач по гольф-обучению в области машинного обучения, я хотел бы сделать все как можно проще:

На языке и структуре по вашему выбору спроектируйте и обучите нейронную сеть, которая с учетом вычисляет их произведение для всех целых чисел между (и включая) и .$(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)$
• вернуть ответ в виде целого числа, числа с плавающей запятой (или подходящего контейнера, например, вектора или списка, который содержит этот ответ).

Ваш ответ должен включать (или ссылку на) весь код, необходимый для проверки ваших результатов, в том числе обученные веса вашей модели.

счет

Нейронная сеть с наименьшим количеством весов (включая веса смещения) выигрывает.

Наслаждайтесь!

21 13 11 9 весов

Это основано на поляризационной идентичности билинейных форм, которая в одномерном реальном случае сводится к полиномиальной идентичности:

Так y1что просто вычисляет [x+y, x-y]с использованием линейного преобразования, и y3это просто абсолютное значение y1в качестве шага предварительной обработки для следующего: затем «трудная» часть вычисляет квадраты, которые я объясню ниже, а после этого просто вычисляя разницу и масштабирование, которое снова линейная операция.

Для вычисления квадратов я использую экспоненциальный ряд который должен быть точным для всех целых чисел пределах примерно . Эта серия имеет вид$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

Попробуйте онлайн!

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

Достаточно маленький выбор позволяет нам выйти за границы допустимых ошибок. Обратите внимание, что и являются постоянными весами в коде.$\epsilon$epsc

33 31 весов

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

Попробуйте онлайн!

Это делает длинное умножение в (sorta) двоичном и, таким образом, возвращает точный результат. Должна быть возможность воспользоваться окном ошибок 0,5 для игры в гольф, но я не уверен, как это сделать.

Слои с 1 по 6 разбивают первый вход на 5 «битов». По причинам, связанным с игрой в гольф, мы не используем настоящий бинарный файл. Наиболее значимый «бит» имеет вес -15 вместо 16, а когда входное значение равно 0, все «биты» равны 0,5 (что все еще отлично работает, поскольку сохраняет идентичность inputA = -15*a15 + 8*a8 + 4*a4 + 2*a2 + 1*a1).

43 веса

Два решения, опубликованные до сих пор, были очень умными, но их подходы, вероятно, не будут работать для более традиционных задач в машинном обучении (таких как OCR). Поэтому я хотел бы представить «общее» (без хитрых уловок) решение этой задачи, которое, мы надеемся, вдохновит других людей улучшить ее и погрузиться в мир машинного обучения:

Моя модель представляет собой очень простую нейронную сеть с 2 скрытыми слоями, встроенными в TensorFlow 2.0 (но любой другой фреймворк также подойдет):

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

Как вы можете видеть, все слои плотные (что, безусловно, не оптимально), функция активации - tanh (что на самом деле хорошо для этой задачи), за исключением выходного слоя, который, в силу характера этой задачи, имеет линейную функцию активации.

Есть 43 веса:

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

$-10$$10$

Затем я настроил их - оптимизировал максимальное отклонение для любой задачи целочисленного умножения. К сожалению, мои заметки не показывают особой настройки, которую я закончил, но это было очень незначительно. В окрестностях 100 эпох на тех 441 обучающих выборках, с размером партии 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.

2 веса

$\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}$, Как я упоминал в комментарии выше, каждая нейронная сеть с весами в точности станка может быть привязана к (огромной!) Нейронной сети только с двумя различными весами. Я применил эту процедуру, чтобы написать следующий код 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$

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

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

(Возможно, мы должны изменить то, как повторно используемые веса будут оцениваться в будущих задачах игры в нейронную сеть.)