python - FizzBu​​zz 神经网络

Question

逼近 FizzBu​​zz

我正在尝试近似臭名昭著的 FizzBu​​zz 函数:

def fizzbuzz(start, end):
    a = list()
    for i in range(start, end + 1):
        a.append(fb(i))
    return a


def fb(i):
    if i % 3 == 0 and i % 5 == 0:
        return "FizzBuzz"
    elif i % 3 == 0:
        return "Fizz"
    elif i % 5 == 0:
        return "Buzz"
    else:
        return i

问题是，在训练之后，对于 1 到 100 之间的所有值，我只得到数字作为输出:

[  1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18
  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36
  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54
  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71  72
  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90
  91  92  93  94  95  96  97  98  99 100]

正确的输出应该是:

['1' '2' 'Fizz' '4' 'Buzz' 'Fizz' '7' '8' 'Fizz' 'Buzz' '11' 'Fizz' '13'
 '14' 'FizzBuzz' '16' '17' 'Fizz' '19' 'Buzz' 'Fizz' '22' '23' 'Fizz'
 'Buzz' '26' 'Fizz' '28' '29' 'FizzBuzz' '31' '32' 'Fizz' '34' 'Buzz'
 'Fizz' '37' '38' 'Fizz' 'Buzz' '41' 'Fizz' '43' '44' 'FizzBuzz' '46' '47'
 'Fizz' '49' 'Buzz' 'Fizz' '52' '53' 'Fizz' 'Buzz' '56' 'Fizz' '58' '59'
 'FizzBuzz' '61' '62' 'Fizz' '64' 'Buzz' 'Fizz' '67' '68' 'Fizz' 'Buzz'
 '71' 'Fizz' '73' '74' 'FizzBuzz' '76' '77' 'Fizz' '79' 'Buzz' 'Fizz' '82'
 '83' 'Fizz' 'Buzz' '86' 'Fizz' '88' '89' 'FizzBuzz' '91' '92' 'Fizz' '94'
 'Buzz' 'Fizz' '97' '98' 'Fizz' 'Buzz']

我的神经网络将每个数字分为四类之一:

0. "Fizz"
1. "Buzz"
2. "FizzBuzz"
3. None of the above

我认为我的神经网络正在学习将每个数字归类到最常被标记为正确类别的类别(即#3:以上都不是)，我不知道如何解决这个问题。

准备数据

我将 X(输入)值编码为 16 位二进制:

def binary_encode_16b_array(a):
    encoded_a = list()
    for elem in a:
        encoded_a.append(binary_encode_16b(elem))
    return np.array(encoded_a)


def binary_encode_16b(val):
    bin_arr = list()
    bin_str = format(val, '016b')
    for bit in bin_str:
        bin_arr.append(bit)
    return np.array(bin_arr)

并将 Y(输出)值编码为单热向量:

def one_hot_encode_array(a):
    encoded_a = list()
    for elem in a:
        encoded_a.append(one_hot_encode(elem))
    return np.array(encoded_a)


def one_hot_encode(val):
    if val == 'Fizz':
        return np.array([1, 0, 0, 0])
    elif val == 'Buzz':
        return np.array([0, 1, 0, 0])
    elif val == 'FizzBuzz':
        return np.array([0, 0, 1, 0])
    else:
        return np.array([0, 0, 0, 1])

这会将 16 位二进制输入数据归类为 FizzBu​​zz 规则指定的 4 个可能类别之一。

例如，如果返回 [ 0.03 -0.4 -0.4 0.4]，则程序知道不打印任何“Fizz”、“Buzz”或“FizzBu​​zz”:

# decoding values of Y
def one_hot_decode_array(x, y):
    decoded_a = list()
    for index, elem in enumerate(y):
        decoded_a.append(one_hot_decode(x[index], elem))
    return np.array(decoded_a)


def one_hot_decode(x, val):
    index = np.argmax(val)
    if index == 0:
        return 'Fizz'
    elif index == 1:
        return 'Buzz'
    elif index == 2:
        return 'FizzBuzz'
    elif index == 3:
        return x

初始化数据

这就是我划分训练和测试数据的方式:

# train with data that will not be tested
test_x_start = 1
test_x_end = 100
train_x_start = 101
train_x_end = 10000

test_x_raw = np.arange(test_x_start, test_x_end + 1)
test_x = binary_encode_16b_array(test_x_raw).reshape([-1, 16])
test_y_raw = fizzbuzz(test_x_start, test_x_end)
test_y = one_hot_encode_array(test_y_raw)

train_x_raw = np.arange(train_x_start, train_x_end + 1)
train_x = binary_encode_16b_array(train_x_raw).reshape([-1, 16])
train_y_raw = fizzbuzz(train_x_start, train_x_end)
train_y = one_hot_encode_array(train_y_raw)

因此模型使用 101 到 10000 之间的值进行训练，并使用 1 到 100 之间的值进行测试。

神经网络模型

我的模型架构很简单，一层有 100 个隐藏神经元:

# define params
input_dim = 16
output_dim = 4
h1_dim = 100

# build graph
X = tf.placeholder(tf.float32, [None, input_dim])
Y = tf.placeholder(tf.float32, [None, output_dim])

h1_w = tf.Variable(tf.zeros([input_dim, h1_dim]))
h1_b = tf.Variable(tf.zeros([h1_dim]))
h1_z = tf.nn.relu(tf.matmul(X, h1_w) + h1_b)

fc_w = tf.Variable(tf.zeros([h1_dim, output_dim]))
fc_b = tf.Variable(tf.zeros([output_dim]))
Z = tf.matmul(h1_z, fc_w) + fc_b

# define cost
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=Z))

# define op
train_step = tf.train.AdamOptimizer(0.005).minimize(cross_entropy)

# define accuracy
correct_prediction = tf.equal(tf.argmax(Z, 1), tf.argmax(Y, 1))
correct_prediction = tf.cast(correct_prediction, tf.float32)
accuracy = tf.reduce_mean(correct_prediction)

运行模型

为了简单起见，我选择省略批量训练:

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())

    for i in range(1000):
        sess.run(train_step, feed_dict={X: train_x, Y: train_y})

        train_accuracy = sess.run(accuracy, feed_dict={X: train_x, Y: train_y})
        print(i, ":", train_accuracy)

    output = sess.run(Z, feed_dict={X: test_x})
    decoded = one_hot_decode_array(test_x_raw, output)
    print(decoded)

在训练期间，准确度值未能超过 0.533333。网络被训练为仅输出每个规则的数字 !(i%3==0 || i%5==0) ? i，这是 FizzBu​​zz 函数最常见的答案。

编辑:已解决

使用下面@Blender 提供的解决方案，我将隐藏层和输出层的初始值设定项更改为均匀随机。增加迭代次数并降低 AdamOptimizer 的学习率，我的模型现在可以在测试数据集上完美运行。我已经上传了工作模型的源代码 in a GitHub repository .

Answer 1

将网络中的所有初始权重设置为相同的值(零)会抵消在一个层中具有多个神经元的任何好处。随机初始化权重是必要的:

h1_w = tf.Variable(tf.random_normal([input_dim, h1_dim], stddev=0.1))

对我而言，准确度仅在大约 200 次迭代后才开始变化，但在 1,000 次迭代后，测试集的准确度为 0.99。我有点惊讶这甚至只适用于一个隐藏层。