Керас: модель CNN не учится

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

ЭКГ (электрокардиография)

В моем наборе данных есть 312 записей, принадлежащих участникам, и есть 18000 строк данных в каждой записи. Итак, когда я объединяю их в один фрейм данных, всего получается 5616000 строк.

Вот мой train_x фрейм данных;

            ecg  
0        0.1912 
1        0.3597 
2        0.3597 
3        0.3597 
4        0.3597 
5        0.3597 
6        0.2739 
7        0.1641 
8        0.0776 
9        0.0005 
10      -0.0375 
11      -0.0676 
12      -0.1071 
13      -0.1197 
..      ....... 
..      ....... 
..      ....... 
5616000 0.0226

А у меня 6 занятий, которые соответствуют эмоциям. Я закодировал эти ярлыки числами;

гнев = 0, спокойствие = 1, отвращение = 2, страх = 3, счастье = 4, грусть = 5

Вот мой train_y;

         emotion
0              0
1              0
2              0
3              0
4              0
.              .
.              .
.              .
18001          1
18002          1
18003          1
.              .
.              .
.              .
360001         2
360002         2
360003         2
.              .
.              .
.              .
.              .
5616000        5

Чтобы прокормить свой CNN, я изменяю форму train_x и одну горячую кодировку данных train_y.

train_x = train_x.values.reshape(312,18000,1) 
train_y = train_y.values.reshape(312,18000)
train_y = train_y[:,:1]  # truncated train_y to have single corresponding value to a complete signal.
train_y = pd.DataFrame(train_y)
train_y = pd.get_dummies(train_y[0]) #one hot encoded labels

Вот как они выглядят после этих процессов: train_x после изменения формы;

[[[0.60399908]
  [0.79763273]
  [0.79763273]
  ...
  [0.09779361]
  [0.09779361]
  [0.14732245]]

 [[0.70386905]
  [0.95101687]
  [0.95101687]
  ...
  [0.41530258]
  [0.41728671]
  [0.42261905]]

 [[0.75008021]
  [1.        ]
  [1.        ]
  ...
  [0.46412148]
  [0.46412148]
  [0.46412148]]

 ...

 [[0.60977509]
  [0.7756791 ]
  [0.7756791 ]
  ...
  [0.12725148]
  [0.02755331]
  [0.02755331]]

 [[0.59939494]
  [0.75514785]
  [0.75514785]
  ...
  [0.0391334 ]
  [0.0391334 ]
  [0.0578706 ]]

 [[0.5786066 ]
  [0.71539303]
  [0.71539303]
  ...
  [0.41355098]
  [0.41355098]
  [0.4112712 ]]]

train_y после одного горячего кодирования;

    0  1  2  3  4  5
0    1  0  0  0  0  0
1    1  0  0  0  0  0
2    0  1  0  0  0  0
3    0  1  0  0  0  0
4    0  0  0  0  0  1
5    0  0  0  0  0  1
6    0  0  1  0  0  0
7    0  0  1  0  0  0
8    0  0  0  1  0  0
9    0  0  0  1  0  0
10   0  0  0  0  1  0
11   0  0  0  0  1  0
12   0  0  0  1  0  0
13   0  0  0  1  0  0
14   0  1  0  0  0  0
15   0  1  0  0  0  0
16   1  0  0  0  0  0
17   1  0  0  0  0  0
18   0  0  1  0  0  0
19   0  0  1  0  0  0
20   0  0  0  0  1  0
21   0  0  0  0  1  0
22   0  0  0  0  0  1
23   0  0  0  0  0  1
24   0  0  0  0  0  1
25   0  0  0  0  0  1
26   0  0  1  0  0  0
27   0  0  1  0  0  0
28   0  1  0  0  0  0
29   0  1  0  0  0  0
..  .. .. .. .. .. ..
282  0  0  0  1  0  0
283  0  0  0  1  0  0
284  1  0  0  0  0  0
285  1  0  0  0  0  0
286  0  0  0  0  1  0
287  0  0  0  0  1  0
288  1  0  0  0  0  0
289  1  0  0  0  0  0
290  0  1  0  0  0  0
291  0  1  0  0  0  0
292  0  0  0  1  0  0
293  0  0  0  1  0  0
294  0  0  1  0  0  0
295  0  0  1  0  0  0
296  0  0  0  0  0  1
297  0  0  0  0  0  1
298  0  0  0  0  1  0
299  0  0  0  0  1  0
300  0  0  0  1  0  0
301  0  0  0  1  0  0
302  0  0  1  0  0  0
303  0  0  1  0  0  0
304  0  0  0  0  0  1
305  0  0  0  0  0  1
306  0  1  0  0  0  0
307  0  1  0  0  0  0
308  0  0  0  0  1  0
309  0  0  0  0  1  0
310  1  0  0  0  0  0
311  1  0  0  0  0  0

