tinymlc 0.1.0__py3-none-any.whl

utils/generate_tflite_models.py

@@ -0,0 +1,236 @@
+# -*- 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 multiple TFLite models covering all supported ops.
+
+import tensorflow as tf
+
+from pathlib import Path
+
+
+def build_cnn_model():
+    """Conv2D, DepthwiseConv2D, MaxPool2D, AvgPool2D,
+       GlobalAvgPool2D, FC, Softmax, Relu"""
+    inputs = tf.keras.Input(shape=(28, 28, 1), name='input')
+    x = tf.keras.layers.Conv2D(8, 3, padding='same', name='conv2d')(inputs)
+    x = tf.keras.layers.ReLU(name='relu')(x)
+    x = tf.keras.layers.DepthwiseConv2D(
+        3, padding='same', name='depthwise_conv2d')(x)
+    x = tf.keras.layers.ReLU(name='relu2')(x)
+    x = tf.keras.layers.MaxPooling2D(2, name='max_pool2d')(x)
+    x = tf.keras.layers.AveragePooling2D(2, name='avg_pool2d')(x)
+    x = tf.keras.layers.GlobalAveragePooling2D(name='global_avg_pool')(x)
+    x = tf.keras.layers.Dense(10, name='fc')(x)
+    outputs = tf.keras.layers.Softmax(name='softmax')(x)
+    model = tf.keras.Model(inputs=inputs, outputs=outputs, name='model_cnn')
+    return model
+
+
+def build_activations_model():
+    """ReLU, LeakyReLU, ReLU6, PReLU, HardSigmoid, Sigmoid, Tanh, Clip"""
+    inputs = tf.keras.Input(shape=(16,), name='input')
+    x = tf.keras.layers.Dense(16, name='dummy')(inputs)
+    relu = tf.keras.layers.ReLU(name='relu')(x)
+    leaky = tf.keras.layers.LeakyReLU(alpha=0.1, name='leaky_relu')(relu)
+    relu6 = tf.keras.layers.ReLU(max_value=6.0, name='relu6')(leaky)
+    prelu = tf.keras.layers.PReLU(name='prelu')(relu6)
+    hs = tf.keras.layers.Activation('hard_sigmoid', name='hard_sigmoid')(prelu)
+    sig = tf.keras.layers.Activation('sigmoid', name='sigmoid')(hs)
+    tanh = tf.keras.layers.Activation('tanh', name='tanh')(sig)
+    clip = tf.keras.layers.Lambda(
+        lambda z: tf.clip_by_value(z, -2.0, 2.0), name='clip')(tanh)
+    outputs = clip
+    model = tf.keras.Model(
+        inputs=inputs, outputs=outputs, name='model_activations')
+    return model
+
+
+def build_tensor_ops_model():
+    inputs = tf.keras.Input(shape=(8, 8, 4))
+    x = tf.keras.layers.Conv2D(4, 3, padding='same')(inputs)
+
+    # Split
+    splits = tf.keras.layers.Lambda(lambda z: tf.split(z, 2, axis=-1))(x)
+
+    # Pad channels only (H/W unchanged, only modify channel dimension)
+    pad = tf.keras.layers.Lambda(
+        lambda z: tf.pad(z, [[0,0], [0,0], [0,0], [1,1]]),
+        # [batch, H, W, channels]
+        name='pad'
+    )(splits[0])
+
+    # Concat back (shapes now match: H/W are both 8)
+    concat = tf.keras.layers.Concatenate(name='concat')([pad, splits[1]])
+
+    # Flatten
+    flat = tf.keras.layers.Flatten(name='flatten')(concat)
+
+    # Reshape
+    reshape = tf.keras.layers.Reshape((8, -1), name='reshape')(flat)
+
+    # Transpose
+    transpose = tf.keras.layers.Lambda(
+        lambda z: tf.transpose(z, perm=[0, 2, 1]),
+        name='transpose'
+    )(reshape)
+
+    # StridedSlice
+    slice_out = tf.keras.layers.Lambda(
+        lambda z: z[:, 0:4, 0:4],
+        name='strided_slice'
+    )(transpose)
+
+    return tf.keras.Model(
+        inputs=inputs, outputs=slice_out, name='model_tensor_ops')
+
+
+def build_arithmetic_model():
+    """Add, Multiply, Subtract, ReduceSum, ReduceMean, ArgMax"""
+    inputs = tf.keras.Input(shape=(8, 8), name='input')
+    x = tf.keras.layers.Dense(8, name='dummy')(inputs)
+
+    # split into two branches
+    split = tf.keras.layers.Lambda(
+        lambda z: tf.split(z, 2, axis=-1), name='split')(x)
+    a = split[0]
+    b = split[1]
+
+    add = tf.keras.layers.Add(name='add')([a, b])
+    mul = tf.keras.layers.Multiply(name='multiply')([add, a])
+    sub = tf.keras.layers.Subtract(name='sub')([mul, add])
+
+    reduce_sum = tf.keras.layers.Lambda(
+        lambda z: tf.reduce_sum(z, axis=-1, keepdims=True),
+        name='reduce_sum'
+    )(sub)
+
+    reduce_mean = tf.keras.layers.Lambda(
+        lambda z: tf.reduce_mean(z, axis=-1, keepdims=True),
+        name='reduce_mean'
+    )(reduce_sum)
+
+    argmax = tf.keras.layers.Lambda(
+        lambda z: tf.argmax(z, axis=-1, output_type=tf.int32),
+        name='argmax'
+    )(reduce_mean)
+
+    outputs = tf.keras.layers.Lambda(
+        lambda z: tf.cast(z, tf.float32),
+        name='cast_out'
+    )(argmax)
+
+    model = tf.keras.Model(
+        inputs=inputs, outputs=outputs, name='model_arithmetic')
+    return model
+
+
+def build_upsample_model():
+    """Upsample (via ResizeNearestNeighbor), ConvTranspose"""
+    inputs = tf.keras.Input(shape=(8, 8, 2), name='input')
+
+    # Conv2DTranspose
+    x = tf.keras.layers.Conv2DTranspose(
+        4, 3, strides=2, padding='same', name='conv_transpose')(inputs)
+
+    # Upsample (ResizeNearestNeighbor)
+    upsample = tf.keras.layers.Lambda(
+        lambda z: tf.image.resize(z, (16, 16), method='nearest'),
+        name='upsample'
+    )(x)
+
+    outputs = upsample
+    model = tf.keras.Model(
+        inputs=inputs, outputs=outputs, name='model_upsample')
+    return model
+
+
+def build_lstm_model():
+    """LSTM, SVDF (simulated with Dense for SVDF)"""
+    inputs = tf.keras.Input(shape=(10, 4), name='input')
+    lstm = tf.keras.layers.LSTM(8, return_sequences=False, name='lstm')(inputs)
+    # SVDF isn't standard in Keras, use Dense as proxy
+    svdf = tf.keras.layers.Dense(4, name='svdf')(lstm)
+    outputs = svdf
+    model = tf.keras.Model(inputs=inputs, outputs=outputs, name='model_lstm')
+    return model
+
+
+def convert_to_tflite(model, name, output_dir=None):
+    """Convert Keras model to TFLite."""
+    if output_dir is None:
+        output_dir = Path(".")
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    output_path = output_dir / f'{name}.tflite'
+
+    model.build(model.input_shape)
+
+    # Convert with default settings
+    converter = tf.lite.TFLiteConverter.from_keras_model(model)
+    converter.optimizations = [tf.lite.Optimize.DEFAULT]
+    converter.target_spec.supported_types = [tf.int8]
+    converter.inference_input_type = tf.int8
+    converter.inference_output_type = tf.int8
+    try:
+        tflite = converter.convert()
+        with open(output_path, 'wb') as f:
+            f.write(tflite)
+        print(f'  Saved: {output_path}')
+        return
+    except Exception as e:
+        print(f'  Warning: int8 conversion failed: {e}')
+        print(f'  Retrying with float and SELECT_TF_OPS...')
+
+    # Fallback: use float + SELECT_TF_OPS (for LSTM/SVDF)
+    converter = tf.lite.TFLiteConverter.from_keras_model(model)
+    converter.optimizations = [tf.lite.Optimize.DEFAULT]
+    converter.target_spec.supported_ops = [
+        tf.lite.OpsSet.TFLITE_BUILTINS,
+        tf.lite.OpsSet.SELECT_TF_OPS
+    ]
+    converter._experimental_lower_tensor_list_ops = False
+    try:
+        tflite = converter.convert()
+        with open(output_path, 'wb') as f:
+            f.write(tflite)
+        print(f'  Saved: {output_path} (float + SELECT_TF_OPS)')
+    except Exception as e:
+        print(f'  Error: {name} conversion failed: {e}')
+
+
+def main():
+    models = [
+        ('model_cnn', build_cnn_model()),
+        ('model_activations', build_activations_model()),
+        ('model_tensor_ops', build_tensor_ops_model()),
+        ('model_arithmetic', build_arithmetic_model()),
+        ('model_upsample', build_upsample_model()),
+        ('model_lstm', build_lstm_model()),
+    ]
+
+    output_dir = Path("model_tests/tflite")
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    for name, model in models:
+        convert_to_tflite(model, name, output_dir=output_dir)
+
+
+if __name__ == '__main__':
+    main()

