Changeset 472

Timestamp:

07/06/11 16:05:45 (5 years ago)

Author:

mmckerns

Message:

new methods for product measure: load, flatten, pts, wts, pos;
more natural interface for constraints in "set_expect"

Files:

• branches/UQ/math/examples2/TEST4d_OUQ_surrogate_diam.py (modified) (4 diffs)
• branches/UQ/math/examples2/TEST_OUQ_surrogate_diam.py (modified) (4 diffs)
• mystic/_math/dirac_measure.py (modified) (10 diffs)
• mystic/tests/test_dirac_measure.py (modified) (3 diffs)

branches/UQ/math/examples2/TEST4d_OUQ_surrogate_diam.py

@@ -68 +68 @@
 
   from mystic.math.measures import split_param
-  from mystic.math.dirac_measure import unflatten, flatten
-  from mystic.math.dirac_measure import compose, decompose
+  from mystic.math.dirac_measure import product_measure
   from mystic.math import almostEqual
   from numpy import inf
@@ -85 +84 @@
 
   # generate secondary constraints function
-  def additional_constraints(c): #XXX: move within 'def constraints'?
+  def more_constraints(c): #XXX: move within 'def constraints'?
     ##################### begin function-specific #####################
 #   E = float(c[0].var)  # var(h)
@@ -104 +103 @@
     return c
 
-  # wrapper to fit format for 'impose_expectation'
-  def cnstr(x, w): #XXX: move within 'def constraints'?
-    c = compose(x,w)
-    c = additional_constraints(c)
-    return decompose(c)[0]
-
   # generate primary constraints function
   def constraints(rv):
-    c = unflatten(rv, npts)
+    c = product_measure()
+    c.load(rv, npts)
     # NOTE: bounds wi in [0,1] enforced by filtering
-    # impose norm on sets
-    for set in c:
-      if not almostEqual(float(set.mass), 1.0, tol=atol, rel=rtol):
-        set.normalize()
-    # impose expectation on collection
+    # impose norm on each discrete measure
+    for measure in c:
+      if not almostEqual(float(measure.mass), 1.0, tol=atol, rel=rtol):
+        measure.normalize()
+    # impose expectation on product measure
     ##################### begin function-specific #####################
     E = float(c.get_expect(model))
     if not (E <= float(target[0] + error[0])) \
     or not (float(target[0] - error[0]) <= E):
-      c.set_expect((target[0],error[0]), model, (x_lb,x_ub), cnstr)
-
-    # c = additional_constraints(c) #XXX: impose constraints again (necessary ?)
+      c.set_expect((target[0],error[0]), model, (x_lb,x_ub), more_constraints)
+
+    # c = more_constraints(c) #XXX: impose constraints again (necessary ?)
     ###################### end function-specific ######################
     # extract weights and positions
-    return flatten(c)
+    return c.flatten()
 
   # generate maximizing function
   def cost(rv):
-    c = unflatten(rv, npts)
+    c = product_measure()
+    c.load(rv, npts)
     #XXX: apply 'filters' to catch errors in constraints solver (necessary ?)
     ##################### begin function-specific #####################
@@ -242 +237 @@
 
   from numpy import array
-  from mystic.math.dirac_measure import unflatten
-  c = unflatten(solved,npts)
+  from mystic.math.dirac_measure import product_measure
+  c = product_measure()
+  c.load(solved,npts)
   print "solved: [wx,x]\n%s" % array(zip(c[0].weights,c[0].coords))
   print "solved: [wy,y]\n%s" % array(zip(c[1].weights,c[1].coords))

branches/UQ/math/examples2/TEST_OUQ_surrogate_diam.py

@@ -68 +68 @@
 
   from mystic.math.measures import split_param
-  from mystic.math.dirac_measure import unflatten, flatten
+  from mystic.math.dirac_measure import product_measure
   from mystic.math import almostEqual
   from numpy import inf
@@ -85 +85 @@
   # generate primary constraints function
   def constraints(rv):
-    c = unflatten(rv, npts)
+    c = product_measure()
+    c.load(rv, npts)
     # NOTE: bounds wi in [0,1] enforced by filtering
