Как написать алгоритм классификации в тензорном потоке с использованием keras в python?

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

Как я могу передать эти данные в нейронную сеть с помощью keras?

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

[
    [
        [
            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 функций, она должна была определить, совпадают ли они или нет?

Вам следует ознакомиться с учебным пособием по созданию классификатора с двумя выходами. Есть много онлайн.

Eypros 27.05.2019 14:10

проверили, но они не решили мою проблему. Можете ли вы предложить какой-либо конкретный учебник для этого?

Abhishek Gautam 27.05.2019 22:34

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

Eypros 28.05.2019 10:54
Почему в Python есть оператор "pass"?
Почему в Python есть оператор "pass"?
Оператор pass в Python - это простая концепция, которую могут быстро освоить даже новички без опыта программирования.
Некоторые методы, о которых вы не знали, что они существуют в Python
Некоторые методы, о которых вы не знали, что они существуют в Python
Python - самый известный и самый простой в изучении язык в наши дни. Имея широкий спектр применения в области машинного обучения, Data Science,...
Основы Python Часть I
Основы Python Часть I
Вы когда-нибудь задумывались, почему в программах на Python вы видите приведенный ниже код?
LeetCode - 1579. Удаление максимального числа ребер для сохранения полной проходимости графа
LeetCode - 1579. Удаление максимального числа ребер для сохранения полной проходимости графа
Алиса и Боб имеют неориентированный граф из n узлов и трех типов ребер:
Оптимизация кода с помощью тернарного оператора Python
Оптимизация кода с помощью тернарного оператора Python
И последнее, что мы хотели бы показать вам, прежде чем двигаться дальше, это
Советы по эффективной веб-разработке с помощью Python
Советы по эффективной веб-разработке с помощью Python
Как веб-разработчик, Python может стать мощным инструментом для создания эффективных и масштабируемых веб-приложений.
0
3
44
1
Перейти к ответу Данный вопрос помечен как решенный

Ответы 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) и labels.shape = (10).

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

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

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

да одна вещь, которую я хочу спросить, у меня есть 2 изображения для сопоставления, каждое из которых имеет 64 функции. Итак, будет ли мой входной слой иметь 64 + 64 = 128 узлов?

Abhishek Gautam 28.05.2019 08:12

Не совсем так, на входе будет 64 узла, и вы подадите ему пакет из 2, но подождите, у вас есть только 2 изображения? Тогда не используйте глубокое обучение, просто openCV, вы не можете ничего тренировать только с двумя изображениями, или я запутался xd

T. Kelher 28.05.2019 08:39

У меня есть данные в этом формате [[[изображение 1], [изображение 2], «истина»], [[изображение 1], [изображение 2], «истина»], [[изображение 1], [изображение 2] , "правда" ], [[ изображение 1 ], [ изображение 2 ], "правда" ], .... ]

Abhishek Gautam 28.05.2019 14:22

Если честно, имело бы смысл разделить данные

T. Kelher 28.05.2019 14:24

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

Abhishek Gautam 28.05.2019 14:26

Ну, метки в любом случае должны быть удалены, и вы можете объединить изображения, я помогу с некоторым кодом, чтобы накормить его, как только вернусь домой к своему ноутбуку, мобильный телефон не очень удобен для этого.

T. Kelher 28.05.2019 14:32

Спасибо большое, понял идею. Теперь это работает. Точность составляет 63,33%. Думаю, мне нужно больше данных.

Abhishek Gautam 29.05.2019 11:13

Другие вопросы по теме