def test_empty_input_not_declared(self):
with self.assertRaises(nnef.Error):
nnef.parse_string("""
version 1.0;
graph G( input ) -> ( output )
{
output = copy(input);
}
""")
def test_empty_output_not_declared(self):
with self.assertRaises(nnef.Error):
nnef.parse_string("""
version 1.0;
graph G( input ) -> ( output )
{
input = external(shape = []);
}
""")
def test_minimal(self):
nnef.parse_string("""
version 1.0;
graph G( input ) -> ( output )
{
input = external(shape = []);
output = copy(input);
}
""")
def test_variable_update(self):
nnef.parse_string("""
version 1.0;
graph G( input ) -> ( output )
{
input = external(shape = []);
var = variable(shape = [], label = 'var');
output = update(var, input);
}
""")
def test_non_variable_update(self):
with self.assertRaises(nnef.Error):
nnef.parse_string("""
version 1.0;
graph G( input ) -> ( output )
{
input = external(shape = []);
output = update(input, input);
}
""")
def test_input_not_external(self):
with self.assertRaises(nnef.Error):
nnef.parse_string("""
version 1.0;
graph G( input ) -> ( output )
{
input = constant(shape = [], value = [1.0]);
output = copy(input);
}
""")
def test_external_not_input(self):
with self.assertRaises(nnef.Error):
nnef.parse_string("""
version 1.0;
graph G( input ) -> ( output )
{
input = external(shape = []);
other = external(shape = []);
output = add(input, other);
}
""")
def test_custom_fragment(self):
nnef.parse_string("""
version 1.0;
extension KHR_enable_fragment_definitions, KHR_enable_operator_expressions;
fragment op( input: tensor<scalar> ) -> ( output: tensor<scalar> )
{
output = input;
}
graph G( input ) -> ( output )
{
input = external(shape = []);
output = op(input);
}
""")
def test_reshape(self):
graph = nnef.parse_string("""
version 1.0;
graph G( input ) -> ( output )
{
input = external(shape = [1,2,3,4]);
output = reshape(input, axis_start = 1, axis_count = 2, shape = [6]);
}
""")
nnef.infer_shapes(graph)
# See the License for the specific language governing permissions and
# limitations under the License.
import nnef
def shuffle_shape(op, args, shapes):
shapes[args['output']] = shapes[args['input']]
nnef._register_custom_ops(
"shuffle",
"fragment shuffle<?>( input: tensor<?>, groups: integer ) -> ( output: tensor<?> );"
)
nnef._register_custom_shapes({"shuffle": shuffle_shape})
graph = nnef.parse_string("""
version 1.0;
graph Net( input ) -> ( output )
{
input = external(shape = [1,3,224,224]);
filter = variable(shape = [32,3,5,5], label = 'conv/filter');
conv = conv(input, filter);
output = shuffle(conv, groups = 4);
}
""")
print(
nnef.format_graph(graph.name, graph.inputs, graph.outputs,
graph.operations))
import nnef
def shuffle_shape(input, groups):
assert input[
1] % groups == 0, "input channels ({}) is not divisible by groups ({})".format(
input[1], groups)
return input
graph = nnef.parse_string("""
version 1.0;
extension KHR_enable_fragment_definitions;
fragment shuffle<?>( input: tensor<?>, groups: integer ) -> ( output: tensor<?> );
graph Net( input ) -> ( output )
{
input = external(shape = [1,3,224,224]);
filter = variable(shape = [32,3,5,5], label = 'conv/filter');
conv = conv(input, filter);
output = shuffle(conv, groups = 4);
}
""")
nnef.infer_shapes(graph, custom_shapes={'shuffle': shuffle_shape})
print(
nnef.format_graph(graph.name, graph.inputs, graph.outputs,
graph.operations))
def parse_string(string):
with ParserConfigToExpandNonAtomics:
with default_config:
return nnef.parse_string(string)
def parse_string(self, graph_str, quant_str=None):
return nnef.parse_string(graph_str=graph_str,
quant_str=quant_str,
stdlib=self._source,
lowered=self._expand)
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import nnef
def shuffle_shape(proto, args, shapes):
shapes[args['output']] = shapes[args['input']]
nnef._register_custom_ops(
"shuffle",
"fragment shuffle<?>( input: tensor<?>, groups: integer ) -> ( output: tensor<?> );"
)
nnef._register_custom_shapes({"shuffle": shuffle_shape})
attrs, ops = nnef.parse_string("""
version 1.0;
graph Net( input ) -> ( output )
{
input = external(shape = [1,3,224,224]);
filter = variable(shape = [32,3,5,5], label = 'conv/filter');
conv = conv(input, filter);
output = shuffle(conv, groups = 4);
}
""",
atomics=nnef.StandardOperations + ["shuffle"])
print(nnef.format_document(attrs, ops))
def parse_string(self, graph_str, quant_str=None):
return nnef.parse_string(graph_str=graph_str,
quant_str=quant_str,
stdlib=self.fragments,
lowered=self.lowered)
def parse_string(string):
with default_config:
return nnef.parse_string(string, atomics=AtomicOperations)
def test_empty_document(self):
with self.assertRaises(nnef.Error):
nnef.parse_string("")
def test_empty_body(self):
with self.assertRaises(nnef.Error):
nnef.parse_string("version 1.0; graph G( input ) -> ( output ) {}")
# Copyright (c) 2017 The Khronos Group Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import nnef
attrs, ops = nnef.parse_string(
"version 1.0;"
"graph Net( input ) -> ( output )"
"{"
" input = external(shape = [1,3,224,224]);"
" filter = variable(shape = [32,3,5,5], label = 'conv/filter');"
" output = conv(input, filter);"
"}")
print(nnef.format_document(attrs, ops))
def parse_string(self, graph_str, quant_str=None):
return nnef.parse_string(graph_str=graph_str,
quant_str=quant_str,
stdlib=self.custom_ops,
lowered=self.expand)
