Init weight in Linear layer with zeros. Also add initial implementation of CsvParametersLoader using BufferedSource.

Author: michalharakal

build.gradle.kts

@@ -2,4 +2,6 @@ plugins {
     alias(libs.plugins.androidLibrary) apply false
     alias(libs.plugins.kotlinMultiplatform) apply  false
     alias(libs.plugins.jetbrainsKotlinJvm) apply false
+    alias(libs.plugins.binaryCompatibility) apply false
+
 }

core/build.gradle.kts

@@ -4,6 +4,7 @@ import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 plugins {
     alias(libs.plugins.kotlinMultiplatform)
     alias(libs.plugins.androidLibrary)
+    alias(libs.plugins.binaryCompatibility)
     id("module.publication")
 }
 

core/src/commonMain/kotlin/sk/ai/net/Shape.kt

@@ -1,5 +1,7 @@
 package sk.ai.net
 
+import sk.ai.net.impl.zipFold
+
 class Shape(vararg dimensions: Int) {
     val dimensions: IntArray = dimensions.copyOf()
 
@@ -8,4 +10,29 @@ class Shape(vararg dimensions: Int) {
 
     val rank: Int
         get() = dimensions.size
+
+    override fun equals(other: Any?): Boolean {
+        if (other !is Shape) {
+            return false
+        }
+
+        return dimensions.size == other.dimensions.size && zipFold(dimensions, other.dimensions, true) { result, a, b ->
+            if (!result) {
+                return false
+            }
+            a == b
+        }
+    }
+
+    override fun hashCode(): Int {
+        return dimensions.hashCode()
+    }
+
+    override fun toString(): String {
+        // Create a string representation of the dimensions array
+        val dimensionsString = dimensions.joinToString(separator = " x ", prefix = "[", postfix = "]")
+        // Return the formatted string including dimensions and volume
+        return "Shape: Dimensions = $dimensionsString, Size (Volume) = $volume"
+    }
+
 }

core/src/commonMain/kotlin/sk/ai/net/dsl/NetworkBuilder.kt

@@ -41,16 +41,36 @@ private fun getDefaultName(id: String, s: String, size: Int): String {
 }
 
 
+fun createLinear(
+    inFeatures: Int,
+    outFeatures: Int,
+    myInitWeights: Tensor? = null,
+    myInitBias: Tensor? = null
+): Linear {
+    return when {
+        myInitWeights != null && myInitBias != null ->
+            Linear(inFeatures, outFeatures, initWeights = myInitWeights, initBias = myInitBias)
+        myInitWeights != null ->
+            Linear(inFeatures, outFeatures, initWeights = myInitWeights)
+        myInitBias != null ->
+            Linear(inFeatures, outFeatures, initBias = myInitBias)
+        else ->
+            Linear(inFeatures, outFeatures)
+    }
+}
+
 class DenseImpl(
     private val inputDimension: Int, private val outputDimension: Int, private val id: String
 ) : DENSE {
 
     private var weightsValue: Tensor? = null
+    private var biasValue: Tensor? = null
     private var _activation: (Tensor) -> Tensor = { tensor -> tensor }
 
     fun create(): List<Module> {
+
         return listOf(
-            Linear(inputDimension, outputDimension, id, weightsValue!!, weightsValue!!),
+            createLinear(inputDimension, outputDimension, weightsValue, biasValue),
             ActivationsWrapperModule(activation, "activation")
         )
     }
@@ -66,7 +86,7 @@ class DenseImpl(
     }
 
     override fun bias(initBlock: (Shape) -> Tensor) {
-        weightsValue = initBlock(Shape(outputDimension))
+        biasValue = initBlock(Shape(outputDimension))
     }
 }
 

core/src/commonMain/kotlin/sk/ai/net/nn/Linear.kt

@@ -1,6 +1,8 @@
 package sk.ai.net.nn
 
+import sk.ai.net.Shape
 import sk.ai.net.Tensor
+import sk.ai.net.impl.DoublesTensor
 
 /**
  * Linear layer (a.k.a. fully connected dense layer). This layer applies a linear transformation to the input data.
@@ -17,8 +19,14 @@ class Linear(
     inFeatures: Int,
     outFeatures: Int,
     override val name: String = "Linear",
-    val initWeights: Tensor,
-    val initBias: Tensor,
+    val initWeights: Tensor = DoublesTensor(
+        Shape(outFeatures, inFeatures),
+        List(inFeatures * outFeatures) { 0.0 }.map { it }.toDoubleArray()
+    ),
+    val initBias: Tensor = DoublesTensor(
+        Shape(outFeatures),
+        List(outFeatures) { 0.0 }.map { it }.toDoubleArray()
+    ),
     override val params: List<ModuleParameter> = listOf(
         ModuleParameter("weight", initWeights),
         ModuleParameter("bias", initBias)

gradle/libs.versions.toml

@@ -6,9 +6,10 @@ android-compileSdk = "35"
 kotlinxSerializationJson = "1.8.0"
 nexus-publish = "2.0.0"
 jetbrainsKotlinJvm = "1.9.22"
-testng = "6.9.6"
+testng = "7.10.2"
 okio = "3.9.1"
 okioNodefilesystem = "3.9.0"
+binaryCompatibility = "0.17.0"
 
 [libraries]
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
@@ -22,4 +23,5 @@ okio-nodefilesystem = { module = "com.squareup.okio:okio-nodefilesystem", versio
 androidLibrary = { id = "com.android.library", version.ref = "agp" }
 kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
 jetbrainsKotlinJvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "jetbrainsKotlinJvm" }
-kotlinSerialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
+kotlinSerialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
+binaryCompatibility = { id = "org.jetbrains.kotlinx.binary-compatibility-validator", version.ref = "binaryCompatibility" }

io/src/commonMain/kotlin/sk/ai/net/io/csv/CsvParameterLoader.kt

@@ -1,22 +1,22 @@
 package sk.ai.net.io.csv
 
 import kotlinx.serialization.json.Json
-import okio.Path
+import okio.BufferedSource
+import okio.use
 import sk.ai.net.Shape
 
 import sk.ai.net.Tensor
 import sk.ai.net.impl.DoublesTensor
 import sk.ai.net.io.ParametersLoader
 
-class CsvParametersLoader(private val fileSystem: okio.FileSystem, private val modelWeightPath: Path) :
+class CsvParametersLoader(private val handleSource: () -> BufferedSource) :
     ParametersLoader {
     override suspend fun load(onTensorLoaded: (String, Tensor) -> Unit) {
-        fileSystem.read(modelWeightPath) {
+        handleSource().use { source ->
             // Initialize Json object
             val json = Json { ignoreUnknownKeys = true }
-
             // Deserialize JSON to Kotlin objects
-            json.decodeFromString<List<ArrayValues>>(this.readUtf8()).also { values ->
+            json.decodeFromString<List<ArrayValues>>(source.readUtf8()).also { values ->
                 values.forEach { (name, array) ->
                     val tensor = DoublesTensor(Shape(*array.shape.toIntArray()), array.values.toDoubleArray())
                     onTensorLoaded(name, tensor)