Struct caffe2_transform::PatternNetTransform

pub struct PatternNetTransform { /* private fields */ }

| PatternNetTransform allows you to | create transforms using a simple interface. | | Simply provide a Pattern NetDef and | a Replace | | NetDef, and this Transform will find | subgraphs which fit the pattern net, | and replace it with the replace net. |

Implementations

impl PatternNetTransform

pub fn new(pattern_net: &NetDef, replace_net: &NetDef) -> Self

pub fn enable_argument_matching(&mut self)

pub fn disable_argument_matching(&mut self)

pub fn transform_blob_wrapper(&mut self, blob_name: &String) -> String

pub fn get_pattern_traversal_order(&mut self, graph: &Graph) -> Vec<i32>

This returns a permutation of the Pattern Net’s operators. The permutation satisfies this property:

• For any index i, order(i) is a neighbor of some node from {order(1), …, order(i-1)}.

Why is this important? Consider the following case: PatternNet: 0 —> 2 <— 1

When we have matched onto [0], and trying to add [1] to our subgraph, we cannot, since PatternMatch only considers neighbors of the current subgraph as a candidate next node.

Therefore, we must present the subgraph in an order such that each node is a neighbor of its prefix subgraph. One ordering for the above example is [0, 2, 1].

First, single source traverse through the netdef. This ensures all newly ordered are reachable from their prefix subset Outputs a permutation of the operators.

pub fn pattern_rule( &mut self, g: &Graph, subgraph: &Vec<i32>, g_idx: i32 ) -> bool

| We want to the final result of subgraph | to match the PatternNet in the order | of ordered_ops, operator by operator. | | [[[ ie. g.node(subgraph[i]) should | match p.node(ordered_ops[i]) ]]] | | PatternRule for PatternNetTransform | does the following: | | When trying to insert node idx into subgraph[p_idx], | we need to see if the edges between index | and the subgraph match the edges between | p[ordered_ops[idx]] and p[ordered_ops[0]…ordered_ops[p_idx-1]]. | | g.node(subgraph[i]) should match | p_.node(ordered_ops_[i]) | | g.node(g_idx) should match p_.node(p_idx) |

pub fn validator_rule(&mut self, g: &Graph, subgraph: &Vec<i32>) -> bool

| ValidatorRule for PatternNetTransform | does the following: | | Checks if the size of subgraph and p.size() | are the same. That’s it! |

pub fn replace_rule(&mut self, match_: &Vec<i32>, g_ptr: *mut Graph) -> bool

| ReplaceRule for PatternNet Transform | does the following: | | 1) Figure out edge renamings for edges | going into/out of the subgraph. | | That is, for each blob in the pattern | graph, what is it called in the matched | subgraph? | | 2) Remove the matched subgraph. | | 3) Append the replace graph’s operators | to the graph’s operators, and use the | renamings to rename the blob names. | | 4) Create all the children/parent | relationships within the replaced | graph, and stitch together the inputs | and outputs into the rest of the graph, | matching the removed subgraph. |

Trait Implementations

impl Transform for PatternNetTransform

fn pattern_match(&mut self, graph: &Graph) -> Vec<Vec<i32>>

| Generates all matches (stored as ordered | subgraphs) and returns them. | | A match is stored as vector, which | is a mapping to OperatorDefs in Graph. | The order matters. |

fn try_neighbors( &mut self, graph: &Graph, neighbors: &HashMap<i32, Vec<String>>, matched: &Vec<bool>, subgraph_ptr: *mut Vec<i32>, best_subgraph_ptr: *mut Vec<i32> )

| Attempts to append each neighbor to | the end of the subgraph. |

fn pattern_match_helper( &mut self, graph: &Graph, matched: &Vec<bool>, subgraph_ptr: *mut Vec<i32>, best_subgraph_ptr: *mut Vec<i32> )

| A helper function for PatternMatch, | which keeps track of the best subgraph | so far. |

fn pattern_rule(&mut self, g: &Graph, subgraph: &Vec<i32>, idx: i32) -> bool

| The PatternRule essentially answers: | | Given the current subgraph (ordered), | should we append the new node at idx? |

fn validator_rule(&mut self, g: &Graph, subgraph: &Vec<i32>) -> bool

| The ValidatorRule essentially answers: | | Given a subgraph, can we accept it? |

fn replace_rule(&mut self, subgraph: &Vec<i32>, g_ptr: *mut Graph) -> bool

| The ReplaceRule actually mutates the | graph, and applies the transformation | upon the subgraph. |

fn set_pattern_match_type(&mut self, ty: PatternMatchType)

fn replace_pattern(&mut self, matches: &Vec<Vec<i32>>, graph: *mut Graph)

| Applies the replace rule onto each of | the matches found. |

fn apply_to(&mut self, orig_net: &NetDef) -> NetDef

| Apply a Transform onto a NetDef. | | Returns the transformed NetDef. | | The simple interface - performs the | transformation upon a NetDef, and returns | the result. |