[Boost-commit] svn:boost r56586 - in sandbox/statistics/kernel/libs/statistics/kernel: example src

Subject: [Boost-commit] svn:boost r56586 - in sandbox/statistics/kernel/libs/statistics/kernel: example src
From: erwann.rogard_at_[hidden]
Date: 2009-10-04 18:55:00

Author: e_r
Date: 2009-10-04 18:54:59 EDT (Sun, 04 Oct 2009)
New Revision: 56586
URL: http://svn.boost.org/trac/boost/changeset/56586

Log:
m
Text files modified: 
   sandbox/statistics/kernel/libs/statistics/kernel/example/benchmark_scalar.cpp |    15 +--                                     
   sandbox/statistics/kernel/libs/statistics/kernel/example/kernel_mono_rp.cpp   |    53 +++++++------                           
   sandbox/statistics/kernel/libs/statistics/kernel/example/scalar_nw.cpp        |   158 +++++++++++++++++++++++---------------- 
   sandbox/statistics/kernel/libs/statistics/kernel/example/scalar_rp.cpp        |    32 ++++----                                
   sandbox/statistics/kernel/libs/statistics/kernel/src/main.cpp                 |     9 +-                                      
   5 files changed, 150 insertions(+), 117 deletions(-)

Modified: sandbox/statistics/kernel/libs/statistics/kernel/example/benchmark_scalar.cpp
==============================================================================
--- sandbox/statistics/kernel/libs/statistics/kernel/example/benchmark_scalar.cpp	(original)
+++ sandbox/statistics/kernel/libs/statistics/kernel/example/benchmark_scalar.cpp	2009-10-04 18:54:59 EDT (Sun, 04 Oct 2009)
@@ -5,6 +5,8 @@
 //  Software License, Version 1.0. (See accompanying file                    //
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)         //
 /////////////////////////////////////////////////////////////////////////////// 
+/*
+
 #include <cmath>
 #include <vector>
 #include <algorithm>
@@ -19,14 +21,9 @@
 #include <boost/math/tools/precision.hpp>
 
 // Order of the files matters!
-#include <boost/standard_distribution/distributions/normal.hpp>
-#include <boost/scalar_dist/fun_wrap/pdf.hpp>
-#include <boost/dist_random/distributions/normal.hpp>
-#include <boost/dist_random/random/generate_n.hpp>
-
-//#include <boost/scalar_dist/fun_wrap/pdf.hpp>
-//#include <boost/scalar_dist/meta/delegate.hpp>
-//#include <boost/scalar_dist/algorithm/transform.hpp>
+#include <boost/statistics/detail/distribution_toolkit/distributions/normal.hpp>
+#include <boost/statistics/detail/distribution_toolkit/fwd_math/cdf.hpp> // ?!
+
 
 #include <boost/binary_op/data/tuple_range.hpp>
 
@@ -268,7 +265,9 @@
     // DO the same for rp
     
     out << "<-" << std::endl;
+
 }
+*/
 
 
 

Modified: sandbox/statistics/kernel/libs/statistics/kernel/example/kernel_mono_rp.cpp
==============================================================================
--- sandbox/statistics/kernel/libs/statistics/kernel/example/kernel_mono_rp.cpp	(original)
+++ sandbox/statistics/kernel/libs/statistics/kernel/example/kernel_mono_rp.cpp	2009-10-04 18:54:59 EDT (Sun, 04 Oct 2009)
@@ -21,32 +21,40 @@
 #include <boost/statistics/kernel/functional/rp_visitor.hpp>
 #include <boost/statistics/kernel/functional/estimator.hpp>
 #include <libs/statistics/kernel/example/scalar_rp.h>
