From 2470a131d0f2a7ec8faeca60b90d537f583251f3 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 9 Dec 2025 14:57:36 +0000
Subject: [PATCH 1/9] Initial plan
From 27d35c5afaa90e116fb710be3ede06c8ef6d0736 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 9 Dec 2025 15:10:02 +0000
Subject: [PATCH 2/9] Initial ros2_svdd_monitor package (SVDD monitor)
Co-authored-by: jondave <6209386+jondave@users.noreply.github.com>
---
.github/workflows/pytest.yml | 33 ++
.gitignore | 23 ++
LICENSE | 222 ++-----------
README.md | 304 ++++++++++++++----
requirements.txt | 5 +
src/ros2_svdd_monitor/config/config.yaml | 25 ++
src/ros2_svdd_monitor/package.xml | 20 ++
src/ros2_svdd_monitor/pytest.ini | 6 +
.../resource/ros2_svdd_monitor | 0
.../ros2_svdd_monitor/__init__.py | 0
.../ros2_svdd_monitor/features.py | 224 +++++++++++++
.../ros2_svdd_monitor/monitor.py | 224 +++++++++++++
.../ros2_svdd_monitor/svdd_model.py | 155 +++++++++
.../ros2_svdd_monitor/train.py | 154 +++++++++
.../ros2_svdd_monitor/utils/__init__.py | 0
.../ros2_svdd_monitor/utils/rosbag_to_csv.py | 148 +++++++++
src/ros2_svdd_monitor/setup.cfg | 4 +
src/ros2_svdd_monitor/setup.py | 37 +++
src/ros2_svdd_monitor/test/__init__.py | 0
src/ros2_svdd_monitor/test/test_features.py | 148 +++++++++
src/ros2_svdd_monitor/test/test_svdd_model.py | 188 +++++++++++
21 files changed, 1664 insertions(+), 256 deletions(-)
create mode 100644 .github/workflows/pytest.yml
create mode 100644 requirements.txt
create mode 100644 src/ros2_svdd_monitor/config/config.yaml
create mode 100644 src/ros2_svdd_monitor/package.xml
create mode 100644 src/ros2_svdd_monitor/pytest.ini
create mode 100644 src/ros2_svdd_monitor/resource/ros2_svdd_monitor
create mode 100644 src/ros2_svdd_monitor/ros2_svdd_monitor/__init__.py
create mode 100644 src/ros2_svdd_monitor/ros2_svdd_monitor/features.py
create mode 100644 src/ros2_svdd_monitor/ros2_svdd_monitor/monitor.py
create mode 100644 src/ros2_svdd_monitor/ros2_svdd_monitor/svdd_model.py
create mode 100644 src/ros2_svdd_monitor/ros2_svdd_monitor/train.py
create mode 100644 src/ros2_svdd_monitor/ros2_svdd_monitor/utils/__init__.py
create mode 100644 src/ros2_svdd_monitor/ros2_svdd_monitor/utils/rosbag_to_csv.py
create mode 100644 src/ros2_svdd_monitor/setup.cfg
create mode 100644 src/ros2_svdd_monitor/setup.py
create mode 100644 src/ros2_svdd_monitor/test/__init__.py
create mode 100644 src/ros2_svdd_monitor/test/test_features.py
create mode 100644 src/ros2_svdd_monitor/test/test_svdd_model.py
diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml
new file mode 100644
index 0000000..7270124
--- /dev/null
+++ b/.github/workflows/pytest.yml
@@ -0,0 +1,33 @@
+name: Python Tests
+
+on:
+ push:
+ branches: [ "main" ]
+ pull_request:
+ branches: [ "main" ]
+
+jobs:
+ test:
+ runs-on: ubuntu-latest
+ strategy:
+ matrix:
+ python-version: ["3.10"]
+
+ steps:
+ - uses: actions/checkout@v3
+
+ - name: Set up Python ${{ matrix.python-version }}
+ uses: actions/setup-python@v4
+ with:
+ python-version: ${{ matrix.python-version }}
+
+ - name: Install dependencies
+ run: |
+ python -m pip install --upgrade pip
+ pip install pytest
+ pip install -r requirements.txt
+
+ - name: Run pytest
+ run: |
+ cd src/ros2_svdd_monitor
+ pytest test/ -v
diff --git a/.gitignore b/.gitignore
index 1bfa387..9a0c931 100644
--- a/.gitignore
+++ b/.gitignore
@@ -51,3 +51,26 @@ qtcreator-*
# Catkin custom files
CATKIN_IGNORE
.DS_Store
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+.venv/
+*.egg-info/
+dist/
+.pytest_cache/
+
+# Trained models and data
+*.pkl
+*.csv
+*.bag
+models/
+
+# IDE
+.vscode/
+.idea/
diff --git a/LICENSE b/LICENSE
index 261eeb9..932a5e0 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,201 +1,21 @@
- Apache License
- Version 2.0, January 2004
- http://www.apache.org/licenses/
-
- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
- 1. Definitions.
-
- "License" shall mean the terms and conditions for use, reproduction,
- and distribution as defined by Sections 1 through 9 of this document.
-
- "Licensor" shall mean the copyright owner or entity authorized by
- the copyright owner that is granting the License.
-
- "Legal Entity" shall mean the union of the acting entity and all
- other entities that control, are controlled by, or are under common
- control with that entity. For the purposes of this definition,
- "control" means (i) the power, direct or indirect, to cause the
- direction or management of such entity, whether by contract or
- otherwise, or (ii) ownership of fifty percent (50%) or more of the
- outstanding shares, or (iii) beneficial ownership of such entity.
-
- "You" (or "Your") shall mean an individual or Legal Entity
- exercising permissions granted by this License.
-
- "Source" form shall mean the preferred form for making modifications,
- including but not limited to software source code, documentation
- source, and configuration files.
-
- "Object" form shall mean any form resulting from mechanical
- transformation or translation of a Source form, including but
- not limited to compiled object code, generated documentation,
- and conversions to other media types.
-
- "Work" shall mean the work of authorship, whether in Source or
- Object form, made available under the License, as indicated by a
- copyright notice that is included in or attached to the work
- (an example is provided in the Appendix below).
-
- "Derivative Works" shall mean any work, whether in Source or Object
- form, that is based on (or derived from) the Work and for which the
- editorial revisions, annotations, elaborations, or other modifications
- represent, as a whole, an original work of authorship. For the purposes
- of this License, Derivative Works shall not include works that remain
- separable from, or merely link (or bind by name) to the interfaces of,
- the Work and Derivative Works thereof.
-
- "Contribution" shall mean any work of authorship, including
- the original version of the Work and any modifications or additions
- to that Work or Derivative Works thereof, that is intentionally
- submitted to Licensor for inclusion in the Work by the copyright owner
- or by an individual or Legal Entity authorized to submit on behalf of
- the copyright owner. For the purposes of this definition, "submitted"
- means any form of electronic, verbal, or written communication sent
- to the Licensor or its representatives, including but not limited to
- communication on electronic mailing lists, source code control systems,
- and issue tracking systems that are managed by, or on behalf of, the
- Licensor for the purpose of discussing and improving the Work, but
- excluding communication that is conspicuously marked or otherwise
- designated in writing by the copyright owner as "Not a Contribution."
-
- "Contributor" shall mean Licensor and any individual or Legal Entity
- on behalf of whom a Contribution has been received by Licensor and
- subsequently incorporated within the Work.
-
- 2. Grant of Copyright License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- copyright license to reproduce, prepare Derivative Works of,
- publicly display, publicly perform, sublicense, and distribute the
- Work and such Derivative Works in Source or Object form.
-
- 3. Grant of Patent License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- (except as stated in this section) patent license to make, have made,
- use, offer to sell, sell, import, and otherwise transfer the Work,
- where such license applies only to those patent claims licensable
- by such Contributor that are necessarily infringed by their
- Contribution(s) alone or by combination of their Contribution(s)
- with the Work to which such Contribution(s) was submitted. If You
- institute patent litigation against any entity (including a
- cross-claim or counterclaim in a lawsuit) alleging that the Work
- or a Contribution incorporated within the Work constitutes direct
- or contributory patent infringement, then any patent licenses
- granted to You under this License for that Work shall terminate
- as of the date such litigation is filed.
-
- 4. Redistribution. You may reproduce and distribute copies of the
- Work or Derivative Works thereof in any medium, with or without
- modifications, and in Source or Object form, provided that You
- meet the following conditions:
-
- (a) You must give any other recipients of the Work or
- Derivative Works a copy of this License; and
-
- (b) You must cause any modified files to carry prominent notices
- stating that You changed the files; and
-
- (c) You must retain, in the Source form of any Derivative Works
- that You distribute, all copyright, patent, trademark, and
- attribution notices from the Source form of the Work,
- excluding those notices that do not pertain to any part of
- the Derivative Works; and
-
- (d) If the Work includes a "NOTICE" text file as part of its
- distribution, then any Derivative Works that You distribute must
- include a readable copy of the attribution notices contained
- within such NOTICE file, excluding those notices that do not
- pertain to any part of the Derivative Works, in at least one
- of the following places: within a NOTICE text file distributed
- as part of the Derivative Works; within the Source form or
- documentation, if provided along with the Derivative Works; or,
- within a display generated by the Derivative Works, if and
- wherever such third-party notices normally appear. The contents
- of the NOTICE file are for informational purposes only and
- do not modify the License. You may add Your own attribution
- notices within Derivative Works that You distribute, alongside
- or as an addendum to the NOTICE text from the Work, provided
- that such additional attribution notices cannot be construed
- as modifying the License.
-
- You may add Your own copyright statement to Your modifications and
- may provide additional or different license terms and conditions
- for use, reproduction, or distribution of Your modifications, or
- for any such Derivative Works as a whole, provided Your use,
- reproduction, and distribution of the Work otherwise complies with
- the conditions stated in this License.
-
- 5. Submission of Contributions. Unless You explicitly state otherwise,
- any Contribution intentionally submitted for inclusion in the Work
- by You to the Licensor shall be under the terms and conditions of
- this License, without any additional terms or conditions.
- Notwithstanding the above, nothing herein shall supersede or modify
- the terms of any separate license agreement you may have executed
- with Licensor regarding such Contributions.
-
- 6. Trademarks. This License does not grant permission to use the trade
- names, trademarks, service marks, or product names of the Licensor,
- except as required for reasonable and customary use in describing the
- origin of the Work and reproducing the content of the NOTICE file.
-
- 7. Disclaimer of Warranty. Unless required by applicable law or
- agreed to in writing, Licensor provides the Work (and each
- Contributor provides its Contributions) on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- implied, including, without limitation, any warranties or conditions
- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
- PARTICULAR PURPOSE. You are solely responsible for determining the
- appropriateness of using or redistributing the Work and assume any
- risks associated with Your exercise of permissions under this License.
-
- 8. Limitation of Liability. In no event and under no legal theory,
- whether in tort (including negligence), contract, or otherwise,
- unless required by applicable law (such as deliberate and grossly
- negligent acts) or agreed to in writing, shall any Contributor be
- liable to You for damages, including any direct, indirect, special,
- incidental, or consequential damages of any character arising as a
- result of this License or out of the use or inability to use the
- Work (including but not limited to damages for loss of goodwill,
- work stoppage, computer failure or malfunction, or any and all
- other commercial damages or losses), even if such Contributor
- has been advised of the possibility of such damages.
-
- 9. Accepting Warranty or Additional Liability. While redistributing
- the Work or Derivative Works thereof, You may choose to offer,
- and charge a fee for, acceptance of support, warranty, indemnity,
- or other liability obligations and/or rights consistent with this
- License. However, in accepting such obligations, You may act only
- on Your own behalf and on Your sole responsibility, not on behalf
- of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability
- incurred by, or claims asserted against, such Contributor by reason
- of your accepting any such warranty or additional liability.
-
- END OF TERMS AND CONDITIONS
-
- APPENDIX: How to apply the Apache License to your work.
-
- To apply the Apache License to your work, attach the following
- boilerplate notice, with the fields enclosed by brackets "[]"
- replaced with your own identifying information. (Don't include
- the brackets!) The text should be enclosed in the appropriate
- comment syntax for the file format. We also recommend that a
- file or class name and description of purpose be included on the
- same "printed page" as the copyright notice for easier
- identification within third-party archives.
-
- Copyright [yyyy] [name of copyright owner]
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
+MIT License
+
+Copyright (c) 2025 LCAS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
index c028888..875d2ef 100644
--- a/README.md
+++ b/README.md
@@ -1,82 +1,276 @@
-## ROS2 Package Template
+# ros2_svdd_monitor
-This repository serves as a template for creating ROS2 packages, equipped with a comprehensive CI workflow and devcontainer configuration.
+[](https://github.com/LCAS/ros2_svdd_monitor/actions/workflows/pytest.yml)
+[](https://github.com/LCAS/ros2_svdd_monitor/actions/workflows/ros-ci.yml)
-### Development Environment Setup
+SVDD-style anomaly detection for ROS 2 using proprioceptive sensors (IMU and cmd_vel).
-To begin development in a containerized environment:
+This package implements Support Vector Data Description (SVDD) using OneClassSVM for real-time anomaly detection on robotic systems. It monitors the relationship between commanded velocities (`/cmd_vel`) and actual IMU measurements (`/imu`) to detect anomalous behavior that might indicate hardware failures, unexpected terrain, or other system issues.
-1. **Use this repo as a template:**
- The best way to work with this repo is to use it as a template for your ROS package development, to do so, in the top right corner select `Use this template`:
-
- 
+## Features
- Then in the next step specify the owner and the package name as shown below:
-
- 
-
+- **Proprioceptive-only monitoring**: Uses only `/cmd_vel` and `/imu` topics (no external sensors required)
+- **Feature engineering**: Extracts sliding-window features that capture the expected relationship between commanded motion and IMU response
+- **SVDD anomaly detection**: Uses OneClassSVM as a proxy for SVDD to learn normal operation patterns
+- **Real-time monitoring**: ROS 2 node that publishes anomaly detection results
+- **Configurable**: Hyperparameters (window size, nu, gamma) configurable via YAML
+- **Offline training**: Train models on recorded data before deployment
-3. **Open in Visual Studio Code:**
- Open the cloned repository in VSCode. VSCode will prompt you to "Reopen in Container." Alternatively, you can use the command palette (`Ctrl+Shift+P`) and search for the "reopen in container" command.
+## Installation
- 
+### Prerequisites
- Then this will promote you with the following two options:
- 
+- ROS 2 Humble
+- Python 3.10+
- You may select the base image according to your targeted application. For instance, if the nodes do not require GPU processing tasks, it is preferable to use the default devcontainer as it is more lightweight.
+### Build from Source
-5. **Container Setup:**
- Once reopened in the container, VSCode will initiate the building process and pull all necessary dependencies. You can monitor the building log within VSCode.
+1. Clone this repository into your ROS 2 workspace:
- 
+```bash
+cd ~/ros2_ws/src
+git clone https://github.com/LCAS/ros2_svdd_monitor.git
+```
-6. **Verify Container Environment:**
- After the build completes, VSCode will connect to the container. You can verify that you are within the container environment.
+2. Install Python dependencies:
- 
+```bash
+pip install -r ros2_svdd_monitor/requirements.txt
+```
-### Devcontainer Features
+3. Build the package:
-The devcontainer includes a light desktop interface. To utilize this feature:
+```bash
+cd ~/ros2_ws
+colcon build --packages-select ros2_svdd_monitor
+source install/setup.bash
+```
-1. **Configuration:**
- Add the following features to the devcontainer configuration:
+## Quick Start
- ```json
- "features": {
- "ghcr.io/LCAS/devcontainer-features/desktop-lite:1": {}
- },
- "forwardPorts": [6080, 5801],
- "portsAttributes": {
- "6080": {
- "label": "desktop"
- },
- "5801": {
- "label": "desktop opengl"
- }
- }
- ```
+### 1. Collect Training Data
-2. **Accessing the Desktop Interface:**
- Open the user interface by navigating to the PORTS tab in VSCode, selecting port `6080` (or port `5801` for the CUDA-OpenGL version), and opening it in the browser.
+First, record normal operation data. You can either:
- 
+**Option A: Use the built-in CSV recorder (recommended)**
-3. **Connecting to the Interface:**
- Click on "Connect" and use the password `vscode` to access the desktop interface.
+```bash
+# Start the CSV recorder
+ros2 run ros2_svdd_monitor rosbag_to_csv training_data.csv
- 
+# In another terminal, operate your robot normally
+# (or play a rosbag of normal operation)
+ros2 bag play normal_operation.bag
+```
-### Enjoy Development!
+**Option B: Record a rosbag and export to CSV later**
-By leveraging this setup, you can develop on a remote machine with a lightweight desktop interface. Magic! Furthermore, this template package provides very nice ROS2 functionality like syntax highlight and template code generation.
+```bash
+# Record a rosbag with /cmd_vel and /imu topics
+ros2 bag record /cmd_vel /imu -o normal_operation
-**All ROS2 packages should go into the `src/` folder. Create them with `ros2 pkg create...`.**
+# Then use the CSV converter
+ros2 run ros2_svdd_monitor rosbag_to_csv training_data.csv
+ros2 bag play normal_operation
+```
-**The devcontainer tries to install all dependencies of the workspace automatically as much as possible, and also tries to build the workspace when it is created, to speed up later colcon builds.**
+The CSV file should have the following columns:
+```
+timestamp,linear_x,linear_y,linear_z,angular_x,angular_y,angular_z,accel_x,accel_y,accel_z,gyro_x,gyro_y,gyro_z
+```
-### References
+### 2. Train the SVDD Model
-1. [ros2-teaching-ws](https://github.com/LCAS/ros2-teaching-ws)
-2. [Get Started with Dev Containers in VS Code](https://youtu.be/b1RavPr_878?si=ADepc_VocOHTXP55)
+Train the anomaly detection model on your collected data:
+
+```bash
+ros2 run ros2_svdd_monitor train --csv training_data.csv --output-dir models/
+```
+
+This will:
+- Load the training data from CSV
+- Extract features using sliding windows
+- Train a OneClassSVM model
+- Save the trained model and scaler to `models/svdd_model.pkl` and `models/scaler.pkl`
+
+### 3. Run the Monitor
+
+Start the real-time anomaly monitor:
+
+```bash
+ros2 run ros2_svdd_monitor monitor
+```
+
+The monitor will:
+- Subscribe to `/cmd_vel` and `/imu` topics
+- Maintain sliding windows of recent data
+- Extract features and run anomaly detection
+- Publish results to `/svdd/anomaly` (Bool) and `/svdd/anomaly_score` (Float32)
+
+### 4. Visualize Anomalies
+
+Monitor the anomaly detection in real-time:
+
+```bash
+# Watch for anomalies
+ros2 topic echo /svdd/anomaly
+
+# View anomaly scores
+ros2 topic echo /svdd/anomaly_score
+
+# Use rqt_plot for visualization
+rqt_plot /svdd/anomaly_score
+```
+
+## Configuration
+
+The SVDD monitor is configured via `config/config.yaml`:
+
+```yaml
+# Sliding window parameters
+window_size: 10 # Number of recent samples for feature extraction
+
+# OneClassSVM hyperparameters
+nu: 0.1 # Upper bound on fraction of outliers (0 < nu <= 1)
+gamma: 'scale' # RBF kernel coefficient
+
+# Model paths
+model_path: 'svdd_model.pkl'
+scaler_path: 'scaler.pkl'
+
+# Anomaly detection threshold
+anomaly_threshold: 0.0 # Decision function threshold
+```
+
+### Hyperparameter Tuning
+
+- **window_size**: Larger windows capture more temporal context but increase latency. Typical values: 5-20.
+- **nu**: Upper bound on training errors. Lower values make the model more strict. Typical values: 0.05-0.2.
+- **gamma**: Controls the RBF kernel width. Use 'scale' (default) or 'auto' for automatic selection, or specify a float value.
+- **anomaly_threshold**: Adjust this based on your false positive/negative tolerance. Default is 0.0.
+
+## How It Works
+
+### Feature Extraction
+
+The monitor extracts 20 features from sliding windows of `/cmd_vel` and `/imu` data:
+
+**Command Velocity Features (8):**
+- Mean, std, min, max of linear.x (forward velocity)
+- Mean, std, min, max of angular.z (yaw rate)
+
+**IMU Features (8):**
+- Mean, std, min, max of accel.x (forward acceleration)
+- Mean, std, min, max of gyro.z (yaw angular velocity)
+
+**Cross-Features (4):**
+- Correlation between cmd_vel.linear.x and imu.accel.x
+- Correlation between cmd_vel.angular.z and imu.gyro.z
+- Ratio of imu.accel to cmd_vel.linear
+- Ratio of imu.gyro to cmd_vel.angular
+
+These features capture the expected physical relationship between commanded motion and sensor response. Anomalies occur when this relationship breaks down (e.g., wheel slip, motor failure, unexpected obstacles).
+
+### SVDD Model
+
+The OneClassSVM is trained on features extracted from normal operation data. It learns a decision boundary that encompasses normal operation patterns. During monitoring, new feature vectors are classified as:
+
+- **Inliers (normal)**: Decision function > threshold
+- **Outliers (anomalies)**: Decision function < threshold
+
+The decision function value is published as the anomaly score, allowing for tunable sensitivity.
+
+## Example Use Cases
+
+1. **Wheel slip detection**: Commanded forward motion without corresponding IMU acceleration
+2. **Motor failure**: No angular velocity despite commanded turning
+3. **Collision detection**: Unexpected deceleration (high negative acceleration)
+4. **Terrain anomaly**: Unusual vibration patterns in IMU during motion
+5. **Sensor failure**: Loss of correlation between command and measurement
+
+## Testing
+
+Run unit tests with pytest:
+
+```bash
+cd src/ros2_svdd_monitor
+pytest test/ -v
+```
+
+Tests cover:
+- Feature extraction correctness
+- Model training and prediction
+- Model save/load functionality
+- Edge cases (empty windows, missing data)
+
+## Development
+
+This package includes a devcontainer for development:
+
+1. Open the repository in VS Code
+2. Click "Reopen in Container" when prompted
+3. The container includes ROS 2 Humble and all dependencies
+
+See the template README for more details on devcontainer usage.
+
+## Topics
+
+### Subscribed Topics
+
+- `/cmd_vel` (geometry_msgs/Twist): Commanded velocity
+- `/imu` (sensor_msgs/Imu): IMU measurements
+
+### Published Topics
+
+- `/svdd/anomaly` (std_msgs/Bool): True if anomaly detected
+- `/svdd/anomaly_score` (std_msgs/Float32): Anomaly score (decision function value)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Citation
+
+If you use this package in your research, please cite:
+
+```bibtex
+@software{ros2_svdd_monitor,
+ title = {ros2_svdd_monitor: SVDD Anomaly Detection for ROS 2},
+ author = {LCAS},
+ year = {2025},
+ url = {https://github.com/LCAS/ros2_svdd_monitor}
+}
+```
+
+## Acknowledgments
+
+This package was created from the [LCAS ROS 2 Package Template](https://github.com/LCAS/ros2_pkg_template).
+
+## Troubleshooting
+
+### Model file not found
+Ensure you've trained a model first using the `train` command. Check that the model path in `config.yaml` points to the correct location.
+
+### No anomaly detection
+- Check that both `/cmd_vel` and `/imu` topics are publishing data
+- Verify that the window has filled (requires `window_size` samples)
+- Try adjusting the `anomaly_threshold` in the config
+
+### Too many false positives
+- Increase `anomaly_threshold` (more lenient)
+- Increase `nu` during training (allows more outliers)
+- Collect more diverse training data
+
+### Too many false negatives
+- Decrease `anomaly_threshold` (more strict)
+- Decrease `nu` during training (stricter model)
+- Ensure training data only contains normal operation
+
+## References
+
+- Tax, D. M., & Duin, R. P. (2004). Support vector data description. Machine learning, 54(1), 45-66.
+- Schölkopf, B., et al. (2001). Estimating the support of a high-dimensional distribution. Neural computation, 13(7), 1443-1471.
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..332d646
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,5 @@
+scikit-learn>=1.0.0
+numpy>=1.20.0
+pandas>=1.3.0
+joblib>=1.0.0
+pyyaml>=5.4.0
diff --git a/src/ros2_svdd_monitor/config/config.yaml b/src/ros2_svdd_monitor/config/config.yaml
new file mode 100644
index 0000000..0243a8e
--- /dev/null
+++ b/src/ros2_svdd_monitor/config/config.yaml
@@ -0,0 +1,25 @@
+# SVDD Monitor Configuration
+
+# Sliding window parameters
+window_size: 10 # Number of recent samples to use for feature extraction
+
+# OneClassSVM hyperparameters
+nu: 0.1 # Upper bound on fraction of training errors and lower bound on fraction of support vectors
+gamma: 'scale' # Kernel coefficient for RBF ('scale' or 'auto' or float value)
+
+# Model paths
+model_path: 'svdd_model.pkl' # Path to save/load trained model
+scaler_path: 'scaler.pkl' # Path to save/load feature scaler
+
+# Anomaly detection threshold
+# Predictions from OneClassSVM: 1 for inliers, -1 for outliers
+# Decision function returns signed distance to separating hyperplane
+anomaly_threshold: 0.0 # Threshold for anomaly score (decision function)
+
+# Training parameters
+test_size: 0.2 # Fraction of data to use for validation (optional)
+random_state: 42 # Random seed for reproducibility
+
+# Feature extraction parameters
+# Features include statistics (mean, std, min, max) of cmd_vel and IMU data over the window
+feature_scaling: true # Whether to scale features before training/inference
diff --git a/src/ros2_svdd_monitor/package.xml b/src/ros2_svdd_monitor/package.xml
new file mode 100644
index 0000000..51f506f
--- /dev/null
+++ b/src/ros2_svdd_monitor/package.xml
@@ -0,0 +1,20 @@
+
+
+
+ ros2_svdd_monitor
+ 0.1.0
+ SVDD-style anomaly detection for ROS 2 using proprioceptive sensors (IMU and cmd_vel)
+ LCAS
+ MIT
+
+ rclpy
+ std_msgs
+ geometry_msgs
+ sensor_msgs
+
+ python3-pytest
+
+
+ ament_python
+
+
diff --git a/src/ros2_svdd_monitor/pytest.ini b/src/ros2_svdd_monitor/pytest.ini
new file mode 100644
index 0000000..4e3badb
--- /dev/null
+++ b/src/ros2_svdd_monitor/pytest.ini
@@ -0,0 +1,6 @@
+[pytest]
+testpaths = test
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+addopts = -v --tb=short
diff --git a/src/ros2_svdd_monitor/resource/ros2_svdd_monitor b/src/ros2_svdd_monitor/resource/ros2_svdd_monitor
new file mode 100644
index 0000000..e69de29
diff --git a/src/ros2_svdd_monitor/ros2_svdd_monitor/__init__.py b/src/ros2_svdd_monitor/ros2_svdd_monitor/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/ros2_svdd_monitor/ros2_svdd_monitor/features.py b/src/ros2_svdd_monitor/ros2_svdd_monitor/features.py
new file mode 100644
index 0000000..a5eae8c
--- /dev/null
+++ b/src/ros2_svdd_monitor/ros2_svdd_monitor/features.py
@@ -0,0 +1,224 @@
+"""
+Feature Extraction for SVDD Anomaly Detection
+
+This module extracts features from sliding windows of cmd_vel and IMU data.
+Features capture the relationship between commanded velocity and expected IMU response.
+"""
+
+import numpy as np
+
+
+def extract_window_features(cmd_vel_window, imu_window):
+ """
+ Extract statistical features from cmd_vel and IMU sliding windows.
+
+ This function computes features that capture:
+ - cmd_vel statistics (linear and angular velocities)
+ - IMU statistics (linear acceleration and angular velocity)
+ - Cross-features mapping cmd_vel to expected IMU response
+
+ Args:
+ cmd_vel_window: List of cmd_vel messages (linear.x, linear.y, linear.z,
+ angular.x, angular.y, angular.z)
+ imu_window: List of IMU messages (linear_acceleration.x/y/z,
+ angular_velocity.x/y/z)
+
+ Returns:
+ numpy array of extracted features
+ """
+ features = []
+
+ # Extract cmd_vel data
+ if len(cmd_vel_window) > 0:
+ cmd_vel_array = np.array(cmd_vel_window)
+
+ # Statistics for linear velocity
+ features.extend([
+ np.mean(cmd_vel_array[:, 0]), # mean linear.x
+ np.std(cmd_vel_array[:, 0]), # std linear.x
+ np.min(cmd_vel_array[:, 0]), # min linear.x
+ np.max(cmd_vel_array[:, 0]), # max linear.x
+ ])
+
+ # Statistics for angular velocity (z-axis, typical for differential drive)
+ features.extend([
+ np.mean(cmd_vel_array[:, 5]), # mean angular.z
+ np.std(cmd_vel_array[:, 5]), # std angular.z
+ np.min(cmd_vel_array[:, 5]), # min angular.z
+ np.max(cmd_vel_array[:, 5]), # max angular.z
+ ])
+ else:
+ # If no cmd_vel data, use zeros
+ features.extend([0.0] * 8)
+
+ # Extract IMU data
+ if len(imu_window) > 0:
+ imu_array = np.array(imu_window)
+
+ # Statistics for linear acceleration (x-axis, forward acceleration)
+ features.extend([
+ np.mean(imu_array[:, 0]), # mean accel.x
+ np.std(imu_array[:, 0]), # std accel.x
+ np.min(imu_array[:, 0]), # min accel.x
+ np.max(imu_array[:, 0]), # max accel.x
+ ])
+
+ # Statistics for angular velocity (z-axis gyroscope)
+ features.extend([
+ np.mean(imu_array[:, 5]), # mean gyro.z
+ np.std(imu_array[:, 5]), # std gyro.z
+ np.min(imu_array[:, 5]), # min gyro.z
+ np.max(imu_array[:, 5]), # max gyro.z
+ ])
+ else:
+ # If no IMU data, use zeros
+ features.extend([0.0] * 8)
+
+ # Cross-features: relationship between cmd_vel and IMU
+ if len(cmd_vel_window) > 0 and len(imu_window) > 0:
+ cmd_vel_array = np.array(cmd_vel_window)
+ imu_array = np.array(imu_window)
+
+ # Expected: forward cmd_vel (linear.x) should correlate with forward accel (accel.x)
+ cmd_linear = cmd_vel_array[:, 0]
+ imu_accel = imu_array[:, 0]
+
+ # Compute correlation if we have variance
+ if np.std(cmd_linear) > 1e-6 and np.std(imu_accel) > 1e-6:
+ correlation = np.corrcoef(cmd_linear, imu_accel)[0, 1]
+ if np.isnan(correlation):
+ correlation = 0.0
+ else:
+ correlation = 0.0
+
+ features.append(correlation)
+
+ # Expected: angular cmd_vel (angular.z) should correlate with gyro (gyro.z)
+ cmd_angular = cmd_vel_array[:, 5]
+ imu_gyro = imu_array[:, 5]
+
+ if np.std(cmd_angular) > 1e-6 and np.std(imu_gyro) > 1e-6:
+ correlation = np.corrcoef(cmd_angular, imu_gyro)[0, 1]
+ if np.isnan(correlation):
+ correlation = 0.0
+ else:
+ correlation = 0.0
+
+ features.append(correlation)
+
+ # Magnitude ratios (should be relatively stable for normal operation)
+ mean_cmd_linear = np.mean(np.abs(cmd_linear))
+ mean_imu_accel = np.mean(np.abs(imu_accel))
+
+ if mean_cmd_linear > 1e-6:
+ accel_ratio = mean_imu_accel / mean_cmd_linear
+ else:
+ accel_ratio = 0.0
+
+ features.append(accel_ratio)
+
+ mean_cmd_angular = np.mean(np.abs(cmd_angular))
+ mean_imu_gyro = np.mean(np.abs(imu_gyro))
+
+ if mean_cmd_angular > 1e-6:
+ gyro_ratio = mean_imu_gyro / mean_cmd_angular
+ else:
+ gyro_ratio = 0.0
+
+ features.append(gyro_ratio)
+ else:
+ # If missing data, use zeros for cross-features
+ features.extend([0.0] * 4)
+
+ return np.array(features)
+
+
+def extract_features_from_dataframe(df, window_size=10):
+ """
+ Extract features from a pandas DataFrame containing synchronized cmd_vel and IMU data.
+
+ Args:
+ df: DataFrame with columns for cmd_vel (linear_x, angular_z) and
+ IMU (accel_x, gyro_z, etc.)
+ window_size: Size of the sliding window
+
+ Returns:
+ numpy array of features, shape (n_samples, n_features)
+ """
+ features_list = []
+
+ # Expected columns for cmd_vel
+ cmd_vel_cols = ['cmd_vel_linear_x', 'cmd_vel_linear_y', 'cmd_vel_linear_z',
+ 'cmd_vel_angular_x', 'cmd_vel_angular_y', 'cmd_vel_angular_z']
+
+ # Expected columns for IMU
+ imu_cols = ['imu_accel_x', 'imu_accel_y', 'imu_accel_z',
+ 'imu_gyro_x', 'imu_gyro_y', 'imu_gyro_z']
+
+ # Check if columns exist, if not use simplified names
+ if not all(col in df.columns for col in cmd_vel_cols):
+ # Try simplified column names
+ cmd_vel_cols = ['linear_x', 'linear_y', 'linear_z',
+ 'angular_x', 'angular_y', 'angular_z']
+
+ if not all(col in df.columns for col in imu_cols):
+ # Try simplified column names
+ imu_cols = ['accel_x', 'accel_y', 'accel_z',
+ 'gyro_x', 'gyro_y', 'gyro_z']
+
+ # Extract data
+ try:
+ cmd_vel_data = df[cmd_vel_cols].values
+ imu_data = df[imu_cols].values
+ except KeyError as e:
+ raise ValueError(f"Missing required columns in DataFrame: {e}")
+
+ # Sliding window feature extraction
+ for i in range(len(df)):
+ start_idx = max(0, i - window_size + 1)
+ end_idx = i + 1
+
+ cmd_vel_window = cmd_vel_data[start_idx:end_idx]
+ imu_window = imu_data[start_idx:end_idx]
+
+ features = extract_window_features(cmd_vel_window, imu_window)
+ features_list.append(features)
+
+ return np.array(features_list)
+
+
+def get_feature_names():
+ """
+ Get names of all features for interpretability.
+
+ Returns:
+ List of feature names
+ """
+ feature_names = [
+ # cmd_vel linear.x statistics
+ 'cmd_vel_linear_x_mean',
+ 'cmd_vel_linear_x_std',
+ 'cmd_vel_linear_x_min',
+ 'cmd_vel_linear_x_max',
+ # cmd_vel angular.z statistics
+ 'cmd_vel_angular_z_mean',
+ 'cmd_vel_angular_z_std',
+ 'cmd_vel_angular_z_min',
+ 'cmd_vel_angular_z_max',
+ # IMU accel.x statistics
+ 'imu_accel_x_mean',
+ 'imu_accel_x_std',
+ 'imu_accel_x_min',
+ 'imu_accel_x_max',
+ # IMU gyro.z statistics
+ 'imu_gyro_z_mean',
+ 'imu_gyro_z_std',
+ 'imu_gyro_z_min',
+ 'imu_gyro_z_max',
+ # Cross-features
+ 'cmd_linear_to_imu_accel_correlation',
+ 'cmd_angular_to_imu_gyro_correlation',
+ 'imu_accel_to_cmd_linear_ratio',
+ 'imu_gyro_to_cmd_angular_ratio',
+ ]
+ return feature_names
diff --git a/src/ros2_svdd_monitor/ros2_svdd_monitor/monitor.py b/src/ros2_svdd_monitor/ros2_svdd_monitor/monitor.py
new file mode 100644
index 0000000..6ee3843
--- /dev/null
+++ b/src/ros2_svdd_monitor/ros2_svdd_monitor/monitor.py
@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""
+SVDD Anomaly Monitor Node
+
+This ROS 2 node subscribes to /cmd_vel and /imu topics, maintains sliding windows,
+extracts features, and publishes anomaly detection results.
+
+Publishes:
+ /svdd/anomaly (std_msgs/Bool): True if anomaly detected
+ /svdd/anomaly_score (std_msgs/Float32): Anomaly score (decision function value)
+"""
+
+import os
+import sys
+import yaml
+from collections import deque
+import numpy as np
+
+import rclpy
+from rclpy.node import Node
+from geometry_msgs.msg import Twist
+from sensor_msgs.msg import Imu
+from std_msgs.msg import Bool, Float32
+
+from ros2_svdd_monitor.svdd_model import SVDDModel
+from ros2_svdd_monitor.features import extract_window_features
+
+
+class SVDDMonitor(Node):
+ """
+ ROS 2 node for real-time SVDD-based anomaly detection.
+ """
+
+ def __init__(self, config_path=None):
+ super().__init__('svdd_monitor')
+
+ # Load configuration
+ self.config = self.load_config(config_path)
+
+ # Initialize sliding windows
+ self.window_size = self.config['window_size']
+ self.cmd_vel_window = deque(maxlen=self.window_size)
+ self.imu_window = deque(maxlen=self.window_size)
+
+ # Load trained model
+ self.model = SVDDModel()
+ model_path = self.config['model_path']
+ scaler_path = self.config['scaler_path']
+
+ if not os.path.exists(model_path):
+ self.get_logger().error(f"Model file not found: {model_path}")
+ self.get_logger().error("Please train a model first using: ros2 run ros2_svdd_monitor train")
+ sys.exit(1)
+
+ self.get_logger().info(f"Loading model from {model_path}...")
+ self.model.load(model_path, scaler_path)
+ self.get_logger().info("Model loaded successfully!")
+
+ # Anomaly threshold
+ self.anomaly_threshold = self.config.get('anomaly_threshold', 0.0)
+
+ # Subscribers
+ self.cmd_vel_sub = self.create_subscription(
+ Twist,
+ '/cmd_vel',
+ self.cmd_vel_callback,
+ 10
+ )
+
+ self.imu_sub = self.create_subscription(
+ Imu,
+ '/imu',
+ self.imu_callback,
+ 10
+ )
+
+ # Publishers
+ self.anomaly_pub = self.create_publisher(Bool, '/svdd/anomaly', 10)
+ self.score_pub = self.create_publisher(Float32, '/svdd/anomaly_score', 10)
+
+ # Statistics
+ self.message_count = 0
+ self.anomaly_count = 0
+
+ self.get_logger().info("SVDD Monitor started!")
+ self.get_logger().info(f"Window size: {self.window_size}")
+ self.get_logger().info(f"Anomaly threshold: {self.anomaly_threshold}")
+ self.get_logger().info("Subscribing to /cmd_vel and /imu")
+ self.get_logger().info("Publishing to /svdd/anomaly and /svdd/anomaly_score")
+
+ def load_config(self, config_path=None):
+ """Load configuration from YAML file."""
+ if config_path is None:
+ # Search for config in common locations
+ possible_paths = [
+ 'config/config.yaml',
+ '../config/config.yaml',
+ os.path.join(os.path.dirname(__file__), '../config/config.yaml'),
+ ]
+
+ for path in possible_paths:
+ if os.path.exists(path):
+ config_path = path
+ break
+
+ if config_path is None:
+ self.get_logger().error("Could not find config.yaml")
+ sys.exit(1)
+
+ with open(config_path, 'r') as f:
+ config = yaml.safe_load(f)
+
+ return config
+
+ def cmd_vel_callback(self, msg):
+ """Handle incoming cmd_vel messages."""
+ # Store as array: [linear.x, linear.y, linear.z, angular.x, angular.y, angular.z]
+ cmd_vel_data = [
+ msg.linear.x,
+ msg.linear.y,
+ msg.linear.z,
+ msg.angular.x,
+ msg.angular.y,
+ msg.angular.z,
+ ]
+ self.cmd_vel_window.append(cmd_vel_data)
+
+ # Check for anomaly if we have enough data
+ if len(self.cmd_vel_window) >= self.window_size and len(self.imu_window) >= self.window_size:
+ self.check_for_anomaly()
+
+ def imu_callback(self, msg):
+ """Handle incoming IMU messages."""
+ # Store as array: [accel.x, accel.y, accel.z, gyro.x, gyro.y, gyro.z]
+ imu_data = [
+ msg.linear_acceleration.x,
+ msg.linear_acceleration.y,
+ msg.linear_acceleration.z,
+ msg.angular_velocity.x,
+ msg.angular_velocity.y,
+ msg.angular_velocity.z,
+ ]
+ self.imu_window.append(imu_data)
+
+ # Check for anomaly if we have enough data
+ if len(self.cmd_vel_window) >= self.window_size and len(self.imu_window) >= self.window_size:
+ self.check_for_anomaly()
+
+ def check_for_anomaly(self):
+ """
+ Extract features from current windows and check for anomaly.
+ """
+ # Extract features from current windows
+ cmd_vel_array = list(self.cmd_vel_window)
+ imu_array = list(self.imu_window)
+
+ features = extract_window_features(cmd_vel_array, imu_array)
+ features = features.reshape(1, -1) # Reshape for single prediction
+
+ # Get anomaly score (decision function)
+ score = self.model.decision_function(
+ features,
+ scale=self.config.get('feature_scaling', True)
+ )[0]
+
+ # Predict anomaly
+ prediction = self.model.predict(
+ features,
+ scale=self.config.get('feature_scaling', True)
+ )[0]
+
+ is_anomaly = (prediction == -1) or (score < self.anomaly_threshold)
+
+ # Publish results
+ anomaly_msg = Bool()
+ anomaly_msg.data = bool(is_anomaly)
+ self.anomaly_pub.publish(anomaly_msg)
+
+ score_msg = Float32()
+ score_msg.data = float(score)
+ self.score_pub.publish(score_msg)
+
+ # Update statistics
+ self.message_count += 1
+ if is_anomaly:
+ self.anomaly_count += 1
+
+ # Log periodically
+ if self.message_count % 100 == 0:
+ anomaly_rate = self.anomaly_count / self.message_count * 100
+ self.get_logger().info(
+ f"Processed {self.message_count} samples, "
+ f"anomalies: {self.anomaly_count} ({anomaly_rate:.2f}%)"
+ )
+
+ # Log anomalies
+ if is_anomaly:
+ self.get_logger().warn(
+ f"ANOMALY DETECTED! Score: {score:.4f} (threshold: {self.anomaly_threshold})"
+ )
+
+
+def main(args=None):
+ """Main entry point for the SVDD monitor node."""
+ rclpy.init(args=args)
+
+ # Check for config path argument
+ config_path = None
+ if len(sys.argv) > 1:
+ config_path = sys.argv[1]
+
+ node = SVDDMonitor(config_path=config_path)
+
+ try:
+ rclpy.spin(node)
+ except KeyboardInterrupt:
+ pass
+ finally:
+ node.destroy_node()
+ rclpy.shutdown()
+
+
+if __name__ == '__main__':
+ main()
diff --git a/src/ros2_svdd_monitor/ros2_svdd_monitor/svdd_model.py b/src/ros2_svdd_monitor/ros2_svdd_monitor/svdd_model.py
new file mode 100644
index 0000000..5ec39da
--- /dev/null
+++ b/src/ros2_svdd_monitor/ros2_svdd_monitor/svdd_model.py
@@ -0,0 +1,155 @@
+"""
+SVDD Model Wrapper using OneClassSVM
+
+This module provides a wrapper for sklearn's OneClassSVM to use as an SVDD
+(Support Vector Data Description) proxy for anomaly detection.
+"""
+
+import joblib
+import numpy as np
+from sklearn.svm import OneClassSVM
+from sklearn.preprocessing import StandardScaler
+
+
+class SVDDModel:
+ """
+ Wrapper for OneClassSVM to perform SVDD-based anomaly detection.
+ """
+
+ def __init__(self, nu=0.1, gamma='scale', kernel='rbf'):
+ """
+ Initialize the SVDD model.
+
+ Args:
+ nu: Upper bound on fraction of training errors and lower bound
+ on fraction of support vectors (0 < nu <= 1)
+ gamma: Kernel coefficient for RBF kernel
+ kernel: Kernel type to be used in the algorithm
+ """
+ self.nu = nu
+ self.gamma = gamma
+ self.kernel = kernel
+ self.model = OneClassSVM(nu=nu, gamma=gamma, kernel=kernel)
+ self.scaler = StandardScaler()
+ self.is_fitted = False
+
+ def fit(self, X, scale=True):
+ """
+ Train the SVDD model on the provided data.
+
+ Args:
+ X: Training data, shape (n_samples, n_features)
+ scale: Whether to apply feature scaling
+
+ Returns:
+ self
+ """
+ X = np.array(X)
+
+ if scale:
+ X_scaled = self.scaler.fit_transform(X)
+ else:
+ X_scaled = X
+
+ self.model.fit(X_scaled)
+ self.is_fitted = True
+ return self
+
+ def predict(self, X, scale=True):
+ """
+ Predict if samples are inliers (1) or outliers (-1).
+
+ Args:
+ X: Data to predict, shape (n_samples, n_features)
+ scale: Whether to apply feature scaling
+
+ Returns:
+ Array of predictions: 1 for inliers, -1 for outliers
+ """
+ if not self.is_fitted:
+ raise RuntimeError("Model must be fitted before prediction")
+
+ X = np.array(X)
+
+ if scale:
+ X_scaled = self.scaler.transform(X)
+ else:
+ X_scaled = X
+
+ return self.model.predict(X_scaled)
+
+ def decision_function(self, X, scale=True):
+ """
+ Compute the decision function (signed distance to separating hyperplane).
+
+ Args:
+ X: Data to evaluate, shape (n_samples, n_features)
+ scale: Whether to apply feature scaling
+
+ Returns:
+ Array of decision function values (anomaly scores)
+ Negative values indicate outliers
+ """
+ if not self.is_fitted:
+ raise RuntimeError("Model must be fitted before prediction")
+
+ X = np.array(X)
+
+ if scale:
+ X_scaled = self.scaler.transform(X)
+ else:
+ X_scaled = X
+
+ return self.model.decision_function(X_scaled)
+
+ def save(self, model_path, scaler_path=None):
+ """
+ Save the trained model and scaler to disk.
+
+ Args:
+ model_path: Path to save the model
+ scaler_path: Path to save the scaler (optional)
+ """
+ if not self.is_fitted:
+ raise RuntimeError("Model must be fitted before saving")
+
+ joblib.dump(self.model, model_path)
+
+ if scaler_path:
+ joblib.dump(self.scaler, scaler_path)
+
+ print(f"Model saved to {model_path}")
+ if scaler_path:
+ print(f"Scaler saved to {scaler_path}")
+
+ def load(self, model_path, scaler_path=None):
+ """
+ Load a trained model and scaler from disk.
+
+ Args:
+ model_path: Path to load the model from
+ scaler_path: Path to load the scaler from (optional)
+ """
+ self.model = joblib.load(model_path)
+
+ if scaler_path:
+ self.scaler = joblib.load(scaler_path)
+
+ self.is_fitted = True
+ print(f"Model loaded from {model_path}")
+ if scaler_path:
+ print(f"Scaler loaded from {scaler_path}")
+
+ def get_params(self):
+ """
+ Get model parameters.
+
+ Returns:
+ Dictionary of model parameters
+ """
+ return {
+ 'nu': self.nu,
+ 'gamma': self.gamma,
+ 'kernel': self.kernel,
+ 'is_fitted': self.is_fitted
+ }
diff --git a/src/ros2_svdd_monitor/ros2_svdd_monitor/train.py b/src/ros2_svdd_monitor/ros2_svdd_monitor/train.py
new file mode 100644
index 0000000..34bf38b
--- /dev/null
+++ b/src/ros2_svdd_monitor/ros2_svdd_monitor/train.py
@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""
+Train SVDD Model CLI
+
+This script trains an SVDD model (OneClassSVM) on normal operation data
+exported from rosbag to CSV format.
+
+Usage:
+ ros2 run ros2_svdd_monitor train --csv --config
+"""
+
+import argparse
+import os
+import sys
+import yaml
+import pandas as pd
+import numpy as np
+from pathlib import Path
+
+from ros2_svdd_monitor.svdd_model import SVDDModel
+from ros2_svdd_monitor.features import extract_features_from_dataframe, get_feature_names
+
+
+def load_config(config_path):
+ """Load configuration from YAML file."""
+ with open(config_path, 'r') as f:
+ config = yaml.safe_load(f)
+ return config
+
+
+def load_training_data(csv_path):
+ """Load training data from CSV file."""
+ print(f"Loading training data from {csv_path}...")
+ df = pd.read_csv(csv_path)
+ print(f"Loaded {len(df)} samples")
+ print(f"Columns: {list(df.columns)}")
+ return df
+
+
+def main():
+ """Main training function."""
+ parser = argparse.ArgumentParser(
+ description='Train SVDD model for anomaly detection'
+ )
+ parser.add_argument(
+ '--csv',
+ type=str,
+ required=True,
+ help='Path to CSV file with training data'
+ )
+ parser.add_argument(
+ '--config',
+ type=str,
+ default=None,
+ help='Path to config YAML file (default: searches for config/config.yaml)'
+ )
+ parser.add_argument(
+ '--output-dir',
+ type=str,
+ default='.',
+ help='Directory to save trained model and scaler'
+ )
+
+ args = parser.parse_args()
+
+ # Find config file
+ if args.config is None:
+ # Search for config in common locations
+ possible_paths = [
+ 'config/config.yaml',
+ '../config/config.yaml',
+ os.path.join(os.path.dirname(__file__), '../config/config.yaml'),
+ ]
+
+ config_path = None
+ for path in possible_paths:
+ if os.path.exists(path):
+ config_path = path
+ break
+
+ if config_path is None:
+ print("Error: Could not find config.yaml. Please specify with --config")
+ sys.exit(1)
+ else:
+ config_path = args.config
+
+ print(f"Using config: {config_path}")
+ config = load_config(config_path)
+
+ # Load training data
+ df = load_training_data(args.csv)
+
+ # Extract features
+ print(f"\nExtracting features with window_size={config['window_size']}...")
+ try:
+ features = extract_features_from_dataframe(df, window_size=config['window_size'])
+ except ValueError as e:
+ print(f"Error extracting features: {e}")
+ print("\nExpected CSV columns:")
+ print(" timestamp, linear_x, linear_y, linear_z, angular_x, angular_y, angular_z,")
+ print(" accel_x, accel_y, accel_z, gyro_x, gyro_y, gyro_z")
+ sys.exit(1)
+
+ print(f"Extracted {features.shape[0]} feature vectors with {features.shape[1]} features each")
+
+ # Print feature statistics
+ feature_names = get_feature_names()
+ print("\nFeature statistics:")
+ for i, name in enumerate(feature_names):
+ print(f" {name}: mean={features[:, i].mean():.4f}, std={features[:, i].std():.4f}")
+
+ # Initialize and train model
+ print(f"\nTraining SVDD model (OneClassSVM)...")
+ print(f" nu={config['nu']}")
+ print(f" gamma={config['gamma']}")
+
+ model = SVDDModel(
+ nu=config['nu'],
+ gamma=config['gamma']
+ )
+
+ model.fit(features, scale=config.get('feature_scaling', True))
+ print("Training completed!")
+
+ # Evaluate on training data
+ predictions = model.predict(features, scale=config.get('feature_scaling', True))
+ n_outliers = np.sum(predictions == -1)
+ outlier_ratio = n_outliers / len(predictions)
+
+ print(f"\nTraining set evaluation:")
+ print(f" Total samples: {len(predictions)}")
+ print(f" Outliers detected: {n_outliers} ({outlier_ratio*100:.2f}%)")
+ print(f" Inliers: {len(predictions) - n_outliers} ({(1-outlier_ratio)*100:.2f}%)")
+
+ # Save model and scaler
+ os.makedirs(args.output_dir, exist_ok=True)
+
+ model_path = os.path.join(args.output_dir, config['model_path'])
+ scaler_path = os.path.join(args.output_dir, config['scaler_path'])
+
+ print(f"\nSaving model to {model_path}...")
+ model.save(model_path, scaler_path)
+
+ print("\n" + "="*60)
+ print("Training complete!")
+ print("="*60)
+ print(f"Model saved to: {model_path}")
+ print(f"Scaler saved to: {scaler_path}")
+ print("\nYou can now run the monitor with:")
+ print(f" ros2 run ros2_svdd_monitor monitor")
+
+
+if __name__ == '__main__':
+ main()
diff --git a/src/ros2_svdd_monitor/ros2_svdd_monitor/utils/__init__.py b/src/ros2_svdd_monitor/ros2_svdd_monitor/utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/ros2_svdd_monitor/ros2_svdd_monitor/utils/rosbag_to_csv.py b/src/ros2_svdd_monitor/ros2_svdd_monitor/utils/rosbag_to_csv.py
new file mode 100644
index 0000000..818a5db
--- /dev/null
+++ b/src/ros2_svdd_monitor/ros2_svdd_monitor/utils/rosbag_to_csv.py
@@ -0,0 +1,148 @@
+"""
+Rosbag to CSV Converter
+
+This utility helps export /cmd_vel and /imu topics from a ROS 2 bag to CSV format
+for training the SVDD model.
+
+Usage:
+ ros2 run ros2_svdd_monitor rosbag_to_csv
+
+Or use this as a reference to create a custom subscriber that writes synchronized
+CSV rows during data collection.
+"""
+
+import rclpy
+from rclpy.node import Node
+from geometry_msgs.msg import Twist
+from sensor_msgs.msg import Imu
+import csv
+from collections import deque
+import sys
+
+
+class BagToCSVConverter(Node):
+ """
+ Node to subscribe to /cmd_vel and /imu and write synchronized data to CSV.
+
+ This can be run live while recording a rosbag to create training data.
+ """
+
+ def __init__(self, output_csv_path):
+ super().__init__('rosbag_to_csv_converter')
+
+ self.output_csv_path = output_csv_path
+ self.csv_file = open(output_csv_path, 'w', newline='')
+ self.csv_writer = csv.writer(self.csv_file)
+
+ # Write header
+ self.csv_writer.writerow([
+ 'timestamp',
+ 'linear_x', 'linear_y', 'linear_z',
+ 'angular_x', 'angular_y', 'angular_z',
+ 'accel_x', 'accel_y', 'accel_z',
+ 'gyro_x', 'gyro_y', 'gyro_z'
+ ])
+
+ # Store latest messages
+ self.latest_cmd_vel = None
+ self.latest_imu = None
+
+ # Subscriptions
+ self.cmd_vel_sub = self.create_subscription(
+ Twist,
+ '/cmd_vel',
+ self.cmd_vel_callback,
+ 10
+ )
+
+ self.imu_sub = self.create_subscription(
+ Imu,
+ '/imu',
+ self.imu_callback,
+ 10
+ )
+
+ self.get_logger().info(f'Recording to {output_csv_path}')
+ self.get_logger().info('Subscribing to /cmd_vel and /imu')
+
+ self.sample_count = 0
+
+ def cmd_vel_callback(self, msg):
+ """Store latest cmd_vel message."""
+ self.latest_cmd_vel = msg
+ self.try_write_row()
+
+ def imu_callback(self, msg):
+ """Store latest IMU message."""
+ self.latest_imu = msg
+ self.try_write_row()
+
+ def try_write_row(self):
+ """
+ Write a row to CSV if we have both cmd_vel and IMU data.
+ """
+ if self.latest_cmd_vel is not None and self.latest_imu is not None:
+ timestamp = self.get_clock().now().nanoseconds / 1e9
+
+ row = [
+ timestamp,
+ self.latest_cmd_vel.linear.x,
+ self.latest_cmd_vel.linear.y,
+ self.latest_cmd_vel.linear.z,
+ self.latest_cmd_vel.angular.x,
+ self.latest_cmd_vel.angular.y,
+ self.latest_cmd_vel.angular.z,
+ self.latest_imu.linear_acceleration.x,
+ self.latest_imu.linear_acceleration.y,
+ self.latest_imu.linear_acceleration.z,
+ self.latest_imu.angular_velocity.x,
+ self.latest_imu.angular_velocity.y,
+ self.latest_imu.angular_velocity.z,
+ ]
+
+ self.csv_writer.writerow(row)
+ self.sample_count += 1
+
+ if self.sample_count % 100 == 0:
+ self.get_logger().info(f'Recorded {self.sample_count} samples')
+
+ def __del__(self):
+ """Close CSV file on cleanup."""
+ if hasattr(self, 'csv_file'):
+ self.csv_file.close()
+ self.get_logger().info(f'Closed CSV file with {self.sample_count} samples')
+
+
+def main(args=None):
+ """
+ Main entry point for rosbag to CSV converter.
+
+ Usage:
+ python -m ros2_svdd_monitor.utils.rosbag_to_csv output.csv
+
+ Then play your rosbag:
+ ros2 bag play
+
+ Or run this alongside your robot to collect training data.
+ """
+ if len(sys.argv) < 2:
+ print("Usage: ros2 run ros2_svdd_monitor rosbag_to_csv ")
+ print("Then play your rosbag: ros2 bag play ")
+ return
+
+ output_csv = sys.argv[1]
+
+ rclpy.init(args=args)
+ node = BagToCSVConverter(output_csv)
+
+ try:
+ rclpy.spin(node)
+ except KeyboardInterrupt:
+ pass
+ finally:
+ node.destroy_node()
+ rclpy.shutdown()
+
+
+if __name__ == '__main__':
+ main()
diff --git a/src/ros2_svdd_monitor/setup.cfg b/src/ros2_svdd_monitor/setup.cfg
new file mode 100644
index 0000000..473ba4c
--- /dev/null
+++ b/src/ros2_svdd_monitor/setup.cfg
@@ -0,0 +1,4 @@
+[develop]
+script_dir=$base/lib/ros2_svdd_monitor
+[install]
+install_scripts=$base/lib/ros2_svdd_monitor
diff --git a/src/ros2_svdd_monitor/setup.py b/src/ros2_svdd_monitor/setup.py
new file mode 100644
index 0000000..dd26776
--- /dev/null
+++ b/src/ros2_svdd_monitor/setup.py
@@ -0,0 +1,37 @@
+from setuptools import setup, find_packages
+import os
+from glob import glob
+
+package_name = 'ros2_svdd_monitor'
+
+setup(
+ name=package_name,
+ version='0.1.0',
+ packages=find_packages(exclude=['test']),
+ data_files=[
+ ('share/ament_index/resource_index/packages',
+ ['resource/' + package_name]),
+ ('share/' + package_name, ['package.xml']),
+ (os.path.join('share', package_name, 'config'), glob('config/*.yaml')),
+ ],
+ install_requires=[
+ 'setuptools',
+ 'scikit-learn',
+ 'numpy',
+ 'pandas',
+ 'joblib',
+ 'pyyaml',
+ ],
+ zip_safe=True,
+ maintainer='LCAS',
+ maintainer_email='lcas@lincoln.ac.uk',
+ description='SVDD-style anomaly detection for ROS 2 using proprioceptive sensors',
+ license='MIT',
+ tests_require=['pytest'],
+ entry_points={
+ 'console_scripts': [
+ 'train = ros2_svdd_monitor.train:main',
+ 'monitor = ros2_svdd_monitor.monitor:main',
+ ],
+ },
+)
diff --git a/src/ros2_svdd_monitor/test/__init__.py b/src/ros2_svdd_monitor/test/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/ros2_svdd_monitor/test/test_features.py b/src/ros2_svdd_monitor/test/test_features.py
new file mode 100644
index 0000000..9040da3
--- /dev/null
+++ b/src/ros2_svdd_monitor/test/test_features.py
@@ -0,0 +1,148 @@
+"""
+Unit tests for feature extraction module.
+"""
+
+import pytest
+import numpy as np
+import pandas as pd
+from ros2_svdd_monitor.features import (
+ extract_window_features,
+ extract_features_from_dataframe,
+ get_feature_names
+)
+
+
+class TestFeatureExtraction:
+ """Test suite for feature extraction functions."""
+
+ def test_extract_window_features_basic(self):
+ """Test basic feature extraction with simple data."""
+ # Create simple cmd_vel data (linear.x=1.0, angular.z=0.5)
+ cmd_vel_window = [
+ [1.0, 0.0, 0.0, 0.0, 0.0, 0.5],
+ [1.0, 0.0, 0.0, 0.0, 0.0, 0.5],
+ [1.0, 0.0, 0.0, 0.0, 0.0, 0.5],
+ ]
+
+ # Create simple IMU data (accel.x=2.0, gyro.z=1.0)
+ imu_window = [
+ [2.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+ [2.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+ [2.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+ ]
+
+ features = extract_window_features(cmd_vel_window, imu_window)
+
+ # Check feature vector length
+ assert len(features) == 20, "Should have 20 features"
+
+ # Check cmd_vel linear.x statistics
+ assert features[0] == 1.0, "Mean linear.x should be 1.0"
+ assert features[1] == 0.0, "Std linear.x should be 0.0"
+ assert features[2] == 1.0, "Min linear.x should be 1.0"
+ assert features[3] == 1.0, "Max linear.x should be 1.0"
+
+ # Check cmd_vel angular.z statistics
+ assert features[4] == 0.5, "Mean angular.z should be 0.5"
+
+ # Check IMU accel.x statistics
+ assert features[8] == 2.0, "Mean accel.x should be 2.0"
+
+ def test_extract_window_features_empty(self):
+ """Test feature extraction with empty windows."""
+ cmd_vel_window = []
+ imu_window = []
+
+ features = extract_window_features(cmd_vel_window, imu_window)
+
+ # Should return zeros for all features
+ assert len(features) == 20, "Should have 20 features"
+ assert np.all(features == 0.0), "All features should be zero for empty windows"
+
+ def test_extract_window_features_varying_data(self):
+ """Test feature extraction with varying data."""
+ # Create varying cmd_vel data
+ cmd_vel_window = [
+ [0.5, 0.0, 0.0, 0.0, 0.0, 0.0],
+ [1.0, 0.0, 0.0, 0.0, 0.0, 0.2],
+ [1.5, 0.0, 0.0, 0.0, 0.0, 0.4],
+ ]
+
+ # Create varying IMU data
+ imu_window = [
+ [1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+ [2.0, 0.0, 0.0, 0.0, 0.0, 0.1],
+ [3.0, 0.0, 0.0, 0.0, 0.0, 0.2],
+ ]
+
+ features = extract_window_features(cmd_vel_window, imu_window)
+
+ # Check that statistics are computed correctly
+ assert features[0] == 1.0, "Mean linear.x should be 1.0"
+ assert features[1] > 0.0, "Std linear.x should be > 0"
+ assert features[2] == 0.5, "Min linear.x should be 0.5"
+ assert features[3] == 1.5, "Max linear.x should be 1.5"
+
+ def test_extract_features_from_dataframe(self):
+ """Test feature extraction from a DataFrame."""
+ # Create sample DataFrame
+ data = {
+ 'timestamp': [1.0, 2.0, 3.0, 4.0, 5.0],
+ 'linear_x': [1.0, 1.0, 1.0, 1.0, 1.0],
+ 'linear_y': [0.0, 0.0, 0.0, 0.0, 0.0],
+ 'linear_z': [0.0, 0.0, 0.0, 0.0, 0.0],
+ 'angular_x': [0.0, 0.0, 0.0, 0.0, 0.0],
+ 'angular_y': [0.0, 0.0, 0.0, 0.0, 0.0],
+ 'angular_z': [0.5, 0.5, 0.5, 0.5, 0.5],
+ 'accel_x': [2.0, 2.0, 2.0, 2.0, 2.0],
+ 'accel_y': [0.0, 0.0, 0.0, 0.0, 0.0],
+ 'accel_z': [0.0, 0.0, 0.0, 0.0, 0.0],
+ 'gyro_x': [0.0, 0.0, 0.0, 0.0, 0.0],
+ 'gyro_y': [0.0, 0.0, 0.0, 0.0, 0.0],
+ 'gyro_z': [1.0, 1.0, 1.0, 1.0, 1.0],
+ }
+ df = pd.DataFrame(data)
+
+ features = extract_features_from_dataframe(df, window_size=3)
+
+ # Check shape
+ assert features.shape[0] == 5, "Should have 5 feature vectors"
+ assert features.shape[1] == 20, "Should have 20 features per vector"
+
+ # Check that features are computed
+ assert np.all(np.isfinite(features)), "All features should be finite"
+
+ def test_get_feature_names(self):
+ """Test that feature names are returned correctly."""
+ feature_names = get_feature_names()
+
+ assert len(feature_names) == 20, "Should have 20 feature names"
+ assert 'cmd_vel_linear_x_mean' in feature_names
+ assert 'imu_accel_x_mean' in feature_names
+ assert 'cmd_linear_to_imu_accel_correlation' in feature_names
+
+ def test_cross_features_correlation(self):
+ """Test that cross-feature correlations are computed."""
+ # Create perfectly correlated data
+ cmd_vel_window = [
+ [1.0, 0.0, 0.0, 0.0, 0.0, 0.5],
+ [2.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+ [3.0, 0.0, 0.0, 0.0, 0.0, 1.5],
+ ]
+
+ imu_window = [
+ [2.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+ [4.0, 0.0, 0.0, 0.0, 0.0, 2.0],
+ [6.0, 0.0, 0.0, 0.0, 0.0, 3.0],
+ ]
+
+ features = extract_window_features(cmd_vel_window, imu_window)
+
+ # Check correlation features (indices 16 and 17)
+ # Should be close to 1.0 for perfectly correlated data
+ assert features[16] > 0.99, "Linear correlation should be high"
+ assert features[17] > 0.99, "Angular correlation should be high"
+
+
+if __name__ == '__main__':
+ pytest.main([__file__, '-v'])
diff --git a/src/ros2_svdd_monitor/test/test_svdd_model.py b/src/ros2_svdd_monitor/test/test_svdd_model.py
new file mode 100644
index 0000000..ed1f72c
--- /dev/null
+++ b/src/ros2_svdd_monitor/test/test_svdd_model.py
@@ -0,0 +1,188 @@
+"""
+Unit tests for SVDD model wrapper.
+"""
+
+import pytest
+import numpy as np
+import tempfile
+import os
+from ros2_svdd_monitor.svdd_model import SVDDModel
+
+
+class TestSVDDModel:
+ """Test suite for SVDD model wrapper."""
+
+ def test_model_initialization(self):
+ """Test model initialization with default parameters."""
+ model = SVDDModel()
+
+ assert model.nu == 0.1
+ assert model.gamma == 'scale'
+ assert model.kernel == 'rbf'
+ assert not model.is_fitted
+
+ def test_model_initialization_custom(self):
+ """Test model initialization with custom parameters."""
+ model = SVDDModel(nu=0.2, gamma=0.5, kernel='rbf')
+
+ assert model.nu == 0.2
+ assert model.gamma == 0.5
+ assert model.kernel == 'rbf'
+
+ def test_model_fit(self):
+ """Test model fitting."""
+ # Generate simple training data
+ np.random.seed(42)
+ X_train = np.random.randn(100, 5)
+
+ model = SVDDModel(nu=0.1)
+ model.fit(X_train, scale=True)
+
+ assert model.is_fitted
+ assert model.scaler is not None
+
+ def test_model_predict_before_fit(self):
+ """Test that prediction fails before fitting."""
+ model = SVDDModel()
+ X_test = np.random.randn(10, 5)
+
+ with pytest.raises(RuntimeError):
+ model.predict(X_test)
+
+ def test_model_predict(self):
+ """Test model prediction."""
+ # Generate training data (normal operation)
+ np.random.seed(42)
+ X_train = np.random.randn(100, 5) * 0.5 # Small variance
+
+ # Train model
+ model = SVDDModel(nu=0.1)
+ model.fit(X_train, scale=True)
+
+ # Test on normal data
+ X_test_normal = np.random.randn(10, 5) * 0.5
+ predictions = model.predict(X_test_normal, scale=True)
+
+ assert len(predictions) == 10
+ assert all(p in [-1, 1] for p in predictions)
+
+ def test_model_decision_function(self):
+ """Test model decision function."""
+ # Generate training data
+ np.random.seed(42)
+ X_train = np.random.randn(100, 5)
+
+ # Train model
+ model = SVDDModel(nu=0.1)
+ model.fit(X_train, scale=True)
+
+ # Test decision function
+ X_test = np.random.randn(10, 5)
+ scores = model.decision_function(X_test, scale=True)
+
+ assert len(scores) == 10
+ assert all(np.isfinite(s) for s in scores)
+
+ def test_model_save_load(self):
+ """Test model save and load functionality."""
+ # Generate training data
+ np.random.seed(42)
+ X_train = np.random.randn(100, 5)
+
+ # Train model
+ model = SVDDModel(nu=0.15, gamma=0.5)
+ model.fit(X_train, scale=True)
+
+ # Get prediction before saving
+ X_test = np.random.randn(10, 5)
+ predictions_before = model.predict(X_test, scale=True)
+ scores_before = model.decision_function(X_test, scale=True)
+
+ # Save model
+ with tempfile.TemporaryDirectory() as tmpdir:
+ model_path = os.path.join(tmpdir, 'test_model.pkl')
+ scaler_path = os.path.join(tmpdir, 'test_scaler.pkl')
+
+ model.save(model_path, scaler_path)
+
+ # Load model
+ model_loaded = SVDDModel()
+ model_loaded.load(model_path, scaler_path)
+
+ # Get prediction after loading
+ predictions_after = model_loaded.predict(X_test, scale=True)
+ scores_after = model_loaded.decision_function(X_test, scale=True)
+
+ # Check that predictions are the same
+ assert np.array_equal(predictions_before, predictions_after)
+ assert np.allclose(scores_before, scores_after)
+
+ # Check that model is marked as fitted
+ assert model_loaded.is_fitted
+
+ def test_model_save_before_fit(self):
+ """Test that saving fails before fitting."""
+ model = SVDDModel()
+
+ with tempfile.TemporaryDirectory() as tmpdir:
+ model_path = os.path.join(tmpdir, 'test_model.pkl')
+
+ with pytest.raises(RuntimeError):
+ model.save(model_path)
+
+ def test_model_get_params(self):
+ """Test getting model parameters."""
+ model = SVDDModel(nu=0.2, gamma=0.5)
+ params = model.get_params()
+
+ assert params['nu'] == 0.2
+ assert params['gamma'] == 0.5
+ assert params['kernel'] == 'rbf'
+ assert 'is_fitted' in params
+
+ def test_model_outlier_detection(self):
+ """Test that model can detect outliers."""
+ # Generate normal data (clustered around origin)
+ np.random.seed(42)
+ X_train = np.random.randn(100, 5) * 0.5
+
+ # Train model
+ model = SVDDModel(nu=0.1)
+ model.fit(X_train, scale=True)
+
+ # Test on normal data
+ X_test_normal = np.random.randn(10, 5) * 0.5
+ predictions_normal = model.predict(X_test_normal, scale=True)
+
+ # Test on outlier data (far from origin)
+ X_test_outlier = np.random.randn(10, 5) * 10.0
+ predictions_outlier = model.predict(X_test_outlier, scale=True)
+
+ # Check that more outliers are detected in the outlier set
+ normal_outliers = np.sum(predictions_normal == -1)
+ outlier_outliers = np.sum(predictions_outlier == -1)
+
+ # We expect more outliers in the outlier set
+ # (This is a probabilistic test, so we use a lenient threshold)
+ assert outlier_outliers >= normal_outliers
+
+ def test_model_no_scaling(self):
+ """Test model without feature scaling."""
+ # Generate training data
+ np.random.seed(42)
+ X_train = np.random.randn(100, 5)
+
+ # Train model without scaling
+ model = SVDDModel(nu=0.1)
+ model.fit(X_train, scale=False)
+
+ # Predict without scaling
+ X_test = np.random.randn(10, 5)
+ predictions = model.predict(X_test, scale=False)
+
+ assert len(predictions) == 10
+ assert model.is_fitted
+
+
+if __name__ == '__main__':
+ pytest.main([__file__, '-v'])
From 92727a9a8ae02ecbacf992c92e03fccc470301f6 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 9 Dec 2025 15:14:39 +0000
Subject: [PATCH 3/9] Fix GitHub Actions permissions for security
Co-authored-by: jondave <6209386+jondave@users.noreply.github.com>
---
.github/workflows/pytest.yml | 2 ++
1 file changed, 2 insertions(+)
diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml
index 7270124..3571bf0 100644
--- a/.github/workflows/pytest.yml
+++ b/.github/workflows/pytest.yml
@@ -9,6 +9,8 @@ on:
jobs:
test:
runs-on: ubuntu-latest
+ permissions:
+ contents: read
strategy:
matrix:
python-version: ["3.10"]
From 551e2b2d284f0a95105208b772bb28baf597ccbf Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 9 Dec 2025 15:19:11 +0000
Subject: [PATCH 4/9] Add examples directory with sample data generator
Co-authored-by: jondave <6209386+jondave@users.noreply.github.com>
---
examples/README.md | 114 +++++++++++++++++++++++++++++++
examples/generate_sample_data.py | 87 +++++++++++++++++++++++
2 files changed, 201 insertions(+)
create mode 100644 examples/README.md
create mode 100755 examples/generate_sample_data.py
diff --git a/examples/README.md b/examples/README.md
new file mode 100644
index 0000000..6ec3fe6
--- /dev/null
+++ b/examples/README.md
@@ -0,0 +1,114 @@
+# Examples
+
+This directory contains example usage scenarios for the ros2_svdd_monitor package.
+
+## Generating Sample Training Data
+
+You can use the provided script to generate synthetic training data for testing:
+
+```python
+import pandas as pd
+import numpy as np
+
+# Generate 100 samples of normal operation
+np.random.seed(42)
+n_samples = 100
+
+data = {
+ 'timestamp': np.arange(1.0, n_samples + 1.0),
+ 'linear_x': np.random.normal(1.0, 0.1, n_samples), # Mean 1.0 m/s
+ 'linear_y': np.zeros(n_samples),
+ 'linear_z': np.zeros(n_samples),
+ 'angular_x': np.zeros(n_samples),
+ 'angular_y': np.zeros(n_samples),
+ 'angular_z': np.random.normal(0.5, 0.05, n_samples), # Mean 0.5 rad/s
+ 'accel_x': np.random.normal(2.0, 0.2, n_samples), # Forward accel
+ 'accel_y': np.zeros(n_samples),
+ 'accel_z': np.zeros(n_samples),
+ 'gyro_x': np.zeros(n_samples),
+ 'gyro_y': np.zeros(n_samples),
+ 'gyro_z': np.random.normal(1.0, 0.1, n_samples), # Yaw rate
+}
+
+df = pd.DataFrame(data)
+df.to_csv('example_training_data.csv', index=False)
+print("Created example_training_data.csv")
+```
+
+## Quick Test
+
+1. Generate sample data:
+ ```bash
+ cd examples/
+ python generate_sample_data.py
+ ```
+
+2. Train the model:
+ ```bash
+ ros2 run ros2_svdd_monitor train --csv examples/example_training_data.csv
+ ```
+
+3. The trained model will be saved as `svdd_model.pkl` and `scaler.pkl`
+
+## Real Robot Usage
+
+### Recording Data
+
+1. Start recording with the CSV converter:
+ ```bash
+ ros2 run ros2_svdd_monitor rosbag_to_csv training_data.csv
+ ```
+
+2. In another terminal, operate your robot normally:
+ - Drive around in normal conditions
+ - Include various speeds and turning rates
+ - Record for at least 5-10 minutes
+ - Ensure data represents typical operation
+
+3. Stop recording with Ctrl+C
+
+### Training
+
+```bash
+ros2 run ros2_svdd_monitor train --csv training_data.csv --output-dir models/
+```
+
+### Monitoring
+
+```bash
+ros2 run ros2_svdd_monitor monitor
+```
+
+### Visualizing Results
+
+In separate terminals:
+
+```bash
+# Echo anomaly detection
+ros2 topic echo /svdd/anomaly
+
+# Plot anomaly scores
+rqt_plot /svdd/anomaly_score/data
+```
+
+## Typical Anomaly Scenarios
+
+The SVDD monitor can detect:
+
+1. **Wheel Slip**: High cmd_vel but low IMU acceleration
+2. **Motor Failure**: No movement despite commands
+3. **Unexpected Collision**: Sudden negative acceleration
+4. **Rough Terrain**: High vibration in IMU
+5. **Sensor Degradation**: Loss of correlation between command and response
+
+## Tuning Tips
+
+If you get too many false positives:
+- Increase `nu` in config.yaml (e.g., from 0.1 to 0.15)
+- Increase `anomaly_threshold` (e.g., from 0.0 to -0.1)
+- Collect more diverse training data
+
+If you miss real anomalies:
+- Decrease `nu` (e.g., from 0.1 to 0.05)
+- Decrease `anomaly_threshold` (e.g., from 0.0 to 0.1)
+- Ensure training data only contains normal operation
diff --git a/examples/generate_sample_data.py b/examples/generate_sample_data.py
new file mode 100755
index 0000000..d3e56f9
--- /dev/null
+++ b/examples/generate_sample_data.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""
+Generate synthetic training data for testing the SVDD monitor.
+
+This creates a CSV file with simulated robot operation data where
+commanded velocities correlate with IMU measurements (normal operation).
+"""
+
+import pandas as pd
+import numpy as np
+
+def generate_sample_data(n_samples=100, output_file='example_training_data.csv'):
+ """
+ Generate synthetic normal operation data.
+
+ Args:
+ n_samples: Number of samples to generate
+ output_file: Output CSV file path
+ """
+ np.random.seed(42)
+
+ # Generate commanded velocities
+ linear_x = np.random.normal(1.0, 0.1, n_samples) # Mean 1.0 m/s forward
+ angular_z = np.random.normal(0.5, 0.05, n_samples) # Mean 0.5 rad/s turning
+
+ # Generate correlated IMU measurements
+ # Forward acceleration should correlate with linear velocity command
+ accel_x = linear_x * 2.0 + np.random.normal(0, 0.2, n_samples)
+
+ # Gyro should correlate with angular velocity command
+ gyro_z = angular_z * 2.0 + np.random.normal(0, 0.1, n_samples)
+
+ data = {
+ 'timestamp': np.arange(1.0, n_samples + 1.0),
+ 'linear_x': linear_x,
+ 'linear_y': np.zeros(n_samples),
+ 'linear_z': np.zeros(n_samples),
+ 'angular_x': np.zeros(n_samples),
+ 'angular_y': np.zeros(n_samples),
+ 'angular_z': angular_z,
+ 'accel_x': accel_x,
+ 'accel_y': np.zeros(n_samples),
+ 'accel_z': np.zeros(n_samples),
+ 'gyro_x': np.zeros(n_samples),
+ 'gyro_y': np.zeros(n_samples),
+ 'gyro_z': gyro_z,
+ }
+
+ df = pd.DataFrame(data)
+ df.to_csv(output_file, index=False)
+
+ print(f"✓ Generated {n_samples} samples of normal operation data")
+ print(f"✓ Saved to: {output_file}")
+ print(f"\nData summary:")
+ print(f" Linear velocity: mean={linear_x.mean():.2f}, std={linear_x.std():.2f}")
+ print(f" Angular velocity: mean={angular_z.mean():.2f}, std={angular_z.std():.2f}")
+ print(f" Forward accel: mean={accel_x.mean():.2f}, std={accel_x.std():.2f}")
+ print(f" Gyro Z: mean={gyro_z.mean():.2f}, std={gyro_z.std():.2f}")
+ print(f"\nNext steps:")
+ print(f" 1. Train the model:")
+ print(f" ros2 run ros2_svdd_monitor train --csv {output_file}")
+ print(f" 2. Run the monitor:")
+ print(f" ros2 run ros2_svdd_monitor monitor")
+
+
+if __name__ == '__main__':
+ import argparse
+
+ parser = argparse.ArgumentParser(
+ description='Generate synthetic training data for SVDD monitor'
+ )
+ parser.add_argument(
+ '--samples',
+ type=int,
+ default=100,
+ help='Number of samples to generate (default: 100)'
+ )
+ parser.add_argument(
+ '--output',
+ type=str,
+ default='example_training_data.csv',
+ help='Output CSV file path (default: example_training_data.csv)'
+ )
+
+ args = parser.parse_args()
+
+ generate_sample_data(args.samples, args.output)
From 9e47c0bb19027e012015dbb64a2865ba5a09386a Mon Sep 17 00:00:00 2001
From: jondave
Date: Mon, 15 Dec 2025 10:33:15 +0000
Subject: [PATCH 5/9] Add metadata.yaml for dynium_system_filtered rosbag
- Introduced a new metadata.yaml file containing detailed information about the dynium_system_filtered rosbag.
- Included bagfile information such as version, storage identifier, duration, starting time, and message count.
- Documented topics with their respective message counts, types, serialization formats, and QoS profiles.
- Specified the relative file paths and details of the associated database file.
---
src/ros2_svdd_monitor/package.xml | 6 +++
.../ros2_svdd_monitor/utils/rosbag_to_csv.py | 42 +++++++++++++-----
.../dynium_system_filtered_0.db3 | Bin 0 -> 3817472 bytes
.../dynium_system_filtered/metadata.yaml | 32 +++++++++++++
src/ros2_svdd_monitor/setup.py | 1 +
5 files changed, 70 insertions(+), 11 deletions(-)
create mode 100644 src/ros2_svdd_monitor/rosbags/dynium_system_filtered/dynium_system_filtered_0.db3
create mode 100644 src/ros2_svdd_monitor/rosbags/dynium_system_filtered/metadata.yaml
diff --git a/src/ros2_svdd_monitor/package.xml b/src/ros2_svdd_monitor/package.xml
index 51f506f..7780f41 100644
--- a/src/ros2_svdd_monitor/package.xml
+++ b/src/ros2_svdd_monitor/package.xml
@@ -12,6 +12,12 @@
geometry_msgs
sensor_msgs
+ python3-numpy
+ python3-sklearn
+ python3-pandas
+ python3-joblib
+ python3-yaml
+
python3-pytest
diff --git a/src/ros2_svdd_monitor/ros2_svdd_monitor/utils/rosbag_to_csv.py b/src/ros2_svdd_monitor/ros2_svdd_monitor/utils/rosbag_to_csv.py
index 818a5db..6d3533d 100644
--- a/src/ros2_svdd_monitor/ros2_svdd_monitor/utils/rosbag_to_csv.py
+++ b/src/ros2_svdd_monitor/ros2_svdd_monitor/utils/rosbag_to_csv.py
@@ -1,11 +1,15 @@
"""
Rosbag to CSV Converter
-This utility helps export /cmd_vel and /imu topics from a ROS 2 bag to CSV format
+This utility helps export cmd_vel and imu topics from a ROS 2 bag to CSV format
for training the SVDD model.
Usage:
- ros2 run ros2_svdd_monitor rosbag_to_csv
+ ros2 run ros2_svdd_monitor rosbag_to_csv [cmd_vel_topic] [imu_topic]
+
+Examples:
+ ros2 run ros2_svdd_monitor rosbag_to_csv training_data.csv
+ ros2 run ros2_svdd_monitor rosbag_to_csv training_data.csv /cmd_vel /imu/data
Or use this as a reference to create a custom subscriber that writes synchronized
CSV rows during data collection.
@@ -13,6 +17,7 @@
import rclpy
from rclpy.node import Node
+from rclpy.qos import QoSProfile, ReliabilityPolicy, HistoryPolicy, DurabilityPolicy
from geometry_msgs.msg import Twist
from sensor_msgs.msg import Imu
import csv
@@ -27,7 +32,7 @@ class BagToCSVConverter(Node):
This can be run live while recording a rosbag to create training data.
"""
- def __init__(self, output_csv_path):
+ def __init__(self, output_csv_path, cmd_vel_topic='/cmd_vel', imu_topic='/imu'):
super().__init__('rosbag_to_csv_converter')
self.output_csv_path = output_csv_path
@@ -47,23 +52,31 @@ def __init__(self, output_csv_path):
self.latest_cmd_vel = None
self.latest_imu = None
+ # QoS profile for better compatibility with rosbag playback
+ qos_profile = QoSProfile(
+ reliability=ReliabilityPolicy.BEST_EFFORT,
+ durability=DurabilityPolicy.VOLATILE,
+ history=HistoryPolicy.KEEP_LAST,
+ depth=10
+ )
+
# Subscriptions
self.cmd_vel_sub = self.create_subscription(
Twist,
- '/cmd_vel',
+ cmd_vel_topic,
self.cmd_vel_callback,
- 10
+ qos_profile
)
self.imu_sub = self.create_subscription(
Imu,
- '/imu',
+ imu_topic,
self.imu_callback,
- 10
+ qos_profile
)
self.get_logger().info(f'Recording to {output_csv_path}')
- self.get_logger().info('Subscribing to /cmd_vel and /imu')
+ self.get_logger().info(f'Subscribing to {cmd_vel_topic} and {imu_topic}')
self.sample_count = 0
@@ -118,7 +131,11 @@ def main(args=None):
Main entry point for rosbag to CSV converter.
Usage:
- python -m ros2_svdd_monitor.utils.rosbag_to_csv output.csv
+ ros2 run ros2_svdd_monitor rosbag_to_csv [cmd_vel_topic] [imu_topic]
+
+ Examples:
+ ros2 run ros2_svdd_monitor rosbag_to_csv training_data.csv
+ ros2 run ros2_svdd_monitor rosbag_to_csv training_data.csv /cmd_vel /imu/data
Then play your rosbag:
ros2 bag play
@@ -126,14 +143,17 @@ def main(args=None):
Or run this alongside your robot to collect training data.
"""
if len(sys.argv) < 2:
- print("Usage: ros2 run ros2_svdd_monitor rosbag_to_csv ")
+ print("Usage: ros2 run ros2_svdd_monitor rosbag_to_csv [cmd_vel_topic] [imu_topic]")
+ print("Example: ros2 run ros2_svdd_monitor rosbag_to_csv training_data.csv /cmd_vel /imu/data")
print("Then play your rosbag: ros2 bag play ")
return
output_csv = sys.argv[1]
+ cmd_vel_topic = sys.argv[2] if len(sys.argv) > 2 else '/cmd_vel'
+ imu_topic = sys.argv[3] if len(sys.argv) > 3 else '/imu'
rclpy.init(args=args)
- node = BagToCSVConverter(output_csv)
+ node = BagToCSVConverter(output_csv, cmd_vel_topic, imu_topic)
try:
rclpy.spin(node)
diff --git a/src/ros2_svdd_monitor/rosbags/dynium_system_filtered/dynium_system_filtered_0.db3 b/src/ros2_svdd_monitor/rosbags/dynium_system_filtered/dynium_system_filtered_0.db3
new file mode 100644
index 0000000000000000000000000000000000000000..18eeb4f0f12f70362e85759344603fe9cde6bba6
GIT binary patch
literal 3817472
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