Source Code for Module minimise.grid

 1  import sys 
 2  from Numeric import Float64, ones, copy, zeros 
 3  from re import match 
 4   
 5 -def grid(func, grid_ops, args=(), print_flag=0): 
 6          """Grid search function. 
 7   
 8   
 9          Function options 
10          ~~~~~~~~~~~~~~~~ 
11   
12          func            - The function to minimise. 
13          grid_ops        - Matrix of options for the grid search. 
14          args            - The tuple of arguments to supply to the function func. 
15   
16          The first dimension of grid_ops corresponds to the parameters of the function func, and the second dimension corresponds to: 
17                  0 - The number of increments. 
18                  1 - Lower limit. 
19                  2 - Upper limit. 
20   
21   
22          Returned objects 
23          ~~~~~~~~~~~~~~~~ 
24   
25          The parameter vector corresponding to the minimum function value. 
26          The minimum function value. 
27   
28          """ 
29   
30          # Initialise data structures. 
31          num_params = len(grid_ops) 
32          total_steps = 1 
33          step_num = ones((num_params)) 
34          step_size = zeros((num_params), Float64) 
35          params = zeros((num_params), Float64) 
36          min_params = zeros((num_params), Float64) 
37          for k in range(num_params): 
38                  step_size[k] = (grid_ops[k][2] - grid_ops[k][1]) / (grid_ops[k][0] - 1) 
39                  params[k] = grid_ops[k][1] 
40                  min_params[k] = grid_ops[k][1] 
41                  total_steps = total_steps * grid_ops[k][0] 
42   
43          # Back calculate the initial function value. 
44          f = apply(func, (params,)+args) 
45          f_min = f 
46   
47          # Debugging code. 
48          if print_flag: 
49                  print "\n%-23s%-20i\n" % ("Total number of steps:", total_steps) 
50                  if print_flag == 2: 
51                          print "%-20s%-20s\n" % ("Step size:", `step_size`) 
52                  print "%-6s%-8i%-12s%-20s" % ("Step:", 1, "Min params:", `params`) 
53                  if print_flag == 2: 
54                          print "%-20s%-20i" % ("Step number:", 1) 
55                          print "%-20s%-20s" % ("Increment:", `step_num`) 
56                          print "%-20s%-20s" % ("Init params:", `params`) 
57                          print "%-20s%-20g\n" % ("Init f:", f) 
58   
59          # Grid search. 
60          for step in range(2, total_steps + 1): 
61                  # Loop over the parameters. 
62                  for k in range(num_params): 
63                          if step_num[k] < grid_ops[k][0]: 
64                                  step_num[k] = step_num[k] + 1 
65                                  params[k] = params[k] + step_size[k] 
66                                  # Exit so that the other step numbers are not incremented. 
67                                  break 
68                          else: 
69                                  step_num[k] = 1 
70                                  params[k] = grid_ops[k][1] 
71   
72                  # Back calculate the current function value. 
73                  f = apply(func, (params,)+args) 
74   
75                  # Test if the current function value is less than the least function value. 
76                  if f < f_min: 
77                          f_min = f 
78                          min_params = copy.deepcopy(params) 
79   
80                          # Debugging code. 
81                          if print_flag: 
82                                  print "%-6s%-8i%-12s%-65s%-16s%-20s" % ("Step:", step, "Min params:", `min_params`, "Function value:", `f_min`) 
83   
84                  # Debugging code. 
85                  if print_flag == 2: 
86                          print "%-20s%-20i" % ("Step number:", step) 
87                          print "%-20s%-20s" % ("Increment:", `step_num`) 
88                          print "%-20s%-20s" % ("Params:", `params`) 
89                          print "%-20s%-20g" % ("Function value:", f) 
90                          print "%-20s%-20s" % ("Min params:", `min_params`) 
91                          print "%-20s%-20g\n" % ("Min f:", f_min) 
92   
93          return min_params, f_min, total_steps 
94