From 34c9163f180578f9a46d17cbca9f98a27c315dd5 Mon Sep 17 00:00:00 2001 From: Dawid Borycki Date: Thu, 25 Sep 2025 14:12:16 +0200 Subject: [PATCH 01/12] Fundamentals --- .../cross-platform/onnx/01_Fundamentals.md | 103 ++++++++++++++++++ .../cross-platform/onnx/02_Setup.md | 24 ++++ .../onnx/03_BuildingAndExportingModel.md | 24 ++++ .../cross-platform/onnx/04_Inference.md | 24 ++++ .../onnx/05_TrainingWorkflows.md | 24 ++++ .../cross-platform/onnx/06_Profiling.md | 24 ++++ .../cross-platform/onnx/07_Optimisation.md | 24 ++++ .../cross-platform/onnx/08_Android.md | 24 ++++ .../cross-platform/onnx/_index.md | 67 ++++++++++++ .../cross-platform/onnx/_next-steps.md | 8 ++ 10 files changed, 346 insertions(+) create mode 100644 content/learning-paths/cross-platform/onnx/01_Fundamentals.md create mode 100644 content/learning-paths/cross-platform/onnx/02_Setup.md create mode 100644 content/learning-paths/cross-platform/onnx/03_BuildingAndExportingModel.md create mode 100644 content/learning-paths/cross-platform/onnx/04_Inference.md create mode 100644 content/learning-paths/cross-platform/onnx/05_TrainingWorkflows.md create mode 100644 content/learning-paths/cross-platform/onnx/06_Profiling.md create mode 100644 content/learning-paths/cross-platform/onnx/07_Optimisation.md create mode 100644 content/learning-paths/cross-platform/onnx/08_Android.md create mode 100644 content/learning-paths/cross-platform/onnx/_index.md create mode 100644 content/learning-paths/cross-platform/onnx/_next-steps.md diff --git a/content/learning-paths/cross-platform/onnx/01_Fundamentals.md b/content/learning-paths/cross-platform/onnx/01_Fundamentals.md new file mode 100644 index 0000000000..eb21100131 --- /dev/null +++ b/content/learning-paths/cross-platform/onnx/01_Fundamentals.md @@ -0,0 +1,103 @@ +--- +# User change +title: "ONNX Fundamentals" + +weight: 2 + +layout: "learningpathall" +--- +The goal of this tutorial is to provide developers with a practical, end-to-end pathway for working with Open Neural Network Exchange (ONNX) in real-world scenarios. Starting from the fundamentals, we will build a simple neural network model in Python, export it to the ONNX format, and demonstrate how it can be used for both inference and training on Arm64 platforms. Along the way, we will cover model optimization techniques such as layer fusion, and conclude by deploying the optimized model into a fully functional Android application. By following this series, you will gain not only a solid understanding of ONNX’s philosophy and ecosystem but also the hands-on skills required to integrate ONNX into your own projects—from prototyping to deployment. + +In this first step, we will introduce the ONNX standard and explain why it has become a cornerstone of modern machine learning workflows. You will learn what ONNX is, how it represents models in a framework-agnostic format, and why this matters for developers targeting different platforms such as desktops, Arm64 devices, or mobile environments. We will also discuss the role of ONNX Runtime as the high-performance engine that brings these models to life, enabling efficient inference and even training across CPUs, GPUs, and specialized accelerators. Finally, we will outline the typical ONNX workflow—from training in frameworks like PyTorch or TensorFlow, through export and optimization, to deployment on edge and Android devices—which we will gradually demonstrate throughout the tutorial. + +## What is ONNX +The ONNX is an open standard for representing machine learning models in a framework-independent format. Instead of being tied to the internal model representation of a specific framework—such as PyTorch, TensorFlow, or scikit-learn—ONNX provides a universal way to describe models using a common set of operators, data types, and computational graphs. + +At its core, an ONNX model is a directed acyclic graph (DAG) where nodes represent mathematical operations (e.g., convolution, matrix multiplication, activation functions) and edges represent tensors flowing between these operations. This standardized representation allows models trained in one framework to be exported once and executed anywhere, without requiring the original framework at runtime. + +ONNX was originally developed by Microsoft and Facebook to address a growing need in the machine learning community: the ability to move models seamlessly between training environments and deployment targets. Today, it is supported by a wide ecosystem of contributors and hardware vendors, making it the de facto choice for interoperability and cross-platform deployment. + +For developers, this means flexibility: you can train your model in PyTorch, export it to ONNX, run it with ONNX Runtime on an Arm64 device such as a Raspberry Pi, and later deploy it inside an Android application without rewriting the model. This portability is the main reason ONNX has become a central building block in modern AI workflows. + +A useful way to think of ONNX is to compare it to a PDF for machine learning models. Just as a PDF file ensures that a document looks the same regardless of whether you open it in Adobe Reader, Preview on macOS, or a web browser, ONNX ensures that a machine learning model behaves consistently whether you run it on a server GPU, a Raspberry Pi, or an Android phone. It is this “write once, run anywhere” principle that makes ONNX especially powerful for developers working across diverse hardware platforms. + +At the same time, ONNX is not a closed box. Developers can extend the format with custom operators or layers when standard ones are not sufficient. This flexibility makes it possible to inject novel research ideas, proprietary operations, or hardware-accelerated kernels into an ONNX model while still benefiting from the portability of the core standard. In other words, ONNX gives you both consistency across platforms and extensibility for innovation. + +## Why ONNX Matters +Machine learning today is not limited to one framework or one device. A model might be trained in PyTorch on a GPU workstation, tested in TensorFlow on a cloud server, and then finally deployed on an Arm64-based edge device or Android phone. Without a common standard, moving models between these environments would be complex, error-prone, and often impossible. ONNX solves this problem by acting as a universal exchange format, ensuring that models can flow smoothly across the entire development and deployment pipeline. + +The main reasons ONNX matters are: +1. Interoperability – ONNX eliminates framework lock-in. You can train in PyTorch, validate in TensorFlow, and deploy with ONNX Runtime on almost any device, from servers to IoT boards. +2. Performance – ONNX Runtime includes highly optimized execution backends, supporting hardware acceleration through Arm NEON, CUDA, DirectML, and Android NNAPI. This means the same model can run efficiently across a wide spectrum of hardware. +3. Portability – Once exported to ONNX, the model can be deployed to Arm64 devices (like Raspberry Pi or AWS Graviton servers) or even embedded in an Android app, without rewriting the code. +4. Ecosystem – The ONNX Model Zoo provides ready-to-use, pre-trained models for vision, NLP, and speech tasks, making it easy to start from state-of-the-art baselines. +5. Extensibility – Developers can inject their own layers or custom operators when the built-in operator set is not sufficient, enabling innovation while preserving compatibility. + +In short, ONNX matters because it turns the fragmented ML ecosystem into a cohesive workflow, empowering developers to focus on building applications rather than wrestling with conversion scripts or hardware-specific code. + +## ONNX Model Structure +An ONNX model is more than just a collection of weights—it is a complete description of the computation graph that defines how data flows through the network. Understanding this structure is key to seeing why ONNX is both portable and extensible. + +At a high level, an ONNX model consists of three main parts: +1. Graph, which is the heart of the model, represented as a directed acyclic graph (DAG). In this graph nodes correspond to operations (e.g., Conv, Relu, MatMul), edges represent tensors flowing between nodes, carrying input and output data. +2. Opset (Operator Set), which is a versioned collection of supported operations. Opsets guarantee that models exported with one framework will behave consistently when loaded by another, as long as the same opset version is supported. +3. Metadata, which contains information about inputs, outputs, tensor shapes, and data types. Metadata can also include custom annotations such as the model author, domain, or framework version. + +This design allows ONNX to describe anything from a simple logistic regression to a deep convolutional neural network. For example, a single ONNX graph might define: +* An input tensor representing a camera image. +* A sequence of convolution and pooling layers. +* Fully connected layers leading to classification probabilities. +* An output tensor with predicted labels. + +Because the ONNX format is based on a standardized graph representation, it is both human-readable (with tools like Netron for visualization) and machine-executable (parsed directly by ONNX Runtime or other backends). + +Importantly, ONNX models are not static. Developers can insert, remove, or replace nodes in the graph, making it possible to add new layers, prune unnecessary ones, or fuse operations for optimization. This graph-level flexibility is what enables many of the performance improvements we’ll explore later in this tutorial, such as layer fusion and quantization. + +## ONNX Runtime +While ONNX provides a standard way to represent models, it still needs a high-performance engine to actually execute them. This is where ONNX Runtime (ORT) comes in. ONNX Runtime is the official, open-source inference engine for ONNX models, designed to run them quickly and efficiently across a wide variety of hardware. + +At its core, ONNX Runtime is optimized for speed, portability, and extensibility: +1. Cross-platform support. ORT runs on Windows, Linux, macOS, and mobile operating systems like Android and iOS. It has first-class support for both x86 and Arm64 architectures, making it ideal for deployment on devices ranging from cloud servers to Raspberry Pi boards and smartphones. + +2. Hardware acceleration. ORT integrates with a wide range of execution providers (EPs) that tap into hardware capabilities: +* Arm NEON / Arm Compute Library for efficient CPU execution on Arm64. +* CUDA for NVIDIA GPUs. +* DirectML for Windows. +* NNAPI on Android, enabling direct access to mobile accelerators (DSPs, NPUs). + +3. Inference and training. ONNX Runtime also supports training and fine-tuning, making it possible to use the same runtime across the entire ML lifecycle. + +4. Optimization built in. ORT can automatically apply graph optimizations such as constant folding, operator fusion, or memory layout changes to squeeze more performance out of your model. + +For developers, this means you can take a model trained in PyTorch, export it to ONNX, and then run it with ONNX Runtime on virtually any device—without worrying about the underlying hardware differences. The runtime abstracts away the complexity, choosing the best available execution provider for your environment. + +This flexibility makes ONNX Runtime a powerful bridge between training frameworks and deployment targets, and it is the key technology that allows ONNX models to run effectively on Arm64 platforms and Android devices. + +## How ONNX Fits into the Workflow + +One of the biggest advantages of ONNX is how naturally it integrates into a developer’s machine learning workflow. Instead of locking you into a single framework from training to deployment, ONNX provides a bridge that connects different stages of the ML lifecycle. + +A typical ONNX workflow looks like this: +1. Train the model. You first use your preferred framework (e.g., PyTorch, TensorFlow, or scikit-learn) to design and train a model. At this stage, you benefit from the flexibility and ecosystem of the framework of your choice. +2. Export to ONNX. Once trained, the model is exported into the ONNX format using built-in converters (such as torch.onnx.export for PyTorch). This produces a portable .onnx file describing the network architecture, weights, and metadata. +3. Run inference with ONNX Runtime. The ONNX model can now be executed on different devices using ONNX Runtime. On Arm64 hardware, ONNX Runtime takes advantage of the Arm Compute Library and NEON instructions, while on Android devices it can leverage NNAPI for mobile accelerators. +4. Optimize the model. Apply graph optimizations like layer fusion, constant folding, or quantization to improve performance and reduce memory usage, making the model more suitable for edge and mobile deployments. +5. Deploy. Finally, the optimized ONNX model is packaged into its target environment. This could be an Arm64-based embedded system (e.g., Raspberry Pi), a server powered by Arm CPUs (e.g., AWS Graviton), or an Android application distributed via the Play Store. + +This modularity means developers are free to mix and match the best tools for each stage: train in PyTorch, optimize with ONNX Runtime, and deploy to Android—all without rewriting the model. By decoupling training from inference, ONNX enables efficient workflows that span from research experiments to production-grade applications. + +## Example Use Cases +ONNX is already widely adopted in real-world applications where portability and performance are critical. A few common examples include: +1. Computer Vision at the Edge – Running an object detection model (e.g., YOLOv5 exported to ONNX) on a Raspberry Pi 4 or NVIDIA Jetson, enabling low-cost cameras to detect people, vehicles, or defects in real time. +2. Mobile Applications – Deploying face recognition or image classification models inside an Android app using ONNX Runtime Mobile, with NNAPI acceleration for efficient on-device inference. +3. Natural Language Processing (NLP) – Running BERT-based models on Arm64 cloud servers (like AWS Graviton) to provide fast, low-cost inference for chatbots and translation services. +4. Healthcare Devices – Using ONNX to integrate ML models into portable diagnostic tools or wearable sensors, where Arm64 processors dominate due to their low power consumption. +5. Cross-platform Research to Production – Training experimental architectures in PyTorch, exporting them to ONNX, and validating them across different backends to ensure consistent performance. +6. AI Accelerator Integration – ONNX is especially useful for hardware vendors building custom AI accelerators. Since accelerators often cannot support the full range of ML operators, ONNX’s extensible operator model allows manufacturers to plug in custom kernels where hardware acceleration is available, while gracefully falling back to the standard runtime for unsupported ops. This makes it easier to adopt new hardware without rewriting entire models. + +## Summary +In this section, we introduced ONNX as an open standard for representing machine learning models across frameworks and platforms. We explored its model structure—graphs, opsets, and metadata—and explained the role of ONNX Runtime as the high-performance execution engine. We also showed how ONNX fits naturally into the ML workflow: from training in PyTorch or TensorFlow, to exporting and optimizing the model, and finally deploying it on Arm64 or Android devices. + +A useful way to think of ONNX is as the PDF of machine learning models—a universal, consistent format that looks the same no matter where you open it, but with the added flexibility to inject your own layers and optimizations. + +Beyond portability for developers, ONNX is also valuable for hardware and AI-accelerator builders. Because accelerators often cannot support every possible ML operator, ONNX’s extensible operator model allows manufacturers to seamlessly integrate custom kernels where acceleration is available, while relying on the runtime for unsupported operations. This combination of consistency, flexibility, and extensibility makes ONNX a cornerstone technology for both AI application developers and hardware vendors. \ No newline at end of file diff --git a/content/learning-paths/cross-platform/onnx/02_Setup.md b/content/learning-paths/cross-platform/onnx/02_Setup.md new file mode 100644 index 0000000000..de7e75b8ae --- /dev/null +++ b/content/learning-paths/cross-platform/onnx/02_Setup.md @@ -0,0 +1,24 @@ +--- +# User change +title: "Summary" + +weight: 6 + +layout: "learningpathall" +--- +## Summary ## + +In this Learning Path, you have created an Android application to capture and process camera images using OpenCV. + +You performed the following steps: + +* Integrated the OpenCV library into your Android project. + +* Enabled camera permissions to ensure the application can access the device's camera. + +* Set up `JavaCameraView` to capture real-time frames from the camera. You declared and initialized Mat objects to store and process camera frames. + +* Implemented adaptive thresholding using OpenCV's `Imgproc.adaptiveThreshold` to process the camera frames when a checkbox is checked. + +By following these steps, you have successfully created an Android application that captures real-time images from the camera. + diff --git a/content/learning-paths/cross-platform/onnx/03_BuildingAndExportingModel.md b/content/learning-paths/cross-platform/onnx/03_BuildingAndExportingModel.md new file mode 100644 index 0000000000..de7e75b8ae --- /dev/null +++ b/content/learning-paths/cross-platform/onnx/03_BuildingAndExportingModel.md @@ -0,0 +1,24 @@ +--- +# User change +title: "Summary" + +weight: 6 + +layout: "learningpathall" +--- +## Summary ## + +In this Learning Path, you have created an Android application to capture and process camera images using OpenCV. + +You performed the following steps: + +* Integrated the OpenCV library into your Android project. + +* Enabled camera permissions to ensure the application can access the device's camera. + +* Set up `JavaCameraView` to capture real-time frames from the camera. You declared and initialized Mat objects to store and process camera frames. + +* Implemented adaptive thresholding using OpenCV's `Imgproc.adaptiveThreshold` to process the camera frames when a checkbox is checked. + +By following these steps, you have successfully created an Android application that captures real-time images from the camera. + diff --git a/content/learning-paths/cross-platform/onnx/04_Inference.md b/content/learning-paths/cross-platform/onnx/04_Inference.md new file mode 100644 index 0000000000..de7e75b8ae --- /dev/null +++ b/content/learning-paths/cross-platform/onnx/04_Inference.md @@ -0,0 +1,24 @@ +--- +# User change +title: "Summary" + +weight: 6 + +layout: "learningpathall" +--- +## Summary ## + +In this Learning Path, you have created an Android application to capture and process camera images using OpenCV. + +You performed the following steps: + +* Integrated the OpenCV library into your Android project. + +* Enabled camera permissions to ensure the application can access the device's camera. + +* Set up `JavaCameraView` to capture real-time frames from the camera. You declared and initialized Mat objects to store and process camera frames. + +* Implemented adaptive thresholding using OpenCV's `Imgproc.adaptiveThreshold` to process the camera frames when a checkbox is checked. + +By following these steps, you have successfully created an Android application that captures real-time images from the camera. + diff --git a/content/learning-paths/cross-platform/onnx/05_TrainingWorkflows.md b/content/learning-paths/cross-platform/onnx/05_TrainingWorkflows.md new file mode 100644 index 0000000000..de7e75b8ae --- /dev/null +++ b/content/learning-paths/cross-platform/onnx/05_TrainingWorkflows.md @@ -0,0 +1,24 @@ +--- +# User change +title: "Summary" + +weight: 6 + +layout: "learningpathall" +--- +## Summary ## + +In this Learning Path, you have created an Android application to capture and process camera images using OpenCV. + +You performed the following steps: + +* Integrated the OpenCV library into your Android project. + +* Enabled camera permissions to ensure the application can access the device's camera. + +* Set up `JavaCameraView` to capture real-time frames from the camera. You declared and initialized Mat objects to store and process camera frames. + +* Implemented adaptive thresholding using OpenCV's `Imgproc.adaptiveThreshold` to process the camera frames when a checkbox is checked. + +By following these steps, you have successfully created an Android application that captures real-time images from the camera. + diff --git a/content/learning-paths/cross-platform/onnx/06_Profiling.md b/content/learning-paths/cross-platform/onnx/06_Profiling.md new file mode 100644 index 0000000000..de7e75b8ae --- /dev/null +++ b/content/learning-paths/cross-platform/onnx/06_Profiling.md @@ -0,0 +1,24 @@ +--- +# User change +title: "Summary" + +weight: 6 + +layout: "learningpathall" +--- +## Summary ## + +In this Learning Path, you have created an Android application to capture and process camera images using OpenCV. + +You performed the following steps: + +* Integrated the OpenCV library into your Android project. + +* Enabled camera permissions to ensure the application can access the device's camera. + +* Set up `JavaCameraView` to capture real-time frames from the camera. You declared and initialized Mat objects to store and process camera frames. + +* Implemented adaptive thresholding using OpenCV's `Imgproc.adaptiveThreshold` to process the camera frames when a checkbox is checked. + +By following these steps, you have successfully created an Android application that captures real-time images from the camera. + diff --git a/content/learning-paths/cross-platform/onnx/07_Optimisation.md b/content/learning-paths/cross-platform/onnx/07_Optimisation.md new file mode 100644 index 0000000000..de7e75b8ae --- /dev/null +++ b/content/learning-paths/cross-platform/onnx/07_Optimisation.md @@ -0,0 +1,24 @@ +--- +# User change +title: "Summary" + +weight: 6 + +layout: "learningpathall" +--- +## Summary ## + +In this Learning Path, you have created an Android application to capture and process camera images using OpenCV. + +You performed the following steps: + +* Integrated the OpenCV library into your Android project. + +* Enabled camera permissions to ensure the application can access the device's camera. + +* Set up `JavaCameraView` to capture real-time frames from the camera. You declared and initialized Mat objects to store and process camera frames. + +* Implemented adaptive thresholding using OpenCV's `Imgproc.adaptiveThreshold` to process the camera frames when a checkbox is checked. + +By following these steps, you have successfully created an Android application that captures real-time images from the camera. + diff --git a/content/learning-paths/cross-platform/onnx/08_Android.md b/content/learning-paths/cross-platform/onnx/08_Android.md new file mode 100644 index 0000000000..de7e75b8ae --- /dev/null +++ b/content/learning-paths/cross-platform/onnx/08_Android.md @@ -0,0 +1,24 @@ +--- +# User change +title: "Summary" + +weight: 6 + +layout: "learningpathall" +--- +## Summary ## + +In this Learning Path, you have created an Android application to capture and process camera images using OpenCV. + +You performed the following steps: + +* Integrated the OpenCV library into your Android project. + +* Enabled camera permissions to ensure the application can access the device's camera. + +* Set up `JavaCameraView` to capture real-time frames from the camera. You declared and initialized Mat objects to store and process camera frames. + +* Implemented adaptive thresholding using OpenCV's `Imgproc.adaptiveThreshold` to process the camera frames when a checkbox is checked. + +By following these steps, you have successfully created an Android application that captures real-time images from the camera. + diff --git a/content/learning-paths/cross-platform/onnx/_index.md b/content/learning-paths/cross-platform/onnx/_index.md new file mode 100644 index 0000000000..7d29c9852c --- /dev/null +++ b/content/learning-paths/cross-platform/onnx/_index.md @@ -0,0 +1,67 @@ +--- +title: ONNX in Action. Building, Optimizing, and Deploying Models on Arm64 and Mobile + +minutes_to_complete: 120 + +who_is_this_for: This is an introductory topic for developers who are interested in creating, optimizing, and deploying machine learning models with ONNX. It is especially useful for those targeting Arm64-based devices (such as Raspberry Pi, mobile SoCs, or Android smartphones) and looking to run efficient inference at the edge. + +learning_objectives: + - Describe what ONNX is, and what it can offer in the ML ecosystem. + - Build and export a simple neural network model in Python to ONNX format. + - Perform inference and training using ONNX Runtime on Arm64. + - Apply optimization techniques such as layer fusion to improve performance. + - Deploy an optimized ONNX model inside an Android app. + +prerequisites: + - A development machine with Python 3.10+ installed. + - Basic familiarity with PyTorch or TensorFlow. + - An Arm64 device (e.g., Raspberry Pi or Android smartphone). + - [Android Studio](https://developer.android.com/studio) installed for deployment testing. + +author: Dawid Borycki + +### Tags +skilllevels: Introductory +subjects: Machine Learning, Edge AI +armips: + - Cortex-A + - Neoverse +operatingsystems: + - Windows + - Linux + - macOS +tools_software_languages: + - Python + - PyTorch + - TensorFlow + - ONNX + - ONNX Runtime + - Android + - Android Studio + - Kotlin + - Java + +further_reading: + - resource: + title: ONNX + link: https://onnx.ai + type: documentation + - resource: + title: ONNX Runtime + link: https://onnxruntime.ai + type: documentation + - resource: + title: Getting Started with ONNX Runtime on Mobile + link: https://onnxruntime.ai/docs/tutorials/mobile + type: tutorial + - resource: + title: Optimizing Models with ONNX Runtime + link: https://onnxruntime.ai/docs/performance/model-optimizations.html + type: documentation + +### FIXED, DO NOT MODIFY +# ================================================================================ +weight: 1 # _index.md always has weight of 1 to order correctly +layout: "learningpathall" # All files under learning paths have this same wrapper +learning_path_main_page: "yes" # This should be surfaced when looking for related content. Only set for _index.md of learning path content. +--- diff --git a/content/learning-paths/cross-platform/onnx/_next-steps.md b/content/learning-paths/cross-platform/onnx/_next-steps.md new file mode 100644 index 0000000000..c3db0de5a2 --- /dev/null +++ b/content/learning-paths/cross-platform/onnx/_next-steps.md @@ -0,0 +1,8 @@ +--- +# ================================================================================ +# FIXED, DO NOT MODIFY THIS FILE +# ================================================================================ +weight: 21 # Set to always be larger than the content in this path to be at the end of the navigation. +title: "Next Steps" # Always the same, html page title. +layout: "learningpathall" # All files under learning paths have this same wrapper for Hugo processing. +--- From e59c08d8f602cebba9653234c90f99ed2a86bb19 Mon Sep 17 00:00:00 2001 From: Dawid Borycki Date: Fri, 26 Sep 2025 12:25:32 +0200 Subject: [PATCH 02/12] Update 02_Setup.md --- .../cross-platform/onnx/02_Setup.md | 126 ++++++++++++++++-- 1 file changed, 116 insertions(+), 10 deletions(-) diff --git a/content/learning-paths/cross-platform/onnx/02_Setup.md b/content/learning-paths/cross-platform/onnx/02_Setup.md index de7e75b8ae..7838803efe 100644 --- a/content/learning-paths/cross-platform/onnx/02_Setup.md +++ b/content/learning-paths/cross-platform/onnx/02_Setup.md @@ -1,24 +1,130 @@ --- # User change -title: "Summary" +title: "Environment Setup" -weight: 6 +weight: 3 layout: "learningpathall" --- -## Summary ## -In this Learning Path, you have created an Android application to capture and process camera images using OpenCV. +## Objective +This step gets you ready to build, export, run, and optimize ONNX models on Arm64. You’ll set up Python, install ONNX & ONNX Runtime, confirm hardware-backed execution providers, and—optionally—prepare multi-arch Docker builds or source builds for advanced acceleration. -You performed the following steps: +## Choosing the hardware +You can choose a variety of hardware, including: +* Edge boards (Linux/Arm64) - Raspberry Pi 4/5 (64-bit OS), Jetson (Arm64 CPU; GPU via CUDA if using NVIDIA stack), Arm servers (e.g., AWS Graviton). +* Apple Silicon (macOS/Arm64) - Great for development, deploy to Arm64 Linux later. +* Windows on Arm - Dev/test on WoA, deploy to Linux Arm64 for production if desired. -* Integrated the OpenCV library into your Android project. +The nice thing about ONNX is that the **same model file** can run across all of these, so your setup is flexible. -* Enabled camera permissions to ensure the application can access the device's camera. +## Install Python +Depending on the hardware you use you follow different installation paths -* Set up `JavaCameraView` to capture real-time frames from the camera. You declared and initialized Mat objects to store and process camera frames. +1. Linux (Arm64). In the console type: +```console +sudo apt update +sudo apt install -y python3 python3-venv python3-pip build-essential libopenblas-dev +``` -* Implemented adaptive thresholding using OpenCV's `Imgproc.adaptiveThreshold` to process the camera frames when a checkbox is checked. +2. macOS (Apple Sillicon): +```console +brew install python +``` -By following these steps, you have successfully created an Android application that captures real-time images from the camera. +3. Windows on Arm: +* Install Python 3.10+ from python.org (Arm64 build). +* Ensure pip is on PATH. +After installing Python, open a terminal or console, create a clean virtual environment, and update pip and wheel: + +```console +python3 -m venv .venv +source .venv/bin/activate # on Windows use: .venv\Scripts\activate +python -m pip install --upgrade pip wheel +``` + +Using a virtual environment keeps dependencies isolated and avoids conflicts with system-wide Python packages. + +## Install Core Packages +Start by installing the minimal stack: +```console +pip install onnx onnxruntime onnxscript netron numpy +``` +The above will install the following: +* onnx – core library for loading/saving ONNX models. +* onnxruntime – high-performance runtime to execute models. +* onnxscript – required for the new Dynamo-based exporter. +* netron – tool for visualizing ONNX models. +* numpy – used for tensor manipulation. + +Now, install PyTorch (we’ll use it later to build and export a sample model): + +```console +pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu +``` + +## Verify the installation +Let’s verify everything works end-to-end by training a toy network and exporting it to ONNX. + +Create a new file 01_Init.py and add the following code + +```python +import torch, torch.nn as nn +import onnx, onnxruntime as ort +import numpy as np + +class SmallNet(nn.Module): + def __init__(self): + super().__init__() + self.seq = nn.Sequential( + nn.Conv2d(1, 8, 3, padding=1), + nn.ReLU(), + nn.AdaptiveAvgPool2d((1,1)), + nn.Flatten(), + nn.Linear(8, 10) + ) + def forward(self, x): return self.seq(x) + +m = SmallNet().eval() +dummy = torch.randn(1, 1, 28, 28) + +torch.onnx.export( + m, dummy, "smallnet.onnx", + input_names=["input"], output_names=["logits"], + opset_version=19, + do_constant_folding=True, + keep_initializers_as_inputs=False, + dynamo=True +) + +# Quick sanity run +sess = ort.InferenceSession("smallnet.onnx", providers=["CPUExecutionProvider"]) +out = sess.run(["logits"], {"input": dummy.numpy()})[0] +print("Output shape:", out.shape, "Providers:", sess.get_providers()) +``` + +Then, run it as follows + +```console +python3 01_Init.py +``` + +You should see the following output: +```output +python3 01_Init.py +[torch.onnx] Obtain model graph for `SmallNet([...]` with `torch.export.export(..., strict=False)`... +[torch.onnx] Obtain model graph for `SmallNet([...]` with `torch.export.export(..., strict=False)`... ✅ +[torch.onnx] Run decomposition... +[torch.onnx] Run decomposition... ✅ +[torch.onnx] Translate the graph into ONNX... +[torch.onnx] Translate the graph into ONNX... ✅ +Output shape: (1, 10) Providers: ['CPUExecutionProvider'] +``` + +The 01_Init.py script serves as a quick end-to-end validation of your ONNX environment. It defines a very small convolutional neural network (SmallNet) in PyTorch, which consists of a convolution layer, activation function, pooling, flattening, and a final linear layer that outputs 10 logits. Instead of training the model, we simply run it in evaluation mode on a random input tensor to make sure the graph structure works. This model is then exported to the ONNX format using PyTorch’s new Dynamo-based exporter, producing a portable smallnet.onnx file. + +After export, the script immediately loads the ONNX model with ONNX Runtime and executes a forward pass using the CPU execution provider. This verifies that the installation of ONNX, ONNX Runtime, and PyTorch is correct and that models can flow seamlessly from definition to inference. By printing the output tensor’s shape and the active execution provider, the script demonstrates that the toolchain is fully functional on your Arm64 device, giving you a solid baseline before moving on to more advanced models and optimizations. + +## Summary +You now have a fully functional ONNX development environment on Arm64. Python and all required packages are installed, and you successfully exported a small PyTorch model to ONNX using the new Dynamo exporter, ensuring forward compatibility. Running the model with ONNX Runtime confirmed that inference works end-to-end with the CPU execution provider, proving that your toolchain is correctly configured. With this foundation in place, the next step is to build and export a more complete model and run it on Arm64 hardware to establish baseline performance before applying optimizations. \ No newline at end of file From 7e0006dc3f36185a9dfd07bfbdc81b3273a2e18e Mon Sep 17 00:00:00 2001 From: Dawid Borycki Date: Mon, 29 Sep 2025 15:29:21 +0200 Subject: [PATCH 03/12] Data --- .../onnx/03_BuildingAndExportingModel.md | 24 -- .../cross-platform/onnx/03_PreparingData.md | 262 ++++++++++++++++++ 2 files changed, 262 insertions(+), 24 deletions(-) delete mode 100644 content/learning-paths/cross-platform/onnx/03_BuildingAndExportingModel.md create mode 100644 content/learning-paths/cross-platform/onnx/03_PreparingData.md diff --git a/content/learning-paths/cross-platform/onnx/03_BuildingAndExportingModel.md b/content/learning-paths/cross-platform/onnx/03_BuildingAndExportingModel.md deleted file mode 100644 index de7e75b8ae..0000000000 --- a/content/learning-paths/cross-platform/onnx/03_BuildingAndExportingModel.md +++ /dev/null @@ -1,24 +0,0 @@ ---- -# User change -title: "Summary" - -weight: 6 - -layout: "learningpathall" ---- -## Summary ## - -In this Learning Path, you have created an Android application to capture and process camera images using OpenCV. - -You performed the following steps: - -* Integrated the OpenCV library into your Android project. - -* Enabled camera permissions to ensure the application can access the device's camera. - -* Set up `JavaCameraView` to capture real-time frames from the camera. You declared and initialized Mat objects to store and process camera frames. - -* Implemented adaptive thresholding using OpenCV's `Imgproc.adaptiveThreshold` to process the camera frames when a checkbox is checked. - -By following these steps, you have successfully created an Android application that captures real-time images from the camera. - diff --git a/content/learning-paths/cross-platform/onnx/03_PreparingData.md b/content/learning-paths/cross-platform/onnx/03_PreparingData.md new file mode 100644 index 0000000000..b1c2373cc5 --- /dev/null +++ b/content/learning-paths/cross-platform/onnx/03_PreparingData.md @@ -0,0 +1,262 @@ +--- +# User change +title: "Preparing a Synthetic Sudoku Digit Dataset" + +weight: 4 + +layout: "learningpathall" +--- + +## Big picture +Our end goal is a camera-to-solution Sudoku app that runs efficiently on Arm64 devices (e.g., Raspberry Pi or Android phones). ONNX is the glue: we’ll train the digit recognizer in PyTorch, export it to ONNX, and run it anywhere with ONNX Runtime (CPU EP on edge devices, NNAPI EP on Android). Everything around the model—grid detection, perspective rectification, and solving—stays deterministic and lightweight. + +## Objective +In this step, we will generate a custom dataset of Sudoku puzzles and their digit crops, which we’ll use to train a digit recognition model. Starting from a Hugging Face parquet dataset that provides paired puzzle/solution strings, we transform raw boards into realistic, book-style Sudoku pages, apply camera-like augmentations to mimic mobile captures, and automatically slice each page into 81 labeled cell images. This yields a large, diverse, perfectly labeled set of digits (0–9 with 0 = blank) without manual annotation. By the end, you’ll have a structured dataset ready to train a lightweight model in the next section. + +## Why Synthetic Generation? +When building a Sudoku digit recognizer, the hardest part is obtaining a well-labeled dataset that matches real capture conditions. MNIST contains handwritten digits, which differ from printed, grid-aligned Sudoku digits; relying on it alone hurts real-world performance. + +By generating synthetic Sudoku pages directly from the parquet dataset, we get: +1. Perfect labeling. Since the puzzle content is known, every cropped cell automatically comes with the correct label (digit or blank), eliminating manual annotation. +2. Control over style. We can render Sudoku pages to look like those in printed books, with realistic fonts, grid lines, and difficulty levels controlled by how many cells are left blank. +3. Robustness through augmentation: By applying perspective warps, blur, noise, and lighting variations, we simulate how a smartphone camera might capture a Sudoku page, improving the model’s ability to handle real-world photos. +4. Scalability. With millions of Sudoku solutions available, we can easily generate tens of thousands of training samples in minutes, ensuring a dataset that is both large and diverse. + +This synthetic data generation strategy allows us to create a custom-fit dataset for our Sudoku digit recognition problem, bridging the gap between clean digital puzzles and noisy real-world inputs. +In this Learning Path, you have created an Android application to capture and process camera images using OpenCV. + +## What we’ll produce +By the end of this step, you will have two complementary datasets: +1. Digit crops for training the classifier. A folder tree structured for torchvision.datasets.ImageFolder, containing tens of thousands of labeled 28×28 images of Sudoku digits (0–9, with 0 meaning blank): + +```console +data/ + train/ + 0/....png (blank) + 1/....png + ... + 9/....png + val/ + 0/....png + ... + 9/....png +``` + +These will be used in next step to train a lightweight model for digit recognition. + +2. Rendered Sudoku grids for camera simulation. Full-page Sudoku images (both clean book-style and augmented camera-like versions) stored in: +```console +data/ + grids/ + train/ + 000001_clean.png + 000001_cam.png + ... + val/ + ... +``` + +These grid images allow us to later test the end-to-end pipeline: detect the board with OpenCV, rectify perspective, classify each cell using the ONNX digit recognizer, and then solve the Sudoku puzzle. + +Together, these datasets provide both the micro-level data needed to train the digit recognizer and the macro-level data to simulate the camera pipeline for testing and deployment. + +## Implementation +Start by creating a new file 02_PrepareData.py and modify it as follows: +```python +import os, random, pathlib +import numpy as np +import cv2 as cv +import pandas as pd +from tqdm import tqdm + +random.seed(0) + +# Parameters +PARQUET_PATH = "train_1.parquet" # path to your downloaded HF Parquet +OUT_DIR = pathlib.Path("data") +N_TRAIN = 1000 # how many puzzles to render for training +N_VAL = 100 # how many for validation +IMG_H, IMG_W = 1200, 800 # page size (portrait-ish) +GRID_MARGIN = 60 # outer margin, px +CELL_SIZE = 28 # output crop size for classifier (MNIST-like) +FONT = cv.FONT_HERSHEY_SIMPLEX +# + +def str_to_grid(s: str): + """81-char '012345678' string -> 9x9 list of ints.""" + s = s.strip() + assert len(s) == 81, f"bad length: {len(s)}" + return [[int(s[9*r+c]) for c in range(9)] for r in range(9)] + +def load_puzzles(parquet_path, n_train, n_val): + """Load puzzles/solutions; return two lists of 9x9 int grids for train/val.""" + df = pd.read_parquet(parquet_path, engine="pyarrow") + # Shuffle reproducibly + df = df.sample(frac=1.0, random_state=0).reset_index(drop=True) + # Keep only needed columns if present + need_cols = [c for c in ["puzzle", "solution"] if c in df.columns] + if not need_cols or "puzzle" not in need_cols: + raise ValueError(f"Expected 'puzzle' (and optionally 'solution') columns; got: {list(df.columns)}") + + # Slice train/val partitions + df_train = df.iloc[:n_train] + df_val = df.iloc[n_train:n_train+n_val] + + puzzles_train = [str_to_grid(p) for p in df_train["puzzle"].astype(str)] + puzzles_val = [str_to_grid(p) for p in df_val["puzzle"].astype(str)] + + # Solutions are optional (useful later for solver validation) + solutions_train = [str_to_grid(s) for s in df_train["solution"].astype(str)] if "solution" in df_train else None + solutions_val = [str_to_grid(s) for s in df_val["solution"].astype(str)] if "solution" in df_val else None + + return (puzzles_train, solutions_train), (puzzles_val, solutions_val) + +def draw_grid(img, size=9, margin=GRID_MARGIN): + H, W = img.shape[:2] + step = (min(H, W) - 2*margin) // size + x0 = (W - size*step) // 2 + y0 = (H - size*step) // 2 + for i in range(size+1): + thickness = 3 if i % 3 == 0 else 1 + # vertical + cv.line(img, (x0 + i*step, y0), (x0 + i*step, y0 + size*step), (0, 0, 0), thickness) + # horizontal + cv.line(img, (x0, y0 + i*step), (x0 + size*step, y0 + i*step), (0, 0, 0), thickness) + return (x0, y0, step) + +def put_digit(img, r, c, d, x0, y0, step): + if d == 0: + return # blank cell + text = str(d) + scale = step / 60.0 + thickness = 2 + (tw, th), base = cv.getTextSize(text, FONT, scale, thickness) + cx = x0 + c*step + (step - tw)//2 + cy = y0 + r*step + (step + th)//2 - th//4 + cv.putText(img, text, (cx, cy), FONT, scale, (0, 0, 0), thickness, cv.LINE_AA) + +def render_page(puzzle9x9): + page = np.full((IMG_H, IMG_W, 3), 255, np.uint8) + x0, y0, step = draw_grid(page, 9, GRID_MARGIN) + for r in range(9): + for c in range(9): + put_digit(page, r, c, puzzle9x9[r][c], x0, y0, step) + return page, (x0, y0, step) + +def aug_camera(img): + """Light camera-like augmentation: perspective jitter + optional Gaussian blur.""" + H, W = img.shape[:2] + def jitter(pt, s=20): + return (pt[0] + random.randint(-s, s), pt[1] + random.randint(-s, s)) + src = np.float32([(0, 0), (W, 0), (W, H), (0, H)]) + dst = np.float32([jitter((0,0)), jitter((W,0)), jitter((W,H)), jitter((0,H))]) + M = cv.getPerspectiveTransform(src, dst) + warped = cv.warpPerspective(img, M, (W, H), flags=cv.INTER_LINEAR, borderValue=(220, 220, 220)) + if random.random() < 0.5: + k = random.choice([1, 2]) + warped = cv.GaussianBlur(warped, (2*k+1, 2*k+1), 0) + return warped + +def ensure_dirs(split): + for cls in range(10): # 0..9 (0 == blank) + (OUT_DIR / split / str(cls)).mkdir(parents=True, exist_ok=True) + +def save_crops(page, geom, puzzle9x9, split, base_id): + x0, y0, step = geom + idx = 0 + for r in range(9): + for c in range(9): + x1, y1 = x0 + c*step, y0 + r*step + roi = page[y1:y1+step, x1:x1+step] + g = cv.cvtColor(roi, cv.COLOR_BGR2GRAY) + g = cv.resize(g, (CELL_SIZE, CELL_SIZE), interpolation=cv.INTER_AREA) + label = puzzle9x9[r][c] # 0 for blank, 1..9 digits + out_path = OUT_DIR / split / str(label) / f"{base_id}_{idx:02d}.png" + cv.imwrite(str(out_path), g) + idx += 1 + +def process_split(puzzles, split_name, n_limit): + ensure_dirs(split_name) + grid_dir = OUT_DIR / "grids" / split_name + grid_dir.mkdir(parents=True, exist_ok=True) + + N = min(n_limit, len(puzzles)) + for i in tqdm(range(N), desc=f"render {split_name}"): + puzzle = puzzles[i] + + # Clean page + page, geom = render_page(puzzle) + save_crops(page, geom, puzzle, split_name, base_id=f"{i:06d}_clean") + cv.imwrite(str(grid_dir / f"{i:06d}_clean.png"), page) + + # Camera-like + warped = aug_camera(page) + save_crops(warped, geom, puzzle, split_name, base_id=f"{i:06d}_cam") + cv.imwrite(str(grid_dir / f"{i:06d}_cam.png"), warped) + +def main(): + (p_train, _s_train), (p_val, _s_val) = load_puzzles(PARQUET_PATH, N_TRAIN, N_VAL) + process_split(p_train, "train", N_TRAIN) + process_split(p_val, "val", N_VAL) + print("Done. Output under:", OUT_DIR.resolve()) + +if __name__ == "__main__": + main() +``` + +At the top, you set basic knobs for the generator: where to read the Parquet file, where to write outputs, how many puzzles to render for train/val, page size, grid margin, crop size, and the OpenCV font. Tweaking these lets you control dataset scale, visual style, and classifier input size (e.g., CELL_SIZE=32 if you want a slightly larger digit crop). + +The method str_to_grid(s) converts an 81-character Sudoku string into a 9×9 list of integers. Each character represents a cell: 0 is blank, 1–9 are digits. This is the canonical internal representation used throughout the script. + +Then, we have load_puzzles(parquet_path, n_train, n_val), which loads the dataset from Parquet, shuffles it deterministically, and slices it into train/val partitions. It returns the puzzles (and, if present, solutions) as 9×9 integer grids. In this step we only need puzzle for rendering and labeling digit crops (blanks included); solution is useful later for solver validation. + +Subsequently, draw_grid(img, size=9, margin=GRID_MARGIN) draws a Sudoku grid on a blank page image. It computes the step size from the page dimensions and margin, then draws both thin inner lines and thick 3×3 box boundaries. It returns the top-left corner (x0, y0) and the cell size (step), which are reused to place digits and to locate each cell for cropping. + +Next, put_digit(img, r, c, d, x0, y0, step) renders a single digit d at row r, column c inside the grid. The text is centered in the cell using the font metrics; if d == 0, it leaves the cell blank. This mirrors printed-book Sudoku styling so our crops look realistic. + +Another method, render_page(puzzle9x9) builds a complete “book-style” Sudoku page: creates a white canvas, draws the grid, loops over all 81 cells, and writes digits using put_digit. It returns the page plus the grid geometry (x0, y0, step) for subsequent cropping. + +A method aug_camera(img) applies a light, camera-like augmentation to mimic smartphone captures: a small perspective warp (random corner jitter) and optional Gaussian blur. The warp uses a light gray border fill so any exposed areas look like paper rather than colored artifacts. This produces a second version of each page that’s closer to real-world inputs. + +Afterward, ensure_dirs(split) makes the class directories for a given split (train or val) so that crops can be saved in data/{split}/{class}/.... The classes are 0..9 with 0 = blank. + +A method save_crops(page, geom, puzzle9x9, split, base_id) slices the page into 81 cell crops using the grid geometry, converts each crop to grayscale, resizes it to CELL_SIZE × CELL_SIZE, and saves it into the appropriate class directory based on the puzzle’s value at that cell (0..9). Using the puzzle for labels ensures we learn to recognize blanks as well as digits. + +Then, process_split(puzzles, split_name, n_limit) is the workhorse for each partition. For each puzzle, it (1) renders a clean page, saves its 81 crops, and writes the full page under data/grids/{split}; then (2) generates an augmented “camera-like” version and saves its crops and full page too. This gives you both micro-level training data (crops) and macro-level test images (full grids) for the later camera pipeline. + +Finally, main() loads train/val puzzles from Parquet and calls process_split for each. When it finishes, you’ll have: +```console +data/ + train/ + 0/… 1/… … 9/… + val/ + 0/… … 9/… + grids/ + train/ (..._clean.png, ..._cam.png) + val/ (..._clean.png, ..._cam.png) +``` + +## Launching instructions +1. Install dependencies (inside your virtual env): +```console +pip install pandas pyarrow opencv-python tqdm numpy +``` + +2. Place the Parquet file (e.g., train_1.parquet) next to the script or update PARQUET_PATH accordingly. Here we used the file from [this location](https://huggingface.co/datasets/Ritvik19/Sudoku-Dataset/blob/main/train_1.parquet). + +3. Run the generator +```console +python 02_PrepareData.py +``` + +4. Inspect outputs: +* Digit crops live under data/train/{0..9}/ and data/val/{0..9}/. +* Full-page grids (clean + camera-like) live under data/grids/train/ and data/grids/val/. + +Tips +* Start small (N_TRAIN=1000, N_VAL=100) to verify everything, then scale up. +* If you want larger inputs for the classifier, increase CELL_SIZE to 32 or 40. +* To make augmentation a bit stronger (more realistic), slightly increase the perspective jitter in aug_camera, add brightness/contrast jitter, or a faint gradient shadow overlay. + +## Summary +After running this step you’ll have a robust, labeled, Sudoku-specific dataset: thousands of digit crops (including blanks) for training and realistic full-page grids for pipeline testing. You’re ready for the next step—training the digit recognizer and exporting it to ONNX. \ No newline at end of file From 2cf3a822f4d5e121c1ff4512546e01b01e6af14d Mon Sep 17 00:00:00 2001 From: Dawid Borycki Date: Thu, 2 Oct 2025 20:26:39 +0200 Subject: [PATCH 04/12] Training --- .../cross-platform/onnx/04_Training.md | 238 ++++++++++++++++++ .../onnx/{04_Inference.md => 05_Inference.md} | 0 .../cross-platform/onnx/06_Profiling.md | 24 -- ...ningWorkflows.md => 06_SudokuProcessor.md} | 0 4 files changed, 238 insertions(+), 24 deletions(-) create mode 100644 content/learning-paths/cross-platform/onnx/04_Training.md rename content/learning-paths/cross-platform/onnx/{04_Inference.md => 05_Inference.md} (100%) delete mode 100644 content/learning-paths/cross-platform/onnx/06_Profiling.md rename content/learning-paths/cross-platform/onnx/{05_TrainingWorkflows.md => 06_SudokuProcessor.md} (100%) diff --git a/content/learning-paths/cross-platform/onnx/04_Training.md b/content/learning-paths/cross-platform/onnx/04_Training.md new file mode 100644 index 0000000000..35cadef975 --- /dev/null +++ b/content/learning-paths/cross-platform/onnx/04_Training.md @@ -0,0 +1,238 @@ +--- +# User change +title: "Train the Digit Recognizer" + +weight: 5 + +layout: "learningpathall" +--- + +## Objective ## +We will now train a small CNN to classify Sudoku cell crops into 10 classes (0=blank, 1..9=digit), verify accuracy, then export the model to ONNX using the Dynamo exporter and sanity-check parity with ONNX Runtime. This gives us a portable model ready for Arm64 inference and later Android deployment. + +## Creating a model +We use a tiny convolutional neural network (CNN) called DigitNet, designed to be both fast (so it runs efficiently on Arm64 and mobile) and accurate enough for recognizing 28×28 grayscale crops of Sudoku digits. It expects 1 input channel (in_channels=1) because we forced grayscale in the preprocessing step. + +We start by creating a new file digitnet_model.py and defining the DigitNet class: +```python +import torch +import torch.nn as nn + +class DigitNet(nn.Module): + """ + Tiny CNN for Sudoku digit classification. + Classes: 0..9 where 0 = blank. + Input: (N,1,H,W) grayscale (default 28x28). + """ + def __init__(self, num_classes: int = 10): + super().__init__() + self.net = nn.Sequential( + nn.Conv2d(1, 16, 3, padding=1), nn.ReLU(), + nn.MaxPool2d(2), + nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(), + nn.AdaptiveAvgPool2d((1,1)), + nn.Flatten(), + nn.Linear(32, num_classes), + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return self.net(x) +``` + +We use a very compact convolutional neural network (CNN), which we call DigitNet, to recognize Sudoku digits. The goal is to have a model that is simple enough to run efficiently on Arm64 and mobile devices, but still powerful enough to tell apart the ten classes we care about (0 for blank, and digits 1 through 9). + +The network expects each input to be a 28×28 grayscale crop, so it begins with a convolution layer that has one input channel and sixteen filters. This first convolution is responsible for learning very low-level patterns such as strokes or edges. Immediately after, a ReLU activation introduces non-linearity, which allows the network to combine those simple features into more expressive ones. A max-pooling layer then reduces the spatial resolution by half, making the representation more compact and less sensitive to small translations. + +At this point, the feature maps are passed through a second convolutional layer with thirty-two filters. This stage learns richer patterns, for example combinations of edges that form loops or intersections that distinguish an “8” from a “0” or a “6”. Another ReLU activation adds the necessary non-linearity to these higher-level features. + +Instead of flattening the entire feature map, we apply an adaptive average pooling operation that squeezes each of the thirty-two channels down to a single number. This effectively summarizes the information across the whole image and ensures the model produces a fixed-length representation regardless of the exact input size. After pooling, the features are flattened into a one-dimensional vector. + +The final step is a fully connected layer that maps the thirty-two features to ten output values, one for each class. These values are raw scores (logits) that indicate how strongly the model associates the input crop with each digit. During training, a cross-entropy loss will turn these logits into probabilities and guide the model to adjust its weights. + +In practice, this means that when you feed in a batch of grayscale Sudoku cells of shape [N, 1, 28, 28], DigitNet transforms them step by step into a batch of [N, 10] outputs, where each row contains the scores for the ten possible classes. Despite its simplicity, this small CNN strikes a balance between speed and accuracy that makes it ideal for Sudoku digit recognition on resource-constrained devices. + +## Training a model +We will now prepare the self-containing script that trains the above model on the data prepared earlier. Start by creating the new file 03_Training.py and modify it as follows: +```python +import os, random, numpy as np +import torch as tr +import torch.nn as nn +import torch.nn.functional as F +from torch.utils.data import DataLoader +from torchvision import datasets, transforms +from tqdm import tqdm +from torch.onnx import dynamo_export +from torch.export import Dim +import onnxruntime as ort + +from digitnet_model import DigitNet + +# Configuration +random.seed(0); np.random.seed(0); tr.manual_seed(0) +DEVICE = "cpu" # keep CPU for portability +DATA_DIR = "data" # data/train/0..9, data/val/0..9 +ARTI_DIR = "artifacts" +os.makedirs(ARTI_DIR, exist_ok=True) + +BATCH = 256 +EPOCHS = 10 +LR = 1e-3 +WEIGHT_DECAY = 1e-4 +LABEL_SMOOTH = 0.05 + +# Datasets (force grayscale to match model) +tfm_train = transforms.Compose([ + transforms.Grayscale(num_output_channels=1), # force 1-channel input + transforms.ToTensor(), + transforms.Normalize((0.5,), (0.5,)), + transforms.RandomApply([transforms.GaussianBlur(3)], p=0.15), + transforms.RandomAffine(degrees=5, translate=(0.02,0.02), scale=(0.95,1.05)), +]) +tfm_val = transforms.Compose([ + transforms.Grayscale(num_output_channels=1), # force 1-channel input + transforms.ToTensor(), + transforms.Normalize((0.5,), (0.5,)), +]) + +train_ds = datasets.ImageFolder(os.path.join(DATA_DIR, "train"), transform=tfm_train) +val_ds = datasets.ImageFolder(os.path.join(DATA_DIR, "val"), transform=tfm_val) + +train_loader = DataLoader(train_ds, batch_size=BATCH, shuffle=True, num_workers=0) +val_loader = DataLoader(val_ds, batch_size=BATCH, shuffle=False, num_workers=0) + +def evaluate(model: nn.Module, loader: DataLoader) -> float: + model.eval() + correct = total = 0 + with tr.no_grad(): + for x, y in loader: + x, y = x.to(DEVICE), y.to(DEVICE) + pred = model(x).argmax(1) + correct += (pred == y).sum().item() + total += y.numel() + return correct / total if total else 0.0 + +def main(): + # Sanity: verify loader channels + xb, _ = next(iter(train_loader)) + print("Train batch shape:", xb.shape) # expect [B, 1, 28, 28] + + model = DigitNet(num_classes=10).to(DEVICE) + opt = tr.optim.AdamW(model.parameters(), lr=LR, weight_decay=WEIGHT_DECAY) + + best_acc, best_state = 0.0, None + for ep in range(1, EPOCHS + 1): + model.train() + for x, y in tqdm(train_loader, desc=f"epoch {ep}/{EPOCHS}"): + x, y = x.to(DEVICE), y.to(DEVICE) + opt.zero_grad() + logits = model(x) + loss = F.cross_entropy(logits, y, label_smoothing=LABEL_SMOOTH) + loss.backward() + opt.step() + + acc = evaluate(model, val_loader) + print(f"val acc: {acc:.4f}") + if acc > best_acc: + best_acc = acc + best_state = {k: v.cpu().clone() for k, v in model.state_dict().items()} + + if best_state is not None: + model.load_state_dict(best_state) + print(f"Best val acc: {best_acc:.4f}") + + # Save PyTorch weights (optional) + tr.save(model.state_dict(), os.path.join(ARTI_DIR, "digitnet_best.pth")) + + # Export to ONNX with dynamic batch using the Dynamo API + model.eval() + dummy = tr.randn(1, 1, 28, 28) + onnx_path = os.path.join(ARTI_DIR, "sudoku_digitnet.onnx") + + tr.onnx.export( + model, # model + dummy, # input tensor corresponds to arg name 'x' + onnx_path, # output .onnx + input_names=["input"], # ONNX *display* name (independent of arg name) + output_names=["logits"], + opset_version=19, + do_constant_folding=True, + keep_initializers_as_inputs=False, + dynamo=True, + dynamic_shapes={"x": {0: Dim("N")}} + ) + + print("Exported:", onnx_path) + + # quick parity with a big batch (proves dynamic batch works) + sess = ort.InferenceSession(onnx_path, providers=["CPUExecutionProvider"]) + x = tr.randn(512, 1, 28, 28) + onnx_logits = sess.run(["logits"], {"input": x.numpy().astype(np.float32)})[0] + pt_logits = model(x).detach().numpy() + print("Parity MAE:", np.mean(np.abs(onnx_logits - pt_logits))) + +if __name__ == "__main__": + main() +``` + +This file is a self-contained trainer for the Sudoku digit classifier. It starts by fixing random seeds for reproducibility and sets DEVICE="cpu" so the workflow runs the same on desktops and Arm64 boards. It expects the dataset from the previous step under data/train/0..9 and data/val/0..9, and creates an artifacts/ folder for all outputs. + +The script builds two dataloaders (train/val) with a preprocessing stack that forces grayscale (Grayscale(num_output_channels=1)) so inputs match the model’s first convolution, converts to tensors, and normalizes to a centered range. Light augmentations on the training split—small affine jitter and occasional blur—mimic camera variability without distorting the digits. Batch size, epochs, and learning rate are set to conservative defaults so training is smooth on CPU; you can scale them up later. + +Then, the script it instantiates DigitNet(num_classes=10) model. The optimizer is AdamW with mild weight decay to control overfitting. The loss is cross-entropy with label smoothing (e.g., 0.05), which reduces over-confidence and helps on easily confused shapes (like 6/8/9). + +The training loop runs for a fixed number of epochs, iterating mini-batches from the training set. After each epoch, it evaluates on the validation split and logs the accuracy. The script keeps track of the best model state seen so far (based on val accuracy) and restores it at the end, ensuring the final model corresponds to your best epoch, not just the last one. + +The file will create two artifacts: +1. digitnet_best.pth — the best PyTorch weights (handy for quick experiments, fine-tuning, or debugging later). +2. sudoku_digitnet.onnx — the exported ONNX model, produced with PyTorch’s Dynamo exporter and a dynamic batch dimension. Dynamic batch means the model accepts input of shape [N, 1, 28, 28] for any N, which is ideal for efficient batched inference on Arm64 and for Android integration. + +Right after export, the script runs a parity test: it feeds the same randomly generated batch through both the PyTorch model and the ONNX model (executed by ONNX Runtime) and prints the mean absolute error between their logits. A tiny value confirms the exported graph faithfully matches your trained network. + +## Running the script +To run the training script, type: + +```console +python 03_Training.py +``` + +The script will train, validate, export, and verify the digit recognizer in one go. After it finishes, you’ll have both a portable ONNX model and a PyTorch checkpoint ready for the next step—building the image processor that detects the Sudoku grid, rectifies it, segments cells, and performs batched ONNX inference to reconstruct the board for solving. + +Here is a sample run: + +```output +python3 03_Training.py +Train batch shape: torch.Size([256, 1, 28, 28]) +epoch 1/10: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 1597/1597 [03:24<00:00, 7.82it/s] +val acc: 0.8099 +epoch 2/10: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 1597/1597 [03:18<00:00, 8.05it/s] +val acc: 0.8378 +epoch 3/10: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 1597/1597 [03:17<00:00, 8.09it/s] +val acc: 0.8855 +epoch 4/10: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 1597/1597 [03:20<00:00, 7.97it/s] +val acc: 0.9180 +epoch 5/10: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 1597/1597 [03:20<00:00, 7.97it/s] +val acc: 0.9527 +epoch 6/10: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 1597/1597 [03:22<00:00, 7.88it/s] +val acc: 0.9635 +epoch 7/10: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 1597/1597 [03:22<00:00, 7.88it/s] +val acc: 0.9777 +epoch 8/10: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 1597/1597 [03:21<00:00, 7.91it/s] +val acc: 0.9854 +epoch 9/10: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 1597/1597 [03:21<00:00, 7.91it/s] +val acc: 0.9912 +epoch 10/10: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████| 1597/1597 [03:21<00:00, 7.91it/s] +val acc: 0.9928 +Best val acc: 0.9928 +[torch.onnx] Obtain model graph for `DigitNet([...]` with `torch.export.export(..., strict=False)`... +[torch.onnx] Obtain model graph for `DigitNet([...]` with `torch.export.export(..., strict=False)`... ✅ +[torch.onnx] Run decomposition... +[torch.onnx] Run decomposition... ✅ +[torch.onnx] Translate the graph into ONNX... +[torch.onnx] Translate the graph into ONNX... ✅ +Applied 1 of general pattern rewrite rules. +Exported: artifacts/sudoku_digitnet.onnx +Parity MAE: 1.0251999e-05 +``` + +## Summary +By running the training script you train the DigitNet CNN on the Sudoku digit dataset, steadily improving accuracy across epochs until the model surpasses 99% validation accuracy. The process builds on the earlier steps where we first defined the model architecture in digitnet_model.py and then prepared a dedicated training script to handle data loading, augmentation, optimization, and evaluation. During training the best-performing model state is saved, and at the end it is exported to the ONNX format with dynamic batch support. A parity check confirms that the ONNX and PyTorch versions produce virtually identical outputs (mean error ~1e-5). You now have a validated ONNX model (artifacts/sudoku_digitnet.onnx) and a PyTorch checkpoint (digitnet_best.pth), both ready for integration into the Sudoku image processing pipeline. Before moving on to grid detection and solving, however, we will first run standalone inference to confirm the model’s predictions on individual digit crops. diff --git a/content/learning-paths/cross-platform/onnx/04_Inference.md b/content/learning-paths/cross-platform/onnx/05_Inference.md similarity index 100% rename from content/learning-paths/cross-platform/onnx/04_Inference.md rename to content/learning-paths/cross-platform/onnx/05_Inference.md diff --git a/content/learning-paths/cross-platform/onnx/06_Profiling.md b/content/learning-paths/cross-platform/onnx/06_Profiling.md deleted file mode 100644 index de7e75b8ae..0000000000 --- a/content/learning-paths/cross-platform/onnx/06_Profiling.md +++ /dev/null @@ -1,24 +0,0 @@ ---- -# User change -title: "Summary" - -weight: 6 - -layout: "learningpathall" ---- -## Summary ## - -In this Learning Path, you have created an Android application to capture and process camera images using OpenCV. - -You performed the following steps: - -* Integrated the OpenCV library into your Android project. - -* Enabled camera permissions to ensure the application can access the device's camera. - -* Set up `JavaCameraView` to capture real-time frames from the camera. You declared and initialized Mat objects to store and process camera frames. - -* Implemented adaptive thresholding using OpenCV's `Imgproc.adaptiveThreshold` to process the camera frames when a checkbox is checked. - -By following these steps, you have successfully created an Android application that captures real-time images from the camera. - diff --git a/content/learning-paths/cross-platform/onnx/05_TrainingWorkflows.md b/content/learning-paths/cross-platform/onnx/06_SudokuProcessor.md similarity index 100% rename from content/learning-paths/cross-platform/onnx/05_TrainingWorkflows.md rename to content/learning-paths/cross-platform/onnx/06_SudokuProcessor.md From e6e74730d64d9917e1810bae621cbfd2db9d58e0 Mon Sep 17 00:00:00 2001 From: Dawid Borycki Date: Mon, 15 Dec 2025 18:10:06 +0100 Subject: [PATCH 05/12] 6 & 7 --- .../cross-platform/onnx/05_Inference.md | 243 ++++++- .../cross-platform/onnx/06_SudokuProcessor.md | 621 +++++++++++++++++- .../cross-platform/onnx/figures/01.png | Bin 0 -> 56481 bytes .../cross-platform/onnx/figures/02.png | Bin 0 -> 384284 bytes 4 files changed, 843 insertions(+), 21 deletions(-) create mode 100644 content/learning-paths/cross-platform/onnx/figures/01.png create mode 100644 content/learning-paths/cross-platform/onnx/figures/02.png diff --git a/content/learning-paths/cross-platform/onnx/05_Inference.md b/content/learning-paths/cross-platform/onnx/05_Inference.md index de7e75b8ae..83ac758918 100644 --- a/content/learning-paths/cross-platform/onnx/05_Inference.md +++ b/content/learning-paths/cross-platform/onnx/05_Inference.md @@ -1,24 +1,249 @@ --- # User change -title: "Summary" +title: "Inference and Model Evaluation" weight: 6 layout: "learningpathall" --- -## Summary ## -In this Learning Path, you have created an Android application to capture and process camera images using OpenCV. +## Objective ## +In this section, we validate the digit recognizer by running inference on the validation dataset using both the PyTorch checkpoint and the exported ONNX model. We verify that PyTorch and ONNX Runtime produce consistent results, analyze class-level behavior using a confusion matrix, and generate visual diagnostics for debugging and documentation. This step acts as a final verification checkpoint before integrating the model into the full OpenCV-based Sudoku processing pipeline. -You performed the following steps: +Before introducing geometric processing, grid detection, and perspective correction, it is important to confirm that the digit recognizer works reliably in isolation. By validating inference and analyzing errors at the digit level, we ensure that any future issues in the end-to-end system can be attributed to image processing or geometry rather than the classifier itself. -* Integrated the OpenCV library into your Android project. +## Inference and Evaluation Script +Create a new file named 04_Test.py and paste the script below into it. This script evaluates the digit recognizer in a way that closely mirrors deployment conditions. It compares PyTorch and ONNX Runtime inference, measures accuracy on the validation dataset, and generates visual diagnostics that reveal both strengths and remaining failure modes of the model. -* Enabled camera permissions to ensure the application can access the device's camera. +```python +import os, numpy as np, torch +from torchvision import datasets, transforms +from torch.utils.data import DataLoader +from tqdm import tqdm +import matplotlib.pyplot as plt -* Set up `JavaCameraView` to capture real-time frames from the camera. You declared and initialized Mat objects to store and process camera frames. +from digitnet_model import DigitNet -* Implemented adaptive thresholding using OpenCV's `Imgproc.adaptiveThreshold` to process the camera frames when a checkbox is checked. +DATA_DIR = "data" +ARTI_DIR = "artifacts" +os.makedirs(ARTI_DIR, exist_ok=True) -By following these steps, you have successfully created an Android application that captures real-time images from the camera. +ONNX_PATH = os.path.join(ARTI_DIR, "sudoku_digitnet.onnx") # fp32 +# Same normalization as training (and force grayscale → 1 channel) +tfm_val = transforms.Compose([ + transforms.Grayscale(num_output_channels=1), + transforms.ToTensor(), + transforms.Normalize((0.5,), (0.5,)) +]) +val_ds = datasets.ImageFolder(os.path.join(DATA_DIR, "val"), transform=tfm_val) +val_loader = DataLoader(val_ds, batch_size=512, shuffle=False, num_workers=0) + +DIGIT_NAMES = [str(i) for i in range(10)] # 0 = blank, 1..9 = digits + + +def evaluate_pytorch(model, loader): + model.eval() + correct = total = 0 + with torch.no_grad(): + for x, y in loader: + pred = model(x).argmax(1) + correct += (pred == y).sum().item() + total += y.numel() + return correct / total if total else 0.0 + + +def confusion_matrix_onnx(onnx_model_path, loader): + import onnxruntime as ort + sess = ort.InferenceSession(onnx_model_path, providers=["CPUExecutionProvider"]) + mat = np.zeros((10, 10), dtype=np.int64) + total = 0 + correct = 0 + for x, y in tqdm(loader, desc="ONNX eval"): + # x: torch tensor [N,1,28,28] normalized to [-1,1] + inp = x.numpy().astype(np.float32) + logits = sess.run(["logits"], {"input": inp})[0] # [N,10] + pred = logits.argmax(axis=1) + y_np = y.numpy() + for t, p in zip(y_np, pred): + mat[t, p] += 1 + correct += (pred == y_np).sum() + total += y_np.size + acc = float(correct) / float(total) if total else 0.0 + return acc, mat + + +def plot_confusion_matrix(cm, classes=DIGIT_NAMES, normalize=False, title="Confusion matrix", fname=None): + """Plot confusion matrix. If normalize=True, rows sum to 1.""" + cm_plot = cm.astype("float") + if normalize: + row_sums = cm_plot.sum(axis=1, keepdims=True) + 1e-12 + cm_plot = cm_plot / row_sums + + plt.figure(figsize=(6, 5)) + plt.imshow(cm_plot, interpolation="nearest") + plt.title(title) + plt.colorbar() + tick_marks = np.arange(len(classes)) + plt.xticks(tick_marks, classes) + plt.yticks(tick_marks, classes) + + # Label each cell + thresh = cm_plot.max() / 2.0 + for i in range(cm_plot.shape[0]): + for j in range(cm_plot.shape[1]): + txt = f"{cm_plot[i, j]:.2f}" if normalize else f"{int(cm_plot[i, j])}" + plt.text(j, i, txt, + horizontalalignment="center", + verticalalignment="center", + fontsize=7, + color="white" if cm_plot[i, j] > thresh else "black") + + plt.ylabel("True label") + plt.xlabel("Predicted label") + plt.tight_layout() + if fname: + plt.savefig(fname, dpi=150) + print(f"Saved: {fname}") + plt.show() + + +def sample_predictions_onnx(onnx_path, dataset, k=24, seed=0): + """Show a grid of sample predictions (mix of correct and misclassified).""" + import onnxruntime as ort + rng = np.random.default_rng(seed) + sess = ort.InferenceSession(onnx_path, providers=["CPUExecutionProvider"]) + + # Over-sample candidates then choose some wrong + some right + idxs = rng.choice(len(dataset), size=min(k * 2, len(dataset)), replace=False) + imgs, ys, preds = [], [], [] + + for i in idxs: + x, y = dataset[i] # x: [1,28,28] after transforms; y: int + x_np = x.unsqueeze(0).numpy().astype(np.float32) # [1,1,28,28] + logits = sess.run(["logits"], {"input": x_np})[0] # [1,10] + p = int(np.argmax(logits, axis=1)[0]) + imgs.append(x.squeeze(0).numpy()) # [28,28] + ys.append(int(y)) + preds.append(p) + + mis_idx = [i for i, (t, p) in enumerate(zip(ys, preds)) if t != p] + cor_idx = [i for i, (t, p) in enumerate(zip(ys, preds)) if t == p] + picked = (mis_idx[:k // 2] + cor_idx[:k - len(mis_idx[:k // 2])])[:k] + if not picked: # fallback + picked = list(range(min(k, len(imgs)))) + + # Plot grid + import math + cols = 8 + rows = math.ceil(len(picked) / cols) + plt.figure(figsize=(cols * 1.6, rows * 1.8)) + for j, idx in enumerate(picked): + plt.subplot(rows, cols, j + 1) + plt.imshow(imgs[idx], cmap="gray") + t, p = ys[idx], preds[idx] + title = f"T:{t} P:{p}" + color = "green" if t == p else "red" + plt.title(title, color=color, fontsize=9) + plt.axis("off") + plt.tight_layout() + out = os.path.join(ARTI_DIR, "samples_grid.png") + plt.savefig(out, dpi=150) + print(f"Saved: {out}") + plt.show() + +def main(): + # Optional: evaluate the best PyTorch checkpoint for reference + pt_ckpt = os.path.join(ARTI_DIR, "digitnet_best.pth") + if os.path.exists(pt_ckpt): + model = DigitNet() + model.load_state_dict(torch.load(pt_ckpt, map_location="cpu")) + pt_acc = evaluate_pytorch(model, val_loader) + print(f"PyTorch val acc: {pt_acc:.4f}") + else: + print("No PyTorch checkpoint found; skipping PT eval.") + + # Evaluate ONNX fp32 + if os.path.exists(ONNX_PATH): + acc, cm = confusion_matrix_onnx(ONNX_PATH, val_loader) + print(f"ONNX fp32 val acc: {acc:.4f}") + print("Confusion matrix (rows=true, cols=pred):\n", cm) + + # Plots: counts + normalized + plot_confusion_matrix(cm, normalize=False, + title="ONNX fp32 – Confusion (counts)", + fname=os.path.join(ARTI_DIR, "cm_fp32_counts.png")) + plot_confusion_matrix(cm, normalize=True, + title="ONNX fp32 – Confusion (row-normalized)", + fname=os.path.join(ARTI_DIR, "cm_fp32_norm.png")) + + # Sample predictions grid + try: + sample_predictions_onnx(ONNX_PATH, val_ds, k=24) + except Exception as e: + print("Sample grid skipped:", e) + else: + print("Missing ONNX model:", ONNX_PATH) + +if __name__ == "__main__": + main() +``` + +The script first loads the validation dataset using the same preprocessing pipeline as training, including forced grayscale conversion to ensure a single input channel. It then optionally evaluates the best PyTorch checkpoint (digitnet_best.pth) to establish a reference accuracy. + +Next, the exported ONNX model (sudoku_digitnet.onnx) is loaded using ONNX Runtime and evaluated in batches. Because the model was exported with a dynamic batch dimension, inference can be performed efficiently on larger batches, which is representative of how the model will be used later in the pipeline. + +The script expects two things from the earlier steps: +1. A validation dataset stored under data/val/0..9/… +2. A trained model exported in previous step and stored under artifacts/ + * artifacts/digitnet_best.pth (optional, PyTorch weights) + * artifacts/sudoku_digitnet.onnx (required, ONNX model) + +When you run the script, it first loads the validation dataset using the same preprocessing as training, including forcing grayscale so the input has a single channel. It then optionally evaluates the PyTorch checkpoint to provide a reference accuracy. After that, it runs batched inference with ONNX Runtime, computes an overall accuracy, and builds a confusion matrix (true class vs predicted class) that reveals which digits are being confused. + +In addition to printing accuracy metrics, the script generates two types of diagnostic outputs: +1. Confusion matrix visualizations, saved as: + * artifacts/cm_fp32_counts.png (raw counts) + * artifacts/cm_fp32_norm.png (row-normalized) +2. A grid of example predictions, saved as: + *artifacts/samples_grid.png + +These artifacts provide both quantitative and qualitative insight into model performance. + +In the sample grid, each tile shows one crop together with its True label (T:) and Predicted label (P:), with correct predictions highlighted in green and mistakes highlighted in red. This makes it easy to quickly verify that the classifier behaves sensibly and to spot remaining failure modes. + +## Running the script +Run the evaluation script from the project root: + +```console +python 04_Test.py +``` + +In the example below, the PyTorch and ONNX accuracies match exactly, confirming that the export process preserved model behavior. + +```console +python3 04_Test.py +PyTorch val acc: 0.9928 +ONNX eval: 100%|███████████████████████████████████████████████████████████| 32/32 [00:01<00:00, 21.06it/s] +ONNX fp32 val acc: 0.9928 +Confusion matrix (rows=true, cols=pred): + [[12623 7 0 0 0 0 0 0 0 0] + [ 0 420 0 0 0 0 0 0 0 0] + [ 0 0 331 0 4 0 1 0 0 0] + [ 0 1 0 332 0 1 0 0 0 0] + [ 0 0 0 0 460 0 0 0 0 0] + [ 0 1 0 1 0 486 2 0 0 0] + [ 1 0 0 0 0 19 387 0 1 2] + [ 0 1 0 0 0 0 0 375 0 0] + [ 0 0 0 0 0 6 27 0 297 10] + [ 0 1 0 0 0 14 10 0 7 372]] +Saved: artifacts/cm_fp32_counts.png +``` + +![img1](Figures/01.png) +The confusion matrix provides more insight than a single accuracy number. Each row corresponds to the true class, and each column corresponds to the predicted class. A strong diagonal indicates correct classification. In this output, blank cells (class 0) are almost always recognized correctly, while the remaining errors occur primarily between visually similar printed digits such as 6, 8, and 9. + +This behavior is expected and indicates that the model has learned meaningful digit features. The remaining confusions are rare and can be addressed later through targeted augmentation or higher-resolution crops if needed. + +## Summary +With inference validated and error modes understood, the digit recognizer is now ready to be embedded into the full Sudoku image-processing pipeline, where OpenCV will be used to detect the grid, rectify perspective, segment cells, and run batched ONNX inference to reconstruct and solve complete puzzles. \ No newline at end of file diff --git a/content/learning-paths/cross-platform/onnx/06_SudokuProcessor.md b/content/learning-paths/cross-platform/onnx/06_SudokuProcessor.md index de7e75b8ae..ff8efb6a93 100644 --- a/content/learning-paths/cross-platform/onnx/06_SudokuProcessor.md +++ b/content/learning-paths/cross-platform/onnx/06_SudokuProcessor.md @@ -1,24 +1,621 @@ --- # User change -title: "Summary" - -weight: 6 - +title: "Sudoku Processor: From Image to Solution" +weight: 7 layout: "learningpathall" + --- -## Summary ## -In this Learning Path, you have created an Android application to capture and process camera images using OpenCV. +## Objective ## + +In this section, we integrate all previous components into a complete Sudoku processing pipeline. Starting from a full Sudoku image, we detect and rectify the grid, split it into individual cells, recognize digits using the ONNX model, and finally solve the puzzle using a deterministic solver. By the end of this step, you will have an end-to-end system that takes a photograph of a Sudoku puzzle and produces a solved board, along with visual outputs for debugging and validation. + +So far, we have: +1. Generated a synthetic, well-labeled Sudoku digit dataset, +2. Trained a lightweight CNN (DigitNet) to recognize digits and blanks, +3. Exported the model to ONNX with dynamic batch support, +4. Validated inference correctness and analyzed errors using confusion matrices. + +At this point, the digit recognizer is reliable in isolation. The remaining challenge is connecting vision with reasoning: extracting the Sudoku grid from an image, mapping each cell to a digit, and applying a solver. This section bridges that gap. + +## Overview of the pipeline +To implement the Sudoku processor, create a new file sudoku_processor.py and modify it as follows: + +```Python +import cv2 as cv +import numpy as np +import onnxruntime as ort + +class SudokuProcessor: + def __init__( + self, + onnx_path: str, + input_size: int = 28, + warp_size: int = 450, + blank_class: int = 0, + blank_conf_threshold: float = 0.65, + providers=("CPUExecutionProvider",), + ): + """ + onnx_path: path to sudoku_digitnet.onnx + input_size: model input spatial size (28) + warp_size: size of rectified square board (e.g., 450 => each cell ~50px) + blank_class: class index used for blanks (0) + blank_conf_threshold: if model confidence < threshold, treat as blank (helps noisy cells) + """ + self.onnx_path = onnx_path + self.input_size = input_size + self.warp_size = warp_size + self.blank_class = blank_class + self.blank_conf_threshold = blank_conf_threshold + + self.sess = ort.InferenceSession(onnx_path, providers=list(providers)) + self.input_name = self.sess.get_inputs()[0].name # typically "input" + self.output_name = self.sess.get_outputs()[0].name # typically "logits" + + def process_image(self, bgr: np.ndarray, overlay: bool = True): + """ + Returns: + board (9x9 ints with 0 for blank), + solved_board (9x9 ints, or None if unsolved), + debug dict (warped, contours, etc.), + overlay_bgr (optional solution overlay) + """ + warped, H, quad = self.detect_and_warp_board(bgr) + cells = self.split_cells(warped) + board, conf = self.recognize_board(cells) + + solved = [row[:] for row in board] + ok = solve_sudoku(solved) + + overlay_img = None + if overlay and ok: + overlay_img = self.overlay_solution(bgr, H, quad, board, solved) + + debug = { + "warped": warped, + "homography": H, + "quad": quad, + "confidence": conf, + } + return board, (solved if ok else None), debug, overlay_img + + # ----------------------------- + # Board detection / rectification + # ----------------------------- + def detect_and_warp_board(self, bgr: np.ndarray): + """ + Finds the largest Sudoku-like quadrilateral and warps it to a square. + Returns warped_board, homography, quad_points. + """ + gray = cv.cvtColor(bgr, cv.COLOR_BGR2GRAY) + blur = cv.GaussianBlur(gray, (5, 5), 0) + + # Strong binary image helps contour finding (works well for printed grids) + thr = cv.adaptiveThreshold( + blur, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY_INV, 31, 7 + ) + + # Remove small noise, connect lines a bit + kernel = cv.getStructuringElement(cv.MORPH_RECT, (3, 3)) + thr = cv.morphologyEx(thr, cv.MORPH_CLOSE, kernel, iterations=2) + + contours, _ = cv.findContours(thr, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE) + if not contours: + raise RuntimeError("No contours found. Try a clearer image or different thresholding.") + + # Pick the largest contour that approximates to 4 points + contours = sorted(contours, key=cv.contourArea, reverse=True) + quad = None + for c in contours[:20]: + peri = cv.arcLength(c, True) + approx = cv.approxPolyDP(c, 0.02 * peri, True) + if len(approx) == 4: + quad = approx.reshape(4, 2).astype(np.float32) + break + + if quad is None: + raise RuntimeError("Could not find a 4-corner Sudoku grid. Try a more fronto-parallel image.") + + quad = order_quad_points(quad) + + dst = np.array( + [[0, 0], [self.warp_size - 1, 0], [self.warp_size - 1, self.warp_size - 1], [0, self.warp_size - 1]], + dtype=np.float32, + ) + H = cv.getPerspectiveTransform(quad, dst) + warped = cv.warpPerspective(bgr, H, (self.warp_size, self.warp_size)) + + return warped, H, quad + + # ----------------------------- + # Cell splitting / preprocessing + # ----------------------------- + def split_cells(self, warped_bgr: np.ndarray): + """ + Splits a rectified square board into 81 cell images. + Returns list of (r, c, cell_bgr). + """ + cells = [] + step = self.warp_size // 9 + for r in range(9): + for c in range(9): + y0, y1 = r * step, (r + 1) * step + x0, x1 = c * step, (c + 1) * step + cell = warped_bgr[y0:y1, x0:x1].copy() + cells.append((r, c, cell)) + return cells + + def preprocess_cell(self, cell_bgr: np.ndarray): + """ + Produces a 28x28 float32 tensor in the same normalization as training: + grayscale -> [0,1] -> normalize to [-1,1] via (x-0.5)/0.5 + Also tries to suppress grid lines / borders by cropping margins. + """ + g = cv.cvtColor(cell_bgr, cv.COLOR_BGR2GRAY) + + # Crop a margin to remove grid lines/borders + h, w = g.shape + m = int(0.12 * min(h, w)) # ~12% margin + g = g[m:h - m, m:w - m] + + # Binarize & clean (helps isolate printed digits) + g_blur = cv.GaussianBlur(g, (3, 3), 0) + bw = cv.adaptiveThreshold(g_blur, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY_INV, 21, 5) + + # Remove small specks + bw = cv.morphologyEx(bw, cv.MORPH_OPEN, np.ones((2, 2), np.uint8), iterations=1) + + # If almost empty => likely blank + if (bw > 0).sum() < 15: + # Return a near-empty input; classifier should produce blank + resized = cv.resize(g, (self.input_size, self.input_size), interpolation=cv.INTER_AREA) + else: + # Use bw mask to focus on digit; keep as grayscale for the model + resized = cv.resize(g, (self.input_size, self.input_size), interpolation=cv.INTER_AREA) + + x = resized.astype(np.float32) / 255.0 + x = (x - 0.5) / 0.5 # [-1,1] + x = x[None, None, :, :] # [1,1,H,W] + return x + + # ----------------------------- + # Inference + # ----------------------------- + def recognize_board(self, cells): + """ + Runs batched ONNX inference on 81 cells and returns: + board[9][9] with 0 for blank + conf[9][9] with max softmax probability + """ + xs = [] + coords = [] + for r, c, cell in cells: + coords.append((r, c)) + xs.append(self.preprocess_cell(cell)) + + X = np.concatenate(xs, axis=0).astype(np.float32) # [81,1,28,28] + logits = self.sess.run([self.output_name], {self.input_name: X})[0] # [81,10] + probs = softmax(logits, axis=1) + pred = probs.argmax(axis=1) + conf = probs.max(axis=1) + + board = [[0 for _ in range(9)] for _ in range(9)] + conf_grid = [[0.0 for _ in range(9)] for _ in range(9)] + for i, (r, c) in enumerate(coords): + p = int(pred[i]) + cf = float(conf[i]) + + # Optional safety: low-confidence => blank + if cf < self.blank_conf_threshold: + p = self.blank_class + + board[r][c] = p + conf_grid[r][c] = cf + + return board, conf_grid + + # ----------------------------- + # Overlay + # ----------------------------- + def overlay_solution(self, original_bgr, H, quad, board, solved): + """ + Overlays ONLY the filled-in digits (where original board has 0). + """ + invH = np.linalg.inv(H) + overlay = original_bgr.copy() + + step = self.warp_size // 9 + # Create a transparent layer in warped space then map back + layer = np.zeros((self.warp_size, self.warp_size, 3), dtype=np.uint8) + + for r in range(9): + for c in range(9): + if board[r][c] != 0: + continue + d = solved[r][c] + # text placement in warped coordinates + x = int(c * step + step * 0.32) + y = int(r * step + step * 0.72) + cv.putText(layer, str(d), (x, y), cv.FONT_HERSHEY_SIMPLEX, 1.2, (0, 200, 0), 2, cv.LINE_AA) + + # Warp overlay layer back to original image + h0, w0 = original_bgr.shape[:2] + back = cv.warpPerspective(layer, invH, (w0, h0)) + + # Blend + mask = (back.sum(axis=2) > 0).astype(np.uint8) * 255 + mask3 = cv.merge([mask, mask, mask]) + overlay = np.where(mask3 > 0, cv.addWeighted(overlay, 0.6, back, 0.4, 0), overlay) + return overlay + + +# ----------------------------- +# Solver (backtracking) +# ----------------------------- +def solve_sudoku(board): + pos = find_empty(board) + if pos is None: + return True + r, c = pos + for v in range(1, 10): + if valid(board, r, c, v): + board[r][c] = v + if solve_sudoku(board): + return True + board[r][c] = 0 + return False + + +def find_empty(board): + for r in range(9): + for c in range(9): + if board[r][c] == 0: + return (r, c) + return None + + +def valid(board, r, c, v): + # row + for j in range(9): + if board[r][j] == v: + return False + # col + for i in range(9): + if board[i][c] == v: + return False + # box + br, bc = 3 * (r // 3), 3 * (c // 3) + for i in range(br, br + 3): + for j in range(bc, bc + 3): + if board[i][j] == v: + return False + return True + + +# ----------------------------- +# Utilities +# ----------------------------- +def order_quad_points(pts): + """ + Orders 4 points into: top-left, top-right, bottom-right, bottom-left. + """ + pts = np.array(pts, dtype=np.float32) + s = pts.sum(axis=1) + diff = np.diff(pts, axis=1).reshape(-1) + + tl = pts[np.argmin(s)] + br = pts[np.argmax(s)] + tr = pts[np.argmin(diff)] + bl = pts[np.argmax(diff)] + + return np.array([tl, tr, br, bl], dtype=np.float32) + + +def softmax(x, axis=1): + x = x - np.max(x, axis=axis, keepdims=True) + e = np.exp(x) + return e / (np.sum(e, axis=axis, keepdims=True) + 1e-12) +``` + +The Sudoku processor follows a sequence of steps: +1. Grid detection – find the outer Sudoku grid in the input image. +2. Perspective rectification – warp the grid to a square, top-down view. +3. Cell extraction – split the rectified grid into 81 cell images. +4. Digit recognition – run batched ONNX inference to classify each cell. +5. Board reconstruction – assemble a 9×9 numeric board. +6. Solving – apply a backtracking Sudoku solver. +7. Visualization – overlay the solution and render clean board images. + +We encapsulate the entire pipeline in a reusable class called SudokuProcessor. This class loads the ONNX model once and exposes a single high-level method that processes an input image and returns both intermediate results and final outputs. + +Conceptually, the processor: +* Accepts a BGR image, +* Returns the recognized board, the solved board (if solvable), and optional visual overlays. + +This design keeps inference fast and makes the processor easy to integrate later into an Android application or embedded system. + +## Grid detection and rectification +The first task is to locate the Sudoku grid in the image. We convert the image to grayscale, apply adaptive thresholding, and use contour detection to find large rectangular shapes. The largest contour that approximates a quadrilateral is assumed to be the Sudoku grid. + +Once the four corners are identified, we compute a perspective transform and warp the grid into a square image. This rectified representation removes camera tilt and perspective distortion, allowing all subsequent steps to assume a fixed geometry. + +```Python +def detect_and_warp_board(self, bgr: np.ndarray): + """ + Finds the largest Sudoku-like quadrilateral and warps it to a square. + Returns warped_board, homography, quad_points. + """ + gray = cv.cvtColor(bgr, cv.COLOR_BGR2GRAY) + blur = cv.GaussianBlur(gray, (5, 5), 0) + + # Strong binary image helps contour finding (works well for printed grids) + thr = cv.adaptiveThreshold( + blur, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY_INV, 31, 7 + ) + + # Remove small noise, connect lines a bit + kernel = cv.getStructuringElement(cv.MORPH_RECT, (3, 3)) + thr = cv.morphologyEx(thr, cv.MORPH_CLOSE, kernel, iterations=2) + + contours, _ = cv.findContours(thr, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE) + if not contours: + raise RuntimeError("No contours found. Try a clearer image or different thresholding.") + + # Pick the largest contour that approximates to 4 points + contours = sorted(contours, key=cv.contourArea, reverse=True) + quad = None + for c in contours[:20]: + peri = cv.arcLength(c, True) + approx = cv.approxPolyDP(c, 0.02 * peri, True) + if len(approx) == 4: + quad = approx.reshape(4, 2).astype(np.float32) + break + + if quad is None: + raise RuntimeError("Could not find a 4-corner Sudoku grid. Try a more fronto-parallel image.") + + quad = order_quad_points(quad) + + dst = np.array( + [[0, 0], [self.warp_size - 1, 0], [self.warp_size - 1, self.warp_size - 1], [0, self.warp_size - 1]], + dtype=np.float32, + ) + H = cv.getPerspectiveTransform(quad, dst) + warped = cv.warpPerspective(bgr, H, (self.warp_size, self.warp_size)) + + return warped, H, quad +``` + +## Splitting the grid into cells +After rectification, the grid is divided evenly into a 9×9 array. Each cell is cropped based on its row and column index. At this stage, every cell corresponds to one Sudoku position and is ready for preprocessing and classification. + +```Python +def split_cells(self, warped_bgr: np.ndarray): + """ + Splits a rectified square board into 81 cell images. + Returns list of (r, c, cell_bgr). + """ + cells = [] + step = self.warp_size // 9 + for r in range(9): + for c in range(9): + y0, y1 = r * step, (r + 1) * step + x0, x1 = c * step, (c + 1) * step + cell = warped_bgr[y0:y1, x0:x1].copy() + cells.append((r, c, cell)) + return cells +``` + +Each cell undergoes light preprocessing before inference: +* Conversion to grayscale, +* Cropping of a small margin to suppress grid lines, +* Adaptive thresholding and morphological cleanup to isolate printed digits, +* Resizing to the model’s input size (28×28), +* Normalization to match the training distribution. + +```Python +def preprocess_cell(self, cell_bgr: np.ndarray): + """ + Produces a 28x28 float32 tensor in the same normalization as training: + grayscale -> [0,1] -> normalize to [-1,1] via (x-0.5)/0.5 + Also tries to suppress grid lines / borders by cropping margins. + """ + g = cv.cvtColor(cell_bgr, cv.COLOR_BGR2GRAY) + + # Crop a margin to remove grid lines/borders + h, w = g.shape + m = int(0.12 * min(h, w)) # ~12% margin + g = g[m:h - m, m:w - m] + + # Binarize & clean (helps isolate printed digits) + g_blur = cv.GaussianBlur(g, (3, 3), 0) + bw = cv.adaptiveThreshold(g_blur, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY_INV, 21, 5) + + # Remove small specks + bw = cv.morphologyEx(bw, cv.MORPH_OPEN, np.ones((2, 2), np.uint8), iterations=1) + + # If almost empty => likely blank + if (bw > 0).sum() < 15: + # Return a near-empty input; classifier should produce blank + resized = cv.resize(g, (self.input_size, self.input_size), interpolation=cv.INTER_AREA) + else: + # Use bw mask to focus on digit; keep as grayscale for the model + resized = cv.resize(g, (self.input_size, self.input_size), interpolation=cv.INTER_AREA) + + x = resized.astype(np.float32) / 255.0 + x = (x - 0.5) / 0.5 # [-1,1] + x = x[None, None, :, :] # [1,1,H,W] + return x +``` + +Cells with very little foreground content are treated as blank candidates, reducing false digit detections in empty cells. + +## Batched ONNX inference +All 81 cell tensors are stacked into a single batch and passed to ONNX Runtime in one call. Because the model was exported with a dynamic batch dimension, this batched inference is efficient and mirrors how the model will be used in production. + +The output logits are converted to probabilities, and the most likely class is selected for each cell. Optionally, a confidence threshold can be applied so that low-confidence predictions are treated as blanks. + +The result is a 9×9 board where: +* 0 represents a blank cell, +* 1–9 represent recognized digits. + +```Python +def recognize_board(self, cells): + """ + Runs batched ONNX inference on 81 cells and returns: + board[9][9] with 0 for blank + conf[9][9] with max softmax probability + """ + xs = [] + coords = [] + for r, c, cell in cells: + coords.append((r, c)) + xs.append(self.preprocess_cell(cell)) + + X = np.concatenate(xs, axis=0).astype(np.float32) # [81,1,28,28] + logits = self.sess.run([self.output_name], {self.input_name: X})[0] # [81,10] + probs = softmax(logits, axis=1) + pred = probs.argmax(axis=1) + conf = probs.max(axis=1) + + board = [[0 for _ in range(9)] for _ in range(9)] + conf_grid = [[0.0 for _ in range(9)] for _ in range(9)] + for i, (r, c) in enumerate(coords): + p = int(pred[i]) + cf = float(conf[i]) + + # Optional safety: low-confidence => blank + if cf < self.blank_conf_threshold: + p = self.blank_class + + board[r][c] = p + conf_grid[r][c] = cf + + return board, conf_grid +``` + +## Solving the Sudoku +With the recognized board constructed, we apply a classic backtracking Sudoku solver. This solver deterministically fills empty cells while respecting Sudoku constraints (row, column, and 3×3 block rules). + +If the solver succeeds, we obtain a complete solution. If it fails, the failure usually indicates one or more recognition errors, which can be diagnosed using the intermediate visual outputs. + +```Python +def solve_sudoku(board): + pos = find_empty(board) + if pos is None: + return True + r, c = pos + for v in range(1, 10): + if valid(board, r, c, v): + board[r][c] = v + if solve_sudoku(board): + return True + board[r][c] = 0 + return False + + +def find_empty(board): + for r in range(9): + for c in range(9): + if board[r][c] == 0: + return (r, c) + return None + + +def valid(board, r, c, v): + # row + for j in range(9): + if board[r][j] == v: + return False + # col + for i in range(9): + if board[i][c] == v: + return False + # box + br, bc = 3 * (r // 3), 3 * (c // 3) + for i in range(br, br + 3): + for j in range(bc, bc + 3): + if board[i][j] == v: + return False + return True +``` + +## Visualization and outputs +To aid debugging and demonstration, the processor produces several visual artifacts: +1. The rectified (warped) Sudoku grid, +2. A clean rendering of the recognized board, +3. A clean rendering of the solved board, +4. An overlay of the solved digits on top of the original image. + +These outputs make it easy to understand how each stage behaves and are particularly useful when testing on real camera images. + + +## Running the processor +A small driver script (05_RunSudokuProcessor.py) demonstrates how to use the SudokuProcessor: +```Python +import os +import cv2 as cv + +from sudoku_processor import SudokuProcessor + +def print_board(board, title="Board"): + print("\n" + title) + for r in range(9): + row = "" + for c in range(9): + v = board[r][c] + row += (". " if v == 0 else f"{v} ") + if c % 3 == 2 and c != 8: + row += "| " + print(row.strip()) + if r % 3 == 2 and r != 8: + print("-" * 21) + + +def main(): + # Use any image path you like: + # - a real photo + # - a synthetic grid from Step 3A, e.g. data/grids/val/000001_cam.png + img_path = "data/grids/val/000001_cam.png" + onnx_path = os.path.join("artifacts", "sudoku_digitnet.onnx") + + bgr = cv.imread(img_path) + if bgr is None: + raise RuntimeError(f"Could not read image: {img_path}") + + proc = SudokuProcessor(onnx_path=onnx_path, warp_size=450, blank_conf_threshold=0.65) + + board, solved, dbg, overlay = proc.process_image(bgr, overlay=True) + + print_board(board, "Recognized board") + if solved is None: + print("\nSolver failed (board might contain recognition errors).") + else: + print_board(solved, "Solved board") -You performed the following steps: + # Save debug outputs + cv.imwrite("artifacts/warped.png", dbg["warped"]) + if overlay is not None: + cv.imwrite("artifacts/overlay_solution.png", overlay) + print("\nSaved: artifacts/overlay_solution.png") + print("Saved: artifacts/warped.png") -* Integrated the OpenCV library into your Android project. +if __name__ == "__main__": + main() +``` -* Enabled camera permissions to ensure the application can access the device's camera. +You simply provide the path to a Sudoku image and the ONNX model, and the script saves all intermediate and final results to the artifacts/ directory. -* Set up `JavaCameraView` to capture real-time frames from the camera. You declared and initialized Mat objects to store and process camera frames. +Representational result is shown below: -* Implemented adaptive thresholding using OpenCV's `Imgproc.adaptiveThreshold` to process the camera frames when a checkbox is checked. +![img2](Figures/02.png) -By following these steps, you have successfully created an Android application that captures real-time images from the camera. +## Summary +By completing this section, you have built a full vision-to-solution Sudoku system: +1. A trained and validated ONNX digit recognizer, +2. A robust OpenCV-based image processing pipeline, +3. A deterministic solver, +4. Clear visual diagnostics at every stage. +In the next step of the learning path, we will focus on optimization and deployment. \ No newline at end of file diff --git a/content/learning-paths/cross-platform/onnx/figures/01.png b/content/learning-paths/cross-platform/onnx/figures/01.png new file mode 100644 index 0000000000000000000000000000000000000000..c32ae10bba12edcc10f094f696bb632432ae2687 GIT binary patch literal 56481 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%0D8`vM*)yFaE)#o(HnC8+_S|v6J{gLoCsXZ{x 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 z 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𝔗Yi~x7Ry#{>}(M4ONz3aIa`^7+u1W24S(C1473m=#cRzM=p1Gr8^ zrHy~~>>#RE{NAtVXmEGCui6ZT4+5+A1Y%r8hL|IU1@Q2KQeR2!PrV4m6>Uh3@77&!UeL1!Th?klzMtv8rogGqo4RePC55 z_Sgy&;Xp+HszXyRahRsRDL%&NAXJVTCg`7uv^)Xvb6_=&#NZ;nuwId=)A6*TpFiEf zlN&o+3{T6%dTw_1@msc2U2oqCqJYh}%Eb3zzAuR55&04%GizKPah+F=uvV{BwP89o zaKM-%O;@0o-;)*PlWRgLb+|S|J84b22F*-OH%xpT zE(T%@{_*1n0_@QNKDNGaXQ%AZ%Fe$rK}QQCm1BlS`V&G!ZB?3wL5@Jgr1&a3I|x(~ ziA!K(NF%w$bQGS;G8vG$kwoNw9_2Vojgfz+H`A;{pcs!*_`7dNDYOxh5!WCIEQK~y zDa`Lv6nn4u*IV@h6+uox0qJ8ykC$&i9M&MpYXIaD3F`q13DH2n5sXL~elG3rS!+KU z%(!)!3iN2jCE=xRY`G5sLltGnb7x`94ILHm0^DE~Z-&u_q(XKkZ+G#$Hql_Sm_Adz zDcz8tnU%E#i@6ivYNcR#+X7cgfa&ds{>UR7wtxSkM)fu^oJ__mAseV9gGzIz6S z(Zj^|22gFkL&jEv(nGPtYB(B(mm>g~K)f6Yb@;L3+=CTnfyay7vS*c%OVdA@(-lJb;ig*B^dA?0}cJLAFePq*$AW_ zq8mf@q}oH!0OHIu`n% zc$Ph@Gq{3p+*o8T&(!ccu6{wQ))YC4+163}XlU3+&IwQ0s+wH2b-Ko`?H#J9^VbRT zi>Yq1f*UtguNm54rI>N?r#=JR%Gli1NVk(#?R)xuQ$HH-a_&Ue@9kbL9iNSQDs!bS z4?YZTcwxpjskS-CiG26(k0oMJb+1Urt$n_DLK~0k)th4fr>CBdE+{(oJiHe;H=Mu{ zf1b%}gvbMpEOb@1OgdiLGA}&GPmg|oxjJ}|i({SEu6$VGj6UO@5`$Y7Nq*ILxj896 z)E3#d57tzctc#bndnEEwzLgd$OuUM~z$-}EQ*Dz<*~}*0cCnY;z!kTuj!|NWosY6T z|CTyrDkX#|mVGI2S!g5H^};8Pahvqh)ftTz(xKlLrHh@8E5GhvSG+nIWU_Bv^WpM2 z{L$h;D>_o_RZv#=fbjBRi6!`Z0y)e45&!X$=SDe_4Hq|RSukx5o-{-z{8-DQ#>{7wWcUX)10PB=3XSbTwUVYGi~rp4^*fWQ$}n4~1HaM_ENTXQvjw9Hgji`viLJ&F8yF?_A>_e2|sL z9;mQ^kHV@z#*ifT-PSzRz#;jw+On1nN0A!$M|)+Nl>Y2(1OE0veY)1DwwA>&FDj~{ zIsB$4Y`119ozw$&B^hf1#`~7bUXmsJbhzUaaaZX3DH2X}`UE^aY=8C03b~f!EnkJH zN~Vl8rf#Z}RCmt4nfL!e@1XFE!)A46ct+kxXDLlcvpn>no0qK0M}tRB``mE5%2`Kl z=j->SQ(W1IlQV1_%;xe4Aia($^=#?fr`Vfao?1^2nGDzkAR zrf=nA>`nDgoebT>@dVvbN>uEo7Q1$^BBwg;lS|yVoNoIuhPC)pZcUwZ zr1hFsmadXc{n;R*jBVj zjWr9F%#UB=z_=4hG_!C`v2UqZ_}n+5ed0UE8nXqLN0oCpI~Q!Zs5C^ql^A{`Nl|2r zobI+Z=vz`!)^ADL&RGb1e`JM?@7`nLFmhGJ+g7^9(3@J&>-m`8&+GQFS3Q2`P;pf;YiQ(85}u0?AM<#b zLrN%@>g%!awBxb;@9dHpXCb*fOXKol#_M~T8Mnlo3Zv+=+!|hR_C}06EoVWmvDk`H z!x-0L ziN;5vYCkj5Y+7nNHhoVsaileI<4r$Szec71iwv9+;v1cGwNaPi(x$#vkWd{en`ZrmVAQsT3oQ7aYEO1e&$m^A9%)CY4)(rmlyPbcM1;i03d zh>;y%v1h*bqR~^2e6IWESG9aY6_hr5d_Z*7!KZ+6bxq|;aA#%H4W`ENKrxfQtPi1wmQ|C6i4 zb(3n%>$IFhYA49I8{NXbjxW@%ucmxF-j;#)si4yRROA#bhoiw+bGy~JpDrOAsj7O_ zyf1UcTjr1JxA%7IMl2C7&0kfI%36LqF1Nfsk^NdAFKb-vXVNrAcjb7~xUKY>%hZk~ z@m`cVaptX+oeI{Es~av6EKHpdq}?R*^0x$Mn!ocl;q%aBN=@C}$YpGekbJXxF) zbFt+S*G?`+E6e-vZaRo>kODlQ?}Pw!K#52XMMPp@Mml2kwF3tjzXb^l=_usyMET*o zeC3VHGSGCb^AoAP!aQ+2DmOE%SNfkcTQBre*8V?l?$^tdH%tqBB-H$xiG@@f-6o49)CP5;mWz#dP@Q#@$2_5Uuh@1P zcHG*Zm0grVj(l|G*BL)s?$@zGUub7YcbQt1AWMQLZ>6k^ukXZtDF>F4E`>cLT9Q1&`sZcbzA06`#4qTfi7_Y+1jH67A;iQZpNu3_Lz?eQyWgy0l%T%Q z$Cb>Shjah9hQO68`sDfjPyO95q17cLWA)2=)#gY)ROs3 zfGon5KR=;ig8H%|o31;WAlDBX$H?l|#mo?YM<#p6Rm-@j?Q>T*cC%aesMvy$r|0fk z+e^xf>W#auZs*;Fub*nW`?uG@#4vb!W&c4WO$rujLPq7Q@~MDykGdiPKwik(p=jV)|lB@vQo` zw7}QC{*wGJ-Z97I?_iO2?_#PL7tT_}cjisXIqNEaW7Z#dq~$IIH?a?+eWeWQWp27S zA53?16yin82XiPg2iszv$uPgxs-210Hyqg0?-tloDZ9d7$vn*FNnxe&@iw>a=^Cli zsP^xKBvi&M7V1iySNY*RH~JItxL-RH4i5tssH5|ZkoUSrFlxA_C>;9$EcKm}YHS*?K=8cyKL~myIGF0d% z!&%^uZ>w&iCtcgsPxkqpQkOJ+**9J0Y~^gG$E^Fc{>5!{8@Np_+Eq&|pTbU8Y2+z8 zyokfUG#)&ptx3#WKOex@wANVdW2!~(T&_xa*QGWlczm+UEye51sVYwbOWoj#*XhICh z3+qNwizk25qouWexRd4M%Y@R`ur@Rtg%4X|%l@!QkX3)_g85Z-KDEiZ0D440T>q4m zH+}!D+&I|w@?`5PJAcACg%0K20GkP#&_@#f&t`+q;$ied)3@`ZO|(i`*eBe9IKe+Q zS`!U&h}@1}J2&Kb?oFU3;mxk$xmFsY=R14vXPlRx-AeHtl$UhtC)80ab`#9tbfXrs zd9&C}cDiqoo^+dbX_tTS@eleU;gmwRd+4SPZs|Cl`SNpna|_Pw)N;yVsPKG^;`OQ! zZ5q|wRq(g-;^tnA-1lE(hUK`Fr6<|d-~Be5E7Qnhyh>8qgXV_!FbBl&-_k5TzVI)8 zm0l}Tyzu1KMj4@OAf?02Y|hWj1H-Y;Y8L&M)^@!mjdG3~>2lzG3>&T#Jk6TAm`<#| zfq}I$%Fx;i@$Zc!yPqEk77CnJn4vX*?kjVem|ty?kSKP)aj;)c{nP3lYsw@%EmG`x zWV~IXWMRbc>Gz2(Gin|NdPy~RF{>3*@VFcDgBikOJic8JVK(3;!*1{}5wC<8N$~=- zWl9DvfgV6O5?@MGEcj-@AnqSAvC?mZ(JdSxR}C7xTe;9dd_nDRNTA%cFp;jlh@X7Sf{-;W3rI{lEP>cU9}Rr|Jo74XtDie3ikHK6Su2V zWZsoxD{SLFfBeNnb>Iu_`i|Krp3XT}`%Q=1F^#VTZk%)~o{AySYqHlj$!F5UWwjQ} z^Zp=?zG?qVB&a!IFRPD(@CX;aKq|)SHiR;*U%kGv-`McGEwwZnF ziYuq#RhttQ$EYXhV!RhC81YgBqWy0xbGBbg*f6?)5m|U44+T%JN7v`;(za2JDite( z?0u=!=qc|Ow+y@C0l{D<|QeYz;yOIb7uGQQENlkA^O6p5^rGma4rulg#qVFSnQ zg$R#^xt@|`P4R7pAb(O>R~_ZJSe^(=Kaza-6G=wd3W4XLEMaorQyeveIc!&FD#h>l zZxNK9w6c8iz{lOM#_O{n3qYM9SHlKmVE$34zeC=1Alj z&#&KxGFY0wWQ1X!E)uQGFDy6J_J+dWxOM$PE~nEQ>0WCTB{E?X>vJ3}9UUooFQU7J za&jHIsYooh>Bye59O@f(xI*F?S65fx0_z;*?LzUOAk0%hDpRGiF9S)z;{hEpLs zK^Z{`We^kBysZtcK z{I8ww17UgmLss8^uJjxgF@*!44x_d_zw%cR>Q_OXC=Xln0!UD9Q^x*PFsJ=3p-5_0 zZ26Dci__S?-=cXkZ)ckG{FVV6zDsDQWMJF>{MVrujJGNfse_VS#xRXP&R&cNB7j(l zwWJ=Tl=Le%lPnshi6cc8&u?wQuM0&+`Yi)LliB5p>VMLONXAsNFvYictRE)xboTq;VV3=+yjO20FXL7kGt8r zEn`Y7o~nU;0ki|dfp_((4$5BhZ`-6W2FCRjU1rb0w&a;W(Ie&)JebR<)@rt&MuEN1 z>=PxPaJN8Is@|n9<_;!WEX%3Iq$V{&)5fQBicBAPPlq_T{v;cPpiDYFh@+M`Jk|%N zv>YRBQQUjYigkcOQ}Mabdz%qmw3d5#k42YiIl^Nqac1I4UEgj$o1%KK!zZ}JJwm}# zCU!B-nt4x&d#7!`%{yQwWH8s_o5t7pO}dvAWFIjc3pbWOgsbgVFR$Oa&X}QVMNhLW z>AtA<5yMGUWoy4*V^8B;e=ynOxKcHm<4_)d4sxsB-rgZ#!6I-Tq{PahU2Fq)R2j@_ z08=t?ibnYuE3Ce9%Blj}oX?}h=&Z$n1*Z1G8J2Wl?5~~nKdRly z;YyX>NBIF#5E|oV_wQVPoLdK_tBR23RUX=Hw(mc1ji7Y3zPWbza-ZHcTF;SEi6x*` zjh)^WP#M)flOHm;`fQ<{j?4AfKvih?iH*Xtb*Z3*nTp5=2kOz<_LEJGGxvWGE3TtGS4Dqj0~CH>+YP>Ilp&(zwi3} z_qLX`&N^$`p8f3m`P`q+bzg(<%kZ`#p6^bqwe0~_Ly{63=8iXsCa&q4qB?d+i`f$> zQOiyUfMLU$mKr0%bpen_^L1VCI_V(C9XDh44A7g>4=Z1Mvt#LCOxEszRZ*kkR(&tH zRSL^GK1?WndnuM=#&FEpPdm=vwDf@GgD%<+xoyWSTLKd&ynIE16NZ$OHM8yy(wRL> zxXL@{@2XVakbHBpf3?6Z;r5dg!H0?`77Of13Qf|LI_4P{q2c`QtKAuc>M| z2jW~%!0`QM*yrV2gI#AiBm z;r;SQyyhm9WmcT=*56ojmVx5ZZ9o@Zx!2u7-RwG71#f0;^v0j(LMbKTGAyHvbUQeG z#_t|YQTtb)7(J79U5}sVs+d`o^gi)tOV6A>S#VdgErDfbaQVRFG8Ie3w<-@cRs?PW zaP`22eJ;Aa_>bmJRVwMg>WEs(bxe0Xcuk*oQuC0zeT4r?vi64&yMy9~yS zMg4{iGovQ&-}pu&?NXU|pbk1?H{zl4;Mg=nd#RY;ir~9SvQ9O3i zcC6g~$I^RmSe11j{Wqv?U`uJMDCeZ0(vpv{5kSJK=B_&)wS01e&YkisisAay!L?%V zbq*yn(@IwKZqPm^?HJxWsQ9!=B|XZ{kV!siXq9Wr(;VL(_FV+lD{{YnWHjm4YjcIT z&s1f(E8~6Q>Apirnya#(=6rY-`|w9gwWfc9?z`OGueR9LHaRFQdhkgl<01<;AOBSz z4`T_=OGd?}bkEzkn!@GpKQ;H7({VO9rJ1|=VPc-`7XEw_r=eR`8yVP*J|xGwEaz1f z)U-R+ylwM`N<&F{l{5QiwFjCqrk@wXD49Zh*ot+G8#6=ALcrI`G^7svRIeU(@F$j4FAaTP%#Od0C%c zzw*Q0GvluFeXjPf8ODKX47ARjrZCplN5m{eMJ1x)V@XR(i+=Oi*jRBvhpbEq$DFhD zmqB((o4D(X7OtNC=v3&yA7G(omMd*+SH>n($M-s9rTeR`gN$+_p8U6bu06Ry&tKu( z8#USW#`Rv?;9>vnUaL5L4vmL=4;@?TwyKA>Z7^IVd-jcT9o?094x1&x1CsHPs9A`8E~;m|LsmNG2Fh=@a046fw`NuhC}iC-QRkXt_ywdGMz9o zq#zDab*p-g&U(YnT_$ptzrpicw~RVcm{WkCohi!y(r29M&te$szq}k~!Db zM|@AjREp-^UI|EwP0@$wQm2>pC@goVb)voOsJ$Nm2ZQf=yYnh^uREhB^{vc>qpKqe zj%YrgKBjHOEayhOZoGrvk!@(5v7^n(&1@px&CCZC8k{fPv3?Qwtg|$bkL>PWqGxwF zIM>%EHx~~aoc)6`uYDz8ZpO~_#ttQsW-oI*q)mI>YlB~FpNQ)&7~fn(x^2M(F3cav z-y!*oWZr$&0*WS&tS7OtmQeDI!Im|?)RDnAgHXttt*oqewy0PiODS8e^pSs3T!k># zq^vZGn(w~SdRV5iigWD{>v6FyQgtEmo-=#mcbNar$8-Hqw8(_!>$3XtwykV6)WC)w z&D^k)deTE@tL7eRT(Q6XFg9=|Nkl3Fm{aV{Jl||po>VQV-41dSyO)_57-+94cG8u% zw&}C(9H-8tOfD0OqUuuHYjhHM6{xwFg@^xd{LH_3$9HArZ|yZbQ3WAelQ#@+H_`Mg zaxc)HjA`$-nS20c=Hrm#^r2VdzinNZ_!>FBCZ|lZ?9*Ir9FtSqr=6bGyC#D36xXa< zw~nyi3G00p{-r$yh^=&hD;sh5d-m*^WR>z^(bM~$-B0y>Fx}M|PuHNpGg^{q8DPKf z*~W)Aavmk!V}C$@fMfOLDOx`nyB2%l!l4lfo7h{$_di6Y+g9|J{6jTeyv_0IsnsnC z@13qBQ|CJr@zF|h&d)EFKqD&sdU4&&_<}F24Y%p|x2Q(~_X;!E`#_$n`N zLFIQC=KOTbP~2RVkMZW6X96Er&57B|TRNva)RDJf3ZIMiA6$1hzPU|q&&H~nXgdO{ zRgAg(M@)^~rcL@cq?T0Mm$xZt?#AN~uapEnvq$~wXZ9P-(bh#4cI;WX>rq(&v+h^< z+XX?=9~ZXR*U3f>jkd=c1UEOFvSbak+1}rs|*^-m5x7aF6GWN*~OkQ)iIUgY#8@O1Ir}UM3b%O5F zP%e-2Mt^}_J^Aacndr8vI>V(8drCSF) z?ws5S*rw-*&)o)dv(N37<14mS)xUTkgF_|SAK%U?&+x0|U&PrdaG(!VJ6qvN&IO@2 z?sWaV^2Kt3*Z|mne7l{o`sk1J*}UAl@9PEbXQo!?c#2_!(Cb%e4_omXJ29CYXeznq$Ayl;~)4Ij_ zr7_n4?E`J~D&Id+lnHfIeZt~Yu(|D&BOj0JP4CyQ&R>v|Ry2=a$uSBi$L~$X$q?ko z!JpxvMF#~=8IO~a?!qRb?>?RTFMNRW=?3r)LiXt`!(ogrMj2uhnWT}s578|yFj0+S znPmK>)Y+&S*DtV6_WUE7&Q-)Z_RamBwjNu4y~l@(e<^bMdD6u^Beu;1H?01XBC7ru zeT?%TCCNHA_Y??y6qLpP6MPc?sq+5`Ht|S7k@6n^9Z(X*Y^B~A{u>iX-y zBCqkYiLwONq%l$dep$uknAq4`7`}sH+_0LRU4g{KkCts{1U+4T({m8;h_RZtHv`Np zD=I2FJPyrn@nB>(nkl4e|Ao+4vvAdoYMDOH%nTw{vK|~)J>R@J21m>jP(?W4MuQyr z2aJWdof7>0SCex<5{`ou8Qen%SFeH781a`2M5bDcfyiGlREaIg>Q>9K-pP8wf(GY> z-LPWkhR={Ll6#PUW7X|*AZjFqd_yEphu`L_3Nh`+$(fRnNkide!Gbf4*UEfd#vj?f z?Rop~PaF!|N-2=2o1~nb#fd{M#r`WCiG6*U%x7wRT}s}^NQWMBmDsJCBsP>na#3&y zH#+SkHaA{tFQ&y4{vGD5_x$~T#RcJpHEo*^i2P0N{I7ISU&jPujeBxO2`G5T#PMlh zfpb5z>V?C5*?J=F+AfE8P%Zw(yAt7uzg$vNQ!}l3LvwwidVNf}m<%?MBPUr=;e651Xb zJ#EaTLSV(+yT-eJM78zhh8pHM?N9;K$Pc57&8(9bF_Eu}em>QoK6 zgcbCnC%ZlP#9vK6XCB;n=+GuNxUqtD4F>_D4tm2L5&T;qa5&ptJX>zs_U1y6D0}0a zgJHs(%22t*MU3g@?GnvxxubWgZ(oS%H;D)%zw(*!UDa=y%Y&BJq1l_L1q*ZLxzfUa zl1UF}IVZ)(FM`ZDM%wrDAE5gEqVSmnMny47!l94c27!J1M1I|dKjGvCBNQG=!ugE& z#zCJ!B-IVR*FAXc_g95ztbmY^qb@EIFmSq@>I{2(3US6R7ypD~M2qYTJm+3Ks4VXL z_Vp{_^CC9EY0y~9IG}-Q{rh`zlGtR|a)pkP)$ZarC2`0NY1-c4^zxgv2p_q-ah=%$ zOpps9ot;J+!>TI@-~w9$B0sIAMK#T8J+gTvz4=VPlIt?=ri2Bd6UqfVI~~qJkjVmcl_9~h8&ySm}yKc6G)c1E=beF-GNx* zAyml&e$=TKi4%U9=vAr&YjP6 zSBotEr`Q1n{`DpOTdVjF!2FK{@gE-OZ%HFoS~jk1=+&eq45p4+TMNQBy$jaHmnMf= zZ9P7j0oka8!J>MsV&pNT0KMQ@UX?n)_`LOus_Gc*1FUKl4)6o2didxONaDI!2*mtc zDHoIU#fF!Qfur7xC@WKzRg;H>I2N{!#?*|2acqGTfQ>9brMq}$y zn}p_Y)BL>I&^LJaq=}Z;s)B;9Vb@BsXAmF}gHw>6&!0yFqGwCMc_>9SYx#Q6eD*51 z=!1+I8vm7IYTf(Plh74O>MYg!Ut}8NQHQlLX9@6wjPt#sl&M!g`8H%S%6)Y=aEz0EhEzaOzF(rp{G^ zseuP_m`%6h&6}9|4NaZGy0QWICt^m%I_Gqry2OJ&=%=5U*e#XtEO z_{-^00>Z+KW?c$a_}N6@kzH3v&d`?Zh2Ng7M_p2x&jtfZnr=B`u5`ZzxQ%;TbL|eK zq@?r$j5ADiMtGHwj9xOx_2raUIA3tBUDn9182)``E*4+XlD#Bjgfr8$DZLUQ#nqHv z+^Y1QMH8paoY6b2th_=S&q{@MtY2HFyZt8vVvDKGZ*X^Pz8XA$Hy9>Ih zAtfn*)WQ93aOJzXqQ-{jDFeMaSrm&y;^KBFtEw8<3A6L=-d#n}M-OD{@xcr?R^jZ~ zAT-nb*nVr>UIgSKt!;%iNm|I2K4^+B1D6AVc6Mt_dN!OlHx$C_DXwww(9~-t25r!9 z+iff^4Su`Hs!89+&ah-_=EwT_a2(LAE5tlo7E3QHLf0zYAioFw7Sticw#Rc7j-?kq zW#!WrhMVU%*2LUiL4*{N8XD|Ro;(qfs~rW9Ns)-A_8x7bE@l#wJbajj97h&SAL~<5 zRxT!5%nKJbB5%#TwKIYxK0dxEYnfA@XnV@RuuN8FW*e!Q?cCg1R@>N(Kfej2z+;Ie zc=vauv&r>U5C+hMy;6{oQH&@bqC9p64#+|h<%qT*Sv@PMSZDPwvBru5$y}Rn`c{JM z(Gm) z>O0K4k@?&4(2JK7p^sRf!EmZRt*%}L1a3%^TK} zNo!6ZAvgbKJ0mj75AA>@$Y4!udd<(VPdaCnwcbD9VtRo%6`MjE( zlvgiaydWP%Y<{Ynaw1Hy|3jYGwq z@@HCy{UHs37{f8QIOSJtif29694q+pO!)CtSe20szb~5iBwmrV<|q8)Dg~%w#pIEZ zv(GfVa3WUVEFI1Ng4%cXX>La_LKMF+`tpclPRElo-cbGEXi;h;ZvDr^}nkZ^3pszq*e86eT0BhH~G#$QHLF*DkvE_#I+nMKQehJ?hx(u+sCj=)V7eTW@^i>V)=fj)P{T2NDn9O#-Y$IeOFGM34Cp+Akh%b5o z7^o*sFn~VULjssczzqd{kB9c}-#@XWkx?pUCFPo=8?i4YiA~s8_U+qe-{U9u@@xF_ zk(oI$w7u9Y_;C*v_Oe|9(GYHms8PA0;*LUnk#-!;GZT6!W7uL-O`C=E--f(?8!7quns`{>p@quE86Af&cMJx9<|gP$%t&}lzYC>(KW_1Vxu#i&1oNM zPkd66nXO}Y-YnEZ_=ZJ3A(g-^nUFd6vTsl5mrRwhJ7bZG(yO3T!1xPT_rZf6zK=-ECG=sGuEfv2Ai{p zV*_@?cSOVH&=)C(Qi48VcADziOF}>)Gb4%|TaTt#o~o{os#@EjM*Iu241iz`^`L_I z-yv@OTF@~6TE8`q9O@ zCA8O$;EZp-`Kuo+B>xb9^7)EYnbCM|u&#@ZlV6o}m3jed+=35G8Wy~m*$qU*@JDM8 zrd^h7kl(Mk;sUl9(urd{Y$6}hFyegLYU^eyZ|RrHb;X+YtAjt}dPMt(P6i z9GS9OMO}SE+b7|p)_2Ng2G$P;51m-QX*+7Uw1$R8z|Du~IqBaI6vq4tHlv_(GxC~z zYq!LQ^~#zxYr>%zYn#d*Ho-Khs$s*7pEEKuxKx@V)_j?sDo~*mjo__|PR~C&x_zLC zB!bd(+}WM;?wJDoWg{Ps^U*{)=ImIRG?e^{ zedSZz89DBpkFf_+tF)!%KINy18KN8g1j102?^FBG?hR4a4+$9M8LaGp)7 zWK$Dv0g1p^y2O3eAOw;fW$N;%eWC$=c}owTAX3Wi_=r_4tPIxYC53 z*gj;!!gG$8abf!J^*_!_mdSqHA&SIw&zgDkAxBKq(TI{!V|ig#{*OdP-^5qQb&aWH z@PJn#nfYa9X$e`Ii>oa5i;M`J!n(l{lFG!7NL>~_%@Yt*65SLQzFt)ja&kWOn@O0D z!>UwHOfx1wpTq6cqa!z)0UB`RWBRwVHyP|FiaL@f_kOSJcj$eLZ42*}h+q?Yd^+iBufQD(Qp+RIZpq8bLnKVB zIMH9jbn-K_qR-JrhhtwI#oRLnrD{MxKrx@c%jYD zGhAbTa;fYQ9-0k06+sg!Dl0DnZ6ehT6aSv9mLjnJjqKt~hic?Dea2?E6OdhM9~EV1?i)vUL+$Lj-d{~aVCQ1{M=RC zr2)pY>Q=N5<<%SZ!ut5aInGY)2F@5yZLY5zO7#ucZ$R$$KrB^RyJ#(#dO6R zzr{AHU}BPh*-8M=%(c+{#zCzy8M#eO=W7uhvp57I*CuvF4>CbiqxdRVTBeTLi^ZZV z=|zh#1fj7%ULOvzarFh;Mm@w6S0lZ(7DJZ+*4h~EQX_lV(We*J>7JnTJ^ZI!uSf8G zcHg-_d1Obu{;|LLUyqc(Reyi0ssF_*``6_8ub26qJr~40icDJs`w?B>?4Y@8F`KTj z6RbaqQhAWRHSalru^ifF`2M8qx#FzWUG7_+$^#{|gVapc{e@tX8Oc*6^0|8>HT0?( zoPw>$U+wvWP`>+XpIRZh#1E_Np{y4%76KI}jNF*ajV6$$SM*ov+EF+;4X&%D>C5It ziQ4gM%{0~9BTSXVZjtDv!KDebC=PoGTU=fV%ZHc(9rPibtnb@TgzUXGjMkTuH~;h7 z#FAQXtc87u?18`kAS3yhin;{KaFR!lN$CIp$CRZOL`KlKB3jqhmDt&^b(Lk^Wrc0cyH8e4#U&&ZgcInlQF~$`sg`cIN;7%#@%PJ>$hCM) zb(s)YvSK|!Ljfo)Z_YCBL)q$1%xdexj}Ag7t0(4AOQA0VSAqWj+>h}FAf1DU0e6*)2-&o!Da)z>&C?) zsDTGs0GgVid@*SMg2yHo8mTTUE(LfCzAk5Y%$re2ZIMlP{k&U?-;JuO?lF2S= zOKR3FtwX58)f_Wl=DJZYot*MQMeWQ=GV#{+q&{VtYhg-eHFL!ixI!C-`_&jtiUwyU zhYvuaVJjT{C@UlO2^%0=0|3zPFD+n;rjqg<7^o)|bFw58-PGa`UX7d(w2U{JckkNu zc6;!J)e`1%Gg!Lj6auKE0fez|#L%AI9~+JldLk`acKmXG3kqMuVZzE(ltKfJbBY%G zZXdG4V2T{6d-F&f4=3X3L?4>Mj2`y$T-LxSjIIrVk#*9i(A}KvXWM z(+sHaCD!yb_DToPD~bp44uZet3jEgctVv`VV8rUV(LQ63C^#wDd<0AoQ0RG5&K)4m z2*kM|J2F3Uyhhoi^r#fS+kY9_I;0DO;paHG^=fbBIsY{b`% zg7)|IXQQ9pS))-!HZ6MgbCV<|lD8aFt+bKQ1FvVn(3UUwZ~S zCAdm9m{)^s-z9qVk*2m3Y?{7Ylgx`cJrZG6-b()Lo_tkZ+GX14Kq!|kT@uV4t~rz0 zefh#{Zv)Lh@W&8pO5l6l!29jLV)i7tg!%a$R#R)-S)Pe2%^&qKPygvQ zQ|2fc?iF*8ECH;lPOA_013)P_Ca+Dv=^seXm#J%Bo}Siw$sVj&n6leAlS@P-r*Wd} zvOBAW^{Ma`ZwBf@l)AOEwxVzt&(A3KtzN$wGXKmAz@)*`l@X$c-VKAXXsV2WSTS< zVK!WI<&gfP>(@cwWQ8vcETi?CX|DeGO6zn*f{uy9=` z8NoJ>Nzyo0W=d`@1ZrtnRBm)(N)P1@lQ4&!D1bgW0WP6A^#g?JT{a{igs zV!0f<@~URLp_X-;7PR?sH%wb|G8((*(A{$Zi^?6!@xpYMQ8|&5BSK~toUgnbgf@-V zaJ8en{L(|yl}d`j!Jin|_F^@bq8hNJgd8_D-P1nPHhEXn-Vwk=@$zzt3b1&TwN1JV z=+LEKrmn+@7fF`HPD+Njw7_z7?Ia2#U0xHX5rc&Xq(5-2<4#5ok@azSk$O)$JOyKuOkjxu^n;|1ND0=$;wkh{^aM z8S^oBawnr0kRtzxh_{3}qN%cE{aN8xKuC7*@L=@tfGvy1%vCXtBR=bG?kp6o@cK#e z34y!|m^AF=Ets`T%K5qr!$~>rSp^c9&JVhh$U1Dl0yt?-%I;l{N1l|O?Cfk3Hn?hL z9`2XGE~go>srDtLz0<*Gz2G>Q@#_p7E-VBs2HZGy-wKD#m-$FLXZ-->o0wISGgjzi z&%L_3A2aVobS4molH*H4t(F}Rg&oT#=kZm55BWC;nGg&r7EcrL!GW*T$m6yG>_h}4 zBcKqTroBL>NG>`sVKV2C?z4F2h@9LQMmGU?B@>tci`O2(unn1}>M|z4MY}Pr6{qs_ zzKg6v-c2<@MnJotsxO$ARa8`zVIYn}1wa)^$3}oPbclLQ>6e{Q1*((Y{nVSqfx;y$ zK@u%WHYPZ2SU@O~s#AK0MRk?wI5IUxz~xsycdi0m%QZbUV#Dd5L;gaZjVN9497J$uxn>3Sdv@E6m;;T-lt#ZRWd!^|0pf~ae@5%)bHO` lmj5Ulew#)9e|g!$A)~eSW!qRS%_#UMFRLh%B&B`*{{Z&ee(L}L literal 0 HcmV?d00001 diff --git a/content/learning-paths/cross-platform/onnx/figures/02.png b/content/learning-paths/cross-platform/onnx/figures/02.png new file mode 100644 index 0000000000000000000000000000000000000000..48021bad665380356a6e9420f9d244ee0f9fe5ff GIT binary patch literal 384284 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 z%0D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�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 z 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̮+RA?HyGFu+%{p38j@Qs6P!sDk2%$$YsS5q)oXz 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%0A$%;l&N7S)%) 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 RAeZSo7JL8hq!Z>z#L5eMGY8vih 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 literal 0 HcmV?d00001 From 2172d8d56813c1f301e7625b23b59c2a17aebfae Mon Sep 17 00:00:00 2001 From: Dawid Borycki Date: Mon, 15 Dec 2025 18:30:42 +0100 Subject: [PATCH 06/12] Update 06_SudokuProcessor.md --- .../cross-platform/onnx/06_SudokuProcessor.md | 203 ++---------------- 1 file changed, 14 insertions(+), 189 deletions(-) diff --git a/content/learning-paths/cross-platform/onnx/06_SudokuProcessor.md b/content/learning-paths/cross-platform/onnx/06_SudokuProcessor.md index ff8efb6a93..0263f6b015 100644 --- a/content/learning-paths/cross-platform/onnx/06_SudokuProcessor.md +++ b/content/learning-paths/cross-platform/onnx/06_SudokuProcessor.md @@ -10,6 +10,7 @@ layout: "learningpathall" In this section, we integrate all previous components into a complete Sudoku processing pipeline. Starting from a full Sudoku image, we detect and rectify the grid, split it into individual cells, recognize digits using the ONNX model, and finally solve the puzzle using a deterministic solver. By the end of this step, you will have an end-to-end system that takes a photograph of a Sudoku puzzle and produces a solved board, along with visual outputs for debugging and validation. +## Context So far, we have: 1. Generated a synthetic, well-labeled Sudoku digit dataset, 2. Trained a lightweight CNN (DigitNet) to recognize digits and blanks, @@ -19,9 +20,9 @@ So far, we have: At this point, the digit recognizer is reliable in isolation. The remaining challenge is connecting vision with reasoning: extracting the Sudoku grid from an image, mapping each cell to a digit, and applying a solver. This section bridges that gap. ## Overview of the pipeline -To implement the Sudoku processor, create a new file sudoku_processor.py and modify it as follows: +To implement the Sudoku processor, create the file (sudoku_processor.py) and paste the implementation below: -```Python +```python import cv2 as cv import numpy as np import onnxruntime as ort @@ -70,7 +71,7 @@ class SudokuProcessor: overlay_img = None if overlay and ok: - overlay_img = self.overlay_solution(bgr, H, quad, board, solved) + overlay_img = self.overlay_solution(bgr, H, board, solved) debug = { "warped": warped, @@ -218,7 +219,7 @@ class SudokuProcessor: # ----------------------------- # Overlay # ----------------------------- - def overlay_solution(self, original_bgr, H, quad, board, solved): + def overlay_solution(self, original_bgr, H, board, solved): """ Overlays ONLY the filled-in digits (where original board has 0). """ @@ -340,73 +341,11 @@ The first task is to locate the Sudoku grid in the image. We convert the image t Once the four corners are identified, we compute a perspective transform and warp the grid into a square image. This rectified representation removes camera tilt and perspective distortion, allowing all subsequent steps to assume a fixed geometry. -```Python -def detect_and_warp_board(self, bgr: np.ndarray): - """ - Finds the largest Sudoku-like quadrilateral and warps it to a square. - Returns warped_board, homography, quad_points. - """ - gray = cv.cvtColor(bgr, cv.COLOR_BGR2GRAY) - blur = cv.GaussianBlur(gray, (5, 5), 0) - - # Strong binary image helps contour finding (works well for printed grids) - thr = cv.adaptiveThreshold( - blur, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY_INV, 31, 7 - ) - - # Remove small noise, connect lines a bit - kernel = cv.getStructuringElement(cv.MORPH_RECT, (3, 3)) - thr = cv.morphologyEx(thr, cv.MORPH_CLOSE, kernel, iterations=2) - - contours, _ = cv.findContours(thr, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE) - if not contours: - raise RuntimeError("No contours found. Try a clearer image or different thresholding.") - - # Pick the largest contour that approximates to 4 points - contours = sorted(contours, key=cv.contourArea, reverse=True) - quad = None - for c in contours[:20]: - peri = cv.arcLength(c, True) - approx = cv.approxPolyDP(c, 0.02 * peri, True) - if len(approx) == 4: - quad = approx.reshape(4, 2).astype(np.float32) - break - - if quad is None: - raise RuntimeError("Could not find a 4-corner Sudoku grid. Try a more fronto-parallel image.") - - quad = order_quad_points(quad) - - dst = np.array( - [[0, 0], [self.warp_size - 1, 0], [self.warp_size - 1, self.warp_size - 1], [0, self.warp_size - 1]], - dtype=np.float32, - ) - H = cv.getPerspectiveTransform(quad, dst) - warped = cv.warpPerspective(bgr, H, (self.warp_size, self.warp_size)) - - return warped, H, quad -``` +We order the four corners consistently (top-left → top-right → bottom-right → bottom-left) before computing the perspective transform. ## Splitting the grid into cells After rectification, the grid is divided evenly into a 9×9 array. Each cell is cropped based on its row and column index. At this stage, every cell corresponds to one Sudoku position and is ready for preprocessing and classification. -```Python -def split_cells(self, warped_bgr: np.ndarray): - """ - Splits a rectified square board into 81 cell images. - Returns list of (r, c, cell_bgr). - """ - cells = [] - step = self.warp_size // 9 - for r in range(9): - for c in range(9): - y0, y1 = r * step, (r + 1) * step - x0, x1 = c * step, (c + 1) * step - cell = warped_bgr[y0:y1, x0:x1].copy() - cells.append((r, c, cell)) - return cells -``` - Each cell undergoes light preprocessing before inference: * Conversion to grayscale, * Cropping of a small margin to suppress grid lines, @@ -414,42 +353,7 @@ Each cell undergoes light preprocessing before inference: * Resizing to the model’s input size (28×28), * Normalization to match the training distribution. -```Python -def preprocess_cell(self, cell_bgr: np.ndarray): - """ - Produces a 28x28 float32 tensor in the same normalization as training: - grayscale -> [0,1] -> normalize to [-1,1] via (x-0.5)/0.5 - Also tries to suppress grid lines / borders by cropping margins. - """ - g = cv.cvtColor(cell_bgr, cv.COLOR_BGR2GRAY) - - # Crop a margin to remove grid lines/borders - h, w = g.shape - m = int(0.12 * min(h, w)) # ~12% margin - g = g[m:h - m, m:w - m] - - # Binarize & clean (helps isolate printed digits) - g_blur = cv.GaussianBlur(g, (3, 3), 0) - bw = cv.adaptiveThreshold(g_blur, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY_INV, 21, 5) - - # Remove small specks - bw = cv.morphologyEx(bw, cv.MORPH_OPEN, np.ones((2, 2), np.uint8), iterations=1) - - # If almost empty => likely blank - if (bw > 0).sum() < 15: - # Return a near-empty input; classifier should produce blank - resized = cv.resize(g, (self.input_size, self.input_size), interpolation=cv.INTER_AREA) - else: - # Use bw mask to focus on digit; keep as grayscale for the model - resized = cv.resize(g, (self.input_size, self.input_size), interpolation=cv.INTER_AREA) - - x = resized.astype(np.float32) / 255.0 - x = (x - 0.5) / 0.5 # [-1,1] - x = x[None, None, :, :] # [1,1,H,W] - return x -``` - -Cells with very little foreground content are treated as blank candidates, reducing false digit detections in empty cells. +We crop a margin to suppress grid lines, because grid strokes can dominate the digit pixels and cause systematic misclassification. Cells with very little foreground content are treated as blank candidates, reducing false digit detections in empty cells. ## Batched ONNX inference All 81 cell tensors are stacked into a single batch and passed to ONNX Runtime in one call. Because the model was exported with a dynamic batch dimension, this batched inference is efficient and mirrors how the model will be used in production. @@ -460,100 +364,21 @@ The result is a 9×9 board where: * 0 represents a blank cell, * 1–9 represent recognized digits. -```Python -def recognize_board(self, cells): - """ - Runs batched ONNX inference on 81 cells and returns: - board[9][9] with 0 for blank - conf[9][9] with max softmax probability - """ - xs = [] - coords = [] - for r, c, cell in cells: - coords.append((r, c)) - xs.append(self.preprocess_cell(cell)) - - X = np.concatenate(xs, axis=0).astype(np.float32) # [81,1,28,28] - logits = self.sess.run([self.output_name], {self.input_name: X})[0] # [81,10] - probs = softmax(logits, axis=1) - pred = probs.argmax(axis=1) - conf = probs.max(axis=1) - - board = [[0 for _ in range(9)] for _ in range(9)] - conf_grid = [[0.0 for _ in range(9)] for _ in range(9)] - for i, (r, c) in enumerate(coords): - p = int(pred[i]) - cf = float(conf[i]) - - # Optional safety: low-confidence => blank - if cf < self.blank_conf_threshold: - p = self.blank_class - - board[r][c] = p - conf_grid[r][c] = cf - - return board, conf_grid -``` - ## Solving the Sudoku With the recognized board constructed, we apply a classic backtracking Sudoku solver. This solver deterministically fills empty cells while respecting Sudoku constraints (row, column, and 3×3 block rules). If the solver succeeds, we obtain a complete solution. If it fails, the failure usually indicates one or more recognition errors, which can be diagnosed using the intermediate visual outputs. -```Python -def solve_sudoku(board): - pos = find_empty(board) - if pos is None: - return True - r, c = pos - for v in range(1, 10): - if valid(board, r, c, v): - board[r][c] = v - if solve_sudoku(board): - return True - board[r][c] = 0 - return False - - -def find_empty(board): - for r in range(9): - for c in range(9): - if board[r][c] == 0: - return (r, c) - return None - - -def valid(board, r, c, v): - # row - for j in range(9): - if board[r][j] == v: - return False - # col - for i in range(9): - if board[i][c] == v: - return False - # box - br, bc = 3 * (r // 3), 3 * (c // 3) - for i in range(br, br + 3): - for j in range(bc, bc + 3): - if board[i][j] == v: - return False - return True -``` - ## Visualization and outputs -To aid debugging and demonstration, the processor produces several visual artifacts: -1. The rectified (warped) Sudoku grid, -2. A clean rendering of the recognized board, -3. A clean rendering of the solved board, -4. An overlay of the solved digits on top of the original image. - -These outputs make it easy to understand how each stage behaves and are particularly useful when testing on real camera images. - +The processor saves several artifacts to help debugging and demonstration: +- `artifacts/warped.png` – rectified top-down view of the Sudoku grid. +- `artifacts/overlay_solution.png` – solution digits overlaid onto the original image (if solved). +- (Optional) `artifacts/recognized_board.png`, `artifacts/solved_board.png`, `artifacts/boards_side_by_side.png` – clean board renderings if you enabled those helpers. ## Running the processor A small driver script (05_RunSudokuProcessor.py) demonstrates how to use the SudokuProcessor: -```Python + +```python import os import cv2 as cv @@ -576,7 +401,7 @@ def print_board(board, title="Board"): def main(): # Use any image path you like: # - a real photo - # - a synthetic grid from Step 3A, e.g. data/grids/val/000001_cam.png + # - a synthetic grid, e.g. data/grids/val/000001_cam.png img_path = "data/grids/val/000001_cam.png" onnx_path = os.path.join("artifacts", "sudoku_digitnet.onnx") From bc8c81f72901b84522bc63712d4a8a5ae111c208 Mon Sep 17 00:00:00 2001 From: Dawid Borycki Date: Wed, 17 Dec 2025 14:43:56 +0100 Subject: [PATCH 07/12] Update 07_Optimisation.md --- .../cross-platform/onnx/07_Optimisation.md | 425 +++++++++++++++++- 1 file changed, 412 insertions(+), 13 deletions(-) diff --git a/content/learning-paths/cross-platform/onnx/07_Optimisation.md b/content/learning-paths/cross-platform/onnx/07_Optimisation.md index de7e75b8ae..490108c451 100644 --- a/content/learning-paths/cross-platform/onnx/07_Optimisation.md +++ b/content/learning-paths/cross-platform/onnx/07_Optimisation.md @@ -1,24 +1,423 @@ --- -# User change -title: "Summary" - -weight: 6 - +title: "Model Enhancements and Optimizations" +weight: 8 layout: "learningpathall" --- -## Summary ## -In this Learning Path, you have created an Android application to capture and process camera images using OpenCV. +## Objective +In this section, we improve the Sudoku system from a working prototype into something that is faster, smaller, and more robust on Arm64-class hardware. We start by measuring a baseline, then apply ONNX Runtime optimizations and quantization, and finally address the most common real bottleneck: image preprocessing. At each step we re-check accuracy and solve rate so performance gains don’t come at the cost of correctness. + +## Establish a baseline +Before applying any optimizations, it is essential to understand where time is actually being spent in the Sudoku pipeline. Without this baseline, it is impossible to tell whether an optimization is effective or whether it simply shifts the bottleneck elsewhere. + +In the current system, the total latency of processing a single Sudoku image is composed of four main stages: +* Grid detection and warping – locating the outer Sudoku grid and rectifying it using a perspective transform. This step relies entirely on OpenCV and depends on image resolution, lighting, and grid clarity. +* Cell preprocessing – converting each of the 81 cells into a normalized 28×28 grayscale input for the neural network. This includes cropping margins, thresholding, and morphological operations. In practice, this stage is often the dominant cost. +* ONNX inference – running the digit recognizer on all 81 cells as a single batch. Thanks to dynamic batch support, this step is typically fast compared to preprocessing. +* Solving – applying a backtracking Sudoku solver to the recognized board. This step is usually negligible in runtime, unless recognition errors lead to difficult or contradictory boards. + +To quantify these contributions, we will add simple timing measurements around each stage of the pipeline using a high-resolution clock (time.perf_counter()). For each processed image, we will print a breakdown: +* warp_ms – time spent on grid detection and perspective rectification +* preprocess_ms – total time spent preprocessing all 81 cells +* onnx_ms – time spent running batched ONNX inference +* solve_ms – time spent solving the Sudoku +* total_ms – end-to-end processing time + +## Performance measurements +Open the sudoku_processor.py and add the following import + +```python +import time +``` + +Then, modify the process_image as follows +```python +def process_image(self, bgr: np.ndarray, overlay: bool = True): + """ + Returns: + board (9x9 ints with 0 for blank), + solved_board (9x9 ints, or None if unsolved), + debug dict (warped, homography, confidence, timing), + overlay_bgr (optional solution overlay) + """ + timing = {} + + t_total0 = time.perf_counter() + + # --- Grid detection + warp --- + t0 = time.perf_counter() + warped, H, quad = self.detect_and_warp_board(bgr) + timing["warp_ms"] = (time.perf_counter() - t0) * 1000.0 + + # --- Cell splitting --- + t0 = time.perf_counter() + cells = self.split_cells(warped) + timing["split_ms"] = (time.perf_counter() - t0) * 1000.0 + + # --- Preprocessing (81 cells) --- + t0 = time.perf_counter() + xs = [] + coords = [] + for r, c, cell in cells: + coords.append((r, c)) + xs.append(self.preprocess_cell(cell)) + X = np.concatenate(xs, axis=0).astype(np.float32) # [81,1,28,28] + timing["preprocess_ms"] = (time.perf_counter() - t0) * 1000.0 + + # --- ONNX inference --- + t0 = time.perf_counter() + logits = self.sess.run([self.output_name], {self.input_name: X})[0] + timing["onnx_ms"] = (time.perf_counter() - t0) * 1000.0 + + # --- Postprocess predictions --- + probs = softmax(logits, axis=1) + pred = probs.argmax(axis=1) + conf = probs.max(axis=1) + + board = [[0 for _ in range(9)] for _ in range(9)] + conf_grid = [[0.0 for _ in range(9)] for _ in range(9)] + for i, (r, c) in enumerate(coords): + p = int(pred[i]) + cf = float(conf[i]) + if cf < self.blank_conf_threshold: + p = self.blank_class + board[r][c] = p + conf_grid[r][c] = cf + + # --- Solve --- + t0 = time.perf_counter() + solved = [row[:] for row in board] + ok = solve_sudoku(solved) + timing["solve_ms"] = (time.perf_counter() - t0) * 1000.0 + + # --- Overlay (optional) --- + overlay_img = None + if overlay and ok: + t0 = time.perf_counter() + overlay_img = self.overlay_solution(bgr, H, board, solved) + timing["overlay_ms"] = (time.perf_counter() - t0) * 1000.0 + else: + timing["overlay_ms"] = 0.0 + + timing["total_ms"] = (time.perf_counter() - t_total0) * 1000.0 + + debug = { + "warped": warped, + "homography": H, + "quad": quad, + "confidence": conf_grid, + "timing": timing, + } + + return board, (solved if ok else None), debug, overlay_img +``` + +Finally, print the timings in the 05_RunSudokuProcessor.py: +```python +def main(): + # Use any image path you like: + # - a real photo + # - a synthetic grid, e.g. data/grids/val/000001_cam.png + img_path = "data/grids/val/000002_cam.png" + onnx_path = os.path.join("artifacts", "sudoku_digitnet.onnx") + + bgr = cv.imread(img_path) + if bgr is None: + raise RuntimeError(f"Could not read image: {img_path}") + + proc = SudokuProcessor(onnx_path=onnx_path, warp_size=450, blank_conf_threshold=0.65) + + board, solved, dbg, overlay = proc.process_image(bgr, overlay=True) + + print_board(board, "Recognized board") + if solved is None: + print("\nSolver failed (board might contain recognition errors).") + else: + print_board(solved, "Solved board") + + # Save debug outputs + cv.imwrite("artifacts/warped.png", dbg["warped"]) + if overlay is not None: + cv.imwrite("artifacts/overlay_solution.png", overlay) + print("\nSaved: artifacts/overlay_solution.png") + print("Saved: artifacts/warped.png") + + tim = dbg["timing"] + print( + f"warp={tim['warp_ms']:.1f} ms | " + f"preprocess={tim['preprocess_ms']:.1f} ms | " + f"onnx={tim['onnx_ms']:.1f} ms | " + f"solve={tim['solve_ms']:.1f} ms | " + f"total={tim['total_ms']:.1f} ms" + ) + +if __name__ == "__main__": + main() +``` + +The sample output will look as follows: +```output +python3 05_RunSudokuProcessor.py + +Recognized board +. . . | 7 . . | 6 . . +. . 4 | . . . | 1 . 9 +. . . | 1 5 . | . . . +--------------------- +. . . | . 1 . | . . . +. . . | . . . | . . . +3 . . | . . . | . 6 . +--------------------- +7 . . | . . . | . . . +. . 9 | . . . | . . . +. . . | . . . | . . . + +Solved board +1 2 3 | 7 4 9 | 6 5 8 +5 6 4 | 2 3 8 | 1 7 9 +8 9 7 | 1 5 6 | 2 3 4 +--------------------- +2 4 5 | 6 1 3 | 8 9 7 +9 1 6 | 4 8 7 | 3 2 5 +3 7 8 | 5 9 2 | 4 6 1 +--------------------- +7 3 1 | 8 2 5 | 9 4 6 +4 5 9 | 3 6 1 | 7 8 2 +6 8 2 | 9 7 4 | 5 1 3 + +Saved: artifacts/overlay_solution.png +Saved: artifacts/warped.png +warp=11.9 ms | preprocess=3.3 ms | onnx=1.9 ms | solve=3.1 ms | total=48.2 ms +``` + +## Folder benchmark +The single-image measurements introduced earlier are useful for understanding the rough structure of the pipeline and for verifying that ONNX inference is not the main computational bottleneck. In our case, batched ONNX inference typically takes less than 2 ms, while grid detection, warping, and preprocessing dominate the runtime. However, individual measurements can be noisy due to caching effects, operating system scheduling, and Python overhead. + +To obtain more reliable performance numbers, we extend the evaluation to multiple images and compute aggregated statistics. This allows us to track not only average performance, but also variability and tail latency, which are particularly important for interactive applications. + +To do this, we add two helper functions to 05_RunSudokuProcessor.py. + +The first function, summarize, computes basic statistics from a list of timing measurements: +* mean – average runtime +* median – robust central tendency +* p90 / p95 – tail latency (90th and 95th percentiles), which indicate how bad the slow cases are + +```python +def summarize(values): + values = np.asarray(values, dtype=np.float64) + return { + "mean": float(values.mean()), + "median": float(np.median(values)), + "p90": float(np.percentile(values, 90)), + "p95": float(np.percentile(values, 95)), + } +``` + +The second function, benchmark_folder, runs the full Sudoku pipeline on a collection of images and aggregates timing results across multiple runs: + +```python +def benchmark_folder(proc, folder_glob, limit=100, warmup=10, overlay=False): + paths = sorted(glob.glob(folder_glob)) + if not paths: + raise RuntimeError(f"No images matched: {folder_glob}") + paths = paths[:limit] + + # Warmup + for p in paths[:min(warmup, len(paths))]: + bgr = cv.imread(p) + if bgr is None: + continue + proc.process_image(bgr, overlay=overlay) + + # Benchmark + agg = {k: [] for k in ["warp_ms", "preprocess_ms", "onnx_ms", "solve_ms", "total_ms"]} + solved_cnt = 0 + total_cnt = 0 + + for p in paths: + bgr = cv.imread(p) + if bgr is None: + continue + + board, solved, dbg, _ = proc.process_image(bgr, overlay=overlay) + tim = dbg["timing"] + + for k in agg: + agg[k].append(tim[k]) + + total_cnt += 1 + if solved is not None: + solved_cnt += 1 + + print(f"\nSolved {solved_cnt}/{total_cnt} ({(solved_cnt/total_cnt*100.0 if total_cnt else 0):.1f}%)") + + print("\nTiming summary (ms):") + for k in ["warp_ms", "preprocess_ms", "onnx_ms", "solve_ms", "total_ms"]: + s = summarize(agg[k]) + print(f"{k:14s} mean={s['mean']:.2f} median={s['median']:.2f} p90={s['p90']:.2f} p95={s['p95']:.2f}") +``` + +Finally, we invoke the benchmark in the main() function: + +```python +def main(): + onnx_path = os.path.join("artifacts", "sudoku_digitnet.onnx") + + proc = SudokuProcessor(onnx_path=onnx_path, warp_size=450, blank_conf_threshold=0.65) + + benchmark_folder(proc, "data/grids/val/*_cam.png", limit=30, warmup=10, overlay=False) + +if __name__ == "__main__": + main() +``` + +This evaluates the processor on a representative subset of camera-like validation grids, prints aggregated timing statistics, and reports the overall solve rate. + +Aggregated benchmarks provide a much more accurate picture than single measurements, especially when individual stages take only a few milliseconds. By reporting median and tail latencies, you can see whether occasional slow cases exist and whether an optimization truly improves user-perceived performance. Percentiles are particularly useful when a few slow cases exist (e.g., harder solves), because they reveal tail latency. These results form a solid quantitative baseline that you can reuse to evaluate every optimization that follows. + +Here is the sample output of the updated script: +```output +python3 05_RunSudokuProcessor.py + +Solved 30/30 (100.0%) + +Timing summary (ms): +warp_ms mean=10.25 median=10.27 p90=10.57 p95=10.59 +preprocess_ms mean=3.01 median=2.98 p90=3.16 p95=3.21 +onnx_ms mean=1.27 median=1.24 p90=1.30 p95=1.45 +solve_ms mean=74.76 median=2.02 p90=48.51 p95=74.82 +total_ms mean=89.41 median=16.97 p90=62.95 p95=89.43 +``` + +Notice that solve_ms (and therefore total_ms) has a much larger mean than median. This indicates a small number of outliers where the solver takes significantly longer. In practice, this occurs when one or more digits are misrecognized, forcing the backtracking solver to explore many branches before finding a solution (or failing). For interactive applications, median and p95 latency are more informative than the mean, as they better reflect typical user experience. + +## ONNX Runtime session optimizations +Now that you can measure onnx_ms and total_ms, the first low-effort improvement is to enable ONNX Runtime’s built-in graph optimizations and tune CPU threading. These changes do not modify the model, but can reduce inference overhead and improve throughput. + +In sudoku_processor.py, update the ONNX Runtime session initialization in __init__ to use SessionOptions: +```python +so = ort.SessionOptions() +so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL + +self.sess = ort.InferenceSession(onnx_path, sess_options=so, providers=list(providers)) +``` + +Re-run 05_RunSudokuProcessor.py and compare onnx_ms and total_ms to the baseline. + +```output +python3 05_RunSudokuProcessor.py + +Solved 30/30 (100.0%) + +Timing summary (ms): +warp_ms mean=10.43 median=10.36 p90=10.89 p95=10.96 +preprocess_ms mean=3.13 median=3.11 p90=3.34 p95=3.42 +onnx_ms mean=1.28 median=1.26 p90=1.37 p95=1.47 +solve_ms mean=78.61 median=2.01 p90=50.15 p95=77.87 +total_ms mean=93.58 median=17.06 p90=65.10 p95=92.55 +``` + +This result is expected for such a small model: ONNX inference is already efficient, and the dominant costs lie in image preprocessing and occasional solver backtracking. This highlights why system-level profiling is essential before focusing on model-level optimizations. + +## Quantize the model (FP32 -> INT8) +Quantization is one of the most impactful optimizations for Arm64 and mobile deployments because it reduces both model size and compute cost. The simplest approach is dynamic quantization, which requires no calibration dataset and is quick to apply. + +Create a small script 06_QuantizeModel.py: + +```python +import os, glob +import numpy as np +import cv2 as cv + +from onnxruntime.quantization import ( + quantize_static, CalibrationDataReader, QuantFormat, QuantType +) + +ARTI_DIR = "artifacts" +FP32_PATH = os.path.join(ARTI_DIR, "sudoku_digitnet.onnx") +INT8_PATH = os.path.join(ARTI_DIR, "sudoku_digitnet.int8.onnx") + +# ---- Calibration data reader ---- +class SudokuCalibReader(CalibrationDataReader): + def __init__(self, folder_glob="data/train/0/*.png", limit=500, input_name="input", input_size=28): + self.input_name = input_name + self.input_size = input_size + + paths = sorted(glob.glob(folder_glob))[:limit] + self._iter = iter(paths) + + def get_next(self): + try: + p = next(self._iter) + except StopIteration: + return None + + g = cv.imread(p, cv.IMREAD_GRAYSCALE) + if g is None: + return self.get_next() + + g = cv.resize(g, (self.input_size, self.input_size), interpolation=cv.INTER_AREA) + x = g.astype(np.float32) / 255.0 + x = (x - 0.5) / 0.5 + x = x[None, None, :, :] # [1,1,28,28] + return {self.input_name: x} + +# ---- Run quantization ---- +reader = SudokuCalibReader(folder_glob="data/train/*/*.png", limit=1000) + +print("Quantizing (QDQ static INT8)...") +quantize_static( + model_input=FP32_PATH, + model_output=INT8_PATH, + calibration_data_reader=reader, + quant_format=QuantFormat.QDQ, # key: keep Conv as Conv with Q/DQ wrappers + activation_type=QuantType.QInt8, + weight_type=QuantType.QInt8, + per_channel=True # usually helps conv accuracy +) + +print("Saved:", INT8_PATH) +``` + +Run python 06_QuantizeModel.py + +Then update the runner script to point to the quantized model: + +```python +onnx_path = os.path.join("artifacts", "sudoku_digitnet.int8.onnx") +``` + +Re-run the processor and compare: +* onnx_ms (should improve or remain similar) +* total_ms +* solve success (should remain stable) + +Also compare file sizes: +```console +ls -lh artifacts/sudoku_digitnet.onnx artifacts/sudoku_digitnet.int8.onnx +``` +Even when inference time changes only modestly, size reduction is typically significant and matters for Android packaging. -You performed the following steps: +In this pipeline, quantization primarily reduces model size and improves deployability, while runtime speedups may be modest because inference is already a small fraction of the total latency. -* Integrated the OpenCV library into your Android project. +## Preprocessing-focused optimizations (highest impact) +The measurements above show that ONNX inference accounts for only a small fraction of the total runtime. In practice, the largest performance gains come from optimizing image preprocessing. -* Enabled camera permissions to ensure the application can access the device's camera. +The most effective improvements include: +- Converting the rectified board to grayscale **once**, instead of converting each cell independently. +- Adding an early “blank cell” check to skip expensive thresholding and morphology for empty cells. +- Using simpler thresholding (e.g., Otsu) on clean images, and reserving adaptive thresholding for difficult lighting conditions. +- Reducing or conditionally disabling morphological operations when cells already appear clean. -* Set up `JavaCameraView` to capture real-time frames from the camera. You declared and initialized Mat objects to store and process camera frames. +These changes typically reduce `preprocess_ms` more than any model-level optimization, and therefore have the greatest impact on end-to-end latency. -* Implemented adaptive thresholding using OpenCV's `Imgproc.adaptiveThreshold` to process the camera frames when a checkbox is checked. +## Summary +In this section, we transformed the Sudoku solver from a functional prototype into a system with measurable, well-understood performance characteristics. By instrumenting the pipeline with fine-grained timing, we identified where computation is actually spent and established a quantitative baseline. -By following these steps, you have successfully created an Android application that captures real-time images from the camera. +We showed that: +- Batched ONNX inference is already efficient (≈1–2 ms per board). +- Image preprocessing dominates runtime and offers the largest optimization potential. +- Solver backtracking introduces rare but significant tail-latency outliers. +- ONNX Runtime optimizations and INT8 quantization improve deployability, even when raw inference speed gains are modest. +Most importantly, we demonstrated a systematic optimization workflow: **measure first, optimize second, and always re-validate correctness**. With performance, robustness, and accuracy validated, the Sudoku pipeline is now ready for its final step—deployment as a fully on-device Android application. \ No newline at end of file From 8c81816ddf76e84160881a9ea3247900bb99bdb2 Mon Sep 17 00:00:00 2001 From: Dawid Borycki Date: Sun, 21 Dec 2025 17:13:04 +0100 Subject: [PATCH 08/12] ONNX --- .../cross-platform/onnx/08_Android.md | 24 - .../cross-platform/onnx/_index.md | 67 -- .../onnx/01_Fundamentals.md | 0 .../onnx/02_Setup.md | 2 +- .../onnx/03_PreparingData.md | 0 .../onnx/04_Training.md | 0 .../onnx/05_Inference.md | 0 .../onnx/06_SudokuProcessor.md | 2 +- .../onnx/07_Optimisation.md | 0 .../onnx/08_Android.md | 1055 +++++++++++++++++ .../onnx/Figures}/01.png | Bin .../onnx/Figures}/02.png | Bin .../onnx/Figures/03.png | Bin 0 -> 435827 bytes .../onnx/Figures/04.png | Bin 0 -> 535274 bytes .../onnx/Figures/05.png | Bin 0 -> 49659 bytes .../onnx/Figures/06.png | Bin 0 -> 266016 bytes .../onnx/Figures/07.png | Bin 0 -> 304059 bytes .../mobile-graphics-and-gaming/onnx/_index.md | 67 ++ .../onnx/_next-steps.md | 0 19 files changed, 1124 insertions(+), 93 deletions(-) delete mode 100644 content/learning-paths/cross-platform/onnx/08_Android.md delete mode 100644 content/learning-paths/cross-platform/onnx/_index.md rename content/learning-paths/{cross-platform => mobile-graphics-and-gaming}/onnx/01_Fundamentals.md (100%) rename content/learning-paths/{cross-platform => mobile-graphics-and-gaming}/onnx/02_Setup.md (97%) rename content/learning-paths/{cross-platform => mobile-graphics-and-gaming}/onnx/03_PreparingData.md (100%) rename content/learning-paths/{cross-platform => mobile-graphics-and-gaming}/onnx/04_Training.md (100%) rename content/learning-paths/{cross-platform => mobile-graphics-and-gaming}/onnx/05_Inference.md (100%) rename content/learning-paths/{cross-platform => mobile-graphics-and-gaming}/onnx/06_SudokuProcessor.md (99%) rename content/learning-paths/{cross-platform => mobile-graphics-and-gaming}/onnx/07_Optimisation.md (100%) create mode 100644 content/learning-paths/mobile-graphics-and-gaming/onnx/08_Android.md rename content/learning-paths/{cross-platform/onnx/figures => mobile-graphics-and-gaming/onnx/Figures}/01.png (100%) rename content/learning-paths/{cross-platform/onnx/figures => mobile-graphics-and-gaming/onnx/Figures}/02.png (100%) create mode 100644 content/learning-paths/mobile-graphics-and-gaming/onnx/Figures/03.png create mode 100644 content/learning-paths/mobile-graphics-and-gaming/onnx/Figures/04.png create mode 100644 content/learning-paths/mobile-graphics-and-gaming/onnx/Figures/05.png create mode 100644 content/learning-paths/mobile-graphics-and-gaming/onnx/Figures/06.png create mode 100644 content/learning-paths/mobile-graphics-and-gaming/onnx/Figures/07.png create mode 100644 content/learning-paths/mobile-graphics-and-gaming/onnx/_index.md rename content/learning-paths/{cross-platform => mobile-graphics-and-gaming}/onnx/_next-steps.md (100%) diff --git a/content/learning-paths/cross-platform/onnx/08_Android.md b/content/learning-paths/cross-platform/onnx/08_Android.md deleted file mode 100644 index de7e75b8ae..0000000000 --- a/content/learning-paths/cross-platform/onnx/08_Android.md +++ /dev/null @@ -1,24 +0,0 @@ ---- -# User change -title: "Summary" - -weight: 6 - -layout: "learningpathall" ---- -## Summary ## - -In this Learning Path, you have created an Android application to capture and process camera images using OpenCV. - -You performed the following steps: - -* Integrated the OpenCV library into your Android project. - -* Enabled camera permissions to ensure the application can access the device's camera. - -* Set up `JavaCameraView` to capture real-time frames from the camera. You declared and initialized Mat objects to store and process camera frames. - -* Implemented adaptive thresholding using OpenCV's `Imgproc.adaptiveThreshold` to process the camera frames when a checkbox is checked. - -By following these steps, you have successfully created an Android application that captures real-time images from the camera. - diff --git a/content/learning-paths/cross-platform/onnx/_index.md b/content/learning-paths/cross-platform/onnx/_index.md deleted file mode 100644 index 7d29c9852c..0000000000 --- a/content/learning-paths/cross-platform/onnx/_index.md +++ /dev/null @@ -1,67 +0,0 @@ ---- -title: ONNX in Action. Building, Optimizing, and Deploying Models on Arm64 and Mobile - -minutes_to_complete: 120 - -who_is_this_for: This is an introductory topic for developers who are interested in creating, optimizing, and deploying machine learning models with ONNX. It is especially useful for those targeting Arm64-based devices (such as Raspberry Pi, mobile SoCs, or Android smartphones) and looking to run efficient inference at the edge. - -learning_objectives: - - Describe what ONNX is, and what it can offer in the ML ecosystem. - - Build and export a simple neural network model in Python to ONNX format. - - Perform inference and training using ONNX Runtime on Arm64. - - Apply optimization techniques such as layer fusion to improve performance. - - Deploy an optimized ONNX model inside an Android app. - -prerequisites: - - A development machine with Python 3.10+ installed. - - Basic familiarity with PyTorch or TensorFlow. - - An Arm64 device (e.g., Raspberry Pi or Android smartphone). - - [Android Studio](https://developer.android.com/studio) installed for deployment testing. - -author: Dawid Borycki - -### Tags -skilllevels: Introductory -subjects: Machine Learning, Edge AI -armips: - - Cortex-A - - Neoverse -operatingsystems: - - Windows - - Linux - - macOS -tools_software_languages: - - Python - - PyTorch - - TensorFlow - - ONNX - - ONNX Runtime - - Android - - Android Studio - - Kotlin - - Java - -further_reading: - - resource: - title: ONNX - link: https://onnx.ai - type: documentation - - resource: - title: ONNX Runtime - link: https://onnxruntime.ai - type: documentation - - resource: - title: Getting Started with ONNX Runtime on Mobile - link: https://onnxruntime.ai/docs/tutorials/mobile - type: tutorial - - resource: - title: Optimizing Models with ONNX Runtime - link: https://onnxruntime.ai/docs/performance/model-optimizations.html - type: documentation - -### FIXED, DO NOT MODIFY -# ================================================================================ -weight: 1 # _index.md always has weight of 1 to order correctly -layout: "learningpathall" # All files under learning paths have this same wrapper -learning_path_main_page: "yes" # This should be surfaced when looking for related content. Only set for _index.md of learning path content. ---- diff --git a/content/learning-paths/cross-platform/onnx/01_Fundamentals.md b/content/learning-paths/mobile-graphics-and-gaming/onnx/01_Fundamentals.md similarity index 100% rename from content/learning-paths/cross-platform/onnx/01_Fundamentals.md rename to content/learning-paths/mobile-graphics-and-gaming/onnx/01_Fundamentals.md diff --git a/content/learning-paths/cross-platform/onnx/02_Setup.md b/content/learning-paths/mobile-graphics-and-gaming/onnx/02_Setup.md similarity index 97% rename from content/learning-paths/cross-platform/onnx/02_Setup.md rename to content/learning-paths/mobile-graphics-and-gaming/onnx/02_Setup.md index 7838803efe..fe9179c87c 100644 --- a/content/learning-paths/cross-platform/onnx/02_Setup.md +++ b/content/learning-paths/mobile-graphics-and-gaming/onnx/02_Setup.md @@ -8,7 +8,7 @@ layout: "learningpathall" --- ## Objective -This step gets you ready to build, export, run, and optimize ONNX models on Arm64. You’ll set up Python, install ONNX & ONNX Runtime, confirm hardware-backed execution providers, and—optionally—prepare multi-arch Docker builds or source builds for advanced acceleration. +This step gets you ready to build, export, run, and optimize ONNX models on Arm64. You’ll set up Python, install ONNX & ONNX Runtime, confirm hardware-backed execution providers. ## Choosing the hardware You can choose a variety of hardware, including: diff --git a/content/learning-paths/cross-platform/onnx/03_PreparingData.md b/content/learning-paths/mobile-graphics-and-gaming/onnx/03_PreparingData.md similarity index 100% rename from content/learning-paths/cross-platform/onnx/03_PreparingData.md rename to content/learning-paths/mobile-graphics-and-gaming/onnx/03_PreparingData.md diff --git a/content/learning-paths/cross-platform/onnx/04_Training.md b/content/learning-paths/mobile-graphics-and-gaming/onnx/04_Training.md similarity index 100% rename from content/learning-paths/cross-platform/onnx/04_Training.md rename to content/learning-paths/mobile-graphics-and-gaming/onnx/04_Training.md diff --git a/content/learning-paths/cross-platform/onnx/05_Inference.md b/content/learning-paths/mobile-graphics-and-gaming/onnx/05_Inference.md similarity index 100% rename from content/learning-paths/cross-platform/onnx/05_Inference.md rename to content/learning-paths/mobile-graphics-and-gaming/onnx/05_Inference.md diff --git a/content/learning-paths/cross-platform/onnx/06_SudokuProcessor.md b/content/learning-paths/mobile-graphics-and-gaming/onnx/06_SudokuProcessor.md similarity index 99% rename from content/learning-paths/cross-platform/onnx/06_SudokuProcessor.md rename to content/learning-paths/mobile-graphics-and-gaming/onnx/06_SudokuProcessor.md index 0263f6b015..e30a24c664 100644 --- a/content/learning-paths/cross-platform/onnx/06_SudokuProcessor.md +++ b/content/learning-paths/mobile-graphics-and-gaming/onnx/06_SudokuProcessor.md @@ -1,6 +1,6 @@ --- # User change -title: "Sudoku Processor: From Image to Solution" +title: "Sudoku Processor. From Image to Solution" weight: 7 layout: "learningpathall" diff --git a/content/learning-paths/cross-platform/onnx/07_Optimisation.md b/content/learning-paths/mobile-graphics-and-gaming/onnx/07_Optimisation.md similarity index 100% rename from content/learning-paths/cross-platform/onnx/07_Optimisation.md rename to content/learning-paths/mobile-graphics-and-gaming/onnx/07_Optimisation.md diff --git a/content/learning-paths/mobile-graphics-and-gaming/onnx/08_Android.md b/content/learning-paths/mobile-graphics-and-gaming/onnx/08_Android.md new file mode 100644 index 0000000000..9076ed5fba --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/onnx/08_Android.md @@ -0,0 +1,1055 @@ +--- +# User change +title: "Android Deployment. From Model to App" + +weight: 9 + +layout: "learningpathall" +--- + +## Objective ## +In this section, we transition from a desktop prototype to a fully on-device Android application. The goal is to demonstrate how the optimized Sudoku pipeline—image preprocessing, ONNX inference, and deterministic solving—can be packaged and executed entirely on a mobile device, without relying on any cloud services. + +Rather than starting with a live camera feed, we begin with a fixed input bitmap that was generated earlier in the learning path. This approach allows us to focus on correctness, performance, and integration details before introducing additional complexity such as camera permissions, real-time capture, and varying lighting conditions. By keeping the input controlled, we can verify that the Android implementation faithfully reproduces the behavior observed in Python. + +Over the course of this section, we will: +1. Create a new Android project and add the required dependencies. +2. Bundle the trained ONNX model and a sample Sudoku image with the application. +3. Implement a minimal user interface that loads the image and triggers the solver. +4. Re-implement the Sudoku processing pipeline on Android, including preprocessing, batched ONNX inference, and solving. +5. Display the solved result as an image, confirming that the entire pipeline runs locally on the device. + +By the end of this section, you will have a working Android app that takes a Sudoku image, runs neural network inference and solving on-device, and displays the solution. This completes the learning path by showing how a trained and optimized ONNX model can be deployed in a real mobile application, closing the loop from data generation and training to practical, end-user deployment. + +## Project creation +We start by creating a new Android project using Android Studio. This project will host the Sudoku solver application and serve as the foundation for integrating ONNX Runtime and OpenCV. + +1. Create a new project: +* Open Android Studio and click New Project. +* In the Templates screen, select Phone and Tablet, then choose Empty Views Activity. +![img3](Figures/03.png) + +This template creates a minimal Android application without additional UI components, which is ideal for a focused, step-by-step integration. + +* Click Next to proceed to the project configuration screen. + +2. Configure the project. In the configuration screen, fill in the fields as follows: +* Name: SudokuSolverOnnx. This is the application name that will appear in Android Studio and on the device. +* Package name: com.arm.sudokusolveronnx. This package name clearly reflects the purpose of the app and its use of ONNX on Arm platforms. +* Save location. Choose a convenient directory on your system (for example, your repositories folder). +* Language: Kotlin. Kotlin is the recommended language for modern Android development and integrates cleanly with ONNX Runtime APIs. +* Minimum SDK: API 24 (Android 7.0 – Nougat). This provides wide device coverage while remaining compatible with ONNX Runtime and OpenCV. +* Build configuration language: Kotlin DSL (build.gradle.kts). We use the Kotlin DSL for Gradle, which is now the recommended option. + +![img4](Figures/04.png) + +* After confirming these settings, click Finish. Android Studio will create the project and generate a basic MainActivity along with the necessary Gradle files. + +## View +We now define the user interface of the Android application. The goal of this view is to remain intentionally simple while clearly exposing the end-to-end Sudoku workflow. The interface will consist of: +* A button row at the top that allows the user to load a Sudoku image and trigger the solver. +* A status text area used to display short messages (for example, whether an image has been loaded or the puzzle has been solved). +* An input image view that displays the selected Sudoku bitmap. +* An output image view that displays the solved result. + +This layout is sufficient to validate that the ONNX model, preprocessing pipeline, and solver are all working correctly on Android before adding more advanced features such as camera input or animations. + +To define the view, open the file res/layout/activity_main.xml and replace its contents with the following layout definition: +```xml + + + + + + + + + +