Format

Author: EmergentOrder

.scalafmt.conf

@@ -1,3 +1,5 @@
-align = more
+align.preset = "more"
 maxColumn = 100
-version=2.7.5
+version=3.0.0-RC2
+runner.dialect = scala3
+indent.main = 3

backends/.jvm/src/main/scala/NCF.scala

@@ -19,38 +19,35 @@ import io.kjaer.compiletime._
 class NCF(byteArray: Array[Byte], userIdsMap: Map[Long, Long], itemIdsMap: Map[Long, Long])
     extends AutoCloseable {
 
+   val fullORTBackend = new ORTModelBackend(byteArray)
 
-  val fullORTBackend = new ORTModelBackend(byteArray)
-
-  def fullNCF(
-      inputDataactual_input_1: Tensor[Long, Axes],
-      inputDatalearned_0: Tensor[Long, Axes]
-  ): Tensor[Float, Axes] = {
+   def fullNCF(
+       inputDataactual_input_1: Tensor[Long, Axes],
+       inputDatalearned_0: Tensor[Long, Axes]
+   ): Tensor[Float, Axes] = {
 //    val scope = new PointerScope()
-    val nodeactual_input_1 = Tuple1((
-      inputDataactual_input_1.data.map(y => userIdsMap(y)),
-      inputDataactual_input_1.shape)
-    )
-
-    val tensorType: String with Singleton = "TensorType"
-    val nodelearned_0 = Tuple1((inputDatalearned_0.data.map(y => itemIdsMap(y)), inputDatalearned_0.shape))
-
-    //Note: Don't need to specify all the type params except in Dotty
-    val nodeFullOutput: Tensor[Float, Axes] =
-      fullORTBackend
-        .fullModel[Float, "TensorType", "DimensionDenotation" ##: TSNil, 1 #: 1000 #: SNil](
-          //TODO: testing less than enough inputs
-          (nodeactual_input_1) 
-        )
-        
-
-
-
-    nodeFullOutput //.asInstanceOf[Tensor[Float]] //Bad
-  }
-
-  override def close(): Unit = {
-    fullORTBackend.close()
-
-  }
+      val nodeactual_input_1 = Tuple1(
+        (inputDataactual_input_1.data.map(y => userIdsMap(y)), inputDataactual_input_1.shape)
+      )
+
+      val tensorType: String with Singleton = "TensorType"
+      val nodelearned_0 = Tuple1(
+        (inputDatalearned_0.data.map(y => itemIdsMap(y)), inputDatalearned_0.shape)
+      )
+
+      //Note: Don't need to specify all the type params except in Dotty
+      val nodeFullOutput: Tensor[Float, Axes] =
+         fullORTBackend
+            .fullModel[Float, "TensorType", "DimensionDenotation" ##: TSNil, 1 #: 1000 #: SNil](
+              //TODO: testing less than enough inputs
+              (nodeactual_input_1)
+            )
+
+      nodeFullOutput //.asInstanceOf[Tensor[Float]] //Bad
+   }
+
+   override def close(): Unit = {
+      fullORTBackend.close()
+
+   }
 }

backends/.jvm/src/main/scala/ORTModelBackend.scala

@@ -18,50 +18,58 @@ class ORTModelBackend(onnxBytes: Array[Byte])
     with ORTOperatorBackend
     with AutoCloseable {
 
-  def getInputAndOutputNodeNamesAndDims(sess: OrtSession) = {
-    val input_node_names = session.getInputNames
- 
-    val inputNodeDims = session.getInputInfo.values.asScala.map(_.getInfo.asInstanceOf[TensorInfo].getShape)
+   def getInputAndOutputNodeNamesAndDims(sess: OrtSession) = {
+      val input_node_names = session.getInputNames
 
-    val output_node_names = session.getOutputNames
+      val inputNodeDims =
+         session.getInputInfo.values.asScala.map(_.getInfo.asInstanceOf[TensorInfo].getShape)
 
-    (input_node_names.asScala.toList, inputNodeDims.toArray, output_node_names.asScala.toList)
-  }
+      val output_node_names = session.getOutputNames
 
-  val session = getSession(onnxBytes)
+      (input_node_names.asScala.toList, inputNodeDims.toArray, output_node_names.asScala.toList)
+   }
 
-  val allNodeNamesAndDims = getInputAndOutputNodeNamesAndDims(session)
+   val session = getSession(onnxBytes)
 
-  override def fullModel[
-      T <: Supported,
-      Tt <: TensorTypeDenotation, Td <: TensorShapeDenotation, S <: Shape
-  ](
-      inputs: Tuple
-    )(using tt: ValueOf[Tt], td: TensorShapeDenotationOf[Td], s: ShapeOf[S]): Tensor[T, Tuple3[Tt, Td, S]] = {
+   val allNodeNamesAndDims = getInputAndOutputNodeNamesAndDims(session)
 
-        val size = inputs.size
-        val inputTensors = (0 until size).map { i =>
-          val tup               = inputs.drop(i).take(1)
-          tup match { //Spurious warning here, see: https://github.com/lampepfl/dotty/issues/10318
+   override def fullModel[
+       T <: Supported,
+       Tt <: TensorTypeDenotation,
+       Td <: TensorShapeDenotation,
+       S <: Shape
+   ](
+       inputs: Tuple
+   )(using
+       tt: ValueOf[Tt],
+       td: TensorShapeDenotationOf[Td],
+       s: ShapeOf[S]
+   ): Tensor[T, Tuple3[Tt, Td, S]] = {
+
+      val size = inputs.size
+      val inputTensors = (0 until size).map { i =>
+         val tup = inputs.drop(i).take(1)
+         tup match { //Spurious warning here, see: https://github.com/lampepfl/dotty/issues/10318
             case t: Tuple1[_] =>
-              t(0) match {
-                case tens: Tensor[T, Tuple3[Tt, Td, S]] => getOnnxTensor(tens.data, tens.shape, env)
-              }
-          }
-        }.toArray
+               t(0) match {
+                  case tens: Tensor[T, Tuple3[Tt, Td, S]] =>
+                     getOnnxTensor(tens.data, tens.shape, env)
+               }
+         }
+      }.toArray
 
-        val output = runModel[T, Tt, Td, S](
-          session,
-          inputTensors,
-          allNodeNamesAndDims._1,
-          allNodeNamesAndDims._3
-        )
+      val output = runModel[T, Tt, Td, S](
+        session,
+        inputTensors,
+        allNodeNamesAndDims._1,
+        allNodeNamesAndDims._3
+      )
 
-        output //.asInstanceOf[Tensor[T, Tuple3[Tt, Td, S]]]
-  }
+      output //.asInstanceOf[Tensor[T, Tuple3[Tt, Td, S]]]
+   }
 
-  override def close(): Unit = {
+   override def close(): Unit = {
 //    executable.close
 //    super.close
-  }
+   }
 }