[312 rows x 6 columns]

После изменения формы я создал свою модель CNN;

model = Sequential()
model.add(Conv1D(100,700,activation='relu',input_shape=(18000,1))) #kernel_size is 700 because 18000 rows = 60 seconds so 700 rows = ~2.33 seconds and there is two heart beat peak in every 2 second for ecg signal.
model.add(Conv1D(50,700))
model.add(Dropout(0.5))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling1D(4))
model.add(Flatten())
model.add(Dense(6,activation='softmax'))

adam = keras.optimizers.Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)

model.compile(optimizer = adam, loss = 'categorical_crossentropy', metrics = ['acc'])
model.fit(train_x,train_y,epochs = 50, batch_size = 32, validation_split=0.33, shuffle=False)

Проблема в том, что точность не превышает 0,2 и колеблется вверх и вниз. Похоже, модель ничего не узнает. Я попытался увеличить слои, поиграть со скоростью обучения, изменить функцию потерь, изменить оптимизатор, масштабирование данных, нормализация данных, но мне ничего не помогло решить эту проблему. Я также пробовал более простые модели Dense или модели LSTM, но я не могу найти способ, который работает.

Как я могу решить эту проблему? Заранее спасибо.

Дополнение:

Я хотел добавить результаты тренировок через 50 эпох;

