Ram*_*hum 8 python machine-learning neural-network keras tensorflow
我是一名经验丰富的 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()
这实现了 99.74% 的准确率和 99.69% 的验证准确率。
import tensorflow as tf, numpy as np
def int2bits(i,fill=20):
return list(map(int,bin(i)[2:].zfill(fill)))
def bits2int(b):
return sum(i*2**n for n,i in enumerate(reversed(b)))
# Data.
I = np.random.randint(0,2**20,size=(250_000,))
X = np.array(list(map(int2bits,I)))
Y = np.array([int2bits(2**i,7) for i in I % 7])
# Test Data.
It = np.random.randint(0,2**20,size=(10_000,))
Xt = np.array(list(map(int2bits,It)))
Yt = np.array([int2bits(2**i,7) for i in It % 7])
# Model.
model = tf.keras.models.Sequential([
tf.keras.layers.Dense(1000,'relu'),
tf.keras.layers.Dense(7,'softmax'),
])
model.compile('adam','categorical_crossentropy',['accuracy'])
# Train.
model.fit(X,Y,10_000,100,validation_data=(Xt,Yt))
一些外卖：
1）你的数据太少了。您从 0 到 2**20 统一采样点，但只采样了 10,000，这仅是模型假设学习的可能向量的 1% 左右。关键是很多组件（在二进制表示中）大多固定为零或一，而没有机会了解它们在整体数据中的功能或它们如何与其他组件交互。
2）你需要一个嵌入层，即将空间扩展到一些更大的更高维度，这样神经元可以更容易地移动。这允许学习更好地洗牌，希望找到您正在寻找的算法。单个 Dense(1000) 似乎有效。
3) 批量运行 10_000（只是为了最大化我的 CPU 使用率）。跑了 100 个 epoch。在训练中包含我的 validation_data 以便我可以看到验证集在每个时期的表现（包括这不会影响训练，只是在训练时更容易查看模型是否表现良好）。
谢谢。:-)
UPD
经过一番修改后，我能够使用 RNN 找到一个相当好的解决方案。它对所有可能的唯一输入中不到 5% 的数据进行训练，并对随机测试样本给出 >90% 的准确率。您可以将批次数从 40 增加到 100，以使其更加准确（尽管在某些运行中，模型有可能不会收敛到正确的答案 - 这里它比通常要高）。我在这里改用 Adam 优化器，并且必须将样本数量增加到 50K（10K 导致我过度拟合）。
请理解，这个解决方案有点开玩笑，因为它基于任务域知识，我们的目标函数可以通过输入位序列的简单循环公式来定义（甚至更简单的公式，如果您反转了输入位序列，但go_backwards=True在 LSTM 中使用在这里没有帮助）。
如果反转输入位顺序（以便我们始终从最高有效位开始），那么目标函数的循环公式就是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()
原答案
我不确定它是如何发生的，但是您选择检查代码的特定任务对于神经网络来说非常困难。我认为最好的解释是，当特征以这种方式互连时，神经网络并不是很好，改变一个特征总是会完全改变目标输出的值。一种看待它的方法是，当您期望得到某个答案时，查看特征集 - 在您的情况下，它们看起来像是 20 维空间中大量平行超平面的并集 - 对于 7 个类别中的每一个，这些特征集平面“很好”地交错并留给 NN 来区分。
也就是说 - 如果你的示例数量很大，比如 10K，而可能的输入数量较小，比如你的输入位数只有 8 位（因此仅可能有 256 个唯一输入） - 网络应该“学习”正确的功能（通过“记住”每个输入的正确答案，而不进行概括）。在您的情况下，这种情况不会发生，因为代码存在以下错误。
你的标签是 20 维向量，具有 0-6 个整数位（你实际想要的标签） - 所以我猜你几乎是在尝试教 NN 学习答案的位作为单独的分类器（只有 3 位可能是非零）。我将其更改为我假设您实际想要的内容 - 长度为 7 的向量，只有一个值为 1，其他值为 0（所谓的一种热编码，keras 根据categorical_crossentropy此实际期望）。如果你想尝试单独学习每一位，你绝对不应该在最后一层使用 softmax 20，因为这样的输出会生成 20 个类别的概率，总和为 1（在这种情况下，你应该训练 20 个或更多） -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()
| 归档时间： |
|
| 查看次数： |
1074 次 |
| 最近记录： |