• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号
登陆 注册

C++ sys::ComputeSystem类代码示例

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

本文整理汇总了C++中sys::ComputeSystem类的典型用法代码示例。如果您正苦于以下问题：C++ ComputeSystem类的具体用法？C++ ComputeSystem怎么用？C++ ComputeSystem使用的例子？那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。



在下文中一共展示了ComputeSystem类的20个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于我们的系统推荐出更棒的C++代码示例。

示例1: 

DoubleBuffer2D neo::createDoubleBuffer2D(sys::ComputeSystem &cs, cl_int2 size) {
	DoubleBuffer2D db;
	
	db[_front] = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), size.x, size.y);
	db[_back] = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), size.x, size.y);

	return db;
}
开发者ID:dsimba，项目名称:NeoRL，代码行数:8，代码来源:Helpers.cpp


示例2: activate

void Predictor::activate(sys::ComputeSystem &cs, const std::vector<cl::Image2D> &visibleStates, NonlinearityType nonlinearityType, bool bufferSwap) {
	// Start by clearing summation buffer
	{
		cl_float4 zeroColor = { 0.0f, 0.0f, 0.0f, 0.0f };

		cl::array<cl::size_type, 3> zeroOrigin = { 0, 0, 0 };
		cl::array<cl::size_type, 3> hiddenRegion = { _hiddenSize.x, _hiddenSize.y, 1 };

		cs.getQueue().enqueueFillImage(_hiddenSummationTemp[_back], zeroColor, zeroOrigin, hiddenRegion);
	}

	for (int vli = 0; vli < _visibleLayers.size(); vli++) {
		VisibleLayer &vl = _visibleLayers[vli];
		VisibleLayerDesc &vld = _visibleLayerDescs[vli];

		int argIndex = 0;

		_activateKernel.setArg(argIndex++, visibleStates[vli]);
		_activateKernel.setArg(argIndex++, _hiddenSummationTemp[_back]);
		_activateKernel.setArg(argIndex++, _hiddenSummationTemp[_front]);
		_activateKernel.setArg(argIndex++, vl._weights[_back]);
		_activateKernel.setArg(argIndex++, vld._size);
		_activateKernel.setArg(argIndex++, vl._hiddenToVisible);
		_activateKernel.setArg(argIndex++, vld._radius);

		cs.getQueue().enqueueNDRangeKernel(_activateKernel, cl::NullRange, cl::NDRange(_hiddenSize.x, _hiddenSize.y));

		// Swap buffers
		std::swap(_hiddenSummationTemp[_front], _hiddenSummationTemp[_back]);
	}

	if (nonlinearityType == _binary) {
		int argIndex = 0;

		_solveHiddenBinaryKernel.setArg(argIndex++, _hiddenSummationTemp[_back]);
		_solveHiddenBinaryKernel.setArg(argIndex++, _hiddenStates[_front]);
	
		cs.getQueue().enqueueNDRangeKernel(_solveHiddenBinaryKernel, cl::NullRange, cl::NDRange(_hiddenSize.x, _hiddenSize.y));
	}
	else if (nonlinearityType == _tanH) {
		int argIndex = 0;

		_solveHiddenTanHKernel.setArg(argIndex++, _hiddenSummationTemp[_back]);
		_solveHiddenTanHKernel.setArg(argIndex++, _hiddenStates[_front]);

		cs.getQueue().enqueueNDRangeKernel(_solveHiddenTanHKernel, cl::NullRange, cl::NDRange(_hiddenSize.x, _hiddenSize.y));
	}
	else
		cs.getQueue().enqueueCopyImage(_hiddenSummationTemp[_back], _hiddenStates[_front], { 0, 0, 0 }, { 0, 0, 0 }, { static_cast<cl::size_type>(_hiddenSize.x), static_cast<cl::size_type>(_hiddenSize.y), 1 });

	// Swap hidden state buffers
	std::swap(_hiddenStates[_front], _hiddenStates[_back]);
}
开发者ID:JamesLinus，项目名称:NeoRL，代码行数:53，代码来源:Predictor.cpp


示例3: activate

void PredictorSwarm::activate(sys::ComputeSystem &cs, const cl::Image2D &targets, const std::vector<cl::Image2D> &visibleStates, const std::vector<cl::Image2D> &visibleStatesPrev, float activeRatio, int inhibitionRadius, float noise, std::mt19937 &rng) {
	// Start by clearing summation buffer
	{
		cl_float4 zeroColor = { 0.0f, 0.0f, 0.0f, 0.0f };

		cl::array<cl::size_type, 3> zeroOrigin = { 0, 0, 0 };
		cl::array<cl::size_type, 3> hiddenRegion = { _hiddenSize.x, _hiddenSize.y, 1 };

		//cs.getQueue().enqueueCopyImage(_hiddenBiases[_back], _hiddenSummationTemp[_back], zeroOrigin, zeroOrigin, hiddenRegion);
		cs.getQueue().enqueueFillImage(_hiddenSummationTemp[_back], cl_float4{ 0.0f, 0.0f, 0.0f, 0.0f }, zeroOrigin, hiddenRegion);
	}

	for (int vli = 0; vli < _visibleLayers.size(); vli++) {
		VisibleLayer &vl = _visibleLayers[vli];
		VisibleLayerDesc &vld = _visibleLayerDescs[vli];

		int argIndex = 0;

		_activateKernel.setArg(argIndex++, visibleStates[vli]);
		_activateKernel.setArg(argIndex++, _hiddenSummationTemp[_back]);
		_activateKernel.setArg(argIndex++, _hiddenSummationTemp[_front]);
		_activateKernel.setArg(argIndex++, vl._weights[_back]);
		_activateKernel.setArg(argIndex++, vld._size);
		_activateKernel.setArg(argIndex++, vl._hiddenToVisible);
		_activateKernel.setArg(argIndex++, vld._radius);

		cs.getQueue().enqueueNDRangeKernel(_activateKernel, cl::NullRange, cl::NDRange(_hiddenSize.x, _hiddenSize.y));

		// Swap buffers
		std::swap(_hiddenSummationTemp[_front], _hiddenSummationTemp[_back]);
	}

	{
		std::uniform_int_distribution<int> seedDist(0, 999);

		cl_uint2 seed = { seedDist(rng), seedDist(rng) };

		int argIndex = 0;

		_solveHiddenKernel.setArg(argIndex++, _hiddenSummationTemp[_back]);
		_solveHiddenKernel.setArg(argIndex++, _hiddenStates[_front]);
		_solveHiddenKernel.setArg(argIndex++, _hiddenActivations[_front]);
		_solveHiddenKernel.setArg(argIndex++, _hiddenSize);
		_solveHiddenKernel.setArg(argIndex++, inhibitionRadius);
		_solveHiddenKernel.setArg(argIndex++, activeRatio);

		cs.getQueue().enqueueNDRangeKernel(_solveHiddenKernel, cl::NullRange, cl::NDRange(_hiddenSize.x, _hiddenSize.y));
	}

	// Swap hidden state buffers
	std::swap(_hiddenStates[_front], _hiddenStates[_back]);
	std::swap(_hiddenActivations[_front], _hiddenActivations[_back]);
}
开发者ID:JamesLinus，项目名称:NeoRL，代码行数:53，代码来源:PredictorSwarm.cpp