-
 void example_kernel_mono_rp(std::ostream& out){
     out << "-> example_kernel_mono_rp : ";
+
+
+    // This example shows how to compute a Rosenblatt-Parzen estimate of the 
+    // density, p(x). The type used for each data-unit, x, is a vector of 
+    // doubles, and the kernel uses the same bandwidth throughout all 
+    // coordinates
+
     using namespace boost;
+    namespace kernel = boost::statistics::kernel;
     
     // Types
     typedef double                                          val_;
     typedef std::vector<val_>                               vec_;
-    typedef std::vector<vec_>                               mat_;
+    typedef vec_                                            x_;
+    typedef std::vector<x_>                                 dataset_;
     typedef mt19937                                         urng_;
     typedef normal_distribution<val_>                       norm_;
     typedef variate_generator<urng_&,norm_>                 gen_;
-    typedef statistics::kernel::scalar::gaussian<val_>                  gauss_k_;
+    typedef kernel::scalar::gaussian<val_>                  gauss_k_;
 
     const unsigned dim = 2;
-    typedef statistics::kernel::joint::kernel_mono<gauss_k_,dim>               kernel_mono_k_;
-    // NB const vec_&, not vec_
-    typedef statistics::kernel::rp_visitor<kernel_mono_k_,const vec_&>  rp_visitor_;
+    typedef kernel::joint::kernel_mono<gauss_k_,dim> kernel_mono_k_;
+    // Use of a const reference is not necessary but probably improves speed
+    typedef kernel::rp_visitor<kernel_mono_k_,const x_&>  rp_visitor_;
     
     // Constants
     const val_ bandwidth = 0.5;
     const val_ eps = math::tools::epsilon<val_>();
     const unsigned n = 10;
     
-    // Generate sample
-    mat_ vec_x; vec_x.reserve(n);
+    // Generate n samples, each drawn from prod{N(0,1):i=1,...,dim}
+    dataset_ dataset; dataset.reserve(n);
     vec_ vec_rp; vec_rp.reserve(n);
     urng_ urng;
     norm_ norm;
@@ -54,41 +62,38 @@
     for(unsigned i = 0; i<n; i++){
         vec_ tmp(dim);
         std::generate_n(
-            begin(tmp),
+            boost::begin(tmp),
             dim,
             gen
         );
-        vec_x.push_back( tmp );
+        dataset.push_back( tmp );
     }
 
-    kernel_mono_k_ kernel_mono_k(bandwidth);
-    
-    kernel_mono_k(vec_x[0],vec_x[1]);
-    // Density estimate for each x in vec_x using vec_x as the sample
-    BOOST_FOREACH(const vec_& x,vec_x){
+    // Density estimate for each x in dataset
+    BOOST_FOREACH(const x_& x,dataset){
         val_ rp = std::for_each(
-            begin(vec_x),
-            end(vec_x),
+            boost::begin(dataset),
+            boost::end(dataset),
             rp_visitor_(bandwidth,x)
         ).estimate();
         vec_rp.push_back(rp);
     } 
-    typedef sub_range<mat_> sub_;
-    typedef statistics::kernel::estimator<
+    typedef sub_range<dataset_> sub_;
+    typedef kernel::estimator<
         sub_,
-        statistics::kernel::rp_visitor,
+        kernel::rp_visitor,
         kernel_mono_k_
     > estimator_;
     estimator_ estimator(bandwidth); 
-    statistics::train(estimator,sub_(vec_x));
+    estimator.train(sub_(dataset));
     vec_ vec_rp2; vec_rp2.reserve(n);
 
     // Same as previous but calls estimator instead of for_each
     for(unsigned i = 0; i<n; i++){
-        vec_ x = vec_x[i];
+        x_ x = dataset[i];
         val_ rp = vec_rp[i];
-        val_ rp2 = estimator(x).estimate();
+        val_ rp2 = estimator.predict(x);
         BOOST_ASSERT(fabs(rp-rp2)<eps);
     } 
     out << "<-" << std::endl;
-}
\ No newline at end of file
+}

Modified: sandbox/statistics/kernel/libs/statistics/kernel/example/scalar_nw.cpp
==============================================================================
--- sandbox/statistics/kernel/libs/statistics/kernel/example/scalar_nw.cpp	(original)
+++ sandbox/statistics/kernel/libs/statistics/kernel/example/scalar_nw.cpp	2009-10-04 18:54:59 EDT (Sun, 04 Oct 2009)
@@ -17,28 +17,59 @@
 #include <boost/math/tools/precision.hpp>
 #include <boost/typeof/typeof.hpp>
 
