xmos-ai-tools 1.2.1.dev20__py3-none-win_amd64.whl → 1.3.2.dev180__py3-none-win_amd64.whl

xmos_ai_tools/runtime/include/tensorflow/lite/schema/schema_utils.h

@@ -18,7 +18,7 @@ limitations under the License.
 #include "flatbuffers/flatbuffers.h"
 #include "tensorflow/lite/schema/schema_generated.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 // The following methods are introduced to resolve op builtin code shortage
 // problem. The new builtin operator will be assigned to the extended builtin
@@ -28,6 +28,6 @@ BuiltinOperator GetBuiltinCode(const OperatorCode *op_code);
 
 BuiltinOperator GetBuiltinCode(const OperatorCodeT *op_code);
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_SCHEMA_SCHEMA_UTILS_H_

xmos_ai_tools/xformer/__init__.py

@@ -1,60 +1,64 @@
-import subprocess
-import typing
-from pathlib import Path
-from typing import Union, List, Optional
-from .flash import generate_flash
-import re
-
-__compilation_output = ""
-__arena_size = 0
-
-
-def convert(
-    filename: Union[str, Path],
-    outfile: Union[str, Path],
-    params: Optional[typing.Dict[str, Optional[str]]],
-) -> int:
-    args: List[str] = ["xcore-opt", "-o", str(outfile)]
-
-    if params is not None:
-        for key, val in params.items():
-            if len(key) > 1:
-                flag: str = "--" + str(key)
-            else:
-                flag = "-" + str(key)
-            if str(val) == "" or val is None:
-                args.append(flag)
-            else:
-                args.append(f"{flag}={val}")
-
-    args.append(str(filename))
-
-    process_call: subprocess.CompletedProcess = subprocess.run(
-        [arg for arg in args],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-        check=True,
-    )
-
-    global __compilation_output, __arena_size
-    __compilation_output = process_call.stdout.decode("utf-8")
-    size_str = re.sub("((.|\n|\r)*)Tensor arena size :", "", __compilation_output)
-    size_str = re.sub("(\n|\r)((.|\n|\r)*)", "", size_str)
-    __arena_size = int(size_str.strip())
-
-    return process_call.returncode
-
-
-def tensor_arena_size() -> int:
-    return __arena_size
-
-
-def print_optimization_report():
-    print(__compilation_output)
-
-
-def print_help(show_hidden: Optional[bool] = False) -> int:
-    if show_hidden:
-        return subprocess.run(["xcore-opt", "--help-list-hidden"]).returncode
-
-    return subprocess.run(["xcore-opt", "--help-list"]).returncode
+import subprocess
+import typing
+from pathlib import Path
+from typing import Union, List, Optional, Tuple
+from .flash import generate_flash
+import re
+
+__compilation_stdout = ""
+__compilation_stderr = ""
+__arena_size = 0
+
+
+def convert(
+    filename: Union[str, Path],
+    outfile: Union[str, Path],
+    params: Optional[List[Tuple[str, Optional[str]]]],
+) -> int:
+    args: List[str] = ["xcore-opt", "-o", str(outfile)]
+
+    if params is not None:
+        for key, val in params:
+            if len(key) > 1:
+                flag: str = "--" + str(key)
+            else:
+                flag = "-" + str(key)
+            if str(val) == "" or val is None:
+                args.append(flag)
+            else:
+                args.append(f"{flag}={val}")
+
+    args.append(str(filename))
+
+    try:
+        process_call: subprocess.CompletedProcess = subprocess.run(
+            [arg for arg in args],
+            check=True, text=True, capture_output=True,
+        )
+        global __compilation_stdout, __compilation_stderr, __arena_size
+        __compilation_stdout = process_call.stdout
+        __compilation_stderr = process_call.stderr
+        size_str = re.sub("((.|\n|\r)*)Tensor arena size :", "", __compilation_stdout)
+        size_str = re.sub("(\n|\r)((.|\n|\r)*)", "", size_str)
+        __arena_size = int(size_str.strip())
+        return process_call.returncode
+    except subprocess.CalledProcessError as e:
+        print(e)
+        print("Return code:", e.returncode)
+        print("Error output:", e.stderr)
+
+
+def tensor_arena_size() -> int:
+    return __arena_size
+
+
+def print_optimization_report():
+    print(__compilation_stderr)
+    print(__compilation_stdout)
+
+
+def print_help(show_hidden: Optional[bool] = False) -> int:
+    if show_hidden:
+        return subprocess.run(["xcore-opt", "--help-list-hidden"]).returncode
+
+    return subprocess.run(["xcore-opt", "--help-list"]).returncode

xmos_ai_tools/xformer/flash.py

