PLearn 0.1
|
00001 // -*- C++ -*- 00002 00003 // PLearn (A C++ Machine Learning Library) 00004 // Copyright (C) 1998 Pascal Vincent 00005 // Copyright (C) 1999-2002 Pascal Vincent, Yoshua Bengio and University of Montreal 00006 // 00007 00008 // Redistribution and use in source and binary forms, with or without 00009 // modification, are permitted provided that the following conditions are met: 00010 // 00011 // 1. Redistributions of source code must retain the above copyright 00012 // notice, this list of conditions and the following disclaimer. 00013 // 00014 // 2. Redistributions in binary form must reproduce the above copyright 00015 // notice, this list of conditions and the following disclaimer in the 00016 // documentation and/or other materials provided with the distribution. 00017 // 00018 // 3. The name of the authors may not be used to endorse or promote 00019 // products derived from this software without specific prior written 00020 // permission. 00021 // 00022 // THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR 00023 // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 00024 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN 00025 // NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 00026 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 00027 // TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 00028 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 00029 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 00030 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 00031 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00032 // 00033 // This file is part of the PLearn library. For more information on the PLearn 00034 // library, go to the PLearn Web site at www.plearn.org 00035 00036 00037 /* ******************************************************* 00038 * $Id: StatsIterator.cc 3994 2005-08-25 13:35:03Z chapados $ 00039 * This file is part of the PLearn library. 00040 ******************************************************* */ 00041 00042 #include "StatsIterator.h" 00043 #include "TMat_maths.h" 00044 00045 namespace PLearn { 00046 using namespace std; 00047 00048 // ******************* 00049 // ** StatsIterator ** 00050 // ******************* 00051 00052 PLEARN_IMPLEMENT_ABSTRACT_OBJECT(StatsIterator, "ONE LINE DESCR", "NO HELP"); 00053 void StatsIterator::makeDeepCopyFromShallowCopy(CopiesMap& copies) 00054 { 00055 inherited::makeDeepCopyFromShallowCopy(copies); 00056 deepCopyField(result, copies); 00057 } 00058 00059 bool StatsIterator::requiresMultiplePasses() { return false; } 00060 00061 Vec StatsIterator::getResult() { return result; } 00062 00063 void StatsIterator::declareOptions(OptionList& ol) 00064 { 00065 declareOption(ol, "result", &StatsIterator::result, OptionBase::learntoption, 00066 " result\n"); 00067 00068 inherited::declareOptions(ol); 00069 } 00070 00071 void StatsIterator::oldwrite(ostream& out) const 00072 { 00073 writeHeader(out,"StatsIterator"); 00074 //inherited::write(out); 00075 writeField(out,"result",result); 00076 writeFooter(out,"StatsIterator"); 00077 } 00078 00079 /* TODO Remove (deprecated) 00080 void StatsIterator::oldread(istream& in) 00081 { 00082 readHeader(in,"StatsIterator"); 00083 //inherited::read(int); 00084 readField(in,"result",result); 00085 readFooter(in,"StatsIterator"); 00086 } 00087 */ 00088 00089 // *********************** 00090 // ** MeanStatsIterator ** 00091 // *********************** 00092 00093 PLEARN_IMPLEMENT_OBJECT(MeanStatsIterator, "ONE LINE DESCR", "NO HELP"); 00094 00095 void MeanStatsIterator::init(int inputsize) 00096 { 00097 // We do not use resize on purpose, so 00098 // that the previous result Vec does not get overwritten 00099 result = Vec(inputsize); 00100 nsamples.resize(inputsize); 00101 nsamples.clear(); 00102 } 00103 00104 void MeanStatsIterator::update(const Vec& input) 00105 { 00106 addIfNonMissing(input,nsamples,result); 00107 } 00108 00109 bool MeanStatsIterator::finish() 00110 { 00111 for (int i=0;i<result.length();i++) 00112 result[i] /= nsamples[i]; 00113 return true; 00114 } 00115 00116 void MeanStatsIterator::declareOptions(OptionList& ol) 00117 { 00118 declareOption(ol, "nsamples", &MeanStatsIterator::nsamples, OptionBase::learntoption, 00119 " nsamples\n"); 00120 00121 inherited::declareOptions(ol); 00122 } 00123 00124 00125 void MeanStatsIterator::oldwrite(ostream& out) const 00126 { 00127 writeHeader(out,"MeanStatsIterator"); 00128 inherited::write(out); 00129 writeField(out,"nsamples",nsamples); 00130 writeFooter(out,"MeanStatsIterator"); 00131 } 00132 00133 /* TODO Remove (deprecated) 00134 void MeanStatsIterator::oldread(istream& in) 00135 { 00136 readHeader(in,"MeanStatsIterator"); 00137 inherited::oldread(in); 00138 readField(in,"nsamples",nsamples); 00139 readFooter(in,"MeanStatsIterator"); 00140 } 00141 */ 00142 00143 // *********************** 00144 // ** ExpMeanStatsIterator ** 00145 // *********************** 00146 00147 PLEARN_IMPLEMENT_OBJECT(ExpMeanStatsIterator, "ONE LINE DESCR", "NO HELP"); 00148 00149 void ExpMeanStatsIterator::init(int inputsize) 00150 { 00151 // We do not use resize on purpose, so 00152 // that the previous result Vec does not get overwritten 00153 result = Vec(inputsize); 00154 nsamples.resize(inputsize); 00155 nsamples.clear(); 00156 } 00157 00158 void ExpMeanStatsIterator::update(const Vec& input) 00159 { 00160 addIfNonMissing(input,nsamples,result); 00161 } 00162 00163 bool ExpMeanStatsIterator::finish() 00164 { 00165 for (int i=0;i<result.length();i++) 00166 result[i] = exp(result[i]/nsamples[i]); 00167 return true; 00168 } 00169 00170 void ExpMeanStatsIterator::declareOptions(OptionList& ol) 00171 { 00172 declareOption(ol, "nsamples", &ExpMeanStatsIterator::nsamples, OptionBase::learntoption, 00173 " nsamples\n"); 00174 00175 inherited::declareOptions(ol); 00176 } 00177 00178 void ExpMeanStatsIterator::oldwrite(ostream& out) const 00179 { 00180 writeHeader(out,"ExpMeanStatsIterator"); 00181 inherited::write(out); 00182 writeField(out,"nsamples",nsamples); 00183 writeFooter(out,"ExpMeanStatsIterator"); 00184 } 00185 00186 /* TODO Remove (deprecated) 00187 void ExpMeanStatsIterator::oldread(istream& in) 00188 { 00189 readHeader(in,"ExpMeanStatsIterator"); 00190 inherited::oldread(in); 00191 readField(in,"nsamples",nsamples); 00192 readFooter(in,"ExpMeanStatsIterator"); 00193 } 00194 */ 00195 00196 // ************************* 00197 // ** StddevStatsIterator ** 00198 // ************************* 00199 00200 PLEARN_IMPLEMENT_OBJECT(StddevStatsIterator, "ONE LINE DESCR", "NO HELP"); 00201 00202 void StddevStatsIterator::makeDeepCopyFromShallowCopy(CopiesMap& copies) 00203 { 00204 inherited::makeDeepCopyFromShallowCopy(copies); 00205 deepCopyField(mean, copies); 00206 deepCopyField(meansquared, copies); 00207 } 00208 00209 void StddevStatsIterator::init(int inputsize) 00210 { 00211 // We do not use resize on purpose, so 00212 // that the previous result Vec does not get overwritten 00213 meansquared = Vec(inputsize); 00214 mean = Vec(inputsize); 00215 nsamples.resize(inputsize); 00216 nsamples.clear(); 00217 } 00218 00219 void StddevStatsIterator::update(const Vec& input) 00220 { 00221 addXandX2IfNonMissing(input,nsamples,mean,meansquared); 00222 } 00223 00224 bool StddevStatsIterator::finish() 00225 { 00226 Vec square_mean(mean.length()); 00227 for (int i=0;i<mean.length();i++) 00228 { 00229 //mean[i] /= nsamples[i]; 00230 real n = nsamples[i]; 00231 square_mean[i] = mean[i]*mean[i]/(n*(n-1.0)); 00232 meansquared[i] /= n-1.0; 00233 } 00234 //squareSubtract(meansquared, mean); 00235 meansquared -= square_mean; 00236 result = sqrt(meansquared); 00237 return true; 00238 } 00239 00240 void StddevStatsIterator::declareOptions(OptionList& ol) 00241 { 00242 declareOption(ol, "mean", &StddevStatsIterator::mean, OptionBase::learntoption, 00243 " mean\n"); 00244 00245 declareOption(ol, "meansquared", &StddevStatsIterator::meansquared, OptionBase::learntoption, 00246 " meansquared\n"); 00247 00248 declareOption(ol, "nsamples", &StddevStatsIterator::nsamples, OptionBase::learntoption, 00249 " nsamples\n"); 00250 00251 inherited::declareOptions(ol); 00252 } 00253 00254 void StddevStatsIterator::oldwrite(ostream& out) const 00255 { 00256 writeHeader(out,"StddevStatsIterator"); 00257 inherited::write(out); 00258 writeField(out,"mean",mean); 00259 writeField(out,"meansquared",meansquared); 00260 writeField(out,"nsamples",nsamples); 00261 writeFooter(out,"StddevStatsIterator"); 00262 } 00263 00264 /* TODO Remove (deprecated) 00265 void StddevStatsIterator::oldread(istream& in) 00266 { 00267 readHeader(in,"StddevStatsIterator"); 00268 inherited::oldread(in); 00269 readField(in,"mean",mean); 00270 readField(in,"meansquared",meansquared); 00271 readField(in,"nsamples",nsamples); 00272 readFooter(in,"StddevStatsIterator"); 00273 } 00274 */ 00275 00276 // ************************* 00277 // ** StderrStatsIterator ** 00278 // ************************* 00279 00280 PLEARN_IMPLEMENT_OBJECT(StderrStatsIterator, "ONE LINE DESCR", "NO HELP"); 00281 00282 void StderrStatsIterator::makeDeepCopyFromShallowCopy(CopiesMap& copies) 00283 { 00284 inherited::makeDeepCopyFromShallowCopy(copies); 00285 deepCopyField(mean, copies); 00286 deepCopyField(meansquared, copies); 00287 } 00288 00289 void StderrStatsIterator::init(int inputsize) 00290 { 00291 // We do not use resize on purpose, so 00292 // that the previous result Vec does not get overwritten 00293 meansquared = Vec(inputsize); 00294 mean = Vec(inputsize); 00295 nsamples.resize(inputsize); 00296 nsamples.clear(); 00297 } 00298 00299 void StderrStatsIterator::update(const Vec& input) 00300 { 00301 addXandX2IfNonMissing(input,nsamples,mean,meansquared); 00302 } 00303 00304 bool StderrStatsIterator::finish() 00305 { 00306 for (int i=0;i<mean.length();i++) 00307 { 00308 mean[i] /= nsamples[i]; 00309 meansquared[i] /= nsamples[i]-1; 00310 } 00311 squareSubtract(meansquared, mean); 00312 for (int i = 0; i < mean.length(); i++) { 00313 result[i] = sqrt(meansquared[i] / real(nsamples[i])); 00314 } 00315 return true; 00316 } 00317 00318 void StderrStatsIterator::declareOptions(OptionList& ol) 00319 { 00320 declareOption(ol, "mean", &StderrStatsIterator::mean, OptionBase::learntoption, 00321 " mean\n"); 00322 00323 declareOption(ol, "meansquared", &StderrStatsIterator::meansquared, OptionBase::learntoption, 00324 " meansquared\n"); 00325 00326 declareOption(ol, "nsamples", &StderrStatsIterator::nsamples, OptionBase::learntoption, 00327 " nsamples\n"); 00328 00329 inherited::declareOptions(ol); 00330 } 00331 00332 void StderrStatsIterator::oldwrite(ostream& out) const 00333 { 00334 writeHeader(out,"StderrStatsIterator"); 00335 inherited::write(out); 00336 writeField(out,"mean",mean); 00337 writeField(out,"meansquared",meansquared); 00338 writeField(out,"nsamples",nsamples); 00339 writeFooter(out,"StderrStatsIterator"); 00340 } 00341 00342 /* TODO Remove (deprecated) 00343 void StderrStatsIterator::oldread(istream& in) 00344 { 00345 readHeader(in,"StderrStatsIterator"); 00346 inherited::oldread(in); 00347 readField(in,"mean",mean); 00348 readField(in,"meansquared",meansquared); 00349 readField(in,"nsamples",nsamples); 00350 readFooter(in,"StderrStatsIterator"); 00351 } 00352 */ 00353 00354 // ************************* 00355 // ** SharpeRatioStatsIterator ** 00356 // ************************* 00357 00358 PLEARN_IMPLEMENT_OBJECT(SharpeRatioStatsIterator, "ONE LINE DESCR", "NO HELP"); 00359 00360 void SharpeRatioStatsIterator::makeDeepCopyFromShallowCopy(CopiesMap& copies) 00361 { 00362 inherited::makeDeepCopyFromShallowCopy(copies); 00363 deepCopyField(mean, copies); 00364 deepCopyField(meansquared, copies); 00365 } 00366 00367 void SharpeRatioStatsIterator::init(int inputsize) 00368 { 00369 // We do not use resize on purpose, so 00370 // that the previous result Vec does not get overwritten 00371 meansquared = Vec(inputsize); 00372 mean = Vec(inputsize); 00373 nnonzero = Vec(inputsize); 00374 } 00375 00376 void SharpeRatioStatsIterator::update(const Vec& input) 00377 { 00378 int n=input.length(); 00379 for (int i=0;i<n;i++) 00380 { 00381 real in=input[i]; 00382 if (in!=0) nnonzero[i]++; 00383 mean[i] += in; 00384 meansquared[i] += in*in; 00385 } 00386 } 00387 00388 bool SharpeRatioStatsIterator::finish() 00389 { 00390 mean /= nnonzero; 00391 meansquared /= nnonzero; 00392 squareSubtract(meansquared, mean); 00393 result = mean/sqrt(meansquared); 00394 return true; 00395 } 00396 00397 void SharpeRatioStatsIterator::declareOptions(OptionList& ol) 00398 { 00399 declareOption(ol, "mean", &SharpeRatioStatsIterator::mean, OptionBase::learntoption, 00400 " mean\n"); 00401 00402 declareOption(ol, "meansquared", &SharpeRatioStatsIterator::meansquared, OptionBase::learntoption, 00403 " meansquared\n"); 00404 00405 declareOption(ol, "nnonzero", &SharpeRatioStatsIterator::nnonzero, OptionBase::learntoption, 00406 " nnonzero\n"); 00407 00408 inherited::declareOptions(ol); 00409 } 00410 00411 void SharpeRatioStatsIterator::oldwrite(ostream& out) const 00412 { 00413 writeHeader(out,"SharpeRatioStatsIterator"); 00414 inherited::write(out); 00415 writeField(out,"mean",mean); 00416 writeField(out,"meansquared",meansquared); 00417 writeField(out,"nnonzero",nnonzero); 00418 writeFooter(out,"SharpeRatioStatsIterator"); 00419 } 00420 00421 /* TODO Remove (deprecated) 00422 void SharpeRatioStatsIterator::oldread(istream& in) 00423 { 00424 readHeader(in,"SharpeRatioStatsIterator"); 00425 inherited::oldread(in); 00426 readField(in,"mean",mean); 00427 readField(in,"meansquared",meansquared); 00428 readField(in,"nnonzero",nnonzero); 00429 readFooter(in,"SharpeRatioStatsIterator"); 00430 } 00431 */ 00432 00433 // *********************** 00434 // ** MinStatsIterator ** 00435 // *********************** 00436 00437 PLEARN_IMPLEMENT_OBJECT(MinStatsIterator, "ONE LINE DESCR", "NO HELP"); 00438 00439 void MinStatsIterator::init(int inputsize) 00440 { 00441 result = Vec(inputsize,FLT_MAX); 00442 } 00443 00444 void MinStatsIterator::update(const Vec& input) 00445 { 00446 real* inputdata = input.data(); 00447 real* resultdata = result.data(); 00448 for(int i=0; i<input.length(); i++) 00449 if(inputdata[i]<resultdata[i]) 00450 resultdata[i] = inputdata[i]; 00451 } 00452 00453 bool MinStatsIterator::finish() 00454 { return true; } 00455 00456 void MinStatsIterator::declareOptions(OptionList& ol) 00457 { 00458 inherited::declareOptions(ol); 00459 } 00460 00461 void MinStatsIterator::oldwrite(ostream& out) const 00462 { 00463 writeHeader(out,"MinStatsIterator"); 00464 inherited::write(out); 00465 writeFooter(out,"MinStatsIterator"); 00466 } 00467 00468 /* TODO Remove (deprecated) 00469 void MinStatsIterator::oldread(istream& in) 00470 { 00471 readHeader(in,"MinStatsIterator"); 00472 inherited::oldread(in); 00473 readFooter(in,"MinStatsIterator"); 00474 } 00475 */ 00476 00477 // *********************** 00478 // ** MaxStatsIterator ** 00479 // *********************** 00480 00481 PLEARN_IMPLEMENT_OBJECT(MaxStatsIterator, "ONE LINE DESCR", "NO HELP"); 00482 00483 void MaxStatsIterator::init(int inputsize) 00484 { 00485 // We do not use resize on purpose, so 00486 // that the previous result Vec does not get overwritten 00487 result = Vec(inputsize,-FLT_MAX); 00488 } 00489 00490 void MaxStatsIterator::update(const Vec& input) 00491 { 00492 real* inputdata = input.data(); 00493 real* resultdata = result.data(); 00494 for(int i=0; i<input.length(); i++) 00495 if(inputdata[i]>resultdata[i]) 00496 resultdata[i] = inputdata[i]; 00497 } 00498 00499 bool MaxStatsIterator::finish() 00500 { return true; } 00501 00502 void MaxStatsIterator::declareOptions(OptionList& ol) 00503 { 00504 inherited::declareOptions(ol); 00505 } 00506 00507 void MaxStatsIterator::oldwrite(ostream& out) const 00508 { 00509 writeHeader(out,"MaxStatsIterator"); 00510 inherited::write(out); 00511 writeFooter(out,"MaxStatsIterator"); 00512 } 00513 00514 /* TODO Remove (deprecated) 00515 void MaxStatsIterator::oldread(istream& in) 00516 { 00517 readHeader(in,"MaxStatsIterator"); 00518 inherited::oldread(in); 00519 readFooter(in,"MaxStatsIterator"); 00520 } 00521 */ 00522 00523 00524 // *********************** 00525 // ** LiftStatsIterator ** 00526 // *********************** 00527 00528 PLEARN_IMPLEMENT_OBJECT(LiftStatsIterator, "ONE LINE DESCR", "NO HELP"); 00529 void LiftStatsIterator::makeDeepCopyFromShallowCopy(CopiesMap& copies) 00530 { 00531 StatsIterator::makeDeepCopyFromShallowCopy(copies); 00532 deepCopyField(output_and_pos, copies); 00533 deepCopyField(targets, copies); 00534 } 00535 00536 LiftStatsIterator::LiftStatsIterator(int the_index, real the_fraction) 00537 : nsamples(-1), 00538 lift_index(the_index), 00539 lift_fraction(the_fraction) 00540 {} 00541 00542 void LiftStatsIterator::init(int inputsize) 00543 { 00544 // We do not use resize on purpose, so 00545 // that the previous result Vec does not get overwritten 00546 result = Vec(2); 00547 00548 const int initial_length = 1000; 00549 output_and_pos.resize(initial_length, 2); // 1 output + 1 pos 00550 targets.resize(initial_length); 00551 nsamples = 0; 00552 } 00553 00554 void LiftStatsIterator::update(const Vec& input) 00555 { 00556 if (nsamples == output_and_pos.length()) 00557 { 00558 output_and_pos.resize(10*output_and_pos.length(), 2); 00559 targets.resize(10*output_and_pos.length()); 00560 } 00561 00562 output_and_pos(nsamples, 0) = FABS(input[lift_index]); 00563 output_and_pos(nsamples, 1) = nsamples; 00564 targets[nsamples] = (input[lift_index]>0) ? 1 : 0; 00565 nsamples++; 00566 } 00567 00568 bool LiftStatsIterator::finish() 00569 { 00570 output_and_pos.resize(nsamples,2); 00571 targets.resize(nsamples); 00572 00573 const int n_first_samples = int(lift_fraction*nsamples); 00574 const int n_last_samples = nsamples - n_first_samples; 00575 selectAndOrder(output_and_pos, n_last_samples); 00576 /* 00577 Vec first_samples_index = 00578 output_and_pos.subMat(n_last_samples,1,n_first_samples,1).toVecCopy(); 00579 */ 00580 TVec<int> first_samples_index(n_first_samples); 00581 first_samples_index << output_and_pos.subMat(n_last_samples,1,n_first_samples,1); 00582 00583 Vec first_samples_targets = targets(first_samples_index); 00584 real first_samples_perf = sum(first_samples_targets)/n_first_samples; 00585 real targets_perf = sum(targets)/nsamples; 00586 real lift = first_samples_perf/targets_perf*100.0; 00587 result[0] = lift; 00588 real nones = sum(targets); 00589 real max_first_samples_perf = MIN(nones,(real)n_first_samples)/n_first_samples; 00590 real max_lift = max_first_samples_perf/targets_perf*100.0; 00591 result[1] = lift/max_lift; 00592 00593 return true; 00594 } 00595 00596 void LiftStatsIterator::declareOptions(OptionList& ol) 00597 { 00598 declareOption(ol, "nsamples", &LiftStatsIterator::nsamples, OptionBase::learntoption, 00599 " nsamples\n"); 00600 00601 declareOption(ol, "lift_index", &LiftStatsIterator::lift_index, OptionBase::buildoption, 00602 " lift_index\n"); 00603 00604 declareOption(ol, "lift_fraction", &LiftStatsIterator::lift_fraction, OptionBase::buildoption, 00605 " lift_fraction\n"); 00606 00607 declareOption(ol, "output_and_pos", &LiftStatsIterator::output_and_pos, OptionBase::learntoption, 00608 " output_and_pos\n"); 00609 00610 declareOption(ol, "targets", &LiftStatsIterator::targets, OptionBase::learntoption, 00611 " targets\n"); 00612 00613 inherited::declareOptions(ol); 00614 } 00615 00616 void LiftStatsIterator::oldwrite(ostream& out) const 00617 { 00618 writeHeader(out,"LiftStatsIterator"); 00619 inherited::write(out); 00620 writeField(out,"nsamples",nsamples); 00621 writeField(out,"lift_index",lift_index); 00622 writeField(out,"lift_fraction",lift_fraction); 00623 writeField(out,"output_and_pos",output_and_pos); 00624 writeField(out,"targets",targets); 00625 writeFooter(out,"LiftStatsIterator"); 00626 } 00627 00628 /* TODO Remove (deprecated) 00629 void LiftStatsIterator::oldread(istream& in) 00630 { 00631 readHeader(in,"LiftStatsIterator"); 00632 inherited::oldread(in); 00633 readField(in,"nsamples",nsamples); 00634 readField(in,"lift_index",lift_index); 00635 readField(in,"lift_fraction",lift_fraction); 00636 readField(in,"output_and_pos",output_and_pos); 00637 readField(in,"targets",targets); 00638 readFooter(in,"LiftStatsIterator"); 00639 } 00640 */ 00641 00642 // **************************** 00643 // ** QuantilesStatsIterator ** 00644 // **************************** 00645 00646 PLEARN_IMPLEMENT_OBJECT(QuantilesStatsIterator, "ONE LINE DESCR", "NO HELP"); 00647 00648 void QuantilesStatsIterator::makeDeepCopyFromShallowCopy(CopiesMap& copies) 00649 { 00650 StatsIterator::makeDeepCopyFromShallowCopy(copies); 00651 deepCopyField(quantiles, copies); 00652 deepCopyField(data, copies); 00653 } 00654 00655 QuantilesStatsIterator::QuantilesStatsIterator(Vec quantiles_,int n_data) 00656 : nsamples(n_data), quantiles(quantiles_) 00657 { 00658 } 00659 00660 void QuantilesStatsIterator::init(int inputsize) 00661 { 00662 data.resize(inputsize); 00663 for (int i=0;i<inputsize;i++) 00664 { 00665 data[i].resize(nsamples); 00666 data[i].resize(0); 00667 } 00668 nsamples=0; 00669 // We do not use resize on purpose, so 00670 // that the previous result Vec does not get overwritten 00671 result = Vec(quantiles.length()*data.length()); 00672 } 00673 00674 void QuantilesStatsIterator::update(const Vec& input) 00675 { 00676 if (nsamples == data[0].length()) 00677 { 00678 for (int i=0;i<data.length();i++) 00679 { 00680 data[i].resize(10*(nsamples+1)); 00681 data[i].resize(nsamples); 00682 } 00683 } 00684 00685 for (int i=0;i<input.length();i++) 00686 data[i].push_back(input[i]); 00687 nsamples++; 00688 } 00689 00690 bool QuantilesStatsIterator::finish() 00691 { 00692 for (int i=0;i<data.length();i++) 00693 sortElements(data[i]); 00694 real dq =real(1.0)/nsamples; 00695 real hdq = dq*real(0.5); 00696 Mat results = result.toMat(data.length(),quantiles.length()); 00697 results.fill(MISSING_VALUE); 00698 for (int i=0;i<data.length();i++) // loop over "variables" 00699 { 00700 real q=0; 00701 for (int t=0;t<nsamples;t++,q+=dq) 00702 { 00703 for (int j=0;j<quantiles.length();j++) 00704 if (quantiles[j]>q-hdq && quantiles[j]<=q+hdq) 00705 results(i,j) = data[i][t]; 00706 } 00707 } 00708 return true; 00709 } 00710 00711 void QuantilesStatsIterator::declareOptions(OptionList& ol) 00712 { 00713 declareOption(ol, "nsamples", &QuantilesStatsIterator::nsamples, OptionBase::buildoption, 00714 " nsamples\n"); 00715 00716 declareOption(ol, "quantiles", &QuantilesStatsIterator::quantiles, OptionBase::buildoption, 00717 " quantiles\n"); 00718 00719 inherited::declareOptions(ol); 00720 } 00721 00722 void QuantilesStatsIterator::oldwrite(ostream& out) const 00723 { 00724 writeHeader(out,"QuantilesStatsIterator"); 00725 inherited::write(out); 00726 writeField(out,"nsamples",nsamples); 00727 writeField(out,"quantiles",quantiles); 00728 writeFooter(out,"QuantilesStatsIterator"); 00729 } 00730 00731 /* TODO Remove (deprecated) 00732 void QuantilesStatsIterator::oldread(istream& in) 00733 { 00734 readHeader(in,"QuantilesStatsIterator"); 00735 inherited::oldread(in); 00736 readField(in,"nsamples",nsamples); 00737 readField(in,"quantiles",quantiles); 00738 readFooter(in,"QuantilesStatsIterator"); 00739 } 00740 */ 00741 00742 // ****************** 00743 // ** StatsItArray ** 00744 // ****************** 00745 00746 StatsItArray::StatsItArray() 00747 : Array<StatsIt>(0,5) 00748 {} 00749 00750 StatsItArray::StatsItArray(const StatsIt& statsit) 00751 : Array<StatsIt>(1,5) 00752 { (*this)[0] = statsit; } 00753 00754 StatsItArray::StatsItArray(const StatsIt& statsit1, const StatsIt& statsit2) 00755 : Array<StatsIt>(2,5) 00756 { 00757 (*this)[0] = statsit1; 00758 (*this)[1] = statsit2; 00759 } 00760 00761 void StatsItArray::init(int inputsize) 00762 { 00763 for(int k=0; k<size(); k++) 00764 (*this)[k]->init(inputsize); 00765 } 00766 00767 void StatsItArray::update(const Vec& input) 00768 { 00769 for(int k=0; k<size(); k++) 00770 (*this)[k]->update(input); 00771 } 00772 void StatsItArray::update(const Mat& inputs) 00773 { 00774 for (int i=0;i<inputs.length();i++) 00775 { 00776 Vec input = inputs(i); 00777 update(input); 00778 } 00779 } 00780 00781 bool StatsItArray::requiresMultiplePasses() 00782 { 00783 for(int k=0; k<size(); k++) 00784 if ( (*this)[k]->requiresMultiplePasses() ) 00785 return true; 00786 return false; 00787 } 00788 00789 // returns an array of those that are not yet finished 00790 StatsItArray StatsItArray::finish() 00791 { 00792 StatsItArray unfinished; 00793 for(int k=0; k<size(); k++) 00794 if ( ! (*this)[k]->finish() ) 00795 unfinished.append((*this)[k]); 00796 return unfinished; 00797 } 00798 00799 Array<Vec> StatsItArray::getResults() 00800 { 00801 Array<Vec> results(size()); 00802 for(int k=0; k<size(); k++) 00803 results[k] = (*this)[k]->getResult(); 00804 return results; 00805 } 00806 00807 Array<Vec> StatsItArray::computeStats(VMat data) 00808 { 00809 int inputsize = data.width(); 00810 init(inputsize); 00811 00812 Vec input(inputsize); 00813 StatsItArray unfinished = *this; 00814 00815 while(unfinished.size()>0) 00816 { 00817 for(int i=0; i<data.length(); i++) 00818 { 00819 data->getRow(i,input); 00820 unfinished.update(input); 00821 } 00822 unfinished = finish(); 00823 } 00824 00825 return getResults(); 00826 } 00827 00828 } // end of namespace PLearn 00829 00830 00831 /* 00832 Local Variables: 00833 mode:c++ 00834 c-basic-offset:4 00835 c-file-style:"stroustrup" 00836 c-file-offsets:((innamespace . 0)(inline-open . 0)) 00837 indent-tabs-mode:nil 00838 fill-column:79 00839 End: 00840 */ 00841 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=79 :