Optimizing RAM utilization during dataset loading (#2)

- add venv folder and memory mapped files to gitignore (14ec4ba9bf703563dc2fe7dba6d8921a15b19937)
- add pycache folder (b4ce5310d64c155c6bb37673730777584f207e6d)
- add preprocessed dataset (55635196d2682016f5fb21c09e774dc46ba6a8a7)
- add RAM utilization note (ea1a1e5bfbd3c96cbce2530bb085d1c5d88b5e2e)

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+.venv/
+*.npy

README.md

@@ -43,6 +43,9 @@ If you use this dataset in your research, please cite it as follows:
 
 To get started with the **Fall Prediction Dataset for Humanoid Robots**, follow the steps below:
 
+### 0. Clone the repository
+Please make sure that you have installed git large file support (git-lfs) before cloning this repository.
+
 ### 1. Set Up a Virtual Environment
 
 It's recommended to create a virtual environment to isolate dependencies. You can do this with the following command:
@@ -70,13 +73,20 @@ Once the virtual environment is active, install the necessary packages by runnin
 ```bash
 pip install -r requirements.txt
 ```
+If you have trouble downloading the requirements, check your internet connection. Alternatively, try increasing the pip timeout or upgrading your pip installation:
+```bash
+# Increase the timeout by 120 seconds
+pip install --default-timeout=120 -r requirements.txt
+# or upgrade pip
+python -m pip install --upgrade pip
+```
 
 ### 3. Run the Example Script
 
-To load and use the dataset for training a simple LSTM model, run the `usage_example.py` script:
+To load and use the plain csv dataset for training a simple LSTM model, run the `plain_dataset_usage_example.py` script (RAM utilisation exceeds 16 GB):
 
 ```bash
-python usage_example.py
+python plain_dataset_usage_example.py
 ```
 
 This script demonstrates how to:
@@ -86,7 +96,23 @@ This script demonstrates how to:
 - Train a basic LSTM model to predict falls
 - Evaluate the model on the test set
 
-Make sure to check the script and adjust the dataset paths if necessary. For further details, see the comments within the script.
+To load and use a already prepared dataset, with reduced RAM utilisation, for training a simple LSTM model, run the `lightweight_dataset_usage_example.py` script (RAM utilisation less than 2 GB):
+
+```bash
+python lightweight_dataset_usage_example.py
+```
+
+This script demonstrates how to:
+- Convert the csv dataset into a memory mapped file
+- Load the memory mapped version of the dataset
+- Train a basic LSTM model to predict falls
+- Evaluate the model on the test set
+
+The script `convert_and_load_dataset.py` used by the lightweight example demonstrates how to:
+- Select the relevant sensor columns
+- Split the data into training and test sets
+
+Make sure to check the scripts and adjust the dataset paths if necessary. For further details, see the comments and docstrings within the scripts.
 
 
 ---

convert_and_load_dataset.py

@@ -0,0 +1,233 @@
+# Helper functions to reduce RAM utilization
+# Please install dependencies before:
+# pip install -r requirements.txt
+
+# Import necessary libraries
+import os
+import pickle
+import tarfile
+import pandas as pd
+import numpy as np
+
+from tqdm import tqdm
+from tqdm import trange
+from pathlib import Path
+from sklearn.model_selection import train_test_split
+
+
+def delete_temporary_files():
+    if Path('tmp_dataset_X.pkl').exists():
+        os.remove('tmp_dataset_X.pkl')
+    if Path('tmp_dataset_y.pkl').exists():
+        os.remove('tmp_dataset_y.pkl')
+    if Path('tmp_dataset_X.npy').exists():
+        os.remove('tmp_dataset_X.npy')
+    if Path('tmp_dataset_y.npy').exists():
+        os.remove('tmp_dataset_y.npy')
+
+    if Path('tmp_X_train.pkl').exists():
+        os.remove('tmp_X_train.npy')
+    if Path('tmp_y_train.pkl').exists():
+        os.remove('tmp_y_train.npy')
+    if Path('tmp_X_test.npy').exists():
+        os.remove('tmp_X_test.npy')
+    if Path('tmp_y_test.npy').exists():
+        os.remove('tmp_y_test.npy')
+
+
+
+def load_dataset(file_path='dataset.tar.bz2'):
+    """
+    Decompress and load already prepared dataset.
+
+    Parameters:
+        file_path (str): Path to the compressed version of the prepared dataset (default dataset.tar.bz2)
+    
+    Returns:
+        X_train (np.memmap): Memory-mapped NumPy array of the X training data
+        X_test (np.memmap): Memory-mapped NumPy array of the X test data
+        y_train (np.memmap): Memory-mapped NumPy array of the y training data
+        y_test (np.memmap): Memory-mapped NumPy array of the y test data
+    """
+
+    # Return the pepared dataset if it already exists
+    if Path('X_train.npy').exists() and Path('y_train.npy').exists() and Path('X_test.npy').exists() and Path('y_test.npy').exists():
+        X_train = np.load('X_train.npy', mmap_mode='r')
+        y_train = np.load('y_train.npy', mmap_mode='r')
+        X_test = np.load('X_test.npy', mmap_mode='r')
+        y_test = np.load('y_test.npy', mmap_mode='r')
+
+        return X_train, X_test, y_train, y_test
+    
+    # Decompress memory mapped files
+    if Path(file_path).exists():
+        with tarfile.open(file_path) as dataset:
+            dataset.extractall(path='.')
+        
+        # Load the dataset
+        dataset_X = np.load('dataset_X.npy', mmap_mode='r')
+        dataset_y = np.load('dataset_y.npy', mmap_mode='r')
+
+        # Create a train test split with memory mapped files
+        X_train, X_test, y_train, y_test = train_test_split_memmapped(dataset_X, dataset_y)
+
+        return X_train, X_test, y_train, y_test
+    else:
+        print('ERROR: file not found')
+
+def convert_and_load_dataset(file_path='dataset.csv.bz2'):
+    """
+    Converts a CSV dataset into a NumPy memory-mapped dataset and load it.
+
+    This function transforms a given CSV dataset into a memory-mapped NumPy array. 
+    Memory-mapping helps to reduce RAM usage by loading the dataset in smaller chunks. 
+    However, it requires additional disk space during the conversion process.
+
+    Parameters:
+        file_path (str): Path to the CSV dataset file (default dataset.csv.bz2)
+    
+    Returns:
+        X_train (np.memmap): Memory-mapped NumPy array of the X training data
+        X_test (np.memmap): Memory-mapped NumPy array of the X test data
+        y_train (np.memmap): Memory-mapped NumPy array of the y training data
+        y_test (np.memmap): Memory-mapped NumPy array of the y test data
+    """
+
+    # Return the pepared dataset if it already exists
+    if Path('X_train.npy').exists() and Path('y_train.npy').exists() and Path('X_test.npy').exists() and Path('y_test.npy').exists():
+        return load_dataset()
+
+    # Load and prepare dataset
+    delete_temporary_files()
+    with open('tmp_dataset_X.pkl', 'ab') as tmp_dataset_X, open('tmp_dataset_y.pkl', 'ab') as tmp_dataset_y:
+        shape = None
+        num_of_chunks = 0
+
+        # Load the dataset from a local file path
+        # Replace with Huggingface dataset call if applicable
+        for real_data_chunk in tqdm(pd.read_csv(file_path, compression='bz2', chunksize=4096), desc='Read and Prepare Dataset'):
+            # Select relevant columns (replace these with actual column names from your dataset)
+            # Here we assume that the dataset contains sensor readings like gyroscope and accelerometer data
+            relevant_columns = ['gyro_x', 'gyro_y', 'gyro_z', 'acc_x', 'acc_y', 'acc_z', 'upright']
+            sensordata_chunk = real_data_chunk[relevant_columns]
+
+            # Split the data into features (X) and labels (y)
+            # 'fall_label' is assumed to be the column indicating whether a fall occurred
+            X_chunk = np.array(sensordata_chunk.drop(columns=['upright'])) # Replace 'fall_label' with the actual label column
+            y_chunk = np.array(sensordata_chunk['upright'])
+            
+            if shape is None:
+                # Preview the dataset
+                print('\n' + str(real_data_chunk.head()))
+
+            if shape is None:
+                shape = np.array(X_chunk.shape)
+            else:
+                shape[0] += X_chunk.shape[0]
+
+            pickle.dump(X_chunk, tmp_dataset_X)
+            pickle.dump(y_chunk, tmp_dataset_y)
+            num_of_chunks += 1
+
+    # Convert dataset into a memory-mapped array stored in a binary file on disk.
+    X_idx = 0
+    y_idx = 0
+    dataset_X = np.memmap('tmp_dataset_X.npy', mode='w+', dtype=np.float32, shape=(shape[0], shape[1], 1))
+    dataset_y = np.memmap('tmp_dataset_y.npy', mode='w+', dtype=np.float32, shape=(shape[0], 1))
+    with open('tmp_dataset_X.pkl', 'rb') as tmp_dataset_X, open('tmp_dataset_y.pkl', 'rb') as tmp_dataset_y:
+        for _ in trange(0, num_of_chunks, 1, desc='Convert Dataset'):
+            X_chunk = pickle.load(tmp_dataset_X)
+            y_chunk = pickle.load(tmp_dataset_y)
+
+            # Reshape data for LSTM input (assuming time-series data)
+            # Adjust the reshaping based on your dataset structure
+            for X_data in X_chunk:
+                dataset_X[X_idx] = np.expand_dims(X_data, axis=-1)
+                X_idx += 1
+            for y_data in y_chunk:
+                dataset_y[y_idx] = np.expand_dims(y_data, axis=-1)
+                y_idx += 1
+
+    # Delete temporary files
+    os.remove('tmp_dataset_X.pkl')
+    os.remove('tmp_dataset_y.pkl')
+
+    # Save the memory-mapped arrays
+    with open('dataset_X.npy', 'wb') as dataset_x_file, open('dataset_y.npy', 'wb') as dataset_y_file:
+        np.save(dataset_x_file, dataset_X, allow_pickle=False, fix_imports=True)
+        np.save(dataset_y_file, dataset_y, allow_pickle=False, fix_imports=True)
+    
+    # Delete temporary files
+    dataset_X._mmap.close()
+    dataset_y._mmap.close()
+    os.remove('tmp_dataset_X.npy')
+    os.remove('tmp_dataset_y.npy')
+
+    # Reload memory-mapped arrays
+    dataset_X = np.load('dataset_X.npy', mmap_mode='r')
+    dataset_y = np.load('dataset_y.npy', mmap_mode='r')
+
+    # Create a train test split with memory mapped files
+    X_train, X_test, y_train, y_test = train_test_split_memmapped(dataset_X, dataset_y)
+
+    return X_train, X_test, y_train, y_test
+
+
+def train_test_split_memmapped(dataset_X, dataset_y, test_size=0.2, random_state=42):
+    """
+    Create memory-mapped files for train and test datasets.
+
+    Parameters:
+        dataset_X (np.memmap): X part of the complete dataset
+        dataset_y (np.memmap): y part of the complete dataset
+        test_size (float): Propotion of the dataset used for the test split (default 0.2)
+        random_state (int): Random state used for repeatability (default 42)
+
+    Returns:
+        X_train (np.memmap): Memory-mapped NumPy array of the X training data
+        X_test (np.memmap): Memory-mapped NumPy array of the X test data
+        y_train (np.memmap): Memory-mapped NumPy array of the y training data
+        y_test (np.memmap): Memory-mapped NumPy array of the y test data
+    """
+    delete_temporary_files()
+
+    # Split data into training and test sets
+    idxs = np.arange(dataset_X.shape[0])
+    train_idx, test_idx = train_test_split(idxs, test_size=test_size, random_state=random_state)
+
+    # Create memory-mapped files for train and test sets
+    X_train = np.memmap('tmp_X_train.npy', dtype=dataset_X.dtype, mode='w+', shape=(len(train_idx), dataset_X.shape[1], 1))
+    y_train = np.memmap('tmp_y_train.npy', dtype=dataset_y.dtype, mode='w+', shape=(len(train_idx), dataset_y.shape[1]))
+    X_test = np.memmap('tmp_X_test.npy', dtype=dataset_X.dtype, mode='w+', shape=(len(test_idx), dataset_X.shape[1], 1))
+    y_test = np.memmap('tmp_y_test.npy', dtype=dataset_y.dtype, mode='w+', shape=(len(test_idx), dataset_y.shape[1]))
+
+    # Assign values to the train and test memmap arrays
+    X_train[:] = dataset_X[train_idx]
+    y_train[:] = dataset_y[train_idx]
+    X_test[:] = dataset_X[test_idx]
+    y_test[:] = dataset_y[test_idx]
+
+    # Save the memory-mapped arrays
+    with open('X_train.npy', 'wb') as X_train_file, open('y_train.npy', 'wb') as y_train_file, open('X_test.npy', 'wb') as X_test_file, open('y_test.npy', 'wb') as y_test_file:
+        np.save(X_train_file, X_train, allow_pickle=False, fix_imports=True)
+        np.save(y_train_file, y_train, allow_pickle=False, fix_imports=True)
+        np.save(X_test_file, X_test, allow_pickle=False, fix_imports=True)
+        np.save(y_test_file, y_test, allow_pickle=False, fix_imports=True)
+    
+    X_train._mmap.close()
+    y_train._mmap.close()
+    X_test._mmap.close()
+    y_test._mmap.close()
+
+    # Delete temporary files
+    os.remove('tmp_X_train.npy')
+    os.remove('tmp_y_train.npy')
+    os.remove('tmp_X_test.npy')
+    os.remove('tmp_y_test.npy')
+
+    X_train = np.load('X_train.npy', mmap_mode='r')
+    y_train = np.load('y_train.npy', mmap_mode='r')
+    X_test = np.load('X_test.npy', mmap_mode='r')
+    y_test = np.load('y_test.npy', mmap_mode='r')
+    
+    return X_train, X_test, y_train, y_test

dataset.tar.bz2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2b32bfbbc2d3dececb55185fc344bd8e1c0228c70fdb5970ba0b9c9e04216d9b
+size 100001092

lightweight_dataset_usage_example.py

@@ -0,0 +1,37 @@
+# Usage Example for the Fall Prediction Dataset
+# Please install dependencies before:
+# pip install -r requirements.txt
+
+# Import necessary libraries
+import tensorflow as tf
+
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense, LSTM, Dropout, Input
+from convert_and_load_dataset import load_dataset, convert_and_load_dataset
+
+
+# Example for local converting and loading (frist time usage take a while)
+# X_train, X_test, y_train, y_test = convert_and_load_dataset()
+
+# Example for local loading (first time usage may take a while)
+X_train, X_test, y_train, y_test = load_dataset()
+
+# Define a simple LSTM model
+model = Sequential()
+model.add(Input((X_train.shape[1], 1)))
+model.add(LSTM(64))
+model.add(Dropout(0.2))
+model.add(Dense(1, activation='sigmoid'))
+
+# Compile the model
+model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+
+# Train the model
+history = model.fit(X_train, y_train, epochs=10, batch_size=64, validation_data=(X_test, y_test))
+
+# Evaluate the model on the test set
+loss, accuracy = model.evaluate(X_test, y_test)
+print(f"Test Accuracy: {accuracy * 100:.2f}%")
+
+# You can save the model if needed
+# model.save('fall_prediction_model.h5')

usage_example.py → plain_dataset_usage_example.py

@@ -6,7 +6,7 @@
 import pandas as pd
 import tensorflow as tf
 from tensorflow.keras.models import Sequential
-from tensorflow.keras.layers import Dense, LSTM, Dropout
+from tensorflow.keras.layers import Dense, LSTM, Dropout, Input
 from sklearn.model_selection import train_test_split
 
 # Load the dataset from Huggingface or a local file path
@@ -36,6 +36,7 @@ X_test = X_test.values.reshape(X_test.shape[0], X_test.shape[1], 1)
 
 # Define a simple LSTM model
 model = Sequential()
+model.add(Input((X_train.shape[1], 1)))
 model.add(LSTM(64, input_shape=(X_train.shape[1], 1)))
 model.add(Dropout(0.2))
 model.add(Dense(1, activation='sigmoid'))

requirements.txt

@@ -1,3 +1,4 @@
+tqdm
 pandas
 tensorflow
 scikit-learn