-    # impose norm on sets
-    for set in c:
-      if not almostEqual(float(set.mass), 1.0, tol=atol, rel=rtol):
-        set.normalize()
-    # impose expectation on collection
+    # impose norm on each discrete measure
+    for measure in c:
+      if not almostEqual(float(measure.mass), 1.0, tol=atol, rel=rtol):
+        measure.normalize()
+    # impose expectation on product measure
     ##################### begin function-specific #####################
     E = float(c.get_expect(model))
@@ -99 +100 @@
     ###################### end function-specific ######################
     # extract weights and positions
-    return flatten(c)
+    return c.flatten()
 
   # generate maximizing function
   def cost(rv):
-    c = unflatten(rv, npts)
+    c = product_measure()
+    c.load(rv, npts)
     E = float(c.get_expect(model))
     if E > (target[0] + error[0]) or E < (target[0] - error[0]):
@@ -187 +189 @@
 
   from numpy import array
-  from mystic.math.dirac_measure import unflatten
-  c = unflatten(solved,npts)
+  from mystic.math.dirac_measure import product_measure
+  c = product_measure()
+  c.load(solved,npts)
   print "solved: [wx,x]\n%s" % array(zip(c[0].weights,c[0].coords))
   print "solved: [wy,y]\n%s" % array(zip(c[1].weights,c[1].coords))

mystic/_math/dirac_measure.py

@@ -40 +40 @@
 
  settings:
-  s.weights = [w1, w2, ..., wn]  --  set weights
-  s.coords = [x1, x2, ..., xn]  --  set positions
-  s.normalize()  --  normalizes the weights to 1.0
+  s.weights = [w1, w2, ..., wn]  --  set the weights
+  s.coords = [x1, x2, ..., xn]  --  set the positions
+  s.normalize()  --  normalize the weights to 1.0
   s.mean(R)  --  set the mean
   s.range(R)  --  set the range
@@ -125 +125 @@
   c.coords  --  returns list of position tuples
   c.mass  --  returns list of weight norms
+  c.pts  --  returns number of points for each discrete measure
+  c.wts  --  returns list of weights for each discrete measure
+  c.pos  --  returns list of positions for each discrete measure
 
  settings:
-  c.coords = [(x1,y1,z1),...]  --  set positions (propagates to each set member)
+  c.coords = [(x1,y1,z1),...]  --  set the positions (tuples in product measure)
 
  methods:
@@ -133 +136 @@
   c.get_expect(f)  --  calculate the expectation
   c.set_expect((center,delta), f)  --  impose expectation by adjusting positions
+  c.flatten()  --  convert measure to a flat list of parameters
+  c.load(params, pts)  --  'fill' the measure from a flat list of parameters
 
  notes:
@@ -141 +146 @@
 """
 
+  def __pts(self):
+    return [i.npts for i in self]
+
+  def __wts(self):
+    return [i.weights for i in self]
+
+  def __pos(self):
+    return [i.coords for i in self]
+
   def __n(self):
-    npts = 1
-    for i in self:
-      npts *= i.npts
-    return npts
+    from numpy import product
+    return product(self.pts)
 
   def __weights(self):
     from mystic.math.measures import _pack
-    weights = [i.weights for i in self]
-    weights = _pack(weights)
+    from numpy import product
+    weights = _pack(self.wts)
     _weights = []
     for wts in weights:
-      weight = 1.0
-      for w in wts:
-        weight *= w
-      _weights.append(weight)
+      _weights.append(product(wts))
     return _weights
 
   def __positions(self):
     from mystic.math.measures import _pack
-    coords = [i.coords for i in self]
-    coords = _pack(coords)
-    return coords
+    return _pack(self.pos)
 
   def __set_positions(self, coords):
     from mystic.math.measures import _unpack
-    npts = [i.npts for i in self]
-    coords = _unpack(coords,npts)
+    coords = _unpack(coords, self.pts)
     for i in range(len(coords)):
       self[i].coords = coords[i]
@@ -198 +204 @@
     f -- a function that takes a list and returns a number
     bounds -- tuple of lists of bounds  (lower_bounds, upper_bounds)
-    constraints -- a function that takes a nested list of N x 1D discrete
-        measure positions and weights   x' = constraints(x, w)
+    constraints -- a function that takes a product_measure  c' = constraints(c)
 """
    #self.__center = m
    #self.__delta = D
