fme_apply Namespace Reference

Data Structures
struct	EqualizePattern
class	FMEqualizer
class	FusePostScalePass
	Pass to fuse CircleCustom(PostScale) to succeeding Ops. More...
class	FusePreScalePass
	Pass to fuse CircleCustom(PreScale) to preceding Ops. More...
class	InsertScaleShift
	Class to insert scale/shift virtual Ops to loco::Graph. More...
class	ProgressReporter

Functions
void	check_patterns_valid (loco::Graph *g, const std::vector< EqualizePattern > &patterns)
std::vector< EqualizePattern >	read (const std::string &filename)
std::string	random_str (uint32_t len)
luci::CircleCustom *	to_scale (loco::Node *node)
void	copy_shape (luci::CircleNode *from, luci::CircleNode *to)
loco::Node *	get_input (luci::CircleNode *node)
void	set_input (luci::CircleNode *node, luci::CircleCustom *input)
luci::CircleNode *	find_arg_with_name (const luci::CircleNode *node, const std::string &name, const uint32_t &depth)

Function Documentation

check_patterns_valid()

void fme_apply::check_patterns_valid	(	loco::Graph *	g,
		const std::vector< EqualizePattern > &	patterns
	)

It checks if given patterns are valid as follows.

• "scale" is empty.
• "front" and "back" of the patterns are in the graph.

Definition at line 37 of file EqualizePatternCheck.cpp.

{
  // Create a map to find node by its name
  std::map<std::string, const luci::CircleNode *> node_by_name;
  {
    for (auto node : loco::active_nodes(loco::output_nodes(g)))
    {
      auto cnode = loco::must_cast<luci::CircleNode *>(node);
      node_by_name[cnode->name()] = cnode;
    }
  }
 
  for (const auto &p : patterns)
  {
    // "scale" is empty.
    // "scale" is calculated in the runtime.
    if (not p.scale.empty())
    {
      throw std::runtime_error{"'scale' shouldn't exist."};
    }
 
    // "front" and "back" of the patterns are in the graph.
    if (node_by_name.find(p.front) == node_by_name.end() or
        node_by_name.find(p.back) == node_by_name.end())
    {
      throw std::runtime_error{"Given front or back don't exist in the graph."};
    }
  }
}

References loco::active_nodes(), loco::output_nodes(), and p.

Referenced by fme_apply::FMEqualizer::equalize().

copy_shape()

void fme_apply::copy_shape	(	luci::CircleNode *	from,
		luci::CircleNode *	to
	)

Definition at line 22 of file Support.Misc.cpp.

{
  if (not from)
    throw std::invalid_argument("from");
 
  if (not to)
    throw std::invalid_argument("to");
 
  to->rank(from->rank());
  for (uint32_t i = 0; i < from->rank(); ++i)
  {
    to->dim(i) = from->dim(i);
  }
}

find_arg_with_name()

luci::CircleNode * fme_apply::find_arg_with_name	(	const luci::CircleNode *	node,
		const std::string &	name,
		const uint32_t &	depth
	)

It returns one of given node's arguments whose name is "name".

According to the depth, it finds from more preceded nodes.

Definition at line 174 of file Support.Misc.cpp.

{
  if (depth == 0)
    return nullptr;
 
  const auto arity = node->arity();
  for (uint32_t idx = 0; idx < arity; idx++)
  {
    auto front_node = loco::must_cast<luci::CircleNode *>(node->arg(idx));
    if (front_node->name() == name)
      return front_node;
    front_node = find_arg_with_name(front_node, name, depth - 1);
    if (front_node)
      return front_node;
  }
  return nullptr;
}

References loco::Node::arg(), loco::Node::arity(), and find_arg_with_name().

Referenced by find_arg_with_name().

get_input()

loco::Node * fme_apply::get_input

(

luci::CircleNode *

node

)

It returns given node's input.

Definition at line 40 of file Support.Misc.cpp.

{
  switch (node->opcode())
  {
    case luci::CircleOpcode::CONV_2D:
    {
      auto conv = loco::must_cast<luci::CircleConv2D *>(node);
      return conv->input();
    }
    case luci::CircleOpcode::DEPTHWISE_CONV_2D:
    {
      auto dconv = loco::must_cast<luci::CircleDepthwiseConv2D *>(node);
      return dconv->input();
    }
    case luci::CircleOpcode::FULLY_CONNECTED:
    {
      auto fc = loco::must_cast<luci::CircleFullyConnected *>(node);
      return fc->input();
    }
    case luci::CircleOpcode::GELU:
    {
      auto gelu = loco::must_cast<luci::CircleGelu *>(node);
      return gelu->features();
    }
    case luci::CircleOpcode::LEAKY_RELU:
    {
      auto relu = loco::must_cast<luci::CircleLeakyRelu *>(node);
      return relu->features();
    }
    case luci::CircleOpcode::MAX_POOL_2D:
    {
      auto maxpool = loco::must_cast<luci::CircleMaxPool2D *>(node);
      return maxpool->value();
    }
    case luci::CircleOpcode::PAD:
    {
      auto pad = loco::must_cast<luci::CirclePad *>(node);
      return pad->input();
    }
    case luci::CircleOpcode::RELU:
    {
      auto relu = loco::must_cast<luci::CircleLeakyRelu *>(node);
      return relu->features();
    }
    case luci::CircleOpcode::TRANSPOSE_CONV:
    {
      auto tconv = loco::must_cast<luci::CircleTransposeConv *>(node);
      return tconv->outBackprop();
    }
    default:
    {
      throw std::runtime_error("(get_input) NYI operator: " + node->name());
    }
  }
}

