Bias and Weight Scope DSL refactoring

Related-To: #94

Author: michalharakal

skainet-core/skainet-tensors/src/commonMain/kotlin/sk/ainet/core/tensor/backend/CpuBackend.kt

@@ -2354,6 +2354,20 @@ public class CpuBackend : ComputeBackend<FP32, Float> {
         })
     }
 
+    override fun fromArray(
+        shape: Shape,
+        data: FloatArray
+    ): Tensor<FP32, Float> {
+        return CpuTensorFP32.fromArray(shape, data)
+    }
+
+    override fun fromArray(
+        shape: Shape,
+        data: IntArray
+    ): Tensor<FP32, Float> {
+        return CpuTensorFP32.fromArray(shape, FloatArray(data.size) { data[it].toFloat() })
+    }
+
     private fun generateNormalDistribution(random: kotlin.random.Random, mean: Double, std: Double): Double {
         // Box-Muller transform for generating normal distribution
         val u1 = random.nextDouble()
@@ -2566,6 +2580,20 @@ public class CpuBackendInt8 : ComputeBackend<Int8, Byte> {
             random.nextInt(min.toInt().coerceAtLeast(-128), max.toInt().coerceAtMost(127) + 1).toByte()
         })
 
+    override fun fromArray(
+        shape: Shape,
+        data: FloatArray
+    ): Tensor<Int8, Byte> {
+        return CpuTensorInt8.fromArray(shape, ByteArray(data.size) { data[it].toInt().coerceIn(-128, 127).toByte() })
+    }
+
+    override fun fromArray(
+        shape: Shape,
+        data: IntArray
+    ): Tensor<Int8, Byte> {
+        return CpuTensorInt8.fromArray(shape, ByteArray(data.size) { data[it].coerceIn(-128, 127).toByte() })
+    }
+
     private fun generateNormalDistributionInt8(random: kotlin.random.Random, mean: Double, std: Double): Byte {
         // Box-Muller transform for generating normal distribution
         val u1 = random.nextDouble()
@@ -2777,6 +2805,20 @@ public class CpuBackendInt32 : ComputeBackend<Int32, Int> {
             random.nextInt(min.toInt(), max.toInt() + 1)
         })
 
+    override fun fromArray(
+        shape: Shape,
+        data: FloatArray
+    ): Tensor<Int32, Int> {
+        return CpuTensorInt32.fromArray(shape, IntArray(data.size) { data[it].toInt() })
+    }
+
+    override fun fromArray(
+        shape: Shape,
+        data: IntArray
+    ): Tensor<Int32, Int> {
+        return CpuTensorInt32.fromArray(shape, data)
+    }
+
     private fun generateNormalDistributionInt32(random: kotlin.random.Random, mean: Double, std: Double): Int {
         // Box-Muller transform for generating normal distribution
         val u1 = random.nextDouble()
@@ -3533,6 +3575,20 @@ public class CpuBackendFP16 : ComputeBackend<FP16, Float> {
             (random.nextDouble() * (max - min) + min).toFloat()
         })
 
+    override fun fromArray(
+        shape: Shape,
+        data: FloatArray
+    ): Tensor<FP16, Float> {
+        return CpuTensorFP16.fromArray(shape, data)
+    }
+
+    override fun fromArray(
+        shape: Shape,
+        data: IntArray
+    ): Tensor<FP16, Float> {
+        return CpuTensorFP16.fromArray(shape, FloatArray(data.size) { data[it].toFloat() })
+    }
+
     private fun generateNormalDistributionFP16(random: kotlin.random.Random, mean: Double, std: Double): Float {
         // Box-Muller transform for generating normal distribution
         val u1 = random.nextDouble()

skainet-core/skainet-tensors/src/commonTest/kotlin/sk/ainet/core/tensor/multiplication/MLOperationsTest.kt

@@ -49,8 +49,8 @@ class MLOperationsTest {
         val featureShape = Shape(1, 2, 3, 3) // 1x2x3x3
         val filterShape = Shape(18, 8) // Flattened: 2*3*3=18 input features, 8 filters
 
-        val featureData = FloatArray(18) { (it + 1).toFloat() }
-        val filterData = FloatArray(144) { (it % 5 + 1).toFloat() }
+        val featureData = FloatArray(featureShape.volume) { (it + 1).toFloat() }
+        val filterData = FloatArray(filterShape.volume) { (it % 5 + 1).toFloat() }
 
         // Flatten feature map for matrix multiplication
         val flatFeatureShape = Shape(1, 18) // Batch size 1, 18 features