@@ -1,190 +1,190 @@
-BYTES_FOR_MAGIC_PATTERN = 32
-BYTES_FOR_VERSION = 4
-BYTES_PER_ENGINE_HEADER = 16
-VERSION_MAJOR = 1
-VERSION_MINOR = 2
-
-
-class FlashBuilder:
-    class Header:
-        """
-        Class that stores a header for a flash file system
-        The header comprises the addresses of the model, parameters, and operators
-        relative to the start address
-        """
-
-        def __init__(self, model_bytes, params_bytes, ops_bytes, xip_bytes, start):
-            self.model_start = start
-            self.parameters_start = self.model_start + model_bytes + 4  # len
-            self.operators_start = self.parameters_start + params_bytes  # no len
-            self.xip_start = self.operators_start + ops_bytes  # no len
-            new_start = self.xip_start + xip_bytes  # no len
-            self.length = new_start - start
-
-    def __init__(self, engines=1):
-        self.engines = engines
-        self.models = [bytes([])] * engines
-        self.params = [bytes([])] * engines
-        self.ops = [bytes([])] * engines
-        self.xips = [bytes([])] * engines
-
-    @staticmethod
-    def read_whole_binary_file(filename):
-        """
-        Reads a whole binary file in and returns bytes(). If the file to be read is called '-'
-        then an empty bytes is returned.
-        """
-        if filename == "-":
-            return bytes([])
-        try:
-            with open(filename, "rb") as input_fd:
-                contents = input_fd.read()
-            return contents
-        except:
-            print('File "%s" is not a readable file' % (filename))
-            return None
-
-    @staticmethod
-    def create_params_image(params=None, filename=None):
-        if params is None:
-            params = FlashBuilder.read_whole_binary_file(filename)
-        return params
-
-    @staticmethod
-    def create_model_image(model=None, filename=None):
-        if model is None:
-            model = FlashBuilder.read_whole_binary_file(filename)
-        return model
-
-    @staticmethod
-    def create_params_file(params_filename, params=None, input_filename=None):
-        image = FlashBuilder.create_params_image(params=params, filename=input_filename)
-        with open(params_filename, "wb") as output_fd:
-            output_fd.write(image)
-
-    @staticmethod
-    def tobytes(integr):
-        """Converts an int to a LSB first quad of bytes"""
-        data = []
-        for i in range(4):
-            data.append((integr >> (8 * i)) & 0xFF)
-        return bytes(data)
-
-    @staticmethod
-    def swap_nibbles(x):
-        return (x & 0x0F) << 4 | (x & 0xF0) >> 4
-
-    def add_params(self, engine, params=None, filename=None):
-        image = FlashBuilder.create_params_image(params, filename)
-        self.params[engine] = image
-
-    def add_model(self, engine, model=None, filename=None):
-        image = FlashBuilder.create_model_image(model, filename)
-        self.models[engine] = image
-
-    def flash_image(self):
-        """
-        Builds a flash image out of a collection of models and parameter blobs.
-        This function returns a bytes comprising the header, models, parameters, etc.
-        The whole thing should be written as is to flash
-        """
-        headers = [None] * self.engines
-        start = (
-            BYTES_FOR_MAGIC_PATTERN
-            + BYTES_FOR_VERSION
-            + BYTES_PER_ENGINE_HEADER * self.engines
-        )
-        for i in range(self.engines):
-            headers[i] = FlashBuilder.Header(
-                len(self.models[i]),
-                len(self.params[i]),
-                len(self.ops[i]),
-                len(self.xips[i]),
-                start,
-            )
-            start += headers[i].length
-
-        # We add the magic fast flash pattern of 32 bytes at the very beginning
-        # After that comes the version
-        output = bytes(
-            [
-                0xFF,
-                0x00,
-                0x0F,
-                0x0F,
-                0x0F,
-                0x0F,
-                0x0F,
-                0x0F,
-                0xFF,
-                0x00,
-                0xFF,
-                0x00,
-                0xFF,
-                0x00,
-                0xFF,
-                0x00,
-                0x31,
-                0xF7,
-                0xCE,
-                0x08,
-                0x31,
-                0xF7,
-                0xCE,
-                0x08,
-                0x9C,
-                0x63,
-                0x9C,
-                0x63,
-                0x9C,
-                0x63,
-                0x9C,
-                0x63,
-            ]
-        )
-
-        output += bytes(
-            [VERSION_MAJOR, VERSION_MINOR, 0xFF ^ VERSION_MAJOR, 0xFF ^ VERSION_MINOR]
-        )
-
-        for i in range(self.engines):
-            output += FlashBuilder.tobytes(
-                headers[i].model_start
-            )  # encode start of model
-            output += FlashBuilder.tobytes(
-                headers[i].parameters_start
-            )  # encode start of params
-            output += FlashBuilder.tobytes(
-                headers[i].operators_start
-            )  # encode start of ops
-            output += FlashBuilder.tobytes(headers[i].xip_start)  # encode start of xip
-
-        for i in range(self.engines):
-            output += FlashBuilder.tobytes(len(self.models[i]))  # encode len of model
-            output += self.models[i]  # add model image
-            output += self.params[i]  # add params image
-            output += self.ops[i]  # add operators image
-            output += self.xips[i]  # add exec in place image
-        return output
-
-    def flash_file(self, filename):
-        """
-        Builds a file for the host system that comprises a single parameter blob.
-        """
-        output = self.flash_image()
-        # swap nibbles around
-        swapped_output = bytes([FlashBuilder.swap_nibbles(byte) for byte in output])
-        with open(filename, "wb") as output_fd:
-            output_fd.write(swapped_output)
-
-
-def generate_flash(*, output_file, model_files, param_files):
-    assert len(model_files) == len(
-        param_files
-    ), "The number of provided model files must match the number of param files!"
-    num_of_engines = len(model_files)
-    fb = FlashBuilder(engines=num_of_engines)
-    for i in range(num_of_engines):
-        fb.add_model(i, filename=model_files[i])
-        fb.add_params(i, filename=param_files[i])
-    fb.flash_file(output_file)
+BYTES_FOR_MAGIC_PATTERN = 32
+BYTES_FOR_VERSION = 4
+BYTES_PER_ENGINE_HEADER = 16
+VERSION_MAJOR = 1
+VERSION_MINOR = 2
+
+
+class FlashBuilder:
+    class Header:
+        """
+        Class that stores a header for a flash file system
+        The header comprises the addresses of the model, parameters, and operators
+        relative to the start address
+        """
+
+        def __init__(self, model_bytes, params_bytes, ops_bytes, xip_bytes, start):
+            self.model_start = start
+            self.parameters_start = self.model_start + model_bytes + 4  # len
+            self.operators_start = self.parameters_start + params_bytes  # no len
+            self.xip_start = self.operators_start + ops_bytes  # no len
+            new_start = self.xip_start + xip_bytes  # no len
+            self.length = new_start - start
+
+    def __init__(self, engines=1):
+        self.engines = engines
+        self.models = [bytes([])] * engines
+        self.params = [bytes([])] * engines
+        self.ops = [bytes([])] * engines
+        self.xips = [bytes([])] * engines
+
+    @staticmethod
+    def read_whole_binary_file(filename):
+        """
+        Reads a whole binary file in and returns bytes(). If the file to be read is called '-'
+        then an empty bytes is returned.
+        """
+        if filename == "-":
+            return bytes([])
+        try:
+            with open(filename, "rb") as input_fd:
+                contents = input_fd.read()
+            return contents
+        except:
+            print('File "%s" is not a readable file' % (filename))
+            return None
+
+    @staticmethod
+    def create_params_image(params=None, filename=None):
+        if params is None:
+            params = FlashBuilder.read_whole_binary_file(filename)
+        return params
+
+    @staticmethod
+    def create_model_image(model=None, filename=None):
+        if model is None:
+            model = FlashBuilder.read_whole_binary_file(filename)
+        return model
+
+    @staticmethod
+    def create_params_file(params_filename, params=None, input_filename=None):
+        image = FlashBuilder.create_params_image(params=params, filename=input_filename)
+        with open(params_filename, "wb") as output_fd:
+            output_fd.write(image)
+
+    @staticmethod
+    def tobytes(integr):
+        """Converts an int to a LSB first quad of bytes"""
+        data = []
+        for i in range(4):
+            data.append((integr >> (8 * i)) & 0xFF)
+        return bytes(data)
+
+    @staticmethod
+    def swap_nibbles(x):
+        return (x & 0x0F) << 4 | (x & 0xF0) >> 4
+
+    def add_params(self, engine, params=None, filename=None):
+        image = FlashBuilder.create_params_image(params, filename)
+        self.params[engine] = image
+
+    def add_model(self, engine, model=None, filename=None):
+        image = FlashBuilder.create_model_image(model, filename)
+        self.models[engine] = image
+
+    def flash_image(self):
+        """
+        Builds a flash image out of a collection of models and parameter blobs.
+        This function returns a bytes comprising the header, models, parameters, etc.
+        The whole thing should be written as is to flash
+        """
+        headers = [None] * self.engines
+        start = (
+            BYTES_FOR_MAGIC_PATTERN
+            + BYTES_FOR_VERSION
+            + BYTES_PER_ENGINE_HEADER * self.engines
+        )
+        for i in range(self.engines):
+            headers[i] = FlashBuilder.Header(
+                len(self.models[i]),
+                len(self.params[i]),
+                len(self.ops[i]),
+                len(self.xips[i]),
+                start,
+            )
+            start += headers[i].length
+
+        # We add the magic fast flash pattern of 32 bytes at the very beginning
+        # After that comes the version
+        output = bytes(
+            [
+                0xFF,
+                0x00,
+                0x0F,
+                0x0F,
+                0x0F,
+                0x0F,
+                0x0F,
+                0x0F,
+                0xFF,
+                0x00,
+                0xFF,
+                0x00,
+                0xFF,
+                0x00,
+                0xFF,
+                0x00,
+                0x31,
+                0xF7,
+                0xCE,
+                0x08,
+                0x31,
+                0xF7,
+                0xCE,
+                0x08,
+                0x9C,
+                0x63,
+                0x9C,
+                0x63,
+                0x9C,
+                0x63,
+                0x9C,
+                0x63,
+            ]
+        )
+
+        output += bytes(
+            [VERSION_MAJOR, VERSION_MINOR, 0xFF ^ VERSION_MAJOR, 0xFF ^ VERSION_MINOR]
+        )
+
+        for i in range(self.engines):
+            output += FlashBuilder.tobytes(
+                headers[i].model_start
+            )  # encode start of model
+            output += FlashBuilder.tobytes(
+                headers[i].parameters_start
+            )  # encode start of params
+            output += FlashBuilder.tobytes(
+                headers[i].operators_start
+            )  # encode start of ops
+            output += FlashBuilder.tobytes(headers[i].xip_start)  # encode start of xip
+
+        for i in range(self.engines):
+            output += FlashBuilder.tobytes(len(self.models[i]))  # encode len of model
+            output += self.models[i]  # add model image
+            output += self.params[i]  # add params image
+            output += self.ops[i]  # add operators image
+            output += self.xips[i]  # add exec in place image
+        return output
+
+    def flash_file(self, filename):
+        """
+        Builds a file for the host system that comprises a single parameter blob.
+        """
+        output = self.flash_image()
+        # swap nibbles around
+        swapped_output = bytes([FlashBuilder.swap_nibbles(byte) for byte in output])
+        with open(filename, "wb") as output_fd:
+            output_fd.write(swapped_output)
+
+
+def generate_flash(*, output_file, model_files, param_files):
+    assert len(model_files) == len(
+        param_files
+    ), "The number of provided model files must match the number of param files!"
+    num_of_engines = len(model_files)
+    fb = FlashBuilder(engines=num_of_engines)
+    for i in range(num_of_engines):
+        fb.add_model(i, filename=model_files[i])
+        fb.add_params(i, filename=param_files[i])
+    fb.flash_file(output_file)