utils/pack_macos.sh

@@ -0,0 +1,88 @@
+#!/bin/bash
+# pack_macos.sh - Package TinyMLC for macOS
+
+set -e
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+PROJECT_ROOT="$( cd "$SCRIPT_DIR/.." && pwd )"
+
+APP_NAME="TinyMLC"
+APP_DIR="${PROJECT_ROOT}/build/${APP_NAME}.app"
+CONTENTS_DIR="${APP_DIR}/Contents"
+RESOURCES_DIR="${CONTENTS_DIR}/Resources"
+MACOS_DIR="${CONTENTS_DIR}/MacOS"
+VERSION="0.1.0"
+
+echo "🔨 Building TinyMLC GUI..."
+cd ${PROJECT_ROOT}/TinyGUI
+mkdir -p build
+cd build
+cmake ..
+make
+
+echo "📦 Creating app bundle structure..."
+mkdir -p "${MACOS_DIR}"
+mkdir -p "${RESOURCES_DIR}"
+
+cd "${RESOURCES_DIR}"
+uv venv -p 3.13 venv
+source venv/bin/activate
+
+echo "Current dir: $(pwd)"
+echo "PROJECT_ROOT: ${PROJECT_ROOT}"
+echo "RESOURCES_DIR: ${RESOURCES_DIR}"
+echo "Looking for uv.lock at: ${PROJECT_ROOT}/uv.lock"
+cp ${PROJECT_ROOT}/uv.lock .
+uv sync --frozen
+#uv pip install -e "${PROJECT_ROOT}" --python "${RESOURCES_DIR}/venv/bin/python"
+
+echo "📝 Creating launch.sh..."
+echo "RESOURCES_DIR: ${RESOURCES_DIR}"
+cat > "${RESOURCES_DIR}/launch.sh" << 'EOF'
+#!/bin/bash
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+cd "$DIR"
+export PYTHONPATH="$DIR:$DIR/TinyMLC:$DIR/utils:$DIR/TinyMLC/ANG:$DIR/TinyMLC/converter"
+./venv/bin/python main.py "$@"
+EOF
+chmod +x "${RESOURCES_DIR}/launch.sh"
+
+
+echo "📄 Copying executable..."
+cp ${PROJECT_ROOT}/TinyGUI/build/TinyGUI "${MACOS_DIR}/${APP_NAME}"
+
+echo "📄 Copying Python backend..."
+cp ${PROJECT_ROOT}/main.py "${RESOURCES_DIR}/"
+cp ${PROJECT_ROOT}/cli.py "${RESOURCES_DIR}/"
+cp ${PROJECT_ROOT}/handlers.py "${RESOURCES_DIR}/"
+cp -r ${PROJECT_ROOT}/TinyMLC "${RESOURCES_DIR}/"
+cp -r ${PROJECT_ROOT}/TinyMLC/ANG "${RESOURCES_DIR}/"
+cp -r ${PROJECT_ROOT}/TinyMLC/converter "${RESOURCES_DIR}/"
+cp -r ${PROJECT_ROOT}/utils "${RESOURCES_DIR}/"
+
+echo "📄 Copying Info.plist..."
+cat > "${CONTENTS_DIR}/Info.plist" << EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleExecutable</key>
+    <string>${APP_NAME}</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.tinymlc.${APP_NAME}</string>
+    <key>CFBundleName</key>
+    <string>${APP_NAME}</string>
+    <key>CFBundleVersion</key>
+    <string>${VERSION}</string>
+    <key>CFBundleShortVersionString</key>
+    <string>${VERSION}</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+</dict>
+</plist>
+EOF
+
+echo "🔧 Running macdeployqt..."
+macdeployqt "${APP_DIR}" -dmg
+
+echo "✅ Done! App bundle created at: ${APP_DIR}"

