A Guide to Time-Series Sensor Data Classification Using UCI HAR Data | by Chris Knorowski | Jan, 2025

Utilizing TS-Recent, scikit-learn, and Information Studio to categorise sensor knowledge

The world is filled with sensors producing time-series knowledge, and extracting significant insights from this knowledge is an important talent in in the present day’s data-driven world. This text gives a hands-on information to classifying human exercise utilizing sensor knowledge and machine studying. We’ll stroll you thru the complete course of, from making ready the information to constructing and validating a mannequin that may precisely acknowledge totally different actions like strolling, sitting, and standing. By the top of this text you’ll have labored via a sensible machine studying utility and gained useful expertise in analyzing real-world sensor knowledge.

The UCI Human Exercise Recognition (HAR) dataset is nice for studying easy methods to classify time-series sensor knowledge utilizing machine studying. On this article, we’ll:

• Streamline dataset preparation and exploration with the Information Studio
• Create a characteristic extraction pipeline utilizing TSFresh
• Practice a machine studying classifier utilizing scikit-learn
• Validating your mannequin’s accuracy utilizing the Information Studio

• The UCI HAR dataset captures six elementary actions (strolling, strolling upstairs, strolling downstairs, sitting, standing, mendacity) utilizing smartphone sensors. It’s an ideal start line for understanding human motion patterns, time-series knowledge, and modeling. This dataset is licensed underneath a Creative Commons Attribution 4.0 International (CC BY 4.0) license.
• SensiML Data Studio gives an intuitive GUI interface to machine studying dataset. It has instruments for managing, annotating, and visualizing time-series sensor data-based machine-learning initiatives. The highly effective instruments make it simpler to discover totally different options in addition to establish drawback areas your knowledge set and fashions. The neighborhood model is free to make use of with paid choices obtainable.
• TSFresh is a Python library particularly designed for extracting significant options from time sequence knowledge. It’s used for evaluation, in addition to preprocessing options to ship to classification, regression, or clustering algorithms. TSFresh will robotically calculate a variety of options from its built-in characteristic library akin to statistical and frequency-based options. For those who want a particular characteristic, it’s simple so as to add customized options.
• Scikit-learn: is a free machine studying library for Python. It gives easy and environment friendly instruments for predictive knowledge evaluation, together with classification, regression, clustering, and dimensionality discount.

Put together the Dataset for Mannequin coaching

The UCI dataset is pre-split into chunks of information, which makes it troublesome to visualise and prepare fashions in opposition to. This Python script converts the UCR challenge right into a single CSV file per consumer and exercise. It additionally shops the metadata in a .dai file. The transformed challenge is out there immediately on GitHub here.

You may import the transformed challenge into the information studio from the .dai file into the SensiML Information Studio.

Open the challenge explorer and choose the file 1_WALKING.CSV. Whenever you open this file, you will note 95 labeled segments within the Label Session of this challenge.

The UCR dataset defaults to occasions of 128 samples every. Nonetheless, that isn’t essentially the very best section measurement for our challenge. Moreover, when constructing out a coaching dataset, its useful to enhance the information utilizing an overlap of the occasions. To alter the best way knowledge is labeled, we create a Sliding Windowing perform. We’ve carried out a sliding window perform here you could import into the Information Studio. Obtain and import the sliding window as a brand new mannequin:

1. File->Import Python Mannequin
2. Navigate and choose the file you simply downloaded
3. Give the mannequin the title Sliding Window and click on Subsequent
4. Set the window measurement to 128 and the delta to 64 and click on Save

Word: To make use of Python code you might want to set the Python path for the Information Studio. Go to Edit->Settings->Common Navigate to and Choose the .dll file for the Python surroundings you need to use.

Now that you’ve imported the sliding window segmentation algorithm as a mannequin, we will create new segments utilizing the algorithm.

1. Click on on the mannequin tab within the high proper Seize Discover Part.
2. Proper-Click on on the mannequin and Choose Run Mannequin
3. Click on on one of many new labels and click on CTL + A to pick out all of them.
4. Click on edit label and choose the suitable label for the file, on this case strolling.

