Gait Pattern Analysis for Early Detection of Neuromuscular Disorders Using Wearable Sensors and Artificial Intelligence Techniques

In this paper, propose an end-to-end methodology to classify normal and pathological gait patterns due to cerebellar ataxia from wearable magnetic and angular sensor data and convolutional neural networks (CNN). The methodology consists of key stages: data collection, preprocessing, segmentation, model development, training, and testing.

2.1 Data acquisition

The gait dataset used in the current study was obtained from the publicly available Kaggle Gait Analysis Dataset for cerebellar ataxia curated by Rakesh Kumar Pudi (2021). The dataset was created for the purpose of discriminating and classifying the gait signals of healthy subjects and cerebellar-ataxia patients, an atypical neuromuscular disorder caused by cerebellar pathology that leads to poor coordination and an unsteady walking pattern.

The data is divided into two classes based on the subjects:

• Normal Gait: Data for subjects anticipated to have normal gait.
• Ataxic Gait: Gait data acquired from patients clinically diagnosed with adult dominant cerebellar ataxia.

Each class has its training and test folders, therefore enabling correct model creation and independent test. The file of the dataset being in CSV (Comma-Separated Values) format, containing each recording of a trial or walk with the wearable knock sensors. These sensors were positioned on the right and left thigh of each subject in order to record vibration and impact while walking.

There are multi-dimensional time series data in the CSV files, and each row is a discrete time, each column is different sensor channel. In this study, only the second and third columns (right and left leg sensor data) were used. This decision was made because of the assumption that dtFT pattern itself already contained sufficient discriminative features to discriminate between typical and atypical gait patterns.

The acquisition protocol included the following measures to maintain data accuracy:

• File format check: Checking that all the files have consistent formatting and contain an appropriate number of samples.
• Data Filter: No file will be allowed into the experiment with lower than 128 times samples, as these would not give enough information to be segmented in a window based approach.
• Class balance confirmation: Inspect the training and test sample counts to see if the class distribution is balanced or at least remove some bias.

This enriched and pre-labeled database provides a solid ground to construct AI models for early detection of gait anomalies. The dependence on real-world sensor data endows the study with the generalization to wearable healthcare systems for possible immediate application in clinical or home care settings.

2.2 Preprocessing and feature selection

Preprocessing is an essential step of any machine learning pipeline, particularly with respect to biomedical time-series data. The original gait signals recorded from knock sensors worn on the body are teed to be affected by noise, signal wandering, variable between sampling period, and among subject differences. Thus, an efficient pre-processing approach was applied to process those unclean and unstructured input into clean and relevant data for training and testing the convolutional neural network (CNN).

2.2.1 Channel selection

The raw CSV files included multi-channel sensor measurements with only a portion of it being used for this study. After a preliminary data exploration, the second one and third columns (representing signals of right and left leg sensor) were involved as well due to the relevance of this domain. These two channels were considered to be the most discriminative information of the bilateral gait coordination and asymmetry -among major factor s- used for diagnosing cerebellar ataxia.

2.2.2 Data cleaning

The content of all the CSV files were parsed and checked for:

• The minimum length signal of 128 samples to apply the window division method.
• There are no missing values (Nan) and no non-numeric entries.
• Same row- and column- layout for all files.

Files not satisfying these conditions were automatically discarded from the training and testing datasets in order to keep data correctness in the whole pipeline.

2.2.3 Normalization

In order to reduce the influence of amplitude variability caused by differences across sensors, due to limb strength and walking intensity specific for the individual subject, z-score normalization was performed for each segment:

$x_{\text {norm }}=\frac{x-\mu}{\sigma}$      (1)

where, x is the original sensor value, μ is the mean, and σ is the standard deviation of the signal. This normalization step ensured that the CNN focused on the relative dynamics and patterns rather than absolute values, thus improving model generalizability across different subjects.

2.2.4 Segmentation

Motion signals are temporal in nature and also variable in length per trial. To transform nonuniform (variable-length) time-series data into fixed-size (uniform) input that is suitable for CNN, a sliding window segmentation method was employed as follows:

