linear_operators.iterative.optimize

1 """ 2 Wraps scipy.optimize.fmin_* algorithms using Criterion instances. 3 """ 4 from copy import copy 5 import numpy as np 6 import scipy.optimize as opt 7

8 -class FminWrapper(object):

9 """ 10 Abstract class to generate wrappers around scipy.optimize fmin_* 11 functions. 12 13 Parameters 14 ----------- 15 16 criterion : Criterion 17 A criterion function with __call__ and gradient methods. 18 x0 : ndarray (None) 19 First guess 20 args=() : tuple 21 Extra arguments for the criterion function 22 kwargs : dict 23 Parameters of the fmin_function 24 25 fmin function docstring 26 ------------------------ 27 """

28 - def __init__(self, criterion, x0=None, *args, **kwargs):

29 self.criterion = criterion 30 self.gradient = getattr(criterion, "gradient", None) 31 self.hessian = getattr(criterion, "hessian", None) 32 self.hessian_p = getattr(criterion, "hessian_p", None) 33 self.n_variables = criterion.n_variables 34 self.args = args 35 self.kwargs = kwargs 36 self.first_guess(x0) 37 # to store solution 38 self.current_solution = None 39 self.optimizer_output = None

40 - def first_guess(self, x0=None):

41 """ 42 Sets current_solution attribute to initial value. 43 """ 44 if x0 is None: 45 self.current_solution = np.zeros(self.n_variables) 46 else: 47 self.current_solution = copy(x0)

48

49 -class FminCOBYLA(FminWrapper):

50 __doc__ = FminWrapper.__doc__ + opt.fmin_cobyla.__doc__

51 - def __init__(self, criterion, cons, x0=None, *args, **kwargs):

52 self.cons = cons 53 FminWrapper.__init__(self, criterion, x0=x0, *args, **kwargs)

54 - def __call__(self):

55 self.first_guess() 56 self.current_solution = opt.fmin_cobyla(self.criterion, 57 self.current_solution, 58 self.cons, 59 args=self.args, 60 **self.kwargs) 61 # output depends on kwargs ... 62 if isinstance(self.optimizer_output, tuple): 63 self.current_solution = self.optimizer_output[0] 64 else: 65 self.current_solution = self.optimizer_output 66 return self.current_solution

67

68 -class FminPowell(FminWrapper):

69 __doc__ = FminWrapper.__doc__ + opt.fmin_powell.__doc__

70 - def __call__(self):

71 self.first_guess() 72 self.optimizer_output = opt.fmin_powell(self.criterion, 73 self.current_solution, 74 args=self.args, 75 **self.kwargs) 76 # output depends on kwargs ... 77 if isinstance(self.optimizer_output, tuple): 78 self.current_solution = self.optimizer_output[0] 79 else: 80 self.current_solution = self.optimizer_output 81 return self.current_solution

82

83 -class FminCG(FminWrapper):

84 __doc__ = FminWrapper.__doc__ + opt.fmin_cg.__doc__

85 - def __call__(self):

86 self.first_guess() 87 self.optimizer_output = opt.fmin_cg(self.criterion, 88 self.current_solution, 89 fprime=self.gradient, 90 args=self.args, 91 **self.kwargs) 92 # output depends on kwargs ... 93 if isinstance(self.optimizer_output, tuple): 94 self.current_solution = self.optimizer_output[0] 95 else: 96 self.current_solution = self.optimizer_output 97 return self.current_solution

98

99 -class FminTNC(FminWrapper):

100 __doc__ = FminWrapper.__doc__ + opt.fmin_tnc.__doc__

101 - def __call__(self):

102 self.first_guess() 103 self.optimizer_output = opt.fmin_tnc(self.criterion, 104 self.current_solution, 105 fprime=self.gradient, 106 args=self.args, 107 **self.kwargs) 108 # output depends on kwargs ... 109 if isinstance(self.optimizer_output, tuple): 110 self.current_solution = self.optimizer_output[0] 111 else: 112 self.current_solution = self.optimizer_output 113 return self.current_solution

114

115 -class FminNCG(FminWrapper):

116 __doc__ = FminWrapper.__doc__ + opt.fmin_ncg.__doc__

117 - def __call__(self):

118 self.first_guess() 119 self.optimizer_output = opt.fmin_ncg(self.criterion, 120 self.current_solution, 121 fprime=self.gradient, 122 fhess_p=self.hessian_p, 123 args=self.args, 124 **self.kwargs) 125 # output depends on kwargs ... 126 if isinstance(self.optimizer_output, tuple): 127 self.current_solution = self.optimizer_output[0] 128 else: 129 self.current_solution = self.optimizer_output 130 return self.current_solution

131

132 -class FminLBFGSB(FminWrapper):

133 __doc__ = FminWrapper.__doc__ + opt.fmin_l_bfgs_b.__doc__

134 - def __call__(self):

135 self.first_guess() 136 self.optimizer_output = opt.fmin_l_bfgs_b(self.criterion, 137 self.current_solution, 138 fprime=self.gradient, 139 args=self.args, 140 **self.kwargs) 141 # output depends on kwargs ... 142 if isinstance(self.optimizer_output, tuple): 143 self.current_solution = self.optimizer_output[0] 144 else: 145 self.current_solution = self.optimizer_output 146 return self.current_solution

147

148 -class FminSLSQP(FminWrapper):

149 __doc__ = FminWrapper.__doc__ + opt.fmin_slsqp.__doc__

150 - def __call__(self):

151 self.first_guess() 152 self.optimizer_output = opt.fmin_slsqp(self.criterion, 153 self.current_solution, 154 fprime=self.gradient, 155 args=self.args, 156 **self.kwargs) 157 158 # output depends on kwargs ... 159 if isinstance(self.optimizer_output, tuple): 160 self.current_solution = self.optimizer_output[0] 161 else: 162 self.current_solution = self.optimizer_output 163 return self.current_solution

164

165 -class FminBFGS(FminWrapper):

166 __doc__ = FminWrapper.__doc__ + opt.fmin_bfgs.__doc__

167 - def __call__(self):

168 self.first_guess() 169 self.optimizer_output = opt.fmin_bfgs(self.criterion, 170 self.current_solution, 171 fprime=self.gradient, 172 args=self.args, 173 **self.kwargs) 174 # output depends on kwargs ... 175 if isinstance(self.optimizer_output, tuple): 176 self.current_solution = self.optimizer_output[0] 177 else: 178 self.current_solution = self.optimizer_output 179 return self.current_solution

180

Source Code for Module linear_operators.iterative.optimize