You must now see 188 overlapping labels within the file. Utilizing the sliding window augmentation allowed us to double the scale of our coaching set. Every section is totally different sufficient that it shouldn’t introduce bias into our dataset trying to find the mannequin’s hyperparameters, however you need to nonetheless think about splitting throughout totally different customers when producing your folds as a substitute of single information. You may customise the sliding window perform or add your segmentation algorithms to the Information Studio to assist label after which your personal knowledge units.

Function Engineering

The sensor knowledge for this knowledge set has 9 channels of information (X, Y, and Z for physique acceleration, gyroscope, and complete acceleration). For section sizes of 128, meaning we’ve got 128*9=1152 options within the section. As an alternative of feeding the uncooked sensor knowledge into our machine-learning mannequin, we use characteristic extractors to compute related options from the datasets. This enables us to cut back the dimensionality, cut back the noise, and take away biases from the dataset.

Utilizing TSFresh, every labeled section might be transformed into a bunch of options referred to as a characteristic vector that can be utilized to coach a machine studying mannequin.

We’ll use a Jupyter Pocket book to coach the mannequin. You may get the complete pocket book here. The very first thing you’ll need is the SensiML Python Shoppers Information Studio library which we will use to programmatically entry the information within the native Information Studio challenge.

!pip set up SensiML

Import the DCLProject API and hook up with the native UCI HAR challenge file. You may right-click on a file within the challenge explorer of the Information Studio and click on Open In Explorer to seek out the trail of the challenge.

from sensiml.dclproj import DCLProject
ds = DCLProject(path=r"<path-to-uci-har-datastudio-project/UCI HAR.dsproj")

Subsequent we’re going to pull in all the knowledge segments from which might be a part of the session “Label Session. It will return a DataSegments object containing all the DataSegments within the specified session. The DataSegments object holds DataSegment objects which retailer metadata and uncooked knowledge for every section. The DataSegments object additionally has built-in visualization and conversion APIs

segments = ds.get_segments("Label Session")
segments[0].plot()

Subsequent, filter the DataSegments so we solely embrace ones which might be a part of our coaching set (ie metadata Set==Practice) and convert to the time-series format to make use of as enter into TSFresh.

train_segments = segments.filter_by_metadata({"Set":["Train"]})
timeseries, y = train_segments.to_timeseries()

Import TSFresh for characteristic extraction strategies

from tsfresh import select_features, extract_features
from tsfresh.feature_selection.relevance import calculate_relevance_table

Use the TSFrsesh extract_features methodology to generate plenty of options from every DataSegment. To save lots of processing time, initially generate options on a subset of the information.

timeseries, y = train_segments.to_timeseries()
X = extract_features(timeseries[timeseries["id"]<1000],
column_id="id", 
column_sort="time")

Break up the dataset into prepare and take a look at so we will validate the hyperparameters we choose

X_train, X_test, y_train, y_test = train_test_split(X,
y[y['id']<1000].label_value,
test_size=.2)

Utilizing the select_feature API from TSFresh, filter out options that aren’t vital to the mannequin. You may learn the tsfresh documentation for extra info.

X_train_filtered_multi = select_features(X_train.reset_index(drop=True),
y_train.reset_index(drop=True),
multiclass=True, 
n_significant=5)
X_train_filtered_multi = X_train_filtered_multi.filter(
sorted(X_train_filtered_multi.columns))

Modeling

Now that we’ve got our coaching dataset we will begin constructing a machine studying mannequin. On this tutorial, we’ll follow a single classifier and coaching algorithm, in apply you’d usually do a extra exhaustive search throughout classifiers to tune for the very best mannequin.

Import the libraries we’d like from sklearn to construct a random forest classifier

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, 
confusion_matrix, 
ConfusionMatrixDisplay,
f1_score