• The signals were divided into 128-sample windows (providing us with one or two full gait cycles).
• A 50% overlap was maintained in the windows to boost data augmentation and keep temporal flow.

The process resulted in segments of a fixed size of 2 × 128 samples per channel (right and left leg) and recording time.

2.2.5 Feature representation

Unlike the classical machine learning methods that depend on handcrafted statistical or frequency-domain based features (e.g., step length, cadence, or FFT coefficients), in this work, use a deep learning based feature extraction approach. Therefore, they did not design any manual features. Instead, directly input the raw 2D gait segment (channels × time) into the CNN model, wherein multi-level hierarchical features were autonomously learned by the network during the training process.

This method utilizes the CNN to learn the:

• Temporal dependencies in channels that are local with respect to time (the timing of impact between channels).
• Inter-channel relationships (gait symmetry).
• Higher-level characteristics that are non-trivial to measure using handcrafted features.

Accordingly, the preprocessing and feature extraction was well-tuned in terms of both computational run-time and model quality, thereby providing a powerful basis for the learning steps in the following sections.

2.3 Signal segmentation

Signal segmentation is a crucial step in converting raw time-series sensor readings to windowed samples of fixed-size that can be effectively used for machine-learning (ML) and/or deep-learning (DL) based models. For gait analysis, segmentation breaks a stream of continuous movement into small, manageable segments that encompass relevant biological rhythms due to walking activity.

2.3.1 Motivation for segmentation

The raw gait data measured through wearable knock sensors has a different length at different subjects due to different duration of stride period, walking speed and trial length. Directly admitting those variable-length signals to a CNN is obviously impracticable because of the fixed requirement of input dimensionality in the CNN. Thus, the purpose of segmentation is dualistic:

• Standardization: Irregular length recordings are transformed in fixed length segments.
• Augmentation: Create multiple training samples from a single trial to diversify and to improve the robustness of the model.

Moreover, cerebellar ataxia might manifest itself as mild, episodic gait instabilities which can be better assessed by analyzing local time windows instead of the entire walking trials.

2.3.2 Segmentation strategy

Representative gait segments were extracted using a sliding window segmentation method. The operation sweeps a fixed-sized window along the time-series signal with a certain step size, creating the overlapped segments to maintain the continuity for motion information.

• Window length: 128 samples in time (~1–2 gait cycles depending on dataset sampling rate).
• Overlap: 50% (i.e., new windows are separated by half a time window).

This overlapping ensures continuity of the feature between segments and enhances the amount of training samples without introducing mutual information between the signals.

Segmentation was performed in a similar manner for all other CSV files and the following steps were included:

1. Take out the channels of the right and left leg sensors (Columns 2 and 3).
2. Shift a window of 128 samples across each channel together.
3. Reshape the 2-channel segment of the spectrogram into 2D array with dimensions 2 128 with the following layout:

• Rows are for right and left leg channels.
• Columns are time steps in the segment.

They were saved as samples by means of a segmentation process and were labeled as class (normal or ataxia) according to the parent directory name of the file.

2.3.3 Segment structure and dataset growth

Let L be the length of a signal and W be the window size. With 50% overlap, the number of segments per file is approximately:

$N=\left|\frac{2(L-W)}{W}+1\right|$      (2)

This method substantially expanded the training and test samples, as follows:

• Generalization of the CNN model.
• Improving the representation of temporal gait change.
• Permitting balanced learning also with a low number of subjects.

Every segment remained labeled, resulting in a multi-segment dataset with structural continuity and detailed behaviour.

2.3.4 Benefits of overlapping windows

The overlapping windowing that adopted in this study has several methodological advantages:

• Data augmentation without synthetic transformations.
• Reduced loss of information at segment transitions.
• Better temporal resolution, which is essential for capture of asymmetric or transient gait cycles in ataxic subjects.

