Odtnhj

I would like to train an LSTM or GRU network in TensorFlow/Keras to continuously recognize whether a user is walking or not based on input from motion sensors (accelerometer and gyroscope). I have 50 input sequences with lengths varying from 581 to 5629 time steps and 6 features and 50 corresponding output sequences of boolean values. My problem is that I don't know how to feed the training data to the fit() method.

I know approximately what I need to do: I'd like to train with 5 batches of 10 sequences each, and for each batch I have to pad all but the longest sequence so all 10 sequences have the same lengths and apply masking. I just don't know how to build the data structures. I know that I can make one big 3D tensor of size (50,5629,6) and that works, but it's painfully slow, so I'd really like to make the sequence length of each batch as small as possible.

Here's the problem in code:

import tensorflow as tf
import numpy as np

# Load data from file
x_list, y_list = loadSequences("train.csv")

# x_list is now a list of arrays (n,6) of float64, where n is the timesteps
# and 6 is the number of features, sorted by increasing sequence lengths.
# y_list is a list of arrays (n,1) of Boolean.

x_train = # WHAT DO I WRITE HERE?
y_train = # AND HERE?

model = tf.keras.models.Sequential([
 tf.keras.layers.Masking(),
 tf.keras.layers.LSTM(32, return_sequences=True),
 tf.keras.layers.Dense(2, activation=tf.nn.softmax)
 ])
model.compile(optimizer='adam',
 loss='sparse_categorical_crossentropy',
 metrics=['accuracy'])
model.fit(x_train, y_train, batch_size=10, epochs=100)

You can do some thing like this

use generator function take a look at this link fit_generator look for fit_generator method.

def data_generater(batch_size):
print("reading data")
training_file = 'data_location', 'r')

# assuming data is in json format so feels free to change accordingly

training_set = json.loads(training_file.read())
training_file.close()

batch_i = 0 # Counter inside the current batch vector
batch_x = # The current batch's x data
batch_y = # The current batch's y data

while True:

 for obj in training_set:
 batch_x.append(your input sequences one by one)
 if obj['val'] == True:
 batch_y.append([1])
 elif obj['val'] == False:
 batch_y.append([0])
 batch_i += 1

 if batch_i == batch_size:
 # Ready to yield the batch
 # pad input to max length in the batch
 batch_x = pad_txt_data(batch_x)
 yield batch_x, np.array(batch_y)
 batch_x = 
 batch_y = 
 batch_i = 0

def pad_txt_data(arr):
# expecting arr to be in the shape of (10, m, 6)
paded_arr = 
prefered_len = len(max(arr, key=len))

# Now pad all your sequences to preferred length in the batch(arr)

return np.array(paded_arr)

and in the model

model = keras.Sequential()
model.add(keras.layers.Masking(mask_value=0., input_shape=(None,6)))
model.add(keras.layers.LSTM(32))
model.add(keras.layers.Dense(1, activation="softmax"))
model.compile(optimizer="Adam", loss='categorical_crossentropy', metrics=['categorical_accuracy'])
model.fit_generator(data_generater(10), steps_per_epoch=5, epochs=10)

Batch_size, steps_per_epoch, epoch can be different.
Generally

steps_per_epoch = (number of sequences/batch_size)

Note: Form reading your description your task appears to be Binary classification problem not like an Sequence to sequence problem. A good example for sequence to sequence is a language translation. Just google around you will find what i mean.

And if you really want to see the difference in training times I suggest using a GPU if available and CuDNNLSTM.

In case it helps someone, here's how I ended up implementing a solution:

import tensorflow as tf
import numpy as np

# Load data from file
x_list, y_list = loadSequences("train.csv")

# x_list is now a list of arrays (m,n) of float64, where m is the timesteps
# and n is the number of features.
# y_list is a list of arrays (m,1) of Boolean.
assert len(x_list) == len(y_list)
num_sequences = len(x_list)
num_features = len(x_list[0][0])
batch_size = 10
batches_per_epoch = 5
assert batch_size * batches_per_epoch == num_sequences

def train_generator():
 # Sort by length so the number of timesteps in each batch is minimized
 x_list.sort(key=len)
 y_list.sort(key=len)
 # Generate batches
 while True:
 for b in range(batches_per_epoch):
 longest_index = (b + 1) * batch_size - 1
 timesteps = len(x_list[longest_index])
 x_train = np.zeros((batch_size, timesteps, num_features))
 y_train = np.zeros((batch_size, timesteps, 1))
 for i in range(batch_size):
 li = b * batch_size + i
 x_train[i, 0:len(x_list[li]), :] = x_list[li]
 y_train[i, 0:len(y_list[li]), 0] = y_list[li]
 yield x_train, y_train

model = tf.keras.models.Sequential([
 tf.keras.layers.Masking(mask_value=0., input_shape=(None,num_features)),
 tf.keras.layers.LSTM(32, return_sequences=True),
 tf.keras.layers.Dense(2, activation=tf.nn.softmax)
 ])
model.compile(optimizer='adam',
 loss='sparse_categorical_crossentropy',
 metrics=['accuracy'])
model.fit_generator(train_generator(), steps_per_epoch=batches_per_epoch, epochs=100)