void DeConv3DLayer::forward(PassType passType) {
Layer::forward(passType);
int batchSize = inputLayers_[0]->getOutputValue()->getHeight();
int outWidth = getSize();
resetOutput(batchSize, outWidth);
const MatrixPtr outMat = getOutputValue();
REGISTER_TIMER_INFO("FwdDeConv3D", getName().c_str());
for (size_t i = 0; i != inputLayers_.size(); ++i) {
const MatrixPtr &inMat = getInputValue(i);
int M = M_[i];
int N = N_[i];
int K = K_[i];
MatrixPtr wMat = weights_[i]->getW();
Matrix::resizeOrCreate(colBuf_, K * groups_[i], N, false, useGpu_);
for (int n = 0; n < batchSize; ++n) {
real *inData = inMat->getData() + n * inMat->getStride();
for (int g = 0; g < groups_[i]; ++g) {
MatrixPtr inMatSub = Matrix::create(inData, M, N, false, useGpu_);
MatrixPtr wMatSub = wMat->subMatrix(g * K, K);
MatrixPtr colBufDataSub = colBuf_->subMatrix(g * K, K);
colBufDataSub->mul(*wMatSub, *inMatSub, 1.0, 0.0);
inData += M * N;
}
colBuf_->col2Vol(outMat->getData() + n * outMat->getStride(),
numFilters_,
imgSizeD_[i],
imgSizeH_[i],
imgSizeW_[i],
filterSizeZ_[i],
filterSizeY_[i],
filterSize_[i],
strideZ_[i],
strideY_[i],
stride_[i],
paddingZ_[i],
paddingY_[i],
padding_[i],
1.0,
1.0);
}
}
if (nullptr != this->biasParameter_) {
this->addBias();
}
forwardActivation();
}
idgs::rdd::pb::RddResultCode Transformer::transform(TransformerContext* ctx, idgs::rdd::PairRddPartition* output) {
auto exprCtx = ctx->getExpressionContext();
if (ctx->getRddOperator()->evaluate(exprCtx)) {
auto outkey = * exprCtx->getOutputKey();
auto outvalue = * exprCtx->getOutputValue();
if (!outkey || !outvalue) {
LOG(ERROR) << output->getPartitionName() << " operator " << ctx->getRddOperator()->getName() << " returns null";
LOG_IF(ERROR, exprCtx->getKey() && *exprCtx->getKey()) << "Input key " << (*exprCtx->getKey())->DebugString();
LOG_IF(ERROR, exprCtx->getValue() && *exprCtx->getValue()) << "input value: " << (*exprCtx->getValue())->DebugString();
}
output->processRow(outkey, outvalue);
}
return idgs::rdd::pb::RRC_SUCCESS;
}
pb::RddResultCode ReduceByKeyTransformer::transform(TransformerContext* ctx, PairRddPartition* output) {
ReduceOperator* reduceOp = dynamic_cast<ReduceOperator*>(ctx->getRddOperator());
auto exprCtx = ctx->getExpressionContext();
if (reduceOp->evaluate(exprCtx)) {
size_t reduceSize = reduceOp->options.size();
auto& outkey = * exprCtx->getOutputKey();
auto& reduceOptions = ctx->getReduceOption(outkey, reduceSize);
for (int32_t i = 0; i < reduceSize; ++ i) {
reduceOp->options[i]->reduce(exprCtx, reduceOptions[i]);
}
output->put(outkey, * exprCtx->getOutputValue(), true);
}
return pb::RRC_SUCCESS;
}
void FeatureMapExpandLayer::forward(PassType passType) {
Layer::forward(passType);
MatrixPtr inputV = getInputValue(0);
size_t batchSize = getInput(0).getBatchSize();
int imgSize = inputV->getWidth();
resetOutput(batchSize, imgSize * numFilters_);
MatrixPtr outputV = getOutputValue();
{
AsyncGpuBlock asyncGpuBlock;
if (asRowVector_) {
for (size_t i = 0; i < batchSize; i++) {
MatrixPtr outVTmp =
Matrix::create(outputV->getData() + i * imgSize * numFilters_,
numFilters_,
imgSize,
false,
useGpu_);
MatrixPtr inVTmp = Matrix::create(
inputV->getData() + i * imgSize, 1, imgSize, false, useGpu_);
outVTmp->addRowVector(*inVTmp);
}
} else {
for (size_t i = 0; i < batchSize; i++) {
MatrixPtr outVTmp =
Matrix::create(outputV->getData() + i * imgSize * numFilters_,
imgSize,
numFilters_,
false,
useGpu_);
MatrixPtr inVTmp = Matrix::create(
inputV->getData() + i * imgSize, imgSize, 1, false, useGpu_);
outVTmp->addColVector(*inVTmp);
}
}
}
/* activation */ {
REGISTER_TIMER_INFO("FwAtvTimer", getName().c_str());
forwardActivation();
}
}
/** Der helligkeitssensor_timer_handler wird alle 1 s aufgerufen: Er liest den ADC-Wert des
* konfigurierten helligkeitssensors und sendet diesen auf den CAN-Bus. */
inline void helligkeitssensor_timer_handler(device_data_helligkeitssensor *p, uint8_t zyklus)
{
if (zyklus != 1) return; // 1s-Zyklus verwendet
uint16_t currentADCaverage;
if (p->secsUntilNextSend)
{
p->secsUntilNextSend--;
// nur die letzten n Werte vorm Senden sind wichtig:
if(p->secsUntilNextSend <= SIZE_OF_AVG)
{
setADMUX(p->config.port);
addToFloatAvg(&(p->filterBrightness), getADCvalue_inverted());
}
}
else
{
currentADCaverage = getOutputValue(&(p->filterBrightness));
// sende das Helligkeitssensortelegramm:
canix_frame message;
message.src = canix_selfaddr();
message.dst = HCAN_MULTICAST_CONTROL;
message.proto = HCAN_PROTO_SFP;
message.data[0] = HCAN_SRV_HES;
message.data[1] = HCAN_HES_HELLIGKEITS_INFO; //z.B. fuer rolladenAutomat-Device
message.data[2] = p->config.gruppe;
message.data[3] = (uint8_t)((currentADCaverage & 0xFF00) >> 8); //high value
message.data[4] = (uint8_t)currentADCaverage; //low value
message.size = 5;
canix_frame_send_with_prio(&message, HCAN_PRIO_LOW);
p->secsUntilNextSend = (uint16_t) 60 * p->config.sendCycleMins;
}
}
void MixedLayer::forward(PassType passType) {
Layer::forward(passType);
int batchSize = getInput(0).getBatchSize();
int size = getSize();
{
REGISTER_TIMER_INFO("FwResetTimer", getName().c_str());
resetOutput(batchSize, size);
}
MatrixPtr outV = getOutputValue();
for (size_t i = 0; i != inputLayers_.size(); ++i) {
if (projections_[i]) {
projections_[i]->forward(&getInput(i), &output_, passType);
}
}
std::vector<const Argument*> ins;
for (auto& op : operators_) {
ins.clear();
for (auto& input_index : op->getConfig().input_indices()) {
ins.push_back(&getInput(input_index));
}
op->forward(ins, &output_, passType);
}
/* add the bias-vector */
if (biases_.get() != NULL) {
REGISTER_TIMER_INFO("FwBiasTimer", getName().c_str());
outV->addBias(*(biases_->getW()), 1, sharedBias_);
}
/* activation */ {
REGISTER_TIMER_INFO("FwAtvTimer", getName().c_str());
forwardActivation();
}
}
void ConcatenateLayer::forward(PassType passType) {
Layer::forward(passType);
int batchSize = getInput(0).getBatchSize();
int size = getSize();
reserveOutput(batchSize, size);
const MatrixPtr& out = getOutputValue();
int offset = 0;
for (size_t i = 0; i != inputLayers_.size(); ++i) {
const MatrixPtr& in = getInputValue(i);
size_t inSize = in->getWidth();
out->assignAtOffset(*in, offset);
offset += inSize;
}
CHECK_EQ(size, offset);
/* activation */ {
REGISTER_TIMER_INFO("FwAtvTimer", getName().c_str());
forwardActivation();
}
}
void SlopeInterceptLayer::forward(PassType passType) {
Layer::forward(passType);
MatrixPtr inV = getInputValue(0);
/* malloc memory for the output_ if necessary */
size_t batchSize = inV->getHeight();
size_t size = getSize();
CHECK_EQ(size, inV->getWidth());
{
REGISTER_TIMER_INFO("FwResetTimer", getName().c_str());
reserveOutput(batchSize, size);
}
MatrixPtr outV = getOutputValue();
{
REGISTER_TIMER_INFO("FwSlopeInterceptTimer", getName().c_str());
outV->mulScalar(*inV, config_.slope());
outV->add(config_.intercept());
}
}
void SequenceConcatLayer::forward(PassType passType) {
Layer::forward(passType);
size_t dim = getSize();
const Argument& input1 = getInput(0);
size_t numSequences1 = input1.getNumSequences();
auto startPositions1 = input1.sequenceStartPositions->getVector(false);
const Argument& input2 = getInput(1);
size_t numSequences2 = input2.getNumSequences();
auto startPositions2 = input2.sequenceStartPositions->getVector(false);
CHECK_EQ(dim, input1.value->getWidth());
CHECK_EQ(startPositions1->getData()[numSequences1], input1.getBatchSize());
CHECK_EQ(numSequences1, startPositions1->getSize() - 1);
CHECK_EQ(dim, input2.value->getWidth());
CHECK_EQ(startPositions2->getData()[numSequences2], input2.getBatchSize());
CHECK_EQ(numSequences2, startPositions2->getSize() - 1);
CHECK_EQ(numSequences1, numSequences2);
MatrixPtr inputValue1 = getInputValue(0);
MatrixPtr inputValue2 = getInputValue(1);
// reset output
reserveOutput(inputValue1->getHeight() + inputValue2->getHeight(), dim);
MatrixPtr outputValue = getOutputValue();
const int* starts1 = startPositions1->getData();
const int* starts2 = startPositions2->getData();
{
AsyncGpuBlock asyncGpuBlock;
REGISTER_TIMER_INFO("SequenceConcatLayerForward", getName().c_str());
size_t offset = 0;
size_t leftNumIns = 0;
size_t rightNumIns = 0;
for (size_t seqId = 0; seqId < numSequences1; ++seqId) {
leftNumIns = starts1[seqId + 1] - starts1[seqId];
outputValue->subMatrix(offset, leftNumIns)
->assign(*(inputValue1->subMatrix(starts1[seqId], leftNumIns)));
offset += leftNumIns;
rightNumIns = starts2[seqId + 1] - starts2[seqId];
outputValue->subMatrix(offset, rightNumIns)
->assign(*(inputValue2->subMatrix(starts2[seqId], rightNumIns)));
offset += rightNumIns;
}
// modify the sequenceStartPositions
ICpuGpuVector::resizeOrCreate(
output_.sequenceStartPositions, numSequences1 + 1, false);
int* tgtBuf = output_.sequenceStartPositions->getMutableData(false);
for (size_t seqId = 0; seqId < numSequences1 + 1; ++seqId) {
tgtBuf[seqId] = starts1[seqId] + starts2[seqId];
}
}
if (biases_.get() != NULL) {
MatrixPtr outV = getOutputValue();
outV->addBias(*(biases_->getW()), 1);
}
/* activation */
forwardActivation();
}
