#include <Model.h>

Public Member Functions
const BatchStrategy &	getBatchStrategy () const

	Model ()

const std::string &	name () const

template<typename... Outputs, typename... Inputs>
std::tuple< Outputs... >	run (size_t batchSize, Inputs &&... inputs)

void	setBatchRule (size_t batchSize, const std::vector< size_t > &sizes, size_t lastPadding=0)

void	setBatchRule (const std::string &batchRule)

void	setBatchStrategy (const BatchStrategy &strategy)

	~Model ()

Private Member Functions
const BatchRule &	ensureRule (size_t batchSize)

template<typename T >
void	extractBatchOutput (size_t batchSize, size_t batchIndex, size_t resultIndex, std::vector< T > &batchData) const

template<typename T >
void	injectBatchInput (size_t batchSize, size_t batchIndex, size_t argIndex, const std::vector< T > &batchData)

template<typename T >
void	reserveOutput (size_t batchSize, size_t resultIndex, std::vector< std::vector< T >> &data) const

Private Attributes
BatchStrategy	batchStrategy_

std::unique_ptr< W >	wrapper_

Detailed Description

template<class W>
class tfaot::Model< W >

Definition at line 19 of file Model.h.

Constructor & Destructor Documentation

◆ Model()

template<class W >

tfaot::Model< W >::Model ( )

inlineexplicit

Definition at line 22 of file Model.h.

22 : wrapper_(std::make_unique<W>()) {}

tfaot::Model::wrapper_

std::unique_ptr< W > wrapper_

Definition: Model.h:49

◆ ~Model()

template<class W >

tfaot::Model< W >::~Model ( )

inline

Definition at line 25 of file Model.h.

References tfaot::Model< W >::wrapper_.

25 { wrapper_.reset(); };

tfaot::Model::wrapper_

std::unique_ptr< W > wrapper_

Definition: Model.h:49

Member Function Documentation

◆ ensureRule()

template<class W >

const BatchRule & Model::ensureRule ( size_t batchSize )

private

Definition at line 70 of file Model.h.

References HLT_FULL_cff::batchSize.

                                                         {
     // register a default rule if there is none yet for that batch size
     if (!batchStrategy_.hasRule(batchSize)) {
       batchStrategy_.setDefaultRule(batchSize, wrapper_->batchSizes());
     }
     return batchStrategy_.getRule(batchSize);
   }

◆ extractBatchOutput()

template<class W >

template<typename T >

void Model::extractBatchOutput	(	size_t	batchSize,
		size_t	batchIndex,
		size_t	resultIndex,
		std::vector< T > &	batchData
	)		const

private

Definition at line 103 of file Model.h.

References HLT_FULL_cff::batchSize, and submitPVResolutionJobs::count.

                                                                    {
     size_t count = wrapper_->resultCountNoBatch(resultIndex);
     const T* resPtr = wrapper_->template resultData<T>(batchSize, resultIndex) + batchIndex * count;
     batchData.assign(resPtr, resPtr + count);
   }

◆ getBatchStrategy()

template<class W >

const BatchStrategy& tfaot::Model< W >::getBatchStrategy ( ) const

inline

Definition at line 34 of file Model.h.

References tfaot::Model< W >::batchStrategy_.

34 { return batchStrategy_; }

tfaot::Model::batchStrategy_

BatchStrategy batchStrategy_

Definition: Model.h:50

◆ injectBatchInput()

template<class W >

template<typename T >

void Model::injectBatchInput	(	size_t	batchSize,
		size_t	batchIndex,
		size_t	argIndex,
		const std::vector< T > &	batchData
	)

private

Definition at line 86 of file Model.h.

References HLT_FULL_cff::batchSize, filterCSVwithJSON::copy, submitPVResolutionJobs::count, Exception, and mergeVDriftHistosByStation::name.

                                                                  {
     size_t count = wrapper_->argCountNoBatch(argIndex);
     if (batchData.size() != count) {
       throw cms::Exception("InputMismatch")
           << "model '" << name() << "' received " << batchData.size() << " elements for argument " << argIndex
           << ", but " << count << " are expected";
     }
     T* argPtr = wrapper_->template argData<T>(batchSize, argIndex) + batchIndex * count;
     auto beg = batchData.cbegin();
     std::copy(beg, beg + count, argPtr);
   }