In total, this step formed an effective abstraction between the raw sensor measurements and organised input that is compatible with the input conditioning used during deep neural network training. It facilitated learning of fine spen spatiotemporal features that are crucial for the detection of normal and pathological gait.

2.4 CNN model architecture in depth

CNNs are a subclass of deep learning model, which are very effective in learning hierarchy of features from structured input like image and time-series signal. In this work, a personalized 1D CNN model was constructed to efficiently capture discriminative features from segmented gait patterns and to decide if the signals are normal or ataxic. In contrast to conventional feature engineering that depends on handcrafted time-domain (e.g., step length and cadence) or frequency-domain (e.g., FFT coefficients) features, originating from raw sensor input, CNNs are able to learn data-driven representations. This not only diminishes the requirement of manual feature extraction but also learns multi-scale temporal dynamics which are difficult to encode explicitly.

2.4.1 Input representation

Each input-sample of the CNN is a 2D matrix of the size 2 × 128 × 1, i.e.

• 2: Number of channels (right leg and left leg knock sensor signals).
• 128: The size of each segment (window length).
• 1: Dimension of the depth, comparable to single-channel grayscale image.

The proposed representation allows applying 2D convolutional layers to learn relationships between time and sensor channels to capture spatial patterns and for the network to analyze inter-limb coordination and asymmetries — signs and markers of cerebellar ataxia.

2.4.2 Network structure

The design of the CNN model architecture is described as follows, with the layers involved carefully selected to achieve a good tradeoff between model complexity, training stability, and generalization performance as shown in Table 1.

Table 1. Parameters of CNN model

2.4.3 Design rationale

• 1 × 3 Convolutional filters: Our choice to convolve along the time axis to extract local temporal information, without mixing sensor channels too early.
• MaxPooling Separated Only in Time: Have separated maxpooling in the features corresponding to the time track and in the features related to the 2D intrachannel structure to decrease the temporal resolution and not to harm the inter-channel structure that it is important to recognize gait asymmetry.
• Dropout Regularization: Added for prevention of over fitting, in particular because of few unique subjects in medical datasets.
• Two Convolutional Blocks: Two blocks are enough to obtain low- and mid-level features, making the models light and effective.

2.4.4 Training configuration

The model was trained with the Adam optimizer with the following settings:

• MaxEpochs: 15
• MiniBatchSize: 32
• Initial Learn Rate: Default (0.001)
• Loss Function: Cross-entropy (via classification Layer)
• Early Visualization: The real-time plots of the training accuracy and loss were observed in real time in order to detect over fit.

The architecture was implemented in MATLAB with the Deep Learning Toolbox considering embedded applications and [19] possible usage for real-time wearable objects.

2.5 Model training

After preprocessing and segmentation of the datasets, and definition of the topology of the CNN, the model was trained to be able to discern normal and ataxic gaits. This training procedure was performed in several stages comprising the following: data pre-processing for deep learning, specifying the hyper-parameters and monitoring the performance.

2.5.1 Training dataset preparation

The gait signals that have been segmented and normalized from the training set were input to the CNN model. Each segment was described like a 2D matrix of 2 × 128 × 1 as follows:

• The two columns show the right and left leg sensors.
• The 128 columns are the time points within the part of the gait cycle.
• The depth dimension (1) represents one grayscale channel, applicable to 2D convolutional filters.

For each of these segments, the respective class label (normal or ataxia) was applied, generating a supervised learning problem with explicit input output pairs.

2.5.2 Training configuration and optimization

The training process was conducted in MATLAB’s Deep Learning Toolbox, which supports GPU acceleration and real time monitoring. The training hyperparameters were as follows as shown in Table 2.

Table 2. Training hyperparameters

The Adam optimizer was used for more adaptive learning rates and it converges faster than SGD. A mini-batch of 32 examples was found to ensure the tradeoff between efficiency and stability of the gradients. The loss function minimized during training was the categorical cross-entropy to maximize the predicted likelihood of the right class. The softmax function in the final layer transformed network output to a probability distribution over the two classes.

2.5.3 Training progress monitoring