示例4: writeToStream

void Predictor::writeToStream(sys::ComputeSystem &cs, std::ostream &os) const {
	abort(); // Not yet working

	os << _hiddenSize.x << " " << _hiddenSize.y << std::endl;

	{
		std::vector<cl_float> hiddenStates(_hiddenSize.x * _hiddenSize.y);

		cs.getQueue().enqueueReadImage(_hiddenStates[_back], CL_TRUE, { 0, 0, 0 }, { static_cast<cl::size_type>(_hiddenSize.x), static_cast<cl::size_type>(_hiddenSize.y), 1 }, 0, 0, hiddenStates.data());

		for (int si = 0; si < hiddenStates.size(); si++)
			os << hiddenStates[si] << " ";

		os << std::endl;
	}

	// Layer information
	os << _visibleLayers.size() << std::endl;

	for (int vli = 0; vli < _visibleLayers.size(); vli++) {
		const VisibleLayer &vl = _visibleLayers[vli];
		const VisibleLayerDesc &vld = _visibleLayerDescs[vli];

		// Desc
		os << vld._size.x << " " << vld._size.y << " " << vld._radius << std::endl;

		// Layer
		int weightDiam = vld._radius * 2 + 1;

		int numWeights = weightDiam * weightDiam;

		cl_int3 weightsSize = cl_int3{ _hiddenSize.x, _hiddenSize.y, numWeights };

		int totalNumWeights = weightsSize.x * weightsSize.y * weightsSize.z;

		{
			std::vector<cl_float> weights(totalNumWeights);

			cs.getQueue().enqueueReadImage(vl._weights[_back], CL_TRUE, { 0, 0, 0 }, { static_cast<cl::size_type>(weightsSize.x), static_cast<cl::size_type>(weightsSize.y), static_cast<cl::size_type>(weightsSize.z) }, 0, 0, weights.data());

			for (int wi = 0; wi < weights.size(); wi++)
				os << weights[wi] << " ";
		}

		os << std::endl;

		os << vl._hiddenToVisible.x << " " << vl._hiddenToVisible.y << " " << vl._visibleToHidden.x << " " << vl._visibleToHidden.y << " " << vl._reverseRadii.x << " " << vl._reverseRadii.y << std::endl;
	}
}
开发者ID:JamesLinus，项目名称:NeoRL，代码行数:49，代码来源:Predictor.cpp


示例5: learn

void Predictor::learn(sys::ComputeSystem &cs, float tdError, const cl::Image2D &targets, std::vector<cl::Image2D> &visibleStatesPrev, float weightAlpha, float weightLambda) {
	// Learn weights
	for (int vli = 0; vli < _visibleLayers.size(); vli++) {
		VisibleLayer &vl = _visibleLayers[vli];
		VisibleLayerDesc &vld = _visibleLayerDescs[vli];

		int argIndex = 0;

		_learnWeightsTracesKernel.setArg(argIndex++, visibleStatesPrev[vli]);
		_learnWeightsTracesKernel.setArg(argIndex++, targets);
		_learnWeightsTracesKernel.setArg(argIndex++, _hiddenStates[_front]);
		_learnWeightsTracesKernel.setArg(argIndex++, vl._weights[_back]);
		_learnWeightsTracesKernel.setArg(argIndex++, vl._weights[_front]);
		_learnWeightsTracesKernel.setArg(argIndex++, vld._size);
		_learnWeightsTracesKernel.setArg(argIndex++, vl._hiddenToVisible);
		_learnWeightsTracesKernel.setArg(argIndex++, vld._radius);
		_learnWeightsTracesKernel.setArg(argIndex++, weightAlpha);
		_learnWeightsTracesKernel.setArg(argIndex++, weightLambda);
		_learnWeightsTracesKernel.setArg(argIndex++, tdError);

		cs.getQueue().enqueueNDRangeKernel(_learnWeightsTracesKernel, cl::NullRange, cl::NDRange(_hiddenSize.x, _hiddenSize.y));

		std::swap(vl._weights[_front], vl._weights[_back]);
	}
}
开发者ID:JamesLinus，项目名称:NeoRL，代码行数:25，代码来源:Predictor.cpp


示例6: learnPrediction

