OSCR

Sleep awake detection from leg-worn wearables using deep sensor fusion.

Code ↔ Paper

8 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 8 matches
  1. [1] § Methods › Model architecture ↔ Train/model.py, lines 11–86 · score 0.83 · fully connected layers, global max, Conv2D, BiLSTM, channel, binary
  2. [2] § Methods › Model architecture › Regularization and overfitting control ↔ Train/model.py, lines 110–159 · score 0.82 · Global Max, LeakyReLU, dense layers, Batch Normalization, dropout rate, block
  3. [3] § Methods › Model training and evaluation › Learning rate and loss function ↔ Train/model.py, lines 11–86 · score 0.75 · cosine decay, learning rate scheduler, decay step, Adam, optimized, loss
  4. [4] § Methods › Signal preprocessing ↔ Train/ppg_preprocess.py, lines 136–218 · score 0.74 · noise power, Signal power, detected peak, spectral, SNR, band
  5. [5] § Methods › Model architecture ↔ Train/Late_Fusion.ipynb, lines 1–38 · score 0.58 · late fusion architecture, separate sub, tensor, concatenating, classification, sensor
  6. [6] § Methods › Model architecture ↔ Train/ppg_preprocess.py, lines 422–484 · score 0.56 · standard deviation, heart rate, interval, HRV, signals
  7. [7] § Results ↔ Train/Late_Fusion.ipynb, lines 269–332 · score 0.56 · Receiver Operating Characteristic, ROC AUC, Curve, sensitivity, fold, windows
  8. [8] § Methods › Neighborhood majority voting-based label smoothing ↔ Train/Late_Fusion.ipynb, lines 269–332 · score 0.51 · neighboring window, refine, majority, probabilities, smoothing, threshold

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 701 lines · 27 KB · no license · 3 matches

  1. import tensorflow as tf
  2. from tensorflow.keras import layers, models, Input, Model
  3. import numpy as np
  4. from tensorflow.keras.layers import Input, Lambda
  6. from tensorflow.keras.optimizers import Adam
  7. #import tensorflow_addons as tfa
  8. from tensorflow.keras.utils import plot_model
  9. from tensorflow import keras
  11. def build_stacked_model(input_shape, num_classes, model_config):
  12. """
  13. Builds a classification model using early fusion with BiLSTM for sensor data.
  15. Args:
  16. input_shape (tuple): Shape of the input data after stacking (e.g., (1500, 3, 3)).
  17. model_config (dict): Dictionary containing all the model configurations and hyperparameters.
  19. Returns:
  20. tf.keras.Model: The compiled classification model.
  21. """
  22. inputs = Input(shape=input_shape)
  24. x = layers.Conv2D(model_config['num_filters_1'], (3, 3), padding='same',
  25. kernel_regularizer=tf.keras.regularizers.l2(model_config['l2_regularization']),
  26. kernel_initializer='he_normal')(inputs)
  27. x = layers.BatchNormalization()(x)
  28. x = layers.LeakyReLU()(x)
  30. x = layers.Conv2D(model_config['num_filters_2'], (3, 3), padding='same',
  31. kernel_regularizer=tf.keras.regularizers.l2(model_config['l2_regularization']),
  32. kernel_initializer='he_normal')(x)
  33. x = layers.BatchNormalization()(x)
  34. x = layers.LeakyReLU()(x)
  36. x = layers.MaxPooling2D(pool_size=(2, 2))(x)
  37. x = layers.Dropout(model_config['dropout_rate'])(x)
  39. x = layers.Conv2D(model_config['num_filters_3'], (3, 3), padding='same',
  40. kernel_regularizer=tf.keras.regularizers.l2(model_config['l2_regularization']),
  41. kernel_initializer='he_normal')(x)
  42. x = layers.BatchNormalization()(x)
  43. x = layers.LeakyReLU()(x)
  45. x = layers.MaxPooling2D(pool_size=(2, 1))(x)
  46. x = layers.Dropout(model_config['dropout_rate'])(x)
  48. # Reshape for BiLSTM
  49. # Convert to shape compatible with LSTM input: (batch_size, time_steps, features)
  50. # _, time_steps, features, channels = x.shape.as_list()
  51. _, time_steps, features, channels = list(x.shape)
  52. reshaped = layers.Reshape((time_steps, features * channels))(x)
  54. # BiLSTM layers for temporal dependency extraction
  55. x = layers.Bidirectional(layers.LSTM(model_config['lstm_units'], return_sequences=True))(reshaped)
  56. x = layers.GlobalMaxPooling1D()(x)
  58. # Fully connected layers
  59. x = layers.Dense(model_config['dense_units'], activation='relu')(x)
  60. x = layers.Dropout(model_config['dropout_rate'])(x)
  61. output = layers.Dense(1, activation='sigmoid', dtype='float32')(x)
  63. # Compile the model
  64. initial_learning_rate = model_config['lr']
  65. decay_steps = model_config['lr_decay_steps']
  67. # Learning rate schedule
  68. lr_schedule = tf.keras.optimizers.schedules.CosineDecay(
  69. initial_learning_rate=initial_learning_rate,
  70. decay_steps=decay_steps,
  71. alpha=model_config['lr_alpha']
  72. )
  73. optimizer = Adam(learning_rate=lr_schedule)
  75. # Loss function
  76. loss_fn = tf.keras.losses.BinaryFocalCrossentropy(gamma=model_config['loss_gamma'], alpha=model_config['loss_alpha'])
  78. # Create and compile the model
  79. model = Model(inputs=inputs, outputs=output)
  80. model.compile(optimizer=optimizer,
  81. loss=loss_fn,
  82. metrics=[keras.metrics.AUC(),
  83. keras.metrics.SpecificityAtSensitivity(0.99),
  84. keras.metrics.SensitivityAtSpecificity(0.99)])
  86. return model
  88. def attention_block(inputs):
  89. attention_probs = layers.Dense(inputs.shape[-1], activation='softmax')(inputs)
  90. attention_mul = layers.multiply([inputs, attention_probs])
  91. return attention_mul
  93. def transformer_block(inputs, num_heads, ff_dim, dropout_rate):
  94. # Multi-head self-attention
  95. attention_output = layers.MultiHeadAttention(num_heads=num_heads, key_dim=inputs.shape[-1])(inputs, inputs)
  97. # Add & normalize
  98. attention_output = layers.Dropout(dropout_rate)(attention_output)
  99. attention_output = layers.LayerNormalization(epsilon=1e-6)(attention_output + inputs)
  101. # Feed-forward network
  102. ff_output = layers.Dense(ff_dim, activation="relu")(attention_output)
  103. ff_output = layers.Dense(inputs.shape[-1])(ff_output)
  105. # Add & normalize
  106. ff_output = layers.Dropout(dropout_rate)(ff_output)
  107. output = layers.LayerNormalization(epsilon=1e-6)(ff_output + attention_output)
  109. return output
  110. def build_sensor_model_2d_TRANS(input_shape, model_config):
  111. """
  112. Builds a sub-model for processing sensor data.
  114. Args:
  115. input_shape (tuple): Shape of the input data for the sensor.
  116. model_config (dict): Dictionary containing all the model configurations and hyperparameters.
  118. Returns:
  119. tf.keras.Model: The sub-model for the sensor.
  120. """
  121. inputs = Input(shape=input_shape)
  123. x = layers.Conv2D(model_config['num_filters_1'], model_config['kernel_size_1'], padding='same',
  124. kernel_regularizer=tf.keras.regularizers.l2(model_config['l2_regularization']),
  125. kernel_initializer='he_normal')(inputs)
  126. x = layers.BatchNormalization()(x)
  127. x = layers.LeakyReLU()(x)
  129. x = layers.Conv2D(model_config['num_filters_2'], model_config['kernel_size_2'], padding='same',
  130. kernel_regularizer=tf.keras.regularizers.l2(model_config['l2_regularization']),
  131. kernel_initializer='he_normal')(x)
  132. x = layers.BatchNormalization()(x)
  133. x = layers.LeakyReLU()(x)
  135. x = layers.MaxPooling2D(model_config['pooling_size'])(x)
  136. x = layers.Dropout(model_config['dropout_rate'])(x)
  138. x = layers.Conv2D(model_config['num_filters_3'], model_config['kernel_size_2'], padding='same',
  139. kernel_regularizer=tf.keras.regularizers.l2(model_config['l2_regularization']),
  140. kernel_initializer='he_normal')(x)
  141. x = layers.BatchNormalization()(x)
  142. x = layers.LeakyReLU()(x)
  143. x = layers.MaxPooling2D(model_config['pooling_size'])(x)
  144. x = layers.Dropout(model_config['dropout_rate'])(x)
  146. batch_size, height, width, channels = x.shape.as_list()
  147. new_shape = (height, width * channels)
  149. x = layers.Reshape(new_shape)(x)
  151. # Transformer block
  152. x = transformer_block(x, num_heads=model_config['num_heads'],
  153. ff_dim=model_config['ff_dim'], dropout_rate=model_config['dropout_rate'])
  155. # LSTM block or dense layers
  156. x = layers.Bidirectional(layers.LSTM(model_config['lstm_units'], return_sequences=True))(x)
  157. x = layers.GlobalMaxPooling1D()(x)
  159. return Model(inputs, x)
  161. def build_sensor_model_2d_2(input_shape, model_config):
  162. """
  163. Builds a sub-model for processing sensor data.
  165. Args:
  166. input_shape (tuple): Shape of the input data for the sensor.
  167. model_config (dict): Dictionary containing all the model configurations and hyperparameters.
  169. Returns:
  170. tf.keras.Model: The sub-model for the sensor.
  171. """
  172. inputs = Input(shape=input_shape)
  174. x = layers.Conv2D(model_config['num_filters_1'], model_config['kernel_size_1'], padding='same',
  175. kernel_regularizer=tf.keras.regularizers.l2(model_config['l2_regularization']),
  176. kernel_initializer='he_normal')(inputs)
  177. x = layers.BatchNormalization()(x)
  178. x = layers.LeakyReLU()(x)
  180. x = layers.Conv2D(model_config['num_filters_2'], model_config['kernel_size_2'], padding='same',
  181. kernel_regularizer=tf.keras.regularizers.l2(model_config['l2_regularization']),
  182. kernel_initializer='he_normal')(x)
  183. x = layers.BatchNormalization()(x)
  184. x = layers.LeakyReLU()(x)
  186. x = layers.MaxPooling2D(model_config['pooling_size'])(x)
  187. # Removed Dropout here to avoid applying it on a 4D tensor
  189. x = layers.Conv2D(model_config['num_filters_3'], model_config['kernel_size_2'], padding='same',
  190. kernel_regularizer=tf.keras.regularizers.l2(model_config['l2_regularization']),
  191. kernel_initializer='he_normal')(x)
  192. x = layers.BatchNormalization()(x)
  193. x = layers.LeakyReLU()(x)
  194. x = layers.MaxPooling2D(model_config['pooling_size'])(x)
  195. # Removed Dropout here as well
  197. # Attention block
  198. # x = attention_block(x)
  200. # Use Reshape to prepare for LSTM layer
  201. shape_before_lstm = x.shape[1] * x.shape[2] # Combine height and width
  202. x = layers.Reshape((shape_before_lstm, x.shape[-1]))(x)
  203. x = layers.Dropout(model_config['dropout_rate'])(x) # Apply Dropout after Reshape
  206. x = layers.Bidirectional(layers.LSTM(model_config['lstm_units'], return_sequences=True))(x)
  207. x = layers.GlobalMaxPooling1D()(x)
  209. return Model(inputs, x)
  211. def build_sensor_model_2d_sm_2(input_shape, model_config):
  212. """
  213. Builds a sub-model for processing sensor data with simpler structure.
  215. Args:
  216. input_shape (tuple): Shape of the input data for the sensor.
  217. model_config (dict): Dictionary containing all the model configurations and hyperparameters.
  219. Returns:
  220. tf.keras.Model: The sub-model for the sensor.
  221. """
  222. inputs = Input(shape=input_shape)
  224. x = layers.Conv2D(model_config['num_filters_1_sm'], model_config['kernel_size_1_sm'], padding='same',
  225. kernel_regularizer=tf.keras.regularizers.l2(model_config['l2_regularization']),
  226. kernel_initializer='he_normal')(inputs)
  227. x = layers.BatchNormalization()(x)
  228. x = layers.LeakyReLU()(x)
  230. x = layers.MaxPooling2D(model_config['pooling_size'])(x)
  231. # Removed Dropout here as well
  233. # Flatten and Reshape to prepare for Dense and GlobalMaxPooling1D
  234. x = layers.Flatten()(x)
  235. x = layers.Dense(32, activation='relu')(x)
  237. # Reshape to add a dimension for compatibility with GlobalMaxPooling1D
  238. x = layers.Reshape((32, 1))(x) # Reshaping to (batch, 32, 1)
  239. x = layers.GlobalMaxPooling1D()(x)
  241. return Model(inputs, x)
  243. def build_sensor_model_2d(input_shape, model_config):
  244. """
  245. Builds a sub-model for processing sensor data.
  247. Args:
  248. input_shape (tuple): Shape of the input data for the sensor.
  249. model_config (dict): Dictionary containing all the model configurations and hyperparameters.
  251. Returns:
  252. tf.keras.Model: The sub-model for the sensor.
  253. """
  254. inputs = Input(shape=input_shape)
  256. x = layers.Conv2D(model_config['num_filters_1'], model_config['kernel_size_1'], padding='same',
  257. kernel_regularizer=tf.keras.regularizers.l2(model_config['l2_regularization']),
  258. kernel_initializer='he_normal')(inputs)
  259. x = layers.BatchNormalization()(x)
  260. x = layers.LeakyReLU()(x)
  262. x = layers.Conv2D(model_config['num_filters_2'], model_config['kernel_size_2'], padding='same',
  263. kernel_regularizer=tf.keras.regularizers.l2(model_config['l2_regularization']),
  264. kernel_initializer='he_normal')(x)
  265. x = layers.BatchNormalization()(x)
  266. x = layers.LeakyReLU()(x)
  268. x = layers.MaxPooling2D(model_config['pooling_size'])(x)
  269. x = layers.Dropout(model_config['dropout_rate'])(x)
  271. x = layers.Conv2D(model_config['num_filters_3'], model_config['kernel_size_2'], padding='same',
  272. kernel_regularizer=tf.keras.regularizers.l2(model_config['l2_regularization']),
  273. kernel_initializer='he_normal')(x)
  274. x = layers.BatchNormalization()(x)
  275. x = layers.LeakyReLU()(x)
  276. x = layers.MaxPooling2D(model_config['pooling_size'])(x)
  277. x = layers.Dropout(model_config['dropout_rate'])(x)
  279. # Attention block
  280. #x = attention_block(x)
  282. batch_size, height, width, channels = x.shape.as_list()
  283. new_shape = (height, width * channels)
  285. x = layers.Reshape(new_shape)(x)
  286. x = layers.Dropout(model_config['dropout_rate'])(x)
  287. x = layers.Bidirectional(layers.LSTM(model_config['lstm_units'], return_sequences=True))(x)
  288. x = layers.GlobalMaxPooling1D()(x)
  290. return Model(inputs, x)
  292. def build_sensor_model_2d_sm(input_shape, model_config):
  293. """
  294. Builds a sub-model for processing sensor data.
  296. Args:
  297. input_shape (tuple): Shape of the input data for the sensor.
  298. model_config (dict): Dictionary containing all the model configurations and hyperparameters.
  300. Returns:
  301. tf.keras.Model: The sub-model for the sensor.
  302. """
  303. inputs = Input(shape=input_shape)
  305. x = layers.Conv2D(model_config['num_filters_1_sm'], model_config['kernel_size_1_sm'], padding='same',
  306. kernel_regularizer=tf.keras.regularizers.l2(model_config['l2_regularization']),
  307. kernel_initializer='he_normal')(inputs)
  308. x = layers.BatchNormalization()(x)
  309. x = layers.LeakyReLU()(x)
  311. x = layers.MaxPooling2D(model_config['pooling_size'])(x)
  312. x = layers.Dropout(model_config['dropout_rate'])(x)
  314. # Attention block
  315. #x = attention_block(x)
  317. batch_size, height, width, channels = x.shape.as_list()
  318. new_shape = (height, width * channels)
  320. x = layers.Reshape(new_shape)(x)
  321. x = layers.Dropout(model_config['dropout_rate'])(x)
  322. x = layers.Dense(32, activation='relu')(x)
  323. #x = layers.Bidirectional(layers.LSTM(model_config['lstm_units_sm'], return_sequences=True))(x)
  324. x = layers.GlobalMaxPooling1D()(x)
  326. return Model(inputs, x)
  328. def build_combined_model(input_shapes, num_classes, model_config): # late fusion model architecture
  329. """
  330. Builds a classification model that combines data from three sensors.
  332. Args:
  333. input_shapes (list of tuples): Shapes of the input data for each sensor.
  334. num_classes (int): Number of output classes.
  335. model_config (dict): Dictionary containing all the model configurations and hyperparameters.
  337. Returns:
  338. tf.keras.Model: The compiled classification model.
  339. """
  340. # Create sub-models for each sensor
  341. # sensor1_model = build_sensor_model_2d(input_shapes[0], model_config)
  342. # sensor2_model = build_sensor_model_2d(input_shapes[1], model_config)
  343. # sensor3_model = build_sensor_model_2d(input_shapes[2], model_config)
  344. # sensor4_model = build_sensor_model_2d_sm(input_shapes[3], model_config)
  346. sensor1_model = build_sensor_model_2d_2(input_shapes[0], model_config)
  347. sensor2_model = build_sensor_model_2d_2(input_shapes[1], model_config)
  348. sensor3_model = build_sensor_model_2d_2(input_shapes[2], model_config)
  349. sensor4_model = build_sensor_model_2d_sm_2(input_shapes[3], model_config)
  351. #sensor1_model = build_sensor_model_2d_TRANS(input_shapes[0], model_config)
  352. #sensor2_model = build_sensor_model_2d_TRANS(input_shapes[1], model_config)
  353. #sensor3_model = build_sensor_model_2d_TRANS(input_shapes[2], model_config)
  354. #sensor4_model = build_sensor_model_2d_sm(input_shapes[3], model_config)
  357. # Define inputs for each sensor
  358. sensor1_input = Input(shape=input_shapes[0])
  359. sensor2_input = Input(shape=input_shapes[1])
  360. sensor3_input = Input(shape=input_shapes[2])
  361. sensor4_input = Input(shape=input_shapes[3])
  363. # Get the outputs from each sub-model
  364. sensor1_output = sensor1_model(sensor1_input)
  365. sensor2_output = sensor2_model(sensor2_input)
  366. sensor3_output = sensor3_model(sensor3_input)
  367. sensor4_output = sensor4_model(sensor4_input)
  369. # Concatenate the outputs
  370. concatenated = layers.concatenate([sensor1_output, sensor2_output, sensor3_output, sensor4_output])
  372. # Add Dense and Dropout layers
  373. x = layers.Dense(model_config['dense_units'], activation='relu')(concatenated)
  374. x = layers.Dropout(model_config['dropout_rate'])(x)
  375. output = layers.Dense(1, activation='sigmoid', dtype='float32')(x)
  376. #output = layers.Dense(1)(x)
  378. initial_learning_rate = model_config['lr']
  379. decay_steps = model_config['lr_decay_steps']
  381. # Create the learning rate schedule
  382. lr_schedule = tf.keras.optimizers.schedules.CosineDecay(
  383. initial_learning_rate=initial_learning_rate,
  384. decay_steps=decay_steps,
  385. alpha=model_config['lr_alpha']
  387. )
  389. optimizer = Adam(learning_rate=lr_schedule)
  391. # Create and compile the model
  392. model = Model(inputs=[sensor1_input, sensor2_input, sensor3_input, sensor4_input], outputs=output)
  394. #loss_fn = tf.keras.losses.BinaryCrossentropy()
  395. loss_fn = tf.keras.losses.BinaryFocalCrossentropy(gamma=model_config['loss_gamma'], alpha=model_config['loss_alpha'])
  397. model.compile(optimizer=optimizer,
  398. loss=loss_fn,
  399. metrics=[keras.metrics.AUC(),
  400. keras.metrics.SpecificityAtSensitivity(0.99),
  401. keras.metrics.SensitivityAtSpecificity(0.99)]
  402. )
  406. return model
  411. def build_combined_model_removed_1(input_shapes, num_classes, model_config):
  412. """
  413. Builds a classification model that combines data from three sensors.
  415. Args:
  416. input_shapes (list of tuples): Shapes of the input data for each sensor.
  417. num_classes (int): Number of output classes.
  418. model_config (dict): Dictionary containing all the model configurations and hyperparameters.
  420. Returns:
  421. tf.keras.Model: The compiled classification model.
  422. """
  423. # Create sub-models for each sensor
  424. # sensor1_model = build_sensor_model_2d(input_shapes[0], model_config)
  425. # sensor2_model = build_sensor_model_2d(input_shapes[1], model_config)
  426. # sensor3_model = build_sensor_model_2d(input_shapes[2], model_config)
  427. # sensor4_model = build_sensor_model_2d_sm(input_shapes[3], model_config)
  429. sensor1_model = build_sensor_model_2d_2(input_shapes[0], model_config)
  430. sensor2_model = build_sensor_model_2d_2(input_shapes[1], model_config)
  431. sensor3_model = build_sensor_model_2d_2(input_shapes[2], model_config)
  432. sensor4_model = build_sensor_model_2d_sm_2(input_shapes[3], model_config)
  434. #sensor1_model = build_sensor_model_2d_TRANS(input_shapes[0], model_config)
  435. #sensor2_model = build_sensor_model_2d_TRANS(input_shapes[1], model_config)
  436. #sensor3_model = build_sensor_model_2d_TRANS(input_shapes[2], model_config)
  437. #sensor4_model = build_sensor_model_2d_sm(input_shapes[3], model_config)
  440. # Define inputs for each sensor
  441. sensor1_input = Input(shape=input_shapes[0])
  442. sensor2_input = Input(shape=input_shapes[1])
  443. sensor3_input = Input(shape=input_shapes[2])
  444. sensor4_input = Input(shape=input_shapes[3])
  446. # Get the outputs from each sub-model
  447. sensor1_output = sensor1_model(sensor1_input)
  448. # sensor2_output = sensor2_model(sensor2_input)
  449. # sensor3_output = sensor3_model(sensor3_input)
  450. # sensor4_output = sensor4_model(sensor4_input)
  452. # Concatenate the outputs
  453. # concatenated = layers.concatenate([sensor1_output, sensor2_output, sensor3_output, sensor4_output])
  454. concatenated = sensor1_output
  456. # Add Dense and Dropout layers
  457. x = layers.Dense(model_config['dense_units'], activation='relu')(concatenated)
  458. x = layers.Dropout(model_config['dropout_rate'])(x)
  459. output = layers.Dense(1, activation='sigmoid', dtype='float32')(x)
  460. #output = layers.Dense(1)(x)
  462. initial_learning_rate = model_config['lr']
  463. decay_steps = model_config['lr_decay_steps']
  465. # Create the learning rate schedule
  466. lr_schedule = tf.keras.optimizers.schedules.CosineDecay(
  467. initial_learning_rate=initial_learning_rate,
  468. decay_steps=decay_steps,
  469. alpha=model_config['lr_alpha']
  471. )
  473. optimizer = Adam(learning_rate=lr_schedule)
  475. # Create and compile the model
  476. model = Model(inputs=[sensor1_input, sensor2_input, sensor3_input, sensor4_input], outputs=output)
  478. #loss_fn = tf.keras.losses.BinaryCrossentropy()
  479. loss_fn = tf.keras.losses.BinaryFocalCrossentropy(gamma=model_config['loss_gamma'], alpha=model_config['loss_alpha'])
  481. model.compile(optimizer=optimizer,
  482. loss=loss_fn,
  483. metrics=[keras.metrics.AUC(),
  484. keras.metrics.SpecificityAtSensitivity(0.99),
  485. keras.metrics.SensitivityAtSpecificity(0.99)]
  486. )
  490. return model
  494. def feature_model_1D(input_dim,model_config):
  495. inputs = Input(shape=(input_dim,), name="input_features")
  497. # First Dense Layer
  498. x = tf.keras.layers.Dense(128, activation='relu', name="dense_1")(inputs)
  499. x = tf.keras.layers.BatchNormalization(name="batch_norm_1")(x)
  500. x = tf.keras.layers.Dropout(0.3, name="dropout_1")(x)
  502. # Second Dense Layer
  503. x = tf.keras.layers.Dense(64, activation='relu', name="dense_2")(x)
  504. x = tf.keras.layers.BatchNormalization(name="batch_norm_2")(x)
  505. x = tf.keras.layers.Dropout(0.3, name="dropout_2")(x)
  507. # Third Dense Layer
  508. x = tf.keras.layers.Dense(32, activation='relu', name="dense_3")(x)
  509. x = tf.keras.layers.BatchNormalization(name="batch_norm_3")(x)
  510. x = tf.keras.layers.Dropout(0.3, name="dropout_3")(x)
  512. # Output Layer
  513. outputs = tf.keras.layers.Dense(1, activation='sigmoid', name="output")(x)
  515. # Create the model
  516. model = tf.keras.Model(inputs=inputs, outputs=outputs, name="sleep_awake_classifier")
  518. loss_fn = tf.keras.losses.BinaryFocalCrossentropy(gamma=3, alpha=0.9)
  519. model.compile(
  520. optimizer=tf.keras.optimizers.Adam(learning_rate=model_config['lr']),
  521. loss=loss_fn,
  522. metrics=[keras.metrics.AUC(),
  523. keras.metrics.SpecificityAtSensitivity(0.99),
  524. keras.metrics.SensitivityAtSpecificity(0.99)]
  525. )
  527. return model
  529. def wrap_model_for_single_input(original_model, input_shapes):
  530. """
  531. Wraps a multi-input model to accept a single concatenated input tensor.
  533. Args:
  534. original_model (tf.keras.Model): The original multi-input model.
  535. input_shapes (list of tuples): Shapes of the inputs for the original model.
  537. Returns:
  538. tf.keras.Model: The wrapped model with a single input tensor.
  539. """
  540. # Calculate the total number of features in the concatenated input
  541. total_features = sum(np.prod(shape) for shape in input_shapes)
  543. # Define a new single input tensor
  544. single_input = Input(shape=(total_features,))
  546. # Split the single input tensor into the original input tensors
  547. split_tensors = []
  548. start_idx = 0
  549. for shape in input_shapes:
  550. num_features = np.prod(shape)
  551. end_idx = start_idx + num_features
  552. # Extract the slice corresponding to this input and reshape
  553. slice_tensor = single_input[..., start_idx:end_idx]
  554. reshaped_tensor = tf.reshape(slice_tensor, [-1, *shape]) # Ensure correct reshaping
  555. split_tensors.append(reshaped_tensor)
  556. start_idx = end_idx
  558. # Pass the split inputs to the original model
  559. output = original_model(split_tensors)
  561. # Create and return the wrapped model
  562. wrapped_model = Model(inputs=single_input, outputs=output)
  563. return wrapped_model
  565. if __name__ == '__main__':
  567. # input_shapes = (1500,3,3)
  569. # num_classes = 2 # Adjust as per your number of classes
  571. # model_config = {
  572. # 'lr': 0.001,
  573. # 'num_filters_1': 8,
  574. # 'num_filters_2': 16,
  575. # 'num_filters_3':32,
  576. # 'num_filters_4':64,
  577. # 'num_filters_1_sm': 8,
  578. # 'num_filters_2_sm': 16,
  579. # 'kernel_size_1': (3, 1),
  580. # 'kernel_size_2': (3, 1),
  581. # 'kernel_size_1_sm': (2, 1),
  582. # 'lstm_units': 32,
  583. # 'dropout_rate': 0.2,
  584. # 'dense_units': 64,
  585. # 'l2_regularization': 0.001,
  586. # 'pooling_size': (2, 1),
  587. # 'num_heads': 8, # Number of heads in Transformer block
  588. # 'ff_dim': 128, # Feed-forward layer size in Transformer block
  589. # 'loss_gamma': 4,
  590. # 'loss_alpha': 0.2,
  591. # 'lr_alpha': 0.5,
  592. # 'lr_decay_steps': 12100
  593. # }
  595. # model_config = {
  596. # 'lr': 0.001,
  597. # 'num_filters_1': 16,
  598. # 'num_filters_2': 32,
  599. # 'num_filters_3':64,
  600. # 'dropout_rate': 0.3,
  601. # 'dense_units': 128,
  602. # 'l2_regularization': 0.0001,
  603. # 'loss_gamma': 4,
  604. # 'loss_alpha': 0.2,
  605. # 'lr_alpha': 0.1,
  606. # 'lr_decay_steps': 12100
  607. # }
  609. # model = build_stacked_model(input_shapes, num_classes, model_config)
  610. # model.summary()
  611. # random_data = np.random.rand(1, 1500,3,3).astype(np.float32)
  612. # output = model.predict(random_data)
  614. # # Define input shape and number of classes
  615. ppg_input_shape = (1500, 3, 1) # Adjust as per your data
  616. gyro_input_shape = (1500, 3, 1) # Adjust as per your data
  617. acc_input_shape = (1500, 3, 1) # Adjust as per your data
  618. temp_input_shape = (1500, 3, 1)
  620. input_shapes = [ppg_input_shape, gyro_input_shape, acc_input_shape, temp_input_shape]
  622. num_classes = 2 # Adjust as per your number of classes
  624. model_config = {
  625. 'lr': 0.001,
  626. 'num_filters_1': 8,
  627. 'num_filters_2': 16,
  628. 'num_filters_3':32,
  629. 'num_filters_4':64,
  630. 'num_filters_1_sm': 8,
  631. 'num_filters_2_sm': 16,
  632. 'kernel_size_1': (3, 1),
  633. 'kernel_size_2': (3, 1),
  634. 'kernel_size_1_sm': (2, 1),
  635. 'lstm_units': 32,
  636. 'dropout_rate': 0.2,
  637. 'dense_units': 64,
  638. 'l2_regularization': 0.001,
  639. 'pooling_size': (2, 1),
  640. 'num_heads': 8, # Number of heads in Transformer block
  641. 'ff_dim': 128, # Feed-forward layer size in Transformer block
  642. 'loss_gamma': 4,
  643. 'loss_alpha': 0.2,
  644. 'lr_alpha': 0.5,
  645. 'lr_decay_steps': 12100
  646. }
  648. # Build and summarize the model
  649. model = build_combined_model(input_shapes, num_classes, model_config)
  651. # Wrap the model for a single concatenated input
  652. wrapped_model = wrap_model_for_single_input(
  653. model,
  654. input_shapes=input_shapes
  655. )
  657. # Save the wrapped model
  658. wrapped_model.save('wrapped_model')
  660. converter = tf.lite.TFLiteConverter.from_saved_model('wrapped_model')
  661. converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS, tf.lite.OpsSet.SELECT_TF_OPS]
  662. converter._experimental_lower_tensor_list_ops = False
  663. tflite_model = converter.convert()
  665. try:
  666. tflite_model = converter.convert()
  667. # Save the TensorFlow Lite model
  668. with open('wrapped_model.tflite', 'wb') as f:
  669. f.write(tflite_model)
  670. print("TensorFlow Lite model conversion successful.")
  671. except Exception as e:
  672. print(f"Error during TFLite conversion: {e}")
  674. plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True,expand_nested=True)
  675. model.summary()
  677. # # Create synthetic test input data
  678. # ppg_data = np.random.rand(1, *ppg_input_shape).astype(np.float32) # Batch size of 1
  679. # gyro_data = np.random.rand(1, *gyro_input_shape).astype(np.float32)
  680. # acc_data = np.random.rand(1, *acc_input_shape).astype(np.float32)
  681. # temp_data = np.random.rand(1, *temp_input_shape).astype(np.float32)
  683. # # Print shapes of the synthetic data
  684. # print("PPG data shape:", ppg_data.shape)
  685. # print("Gyro data shape:", gyro_data.shape)
  686. # print("Acc data shape:", acc_data.shape)
  687. # print("Temp data shape:", temp_data.shape)
  689. # # Pass the synthetic data through the model to get the output
  690. # output = model.predict([ppg_data, gyro_data, acc_data, temp_data])
  691. # #output = model.predict([ppg_data, gyro_data, acc_data])
  693. # # Print the model output
  694. # print("Model output:", output)
  696. # input_dim = 345 # Replace with the number of features in your dataset
  697. # model = feature_model_1D(input_dim, model_config)
  698. # model.summary()

