Add initial gradle modules structure for reflective Ops documentaion

Related-To #139

Author: michalharakal

settings.gradle.kts

@@ -17,3 +17,6 @@ rootProject.name = "SKaiNET"
 
 include("skainet-lang:skainet-lang-core")
 include("skainet-lang:skainet-lang-models")
+include("skainet-lang:skainet-lang-ksp-annotations")
+include("skainet-lang:skainet-lang-ksp-processor")
+include("skainet-lang:skainet-lang-export-ops")

skainet-lang/skainet-lang-core/src/commonMain/kotlin/sk/ainet/compile/nn/NeuralNetworkContext.kt

@@ -0,0 +1,52 @@
+package sk.ainet.compile.nn
+
+import sk.ainet.compile.nn.DefaultNetworkContext
+import sk.ainet.lang.nn.dsl.NeuralNetworkDsl
+import sk.ainet.lang.nn.dsl.network
+
+
+import sk.ainet.lang.nn.Module
+import sk.ainet.lang.tensor.data.DenseTensorDataFactory
+import sk.ainet.lang.tensor.data.TensorDataFactory
+import sk.ainet.lang.types.DType
+
+
+/**
+ * Context for the DSL to define the data type and operations.
+ *
+ * This class holds the information about the data type and operations
+ * that should be used in the DSL. It's used to make the DSL generic
+ * and to avoid hardcoding the data type.
+ *
+ * @param T The default data type.
+ */
+public interface NeuralNetworkContext<T: DType, V> {
+
+    public val tensorDataFactory: TensorDataFactory
+
+}
+
+/**
+ * Creates a context for the DSL with the given configuration.
+ *
+ * @param T The type of data processed by the modules.
+ * @param init The configuration function.
+ * @return The configured context.
+ */
+public fun <T: DType, V> context(init: NeuralNetworkContext<T, V>.(NeuralNetworkContext<T, V>) -> Module<T, V>): Module<T, V> {
+    val instance = DefaultNetworkContext<T, V>()
+    return instance.init(instance)
+}
+
+/**
+ * Extension function to create a network within a NetworkContext.
+ * This bridges the context wrapper with the network DSL using the context's tensor factory.
+ */
+public inline fun <reified T: DType, V> NeuralNetworkContext<T, V>.network(
+    content: NeuralNetworkDsl<T, V>.() -> Unit
+): Module<T, V> = network(tensorDataFactory, content)
+
+public class DefaultNetworkContext<T : DType, V> : NeuralNetworkContext<T, V> {
+    override val tensorDataFactory: TensorDataFactory
+        get() = DenseTensorDataFactory()
+}

skainet-lang/skainet-lang-core/src/commonMain/kotlin/sk/ainet/context/ExecutionContext.kt

@@ -0,0 +1,8 @@
+package sk.ainet.context
+
+import sk.ainet.lang.tensor.ops.TensorOps
+
+
+public interface ExecutionContext<V> {
+    public val ops: TensorOps<V>
+}

skainet-lang/skainet-lang-export-ops/build.gradle.kts

@@ -0,0 +1,70 @@
+plugins {
+    alias(libs.plugins.kotlinMultiplatform)
+    alias(libs.plugins.ksp)
+}
+
+
+group = "org.mikrograd.samples"
+
+kotlin {
+
+    compilerOptions {
+        // Common compiler options applied to all Kotlin source sets
+        freeCompilerArgs.add("-Xexpect-actual-classes")
+        freeCompilerArgs.add("-Xmulti-platform")
+    }
+
+    jvmToolchain(17)
+
+    jvm()
+
+
+    sourceSets {
+        commonMain.dependencies {
+            implementation(project(":miKrograd"))
+        }
+
+        commonTest.dependencies {
+            implementation(kotlin("test-common"))
+            implementation(kotlin("test-annotations-common"))
+        }
+
+        val jvmMain by getting {
+            kotlin.srcDir("build/generated/ksp/jvm/jvmMain/kotlin")
+            dependencies {
+                implementation(project(":miKrograd-annotations"))
+            }
+        }
+
+
+
+        jvmTest.dependencies {
+            implementation(kotlin("test-junit"))
+        }
+    }
+}
+
+dependencies {
+    //    add("kspCommonMainMetadata", project(":test-processor"))
+    add("kspJvm", project(":skainet-lang:skainet-lang-ksp-processor"))
+}
+
+ksp {
+    arg("ksp.verbose", "true")
+}
+
+// Add a run task for the JVM application
+tasks.register<JavaExec>("runJvm") {
+    group = "application"
+    description = "Run the JVM application"
+    classpath = files(kotlin.jvm().compilations["main"].output.allOutputs, configurations.getByName("jvmRuntimeClasspath"))
+    mainClass.set("com.example.MainKt")
+}
+
+// Add a run task for the KspMain application
+tasks.register<JavaExec>("runKspMain") {
+    group = "application"
+    description = "Run the KspMain application"
+    classpath = files(kotlin.jvm().compilations["main"].output.allOutputs, configurations.getByName("jvmRuntimeClasspath"))
+    mainClass.set("com.example.KspMainKt")
+}

