Add comments, remove unused variables and clean up code

Author: martinfoell

bindings/pyroot/pythonizations/python/ROOT/_pythonization/_tmva/_batchgenerator.py

@@ -227,7 +227,6 @@ def __init__(
             block_size,            
             batch_size,
             self.given_columns,
-            self.num_columns,
             max_vec_sizes_list,
             vec_padding,
             validation_split,
@@ -477,6 +476,7 @@ def GetValidationBatch(self) -> Any:
 class LoadingThreadContext:
     def __init__(self, base_generator: BaseGenerator):
         self.base_generator = base_generator
+        # create training batches from the first chunk
         self.base_generator.CreateTrainBatches();
 
     def __enter__(self):
@@ -537,7 +537,6 @@ def last_batch_no_of_rows(self) -> int:
         return self.base_generator.generator.TrainRemainderRows()
 
     def __iter__(self):
-        # batch = self.base_generator.GetTrainBatch()        
 
         self._callable = self.__call__()
 
@@ -546,7 +545,6 @@ def __iter__(self):
     def __next__(self):
         batch = self._callable.__next__()
 
-        # self.base_generator.ActivateTrainingEpoch()                            
         if batch is None:
             raise StopIteration
 
@@ -558,14 +556,11 @@ def __call__(self) -> Any:
         Yields:
             Union[np.NDArray, torch.Tensor]: A batch of data
         """
-        # if (not self.base_generator.is_training_active):
-        #     self.base_generator.DeActivateTrainingEpoch()            
 
         with LoadingThreadContext(self.base_generator):        
             while True:
                 batch = self.base_generator.GetTrainBatch()
                 if batch is None:
-                    # self.base_generator.DeActivateTrainingEpoch()                    
                     break
                 yield self.conversion_function(batch)
 
@@ -574,6 +569,7 @@ def __call__(self) -> Any:
 class LoadingThreadContextVal:
     def __init__(self, base_generator: BaseGenerator):
         self.base_generator = base_generator
+        # create validation batches from the first chunk
         self.base_generator.CreateValidationBatches()        
 
     def __enter__(self):
@@ -639,7 +635,7 @@ def __next__(self):
         return batch
 
     def __call__(self) -> Any:
-        """Start the loading of batches and Yield the results
+        """Start the loading of batches and yield the results
 
         Yields:
             Union[np.NDArray, torch.Tensor]: A batch of data

bindings/pyroot/pythonizations/test/rbatchgenerator_completeness.py

@@ -1,10 +1,9 @@
 import unittest
 import os
 import ROOT
-# from ROOT import RVec
+from ROOT import RVec
 import numpy as np
 from random import randrange
-ROOT.gInterpreter.Declare("#include <ROOT/RVec.hxx>")
 
 class RBatchGeneratorMultipleFiles(unittest.TestCase):
 

tmva/tmva/inc/TMVA/BatchGenerator/RBatchGenerator.hxx

@@ -108,7 +108,7 @@ private:
 
 public:
    RBatchGenerator(ROOT::RDF::RNode &rdf, const std::size_t chunkSize, const std::size_t blockSize,
-                   const std::size_t batchSize, const std::vector<std::string> &cols, const std::size_t numColumns,
+                   const std::size_t batchSize, const std::vector<std::string> &cols,
                    const std::vector<std::size_t> &vecSizes = {}, const float vecPadding = 0.0,
                    const float validationSplit = 0.0, const std::size_t maxChunks = 0, bool shuffle = true,
                    bool dropRemainder = true, const std::size_t setSeed = 0)
@@ -149,9 +149,10 @@ public:
       // split the dataset into training and validation sets
       fChunkLoader->SplitDataset();
 
-      fNumTrainingEntries = fChunkLoader->GetNumTrainingEntries();
-      fNumValidationEntries = fChunkLoader->GetNumValidationEntries();
-
+      // number of training and validation entries after the split
+      fNumValidationEntries = static_cast<std::size_t>(fValidationSplit * fNumEntries);
+      fNumTrainingEntries = fNumEntries - fNumValidationEntries;
+      
       fLeftoverTrainingBatchSize = fNumTrainingEntries % fBatchSize;
       fLeftoverValidationBatchSize = fNumValidationEntries % fBatchSize;
 
@@ -171,6 +172,7 @@ public:
          fNumValidationBatches = fNumFullValidationBatches + fNumLeftoverValidationBatches;
       }
 
+      // number of training and validation chunks, calculated in RChunkConstructor
       fNumTrainingChunks = fChunkLoader->GetNumTrainingChunks();
       fNumValidationChunks = fChunkLoader->GetNumValidationChunks();
 
@@ -228,8 +230,6 @@ public:
    void CreateTrainBatches()
    {
 
-      auto batchQueue = fBatchLoader->GetNumTrainingBatchQueue();
-
       fChunkLoader->CreateTrainingChunksIntervals();
       fTrainingEpochActive = true;
       fTrainingChunkNum = 0;
@@ -244,8 +244,6 @@ public:
    void CreateValidationBatches()
    {
 
-      auto batchQueue = fBatchLoader->GetNumValidationBatchQueue();
-
       fChunkLoader->CreateValidationChunksIntervals();
       fValidationEpochActive = true;
       fValidationChunkNum = 0;

tmva/tmva/inc/TMVA/BatchGenerator/RChunkConstructor.hxx

@@ -1,7 +1,3 @@
-// Author: Dante Niewenhuis, VU Amsterdam 07/2023
-// Author: Kristupas Pranckietis, Vilnius University 05/2024
-// Author: Nopphakorn Subsa-Ard, King Mongkut's University of Technology Thonburi (KMUTT) (TH) 08/2024
-// Author: Vincenzo Eduardo Padulano, CERN 10/2024
 // Author: Martin Føll, University of Oslo (UiO) & CERN 05/2025
 
 /*************************************************************************
@@ -55,9 +51,9 @@ The blocks are defined by their start and end entries, which correspond to posit
 
 struct RChunkConstructor {
    // clang-format on
-   std::size_t fNumEntries;
-   std::size_t fChunkSize;
-   std::size_t fBlockSize;
+   std::size_t fNumEntries{};
+   std::size_t fChunkSize{};
+   std::size_t fBlockSize{};
 
    // size of full and leftover chunks
    std::size_t SizeOfFullChunk;
@@ -102,17 +98,17 @@ struct RChunkConstructor {
    std::size_t NumberOfBlocks;
 
    // pair of start and end entries in the different block types
-   std::vector<std::pair<Long_t, Long_t>> BlockIntervals = {};
+   std::vector<std::pair<Long_t, Long_t>> BlockIntervals;
 
-   std::vector<std::pair<Long_t, Long_t>> FullBlockIntervalsInFullChunks = {};
-   std::vector<std::pair<Long_t, Long_t>> LeftoverBlockIntervalsInFullChunks = {};
+   std::vector<std::pair<Long_t, Long_t>> FullBlockIntervalsInFullChunks;
+   std::vector<std::pair<Long_t, Long_t>> LeftoverBlockIntervalsInFullChunks;
 
-   std::vector<std::pair<Long_t, Long_t>> FullBlockIntervalsInLeftoverChunks = {};
-   std::vector<std::pair<Long_t, Long_t>> LeftoverBlockIntervalsInLeftoverChunks = {};
+   std::vector<std::pair<Long_t, Long_t>> FullBlockIntervalsInLeftoverChunks;
+   std::vector<std::pair<Long_t, Long_t>> LeftoverBlockIntervalsInLeftoverChunks;
 
-   std::vector<std::vector<std::pair<Long_t, Long_t>>> ChunksIntervals = {};
+   std::vector<std::vector<std::pair<Long_t, Long_t>>> ChunksIntervals;
 
-   std::vector<std::size_t> ChunksSizes = {};
+   std::vector<std::size_t> ChunksSizes;
 
    RChunkConstructor(const std::size_t numEntries, const std::size_t chunkSize, const std::size_t blockSize)
       : fNumEntries(numEntries), fChunkSize(chunkSize), fBlockSize(blockSize)