def problem_params(lr, gam, memories, inpst, neurons): """ Return the lowest eigenvector of the classical Hamiltonian constructed by the learning rule, gamma, memories, and input. """ # Bias Hamiltonian alpha = gam * np.array(inpst) # Memory Hamiltonian beta = np.zeros((qubits, qubits)) if lr == "hebb": # Hebb rule memMat = sp.matrix(memories).T beta = sp.triu(memMat * memMat.T) / float(neurons) elif lr == "stork": # Storkey rule Wm = sp.zeros((neurons, neurons)) for m, mem in enumerate(memories): Am = sp.outer(mem, mem) - sp.eye(neurons) Wm += (Am - Am * Wm - Wm * Am) / float(neurons) beta = sp.triu(Wm) elif lr == "proj": # Moore-Penrose pseudoinverse rule memMat = sp.matrix(memories).T beta = sp.triu(memMat * sp.linalg.pinv(memMat)) # Find the eigenvectors evals, evecs = sp.linalg.eig(np.diag(alpha) + beta) idx = evals.argsort() return evals[idx], evecs[:, idx], np.diag(alpha), beta
def problem_params(lr, gam, memories, inpst, neurons): """ Return the lowest eigenvector of the classical Hamiltonian constructed by the learning rule, gamma, memories, and input. """ # Bias Hamiltonian alpha = gam * np.array(inpst) # Memory Hamiltonian beta = np.zeros((qubits, qubits)) if lr == 'hebb': # Hebb rule memMat = sp.matrix(memories).T beta = sp.triu(memMat * memMat.T) / float(neurons) elif lr == 'stork': # Storkey rule Wm = sp.zeros((neurons, neurons)) for m, mem in enumerate(memories): Am = sp.outer(mem, mem) - sp.eye(neurons) Wm += (Am - Am * Wm - Wm * Am) / float(neurons) beta = sp.triu(Wm) elif lr == 'proj': # Moore-Penrose pseudoinverse rule memMat = sp.matrix(memories).T beta = sp.triu(memMat * sp.linalg.pinv(memMat)) # Find the eigenvectors evals, evecs = sp.linalg.eig(np.diag(alpha) + beta) idx = evals.argsort() return evals[idx], evecs[:, idx], np.diag(alpha), beta
def from_gene(self, gene): sg = gene.splicegraph.vertices breakpoints = sp.unique(sg.ravel()) self.segments = sp.zeros((2, 0), dtype='int') for j in range(1, breakpoints.shape[0]): s = sp.sum(sg[0, :] < breakpoints[j]) e = sp.sum(sg[1, :] < breakpoints[j]) if s > e: self.segments = sp.c_[self.segments, [breakpoints[j-1], breakpoints[j]]] ### match nodes to segments self.seg_match = sp.zeros((0, sg.shape[1]), dtype='bool') for j in range(sg.shape[1]): tmp = ((sg[0, j] <= self.segments[0, :]) & (sg[1, j] >= self.segments[1, :])) if self.seg_match.shape[0] == 0: self.seg_match = tmp.copy().reshape((1, tmp.shape[0])) else: self.seg_match = sp.r_[self.seg_match, tmp.reshape((1, tmp.shape[0]))] ### create edge graph between segments self.seg_edges = sp.zeros((self.segments.shape[1], self.segments.shape[1]), dtype='bool') k, l = sp.where(sp.triu(gene.splicegraph.edges)) for m in range(k.shape[0]): ### donor segment d = sp.where(self.seg_match[k[m], :])[0][-1] ### acceptor segment a = sp.where(self.seg_match[l[m], :])[0][0] self.seg_edges[d, a] = True
def from_gene(self, gene): sg = gene.splicegraph.vertices breakpoints = sp.unique(sg.ravel()) self.segments = sp.zeros((2, 0), dtype='int') for j in range(1, breakpoints.shape[0]): s = sp.sum(sg[0, :] < breakpoints[j]) e = sp.sum(sg[1, :] < breakpoints[j]) if s > e: self.segments = sp.c_[self.segments, [breakpoints[j - 1], breakpoints[j]]] ### match nodes to segments self.seg_match = sp.zeros((0, sg.shape[1]), dtype='bool') for j in range(sg.shape[1]): tmp = ((sg[0, j] <= self.segments[0, :]) & (sg[1, j] >= self.segments[1, :])) if self.seg_match.shape[0] == 0: self.seg_match = tmp.copy().reshape((1, tmp.shape[0])) else: self.seg_match = sp.r_[self.seg_match, tmp.reshape((1, tmp.shape[0]))] ### create edge graph between segments self.seg_edges = sp.zeros( (self.segments.shape[1], self.segments.shape[1]), dtype='bool') k, l = sp.where(sp.triu(gene.splicegraph.edges)) for m in range(k.shape[0]): ### donor segment d = sp.where(self.seg_match[k[m], :])[0][-1] ### acceptor segment a = sp.where(self.seg_match[l[m], :])[0][0] self.seg_edges[d, a] = True
def add_intron_retention(self, idx1, idx2): adj_mat = sp.triu(self.edges) self.vertices = sp.c_[ self.vertices, sp.array([self.vertices[0, idx1], self.vertices[1, idx2]], dtype='int')] self.new_edge() adj_mat = sp.r_[adj_mat, sp.zeros((1, adj_mat.shape[1]), dtype='int')] adj_mat = sp.c_[adj_mat, sp.zeros((adj_mat.shape[0], 1), dtype='int')] ### check if adjacency matrix is symmetric ### otherwise or is not justyfied assert (sp.all(sp.all(adj_mat - (self.edges - adj_mat).T == 0))) ### AK: under the assumption that our splice graph representation is symmetric ### I preserve symmetry by using OR over the adj_mat column and row self.edges[:, -1] = adj_mat[:, idx1] | adj_mat[idx2, :].T self.edges[-1, :] = adj_mat[:, idx1].T | adj_mat[idx2, :] self.terminals = sp.c_[ self.terminals, sp.array([self.terminals[0, idx1], self.terminals[1, idx2]], dtype='int')]
def calcElasticEnergy(pdb, refpdb, sel="calpha", cutoff=12, k=1): import prody as pd import numpy as np import scipy as sci import scipy.spatial as sp # Select desired atoms, retrieve reference parameters, and initialize Kirchhoff matrix gnm = pd.GNM() gnm.buildKirchhoff(refpdb.calpha, cutoff, k) kirchhoff = gnm.getKirchhoff() np.fill_diagonal(kirchhoff, 0) kirchhoff = abs(kirchhoff) # Calculate distances between Kirchhoff contacts eq_dists = sp.distance.cdist( refpdb.calpha.select(sel).getCoords(), refpdb.calpha.select(sel).getCoords(), metric="euclidean" ) dists = sp.cdist(pdb.calpha.select(sel).getCoords(), pdb.calpha.select(sel).getCoords(), metric="euclidean") # Iterate over coords within ensemble energies = k * np.multiply(np.square(dists - eq_dists), kirchhoff) energies = sci.triu(energies) energies = np.sum(energies) return energies
def calcMultiStateEnergy(ensemble, ensemble_ref, cutoff=12, k=1, U0=None): import prody as pd import scipy as sci import scipy.spatial as sp import numpy as np n_conf = ensemble.numConfs() n_ref = ensemble_ref.numConfs() energies = np.zeros((n_ref, n_conf)) for i, conf_ref in zip(xrange(n_ref), ensemble_ref.iterCoordsets()): gnm = pd.GNM() gnm.buildKirchhoff(conf_ref, cutoff, k) kirchhoff = gnm.getKirchhoff() np.fill_diagonal(kirchhoff, 0) kirchhoff = abs(kirchhoff) eq_dists = sp.distance.squareform(sp.distance.pdist(conf_ref, metric="euclidean")) for j, conf in zip(xrange(n_conf), ensemble.iterCoordsets()): dists = sp.distance.squareform(sp.distance.pdist(conf, metric="euclidean")) springs = (k / 2) * np.multiply(np.square(dists - eq_dists), kirchhoff) springs = sci.triu(springs) energies[i, j] = np.sum(springs) # return np.min(energies, axis=0) return energies
def sample_plaquette(p1, p2, p3, normalize_GS=False): # Generates one of 4 types of plaquette depending on parameters # p1..3 (p4=1-p1-p2-p3) # Type i is a plaqutte containing i GSs (up to flip) including the # FM state. Achieved by generating i weak bonds in the cycle, one # of which is AFM. # Returned J magnitudes on cycle edges are in {1,2}. One of # the mag-1 edges is AFM; all other edges are FM. # Note that this (may) return an *integer-valued* matrix, but when put into full problem in generate_2D_problem, gets converted to real. R = sp.rand() if R < p1: num_GS = 1 elif R < p1 + p2: num_GS = 2 elif R < p1 + p2 + p3: num_GS = 3 else: num_GS = 4 J_plaq = 2 * make_plaquette_adj() edges = sp.where(sp.triu(J_plaq)) num_edges = len(edges[0]) # i.e 4 P = sp.random.permutation(num_edges) # Set the weak edges for e in P[0:num_GS]: (v1, v2) = edges[0][e], edges[1][e] J_plaq[v1, v2] *= 0.5 J_plaq[v2, v1] *= 0.5 # Arbitrarily select the first of the permutation to be AFM e_flip = P[0] (v1, v2) = edges[0][e_flip], edges[1][e_flip] J_plaq[v1, v2] *= -1 J_plaq[v2, v1] *= -1 # Scale such that each cycle has the same GS energy if normalize_GS: J_plaq = sp.float64(J_plaq) minus_EGS = sp.triu(J_plaq).sum() J_plaq /= minus_EGS return J_plaq
def update_terminals(self): self.terminals = sp.zeros(self.vertices.shape, dtype='int') self.terminals[0, sp.where( sp.sum(sp.tril(self.edges), axis=1) == 0)[0]] = 1 self.terminals[1, sp.where( sp.sum(sp.triu(self.edges), axis=1) == 0)[0]] = 1
def modalDiffMatrix(n): """Return the modal differentiation matrix for Chebyshev coefficients""" k = np.arange(n) a = (-1)**k A = sp.triu(1 - np.outer(a, a)) D = np.dot(A, np.diag(k)) D[0, :] = D[0, :] / 2 return D
def modalDiffMatrix(n): """Return the modal differentiation matrix for Chebyshev coefficients""" k = np.arange(n) a = (-1)**k A = sp.triu(1-np.outer(a,a)) D = np.dot(A,np.diag(k)) D[0,:] = D[0,:]/2 return D
def stork2(neurons, memories): memMat = sp.zeros((neurons,neurons)) for m, mem in enumerate(memories): for i in range(neurons): for j in range(i, neurons): hij = sp.sum([ memMat[i,k]*mem[k] for k in range(neurons) ]) hji = sp.sum([ memMat[j,k]*mem[k] for k in range(neurons) ]) # Don't forget to make the normalization a float! memMat[i,j] += (mem[i]*mem[j] - mem[i]*hji - hij*mem[j])/float(neurons) return sp.triu(memMat)
def kpca_cluster(data,nclusters=100,ncomponents=40,topwhat=10,zscored=False): ''' Computes clustering of bag-of-words vectors of articles INPUT folder model folder nclusters number of clusters ''' from sklearn.cluster import KMeans # filtering out some noise words stops = map(lambda x:x.lower().strip(),open('stopwords.txt').readlines()[6:]) # vectorize non-stopwords bow = TfidfVectorizer(min_df=2,stop_words=stops) X = bow.fit_transform(data) # creating bow-index-to-word map idx2word = dict(zip(bow.vocabulary_.values(),bow.vocabulary_.keys())) # using now stopwords and filtering out digits print 'Computing pairwise distances' K = pairwise_distances(X,metric='l2',n_jobs=1) perc = 50.0 width = percentile(K.flatten(),perc) # KPCA transform bow vectors Xc = KernelPCA(n_components=ncomponents,kernel='rbf',gamma=width).fit_transform(X) if zscored: Xc = zscore(Xc) # compute clusters km = KMeans(n_clusters=nclusters).fit(Xc) Xc = km.predict(Xc) clusters = [] for icluster in range(nclusters): nmembers = (Xc==icluster).sum() if True:#nmembers < len(data) / 5.0 and nmembers > 1: # only group clusters big enough but not too big members = (Xc==icluster).nonzero()[0] topwordidx = array(X[members,:].sum(axis=0))[0].argsort()[-topwhat:][::-1] topwords = ' '.join([idx2word[wi] for wi in topwordidx]) meanDist = triu(pairwise_distances(X[members,:],metric='l2',n_jobs=1)).sum() meanDist = meanDist / (len(members) + (len(members)**2 - len(members))/2.0) # print u'Cluster %d'%icluster + u' %d members'%nmembers + u' mean Distance %f'%meanDist + u'\n\t'+topwords clusters.append({ 'name':'Cluster-%d'%icluster, 'description': topwords, 'members': list(members), 'meanL2Distances': meanDist }) return clusters
def Calculate_NCG(X, Pi, alpha, beta1, beta2, d_old, g_norm_old): # Probability of observing an edge between clusters eps = 1e-10 N = X.shape[0] k = Pi.shape[1] psi = sc.special.psi Y = sc.ones((N, N)) - sc.identity(N) - X d_log_B1 = psi(beta1) - psi(beta1 + beta2) d_log_B2 = psi(beta2) - psi(beta1 + beta2) d_log_B1 = sc.diag( sc.diag(d_log_B1)) + sc.log(eps) * sc.triu(sc.ones( (k, k)), 1) + sc.log(eps) * sc.tril(sc.ones((k, k)), -1) d_log_B2 = sc.diag( sc.diag(d_log_B2)) + sc.log(1 - eps) * sc.triu(sc.ones( (k, k)), 1) + sc.log(1 - eps) * sc.tril(sc.ones((k, k)), -1) # L_prime_i,j = dL / dPi_i,j L_prime = X.dot(Pi.dot(d_log_B1.T)) + Y.dot(Pi.dot(d_log_B2.T)) \ + sc.outer(sc.ones(N), psi(alpha)) - sc.log(Pi) - sc.outer(sc.ones(N), sc.ones(k)) u = sc.concatenate([sc.identity(k - 1), -sc.ones((1, k - 1))], axis=0) # Natural gradient g = L_prime.dot(u) # Norm of natural gradient g_norm = 0 for i in range(N): l = L_prime[i, :] p = Pi[i, :] B = sc.diag(p) - sc.outer(p, p) g_norm += l.dot(B.dot(l)) # Natural Conjugate Gradient d = g + g_norm / g_norm_old * d_old return d, g_norm
def read_from_do_cor(self, path): vac = fitsio.FITS(path) head = vac[1].read_header() self._llmin = head['LLMIN'] self._llmax = head['LLMAX'] self._dll = head['DLL'] self._n1d = int((self._llmax - self._llmin) / self._dll + 1) ### All Matrix self._mat = {} self._mat["DA"] = vac[2]['DA'][:] self._mat["WE"] = vac[2]['WE'][:] self._mat["NB"] = vac[2]['NB'][:] ### Variance self._var = sp.zeros((self._n1d, 4)) self._var[:, 0] = 10.**(sp.arange(self._n1d) * self._dll + self._llmin) self._var[:, 1] = sp.diag(self._mat["DA"]) self._var[:, 2] = sp.diag(self._mat["WE"]) self._var[:, 3] = sp.diag(self._mat["NB"]) ### Correlation self._cor = sp.zeros((self._n1d, 4)) self._cor[:, 0] = 10.**(sp.arange(self._n1d) * self._dll) inDown = False upperTri = sp.triu(self._mat["NB"]) if (upperTri > 0.).sum() == 0: inDown = True self._cor[:, 0] = self._cor[:, 0][::-1] norm = 1. if sp.trace(self._mat["NB"]) > 0: norm = sp.sum( sp.diag(self._mat["DA"], k=0) * sp.diag(self._mat["WE"], k=0)) / sp.trace(self._mat["WE"], offset=0) for i in range(self._n1d): d = i if inDown: d = 1 + i - self._n1d tda = sp.diag(self._mat["DA"], k=d) twe = sp.diag(self._mat["WE"], k=d) tnb = sp.trace(self._mat["NB"], offset=d) if tnb > 0: self._cor[i, 1] = sp.sum(tda * twe) / sp.sum(twe) / norm self._cor[i, 2] = sp.sum(twe) / norm self._cor[i, 3] = tnb vac.close() return
def generateDIMask(theDIs, cons, sStruct, k=6,consthresh=0.95,ambigChar='X'): L,M = theDIs.shape assert L == M , "Non square DI matrix!?" DImask = S.ones(theDIs.shape) # #1 Sequence Separation # DImask = S.triu(DImask,k) # #2 Conservation Filter # #Scan the consensus sequence and find overly conserved columns, note those, and note conserved cysteine columns conservedSites = S.array([i != ambigChar for i in cons],dtype=S.int8) conservedCysteine = S.array([i == 'C' for i in cons],dtype=S.int8) DImask = (1-conservedSites).reshape(-1,1)*(DImask*(1-conservedSites)) # #3 Cysteine columns may be strongly conserved, but only allow their best contact. #TODO : implement Cysteine Best-Friend pairs # #4 Secondary Structure Masking #Seet Table S2 in th EVFold paper # abovez = lambda x:max(x,0) for start,end,type in sStruct: if type is "H": #alpha helix #Table S2 in EVFold paper. Not how I would have done it. DImask[abovez(start-1):end+1,abovez(start-1):end+1] = 0.0 #Constraints H,H; H-1,H; H-1,H+1 in Table S2 DImask[abovez(start-2):abovez(end-4),start+4:end+2] = 0.0 #Constraints H-2,H; (assumed) H,H+2 in Table S2 DImask[abovez(start-3):abovez(end-9),start+9:end+3] = 0.0 #Constraints H-3,H; (assumed) H,H+3 in Table S2 #TODO : Not mentioned in the paper, but what if helices are longer than this? We could just continue in a pattern! elif type is "E": #beta strand width = 1 if (end-start) < 5 else 2 DImask[abovez(start-width):end+width,abovez(start-width):end+width] = 0.0 #constraints E,E ; E-1, E+1; E-2,E+2 in Table S2 DImask[abovez(start-2):end,start:end] = 0.0#constraint E-2,E DImask[start:end,start:end+2] = 0.0#constraints (assumed) E,E+2 DImask[abovez(start-3):end,start:end] = 0.0#constraint E-3,E DImask[start:end,start:end+3] = 0.0#constraints (assumed) E,E+3 DImask[abovez(start-4):start,start+4:end] = 0.0#constraint E-4,E in table S2 DImask[start:abovez(end-4),end:end+4] = 0.0#constraint (assumed) E,E+4 in table S2i return DImask
def backward(self): ####################################### # Start Backward Computation # ####################################### basics.niceprint("Start Backward Computation") # define function for dividing columns of a matrix by their respective norm def colnorm(M): norms = np.linalg.norm(M, axis=0, keepdims=True) return M / norms, norms # initialize random initial upper triangular matrix tri, _ = colnorm(sp.triu(np.random.rand(self.dim, self.dim))) for revnstep, (tpast, tfuture) in enumerate( zip(reversed(self.time_mainrun[0:-1]), reversed(self.time_mainrun[1:]))): nstep = len(self.time_mainrun) - 1 - revnstep basics.printProgressBar(nstep, len(self.time_mainrun), prefix='Progress:', suffix='Complete', length=20) # solve R_{n,n+1}*X = C_{n+1} tri = sp.linalg.solve_triangular(self.R[nstep - 1, :, :], tri) # normlize upper triangular matrix tri, growth = colnorm(tri) # compute growth factor self.CLE[nstep - 1, :] = -np.log(growth) / (self.dt * self.rescale_rate) # change from triangular representation to normal coordinates self.CLV[nstep - 1, :, :] = np.matmul(self.BLV[nstep - 1, :, :], tri) np.memmap.flush(self.CLV) np.memmap.flush(self.CLE) basics.printProgressBar(nstep, len(self.time_mainrun), prefix='Progress:', suffix='Complete', length=20)
def optimal_gauss_kernel_size(train, optimize_steps, progress=ProgressIndicator()): """ Return the optimal kernel size for a spike density estimation of a SpikeTrain for a gaussian kernel. This function takes a single spike train, which can be a superposition of multiple spike trains (created with :func:`collapsed_spike_trains`) that should be included in a spike density estimation. See (Shimazaki, Shinomoto. Journal of Computational Neuroscience. 2010). :param SpikeTrain train: The spike train for which the kernel size should be optimized. :param optimize_steps: Array of kernel sizes to try (the best of these sizes will be returned). :type optimize_steps: Quantity 1D :param progress: Set this parameter to report progress. Will be advanced by len(`optimize_steps`) steps. :type progress: :class:`spykeutils.progress_indicator.ProgressIndicator` :returns: Best of the given kernel sizes :rtype: Quantity scalar """ x = sp.asarray(train.rescale(optimize_steps.units)) steps = sp.asarray(optimize_steps) N = len(train) tau = sp.triu(sp.vstack([x] * N) - sp.vstack([x] * N).T, 1) idx = sp.triu(sp.ones((N,N)), 1) TAU = tau.T[idx.T==1]**2 C = {} for s in steps: C[s] = N/s + 1/s * sum(2 * sp.exp(-TAU/(4 * s**2)) - 4 * sp.sqrt(2) * sp.exp(-TAU/(2 * s**2))) progress.step() # Return kernel size with smallest cost return min(C, key=C.get)*train.units
def add_intron(self, idx1, flag1, idx2, flag2): """adds new introns into splicegraph between idx1 and idx2""" ### if flag1, all end terminal exons in idx1 are preserved ### if flag2, all start terminal exons in idx2 are preserved if idx2.shape[0] > 0: adj_mat = sp.triu(self.edges) if flag1: for i1 in idx1: ### if exon is end-terminal if sp.all(adj_mat[i1, :] == 0): self.vertices = sp.c_[self.vertices, self.vertices[:, i1]] self.new_edge() self.edges[:, -1] = self.edges[:, i1] self.edges[-1, :] = self.edges[i1, :] self.terminals = sp.c_[self.terminals, self.terminals[:, i1]] if flag2: for i2 in idx2: ### if exon is start-terminal if sp.all(adj_mat[:, i2] == 0): self.vertices = sp.c_[self.vertices, self.vertices[:, i2]] self.new_edge() self.edges[:, -1] = self.edges[:, i2] self.edges[-1, :] = self.edges[i2, :] self.terminals = sp.c_[self.terminals, self.terminals[:, i2]] for i1 in idx1: for i2 in idx2: self.edges[i1, i2] = 1 self.edges[i2, i1] = 1 self.uniquify()
def aic(self, X): """Akaike information criterion for the current model fit and the proposed data Parameters ---------- X : array of shape(n_samples, n_dimensions) Returns ------- aic: float (the greater the better) """ n_vars = self.means_.shape[1] score = self.score(X).sum() df = 0 for k in range(self.n_components): df += (np.abs(scipy.triu(self.precs_[k])) > self.tol).sum() df += n_vars return score - df
def Read_SymMatrix(self, name): self.file.seek(0, 0) # Initialize the C matrix C = numpy.zeros((6,6), self.dtype) # By default, the elastic type is general elastic_type = 'general' myline = self.file.readline() while ( myline != "" and myline != '$' + name +'\n' ): myline = self.file.readline() try: for i in range(6): myline = self.file.readline() myline.strip() elements = myline.split() for j in range(i, 6): C[i, j] = float(elements[j]) C = C + triu(C,1).T.astype(self.dtype) # Check if the elastic type is orthotropic temp = True for (i, j) in [(0,3),(0,4),(0,5),(1,3),(1,4),(1,5),(2,3),(2,4),(2,5),(3,4),(3,5),(4,5)]: temp = temp and C[i, j] == 0 if(temp): elastic_type = 'orthotropic' # Check if the elastic type is isotropic if((C[0, 1] == C[0, 2]) and (C[0, 2] == C[1, 2]) \ and (C[3, 3] == C[4, 4]) and (C[4, 4] == C[5, 5]) \ and (C[0, 0] == C[0, 1] + C[3, 3])): elastic_type = 'isotropic' except: if self.print_output: print self.filename, 'contains no valid', name, 'section.' return None if (self.file.readline() != '$End' + name + '\n') and self.print_output: print self.filename, 'has an invalid', name, 'section.' return C, elastic_type
def add_intron_retention(self, idx1, idx2): adj_mat = sp.triu(self.edges) self.vertices = sp.c_[self.vertices, sp.array([self.vertices[0, idx1], self.vertices[1, idx2]], dtype='int')] self.new_edge() adj_mat = sp.r_[adj_mat, sp.zeros((1, adj_mat.shape[1]), dtype='int')] adj_mat = sp.c_[adj_mat, sp.zeros((adj_mat.shape[0], 1), dtype='int')] ### check if adjacency matrix is symmetric ### otherwise or is not justyfied assert(sp.all(sp.all(adj_mat - (self.edges - adj_mat).T == 0))) ### AK: under the assumption that our splice graph representation is symmetric ### I preserve symmetry by using OR over the adj_mat column and row self.edges[:, -1] = adj_mat[:, idx1] | adj_mat[idx2, :].T self.edges[-1, :] = adj_mat[:, idx1].T | adj_mat[idx2, :] self.terminals = sp.c_[self.terminals, sp.array([self.terminals[0, idx1], self.terminals[1, idx2]], dtype='int')]
def factLU(A): n=len(A) for k in range(n-1): if s.absolute(A[k][k])<1e-20: print('Pivote cercano a cero en k=%d' % k) L=[[0.0]*n for i in range(n)] U=[[0.0]*n for i in range(n)] return L,U else: for i in range(k+1,n): A[i][k] = A[i][k]/A[k][k] for j in range(k+1,n): A[i][j] = A[i][j]-A[i][k]*A[k][j] #================================== #OBSERVE QUE: #Las siguientes lineas en realidad no hacen falta U=s.triu(A) L=s.tril(A,-1) for i in range(n): L[i][i] =1.0 return L,U
def parameters(cmdargs): """ cmdargs: -q, qubits -k, lrule -f, nmems """ # The Hopfield parameters hparams = { 'numNeurons': cmdargs['qubits'], 'inputState': [ 2*sp.random.random_integers(0,1)-1 for k in xrange(cmdargs['qubits']) ], 'learningRule': cmdargs['simtype'], 'numMemories': int(cmdargs['farg']) } # Construct memories memories = [ [ 2*sp.random.random_integers(0,1)-1 for k in xrange(hparams['numNeurons']) ] for j in xrange(hparams['numMemories']) ] # At least one pattern must be one Hamming unit away from the input memories[0] = list(hparams['inputState']) memories[0][sp.random.random_integers(0,hparams['numNeurons']-1)] *= -1 # Make sure all other patterns have Hamming distance > 1 def hamdist(a,b): """ Calculate Hamming distance. """ return sp.sum(abs(sp.array(a)-sp.array(b))/2.0) # Loop over additional memories, if there are any for imem, mem in enumerate(memories[1:]): while hamdist(mem, hparams['inputState']) < 2.0: # Flip a random spin rndbit = sp.random.random_integers(0,hparams['numNeurons']-1) memories[imem+1][rndbit] *= -1 # Basic simulation params nQubits = hparams['numNeurons'] T = 1000.0 # sp.arange(0.1, 15, 0.5) # T = sp.array([10.0, 20.0, 50.0, 100.0]) dt = 0.01*T # Define states for which to track probabilities in time # import statelabels # label_list = statelabels.GenerateLabels(nQubits) # stateoverlap = [] # for mem in memories: # # Convert spins to bits # bitstr = ''.join([ '0' if k == 1 else '1' for k in mem ]) # # Get the index of the current (converted) memory and add it to list # stateoverlap.append([ label_list.index(bitstr), bitstr ]) stateoverlap = None # Output parameters binary = 1 # Save output files as binary Numpy format progressout = 0 # Output simulation progress over anneal timesteps eigspecdat = 1 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 2**nQubits # Number of eigenvalues to output fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' # Output directory stuff probdir = 'data/hopfield_exp1_tuned/n'+str(nQubits)+'p'+\ str(hparams['numMemories'])+hparams['learningRule'] if isinstance(T, collections.Iterable): probdir += 'MultiT' if os.path.isdir(probdir): outlist = sorted([ int(name) for name in os.listdir(probdir) if name.isdigit() ]) else: outlist = [] outnum = outlist[-1] + 1 if outlist else 0 outputdir = probdir + '/' + str(outnum) + '/' probshow = 0 # Print final state probabilities to screen probout = 1 # Output probabilities to file mingap = 0 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 0 isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1} # Construct network Ising parameters neurons = nQubits # This is gamma, the appropriate weighting on the input vector # isingSigns['hz'] *= 1 - (len(hparams['inputState']) - # hparams['inputState'].count(0))/(2*neurons) # isingSigns['hz'] *= 1.0/(5*neurons) isingSigns['hz'] *= 0.2 alpha = sp.array(hparams['inputState']) beta = sp.zeros((neurons,neurons)) delta = sp.array([]) # Construct the memory matrix according to a learning rule if hparams['learningRule'] == 'hebb': # Hebb rule isingSigns['hz'] *= 0.7 memMat = sp.matrix(memories).T beta = sp.triu(memMat*memMat.T)/float(neurons) elif hparams['learningRule'] == 'stork': # Storkey rule isingSigns['hz'] *= 0.15 Wm = sp.zeros((neurons,neurons)) for m, mem in enumerate(memories): Am = sp.outer(mem,mem) - sp.eye(neurons) Wm += (Am - Am*Wm - Wm*Am)/float(neurons) beta = sp.triu(Wm) elif hparams['learningRule'] == 'proj': isingSigns['hz'] *= 0.15 # Moore-Penrose pseudoinverse rule memMat = sp.matrix(memories).T beta = sp.triu(memMat * sp.linalg.pinv(memMat)) # Some outputs outputs = { 'nQubits': nQubits, 'learningRule': hparams['learningRule'], 'outdir': probdir, 'inputState': hparams['inputState'], 'memories': memories, 'answer': memories[0], 'annealTime': list(T) if isinstance(T, collections.Iterable) else T } ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': None, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': stateoverlap, 'hzscale': None, 'hzzscale': None, 'hxscale': None, 'solveMethod': solveMethod }
def detect_multipleskips(genes, idx_alt): # [idx_multiple_skips, exon_multiple_skips, id_multiple_skips] = detect_multipleskips(genes, idx_alt) ; id = 0 idx_multiple_skips = [] id_multiple_skips = [] exon_multiple_skips = [] for ix in idx_alt: if ix % 50 == 0: print '.', num_exons = genes[ix].splicegraph.get_len() edges = genes[ix].splicegraph.edges labels = repmat(sp.arange(num_exons), num_exons, 1).T # adjecency matrix: upper half only A = sp.zeros((num_exons, num_exons)) for i in range(num_exons - 1): for j in range(i + 1, num_exons): A[i, j] = edges[i, j] # possible starting and ending exons of a multiple exon skip Pairs = lil_matrix((num_exons, num_exons)) Ai = sp.dot(sp.dot(A, A), A) #paths of length 3 while sp.any(Ai.ravel() > 0): coords = sp.where((A > 0 ) & (Ai > 0)) # multiple skip Pairs[coords[0], coords[1]] = 1 Ai = sp.dot(Ai, A) # paths of length ..+1 edge = sp.where(Pairs.toarray() == 1) if edge[0].shape[0] > 10000: print 'Warning: not processing gene %d, because there are more than 10000 potential hits.' % ix continue for cnt in range(edge[0].shape[0]): exon_idx_first = edge[0][cnt] exon_idx_last = edge[1][cnt] if edges[exon_idx_first, exon_idx_last] == 1: # find all pairs shortest path exist_path = sp.triu(edges).astype('double') exist_path[exon_idx_first, exon_idx_last] = 0 exist_path[exist_path == 0] = sp.inf # set diagonal to 0 exist_path[sp.arange(exist_path.shape[0]), sp.arange(exist_path.shape[0])] = 0 long_exist_path = -sp.triu(edges).astype('double') long_exist_path[exon_idx_first, exon_idx_last] = 0 long_exist_path[long_exist_path == 0] = sp.inf # set diagonal to 0 long_exist_path[sp.arange(long_exist_path.shape[0]), sp.arange(long_exist_path.shape[0])] = 0 path = sp.isfinite(exist_path) * labels long_path = sp.isfinite(long_exist_path) * labels for k in range(num_exons): for i in range(num_exons): idx = sp.where((exist_path[i, k] + exist_path[k, :]) < exist_path[i, :])[0] exist_path[i, idx] = exist_path[i, k] + exist_path[k, idx] path[i, idx] = path[k, idx] idx = sp.where((long_exist_path[i,k] + long_exist_path[k, :]) < long_exist_path[i, :])[0] long_exist_path[i, idx] = long_exist_path[i, k] + long_exist_path[k, idx] long_path[i, idx] = long_path[k, idx] temp_ix = sp.isfinite(long_exist_path) long_exist_path[temp_ix] = -long_exist_path[temp_ix] if (exist_path[exon_idx_first, exon_idx_last] > 2) and sp.isfinite(exist_path[exon_idx_first, exon_idx_last]): backtrace = sp.array([path[exon_idx_first, exon_idx_last]]) while backtrace[-1] > exon_idx_first: backtrace = sp.r_[backtrace, path[exon_idx_first, backtrace[-1]]] backtrace = backtrace[:-1] backtrace = backtrace[::-1] idx_multiple_skips.append(ix) #repmat(ix, 1, backtrace.shape[0] + 2)) exon_multiple_skips.append([exon_idx_first, backtrace, exon_idx_last]) id_multiple_skips.append(id) # * sp.ones((1, backtrace.shape[0] + 2))) id += 1 elif (long_exist_path[exon_idx_first, exon_idx_last] > 2) and sp.isfinite(long_exist_path[exon_idx_first, exon_idx_last]): backtrace = sp.array([long_path[exon_idx_first, exon_idx_last]]) while backtrace[-1] > exon_idx_first: backtrace = sp.r_[backtrace, long_path[exon_idx_first, backtrace[-1]]] backtrace = backtrace[:-1] backtrace = backtrace[::-1] idx_multiple_skips.append(ix) #repmat(ix, 1, backtrace.shape[0] + 2)) exon_multiple_skips.append([exon_idx_first, backtrace, exon_idx_last]) id_multiple_skips.append(id) # * sp.ones((1, backtrace.shape[0] + 2))) id += 1 print 'Number of multiple exon skips:\t\t\t\t\t%d' % len(idx_multiple_skips) return (idx_multiple_skips, exon_multiple_skips, id_multiple_skips)
def parameters(cmdargs): """ cmdargs: -q, qubits -k, lrule -f, nmems """ # The Hopfield parameters hparams = { 'numNeurons': cmdargs['qubits'], 'inputState': [ 2*sp.random.random_integers(0,1)-1 for k in xrange(cmdargs['qubits']) ], 'learningRule': cmdargs['simtype'], 'numMemories': int(cmdargs['farg']) } # Construct memories memories = [ [ 2*sp.random.random_integers(0,1)-1 for k in xrange(hparams['numNeurons']) ] for j in xrange(hparams['numMemories']) ] # At least one pattern must be one Hamming unit away from the input memories[0] = list(hparams['inputState']) memories[0][sp.random.random_integers(0,hparams['numNeurons']-1)] *= -1 # Make sure all other patterns have Hamming distance > 1 def hamdist(a,b): """ Calculate Hamming distance. """ return sp.sum(abs(sp.array(a)-sp.array(b))/2.0) # Loop over additional memories, if there are any for imem, mem in enumerate(memories[1:]): # Avoid duplication and ensure we're far away enough from the input while (memories.count(mem) > 1 or hamdist(mem, hparams['inputState']) < 2.0): # Flip a random spin rndbit = sp.random.random_integers(0,hparams['numNeurons']-1) memories[imem+1][rndbit] *= -1 # Basic simulation params nQubits = hparams['numNeurons'] T = 1000.0 # sp.arange(0.1, 15, 0.5) # T = sp.array([10.0, 20.0, 50.0, 100.0]) dt = 0.01*T # Define states for which to track probabilities in time # import statelabels # label_list = statelabels.GenerateLabels(nQubits) # stateoverlap = [] # for mem in memories: # # Convert spins to bits # bitstr = ''.join([ '0' if k == 1 else '1' for k in mem ]) # # Get the index of the current (converted) memory and add it to list # stateoverlap.append([ label_list.index(bitstr), bitstr ]) stateoverlap = None # Output parameters binary = 1 # Save output files as binary Numpy format progressout = 0 # Output simulation progress over anneal timesteps eigspecdat = 1 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 8 # Number of eigenvalues to output fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' # Output directory stuff probdir = 'data/hopfield_opt_gamma/n'+str(nQubits)+'p'+\ str(hparams['numMemories'])+hparams['learningRule'] if isinstance(T, collections.Iterable): probdir += 'MultiT' if os.path.isdir(probdir): outlist = sorted([ int(name) for name in os.listdir(probdir) if name.isdigit() ]) else: outlist = [] outnum = outlist[-1] + 1 if outlist else 0 outputdir = probdir + '/' + str(outnum) + '/' probshow = 0 # Print final state probabilities to screen probout = 1 # Output probabilities to file mingap = 0 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 0 isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1} # Construct network Ising parameters neurons = nQubits alpha = sp.array(hparams['inputState']) beta = sp.zeros((neurons,neurons)) delta = sp.array([]) def kbits(n, k): " kbits(n: length of bitstring, k: number of ones) " result = [] for bits in itertools.combinations(range(n), k): s = ['0'] * n for bit in bits: s[bit] = '1' result.append(''.join(s)) return result def bitstr2spins(vec): """ Return converted list of spins from bitstring @vec. """ return [ 1 if k == '1' else -1 for k in vec ] def calculate_gamma(Jmat, inp, mems): """ Return a threshold+eps for Gamma by analyzing energies of the given memory matrix. """ step = 0.001 eps = 0.1*step Glist = np.arange(0,1.+step, step) Gthresh = [] Minp = np.matrix(inp).T mem0 = np.matrix(mems[0]).T # The input state's energy Einp = -Glist*np.sum(Minp.T*Minp) + -np.sum(Minp.T*Jmat*Minp) # Loop backwards through Gamma (go high to low) for i in range(len(Glist))[::-1]: # Calculate new bias matrix bias = np.sum(np.array(inp)*np.array(mems[0])) # Compute the memory state energies lower = -np.sum(mem0.T*Jmat*mem0) - bias # Generate bitstrings bitstring = [] for i in range(0,neurons+1): bitstring.append(kbits(neurons, i)) # Flatten, convert to spins spinstr = [ bitstr2spins(item) for item in list(itertools.chain.from_iterable(bitstring)) ] alllist = [ [-np.sum(np.matrix(v)*Jmat*np.matrix(v).T)-bias, v] for v in spinstr ] # Sort by energy alllist = sorted(alllist, key=lambda x: x[0]) indices = [] upper = 0 # Find the next energy level for irec, rec in enumerate(alllist): if len(indices) == 2*len(mems): upper = rec[0] break if rec[1] in mems: indices.append(irec) # If this Gamma value gives the right input state energy, # keep it for later analysis if lower < Einp[i] and Einp[i] <= upper: Gthresh.append(Glist[i]) Gthresh = list(set(Gthresh)) # Now pick a Gamma in the middle somewhere if len(Gthresh) == 0: return 0 elif len(Gthresh) == 1: return Gthresh[0] else: return Gthresh[(len(Gthresh)-1)/2] # Construct the memory matrix according to a learning rule if hparams['learningRule'] == 'hebb': # Hebb rule memMat = sp.matrix(memories).T beta = sp.triu(memMat*memMat.T)/float(neurons) isingSigns['hz'] *= calculate_gamma(beta, hparams['inputState'], memories) elif hparams['learningRule'] == 'stork': # Storkey rule Wm = sp.zeros((neurons,neurons)) for m, mem in enumerate(memories): Am = sp.outer(mem,mem) - sp.eye(neurons) Wm += (Am - Am*Wm - Wm*Am)/float(neurons) beta = sp.triu(Wm) isingSigns['hz'] *= calculate_gamma(beta, hparams['inputState'], memories) elif hparams['learningRule'] == 'proj': # Moore-Penrose pseudoinverse rule memMat = sp.matrix(memories).T beta = sp.triu(memMat * sp.linalg.pinv(memMat)) isingSigns['hz'] *= calculate_gamma(beta, hparams['inputState'], memories) # Some outputs outputs = { 'nQubits': nQubits, 'learningRule': hparams['learningRule'], 'outdir': probdir, 'inputState': hparams['inputState'], 'memories': memories, 'bias': -isingSigns['hz'], 'answer': memories[0], 'annealTime': list(T) if isinstance(T, collections.Iterable) else T } ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': None, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': stateoverlap, 'hzscale': None, 'hzzscale': None, 'hxscale': None, 'solveMethod': solveMethod }
def parameters(cmdargs): """ """ # Basic simulation params nQubits = int(cmdargs['simtype']) T = 10.0 # sp.arange(0.1, 15, 0.5) dt = 0.01*T # Output parameters binary = 1 # Save as binary Numpy progressout = 0 # Output simulation progress over anneal timesteps eigspecdat = 1 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 2**nQubits # Number of eigenvalues fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' # Output directory stuff probdir = 'data/random_n'+str(nQubits) if isinstance(T, collections.Iterable): probdir += 'MultiT' if os.path.isdir(probdir): outlist = sorted([ int(name) for name in os.listdir(probdir) if name.isdigit() ]) else: outlist = [] outnum = outlist[-1] + 1 if outlist else 0 outputdir = probdir + '/' + str(outnum) + '/' probshow = 0 # Print final state probabilities to screen probout = 1 # Output probabilities to file mingap = 0 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 0 isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1} # Generate random matrix of coefficents between [-1,1] beta = sp.triu(2*sp.random.ranf((nQubits,nQubits)) - 1) alpha = 2*sp.random.ranf(nQubits) - 1 delta = sp.array([]) # Some outputs outputs = None ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': None, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': None, 'hzscale': None, 'hzzscale': None, 'hxscale': None, 'solveMethod': solveMethod }
def parameters(cmdargs): """ """ # The Hopfield parameters hparams = { 'numNeurons': cmdargs['qubits'], 'inputState': [ 2 * sp.random.random_integers(0, 1) - 1 for k in xrange(cmdargs['qubits']) ], 'learningRule': cmdargs['simtype'], 'bias': float(cmdargs['farg']), 'numMemories': sp.random.random_integers(1, cmdargs['qubits']) } # Construct memories memories = [[ 2 * sp.random.random_integers(0, 1) - 1 for k in xrange(hparams['numNeurons']) ] for j in xrange(hparams['numMemories'])] # At least one pattern must be one Hamming unit away from the input memories[0] = list(hparams['inputState']) memories[0][sp.random.random_integers(0, hparams['numNeurons'] - 1)] *= -1 # Make sure all other patterns have Hamming distance > 1 def hamdist(a, b): """ Calculate Hamming distance. """ return sp.sum(abs(sp.array(a) - sp.array(b)) / 2.0) # Loop over additional memories, if there are any for imem, mem in enumerate(memories[1:]): while hamdist(mem, hparams['inputState']) < 2.0: # Flip a random spin rndbit = sp.random.random_integers(0, hparams['numNeurons'] - 1) memories[imem + 1][rndbit] *= -1 # Basic simulation params nQubits = hparams['numNeurons'] T = 100.0 dt = 0.01 * T # Output parameters binary = 1 # Save output files as binary Numpy format progressout = 0 # Output simulation progress over anneal timesteps eigspecdat = 1 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 2**(nQubits - 1) # Number of eigenvalues to output fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' # Output directory stuff probdir = 'data/hopfield_gamma_random/' + hparams['learningRule'] if isinstance(T, collections.Iterable): probdir += 'MultiT' if os.path.isdir(probdir): outlist = sorted( [int(name) for name in os.listdir(probdir) if name.isdigit()]) else: outlist = [] outnum = outlist[-1] + 1 if outlist else 0 outputdir = probdir + '/' + str(outnum) + '/' probshow = 0 # Print final state probabilities to screen probout = 1 # Output probabilities to file mingap = 1 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 0 isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1} # Construct network Ising parameters neurons = nQubits # This is gamma, the appropriate weighting on the input vector # isingSigns['hz'] *= 1 - (len(hparams['inputState']) - # hparams['inputState'].count(0))/(2*neurons) isingSigns['hz'] *= hparams['bias'] alpha = sp.array(hparams['inputState']) beta = sp.zeros((neurons, neurons)) delta = sp.array([]) # Construct the memory matrix according to a learning rule if hparams['learningRule'] == 'hebb': # Construct pattern matrix according to Hebb's rule for i in range(neurons): for j in range(neurons): for p in range(len(memories)): beta[i, j] += (memories[p][i] * memories[p][j] - len(memories) * (i == j)) beta = sp.triu(beta) / float(neurons) elif hparams['learningRule'] == 'stork': # Construct the memory matrix according to the Storkey learning rule memMat = sp.zeros((neurons, neurons)) for m, mem in enumerate(memories): for i in range(neurons): for j in range(neurons): hij = sp.sum( [memMat[i, k] * mem[k] for k in range(neurons)]) hji = sp.sum( [memMat[j, k] * mem[k] for k in range(neurons)]) # Don't forget to make the normalization a float! memMat[i, j] += 1. / neurons * (mem[i] * mem[j] - mem[i] * hji - hij * mem[j]) beta = sp.triu(memMat) elif hparams['learningRule'] == 'proj': # Construct memory matrix according to the Moore-Penrose pseudoinverse rule memMat = sp.matrix(memories).T beta = sp.triu(memMat * sp.linalg.pinv(memMat)) # Some outputs outputs = { 'nQubits': nQubits, 'learningRule': hparams['learningRule'], 'outdir': probdir, 'inputState': hparams['inputState'], 'memories': memories, 'answer': memories[0], 'bias': hparams['bias'], 'annealTime': list(T) if isinstance(T, collections.Iterable) else T } ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': None, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': None, 'solveMethod': solveMethod }
print('generating GTEx intron list') genes = pickle.load(open(GTEX, 'rb'), encoding='latin') gtex_introns = dict() gtex_exons = dict() for j, g in enumerate(genes[0]): if j > 0 and j % 100 == 0: sys.stdout.write('.') if j % 1000 == 0: sys.stdout.write('%i/%i\n' % (j, genes[0].shape[0])) sys.stdout.flush() sg_edges = spsp.coo_matrix( (g.splicegraph_edges_data, (g.splicegraph_edges_row, g.splicegraph_edges_col)), g.splicegraph_edges_shape).toarray() x, y = sp.where(sp.triu(sg_edges)) for i in range(x.shape[0]): intron = ':'.join([ g.chr, str(g.splicegraph.vertices[1, x[i]]), str(g.splicegraph.vertices[0, y[i]]) ]) try: gtex_introns[g.chr].append(intron) except KeyError: gtex_introns[g.chr] = [intron] for i in range(g.splicegraph.vertices.shape[1]): exon = ':'.join([ g.chr, str(g.splicegraph.vertices[0, i]), str(g.splicegraph.vertices[1, i])
sys.exit(1) if __name__ == "__main__": machEps = macheps() print "Python eps =", machEps #print "FORTRAN eps =", dlamch('E') #print "FORTRAN safe min =", dlamch('S') #print "FORTRAN base of the machine =", dlamch('B') #print "FORTRAN eps*base =", dlamch('P') #print "FORTRAN number of (base) digits in the mantissa =", dlamch('N') #print "FORTRAN rmax = ", dlamch('O') N = 3 M = 3 A0 = triu(rand(M, N) + 1.j * rand(M, N)) A1 = copy.deepcopy(A0) A2 = zeros((M, N), 'D', 2) A2[:] = A0 print A0 #for j in range(A1.shape[0]): #A2[j] = A0[j] LIB_G2C = 'g2c' # for gcc >= 4.3.0, LIB_G2C = 'gfortran' from scipy import linalg X1 = linalg.pinv(A1) # the pseudo inverse X2 = computeMyPinvCC(A2, LIB_G2C) X3 = computeTriangleUpSolve(A1, LIB_G2C) print print "X1 - X2 = " print X1 - X2 print "X1 - X3 = "
tlogsched = np.array( [tempstart / (np.log(k + 1) * trlog + 1) for k in xrange(tannealingsteps)]) # hack tannealingsched = texpsched annealingsched = expsched def getbitstr(vec): """ Return bitstring from spin vector array. """ return reduce(lambda x, y: x + y, [str(int(k)) for k in tools.spins2bits(vec)]) # Construct Ising matrix memMat = sp.matrix(memories).T isingJ = sp.triu(memMat * sp.linalg.pinv(memMat)) isingJ -= sp.diag(sp.diag(isingJ)) isingJ = sp.triu(memMat * sp.linalg.pinv(memMat)) isingJ += inpbias * sp.diag(vinput) isingJ = sps.dok_matrix(isingJ) # get energies of all states results = [] energies = np.zeros(2**nspins) for b in [bin(x)[2:].rjust(nspins, '0') for x in range(2**nspins)]: svec = tools.bits2spins(np.array([int(k) for k in b])) energies[int(b, 2)] = sa.ClassicalIsingEnergy(svec, isingJ) results.append([energies[int(b, 2)], b]) print("All possible states and their energies:") for res in sorted(results)[:10]: print("%s %2.4f" % tuple(res[::-1]))
def update_terminals(self): self.terminals = sp.zeros(self.vertices.shape, dtype='int') self.terminals[0, sp.where(sp.sum(sp.tril(self.edges), axis=1) == 0)[0]] = 1 self.terminals[1, sp.where(sp.sum(sp.triu(self.edges), axis=1) == 0)[0]] = 1
def parameters(cmdargs): """ """ # The Hopfield parameters hparams = { 'numNeurons': 4, 'inputState': [1,-1,1,-1], 'learningRule': cmdargs['simtype'], 'bias': float(cmdargs['farg']) } # Construct memories # memories = sp.linalg.hadamard(hparams['numNeurons']).tolist() # memories = memories[:1] memories = [[1,-1,1,-1], [-1,1,1,1], [-1,-1,1,1], [1,-1,1,1]] memories = [memories[0]] # Basic simulation params nQubits = hparams['numNeurons'] T = 1000.0 # dt = 0.01*T dt = 0.001*T # Output parameters binary = 1 # Save output files as binary Numpy format progressout = 0 # Output simulation progress over anneal timesteps eigspecdat = 1 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 2**(nQubits-1) # Number of eigenvalues to output fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' # Output directory stuff probdir = 'data/testcases_fixed/ortho/n'+str(nQubits)+'p'+\ str(len(memories))+hparams['learningRule'] if isinstance(T, collections.Iterable): probdir += 'MultiT' if os.path.isdir(probdir): outlist = sorted([ int(name) for name in os.listdir(probdir) if name.isdigit() ]) else: outlist = [] outnum = outlist[-1] + 1 if outlist else 0 outputdir = probdir + '/' + str(outnum) + '/' probshow = 0 # Print final state probabilities to screen probout = 1 # Output probabilities to file mingap = 1 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 0 isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1} # Construct network Ising parameters neurons = nQubits # This is gamma, the appropriate weighting on the input vector # isingSigns['hz'] *= 1 - (len(hparams['inputState']) - # hparams['inputState'].count(0))/(2*neurons) isingSigns['hz'] *= hparams['bias'] alpha = sp.array(hparams['inputState']) beta = sp.zeros((neurons,neurons)) delta = sp.array([]) # Construct the memory matrix according to a learning rule if hparams['learningRule'] == 'hebb': # Construct pattern matrix according to Hebb's rule memMat = sp.matrix(memories).T beta = sp.triu(memMat*memMat.T)/float(neurons) elif hparams['learningRule'] == 'stork': # Construct the memory matrix according to the Storkey learning rule Wm = sp.zeros((neurons,neurons)) for m, mem in enumerate(memories): Am = sp.mat((sp.outer(mem,mem) - sp.eye(neurons))) Wm += (Am - Am*Wm - Wm*Am)/float(neurons) beta = sp.triu(Wm) elif hparams['learningRule'] == 'proj': # Construct memory matrix according to the Moore-Penrose pseudoinverse rule memMat = sp.matrix(memories).T beta = sp.triu(memMat * sp.linalg.pinv(memMat)) # Some outputs outputs = { 'nQubits': nQubits, 'learningRule': hparams['learningRule'], 'outdir': probdir, 'inputState': hparams['inputState'], 'memories': memories, 'answer': memories[0], 'bias': hparams['bias'], 'annealTime': list(T) if isinstance(T, collections.Iterable) else T } ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': None, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': None, 'hzscale': None, 'hzzscale': None, 'hxscale': None, 'solveMethod': solveMethod }
def parameters(cmdargs): """ """ # The Hopfield parameters hparams = { 'numNeurons': cmdargs['qubits'], 'inputState': None, 'learningRule': cmdargs['simtype'], 'numMemories': 0 } # Set input state inpst = sp.eye(cmdargs['qubits'])[0, :] - 1 inpst[inpst == 0] = 1 hparams['inputState'] = inpst.tolist() # Construct memories imems = cmdargs['instance'] memories = sp.eye(cmdargs['qubits'])[0:imems, :] memories[memories == 0] -= 1 memories = memories.tolist() # Basic simulation params nQubits = hparams['numNeurons'] T = 15. # sp.arange(0.1, 15, 0.5) dt = 0.01 * T # Define states for which to track probabilities in time import statelabels label_list = statelabels.GenerateLabels(nQubits) stateoverlap = [] for mem in memories: # Convert spins to bits bitstr = ''.join(['0' if k == -1 else '1' for k in mem]) # Get the index of the current (converted) memory and add it to list stateoverlap.append([label_list.index(bitstr), bitstr]) # Output parameters binary = 1 # Save output files as binary Numpy format progressout = 1 # Output simulation progress over anneal timesteps eigspecdat = 1 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 2**nQubits # Number of eigenvalues to output fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' # Output directory stuff probdir = 'data/hopfield_ortho/m' + str(imems) + hparams['learningRule'] if isinstance(T, collections.Iterable): probdir += 'MultiT' if os.path.isdir(probdir): outlist = sorted( [int(name) for name in os.listdir(probdir) if name.isdigit()]) else: outlist = [] outnum = outlist[-1] + 1 if outlist else 0 outputdir = probdir + '/' + str(outnum) + '/' probshow = 0 # Print final state probabilities to screen probout = 1 # Output probabilities to file mingap = 1 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 0 isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1} # Construct network Ising parameters neurons = nQubits # This is gamma, the appropriate weighting on the input vector isingSigns['hz'] *= 1 - (len(hparams['inputState']) - hparams['inputState'].count(0)) / (2 * neurons) alpha = sp.array(hparams['inputState']) beta = sp.zeros((neurons, neurons)) delta = sp.array([]) # Construct the memory matrix according to a learning rule if hparams['learningRule'] == 'hebb': # Construct pattern matrix according to Hebb's rule for i in range(neurons): for j in range(neurons): for p in range(len(memories)): beta[i, j] += (memories[p][i] * memories[p][j] - len(memories) * (i == j)) beta = sp.triu(beta) / float(neurons) elif hparams['learningRule'] == 'stork': # Construct the memory matrix according to the Storkey learning rule memMat = sp.zeros((neurons, neurons)) for m, mem in enumerate(memories): for i in range(neurons): for j in range(neurons): hij = sp.sum( [memMat[i, k] * mem[k] for k in range(neurons)]) hji = sp.sum( [memMat[j, k] * mem[k] for k in range(neurons)]) # Don't forget to make the normalization a float! memMat[i, j] += 1. / neurons * (mem[i] * mem[j] - mem[i] * hji - hij * mem[j]) beta = sp.triu(memMat) elif hparams['learningRule'] == 'proj': # Construct memory matrix according to the Moore-Penrose pseudoinverse rule memMat = sp.matrix(memories).T beta = sp.triu(memMat * sp.linalg.pinv(memMat)) # Usually we specify outputs that may be of interest in the form of a dict, # but we don't need any for this problem outputs = None ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': None, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': stateoverlap, 'hzscale': None, 'hzzscale': None, 'hxscale': None, 'solveMethod': solveMethod }
def parameters(cmdargs): """ """ nQubits = 8 T = 10.0 #T = sp.arange(2,23,4.0) # Output a sequence of anneal times dt = 0.01*T # Output parameters binary = 0 # Save output files as binary Numpy format progressout = 0 # Output simulation progress over anneal timesteps outputdir = 'data/hopfield_hamming_inv/' # In relation to run.py eigspecdat = 1 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 16 # Number of eigenvalues to output fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' # solveMethod = 'SuzTrot' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' probshow = 1 # Print final state probabilities to screen probout = 1 # Output probabilities to file mingap = 0 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 0 isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1} def spins2bitstr(vec): """ Return a converted bitstring from @vec, a list of spins. """ return ''.join([ '0' if k == 1 else '1' for k in vec ]) # Construct network Ising parameters neurons = nQubits # if nQubits % 2 == 0: # memories = sp.linalg.hadamard(neurons).tolist() # inputstate = memories[0] # memories = [[ 1,-1,-1, 1, 1,-1,-1, 1], # [-1,-1,-1, 1, 1,-1,-1, 1], # [ 1,-1,-1, 1, 1,-1,-1,-1]] memories = [[ 1,-1,-1, 1,-1,-1,-1, 1], [ 1,-1,-1, 1,-1,-1,-1, 1], [ 1,-1,-1, 1,-1,-1,-1,-1]] inputstate = memories[0] print("Input:") print(spins2bitstr(inputstate)) print('') print("Memories:") for mem in memories: print(spins2bitstr(mem)) print('') # This is gamma, the appropriate weighting on the input vector # isingSigns['hz'] *= 1 - (len(inputstate) - inputstate.count(0))/(2*neurons) # isingSigns['hz'] *= 0.6772598397 isingSigns['hz'] *= 1.0 print("Gamma: ", isingSigns['hz']) print('') alpha = sp.array(inputstate) beta = sp.zeros((neurons,neurons)) delta = sp.array([]) # Hebb rule - even better matrix style memMat = sp.matrix(memories).T beta = (sp.triu(memMat*memMat.T)-len(memories)*sp.eye(nQubits))/float(neurons) print beta # # Hebb rule - matrix style # for m, mem in enumerate(memories): # beta += (sp.outer(mem, mem))-sp.eye(neurons) # beta = sp.triu(beta)/float(neurons) # beta = sp.zeros((neurons,neurons)) # # Construct pattern matrix according to the Hebb learning rule # for i in range(neurons): # for j in range(neurons): # for p in range(len(memories)): # beta[i,j] += ( memories[p][i]*memories[p][j] - # len(memories)*(i == j) ) # beta = sp.triu(beta)/float(neurons) # Storkey rule (incorrect, but may be useful later) # memMat = sp.zeros((neurons,neurons)) # for m, mem in enumerate(memories): # for i in range(neurons): # for j in range(neurons): # hij = sp.sum([ memMat[i,k]*mem[k] for k in range(neurons) ]) # hji = sp.sum([ memMat[j,k]*mem[k] for k in range(neurons) ]) # # Don't forget to make the normalization a float! # memMat[i,j] += (mem[i]*mem[j] - mem[i]*hji - hij*mem[j])/float(neurons) # beta = sp.triu(memMat) # # Storkey rule # Wm = sp.zeros((neurons,neurons)) # for m, mem in enumerate(memories): # Am = sp.mat((sp.outer(mem,mem) - sp.eye(neurons))) # Wm += (Am - Am*Wm - Wm*Am)/float(neurons) # beta = sp.triu(Wm) # # Construct memory matrix according to the Moore-Penrose pseudoinverse rule # memMat = sp.matrix(memories).T # beta = sp.triu(memMat * sp.linalg.pinv(memMat)) # Usually we specify outputs that may be of interest in the form of a dict, # but we don't need any for this problem outputs = None ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': None, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': None, 'hzscale': None, 'hzzscale': None, 'hxscale': None, 'solveMethod': solveMethod }
def parameters(cmdargs): """ """ # The Hopfield parameters properties = json.load( open('data/hopfield_gamma_tune/gamma_problem_inputs.json')) hparams = { 'numNeurons': properties['nQubits'], 'inputState': properties['inputState'], 'learningRule': properties['learningRule'], 'numMemories': len(properties['memories']) } # Construct memories memories = properties['memories'] # Basic simulation params nQubits = hparams['numNeurons'] T = properties['annealTime'] dt = 0.01 * T # Output parameters binary = 1 # Save output files as binary Numpy format progressout = 0 # Output simulation progress over anneal timesteps eigspecdat = 0 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 2**nQubits # Number of eigenvalues to output fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap # Output directory stuff # probdir = 'data/hopfield_gamma_tune/n'+str(nQubits)+'p'+\ # str(hparams['numMemories'])+hparams['learningRule'] # if isinstance(T, collections.Iterable): # probdir += 'MultiT' # if os.path.isdir(probdir): # outlist = sorted([ int(name) for name in os.listdir(probdir) # if name.isdigit() ]) # else: # outlist = [] # outnum = outlist[-1] + 1 if outlist else 0 # outputdir = probdir + '/' + str(outnum) + '/' outputdir = 'data/hopfield_gamma_tune' probshow = 0 # Print final state probabilities to screen probout = 1 # Output probabilities to file mingap = 0 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 0 isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1} # Construct network Ising parameters neurons = nQubits # This is gamma, the appropriate weighting on the input vector isingSigns['hz'] *= float(cmdargs['farg']) alpha = sp.array(hparams['inputState']) beta = sp.zeros((neurons, neurons)) delta = sp.array([]) # Construct the memory matrix according to a learning rule if hparams['learningRule'] == 'hebb': # Construct pattern matrix according to Hebb's rule for i in range(neurons): for j in range(neurons): for p in range(len(memories)): beta[i, j] += (memories[p][i] * memories[p][j] - len(memories) * (i == j)) beta = sp.triu(beta) / float(neurons) elif hparams['learningRule'] == 'stork': # Construct the memory matrix according to the Storkey learning rule memMat = sp.zeros((neurons, neurons)) for m, mem in enumerate(memories): for i in range(neurons): for j in range(neurons): hij = sp.sum( [memMat[i, k] * mem[k] for k in range(neurons)]) hji = sp.sum( [memMat[j, k] * mem[k] for k in range(neurons)]) # Don't forget to make the normalization a float! memMat[i, j] += 1. / neurons * (mem[i] * mem[j] - mem[i] * hji - hij * mem[j]) beta = sp.triu(memMat) elif hparams['learningRule'] == 'proj': # Construct memory matrix according to the Moore-Penrose pseudoinverse rule memMat = sp.matrix(memories).T beta = sp.triu(memMat * sp.linalg.pinv(memMat)) # Some outputs outputs = { 'nQubits': nQubits, 'learningRule': hparams['learningRule'], 'inputState': hparams['inputState'], 'memories': memories, 'answer': memories[0], 'annealTime': list(T) if isinstance(T, collections.Iterable) else T } ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': None, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': None, 'hzscale': None, 'hzzscale': None, 'hxscale': None }
def parameters(cmdargs): """ """ nQubits = 6 T = 30.0 #T = sp.arange(2,103,10) # Output a sequence of anneal times dt = 0.1 # Output parameters binary = 1 # Save output files as binary Numpy format progressout = 0 # Output simulation progress over anneal timesteps outputdir = 'data/sixvarqubo_overlap/' # In relation to run.py eigspecdat = 0 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 2**nQubits # Number of eigenvalues to output fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' probshow = 1 # Print final state probabilities to screen #### BUG ##### probshow requires probout probout = 1 # Output probabilities to file mingap = 0 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 1 isingSigns = {'hx': 1, 'hz': 1, 'hzz': -1} # Define states for which to track probabilities in time import statelabels label_list = statelabels.GenerateLabels(nQubits) stateoverlap = [] for bitstr in ['100101', '110101']: # Get the index of the current (converted) memory and add it to list stateoverlap.append([ label_list.index(bitstr), bitstr ]) # Define the QUBO and its diagonal Q = sp.zeros((nQubits,nQubits)) a = sp.zeros(nQubits) a[0] = 2 a[1] = 1 a[2] = -2 a[3] = -1 a[4] = 1 a[5] = -1 Q[0,1] = Q[1,0] = -1 Q[0,2] = Q[2,0] = 2 Q[0,3] = Q[3,0] = -2 Q[0,4] = Q[4,0] = 2 Q[0,5] = Q[5,0] = -1 Q[1,2] = Q[2,1] = 1 Q[1,3] = Q[3,1] = -1 Q[1,4] = Q[4,1] = -1 Q[1,5] = Q[5,1] = 1 Q[2,3] = Q[3,2] = 2 Q[2,4] = Q[4,2] = -2 Q[2,5] = Q[5,2] = 1 Q[3,4] = Q[4,3] = 2 Q[3,5] = Q[5,3] = -1 Q[4,5] = Q[5,4] = 2 Q = sp.triu(Q) + a*sp.identity(6) # Usually we specify outputs that may be of interest in the form of a dict, # but we don't need any for this problem outputs = None # We could specify these below, but we want to avoid modifying that part alpha = beta = delta = None ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': Q, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': stateoverlap, 'solveMethod': solveMethod }
def CATS2D(mol, PathLength=10, scale=3): """ ################################################################# The main program for calculating the CATS descriptors. CATS: chemically advanced template serach ----> CATS_DA0 .... Usage: result=CATS2D(mol,PathLength = 10,scale = 1) Input: mol is a molecule object. PathLength is the max topological distance between two atoms. scale is the normalization method (descriptor scaling method) scale = 1 indicates that no normalization. That is to say: the values of the vector represent raw counts ("counts"). scale = 2 indicates that division by the number of non-hydrogen atoms (heavy atoms) in the molecule. scale = 3 indicates that division of each of 15 possible PPP pairs by the added occurrences of the two respective PPPs. Output: result is a dict format with the definitions of each descritor. ################################################################# """ Hmol = Chem.RemoveHs(mol) AtomNum = Hmol.GetNumAtoms() atomtype = AssignAtomType(Hmol) DistanceMatrix = Chem.GetDistanceMatrix(Hmol) DM = scipy.triu(DistanceMatrix) tempdict = {} for PL in range(0, PathLength): if PL == 0: Index = [[k, k] for k in range(AtomNum)] else: Index1 = scipy.argwhere(DM == PL) Index = [[k[0], k[1]] for k in Index1] temp = [] for j in Index: temp.extend(MatchAtomType(j, atomtype)) tempdict.update({PL: temp}) CATSLabel = FormCATSLabel(PathLength) CATS1 = FormCATSDict(tempdict, CATSLabel) ####set normalization 3 AtomPair = [ "DD", "DA", "DP", "DN", "DL", "AA", "AP", "AN", "AL", "PP", "PN", "PL", "NN", "NL", "LL", ] temp = [] for i, j in tempdict.items(): temp.extend(j) AtomPairNum = {} for i in AtomPair: AtomPairNum.update({i: temp.count(i)}) ############################################ CATS = {} if scale == 1: CATS = CATS1 if scale == 2: for i in CATS1: CATS.update({i: round(CATS1[i] / (AtomNum + 0.0), 3)}) if scale == 3: for i in CATS1: if AtomPairNum[i[5:7]] == 0: CATS.update({i: round(CATS1[i], 3)}) else: CATS.update( {i: round(CATS1[i] / (AtomPairNum[i[5:7]] + 0.0), 3)}) return CATS
def parameters(cmdargs): """ """ # import problems.hopfield.params as params # learningRule = params.learningRules[params.rule] learningRule = cmdargs['simtype'] # nQubits = params.numQubits nQubits = 5 # T = params.annealTime T = sp.arange(0.1, 15, 0.5) T = 10.0 dt = 0.01*T inputstate = [1,1,-1,-1,1] # Output parameters output = 1 # Turn on/off all output except final probabilities binary = 1 # Save as binary Numpy progressout = 0 # Output simulation progress over anneal timesteps eigspecdat = 1 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 2**nQubits # Number of eigenvalues fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap # Output directory stuff pnum = 0 if 32 > cmdargs['instance']: pnum = 1 elif (496-1) < cmdargs['instance']: pnum = 3 else: pnum = 2 probdir = 'data/hopfield_all_n'+str(nQubits)+'p'+str(pnum)+learningRule # probdir = 'problems/all_n'+str(nQubits)+'p'+str(pnum)+learningRule if isinstance(T, collections.Iterable): probdir += 'MultiT' if os.path.isdir(probdir): outlist = sorted([ int(name) for name in os.listdir(probdir) if name.isdigit() ]) else: outlist = [] outnum = outlist[-1] + 1 if outlist else 0 outputdir = probdir + '/' + str(outnum) + '/' probshow = 0 # Print final state probabilities to screen probout = 1 # Output probabilities to file mingap = 1 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 0 isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1} neurons = nQubits memories = [] # Load the list of memories patternSet = pickle.load(open('problems/n5p'+str(pnum)+'mems.dat', 'rb')) # Define the right index for each pnum case psetIdx = cmdargs['instance'] if 31 < cmdargs['instance'] < 496: psetIdx -= 32 elif cmdargs['instance'] >= 496: psetIdx -= 496 # Iterate through the set that corresponds to the [corrected] instance number for bitstring in patternSet[psetIdx]: # Convert binary to Ising spins spins = [ 1 if k == '1' else -1 for k in bitstring ] memories.append(spins) # Make the input the last memory recorded # inputstate = params.inputState # Add in the input state # if params.includeInput and inputstate not in memories: # memories[0] = inputstate if inputstate not in memories: memories[0] = inputstate # This is gamma, the appropriate weighting on the input vector isingSigns['hz'] *= 1 - (len(inputstate) - inputstate.count(0))/(2*neurons) # Initialize Hamiltonian parameters alpha = sp.array(inputstate) beta = sp.zeros((neurons,neurons)) delta = sp.array([]) # Construct the memory matrix according to a learning rule if learningRule == 'hebb': # Construct pattern matrix according to Hebb's rule for i in range(neurons): for j in range(neurons): for p in range(len(memories)): beta[i,j] += ( memories[p][i]*memories[p][j] - len(memories)*(i == j) ) beta = sp.triu(beta)/float(neurons) elif learningRule == 'stork': # Construct the memory matrix according to the Storkey learning rule memMat = sp.zeros((neurons,neurons)) for m, mem in enumerate(memories): for i in range(neurons): for j in range(neurons): hij = sp.sum([ memMat[i,k]*mem[k] for k in range(neurons) ]) hji = sp.sum([ memMat[j,k]*mem[k] for k in range(neurons) ]) # Don't forget to make the normalization a float! memMat[i,j] += 1./neurons*(mem[i]*mem[j] - mem[i]*hji - hij*mem[j]) beta = sp.triu(memMat) elif learningRule == 'proj': # Construct memory matrix according to the Moore-Penrose pseudoinverse rule memMat = sp.matrix(memories).T beta = sp.triu(memMat * sp.linalg.pinv(memMat)) # Calculate Hamming distance between input state and each memory hammingDistance = [] for mem in memories: dist = sp.sum(abs(sp.array(inputstate)-sp.array(mem))/2) hammingDistance.append(dist) hamMean = sp.average(hammingDistance) hamMed = sp.median(hammingDistance) # Some outputs outputs = { 'nQubits': nQubits, 'learningRule': learningRule, 'outdir': probdir, 'inputState': inputstate, 'memories': memories, 'hammingDistance': {'dist': hammingDistance, 'mean': hamMean, 'median': hamMed }, 'annealTime': list(T) if isinstance(T, collections.Iterable) else T } ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': None, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': None }
def CATS2D(mol,PathLength = 10,scale = 3): """ ################################################################# The main program for calculating the CATS descriptors. CATS: chemically advanced template serach ----> CATS_DA0 .... Usage: result=CATS2D(mol,PathLength = 10,scale = 1) Input: mol is a molecule object. PathLength is the max topological distance between two atoms. scale is the normalization method (descriptor scaling method) scale = 1 indicates that no normalization. That is to say: the values of the vector represent raw counts ("counts"). scale = 2 indicates that division by the number of non-hydrogen atoms (heavy atoms) in the molecule. scale = 3 indicates that division of each of 15 possible PPP pairs by the added occurrences of the two respective PPPs. Output: result is a dict format with the definitions of each descritor. ################################################################# """ Hmol = Chem.RemoveHs(mol) AtomNum = Hmol.GetNumAtoms() atomtype = AssignAtomType(Hmol) DistanceMatrix = Chem.GetDistanceMatrix(Hmol) DM = scipy.triu(DistanceMatrix) tempdict = {} for PL in range(0,PathLength): if PL == 0: Index = [[k,k] for k in range(AtomNum)] else: Index1 = scipy.argwhere(DM == PL) Index = [[k[0],k[1]] for k in Index1] temp = [] for j in Index: temp.extend(MatchAtomType(j,atomtype)) tempdict.update({PL:temp}) CATSLabel = FormCATSLabel(PathLength) CATS1 = FormCATSDict(tempdict,CATSLabel) ####set normalization 3 AtomPair = ['DD','DA','DP','DN','DL','AA','AP', 'AN','AL','PP','PN','PL','NN','NL','LL'] temp = [] for i,j in tempdict.items(): temp.extend(j) AtomPairNum = {} for i in AtomPair: AtomPairNum.update({i:temp.count(i)}) ############################################ CATS = {} if scale == 1: CATS = CATS1 if scale == 2: for i in CATS1: CATS.update({i:round(CATS1[i]/(AtomNum+0.0),3)}) if scale == 3: for i in CATS1: if AtomPairNum[i[5:7]] == 0: CATS.update({i:round(CATS1[i],3)}) else: CATS.update({i:round(CATS1[i]/(AtomPairNum[i[5:7]]+0.0),3)}) return CATS
def from_gene(self, gene): for transcript_idx in range(len(gene.transcripts)): exon_start_end = gene.exons[transcript_idx] ### only one exon in the transcript if exon_start_end.shape[0] == 1: exon1_start = exon_start_end[0, 0] exon1_end = exon_start_end[0, 1] if self.vertices.shape[1] == 0: self.vertices = sp.array([[exon1_start], [exon1_end]], dtype='int') self.edges = sp.array([[0]], dtype='int') else: self.vertices = sp.c_[self.vertices, [exon1_start, exon1_end]] self.new_edge() ### more than one exon in the transcript else: for exon_idx in range(exon_start_end.shape[0] - 1): exon1_start = exon_start_end[exon_idx , 0] exon1_end = exon_start_end[exon_idx, 1] exon2_start = exon_start_end[exon_idx + 1, 0] exon2_end = exon_start_end[exon_idx + 1, 1] if self.vertices.shape[1] == 0: self.vertices = sp.array([[exon1_start, exon2_start], [exon1_end, exon2_end]], dtype='int') self.edges = sp.array([[0, 1], [1, 0]], dtype='int') else: exon1_idx = -1 exon2_idx = -1 ### check if current exon already occurred for idx in range(self.vertices.shape[1]): if ((self.vertices[0, idx] == exon1_start) and (self.vertices[1, idx] == exon1_end)): exon1_idx = idx if ((self.vertices[0, idx] == exon2_start) and (self.vertices[1, idx] == exon2_end)): exon2_idx = idx ### both exons already occured -> only add an edge if (exon1_idx != -1) and (exon2_idx != -1): self.edges[exon1_idx, exon2_idx] = 1 self.edges[exon2_idx, exon1_idx] = 1 else: ### 2nd exon occured if ((exon1_idx == -1) and (exon2_idx != -1)): self.vertices = sp.c_[self.vertices, [exon1_start, exon1_end]] self.new_edge() self.edges[exon2_idx, -1] = 1 self.edges[-1, exon2_idx] = 1 ### 1st exon occured elif ((exon2_idx == -1) and (exon1_idx != -1)): self.vertices = sp.c_[self.vertices, [exon2_start, exon2_end]] self.new_edge() self.edges[exon1_idx, -1] = 1 self.edges[-1, exon1_idx] = 1 ### no exon occured else: assert((exon1_idx == -1) and (exon2_idx == -1)) self.vertices = sp.c_[self.vertices, [exon1_start, exon1_end]] self.vertices = sp.c_[self.vertices, [exon2_start, exon2_end]] self.new_edge() self.new_edge() self.edges[-2, -1] = 1 self.edges[-1, -2] = 1 ### take care of the sorting by exon start s_idx = sp.argsort(self.vertices[0, :]) self.vertices = self.vertices[:, s_idx] self.edges = self.edges[s_idx, :][:, s_idx] self.terminals = sp.zeros(self.vertices.shape, dtype='int') self.terminals[0, sp.where(sp.tril(self.edges).sum(axis=1) == 0)[0]] = 1 self.terminals[1, sp.where(sp.triu(self.edges).sum(axis=1) == 0)[0]] = 1
def parameters(cmdargs): """ """ # The Hopfield parameters hparams = { 'numNeurons': cmdargs['qubits'], 'inputState': [ 2*sp.random.random_integers(0,1)-1 for k in xrange(cmdargs['qubits']) ], 'learningRule': cmdargs['simtype'], 'numMemories': int(cmdargs['farg']) } def hamdist(a,b): """ Calculate Hamming distance. """ return sp.sum(abs(sp.array(a)-sp.array(b))/2.0) # Construct memories memories = [ [ 2*sp.random.random_integers(0,1)-1 for k in xrange(hparams['numNeurons']) ] for j in xrange(hparams['numMemories']) ] # Choose an input state to start memories[0] = list(hparams['inputState']) # # Pick two random spins to flip # rndbit1 = sp.random.random_integers(0,hparams['numNeurons']-1) # rndbit2 = sp.random.random_integers(0,hparams['numNeurons']-1) # while rndbit1 == rndbit2: # rndbit2 = sp.random.random_integers(0,hparams['numNeurons']-1) # # Flip them # memories[0][rndbit1] *= -1 # memories[0][rndbit2] *= -1 # # Make sure that the input is NOT in the memory set # while list(hparams['inputState']) in memories: # # Do it all again to make sure we don't get stuck # memories = [ [ 2*sp.random.random_integers(0,1)-1 # for k in xrange(hparams['numNeurons']) ] # for j in xrange(hparams['numMemories']) ] # memories[0] = list(hparams['inputState']) # # Pick two random spins to flip # rndbit1 = sp.random.random_integers(0,hparams['numNeurons']-1) # rndbit2 = sp.random.random_integers(0,hparams['numNeurons']-1) # while rndbit1 == rndbit2: # rndbit2 = sp.random.random_integers(0,hparams['numNeurons']-1) # # Flip them # memories[0][rndbit1] *= -1 # memories[0][rndbit2] *= -1 # # Loop over additional memories, if there are any # for imem, mem in enumerate(memories[1:]): # while hamdist(mem, hparams['inputState']) < 2.0: # # Flip a random spin # rndbit = sp.random.random_integers(0,hparams['numNeurons']-1) # memories[imem+1][rndbit] *= -1 memories[0][:3] *= -1 # Loop over memories, make sure none are closer than 3.0 to input for imem, mem in enumerate(memories[1:]): while hamdist(mem, hparams['inputState']) < 2.0: # Flip a random spin rndbit = sp.random.random_integers(0,hparams['numNeurons']-1) memories[imem+1][rndbit] *= -1 # Basic simulation params nQubits = hparams['numNeurons'] T = 1000.0 dt = 0.01*T # Output parameters binary = 1 # Save output files as binary Numpy format progressout = 0 # Output simulation progress over anneal timesteps eigspecdat = 1 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 2**nQubits # Number of eigenvalues to output fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' # Output directory stuff probdir = 'data/hopfield_var_gamma_exp4_hd2/n'+str(nQubits)+'p'+\ str(hparams['numMemories'])+hparams['learningRule'] if isinstance(T, collections.Iterable): probdir += 'MultiT' if os.path.isdir(probdir): outlist = sorted([ int(name) for name in os.listdir(probdir) if name.isdigit() ]) else: outlist = [] outnum = outlist[-1] + 1 if outlist else 0 outputdir = probdir + '/' + str(outnum) + '/' probshow = 0 # Print final state probabilities to screen probout = 1 # Output probabilities to file mingap = 0 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 0 isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1} # Construct network Ising parameters neurons = nQubits # This is gamma, the appropriate weighting on the input vector isingSigns['hz'] *= float(cmdargs['garg']) alpha = sp.array(hparams['inputState']) beta = sp.zeros((neurons,neurons)) delta = sp.array([]) # Construct the memory matrix according to a learning rule if hparams['learningRule'] == 'hebb': # Construct pattern matrix according to Hebb's rule for i in range(neurons): for j in range(neurons): for p in range(len(memories)): beta[i,j] += ( memories[p][i]*memories[p][j] - len(memories)*(i == j) ) beta = sp.triu(beta)/float(neurons) elif hparams['learningRule'] == 'stork': # Construct the memory matrix according to the Storkey learning rule memMat = sp.zeros((neurons,neurons)) for m, mem in enumerate(memories): for i in range(neurons): for j in range(neurons): hij = sp.sum([ memMat[i,k]*mem[k] for k in range(neurons) ]) hji = sp.sum([ memMat[j,k]*mem[k] for k in range(neurons) ]) # Don't forget to make the normalization a float! memMat[i,j] += 1./neurons*(mem[i]*mem[j] - mem[i]*hji - hij*mem[j]) beta = sp.triu(memMat) elif hparams['learningRule'] == 'proj': # Construct memory matrix according to the Moore-Penrose pseudoinverse rule memMat = sp.matrix(memories).T beta = sp.triu(memMat * sp.linalg.pinv(memMat)) # Some outputs outputs = { 'nQubits': nQubits, 'learningRule': hparams['learningRule'], 'inputState': hparams['inputState'], 'memories': memories, 'answer': memories[0], 'gamma': float(cmdargs['garg']), 'annealTime': list(T) if isinstance(T, collections.Iterable) else T } ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': None, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': None, 'hzscale': None, 'hzzscale': None, 'hxscale': None, 'solveMethod': solveMethod }
def detect_multipleskips(genes, gidx, log=False, edge_limit=300): # [idx_multiple_skips, exon_multiple_skips] = detect_multipleskips(genes, idx_alt) ; idx_multiple_skips = [] exon_multiple_skips = [] for iix, ix in enumerate(gidx): if log: sys.stdout.write('.') if (iix + 1) % 50 == 0: sys.stdout.write(' - %i/%i, found %i\n' % (iix + 1, genes.shape[0] + 1, len(idx_multiple_skips))) sys.stdout.flush() genes[iix].from_sparse() num_exons = genes[iix].splicegraph.get_len() edges = genes[iix].splicegraph.edges.copy() labels = repmat(sp.arange(num_exons), num_exons, 1).T genes[iix].to_sparse() # adjecency matrix: upper half only A = sp.zeros((num_exons, num_exons)) for i in range(num_exons - 1): for j in range(i + 1, num_exons): A[i, j] = edges[i, j] # possible starting and ending exons of a multiple exon skip Pairs = lil_matrix((num_exons, num_exons)) Ai = sp.dot(sp.dot(A, A), A) #paths of length 3 while sp.any(Ai.ravel() > 0): coords = sp.where((A > 0 ) & (Ai > 0)) # multiple skip Pairs[coords[0], coords[1]] = 1 Ai = sp.dot(Ai, A) # paths of length ..+1 edge = sp.where(Pairs.toarray() == 1) if edge[0].shape[0] > edge_limit: print '\nWARNING: not processing gene %i (%s); has %i edges; current limit is %i; adjust edge_limit to include.' % (ix, genes[iix].name, edge[0].shape[0], edge_limit) continue for cnt in range(edge[0].shape[0]): exon_idx_first = edge[0][cnt] exon_idx_last = edge[1][cnt] if edges[exon_idx_first, exon_idx_last] == 1: # find all pairs shortest path exist_path = sp.triu(edges).astype('double') exist_path[exon_idx_first, exon_idx_last] = 0 exist_path[exist_path == 0] = sp.inf # set diagonal to 0 exist_path[sp.arange(exist_path.shape[0]), sp.arange(exist_path.shape[0])] = 0 long_exist_path = -sp.triu(edges).astype('double') long_exist_path[exon_idx_first, exon_idx_last] = 0 long_exist_path[long_exist_path == 0] = sp.inf # set diagonal to 0 long_exist_path[sp.arange(long_exist_path.shape[0]), sp.arange(long_exist_path.shape[0])] = 0 path = sp.isfinite(exist_path) * labels long_path = sp.isfinite(long_exist_path) * labels for k in range(num_exons): for i in range(num_exons): idx = sp.where((exist_path[i, k] + exist_path[k, :]) < exist_path[i, :])[0] exist_path[i, idx] = exist_path[i, k] + exist_path[k, idx] path[i, idx] = path[k, idx] idx = sp.where((long_exist_path[i,k] + long_exist_path[k, :]) < long_exist_path[i, :])[0] long_exist_path[i, idx] = long_exist_path[i, k] + long_exist_path[k, idx] long_path[i, idx] = long_path[k, idx] temp_ix = sp.isfinite(long_exist_path) long_exist_path[temp_ix] = -long_exist_path[temp_ix] if (exist_path[exon_idx_first, exon_idx_last] > 2) and sp.isfinite(exist_path[exon_idx_first, exon_idx_last]): backtrace = sp.array([path[exon_idx_first, exon_idx_last]]) while backtrace[-1] > exon_idx_first: backtrace = sp.r_[backtrace, path[exon_idx_first, backtrace[-1]]] backtrace = backtrace[:-1] backtrace = backtrace[::-1] idx_multiple_skips.append(ix) #repmat(ix, 1, backtrace.shape[0] + 2)) exon_multiple_skips.append([exon_idx_first, backtrace, exon_idx_last]) elif (long_exist_path[exon_idx_first, exon_idx_last] > 2) and sp.isfinite(long_exist_path[exon_idx_first, exon_idx_last]): backtrace = sp.array([long_path[exon_idx_first, exon_idx_last]]) while backtrace[-1] > exon_idx_first: backtrace = sp.r_[backtrace, long_path[exon_idx_first, backtrace[-1]]] backtrace = backtrace[:-1] backtrace = backtrace[::-1] idx_multiple_skips.append(ix) #repmat(ix, 1, backtrace.shape[0] + 2)) exon_multiple_skips.append([exon_idx_first, backtrace, exon_idx_last]) if log: print 'Number of multiple exon skips:\t\t\t\t\t%d' % len(idx_multiple_skips) return (idx_multiple_skips, exon_multiple_skips)
def parameters(cmdargs): """ """ nQubits = 8 T = 10.0 #T = sp.arange(2,23,4.0) # Output a sequence of anneal times dt = 0.01 * T # Output parameters binary = 0 # Save output files as binary Numpy format progressout = 0 # Output simulation progress over anneal timesteps outputdir = 'data/hopfield_hamming_inv/' # In relation to run.py eigspecdat = 1 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 16 # Number of eigenvalues to output fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' # solveMethod = 'SuzTrot' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' probshow = 1 # Print final state probabilities to screen probout = 1 # Output probabilities to file mingap = 0 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 0 isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1} def spins2bitstr(vec): """ Return a converted bitstring from @vec, a list of spins. """ return ''.join(['0' if k == 1 else '1' for k in vec]) # Construct network Ising parameters neurons = nQubits # if nQubits % 2 == 0: # memories = sp.linalg.hadamard(neurons).tolist() # inputstate = memories[0] # memories = [[ 1,-1,-1, 1, 1,-1,-1, 1], # [-1,-1,-1, 1, 1,-1,-1, 1], # [ 1,-1,-1, 1, 1,-1,-1,-1]] memories = [[1, -1, -1, 1, -1, -1, -1, 1], [1, -1, -1, 1, -1, -1, -1, 1], [1, -1, -1, 1, -1, -1, -1, -1]] inputstate = memories[0] print("Input:") print(spins2bitstr(inputstate)) print('') print("Memories:") for mem in memories: print(spins2bitstr(mem)) print('') # This is gamma, the appropriate weighting on the input vector # isingSigns['hz'] *= 1 - (len(inputstate) - inputstate.count(0))/(2*neurons) # isingSigns['hz'] *= 0.6772598397 isingSigns['hz'] *= 1.0 print("Gamma: ", isingSigns['hz']) print('') alpha = sp.array(inputstate) beta = sp.zeros((neurons, neurons)) delta = sp.array([]) # Hebb rule - even better matrix style memMat = sp.matrix(memories).T beta = (sp.triu(memMat * memMat.T) - len(memories) * sp.eye(nQubits)) / float(neurons) print beta # # Hebb rule - matrix style # for m, mem in enumerate(memories): # beta += (sp.outer(mem, mem))-sp.eye(neurons) # beta = sp.triu(beta)/float(neurons) # beta = sp.zeros((neurons,neurons)) # # Construct pattern matrix according to the Hebb learning rule # for i in range(neurons): # for j in range(neurons): # for p in range(len(memories)): # beta[i,j] += ( memories[p][i]*memories[p][j] - # len(memories)*(i == j) ) # beta = sp.triu(beta)/float(neurons) # Storkey rule (incorrect, but may be useful later) # memMat = sp.zeros((neurons,neurons)) # for m, mem in enumerate(memories): # for i in range(neurons): # for j in range(neurons): # hij = sp.sum([ memMat[i,k]*mem[k] for k in range(neurons) ]) # hji = sp.sum([ memMat[j,k]*mem[k] for k in range(neurons) ]) # # Don't forget to make the normalization a float! # memMat[i,j] += (mem[i]*mem[j] - mem[i]*hji - hij*mem[j])/float(neurons) # beta = sp.triu(memMat) # # Storkey rule # Wm = sp.zeros((neurons,neurons)) # for m, mem in enumerate(memories): # Am = sp.mat((sp.outer(mem,mem) - sp.eye(neurons))) # Wm += (Am - Am*Wm - Wm*Am)/float(neurons) # beta = sp.triu(Wm) # # Construct memory matrix according to the Moore-Penrose pseudoinverse rule # memMat = sp.matrix(memories).T # beta = sp.triu(memMat * sp.linalg.pinv(memMat)) # Usually we specify outputs that may be of interest in the form of a dict, # but we don't need any for this problem outputs = None ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': None, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': None, 'hzscale': None, 'hzzscale': None, 'hxscale': None, 'solveMethod': solveMethod }
def parameters(cmdargs): """ """ # The Hopfield parameters hparams = { 'numNeurons': cmdargs['qubits'], 'inputState': None, 'learningRule': cmdargs['simtype'], 'numMemories': 0 } # Set input state inpst = sp.eye(cmdargs['qubits'])[0,:] - 1 inpst[inpst == 0] = 1 hparams['inputState'] = inpst.tolist() # Construct memories imems = cmdargs['instance'] memories = sp.eye(cmdargs['qubits'])[0:imems,:] memories[memories == 0] -= 1 memories = memories.tolist() # Basic simulation params nQubits = hparams['numNeurons'] T = 15. # sp.arange(0.1, 15, 0.5) dt = 0.01*T # Define states for which to track probabilities in time import statelabels label_list = statelabels.GenerateLabels(nQubits) stateoverlap = [] for mem in memories: # Convert spins to bits bitstr = ''.join([ '0' if k == -1 else '1' for k in mem ]) # Get the index of the current (converted) memory and add it to list stateoverlap.append([ label_list.index(bitstr), bitstr ]) # Output parameters binary = 1 # Save output files as binary Numpy format progressout = 1 # Output simulation progress over anneal timesteps eigspecdat = 1 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 2**nQubits # Number of eigenvalues to output fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' # Output directory stuff probdir = 'data/hopfield_ortho/m'+str(imems)+hparams['learningRule'] if isinstance(T, collections.Iterable): probdir += 'MultiT' if os.path.isdir(probdir): outlist = sorted([ int(name) for name in os.listdir(probdir) if name.isdigit() ]) else: outlist = [] outnum = outlist[-1] + 1 if outlist else 0 outputdir = probdir + '/' + str(outnum) + '/' probshow = 0 # Print final state probabilities to screen probout = 1 # Output probabilities to file mingap = 1 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 0 isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1} # Construct network Ising parameters neurons = nQubits # This is gamma, the appropriate weighting on the input vector isingSigns['hz'] *= 1 - (len(hparams['inputState']) - hparams['inputState'].count(0))/(2*neurons) alpha = sp.array(hparams['inputState']) beta = sp.zeros((neurons,neurons)) delta = sp.array([]) # Construct the memory matrix according to a learning rule if hparams['learningRule'] == 'hebb': # Construct pattern matrix according to Hebb's rule for i in range(neurons): for j in range(neurons): for p in range(len(memories)): beta[i,j] += ( memories[p][i]*memories[p][j] - len(memories)*(i == j) ) beta = sp.triu(beta)/float(neurons) elif hparams['learningRule'] == 'stork': # Construct the memory matrix according to the Storkey learning rule memMat = sp.zeros((neurons,neurons)) for m, mem in enumerate(memories): for i in range(neurons): for j in range(neurons): hij = sp.sum([ memMat[i,k]*mem[k] for k in range(neurons) ]) hji = sp.sum([ memMat[j,k]*mem[k] for k in range(neurons) ]) # Don't forget to make the normalization a float! memMat[i,j] += 1./neurons*(mem[i]*mem[j] - mem[i]*hji - hij*mem[j]) beta = sp.triu(memMat) elif hparams['learningRule'] == 'proj': # Construct memory matrix according to the Moore-Penrose pseudoinverse rule memMat = sp.matrix(memories).T beta = sp.triu(memMat * sp.linalg.pinv(memMat)) # Usually we specify outputs that may be of interest in the form of a dict, # but we don't need any for this problem outputs = None ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': None, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': stateoverlap, 'hzscale': None, 'hzzscale': None, 'hxscale': None, 'solveMethod': solveMethod }
def parameters(cmdargs): """ """ # The Hopfield parameters hparams = { 'numNeurons': cmdargs['qubits'], 'inputState': [ 2*sp.random.random_integers(0,1)-1 for k in xrange(cmdargs['qubits']) ], 'learningRule': cmdargs['simtype'], 'numMemories': int(cmdargs['farg']) } # Instances will be actual instances x # of patterns instIdx = cmdargs['instance'] / hparams['numMemories'] # Subinstance will be given by the modulus subinst = cmdargs['instances'] % hparams['numMemories'] # Get memories memdat = pickle.load( open('exp2_memset_n'+str(hparams['numNeurons'])+'.dat', 'rb')) memories = memdat[instIdx] del memdat # Define the input state as a pattern with Hamming dist. 1 from # the pattern with index = subinst hparams['inputState'] = memories[subinst] hparams['inputState'][sp_rint(0,hparams['numNeurons']-1)] *= -1 # Simulation variables nQubits = hparams['numNeurons'] T = 15.0 dt = 0.01*T # Define states for which to track probabilities in time import statelabels label_list = statelabels.GenerateLabels(nQubits) stateoverlap = [] for mem in memories: # Convert spins to bits bitstr = ''.join([ '0' if k == 1 else '1' for k in mem ]) # Get the index of the current (converted) memory and add it to list stateoverlap.append([ label_list.index(bitstr), bitstr ]) # Output parameters binary = 1 # Save as binary Numpy progressout = 0 # Output simulation progress over anneal timesteps eigspecdat = 1 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 2**nQubits # Number of eigenvalues fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' # Output directory stuff probdir = 'data/hopfield_exp2/n'+str(nQubits)+'p'+str(pnum)+learningRule if isinstance(T, collections.Iterable): probdir += 'MultiT' if os.path.isdir(probdir): outlist = sorted([ int(name) for name in os.listdir(probdir) if name.isdigit() ]) else: outlist = [] outnum = outlist[-1] + 1 if outlist else 0 outputdir = probdir + '/' + str(outnum) + '/' probshow = 0 # Print final state probabilities to screen probout = 1 # Output probabilities to file mingap = 1 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 0 isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1} # This is gamma, the appropriate weighting on the input vector isingSigns['hz'] *= 1.0/(5*nQubits) neurons = nQubits # Initialize Hamiltonian parameters alpha = sp.array(hparams['inputState']) beta = sp.zeros((neurons,neurons)) delta = sp.array([]) # Construct the memory matrix according to a learning rule if hparams['learningRule'] == 'hebb': # Construct pattern matrix according to Hebb's rule for i in range(neurons): for j in range(neurons): for p in range(len(memories)): beta[i,j] += ( memories[p][i]*memories[p][j] - len(memories)*(i == j) ) beta = sp.triu(beta)/float(neurons) elif hparams['learningRule'] == 'stork': # Construct the memory matrix according to the Storkey learning rule memMat = sp.zeros((neurons,neurons)) for m, mem in enumerate(memories): for i in range(neurons): for j in range(neurons): hij = sp.sum([ memMat[i,k]*mem[k] for k in range(neurons) ]) hji = sp.sum([ memMat[j,k]*mem[k] for k in range(neurons) ]) # Don't forget to make the normalization a float! memMat[i,j] += 1./neurons*(mem[i]*mem[j] - mem[i]*hji - hij*mem[j]) beta = sp.triu(memMat) elif hparams['learningRule'] == 'proj': # Construct memory matrix according to the Moore-Penrose pseudoinverse rule memMat = sp.matrix(memories).T beta = sp.triu(memMat * sp.linalg.pinv(memMat)) # Calculate Hamming distance between input state and each memory hammingDistance = [] for mem in memories: dist = sp.sum(abs(sp.array(hparams['inputState'])-sp.array(mem))/2) hammingDistance.append(dist) hamMean = sp.average(hammingDistance) hamMed = sp.median(hammingDistance) # Some outputs outputs = { 'nQubits': nQubits, 'learningRule': hparams['learningRule'], 'outdir': probdir, 'hparams['inputState']': hparams['inputState'], 'memories': memories, 'hammingDistance': {'dist': hammingDistance, 'mean': hamMean, 'median': hamMed }, 'annealTime': list(T) if isinstance(T, collections.Iterable) else T } ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': None, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': stateoverlap, 'hzscale': None, 'hzzscale': None, 'hxscale': None, 'solveMethod': solveMethod }
def plot_graph(vertices, edges, ax, xlim=None, highlight=None, highlight_color='magenta', node_color='b', edge_color='#999999'): """Takes a graph given as vertices and edges and visualizes its structure""" start = vertices.ravel().min() stop = vertices.ravel().max() ### draw grid ax.grid(b=True, which='major', linestyle='--', linewidth=0.2, color='#222222') ax.yaxis.grid(False) ### nodes patchlist = [] exon_num = sp.zeros((stop - start, )) exon_loc = sp.zeros((1, stop - start)) exon_level = sp.zeros((vertices.shape[1], )) #vertices.shape[1])) for i in range(vertices.shape[1]): cur_vertex = vertices[:, i] - start exon_num[cur_vertex[0]:cur_vertex[1]] += 1 if sp.all(exon_num < 2): exon_loc[0, :] = exon_num level = 0 elif exon_num.max() > exon_loc.shape[0]: exon_loc = sp.r_[exon_loc, sp.zeros((1, stop - start))] exon_loc[-1, cur_vertex[0]:cur_vertex[1]] = 1 level = exon_loc.shape[0] - 1 elif exon_num.max() <= exon_loc.shape[0]: idx = sp.where( sp.all(exon_loc[:, cur_vertex[0]:cur_vertex[1]] == 0, 1))[0].min() exon_loc[idx, cur_vertex[0]:cur_vertex[1]] = 1 level = idx exon_level[i] = level patchlist.append( mpatches.Rectangle([cur_vertex[0] + start, 20 + (level * 20)], cur_vertex[1] - cur_vertex[0], 10, facecolor=node_color, edgecolor='none', alpha=0.7)) ### edges linelist = [] intron_loc = sp.zeros((1, stop - start)) if edges.shape[0] > 1: ii, jj = sp.where(sp.triu(edges) > 0) for i, j in zip(ii, jj): #for i in range(vertices.shape[1]): #for j in range(i + 1, vertices.shape[1]): #if edges[i ,j] > 0: if vertices[0, i] < vertices[0, j]: istart = vertices[1, i] istop = vertices[0, j] level1 = exon_level[i] level2 = exon_level[j] else: istart = vertices[1, j] istop = vertices[0, i] level1 = exon_level[j] level2 = exon_level[i] cur_intron = [istart - start, istop - start] intron_loc[cur_intron[0]:cur_intron[1]] += 1 leveli = [(istart + istop) * 0.5, (level1 + level2) * 0.5] #ax.plot([istart, leveli[0], istop], [25 + (level1 * 20), 32 + (leveli[1] * 20), 25 + (level2 * 20)], '-', color=edge_color, linewidth=0.5) linelist.append( mlines.Line2D([istart, leveli[0], istop], [ 25 + (level1 * 20), 32 + (leveli[1] * 20), 25 + (level2 * 20) ], color=edge_color, linewidth=0.5)) #ax.plot([leveli[0], istop], [32 + (leveli[1] * 20), 25 + (level2 * 20)], '-', color=edge_color, linewidth=0.5) ### draw patches for node in patchlist: ax.add_patch(node) for line in linelist: ax.add_line(line) ### axes if xlim is not None: ax.set_xlim(xlim) else: ax.set_xlim([max(start - 20, 0), stop + 20]) ax.set_ylim([0, 40 + (exon_loc.shape[0] * 20)]) ax.set_yticklabels([]) ### highlight if requested if highlight is not None: rect = patches.Rectangle((highlight[0], 0), highlight[1] - highlight[0], ax.get_ylim()[1], facecolor=highlight_color, edgecolor='none', alpha=0.5) ax.add_patch(rect)
def detect_multipleskips(genes, gidx, log=False, edge_limit=300): # [idx_multiple_skips, exon_multiple_skips] = detect_multipleskips(genes, idx_alt) ; idx_multiple_skips = [] exon_multiple_skips = [] for iix, ix in enumerate(gidx): if log: sys.stdout.write('.') if (iix + 1) % 50 == 0: sys.stdout.write(' - %i/%i, found %i\n' % (iix + 1, genes.shape[0] + 1, len(idx_multiple_skips))) sys.stdout.flush() num_exons = genes[iix].splicegraph.get_len() edges = genes[iix].splicegraph.edges labels = repmat(sp.arange(num_exons), num_exons, 1).T # adjecency matrix: upper half only A = sp.zeros((num_exons, num_exons)) for i in range(num_exons - 1): for j in range(i + 1, num_exons): A[i, j] = edges[i, j] # possible starting and ending exons of a multiple exon skip Pairs = lil_matrix((num_exons, num_exons)) Ai = sp.dot(sp.dot(A, A), A) #paths of length 3 while sp.any(Ai.ravel() > 0): coords = sp.where((A > 0 ) & (Ai > 0)) # multiple skip Pairs[coords[0], coords[1]] = 1 Ai = sp.dot(Ai, A) # paths of length ..+1 edge = sp.where(Pairs.toarray() == 1) if edge[0].shape[0] > edge_limit: print '\nWARNING: not processing gene %i (%s); has %i edges; current limit is %i; adjust edge_limit to include.' % (ix, genes[iix].name, edge[0].shape[0], edge_limit) continue for cnt in range(edge[0].shape[0]): exon_idx_first = edge[0][cnt] exon_idx_last = edge[1][cnt] if edges[exon_idx_first, exon_idx_last] == 1: # find all pairs shortest path exist_path = sp.triu(edges).astype('double') exist_path[exon_idx_first, exon_idx_last] = 0 exist_path[exist_path == 0] = sp.inf # set diagonal to 0 exist_path[sp.arange(exist_path.shape[0]), sp.arange(exist_path.shape[0])] = 0 long_exist_path = -sp.triu(edges).astype('double') long_exist_path[exon_idx_first, exon_idx_last] = 0 long_exist_path[long_exist_path == 0] = sp.inf # set diagonal to 0 long_exist_path[sp.arange(long_exist_path.shape[0]), sp.arange(long_exist_path.shape[0])] = 0 path = sp.isfinite(exist_path) * labels long_path = sp.isfinite(long_exist_path) * labels for k in range(num_exons): for i in range(num_exons): idx = sp.where((exist_path[i, k] + exist_path[k, :]) < exist_path[i, :])[0] exist_path[i, idx] = exist_path[i, k] + exist_path[k, idx] path[i, idx] = path[k, idx] idx = sp.where((long_exist_path[i,k] + long_exist_path[k, :]) < long_exist_path[i, :])[0] long_exist_path[i, idx] = long_exist_path[i, k] + long_exist_path[k, idx] long_path[i, idx] = long_path[k, idx] temp_ix = sp.isfinite(long_exist_path) long_exist_path[temp_ix] = -long_exist_path[temp_ix] if (exist_path[exon_idx_first, exon_idx_last] > 2) and sp.isfinite(exist_path[exon_idx_first, exon_idx_last]): backtrace = sp.array([path[exon_idx_first, exon_idx_last]]) while backtrace[-1] > exon_idx_first: backtrace = sp.r_[backtrace, path[exon_idx_first, backtrace[-1]]] backtrace = backtrace[:-1] backtrace = backtrace[::-1] idx_multiple_skips.append(ix) #repmat(ix, 1, backtrace.shape[0] + 2)) exon_multiple_skips.append([exon_idx_first, backtrace, exon_idx_last]) elif (long_exist_path[exon_idx_first, exon_idx_last] > 2) and sp.isfinite(long_exist_path[exon_idx_first, exon_idx_last]): backtrace = sp.array([long_path[exon_idx_first, exon_idx_last]]) while backtrace[-1] > exon_idx_first: backtrace = sp.r_[backtrace, long_path[exon_idx_first, backtrace[-1]]] backtrace = backtrace[:-1] backtrace = backtrace[::-1] idx_multiple_skips.append(ix) #repmat(ix, 1, backtrace.shape[0] + 2)) exon_multiple_skips.append([exon_idx_first, backtrace, exon_idx_last]) if log: print 'Number of multiple exon skips:\t\t\t\t\t%d' % len(idx_multiple_skips) return (idx_multiple_skips, exon_multiple_skips)
def plot_graph(vertices, edges, ax, xlim=None, highlight=None, highlight_color='magenta', node_color='b', edge_color='#999999'): """Takes a graph given as vertices and edges and visualizes its structure""" start = vertices.ravel().min() stop = vertices.ravel().max() ### draw grid ax.grid(b=True, which='major', linestyle='--', linewidth=0.2, color='#222222') ax.yaxis.grid(False) ### nodes patchlist = [] exon_num = sp.zeros((stop - start,)) exon_loc = sp.zeros((1, stop - start)) exon_level = sp.zeros((vertices.shape[1], )) #vertices.shape[1])) for i in range(vertices.shape[1]): cur_vertex = vertices[:, i] - start exon_num[cur_vertex[0]:cur_vertex[1]] += 1 if sp.all(exon_num < 2): exon_loc[0, :] = exon_num level = 0 elif exon_num.max() > exon_loc.shape[0]: exon_loc = sp.r_[exon_loc, sp.zeros((1, stop - start))] exon_loc[-1, cur_vertex[0]:cur_vertex[1]] = 1 level = exon_loc.shape[0] - 1 elif exon_num.max() <= exon_loc.shape[0]: idx = sp.where(sp.all(exon_loc[:, cur_vertex[0]:cur_vertex[1]] == 0, 1))[0].min() exon_loc[idx, cur_vertex[0]:cur_vertex[1]] = 1 level = idx exon_level[i] = level patchlist.append(mpatches.Rectangle([cur_vertex[0] + start, 20 + (level * 20)], cur_vertex[1] - cur_vertex[0], 10, facecolor=node_color, edgecolor='none', alpha=0.7)) ### edges linelist = [] intron_loc = sp.zeros((1, stop - start)) if edges.shape[0] > 1: ii, jj = sp.where(sp.triu(edges) > 0) for i, j in zip(ii, jj): #for i in range(vertices.shape[1]): #for j in range(i + 1, vertices.shape[1]): #if edges[i ,j] > 0: if vertices[0,i] < vertices[0,j]: istart = vertices[1, i] istop = vertices[0, j] level1 = exon_level[i] level2 = exon_level[j] else: istart = vertices[1, j] istop = vertices[0, i] level1 = exon_level[j] level2 = exon_level[i] cur_intron = [istart - start, istop - start] intron_loc[cur_intron[0]:cur_intron[1]] += 1 leveli = [(istart + istop) * 0.5, (level1 + level2) * 0.5] #ax.plot([istart, leveli[0], istop], [25 + (level1 * 20), 32 + (leveli[1] * 20), 25 + (level2 * 20)], '-', color=edge_color, linewidth=0.5) linelist.append(mlines.Line2D([istart, leveli[0], istop], [25 + (level1 * 20), 32 + (leveli[1] * 20), 25 + (level2 * 20)], color=edge_color, linewidth=0.5)) #ax.plot([leveli[0], istop], [32 + (leveli[1] * 20), 25 + (level2 * 20)], '-', color=edge_color, linewidth=0.5) ### draw patches for node in patchlist: ax.add_patch(node) for line in linelist: ax.add_line(line) ### axes if xlim is not None: ax.set_xlim(xlim) else: ax.set_xlim([max(start - 20, 0), stop + 20]) ax.set_ylim([0, 40 + (exon_loc.shape[0] * 20)]) ax.set_yticklabels([]) ### highlight if requested if highlight is not None: rect = patches.Rectangle((highlight[0], 0), highlight[1] - highlight[0], ax.get_ylim()[1], facecolor=highlight_color, edgecolor='none', alpha=0.5) ax.add_patch(rect)
logsched = np.array([ fieldstart/(np.log(k+1)*rlog + 1) for k in xrange(annealingsteps) ]) trlog = (tempend/(tempstart-1))/np.log(tannealingsteps+1) tlogsched = np.array([ tempstart/(np.log(k+1)*trlog + 1) for k in xrange(tannealingsteps) ]) # hack tannealingsched = texpsched annealingsched = expsched def getbitstr(vec): """ Return bitstring from spin vector array. """ return reduce(lambda x,y: x+y, [ str(int(k)) for k in tools.spins2bits(vec) ]) # Construct Ising matrix memMat = sp.matrix(memories).T isingJ = sp.triu(memMat * sp.linalg.pinv(memMat)) isingJ -= sp.diag(sp.diag(isingJ)) isingJ = sp.triu(memMat * sp.linalg.pinv(memMat)) isingJ += inpbias*sp.diag(vinput) isingJ = sps.dok_matrix(isingJ) # get energies of all states results = [] energies = np.zeros(2**nspins) for b in [ bin(x)[2:].rjust(nspins, '0') for x in range(2**nspins) ]: svec = tools.bits2spins(np.array([ int(k) for k in b ])) energies[int(b,2)] = sa.ClassicalIsingEnergy(svec, isingJ) results.append([energies[int(b,2)], b]) print("All possible states and their energies:") for res in sorted(results)[:10]: print("%s %2.4f" % tuple(res[::-1]))
def parameters(cmdargs): """ """ nQubits = 6 T = 30.0 #T = sp.arange(2,103,10) # Output a sequence of anneal times dt = 0.1 # Output parameters binary = 1 # Save output files as binary Numpy format progressout = 0 # Output simulation progress over anneal timesteps outputdir = 'data/sixvarqubo_overlap/' # In relation to run.py eigspecdat = 0 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 2**nQubits # Number of eigenvalues to output fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' probshow = 1 # Print final state probabilities to screen #### BUG ##### probshow requires probout probout = 1 # Output probabilities to file mingap = 0 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 1 isingSigns = {'hx': 1, 'hz': 1, 'hzz': -1} # Define states for which to track probabilities in time import statelabels label_list = statelabels.GenerateLabels(nQubits) stateoverlap = [] for bitstr in ['100101', '110101']: # Get the index of the current (converted) memory and add it to list stateoverlap.append([label_list.index(bitstr), bitstr]) # Define the QUBO and its diagonal Q = sp.zeros((nQubits, nQubits)) a = sp.zeros(nQubits) a[0] = 2 a[1] = 1 a[2] = -2 a[3] = -1 a[4] = 1 a[5] = -1 Q[0, 1] = Q[1, 0] = -1 Q[0, 2] = Q[2, 0] = 2 Q[0, 3] = Q[3, 0] = -2 Q[0, 4] = Q[4, 0] = 2 Q[0, 5] = Q[5, 0] = -1 Q[1, 2] = Q[2, 1] = 1 Q[1, 3] = Q[3, 1] = -1 Q[1, 4] = Q[4, 1] = -1 Q[1, 5] = Q[5, 1] = 1 Q[2, 3] = Q[3, 2] = 2 Q[2, 4] = Q[4, 2] = -2 Q[2, 5] = Q[5, 2] = 1 Q[3, 4] = Q[4, 3] = 2 Q[3, 5] = Q[5, 3] = -1 Q[4, 5] = Q[5, 4] = 2 Q = sp.triu(Q) + a * sp.identity(6) # Usually we specify outputs that may be of interest in the form of a dict, # but we don't need any for this problem outputs = None # We could specify these below, but we want to avoid modifying that part alpha = beta = delta = None ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': Q, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': stateoverlap, 'solveMethod': solveMethod }
def parameters(cmdargs): """ cmdargs: -q, qubits -k, lrule -f, nmems -g, hdist """ # The Hopfield parameters hparams = { 'numNeurons': cmdargs['qubits'], 'inputState': [], 'learningRule': cmdargs['simtype'], 'numMemories': int(cmdargs['farg']) } # Construct memories memories = [ [ 2*sp.random.random_integers(0,1)-1 for k in xrange(hparams['numNeurons']) ] ] # Add a few memories that are some Hamming distance away from each other def hamdist(a,b): """ Calculate Hamming distance. """ return sp.sum(abs(sp.array(a)-sp.array(b))/2.0) for m in range(hparams['numMemories']-1): # pick a random memory newmem = memories[sp.random.random_integers(0,len(memories)-1)][:] # flip a random bit rndbit = sp.random.random_integers(0,hparams['numNeurons']-1) newmem[rndbit] *= -1 # make sure no duplicates while newmem in memories: rndbit = sp.random.random_integers(0,hparams['numNeurons']-1) newmem[rndbit] *= -1 # add it memories.append(newmem) # Choose a random memory for the input state hparams['inputState'] = memories[ sp.random.random_integers(0,len(memories)-1)] # Basic simulation params nQubits = hparams['numNeurons'] T = 10.0 # sp.arange(0.1, 15, 0.5) # T = sp.array([10.0, 20.0, 50.0, 100.0]) dt = 0.01*T # Define states for which to track probabilities in time # import statelabels # label_list = statelabels.GenerateLabels(nQubits) # stateoverlap = [] # for mem in memories: # # Convert spins to bits # bitstr = ''.join([ '0' if k == 1 else '1' for k in mem ]) # # Get the index of the current (converted) memory and add it to list # stateoverlap.append([ label_list.index(bitstr), bitstr ]) stateoverlap = None # Output parameters binary = 1 # Save output files as binary Numpy format progressout = 0 # Output simulation progress over anneal timesteps eigspecdat = 1 # Output data for eigspec eigspecplot = 0 # Plot eigspec eigspecnum = 16 # Number of eigenvalues to output fidelplot = 0 # Plot fidelity fideldat = 0 # Output fidelity data fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates overlapdat = 0 # Output overlap data overlapplot = 0 # Plot overlap solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM' # Output directory stuff probdir = 'data/hopfield_hamming/n'+str(nQubits)+'p'+\ str(hparams['numMemories'])+hparams['learningRule'] if isinstance(T, collections.Iterable): probdir += 'MultiT' if os.path.isdir(probdir): outlist = sorted([ int(name) for name in os.listdir(probdir) if name.isdigit() ]) else: outlist = [] outnum = outlist[-1] + 1 if outlist else 0 outputdir = probdir + '/' + str(outnum) + '/' probshow = 0 # Print final state probabilities to screen probout = 1 # Output probabilities to file mingap = 0 # Record the minimum spectral gap errchk = 0 # Error-checking on/off (for simulation accuracy) eps = 0.01 # Numerical error in normalization condition (1 - norm < eps) # Specify a QUBO (convert to Ising = True), or alpha, beta directly # (convert = False), and also specify the signs on the Ising Hamiltonian # terms (you can specify coefficients too for some problems if needed) isingConvert = 0 isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1} # Construct network Ising parameters neurons = nQubits # This is gamma, the appropriate weighting on the input vector # isingSigns['hz'] *= 1 - (len(hparams['inputState']) - # hparams['inputState'].count(0))/(2*neurons) # isingSigns['hz'] *= 1.0/(5*neurons) alpha = sp.array(hparams['inputState']) beta = sp.zeros((neurons,neurons)) delta = sp.array([]) # Construct the memory matrix according to a learning rule if hparams['learningRule'] == 'hebb': # Hebb rule isingSigns['hz'] *= 0.7 memMat = sp.matrix(memories).T beta = sp.triu(memMat*memMat.T)/float(neurons) elif hparams['learningRule'] == 'stork': # Storkey rule isingSigns['hz'] *= 0.15 Wm = sp.zeros((neurons,neurons)) for m, mem in enumerate(memories): Am = sp.outer(mem,mem) - sp.eye(neurons) Wm += (Am - Am*Wm - Wm*Am)/float(neurons) beta = sp.triu(Wm) elif hparams['learningRule'] == 'proj': isingSigns['hz'] *= 0.15 # Moore-Penrose pseudoinverse rule memMat = sp.matrix(memories).T beta = sp.triu(memMat * sp.linalg.pinv(memMat)) # Some outputs outputs = { 'nQubits': nQubits, 'learningRule': hparams['learningRule'], 'outdir': probdir, 'inputState': hparams['inputState'], 'memories': memories, 'answer': memories[0], 'annealTime': list(T) if isinstance(T, collections.Iterable) else T } ############################################################################ ######## All variables must be specified here, do NOT change the keys ###### ############################################################################ return { 'nQubits': nQubits, 'Q': None, 'T': T, 'dt': dt, 'outputdir': outputdir, 'errchk': errchk, 'eps': eps, 'isingConvert': isingConvert, 'isingSigns': isingSigns, 'outputs': outputs, 'alpha': alpha, 'beta': beta, 'delta': delta, 'eigdat': eigspecdat, 'eigplot': eigspecplot, 'eignum': eigspecnum, 'fiddat': fideldat, 'fidplot': fidelplot, 'fidnumstates': fidelnumstates, 'overlapdat': overlapdat, 'overlapplot': overlapplot, 'outdir': outputdir, 'binary': binary, 'progressout': progressout, 'probshow': probshow, 'probout': probout, 'mingap': mingap, 'stateoverlap': stateoverlap, 'hzscale': None, 'hzzscale': None, 'hxscale': None, 'solveMethod': solveMethod }