isotree 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6121fa6837526e05ea0124e69c189dea6e0c94a303a003ed8f5db5e8469e54b3
-  data.tar.gz: eb4a955ffa47876af4ece7ce7006635af4b43e29475055cf0046d61cbb54d443
+  metadata.gz: a5974c65c4adc4fd79ee7770f324c906a2788534f3fe6f381d61711e7cdce78c
+  data.tar.gz: d401e7c5aaabcd5dcffd5e4f54d93ea4d0966698854e70d3475fd79a92e1e241
 SHA512:
-  metadata.gz: 22eb873ac7cff7cd5a1e0e7c04e6c47e895c06d8e0e52cd5ee2c4ab31b652203737186fe2dfd84298ea9cdf5327bed0c4d22e67ec9fb787179eae978f922b127
-  data.tar.gz: bcc62a52fa71bf6e3175108a473e834b8a730ea0a94dd8adc017057a23a9bf56d451c3b955b3aafacd2cd9e6f4c237c31ce4f7a3eefd4d11aaed25183def3b92
+  metadata.gz: d00de0c3902b4f7fd3e13e08f0738ec4daf8be173f60cf46f49318e76f5be3c4ef3edd925f83074e03b4fe181aa6384d43c749f5f72247cf08d44f6811a6fe80
+  data.tar.gz: 70195ae442c2e4762b2f900a82a891d8f991ace1e521d625f910a1b5e3482334a299674c255e1aebf855728ee169ab5886428baf6df9a5e436bc73f3aff6dda6

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.1.5 (2021-03-14)
+
+- Updated Isotree to 0.1.25
+- Added support for exporting and importing models
+
 ## 0.1.4 (2020-08-22)
 
 - Added `missing_action`, `new_categ_action`, `categ_split_type`, `coefs`, `depth_imp`, and `weigh_imp_rows` options

data/LICENSE.txt

@@ -1,7 +1,7 @@
 BSD 2-Clause License
 
-Copyright (c) 2019, David Cortes
-Copyright (c) 2020, Andrew Kane
+Copyright (c) 2020, David Cortes
+Copyright (c) 2020-2021, Andrew Kane
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/README.md