Epoch 1/80
249/249 [==============================] - 24s 96ms/step - loss: 2.3118 - acc: 0.1406 - val_loss: 1.7989 - val_acc: 0.1587
Epoch 2/80
249/249 [==============================] - 19s 76ms/step - loss: 2.0468 - acc: 0.1647 - val_loss: 1.8605 - val_acc: 0.2222
Epoch 3/80
249/249 [==============================] - 19s 76ms/step - loss: 1.9562 - acc: 0.1767 - val_loss: 1.8203 - val_acc: 0.2063
Epoch 4/80
249/249 [==============================] - 19s 75ms/step - loss: 1.9361 - acc: 0.2169 - val_loss: 1.8033 - val_acc: 0.1905
Epoch 5/80
249/249 [==============================] - 19s 74ms/step - loss: 1.8834 - acc: 0.1847 - val_loss: 1.8198 - val_acc: 0.2222
Epoch 6/80
249/249 [==============================] - 19s 75ms/step - loss: 1.8278 - acc: 0.2410 - val_loss: 1.7961 - val_acc: 0.1905
Epoch 7/80
249/249 [==============================] - 19s 75ms/step - loss: 1.8022 - acc: 0.2450 - val_loss: 1.8092 - val_acc: 0.2063
Epoch 8/80
249/249 [==============================] - 19s 75ms/step - loss: 1.7959 - acc: 0.2369 - val_loss: 1.8005 - val_acc: 0.2222
Epoch 9/80
249/249 [==============================] - 19s 75ms/step - loss: 1.7234 - acc: 0.2610 - val_loss: 1.7871 - val_acc: 0.2381
Epoch 10/80
249/249 [==============================] - 19s 75ms/step - loss: 1.6861 - acc: 0.2972 - val_loss: 1.8017 - val_acc: 0.1905
Epoch 11/80
249/249 [==============================] - 19s 75ms/step - loss: 1.6696 - acc: 0.3173 - val_loss: 1.7878 - val_acc: 0.1905
Epoch 12/80
249/249 [==============================] - 19s 75ms/step - loss: 1.5868 - acc: 0.3655 - val_loss: 1.7771 - val_acc: 0.1270
Epoch 13/80
249/249 [==============================] - 19s 75ms/step - loss: 1.5751 - acc: 0.3936 - val_loss: 1.7818 - val_acc: 0.1270
Epoch 14/80
249/249 [==============================] - 19s 75ms/step - loss: 1.5647 - acc: 0.3735 - val_loss: 1.7733 - val_acc: 0.1429
Epoch 15/80
249/249 [==============================] - 19s 75ms/step - loss: 1.4621 - acc: 0.4177 - val_loss: 1.7759 - val_acc: 0.1270
Epoch 16/80
249/249 [==============================] - 19s 75ms/step - loss: 1.4519 - acc: 0.4498 - val_loss: 1.8005 - val_acc: 0.1746
Epoch 17/80
249/249 [==============================] - 19s 75ms/step - loss: 1.4489 - acc: 0.4378 - val_loss: 1.8020 - val_acc: 0.1270
Epoch 18/80
249/249 [==============================] - 19s 75ms/step - loss: 1.4449 - acc: 0.4297 - val_loss: 1.7852 - val_acc: 0.1587
Epoch 19/80
249/249 [==============================] - 19s 75ms/step - loss: 1.3600 - acc: 0.5301 - val_loss: 1.7922 - val_acc: 0.1429
Epoch 20/80
249/249 [==============================] - 19s 75ms/step - loss: 1.3349 - acc: 0.5422 - val_loss: 1.8061 - val_acc: 0.2222
Epoch 21/80
249/249 [==============================] - 19s 75ms/step - loss: 1.2885 - acc: 0.5622 - val_loss: 1.8235 - val_acc: 0.1746
Epoch 22/80
249/249 [==============================] - 19s 75ms/step - loss: 1.2291 - acc: 0.5823 - val_loss: 1.8173 - val_acc: 0.1905
Epoch 23/80
249/249 [==============================] - 19s 75ms/step - loss: 1.1890 - acc: 0.6506 - val_loss: 1.8293 - val_acc: 0.1905
Epoch 24/80
249/249 [==============================] - 19s 75ms/step - loss: 1.1473 - acc: 0.6627 - val_loss: 1.8274 - val_acc: 0.1746
Epoch 25/80
249/249 [==============================] - 19s 75ms/step - loss: 1.1060 - acc: 0.6747 - val_loss: 1.8142 - val_acc: 0.1587
Epoch 26/80
249/249 [==============================] - 19s 75ms/step - loss: 1.0210 - acc: 0.7510 - val_loss: 1.8126 - val_acc: 0.1905
Epoch 27/80
249/249 [==============================] - 19s 75ms/step - loss: 0.9699 - acc: 0.7631 - val_loss: 1.8094 - val_acc: 0.1746
Epoch 28/80
249/249 [==============================] - 19s 75ms/step - loss: 0.9127 - acc: 0.8193 - val_loss: 1.8012 - val_acc: 0.1746
Epoch 29/80
249/249 [==============================] - 19s 75ms/step - loss: 0.9176 - acc: 0.7871 - val_loss: 1.8371 - val_acc: 0.1746
Epoch 30/80
249/249 [==============================] - 19s 75ms/step - loss: 0.8725 - acc: 0.8233 - val_loss: 1.8215 - val_acc: 0.1587
Epoch 31/80
249/249 [==============================] - 19s 75ms/step - loss: 0.8316 - acc: 0.8514 - val_loss: 1.8010 - val_acc: 0.1429
Epoch 32/80
249/249 [==============================] - 19s 75ms/step - loss: 0.7958 - acc: 0.8474 - val_loss: 1.8594 - val_acc: 0.1270
Epoch 33/80
249/249 [==============================] - 19s 75ms/step - loss: 0.7452 - acc: 0.8795 - val_loss: 1.8260 - val_acc: 0.1587
Epoch 34/80
249/249 [==============================] - 19s 75ms/step - loss: 0.7395 - acc: 0.8916 - val_loss: 1.8191 - val_acc: 0.1587
Epoch 35/80
249/249 [==============================] - 19s 75ms/step - loss: 0.6794 - acc: 0.9357 - val_loss: 1.8344 - val_acc: 0.1429
Epoch 36/80
249/249 [==============================] - 19s 75ms/step - loss: 0.6106 - acc: 0.9357 - val_loss: 1.7903 - val_acc: 0.1111
Epoch 37/80
249/249 [==============================] - 19s 75ms/step - loss: 0.5609 - acc: 0.9598 - val_loss: 1.7882 - val_acc: 0.1429
Epoch 38/80
249/249 [==============================] - 19s 75ms/step - loss: 0.5788 - acc: 0.9478 - val_loss: 1.8036 - val_acc: 0.1905
Epoch 39/80
249/249 [==============================] - 19s 75ms/step - loss: 0.5693 - acc: 0.9398 - val_loss: 1.7712 - val_acc: 0.1746
Epoch 40/80
249/249 [==============================] - 19s 75ms/step - loss: 0.4911 - acc: 0.9598 - val_loss: 1.8497 - val_acc: 0.1429
Epoch 41/80
249/249 [==============================] - 19s 75ms/step - loss: 0.4824 - acc: 0.9518 - val_loss: 1.8105 - val_acc: 0.1429
Epoch 42/80
249/249 [==============================] - 19s 75ms/step - loss: 0.4198 - acc: 0.9759 - val_loss: 1.8332 - val_acc: 0.1111
Epoch 43/80
249/249 [==============================] - 19s 75ms/step - loss: 0.3890 - acc: 0.9880 - val_loss: 1.9316 - val_acc: 0.1111
Epoch 44/80
249/249 [==============================] - 19s 75ms/step - loss: 0.3762 - acc: 0.9920 - val_loss: 1.8333 - val_acc: 0.1746
Epoch 45/80
249/249 [==============================] - 19s 75ms/step - loss: 0.3510 - acc: 0.9880 - val_loss: 1.8090 - val_acc: 0.1587
Epoch 46/80
249/249 [==============================] - 19s 75ms/step - loss: 0.3306 - acc: 0.9880 - val_loss: 1.8230 - val_acc: 0.1587
Epoch 47/80
249/249 [==============================] - 19s 75ms/step - loss: 0.2814 - acc: 1.0000 - val_loss: 1.7843 - val_acc: 0.2222
Epoch 48/80
249/249 [==============================] - 19s 75ms/step - loss: 0.2794 - acc: 1.0000 - val_loss: 1.8147 - val_acc: 0.2063
Epoch 49/80
249/249 [==============================] - 19s 75ms/step - loss: 0.2430 - acc: 1.0000 - val_loss: 1.8488 - val_acc: 0.1587
Epoch 50/80
249/249 [==============================] - 19s 75ms/step - loss: 0.2216 - acc: 1.0000 - val_loss: 1.8215 - val_acc: 0.1587

