python - Keras:制作一个神经网络来找到一个数字的模数

Question

我是一名经验丰富的 Python 开发人员，但在机器学习方面完全是新手。这是我第一次尝试使用 Keras。你能告诉我我做错了什么吗？

我正在尝试制作一个神经网络，它采用二进制形式的数字，并在除以 7 时输出其模数。(我的目标是执行一个非常简单的任务，只是为了看看一切正常。)

在下面的代码中，我定义了网络并用 10,000 个随机数训练它。然后我在 500 个随机数上测试它。

出于某种原因，我得到的准确度约为 1/7，这是您对完全随机算法所期望的准确度，即我的神经网络没有做任何事情。

谁能帮我弄清楚出了什么问题？

import keras.models
import numpy as np
from python_toolbox import random_tools

RADIX = 7

def _get_number(vector):
    return sum(x * 2 ** i for i, x in enumerate(vector))

def _get_mod_result(vector):
    return _get_number(vector) % RADIX

def _number_to_vector(number):
    binary_string = bin(number)[2:]
    if len(binary_string) > 20:
        raise NotImplementedError
    bits = (((0,) * (20 - len(binary_string))) +
            tuple(map(int, binary_string)))[::-1]
    assert len(bits) == 20
    return np.c_[bits]


def get_mod_result_vector(vector):
    return _number_to_vector(_get_mod_result(vector))


def main():
    model = keras.models.Sequential(
        (
            keras.layers.Dense(
                units=20, activation='relu', input_dim=20
            ),
            keras.layers.Dense(
                units=20, activation='relu'
            ),
            keras.layers.Dense(
                units=20, activation='softmax'
            )
        )
    )
    model.compile(optimizer='sgd',
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])

    data = np.random.randint(2, size=(10000, 20))
    labels = np.vstack(map(get_mod_result_vector, data))

    model.fit(data, labels, epochs=10, batch_size=50)
    def predict(number):
        foo = model.predict(_number_to_vector(number))
        return _get_number(tuple(map(round, foo[0])))
    def is_correct_for_number(x):
        return bool(predict(x) == x % RADIX)
    predict(7)
    sample = random_tools.shuffled(range(2 ** 20))[:500]
    print('Total accuracy:')
    print(sum(map(is_correct_for_number, sample)) / len(sample))
    print(f'(Accuracy of random algorithm is {1/RADIX:.2f}')


if __name__ == '__main__':
    main()

Answer 1

UPD

经过一些修补，我能够使用 RNN 找到一个相当不错的解决方案。它对不到 5% 的所有可能的唯一输入进行训练，并在随机测试样本上提供 >90% 的准确度。您可以将批次数从 40 增加到 100 以使其更准确(尽管在某些运行中，模型有可能无法收敛到正确的答案 - 这里比通常情况下更高)。我在这里改用 Adam 优化器，不得不将样本数量增加到 50K(10K 导致我过度拟合)。

请理解这个解决方案有点诙谐，因为它基于任务域知识，即我们的目标函数可以通过输入位序列上的简单循环公式来定义(甚至更简单的公式，如果您反转了输入位序列，但在 LSTM 中使用 go_backwards=True 在这里没有帮助)。

如果您反转输入位顺序(以便我们始终从最高有效位开始)，那么目标函数的循环公式就是 F_n = G(F_{n-1}, x_n) ，其中 F_n = MOD([x_1,...,x_n], 7) , 和 G(x, y) = MOD(2*x+y, 7) - 只有 49 个不同的输入和 7 个可能的输出。所以模型必须学习初始状态+这个G更新功能。对于从最低有效位开始的序列，循环公式稍微复杂一些，因为它还需要跟踪当前的内容 MOD(2**n, 7)在每一步，但似乎这个难度对训练来说并不重要。

请注意 - 这些公式仅用于解释 RNN 在这里工作的原因。下面的网络只是一个普通的 LSTM 层 + softmax，原始输入的比特被视为一个序列。

使用 RNN 层的答案的完整代码:

import keras.models
import numpy as np
from python_toolbox import random_tools

RADIX = 7
FEATURE_BITS = 20

def _get_number(vector):
    return sum(x * 2 ** i for i, x in enumerate(vector))

def _get_mod_result(vector):
    return _get_number(vector) % RADIX

def _number_to_vector(number):
    binary_string = bin(number)[2:]
    if len(binary_string) > FEATURE_BITS:
        raise NotImplementedError
    bits = (((0,) * (FEATURE_BITS - len(binary_string))) +
            tuple(map(int, binary_string)))[::-1]
    assert len(bits) == FEATURE_BITS
    return np.c_[bits]


def get_mod_result_vector(vector):
    v = np.repeat(0, 7)
    v[_get_mod_result(vector)] = 1
    return v


