tinymlc 0.1.0__py3-none-any.whl

TinyMLC/generate_lut.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+# TinyMLC - Tiny Machine Learning Compiler
+#
+# Copyright (c) 2026 Jia Liu & TinyMLC Contributors
+# SPDX-License-Identifier: Apache-2.0
+#
+# This file is part of TinyMLC.
+# 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.
+
+#!/usr/bin/env python3
+"""
+Generate sigmoid and tanh int16 lookup tables (256 entries,
+for int8 quantized LSTM)
+"""
+
+import numpy as np
+from pathlib import Path
+from jinja2 import Template
+
+from utils.dump import fatal_error, info
+
+
+def generate_sigmoid_lut():
+    """Generate sigmoid LUT, output int16 range [0, 32767]"""
+    x = np.linspace(-8, 8, 256, endpoint=False)
+    y = 1 / (1 + np.exp(-x))
+    # Quantize to int16: 0~1 maps to 0~32767
+    y_scaled = np.round(y * 32767).astype(np.int16)
+    return y_scaled
+
+
+def generate_tanh_lut():
+    """Generate tanh LUT, output int16 range [-32768, 32767]"""
+    x = np.linspace(-8, 8, 256, endpoint=False)
+    y = np.tanh(x)
+    # Quantize to int16: -1~1 maps to -32768~32767
+    y_scaled = np.round(y * 32767).astype(np.int16)
+    return y_scaled
+
+
+def generate_lut(output_dir: Path):
+    """Generate LUT header and source files"""
+    try:
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        sigmoid_lut = generate_sigmoid_lut()
+        tanh_lut = generate_tanh_lut()
+
+        # Render lut.h.tpl
+        template_path = Path(__file__).parent / 'templates' / 'lut.h.tpl'
+        with open(template_path, 'r') as f:
+            template = Template(f.read())
+
+        lut_h = template.render(
+            sigmoid_lut=sigmoid_lut.tolist(),
+            tanh_lut=tanh_lut.tolist()
+        )
+
+        with open(output_dir / 'lut.h', 'w') as f:
+            f.write(lut_h)
+
+        # Render lut.c.tpl
+        template_path = Path(__file__).parent / 'templates' / 'lut.c.tpl'
+        with open(template_path, 'r') as f:
+            template = Template(f.read())
+
+        lut_c = template.render()
+
+        with open(output_dir / 'lut.c', 'w') as f:
+            f.write(lut_c)
+
+        info(f"Generated: {output_dir}/lut.h")
+        info(f"Generated: {output_dir}/lut.c")
+
+    except Exception as e:
+        fatal_error(
+            f"LUT generation failed: {e}",
+            "Check numpy and file system permissions")
+
+
+def main():
+    output_dir = Path('tinymlc_generated')
+    generate_lut(output_dir)
+
+
+if __name__ == "__main__":
+    main()

TinyMLC/handlers.py

