/** * @time * @l */ int DatastoreDelayTestProbe::outputState(double timed) { HyPerLayer * l = getTargetLayer(); InterColComm * icComm = l->getParent()->icCommunicator(); const int rcvProc = 0; if( icComm->commRank() != rcvProc ) { return PV_SUCCESS; } int status = PV_SUCCESS; int numDelayLevels = l->getParent()->getLayer(0)->getNumDelayLevels(); pvdata_t correctValue = numDelayLevels*(numDelayLevels+1)/2; if( timed >= numDelayLevels+2 ) { pvdata_t * V = l->getV(); for( int k=0; k<l->getNumNeuronsAllBatches(); k++ ) { if( V[k] != correctValue ) { fprintf(outputstream->fp, "Layer \"%s\": timef = %f, neuron %d: value is %f instead of %d\n", l->getName(), timed, k, V[k], (int) correctValue); status = PV_FAILURE; } } if( status == PV_SUCCESS) { fprintf(outputstream->fp, "Layer \"%s\": timef = %f, all neurons have correct value %d\n", l->getName(), timed, (int) correctValue); } } assert(status == PV_SUCCESS); return PV_SUCCESS; }
int ArborTestProbe::outputState(double timed) { int status = StatsProbe::outputState(timed); InterColComm * icComm = getTargetLayer()->getParent()->icCommunicator(); const int rcvProc = 0; if( icComm->commRank() != rcvProc ) { return 0; } for(int b = 0; b < getParent()->getNBatch(); b++){ if(timed==1.0f){ assert((avg[b]>0.2499)&&(avg[b]<0.2501)); } else if(timed==2.0f){ assert((avg[b]>0.4999)&&(avg[b]<0.5001)); } else if(timed==3.0f){ assert((avg[b]>0.7499)&&(avg[b]<0.7501)); } else if(timed>3.0f){ assert((fMin[b]>0.9999)&&(fMin[b]<1.001)); assert((fMax[b]>0.9999)&&(fMax[b]<1.001)); assert((avg[b]>0.9999)&&(avg[b]<1.001)); } } return status; }
int KernelProbe::outputState(double timed) { InterColComm * icComm = parent->icCommunicator(); const int rank = icComm->commRank(); if( rank != 0 ) return PV_SUCCESS; assert(getTargetConn()!=NULL); int nxp = getTargetHyPerConn()->xPatchSize(); int nyp = getTargetHyPerConn()->yPatchSize(); int nfp = getTargetHyPerConn()->fPatchSize(); int patchSize = nxp*nyp*nfp; const pvwdata_t * wdata = getTargetHyPerConn()->get_wDataStart(arborID)+patchSize*kernelIndex; const pvwdata_t * dwdata = outputPlasticIncr ? getTargetHyPerConn()->get_dwDataStart(arborID)+patchSize*kernelIndex : NULL; fprintf(outputstream->fp, "Time %f, Conn \"%s\", nxp=%d, nyp=%d, nfp=%d\n", timed, getTargetConn()->getName(),nxp, nyp, nfp); for(int f=0; f<nfp; f++) { for(int y=0; y<nyp; y++) { for(int x=0; x<nxp; x++) { int k = kIndex(x,y,f,nxp,nyp,nfp); fprintf(outputstream->fp, " x=%d, y=%d, f=%d (index %d):", x, y, f, k); if(getOutputWeights()) { fprintf(outputstream->fp, " weight=%f", (float)wdata[k]); } if(getOutputPlasticIncr()) { fprintf(outputstream->fp, " dw=%f", (float)dwdata[k]); } fprintf(outputstream->fp,"\n"); } } } return PV_SUCCESS; }
PlasticConnTestProbe::~PlasticConnTestProbe() { InterColComm * icComm = getParent()->icCommunicator(); if( icComm->commRank() == 0) { if( !errorPresent ) { outputStream->printf("No errors detected\n"); } } }
int MapReduceKernelConn::initialize(const char * name, HyPerCol * hc) { int status = HyPerConn::initialize(name, hc); // if (status==PV_SUCCESS) status = setMovieLayerName(); InterColComm *icComm = parent->icCommunicator(); int rootproc = 0; int file_count = 0; PV_Stream * dWeightstream = pvp_open_read_file(this->dWeightsListName, icComm); if ((dWeightstream == NULL) && (icComm->commRank() == rootproc)) { fprintf(stderr, "MapReduceKernelConn::initialize: Cannot open list of dWeight files \"%s\". Exiting.\n", this->dWeightsListName); // CHECK THIS! // CHECK THIS! this->dWeightsListName was filename but filename is no more exit(EXIT_FAILURE); } // dWeightstream == NULL if (icComm->commRank() == rootproc) { for (file_count = 0; file_count < num_dWeightFiles; file_count++) { /* for (int i_char = 0; i_char < PV_PATH_MAX; i_char++) { dWeightsList[file_count][i_char] = 0; } */ char * fgetsstatus = fgets(dWeightsList[file_count], PV_PATH_MAX, dWeightstream->fp); if (fgetsstatus == NULL) { bool endoffile = feof(dWeightstream->fp) != 0; if (endoffile) { fprintf(stderr, "MapReduceKernelConn::initialize: " "File of weight files \"%s\" reached end of file before all %d weight files were read. " "Exiting.\n", dWeightstream->name, num_dWeightFiles); // CHECK THIS! dWeightstream->name was filename but filename is no more exit(EXIT_FAILURE); } else { int error = ferror(dWeightstream->fp); assert(error); fprintf(stderr, "MapReduceKernelConn::initialize: File of weight files error reading:%s. Exiting.\n", strerror(error)); exit(error); } } else { // Remove linefeed from end of string dWeightsList[file_count][PV_PATH_MAX - 1] = '\0'; int len = strlen(dWeightsList[file_count]); if (len > 1) { if (dWeightsList[file_count][len - 1] == '\n') { dWeightsList[file_count][len - 1] = '\0'; } } } // fgetsstatus == NULL } // file_count this->dWeightsFilename = strdup(dWeightsList[dWeightFileIndex]); std::cout << "dWeightFile[" << dWeightFileIndex << "] = " << dWeightsList[dWeightFileIndex] << std::endl; } // commRank() == rootproc return status; }
/** * - Update the image buffers * - If the time is a multiple of biasChangetime then the position of the bias (biasX, biasY) changes. * - With probability persistenceProb the offset position (offsetX, offsetY) remains unchanged. * - Otherwise, with probability (1-persistenceProb) the offset position performs a random walk * around the bias position (biasX, biasY). * * - If the time is a multiple of displayPeriod then load the next image. * - If nf=1 then the image is converted to grayscale during the call to read(filename, offsetX, offsetY). * If nf>1 then the image is loaded with color information preserved. * - Return true if buffers have changed */ bool Movie::updateImage(double time, double dt) { if( jitterFlag ) { jitter(); } // jitterFlag InterColComm * icComm = getParent()->icCommunicator(); //TODO: Fix movie layer to take with batches. This is commented out for compile //if(!flipOnTimescaleError && (parent->getTimeScale() > 0 && parent->getTimeScale() < parent->getTimeScaleMin())){ // if (parent->icCommunicator()->commRank()==0) { // std::cout << "timeScale of " << parent->getTimeScale() << " is less than timeScaleMin of " << parent->getTimeScaleMin() << ", Movie is keeping the same frame\n"; // } //} //else{ //Only do this if it's not the first update timestep //The timestep number is (time - startTime)/(width of timestep), with allowance for roundoff. //But if we're using adaptive timesteps, the dt passed as a function argument is not the correct (width of timestep). if(fabs(time - (parent->getStartTime() + parent->getDeltaTime())) > (parent->getDeltaTime()/2)){ int status = getFrame(time, dt); assert(status == PV_SUCCESS); } //nextDisplayTime removed, now using nextUpdateTime in HyPerLayer //while (time >= nextDisplayTime) { // nextDisplayTime += displayPeriod; //} //Set frame number (member variable in Image) //Write to timestamp file here when updated if( icComm->commRank()==0 ) { //Only write if the parameter is set if(timestampFile){ std::ostringstream outStrStream; outStrStream.precision(15); int kb0 = getLayerLoc()->kb0; for(int b = 0; b < parent->getNBatch(); b++){ outStrStream << time << "," << b+kb0 << "," << frameNumbers[b] << "," << framePath[b] << "\n"; } size_t len = outStrStream.str().length(); int status = PV_fwrite(outStrStream.str().c_str(), sizeof(char), len, timestampFile)==len ? PV_SUCCESS : PV_FAILURE; if (status != PV_SUCCESS) { fprintf(stderr, "%s \"%s\" error: Movie::updateState failed to write to timestamp file.\n", getKeyword(), name); exit(EXIT_FAILURE); } //Flush buffer fflush(timestampFile->fp); } } //} // randomMovie return true; }
int InitWeights::readCombinedWeightFiles(PVPatch *** patches, pvwdata_t ** dataStart,int numPatches, const char * fileOfWeightFiles, double * timef) { InterColComm *icComm = callingConn->getParent()->icCommunicator(); int numArbors = callingConn->numberOfAxonalArborLists(); const PVLayerLoc *preLoc = callingConn->preSynapticLayer()->getLayerLoc(); double timed; int rootproc = 0; int max_weight_files = 1; // arbitrary limit... int num_weight_files = weightParams->getNumWeightFiles(); int file_count=0; PV_Stream * weightstream = pvp_open_read_file(fileOfWeightFiles, icComm); if ((weightstream == NULL) && (icComm->commRank() == rootproc) ){ pvError().printf("Cannot open file of weight files \"%s\". Exiting.\n", fileOfWeightFiles); } char weightsfilename[PV_PATH_MAX]; while( file_count < num_weight_files ) { if( icComm->commRank() == rootproc ) { char * fgetsstatus = fgets(weightsfilename, PV_PATH_MAX, weightstream->fp); if( fgetsstatus == NULL ) { bool endoffile = feof(weightstream->fp)!=0; if( endoffile ) { pvError().printf("File of weight files \"%s\" reached end of file before all %d weight files were read. Exiting.\n", fileOfWeightFiles, num_weight_files); } else { int error = ferror(weightstream->fp); assert(error); pvError().printf("File of weight files: error %d while reading. Exiting.\n", error); } } else { // Remove linefeed from end of string weightsfilename[PV_PATH_MAX-1] = '\0'; int len = strlen(weightsfilename); if (len > 1) { if (weightsfilename[len-1] == '\n') { weightsfilename[len-1] = '\0'; } } } } // commRank() == rootproc int filetype, datatype; int numParams = NUM_BIN_PARAMS+NUM_WGT_EXTRA_PARAMS; int params[NUM_BIN_PARAMS+NUM_WGT_EXTRA_PARAMS]; pvp_read_header(weightsfilename, icComm, &timed, &filetype, &datatype, params, &numParams); const int nxp = callingConn->xPatchSize(); const int nyp = callingConn->yPatchSize(); const int nfp = callingConn->fPatchSize(); int status = PV::readWeights(patches, dataStart, numArbors, numPatches, nxp, nyp, nfp, weightsfilename, icComm, &timed, preLoc); if (status != PV_SUCCESS) { pvError().printf("PV::InitWeights::readWeights: problem reading arbor file %s, SHUTTING DOWN\n", weightsfilename); } file_count += 1; } // file_count < num_weight_files return PV_SUCCESS; }
int InitWeights::readListOfArborFiles(PVPatch *** patches, pvwdata_t ** dataStart, int numPatches, const char * listOfArborsFilename, double * timef) { int arbor=0; InterColComm *icComm = callingConn->getParent()->icCommunicator(); int numArbors = callingConn->numberOfAxonalArborLists(); const PVLayerLoc *preLoc = callingConn->preSynapticLayer()->getLayerLoc(); double timed; PV_Stream * arborstream = pvp_open_read_file(listOfArborsFilename, icComm); int rootproc = 0; char arborfilename[PV_PATH_MAX]; while( arbor < callingConn->numberOfAxonalArborLists() ) { if( icComm->commRank() == rootproc ) { char * fgetsstatus = fgets(arborfilename, PV_PATH_MAX, arborstream->fp); if( fgetsstatus == NULL ) { bool endoffile = feof(arborstream->fp)!=0; if( endoffile ) { fprintf(stderr, "File of arbor files \"%s\" reached end of file before all %d arbors were read. Exiting.\n", listOfArborsFilename, numArbors); exit(EXIT_FAILURE); } else { int error = ferror(arborstream->fp); assert(error); fprintf(stderr, "File of arbor files: error %d while reading. Exiting.\n", error); exit(error); } } else { // Remove linefeed from end of string arborfilename[PV_PATH_MAX-1] = '\0'; int len = strlen(arborfilename); if (len > 1) { if (arborfilename[len-1] == '\n') { arborfilename[len-1] = '\0'; } } } } // commRank() == rootproc int filetype, datatype; int numParams = NUM_BIN_PARAMS+NUM_WGT_EXTRA_PARAMS; int params[NUM_BIN_PARAMS+NUM_WGT_EXTRA_PARAMS]; pvp_read_header(arborfilename, icComm, &timed, &filetype, &datatype, params, &numParams); int thisfilearbors = params[INDEX_NBANDS]; const int nxp = callingConn->xPatchSize(); const int nyp = callingConn->yPatchSize(); const int nfp = callingConn->fPatchSize(); int status = PV::readWeights(patches ? &patches[arbor] : NULL, &dataStart[arbor], numArbors-arbor, numPatches, nxp, nyp, nfp, arborfilename, icComm, &timed, preLoc); if (status != PV_SUCCESS) { fprintf(stderr, "PV::InitWeights::readWeights: problem reading arbor file %s, SHUTTING DOWN\n", arborfilename); exit(EXIT_FAILURE); } arbor += thisfilearbors; } // while pvp_close_file(arborstream, icComm); return PV_SUCCESS; }
int LCALIFLayer::checkpointWrite(const char * cpDir) { int status = LIFGap::checkpointWrite(cpDir); InterColComm * icComm = parent->icCommunicator(); char basepath[PV_PATH_MAX]; char filename[PV_PATH_MAX]; int lenbase = snprintf(basepath, PV_PATH_MAX, "%s/%s", cpDir, name); if (lenbase+strlen("_integratedSpikeCount.pvp") >= PV_PATH_MAX) { // currently _integratedSpikeCount.pvp is the longest suffix needed if (icComm->commRank()==0) { fprintf(stderr, "LCALIFLayer::checkpointWrite error in layer \"%s\". Base pathname \"%s/%s_\" too long.\n", name, cpDir, name); } abort(); } double timed = (double) parent->simulationTime(); int chars_needed = snprintf(filename, PV_PATH_MAX, "%s_integratedSpikeCount.pvp", basepath); assert(chars_needed < PV_PATH_MAX); writeBufferFile(filename, icComm, timed, &integratedSpikeCount, 1, /*extended*/false, getLayerLoc()); chars_needed = snprintf(filename, PV_PATH_MAX, "%s_Vadpt.pvp", basepath); assert(chars_needed < PV_PATH_MAX); writeBufferFile(filename, icComm, timed, &Vadpt, 1, /*extended*/false, getLayerLoc()); chars_needed = snprintf(filename, PV_PATH_MAX, "%s_Vattained.pvp", basepath); assert(chars_needed < PV_PATH_MAX); writeBufferFile(filename, icComm, timed, &Vattained, 1, /*extended*/false, getLayerLoc()); chars_needed = snprintf(filename, PV_PATH_MAX, "%s_Vmeminf.pvp", basepath); assert(chars_needed < PV_PATH_MAX); writeBufferFile(filename, icComm, timed, &Vmeminf, 1, /*extended*/false, getLayerLoc()); chars_needed = snprintf(filename, PV_PATH_MAX, "%s_G_Norm.pvp", basepath); assert(chars_needed < PV_PATH_MAX); writeBufferFile(filename, icComm, timed, &G_Norm, 1, /*extended*/false, getLayerLoc()); chars_needed = snprintf(filename, PV_PATH_MAX, "%s_GSynExcEffective.pvp", basepath); assert(chars_needed < PV_PATH_MAX); writeBufferFile(filename, icComm, timed, &GSynExcEffective, 1, /*extended*/false, getLayerLoc()); chars_needed = snprintf(filename, PV_PATH_MAX, "%s_GSynInhEffective.pvp", basepath); assert(chars_needed < PV_PATH_MAX); writeBufferFile(filename, icComm, timed, &GSynInhEffective, 1, /*extended*/false, getLayerLoc()); chars_needed = snprintf(filename, PV_PATH_MAX, "%s_excitatoryNoise.pvp", basepath); assert(chars_needed < PV_PATH_MAX); writeBufferFile(filename, icComm, timed, &excitatoryNoise, 1, /*extended*/false, getLayerLoc()); chars_needed = snprintf(filename, PV_PATH_MAX, "%s_inhibitoryNoise.pvp", basepath); assert(chars_needed < PV_PATH_MAX); writeBufferFile(filename, icComm, timed, &inhibitoryNoise, 1, /*extended*/false, getLayerLoc()); chars_needed = snprintf(filename, PV_PATH_MAX, "%s_inhibNoiseB.pvp", basepath); assert(chars_needed < PV_PATH_MAX); writeBufferFile(filename, icComm, timed, &inhibNoiseB, 1, /*extended*/false, getLayerLoc()); return status; }
/** * @time * @l */ int GradientCheckProbe::outputState(double timed) { #ifdef PV_USE_MPI InterColComm * icComm = parent->icCommunicator(); MPI_Comm comm = icComm->globalCommunicator(); int rank = icComm->globalCommRank(); #endif // PV_USE_MPI std::cout << name << " probeOutputState on timestep " << timed << "\n"; return PV_SUCCESS; }
int ANNWeightedErrorLayer::allocateDataStructures() { int status = HyPerLayer::allocateDataStructures(); int nf = getLayerLoc()->nf; errWeights = (float *) calloc(nf, sizeof(float *)); for(int i_weight = 0; i_weight < nf; i_weight++){ errWeights[i_weight] = 1.0f; } PV_Stream * pvstream = NULL; InterColComm *icComm = getParent()->icCommunicator(); char errWeight_string[PV_PATH_MAX]; if (getParent()->icCommunicator()->commRank()==0) { PV_Stream * errWeights_stream = pvp_open_read_file(errWeightsFileName, icComm); for(int i_weight = 0; i_weight < nf; i_weight++){ char * fgetsstatus = fgets(errWeight_string, PV_PATH_MAX, errWeights_stream->fp); if( fgetsstatus == NULL ) { bool endoffile = feof(errWeights_stream->fp)!=0; if( endoffile ) { fprintf(stderr, "File of errWeights \"%s\" reached end of file before all %d errWeights were read. Exiting.\n", errWeightsFileName, nf); exit(EXIT_FAILURE); } else { int error = ferror(errWeights_stream->fp); assert(error); fprintf(stderr, "File of errWeights: error %d while reading. Exiting.\n", error); exit(error); } } else { // Remove linefeed from end of string errWeight_string[PV_PATH_MAX-1] = '\0'; int len = strlen(errWeight_string); if (len > 1) { if (errWeight_string[len-1] == '\n') { errWeight_string[len-1] = '\0'; } } } // fgetstatus // set errWeight = chance / relative fraction float errWeight_tmp = atof(errWeight_string); fprintf(stderr, "errWeight %i = %f\n", i_weight, errWeight_tmp); errWeights[i_weight] = (1.0/nf) / errWeight_tmp; } // i_weight } // commRank() == rootproc #ifdef PV_USE_MPI //broadcast errWeights MPI_Bcast(errWeights, nf, MPI_FLOAT, 0, icComm->communicator()); #endif // PV_USE_MPI }
// advance by n_skip lines through file of filenames, always advancing at least one line const char * Movie::getNextFileName(int n_skip, int batchIdx) { InterColComm * icComm = getParent()->icCommunicator(); assert(icComm->commRank() == 0); const char* outFilename = NULL; int numskip = n_skip < 1 ? 1 : n_skip; for (int i_skip = 0; i_skip < numskip; i_skip++){ outFilename = advanceFileName(batchIdx); } if (echoFramePathnameFlag){ printf("%f, %d: %s\n", parent->simulationTime(), batchIdx, outFilename); } return outFilename; }
/** * @timef */ int PlasticConnTestProbe::outputState(double timed) { HyPerConn * c = getTargetHyPerConn(); InterColComm * icComm = c->getParent()->icCommunicator(); const int rcvProc = 0; if( icComm->commRank() != rcvProc ) { return PV_SUCCESS; } assert(getTargetConn()!=NULL); outputStream->printf(" Time %f, connection \"%s\":\n", timed, getTargetName()); const pvwdata_t * w = c->get_wDataHead(getArbor(), getKernelIndex()); const pvdata_t * dw = c->get_dwDataHead(getArbor(), getKernelIndex()); if( getOutputPlasticIncr() && dw == NULL ) { pvError().printf("PlasticConnTestProbe \"%s\": connection \"%s\" has dKernelData(%d,%d) set to null.\n", getName(), getTargetName(), getKernelIndex(), getArbor()); } int nxp = c->xPatchSize(); int nyp = c->yPatchSize(); int nfp = c->fPatchSize(); int status = PV_SUCCESS; for( int k=0; k<nxp*nyp*nfp; k++ ) { int x=kxPos(k,nxp,nyp,nfp); int wx = (nxp-1)/2 - x; // assumes connection is one-to-one if(getOutputWeights()) { pvdata_t wCorrect = timed*wx; pvdata_t wObserved = w[k]; if( fabs( ((double) (wObserved - wCorrect))/timed ) > 1e-4 ) { int y=kyPos(k,nxp,nyp,nfp); int f=featureIndex(k,nxp,nyp,nfp); outputStream->printf(" index %d (x=%d, y=%d, f=%d: w = %f, should be %f\n", k, x, y, f, wObserved, wCorrect); } } if(timed > 0 && getOutputPlasticIncr() && dw != NULL) { pvdata_t dwCorrect = wx; pvdata_t dwObserved = dw[k]; if( dwObserved != dwCorrect ) { int y=kyPos(k,nxp,nyp,nfp); int f=featureIndex(k,nxp,nyp,nfp); outputStream->printf(" index %d (x=%d, y=%d, f=%d: dw = %f, should be %f\n", k, x, y, f, dwObserved, dwCorrect); } } } assert(status==PV_SUCCESS); if( status == PV_SUCCESS ) { if (getOutputWeights()) { outputStream->printf(" All weights are correct.\n"); } if (getOutputPlasticIncr()) { outputStream->printf(" All plastic increments are correct.\n"); } } if(getOutputPatchIndices()) { patchIndices(c); } return PV_SUCCESS; }
int GatePoolTestLayer::updateState(double timef, double dt) { //Do update state of ANN Layer first ANNLayer::updateState(timef, dt); //Grab layer size const PVLayerLoc* loc = getLayerLoc(); int nx = loc->nx; int ny = loc->ny; int nxGlobal = loc->nxGlobal; int nyGlobal = loc->nyGlobal; int nf = loc->nf; int kx0 = loc->kx0; int ky0 = loc->ky0; bool isCorrect = true; //Grab the activity layer of current layer for(int b = 0; b < loc->nbatch; b++) { const pvdata_t * A = getActivity() + b * getNumExtended(); //We only care about restricted space, but iY and iX are extended for(int iY = loc->halo.up; iY < ny + loc->halo.up; iY++) { for(int iX = loc->halo.lt; iX < nx + loc->halo.lt; iX++) { for(int iFeature = 0; iFeature < nf; iFeature++) { int ext_idx = kIndex(iX, iY, iFeature, nx+loc->halo.lt+loc->halo.rt, ny+loc->halo.dn+loc->halo.up, nf); float actualvalue = A[ext_idx]; int xval = (iX + kx0 - loc->halo.lt)/2; int yval = (iY + ky0 - loc->halo.up)/2; assert(xval >= 0 && xval < loc->nxGlobal); assert(yval >= 0 && yval < loc->nxGlobal); float expectedvalue; expectedvalue = iFeature * 64 + yval * 16 + xval * 2 + 4.5; expectedvalue*=4; if(fabs(actualvalue - expectedvalue) >= 1e-4) { pvErrorNoExit() << "Connection " << name << " Mismatch at (" << iX << "," << iY << ") : actual value: " << actualvalue << " Expected value: " << expectedvalue << ". Discrepancy is a whopping " << actualvalue - expectedvalue << "! Horrors!" << "\n"; isCorrect = false; } } } } } if(!isCorrect) { InterColComm * icComm = parent->icCommunicator(); MPI_Barrier(icComm->communicator()); // If there is an error, make sure that MPI doesn't kill the run before process 0 reports the error. exit(-1); } return PV_SUCCESS; }
bool DisparityMovie::updateImage(double timef, double dt){ InterColComm * icComm = getParent()->icCommunicator(); assert(!readPvpFile); if(fabs(timef - (parent->getStartTime() + parent->getDeltaTime())) > (parent->getDeltaTime()/2)){ //If disparity is over numDisparity, read new image and reset index if(disparityIndex >= numDisparity - 1){ if (filename != NULL) free(filename); filename = strdup(getNextFileName(skipFrameIndex)); disparityIndex = 0; frameCount++; } else{ disparityIndex++; } } assert(filename != NULL); //Set frame number (member variable in Image) int newOffsetX; if((frameCount + frameOffset) % 2 == 0){ newOffsetX = this->offsets[0]; } else{ newOffsetX = this->offsets[0] + (disparityIndex * dPixelDisparity); } int status = readImage(filename, newOffsetX, this->offsets[1], this->offsetAnchor); if( status != PV_SUCCESS ) { fprintf(stderr, "Movie %s: Error reading file \"%s\"\n", name, filename); abort(); } //Write to timestamp file here when updated if( icComm->commRank()==0 ) { //Only write if the parameter is set if(timestampFile){ std::ostringstream outStrStream; outStrStream.precision(15); outStrStream << frameNumber << "," << timef << "," << filename << "\n"; size_t len = outStrStream.str().length(); int status = PV_fwrite(outStrStream.str().c_str(), sizeof(char), len, timestampFile)==len ? PV_SUCCESS : PV_FAILURE; if (status != PV_SUCCESS) { fprintf(stderr, "%s \"%s\" error: Movie::updateState failed to write to timestamp file.\n", parent->parameters()->groupKeywordFromName(name), name); exit(EXIT_FAILURE); } //Flush buffer fflush(timestampFile->fp); } } return true; }
/** * @timef */ int MomentumConnTestProbe::outputState(double timed) { HyPerConn * c = getTargetHyPerConn(); InterColComm * icComm = c->getParent()->icCommunicator(); const int rcvProc = 0; if( icComm->commRank() != rcvProc ) { return PV_SUCCESS; } assert(getTargetConn()!=NULL); FILE * fp = getStream()->fp; fprintf(fp, " Time %f, connection \"%s\":\n", timed, getTargetName()); const pvwdata_t * w = c->get_wDataHead(getArbor(), getKernelIndex()); const pvdata_t * dw = c->get_dwDataHead(getArbor(), getKernelIndex()); if( getOutputPlasticIncr() && dw == NULL ) { fprintf(stderr, "MomentumConnTestProbe \"%s\": connection \"%s\" has dKernelData(%d,%d) set to null.\n", getName(), getTargetName(), getKernelIndex(), getArbor()); assert(false); } int nxp = c->xPatchSize(); int nyp = c->yPatchSize(); int nfp = c->fPatchSize(); int status = PV_SUCCESS; for( int k=0; k<nxp*nyp*nfp; k++ ) { pvdata_t wObserved = w[k]; //Pulse happens at time 3 pvdata_t wCorrect; if(timed < 3){ wCorrect = 0; } else{ if(isViscosity){ wCorrect = 1; for(int i = 0; i < (timed - 3); i++){ wCorrect += exp(-(2*(i+1))); } } else{ wCorrect = 2 - pow(2, -(timed - 3)); } } if( fabs( ((double) (wObserved - wCorrect))/timed ) > 1e-4 ) { int y=kyPos(k,nxp,nyp,nfp); int f=featureIndex(k,nxp,nyp,nfp); fprintf(fp, " w = %f, should be %f\n", wObserved, wCorrect); exit(-1); } } return PV_SUCCESS; }
int BatchSweepTestProbe::outputState(double timed) { int status = StatsProbe::outputState(timed); InterColComm * icComm = getTargetLayer()->getParent()->icCommunicator(); const int rcvProc = 0; if( icComm->commRank() != rcvProc ) { return 0; } for(int b = 0; b < parent->getNBatch(); b++){ if (timed >= 3.0 ) { assert(fabs(expectedSum - sum[b])<1e-6); assert(fabs(expectedMin - fMin[b])<1e-6); assert(fabs(expectedMax - fMax[b])<1e-6); } } return status; }
int InitWeightTestProbe::outputState(double timed) { int status = StatsProbe::outputState(timed); InterColComm * icComm = getTargetLayer()->getParent()->icCommunicator(); const int rcvProc = 0; if( icComm->commRank() != rcvProc ) { return 0; } for(int b = 0; b < parent->getNBatch(); b++){ if(timed>2.0f){ assert((fMin[b]>-0.001)&&(fMin[b]<0.001)); assert((fMax[b]>-0.001)&&(fMax[b]<0.001)); assert((avg[b]>-0.001)&&(avg[b]<0.001)); } } return status; }
int CloneKernelConnTestProbe::outputState(double timed) { int status = StatsProbe::outputState(timed); InterColComm * icComm = getTargetLayer()->getParent()->icCommunicator(); const int rcvProc = 0; if( icComm->commRank() != rcvProc ) { return 0; } for(int b = 0; b < getParent()->getNBatch(); b++){ if(timed>2.0f){ assert(fabs(fMin[b]) < 1e-6); assert(fabs(fMax[b]) < 1e-6); assert(fabs(avg[b]) < 1e-6); } } return status; }
/** * @time * @l */ int MPITestProbe::outputState(double timed) { int status = StatsProbe::outputState(timed); InterColComm * icComm = getTargetLayer()->getParent()->icCommunicator(); const int rcvProc = 0; if( icComm->commRank() != rcvProc ) { return status; } double tol = 1e-4f; // if many to one connection, each neuron should receive its global x/y/f position // if one to many connection, the position of the nearest sending cell is received // assume sending layer has scale factor == 1 int xScaleLog2 = getTargetLayer()->getCLayer()->xScale; // determine min/max position of receiving layer const PVLayerLoc * loc = getTargetLayer()->getLayerLoc(); int nf = loc->nf; int nxGlobal = loc->nxGlobal; int nyGlobal = loc->nyGlobal; float min_global_xpos = xPosGlobal(0, xScaleLog2, nxGlobal, nyGlobal, nf); int kGlobal = nf * nxGlobal * nyGlobal - 1; float max_global_xpos = xPosGlobal(kGlobal, xScaleLog2, nxGlobal, nyGlobal, nf); if (xScaleLog2 < 0) { float xpos_shift = 0.5 - min_global_xpos; min_global_xpos = 0.5; max_global_xpos -= xpos_shift; } float ave_global_xpos = (min_global_xpos + max_global_xpos) / 2.0f; outputStream->printf("%s min_global_xpos==%f ave_global_xpos==%f max_global_xpos==%f", getMessage(), min_global_xpos, ave_global_xpos, max_global_xpos); output() << std::endl; for(int b = 0; b < parent->getNBatch(); b++){ if (timed > 3.0f) { assert((fMin[b]/min_global_xpos > (1 - tol)) && (fMin[b]/min_global_xpos < (1 + tol))); assert((fMax[b]/max_global_xpos > (1 - tol)) && (fMax[b]/max_global_xpos < (1 + tol))); assert((avg[b]/ave_global_xpos > (1 - tol)) && (avg[b]/ave_global_xpos < (1 + tol))); } } return status; }
int customexit(HyPerCol * hc, int argc, char ** argv) { pvadata_t correctvalue = 0.5f; pvadata_t tolerance = 1.0e-7f; if (hc->columnId()==0) { pvInfo().printf("Checking whether input layer has all values equal to %f ...\n", correctvalue); } HyPerLayer * inputlayer = hc->getLayerFromName("input"); assert(inputlayer); PVLayerLoc const * loc = inputlayer->getLayerLoc(); assert(loc->nf==1); const int numNeurons = inputlayer->getNumNeurons(); assert(numNeurons>0); int status = PV_SUCCESS; int numExtended = inputlayer->getNumExtended(); InterColComm * icComm = hc->icCommunicator(); pvadata_t * layerData = (pvadata_t *) icComm->publisherStore(inputlayer->getLayerId())->buffer(LOCAL); int rootproc = 0; if (icComm->commRank()==rootproc) { pvadata_t * databuffer = (pvadata_t *) malloc(numExtended*sizeof(pvadata_t)); assert(databuffer); for (int proc=0; proc<icComm->commSize(); proc++) { if (proc==rootproc) { memcpy(databuffer, layerData, numExtended*sizeof(pvadata_t)); } else { MPI_Recv(databuffer, numExtended*sizeof(pvadata_t),MPI_BYTE,proc,15,icComm->communicator(), MPI_STATUS_IGNORE); } // At this point, databuffer on rank 0 should contain the extended input layer on rank proc for (int k=0; k<numNeurons; k++) { int kExt = kIndexExtended(k,loc->nx,loc->ny,loc->nf,loc->halo.lt,loc->halo.rt,loc->halo.dn,loc->halo.up); pvadata_t value = databuffer[kExt]; if (fabs(value-correctvalue)>=tolerance) { pvErrorNoExit().printf("Rank %d, restricted index %d, extended index %d, value is %f instead of %f\n", proc, k, kExt, value, correctvalue); status = PV_FAILURE; } } } free(databuffer); if (status == PV_SUCCESS) { pvInfo().printf("%s succeeded.\n", argv[0]); } else { pvError().printf("%s failed.\n", argv[0]); } } else { MPI_Send(layerData,numExtended*sizeof(pvadata_t),MPI_BYTE,rootproc,15,icComm->communicator()); } MPI_Barrier(icComm->communicator()); return status; }
int RescaleLayerTestProbe::outputState(double timed) { int status = StatsProbe::outputState(timed); if (timed==getParent()->getStartTime()) { return PV_SUCCESS; } float tolerance = 2.0e-5f; InterColComm * icComm = getTargetLayer()->getParent()->icCommunicator(); bool isRoot = icComm->commRank() == 0; RescaleLayer * targetRescaleLayer = dynamic_cast<RescaleLayer *>(getTargetLayer()); assert(targetRescaleLayer); if (targetRescaleLayer->getRescaleMethod()==NULL) { fprintf(stderr, "RescaleLayerTestProbe \"%s\": RescaleLayer \"%s\" does not have rescaleMethod set. Exiting.\n", name, targetRescaleLayer->getName()); status = PV_FAILURE; } else if (!strcmp(targetRescaleLayer->getRescaleMethod(), "maxmin")) { if (!isRoot) { return PV_SUCCESS; } for(int b = 0; b < parent->getNBatch(); b++){ float targetMax = targetRescaleLayer->getTargetMax(); if (fabs(fMax[b]-targetMax)>tolerance) { fprintf(stderr, "RescaleLayerTestProbe \"%s\": RescaleLayer \"%s\" has max %f instead of target max %f\n", getName(), targetRescaleLayer->getName(), fMax[b], targetMax); status = PV_FAILURE; } float targetMin = targetRescaleLayer->getTargetMin(); if (fabs(fMin[b]-targetMin)>tolerance) { fprintf(stderr, "RescaleLayerTestProbe \"%s\": RescaleLayer \"%s\" has min %f instead of target min %f\n", getName(), targetRescaleLayer->getName(), fMin[b], targetMin); status = PV_FAILURE; } // Now, check whether rescaled activity and original V are colinear. PVLayerLoc const * rescaleLoc = targetRescaleLayer->getLayerLoc(); PVHalo const * rescaleHalo = &rescaleLoc->halo; int nk = rescaleLoc->nx * rescaleLoc->nf; int ny = rescaleLoc->ny; int rescaleStrideYExtended = (rescaleLoc->nx + rescaleHalo->lt + rescaleHalo->rt) * rescaleLoc->nf; int rescaleExtendedOffset = kIndexExtended(0, rescaleLoc->nx, rescaleLoc->ny, rescaleLoc->nf, rescaleHalo->lt, rescaleHalo->rt, rescaleHalo->dn, rescaleHalo->up); pvadata_t const * rescaledData = targetRescaleLayer->getLayerData() + b * targetRescaleLayer->getNumExtended() + rescaleExtendedOffset; PVLayerLoc const * origLoc = targetRescaleLayer->getOriginalLayer()->getLayerLoc(); PVHalo const * origHalo = &origLoc->halo; assert(nk == origLoc->nx * origLoc->nf); assert(ny == origLoc->ny); int origStrideYExtended = (origLoc->nx + origHalo->lt + origHalo->rt) * origLoc->nf; int origExtendedOffset = kIndexExtended(0, rescaleLoc->nx, rescaleLoc->ny, rescaleLoc->nf, rescaleHalo->lt, rescaleHalo->rt, rescaleHalo->dn, rescaleHalo->up); pvadata_t const * origData = targetRescaleLayer->getOriginalLayer()->getLayerData() + b * targetRescaleLayer->getOriginalLayer()->getNumExtended() + origExtendedOffset; bool iscolinear = colinear(nk, ny, origStrideYExtended, rescaleStrideYExtended, origData, rescaledData, tolerance, NULL, NULL, NULL); if (!iscolinear) { fprintf(stderr, "RescaleLayerTestProbe \"%s\": Rescale layer \"%s\" data is not a linear rescaling of original membrane potential.\n", getName(), targetRescaleLayer->getName()); status = PV_FAILURE; } } } //l2 norm with a patch size of 1 (default) should be the same as rescaling with meanstd with target mean 0 and std of 1/sqrt(patchsize) else if (!strcmp(targetRescaleLayer->getRescaleMethod(), "meanstd") || !strcmp(targetRescaleLayer->getRescaleMethod(), "l2")) { if (!isRoot) { return PV_SUCCESS; } for(int b = 0; b < parent->getNBatch(); b++){ float targetMean, targetStd; if(!strcmp(targetRescaleLayer->getRescaleMethod(), "meanstd")){ targetMean = targetRescaleLayer->getTargetMean(); targetStd = targetRescaleLayer->getTargetStd(); } else{ targetMean = 0; targetStd = 1/sqrt((float)targetRescaleLayer->getL2PatchSize()); } if (fabs(avg[b]-targetMean)>tolerance) { fprintf(stderr, "RescaleLayerTestProbe \"%s\": RescaleLayer \"%s\" has mean %f instead of target mean %f\n", getName(), targetRescaleLayer->getName(), (double)avg[b], targetMean); status = PV_FAILURE; } if (sigma[b]>tolerance && fabs(sigma[b]-targetStd)>tolerance) { fprintf(stderr, "RescaleLayerTestProbe \"%s\": RescaleLayer \"%s\" has std.dev. %f instead of target std.dev. %f\n", getName(), targetRescaleLayer->getName(), (double)sigma[b], targetStd); status = PV_FAILURE; } // Now, check whether rescaled activity and original V are colinear. PVLayerLoc const * rescaleLoc = targetRescaleLayer->getLayerLoc(); PVHalo const * rescaleHalo = &rescaleLoc->halo; int nk = rescaleLoc->nx * rescaleLoc->nf; int ny = rescaleLoc->ny; int rescaleStrideYExtended = (rescaleLoc->nx + rescaleHalo->lt + rescaleHalo->rt) * rescaleLoc->nf; int rescaleExtendedOffset = kIndexExtended(0, rescaleLoc->nx, rescaleLoc->ny, rescaleLoc->nf, rescaleHalo->lt, rescaleHalo->rt, rescaleHalo->dn, rescaleHalo->up); pvadata_t const * rescaledData = targetRescaleLayer->getLayerData() + b*targetRescaleLayer->getNumExtended() + rescaleExtendedOffset; PVLayerLoc const * origLoc = targetRescaleLayer->getOriginalLayer()->getLayerLoc(); PVHalo const * origHalo = &origLoc->halo; assert(nk == origLoc->nx * origLoc->nf); assert(ny == origLoc->ny); int origStrideYExtended = (origLoc->nx + origHalo->lt + origHalo->rt) * origLoc->nf; int origExtendedOffset = kIndexExtended(0, rescaleLoc->nx, rescaleLoc->ny, rescaleLoc->nf, rescaleHalo->lt, rescaleHalo->rt, rescaleHalo->dn, rescaleHalo->up); pvadata_t const * origData = targetRescaleLayer->getOriginalLayer()->getLayerData() + b*targetRescaleLayer->getOriginalLayer()->getNumExtended() + origExtendedOffset; bool iscolinear = colinear(nk, ny, origStrideYExtended, rescaleStrideYExtended, origData, rescaledData, tolerance, NULL, NULL, NULL); if (!iscolinear) { fprintf(stderr, "RescaleLayerTestProbe \"%s\": Rescale layer \"%s\" data is not a linear rescaling of original membrane potential.\n", getName(), targetRescaleLayer->getName()); status = PV_FAILURE; } } } else if (!strcmp(targetRescaleLayer->getRescaleMethod(), "pointmeanstd")) { PVLayerLoc const * loc = targetRescaleLayer->getLayerLoc(); int nf = loc->nf; if (nf<2) { return PV_SUCCESS; } PVHalo const * halo = &loc->halo; float targetMean = targetRescaleLayer->getTargetMean(); float targetStd = targetRescaleLayer->getTargetStd(); int numNeurons = targetRescaleLayer->getNumNeurons(); for(int b = 0; b < parent->getNBatch(); b++){ pvpotentialdata_t const * originalData = targetRescaleLayer->getV() + b*targetRescaleLayer->getNumNeurons(); pvadata_t const * rescaledData = targetRescaleLayer->getLayerData() + b*targetRescaleLayer->getNumExtended(); for (int k=0; k<numNeurons; k+=nf) { int kExtended = kIndexExtended(k, loc->nx, loc->ny, loc->nf, halo->lt, halo->rt, halo->dn, halo->up); double pointmean = 0.0; for (int f=0; f<nf; f++) { pointmean += rescaledData[kExtended+f]; } pointmean /= nf; double pointstd = 0.0; for (int f=0; f<nf; f++) { double d = rescaledData[kExtended+f]-pointmean; pointstd += d*d; } pointstd /= nf; pointstd = sqrt(pointstd); if (fabs(pointmean-targetMean)>tolerance) { fprintf(stderr, "RescaleLayerTestProbe \"%s\": RescaleLayer \"%s\", location in rank %d, starting at restricted neuron %d, has mean %f instead of target mean %f\n", getName(), targetRescaleLayer->getName(), getParent()->columnId(), k, pointmean, targetMean); status = PV_FAILURE; } if (pointstd>tolerance && fabs(pointstd-targetStd)>tolerance) { fprintf(stderr, "RescaleLayerTestProbe \"%s\": RescaleLayer \"%s\", location in rank %d, starting at restricted neuron %d, has std.dev. %f instead of target std.dev. %f\n", getName(), targetRescaleLayer->getName(), getParent()->columnId(), k, pointstd, targetStd); status = PV_FAILURE; } bool iscolinear = colinear(nf, 1, 0, 0, &originalData[k], &rescaledData[kExtended], tolerance, NULL, NULL, NULL); if (!iscolinear) { fprintf(stderr, "RescaleLayerTestProbe \"%s\": RescaleLayer \"%s\", location in rank %d, starting at restricted neuron %d, is not a linear rescaling.\n", getName(), targetRescaleLayer->getName(), parent->columnId(), k); status = PV_FAILURE; } } } } else if (!strcmp(targetRescaleLayer->getRescaleMethod(), "zerotonegative")) { int numNeurons = targetRescaleLayer->getNumNeurons(); assert(numNeurons == targetRescaleLayer->getOriginalLayer()->getNumNeurons()); PVLayerLoc const * rescaleLoc = targetRescaleLayer->getLayerLoc(); PVHalo const * rescaleHalo = &rescaleLoc->halo; int nf = rescaleLoc->nf; HyPerLayer * originalLayer = targetRescaleLayer->getOriginalLayer(); PVLayerLoc const * origLoc = originalLayer->getLayerLoc(); PVHalo const * origHalo = &origLoc->halo; assert(origLoc->nf == nf); for(int b = 0; b < parent->getNBatch(); b++){ pvadata_t const * rescaledData = targetRescaleLayer->getLayerData() + b * targetRescaleLayer->getNumExtended(); pvadata_t const * originalData = originalLayer->getLayerData() + b * originalLayer->getNumExtended(); for (int k=0; k<numNeurons; k++) { int rescale_kExtended = kIndexExtended(k, rescaleLoc->nx, rescaleLoc->ny, rescaleLoc->nf, rescaleHalo->lt, rescaleHalo->rt, rescaleHalo->dn, rescaleHalo->up); int orig_kExtended = kIndexExtended(k, origLoc->nx, origLoc->ny, origLoc->nf, origHalo->lt, origHalo->rt, origHalo->dn, origHalo->up); pvadata_t observedval = rescaledData[rescale_kExtended]; pvpotentialdata_t correctval = originalData[orig_kExtended] ? observedval : -1.0; if (observedval != correctval) { fprintf(stderr, "RescaleLayerTestProbe \"%s\": RescaleLayer \"%s\", rank %d, restricted neuron %d has value %f instead of expected %f\n.", this->getName(), targetRescaleLayer->getName(), parent->columnId(), k, observedval, correctval); status = PV_FAILURE; } } } } else { assert(0); // All allowable rescaleMethod values are handled above. } if (status == PV_FAILURE) { exit(EXIT_FAILURE); } return status; }
int main(int argc, char * argv[]) { PV_Init* initObj = new PV_Init(&argc, &argv, false/*allowUnrecognizedArguments*/); InterColComm * icComm = new InterColComm(initObj->getArguments()); PV_Arguments * arguments = initObj->getArguments(); if (arguments->getParamsFile() != NULL) { int rank = icComm->globalCommRank(); if (rank==0) { fprintf(stderr, "%s does not take -p as an option. Instead the necessary params file is hard-coded.\n", arguments->getProgramName()); } MPI_Barrier(MPI_COMM_WORLD); exit(EXIT_FAILURE); } arguments->setParamsFile("input/TransposeHyPerConnTest.params"); initObj->initialize(); // Don't call buildandrun because it will delete hc before returning. (I could use the customexit hook) HyPerCol * hc = build(initObj); hc->run(); // Weight values are initialized when run calls allocateDataStructures int status = PV_SUCCESS; HyPerConn * originalMap = NULL; TransposeConn * transpose = NULL; TransposeConn * transposeOfTranspose = NULL; BaseConnection * baseConn; baseConn = hc->getConnFromName("Original Map for One to One Test"); originalMap = dynamic_cast<HyPerConn *>(baseConn); //assert(originalMap->usingSharedWeights()); transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for One to One Test of TransposeConn")); transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for One to One Test of TransposeConn")); status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "One-to-one case, TransposeConn"); baseConn = hc->getConnFromName("Original Map for Many to One Test"); originalMap = dynamic_cast<HyPerConn *>(baseConn); //assert(originalMap->usingSharedWeights()); transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for Many to One Test of TransposeConn")); transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for Many to One Test of TransposeConn")); status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "Many-to-one case, TransposeConn"); baseConn = hc->getConnFromName("Original Map for One to Many Test"); originalMap = dynamic_cast<HyPerConn *>(baseConn); //assert(originalMap->usingSharedWeights()); transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for One to Many Test of TransposeConn")); transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for One to Many Test of TransposeConn")); status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "One-to-many case, TransposeConn"); baseConn = hc->getConnFromName("Original Map for One to One Test"); originalMap = dynamic_cast<HyPerConn *>(baseConn); //assert(originalMap->usingSharedWeights()); transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for One to One Test of FeedbackConn")); transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for One to One Test of FeedbackConn")); status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "One-to-one case, FeedbackConn"); baseConn = hc->getConnFromName("Original Map for Many to One Test"); originalMap = dynamic_cast<HyPerConn *>(baseConn); //assert(originalMap->usingSharedWeights()); transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for Many to One Test of FeedbackConn")); transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for Many to One Test of FeedbackConn")); status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "Many-to-one case, FeedbackConn"); baseConn = hc->getConnFromName("Original Map for One to Many Test"); originalMap = dynamic_cast<HyPerConn *>(baseConn); //assert(originalMap->usingSharedWeights()); transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for One to Many Test of FeedbackConn")); transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for One to Many Test of FeedbackConn")); status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "One-to-many case, FeedbackConn"); delete hc; delete initObj; return status; }
int SegmentLayer::updateState(double timef, double dt) { pvdata_t* srcA = originalLayer->getActivity(); pvdata_t* thisA = getActivity(); assert(srcA); assert(thisA); const PVLayerLoc* loc = getLayerLoc(); //Segment input layer based on segmentMethod if(strcmp(segmentMethod, "none") == 0){ int numBatchExtended = getNumExtendedAllBatches(); //Copy activity over //Since both buffers should be identical size, we can do a memcpy here memcpy(thisA, srcA, numBatchExtended * sizeof(pvdata_t)); } else{ //This case should never happen assert(0); } assert(loc->nf == 1); //Clear centerIdxs for(int bi = 0; bi < loc->nbatch; bi++){ centerIdx[bi].clear(); } for(int bi = 0; bi < loc->nbatch; bi++){ pvdata_t* batchA = thisA + bi * getNumExtended(); //Reset max/min buffers maxX.clear(); maxY.clear(); minX.clear(); minY.clear(); //Loop through this buffer to fill labelVec and idxVec //Looping through restricted, but indices are extended for(int yi = loc->halo.up; yi < loc->ny+loc->halo.up; yi++){ for(int xi = loc->halo.lt; xi < loc->nx+loc->halo.lt; xi++){ //Convert to local extended linear index int niLocalExt = yi * (loc->nx+loc->halo.lt+loc->halo.rt) + xi; //Convert yi and xi to global res index int globalResYi = yi - loc->halo.up + loc->ky0; int globalResXi = xi - loc->halo.lt + loc->kx0; //Get label value //Note that we're assuming that the activity here are integers, //even though the buffer is floats int labelVal = round(batchA[niLocalExt]); //Calculate max/min x and y for a single batch //If labelVal exists in map if(maxX.count(labelVal)){ //Here, we're assuming the 4 maps are in sync, so we use the //.at method, as it will throw an exception as opposed to the //[] operator, which will simply add the key into the map if(globalResXi > maxX.at(labelVal)){ maxX[labelVal] = globalResXi; } if(globalResXi < minX.at(labelVal)){ minX[labelVal] = globalResXi; } if(globalResYi > maxY.at(labelVal)){ maxY[labelVal] = globalResYi; } if(globalResYi < minY.at(labelVal)){ minY[labelVal] = globalResYi; } } //If doesn't exist, add into map with current vals else{ maxX[labelVal] = globalResXi; minX[labelVal] = globalResXi; maxY[labelVal] = globalResYi; minY[labelVal] = globalResYi; } } } //We need to mpi across processors in case a segment crosses an mpi boundary InterColComm * icComm = parent->icCommunicator(); int numMpi = icComm->commSize(); int rank = icComm->commRank(); //Local comm rank //Non root processes simply send buffer size and then buffers int numLabels = maxX.size(); if(rank != 0){ //Load buffers loadLabelBuf(); //Send number of labels first MPI_Send(&numLabels, 1, MPI_INT, 0, rank, icComm->communicator()); //Send labels, then max/min buffers MPI_Send(labelBuf, numLabels, MPI_INT, 0, rank, icComm->communicator()); MPI_Send(maxXBuf, numLabels, MPI_INT, 0, rank, icComm->communicator()); MPI_Send(maxYBuf, numLabels, MPI_INT, 0, rank, icComm->communicator()); MPI_Send(minXBuf, numLabels, MPI_INT, 0, rank, icComm->communicator()); MPI_Send(minYBuf, numLabels, MPI_INT, 0, rank, icComm->communicator()); //Receive the full centerIdxBuf from root process int numCenterIdx = 0; MPI_Bcast(&numCenterIdx, 1, MPI_INT, 0, icComm->communicator()); checkIdxBufSize(numCenterIdx); MPI_Bcast(allLabelsBuf, numCenterIdx, MPI_INT, 0, icComm->communicator()); MPI_Bcast(centerIdxBuf, numCenterIdx, MPI_INT, 0, icComm->communicator()); //Load buffer into centerIdx map loadCenterIdxMap(bi, numCenterIdx); } //Root process stores everything else{ //One recv per buffer for(int recvRank = 1; recvRank < numMpi; recvRank++){ int numRecvLabels = 0; MPI_Recv(&numRecvLabels, 1, MPI_INT, recvRank, recvRank, icComm->communicator(), NULL); checkLabelBufSize(numRecvLabels); MPI_Recv(labelBuf, numRecvLabels, MPI_INT, recvRank, recvRank, icComm->communicator(), NULL); MPI_Recv(maxXBuf, numRecvLabels, MPI_INT, recvRank, recvRank, icComm->communicator(), NULL); MPI_Recv(maxYBuf, numRecvLabels, MPI_INT, recvRank, recvRank, icComm->communicator(), NULL); MPI_Recv(minXBuf, numRecvLabels, MPI_INT, recvRank, recvRank, icComm->communicator(), NULL); MPI_Recv(minYBuf, numRecvLabels, MPI_INT, recvRank, recvRank, icComm->communicator(), NULL); for(int i = 0; i < numRecvLabels; i++){ int label = labelBuf[i]; //Add on to maps //If the label already exists, fill with proper max/min if(maxX.count(label)){ if(maxXBuf[i] > maxX.at(label)){ maxX[label] = maxXBuf[i]; } if(maxYBuf[i] > maxY.at(label)){ maxY[label] = maxYBuf[i]; } if(minXBuf[i] < minX.at(label)){ minX[label] = minXBuf[i]; } if(minYBuf[i] < minY.at(label)){ minY[label] = minYBuf[i]; } } else{ maxX[label] = maxXBuf[i]; maxY[label] = maxYBuf[i]; minX[label] = minXBuf[i]; minY[label] = minYBuf[i]; } } } //Maps are now filled with all segments from the image //Fill centerIdx based on max/min for(std::map<int, int>::iterator it = maxX.begin(); it != maxX.end(); ++it){ int label = it->first; int centerX = minX.at(label) + (maxX.at(label) - minX.at(label))/2; int centerY = minY.at(label) + (maxY.at(label) - minY.at(label))/2; //Convert centerpoints (in global res idx) to linear idx (in global res space) int centerIdxVal = centerY * (loc->nxGlobal) + centerX; //Add to centerIdxMap centerIdx[bi][label] = centerIdxVal; } //Fill centerpoint buffer int numCenterIdx = centerIdx[bi].size(); checkIdxBufSize(numCenterIdx); int idx = 0; for(std::map<int, int>::iterator it = centerIdx[bi].begin(); it != centerIdx[bi].end(); ++it){ allLabelsBuf[idx] = it->first; centerIdxBuf[idx] = it->second; idx++; } //Broadcast buffers MPI_Bcast(&numCenterIdx, 1, MPI_INT, 0, icComm->communicator()); MPI_Bcast(allLabelsBuf, numCenterIdx, MPI_INT, 0, icComm->communicator()); MPI_Bcast(centerIdxBuf, numCenterIdx, MPI_INT, 0, icComm->communicator()); } } //End batch loop //centerIdx now stores each center coordinate of each segment return PV_SUCCESS; }
int MapReduceKernelConn::reduceKernels(const int arborID) { int status = HyPerConn::reduceKernels(arborID); int rootproc = 0; InterColComm *icComm = parent->icCommunicator(); const int numPatches = getNumDataPatches(); const size_t patchSize = nxp * nyp * nfp * sizeof(pvdata_t); const size_t localSize = numPatches * patchSize; const size_t arborSize = localSize * this->numberOfAxonalArborLists(); if (icComm->commRank() == rootproc) { // write dW for this instantiation of PetaVision to disk status = HyPerConn::writeWeights(NULL, this->get_dwDataStart(), getNumDataPatches(), dWeightsList[dWeightFileIndex], parent->simulationTime(), /*writeCompressedWeights*/false, /*last*/ false); if (status != PV_SUCCESS) { fprintf(stderr, "MapReduceKernelConn::reduceKernels::HyPerConn::writeWeights: problem writing to file %s, " "SHUTTING DOWN\n", dWeightsList[dWeightFileIndex]); exit(EXIT_FAILURE); } // status // use dWeightsList to read in the weights written by other PetaVision instantiations double dW_time; double simulation_time = parent->simulationTime(); int filetype, datatype; int numParams = NUM_BIN_PARAMS + NUM_WGT_EXTRA_PARAMS; int params[NUM_BIN_PARAMS + NUM_WGT_EXTRA_PARAMS]; const PVLayerLoc *preLoc = this->preSynapticLayer()->getLayerLoc(); int file_count = 0; for (file_count = 0; file_count < num_dWeightFiles; file_count++) { if (file_count == dWeightFileIndex) { continue; } int num_attempts = 0; const int MAX_ATTEMPTS = 5; dW_time = 0; while (dW_time < simulation_time && num_attempts <= MAX_ATTEMPTS) { pvp_read_header(dWeightsList[file_count], icComm, &dW_time, &filetype, &datatype, params, &numParams); num_attempts++; } // while if (num_attempts > MAX_ATTEMPTS) { fprintf(stderr, "PV::MapReduceKernelConn::reduceKernels: problem reading arbor file %s, SHUTTING DOWN\n", dWeightsList[file_count]); status = EXIT_FAILURE; exit(EXIT_FAILURE); } // num_attempts > MAX_ATTEMPTS int status = PV::readWeights(NULL, get_dwDataStart(), this->numberOfAxonalArborLists(), this->getNumDataPatches(), nxp, nyp, nfp, dWeightsList[file_count], icComm, &dW_time, preLoc); if (status != PV_SUCCESS) { fprintf(stderr, "MapReduceKernelConn::reduceKernels::PV::readWeights: problem reading file %s, " "SHUTTING DOWN\n", dWeightsList[file_count]); exit(EXIT_FAILURE); } // status } // file_count < numWeightFiles // average dW from map-reduce pvwdata_t * dW_data = this->get_dwDataStart(0); for (int i_dW = 0; i_dW < arborSize; i_dW++) { dW_data[i_dW] /= num_dWeightFiles; } } // rootproc // broadcast map-reduced dWeights to all non-root processes MPI_Comm mpi_comm = icComm->communicator(); #ifdef PV_USE_MPI MPI_Bcast(this->get_wDataStart(0), arborSize, MPI_FLOAT, rootproc, mpi_comm); #endif return PV_BREAK; }