From b1778dba90a315fde2984ae11f91825cc13b872c Mon Sep 17 00:00:00 2001 From: sehe Date: Thu, 17 Dec 2015 10:16:49 +0100 Subject: [PATCH 1/4] range_min_size needs to be ordered before use ADL doesn't apply to invocations --- src/Helpers.hpp | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/src/Helpers.hpp b/src/Helpers.hpp index af6bb96..0f4d89f 100644 --- a/src/Helpers.hpp +++ b/src/Helpers.hpp @@ -248,6 +248,22 @@ template static size_t count_adjacent(const R& r) } return count; } +template static size_t range_min_size (const R1& a, const R2& b) +{ + return min(boost::size(a), boost::size(b)); +} +template static size_t range_min_size (const R1& a, const R2& b, const R3& c) +{ + return min(min(boost::size(a), boost::size(b)), boost::size(c)); +} +template static size_t range_min_size (const R1& a, const R2& b, const R3& c, const R4& d) +{ + return min(min(min(boost::size(a), boost::size(b)), boost::size(c)), boost::size(d)); +} +template static size_t range_min_size (const R1& a, const R2& b, const R3& c, const R4& d, const R5& e) +{ + return min(min(min(min(boost::size(a), boost::size(b)), boost::size(c)), boost::size(d)), boost::size(e)); +} template static pair::type, typename range_iterator::type> >, zip_iterator::type, typename range_iterator::type> > > zip(R1& r1, R2& r2) @@ -436,22 +452,6 @@ template void delete_range(R& r) delete *it; } } -template static size_t range_min_size (const R1& a, const R2& b) -{ - return min(boost::size(a), boost::size(b)); -} -template static size_t range_min_size (const R1& a, const R2& b, const R3& c) -{ - return min(min(boost::size(a), boost::size(b)), boost::size(c)); -} -template static size_t range_min_size (const R1& a, const R2& b, const R3& c, const R4& d) -{ - return min(min(min(boost::size(a), boost::size(b)), boost::size(c)), boost::size(d)); -} -template static size_t range_min_size (const R1& a, const R2& b, const R3& c, const R4& d, const R5& e) -{ - return min(min(min(min(boost::size(a), boost::size(b)), boost::size(c)), boost::size(d)), boost::size(e)); -} template static int max_index(const R& r) { return distance(boost::begin(r), max_element(boost::begin(r), boost::end(r))); From 706cd3d04084635f5b3d8ff2818ab219f4f4fcd6 Mon Sep 17 00:00:00 2001 From: sehe Date: Thu, 17 Dec 2015 10:18:37 +0100 Subject: [PATCH 2/4] indices used wrong integral type Also ordered before use --- src/Helpers.hpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Helpers.hpp b/src/Helpers.hpp index 0f4d89f..88d791e 100644 --- a/src/Helpers.hpp +++ b/src/Helpers.hpp @@ -296,10 +296,6 @@ zip(R1& r1, R2& r2, R3& r3, R4& r4, R5& r5) return make_pair(make_zip_iterator(make_tuple(boost::begin(r1), boost::begin(r2), boost::begin(r3), boost::begin(r4), boost::begin(r5))), make_zip_iterator(make_tuple(boost::end(r1) - (boost::size(r1) - size), boost::end(r2) - (boost::size(r2) - size), boost::end(r3) - (boost::size(r3) - size), boost::end(r4) - (boost::size(r4) - size), boost::end(r5) - (boost::size(r5) - size)))); } -template static pair::type>, counting_iterator::type> > indices(const R& r) -{ - return range(boost::size(r)); -} template static pair::type, counting_iterator::type> > >, zip_iterator::type, counting_iterator::type> > > > enumerate(R& r) @@ -315,6 +311,10 @@ template static pair, counting_iterator > rang { return make_pair(counting_iterator(t1), counting_iterator(t2)); } +template static pair::type>, counting_iterator::type> > indices(const R& r) +{ + return ::range(boost::size(r)); +} template static typename range_iterator::type transform(const R1& r1, R2& r2, F f) { return transform(boost::begin(r1), boost::end(r1), boost::begin(r2), f); From 02ed807dc16653035099b33683894a8738621cbb Mon Sep 17 00:00:00 2001 From: sehe Date: Thu, 17 Dec 2015 10:22:44 +0100 Subject: [PATCH 3/4] qualify ambiguous `range` uses as `::range` The true issue is blanket `using` directives. It doesn't get much more inviting to ambiguities than what is found in src/Helpers.hpp: using namespace std; using namespace boost; using namespace boost::assign; using namespace boost::posix_time; using namespace boost::gregorian; This is just the cheap compilation fix --- src/AutoregressionLayer.hpp | 4 ++-- src/ClassificationLayer.hpp | 4 ++-- src/DecodingLayer.hpp | 2 +- src/LstmLayer.hpp | 36 ++++++++++++++++++------------------ src/NetcdfDataset.hpp | 10 +++++----- src/RegressionLayer.hpp | 2 +- src/SeqBuffer.hpp | 4 ++-- src/TranscriptionLayer.hpp | 12 ++++++------ 8 files changed, 37 insertions(+), 37 deletions(-) diff --git a/src/AutoregressionLayer.hpp b/src/AutoregressionLayer.hpp index f4c4ea9..01986d5 100644 --- a/src/AutoregressionLayer.hpp +++ b/src/AutoregressionLayer.hpp @@ -43,14 +43,14 @@ struct AutoregressionLayer: public LinearOutputLayer targets = this->source->outputActivations; fill (seqMeanTargs, 0); int seqSize = targets.seq_size(); - loop(int i, range(seqSize)) + loop(int i, ::range(seqSize)) { range_plus_equals(seqMeanTargs, targets[i]); } range_divide_val(seqMeanTargs, seqSize); double seqRmsNormFactor = 0; double rmsError = 0; - loop(int i, range(seqSize)) + loop(int i, ::range(seqSize)) { seqRmsNormFactor += euclidean_squared(seqMeanTargs, targets[i]); loop(TDDD t, zip(this->outputErrors[i], this->outputActivations[i], targets[i])) diff --git a/src/ClassificationLayer.hpp b/src/ClassificationLayer.hpp index 8eb6323..379874e 100644 --- a/src/ClassificationLayer.hpp +++ b/src/ClassificationLayer.hpp @@ -63,7 +63,7 @@ struct ClassificationLayer: public SoftmaxLayer } targets.reshape(this->outputActivations, 0); double crossEntropyError = 0; - loop(int i, range(this->outputActivations.seq_size())) + loop(int i, ::range(this->outputActivations.seq_size())) { int targetClass = seq.targetClasses[i].front(); if (targetClass >= 0) @@ -122,7 +122,7 @@ struct ClassificationLayer: public SoftmaxLayer if (this->num_seq_dims() == 0) { View logActs = this->logActivations[0]; - loop (int i, range(this->output_size())) + loop (int i, ::range(this->output_size())) { labelProbs[i] = make_pair(logActs[i].log, i); } diff --git a/src/DecodingLayer.hpp b/src/DecodingLayer.hpp index 2a51073..48c4f01 100644 --- a/src/DecodingLayer.hpp +++ b/src/DecodingLayer.hpp @@ -272,7 +272,7 @@ struct DecodingLayer: public TranscriptionLayer } //pass the tokens - loop(int t, range(1, totalTime)) + loop(int t, ::range(1, totalTime)) { //reduce newTokens list to nBest, unless using language model if (oneGrams.empty()) diff --git a/src/LstmLayer.hpp b/src/LstmLayer.hpp index bc1e51a..8619862 100644 --- a/src/LstmLayer.hpp +++ b/src/LstmLayer.hpp @@ -76,7 +76,7 @@ template struct LstmLayer: public Layer #endif { //initialise the state delays - loop(int i, range(this->num_seq_dims())) + loop(int i, ::range(this->num_seq_dims())) { stateDelays[i].resize(this->num_seq_dims(), 0); stateDelays[i][i] = -directions[i]; @@ -116,7 +116,7 @@ template struct LstmLayer: public Layer double* stateBegin = states[coords].begin(); double* preGateStateBegin = preGateStates[coords].begin(); double* preOutGateActBegin = preOutGateActs[coords].begin(); - loop(int d, range(this->num_seq_dims())) + loop(int d, ::range(this->num_seq_dims())) { oldStates[d] = states.at(range_plus(delayedCoords, coords, stateDelays[d])); } @@ -126,7 +126,7 @@ template struct LstmLayer: public Layer int cellStart = 0; int cellEnd = cellsPerBlock; double* fgActEnd = fgActBegin + this->num_seq_dims(); - loop(int b, range(numBlocks)) + loop(int b, ::range(numBlocks)) { #ifdef PEEPS View fgActs(fgActBegin, fgActEnd); @@ -147,7 +147,7 @@ template struct LstmLayer: public Layer //forget gates //extra inputs from peepholes (from old states) - loop(int d, range(this->num_seq_dims())) + loop(int d, ::range(this->num_seq_dims())) { #ifdef PEEPS const View& os = oldStates[d]; @@ -166,10 +166,10 @@ template struct LstmLayer: public Layer inActIt += cellsPerBlock; //cell states - loop(int c, range(cellStart, cellEnd)) + loop(int c, ::range(cellStart, cellEnd)) { double state = inGateAct * preGateStateBegin[c]; - loop(int d, range(this->num_seq_dims())) + loop(int d, ::range(this->num_seq_dims())) { const View& os = oldStates[d]; if (os.begin()) @@ -218,7 +218,7 @@ template struct LstmLayer: public Layer #ifdef PEEPS const double* peepWtIt = WeightContainer::instance().get_weights(peepRange).begin(); #endif - loop(int d, range(this->num_seq_dims())) + loop(int d, ::range(this->num_seq_dims())) { oldStates[d] = states.at(range_plus(delayedCoords, coords, stateDelays[d])); range_minus(delayedCoords, coords, stateDelays[d]); @@ -230,7 +230,7 @@ template struct LstmLayer: public Layer int cellEnd = cellsPerBlock; int fgStart = 0; int gateStart = 0; - loop(int b, range(numBlocks)) + loop(int b, ::range(numBlocks)) { double inGateAct = inGateActBegin[b]; double outGateAct = outGateActBegin[b]; @@ -240,7 +240,7 @@ template struct LstmLayer: public Layer inner_product(preOutGateActBegin + cellStart, preOutGateActBegin + cellEnd, outputErrorBegin + cellStart, 0.0); //cell pds (dE/dState) - loop(int c, range(cellStart, cellEnd)) + loop(int c, ::range(cellStart, cellEnd)) { double deriv = (CO::deriv(preOutGateActBegin[c]) * outGateAct * outputErrorBegin[c]); #ifdef PEEPS @@ -249,7 +249,7 @@ template struct LstmLayer: public Layer double ogPeepWt = peepWtIt[peepsPerBlock - cellsPerBlock + cOffset]; deriv += outGateError * ogPeepWt; #endif - loop(int d, range(this->num_seq_dims())) + loop(int d, ::range(this->num_seq_dims())) { #ifdef PEEPS double fgPeepWt = peepWtIt[cOffset + (cellsPerBlock * (d + 1))]; @@ -272,7 +272,7 @@ template struct LstmLayer: public Layer ++errorIt; //forget gate error - loop(int d, range(this->num_seq_dims())) + loop(int d, ::range(this->num_seq_dims())) { const View& os = oldStates[d]; if (os.begin()) @@ -288,7 +288,7 @@ template struct LstmLayer: public Layer } //cell errors - loop(int c, range(cellStart, cellEnd)) + loop(int c, ::range(cellStart, cellEnd)) { *errorIt = inGateAct * CI::deriv(preGateStateBegin[c]) * cellErrorBegin[c]; ++errorIt; @@ -316,34 +316,34 @@ template struct LstmLayer: public Layer const double* stateBegin = states[coords].begin(); const double* errorBegin = this->inputErrors[coords].begin(); double* pdIt = WeightContainer::instance().get_derivs(peepRange).begin(); - loop(int d, range(this->num_seq_dims())) + loop(int d, ::range(this->num_seq_dims())) { oldStates[d] = states.at(range_plus(delayedCoords, coords, stateDelays[d])); } - loop(int b, range(numBlocks)) + loop(int b, ::range(numBlocks)) { int cellStart = b * cellsPerBlock; int cellEnd = cellStart + cellsPerBlock; int errorOffset = b * unitsPerBlock; double inGateError = errorBegin[errorOffset]; - loop(int d, range(this->num_seq_dims())) + loop(int d, ::range(this->num_seq_dims())) { const View& os = oldStates[d]; if (os.begin()) { - loop(int c, range(cellStart, cellEnd)) + loop(int c, ::range(cellStart, cellEnd)) { pdIt[c - cellStart] += inGateError * os[c]; } double forgGateError = errorBegin[errorOffset + d + 1]; - loop(int c, range(cellStart, cellEnd)) + loop(int c, ::range(cellStart, cellEnd)) { pdIt[(c - cellStart) + ((d + 1) * cellsPerBlock)] += forgGateError * os[c]; } } } double outGateError = errorBegin[errorOffset + unitsPerBlock - 1]; - loop(int c, range(cellStart, cellEnd)) + loop(int c, ::range(cellStart, cellEnd)) { pdIt[(c - cellStart) + peepsPerBlock - cellsPerBlock] += outGateError * stateBegin[c]; } diff --git a/src/NetcdfDataset.hpp b/src/NetcdfDataset.hpp index e9e01a9..8222559 100644 --- a/src/NetcdfDataset.hpp +++ b/src/NetcdfDataset.hpp @@ -143,7 +143,7 @@ struct DataHeader } inputSize = load_nc_dim(nc, "inputPattSize"); numSequences = load_nc_dim(nc, "numSeqs") * bound(dataFraction, 0.0, 1.0); - loop(int s, range(numSequences)) + loop(int s, ::range(numSequences)) { vector seqDims = get_nc_array_step(nc, "seqDims", s, numDims != 1); if (seqDims.empty()) @@ -189,11 +189,11 @@ struct DataHeader } else if (task == "sequence_classification" || task == "transcription" || task == "dictionary_transcription") { - loop(int i, range(outputSize)) + loop(int i, ::range(outputSize)) { targetLabelCounts[targetLabels.left.at(i)] = 0; } - loop(int s, range(numSequences)) + loop(int s, ::range(numSequences)) { stringstream labelSeq (get_nc_string(nc, "targetStrings", s)); string label; @@ -319,7 +319,7 @@ struct NetcdfDataset pair get_offset(int seqNum) const { pair offset(0, 0); - loop(int i, range(seqNum)) + loop(int i, ::range(seqNum)) { offset += seq_to_offset(i); } @@ -328,7 +328,7 @@ struct NetcdfDataset void load_sequences (int first, int last) { pair offsets = get_offset(first); - loop(int i, range(first, last)) + loop(int i, ::range(first, last)) { check(i >= 0 && i < inputSeqDims.shape[0], "sequence " + str(i) + " requested from data file " + str(filename) + " containing " + str(inputSeqDims.shape[0]) + " sequences"); DataSequence* seq = new DataSequence(header.inputSize, in(task, "regression") ? header.outputSize : 0); diff --git a/src/RegressionLayer.hpp b/src/RegressionLayer.hpp index 73adc6b..94a8eaf 100644 --- a/src/RegressionLayer.hpp +++ b/src/RegressionLayer.hpp @@ -43,7 +43,7 @@ struct RegressionLayer: public LinearOutputLayer + ", target shape = " + str(seq.targetPatterns.shape)); targets = seq.targetPatterns; double sumSquaresError = 0; - loop(int i, range(this->outputActivations.seq_size())) + loop(int i, ::range(this->outputActivations.seq_size())) { // double errScale = (seq.importance.empty() ? 1 : *(seq.importance[i].first)); loop(TDDCF t, zip(this->outputErrors[i], this->outputActivations[i], seq.targetPatterns[i])) diff --git a/src/SeqBuffer.hpp b/src/SeqBuffer.hpp index a82cb9a..42ee121 100644 --- a/src/SeqBuffer.hpp +++ b/src/SeqBuffer.hpp @@ -222,9 +222,9 @@ template struct SeqBuffer: public MultiArray void print(ostream& out) const { out << "DIMENSIONS: " << seq_shape() << endl; - loop(int j, range(this->shape.back())) + loop(int j, ::range(this->shape.back())) { - loop(int i, range(seq_size())) + loop(int i, ::range(seq_size())) { out << (*this)[i][j] << " "; } diff --git a/src/TranscriptionLayer.hpp b/src/TranscriptionLayer.hpp index e3b1050..0f746d5 100644 --- a/src/TranscriptionLayer.hpp +++ b/src/TranscriptionLayer.hpp @@ -60,7 +60,7 @@ struct TranscriptionLayer: public SoftmaxLayer { totalSegs = totalSegments; } - return range(max(0, totalSegs - (2 *(totalTime-time))), min(totalSegs, 2 * (time + 1))); + return ::range(max(0, totalSegs - (2 *(totalTime-time))), min(totalSegs, 2 * (time + 1))); } vector& path_to_string(const vector& path) const { @@ -81,7 +81,7 @@ struct TranscriptionLayer: public SoftmaxLayer { static vector path; path.clear(); - loop(int i, range(this->outputActivations.seq_size())) + loop(int i, ::range(this->outputActivations.seq_size())) { path += max_index(this->outputActivations[i]); } @@ -114,7 +114,7 @@ struct TranscriptionLayer: public SoftmaxLayer { forwardVariables.data[1] = this->logActivations.data[seq.labelSeq[0]]; } - loop(int t, range(1, totalTime)) + loop(int t, ::range(1, totalTime)) { View logActs = this->logActivations[t]; View oldFvars = forwardVariables[t-1]; @@ -165,7 +165,7 @@ struct TranscriptionLayer: public SoftmaxLayer nth_last(lastBvs, 2) = 1; } //loop over time, calculating backward variables recursively - loop_back(int t, range(totalTime - 1)) + loop_back(int t, ::range(totalTime - 1)) { View oldLogActs = this->logActivations[t+1]; View oldBvars = backwardVariables[t+1]; @@ -200,12 +200,12 @@ struct TranscriptionLayer: public SoftmaxLayer } } //inject the training errors - loop(int time, range(totalTime)) + loop(int time, ::range(totalTime)) { fill(dEdYTerms, LogDouble(0)); View fvars = forwardVariables[time]; View bvars = backwardVariables[time]; - loop (int s, range(totalSegments)) + loop (int s, ::range(totalSegments)) { //k = blank for even s, target label for odd s int k = (s&1) ? seq.labelSeq[s/2] : blank; From c945414d50447e46471fe2d174cdd8d848bc49da Mon Sep 17 00:00:00 2001 From: sehe Date: Thu, 17 Dec 2015 10:24:31 +0100 Subject: [PATCH 4/4] qualify ambiguous `equal` uses as `::equal` see comment at 02ed807dc --- src/ClassificationLayer.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ClassificationLayer.hpp b/src/ClassificationLayer.hpp index 379874e..439f40b 100644 --- a/src/ClassificationLayer.hpp +++ b/src/ClassificationLayer.hpp @@ -56,7 +56,7 @@ struct ClassificationLayer: public SoftmaxLayer } double calculate_errors(const DataSequence& seq) { - assert(equal(seq.targetClasses.seq_shape(), this->outputActivations.seq_shape())); + assert(::equal(seq.targetClasses.seq_shape(), this->outputActivations.seq_shape())); loop(vector& v, confusionMatrix) { fill(v, 0);