@@ -0,0 +1,325 @@
+# -*- coding: utf-8 -*-
+# TinyMLC - Tiny Machine Learning Compiler
+#
+# Copyright (c) 2026 Jia Liu & TinyMLC Contributors
+# SPDX-License-Identifier: Apache-2.0
+#
+# This file is part of TinyMLC.
+# 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.
+
+#!/usr/bin/env python3
+"""
+Command handlers for TinyMLC CLI.
+Contains handle_generate, handle_table, handle_convert.
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+from TinyMLC.ANG.model_generator import ModelGenerator
+from TinyMLC.ANG.args import create_estimator
+from TinyMLC.converter.parser_litert import parse_model_tflite, extract_all_weights_litert
+from TinyMLC.converter.parser_onnx import parse_model_onnx, extract_all_weights_onnx
+from TinyMLC.converter.export_weights import export_model_weights
+from utils.path import get_output_dir
+from TinyMLC.codegen import generate_c_code, copy_files_to_build
+from TinyMLC.generate_lut import generate_lut
+from TinyMLC.transform.pass_manager import PassManager
+from utils.dump import fatal_error, warning, info, dump_model_info
+
+
+def handle_generate(args: argparse.Namespace) -> int:
+    info("Running network generation...")
+    estimator = create_estimator(args)
+
+    generator = ModelGenerator(
+        estimator=estimator,
+        config={
+            "task_type": getattr(args, "task_type", "classification"),
+            "population_size": getattr(args, "population", 50),
+            "generations": getattr(args, "generations", 50),
+            "mutation_rate": getattr(args, "mutation_rate", 0.1),
+            "crossover_rate": getattr(args, "crossover_rate", 0.8),
+            "early_stop": getattr(args, "early_stop", 10),
+            "input_shape": getattr(args, "input_shape", [1, 28, 28, 1]),
+            "output_shape": getattr(args, "output_shape", [1, 10]),
+            "max_macs": getattr(args, "max_macs", 100000),
+            "max_ram": getattr(args, "max_ram", 30) * 1024,
+            "max_flash": getattr(args, "max_flash", 64) * 1024,
+            "num_samples": getattr(args, "num_samples", 100),
+        },
+    )
+
+    mode = getattr(args, "generate_mode", "genetic")
+    model_info = generator.generate(mode=mode)
+
+    # Get target, mode, accel for code generation and build
+    target = getattr(args, "target", "riscv")
+    mode = getattr(args, "mode", "release")
+    accel = getattr(args, "accel", "pure-c")
+    run = getattr(args, "run", False)
+
+    # Validate target/accel/mode combination
+    if target == "arm":
+        if accel not in ("pure-c", "cmsis-nn"):
+            fatal_error(
+                f"Invalid --accel '{accel}' for --target arm",
+                "Supported accel for ARM: pure-c, cmsis-nn")
+    elif target == "riscv":
+        if accel not in ("pure-c", "nmsis-nn", "nuclei-ai"):
+            fatal_error(
+                f"Invalid --accel '{accel}' for --target riscv",
+                "Supported accel for RISC-V: pure-c, nmsis-nn, nuclei-ai")
+    elif target == "host":
+        # Host only supports pure-c and debug mode
+        if accel != "pure-c":
+            fatal_error(
+                f"Invalid --accel '{accel}' for --target host",
+                "Host only supports pure-c (no hardware acceleration)")
+        if mode != "debug":
+            warning("Host target only supports debug mode, forcing mode=debug")
+            mode = "debug"
+
+    # ---- Dump model_info BEFORE optimization? No ----
+    # dump_model = getattr(args, "dump_model", None)
+    # if dump_model:
+    #     with open(dump_model, "w") as f:
+    #         json.dump(model_info, f, indent=2, default=str)
+    #     info(f"Model info saved to: {dump_model}")
+
+    # ---- Optimization passes ----
+    pm = PassManager.default_pipeline()
+    info("Running optimization passes...")
+    optimized_model_info = pm.run(model_info)
+    pm.dump_summary()
+
+    # ---- Generate C code ----
+    info("Generating C code...")
+    out_dir = get_output_dir(args)
+    result = generate_c_code(
+        model_info=optimized_model_info,
+        output_dir=str(out_dir),
+        target=target,
+        inference_func=getattr(args, "inference_function_name",
+                               "tinymlc_inference"),
+        with_test_main=True,  # Always generate test main for generated networks
+    )
+
+    # ---- Dump optimized model_info (with quant_scales) ----
+    dump_model = getattr(args, "dump_model", None)
+    if dump_model:
+        with open(dump_model, "w") as f:
+            json.dump(optimized_model_info, f, indent=2, default=str)
+        info(f"Optimized model info saved to: {dump_model}")
+
+    for filename, content in result.items():
+        filepath = out_dir / filename
+        with open(filepath, "w") as f:
+            f.write(content)
+        info(f"Generated: {filepath}")
+
+    # Export weights (needed for ANG-generated models)
+    quant_scales = export_model_weights(out_dir, optimized_model_info)
+    optimized_model_info["quant_scales"] = quant_scales
+
+    # Generate LUT and copy build files
+    generate_lut(out_dir)
+
+    # Compute accel library paths if not provided
+    project_root = Path(__file__).parent
+    accel_lib_inc = getattr(args, "accel_lib_inc", None)
+    accel_lib_lib = getattr(args, "accel_lib_lib", None)
+
+    if accel == "cmsis-nn" and (not accel_lib_inc or not accel_lib_lib):
+        accel_lib_inc = str(project_root / "third_party" /
+                           "CMSIS-NN-7.0.0" / "Include")
+        accel_lib_lib = str(project_root / "third_party" /
+                           "CMSIS-NN-7.0.0" / "Lib" / "libcmsis-nn.a")
+    elif accel == "nmsis-nn" and (not accel_lib_inc or not accel_lib_lib):
+        accel_lib_inc = str(project_root / "third_party" /
+                           "NMSIS-NN-1.6.0" / "Include")
+        accel_lib_lib = str(project_root / "third_party" /
+                           "NMSIS-NN-1.6.0" / "Lib" / "libNMSISNN.a")
+
+    if accel == "pure-c":
+        copy_files_to_build(out_dir, target, mode, accel)
+    copy_files_to_build(out_dir, target, mode, accel,
+                        accel_lib_inc, accel_lib_lib)
+
+    # Determine script name (must match copy_files_to_build logic)
+    if target == "host":
+        script_name = "build_host_debug.sh"
+    elif accel != 'none':
+        script_name = f"build_{target}_{accel.replace('-', '_')}_{mode}.sh"
+    else:
+        script_name = f"build_{target}_{mode}.sh"
+
+    if run:
+        script_path = out_dir / script_name
+        try:
+            script_path.chmod(0o755)
+        except OSError:
+            pass
+        info(f"Executing: {script_path}")
+        result = subprocess.run(
+            [str(script_path.resolve())],
+            cwd=out_dir)
+        sys.exit(result.returncode)
+
+    info(f"Done! Output directory: {out_dir}")
+    info("\nNext steps:")
+    info(f"  cd {out_dir}")
+    info(f"  ./{script_name}")
+
+    return 0
+
+
+def handle_convert(args: argparse.Namespace) -> int:
+    target = getattr(args, "target", None)
+    mode = getattr(args, "mode", None)
+    accel = getattr(args, "accel", None)
+    model_path = getattr(args, "model", None)
+    output_dir = Path(getattr(args, "output_dir", ".."))
+    with_test_main = getattr(args, "with_test_main", None)
+    inference_function_name = getattr(args, "inference_function_name", None)
+    verbose = getattr(args, "verbose", None)
+    run = getattr(args, "run", None)
+
+    if not model_path:
+        fatal_error("--model is required for convert")
+    if not Path(model_path).exists():
+        fatal_error(f"Model file not found: {model_path}",
+                    "Please check file path")
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    if model_path.endswith(".tflite"):
+        # Lazy import to avoid dependency when not using tflite
+        model_info = parse_model_tflite(model_path)
+        # Extract weights (interpreter created internally)
+        extract_all_weights_litert(model_path, model_info)
+        # Export weights using unified function
+        quant_scales = export_model_weights(output_dir, model_info)
+        model_info["quant_scales"] = quant_scales
+    elif model_path.endswith(".onnx"):
+        model_info = parse_model_onnx(model_path)
+        # Extract weights (model_path for consistency)
+        extract_all_weights_onnx(model_path, model_info)
+        # Export weights using unified function
+        quant_scales = export_model_weights(output_dir, model_info)
+        model_info["quant_scales"] = quant_scales
+    else:
+        fatal_error("Unsupported model format", "Supported: .tflite and .onnx")
+
+    info(f"Converting model: {model_path}")
+
+    if verbose:
+        dump_model_info(model_info)
+
+    if target == "arm":
+        if accel not in ("pure-c", "cmsis-nn"):
+            fatal_error(
+                f"Invalid --accel '{accel}' for --target arm",
+                "Supported accel for ARM: pure-c, cmsis-nn")
+    elif target == "riscv":
+        if accel not in ("pure-c", "nmsis-nn", "nuclei-ai"):
+            fatal_error(
+                f"Invalid --accel '{accel}' for --target riscv",
+                "Supported accel for RISC-V: pure-c, nmsis-nn, nuclei-ai")
+    elif target == "host":
+        # Host only supports pure-c and debug mode
+        if accel != "pure-c":
+            fatal_error(
+                f"Invalid --accel '{accel}' for --target host",
+                "Host only supports pure-c (no hardware acceleration)")
+        if mode != "debug":
+            warning("Host target only supports debug mode, forcing mode=debug")
+            mode = "debug"
+    else:
+        fatal_error(
+            f"Invalid --target '{target}'",
+            "Supported targets: arm, riscv, host")
+
+    dump_model = getattr(args, "dump_model", None)
+    if dump_model:
+        with open(dump_model, "w") as f:
+            json.dump(model_info, f, indent=2, default=str)
+    info(f"Model info saved to: {dump_model}")
+
+    # ---- Optimization passes ----
+    pm = PassManager.default_pipeline()
+    info("Running optimization passes...")
+    optimized_model_info = pm.run(model_info)
+    pm.dump_summary()
+
+    info("Generating C code...")
+    generated_files = generate_c_code(
+        optimized_model_info, output_dir, target,
+        inference_func=inference_function_name,
+        with_test_main=with_test_main)
+
+    for filename, content in generated_files.items():
+        output_path = output_dir / filename
+        with open(output_path, 'w') as f:
+            f.write(content)
+        info(f"Generated: {output_path}")
+
+    generate_lut(output_dir)
+
+    # Compute accel library paths if not provided
+    project_root = Path(__file__).parent
+    accel_lib_inc = getattr(args, "accel_lib_inc", None)
+    accel_lib_lib = getattr(args, "accel_lib_lib", None)
+
+    if accel == "cmsis-nn" and (not accel_lib_inc or not accel_lib_lib):
+        accel_lib_inc = str(project_root / "third_party" /
+                           "CMSIS-NN-7.0.0" / "Include")
+        accel_lib_lib = str(project_root / "third_party" /
+                           "CMSIS-NN-7.0.0" / "Lib" / "libcmsis-nn.a")
+    elif accel == "nmsis-nn" and (not accel_lib_inc or not accel_lib_lib):
+        accel_lib_inc = str(project_root / "third_party" /
+                           "NMSIS-NN-1.6.0" / "Include")
+        accel_lib_lib = str(project_root / "third_party" /
+                           "NMSIS-NN-1.6.0" / "Lib" / "libNMSISNN.a")
+
+    copy_files_to_build(output_dir, target, mode, accel,
+                        accel_lib_inc, accel_lib_lib)
+
+    # Determine script name
+    if target == "host":
+        script_name = "build_host_debug.sh"
+    elif accel != 'none':
+        script_name = (
+            f"build_{target}_{accel.replace('-', '_')}_{mode}.sh")
+    else:
+        script_name = f"build_{target}_{mode}.sh"
+
+    if run:
+        script_path = output_dir / script_name
+        try:
+            script_path.chmod(0o755)
+        except OSError:
+            pass
+        info(f"Executing: {script_path} {model_path}")
+        result = subprocess.run(
+            [str(script_path.resolve()), model_path],
+            cwd=output_dir)
+        sys.exit(result.returncode)
+
+    info(f"Done! Output directory: {output_dir}")
+    info("\nNext steps:")
+    info(f"  cd {output_dir}")
+    info(f"  ./{script_name} {model_path}")

TinyMLC/ops.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+# TinyMLC - Tiny Machine Learning Compiler
+#
+# Copyright (c) 2026 Jia Liu & TinyMLC Contributors
+# SPDX-License-Identifier: Apache-2.0
+#
+# This file is part of TinyMLC.
+# 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.
+
+
+SUPPORTED_OPS = [
+    # Activation
+    "RELU",
+    "RELU6",
+    "LEAKY_RELU",
+    "PRELU",
+    "HARD_SIGMOID",
+    "SIGMOID",
+    "TANH",
+    "CLIP",
+
+    # Convolution
+    "CONV_2D",
+    "DEPTHWISE_CONV_2D",
+    "CONV_TRANSPOSE",
+
+    # Pooling
+    "MAX_POOL_2D",
+    "AVG_POOL_2D",
+    "GLOBAL_AVG_POOL",
+
+    # Fully Connected
+    "FULLY_CONNECTED",
+
+    # Activation (continued)
+    "SOFTMAX",
+
+    # Tensor operations
+    "RESHAPE",
+    "TRANSPOSE",
+    "CONCAT",
+    "SPLIT",
+    "PAD",
+    "STRIDED_SLICE",
+    "FLATTEN",
+
+    # Arithmetic
+    "ADD",
+    "MULTIPLY",
+    "SUB",
+    "MEAN",
+    "REDUCE_SUM",
+    "ARGMAX",
+
+    # Upsampling
+    "UPSAMPLE",
+    "RESIZE_NEAREST_NEIGHBOR",
+
+    # RNN
+    "LSTM",
+    "SVDF",
+
+    # Quantization
+    "QUANTIZE",
+    "DEQUANTIZE",
+]

TinyMLC/templates/lut.c.tpl

@@ -0,0 +1,23 @@
+/* TinyMLC - Tiny Machine Learning Compiler
+ *
+ * Copyright (c) 2026 Jia Liu & TinyMLC Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * This file is part of TinyMLC.
+ * 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.
+ */
+
+// Auto-generated LUT implementation
+// Actual content is in lut.h, this file is just a placeholder
+
+#include "lut.h"

TinyMLC/templates/lut.h.tpl

@@ -0,0 +1,67 @@
+/* TinyMLC - Tiny Machine Learning Compiler
+ *
+ * Copyright (c) 2026 Jia Liu & TinyMLC Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * This file is part of TinyMLC.
+ * 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.
+ */
+
+// Auto-generated LUT tables, do not modify manually
+// sigmoid and tanh int16 lookup tables (256 entries)
+
+#ifndef TINYMLC_LUT_H
+#define TINYMLC_LUT_H
+
+#include <stdint.h>
+
+// Sigmoid LUT (input range [-8,8), output range [0,1] quantized to [0,32767])
+static const int16_t sigmoid_lut[256] = {
+{% for val in sigmoid_lut %}
+    {{ val }}{% if not loop.last %},{% endif %}
+{% endfor %}
+};
+
+// Tanh LUT (input [-8,8), output [-1,1] quantized to [-32768,32767])
+static const int16_t tanh_lut[256] = {
+{% for val in tanh_lut %}
+    {{ val }}{% if not loop.last %},{% endif %}
+{% endfor %}
+};
+
+// LUT lookup functions (linear interpolation)
+static inline int16_t sigmoid_lut_lookup(int32_t x) {
+    // x is int32 accumulator, map to [-8,8) range based on quantization
+    // Assume x is already scaled to [0, 256*8) range
+    int32_t idx = (x >> 8) & 0xFF;
+    uint8_t frac = (uint8_t)(x & 0xFF);
+
+    int16_t lower = sigmoid_lut[idx];
+    int16_t upper = sigmoid_lut[idx + 1];
+
+    int32_t result = lower + ((upper - lower) * frac >> 8);
+    return (int16_t)result;
+}
+
+static inline int16_t tanh_lut_lookup(int32_t x) {
+    int32_t idx = (x >> 8) & 0xFF;
+    uint8_t frac = (uint8_t)(x & 0xFF);
+
+    int16_t lower = tanh_lut[idx];
+    int16_t upper = tanh_lut[idx + 1];
+
+    int32_t result = lower + ((upper - lower) * frac >> 8);
+    return (int16_t)result;
+}
+
+#endif // TINYMLC_LUT_H