Как написать алгоритм классификации в тензорном потоке, используя керасы в Python?

Question

У меня есть тренировочный набор из 2 изображений, который имеет 64 элемента и к ним прикреплена метка, то есть соответствует / не соответствует.

Как я могу передать эти данные в нейронной сети, используя керас?

Мои данные следующие:

[
    [
        [
            239, 
            1, 
            255, 
            255, 
            255, 
            255, 
            2, 
            0, 
            130, 
            3, 
            1, 
            101, 
            22, 
            154, 
            0, 
            240, 
            30, 
            0, 
            2, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            128, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            71, 
            150, 
            212
        ], 
        [
            239, 
            1, 
            255, 
            255, 
            255, 
            255, 
            2, 
            0, 
            130, 
            3, 
            1, 
            101, 
            22, 
            154, 
            0, 
            240, 
            30, 
            0, 
            2, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            128, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            71, 
            150, 
            212
        ], 
        "true"
    ], 
    [
        [
            239, 
            1, 
            255, 
            255, 
            255, 
            255, 
            2, 
            0, 
            130, 
            3, 
            1, 
            81, 
            28, 
            138, 
            0, 
            241, 
            254, 
            128, 
            6, 
            0, 
            2, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            128, 
            0, 
            128, 
            2, 
            128, 
            2, 
            192, 
            6, 
            224, 
            6, 
            224, 
            62, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            13, 
            62
        ], 
        [
            239, 
            1, 
            255, 
            255, 
            255, 
            255, 
            2, 
            0, 
            130, 
            3, 
            1, 
            81, 
            28, 
            138, 
            0, 
            241, 
            254, 
            128, 
            6, 
            0, 
            2, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            128, 
            0, 
            128, 
            2, 
            128, 
            2, 
            192, 
            6, 
            224, 
            6, 
            224, 
            62, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            0, 
            13, 
            62
        ], 
        "true"
    ], 
    ....
]

Я хочу обучить нейронную сеть, чтобы после обучения, если я предоставил ей 2 массива из 64 функций, он мог определить, совпадают они или нет?

Answer 1

Поскольку вы уже извлекли фьючерсы, я бы предложил использовать несколько плотных слоев и преобразовать «истину» и «ложь» в 1 и 0 соответственно, а затем использовать сигмоидальный слой в конечном плотном слое..

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

РЕДАКТИРОВАТЬ

def generator(batch_size=10, nr_features=126):
    feed_data = np.zeros((batch_size, nr_features))
    labels = np.zeros(batch_size)
    i = 0
    for entry in data:
        if entry.pop(-1) == "true":
            labels[i] = 1
        else:
            labels[i] = 0
        feed_data[i, :] = np.array(entry).flatten()
        i += 1
        if not (i % batch_size):
            i = 0
            yield feed_data, labels


model = keras.Sequential()
model.add(keras.layers.Dense(126, input_dim=126))
model.add(keras.layers.Dense(20))
model.add(keras.layers.Dense(1))
model.add(keras.layers.Activation('sigmoid'))
model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])
for d, l in generator():
    model.train_on_batch(d, l)

Так что же происходит,

данные в генераторе - это ваши полные данные, я выскакиваю true / false, преобразовываю их в 1/0 и помещаю в массив меток, я объединяю все функции как vecotr 126.Так что feed_data.shape = (10, 126) и label.shape = (10).

Я передаю это в простую полностью подключенную сеть, которая заканчивается сигмоидом.Sigmoid полезен для вероятности, поэтому в этом случае на выходе будет вероятность того, что свойство vecotr истинно.и я просто передаю данные.

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

Ой, а вопросы задавай