void HEInet::learnPrediction(sys::ComputeSystem &cs, const cl::Image2D &inputImage, float alpha) {
	cl_float2 eFeedForwardDimsToEDims = { static_cast<float>(_eiLayers.front().getConfig()._eWidth + 1) / static_cast<float>(_eiLayers.front().getConfig()._eFeedForwardWidth + 1), static_cast<float>(_eiLayers.front().getConfig()._eHeight + 1) / static_cast<float>(_eiLayers.front().getConfig()._eFeedForwardHeight + 1) };
	cl_float2 eFeedForwardDimsToIDims = { static_cast<float>(_eiLayers.front().getConfig()._iWidth + 1) / static_cast<float>(_eiLayers.front().getConfig()._eFeedForwardWidth + 1), static_cast<float>(_eiLayers.front().getConfig()._iHeight + 1) / static_cast<float>(_eiLayers.front().getConfig()._eFeedForwardHeight + 1) };

	cl_int2 eDims = { _eiLayers.front().getConfig()._eWidth, _eiLayers.front().getConfig()._eHeight };
	cl_int2 iDims = { _eiLayers.front().getConfig()._iWidth, _eiLayers.front().getConfig()._iHeight };

	int index = 0;

	_kernels->_predictionLearnKernel.setArg(index++, _eSpikeSumsIterPrev);
	_kernels->_predictionLearnKernel.setArg(index++, _iSpikeSumsIterPrev);
	_kernels->_predictionLearnKernel.setArg(index++, inputImage);
	_kernels->_predictionLearnKernel.setArg(index++, _predictionPrev);
	_kernels->_predictionLearnKernel.setArg(index++, _predictionFromEWeights._weightsPrev);
	_kernels->_predictionLearnKernel.setArg(index++, _predictionFromIWeights._weightsPrev);
	_kernels->_predictionLearnKernel.setArg(index++, _predictionFromEWeights._weights);
	_kernels->_predictionLearnKernel.setArg(index++, _predictionFromIWeights._weights);

	_kernels->_predictionLearnKernel.setArg(index++, eFeedForwardDimsToEDims);
	_kernels->_predictionLearnKernel.setArg(index++, eFeedForwardDimsToIDims);
	_kernels->_predictionLearnKernel.setArg(index++, eDims);
	_kernels->_predictionLearnKernel.setArg(index++, iDims);
	_kernels->_predictionLearnKernel.setArg(index++, _predictionRadiusFromE);
	_kernels->_predictionLearnKernel.setArg(index++, _predictionRadiusFromI);
	_kernels->_predictionLearnKernel.setArg(index++, alpha);

	cs.getQueue().enqueueNDRangeKernel(_kernels->_predictionLearnKernel, cl::NullRange, cl::NDRange(_eiLayers.front().getConfig()._eFeedForwardWidth, _eiLayers.front().getConfig()._eFeedForwardHeight));
}
开发者ID:222464，项目名称:HEInetGPU，代码行数:28，代码来源:HEInet.cpp


示例7: update

void HEInet::update(sys::ComputeSystem &cs, const cl::Image2D &inputFrequencyImage, const cl::Image2D &zeroImage, float eta, float shDecay, float saDecay) {
	// Update input spikes
	int index = 0;

	_kernels->_updateInputSpikesKernel.setArg(index++, inputFrequencyImage);
	_kernels->_updateInputSpikesKernel.setArg(index++, _inputSpikeTimersPrev);
	_kernels->_updateInputSpikesKernel.setArg(index++, _inputSpikesHistoryPrev);
	_kernels->_updateInputSpikesKernel.setArg(index++, _inputSpikeTimers);
	_kernels->_updateInputSpikesKernel.setArg(index++, _inputSpikes);
	_kernels->_updateInputSpikesKernel.setArg(index++, _inputSpikesHistory);
	_kernels->_updateInputSpikesKernel.setArg(index++, shDecay);

	cs.getQueue().enqueueNDRangeKernel(_kernels->_updateInputSpikesKernel, cl::NullRange, cl::NDRange(_eiLayers.front().getConfig()._eFeedForwardWidth, _eiLayers.front().getConfig()._eFeedForwardHeight));

	const cl::Image2D* pLayerInput = &_inputSpikesPrev;

	// Feed forward
	for (int li = 0; li < _eiLayers.size(); li++) {
		_eiLayers[li].eActivate(cs, *pLayerInput, eta, shDecay, saDecay);

		pLayerInput = &_eiLayers[li]._eLayer._statesPrev;
	}

	pLayerInput = &zeroImage;

	// Feed back
	for (int li = _eiLayers.size() - 1; li >= 0; li--) {
		_eiLayers[li].iActivate(cs, *pLayerInput, eta, shDecay, saDecay);

		pLayerInput = &_eiLayers[li]._iLayer._statesPrev;
	}
}
开发者ID:222464，项目名称:HEInetGPU，代码行数:32，代码来源:HEInet.cpp


示例8: learn

void PredictorSwarm::learn(sys::ComputeSystem &cs, float reward, float gamma, const cl::Image2D &targets, std::vector<cl::Image2D> &visibleStatesPrev, cl_float2 weightAlpha, cl_float2 weightLambda, cl_float biasAlpha, cl_float activeRatio, float noise) {
	// Learn weights
	for (int vli = 0; vli < _visibleLayers.size(); vli++) {
		VisibleLayer &vl = _visibleLayers[vli];
		VisibleLayerDesc &vld = _visibleLayerDescs[vli];

		int argIndex = 0;

		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, visibleStatesPrev[vli]);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, targets);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, _hiddenStates[_back]);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, _hiddenActivations[_front]);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, _hiddenStates[_front]);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, vl._weights[_back]);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, vl._weights[_front]);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, vl._qTraces[_back]);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, vl._qTraces[_front]);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, vld._size);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, vl._hiddenToVisible);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, vld._radius);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, weightAlpha);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, weightLambda);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, reward);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, gamma);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, activeRatio);
		_learnWeightsTracesInhibitedKernel.setArg(argIndex++, noise);

		cs.getQueue().enqueueNDRangeKernel(_learnWeightsTracesInhibitedKernel, cl::NullRange, cl::NDRange(_hiddenSize.x, _hiddenSize.y));

		std::swap(vl._weights[_front], vl._weights[_back]);
		std::swap(vl._qTraces[_front], vl._qTraces[_back]);
	}
}
开发者ID:JamesLinus，项目名称:NeoRL，代码行数:33，代码来源:PredictorSwarm.cpp


