mirror of
https://github.com/rmontanana/mdlp.git
synced 2025-08-17 16:35:57 +00:00
Compare commits
5 Commits
059fd33b4e
...
4418ea8a6f
Author | SHA1 | Date | |
---|---|---|---|
4418ea8a6f
|
|||
159e24b5cb
|
|||
77e28e728e
|
|||
18db982dec
|
|||
99b751a4d4
|
11
.conan/profiles/default
Normal file
11
.conan/profiles/default
Normal file
@@ -0,0 +1,11 @@
|
||||
[settings]
|
||||
os=Linux
|
||||
arch=x86_64
|
||||
compiler=gcc
|
||||
compiler.version=11
|
||||
compiler.libcxx=libstdc++11
|
||||
build_type=Release
|
||||
|
||||
[conf]
|
||||
tools.system.package_manager:mode=install
|
||||
tools.system.package_manager:sudo=True
|
3
.gitmodules
vendored
3
.gitmodules
vendored
@@ -1,3 +0,0 @@
|
||||
[submodule "tests/lib/Files"]
|
||||
path = tests/lib/Files
|
||||
url = https://github.com/rmontanana/ArffFiles.git
|
6
.vscode/settings.json
vendored
6
.vscode/settings.json
vendored
@@ -104,6 +104,10 @@
|
||||
"stop_token": "cpp",
|
||||
"text_encoding": "cpp",
|
||||
"typeindex": "cpp",
|
||||
"valarray": "cpp"
|
||||
"valarray": "cpp",
|
||||
"csignal": "cpp",
|
||||
"regex": "cpp",
|
||||
"future": "cpp",
|
||||
"shared_mutex": "cpp"
|
||||
}
|
||||
}
|
182
CHANGELOG.md
Normal file
182
CHANGELOG.md
Normal file
@@ -0,0 +1,182 @@
|
||||
# Changelog
|
||||
|
||||
All notable changes to this project will be documented in this file.
|
||||
|
||||
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
|
||||
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
### Added
|
||||
- Conan dependency manager support
|
||||
- Technical analysis report
|
||||
|
||||
### Changed
|
||||
- Updated README.md
|
||||
- Refactored library version and installation system
|
||||
- Updated config variable names
|
||||
|
||||
### Fixed
|
||||
- Removed unneeded semicolon
|
||||
|
||||
## [2.0.1] - 2024-07-22
|
||||
|
||||
### Added
|
||||
- CMake install target and make install command
|
||||
- Flag to control sample building in Makefile
|
||||
|
||||
### Changed
|
||||
- Library name changed to `fimdlp`
|
||||
- Updated version numbers across test files
|
||||
|
||||
### Fixed
|
||||
- Version number consistency in tests
|
||||
|
||||
## [2.0.0] - 2024-07-04
|
||||
|
||||
### Added
|
||||
- Makefile with build & test actions for easier development
|
||||
- PyTorch (libtorch) integration for tensor operations
|
||||
|
||||
### Changed
|
||||
- Major refactoring of build system
|
||||
- Updated build workflows and CI configuration
|
||||
|
||||
### Fixed
|
||||
- BinDisc quantile calculation errors (#9)
|
||||
- Error in percentile method calculation
|
||||
- Integer type issues in calculations
|
||||
- Multiple GitHub Actions configuration fixes
|
||||
|
||||
## [1.2.1] - 2024-06-08
|
||||
|
||||
### Added
|
||||
- PyTorch tensor methods for discretization
|
||||
- Improved library build system
|
||||
|
||||
### Changed
|
||||
- Refactored sample build process
|
||||
|
||||
### Fixed
|
||||
- Library creation and linking issues
|
||||
- Multiple GitHub Actions workflow fixes
|
||||
|
||||
## [1.2.0] - 2024-06-05
|
||||
|
||||
### Added
|
||||
- **Discretizer** - Abstract base class for all discretization algorithms (#8)
|
||||
- **BinDisc** - K-bins discretization with quantile and uniform strategies (#7)
|
||||
- Transform method to discretize values using existing cut points
|
||||
- Support for multiple datasets in sample program
|
||||
- Docker development container configuration
|
||||
|
||||
### Changed
|
||||
- Refactored system types throughout the library
|
||||
- Improved sample program with better dataset handling
|
||||
- Enhanced build system with debug options
|
||||
|
||||
### Fixed
|
||||
- Transform method initialization issues
|
||||
- ARFF file attribute name extraction
|
||||
- Sample program library binary separation
|
||||
|
||||
## [1.1.3] - 2024-06-05
|
||||
|
||||
### Added
|
||||
- `max_cutpoints` hyperparameter for controlling algorithm complexity
|
||||
- `max_depth` and `min_length` as configurable hyperparameters
|
||||
- Enhanced sample program with hyperparameter support
|
||||
- Additional datasets for testing
|
||||
|
||||
### Changed
|
||||
- Improved constructor design and parameter handling
|
||||
- Enhanced test coverage and reporting
|
||||
- Refactored build system configuration
|
||||
|
||||
### Fixed
|
||||
- Depth initialization in fit method
|
||||
- Code quality improvements and smell fixes
|
||||
- Exception handling in value cut point calculations
|
||||
|
||||
## [1.1.2] - 2023-04-01
|
||||
|
||||
### Added
|
||||
- Comprehensive test suite with GitHub Actions CI
|
||||
- SonarCloud integration for code quality analysis
|
||||
- Enhanced build system with automated testing
|
||||
|
||||
### Changed
|
||||
- Improved GitHub Actions workflow configuration
|
||||
- Updated project structure for better maintainability
|
||||
|
||||
### Fixed
|
||||
- Build system configuration issues
|
||||
- Test execution and coverage reporting
|
||||
|
||||
## [1.1.1] - 2023-02-22
|
||||
|
||||
### Added
|
||||
- Limits header for proper compilation
|
||||
- Enhanced build system support
|
||||
|
||||
### Changed
|
||||
- Updated version numbering system
|
||||
- Improved SonarCloud configuration
|
||||
|
||||
### Fixed
|
||||
- ValueCutPoint exception handling (removed unnecessary exception)
|
||||
- Build system compatibility issues
|
||||
- GitHub Actions token configuration
|
||||
|
||||
## [1.1.0] - 2023-02-21
|
||||
|
||||
### Added
|
||||
- Classic algorithm implementation for performance comparison
|
||||
- Enhanced ValueCutPoint logic with same_values detection
|
||||
- Glass dataset support in sample program
|
||||
- Debug configuration for development
|
||||
|
||||
### Changed
|
||||
- Refactored ValueCutPoint algorithm for better accuracy
|
||||
- Improved candidate selection logic
|
||||
- Enhanced sample program with multiple datasets
|
||||
|
||||
### Fixed
|
||||
- Sign error in valueCutPoint calculation
|
||||
- Final cut value computation
|
||||
- Duplicate dataset handling in sample
|
||||
|
||||
## [1.0.0.0] - 2022-12-21
|
||||
|
||||
### Added
|
||||
- Initial release of MDLP (Minimum Description Length Principle) discretization library
|
||||
- Core CPPFImdlp algorithm implementation based on Fayyad & Irani's paper
|
||||
- Entropy and information gain calculation methods
|
||||
- Sample program demonstrating library usage
|
||||
- CMake build system
|
||||
- Basic test suite
|
||||
- ARFF file format support for datasets
|
||||
|
||||
### Features
|
||||
- Recursive discretization using entropy-based criteria
|
||||
- Stable sorting with tie-breaking for identical values
|
||||
- Configurable algorithm parameters
|
||||
- Cross-platform C++ implementation
|
||||
|
||||
---
|
||||
|
||||
## Release Notes
|
||||
|
||||
### Version 2.x
|
||||
- **Breaking Changes**: Library renamed to `fimdlp`
|
||||
- **Major Enhancement**: PyTorch integration for improved performance
|
||||
- **New Features**: Comprehensive discretization framework with multiple algorithms
|
||||
|
||||
### Version 1.x
|
||||
- **Core Algorithm**: MDLP discretization implementation
|
||||
- **Extensibility**: Hyperparameter support and algorithm variants
|
||||
- **Quality**: Comprehensive testing and CI/CD pipeline
|
||||
|
||||
### Version 1.0.x
|
||||
- **Foundation**: Initial stable implementation
|
||||
- **Algorithm**: Core MDLP discretization functionality
|
@@ -4,11 +4,12 @@ project(fimdlp
|
||||
LANGUAGES CXX
|
||||
DESCRIPTION "Discretization algorithm based on the paper by Fayyad & Irani Multi-Interval Discretization of Continuous-Valued Attributes for Classification Learning."
|
||||
HOMEPAGE_URL "https://github.com/rmontanana/mdlp"
|
||||
VERSION 2.0.1
|
||||
VERSION 2.1.0
|
||||
)
|
||||
set(CMAKE_CXX_STANDARD 17)
|
||||
cmake_policy(SET CMP0135 NEW)
|
||||
|
||||
# Find dependencies
|
||||
find_package(Torch REQUIRED)
|
||||
|
||||
# Options
|
||||
@@ -27,6 +28,7 @@ endif()
|
||||
|
||||
if (ENABLE_TESTING)
|
||||
message("Debug mode")
|
||||
|
||||
enable_testing()
|
||||
set(CODE_COVERAGE ON)
|
||||
set(GCC_COVERAGE_LINK_FLAGS "${GCC_COVERAGE_LINK_FLAGS} -lgcov --coverage")
|
||||
@@ -46,7 +48,7 @@ include_directories(
|
||||
)
|
||||
|
||||
add_library(fimdlp src/CPPFImdlp.cpp src/Metrics.cpp src/BinDisc.cpp src/Discretizer.cpp)
|
||||
target_link_libraries(fimdlp torch::torch)
|
||||
target_link_libraries(fimdlp PRIVATE torch::torch)
|
||||
|
||||
# Installation
|
||||
# ------------
|
||||
|
@@ -4,6 +4,7 @@
|
||||
"conan": {}
|
||||
},
|
||||
"include": [
|
||||
"build/Release/generators/CMakePresets.json"
|
||||
"build_release/build/Release/generators/CMakePresets.json",
|
||||
"build_debug/build/Debug/generators/CMakePresets.json"
|
||||
]
|
||||
}
|
153
CONAN_README.md
Normal file
153
CONAN_README.md
Normal file
@@ -0,0 +1,153 @@
|
||||
# Conan Package for fimdlp
|
||||
|
||||
This directory contains the Conan package configuration for the fimdlp library.
|
||||
|
||||
## Dependencies
|
||||
|
||||
The package manages the following dependencies:
|
||||
|
||||
### Build Requirements
|
||||
- **libtorch/2.4.1** - PyTorch C++ library for tensor operations
|
||||
|
||||
### Test Requirements (when testing enabled)
|
||||
- **catch2/3.8.1** - Modern C++ testing framework
|
||||
- **arff-files** - ARFF file format support (included locally in tests/lib/Files/)
|
||||
|
||||
## Building with Conan
|
||||
|
||||
### 1. Install Dependencies and Build
|
||||
|
||||
```bash
|
||||
# Install dependencies
|
||||
conan install . --output-folder=build --build=missing
|
||||
|
||||
# Build the project
|
||||
cd build
|
||||
cmake .. -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release
|
||||
cmake --build .
|
||||
```
|
||||
|
||||
### 2. Using the Build Script
|
||||
|
||||
```bash
|
||||
# Build release version
|
||||
./scripts/build_conan.sh
|
||||
|
||||
# Build with tests
|
||||
./scripts/build_conan.sh --test
|
||||
```
|
||||
|
||||
## Creating a Package
|
||||
|
||||
### 1. Create Package Locally
|
||||
|
||||
```bash
|
||||
conan create . --profile:build=default --profile:host=default
|
||||
```
|
||||
|
||||
### 2. Create Package with Options
|
||||
|
||||
```bash
|
||||
# Create with testing enabled
|
||||
conan create . -o enable_testing=True --profile:build=default --profile:host=default
|
||||
|
||||
# Create shared library version
|
||||
conan create . -o shared=True --profile:build=default --profile:host=default
|
||||
```
|
||||
|
||||
### 3. Using the Package Creation Script
|
||||
|
||||
```bash
|
||||
./scripts/create_package.sh
|
||||
```
|
||||
|
||||
## Uploading to Cimmeria
|
||||
|
||||
### 1. Configure Remote
|
||||
|
||||
```bash
|
||||
# Add Cimmeria remote
|
||||
conan remote add cimmeria <cimmeria-server-url>
|
||||
|
||||
# Login to Cimmeria
|
||||
conan remote login cimmeria <username>
|
||||
```
|
||||
|
||||
### 2. Upload Package
|
||||
|
||||
```bash
|
||||
# Upload the package
|
||||
conan upload fimdlp/2.1.0 --remote=cimmeria --all
|
||||
|
||||
# Or use the script (will configure remote instructions if not set up)
|
||||
./scripts/create_package.sh
|
||||
```
|
||||
|
||||
## Using the Package
|
||||
|
||||
### In conanfile.txt
|
||||
|
||||
```ini
|
||||
[requires]
|
||||
fimdlp/2.1.0
|
||||
|
||||
[generators]
|
||||
CMakeDeps
|
||||
CMakeToolchain
|
||||
```
|
||||
|
||||
### In conanfile.py
|
||||
|
||||
```python
|
||||
def requirements(self):
|
||||
self.requires("fimdlp/2.1.0")
|
||||
```
|
||||
|
||||
### In CMakeLists.txt
|
||||
|
||||
```cmake
|
||||
find_package(fimdlp REQUIRED)
|
||||
target_link_libraries(your_target fimdlp::fimdlp)
|
||||
```
|
||||
|
||||
## Package Options
|
||||
|
||||
| Option | Values | Default | Description |
|
||||
|--------|--------|---------|-------------|
|
||||
| shared | True/False | False | Build shared library |
|
||||
| fPIC | True/False | True | Position independent code |
|
||||
| enable_testing | True/False | False | Enable test suite |
|
||||
| enable_sample | True/False | False | Build sample program |
|
||||
|
||||
## Example Usage
|
||||
|
||||
```cpp
|
||||
#include <fimdlp/CPPFImdlp.h>
|
||||
#include <fimdlp/Metrics.h>
|
||||
|
||||
int main() {
|
||||
// Create MDLP discretizer
|
||||
CPPFImdlp discretizer;
|
||||
|
||||
// Calculate entropy
|
||||
Metrics metrics;
|
||||
std::vector<int> labels = {0, 1, 0, 1, 1};
|
||||
double entropy = metrics.entropy(labels);
|
||||
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
## Testing
|
||||
|
||||
The package includes comprehensive tests that can be enabled with:
|
||||
|
||||
```bash
|
||||
conan create . -o enable_testing=True
|
||||
```
|
||||
|
||||
## Requirements
|
||||
|
||||
- C++17 compatible compiler
|
||||
- CMake 3.20 or later
|
||||
- Conan 2.0 or later
|
42
Makefile
42
Makefile
@@ -1,35 +1,41 @@
|
||||
SHELL := /bin/bash
|
||||
.DEFAULT_GOAL := build
|
||||
.PHONY: build test
|
||||
.PHONY: build install test
|
||||
lcov := lcov
|
||||
|
||||
build:
|
||||
@if [ -d build_release ]; then rm -fr build_release; fi
|
||||
@mkdir build_release
|
||||
@cmake -B build_release -S . -DCMAKE_BUILD_TYPE=Release -DENABLE_TESTING=OFF -DENABLE_SAMPLE=ON
|
||||
@cmake --build build_release -j 8
|
||||
f_debug = build_debug
|
||||
f_release = build_release
|
||||
|
||||
install:
|
||||
build: ## Build the project for Release
|
||||
@echo ">>> Building the project for Release..."
|
||||
@if [ -d $(f_release) ]; then rm -fr $(f_release); fi
|
||||
@conan install . --build=missing -of $(f_release) -s build_type=Release --profile:build=default --profile:host=default
|
||||
cmake -S . -B $(f_release) -DCMAKE_TOOLCHAIN_FILE=$(f_release)/build/Release/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release -DENABLE_TESTING=OFF -DENABLE_SAMPLE=ON
|
||||
@cmake --build $(f_release) -j 8
|
||||
|
||||
install: ## Install the project
|
||||
@echo ">>> Installing the project..."
|
||||
@cmake --build build_release --target install -j 8
|
||||
|
||||
test:
|
||||
@if [ -d build_debug ]; then rm -fr build_debug; fi
|
||||
@mkdir build_debug
|
||||
@cmake -B build_debug -S . -DCMAKE_BUILD_TYPE=Debug -DENABLE_TESTING=ON -DENABLE_SAMPLE=ON
|
||||
@cmake --build build_debug -j 8
|
||||
@cd build_debug/tests && ctest --output-on-failure -j 8
|
||||
@cd build_debug/tests && $(lcov) --capture --directory ../ --demangle-cpp --ignore-errors source,source --ignore-errors mismatch --output-file coverage.info >/dev/null 2>&1; \
|
||||
test: ## Build Debug version and run tests
|
||||
@echo ">>> Building Debug version and running tests..."
|
||||
@if [ -d $(f_debug) ]; then rm -fr $(f_debug); fi
|
||||
@conan install . --build=missing -of $(f_debug) -s build_type=Debug
|
||||
@cmake -B $(f_debug) -S . -DCMAKE_BUILD_TYPE=Debug -DCMAKE_TOOLCHAIN_FILE=$(f_debug)/build/Debug/generators/conan_toolchain.cmake -DENABLE_TESTING=ON -DENABLE_SAMPLE=ON
|
||||
@cmake --build $(f_debug) -j 8
|
||||
@cd $(f_debug)/tests && ctest --output-on-failure -j 8
|
||||
@cd $(f_debug)/tests && $(lcov) --capture --directory ../ --demangle-cpp --ignore-errors source,source --ignore-errors mismatch --output-file coverage.info >/dev/null 2>&1; \
|
||||
$(lcov) --remove coverage.info '/usr/*' --output-file coverage.info >/dev/null 2>&1; \
|
||||
$(lcov) --remove coverage.info 'lib/*' --output-file coverage.info >/dev/null 2>&1; \
|
||||
$(lcov) --remove coverage.info 'libtorch/*' --output-file coverage.info >/dev/null 2>&1; \
|
||||
$(lcov) --remove coverage.info 'tests/*' --output-file coverage.info >/dev/null 2>&1; \
|
||||
$(lcov) --remove coverage.info 'gtest/*' --output-file coverage.info >/dev/null 2>&1;
|
||||
@genhtml build_debug/tests/coverage.info --demangle-cpp --output-directory build_debug/tests/coverage --title "Discretizer mdlp Coverage Report" -s -k -f --legend
|
||||
@echo "* Coverage report is generated at build_debug/tests/coverage/index.html"
|
||||
@genhtml $(f_debug)/tests/coverage.info --demangle-cpp --output-directory $(f_debug)/tests/coverage --title "Discretizer mdlp Coverage Report" -s -k -f --legend
|
||||
@echo "* Coverage report is generated at $(f_debug)/tests/coverage/index.html"
|
||||
@which python || (echo ">>> Please install python"; exit 1)
|
||||
@if [ ! -f build_debug/tests/coverage.info ]; then \
|
||||
@if [ ! -f $(f_debug)/tests/coverage.info ]; then \
|
||||
echo ">>> No coverage.info file found!"; \
|
||||
exit 1; \
|
||||
fi
|
||||
@echo ">>> Updating coverage badge..."
|
||||
@env python update_coverage.py build_debug/tests
|
||||
@env python update_coverage.py $(f_debug)/tests
|
101
build_conan/CMakeCache.txt
Normal file
101
build_conan/CMakeCache.txt
Normal file
@@ -0,0 +1,101 @@
|
||||
# This is the CMakeCache file.
|
||||
# For build in directory: /home/rmontanana/Code/mdlp/build_conan
|
||||
# It was generated by CMake: /usr/bin/cmake
|
||||
# You can edit this file to change values found and used by cmake.
|
||||
# If you do not want to change any of the values, simply exit the editor.
|
||||
# If you do want to change a value, simply edit, save, and exit the editor.
|
||||
# The syntax for the file is as follows:
|
||||
# KEY:TYPE=VALUE
|
||||
# KEY is the name of a variable in the cache.
|
||||
# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!.
|
||||
# VALUE is the current value for the KEY.
|
||||
|
||||
########################
|
||||
# EXTERNAL cache entries
|
||||
########################
|
||||
|
||||
//No help, variable specified on the command line.
|
||||
CMAKE_BUILD_TYPE:UNINITIALIZED=Release
|
||||
|
||||
//Value Computed by CMake.
|
||||
CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/home/rmontanana/Code/mdlp/build_conan/CMakeFiles/pkgRedirects
|
||||
|
||||
//Value Computed by CMake
|
||||
CMAKE_PROJECT_DESCRIPTION:STATIC=Discretization algorithm based on the paper by Fayyad & Irani Multi-Interval Discretization of Continuous-Valued Attributes for Classification Learning.
|
||||
|
||||
//Value Computed by CMake
|
||||
CMAKE_PROJECT_HOMEPAGE_URL:STATIC=https://github.com/rmontanana/mdlp
|
||||
|
||||
//Value Computed by CMake
|
||||
CMAKE_PROJECT_NAME:STATIC=fimdlp
|
||||
|
||||
//Value Computed by CMake
|
||||
CMAKE_PROJECT_VERSION:STATIC=2.1.0
|
||||
|
||||
//Value Computed by CMake
|
||||
CMAKE_PROJECT_VERSION_MAJOR:STATIC=2
|
||||
|
||||
//Value Computed by CMake
|
||||
CMAKE_PROJECT_VERSION_MINOR:STATIC=1
|
||||
|
||||
//Value Computed by CMake
|
||||
CMAKE_PROJECT_VERSION_PATCH:STATIC=0
|
||||
|
||||
//Value Computed by CMake
|
||||
CMAKE_PROJECT_VERSION_TWEAK:STATIC=
|
||||
|
||||
//No help, variable specified on the command line.
|
||||
CMAKE_TOOLCHAIN_FILE:UNINITIALIZED=conan_toolchain.cmake
|
||||
|
||||
//Value Computed by CMake
|
||||
fimdlp_BINARY_DIR:STATIC=/home/rmontanana/Code/mdlp/build_conan
|
||||
|
||||
//Value Computed by CMake
|
||||
fimdlp_IS_TOP_LEVEL:STATIC=ON
|
||||
|
||||
//Value Computed by CMake
|
||||
fimdlp_SOURCE_DIR:STATIC=/home/rmontanana/Code/mdlp
|
||||
|
||||
|
||||
########################
|
||||
# INTERNAL cache entries
|
||||
########################
|
||||
|
||||
//This is the directory where this CMakeCache.txt was created
|
||||
CMAKE_CACHEFILE_DIR:INTERNAL=/home/rmontanana/Code/mdlp/build_conan
|
||||
//Major version of cmake used to create the current loaded cache
|
||||
CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3
|
||||
//Minor version of cmake used to create the current loaded cache
|
||||
CMAKE_CACHE_MINOR_VERSION:INTERNAL=30
|
||||
//Patch version of cmake used to create the current loaded cache
|
||||
CMAKE_CACHE_PATCH_VERSION:INTERNAL=8
|
||||
//Path to CMake executable.
|
||||
CMAKE_COMMAND:INTERNAL=/usr/bin/cmake
|
||||
//Path to cpack program executable.
|
||||
CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack
|
||||
//Path to ctest program executable.
|
||||
CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest
|
||||
//Path to cache edit program executable.
|
||||
CMAKE_EDIT_COMMAND:INTERNAL=/usr/bin/ccmake
|
||||
//Name of external makefile project generator.
|
||||
CMAKE_EXTRA_GENERATOR:INTERNAL=
|
||||
//Name of generator.
|
||||
CMAKE_GENERATOR:INTERNAL=Unix Makefiles
|
||||
//Generator instance identifier.
|
||||
CMAKE_GENERATOR_INSTANCE:INTERNAL=
|
||||
//Name of generator platform.
|
||||
CMAKE_GENERATOR_PLATFORM:INTERNAL=
|
||||
//Name of generator toolset.
|
||||
CMAKE_GENERATOR_TOOLSET:INTERNAL=
|
||||
//Source directory with the top level CMakeLists.txt file for this
|
||||
// project
|
||||
CMAKE_HOME_DIRECTORY:INTERNAL=/home/rmontanana/Code/mdlp
|
||||
//number of local generators
|
||||
CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1
|
||||
//Platform information initialized
|
||||
CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1
|
||||
//Path to CMake installation.
|
||||
CMAKE_ROOT:INTERNAL=/usr/share/cmake
|
||||
//uname command
|
||||
CMAKE_UNAME:INTERNAL=/usr/bin/uname
|
||||
|
16
conandata.yml
Normal file
16
conandata.yml
Normal file
@@ -0,0 +1,16 @@
|
||||
sources:
|
||||
"2.1.0":
|
||||
url: "https://github.com/rmontanana/mdlp/archive/refs/tags/v2.1.0.tar.gz"
|
||||
sha256: "placeholder_sha256_hash"
|
||||
"2.0.1":
|
||||
url: "https://github.com/rmontanana/mdlp/archive/refs/tags/v2.0.1.tar.gz"
|
||||
sha256: "placeholder_sha256_hash"
|
||||
"2.0.0":
|
||||
url: "https://github.com/rmontanana/mdlp/archive/refs/tags/v2.0.0.tar.gz"
|
||||
sha256: "placeholder_sha256_hash"
|
||||
|
||||
patches:
|
||||
"2.1.0":
|
||||
- patch_file: "patches/001-cmake-fix.patch"
|
||||
patch_description: "Fix CMake configuration for Conan compatibility"
|
||||
patch_type: "portability"
|
78
conanfile.py
78
conanfile.py
@@ -1,8 +1,8 @@
|
||||
import re
|
||||
import os
|
||||
from conan import ConanFile
|
||||
from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout, CMakeDeps
|
||||
from conan.tools.files import save, load
|
||||
from conan.tools.cmake import CMakeToolchain, CMake, cmake_layout, CMakeDeps
|
||||
from conan.tools.files import copy
|
||||
import os
|
||||
|
||||
|
||||
class FimdlpConan(ConanFile):
|
||||
name = "fimdlp"
|
||||
@@ -10,10 +10,26 @@ class FimdlpConan(ConanFile):
|
||||
license = "MIT"
|
||||
author = "Ricardo Montañana <rmontanana@gmail.com>"
|
||||
url = "https://github.com/rmontanana/mdlp"
|
||||
description = "Discretization algorithm based on the paper by Fayyad & Irani."
|
||||
topics = ("discretization", "classification", "machine learning")
|
||||
description = "Discretization algorithm based on the paper by Fayyad & Irani Multi-Interval Discretization of Continuous-Valued Attributes for Classification Learning."
|
||||
topics = ("machine-learning", "discretization", "mdlp", "classification")
|
||||
|
||||
# Package configuration
|
||||
settings = "os", "compiler", "build_type", "arch"
|
||||
exports_sources = "src/*", "CMakeLists.txt", "README.md", "config/*", "fimdlpConfig.cmake.in"
|
||||
options = {
|
||||
"shared": [True, False],
|
||||
"fPIC": [True, False],
|
||||
"enable_testing": [True, False],
|
||||
"enable_sample": [True, False],
|
||||
}
|
||||
default_options = {
|
||||
"shared": False,
|
||||
"fPIC": True,
|
||||
"enable_testing": False,
|
||||
"enable_sample": False,
|
||||
}
|
||||
|
||||
# Sources are located in the same place as this recipe, copy them to the recipe
|
||||
exports_sources = "CMakeLists.txt", "src/*", "sample/*", "tests/*", "config/*", "fimdlpConfig.cmake.in"
|
||||
|
||||
def set_version(self):
|
||||
# Read the CMakeLists.txt file to get the version
|
||||
@@ -23,18 +39,38 @@ class FimdlpConan(ConanFile):
|
||||
if match:
|
||||
self.version = match.group(1)
|
||||
except Exception:
|
||||
self.version = "2.0.1" # fallback version
|
||||
self.version = "0.0.1" # fallback version
|
||||
|
||||
def config_options(self):
|
||||
if self.settings.os == "Windows":
|
||||
self.options.rm_safe("fPIC")
|
||||
|
||||
def configure(self):
|
||||
if self.options.shared:
|
||||
self.options.rm_safe("fPIC")
|
||||
|
||||
def requirements(self):
|
||||
# PyTorch dependency for tensor operations
|
||||
self.requires("libtorch/2.7.0")
|
||||
|
||||
def build_requirements(self):
|
||||
self.requires("arff-files/1.2.0") # for tests and sample
|
||||
if self.options.enable_testing:
|
||||
self.test_requires("gtest/1.16.0")
|
||||
|
||||
def layout(self):
|
||||
cmake_layout(self)
|
||||
|
||||
def generate(self):
|
||||
# Generate CMake configuration files
|
||||
deps = CMakeDeps(self)
|
||||
deps.generate()
|
||||
|
||||
tc = CMakeToolchain(self)
|
||||
# Set CMake variables based on options
|
||||
tc.variables["ENABLE_TESTING"] = self.options.enable_testing
|
||||
tc.variables["ENABLE_SAMPLE"] = self.options.enable_sample
|
||||
tc.variables["BUILD_SHARED_LIBS"] = self.options.shared
|
||||
tc.generate()
|
||||
|
||||
def build(self):
|
||||
@@ -42,14 +78,34 @@ class FimdlpConan(ConanFile):
|
||||
cmake.configure()
|
||||
cmake.build()
|
||||
|
||||
# Run tests if enabled
|
||||
if self.options.enable_testing:
|
||||
cmake.test()
|
||||
|
||||
def package(self):
|
||||
# Install using CMake
|
||||
cmake = CMake(self)
|
||||
cmake.install()
|
||||
|
||||
# Copy license file
|
||||
copy(self, "LICENSE", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
|
||||
|
||||
def package_info(self):
|
||||
# Library configuration
|
||||
self.cpp_info.libs = ["fimdlp"]
|
||||
self.cpp_info.includedirs = ["include"]
|
||||
self.cpp_info.libdirs = ["lib"]
|
||||
self.cpp_info.set_property("cmake_find_mode", "both")
|
||||
self.cpp_info.set_property("cmake_target_name", "fimdlp::fimdlp")
|
||||
|
||||
# CMake package configuration
|
||||
self.cpp_info.set_property("cmake_file_name", "fimdlp")
|
||||
self.cpp_info.set_property("cmake_target_name", "fimdlp::fimdlp")
|
||||
|
||||
# Compiler features
|
||||
self.cpp_info.cppstd = "17"
|
||||
|
||||
# System libraries (if needed)
|
||||
if self.settings.os in ["Linux", "FreeBSD"]:
|
||||
self.cpp_info.system_libs.append("m") # Math library
|
||||
self.cpp_info.system_libs.append("pthread") # Threading
|
||||
|
||||
# Build information for consumers
|
||||
self.cpp_info.builddirs = ["lib/cmake/fimdlp"]
|
@@ -2,11 +2,15 @@ set(CMAKE_CXX_STANDARD 17)
|
||||
|
||||
set(CMAKE_BUILD_TYPE Debug)
|
||||
|
||||
find_package(arff-files REQUIRED)
|
||||
|
||||
include_directories(
|
||||
${fimdlp_SOURCE_DIR}/src
|
||||
${fimdlp_SOURCE_DIR}/tests/lib/Files
|
||||
${CMAKE_BINARY_DIR}/configured_files/include
|
||||
${libtorch_INCLUDE_DIRS_RELEASE}
|
||||
${arff-files_INCLUDE_DIRS}
|
||||
)
|
||||
|
||||
add_executable(sample sample.cpp)
|
||||
target_link_libraries(sample fimdlp "${TORCH_LIBRARIES}")
|
||||
target_link_libraries(sample PRIVATE fimdlp torch::torch arff-files::arff-files)
|
||||
|
25
scripts/build_conan.sh
Executable file
25
scripts/build_conan.sh
Executable file
@@ -0,0 +1,25 @@
|
||||
#!/bin/bash
|
||||
|
||||
# Build script for fimdlp using Conan
|
||||
set -e
|
||||
|
||||
echo "Building fimdlp with Conan..."
|
||||
|
||||
# Clean previous builds
|
||||
rm -rf build_conan
|
||||
|
||||
# Install dependencies and build
|
||||
conan install . --output-folder=build_conan --build=missing --profile:build=default --profile:host=default
|
||||
|
||||
# Build the project
|
||||
cd build_conan
|
||||
cmake .. -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release
|
||||
cmake --build .
|
||||
|
||||
echo "Build completed successfully!"
|
||||
|
||||
# Run tests if requested
|
||||
if [ "$1" = "--test" ]; then
|
||||
echo "Running tests..."
|
||||
ctest --output-on-failure
|
||||
fi
|
33
scripts/create_package.sh
Executable file
33
scripts/create_package.sh
Executable file
@@ -0,0 +1,33 @@
|
||||
#!/bin/bash
|
||||
|
||||
# Script to create and upload fimdlp Conan package
|
||||
set -e
|
||||
|
||||
PACKAGE_NAME="fimdlp"
|
||||
PACKAGE_VERSION="2.1.0"
|
||||
REMOTE_NAME="cimmeria"
|
||||
|
||||
echo "Creating Conan package for $PACKAGE_NAME/$PACKAGE_VERSION..."
|
||||
|
||||
# Create the package
|
||||
conan create . --profile:build=default --profile:host=default
|
||||
|
||||
echo "Package created successfully!"
|
||||
|
||||
# Test the package
|
||||
echo "Testing package..."
|
||||
conan test test_package $PACKAGE_NAME/$PACKAGE_VERSION@ --profile:build=default --profile:host=default
|
||||
|
||||
echo "Package tested successfully!"
|
||||
|
||||
# Upload to Cimmeria (if remote is configured)
|
||||
if conan remote list | grep -q "$REMOTE_NAME"; then
|
||||
echo "Uploading package to $REMOTE_NAME..."
|
||||
conan upload $PACKAGE_NAME/$PACKAGE_VERSION --remote=$REMOTE_NAME --all
|
||||
echo "Package uploaded to $REMOTE_NAME successfully!"
|
||||
else
|
||||
echo "Remote '$REMOTE_NAME' not configured. To upload the package:"
|
||||
echo "1. Add the remote: conan remote add $REMOTE_NAME <cimmeria-url>"
|
||||
echo "2. Login: conan remote login $REMOTE_NAME <username>"
|
||||
echo "3. Upload: conan upload $PACKAGE_NAME/$PACKAGE_VERSION --remote=$REMOTE_NAME --all"
|
||||
fi
|
@@ -22,13 +22,15 @@ namespace mdlp {
|
||||
BinDisc::~BinDisc() = default;
|
||||
void BinDisc::fit(samples_t& X)
|
||||
{
|
||||
// y is included for compatibility with the Discretizer interface
|
||||
cutPoints.clear();
|
||||
// Input validation
|
||||
if (X.empty()) {
|
||||
cutPoints.push_back(0.0);
|
||||
cutPoints.push_back(0.0);
|
||||
return;
|
||||
throw std::invalid_argument("Input data X cannot be empty");
|
||||
}
|
||||
if (X.size() < static_cast<size_t>(n_bins)) {
|
||||
throw std::invalid_argument("Input data size must be at least equal to n_bins");
|
||||
}
|
||||
|
||||
cutPoints.clear();
|
||||
if (strategy == strategy_t::QUANTILE) {
|
||||
direction = bound_dir_t::RIGHT;
|
||||
fit_quantile(X);
|
||||
@@ -39,10 +41,31 @@ namespace mdlp {
|
||||
}
|
||||
void BinDisc::fit(samples_t& X, labels_t& y)
|
||||
{
|
||||
// Input validation for supervised interface
|
||||
if (X.size() != y.size()) {
|
||||
throw std::invalid_argument("X and y must have the same size");
|
||||
}
|
||||
if (X.empty() || y.empty()) {
|
||||
throw std::invalid_argument("X and y cannot be empty");
|
||||
}
|
||||
|
||||
// BinDisc is inherently unsupervised, but we validate inputs for consistency
|
||||
// Note: y parameter is validated but not used in binning strategy
|
||||
fit(X);
|
||||
}
|
||||
std::vector<precision_t> linspace(precision_t start, precision_t end, int num)
|
||||
{
|
||||
// Input validation
|
||||
if (num < 2) {
|
||||
throw std::invalid_argument("Number of points must be at least 2 for linspace");
|
||||
}
|
||||
if (std::isnan(start) || std::isnan(end)) {
|
||||
throw std::invalid_argument("Start and end values cannot be NaN");
|
||||
}
|
||||
if (std::isinf(start) || std::isinf(end)) {
|
||||
throw std::invalid_argument("Start and end values cannot be infinite");
|
||||
}
|
||||
|
||||
if (start == end) {
|
||||
return { start, end };
|
||||
}
|
||||
@@ -60,6 +83,14 @@ namespace mdlp {
|
||||
}
|
||||
std::vector<precision_t> percentile(samples_t& data, const std::vector<precision_t>& percentiles)
|
||||
{
|
||||
// Input validation
|
||||
if (data.empty()) {
|
||||
throw std::invalid_argument("Data cannot be empty for percentile calculation");
|
||||
}
|
||||
if (percentiles.empty()) {
|
||||
throw std::invalid_argument("Percentiles cannot be empty");
|
||||
}
|
||||
|
||||
// Implementation taken from https://dpilger26.github.io/NumCpp/doxygen/html/percentile_8hpp_source.html
|
||||
std::vector<precision_t> results;
|
||||
bool first = true;
|
||||
|
@@ -8,6 +8,7 @@
|
||||
#include <algorithm>
|
||||
#include <set>
|
||||
#include <cmath>
|
||||
#include <stdexcept>
|
||||
#include "CPPFImdlp.h"
|
||||
|
||||
namespace mdlp {
|
||||
@@ -18,6 +19,17 @@ namespace mdlp {
|
||||
max_depth(max_depth_),
|
||||
proposed_cuts(proposed)
|
||||
{
|
||||
// Input validation for constructor parameters
|
||||
if (min_length_ < 3) {
|
||||
throw std::invalid_argument("min_length must be greater than 2");
|
||||
}
|
||||
if (max_depth_ < 1) {
|
||||
throw std::invalid_argument("max_depth must be greater than 0");
|
||||
}
|
||||
if (proposed < 0.0f) {
|
||||
throw std::invalid_argument("proposed_cuts must be non-negative");
|
||||
}
|
||||
|
||||
direction = bound_dir_t::RIGHT;
|
||||
}
|
||||
|
||||
@@ -49,12 +61,6 @@ namespace mdlp {
|
||||
if (X.empty() || y.empty()) {
|
||||
throw invalid_argument("X and y must have at least one element");
|
||||
}
|
||||
if (min_length < 3) {
|
||||
throw invalid_argument("min_length must be greater than 2");
|
||||
}
|
||||
if (max_depth < 1) {
|
||||
throw invalid_argument("max_depth must be greater than 0");
|
||||
}
|
||||
indices = sortIndices(X_, y_);
|
||||
metrics.setData(y, indices);
|
||||
computeCutPoints(0, X.size(), 1);
|
||||
@@ -81,26 +87,32 @@ namespace mdlp {
|
||||
precision_t previous;
|
||||
precision_t actual;
|
||||
precision_t next;
|
||||
previous = X[indices[idxPrev]];
|
||||
actual = X[indices[cut]];
|
||||
next = X[indices[idxNext]];
|
||||
previous = safe_X_access(idxPrev);
|
||||
actual = safe_X_access(cut);
|
||||
next = safe_X_access(idxNext);
|
||||
// definition 2 of the paper => X[t-1] < X[t]
|
||||
// get the first equal value of X in the interval
|
||||
while (idxPrev > start && actual == previous) {
|
||||
previous = X[indices[--idxPrev]];
|
||||
--idxPrev;
|
||||
previous = safe_X_access(idxPrev);
|
||||
}
|
||||
backWall = idxPrev == start && actual == previous;
|
||||
// get the last equal value of X in the interval
|
||||
while (idxNext < end - 1 && actual == next) {
|
||||
next = X[indices[++idxNext]];
|
||||
++idxNext;
|
||||
next = safe_X_access(idxNext);
|
||||
}
|
||||
// # of duplicates before cutpoint
|
||||
n = cut - 1 - idxPrev;
|
||||
n = safe_subtract(safe_subtract(cut, 1), idxPrev);
|
||||
// # of duplicates after cutpoint
|
||||
m = idxNext - cut - 1;
|
||||
m = safe_subtract(safe_subtract(idxNext, cut), 1);
|
||||
// Decide which values to use
|
||||
cut = cut + (backWall ? m + 1 : -n);
|
||||
actual = X[indices[cut]];
|
||||
if (backWall) {
|
||||
cut = cut + m + 1;
|
||||
} else {
|
||||
cut = safe_subtract(cut, n);
|
||||
}
|
||||
actual = safe_X_access(cut);
|
||||
return { (actual + previous) / 2, cut };
|
||||
}
|
||||
|
||||
@@ -109,7 +121,7 @@ namespace mdlp {
|
||||
size_t cut;
|
||||
pair<precision_t, size_t> result;
|
||||
// Check if the interval length and the depth are Ok
|
||||
if (end - start < min_length || depth_ > max_depth)
|
||||
if (end < start || safe_subtract(end, start) < min_length || depth_ > max_depth)
|
||||
return;
|
||||
depth = depth_ > depth ? depth_ : depth;
|
||||
cut = getCandidate(start, end);
|
||||
@@ -129,14 +141,14 @@ namespace mdlp {
|
||||
/* Definition 1: A binary discretization for A is determined by selecting the cut point TA for which
|
||||
E(A, TA; S) is minimal amongst all the candidate cut points. */
|
||||
size_t candidate = numeric_limits<size_t>::max();
|
||||
size_t elements = end - start;
|
||||
size_t elements = safe_subtract(end, start);
|
||||
bool sameValues = true;
|
||||
precision_t entropy_left;
|
||||
precision_t entropy_right;
|
||||
precision_t minEntropy;
|
||||
// Check if all the values of the variable in the interval are the same
|
||||
for (size_t idx = start + 1; idx < end; idx++) {
|
||||
if (X[indices[idx]] != X[indices[start]]) {
|
||||
if (safe_X_access(idx) != safe_X_access(start)) {
|
||||
sameValues = false;
|
||||
break;
|
||||
}
|
||||
@@ -146,7 +158,7 @@ namespace mdlp {
|
||||
minEntropy = metrics.entropy(start, end);
|
||||
for (size_t idx = start + 1; idx < end; idx++) {
|
||||
// Cutpoints are always on boundaries (definition 2)
|
||||
if (y[indices[idx]] == y[indices[idx - 1]])
|
||||
if (safe_y_access(idx) == safe_y_access(idx - 1))
|
||||
continue;
|
||||
entropy_left = precision_t(idx - start) / static_cast<precision_t>(elements) * metrics.entropy(start, idx);
|
||||
entropy_right = precision_t(end - idx) / static_cast<precision_t>(elements) * metrics.entropy(idx, end);
|
||||
@@ -168,7 +180,7 @@ namespace mdlp {
|
||||
precision_t ent;
|
||||
precision_t ent1;
|
||||
precision_t ent2;
|
||||
auto N = precision_t(end - start);
|
||||
auto N = precision_t(safe_subtract(end, start));
|
||||
k = metrics.computeNumClasses(start, end);
|
||||
k1 = metrics.computeNumClasses(start, cut);
|
||||
k2 = metrics.computeNumClasses(cut, end);
|
||||
@@ -188,6 +200,9 @@ namespace mdlp {
|
||||
indices_t idx(X_.size());
|
||||
std::iota(idx.begin(), idx.end(), 0);
|
||||
stable_sort(idx.begin(), idx.end(), [&X_, &y_](size_t i1, size_t i2) {
|
||||
if (i1 >= X_.size() || i2 >= X_.size() || i1 >= y_.size() || i2 >= y_.size()) {
|
||||
throw std::out_of_range("Index out of bounds in sort comparison");
|
||||
}
|
||||
if (X_[i1] == X_[i2])
|
||||
return y_[i1] < y_[i2];
|
||||
else
|
||||
@@ -206,7 +221,7 @@ namespace mdlp {
|
||||
size_t end;
|
||||
for (size_t idx = 0; idx < cutPoints.size(); idx++) {
|
||||
end = begin;
|
||||
while (X[indices[end]] < cutPoints[idx] && end < X.size())
|
||||
while (end < indices.size() && safe_X_access(end) < cutPoints[idx] && end < X.size())
|
||||
end++;
|
||||
entropy = metrics.entropy(begin, end);
|
||||
if (entropy > maxEntropy) {
|
||||
|
@@ -39,6 +39,33 @@ namespace mdlp {
|
||||
size_t getCandidate(size_t, size_t);
|
||||
size_t compute_max_num_cut_points() const;
|
||||
pair<precision_t, size_t> valueCutPoint(size_t, size_t, size_t);
|
||||
private:
|
||||
inline precision_t safe_X_access(size_t idx) const {
|
||||
if (idx >= indices.size()) {
|
||||
throw std::out_of_range("Index out of bounds for indices array");
|
||||
}
|
||||
size_t real_idx = indices[idx];
|
||||
if (real_idx >= X.size()) {
|
||||
throw std::out_of_range("Index out of bounds for X array");
|
||||
}
|
||||
return X[real_idx];
|
||||
}
|
||||
inline label_t safe_y_access(size_t idx) const {
|
||||
if (idx >= indices.size()) {
|
||||
throw std::out_of_range("Index out of bounds for indices array");
|
||||
}
|
||||
size_t real_idx = indices[idx];
|
||||
if (real_idx >= y.size()) {
|
||||
throw std::out_of_range("Index out of bounds for y array");
|
||||
}
|
||||
return y[real_idx];
|
||||
}
|
||||
inline size_t safe_subtract(size_t a, size_t b) const {
|
||||
if (b > a) {
|
||||
throw std::underflow_error("Subtraction would cause underflow");
|
||||
}
|
||||
return a - b;
|
||||
}
|
||||
};
|
||||
}
|
||||
#endif
|
||||
|
@@ -10,6 +10,14 @@ namespace mdlp {
|
||||
|
||||
labels_t& Discretizer::transform(const samples_t& data)
|
||||
{
|
||||
// Input validation
|
||||
if (data.empty()) {
|
||||
throw std::invalid_argument("Data for transformation cannot be empty");
|
||||
}
|
||||
if (cutPoints.size() < 2) {
|
||||
throw std::runtime_error("Discretizer not fitted yet or no valid cut points found");
|
||||
}
|
||||
|
||||
discretizedData.clear();
|
||||
discretizedData.reserve(data.size());
|
||||
// CutPoints always have at least two items
|
||||
@@ -31,6 +39,26 @@ namespace mdlp {
|
||||
}
|
||||
void Discretizer::fit_t(const torch::Tensor& X_, const torch::Tensor& y_)
|
||||
{
|
||||
// Validate tensor properties for security
|
||||
if (!X_.is_contiguous() || !y_.is_contiguous()) {
|
||||
throw std::invalid_argument("Tensors must be contiguous");
|
||||
}
|
||||
if (X_.sizes().size() != 1 || y_.sizes().size() != 1) {
|
||||
throw std::invalid_argument("Only 1D tensors supported");
|
||||
}
|
||||
if (X_.dtype() != torch::kFloat32) {
|
||||
throw std::invalid_argument("X tensor must be Float32 type");
|
||||
}
|
||||
if (y_.dtype() != torch::kInt32) {
|
||||
throw std::invalid_argument("y tensor must be Int32 type");
|
||||
}
|
||||
if (X_.numel() != y_.numel()) {
|
||||
throw std::invalid_argument("X and y tensors must have same number of elements");
|
||||
}
|
||||
if (X_.numel() == 0) {
|
||||
throw std::invalid_argument("Tensors cannot be empty");
|
||||
}
|
||||
|
||||
auto num_elements = X_.numel();
|
||||
samples_t X(X_.data_ptr<precision_t>(), X_.data_ptr<precision_t>() + num_elements);
|
||||
labels_t y(y_.data_ptr<int>(), y_.data_ptr<int>() + num_elements);
|
||||
@@ -38,6 +66,20 @@ namespace mdlp {
|
||||
}
|
||||
torch::Tensor Discretizer::transform_t(const torch::Tensor& X_)
|
||||
{
|
||||
// Validate tensor properties for security
|
||||
if (!X_.is_contiguous()) {
|
||||
throw std::invalid_argument("Tensor must be contiguous");
|
||||
}
|
||||
if (X_.sizes().size() != 1) {
|
||||
throw std::invalid_argument("Only 1D tensors supported");
|
||||
}
|
||||
if (X_.dtype() != torch::kFloat32) {
|
||||
throw std::invalid_argument("X tensor must be Float32 type");
|
||||
}
|
||||
if (X_.numel() == 0) {
|
||||
throw std::invalid_argument("Tensor cannot be empty");
|
||||
}
|
||||
|
||||
auto num_elements = X_.numel();
|
||||
samples_t X(X_.data_ptr<precision_t>(), X_.data_ptr<precision_t>() + num_elements);
|
||||
auto result = transform(X);
|
||||
@@ -45,6 +87,26 @@ namespace mdlp {
|
||||
}
|
||||
torch::Tensor Discretizer::fit_transform_t(const torch::Tensor& X_, const torch::Tensor& y_)
|
||||
{
|
||||
// Validate tensor properties for security
|
||||
if (!X_.is_contiguous() || !y_.is_contiguous()) {
|
||||
throw std::invalid_argument("Tensors must be contiguous");
|
||||
}
|
||||
if (X_.sizes().size() != 1 || y_.sizes().size() != 1) {
|
||||
throw std::invalid_argument("Only 1D tensors supported");
|
||||
}
|
||||
if (X_.dtype() != torch::kFloat32) {
|
||||
throw std::invalid_argument("X tensor must be Float32 type");
|
||||
}
|
||||
if (y_.dtype() != torch::kInt32) {
|
||||
throw std::invalid_argument("y tensor must be Int32 type");
|
||||
}
|
||||
if (X_.numel() != y_.numel()) {
|
||||
throw std::invalid_argument("X and y tensors must have same number of elements");
|
||||
}
|
||||
if (X_.numel() == 0) {
|
||||
throw std::invalid_argument("Tensors cannot be empty");
|
||||
}
|
||||
|
||||
auto num_elements = X_.numel();
|
||||
samples_t X(X_.data_ptr<precision_t>(), X_.data_ptr<precision_t>() + num_elements);
|
||||
labels_t y(y_.data_ptr<int>(), y_.data_ptr<int>() + num_elements);
|
||||
|
@@ -26,6 +26,7 @@ namespace mdlp {
|
||||
|
||||
void Metrics::setData(const labels_t& y_, const indices_t& indices_)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(cache_mutex);
|
||||
indices = indices_;
|
||||
y = y_;
|
||||
numClasses = computeNumClasses(0, indices.size());
|
||||
@@ -35,15 +36,23 @@ namespace mdlp {
|
||||
|
||||
precision_t Metrics::entropy(size_t start, size_t end)
|
||||
{
|
||||
if (end - start < 2)
|
||||
return 0;
|
||||
|
||||
// Check cache first with read lock
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(cache_mutex);
|
||||
if (entropyCache.find({ start, end }) != entropyCache.end()) {
|
||||
return entropyCache[{start, end}];
|
||||
}
|
||||
}
|
||||
|
||||
// Compute entropy outside of lock
|
||||
precision_t p;
|
||||
precision_t ventropy = 0;
|
||||
int nElements = 0;
|
||||
labels_t counts(numClasses + 1, 0);
|
||||
if (end - start < 2)
|
||||
return 0;
|
||||
if (entropyCache.find({ start, end }) != entropyCache.end()) {
|
||||
return entropyCache[{start, end}];
|
||||
}
|
||||
|
||||
for (auto i = &indices[start]; i != &indices[end]; ++i) {
|
||||
counts[y[*i]]++;
|
||||
nElements++;
|
||||
@@ -54,12 +63,27 @@ namespace mdlp {
|
||||
ventropy -= p * log2(p);
|
||||
}
|
||||
}
|
||||
|
||||
// Update cache with write lock
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(cache_mutex);
|
||||
entropyCache[{start, end}] = ventropy;
|
||||
}
|
||||
|
||||
return ventropy;
|
||||
}
|
||||
|
||||
precision_t Metrics::informationGain(size_t start, size_t cut, size_t end)
|
||||
{
|
||||
// Check cache first with read lock
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(cache_mutex);
|
||||
if (igCache.find(make_tuple(start, cut, end)) != igCache.end()) {
|
||||
return igCache[make_tuple(start, cut, end)];
|
||||
}
|
||||
}
|
||||
|
||||
// Compute information gain outside of lock
|
||||
precision_t iGain;
|
||||
precision_t entropyInterval;
|
||||
precision_t entropyLeft;
|
||||
@@ -67,9 +91,7 @@ namespace mdlp {
|
||||
size_t nElementsLeft = cut - start;
|
||||
size_t nElementsRight = end - cut;
|
||||
size_t nElements = end - start;
|
||||
if (igCache.find(make_tuple(start, cut, end)) != igCache.end()) {
|
||||
return igCache[make_tuple(start, cut, end)];
|
||||
}
|
||||
|
||||
entropyInterval = entropy(start, end);
|
||||
entropyLeft = entropy(start, cut);
|
||||
entropyRight = entropy(cut, end);
|
||||
@@ -77,7 +99,13 @@ namespace mdlp {
|
||||
(static_cast<precision_t>(nElementsLeft) * entropyLeft +
|
||||
static_cast<precision_t>(nElementsRight) * entropyRight) /
|
||||
static_cast<precision_t>(nElements);
|
||||
|
||||
// Update cache with write lock
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(cache_mutex);
|
||||
igCache[make_tuple(start, cut, end)] = iGain;
|
||||
}
|
||||
|
||||
return iGain;
|
||||
}
|
||||
|
||||
|
@@ -8,6 +8,7 @@
|
||||
#define CCMETRICS_H
|
||||
|
||||
#include "typesFImdlp.h"
|
||||
#include <mutex>
|
||||
|
||||
namespace mdlp {
|
||||
class Metrics {
|
||||
@@ -15,6 +16,7 @@ namespace mdlp {
|
||||
labels_t& y;
|
||||
indices_t& indices;
|
||||
int numClasses;
|
||||
mutable std::mutex cache_mutex;
|
||||
cacheEnt_t entropyCache = cacheEnt_t();
|
||||
cacheIg_t igCache = cacheIg_t();
|
||||
public:
|
||||
|
8
test_package/CMakeLists.txt
Normal file
8
test_package/CMakeLists.txt
Normal file
@@ -0,0 +1,8 @@
|
||||
cmake_minimum_required(VERSION 3.20)
|
||||
project(test_fimdlp)
|
||||
|
||||
find_package(fimdlp REQUIRED)
|
||||
|
||||
add_executable(test_fimdlp src/test_fimdlp.cpp)
|
||||
target_link_libraries(test_fimdlp fimdlp::fimdlp)
|
||||
target_compile_features(test_fimdlp PRIVATE cxx_std_17)
|
28
test_package/conanfile.py
Normal file
28
test_package/conanfile.py
Normal file
@@ -0,0 +1,28 @@
|
||||
import os
|
||||
from conan import ConanFile
|
||||
from conan.tools.cmake import CMake, cmake_layout
|
||||
from conan.tools.build import can_run
|
||||
|
||||
|
||||
class FimdlpTestConan(ConanFile):
|
||||
settings = "os", "compiler", "build_type", "arch"
|
||||
# VirtualBuildEnv and VirtualRunEnv can be avoided if "tools.env:CONAN_RUN_TESTS" is false
|
||||
generators = "CMakeDeps", "CMakeToolchain", "VirtualRunEnv"
|
||||
apply_env = False # avoid the default VirtualBuildEnv from the base class
|
||||
test_type = "explicit"
|
||||
|
||||
def requirements(self):
|
||||
self.requires(self.tested_reference_str)
|
||||
|
||||
def layout(self):
|
||||
cmake_layout(self)
|
||||
|
||||
def build(self):
|
||||
cmake = CMake(self)
|
||||
cmake.configure()
|
||||
cmake.build()
|
||||
|
||||
def test(self):
|
||||
if can_run(self):
|
||||
cmd = os.path.join(self.cpp.build.bindir, "test_fimdlp")
|
||||
self.run(cmd, env="conanrun")
|
27
test_package/src/test_fimdlp.cpp
Normal file
27
test_package/src/test_fimdlp.cpp
Normal file
@@ -0,0 +1,27 @@
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <fimdlp/CPPFImdlp.h>
|
||||
#include <fimdlp/Metrics.h>
|
||||
|
||||
int main() {
|
||||
std::cout << "Testing fimdlp library..." << std::endl;
|
||||
|
||||
// Simple test of the library
|
||||
try {
|
||||
// Test Metrics class
|
||||
Metrics metrics;
|
||||
std::vector<int> labels = {0, 0, 1, 1, 0, 1};
|
||||
double entropy = metrics.entropy(labels);
|
||||
std::cout << "Entropy calculated: " << entropy << std::endl;
|
||||
|
||||
// Test CPPFImdlp creation
|
||||
CPPFImdlp discretizer;
|
||||
std::cout << "CPPFImdlp instance created successfully" << std::endl;
|
||||
|
||||
std::cout << "fimdlp library test completed successfully!" << std::endl;
|
||||
return 0;
|
||||
} catch (const std::exception& e) {
|
||||
std::cerr << "Error testing fimdlp library: " << e.what() << std::endl;
|
||||
return 1;
|
||||
}
|
||||
}
|
@@ -16,13 +16,13 @@ namespace mdlp {
|
||||
const float margin = 1e-4;
|
||||
static std::string set_data_path()
|
||||
{
|
||||
std::string path = "../datasets/";
|
||||
std::string path = "datasets/";
|
||||
std::ifstream file(path + "iris.arff");
|
||||
if (file.is_open()) {
|
||||
file.close();
|
||||
return path;
|
||||
}
|
||||
return "../../tests/datasets/";
|
||||
return "tests/datasets/";
|
||||
}
|
||||
const std::string data_path = set_data_path();
|
||||
class TestBinDisc3U : public BinDisc, public testing::Test {
|
||||
|
@@ -1,17 +1,11 @@
|
||||
include(FetchContent)
|
||||
include_directories(${GTEST_INCLUDE_DIRS})
|
||||
FetchContent_Declare(
|
||||
googletest
|
||||
URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
|
||||
)
|
||||
# For Windows: Prevent overriding the parent project's compiler/linker settings
|
||||
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
|
||||
FetchContent_MakeAvailable(googletest)
|
||||
|
||||
find_package(arff-files REQUIRED)
|
||||
find_package(GTest REQUIRED)
|
||||
|
||||
include_directories(
|
||||
${TORCH_INCLUDE_DIRS}
|
||||
${libtorch_INCLUDE_DIRS_DEBUG}
|
||||
${fimdlp_SOURCE_DIR}/src
|
||||
${fimdlp_SOURCE_DIR}/tests/lib/Files
|
||||
${arff-files_INCLUDE_DIRS}
|
||||
${CMAKE_BINARY_DIR}/configured_files/include
|
||||
)
|
||||
|
||||
@@ -22,18 +16,18 @@ target_link_options(Metrics_unittest PRIVATE --coverage)
|
||||
|
||||
add_executable(FImdlp_unittest FImdlp_unittest.cpp
|
||||
${fimdlp_SOURCE_DIR}/src/CPPFImdlp.cpp ${fimdlp_SOURCE_DIR}/src/Metrics.cpp ${fimdlp_SOURCE_DIR}/src/Discretizer.cpp)
|
||||
target_link_libraries(FImdlp_unittest GTest::gtest_main "${TORCH_LIBRARIES}")
|
||||
target_link_libraries(FImdlp_unittest GTest::gtest_main torch::torch)
|
||||
target_compile_options(FImdlp_unittest PRIVATE --coverage)
|
||||
target_link_options(FImdlp_unittest PRIVATE --coverage)
|
||||
|
||||
add_executable(BinDisc_unittest BinDisc_unittest.cpp ${fimdlp_SOURCE_DIR}/src/BinDisc.cpp ${fimdlp_SOURCE_DIR}/src/Discretizer.cpp)
|
||||
target_link_libraries(BinDisc_unittest GTest::gtest_main "${TORCH_LIBRARIES}")
|
||||
target_link_libraries(BinDisc_unittest GTest::gtest_main torch::torch)
|
||||
target_compile_options(BinDisc_unittest PRIVATE --coverage)
|
||||
target_link_options(BinDisc_unittest PRIVATE --coverage)
|
||||
|
||||
add_executable(Discretizer_unittest Discretizer_unittest.cpp
|
||||
${fimdlp_SOURCE_DIR}/src/BinDisc.cpp ${fimdlp_SOURCE_DIR}/src/CPPFImdlp.cpp ${fimdlp_SOURCE_DIR}/src/Metrics.cpp ${fimdlp_SOURCE_DIR}/src/Discretizer.cpp )
|
||||
target_link_libraries(Discretizer_unittest GTest::gtest_main "${TORCH_LIBRARIES}")
|
||||
target_link_libraries(Discretizer_unittest GTest::gtest_main torch::torch)
|
||||
target_compile_options(Discretizer_unittest PRIVATE --coverage)
|
||||
target_link_options(Discretizer_unittest PRIVATE --coverage)
|
||||
|
||||
|
@@ -17,13 +17,13 @@ namespace mdlp {
|
||||
const float margin = 1e-4;
|
||||
static std::string set_data_path()
|
||||
{
|
||||
std::string path = "../datasets/";
|
||||
std::string path = "datasets/";
|
||||
std::ifstream file(path + "iris.arff");
|
||||
if (file.is_open()) {
|
||||
file.close();
|
||||
return path;
|
||||
}
|
||||
return "../../tests/datasets/";
|
||||
return "tests/datasets/";
|
||||
}
|
||||
const std::string data_path = set_data_path();
|
||||
const labels_t iris_quantile = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 3, 3, 3, 1, 3, 1, 2, 0, 3, 1, 0, 2, 2, 2, 1, 3, 1, 2, 2, 1, 2, 2, 2, 2, 3, 3, 3, 3, 2, 1, 1, 1, 2, 2, 1, 2, 3, 2, 1, 1, 1, 2, 2, 0, 1, 1, 1, 2, 1, 1, 2, 2, 3, 2, 3, 3, 0, 3, 3, 3, 3, 3, 3, 1, 2, 3, 3, 3, 3, 2, 3, 1, 3, 2, 3, 3, 2, 2, 3, 3, 3, 3, 3, 2, 2, 3, 2, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 2, 2 };
|
||||
@@ -33,7 +33,7 @@ namespace mdlp {
|
||||
auto version = disc->version();
|
||||
delete disc;
|
||||
std::cout << "Version computed: " << version;
|
||||
EXPECT_EQ("2.0.1", version);
|
||||
EXPECT_EQ("2.1.0", version);
|
||||
}
|
||||
TEST(Discretizer, BinIrisUniform)
|
||||
{
|
||||
|
@@ -40,13 +40,13 @@ namespace mdlp {
|
||||
|
||||
static string set_data_path()
|
||||
{
|
||||
string path = "../datasets/";
|
||||
string path = "datasets/";
|
||||
ifstream file(path + "iris.arff");
|
||||
if (file.is_open()) {
|
||||
file.close();
|
||||
return path;
|
||||
}
|
||||
return "../../tests/datasets/";
|
||||
return "tests/datasets/";
|
||||
}
|
||||
|
||||
void checkSortedVector()
|
||||
|
Submodule tests/lib/Files deleted from a5316928d4
Reference in New Issue
Block a user