TFCSNetworkFactory Class Reference

Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration. More...

#include <TFCSNetworkFactory.h>

Collaboration diagram for TFCSNetworkFactory:

Static Public Member Functions
static std::unique_ptr< VNetworkBase >	create (std::string input)
	Given a string, make a network.
static std::unique_ptr< VNetworkBase >	create (std::string input, bool graph_form)
	Given a string, and information about format, make a network.
static std::unique_ptr< VNetworkBase >	create (std::vector< char > const &input)
	Given a vector of chars (bytes), make a network.
static std::unique_ptr< VNetworkBase >	create (std::vector< char > const &vector_input, std::string string_input)
	Create a network from whichever input isn't empty.
static std::unique_ptr< VNetworkBase >	create (std::vector< char > const &vector_input, std::string string_input, bool graph_form)
	Create a network from whichever input isn't empty.

Static Private Member Functions
static void	resolveGlobs (std::string &filename)
	If the filepath ends in .
static bool	isOnnxFile (std::string const &filename)
	Check if a filename seems to be an onnx file.

Detailed Description

Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration.

Class to perform runtime selection from the derived classes of VNetworkBase given inout for a network.

Has only static functions becuase no statelike information is needed to make this decision.

Information about the which network would be apropreate can be specified, or left entirely to the factory to determine.

Definition at line 24 of file TFCSNetworkFactory.h.

Member Function Documentation

create() [1/5]

std::unique_ptr< VNetworkBase > TFCSNetworkFactory::create ( std::string input )

static

Given a string, make a network.

This function will first check if the string is the path of a readable file on the disk. If so, the file suffix is used to decide if it's an onnx (.onnx) or lwtnn file (.json). If the filepath ends in .* then first an onnx then an lwtnn file will be tried. The file is read and parsed into a network.

If the string is not a filepath, it is assumed to be the content of a json file to make an lwtnn network.

When an lwtnn network is created, first the TFCSSimpleLWTNNHandler format is tried, and if this raises an error, the TFCSGANLWTNNHandler is applied. The former is simpler than the latter, so it will always fail to parse the more complex graph format.

Parameters

input

Either a file path, or the content of a file.

Definition at line 66 of file TFCSNetworkFactory.cxx.

                                                                      {
  ISF_FCS::MLogging logger;
  resolveGlobs(input);
  if (VNetworkBase::isFile(input) && isOnnxFile(input)) {
    ATH_MSG_NOCLASS(logger, "Creating ONNX network from file ..."
                                << input.substr(input.length() - 10));
    std::unique_ptr<VNetworkBase> created(new TFCSONNXHandler(input));
    return created;
  } else {
    try {
      std::unique_ptr<VNetworkBase> created(new TFCSSimpleLWTNNHandler(input));
      ATH_MSG_NOCLASS(logger,
                      "Succedeed in creating LWTNN nn from string starting "
                          << input.substr(0, 10));
      return created;
    } catch (const boost::property_tree::ptree_bad_path &e) {
      // If we get this error, it was actually a graph, not a NeuralNetwork
      std::unique_ptr<VNetworkBase> created(new TFCSGANLWTNNHandler(input));
      ATH_MSG_NOCLASS(logger, "Succedeed in creating LWTNN graph from string");
      return created;
    };
  };
};

create() [2/5]

std::unique_ptr< VNetworkBase > TFCSNetworkFactory::create ( std::string input, bool graph_form )

static

Given a string, and information about format, make a network.

This function will first check if the string is the path of a readable file on the disk. If so, the file suffix is used to decide if it's an onnx (.onnx) or lwtnn file (.json). If the filepath ends in .* then first an onnx then an lwtnn file will be tried. The file is read and parsed into a network.

If the string is not a filepath, it is assumed to be the content of a json file to make an lwtnn network.

When an lwtnn network is created, if graph_form is true the network will be a TFCSSimpleLWTNNHandler otherwise it is a TFCSGANLWTNNHandler.

Parameters

input	Either a file path, or the content of a file.
graph_form	Is the network the more complex graph form?

Definition at line 90 of file TFCSNetworkFactory.cxx.

                                                                          {
  ISF_FCS::MLogging logger;
  resolveGlobs(input);
  if (VNetworkBase::isFile(input) && isOnnxFile(input)) {
    ATH_MSG_NOCLASS(logger, "Creating ONNX network from file ..."
                                << input.substr(input.length() - 10));
    std::unique_ptr<VNetworkBase> created(new TFCSONNXHandler(input));
    return created;
  } else if (graph_form) {
    ATH_MSG_NOCLASS(logger, "Creating LWTNN graph from string");
    std::unique_ptr<VNetworkBase> created(new TFCSGANLWTNNHandler(input));
    return created;
  } else {
    std::unique_ptr<VNetworkBase> created(new TFCSSimpleLWTNNHandler(input));
    ATH_MSG_NOCLASS(logger, "Creating LWTNN nn from string");
    return created;
  };
};

create() [3/5]

std::unique_ptr< VNetworkBase > TFCSNetworkFactory::create ( std::vector< char > const & input )

