From 17195aa6b4f43faa0fff8bf4b01c69f767fda2b4 Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Fri, 17 Nov 2023 11:38:53 +0100 Subject: [PATCH 01/31] seed writting --- .../ActsExamples/Io/Csv/CsvSeedWriter.hpp | 107 ++++++++++ .../ActsExamples/Io/Csv/CsvTrackWriter.hpp | 1 + Examples/Io/Csv/src/CsvSeedWriter.cpp | 201 ++++++++++++++++++ Examples/Io/Csv/src/CsvTrackWriter.cpp | 14 +- .../python/acts/examples/reconstruction.py | 19 ++ Examples/Python/src/Output.cpp | 6 + .../match_good_track-seed.py | 62 ++++++ Examples/Scripts/Python/full_chain_odd.py | 1 + 8 files changed, 410 insertions(+), 1 deletion(-) create mode 100644 Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp create mode 100644 Examples/Io/Csv/src/CsvSeedWriter.cpp create mode 100644 Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py diff --git a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp new file mode 100644 index 00000000000..9976b3717f3 --- /dev/null +++ b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp @@ -0,0 +1,107 @@ +// This file is part of the Acts project. +// +// Copyright (C) 2023 CERN for the benefit of the Acts project +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#pragma once + +#include "Acts/EventData/MultiTrajectoryHelpers.hpp" +#include "ActsExamples/EventData/ProtoTrack.hpp" +#include "ActsExamples/EventData/SimHit.hpp" +#include "ActsExamples/EventData/SimParticle.hpp" +#include "ActsExamples/EventData/SimSeed.hpp" +#include "ActsExamples/EventData/Trajectories.hpp" +#include "ActsExamples/Framework/DataHandle.hpp" +#include "ActsExamples/Framework/WriterT.hpp" +#include "ActsFatras/EventData/Barcode.hpp" + +#include + +using namespace Acts::UnitLiterals; + +namespace ActsExamples { + +/// @class CsvSeedWriter +/// +/// Write out the seed reconstructed by the seeding algorithm in +/// comma-separated-value format. +/// +/// This writes one file per event into the configured output directory. By +/// default it writes to the current working directory. +/// Files are named using the following schema +/// +/// event000000001-seed.csv +/// event000000002-seed.csv +/// +/// and each line in the file corresponds to one seed. +class CsvSeedWriter : public WriterT { + public: + using HitParticlesMap = IndexMultimap; + using HitSimHitsMap = IndexMultimap; + + struct Config { + /// Input estimated track parameters collection. + std::string inputTrackParameters; + /// Input seed collection. + std::string inputSimSeeds; + /// Input collection of simulated hits. + std::string inputSimHits; + /// Input hit-particles map collection. + std::string inputMeasurementParticlesMap; + /// Input collection to map measured hits to simulated hits. + std::string inputMeasurementSimHitsMap; + /// output filename. + std::string fileName = "Seed.csv"; + /// output directory + std::string outputDir; + }; + + /// Constructor + /// + /// @param config Configuration struct + /// @param level Message level declaration + CsvSeedWriter(const Config& config, + Acts::Logging::Level level = Acts::Logging::INFO); + + /// Get readonly access to the config parameters + const Config& config() const { return m_cfg; } + + protected: + /// @brief Write method called by the base class + /// @param [in] ctx is the algorithm context for event information + /// @param [in] trackParams are parameters to write + ProcessCode writeT(const AlgorithmContext& ctx, + const TrackParametersContainer& trackParams) override; + + private: + Config m_cfg; ///< The config class + + ReadDataHandle m_inputParticles{this, "InputParticles"}; + ReadDataHandle m_inputSimSeeds{this, "InputSimSeeds"}; + ReadDataHandle m_inputSimHits{this, "InputSimHits"}; + ReadDataHandle m_inputMeasurementParticlesMap{ + this, "InputMeasurementParticlesMap"}; + ReadDataHandle m_inputMeasurementSimHitsMap{ + this, "InputMeasurementSimHitsMap"}; + + /// @brief Struct for brief seed summary info + /// + struct seedInfo { + size_t seedId = 0; + ActsFatras::Barcode particleId; + float seedPt = -1; + float seedPhi = 0; + float seedEta = 0; + float vertexZ = 0; + float quality = -1; + std::vector globalPosition; + float truthDistance = -1; + std::string seedType = "unknown"; + ProtoTrack measurementsID; + }; // trackInfo struct +}; + +} // namespace ActsExamples diff --git a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvTrackWriter.hpp b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvTrackWriter.hpp index b9ff60fe15e..2bea2289973 100644 --- a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvTrackWriter.hpp +++ b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvTrackWriter.hpp @@ -89,6 +89,7 @@ class CsvTrackWriter : public WriterT { /// struct TrackInfo : public Acts::MultiTrajectoryHelpers::TrajectoryState { std::size_t trackId = 0; + unsigned int seedId = 0; ActsFatras::Barcode particleId; std::size_t nMajorityHits = 0; std::string trackType; diff --git a/Examples/Io/Csv/src/CsvSeedWriter.cpp b/Examples/Io/Csv/src/CsvSeedWriter.cpp new file mode 100644 index 00000000000..e4a51e8805b --- /dev/null +++ b/Examples/Io/Csv/src/CsvSeedWriter.cpp @@ -0,0 +1,201 @@ +// This file is part of the Acts project. +// +// Copyright (C) 2023 CERN for the benefit of the Acts project +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#include "ActsExamples/Io/Csv/CsvSeedWriter.hpp" + +#include "Acts/EventData/TrackParameters.hpp" +#include "Acts/Seeding/Seed.hpp" +#include "Acts/Utilities/Helpers.hpp" +#include "ActsExamples/EventData/AverageSimHits.hpp" +#include "ActsExamples/EventData/Index.hpp" +#include "ActsExamples/EventData/Measurement.hpp" +#include "ActsExamples/EventData/SimHit.hpp" +#include "ActsExamples/EventData/SimParticle.hpp" +#include "ActsExamples/EventData/SimSeed.hpp" +#include "ActsExamples/Utilities/EventDataTransforms.hpp" +#include "ActsExamples/Utilities/Paths.hpp" +#include "ActsExamples/Utilities/Range.hpp" +#include "ActsExamples/Validation/TrackClassification.hpp" + +#include +#include +#include +#include +#include +#include + +using Acts::VectorHelpers::eta; +using Acts::VectorHelpers::phi; +using Acts::VectorHelpers::theta; + +ActsExamples::CsvSeedWriter::CsvSeedWriter( + const ActsExamples::CsvSeedWriter::Config& config, + Acts::Logging::Level level) + : WriterT(config.inputTrackParameters, + "CsvSeedWriter", level), + m_cfg(config) { + if (m_cfg.inputSimSeeds.empty()) { + throw std::invalid_argument("Missing space points input collection"); + } + if (m_cfg.inputSimHits.empty()) { + throw std::invalid_argument("Missing simulated hits input collection"); + } + if (m_cfg.inputMeasurementParticlesMap.empty()) { + throw std::invalid_argument("Missing hit-particles map input collection"); + } + if (m_cfg.inputMeasurementSimHitsMap.empty()) { + throw std::invalid_argument( + "Missing hit-simulated-hits map input collection"); + } + if (m_cfg.fileName.empty()) { + throw std::invalid_argument("Missing output filename"); + } + if (m_cfg.outputDir.empty()) { + throw std::invalid_argument("Missing output directory"); + } + + m_inputSimSeeds.initialize(m_cfg.inputSimSeeds); + m_inputSimHits.initialize(m_cfg.inputSimHits); + m_inputMeasurementParticlesMap.initialize(m_cfg.inputMeasurementParticlesMap); + m_inputMeasurementSimHitsMap.initialize(m_cfg.inputMeasurementSimHitsMap); +} + +ActsExamples::ProcessCode ActsExamples::CsvSeedWriter::writeT( + const ActsExamples::AlgorithmContext& ctx, + const TrackParametersContainer& trackParams) { + // Read additional input collections + const auto& seeds = m_inputSimSeeds(ctx); + const auto& simHits = m_inputSimHits(ctx); + const auto& hitParticlesMap = m_inputMeasurementParticlesMap(ctx); + const auto& hitSimHitsMap = m_inputMeasurementSimHitsMap(ctx); + + std::string path = + perEventFilepath(m_cfg.outputDir, m_cfg.fileName, ctx.eventNumber); + + std::ofstream mos(path, std::ofstream::out | std::ofstream::trunc); + if (!mos) { + throw std::ios_base::failure("Could not open '" + path + "' to write"); + } + + std::unordered_map infoMap; + std::unordered_map> goodSeed; + + // Loop over the estimated track parameters + for (size_t iparams = 0; iparams < trackParams.size(); ++iparams) { + // The estimated bound parameters vector + const auto params = trackParams[iparams].parameters(); + + float seedPhi = params[Acts::eBoundPhi]; + float seedEta = std::atanh(std::cos(params[Acts::eBoundTheta])); + + // Get the proto track from which the track parameters are estimated + const auto& seed = seeds[iparams]; + const auto& ptrack = seedToPrototrack(seed); + + std::vector particleHitCounts; + identifyContributingParticles(hitParticlesMap, ptrack, particleHitCounts); + bool truthMatched = false; + float truthDistance = -1; + auto majorityParticleId = particleHitCounts.front().particleId; + // Seed are considered truth matched if they have only one contributing + // particle + if (particleHitCounts.size() == 1) { + truthMatched = true; + // Get the index of the first space point + const auto& hitIdx = ptrack.front(); + // Get the sim hits via the measurement to sim hits map + auto indices = makeRange(hitSimHitsMap.equal_range(hitIdx)); + // Get the truth particle direction from the sim hits + Acts::Vector3 truthUnitDir = {0, 0, 0}; + for (auto [_, simHitIdx] : indices) { + const auto& simHit = *simHits.nth(simHitIdx); + if (simHit.particleId() == majorityParticleId) { + truthUnitDir = simHit.direction(); + } + } + // Compute the distance between the truth and estimated directions + float truthPhi = phi(truthUnitDir); + float truthEta = std::atanh(std::cos(theta(truthUnitDir))); + float dEta = fabs(truthEta - seedEta); + float dPhi = fabs(truthPhi - seedPhi) < M_PI + ? fabs(truthPhi - seedPhi) + : fabs(truthPhi - seedPhi) - M_PI; + truthDistance = sqrt(dPhi * dPhi + dEta * dEta); + // If the seed is truth matched, check if it is the closest one for the + // contributing particle + if (goodSeed.find(majorityParticleId) != goodSeed.end()) { + if (goodSeed[majorityParticleId].second > truthDistance) { + goodSeed[majorityParticleId] = std::make_pair(iparams, truthDistance); + } + } else { + goodSeed[majorityParticleId] = std::make_pair(iparams, truthDistance); + } + } + // Store the global position of the space points + std::vector globalPosition; + for (auto spacePointPtr : seed.sp()) { + Acts::Vector3 pos(spacePointPtr->x(), spacePointPtr->y(), + spacePointPtr->z()); + globalPosition.push_back(pos); + } + + // track info + seedInfo toAdd; + toAdd.seedId = iparams; + toAdd.particleId = majorityParticleId; + toAdd.seedPt = std::abs(1.0 / params[Acts::eBoundQOverP]) * + std::sin(params[Acts::eBoundTheta]); + toAdd.seedPhi = seedPhi; + toAdd.seedEta = seedEta; + toAdd.vertexZ = seed.z(); + toAdd.quality = seed.seedQuality(); + toAdd.globalPosition = globalPosition; + toAdd.truthDistance = truthDistance; + toAdd.seedType = truthMatched ? "duplicate" : "fake"; + toAdd.measurementsID = ptrack; + + infoMap[toAdd.seedId] = toAdd; + } + + mos << "seed_id,particleId," + << "pT,eta,phi," + << "bX,bY,bZ," + << "mX,mY,mZ," + << "tX,tY,tZ," + << "good/duplicate/fake," + << "vertexZ,quality," + << "Hits_ID" << '\n'; + + for (auto& [id, info] : infoMap) { + if (goodSeed[info.particleId].first == id) { + info.seedType = "good"; + } + // write the track info + mos << info.seedId << ","; + mos << info.particleId << ","; + mos << info.seedPt << ","; + mos << info.seedPhi << ","; + mos << info.seedEta << ","; + for (auto& point : info.globalPosition) { + mos << point.x() << ","; + mos << point.y() << ","; + mos << point.z() << ","; + } + mos << info.seedType << ","; + mos << info.vertexZ << ","; + mos << info.quality << ","; + mos << "\"["; + for (auto& ID : info.measurementsID) { + mos << ID << ","; + } + mos << "]\""; + mos << '\n'; + } + + return ProcessCode::SUCCESS; +} diff --git a/Examples/Io/Csv/src/CsvTrackWriter.cpp b/Examples/Io/Csv/src/CsvTrackWriter.cpp index 54374f21bc7..a013ca3aca1 100644 --- a/Examples/Io/Csv/src/CsvTrackWriter.cpp +++ b/Examples/Io/Csv/src/CsvTrackWriter.cpp @@ -10,6 +10,8 @@ #include "Acts/Definitions/Algebra.hpp" #include "Acts/EventData/MultiTrajectory.hpp" +#include "Acts/EventData/TrackContainer.hpp" +#include "Acts/EventData/TrackProxy.hpp" #include "Acts/EventData/VectorMultiTrajectory.hpp" #include "Acts/Utilities/Helpers.hpp" #include "Acts/Utilities/MultiIndex.hpp" @@ -108,9 +110,18 @@ ProcessCode CsvTrackWriter::writeT(const AlgorithmContext& context, // n Majority hits nMajorityHits = particleHitCount.front().hitCount; } + + static const Acts::ConstTrackAccessor seedNumber( + "trackGroup"); + // track info TrackInfo toAdd; toAdd.trackId = trackId; + if (tracks.hasColumn(Acts::hashString("trackGroup"))) { + toAdd.seedId = seedNumber(track) - 1; + } else { + toAdd.seedId = 0; + } toAdd.particleId = majorityParticleId; toAdd.nStates = track.nTrackStates(); toAdd.nMajorityHits = nMajorityHits; @@ -166,7 +177,7 @@ ProcessCode CsvTrackWriter::writeT(const AlgorithmContext& context, } // write csv header - mos << "track_id,particleId," + mos << "track_id,seed_id,particleId," << "nStates,nMajorityHits,nMeasurements,nOutliers,nHoles,nSharedHits," << "chi2,ndf,chi2/ndf," << "pT,eta,phi," @@ -190,6 +201,7 @@ ProcessCode CsvTrackWriter::writeT(const AlgorithmContext& context, // write the track info mos << trajState.trackId << ","; + mos << trajState.seedId << ","; mos << trajState.particleId << ","; mos << trajState.nStates << ","; mos << trajState.nMajorityHits << ","; diff --git a/Examples/Python/python/acts/examples/reconstruction.py b/Examples/Python/python/acts/examples/reconstruction.py index 7ab4c4a072e..13a3c21e65d 100644 --- a/Examples/Python/python/acts/examples/reconstruction.py +++ b/Examples/Python/python/acts/examples/reconstruction.py @@ -187,6 +187,7 @@ def addSeeding( ] = acts.ParticleHypothesis.pion, inputParticles: str = "particles", outputDirRoot: Optional[Union[Path, str]] = None, + outputDirCsv: Optional[Union[Path, str]] = None, logLevel: Optional[acts.logging.Level] = None, rnd: Optional[acts.examples.RandomNumbers] = None, ) -> None: @@ -367,6 +368,24 @@ def addSeeding( parEstimateAlg.config.outputTrackParameters, logLevel, ) + + if outputDirCsv is not None: + outputDirCsv = Path(outputDirCsv) + + if not outputDirCsv.exists(): + outputDirCsv.mkdir() + + CsvSeedWriter = acts.examples.CsvSeedWriter( + level=logLevel, + inputTrackParameters=parEstimateAlg.config.outputTrackParameters, + inputSimSeeds=seeds, + inputSimHits="simhits", + inputMeasurementParticlesMap="measurement_particles_map", + inputMeasurementSimHitsMap="measurement_simhits_map", + outputDir=str(outputDirCsv), + fileName=str(f"seed.csv"), + ) + s.addWriter(CsvSeedWriter) return s diff --git a/Examples/Python/src/Output.cpp b/Examples/Python/src/Output.cpp index e5dde8abcea..9b04de3f2f0 100644 --- a/Examples/Python/src/Output.cpp +++ b/Examples/Python/src/Output.cpp @@ -18,6 +18,7 @@ #include "ActsExamples/Io/Csv/CsvParticleWriter.hpp" #include "ActsExamples/Io/Csv/CsvPlanarClusterWriter.hpp" #include "ActsExamples/Io/Csv/CsvProtoTrackWriter.hpp" +#include "ActsExamples/Io/Csv/CsvSeedWriter.hpp" #include "ActsExamples/Io/Csv/CsvSimHitWriter.hpp" #include "ActsExamples/Io/Csv/CsvSpacepointWriter.hpp" #include "ActsExamples/Io/Csv/CsvTrackParameterWriter.hpp" @@ -363,6 +364,11 @@ void addOutput(Context& ctx) { inputMeasurementParticlesMap, outputPrecision, nMeasurementsMin, truthMatchProbMin, ptMin); + ACTS_PYTHON_DECLARE_WRITER(ActsExamples::CsvSeedWriter, mex, "CsvSeedWriter", + inputTrackParameters, inputSimSeeds, inputSimHits, + inputMeasurementParticlesMap, + inputMeasurementSimHitsMap, fileName, outputDir); + ACTS_PYTHON_DECLARE_WRITER( ActsExamples::CsvTrackingGeometryWriter, mex, "CsvTrackingGeometryWriter", trackingGeometry, outputDir, outputPrecision, writeSensitive, diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py b/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py new file mode 100644 index 00000000000..1d4311c936b --- /dev/null +++ b/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py @@ -0,0 +1,62 @@ +import glob + +import pandas as pd +import numpy as np + + +def matchGood(Seed_files: list[str], CKF_files: list[str]) -> pd.DataFrame: + """Read the dataset from the different files, remove the particle with only fakes and combine the datasets""" + """ + @param[in] Seed_files: DataFrame contain the data from each seed files (1 file per events usually) + @return: combined DataFrame containing all the seed, ordered by events and then by truth particle ID in each events + """ + data_seed = pd.DataFrame() + data_track = pd.DataFrame() + goodSeed = pd.DataFrame() + data = pd.DataFrame() + # Loop over the different track files and collect the list of seed ID associated to the good tracks + for f_ckf, f_seed in zip(CKF_files, Seed_files): + print("reading file: ", f_ckf, f_seed) + data_track = pd.read_csv(f_ckf) + data_track = data_track.loc[data_track["good/duplicate/fake"] == "good"] + goodSeed = data_track["seed_id"] + + data_seed = pd.read_csv(f_seed) + # Add a good seed column to the seed dataset + data_seed["goodSeed"] = data_seed["seed_id"].isin(goodSeed) + + data_seed.loc[data_seed["good/duplicate/fake"] == "good", "good/duplicate/fake"] = "duplicate" + data_seed.loc[data_seed["goodSeed"] == True, "good/duplicate/fake"] = "good" + + cleanedData = pd.DataFrame() + + for ID in data_seed["particleId"].unique(): + if ( + data_seed.loc[data_seed["particleId"] == ID, "goodSeed"] == False + ).all(): + data_seed.loc[data_seed["particleId"] == ID, "good/duplicate/fake"] = "fake" + else: + cleanedData = pd.concat([data_seed.loc[data_seed["particleId"] == ID], cleanedData]) + + # Save the cleaned dataset for future use (the cleaning is time consuming) + matched = f_seed[:-4] + "_matched.csv" + matchedData = data_seed.sort_values("seed_id") + matchedData = matchedData.set_index("seed_id") + matchedData = matchedData.drop(columns=["goodSeed"]) + matchedData.to_csv(matched) + data = pd.concat([data, matchedData]) + + # Save the cleaned dataset for future use (the cleaning is time consuming) + cleaned = f_seed[:-4] + "_cleaned.csv" + cleanedData = cleanedData.sort_values("seed_id") + cleanedData = cleanedData.set_index("seed_id") + cleanedData = cleanedData.drop(columns=["goodSeed"]) + cleanedData.to_csv(cleaned) + + return data + + +# ttbar events used as the training input +seed_files = sorted(glob.glob("odd_output" + "/event*-seed.csv")) +CKF_files = sorted(glob.glob("odd_output" + "/event*-tracks_ckf.csv")) +data = matchGood(seed_files, CKF_files) diff --git a/Examples/Scripts/Python/full_chain_odd.py b/Examples/Scripts/Python/full_chain_odd.py index 26c951249eb..d760149dd2c 100755 --- a/Examples/Scripts/Python/full_chain_odd.py +++ b/Examples/Scripts/Python/full_chain_odd.py @@ -162,6 +162,7 @@ else TruthSeedRanges(), geoSelectionConfigFile=oddSeedingSel, outputDirRoot=outputDir, + #outputDirCsv=outputDir, ) addCKFTracks( From 79e1b66bb5977c489c3ad8bb7bf29b8b8c0b8caa Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Fri, 17 Nov 2023 13:33:27 +0100 Subject: [PATCH 02/31] format --- .../MLAmbiguityResolution/match_good_track-seed.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py b/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py index 1d4311c936b..1a2bae7cb4b 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py @@ -25,7 +25,9 @@ def matchGood(Seed_files: list[str], CKF_files: list[str]) -> pd.DataFrame: # Add a good seed column to the seed dataset data_seed["goodSeed"] = data_seed["seed_id"].isin(goodSeed) - data_seed.loc[data_seed["good/duplicate/fake"] == "good", "good/duplicate/fake"] = "duplicate" + data_seed.loc[ + data_seed["good/duplicate/fake"] == "good", "good/duplicate/fake" + ] = "duplicate" data_seed.loc[data_seed["goodSeed"] == True, "good/duplicate/fake"] = "good" cleanedData = pd.DataFrame() @@ -34,9 +36,13 @@ def matchGood(Seed_files: list[str], CKF_files: list[str]) -> pd.DataFrame: if ( data_seed.loc[data_seed["particleId"] == ID, "goodSeed"] == False ).all(): - data_seed.loc[data_seed["particleId"] == ID, "good/duplicate/fake"] = "fake" + data_seed.loc[ + data_seed["particleId"] == ID, "good/duplicate/fake" + ] = "fake" else: - cleanedData = pd.concat([data_seed.loc[data_seed["particleId"] == ID], cleanedData]) + cleanedData = pd.concat( + [data_seed.loc[data_seed["particleId"] == ID], cleanedData] + ) # Save the cleaned dataset for future use (the cleaning is time consuming) matched = f_seed[:-4] + "_matched.csv" @@ -52,7 +58,7 @@ def matchGood(Seed_files: list[str], CKF_files: list[str]) -> pd.DataFrame: cleanedData = cleanedData.set_index("seed_id") cleanedData = cleanedData.drop(columns=["goodSeed"]) cleanedData.to_csv(cleaned) - + return data From 8da472132e2ba83195509d31ca5874c55b2d7f78 Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Fri, 17 Nov 2023 13:38:36 +0100 Subject: [PATCH 03/31] comments --- Examples/Io/Csv/src/CsvTrackWriter.cpp | 2 -- .../MLAmbiguityResolution/match_good_track-seed.py | 11 +++++++---- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/Examples/Io/Csv/src/CsvTrackWriter.cpp b/Examples/Io/Csv/src/CsvTrackWriter.cpp index a013ca3aca1..b5127de1e60 100644 --- a/Examples/Io/Csv/src/CsvTrackWriter.cpp +++ b/Examples/Io/Csv/src/CsvTrackWriter.cpp @@ -10,8 +10,6 @@ #include "Acts/Definitions/Algebra.hpp" #include "Acts/EventData/MultiTrajectory.hpp" -#include "Acts/EventData/TrackContainer.hpp" -#include "Acts/EventData/TrackProxy.hpp" #include "Acts/EventData/VectorMultiTrajectory.hpp" #include "Acts/Utilities/Helpers.hpp" #include "Acts/Utilities/MultiIndex.hpp" diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py b/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py index 1a2bae7cb4b..d7d1ece33fb 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py @@ -5,9 +5,10 @@ def matchGood(Seed_files: list[str], CKF_files: list[str]) -> pd.DataFrame: - """Read the dataset from the different files, remove the particle with only fakes and combine the datasets""" + """Read the dataset from the tracks and seeds files, then modify the seed dataset so that good seed correspond to the ones that lead to good tracks. Seed with truth id that do not lead to good tracks are considered as fake. Also create a new dataset with only truth particle associated to a good seeds.""" """ - @param[in] Seed_files: DataFrame contain the data from each seed files (1 file per events usually) + @param[in] Seed_files: List of files containing seeds data (1 file per events usually) + @param[in] CKF_files: List of files containing tracks data (1 file per events usually) @return: combined DataFrame containing all the seed, ordered by events and then by truth particle ID in each events """ data_seed = pd.DataFrame() @@ -32,6 +33,7 @@ def matchGood(Seed_files: list[str], CKF_files: list[str]) -> pd.DataFrame: cleanedData = pd.DataFrame() + # Find the particle ID that are associated to only fake seeds for ID in data_seed["particleId"].unique(): if ( data_seed.loc[data_seed["particleId"] == ID, "goodSeed"] == False @@ -44,7 +46,7 @@ def matchGood(Seed_files: list[str], CKF_files: list[str]) -> pd.DataFrame: [data_seed.loc[data_seed["particleId"] == ID], cleanedData] ) - # Save the cleaned dataset for future use (the cleaning is time consuming) + # Save the matched dataset for future use (the matching is time consuming) matched = f_seed[:-4] + "_matched.csv" matchedData = data_seed.sort_values("seed_id") matchedData = matchedData.set_index("seed_id") @@ -62,7 +64,8 @@ def matchGood(Seed_files: list[str], CKF_files: list[str]) -> pd.DataFrame: return data -# ttbar events used as the training input +# Read the seed and track files and match them +# This will allow us to determine which seeds leads to the best possible tracks seed_files = sorted(glob.glob("odd_output" + "/event*-seed.csv")) CKF_files = sorted(glob.glob("odd_output" + "/event*-tracks_ckf.csv")) data = matchGood(seed_files, CKF_files) From 60acd9a944c072dd8d22ca31640fcd2bdbc61845 Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Fri, 17 Nov 2023 14:14:23 +0100 Subject: [PATCH 04/31] cmake --- Examples/Io/Csv/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/Examples/Io/Csv/CMakeLists.txt b/Examples/Io/Csv/CMakeLists.txt index 0b5dd42d028..d8faabbcc36 100644 --- a/Examples/Io/Csv/CMakeLists.txt +++ b/Examples/Io/Csv/CMakeLists.txt @@ -14,6 +14,7 @@ add_library( src/CsvTrackingGeometryWriter.cpp src/CsvTrackParameterReader.cpp src/CsvTrackParameterWriter.cpp + src/CsvSeedWriter.cpp src/CsvTrackWriter.cpp src/CsvProtoTrackWriter.cpp src/CsvSpacePointWriter.cpp From b38cc70a505856c78f2ec0a4327efe5fc6466ac0 Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Fri, 17 Nov 2023 14:20:06 +0100 Subject: [PATCH 05/31] format --- Examples/Python/python/acts/examples/reconstruction.py | 2 +- Examples/Scripts/Python/full_chain_odd.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Examples/Python/python/acts/examples/reconstruction.py b/Examples/Python/python/acts/examples/reconstruction.py index 13a3c21e65d..440ac9ce65e 100644 --- a/Examples/Python/python/acts/examples/reconstruction.py +++ b/Examples/Python/python/acts/examples/reconstruction.py @@ -368,7 +368,7 @@ def addSeeding( parEstimateAlg.config.outputTrackParameters, logLevel, ) - + if outputDirCsv is not None: outputDirCsv = Path(outputDirCsv) diff --git a/Examples/Scripts/Python/full_chain_odd.py b/Examples/Scripts/Python/full_chain_odd.py index d760149dd2c..3f294dd4b3f 100755 --- a/Examples/Scripts/Python/full_chain_odd.py +++ b/Examples/Scripts/Python/full_chain_odd.py @@ -162,7 +162,7 @@ else TruthSeedRanges(), geoSelectionConfigFile=oddSeedingSel, outputDirRoot=outputDir, - #outputDirCsv=outputDir, + # outputDirCsv=outputDir, ) addCKFTracks( From e832ee20ce7be399d55de15b40dde69cf5547eac Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Fri, 17 Nov 2023 14:21:54 +0100 Subject: [PATCH 06/31] size_t --- .../Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp | 2 +- Examples/Io/Csv/src/CsvSeedWriter.cpp | 7 ++++--- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp index 9976b3717f3..8d076eea1f1 100644 --- a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp +++ b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp @@ -90,7 +90,7 @@ class CsvSeedWriter : public WriterT { /// @brief Struct for brief seed summary info /// struct seedInfo { - size_t seedId = 0; + std::size_t seedId = 0; ActsFatras::Barcode particleId; float seedPt = -1; float seedPhi = 0; diff --git a/Examples/Io/Csv/src/CsvSeedWriter.cpp b/Examples/Io/Csv/src/CsvSeedWriter.cpp index e4a51e8805b..f7de878367e 100644 --- a/Examples/Io/Csv/src/CsvSeedWriter.cpp +++ b/Examples/Io/Csv/src/CsvSeedWriter.cpp @@ -82,11 +82,12 @@ ActsExamples::ProcessCode ActsExamples::CsvSeedWriter::writeT( throw std::ios_base::failure("Could not open '" + path + "' to write"); } - std::unordered_map infoMap; - std::unordered_map> goodSeed; + std::unordered_map infoMap; + std::unordered_map> + goodSeed; // Loop over the estimated track parameters - for (size_t iparams = 0; iparams < trackParams.size(); ++iparams) { + for (std::size_t iparams = 0; iparams < trackParams.size(); ++iparams) { // The estimated bound parameters vector const auto params = trackParams[iparams].parameters(); From b0224ddff6d26f8f1da22bc6e94831b2712a229e Mon Sep 17 00:00:00 2001 From: Corentin ALLAIRE <62873125+Corentin-Allaire@users.noreply.github.com> Date: Mon, 20 Nov 2023 16:56:52 +0100 Subject: [PATCH 07/31] Apply suggestions from code review Renaming Co-authored-by: Andreas Stefl --- .../Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp | 2 +- .../Python/MLAmbiguityResolution/match_good_track-seed.py | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp index 8d076eea1f1..b95642b4d6d 100644 --- a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp +++ b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp @@ -89,7 +89,7 @@ class CsvSeedWriter : public WriterT { /// @brief Struct for brief seed summary info /// - struct seedInfo { + struct SeedInfo { std::size_t seedId = 0; ActsFatras::Barcode particleId; float seedPt = -1; diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py b/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py index d7d1ece33fb..e5321040952 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py @@ -4,7 +4,7 @@ import numpy as np -def matchGood(Seed_files: list[str], CKF_files: list[str]) -> pd.DataFrame: +def matchGood(seed_files: list[str], ckf_files: list[str]) -> pd.DataFrame: """Read the dataset from the tracks and seeds files, then modify the seed dataset so that good seed correspond to the ones that lead to good tracks. Seed with truth id that do not lead to good tracks are considered as fake. Also create a new dataset with only truth particle associated to a good seeds.""" """ @param[in] Seed_files: List of files containing seeds data (1 file per events usually) @@ -16,7 +16,7 @@ def matchGood(Seed_files: list[str], CKF_files: list[str]) -> pd.DataFrame: goodSeed = pd.DataFrame() data = pd.DataFrame() # Loop over the different track files and collect the list of seed ID associated to the good tracks - for f_ckf, f_seed in zip(CKF_files, Seed_files): + for f_ckf, f_seed in zip(ckf_files, seed_files): print("reading file: ", f_ckf, f_seed) data_track = pd.read_csv(f_ckf) data_track = data_track.loc[data_track["good/duplicate/fake"] == "good"] @@ -67,5 +67,5 @@ def matchGood(Seed_files: list[str], CKF_files: list[str]) -> pd.DataFrame: # Read the seed and track files and match them # This will allow us to determine which seeds leads to the best possible tracks seed_files = sorted(glob.glob("odd_output" + "/event*-seed.csv")) -CKF_files = sorted(glob.glob("odd_output" + "/event*-tracks_ckf.csv")) -data = matchGood(seed_files, CKF_files) +ckf_files = sorted(glob.glob("odd_output" + "/event*-tracks_ckf.csv")) +data = matchGood(seed_files, ckf_files) From 2a5d15bedfe1e4ce7375266378c8777d0fc6b7b2 Mon Sep 17 00:00:00 2001 From: Corentin ALLAIRE <62873125+Corentin-Allaire@users.noreply.github.com> Date: Mon, 20 Nov 2023 17:11:36 +0100 Subject: [PATCH 08/31] SeedInfo --- Examples/Io/Csv/src/CsvSeedWriter.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Examples/Io/Csv/src/CsvSeedWriter.cpp b/Examples/Io/Csv/src/CsvSeedWriter.cpp index f7de878367e..95e27ace158 100644 --- a/Examples/Io/Csv/src/CsvSeedWriter.cpp +++ b/Examples/Io/Csv/src/CsvSeedWriter.cpp @@ -82,7 +82,7 @@ ActsExamples::ProcessCode ActsExamples::CsvSeedWriter::writeT( throw std::ios_base::failure("Could not open '" + path + "' to write"); } - std::unordered_map infoMap; + std::unordered_map infoMap; std::unordered_map> goodSeed; @@ -146,7 +146,7 @@ ActsExamples::ProcessCode ActsExamples::CsvSeedWriter::writeT( } // track info - seedInfo toAdd; + SeedInfo toAdd; toAdd.seedId = iparams; toAdd.particleId = majorityParticleId; toAdd.seedPt = std::abs(1.0 / params[Acts::eBoundQOverP]) * From 25068893328b7245b95fe3611c8df94341b3c969 Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Tue, 21 Nov 2023 15:04:23 +0100 Subject: [PATCH 09/31] fixed sized vector --- Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp | 2 +- Examples/Io/Csv/src/CsvSeedWriter.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp index 8d076eea1f1..84bdce92f3a 100644 --- a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp +++ b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp @@ -97,7 +97,7 @@ class CsvSeedWriter : public WriterT { float seedEta = 0; float vertexZ = 0; float quality = -1; - std::vector globalPosition; + boost::container::small_vector globalPosition; float truthDistance = -1; std::string seedType = "unknown"; ProtoTrack measurementsID; diff --git a/Examples/Io/Csv/src/CsvSeedWriter.cpp b/Examples/Io/Csv/src/CsvSeedWriter.cpp index f7de878367e..2c84dec9614 100644 --- a/Examples/Io/Csv/src/CsvSeedWriter.cpp +++ b/Examples/Io/Csv/src/CsvSeedWriter.cpp @@ -138,7 +138,7 @@ ActsExamples::ProcessCode ActsExamples::CsvSeedWriter::writeT( } } // Store the global position of the space points - std::vector globalPosition; + boost::container::small_vector globalPosition; for (auto spacePointPtr : seed.sp()) { Acts::Vector3 pos(spacePointPtr->x(), spacePointPtr->y(), spacePointPtr->z()); From b2a9cf3fa5cd847bc35781c9d64000572fdae02b Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Tue, 21 Nov 2023 16:04:02 +0100 Subject: [PATCH 10/31] new files --- .../TrackFindingML/SeedFilterMLAlgorithm.hpp | 83 ++++++++++++++ .../src/SeedFilterMLAlgorithm.cpp | 106 ++++++++++++++++++ .../Mlpack/SeedFilterDBScanClustering.hpp | 61 ++++++++++ .../Acts/Plugins/Onnx/SeedClassifier.hpp | 93 +++++++++++++++ 4 files changed, 343 insertions(+) create mode 100644 Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp create mode 100644 Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp create mode 100644 Plugins/Mlpack/include/Acts/Plugins/Mlpack/SeedFilterDBScanClustering.hpp create mode 100644 Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp diff --git a/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp b/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp new file mode 100644 index 00000000000..99160451ad1 --- /dev/null +++ b/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp @@ -0,0 +1,83 @@ +// This file is part of the Acts project. +// +// Copyright (C) 2023 CERN for the benefit of the Acts project +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#pragma once + +#include "Acts/Plugins/Onnx/SeedClassifier.hpp" +#include "ActsExamples/EventData/SimSeed.hpp" +#include "ActsExamples/EventData/Track.hpp" +#include "ActsExamples/Framework/DataHandle.hpp" +#include "ActsExamples/TrackFindingML/AmbiguityResolutionML.hpp" + +#include + +namespace ActsExamples { + +/// Removes seeds that seem to be duplicated and fake. +/// +/// The implementation works as follows: +/// 1) Cluster together nearby seeds using a DBScan +/// 2) For each seed use a neural network to compute a score +/// 3) In each cluster keep the seed with the highest score +class SeedFilterMLAlgorithm : public IAlgorithm { + public: + struct Config { + /// Input estimated track parameters collection. + std::string inputTrackParameters; + /// Input seeds collection. + std::string inputSimSeeds; + /// Path to the ONNX model for the duplicate neural network + std::string inputSeedFilterNN; + /// Output estimated track parameters collection. + std::string outputTrackParameters; + /// Output seeds collection. + std::string outputSimSeeds; + /// Maximum distance between 2 tracks to be clustered in the DBScan + float epsilonDBScan = 0.1; + /// Minimum number of tracks to create a cluster in the DBScan + int minPointsDBScan = 2; + /// Minimum score a seed need to be selected + int minSeedScore = 0.0; + /// Clustering parameters weight for phi used before the DBSCAN + double clusteringWeighPhi = 1.0; + /// Clustering parameters weight for eta used before the DBSCAN + double clusteringWeighEta = 1.0; + /// Clustering parameters weight for z used before the DBSCAN + double clusteringWeighZ = 50.0; + /// Clustering parameters weight for pT used before the DBSCAN + double clusteringWeighPt = 1.0; + }; + + /// Construct the seed filter algorithm. + /// + /// @param cfg is the algorithm configuration + /// @param lvl is the logging level + SeedFilterMLAlgorithm(Config cfg, Acts::Logging::Level lvl); + + /// Run the seed filter algorithm. + /// + /// @param cxt is the algorithm context with event information + /// @return a process code indication success or failure + ProcessCode execute(const AlgorithmContext& ctx) const final; + + /// Const access to the config + const Config& config() const { return m_cfg; } + + private: + Config m_cfg; + // ONNX model for track selection + Acts::SeedClassifier m_seedClassifier; + ReadDataHandle m_inputTrackParameters{ + this, "InputTrackParameters"}; + ReadDataHandle m_inputSimSeeds{this, "InputSimSeeds"}; + WriteDataHandle m_outputTrackParameters{ + this, "OutputTrackParameters"}; + WriteDataHandle m_outputSimSeeds{this, "OutputSimSeeds"}; +}; + +} // namespace ActsExamples diff --git a/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp b/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp new file mode 100644 index 00000000000..db66da01415 --- /dev/null +++ b/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp @@ -0,0 +1,106 @@ +// This file is part of the Acts project. +// +// Copyright (C) 2023 CERN for the benefit of the Acts project +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#include "ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp" + +#include "Acts/Plugins/Mlpack/SeedFilterDBScanClustering.hpp" +#include "ActsExamples/Framework/ProcessCode.hpp" +#include "ActsExamples/Framework/WhiteBoard.hpp" + +#include +#include + +ActsExamples::SeedFilterMLAlgorithm::SeedFilterMLAlgorithm( + ActsExamples::SeedFilterMLAlgorithm::Config cfg, Acts::Logging::Level lvl) + : ActsExamples::IAlgorithm("SeedFilterMLAlgorithm", lvl), + m_cfg(std::move(cfg)), + m_seedClassifier(m_cfg.inputSeedFilterNN.c_str()) { + if (m_cfg.inputTrackParameters.empty()) { + throw std::invalid_argument("Missing trajectories input collection"); + } + if (m_cfg.inputSimSeeds.empty()) { + throw std::invalid_argument("Missing trajectories input collection"); + } + if (m_cfg.outputTrackParameters.empty()) { + throw std::invalid_argument("Missing trajectories output collection"); + } + if (m_cfg.outputSimSeeds.empty()) { + throw std::invalid_argument("Missing trajectories output collection"); + } + m_inputTrackParameters.initialize(m_cfg.inputTrackParameters); + m_inputSimSeeds.initialize(m_cfg.inputSimSeeds); + m_outputTrackParameters.initialize(m_cfg.outputTrackParameters); + m_outputSimSeeds.initialize(m_cfg.outputSimSeeds); +} + +ActsExamples::ProcessCode ActsExamples::SeedFilterMLAlgorithm::execute( + const AlgorithmContext& ctx) const { + // Read input data + const auto& seeds = m_inputSimSeeds(ctx); + const auto& params = m_inputTrackParameters(ctx); + if (seeds.size() != params.size()) { + throw std::invalid_argument( + "The number of seeds and track parameters is different"); + } + + Eigen::Array + networkInput(seeds.size(), 14); + std::vector> clusteringParams; + std::vector mapSeepIndex; + // Loop over the seed and parameters to fill the input for the clustering + // and the NN + for (std::size_t i = 0; i < seeds.size(); i++) { + // Keep track of the index of the seed in the original collection + std::size_t NNindex = mapSeepIndex.size() - 1; + mapSeepIndex.push_back(i); + // Compute the track parameters + double pT = std::abs(1.0 / params[i].parameters()[Acts::eBoundQOverP]) * + std::sin(params[i].parameters()[Acts::eBoundTheta]); + double eta = + std::atanh(std::cos(params[i].parameters()[Acts::eBoundTheta])); + double phi = params[i].parameters()[Acts::eBoundPhi]; + + // Fill and weight the clustering inputs + clusteringParams.push_back({phi / m_cfg.clusteringWeighPhi, + eta / m_cfg.clusteringWeighEta, + seeds[i].z() / m_cfg.clusteringWeighZ, + pT / m_cfg.clusteringWeighPt}); + // Fill the NN input + networkInput.row(NNindex) << pT, eta, phi, seeds[i].sp()[0]->x(), + seeds[i].sp()[0]->y(), seeds[i].sp()[0]->z(), seeds[i].sp()[1]->x(), + seeds[i].sp()[1]->y(), seeds[i].sp()[1]->z(), seeds[i].sp()[2]->x(), + seeds[i].sp()[2]->y(), seeds[i].sp()[2]->z(), seeds[i].z(), + seeds[i].seedQuality(); + } + + // Cluster the tracks using DBscan + auto cluster = Acts::dbscanSeedClustering( + clusteringParams, m_cfg.epsilonDBScan, m_cfg.minPointsDBScan); + + // Select the ID of the track we want to keep + std::vector goodSeed = + m_seedClassifier.solveAmbiguity(cluster, networkInput, minSeedScore); + + // Create the output seed collection + SimSeedContainer outputSeeds; + outputSeeds.reserve(goodSeed.size()); + + // Create the output track parameters collection + TrackParametersContainer outputTrackParameters; + outputTrackParameters.reserve(goodSeed.size()); + + for (auto&& i : goodSeed) { + outputSeeds.push_back(seeds[mapSeepIndex[i]]); + outputTrackParameters.push_back(params[mapSeepIndex[i]]); + } + + m_outputSimSeeds(ctx, SimSeedContainer{outputSeeds}); + m_outputTrackParameters(ctx, TrackParametersContainer{outputTrackParameters}); + + return ActsExamples::ProcessCode::SUCCESS; +} diff --git a/Plugins/Mlpack/include/Acts/Plugins/Mlpack/SeedFilterDBScanClustering.hpp b/Plugins/Mlpack/include/Acts/Plugins/Mlpack/SeedFilterDBScanClustering.hpp new file mode 100644 index 00000000000..762776494bb --- /dev/null +++ b/Plugins/Mlpack/include/Acts/Plugins/Mlpack/SeedFilterDBScanClustering.hpp @@ -0,0 +1,61 @@ +// This file is part of the Acts project. +// +// Copyright (C) 2023 CERN for the benefit of the Acts project +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#pragma once + +#include +#include +#include + +#include "mlpack/methods/dbscan.hpp" + +namespace Acts { + +/// Clusters seed based on their direction, their Z impact parameter and their +/// momentum using DBScan +/// +/// @param input : Input parameters for the clustering (phi, eta, z, Pt) +/// @param epsilon : Maximum distance between 2 tracks to be clustered +/// @param minPoints : Minimum number of tracks to create a cluster +/// @return an unordered map representing the clusters, the keys the ID of the primary seed of each cluster and the stored value a vector of seed IDs. +std::vector> dbscanSeedClustering( + const std::vector>& input, float epsilon = 0.1, + int minPoints = 2) { + // DBSCAN algorithm from MLpack used in the seed clustering + mlpack::DBSCAN dbscan(epsilon, minPoints); + + // Compute the space dimension of the input + int dim = input[0].size(); + + // Prepare the input for the DBScan + arma::mat data(dim, input.size()); + arma::Row assignments; + std::size_t trackID = 0; + for (const auto& param : input) { + for (int i = 0; i < dim; i++) { + data(i, trackID) = param[i]; + } + trackID++; + } + // Cluster track with DBScan + std::size_t clusterNb = dbscan.Cluster(data, assignments); + + // Prepare the output + std::vector> cluster(clusterNb); + for (std::size_t iD = 0; iD < input.size(); iD++) { + int clusterID = assignments(iD); + if (assignments(iD) == SIZE_MAX) { + cluster.push_back(std::vector(1, iD)); + } else { + cluster[clusterID].push_back(iD); + } + } + return cluster; +} + +} // namespace Acts diff --git a/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp b/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp new file mode 100644 index 00000000000..03f6e5d699e --- /dev/null +++ b/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp @@ -0,0 +1,93 @@ +// This file is part of the Acts project. +// +// Copyright (C) 2023 CERN for the benefit of the Acts project +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#pragma once + +#include "Acts/Plugins/Onnx/OnnxRuntimeBase.hpp" + +#include + +#include + +namespace Acts { + +/// Onnx model implementation for seed scoring and selection +class SeedClassifier { + public: + /// Construct the scoring algorithm. + /// + /// @param modelPath path to the model file + SeedClassifier(const char* modelPath) + : m_env(ORT_LOGGING_LEVEL_WARNING, "MLSeedClassifier"), + m_duplicateClassifier(m_env, modelPath){}; + + /// Compute a score for each seed to be used in the seed selection + /// + /// @param networkInput input of the network + /// @return a vector of vector of seed score. Due to the architecture of the network each seed only have a size 1 score vector. + std::vector> inferScores( + Acts::NetworkBatchInput& networkInput) const { + // Use the network to compute a score for all the Seeds. + std::vector> outputTensor = + m_duplicateClassifier.runONNXInference(networkInput); + return outputTensor; + } + + /// Select the seed associated with each cluster based on the score vector + /// + /// @param clusters is a vector of clusters, each cluster correspond to a vector of seed ID + /// @param outputTensor is the score vector obtained from inferScores. + /// @param minSeedScore is the minimum score a seed need to be selected + /// @return a vector of seedID corresponding tho the good seeds + std::vector seedSelection( + std::vector>& clusters, + std::vector>& outputTensor + float minSeedScore = 0.0) const { + std::vector goodSeeds; + int iOut = 0; + // Loop over all the cluster and only keep the seed with the highest score + // in each cluster + for (const auto& cluster : clusters) { + int bestSeedID = 0; + float bestSeedScore = 0; + for (const auto& seed : cluster) { + if (outputTensor[iOut][0] > bestSeedScore) { + bestSeedScore = outputTensor[iOut][0]; + bestSeedID = seed; + } + iOut++; + } + if(bestSeedScore >= minSeedScore){ + goodSeeds.push_back(bestSeedID); + } + } + return goodSeeds; + } + + /// Select the seed associated with each cluster + /// + /// @param clusters is a map of clusters, each cluster correspond to a vector of seed ID + /// @param networkInput input of the network + /// @param minSeedScore is the minimum score a seed need to be selected + /// @return a vector of seedID corresponding the the good seeds + std::vector solveAmbiguity(std::vector>& clusters, + Acts::NetworkBatchInput& networkInput, + float minSeedScore = 0.0) const { + std::vector> outputTensor = inferScores(networkInput); + std::vector goodSeeds = seedSelection(clusters, outputTensor, minSeedScore); + return goodSeeds; + } + + private: + // ONNX environment + Ort::Env m_env; + // ONNX model for the duplicate neural network + Acts::OnnxRuntimeBase m_duplicateClassifier; +}; + +} // namespace Acts From 1e6a93cf8780d15e4e1933b255b20c250659938c Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Tue, 21 Nov 2023 16:04:52 +0100 Subject: [PATCH 11/31] update CMakelists --- Examples/Algorithms/TrackFindingML/CMakeLists.txt | 1 + Plugins/Mlpack/CMakeLists.txt | 3 ++- Plugins/Onnx/CMakeLists.txt | 1 + 3 files changed, 4 insertions(+), 1 deletion(-) diff --git a/Examples/Algorithms/TrackFindingML/CMakeLists.txt b/Examples/Algorithms/TrackFindingML/CMakeLists.txt index fce4f979a72..e517d0060e8 100644 --- a/Examples/Algorithms/TrackFindingML/CMakeLists.txt +++ b/Examples/Algorithms/TrackFindingML/CMakeLists.txt @@ -6,6 +6,7 @@ set(SOURCES if(ACTS_BUILD_PLUGIN_MLPACK) list(APPEND SOURCES src/AmbiguityResolutionMLDBScanAlgorithm.cpp + src/SeedFilterMLAlgorithm.cpp ) endif() diff --git a/Plugins/Mlpack/CMakeLists.txt b/Plugins/Mlpack/CMakeLists.txt index 1fc9090e4f3..132921eb814 100644 --- a/Plugins/Mlpack/CMakeLists.txt +++ b/Plugins/Mlpack/CMakeLists.txt @@ -1,7 +1,8 @@ add_library( ActsPluginMlpack SHARED # header files - include/Acts/Plugins/Mlpack/AmbiguityDBScanClustering.hpp) + include/Acts/Plugins/Mlpack/AmbiguityDBScanClustering.hpp + include/Acts/Plugins/Mlpack/SeedFilterDBScanClustering.hpp) target_include_directories( ActsPluginMlpack diff --git a/Plugins/Onnx/CMakeLists.txt b/Plugins/Onnx/CMakeLists.txt index 3e04aefad4c..f4b756fb38a 100644 --- a/Plugins/Onnx/CMakeLists.txt +++ b/Plugins/Onnx/CMakeLists.txt @@ -4,6 +4,7 @@ add_library( include/Acts/Plugins/Onnx/OnnxRuntimeBase.hpp include/Acts/Plugins/Onnx/MLTrackClassifier.hpp include/Acts/Plugins/Onnx/AmbiguityTrackClassifier.hpp + include/Acts/Plugins/Onnx/SeedClassifier.hpp # source files src/OnnxRuntimeBase.cpp src/MLTrackClassifier.cpp) From acedcc3b4eb1142393844b76cd6baa99171f4de0 Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Tue, 21 Nov 2023 16:05:34 +0100 Subject: [PATCH 12/31] algorithms --- .../TrackFindingML/src/AmbiguityResolutionMLAlgorithm.cpp | 2 +- .../src/AmbiguityResolutionMLDBScanAlgorithm.cpp | 2 +- .../TrackFindingML/src/SeedFilterMLAlgorithm.cpp | 7 +++---- 3 files changed, 5 insertions(+), 6 deletions(-) diff --git a/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLAlgorithm.cpp b/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLAlgorithm.cpp index 3be5dd22bd4..3776f1f6778 100644 --- a/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLAlgorithm.cpp +++ b/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLAlgorithm.cpp @@ -40,7 +40,7 @@ ActsExamples::ProcessCode ActsExamples::AmbiguityResolutionMLAlgorithm::execute( auto cluster = Acts::detail::clusterDuplicateTracks(trackMap); // Select the ID of the track we want to keep std::vector goodTracks = - m_duplicateClassifier.solveAmbuguity(cluster, tracks); + m_duplicateClassifier.solveAmbiguity(cluster, tracks); // Prepare the output track collection from the IDs auto outputTracks = prepareOutputTrack(tracks, goodTracks); m_outputTracks(ctx, std::move(outputTracks)); diff --git a/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLDBScanAlgorithm.cpp b/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLDBScanAlgorithm.cpp index dd72d147839..3af289cf09a 100644 --- a/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLDBScanAlgorithm.cpp +++ b/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLDBScanAlgorithm.cpp @@ -46,7 +46,7 @@ ActsExamples::AmbiguityResolutionMLDBScanAlgorithm::execute( trackMap, tracks, m_cfg.epsilonDBScan, m_cfg.minPointsDBScan); // Select the ID of the track we want to keep std::vector goodTracks = - m_duplicateClassifier.solveAmbuguity(cluster, tracks); + m_duplicateClassifier.solveAmbiguity(cluster, tracks); // Prepare the output track collection from the IDs auto outputTracks = prepareOutputTrack(tracks, goodTracks); m_outputTracks(ctx, std::move(outputTracks)); diff --git a/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp b/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp index db66da01415..5778c8bab1e 100644 --- a/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp +++ b/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp @@ -66,10 +66,9 @@ ActsExamples::ProcessCode ActsExamples::SeedFilterMLAlgorithm::execute( double phi = params[i].parameters()[Acts::eBoundPhi]; // Fill and weight the clustering inputs - clusteringParams.push_back({phi / m_cfg.clusteringWeighPhi, - eta / m_cfg.clusteringWeighEta, - seeds[i].z() / m_cfg.clusteringWeighZ, - pT / m_cfg.clusteringWeighPt}); + clusteringParams.push_back( + {phi / m_cfg.clusteringWeighPhi, eta / m_cfg.clusteringWeighEta, + seeds[i].z() / m_cfg.clusteringWeighZ, pT / m_cfg.clusteringWeighPt}); // Fill the NN input networkInput.row(NNindex) << pT, eta, phi, seeds[i].sp()[0]->x(), seeds[i].sp()[0]->y(), seeds[i].sp()[0]->z(), seeds[i].sp()[1]->x(), From 238d49ef34e4a1e26cdad60464d58938a80913cc Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Tue, 21 Nov 2023 16:06:05 +0100 Subject: [PATCH 13/31] plugin onnx --- .../Acts/Plugins/Onnx/AmbiguityTrackClassifier.hpp | 2 +- .../Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp | 9 +++++---- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/Plugins/Onnx/include/Acts/Plugins/Onnx/AmbiguityTrackClassifier.hpp b/Plugins/Onnx/include/Acts/Plugins/Onnx/AmbiguityTrackClassifier.hpp index 24cf17db84d..5508371a2e7 100644 --- a/Plugins/Onnx/include/Acts/Plugins/Onnx/AmbiguityTrackClassifier.hpp +++ b/Plugins/Onnx/include/Acts/Plugins/Onnx/AmbiguityTrackClassifier.hpp @@ -109,7 +109,7 @@ class AmbiguityTrackClassifier { /// @return a vector of trackID corresponding tho the good tracks template class holder_t> - std::vector solveAmbuguity( + std::vector solveAmbiguity( std::unordered_map>& clusters, const Acts::TrackContainer& tracks) const { diff --git a/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp b/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp index 03f6e5d699e..9b8ef71806e 100644 --- a/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp +++ b/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp @@ -46,8 +46,8 @@ class SeedClassifier { /// @return a vector of seedID corresponding tho the good seeds std::vector seedSelection( std::vector>& clusters, - std::vector>& outputTensor - float minSeedScore = 0.0) const { + std::vector>& outputTensor float minSeedScore = + 0.0) const { std::vector goodSeeds; int iOut = 0; // Loop over all the cluster and only keep the seed with the highest score @@ -62,7 +62,7 @@ class SeedClassifier { } iOut++; } - if(bestSeedScore >= minSeedScore){ + if (bestSeedScore >= minSeedScore) { goodSeeds.push_back(bestSeedID); } } @@ -79,7 +79,8 @@ class SeedClassifier { Acts::NetworkBatchInput& networkInput, float minSeedScore = 0.0) const { std::vector> outputTensor = inferScores(networkInput); - std::vector goodSeeds = seedSelection(clusters, outputTensor, minSeedScore); + std::vector goodSeeds = + seedSelection(clusters, outputTensor, minSeedScore); return goodSeeds; } From 9f1116abe599c8a8deca1b4c74f4ed3f38ebfcaa Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Tue, 21 Nov 2023 16:54:20 +0100 Subject: [PATCH 14/31] python files --- .../seed_filter_full_chain.py | 434 ++++++++++++++++++ .../seed_solver_network.py | 67 +++ .../train_seed_solver.py | 391 ++++++++++++++++ 3 files changed, 892 insertions(+) create mode 100644 Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py create mode 100644 Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py create mode 100644 Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py b/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py new file mode 100644 index 00000000000..6f4ba4476dd --- /dev/null +++ b/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py @@ -0,0 +1,434 @@ +import glob +import os +import math + +import pandas as pd +import numpy as np + +import torch.utils + +from sklearn.cluster import DBSCAN, KMeans + +from sklearn.preprocessing import LabelEncoder, OrdinalEncoder +from seed_solver_network import prepareDataSet, DuplicateClassifier, Normalise + + +def readDataSet(CKS_files: list[str]) -> pd.DataFrame: + """Read the dataset from the different files, remove the pure duplicate tracks and combine the datasets""" + """ + @param[in] CKS_files: DataFrame contain the data from each track files (1 file per events usually) + @return: combined DataFrame containing all the track, ordered by events and then by truth particle ID in each events + """ + data = [] + for f in CKS_files: + datafile = pd.read_csv(f) + datafile = prepareDataSet(datafile) + data.append(datafile) + return data + + +def prepareInferenceData(data: pd.DataFrame) -> tuple[np.ndarray, np.ndarray]: + """Prepare the data""" + """ + @param[in] data: input DataFrame to be prepared + @return: array of the network input and the corresponding truth + """ + # Remove truth and useless variable + target_column = "good/duplicate/fake" + # Separate the truth from the input variables + + y = LabelEncoder().fit(data[target_column]).transform(data[target_column]) + input = data.drop( + columns=[ + target_column, + "seed_id", + "Hits_ID", + "cluster", + ] + ) + # Prepare the input feature + x_cat = OrdinalEncoder().fit_transform(input.select_dtypes("object")) + x = np.concatenate((x_cat, input), axis=1) + return x, y + + +def clusterSeed( + event: pd.DataFrame, DBSCAN_eps: float = 0.1, DBSCAN_min_samples: int = 2 +) -> pd.DataFrame: + """ + Cluster together all the track that appear to belong to the same truth particle + To cluster the tracks together, a DBSCAN is first used followed by a sub clustering based on hits shared by tracks. + """ + """ + @param[in] event: input DataFrame that contain all track in one event + @param[in] DBSCAN_eps: minimum radius used by the DBSCAN to cluster track together + @param[in] DBSCAN_min_samples: minimum number of tracks needed for DBSCAN to create a cluster + @return: DataFrame identical to the output with an added column with the cluster + """ + # Perform the DBSCAN clustering and sort the Db by cluster ID + trackDir = event[["eta", "phi", "vertexZ", "pT"]].to_numpy() + trackDir[:, 2] = trackDir[:, 2] / 50 + # Perform the subclustering + clustering = DBSCAN(eps=DBSCAN_eps, min_samples=DBSCAN_min_samples).fit(trackDir) + clusterarray = renameCluster(clustering.labels_) + event["cluster"] = clusterarray + sorted = event.sort_values(["cluster"], ascending=True) + return sorted + + +def renameCluster(clusterarray: np.ndarray) -> np.ndarray: + """Rename the cluster IDs to be int starting from 0""" + """ + @param[in] clusterarray: numpy array containing the hits IDs and the cluster ID + @return: numpy array with updated cluster IDs + """ + last_id = -1 + new_id = -1 + for i, cluster in enumerate(clusterarray): + if cluster != last_id or cluster == -1: + last_id = cluster + new_id = new_id + 1 + clusterarray[i] = new_id + return clusterarray + + +# ================================================================== + +import time + +start = time.time() + +# ttbar events as test input +CKF_files = sorted(glob.glob("odd_output" + "/event0000000[0-1][0-9]-seed_matched.csv")) +data = readDataSet(CKF_files) + +# Data of each events after clustering +clusteredData = [] +# data of each events after ambiguity resolution +cleanedData = [] + +t1 = time.time() + +# Cluster togather tracks belonging to the same particle +for event in data: + clustered = clusterSeed(event) + clusteredData.append(clustered) + +t2 = time.time() + +duplicateClassifier = torch.load("seedduplicateClassifier.pt") + +import matplotlib.pyplot as plt + +# Make a copy of the data to be plotted +plotData = [] +plotDF = pd.DataFrame() +for event in clusteredData: + plotData.append(event.copy()) + plotDF = pd.concat([plotDF, event.copy()]) + +# Plot the distribution of the 4 variable +plotDF["eta"].hist(bins=100) +plt.xlabel("eta") +plt.ylabel("nb seed") +plt.savefig("eta.png") +plt.clf() + +plotDF["phi"].hist(bins=100) +plt.xlabel("phi") +plt.ylabel("nb seed") +plt.savefig("phi.png") +plt.clf() + +plotDF["vertexZ"].hist(bins=100) +plt.xlabel("vertexZ") +plt.ylabel("nb seed") +plt.savefig("vertexZ.png") +plt.clf() + +plotDF["pT"].hist(bins=100, range=[0, 10]) +plt.xlabel("pT") +plt.ylabel("nb seed") +plt.savefig("pT.png") +plt.clf() + +plotDF2 = pd.DataFrame() +# Create histogram filled with the number of seed per cluster +for event in plotData: + event["nb_seed"] = 0 + event["nb_fake"] = 0 + event["nb_duplicate"] = 0 + event["nb_good"] = 0 + event["nb_cluster"] = 0 + event["nb_truth"] = 0 + event["nb_seed_truth"] = 0 + event["nb_seed_removed"] = 0 + event["particleId"] = event.index + event["nb_seed"] = event.groupby(["cluster"])["cluster"].transform("size") + event["nb_seed"] = event.groupby(["cluster"])["cluster"].transform("size") + # Create histogram filled with the number of fake seed per cluster + event.loc[event["good/duplicate/fake"] == "fake", "nb_fake"] = ( + event.loc[event["good/duplicate/fake"] == "fake"] + .groupby(["cluster"])["cluster"] + .transform("size") + ) + # Create histogram filled with the number of duplicate seed per cluster + event.loc[event["good/duplicate/fake"] == "duplicate", "nb_duplicate"] = ( + event.loc[event["good/duplicate/fake"] == "duplicate"] + .groupby(["cluster"])["cluster"] + .transform("size") + ) + # Create histogram filled with the number of good seed per cluster + event.loc[event["good/duplicate/fake"] == "good", "nb_good"] = ( + event.loc[event["good/duplicate/fake"] == "good"] + .groupby(["cluster"])["cluster"] + .transform("size") + ) + + plotDF2 = pd.concat([plotDF2, event]) + +plotDF2["nb_seed"].hist(bins=20, weights=1 / plotDF2["nb_seed"], range=[0, 20]) +plt.xlabel("nb seed/[cluster]") +plt.ylabel("Arbitrary unit") +plt.savefig("nb_seed.png") +plt.clf() + +plotDF2["nb_fake"].hist(bins=10, weights=1 / plotDF2["nb_seed"], range=[0, 10]) +plt.xlabel("nb fake/[cluster]") +plt.ylabel("Arbitrary unit") +plt.savefig("nb_fake.png") +plt.clf() + +plotDF2["nb_duplicate"].hist(bins=10, weights=1 / plotDF2["nb_seed"], range=[0, 10]) +plt.xlabel("nb duplicate/[cluster]") +plt.ylabel("Arbitrary unit") +plt.savefig("nb_duplicate.png") +plt.clf() + +plotDF2["nb_good"].hist(bins=5, weights=1 / plotDF2["nb_seed"], range=[0, 5]) +plt.xlabel("nb good/[cluster]") +plt.ylabel("Arbitrary unit") +plt.savefig("nb_good.png") +plt.clf() + +t3 = time.time() + +# Performed the MLP based ambiguity resolution +for clusteredEvent in clusteredData: + # Prepare the data + x_test, y_test = prepareInferenceData(clusteredEvent) + x = torch.tensor(x_test, dtype=torch.float32) + output_predict = duplicateClassifier(x).detach().numpy() + + # Create an array of random value between 0 and 1 of the same size as the output + # output_predict = np.random.rand(len(x_test)) + + clusteredEvent["score"] = output_predict + # Keep only the track in cluster of more than 1 track or with a score above 0.5 + idx = (clusteredEvent["score"] > 0.0) | ( + clusteredEvent.groupby(["cluster"])["cluster"].transform("size") > 3 + ) + cleanedEvent = clusteredEvent[idx] + + # For each cluster only keep the track with the highest score + idx = ( + cleanedEvent.groupby(["cluster"])["score"].transform(max) + == cleanedEvent["score"] + ) + cleanedEvent = cleanedEvent[idx] + cleanedData.append(cleanedEvent) + +t4 = time.time() + +# Compute the algorithm performances +nb_part = 0 +nb_track = 0 +nb_fake = 0 +nb_duplicate = 0 + +nb_good_match = 0 +nb_reco_part = 0 +nb_reco_fake = 0 +nb_reco_duplicate = 0 +nb_reco_track = 0 + +for clusteredEvent, cleanedEvent in zip(clusteredData, cleanedData): + nb_part += clusteredEvent.loc[ + clusteredEvent["good/duplicate/fake"] != "fake" + ].index.nunique() + nb_track += clusteredEvent.shape[0] + nb_fake += clusteredEvent.loc[ + clusteredEvent["good/duplicate/fake"] == "fake" + ].shape[0] + nb_duplicate += clusteredEvent.loc[ + clusteredEvent["good/duplicate/fake"] == "duplicate" + ].shape[0] + + nb_good_match += cleanedEvent.loc[ + cleanedEvent["good/duplicate/fake"] == "good" + ].shape[0] + nb_reco_fake += cleanedEvent.loc[ + cleanedEvent["good/duplicate/fake"] == "fake" + ].shape[0] + nb_reco_duplicate += cleanedEvent.loc[ + cleanedEvent["good/duplicate/fake"] == "duplicate" + ].shape[0] + nb_reco_part += cleanedEvent.loc[ + cleanedEvent["good/duplicate/fake"] != "fake" + ].index.nunique() + nb_reco_track += cleanedEvent.shape[0] + +tend = time.time() + +print("===Initial efficiencies===") +print("nb particles : ", nb_part) +print("nb track : ", nb_track) +print("duplicate rate: ", 100 * nb_duplicate / nb_track, " %") +print("Fake rate: ", 100 * nb_fake / nb_track, " %") + +print("===computed efficiencies===") +print("nb particles : ", nb_part) +print("nb good match : ", nb_good_match) +print("nb particle reco : ", nb_reco_part) +print("nb track reco : ", nb_reco_track) +print("Efficiency (good track) : ", 100 * nb_good_match / nb_part, " %") +print("Efficiency (particle reco) : ", 100 * nb_reco_part / nb_part, " %") +print( + "duplicate rate: ", + 100 * ((nb_good_match + nb_reco_duplicate) - nb_reco_part) / nb_reco_track, + " %", +) +print("Fake rate: ", 100 * nb_reco_fake / nb_reco_track, " %") + +print("===computed speed===") +print("Load : ", (t1 - start) * 1000 / len(CKF_files), "ms") +print("Clustering : ", (t2 - t1) * 1000 / len(CKF_files), "ms") +print("Inference : ", (t4 - t3) * 1000 / len(CKF_files), "ms") +print("Perf : ", (tend - t4) * 1000 / len(CKF_files), "ms") +print("tot : ", (t4 - start) * 1000 / len(CKF_files), "ms") +print("Seed filter : ", (t4 - t1) * 1000 / len(CKF_files), "ms") + + +# ================================================================== +# Plotting + +# Combine the events together to have a better statistics +clusteredDataPlots = pd.concat(clusteredData) + +cleanedDataPlots = pd.concat(cleanedData) +# cleanedDataPlots = cleanedData[0] + +import matplotlib.pyplot as plt + +# Plot the average score distribution for each type of track + +plt.figure() +weightsGood = np.ones_like( + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "good"]["score"] +) / len( + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "good"]["score"] +) +plt.hist( + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "good"]["score"], + bins=100, + weights=weightsGood, + alpha=0.65, + label="good", +) +weightsDuplicate = np.ones_like( + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "duplicate"]["score"] +) / len( + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "duplicate"]["score"] +) +plt.hist( + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "duplicate"]["score"], + bins=100, + weights=weightsDuplicate, + alpha=0.65, + label="duplicate", +) +weightsFake = np.ones_like( + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "fake"]["score"] +) / len( + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "fake"]["score"] +) +plt.hist( + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "fake"]["score"], + bins=100, + weights=weightsFake, + alpha=0.65, + label="fake", +) +plt.legend() +plt.xlabel("score") +plt.ylabel("Fraction of good/duplicate/fake tracks") +plt.title("Score distribution for each type of track") +plt.savefig("score_distribution.png") + +# Average value of the score for 50 eta bins +averageCleanedDataPlots = cleanedDataPlots.loc[ + cleanedDataPlots["good/duplicate/fake"] == "good" +].groupby( + pd.cut( + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "good"]["eta"], + np.linspace(-3, 3, 100), + ) +) +plt.figure() +plt.plot( + np.linspace(-3, 3, 99), + averageCleanedDataPlots["score"].mean(), + label="average score", +) +plt.legend() +plt.xlabel("eta") +plt.ylabel("score") +plt.title("Average score for each eta bin") +plt.savefig("score_eta.png") + +# Plot the pT distribution for each type of track +plt.figure() +plt.hist( + [ + clusteredDataPlots.loc[clusteredDataPlots["good/duplicate/fake"] == "good"][ + "pT" + ], + clusteredDataPlots.loc[ + clusteredDataPlots["good/duplicate/fake"] == "duplicate" + ]["pT"], + clusteredDataPlots.loc[clusteredDataPlots["good/duplicate/fake"] == "fake"][ + "pT" + ], + ], + bins=100, + range=(0, 100), + stacked=False, + label=["good", "duplicate", "fake"], +) +plt.legend() +plt.xlabel("pT") +plt.ylabel("number of tracks") +plt.yscale("log") +plt.title("pT distribution for each type of track") +plt.savefig("pT_distribution.png") + +# Average value of the score for 50 pt bins +averageCleanedDataPlots = cleanedDataPlots.loc[ + cleanedDataPlots["good/duplicate/fake"] == "good" +].groupby( + pd.cut( + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "good"]["pT"], + np.linspace(0, 100, 50), + ) +) +plt.figure() +plt.plot( + np.linspace(0, 100, 49), + averageCleanedDataPlots["score"].mean(), + label="average score", +) +plt.legend() +plt.xlabel("pT") +plt.ylabel("score") +plt.title("Average score for each eta bin") +plt.savefig("score_pt.png") diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py b/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py new file mode 100644 index 00000000000..c4c4ca7c6f0 --- /dev/null +++ b/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py @@ -0,0 +1,67 @@ +import pandas as pd +import numpy as np + +import torch.nn as nn +import torch.nn.functional as F +import torch.utils + +import ast + + +def prepareDataSet(data: pd.DataFrame) -> pd.DataFrame: + """Format the dataset that have been written from the Csv file""" + """ + @param[in] data: input DataFrame containing 1 event + @return: Formatted DataFrame + """ + data = data + data = data.sort_values("good/duplicate/fake", ascending=False) + # Sort by particle ID + data = data.sort_values("particleId") + # Set truth particle ID as index + data = data.set_index("particleId") + # Transform the hit list from a string to an actual list + hitsIds = [] + mergedIds = [] + for list in data["Hits_ID"].values: + hitsIds.append(ast.literal_eval(list)) + data["Hits_ID"] = hitsIds + # Combine dataset + return data + + +class DuplicateClassifier(nn.Module): + """MLP model used to separate goods seed from duplicate seeds. Return one score per seed the higher one correspond to the good seed.""" + + def __init__(self, input_dim, n_layers): + """Four layer MLP, sigmoid activation for the last layer.""" + super(DuplicateClassifier, self).__init__() + self.linear1 = nn.Linear(input_dim, n_layers[0]) + self.linear2 = nn.Linear(n_layers[0], n_layers[1]) + self.linear3 = nn.Linear(n_layers[1], n_layers[2]) + self.linear4 = nn.Linear(n_layers[2], n_layers[3]) + self.linear5 = nn.Linear(n_layers[3], n_layers[4]) + self.output = nn.Linear(n_layers[4], 1) + self.sigmoid = nn.Sigmoid() + + def forward(self, z): + z = F.relu(self.linear1(z)) + z = F.relu(self.linear2(z)) + z = F.relu(self.linear3(z)) + z = F.relu(self.linear4(z)) + z = F.relu(self.linear5(z)) + return self.sigmoid(self.output(z)) + + +class Normalise(nn.Module): + """Normalisation of the input before the MLP model.""" + + def __init__(self, mean, std): + super(Normalise, self).__init__() + self.mean = torch.tensor(mean, dtype=torch.float32) + self.std = torch.tensor(std, dtype=torch.float32) + + def forward(self, z): + z = z - self.mean + z = z / self.std + return z diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py b/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py new file mode 100644 index 00000000000..3f136b9f206 --- /dev/null +++ b/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py @@ -0,0 +1,391 @@ +import glob + +import pandas as pd +import numpy as np + +import torch.nn as nn +import torch.nn.functional as F +import torch.utils +from torch.utils.tensorboard import SummaryWriter + +from sklearn.preprocessing import LabelEncoder, StandardScaler, OrdinalEncoder + +from seed_solver_network import ( + prepareDataSet, + DuplicateClassifier, + Normalise, +) + +avg_mean = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +avg_sdv = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +events = 0 +device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + + +def readDataSet(Seed_files: list[str]) -> pd.DataFrame: + """Read the dataset from the different files, remove the particle with only fakes and combine the datasets""" + """ + @param[in] Seed_files: DataFrame contain the data from each seed files (1 file per events usually) + @return: combined DataFrame containing all the seed, ordered by events and then by truth particle ID in each events + """ + data = pd.DataFrame() + for f in Seed_files: + datafile = pd.read_csv(f) + datafile = prepareDataSet(datafile) + data = pd.concat([data, datafile]) + return data + + +def prepareTrainingData(data: pd.DataFrame) -> tuple[np.ndarray, np.ndarray]: + """Prepare the data""" + """ + @param[in] data: input DataFrame to be prepared + @return: array of the network input and the corresponding truth + """ + # Remove truth and useless variable + target_column = "good/duplicate/fake" + # Separate the truth from the input variables + y = LabelEncoder().fit(data[target_column]).transform(data[target_column]) + input = data.drop( + columns=[ + target_column, + "seed_id", + "Hits_ID", + ] + ) + # Compute the normalisation factors + scale = StandardScaler() + scale.fit(input.select_dtypes("number")) + # Variables to compute the normalisation + global avg_mean + avg_mean = avg_mean + scale.mean_ + global avg_sdv + avg_sdv = avg_sdv + scale.var_ + global events + events = events + 1 + # Prepare the input feature + x_cat = OrdinalEncoder().fit_transform(input.select_dtypes("object")) + x = np.concatenate((x_cat, input), axis=1) + return x, y + + +def batchSplit(data: pd.DataFrame, batch_size: int) -> list[pd.DataFrame]: + """Split the data into batch each containing @batch_size truth particles (the number of corresponding seeds may vary)""" + """ + @param[in] data: input DataFrame to be cut into batch + @param[in] batch_size: Number of truth particles per batch + @return: list of DataFrame, each element correspond to a batch + """ + batch = [] + pid = data[0][0] + n_particle = 0 + id_prev = 0 + id = 0 + for index, row, truth in zip(data[0], data[1], data[2]): + if index != pid: + pid = index + n_particle += 1 + if n_particle == batch_size: + b = data[0][id_prev:id], data[1][id_prev:id], data[2][id_prev:id] + batch.append(b) + n_particle = 0 + id_prev = id + id += 1 + return batch + + +def computeLoss( + score_good: torch.Tensor, + score_duplicate: list[torch.Tensor], + score_fake: list[torch.Tensor], + batch_loss: torch.Tensor, + margin_duplicate: float = 0.3, + margin_fake: float = 0.9, +) -> torch.Tensor: + """Compute one loss for each duplicate seed associated with the particle""" + """ + @param[in] score_good: score return by the model for the good seed associated with this particle + @param[in] score_duplicate: list of the scores of all duplicate seed associated with this particle + @param[in] margin_duplicate: Margin used in the computation of the MarginRankingLoss for duplicate seeds + @param[in] margin_fake: Margin used in the computation of the MarginRankingLoss for fake seeds + @return: return the updated loss + """ + # Compute the losses using the MarginRankingLoss with respect to the good seed score + batch_loss = batch_loss + if score_duplicate: + for s in score_duplicate: + batch_loss += F.relu(s - score_good + margin_duplicate) / ( + len(score_duplicate) + len(score_fake) + 1 + ) + if score_fake: + for s in score_fake: + batch_loss += F.relu(s - score_good + margin_fake) / ( + len(score_duplicate) + len(score_fake) + 1 + ) + batch_loss += margin_fake / (len(score_duplicate) + len(score_fake) + 1) + + return batch_loss + + +def scoringBatch(batch: list[pd.DataFrame], Optimiser=0) -> tuple[int, int, float]: + """Run the MLP on a batch and compute the corresponding efficiency and loss. If an optimiser is specify train the MLP.""" + """ + @param[in] batch: list of DataFrame, each element correspond to a batch + @param[in] Optimiser: Optimiser for the MLP, if one is specify the network will be train on batch. + @return: array containing the number of particles, the number of particle where the good seed was found and the loss + """ + # number of particles + nb_part = 0 + # number of particles associated with a good seed + nb_good_match = 0 + # number of particles associated with a best seed + nb_best_match = 0 + # loss for the batch + loss = 0 + # best seed score for a particle + max_score = 0 + # is the best score associated with the good seed + max_match = 1 + # loop over all the batch + for b_data in batch: + # ID of the current particle + pid = b_data[0][0] + # loss for the current batch + batch_loss = 0 + # score of the good seed + score_good = 1 + # score of the duplicate seeds + score_duplicate = [] + # score of the fake seeds + score_fake = [] + + if Optimiser: + Optimiser.zero_grad() + input = torch.tensor(b_data[1], dtype=torch.float32) + input = input.to(device) + prediction = duplicateClassifier(input) + # loop over all the seed in the batch + for index, pred, truth in zip(b_data[0], prediction, b_data[2]): + # If we are changing particle update the loss + if index != pid: + # Starting a new particles, compute the loss for the previous one + if max_match == 0 or max_match == 2: + nb_good_match += 1 + if max_match == 2: + nb_best_match += 1 + batch_loss = computeLoss( + score_good, + score_duplicate, + score_fake, + batch_loss, + margin_duplicate=0.2, + margin_fake=0.4, + ) + nb_part += 1 + # Reinitialise the variable for the next particle + pid = index + score_duplicate = [] + score_fake = [] + score_good = 1 + max_score = 0 + max_match = 1 + # Store seed scores + if truth == 2: + score_good = pred + elif truth == 0: + score_duplicate.append(pred) + else: + score_fake.append(pred) + # Prepare efficiency computtion + if pred > max_score: + max_score = pred + max_match = truth + # Compute the loss for the last particle when reaching the end of the batch + if max_match == 0 or max_match == 2: + nb_good_match += 1 + if max_score == 2: + nb_best_match += 1 + batch_loss = computeLoss( + score_good, + score_duplicate, + score_fake, + batch_loss, + margin_duplicate=0.2, + margin_fake=0.4, + ) + nb_part += 1 + # Normalise the loss to the batch size + batch_loss = batch_loss / len(b_data[0]) + loss += batch_loss + # Perform the gradient descent if an optimiser was specified + if Optimiser: + batch_loss.backward() + Optimiser.step() + loss = loss / len(batch) + return nb_part, nb_good_match, nb_best_match, loss + + +def train( + duplicateClassifier: DuplicateClassifier, + data: tuple[np.ndarray, np.ndarray, np.ndarray], + epochs: int = 20, + batch: int = 32, + validation: float = 0.3, +) -> DuplicateClassifier: + """Training of the MLP""" + """ + @param[in] duplicateClassifier: model to be trained. + @param[in] data: tuple containing three list. Each element of those list correspond to a given seed and represent : the truth particle ID, the seed parameters and the truth. + @param[in] epochs: number of epoch the model will be trained for. + @param[in] batch: size of the batch used in the training + @param[in] validation: Fraction of the batch used in training + @return: trained model + """ + # Prepare tensorboard for the training plot + # use 'tensorboard --logdir=runs' to access the plot afterward + writer = SummaryWriter() + opt = torch.optim.Adam(duplicateClassifier.parameters()) + # Split the data in batch + batch = batchSplit(data, batch) + val_batch = int(len(batch) * (1 - validation)) + # Loop over all the epoch + for epoch in range(epochs): + print("Epoch : ", epoch, " / ", epochs) + loss = 0.0 + nb_part = 0.0 + nb_good_match = 0.0 + + # Loop over all the network over the training batch + nb_part, nb_good_match, nb_best_match, loss = scoringBatch( + batch[:val_batch], Optimiser=opt + ) + print( + "Loss/train : ", + loss, + " Eff/train : ", + nb_good_match / nb_part, + " Eff_best/train : ", + nb_best_match / nb_part, + ) + writer.add_scalar("Loss/train", loss, epoch) + writer.add_scalar("Eff/train", nb_good_match / nb_part, epoch) + writer.add_scalar("Eff_best/train", nb_best_match / nb_part, epoch) + + # If using validation, compute the efficiency and loss over the training batch + if validation > 0.0: + nb_part, nb_good_match, nb_best_match, loss = scoringBatch( + batch[val_batch:] + ) + writer.add_scalar("Loss/val", loss, epoch) + writer.add_scalar("Eff/val", nb_good_match / nb_part, epoch) + writer.add_scalar("Eff_best/train", nb_best_match / nb_part, epoch) + print( + "Loss/val : ", + loss, + " Eff/val : ", + nb_good_match / nb_part, + " Eff_best/val : ", + nb_best_match / nb_part, + ) + + writer.close() + return duplicateClassifier + + +# ================================================================== + +# ttbar events used as the training input, here we assume 160 events are availables +CKF_files = sorted(glob.glob("odd_output" + "/event000000[0-9][0-9][0-9]-seed_cleaned.csv")) +data = readDataSet(CKF_files) +# Prepare the data +x_train, y_train = prepareTrainingData(data) + +avg_mean = [x / events for x in avg_mean] +avg_sdv = [x / events for x in avg_sdv] + +# Create our model and chose the layers sizes +input_dim = np.shape(x_train)[1] +layers_dim = [80, 100, 80] + +duplicateClassifier = nn.Sequential( + Normalise(avg_mean, avg_sdv), DuplicateClassifier(input_dim, layers_dim) +) +duplicateClassifier = duplicateClassifier.to(device) + +# Train the model and save it +input = data.index, x_train, y_train +train(duplicateClassifier, input, epochs=30, batch=128, validation=0.3) +duplicateClassifier.eval() +input_test = torch.tensor(x_train, dtype=torch.float32) +torch.save(duplicateClassifier, "seedduplicateClassifier.pt") +torch.onnx.export( + duplicateClassifier, + input_test, + "seedduplicateClassifier.onnx", + input_names=["x"], + output_names=["y"], + dynamic_axes={"x": {0: "batch_size"}, "y": {0: "batch_size"}}, +) + +del CKF_files +del data +del x_train, y_train +del input, input_test +del duplicateClassifier +# ================================================================== + +# ttbar events for the test, here we assume 40 events are availables +CKF_files_test = sorted(glob.glob("odd_output" + "/event000001[0-0][0-9][0-9]-seed_cleaned.csv")) + +test = readDataSet(CKF_files_test) + +# Prepare the data +x_test, y_test = prepareTrainingData(test) + +# Write the network score to a list +output_predict = [] + +model = torch.load("seedduplicateClassifier.pt") + +x_test = torch.tensor(x_test, dtype=torch.float32) +x_test = x_test.to(device) +for x in x_test: + output_predict.append(model(x)) + +# For the first 100 particles print the ID, score and truth +for sample_test, sample_predict, sample_true in zip( + test.index[0:100], output_predict[0:100], y_test[0:100] +): + print(sample_test, sample_predict, sample_true) + +id = 0 +pid = test.index[0] +nb_part = 0 +nb_good_match = 0 +nb_best_match = 0 +max_match = 1 +max_score = 0 + +# Compute the efficiency +for index, pred, truth in zip(test.index, output_predict, y_test): + if index != pid: + if max_match == 0 or max_match == 2: + nb_good_match += 1 + if max_match == 2: + nb_best_match += 1 + +nb_part += 1 +if max_match == 0 or max_match == 2: + nb_good_match += 1 +if max_score == 2: + nb_best_match += 1 + +# Check if the good/best match was in the first n seeds +good_match_bucket = 0 +best_match_bucket = 0 + +print("nb particles : ", nb_part) +print("nb good match : ", nb_good_match) +print("nb best match : ", nb_best_match) +print("Efficiency: ", 100 * nb_good_match / nb_part, " %") +print("Efficiency_best: ", 100 * nb_best_match / nb_part, " %") From 9d6979bb3f4c6e847638d3088df1cace9354152f Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Tue, 21 Nov 2023 16:57:32 +0100 Subject: [PATCH 15/31] python bindings --- .../python/acts/examples/reconstruction.py | 86 +++++++++++++++++++ Examples/Python/src/OnnxMlpack.cpp | 7 ++ .../ambiguity_solver_full_chain.py | 1 - .../ambiguity_solver_perf.py | 62 ++++++++++++- .../train_ambiguity_solver.py | 4 + Examples/Scripts/Python/full_chain_odd.py | 17 ++++ 6 files changed, 173 insertions(+), 4 deletions(-) diff --git a/Examples/Python/python/acts/examples/reconstruction.py b/Examples/Python/python/acts/examples/reconstruction.py index cfc8de476ff..7ae360bae31 100644 --- a/Examples/Python/python/acts/examples/reconstruction.py +++ b/Examples/Python/python/acts/examples/reconstruction.py @@ -144,6 +144,12 @@ defaults=[None] * 3, ) +SeedFilterMLDBScanConfig = namedtuple( + "SeedFilterMLDBScanConfig", + ["epsilonDBScan", "minPointsDBScan", "minSeedScore"], + defaults=[None] * 3, +) + class VertexFinder(Enum): Truth = (1,) @@ -913,6 +919,86 @@ def addSeedPerformanceWriters( ) +acts.examples.NamedTypeArgs( + config=SeedFilterMLDBScanConfig, +) + + +def addSeedFilterML( + s, + config: SeedFilterMLDBScanConfig = SeedFilterMLDBScanConfig(), + onnxModelFile: Optional[Union[Path, str]] = None, + logLevel: Optional[acts.logging.Level] = None, + outputDirRoot: Optional[Union[Path, str]] = None, + outputDirCsv: Optional[Union[Path, str]] = None, +) -> None: + customLogLevel = acts.examples.defaultLogging(s, logLevel)() + from acts.examples.onnx.mlpack import SeedFilterMLAlgorithm + + inputParticles = "particles" + selectedParticles = "truth_seeds_selected" + seeds = "seeds" + estParams = "estimatedparameters" + + filterML = SeedFilterMLAlgorithm( + level=customLogLevel, + inputTrackParameters="estimatedparameters", + inputSimSeeds="seeds", + inputSeedFilterNN=onnxModelFile, + outputTrackParameters="filtered-parameters", + outputSimSeeds="filtered-seeds", + **acts.examples.defaultKWArgs( + epsilonDBScan=config.epsilonDBScan, + minPointsDBScan=config.minPointsDBScan, + minSeedScore=config.minSeedScore, + ), + ) + s.addAlgorithm(filterML) + s.addWhiteboardAlias(seeds, "filtered-seeds") + s.addWhiteboardAlias("estimatedparameters", "filtered-parameters") + + prototracks = "seed-prototracks-ML" + s.addAlgorithm( + acts.examples.SeedsToPrototracks( + level=customLogLevel, + inputSeeds=seeds, + outputProtoTracks=prototracks, + ) + ) + + if outputDirRoot is not None: + addSeedPerformanceWriters( + s, + outputDirRoot, + seeds, + prototracks, + selectedParticles, + inputParticles, + estParams, + customLogLevel, + ) + + if outputDirCsv is not None: + outputDirCsv = Path(outputDirCsv) + + if not outputDirCsv.exists(): + outputDirCsv.mkdir() + + CsvSeedWriter = acts.examples.CsvSeedWriter( + level=customLogLevel, + inputTrackParameters=estParams, + inputSimSeeds=seeds, + inputSimHits="simhits", + inputMeasurementParticlesMap="measurement_particles_map", + inputMeasurementSimHitsMap="measurement_simhits_map", + outputDir=str(outputDirCsv), + fileName=str(f"seed.csv"), + ) + s.addWriter(CsvSeedWriter) + + return s + + def addKalmanTracks( s: acts.examples.Sequencer, trackingGeometry: acts.TrackingGeometry, diff --git a/Examples/Python/src/OnnxMlpack.cpp b/Examples/Python/src/OnnxMlpack.cpp index f27555b4c7f..2c2da4cfb7b 100644 --- a/Examples/Python/src/OnnxMlpack.cpp +++ b/Examples/Python/src/OnnxMlpack.cpp @@ -8,6 +8,7 @@ #include "Acts/Plugins/Python/Utilities.hpp" #include "ActsExamples/TrackFindingML/AmbiguityResolutionMLDBScanAlgorithm.hpp" +#include "ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp" #include #include @@ -27,5 +28,11 @@ void addOnnxMlpack(Context& ctx) { ActsExamples::AmbiguityResolutionMLDBScanAlgorithm, mlpack, "AmbiguityResolutionMLDBScanAlgorithm", inputTracks, inputDuplicateNN, outputTracks, nMeasurementsMin, epsilonDBScan, minPointsDBScan); + + ACTS_PYTHON_DECLARE_ALGORITHM(ActsExamples::SeedFilterMLAlgorithm, mlpack, + "SeedFilterMLAlgorithm", inputTrackParameters, + inputSimSeeds, inputSeedFilterNN, + outputTrackParameters, outputSimSeeds, + epsilonDBScan, minPointsDBScan, minSeedScore); } } // namespace Acts::Python diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_full_chain.py b/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_full_chain.py index e748efa686c..290d38e6bf8 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_full_chain.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_full_chain.py @@ -19,7 +19,6 @@ def readDataSet(CKS_files: list[str]) -> pd.DataFrame: @param[in] CKS_files: DataFrame contain the data from each track files (1 file per events usually) @return: combined DataFrame containing all the track, ordered by events and then by truth particle ID in each event """ - globalindex = 0 data = [] for f in CKS_files: datafile = pd.read_csv(f) diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_perf.py b/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_perf.py index fc2545d88ce..10d254cd432 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_perf.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_perf.py @@ -14,7 +14,6 @@ def readDataSet(CKS_files: list[str]) -> pd.DataFrame: @param[in] CKS_files: DataFrame contain the data from each track files (1 file per events usually) @return: combined DataFrame containing all the track, ordered by events and then by truth particle ID in each event """ - globalindex = 0 data = [] for f in CKS_files: datafile = pd.read_csv(f) @@ -31,11 +30,16 @@ def readDataSet(CKS_files: list[str]) -> pd.DataFrame: glob.glob("odd_output" + "/event0000000[0-9][0-9]-tracks_ckf.csv") ) CKF_files_resolved = sorted( - glob.glob("odd_output" + "/event0000000[0-9][0-9]-tracks_ambiML.csv") + glob.glob("odd_output" + "/event0000000[0-9][0-9]-tracks_ambi.csv") +) +ML_files_resolved = sorted( + glob.glob("odd_output_seedML" + "/event0000000[0-9][0-9]-tracks_ambi.csv") ) data_track = readDataSet(CKF_files_track) +data_ML_track = readDataSet(CKF_files_track) data_resolved = readDataSet(CKF_files_resolved) +data_ML_resolved = readDataSet(ML_files_resolved) # Compute the algorithm performances nb_part = 0 @@ -49,6 +53,12 @@ def readDataSet(CKS_files: list[str]) -> pd.DataFrame: nb_reco_duplicate = 0 nb_reco_track = 0 +nb_good_match_ML = 0 +nb_reco_part_ML = 0 +nb_reco_fake_ML = 0 +nb_reco_duplicate_ML = 0 +nb_reco_track_ML = 0 + # Compute the different efficiencies for trackEvent, resolvedEvent in zip(data_track, data_resolved): nb_part += trackEvent.loc[trackEvent["good/duplicate/fake"] == "good"].shape[0] @@ -91,13 +101,49 @@ def readDataSet(CKS_files: list[str]) -> pd.DataFrame: ].index.nunique() nb_reco_track += resolvedEvent.shape[0] +# Compute the different efficiencies +for trackEvent, resolvedEvent in zip(data_ML_track, data_ML_resolved): + # Merge two dataFrames and add indicator column + merged_ML = pd.merge( + trackEvent.loc[trackEvent["good/duplicate/fake"] == "good"], + resolvedEvent, + on=[ + "particleId", + "nStates", + "nMeasurements", + "nOutliers", + "nHoles", + "ndf", + "chi2/ndf", + "good/duplicate/fake", + ], + how="left", + indicator="exists", + ) + + # Add column to show if each row in first DataFrame exists in second + merged_ML["exists"] = np.where(merged_ML.exists == "both", True, False) + merged_ML.to_csv(path_or_buf="merged_ML.csv") + + nb_good_match_ML += merged_ML.loc[merged_ML["exists"] == True].shape[0] + nb_reco_fake_ML += resolvedEvent.loc[ + resolvedEvent["good/duplicate/fake"] == "fake" + ].shape[0] + nb_reco_duplicate_ML += resolvedEvent.loc[ + resolvedEvent["good/duplicate/fake"] == "duplicate" + ].shape[0] + nb_reco_part_ML += resolvedEvent.loc[ + resolvedEvent["good/duplicate/fake"] != "fake" + ].index.nunique() + nb_reco_track_ML += resolvedEvent.shape[0] + print("===Initial efficiencies===") print("nb particles : ", nb_part) print("nb track : ", nb_track) print("duplicate rate: ", 100 * nb_duplicate / nb_track, " %") print("Fake rate: ", 100 * nb_fake / nb_track, " %") -print("===computed efficiencies===") +print("===computed efficiencies Greedy===") print("nb particles : ", nb_part) print("nb good match : ", nb_good_match) print("nb particle reco : ", nb_reco_part) @@ -106,3 +152,13 @@ def readDataSet(CKS_files: list[str]) -> pd.DataFrame: print("Efficiency (particle reco) : ", 100 * nb_reco_part / nb_part, " %") print("duplicate rate: ", 100 * nb_reco_duplicate / nb_reco_track, " %") print("Fake rate: ", 100 * nb_reco_fake / nb_reco_track, " %") + +print("===computed efficiencies ML===") +print("nb particles : ", nb_part) +print("nb good match : ", nb_good_match_ML) +print("nb particle reco : ", nb_reco_part_ML) +print("nb track reco : ", nb_reco_track_ML) +print("Efficiency (good track) : ", 100 * nb_good_match_ML / nb_part, " %") +print("Efficiency (particle reco) : ", 100 * nb_reco_part_ML / nb_part, " %") +print("duplicate rate: ", 100 * nb_reco_duplicate_ML / nb_reco_track_ML, " %") +print("Fake rate: ", 100 * nb_reco_fake_ML / nb_reco_track_ML, " %") diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py b/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py index a94ea7cbbbb..f33d3e29fb2 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py @@ -15,6 +15,7 @@ avg_mean = [0, 0, 0, 0, 0, 0, 0, 0] avg_sdv = [0, 0, 0, 0, 0, 0, 0, 0] events = 0 +device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") def readDataSet(CKS_files: list[str]) -> pd.DataFrame: @@ -151,6 +152,7 @@ def scoringBatch(batch: list[pd.DataFrame], Optimiser=0) -> tuple[int, int, floa if Optimiser: Optimiser.zero_grad() input = torch.tensor(b_data[1], dtype=torch.float32) + input = input.to(device) prediction = duplicateClassifier(input) # loop over all the track in the batch for index, pred, truth in zip(b_data[0], prediction, b_data[2]): @@ -262,6 +264,7 @@ def train( duplicateClassifier = nn.Sequential( Normalise(avg_mean, avg_sdv), DuplicateClassifier(input_dim, layers_dim) ) +duplicateClassifier = duplicateClassifier.to(device) # Train the model and save it input = data.index, x_train, y_train @@ -292,6 +295,7 @@ def train( output_predict = [] x_test = torch.tensor(x_test, dtype=torch.float32) +x_test = x_test.to(device) for x in x_test: output_predict.append(duplicateClassifier(x)) diff --git a/Examples/Scripts/Python/full_chain_odd.py b/Examples/Scripts/Python/full_chain_odd.py index 26c951249eb..38dbfd55351 100755 --- a/Examples/Scripts/Python/full_chain_odd.py +++ b/Examples/Scripts/Python/full_chain_odd.py @@ -23,6 +23,8 @@ AmbiguityResolutionMLConfig, addVertexFitting, VertexFinder, + addSeedFilterML, + SeedFilterMLDBScanConfig, ) from common import getOpenDataDetectorDirectory from acts.examples.odd import getOpenDataDetector @@ -43,12 +45,18 @@ help="Use the Ml Ambiguity Solver instead of the classical one", action="store_true", ) +parser.add_argument( + "--MLSeedFilter", + help="Use the Ml seed filter to select seed after the seeding step", + action="store_true", +) args = vars(parser.parse_args()) ttbar = args["ttbar"] g4_simulation = args["geant4"] ambiguity_MLSolver = args["MLSolver"] +seedFilter_ML = args["MLSeedFilter"] u = acts.UnitConstants geoDir = getOpenDataDetectorDirectory() outputDir = pathlib.Path.cwd() / "odd_output" @@ -163,6 +171,15 @@ geoSelectionConfigFile=oddSeedingSel, outputDirRoot=outputDir, ) +if seedFilter_ML: + addSeedFilterML( + s, + SeedFilterMLDBScanConfig(epsilonDBScan=0.1, minPointsDBScan=2), + onnxModelFile=os.path.dirname(__file__) + + "/MLAmbiguityResolution/seedDuplicateClassifier.onnx", + outputDirRoot=outputDir, + # outputDirCsv=outputDir, + ) addCKFTracks( s, From 8038cf084343f182935e95473489c7489a6c8cab Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Tue, 21 Nov 2023 17:17:58 +0100 Subject: [PATCH 16/31] format --- .../MLAmbiguityResolution/seed_filter_full_chain.py | 12 +++++++++--- .../MLAmbiguityResolution/seed_solver_network.py | 2 +- .../MLAmbiguityResolution/train_seed_solver.py | 10 +++++++--- 3 files changed, 17 insertions(+), 7 deletions(-) diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py b/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py index 6f4ba4476dd..cba6820369a 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py @@ -336,12 +336,18 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: label="good", ) weightsDuplicate = np.ones_like( - cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "duplicate"]["score"] + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "duplicate"][ + "score" + ] ) / len( - cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "duplicate"]["score"] + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "duplicate"][ + "score" + ] ) plt.hist( - cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "duplicate"]["score"], + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "duplicate"][ + "score" + ], bins=100, weights=weightsDuplicate, alpha=0.65, diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py b/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py index c4c4ca7c6f0..d4f39d7bc30 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py @@ -48,7 +48,7 @@ def forward(self, z): z = F.relu(self.linear1(z)) z = F.relu(self.linear2(z)) z = F.relu(self.linear3(z)) - z = F.relu(self.linear4(z)) + z = F.relu(self.linear4(z)) z = F.relu(self.linear5(z)) return self.sigmoid(self.output(z)) diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py b/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py index 3f136b9f206..bbdde2e0dec 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py @@ -123,7 +123,7 @@ def computeLoss( len(score_duplicate) + len(score_fake) + 1 ) batch_loss += margin_fake / (len(score_duplicate) + len(score_fake) + 1) - + return batch_loss @@ -295,7 +295,9 @@ def train( # ================================================================== # ttbar events used as the training input, here we assume 160 events are availables -CKF_files = sorted(glob.glob("odd_output" + "/event000000[0-9][0-9][0-9]-seed_cleaned.csv")) +CKF_files = sorted( + glob.glob("odd_output" + "/event000000[0-9][0-9][0-9]-seed_cleaned.csv") +) data = readDataSet(CKF_files) # Prepare the data x_train, y_train = prepareTrainingData(data) @@ -335,7 +337,9 @@ def train( # ================================================================== # ttbar events for the test, here we assume 40 events are availables -CKF_files_test = sorted(glob.glob("odd_output" + "/event000001[0-0][0-9][0-9]-seed_cleaned.csv")) +CKF_files_test = sorted( + glob.glob("odd_output" + "/event000001[0-0][0-9][0-9]-seed_cleaned.csv") +) test = readDataSet(CKF_files_test) From f992d89432ec027b4f2b447879411c98541e44e0 Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Wed, 22 Nov 2023 17:03:30 +0100 Subject: [PATCH 17/31] onnx file --- .../seedduplicateClassifier.onnx | Bin 0 -> 123798 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100755 Examples/Scripts/Python/MLAmbiguityResolution/seedduplicateClassifier.onnx diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/seedduplicateClassifier.onnx b/Examples/Scripts/Python/MLAmbiguityResolution/seedduplicateClassifier.onnx new file mode 100755 index 0000000000000000000000000000000000000000..b7b265618b58e6a16b27dc9cc5636b3ed033fcc0 GIT binary patch literal 123798 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 Date: Fri, 24 Nov 2023 15:48:57 +0100 Subject: [PATCH 18/31] bugfix --- .../TrackFindingML/SeedFilterMLAlgorithm.hpp | 2 +- Examples/Io/Csv/src/CsvSeedWriter.cpp | 2 +- .../ambiguity_solver_network.py | 4 ++-- .../ambiguity_solver_perf.py | 2 +- .../seed_filter_full_chain.py | 20 +++++++++------- .../train_ambiguity_solver.py | 1 - .../train_seed_solver.py | 24 +++++++++---------- Examples/Scripts/Python/full_chain_odd.py | 2 +- .../Acts/Plugins/Onnx/SeedClassifier.hpp | 4 ++-- 9 files changed, 30 insertions(+), 31 deletions(-) diff --git a/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp b/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp index 99160451ad1..6d95253ed2f 100644 --- a/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp +++ b/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp @@ -42,7 +42,7 @@ class SeedFilterMLAlgorithm : public IAlgorithm { /// Minimum number of tracks to create a cluster in the DBScan int minPointsDBScan = 2; /// Minimum score a seed need to be selected - int minSeedScore = 0.0; + int minSeedScore = 0.1; /// Clustering parameters weight for phi used before the DBSCAN double clusteringWeighPhi = 1.0; /// Clustering parameters weight for eta used before the DBSCAN diff --git a/Examples/Io/Csv/src/CsvSeedWriter.cpp b/Examples/Io/Csv/src/CsvSeedWriter.cpp index 1961f13fd07..12361d694b3 100644 --- a/Examples/Io/Csv/src/CsvSeedWriter.cpp +++ b/Examples/Io/Csv/src/CsvSeedWriter.cpp @@ -180,8 +180,8 @@ ActsExamples::ProcessCode ActsExamples::CsvSeedWriter::writeT( mos << info.seedId << ","; mos << info.particleId << ","; mos << info.seedPt << ","; - mos << info.seedPhi << ","; mos << info.seedEta << ","; + mos << info.seedPhi << ","; for (auto& point : info.globalPosition) { mos << point.x() << ","; mos << point.y() << ","; diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_network.py b/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_network.py index 5fbeb1d78eb..cb0a63e6e42 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_network.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_network.py @@ -17,7 +17,7 @@ def prepareDataSet(data: pd.DataFrame) -> pd.DataFrame: data = data # Remove tracks with less than 7 measurements data = data[data["nMeasurements"] > 6] - data = data.sort_values("good/duplicate/fake", ascending=False) + # data = data.sort_values("good/duplicate/fake", ascending=False) # Remove pure duplicate (tracks purely identical) keep the ones good one if among them. data = data.drop_duplicates( subset=[ @@ -30,7 +30,7 @@ def prepareDataSet(data: pd.DataFrame) -> pd.DataFrame: ], keep="first", ) - data = data.sort_values("particleId") + # data = data.sort_values("particleId") # Set truth particle ID as index data = data.set_index("particleId") # Transform the hit list from a string to an actual list diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_perf.py b/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_perf.py index 10d254cd432..574b9a55389 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_perf.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_perf.py @@ -33,7 +33,7 @@ def readDataSet(CKS_files: list[str]) -> pd.DataFrame: glob.glob("odd_output" + "/event0000000[0-9][0-9]-tracks_ambi.csv") ) ML_files_resolved = sorted( - glob.glob("odd_output_seedML" + "/event0000000[0-9][0-9]-tracks_ambi.csv") + glob.glob("odd_output" + "/event0000000[0-9][0-9]-tracks_ambiML.csv") ) data_track = readDataSet(CKF_files_track) diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py b/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py index cba6820369a..870bd8c28a7 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py @@ -82,13 +82,11 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: @param[in] clusterarray: numpy array containing the hits IDs and the cluster ID @return: numpy array with updated cluster IDs """ - last_id = -1 - new_id = -1 + new_id = len(set(clustering.labels_)) - (1 if -1 in clustering.labels_ else 0)) for i, cluster in enumerate(clusterarray): - if cluster != last_id or cluster == -1: - last_id = cluster + if cluster == -1: + clusterarray[i] = new_id new_id = new_id + 1 - clusterarray[i] = new_id return clusterarray @@ -225,17 +223,21 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: clusteredEvent["score"] = output_predict # Keep only the track in cluster of more than 1 track or with a score above 0.5 - idx = (clusteredEvent["score"] > 0.0) | ( - clusteredEvent.groupby(["cluster"])["cluster"].transform("size") > 3 - ) + idx = clusteredEvent["score"] > 0.1 cleanedEvent = clusteredEvent[idx] - # For each cluster only keep the track with the highest score + # For each cluster only keep the seed with the highest score idx = ( cleanedEvent.groupby(["cluster"])["score"].transform(max) == cleanedEvent["score"] ) cleanedEvent = cleanedEvent[idx] + # For cluster with more than 1 seed, keep the one with the smallest nb_seed + idx = ( + cleanedEvent.groupby(["cluster"])["nb_seed"].transform(min) + == cleanedEvent["nb_seed"] + ) + cleanedEvent = cleanedEvent[idx] cleanedData.append(cleanedEvent) t4 = time.time() diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py b/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py index f33d3e29fb2..44bab112f80 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py @@ -24,7 +24,6 @@ def readDataSet(CKS_files: list[str]) -> pd.DataFrame: @param[in] CKS_files: DataFrame contain the data from each track files (1 file per events usually) @return: combined DataFrame containing all the track, ordered by events and then by truth particle ID in each events """ - globalindex = 0 data = pd.DataFrame() for f in CKS_files: datafile = pd.read_csv(f) diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py b/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py index bbdde2e0dec..abdaa0da233 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py @@ -196,7 +196,7 @@ def scoringBatch(batch: list[pd.DataFrame], Optimiser=0) -> tuple[int, int, floa score_duplicate.append(pred) else: score_fake.append(pred) - # Prepare efficiency computtion + # Prepare efficiency computation if pred > max_score: max_score = pred max_match = truth @@ -294,7 +294,7 @@ def train( # ================================================================== -# ttbar events used as the training input, here we assume 160 events are availables +# ttbar events used as the training input, here we assume 1000 events are available CKF_files = sorted( glob.glob("odd_output" + "/event000000[0-9][0-9][0-9]-seed_cleaned.csv") ) @@ -307,7 +307,7 @@ def train( # Create our model and chose the layers sizes input_dim = np.shape(x_train)[1] -layers_dim = [80, 100, 80] +layers_dim = [80, 80, 100, 80, 80] duplicateClassifier = nn.Sequential( Normalise(avg_mean, avg_sdv), DuplicateClassifier(input_dim, layers_dim) @@ -322,7 +322,7 @@ def train( torch.save(duplicateClassifier, "seedduplicateClassifier.pt") torch.onnx.export( duplicateClassifier, - input_test, + input_test[0], "seedduplicateClassifier.onnx", input_names=["x"], output_names=["y"], @@ -373,20 +373,18 @@ def train( # Compute the efficiency for index, pred, truth in zip(test.index, output_predict, y_test): if index != pid: + nb_part += 1 if max_match == 0 or max_match == 2: nb_good_match += 1 if max_match == 2: nb_best_match += 1 + pid = index + max_match = 1 + max_score = 0 -nb_part += 1 -if max_match == 0 or max_match == 2: - nb_good_match += 1 -if max_score == 2: - nb_best_match += 1 - -# Check if the good/best match was in the first n seeds -good_match_bucket = 0 -best_match_bucket = 0 + if pred > max_score: + max_score = pred + max_match = truth print("nb particles : ", nb_part) print("nb good match : ", nb_good_match) diff --git a/Examples/Scripts/Python/full_chain_odd.py b/Examples/Scripts/Python/full_chain_odd.py index eee0d664d6b..1fc8e009c39 100755 --- a/Examples/Scripts/Python/full_chain_odd.py +++ b/Examples/Scripts/Python/full_chain_odd.py @@ -175,7 +175,7 @@ if seedFilter_ML: addSeedFilterML( s, - SeedFilterMLDBScanConfig(epsilonDBScan=0.1, minPointsDBScan=2), + SeedFilterMLDBScanConfig(epsilonDBScan=0.1, minPointsDBScan=2, minSeedScore=0.05), onnxModelFile=os.path.dirname(__file__) + "/MLAmbiguityResolution/seedDuplicateClassifier.onnx", outputDirRoot=outputDir, diff --git a/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp b/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp index 9b8ef71806e..c62275a364a 100644 --- a/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp +++ b/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp @@ -47,7 +47,7 @@ class SeedClassifier { std::vector seedSelection( std::vector>& clusters, std::vector>& outputTensor float minSeedScore = - 0.0) const { + 0.1) const { std::vector goodSeeds; int iOut = 0; // Loop over all the cluster and only keep the seed with the highest score @@ -77,7 +77,7 @@ class SeedClassifier { /// @return a vector of seedID corresponding the the good seeds std::vector solveAmbiguity(std::vector>& clusters, Acts::NetworkBatchInput& networkInput, - float minSeedScore = 0.0) const { + float minSeedScore = 0.1) const { std::vector> outputTensor = inferScores(networkInput); std::vector goodSeeds = seedSelection(clusters, outputTensor, minSeedScore); From 4670b5ce4d3f15ea864a78664335a6c825fe765b Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Tue, 5 Dec 2023 15:50:19 +0100 Subject: [PATCH 19/31] update initialised value --- .../TrackFindingML/SeedFilterMLAlgorithm.hpp | 4 ++-- .../src/SeedFilterMLAlgorithm.cpp | 4 ++-- .../seed_filter_full_chain.py | 7 +++++++ .../seedduplicateClassifier.onnx | Bin 123798 -> 123798 bytes Examples/Scripts/Python/full_chain_odd.py | 2 +- .../Mlpack/SeedFilterDBScanClustering.hpp | 2 +- .../Acts/Plugins/Onnx/SeedClassifier.hpp | 7 +++---- 7 files changed, 16 insertions(+), 10 deletions(-) diff --git a/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp b/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp index 6d95253ed2f..33fba3bfe3c 100644 --- a/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp +++ b/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp @@ -38,11 +38,11 @@ class SeedFilterMLAlgorithm : public IAlgorithm { /// Output seeds collection. std::string outputSimSeeds; /// Maximum distance between 2 tracks to be clustered in the DBScan - float epsilonDBScan = 0.1; + float epsilonDBScan = 0.05; /// Minimum number of tracks to create a cluster in the DBScan int minPointsDBScan = 2; /// Minimum score a seed need to be selected - int minSeedScore = 0.1; + float minSeedScore = 0.1; /// Clustering parameters weight for phi used before the DBSCAN double clusteringWeighPhi = 1.0; /// Clustering parameters weight for eta used before the DBSCAN diff --git a/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp b/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp index 5778c8bab1e..b5e56e199ad 100644 --- a/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp +++ b/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp @@ -82,8 +82,8 @@ ActsExamples::ProcessCode ActsExamples::SeedFilterMLAlgorithm::execute( clusteringParams, m_cfg.epsilonDBScan, m_cfg.minPointsDBScan); // Select the ID of the track we want to keep - std::vector goodSeed = - m_seedClassifier.solveAmbiguity(cluster, networkInput, minSeedScore); + std::vector goodSeed = m_seedClassifier.solveAmbiguity( + cluster, networkInput, m_cfg.minSeedScore); // Create the output seed collection SimSeedContainer outputSeeds; diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py b/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py index 870bd8c28a7..bfdb152c9fd 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py @@ -150,6 +150,13 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: plt.savefig("pT.png") plt.clf() +plotDF.plot.scatter(x="eta", y="pT") +plt.xlabel("eta") +plt.ylabel("pT") +plt.savefig("pT_eta.png") +plt.clf() + + plotDF2 = pd.DataFrame() # Create histogram filled with the number of seed per cluster for event in plotData: diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/seedduplicateClassifier.onnx b/Examples/Scripts/Python/MLAmbiguityResolution/seedduplicateClassifier.onnx index b7b265618b58e6a16b27dc9cc5636b3ed033fcc0..4df6b659fc0cb6c9edb24efa036a2d5f6b002701 100755 GIT binary patch literal 123798 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 literal 123798 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 dbscanSeedClustering( - const std::vector>& input, float epsilon = 0.1, + const std::vector>& input, float epsilon = 0.05, int minPoints = 2) { // DBSCAN algorithm from MLpack used in the seed clustering mlpack::DBSCAN dbscan(epsilon, minPoints); diff --git a/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp b/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp index c62275a364a..06153d3c86c 100644 --- a/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp +++ b/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp @@ -44,10 +44,9 @@ class SeedClassifier { /// @param outputTensor is the score vector obtained from inferScores. /// @param minSeedScore is the minimum score a seed need to be selected /// @return a vector of seedID corresponding tho the good seeds - std::vector seedSelection( - std::vector>& clusters, - std::vector>& outputTensor float minSeedScore = - 0.1) const { + std::vector seedSelection(std::vector>& clusters, + std::vector>& outputTensor, + float minSeedScore = 0.1) const { std::vector goodSeeds; int iOut = 0; // Loop over all the cluster and only keep the seed with the highest score From 2801ce277f536b66cda915eb7cf2a52e65d5345d Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Wed, 6 Dec 2023 16:44:39 +0100 Subject: [PATCH 20/31] working --- .../TrackFindingML/SeedFilterMLAlgorithm.hpp | 2 +- .../src/SeedFilterMLAlgorithm.cpp | 8 ++-- .../seed_filter_full_chain.py | 43 +++++++++++++++---- Examples/Scripts/Python/full_chain_odd.py | 4 +- .../Mlpack/SeedFilterDBScanClustering.hpp | 4 +- .../Acts/Plugins/Onnx/SeedClassifier.hpp | 6 +-- 6 files changed, 45 insertions(+), 22 deletions(-) diff --git a/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp b/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp index 33fba3bfe3c..122feb693c7 100644 --- a/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp +++ b/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/SeedFilterMLAlgorithm.hpp @@ -38,7 +38,7 @@ class SeedFilterMLAlgorithm : public IAlgorithm { /// Output seeds collection. std::string outputSimSeeds; /// Maximum distance between 2 tracks to be clustered in the DBScan - float epsilonDBScan = 0.05; + float epsilonDBScan = 0.03; /// Minimum number of tracks to create a cluster in the DBScan int minPointsDBScan = 2; /// Minimum score a seed need to be selected diff --git a/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp b/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp index b5e56e199ad..6ee217ebcba 100644 --- a/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp +++ b/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp @@ -51,13 +51,11 @@ ActsExamples::ProcessCode ActsExamples::SeedFilterMLAlgorithm::execute( Eigen::Array networkInput(seeds.size(), 14); std::vector> clusteringParams; - std::vector mapSeepIndex; // Loop over the seed and parameters to fill the input for the clustering // and the NN for (std::size_t i = 0; i < seeds.size(); i++) { // Keep track of the index of the seed in the original collection - std::size_t NNindex = mapSeepIndex.size() - 1; - mapSeepIndex.push_back(i); + std::size_t NNindex = i; // Compute the track parameters double pT = std::abs(1.0 / params[i].parameters()[Acts::eBoundQOverP]) * std::sin(params[i].parameters()[Acts::eBoundTheta]); @@ -94,8 +92,8 @@ ActsExamples::ProcessCode ActsExamples::SeedFilterMLAlgorithm::execute( outputTrackParameters.reserve(goodSeed.size()); for (auto&& i : goodSeed) { - outputSeeds.push_back(seeds[mapSeepIndex[i]]); - outputTrackParameters.push_back(params[mapSeepIndex[i]]); + outputSeeds.push_back(seeds[i]); + outputTrackParameters.push_back(params[i]); } m_outputSimSeeds(ctx, SimSeedContainer{outputSeeds}); diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py b/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py index bfdb152c9fd..622f973b00b 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py @@ -53,7 +53,7 @@ def prepareInferenceData(data: pd.DataFrame) -> tuple[np.ndarray, np.ndarray]: def clusterSeed( - event: pd.DataFrame, DBSCAN_eps: float = 0.1, DBSCAN_min_samples: int = 2 + event: pd.DataFrame, DBSCAN_eps: float = 0.03, DBSCAN_min_samples: int = 2 ) -> pd.DataFrame: """ Cluster together all the track that appear to belong to the same truth particle @@ -82,7 +82,7 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: @param[in] clusterarray: numpy array containing the hits IDs and the cluster ID @return: numpy array with updated cluster IDs """ - new_id = len(set(clustering.labels_)) - (1 if -1 in clustering.labels_ else 0)) + new_id = len(set(clusterarray)) - (1 if -1 in clusterarray else 0) for i, cluster in enumerate(clusterarray): if cluster == -1: clusterarray[i] = new_id @@ -170,7 +170,6 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: event["nb_seed_removed"] = 0 event["particleId"] = event.index event["nb_seed"] = event.groupby(["cluster"])["cluster"].transform("size") - event["nb_seed"] = event.groupby(["cluster"])["cluster"].transform("size") # Create histogram filled with the number of fake seed per cluster event.loc[event["good/duplicate/fake"] == "fake", "nb_fake"] = ( event.loc[event["good/duplicate/fake"] == "fake"] @@ -232,17 +231,16 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: # Keep only the track in cluster of more than 1 track or with a score above 0.5 idx = clusteredEvent["score"] > 0.1 cleanedEvent = clusteredEvent[idx] - # For each cluster only keep the seed with the highest score idx = ( cleanedEvent.groupby(["cluster"])["score"].transform(max) == cleanedEvent["score"] ) cleanedEvent = cleanedEvent[idx] - # For cluster with more than 1 seed, keep the one with the smallest nb_seed + # For cluster with more than 1 seed, keep the one with the smallest seed_id idx = ( - cleanedEvent.groupby(["cluster"])["nb_seed"].transform(min) - == cleanedEvent["nb_seed"] + cleanedEvent.groupby(["cluster"])["seed_id"].transform(min) + == cleanedEvent["seed_id"] ) cleanedEvent = cleanedEvent[idx] cleanedData.append(cleanedEvent) @@ -330,7 +328,6 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: import matplotlib.pyplot as plt # Plot the average score distribution for each type of track - plt.figure() weightsGood = np.ones_like( cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "good"]["score"] @@ -379,8 +376,10 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: plt.ylabel("Fraction of good/duplicate/fake tracks") plt.title("Score distribution for each type of track") plt.savefig("score_distribution.png") +plt.yscale("log") +plt.savefig("score_distribution_log.png") -# Average value of the score for 50 eta bins +# Average value of the score averageCleanedDataPlots = cleanedDataPlots.loc[ cleanedDataPlots["good/duplicate/fake"] == "good" ].groupby( @@ -427,6 +426,32 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: plt.title("pT distribution for each type of track") plt.savefig("pT_distribution.png") +# Plot the eta distribution for each type of track +plt.figure() +plt.hist( + [ + clusteredDataPlots.loc[clusteredDataPlots["good/duplicate/fake"] == "good"][ + "eta" + ], + clusteredDataPlots.loc[ + clusteredDataPlots["good/duplicate/fake"] == "duplicate" + ]["eta"], + clusteredDataPlots.loc[clusteredDataPlots["good/duplicate/fake"] == "fake"][ + "eta" + ], + ], + bins=100, + range=(-3, 3), + stacked=False, + label=["good", "duplicate", "fake"], +) +plt.legend() +plt.xlabel("eta") +plt.ylabel("number of tracks") +plt.yscale("log") +plt.title("eta distribution for each type of track") +plt.savefig("eta_distribution.png") + # Average value of the score for 50 pt bins averageCleanedDataPlots = cleanedDataPlots.loc[ cleanedDataPlots["good/duplicate/fake"] == "good" diff --git a/Examples/Scripts/Python/full_chain_odd.py b/Examples/Scripts/Python/full_chain_odd.py index 7d470fef5d5..35b74ef8fb0 100755 --- a/Examples/Scripts/Python/full_chain_odd.py +++ b/Examples/Scripts/Python/full_chain_odd.py @@ -175,7 +175,9 @@ if seedFilter_ML: addSeedFilterML( s, - SeedFilterMLDBScanConfig(epsilonDBScan=0.05, minPointsDBScan=2, minSeedScore=0.1), + SeedFilterMLDBScanConfig( + epsilonDBScan=0.03, minPointsDBScan=2, minSeedScore=0.1 + ), onnxModelFile=os.path.dirname(__file__) + "/MLAmbiguityResolution/seedDuplicateClassifier.onnx", outputDirRoot=outputDir, diff --git a/Plugins/Mlpack/include/Acts/Plugins/Mlpack/SeedFilterDBScanClustering.hpp b/Plugins/Mlpack/include/Acts/Plugins/Mlpack/SeedFilterDBScanClustering.hpp index f72a085f388..75ac6596e7c 100644 --- a/Plugins/Mlpack/include/Acts/Plugins/Mlpack/SeedFilterDBScanClustering.hpp +++ b/Plugins/Mlpack/include/Acts/Plugins/Mlpack/SeedFilterDBScanClustering.hpp @@ -24,7 +24,7 @@ namespace Acts { /// @param minPoints : Minimum number of tracks to create a cluster /// @return an unordered map representing the clusters, the keys the ID of the primary seed of each cluster and the stored value a vector of seed IDs. std::vector> dbscanSeedClustering( - const std::vector>& input, float epsilon = 0.05, + const std::vector>& input, float epsilon = 0.03, int minPoints = 2) { // DBSCAN algorithm from MLpack used in the seed clustering mlpack::DBSCAN dbscan(epsilon, minPoints); @@ -46,7 +46,7 @@ std::vector> dbscanSeedClustering( std::size_t clusterNb = dbscan.Cluster(data, assignments); // Prepare the output - std::vector> cluster(clusterNb); + std::vector> cluster(clusterNb, std::vector()); for (std::size_t iD = 0; iD < input.size(); iD++) { int clusterID = assignments(iD); if (assignments(iD) == SIZE_MAX) { diff --git a/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp b/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp index 06153d3c86c..23873286d22 100644 --- a/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp +++ b/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp @@ -48,18 +48,16 @@ class SeedClassifier { std::vector>& outputTensor, float minSeedScore = 0.1) const { std::vector goodSeeds; - int iOut = 0; // Loop over all the cluster and only keep the seed with the highest score // in each cluster for (const auto& cluster : clusters) { int bestSeedID = 0; float bestSeedScore = 0; for (const auto& seed : cluster) { - if (outputTensor[iOut][0] > bestSeedScore) { - bestSeedScore = outputTensor[iOut][0]; + if (outputTensor[seed][0] > bestSeedScore) { + bestSeedScore = outputTensor[seed][0]; bestSeedID = seed; } - iOut++; } if (bestSeedScore >= minSeedScore) { goodSeeds.push_back(bestSeedID); From 791498ddb843399faca00de40756847dc36f9477 Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Thu, 7 Dec 2023 15:32:23 +0100 Subject: [PATCH 21/31] Greatly reduce trainning mem consuption --- .../Python/MLAmbiguityResolution/train_ambiguity_solver.py | 2 +- .../Scripts/Python/MLAmbiguityResolution/train_seed_solver.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py b/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py index 44bab112f80..36cde1ebbbe 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py @@ -188,7 +188,7 @@ def scoringBatch(batch: list[pd.DataFrame], Optimiser=0) -> tuple[int, int, floa nb_part += 1 # Normalise the loss to the batch size batch_loss = batch_loss / len(b_data[0]) - loss += batch_loss + loss += batch_loss.item() # Perform the gradient descend if an optimiser was specified if Optimiser: batch_loss.backward() diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py b/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py index abdaa0da233..e800e940ee7 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py @@ -216,7 +216,7 @@ def scoringBatch(batch: list[pd.DataFrame], Optimiser=0) -> tuple[int, int, floa nb_part += 1 # Normalise the loss to the batch size batch_loss = batch_loss / len(b_data[0]) - loss += batch_loss + loss += batch_loss.item() # Perform the gradient descent if an optimiser was specified if Optimiser: batch_loss.backward() From b2926a023e0fe777956900fc9b0aa19b879ad466 Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Thu, 7 Dec 2023 15:47:09 +0100 Subject: [PATCH 22/31] remove useless part of matching --- .../Python/MLAmbiguityResolution/match_good_track-seed.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py b/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py index e5321040952..de1129336dc 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py @@ -14,7 +14,6 @@ def matchGood(seed_files: list[str], ckf_files: list[str]) -> pd.DataFrame: data_seed = pd.DataFrame() data_track = pd.DataFrame() goodSeed = pd.DataFrame() - data = pd.DataFrame() # Loop over the different track files and collect the list of seed ID associated to the good tracks for f_ckf, f_seed in zip(ckf_files, seed_files): print("reading file: ", f_ckf, f_seed) @@ -52,7 +51,6 @@ def matchGood(seed_files: list[str], ckf_files: list[str]) -> pd.DataFrame: matchedData = matchedData.set_index("seed_id") matchedData = matchedData.drop(columns=["goodSeed"]) matchedData.to_csv(matched) - data = pd.concat([data, matchedData]) # Save the cleaned dataset for future use (the cleaning is time consuming) cleaned = f_seed[:-4] + "_cleaned.csv" @@ -61,7 +59,7 @@ def matchGood(seed_files: list[str], ckf_files: list[str]) -> pd.DataFrame: cleanedData = cleanedData.drop(columns=["goodSeed"]) cleanedData.to_csv(cleaned) - return data + return # Read the seed and track files and match them From fe3addb0525ee32aa297d97753b021533ea9d80d Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Mon, 11 Dec 2023 16:06:24 +0100 Subject: [PATCH 23/31] improved the network --- .../seedduplicateClassifier.onnx | Bin 123798 -> 123798 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/seedduplicateClassifier.onnx b/Examples/Scripts/Python/MLAmbiguityResolution/seedduplicateClassifier.onnx index 4df6b659fc0cb6c9edb24efa036a2d5f6b002701..f8dd749ef4bd14e2c34e25626c614dddec5928ed 100755 GIT binary patch literal 123798 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

