def load_data(primal=True, fold_index=0): X1 = np.random.rand(20, 300) X2 = np.random.rand(10, 200) dfold = [1, 2, 4, 5] tfold = [0, 6, 7] Y = np.random.randn(X1.shape[0], X2.shape[0]) Y = np.where(Y >= 0, 1., -1.) dtraininds = list(set(range(Y.shape[0])).difference(dfold)) ttraininds = list(set(range(Y.shape[1])).difference(tfold)) X1_train = X1[dtraininds, :] X2_train = X2[ttraininds, :] X1_test = X1[dfold, :] X2_test = X2[tfold, :] KT = np.mat(X2) KT = KT * KT.T KD = np.mat(X1) KD = KD * KD.T K1_train = KD[np.ix_(dtraininds, dtraininds)] K2_train = KT[np.ix_(ttraininds, ttraininds)] Y_train = Y[np.ix_(dtraininds, ttraininds)] K1_test = KD[np.ix_(dfold, dtraininds)] K2_test = KT[np.ix_(tfold, ttraininds)] Y_test = Y[np.ix_(dfold, tfold)] ssize = int(Y_train.shape[0] * Y_train.shape[1] * 0.25) rows = numpyrandom.random_integers(0, K1_train.shape[0] - 1, ssize) cols = numpyrandom.random_integers(0, K2_train.shape[0] - 1, ssize) ind = np.ravel_multi_index([rows, cols], (K1_train.shape[0], K2_train.shape[0])) Y_train = Y_train.ravel()[ind] Y_test = Y_test.ravel(order='F') if primal: return X1_train, X2_train, Y_train, rows, cols, X1_test, X2_test, Y_test else: return K1_train, K2_train, Y_train, rows, cols, K1_test, K2_test, Y_test
def load_data(primal=True, fold_index=0): X1 = np.random.rand(20, 300) X2 = np.random.rand(10, 200) dfold = [1,2,4,5] tfold = [0,6,7] Y = np.random.randn(X1.shape[0], X2.shape[0]) Y = np.where(Y>=0, 1., -1.) dtraininds = list(set(range(Y.shape[0])).difference(dfold)) ttraininds = list(set(range(Y.shape[1])).difference(tfold)) X1_train = X1[dtraininds, :] X2_train = X2[ttraininds, :] X1_test = X1[dfold,:] X2_test = X2[tfold,:] KT = np.mat(X2) KT = KT * KT.T KD = np.mat(X1) KD = KD * KD.T K1_train = KD[np.ix_(dtraininds, dtraininds)] K2_train = KT[np.ix_(ttraininds, ttraininds)] Y_train = Y[np.ix_(dtraininds, ttraininds)] K1_test = KD[np.ix_(dfold,dtraininds)] K2_test = KT[np.ix_(tfold,ttraininds)] Y_test = Y[np.ix_(dfold, tfold)] ssize = int(Y_train.shape[0]*Y_train.shape[1]*0.25) rows = numpyrandom.random_integers(0, K1_train.shape[0]-1, ssize) cols = numpyrandom.random_integers(0, K2_train.shape[0]-1, ssize) ind = np.ravel_multi_index([rows, cols], (K1_train.shape[0], K2_train.shape[0])) Y_train = Y_train.ravel()[ind] Y_test = Y_test.ravel(order='F') if primal: return X1_train, X2_train, Y_train, rows, cols, X1_test, X2_test, Y_test else: return K1_train, K2_train, Y_train, rows, cols, K1_test, K2_test, Y_test
def shuffle(bedtool, background,organism): """ Accepts a file path to a bed file and a background file Random intervals are generate from the intervals in the background file. An attempt is made to make the new random intervals the same size as the original intervals. One new interval is generated per interval in the bed file. If no background is provided, The pybedtool internal shuffle function is called and the entire genome is used as background """ A, B = bedtool,background if B is not None: rand_a = "" for a in A: a_len = a.length r = rand.random_integers(0,len(B)-1) # if cur A length is greater than random background inteval # the new randA is set to be same size as background inteval if a_len > B[r].length: rand_a += "\t".join(B[r][:4]) +"\t" + "\t".join(a[4:])+"\n" else: randstart = rand.random_integers(B[r].start,B[r].end - a_len) rand_a += "\t".join([B[r].chrom,str(randstart),str(randstart+a_len), B[r].name, "\t".join(a[4:])]) + "\n" rand_A = BedTool(rand_a,from_string=True) return rand_A else: return A.shuffle(genome=organism,chrom=True)
def displacement(parent): # generate two key positions; second position should be different than first p1 = random.random_integers(len(parent) - 2) while True: p2 = random.random_integers(len(parent) - 2) if p2 != p1: break keyPos = [p1, p2] keyPos.sort() # generate third key position different than the min keyPos while True: p3 = random.random_integers(len(parent)) - 1 if p3 != keyPos[0]: break offspring = [None for i in range(len(parent))] slicedP = parent[:keyPos[0]] + parent[keyPos[1] + 1:] # starting from p3 report the alleles between p1 and p2 for i in range(keyPos[1] - keyPos[0] + 1): offspring[(p3 + i) % len(parent)] = parent[keyPos[0] + i] startPos = (p3 + keyPos[1] - keyPos[0] + 1) % len(parent) # complete the offspring with alleles from the slicedP for i in range(len(slicedP)): offspring[(startPos + i) % len(parent)] = slicedP[i] return offspring
def Evolve_DE(self): for i in scipy.arange(self.npop1): # para cada individuo da populacao # gera trial vector usado para perturbar individuo atual (indice i) # a partir de 3 individuos escolhidos aleatoriamente na populacao e # cujos indices sejam distintos e diferentes de i invalido = True while invalido: j = random_integers(0, self.npop1 - 1, 3) invalido = (i in j) invalido = invalido or (j[0] == j[1]) invalido = invalido or (j[1] == j[2]) invalido = invalido or (j[2] == j[0]) # trial vector a partir da mutacao de um alvo u = self.pop1[j[0]] + self.beta * (self.pop1[j[1]] - self.pop1[j[2]]) # gera por crossover solucao candidata c = self.pop1[i].copy() # seleciona indices para crossover # garantindo que ocorra crossover em # pelo menos uma vez j = random_integers(0, self.pop1.shape[1] - 1) for k in scipy.arange(self.pop1.shape[1]): if (scipy.rand() < self.pr) or (k == j): c[k] = u[k] ans, c = self.resolve_desafio(c) c_fit = self.avalia_aptidao1(ans) # leva para proxima geracao quem tiver melhor fitness if (c_fit > self.fit1[i]): self.pop1[i] = c self.fit1[i] = c_fit self.ans1[i] = ans
def uniform_crossover(parents, len_items): parents_crossover = [] while len(parents) > 0: first_person = parents.pop(random.random_integers(0, len(parents) - 1)) second_person = parents.pop(random.random_integers(0, len(parents) - 1)) if random.rand() > 0.6: pattern = random.random_integers(0, 1, len_items) for i, cross in enumerate(pattern): if cross == 1: r = first_person.backpack[i] first_person.backpack[i] = second_person.backpack[i] second_person.backpack[i] = r alfa = random.rand() new_first_deviation = alfa * np.array(first_person.standard_deviation) + (1 - alfa) * np.array(second_person.standard_deviation) new_second_deviation = alfa * np.array(second_person.standard_deviation) + (1 - alfa) * np.array(first_person.standard_deviation) first_person.standard_deviation = new_first_deviation second_person.standard_deviation = new_second_deviation parents_crossover.append(first_person) parents_crossover.append(second_person) return parents_crossover
def test_002(self): vlen = 200 N = 100000 _n = N / vlen refdata = random_integers(0, 1, N) data = random_integers(0, 1, N) ref = numpy.array([0] * (vlen / 2)) for x in range(N / 2, N): ref[x % (vlen / 2)] += 1 if refdata[x] != data[x] else 0 vlen = concatenate([[vlen] * (_n / 2), [vlen / 2] * (_n)]) src0 = gr.vector_source_b(refdata.tolist()) src1 = gr.vector_source_b(data.tolist()) src2 = gr.vector_source_i(vlen.tolist()) uut = ofdm.bit_position_dependent_BER("test") self.tb.connect(src0, (uut, 0)) self.tb.connect(src1, (uut, 1)) self.tb.connect(src2, (uut, 2)) if os.path.exists("test_000.uint"): os.remove("test_000.uint") self.assert_(not os.path.exists("test_000.uint")) self.tb.run() ret = numpy.array(uut.get_cntr_vec()) self.assert_((ret == ref).all()) self.assert_(os.path.exists("test_000.uint"))
def test_001(self): vlen = 256 N = 100000 refdata = random_integers(0, 1, N) data = random_integers(0, 1, N) ref = numpy.array([0] * vlen) for x in range(len(data)): ref[x % vlen] += 1 if refdata[x] != data[x] else 0 src0 = gr.vector_source_b(refdata.tolist()) src1 = gr.vector_source_b(data.tolist()) src2 = gr.vector_source_i([vlen] * N) uut = ofdm.bit_position_dependent_BER("test") self.tb.connect(src0, (uut, 0)) self.tb.connect(src1, (uut, 1)) self.tb.connect(src2, (uut, 2)) self.tb.run() ret = numpy.array(uut.get_cntr_vec()) self.assert_((ret == ref).all())
def order2x(parent1, parent2): # verify that the parents have same length assert len(parent1) == len(parent2) numGenes = len(parent1) # generate number of key positions numKP = random.random_integers(numGenes - 1) # generate key positions keyPositions = [] key = 0 while key < numKP: possibleKey = random.random_integers(numGenes - 1) if possibleKey not in keyPositions: keyPositions.append(possibleKey) key += 1 # sort key positions keyPositions.sort() # generate first offspring offspring1 = offGeneration(keyPositions, parent1, parent2) # generate second offspring offspring2 = offGeneration(keyPositions, parent2, parent1) return offspring1, offspring2
def createHeteroAPD(tissueHeight, APDrefernce, PatchDiam, PatchAPDref, APDfile): """ Write a set of tissueHeight^2 APD values to APDfile with a patch of different APD in the middle """ # Create a square array to represent the tissue setAPD = np.zeros((tissueHeight, tissueHeight)) # Identify where the patch will start patchStart = np.floor(tissueHeight / 2) - 1 # Set the values in the patch to NaN to make them easy to find for i in np.arange(patchStart, patchStart + PatchDiam, 1): for j in np.arange(patchStart, patchStart + PatchDiam, 1): setAPD[int(i), int(j)] = np.NaN # Flatten the array so the indices match up to ResList's (a flat array) setAPD = np.reshape(setAPD, (-1, 1)) for i in range(len(setAPD)): if (setAPD[i, 0] == np.NaN): # in the patch setAPD[i] = npr.random_integers(PatchAPDref - 5, PatchAPDref + 5) else: setAPD[i] = npr.random_integers(APDrefernce - 5, APDrefernce + 5) with open(APDfile, 'w') as file: for apd in setAPD: theString = "{!s}\n" file.write(theString.format(int(apd[0]))) return
def displacement(parent): # generate two key positions; second position should be different than first p1 = random.random_integers(len(parent)-2) while True: p2 = random.random_integers(len(parent)-2) if p2 != p1: break keyPos = [p1,p2] keyPos.sort() # generate third key position different than the min keyPos while True: p3 = random.random_integers(len(parent))-1 if p3 != keyPos[0]: break offspring = [None for i in range(len(parent))] slicedP = parent[:keyPos[0]]+parent[keyPos[1]+1:] # starting from p3 report the alleles between p1 and p2 for i in range(keyPos[1]-keyPos[0]+1): offspring[(p3+i)%len(parent)] = parent[keyPos[0]+i] startPos = (p3+keyPos[1]-keyPos[0]+1)%len(parent) # complete the offspring with alleles from the slicedP for i in range(len(slicedP)): offspring[(startPos+i)%len(parent)] = slicedP[i] return offspring
def gera_individuo(self): l = [] l.append(random_integers(self.arg_lim[0][0],self.arg_lim[0][1])) l.append(self.arg_lim[1][0]+ (self.arg_lim[1][1] - self.arg_lim[1][0])*rand()) l.append(self.arg_lim[2][0]+ (self.arg_lim[2][1] - self.arg_lim[2][0])*rand()) l.append(random_integers(self.arg_lim[3][0],self.arg_lim[3][1])) return np.array(l)
def test_001( self ): vlen = 256 N = 100000 refdata = random_integers(0, 1, N) data = random_integers(0, 1, N) ref = numpy.array([0]*vlen) for x in range(len(data)): ref[x%vlen] += 1 if refdata[x] != data[x] else 0 src0 = gr.vector_source_b( refdata.tolist() ) src1 = gr.vector_source_b( data.tolist() ) src2 = gr.vector_source_i( [vlen]*N ) uut = ofdm.bit_position_dependent_BER( "test" ) self.tb.connect( src0, ( uut, 0 ) ) self.tb.connect( src1, ( uut, 1 ) ) self.tb.connect( src2, ( uut, 2 ) ) self.tb.run() ret = numpy.array( uut.get_cntr_vec() ) self.assert_( (ret==ref).all() )
def test_003( self ): vlen = 200 N = 100000 _n = N / vlen refdata = random_integers(0, 1, N) data = random_integers(0, 1, N) vlen = concatenate( [ [vlen]*(_n/2),[vlen/2]*(_n/2),[vlen/4]*(_n)] ) src0 = gr.vector_source_b( refdata.tolist() ) src1 = gr.vector_source_b( data.tolist() ) src2 = gr.vector_source_i( vlen.tolist() ) uut = ofdm.bit_position_dependent_BER( "test" ) self.tb.connect( src0, ( uut, 0 ) ) self.tb.connect( src1, ( uut, 1 ) ) self.tb.connect( src2, ( uut, 2 ) ) if os.path.exists("test_000.uint"): os.remove("test_000.uint") if os.path.exists("test_001.uint"): os.remove("test_001.uint") self.assert_( not os.path.exists("test_000.uint") ) self.assert_( not os.path.exists("test_001.uint") ) self.tb.run() self.assert_( os.path.exists("test_000.uint")) self.assert_( os.path.exists("test_001.uint"))
def el_distor(im, kernel_dim, Sigma, alpha): out = np.zeros(im.shape) displace_x = np.array([[random_integers(-1, 1) for x in xrange(im.shape[0])] \ for y in xrange(im.shape[1])]) * alpha displace_y = np.array([[random_integers(-1, 1) for x in xrange(im.shape[0])] \ for y in xrange(im.shape[1])]) * alpha kernel = create_gaussian_kernel(kernel_dim, Sigma) #kernel = cv2.getGaussianKernel(kernel_dim,Sigma) displace_x = convolve2d(displace_x, kernel) displace_y = convolve2d(displace_y, kernel) for row in xrange(im.shape[1]): for col in xrange(im.shape[0]): low_x = row + int(math.floor(displace_x[row, col])) high_x = row + int(math.ceil(displace_x[row, col])) low_y = col + int(math.floor(displace_y[row, col])) high_y = col + int(math.ceil(displace_y[row, col])) if high_x >= im.shape[1] -1 or high_y >= im.shape[0] - 1: continue res = im[low_x, low_y]/4 + im[low_x, high_y]/4 + \ im[high_x, low_y]/4 + im[high_x, high_y]/4 out[row, col] = res n,m = out.shape out = out.reshape(n*m,) return out
def test_sample_box(): """Test that `sample_box` generates the proper number of samples within the correct bounds. """ # Generate some random bounds bounds = [] bounds_count = 0 num_dimensions = random_integers(2, 10) while bounds_count < num_dimensions: candidate_bound = random_sample(2) low, high = candidate_bound if low > high: candidate_bound = [high, low] bounds.append(candidate_bound) bounds_count += 1 num_samples = random_integers(100) points = sample_box(bounds, num_samples) assert len(points) == num_samples results = np.empty([num_samples, num_dimensions]) for counter, point in enumerate(points): for axis, value in enumerate(point): low = bounds[axis][0] high = bounds[axis][1] results[counter, axis] = (low <= value <= high) assert results.all()
def corrupt_image(img, MAR_prob=0, min_rects=0, max_rects=0, min_width=0, max_width=0): new_img = img.copy() mask = np.zeros(img.shape[0:2], dtype=np.bool) if MAR_prob > 0: mask[(random_sample(mask.shape) < MAR_prob)] = True if max_rects > 0 and max_width > 0: h, w = mask.shape num_rects = random_integers(min_rects, max_rects) for i in range(num_rects): px1 = random_integers(0, w - min(max(min_width, 1), w)) py1 = random_integers(0, h - min(max(min_width, 1), h)) px2 = px1 + (min_width - 1) + random_integers( 0, max(min(w - px1 - min_width, max_width - min_width), 0)) py2 = py1 + (min_width - 1) + random_integers( 0, max(min(h - py1 - min_width, max_width - min_width), 0)) if px1 <= px2 and py1 <= py2: mask[py1:py2, px1:px2] = True else: # One of the sides has length 0, so we should remove any pixels4 pass if len(new_img.shape) == 2: new_img[mask] = 0 else: new_img[mask, :] = 0 return (new_img, 1.0 * mask)
def generate_data(start_index=START_INDEX, num_users=NUM_USERS, num_rows=NUM_ROWS): users = random_integers(start_index, start_index+num_users, num_rows) activity = random_integers(0, len(MESSAGE_TYPES) - 1, num_rows) activity_name = [MESSAGE_TYPES[i] for i in activity] user_activity = zip(users, activity_name) return user_activity
def order2x(parent1, parent2): # verify that the parents have same length assert(len(parent1)==len(parent2)) numGenes = len(parent1) # generate number of key positions numKP = random.random_integers(numGenes-1) # generate key positions keyPositions = [] key = 0 while key < numKP: possibleKey = random.random_integers(numGenes-1) if possibleKey not in keyPositions: keyPositions.append(possibleKey) key += 1 # sort key positions keyPositions.sort() # generate first offspring offspring1 = offGeneration(keyPositions, parent1, parent2) # generate second offspring offspring2 = offGeneration(keyPositions, parent2, parent1) return offspring1, offspring2
def random_crop(image, normal, size): decal = [image.shape[0]-size[0],image.shape[1]-size[1]]; #tirer decalage aleatoire decal_alea = [random_integers(0,decal[0]),random_integers(0,decal[1])] crop_img = image[decal_alea[0]:decal_alea[0]+size[0], decal_alea[1]:decal_alea[1]+size[1]] crop_normal = normal[decal_alea[0]:decal_alea[0]+size[0], decal_alea[1]:decal_alea[1]+size[1]] return crop_img,crop_normal
def getPoly(order, sym=sympy.symbols('x')): roots = random_integers(-5,5, order) leadCoeff = random_integers(1,5) poly = sympy.S(leadCoeff) for root in roots: poly *= sym-root return sympy.Poly(poly.expand())
def getPoly(order, sym=sympy.symbols('x')): roots = random_integers(-5, 5, order) leadCoeff = random_integers(1, 5) poly = sympy.S(leadCoeff) for root in roots: poly *= sym - root return sympy.Poly(poly.expand())
def MangleByte(packet): index = random_integers(0,packet.size-1) new_byte = random_integers(0,255) while new_byte == packet[index]: new_byte = random_integers(0,255) packet[index] = new_byte return packet
def mutate_packet(pkt, state, lan): radiohead = pkt.getlayer(RadioTap2) mutateDot11Body = pkt.getlayer(Dot11) mutateDot11Body.proto = np.random_integers(0, 256**2 - 1, 1)[0] mutateDot11Body.FCfield = np.random_integers(0, 256 - 1, 1)[0] mutateDot11Body.ID = np.random_integers(0, 256**2 - 1, 1)[0] mutateDot11Body.SC = np.random_integers(0, 256**2 - 1, 1)[0] returnPkt = None if (state == 0): mutatePrbElt = np.bytes(np.random_integers(0, 1514 - 424, 1)[0]) returnPkt = radiohead / mutateDot11Body / mutatePrbElt if (state == 1): mutateAuthBody = pkt.getlayer(Dot11Auth) mutateAuthBody.algo = np.random_integers(0, 256**2 - 1, 1)[0] mutateAuthBody.sequm = np.random_integers(0, 256**2 - 1, 1)[0] mutateAuthBody.status = np.random_integers(0, 256**2 - 1, 1)[0] # mutateAuthElt = np.bytes(1514 - 54) #not necessary returnPkt = radiohead / mutateDot11Body / mutateAuthBody if (state == 2): mutateAssoBody = pkt.getlayer(Dot11AssoReq) mutateAssoBody.cap = np.random_integers(0, 256**2 - 1, 1)[0] mutateAssoElt = np.bytes(np.random_integers(0, 1514 - 424, 1)[0]) returnPkt = radiohead / mutateDot11Body / mutateAssoBody / mutateAssoElt sendp(returnPkt, iface=lan, verbose=3) mutateList.append(returnPkt) return mutateList
def Fragment(packet): index = random_integers(1,packet.size-1) if 1 == random_integers(0,1): packet = packet[:index] else: packet = packet[index:] return packet
def Evolve_DE(self): for i in scipy.arange(self.npop1): # para cada individuo da populacao # gera trial vector usado para perturbar individuo atual (indice i) # a partir de 3 individuos escolhidos aleatoriamente na populacao e # cujos indices sejam distintos e diferentes de i invalido = True while invalido: j = random_integers(0,self.npop1-1,3) invalido = (i in j) invalido = invalido or (j[0] == j[1]) invalido = invalido or (j[1] == j[2]) invalido = invalido or (j[2] == j[0]) # trial vector a partir da mutacao de um alvo u = self.pop1[j[0]] + self.beta*(self.pop1[j[1]] - self.pop1[j[2]]) # gera por crossover solucao candidata c = self.pop1[i].copy() # seleciona indices para crossover # garantindo que ocorra crossover em # pelo menos uma vez j = random_integers(0,self.pop1.shape[1]-1) for k in scipy.arange(self.pop1.shape[1]): if (scipy.rand() < self.pr) or (k == j): c[k] = u[k] ans,c = self.resolve_desafio(c) c_fit = self.avalia_aptidao1(ans) # leva para proxima geracao quem tiver melhor fitness if (c_fit > self.fit1[i]): self.pop1[i] = c self.fit1[i] = c_fit self.ans1[i] = ans
def create_test_set(self): ''' randomly selects test sentences from positive and negative bags and making a uniform distribution of test sentences ''' from numpy import random as np_random count = self.counts["test set"] // 2 while (count != 0): index = np_random.random_integers(low=0, high=len(self.positive_bag) - 1) self.positve_test_bag.append(self.positive_bag.pop(index)) index = np_random.random_integers(low=0, high=len(self.negative_bag) - 1) self.negative_test_bag.append(self.negative_bag.pop(index)) count -= 1 self.logger.info("test sentences selected") self.logger.info( "Total sentences for testing : " + str(len(self.positve_test_bag) + len(self.negative_test_bag))) self.logger.info("positive sentences for testing : " + str(len(self.positve_test_bag))) self.logger.info("negative sentences for testing : " + str(len(self.negative_test_bag))) self.counts["positive sentences"] = len(self.positive_bag) self.counts["negative sentences"] = len(self.negative_bag) self.counts["total sentences"] = len(self.positive_bag) + len( self.negative_bag)
def __call__(self, X, n = 10, x0 = None): ''' Parameters ---------- n : required number of start points, if None, defaults to 10 start points x0 : 2-dimensional numpy.array containing #rows equal to number of explicitly defined start points and #columns equal to dimension of the feature space points X : 2-dimensional numpy.array containing #rows equal to number of data points and #columns equal to dimension of the data points ''' self._Xi = X if n is None or n == 0: n = 10 if x0 is not None: num_x0_pts = x0.shape[0] else: return self._Xi[random_integers(0, self._Xi.shape[0] - 1, n),:] if num_x0_pts == n: return x0 elif num_x0_pts < n: return vstack((x0,self._Xi[random_integers(0, self._Xi.shape[0] - 1, n - num_x0_pts),:])) else: #num_x0_pts > n return x0[sample(xrange(0,num_x0_pts), n),:]
def GIBBSSAMPLER(DNA, K, T, N): MOTIF = [] randn = random.random_integers(0, len(DNA[0]), T) countmatrix = array([[1.0]*K]*4) for i in range(T): index = randn[i] MOTIF.append(DNA[i][index:index+K]) countmatrix = UPDATEPROFILE(countmatrix, MOTIF[-1]) bestscore = 1000 BESTGROUP = [] for i in range(N): randdna = random.random_integers(0, T-1) countmatrix = UPDATEPROFILE2(countmatrix, MOTIF[randdna]) profile = countmatrix/(T-1) probs = FINDPROBS(DNA[randdna], K, profile) probs = probs/sum(probs) randi = random.choice(range(len(probs)), p = probs) motifi = DNA[randdna][randi:randi+K] MOTIF[randdna] = motifi countmatrix = UPDATEPROFILE(countmatrix, motifi) profile = countmatrix/T concensus = FINDCONCENSUS(profile) curscore = DISTANCEPATTERNSTRING(concensus, MOTIF) if curscore < bestscore: BESTGROUP = deepcopy(MOTIF) bestscore = curscore return BESTGROUP, bestscore
def test_003(self): vlen = 200 N = 100000 _n = N / vlen refdata = random_integers(0, 1, N) data = random_integers(0, 1, N) vlen = concatenate([[vlen] * (_n / 2), [vlen / 2] * (_n / 2), [vlen / 4] * (_n)]) src0 = gr.vector_source_b(refdata.tolist()) src1 = gr.vector_source_b(data.tolist()) src2 = gr.vector_source_i(vlen.tolist()) uut = ofdm.bit_position_dependent_BER("test") self.tb.connect(src0, (uut, 0)) self.tb.connect(src1, (uut, 1)) self.tb.connect(src2, (uut, 2)) if os.path.exists("test_000.uint"): os.remove("test_000.uint") if os.path.exists("test_001.uint"): os.remove("test_001.uint") self.assert_(not os.path.exists("test_000.uint")) self.assert_(not os.path.exists("test_001.uint")) self.tb.run() self.assert_(os.path.exists("test_000.uint")) self.assert_(os.path.exists("test_001.uint"))
def mutate_simple(ind): "just blast one spot" mutated = ind.copy() row = nprand.random_integers(0, ind.data.shape[0] - 1) col = nprand.random_integers(0, ind.data.shape[1] - 1) mutated.data[row, col] = nprand.random() mutated.cost = -1 return mutated
def __gera_s0(self): l = [] l.append(random_integers(self.arg_lim[0][0],self.arg_lim[0][1])) l.append(random_integers(self.arg_lim[1][0],self.arg_lim[1][1])) l.append(self.arg_lim[2][0]+ (self.arg_lim[2][1] - self.arg_lim[2][0])*rand()) l.append(random_integers(self.arg_lim[3][0],self.arg_lim[3][1])) return l
def N(self): if random.sample() > .5: return [self.nouns[random.random_integers(0, len(self.nouns) - 1)]] else: return [self.THE] + [ self.nouns[random.random_integers(0, len(self.nouns) - 1)] ]
def random_cl_key(self): """Returns a random classifier key. """ a, b = random_integers(0, 100), random_integers(0, 100) # make sure that b > a if a > b: return (b, a) return (a, b)
def random_terrain(): """Return a randomized terrain""" answer = np.ones((I_MAX+1, J_MAX+1))*100 for i, j in zip(nprand.random_integers(0, I_MAX, 8), nprand.random_integers(0, J_MAX, 8)): answer[i, j] = nprand.random_integers(2, 4)*100 answer[0, 0] += 1 return answer
def _rand_sparse(m, n, density): # check parameters here nnz = max( min( int(m*n*density), m*n), 0) row = random_integers(low=0, high=m-1, size=nnz) col = random_integers(low=0, high=n-1, size=nnz) data = ones(nnz, dtype='int8') # duplicate (i,j) entries will be summed together return csr_matrix( (data,(row,col)),shape=(m,n))
def generate_data(start_index=START_INDEX, num_users=NUM_USERS, num_rows=NUM_ROWS): users = random_integers(start_index, start_index + num_users, num_rows) activity = random_integers(0, len(MESSAGE_TYPES) - 1, num_rows) activity_name = [MESSAGE_TYPES[i] for i in activity] user_activity = zip(users, activity_name) return user_activity
def new_food(terminal, body_locs, edge_x, edge_y): valid = False while not valid: food_loc = (random_integers(edge_y[0] + 1, edge_y[1] - 1), random_integers( random_integers(edge_x[0] + 1, edge_x[1] - 1))) valid = food_loc not in body_locs return food_loc
def _rand_sparse(m, n, density): # check parameters here nnz = max(min(int(m * n * density), m * n), 0) row = random_integers(low=0, high=m - 1, size=nnz) col = random_integers(low=0, high=n - 1, size=nnz) data = ones(nnz, dtype='int8') # duplicate (i,j) entries will be summed together return csr_matrix((data, (row, col)), shape=(m, n))
def successors3(self): successors = [] nc = copy.deepcopy(self.path) si = random.random_integers(1, len(self.path)-1) ti = random.random_integers(1, len(self.path)-1) nc[si], nc[ti] = nc[ti], nc[si] successors.append(TravelingSalesmanProblem(nc)) return successors
def gera_individuo(self): l = [] l.append(random_integers(self.arg_lim[0][0], self.arg_lim[0][1])) l.append(self.arg_lim[1][0] + (self.arg_lim[1][1] - self.arg_lim[1][0]) * rand()) l.append(self.arg_lim[2][0] + (self.arg_lim[2][1] - self.arg_lim[2][0]) * rand()) l.append(random_integers(self.arg_lim[3][0], self.arg_lim[3][1])) return np.array(l)
def random_crop(image, normal, size): decal = [image.shape[0] - size[0], image.shape[1] - size[1]] #tirer decalage aleatoire decal_alea = [random_integers(0, decal[0]), random_integers(0, decal[1])] crop_img = image[decal_alea[0]:decal_alea[0] + size[0], decal_alea[1]:decal_alea[1] + size[1]] crop_normal = normal[decal_alea[0]:decal_alea[0] + size[0], decal_alea[1]:decal_alea[1] + size[1]] return crop_img, crop_normal
def myNew(): global n, an q = random.random_integers(10) if random.random() > 0.2: an += q print('mtn {} -A {}'.format(q, random.random_integers(100)), file=f) else: n += q print('mtn {}'.format(q), file=f)
def __gera_s0(self): l = [] l.append(random_integers(self.arg_lim[0][0], self.arg_lim[0][1])) l.append(random_integers(self.arg_lim[1][0], self.arg_lim[1][1])) l.append(self.arg_lim[2][0] + (self.arg_lim[2][1] - self.arg_lim[2][0]) * rand()) l.append(random_integers(self.arg_lim[3][0], self.arg_lim[3][1])) return l
def elastic_distortion(image, kernel_dim=21, sigma=6, alpha=30, negated=True): """ This method performs elastic transformations on an image by convolving with a gaussian kernel. :param image: a numpy nd array :kernel_dim: dimension(1-D) of the gaussian kernel :param sigma: standard deviation of the kernel :param alpha: a multiplicative factor for image after convolution :param negated: a flag indicating whether the image is negated or not :returns: a nd array transformed image """ # check if the image is a negated one if not negated: image = 255 - image # check if kernel dimesnion is odd if kernel_dim % 2 == 0: raise ValueError("Kernel dimension should be odd") # create an empty image result = np.zeros(image.shape) # create random displacement fields displacement_field_x = np.array([[random_integers(-1, 1) for x in xrange(image.shape[0])] \ for y in xrange(image.shape[1])]) * alpha displacement_field_y = np.array([[random_integers(-1, 1) for x in xrange(image.shape[0])] \ for y in xrange(image.shape[1])]) * alpha # create the gaussian kernel kernel = create_2d_gaussian(kernel_dim, sigma) # convolve the fields with the gaussian kernel displacement_field_x = convolve2d(displacement_field_x, kernel) displacement_field_y = convolve2d(displacement_field_y, kernel) # make the distortrd image by averaging each pixel value to the neighbouring # four pixels based on displacement fields for row in xrange(image.shape[1]): for col in xrange(image.shape[0]): low_ii = row + int(math.floor(displacement_field_x[row, col])) high_ii = row + int(math.ceil(displacement_field_x[row, col])) low_jj = col + int(math.floor(displacement_field_y[row, col])) high_jj = col + int(math.ceil(displacement_field_y[row, col])) if low_ii < 0 or low_jj < 0 or high_ii >= image.shape[1] -1 \ or high_jj >= image.shape[0] - 1: continue res = image[low_ii, low_jj]/4 + image[low_ii, high_jj]/4 + \ image[high_ii, low_jj]/4 + image[high_ii, high_jj]/4 result[row, col] = res return result
def test_reference_3d(self): random.seed(42) im0 = random.random_integers(0, high=127, size=(25, 25, 3)).astype('uint16') im1 = random.random_integers(0, high=127, size=(25, 25, 3)).astype('uint16') imgIn = ImagesLoader(self.sc).fromArrays([im0, im1]) ref = Register.reference(imgIn) assert (allclose(ref, (im0 + im1) / 2))
def mutate_reorder(ind): "reorder rectangles " mutated = ind.copy() for i in xrange(3): row1 = nprand.random_integers(0, ind.data.shape[0] - 1) row2 = nprand.random_integers(0, ind.data.shape[0] - 1) mutated.data[row1], mutated.data[row2] =\ mutated.data[row2].copy(), mutated.data[row1].copy() mutated.cost = -1 return mutated
def random_pick_attr_splits(node, config, attr_index): samples = node.samples ind_middle = random.random_integers(0, len(samples)-2 ) ind_a = random.random_integers(0, ind_middle ) ind_b = random.random_integers(ind_middle+1, len(samples)-1 ) # print "a:",ind_a, samples[ind_a][attr_index] # print "b:",ind_b, samples[ind_b][attr_index] spliter = (samples[ind_a][attr_index] + samples[ind_b][attr_index])*0.5 return spliter
def resolve_desafio(self,x): if not self.arg_lim[0][0] <= x[0] <= self.arg_lim[0][1]: x[0] = random_integers(self.arg_lim[0][0],self.arg_lim[0][1]) if not self.arg_lim[1][0] <= x[1] <= self.arg_lim[1][1]: x[1] = self.arg_lim[1][0]+ (self.arg_lim[1][1] - self.arg_lim[1][0])*rand() if not self.arg_lim[2][0] <= x[2] <= self.arg_lim[2][1]: x[2] = self.arg_lim[2][0]+ (self.arg_lim[2][1] - self.arg_lim[2][0])*rand() if not self.arg_lim[3][0] <= x[3] <= self.arg_lim[3][1]: x[0] = random_integers(self.arg_lim[3][0],self.arg_lim[3][1]) return (self.fc(x),x)
def new_config(self,batch): """ Randomly generate a new configuration """ x_index,y_index=random.random_integers(0,self.Nx-1,size=batch),random.random_integers(0,self.Ny-1,size=batch) x=(2 * random.rand(batch)) thetaprime,phiprime=np.arccos(1-x),self.delta_phi*(2*random.rand(batch)) layer=np.round(np.random.rand(batch)) # thetaprime,phiprime=2*random.rand(batch),self.delta_phi*(2*random.rand(batch)-1) return np.vstack([x_index,y_index]).transpose(), np.vstack([thetaprime,phiprime]).transpose(),layer.transpose()
def add_noise(imagename,changed_pixels=10000): # Read the image file imagename. # Multiply by 1. / 255 to change the values so that they are floating point # numbers ranging from 0 to 1. IM = imread(imagename, flatten=True) * (1. / 255) IM_x, IM_y = IM.shape for lost in xrange(changed_pixels): x_,y_ = random_integers(1,IM_x-2), random_integers(1,IM_y-2) val = .25*randn() + .5 IM[x_,y_] = max( min(val+ IM[x_,y_],1.), 0.)
def randomPix(im): """Switch the value of two random pixels""" x1 = random.random_integers(0, im.size[0] - 1) x2 = random.random_integers(0, im.size[0] - 1) y1 = random.random_integers(0, im.size[1] - 1) y2 = random.random_integers(0, im.size[1] - 1) aux = im.getpixel((x1, y1)) im.putpixel((x1, y1), im.getpixel((x2, y2))) im.putpixel((x2, y2), aux) return 1
def seq1(L): a = random_integers(20) # d = random_integers(15) * (-1+np.random.binomial(1,0.5)*2) d = random_integers(15) seq = [str(a)] for i in range(1, L): seq.append(str(a + i * d)) return seq
def avalia_aptidao(self,x): if not self.arg_lim[0][0] <= x[0] <= self.arg_lim[0][1]: x[0] = random_integers(self.arg_lim[0][0],self.arg_lim[0][1]) if not self.arg_lim[1][0] <= x[1] <= self.arg_lim[1][1]: x[1] = self.arg_lim[1][0]+ (self.arg_lim[1][1] - self.arg_lim[1][0])*rand() if not self.arg_lim[2][0] <= x[2] <= self.arg_lim[2][1]: x[2] = self.arg_lim[2][0]+ (self.arg_lim[2][1] - self.arg_lim[2][0])*rand() if not self.arg_lim[3][0] <= x[3] <= self.arg_lim[3][1]: x[3] = random_integers(self.arg_lim[3][0],self.arg_lim[3][1]) return (self.fitness_func(x),x)
def SaltAndPepper(src, percetage): NoiseImg = src NoiseNum = int(percetage * src.shape[0] * src.shape[1]) for i in range(NoiseNum): randX = random.random_integers(0, src.shape[0] - 1) randY = random.random_integers(0, src.shape[1] - 1) if random.random_integers(0, 1) == 0: NoiseImg[randX, randY] = 0 else: NoiseImg[randX, randY] = 255 return NoiseImg
def getcartaddinfo(inventoryInfo,k = 500): cartList = [] n = len(set(inventoryInfo["beerId"])) #get quantities for each beers when added to cart for i in range(k): cartDict = {} userId = random.random_integers(0,k) beerId = inventoryInfo.loc[random.random_integers(0,n),"beerId"] quantity = [1,2,3,4,5,6][random.choice(6,1,p=[0.7,0.2,0.01,0.02,0.01,0.06])] cartDict["userId"] = userId cartDict["beerId"] = beerId cartDict["quantity"] = quantity cartList.append(cartDict) return(DataFrame(cartList))
def getcheckoutinfo(inventoryInfo,k = 100): checkoutList = [] n = len(set(inventoryInfo["beerId"])) #get checkout quantities for each beers for i in range(k): checkoutDict = {} userId = random.random_integers(0,k) beerId = inventoryInfo.loc[random.random_integers(0,n),"beerId"] quantity = [1,2,3,4,5,6][random.choice(6,1,p=[0.5,0.3,0.02,0.04,0.04,0.1])] checkoutDict["userId"] = userId checkoutDict["beerId"] = beerId checkoutDict["quantity"] = quantity checkoutList.append(checkoutDict) return(DataFrame(checkoutList))