本文整理汇总了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]);
}
}
|
请发表评论