//////////////////////////////////////////////////////////////////////////////// // 'processFeatureVector' reads a feature vector and modifies the classifier's // data members accordingly //////////////////////////////////////////////////////////////////////////////// void MaxEnt::processFeatureVector(const FeatureVector& features){ // Class=2; // what does this do? Need to be there? en.f.resize(C); en.fs.resize(C); en.Ny.resize(C); size_t c=0; // class en.Ny[c]=0.0; // strength of class (first num after @) // for each feature for (FeatureVector::const_iterator feat = features.begin(); feat!=features.end();feat++) { // these loops may have to be reversed !! // the classes may need to be looped over first, and features within // instead of classes within feature loop StringXML feature; double value = feat->getValue(); // for each class for (unsigned int i=0;i<C;i++){ stringstream ss; ss << "cat" << i << "_" << feat->getFeature(); feature = ss.str(); if (value!=0) { // set values if (f2s.count(feature)!=0) { // check whether feature exists (s2f)[f2s[feature]].second+=(en.Ny[i]!=0); en.f[i].push_back(make_pair(f2s[feature], value)); en.fs[i]+=value; F=max(F, en.fs[i]); } } } } }
ErrorStruct StrongClassifier::errorForFeatures(const TrainingData &features, bool printStats) const { ErrorStruct e; for (int i=0; i<features.size(); i++) { FeatureVector feature = *(features.feature(i)); if (decide(feature)) { feature.val() == POS ? e.true_pos++ : e.false_pos++;//it is really positive } else { feature.val() == NEG ? e.true_neg++ : e.false_neg++;//it is really negative } } // if all 10 samples, 3 is misclassified, error is 3/10 e.error = (e.false_pos + e.false_neg) / ((float)features.size()); if (printStats) { std::cout << e.true_pos << " true positives" << std::endl; std::cout << e.false_pos << " false positives" << std::endl; std::cout << e.true_neg << " true negatives" << std::endl; std::cout << e.false_neg << " false negatives" << std::endl; std::cout << e.error * 100 << "% error" << std::endl; std::cout << std::endl; } return e; }
bool StrongClassifier::decide(const FeatureVector &featureVector) const { std::vector<float> features(featureVector.size()); for (int i=0; i<featureVector.size(); i++) { features[i] = featureVector.at(i); } return decide(features); }
realv Layer::signalWeighting(FeatureVector _signal, Mat _weights) { if (_signal.getLength() != ((uint) _weights.cols)) { throw length_error("Layer : Uncorrect length between signal and weights"); } realv sum = 0; for (uint i = 0; i < _signal.getLength(); i++) { sum += _signal[i] * _weights.at<realv>(0, i); } return sum; }
double Slic::_ComputeDistance(const FeatureVector &vec1, const FeatureVector &vec2) { assert(vec1.size() == vec2.size()); double dis = 0; for (unsigned int i=0;i<vec1.size();++i) { dis += (vec1[i]-vec2[i])*(vec1[i]-vec2[i]); } return dis; }
realv SEMeasurer::totalError(FeatureVector _output, FeatureVector _target) { if (_output.getLength() != _target.getLength()) { throw length_error("SE : Output and target do not have the same size"); } realv result = 0; for (uint i = 0; i < _output.getLength(); i++) { result += (_output[i] - _target[i]) * (_output[i] - _target[i]); } err = result; return err; }
ErrorVector SEMeasurer::errorPerUnit(FeatureVector _output, FeatureVector _target) { if (_output.getLength() != _target.getLength()) { throw length_error("SEMeasurer : Output and target do not have the same size"); } ErrorVector result(_output.getLength()); for (uint i = 0; i < _output.getLength(); i++) { result[i] = (_output[i] - _target[i]) * (_output[i] - _target[i]); } errPerUnit = result; return result; }
/** * Determines the Random Approximation of GVC * (Determines the optimal Regularization Factor) */ double KerDenSOM::randApproxGVC(const TS* _examples, const FuzzyMap* _som, double _dataSD, double _reg) { unsigned j, vv, cc; double num, den, r; FeatureVector VV; VV.resize(dim, 0.0); FuzzyMap tmpSOM(*_som); TS tmpTS(*_examples); num = 0; for (vv = 0; vv < numVectors; vv++) { for (j = 0; j < dim; j++) VV[j] = 0.0; for (cc = 0; cc < numNeurons; cc++) { for (j = 0; j < dim; j++) VV[j] += (_examples->theItems[vv][j] - _som->theItems[cc][j]) * _som->memb[vv][cc]; } for (j = 0; j < dim; j++) num += VV[j] * VV[j]; } init_random_generator(); for (vv = 0; vv < numVectors; vv++) { for (j = 0; j < dim; j++) tmpTS.theItems[vv][j] += rnd_gaus() * _dataSD; } updateV(&tmpSOM, &tmpTS, _reg); den = 0.0; init_random_generator(); for (vv = 0; vv < numVectors; vv++) { for (j = 0; j < dim; j++) VV[j] = 0.0; for (cc = 0; cc < numNeurons; cc++) { for (j = 0; j < dim; j++) VV[j] += (tmpTS.theItems[vv][j] - tmpSOM.theItems[cc][j] - _examples->theItems[vv][j] + _som->theItems[cc][j]) * _som->memb[vv][cc]; } r = 0.; for (j = 0; j < dim; j++) r += VV[j] * rnd_gaus() * _dataSD; den += r * r; } if (den != 0) return (double) num / den; else return 0.; }
inline Tp dot_product(const FeatureVector<Tp1, Alloc1>& x, Iterator first, Iterator last, Tp __dot) { typedef FeatureVector<Tp1, Alloc1> feature_vector1_type; for (/**/; first != last; ++ first) { typename feature_vector1_type::const_iterator iter = x.find(first->first); if (iter != x.end()) __dot += iter->second * first->second; } return __dot; }
inline Tp dot_product(Iterator first, Iterator last, const FeatureVector<Tp2, Alloc2>& y, Tp __dot) { typedef FeatureVector<Tp2, Alloc2> feature_vector2_type; for (/**/; first != last; ++ first) { typename feature_vector2_type::const_iterator iter = y.find(first->first); if (iter != y.end()) __dot += first->second * iter->second; } return __dot; }
void SegmentList::normalizeFeatures() { if (isEmpty()) return; FeatureVector min = at(0)->features(); FeatureVector max = at(0)->features(); foreach (Segment const * const segment, *this) { min.setCompwiseMin(segment->features()); max.setCompwiseMax(segment->features()); } max = max - min; foreach (Segment * const segment, *this) { segment->features() = (segment->features() - min) / max; } }
/************************************** * Fucntion: is_classifier_correct * ------------------------------- * returns true if weak classifier (wc) correctly identified the * feature vector (fv), false otherwise. */ bool AdaBooster::is_classifier_correct(WeakClassifier &wc, FeatureVector &fv){ // check if threshold is greater than (or equal to) feature bool guess = ( wc.threshold() >= fv.at(wc.dimension()) ); // if classifier is flipped, negate guess guess = wc.isFlipped() ? !guess : guess; // find actual value of point bool real = ( fv.val() == POS ); // return if guess and real agree return ( real == guess ); }
PERIPHERAL_ERROR GetFeatures(const JOYSTICK_INFO* joystick, const char* controller_id, unsigned int* feature_count, JOYSTICK_FEATURE** features) { if (!joystick || !controller_id || !feature_count || !features) return PERIPHERAL_ERROR_INVALID_PARAMETERS; FeatureVector featureVector; if (CStorageManager::Get().GetFeatures(ADDON::Joystick(*joystick), controller_id, featureVector)) { *feature_count = featureVector.size(); ADDON::JoystickFeatures::ToStructs(featureVector, features); return PERIPHERAL_NO_ERROR; } return PERIPHERAL_ERROR_FAILED; }
int RecBase :: recognizeEuclidean(FeatureVector& charvec, int gHint){ int cat,rank,i; double d,d0; initResultTable(); d0 = DBL_MAX; for ( cat=0 ; cat<n_cat ; cat++ ){ // d = charvec.distEuclidean2(dic[cat]); d = charvec.distEuclidean2(dic[cat],d0); if ( d >= d0 ) continue; for ( rank=0 ; rank<n_top ; rank++ ){ if ( d >= resultTable[rank].dist ) continue; for ( i=n_top-2 ; i>=rank ; i-- ){ resultTable[i+1] = resultTable[i]; } resultTable[rank].dist = d; resultTable[rank].id = cat; d0 = resultTable[n_top-1].dist; break; } } for ( i=0 ; i<n_top ; i++ ){ resultTable[i].dist = sqrt(resultTable[i].dist); } return(0); }
inline Tp1 dot_product(const FeatureVector<Tp1, Alloc1>& x, const WeightVector<Tp, Alloc>& w, const FeatureVector<Tp2, Alloc2>& y) { typedef FeatureVector<Tp1, Alloc1> feature_vector1_type; typedef WeightVector<Tp, Alloc> weight_vector_type; typedef FeatureVector<Tp2, Alloc2> feature_vector2_type; if (x.empty() || y.empty()) return Tp1(); if (static_cast<const void*>(&x) == static_cast<const void*>(&y)) return details::__inner_product(x.begin(), x.end(), w, Tp1()); if (x.size() < y.size()) return dot_product(x.begin(), x.end(), w, y, Tp1()); else return dot_product(x, w, y.begin(), y.end(), Tp1()); }
void VectorDataSet::weightedSum(FeatureVector& result, const std::vector<int> &patterns, const std::vector<double> &alpha) { int pIndex; // ASA FeatureVector is an alias for vector<double> vector<double> weight_temp (numFeatures,0); for (unsigned int i = 0; i < patterns.size(); i++){ pIndex = patterns[i]; for (int j = 0; j != X[pIndex].size(); ++j){ weight_temp[j] += X[pIndex][j] * alpha[i]; } } result.clear(); result.initialize(weight_temp); }
inline Tp1 dot_product(const FeatureVector<Tp1, Alloc1>& x, const FeatureVector<Tp2, Alloc2>& y) { typedef FeatureVector<Tp1, Alloc1> feature_vector1_type; typedef FeatureVector<Tp2, Alloc2> feature_vector2_type; if (x.empty() || y.empty()) return Tp1(); // if the same address, we are identical! if (static_cast<const void*>(&x) == static_cast<const void*>(&y)) return details::__inner_product(x.begin(), x.end(), Tp1()); if (x.size() < y.size()) return dot_product(x.begin(), x.end(), y, Tp1()); else return dot_product(x, y.begin(), y.end(), Tp1()); }
FeatureSet FeatureSet::clone() const { FeatureSet other; for (FeatureSet::const_iterator i = begin(); i != end(); ++i) { FeatureVector cv = i->clone(); // check that all data is the same: if (cv.size() != i->size()) throw std::runtime_error("ssssssssss"); for (unsigned int idx=0; idx<cv.size(); ++idx) { if (cv[idx] != (*i)[idx]) { cout << "(" << cv[idx] << "!=" << (*i)[idx] << ")" << flush; throw std::runtime_error("??????????"); } } if (cv.getTag<TagTrueClassLabel>().label != i->getTag<TagTrueClassLabel>().label) { cout << "(" << cv.getTag<TagTrueClassLabel>().label << "!=" << i->getTag<TagTrueClassLabel>().label << ")" << flush; throw std::runtime_error("!!!!!!!!!!!"); } other.push_back(cv); } return other; }
int main(int argc, char** argv) { static const size_t K = 3; typedef double Scalar; typedef Eigen::Matrix<Scalar, 1, K> Feature; typedef std::vector<Feature, Eigen::aligned_allocator<Feature> > FeatureVector; FeatureVector features(1000*K); FeatureVector centers; std::vector<unsigned int> membership; FILE* data = fopen(argv[1], "r"); for (size_t i = 0; i < features.size(); ++i) { Feature& f = features[i]; fscanf(data, "%lf %lf %lf", &f[0], &f[1], &f[2]); } vt::SimpleKmeans<Feature> kmeans(Feature::Zero()); double sse = kmeans.cluster(features, K, centers, membership); for (size_t i = 0; i < centers.size(); ++i) { printf("%f %f %f\n", centers[i][0], centers[i][1], centers[i][2]); } printf("sse = %f\n", sse); unsigned int pattern[K]; pattern[0] = membership[0]; pattern[1] = membership[1]; pattern[2] = membership[2]; for (size_t i = 0; i < membership.size(); i+=K) { if (membership[i] != pattern[0] || membership[i+1] != pattern[1] || membership[i+2] != pattern[2]) { printf("Misassignment!\n"); return -1; } } }
void Slic::_InitCenterFeature(int i, int j, FeatureVector &featureVec) { featureVec.clear(); uchar *buffer = new uchar[5*5*_dataSize*_bandCount]; _poSrcDS->RasterIO(GF_Read,j-2,i-2,5,5,buffer,5,5,_dataType,_bandCount,0,0,0,0); double minEdge = std::numeric_limits<double>::max(); int minN; int minM; for (int n=1;n<4;++n) { for(int m=1;m<4;++m) { double edge = 0; edge += (buffer[(n-1)*5+m]-buffer[(n+1)*5+m])*(buffer[(n-1)*5+m]-buffer[(n+1)*5+m]); edge += (buffer[n*5+m-1]-buffer[n*5+m+1])*(buffer[n*5+m-1]-buffer[n*5+m+1]); if (edge < minEdge) { minEdge = edge; minN = n; minM = m; } } } int centerIndex = minN*5+minM; uchar* p = buffer; for(int k=0;k<_bandCount;++k,p += (5*5*_dataSize)) { featureVec.push_back( SRCVAL(p,_dataType,centerIndex)/_regularizer); } featureVec.push_back(static_cast<double>(j+minM-2)/_regionSize); //x featureVec.push_back(static_cast<double>(i+minN-2)/_regionSize); //y delete []buffer; }
void ClassifySvmSharedCommand::readSharedRAbundVectors(vector<SharedRAbundVector*>& lookup, GroupMap& designMap, LabeledObservationVector& labeledObservationVector, FeatureVector& featureVector) { for ( int j = 0; j < lookup.size(); j++ ) { //i++; vector<individual> data = lookup[j]->getData(); Observation* observation = new Observation(data.size(), 0.0); string sharedGroupName = lookup[j]->getGroup(); string treatmentName = designMap.getGroup(sharedGroupName); //std::cout << "shared group name: " << sharedGroupName << " treatment name: " << treatmentName << std::endl; //labeledObservationVector.push_back(std::make_pair(treatmentName, observation)); labeledObservationVector.push_back(LabeledObservation(j, treatmentName, observation)); //std::cout << " j=" << j << " label : " << lookup[j]->getLabel() << " group: " << lookup[j]->getGroup(); for (int k = 0; k < data.size(); k++) { //std::cout << " abundance " << data[k].abundance; observation->at(k) = double(data[k].abundance); if ( j == 0) { featureVector.push_back(Feature(k, m->currentSharedBinLabels[k])); } } //std::cout << std::endl; // let this happen later? //delete lookup[j]; } }
bool CButtonMapXml::Load(void) { TiXmlDocument xmlFile; if (!xmlFile.LoadFile(m_strResourcePath)) { esyslog("Error opening %s: %s", m_strResourcePath.c_str(), xmlFile.ErrorDesc()); return false; } TiXmlElement* pRootElement = xmlFile.RootElement(); if (!pRootElement || pRootElement->NoChildren() || pRootElement->ValueStr() != BUTTONMAP_XML_ROOT) { esyslog("Can't find root <%s> tag", BUTTONMAP_XML_ROOT); return false; } const TiXmlElement* pDevice = pRootElement->FirstChildElement(DEVICES_XML_ELEM_DEVICE); if (!pDevice) { esyslog("Can't find <%s> tag", DEVICES_XML_ELEM_DEVICE); return false; } if (!CDeviceXml::Deserialize(pDevice, m_device)) return false; const TiXmlElement* pController = pDevice->FirstChildElement(BUTTONMAP_XML_ELEM_CONTROLLER); if (!pController) { esyslog("Device \"%s\": can't find <%s> tag", m_device.Name().c_str(), BUTTONMAP_XML_ELEM_CONTROLLER); return false; } // For logging purposes unsigned int totalFeatureCount = 0; while (pController) { const char* id = pController->Attribute(BUTTONMAP_XML_ATTR_CONTROLLER_ID); if (!id) { esyslog("Device \"%s\": <%s> tag has no attribute \"%s\"", m_device.Name().c_str(), BUTTONMAP_XML_ELEM_CONTROLLER, BUTTONMAP_XML_ATTR_CONTROLLER_ID); return false; } FeatureVector features; if (!Deserialize(pController, features)) return false; if (features.empty()) { esyslog("Device \"%s\" has no features for controller %s", m_device.Name().c_str(), id); } else { totalFeatureCount += features.size(); m_buttonMap[id] = std::move(features); } pController = pController->NextSiblingElement(BUTTONMAP_XML_ELEM_CONTROLLER); } dsyslog("Loaded device \"%s\" with %u controller profiles and %u total features", m_device.Name().c_str(), m_buttonMap.size(), totalFeatureCount); return true; }
MLClassPtr Classifier2::ClassifyAImageOneLevel (FeatureVector& example, double& probability, kkint32& numOfWinners, bool& knownClassOneOfTheWinners, double& breakTie ) { probability = 0.0; double probOfKnownClass = 0.0f; probability = 0.0; MLClassPtr origClass = example.MLClass (); MLClassPtr predictedClass = NULL; MLClassPtr predictedClass2 = NULL; kkint32 class1Votes = -1; kkint32 class2Votes = -1; double predictedClass2Prob = 0.0f; trainedModel->Predict (&example, origClass, predictedClass, predictedClass2, class1Votes, class2Votes, probOfKnownClass, probability, predictedClass2Prob, numOfWinners, knownClassOneOfTheWinners, breakTie, log ); if (predictedClass == NULL) { log.Level (-1) << endl << endl << "Classifier2::ClassifyAImageOneLevel The trainedModel returned back a NULL pointer for predicted class" << endl << endl; predictedClass = unKnownMLClass; } if (subClassifiers) { Classifier2Ptr subClassifer = LookUpSubClassifietByClass (predictedClass); if (subClassifer) { double subProbability = 0.0; kkint32 subNumOfWinners = 0; double subBreakTie = 0.0; /**@todo make sure that the following call does not normalize the features. */ MLClassPtr subPrediction = subClassifer->ClassifyAImageOneLevel (example, subProbability, subNumOfWinners, knownClassOneOfTheWinners, subBreakTie); if (subPrediction) { probability = probability * subProbability; numOfWinners = numOfWinners + subNumOfWinners; breakTie += subBreakTie * (1.0 - breakTie); } } } if (predictedClass->UnDefined ()) predictedClass = noiseMLClass; example.MLClass (predictedClass); return predictedClass; } /* ClassifyAImageOneLevel */
inline Tp1 dot_product(const WeightVector<Tp1, Alloc1>& x, const FeatureVector<Tp2, Alloc2>& y) { return dot_product(x, y.begin(), y.end(), Tp1()); }
void Classifier2::ClassifyAExample (FeatureVector& example, MLClassPtr& predClass1, MLClassPtr& predClass2, kkint32& predClass1Votes, kkint32& predClass2Votes, double& knownClassProb, double& predClass1Prob, double& predClass2Prob, kkint32& numOfWinners, double& breakTie ) { bool knownClassOneOfTheWiners = false; predClass1 = NULL; predClass2 = NULL; knownClassProb = -1.0f; predClass1Prob = -1.0f; predClass2Prob = -1.0f; MLClassPtr origClass = example.MLClass (); trainedModel->Predict (&example, origClass, predClass1, predClass2, predClass1Votes, predClass2Votes, knownClassProb, predClass1Prob, predClass2Prob, numOfWinners, knownClassOneOfTheWiners, breakTie, log ); if (!predClass1) predClass1 = noiseMLClass; if (subClassifiers) { Classifier2Ptr subClassifer = LookUpSubClassifietByClass (predClass1); if (subClassifer) { MLClassPtr subPredClass1 = NULL; MLClassPtr subPredClass2 = NULL; kkint32 subPredClass1Votes = 0; kkint32 subPredClass2Votes = 0; double subKnownClassProb = 0.0; double subPredClass1Prob = 0.0; double subPredClass2Prob = 0.0; kkint32 subNumOfWinners = 0; double subBreakTie = 0.0; subClassifer->ClassifyAExample (example, subPredClass1, subPredClass2, subPredClass1Votes, subPredClass2Votes, subKnownClassProb, subPredClass1Prob, subPredClass2Prob, subNumOfWinners, subBreakTie ); predClass1 = subPredClass1; predClass1Votes += subPredClass1Votes; predClass1Prob *= subPredClass1Prob; knownClassProb *= subKnownClassProb; numOfWinners += subNumOfWinners; breakTie += subBreakTie * (1.0 - breakTie); } subClassifer = LookUpSubClassifietByClass (predClass2); if (subClassifer) { MLClassPtr subPredClass1 = NULL; MLClassPtr subPredClass2 = NULL; kkint32 subPredClass1Votes = 0; kkint32 subPredClass2Votes = 0; double subKnownClassProb = 0.0; double subPredClass1Prob = 0.0; double subPredClass2Prob = 0.0; kkint32 subNumOfWinners = 0; double subBreakTie = 0.0; subClassifer->ClassifyAExample (example, subPredClass1, subPredClass2, subPredClass1Votes, subPredClass2Votes, subKnownClassProb, subPredClass1Prob, subPredClass2Prob, subNumOfWinners, subBreakTie ); predClass2 = subPredClass1; predClass2Votes += subPredClass1Votes; predClass2Prob *= subPredClass1Prob; } } example.MLClass (predClass1); return; } /* ClassifyAExample */
void Pipe::TrainEpoch(int epoch) { Instance *instance; Parts *parts = CreateParts(); Features *features = CreateFeatures(); vector<double> scores; vector<double> gold_outputs; vector<double> predicted_outputs; double total_cost = 0.0; double total_loss = 0.0; double eta; int num_instances = instances_.size(); double lambda = 1.0/(options_->GetRegularizationConstant() * (static_cast<double>(num_instances))); timeval start, end; gettimeofday(&start, NULL); int time_decoding = 0; int time_scores = 0; int num_mistakes = 0; LOG(INFO) << " Iteration #" << epoch + 1; dictionary_->StopGrowth(); for (int i = 0; i < instances_.size(); i++) { int t = num_instances * epoch + i; instance = instances_[i]; MakeParts(instance, parts, &gold_outputs); MakeFeatures(instance, parts, features); // If using only supported features, must remove the unsupported ones. // This is necessary not to mess up the computation of the squared norm // of the feature difference vector in MIRA. if (options_->only_supported_features()) { RemoveUnsupportedFeatures(instance, parts, features); } timeval start_scores, end_scores; gettimeofday(&start_scores, NULL); ComputeScores(instance, parts, features, &scores); gettimeofday(&end_scores, NULL); time_scores += diff_ms(end_scores, start_scores); if (options_->GetTrainingAlgorithm() == "perceptron" || options_->GetTrainingAlgorithm() == "mira" ) { timeval start_decoding, end_decoding; gettimeofday(&start_decoding, NULL); decoder_->Decode(instance, parts, scores, &predicted_outputs); gettimeofday(&end_decoding, NULL); time_decoding += diff_ms(end_decoding, start_decoding); if (options_->GetTrainingAlgorithm() == "perceptron") { for (int r = 0; r < parts->size(); ++r) { if (!NEARLY_EQ_TOL(gold_outputs[r], predicted_outputs[r], 1e-6)) { ++num_mistakes; } } eta = 1.0; } else { CHECK(false) << "Plain mira is not implemented yet."; } MakeGradientStep(parts, features, eta, t, gold_outputs, predicted_outputs); } else if (options_->GetTrainingAlgorithm() == "svm_mira" || options_->GetTrainingAlgorithm() == "crf_mira" || options_->GetTrainingAlgorithm() == "svm_sgd" || options_->GetTrainingAlgorithm() == "crf_sgd") { double loss; timeval start_decoding, end_decoding; gettimeofday(&start_decoding, NULL); if (options_->GetTrainingAlgorithm() == "svm_mira" || options_->GetTrainingAlgorithm() == "svm_sgd") { // Do cost-augmented inference. double cost; decoder_->DecodeCostAugmented(instance, parts, scores, gold_outputs, &predicted_outputs, &cost, &loss); total_cost += cost; } else { // Do marginal inference. double entropy; decoder_->DecodeMarginals(instance, parts, scores, gold_outputs, &predicted_outputs, &entropy, &loss); CHECK_GE(entropy, 0.0); } gettimeofday(&end_decoding, NULL); time_decoding += diff_ms(end_decoding, start_decoding); if (loss < 0.0) { if (!NEARLY_EQ_TOL(loss, 0.0, 1e-9)) { LOG(INFO) << "Warning: negative loss set to zero: " << loss; } loss = 0.0; } total_loss += loss; // Compute difference between predicted and gold feature vectors. FeatureVector difference; MakeFeatureDifference(parts, features, gold_outputs, predicted_outputs, &difference); // Get the stepsize. if (options_->GetTrainingAlgorithm() == "svm_mira" || options_->GetTrainingAlgorithm() == "crf_mira") { double squared_norm = difference.GetSquaredNorm(); double threshold = 1e-9; if (loss < threshold || squared_norm < threshold) { eta = 0.0; } else { eta = loss / squared_norm; if (eta > options_->GetRegularizationConstant()) { eta = options_->GetRegularizationConstant(); } } } else { if (options_->GetLearningRateSchedule() == "fixed") { eta = options_->GetInitialLearningRate(); } else if (options_->GetLearningRateSchedule() == "invsqrt") { eta = options_->GetInitialLearningRate() / sqrt(static_cast<double>(t+1)); } else if (options_->GetLearningRateSchedule() == "inv") { eta = options_->GetInitialLearningRate() / static_cast<double>(t+1); } else if (options_->GetLearningRateSchedule() == "lecun") { eta = options_->GetInitialLearningRate() / (1.0 + (static_cast<double>(t) / static_cast<double>(num_instances))); } else { CHECK(false) << "Unknown learning rate schedule: " << options_->GetLearningRateSchedule(); } // Scale the parameter vector (only for SGD). double decay = 1 - eta * lambda; CHECK_GT(decay, 0.0); parameters_->Scale(decay); } MakeGradientStep(parts, features, eta, t, gold_outputs, predicted_outputs); } else { CHECK(false) << "Unknown algorithm: " << options_->GetTrainingAlgorithm(); } } // Compute the regularization value (halved squared L2 norm of the weights). double regularization_value = lambda * static_cast<double>(num_instances) * parameters_->GetSquaredNorm() / 2.0; delete parts; delete features; gettimeofday(&end, NULL); LOG(INFO) << "Time: " << diff_ms(end,start); LOG(INFO) << "Time to score: " << time_scores; LOG(INFO) << "Time to decode: " << time_decoding; LOG(INFO) << "Number of Features: " << parameters_->Size(); if (options_->GetTrainingAlgorithm() == "perceptron" || options_->GetTrainingAlgorithm() == "mira") { LOG(INFO) << "Number of mistakes: " << num_mistakes; } LOG(INFO) << "Total Cost: " << total_cost << "\t" << "Total Loss: " << total_loss << "\t" << "Total Reg: " << regularization_value << "\t" << "Total Loss+Reg: " << total_loss + regularization_value << endl; }
void vtree_user::compute_features( const std::string& cloud_filename, FeatureVector &feature_vector ) { typedef pcl::PointXYZ nx_PointT; typedef pcl::Normal nx_Normal; typedef pcl::PointCloud<nx_PointT> nx_PointCloud; typedef pcl::PointCloud<nx_Normal> nx_PointCloud_normal; typedef pcl::PointCloud<int> nx_PointCloud_int; typedef pcl::UniformSampling<nx_PointT> nx_Sampler; typedef pcl::search::KdTree<nx_PointT> nx_SearchMethod; typedef pcl::NormalEstimation<nx_PointT, nx_Normal> nx_NormalEst; #if FEATURE == 1 typedef pcl::FPFHSignature33 nx_FeatureType; typedef pcl::FPFHEstimation<nx_PointT, nx_Normal, nx_FeatureType> nx_FeatureEst; #elif FEATURE == 2 typedef pcl::PFHSignature125 nx_FeatureType; typedef pcl::PFHEstimation<nx_PointT, nx_Normal, nx_FeatureType> nx_FeatureEst; #elif FEATURE == 3 typedef pcl::VFHSignature308 nx_FeatureType; typedef pcl::VFHEstimation<nx_PointT, nx_Normal, nx_FeatureType> nx_FeatureEst; #else #error A valid feature definition is required! #endif typedef pcl::PointCloud<nx_FeatureType> nx_PointCloud_feature; // load the file nx_PointCloud::Ptr cld_ptr(new nx_PointCloud); pcl::io::loadPCDFile<nx_PointT> ( cloud_filename, *cld_ptr); ROS_INFO("[vtree_user] Starting keypoint extraction..."); clock_t tic = clock(); nx_PointCloud::Ptr keypoints( new nx_PointCloud); nx_PointCloud_int::Ptr keypoint_idx(new nx_PointCloud_int); nx_Sampler uniform_sampling; uniform_sampling.setInputCloud ( cld_ptr ); uniform_sampling.setRadiusSearch ( keypoint_radius_ ); uniform_sampling.compute( *keypoint_idx ); pcl::copyPointCloud ( *cld_ptr, keypoint_idx->points, *keypoints); ROS_INFO("[vtree_user] No of Keypoints found %d", static_cast<int>(keypoint_idx->size()) ); ROS_INFO("[vtree_user] Keypoint extraction took %f msec.", static_cast<double>((clock()-tic)*1000)/CLOCKS_PER_SEC ); if( keypoints->empty() ) { ROS_WARN("[vtree_user] No keypoints were found..."); return; } // Compute normals for the input cloud ROS_INFO("[vtree_user] Starting normal extraction..."); tic = clock(); nx_PointCloud_normal::Ptr normals (new nx_PointCloud_normal); nx_SearchMethod::Ptr search_method_xyz (new nx_SearchMethod); nx_NormalEst norm_est; norm_est.setInputCloud ( cld_ptr ); norm_est.setSearchMethod ( search_method_xyz ); norm_est.setRadiusSearch ( normal_radius_ ); norm_est.compute ( *normals ); ROS_INFO("[vtree_user] Normal extraction took %f msec.", static_cast<double>((clock()-tic)*1000)/CLOCKS_PER_SEC ); // Get features at the computed keypoints ROS_INFO("[vtree_user] Starting feature computation..."); tic = clock(); nx_PointCloud_feature::Ptr features(new nx_PointCloud_feature); nx_FeatureEst feat_est; feat_est.setInputCloud ( keypoints ); feat_est.setSearchSurface ( cld_ptr ); feat_est.setInputNormals ( normals ); search_method_xyz.reset(new nx_SearchMethod); feat_est.setSearchMethod ( search_method_xyz ); feat_est.setRadiusSearch ( feature_radius_ ); feat_est.compute ( *features ); ROS_INFO("[vtree_user] No of Features found %d", static_cast<int>(features->size()) ); ROS_INFO("[vtree_user] Feature computation took %f msec.", static_cast<double>((clock()-tic)*1000)/CLOCKS_PER_SEC ); // Rectify the historgram values to ensure they are in [0,100] and create a document for( nx_PointCloud_feature::iterator iter = features->begin(); iter != features->end(); ++iter) { rectify_histogram( iter->histogram ); feature_vector.push_back( FeatureHist( iter->histogram ) ); } }
bool CButtonMapXml::Serialize(const FeatureVector& features, TiXmlElement* pElement) { if (pElement == NULL) return false; for (FeatureVector::const_iterator it = features.begin(); it != features.end(); ++it) { const ADDON::JoystickFeature& feature = *it; if (!IsValid(feature)) continue; TiXmlElement featureElement(BUTTONMAP_XML_ELEM_FEATURE); TiXmlNode* featureNode = pElement->InsertEndChild(featureElement); if (featureNode == NULL) return false; TiXmlElement* featureElem = featureNode->ToElement(); if (featureElem == NULL) return false; featureElem->SetAttribute(BUTTONMAP_XML_ATTR_FEATURE_NAME, feature.Name()); switch (feature.Type()) { case JOYSTICK_FEATURE_TYPE_SCALAR: { SerializePrimitive(featureElem, feature.Primitive()); break; } case JOYSTICK_FEATURE_TYPE_ANALOG_STICK: { if (!SerializePrimitiveTag(featureElem, feature.Up(), BUTTONMAP_XML_ELEM_UP)) return false; if (!SerializePrimitiveTag(featureElem, feature.Down(), BUTTONMAP_XML_ELEM_DOWN)) return false; if (!SerializePrimitiveTag(featureElem, feature.Right(), BUTTONMAP_XML_ELEM_RIGHT)) return false; if (!SerializePrimitiveTag(featureElem, feature.Left(), BUTTONMAP_XML_ELEM_LEFT)) return false; break; } case JOYSTICK_FEATURE_TYPE_ACCELEROMETER: { if (!SerializePrimitiveTag(featureElem, feature.PositiveX(), BUTTONMAP_XML_ELEM_POSITIVE_X)) return false; if (!SerializePrimitiveTag(featureElem, feature.PositiveY(), BUTTONMAP_XML_ELEM_POSITIVE_Y)) return false; if (!SerializePrimitiveTag(featureElem, feature.PositiveZ(), BUTTONMAP_XML_ELEM_POSITIVE_Z)) return false; break; } default: break; } } return true; }
bool CButtonMapXml::Deserialize(const TiXmlElement* pElement, FeatureVector& features) { const TiXmlElement* pFeature = pElement->FirstChildElement(BUTTONMAP_XML_ELEM_FEATURE); if (!pFeature) { esyslog("Can't find <%s> tag", BUTTONMAP_XML_ELEM_FEATURE); return false; } while (pFeature) { const char* name = pFeature->Attribute(BUTTONMAP_XML_ATTR_FEATURE_NAME); if (!name) { esyslog("<%s> tag has no \"%s\" attribute", BUTTONMAP_XML_ELEM_FEATURE, BUTTONMAP_XML_ATTR_FEATURE_NAME); return false; } std::string strName(name); const TiXmlElement* pUp = nullptr; const TiXmlElement* pDown = nullptr; const TiXmlElement* pRight = nullptr; const TiXmlElement* pLeft = nullptr; const TiXmlElement* pPositiveX = nullptr; const TiXmlElement* pPositiveY = nullptr; const TiXmlElement* pPositiveZ = nullptr; // Determine the feature type JOYSTICK_FEATURE_TYPE type; ADDON::DriverPrimitive primitive; if (DeserializePrimitive(pFeature, primitive, strName)) { type = JOYSTICK_FEATURE_TYPE_SCALAR; } else { pUp = pFeature->FirstChildElement(BUTTONMAP_XML_ELEM_UP); pDown = pFeature->FirstChildElement(BUTTONMAP_XML_ELEM_DOWN); pRight = pFeature->FirstChildElement(BUTTONMAP_XML_ELEM_RIGHT); pLeft = pFeature->FirstChildElement(BUTTONMAP_XML_ELEM_LEFT); if (pUp || pDown || pRight || pLeft) { type = JOYSTICK_FEATURE_TYPE_ANALOG_STICK; } else { pPositiveX = pFeature->FirstChildElement(BUTTONMAP_XML_ELEM_POSITIVE_X); pPositiveY = pFeature->FirstChildElement(BUTTONMAP_XML_ELEM_POSITIVE_Y); pPositiveZ = pFeature->FirstChildElement(BUTTONMAP_XML_ELEM_POSITIVE_Z); if (pPositiveX || pPositiveY || pPositiveZ) { type = JOYSTICK_FEATURE_TYPE_ACCELEROMETER; } else { esyslog("Feature \"%s\": <%s> tag is not a valid primitive", strName.c_str(), BUTTONMAP_XML_ELEM_FEATURE); return false; } } } ADDON::JoystickFeature feature(strName, type); // Deserialize according to type switch (type) { case JOYSTICK_FEATURE_TYPE_SCALAR: { feature.SetPrimitive(primitive); break; } case JOYSTICK_FEATURE_TYPE_ANALOG_STICK: { ADDON::DriverPrimitive up; ADDON::DriverPrimitive down; ADDON::DriverPrimitive right; ADDON::DriverPrimitive left; bool bSuccess = true; if (pUp && !DeserializePrimitive(pUp, up, strName)) { esyslog("Feature \"%s\": <%s> tag is not a valid primitive", strName.c_str(), BUTTONMAP_XML_ELEM_UP); bSuccess = false; } if (pDown && !DeserializePrimitive(pDown, down, strName)) { esyslog("Feature \"%s\": <%s> tag is not a valid primitive", strName.c_str(), BUTTONMAP_XML_ELEM_DOWN); bSuccess = false; } if (pRight && !DeserializePrimitive(pRight, right, strName)) { esyslog("Feature \"%s\": <%s> tag is not a valid primitive", strName.c_str(), BUTTONMAP_XML_ELEM_RIGHT); bSuccess = false; } if (pLeft && !DeserializePrimitive(pLeft, left, strName)) { esyslog("Feature \"%s\": <%s> tag is not a valid primitive", strName.c_str(), BUTTONMAP_XML_ELEM_LEFT); bSuccess = false; } if (!bSuccess) return false; feature.SetUp(up); feature.SetDown(down); feature.SetRight(right); feature.SetLeft(left); break; } case JOYSTICK_FEATURE_TYPE_ACCELEROMETER: { ADDON::DriverPrimitive positiveX; ADDON::DriverPrimitive positiveY; ADDON::DriverPrimitive positiveZ; bool bSuccess = true; if (pPositiveX && !DeserializePrimitive(pPositiveX, positiveY, strName)) { esyslog("Feature \"%s\": <%s> tag is not a valid primitive", strName.c_str(), BUTTONMAP_XML_ELEM_POSITIVE_X); bSuccess = false; } if (pPositiveY && !DeserializePrimitive(pPositiveY, positiveY, strName)) { esyslog("Feature \"%s\": <%s> tag is not a valid primitive", strName.c_str(), BUTTONMAP_XML_ELEM_POSITIVE_Y); bSuccess = false; } if (pPositiveZ && !DeserializePrimitive(pPositiveZ, positiveZ, strName)) { esyslog("Feature \"%s\": <%s> tag is not a valid primitive", strName.c_str(), BUTTONMAP_XML_ELEM_POSITIVE_Z); bSuccess = false; } if (!bSuccess) return false; feature.SetPositiveX(positiveX); feature.SetPositiveY(positiveY); feature.SetPositiveZ(positiveZ); break; } default: break; } features.push_back(feature); pFeature = pFeature->NextSiblingElement(BUTTONMAP_XML_ELEM_FEATURE); } return true; }
void ClassifySvmSharedCommand::processSharedAndDesignData(vector<SharedRAbundVector*> lookup) { try { OutputFilter outputFilter(verbosity); LabeledObservationVector labeledObservationVector; FeatureVector featureVector; readSharedRAbundVectors(lookup, designMap, labeledObservationVector, featureVector); // optionally remove features with low standard deviation if ( stdthreshold > 0.0 ) { FeatureVector removedFeatureVector = applyStdThreshold(stdthreshold, labeledObservationVector, featureVector); if (removedFeatureVector.size() > 0) { std::cout << removedFeatureVector.size() << " OTUs were below the stdthreshold of " << stdthreshold << " and were removed" << std::endl; if ( outputFilter.debug() ) { std::cout << "the following OTUs were below the standard deviation threshold of " << stdthreshold << std::endl; for (FeatureVector::iterator i = removedFeatureVector.begin(); i != removedFeatureVector.end(); i++) { std::cout << " " << i->getFeatureLabel() << std::endl; } } } } // apply [0,1] standardization if ( transformName == "zeroone") { std::cout << "transforming data to lie within range [0,1]" << std::endl; transformZeroOne(labeledObservationVector); } else { std::cout << "transforming data to have zero mean and unit variance" << std::endl; transformZeroMeanUnitVariance(labeledObservationVector); } SvmDataset svmDataset(labeledObservationVector, featureVector); OneVsOneMultiClassSvmTrainer trainer(svmDataset, evaluationFoldCount, trainingFoldCount, *this, outputFilter); if ( mode == "rfe" ) { SvmRfe svmRfe; ParameterRange& linearKernelConstantRange = kernelParameterRangeMap["linear"]["constant"]; ParameterRange& linearKernelSmoCRange = kernelParameterRangeMap["linear"]["smoc"]; RankedFeatureList rankedFeatureList = svmRfe.getOrderedFeatureList(svmDataset, trainer, linearKernelConstantRange, linearKernelSmoCRange); map<string, string> variables; variables["[filename]"] = outputDir + m->getRootName(m->getSimpleName(sharedfile)); variables["[distance]"] = lookup[0]->getLabel(); string filename = getOutputFileName("summary", variables); outputNames.push_back(filename); outputTypes["summary"].push_back(filename); m->mothurOutEndLine(); std::ofstream outputFile(filename.c_str()); int n = 0; int rfeRoundCount = rankedFeatureList.front().getRank(); std::cout << "ordered features:" << std::endl; std::cout << setw(5) << "index" << setw(12) << "OTU" << setw(5) << "rank" << std::endl; outputFile << setw(5) << "index" << setw(12) << "OTU" << setw(5) << "rank" << std::endl; for (RankedFeatureList::iterator i = rankedFeatureList.begin(); i != rankedFeatureList.end(); i++) { n++; int rank = rfeRoundCount - i->getRank() + 1; outputFile << setw(5) << n << setw(12) << i->getFeature().getFeatureLabel() << setw(5) << rank << std::endl; if ( n <= 20 ) { std::cout << setw(5) << n << setw(12) << i->getFeature().getFeatureLabel() << setw(5) << rank << std::endl; } } outputFile.close(); } else { MultiClassSVM* mcsvm = trainer.train(kernelParameterRangeMap); map<string, string> variables; variables["[filename]"] = outputDir + m->getRootName(m->getSimpleName(sharedfile)); variables["[distance]"] = lookup[0]->getLabel(); string filename = getOutputFileName("summary", variables); outputNames.push_back(filename); outputTypes["summary"].push_back(filename); m->mothurOutEndLine(); std::ofstream outputFile(filename.c_str()); printPerformanceSummary(mcsvm, std::cout); printPerformanceSummary(mcsvm, outputFile); outputFile << "actual predicted" << std::endl; for ( LabeledObservationVector::const_iterator i = labeledObservationVector.begin(); i != labeledObservationVector.end(); i++ ) { Label actualLabel = i->getLabel(); outputFile << i->getDatasetIndex() << " " << actualLabel << " "; try { Label predictedLabel = mcsvm->classify(*(i->getObservation())); outputFile << predictedLabel << std::endl; } catch ( MultiClassSvmClassificationTie& m ) { outputFile << "tie" << std::endl; std::cout << "classification tie for observation " << i->datasetIndex << " with label " << i->first << std::endl; } } outputFile.close(); delete mcsvm; } } catch (exception& e) { m->errorOut(e, "ClassifySvmSharedCommand", "processSharedAndDesignData"); exit(1); } }