实现带有capacity的多维数组tensor

dianyancao 2016-02-16 02:41:46

在实现多维数组，输入的多维数组会改变size
看了两个库
boost和Eigen
boost的resize每次都会重新申请内存，这样效率比较低
Eigen有tensor类型，但是没有使用文档支持，不会用
因此想自己实现，有好用的库推荐吗？

【一些基本的操作】
resize改变tensor大小,有容量capacity，当tensor大小小于容量时不重新申请内存
reshape改变tensor形状，不改变其大小
transpose转置指定的维度
flip翻转指定的维度
squeeze去除大小为1的维度
operator[](size_t)当数据存放是连续时，按一维下标访问元素

转置和翻转是常数时间操作，只改变访问tensor元素的方式(线性索引)，不复制数据
【tensor】
tensor持有数据，支持resize，其数据存放是连续的，支持reshape，切割后返回tensor_view
【tensor_view】
tensor_view将某段内存按tensor解释，不支持resize，其数据存放可以是不连续的，
当其查看的数据是连续时，支持reshape，切割后返回tensor_view
【tensor_base】
tensor和tensor_view继承自tensor_base，tensor_base提供tensor和tensor_view的共同成员

为了访问效率，编译时应该确定tensor的rank维度数？
tensor内部数据data_采用共享指针std::share_ptr<std::vector<T>>管理new出的std::vector，
tensor_view内部数据data_准备采用数据指针或者std::vector<T>::iterator迭代器
为了避免直接用原始指针访问数据带来的不安全，有更好的方案提供内部数据吗？

以下是代码：
tensor_view_t.h 空
const_tensor_view_t.h 空

tensor_base_t.h

#include <vector>

#include <memory>

#include <algorithm>

#include <assert.h>



typedef int layer_size_t;



template<typename T>

class range_t

{

public:

	range_t()

	{

		full_ = true;

	}

	range_t(T begin, T end, T step = T(1))

	{

		assert(begin < end);

		begin_ = begin;

		end_ = end;

		step_ = step;

		full_ = false;

	}

	size_t size()

	{

		size_t ret = (end_ - begin_) / step_ + 1;

		if ((end_ - begin_) % step_ == 0) ret--;

		return ret;

	}

	size_t size() const

	{

		size_t ret = (end_ - begin_) / step_ + 1;

		if ((end_ - begin_) % step_ == 0) ret--;

		return ret;

	}

	T begin_;

	T end_;

	T step_;

	bool full_;

};



typedef range_t<size_t> range_type;



template<typename T>

class extents_t

{

public:

	extents_t<T>& operator[](const range_t<T>& range)

	{

		ranges.push_back(range);

		return *this;

	}

	extents_t<T>& operator[](T index)

	{

		ranges.push_back(range_t<T>(index, index + 1));

		return *this;

	}

	std::vector<range_t<T>> ranges;

};



typedef extents_t<size_t> extents_type;



template<typename derived,typename value_type,typename data_type>

class tensor_base_t

{

public:

	typedef typename int index_value;//signed

	typedef typename std::vector<index_value> shape_type;

	typedef typename shape_type index_type;

	typedef typename derived tensor_type;

	typedef typename value_type value_type;

	typedef typename std::vector<value_type> vector_type;

	typedef typename data_type data_type;

protected:

	data_type data_;

	bool continuous_;



	int offset_;

	shape_type shape_;

	index_type steps_;

	size_t size_;

public:

	tensor_base_t() = default;

	void assign(const std::initializer_list<value_type>& vec)

	{

		assert(size_ == vec.size());

		(*data_).assign(vec.begin(), vec.end());

	}

	derived& operator =(derived& tensor)

	{

		data_ = tensor.data();

		offset_ = tensor.offset();

		size_ = tensor.size();

		shape_ = tensor.shape();

		steps_ = tensor.steps();



		return *this;

	}

	void reshape(const std::initializer_list<size_t>& sizes_list)

	{

		reshape(shape_type(sizes_list));

	}

	void reshape(const shape_type& shape)//if this failed please clone this tensor to itself

	{

		size_t size = calculate_size(shape);

		assert(offset_ == 0 && size_ == (*data).size());

		assert(size == size_);

		shape_ = shape;

		init_steps();

	}

