tensorflow Namespace Reference

Classes
class	NoThreadPool
struct	SessionCache
class	TBBThreadPool

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

Enumerations
enum	Backend {   Backend::cpu, Backend::cuda, Backend::rocm, Backend::intel,   Backend::best }

Functions
bool	closeSession (Session *&session)
bool	closeSession (const Session *&session)
Session *	createSession (SessionOptions &sessionOptions)
Session *	createSession (Backend backend=Backend::cpu, int nThreads=1)
Session *	createSession (const MetaGraphDef *metaGraphDef, const std::string &exportDir, SessionOptions &sessionOptions)
Session *	createSession (const MetaGraphDef *metaGraphDef, const std::string &exportDir, Backend backend=Backend::cpu, int nThreads=1)
Session *	createSession (const GraphDef *graphDef, SessionOptions &sessionOptions)
Session *	createSession (const GraphDef *graphDef, Backend backend=Backend::cpu, 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, Backend backend=Backend::cpu, 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, Backend backend=Backend::cpu, 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 (const 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 (const 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 (const 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	run (const Session *session, const std::vector< std::string > &outputNames, std::vector< Tensor > *outputs, const std::string &threadPoolName="no_threads")
void	setBackend (SessionOptions &sessionOptions, Backend backend=Backend::cpu)
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

NamedTensor

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

Definition at line 30 of file TensorFlow.h.

NamedTensorList

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

Definition at line 31 of file TensorFlow.h.

Enumeration Type Documentation

Backend

enum tensorflow::Backend

strong

Enumerator
cpu
cuda
rocm
intel
best

Definition at line 28 of file TensorFlow.h.

{ cpu, cuda, rocm, intel, best };

Function Documentation

closeSession() [1/2]

bool tensorflow::closeSession

(

Session *&

session

)

Definition at line 261 of file TensorFlow.cc.

References mps_update::status.

Referenced by closeSession(), tensorflow::SessionCache::closeSession(), DTOccupancyTestML::dqmEndLuminosityBlock(), GEDPhotonProducer::endStream(), GsfElectronProducer::endStream(), L2TauNNProducer::globalEndJob(), BaseMVACache::~BaseMVACache(), reco::DeepSCGraphEvaluation::~DeepSCGraphEvaluation(), deep_tau::DeepTauCache::~DeepTauCache(), PtAssignmentEngineDxy::~PtAssignmentEngineDxy(), 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();
  }

closeSession() [2/2]

bool tensorflow::closeSession

(

const Session *&

session

)

Definition at line 276 of file TensorFlow.cc.

References closeSession(), and alignCSCRings::s.

                                             {
    auto s = const_cast<Session*>(session);
    bool state = closeSession(s);

    // reset the pointer
    session = nullptr;

    return state;
  }

createSession() [1/6]

Session * tensorflow::createSession

(

SessionOptions &

sessionOptions

)

Definition at line 145 of file TensorFlow.cc.

References Exception, and mps_update::status.

Referenced by BaseMVACache::BaseMVACache(), PtAssignmentEngineDxy::configure(), createSession(), tensorflow::SessionCache::createSession(), deep_tau::DeepTauCache::DeepTauCache(), DTOccupancyTestML::dqmEndLuminosityBlock(), egammaTools::EgammaDNNHelper::getSessions(), HGCalConcentratorAutoEncoderImpl::HGCalConcentratorAutoEncoderImpl(), L2TauNNProducer::initializeGlobalCache(), reco::DeepSCGraphEvaluation::initTensorFlowGraphAndSession(), TfGraphDefProducer::produce(), 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;
  }

createSession() [2/6]

Session * tensorflow::createSession	(	Backend	backend = Backend::cpu,
		int	nThreads = 1
	)

Definition at line 159 of file TensorFlow.cc.

References jetsAK4_CHS_cff::backend, createSession(), setBackend(), and setThreading().

                                                        {
    // create session options and set thread options
    SessionOptions sessionOptions;
    setThreading(sessionOptions, nThreads);
    setBackend(sessionOptions, backend);

    return createSession(sessionOptions);
  }

createSession() [3/6]

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

Definition at line 168 of file TensorFlow.cc.

References createSession(), cms::soa::RestrictQualify::Default, Exception, convertSQLiteXML::ok, 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;
  }

createSession() [4/6]

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

Definition at line 217 of file TensorFlow.cc.

References jetsAK4_CHS_cff::backend, createSession(), setBackend(), and setThreading().

                                                                                                                      {
    // create session options and set thread options
    SessionOptions sessionOptions;
    setThreading(sessionOptions, nThreads);
    setBackend(sessionOptions, backend);

    return createSession(metaGraphDef, exportDir, sessionOptions);
  }

createSession() [5/6]

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

Definition at line 226 of file TensorFlow.cc.

References createSession(), Exception, 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;
  }

createSession() [6/6]