-#include <boost/binary_op/data/tuple_range.hpp>
-//#include <boost/statistics/estimator_concept/trainable_estimator/concept.hpp>
+#include <boost/fusion/sequence/intrinsic/at_key.hpp>
+#include <boost/fusion/include/at_key.hpp>
+#include <boost/fusion/container/map.hpp>
+#include <boost/fusion/include/map.hpp>
+#include <boost/fusion/include/map_fwd.hpp>
+
+
+#include <boost/statistics/detail/fusion/functor/at_key.hpp>
+
 #include <boost/statistics/kernel/scalar/gaussian.hpp>
-#include <boost/statistics/kernel/functional/nw_visitor_tuple.hpp>
+#include <boost/statistics/kernel/functional/meta_nw_visitor_unary.hpp>
 #include <boost/statistics/kernel/functional/estimator.hpp>
 #include <libs/statistics/kernel/example/scalar_nw.h>
 
 void example_scalar_nw(std::ostream& out){
+
     out << "-> example_scalar_nw : ";
     using namespace boost;
 
+    namespace kernel = boost::statistics::kernel;
+
+    // This example shows how to compute a Nadaraya-Watson estimate of E[y|x]. 
+    // The type used for each data-unit, here, is a fusion map whose x and y
+    // components are accessed using keys
+    
     // Types
     typedef double                                          val_;
-    typedef std::vector<val_>                               vec_;
+    typedef std::vector<val_>                               vals_;
+    typedef mpl::int_<0>                                    key_x_;
+    typedef mpl::int_<1>                                    key_y_;
+    typedef fusion::pair<key_x_,val_>                       x_;
+    typedef fusion::pair<key_y_,val_>                       y_;
+    typedef statistics::detail::fusion::functor::at_key<key_x_> at_key_x_;
+    typedef statistics::detail::fusion::functor::at_key<key_y_> at_key_y_;
+    typedef fusion::map<x_,y_>                              data_unit_;
+    typedef std::vector<data_unit_>                          dataset_;
+    // The rationale for data_range_ is it's cheap to copy
+    typedef sub_range<dataset_>                             data_range_;
+        
     typedef mt19937                                         urng_;
     typedef normal_distribution<val_>                       norm_;
     typedef variate_generator<urng_&,norm_>                 gen_;
-    typedef statistics::kernel::scalar::gaussian<val_>      gauss_k_;
-    typedef statistics::kernel::nw_visitor_tuple<gauss_k_,val_> 
-                                                            nw_visitor_tuple_;
-    typedef nw_visitor_tuple_::nw_visitor_type              nw_visitor_;
-    typedef nw_visitor_tuple_::rp_visitor_type              rp_visitor_;
+    typedef kernel::scalar::gaussian<val_>                  gauss_k_;
+    typedef kernel::meta_nw_visitor_unary<
+        at_key_x_,
+        at_key_y_
+    > meta_nw_visitor_u_;
+    typedef meta_nw_visitor_u_::apply<
+        gauss_k_,
+        val_
+    >::type  nw_visitor_u_;
+    typedef nw_visitor_u_::nw_visitor_type              nw_visitor_;
+    typedef nw_visitor_u_::rp_visitor_type              rp_visitor_;
     
     // Constants
     const val_ bandwidth = 0.5;
@@ -46,73 +77,70 @@
     const unsigned n = 10;
     
     // Initialization
-    vec_ vec_x(n);
-    vec_ vec_y(n,static_cast<val_>(1)); 
-    vec_ vec_rp; vec_rp.reserve(n);
-    vec_ vec_nw; vec_nw.reserve(n);
-    urng_ urng;
-    norm_ norm;
-    gen_ gen(urng,norm);
-    std::generate_n(
-        begin(vec_x),
-        n,
-        gen
-    );
-
-    // Computes a conditional mean estimate (nw) for each x in vec_x using 
-    // a sequence of (x,y) tuples constructed from (vec_x,vec_y) as training
-    // sample. The density (rp) is computed as a by-product. 
-    // Here, y = 1, so we should have rp = nw (un-normalized).
-    BOOST_FOREACH(val_& x,vec_x){
-        typedef binary_op::tuple_range<const vec_&,const vec_&> factory_;
-        typedef factory_::type range_tuple_;
-        range_tuple_ range_tuple = factory_::make(vec_x,vec_y);
+    vals_ vec_rp; vec_rp.reserve(n);
+    vals_ vec_nw; vec_nw.reserve(n);
+    dataset_ dataset;
+    dataset.reserve(n);
+    {
+        urng_ urng;
+        norm_ norm;
+        gen_ gen(urng,norm);
+        val_ one = static_cast<val_>(1);
+        for(unsigned i = 0; i<n; i++){
+            dataset.push_back(
+                data_unit_(
+                    fusion::make_pair<key_x_>(gen()),
+                    fusion::make_pair<key_y_>(one)
+                )
+            );
+        }
+    }
+
+    // Computes nw = E[y|x] for each x in the dataset. The density (rp) is 
+    // obtained as a by-product. Here, y = 1, so we should have 
+    // rp = nw (un-normalized).
+    BOOST_FOREACH(data_unit_& u,dataset){
         nw_visitor_ nw_visitor = std::for_each(
-            begin(range_tuple),
-            end(range_tuple),
-            nw_visitor_tuple_(bandwidth,x)
-        ).nw_visitor();
+            boost::begin(dataset),
+            boost::end(dataset),
+            nw_visitor_u_(
+                bandwidth,
+                fusion::at_key<key_x_>(u)
+            )
+        );
         val_ u_nw = nw_visitor.unnormalized_estimate();
         vec_nw.push_back(u_nw);
         rp_visitor_ rp_visitor = nw_visitor.rp_visitor();
         val_ rp = rp_visitor.estimate();
         BOOST_ASSERT(fabs(rp-u_nw)<eps);
-    } 
-
-    typedef binary_op::tuple_range<const vec_&,const vec_&> factory_;
-    typedef factory_::type range_xy_;
-    range_xy_ range_xy = factory_::make(vec_x,vec_y);
-    // A pair of iterators is cheap to copy so no need to pass it by reference
-    typedef statistics::kernel::estimator<
-        range_xy_,
-        statistics::kernel::nw_visitor_tuple,
+    }
+    
+    // Same as above using estimator
+    
+    typedef kernel::estimator<
+        data_range_,
+        meta_nw_visitor_u_::apply,
         gauss_k_
     > estimator_;
     estimator_ estimator(bandwidth);
