Skip to content

Commit 09d0883

Browse files
vepadulanovepadulano
committed
Apply clang-format fixes to data loader C++ files
1 parent d9acb6a commit 09d0883

3 files changed

Lines changed: 68 additions & 74 deletions

File tree

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

Lines changed: 52 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -50,7 +50,7 @@ template <typename... Args>
5050
class RBatchGenerator {
5151
private:
5252
std::vector<std::string> fCols;
53-
std::vector<std::size_t> fVecSizes;
53+
std::vector<std::size_t> fVecSizes;
5454
// clang-format on
5555
std::size_t fChunkSize;
5656
std::size_t fMaxChunks;
@@ -60,17 +60,17 @@ private:
6060

6161
float fValidationSplit;
6262

63-
std::unique_ptr<RDatasetLoader<Args...>> fDatasetLoader;
63+
std::unique_ptr<RDatasetLoader<Args...>> fDatasetLoader;
6464
std::unique_ptr<RChunkLoader<Args...>> fChunkLoader;
6565
std::unique_ptr<RBatchLoader> fTrainingBatchLoader;
6666
std::unique_ptr<RBatchLoader> fValidationBatchLoader;
6767
std::unique_ptr<RSampler> fTrainingSampler;
6868
std::unique_ptr<RSampler> fValidationSampler;
6969

7070
std::unique_ptr<RFlat2DMatrixOperators> fTensorOperators;
71-
71+
7272
std::vector<ROOT::RDF::RNode> f_rdfs;
73-
73+
7474
std::unique_ptr<std::thread> fLoadingThread;
7575

7676
std::size_t fTrainingChunkNum;
@@ -83,8 +83,8 @@ private:
8383
bool fLoadEager;
8484
std::string fSampleType;
8585
float fSampleRatio;
86-
bool fReplacement;
87-
86+
bool fReplacement;
87+
8888
bool fIsActive{false}; // Whether the loading thread is active
8989
bool fUseWholeFile;
9090

@@ -104,10 +104,10 @@ private:
104104

105105
RFlat2DMatrix fTrainingDataset;
106106
RFlat2DMatrix fValidationDataset;
107-
107+
108108
RFlat2DMatrix fSampledTrainingDataset;
109109
RFlat2DMatrix fSampledValidationDataset;
110-
110+
111111
RFlat2DMatrix fTrainTensor;
112112
RFlat2DMatrix fTrainChunkTensor;
113113

@@ -124,7 +124,7 @@ public:
124124

125125
: f_rdfs(rdfs),
126126
fCols(cols),
127-
fVecSizes(vecSizes),
127+
fVecSizes(vecSizes),
128128
fChunkSize(chunkSize),
129129
fBlockSize(blockSize),
130130
fBatchSize(batchSize),
@@ -140,57 +140,56 @@ public:
140140
fUseWholeFile(maxChunks == 0)
141141
{
142142
fTensorOperators = std::make_unique<RFlat2DMatrixOperators>(fShuffle, fSetSeed);
143-
143+
144144
if (fLoadEager) {
145145
fDatasetLoader = std::make_unique<RDatasetLoader<Args...>>(f_rdfs, fValidationSplit, fCols, fVecSizes,
146-
vecPadding, fShuffle, fSetSeed);
146+
vecPadding, fShuffle, fSetSeed);
147147
// split the datasets and extract the training and validation datasets
148148
fDatasetLoader->SplitDatasets();
149149

150150
if (fSampleType == "") {
151151
fDatasetLoader->ConcatenateDatasets();
152-
152+
153153
fTrainingDataset = fDatasetLoader->GetTrainingDataset();
154-
fValidationDataset = fDatasetLoader->GetValidationDataset();
155-
154+
fValidationDataset = fDatasetLoader->GetValidationDataset();
155+
156156
fNumTrainingEntries = fDatasetLoader->GetNumTrainingEntries();
157157
fNumValidationEntries = fDatasetLoader->GetNumValidationEntries();
158158
}
159159

160160
else {
161161
fTrainingDatasets = fDatasetLoader->GetTrainingDatasets();
162-
fValidationDatasets = fDatasetLoader->GetValidationDatasets();
163-
162+
fValidationDatasets = fDatasetLoader->GetValidationDatasets();
163+
164164
fTrainingSampler = std::make_unique<RSampler>(fTrainingDatasets, fSampleType, fSampleRatio, fReplacement,
165165
fShuffle, fSetSeed);
166-
fValidationSampler = std::make_unique<RSampler>(fValidationDatasets, fSampleType, fSampleRatio, fReplacement,
167-
fShuffle, fSetSeed);
166+
fValidationSampler = std::make_unique<RSampler>(fValidationDatasets, fSampleType, fSampleRatio,
167+
fReplacement, fShuffle, fSetSeed);
168168

169-
fNumTrainingEntries = fTrainingSampler->GetNumEntries();
169+
fNumTrainingEntries = fTrainingSampler->GetNumEntries();
170170
fNumValidationEntries = fValidationSampler->GetNumEntries();
171171
}
172172
}
173173

174174
else {
175-
fChunkLoader =
176-
std::make_unique<RChunkLoader<Args...>>(f_rdfs[0], fChunkSize, fBlockSize, fValidationSplit,
177-
fCols, fVecSizes, vecPadding, fShuffle, fSetSeed);
175+
fChunkLoader = std::make_unique<RChunkLoader<Args...>>(f_rdfs[0], fChunkSize, fBlockSize, fValidationSplit,
176+
fCols, fVecSizes, vecPadding, fShuffle, fSetSeed);
178177

179178
// split the dataset into training and validation sets
180179
fChunkLoader->SplitDataset();
181180

182181
fNumTrainingEntries = fChunkLoader->GetNumTrainingEntries();
183-
fNumValidationEntries = fChunkLoader->GetNumValidationEntries();
182+
fNumValidationEntries = fChunkLoader->GetNumValidationEntries();
184183

185184
// number of training and validation chunks, calculated in RChunkConstructor
186185
fNumTrainingChunks = fChunkLoader->GetNumTrainingChunks();
187186
fNumValidationChunks = fChunkLoader->GetNumValidationChunks();
188187
}
189188

190-
fTrainingBatchLoader = std::make_unique<RBatchLoader>(fBatchSize, fCols, fVecSizes,
191-
fNumTrainingEntries, fDropRemainder);
192-
fValidationBatchLoader = std::make_unique<RBatchLoader>(fBatchSize, fCols, fVecSizes,
193-
fNumValidationEntries, fDropRemainder);
189+
fTrainingBatchLoader =
190+
std::make_unique<RBatchLoader>(fBatchSize, fCols, fVecSizes, fNumTrainingEntries, fDropRemainder);
191+
fValidationBatchLoader =
192+
std::make_unique<RBatchLoader>(fBatchSize, fCols, fVecSizes, fNumValidationEntries, fDropRemainder);
194193
}
195194

