Classes
class	NoThreadPool

class	TBBThreadPool

Typedefs
typedef std::pair< std::string, Tensor >	NamedTensor

typedef std::vector< NamedTensor >	NamedTensorList

Functions
bool	closeSession (Session *&session)

Session *	createSession (SessionOptions &sessionOptions)

Session *	createSession (int nThreads=1)

Session *	createSession (const MetaGraphDef *metaGraphDef, const std::string &exportDir, SessionOptions &sessionOptions)

Session *	createSession (const MetaGraphDef *metaGraphDef, const std::string &exportDir, int nThreads=1)

Session *	createSession (const GraphDef *graphDef, SessionOptions &sessionOptions)

Session *	createSession (const GraphDef *graphDef, int nThreads=1)

GraphDef *	loadGraphDef (const std::string &pbFile)

MetaGraphDef *	loadMetaGraph (const std::string &exportDir, const std::string &tag, SessionOptions &sessionOptions)

MetaGraphDef *	loadMetaGraph (const std::string &exportDir, const std::string &tag=kSavedModelTagServe, int nThreads=1)

MetaGraphDef *	loadMetaGraphDef (const std::string &exportDir, const std::string &tag, SessionOptions &sessionOptions)

MetaGraphDef *	loadMetaGraphDef (const std::string &exportDir, const std::string &tag=kSavedModelTagServe, int nThreads=1)

void	run (Session session, const NamedTensorList &inputs, const std::vector< std::string > &outputNames, std::vector< Tensor > outputs, const thread::ThreadPoolOptions &threadPoolOptions)

void	run (Session session, const NamedTensorList &inputs, const std::vector< std::string > &outputNames, std::vector< Tensor > outputs, thread::ThreadPoolInterface *threadPool)

void	run (Session session, const NamedTensorList &inputs, const std::vector< std::string > &outputNames, std::vector< Tensor > outputs, const std::string &threadPoolName="no_threads")

void	run (Session session, const std::vector< std::string > &outputNames, std::vector< Tensor > outputs, const std::string &threadPoolName="no_threads")

void	setLogging (const std::string &level="3")

void	setThreading (SessionOptions &sessionOptions, int nThreads=1)

void	setThreading (SessionOptions &sessionOptions, int nThreads, const std::string &singleThreadPool)

Typedef Documentation

typedef std::pair<std::string, Tensor> tensorflow::NamedTensor

Definition at line 29 of file TensorFlow.h.

typedef std::vector<NamedTensor> tensorflow::NamedTensorList

Definition at line 30 of file TensorFlow.h.

Function Documentation

bool tensorflow::closeSession ( Session *& session )

Definition at line 198 of file TensorFlow.cc.

References run_AlCaRecoTriggerBitsUpdateWorkflow::session, and mps_update::status.

Referenced by DTOccupancyTestML::dqmEndLuminosityBlock(), GEDPhotonProducer::endStream(), GsfElectronProducer::endStream(), L2TauNNProducer::globalEndJob(), BaseMVACache::~BaseMVACache(), deep_tau::DeepTauCache::~DeepTauCache(), PtAssignmentEngineDxy::~PtAssignmentEngineDxy(), TauNNId::~TauNNId(), TfGraphDefWrapper::~TfGraphDefWrapper(), and TSGForOIDNN::~TSGForOIDNN().

                                        {
     if (session == nullptr) {
       return true;
     }
 
     // close and delete the session
     Status status = session->Close();
     delete session;
 
     // reset the pointer
     session = nullptr;
 
     return status.ok();
   }

Session * tensorflow::createSession ( SessionOptions & sessionOptions )

Definition at line 85 of file TensorFlow.cc.

References Exception, run_AlCaRecoTriggerBitsUpdateWorkflow::session, and mps_update::status.

Referenced by BaseMVACache::BaseMVACache(), PtAssignmentEngineDxy::configure(), createSession(), deep_tau::DeepTauCache::DeepTauCache(), DTOccupancyTestML::dqmEndLuminosityBlock(), egammaTools::EgammaDNNHelper::getSessions(), HGCalConcentratorAutoEncoderImpl::HGCalConcentratorAutoEncoderImpl(), L2TauNNProducer::initializeGlobalCache(), TfGraphDefProducer::produce(), TauNNId::TauNNId(), and TSGForOIDNN::TSGForOIDNN().

                                                          {
     // objects to create the session
     Status status;
 
     // create a new, empty session
     Session* session = nullptr;
     status = NewSession(sessionOptions, &session);
     if (!status.ok()) {
       throw cms::Exception("InvalidSession") << "error while creating session: " << status.ToString();
     }
 
     return session;
   }