示例9: sumSpikes

void HEInet::sumSpikes(sys::ComputeSystem &cs, float scalar) {
	int index = 0;

	_kernels->_sumSpikesKernel.setArg(index++, _eiLayers.front()._eLayer._states);
	_kernels->_sumSpikesKernel.setArg(index++, _eSpikeSumsPrev);
	_kernels->_sumSpikesKernel.setArg(index++, _eSpikeSums);
	_kernels->_sumSpikesKernel.setArg(index++, scalar);

	cs.getQueue().enqueueNDRangeKernel(_kernels->_sumSpikesKernel, cl::NullRange, cl::NDRange(_eiLayers.front().getConfig()._eWidth, _eiLayers.front().getConfig()._eHeight));

	index = 0;

	_kernels->_sumSpikesKernel.setArg(index++, _eiLayers.front()._iLayer._states);
	_kernels->_sumSpikesKernel.setArg(index++, _iSpikeSumsPrev);
	_kernels->_sumSpikesKernel.setArg(index++, _iSpikeSums);
	_kernels->_sumSpikesKernel.setArg(index++, scalar);

	cs.getQueue().enqueueNDRangeKernel(_kernels->_sumSpikesKernel, cl::NullRange, cl::NDRange(_eiLayers.front().getConfig()._iWidth, _eiLayers.front().getConfig()._iHeight));
}
开发者ID:222464，项目名称:HEInetGPU，代码行数:19，代码来源:HEInet.cpp


示例10: clearMemory

void AgentSwarm::clearMemory(sys::ComputeSystem &cs) {
    cl_float4 zeroColor = { 0.0f, 0.0f, 0.0f, 0.0f };
    cl::array<cl::size_type, 3> zeroOrigin = { 0, 0, 0 };

    for (int l = 0; l < _layers.size(); l++) {
        cl::array<cl::size_type, 3> layerRegion = { _layerDescs[l]._hiddenSize.x, _layerDescs[l]._hiddenSize.y, 1 };

        cs.getQueue().enqueueFillImage(_layers[l]._scHiddenStatesPrev, zeroColor, zeroOrigin, layerRegion);
    }
}
开发者ID:JamesLinus，项目名称:NeoRL，代码行数:10，代码来源:AgentSwarm.cpp


示例11: setInputPhase

void HEInet::setInputPhase(sys::ComputeSystem &cs, cl_uint4 color) {
	cl::size_t<3> zeroCoord;
	zeroCoord[0] = zeroCoord[1] = zeroCoord[2] = 0;

	cl::size_t<3> eFeedForwardDimsCoord;
	eFeedForwardDimsCoord[0] = _eiLayers.front().getConfig()._eFeedForwardWidth;
	eFeedForwardDimsCoord[1] = _eiLayers.front().getConfig()._eFeedForwardHeight;
	eFeedForwardDimsCoord[2] = 1;

	cs.getQueue().enqueueFillImage(_inputSpikeTimersPrev, color, zeroCoord, eFeedForwardDimsCoord);
}
开发者ID:222464，项目名称:HEInetGPU，代码行数:11，代码来源:HEInet.cpp


示例12: spikeSumBegin

void HEInet::spikeSumBegin(sys::ComputeSystem &cs) {
	cl_float4 zeroColor = { 0.0f, 0.0f, 0.0f, 0.0f };

	cl::size_t<3> zeroCoord;
	zeroCoord[0] = zeroCoord[1] = zeroCoord[2] = 0;

	cl::size_t<3> eDims;
	eDims[0] = _eiLayers.front().getConfig()._eWidth;
	eDims[1] = _eiLayers.front().getConfig()._eHeight;
	eDims[2] = 1;

	cl::size_t<3> iDims;
	iDims[0] = _eiLayers.front().getConfig()._iWidth;
	iDims[1] = _eiLayers.front().getConfig()._iHeight;
	iDims[2] = 1;

	cs.getQueue().enqueueFillImage(_eSpikeSums, zeroColor, zeroCoord, eDims);
	cs.getQueue().enqueueFillImage(_eSpikeSumsPrev, zeroColor, zeroCoord, eDims);
	cs.getQueue().enqueueFillImage(_iSpikeSums, zeroColor, zeroCoord, iDims);
	cs.getQueue().enqueueFillImage(_iSpikeSumsPrev, zeroColor, zeroCoord, iDims);
}
开发者ID:222464，项目名称:HEInetGPU，代码行数:21，代码来源:HEInet.cpp


示例13: randomUniform

void neo::randomUniform(cl::Image3D &image3D, sys::ComputeSystem &cs, cl::Kernel &randomUniform3DKernel, cl_int3 size, cl_float2 range, std::mt19937 &rng) {
	int argIndex = 0;

	std::uniform_int_distribution<int> seedDist;

	cl_uint2 seed = { seedDist(rng), seedDist(rng) };

	randomUniform3DKernel.setArg(argIndex++, image3D);
	randomUniform3DKernel.setArg(argIndex++, seed);
	randomUniform3DKernel.setArg(argIndex++, range);

	cs.getQueue().enqueueNDRangeKernel(randomUniform3DKernel, cl::NullRange, cl::NDRange(size.x, size.y, size.z));
}
开发者ID:dsimba，项目名称:NeoRL，代码行数:13，代码来源:Helpers.cpp