Session * tensorflow::createSession	(	const GraphDef *	graphDef,
		Backend	backend = Backend::cpu,
		int	nThreads = 1
	)

Definition at line 252 of file TensorFlow.cc.

References jetsAK4_CHS_cff::backend, createSession(), setBackend(), and setThreading().

                                                                                  {
    // create session options and set thread options
    SessionOptions sessionOptions;
    setThreading(sessionOptions, nThreads);
    setBackend(sessionOptions, backend);

    return createSession(graphDef, sessionOptions);
  }

loadGraphDef()

GraphDef * tensorflow::loadGraphDef

(

const std::string &

pbFile

)

Definition at line 128 of file TensorFlow.cc.

References cms::soa::RestrictQualify::Default, Exception, and mps_update::status.

Referenced by BaseMVACache::BaseMVACache(), PtAssignmentEngineDxy::configure(), tensorflow::SessionCache::createSession(), deep_tau::DeepTauCache::DeepTauCache(), DTOccupancyTestML::dqmEndLuminosityBlock(), HGCalConcentratorAutoEncoderImpl::HGCalConcentratorAutoEncoderImpl(), L2TauNNProducer::initializeGlobalCache(), reco::DeepSCGraphEvaluation::initTensorFlowGraphAndSession(), 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;
  }

loadMetaGraph() [1/2]

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

Definition at line 105 of file TensorFlow.cc.

References loadMetaGraphDef(), and makeGlobalPositionRcd_cfg::tag.

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

    return loadMetaGraphDef(exportDir, tag, sessionOptions);
  }

loadMetaGraph() [2/2]

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

Definition at line 121 of file TensorFlow.cc.

References jetsAK4_CHS_cff::backend, loadMetaGraphDef(), and makeGlobalPositionRcd_cfg::tag.

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

    return loadMetaGraphDef(exportDir, tag, backend, nThreads);
  }

loadMetaGraphDef() [1/2]

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

Definition at line 88 of file TensorFlow.cc.

References Exception, mps_update::status, and makeGlobalPositionRcd_cfg::tag.

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);
  }

loadMetaGraphDef() [2/2]

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

Definition at line 112 of file TensorFlow.cc.

References jetsAK4_CHS_cff::backend, loadMetaGraphDef(), setBackend(), setThreading(), and makeGlobalPositionRcd_cfg::tag.

                                                                                                                  {
    // create session options and set thread options
    SessionOptions sessionOptions;
    setThreading(sessionOptions, nThreads);
    setBackend(sessionOptions, backend);

    return loadMetaGraphDef(exportDir, tag, sessionOptions);
  }

run() [1/8]

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 286 of file TensorFlow.cc.

References Exception, PixelMapPlotter::inputs, jetsAK4_CHS_cff::outputNames, PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, and mps_update::status.

Referenced by PtAssignmentEngineDxy::call_tensorflow_dxy(), MkFitOutputConverter::computeDNNs(), ticl::PatternRecognitionbyCLUE3D< TILES >::energyRegressionAndID(), ticl::PatternRecognitionbyCA< TILES >::energyRegressionAndID(), ticl::PatternRecognitionbyFastJet< TILES >::energyRegressionAndID(), TrackstersMergeProducerV3::energyRegressionAndID(), TrackstersMergeProducer::energyRegressionAndID(), egammaTools::EgammaDNNHelper::evaluate(), reco::DeepSCGraphEvaluation::evaluate(), TSGForOIDNN::evaluateClassifier(), TauNNId::EvaluateNN(), TSGForOIDNN::evaluateRegressor(), DeepTauId::getPartialPredictions(), DeepTauId::getPredictionsV2(), L2TauNNProducer::getTauScore(), DeepMETProducer::produce(), BaseMVAValueMapProducer< pat::Muon >::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();
    }
  }

run() [2/8]

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

inline

Definition at line 127 of file TensorFlow.h.

References PixelMapPlotter::inputs, jetsAK4_CHS_cff::outputNames, PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, and run().

                                                                    {
    // TF takes a non-const session in the run call which is, however, thread-safe and logically
    // const, thus const_cast is consistent
    run(const_cast<Session*>(session), inputs, outputNames, outputs, threadPoolOptions);
  }

run() [3/8]

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

Definition at line 305 of file TensorFlow.cc.

References PixelMapPlotter::inputs, jetsAK4_CHS_cff::outputNames, PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, and 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);
  }

run() [4/8]

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

inline

Definition at line 147 of file TensorFlow.h.

References PixelMapPlotter::inputs, jetsAK4_CHS_cff::outputNames, PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, and run().

                                                         {
    // TF takes a non-const session in the run call which is, however, thread-safe and logically
    // const, thus const_cast is consistent
    run(const_cast<Session*>(session), inputs, outputNames, outputs, threadPool);
  }

run() [5/8]

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 319 of file TensorFlow.cc.

