clean code fixup tensor dim and steps as Int type

Author: mullerhai

build.sbt

@@ -105,8 +105,10 @@ releaseProcess := Seq[ReleaseStep](
 //libraryDependencies += "org.bytedeco" % "pytorch-platform-gpu" % "2.7.1-1.5.12"
 libraryDependencies += "org.bytedeco" % "cuda" % "12.9-9.10-1.5.12"
 libraryDependencies += "org.apache.commons" % "commons-pool2" % "2.12.1"
+// https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind
+libraryDependencies += "com.fasterxml.jackson.core" % "jackson-databind" % "2.20.0"
 
-libraryDependencies += "ai.djl" % "api" % "0.33.0"
+//libraryDependencies += "ai.djl" % "api" % "0.33.0"
 libraryDependencies += "com.alibaba.fastjson2" % "fastjson2" % "2.0.57"
 //libraryDependencies += "org.bytedeco" % "cuda-platform" % "12.9-9.10-1.5.12"
 libraryDependencies += "io.github.mullerhai" % "storch-numpy_3" % "0.1.7"
@@ -120,8 +122,8 @@ excludeDependencies += ExclusionRule(organization = "spire", name = "compat_3")
 excludeDependencies ++= Seq(
   "com.thesamet.scalapb" % "lenses_2.13" ,
   "com.thesamet.scalapb" % "scalapb-runtime_2.13",
-  "io.github.mullerhai" % "storch-safe-tensor_3",
-  "io.github.mullerhai" % "storch-polar_3",
+//  "io.github.mullerhai" % "storch-safe-tensor_3",
+//  "io.github.mullerhai" % "storch-polar_3",
   "com.lihaoyi" % "sourcecode_2.13",
   "spire" %"compat_2.13",
   "spire" %"compat_3"
@@ -149,25 +151,26 @@ lazy val storch_core = project
       "com.lihaoyi" %% "os-lib" % "0.9.1",
       "com.lihaoyi" %% "sourcecode" % "0.3.0",
       "dev.dirs" % "directories" % "26",
-      "ai.djl" % "api" % "0.33.0",
+//      "ai.djl" % "api" % "0.33.0",
+      "com.fasterxml.jackson.core" % "jackson-databind" % "2.20.0",
       "com.alibaba.fastjson2" % "fastjson2" % "2.0.57",
       "org.apache.commons" % "commons-pool2" % "2.12.1",
       "io.github.mullerhai" % "storch-numpy_3" % "0.1.7",
-      "io.github.mullerhai" % "storch-pandas_3" % "0.1.5",
+//      "io.github.mullerhai" % "storch-pandas_3" % "0.1.5",
       "io.github.mullerhai" % "storch-pickle_3" % "0.1.4",
       "io.github.mullerhai" % "storch-tensorboard-proto_3" % "0.1.1",
       "io.github.mullerhai" % "storch-plot_3" % "0.0.3",
       "io.github.mullerhai" % "storch-scalapy_3" % "0.1.4-1.15.2" exclude("com.lihaoyi","sourcecode_2.13"),
-      "io.github.mullerhai" % "storch-scikit-learn_3" % "0.1.2-1.15.2"  exclude("org.scala-lang.modules","scala-collection-compat_2.13") exclude("org.typelevel","algebra_2.13")exclude("org.typelevel","cats-kernel_2.13"),
+//      "io.github.mullerhai" % "storch-scikit-learn_3" % "0.1.2-1.15.2"  exclude("org.scala-lang.modules","scala-collection-compat_2.13") exclude("org.typelevel","algebra_2.13")exclude("org.typelevel","cats-kernel_2.13"),
       "org.scalameta" %% "munit" % "0.7.29" % Test,
       "org.scalameta" %% "munit-scalacheck" % "0.7.29" % Test
     ),
     excludeDependencies ++= Seq(
       "com.thesamet.scalapb" % "lenses_2.13" ,
       "com.lihaoyi" % "sourcecode_2.13",
       "com.thesamet.scalapb" % "scalapb-runtime_2.13",
-      "io.github.mullerhai" % "storch-safe-tensor_3",
-      "io.github.mullerhai" % "storch-polar_3",
+//      "io.github.mullerhai" % "storch-safe-tensor_3",
+//      "io.github.mullerhai" % "storch-polar_3",
       "spire" %"compat_2.13",
       "spire" %"compat_3"
     ),

project/build.properties

@@ -1 +1 @@
-sbt.version=1.9.8
+sbt.version=1.11.0

storch_core/src/main/scala/torch/Tensor.scala

@@ -290,7 +290,7 @@ sealed abstract class Tensor[D <: DType]( /* private[torch]  */ val native: pyto
 
   def scalar_type(un_used: Int*) = native.scalar_type()
 
-  def stride(dim: Long) = native.stride(dim)
+  def stride(dim: Int) = native.stride(dim.toLong)
 
   def size(dim: Long) = native.size(dim)
 
@@ -1071,15 +1071,15 @@ sealed abstract class Tensor[D <: DType]( /* private[torch]  */ val native: pyto
     )
   }
 
-  def norm[D1 <: DType, S <: ScalaType](p: S, dim: Long*): Tensor[D1] = {
+  def norm[D1 <: DType, S <: ScalaType](p: S, dim: Int*): Tensor[D1] = {
 
     val pFloat = p match {
       case m: Float  => m
       case m: Double => m.toFloat
       case m: Int    => m.toFloat
       case m: Long   => m.toFloat
     }
-    fromNative(native.norm(ScalarOptional(toScalar(pFloat)), dim*))
+    fromNative(native.norm(ScalarOptional(toScalar(pFloat)), dim.map(_.toLong)*))
   }
 
   def norm[D1 <: DType, S <: ScalaType](
@@ -1138,8 +1138,8 @@ sealed abstract class Tensor[D <: DType]( /* private[torch]  */ val native: pyto
     *   If there are multiple maximal values in a reduced row then the indices of the first maximal
     *   value are returned.
     */
-  def max(dim: Long, keepdim: Boolean = false): TensorTuple[D] =
-    val nativeTuple = native.max(dim, keepdim)
+  def max(dim: Int, keepdim: Boolean = false): TensorTuple[D] =
+    val nativeTuple = native.max(dim.toLong, keepdim)
     TensorTuple(values = fromNative(nativeTuple.get0), indices = new Int64Tensor(nativeTuple.get1))
 
   def maximum[D2 <: DType](other: Tensor[D2]): Tensor[Promoted[D, D2]] =
@@ -1229,7 +1229,7 @@ sealed abstract class Tensor[D <: DType]( /* private[torch]  */ val native: pyto
   def shape: Seq[Int] = size
 
   def softmax[Out <: FloatNN | Derive](
-      dim: Long,
+      dim: Int,
       dtype: Out = derive
   ): Tensor[DTypeOrDeriveFromTensor[D, Out]] = F.softmax(input = this, dim = dim, dtype = dtype)
 
@@ -1854,23 +1854,23 @@ sealed abstract class Tensor[D <: DType]( /* private[torch]  */ val native: pyto
 
   def to_sparse: Tensor[D] = fromNative(native.to_sparse)
 
-  def to_sparse_csr(dense_dim: Long): Tensor[D] = fromNative(
-    native.to_sparse_csr(LongOptional(dense_dim))
+  def to_sparse_csr(dense_dim: Int): Tensor[D] = fromNative(
+    native.to_sparse_csr(LongOptional(dense_dim.toLong))
   )
 
-  def to_sparse_csc(dense_dim: Long): Tensor[D] = fromNative(
-    native.to_sparse_csc(LongOptional(dense_dim))
+  def to_sparse_csc(dense_dim: Int): Tensor[D] = fromNative(
+    native.to_sparse_csc(LongOptional(dense_dim.toLong))
   )
 
-  def to_sparse_bsr(blockSize: Seq[Long], dense_dim: Long): Tensor[D] = fromNative(
-    native.to_sparse_bsr(blockSize.toArray, LongOptional(dense_dim))
+  def to_sparse_bsr(blockSize: Seq[Long], dense_dim: Int): Tensor[D] = fromNative(
+    native.to_sparse_bsr(blockSize.toArray, LongOptional(dense_dim.toLong))
   )
 
-  def to_sparse_bsc(blockSize: Seq[Long], dense_dim: Long): Tensor[D] = fromNative(
-    native.to_sparse_bsc(blockSize.toArray, LongOptional(dense_dim))
+  def to_sparse_bsc(blockSize: Seq[Long], dense_dim: Int): Tensor[D] = fromNative(
+    native.to_sparse_bsc(blockSize.toArray, LongOptional(dense_dim.toLong))
   )
 
-  def to_sparse_coo(sparse_dim: Long): Tensor[D] = fromNative(native.to_sparse(sparse_dim))
+  def to_sparse_coo(sparse_dim: Int): Tensor[D] = fromNative(native.to_sparse(sparse_dim.toLong))
 
   def to_dense(un_used: Int*): Tensor[D] = fromNative(native.to_dense)
 
@@ -3284,8 +3284,8 @@ sealed abstract class Tensor[D <: DType]( /* private[torch]  */ val native: pyto
     fromNative(native.repeat_interleave(repeats.native, dimOpt, outputSizeOpt))
   }
 
-  def repeat_interleave[D1 <: DType](repeats: Long, dim: Long): Tensor[D1] =
-    fromNative(native.repeat_interleave(repeats, new LongOptional(dim), new LongOptional()))
+  def repeat_interleave[D1 <: DType](repeats: Long, dim: Int): Tensor[D1] =
+    fromNative(native.repeat_interleave(repeats, new LongOptional(dim.toLong), new LongOptional()))
 
   def repeat_interleave[D1 <: DType](
       repeats: Long,
@@ -3744,10 +3744,10 @@ sealed abstract class Tensor[D <: DType]( /* private[torch]  */ val native: pyto
 
   def std(unbiased: Boolean): Tensor[D] = fromNative(native.std(unbiased))
 
-  def prod_with_dim(dim: Long, keepdim: Boolean = false, dtype: ScalarTypeOptional): Tensor[D] =
-    fromNative(native.prod(dim, keepdim, dtype))
+  def prod_with_dim(dim: Int, keepdim: Boolean = false, dtype: ScalarTypeOptional): Tensor[D] =
+    fromNative(native.prod(dim.toLong, keepdim, dtype))
 
-  def prod(dim: Long): Tensor[D] = fromNative(native.prod(dim))
+  def prod(dim: Int): Tensor[D] = fromNative(native.prod(dim.toLong))
 
   def prod(un_used: Int*): Tensor[D] = fromNative(native.prod())
 
@@ -5078,7 +5078,7 @@ sealed abstract class Tensor[D <: DType]( /* private[torch]  */ val native: pyto
         fromNative(native.gather(dim.toLong, index.to(dtype = torch.int64).native, sparse_grad))
   }
 
-  def gather(dim: Long, index: Tensor[Int64] | Tensor[Int32]): Tensor[D] = {
+  def gather(dim: Int, index: Tensor[Int64] | Tensor[Int32]): Tensor[D] = {
     index.dtype match
       case torch.int64 => fromNative(native.gather(dim.toLong, index.native))
       case torch.int32 =>
@@ -5249,12 +5249,12 @@ sealed abstract class Tensor[D <: DType]( /* private[torch]  */ val native: pyto
 
   def digamma: Tensor[D] = fromNative(native.digamma())
 
-  def polygamma_(n: Long): this.type = {
-    native.polygamma_(n)
+  def polygamma_(n: Int): this.type = {
+    native.polygamma_(n.toLong)
     this
   }
 
-  def polygamma(n: Long): Tensor[D] = fromNative(native.polygamma(n))
+  def polygamma(n: Int): Tensor[D] = fromNative(native.polygamma(n.toLong))
 
   def erfinv_(): this.type = {
     native.erfinv_()
@@ -5455,12 +5455,12 @@ sealed abstract class Tensor[D <: DType]( /* private[torch]  */ val native: pyto
     native.remainder(other.native)
   )
 
-  def renorm_[S <: ScalaType](p: S, dim: Long, maxnorm: S): this.type = {
-    native.renorm_(toScalar(p), dim, toScalar(maxnorm))
+  def renorm_[S <: ScalaType](p: S, dim: Int, maxnorm: S): this.type = {
+    native.renorm_(toScalar(p), dim.toLong, toScalar(maxnorm))
     this
   }
-  def renorm_(p: Float, dim: Long, maxnorm: Float): this.type = {
-    native.renorm_(toScalar(p), dim, toScalar(maxnorm))
+  def renorm_(p: Float, dim: Int, maxnorm: Float): this.type = {
+    native.renorm_(toScalar(p), dim.toLong, toScalar(maxnorm))
     this
   }
 
@@ -5566,8 +5566,8 @@ sealed abstract class Tensor[D <: DType]( /* private[torch]  */ val native: pyto
     (s, t)
   }
 
-  def unfold(dimension: Long, size: Long, step: Long): Tensor[D] = fromNative(
-    native.unfold(dimension, size, step)
+  def unfold(dimension: Int, size: Int, step: Int): Tensor[D] = fromNative(
+    native.unfold(dimension.toLong, size.toLong, step.toLong)
   )
   def float_power[D1 <: DType](exponent: Tensor[D1]): Tensor[Promoted[D1, D]] = fromNative(
     native.float_power(exponent.native)
@@ -5581,13 +5581,13 @@ sealed abstract class Tensor[D <: DType]( /* private[torch]  */ val native: pyto
     native.pow(exponent.native)
   )
 
-  def renorm(p: Float, dim: Long, maxnorm: Float): Tensor[D] = fromNative(
-    native.renorm(toScalar(p), dim, toScalar(maxnorm))
+  def renorm(p: Float, dim: Int, maxnorm: Float): Tensor[D] = fromNative(
+    native.renorm(toScalar(p), dim.toLong, toScalar(maxnorm))
   )
 
-  def renorm[S <: ScalaType](p: S, dim: Long, maxnorm: S): Tensor[Promoted[D, ScalaToDType[S]]] =
+  def renorm[S <: ScalaType](p: S, dim: Int, maxnorm: S): Tensor[Promoted[D, ScalaToDType[S]]] =
     fromNative(
-      native.renorm(toScalar(p), dim, toScalar(maxnorm))
+      native.renorm(toScalar(p), dim.toLong, toScalar(maxnorm))
     )
 
   def alias(un_used: Int*): Tensor[D] = fromNative(native.alias())
@@ -5687,9 +5687,9 @@ sealed abstract class Tensor[D <: DType]( /* private[torch]  */ val native: pyto
         case _ =>
           val innerSummary = {
             def summarizeSlice(index: Int) = summarize(tensor(index), maxEntries)
-            val sliceLen = tensor.size(0).toInt
+            val sliceLen = tensor.size(0)
             if sliceLen <= math.max(maxEntries, 6) then
-              for (i <- 0 until sliceLen.toInt) yield summarizeSlice(i)
+              for (i <- 0 until sliceLen) yield summarizeSlice(i)
             else
               val start = for (i <- 0 until maxEntries / 2) yield summarizeSlice(i)
               val end = for (i <- sliceLen - maxEntries / 2 until sliceLen) yield summarizeSlice(i)

storch_core/src/main/scala/torch/amp/GradScaler.scala

@@ -1,3 +1,5 @@
 package torch.amp
 
+//https://gist.github.com/dorpxam/67ad2bc222b2cf567d4a6fc298375e13
+
 class GradScaler {}

storch_core/src/main/scala/torch/nn/functional/Activations.scala

@@ -46,7 +46,7 @@ private[torch] trait Activations {
     */
   def logSoftmax[In <: DType, Out <: FloatNN | Derive](
       input: Tensor[In],
-      dim: Long,
+      dim: Int,
       dtype: Out = derive
   ): Tensor[DTypeOrDeriveFromTensor[In, Out]] =
     val derivedDType = dtype match
@@ -55,11 +55,11 @@ private[torch] trait Activations {
     val nativeDType =
       if dtype == input.dtype then ScalarTypeOptional()
       else ScalarTypeOptional(derivedDType.toScalarType)
-    fromNative(torchNative.log_softmax(input.native, dim, nativeDType))
+    fromNative(torchNative.log_softmax(input.native, dim.toLong, nativeDType))
 
   def log_softmax[In <: DType, Out <: FloatNN | Derive](
       input: Tensor[In],
-      dim: Long,
+      dim: Int,
       dtype: Out = derive
   ) = logSoftmax(input, dim, dtype)
 
@@ -94,7 +94,7 @@ private[torch] trait Activations {
     */
   def softmax[In <: DType, Out <: FloatNN | Derive](
       input: Tensor[In],
-      dim: Long,
+      dim: Int,
       dtype: Out = derive
   ): Tensor[DTypeOrDeriveFromTensor[In, Out]] =
     val derivedDType = dtype match
@@ -103,7 +103,7 @@ private[torch] trait Activations {
     val nativeDType =
       if dtype == input.dtype then ScalarTypeOptional()
       else ScalarTypeOptional(derivedDType.toScalarType)
-    fromNative(torchNative.softmax(input.native, dim, nativeDType))
+    fromNative(torchNative.softmax(input.native, dim.toLong, nativeDType))
 
   def relu_[D <: DType](input: Tensor[D]): Tensor[D] = fromNative(torchNative.relu_(input.native))
 
@@ -160,8 +160,8 @@ private[torch] trait Activations {
 
   def selu_[D <: DType](input: Tensor[D]): Tensor[D] = fromNative(torchNative.selu_(input.native))
 
-  def glu[D <: DType](input: Tensor[D], dim: Long): Tensor[D] = fromNative(
-    torchNative.glu(input.native, dim)
+  def glu[D <: DType](input: Tensor[D], dim: Int): Tensor[D] = fromNative(
+    torchNative.glu(input.native, dim.toLong)
   )
 
   def gelu[D <: DType](input: Tensor[D], approximate: String = "none"): Tensor[D] = {
@@ -193,8 +193,8 @@ private[torch] trait Activations {
     torchNative.softsign(input.native)
   )
 
-  def softmin[D <: DType](input: Tensor[D], dim: Long, dtype: DType): Tensor[D] = {
-    val options = SoftminFuncOptions(dim)
+  def softmin[D <: DType](input: Tensor[D], dim: Int, dtype: DType): Tensor[D] = {
+    val options = SoftminFuncOptions(dim.toLong)
     options.dtype().put(ScalarTypeOptional(dtype.toScalarType))
     fromNative(
       torchNative.softmin(input.native, options)