def main():
    model = keras.models.Sequential(
        (
            keras.layers.Reshape(
                (1, -1)
            ),
            keras.layers.LSTM(
                units=100,
            ),
            keras.layers.Dense(
                units=7, activation='softmax'
            )
        )
    )
    model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.01),
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])

    data = np.random.randint(2, size=(50000, FEATURE_BITS))
    labels = np.vstack(map(get_mod_result_vector, data))

    model.fit(data, labels, epochs=40, batch_size=50)
    def predict(number):
        foo = model.predict(_number_to_vector(number))
        return np.argmax(foo)
    def is_correct_for_number(x):
        return bool(predict(x) == x % RADIX)
    sample = random_tools.shuffled(range(2 ** FEATURE_BITS))[:500]
    print('Total accuracy:')
    print(sum(map(is_correct_for_number, sample)) / len(sample))
    print(f'(Accuracy of random algorithm is {1/RADIX:.2f}')


if __name__ == '__main__':
    main()

原答案

我不确定它是如何发生的，但是您选择检查代码的特定任务对于 NN 来说是极其困难的。我认为最好的解释是，当特征以改变一个特征总是完全改变目标输出值的方式相互连接时，神经网络并不是真的很好。一种看待它的方法是在您期望得到某个答案时查看特征集 - 在您的情况下，它们看起来像是 20 维空间中大量平行超平面的联合 - 对于 7 个类别中的每一个，这些集的飞机被“很好地”交错并留给 NN 区分。

也就是说-如果您的示例数量很大，例如 10K，并且可能的输入数量较小，则说您的输入位数只有 8 位大(因此只能有 256 个唯一输入)- 网络应该可以“学习”正确的功能(通过“记住”每个输入的正确答案，没有概括)。在您的情况下，这不会发生，因为代码有以下错误。

您的标签是 20 维向量，其中包含 0-6 位整数(您实际所需的标签)-所以我猜您几乎是在尝试教 NN 将答案作为单独的分类器学习(只有 3 位可能是非零)。我把它改成了我假设你真正想要的 - 长度为 7 的向量，只有一个值为 1，其他值为 0(所谓的一种热编码，根据 this，keras 实际上期望 categorical_crossentropy)。如果你想分别学习每一位，你绝对不应该在最后一层使用 softmax 20，因为这样的输出会在 20 个类别上生成总和为 1 的概率(在这种情况下，你应该训练 20-or-rather -3 二进制分类器)。由于您的代码没有给 keras 正确的输入，因此您最终得到的模型有点随机，并且您应用的舍入旨在为 95%-100% 的输入输出相同的值。

下面稍微更改的代码训练了一个模型，该模型可以或多或少地正确猜测每个数字 0 到 255 的 mod 7 答案(同样，几乎记住了每个输入的正确答案)。如果你尝试增加 FEATURE_BITS你会看到结果的大幅下降。如果您真的想训练 NN 以 20 位或更多位的输入(并且不为 NN 提供所有可能的输入和无限的训练时间)来学习此任务，您将需要应用一些特定于任务的特征转换和/或一些精心设计的图层完全适合您想要完成的任务，正如其他人在对您的问题的评论中已经提到的那样。

import keras.models
import numpy as np
from python_toolbox import random_tools

RADIX = 7
FEATURE_BITS = 8

def _get_number(vector):
    return sum(x * 2 ** i for i, x in enumerate(vector))

def _get_mod_result(vector):
    return _get_number(vector) % RADIX

def _number_to_vector(number):
    binary_string = bin(number)[2:]
    if len(binary_string) > FEATURE_BITS:
        raise NotImplementedError
    bits = (((0,) * (FEATURE_BITS - len(binary_string))) +
            tuple(map(int, binary_string)))[::-1]
    assert len(bits) == FEATURE_BITS
    return np.c_[bits]


def get_mod_result_vector(vector):
    v = np.repeat(0, 7)
    v[_get_mod_result(vector)] = 1
    return v


def main():
    model = keras.models.Sequential(
        (
            keras.layers.Dense(
                units=20, activation='relu', input_dim=FEATURE_BITS
            ),
            keras.layers.Dense(
                units=20, activation='relu'
            ),
            keras.layers.Dense(
                units=7, activation='softmax'
            )
        )
    )
    model.compile(optimizer='sgd',
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])

    data = np.random.randint(2, size=(10000, FEATURE_BITS))
    labels = np.vstack(map(get_mod_result_vector, data))

    model.fit(data, labels, epochs=100, batch_size=50)
    def predict(number):
        foo = model.predict(_number_to_vector(number))
        return np.argmax(foo)
    def is_correct_for_number(x):
        return bool(predict(x) == x % RADIX)
    sample = random_tools.shuffled(range(2 ** FEATURE_BITS))[:500]
    print('Total accuracy:')
    print(sum(map(is_correct_for_number, sample)) / len(sample))
    print(f'(Accuracy of random algorithm is {1/RADIX:.2f}')


if __name__ == '__main__':
    main()