实现带有capacity的多维数组tensor

2016-02-16 02:41:46 295 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›
dianyancao dianyancao 墨衍会员 · AI 创作全网分发 墨衍智能分发 通过墨衍一键同步至各平台 可同步平台 CSDN微信公众号微博知乎掘金百家号博客园抖音小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 + 加入社区
纯Rust构建轻量级深度学习推理引擎：CPU架构与TUI可视化实践 深度学习推理作为模型部署的关键环节，其核心原理是将训练好的神经网络模型应用于实际数据预测。传统方案通常依赖GPU加速和复杂框架，而CPU推理凭借其部署简便性和成本优势，在边缘计算和资源受限场景中展现出独特价值。Rust语言凭借内存安全、零成本抽象和最小运行时等特性，为构建高性能推理引擎提供了理想的技术基础。通过实现张量计算、神经网络算子等核心组件，结合终端用户界面（TUI）实现实时监控，这种轻量级方案特别适用于IoT设备、教学演示等对依赖简化有严格要求的应用场景。本文基于Rust生态的ndarray和tui 阅读详情
在实现多维数组，输入的多维数组会改变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>;

};
...全文
基于python的排课表系统,用python编写排课系统 实现一个具体的课程管理系统。(5) 学生可以查看自己选上的课的成绩，以及各个课程的得分、绩点，并给出其平均绩点，但不允许查看年级其他人的成绩。(2) 学生定制专属课表，可以查看整个学期本人的课程安排，包括课程名称、上课时间、上课地点、任课老师、学分等等。(13) 系主任可以查看整个系的全部学生以及他们的平均绩点，可以对每个班进行排名，或者也可以对整个系进行排名。(15) 系主任可以查看整个学期所开设的所有课程，包括这些课程的全部详细信息。(1) 学生基本信息的查询，学生可以对本人的系统登陆密码进行修改。 阅读详情

相关推荐

tensorflow之tf.record实现存浮点数数组

今天小编就为大家分享一篇tensorflow之tf.record实现存浮点数数组，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧

weixin_38580959

Tensorflow分批量读取数据教程

之前的博客里使用tf读取数据都是每次fetch一条记录，实际上大部分时候需要fetch到一个batch的小批量数据，在tf中这一操作的明显变化就是tensor的rank发生了变化，我目前使用的人脸数据集是灰度图像，因此大小是92*112的，所以最开始fetch拿到的图像数据集经过reshape之后就是一个rank为2的tensor，大小是92*112的（如果考虑通道，也可以reshape为rank为3的，即92*112*1）。如果加入batch，比如batch大小为5，那么拿到的tensor的rank就变成了3，大小为5*92*112。 下面规则化的写一下读取数据的一般流程，按照官网的实例，一

weixin_38589795

【信息科学与工程学】计算机科学与自动化——第三百零五篇 计算机系统中的各类运算操作01

编号类型领域运算操作运算类型算法算法的详细设计及数学分析参数列表及参数的数值设计应用场景 (100+条)集合运算​1集合运算关系代数并集 (Union)集合运算归并排序去重合并两个集合，去除重复元素。时间复杂度 O(n+m)，n,m为两集合大小。输入：集合A, B。输出：A∪B。数据集成、多表结果合并、去重后的全量数据提取。2集合运算关系代数交集 (Intersection)集合运算哈希交集找出同时属于两个集合的元素。平均时间复杂度 O(min(n,m))，最坏 O(n*m)。输入：集合A, B。输出：A∩

flyair_China

【信息科学与工程学】计算机科学与自动化——第三百零五篇 计算机系统中的各类运算操作02

编号类型领域运算操作运算类型算法算法的详细设计及数学分析参数列表及参数的数值设计应用场景301集合运算关系代数关系集合Feature Selection (Chi-Square)集合运算卡方检验目标函数：χ2=∑E(O−E)2​ 衡量分类特征与目标的相关性；资源：O(n·d)；条件：离散特征，离散目标；组合约束：值越大相关性越强。 数据结构：列联表。 代码实现（C++）： 特征列，目标列文本分类中的特征选择。302集合运算关系代数关系集合Feature Selection (ANOVA F

flyair_China

高校技术转移办公室人员如何高效开展技术需求挖掘工作？.docx

科易网基于AI模型+行业大数据，在技术转移、成果转化、技术经纪、知识产权、产业创新、科技招商等垂直领域的多样化应用场景，推出科技创新领域的AI+工具与数智化解决方案，推动科技创新与产业创新智能化发展。

BIZKEEN
评论 4
收藏 已收藏
分享
返回顶部
dianyancao
dianyancao
新手乐园 33,315 成员 41,769 内容
+ 加入社区