示例14: clearMemory

void HTFE::clearMemory(sys::ComputeSystem &cs) {
    // ------------------------------------------------------------------------------
    // -------------------------------- Clear Memory --------------------------------
    // ------------------------------------------------------------------------------

    cl_uint4 clear = { 0, 0, 0, 0 };

    for (int l = 0; l < _layers.size(); l++) {
        cl::size_t<3> origin;
        origin[0] = 0;
        origin[1] = 0;
        origin[2] = 0;

        cl::size_t<3> region;
        region[0] = _layerDescs[l]._width;
        region[1] = _layerDescs[l]._height;
        region[2] = 1;

        cs.getQueue().enqueueFillImage(_layers[l]._hiddenStatesFeedBackPrevPrev, clear, origin, region);
        cs.getQueue().enqueueFillImage(_layers[l]._hiddenStatesFeedBackPrev, clear, origin, region);
        cs.getQueue().enqueueFillImage(_layers[l]._hiddenStatesFeedBack, clear, origin, region);
    }
}
开发者ID:shayanrc，项目名称:pyhtfe，代码行数:23，代码来源:HTFE.cpp


示例15: reconstruct

void ComparisonSparseCoder::reconstruct(sys::ComputeSystem &cs, const cl::Image2D &hiddenStates, int visibleLayerIndex, cl::Image2D &visibleStates) {
	VisibleLayer &vl = _visibleLayers[visibleLayerIndex];
	VisibleLayerDesc &vld = _visibleLayerDescs[visibleLayerIndex];

	int argIndex = 0;

	_forwardKernel.setArg(argIndex++, hiddenStates);
	_forwardKernel.setArg(argIndex++, visibleStates);
	_forwardKernel.setArg(argIndex++, vl._weights[_back]);
	_forwardKernel.setArg(argIndex++, vld._size);
	_forwardKernel.setArg(argIndex++, _hiddenSize);
	_forwardKernel.setArg(argIndex++, vl._visibleToHidden);
	_forwardKernel.setArg(argIndex++, vl._hiddenToVisible);
	_forwardKernel.setArg(argIndex++, vld._radius);
	_forwardKernel.setArg(argIndex++, vl._reverseRadii);

	cs.getQueue().enqueueNDRangeKernel(_forwardKernel, cl::NullRange, cl::NDRange(vld._size.x, vld._size.y));
}
开发者ID:JamesLinus，项目名称:NeoRL，代码行数:18，代码来源:ComparisonSparseCoder.cpp


示例16: activate