	const data_type& data()

	{

		return data_;

	}

	bool continuous()

	{

		return continuous_;

	}

	derived clone()//iterate through view and copy data

	{

		derived ret(shape_);

		index_type index(shape_.size(), 0);

		bool finish = false;



		while (true)

		{

			for (size_t i = 0; i < shape_.size(); ++i)

			{

				if (index[i] == shape_[i])

				{

					if (i == shape_.size() - 1)

					{

						finish = true;

						break;

					}

					index[i] = 0;

					index[i + 1]++;

				}

				else{

					break;

				}

			}

			if (finish) break;



			ret(index) = (*this)(index);

			index[0]++;

		}

		return ret;

	}

	derived operator()(const extents_type& extents)

	{

		derived ret(*static_cast<derived*>(this));

		const auto& ranges = extents.ranges;

		assert(dims() == ranges.size());



		for (size_t i = 0; i < ranges.size(); ++i)

		{

			if (ranges[i].full_) continue;

			ret.offset_ += ranges[i].begin_ * ret.steps_[i];

			ret.shape_[i] = ranges[i].size();

			ret.steps_[i] *= ranges[i].step_;

			ret.update_size();

		}



		ret.squeeze();



		return ret;

	}



	void squeeze()//去除大小为1的维度

	{

		for (size_t i = 0; i < shape_.size(); ++i)

		{

			if (shape_[i] == 1)

			{

				shape_.erase(shape_.begin() + i);

				steps_.erase(steps_.begin() + i);

			}

		}

	}

	void transpose(const std::initializer_list<size_t>& permutation)

	{

		assert(permutation.size() == dims());

		index_type index(dims());



		for (size_t i = 0; i < dims(); ++i)

		{

			index[i] = i;

		}

		assert(std::is_permutation(permutation.begin(), permutation.end(), index.begin()));

		index_type steps(dims());



		for (size_t i = 0; i < dims(); ++i)

		{

			steps[permutation.begin()[i]] = steps_[i];

		}

		steps_ = steps;

	}

	void flip(const std::initializer_list<bool>& flip_flags)

	{

		assert(flip_flags.size() == dims());

		for (size_t i = 0; i < shape_.size(); ++i)

		{

			if (flip_flags.begin()[i] == false) continue;

			offset_ += (shape_[i] - 1) * steps_[i];

			steps_[i] *= -1;

		}

	}



	value_type& operator()(const std::initializer_list<index_value>& index)

	{

		return (*data_)[_index(index)];

	}

	const value_type& operator()(const std::initializer_list<index_value>& index) const

	{

		return (*data_)[_index(index)];

	}

	value_type& operator()(const index_type& index)

	{

		return (*data_)[_index(index)];

	}

	const value_type& operator()(const index_type&& index) const

	{

		return (*data_)[_index(index)];

	}



	value_type& operator[](size_t index)

	{

#if _ITERATOR_DEBUG_LEVEL == 2

		assert(offset_ == 0 && size_ == (*data_).size());

#endif

		return (*data_)[index];

	}

	const value_type& operator[](size_t index) const

	{

#if _ITERATOR_DEBUG_LEVEL == 2

		assert(offset_ == 0 && size_ == (*data_).size());

#endif

		return (*data_)[index];

	}

private:

	/*

	template<int ndims>

	size_t index(const std::vector<T>& coordinate)

	{

	return coordinate[ndims - 1] * steps_[ndims - 1] + index<ndims - 1>(coordinate);

	}

	template<>

	size_t index<0>(const std::vector<T>& coordinate)

	{

	return 0;

	}

	*/

	size_t _index(const std::initializer_list<index_value>& coordinate)

	{

		return _index(index_type(coordinate));

	}

	size_t _index(const index_type& coordinate)

	{

		int ret = offset_;

		const size_t ndims = coordinate.size();

#if _ITERATOR_DEBUG_LEVEL == 2

		assert(ndims == dims());

#endif

		for (size_t i = 0; i < ndims; ++i)

		{

#if _ITERATOR_DEBUG_LEVEL == 2

			if (coordinate[i] >= shape_[i])

			{	// report error

				_DEBUG_ERROR("tensor subscript out of range");

				_SCL_SECURE_OUT_OF_RANGE;

			}

#endif

			ret += coordinate[i] * steps_[i];

		}

		return ret;

	}

public:

