def test_array1(self): """ Tests functions with single numpy 1d array output """ def f1(x): # single scalar input return np.array([i*x**i for i in range(5)]) df = jacobian(f1)(3.0) for i, d in enumerate(df): self.assertAlmostEqual(i**2 * 3.0 ** (i - 1), d) def f2(params): # one list, one numpy array input x,y = params[0] A = params[1] return np.linalg.dot(np.sin(A), np.array([x,y**2])) A = np.array([[1.0, 2.0],[3.0, 4.0]]) x,y = 2.0, np.pi params = [[x, y], A] df = jacobian(f2)(params) # df0_dx self.assertAlmostEqual(df[0][0][0], np.sin(A)[0][0]) # df1_dx self.assertAlmostEqual(df[1][0][0], np.sin(A)[1][0]) # df0_dy self.assertAlmostEqual(df[0][0][1], 2*np.sin(A)[0][1]*y) # df1_dy self.assertAlmostEqual(df[1][0][1], 2*np.sin(A)[1][1]*y) # df_dA assert np.linalg.norm(df[0][1][0] - (np.cos(A)*np.array([x,y**2]))[0]) < 1e-10 assert np.linalg.norm(df[1][1][1] - (np.cos(A)*np.array([x,y**2]))[1]) < 1e-10
def _setup_input(self, X, y=None): if not isinstance(X, np.ndarray): X = np.array(X) if X.size == 0: raise ValueError("Number of features must be > 0") if X.ndim == 1: self.n_samples, self.n_features = 1, X.shape else: self.n_samples, self.n_features = X.shape[0], np.prod(X.shape[1:]) self.X = X if self.y_required: if y is None: raise ValueError("Missed required argument y") if not isinstance(y, np.ndarray): y = np.array(y) if y.size == 0: raise ValueError("Number of targets must be > 0") self.y = y
def opt_traj(func, fdict, T, opt_method = 'SGD', init = None, \ learning_rate = 0.1, seed = 100, momentum = False, noise_level = 0.0): # do optimization and return the trajectory params = {'x': 0.0, 'y': 0.0} domain = fdict['domain'] optimum = fdict['optimum'] loss_and_grad = value_and_grad(func) #quick_grad_check(func, params) params = init_params(params, domain, init, seed) check_grads(func, params) opt_server = Parameter_Server(opt_method, momentum) opt_server.init_gradient_storage(params) x_traj = [] y_traj = [] f_traj = [] print 'optimising function using %s...' % opt_method for t in xrange(T): (func_value, func_grad) = loss_and_grad(params) x_traj.append(params['x']) y_traj.append(params['y']) f_traj.append(func_value) func_grad = inject_noise(func_grad, noise_level) if opt_method == 'SGD': norm = np.sqrt(func_grad['x'] ** 2 + func_grad['y'] ** 2) if norm >= 2.0: func_grad['x'] /= norm / 2; func_grad['y'] /= norm / 2 params = opt_server.update(params, func_grad, learning_rate) return np.array(x_traj), np.array(y_traj), np.array(f_traj)
def GetTimeSeries(): TS = [] ERR = [] GYRO = [] ACCEL = [] lastim = None t0 = None for msg in parse.ParseLog(open('../rustlerlog-BMPauR')): if msg[0] == 'img': _, ts, im = msg if t0 is None: t0 = ts im = GammaCorrect(im) if lastim is not None: TS.append(ts - t0) ERR.append(np.sum(np.abs(lastim-im)) / (320*240)) GYRO.append(GYRO[-1]) ACCEL.append(ACCEL[-1]) lastim = im elif msg[0] == 'imu': _, ts, gyro, mag, accel = msg if t0 is None: t0 = ts TS.append(ts - t0) GYRO.append(gyro) ACCEL.append(accel) if len(ERR): ERR.append(ERR[-1]) else: ERR.append(0) return np.array(TS), np.array(ERR), np.array(GYRO), np.array(ACCEL)
def initial(): q = np.array([0, 0, 0, 1], np.float32) # unit quaternion orientation b_g = np.array([0, 0, 0], np.float32) # gyroscope bias v_g = np.array([0, 0, 0], np.float32) # velocity of IMU in global frame b_a = np.array([0, 0, 0], np.float32) # accelerometer bias p_g = np.array([0, 0, 0], np.float32) # position in global frame return (q, b_g, v_g, b_a, p_g)
def _forward(self, g, beta, initval, ifx): """ Applies the forward iteration of the Picard series """ g = g.reshape((self.dim.R, self.dim.N)).T struct_mats = np.array([sum(brd * Ld for brd, Ld in zip(br, self.basis_mats)) for br in beta]) # construct the sets of A(t_n) shape: (N, K, K) A = np.array([sum(gnr * Ar for gnr, Ar in zip(gn, struct_mats[1:])) + struct_mats[0] for gn in g]) # initial layer shape (N, K, N_samples) layer = np.dstack([np.row_stack([m]*self.dim.N) for m in initval]) # weight matrix weights = self._get_weight_matrix(self.ttc, ifx) for m in range(self.order): layer = get_next_layer(layer, initval, A, weights) return layer
def test_linear_system(self): """ Tests taking the derivative across a linear system solve """ def linsolve(params): A, B = params return np.linalg.solve(A, B) B = np.array([1.0, 3.0]) A = np.array([[5.0, 2.0],[1.0, 3.0]]) df = jacobian(linsolve) diff = df([A, B]) Ainv = np.linalg.inv(A) x = np.linalg.solve(A, B) #df_dB assert np.linalg.norm(diff[0][1] - Ainv[0]) < 1e-10 assert np.linalg.norm(diff[1][1] - Ainv[1]) < 1e-10 #df_fA dr_da = np.zeros((2,4)) dr_da[0, 0:2] = x dr_da[1, 2:] = x df_fa = np.linalg.solve(A, -dr_da) assert np.linalg.norm(df_fa[0] - diff[0][0].flatten()) < 1e-10 assert np.linalg.norm(df_fa[1] - diff[1][0].flatten()) < 1e-10
def MLE_EP(self, random_init): w_init = RS.normal(0,1, (self.dimx, self.dimz)) if random_init is False: print "FALSE" w_init = self.W mus = np.array([]) #w = self.marginal_likelihood(w_init) print "initialisation of W:" print w_init print "" w = self.marginal_likelihood(w_init) print "True W" print self.W print "MLE W" print w mus = np.array([]) for i in xrange(self.n): mu = self.get_mu(self.observed[i], w) mus = np.hstack((mus, mu)) mus = mus.reshape((self.n,2)) sig = np.dot(self.W.transpose(), self.W) sig = sig/self.sigx sig = np.linalg.inv(sig) return mus, sig
def callback(params): print("Log likelihood {}, Squared Error {}".format(-objective(params),squared_error(params,X,y,n_samples))) # Show posterior marginals. if dimensions[0] == 1: plot_xs = np.reshape(np.linspace(-5, 5, 300), (300,1)) plot_deep_gp(ax_end_to_end, params, plot_xs) deep_map = create_deep_map(params) if dimensions == [1,1]: ax_end_to_end.plot(np.ndarray.flatten(deep_map[0][0]['x0']),deep_map[0][0]['y0'], 'ro') elif dimensions == [1,1,1]: plot_single_gp(ax_x_to_h,params,0,0,plot_xs) ax_x_to_h.set_title("Inputs to hiddens, pesudo data in red") plot_single_gp(ax_h_to_y,params,1,0,plot_xs) ax_h_to_y.set_title("Hiddens to outputs, pesudo data in red") elif dimensions == [1,1,1,1]: plot_single_gp(ax_x_to_h, params,0,0, plot_xs) ax_x_to_h.set_title("Inputs to Hidden 1, pesudo data in red") plot_single_gp(ax_h_to_h2, params,1,0,plot_xs) ax_h_to_h2.set_title("Hidden 1 to Hidden 2, pesudo data in red") plot_single_gp(ax_h2_to_y, params,2,0, plot_xs) ax_h2_to_y.set_title("Hidden 2 to Outputs, pesudo data in red") elif dimensions[0] == 2: plot_xs = np.array([np.array([a,b]) for a in np.linspace(-1,1,40) for b in np.linspace(-1,1,40)]) plot_deep_gp_2d(ax, params, plot_xs) plt.draw() plt.pause(1.0/60.0)
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 gradient_check(): params = np.array([2,2]) h = np.array([1e-5,0]) print (log_variational(params+h,0.5)-log_variational(params,0.5))/h[0] h = np.array([0,1e-5]) print (log_variational(params+h,0.5)-log_variational(params,0.5))/h[1] print gradient_log_variational(params,0.5,0) print gradient_log_variational(params,0.5,1)
def initial(): r_g = np.array([0, 0, 0], np.float32) # global to imu frame rotation b_g = np.array([0, 0, 0], np.float32) # gyroscope bias v_g = np.array([0, 0, 0], np.float32) # velocity of IMU in global frame b_a = np.array([0, 0, 0], np.float32) # accelerometer bias p_g = np.array([0, 0, 0], np.float32) # position in global frame a_s = 1.0 # accelerometer scale return (r_g, b_g, v_g, b_a, p_g, a_s)
def gen_point_source_psf_image(pixel_grid, image, loc, psf_weights, psf_means, psf_covars): # use image PSF icovs = np.array([npla.inv(c) for c in psf_covars]) dets = np.array([npla.det(c) for c in psf_covars]) chols = np.array([npla.cholesky(c) for c in psf_covars]) return mog_like(pixel_grid, psf_means, icovs, dets, psf_weights)
def time_vspace_flatten(): val = {'k': npr.random((4, 4)), 'k2': npr.random((3, 3)), 'k3': 3.0, 'k4': [1.0, 4.0, 7.0, 9.0], 'k5': np.array([4., 5., 6.]), 'k6': np.array([[7., 8.], [9., 10.]])} vspace_flatten(val)
def compute_modfeat(self, w): mod_feat = self.conv_data_fea.copy() mod_dem = np.ones(mod_feat.shape) ## need to change to accommodate non-binary features ws = np.array([w[k*self.F:(k+1)*self.F] for k in range(self.K)]) w_tiled = np.array([ws for i in range(mod_feat.shape[0])]) mod_feat = mod_feat * w_tiled mod_dem = mod_dem * w_tiled mod_feat = np.sum(np.exp(mod_feat), axis=2) mod_dem = np.sum(np.exp(mod_dem), axis=2) return mod_feat / mod_dem
def predict1(params, x): c, lam = params x_predict = None for i in x: if i == 0: x_predict = np.array([c]) else: curr_predict = np.array([c*(i**lam)]) x_predict = np.concatenate([x_predict, curr_predict], axis=0) return x_predict
def predict2(params, x): w, b = params x_predict = None for i in x: if i == 0: x_predict = np.array([b]) else: curr_predict = np.array([w*i + b]) x_predict = np.concatenate([x_predict, curr_predict], axis=0) return x_predict
def stamps2array(gstamps): stamps = [] for gstamp in gstamps: template = gstamp.replace('-g-', '-%s-') bands = ['u', 'g', 'r', 'i', 'z'] imgs = [FitsImage(b, fits_file_template=template) for b in bands] img_array = np.array([img.nelec for img in imgs]) stamps.append( np.rollaxis(img_array, 0, 3) ) stamps = np.array(stamps) return stamps
def flatten(value): """value can be any nesting of tuples, arrays, dicts. returns 1D numpy array and an unflatten function.""" if isinstance(getval(value), np.ndarray): def unflatten(vector): return np.reshape(vector, value.shape) return np.ravel(value), unflatten elif isinstance(getval(value), float): return np.array([value]), lambda x : x[0] elif isinstance(getval(value), tuple): if not value: return np.array([]), lambda x : () flattened_first, unflatten_first = flatten(value[0]) flattened_rest, unflatten_rest = flatten(value[1:]) def unflatten(vector): N = len(flattened_first) return (unflatten_first(vector[:N]),) + unflatten_rest(vector[N:]) return np.concatenate((flattened_first, flattened_rest)), unflatten elif isinstance(getval(value), list): if not value: return np.array([]), lambda x : [] flattened_first, unflatten_first = flatten(value[0]) flattened_rest, unflatten_rest = flatten(value[1:]) def unflatten(vector): N = len(flattened_first) return [unflatten_first(vector[:N])] + unflatten_rest(vector[N:]) return np.concatenate((flattened_first, flattened_rest)), unflatten elif isinstance(getval(value), dict): flattened = [] unflatteners = [] lengths = [] keys = [] for k, v in sorted(iteritems(value), key=itemgetter(0)): cur_flattened, cur_unflatten = flatten(v) flattened.append(cur_flattened) unflatteners.append(cur_unflatten) lengths.append(len(cur_flattened)) keys.append(k) def unflatten(vector): split_ixs = np.cumsum(lengths) pieces = np.split(vector, split_ixs) return {key: unflattener(piece) for piece, unflattener, key in zip(pieces, unflatteners, keys)} return np.concatenate(flattened), unflatten else: raise Exception("Don't know how to flatten type {}".format(type(value)))
def time_flatten(): val = {'k': npr.random((4, 4)), 'k2': npr.random((3, 3)), 'k3': 3.0, 'k4': [1.0, 4.0, 7.0, 9.0], 'k5': np.array([4., 5., 6.]), 'k6': np.array([[7., 8.], [9., 10.]])} vect, unflatten = flatten(val) val_recovered = unflatten(vect) vect_2, _ = flatten(val_recovered)
def testRemapPointsToSegments01(self): points = np.array([[1, 2], [3, 4], [5, 6]]) indices = np.array([[0, 1], [2, 0]]) res = contourloss.remapPointsToSegements(points, indices) ans = np.array([ [[1, 2], [3, 4]], [[5, 6], [1, 2]] ]) self.assertEqual(res.shape, ans.shape) self.assertTrue(np.allclose(res, ans))
def gen_test_data() : ################################################################ # using sklearn # ################################################################ N = 500 #features,labels = ds.make_classification(n_samples = N,n_features = 2,n_informative = 2,n_redundant = 0,n_clusters_per_class = 1,class_sep = 2,shift = 2.2) features,labels = ds.make_circles(n_samples = N) #features,labels = ds.make_moons(n_samples = N) labels[labels == 0] = -1 features = auto_np.array(features) * 4.0 labels = auto_np.array(labels).reshape(features.shape[0],1) return features,labels
def read_as_float_array(content, truncated=None, delimiter=None): """ Read input as a float array. :param content: string input :param truncated: head number of elements extracted :param delimiter: delimiter string :return: a numpy float array """ if truncated is None: return np.array(map(float, content.split(delimiter)), dtype=np.float64) else: return np.array(map(float, content.split(delimiter)[:truncated]), dtype=np.float64)
def PyLQR_TrajCtrl_GeneralTest(): #build RBF basis rbf_basis = np.array([ [-1.0, -1.0], [-1.0, 1.0], [1.0, -1.0], [1.0, 1.0] ]) gamma = 1 T = 100 R = 1e-5 # rbf_funcs = [lambda x, u, t, aux: np.exp(-gamma*np.linalg.norm(x[0:2]-basis)**2) + .01*np.linalg.norm(u)**2 for basis in rbf_basis] rbf_funcs = [ lambda x, u, t, aux: -np.exp(-gamma*np.linalg.norm(x[0:2]-rbf_basis[0])**2) + R*np.linalg.norm(u)**2, lambda x, u, t, aux: -np.exp(-gamma*np.linalg.norm(x[0:2]-rbf_basis[1])**2) + R*np.linalg.norm(u)**2, lambda x, u, t, aux: -np.exp(-gamma*np.linalg.norm(x[0:2]-rbf_basis[2])**2) + R*np.linalg.norm(u)**2, lambda x, u, t, aux: -np.exp(-gamma*np.linalg.norm(x[0:2]-rbf_basis[3])**2) + R*np.linalg.norm(u)**2 ] weights = np.array([.75, .5, .25, 1.]) weights = weights / (np.sum(weights) + 1e-6) cost_func = lambda x, u, t, aux: np.sum(weights * np.array([basis_func(x, u, t, aux) for basis_func in rbf_funcs])) lqr_traj_ctrl = PyLQR_TrajCtrl(use_autograd=True) lqr_traj_ctrl.build_ilqr_general_solver(cost_func, n_dims=rbf_basis.shape[1], T=T) n_eval_pnts = 50 coords = np.linspace(-2.5, 2.5, n_eval_pnts) xv, yv = np.meshgrid(coords, coords) z = [[cost_func(np.array([xv[i, j], yv[i, j]]), np.zeros(2), None, None) for j in range(yv.shape[1])] for i in range(len(xv))] fig = plt.figure() ax = fig.add_subplot(111) ax.hold(True) ax.contour(xv, yv, z) n_queries = 5 u_array = np.random.rand(2, T-1).T * 2 - 1 for i in range(n_queries): #start from a perturbed point x0 = np.random.rand(2) * 4 - 2 syn_traj = lqr_traj_ctrl.synthesize_trajectory(x0, u_array) #plot it ax.plot([x0[0]], [x0[1]], 'k*', markersize=12.0) ax.plot(syn_traj[:, 0], syn_traj[:, 1], linewidth=3.5) plt.show() return
def dw(px, py, d, r, T): R = so3.exp(r) x0 = np.array([px, py, 1]) X = np.dot(R, d * x0) + T # derivative of projection w = xy/z, as a matrix # dw/dk = dw/dX * dX/dk dwdX = np.array([ [X[2], 0, -X[0]], [0, X[2], -X[1]]]) / (X[2]*X[2]) dXdR = so3.diff(r, R, d * x0) dXdT = np.eye(3) dXdd = np.dot(R, x0).reshape((3, 1)) return np.dot(dwdX, np.hstack((dXdR, dXdT, dXdd)))
def init_weight(self, x, y): self.classes_ = np.unique(y) if self.prob_func_ == "sigmoid" and len(self.classes_) > 2: raise ValueError() if self.prob_func_ is None: if len(self.classes_) == 2: self.prob_func_ = "sigmoid" else: self.prob_func_ = "softmax" if self.prob_func_ == "sigmoid": return np.array([self.eps_] * (x.shape[1] + 1)) else: # self.prob_func_ == "softmax" return np.array([[self.eps_] * len(self.classes_) for i in xrange(x.shape[1] + 1)])
def apply_control(self, x_array, u_array, k_array, K_array, alpha): """ apply the derived control to the error system to derive new x and u arrays """ x_new_array = [None] * len(x_array) u_new_array = [None] * len(u_array) x_new_array[0] = x_array[0] for t in range(self.T): u_new_array[t] = u_array[t] + alpha * (k_array[t] + K_array[t].dot(x_new_array[t] - x_array[t])) x_new_array[t+1] = self.plant_dyn(x_new_array[t], u_new_array[t], t, self.aux) return np.array(x_new_array), np.array(u_new_array)
def create_batches(images, labels): l = zip(images, labels) random.shuffle(l) r = [l[i:i+BATCH_SIZE] for i in xrange(0, len(l), BATCH_SIZE)] res = [] for i in r: images = [] labels = [] for j in i: images.append(j[0]) labels.append(j[1]) res.append((np.array(images), np.array(labels))) return res
def shape_match_1d(y, x): """ match the shape of y to that of x and return the new y object. """ #assert(len(y.shape) == 1) sh = (np.array(x.shape) == np.array(y.shape)) if sh.sum() != 1: print("There have been " + str(sh.sum()) + " matches in shape instead of exactly 1. Using first match only.", file=sys.stderr) sh[np.argmax(sh)+1:] = False new_sh = np.ones(sh.shape) new_sh[sh] = y.shape return np.reshape(y, new_sh)
def __init__(self, n_unique=2, n_lags=1, n_tied=0, n_features=1, startprob_init=None, transmat_init=None, startprob_prior=1.0, transmat_prior=None, algorithm="viterbi", random_state=None, n_iter=25, n_iter_min=2, tol=1e-4, params=string.ascii_letters, init_params=string.ascii_letters, alpha_init=None, mu_init=None, precision_init=None, precision_prior=None, precision_weight=0.0, mu_prior=None, mu_weight=0.0, shared_alpha=True, n_iter_update=1, verbose=False, mu_bounds=np.array([-1.0e5, 1.0e5]), precision_bounds=np.array([-1.0e5, 1.0e5]), alpha_bounds=np.array([-1.0e5, 1.0e5])): super(ARTHMM, self).__init__(n_unique=n_unique, n_tied=n_tied, n_features=n_features, algorithm=algorithm, params=params, init_params=init_params, startprob_init=startprob_init, startprob_prior=startprob_prior, transmat_init=transmat_init, transmat_prior=transmat_prior, mu_init=mu_init, mu_weight=mu_weight, mu_prior=mu_prior, precision_init=precision_init, precision_weight=precision_weight, precision_prior=precision_prior, tol=tol, n_iter=n_iter, n_iter_min=n_iter_min, n_iter_update=n_iter_update, random_state=random_state, verbose=verbose, mu_bounds=mu_bounds, precision_bounds=precision_bounds) self.n_lags = n_lags if self.n_lags < 1: raise ValueError("n_lags needs to be greater than 0") self.shared_alpha = shared_alpha self.alpha_ = alpha_init self.alpha_bounds = alpha_bounds self.wrt.extend(['a']) if not self.shared_alpha: self.wrt_dims.update({'a': (self.n_unique, self.n_lags)}) else: self.wrt_dims.update({'a': (1, self.n_lags)}) self.wrt_bounds.update({'a': (self.alpha_bounds[0], self.alpha_bounds[1])})
def predict(weights, inputs): return activation(np.dot(inputs, weights)) def loss(weights): preds = predict(weights, train_X) label_probabilities = preds * train_y + (1 - preds) * (1 - train_y) return -np.sum(np.log(label_probabilities)) # Compute the gradient of the loss function gradient_loss = grad(loss) # Set the initial weights weights = np.array([1.0, 1.0]) # Steepest Descent loss_values = [] learning_rate = 0.001 for i in range(100): loss_values.append(loss(weights)) step = gradient_loss(weights) weights -= step * learning_rate # Plot the decision boundary x_min, x_max = train_X[:, 0].min() - 0.5, train_X[:, 0].max() + 0.5 y_min, y_max = train_X[:, 1].min() - 0.5, train_X[:, 1].max() + 0.5 x_mesh, y_mesh = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01)) Z = predict(weights, np.c_[x_mesh.ravel(), y_mesh.ravel()])
print("") print("x ", xOpt) print("f(x) ", fOpt) print("fevals: ", fevals) print("DeltaF: ", deltaF) print("\nCheck end point") print("xOpt", xOpt) print("f_1(x) = {} <= 0".format(L4_Q5_ineq1(xOpt))) print("f_2(x) = {} <= 0".format(L4_Q5_ineq2(xOpt))) optNameList.append(optName) xList.append(xOpt) fxList.append(fOpt) fevalsList.append(fevals) deltaFList.append(deltaF) xList = np.array(xList) resultsDf = pd.DataFrame(data={"Optimizer": optNameList, "\\(x^*_1\\)" : xList[:, 0], "\\(x^*_2\\)" : xList[:, 1], "\\(x^*_3\\)" : xList[:, 2], "\\(x^*_4\\)" : xList[:, 3], "\\(f(x^*)\\)" : fxList, "FEvals" : fevalsList, "\\(\\Delta F\\)" : deltaFList}) print(resultsDf) resultsDf.to_excel(savePath)
def log_p_F_given_s(self,s,floor=1e-8): # bin-wise likelihood of s spikes in each bin given df/f data F # n x T x N prev = np.array([self.g[:,k:k+1]*(self.F-self.b)[:,self.p-(k+1):-(k+1)] for k in range(self.p)]) log_p_raw = -0.5*((self.F-self.b)[:,self.p:]-self.a*s-prev.sum(0))**2/self.noise return log_p_raw
def set_energy(self, key, geom, d=None): e = lj_potential(np.array(geom)) if d is None: self.energy[key] = e else: d[key] = e
parser = argparse.ArgumentParser(description='Run Sparse gamma DEF example.') parser.add_argument('--eta', type=float, help='Stepsize parameter') parser.add_argument('-B', type=int, help='Alpha Boost') args = parser.parse_args() eta = 0.75 B = 4 if (B > 1): correction = True else: correction = False n_iter = 1000 # Setup sizes K = np.array([100, 40, 15]) D = 64 * 64 N = 320 n_latent = N * np.sum(K) + K[0] * D + np.sum(K[1:] * K[:-1]) sigma = 0.1 # Load data x = np.loadtxt('data/faces_training.csv', delimiter=',') alphaz = 0.1 # Define truncation functions and stepsize updates trunc_shape = np.log(np.exp(1e-3) - 1.) trunc_mean = np.log(np.exp(1e-4) - 1.) def stepSize(iteration, sPrev, gradient, eta=1.0):
def make_nascar_model(): As = [ random_rotation(D_latent, np.pi / 24.), random_rotation(D_latent, np.pi / 48.) ] # Set the center points for each system centers = [np.array([+2.0, 0.]), np.array([-2.0, 0.])] bs = [ -(A - np.eye(D_latent)).dot(center) for A, center in zip(As, centers) ] # Add a "right" state As.append(np.eye(D_latent)) bs.append(np.array([+0.1, 0.])) # Add a "right" state As.append(np.eye(D_latent)) bs.append(np.array([-0.25, 0.])) # Construct multinomial regression to divvy up the space w1, b1 = np.array([+1.0, 0.0]), np.array([-2.0]) # x + b > 0 -> x > -b w2, b2 = np.array([-1.0, 0.0]), np.array([-2.0]) # -x + b > 0 -> x < b w3, b3 = np.array([0.0, +1.0]), np.array([0.0]) # y > 0 w4, b4 = np.array([0.0, -1.0]), np.array([0.0]) # y < 0 Rs = np.row_stack((100 * w1, 100 * w2, 10 * w3, 10 * w4)) r = np.concatenate((100 * b1, 100 * b2, 10 * b3, 10 * b4)) true_rslds = SLDS(D_obs, K, D_latent, transitions="recurrent_only", dynamics="gaussian", emissions="gaussian", single_subspace=True) true_rslds.dynamics.mu_init = np.array([0, 1]) true_rslds.dynamics.inv_sigma_init = np.log(1e-4) * np.ones(2) true_rslds.dynamics.As = np.array(As) true_rslds.dynamics.bs = np.array(bs) true_rslds.dynamics.inv_sigmas = np.log(1e-4) * np.ones((K, D_latent)) true_rslds.transitions.Rs = Rs true_rslds.transitions.r = r true_rslds.emissions.inv_etas = np.log(1e-2) * np.ones((1, D_obs)) return true_rslds
def grad_f1(x): B = np.array([[3, -1], [-1, 3]]) a = np.array([[1], [0]]) b = np.array([[0], [-1]]) grad = np.dot(2, x).transpose() + np.dot(2, np.dot(B, x)).transpose() - a.transpose() + b.transpose() return grad
- np.exp(-np.dot(np.dot((x - b).transpose(), B), (x-b))) \ + 1/10 * np.log(np.linalg.det(np.dot(1/100, np.identity(2)) + np.dot(x, x.transpose()))) return c1 def grad_f3(x): B = np.array([[3, -1], [-1, 3]]) a = np.array([[1], [0]]) b = np.array([[0], [-1]]) grad = np.dot((np.exp(-np.dot((x-a).transpose(), (x-a)))), (x-a).transpose()) \ - np.dot(np.exp(-np.dot((x-b).transpose(), np.dot(B, (x-b)))), np.dot(2, np.dot((x-b).transpose(), B))) \ + np.dot((1/10/(1/100 + np.dot(x, x.transpose()))), np.dot(2, x.transpose())) return grad theta = np.array([[1], [-1]]) gradf1 = grad(f1) gradf2 = grad(f2) gradf3 = grad(f3) print( "AutoGradient of f1 is", gradf1(theta)) print( "ManGradient of f1 is", grad_f1(theta)) print( "AutoGradient of f2 is", gradf2(theta)) print( "ManGradient of f2 is", grad_f2(theta)) print( "AutoGradient of f3 is", gradf3(theta)) #print( "ManGradient of f3 is", grad_f3(theta))
def logp(x): return -logsumexp( np.log(probs) - np.array([logp(x) for logp in neg_log_probs]))
def governing_equation(self, t, Y): ''' ODEs of Bicycle Track Problem ''' x, y = Y k1 = np.array([self.dfx(t), self.dfy(t)]) k2 = np.array([x - self.front_track_x(t), y - self.front_track_y(t)]) return np.sum(k1 * k2) * k2 / self.L**2
back_track.set_data(bx, by) return lines if __name__ == '__main__': import matplotlib.pyplot as plt import matplotlib.animation as animation def fx(x): return 5 + 5 * np.cos(x) def fy(x): return 5 * np.sin(x) span = [-np.pi, np.pi] P0 = np.array([-3, 0]) BT = BicycleTrack(fx, fy) fig = plt.figure(tight_layout=True) for i in range(4): BT.solve(span, np.array([-4 - i, 0]), err=1e-6) plt.subplot(221 + i) BT.plot(plt) BT.animate(plt, animation) plt.show()
def Styblinski_Tang_low(x, bounds): delta = bounds[:, 1] - bounds[:, 0] s = np.array([0.28, 0.59, 0.47, 0.16, 0.32]) x = ((x.T * delta - s) / delta).T return Styblinski_Tang_high(x, bounds)
def string_to_one_hot(string, maxchar): """Converts an ASCII string to a one-of-k encoding.""" ascii = np.array([ord(c) for c in string]).T return np.array(ascii[:,None] == np.arange(maxchar)[None, :], dtype=int)
def grad_f2(x): B = np.array([[3, -1], [-1, 3]]) a = np.array([[1], [0]]) b = np.array([[0], [-1]]) grad = np.dot((np.cos(np.dot((x-a).transpose(), (x-a)))), (x-a).transpose()) + np.dot(2, np.dot((x-b).transpose(), B)) return grad
from __future__ import absolute_import from __future__ import print_function import autograd.numpy as np from autograd import value_and_grad from scipy.optimize import minimize def rosenbrock(x): return 100*(x[1] - x[0]**2)**2 + (1 - x[0])**2 # Build a function that also returns gradients using autograd. rosenbrock_with_grad = value_and_grad(rosenbrock) # Optimize using conjugate gradients. result = minimize(rosenbrock_with_grad, x0=np.array([0.0, 0.0]), jac=True, method='CG') print("Found minimum at {0}".format(result.x))
thetaHat = model.params.get_free().copy() X = train.X Y = train.Y D1 = model.D1 D2 = model.D2 iprods = np.linalg.solve(model.hessian, X.T).T # Comptue exact and approximate Q_n Q = np.einsum('nd,nd->n', iprods, X) Qappx, estQErr = solvers.compute_Q(model, K=Xrank + 5, estErr=True) print(X.shape) exactCV, exactParams, sets = retrainingPlans.leave_k_out_cv( model, k=1, method="exact", B=100, hold_outs='stochastic') sets = np.array(sets).squeeze().astype(np.int32) exact = np.einsum('nd,nd->n', exactParams, X[sets]) NS = np.zeros(sets.shape[0]) IJ = np.zeros(sets.shape[0]) NSAppx = np.zeros(sets.shape[0]) IJAppx = np.zeros(sets.shape[0]) IJAppxBnd = np.zeros(sets.shape[0]) for idx, n in enumerate(sets): IJParams = thetaHat + D1[n] * iprods[n] NS[idx] = np.inner(thetaHat, X[n]) + D1[n] * Q[n] / (1 - D2[n] * Q[n]) IJ[idx] = np.inner(thetaHat, X[n]) + D1[n] * Q[n] IJAppx[idx] = np.inner(thetaHat, X[n]) + D1[n] * Qappx[n] IJAppxBnd[idx] = np.abs(D1[n]) * estQErr[n] model.compute_bounds()
# Each row is a case # Columns 0-4 are features # Columns 5 & 6 are targets features_and_targets = np.array( [[0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 1, 0, 1], [0, 0, 0, 1, 1, 0, 1], [0, 0, 1, 1, 1, 0, 1], [0, 1, 1, 1, 1, 0, 1], [1, 1, 1, 1, 0, 0, 1], [1, 1, 1, 0, 0, 0, 1], [1, 1, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 1], [1, 0, 0, 1, 0, 0, 1], [1, 0, 1, 1, 0, 0, 1], [1, 1, 0, 1, 0, 0, 1], [0, 1, 0, 1, 1, 0, 1], [0, 0, 1, 0, 1, 0, 1], [1, 0, 1, 1, 1, 1, 0], [1, 1, 0, 1, 1, 1, 0], [1, 0, 1, 0, 1, 1, 0], [1, 0, 0, 0, 1, 1, 0], [1, 1, 0, 0, 1, 1, 0], [1, 1, 1, 0, 1, 1, 0], [1, 1, 1, 1, 1, 1, 0], [1, 0, 0, 1, 1, 1, 0]], dtype=float) # shuffle our cases np.random.shuffle(features_and_targets)
def plot_con(self, con, p, index=None): if not index: x = np.array(3 * [p] * len(self.itinerary) + 3 * [0] * len(self.itinerary)) return con['fun'](x, con['args'][0], con['args'][1], con['args'][2], con['args'][3], con['args'][4])
def cast_to_same_dtype(value, example): if hasattr(example, 'dtype') and example.dtype.type is not np.float64: return np.array(value, dtype=example.dtype) else: return value
def calculate_A_matrix_autograd(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, x6, y6, P, normalize=False): """ Calculate the A matrix for the DLT algorithm: A.H = 0 all coordinates are in object plane """ X1 = np.array([[x1], [y1], [0.], [1.]]).reshape(4, 1) X2 = np.array([[x2], [y2], [0.], [1.]]).reshape(4, 1) X3 = np.array([[x3], [y3], [0.], [1.]]).reshape(4, 1) X4 = np.array([[x4], [y4], [0.], [1.]]).reshape(4, 1) X5 = np.array([[x5], [y5], [0.], [1.]]).reshape(4, 1) X6 = np.array([[x6], [y6], [0.], [1.]]).reshape(4, 1) U1 = np.array(np.dot(P, X1)).reshape(3, 1) U2 = np.array(np.dot(P, X2)).reshape(3, 1) U3 = np.array(np.dot(P, X3)).reshape(3, 1) U4 = np.array(np.dot(P, X4)).reshape(3, 1) U5 = np.array(np.dot(P, X5)).reshape(3, 1) U6 = np.array(np.dot(P, X6)).reshape(3, 1) object_pts = np.hstack([X1, X2, X3, X4, X5, X6]) image_pts = np.hstack([U1, U2, U3, U4, U5, U6]) if normalize: object_pts_norm, T1 = normalise_points(object_pts) image_pts_norm, T2 = normalise_points(image_pts) else: object_pts_norm = object_pts[[0, 1, 3], :] image_pts_norm = image_pts x1 = object_pts_norm[0, 0] / object_pts_norm[2, 0] y1 = object_pts_norm[1, 0] / object_pts_norm[2, 0] x2 = object_pts_norm[0, 1] / object_pts_norm[2, 1] y2 = object_pts_norm[1, 1] / object_pts_norm[2, 1] x3 = object_pts_norm[0, 2] / object_pts_norm[2, 2] y3 = object_pts_norm[1, 2] / object_pts_norm[2, 2] x4 = object_pts_norm[0, 3] / object_pts_norm[2, 3] y4 = object_pts_norm[1, 3] / object_pts_norm[2, 3] x5 = object_pts_norm[0, 4] / object_pts_norm[2, 4] y5 = object_pts_norm[1, 4] / object_pts_norm[2, 4] x6 = object_pts_norm[0, 5] / object_pts_norm[2, 5] y6 = object_pts_norm[1, 5] / object_pts_norm[2, 5] u1 = image_pts_norm[0, 0] / image_pts_norm[2, 0] v1 = image_pts_norm[1, 0] / image_pts_norm[2, 0] u2 = image_pts_norm[0, 1] / image_pts_norm[2, 1] v2 = image_pts_norm[1, 1] / image_pts_norm[2, 1] u3 = image_pts_norm[0, 2] / image_pts_norm[2, 2] v3 = image_pts_norm[1, 2] / image_pts_norm[2, 2] u4 = image_pts_norm[0, 3] / image_pts_norm[2, 3] v4 = image_pts_norm[1, 3] / image_pts_norm[2, 3] u5 = image_pts_norm[0, 4] / image_pts_norm[2, 4] v5 = image_pts_norm[1, 4] / image_pts_norm[2, 4] u6 = image_pts_norm[0, 5] / image_pts_norm[2, 5] v6 = image_pts_norm[1, 5] / image_pts_norm[2, 5] A = np.array([ [0, 0, 0, -x1, -y1, -1, v1 * x1, v1 * y1, v1], [x1, y1, 1, 0, 0, 0, -u1 * x1, -u1 * y1, -u1], [0, 0, 0, -x2, -y2, -1, v2 * x2, v2 * y2, v2], [x2, y2, 1, 0, 0, 0, -u2 * x2, -u2 * y2, -u2], [0, 0, 0, -x3, -y3, -1, v3 * x3, v3 * y3, v3], [x3, y3, 1, 0, 0, 0, -u3 * x3, -u3 * y3, -u3], [0, 0, 0, -x4, -y4, -1, v4 * x4, v4 * y4, v4], [x4, y4, 1, 0, 0, 0, -u4 * x4, -u4 * y4, -u4], [0, 0, 0, -x5, -y5, -1, v5 * x5, v5 * y5, v5], [x5, y5, 1, 0, 0, 0, -u5 * x5, -u5 * y5, -u5], [0, 0, 0, -x6, -y6, -1, v6 * x6, v6 * y6, v6], [x6, y6, 1, 0, 0, 0, -u6 * x6, -u6 * y6, -u6], ]) return A
def _create_initial_point(self, Ts, E, *args): base_point = self._base_fitter._create_initial_point(Ts, E, *args) return anp.array([0.5] + list(base_point))
def _perfect_match_values(set_1, set_2, close_fn=np.allclose): """Checks that there's a perfect matching between set_1 and set_2.""" if len(set_1) == len(set_2): matches = np.array([[close_fn(a, b) for a in set_1] for b in set_2], int) return np.all(matches.sum(0) == 1) and np.all(matches.sum(1) == 1) return False
#cam.set_R_axisAngle(1.0, 0.0, 0.0, np.deg2rad(140.0)) #cam.set_t(0.0,-1,1.0, frame='world') # r = 0.5 angle = 10 x = r*np.cos(np.deg2rad(angle)) z = r*np.sin(np.deg2rad(angle)) cam.set_t(0, x,z) cam.set_R_mat(R_matrix_from_euler_t(0.0,0,0)) cam.look_at([0,0,0]) cam.set_R_axisAngle(1.0, 0.0, 0.0, np.deg2rad(110.0)) cam.set_t(0.0,-0.3,0.1, frame='world') ## Define a Display plane pl = Plane(origin=np.array([0, 0, 0]), normal = np.array([0, 0, 1]), size=(0.3,0.3), n = (2,2)) pl = CircularPlane() pl.random(n =number_of_points, r = 0.01, min_sep = 0.01) #objectPoints = pl.get_points() #x1,y1,x2,y2,x3,y3,x4,y4 = gd.extract_objectpoints_vars(objectPoints) #imagePoints_true = np.array(cam.project(objectPoints, False)) #imagePoints_measured = cam.addnoise_imagePoints(imagePoints_true, mean = 0, sd = 4) #[repro, imagePoints_repro] = gd.repro_error_autograd(x1,y1,x2,y2,x3,y3,x4,y4,cam.P, imagePoints_measured) #%%
def simple_contour(g, xc, yc, nom_bord, i, j, c=0, delta=0.001, eps=2**(-26)): abscisses, ordonnées = [], [] dic_fonction = { "UP": find_seed_U, "LEFT": find_seed_L, "RIGHT": find_seed_R, "DOWN": find_seed_D } position = dic_fonction[nom_bord](g, c, [xc[i], xc[i + 1]], [yc[j], yc[j + 1]]) print(position) gradg = autograd.grad(g) if not isinstance(position, list): return [], [] else: position = np.array(position) abscisses.append(position[0]) ordonnées.append(position[1]) print(position) def test(position): return xc[i] <= position[0] <= xc[ i + 1] and yc[j] <= position[1] <= yc[j + 1] while test(position): gradX = gradg(position) norme = np.sqrt(gradX[1]**2 + gradX[0]**2) vect = np.array([gradX[1] / norme, -1 * gradX[0] / norme]) position_faux = position + vect * delta position1 = position def h1(x, y): return g(np.array([x, y])) - c def h2(x, y): return (x - position1[0])**2 + (y - position1[1])**2 - delta**2 def H(x, y): return np.array([h1(x, y), h2(x, y)]) def J_H(x, y): j = autograd.jacobian return np.c_[j(H, 0)(x, y), j(H, 1)(x, y)] J = J_H(position_faux[0], position_faux[1]) if np.linalg.det(J) == 0: abscisses.append(position_faux[0]) ordonnées.append(position_faux[1]) else: J_inv = np.linalg.inv(J) position = position_faux - J_inv @ H(position_faux[0], position_faux[1]) while np.linalg.norm(position - position_faux) > eps: position_faux = position J = J_H(position_faux[0], position_faux[1]) if np.linalg.det(J) == 0: break else: J_inv = np.linalg.inv(J) position = position_faux - J_inv @ H( position_faux[0], position_faux[1]) abscisses.append(position[0]) ordonnées.append(position[1]) return abscisses, ordonnées
ntrials = 20 #theta = 1.2 #A = np.array([[np.cos(theta), np.sin(theta)], [-np.sin(theta), np.cos(theta)]]) # the same for convenience. constructing reasonable C from small to large # dimensions is tricky d = 10 D = 120 #d = 05 #D = 6 # A = rand_stable(d) # A = np.stack([A for _ in range(T)], axis=0) A = np.array([0.5*np.eye(d) for _ in range(T)]) f01 = np.sin(np.linspace(0., 2*np.pi, num=T)) f10 = -np.sin(np.linspace(0., 2*np.pi, num=T) + 1.2)*f01 A[:,0,1] = f01*np.random.randn()*np.sign(np.random.randn()) A[:,1,0] = f10*np.random.randn()*np.sign(np.random.randn()) A[-1] = np.zeros((d, d)) #C = np.eye(D) C, _ = np.linalg.qr(np.random.randn(D, d)) #Q0 = 0.5*np.eye(d) #Q = 0.5*np.eye(d) # Q = np.diag([2.9, 3.5, 3., 10.]) Q0 = rand_psd(d, maxew=0.5) Q = rand_psd(d, maxew=0.5)
def H(x, y): return np.array([h1(x, y), h2(x, y)])
def logistic_predictions(weights, inputs): # Outputs probability of a label being true according to logistic model. return sigmoid(np.dot(inputs, weights)) def training_loss(weights): # Training loss is the negative log-likelihood of the training labels. preds = logistic_predictions(weights, inputs) label_probabilities = preds * targets + (1 - preds) * (1 - targets) return -np.sum(np.log(label_probabilities)) # Build a toy dataset. inputs = np.array([[0.52, 1.12, 0.77], [0.88, -1.08, 0.15], [0.52, 0.06, -1.30], [0.74, -2.49, 1.39]]) targets = np.array([True, True, False, True]) # Build a function that returns gradients of training loss using autograd. training_gradient_fun = grad(training_loss) # Check the gradients numerically, just to be safe. weights = np.array([0.0, 0.0, 0.0]) quick_grad_check(training_loss, weights) # Optimize weights using gradient descent. print("Initial loss:", training_loss(weights)) for i in range(100): weights -= training_gradient_fun(weights) * 0.01 print("Trained loss:", training_loss(weights))
def h1(x, y): return g(np.array([x, y])) - c
# dLpoiss = (df / f)[:,None] * ygrid[None,:] - df[:,None] # deriv of Poisson log likelihood # gwts = np.sum(np.exp(logjoint-logli[:,None]) * dLpoiss, axis=1) # gradient weights # gradient = -X.T@gwts # # Hessian # ddLpoiss = (ddf / f - (df / f)**2)[:,None] * ygrid[None,:] - ddf[:,None] # ddL = (ddLpoiss + dLpoiss**2) # hwts = np.sum(np.exp(logjoint-logli[:,None]) * ddL, axis=1) - gwts**2 # hessian weights # H = -X.T @ (X * hwts[:,None]) # return negL, gradient, H # Set calcium model hyperparams p = 2 ar_coefs = np.array([1.51, -0.6]) # decay in one time bin alpha = 1.0 # gain # sig = 0.2 # stdev of Gaussian noise (in spike train space) sig2 = 0.001 # stdev of Gaussian noise (in spike train space) sig = np.sqrt(sig2) # variance of noise hyperparams = [ar_coefs, np.log(alpha), np.log(sig2)] S = 10 # max spike count to consider ygrid = np.arange(0, S + 1) # Set up GLM D_in = 19 # dimension of stimulus D = D_in + 1 # total dims with bias T = 50000 dt = 0.5 bias = npr.randn(T)
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.) U = np.random.uniform(0, 1, 100000)