Source Code for Module vsql_core.plan_generators.generate_plan

  1   
  2  """ 
  3  This generates plan for generic linear models 
  4  """ 
  5    
  6  import string 
  7 -class Python_Plan: 
  8      """The Plan Generator""" 
  9      mid=1 
 10      epochs=20 
 11      nparts= 2 
 12      step_size=1e-2 
 13      step_diminish=0.8 
 14      iname='instance_table' 
 15      iname_table='iname_table' 
 16      curried_grad='curried_grad' 
 17      batch_grad = 'grad' 
 18      prox = 'prox' 
 19      obj_aggregate_function = None 
 20      obj_row_function       = None 
 21      sparse_data = False 
 22      batch_step = None 
 23       
 24 -    def __init__(self, mid, epochs, step_size, step_diminish, iname_table, curried_grad, batch_grad, data_query, prox, obj_aggregate_function, obj_row_function, sparse_data=False, batch_step=None): 
 25          """ 
 26          Init function 
 27          """ 
 28          self.mid = mid 
 29          self.epochs = epochs 
 30          self.step_size = step_size 
 31          self.step_diminsh = step_diminish 
 32          self.iname_table = iname_table 
 33          self.curried_grad = curried_grad 
 34          self.batch_grad = batch_grad 
 35          self.data_query = data_query 
 36          self.prox = prox 
 37          self.nparts = 2 # CHANGE! 
 38          self.obj_aggregate_function = obj_aggregate_function 
 39          self.obj_row_function       = obj_row_function 
 40          self.sparse_data = sparse_data 
 41          self.batch_step = batch_step 
 42   
 43 -    def generate_cache_model(self): 
 44          """ 
 45          Generates cache model query 
 46   
 47          @rtype: string 
 48          @return: query to generate cache model 
 49          """ 
 50          z = "SELECT retrieve_model_instance(%d, serialized_model) FROM %s where mid=%d;\n" % (self.mid, self.iname_table, self.mid) 
 51          return z 
 52       
 53      # UPDATE ell_two_model_instance_table SET serialized_model=serialize_float8(get_model_instance(mid)); 
 54 -    def generate_store_model(self): 
 55          """ 
 56          Generates store model query 
 57   
 58          @rtype: string 
 59          @return: query to store the model 
 60          """ 
 61          z = "UPDATE %s SET serialized_model=get_model_instance(%d,serialized_model) where mid=%d" % (self.iname_table, self.mid, self.mid) 
 62          return z 
 63   
 64 -    def generate_loss_function(self): 
 65          """ 
 66          Generates loss function query 
 67   
 68          @rtype: string 
 69          @return: query to generate loss function 
 70          """ 
 71          loss_eval = None 
 72          if self.obj_aggregate_function and self.obj_row_function: 
 73              if self.sparse_data: 
 74                  loss_eval = "SELECT %s(%s(%d, k,v,label)) FROM (%s) as x;\n" % (self.obj_aggregate_function, self.obj_row_function, self.mid, self.data_query) 
 75              else: 
 76                  loss_eval = "SELECT %s(%s(%d, vec,label)) FROM (%s) as x;\n" % (self.obj_aggregate_function, self.obj_row_function, self.mid, self.data_query) 
 77          return loss_eval 
 78       
 79 -    def incremental_plan(self): 
 80          """ 
 81          Generates incremental plan 
 82           
 83          @rtype: tuple 
 84          @return: incremental plan tuple that contains: header, body, loss_eval and foote 
 85          """ 
 86          header = self.generate_cache_model() 
 87          current_step = self.step_size 
 88          body   = [] 
 89          for step in range(self.epochs): 
 90              if self.prox: 
 91                  z = ["SELECT COUNT(*) FROM (SELECT ", self.prox, "(", str(self.mid), ", ", str(self.step_size),  
 92                       ", curried_step(", str(self.mid), ",", str(self.step_size), ", ",  
 93                       self.curried_grad, "(", str(self.mid), ", vec, label))) FROM (", self.data_query,  
 94                       ") AS T ORDER BY RANDOM()) AS T;\n"] 
 95                  body.append(string.join(z,'')) 
 96              else: 
 97                  if self.sparse_data: 
 98                      z = "SELECT COUNT(*) FROM (SELECT %s(%d,%f,k,v,label) FROM (%s) AS i ORDER BY RANDOM()) AS T;\n" % ( self.curried_grad, self.mid, current_step, self.data_query) 
 99                  else: 
100                      z = "SELECT COUNT(*) FROM (SELECT %s(%d,%f,vec,label) FROM (%s) AS i ORDER BY RANDOM()) AS T;\n" % ( self.curried_grad, self.mid, current_step, self.data_query) 
101                  body.append(z)                 
102              current_step = current_step * self.step_diminish 
103   
104          footer = self.generate_store_model() 
105   
106          loss_eval = self.generate_loss_function() 
107   
108   
109          return [header, body, loss_eval, footer] 
110           
111   
112 -    def batchgradient_plan(self): 
113          """ 
114          Generates batch gradient plan 
115           
116          @rtype: tuple 
117          @return: batch plan tuple that contains: header, body, loss_eval and foote 
118          """ 
119          header       = self.generate_cache_model() 
120          header      += "SELECT zero_gradient(%d);\n" % (self.mid) 
121          current_step = self.step_size 
122   
123          assert( self.prox ) # contract says must implement a trivial prox that zeros the gradient 
124           
125          body = [] 
126          for step in range(self.epochs): 
127              if self.sparse_data: 
128                  z = "SELECT COUNT(*) FROM (SELECT %s(%d, k,v,label) FROM (%s) as f) as T;\n" % (self.batch_grad, self.mid, self.data_query) 
129              else: 
130                  z = "SELECT COUNT(*) FROM (SELECT %s(%d, vec,label) FROM (%s) as f) as T;\n" % (self.batch_grad, self.mid, self.data_query) 
131                   
132               
133              z   += "SELECT %s(%d, %f);\n" % (self.prox, self.mid,current_step) 
134              body.append(z)                 
135              current_step = current_step * self.step_diminish 
136   
137          loss_eval = self.generate_loss_function() 
138          # generate footer 
139          footer = self.generate_store_model() 
140          return [header, body, loss_eval, footer] 
141       
142   
143 -def test_handler(): 
144      """ 
145      Test this class 
146      """ 
147   
148      P = Python_Plan(1, 3, 0.9, 0.8, 'ell_two_model_instance', 'c_ell_two_grad', 'full_ell2_grad_step', 'SELECT * FROM FOREST', None, 'SUM', 'full_mse_loss', batch_step='full_gradient_step') 
149      print "*** Incremental, No Prox" 
150      print P.incremental_plan() 
151      print "*** Batch, No Prox" 
152      print P.batchgradient_plan() 
153       
154      # P = Python_Plan(1, 3, 0.9, 0.8, 'forest_ell_two', 'ell_two_model_instance_table', 'c_ell_two_grad', 'full_ell2_grad_step', 'SELECT * FROM FOREST', 'prox') 
155      # print "*** Incremental, Prox" 
156      # print P.incremental_plan() 
157      # print "*** Batch, Prox" 
158      # print P.batchgradient_plan() 
159       
160   
161  #test_handler() 
162