tensorflow Namespace Reference

Classes
class	NTSession
class	NTSessionFactory
class	NTSessionRegistrar
class	TBBSession
class	TBBSessionFactory
class	TBBSessionRegistrar

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 (MetaGraphDef *metaGraph, const std::string &exportDir, SessionOptions &sessionOptions)
Session *	createSession (MetaGraphDef *metaGraph, const std::string &exportDir, int nThreads=1)
Session *	createSession (GraphDef *graphDef, SessionOptions &sessionOptions)
Session *	createSession (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)
void	run (Session *session, const NamedTensorList &inputs, const std::vector< std::string > &outputNames, const std::vector< std::string > &targetNodes, std::vector< Tensor > *outputs)
void	run (Session *session, const std::vector< std::string > &inputNames, const std::vector< Tensor > &inputTensors, const std::vector< std::string > &outputNames, const std::vector< std::string > &targetNodes, std::vector< Tensor > *outputs)
void	run (Session *session, const NamedTensorList &inputs, const std::vector< std::string > &outputNames, std::vector< Tensor > *outputs)
void	run (Session *session, const std::vector< std::string > &inputNames, const std::vector< Tensor > &inputTensors, const std::vector< std::string > &outputNames, std::vector< Tensor > *outputs)
void	setLogging (const std::string &level="3")
void	setThreading (SessionOptions &sessionOptions, int nThreads, const std::string &singleThreadPool="no_threads")

Variables
static NTSessionRegistrar	registrar
static TBBSessionRegistrar	registrar

Typedef Documentation

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

Definition at line 24 of file TensorFlow.h.

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

Definition at line 25 of file TensorFlow.h.

Function Documentation

bool tensorflow::closeSession

(

Session *&

session

)

Definition at line 161 of file TensorFlow.cc.

References btagGenBb_cfi::Status, and mps_update::status.

Referenced by DTOccupancyTestML::dqmEndLuminosityBlock(), DeepDoubleXTFJetTagsProducer::~DeepDoubleXTFJetTagsProducer(), DeepFlavourTFJetTagsProducer::~DeepFlavourTFJetTagsProducer(), deep_tau::DeepTauCache::~DeepTauCache(), and DeepVertexTFJetTagsProducer::~DeepVertexTFJetTagsProducer().

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

References Exception, btagGenBb_cfi::Status, and mps_update::status.

Referenced by BaseMVAValueMapProducer< pat::Jet >::BaseMVAValueMapProducer(), createSession(), DeepDoubleXTFJetTagsProducer::DeepDoubleXTFJetTagsProducer(), DeepFlavourTFJetTagsProducer::DeepFlavourTFJetTagsProducer(), deep_tau::DeepTauCache::DeepTauCache(), DeepVertexTFJetTagsProducer::DeepVertexTFJetTagsProducer(), DTOccupancyTestML::dqmEndLuminosityBlock(), and ticl::PatternRecognitionbyCA::PatternRecognitionbyCA().

                                                         {
    // 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 85 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	(	MetaGraphDef *	metaGraph,
		const std::string &	exportDir,
		SessionOptions &	sessionOptions
	)

Definition at line 93 of file TensorFlow.cc.

References createSession(), Default, Exception, convertSQLiteXML::ok, btagGenBb_cfi::Status, mps_update::status, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                              {
    Session* session = createSession(sessionOptions);

    // add the graph def from the meta graph
    Status status;
    status = session->Create(metaGraph->graph_def());
    if (!status.ok()) {
      throw cms::Exception("InvalidSession") << "error while attaching meta graph to session: " << status.ToString();
    }

    // restore variables using the variable and index files in the export directory
    // first, find names and paths
    std::string varFileTensorName = metaGraph->saver_def().filename_tensor_name();
    std::string restoreOpName = metaGraph->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<std::string>()() = 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	(	MetaGraphDef *	metaGraph,
		const std::string &	exportDir,
		int	nThreads = 1
	)

Definition at line 129 of file TensorFlow.cc.

References createSession(), and setThreading().

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

    return createSession(metaGraph, exportDir, sessionOptions);
  }

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

Definition at line 137 of file TensorFlow.cc.

References createSession(), Exception, btagGenBb_cfi::Status, and mps_update::status.

                                                                             {
    // 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 graph def to session: " << status.ToString();
    }

    return session;
  }

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

Definition at line 153 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 55 of file TensorFlow.cc.

References Default, Exception, btagGenBb_cfi::Status, and mps_update::status.

Referenced by BaseMVAValueMapProducer< pat::Jet >::BaseMVAValueMapProducer(), deep_tau::DeepTauCache::DeepTauCache(), DTOccupancyTestML::dqmEndLuminosityBlock(), TrackstersProducer::initializeGlobalCache(), DeepFlavourTFJetTagsProducer::initializeGlobalCache(), DeepVertexTFJetTagsProducer::initializeGlobalCache(), and DeepDoubleXTFJetTagsProducer::initializeGlobalCache().

                                                  {
    // 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 graph def: " << status.ToString();
    }

    return graphDef;
  }

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

