void ParallelInfo::sendZi(const Pattern &toSend) { int P_Tag = 0; #if defined(TIMING_MODE) long long elapsed, start; elapsed = 0; #endif // 10-2-2002, Replaced MPI_Send with MPI_Rsend // this assumes that the comp nodes have already // called MPI_Recv, which they should have. for (unsigned int i = 1; i < P_NumNodes; i++) { #if defined(TIMING_MODE) start = rdtsc(); #endif int * tmpToSend = new int[totalNumNrns]; for (unsigned int nrn = 0; nrn < totalNumNrns; nrn++) tmpToSend[nrn] = toSend.at(nrn); MPI_Rsend(&tmpToSend[0], totalNumNrns, MPI_INT, i, P_Tag, MPI_COMM_WORLD); #if defined(TIMING_MODE) elapsed += rdtsc() - start; #endif } #if defined(TIMING_MODE) Output::Out() << "Elapsed root_snd time = " << elapsed * 1.0 / TICKS_PER_SEC << " seconds" << endl; #endif }
void RateMeyerHaeseler::computeFuncDerv(double value, double &df, double &ddf) { int nseq = phylo_tree->leafNum; int nstate = phylo_tree->getModel()->num_states; int i, j, state1, state2; // double lh = 0.0; double trans, derv1, derv2; ModelSubst *model = phylo_tree->getModel(); Pattern *pat = & phylo_tree->aln->at(optimizing_pattern); df = ddf = 0.0; for (i = 0; i < nseq-1; i++) if ((state1 = pat->at(i)) < nstate) for (j = i+1; j < nseq; j++) if ((state2 = pat->at(j)) < nstate) { double dist = dist_mat[i*nseq + j]; trans = model->computeTrans(value * dist, state1, state2, derv1, derv2); // lh -= log(trans); double t1 = derv1 / trans; double t2 = derv2 / trans; df -= t1 * dist; ddf -= dist * dist * (t2 - t1*t1); } // return lh; }
double RateMeyerHaeseler::computeFunction(double value) { if (!rate_mh) { if (value != cur_scale) { ptn_tree->scaleLength(value/cur_scale); cur_scale = value; ptn_tree->clearAllPartialLH(); } return -ptn_tree->computeLikelihood(); } int nseq = phylo_tree->leafNum; int nstate = phylo_tree->getModel()->num_states; int i, j, state1, state2; double lh = 0.0; ModelSubst *model = phylo_tree->getModel(); Pattern *pat = & phylo_tree->aln->at(optimizing_pattern); for (i = 0; i < nseq-1; i++) if ((state1 = pat->at(i)) < nstate) for (j = i+1; j < nseq; j++) if ((state2 = pat->at(j)) < nstate) lh -= log(model->computeTrans(value * dist_mat[i*nseq + j], state1, state2)); return lh; }
double RateMeyerDiscrete::computeFunction(double value) { if (!is_categorized) return RateMeyerHaeseler::computeFunction(value); if (!rate_mh) { if (value != cur_scale) { ptn_tree->scaleLength(value/cur_scale); cur_scale = value; ptn_tree->clearAllPartialLH(); } return -ptn_tree->computeLikelihood(); } double lh = 0.0; int nseq = phylo_tree->leafNum; int nstate = phylo_tree->getModel()->num_states; int i, j, k, state1, state2; ModelSubst *model = phylo_tree->getModel(); int trans_size = nstate * nstate; double *trans_mat = new double[trans_size]; int *pair_freq = new int[trans_size]; for (i = 0; i < nseq-1; i++) for (j = i+1; j < nseq; j++) { memset(pair_freq, 0, trans_size * sizeof(int)); for (k = 0; k < size(); k++) { if (ptn_cat[k] != optimizing_cat) continue; Pattern *pat = & phylo_tree->aln->at(k); if ((state1 = pat->at(i)) < nstate && (state2 = pat->at(j)) < nstate) pair_freq[state1*nstate + state2] += pat->frequency; } model->computeTransMatrix(value * dist_mat[i*nseq + j], trans_mat); for (k = 0; k < trans_size; k++) if (pair_freq[k]) lh -= pair_freq[k] * log(trans_mat[k]); } delete [] pair_freq; delete [] trans_mat; return lh; }
void ActiveConnect(ArgListType &arg) //AT_FUN { // process the function arguments static string FunctionName = "ActiveConnect"; static IntArg StartNeuron("-Nstart", "start neuron", 1); static IntArg EndNeuron("-Nend", "end neuron{-1 gives last neuron}", -1); static IntArg StartPat("-Pstart", "start pattern(or vector)", 1); static IntArg EndPat("-Pend", "end pattern(or vector) {-1 gives end time}", -1); static StrArg SeqName("-name", "sequence name"); static StrArg ResetSeq("-reset", "reset sequence", "{zeros}"); static StrArg External("-ext", "external sequence", "{zeros}"); static FlagArg DoSummary("-sum", "-nosum", "print a summary", 1); static int argunset = true; static CommandLine ComL(FunctionName); if (argunset) { ComL.HelpSet("@ActiveConnect() \n" "\tGenerates the data about conditional probabilities of firing\n" "\tand saves the results into the ActiveConBuffer.\n" "\tThe reset sequence is used for the 0 time step and\n" "\tif externals are given then they are ignored.\n" "\tActiveConBuffer is a matrix with 6 Vectors:\n" "\t\t1: TimeStep(Pattern Number)\n" "\t\t2: Absolute Activity Last Time\n" "\t\t3: Absolute Activity This Time - Externals\n" "\t\t4: # of Conns between CoActive Neurons\n" "\t\t5: 4/3 = Ave # of Active Conns for Active Neurons\n" "\t\t6: 4/(2*3) = Prob cij=1 given zi=1,zj=1\n" "\tActiveConnect also updates the variable Pczz which\n" "\tholds the Prob(cij=1 | zi=1,zj=1) for the whole sequence\n"); ComL.IntSet(4, &StartNeuron, &EndNeuron, &StartPat, &EndPat); ComL.StrSet(3, &SeqName, &ResetSeq, &External); ComL.FlagSet(1, &DoSummary); argunset = false; } ComL.Process(arg, Output::Err()); if (!program::Main().getNetworkCreated()) { CALL_ERROR << "Error: You must call @CreateNetwork() before you can " "call @ActiveConnect." << ERR_WHERE; exit(EXIT_FAILURE); } UIPtnSequence Seq = SystemVar::getSequence(SeqName, FunctionName, ComL); int SeqSize = Seq.size(); UIPtnSequence ReSeq; if (ResetSeq.getValue() != "{zeros}") { ReSeq = SystemVar::getSequence(ResetSeq, FunctionName, ComL); } else { ReSeq.resize(SeqSize, UIVector(0)); } int lastNeuron = 0; for (UIPtnSequenceCIt it = Seq.begin(); it != Seq.end(); it++) { updateMax(lastNeuron, it->back()); } if (EndNeuron.getValue() == -1) { EndNeuron.setValue(lastNeuron); } if (EndPat.getValue() == -1) { EndPat.setValue(SeqSize); } if (StartNeuron.getValue() < 1 || StartNeuron.getValue() > EndNeuron.getValue() || EndNeuron.getValue() > static_cast<int>(ni)) { CALL_ERROR << "Error in " << FunctionName << ": Neuron range of " << StartNeuron.getValue() << "..." << EndNeuron.getValue() << " is invalid." << ERR_WHERE; ComL.DisplayHelp(Output::Err()); } if (EndPat.getValue() < 1 || EndPat.getValue() > SeqSize || StartPat.getValue() < 1 || StartPat.getValue() > EndPat.getValue()) { CALL_ERROR << "Error in " << FunctionName << ": Pattern range of " << StartPat.getValue() << "..." << EndPat.getValue() << " is invalid." << ERR_WHERE; ComL.DisplayHelp(Output::Err()); } // get externals UIMatrix ExtSeq; if (External.getValue() != "{zeros}") { ExtSeq = SystemVar::getSequence(External, FunctionName, ComL); } else { ExtSeq.resize(SeqSize, UIVector(0)); } // Do the loops int NumPats = EndPat.getValue() - StartPat.getValue() + 1; DataList Ave(NumPats); DataList Sum(NumPats); DataList Pats(NumPats); DataList jNumFired(NumPats); DataList iNumFired(NumPats); DataList PczzV(NumPats); int index = 0; UIPtnSequenceCIt SeqConstIterator = Seq.begin(); UIPtnSequenceCIt ExtConstIterator = ExtSeq.begin(); UIVector pat_b4; if (StartPat.getValue() == 1) { pat_b4 = ReSeq.front(); } else { for (int inc = 0; inc < StartPat.getValue() - 2; ++inc) ++SeqConstIterator; pat_b4 = *(SeqConstIterator++); } for (int t = StartPat.getValue(); t <= EndPat.getValue(); ++t, ++index, ++SeqConstIterator, ++ExtConstIterator) { Pats.at(index) = static_cast<float>(t); Pattern pat = UIVectorToPtn(*SeqConstIterator, lastNeuron); Pattern pat_ext = UIVectorToPtn(*ExtConstIterator, lastNeuron); for (int j = StartNeuron.getValue(); j <= EndNeuron.getValue(); j++) { // count the number on if (pat_b4.at(j-1)) ++iNumFired.at(index); // do the calculation for non-externals and active if (pat.at(j-1) && (!(pat_ext.at(j-1)))) { ++jNumFired.at(index); for (unsigned int c = 0; c < FanInCon.at(j-1); c++) { if (pat_b4.at(inMatrix[j-1][c].getSrcNeuron())) ++Sum.at(index); } } } pat_b4 = pat; } // Output the data Output::Out() << "\nSummed Active Connections in sequence " << SeqName.getValue() << " using neurons " << StartNeuron.getValue() << "..." << EndNeuron.getValue() << " and patterns " << StartPat.getValue() << "..." << EndPat.getValue() << "\n\tignoring externals given by " << External.getValue(); if (DoSummary.getValue()) { Output::Out() << "\n" << std::setw(11) << "1:TimeStep" << std::setw(9) << "2:#z(t-1)" << std::setw(9) << "3:#z(t)" << std::setw(15) << "4:#cz(t-1)z(t)" << std::setw(9) << "4/3" << std::setw(9) << "4/(2*3)" << "\n"; } float TotalSumC = 0.0f; float TotalSumZ = 0.0f; for (int i = 0; i < index; i++) { if (fabs(Sum.at(i)) < verySmallFloat) { Ave.at(i) = 0.0f; PczzV.at(i) = 0.0f; } else { Ave.at(i) = Sum.at(i) / jNumFired.at(i); PczzV.at(i) = Ave.at(i) / iNumFired.at(i); } TotalSumC += Sum.at(i); TotalSumZ += iNumFired.at(i) * jNumFired.at(i); if (DoSummary.getValue()) { Output::Out() << "\n" << std::setw(11) << static_cast<int>(Pats.at(i)) << std::setw(9) << static_cast<int>(iNumFired.at(i)) << std::setw(9) << static_cast<int>(jNumFired.at(i)) << std::setw(15) << static_cast<int>(Sum.at(i)) << std::setw(9) << Ave.at(i) << std::setw(9) << PczzV.at(i); } } Output::Out() << "\n"; float Pczz; if (fabs(TotalSumC) < verySmallFloat) { Pczz = 0.0f; } else { Pczz = TotalSumC / TotalSumZ; } SystemVar::SetFloatVar("Pczz", Pczz); if (DoSummary.getValue()) { Output::Out() << "Average: " << Pczz << "\n"; } // Save the vector to the ActiveConBuffer DataMatrix ActiveConMat; ActiveConMat.push_back(Pats); ActiveConMat.push_back(iNumFired); ActiveConMat.push_back(jNumFired); ActiveConMat.push_back(Sum); ActiveConMat.push_back(Ave); ActiveConMat.push_back(PczzV); SystemVar::insertData("ActiveConBuffer", ActiveConMat, DLT_matrix); return; }
void RateMeyerDiscrete::computeFuncDerv(double value, double &df, double &ddf) { if (!is_categorized) { RateMeyerHaeseler::computeFuncDerv(value, df, ddf); return; } // double lh = 0.0; int nseq = phylo_tree->leafNum; int nstate = phylo_tree->getModel()->num_states; int i, j, k, state1, state2; ModelSubst *model = phylo_tree->getModel(); int trans_size = nstate * nstate; double *trans_mat = new double[trans_size]; double *trans_derv1 = new double[trans_size]; double *trans_derv2 = new double[trans_size]; df = ddf = 0.0; int *pair_freq = new int[trans_size]; for (i = 0; i < nseq-1; i++) for (j = i+1; j < nseq; j++) { memset(pair_freq, 0, trans_size * sizeof(int)); for (k = 0; k < size(); k++) { if (ptn_cat[k] != optimizing_cat) continue; Pattern *pat = & phylo_tree->aln->at(k); if ((state1 = pat->at(i)) < nstate && (state2 = pat->at(j)) < nstate) pair_freq[state1*nstate + state2] += pat->frequency; } double dist = dist_mat[i*nseq + j]; double derv1 = 0.0, derv2 = 0.0; model->computeTransDerv(value * dist, trans_mat, trans_derv1, trans_derv2); for (k = 0; k < trans_size; k++) if (pair_freq[k]) { double t1 = trans_derv1[k] / trans_mat[k]; double t2 = trans_derv2[k] / trans_mat[k]; trans_derv1[k] = t1; trans_derv2[k] = (t2 - t1*t1); // lh -= log(trans_mat[k]) * pair_freq[k]; derv1 += trans_derv1[k] * pair_freq[k]; derv2 += trans_derv2[k] * pair_freq[k]; } df -= derv1 * dist; ddf -= derv2 * dist * dist; } delete [] pair_freq; delete [] trans_derv2; delete [] trans_derv1; delete [] trans_mat; // return lh; /* double lh = 0.0, derv1, derv2; df = 0.0; ddf = 0.0; for (int i = 0; i < size(); i++) if (ptn_cat[i] == optimizing_cat) { optimizing_pattern = i; int freq = phylo_tree->aln->at(i).frequency; lh += RateMeyerHaeseler::computeFuncDerv(value, derv1, derv2) * freq; df += derv1 * freq; ddf += derv2 * freq; } return lh;*/ }
void Preprocessor::correctSlanting () { boost::timer timer; timer.restart(); const double PI = 3.1415926535; for ( std::vector<Pattern>::iterator i = patterns_.begin(); i != patterns_.end(); ++i ) { const unsigned int rotationLimit = 20; double shearingFactor;; // This vector stores the greatest number of ink pixels counted in any column of a rotated pattern. std::vector<unsigned int> columnPixelMaximalCounts(rotationLimit); // Rotate the pattern and count the number of ink pixels per column for ( double angle = 0; angle < rotationLimit; ++angle ) { std::map<unsigned int, std::set<unsigned int> > pixelsPerColumn; shearingFactor = tan(-angle * PI / 180.0); // Store the columns of rotated pixels for ( unsigned int j = 0; j < i->height(); ++j ) { for ( unsigned int k = 0; k < i->width(); ++k ) { if ( i->at(j,k) == 1 ) // Ink pixel { double jp = j; double kp = k; kp = round(kp - jp * shearingFactor); if ( kp < i->width() && kp > 0 ) pixelsPerColumn[kp].insert(j); } } } unsigned int columnPixelMaximalCount = 0; for ( std::map<unsigned int, std::set<unsigned int> >::iterator row = pixelsPerColumn.begin(); row != pixelsPerColumn.end(); ++row ) { if ( row->second.size() > columnPixelMaximalCount ) columnPixelMaximalCount = row->second.size(); } columnPixelMaximalCounts.at(angle) = columnPixelMaximalCount; } // Get the angle to rotate selecting the rotation that generates the maximal number of pixels in a column double targetAngle = distance( columnPixelMaximalCounts.begin(), std::max_element(columnPixelMaximalCounts.begin(), columnPixelMaximalCounts.end()) ); shearingFactor = tan(-targetAngle * PI / 180.0); // Correct slanting of the actual pattern if ( targetAngle != 0 ) { Pattern rotatedPattern; rotatedPattern.clean(); for ( unsigned int j = 0; j < i->height(); ++j ) { for ( unsigned int k = 0; k < i->width(); ++k ) { if ( i->at(j,k) == 1 ) { double jp = j; double kp = k; kp = round(kp - jp * shearingFactor); if ( kp < i->width() && kp > 0 ) rotatedPattern.at(jp, kp) = 1; } } } *i = rotatedPattern; } } statistics_.slantingCorrectionTime(timer.elapsed());; }
void Preprocessor::buildPatterns () { boost::timer timer; timer.restart(); patterns_.clear(); patterns_.reserve(regions_.size()); Pattern pattern; // Traverse the list of iterators to regions creating a Pattern object for each region for( RegionLines::iterator k = inlineRegions_.begin(); k != inlineRegions_.end(); ++k ) { std::list<RegionIterator> line(k->second); for( std::list<RegionIterator>::iterator i = line.begin(); i != line.end(); ++i ) { (*i)->normalizeCoordinates(); // Normalize region using Magick++ facilities Magick::Image image( Magick::Geometry((*i)->width(), (*i)->height()), Magick::ColorGray(1.0) ); image.type( Magick::BilevelType ); Magick::Pixels view(image); Magick::PixelPacket *originPixel = view.get(0, 0, (*i)->width(), (*i)->height()); Magick::PixelPacket *pixel; for ( unsigned int j = 0; j < (*i)->size(); ++j ) { pixel = originPixel + ((*i)->at(j).first * view.columns() + (*i)->at(j).second); *pixel = Magick::ColorGray (0.0); } view.sync(); image.syncPixels(); image.scale( Magick::Geometry(Pattern::planeSize(), Pattern::planeSize()) ); // Preprocess the normalized region Preprocessor temporalPreprocessor (image, 0, 0, image.rows(), image.columns()); temporalPreprocessor.applyGlobalThresholding(); temporalPreprocessor.isolateRegions(); Region normalizedRegion; if ( ! temporalPreprocessor.regions_.empty() ) { // Merge subregions if preprocessing split the original region if ( temporalPreprocessor.regions_.size() > 1 ) { for ( RegionIterator j = temporalPreprocessor.regions_.begin(); j != temporalPreprocessor.regions_.end(); ++j ) normalizedRegion = normalizedRegion + *j; temporalPreprocessor.regions_.clear(); temporalPreprocessor.regions_.push_back(normalizedRegion); } else normalizedRegion = temporalPreprocessor.regions_.front(); } // Build the pattern pattern.clean(); for ( unsigned int i = 0; i < normalizedRegion.size(); ++i ) pattern.at(normalizedRegion.at(i).first, normalizedRegion.at(i).second) = 1; // Correct shifting if ( image.rows() < Pattern::planeSize() ) // Shift rows from top to the center { unsigned int offset = (Pattern::planeSize() - image.rows()) / 2; while ( offset != 0 ) { for ( int i = Pattern::planeSize()-2; i >= 0; --i ) { for ( unsigned int j = 0; j < Pattern::planeSize(); ++j ) pattern.at(i+1, j) = pattern.at(i, j); } for ( unsigned int j = 0; j < Pattern::planeSize(); ++j ) pattern.at(0, j) = 0; --offset; } } if ( image.columns() < Pattern::planeSize() ) // Shift columns from left to center { unsigned int offset = (Pattern::planeSize() - image.columns()) / 2; while ( offset != 0 ) { for ( unsigned int i = 0; i < Pattern::planeSize(); ++i ) { for ( int j = Pattern::planeSize()-2; j >= 0; --j ) pattern.at(i, j+1) = pattern.at(i, j); } for ( unsigned int i = 0; i < Pattern::planeSize(); ++i ) pattern.at(i, 0) = 0; --offset; } } patterns_.push_back( pattern ); } } statistics_.patternsBuildingTime(timer.elapsed()); }