python keras tensorflow deep-learning neural-network
person Ozan Yurtsever    schedule 20.04.2019    source источник
comment
ваша потеря валидации не изменится, но потеря уменьшается во время тренировки. на этом этапе ваша модель, вероятно, переоснащена, и вы можете сократить свои эпохи и дополнительно рассмотреть возможность упрощения сети и посмотреть, поможет ли это. (отказ от ответственности, не рассматривал сам код модели)   -  person Paritosh Singh    schedule 20.04.2019
comment
@ParitoshSingh, да, это явно переоснащение, но пока оно не переоборудуется, удовлетворительного результата нет. Точность колеблется полностью. Попробовал модели попроще, ничего не изменилось.   -  person Ozan Yurtsever    schedule 20.04.2019
comment
Одно, конечно, разочаровывающее. Поскольку validation_split просто извлекается из конца каждого пакета, может ли существовать шаблон для каждого пакета, в результате чего данные проверки будут существенно отличаться от данных обучения? Возможно, вы уже пробовали shuffle = True?   -  person TheLoneDeranger    schedule 21.04.2019
comment
@TheLoneDeranger, да, я пробовал shuffle = True, ничего не изменилось.   -  person Ozan Yurtsever    schedule 21.04.2019
comment
вы можете попробовать регулирование keras.io/regularizers, чтобы избежать переобучения   -  person Peter    schedule 21.04.2019
comment
Может быть, для начала: если эмоция субъекта i во времени t зависит от эмоции i в t-1, ваша модель не сможет уловить эту динамическую реакцию. Простой способ проверить, может ли это быть проблемой, - запустить модель OLS и добавить запаздывающие эмоции. Это в R, но это хорошее вступление к временным рядам в Keras blogs.rstudio.com/tensorflow/posts/   -  person Peter    schedule 21.04.2019
comment
@Peter, на самом деле, чтобы сделать классификацию временных рядов, я попробовал модель LSTM, но точность также была слишком низкой.   -  person Ozan Yurtsever    schedule 21.04.2019
comment
Может проблема в самих данных? Поскольку вы пробовали методы регуляризации и LSTM, возможно, с вашими данными что-то не так.   -  person Timbus Calin    schedule 24.04.2019
comment
Для меня это проблема временного ряда. Повторяющиеся нейронные сети - это, вероятно, то, что вам нужно. Не могли бы вы поделиться образцом своего набора данных, чтобы поиграть с ним?   -  person Ioannis Nasios    schedule 25.04.2019
comment
Набор данных общедоступен или создан вами? И если он общедоступен, где я могу его найти?   -  person Krunal V    schedule 25.04.2019
comment
@kruxx, вот необработанный, не предварительно обработанный набор данных. Обратите внимание, что это очень зашумленные данные, и их следует предварительно обработать. github.com/ozanyurtsever/emotion_recognition/tree/master/   -  person Ozan Yurtsever    schedule 25.04.2019
comment
@OzanYurtsever, Помимо настройки shuffle = True, попробуйте перетасовать данные обучения, прежде чем вставлять их в свою модель.   -  person pouyan    schedule 25.04.2019
comment
Ваш обучающий набор слишком мал для того количества параметров, которое вы используете, если только вы не дадите системе разумное заблаговременное решение, вероятно, потребуется целая вечность, чтобы сойтись на чем-то, а когда это произойдет, обобщение не получится. Я бы посоветовал, если вы настаиваете на использовании только этого небольшого набора, подумайте о включении неопределенности (байесовских сетей) в свою модель. Поищите работы Ярина Гала и связанных с ними авторов и, в основном, вариационный вывод.   -  person Chris    schedule 29.04.2019