skainet-lang/skainet-lang-export-ops/src/commonMain/kotlin/org/mikrograd/data/generator/generator.kt

@@ -0,0 +1,71 @@
+package org.mikrograd.data.generator
+
+import kotlin.math.cos
+import kotlin.math.sin
+import kotlin.random.Random
+
+fun makeMoons(
+    nSamples: Any = 100,
+    shuffle: Boolean = true,
+    noise: Double? = null,
+    randomState: Int? = null
+): Pair<Array<DoubleArray>, IntArray> {
+    val (nSamplesOut, nSamplesIn) = when (nSamples) {
+        is Int -> Pair(nSamples / 2, nSamples - nSamples / 2)
+        is Pair<*, *> -> {
+            if (nSamples.first is Int && nSamples.second is Int) {
+                Pair(nSamples.first as Int, nSamples.second as Int)
+            } else {
+                throw IllegalArgumentException("`n_samples` can be either an int or a two-element tuple.")
+            }
+        }
+        else -> throw IllegalArgumentException("`n_samples` can be either an int or a two-element tuple.")
+    }
+
+    val generator = randomState?.let { Random(it) } ?: Random.Default
+
+    val outerCircX = DoubleArray(nSamplesOut) { cos(it * Math.PI / nSamplesOut) }
+    val outerCircY = DoubleArray(nSamplesOut) { sin(it * Math.PI / nSamplesOut) }
+    val innerCircX = DoubleArray(nSamplesIn) { 1 - cos(it * Math.PI / nSamplesIn) }
+    val innerCircY = DoubleArray(nSamplesIn) { 1 - sin(it * Math.PI / nSamplesIn) - 0.5 }
+
+    val X = Array(nSamplesOut + nSamplesIn) { DoubleArray(2) }
+    for (i in 0 until nSamplesOut) {
+        X[i][0] = outerCircX[i]
+        X[i][1] = outerCircY[i]
+    }
+    for (i in 0 until nSamplesIn) {
+        X[nSamplesOut + i][0] = innerCircX[i]
+        X[nSamplesOut + i][1] = innerCircY[i]
+    }
+
+    val y = IntArray(nSamplesOut + nSamplesIn)
+    for (i in 0 until nSamplesOut) {
+        y[i] = 0
+    }
+    for (i in 0 until nSamplesIn) {
+        y[nSamplesOut + i] = 1
+    }
+
+    if (shuffle) {
+        val indices = X.indices.toList().shuffled(generator)
+        val XShuffled = Array(X.size) { DoubleArray(2) }
+        val yShuffled = IntArray(y.size)
+        for (i in indices.indices) {
+            XShuffled[i] = X[indices[i]]
+            yShuffled[i] = y[indices[i]]
+        }
+        X.indices.forEach { X[it] = XShuffled[it] }
+        y.indices.forEach { y[it] = yShuffled[it] }
+    }
+
+    noise?.let {
+        for (i in X.indices) {
+            X[i][0] += generator.nextDouble(-noise, noise)
+            X[i][1] += generator.nextDouble(-noise, noise)
+        }
+    }
+
+    return Pair(X, y)
+}
+

skainet-lang/skainet-lang-export-ops/src/commonMain/kotlin/org/mikrograd/samples/clusters.kt

@@ -0,0 +1,45 @@
+package org.mikrograd.samples
+/*
+import org.mikrograd.diff.MLP
+import kotlin.random.Random
+import org.mikrograd.diff.Value
+
+
+class MLPClustering(private val data: Pair<Array<DoubleArray>, IntArray>, val model: MLP ) {
+    private val X: Array<DoubleArray> = data.first
+    private val y: IntArray = data.second
+
+      fun loss(batchSize: Int? = null): Pair<Value, Double> {
+        val (Xb, yb) = if (batchSize == null) {
+            Pair(X.toList(), y.toList())
+        } else {
+            val ri = List(batchSize) { Random.nextInt(X.size) }
+            Pair(ri.map { X[it] }, ri.map { y[it] })
+        }
+        val xc: List<DoubleArray> = Xb
+        val inputs: List<List<Value>> = Xb.map { xrow -> xrow.map { Value(it) } }
+
+        val scores: List<Value> = inputs.flatMap { input ->  model.invoke (input) }
+
+        //losses = [(1 + -yi*scorei).relu() for yi, scorei in zip(yb, scores)]
+
+
+        val losses: List<Value> = yb.zip(scores).map { (yi, scorei) -> Value(1 + -yi * scorei.data).relu() }
+        val lossesSum: Value = losses.fold(Value(0.0)) { a, i -> a + i }
+
+        val dataLoss: Value = lossesSum / losses.size
+
+        val alpha = 1e-4
+        val regLoss: Value = alpha  * (model.parameters().reduce { a, i -> a * i })
+        //val reg_loss = alpha * sum((p*p for p in model.parameters()))
+        val totalLoss = dataLoss + regLoss
+
+        val accuracy = yb.zip(scores).count { (yi, scorei) -> (yi > 0) == (scorei.data > 0) }.toDouble() / yb.size
+
+        return Pair(totalLoss, accuracy)
+    }
+
+
+}
+
+ */