References Exception, PixelMapPlotter::inputs, tensorflow::NoThreadPool::instance(), tensorflow::TBBThreadPool::instance(), jetsAK4_CHS_cff::outputNames, PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, 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'";
    }
  }

run() [6/8]

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

inline

Definition at line 167 of file TensorFlow.h.

References PixelMapPlotter::inputs, jetsAK4_CHS_cff::outputNames, PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, and run().

                                                                  {
    // TF takes a non-const session in the run call which is, however, thread-safe and logically
    // const, thus const_cast is consistent
    run(const_cast<Session*>(session), inputs, outputNames, outputs, threadPoolName);
  }

run() [7/8]

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

Definition at line 338 of file TensorFlow.cc.

References jetsAK4_CHS_cff::outputNames, PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, and run().

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

run() [8/8]

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

inline

Definition at line 186 of file TensorFlow.h.

References jetsAK4_CHS_cff::outputNames, PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, and run().

                                                                  {
    // TF takes a non-const session in the run call which is, however, thread-safe and logically
    // const, thus const_cast is consistent
    run(const_cast<Session*>(session), outputNames, outputs, threadPoolName);
  }

setBackend()

void tensorflow::setBackend	(	SessionOptions &	sessionOptions,
		Backend	backend = Backend::cpu
	)

Definition at line 29 of file TensorFlow.cc.

References cms::Exception::addContext(), jetsAK4_CHS_cff::backend, best, cpu, cuda, intel, edm::ResourceInformation::nvidiaDriverVersion(), rocm, and edm::errors::UnavailableAccelerator.

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

                                                                   {
    /*
     * The TensorFlow backend configures the available devices using options provided in the sessionOptions proto.
     * // Options from https://github.com/tensorflow/tensorflow/blob/c53dab9fbc9de4ea8b1df59041a5ffd3987328c3/tensorflow/core/protobuf/config.proto
     *
     * If the device_count["GPU"] = 0 GPUs are not used. 
     * The visible_device_list configuration is used to map the `visible` devices (from CUDA_VISIBLE_DEVICES) to `virtual` devices.
     * If Backend::cpu is request, the GPU device is disallowed by device_count configuration.
     * If Backend::cuda is request:
     *  - if ResourceInformation shows an available Nvidia GPU device:
     *     the device is used with memory_growth configuration (not allocating all cuda memory at once).
     *  - if no device is present: an exception is raised.
     */

    edm::Service<edm::ResourceInformation> ri;
    if (backend == Backend::cpu) {
      // disable GPU usage
      (*sessionOptions.config.mutable_device_count())["GPU"] = 0;
      sessionOptions.config.mutable_gpu_options()->set_visible_device_list("");
    }
    // NVidia GPU
    else if (backend == Backend::cuda) {
      if (not ri->nvidiaDriverVersion().empty()) {
        // Take only the first GPU in the CUDA_VISIBLE_DEVICE list
        (*sessionOptions.config.mutable_device_count())["GPU"] = 1;
        sessionOptions.config.mutable_gpu_options()->set_visible_device_list("0");
        // Do not allocate all the memory on the GPU at the beginning.
        sessionOptions.config.mutable_gpu_options()->set_allow_growth(true);
      } else {
        edm::Exception ex(edm::errors::UnavailableAccelerator);
        ex << "Cuda backend requested, but no NVIDIA GPU available in the job";
        ex.addContext("Calling tensorflow::setBackend()");
        throw ex;
      }
    }
    // ROCm and Intel GPU are still not supported
    else if ((backend == Backend::rocm) || (backend == Backend::intel)) {
      edm::Exception ex(edm::errors::UnavailableAccelerator);
      ex << "ROCm/Intel GPU backend requested, but TF is not compiled yet for this platform";
      ex.addContext("Calling tensorflow::setBackend()");
      throw ex;
    }
    // Get NVidia GPU if possible or fallback to CPU
    else if (backend == Backend::best) {
      // Check if a Nvidia GPU is availabl
      if (not ri->nvidiaDriverVersion().empty()) {
        // Take only the first GPU in the CUDA_VISIBLE_DEVICE list
        (*sessionOptions.config.mutable_device_count())["GPU"] = 1;
        sessionOptions.config.mutable_gpu_options()->set_visible_device_list("0");
        // Do not allocate all the memory on the GPU at the beginning.
        sessionOptions.config.mutable_gpu_options()->set_allow_growth(true);
      } else {
        // Just CPU support
        (*sessionOptions.config.mutable_device_count())["GPU"] = 0;
        sessionOptions.config.mutable_gpu_options()->set_visible_device_list("");
      }
    }
  }

setLogging()

void tensorflow::setLogging

(

const std::string &

level = "3"

)

Definition at line 15 of file TensorFlow.cc.

References personalPlayback::level.

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

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

setThreading() [1/2]

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);
  }

setThreading() [2/2]

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);
  }