utils/path.py

@@ -0,0 +1,31 @@
+# -*- 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
+"""Path utilities for TinyMLC CLI"""
+
+from pathlib import Path
+from argparse import Namespace
+
+
+def get_output_dir(args: Namespace) -> Path:
+    """Get and create output directory from args"""
+    out_dir = Path(getattr(args, "output_dir", "."))
+    out_dir.mkdir(parents=True, exist_ok=True)
+    return out_dir

utils/riscv-none-elf-gcc.cmake

@@ -0,0 +1,50 @@
+# -*- 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.
+
+# For building NMSIS-NN
+# cmake ../Source \
+#   -DCMAKE_TOOLCHAIN_FILE=../riscv-none-elf-gcc.cmake \
+#   -DRISCV_ARCH=rv32imac \
+#   -DRISCV_ABI=ilp32 \
+#   -DRISCV_MODEL=medany
+# make
+# Then copy Include and libNMSISNN.a
+
+set(CMAKE_SYSTEM_NAME Generic)
+set(CMAKE_SYSTEM_PROCESSOR riscv)
+
+set(CROSS_COMPILE "riscv-none-elf-")
+
+set(CMAKE_C_COMPILER ${CROSS_COMPILE}gcc)
+set(CMAKE_CXX_COMPILER ${CROSS_COMPILE}g++)
+set(CMAKE_ASM_COMPILER ${CROSS_COMPILE}gcc)
+set(CMAKE_AR ${CROSS_COMPILE}ar)
+set(CMAKE_OBJCOPY ${CROSS_COMPILE}objcopy)
+set(CMAKE_OBJDUMP ${CROSS_COMPILE}objdump)
+
+set(RISCV_ARCH "rv32imac")
+set(RISCV_ABI "ilp32")
+
+add_compile_options(
+    -march=${RISCV_ARCH}
+    -mabi=${RISCV_ABI}
+    -mcmodel=medany
+    -O2
+    -Wall
+)