Session * tensorflow::createSession ( int nThreads = 1 )

Definition at line 99 of file TensorFlow.cc.

References createSession(), and setThreading().

                                        {
     // create session options and set thread options
     SessionOptions sessionOptions;
     setThreading(sessionOptions, nThreads);
 
     return createSession(sessionOptions);
   }

Session * tensorflow::createSession	(	const MetaGraphDef *	metaGraphDef,
		const std::string &	exportDir,
		SessionOptions &	sessionOptions
	)

Definition at line 107 of file TensorFlow.cc.

References createSession(), Exception, convertSQLiteXML::ok, run_AlCaRecoTriggerBitsUpdateWorkflow::session, mps_update::status, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                          {
     // check for valid pointer
     if (metaGraphDef == nullptr) {
       throw cms::Exception("InvalidMetaGraphDef") << "error while creating session: metaGraphDef is nullptr";
     }
 
     // check that the graph has nodes
     if (metaGraphDef->graph_def().node_size() <= 0) {
       throw cms::Exception("InvalidMetaGraphDef") << "error while creating session: graphDef has no nodes";
     }
 
     Session* session = createSession(sessionOptions);
 
     // add the graph def from the meta graph
     Status status;
     status = session->Create(metaGraphDef->graph_def());
     if (!status.ok()) {
       throw cms::Exception("InvalidMetaGraphDef")
           << "error while attaching metaGraphDef to session: " << status.ToString();
     }
 
     // restore variables using the variable and index files in the export directory
     // first, find names and paths
     std::string varFileTensorName = metaGraphDef->saver_def().filename_tensor_name();
     std::string restoreOpName = metaGraphDef->saver_def().restore_op_name();
     std::string varDir = io::JoinPath(exportDir, kSavedModelVariablesDirectory);
     std::string indexFile = io::JoinPath(varDir, MetaFilename(kSavedModelVariablesFilename));
     std::string varFile = io::JoinPath(varDir, kSavedModelVariablesFilename);
 
     // when the index file is missing, there's nothing to do
     if (!Env::Default()->FileExists(indexFile).ok()) {
       return session;
     }
 
     // create a tensor to store the variable file
     Tensor varFileTensor(DT_STRING, TensorShape({}));
     varFileTensor.scalar<tensorflow::tstring>()() = varFile;
 
     // run the restore op
     status = session->Run({{varFileTensorName, varFileTensor}}, {}, {restoreOpName}, nullptr);
     if (!status.ok()) {
       throw cms::Exception("InvalidSession") << "error while restoring variables in session: " << status.ToString();
     }
 
     return session;
   }

Session * tensorflow::createSession	(	const MetaGraphDef *	metaGraphDef,
		const std::string &	exportDir,
		int	nThreads = `1`
	)

Definition at line 156 of file TensorFlow.cc.

References createSession(), and setThreading().

                                                                                                      {
     // create session options and set thread options
     SessionOptions sessionOptions;
     setThreading(sessionOptions, nThreads);
 
     return createSession(metaGraphDef, exportDir, sessionOptions);
   }

Session * tensorflow::createSession	(	const GraphDef *	graphDef,
		SessionOptions &	sessionOptions
	)

Definition at line 164 of file TensorFlow.cc.

References createSession(), Exception, run_AlCaRecoTriggerBitsUpdateWorkflow::session, and mps_update::status.

                                                                                    {
     // check for valid pointer
     if (graphDef == nullptr) {
       throw cms::Exception("InvalidGraphDef") << "error while creating session: graphDef is nullptr";
     }
 
     // check that the graph has nodes
     if (graphDef->node_size() <= 0) {
       throw cms::Exception("InvalidGraphDef") << "error while creating session: graphDef has no nodes";
     }
 
     // create a new, empty session
     Session* session = createSession(sessionOptions);
 
     // add the graph def
     Status status;
     status = session->Create(*graphDef);
 
     // check for success
     if (!status.ok()) {
       throw cms::Exception("InvalidSession") << "error while attaching graphDef to session: " << status.ToString();
     }
 
     return session;
   }

Session * tensorflow::createSession	(	const GraphDef *	graphDef,
		int	nThreads = `1`
	)

Definition at line 190 of file TensorFlow.cc.

References createSession(), and setThreading().

                                                                  {
     // create session options and set thread options
     SessionOptions sessionOptions;
     setThreading(sessionOptions, nThreads);
 
     return createSession(graphDef, sessionOptions);
   }

GraphDef * tensorflow::loadGraphDef ( const std::string & pbFile )

Definition at line 68 of file TensorFlow.cc.

References Exception, and mps_update::status.

