def randomRotation(): """ Get random rotation matrix. Written by Michael Habeck. :return: 3 x 3 array of float :rtype: array """ alpha = R.random_sample() * 2 * N0.pi gamma = R.random_sample() * 2 * N0.pi beta = N0.arccos(2*(R.random_sample() - 0.5)) return eulerRotation(alpha, beta, gamma)
def randomRotation(): """ Get random rotation matrix. Written by Michael Habeck. :return: 3 x 3 array of float :rtype: array """ alpha = R.random_sample() * 2 * N0.pi gamma = R.random_sample() * 2 * N0.pi beta = N0.arccos(2 * (R.random_sample() - 0.5)) return eulerRotation(alpha, beta, gamma)
def test_change(dset_key, conn, fun): """Takes in a data set key and computes g(r) with different amounts of noise added to the positions returns a list of the g(r)""" max_rng = 100 nbins = 1000 buff = 1 cull_rate = 0.5 (fname, comp_num) = conn.execute( "select fout,comp_key from comps where dset_key =?" + " and function = 'Iden'", (dset_key,) ).fetchone() F = h5py.File(fname, "r") frame = 10 x = F["/frame%(#)06d" % {"#": frame} + "/x_%(#)07d" % {"#": comp_num}] y = F["/frame%(#)06d" % {"#": frame} + "/y_%(#)07d" % {"#": comp_num}] parts = [a for a in itertools.izip(x, y) if nrm.random_sample() < cull_rate] steps = 5 gs = [] for j in range(0, steps): hc = sc.hash_case((np.ceil(np.max(x)), np.ceil(np.max(y))), max_rng) gofr = sc.gofr_comp(nbins, max_rng) for p in parts: hc.add_particle(fun(p, j)) pass hc.compute_corr(buff, gofr.add_particle) gs.append(cord_pairs(gofr.bin_edges, gofr.vals)) return gs
def generate(self): matrix = 8 * random_sample((3, 8)) - 4 for i in range(3): for j in range(8): if i + 6 == j: matrix[i][j] = 0 return matrix
def random_Butter(n=(5, 10), Wc=(0.1, 0.8), W1=(0.1, 0.5), W2=(0.5, 0.8), form=None, onlyEven=True, seed=None): """ Generate a n-th order Butterworh filters Parameters ---------- - n: (int) The order of the filter - Wc: used if btype is 'lowpass' or 'highpass' Wc is a tuple (min,max) for the cut frequency - W1 and W2: used if btype is ‘bandpass’, ‘bandstop’ W1 and W2 are tuple (min,max) for the two start/stop frequencies - form: (string) {None, ‘lowpass’, ‘highpass’, ‘bandpass’, ‘bandstop’}. Gives the type of filter. If None, the type is randomized - onlyEven: if True, only even order filter are generated - seed: if not None, indicates the seed toi use for the random part (in order to be reproductible, the seed is stored in the name of the filter) """ # change the seed if asked if seed: numpy_seed(seed) # choose a form if asked if form is None: form = choice(("lowpass", "highpass", "bandpass", "bandstop")) # choose Wn if form in ("bandpass", "bandstop"): # choose 2 frequencies if W2[1] <= W1[0]: raise ValueError("iter_random_Butter: W1 should be lower than W2") Wn1 = (W1[1] - W1[0]) * random_sample() + W1[0] Wn2 = (W2[1] - W2[0]) * random_sample() + W2[0] while Wn2 <= Wn1: Wn2 = (W2[1] - W2[0]) * random_sample() + W2[0] W = [Wn1, Wn2] else: # choose 1 frequency W = (Wc[1] - Wc[0]) * random_sample() + Wc[0] # choose order order = randint(*n) if onlyEven and order % 2 == 0: order += 1 return Butter(order, W, form, name='Butterworth-random-%d' % seed)
def random_TF(n=(5, 10), Wc=(0.1, 0.8), W1=(0.1, 0.5), W2=(0.5, 0.8)): """Generate one n-th order stable butterworth filter ((num, den) of the transfer function)""" # choose a form form = choice(['lowpass', 'highpass', 'bandpass', 'bandstop']) # choose Wn if form in ("bandpass", "bandstop"): # choose 2 frequencies such that Wn2<=Wn1 Wn1 = (W1[1] - W1[0]) * random_sample() + W1[0] Wn2 = (W2[1] - W2[0]) * random_sample() + W2[0] while Wn2 <= Wn1: Wn2 = (W2[1] - W2[0]) * random_sample() + W2[0] W = [Wn1, Wn2] else: # choose 1 frequency W = (Wc[1] - Wc[0]) * random_sample() + Wc[0] # choose order order = randint(*n) num, den = butter(order, W, form) return num, den
def test_FuzzyCluster( self): """FuzzyCluster test""" import gnuplot as G x1 = R.random_sample((500,2)) x2 = R.random_sample((500,2)) + 1 x3 = R.random_sample((500,2)) + 2 self.x = N0.concatenate((x1, x2, x3)) self.fuzzy = FuzzyCluster(self.x, n_cluster=5, weight=1.5) self.centers = self.fuzzy.go(1.e-30, n_iterations=50, nstep=10, verbose=self.local) if self.local: print "cluster centers are displayed in green" G.scatter( self.x, self.centers ) self.assertEqual( N0.shape(self.centers), (5, 2) )
def test_FuzzyCluster( self): """FuzzyCluster test""" import biskit.gnuplot as G x1 = R.random_sample((500,2)) x2 = R.random_sample((500,2)) + 1 x3 = R.random_sample((500,2)) + 2 self.x = N0.concatenate((x1, x2, x3)) self.fuzzy = FuzzyCluster(self.x, n_cluster=5, weight=1.5) self.centers = self.fuzzy.go(1.e-30, n_iterations=50, nstep=10, verbose=self.local) if self.local: print("cluster centers are displayed in green") G.scatter( self.x, self.centers ) self.assertEqual( N0.shape(self.centers), (5, 2) )
def random_Elliptic(n=(5, 10), rp=(10, 50), rs=(10, 50), Wc=(0.1, 0.8), W1=(0.1, 0.5), W2=(0.5, 0.8), form=None, seed=None, quant=None): """ Generate a n-th order Butterworh filters Parameters ---------- - n: (int) The order of the filter - Wc: used if btype is 'lowpass' or 'highpass' Wc is a tuple (min,max) for the cut frequency - W1 and W2: used if btype is ‘bandpass’, ‘bandstop’ W1 and W2 are tuple (min,max) for the two start/stop frequencies - form: (string) {None, ‘lowpass’, ‘highpass’, ‘bandpass’, ‘bandstop’}. Gives the type of filter. If None, the type is randomized - quant: quantized the coefficients with quant bits (None by default -> no quantization) - seed: if not None, indicates the seed toi use for the random part (in order to be reproductible, the seed is stored in the name of the filter) """ # change the seed if asked if seed: numpy_seed(seed) # choose a form if asked if form is None: form = choice(("lowpass", "highpass", "bandpass", "bandstop")) # choose Wn if form in ("bandpass", "bandstop"): # choose 2 frequencies if W2[1] <= W1[0]: raise ValueError( "iter_random_Elliptic: W1 should be lower than W2") Wn1 = (W1[1] - W1[0]) * random_sample() + W1[0] Wn2 = (W2[1] - W2[0]) * random_sample() + W2[0] while Wn2 <= Wn1: Wn2 = (W2[1] - W2[0]) * random_sample() + W2[0] W = [Wn1, Wn2] else: # choose 1 frequency W = (Wc[1] - Wc[0]) * random_sample() + Wc[0] # choose rp and rs rip = (rp[1] - rp[0]) * random_sample() + rp[0] rst = (rs[1] - rs[0]) * random_sample() + rs[0] # choose order order = randint(*n) # do we quantified the parameter (to be able to print them exactly, for example) if quant: rip = quantify(rip, quant) rst = quantify(rst, quant) if isinstance(W, list): W = [quantify(W[0], quant), quantify(W[1], quant)] return Elliptic(order, rp=rip, rs=rst, Wn=W, etype=form, name='Elliptic-random-%d' % seed)
def __random_translation( self ): """ Random translation on a sphere around 0,0,0 with fixed radius The radius is the sum of the (max) radius of receptor and ligand @return: translation array 3 x 1 of float @rtype: array """ radius = (self.d_max_rec + self.d_max_lig) / 2.0 xyz = R.random_sample( 3 ) - 0.5 scale = radius*1.0 / N0.sqrt( N0.sum( xyz**2 ) ) return scale * xyz
def create_membership_matrix(self): """ Create a random membership matrix. @return: random array of shape length of data to cluster times number of clusters @rtype: array('f') """ ## default signature has changed oldnumeric->numpy if (self.seedx == 0 or self.seedy == 0): R.seed() else: R.seed((self.seedx, self.seedy)) r = R.random_sample((self.npoints, self.n_cluster)) return N0.transpose(r / N0.sum(r))
def create_membership_matrix(self): """ Create a random membership matrix. @return: random array of shape length of data to cluster times number of clusters @rtype: array('f') """ ## default signature has changed oldnumeric->numpy if (self.seedx==0 or self.seedy==0): R.seed() else: R.seed((self.seedx, self.seedy)) r = R.random_sample((self.npoints, self.n_cluster)) return N0.transpose(r / N0.sum(r))
def compute_clusters(self, pXY, qXhatYhat, qXhat, qXxhat, cXY, axis): """ Compute the best cluster assignment along a single axis, given all the distributions and clusters on other axes. Args: pXY: the original probability distribution matrix qXhatYhat: the joint distribution over the clusters qXhat: the marginal distributions of qXhatYhat qXxhat: the distribution conditioned on the clustering in a list cXY: current cluster assignments along each dimension axis: the axis (dimension) over which clusters are being computed Return: Best cluster assignment along a single axis as a list """ if not isinstance(pXY, SparseMatrix) or not isinstance(qXhatYhat, SparseMatrix): raise Exception("Arguments to compute_clusters not an instance of SparseMatrix.") # To assign clusters, we calculate argmin_xhat D(p(Y,Z|x) || q(Y,Z|xhat)), # where D(P|Q) = \sum_i P_i log (P_i / Q_i) dPQ = np.zeros(shape=(pXY.N[axis], qXhatYhat.N[axis])) # iterate though all non-zero elements; here we are making use of the sparsity to reduce computation for coords, p_i in pXY.nonzero_elements.iteritems(): coord_this_axis = coords[axis] px = self.pX[axis][coord_this_axis] p_i = 1 if px == 0 else p_i / px # calculate p(y|x) = p(x,y)/p(x), but we should be careful if px == 0 current_cluster_assignments = [cXY[i][coords[i]] for i in xrange(self.dim)] # cluster assignments on each axis for xhat in xrange(self.K[axis]): current_cluster_assignments[axis] = xhat # temporarily assign dth dimension to this xhat current_qXhatYhat = qXhatYhat.get(tuple(current_cluster_assignments)) current_qXhat = qXhat[axis][xhat] q_i = 1.0 if current_qXhatYhat == 0 and current_qXhat == 0: q_i = 0 # Here we define 0/0=0 else: q_i *= current_qXhatYhat / current_qXhat for i in xrange(self.dim): if i == axis: continue q_i *= qXxhat[i][coords[i]] if q_i == 0: # this can definitely happen if cluster joint distribution has zero element dPQ[coord_this_axis, xhat] = INFINITE else: dPQ[coord_this_axis, xhat] += p_i * math.log(p_i / q_i) # add random jitter to break ties dPQ += self.jitter_max * random_sample(dPQ.shape) return list(dPQ.argmin(1)) # return the closest cluster assignment under KL-divergence
def solve(self): self.t = 0 self.initialize() self.evaluate() best = np.max(self.fitness) newpop1 = self.population bestIndex = np.argmax(self.fitness) self.best = copy.deepcopy(self.population[bestIndex]) while (self.t < self.MAXGEN and best != 32): self.t += 1 newpop = [] arr = [] fitness_sum = [] population_sum = [] for i in range(self.sizepop): bestmatrix = self.best.matrix bestmatrix1 = 8 * random_sample((3, 8)) - 4 ind = GAIndividual() ind.matrix = bestmatrix1 newpop.append(ind) population_sum = newpop1 + newpop for i in range(2 * self.sizepop): fitness_sum.append(population_sum[i].calculateFitness()) fitness_sum = np.array(fitness_sum) arr = np.argsort(-fitness_sum) for i in range(self.sizepop): newpop[i] = population_sum[arr[i]] self.population = [] self.population = newpop self.evaluate() best = np.max(self.fitness) bestIndex = np.argmax(self.fitness) best = np.max(self.fitness) newpop1 = self.population if best == 32: break matrix2 = self.population[bestIndex].matrix for i in range(3): for j in range(8): print(matrix2[i][j], end=' ') print("") print(self.iteration)
def initialize_cluster_centers(self, pXY, K): """ Initializes the cluster assignments along each axis, by first selecting k centers, and then map each row to its closet center under cosine similarity. Args: pXY: original data matrix K: numbers of clusters desired in each dimension Return: new_C: a list of list of cluster id that the current index in the current axis is assigned to. """ if not isinstance(pXY, SparseMatrix): raise Exception("Matrix argument to initialize_cluster_centers is not an instance of SparseMatrix.") new_C = [[-1] * Ni for Ni in pXY.N] for axis in xrange(len(K)): # loop over each dimension # choose cluster centers axis_length = pXY.N[axis] center_indices = random.sample(xrange(axis_length), K[axis]) cluster_ids = {} for i in xrange(K[axis]): # assign identifiers to clusters center_index = center_indices[i] cluster_ids[center_index] = i centers = defaultdict(lambda: defaultdict(float)) # all nonzero indices for each center for coords in pXY.nonzero_elements: coord_this_axis = coords[axis] if coord_this_axis in cluster_ids: # is a center reduced_coords = tuple([coords[i] for i in xrange(len(coords)) if i != axis]) # coords without the current axis centers[cluster_ids[coord_this_axis]][reduced_coords] = pXY.nonzero_elements[coords] # (cluster_id, other coords) -> value # assign rows to clusters scores = np.zeros(shape=(pXY.N[axis], K[axis])) # scores: axis_size x cluster_number denoms_P = np.zeros(shape=(pXY.N[axis])) denoms_Q = np.zeros(shape=(K[axis])) for coords in pXY.nonzero_elements: coord_this_axis = coords[axis] if coord_this_axis in center_indices: continue # don't reassign cluster centers, please reduced_coords = tuple([coords[i] for i in xrange(len(coords)) if i != axis]) for cluster_index in cluster_ids: xhat = cluster_ids[cluster_index] # need cluster ID, not the axis index if reduced_coords in centers[xhat]: # overlapping point P_i = pXY.nonzero_elements[coords] Q_i = centers[xhat][reduced_coords] scores[coords[axis]][xhat] += P_i * Q_i # now doing based on cosine similarity denoms_P[coords[axis]] += P_i * P_i # magnitude of this slice of original matrix denoms_Q[xhat] += Q_i * Q_i # magnitude of cluster centers # normalize scores scores = divide(scores, outer(sqrt(denoms_P), sqrt(denoms_Q))) scores[scores == 0] = -1.0 # add random jitter to scores to handle tie-breaking scores += self.jitter_max * random_sample(scores.shape) new_cXYi = list(scores.argmax(1)) # this needs to be argmax because cosine similarity # make sure to assign the cluster centers to themselves for center_index in cluster_ids: new_cXYi[center_index] = cluster_ids[center_index] # ensure numbers of clusters are correct self.ensure_correct_number_clusters(new_cXYi, K[axis]) new_C[axis] = new_cXYi return new_C
std_deviation = 0.3 noise = std_deviation * randn(N) t = tlab + noise for idx, val in enumerate(mDegrees): w = polyfit(x, t, val) row = idx / 2 col = idx % 2 fig = ax[row, col] fig.set_title('M=%d' % val) fig.plot(xlab, ylab) fig.plot(x, t, 'ro') fig.plot(xlab, polynomial(w, xlab), 'g') NTest = 8 xTest = random_sample(NTest) yTest = sin(2 * pi * xTest) + randn(NTest) * std_deviation test_err = [] train_err = [] maxOrder = 10 figError = plt.figure() for m in range(0, maxOrder): weights = polyfit(x, t, m) train_err.append(rms(weights, x, t)) test_err.append(rms(weights, xTest, yTest)) plt.xlabel("M")
def random(shape=[]): "random(n) or random([n, m, ...]) returns array of random numbers" if shape == []: shape = None return mt.random_sample(shape)
t = tlab + noise for idx, val in enumerate(mDegrees): w = polyfit(x, t, val) row = idx / 2 col = idx % 2 fig = ax[row, col] fig.set_title('M=%d' % val) fig.plot(xlab, ylab) fig.plot(x, t, 'ro') fig.plot(xlab, polynomial(w, xlab), 'g') NTest = 8 xTest = random_sample(NTest) yTest = sin(2 * pi * xTest) + randn(NTest) * std_deviation test_err = [] train_err = [] maxOrder = 10 figError = plt.figure() for m in range(0, maxOrder): weights = polyfit(x, t, m) train_err.append(rms(weights, x, t)) test_err.append(rms(weights, xTest, yTest))