tensor:基础算子完成

Author: miaobyte

dl/array_math.go

@@ -43,3 +43,10 @@ func Div[T Number](a, b []T) (c []T) {
 	}
 	return
 }
+
+func Max[T Number](a, b T) T {
+	if a > b {
+		return a
+	}
+	return b
+}

dl/tensor_op_l2.go

@@ -0,0 +1,78 @@
+package dl
+
+func (t *Tensor[T]) BroadcastShape(shape []int) []int {
+	maxShape := Max(len(t.Shape), len(shape))
+	result := make([]int, maxShape)
+	for i := 1; i <= maxShape; i++ {
+		var dim1 int
+		if i <= len(t.Shape) {
+			dim1 = t.Shape[len(t.Shape)-i]
+		} else {
+			dim1 = 1
+		}
+		var dim2 int
+		if i <= len(shape) {
+			dim2 = shape[len(shape)-i]
+		} else {
+			dim2 = 1
+		}
+
+		if dim1 != dim2 && dim1 != 1 && dim2 != 1 {
+			return nil
+		}
+		result[maxShape-i] = Max(dim1, dim2)
+	}
+	return result
+}
+
+type BroadcastCase int
+
+const (
+	XToX BroadcastCase = iota
+	NullTo1
+	XTo1
+)
+
+func (t *Tensor[T]) BroadcastMap(broadcastShape []int) []BroadcastCase {
+	broadcastMap := make([]BroadcastCase, len(broadcastShape))
+	s := len(broadcastShape) - len(t.Shape)
+	for i := 0; i < s; i++ {
+		broadcastMap[i] = NullTo1
+	}
+	for i := s; i < len(broadcastShape); i++ {
+		if t.Shape[i-s] == broadcastShape[i] {
+			broadcastMap[i] = XToX
+		} else if t.Shape[i-s] == 1 {
+			broadcastMap[i] = XTo1
+		} else {
+			panic("Shapes are not broadcastable for operation")
+		}
+	}
+	return broadcastMap
+}
+func FromBroadcastIndices(broadcastMap []BroadcastCase, broadcastIndices []int) (indices []int) {
+	indices = make([]int, 0)
+	for i, j := 0, 0; i < len(broadcastIndices); i++ {
+		switch broadcastMap[i] {
+		case XToX:
+			indices = append(indices, broadcastIndices[i])
+			j++
+		case NullTo1:
+			continue
+		case XTo1:
+			indices = append(indices, 0)
+			j++
+		}
+	}
+	return
+}
+func (t *Tensor[T]) Broadcast(broadcastShape []int) *Tensor[T] {
+	broadcastMap := t.BroadcastMap(broadcastShape)
+	result := NewTensor[T](broadcastShape)
+
+	result.Range(len(broadcastShape), func(indices []int) {
+		oldIndices := FromBroadcastIndices(broadcastMap, indices)
+		result.Set(indices, t.Get(oldIndices...))
+	})
+	return result
+}

dl/tensor_op_l2_test.go

@@ -0,0 +1,11 @@
+package dl
+
+import "testing"
+
+func TestBroadcast(t *testing.T) {
+	a := NewTensor[float32]([]int{2, 3})
+	a.Linear(1, float64(a.Len()))
+	bShape := a.BroadcastShape([]int{3, 2, 3})
+	b := a.Broadcast(bShape)
+	b.Print("%0.f")
+}

dl/tensor_op_l3.go

@@ -101,3 +101,64 @@ func (t *Tensor[T]) Sum(dims []int) *Tensor[T] {
 	})
 	return result
 }
