pretrained gguf FC model from python works

Author: michalharakal

MNISTDemo/.claude/settings.local.json

@@ -0,0 +1,16 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(./gradlew :cli:compileKotlin:*)",
+      "Bash(./gradlew :cli:test:*)",
+      "Bash(./gradlew :cli:run:*)",
+      "Bash(python3:*)",
+      "Bash(./gradlew :shared:jvmTest:*)",
+      "Bash(uv venv:*)",
+      "Bash(uv pip install:*)",
+      "Bash(source:*)",
+      "Bash(ls:*)",
+      "Bash(./gradlew:*)"
+    ]
+  }
+}

MNISTDemo/cli/build.gradle.kts

@@ -0,0 +1,37 @@
+plugins {
+    alias(libs.plugins.kotlinJvm)
+    application
+}
+
+kotlin {
+    jvmToolchain(21)
+}
+
+dependencies {
+    implementation(project(":shared"))
+    implementation(libs.kotlinx.coroutines)
+    implementation(libs.kotlinx.io.core)
+
+    // JVM-optimized SKaiNET backend for inference
+    implementation(libs.skainet.backend.cpu.jvm)
+
+    // Testing
+    testImplementation(kotlin("test"))
+    testImplementation(libs.kotlinx.coroutines.test)
+
+    // SKaiNET dependencies for tests that need direct access to Module
+    testImplementation(libs.skainet.lang.core)
+    testImplementation(libs.skainet.io.gguf)
+}
+
+application {
+    mainClass.set("sk.ainet.cli.MainKt")
+}
+
+tasks.named<JavaExec>("run") {
+    standardInput = System.`in`
+}
+
+tasks.withType<Test> {
+    maxHeapSize = "4g"
+}

MNISTDemo/cli/src/main/kotlin/sk/ainet/cli/ArgsParser.kt

@@ -0,0 +1,68 @@
+package sk.ainet.cli
+
+/**
+ * CLI argument parser for MNIST classifier.
+ */
+object ArgsParser {
+
+    /**
+     * Parses command line arguments into a CliConfig.
+     */
+    fun parse(args: Array<String>): CliConfig {
+        var model = "mlp"
+        var weightsDir: String? = null
+        var modelFile: String? = null
+        var imagePath: String? = null
+        var invert = false
+        var debug = false
+        var help = false
+
+        var i = 0
+        while (i < args.size) {
+            when (args[i]) {
+                "--model" -> {
+                    i++
+                    if (i < args.size) {
+                        model = args[i]
+                    }
+                }
+                "--weights-dir" -> {
+                    i++
+                    if (i < args.size) {
+                        weightsDir = args[i]
+                    }
+                }
+                "--model-file" -> {
+                    i++
+                    if (i < args.size) {
+                        modelFile = args[i]
+                    }
+                }
+                "--invert" -> invert = true
+                "--debug" -> debug = true
+                "--help", "-h" -> help = true
+                else -> {
+                    if (!args[i].startsWith("-")) {
+                        imagePath = args[i]
+                    }
+                }
+            }
+            i++
+        }
+
+        return CliConfig(model, weightsDir, modelFile, imagePath, invert, debug, help)
+    }
+}
+
+/**
+ * Configuration parsed from CLI arguments.
+ */
+data class CliConfig(
+    val model: String = "mlp",
+    val weightsDir: String? = null,
+    val modelFile: String? = null,
+    val imagePath: String? = null,
+    val invert: Boolean = false,
+    val debug: Boolean = false,
+    val help: Boolean = false,
+)

MNISTDemo/cli/src/main/kotlin/sk/ainet/cli/Main.kt

@@ -0,0 +1,160 @@
+package sk.ainet.cli
+
+import sk.ainet.clean.domain.port.InferenceModule
+import sk.ainet.clean.framework.inference.CnnInferenceModuleAdapter
+import sk.ainet.clean.framework.inference.MlpInferenceModuleAdapter
+import sk.ainet.cli.io.ImageLoader
+import java.io.File
+import kotlin.system.exitProcess
+
+/**
+ * CLI application for MNIST digit classification.
+ *
+ * Usage: mnist-cli [options] <image-path>
+ *
+ * Options:
+ *   --model <mlp|cnn>       Model type to use for classification (default: mlp)
+ *   --model-file <file>     Path to model weights file (.gguf)
+ *   --weights-dir <dir>     Directory containing model weights (alternative to --model-file)
+ *   --invert                Invert image colors (use for black-on-white images)
+ *   --debug                 Print debug information including image preview
+ *   --help                  Show this help message
+ */
+fun main(args: Array<String>) {
+    val config = ArgsParser.parse(args)
+
+    if (config.help) {
+        printHelp()
+        exitProcess(0)
+    }
+
+    if (config.imagePath == null) {
+        System.err.println("Error: Image path is required")
+        printHelp()
+        exitProcess(1)
+    }
+
+    val imageFile = File(config.imagePath)
+    if (!imageFile.exists()) {
+        System.err.println("Error: Image file not found: ${config.imagePath}")
+        exitProcess(1)
+    }
+
+    // Determine model type
+    val modelType = when (config.model.lowercase()) {
+        "mlp" -> ModelType.MLP
+        "cnn" -> ModelType.CNN
+        else -> {
+            System.err.println("Error: Unknown model type '${config.model}'. Use 'mlp' or 'cnn'.")
+            exitProcess(1)
+        }
+    }
+
+    // Determine model weights source
+    val modelWeights: ByteArray = when {
+        config.modelFile != null -> {
+            val modelFile = File(config.modelFile)
+            if (!modelFile.exists()) {
+                System.err.println("Error: Model file not found: ${config.modelFile}")
+                exitProcess(1)
+            }
+            modelFile.readBytes()
+        }
+        config.weightsDir != null -> {
+            val weightsDir = File(config.weightsDir)
+            if (!weightsDir.exists()) {
+                System.err.println("Error: Weights directory not found: ${config.weightsDir}")
+                exitProcess(1)
+            }
+            val modelFileName = when (modelType) {
+                ModelType.MLP -> "files/mnist_mlp.gguf"
+                ModelType.CNN -> "files/mnist_cnn.gguf"
+            }
+            val modelFile = File(weightsDir, modelFileName)
+            if (!modelFile.exists()) {
+                System.err.println("Error: Model file not found: ${modelFile.absolutePath}")
+                exitProcess(1)
+            }
+            modelFile.readBytes()
+        }
+        else -> {
+            System.err.println("Error: Either --model-file or --weights-dir is required")
+            printHelp()
+            exitProcess(1)
+        }
+    }
+
+    classify(imageFile, modelType, modelWeights, config.invert, config.debug)
+}
+
+private enum class ModelType { MLP, CNN }
+
+private fun classify(
+    imageFile: File,
+    modelType: ModelType,
+    modelWeights: ByteArray,
+    invert: Boolean,
+    debug: Boolean,
+) {
+    // Create inference module based on model type
+    val inferenceModule: InferenceModule = when (modelType) {
+        ModelType.MLP -> MlpInferenceModuleAdapter.create()
+        ModelType.CNN -> CnnInferenceModuleAdapter.create()
+    }
+
+    if (debug) {
+        println("Loading model: ${modelType.name.lowercase()}")
+    }
+
+    // Load weights directly into inference module
+    inferenceModule.load(modelWeights)
+
+    if (debug) {
+        println("Model loaded successfully (${modelWeights.size} bytes)")
+    }
+
+    // Load and convert image
+    val image = ImageLoader.load(imageFile, invert)
+
+    if (debug) {
+        println("Image loaded: ${imageFile.absolutePath}")
+        println("Image preview:")
+        image.debugPrintInConsoleOutput()
+    }
+
+    // Classify
+    val digit = inferenceModule.infer(image)
+
+    println(digit)
+}
+
+private fun printHelp() {
+    println("""
+        MNIST Digit Classifier CLI
+
+        Usage: mnist-cli [options] <image-path>
+
+        Arguments:
+          <image-path>            Path to the image file (PNG, JPG, etc.)
+
+        Options:
+          --model <mlp|cnn>       Model type to use for classification (default: mlp)
+          --model-file <file>     Path to model weights file (.gguf)
+          --weights-dir <dir>     Directory containing model weights (alternative to --model-file)
+                                  Expects files: files/mnist_mlp.gguf or files/mnist_cnn.gguf
+          --invert                Invert image colors (use for black-on-white images,
+                                  as MNIST expects white digit on black background)
+          --debug                 Print debug information including image preview
+          --help, -h              Show this help message
+
+        Examples:
+          # Using explicit model file
+          mnist-cli --model mlp --model-file ./mnist_mlp.gguf digit.png
+
+          # Using weights directory
+          mnist-cli --model cnn --weights-dir ./models digit.png
+
+          # With debug output
+          mnist-cli --debug --model-file ./model.gguf test_image.png
+    """.trimIndent())
+}

MNISTDemo/cli/src/main/kotlin/sk/ainet/cli/io/FileResourceReader.kt

@@ -0,0 +1,20 @@
+package sk.ainet.cli.io
+
+import sk.ainet.clean.data.io.ResourceReader
+import java.io.File
+
+/**
+ * File-system based ResourceReader for CLI application.
+ * Reads model weights from a specified base directory.
+ */
+class FileResourceReader(private val baseDir: File) : ResourceReader {
+
+    override suspend fun read(path: String): ByteArray? {
+        val file = File(baseDir, path)
+        return if (file.exists() && file.isFile) {
+            file.readBytes()
+        } else {
+            null
+        }
+    }
+}

MNISTDemo/cli/src/main/kotlin/sk/ainet/cli/io/ImageLoader.kt

@@ -0,0 +1,68 @@
+package sk.ainet.cli.io
+
+import sk.ainet.clean.data.image.GrayScale28To28Image
+import java.awt.Color
+import java.awt.RenderingHints
+import java.awt.image.BufferedImage
+import java.io.File
+import javax.imageio.ImageIO
+
+/**
+ * Loads and converts images to GrayScale28To28Image format for MNIST classification.
+ */
+object ImageLoader {
+
+    /**
+     * Loads an image from file and converts it to a 28x28 grayscale image.
+     *
+     * @param file The image file (PNG, JPG, etc.)
+     * @param invert If true, inverts colors (useful for white-on-black MNIST style images)
+     * @return A 28x28 grayscale image ready for classification
+     */
+    fun load(file: File, invert: Boolean = false): GrayScale28To28Image {
+        require(file.exists()) { "Image file does not exist: ${file.absolutePath}" }
+
+        val originalImage = ImageIO.read(file)
+            ?: throw IllegalArgumentException("Cannot read image file: ${file.absolutePath}")
+
+        return convertToGrayscale28x28(originalImage, invert)
+    }
+
+    /**
+     * Converts a BufferedImage to a 28x28 grayscale image.
+     */
+    fun convertToGrayscale28x28(image: BufferedImage, invert: Boolean = false): GrayScale28To28Image {
+        // Resize to 28x28
+        val resized = resizeImage(image, 28, 28)
+
+        val result = GrayScale28To28Image()
+        for (y in 0 until 28) {
+            for (x in 0 until 28) {
+                val rgb = resized.getRGB(x, y)
+                val color = Color(rgb)
+
+                // Convert to grayscale using luminance formula
+                val gray = (0.299 * color.red + 0.587 * color.green + 0.114 * color.blue) / 255.0
+
+                // MNIST expects white digit on black background (1.0 = digit, 0.0 = background)
+                // Default: assume input is already white-on-black (MNIST style), keep as-is
+                // With invert: for black digit on white background, invert colors
+                val value = if (invert) (1.0 - gray) else gray
+
+                result.setPixel(x, y, value.toFloat().coerceIn(0f, 1f))
+            }
+        }
+        return result
+    }
+
+    private fun resizeImage(original: BufferedImage, width: Int, height: Int): BufferedImage {
+        val resized = BufferedImage(width, height, BufferedImage.TYPE_INT_RGB)
+        val g = resized.createGraphics()
+        g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR)
+        g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY)
+        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON)
+        g.drawImage(original, 0, 0, width, height, null)
+        g.dispose()
+        return resized
+    }
+}