Referenced by BaseMVACache::BaseMVACache(), PtAssignmentEngineDxy::configure(), deep_tau::DeepTauCache::DeepTauCache(), DTOccupancyTestML::dqmEndLuminosityBlock(), HGCalConcentratorAutoEncoderImpl::HGCalConcentratorAutoEncoderImpl(), DeepMETProducer::initializeGlobalCache(), L1NNTauProducer::initializeGlobalCache(), DeepCoreSeedGenerator::initializeGlobalCache(), L2TauNNProducer::initializeGlobalCache(), egammaTools::EgammaDNNHelper::initTensorFlowGraphs(), TfGraphDefProducer::produce(), and TSGForOIDNN::TSGForOIDNN().

                                                   {
     // objects to load the graph
     Status status;
 
     // load it
     GraphDef* graphDef = new GraphDef();
     status = ReadBinaryProto(Env::Default(), pbFile, graphDef);
 
     // check for success
     if (!status.ok()) {
       throw cms::Exception("InvalidGraphDef")
           << "error while loading graphDef from '" << pbFile << "': " << status.ToString();
     }
 
     return graphDef;
   }

MetaGraphDef * tensorflow::loadMetaGraph	(	const std::string &	exportDir,
		const std::string &	tag,
		SessionOptions &	sessionOptions
	)

Definition at line 46 of file TensorFlow.cc.

References loadMetaGraphDef().

                                                                                                                 {
     edm::LogInfo("PhysicsTools/TensorFlow")
         << "tensorflow::loadMetaGraph() is deprecated, use tensorflow::loadMetaGraphDef() instead";
 
     return loadMetaGraphDef(exportDir, tag, sessionOptions);
   }

MetaGraphDef * tensorflow::loadMetaGraph	(	const std::string &	exportDir,
		const std::string &	tag = `kSavedModelTagServe`,
		int	nThreads = `1`
	)

Definition at line 61 of file TensorFlow.cc.

References loadMetaGraphDef().

                                                                                               {
     edm::LogInfo("PhysicsTools/TensorFlow")
         << "tensorflow::loadMetaGraph() is deprecated, use tensorflow::loadMetaGraphDef() instead";
 
     return loadMetaGraphDef(exportDir, tag, nThreads);
   }

MetaGraphDef * tensorflow::loadMetaGraphDef	(	const std::string &	exportDir,
		const std::string &	tag,
		SessionOptions &	sessionOptions
	)

Definition at line 29 of file TensorFlow.cc.

References Exception, and mps_update::status.

Referenced by loadMetaGraph(), and loadMetaGraphDef().

                                                                                                                    {
     // objects to load the graph
     Status status;
     RunOptions runOptions;
     SavedModelBundle bundle;
 
     // load the model
     status = LoadSavedModel(sessionOptions, runOptions, exportDir, {tag}, &bundle);
     if (!status.ok()) {
       throw cms::Exception("InvalidMetaGraphDef")
           << "error while loading metaGraphDef from '" << exportDir << "': " << status.ToString();
     }
 
     // return a copy of the graph
     return new MetaGraphDef(bundle.meta_graph_def);
   }

MetaGraphDef * tensorflow::loadMetaGraphDef	(	const std::string &	exportDir,
		const std::string &	tag = `kSavedModelTagServe`,
		int	nThreads = `1`
	)

Definition at line 53 of file TensorFlow.cc.

References loadMetaGraphDef(), and setThreading().

                                                                                                  {
     // create session options and set thread options
     SessionOptions sessionOptions;
     setThreading(sessionOptions, nThreads);
 
     return loadMetaGraphDef(exportDir, tag, sessionOptions);
   }

void tensorflow::run	(	Session *	session,
		const NamedTensorList &	inputs,
		const std::vector< std::string > &	outputNames,
		std::vector< Tensor > *	outputs,
		const thread::ThreadPoolOptions &	threadPoolOptions
	)

Definition at line 213 of file TensorFlow.cc.

References Exception, and mps_update::status.

