{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Getting Started with Minerva for Human Activity Recognition\n", "\n", "Human Activity Recognition (HAR) is a challenging task that involves identifying actions performed by individuals based on sensor data—typically time-series signals from accelerometers and gyroscopes.\n", "\n", "In this notebook, we will use Minerva to train and evaluate an [1D ResNet-SE](https://ieeexplore.ieee.org/document/9771436) model from scratch for classifying human activities using [DAGHAR Dataset](https://www.nature.com/articles/s41597-024-03951-4).\n", "\n", "Thus, this notebook is a step-by-step guide to get you started with Minerva for HAR.\n", "It comprehends the following steps:\n", "\n", "1. Data Preparation\n", "2. Model Creation\n", "3. Model Training\n", "4. Model Evaluation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Imports" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.10/dist-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n" ] } ], "source": [ "from pathlib import Path\n", "\n", "import lightning as L\n", "import matplotlib.pyplot as plt\n", "import torch\n", "from torchmetrics import Accuracy\n", "\n", "from minerva.data.readers.csv_reader import CSVReader\n", "from minerva.data.datasets.base import SimpleDataset\n", "from minerva.data.data_modules.base import MinervaDataModule\n", "from minerva.models.nets.time_series.resnet import ResNetSE1D_5\n", "from minerva.transforms import Reshape, CastTo, TransformPipeline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Data Preparation\n", "\n", "We begin by preparing the data required for training and evaluation.\n", "\n", "For this tutorial, we will use the [standardized view of the DAGHAR Dataset](https://zenodo.org/records/13987073), as introduced in the following paper:\n", "\n", "```latex\n", "Napoli, O., Duarte, D., Alves, P., Soto, D.H.P., de Oliveira, H.E., Rocha, A., Boccato, L. and Borin, E., 2024. \n", "A benchmark for domain adaptation and generalization in smartphone-based human activity recognition. \n", "Scientific Data, 11(1), p.1192.\n", "```\n", "\n", "This dataset includes time-series data from two tri-axial sensors—an accelerometer and a gyroscope—collected via smartphones. It is organized into six different datasets:\n", "- KuHar \n", "- MotionSense \n", "- RealWorld-waist \n", "- RealWorld-thigh \n", "- UCI \n", "- WISDM \n", "\n", "In this notebook, we will work with the **standardized view of the MotionSense** dataset.\n", "\n", "You can download and extract the dataset using the commands below (`wget` and `unzip`):" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "!wget https://zenodo.org/records/13987073/files/standardized_view.zip?download=1 -O daghar_standardized_view.zip\n", "!mkdir -p datasets/DAGHAR\n", "!unzip -o daghar_standardized_view.zip -d datasets/DAGHAR/\n", "!rm daghar_standardized_view.zip" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "Once extracted, the folder structure will look like this:\n", "\n", "```tree\n", "daghar_standardized_view/standardized_view\n", "├── KuHar\n", "│ ├── train.csv\n", "│ ├── test.csv\n", "│ └── val.csv\n", "├── MotionSense\n", "│ ├── train.csv\n", "│ ├── test.csv\n", "│ └── val.csv\n", "├── RealWorld_waist\n", "│ ├── train.csv\n", "│ ├── test.csv\n", "│ └── val.csv\n", "├── RealWorld_thigh\n", "│ ├── train.csv\n", "│ ├── test.csv\n", "│ └── val.csv\n", "├── UCI\n", "│ ├── train.csv\n", "│ ├── test.csv\n", "│ └── val.csv\n", "└── WISDM\n", " ├── train.csv\n", " ├── test.csv\n", " └── val.csv\n", "```\n", "\n", "Each dataset is split into `train.csv`, `val.csv`, and `test.csv` files. Each file contains time-series data with the following structure:\n", "\n", "| Column Range | Description | Pattern to match |\n", "|-------------------------------|---------------------------------------------|-----------------------------|\n", "| `accel-x-0` to `accel-x-59` | 60 time steps of accelerometer x-axis | `accel-x-*` |\n", "| `accel-y-0` to `accel-y-59` | 60 time steps of accelerometer y-axis | `accel-y-*` |\n", "| `accel-z-0` to `accel-z-59` | 60 time steps of accelerometer z-axis | `accel-z-*` |\n", "| `gyro-x-0` to `gyro-x-59` | 60 time steps of gyroscope x-axis | `gyro-x-*` |\n", "| `gyro-y-0` to `gyro-y-59` | 60 time steps of gyroscope y-axis | `gyro-y-*` |\n", "| `gyro-z-0` to `gyro-z-59` | 60 time steps of gyroscope z-axis | `gyro-z-*` |\n", "| `standard activity code` | Encoded activity label | `standard activity code` |\n", "\n", "Each row represents one sample, composed of 6 channels (3 from each sensor) and 60 time steps per channel, representing 3 seconds of data at a sampling rate of 20 Hz.\n", "The \"Pattern to match\" column indicates the regex pattern used to identify the columns in the dataset.\n", "\n", "All datasets in DAGHAR share the same structure and label set. The activity codes are mapped as follows:\n", "\n", "| Standard Activity Code | Activity |\n", "|------------------------|--------------|\n", "| 0 | Sit |\n", "| 1 | Stand |\n", "| 2 | Walk |\n", "| 3 | Stair-up |\n", "| 4 | Stair-down |\n", "| 5 | Run |\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.1. Creating Data Readers and Datasets\n", "\n", "In Minerva, we can create readers, which are responsible for loading a single unit of data in a ordered way. It is like an ordered iterator that loads data from a source. A dataset is a collection of readers and transforms associated to each reader.\n", "We will create two readers for each split of the dataset (train, validation, and test): the data reader and label reader. For this purpose, we will use `CSVReader` that loads data from CSV files, select the columns that match the regex patterns, and reshape it to a format suitable for training.\n", "\n", "The data reader requires the following parameters:\n", "- `path`: Path to the CSV file.\n", "- `columns_to_select`: A list of regular expressions to select the columns from the CSV file, in order. In our case, we will use patterns indicated in the table above. Thus, we will select the columns that match the regex patterns `accel-x-*`, `accel-y-*`, `accel-z-*`, `gyro-x-*`, `gyro-y-*`, and `gyro-z-*`. This will give us a total of 360 columns (60 time steps * 6 channels), in order of pattern matched:\n", " - `accel-x-*`: 60 columns (`accel-x-0` to `accel-x-59`)\n", " - `accel-y-*`: 60 columns (`accel-y-0` to `accel-y-59`)\n", " - `accel-z-*`: 60 columns (`accel-z-0` to `accel-z-59`)\n", " - `gyro-x-*`: 60 columns (`gyro-x-0` to `gyro-x-59`)\n", " - `gyro-y-*`: 60 columns (`gyro-y-0` to `gyro-y-59`)\n", " - `gyro-z-*`: 60 columns (`gyro-z-0` to `gyro-z-59`)\n", "\n", "The label reader requires the following parameters:\n", "- `path`: Path to the CSV file.\n", "- `columns_to_select`: A single string indicating the column name to select. In our case, we will use `standard activity code`, which is the name of the column that contains the activity labels.\n", "- `cast_to`: The data type of the labels. In our case, we will use `np.int64`, which is a 64-bit integer. \n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train data reader length: 3558; Label reader length: 3558\n", "Validation data reader length: 420; Label reader length: 420\n", "Test data reader length: 1062; Label reader length: 1062\n" ] } ], "source": [ "# train_reader\n", "root_data_dir = Path(\"datasets/DAGHAR/standardized_view/MotionSense/\")\n", "\n", "# Train data and label readers\n", "train_data_reader = CSVReader(\n", " path=root_data_dir / \"train.csv\",\n", " columns_to_select=[\"accel-x-*\", \"accel-y-*\", \"accel-z-*\", \"gyro-x-*\", \"gyro-y-*\", \"gyro-z-*\"],\n", ")\n", "train_label_reader = CSVReader(\n", " path=root_data_dir / \"train.csv\",\n", " columns_to_select=\"standard activity code\",\n", " cast_to=\"int64\",\n", ")\n", "\n", "# Validation data and label readers\n", "validation_data_reader = CSVReader(\n", " path=root_data_dir / \"validation.csv\",\n", " columns_to_select=[\"accel-x-*\", \"accel-y-*\", \"accel-z-*\", \"gyro-x-*\", \"gyro-y-*\", \"gyro-z-*\"],\n", ")\n", "validation_label_reader = CSVReader(\n", " path=root_data_dir / \"validation.csv\",\n", " columns_to_select=\"standard activity code\",\n", " cast_to=\"int64\",\n", ")\n", "\n", "# Test data and label readers\n", "test_data_reader = CSVReader(\n", " path=root_data_dir / \"test.csv\",\n", " columns_to_select=[\"accel-x-*\", \"accel-y-*\", \"accel-z-*\", \"gyro-x-*\", \"gyro-y-*\", \"gyro-z-*\"],\n", ")\n", "test_label_reader = CSVReader(\n", " path=root_data_dir / \"test.csv\",\n", " columns_to_select=\"standard activity code\",\n", " cast_to=\"int64\",\n", ")\n", "\n", "print(f\"Train data reader length: {len(train_data_reader)}; Label reader length: {len(train_label_reader)}\")\n", "print(f\"Validation data reader length: {len(validation_data_reader)}; Label reader length: {len(validation_label_reader)}\")\n", "print(f\"Test data reader length: {len(test_data_reader)}; Label reader length: {len(test_label_reader)}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once the readers are set up, we can create a dataset using them. For this purpose, we'll use the `SimpleDataset` class, which takes two main inputs:\n", "\n", "- A list of **readers** (data sources) \n", "- A list of **transforms** (optional preprocessing steps)\n", "\n", "When an item at index `i` is requested from the dataset (e.g., `dataset[i]`), the following steps occur:\n", "\n", "1. The dataset retrieves the item at index `i` from `reader[0]` and applies the corresponding transform `transform[0]` (if any).\n", "2. It then retrieves the item at index `i` from `reader[1]` and applies `transform[1]` (if any).\n", "3. Finally, it returns a 2-element tuple containing the transformed outputs:\n", " - The first element is data: `transform[0](reader[0][i])`\n", " - The second element is label: `transform[1](reader[1][i])`\n", "\n", "This design enables flexible and consistent pairing of multiple data sources with their corresponding preprocessing logic-ideal for training, validation, or testing workflows.\n", "\n", "\n", "As transformation, we will use `Reshape` to reshape the data to the format required by the model, in our case `(6, 60)`, which means 6 channels (3 from each sensor) and 60 time steps per channel. We also use a `CastTo` transform to cast the data to `np.float32`, which is the data type required by the model and labels to `np.int64`." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "train_dataset = SimpleDataset(\n", " readers=[\n", " train_data_reader, # Reader for the data\n", " train_label_reader # Reader for the labels\n", " ],\n", " transforms=[\n", " TransformPipeline([Reshape((6, 60)), CastTo(\"float32\")]), # Transforms to apply to the data\n", " CastTo(\"int64\") # Cast the labels to int64\n", " ]\n", ")\n", "\n", "val_dataset = SimpleDataset(\n", " readers=[\n", " validation_data_reader, \n", " validation_label_reader\n", " ],\n", " transforms=[\n", " TransformPipeline([Reshape((6, 60)), CastTo(\"float32\")]), # Transforms to apply to the data\n", " CastTo(\"int64\") # Cast the labels to int64\n", " ]\n", ")\n", "\n", "test_dataset = SimpleDataset(\n", " readers=[test_data_reader, test_label_reader],\n", " transforms=[\n", " TransformPipeline([Reshape((6, 60)), CastTo(\"float32\")]), # Transforms to apply to the data\n", " CastTo(\"int64\") # Cast the labels to int64\n", " ]\n", ")" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train dataset\n", " ==================================================\n", " 📂 SimpleDataset Information \n", "==================================================\n", "📌 Dataset Type: SimpleDataset\n", " └── Reader 0: TabularReader(df=(3558, 728), columns_to_select=['accel-x-*', 'accel-y-*', 'accel-z-*', 'gyro-x-*', 'gyro-y-*', 'gyro-z-*'], cast_to=None, data_shape=None)\n", " │ └── Transform: TransformPipeline(transforms=[Reshape(shape=(6, 60)), CastTo(dtype=float32)])\n", " └── Reader 1: TabularReader(df=(3558, 728), columns_to_select=['standard activity code'], cast_to=int64, data_shape=None)\n", " │ └── Transform: CastTo(dtype=int64)\n", " │\n", " └── Total Readers: 2\n", "==================================================\n", "\n", "Validation dataset\n", " ==================================================\n", " 📂 SimpleDataset Information \n", "==================================================\n", "📌 Dataset Type: SimpleDataset\n", " └── Reader 0: TabularReader(df=(420, 728), columns_to_select=['accel-x-*', 'accel-y-*', 'accel-z-*', 'gyro-x-*', 'gyro-y-*', 'gyro-z-*'], cast_to=None, data_shape=None)\n", " │ └── Transform: TransformPipeline(transforms=[Reshape(shape=(6, 60)), CastTo(dtype=float32)])\n", " └── Reader 1: TabularReader(df=(420, 728), columns_to_select=['standard activity code'], cast_to=int64, data_shape=None)\n", " │ └── Transform: CastTo(dtype=int64)\n", " │\n", " └── Total Readers: 2\n", "==================================================\n", "\n", "Test dataset\n", " ==================================================\n", " 📂 SimpleDataset Information \n", "==================================================\n", "📌 Dataset Type: SimpleDataset\n", " └── Reader 0: TabularReader(df=(1062, 728), columns_to_select=['accel-x-*', 'accel-y-*', 'accel-z-*', 'gyro-x-*', 'gyro-y-*', 'gyro-z-*'], cast_to=None, data_shape=None)\n", " │ └── Transform: TransformPipeline(transforms=[Reshape(shape=(6, 60)), CastTo(dtype=float32)])\n", " └── Reader 1: TabularReader(df=(1062, 728), columns_to_select=['standard activity code'], cast_to=int64, data_shape=None)\n", " │ └── Transform: CastTo(dtype=int64)\n", " │\n", " └── Total Readers: 2\n", "==================================================\n", "\n" ] } ], "source": [ "print(f\"Train dataset\\n {train_dataset}\\n\")\n", "print(f\"Validation dataset\\n {val_dataset}\\n\")\n", "print(f\"Test dataset\\n {test_dataset}\\n\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's take a look at the first sample of the training dataset. \n", "As each sample has 6 channels and 60 time steps, the shape of the sample will be `(6, 60)`.\n", "The label will be a single integer representing the activity code.\n", "We can visualize the data using `matplotlib` to get an idea of what the data looks like." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The shape of the input is (6, 60) and the label is 5\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "sample_X, sample_y = train_dataset[800]\n", "print(f\"The shape of the input is {sample_X.shape} and the label is {sample_y}\")\n", "\n", "activity_labels = {\n", " 0: \"Sit\",\n", " 1: \"Stand\",\n", " 2: \"Walk\",\n", " 3: \"Stair-up\",\n", " 4: \"Stair-down\",\n", " 5: \"Run\",\n", "}\n", "\n", "activity = activity_labels[sample_y]\n", "\n", "fig = plt.figure(figsize=(16, 6))\n", "fig.suptitle(f\"Activity: {activity}\", fontsize=14)\n", "# Accelerometer subplot\n", "plt.subplot(1, 2, 1)\n", "# plt.subptitle(f\"Activity: {activity}\")\n", "plt.plot(sample_X[0, :], label=\"x\")\n", "plt.plot(sample_X[1, :], label=\"y\")\n", "plt.plot(sample_X[2, :], label=\"z\")\n", "plt.title(f\"Accelerometer\")\n", "plt.xlabel(\"Time (s)\")\n", "plt.ylabel(\"Sensor value (m/s^2)\")\n", "plt.legend()\n", "\n", "# Gyroscope subplot\n", "plt.subplot(1, 2, 2)\n", "plt.plot(sample_X[3, :], label=\"x\")\n", "plt.plot(sample_X[4, :], label=\"y\")\n", "plt.plot(sample_X[5, :], label=\"z\")\n", "plt.title(f\"Gyroscope\")\n", "plt.xlabel(\"Time (s)\")\n", "plt.ylabel(\"Sensor value (rad/s)\")\n", "plt.legend()\n", "\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.2. Creating the `MinervaDataModule`\n", "\n", "Minerva models are implemented using Pytorch Lightning. \n", "Thus, to train a model we should create a `LightningDataModule` object that will handle the data loading and preprocessing.\n", "Minerva provides a `MinervaDataModule` class that extends Pytorch Lightning's `LightningDataModule` class and standardizes the data loading process.\n", "\n", "We may create a `MinervaDataModule` object by passing the training, validation, and testing datasets, as well as the batch size and the number of workers for data loading" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==================================================\n", " 🆔 MotionSense Dataset\n", "==================================================\n", "└── Predict Split: test\n", "📂 Datasets:\n", " ├── Train Dataset:\n", " │ ==================================================\n", " │ 📂 SimpleDataset Information \n", " │ ==================================================\n", " │ 📌 Dataset Type: SimpleDataset\n", " │ └── Reader 0: TabularReader(df=(3558, 728), columns_to_select=['accel-x-*', 'accel-y-*', 'accel-z-*', 'gyro-x-*', 'gyro-y-*', 'gyro-z-*'], cast_to=None, data_shape=None)\n", " │ │ └── Transform: TransformPipeline(transforms=[Reshape(shape=(6, 60)), CastTo(dtype=float32)])\n", " │ └── Reader 1: TabularReader(df=(3558, 728), columns_to_select=['standard activity code'], cast_to=int64, data_shape=None)\n", " │ │ └── Transform: CastTo(dtype=int64)\n", " │ │\n", " │ └── Total Readers: 2\n", " │ ==================================================\n", " ├── Val Dataset:\n", " │ ==================================================\n", " │ 📂 SimpleDataset Information \n", " │ ==================================================\n", " │ 📌 Dataset Type: SimpleDataset\n", " │ └── Reader 0: TabularReader(df=(420, 728), columns_to_select=['accel-x-*', 'accel-y-*', 'accel-z-*', 'gyro-x-*', 'gyro-y-*', 'gyro-z-*'], cast_to=None, data_shape=None)\n", " │ │ └── Transform: TransformPipeline(transforms=[Reshape(shape=(6, 60)), CastTo(dtype=float32)])\n", " │ └── Reader 1: TabularReader(df=(420, 728), columns_to_select=['standard activity code'], cast_to=int64, data_shape=None)\n", " │ │ └── Transform: CastTo(dtype=int64)\n", " │ │\n", " │ └── Total Readers: 2\n", " │ ==================================================\n", " └── Test Dataset:\n", " ==================================================\n", " 📂 SimpleDataset Information \n", " ==================================================\n", " 📌 Dataset Type: SimpleDataset\n", " └── Reader 0: TabularReader(df=(1062, 728), columns_to_select=['accel-x-*', 'accel-y-*', 'accel-z-*', 'gyro-x-*', 'gyro-y-*', 'gyro-z-*'], cast_to=None, data_shape=None)\n", " │ └── Transform: TransformPipeline(transforms=[Reshape(shape=(6, 60)), CastTo(dtype=float32)])\n", " └── Reader 1: TabularReader(df=(1062, 728), columns_to_select=['standard activity code'], cast_to=int64, data_shape=None)\n", " │ └── Transform: CastTo(dtype=int64)\n", " │\n", " └── Total Readers: 2\n", " ==================================================\n", "\n", "🛠 **Dataloader Configurations:**\n", " ├── Dataloader class: \n", " ├── Train Dataloader Kwargs:\n", " ├── batch_size: 64\n", " ├── num_workers: 4\n", " ├── shuffle: true\n", " ├── drop_last: false\n", " ├── Val Dataloader Kwargs:\n", " ├── batch_size: 64\n", " ├── num_workers: 4\n", " ├── shuffle: false\n", " ├── drop_last: false\n", " └── Test Dataloader Kwargs:\n", " ├── batch_size: 64\n", " ├── num_workers: 4\n", " ├── shuffle: false\n", " ├── drop_last: false\n", "==================================================\n" ] } ], "source": [ "data_module = MinervaDataModule(\n", " train_dataset=train_dataset, \n", " val_dataset=val_dataset, \n", " test_dataset=test_dataset, \n", " batch_size=64,\n", " name=\"MotionSense Dataset\",\n", " num_workers=4\n", ")\n", "\n", "print(data_module)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Creating the Model\n", "\n", "Minerva provides several models to be used in Human Activity Recognition. \n", "In this notebook we will use the [`ResNetSE1D_5` model](https://ieeexplore.ieee.org/document/9771436) which is a 1D ResNet model with Squeeze-and-Excitation blocks and 5 residual blocks.\n", "\n", "To create the model, we just need to call the `ResNetSE1D_5` class from Minerva and pass the following parameters:\n", "- `input_shape`: Shape of each input samples, in the format `(channels, time_steps)`. In this case, it will be `(6, 60)`.\n", "- `num_classes`: Number of classes in the dataset. In this case, it will be 6." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "[W519 00:56:43.921873382 NNPACK.cpp:57] Could not initialize NNPACK! Reason: Unsupported hardware.\n", "[W519 00:56:43.924887388 NNPACK.cpp:57] Could not initialize NNPACK! Reason: Unsupported hardware.\n", "[W519 00:56:43.926286206 NNPACK.cpp:57] Could not initialize NNPACK! Reason: Unsupported hardware.\n", "[W519 00:56:43.927542423 NNPACK.cpp:57] Could not initialize NNPACK! Reason: Unsupported hardware.\n", "[W519 00:56:43.928236215 NNPACK.cpp:57] Could not initialize NNPACK! Reason: Unsupported hardware.\n", "[W519 00:56:43.929310238 NNPACK.cpp:57] Could not initialize NNPACK! Reason: Unsupported hardware.\n", "[W519 00:56:43.929749328 NNPACK.cpp:57] Could not initialize NNPACK! Reason: Unsupported hardware.\n", "[W519 00:56:43.930615444 NNPACK.cpp:57] Could not initialize NNPACK! Reason: Unsupported hardware.\n", "[W519 00:56:43.931039904 NNPACK.cpp:57] Could not initialize NNPACK! Reason: Unsupported hardware.\n", "[W519 00:56:43.931915372 NNPACK.cpp:57] Could not initialize NNPACK! Reason: Unsupported hardware.\n", "[W519 00:56:43.932344124 NNPACK.cpp:57] Could not initialize NNPACK! Reason: Unsupported hardware.\n" ] }, { "data": { "text/plain": [ "ResNetSE1D_5(\n", " (backbone): _ResNet1D(\n", " (conv_block): ConvolutionalBlock(\n", " (block): Sequential(\n", " (0): Conv1d(6, 64, kernel_size=(5,), stride=(1,))\n", " (1): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU()\n", " (3): MaxPool1d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " )\n", " )\n", " (residual_blocks): Sequential(\n", " (0): ResNetSEBlock(\n", " (block): Sequential(\n", " (0): Conv1d(64, 32, kernel_size=(5,), stride=(1,), padding=same)\n", " (1): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU()\n", " (3): Conv1d(32, 64, kernel_size=(5,), stride=(1,), padding=same)\n", " (4): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): SqueezeAndExcitation1D(\n", " (block): Sequential(\n", " (0): Linear(in_features=64, out_features=32, bias=True)\n", " (1): ReLU()\n", " (2): Linear(in_features=32, out_features=64, bias=True)\n", " (3): Sigmoid()\n", " )\n", " )\n", " )\n", " )\n", " (1): ResNetSEBlock(\n", " (block): Sequential(\n", " (0): Conv1d(64, 32, kernel_size=(5,), stride=(1,), padding=same)\n", " (1): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU()\n", " (3): Conv1d(32, 64, kernel_size=(5,), stride=(1,), padding=same)\n", " (4): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): SqueezeAndExcitation1D(\n", " (block): Sequential(\n", " (0): Linear(in_features=64, out_features=32, bias=True)\n", " (1): ReLU()\n", " (2): Linear(in_features=32, out_features=64, bias=True)\n", " (3): Sigmoid()\n", " )\n", " )\n", " )\n", " )\n", " (2): ResNetSEBlock(\n", " (block): Sequential(\n", " (0): Conv1d(64, 32, kernel_size=(5,), stride=(1,), padding=same)\n", " (1): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU()\n", " (3): Conv1d(32, 64, kernel_size=(5,), stride=(1,), padding=same)\n", " (4): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): SqueezeAndExcitation1D(\n", " (block): Sequential(\n", " (0): Linear(in_features=64, out_features=32, bias=True)\n", " (1): ReLU()\n", " (2): Linear(in_features=32, out_features=64, bias=True)\n", " (3): Sigmoid()\n", " )\n", " )\n", " )\n", " )\n", " (3): ResNetSEBlock(\n", " (block): Sequential(\n", " (0): Conv1d(64, 32, kernel_size=(5,), stride=(1,), padding=same)\n", " (1): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU()\n", " (3): Conv1d(32, 64, kernel_size=(5,), stride=(1,), padding=same)\n", " (4): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): SqueezeAndExcitation1D(\n", " (block): Sequential(\n", " (0): Linear(in_features=64, out_features=32, bias=True)\n", " (1): ReLU()\n", " (2): Linear(in_features=32, out_features=64, bias=True)\n", " (3): Sigmoid()\n", " )\n", " )\n", " )\n", " )\n", " (4): ResNetSEBlock(\n", " (block): Sequential(\n", " (0): Conv1d(64, 32, kernel_size=(5,), stride=(1,), padding=same)\n", " (1): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU()\n", " (3): Conv1d(32, 64, kernel_size=(5,), stride=(1,), padding=same)\n", " (4): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): SqueezeAndExcitation1D(\n", " (block): Sequential(\n", " (0): Linear(in_features=64, out_features=32, bias=True)\n", " (1): ReLU()\n", " (2): Linear(in_features=32, out_features=64, bias=True)\n", " (3): Sigmoid()\n", " )\n", " )\n", " )\n", " )\n", " )\n", " (global_avg_pool): AdaptiveAvgPool1d(output_size=1)\n", " )\n", " (fc): Linear(in_features=64, out_features=6, bias=True)\n", " (loss_fn): CrossEntropyLoss()\n", ")" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model = ResNetSE1D_5(\n", " input_shape=(6, 60),\n", " num_classes=6,\n", ")\n", "model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Defining the trainer\n", "\n", "As we are using Pytorch Lightning, we need to define a `Trainer` object to train the model.\n", "We can define the trainer by passing the following parameters:\n", "- `max_epochs`: Maximum number of epochs to train the model.\n", "- `acceleartor`: Device to use for training. It can be `cpu` or `gpu`.\n", "- `devices`: the list or the number of accelerator to use for training.\n", "\n", "For this example we will disable logging and checkpointing, by setting `logger=False` and `checkpoint_callback=False`." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n" ] } ], "source": [ "trainer = L.Trainer(\n", " max_epochs=100,\n", " devices=1,\n", " accelerator=\"gpu\",\n", " logger=False,\n", " enable_checkpointing=False,\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.1. Training the model\n", "\n", "To train the model we need to have three objects: the model, the data module, and the trainer.\n", "We can train the model by calling the `fit` method from the trainer and passing the model and the data module.\n", "\n", "The `fit` method will train the model for the number of epochs defined in the trainer object. Also, training dataloader will be used for training, and validation dataloader will be used for validation.\n", "\n", "> **NOTE**: We are not saving the model checkpoints in this example and not using early stopping based on validation loss. Thus, the model from last checkpoint will be used for evaluation. This may cause overfitting if the model is trained for too many epochs. " ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n", " | Name | Type | Params | Mode \n", "------------------------------------------------------\n", "0 | backbone | _ResNet1D | 126 K | train\n", "1 | fc | Linear | 390 | train\n", "2 | loss_fn | CrossEntropyLoss | 0 | train\n", "------------------------------------------------------\n", "127 K Trainable params\n", "0 Non-trainable params\n", "127 K Total params\n", "0.509 Total estimated model params size (MB)\n", "76 Modules in train mode\n", "0 Modules in eval mode\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " \r" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/vscode/.local/lib/python3.10/site-packages/lightning/pytorch/core/module.py:512: You called `self.log('val_loss', ..., logger=True)` but have no logger configured. You can enable one by doing `Trainer(logger=ALogger(...))`\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch 0: 2%|▏ | 1/56 [00:00<00:50, 1.09it/s]" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/vscode/.local/lib/python3.10/site-packages/lightning/pytorch/core/module.py:512: You called `self.log('train_loss', ..., logger=True)` but have no logger configured. You can enable one by doing `Trainer(logger=ALogger(...))`\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch 99: 100%|██████████| 56/56 [00:08<00:00, 6.53it/s, val_loss=3.410, train_loss=0.0357]" ] }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=100` reached.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch 99: 100%|██████████| 56/56 [00:08<00:00, 6.52it/s, val_loss=3.410, train_loss=0.0357]\n" ] } ], "source": [ "trainer.fit(model, data_module)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. Evaluating Model\n", "\n", "Once model is trained, we can evaluate the performance of the model on the test dataset.\n", "The performance is evaluated using the accuracy metric.\n", "To evaluate the model, we perform the following steps:\n", "1. Perform inference on the test dataset using the trained model. This is done using the `trainer.predict` method. The method returns the predicted logits for each sample in the test dataset.\n", "2. Calculate the predicted labels by taking the argmax of the logits.\n", "3. Obtain the labels from the test dataset.\n", "4. Create the accuracy metric object and pass the predicted labels and the true labels." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Predicting DataLoader 0: 100%|██████████| 17/17 [00:01<00:00, 11.43it/s]\n" ] } ], "source": [ "# 1. Obtain predictions for the test set\n", "predictions = trainer.predict(model, data_module)\n", "# As predictions is a list of batches, we concatenate them along the first dimension\n", "predictions = torch.cat(predictions, dim=0) # type: ignore" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The shape of the predicted labels is torch.Size([1062]) and dtype torch.int64\n" ] } ], "source": [ "# 2. We an use the torch.argmax function to obtain the class with the highest probability\n", "predicted_classes = torch.argmax(predictions, dim=1) # type: ignore\n", "# Let's print the predicted classes\n", "print(f\"The shape of the predicted labels is {predicted_classes.shape} and dtype {predicted_classes.dtype}\")" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The shape of the true labels is torch.Size([1062]) and dtype torch.int64\n" ] } ], "source": [ "# 3. Let's obtain the true labels\n", "y = []\n", "\n", "# We can use the test_dataset to obtain all the true labels\n", "for i in range(len(data_module.test_dataset)): # type: ignore\n", " sample_x, sample_y = data_module.test_dataset[i] # type: ignore\n", " y.append(sample_y) # type: ignore\n", " \n", "y = torch.Tensor(y).flatten().to(torch.int64)\n", "# Let's print the true labels\n", "print(f\"The shape of the true labels is {y.shape} and dtype {y.dtype}\")" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The accuracy of the model is 78.44%\n" ] } ], "source": [ "# 4. Let's create the accuracy metric object and compute the accuracy\n", "acc_metric = Accuracy(task=\"multiclass\", num_classes=6)\n", "score = acc_metric(predicted_classes, y)\n", "print(f\"The accuracy of the model is {score.item()*100:.2f}%\")" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.6" } }, "nbformat": 4, "nbformat_minor": 2 }