def _set_startprob(self, startprob): if startprob is None: startprob = np.tile(1.0 / self.n_components, self.n_components) else: startprob = np.asarray(startprob, dtype=np.float) if not np.alltrue(startprob <= 1.0): normalize(startprob) if len(startprob) != self.n_components: if len(startprob) == self.n_unique: startprob_split = np.copy(startprob) / (1.0+self.n_tied) startprob = np.zeros(self.n_components) for u in range(self.n_unique): for t in range(self.n_chain): startprob[u*(self.n_chain)+t] = \ startprob_split[u].copy() else: raise ValueError("cannot match shape of startprob") if not np.allclose(np.sum(startprob), 1.0): raise ValueError('startprob must sum to 1.0') self._log_startprob = np.log(np.asarray(startprob).copy())
def _make_grad_prod(ans, x): x = np.asarray(x) def gradient_product(g): return np.full(x.shape, g) * ans * (1 - ans) return gradient_product
def generate_random_problem(cls, k, l, n, sigma=1.): """Generate a random linear regression problem. Parameters: ----------- k : int, dimension of X l : int, dimension of Y n : int, number of observations sigma: float, expected norm of additive noise on Y Returns: -------- regression_problem : LinearRegressionProblem, class combining loss, data, solver """ # independent gaussian vectors with approx unit norm X = 1 / np.sqrt(k) * np.random.standard_normal(size=(k, n)) X -= np.mean(X, axis=1)[:, None] # unit norm transformation with uniform orientation W = np.asarray( [random_matrix.generate_random_unit_vector(dim=k) for _ in range(l)])\ .T.squeeze() Y = np.dot(W.T, X) Y += np.sqrt(sigma / l) * np.random.standard_normal(size=Y.shape) return cls(X, Y)
def run_algo(self, algo, **kwargs): # Get function and compute gradient self.g = self.least_squares self.grad = compute_grad(self.g) # choose algorithm self.algo = algo if self.algo == 'gradient_descent': self.alpha = 10**-3 if 'alpha' in kwargs: self.alpha = kwargs['alpha'] self.max_its = 10 if 'max_its' in kwargs: self.max_its = kwargs['max_its'] self.w_init = np.random.randn(2) if 'w_init' in kwargs: self.w_init = kwargs['w_init'] self.w_init = np.asarray([float(s) for s in self.w_init]) self.w_init.shape = (len(self.w_init), 1) # run algorithm of choice if self.algo == 'gradient_descent': self.w_hist = [] self.gradient_descent() if self.algo == 'newtons_method': self.hess = compute_hess(self.g) # hessian of input function self.beta = 0 if 'beta' in kwargs: self.beta = kwargs['beta'] self.w_hist = [] self.newtons_method()
def generate_normal_data(nonlinearity=None, d=20, T=500, n_pred=250, r=6, var=0.1, **kwargs): C_true = np.random.randn(d, r) theta_true = np.asarray([[th * 1e-4] for th in range(1, r + 1)]) x_true = {0: np.random.randn(r, 1)} y_true = {} y_obs = {} for t in range(1, T + n_pred + 1): x_true[t] = nonlinearity(theta_true, x_true[t - 1], t) y_true[t] = C_true @ x_true[t] y_obs[t] = C_true @ x_true[t] + np.sqrt(var) * np.random.randn(d, 1) y_train = {t: y_obs[t] for t in range(1, T + 1)} return dict( C_true=C_true, theta_true=theta_true, x_true=x_true, y_true=y_true, y_obs=y_obs, y_train=y_train, )
def detector_response_dCS(frequencies, chirpm, symmratio, spin1, spin2, Luminosity_Distance, theta, phi, iota, alpha_squared, bppe, NSflag, cosmology=cosmology.Planck15): mass1 = utilities.calculate_mass1(chirpm, symmratio) mass2 = utilities.calculate_mass2(chirpm, symmratio) template = dcsimr_detector_frame(mass1=mass1, mass2=mass2, spin1=spin1, spin2=spin2, collision_time=0, collision_phase=0, Luminosity_Distance=Luminosity_Distance, phase_mod=alpha_squared, cosmo_model=cosmology, NSflag=NSflag) frequencies = np.asarray(frequencies) amp, phase, hreal = template.calculate_waveform_vector(frequencies) h_complex = amp * (np.exp(-1j * phase)) Fplus = (1 / 2) * (1 + np.cos(theta)**2) * np.cos(2 * phi) Fcross = np.cos(theta) * np.sin(2 * phi) Q = (1 + np.cos(iota)**2) / 2 * Fplus + 1j * Fcross * np.cos(iota) template_detector_response = h_complex * Q return template_detector_response
def print_training_prediction(weights, train_inputs, train_targets): print "Training text Predicted text" logprobs = np.asarray(pred_fun(weights, train_inputs)) for t in xrange(logprobs.shape[1]): training_text = one_hot_to_string(train_targets[:,t,:]) predicted_text = one_hot_to_string(logprobs[:,t,:]) print training_text.replace('\n', ' ') + "| " + predicted_text.replace('\n', ' ')
def multivariate_t_rvs(self, m, S, random_state = None): '''generate random variables of multivariate t distribution Parameters ---------- m : array_like mean of random variable, length determines dimension of random variable S : array_like square array of covariance matrix df : int or float degrees of freedom n : int number of observations, return random array will be (n, len(m)) random_state : int seed Returns ------- rvs : ndarray, (n, len(m)) each row is an independent draw of a multivariate t distributed random variable ''' np.random.rand(9) m = np.asarray(m) d = self.n_features df = self.degree_freedom n = 1 if df == np.inf: x = 1. else: x = random_state.chisquare(df, n)/df np.random.rand(90) z = random_state.multivariate_normal(np.zeros(d),S,(n,)) return m + z/np.sqrt(x)[:,None]
def tanh_feats(self,D): F = [np.ones((len(self.x)))] for deg in range(D): F.append(np.tanh(self.R[deg,0] + self.R[deg,1]*self.x)) F = np.asarray(F) F.shape = (D+1,len(self.x)) return F.T
def __new__( cls, array, name="unnamed", prior=None, constraint=None, step=0, std=None, m=None, v=None, vhat=None, fixed=False, ): obj = np.asarray(array, dtype=array.dtype).view(cls) obj.name = name if prior is not None: assert isinstance(prior, Prior) obj.prior = prior if constraint is not None: assert isinstance(constraint, Constraint) or isinstance( constraint, ConstraintChain) obj.constraint = constraint obj.step = step obj.std = std obj.m = m obj.v = v obj.vhat = vhat obj.fixed = fixed return obj
def setup_from_params(self, parameters, start=2, imax=100, minmax=(2e-07, 4.5e-05), find_mode=True, stds=None): """ Find bounds of integration for a given parameterization Will attempt to set model wide variables appropriate to model given parameters. does a binary search over the kernel values to find the points whose value is between the minmax bounds. This function will not guarantee results when the starting point is not the mode of the kernel or if the functions is not monotonically decreasing away from the mode. This function is only necessary when working without data since bounds of integration can be inferred from the data. Args: parameters (tuple, list, or np.array): parameter values to initialize the model start (int) - uses that index from params | (float) - starts on that value | (else) - 0. imax(int): maximum number of steps before quitting search minmax(tuple): min, max values of kernel, by default searches for the range (2e-07, 4.5e-05) find_mode(bool): If True, searches for and begins from mode (default True) """ assert isinstance(parameters, (tuple, list, np.ndarray)) assert len(parameters)==len(self.kernel.pnames) support_fun = lambda x: self.kernel.kernel(x, parameters) if isinstance(start, int): start_value = parameters[start] elif isinstance(start, float): start_value = start else: start_value = 0. if find_mode is True: mode_fun = lambda x: -support_fun(x) mode = sp.optimize.minimize(mode_fun, start_value).x[0] else: mode = start_value self.i_min, self.i_max = \ mathstats.find_support_bounds(support_fun, start=mode, which='both', minmax=minmax, imax=imax) self._itick_setup() self.params0 = copy.copy(np.asarray(parameters)) self.params = parameters
def rvs(self, theta, n, random_state=None, return_histories=False): logging.info('Simulating %s epidemic evolutions for theta = %s', n, theta) rng = check_random_state(random_state) all_x = [] histories = [] for i in range(n): if return_histories: _, (state, history) = self._simulate_transmission(theta, rng, return_history=True) histories.append(history) else: _, state = self._simulate_transmission(theta, rng, return_history=False) x = self._calculate_observables(state) all_x.append(x) all_x = np.asarray(all_x) if return_histories: return all_x, histories return all_x
def calculate_activation_contours(f, mn=0.05, mx=0.3, N=5, contour_lims=[-0.5, 1], contour_eps=1e-2, contour_tolerance=1.): """ Compute contours of f by euler continuation from starting points linearly spaced along the x-axis between mn and mx. """ starting_points = [ np.asarray([x_val, 0]) for x_val in np.linspace(mn, mx, num=N) ] activation_contours = [ trace_contour(starting_point, f, lims=contour_lims, eps=contour_eps, tolerance=contour_tolerance) for starting_point in starting_points ] contour_vals = [f(starting_point) for starting_point in starting_points] return activation_contours, contour_vals
def initialize_general_network_weights(self, layer_sizes, num_kernels, scale): # container for entire weight tensor weights = [] kernel_weights = [] # loop over desired kernel sizes and create appropriately sized initial # weight matrix for each kernel for k in range(num_kernels): # make weight matrix weight = scale * np.random.randn(3, 3) kernel_weights.append(weight) kernel_weights = np.asarray(kernel_weights) # loop over desired layer sizes and create appropriately sized initial # weight matrix for each layer for k in range(len(layer_sizes) - 1): # get layer sizes for current weight matrix U_k = layer_sizes[k] U_k_plus_1 = layer_sizes[k + 1] # make weight matrix weight = scale * np.random.randn(U_k + 1, U_k_plus_1) weights.append(weight) # re-express weights so that w_init[0] = omega_inner contains all # internal weight matrices, and w_init[1] = w contains weights of # final linear combination in predict function w_init = [weights[:-1], kernel_weights, weights[-1]] return w_init
def _centered(arr, newshape): """Return the center newshape portion of the array. This function is used by `fft_convolve` to remove the zero padded region of the convolution. Note: If the array shape is odd and the target is even, the center of `arr` is shifted to the center-right pixel position. This is slightly different than the scipy implementation, which uses the center-left pixel for the array center. The reason for the difference is that we have adopted the convention of `np.fft.fftshift` in order to make sure that changing back and forth from fft standard order (0 frequency and position is in the bottom left) to 0 position in the center. """ newshape = np.asarray(newshape) currshape = np.array(arr.shape) if not np.all(newshape <= currshape): msg = "arr must be larger than newshape in both dimensions, received {0}, and {1}" raise ValueError(msg.format(arr.shape, newshape)) startind = (currshape - newshape + 1) // 2 endind = startind + newshape myslice = [slice(startind[k], endind[k]) for k in range(len(endind))] return arr[tuple(myslice)]
def _pad(arr, newshape, axes=None): """Pad an array to fit into newshape Pad `arr` with zeros to fit into newshape, which uses the `np.fft.fftshift` convention of moving the center pixel of `arr` (if `arr.shape` is odd) to the center-right pixel in an even shaped `newshape`. """ if axes is None: newshape = np.asarray(newshape) currshape = np.array(arr.shape) dS = newshape - currshape startind = (dS + 1) // 2 endind = dS - startind pad_width = list(zip(startind, endind)) else: # only pad the axes that will be transformed pad_width = [(0, 0) for axis in arr.shape] try: len(axes) except TypeError: axes = [axes] for a, axis in enumerate(axes): dS = newshape[a] - arr.shape[axis] startind = (dS + 1) // 2 endind = dS - startind pad_width[axis] = (startind, endind) return np.pad(arr, pad_width, mode="constant")
def mle_batch(self, data, batch, k): """ Calculates LID values of data w.r.t batch Args: data: samples to calculate LIDs of batch: samples to calculate LIDs against k: the number of nearest neighbors to consider Returns: the calculated LID values """ k = min(k, len(data) - 1) f = lambda v: -k / np.sum(np.log(v / v[-1])) gamma = self.classifier.kernel.gamma if gamma is None: gamma = 1.0 / self.training_data_ndarray.shape[1] if batch is None: # K = cdist(data, data) K = rbf_kernel(data, Y=data, gamma=gamma) K = np.reciprocal(K) # get the closest k neighbours a = np.apply_along_axis(np.sort, axis=1, arr=K)[:, 1:k + 1] else: batch = np.asarray(batch, dtype=np.float32) # K = cdist(data, batch) K = rbf_kernel(data, Y=batch, gamma=gamma) K = np.reciprocal(K) # get the closest k neighbours a = np.apply_along_axis(np.sort, axis=1, arr=K)[:, 0:k] a = np.apply_along_axis(f, axis=1, arr=a) return np.nan_to_num(a)
def poly_feats(self,D): F = [] for deg in range(D+1): F.append(self.x**deg) F = np.asarray(F) F.shape = (D+1,len(self.x)) return F.T
def compose(T, R, Z, S=None): ''' Compose translations, rotations, zooms, [shears] to affine Parameters ---------- T : array-like shape (N,) Translations, where N is usually 3 (3D case) R : array-like shape (N,N) Rotation matrix where N is usually 3 (3D case) Z : array-like shape (N,) Zooms, where N is usually 3 (3D case) S : array-like, shape (P,), optional Shear vector, such that shears fill upper triangle above diagonal to form shear matrix. P is the (N-2)th Triangular number, which happens to be 3 for a 4x4 affine (3D case) Returns ------- A : array, shape (N+1, N+1) Affine transformation matrix where N usually == 3 (3D case) Examples -------- >>> T = [20, 30, 40] # translations >>> R = [[0, -1, 0], [1, 0, 0], [0, 0, 1]] # rotation matrix >>> Z = [2.0, 3.0, 4.0] # zooms >>> A = compose(T, R, Z) >>> A array([[ 0., -3., 0., 20.], [ 2., 0., 0., 30.], [ 0., 0., 4., 40.], [ 0., 0., 0., 1.]]) >>> S = np.zeros(3) >>> B = compose(T, R, Z, S) >>> np.all(A == B) True A null set >>> compose(np.zeros(3), np.eye(3), np.ones(3), np.zeros(3)) array([[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.], [0., 0., 0., 1.]]) ''' n = len(T) R = np.asarray(R) if R.shape != (n, n): raise ValueError('Expecting shape (%d,%d) for rotations' % (n, n)) A = np.eye(n + 1) if not S is None: Smat = striu2mat(S) ZS = np.dot(np.diag(Z), Smat) else: ZS = np.diag(Z) A[:n, :n] = np.dot(R, ZS) A[:n, n] = T[:] return A
def random_eval_experiment(): ''' Experiment illutrating how quickly global random evaluation will fail as a method of optimization. Output is minimum value attained by random sampling over the cube [-1,1] x [-1,1] x... [-1,1] evaluating simple quadratic for 100, 1000, or 10000 times. The dimension is increased from 1 to 100 and the minimum plotted for each dimension. ''' # define symmetric quadratic N-dimensional g = lambda w: np.dot(w.T, w) # loop over dimensions, sample points, evaluate mean_evals = [] big_dim = 100 num_pts = 10000 pt_stops = [100, 1000, 10000] for dim in range(big_dim): dim_eval = [] m_eval = [] for pt in range(num_pts): # generate random point using uniform r = 2 * np.random.rand(dim + 1) - 1 e = g(r) dim_eval.append(e) # record mean and std of so many pts if (pt + 1) in pt_stops: m_eval.append(np.min(dim_eval)) mean_evals.append(m_eval) # convert to array for easy access mean_evals_global = np.asarray(mean_evals) fig = plt.figure(figsize=(6, 3)) # create subplot with 3 panels, plot input function in center plot gs = gridspec.GridSpec(1, 1, width_ratios=[1]) fig.subplots_adjust(wspace=0.5, hspace=0.01) # plot input function ax = plt.subplot(gs[0]) for k in range(len(pt_stops)): mean_evals = mean_evals_global[:, k] # scatter plot mean value ax.plot(np.arange(big_dim) + 1, mean_evals) # clean up plot - label axes, etc., ax.set_xlabel('dimension of input') ax.set_ylabel('funciton value') # draw legend t = [str(p) for p in pt_stops] ax.legend(t, bbox_to_anchor=(1, 0.5)) # draw horizontal axis ax.plot(np.arange(big_dim) + 1, np.arange(big_dim) * 0, linewidth=1, linestyle='--', color='k') plt.show()
def predict_percentile( self, df: DataFrame, *, ancillary_df: Optional[DataFrame] = None, p: float = 0.5, conditional_after: Optional[ndarray] = None) -> DataFrame: """ Returns the median lifetimes for the individuals, by default. If the survival curve of an individual does not cross ``p``, then the result is infinity. http://stats.stackexchange.com/questions/102986/percentile-loss-functions 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. ancillary_X: numpy array or DataFrame, optional 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. p: float, optional (default=0.5) the percentile, must be between 0 and 1. conditional_after: iterable, optional Must be equal is size to df.shape[0] (denoted `n` above). An iterable (array, list, series) of possibly non-zero values that represent how long the subject has already lived for. Ex: if :math:`T` is the unknown event time, then this represents :math:`T | T > s`. This is useful for knowing the *remaining* hazard/survival of censored subjects. The new timeline is the remaining duration of the subject, i.e. normalized back to starting at 0. Returns ------- percentiles: DataFrame See Also -------- predict_median """ exp_mu_, sigma_ = self._prep_inputs_for_prediction_and_return_scores( df, ancillary_df) if conditional_after is None: return pd.DataFrame( exp_mu_ * np.exp(np.sqrt(2) * sigma_ * erfinv(2 * (1 - p) - 1)), index=_get_index(df)) else: conditional_after = np.asarray(conditional_after) Z = (np.log(conditional_after) - np.log(exp_mu_)) / sigma_ S = norm.sf(Z) return pd.DataFrame( exp_mu_ * np.exp(np.sqrt(2) * sigma_ * erfinv(2 * (1 - p * S) - 1)) - conditional_after, index=_get_index(df), )
def _get_weights(tt): tt = np.asarray(tt) W = np.zeros((tt.size, tt.size)) h = np.diff(tt) for i in range(len(tt)): W[i, :i] += .5 * h[:i] W[i, 1:i + 1] += .5 * h[:i] return W
def __init__(self, sigma2s, wts=None): """ Mixture of isotropic Gaussian kernels: sum wts[i] * exp(- ||x - y||^2 / (2 * sigma2s[i])) sigma2s: a list/array of squared bandwidths wts: a list/array of weights. Defaults to equal weights summing to 1. """ self.sigma2s = sigma2s = np.asarray(sigma2s) assert len(sigma2s) > 0 if wts is None: self.wts = wts = np.full(len(sigma2s), 1/len(sigma2s)) else: self.wts = wts = np.asarray(wts) assert len(wts) == len(sigma2s) assert all(w >= 0 for w in wts)
def poly_feats(self,D): F = [] for i in range(D+1): for j in range(D+1-i): f = (self.x[:,0]**i)*(self.x[:,1]**j) F.append(f) F = np.asarray(F) return F.T
def circulant_2d_vector_to_circulant_2d_matrix(circulant_2d_vector): circulant_2d_matrix = np.asarray([ np.roll(circulant_2d_vector, ii) for ii in range(len(circulant_2d_vector)) ]) return circulant_2d_matrix
def print_training_prediction(weights): print("Training text Predicted text") logprobs = np.asarray(lstm_predict(weights, train_inputs)) for t in range(logprobs.shape[1]): training_text = one_hot_to_string(train_inputs[:,t,:]) predicted_text = one_hot_to_string(logprobs[:,t,:]) print(training_text.replace('\n', ' ') + "|" + predicted_text.replace('\n', ' '))
def unflatten(flat, model): """Wrapper for :func:`_unflatten`. """ # pylint:disable=len-as-condition res, tail = _unflatten(np.asarray(flat), model) if len(tail) != 0: raise ValueError('Flattened iterable has more elements than the model.') return res
def compute_evaluation(self, tetvalue): if tetvalue.top == 'T': if len(self.children) == 0: return 1 else: evaluations = [[] for _ in range(len(tetvalue.multisets))] for i in range(len(tetvalue.multisets)): child = self.children[i] n_elements = len(tetvalue.multisets[i].elements) print("elements", i, n_elements) print(type(n_elements)) for subvalue in tetvalue.multisets[i].elements: evaluations[i].append( (child.compute_evaluation(subvalue[0]), subvalue[1])) print(np.asarray(evaluations)) return self.activation.forward(np.asarray(evaluations))
def trial_function(self, x_in, weights): """Compute the trail function c_t.""" net = self.mlp.network_output(x_in, weights) y_const = np.asarray([x_in[0], 1.0]) net_y = self.mlp.network_output(y_const, weights) dy_net = self.grad_network(y_const, weights)[1] return self.bc(x_in) + x_in[0] * (1.0 - x_in[0]) * x_in[1] * \ (net - net_y - dy_net)
def _get_weights(tt): tt = np.asarray(tt) W = np.zeros((tt.size, tt.size)) h = np.diff(tt) for i in range(len(tt)): W[i, :i] += .5 * h[:i] W[i, 1:i+1] += .5 * h[:i] return W
def set_loss_control_points(self): """Select a subset of control points used for training.""" training_points = [] training_indices = [] points_and_indices = [(i, point) for i, point in enumerate(self.control_points)] shuffle(points_and_indices) for i in range(len(points_and_indices)): if (i + 1) % self.every == 0: training_points.append(points_and_indices[i][1]) training_indices.append(points_and_indices[i][0]) self.loss_control_points = np.asarray(training_points) self.loss_indices = np.asarray(training_indices) len_training = len(self.loss_control_points) len_all = len(self.control_points) print("Selecting subset for training: {} out of {} \ selected.".format(len_training, len_all))
def get_dx_g(self, x): atoms4 = self.atoms4 atoms3 = self.atoms3 p = self.p d = self.d combos = np.asarray([[0, 1, 2], [1, 2, 3], [0, 2, 3], [0, 1, 3]]) output = np.zeros((d, p)) for k in range(p): atom4 = atoms4[k, :] angles4 = [] # get identities of triangles on boundary of tetrahedron # which atoms3 are in the atoms4... actived = [ np.where([ set(item).issubset(atom4[combos[i, :]]) for item in atoms3 ])[0][0] for i in range(4) ] actived = np.asarray(actived, dtype=int) naive = np.reshape(x, (int(x.shape[0] / 3), 3))[actived, :] for i in range(4): a = atoms3[actived[i]] b = atom4[np.in1d(atom4, atoms3[actived[i]])] for j in range(3): angles4.append(naive[i, np.where(a == b[j])[0]]) # the jth positEion in the ith row contains the gradient corresponding to the jth position in the truncated atom4 a4 = np.reshape(angles4, (4, 3)) # fitin = g4(a4)[1] fitin = self.gradg4(a4) faceindex = np.zeros(4) for j in range(4): face = atom4[combos[j]] for i in range(4): if collections.Counter( atoms3[actived][i]) == collections.Counter(face): faceindex[j] = i faceindex = np.asarray(faceindex, dtype=int) anglerowtooutput = actived[faceindex] #print(anglerowtooutput) for i in range(4): face = atom4[combos[i]] buffer = np.asarray(scipy.stats.rankdata(face) - 1, dtype=int) for j in range(3): output[3 * anglerowtooutput[i] + buffer[j], k] = fitin[i, j] return (output)
def contour_plot(ax, g, pts, wmax, num_contours, my_colors, pts_levels): #### define input space for function and evaluate #### w1 = np.linspace(-wmax, wmax, 100) w2 = np.linspace(-wmax, wmax, 100) w1_vals, w2_vals = np.meshgrid(w1, w2) w1_vals.shape = (len(w1)**2, 1) w2_vals.shape = (len(w2)**2, 1) h = np.concatenate((w1_vals, w2_vals), axis=1) func_vals = np.asarray([g(s) for s in h]) w1_vals.shape = (len(w1), len(w1)) w2_vals.shape = (len(w2), len(w2)) func_vals.shape = (len(w1), len(w2)) ### make contour right plot - as well as horizontal and vertical axes ### # set level ridges levelmin = min(func_vals.flatten()) levelmax = max(func_vals.flatten()) cutoff = 0.3 cutoff = (levelmax - levelmin) * cutoff numper = 3 levels1 = np.linspace(cutoff, levelmax, numper) num_contours -= numper ##### plot filled contours with generic contour lines ##### # produce generic contours levels2 = np.linspace(levelmin, cutoff, min(num_contours, numper)) levels = np.unique(np.append(levels1, levels2)) num_contours -= numper while num_contours > 0: cutoff = levels[1] levels2 = np.linspace(levelmin, cutoff, min(num_contours, numper)) levels = np.unique(np.append(levels2, levels)) num_contours -= numper # plot the contours ax.contour(w1_vals, w2_vals, func_vals, levels=levels[1:], colors='k') ax.contourf(w1_vals, w2_vals, func_vals, levels=levels, cmap='Blues') ###### add contour curves based on input points ##### # add to this list the contours passing through input points ax.contour(w1_vals, w2_vals, func_vals, levels=pts_levels, colors='k', linewidths=3) ax.contour(w1_vals, w2_vals, func_vals, levels=pts_levels, colors=my_colors, linewidths=2.5) ###### clean up plot ###### ax.set_xlabel('$w_0$', fontsize=12) ax.set_ylabel('$w_1$', fontsize=12, rotation=0) ax.axhline(y=0, color='k', zorder=0, linewidth=0.5) ax.axvline(x=0, color='k', zorder=0, linewidth=0.5)
def problem1(part): x_train_N = ag_np.asarray([-5.0, -2.50, 0.00, 2.50, 5.0]) y_train_N = ag_np.asarray([-4.91, -2.48, 0.05, 2.61, 5.09]) n_samples_list = [1, 10, 100, 1000] # mean of w m_tilda_list = ag_np.linspace(-3.0, 5.0, 20) # log stddev of w s_tilda = ag_np.log(0.1) # mean of b m_bar = 0.0 # log stddev of b s_bar = ag_np.log(0.1) loss_lists_for_all_of_the_sample_sizes = [] for n_samples in n_samples_list: loss_list_for_one_of_the_sample_sizes = [] for m_tilda in m_tilda_list: sum_loss_for_n_samples = 0 for n in range(0, n_samples): if part == 'a': loss = approximate_loss(m_tilda, m_bar, s_tilda, s_bar, x_train_N, y_train_N) if part == 'c': loss = approximate_loss_grad(m_tilda, m_bar, s_tilda, s_bar, x_train_N, y_train_N) sum_loss_for_n_samples += loss sum_loss_for_n_samples_and_m_tilda = sum_loss_for_n_samples / n_samples loss_list_for_one_of_the_sample_sizes.append( sum_loss_for_n_samples_and_m_tilda) loss_lists_for_all_of_the_sample_sizes.append( loss_list_for_one_of_the_sample_sizes) plot_prior_data(m_tilda_list, n_samples_list, loss_lists_for_all_of_the_sample_sizes)
def _set_startprob_prior(self, startprob_prior): if startprob_prior is None or startprob_prior == 1.0: startprob_prior = np.zeros(self.n_components) else: startprob_prior = np.asarray(startprob_prior, dtype=np.float) if len(startprob_prior) != self.n_components: if len(startprob_prior) == self.n_unique: startprob_prior_split = np.copy(startprob_prior) / \ (1.0 + self.n_tied) startprob_prior = np.zeros(self.n_components) for u in range(self.n_unique): for t in range(self.n_chain): startprob_prior[u*(self.n_chain)+t] = \ startprob_prior_split[u].copy() else: raise ValueError("cannot match shape of startprob") self.startprob_prior = np.asarray(startprob_prior).copy()
def _set_mu_prior(self, mu_prior): if mu_prior is None: self._mu_prior_ = np.zeros((self.n_components, self.n_features)) else: mu_prior = np.asarray(mu_prior) mu_prior = mu_prior.reshape(self.n_unique, self.n_features) if mu_prior.shape == (self.n_unique, self.n_features): self._mu_prior_ = mu_prior.copy() else: raise ValueError("cannot match shape of mu_prior")
def gmm_objective(alphas,means,icf,x,wishart_gamma,wishart_m): def inner_term(ix,ik): xcentered = x[ix,:] - means[ik,:] Lxcentered = Qtimesx(Qdiags[ik,:],Ls[ik,:,:],xcentered) sqsum_Lxcentered = sqsum(Lxcentered) return alphas[ik] + sum_qs[ik] - 0.5*sqsum_Lxcentered n = x.shape[0] d = x.shape[1] k = alphas.size Qdiags = np.asarray([(np.exp(icf[ik,:d])) for ik in range(k)]) sum_qs = np.asarray([(np.sum(icf[ik,:d])) for ik in range(k)]) Ls = np.asarray([constructL(d,curr_icf) for curr_icf in icf]) slse = 0 for ix in range(n): lse = np.asarray([inner_term(ix,ik) for ik in range(k)]) slse = slse + logsumexp(lse) CONSTANT = -n*d*0.5*np.log(2 * np.pi) return CONSTANT + slse - n*logsumexp(alphas) \ + log_wishart_prior(d,wishart_gamma,wishart_m,sum_qs,Qdiags,icf)
def _set_transmat(self, transmat_val): if transmat_val is None: transmat = np.tile(1.0 / self.n_components, (self.n_components, self.n_components)) else: transmat_val[np.isnan(transmat_val)] = 0.0 normalize(transmat_val, axis=1) if (np.asarray(transmat_val).shape == (self.n_components, self.n_components)): transmat = np.copy(transmat_val) elif transmat_val.shape[0] == self.n_unique: transmat = self._ntied_transmat(transmat_val) else: raise ValueError("cannot match shape of transmat") if not np.all(np.allclose(np.sum(transmat, axis=1), 1.0)): raise ValueError('Rows of transmat must sum to 1.0') self._log_transmat = np.log(np.asarray(transmat).copy()) underflow_idx = np.isnan(self._log_transmat) self._log_transmat[underflow_idx] = NEGINF
def gmm_objective_split_inner(alphas,means,icf,x): def inner_term(ik): sum_qs = icf[ik,:d].sum() xcentered = x - means[ik,:] Qdiag = np.exp(icf[ik,:d]) L = constructL(d,icf[ik,:]) Lxcentered = Qtimesx(Qdiag,L,xcentered) return alphas[ik] + sum_qs - 0.5*sqsum(Lxcentered) d = x.size k = alphas.size lse = np.asarray([inner_term(ik) for ik in range(k)]) return logsumexp(lse)
def _setup_times(self, tt, h=None, tt_aug=None): """ Handles storing of training times and augmenting the time vector. """ # make sure all the times are arrays tt = [np.asarray(item) for item in tt] ttc, data_inds = handle_time_inds(tt, h) self.x_train_ = tt self.ttc = ttc self.data_inds = data_inds self.is_tt_aug = True # store the dimension variable _, K, R, D = self.dim self.dim = Dimensions(self.ttc.size, K, R, D) self.N_data = tuple(item.size for item in self.x_train_)
def _set_precision_prior(self, precision_prior): if precision_prior is None: self._precision_prior_ = \ np.zeros((self.n_components, self.n_features, self.n_features)) else: precision_prior = np.asarray(precision_prior) if len(precision_prior) == 1: self._precision_prior_ = np.tile(precision_prior, (self.n_components, self.n_features, self.n_features)) elif \ (precision_prior.reshape(self.n_unique, self.n_features, self.n_features)).shape \ == (self.n_unique, self.n_features, self.n_features): self._precision_prior_ = \ np.zeros((self.n_components, self.n_features, self.n_features)) for u in range(self.n_unique): for t in range(self.n_chain): self._precision_prior_[u*(self.n_chain)+t] = precision_prior[u].copy() else: raise ValueError("cannot match shape of precision_prior")
def _set_var_prior(self, var_prior): var_prior = np.asarray(var_prior) if self.n_features == 1: self._set_precision_prior(1.0 / var_prior) else: self._set_precision_prior(np.linalg.inv(var_prior))
def _read_kurucz_spec(f): """ Read Kurucz spectra that have been precomputed Args: f (string) : path to the file to be read Returns: new_vel (real array) : velocity axis in km/s spectrum (real array) : spectrum for each velocity bin """ f = open(f, "rb") res = f.read() n_chunk = struct.unpack('i',res[0:4]) freq = [] stokes = [] cont = [] left = 4 for i in range(n_chunk[0]): right = left + 4 n = struct.unpack('i',res[left:right]) left = right right = left + 4 nmus = struct.unpack('i',res[left:right]) left = right right = left + 8*n[0] t1 = np.asarray(struct.unpack('d'*n[0],res[left:right])) freq.append(t1) left = right right = left + 8*n[0]*nmus[0] t2 = np.asarray(struct.unpack('d'*n[0]*nmus[0],res[left:right])).reshape((n[0],nmus[0])) stokes.append(t2) left = right right = left + 8*n[0]*nmus[0] t2 = np.asarray(struct.unpack('d'*n[0]*nmus[0],res[left:right])).reshape((n[0],nmus[0])) cont.append(t2) left = right freq = np.concatenate(freq) stokes = np.concatenate(stokes) cont = np.concatenate(cont) ind = np.argsort(freq) freq = freq[ind] stokes = stokes[ind] cont = cont[ind] wavelength = const.c.to('cm/s').value / freq mean_wavelength = np.mean(wavelength) vel = (wavelength - mean_wavelength) / mean_wavelength * const.c.to('km/s').value nl, nmus = stokes.shape # Reinterpolate in a equidistant velocity axis new_vel = np.linspace(np.min(vel), np.max(vel), nl) for i in range(nmus): interpolator = scipy.interpolate.interp1d(vel, stokes[:,i], kind='linear') stokes[:,i] = interpolator(new_vel) return new_vel, wavelength, stokes
def scalar_subtract_and_exp(a,scalar): return np.asarray([np.exp(a[i] - scalar) for i in range(a.size)])
def scalar_multiply(a,scalar): return np.asarray([(a[i] * scalar) for i in range(a.size)])
def cwise_multiply(a,b): return np.asarray([(a[i] * b[i]) for i in range(a.size)])
def _set_var_prior(self, var_prior): var_prior = np.asarray(var_prior) self._set_precision_prior(1.0 / var_prior)