Add Linear System Operators to Bonsai.ML.Torch

src/Bonsai.ML.Torch/LinearAlgebra/CholeskyDecomposition.cs

@@ -3,24 +3,23 @@
 using System.Reactive.Linq;
 using static TorchSharp.torch;
 
-namespace Bonsai.ML.Torch.LinearAlgebra
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the Cholesky decomposition of a complex Hermitian or real symmetric positive-definite matrix.
+/// </summary>
+[Combinator]
+[Description("Computes the Cholesky decomposition of a complex Hermitian or real symmetric positive-definite matrix.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class CholeskyDecomposition
 {
     /// <summary>
     /// Computes the Cholesky decomposition of a complex Hermitian or real symmetric positive-definite matrix.
     /// </summary>
-    [Combinator]
-    [Description("Computes the Cholesky decomposition of a complex Hermitian or real symmetric positive-definite matrix.")]
-    [WorkflowElementCategory(ElementCategory.Transform)]
-    public class CholeskyDecomposition
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tensor> source)
     {
-        /// <summary>
-        /// Computes the Cholesky decomposition of a complex Hermitian or real symmetric positive-definite matrix.
-        /// </summary>
-        /// <param name="source"></param>
-        /// <returns></returns>
-        public IObservable<Tensor> Process(IObservable<Tensor> source)
-        {
-            return source.Select(linalg.cholesky);
-        }
+        return source.Select(linalg.cholesky);
     }
-}
+}

src/Bonsai.ML.Torch/LinearAlgebra/CrossProduct.cs