model.py at commit d066920, no license · at the source

Overview

Authors: Yumna Anwar1, Kanika Bansal1,2, Murat Kucukosmanoglu3, Quang Dang1, Cody Feltch4, Justin Brooks1,3,4, Nilanjan Banerjee1,4
ORCID iDs: Cody Feltch
  1. Department of Computer Science and Electrical Engineering, University of Maryland Baltimore County,Baltimore, MD USA
  2. Humans in Complex Systems Division, US Army DEVCOM Army Research Laboratory,Aberdeen, MD USA
  3. D-Prime LLC, McLean, VA 22101 USA
  4. Tanzen Medical Inc.,Severna Park, MD 21146 USA
Institutions: University of Maryland, Baltimore County (United States); Humans in Complex Systems Division, US Army DEVCOM Army Research Laboratory,Aberdeen, MD USA
Journal: Scientific reports, volume 16, issue 1, article 9930
Dates: received 24 June 2025; accepted 25 February 2026; published online 12 March 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41598-026-42310-8 · PMID 41820476 · PMCID PMC13018206 · OpenAlex W7135013274
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: other (modality), human (organism), ADHD (population), methods / tools (subfield)
Methods: Spectral & time-frequency, Connectivity, Machine learning, Statistics, Preprocessing, Physiology & signal measures
Keywords: Sleep classification, ADHD, Wearable sensors, RestEaze, Deep learning, CNN–BiLSTM, Biomarkers, Health care, Medical research
MeSH: Attention Deficit Disorder with Hyperactivity*, Sleep*, Wakefulness*, Wearable Electronic Devices*, Accelerometry, Child, Convolutional Neural Networks, Deep Learning, Female, Humans, Leg, Male, Photoplethysmography, Polysomnography, Sleep Duration, Support Vector Machine (* major topic)
Topic: Sleep and related disorders (Experimental and Cognitive Psychology, Psychology), according to OpenAlex
Funding: NIH (1R43MH133495-01A1)
Citations: not cited yet (Europe PMC); 27 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repository

