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(); }