Ответы (8)


arrow_upward
6
arrow_downward

Я бы порекомендовал сделать несколько шагов назад и рассмотреть гораздо более простой подход.
На основании следующих ...

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

Не похоже, что вы так хорошо разбираетесь в своих данных и инструментах ... что нормально, потому что это возможность учиться.

Несколько вопросов

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

  2. Вы проверяли классовый дисбаланс?

  3. Почему вы используете CNN? Чего вы хотите добиться со сверточными слоями? Что касается меня, когда я создаю модель зрения, скажем, для классификации обуви в моем шкафу, я использую несколько сверточных слоев для извлечения пространственных характеристик, таких как края и кривые.

  4. По поводу третьего вопроса ... Откуда вы взяли эту архитектуру? Это из публикации? Является ли это современной моделью для кривых ЭКГ? Или это самая доступная модель? Иногда это не одно и то же. Я хотел бы покопаться в литературе и поискать в Интернете еще немного, чтобы найти дополнительную информацию о нейронных сетях и анализе кривых ЭКГ.

Думаю, если вы ответите на эти вопросы, вы сможете решить свою проблему самостоятельно.

person VanBantam    schedule 24.04.2019
comment
На самом деле, поскольку в этой области проведено большинство исследований, используется структура CNN. Я решил использовать его после прочтения нескольких статей по этой теме. - person Ozan Yurtsever; 25.04.2019
comment
@OzanYurtsever Ладно, круто! Есть ли в этих документах базовая модель, которую вы можете реализовать? Основана ли модель, которую вы использовали в своем вопросе, на базовой модели в документе? Вы пробовали воспроизвести результаты авторов, используя их методы и данные? - person VanBantam; 25.04.2019

arrow_upward
2
arrow_downward