Its files are read in the Code ↔ Paper reader above, with 8 matches between paragraphs and lines of code.

Madeby7/Sleep-State-Detection

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: d0669200bfae7882b6457d48fb3fc41d04e49551, 23 February 2026
Languages: Python (3), Jupyter (1)
Size: 30 files, 4 scripts
Software Heritage: not archived
Found in: “Data availability”
Holds: README, 1 notebook
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (4 files), pandas (3 files), TensorFlow (3 files), Matplotlib (2 files), NeuroKit2 (2 files), scikit-learn (2 files), SciPy (2 files), Keras (1 file), Plotly (1 file), seaborn (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
5 files
At the source: github.com/Madeby7/Sleep-State-Detection

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 4 scripts, each with its path and the digest of its content;
  • 8 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Code and data availability statement

The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41598-026-42310-8.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 30 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 7 authors, 9 keywords, 16 MeSH terms, 1 funder, 23 references.

Cite

This paper

Anwar, Y., Bansal, K., Kucukosmanoglu, M., Dang, Q., Feltch, C., Brooks, J., & Banerjee, N. (2026). Sleep awake detection from leg-worn wearables using deep sensor fusion. Scientific reports, 16(1), 9930. https://doi.org/10.1038/s41598-026-42310-8

BibTeX

@article{anwar2026sleep,
author = {Anwar, Yumna and Bansal, Kanika and Kucukosmanoglu, Murat and Dang, Quang and Feltch, Cody and Brooks, Justin and Banerjee, Nilanjan},
title = {{Sleep awake detection from leg-worn wearables using deep sensor fusion}},
journal = {Scientific reports},
year = {2026},
month = mar,
volume = {16},
number = {1},
pages = {9930},
publisher = {Nature Publishing Group},
issn = {2045-2322},
doi = {10.1038/s41598-026-42310-8},
url = {https://doi.org/10.1038/s41598-026-42310-8},
pmid = {41820476},
pmcid = {PMC13018206}
}

RIS

TY - JOUR
AU - Anwar, Yumna
AU - Bansal, Kanika
AU - Kucukosmanoglu, Murat
AU - Dang, Quang
AU - Feltch, Cody
AU - Brooks, Justin
AU - Banerjee, Nilanjan
TI - Sleep awake detection from leg-worn wearables using deep sensor fusion
T2 - Scientific reports
J2 - Sci Rep
PY - 2026
DA - 2026/03/12
VL - 16
IS - 1
SP - 9930
SN - 2045-2322
PB - Nature Publishing Group
DO - 10.1038/s41598-026-42310-8
UR - https://doi.org/10.1038/s41598-026-42310-8
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41598-026-42310-8",
"type": "article-journal",
"title": "Sleep awake detection from leg-worn wearables using deep sensor fusion",
"container-title": "Scientific reports",
"author": [
{
"family": "Anwar",
"given": "Yumna"
},
{
"family": "Bansal",
"given": "Kanika"
},
{
"family": "Kucukosmanoglu",
"given": "Murat"
},
{
"family": "Dang",
"given": "Quang"
},
{
"family": "Feltch",
"given": "Cody"
},
{
"family": "Brooks",
"given": "Justin"
},
{
"family": "Banerjee",
"given": "Nilanjan"
}
],
"container-title-short": "Sci Rep",
"volume": "16",
"issue": "1",
"page": "9930",
"DOI": "10.1038/s41598-026-42310-8",
"PMID": "41820476",
"PMCID": "PMC13018206",
"ISSN": "2045-2322",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41598-026-42310-8",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
12
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1093/sleepadvances/zpag051 [code]
What matters beyond model choice for wearable sleep staging? How personalization, evaluation choices, and easy-to-classify wake impact performance.
Journal: Sleep advances : a journal of the Sleep Research Society
In common: Keras, TensorFlow, seaborn, 5 other tools, other, methods / tools, 3 references
[2] doi:10.1038/s41597-025-05174-7 [code]
A large-scale MEG and EEG dataset for object recognition in naturalistic scenes
Journal: n/a
In common: Keras, TensorFlow, Plotly, 6 other tools, methods / tools
[3] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: Keras, TensorFlow, Plotly, 6 other tools
[4] doi:10.1038/s41467-026-75455-1 [code]
Shared latent representations of speech production for cross-patient speech decoding.
Journal: Nature communications
In common: Keras, TensorFlow, Plotly, 6 other tools
[5] doi:10.1186/s12880-026-02481-2 [code]
Deep learning-based neuroanatomical profiling reveals population-specific brain changes in multiple sclerosis: a large-scale Middle Eastern study.
Journal: BMC medical imaging
In common: Keras, TensorFlow, Plotly, 6 other tools
[6] doi:10.1016/j.xcrm.2026.102766 [code]
A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: Keras, TensorFlow, Plotly, 6 other tools
[7] doi:10.1162/imag.a.1164 [code]
Bias and generalizability of brain age prediction models: A multi-cohort evaluation with anatomical and interpretability insights.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Keras, TensorFlow, Plotly, 6 other tools
[8] doi:10.1523/eneuro.0023-26.2026 [code]
Real-Time Segmentation and Classification of Birdsong Syllables for Learning Experiments.
Journal: eNeuro
In common: Keras, TensorFlow, Plotly, 6 other tools
[9] doi:10.3389/fnsys.2026.1822122 [code]
Convergence-divergence circuits for multimodal integration of innate and learned opponent valences.
Journal: Frontiers in systems neuroscience
In common: Keras, TensorFlow, Plotly, 6 other tools
[10] doi:10.64898/2026.05.06.26352540 [code]
Generating synthetic tau-PET scans in Alzheimer’s disease from MRI, blood biomarkers and demographics with deep learning
Journal: medRxiv (preprint)
In common: Keras, TensorFlow, seaborn, 5 other tools, other

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.