The following graphs were generated in real time during the training:

• Training Accuracy: indicates the ratio of correctly categorized segments for the epoch.
• Training Loss: It is a measure of how well the model fits the training data.
• Mini-batch Loss: Variations between the batches, which are helpful in identifying any evidence that might point toward over-fitting or unstable gradients.
• This visual evidence allowed detection of Underfitting: Low accuracy and high loss, still after some epoch.

Overfitting: High training accuracy and low loss, but low validation accuracy.

As no additional validation set was employed (because of the limited number of subjects), the generalization of the model was later tested on a test set (in Section 2.6).

Extended the training procedure by including Early Stopping, more robust regularization and learning rate adjustments for improved generalization performance and to prevent overfitting. The model was only trained for as many as 40 epochs, ending its training at epoch 11 when validation loss was increasing (Early Stopping). For the dense layers we combined dropout layers with a rate of 0.5 and applied L2 regularization (weight decay of 0.001) on all convolutional layers. A Reduce-on-Plateau scheduler reduced the learning rate by a factor of 0.2 if the validation loss was at a plateau for three epochs. These features led to smoother convergence, minimised model variance, and enhanced the model's ability of generalisation to new gait samples.

2.5.4 Regularization and overfitting control

To prevent overfitting, the following measures were carried out:

• Introducing Dropout Layer (30% rate): This layer has a randomized behavior, 0 of the document’s neurons were removed on avg., and during training, which disables neurons randomly during training, that help boost the robustness of the trained network.
• Batch Normalization: Allows to train transfer learning model and process the features extraction faster by stabilizing and accelerating training with normalized layer inputs.
• Sliding Window Segmentation: Implicitly enlarges the training set by generating several slightly shifted instances for each trial.

These approaches prevented the model from simply memorizing certain training patterns, which is particularly important for biomedical data with small subject variety.

2.5.5 Final model output

At the end of 15 epochs the A module's classification performance of the subject's motion modality was performed in high accuracy on the training set; this evidence suggested the learning model was successful in identifying the two gait classes with the right-left leg sensor dynamics respectively. The trained model (net) was saved and tested on unseen test data in this experiment in the second phase of the methodology below.

2.6 Model evaluation

The CNN was trained and the model was tested with a separate set of test samples. These testing samples were never involved with training phase so that such an assessment was fair. The test aimed at assessing the ability of the model to correctly and repeatably classify the gait as ataxic versus normal given new right/left leg sensor segment readings.

2.6.1 Test dataset preparation

The test set was extracted from test/normal and test/ataxia folders of the original Kaggle dataset. As during the training phase, every CSV file was:

• Accepted, monochrome (unless colored scientific) figures to conform to the correct format and completed in terms of content (three columns at the least).
• Extracted by column 2nd and 3rd yielding the signals from the right and left legs respectively.
• Segmented into 128 sample-long windows with 50% overlap.

Each of these windows was then resized to have the same input dimensions of the CNN (2 × 128 × 1), and labelled as positive. This provided uniform preprocessing pipeline during both training and test phases.

2.6.2 Prediction and classification

Each segment of the test set was input into the trained CNN model using MATLAB classify () function. Network output was probability distribution over two output classes (normal and ataxia), and class with maximum probability was chosen as model prediction.

$\hat{y}=\arg \max _{c \in\{\text { normal,ataxia }\}} P(y=c \mid x)$     (3)

where, x is the input segment, and $\hat{y}$ is the predicted class.

2.6.3 Performance metrics

To evaluate model performance, several standard classification metrics were computed based on the comparison between predicted labels and true labels:

• Accuracy: The proportion of correctly classified samples:

Accuracy $=\frac{T P+T N}{T P+T N+F P+F N}$     (4)

• Precision: The proportion of positive identifications that were actually correct:

Precision $=\frac{T P}{T P+F P}$      (5)

• Recall (Sensitivity): The proportion of actual positives that were correctly identified:

Recall $=\frac{T P}{T P+F N}$     (6)