Текущая проблема в вашей реализации заключается в том, что, поскольку вы использовали данные с формой (312,18000,1) для своей модели, у вас есть только 312 образцов, и вы использовали валидационный сплит 0,33, поэтому вы используете только 209 образцов для целей обучения.

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv1d_1 (Conv1D)            (None, 17301, 100)        70100     
_________________________________________________________________
conv1d_2 (Conv1D)            (None, 16602, 50)         3500050   
_________________________________________________________________
dropout_1 (Dropout)          (None, 16602, 50)         0         
_________________________________________________________________
batch_normalization_1 (Batch (None, 16602, 50)         200       
_________________________________________________________________
activation_1 (Activation)    (None, 16602, 50)         0         
_________________________________________________________________
max_pooling1d_1 (MaxPooling1 (None, 4150, 50)          0         
_________________________________________________________________
flatten_1 (Flatten)          (None, 207500)            0         
_________________________________________________________________
dense_1 (Dense)              (None, 6)                 1245006   
=================================================================
Total params: 4,815,356
Trainable params: 4,815,256
Non-trainable params: 100
_________________________________________________________________

Как я видел model.summary(), ваша модель имеет 4 815 256 обучаемых параметров. Итак, ваша модель легко переоснащается обучающими данными. Проблема в том, что вам нужно изучить так много параметров без достаточного количества образцов. Вы можете попробовать уменьшить размер вашей модели, как показано ниже:

model = Sequential()
model.add(Conv1D(100,2,activation='relu',input_shape=(18000,1))) 
model.add(Conv1D(10,2))
model.add(Dropout(0.5))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling1D(4))
model.add(Flatten())
model.add(Dense(6,activation='softmax'))
model.summary()

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv1d_1 (Conv1D)            (None, 17999, 100)        300       
_________________________________________________________________
conv1d_2 (Conv1D)            (None, 17998, 10)         2010      
_________________________________________________________________
dropout_1 (Dropout)          (None, 17998, 10)         0         
_________________________________________________________________
batch_normalization_1 (Batch (None, 17998, 10)         40        
_________________________________________________________________
activation_1 (Activation)    (None, 17998, 10)         0         
_________________________________________________________________
max_pooling1d_1 (MaxPooling1 (None, 4499, 10)          0         
_________________________________________________________________
flatten_1 (Flatten)          (None, 44990)             0         
_________________________________________________________________
dense_1 (Dense)              (None, 6)                 269946    
=================================================================
Total params: 272,296
Trainable params: 272,276
Non-trainable params: 20
_________________________________________________________________

Насколько я знаю, у вас есть 3 типа данных: ecg, gsr, temp. Итак, вы можете использовать train_x как (312,18000,3). и ваш train_y будет (312,6).

Если вышеуказанное решение не работает,

  1. Постройте распределение классов из вашего набора данных и проверьте, есть ли какой-либо дисбаланс классов в данных.
  2. Поскольку ваша модель превышает данные, попробуйте создать больше данных (если этот набор данных создан вами) или найдите для этого какой-нибудь метод увеличения данных.
person Krunal V    schedule 25.04.2019

arrow_upward
0
arrow_downward

Я считаю, что ваш код правильный, но, как сказал комментатор, вы, вероятно, переоцениваете свои данные.

Вы можете захотеть построить график точности проверки и обучения по эпохам, чтобы визуализировать это.

Сначала вам следует подумать о том, улучшится ли ваша проблема с переобучением с помощью более простой модели. Обратите внимание, что это вряд ли улучшит вашу общую производительность, но ваша точность проверки будет более точно соответствовать точности вашей тренировки. Другой вариант - добавить слой объединения сразу после слоев свертки.

person samvoit4    schedule 20.04.2019

arrow_upward
0
arrow_downward

Вы можете попробовать добавить регуляризатор (ы) (L1 или L2), проверить kernel_initializer и / или настроить скорость обучения во время обучения с помощью обратных вызовов. Пример ниже взят из регрессионной модели.

model = Sequential()
model.add(Dense(128, input_dim=dims, activation='relu'))
model.add(Dropout(0.2))
model.add(layers.BatchNormalization())
model.add(Dense(16, activation='relu', kernel_initializer='normal', kernel_regularizer=regularizers.l1(x)))
model.add(Dropout(0.2))
model.add(layers.BatchNormalization())
model.add(Dense(1, kernel_initializer='normal'))

model.compile(optimizer=optimizers.adam(lr=l), loss='mean_squared_error')

reduce_lr = ReduceLROnPlateau(monitor='val_loss', mode='min', factor=0.5, patience=3, min_lr=0.000001, verbose=1, cooldown=0)

history = model.fit(xtrain, ytrain, epochs=epochs, batch_size=batch_size, validation_split=0.3, callbacks=[reduce_lr])
person Peter    schedule 20.04.2019
comment
Я пробовал все методы, которые вы упомянули, но, к сожалению, ни один из них не помог моей проблеме. - person Ozan Yurtsever; 21.04.2019
comment
Мммм ... хорошо. Вы пробовали другие методы, такие как усиление RF, a la lightGBM или catboost? Или есть временное измерение? В этом случае Keras LSTM может работать ... - person Peter; 21.04.2019
comment
нет, я не пробовал ни один из этих методов. Возможно, мне стоит поискать их и попытаться внедрить в свой код. - person Ozan Yurtsever; 21.04.2019

arrow_upward
0
arrow_downward

Я сомневаюсь, что способ предварительной обработки train_y не мог должным образом синхронизироваться с вашим train_x. Мой вопрос: вы сжимали y_train с помощью какой-то частотной техники?
Я думаю, что если вы сжали свои метки (для каждой строки) с помощью некоторой частотной техники, вы уже внесли большое смещение в свои данные. Дайте мне знать, как было выполнено сжатие! Спасибо

person aps014    schedule 22.04.2019
comment
К train_y не применялось никаких специальных методов предварительной обработки, кроме одного метода горячего кодирования. - person Ozan Yurtsever; 22.04.2019
comment
Хорошо я понял. Это означает, что каждая выборка имеет 18000 одномерных физических сигналов и 18000 соответствующих меток. Вам не кажется, что такая структура распределения вредна для тренировок? Поправьте меня, если я неправильно истолковал структуру. - person aps014; 22.04.2019
comment
фактически с помощью строки кода train_y = train_y[:,:1] я конвертирую y_train в форму (312,1). При этом для каждого сигнала 18000 имеется только одно соответствующее значение метки. - person Ozan Yurtsever; 22.04.2019

arrow_upward
0
arrow_downward

Я бы посоветовал следующее:

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

  2. Есть ли способ пополнить данные ?? Я вижу длину вашего сигнала 18000. Вы можете уменьшить выборку данных вдвое, используя различные методы, и увеличить набор данных. Вы будете работать с сигналом длиной 9000.

  3. Попробуйте уменьшить длину ядра свертки до 3 или 5 и увеличить глубину модели, добавив еще один сверточный слой.

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

person Illuminati0x5B    schedule 26.04.2019
comment
Длина сверточного ядра составляет 700, потому что в наборе данных 700 строк ~ = 2 секунды и каждые 2 секунды есть 2 пика сердечных сокращений (пики R). Я хотел, чтобы Си-Эн-Эн распознала эти шаблоны и извлекла из них черты. - person Ozan Yurtsever; 26.04.2019

arrow_upward
0
arrow_downward

У меня возникла проблема с ЭКГ, когда я выполнял последнее задание в колледже год назад, но с другим подходом и данными (MIT-BIH).

Кажется, вы пользуетесь одинарным отведением, не так ли? Вы пытались подготовить данные перед тем, как очистить их (обратите внимание на шум сердцебиения)? Мое предложение состоит в том, чтобы не объединять все данные в один список для тренировок, которые могут возникнуть из-за природы сердцебиения человека, постарайтесь проводить тренировки на основе пола или возраста. В некоторой литературе это довольно помогает.

Модель не работает должным образом, не из-за неправильной реализации, а из-за того, что иногда мы хорошо подготавливаем данные.

person Yosafat Vincent Saragih    schedule 30.04.2019

arrow_upward
0
arrow_downward

Ваша модель явно превышает набор данных. Одно из предложений, которое никто из комментаторов не принял во внимание, - это увеличить шаг. Здесь у вас kernel size = 700, без отступов и stride = 1. Таким образом, вы получите результат с формой (None, 17301, 100) из первого слоя Conv.

Я бы попытался либо увеличить шаг до числа от 50 до 100 (сдвиг вашего ядра на долю 2.33/(700/stride) секунд), либо вставить слой объединения после каждого из слоев Conv.

person Luca Vavassori    schedule 01.05.2019