void HTFE::activate(sys::ComputeSystem &cs) {
    {
        cl::size_t<3> origin;
        origin[0] = 0;
        origin[1] = 0;
        origin[2] = 0;

        cl::size_t<3> region;
        region[0] = _inputWidth;
        region[1] = _inputHeight;
        region[2] = 1;

        cs.getQueue().enqueueWriteImage(_inputImage, CL_TRUE, origin, region, 0, 0, _input.data());
    }

    std::uniform_int_distribution<int> seedDist(0, 99999);

    // ------------------------------------------------------------------------------
    // ------------------------------------ Go up -----------------------------------
    // ------------------------------------------------------------------------------

    cl::Image2D* pPrevLayer = &_inputImage;
    int prevWidth = _inputWidth;
    int prevHeight = _inputHeight;

    for (int l = 0; l < _layers.size(); l++) {
        float localActivity = std::round(_layerDescs[l]._sparsity * std::pow(2 * _layerDescs[l]._inhibitionRadius + 1, 2));

        Int2 layerSize;
        layerSize._x = _layerDescs[l]._width;
        layerSize._y = _layerDescs[l]._height;

        Int2 layerSizeMinusOne;
        layerSizeMinusOne._x = _layerDescs[l]._width - 1;
        layerSizeMinusOne._y = _layerDescs[l]._height - 1;

        Float2 layerSizeMinusOneInv;
        layerSizeMinusOneInv._x = 1.0f / (_layerDescs[l]._width - 1);
        layerSizeMinusOneInv._y = 1.0f / (_layerDescs[l]._height - 1);

        Int2 inputSize;
        inputSize._x = prevWidth;
        inputSize._y = prevHeight;

        Int2 inputSizeMinusOne;
        inputSizeMinusOne._x = prevWidth - 1;
        inputSizeMinusOne._y = prevHeight - 1;

        Float2 inputSizeMinusOneInv;
        inputSizeMinusOneInv._x = 1.0f / (prevWidth - 1);
        inputSizeMinusOneInv._y = 1.0f / (prevHeight - 1);

        // -------------------------------- Activate --------------------------------

        int index = 0;

        _layerHiddenFeedForwardActivateKernel.setArg(index++, *pPrevLayer);
        _layerHiddenFeedForwardActivateKernel.setArg(index++, _layers[l]._hiddenStatesFeedBackPrev);
        _layerHiddenFeedForwardActivateKernel.setArg(index++, _layers[l]._feedForwardWeightsPrev);
        _layerHiddenFeedForwardActivateKernel.setArg(index++, _layers[l]._lateralWeightsPrev);
        _layerHiddenFeedForwardActivateKernel.setArg(index++, _layers[l]._hiddenBiasesPrev);
        _layerHiddenFeedForwardActivateKernel.setArg(index++, _layers[l]._hiddenFeedForwardActivations);
        _layerHiddenFeedForwardActivateKernel.setArg(index++, layerSize);
        _layerHiddenFeedForwardActivateKernel.setArg(index++, layerSizeMinusOneInv);
        _layerHiddenFeedForwardActivateKernel.setArg(index++, inputSize);
        _layerHiddenFeedForwardActivateKernel.setArg(index++, inputSizeMinusOne);
        _layerHiddenFeedForwardActivateKernel.setArg(index++, _layerDescs[l]._receptiveFieldRadius);
        _layerHiddenFeedForwardActivateKernel.setArg(index++, _layerDescs[l]._lateralConnectionRadius);

        cs.getQueue().enqueueNDRangeKernel(_layerHiddenFeedForwardActivateKernel, cl::NullRange, cl::NDRange(_layerDescs[l]._width, _layerDescs[l]._height));

        // ---------------------------------- Inhibit ---------------------------------

        index = 0;

        _layerHiddenInhibitKernel.setArg(index++, _layers[l]._hiddenFeedForwardActivations);
        _layerHiddenInhibitKernel.setArg(index++, _layers[l]._hiddenStatesFeedForwardPrev);
        _layerHiddenInhibitKernel.setArg(index++, _layers[l]._hiddenStatesFeedForward);
        _layerHiddenInhibitKernel.setArg(index++, layerSize);
        _layerHiddenInhibitKernel.setArg(index++, _layerDescs[l]._inhibitionRadius);
        _layerHiddenInhibitKernel.setArg(index++, localActivity);

        cs.getQueue().enqueueNDRangeKernel(_layerHiddenInhibitKernel, cl::NullRange, cl::NDRange(_layerDescs[l]._width, _layerDescs[l]._height));

        pPrevLayer = &_layers[l]._hiddenStatesFeedForward;
        prevWidth = _layerDescs[l]._width;
        prevHeight = _layerDescs[l]._height;
    }

    // ------------------------------------------------------------------------------
    // -------------------------------- Go back down --------------------------------
    // ------------------------------------------------------------------------------

    for (int l = _layers.size() - 1; l >= 0; l--) {
        if (l > 0) {
            pPrevLayer = &_layers[l - 1]._hiddenStatesFeedForward;
            prevWidth = _layerDescs[l - 1]._width;
            prevHeight = _layerDescs[l - 1]._height;
        }
        else {
//.........这里部分代码省略.........
开发者ID:shayanrc，项目名称:pyhtfe，代码行数:101，代码来源:HTFE.cpp


示例17: createRandom

void HTFE::createRandom(sys::ComputeSystem &cs, sys::ComputeProgram &program, int inputWidth, int inputHeight, const std::vector<LayerDesc> &layerDescs, float minInitWeight, float maxInitWeight) {
    std::mt19937 generator(time(nullptr));

    std::uniform_int_distribution<int> seedDist(0, 99999);

    _inputWidth = inputWidth;
    _inputHeight = inputHeight;

    _layerDescs = layerDescs;

    _layers.resize(_layerDescs.size());

    cl::Kernel initializeLayerHiddenKernel = cl::Kernel(program.getProgram(), "initializeLayerHidden");
    cl::Kernel initializeLayerVisibleKernel = cl::Kernel(program.getProgram(), "initializeLayerVisible");

    _input.clear();
    _input.resize(_inputWidth * _inputHeight, 0.0f);

    _prediction.clear();
    _prediction.resize(_inputWidth * _inputHeight, 0.0f);

    _inputImage = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), _inputWidth, _inputHeight);
    _inputImagePrev = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), _inputWidth, _inputHeight);

    {
        cl_uint4 clear = { 0, 0, 0, 0 };

        cl::size_t<3> origin;
        origin[0] = 0;
        origin[1] = 0;
        origin[2] = 0;

        cl::size_t<3> region;
        region[0] = _inputWidth;
        region[1] = _inputHeight;
        region[2] = 1;

        cs.getQueue().enqueueFillImage(_inputImage, clear, origin, region);
        cs.getQueue().enqueueFillImage(_inputImagePrev, clear, origin, region);
    }

    int prevWidth = _inputWidth;
    int prevHeight = _inputHeight;

    for (int l = 0; l < _layers.size(); l++) {
        int numFeedForwardWeights = std::pow(_layerDescs[l]._receptiveFieldRadius * 2 + 1, 2);
        int numReconstructionWeights = std::pow(_layerDescs[l]._reconstructionRadius * 2 + 1, 2);
        int numLateralWeights = std::pow(_layerDescs[l]._lateralConnectionRadius * 2 + 1, 2);
        int numFeedBackWeights = std::pow(_layerDescs[l]._feedBackConnectionRadius * 2 + 1, 2);

        _layers[l]._hiddenFeedForwardActivations = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_RG, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height);

        _layers[l]._hiddenFeedBackActivations = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_RG, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height);
        _layers[l]._hiddenFeedBackActivationsPrev = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_RG, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height);

        _layers[l]._hiddenStatesFeedForward = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height);
        _layers[l]._hiddenStatesFeedForwardPrev = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height);

        _layers[l]._hiddenStatesFeedBack = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height);
        _layers[l]._hiddenStatesFeedBackPrev = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height);
        _layers[l]._hiddenStatesFeedBackPrevPrev = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height);

        _layers[l]._feedForwardWeights = cl::Image3D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height, numFeedForwardWeights);
        _layers[l]._feedForwardWeightsPrev = cl::Image3D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height, numFeedForwardWeights);

        _layers[l]._reconstructionWeights = cl::Image3D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), prevWidth, prevHeight, numReconstructionWeights);
        _layers[l]._reconstructionWeightsPrev = cl::Image3D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), prevWidth, prevHeight, numReconstructionWeights);

        _layers[l]._visibleBiases = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), prevWidth, prevHeight);
        _layers[l]._visibleBiasesPrev = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), prevWidth, prevHeight);

        _layers[l]._hiddenBiases = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height);
        _layers[l]._hiddenBiasesPrev = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height);

        _layers[l]._lateralWeights = cl::Image3D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height, numLateralWeights);
        _layers[l]._lateralWeightsPrev = cl::Image3D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height, numLateralWeights);

        _layers[l]._feedBackWeights = cl::Image3D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height, numFeedBackWeights);
        _layers[l]._feedBackWeightsPrev = cl::Image3D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), _layerDescs[l]._width, _layerDescs[l]._height, numFeedBackWeights);

        _layers[l]._visibleReconstruction = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), prevWidth, prevHeight);
        _layers[l]._visibleReconstructionPrev = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), prevWidth, prevHeight);

        // Initialize
        Uint2 initSeedHidden;
        initSeedHidden._x = seedDist(generator);
        initSeedHidden._y = seedDist(generator);

        int index = 0;

        initializeLayerHiddenKernel.setArg(index++, _layers[l]._hiddenFeedForwardActivations);
        initializeLayerHiddenKernel.setArg(index++, _layers[l]._hiddenFeedBackActivations);
        initializeLayerHiddenKernel.setArg(index++, _layers[l]._hiddenStatesFeedForward);
        initializeLayerHiddenKernel.setArg(index++, _layers[l]._feedForwardWeights);
        initializeLayerHiddenKernel.setArg(index++, _layers[l]._hiddenBiases);
        initializeLayerHiddenKernel.setArg(index++, _layers[l]._lateralWeights);
        initializeLayerHiddenKernel.setArg(index++, _layers[l]._feedBackWeights);
        initializeLayerHiddenKernel.setArg(index++, numFeedForwardWeights);
        initializeLayerHiddenKernel.setArg(index++, numLateralWeights);
        initializeLayerHiddenKernel.setArg(index++, numFeedBackWeights);