^9Q%gs#a%wZx)Y_QPN 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 literal 123798 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 From d9a363e6b9b4c009b31ad5d9385a6fa4f3aa4aa6 Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Mon, 11 Dec 2023 16:44:00 +0100 Subject: [PATCH 24/31] doc --- docs/plugins/MLAlgorithms.md | 50 +++++++++++++++++++++++++++--------- 1 file changed, 38 insertions(+), 12 deletions(-) diff --git a/docs/plugins/MLAlgorithms.md b/docs/plugins/MLAlgorithms.md index 2534bcb4cfe..53fa366c5f6 100644 --- a/docs/plugins/MLAlgorithms.md +++ b/docs/plugins/MLAlgorithms.md @@ -1,38 +1,64 @@ -# Machine leaning algorithms +# Machine learning algorithms -ACTS allows you to replace some components of the tracking chain by machine learning solutions. -For now a replacement to the ambiguity solver is available, but when others are implemented they will be explained here. +ACTS allows you to replace some components of the tracking chain with machine-learning solutions. +A replacement for the ambiguity solver and a filtering algorithm for seed are available for now, but when others are implemented, they will be explained here. ## Onnx plugin -To be able to perform neural network models' inferences in C++ ACTS uses [onnxruntime](https://onnxruntime.ai/). An interface to use it has been implemented as an ACTS plugin, to use it you will need to compile ACTS with the `ACTS_PLUGIN_ONNX` option. For more detail on how to export your model to onnx please see the documentation on their [website](https://onnxruntime.ai/docs/) +To be able to perform neural network (NN) models' inferences in C++, ACTS uses [onnxruntime](https://onnxruntime.ai/). An interface to use it has been implemented as an ACTS plugin; to use it, you will need to compile ACTS with the `ACTS_PLUGIN_ONNX` option. For more details on how to export your model to onnx, please see the documentation on their [website](https://onnxruntime.ai/docs/) ### OnnxRuntimeBase -The `OnnxRuntimeBase` class implement the inference of a standard MLP via Onnx and just require a link to the `.onnx` file containing the model one wants to use. Please note that right now the implementation of the inference in ACTS only work with a single input node and a single output node. The inference can be both perform in single entry mode and in batch mode. In single entry mode, the `runONNXInference` method takes a single vector as entry, each element of the vector corresponding to one of the input features of your network. In batch mode, the input is an `Eigen::Array` with the columns corresponding to the input features and rows to the different batch inputs. +The `OnnxRuntimeBase` class implement the inference of a standard MLP via Onnx and just requires a link to the `.onnx` file containing the model one wants to use. Please note that the implementation of the inference in ACTS only works with a single input node and a single output node. The inference can be performed in single entry and batch modes. In single entry mode, the `runONNXInference` method takes a single vector as an entry, each element of the vector corresponding to one of the input features of your network. In batch mode, the input is an `Eigen::Array` with the columns corresponding to the input features and rows to the different batch inputs. ## AmbiguityResolutionMLAlgorithm -The goal of the ambiguity solver is to remove duplicated and fake tracks that remains after the CKF. To perform this cleaning, this algorithm works in three steps : +The goal of the ambiguity solver is to remove duplicated and fake tracks that remain after the CKF. To perform this cleaning, this algorithm works in three steps : - Clustering: tracks are clustered together, one cluster ~ one truth particle -- Ranking: tracks in each cluster are ranked, the best one is kept +- Ranking: tracks in each cluster are scored, the best one is kept - Cleaning: last pass over all the remaining tracks to remove duplicate and fake (not implemented yet) ### Clustering -The clustering is implemented with the `clusterTracks` function. Its input is a multimap of pair of track ID and vector of measurement ID. The multimap uses the number of measurement associated with the tracks as a key, this is only a trick to sort the tracks by the number of measurements efficiently. Then for each track, starting with the one which has the most measurements, we check if a cluster shares a hits with the track. If not, we create a new cluster and associate all the hits of the current track with the cluster. If yes, the track is added to that cluster (note that the hits associated to the cluster doesn't change here). After looping over all the tracks, each of them should have been associated with a cluster. +The clustering is implemented with the `clusterTracks` function. Its input is a multimap of a pair of track IDs and a vector of measurement IDs. The multimap uses the number of measurements associated with the tracks as a key, which is only a trick to sort the tracks efficiently by the number of measurements. Then, for each track, starting with the one with the most measurements, we check if a cluster shares a hit with the track. If not, we create a new cluster and associate all the hits of the current track with the cluster. If yes, the track is added to that cluster (note that the hits associated with the cluster don’t change here). After looping over all the tracks, each should have been associated with a cluster. ### Ranking -At this step we have multiple clusters of tracks. We use a NN to compute a score for each track, the closer the score is to 1, the more confident we are that the track is the best track (the best one associated with the truth particle). Then for each cluster, we select the track with the highest score. +At this step, we have multiple clusters of tracks. We use a NN to compute a score for each track; the closer the score is to 1, the more confident we are that the track is the best (the best one associated with the truth particle). Then, for each cluster, we select the track with the highest score. ### Cleaning -Finally, for the remaining tracks, there might be some fakes and duplicates. With the first tests it doesn't seem to be the case, so the current implementation stops here. But in the future if some configuration encounters too many fake/duplicate after the ranking a simple classification NN could be used to separate the good tracks from the others. +Finally, for the remaining tracks, there might be some fakes and duplicates. It doesn’t seem to be the case with the first tests, so the current implementation stops here. But in the future, if some configuration encounters too many fake/duplicates after the ranking, a simple classification NN could be used to separate the good tracks from the others. + +Running the ACTS Greedy Solver after the ML Solver can be helpful in some cases; it will likely remove most of the remaining fakes while being extremely fast and not affecting the reconstruction performances (since both algorithms are orthogonal). The default implementation in the full ODD chain uses this approach. + +### How to use + +The ML-based Ambiguity solver comes with a pre-trained model to be used with the ODD. Using it is extremely simple; just call the `full_chain_odd.py` with the `--MLSolver` option. If you want to try this solver with another detector, a few more steps are needed. First, you need to train a model. As an input, you will need the multitrajectory output from the CKF (run a full chain up to the CKF, then use the `CSVWriter`). At least 100 ttbar events with 200 PU are needed (1000 would be ideal). You can then run `Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py ` on our dataset, 2/3 of the data should be used for the training and 1/3 for the validation. You will receive a `duplicateClassifier.onnx` file as an output, which can now be used as an input for the `AmbiguityResolutionMLAlgorithm` with your detector. + +Additionally, two other Python files are present with the training. One called `ambiguity_solver_full_chain.py` performs the same job as the chain we presented here but in Python using CSV files in input. The other one, `ambiguity_solver_perf.py`, can be used to study the performance of the ambiguity solver (ML and not) and also takes CSV files as input. + +## MLSeedFiltering + +While the ambiguity solver can significantly improve the cleanliness of the output removing both duplicate and fake from the final collection, it doesn't help with the speed of the full tracking chain. The MLSeedFiltering aims to use a NN to determine which seed will lead to the best trajectory before performing the track reconstruction. We can select the seed used in track reconstruction based on the NN score. Depending on the full tracking setup, this might help us improve the track reconstruction speed, the track reconstructed quality, or both. In the case of the ODD, a speed improvement of x10 was observed in track reconstruction speed for ttbar, mu=200 G4+Pythia8 events. + +It uses the same three steps as the ML ambiguity solver but with seed instead of tracks : + +- Clustering: seeds are clustered together, one cluster ~ one truth particle +- Ranking: seeds in each cluster are scored, and the best one is kept +- Cleaning: last pass over all the remaining scores to remove fake + +### Clustering + +The clustering is implemented with the `dbscanSeedClustering` function. Its input is a vector of vector containing the seed parameters that will be used in the clustering. For the clustering itself, we used a 4D DBSCAN clustering algorithm, a density-based clustering technique. All the seeds are represented as points in a 4D space using their value of $\phi$, $\eta$, $z_{0}$, $p_{T}$ and are clustered together based on their proximity. The output of the clustering is a vector of vector of int; each element corresponds to one cluster with the inner vector listing the ID of all the seeds in that cluster. + +### Ranking + +At this step, we have multiple clusters of seeds. We use a NN to compute a score for each seed. Due to the loss function used in training, the fake seed (coming from more than one truth particle) tends to have a score close to 0; we can thus remove them by cutting the low-score seed. The `minSeedScore` parameter is used to choose the cutoff value. For each cluster, we can then select the seed with the highest score to be kept. ### How to use -The ML based Ambiguity solver comes with a pre-trained model to be used with the ODD. Using it is extremely simple, just call the `full_chain_odd.py` with the `--MLSolver` option. If you want to try this solver with another detector, a few more step are needed. First you need to train a model. As an input you will need the multitrajectory output from the CKF (run a full chain up to the CKF then use the `CSVWriter`). At least 100 ttbar events with 200 PU are needed (1000 would be ideal). You can then run `Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py ` on our dataset, 2/3 of the data should be used for the training and 1/3 for the validation. You will receive a `duplicateClassifier.onnx` file as an output which now can be used as an input for the `AmbiguityResolutionMLAlgorithm` with your detector. +The ML-based Ambiguity solver comes with a pre-trained model to be used with the ODD. Using it is extremely simple; just call the `full_chain_odd.py` with the `--MLSeedFilter` option. If you want to try this solver with another detector, a few more steps are needed. First, you need to train a model. As an input, you will need the seeding and multitrajectory output from the CKF (run a full chain up to the CKF, then use the `CSVWriter` for both the seeding and the CKF). At least 1000 ttbar events with 200 PU are needed. First, we need to match the seed and the corresponding tracks together; for that, we can run `Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py`. The network can then be trained with: `Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py ` on our dataset, 2/3 of the data should be used for the training and 1/3 for the validation. You will receive a `seedduplicateClassifier.onnx` file as an output, which can now be used as an input for the `AmbiguityResolutionMLAlgorithm` with your detector. -Additionally, two other Python files are present with the training. One called `ambiguity_solver_full_chain.py` this one perform the same job as the chain we presented here but in python using Csv files in input. The difference is that they also perform an additional pre-clustering using a DBScan. The other one `ambiguity_solver_perf.py` can be used to study the performance of the ambiguity solver (ML and not) and also takes Csv files as input. \ No newline at end of file +Additionally, two other Python files are present with the training. One called `seed_filter_full_chain.py` performs the same job as the chain we presented here, but in Python, using CSV files in the input, this will plot many helpful distributions that will help you understand how the Filter is performing. From 74f5a9480572bd9d259973179488a288ecff39e3 Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Thu, 14 Dec 2023 15:25:48 +0100 Subject: [PATCH 25/31] PR comments --- .../detail/AmbiguityTrackClustering.hpp | 6 +++-- .../TrackFinding/AmbiguityTrackClustering.cpp | 14 ++++++----- .../TrackFindingML/AmbiguityResolutionML.hpp | 9 ++++---- .../src/AmbiguityResolutionML.cpp | 15 ++++++------ .../src/AmbiguityResolutionMLAlgorithm.cpp | 6 ++--- .../AmbiguityResolutionMLDBScanAlgorithm.cpp | 6 ++--- .../src/SeedFilterMLAlgorithm.cpp | 10 ++++---- .../ActsExamples/Io/Csv/CsvSeedWriter.hpp | 2 +- .../ActsExamples/Io/Csv/CsvTrackWriter.hpp | 2 +- Examples/Io/Csv/src/CsvSeedWriter.cpp | 6 ++--- Examples/Io/Csv/src/CsvTrackWriter.cpp | 6 ++--- .../match_good_track-seed.py | 5 ++-- .../Mlpack/AmbiguityDBScanClustering.hpp | 18 ++++++++------- .../Mlpack/SeedFilterDBScanClustering.hpp | 9 ++++---- .../Plugins/Onnx/AmbiguityTrackClassifier.hpp | 21 +++++++++-------- .../Acts/Plugins/Onnx/SeedClassifier.hpp | 23 ++++++++++--------- 16 files changed, 84 insertions(+), 74 deletions(-) diff --git a/Core/include/Acts/TrackFinding/detail/AmbiguityTrackClustering.hpp b/Core/include/Acts/TrackFinding/detail/AmbiguityTrackClustering.hpp index 5985f37a6a3..fb2c11f21ba 100644 --- a/Core/include/Acts/TrackFinding/detail/AmbiguityTrackClustering.hpp +++ b/Core/include/Acts/TrackFinding/detail/AmbiguityTrackClustering.hpp @@ -20,8 +20,10 @@ namespace detail { /// /// @param trackMap : Multimap storing pair of track ID and vector of measurement ID. The keys are the number of measurement and are just there to facilitate the ordering. /// @return an unordered map representing the clusters, the keys the ID of the primary track of each cluster and the store a vector of track IDs. -std::unordered_map> clusterDuplicateTracks( - const std::multimap>>& trackMap); +std::unordered_map> +clusterDuplicateTracks( + const std::multimap>>& + trackMap); } // namespace detail } // namespace Acts diff --git a/Core/src/TrackFinding/AmbiguityTrackClustering.cpp b/Core/src/TrackFinding/AmbiguityTrackClustering.cpp index 6e31a39a4dc..b9cf526df7e 100644 --- a/Core/src/TrackFinding/AmbiguityTrackClustering.cpp +++ b/Core/src/TrackFinding/AmbiguityTrackClustering.cpp @@ -10,18 +10,20 @@ #include -std::unordered_map> Acts::detail::clusterDuplicateTracks( - const std::multimap>>& trackMap) { +std::unordered_map> +Acts::detail::clusterDuplicateTracks( + const std::multimap>>& + trackMap) { // Unordered map associating a vector with all the track ID of a cluster to // the ID of the first track of the cluster - std::unordered_map> cluster; + std::unordered_map> cluster; // Unordered map associating hits to the ID of the first track of the // different clusters. - std::unordered_map hitToTrack; + std::unordered_map hitToTrack; // Loop over all the tracks for (auto track = trackMap.rbegin(); track != trackMap.rend(); ++track) { - std::vector hits = track->second.second; + std::vector hits = track->second.second; auto matchedTrack = hitToTrack.end(); // Loop over all the hits in the track for (auto hit = hits.begin(); hit != hits.end(); hit++) { @@ -36,7 +38,7 @@ std::unordered_map> Acts::detail::clusterDuplicateTracks( // None of the hits have been matched to a track create a new cluster if (matchedTrack == hitToTrack.end()) { cluster.emplace(track->second.first, - std::vector(1, track->second.first)); + std::vector(1, track->second.first)); for (const auto& hit : hits) { // Add the hits of the new cluster to the hitToTrack hitToTrack.emplace(hit, track->second.first); diff --git a/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/AmbiguityResolutionML.hpp b/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/AmbiguityResolutionML.hpp index d9bffb31a83..aafc5c403fc 100644 --- a/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/AmbiguityResolutionML.hpp +++ b/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/AmbiguityResolutionML.hpp @@ -33,15 +33,16 @@ class AmbiguityResolutionML : public IAlgorithm { /// @param tracks is the input track container /// @param nMeasurementsMin minimum number of measurement per track /// @return an ordered list containing pairs of track ID and associated measurement ID - std::multimap>> mapTrackHits( - const ConstTrackContainer& tracks, int nMeasurementsMin) const; + std::multimap>> + mapTrackHits(const ConstTrackContainer& tracks, int nMeasurementsMin) const; /// Prepare the output track container to be written /// /// @param tracks is the input track container /// @param goodTracks is list of the IDs of all the tracks we want to keep - ConstTrackContainer prepareOutputTrack(const ConstTrackContainer& tracks, - std::vector& goodTracks) const; + ConstTrackContainer prepareOutputTrack( + const ConstTrackContainer& tracks, + std::vector& goodTracks) const; }; } // namespace ActsExamples diff --git a/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionML.cpp b/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionML.cpp index 5b4d80b25a5..7895d627cd6 100644 --- a/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionML.cpp +++ b/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionML.cpp @@ -15,23 +15,24 @@ ActsExamples::AmbiguityResolutionML::AmbiguityResolutionML( std::string name, Acts::Logging::Level lvl) : ActsExamples::IAlgorithm(name, lvl) {} -std::multimap>> +std::multimap>> ActsExamples::AmbiguityResolutionML::mapTrackHits( const ActsExamples::ConstTrackContainer& tracks, int nMeasurementsMin) const { - std::multimap>> trackMap; + std::multimap>> trackMap; // Loop over all the trajectories in the events for (const auto& track : tracks) { - std::vector hits; + std::vector hits; int nbMeasurements = 0; // Store the hits id for the trajectory and compute the number of // measurement tracks.trackStateContainer().visitBackwards( track.tipIndex(), [&](const auto& state) { if (state.typeFlags().test(Acts::TrackStateFlag::MeasurementFlag)) { - int indexHit = state.getUncalibratedSourceLink() - .template get() - .index(); + std::size_t indexHit = + state.getUncalibratedSourceLink() + .template get() + .index(); hits.emplace_back(indexHit); ++nbMeasurements; } @@ -47,7 +48,7 @@ ActsExamples::AmbiguityResolutionML::mapTrackHits( ActsExamples::ConstTrackContainer ActsExamples::AmbiguityResolutionML::prepareOutputTrack( const ActsExamples::ConstTrackContainer& tracks, - std::vector& goodTracks) const { + std::vector& goodTracks) const { std::shared_ptr trackStateContainer = tracks.trackStateContainerHolder(); auto trackContainer = std::make_shared(); diff --git a/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLAlgorithm.cpp b/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLAlgorithm.cpp index 3776f1f6778..0bdbe661c14 100644 --- a/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLAlgorithm.cpp +++ b/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLAlgorithm.cpp @@ -35,11 +35,11 @@ ActsExamples::ProcessCode ActsExamples::AmbiguityResolutionMLAlgorithm::execute( // Read input data const auto& tracks = m_inputTracks(ctx); // Associate measurement to their respective tracks - std::multimap>> trackMap = - mapTrackHits(tracks, m_cfg.nMeasurementsMin); + std::multimap>> + trackMap = mapTrackHits(tracks, m_cfg.nMeasurementsMin); auto cluster = Acts::detail::clusterDuplicateTracks(trackMap); // Select the ID of the track we want to keep - std::vector goodTracks = + std::vector goodTracks = m_duplicateClassifier.solveAmbiguity(cluster, tracks); // Prepare the output track collection from the IDs auto outputTracks = prepareOutputTrack(tracks, goodTracks); diff --git a/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLDBScanAlgorithm.cpp b/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLDBScanAlgorithm.cpp index 3af289cf09a..4c0601c4ece 100644 --- a/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLDBScanAlgorithm.cpp +++ b/Examples/Algorithms/TrackFindingML/src/AmbiguityResolutionMLDBScanAlgorithm.cpp @@ -39,13 +39,13 @@ ActsExamples::AmbiguityResolutionMLDBScanAlgorithm::execute( // Read input data const auto& tracks = m_inputTracks(ctx); // Associate measurement to their respective tracks - std::multimap>> trackMap = - mapTrackHits(tracks, m_cfg.nMeasurementsMin); + std::multimap>> + trackMap = mapTrackHits(tracks, m_cfg.nMeasurementsMin); // Cluster the tracks using DBscan auto cluster = Acts::dbscanTrackClustering( trackMap, tracks, m_cfg.epsilonDBScan, m_cfg.minPointsDBScan); // Select the ID of the track we want to keep - std::vector goodTracks = + std::vector goodTracks = m_duplicateClassifier.solveAmbiguity(cluster, tracks); // Prepare the output track collection from the IDs auto outputTracks = prepareOutputTrack(tracks, goodTracks); diff --git a/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp b/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp index 6ee217ebcba..32b612fb12b 100644 --- a/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp +++ b/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp @@ -21,16 +21,16 @@ ActsExamples::SeedFilterMLAlgorithm::SeedFilterMLAlgorithm( m_cfg(std::move(cfg)), m_seedClassifier(m_cfg.inputSeedFilterNN.c_str()) { if (m_cfg.inputTrackParameters.empty()) { - throw std::invalid_argument("Missing trajectories input collection"); + throw std::invalid_argument("Missing track parameters input collection"); } if (m_cfg.inputSimSeeds.empty()) { - throw std::invalid_argument("Missing trajectories input collection"); + throw std::invalid_argument("Missing seed input collection"); } if (m_cfg.outputTrackParameters.empty()) { - throw std::invalid_argument("Missing trajectories output collection"); + throw std::invalid_argument("Missing track parameters output collection"); } if (m_cfg.outputSimSeeds.empty()) { - throw std::invalid_argument("Missing trajectories output collection"); + throw std::invalid_argument("Missing seed output collection"); } m_inputTrackParameters.initialize(m_cfg.inputTrackParameters); m_inputSimSeeds.initialize(m_cfg.inputSimSeeds); @@ -80,7 +80,7 @@ ActsExamples::ProcessCode ActsExamples::SeedFilterMLAlgorithm::execute( clusteringParams, m_cfg.epsilonDBScan, m_cfg.minPointsDBScan); // Select the ID of the track we want to keep - std::vector goodSeed = m_seedClassifier.solveAmbiguity( + std::vector goodSeed = m_seedClassifier.solveAmbiguity( cluster, networkInput, m_cfg.minSeedScore); // Create the output seed collection diff --git a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp index 2059bb63dc9..c182aa5bbf7 100644 --- a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp +++ b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvSeedWriter.hpp @@ -90,7 +90,7 @@ class CsvSeedWriter : public WriterT { /// @brief Struct for brief seed summary info /// struct SeedInfo { - std::size_t seedId = 0; + std::size_t seedID = 0; ActsFatras::Barcode particleId; float seedPt = -1; float seedPhi = 0; diff --git a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvTrackWriter.hpp b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvTrackWriter.hpp index 2bea2289973..c53c21f7ef7 100644 --- a/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvTrackWriter.hpp +++ b/Examples/Io/Csv/include/ActsExamples/Io/Csv/CsvTrackWriter.hpp @@ -89,7 +89,7 @@ class CsvTrackWriter : public WriterT { /// struct TrackInfo : public Acts::MultiTrajectoryHelpers::TrajectoryState { std::size_t trackId = 0; - unsigned int seedId = 0; + unsigned int seedID = 0; ActsFatras::Barcode particleId; std::size_t nMajorityHits = 0; std::string trackType; diff --git a/Examples/Io/Csv/src/CsvSeedWriter.cpp b/Examples/Io/Csv/src/CsvSeedWriter.cpp index 12361d694b3..2b3be226c48 100644 --- a/Examples/Io/Csv/src/CsvSeedWriter.cpp +++ b/Examples/Io/Csv/src/CsvSeedWriter.cpp @@ -147,7 +147,7 @@ ActsExamples::ProcessCode ActsExamples::CsvSeedWriter::writeT( // track info SeedInfo toAdd; - toAdd.seedId = iparams; + toAdd.seedID = iparams; toAdd.particleId = majorityParticleId; toAdd.seedPt = std::abs(1.0 / params[Acts::eBoundQOverP]) * std::sin(params[Acts::eBoundTheta]); @@ -160,7 +160,7 @@ ActsExamples::ProcessCode ActsExamples::CsvSeedWriter::writeT( toAdd.seedType = truthMatched ? "duplicate" : "fake"; toAdd.measurementsID = ptrack; - infoMap[toAdd.seedId] = toAdd; + infoMap[toAdd.seedID] = toAdd; } mos << "seed_id,particleId," @@ -177,7 +177,7 @@ ActsExamples::ProcessCode ActsExamples::CsvSeedWriter::writeT( info.seedType = "good"; } // write the track info - mos << info.seedId << ","; + mos << info.seedID << ","; mos << info.particleId << ","; mos << info.seedPt << ","; mos << info.seedEta << ","; diff --git a/Examples/Io/Csv/src/CsvTrackWriter.cpp b/Examples/Io/Csv/src/CsvTrackWriter.cpp index 2938724eab5..d6b3b336ce4 100644 --- a/Examples/Io/Csv/src/CsvTrackWriter.cpp +++ b/Examples/Io/Csv/src/CsvTrackWriter.cpp @@ -116,9 +116,9 @@ ProcessCode CsvTrackWriter::writeT(const AlgorithmContext& context, TrackInfo toAdd; toAdd.trackId = trackId; if (tracks.hasColumn(Acts::hashString("trackGroup"))) { - toAdd.seedId = seedNumber(track); + toAdd.seedID = seedNumber(track); } else { - toAdd.seedId = 0; + toAdd.seedID = 0; } toAdd.particleId = majorityParticleId; toAdd.nStates = track.nTrackStates(); @@ -199,7 +199,7 @@ ProcessCode CsvTrackWriter::writeT(const AlgorithmContext& context, // write the track info mos << trajState.trackId << ","; - mos << trajState.seedId << ","; + mos << trajState.seedID << ","; mos << trajState.particleId << ","; mos << trajState.nStates << ","; mos << trajState.nMajorityHits << ","; diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py b/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py index de1129336dc..f917eaaf3cc 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py @@ -4,12 +4,11 @@ import numpy as np -def matchGood(seed_files: list[str], ckf_files: list[str]) -> pd.DataFrame: +def matchGood(seed_files: list[str], ckf_files: list[str]): """Read the dataset from the tracks and seeds files, then modify the seed dataset so that good seed correspond to the ones that lead to good tracks. Seed with truth id that do not lead to good tracks are considered as fake. Also create a new dataset with only truth particle associated to a good seeds.""" """ @param[in] Seed_files: List of files containing seeds data (1 file per events usually) @param[in] CKF_files: List of files containing tracks data (1 file per events usually) - @return: combined DataFrame containing all the seed, ordered by events and then by truth particle ID in each events """ data_seed = pd.DataFrame() data_track = pd.DataFrame() @@ -66,4 +65,4 @@ def matchGood(seed_files: list[str], ckf_files: list[str]) -> pd.DataFrame: # This will allow us to determine which seeds leads to the best possible tracks seed_files = sorted(glob.glob("odd_output" + "/event*-seed.csv")) ckf_files = sorted(glob.glob("odd_output" + "/event*-tracks_ckf.csv")) -data = matchGood(seed_files, ckf_files) +matchGood(seed_files, ckf_files) diff --git a/Plugins/Mlpack/include/Acts/Plugins/Mlpack/AmbiguityDBScanClustering.hpp b/Plugins/Mlpack/include/Acts/Plugins/Mlpack/AmbiguityDBScanClustering.hpp index 273dd863846..d726a6db888 100644 --- a/Plugins/Mlpack/include/Acts/Plugins/Mlpack/AmbiguityDBScanClustering.hpp +++ b/Plugins/Mlpack/include/Acts/Plugins/Mlpack/AmbiguityDBScanClustering.hpp @@ -28,22 +28,23 @@ namespace Acts { /// @return an unordered map representing the clusters, the keys the ID of the primary track of each cluster and the store a vector of track IDs. template class holder_t> -std::unordered_map> dbscanTrackClustering( - std::multimap>>& trackMap, +std::unordered_map> dbscanTrackClustering( + std::multimap>>& + trackMap, const Acts::TrackContainer& tracks, float epsilon = 0.07, int minPoints = 2) { // Unordered map associating a vector with all the track ID of a cluster to // the ID of the first track of the cluster - std::unordered_map> cluster; + std::unordered_map> cluster; // Unordered map associating hits to the ID of the first track of the // different clusters. - std::unordered_map hitToTrack; + std::unordered_map hitToTrack; // DBSCAN algorithm from MLpack used in the track clustering mlpack::DBSCAN dbscan(epsilon, minPoints); arma::mat data(2, trackMap.size()); - int trackID = 0; + std::size_t trackID = 0; arma::Row assignments; // Get the input feature of the network for all the tracks @@ -57,12 +58,13 @@ std::unordered_map> dbscanTrackClustering( trackID = 0; // Cluster track with DBScan - std::vector>>> + std::vector< + std::multimap>>> dbscanClusters(clusterNb); for (const auto& [key, val] : trackMap) { - int clusterID = assignments(trackID); + std::size_t clusterID = assignments(trackID); if (assignments(trackID) == SIZE_MAX) { - cluster.emplace(val.first, std::vector(1, val.first)); + cluster.emplace(val.first, std::vector(1, val.first)); } else { dbscanClusters[clusterID].emplace(key, val); } diff --git a/Plugins/Mlpack/include/Acts/Plugins/Mlpack/SeedFilterDBScanClustering.hpp b/Plugins/Mlpack/include/Acts/Plugins/Mlpack/SeedFilterDBScanClustering.hpp index 75ac6596e7c..369650ed3e5 100644 --- a/Plugins/Mlpack/include/Acts/Plugins/Mlpack/SeedFilterDBScanClustering.hpp +++ b/Plugins/Mlpack/include/Acts/Plugins/Mlpack/SeedFilterDBScanClustering.hpp @@ -23,7 +23,7 @@ namespace Acts { /// @param epsilon : Maximum distance between 2 tracks to be clustered /// @param minPoints : Minimum number of tracks to create a cluster /// @return an unordered map representing the clusters, the keys the ID of the primary seed of each cluster and the stored value a vector of seed IDs. -std::vector> dbscanSeedClustering( +std::vector> dbscanSeedClustering( const std::vector>& input, float epsilon = 0.03, int minPoints = 2) { // DBSCAN algorithm from MLpack used in the seed clustering @@ -46,11 +46,12 @@ std::vector> dbscanSeedClustering( std::size_t clusterNb = dbscan.Cluster(data, assignments); // Prepare the output - std::vector> cluster(clusterNb, std::vector()); + std::vector> cluster(clusterNb, + std::vector()); for (std::size_t iD = 0; iD < input.size(); iD++) { - int clusterID = assignments(iD); + std::size_t clusterID = assignments(iD); if (assignments(iD) == SIZE_MAX) { - cluster.push_back(std::vector(1, iD)); + cluster.push_back(std::vector(1, iD)); } else { cluster[clusterID].push_back(iD); } diff --git a/Plugins/Onnx/include/Acts/Plugins/Onnx/AmbiguityTrackClassifier.hpp b/Plugins/Onnx/include/Acts/Plugins/Onnx/AmbiguityTrackClassifier.hpp index 5508371a2e7..8759450abd4 100644 --- a/Plugins/Onnx/include/Acts/Plugins/Onnx/AmbiguityTrackClassifier.hpp +++ b/Plugins/Onnx/include/Acts/Plugins/Onnx/AmbiguityTrackClassifier.hpp @@ -39,7 +39,7 @@ class AmbiguityTrackClassifier { template class holder_t> std::vector> inferScores( - std::unordered_map>& clusters, + std::unordered_map>& clusters, const Acts::TrackContainer& tracks) const { // Compute the number of entry (since it is smaller than the number of @@ -50,7 +50,7 @@ class AmbiguityTrackClassifier { } // Input of the neural network Acts::NetworkBatchInput networkInput(trackNb, 8); - int inputID = 0; + std::size_t inputID = 0; // Get the input feature of the network for all the tracks for (const auto& [key, val] : clusters) { for (const auto& trackID : val) { @@ -80,15 +80,15 @@ class AmbiguityTrackClassifier { /// @param clusters is a map of clusters, each cluster correspond to a vector of track ID /// @param outputTensor is the score vector obtained from inferScores. /// @return a vector of trackID corresponding tho the good tracks - std::vector trackSelection( - std::unordered_map>& clusters, + std::vector trackSelection( + std::unordered_map>& clusters, std::vector>& outputTensor) const { - std::vector goodTracks; - int iOut = 0; + std::vector goodTracks; + std::size_t iOut = 0; // Loop over all the cluster and only keep the track with the highest score // in each cluster for (const auto& [key, val] : clusters) { - int bestTrackID = 0; + std::size_t bestTrackID = 0; float bestTrackScore = 0; for (const auto& track : val) { if (outputTensor[iOut][0] > bestTrackScore) { @@ -109,13 +109,14 @@ class AmbiguityTrackClassifier { /// @return a vector of trackID corresponding tho the good tracks template class holder_t> - std::vector solveAmbiguity( - std::unordered_map>& clusters, + std::vector solveAmbiguity( + std::unordered_map>& clusters, const Acts::TrackContainer& tracks) const { std::vector> outputTensor = inferScores(clusters, tracks); - std::vector goodTracks = trackSelection(clusters, outputTensor); + std::vector goodTracks = + trackSelection(clusters, outputTensor); return goodTracks; } diff --git a/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp b/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp index 23873286d22..6daa4f410e7 100644 --- a/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp +++ b/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp @@ -44,23 +44,24 @@ class SeedClassifier { /// @param outputTensor is the score vector obtained from inferScores. /// @param minSeedScore is the minimum score a seed need to be selected /// @return a vector of seedID corresponding tho the good seeds - std::vector seedSelection(std::vector>& clusters, - std::vector>& outputTensor, - float minSeedScore = 0.1) const { - std::vector goodSeeds; + std::vector seedSelection( + std::vector>& clusters, + std::vector>& outputTensor, + float minSeedScore = 0.1) const { + std::vector goodSeeds; // Loop over all the cluster and only keep the seed with the highest score // in each cluster for (const auto& cluster : clusters) { - int bestSeedID = 0; + std::size_t bestseedID = 0; float bestSeedScore = 0; for (const auto& seed : cluster) { if (outputTensor[seed][0] > bestSeedScore) { bestSeedScore = outputTensor[seed][0]; - bestSeedID = seed; + bestseedID = seed; } } if (bestSeedScore >= minSeedScore) { - goodSeeds.push_back(bestSeedID); + goodSeeds.push_back(bestseedID); } } return goodSeeds; @@ -72,11 +73,11 @@ class SeedClassifier { /// @param networkInput input of the network /// @param minSeedScore is the minimum score a seed need to be selected /// @return a vector of seedID corresponding the the good seeds - std::vector solveAmbiguity(std::vector>& clusters, - Acts::NetworkBatchInput& networkInput, - float minSeedScore = 0.1) const { + std::vector solveAmbiguity( + std::vector>& clusters, + Acts::NetworkBatchInput& networkInput, float minSeedScore = 0.1) const { std::vector> outputTensor = inferScores(networkInput); - std::vector goodSeeds = + std::vector goodSeeds = seedSelection(clusters, outputTensor, minSeedScore); return goodSeeds; } From fa1abc55e0cd7366279ed3ff2ce0af2b2831a301 Mon Sep 17 00:00:00 2001 From: Corentin ALLAIRE <62873125+Corentin-Allaire@users.noreply.github.com> Date: Thu, 14 Dec 2023 15:36:45 +0100 Subject: [PATCH 26/31] Apply suggestions from code review PR sugestions Co-authored-by: Alexander J. Pfleger <70842573+AJPfleger@users.noreply.github.com> --- .../src/SeedFilterMLAlgorithm.cpp | 7 +++---- .../ambiguity_solver_perf.py | 14 ++++++------- .../train_seed_solver.py | 4 ++-- docs/plugins/MLAlgorithms.md | 20 ++++++++++--------- 4 files changed, 23 insertions(+), 22 deletions(-) diff --git a/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp b/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp index 32b612fb12b..05eb6a9a02e 100644 --- a/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp +++ b/Examples/Algorithms/TrackFindingML/src/SeedFilterMLAlgorithm.cpp @@ -54,8 +54,6 @@ ActsExamples::ProcessCode ActsExamples::SeedFilterMLAlgorithm::execute( // Loop over the seed and parameters to fill the input for the clustering // and the NN for (std::size_t i = 0; i < seeds.size(); i++) { - // Keep track of the index of the seed in the original collection - std::size_t NNindex = i; // Compute the track parameters double pT = std::abs(1.0 / params[i].parameters()[Acts::eBoundQOverP]) * std::sin(params[i].parameters()[Acts::eBoundTheta]); @@ -67,8 +65,9 @@ ActsExamples::ProcessCode ActsExamples::SeedFilterMLAlgorithm::execute( clusteringParams.push_back( {phi / m_cfg.clusteringWeighPhi, eta / m_cfg.clusteringWeighEta, seeds[i].z() / m_cfg.clusteringWeighZ, pT / m_cfg.clusteringWeighPt}); + // Fill the NN input - networkInput.row(NNindex) << pT, eta, phi, seeds[i].sp()[0]->x(), + networkInput.row(i) << pT, eta, phi, seeds[i].sp()[0]->x(), seeds[i].sp()[0]->y(), seeds[i].sp()[0]->z(), seeds[i].sp()[1]->x(), seeds[i].sp()[1]->y(), seeds[i].sp()[1]->z(), seeds[i].sp()[2]->x(), seeds[i].sp()[2]->y(), seeds[i].sp()[2]->z(), seeds[i].z(), @@ -91,7 +90,7 @@ ActsExamples::ProcessCode ActsExamples::SeedFilterMLAlgorithm::execute( TrackParametersContainer outputTrackParameters; outputTrackParameters.reserve(goodSeed.size()); - for (auto&& i : goodSeed) { + for (auto i : goodSeed) { outputSeeds.push_back(seeds[i]); outputTrackParameters.push_back(params[i]); } diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_perf.py b/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_perf.py index 574b9a55389..1f1ba26d7c7 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_perf.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/ambiguity_solver_perf.py @@ -101,7 +101,7 @@ def readDataSet(CKS_files: list[str]) -> pd.DataFrame: ].index.nunique() nb_reco_track += resolvedEvent.shape[0] -# Compute the different efficiencies +# Compute the different efficiencies for ML for trackEvent, resolvedEvent in zip(data_ML_track, data_ML_resolved): # Merge two dataFrames and add indicator column merged_ML = pd.merge( @@ -154,11 +154,11 @@ def readDataSet(CKS_files: list[str]) -> pd.DataFrame: print("Fake rate: ", 100 * nb_reco_fake / nb_reco_track, " %") print("===computed efficiencies ML===") -print("nb particles : ", nb_part) -print("nb good match : ", nb_good_match_ML) -print("nb particle reco : ", nb_reco_part_ML) -print("nb track reco : ", nb_reco_track_ML) -print("Efficiency (good track) : ", 100 * nb_good_match_ML / nb_part, " %") -print("Efficiency (particle reco) : ", 100 * nb_reco_part_ML / nb_part, " %") +print("nb particles: ", nb_part) +print("nb good match: ", nb_good_match_ML) +print("nb particle reco: ", nb_reco_part_ML) +print("nb track reco: ", nb_reco_track_ML) +print("Efficiency (good track): ", 100 * nb_good_match_ML / nb_part, " %") +print("Efficiency (particle reco): ", 100 * nb_reco_part_ML / nb_part, " %") print("duplicate rate: ", 100 * nb_reco_duplicate_ML / nb_reco_track_ML, " %") print("Fake rate: ", 100 * nb_reco_fake_ML / nb_reco_track_ML, " %") diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py b/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py index e800e940ee7..9205aea996f 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py @@ -16,8 +16,8 @@ Normalise, ) -avg_mean = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] -avg_sdv = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +avg_mean = [0] * 14 +avg_sdv = [0] * 14 events = 0 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") diff --git a/docs/plugins/MLAlgorithms.md b/docs/plugins/MLAlgorithms.md index 53fa366c5f6..39e2121b9a4 100644 --- a/docs/plugins/MLAlgorithms.md +++ b/docs/plugins/MLAlgorithms.md @@ -1,19 +1,19 @@ # Machine learning algorithms ACTS allows you to replace some components of the tracking chain with machine-learning solutions. -A replacement for the ambiguity solver and a filtering algorithm for seed are available for now, but when others are implemented, they will be explained here. +A replacement for the ambiguity solver and a filtering algorithm for seeds are available for now, but when others are implemented, they will be explained here. ## Onnx plugin -To be able to perform neural network (NN) models' inferences in C++, ACTS uses [onnxruntime](https://onnxruntime.ai/). An interface to use it has been implemented as an ACTS plugin; to use it, you will need to compile ACTS with the `ACTS_PLUGIN_ONNX` option. For more details on how to export your model to onnx, please see the documentation on their [website](https://onnxruntime.ai/docs/) +To be able to perform neural network (NN) models' inferences in C++, ACTS uses [ONNX Runtime](https://onnxruntime.ai/). An interface to use ONNX Runtime has been implemented as an ACTS plugin; to use it, you will need to compile ACTS with the `ACTS_PLUGIN_ONNX` option. For more details on how to export your model to ONNX, please see the documentation on their [website](https://onnxruntime.ai/docs/). ### OnnxRuntimeBase -The `OnnxRuntimeBase` class implement the inference of a standard MLP via Onnx and just requires a link to the `.onnx` file containing the model one wants to use. Please note that the implementation of the inference in ACTS only works with a single input node and a single output node. The inference can be performed in single entry and batch modes. In single entry mode, the `runONNXInference` method takes a single vector as an entry, each element of the vector corresponding to one of the input features of your network. In batch mode, the input is an `Eigen::Array` with the columns corresponding to the input features and rows to the different batch inputs. +The `OnnxRuntimeBase` class implements the inference of a standard MLP via ONNX. The class just requires a link to the `.onnx` file containing the model one wants to use. Please note, that the implementation of the inference in ACTS only works with a single input node and a single output node. The inference can be performed in single entry and batch modes. In single entry mode, the `runONNXInference` method takes a single vector as an entry, each element of the vector corresponding to one of the input features of your network. In batch mode, the input is an `Eigen::Array` with the columns corresponding to the input features and rows to the different batch inputs. ## AmbiguityResolutionMLAlgorithm -The goal of the ambiguity solver is to remove duplicated and fake tracks that remain after the CKF. To perform this cleaning, this algorithm works in three steps : +The goal of the ambiguity solver is to remove duplicated and fake tracks that remain after the CKF. To perform this cleaning, this algorithm works in three steps: - Clustering: tracks are clustered together, one cluster ~ one truth particle - Ranking: tracks in each cluster are scored, the best one is kept @@ -35,15 +35,17 @@ Running the ACTS Greedy Solver after the ML Solver can be helpful in some cases; ### How to use -The ML-based Ambiguity solver comes with a pre-trained model to be used with the ODD. Using it is extremely simple; just call the `full_chain_odd.py` with the `--MLSolver` option. If you want to try this solver with another detector, a few more steps are needed. First, you need to train a model. As an input, you will need the multitrajectory output from the CKF (run a full chain up to the CKF, then use the `CSVWriter`). At least 100 ttbar events with 200 PU are needed (1000 would be ideal). You can then run `Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py ` on our dataset, 2/3 of the data should be used for the training and 1/3 for the validation. You will receive a `duplicateClassifier.onnx` file as an output, which can now be used as an input for the `AmbiguityResolutionMLAlgorithm` with your detector. +The ML-based Ambiguity solver comes with a pre-trained model to be used with the ODD. Using it is extremely simple; just call the `full_chain_odd.py` with the `--MLSolver` option. If you want to try this solver with another detector, a few more steps are needed. First, you need to train a model. As an input, you will need the multitrajectory output from the CKF (run a full chain up to the CKF, then use the `CSVWriter`). At least 100 ttbar events with 200 PU are needed (1000 would be ideal). You can then run `Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py` on our dataset, 2/3 of the data should be used for the training and 1/3 for the validation. You will receive a `duplicateClassifier.onnx` file as an output, which can now be used as an input for the `AmbiguityResolutionMLAlgorithm` with your detector. -Additionally, two other Python files are present with the training. One called `ambiguity_solver_full_chain.py` performs the same job as the chain we presented here but in Python using CSV files in input. The other one, `ambiguity_solver_perf.py`, can be used to study the performance of the ambiguity solver (ML and not) and also takes CSV files as input. +Additionally, two other Python files are present with the training. +- `ambiguity_solver_full_chain.py` performs the same job as the chain we presented here but in Python using CSV files as input. +- `ambiguity_solver_perf.py` can be used to study the performance of the ambiguity solver (with and without ML) and also takes CSV files as input. ## MLSeedFiltering -While the ambiguity solver can significantly improve the cleanliness of the output removing both duplicate and fake from the final collection, it doesn't help with the speed of the full tracking chain. The MLSeedFiltering aims to use a NN to determine which seed will lead to the best trajectory before performing the track reconstruction. We can select the seed used in track reconstruction based on the NN score. Depending on the full tracking setup, this might help us improve the track reconstruction speed, the track reconstructed quality, or both. In the case of the ODD, a speed improvement of x10 was observed in track reconstruction speed for ttbar, mu=200 G4+Pythia8 events. +While the ambiguity solver can significantly improve the cleanliness of the output removing both duplicates and fakes from the final collection, it doesn't help with the speed of the full tracking chain. The MLSeedFiltering aims to use a NN to determine which seed will lead to the best trajectory before performing the track reconstruction. We can select the seed used in track reconstruction based on the NN score. Depending on the full tracking setup, this might help us improve the track reconstruction speed, the track reconstructed quality, or both. In the case of the ODD, a speed improvement of x10 was observed in track reconstruction speed for ttbar, mu=200 G4+Pythia8 events. -It uses the same three steps as the ML ambiguity solver but with seed instead of tracks : +It uses the same three steps as the ML ambiguity solver but with seed instead of tracks: - Clustering: seeds are clustered together, one cluster ~ one truth particle - Ranking: seeds in each cluster are scored, and the best one is kept @@ -51,7 +53,7 @@ It uses the same three steps as the ML ambiguity solver but with seed instead of ### Clustering -The clustering is implemented with the `dbscanSeedClustering` function. Its input is a vector of vector containing the seed parameters that will be used in the clustering. For the clustering itself, we used a 4D DBSCAN clustering algorithm, a density-based clustering technique. All the seeds are represented as points in a 4D space using their value of $\phi$, $\eta$, $z_{0}$, $p_{T}$ and are clustered together based on their proximity. The output of the clustering is a vector of vector of int; each element corresponds to one cluster with the inner vector listing the ID of all the seeds in that cluster. +The clustering is implemented with the `dbscanSeedClustering` function. Its input is a vector of vectors containing the seed parameters that will be used in the clustering. For the clustering itself, we used a 4D DBSCAN clustering algorithm, a density-based clustering technique. All the seeds are represented as points in a 4D space using their value of $\phi$, $\eta$, $z_{0}$, $p_{T}$ and are clustered together based on their proximity. The output of the clustering is a vector of vectors of ints; each element corresponds to one cluster with the inner vector listing the ID of all the seeds in that cluster. ### Ranking From c70cce95920b467cb4294216c681de93fd736824 Mon Sep 17 00:00:00 2001 From: Corentin ALLAIRE <62873125+Corentin-Allaire@users.noreply.github.com> Date: Thu, 14 Dec 2023 15:39:40 +0100 Subject: [PATCH 27/31] Apply suggestions from code review More sugestions Co-authored-by: Alexander J. Pfleger <70842573+AJPfleger@users.noreply.github.com> --- .../seed_filter_full_chain.py | 72 ++++++------------- 1 file changed, 21 insertions(+), 51 deletions(-) diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py b/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py index 622f973b00b..9981e659f91 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py @@ -36,7 +36,6 @@ def prepareInferenceData(data: pd.DataFrame) -> tuple[np.ndarray, np.ndarray]: # Remove truth and useless variable target_column = "good/duplicate/fake" # Separate the truth from the input variables - y = LabelEncoder().fit(data[target_column]).transform(data[target_column]) input = data.drop( columns=[ @@ -100,14 +99,14 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: CKF_files = sorted(glob.glob("odd_output" + "/event0000000[0-1][0-9]-seed_matched.csv")) data = readDataSet(CKF_files) -# Data of each events after clustering +# Data of each event after clustering clusteredData = [] -# data of each events after ambiguity resolution +# Data of each event after ambiguity resolution cleanedData = [] t1 = time.time() -# Cluster togather tracks belonging to the same particle +# Cluster tracks belonging to the same particle for event in data: clustered = clusterSeed(event) clusteredData.append(clustered) @@ -158,7 +157,7 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: plotDF2 = pd.DataFrame() -# Create histogram filled with the number of seed per cluster +# Create histogram filled with the number of seeds per cluster for event in plotData: event["nb_seed"] = 0 event["nb_fake"] = 0 @@ -170,19 +169,19 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: event["nb_seed_removed"] = 0 event["particleId"] = event.index event["nb_seed"] = event.groupby(["cluster"])["cluster"].transform("size") - # Create histogram filled with the number of fake seed per cluster + # Create histogram filled with the number of fake seeds per cluster event.loc[event["good/duplicate/fake"] == "fake", "nb_fake"] = ( event.loc[event["good/duplicate/fake"] == "fake"] .groupby(["cluster"])["cluster"] .transform("size") ) - # Create histogram filled with the number of duplicate seed per cluster + # Create histogram filled with the number of duplicate seeds per cluster event.loc[event["good/duplicate/fake"] == "duplicate", "nb_duplicate"] = ( event.loc[event["good/duplicate/fake"] == "duplicate"] .groupby(["cluster"])["cluster"] .transform("size") ) - # Create histogram filled with the number of good seed per cluster + # Create histogram filled with the number of good seeds per cluster event.loc[event["good/duplicate/fake"] == "good", "nb_good"] = ( event.loc[event["good/duplicate/fake"] == "good"] .groupby(["cluster"])["cluster"] @@ -319,7 +318,7 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: # ================================================================== # Plotting -# Combine the events together to have a better statistics +# Combine the events to have a better statistic clusteredDataPlots = pd.concat(clusteredData) cleanedDataPlots = pd.concat(cleanedData) @@ -329,48 +328,19 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: # Plot the average score distribution for each type of track plt.figure() -weightsGood = np.ones_like( - cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "good"]["score"] -) / len( - cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "good"]["score"] -) -plt.hist( - cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "good"]["score"], - bins=100, - weights=weightsGood, - alpha=0.65, - label="good", -) -weightsDuplicate = np.ones_like( - cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "duplicate"][ - "score" - ] -) / len( - cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "duplicate"][ - "score" - ] -) -plt.hist( - cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "duplicate"][ - "score" - ], - bins=100, - weights=weightsDuplicate, - alpha=0.65, - label="duplicate", -) -weightsFake = np.ones_like( - cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "fake"]["score"] -) / len( - cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "fake"]["score"] -) -plt.hist( - cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == "fake"]["score"], - bins=100, - weights=weightsFake, - alpha=0.65, - label="fake", -) +for tag in ["good", "duplicate", "fake"]: + weights = np.ones_like( + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == tag]["score"] + ) / len( + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == tag]["score"] + ) + plt.hist( + cleanedDataPlots.loc[cleanedDataPlots["good/duplicate/fake"] == tag]["score"], + bins=100, + weights=weights, + alpha=0.65, + label=tag, + ) plt.legend() plt.xlabel("score") plt.ylabel("Fraction of good/duplicate/fake tracks") From 52a2d2ac082f927e1725eba7a04575994a8deb75 Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Thu, 14 Dec 2023 15:41:38 +0100 Subject: [PATCH 28/31] fix doc --- docs/plugins/MLAlgorithms.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/plugins/MLAlgorithms.md b/docs/plugins/MLAlgorithms.md index 53fa366c5f6..7b36e2e3e6c 100644 --- a/docs/plugins/MLAlgorithms.md +++ b/docs/plugins/MLAlgorithms.md @@ -61,4 +61,4 @@ At this step, we have multiple clusters of seeds. We use a NN to compute a score The ML-based Ambiguity solver comes with a pre-trained model to be used with the ODD. Using it is extremely simple; just call the `full_chain_odd.py` with the `--MLSeedFilter` option. If you want to try this solver with another detector, a few more steps are needed. First, you need to train a model. As an input, you will need the seeding and multitrajectory output from the CKF (run a full chain up to the CKF, then use the `CSVWriter` for both the seeding and the CKF). At least 1000 ttbar events with 200 PU are needed. First, we need to match the seed and the corresponding tracks together; for that, we can run `Examples/Scripts/Python/MLAmbiguityResolution/match_good_track-seed.py`. The network can then be trained with: `Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py ` on our dataset, 2/3 of the data should be used for the training and 1/3 for the validation. You will receive a `seedduplicateClassifier.onnx` file as an output, which can now be used as an input for the `AmbiguityResolutionMLAlgorithm` with your detector. -Additionally, two other Python files are present with the training. One called `seed_filter_full_chain.py` performs the same job as the chain we presented here, but in Python, using CSV files in the input, this will plot many helpful distributions that will help you understand how the Filter is performing. +Additionally, another Python files is present with the training: `seed_filter_full_chain.py` performs the same job as the chain we presented here, but in Python, using CSV files in the input, this will plot many helpful distributions that will help you understand how the Filter is performing. From 3018e47b0b76e888a4994406238e54d6810959f2 Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Thu, 14 Dec 2023 15:55:18 +0100 Subject: [PATCH 29/31] format --- .../seed_filter_full_chain.py | 28 +++++++++---------- .../seed_solver_network.py | 3 ++ .../train_ambiguity_solver.py | 10 +++---- .../train_seed_solver.py | 20 ++++++------- .../Acts/Plugins/Onnx/SeedClassifier.hpp | 6 ++-- 5 files changed, 35 insertions(+), 32 deletions(-) diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py b/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py index 9981e659f91..58aae10821e 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/seed_filter_full_chain.py @@ -287,18 +287,18 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: tend = time.time() print("===Initial efficiencies===") -print("nb particles : ", nb_part) -print("nb track : ", nb_track) +print("nb particles: ", nb_part) +print("nb track: ", nb_track) print("duplicate rate: ", 100 * nb_duplicate / nb_track, " %") print("Fake rate: ", 100 * nb_fake / nb_track, " %") print("===computed efficiencies===") -print("nb particles : ", nb_part) -print("nb good match : ", nb_good_match) -print("nb particle reco : ", nb_reco_part) -print("nb track reco : ", nb_reco_track) -print("Efficiency (good track) : ", 100 * nb_good_match / nb_part, " %") -print("Efficiency (particle reco) : ", 100 * nb_reco_part / nb_part, " %") +print("nb particles: ", nb_part) +print("nb good match: ", nb_good_match) +print("nb particle reco: ", nb_reco_part) +print("nb track reco: ", nb_reco_track) +print("Efficiency (good track): ", 100 * nb_good_match / nb_part, " %") +print("Efficiency (particle reco): ", 100 * nb_reco_part / nb_part, " %") print( "duplicate rate: ", 100 * ((nb_good_match + nb_reco_duplicate) - nb_reco_part) / nb_reco_track, @@ -307,12 +307,12 @@ def renameCluster(clusterarray: np.ndarray) -> np.ndarray: print("Fake rate: ", 100 * nb_reco_fake / nb_reco_track, " %") print("===computed speed===") -print("Load : ", (t1 - start) * 1000 / len(CKF_files), "ms") -print("Clustering : ", (t2 - t1) * 1000 / len(CKF_files), "ms") -print("Inference : ", (t4 - t3) * 1000 / len(CKF_files), "ms") -print("Perf : ", (tend - t4) * 1000 / len(CKF_files), "ms") -print("tot : ", (t4 - start) * 1000 / len(CKF_files), "ms") -print("Seed filter : ", (t4 - t1) * 1000 / len(CKF_files), "ms") +print("Load: ", (t1 - start) * 1000 / len(CKF_files), "ms") +print("Clustering: ", (t2 - t1) * 1000 / len(CKF_files), "ms") +print("Inference: ", (t4 - t3) * 1000 / len(CKF_files), "ms") +print("Perf: ", (tend - t4) * 1000 / len(CKF_files), "ms") +print("tot: ", (t4 - start) * 1000 / len(CKF_files), "ms") +print("Seed filter: ", (t4 - t1) * 1000 / len(CKF_files), "ms") # ================================================================== diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py b/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py index d4f39d7bc30..687b923c0bf 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py @@ -14,8 +14,11 @@ def prepareDataSet(data: pd.DataFrame) -> pd.DataFrame: @param[in] data: input DataFrame containing 1 event @return: Formatted DataFrame """ + print("TEST") data = data + print(data) data = data.sort_values("good/duplicate/fake", ascending=False) + print(data) # Sort by particle ID data = data.sort_values("particleId") # Set truth particle ID as index diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py b/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py index 36cde1ebbbe..c36972ec38b 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/train_ambiguity_solver.py @@ -222,14 +222,14 @@ def train( val_batch = int(len(batch) * (1 - validation)) # Loop over all the epoch for epoch in range(epochs): - print("Epoch : ", epoch, " / ", epochs) + print("Epoch: ", epoch, " / ", epochs) loss = 0.0 nb_part = 0.0 nb_good_match = 0.0 # Loop over all the network over the training batch nb_part, nb_good_match, loss = scoringBatch(batch[:val_batch], Optimiser=opt) - print("Loss/train : ", loss, " Eff/train : ", nb_good_match / nb_part) + print("Loss/train: ", loss, " Eff/train: ", nb_good_match / nb_part) writer.add_scalar("Loss/train", loss, epoch) writer.add_scalar("Eff/train", nb_good_match / nb_part, epoch) @@ -238,7 +238,7 @@ def train( nb_part, nb_good_match, loss = scoringBatch(batch[val_batch:]) writer.add_scalar("Loss/val", loss, epoch) writer.add_scalar("Eff/val", nb_good_match / nb_part, epoch) - print("Loss/val : ", loss, " Eff/val : ", nb_good_match / nb_part) + print("Loss/val: ", loss, " Eff/val: ", nb_good_match / nb_part) writer.close() return duplicateClassifier @@ -329,6 +329,6 @@ def train( if max_match == 1: nb_good_match += 1 -print("nb particles : ", nb_part) -print("nb good match : ", nb_good_match) +print("nb particles: ", nb_part) +print("nb good match: ", nb_good_match) print("Efficiency: ", 100 * nb_good_match / nb_part, " %") diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py b/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py index 9205aea996f..f3f8b9930df 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/train_seed_solver.py @@ -250,7 +250,7 @@ def train( val_batch = int(len(batch) * (1 - validation)) # Loop over all the epoch for epoch in range(epochs): - print("Epoch : ", epoch, " / ", epochs) + print("Epoch: ", epoch, " / ", epochs) loss = 0.0 nb_part = 0.0 nb_good_match = 0.0 @@ -260,11 +260,11 @@ def train( batch[:val_batch], Optimiser=opt ) print( - "Loss/train : ", + "Loss/train: ", loss, - " Eff/train : ", + " Eff/train: ", nb_good_match / nb_part, - " Eff_best/train : ", + " Eff_best/train: ", nb_best_match / nb_part, ) writer.add_scalar("Loss/train", loss, epoch) @@ -280,11 +280,11 @@ def train( writer.add_scalar("Eff/val", nb_good_match / nb_part, epoch) writer.add_scalar("Eff_best/train", nb_best_match / nb_part, epoch) print( - "Loss/val : ", + "Loss/val: ", loss, - " Eff/val : ", + " Eff/val: ", nb_good_match / nb_part, - " Eff_best/val : ", + " Eff_best/val: ", nb_best_match / nb_part, ) @@ -386,8 +386,8 @@ def train( max_score = pred max_match = truth -print("nb particles : ", nb_part) -print("nb good match : ", nb_good_match) -print("nb best match : ", nb_best_match) +print("nb particles: ", nb_part) +print("nb good match: ", nb_good_match) +print("nb best match: ", nb_best_match) print("Efficiency: ", 100 * nb_good_match / nb_part, " %") print("Efficiency_best: ", 100 * nb_best_match / nb_part, " %") diff --git a/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp b/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp index 6daa4f410e7..77dfef6c51d 100644 --- a/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp +++ b/Plugins/Onnx/include/Acts/Plugins/Onnx/SeedClassifier.hpp @@ -40,10 +40,10 @@ class SeedClassifier { /// Select the seed associated with each cluster based on the score vector /// - /// @param clusters is a vector of clusters, each cluster correspond to a vector of seed ID + /// @param clusters is a vector of clusters, each cluster corresponds to a vector of seedIDs /// @param outputTensor is the score vector obtained from inferScores. - /// @param minSeedScore is the minimum score a seed need to be selected - /// @return a vector of seedID corresponding tho the good seeds + /// @param minSeedScore is the minimum score a seed needs to be selected + /// @return a vector of seedIDs corresponding tho the good seeds std::vector seedSelection( std::vector>& clusters, std::vector>& outputTensor, From d94a63f262c193202d74d343494b7b9bc5b0540f Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Thu, 14 Dec 2023 16:21:23 +0100 Subject: [PATCH 30/31] remove data=data --- .../Scripts/Python/MLAmbiguityResolution/seed_solver_network.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py b/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py index 687b923c0bf..d7985198cf2 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py @@ -15,7 +15,7 @@ def prepareDataSet(data: pd.DataFrame) -> pd.DataFrame: @return: Formatted DataFrame """ print("TEST") - data = data + # data = data print(data) data = data.sort_values("good/duplicate/fake", ascending=False) print(data) From 92973953525c169c394e2033927b9428c4907630 Mon Sep 17 00:00:00 2001 From: Corentin Allaire Date: Thu, 14 Dec 2023 16:51:29 +0100 Subject: [PATCH 31/31] remove print --- .../Python/MLAmbiguityResolution/seed_solver_network.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py b/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py index d7985198cf2..36de3db37f8 100644 --- a/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py +++ b/Examples/Scripts/Python/MLAmbiguityResolution/seed_solver_network.py @@ -14,11 +14,6 @@ def prepareDataSet(data: pd.DataFrame) -> pd.DataFrame: @param[in] data: input DataFrame containing 1 event @return: Formatted DataFrame """ - print("TEST") - # data = data - print(data) - data = data.sort_values("good/duplicate/fake", ascending=False) - print(data) # Sort by particle ID data = data.sort_values("particleId") # Set truth particle ID as index