static

Given a vector of chars (bytes), make a network.

This function will always create a TFCSONNXHandler. Caution: this function is designed to modify its input.

Parameters

input

The content of an onnx proto file.

Definition at line 58 of file TFCSNetworkFactory.cxx.

                                                       {
  ISF_FCS::MLogging logger;
  ATH_MSG_NOCLASS(logger, "Directly creating ONNX network from bytes length "
                              << input.size());
  std::unique_ptr<VNetworkBase> created(new TFCSONNXHandler(input));
  return created;
};

create() [4/5]

std::unique_ptr< VNetworkBase > TFCSNetworkFactory::create ( std::vector< char > const & vector_input, std::string string_input )

static

Create a network from whichever input isn't empty.

If the vector_input is not empty, construct a network from that, otherwise, use the string_input to construct a network.

Parameters

vector_input	The content of an onnx proto file.
string_input	Either a file path, or the content of a file.

Definition at line 111 of file TFCSNetworkFactory.cxx.

                                                   {
  ISF_FCS::MLogging logger;
  ATH_MSG_NOCLASS(logger, "Given both bytes and a string to create an nn.");
  resolveGlobs(string_input);
  if (vector_input.size() > 0) {
    ATH_MSG_NOCLASS(logger,
                    "Bytes contains data, size=" << vector_input.size()
                                                 << ", creating from bytes.");
    return create(vector_input);
  } else if (string_input.length() > 0) {
    ATH_MSG_NOCLASS(logger, "No data in bytes, string contains data, "
                                << "creating from string.");
    return create(std::move(string_input));
  } else {
    throw std::invalid_argument(
        "Neither vector_input nor string_input contain data");
  };
};

create() [5/5]

std::unique_ptr< VNetworkBase > TFCSNetworkFactory::create ( std::vector< char > const & vector_input, std::string string_input, bool graph_form )

static

Create a network from whichever input isn't empty.

If the vector_input is not empty, construct a network from that, otherwise, use the string_input to construct a network. Whether the network is in graph form is specifed for LWTNN networks.

Parameters

vector_input	The content of an onnx proto file.
string_input	Either a file path, or the content of a file.
graph_form	Is the network the more compelx graph form?

Definition at line 132 of file TFCSNetworkFactory.cxx.

                                                                    {
  ISF_FCS::MLogging logger;
  ATH_MSG_NOCLASS(
      logger,
      "Given both bytes, a string and graph form sepcified to create an nn.");
  resolveGlobs(string_input);
  if (vector_input.size() > 0) {
    ATH_MSG_NOCLASS(logger,
                    "Bytes contains data, size=" << vector_input.size()
                                                 << ", creating from bytes.");
    return create(vector_input);
  } else if (string_input.length() > 0) {
    ATH_MSG_NOCLASS(logger, "No data in bytes, string contains data, "
                                << "creating from string.");
    return create(std::move(string_input), graph_form);
  } else {
    throw std::invalid_argument(
        "Neither vector_input nor string_input contain data");
  };
};

isOnnxFile()

bool TFCSNetworkFactory::isOnnxFile ( std::string const & filename )

staticprivate

Check if a filename seems to be an onnx file.

Really just checks if the input ends in ".onnx"

Parameters

filename

Path to check.

Definition at line 42 of file TFCSNetworkFactory.cxx.

                                                             {
  ISF_FCS::MLogging logger;
  const std::string ending = ".onnx";
  const int ending_len = ending.length();
  const int filename_len = filename.length();
  bool is_onnx;
  if (filename_len < ending_len) {
    is_onnx = false;
  } else {
    is_onnx =
        (0 == filename.compare(filename_len - ending_len, ending_len, ending));
  };
  return is_onnx;
};

resolveGlobs()

void TFCSNetworkFactory::resolveGlobs ( std::string & filename )

staticprivate

If the filepath ends in .

• change it to .onnx or .json

If the filepath doesn't end in .*, no change is made. Will check first for a .onnx file, then look for a .json. Throws an exception if niether are found.

Parameters

filename

Path to check.

Definition at line 19 of file TFCSNetworkFactory.cxx.

                                                         {
  ISF_FCS::MLogging logger;
  const std::string ending = ".*";
  const int ending_len = ending.length();
  const int filename_len = filename.length();
  if (filename_len < ending_len) {
    ATH_MSG_NOCLASS(logger, "Filename is implausably short.");
  } else if (0 ==
             filename.compare(filename_len - ending_len, ending_len, ending)) {
    ATH_MSG_NOCLASS(logger, "Filename ends in glob.");
    // Remove the glob
    filename.pop_back();
    if (std::filesystem::exists(filename + "onnx")) {
      filename += "onnx";
    } else if (std::filesystem::exists(filename + "json")) {
      filename += std::string("json");
    } else {
      throw std::invalid_argument("No file found matching globbed filename " +
                                  filename);
    };
  };
};

---

The documentation for this class was generated from the following files:

• TFCSNetworkFactory.h
• TFCSNetworkFactory.cxx