hazy_sgd.h

Go to the documentation of this file.

#ifndef HAZY_SGD_H
#define HAZY_SGD_H

//#include "sgd_model.h"
#include "skiing.h"
#include "reservoir.h"
#include "incremental_sgd.h"
#include "storage_manager.h"
#include "ondisk_storage_manager.h"
#include "hybrid_storage_manager.h"
#include "main_memory_storage_manager.h"
#include <pthread.h>

#include <string>

#define LAMBDA 0.0001

template <class T>
class Hazy_Sgd {
 protected:
  int _dim;
  
  Skiing ski;
  
  IncrementalSGD<T> *sgd;  
  struct hazy_model hm;
  
  Storage_Manager<T> *st_man;
  
  pthread_rwlock_t _rwlock;
  
  struct model _last_sort_model;

  typedef std::map<std::string, Hazy_Database*> _connection_map;
  _connection_map connections;
  
  void updateModel();
  
  void holder_difference_models(double &delta_w, double &delta_b); 
  
  bool _high_low_water_valid; 
  void  update_low_high_water() { // Implicitly uses the current model and the last sort model.
    double delta_bias = 0.0, delta_w = 0.0;
    holder_difference_models(delta_w, delta_bias);
    
    // Update the high and low water
    double cond_plus = -(delta_bias - delta_w);
    double cond_neg = -(delta_bias + delta_w);
    hm.low_water  = std::min(hm.low_water, cond_neg);
    hm.high_water = std::max(hm.high_water, cond_plus);
    LOGGING_ONLY(std::cout << "low & high water: " << hm.low_water << ", " << hm.high_water << std::endl;);
  }
 public:
  Hazy_Sgd(Storage_Manager<T> *sm, IncrementalSGD<T> *sgd, Skiing &ski, hazy_model::strategy s);    
  void updateModel(T vec, sClass label);
  
  void deleteModel(std::string db_name, std::string table_name);

  void readEntityClass(key entity_id, sClass &c);
  void readEntityClass(T vec, sClass &label);
  void readEntityClass(T vec, double eps, sClass &label);
  
  void readNumInClass(sClass c, int &nClass);
};
#include "hazy_sgd.hxx"

template<class T>
class Read_Specialized_Hazy_Sgd : public Hazy_Sgd<T> {
 public:
 Read_Specialized_Hazy_Sgd(Storage_Manager<T> *sm, IncrementalSGD<T> *sgd, Skiing &_ski, hazy_model::strategy s, 
                           double _low_water, double _high_water) : 
  Hazy_Sgd<T>(sm, sgd, _ski, s) {this->hm.low_water = _low_water; this->hm.high_water = _high_water;}
};

template<class T>
class Multiclass_Specialized_Hazy_Sgd : public Hazy_Sgd<T> {
 public:
 Multiclass_Specialized_Hazy_Sgd(Storage_Manager<T> *sm, IncrementalSGD<T> *sgd, Skiing ski, hazy_model::strategy s) :
  Hazy_Sgd<T>(sm, sgd, ski, s) {}
  
  void resort() {
    Timer t(true);
    this->st_man->resort(this->hm);
    this->_last_sort_model = model(this->hm._model);
    
    this->ski.doResort(t.stop());
    this->hm.low_water = 0.0, this->hm.high_water = 0.0;
  }
};

#endif

---