-    statistics::train(estimator,range_xy);
-        
-    // Same as previous but calls estimator instead of for_each
-    BOOST_FOREACH(val_& x,vec_x){
-        // A local definition of nw_visitor_ is needed because x is passed
-        // by ref, not by value as in that outside the scope
-        typedef estimator_::result<val_>::type result_type;
-        typedef result_type::nw_visitor_type nw_visitor_;
-        typedef result_type::rp_visitor_type rp_visitor_;
-        nw_visitor_ nw_visitor = estimator(x).nw_visitor();
-        val_ u_nw = nw_visitor.unnormalized_estimate();
-        rp_visitor_ rp_visitor = nw_visitor.rp_visitor();
-        val_ rp = rp_visitor.estimate();
-        BOOST_ASSERT(fabs(rp-u_nw)<eps);
-    } 
+    estimator.train(
+        data_range_(dataset)
+    ); // * step 1 *
+
     
-    // Shorter version of the above
-    BOOST_FOREACH(val_& x,vec_x){
-        BOOST_AUTO( nw_visitor , estimator(x).nw_visitor() );
-        val_ u_nw = nw_visitor.unnormalized_estimate();
-        BOOST_AUTO( rp_visitor , nw_visitor.rp_visitor() );
-        val_ rp = rp_visitor.estimate();
+    BOOST_FOREACH(data_unit_& u,dataset){
+        // -> these steps are independent of step2, they're just a test
+        val_ x = fusion::at_key<key_x_>(u);
+        BOOST_AUTO( nw_v , estimator.visit(x) );
+        val_ u_nw = nw_v.unnormalized_estimate();
+        BOOST_AUTO( rp_v , nw_v.rp_visitor() );
+        val_ rp = rp_v.estimate();
         BOOST_ASSERT(fabs(rp-u_nw)<eps);
+        // <-
+        
+        estimator.predict(x); // * step 2 *
+    
     } 
     
     out << "<-" << std::endl;
-}
\ No newline at end of file
+}