We will filter the variety of options down much more by computing the relevance desk of the filtered options. We then do a seek for the bottom variety of options that present a superb mannequin. Since computing options will be CPU intensive and too many options make it simpler for the mannequin to overfit, we attempt to cut back the variety of options with out affecting efficiency.

def get_top_features(relevance_table, quantity):
return sorted(relevance_table["feature"][:number])
relevance_table = calculate_relevance_table(X_train_filtered_multi,
y_train.reset_index(drop=True))
relevance_table = relevance_table[relevance_table.relevant]
relevance_table.sort_values("p_value", inplace=True)
for i in vary(20,400,20):    
relevant_features = get_top_features(relevance_table, i)
X_train_relevant_features = X_train[relevant_features]
classifier_selected_multi = RandomForestClassifier()
classifier_selected_multi.match(X_train_relevant_features, y_train)
X_test_filtered_multi = X_test[X_train_relevant_features.columns]
print(i, f1_score(y_test, classifier_selected_multi.predict(
X_test_filtered_multi), common="weighted"))

From the outcomes of the search we will see that 120 is the optimum variety of options to make use of.

relevant_features = get_top_features(relevance_table, 120 )
X_train_relevant_features = X_train[relevant_features]

Utilizing the TSFresh kind_to_fc_parameters parameter, we will generate 120 related options for the complete coaching dataset and use that to coach our mannequin.

from tsfresh.feature_extraction.settings import from_columns
kind_to_fc_parameters = from_columns(X_train_relevant_features)
timeseries, y = segments.to_timeseries()
X = extract_features(timeseries, column_id="id", column_sort="time",kind_to_fc_parameters=kind_to_fc_parameters)
X_train, X_test, y_train, y_test = train_test_split(X, y.label_value, test_size=.2)
classifier_selected_multi = RandomForestClassifier()
classifier_selected_multi.match(X_train, y_train)
print(classification_report(y_test, classifier_selected_multi.predict(X_test)))
ConfusionMatrixDisplay(confusion_matrix(y_test, classifier_selected_multi.predict(X_test))).plot()

Now that we’ve got a skilled mannequin and have extraction pipeline, we dump the mannequin right into a pickle file and dump the kind_to_fc_parameters right into a json. We’ll use these within the Information Studio to load the mannequin and extract the options there.

import pickle
import json
with open('mannequin.pkl', 'wb') as out:
pickle.dump(classifier_selected_multi, out)
json.dump(kind_to_fc_parameters, open("fc_params.json",'w'))

Validating

With the saved mannequin we’ll use the Information Studio to visualise and validate the mannequin accuracy in opposition to our take a look at knowledge set. To validate the mannequin within the Information Studio, import the mannequin.py into your Information Studio challenge.

1. Go to File->Import Python Mannequin.
2. Choose the trail to the mannequin.pkl and the fc_params.json as the 2 parameters within the mannequin
3. Set the window measurement to 128 and the delta to 128. After importing the mannequin, open the WALKING_1.CSV file once more
4. . Go to the seize data on the highest proper and choose the mannequin tab. Click on the newly imported mannequin and Choose Run Mannequin.
5. It will provide you with the choice to create a brand new Check Mannequin session, choose sure to avoid wasting the segments which might be generated the Check Session.
6. Choose Examine Periods in seize data and choose the take a look at mannequin.

It will mean you can see the bottom fact and mannequin outcomes overlayed with the sensor knowledge. Within the seize data space within the backside proper, click on on the confusion matrix tab. This reveals the efficiency of the mannequin in opposition to the take a look at session.

On this information we walked via utilizing the SensiML Information Studio to annotate and visualize the UCI HAR dataset, leveraged TSFresh to create a characteristic extraction pipeline, scikit-learn to coach a random forest classifier, and eventually the Information Studio to validate the skilled mannequin in opposition to our take a look at knowledge set. By leveraging sci-kit study, TSFresh and the Information Studio, you’ll be able to carry out all the duties required for constructing a machine studying classification pipeline for time sequence knowledge ranging from from labeling to and ending in mannequin validation.