◆ name()

template<class W >

const std::string& tfaot::Model< W >::name ( void ) const

inline

Definition at line 28 of file Model.h.

References tfaot::Model< W >::wrapper_.

Referenced by config.CFG::__str__(), and validation.Sample::digest().

28 { return wrapper_->name(); }

tfaot::Model::wrapper_

std::unique_ptr< W > wrapper_

Definition: Model.h:49

◆ reserveOutput()

template<class W >

template<typename T >

void Model::reserveOutput	(	size_t	batchSize,
		size_t	resultIndex,
		std::vector< std::vector< T >> &	data
	)		const

private

Definition at line 80 of file Model.h.

References HLT_FULL_cff::batchSize, and data.

                                                                                                         {
     data.resize(batchSize, std::vector<T>(wrapper_->resultCountNoBatch(resultIndex)));
   }

◆ run()

template<class W >

template<typename... Outputs, typename... Inputs>

std::tuple< Outputs... > Model::run	(	size_t	batchSize,
		Inputs &&...	inputs
	)

Definition at line 114 of file Model.h.

References HLT_FULL_cff::batchSize, cms::cuda::bs, tfaot::createIndexLooper(), Exception, tfaot::BatchRule::getLastPadding(), tfaot::BatchRule::getSize(), mps_fire::i, PixelMapPlotter::inputs, mergeVDriftHistosByStation::name, tfaot::BatchRule::nSizes(), PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, and mkLumiAveragedPlots::tuple.

                                                                          {
     // check number of inputs
     size_t nInputs = sizeof...(Inputs);
     if (nInputs != wrapper_->nArgs()) {
       throw cms::Exception("InputMismatch")
           << "model '" << name() << "' received " << nInputs << " inputs, but " << wrapper_->nArgs() << " are expected";
     }
 
     // check number of outputs
     size_t nOutputs = sizeof...(Outputs);
     if (nOutputs != wrapper_->nResults()) {
       throw cms::Exception("OutputMismatch") << "requested " << nOutputs << " from model '" << name() << "', but "
                                              << wrapper_->nResults() << " are provided";
     }
 
     // get the corresponding batch rule
     const BatchRule& rule = ensureRule(batchSize);
 
     // create a callback that invokes lambdas over all outputs with normal indices
     auto forEachOutput = createIndexLooper<sizeof...(Outputs)>();
 
     // reserve output arrays
     std::tuple<Outputs...> outputs;
     forEachOutput([&](auto resultIndex) { reserveOutput(batchSize, resultIndex, std::get<resultIndex>(outputs)); });
 
     // loop over particular batch sizes, copy input, evaluate and compose the output
     size_t batchOffset = 0;
     size_t nSizes = rule.nSizes();
     for (size_t i = 0; i < nSizes; i++) {
       // get actual model batch size and optional padding
       size_t bs = rule.getSize(i);
       size_t padding = (i == nSizes - 1) ? rule.getLastPadding() : 0;
 
       // fill inputs separately per batch element
       for (size_t batchIndex = 0; batchIndex < bs - padding; batchIndex++) {
         size_t argIndex = 0;
         ([&] { injectBatchInput(bs, batchIndex, argIndex++, inputs[batchOffset + batchIndex]); }(), ...);
       }
 
       // model evaluation
       wrapper_->run(bs);
 
       // fill outputs separately per batch element
       for (size_t batchIndex = 0; batchIndex < bs - padding; batchIndex++) {
         forEachOutput([&](auto resultIndex) {
           extractBatchOutput(bs, batchIndex, resultIndex, std::get<resultIndex>(outputs)[batchOffset + batchIndex]);
         });
       }
 
       batchOffset += bs;
     }
 
     return outputs;
   }

◆ setBatchRule() [1/2]

template<class W >

void tfaot::Model< W >::setBatchRule	(	size_t	batchSize,
		const std::vector< size_t > &	sizes,
		size_t	lastPadding = `0`
	)

inline

Definition at line 37 of file Model.h.

References HLT_FULL_cff::batchSize, tfaot::Model< W >::batchStrategy_, and tfaot::BatchStrategy::setRule().

                                                                                                 {
       batchStrategy_.setRule(BatchRule(batchSize, sizes, lastPadding));
     }