//.........这里部分代码省略.........
开发者ID:shayanrc，项目名称:pyhtfe，代码行数:101，代码来源:HTFE.cpp


示例18: simStep

void AgentER::simStep(sys::ComputeSystem &cs, const cl::Image2D &input, const cl::Image2D &actionTaken, float reward, std::mt19937 &rng, bool learn, bool whiten) {
	// Keep previous best action for later
	std::vector<float> prevBestAction(_actionSize.x * _actionSize.y);
	std::vector<float> prevTakenAction(_actionSize.x * _actionSize.y);

	cs.getQueue().enqueueReadImage(getAction(), CL_TRUE, { 0, 0, 0 }, { static_cast<cl::size_type>(_actionSize.x), static_cast<cl::size_type>(_actionSize.y), 1 }, 0, 0, prevBestAction.data());
	cs.getQueue().enqueueReadImage(actionTaken, CL_TRUE, { 0, 0, 0 }, { static_cast<cl::size_type>(_actionSize.x), static_cast<cl::size_type>(_actionSize.y), 1 }, 0, 0, prevTakenAction.data());

	// Place previous Q into Q buffer
	{
		int argIndex = 0;

		_setQKernel.setArg(argIndex++, _qTransform);
		_setQKernel.setArg(argIndex++, _qInput);
		_setQKernel.setArg(argIndex++, _prevQ);

		cs.getQueue().enqueueNDRangeKernel(_setQKernel, cl::NullRange, cl::NDRange(_qSize.x, _qSize.y));
	}

	// Whiten input
	if (whiten)
		_inputWhitener.filter(cs, input, _whiteningKernelRadius, _whiteningIntensity);

	_actionWhitener.filter(cs, actionTaken, _whiteningKernelRadius, _whiteningIntensity);

	_qWhitener.filter(cs, _qInput, _whiteningKernelRadius, _whiteningIntensity);

	// Feed forward
	for (int l = 0; l < _layers.size(); l++) {
		{
			std::vector<cl::Image2D> visibleStates;

			if (l == 0) {
				visibleStates.resize(3);

				visibleStates[0] = whiten ? _inputWhitener.getResult() : input;
				visibleStates[1] = _actionWhitener.getResult();
				visibleStates[2] = _qWhitener.getResult();
			}
			else {
				visibleStates.resize(2);

				visibleStates[0] = _layers[l - 1]._sc.getHiddenStates()[_back];
				visibleStates[1] = _layers[l]._sc.getHiddenStates()[_back];
			}

			_layers[l]._sc.activate(cs, visibleStates, _layerDescs[l]._scActiveRatio);
		}
	}

	for (int l = _layers.size() - 1; l >= 0; l--) {
		std::vector<cl::Image2D> visibleStates;

		if (l < _layers.size() - 1) {
			visibleStates.resize(2);

			visibleStates[0] = _layers[l]._sc.getHiddenStates()[_back];
			visibleStates[1] = _layers[l + 1]._pred.getHiddenStates()[_back];
		}
		else {
			visibleStates.resize(1);

			visibleStates[0] = _layers[l]._sc.getHiddenStates()[_back];
		}

		//_layers[l]._pred.activate(cs, visibleStates, l != 0);
	}

	// Q predictor
	{
		std::vector<cl::Image2D> visibleStates;

		if (0 < _layers.size() - 1) {
			visibleStates.resize(2);

			visibleStates[0] = _layers[0]._sc.getHiddenStates()[_back];
			visibleStates[1] = _layers[0 + 1]._pred.getHiddenStates()[_back];
		}
		else {
			visibleStates.resize(1);

			visibleStates[0] = _layers[0]._sc.getHiddenStates()[_back];
		}

		//_qPred.activate(cs, visibleStates, false);
	}

	// Recover Q
	std::vector<float> qValues(_qSize.x * _qSize.y);

	cs.getQueue().enqueueReadImage(_qPred.getHiddenStates()[_back], CL_TRUE, { 0, 0, 0 }, { static_cast<cl::size_type>(_qSize.x), static_cast<cl::size_type>(_qSize.y), 1 }, 0, 0, qValues.data());

	// Average all Q values
	float q = 0.0f;

	for (int i = 0; i < qValues.size(); i++)
		q += qValues[i];

	q /= qValues.size();

//.........这里部分代码省略.........
开发者ID:JamesLinus，项目名称:NeoRL，代码行数:101，代码来源:AgentER.cpp


示例19: activate

void ComparisonSparseCoder::activate(sys::ComputeSystem &cs, const std::vector<cl::Image2D> &visibleStates, float activeRatio, bool bufferSwap) {
	// Start by clearing summation buffer to biases
	{
		cl::array<cl::size_type, 3> zeroOrigin = { 0, 0, 0 };
		cl::array<cl::size_type, 3> hiddenRegion = { _hiddenSize.x, _hiddenSize.y, 1 };

		cs.getQueue().enqueueCopyImage(_hiddenBiases[_back], _hiddenActivationSummationTemp[_back], zeroOrigin, zeroOrigin, hiddenRegion);
	}

	for (int vli = 0; vli < _visibleLayers.size(); vli++) {
		VisibleLayer &vl = _visibleLayers[vli];
		VisibleLayerDesc &vld = _visibleLayerDescs[vli];

		if (!vld._isPredictiveCoding) {
			if (vld._ignoreMiddle) {
				int argIndex = 0;

				_activateIgnoreMiddleKernel.setArg(argIndex++, visibleStates[vli]);
				_activateIgnoreMiddleKernel.setArg(argIndex++, _hiddenActivationSummationTemp[_back]);
				_activateIgnoreMiddleKernel.setArg(argIndex++, _hiddenActivationSummationTemp[_front]);
				_activateIgnoreMiddleKernel.setArg(argIndex++, vl._weights[_back]);
				_activateIgnoreMiddleKernel.setArg(argIndex++, vld._size);
				_activateIgnoreMiddleKernel.setArg(argIndex++, vl._hiddenToVisible);
				_activateIgnoreMiddleKernel.setArg(argIndex++, vld._radius);

				cs.getQueue().enqueueNDRangeKernel(_activateIgnoreMiddleKernel, cl::NullRange, cl::NDRange(_hiddenSize.x, _hiddenSize.y));
			}
			else {
				int argIndex = 0;

				_activateKernel.setArg(argIndex++, visibleStates[vli]);
				_activateKernel.setArg(argIndex++, _hiddenActivationSummationTemp[_back]);
				_activateKernel.setArg(argIndex++, _hiddenActivationSummationTemp[_front]);
				_activateKernel.setArg(argIndex++, vl._weights[_back]);
				_activateKernel.setArg(argIndex++, vld._size);
				_activateKernel.setArg(argIndex++, vl._hiddenToVisible);
				_activateKernel.setArg(argIndex++, vld._radius);

				cs.getQueue().enqueueNDRangeKernel(_activateKernel, cl::NullRange, cl::NDRange(_hiddenSize.x, _hiddenSize.y));
			}

			// Swap buffers
			std::swap(_hiddenActivationSummationTemp[_front], _hiddenActivationSummationTemp[_back]);
		}
	}

	// Start by clearing summation buffer to biases
	{
		cl::array<cl::size_type, 3> zeroOrigin = { 0, 0, 0 };
		cl::array<cl::size_type, 3> hiddenRegion = { _hiddenSize.x, _hiddenSize.y, 1 };

		cs.getQueue().enqueueFillImage(_hiddenPredictionSummationTemp[_back], cl_float4{ 0.0f, 0.0f, 0.0f, 0.0f }, zeroOrigin, hiddenRegion);
	}

	for (int vli = 0; vli < _visibleLayers.size(); vli++) {
		VisibleLayer &vl = _visibleLayers[vli];
		VisibleLayerDesc &vld = _visibleLayerDescs[vli];

		if (vld._isPredictiveCoding) {
			if (vld._ignoreMiddle) {
				int argIndex = 0;

				_activateIgnoreMiddleKernel.setArg(argIndex++, visibleStates[vli]);
				_activateIgnoreMiddleKernel.setArg(argIndex++, _hiddenPredictionSummationTemp[_back]);
				_activateIgnoreMiddleKernel.setArg(argIndex++, _hiddenPredictionSummationTemp[_front]);
				_activateIgnoreMiddleKernel.setArg(argIndex++, vl._weights[_back]);
				_activateIgnoreMiddleKernel.setArg(argIndex++, vld._size);
				_activateIgnoreMiddleKernel.setArg(argIndex++, vl._hiddenToVisible);
				_activateIgnoreMiddleKernel.setArg(argIndex++, vld._radius);

				cs.getQueue().enqueueNDRangeKernel(_activateIgnoreMiddleKernel, cl::NullRange, cl::NDRange(_hiddenSize.x, _hiddenSize.y));
			}
			else {
				int argIndex = 0;

				_activateKernel.setArg(argIndex++, visibleStates[vli]);
				_activateKernel.setArg(argIndex++, _hiddenPredictionSummationTemp[_back]);
				_activateKernel.setArg(argIndex++, _hiddenPredictionSummationTemp[_front]);
				_activateKernel.setArg(argIndex++, vl._weights[_back]);
				_activateKernel.setArg(argIndex++, vld._size);
				_activateKernel.setArg(argIndex++, vl._hiddenToVisible);
				_activateKernel.setArg(argIndex++, vld._radius);

				cs.getQueue().enqueueNDRangeKernel(_activateKernel, cl::NullRange, cl::NDRange(_hiddenSize.x, _hiddenSize.y));
			}

			// Swap buffers
			std::swap(_hiddenPredictionSummationTemp[_front], _hiddenPredictionSummationTemp[_back]);
		}
	}

鲜花
握手
雷人
路过
鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
More+
上一篇：
C++ sys::Path类代码示例发布时间：2022-05-31
下一篇：
C++ synfig::String类代码示例发布时间：2022-05-31
热门推荐
More+
热门话题
More+
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服
地址：深圳市南山区西丽大学城创智工业园
电邮：jeky_zhao#qq.com
移动电话：139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap