Add support for "describe" fucntion for DNN.

Author: michalharakal

settings.gradle.kts

@@ -13,12 +13,12 @@ dependencyResolutionManagement {
     }
 }
 
-rootProject.name = "skainet"
+rootProject.name = "SKaiNET"
 
 include("skainet-core:skainet-tensors-api")
 include("skainet-core:skainet-tensors")
 include("skainet-core:skainet-performance")
-include("skainet-core:skainet-reflection")
+include("skainet-core:skainet-core-reflection")
 include("skainet-nn:skainet-nn-api")
 include("skainet-nn:skainet-nn-relection")
 include("skainet-data:skainet-data-api")

…n/skainet-nn-reflection/build.gradle.kts …skainet-core-reflection/build.gradle.ktsskainet-nn/skainet-nn-reflection/build.gradle.kts renamed to skainet-core/skainet-core-reflection/build.gradle.kts skainet-nn/skainet-nn-reflection/build.gradle.kts renamed to skainet-core/skainet-core-reflection/build.gradle.kts

@@ -37,7 +37,9 @@ kotlin {
         val commonMain by getting {
             dependencies {
                 implementation(project(":skainet-core:skainet-tensors-api"))
-                implementation(project(":skainet-core:skainet-tensors-api"))
+                implementation(project(":skainet-core:skainet-tensors"))
+                implementation(project(":skainet-nn:skainet-nn-api"))
+
             }
         }
 
@@ -49,7 +51,7 @@ kotlin {
 }
 
 android {
-    namespace = "sk.ainet.core.api"
+    namespace = "sk.ainet.core.reflection"
     compileSdk = libs.versions.android.compileSdk.get().toInt()
 
     defaultConfig {

…/skainet-nn-reflection/gradle.properties …kainet-core-reflection/gradle.propertiesskainet-nn/skainet-nn-reflection/gradle.properties renamed to skainet-core/skainet-core-reflection/gradle.properties skainet-nn/skainet-nn-reflection/gradle.properties renamed to skainet-core/skainet-core-reflection/gradle.properties

@@ -1,2 +1,2 @@
-POM_ARTIFACT_ID=nn-api
+POM_ARTIFACT_ID=core-reflection
 POM_NAME=skainet neural network API

skainet-core/skainet-core-reflection/src/commonMain/kotlin/sk/ainet/nn/reflection/ModelSummary.kt

@@ -0,0 +1,94 @@
+package sk.ainet.nn.reflection
+
+import sk.ainet.core.tensor.DType
+import sk.ainet.core.tensor.Shape
+import sk.ainet.core.tensor.Tensor
+import sk.ainet.nn.Module
+import sk.ainet.nn.reflection.table.table
+import sk.ainet.nn.topology.ModuleParameters
+import sk.ainet.nn.topology.by
+
+
+public data class NodeSummary(val name: String, val input: Shape, val output: Shape, val params: Long)
+
+public class Summary<T : DType, V> {
+
+    public val nodes: MutableList<NodeSummary> = mutableListOf<NodeSummary>()
+
+    private fun countParameters(module: Module<T, V>): Long {
+        var params = 0L
+
+        if (module is ModuleParameters<*, *>) {
+            module.params.forEach { param ->
+                params += param.value.shape.volume
+            }
+        }
+
+        return params
+    }
+
+    private fun nodeSummary(module: Module<T, V>, input: Shape, output: Shape): NodeSummary {
+        val params = countParameters(module)
+
+        return NodeSummary(
+            module.name,
+            input,
+            output,
+            params
+        )
+    }
+
+
+    private fun traverseModules(module: Module<T, V>, currentInput: Shape): List<NodeSummary> {
+        val result = mutableListOf<NodeSummary>()
+        
+        // For leaf modules (modules with parameters), create a summary
+        if (module is ModuleParameters<*, *> && module.params.isNotEmpty()) {
+            // We'll use the current input shape as both input and output for now
+            // In a real implementation, this would require actual forward pass
+            val summary = nodeSummary(module, currentInput, currentInput)
+            result.add(summary)
+        }
+        
+        // Recursively traverse nested modules
+        module.modules.forEach { subModule ->
+            result.addAll(traverseModules(subModule, currentInput))
+        }
+        
+        return result
+    }
+
+    public fun summary(model: Module<T, V>, input: Shape, batch_size: Int = -1): List<NodeSummary> {
+        nodes.clear()
+        val summaries = traverseModules(model, input)
+        nodes.addAll(summaries)
+        return summaries
+    }
+
+    public fun printSummary(nodes: List<NodeSummary>): String =
+        table {
+            cellStyle {
+                border = true
+            }
+            header {
+                row {
+                    cell("Layer (type)")
+                    cell("Output Shape")
+                    cell("Param #")
+                }
+            }
+            nodes.forEach { node ->
+                row {
+                    cell(node.name)
+                    cell(node.output.toString())
+                    cell(node.params)
+                }
+            }
+        }.toString()
+}
+
+public fun <T : DType, V> Module<T, V>.describe(input: Shape, batch_size: Int = -1): String {
+    val summary = Summary<T, V>()
+    val nodes = summary.summary(this, input, batch_size)
+    return summary.printSummary(nodes)
+}

…inet/nn/reflection/table/TableBuilder.kt …lin/sk/ainet/utils/table/TableBuilder.ktskainet-nn/skainet-nn-reflection/src/commonMain/kotlin/sk/ainet/nn/reflection/table/TableBuilder.kt renamed to skainet-core/skainet-core-reflection/src/commonMain/kotlin/sk/ainet/utils/table/TableBuilder.kt skainet-nn/skainet-nn-reflection/src/commonMain/kotlin/sk/ainet/nn/reflection/table/TableBuilder.kt renamed to skainet-core/skainet-core-reflection/src/commonMain/kotlin/sk/ainet/utils/table/TableBuilder.kt

@@ -8,13 +8,13 @@ public fun table(block: Table.() -> Unit): Table {
 // The Table DSL class
 public class Table {
     // A cell style configuration object
-    public val cellStyle = CellStyle()
+    public val cellStyle: CellStyle = CellStyle()
 
     // Optional header section
     public var header: Header? = null
 
     // List of body rows
-    public val rows = mutableListOf<Row>()
+    public val rows: MutableList<Row> = mutableListOf<Row>()
 
     // DSL function to configure the cell style
     public fun cellStyle(block: CellStyle.() -> Unit) {
@@ -97,28 +97,28 @@ public class Table {
 }
 
 // A simple header container allowing multiple header rows.
-class Header {
-    val rows = mutableListOf<Row>()
+public class Header {
+    public val rows: MutableList<Row> = mutableListOf<Row>()
 
-    fun row(block: Row.() -> Unit) {
+    public fun row(block: Row.() -> Unit): Unit {
         rows.add(Row().apply(block))
     }
 }
 
 // Represents a row in the table.
-class Row {
-    val cells = mutableListOf<Cell>()
+public class Row {
+    public val cells: MutableList<Cell> = mutableListOf<Cell>()
 
     // Adds a cell to the row.
-    fun cell(value: Any?) {
+    public fun cell(value: Any?): Unit {
         cells.add(Cell(value?.toString() ?: ""))
     }
 }
 
 // Represents a cell containing text.
-class Cell(val content: String)
+public class Cell(public val content: String)
 
 // A configuration class for cell style options.
-class CellStyle {
-    var border: Boolean = false
+public class CellStyle {
+    public var border: Boolean = false
 }