@@ -0,0 +1,34 @@
+using System;
+using System.ComponentModel;
+using System.Reactive.Linq;
+using static TorchSharp.torch;
+using static TorchSharp.torch.linalg;
+
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the cross product of 2 tensors.
+/// </summary>
+[Combinator]
+[Description("Computes the cross product of 2 tensors.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class CrossProduct
+{
+    /// <summary>
+    /// The dimension to perform the operation.
+    /// </summary>
+    public long Dimension { get; set; } = -1;
+
+    /// <summary>
+    /// Computes the cross product of 2 tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor>> source)
+    {
+        return source.Select(value =>
+        {
+            return cross(value.Item1, value.Item2, Dimension);
+        });
+    }
+}

src/Bonsai.ML.Torch/LinearAlgebra/Determinant.cs

@@ -3,24 +3,23 @@
 using System.Reactive.Linq;
 using static TorchSharp.torch;
 
-namespace Bonsai.ML.Torch.LinearAlgebra
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the determinant of a square matrix.
+/// </summary>
+[Combinator]
+[Description("Computes the determinant of a square matrix.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class Determinant
 {
     /// <summary>
     /// Computes the determinant of a square matrix.
     /// </summary>
-    [Combinator]
-    [Description("Computes the determinant of a square matrix.")]
-    [WorkflowElementCategory(ElementCategory.Transform)]
-    public class Determinant
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tensor> source)
     {
-        /// <summary>
-        /// Computes the determinant of a square matrix.
-        /// </summary>
-        /// <param name="source"></param>
-        /// <returns></returns>
-        public IObservable<Tensor> Process(IObservable<Tensor> source)
-        {
-            return source.Select(linalg.det);
-        }
+        return source.Select(linalg.det);
     }
-}
+}

src/Bonsai.ML.Torch/LinearAlgebra/EigenvalueDecomposition.cs

@@ -3,24 +3,40 @@
 using System.Reactive.Linq;
 using static TorchSharp.torch;
 
-namespace Bonsai.ML.Torch.LinearAlgebra
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the eigenvalue decomposition of a square matrix if it exists.
+/// </summary>
+[Combinator]
+[Description("Computes the eigenvalue decomposition of a square matrix if it exists.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class EigenvalueDecomposition
 {
     /// <summary>
     /// Computes the eigenvalue decomposition of a square matrix if it exists.
     /// </summary>
-    [Combinator]
-    [Description("Computes the eigenvalue decomposition of a square matrix if it exists.")]
-    [WorkflowElementCategory(ElementCategory.Transform)]
-    public class EigenvalueDecomposition
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<EigenDecompositionResult> Process(IObservable<Tensor> source)
     {
+        return source.Select(tensor => new EigenDecompositionResult(linalg.eig(tensor)));
+    }
+
+    /// <summary>
+    /// Represents the result of an eigenvalue decomposition.
+    /// </summary>
+    /// <param name="result">The tuple containing the eigenvalues and eigenvectors.</param>
+    public readonly struct EigenDecompositionResult((Tensor eigenvalues, Tensor eigenvectors) result)
+    {
+        /// <summary>
+        /// Gets the eigenvalues of the decomposition.
+        /// </summary>
+        public Tensor Eigenvalues => result.eigenvalues;
+
         /// <summary>
-        /// Computes the eigenvalue decomposition of a square matrix if it exists.
+        /// Gets the eigenvectors of the decomposition.
         /// </summary>
-        /// <param name="source"></param>
-        /// <returns></returns>
-        public IObservable<Tuple<Tensor, Tensor>> Process(IObservable<Tensor> source)
-        {
-            return source.Select(tensor => linalg.eig(tensor).ToTuple());
-        }
+        public Tensor Eigenvectors => result.eigenvectors;
     }
-}
+}

src/Bonsai.ML.Torch/LinearAlgebra/Inverse.cs

@@ -4,24 +4,23 @@
 using static TorchSharp.torch;
 using static TorchSharp.torch.linalg;
 
-namespace Bonsai.ML.Torch.LinearAlgebra
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the inverse of the input matrix.
+/// </summary>
+[Combinator]
+[Description("Computes the inverse of the input matrix.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class Inverse
 {
     /// <summary>
     /// Computes the inverse of the input matrix.
     /// </summary>
-    [Combinator]
-    [Description("Computes the inverse of the input matrix.")]
-    [WorkflowElementCategory(ElementCategory.Transform)]
-    public class Inverse
+    /// <param name="source">The input matrix to invert.</param>
+    /// <returns>The inverse of the input matrix.</returns>
+    public IObservable<Tensor> Process(IObservable<Tensor> source)
     {
-        /// <summary>
-        /// Computes the inverse of the input matrix.
-        /// </summary>
-        /// <param name="source"></param>
-        /// <returns></returns>
-        public IObservable<Tensor> Process(IObservable<Tensor> source)
-        {
-            return source.Select(inv);
-        }
+        return source.Select(inv);
     }
-}
+}

src/Bonsai.ML.Torch/LinearAlgebra/LeastSquaresSolve.cs

@@ -0,0 +1,57 @@
+using System;
+using System.ComponentModel;
+using System.Reactive.Linq;
+using static TorchSharp.torch;
+
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that computes the solution to the least squares and least norm problems for a full rank matrix A of size m*n and a matrix B of size m*k.
+/// </summary>
+[Combinator]
+[Description("Computes the solution to the least squares and least norm problems for a full rank matrix A of size m*n and a matrix B of size m*k.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class LeastSquaresSolve
+{
+    /// <summary>
+    /// Computes the solution to the least squares and least norm problems for a full rank matrix A of size m*n and a matrix B of size m*k.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<LeastSquaresResult> Process(IObservable<Tuple<Tensor, Tensor>> source)
+    {
+        return source.Select(value => new LeastSquaresResult(linalg.lstsq(value.Item1, value.Item2)));
+    }
+
+    /// <summary>
+    /// Represents the result of solving of linear equations using the least squares method.
+    /// </summary>
+    /// <param name="result"></param>
+    public readonly struct LeastSquaresResult((
+        Tensor solution,
+        Tensor residuals,
+        Tensor rank,
+        Tensor singularValues
+    ) result)
+    {
+        /// <summary>
+        /// The solution to the system of equations.
+        /// </summary>
+        public Tensor Solution => result.solution;
+
+        /// <summary>
+        /// The residual error.
+        /// </summary>
+        public Tensor Residuals => result.residuals;
+
+        /// <summary>
+        /// The effective rank of the solution.
+        /// </summary>
+        public Tensor Rank => result.rank;
+
+        /// <summary>
+        /// The singular values of the solution.
+        /// </summary>
+        public Tensor SingularValues => result.singularValues;
+    }
+}

src/Bonsai.ML.Torch/LinearAlgebra/MatrixMultiply.cs

@@ -0,0 +1,123 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Reactive.Linq;
+using static TorchSharp.torch;
+using static TorchSharp.torch.linalg;
+
+namespace Bonsai.ML.Torch.LinearAlgebra;
+
+/// <summary>
+/// Represents an operator that performs matrix multiplication of 2 or more tensors.
+/// </summary>
+[Combinator]
+[Description("Performs matrix multiplication of 2 or more tensors.")]
+[WorkflowElementCategory(ElementCategory.Transform)]
+public class MatrixMultiply
+{
+    /// <summary>
+    /// Performs matrix multiplication of 2 tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor>> source)
+    {
+        return source.Select(input =>input.Item1.matmul(input.Item2));
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of 3 tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor, Tensor>> source)
+    {
+        return source.Select(input =>
+        {
+            return multi_dot([input.Item1, input.Item2, input.Item3]);
+        });
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of 4 tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor, Tensor, Tensor>> source)
+    {
+        return source.Select(input =>
+        {
+            return multi_dot([input.Item1, input.Item2, input.Item3, input.Item4]);
+        });
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of 5 tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor, Tensor, Tensor, Tensor>> source)
+    {
+        return source.Select(input =>
+        {
+            return multi_dot([input.Item1, input.Item2, input.Item3, input.Item4, input.Item5]);
+        });
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of 6 tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor, Tensor, Tensor, Tensor, Tensor>> source)
+    {
+        return source.Select(input =>
+        {
+            return multi_dot([input.Item1, input.Item2, input.Item3, input.Item4, input.Item5, input.Item6]);
+        });
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of 7 tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tuple<Tensor, Tensor, Tensor, Tensor, Tensor, Tensor, Tensor>> source)
+    {
+        return source.Select(input =>
+        {
+            return multi_dot([input.Item1, input.Item2, input.Item3, input.Item4, input.Item5, input.Item6, input.Item7]);
+        });
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of an array of tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<Tensor[]> source)
+    {
+        return source.Select(multi_dot);
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of a list of tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<IList<Tensor>> source)
+    {
+        return source.Select(multi_dot);
+    }
+
+    /// <summary>
+    /// Performs matrix multiplication of an enumerable of tensors.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <returns></returns>
+    public IObservable<Tensor> Process(IObservable<IEnumerable<Tensor>> source)
+    {
+        return source.Select(input => multi_dot([.. input]));
+    }
+}