+
+func (t *Tensor[T]) OpTensorInPlace(other *Tensor[T], op func(a, b T) T) {
+	if Equal(t.Shape, other.Shape) {
+		t.Range(len(t.Shape), func(indices []int) {
+			t.Set(indices, op(t.Get(indices...), other.Get(indices...)))
+		})
+		return
+	}
+	broadcastShape := t.BroadcastShape(other.Shape)
+	if broadcastShape == nil {
+		panic("shapes are not broadcastable for inplace operation,my shape:" + fmt.Sprint(t.Shape) + " other shape:" + fmt.Sprint(other.Shape))
+	}
+	if !Equal(t.Shape, broadcastShape) {
+		panic("shapes are not broadcastable for inplace operation,my shape:" + fmt.Sprint(t.Shape) + " broadcastedShape:" + fmt.Sprint(broadcastShape))
+	}
+	otherMap := other.BroadcastMap(broadcastShape)
+	t.Range(len(t.Shape), func(indices []int) {
+		otherIndices := FromBroadcastIndices(otherMap, indices)
+		t.Set(indices, op(t.Get(indices...), other.Get(otherIndices...)))
+	})
+}
+
+func (t *Tensor[T]) OpNumberInPlace(other T, op func(a, b T) T) {
+	for i := 0; i < t.Len(); i++ {
+		t.Data[i] = op(t.Data[i], other)
+	}
+}
+
+func (t *Tensor[T]) AddInPlace(other *Tensor[T]) *Tensor[T] {
+	t.OpTensorInPlace(other, func(a, b T) T { return a + b })
+	return t
+}
+func (t *Tensor[T]) AddNumberInPlace(other T) *Tensor[T] {
+	t.OpNumberInPlace(other, func(a, b T) T { return a + b })
+	return t
+}
+
+func (t *Tensor[T]) SubInPlace(other *Tensor[T]) *Tensor[T] {
+	t.OpTensorInPlace(other, func(a, b T) T { return a - b })
+	return t
+}
+func (t *Tensor[T]) SubNumberInPlace(other T) *Tensor[T] {
+	t.OpNumberInPlace(other, func(a, b T) T { return a - b })
+	return t
+}
+func (t *Tensor[T]) MulInPlace(other *Tensor[T]) *Tensor[T] {
+	t.OpTensorInPlace(other, func(a, b T) T { return a * b })
+	return t
+}
+func (t *Tensor[T]) MulNumberInPlace(other T) *Tensor[T] {
+	t.OpNumberInPlace(other, func(a, b T) T { return a * b })
+	return t
+}
+func (t *Tensor[T]) DivInPlace(other *Tensor[T]) *Tensor[T] {
+	t.OpTensorInPlace(other, func(a, b T) T { return a / b })
+	return t
+}
+func (t *Tensor[T]) DivNumberInPlace(other T) *Tensor[T] {
+	t.OpNumberInPlace(other, func(a, b T) T { return a / b })
+	return t
+}

dl/tensor_op_l3_test.go

@@ -0,0 +1,75 @@
+package dl
+
+import (
+	"testing"
+
+	"git.array2d.com/ai/deepgo/py"
+)
+
+func TestTensor_Transpose(t *testing.T) {
+	a := NewTensor([]int{2, 3}, 1, 2, 3, 4, 5, 6)
+	at := a.Transpose([]int{1, 0})
+	at.Print("%d")
+
+	b := NewTensor[float32]([]int{4, 3, 2})
+	b.Linear(0, float64(b.Len()))
+	b.Print()
+	bt := b.Transpose([]int{0, 2, 1})
+	bt.Print("%0.f")
+}
+
+func TestSum(t *testing.T) {
+	testCases := []struct {
+		Data  []float32
+		Shape []int
+	}{
+		{
+			Data:  []float32{-1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0},
+			Shape: []int{3, 3},
+		},
+		{
+			Data:  []float32{1.0, 2.0, -3.0, -4.0, -5.0, 6.0, -7.0, 8.0, 9.0, 10.0},
+			Shape: []int{2, 5},
+		},
+		{
+			Data: []float32{
+				64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49,
+				48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33,
+				32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17,
+				16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
+			},
+			Shape: []int{4, 4, 4},
+		},
+	}
+
+	for index, tc := range testCases {
+		inputTensor := NewTensor(tc.Shape, tc.Data...)
+
+		// 使用 Go 实现计算 Sum
+		axes := []int{0, len(tc.Shape) - 1}
+		goResult := inputTensor.Sum(axes)
+
+		// 使用 Python 计算 Sum
+		pyResult, pyShape, err := py.CalculateA_breturnC("tensor_op_A_b_return_C.py", "sum", tc.Data, tc.Shape, axes)
+		if err != nil {
+			t.Fatalf("计算Python Sum时出错: %v", err)
+		}
+		pyTensor := NewTensor(pyShape, pyResult...)
+		// 比较结果
+		if !TensorAlmostEqual(goResult, pyTensor, 1e-19) {
+			t.Errorf("Sum结果不匹配。\nGo结果: %v\nPy结果: %v", goResult.Data, pyTensor.Data)
+			t.Errorf("shape不匹配。\nGo结果: %v\nPy结果: %v", goResult.Shape, pyTensor.Shape)
+		} else {
+			t.Log("Sum结果与Python一致", index)
+		}
+	}
+}
+
+func TestTensor_AddInPlace(t *testing.T) {
+	a := NewTensor[float32]([]int{2, 3})
+	a.Linear(1, float64(a.Len()))
+	b := NewTensor[float32]([]int{3, 2, 3})
+	b.Linear(1, float64(b.Len()))
+	c := a.AddInPlace(b)
+	c.Print("%0.f")
+}