References luci::CircleNode::name(), and luci::CircleNode::opcode().

random_str()

std::string fme_apply::random_str

(

uint32_t

len

)

Definition at line 25 of file RandomString.cpp.

{
  static const char cand[] = "0123456789"
                             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                             "abcdefghijklmnopqrstuvwxyz";
 
  std::string res;
  res.reserve(len);
 
  for (uint32_t i = 0; i < len; ++i)
  {
    res += cand[std::rand() % (sizeof(cand) - 1)];
  }
 
  return res;
}

read()

std::vector< EqualizePattern > fme_apply::read

(

const std::string &

filename

)

Definition at line 44 of file EqualizePatternRead.cpp.

{
  Json::Value root;
  std::ifstream ifs(filename);
 
  // Failed to open cfg file
  if (not ifs.is_open())
    throw std::runtime_error("Cannot open config file. " + filename);
 
  Json::CharReaderBuilder builder;
  JSONCPP_STRING errs;
 
  // Failed to parse
  if (not parseFromStream(builder, ifs, &root, &errs))
    throw std::runtime_error("Cannot parse config file (json format). " + errs);
 
  std::vector<EqualizePattern> res;
 
  for (auto &eq_pattern : root)
  {
    auto get_string = [&](const std::string &val) {
      if (not eq_pattern.isMember(val))
        throw std::runtime_error(val + " is missing in " + filename);
      if (not eq_pattern[val].isString())
        throw std::runtime_error(val + " is not string");
 
      return eq_pattern[val].asString();
    };
 
    auto get_fp32_array = [&](const std::string &val) {
      if (not eq_pattern.isMember(val))
        throw std::runtime_error(val + " is missing in " + filename);
      auto arr = eq_pattern[val];
      if (not arr.isArray())
        throw std::runtime_error(val + " is not array");
 
      std::vector<float> res;
      for (auto &elem : arr)
      {
        if (not elem.isNumeric())
          throw std::runtime_error(val + "'s element is not fp32");
 
        res.emplace_back(elem.asFloat());
      }
 
      return res;
    };
 
    auto front = get_string("front");
    auto back = get_string("back");
    auto type = get_string("type");
 
    EqualizePattern p;
    {
      p.front = front;
      p.back = back;
      p.type = eq_type(type);
      switch (p.type)
      {
        case EqualizePattern::Type::ScaleOnly:
          p.act_scale = get_fp32_array("act_scale");
          break;
        default:
          throw std::runtime_error("Unsupported EqualizePattern type");
      }
    }
    res.emplace_back(p);
  }
 
  return res;
}

References fme_apply::EqualizePattern::front, p, and fme_apply::EqualizePattern::ScaleOnly.

Referenced by entry().

set_input()

void fme_apply::set_input	(	luci::CircleNode *	node,
		luci::CircleCustom *	input
	)

It sets given 'input' to node's input.

Definition at line 99 of file Support.Misc.cpp.

{
  if (input == nullptr)
  {
    throw std::runtime_error("Invalid input.");
  }
 
  switch (node->opcode())
  {
    case luci::CircleOpcode::CONV_2D:
    {
      auto conv = loco::must_cast<luci::CircleConv2D *>(node);
      conv->input(input);
      break;
    }
    case luci::CircleOpcode::DEPTHWISE_CONV_2D:
    {
      auto dconv = loco::must_cast<luci::CircleDepthwiseConv2D *>(node);
      dconv->input(input);
      break;
    }
    case luci::CircleOpcode::FULLY_CONNECTED:
    {
      auto fc = loco::must_cast<luci::CircleFullyConnected *>(node);
      fc->input(input);
      break;
    }
    case luci::CircleOpcode::GELU:
    {
      auto gelu = loco::must_cast<luci::CircleGelu *>(node);
      gelu->features(input);
      break;
    }
    case luci::CircleOpcode::LEAKY_RELU:
    {
      auto relu = loco::must_cast<luci::CircleLeakyRelu *>(node);
      relu->features(input);
      break;
    }
    case luci::CircleOpcode::MAX_POOL_2D:
    {
      auto maxpool = loco::must_cast<luci::CircleMaxPool2D *>(node);
      maxpool->value(input);
      break;
    }
    case luci::CircleOpcode::PAD:
    {
      auto pad = loco::must_cast<luci::CirclePad *>(node);
      pad->input(input);
      break;
    }
    case luci::CircleOpcode::RELU:
    {
      auto relu = loco::must_cast<luci::CircleLeakyRelu *>(node);
      relu->features(input);
      break;
    }
    case luci::CircleOpcode::TRANSPOSE_CONV:
    {
      auto tconv = loco::must_cast<luci::CircleTransposeConv *>(node);
      tconv->outBackprop(input);
      break;
    }
    default:
    {
      throw std::runtime_error("(set_input) NYI operator: " + node->name());
    }
  }
}

References luci::CircleNode::name(), and luci::CircleNode::opcode().

to_scale()

luci::CircleCustom * fme_apply::to_scale

(

loco::Node *

node

)

Definition at line 22 of file Support.Cast.cpp.

{
  auto scale = dynamic_cast<luci::CircleCustom *>(node);
  if (not scale)
    return nullptr;
 
  if (scale->custom_code() != "scale")
    return nullptr;
 
  // TODO Return false?
  assert(scale->numInputs() == 2); // FIX_PreScale_UNLESS
 
  return scale;
}