• F1-Score: Harmonic mean of precision and recall:

$F 1=2 \times \frac{\text { Precision × Recall }}{\text { Precision }+ \text { Recall }}$     (7)

Here, TP, TN, FP, and FN refer to true positives, true negatives, false positives, and false negatives, respectively, with respect to the "ataxia" class.

2.6.4 Confusion matrix

Generalization data were presented in a confusion matrix to visualize how well the model behaved. The matrix showed the true and false predicted samples for each class. It was used to assess:

• Class imbalance,
• Misclassification trends,
• Overall predictive strength.

The ideal model would produce a diagonal matrix, where all values off the diagonal are zero.

2.6.5 Results interpretation

The last assessment demonstrated whether the model was able to:

• Identify appropriately ataxic gait, reflecting the requirement for the presence of a CAC.
• Attain high precision and recall with few or no false positives and negatives.
• Tolerate variations in signal shapes and subject movements as in their widespread application to the CNN's robustness to signal translation and noise condition.

These results showed that the proposed method — using right/left leg segmentation of sensor and CNN learning —proved to be effective for chairs for early detection of neuromuscular disorder in walking.

2.7 Governing equations

2.7.1 Signal normalization

Each gait signal segment $x=\left\{x_1, x_2, \ldots, x_n\right\}$ from the right or left leg sensor was standardized using $Z$-score normalization to reduce subject-specific variability and sensor scale differences. The normalized signal $x_{\text {norm }}$ is computed as:

$x_{\text {norm }}=\frac{x-\mu}{\sigma}$     (8)

where:

$\mu$ is the mean of the signal segment,

$\sigma$ is the standard deviation,

$x$ is the original raw sensor signal.

2.7.2 Convolutional neural network operations

The core of the CNN model involves applying a discrete convolution operation to extract features from temporal gait data. The convolution between an input segment $x$ and a kernel (or filter) $w$ is defined as:

$s(t)=(x * w)(t)=\sum_{i=0}^{k-1} x(t+i) \cdot w(i)$     (9)

where:

$s(t)$ is the feature map output,

$x(t)$ is the input signal at time $t$,

$w(i)$ is the kernel weight at position $i$,

$k$ is the filter length.

This operation is extended to 2D when applied to the $2 \times 128$ input matrix using 2D convolutional filters.

2.7.3 Activation function (ReLU)

The CNN uses the Rectified Linear Unit (ReLU) as a non-linear activation function after each convolution:

$f(x)=\max (0, x)$     (10)

This introduces non-linearity into the model, allowing it to learn more complex patterns.

2.7.4 Pooling operation

To reduce feature map dimensionality and retain dominant features, max pooling is used:

$p_j=\max \left\{s_j, s_{j+1}, \ldots, s_{j+m-1}\right\}$     (11)

where:

$m$ is the pooling window size,

$s_j$ is the input feature at position $j$,

$p_j$ is the pooled output.

2.7.5 Softmax function

The final output layer applies a softmax function to convert the fully connected output vector $z$ into class probabilities:

$P(y=c \mid x)=\frac{e^{z_c}}{\sum_{i=1}^C e^{z_i}}$     (12)

where:

$z_c$ is the activation score for class $c$,

$C$ is the total number of classes (2 in this study: normal, ataxia),

$P(y=c \mid x)$ is the predicted probability of class $c$ given input $x$.

2.7.6 Loss function - categorical cross-entropy

The CNN is trained to minimize the categorical cross-entropy loss between the true class label $y$ and the predicted probability distribution $\hat{y}$:

$\mathcal{L}=-\sum_{c=1}^c y_c \log \left(\hat{y}_c\right)$     (13)

where:

$y_c$ is the binary indicator (0 or 1) if class label $c$ is the correct classification.

$\hat{y}_c$ is the predicted probability for class $c$.

Figure 1 shows the Flow chart of CNN model and Figure 2 shows CNN model architecture.

Figure 1. Flow chart of CNN model

Figure 2. CNN model architecture