Definition at line 31 of file TensorFlow.cc.

References Exception, btagGenBb_cfi::Status, and mps_update::status.

Referenced by loadMetaGraph().

                                                                                                                {
    // 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("InvalidMetaGraph") << "error while loading meta graph: " << status.ToString();
    }

    // return a copy of the graph
    return new MetaGraphDef(bundle.meta_graph_def);
  }

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

Definition at line 47 of file TensorFlow.cc.

References loadMetaGraph(), and setThreading().

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

    return loadMetaGraph(exportDir, tag, sessionOptions);
  }

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

Definition at line 176 of file TensorFlow.cc.

References Exception, btagGenBb_cfi::Status, and mps_update::status.

Referenced by ticl::PatternRecognitionbyCA::energyRegressionAndID(), DeepTauId::getPartialPredictions(), DPFIsolation::getPredictions(), DeepTauId::getPredictionsV1(), DeepTauId::getPredictionsV2(), DeepDoubleXTFJetTagsProducer::produce(), DeepFlavourTFJetTagsProducer::produce(), DeepVertexTFJetTagsProducer::produce(), BaseMVAValueMapProducer< T >::produce(), run(), and DTOccupancyTestML::runOccupancyTest().

                                       {
    if (session == nullptr) {
      throw cms::Exception("InvalidSession") << "cannot run empty session";
    }

    // run and check the status
    Status status = session->Run(inputs, outputNames, targetNodes, outputs);
    if (!status.ok()) {
      throw cms::Exception("InvalidRun") << "error while running session: " << status.ToString();
    }
  }

void tensorflow::run	(	Session *	session,
		const std::vector< std::string > &	inputNames,
		const std::vector< Tensor > &	inputTensors,
		const std::vector< std::string > &	outputNames,
		const std::vector< std::string > &	targetNodes,
		std::vector< Tensor > *	outputs
	)

Definition at line 192 of file TensorFlow.cc.

References Exception, mps_fire::i, PixelMapPlotter::inputs, and run().

                                       {
    if (inputNames.size() != inputTensors.size()) {
      throw cms::Exception("InvalidInput") << "numbers of input names and tensors not equal";
    }

    NamedTensorList inputs;
    for (size_t i = 0; i < inputNames.size(); i++) {
      inputs.push_back(NamedTensor(inputNames[i], inputTensors[i]));
    }

    run(session, inputs, outputNames, targetNodes, outputs);
  }

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

Definition at line 210 of file TensorFlow.cc.

References PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, and run().

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

void tensorflow::run	(	Session *	session,
		const std::vector< std::string > &	inputNames,
		const std::vector< Tensor > &	inputTensors,
		const std::vector< std::string > &	outputNames,
		std::vector< Tensor > *	outputs
	)

Definition at line 217 of file TensorFlow.cc.

References PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, and run().

                                       {
    run(session, inputNames, inputTensors, outputNames, {}, outputs);
  }

void tensorflow::setLogging

(

const std::string &

level = "3"

)

Definition at line 13 of file TensorFlow.cc.

Referenced by BaseMVAValueMapProducer< pat::Jet >::BaseMVAValueMapProducer(), DTOccupancyTestML::dqmEndLuminosityBlock(), DeepFlavourTFJetTagsProducer::initializeGlobalCache(), DeepDoubleXTFJetTagsProducer::initializeGlobalCache(), and DeepVertexTFJetTagsProducer::initializeGlobalCache().

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

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

Definition at line 15 of file TensorFlow.cc.

References Exception, and jets_cff::singleThreadPool.

Referenced by BaseMVAValueMapProducer< pat::Jet >::BaseMVAValueMapProducer(), createSession(), DeepDoubleXTFJetTagsProducer::DeepDoubleXTFJetTagsProducer(), DeepFlavourTFJetTagsProducer::DeepFlavourTFJetTagsProducer(), deep_tau::DeepTauCache::DeepTauCache(), DeepVertexTFJetTagsProducer::DeepVertexTFJetTagsProducer(), and loadMetaGraph().

                                                                                                     {
    // 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);

    // when exactly one thread is requested use a custom thread pool
    if (nThreads == 1 && !singleThreadPool.empty()) {
      // check for known thread pools
      if (singleThreadPool != "no_threads" && singleThreadPool != "tbb") {
        throw cms::Exception("UnknownThreadPool")
            << "thread pool '" << singleThreadPool << "' unknown, use 'no_threads' or 'tbb'";
      }
      sessionOptions.target = singleThreadPool;
    }
  }

Variable Documentation

NTSessionRegistrar tensorflow::registrar

static

Definition at line 169 of file NTSession.cc.

TBBSessionRegistrar tensorflow::registrar

static

Definition at line 171 of file TBBSession.cc.