	const index_type& shape()

	{

		return shape_;

	}

	const index_type& shape() const

	{

		return shape_;

	}

	index_value shape(size_t i)

	{

		return shape_[i];

	}

	index_value shape(size_t i) const

	{

		return shape_[i];

	}

	const index_type& steps()

	{

		return steps_;

	}

	const index_type& steps() const

	{

		return steps_;

	}

	size_t size()

	{

		return size_;

	}

	size_t size() const

	{

		return size_;

	}

	size_t dims()

	{

		return shape_.size();

	}

	size_t dims() const

	{

		return shape_.size();

	}

	int offset()

	{

		return offset_;

	}

	int offset() const

	{

		return offset_;

	}

protected:

	size_t calculate_size(const shape_type& shape)

	{

		double product = 1;

		size_t size = 1;

		for (auto& v : shape)

		{

			product *= v;

			size *= v;

		}

		assert(product < std::numeric_limits<size_t>::max());//check whether size overflow



		return size;

	}

	void update_size()

	{

		size_ = calculate_size(shape_);

	}

	void init_steps()

	{

		steps_.resize(shape_.size());

		std::fill(steps_.begin(), steps_.end(), 1);

		for (size_t i = 1; i < steps_.size(); ++i)

			for (size_t k = 0; k < i; ++k)

				steps_[i] *= shape_[k];

	}

public:

	friend class tensor_base_t<derived,value_type,data_type>;

};

...全文

174 4 打赏收藏转发到动态举报

写回复

用AI写文章

4 条回复

切换为时间正序

请发表友善的回复…

发表回复

赵4老师 2016-02-17

打赏
举报

引用 3 楼 dianyancao 的回复:

[quote=引用 2 楼 zhao4zhong1 的回复:] 仅供参考：
//在堆中开辟一个2×3×4×5的4维int数组

这个多维数组数据不是连续存放的，效率比较低我用的是通过index_用一维方式访问数组[/quote] 无profiler不要谈效率！！尤其在这个云计算、虚拟机、模拟器、CUDA、多核、多级cache、指令流水线、多种存储介质、……满天飞的时代！

赵4老师 2016-02-16

打赏
举报

仅供参考：

//在堆中开辟一个2×3×4×5的4维int数组
#include <stdio.h>
#include <malloc.h>
int ****p;
int h,i,j,k;
void main() {
    p=(int ****)malloc(2*sizeof(int ***));
    if (NULL==p) return;
    for (h=0;h<2;h++) {
        p[h]=(int ***)malloc(3*sizeof(int **));
        if (NULL==p[h]) return;
        for (i=0;i<3;i++) {
            p[h][i]=(int **)malloc(4*sizeof(int *));
            if (NULL==p[h][i]) return;
            for (j=0;j<4;j++) {
                p[h][i][j]=(int *)malloc(5*sizeof(int));
                if (NULL==p[h][i][j]) return;
            }
        }
    }
    for (h=0;h<2;h++) {
        for (i=0;i<3;i++) {
            for (j=0;j<4;j++) {
                for (k=0;k<5;k++) {
                    p[h][i][j][k]=h*60+i*20+j*5+k;
                }
            }
        }
    }
    for (h=0;h<2;h++) {
        for (i=0;i<3;i++) {
            for (j=0;j<4;j++) {
                for (k=0;k<5;k++) {
                    printf(" %3d",p[h][i][j][k]);
                }
                printf("\n");
            }
            printf("--------------------\n");
        }
        printf("=======================\n");
    }
    for (h=0;h<2;h++) {
        for (i=0;i<3;i++) {
            for (j=0;j<4;j++) {
                free(p[h][i][j]);
            }
            free(p[h][i]);
        }
        free(p[h]);
    }
    free(p);
}
//   0   1   2   3   4
//   5   6   7   8   9
//  10  11  12  13  14
//  15  16  17  18  19
//--------------------
//  20  21  22  23  24
//  25  26  27  28  29
//  30  31  32  33  34
//  35  36  37  38  39
//--------------------
//  40  41  42  43  44
//  45  46  47  48  49
//  50  51  52  53  54
//  55  56  57  58  59
//--------------------
//=======================
//  60  61  62  63  64
//  65  66  67  68  69
//  70  71  72  73  74
//  75  76  77  78  79
//--------------------
//  80  81  82  83  84
//  85  86  87  88  89
//  90  91  92  93  94
//  95  96  97  98  99
//--------------------
// 100 101 102 103 104
// 105 106 107 108 109
// 110 111 112 113 114
// 115 116 117 118 119
//--------------------
//=======================
//

