Changeset 464

Timestamp:

06/30/11 19:22:20 (5 years ago)

Author:

mmckerns

Message:

updated citation, todo's from scipy pub

Files:

• DEV_TODO (modified) (2 diffs)
• mystic/mystic/__init__.py (modified) (2 diffs)

DEV_TODO

@@ +1 @@
+#####################################################################
+#   M.M. McKerns, L. Strand, T. Sullivan, A. Fang, M.A.G. Aivazis,
+#   "Building a framework for predictive science", Proceedings of
+#   the 10th Python in Science Conference, (submitted 2011).
+#####################################################################
+
+# the function to be minimized and initial values 
+from mystic.models import rosen as my_model 
+x0 = [0.8, 1.2, 0.7] 
+
+# configure the solver and obtain the solution 
+from mystic.solvers import fmin 
+solution = fmin(my_model, x0)
+
+#####################################################################
+
+# the function to be minimized and initial values 
+from mystic.models import rosen as my_model 
+x0 = [0.8, 1.2, 0.7] 
+
+# get monitor and termination condition objects 
+from mystic.monitors import Monitor, VerboseMonitor 
+stepmon = VerboseMonitor(5) 
+evalmon = Monitor() 
+from mystic.termination import ChangeOverGeneration 
+COG = ChangeOverGeneration() 
+
+# instantiate and configure the solver 
+from mystic.solvers import NelderMeadSimplexSolver 
+solver = NelderMeadSimplexSolver(len(x0)) 
+solver.SetInitialPoints(x0) 
+solver.SetGenerationMonitor(stepmon) 
+solver.SetEvaluationMonitor(evalmon) 
+solver.Solve(my_model, COG) 
+
+# obtain the solution 
+solution = solver.bestSolution 
+
+# obtain diagnostic information 
+function_evals = solver.evaluations 
+iterations = solver.generations 
+cost = solver.bestEnergy 
+
+# modify the solver configuration, and continue 
+COG = ChangeOverGeneration(tolerance=1e-8) 
+solver.Solve(my_model, COG) 
+
+# obtain the new solution 
+solution = solver.bestSolution
+
+#####################################################################
+
+# a user-provided constraints function 
+def constrain(x): 
+  x[1] = x[0] 
+  return x 
+
+# the function to be minimized and the bounds 
+from mystic.models import rosen as my_model 
+lb = [0.0, 0.0, 0.0] 
+ub = [2.0, 2.0, 2.0] 
+
+# get termination condition object 
+from mystic.termination import ChangeOverGeneration 
+COG = ChangeOverGeneration() 
+
+# instantiate and configure the solver 
+from mystic.solvers import NelderMeadSimplexSolver 
+solver = NelderMeadSimplexSolver(len(x0)) 
+solver.SetRandomInitialPoints(lb, ub) 
+solver.SetStrictRanges(lb, ub) 
+solver.SetConstraints(constrain) 
+solver.Solve(my_model, COG) 
+
+# obtain the solution 
+solution = solver.bestSolution 
+
+#####################################################################
+
+# a user-provided constraints function 
+constraints = """ 
+x2 = x1 
+""" 
+from mystic.constraints import parse 
+constrain = parse(constraints) 
+
+#####################################################################
+
+# generate a model from a stock 'model factory'
+from mystic.models.lorentzian import Lorentzian 
+lorentz = Lorentzian(coeffs) 
+
+# evaluate the model 
+y = lorentz(x) 
+
+#####################################################################
+
+# a user-provided model function 
+def identify(x) 
+  return x 
+
+# add pathos infrastructure (included in mystic) 
+from mystic.tools import modelFactory, Monitor 
+evalmon = Monitor() 
+my_model = modelFactory(identify, monitor=evalmon) 
+
+# evaluate the model 
+y = my_model(x) 
+
+# evaluate the model with a map function 
+from mystic.tools import PythonMap 
+my_map = PythonMap() 
+z = my_map(my_model, range(10)) 
+
+#####################################################################
+
+# a user-provided model function 
+def identify(x) 
+  return x 
+
+# cast the model as a distributed service 
+from pathos.servers import sshServer
+id = 'foo.caltech.edu:50000:spike42'
+my_proxy = sshServer(identify, server=id) 
+
+# evaluate the model via proxy 
+y = my_proxy(x) 
+
+#####################################################################
+
+# a user-provided model function 
+def identify(x) 
+  return x 
+
+# select and configure a parallel map 
+from pathos.maps import ipcPool 
+my_map = ipcPool(2, servers=['foo.caltech.edu']) 
+
+# evaluate the model in parallel 
+z = my_map(identify, range(10)) 
+
+#####################################################################
+
+# configure and build map 
+from pathos.launchers import ipc 
+from pathos.strategies import pool
+from pathos.tools import mapFactory 
+my_map = mapFactory(launcher=ipc, strategy=pool) 
+
+#####################################################################
+
+# establish a tunnel 
+from pathos.tunnel import sshTunnel 
+uid = 'foo.caltech.edu:12345:tunnel69'
+tunnel_proxy = sshTunnel(uid) 
+
+# inspect the ports 
+localport = tunnel_proxy.lport 
+remoteport = tunnel_proxy.rport 
+
+# a user-provided model function 
+def identify(x) 
+  return x 
+
+# cast the model as a distributed service 
+from pathos.servers import ipcServer 
+id = 'localhost:%s:bug01' % localport 
+my_proxy = ipcServer(identify, server=id) 
+
+# evaluate the model via tunneled proxy 
+y = my_proxy(x) 
+
+# disconnect the tunnel 
+tunnel_proxy.disconnect() 
+
+#####################################################################
+
+# configure and build map 
+from pyina.launchers import mpirun 
+from pyina.strategies import carddealer as card 
+from pyina.tools import mapFactory 
+my_map = mapFactory(4, launcher=mpirun, strategy=card) 
+
+#####################################################################
+
+# the function to be minimized and the bounds 
+from mystic.models import rosen as my_model 
+lb = [0.0, 0.0, 0.0] 
+ub = [2.0, 2.0, 2.0] 
+
+# get termination condition object 
+from mystic.termination import ChangeOverGeneration 
+COG = ChangeOverGeneration() 
+
+# select the parallel launch configuration 
+from pyina.maps import MpirunCarddealer 
+my_map = MpirunCarddealer(4) 
+
+# instantiate and configure the solver 
+from mystic.solvers import DifferentialEvolutionSolver 
+solver = DifferentialEvolutionSolver(len(lb), 20) 
+solver.SetRandomInitialPoints(lb, ub) 
+solver.SetStrictRanges(lb, ub) 
+solver.SetEvaluationMap(my_map) 
+solver.Solve(my_model, COG) 
+
+# obtain the solution 
+solution = solver.bestSolution 
+
+#####################################################################
+
+# the function to be minimized and the bounds 
+from mystic.models import rosen as my_model 
+lb = [0.0, 0.0, 0.0] 
+ub = [2.0, 2.0, 2.0] 
+
+# get monitor and termination condition objects 
+from mystic.monitors import LoggingMonitor 
+stepmon = LoggingMonitor(1, ’log.txt’) 
+from mystic.termination import ChangeOverGeneration 
+COG = ChangeOverGeneration() 
+
+# select the parallel launch configuration 
+from pyina.maps import TorqueMpirunCarddealer 
+my_map = TorqueMpirunCarddealer(’5:ppn=4’) 
+
+# instantiate and configure the nested solver 
+from mystic.solvers import PowellDirectionalSolver 
+my_solver = PowellDirectionalSolver(len(lb)) 
+my_solver.SetStrictRanges(lb, ub) 
+my_solver.SetEvaluationLimits(50) 
+
+# instantiate and configure the outer solver 
+from mystic.solvers import BuckshotSolver 
+solver = BuckshotSolver(len(lb), 20) 
+solver.SetRandomInitialPoints(lb, ub) 
+solver.SetGenerationMonitor(stepmon) 
+solver.SetNestedSolver(my_solver) 
+solver.SetSolverMap(my_map) 
+solver.Solve(my_model, COG) 
+
+# obtain the solution 
+solution = solver.bestSolution
+
+#####################################################################
+
+# prepare a (F(X) - G)**2 a metric 
+def costFactory(my_model, my_data): 
+  def cost(param): 
+
+    # compute the cost 
+    return ( my_model(param) - my_data )**2 
+
+  return cost 
+
+#####################################################################
+'''
+The calculation of the diameter is performed as a nested
+optimization, as shown above for the BuckshotSolver. Each
+inner optimization is a calculation of a component
+suboscillation, using the a global optimizer 
+(such as DifferentialEvolutionSolver) and the cost 
+metric shown above.
+'''
+
+# prepare a (F(X) - F(X'))**2 cost metric 
+def suboscillationFactory(my_model, i): 
+  def cost(param): 
+
+    # get X and X' (Xi' is appended to X at param[-1]) 
+    x = param[:-1] 
+    x_prime = param[:i] + param[-1:] + param[i+1:-1] 
+
+    # compute the suboscillation 
+    return -( my_model(x) - my_model(x_prime) )**2 
+
+  return cost
+
+#####################################################################
+'''
+Global optimizations used in solving OUQ problems are 
+composed in the same manner as shown above for the 
+DifferentialEvolutionSolver.
+'''
+
+# OUQ requires bounds in a very specific form... 
+# param = [wxi]*nx + [xi]*nx + [wyi]*ny + [yi]*ny + [wzi]*nz + [zi]*nz 
+npts = (nx,ny,nz) 
+lb = (nx * w_lower) + (nx * x_lower) \ 
+   + (ny * w_lower) + (ny * y_lower) \ 
+   + (nz * w_lower) + (nz * z_lower) 
+ub = (nx * w_upper) + (nx * x_upper) \ 
+   + (ny * w_upper) + (ny * y_upper) \ 
+   + (nz * w_upper) + (nz * z_upper) 
+
+from mystic.math.measures import split_param 
+from mystic.math.dirac_measure import product_measure 
+from mystic.math import almostEqual 
+
+# split bounds into weight-only & sample-only 
+w_lb, m_lb = split_param(lb, npts) 
+w_ub, m_ub = split_param(ub, npts) 
+
+# generate constraints function 
+def constraints(param): 
+  prodmeasure = product_measure() 
+  prodmeasure.load(param, npts) 
+
+  # impose norm on measures 
+  for measure in prodmeasure: 
+    if not almostEqual(float(measure.mass), 1.0): 
+      measure.normalize() 
+
+  # impose expectation on product measure 
+  E = float(prodmeasure.get_expect(my_model)) 
+    if not (E <= float(target_mean + error)) \ 
+    or not (float(target_mean - error) <= E):
+      prodmeasure.set_expect((target_mean, error), my_model, (m_lb, m_ub)) 
+
+  # extract weights and positions 
+  return prodmeasure.flatten() 
+
+# generate maximizing function 
+def cost(param): 
+  prodmeasure = product_measure() 
+  prodmeasure.load(param, npts) 
+  return MINMAX * prodmeasure.pof(my_model)
+
+#####################################################################
+"""
 DIRECT:
 * Add more python optimizers: scipy, OpenOpt, PARK (snobfit)
@@ -17 +347 @@
 * <-- Find OpenOpt's model & optimizer API -->
 * <-- Find DAKOTA's model & optimizer API -->
+"""

mystic/mystic/__init__.py

@@ -4 +4 @@
 #
 #                 Mike McKerns, Alta Fang, & Patrick Hung, Caltech
-#                        (C) 1997-2010  All Rights Reserved
+#                        (C) 1997-2011  All Rights Reserved
 #
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -202 +202 @@
 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-Copyright (c) 2010 California Institute of Technology. All rights reserved.
+Copyright (c) 2011 California Institute of Technology. All rights reserved.
 
 
 If you use this software to do productive scientific research that leads to
 publication, we ask that you acknowledge use of the software by citing the
-following paper in your publication::
-
-    "mystic: a simple model-independent inversion framework",
-     Michael McKerns, Patrick Hung, and Michael Aivazis, unpublished;
-     http://dev.danse.us/trac/mystic
+following in your publication::
+
+    M.M. McKerns, L. Strand, T. Sullivan, A. Fang, M.A.G. Aivazis,
+    "Building a framework for predictive science", Proceedings of
+    the 10th Python in Science Conference, (submitted 2011).
+
+    Michael McKerns, Patrick Hung, and Michael Aivazis,
+    "mystic: a simple model-independent inversion framework", 2009- ;
+    http://dev.danse.us/trac/mystic
 
 """