def initialize(deep_map, X,num_pseudo_params): smart_map = {} for layer,layer_map in deep_map.iteritems(): smart_map[layer] = {} for unit,gp_map in layer_map.iteritems(): smart_map[layer][unit] = {} cov_params = gp_map['cov_params'] lengthscales = cov_params[1:] if layer == 0: pairs = itertools.combinations(X, 2) dists = np.array([np.abs(p1-p2) for p1,p2 in pairs]) smart_lengthscales = np.array([np.log(np.median(dists[:,i])) for i in xrange(len(lengthscales))]) kmeans = KMeans(n_clusters = num_pseudo_params, init = 'k-means++') fit = kmeans.fit(X) smart_x0 = fit.cluster_centers_ #inds = npr.choice(len(X), num_pseudo_params, replace = False) #smart_x0 = np.array(X)[inds,:] smart_y0 = np.ndarray.flatten(smart_x0) #smart_y0 = np.array(y)[inds] smart_noise_scale = np.log(np.var(smart_y0)) else: smart_x0 = gp_map['x0'] smart_y0 = np.ndarray.flatten(smart_x0[:,0]) smart_lengthscales = np.array([np.log(1) for i in xrange(len(lengthscales))]) smart_noise_scale = np.log(np.var(smart_y0)) gp_map['cov_params'] = np.append(cov_params[0],smart_lengthscales) gp_map['x0'] = smart_x0 gp_map['y0'] = smart_y0 #gp_map['noise_scale'] = smart_noise_scale smart_map[layer][unit] = gp_map smart_params = pack_deep_params(smart_map) return smart_params
def fitMulticlass(self,X,y): self.X = np.array(X) #converting X to np array self.y = np.array(y) #converting y to np array self.X = np.append(np.ones((self.X.shape[0],1)),self.X,axis=1) self.totalFeatures = self.X.shape[1] self.theta= np.zeros((self.totalFeatures,y.shape[1])) for i in range(self.maxIterations): softP = self.softmax(self.X, self.theta) for j in range(self.y.shape[1]): val = np.exp(self.X.dot(self.theta[:,j]))/softP error = -(self.y[:,j]-val) self.theta[:,j] = self.theta[:,j]- (self.learningRate * error.dot(self.X))/self.X.shape[0] return self.theta
def predict(self, X): """ predicts according to the trained model X: samples return prediction """ self.X = X bias = np.ones((self.X.shape[0], 1)) self.X = np.append(bias, self.X, axis=1) self.X = np.array(self.X) Z = 1 / (1 + np.exp(-(self.X.dot(self.coef_)))) Y = np.round(Z) return Y
def step(self, action): #Y = self.obs(self.x) self.counter += 1 self.x, self.P, K = self.EKF(self.x, self.P, action) self.L = np.linalg.cholesky(self.P) ind_tril = np.tril_indices(self.L.shape[0]) done = self.terminal_state(self.x) reward = self.reward_func(action) self.state = np.append(self.x, self.L[ind_tril]) if self.counter > 256: done = True return self.state, reward, done, {}
def fparams(self): """ full parameter values Appends xi to params if the kernel uses xi Returns: np.array(float) - params.append(xi) """ if self.kernel.use_xi: return np.append(self.params, self.kernel.xi) else: return self.params
def dump_state(self, xk): ''' callback to save the state to disk during optimization ''' filename = 'state.txt' if not os.path.exists(filename): past = np.zeros((0, xk.shape[0])) else: past = np.loadtxt(filename) if past.ndim < 2: past = past.reshape(1, -1) np.savetxt(filename, np.append(past, xk.reshape(1, -1), axis=0))
def predict_multi(self, X): """ predict multiclass output X: samples """ bias = np.ones((X.shape[0], 1)) X = np.append(bias, X, axis=1) X = np.array(X) Z = 1 / (1 + np.exp(-(X.dot(self.coef_)))) Y = [] for i in Z: Y.append(np.argmax(i)) return Y
def __init__(self): self.counter = 0 self.targetUpdatefreq = 100 # Not being used self.max_action = 0.01 self.world_box = np.array([[5.0, 5.0], [-5.0, -5.0]]) #self.min_position = np.array([-5.0, -5.0]) self.xlow = np.append(self.world_box[1], [0., -1., -1.]) self.xhigh = np.append(self.world_box[0], [2*pi, 1., 1.]) self.low_state = np.append(self.xlow, -10*np.ones(15)) # self.high_state = np.append(self.xhigh, 10*np.ones(15)) # self.action_space = spaces.Box(-np.ones(2), np.ones(2)) self.observation_space = spaces.Box(self.low_state, self.high_state) self.viewer = None #self.state = self.observation_space.sample() self.noise = np.array([0.01]*5 + [0.2]*2) #std dt = 0.1 self.Q = np.eye(5) * (0.01**2) self.R = np.eye(2) * (0.2**2) self.P = np.eye(5) * (0.0001**2) self.Id = np.eye(5) # initialize state pos = random.uniform(self.world_box[0], self.world_box[1]) ang = math.atan2(pos[1], pos[1]) -pi + random.uniform(-pi/8, pi/8) ang %= 2*pi self.x = np.append(pos, [ang, 0., 0.]) self.L = np.linalg.cholesky(self.P) self.goal_position = np.array([0., 0.]) self.A = jacobian(self.dynamics) self.H = jacobian(self.obs) self.seed() self.reset()
def sdot( self, S, t, params, Cin ): # X is population vector, t is time, R is intrinsic growth rate vector, C is the rate limiting nutrient vector, A is interaction matrix ''' Calculates and returns derivatives for the numerical solver odeint Parameters: S: current state t: current time Cin: array of the concentrations of the auxotrophic nutrients and the common carbon source params: list parameters for all the equations num_species: the number of bacterial populations Returns: dsol: array of the derivatives for all state variables ''' # extract variables # autograd gives t as an array_box, need to convert to int if str( type(t) ) == '<class \'autograd.numpy.numpy_boxes.ArrayBox\'>': # sort this out t = t._value t = int(t) else: t = int(t) t = min(Cin.shape[0] - 1, t) # to prevent solver from going past the max time C0in = Cin[t] #C0in = Cin N = S[0] C0 = S[1] # extract parameters q = self.ode_params[0] y, Rmax = params[0:2] Km = self.ode_params[3] R = self.monod(C0, Rmax, Km) # calculate derivatives dN = N * (R.astype(float) - q) # q term takes account of the dilution dC0 = q * (C0in - C0) - 1 / y * R * N # consstruct derivative vector for odeint dC0 = np.array([dC0]) dsol = np.append(dN, dC0) return tuple(dsol)
def reward_func(self, action): R = np.eye(4) * 1.25 P_reduced = np.delete(self.P, 2, 0) P_reduced = np.delete(P_reduced, 2, 1) #P_reduced = P_reduced + np.eye(4)*1e-4 P_ = inv(P_reduced) S_ = inv(R) + P_ S = inv(S_) mu = np.append(self.x[:2], self.x[3:]) a = -0.5 * np.dot(mu.T.dot(P_ - np.dot(P_.dot(S), P_)), mu) reward = np.exp(a) * np.sqrt(np.linalg.det(S)/np.linalg.det(P_reduced)) #- np.sum(mu[:2]**2) #reward -= 1. reward -= -0.1*action[0]**2 + 1*action[1]**2 + 1. return reward
def gradient(self, params): # use the gradient if the model provides it. # if not, compute it using autograd. if not hasattr(self.mean, 'gradient'): _grad = lambda mean, argnum, params: jacobian(mean, argnum)(*params) else: _grad = lambda mean, argnum, params: mean.gradient(*params)[argnum] n_params = len(np.atleast_1d(params)) grad_likelihood = np.array([]) for i in range(n_params): grad = _grad(self.mean, i, params) grad_likelihood = np.append(grad_likelihood, np.nansum(grad * (1 - self.data / self.mean(*params)))) return grad_likelihood
def __init__(self, breakpoints, *args, **kwargs): breakpoints = np.sort(breakpoints) if not (breakpoints[-1] < np.inf): raise ValueError("Do not add inf to the breakpoints.") if breakpoints[0] < 0: raise ValueError("First breakpoint must be greater than 0.") self.breakpoints = np.append(breakpoints, [np.inf]) n_breakpoints = len(self.breakpoints) self._fitted_parameter_names = ["lambda_%d_" % i for i in range(n_breakpoints)] super(PiecewiseExponentialFitter, self).__init__(*args, **kwargs)
def __init__(self): self.counter = 0 self.episode_len = 1000 self.max_action = 1 self.world_box = np.array([[5.0, 5.0], [-5.0, -5.0]]) #self.min_position = np.array([-5.0, -5.0]) #self.xlow = np.append(self.world_box[1], [0., -1., -1.]) #self.xhigh = np.append(self.world_box[0], [2*pi, 1., 1.]) self.xlow = np.array([0., -pi, -1., -1.]) self.xhigh = np.array([8., pi, 1., 1.]) self.low_state = np.append(self.xlow, -5 * np.ones(15)) # self.high_state = np.append(self.xhigh, 5 * np.ones(15)) # self.action_space = spaces.Box(-np.ones(2), np.ones(2)) self.observation_space = spaces.Box(self.low_state, self.high_state) self.viewer = None #self.state = self.observation_space.sample() self.noise = np.array([0.01] * 5 + [0.1] * 2) #std self.dt = 0.1 self.Q = np.eye(5) * (0.01**2) self.R = np.eye(2) * (0.1**2) self.P = np.eye(5) * 0. self.Id = np.eye(5) self.A = jacobian(self.dynamics) self.H = jacobian(self.obs) self.goal_position = np.array([0., 0.]) self.goal_radius = 0.8 self.seed() self.reset()
def __init__(self, name='', length=1, matrix_size=2, diag_lb=0.0, val=None): self.name = name self.__matrix_size = int(matrix_size) self.__matrix_shape = np.array([ int(matrix_size), int(matrix_size) ]) self.__length = int(length) self.__shape = np.append(self.__length, self.__matrix_shape) # vec_size is the size of a single matrix in vector form. self.__vec_size = int(matrix_size * (matrix_size + 1) / 2) self.__diag_lb = diag_lb assert diag_lb >= 0 if val is None: default_val = np.diag(np.full(self.__matrix_size, diag_lb + 1.0)) self.__val = np.broadcast_to(default_val, self.__shape) else: self.set(val)
def l2_difference_minimisation(N, patterns, weights, biases, sc): ''' minimisation of || lmbd*W @ Z - Z|| ''' Z = deepcopy(patterns).T.reshape(N, -1) W = np.array([]) for i in range(N): A = Z.T b = Z[i, :] if sc == False: # add one more constraint to eliminate the diagonals tmp = np.zeros((1, N)) tmp[0, i] = 1 A = np.vstack([A, tmp]) b = np.append(b, 0) elif sc == True: pass else: raise AttributeError( 'The \'sc\' parameter can take only boolean values') w = lsqr(A, b)[0] W = np.append(W, w) weights = W.reshape(N, N) return weights, biases
def gradient_function(self, w): # separate w and w0 w0 = w[-1] w = w[:-1] eta = np.dot(self.x, w.T) + w0 grad_w = np.dot( np.where(eta > 30, self.y - 1, self.y - (np.exp(eta) / (1 + np.exp(eta)))), self.x) grad_w_0 = np.dot( np.where(eta > 30, self.y - 1, self.y - (np.exp(eta) / (1 + np.exp(eta)))), 1) print(grad_w_0) return np.append(grad_w, grad_w_0)
def grouping(self, solution): # grouping different groups in solution into one group if self.number_group > 1: # solution_help = np.zeros((solution.shape[0], 10)) # for i in range(10): # solution_help[:, i] = np.sum(solution[:, i * self.number_group:(i+1) * self.number_group], axis=1) # solution = solution_help solution_help = [] for i in range(10): solution_help = np.append(solution_help, np.sum(solution[:, i * self.number_group:(i+1) * self.number_group], axis=1)) solution = np.reshape(solution_help, (10, solution.shape[0])).T return solution
def __init__(self, breakpoints, alpha=0.05, penalizer=0.0): super(PiecewiseExponentialRegressionFitter, self).__init__(alpha=alpha) breakpoints = np.sort(breakpoints) if len(breakpoints) and not (breakpoints[-1] < np.inf): raise ValueError("Do not add inf to the breakpoints.") if len(breakpoints) and breakpoints[0] < 0: raise ValueError("First breakpoint must be greater than 0.") self.breakpoints = np.append(breakpoints, [np.inf]) self.n_breakpoints = len(self.breakpoints) self.penalizer = penalizer self._fitted_parameter_names = ["lambda_%d_" % i for i in range(self.n_breakpoints)]
def fit_autograd(self, X, y): self.X = np.array(X) #converting X to np array self.y = np.array(y) #converting y to np array self.X = np.append(np.ones((self.X.shape[0],1)),self.X,axis=1) #appending columns of ones self.theta = np.random.rand(self.X.shape[1])#np.ones(self.X.shape[1])# agrad = elementwise_grad(self.costFunctionUnregularised) agrad1 = elementwise_grad(self.costFunctionL1Regularised) agrad2 = elementwise_grad(self.costFunctionL2Regularised) for iterationNum in range(self.maxIterations): if self.regularization == 'l1': self.theta -= (self.learningRate*(agrad1(self.theta, self.X, self.y))) /(self.X.shape[0]) elif self.regularization == 'l2': self.theta -= (self.learningRate*(agrad2(self.theta, self.X, self.y))) /(self.X.shape[0]) else: self.theta -= (self.learningRate*(agrad(self.theta, self.X, self.y))) /(self.X.shape[0]) return self.theta
def chebyshev_centre(A, b, gamma): rows, cols = A.shape c = np.zeros(cols + 1) c[-1] = -1 A_ = np.hstack([A, np.sqrt(np.sum(np.power(A, 2), axis=1)).reshape(-1, 1)]) A_ = np.vstack([A_, -c.reshape(1, -1)]) b_ = np.append(b, 100).reshape(-1, 1) # l2 norm minimisation of w P = gamma * np.eye(cols + 1) P[:, -1] = P[-1, :] = 0 res = solve_qp(P=P, q=c, G=A_, h=b_) x_c = np.array(res[:-1]) R = np.float(res[-1]) return x_c, R
def run_nn(N, input_size, output_size): integer_part = int(np.floor(N[0])) alpha = N[0] - integer_part # Network parameters layer_sizes = [input_size] layer_sizes.extend([output_size for i in range(0, integer_part - 1)]) L2_reg = 1.0 # Training parameters param_scale = 0.1 # Load and process wines data N_data, train_images, train_labels, test_images, test_labels = get_wine_data() batch_size = len(train_images) # Make neural net functions N_weights, pred_fun, loss_fun, frac_err = make_nn_funs(layer_sizes, L2_reg) # Gradient with respect to weights and alpha loss_grad_P = grad(loss_fun, 0) # Initialize weights rs = npr.RandomState(11) W = rs.randn(N_weights) * param_scale print(" Train err | Test err | Alpha") f_out = open(filename, 'w') f_out.write(" Train err | Test err | Alpha\n") f_out.close() def print_perf(params): f_out = open(filename, 'a') test_perf = frac_err(params, test_images, test_labels) train_perf = frac_err(params, train_images, train_labels) print("{0:15}|{1:15}|{2:15}".format(train_perf, test_perf, params[-1])) f_out.write("{0:15}|{1:15}|{2:15}\n".format(train_perf, test_perf, params[-1])) f_out.close() # Minimize with BFGS res = optimize.minimize(loss_fun, np.append(W, alpha), jac=loss_grad_P, method='L-BFGS-B', \ args=(train_images, train_labels), options={'disp': True, 'maxiter': 2}) print(res) final_test_err = frac_err(res.x, train_images, train_labels) print(N[0], final_test_err) return final_test_err
def __init__(self, name='', array_shape=(1), matrix_size=2, diag_lb=0.0, val=None): self.name = name self.__matrix_size = int(matrix_size) self.__matrix_shape = np.array([ int(matrix_size), int(matrix_size) ]) self.__array_shape = array_shape self.__array_ranges = [ range(0, t) for t in self.__array_shape ] self.__array_length = np.prod(self.__array_shape) self.__shape = np.append(self.__array_shape, self.__matrix_shape) # __vec_size is the size of a single matrix in vector form. self.__vec_size = int(matrix_size * (matrix_size + 1) / 2) self.__diag_lb = diag_lb assert diag_lb >= 0 if val is None: default_val = np.diag(np.full(self.__matrix_size, diag_lb + 1.0)) self.__val = np.broadcast_to(default_val, self.__shape) else: self.set(val)
def __init__(self, breakpoints, *args, **kwargs): if (breakpoints is None) or (not list(breakpoints)): raise ValueError("Breakpoints must be provided.") if not (max(breakpoints) < np.inf): raise ValueError("Do not add inf to the breakpoints.") if min(breakpoints) <= 0: raise ValueError("First breakpoint must be greater than 0.") breakpoints = np.sort(breakpoints) self.breakpoints = np.append(breakpoints, [np.inf]) n_breakpoints = len(self.breakpoints) self._fitted_parameter_names = ["lambda_%d_" % i for i in range(n_breakpoints)] super(PiecewiseExponentialFitter, self).__init__(*args, **kwargs)
def __init__(self, breakpoints, alpha=0.05, penalizer=0.0, fit_intercept=True): super(PiecewiseExponentialRegressionFitter, self).__init__(alpha=alpha) breakpoints = np.sort(breakpoints) if len(breakpoints) and not (breakpoints[-1] < np.inf): raise ValueError("Do not add inf to the breakpoints.") if len(breakpoints) and breakpoints[0] < 0: raise ValueError("First breakpoint must be greater than 0.") self.breakpoints = np.append(breakpoints, [np.inf]) self.n_breakpoints = len(self.breakpoints) self._hazard = egrad(self._cumulative_hazard, argnum=1) # pylint: disable=unexpected-keyword-arg self.penalizer = penalizer self.fit_intercept = fit_intercept self._fitted_parameter_names = ["lambda_%d_" % i for i in range(self.n_breakpoints)]
def compute_restricted_hessian_and_dParamsdWeights(self, dims, weights, comp_dParams_dWeights=True): ''' Computes the dims.shape[0] by dims.shape[0] Hessian only along the entries in dims (used when using l_1 regularization) ''' theta0 = self.params.get_free() # Objective to differentiate just along the dimensions specified def lowDimObj(weights, thetaOnDims, thetaOffDims, invPerm): allDims = np.append(dims, offDims) thetaFull = np.append(thetaOnDims, thetaOffDims)[invPerm] return self.weighted_model_objective(weights, thetaFull) offDims = np.setdiff1d(np.arange(self.params.get_free().shape[0]), dims) thetaOnDims = theta0[dims] thetaOffDims = theta0[offDims] # lowDimObj will concatenate thetaOnDims, thetaOffDims, then needs to # un-permute them into the original theta. allDims = np.append(dims, offDims) invPerm = np.zeros(theta0.shape[0], dtype=np.int32) for i, idx in enumerate(allDims): invPerm[idx] = i evalHess = autograd.hessian(lowDimObj, argnum=1) array_box_go_away = self.params.get_free().copy() restricted_hess = evalHess(weights, thetaOnDims, thetaOffDims, invPerm) self.params.set_free(theta0) dObj_dParams = autograd.jacobian(lowDimObj, argnum=1) d2Obj_dParamsdWeights = autograd.jacobian(dObj_dParams, argnum=0) if comp_dParams_dWeights: restricted_dParamsdWeights = d2Obj_dParamsdWeights(weights, thetaOnDims, thetaOffDims, invPerm) return restricted_hess, restricted_dParamsdWeights else: return restricted_hess
def predict_cumulative_hazard(self, df, times=None, conditional_after=None) -> pd.DataFrame: """ Return the cumulative hazard rate of subjects in X at time points. Parameters ---------- X: numpy array or DataFrame a (n,d) covariate numpy array or DataFrame. If a DataFrame, columns can be in any order. If a numpy array, columns must be in the same order as the training data. times: iterable, optional an iterable of increasing times to predict the cumulative hazard at. Default is the set of all durations (observed and unobserved). Uses a linear interpolation if points in time are not in the index. Returns ------- cumulative_hazard_ : DataFrame the cumulative hazard of individuals over the timeline """ if isinstance(df, pd.Series): return self.predict_cumulative_hazard(df.to_frame().T) if conditional_after is not None: raise NotImplementedError() times = np.atleast_1d( coalesce(times, self.timeline, np.unique(self.durations))).astype(float) n = times.shape[0] times = times.reshape((n, 1)) lambdas_ = self._prep_inputs_for_prediction_and_return_parameters(df) bp = np.append(self.breakpoints, [np.inf]) M = np.minimum(np.tile(bp, (n, 1)), times) M = np.hstack([M[:, tuple([0])], np.diff(M, axis=1)]) return pd.DataFrame(np.dot(M, (1 / lambdas_)), columns=_get_index(df), index=times[:, 0])
def simple_contour(f, c=0, delta=0.01): '''Donne les coordonnées demandées sur un cadre de côté unitaire de manière optimisée''' x = np.array([]) y = np.array([]) def g(x): return (f(0, x)) if find_seed(g, c) == None: return x, y y = np.append(y, np.array([find_seed(g, c)])) x = np.append(x, np.array([0])) grad = gradient(f, x[-1], y[-1]) tang = [-grad[1], grad[0]] print(tang) if tang[0] < 0: tang = [grad[1], -grad[0]] while x[-1] <= 1 and y[-1] <= 1 and x[-1] >= 0 and y[-1] >= 0: grad = gradient(f, x[-1], y[-1]) tang = [grad[1], -grad[0]] norme = math.sqrt(tang[0]**2 + tang[1]**2) x = np.append(x, np.array(x[-1] + (delta * tang[0]) / (norme))) y = np.append(y, np.array(y[-1] + (delta * tang[1]) / (norme))) def F( x, y ): #On définit la fonction F pour les deux derniers points trouvés return np.array( [f(x, y) - c, (x - x[-2])**2 + (y - y[-2])**2 - delta**2]) res = newton( F, np.array([x[-1], y[-1]]) ) #On applique Newton: ATTENTION, un problème non résolu apparait lors de l'éxécution de autograd.jacobian x[-1], y[-1] = res[0], res[1] else: tang = [-grad[1], grad[0]] while x[-1] <= (1) and y[-1] <= (1) and x[-1] >= 0 and y[-1] >= 0: grad = gradient(f, x[-1], y[-1]) tang = [-grad[1], grad[0]] norme = math.sqrt(tang[0]**2 + tang[1]**2) x = np.append(x, np.array(x[-1] + (delta * tang[0]) / (norme))) y = np.append(y, np.array(y[-1] + (delta * tang[1]) / (norme))) def F(x, y): return np.array( [f(x, y) - c, (x - x[-2])**2 + (y - y[-2])**2 - delta**2]) res = newton(F, np.array([x[-1], y[-1]])) x[-1], y[-1] = res[0], res[1] return x, y
def forward(self, model, x_traj, u_traj, k_traj, K_traj, alpha): x_traj_new = np.array(x_traj) u_traj_new = np.array(u_traj) for t in range(len(u_traj)): control = alpha**t * k_traj[t] + np.matmul( K_traj[t], (x_traj_new[t] - x_traj[t])) u_traj_new[t] = np.clip(u_traj[t] + control, -2, 2) # Create the vector of observations X={x,u} observations = np.array([np.append(x_traj_new[t], u_traj_new[t])]) # Comment for Task 4 test_predict = x_traj_new[t] + model.predict(observations) # TODO Task 4: use the dynamics of the system instead of the learned model compute the next state -- DONE x_traj_new[t + 1] = test_predict # x_traj_new[t + 1] = self.f(x_traj_new[t], u_traj_new[t]) return x_traj_new, u_traj_new
def cost(S, v): # Unpack parameters nu = np.append(v, 0) logdetS = np.expand_dims(np.linalg.slogdet(S)[1], 1) y = np.concatenate([samples.T, np.ones((1, N))], axis=0) # Calculate log_q y = np.expand_dims(y, 0) # 'Probability' of y belonging to each cluster log_q = -0.5 * (np.sum(y * np.linalg.solve(S, y), axis=1) + logdetS) alpha = np.exp(nu) alpha = alpha / np.sum(alpha) alpha = np.expand_dims(alpha, 1) loglikvec = logsumexp(np.log(alpha) + log_q, axis=0) return -np.sum(loglikvec)
def init_yields(self, quiet=False): nf = len(self.KL_amplitude_files) npar = len(self.param_sets) total_yields = nf * npar if not quiet: print "Making yields for bias study:" print " # of params : {}".format(npar) print " # of A(KL)'s : {}".format(nf) print " # TOTAL yield sets : {}".format(total_yields) yield_n = 0 if not quiet: print(" Yield gen: {}/{}".format(yield_n, total_yields)) for fi, f in enumerate(self.KL_amplitude_files): self.generator_model.load_KL_amplitude(f) for pi, p in enumerate(self.param_sets): physics_param = p sys.stdout.write("\033[F") #back to previous line sys.stdout.write("\033[K") #clear line yield_n += 1 if not quiet: print(" Yield gen: {}/{}".format(yield_n, total_yields)) if len(p) == 3: # single channel setup avg_yields = self.generator_model.predict_yields( p, self.N_signal[0] ) # Yields calculated using FullModel.py elif len(p) == 5: # two channel channel setup avg_yields_ch1 = self.generator_model.predict_yields( p[0:3], self.N_signal[0] ) # Yields calculated using FullModel.py avg_yields_ch2 = self.generator_model.predict_yields( [p[0], p[3], p[4]], self.N_signal[1] ) # Yields calculated using FullModel.py avg_yields = np.append(avg_yields_ch1, avg_yields_ch2) self.yields["{}_{}".format(fi, pi)] = avg_yields self.yields_init = True
def fit(self, X, y): """ trains the model X: samples y: labels returns trained weights """ self.X = X.copy() bias = np.ones((self.X.shape[0], 1)) self.X = np.append(bias, self.X, axis=1) # Include Bais self.X = np.array(self.X) self.y = y self.nofFeatures = len(self.X[0]) self.samples = len(self.X) self.coef_ = np.ones(self.nofFeatures) # init features for i in range(self.epoch): err = self.sigmoid(self.X.dot(self.coef_)) - y # error self.coef_ = self.coef_ - self.lr * (err).dot(self.X) # coef return self.coef_
def yields_chi_square(self, xy_and_Fi, *args): ''' The function to me minimized when fitting x, y, is the chi-square xy_Fi: a list with elements [{Fi}, xm, ym, xp, yp] data: The yields to which the fit is being made ''' data = args[0] Nplus = sum(data[0:len(data)/2]) # B+ Nminus = sum(data[len(data)/2:]) # B- xy = xy_and_Fi[0:4] Fi = xy_and_Fi[4:] Fi = np.append(Fi, 1-sum(Fi)) predictions = self.predict_yields(xy, Nplus, Nminus, Fi=Fi) uncertainty_squared = data for i, u in enumerate(uncertainty_squared): if u==0: uncertainty_squared[i]=1 # make sure there are no divisions by zero minLL = np.sum(0.5*(data - predictions)**2/uncertainty_squared) # least squares fit return minLL
f_out.close() def print_perf(params): f_out = open(filename, 'a') test_perf = frac_err(params, test_images, test_labels) train_perf = frac_err(params, train_images, train_labels) print("{0:15}|{1:15}|{2:15}".format(train_perf, test_perf, params[-1])) f_out.write("{0:15}|{1:15}|{2:15}\n".format(train_perf, test_perf, params[-1])) f_out.close() # Minimize with BFGS num_iterations = [] train_errors = [] test_errors = [] for i in range(0, 100): optimize.minimize(loss_fun, np.append(W, alpha), jac=loss_grad_P, method='L-BFGS-B', \ args=(train_images, train_labels), options={'disp': True}, callback=print_perf) training_error = 0. test_error = 0. with open(filename, 'r') as input_file: next(input_file) curr_iteration = 0 for line in input_file: data_as_string = line.split('|') data = map(float, data_as_string) training_error = data[0] test_error = data[1] curr_iteration += 1 num_iterations.append(curr_iteration)
def minConf_SPG(funObj, x, funProj, options=None): """ This function implements Mark Schmidt's MATLAB implementation of spectral projected gradient (SPG) to solve for projected quasi-Newton direction min funObj(x) s.t. x in C Parameters ---------- funObj: function that returns objective function value and the gradient x: initial parameter value funProj: fcuntion that returns projection of x onto C options: verbose: level of verbosity (0: no output, 1: final, 2: iter (default), 3: debug) optTol: tolerance used to check for optimality (default: 1e-5) progTol: tolerance used to check for lack of progress (default: 1e-9) maxIter: maximum number of calls to funObj (default: 500) numDiff: compute derivatives numerically (0: use user-supplied derivatives (default), 1: use finite differences, 2: use complex differentials) suffDec: sufficient decrease parameter in Armijo condition (default : 1e-4) interp: type of interpolation (0: step-size halving, 1: quadratic, 2: cubic) memory: number of steps to look back in non-monotone Armijo condition useSpectral: use spectral scaling of gradient direction (default: 1) curvilinear: backtrack along projection Arc (default: 0) testOpt: test optimality condition (default: 1) feasibleInit: if 1, then the initial point is assumed to be feasible bbType: type of Barzilai Borwein step (default: 1) Notes: - if the projection is expensive to compute, you can reduce the number of projections by setting testOpt to 0 """ nVars = x.shape[0] options_default = {'verbose':2, 'numDiff':0, 'optTol':1e-5, 'progTol':1e-9,\ 'maxIter':500, 'suffDec':1e-4, 'interp':2, 'memory':10,\ 'useSpectral':1,'curvilinear':0,'feasibleInit':0,'testOpt':1,\ 'bbType':1} options = setDefaultOptions(options, options_default) if options['verbose'] >= 2: if options['testOpt'] == 1: print '{:10s}'.format('Iteration') + \ '{:10s}'.format('FunEvals') + \ '{:10s}'.format('Projections') + \ '{:15s}'.format('StepLength') + \ '{:15s}'.format('FunctionVal') + \ '{:15s}'.format('OptCond') else: print '{:10s}'.format('Iteration') + \ '{:10s}'.format('FunEvals') + \ '{:10s}'.format('Projections') + \ '{:15s}'.format('StepLength') + \ '{:15s}'.format('FunctionVal') funEvalMultiplier = 1 # evaluate initial point if options['feasibleInit'] == 0: x = funProj(x) [f, g] = funObj(x) projects = 1 funEvals = 1 # optionally check optimality if options['testOpt'] == 1: projects = projects + 1 if np.max(np.abs(funProj(x-g)-x)) < options['optTol']: if options['verbose'] >= 1: print "First-order optimality conditions below optTol at initial point" return (x, f, funEvals, projects) i = 1 while funEvals <= options['maxIter']: # compute step direction if i == 1 or options['useSpectral'] == 0: alpha = 1. else: y = g - g_old s = x - x_old if options['bbType'] == 1: alpha = np.dot(s,s)/np.dot(s,y) else: alpha = np.dot(s,y)/np.dot(y,y) if alpha <= 1e-10 or alpha >= 1e10: alpha = 1. d = -alpha * g f_old = f x_old = x g_old = g # compute projected step if options['curvilinear'] == 0: d = funProj(x+d) - x projects = projects + 1 # check that progress can be made along the direction gtd = np.dot(g, d) if gtd > -options['progTol']: if options['verbose'] >= 1: print "Directional derivtive below progTol" break # select initial guess to step length if i == 1: t = np.minimum(1., 1./np.sum(np.abs(g))) else: t = 1. # compute reference function for non-monotone condition if options['memory'] == 1: funRef = f else: if i == 1: old_fvals = np.ones(options['memory'])*(-1)*np.infty if i <= options['memory']: old_fvals[i-1] = f else: old_fvals = np.append(old_fvals[1:], f) funRef = np.max(old_fvals) # evaluate the objective and gradient at the initial step if options['curvilinear'] == 1: x_new = funProj(x + t*d) projects = projects + 1 else: x_new = x + t*d [f_new, g_new] = funObj(x_new) funEvals = funEvals + 1 # Backtracking line search lineSearchIters = 1 while f_new > funRef + options['suffDec']*np.dot(g,x_new-x) or \ isLegal(f_new) == False: temp = t if options['interp'] == 0 or isLegal(f_new) == False: if options['verbose'] == 3: print 'Halving step size' t = t/2. elif options['interp'] == 2 and isLegal(g_new): if options['verbose'] == 3: print "Cubic Backtracking" t = polyinterp(np.array([[0,f,gtd],\ [t,f_new,np.dot(g_new,d)]]))[0] elif lineSearchIters < 2 or isLegal(f_prev): if options['verbose'] == 3: print "Quadratic Backtracking" t = polyinterp(np.array([[0, f, gtd],\ [t, f_new, np.complex(0,1)]]))[0] else: if options['verbose'] == 3: print "Cubic Backtracking on Function Values" t = polyinterp(np.array([[0., f, gtd],\ [t,f_new,np.complex(0,1)],\ [t_prev,f_prev,np.complex(0,1)]]))[0] # adjust if change is too small if t < temp*1e-3: if options['verbose'] == 3: print "Interpolated value too small, Adjusting" t = temp * 1e-3 elif t > temp * 0.6: if options['verbose'] == 3: print "Interpolated value too large, Adjusting" t = temp * 0.6 # check whether step has become too small if np.max(np.abs(t*d)) < options['progTol'] or t == 0: if options['verbose'] == 3: print "Line Search failed" t = 0. f_new = f g_new = g break # evaluate new point f_prev = f_new t_prev = temp if options['curvilinear'] == True: x_new = funProj(x + t*d) projects = projects + 1 else: x_new = x + t*d [f_new, g_new] = funObj(x_new) funEvals = funEvals + 1 lineSearchIters = lineSearchIters + 1 # done with line search # take step x = x_new f = f_new g = g_new if options['testOpt'] == True: optCond = np.max(np.abs(funProj(x-g)-x)) projects = projects + 1 # output log if options['verbose'] >= 2: if options['testOpt'] == True: print '{:10d}'.format(i) + \ '{:10d}'.format(funEvals*funEvalMultiplier) + \ '{:10d}'.format(projects) + \ '{:15.5e}'.format(t) + \ '{:15.5e}'.format(f) + \ '{:15.5e}'.format(optCond) else: print '{:10d}'.format(i) + \ '{:10d}'.format(funEvals*funEvalMultiplier) + \ '{:10d}'.format(projects) + \ '{:15.5e}'.format(t) + \ '{:15.5e}'.format(f) # check optimality if options['testOpt'] == True: if optCond < options['optTol']: if options['verbose'] >= 1: print "First-order optimality conditions below optTol" break if np.max(np.abs(t*d)) < options['progTol']: if options['verbose'] >= 1: print "Step size below progTol" break if np.abs(f-f_old) < options['progTol']: if options['verbose'] >= 1: print "Function value changing by less than progTol" break if funEvals*funEvalMultiplier > options['maxIter']: if options['verbose'] >= 1: print "Function evaluation exceeds maxIter" break i = i + 1 return (x, f, funEvals, projects)
def polyinterp(points, doPlot=None, xminBound=None, xmaxBound=None): """ polynomial interpolation Parameters ---------- points: shape(pointNum, 3), three columns represents x, f, g doPolot: set to 1 to plot, default 0 xmin: min value that brackets minimum (default: min of points) xmax: max value that brackets maximum (default: max of points) set f or g to sqrt(-1)=1j if they are not known the order of the polynomial is the number of known f and g values minus 1 Returns ------- minPos: fmin: """ if doPlot == None: doPlot = 0 nPoints = points.shape[0] order = np.sum(np.imag(points[:, 1:3]) == 0) -1 # code for most common case: cubic interpolation of 2 points if nPoints == 2 and order == 3 and doPlot == 0: [minVal, minPos] = [np.min(points[:,0]), np.argmin(points[:,0])] notMinPos = 1 - minPos d1 = points[minPos,2] + points[notMinPos,2] - 3*(points[minPos,1]-\ points[notMinPos,1])/(points[minPos,0]-points[notMinPos,0]) t_d2 = d1**2 - points[minPos,2]*points[notMinPos,2] if t_d2 > 0: d2 = np.sqrt(t_d2) else: d2 = np.sqrt(-t_d2) * np.complex(0,1) if np.isreal(d2): t = points[notMinPos,0] - (points[notMinPos,0]-points[minPos,0])*\ ((points[notMinPos,2]+d2-d1)/(points[notMinPos,2]-\ points[minPos,2]+2*d2)) minPos = np.min([np.max([t,points[minPos,0]]), points[notMinPos,0]]) else: minPos = np.mean(points[:,0]) fmin = minVal return (minPos, fmin) xmin = np.min(points[:,0]) xmax = np.max(points[:,0]) # compute bounds of interpolation area if xminBound == None: xminBound = xmin if xmaxBound == None: xmaxBound = xmax # constraints based on available function values A = np.zeros((0, order+1)) b = np.zeros((0, 1)) for i in range(nPoints): if np.imag(points[i,1]) == 0: constraint = np.zeros(order+1) for j in np.arange(order,-1,-1): constraint[order-j] = points[i,0]**j A = np.vstack((A, constraint)) b = np.append(b, points[i,1]) # constraints based on availabe derivatives for i in range(nPoints): if np.isreal(points[i,2]): constraint = np.zeros(order+1) for j in range(1,order+1): constraint[j-1] = (order-j+1)* points[i,0]**(order-j) A = np.vstack((A, constraint)) b = np.append(b,points[i,2]) # find interpolating polynomial params = np.linalg.solve(A, b) # compute critical points dParams = np.zeros(order) for i in range(params.size-1): dParams[i] = params[i] * (order-i) if np.any(np.isinf(dParams)): cp = np.concatenate((np.array([xminBound, xmaxBound]), points[:,0])) else: cp = np.concatenate((np.array([xminBound, xmaxBound]), points[:,0], \ np.roots(dParams))) # test critical points fmin = np.infty; minPos = (xminBound + xmaxBound)/2. for xCP in cp: if np.imag(xCP) == 0 and xCP >= xminBound and xCP <= xmaxBound: fCP = np.polyval(params, xCP) if np.imag(fCP) == 0 and fCP < fmin: minPos = np.double(np.real(xCP)) fmin = np.double(np.real(fCP)) # plot situation (omit this part for now since we are not going to use it # anyway) return (minPos, fmin)
def pack_gp_params(mean, cov_params, noise_scale, x0, y0): params = np.append(mean,noise_scale) params = np.concatenate([params,cov_params]) params = np.concatenate([params,np.ndarray.flatten(np.array(x0))]) params = np.concatenate([params,np.ndarray.flatten(np.array(y0))]) return params
layer_gp_params = unpack_layer_params[layer](layer_params) for dim in xrange(dimensions[layer+1]): gp_params = layer_gp_params[dim] mean, cov_params, noise_scale, x0, y0 = unpack_gp_params_all[layer][dim](gp_params) lengthscales = cov_params[1:] if layer == 0: pairs = itertools.combinations(X, 2) dists = np.array([np.abs(p1-p2) for p1,p2 in pairs]) smart_lengthscales = np.array([np.log(np.median(dists[:,i])) for i in xrange(len(lengthscales))]) smart_x0 = np.array(X)[rs.choice(len(X), num_pseudo_params, replace=False),:] smart_y0 = np.ndarray.flatten(smart_x0) else: smart_x0 = x0 smart_y0 = np.ndarray.flatten(x0) smart_lengthscales = np.array([np.log(1) for i in xrange(len(lengthscales))]) cov_params = np.append(cov_params[0],smart_lengthscales) params = pack_gp_params_all[layer][dim](mean, cov_params, noise_scale, smart_x0, smart_y0) smart_params = np.append(smart_params, params) init_params = smart_params print("Optimizing covariance parameters...") objective = lambda params: -log_likelihood(params) params = minimize(value_and_grad(objective), init_params, jac=True, method='BFGS', callback=callback) plt.pause(10.0)
#Correct def KL_via_sampling(params,a2,b2,U): a1 = params[0] b1 = params[1] theta = generate_kumaraswamy(params,U) E = np.log(kumaraswamy_pdf(theta,params)/kumaraswamy_pdf(theta,np.array([a2,b2]))) E = np.mean(E) return E if __name__=='__main__': n = 100 k = 80 params = np.random.uniform(10,100,2) params = np.append(params,1.) m = np.array([0.,0.,0.]) v = np.array([0.,0.,0.]) for i in range(50000): params,m,v = iterate(params,n,k,i,m,v) if i%100==0: print params #print m,v #U1=np.random.uniform(0,1,100) #U2=np.random.uniform(0,1,100) #U3=np.random.uniform(0,1,n) #print lower_bound(params,n,k,U1,U2,U3) print params plt.clf() print "true mean" print (k+1.)/(n+2.)
def pack_gp_params(gp_details): params = np.append(gp_details["mean"], gp_details["noise_scale"]) params = np.concatenate([params, gp_details["cov_params"]]) params = np.concatenate([params, np.ndarray.flatten(np.array(gp_details["x0"]))]) params = np.concatenate([params, np.ndarray.flatten(np.array(gp_details["y0"]))]) return params
def pack_gp_params(gp_details): params = np.append(gp_details['mean'],gp_details['noise_scale']) params = np.concatenate([params,gp_details['cov_params']]) params = np.concatenate([params,np.ndarray.flatten(np.array(gp_details['x0']))]) params = np.concatenate([params,np.ndarray.flatten(np.array(gp_details['y0']))]) return params