Referenced by PtAssignmentEngineDxy::call_tensorflow_dxy(), ticl::PatternRecognitionbyCLUE3D< TILES >::energyRegressionAndID(), ticl::PatternRecognitionbyCA< TILES >::energyRegressionAndID(), ticl::PatternRecognitionbyFastJet< TILES >::energyRegressionAndID(), TrackstersMergeProducer::energyRegressionAndID(), egammaTools::EgammaDNNHelper::evaluate(), TSGForOIDNN::evaluateClassifier(), TauNNId::EvaluateNN(), TSGForOIDNN::evaluateRegressor(), DeepTauId::getPartialPredictions(), DPFIsolation::getPredictions(), DeepTauId::getPredictionsV1(), DeepTauId::getPredictionsV2(), L2TauNNProducer::getTauScore(), DeepMETProducer::produce(), BaseMVAValueMapProducer< T >::produce(), run(), DTOccupancyTestML::runOccupancyTest(), DeepCoreSeedGenerator::SeedEvaluation(), and HGCalConcentratorAutoEncoderImpl::select().

                                                              {
     if (session == nullptr) {
       throw cms::Exception("InvalidSession") << "cannot run empty session";
     }
 
     // create empty run options
     RunOptions runOptions;
 
     // run and check the status
     Status status = session->Run(runOptions, inputs, outputNames, {}, outputs, nullptr, threadPoolOptions);
     if (!status.ok()) {
       throw cms::Exception("InvalidRun") << "error while running session: " << status.ToString();
     }
   }

void tensorflow::run	(	Session *	session,
		const NamedTensorList &	inputs,
		const std::vector< std::string > &	outputNames,
		std::vector< Tensor > *	outputs,
		thread::ThreadPoolInterface *	threadPool
	)

Definition at line 232 of file TensorFlow.cc.

References run().

                                                   {
     // create thread pool options
     thread::ThreadPoolOptions threadPoolOptions;
     threadPoolOptions.inter_op_threadpool = threadPool;
     threadPoolOptions.intra_op_threadpool = threadPool;
 
     // run
     run(session, inputs, outputNames, outputs, threadPoolOptions);
   }

void tensorflow::run	(	Session *	session,
		const NamedTensorList &	inputs,
		const std::vector< std::string > &	outputNames,
		std::vector< Tensor > *	outputs,
		const std::string &	threadPoolName = `"no_threads"`
	)

Definition at line 246 of file TensorFlow.cc.

References Exception, tensorflow::NoThreadPool::instance(), tensorflow::TBBThreadPool::instance(), and run().

                                             {
     // lookup the thread pool and forward the call accordingly
     if (threadPoolName == "no_threads") {
       run(session, inputs, outputNames, outputs, &NoThreadPool::instance());
     } else if (threadPoolName == "tbb") {
       // the TBBTreadPool singleton should be already initialized before with a number of threads
       run(session, inputs, outputNames, outputs, &TBBThreadPool::instance());
     } else if (threadPoolName == "tensorflow") {
       run(session, inputs, outputNames, outputs, nullptr);
     } else {
       throw cms::Exception("UnknownThreadPool")
           << "thread pool implementation'" << threadPoolName << "' unknown, use 'no_threads', 'tbb', or 'tensorflow'";
     }
   }

void tensorflow::run	(	Session *	session,
		const std::vector< std::string > &	outputNames,
		std::vector< Tensor > *	outputs,
		const std::string &	threadPoolName = `"no_threads"`
	)

Definition at line 265 of file TensorFlow.cc.

References run().

                                             {
     run(session, {}, outputNames, outputs, threadPoolName);
   }

void tensorflow::setLogging ( const std::string & level = "3" )

Definition at line 15 of file TensorFlow.cc.

Referenced by DTOccupancyTestML::dqmEndLuminosityBlock(), HGCalConcentratorAutoEncoderImpl::HGCalConcentratorAutoEncoderImpl(), L1NNTauProducer::initializeGlobalCache(), L2TauNNProducer::initializeGlobalCache(), and TSGForOIDNN::TSGForOIDNN().

15 { setenv("TF_CPP_MIN_LOG_LEVEL", level.c_str(), 0); }

testEve_cfg.level

tuple level

Definition: testEve_cfg.py:47

void tensorflow::setThreading	(	SessionOptions &	sessionOptions,
		int	nThreads = `1`
	)

Definition at line 17 of file TensorFlow.cc.

Referenced by createSession(), deep_tau::DeepTauCache::DeepTauCache(), loadMetaGraphDef(), and setThreading().

                                                                   {
     // set number of threads used for intra and inter operation communication
     sessionOptions.config.set_intra_op_parallelism_threads(nThreads);
     sessionOptions.config.set_inter_op_parallelism_threads(nThreads);
   }

void tensorflow::setThreading	(	SessionOptions &	sessionOptions,
		int	nThreads,
		const std::string &	singleThreadPool
	)

Definition at line 23 of file TensorFlow.cc.

References setThreading().

                                                                                                      {
     edm::LogInfo("PhysicsTools/TensorFlow") << "setting the thread pool via tensorflow::setThreading() is deprecated";
 
     setThreading(sessionOptions, nThreads);
   }

Classes

Typedefs

Functions

Typedef Documentation

Function Documentation