dianyancao 2016-02-16

打赏
举报

引用 2 楼 zhao4zhong1 的回复:

仅供参考：

//在堆中开辟一个2×3×4×5的4维int数组

这个多维数组数据不是连续存放的，效率比较低我用的是通过index_用一维方式访问数组

dianyancao 2016-02-16

打赏
举报

tensor_t.h

#pragma once

#include "tensor_base_t.h"

//当数组维度大于等于2时才使用tensor_base_t，否则使用std::vector
template<typename value_type>
class tensor_t : public tensor_base_t < tensor_t<value_type>, value_type, std::shared_ptr<std::vector<value_type>> >
{
public:
	typedef typename int index_value;//signed
	typedef typename std::vector<index_value> shape_type;
	typedef typename shape_type index_type;
	typedef typename tensor_base_t < tensor_t<value_type>, value_type, std::shared_ptr<std::vector<value_type>>> base;

	typedef typename base::value_type value_type;
	typedef typename base::tensor_type tensor_type;
	typedef typename base::vector_type vector_type;
	typedef typename base::data_type data_type;
public:
	tensor_t()
	{
		reset(1, 0);
	}
	tensor_t(const std::initializer_list<index_value>& sizes_list, const value_type& value = value_type())
	{
		reset(sizes_list, value);
	}
	tensor_t(const shape_type& shape, const value_type& value = value_type())
	{
		reset(shape, value);
	}
	tensor_t(tensor_type& tensor)
	{
		*this = tensor;
	}
	void reset(const shape_type& shape, const value_type& value = value_type())
	{
		data_.reset(new vector_type());
		resize(shape, value);
	}
	void reset(size_t size, const value_type& value = value_type())
	{
		data_.reset(new vector_type());
		resize(size, value);
	}
	void resize(const size_t& size1, const value_type& value = value_type())
	{
		resize(shape_type(1, size1), value);
	}
	void resize(const std::initializer_list<index_value>& list, const value_type& value = value_type())
	{
		resize(shape_type(list), value);
	}
	void resize(const shape_type& shape, const value_type& value = value_type()) //after resize the data is dirty,must manual initialize data
	{
		size_t size = calculate_size(shape);
		assert(size > 0);
		(*data_).resize(size, value);
		offset_ = 0;
		size_ = size;
		shape_ = shape;
		init_steps();
		squeeze();
	}
};

main.cpp

#include <iostream>
#include <time.h>
#include "tensor_t.h"

using namespace std;

int main()
{
	tensor_t<double> tensor;
	tensor.reset({ 2, 3, 5 });//重新分配内存，并设置形状

	tensor({ 1, 0, 2 }) = 123456;//对给定位置的元素赋值
	cout << tensor({ 1, 0, 2 }) << std::endl; //123456
	cout << tensor[1 + 0 * 2 + 2 * 2 * 3] << std::endl; //123456
	
	tensor.assign({ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		2, 2, 2, 2, 2, 2, 2, 2, 2, 2 });//复制给定数据
	tensor = tensor.clone();//深度拷贝
	cout << tensor({ 1, 0, 2 }) << std::endl; //2

	tensor[1 + 2 * 2 + 2 * 2 * 3] = 2345;//按一维下标访问多维数组
	tensor_t<double> tensor2 = tensor(extents_type()[1][range_type()][range_type(0, 5, 2)]);//切割数组
	cout << tensor2({ 2,1 }) << std::endl;//2345
	tensor2.transpose({ 1, 0 });//按排列转置数组
	cout << tensor2({ 1, 2 }) << std::endl;//2345

	tensor2.flip({ false, true });//翻转数组的指定维度
	cout << tensor2({  1, 3 - 1 - 2 }) << std::endl;//2345

	system("PAUSE");
	return 0;
}