@@ -6,7 +6,7 @@ Learn how [Isolation Forest](https://www.youtube.com/watch?v=RyFQXQf4w4w) works
 
 :deciduous_tree: Check out [OutlierTree](https://github.com/ankane/outliertree) for human-readable explanations of outliers
 
-[![Build Status](https://travis-ci.org/ankane/isotree.svg?branch=master)](https://travis-ci.org/ankane/isotree)
+[![Build Status](https://github.com/ankane/isotree/workflows/build/badge.svg?branch=master)](https://github.com/ankane/isotree/actions)
 
 ## Installation
 
@@ -43,6 +43,18 @@ model.predict(data)
 
 Scores are between 0 and 1, with higher scores indicating outliers
 
+Export the model
+
+```ruby
+model.export_model("model.bin")
+```
+
+Import a model
+
+```ruby
+model = IsoTree::IsolationForest.import_model("model.bin")
+```
+
 ## Parameters
 
 Pass parameters - default values below
@@ -116,6 +128,15 @@ gem uninstall isotree --force
 bundle install
 ```
 
+## Deployment
+
+Check out [Trove](https://github.com/ankane/trove) for deploying models.
+
+```sh
+trove push model.bin
+trove push model.bin.metadata
+```
+
 ## Reference
 
 Get the average isolation depth

data/ext/isotree/ext.cpp

@@ -151,6 +151,7 @@ void Init_ext()
         double* col_weights = NULL;
         Imputer *imputer = NULL;
         bool impute_at_fit = false;
+        bool handle_interrupt = false;
 
         fit_iforest(
           NULL,
@@ -197,6 +198,7 @@ void Init_ext()
           weigh_imp_rows,
           impute_at_fit,
           random_seed,
+          handle_interrupt,
           nthreads
         );
 
@@ -257,5 +259,29 @@ void Init_ext()
           ret.push(outlier_scores[i]);
         }
         return ret;
+      })
+    .define_singleton_method(
+      "serialize_ext_isoforest",
+      *[](ExtIsoForest& iso, String path) {
+        #ifdef _MSC_VER
+        // TODO convert to wchar_t
+        throw std::runtime_error("Not supported on Windows yet");
+        #else
+        serialize_ext_isoforest(iso, path.c_str());
+        #endif
+      })
+    .define_singleton_method(
+      "deserialize_ext_isoforest",
+      *[](String path) {
+        ExtIsoForest iso;
+
+        #ifdef _MSC_VER
+        // TODO convert to wchar_t
+        throw std::runtime_error("Not supported on Windows yet");
+        #else
+        deserialize_ext_isoforest(iso, path.c_str());
+        #endif
+
+        return iso;
       });
 }

data/ext/isotree/extconf.rb

@@ -1,7 +1,6 @@
 require "mkmf-rice"
 
-# TODO add -D_ENABLE_CEREAL
-$CXXFLAGS += " -std=c++11 -D_USE_MERSENNE_TWISTER"
+$CXXFLAGS += " -std=c++11 -D_USE_MERSENNE_TWISTER -D_ENABLE_CEREAL"
 
 apple_clang = RbConfig::CONFIG["CC_VERSION_MESSAGE"] =~ /apple clang/i
 
@@ -13,10 +12,11 @@ end
 
 ext = File.expand_path(".", __dir__)
 isotree = File.expand_path("../../vendor/isotree/src", __dir__)
+cereal = File.expand_path("../../vendor/cereal/include", __dir__)
 
 exclude = %w(Rwrapper.cpp RcppExports.cpp)
 $srcs = Dir["{#{ext},#{isotree}}/*.{cc,cpp}"].reject { |f| exclude.include?(File.basename(f)) }
-$INCFLAGS << " -I#{isotree}"
+$INCFLAGS << " -I#{isotree} -I#{cereal}"
 $VPATH << isotree
 
 create_makefile("isotree/ext")

data/lib/isotree.rb

@@ -3,6 +3,7 @@ require "isotree/ext"
 
 # stdlib
 require "etc"
+require "json"
 
 # modules
 require "isotree/dataset"

data/lib/isotree/isolation_forest.rb

@@ -48,7 +48,7 @@ module IsoTree
     end
 
     def predict(x, output: "score")
-      raise "Not fit" unless @ext_iso_forest
+      check_fit
 
       x = Dataset.new(x)
       prep_predict(x)
@@ -66,8 +66,83 @@ module IsoTree
       Ext.predict_iforest(@ext_iso_forest, options)
     end
 
+    # same format as Python so models are compatible
+    def export_model(path)
+      check_fit
+
+      File.write("#{path}.metadata", JSON.pretty_generate(export_metadata))
+      Ext.serialize_ext_isoforest(@ext_iso_forest, path)
+    end
+
+    def self.import_model(path)
+      model = new
+      metadata = JSON.parse(File.read("#{path}.metadata"))
+      model.send(:import_metadata, metadata)
+      model.instance_variable_set(:@ext_iso_forest, Ext.deserialize_ext_isoforest(path))
+      model
+    end
+
     private
 
+    def export_metadata
+      data_info = {
+        ncols_numeric: @numeric_columns.size,
+        ncols_categ: @categorical_columns.size,
+        cols_numeric: @numeric_columns,
+        cols_categ: @categorical_columns,
+        cat_levels: @categorical_columns.map { |v| @categories[v].keys }
+      }
+
+      # Ruby-specific
+      data_info[:sym_numeric] = @numeric_columns.map { |v| v.is_a?(Symbol) }
+      data_info[:sym_categ] = @categorical_columns.map { |v| v.is_a?(Symbol) }
+
+      model_info = {
+        ndim: @ndim,
+        nthreads: @nthreads,
+        build_imputer: false
+      }
+
+      params = {}
+      PARAM_KEYS.each do |k|
+        params[k] = instance_variable_get("@#{k}")
+      end
+
+      {
+        data_info: data_info,
+        model_info: model_info,
+        params: params
+      }
+    end
+
+    def import_metadata(metadata)
+      data_info = metadata["data_info"]
+      model_info = metadata["model_info"]
+      params = metadata["params"]
+
+      # Ruby-specific
+      sym_numeric = data_info["sym_numeric"].to_a
+      sym_categ = data_info["sym_categ"].to_a
+
+      @numeric_columns = data_info["cols_numeric"].map.with_index { |v, i| sym_numeric[i] ? v.to_sym : v }
+      @categorical_columns = data_info["cols_categ"].map.with_index { |v, i| sym_categ[i] ? v.to_sym : v }
+      @categories = {}
+      @categorical_columns.zip(data_info["cat_levels"]) do |col, levels|
+        @categories[col] = levels.map.with_index.to_h
+      end
+
+      @ndim = model_info["ndim"]
+      @nthreads = model_info["nthreads"]
+
+      PARAM_KEYS.each do |k|
+        instance_variable_set("@#{k}", params[k.to_s])
+      end
+    end
+
+    def check_fit
+      raise "Not fit" unless @ext_iso_forest
+    end
+
     def prep_fit(df)
       @numeric_columns = df.numeric_columns
       @categorical_columns = df.categorical_columns
@@ -141,6 +216,16 @@ module IsoTree
       options
     end
 
+    PARAM_KEYS = %i(
+      sample_size ntrees ntry max_depth
+      prob_pick_avg_gain prob_pick_pooled_gain
+      prob_split_avg_gain prob_split_pooled_gain min_gain
+      missing_action new_categ_action categ_split_type coefs depth_imp
+      weigh_imp_rows min_imp_obs random_seed all_perm coef_by_prop
+      weights_as_sample_prob sample_with_replacement penalize_range
+      weigh_by_kurtosis assume_full_distr
+    )
+
     def fit_options
       keys = %i(
         sample_size ntrees ndim ntry

data/lib/isotree/version.rb

@@ -1,3 +1,3 @@
 module IsoTree
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/vendor/cereal/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2014, Randolph Voorhies, Shane Grant
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of cereal nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/vendor/cereal/README.md

@@ -0,0 +1,85 @@
+cereal - A C++11 library for serialization
+==========================================
+
+<img src="http://uscilab.github.io/cereal/assets/img/cerealboxside.png" align="right"/><p>cereal is a header-only C++11 serialization library.  cereal takes arbitrary data types and reversibly turns them into different representations, such as compact binary encodings, XML, or JSON.  cereal was designed to be fast, light-weight, and easy to extend - it has no external dependencies and can be easily bundled with other code or used standalone.</p>
+
+### cereal has great documentation
+
+Looking for more information on how cereal works and its documentation?  Visit [cereal's web page](http://USCiLab.github.com/cereal) to get the latest information.
+
+### cereal is easy to use
+
+Installation and use of of cereal is fully documented on the [main web page](http://USCiLab.github.com/cereal), but this is a quick and dirty version:
+
+* Download cereal and place the headers somewhere your code can see them
+* Write serialization functions for your custom types or use the built in support for the standard library cereal provides
+* Use the serialization archives to load and save data
+
+```cpp
+#include <cereal/types/unordered_map.hpp>
+#include <cereal/types/memory.hpp>
+#include <cereal/archives/binary.hpp>
+#include <fstream>
+    
+struct MyRecord
+{
+  uint8_t x, y;
+  float z;
+  
+  template <class Archive>
+  void serialize( Archive & ar )
+  {
+    ar( x, y, z );
+  }
+};
+    
+struct SomeData
+{
+  int32_t id;
+  std::shared_ptr<std::unordered_map<uint32_t, MyRecord>> data;
+  
+  template <class Archive>
+  void save( Archive & ar ) const
+  {
+    ar( data );
+  }
+      
+  template <class Archive>
+  void load( Archive & ar )
+  {
+    static int32_t idGen = 0;
+    id = idGen++;
+    ar( data );
+  }
+};
+
+int main()
+{
+  std::ofstream os("out.cereal", std::ios::binary);
+  cereal::BinaryOutputArchive archive( os );
+
+  SomeData myData;
+  archive( myData );
+
+  return 0;
+}
+```    
+
+### cereal has a mailing list
+
+Either get in touch over <a href="mailto:cerealcpp@googlegroups.com">email</a> or [on the web](https://groups.google.com/forum/#!forum/cerealcpp).
+
+
+
+## cereal has a permissive license
+
+cereal is licensed under the [BSD license](http://opensource.org/licenses/BSD-3-Clause).
+
+## cereal build status
+
+* master : [![Build Status](https://travis-ci.com/USCiLab/cereal.svg?branch=master)](https://travis-ci.com/USCiLab/cereal)
+[![Build status](https://ci.appveyor.com/api/projects/status/91aou6smj36or0vb/branch/master?svg=true)](https://ci.appveyor.com/project/AzothAmmo/cereal/branch/master)
+
+---
+
+Were you looking for the Haskell cereal?  Go <a href="https://github.com/GaloisInc/cereal">here</a>.

data/vendor/cereal/include/cereal/access.hpp

@@ -0,0 +1,351 @@
+/*! \file access.hpp
+    \brief Access control and default construction */
+/*
+  Copyright (c) 2014, Randolph Voorhies, Shane Grant
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+      * Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+      * Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+      * Neither the name of cereal nor the
+        names of its contributors may be used to endorse or promote products
+        derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef CEREAL_ACCESS_HPP_
+#define CEREAL_ACCESS_HPP_
+
+#include <type_traits>
+#include <iostream>
+#include <cstdint>
+#include <functional>
+
+#include "cereal/macros.hpp"
+#include "cereal/specialize.hpp"
+#include "cereal/details/helpers.hpp"
+
+namespace cereal
+{
+  // ######################################################################
+  //! A class that allows cereal to load smart pointers to types that have no default constructor
+  /*! If your class does not have a default constructor, cereal will not be able
+      to load any smart pointers to it unless you overload LoadAndConstruct
+      for your class, and provide an appropriate load_and_construct method.  You can also
+      choose to define a member static function instead of specializing this class.
+
+      The specialization of LoadAndConstruct must be placed within the cereal namespace:
+
+      @code{.cpp}
+      struct MyType
+      {
+        MyType( int x ); // note: no default ctor
+        int myX;
+
+        // Define a serialize or load/save pair as you normally would
+        template <class Archive>
+        void serialize( Archive & ar )
+        {
+          ar( myX );
+        }
+      };
+
+      // Provide a specialization for LoadAndConstruct for your type
+      namespace cereal
+      {
+        template <> struct LoadAndConstruct<MyType>
+        {
+          // load_and_construct will be passed the archive that you will be loading
+          // from as well as a construct object which you can use as if it were the
+          // constructor for your type.  cereal will handle all memory management for you.
+          template <class Archive>
+          static void load_and_construct( Archive & ar, cereal::construct<MyType> & construct )
+          {
+            int x;
+            ar( x );
+            construct( x );
+          }
+
+          // if you require versioning, simply add a const std::uint32_t as the final parameter, e.g.:
+          // load_and_construct( Archive & ar, cereal::construct<MyType> & construct, std::uint32_t const version )
+        };
+      } // end namespace cereal
+      @endcode
+
+      Please note that just as in using external serialization functions, you cannot get
+      access to non-public members of your class by befriending cereal::access.  If you
+      have the ability to modify the class you wish to serialize, it is recommended that you
+      use member serialize functions and a static member load_and_construct function.
+
+      load_and_construct functions, regardless of whether they are static members of your class or
+      whether you create one in the LoadAndConstruct specialization, have the following signature:
+
+      @code{.cpp}
+      // generally Archive will be templated, but it can be specific if desired
+      template <class Archive>
+      static void load_and_construct( Archive & ar, cereal::construct<MyType> & construct );
+      // with an optional last parameter specifying the version: const std::uint32_t version
+      @endcode
+
+      Versioning behaves the same way as it does for standard serialization functions.
+
+      @tparam T The type to specialize for
+      @ingroup Access */
+  template <class T>
+  struct LoadAndConstruct
+  { };
+
+  // forward decl for construct
+  //! @cond PRIVATE_NEVERDEFINED
+  namespace memory_detail{ template <class Ar, class T> struct LoadAndConstructLoadWrapper; }
+  namespace boost_variant_detail{ template <class Ar, class T> struct LoadAndConstructLoadWrapper; }
+  //! @endcond
+
+  //! Used to construct types with no default constructor
+  /*! When serializing a type that has no default constructor, cereal
+      will attempt to call either the class static function load_and_construct
+      or the appropriate template specialization of LoadAndConstruct.  cereal
+      will pass that function a reference to the archive as well as a reference
+      to a construct object which should be used to perform the allocation once
+      data has been appropriately loaded.
+
+      @code{.cpp}
+      struct MyType
+      {
+        // note the lack of default constructor
+        MyType( int xx, int yy );
+
+        int x, y;
+        double notInConstructor;
+
+        template <class Archive>
+        void serialize( Archive & ar )
+        {
+          ar( x, y );
+          ar( notInConstructor );
+        }
+
+        template <class Archive>
+        static void load_and_construct( Archive & ar, cereal::construct<MyType> & construct )
+        {
+          int x, y;
+          ar( x, y );
+
+          // use construct object to initialize with loaded data
+          construct( x, y );
+
+          // access to member variables and functions via -> operator
+          ar( construct->notInConstructor );
+
+          // could also do the above section by:
+          double z;
+          ar( z );
+          construct->notInConstructor = z;
+        }
+      };
+      @endcode
+
+      @tparam T The class type being serialized
+      */
+  template <class T>
+  class construct
+  {
+    public:
+      //! Construct and initialize the type T with the given arguments
+      /*! This will forward all arguments to the underlying type T,
+          calling an appropriate constructor.
+
+          Calling this function more than once will result in an exception
+          being thrown.
+
+          @param args The arguments to the constructor for T
+          @throw Exception If called more than once */
+      template <class ... Args>
+      void operator()( Args && ... args );
+      // implementation deferred due to reliance on cereal::access
+
+      //! Get a reference to the initialized underlying object
+      /*! This must be called after the object has been initialized.
+
+          @return A reference to the initialized object
+          @throw Exception If called before initialization */
+      T * operator->()
+      {
+        if( !itsValid )
+          throw Exception("Object must be initialized prior to accessing members");
+
+        return itsPtr;
+      }
+
+      //! Returns a raw pointer to the initialized underlying object
+      /*! This is mainly intended for use with passing an instance of
+          a constructed object to cereal::base_class.
+
+          It is strongly recommended to avoid using this function in
+          any other circumstance.
+
+          @return A raw pointer to the initialized type */
+      T * ptr()
+      {
+        return operator->();
+      }
+
+    private:
+      template <class Ar, class TT> friend struct ::cereal::memory_detail::LoadAndConstructLoadWrapper;
+      template <class Ar, class TT> friend struct ::cereal::boost_variant_detail::LoadAndConstructLoadWrapper;
+
+      construct( T * p ) : itsPtr( p ), itsEnableSharedRestoreFunction( [](){} ), itsValid( false ) {}
+      construct( T * p, std::function<void()> enableSharedFunc ) : // g++4.7 ice with default lambda to std func
+        itsPtr( p ), itsEnableSharedRestoreFunction( enableSharedFunc ), itsValid( false ) {}
+      construct( construct const & ) = delete;
+      construct & operator=( construct const & ) = delete;
+
+      T * itsPtr;
+      std::function<void()> itsEnableSharedRestoreFunction;
+      bool itsValid;
+  };
+
+  // ######################################################################
+  //! A class that can be made a friend to give cereal access to non public functions
+  /*! If you desire non-public serialization functions within a class, cereal can only
+      access these if you declare cereal::access a friend.
+
+      @code{.cpp}
+      class MyClass
+      {
+        private:
+          friend class cereal::access; // gives access to the private serialize
+
+          template <class Archive>
+          void serialize( Archive & ar )
+          {
+            // some code
+          }
+      };
+      @endcode
+      @ingroup Access */
+  class access
+  {
+    public:
+      // ####### Standard Serialization ########################################
+      template<class Archive, class T> inline
+      static auto member_serialize(Archive & ar, T & t) -> decltype(t.CEREAL_SERIALIZE_FUNCTION_NAME(ar))
+      { return t.CEREAL_SERIALIZE_FUNCTION_NAME(ar); }
+
+      template<class Archive, class T> inline
+      static auto member_save(Archive & ar, T const & t) -> decltype(t.CEREAL_SAVE_FUNCTION_NAME(ar))
+      { return t.CEREAL_SAVE_FUNCTION_NAME(ar); }
+
+      template<class Archive, class T> inline
+      static auto member_save_non_const(Archive & ar, T & t) -> decltype(t.CEREAL_SAVE_FUNCTION_NAME(ar))
+      { return t.CEREAL_SAVE_FUNCTION_NAME(ar); }
+
+      template<class Archive, class T> inline
+      static auto member_load(Archive & ar, T & t) -> decltype(t.CEREAL_LOAD_FUNCTION_NAME(ar))
+      { return t.CEREAL_LOAD_FUNCTION_NAME(ar); }
+
+      template<class Archive, class T> inline
+      static auto member_save_minimal(Archive const & ar, T const & t) -> decltype(t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar))
+      { return t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar); }
+
+      template<class Archive, class T> inline
+      static auto member_save_minimal_non_const(Archive const & ar, T & t) -> decltype(t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar))
+      { return t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar); }
+
+      template<class Archive, class T, class U> inline
+      static auto member_load_minimal(Archive const & ar, T & t, U && u) -> decltype(t.CEREAL_LOAD_MINIMAL_FUNCTION_NAME(ar, std::forward<U>(u)))
+      { return t.CEREAL_LOAD_MINIMAL_FUNCTION_NAME(ar, std::forward<U>(u)); }
+
+      // ####### Versioned Serialization #######################################
+      template<class Archive, class T> inline
+      static auto member_serialize(Archive & ar, T & t, const std::uint32_t version ) -> decltype(t.CEREAL_SERIALIZE_FUNCTION_NAME(ar, version))
+      { return t.CEREAL_SERIALIZE_FUNCTION_NAME(ar, version); }
+
+      template<class Archive, class T> inline
+      static auto member_save(Archive & ar, T const & t, const std::uint32_t version ) -> decltype(t.CEREAL_SAVE_FUNCTION_NAME(ar, version))
+      { return t.CEREAL_SAVE_FUNCTION_NAME(ar, version); }
+
+      template<class Archive, class T> inline
+      static auto member_save_non_const(Archive & ar, T & t, const std::uint32_t version ) -> decltype(t.CEREAL_SAVE_FUNCTION_NAME(ar, version))
+      { return t.CEREAL_SAVE_FUNCTION_NAME(ar, version); }
+
+      template<class Archive, class T> inline
+      static auto member_load(Archive & ar, T & t, const std::uint32_t version ) -> decltype(t.CEREAL_LOAD_FUNCTION_NAME(ar, version))
+      { return t.CEREAL_LOAD_FUNCTION_NAME(ar, version); }
+
+      template<class Archive, class T> inline
+      static auto member_save_minimal(Archive const & ar, T const & t, const std::uint32_t version) -> decltype(t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar, version))
+      { return t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar, version); }
+
+      template<class Archive, class T> inline
+      static auto member_save_minimal_non_const(Archive const & ar, T & t, const std::uint32_t version) -> decltype(t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar, version))
+      { return t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar, version); }
+
+      template<class Archive, class T, class U> inline
+      static auto member_load_minimal(Archive const & ar, T & t, U && u, const std::uint32_t version) -> decltype(t.CEREAL_LOAD_MINIMAL_FUNCTION_NAME(ar, std::forward<U>(u), version))
+      { return t.CEREAL_LOAD_MINIMAL_FUNCTION_NAME(ar, std::forward<U>(u), version); }
+
+      // ####### Other Functionality ##########################################
+      // for detecting inheritance from enable_shared_from_this
+      template <class T> inline
+      static auto shared_from_this(T & t) -> decltype(t.shared_from_this());
+
+      // for placement new
+      template <class T, class ... Args> inline
+      static void construct( T *& ptr, Args && ... args )
+      {
+        new (ptr) T( std::forward<Args>( args )... );
+      }
+
+      // for non-placement new with a default constructor
+      template <class T> inline
+      static T * construct()
+      {
+        return new T();
+      }
+
+      template <class T> inline
+      static std::false_type load_and_construct(...)
+      { return std::false_type(); }
+
+      template<class T, class Archive> inline
+      static auto load_and_construct(Archive & ar, ::cereal::construct<T> & construct) -> decltype(T::load_and_construct(ar, construct))
+      {
+        T::load_and_construct( ar, construct );
+      }
+
+      template<class T, class Archive> inline
+      static auto load_and_construct(Archive & ar, ::cereal::construct<T> & construct, const std::uint32_t version) -> decltype(T::load_and_construct(ar, construct, version))
+      {
+        T::load_and_construct( ar, construct, version );
+      }
+  }; // end class access
+
+  // ######################################################################
+  // Deferred Implementation, see construct for more information
+  template <class T> template <class ... Args> inline
+  void construct<T>::operator()( Args && ... args )
+  {
+    if( itsValid )
+      throw Exception("Attempting to construct an already initialized object");
+
+    ::cereal::access::construct( itsPtr, std::forward<Args>( args )... );
+    itsEnableSharedRestoreFunction();
+    itsValid = true;
+  }
+} // namespace cereal
+
+#endif // CEREAL_ACCESS_HPP_