def project0(east, west, table, x, y): some = 0.000001 # handles a tedious div/zero error # compute the dist between the independent variables c = dist.dist(east, west, table.indep, table, False) for s in range(len(table.data[0])): row = [table.data[k][s] for k in range(len(table.data))] a = dist.dist(east, row, table.indep, table, False) b = dist.dist(west, row, table.indep, table, False) if a > c: x = []; y = []; return project0(east, row, table, x, y) if b > c: x = []; y = []; return project0(row, west, table, x, y) else: temp = (a**2 + c**2 - b**2) / (2*c + some) x += [str('%.3f'%temp)] y += [str('%.3f'%((a**2 -temp**2)**0.5))] return x, y
def rocvq(d, dmode='bin', qs=np.arange(1, 100000, 5000), good=1, scond=('cond1',), nulls=None): ''' scan over q in qs to find the best discrimination ''' nd = d.new() if scond == 'diff': pref = prefstim(d, good, ('cond1', 'cond2'), True) elif scond == 'man': stims = np.intersect1d(d['cond1.stims'], d['cond2.stims'], False) if type(good) == int: good = (good,) pref = (good, np.setdiff1d(stims, good)) else: pref = prefstim(d, good, scond, False) nd['qs'] = tuple(qs) for cond in d.keys(): if not cond.startswith('cond'): continue scla = sclasses(d[cond + '.stims'], pref) bvs = [] for i, q in enumerate(qs): dm = dist.dist(d[cond + '.evts'], dmode, q, nulls) r = roc(scla, dm, 100) nd[cond + '.roc%i' % i] = r bvs.append((r[:, 0] - r[:, 1]).max()) nd[cond + '.bv'] = tuple(bvs) return nd
def Kgrad_x(self,theta,x1,x2,d): """ The partial derivative of the covariance matrix with respect to x, given hyperparameters `theta`. **Parameters:** See :py:class:`pygp.covar.CovarianceFunction` """ # if we are not meant return zeros: if(d not in self.dimension_indices): return SP.zeros([x1.shape[0],x2.shape[0]]) rv = self.K(theta,x1,x2) # #1. get inputs and dimension x1, x2 = self._filter_input_dimensions(x1,x2) d -= self.dimension_indices.min() # #2. exponentialte parameters # V0 = SP.exp(2*theta[0]) # L = SP.exp(theta[1:1+self.n_dimensions])[d] L2 = SP.exp(2*theta[1:1+self.n_dimensions]) # # get squared distance in right dimension: # sqd = dist.sq_dist(x1[:,d]/L,x2[:,d]/L) # #3. calculate the whole covariance matrix: # rv = V0*SP.exp(-0.5*sqd) #4. get non-squared distance in right dimesnion: nsdist = -dist.dist(x1,x2)[:,:,d]/L2[d] return rv * nsdist
def greedyMatch(points1, points2): len1 = len(points1) len2 = len(points2) # get number of points numPoints = np.amin((len1, len2)) # form distance matrix D = np.zeros((len1, len2)) # add distances for row in range(len1): for col in range(len2): D[row, col] = dist(points1[row], points2[col]) # find matches ordered_pts1 = [] ordered_pts2 = [] for it in range(numPoints): min_dist = np.amin(D) # get indices of min_dist min_row, min_col = np.where(D == min_dist) # points1[min_row] matches points2[min_col] ordered_pts1.append(points1[min_row]) ordered_pts2.append(points2[min_col]) # set D along (min_row, min_col) to a really high number D[min_row, :] = 1000000000 * np.ones((1, len2)) D[:, min_col] = 1000000000 * np.ones((len1, 1)) # return matched points return ordered_pts1, ordered_pts2
def Kgrad_theta(self, theta, x1, i): # 2. exponentiate params: A = 2 * SP.exp(2 * theta) # 3. calculate similarity and score accross dimensions D = 1.0 * (dist.dist(x1, x1) == 0) K = D[:, :, i] * A[i] # derivative w.r.t. to amplitude return K
def distance_pruner(zlst): #Prunes cluster tree i.e. zlst with distance between their centroids if args['v'] > -1: sys.stderr.write("\n#Pruning data based on eucledian distance between clusters.\n") print zlst," #Old zlst before distprune" import dist z0 = zlst[0] pairs = [] for _i,i in enumerate(data[z0]): for _j,j in enumerate(data[z0]): if i != j: if dist.dist(i,j,z0,indep,nump) < 0.3: if [_i,_j] not in pairs and [_j,_i] not in pairs: pairs.append(['__'+str(_i+1),'__'+str(_j+1)]) def repaired(pairs): for i in pairs: for j in pairs: if i != j : if i[0] in j or i[1] in j: pairs = [list(set(i+j))]+\ [k for k in pairs if k not in [i,j]] return repaired(pairs) return pairs repairs = repaired(pairs) ps = [] for i in repairs: ps+=i for i in zlst[1:]: if i not in ps: repairs.append([i]) temp_row = {} for ind,p in enumerate(repairs): temp_row[ind] = [] for i in p: temp_row[ind] += data[i] col = colname[z0] for Z in zlst: reader.removeTable(Z) zlst = [None] for ind,value in enumerate(temp_row.values()): Z = '__'+str(ind+1) reader.makeTable(col,Z) for r in value: reader.addRow(r[:len(r)-1]+[ind],Z) zlst.append(Z) xy_lib.buildzero(zlst,'',args['e']) if args['v'] > -1: print zlst," #New zlst after distprune" return zlst
def K(self, theta, x1, x2=None): # get input data: x1, x2 = self._filter_input_dimensions(x1, x2) # 2. exponentiate params: A = SP.exp(2 * theta) # 3. calculate similarity and score accross dimensions D = 1.0 * (dist.dist(x1, x2) == 0) # dot product with A K = SP.dot(D, A) return K
def form_tree(points,node,all_points): global i print 'entering form tree ---' print "points",points pivot = points[0] print "pivot",pivot radius = np.max(dist.dist(points,pivot)) print "radius",radius f = plt.figure() ax = f.gca() plot_points(all_points,'ko',ax) plot_points(points,'ro',ax) circle(pivot,radius,ax) #plt.show() plt.savefig('knn%s.png' % str(i)) i += 1 node[0] = pivot node[1] = radius if len(points) <= __rmin__: node[2] = points return print "node",node idx = np.argmax(dist.dist(points,pivot)) furthest = points[idx,:] print "new pivot 1", furthest idx = np.argmax(dist.dist(points,furthest)) furthest2 = points[idx,:] print "new pivot 2", furthest2 dist1=dist.dist(points,furthest) dist2=dist.dist(points,furthest2) diffs = dist1-dist2 print "points",points print diffs p1 = points[diffs <= 0] p2 = points[diffs > 0] print "points 1", p1 print "points 2", p2 node[3][0] = new_node() # left child node[3][1] = new_node() # right child form_tree(p1,node[3][0],all_points) form_tree(p2,node[3][1],all_points)
def K(self, theta, x1, x2=None): # get input data: x1, x2 = self._filter_input_dimensions(x1, x2) # 2. exponentiate params: A = SP.exp(2 * theta[0]) # 3. calculate similarity and score accross dimensions D = dist.dist(x1, x2) # sum over the numer of zero distances entries accross dimensions K = (D == 0).sum(axis=2) # multiply with scale factor and done RV = A * K return RV
def form_tree(points, node, all_points): pivot = points[0] radius = np.max(dist.dist(points, pivot)) plot_circles(pivot, radius, points, all_points) node[0] = pivot node[1] = radius if len(points) <= __rmin__: node[2] = points return idx = np.argmax(dist.dist(points, pivot)) furthest = points[idx, :] idx = np.argmax(dist.dist(points, furthest)) furthest2 = points[idx, :] dist1 = dist.dist(points, furthest) dist2 = dist.dist(points, furthest2) diffs = dist1 - dist2 p1 = points[diffs <= 0] p2 = points[diffs > 0] node[3][0] = new_node() # left child node[3][1] = new_node() # right child form_tree(p1, node[3][0], all_points) form_tree(p2, node[3][1], all_points)
def K(self, theta, x1, x2=None, p=2): """ See covPeriodic.m from GPML K(x1, x2) = A * exp( -nll*sin^2 (||x1-x2||/p) ) """ # print inspect.stack()[1][3], x1.shape, x2 x1, x2 = self._filter_input_dimensions(x1, x2) A = SP.exp(theta[0]) nll = SP.exp(theta[1]) distance = dist.dist(x1, x2) / p sin_distance = numpy.sin(distance) rv = -nll * numpy.multiply(sin_distance, sin_distance) rv = A * SP.exp(rv) # This next line is kind of hacky. I get a (len, len, 1) # shape, so I just want to make it (len, len) # I should figure out the reason behind this in the first place, though rv.resize(rv.shape[:-1]) return rv
def nearest_edge(rects, *args): x,y = xy.extract(*args) class Result: min_dist = nearest_rect = nearest_edge = None result = Result() for rect in rects: edge = directions.west for midpoint in rect.midpoints(): d = dist.dist([x,y], midpoint) if result.min_dist == None or d < result.min_dist: result.min_dist = d result.nearest_rect = rect result.nearest_edge = edge edge += 1 return result
def dist_discrim_incond(d, mode='vdps', q=6000, nstim=None): """ d: IntIO, mode: DistMode, q: x -> ret: ICD(d[cond], mode, q) norm is a flag. If True, the inter-class distances are normalized by the expected inclass distance: """ dm = dist.dist(d['evts'], mode, q) dc = dist.classDM(dm, d['stims'], nstim) dca = np.zeros((len(dc), len(dc))) for i in range(len(dc)): for j in range(len(dc[i])): dca[i, j] = np.mean(dc[i][j]) if i != j: dca[j, i] = dca[i, j] return dca
def sc_dm(d, cond='cond1', dmode='ed_bin', q=20000, good=1, scond=('cond1',), doroc=100, nulls=None): ''' construct a pair (scla, dm) for d[cond] using the arguments good, scond for prefstim, and q, dmode, nulls for dist.dist. If doroc, use these to build a doroc-point ROC curve and return that. Otherwise return the tuple (scla, dm). ''' if scond == 'diff': pref = prefstim(d, good, ('cond1', 'cond2'), True) else: pref = prefstim(d, good, scond, False) scla = sclasses(d[cond]['stims'], pref) dm = dist.dist(d[cond + '.evts'], dmode, q, nulls) if doroc: return roc(scla, dm, doroc) else: return (scla, dm)
def Kgrad_theta(self, theta, x1, i, x2=None, p=2): """ The derivatives of the covariance matrix for each hyperparameter, respectively. **Parameters:** See :py:class:`pygp.covar.CovarianceFunction` """ x1, x2 = self._filter_input_dimensions(x1, x2) # 2. exponentiate params: A = SP.exp(2*theta[0]) nll = SP.exp(theta[1:1+self.n_dimensions]) # calculate sin^2 (|x1-x2|/p) sin_distance = numpy.sin(dist.dist(x1, x2) / p) sinsq = numpy.multiply(sin_distance, sin_distance) #3. calcualte withotu derivatives, need this anyway: derivative_A = SP.exp(-nll * sinsq) if i==0: return derivative_A else: return -A * sinsq * derivative_A
def pairwise_ROC(d, cond='cond1', mode='ed_bin', q=20000, nroc=100): """ d: CellExp, cond: CondName(d), mode: DistMode, q: DistQ, nroc: i -> ret: {(i,i) of Roc(nroc) Constructs every pairwise comparison between stimuli in d[cond] as a classify.roc ROC curve. Returns a dictionary of pairs (i, j) onto Rocs, where (i, j) are the two stimuli being separated. """ dm = dist.dist(d[cond]['evts'], mode, q) st = np.array(d[cond]['stims']) stn = _stimnames(d, cond, True) stpairs = clust.pairs(sorted(stn)) ret = {} for p in stpairs: s1 = np.nonzero(st == stn[p[0]])[0] s2 = np.nonzero(st == stn[p[1]])[0] ind = np.union1d(s1, s2) scla = np.array([(x in s1 or 2) for x in ind]) dm_p = dm[ind, :][:, ind] ret[p] = roc(scla, dm_p, nts=nroc) return ret
def Kgrad_theta(self, theta, x1, i): """ The derivatives of the covariance matrix for each hyperparameter, respectively. **Parameters:** See :py:class:`pygp.covar.CovarianceFunction` """ x1 = self._filter_x(x1) # 2. exponentiate params: V0 = SP.exp(2*theta[0]) L = SP.exp(theta[1:1+self.n_dimensions]) # calculate squared distance manually as we need to dissect this below x1_ = x1/L d = dist.dist(x1_,x1_) sqd = (d*d) sqdd = sqd.sum(axis=2) #3. calcualte withotu derivatives, need this anyway: rv0 = V0*SP.exp(-0.5*sqdd) if i==0: return 2*rv0 else: return rv0*sqd[:,:,i-1]
def distance(lot, et, q, meth): if et == None: return dist.dist(lot, meth, q) else: return dist.dist_toset(et, lot, meth, q)
def run(self, pars, out, messages): lot = pars['io']['evts'] out['dm'] = dist.dist(lot, pars['dmeth'], pars['q'], pars['nulls'])
def distthresh(cond, q, dmethod='bin', thresh=.9, nulls=None, trel=False): lot = cond['evts'] dists = dist.dist(lot, q, dmethod, nulls) ids = identdthresh(dists, thresh, trel) return cond.fuse({'evts': ids})
def dclust(cond, q=1, dmethod='ibl', nulls=None, cmeth='tree', nclust=16, cargs={}): dists = dist.dist(cond['evts'], dmethod, q, nulls) clsts = clustdm(cmeth, dists, nclust, cargs) return cond.fuse(cond.new(evts=clsts))
def neighbors(this, trainT): lst = {} for d in range(len(trainT['0'].data[0])): that = [trainT['0'].data[s][d] for s in range(len(trainT['0'].data))] lst[d] = dist.dist(this, that, range(len(trainT['0'].data)-1), trainT['0']) return sorted(lst.items(), key=lambda d:d[1])
def project0(east, west, table): print '+' some = 0.000001 # handles a tedious div/zero error c = dist.dist(east, west)