-    npts = [i.npts for i in self]
-    self.coords = impose_expectation((m,D), f, npts, bounds, self.weights, \
-                                                     constraints=constraints) 
+    if constraints:  # then need to adjust interface for 'impose_expectation'
+      def cnstr(x, w):
+        c = compose(x,w)
+        c = constraints(c)
+        return decompose(c)[0]
+    else: cnstr = constraints  # 'should' be None
+    self.coords = impose_expectation((m,D), f, self.pts, bounds, self.weights, \
+                                                         constraints=cnstr) 
     return
 
@@ -258 +268 @@
     return transpose(pts)  #XXX: assumes 'coords' is a list of floats
 
+  def load(self, params, pts):
+    """load a list of parameters corresponding to N x 1D discrete measures
+
+Inputs:
+    params -- a list of parameters (see 'notes')
+    pts -- number of points in each of the underlying discrete measures
+
+Notes:
+    To append len(pts) new discrete measures to product measure c, where
+    pts = (M, N, ...)
+    params = [wt_x1, ..., wt_xM, \
+                 x1, ..., xM,    \
+              wt_y1, ..., wt_yN, \
+                 y1, ..., yN,    \
+                     ...]
+    Thus, the provided list is M weights and the corresponding M positions,
+    followed by N weights and the corresponding N positions, with this
+    pattern followed for each new dimension desired for the product measure.
+"""
+    c = unflatten(params, pts)
+    for i in range(len(c)):
+      self.append(c[i]) 
+    return
+
+  def flatten(self):
+    """flatten the product_measure into a list of parameters
+
+Returns:
+    params -- a list of parameters (see 'notes')
+
+Notes:
+    For a product measure c where c.pts = (M, N, ...), then
+    params = [wt_x1, ..., wt_xM, \
+                 x1, ..., xM,    \
+              wt_y1, ..., wt_yN, \
+                 y1, ..., yN,    \
+                     ...]
+    Thus, the returned list is M weights and the corresponding M positions,
+    followed by N weights and the corresponding N positions, with this
+    pattern followed for each dimension of the product measure.
+"""
+    return flatten(self)
+
  #__center = None
  #__delta = None
@@ -269 +322 @@
  #expect = property(__expect, __set_expect )
   mass = property(__mass )
+  pts = property(__pts )
+  wts = property(__wts )
+  pos = property(__pos )
   pass
 
@@ -299 +355 @@
 
 
-def compose(samples, weights):
-  """Generate a product_measure object from a nested list of N x 1D
+def _list_of_measures(samples, weights):
+  """generate a list of N x 1D discrete measures from a nested list of N x 1D
 discrete measure positions and a nested list of N x 1D weights."""
   total = []
@@ -308 +364 @@
       next.append(point( samples[i][j], weights[i][j] ))
     total.append(next)
+  return total
+
+
+def compose(samples, weights):
+  """Generate a product_measure object from a nested list of N x 1D
+discrete measure positions and a nested list of N x 1D weights."""
+  total = _list_of_measures(samples, weights)
   c = product_measure(total)
   return c
@@ -316 +379 @@
 N x 1D discrete measure positions and a nested list of N x 1D weights."""
   from mystic.math.measures import _nested_split
-  npts = [set.npts for set in c]
-  w, x = _nested_split(flatten(c), npts)
+  w, x = _nested_split(flatten(c), c.pts)
   return x, w
 

mystic/tests/test_dirac_measure.py

@@ -196 +196 @@
   print "randomly selected support:\n %s" % c.support(10)
 
-  print "npts: %s" % c.npts
+  print "npts: %s (i.e. %s)" % (c.npts, c.pts)
   print "weights: %s" % c.weights
   coords = c.coords
@@ -247 +247 @@
   # flatten and unflatten
   from mystic.math.dirac_measure import flatten, unflatten
-  npts = [s.npts for s in c]
-  d = unflatten(flatten(c), npts)
+  d = unflatten(flatten(c), c.pts)
 
   # check if the same
@@ -254 +253 @@
   assert c.weights == d.weights
   assert c.coords == d.coords
+
+  # flatten() and load(...)
+  e = collection()
+  e.load(c.flatten(), c.pts)
+
+  # check if the same
+  assert c.npts == e.npts
+  assert c.weights == e.weights
+  assert c.coords == e.coords
 
   # decompose and compose