xmos_ai_tools/xinterpreters/__init__.py

@@ -1 +1 @@
-from .host_interpreter import TFLMHostInterpreter
+from .host_interpreter import TFLMHostInterpreter

xmos_ai_tools/xinterpreters/exceptions.py

@@ -1,38 +1,38 @@
-# Copyright 2021 XMOS LIMITED. This Software is subject to the terms of the
-# XMOS Public License: Version 1
-
-
-class InterpreterError(Exception):
-    pass
-
-
-class AllocateTensorsError(InterpreterError):
-    pass
-
-
-class InvokeError(InterpreterError):
-    pass
-
-
-class SetTensorError(InterpreterError):
-    pass
-
-
-class GetTensorError(InterpreterError):
-    pass
-
-
-class ModelSizeError(InterpreterError):
-    pass
-
-
-class ArenaSizeError(InterpreterError):
-    pass
-
-
-class DeviceTimeoutError(InterpreterError):
-    pass
-
-
-class GetProfilerTimesError(InterpreterError):
-    pass
+# Copyright 2021 XMOS LIMITED. This Software is subject to the terms of the
+# XMOS Public License: Version 1
+
+
+class InterpreterError(Exception):
+    pass
+
+
+class AllocateTensorsError(InterpreterError):
+    pass
+
+
+class InvokeError(InterpreterError):
+    pass
+
+
+class SetTensorError(InterpreterError):
+    pass
+
+
+class GetTensorError(InterpreterError):
+    pass
+
+
+class ModelSizeError(InterpreterError):
+    pass
+
+
+class ArenaSizeError(InterpreterError):
+    pass
+
+
+class DeviceTimeoutError(InterpreterError):
+    pass
+
+
+class GetProfilerTimesError(InterpreterError):
+    pass