Merge pull request #127 from marty1885/apichange

Rework indexing system

Author: marty1885

Etaler/Algorithms/SpatialPoolerND.cpp

@@ -35,12 +35,12 @@ SpatialPoolerND::SpatialPoolerND(const Shape& input_shape, size_t kernel_size, s
 	permanences_ = Tensor(output_shape+potential_pool_size, DType::Float, b);
 
 	for(size_t i=0;i<(size_t)output_shape.volume();i++) {
-		svector<Range> write_loc;
+		IndexList write_loc;
 		Shape loc = foldIndex(i, output_shape);
 		for(size_t j=0;j<output_shape.size();j++)
 			write_loc.push_back(loc[j]);
 
-		svector<Range> read_loc(loc.size());
+		IndexList read_loc(loc.size());
 		for(size_t j=0;j<loc.size();j++) {
 			intmax_t pos = loc[j]*stride;
 			read_loc[j] = range(pos, pos+kernel_size);

Etaler/Backends/CPUBackend.cpp

@@ -594,10 +594,8 @@ void CPUBackend::assign(TensorImpl* dest, const TensorImpl* src)
 		throw EtError("Shape mismatch in tensor assignment. Shape "
 			+ to_string(dest->shape()) + " and " + to_string(src->shape()));
 
-	auto source = realize(src);
-
-	if(dest->dtype() != source->dtype())
-		source = cast(source.get(), dest->dtype());
+	if(dest->dtype() != src->dtype())
+		assign(dest, cast(src, dest->dtype()).get());
 
 	dispatch(dest->dtype(), [&](auto v) {
 		using T = decltype(v);

Etaler/Core/Tensor.cpp

@@ -168,8 +168,9 @@ bool Tensor::isSame(const Tensor& other) const
 	return (*this == other).sum().item<int32_t>() == (int32_t)size();
 }
 
-Tensor Tensor::view(svector<Range> ranges) const
+Tensor Tensor::view(const svector<std::variant<Range, intmax_t, int, size_t, unsigned int>>& rgs) const
 {
+	auto ranges = rgs;
 	if(ranges.size() > dimentions())
 		throw EtError("Cannot view a tensor of " + std::to_string(dimentions()) + " with " + std::to_string(ranges.size()) + " dimentions");
 
@@ -196,16 +197,20 @@ Tensor Tensor::view(svector<Range> ranges) const
 
 	assert(viewed_strides.size() == dimentions());
 
-	for(size_t i=0;i<dimentions();i++) {
-		const Range& r = ranges[i];
+	for(size_t i=0;i<dimentions();i++) { std::visit([&](auto index_range) { // <- make the code neater
+		const auto& r = index_range;
 		intmax_t dim_size = shape()[i];
 
-		intmax_t start = r.start().value_or(0);
-		intmax_t stop = r.stop().value_or(dim_size);
+		// Try to resolve the indexing details
+		auto [start, stop, step, keep_dim] = [&r, dim_size]() -> std::tuple<intmax_t, intmax_t, intmax_t, bool> {
+			if constexpr(std::is_same_v<std::decay_t<decltype(r)>, Range> == true)
+				return {r.start().value_or(0), r.stop().value_or(dim_size), r.step().value_or(1), true};
+			else // is a integer
+				return {r, r+1, (r<0?-1:1), false};
+		}();
 
 		intmax_t real_start = resolve_index(start, dim_size);
 		intmax_t real_stop = resolve_index(stop, dim_size);
-		intmax_t step = r.step().value_or(real_stop>real_start?1:-1);
 		intmax_t size = (std::abs(real_stop - real_start) - 1) / std::abs(step) + 1;
 
 		// Indexing validations
@@ -221,11 +226,11 @@ Tensor Tensor::view(svector<Range> ranges) const
 		viewed_strides[i] *= step;
 
 		offset.push_back(real_start);
-		if(size != 1 || result_shape.empty() == false) { //Ignore heading 1 dimentions
+		if(keep_dim) {
 			result_shape.push_back(size);
 			result_stride.push_back(viewed_strides[i]);
 		}
-	}
+	}, ranges[i]); }
 
 	//If all dims are 1, thus no shape. Give it a shape
 	if(result_shape.empty() == true) {
@@ -337,7 +342,7 @@ Tensor et::cat(const svector<Tensor>& tensors, intmax_t dim)
 	Tensor res = Tensor(res_shape, base_dtype, base_backend);
 
 	intmax_t pos = 0;
-	svector<Range> ranges;
+	IndexList ranges;
 	for(size_t i=0;i<res_shape.size();i++)
 		ranges.push_back(et::all());
 

Etaler/Core/Tensor.hpp

@@ -45,6 +45,8 @@ struct ETALER_EXPORT TensorIterator
 	difference_type operator- (const ThisIterator& rhs) const { return offset_ - rhs.offset_; }
 	ThisIterator operator+(intmax_t n) {return ThisIterator(t_,offset_+n);}
 	ThisIterator operator-(intmax_t n) {return ThisIterator(t_,offset_-n);}
+	ThisIterator& operator+=(intmax_t n) { offset_+=n; return *this; }
+	ThisIterator& operator-=(intmax_t n) { offset_-=n; return *this; }
 	value_type operator[](intmax_t n) { return *operator+(n); }
 	bool operator< (const ThisIterator& rhs) const { return offset_ < rhs.offset_; }
 	bool operator> (const ThisIterator& rhs) const { return offset_ > rhs.offset_; }
@@ -60,6 +62,8 @@ Tensor ETALER_EXPORT brodcast_to(const Tensor& t, Shape s);
 ETALER_EXPORT std::ostream& operator<< (std::ostream& os, const Tensor& t);
 std::string to_string(const Tensor& t);
 
+using IndexList = svector<std::variant<Range, intmax_t, int, size_t, unsigned int>>;
+
 struct ETALER_EXPORT Tensor
 {
 	Tensor() = default;
@@ -142,7 +146,7 @@ struct ETALER_EXPORT Tensor
 	Tensor copy() const;
 
 	//View/Indexing
-	Tensor view(svector<Range> ranges) const;
+	Tensor view(const IndexList& ranges) const;
 
 	Tensor reshape(Shape shape) const
 	{
@@ -220,6 +224,12 @@ struct ETALER_EXPORT Tensor
 	inline bool any() const { return cast(DType::Bool).sum(std::nullopt, DType::Bool).item<uint8_t>(); }
 	inline bool all() const { return cast(DType::Bool).sum(std::nullopt).item<int32_t>() == int32_t(size()); }
 
+	// Neumeric operations
+	Tensor operator+= (const Tensor& other) { *this = *this + other; return *this; }
+	Tensor operator-= (const Tensor& other) { *this = *this - other; return *this; }
+	Tensor operator*= (const Tensor& other) { *this = *this * other; return *this; }
+	Tensor operator/= (const Tensor& other) { *this = *this / other; return *this; }
+
 	Tensor operator- () const {return negate();}
 	Tensor operator+ () const {return *this;}
 	Tensor operator! () const {return logical_not();}
@@ -241,7 +251,7 @@ struct ETALER_EXPORT Tensor
 	Tensor operator!= (const Tensor& other) const {return !equal(other);}
 
 	//Subscription operator
-	Tensor operator [] (svector<Range> r) { return view(r); }
+	Tensor operator [] (const IndexList& r) { return view(r); }
 
 	Tensor sum(std::optional<intmax_t> dim=std::nullopt, DType dtype=DType::Unknown) const;
 	Tensor abs() const { return backend()->abs(pimpl()); }

Etaler/Core/Views.hpp

@@ -14,10 +14,6 @@ namespace et
 struct Range
 {
 	Range() = default;
-	Range(intmax_t start)
-		: start_(start), stop_(start+(start>=0?1:-1))
-	{}
-
 	Range(std::optional<intmax_t> start, intmax_t stop
 		, std::optional<intmax_t> step = std::nullopt)
 		: start_(start), stop_(stop), step_(step)

tests/common_tests.cpp

@@ -9,6 +9,7 @@
 #include <Etaler/Algorithms/SDRClassifer.hpp>
 
 #include <numeric>
+#include <execution>
 
 using namespace et;
 
@@ -219,6 +220,14 @@ TEST_CASE("Testing Tensor", "[Tensor]")
 			CHECK(realize(r).isSame(pred));
 		}
 
+		SECTION("Indexing a column") {
+			Tensor q = t.view({all(), 0});
+			int arr[] = {0, 4, 8, 12};
+			Tensor r = Tensor({4}, arr);
+			CHECK(q.shape() == Shape({4}));
+			CHECK(r.isSame(q));
+		}
+
 		SECTION("Indexing with negative values") {
 			Tensor q = t.view({3});
 			Tensor r;
@@ -285,7 +294,7 @@ TEST_CASE("Testing Tensor", "[Tensor]")
 		}
 
 		SECTION("subscription operator") {
-			svector<Range> r = {range(2)};
+			IndexList r = {range(2)};
 			//The [] operator should work exactly like the view() function
 			CHECK(t[r].isSame(t.view(r)));
 		}
@@ -938,6 +947,12 @@ TEST_CASE("Type system")
 // This test checks all components of Tensor works together properly
 TEST_CASE("Complex Tensor operations")
 {
+	std::vector<int> v1 = {1, 8, 6, 7
+			, 3, 2, 5, 6
+			, 4, 3, 2, 7
+			, 9, 0 ,1, 1};
+	Tensor a = Tensor(v1).reshape({4,4});
+
 	SECTION("Vector inner product") {
 		std::vector<int> v1 = {1, 6, 7, 9, 15, 6};
 		std::vector<int> v2 = {3, 7, 8, -1, 6, 15};
@@ -948,25 +963,23 @@ TEST_CASE("Complex Tensor operations")
 		CHECK((a*b).sum().item<int>() == std::inner_product(v1.begin(), v1.end(), v2.begin(), 0));
 	}
 
+	SECTION("assign column to row") {
+		std::vector<int> v2 = {9, 0, 1, 1};
+		Tensor b = Tensor(v2);
+
+		Tensor t = a.copy();
+		t[{all(), 1}] = a[{3}];
+		CHECK(t[{all(), 1}].isSame(b));
+	}
+
 	SECTION("shuffle") {
 		std::mt19937 rng;
-		std::vector<int> v1 = {1, 8, 6, 7
-			, 3, 2, 5, 6
-			, 4, 3, 2, 7
-			, 9, 0 ,1, 1};
-		Tensor a = Tensor(v1).reshape({4,4});
 		std::shuffle(a.begin(), a.end(), rng);
 		CHECK(std::accumulate(v1.begin(), v1.end(), 0) == a.sum().item<int>());
 	}
 
 	SECTION("find_if") {
-		std::vector<int> v1 = {1, 8, 6, 7
-			, 3, 2, 5, 6
-			, 4, 3, 2, 7
-			, 9, 0 ,1, 1};
-		Tensor a = Tensor(v1).reshape({4,4});
 		Tensor b = a[{0}];
-
 		CHECK(std::find_if(a.begin(), a.end(), [&b](auto t){ return t.isSame(b); }) != a.end());
 	}
 
@@ -976,6 +989,17 @@ TEST_CASE("Complex Tensor operations")
 		std::transform(a.begin(), a.end(), b.begin(), [](const auto& t){return zeros_like(t);});
 		CHECK(b.isSame(zeros_like(a)));
 	}
+
+	SECTION("accumulate") {
+		// Test summing along the first dimension. Making sure iterator and sum() works
+		// Tho you should always use the sum() function instead of accumulate or reduce
+		Tensor t = std::accumulate(a.begin(), a.end(), zeros({a.shape()[1]}));
+		Tensor q = std::reduce(std::execution::par, a.begin(), a.end(), zeros({a.shape()[1]}));
+		Tensor a_sum = a.sum(0);
+		CHECK(t.isSame(a_sum));
+		CHECK(q.isSame(a_sum));
+		CHECK(t.isSame(q)); // Should be communicative
+	}
 }
 
 // TEST_CASE("Serealize")