Modified: sandbox/statistics/kernel/libs/statistics/kernel/example/scalar_rp.cpp
==============================================================================
--- sandbox/statistics/kernel/libs/statistics/kernel/example/scalar_rp.cpp	(original)
+++ sandbox/statistics/kernel/libs/statistics/kernel/example/scalar_rp.cpp	2009-10-04 18:54:59 EDT (Sun, 04 Oct 2009)
@@ -15,6 +15,7 @@
 #include <boost/random/variate_generator.hpp>
 #include <boost/math/special_functions/fpclassify.hpp> //needed?
 #include <boost/math/tools/precision.hpp>
+#include <boost/mpl/int.hpp>
 
 #include <boost/statistics/kernel/scalar/gaussian.hpp>
 #include <boost/statistics/kernel/functional/rp_visitor.hpp>
@@ -25,6 +26,9 @@
     out << "-> example_scalar_rp : ";
     using namespace boost;
 
+    // This example shows how to compute a Rosenblatt-Parzen estimate of the 
+    // density, p(x). The type used for each data-unit, here, is double
+
     //Types
     typedef double                                          val_;
     typedef std::vector<val_>                               vec_;
@@ -40,33 +44,28 @@
     const unsigned n = 10;
 
     // Initialization
-    vec_ vec_x(n);
+    vec_ dataset(n);
     vec_ vec_rp; vec_rp.reserve(n);
     urng_ urng;
     norm_ norm;
     gen_ gen(urng,norm);
     std::generate_n(
-        begin(vec_x),
+        begin(dataset),
         n,
         gen
     );
 
-    // Computes a density estimate for each x in vec_x using vec_x as sample
-    BOOST_FOREACH(val_& x,vec_x){
+    // Computes a density estimate for each x in dataset
+    BOOST_FOREACH(val_& x,dataset){
         val_ rp = for_each(
-            begin(vec_x),
-            end(vec_x),
+            boost::begin(dataset),
+            boost::end(dataset),
             rp_visitor_(bandwidth,x)
         ).estimate();
         vec_rp.push_back(rp);
     } 
 
-    std::copy(
-        begin(vec_rp),
-        end(vec_rp),
-        std::ostream_iterator<val_>(out," ")
-    );
-    
+    // Same as previous but calls estimator instead of for_each
     typedef sub_range<vec_> sub_x_;
     typedef 
         statistics::kernel::estimator<
@@ -75,16 +74,17 @@
             gauss_k_
         > estimator_;
     estimator_ estimator(bandwidth); 
-    statistics::train(estimator,sub_x_(vec_x));
+    sub_x_ sub_x(dataset);
+    estimator.train(sub_x);
     vec_ vec_rp2; vec_rp2.reserve(n);
     
-    // Same as previous but calls estimator instead of for_each
     for(unsigned i = 0; i<n; i++){
-        val_ x = vec_x[i];
+        val_ x = dataset[i];
         val_ rp = vec_rp[i];
-        val_ rp2 = estimator(x).estimate();
+        val_ rp2 = estimator.predict(x);
         BOOST_ASSERT(fabs(rp-rp2)<eps);
     } 
             
     out << "<-" << std::endl;
+
 }
\ No newline at end of file

Modified: sandbox/statistics/kernel/libs/statistics/kernel/src/main.cpp
==============================================================================
--- sandbox/statistics/kernel/libs/statistics/kernel/src/main.cpp	(original)
+++ sandbox/statistics/kernel/libs/statistics/kernel/src/main.cpp	2009-10-04 18:54:59 EDT (Sun, 04 Oct 2009)
@@ -11,12 +11,13 @@
 #include <libs/statistics/kernel/example/kernel_mono_rp.h>
 #include <libs/statistics/kernel/example/benchmark_scalar.h>
 
+
 int main(){
 
-    // example_scalar_rp(std::cout);
-    // example_scalar_nw(std::cout);
-    // example_kernel_mono_rp(std::cout);
-    example_benchmark_scalar(std::cout);
+    example_scalar_rp(std::cout);
+    example_scalar_nw(std::cout);
+    example_kernel_mono_rp(std::cout);
+    //example_benchmark_scalar(std::cout);
     
     return 0;
 }
\ No newline at end of file