skainet-lang/skainet-lang-export-ops/src/commonMain/kotlin/org/mikrograd/samples/minmal.kt

@@ -0,0 +1,58 @@
+package org.mikrograd.samples
+
+/*
+import org.mikrograd.diff.MLP
+import org.mikrograd.diff.Value
+import org.mikrograd.utils.drawDot
+
+fun loss(X: Array<DoubleArray>, y: DoubleArray, model: MLP): Pair<Value, Double> {
+    val inputs: List<List<Value>> = X.mapIndexed { index, xrow -> xrow.map { Value(it, label = "in$index") } }
+    val scores: List<Value> = inputs.map { input -> model(input).first() }
+
+    // mean square error
+    val values: List<Value> =
+        y.zip(scores) { actual: Double, predicted: Value -> (actual - predicted).pow(2.0) }
+    val mse = values.fold(Value(0.0)) { acc, value -> acc + value }
+
+    return Pair(mse, 0.0)
+}
+
+fun main() {
+
+    val c = Value(3.0, label = "a") + Value(2.0, label = "b")
+    val cGr = drawDot(c)
+    cGr.toFile("a+b.dot")
+
+    val d = Value(3.0, label = "a") * Value(2.0, label = "b")
+    val dGr = drawDot(d)
+    dGr.toFile("a*b.dot")
+
+
+    val model = MLP(1, listOf(1, 1, 1)) //# 2-layer neural network
+    val (X, y) = Pair<Array<DoubleArray>, DoubleArray>(
+        arrayOf(doubleArrayOf(1.0)),
+        doubleArrayOf(2.0)
+    )
+
+    val X_v: List<List<Value>> = X.map { xrow -> xrow.map { Value(it) } }
+    val prediction = model.invoke(X_v[0])[0]
+
+    val modelGr = drawDot(prediction)
+    modelGr.toFile("model.dot")
+
+    val (loss, _) = loss(X, y, model)
+
+    val lossGr = drawDot(loss)
+    lossGr.toFile("loss.dot")
+
+    model.zeroGrad()
+    loss.backward()
+
+    val backGr = drawDot(loss, true)
+    backGr.toFile("back.dot")
+
+
+
+}
+
+ */

skainet-lang/skainet-lang-export-ops/src/commonMain/kotlin/org/mikrograd/samples/neuron.kt

@@ -0,0 +1,16 @@
+package org.mikrograd.samples
+
+/*
+import org.mikrograd.diff.Neuron
+import org.mikrograd.diff.Value
+import org.mikrograd.utils.drawDot
+
+fun main() {
+    val neuralNetwork = Neuron(2)
+    //parameters
+    val x = listOf(Value(1.0), Value(-2.0))
+    val y = neuralNetwork(x)
+    drawDot(y).toFile("neuron.png")
+}
+
+ */

skainet-lang/skainet-lang-export-ops/src/commonMain/kotlin/org/mikrograd/samples/sinusNN.kt

@@ -0,0 +1,53 @@
+package org.mikrograd.samples
+
+import org.mikrograd.diff.MLP
+import org.mikrograd.diff.Value
+import kotlin.math.PI
+import kotlin.math.sin
+
+fun train(sine: MLP) {
+
+    //val X = listOf(0.0, PI / 2, PI)
+    val X = List(100) { index ->
+        (index / (100 - 1).toFloat()) * (PI / 2)
+    }
+
+    val y = X.mapIndexed { index, value -> Value(sin(value)).also { it.label = "y$index" } }
+
+
+
+    (1..100).forEach {
+        // forward propagation
+        val ypred: List<List<Value>> = X.mapIndexed { index, x ->
+            sine.invoke(listOf(x))//.also { it[0].label = "y_pred$index" }
+        }
+        // calculate loss
+        val loss: Value = y.zip(ypred) { ygt, yout -> (ygt - yout[0]).pow(2.0) }.reduce { acc, v -> acc + v }
+        // reset gradients
+        sine.parameters().forEach { param ->
+            param.grad = 0.0
+        }
+        // calc gradients in backpropagation
+        loss.backward()
+
+        // update weights and biases with a learning rate
+        sine.parameters().forEach { param ->
+            param.data += -0.1 * param.grad
+        }
+
+        println(loss.data)
+    }
+}
+
+fun MLP.nsin(d: Double) = invoke(listOf(d))[0].data
+
+
+fun main() {
+    val sine = MLP(1, listOf(16, 16, 1))
+
+    println(sine.nsin(PI / 2))
+    train(sine)
+    println(sine.nsin(PI / 2))
+}
+
+