196195
~RBatchGenerator() { DeActivate(); }
@@ -203,7 +202,7 @@ public:
203202
}
204203

205204
fTrainingBatchLoader->DeActivate();
206-
fValidationBatchLoader->DeActivate();
205+
fValidationBatchLoader->DeActivate();
207206

208207
if (fLoadingThread) {
209208
if (fLoadingThread->joinable()) {
@@ -225,7 +224,7 @@ public:
225224
}
226225

227226
fTrainingBatchLoader->Activate();
228-
fValidationBatchLoader->Activate();
227+
fValidationBatchLoader->Activate();
229228
// fLoadingThread = std::make_unique<std::thread>(&RBatchGenerator::LoadChunks, this);
230229
}
231230

@@ -241,10 +240,11 @@ public:
241240

242241
void DeActivateValidationEpoch() { fValidationEpochActive = false; }
243242

244-
/// \brief Create training batches by first loading a chunk (see RChunkLoader) and split it into batches (see RBatchLoader)
243+
/// \brief Create training batches by first loading a chunk (see RChunkLoader) and split it into batches (see
244+
/// RBatchLoader)
245245
void CreateTrainBatches()
246246
{
247-
fTrainingEpochActive = true;
247+
fTrainingEpochActive = true;
248248
if (fLoadEager) {
249249
if (fSampleType == "") {
250250
fTensorOperators->ShuffleTensor(fSampledTrainingDataset, fTrainingDataset);
@@ -253,10 +253,10 @@ public:
253253
else {
254254
fTrainingSampler->Sampler(fSampledTrainingDataset);
255255
}
256-
256+
257257
fTrainingBatchLoader->CreateBatches(fSampledTrainingDataset, 1);
258258
}
259-
259+
260260
else {
261261
fChunkLoader->CreateTrainingChunksIntervals();
262262
fTrainingChunkNum = 0;
@@ -266,10 +266,11 @@ public:
266266
}
267267
}
268268

269-
/// \brief Creates validation batches by first loading a chunk (see RChunkLoader), and then split it into batches (see RBatchLoader)
269+
/// \brief Creates validation batches by first loading a chunk (see RChunkLoader), and then split it into batches
270+
/// (see RBatchLoader)
270271
void CreateValidationBatches()
271272
{
272-
fValidationEpochActive = true;
273+
fValidationEpochActive = true;
273274
if (fLoadEager) {
274275
if (fSampleType == "") {
275276
fTensorOperators->ShuffleTensor(fSampledValidationDataset, fValidationDataset);
@@ -278,7 +279,7 @@ public:
278279
else {
279280
fValidationSampler->Sampler(fSampledValidationDataset);
280281
}
281-
282+
282283
fValidationBatchLoader->CreateBatches(fSampledValidationDataset, 1);
283284
}
284285

@@ -294,28 +295,28 @@ public:
294295
/// \brief Loads a training batch from the queue
295296
RFlat2DMatrix GetTrainBatch()
296297
{
297-
if (!fLoadEager) {
298-
auto batchQueue = fTrainingBatchLoader->GetNumBatchQueue();
299-
300-
// load the next chunk if the queue is empty
301-
if (batchQueue < 1 && fTrainingChunkNum < fNumTrainingChunks) {
302-
fChunkLoader->LoadTrainingChunk(fTrainChunkTensor, fTrainingChunkNum);
303-
std::size_t lastTrainingBatch = fNumTrainingChunks - fTrainingChunkNum;
304-
fTrainingBatchLoader->CreateBatches(fTrainChunkTensor, lastTrainingBatch);
305-
fTrainingChunkNum++;
306-
}
307-
}
308-
// Get next batch if available
309-
return fTrainingBatchLoader->GetBatch();
298+
if (!fLoadEager) {
299+
auto batchQueue = fTrainingBatchLoader->GetNumBatchQueue();
300+
301+
// load the next chunk if the queue is empty
302+
if (batchQueue < 1 && fTrainingChunkNum < fNumTrainingChunks) {
303+
fChunkLoader->LoadTrainingChunk(fTrainChunkTensor, fTrainingChunkNum);
304+
std::size_t lastTrainingBatch = fNumTrainingChunks - fTrainingChunkNum;
305+
fTrainingBatchLoader->CreateBatches(fTrainChunkTensor, lastTrainingBatch);
306+
fTrainingChunkNum++;
307+
}
308+
}
309+
// Get next batch if available
310+
return fTrainingBatchLoader->GetBatch();
310311
}
311312

312313
/// \brief Loads a validation batch from the queue
313314
RFlat2DMatrix GetValidationBatch()
314315
{
315-
if (!fLoadEager) {
316+
if (!fLoadEager) {
316317
auto batchQueue = fValidationBatchLoader->GetNumBatchQueue();
317318

318-
// load the next chunk if the queue is empty
319+
// load the next chunk if the queue is empty
319320
if (batchQueue < 1 && fValidationChunkNum < fNumValidationChunks) {
320321
fChunkLoader->LoadValidationChunk(fValidationChunkTensor, fValidationChunkNum);
321322
std::size_t lastValidationBatch = fNumValidationChunks - fValidationChunkNum;

‎tmva/tmva/inc/TMVA/BatchGenerator/RBatchLoader.hxx‎

Lines changed: 14 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,7 @@ private:
4444
// needed for calculating the total number of batch columns when vectors columns are present
4545
std::vector<std::string> fCols;
4646
std::vector<std::size_t> fVecSizes;
47-
std::size_t fSumVecSizes;
47+
std::size_t fSumVecSizes;
4848
std::size_t fNumColumns;
4949
std::size_t fNumEntries;
5050
bool fDropRemainder;
@@ -53,7 +53,7 @@ private:
5353
std::size_t fNumLeftoverBatches;
5454
std::size_t fNumBatches;
5555
std::size_t fLeftoverBatchSize;
56-
56+
5757
bool fIsActive = false;
5858

5959
std::mutex fBatchLock;
@@ -70,18 +70,14 @@ private:
7070
std::unique_ptr<RFlat2DMatrix> fSecondaryLeftoverBatch;
7171

7272
public:
73-
RBatchLoader(std::size_t batchSize, const std::vector<std::string> &cols, const std::vector<std::size_t> &vecSizes = {},
74-
std::size_t numEntries = 0, bool dropRemainder = false)
75-
: fBatchSize(batchSize),
76-
fCols(cols),
77-
fVecSizes(vecSizes),
78-
fNumEntries(numEntries),
79-
fDropRemainder(dropRemainder)
73+
RBatchLoader(std::size_t batchSize, const std::vector<std::string> &cols,
74+
const std::vector<std::size_t> &vecSizes = {}, std::size_t numEntries = 0, bool dropRemainder = false)
75+
: fBatchSize(batchSize), fCols(cols), fVecSizes(vecSizes), fNumEntries(numEntries), fDropRemainder(dropRemainder)
8076
{
8177

8278
fSumVecSizes = std::accumulate(fVecSizes.begin(), fVecSizes.end(), 0);
8379
fNumColumns = fCols.size() + fSumVecSizes - fVecSizes.size();
84-
80+
8581
if (fBatchSize == 0) {
8682
fBatchSize = fNumEntries;
8783
}
@@ -98,10 +94,9 @@ public:
9894
else {
9995
fNumBatches = fNumFullBatches + fNumLeftoverBatches;
10096
}
101-
97+
10298
fPrimaryLeftoverBatch = std::make_unique<RFlat2DMatrix>();
10399
fSecondaryLeftoverBatch = std::make_unique<RFlat2DMatrix>();
104-
105100
}
106101

107102
public:
@@ -158,8 +153,7 @@ public:
158153
/// \brief Creating the batches from a chunk and add them to the queue.
159154
/// \param[in] chunkTensor Tensor with the data from the chunk
160155
/// \param[in] lastbatch Check if the batch in the chunk is the last one
161-
void
162-
CreateBatches(RFlat2DMatrix &chunkTensor, std::size_t lastbatch)
156+
void CreateBatches(RFlat2DMatrix &chunkTensor, std::size_t lastbatch)
163157
{
164158
std::size_t ChunkSize = chunkTensor.GetRows();
165159
std::size_t NumCols = chunkTensor.GetCols();
@@ -194,8 +188,8 @@ public:
194188
// copy LeftoverBatch to end of fPrimaryLeftoverBatch and add it to the batch vector
195189
if (emptySlots == LeftoverBatchSize) {
196190
auto copy = std::make_unique<RFlat2DMatrix>(fBatchSize, fNumColumns);
197-
std::copy(fPrimaryLeftoverBatch->GetData(),
198-
fPrimaryLeftoverBatch->GetData() + (fBatchSize * fNumColumns), copy->GetData());
191+
std::copy(fPrimaryLeftoverBatch->GetData(), fPrimaryLeftoverBatch->GetData() + (fBatchSize * fNumColumns),
192+
copy->GetData());
199193
batches.emplace_back(std::move(copy));
200194

201195
// reset fPrimaryLeftoverBatch and fSecondaryLeftoverBatch
@@ -214,13 +208,12 @@ public:
214208
// copy the last part of LeftoverBatch to the end of fSecondaryLeftoverBatch
215209
fSecondaryLeftoverBatch->Resize(LeftoverBatchSize - emptySlots, NumCols);
216210
std::copy(LeftoverBatch.GetData() + (emptySlots * NumCols),
217-
LeftoverBatch.GetData() + (LeftoverBatchSize * NumCols),
218-
fSecondaryLeftoverBatch->GetData());
211+
LeftoverBatch.GetData() + (LeftoverBatchSize * NumCols), fSecondaryLeftoverBatch->GetData());
219212

220213
// add fPrimaryLeftoverBatch to the batch vector
221214
auto copy = std::make_unique<RFlat2DMatrix>(fBatchSize, fNumColumns);
222-
std::copy(fPrimaryLeftoverBatch->GetData(),
223-
fPrimaryLeftoverBatch->GetData() + (fBatchSize * fNumColumns), copy->GetData());
215+
std::copy(fPrimaryLeftoverBatch->GetData(), fPrimaryLeftoverBatch->GetData() + (fBatchSize * fNumColumns),
216+
copy->GetData());
224217
batches.emplace_back(std::move(copy));
225218

226219
// exchange fPrimaryLeftoverBatch and fSecondaryLeftoverBatch
@@ -252,7 +245,7 @@ public:
252245

253246
std::size_t GetNumBatches() { return fNumBatches; }
254247
std::size_t GetNumEntries() { return fNumEntries; }
255-
std::size_t GetNumRemainderRows() { return fLeftoverBatchSize; }
248+
std::size_t GetNumRemainderRows() { return fLeftoverBatchSize; }
256249
std::size_t GetNumBatchQueue() { return fBatchQueue.size(); }
257250
};
258251

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -180,7 +180,7 @@ struct RChunkConstructor {
180180
}
181181

182182
//////////////////////////////////////////////////////////////////////////
183-
/// \brief Creates chunks from the dataset consisting of blocks with the begin and end entry.
183+
/// \brief Creates chunks from the dataset consisting of blocks with the begin and end entry.
184184
void CreateChunksIntervals()
185185
{
186186

@@ -219,7 +219,7 @@ struct RChunkConstructor {
219219
}
220220

221221
//////////////////////////////////////////////////////////////////////////
222-
/// \brief Fills a vector with the size of every chunk from the dataset
222+
/// \brief Fills a vector with the size of every chunk from the dataset
223223
void SizeOfChunks()
224224
{
225225

0 commit comments

Comments
 (0)