def transitionAndWeight(states, y, parameters, t): Nx = states.shape[0] Ntheta = states.shape[2] weights = zeros((Nx, Ntheta)) newstates = zeros_like(states) poissonparameters1 = parameters[6, :] * parameters[4, :] * (parameters[2, :]**2) / parameters[3, :] poissonparameters2 = (1 - parameters[6, :]) * (parameters[4, :] + \ parameters[5, :]) * (parameters[2, :]**2) / parameters[3, :] poissonparameters1 = repeat(poissonparameters1[:,newaxis], Nx, axis = 1) poissonparameters2 = repeat(poissonparameters2[:,newaxis], Nx, axis = 1) for indextheta in range(Ntheta): allK1 = array(random.poisson(lam = array(poissonparameters1[indextheta,:]))).reshape(Nx) allK1[allK1 > 10**4] = 10**4 allK1 = array(allK1).reshape(Nx) sumK1 = numpysum(allK1) allK2 = array(random.poisson(lam = poissonparameters2[indextheta,:])).reshape(Nx) allK2[allK2 > 10**4] = 10**4 allK2 = array(allK2).reshape(Nx) sumK2 = numpysum(allK2) alluniforms1 = random.uniform(size = 2 * sumK1) alluniforms2 = random.uniform(size = 2 * sumK2) subresults = subtransitionAndWeight(states[..., indextheta], y, parameters[:, indextheta], \ alluniforms1, allK1, alluniforms2, allK2) newstates[..., indextheta] = subresults["states"] weights[..., indextheta] = subresults["weights"] return {"states": newstates , "weights": weights}
def __init__(self, unique_id, model): super().__init__(unique_id, model) # Scalar: amount of effort a scientist is born with (M) self.start_effort = poisson(lam=10) # Scalar: rate of decay for starting_effort (lambda_e) self.start_effort_decay = 1 # Scalar: amount of effort a scientist has left self.avail_effort = self.start_effort.copy() # Investment cost for each idea for the scientist self.k = poisson(lam=2, size=model.total_ideas) # Parameters determining perceived returns for ideas self.sds = poisson(4, model.total_ideas) self.means = poisson(50, model.total_ideas) # Create the ideas/returns matrix self.returns_matrix = \ create_return_matrix(model.total_ideas, max(model.max_investment), sds, means) # Records when the scientist was born self.birth_time = model.schedule.time # Array keeping track of how much effort this scientist has invested in each idea self.effort_invested = np.zeros(model.total_ideas)
def update_with_poisson(self, l, t): self.net.layer[0].I = rn.poisson(l, INHIB_NEURONS) * EXTRA_I for i in range(1, EXCIT_MODULES + 1): self.net.layer[i].I = rn.poisson(l, EXCIT_NEURONS_PER_MODULE) * EXTRA_I self.net.Update(t)
def tst_robust_glm(): from scitbx.glmtbx import robust_glm from scitbx.array_family import flex from numpy.random import poisson, seed from math import exp seed(0) n_obs = 100 for c in range(1, 100): # Test for a constant value X = flex.double([1 for i in range(n_obs)]) X.reshape(flex.grid(n_obs, 1)) Y = flex.double(list(poisson(c, n_obs))) B = flex.double([0]) result = robust_glm(X, Y, B, family="poisson", max_iter=100) assert(abs(c - exp(result.parameters()[0])) < 0.1*c) # Now test with a massive outlier for c in range(1, 100): # Test for a constant value X = flex.double([1 for i in range(n_obs)]) X.reshape(flex.grid(n_obs, 1)) Y = flex.double(list(poisson(c, n_obs))) Y[n_obs//2] = c * 100 B = flex.double([0]) result = robust_glm(X, Y, B, family="poisson", max_iter=100) assert(abs(c - exp(result.parameters()[0])) < 0.1*c) print 'OK'
def setUp(self): # produce a dictionary of numbers n # and their factorizations # d[n] = [(p1,e1),(p2,e2)...(pk,ek)] # where p1..pk are the distinct prime # factors of n in order # for example: # d[12] = [(2,2),(3,1)] # j is the number of examples to generate j = 50 # d is a dictionary self.d = {} # pp is the average number of disctinct prime factors pp = 5 # ee is the average exponent ee = 5 for i in range(j): p = poisson(pp) shuffled_primes = copy.deepcopy(ppp) shuffle(shuffled_primes) factors = shuffled_primes[:pp] factors.sort() pairs = [] for factor in factors: # make sure e != 0 e = poisson(ee) + 1 pairs.append((factor,e)) n = self.unfactor(pairs) self.d[n] = pairs
def reproduce_pop_by_rec_probability (self): ''' reproduces the population by choosing two pools of genotypes from it 2 organisms are paired and their sex_locus probabilities are averaged if a random number is lower than this value, they will recombine and that value is assigned as the new organism's sex_locus value. otherwise, one will be cloned. ''' new_pop = Population() chosen_genotypes1 = Population.choose_genotype(self) #choose 2 pools of genotypes from current pop chosen_genotypes2 = Population.choose_genotype(self) for i in range(0,len(chosen_genotypes1)): if len(new_pop.organisms) < self.population_size: offspring_sex_probability = (chosen_genotypes1[i].sex_locus + chosen_genotypes2[i].sex_locus)/2.0 #calc the avg of each genotype's sex_locus if random.random() < offspring_sex_probability: recombined = (genotype.Genotype.recombine(chosen_genotypes1[i], chosen_genotypes2[i])) recombined.mutate_random(rnd.poisson(recombined.mutation_rate)) recombined.last_repro_mode = "sexual" #organism will be labled as product of sexual reproduction recombined.sex_locus = offspring_sex_probability #avg of parents' sex_locus assigned to offspring new_pop.organisms.append(recombined) else: chosen_genotypes1[i].mutate_random(rnd.poisson(chosen_genotypes1[i].mutation_rate)) chosen_genotypes1[i].last_repro_mode = "asexual" #organism labled as product of asexual reproduction chosen_genotypes1[i].sex_locus = offspring_sex_probability new_pop.organisms.append(chosen_genotypes1[i]) Population.get_population_fitness(new_pop) return new_pop
def underdogwin(gpm1, gpm2, elapsed_time, thresh, total_time): remaining_time = total_time - elapsed_time ok1 = [poisson(gpm1, remaining_time).sum() for i in range(100)] ok2 = [poisson(gpm2, remaining_time).sum() for i in range(100)] okdiff = np.array(ok1) - np.array(ok2) downbyx = thresh * elapsed_time / float(total_time) over5 = okdiff > downbyx return len(okdiff[over5]), downbyx
def generate_actions(self): # get feed ba = self.ba feed = ba['feed'][ba['venue_id']][0] best_ask = feed['BEST_ASK1'] if feed['BEST_ASK1'] != None else self['start_price'] best_bid = feed['BEST_BID1'] if feed['BEST_BID1'] != None else self['start_price'] # generate actions while len(self.actions) == 0: # initialize an empty list for actions actions = [] actions_LO = [] actions_MO = [] # loop on the side for side in [Order.Sell, Order.Buy]: # draw a poisson sample n = poisson(self['alpha']*self['timestep']/(2*self['sigma'])) # build actions and generate timestamp for i in range(n): if side == Order.Buy: price = best_ask - self['tick_size']*int(self['price_range']*random()+1) else: price = best_bid + self['tick_size']*int(self['price_range']*random()+1) #draw a half-normal sample qty = gauss(self['sigma'], self.order_size_std) qty = abs(int(qty)) actions_LO.append({'timestamp' : self.start_time_interval+long(self['timestep']*random()), 'type' : Order.Limit, 'quantity' : qty, 'side' : side, 'price' : self['tick_size']*round(price/self['tick_size'])}) if feed['TIME_NUM'] >= self['execution_start_time']: m = poisson(self['mu']*self['timestep']/(2*self['sigma'])) side = int(2*random()) for i in range(m): #draw a half-normal sample qty = gauss(self['sigma'], self.order_size_std) qty = abs(int(qty)) actions_MO.append({'timestamp' : self.start_time_interval+long(self['timestep']*random()), 'type' : Order.Market, 'quantity' : qty, 'side' : side, 'price' : 0.0}) # concatenation des deux listes d'actions market orders et limit orders actions.extend(actions_MO) actions.extend(actions_LO) # if there is no action, just skip this part if len(actions) > 0: # we sort the actions list actions.sort(key = lambda x: x['timestamp']) # make sure timestamps are different ! for i in range(len(actions)-1): if actions[i]['timestamp'] == actions[i+1]['timestamp']: actions[i+1]['timestamp'] += 1L # save actions self.actions = actions # increment the start_time_interval self.start_time_interval += self['timestep']
def generate_next_packet(self, period, destination=None, data=None, *args, **kwargs): """ Lowest-count node gets a message indicating what number packet it is that is addressed to it with a particular stream length. The counter counts the 'actual' number of packets while the packet.data carries the zero-indexed 'packet id' :param period: :param destination: :param data: :param args: :param kwargs: """ if destination is not None: raise RuntimeWarning( "This isn't the kind of application you use with a destination bub") # Update packet_counters with information from the routing layer indirect_nodes = filter( lambda n: n not in self.total_counter.keys(), self.layercake.net.keys()) if len(indirect_nodes): self.logger.debug("Inferred new nodes: {0}".format(indirect_nodes)) for node in indirect_nodes: self.total_counter[node] = 0 # DOES NOT MERGE TARGET COUNTER self.merge_counters() if self.current_target is None: self.current_target = self.select_target() destination = self.current_target packet_id = self.layercake.hostname + str(self.stats['packets_sent']) packet = {"ID": packet_id, "dest": destination, "source": self.layercake.hostname, "route": [], "type": "DATA", "time_stamp": Sim.now(), "length": self.layercake.packet_length, "data": self.test_packet_counter[destination]} self.sent_counter[destination] += 1 self.test_packet_counter[destination] += 1 if self.test_packet_counter[destination] % self.test_stream_length: # In Stream period = poisson(float(self.period * self.stream_period_ratio)) else: # Finished Stream period = poisson(float(self.period)) if DEBUG: self.logger.info("Finished Stream {0} for {1}, sleeping for {2}".format( self.test_packet_counter[destination] / self.test_stream_length, destination, period )) self.current_target = None return packet, period
def RobotStep(args): global t # Input from Sensors SL, SR = Env.GetSensors(x[t], y[t], w[t]) RL_spikes = 0.0 RR_spikes = 0.0 for t2 in xrange(dt): # Deliver stimulus as a Poisson spike stream to the sensor neurons and # noisy base current to the motor neurons I = np.hstack([rn.poisson(SL*15, N1), rn.poisson(SR*15, N2), 5*rn.randn(N3), 5*rn.randn(N4)]) # Update network net.setCurrent(I) fired = net.update() RL_spikes += np.sum(np.logical_and(fired > (N1+N2), fired < N1+N2+N3)) RR_spikes += np.sum(fired > (N1+N2+N3)) # Maintain record of membrane potential v[t2,:],_ = net.getState() # Output to motors # Calculate motor firing rates in Hz RL = 1.0*RL_spikes/(dt*N3)*1000.0 RR = 1.0*RR_spikes/(dt*N4)*1000.0 # Set wheel velocities (as fractions of Umax) UL = (Umin/Umax + RL/Rmax*(1 - Umin/Umax)) UR = (Umin/Umax + RR/Rmax*(1 - Umin/Umax)) # Update Environment x[t+1], y[t+1], w[t+1] = RobotUpdate(x[t], y[t], w[t], UL, UR, Umax, dt, xmax, ymax) ## PLOTTING for i in range(Ns): pl11[i].set_data(range(dt), v[:,i]) pl12[i].set_data(range(dt), v[:,i+Ns]) for i in range(Nm): pl21[i].set_data(range(dt), v[:,2*Ns+i]) pl22[i].set_data(range(dt), v[:,2*Ns+Nm+i]) ax2.scatter(x, y) manager1.canvas.draw() manager2.canvas.draw() t += 1 if t == len(x)-1: print 'Terminating simulation' StopSimulation()
def test_mixture_random_shape(): # test the shape broadcasting in mixture random y = np.concatenate([nr.poisson(5, size=10), nr.poisson(9, size=10)]) with pm.Model() as m: comp0 = pm.Poisson.dist(mu=np.ones(2)) w0 = pm.Dirichlet('w0', a=np.ones(2)) like0 = pm.Mixture('like0', w=w0, comp_dists=comp0, observed=y) comp1 = pm.Poisson.dist(mu=np.ones((20, 2)), shape=(20, 2)) w1 = pm.Dirichlet('w1', a=np.ones(2)) like1 = pm.Mixture('like1', w=w1, comp_dists=comp1, observed=y) comp2 = pm.Poisson.dist(mu=np.ones(2)) w2 = pm.Dirichlet('w2', a=np.ones(2), shape=(20, 2)) like2 = pm.Mixture('like2', w=w2, comp_dists=comp2, observed=y) comp3 = pm.Poisson.dist(mu=np.ones(2), shape=(20, 2)) w3 = pm.Dirichlet('w3', a=np.ones(2), shape=(20, 2)) like3 = pm.Mixture('like3', w=w3, comp_dists=comp3, observed=y) rand0, rand1, rand2, rand3 = draw_values([like0, like1, like2, like3], point=m.test_point, size=100) assert rand0.shape == (100, 20) assert rand1.shape == (100, 20) assert rand2.shape == (100, 20) assert rand3.shape == (100, 20) with m: ppc = pm.sample_posterior_predictive([m.test_point], samples=200) assert ppc['like0'].shape == (200, 20) assert ppc['like1'].shape == (200, 20) assert ppc['like2'].shape == (200, 20) assert ppc['like3'].shape == (200, 20)
def r(self, sid): b = 2.0 * float(sid + 1) / (self.nstims + 2) first = b * self.exp / 2.0 scnd = self.exp - first if hasattr(self, 'perfect'): first = int(round(first)) scnd = int(round(scnd)) else: first = npr.poisson(first) scnd = npr.poisson(scnd) r = np.concatenate([npr.normal(self.m1, self.sd, first), npr.normal(self.m2, self.sd, scnd)]) self.hist = [r]
def axc_ndarr(navg, dims, bgs, flucfs1, flucfs2, flucas1, flucas2, t): ''' Routine for generating a two dimensional array of averaged cross correlations. INPUTS: navg : Number of cross correlations to generate and average at each point. dims : Dimensions of the array to generate xcorrs for. Averaged xcorrs will be generated for the last point bgs : Background count rate. Assumed constant for all elements. flucfs1 : Array of dimensions dims with fluctuation frequencies. Each element is a tuple with (flucf1, flucf2). flucfs2 : Array of dimensions dims with fluctuation frequencies for PMT 2. flucas1 : Array of dimensionality dims with fluctuation amplitudes for PMT 1. Each element is a tuple with (fluca1, fluca2) flucas2 : Array of dimensionality dims with fluctuation amplitudes for PMT 2. As an exmaple, if I wanted to generate a 2x2 matrix of cross correlations, each of which had been averaged over 50 runs measuring a constant 1200 Hz fluctuation, I'd say: bgs = 10000 flucfs = np.array([1200,1200]) dims = (2, 2) navg = 50 xc2d = axc_2darr(50, dims, bgs, flucfs, flucas, t) ''' #Generate all the background arrays. dims = dims + (navg,) bg1 = rand.poisson(bgs, size=dims + (np.size(t),)) bg2 = rand.poisson(bgs, size=dims + (np.size(t),)) #Generate the ndimensional PMT1 and PMT2 matrices. #Generate meshgrids for each of the desired coordinates (t, flucas1, #flucas2, flucfs1, flucfs2) #Each one of these meshgrid lines generates an ndimensional grid of what we #want to use for making the function. fa1g, fs1g, xcpref, tt = np.meshgrid(*[flucfs1, flucas1, np.ones((navg,)), t]) fa2g, fs2g, xcpref, tt = np.meshgrid(*[flucfs2, flucas2, np.ones((navg,)), t]) PMT1 = fa1g * np.sin(2 * np.pi * fs1g * tt) + bg1 PMT2 = fa2g * np.sin(2 * np.pi * fs2g * tt) + bg2 #Add the background noise to it. #Cross correlate the two along each last dimension. #Use a helper function which cross correlates the corresponding 1d arrays #in a certain dimension. uxc12 = uxcorr_ndim(PMT1, PMT2, axis=-1) return (uxc12, PMT1, PMT2)
def add_zingers(imageset, params): from dxtbx.format.FormatCBF import FormatCBF assert issubclass(imageset.reader().get_format_class(), FormatCBF), ( "Only CBF format images supported") from cbflib_adaptbx import compress import binascii from numpy.random import poisson from random import sample import os.path for i in range(len(imageset)): image_data = imageset[i] num = poisson(params.zingers.average_per_image) index = sample(range(len(image_data)), num) value = list(poisson(params.zingers.average_intensity, num)) for j, v in zip(index, value): image_data[j] += v out_image = os.path.join(params.output.directory, "image_%04i.cbf" % i) start_tag = binascii.unhexlify('0c1a04d5') data = open(imageset.get_path(i), 'rb').read() data_offset = data.find(start_tag) cbf_header = data[:data_offset] new_header = [] compressed = compress(image_data) old_size = 0 for record in cbf_header.split('\n')[:-1]: if 'X-Binary-Size:' in record: old_size = int(record.split()[-1]) new_header.append('X-Binary-Size: %d\r\n' % len(compressed)) elif 'Content-MD5' in record: pass else: new_header.append('%s\n' % record) tailer = data[data_offset + 4 + old_size:] with open(out_image, 'wb') as f: f.write(''.join(new_header) + start_tag + compressed + tailer) print '%s written with %d zingers' % (out_image, num) return
def test_glm_any_model(): nbin = 10 align = 'hold' lag = 0.1 # s ds = datasets['small'] dc = DataCollection(ds.get_files()) dc.add_unit(ds.get_units()[0], lag) bnd = dc.make_binned(nbin=nbin, align=align) ntask, nrep, nunit, nbin = bnd.shape # make perfect test counts # direction-only model tp = radians([20, 10]) # degrees b0 = log(10) # log(Hz) pd = pol2cart(tp) drn = kinematics.get_idir(bnd.pos, axis=2) rate = exp(dot(drn, pd) + b0) window_size = diff(bnd.bin_edges, axis=2) count_mean = rate * window_size count = poisson(count_mean) count = count[:,:,None] bnd.set_PSTHs(count) # now fit data for pd count, pos, time = bnd.get_for_regress() bnom, bse_nom = glm_any_model(count, pos, time, model='kd') pd_exp = unitvec(bnom['d']) tp_exp = cart2pol(pd_exp) acceptable_err = 0.05 # about 3 degrees absolute error err = abs(tp - tp_exp) assert_array_less(err, acceptable_err)
def submitPilotsForTaskQueue( self, taskQueueDict, waitingPilots ): from numpy.random import poisson from DIRAC.WorkloadManagementSystem.private.Queues import maxCPUSegments taskQueueID = taskQueueDict['TaskQueueID'] maxCPU = maxCPUSegments[-1] extraPilotFraction = self.am_getOption( 'extraPilotFraction' ) extraPilots = self.am_getOption( 'extraPilots' ) taskQueuePriority = taskQueueDict['Priority'] self.log.verbose( 'Priority for TaskQueue %s:' % taskQueueID, taskQueuePriority ) taskQueueCPU = max( taskQueueDict['CPUTime'], self.am_getOption( 'lowestCPUBoost' ) ) self.log.verbose( 'CPUTime for TaskQueue %s:' % taskQueueID, taskQueueCPU ) taskQueueJobs = taskQueueDict['Jobs'] self.log.verbose( 'Jobs in TaskQueue %s:' % taskQueueID, taskQueueJobs ) # Determine number of pilots to submit, boosting TaskQueues with low CPU requirements pilotsToSubmit = poisson( ( self.pilotsPerPriority * taskQueuePriority + self.pilotsPerJob * taskQueueJobs ) * maxCPU / taskQueueCPU ) # limit the number of pilots according to the number of waiting job in the TaskQueue # and the number of already submitted pilots for that TaskQueue pilotsToSubmit = min( pilotsToSubmit, int( ( 1 + extraPilotFraction ) * taskQueueJobs ) + extraPilots - waitingPilots ) if pilotsToSubmit <= 0: return S_OK( 0 ) self.log.verbose( 'Submitting %s pilots for TaskQueue %s' % ( pilotsToSubmit, taskQueueID ) ) return self.__submitPilots( taskQueueDict, pilotsToSubmit )
def poissonize(h,tol): """ Monte-Carlo sample the mass function, using a Poisson distribution in each bin. h = halo model instance tol = threshold beyond which we don't bother with the Monte Carlism. If there's a high number of haloes in a bin (>~1000?), Poissonizing will make little difference """ poissonnmz = h.nmz*0. arraytopoissonize = h.nmz*(h.volume*h.m*h.dlogm) #pylab.clf() #pylab.loglog(h.m,1.+arraytopoissonize) #print arraytopoissonize tolm2 = tol**(-2) for j in range(len(h.nmz)): if (arraytopoissonize[j] < tolm2) and (arraytopoissonize[j]>1e-45): arraytopoissonize[j] = RandomArray.poisson(arraytopoissonize[j]) #poissonnmz[j] = jimmy #print arraytopoissonize[j],poissonnmz[j] elif (arraytopoissonize[j] <= 1e-45): arraytopoissonize[j] = 0. #pylab.loglog(h.m,1.+poissonnmz) ans = arraytopoissonize/(h.volume*h.m*h.dlogm) #pylab.savefig('poissonize.ps') return(ans)
def generate_toy_MC_from_distribution(distribution): initial_values = list(distribution) new_values = [rnd.poisson(value) for value in initial_values] #statistical errors new_errors = [sqrt(value) for value in new_values] toy_MC = value_error_tuplelist_to_hist(zip(new_values, new_errors), list(distribution.xedges())) return toy_MC
def tgen(self): poiss = random.poisson(lam = 1000, size = 200) # 1000 = 1 day = expected time between measuremens poiss = poiss / 1000.0 x_axis = ones(len(poiss),dtype=float) for i in arange(len(x_axis))[:-1]: x_axis[i+1] = x_axis[i] + poiss[i] return x_axis
def generate_toy_MC_from_values( values ): values = [ 0 if i < 0 else i for i in values ] new_values = [poisson( value ) for value in values] # statistical errors new_errors = [sqrt( value ) for value in new_values] return new_values, new_errors
def diffuse_ribosomes_to_initiation_site(self, mRNA, deltat, time): """Perform Poisson experiment to test how many ribosomes make it initiation site and try to attach.""" if self.ribo_free > 0: # k = npr.binomial(self.ribo_free, mRNA.init_rate*deltat, 1)[0] # number of ribosomes that diffuse to the initiation site during deltat k = npr.poisson( self.ribo_free * mRNA.init_rate * deltat) # number of ribosomes that diffuse to the initiation site during deltat # log.debug('update_initiation: %s ribosomes out of %s diffused to init site at mRNA %s with probability %s', k, self.ribo_free, mRNA.index, self.init_rate*deltat) for i in range(k): # currently k>1 will not attach k ribosomes, TODO: if not mRNA.ribosomes or not mRNA.first_position_occupied(): # log.debug("update_initiation: found mRNA with free first position") if self.GTP > 0 and self.ATP > 0: if mRNA.attach_ribosome_at_start(): # log.debug("update_initiation: attaching ribosome at start of mRNA %s", mRNA.index) self.ribo_bound += 1 self.ribo_free -= 1 self.GTP -= 1 self.GDP += 1 self.ATP -= 2 self.AMP += 2 if not mRNA.tic: # no time measurement ongoing on this mRNA mRNA.tic = time mRNA.toc = len(mRNA.ribosomes) + 1 # number of ribos + 1 to countdown to end of time measurement else: log.warning("update_initiation: unsuccessful attempt to attach ribosome") else: log.warning("update_initiation: no GTP or no ATP") else: # log.warning("update_initiation: unsuccessful attempt to attach ribosome: first position occupied") pass else: # log.warning("update_initiation: no free ribosomes left") pass
def sexer_pestieau_poisson(n): #TODO TODO chk from numpy.random import poisson nkidsvec = poisson(2,n) for nkids in nkidsvec: result = 'F'*nkids print result, yield result
def sample_topic_freqs(word_topic_rates, mask): """Given observed_word_freqs, that each word was held out (if mask is 0) or not held out (if mask is 1), and each word w was produced via topic i according to a Poisson with rate word_topic_rates[w, i], returns a sample from the posterior distribution on the number of times a word was generated from each topic. """ # First, sample the contribution from words where mask was 0. Each # such word is sampled from a poisson distribution. The sum of poisson # distributions is poisson, so we only need to sample one poisson for # each topic. topic_freqs = \ poisson(np.sum((1 - mask)[:, np.newaxis] * word_topic_rates, 0)) # For each word where mask was 1, we sample from a multinomial # distribution with probabilities proportional to the word-topic rates # for that word. For efficiency, we skip over words that didn't occur # at all: multinomial_words is an array of the indices of words for # which we do need to take a sample. multinomial_words = np.arange(vocab_size)[ np.array(mask * observed_word_freqs, dtype = bool)] for word in multinomial_words: topic_rates = word_topic_rates[word, :] topic_freqs += multinomial(observed_word_freqs[word], topic_rates / sum(topic_rates)) return topic_freqs
def run(self): for t in range(1, self.runtime): for neuron in self.neurons: neuron.I = 15 if rn.poisson(0.01, 1)[0] > 0 else 0 self.updateNeurons(t) return
def sim_lemonade(num, mean = 600, sd = 30, pois = False): ## Simulate the profits and tips for ## a lemonade stand. import numpy.random as nr ## number of customer arrivals if pois: arrivals = nr.poisson(lam = mean, size = num) else: arrivals = nr.normal(loc = mean, scale = sd, size = num) print(dist_summary(arrivals, 'customer arrivals per day')) ## Compute distibution of average profit per arrival proft = gen_profits(num) print(dist_summary(proft, 'profit per arrival')) ## Total profits are profit per arrival ## times number of arrivals. total_profit = arrivals * proft print(dist_summary(total_profit, 'total profit per day')) ## Compute distribution of average tips per arrival tps = gen_tips(num) print(dist_summary(tps, 'tips per arrival')) ## Compute average tips per day total_tips = arrivals * tps print(dist_summary(total_tips, 'total tips per day')) ## Compute total profits plus total tips. total_take = total_profit + total_tips return(dist_summary(total_take, 'total net per day'))
def main1(i0b,re,eb,n,point,bpa,background): parms=np.zeros(11) parms[0]=i0b parms[1]=re parms[2]=eb parms[3]=n parms[7]=point parms[8]=bpa parms[10]=background generate_model_galaxy(parms) imag1=fits.open('test_bulge1.fits') model_galaxy=imag1[0].data imag= fits.open('test_bulge.fits') # make 1d array from 2d galaxy array galaxy=imag[0].data z= galaxy.flat # make 1d array from 2d galaxy array numra.seed(120980)# Set random number seed #zerr = np.sqrt(1+0.0*((abs(numra.poisson(z)-z)*c.gain)**2.0+c.rdnoise**2.0)) zerr = np.sqrt((abs(numra.poisson(z)-z)*1.0)**2.0+0.0**2.0) # print zerr validpix = np.where(zerr != 0.0) #if (c.use_mask): # numpoints = ma.count(c.maskedgalaxy) #else: #numpoints = 51 * 51 #chi2= np.sum(((z[validpix]-model_galaxy.flat[validpix])/zerr[validpix])**2.0)/numpoints #print chi2 avg=np.mean(galaxy-model_galaxy) return avg
def simOneGenRec(self,newNHap,recRate,verbose=False): """for now, just assume uniform recombination""" nRecEvents=rng.poisson(recRate,newNHap) if verbose: print nRecEvents newData=np.empty((newNHap,self.nSegsites)) for i,nre in enumerate(nRecEvents): if nre==0: newData[i] = self.data[rng.randint(0,self.nHap)] if verbose: print i,"zero" else: v = rng.randint(0,self.nHap,nre+1) recPos = np.empty(nre+2);recPos[0]=0;recPos[nre+1]=1 recPos[1:nre+1] = np.sort(rng.random(nre)) nChr = np.empty(self.nSegsites) for j in range(nre+1): pos = np.logical_and(self.segSites>recPos[j], self.segSites<recPos[j+1]) nChr[pos] = self.data[v[j]][pos] newData[i] = nChr if verbose: print i,v,recPos self.nHap = newNHap self.data = newData
def makePoissonNoiseImage(im): """Return a Poisson noise image based on im Parameters ---------- im : `lsst.afw.image.Image` image; the output image has the same dtype, dimensions, and shape and its expectation value is the value of ``im`` at each pixel Returns ------- noiseIm : `lsst.afw.image.Image` Newly constructed image instance, same type as ``im``. Notes ----- - Warning: This uses an undocumented numpy API (the documented API uses a single float expectation value instead of an array). - Uses numpy.random; you may wish to call numpy.random.seed first. """ import numpy.random as rand imArr = im.getArray() noiseIm = im.Factory(im.getBBox()) noiseArr = noiseIm.getArray() with np.errstate(invalid='ignore'): intNoiseArr = rand.poisson(imArr) noiseArr[:, :] = intNoiseArr.astype(noiseArr.dtype) return noiseIm
def mixture_process(nu, P, tauc, t): ''' Generate correlated spike trains from a mixture process. nu = rates of source spike trains P = mixture matrix tauc = correlation time constant t = duration Returns a list of (neuron_number,spike_time) to be passed to SpikeGeneratorGroup. ''' n = array(poisson(nu * t)) # number of spikes for each source spike train if n.ndim == 0: n = array([n]) # Only non-zero entries: nonzero = n.nonzero()[0] n = n[nonzero] P = array(P.take(nonzero, axis=1)) nik = binomial(n, P) # number of spikes from k in i result = [] for k in xrange(P.shape[1]): spikes = rand(n[k]) * t for i in xrange(P.shape[0]): m = nik[i, k] if m > 0: if tauc > 0: selection = sample(spikes, m) + array(exponential(tauc, m)) else: selection = sample(spikes, m) result.extend(zip([i] * m, selection)) result = [(i,t*second) for i,t in result] return result
def rfd_poisson(ps,n): """Sample n configs by conditioning on chromosomal occupancy via LeCam's theorem""" lam = sum(ps) G = len(ps) sample_q = lambda:nprandom.poisson(lam) # chromosomal occupancy approximately poisson. sampler = make_sampler(ps) return [direct_sampling_ps(ps,sample_q(),sampler) for i in xrange(n)]
def ucuc_grad_solver(bandit, steps, lam=0.1, init_reward=1.5, uc=0, ucuc=15, heads=100, bs2_heads=100, p=0.3, uc_var=False, ucuc_var=False, bernouli=False): avg_reward = init_reward * torch.randn( (bandit.batches, bandit.size, heads)).cuda() avg_reward = VG(avg_reward) pulled_arms = torch.zeros(bandit.batches, steps) br = torch.arange(0, bandit.batches).long().cuda() sr = torch.arange(0, bandit.size).long().cuda() sgd = optim.SGD([avg_reward], lr=lam) rand_idx_store = torch.LongTensor(64 * 1024 * 1024).random_(heads).cuda() if ucuc == 0: bs2_std = V(torch.zeros(1).cuda()) def get_rand_idx(*sizes): count = np.prod(sizes) start = rng.randint(0, len(rand_idx_store) - count) return rand_idx_store[start:start + count].view(*sizes) for i in range(steps): r_std = (torch.var if uc_var else torch.std)(avg_reward, -1) r_mean = torch.mean(avg_reward, -1) if ucuc != 0: bs2_idx = get_rand_idx(bandit.batches, bandit.size, heads * bs2_heads) bs2 = avg_reward.data.gather(-1, bs2_idx) bs2 = bs2.view(bandit.batches, bandit.size, heads, bs2_heads) bs2_std = V((torch.var if ucuc_var else torch.std)(bs2.mean(-1), -1)) arm = (r_mean + uc * r_std + ucuc * bs2_std).data.max(dim=1)[1] r = V(FTC(bandit.step(NP(arm)))) std_poisson = rng.binomial(1, p, (bandit.batches, heads)) if bernouli else rng.poisson( p, (bandit.batches, heads)) std_poisson = V(FTC(std_poisson)) avg_reward_err = (avg_reward[br, arm] - r.view(-1, 1))**2 * std_poisson err = avg_reward_err.sum() sgd.zero_grad() err.backward() sgd.step() pulled_arms[:, i] = arm.cpu() if i == 0 or (i + 1) % 100 == 0: print(i, NP(r_std.mean()), NP(bs2_std.mean())) r_mean = torch.mean(avg_reward, -1) avg_err = NP(r_mean) - bandit.mean print('mae', np.mean(np.abs(avg_err)), 'mse', np.mean(avg_err**2)) return NP(pulled_arms)
from math import e, factorial,log, gamma, sqrt from matplotlib import pyplot as pt from numpy.random import geometric, poisson, exponential from scipy.stats import ks_2samp f = open("cbdata.txt") v = [int(x)+1 for x in f.readlines()] f.close() lam = 0.5275924670273324 poidata = poisson(lam ,len(v)) expdata = exponential(lam,len(v)) geodata = geometric(lam,len(v)) e= ks_2samp(v,expdata) d = ks_2samp(v,poidata) g = ks_2samp(v,geodata) print('exponential',e) print('poisson',d) print('geometric',g)
lista = [] #Result of each simulated experiment for experiment in range(1): bins = np.linspace(lead_min_e, ct.muonmass / 2, 10 + 1) measured = np.zeros(len(bins) - 1) prediction = np.zeros(len(bins) - 1) # Here we simulate experimental data ("mock" data) for i in range(len(bins) - 1): if i == 6: measured[i] = rn.poisson( [ integrate.quad( lambda Enu1: evt.dNdEvee(Enu1, ct.Ue4_2, ct.DelM2), bins[i], bins[i + 1], epsabs=int_err) ][0][0] + evt.NMuOriginCC(ct.NuMuenergy, ct.Ue4_2, ct.Umu4_2, ct.DelM2)) else: measured[i] = rn.poisson([ integrate.quad( lambda Enu1: evt.dNdEvee(Enu1, ct.Ue4_2, ct.DelM2), bins[i], bins[i + 1], epsabs=int_err) ][0][0]) #Here we define the Chi^2
Copyright (c) 2008 University of Otago. All rights reserved. """ # Import statements from pymc3 import * from numpy import random, array, arange, ones import theano.tensor as t # Sample size n = 100000 # True mean count, given occupancy theta = 2.1 # True occupancy pi = 0.4 # Simulate some data data y = array([(random.random() < pi) * random.poisson(theta) for i in range(n)]) model = Model() with model: # Estimated occupancy p = Beta('b', 1, 1) # Latent variable for occupancy z = Bernoulli('z', p, shape=y.shape) # Estimated mean count theta = Uniform('theta', 0, 100) # Poisson likelihood z = ZeroInflatedPoisson('z', theta, z)
def _sample_obs(self, mean): return poisson(mean)
def generate_image(image_parameters): """Generate image with particles. Input: image_parameters: list with the values of the image parameters in a dictionary: image_parameters['Particle Center X List'] image_parameters['Particle Center Y List'] image_parameters['Particle Radius List'] image_parameters['Particle Bessel Orders List'] image_parameters['Particle Intensities List'] image_parameters['Image Half-Size'] image_parameters['Image Background Level'] image_parameters['Signal to Noise Ratio'] image_parameters['Gradient Intensity'] image_parameters['Gradient Direction'] image_parameters['Ellipsoid Orientation'] image_parameters['Ellipticity'] Note: image_parameters is typically obained from the function get_image_parameters() Output: image: image of the particle [2D numpy array of real numbers betwen 0 and 1] """ from numpy import meshgrid, arange, ones, zeros, sin, cos, sqrt, clip, array from scipy.special import jv as bessel from numpy.random import poisson as poisson particle_center_x_list = image_parameters['Particle Center X List'] particle_center_y_list = image_parameters['Particle Center Y List'] particle_radius_list = image_parameters['Particle Radius List'] particle_bessel_orders_list = image_parameters[ 'Particle Bessel Orders List'] particle_intensities_list = image_parameters['Particle Intensities List'] image_half_size = image_parameters['Image Half-Size'] image_background_level = image_parameters['Image Background Level'] signal_to_noise_ratio = image_parameters['Signal to Noise Ratio'] gradient_intensity = image_parameters['Gradient Intensity'] gradient_direction = image_parameters['Gradient Direction'] ellipsoidal_orientation_list = image_parameters['Ellipsoid Orientation'] ellipticity = image_parameters['Ellipticity'] ### CALCULATE IMAGE PARAMETERS # calculate image full size image_size = image_half_size * 2 + 1 # calculate matrix coordinates from the center of the image image_coordinate_x, image_coordinate_y = meshgrid( arange(-image_half_size, image_half_size + 1), arange(-image_half_size, image_half_size + 1), sparse=False, indexing='ij') ### CALCULATE BACKGROUND # initialize the image at the background level image_background = ones((image_size, image_size)) * image_background_level # add gradient to image background if gradient_intensity != 0: image_background = image_background + gradient_intensity * ( image_coordinate_x * sin(gradient_direction) + image_coordinate_y * cos(gradient_direction)) / (sqrt(2) * image_size) ### CALCULATE IMAGE PARTICLES image_particles = zeros((image_size, image_size)) for particle_center_x, particle_center_y, particle_radius, particle_bessel_orders, particle_intensities, ellipsoidal_orientation in zip( particle_center_x_list, particle_center_y_list, particle_radius_list, particle_bessel_orders_list, particle_intensities_list, ellipsoidal_orientation_list): # calculate the radial distance from the center of the particle # normalized by the particle radius radial_distance_from_particle = sqrt( (image_coordinate_x - particle_center_x)**2 + (image_coordinate_y - particle_center_y)**2 + .001**2) / particle_radius # for elliptical particles rotated_distance_x = (image_coordinate_x - particle_center_x) * cos( ellipsoidal_orientation) + (image_coordinate_y - particle_center_y ) * sin(ellipsoidal_orientation) rotated_distance_y = -(image_coordinate_x - particle_center_x) * sin( ellipsoidal_orientation) + (image_coordinate_y - particle_center_y ) * cos(ellipsoidal_orientation) elliptical_distance_from_particle = sqrt( (rotated_distance_x)**2 + (rotated_distance_y / ellipticity)**2 + .001**2) / particle_radius # calculate particle profile for particle_bessel_order, particle_intensity in zip( particle_bessel_orders, particle_intensities): image_particle = 4 * particle_bessel_order**2.5 * ( bessel(particle_bessel_order, elliptical_distance_from_particle) / elliptical_distance_from_particle)**2 image_particles = image_particles + particle_intensity * image_particle # calculate image without noise as background image plus particle image image_particles_without_noise = clip(image_background + image_particles, 0, 1) ### ADD NOISE image_particles_with_noise = poisson( image_particles_without_noise * signal_to_noise_ratio**2) / signal_to_noise_ratio**2 return image_particles_with_noise
def nsbh_population(rate, t_min, t_max, f_online, d_min, d_max, h_0,\ q_0, m_min_1, m_max_1, m_mean_1, m_std_1, m_min_2, \ m_max_2, m_mean_2, m_std_2, a_min_1, a_max_1, \ a_min_2, a_max_2, seed=None, sample_z=False, \ redshift_rate=False, uniform_bh_masses=False, \ uniform_ns_masses=False, fixed_count=None, \ aligned_spins=False): # constrained realisation if desired if seed is not None: npr.seed(seed) # first draw number of events: a Poisson process, with rate # given by the number of events per year per Gpc^3, the # duration of observations and the volume if fixed_count is None: if sample_z: z_min = d2z(d_min, h_0, q_0) z_max = d2z(d_max, h_0, q_0) vol = volume_z(z_max, z_min, h_0, q_0, \ redshift_rate=redshift_rate) else: vol = volume(d_max, d_min, h_0, q_0) n_per_sec = rate * vol / 365.0 / 24.0 / 3600.0 * f_online n_exp = n_per_sec * (t_max - t_min) n_inj = npr.poisson(n_exp) else: if sample_z: z_min = d2z(d_min, h_0, q_0) z_max = d2z(d_max, h_0, q_0) n_inj = fixed_count n_per_sec = fixed_count / (t_max - t_min) # draw merger times consistent with the expected rate. add a # check to ensure that the latest merger time is within the # observation window times = np.zeros(n_inj) times[0] = t_min times[-1] = t_max + 1.0 while times[-1] >= t_max: delta_times = npr.exponential(1.0 / n_per_sec, n_inj - 1) for i in range(1, n_inj): times[i] = times[i - 1] + delta_times[i - 1] # draw distances via an interpolated CDF if sample_z: z_grid = np.linspace(z_min, z_max, 10000) p_z_grid = volume_z(z_grid, z_min, h_0, q_0, \ redshift_rate=redshift_rate) / \ volume_z(z_max, z_min, h_0, q_0, \ redshift_rate=redshift_rate) interp = si.interp1d(p_z_grid, z_grid) redshifts = interp(npr.uniform(size=n_inj)) distances = z2d(redshifts, h_0, q_0) else: d_grid = np.linspace(d_min, d_max, 10000) p_d_grid = volume(d_grid, d_min, h_0, q_0) / \ volume(d_max, d_min, h_0, q_0) interp = si.interp1d(p_d_grid, d_grid) distances = interp(npr.uniform(size=n_inj)) # draw inclinations, colatitudes and longitudes incs = np.arccos(-npr.uniform(-1.0, 1.0, size=n_inj)) colats = np.arcsin(-npr.uniform(-1.0, 1.0, size=n_inj)) longs = npr.uniform(0.0, 2.0 * np.pi, size=n_inj) # draw masses if uniform_bh_masses: m_1s = npr.uniform(m_min_1, m_max_1, size=n_inj) else: dist = ss.truncnorm((m_min_1 - m_mean_1) / m_std_1, \ (m_max_1 - m_mean_1) / m_std_1, \ loc=m_mean_1, scale=m_std_1) m_1s = dist.rvs(n_inj) if uniform_ns_masses: m_2s = npr.uniform(m_min_2, m_max_2, size=n_inj) else: dist = ss.truncnorm((m_min_2 - m_mean_2) / m_std_2, \ (m_max_2 - m_mean_2) / m_std_2, \ loc=m_mean_2, scale=m_std_2) m_2s = dist.rvs(n_inj) # now draw spins: isotropic in direction, uniform in magnitude spin_amps = npr.uniform(a_min_1, a_max_1, size=n_inj) spin_colats = np.arccos(-npr.uniform(-1.0, 1.0, size=n_inj)) spin_longs = npr.uniform(0.0, 2.0 * np.pi, size=n_inj) a_1_xs = spin_amps * np.sin(spin_colats) * np.cos(spin_longs) a_1_ys = spin_amps * np.sin(spin_colats) * np.sin(spin_longs) a_1_zs = spin_amps * np.cos(spin_colats) if aligned_spins: a_1_xs = 0.0 a_1_ys = 0.0 spin_amps = npr.uniform(a_min_2, a_max_2, size=n_inj) spin_colats = np.arccos(-npr.uniform(-1.0, 1.0, size=n_inj)) spin_longs = npr.uniform(0.0, 2.0 * np.pi, size=n_inj) a_2_xs = spin_amps * np.sin(spin_colats) * np.cos(spin_longs) a_2_ys = spin_amps * np.sin(spin_colats) * np.sin(spin_longs) a_2_zs = spin_amps * np.cos(spin_colats) if aligned_spins: a_2_xs = 0.0 a_2_ys = 0.0 # finally draw isotropic coa_phase and polarization angles coa_phases = npr.uniform(0.0, 2.0 * np.pi, size=n_inj) pols = npr.uniform(0.0, 2.0 * np.pi, size=n_inj) # store in structured array dtypes = [('simulation_id', 'U256'), ('mass1', float), \ ('mass2', float), ('spin1x', float), ('spin1y', float), \ ('spin1z', float), ('spin2x', float), \ ('spin2y', float), ('spin2z', float), ('redshift', float), \ ('distance', float), ('inclination', float), \ ('coa_phase', float), ('polarization', float), \ ('longitude', float), ('latitude', float), \ ('geocent_end_time', int), ('geocent_end_time_ns', int)] data = np.empty((n_inj, ), dtype=dtypes) data['simulation_id'] = \ ['sim_inspiral:simulation_id:{:d}'.format(i) for i in range(n_inj)] data['mass1'] = m_1s data['mass2'] = m_2s data['spin1x'] = a_1_xs data['spin1y'] = a_1_ys data['spin1z'] = a_1_zs data['spin2x'] = a_2_xs data['spin2y'] = a_2_ys data['spin2z'] = a_2_zs data['redshift'] = redshifts data['distance'] = distances data['inclination'] = incs data['coa_phase'] = coa_phases data['polarization'] = pols data['longitude'] = longs data['latitude'] = colats data['geocent_end_time'] = [int(math.modf(t)[1]) for t in times] data['geocent_end_time_ns'] = [int(math.modf(t)[0] * 1e9) for t in times] return 1.0 / n_per_sec, data
def _sampleFromModel(self, D=200, T=100, K=10, F=12, P=8, avgWordsPerDoc=500): ''' Create a test dataset according to the model Params: T - Vocabulary size, the number of "terms". Must be a square number K - Observed topics P - Latent features F - Observed features D - Sample documents (each with associated features) avgWordsPerDoc - average number of words per document generated (Poisson) Returns: modelState - a model state object configured for training tpcs - the matrix of per-document topic distribution vocab - the matrix of per-topic word distributions docLens - the vector of document lengths X - the DxF side information matrix W - The DxW word matrix ''' # Generate vocab beta = 0.1 betaVec = np.ndarray((T, )) betaVec.fill(beta) vocab = np.zeros((K, T)) for k in range(K): vocab[k, :] = rd.dirichlet(betaVec) # Geneate the shared covariance matrix sigT = rd.random((K, K)) sigT = sigT.dot(sigT) sigT.flat[::K + 1] += rd.random((K, )) * 4 # Just link two topics sigT[K // 2, K // 3] = 3 sigT[K // 3, K // 2] = 3 sigT[4 * K // 5, K // 5] = 4 sigT[K // 5, 4 * K // 5] = 4 # Generate Y, then V, then A lfv = 0.1 # latent feature variance (for Y) fv = 0.1 # feature variance (for A) Y = matrix_normal(np.zeros((K, P)), lfv * np.eye(P), sigT) V = matrix_normal(np.zeros((P, F)), fv * np.eye(F), lfv * np.eye(P)) A = matrix_normal(Y.dot(V), fv * np.eye(F), sigT) # Generate the input features. Assume the features are multinomial and sparse # (not quite a perfect match for the twitter example: twitter is binary, this # may not be) featuresDist = [1. / F] * F maxNonZeroFeatures = 3 X = np.zeros((D, F), dtype=np.float32) for d in range(D): X[d, :] = rd.multinomial(maxNonZeroFeatures, featuresDist) X = ssp.csr_matrix(X) # Use the features and the matrix A to generate the topics and documents tpcs = rowwise_softmax(X.dot(A.T)) docLens = rd.poisson(avgWordsPerDoc, (D, )).astype(np.float32) W = tpcs.dot(vocab) W *= docLens[:, np.newaxis] W = np.array(W, dtype=np.int32) # truncate word counts to integers W = ssp.csr_matrix(W) # Return the initialised model, the true parameter values, and the # generated observations return tpcs, vocab, docLens, X, W
# Program below the class import numpy as np from numpy.random import poisson from matplotlib import pyplot as plt import bucketHydrology as bh #plt.ion() rain = poisson(.2, 100) # Convert to an import for real data dt = 1. # day # Change these parameters with an input file or script, eventually # Arbitrary units; will be made real in an actual landscape res_surface = bh.reservoir(t_efold=1., f_to_discharge=0.5, Hmax=10.) res_deep = bh.reservoir(t_efold=10., f_to_discharge=1., Hmax=np.inf) strat_column = [res_surface, res_deep] watershed = bh.buckets(reservoir_list=strat_column, dt=dt) watershed.run(rain) watershed.plot()
plt.xlim(0, 1) plt.ylim(0, 1) plt.show() fig.savefig("foo1.pdf", bbox_inches='tight') def isInUnitSquare(x): return (x[0] > 0 and x[0] < 1 and x[1] > 0 and x[1] < 1) nsLoc = np.empty(shape=(0, 2)) allocs = np.empty(shape=(0), dtype=int) j = 0 for i in nhPPP: N = random.poisson(alpha) jitter = random.normal(loc=0, scale=sigma, size=(N, 2)) nsLoc = np.concatenate((nsLoc, i + jitter)) allocs = np.concatenate((allocs, np.full(N, j))) j += 1 index = [isInUnitSquare(x) for x in nsLoc] nsLoc = nsLoc[index] allocs = allocs[index] fig = plt.figure() ax = fig.add_subplot(111) ax.set_aspect('equal') plt.plot(pointpo.loc[:, 0], pointpo.loc[:, 1], 'o', c="#00743F", alpha=0.5) plt.plot(nhPPP[:, 0], nhPPP[:, 1], 'o', c="#1E65A7") plt.plot(nsLoc[:, 0], nsLoc[:, 1], 'ro', ms=3)
# print # " <T> in {1, 3, 5}" # print # " <mu> in {0.01, 0.02, ..., 0.20}" # sys.exit() # Related coefficients theta = np.ceil(mu * n) / T CI_coef = norm.ppf(0.5 + CI_perc / 200.0) ''' Importance sampling ''' # Store variables Y_total = np.zeros(n_MC) m_MC = rd.poisson(np.ceil(mu * n), n_MC) #t_start = time.time() print('here. note n_Mc = {}'.format(n_MC)) # Do Monte Carlo IS for i_MC in range(n_MC): # # Print progress # if (i_MC + 1) % (n_MC / 100) == 0: # print # "{0: >3}% done in {1}".format( # int(100 * (i_MC + 1) / n_MC), timedelta(seconds=time.time() - t_start)) # Step 1 - Generate S
│ │ │ │ │ │ 7: ───────█───────────────────█───╱7╲───█───────────────────────█───3↦1─── """.strip() assert actual_text_diagram == expected_text_diagram def test_swap_network_init_error(): with pytest.raises(ValueError): SwapNetworkGate(()) with pytest.raises(ValueError): SwapNetworkGate((3, )) @pytest.mark.parametrize( 'part_lens, acquaintance_size', [[[l + 1 for l in poisson(size=n_parts, lam=lam)], poisson(4)] for n_parts, lam in product(range(2, 20, 3), range(1, 4))]) def test_swap_network_permutation(part_lens, acquaintance_size): n_qubits = sum(part_lens) gate = SwapNetworkGate(part_lens, acquaintance_size) expected_permutation = { i: j for i, j in zip(range(n_qubits), reversed(range(n_qubits))) } assert gate.permutation(n_qubits) == expected_permutation def test_swap_network_permutation_error(): gate = SwapNetworkGate((1, 1)) with pytest.raises(ValueError):
def _testInferenceFromHandcraftedExampleWithKEqualingQ(self): print("Fully handcrafted example, K=Q") rd.seed(0xC0FFEE) # Global init for repeatable test T = 100 # Vocabulary size, the number of "terms". Must be a square number Q = 6 # Topics: This cannot be changed without changing the code that generates the vocabulary K = 6 # Observed topics P = 8 # Features F = 12 # Observed features D = 200 # Sample documents (each with associated features) avgWordsPerDoc = 500 # The vocabulary. Presented graphically there are two with horizontal bands # (upper lower); two with vertical bands (left, right); and two with # horizontal bands (inside, outside) vocab = makeSixTopicVocab(T) # Create our (sparse) features X, then our topic proportions ("tpcs") # then our word counts W lmda = np.zeros((D, K)) X = np.zeros((D, F)) for d in range(D): for _ in range(3): lmda[d, rd.randint(K)] += 1. / 3 for _ in range(int(F / 3)): X[d, rd.randint(F)] += 1 A = rd.random((K, F)) X = lmda.dot(la.pinv(A).T) X = ssp.csr_matrix(X) tpcs = lmda docLens = rd.poisson(avgWordsPerDoc, (D, )) W = tpcs.dot(vocab) W *= docLens[:, np.newaxis] W = np.array(W, dtype=np.int32) # truncate word counts to integers W = ssp.csr_matrix(W) # # Now finally try to train the model # modelState = newVbModelState(K, Q, F, P, T) (trainedState, queryState) = train(modelState, X, W, logInterval=1, iterations=1) tpcs_inf = rowwise_softmax(safe_log(queryState.expLmda)) W_inf = np.array(tpcs_inf.dot(trainedState.vocab) * queryState.docLen[:, np.newaxis], dtype=np.int32) priorReconsError = np.sum(np.square(W - W_inf)) / D (trainedState, queryState) = train(modelState, X, W, logInterval=1, plotInterval=100, iterations=130) tpcs_inf = rowwise_softmax(safe_log(queryState.expLmda)) W_inf = np.array(tpcs_inf.dot(trainedState.vocab) * queryState.docLen[:, np.newaxis], dtype=np.int32) print("Model Driven: Prior Reconstruction Error: %f" % (priorReconsError, )) print("Model Driven: Final Reconstruction Error: %f" % (np.sum(np.square(W - W_inf)) / D, )) print("End of Test")
def _testInferenceFromHandcraftedExample(self): print("Partially hand-crafted example") rd.seed(0xC0FFEE) # Global init for repeatable test T = 100 # Vocabulary size, the number of "terms". Must be a square number Q = 6 # Topics: This cannot be changed without changing the code that generates the vocabulary K = 10 # Observed topics P = 8 # Features F = 12 # Observed features D = 200 # Sample documents (each with associated features) avgWordsPerDoc = 500 # Determine what A, U, Y and V should be U = rd.random((K, Q)) Y = rd.random((Q, P)) V = rd.random((F, P)) A = U.dot(Y).dot(V.T) # The vocabulary. Presented graphically there are two with horizontal bands # (upper lower); two with vertical bands (left, right); and two with # horizontal bands (inside, outside) vocab = makeSixTopicVocab(T) # Create our (sparse) features X, then our topic proportions ("tpcs") # then our word counts W X_low = np.array([1 if rd.random() < 0.3 else 0 for _ in range(D * P)]).reshape(D, P) X = ssp.csr_matrix(X_low.dot(V.T)) lmda_low = X_low.dot(Y.T) print("lmda_low.mean() = %f" % (lmda_low.mean())) tpcs = rowwise_softmax(lmda_low) docLens = rd.poisson(avgWordsPerDoc, (D, )) W = tpcs.dot(vocab) W *= docLens[:, np.newaxis] W = np.array(W, dtype=np.int32) # truncate word counts to integers W = ssp.csr_matrix(W) # # Now finally try to train the model # modelState = newVbModelState(K, Q, F, P, T) (trainedState, queryState) = train(modelState, X, W, logInterval=1, plotInterval=10, iterations=10) tpcs_inf = rowwise_softmax(np.log(queryState.expLmda)) W_inf = np.array(tpcs_inf.dot(trainedState.vocab) * queryState.docLen[:, np.newaxis], dtype=np.int32) print("Handcrafted Test-Case") print( "=====================================================================" ) print( "Average, squared, per-element difference between true and estimated:" ) print(" Topic Distribution: %f" % (np.sum(np.square(tpcs.dot(U.T) - tpcs_inf)) / len(tpcs), )) print(" Vocab Distribution: %f" % (np.sum(np.square(U.dot(vocab) - trainedState.vocab)) / len(vocab), )) print( "Average absolute difference between true and reconstructed documents" ) print(" Documents: %f" % (np.sum(np.abs(W.todense() - W_inf)) / np.sum(W.todense()), )) print("End of Test")
def game_loop(self): '''This is called every game tick. You call this in a loop until it returns false, which means you hit a tree trunk, fell off the bottom of the screen, or jumped off the top of the screen. It calls the action and reward callbacks.''' # Render the background. self.screen.blit(self.background_img, (self.iter, 0)) if self.iter < self.background_img.get_width() - self.screen_width: self.screen.blit(self.background_img, (self.iter + self.background_img.get_width(), 0)) # Perhaps generate a new tree. if self.next_tree <= 0: self.next_tree = self.tree_img.get_width() + int( npr.geometric(1.0 / self.tree_mean)) self.trees.append({ 'x': self.screen_width + 1, 'y': int((0.3 + npr.rand() * 0.65) * (self.screen_height - self.tree_gap)), 's': False }) # Process input events. for event in pg.event.get(): if event.type == pg.QUIT: sys.exit() elif self.action_fn is None and event.type == pg.KEYDOWN: self.vel = npr.poisson(self.impulse) self.hook = self.screen_width # Perhaps take an action via the callback. if self.action_fn is not None and self.action_fn(self.get_state()): self.vel = npr.poisson(self.impulse) self.hook = self.screen_width # Eliminate trees that have moved off the screen. self.trees = filter(lambda x: x['x'] > -self.tree_img.get_width(), self.trees) # Monkey dynamics self.monkey_loc -= self.vel self.vel -= self.gravity # Current monkey bounds. monkey_top = self.monkey_loc - self.monkey_img.get_height() / 2 monkey_bot = self.monkey_loc + self.monkey_img.get_height() / 2 # Move trees to the left, render and compute collision. self.next_tree -= self.horz_speed edge_hit = False tree_hit = False pass_tree = False for tree in self.trees: tree['x'] -= self.horz_speed # Render tree. self.screen.blit(self.tree_img, (tree['x'], self.tree_offset)) # Render gap in tree. self.screen.blit(self.background_img, (tree['x'], tree['y']), (tree['x'] - self.iter, tree['y'], self.tree_img.get_width(), self.tree_gap)) if self.iter < self.background_img.get_width() - self.screen_width: self.screen.blit( self.background_img, (tree['x'], tree['y']), (tree['x'] - (self.iter + self.background_img.get_width()), tree['y'], self.tree_img.get_width(), self.tree_gap)) trunk_left = tree['x'] + 215 trunk_right = tree['x'] + 290 trunk_top = tree['y'] trunk_bot = tree['y'] + self.tree_gap # Compute collision. if (((trunk_left < (self.monkey_left + 15)) and (trunk_right > (self.monkey_left + 15))) or ((trunk_left < self.monkey_right) and (trunk_right > self.monkey_right))): #pg.draw.rect(self.screen, (255,0,0), (trunk_left, trunk_top, trunk_right-trunk_left, trunk_bot-trunk_top), 1) #pg.draw.rect(self.screen, (255,0,0), (self.monkey_left+15, monkey_top, self.monkey_img.get_width()-15, monkey_bot-monkey_top), 1) if (monkey_top < trunk_top) or (monkey_bot > trunk_bot): tree_hit = True # Keep score. if not tree['s'] and (self.monkey_left + 15) > trunk_right: tree['s'] = True self.score += 1 global maxscore if self.score > maxscore: maxscore = self.score pass_tree = True if self.sound: self.blop_snd.play() # Monkey swings down on a vine. if self.vel < 0: pg.draw.line(self.screen, (92, 64, 51), (self.screen_width / 2 + 20, self.monkey_loc - 25), (self.hook, 0), 4) # Render the monkey. self.screen.blit(self.monkey_img, (self.monkey_left, monkey_top)) # Fail on hitting top or bottom. if monkey_bot > self.screen_height or monkey_top < 0: edge_hit = True # Render the score score_text = self.font.render("Score: %d" % (self.score), 1, (230, 40, 40)) self.screen.blit(score_text, score_text.get_rect()) global maxscore maxscore_text = self.font.render("MaxScore: %d" % (maxscore), 1, (230, 40, 40)) textpos = maxscore_text.get_rect() self.screen.blit( maxscore_text, (self.screen_width - 2.6 * textpos[2], 0, textpos[2], textpos[3])) if self.text is not None: text = self.font.render(self.text, 1, (230, 40, 40)) textpos = text.get_rect() self.screen.blit( text, (self.screen_width - textpos[2], 0, textpos[2], textpos[3])) # Render the display. pg.display.update() # If failed, play sound and exit. Also, assign rewards. if edge_hit: if self.sound: ch = self.screech_snd.play() while ch.get_busy(): pg.time.delay(500) if self.reward_fn is not None: self.reward_fn(self.edge_penalty) if self.action_fn is not None: self.action_fn(self.get_state()) return False if tree_hit: if self.sound: ch = self.screech_snd.play() while ch.get_busy(): pg.time.delay(500) if self.reward_fn is not None: self.reward_fn(self.tree_penalty) if self.action_fn is not None: self.action_fn(self.get_state()) return False if self.reward_fn is not None: if pass_tree: self.reward_fn(self.tree_reward) else: self.reward_fn(0.0) # Wait just a bit. pg.time.delay(self.tick_length) # Move things. self.hook -= self.horz_speed self.iter -= self.horz_speed if self.iter < -self.background_img.get_width(): self.iter += self.background_img.get_width() return True
def randomPCR_with_ErrorsAndBias_FASTv2(self, slctdSeqs, seqLength, pcrCycleNum, pcrYld, errorRate, aptamerSeqs, alphabetSet, distance): # initialize Mutation object from class mut = Mutation(seqLength=seqLength, errorRate=errorRate, pcrCycleNum=pcrCycleNum, pcrYld=pcrYld) totalseqs = 0 uniqSeqs = 0 #compute total seq num, unique seq num, and transfer info to x for i, seqIdx in enumerate(slctdSeqs): uniqSeqs += 1 totalseqs += int(slctdSeqs[seqIdx][0]) #initialize matrix to hold info for amplified pool x = np.zeros((uniqSeqs, pcrCycleNum + 4)) for i, seqIdx in enumerate(slctdSeqs): x[i][0] = seqIdx x[i][1] = slctdSeqs[seqIdx][0] x[i][2] = slctdSeqs[seqIdx][1] x[i][3] = slctdSeqs[seqIdx][2] print( "number of unique seqs in selected pool prior to amplification: " + str(uniqSeqs)) print("number of seqs in selected pool prior to amplification: " + str(totalseqs)) # calculate probabilities of different possible mutation numbers mutNumProbs = mut.get_mutation_probabilities_original() # compute a discrete distribution of mutation numbers mutDist = mut.get_mutation_distribution_original() print("Discrete Mutation Distribution has been computed") # PCR Amplification totalseqs = 0 # initialize dictionary to keep info on seqs to be mutated mutatedPool = {} #initialize matrix to hold info for mutation pool y = np.zeros((uniqSeqs, seqLength + 1)) # keep track of sequence count after each pcr cycle (except last one) seqPop = np.zeros(pcrCycleNum) # compute cycle number probabilities for this seq cycleNumProbs = np.zeros(pcrCycleNum) print("Amplification has started...") # for each sequence in the selected pool for i, seqIdx in enumerate(slctdSeqs): # random PCR with bias using brute force for n in xrange(pcrCycleNum): # sequence count after n cycles seqPop[n] = x[i][1] # amplify count using initial count, polymerase yield, and bias score x[i][1] += int(binom(x[i][1], pcrYld + x[i][3])) # compute cycle number probabilities for s, seqNum in enumerate(seqPop): cycleNumProbs[s] = seqNum / np.sum(seqPop) # transfer info to x for j, cycleNumProb in enumerate(cycleNumProbs): x[i][j + 4] = cycleNumProb # update total num of seqs totalseqs += x[i][1] # transfer info from x to selection pool slctdSeqs[int(x[i][0])] = x[i][1:] #tranfer seq index to matrix y y[i][0] = x[i][0] #if accumulated seq count is greater than 10,000 if np.sum(seqPop) > 10000: # for each possible number of mutations in any seq copy (1-seqLength) for mutNum in xrange(seqLength): #approximate the proportion of copies that will be mutated using #corresponding probability p(M=mutNum) y[i][mutNum + 1] = mutNumProbs[mutNum + 1] * np.sum(seqPop) # if seq count is less than 10,000 else: # draw random mutNum from the mutation distribution for each seq copy muts = poisson(errorRate * seqLength, int(np.sum(seqPop))) #SLOW STEP # remove all drawn numbers equal to zero muts = muts[muts != 0] # for each non-zero mutation number for mutNum in muts: #increment copy number to be mutated y[i][mutNum + 1] += 1 del (x) gc.collect() print("Amplification carried out") print("Sequence selection for mutation has started...") #remove all mutation numbers with zero copies to be mutated y = y[y[:, 1] != 0] #for each seq to be mutated for mutInfo in y: #add to mutation pool with it's corresponding mutation info mutatedPool[int(mutInfo[0])] = mutInfo[1:][mutInfo[1:] != 0] del (y) gc.collect() print("Mutation selection has been carried out") print("Mutant generation has started...") if (distance == "hamming"): # generate mutants and add to the amplfied sequence pool amplfdSeqs = mut.generate_mutants_1D(mutatedPool=mutatedPool, amplfdSeqs=slctdSeqs, aptamerSeqs=aptamerSeqs, alphabetSet=alphabetSet) del (slctdSeqs) del (mutatedPool) gc.collect() elif (distance == "basepair"): amplfdSeqs = mut.generate_mutants_2D(mutatedPool=mutatedPool, amplfdSeqs=slctdSeqs, aptamerSeqs=aptamerSeqs, alphabetSet=alphabetSet) del (slctdSeqs) del (mutatedPool) gc.collect() elif (distance == "loop"): amplfdSeqs = mut.generate_mutants_loop(mutatedPool=mutatedPool, amplfdSeqs=slctdSeqs, aptamerSeqs=aptamerSeqs, alphabetSet=alphabetSet) del (slctdSeqs) del (mutatedPool) gc.collect() else: print("argument given for distance is invalid") return print("Mutation has been carried out") return amplfdSeqs
def zdist(zmin, zmax, time=365.25, area=1., ratefunc=lambda z: 1.e-4, cosmo=FlatLambdaCDM(H0=70.0, Om0=0.3)): """Generate a distribution of redshifts. Generates the correct redshift distribution and number of SNe, given the input volumetric SN rate, the cosmology, and the observed area and time. Parameters ---------- zmin, zmax : float Minimum and maximum redshift. time : float, optional Time in days (default is 1 year). area : float, optional Area in square degrees (default is 1 square degree). ``time`` and ``area`` are only used to determine the total number of SNe to generate. ratefunc : callable A callable that accepts a single float (redshift) and returns the comoving volumetric rate at each redshift in units of yr^-1 Mpc^-3. The default is a function that returns ``1.e-4``. cosmo : `~astropy.cosmology.Cosmology`, optional Cosmology used to determine volume. The default is a FlatLambdaCDM cosmology with ``Om0=0.3``, ``H0=70.0``. Examples -------- Loop over the generator: >>> for z in zdist(0.0, 0.25): ... print(z) ... 0.151285827576 0.204078030595 0.201009196731 0.181635472172 0.17896188781 0.226561237264 0.192747368762 This tells us that in one observer-frame year, over 1 square degree, 7 SNe occured at redshifts below 0.35 (given the default volumetric SN rate of 10^-4 SNe yr^-1 Mpc^-3). The exact number is drawn from a Poisson distribution. Generate the full list of redshifts immediately: >>> zlist = list(zdist(0., 0.25)) Define a custom volumetric rate: >>> def snrate(z): ... return 0.5e-4 * (1. + z) ... >>> zlist = list(zdist(0., 0.25, ratefunc=snrate)) """ # Get comoving volume in each redshift shell. z_bins = 100 # Good enough for now. z_binedges = np.linspace(zmin, zmax, z_bins + 1) z_binctrs = 0.5 * (z_binedges[1:] + z_binedges[:-1]) sphere_vols = cosmo.comoving_volume(z_binedges).value shell_vols = sphere_vols[1:] - sphere_vols[:-1] # SN / (observer year) in shell shell_snrate = np.array([ shell_vols[i] * ratefunc(z_binctrs[i]) / (1. + z_binctrs[i]) for i in range(z_bins) ]) # SN / (observer year) within z_binedges vol_snrate = np.zeros_like(z_binedges) vol_snrate[1:] = np.add.accumulate(shell_snrate) # Create a ppf (inverse cdf). We'll use this later to get # a random SN redshift from the distribution. snrate_cdf = vol_snrate / vol_snrate[-1] snrate_ppf = Spline1d(snrate_cdf, z_binedges, k=1) # Total numbe of SNe to simulate. nsim = vol_snrate[-1] * (time / 365.25) * (area / WHOLESKY_SQDEG) for i in range(random.poisson(nsim)): yield float(snrate_ppf(random.random()))
def game_loop(self): '''This is called every game tick. You call this in a loop until it returns false, which means you hit a tree trunk, fell off the bottom of the screen, or jumped off the top of the screen. It calls the action and reward callbacks.''' # Perhaps generate a new tree. if self.next_tree <= 0: self.next_tree = self.tree_width * 5 + int( npr.geometric(1.0 / self.tree_mean)) self.trees.append({ 'x': self.screen_width + 1, 'y': int((0.3 + npr.rand() * 0.65) * (self.screen_height - self.tree_gap)), 's': False }) # Perhaps take an action via the callback. if self.action_fn is not None and self.action_fn(self.get_state()): self.vel = npr.poisson(self.impulse) # Eliminate trees that have moved off the screen. self.trees = [x for x in self.trees if x['x'] > -self.tree_width] # Monkey dynamics self.monkey_loc -= self.vel self.vel -= self.gravity # Current monkey bounds. monkey_top = self.monkey_loc - self.monkey_height / 2 monkey_bot = self.monkey_loc + self.monkey_height / 2 # Move trees to the left, render and compute collision. self.next_tree -= self.horz_speed edge_hit = False tree_hit = False pass_tree = False for tree in self.trees: tree['x'] -= self.horz_speed trunk_left = tree['x'] trunk_right = tree['x'] + self.tree_width trunk_top = tree['y'] trunk_bot = tree['y'] + self.tree_gap # Compute collision. if (((trunk_left < (self.monkey_left + 15)) and (trunk_right > (self.monkey_left + 15))) or ((trunk_left < self.monkey_right) and (trunk_right > self.monkey_right))): if (monkey_top < trunk_top) or (monkey_bot > trunk_bot): tree_hit = True # Keep score. if not tree['s'] and (self.monkey_left + 15) > trunk_right: tree['s'] = True self.score += 1 pass_tree = True # Fail on hitting top or bottom. if monkey_bot > self.screen_height or monkey_top < 0: edge_hit = True # If failed, exit. Also, assign rewards. if edge_hit: if self.reward_fn is not None: self.reward_fn(self.edge_penalty) if self.action_fn is not None: self.action_fn(self.get_state()) return False if tree_hit: if self.reward_fn is not None: self.reward_fn(self.tree_penalty) if self.action_fn is not None: self.action_fn(self.get_state()) return False if self.reward_fn is not None: if pass_tree: self.reward_fn(self.tree_reward) else: self.reward_fn(0.0) return True
def get_image(image_parameters): """Generate image with particles. Input: image_parameters: list with the values of the image parameters in a dictionary: image_parameters['Particle Center X List'] image_parameters['Particle Center Y List'] image_parameters['Particle Radius List'] image_parameters['Particle Bessel Orders List'] image_parameters['Particle Intensities List'] image_parameters['Image Size'] image_parameters['Image Background Level'] image_parameters['Signal to Noise Ratio'] image_parameters['Gradient Intensity'] image_parameters['Gradient Direction'] image_parameters['Ellipsoid Orientation'] image_parameters['Ellipticity'] Note: image_parameters is typically obained from the function get_image_parameters() Output: image: image of the particle [2D numpy array of real numbers betwen 0 and 1] """ from numpy import meshgrid, arange, ones, zeros, sin, cos, sqrt, clip, array, ceil, mean, amax, asarray, amin from numpy.random import normal, poisson from math import e from scipy.special import jv as bessel import warnings particle_center_x_list = image_parameters['Particle Center X List'] particle_center_y_list = image_parameters['Particle Center Y List'] particle_radius_list = image_parameters['Particle Radius List'] particle_bessel_orders_list = image_parameters[ 'Particle Bessel Orders List'] particle_intensities_list = image_parameters['Particle Intensities List'] image_size = image_parameters['Image Size'] image_background_level = image_parameters['Image Background Level'] signal_to_noise_ratio = image_parameters['Signal to Noise Ratio'] gradient_intensity = image_parameters['Gradient Intensity'] gradient_direction = image_parameters['Gradient Direction'] ellipsoidal_orientation_list = image_parameters['Ellipsoid Orientation'] ellipticity = image_parameters['Ellipticity'] ### CALCULATE BACKGROUND # initialize the image at the background level image_background = ones((image_size, image_size)) * image_background_level # calculate matrix coordinates from the center of the image image_coordinate_x, image_coordinate_y = meshgrid(arange(0, image_size), arange(0, image_size), sparse=False, indexing='ij') # add gradient to image background image_background = image_background + gradient_intensity * ( image_coordinate_x * sin(gradient_direction) + image_coordinate_y * cos(gradient_direction)) / (sqrt(2) * image_size) ### CALCULATE IMAGE PARTICLES image_particles = zeros((image_size, image_size)) particle_intensities_for_SNR = [] # calculate the particle profiles of all particles and add them to image_particles for particle_center_x, particle_center_y, particle_radius, particle_bessel_orders, particle_intensities, ellipsoidal_orientation in zip( particle_center_x_list, particle_center_y_list, particle_radius_list, particle_bessel_orders_list, particle_intensities_list, ellipsoidal_orientation_list): # calculate coordinates of cutoff window start_x = int(max(ceil(particle_center_x - particle_radius * 3), 0)) stop_x = int( min(ceil(particle_center_x + particle_radius * 3), image_size)) start_y = int(max(ceil(particle_center_y - particle_radius * 3), 0)) stop_y = int( min(ceil(particle_center_y + particle_radius * 3), image_size)) # calculate matrix coordinates from the center of the image image_coordinate_x, image_coordinate_y = meshgrid( arange(start_x, stop_x), arange(start_y, stop_y), sparse=False, indexing='ij') # calculate the elliptical distance from the center of the particle normalized by the particle radius rotated_distance_x = (image_coordinate_x - particle_center_x) * cos( ellipsoidal_orientation) + (image_coordinate_y - particle_center_y ) * sin(ellipsoidal_orientation) rotated_distance_y = -(image_coordinate_x - particle_center_x) * sin( ellipsoidal_orientation) + (image_coordinate_y - particle_center_y ) * cos(ellipsoidal_orientation) # The factor 2 is because the particle radius is defined as the point where the intensity reaches 1/3 of # the intensity in the middle of the particle when Bessel order = 0. When Bessel order = 1, the middle of # the particle is black, and at the radius the intensity is approximately at its maximum. For higher # Bessel orders, there is no clear definition of the radius. elliptical_distance_from_particle = 2 * sqrt( (rotated_distance_x)**2 + (rotated_distance_y / ellipticity)**2 + .001**2) / particle_radius # calculate particle profile. for particle_bessel_order, particle_intensity in zip( particle_bessel_orders, particle_intensities): image_particle = 4 * particle_bessel_order**2.5 * ( bessel(particle_bessel_order, elliptical_distance_from_particle) / elliptical_distance_from_particle)**2 image_particles[start_x:stop_x, start_y:stop_y] = image_particles[ start_x:stop_x, start_y:stop_y] + particle_intensity * image_particle # calculate image without noise as background image plus particle image image_particles_without_noise = clip(image_background + image_particles, 0, 1) ### ADD NOISE image_particles_with_noise = poisson( image_particles_without_noise * signal_to_noise_ratio**2) / signal_to_noise_ratio**2 cut_off_pixels = tuple([image_particles_with_noise > 1]) percentage_of_pixels_that_were_cut_off = image_particles_with_noise[ cut_off_pixels].size / (image_size**2) * 100 # warn if there is a pixel brighter than 1 def custom_formatwarning(msg, *args, **kwargs): # ignore everything except the message return str(msg) + '\n' if percentage_of_pixels_that_were_cut_off > 0: warnings.formatwarning = custom_formatwarning warn_message = ( "Warning: %.5f%% of the pixels in the generated image are brighter than the 1 (%d pixels)! " "These were cut-off to the max value 1. Consider adjusting your gradient intensity, particle " "intensity, background level, or signal to noise ratio." % (percentage_of_pixels_that_were_cut_off, image_particles_with_noise[cut_off_pixels].size)) warnings.warn(warn_message) # print("After poisson: Min is %.4f, Max is %.4f" % (amin(image_particles_with_noise), # amax(image_particles_with_noise))) return clip(image_particles_with_noise, 0, 1)
def run_simulation(self): simulation_time = int( input('For how long, in hours, should the simulation be run? ')) simulation_limit = simulation_time * 3600 q = queue_adt.Queue() nb_of_customers = 0 cumulative_queue_length = 0 cumulative_waiting_length = 0 # A service time of -1 indicates that nobody is being served, which can only happen # if the queue is empty, possibly following the departure of the last served customer. service_time = -1 cumulative_waiting_time = 0 cumulative_waiting_and_serving_time = 0 for simulation_tick in range(simulation_limit): new_customers = poisson(1 / self.average_time_between_two_arrivals) nb_of_customers += new_customers for _ in range(new_customers): customer = Customer() customer.arrival_time = simulation_tick customer.service_time = round( exponential(self.average_service_time)) q.enqueue(customer) # A new customer can now start being served. if service_time == -1 and not q.is_empty(): service_time = q.peek_at_front().service_time cumulative_waiting_time += simulation_tick - q.peek_at_front( ).arrival_time # If the customer at the front has been served, then she should now quit the queue # and all customers that follow her and that need no time to be served should follow # her (these guys have been queuing for a while just to find out that they do not # have an indispensible piece of information when they are about to be served; # surely, they are pretty upset when they quit the queue). while service_time == 0: cumulative_waiting_and_serving_time += simulation_tick - q.dequeue( ).arrival_time if not q.is_empty(): service_time = q.peek_at_front().service_time cumulative_waiting_time += simulation_tick - q.peek_at_front( ).arrival_time else: service_time = -1 cumulative_queue_length += len(q) if not q.is_empty(): service_time -= 1 cumulative_waiting_length += len(q) - 1 if nb_of_customers: print( f'Number of customers who have joinded the queue: {round(nb_of_customers, 2)}' ) print( 'Average number of customers in queue including those being served: ' f'{round(cumulative_queue_length / simulation_limit, 2)}') print('Average number of customers in queue waiting to be served: ' f'{round(cumulative_waiting_length / simulation_limit, 2)}') print('Average waiting time, including serving time:', end='') self.display_time(cumulative_waiting_and_serving_time / nb_of_customers) print('Average waiting time, excluding serving time:', end='') self.display_time(cumulative_waiting_time / nb_of_customers) else: print('No one has joined the queue; a very quiet day...')
# Seed the RNG rng.seed(0) # Publication time and current time t_start = 2.2 t_end = 100.7 duration = t_end - t_start # True parameter values lambda_tips = 0.5 mu_tips = 1.0 sig_log_tips = 1.9 # Arrival times of tips from poisson process expected_num_tips = lambda_tips * duration num_tips = rng.poisson(expected_num_tips) # Uniform distribution for times given number times = t_start + duration * rng.rand(num_tips) times = np.sort(times) # Amounts of tips amounts = mu_tips * np.exp(sig_log_tips * rng.randn(num_tips)) # Save data as YAML f = open("example_data.yaml", "w") f.write("---\n") f.write("t_start: " + str(t_start) + "\n") f.write("t_end: " + str(t_end) + "\n") f.write("times:\n") for i in range(num_tips):
print('Starting simulation') for t in xrange(len(T)): sl, sr = env.read_sensors(x[t], y[t], w[t]) # Reset the neuron firings tab, but carry over those firings that may not have yet reached their # target. Pull the time back to mark these firings as now negative. for layer_index, layer in vehicle.net.layers.items(): firings = [[f[0] - dt, f[1]] for f in layer.firings if f[0] > dt - max_conduction_delay] layer.firings = np.array(firings) for t2 in xrange(dt): vehicle.net.layers[0].I = rn.poisson(sl * 15, vehicle.net.layers[0].N) vehicle.net.layers[1].I = rn.poisson(sr * 15, vehicle.net.layers[1].N) vehicle.net.layers[2].I = 5 * rn.randn(vehicle.net.layers[2].N) vehicle.net.layers[3].I = 5 * rn.randn(vehicle.net.layers[3].N) vehicle.net.tick(t2) for layer_index, layer in vehicle.net.layers.items(): membrane_potentials[layer_index][t2, :] = layer.V for layer_index, layer in vehicle.net.layers.items(): layer.firings = np.array(filter(lambda f: f[0] > 0, layer.firings)) rl = 1.0 * len( vehicle.net.layers[2].firings) / dt / vehicle.net.layers[2].N * 1000
def _testOnModelHandcraftedData(self): # # Create the vocab # T = 3 * 3 K = 5 # Horizontal bars vocab1 = ssp.coo_matrix(([1, 1, 1], ([0, 0, 0], [0, 1, 2])), shape=(3,3)).todense() #vocab2 = ssp.coo_matrix(([1, 1, 1], ([1, 1, 1], [0, 1, 2])), shape=(3,3)).todense() vocab3 = ssp.coo_matrix(([1, 1, 1], ([2, 2, 2], [0, 1, 2])), shape=(3,3)).todense() # Vertical bars vocab4 = ssp.coo_matrix(([1, 1, 1], ([0, 1, 2], [0, 0, 0])), shape=(3,3)).todense() #vocab5 = ssp.coo_matrix(([1, 1, 1], ([0, 1, 2], [1, 1, 1])), shape=(3,3)).todense() vocab6 = ssp.coo_matrix(([1, 1, 1], ([0, 1, 2], [2, 2, 2])), shape=(3,3)).todense() # Diagonals vocab7 = ssp.coo_matrix(([1, 1, 1], ([0, 1, 2], [0, 1, 2])), shape=(3,3)).todense() #vocab8 = ssp.coo_matrix(([1, 1, 1], ([2, 1, 0], [0, 1, 2])), shape=(3,3)).todense() # Put together T = vocab1.shape[0] * vocab1.shape[1] vocabs = [vocab1, vocab3, vocab4, vocab6, vocab7] # Create a single matrix with the flattened vocabularies vocabVectors = [] for vocab in vocabs: vocabVectors.append (np.squeeze(np.asarray (vocab.reshape((1,T))))) vocab = normalizerows_ip(np.array(vocabVectors, dtype=DTYPE)) # Plot the vocab ones = np.ones(vocabs[0].shape) for k in range(K): plt.subplot(2, 3, k) plt.imshow(ones - vocabs[k], interpolation="none", cmap = cm.Greys_r) plt.show() # # Create the corpus # rd.seed(0xC0FFEE) D = 1000 # Make sense (of a sort) of this by assuming that these correspond to # Kittens Omelettes Puppies Oranges Tomatoes Dutch People Basketball Football #topicMean = np.array([10, 25, 5, 15, 5, 5, 10, 25]) # topicCovar = np.array(\ # [[ 100, 5, 55, 20, 5, 15, 4, 0], \ # [ 5, 100, 5, 10, 70, 5, 0, 0], \ # [ 55, 5, 100, 5, 5, 10, 0, 5], \ # [ 20, 10, 5, 100, 30, 30, 20, 10], \ # [ 5, 70, 5, 30, 100, 0, 0, 0], \ # [ 15, 5, 10, 30, 0, 100, 10, 40], \ # [ 4, 0, 0, 20, 0, 10, 100, 20], \ # [ 0, 0, 5, 10, 0, 40, 20, 100]], dtype=DTYPE) / 100.0 topicMean = np.array([25, 15, 40, 5, 15]) self.assertEqual(100, topicMean.sum()) topicCovar = np.array(\ [[ 100, 5, 55, 20, 5 ], \ [ 5, 100, 5, 10, 70 ], \ [ 55, 5, 100, 5, 5 ], \ [ 20, 10, 5, 100, 30 ], \ [ 5, 70, 5, 30, 100 ], \ ], dtype=DTYPE) / 100.0 meanWordCount = 80 wordCounts = rd.poisson(meanWordCount, size=D) topicDists = rd.multivariate_normal(topicMean, topicCovar, size=D) W = topicDists.dot(vocab) * wordCounts[:, np.newaxis] W = ssp.csr_matrix (W.astype(DTYPE)) # # Train the model # model = ctm.newModelAtRandom(W, K, dtype=DTYPE) queryState = ctm.newQueryState(W, model) trainPlan = ctm.newTrainPlan(iterations=65, plot=True, logFrequency=1) self.assertTrue (0.99 < np.sum(model.topicMean) < 1.01) return self._doTest (W, model, queryState, trainPlan)
# import the required libraries import numpy as np import matplotlib.pyplot as plt import random from numpy import random as rand # store the random numbers in a list nums = [] mu = 100 sigma = 25 for i in range(1000): #s = random.gauss(mu,sigma) s = rand.poisson(3, 1) print(s[0]) nums.append(s[0]) # plotting a graph plt.hist(nums, bins=200) plt.show()
D_sorted = np.zeros(np.shape(A)) np.fill_diagonal(D_sorted, sorted_lambda_A) D_sorted_inv = 1 / D_sorted D_sorted_inv[np.isinf(D_sorted_inv)] = 0 U_sorted = swap(U, swaps) U_sorted_inv = U_sorted.T #A_ = U_sorted @ D_sorted @ U_sorted_inv #A_[A_<0.01]=0 #print(A_-A<0.01) #d) rand.seed(230) g_mess = rand.poisson(g, size=(1, 20)) print("g_{mess} = ") print(np.mean(g_mess, axis=0)) b_wahr = U_sorted_inv @ f_wahr b_mess = D_sorted_inv @ U_sorted_inv @ g_mess.T c = U_sorted_inv @ g c_mess = U_sorted_inv @ g_mess.T V_g_mess = np.zeros((20, 20)) np.fill_diagonal(V_g_mess, np.mean(g_mess, axis=0)) V_c_mess = U_sorted_inv @ V_g_mess @ U_sorted V_b_mess = D_sorted_inv @ V_c_mess @ D_sorted_inv
# The result, accuracy and computational time def table(rewardM): n_sample = rewardM.shape[0] game_size = rewardM.shape[1] LP_record = np.zeros((n_sample, 2), dtype=float) NN_record = np.zeros((n_sample, 2), dtype=float) for i in range(n_sample): LP_record[i, 0], LP_record[i, 1] = LP_NE(rewardM[i]) NN_record[i, 0], NN_record[i, 1] = CNN_NE(rewardM[i]) LP_mv, LP_mt = LP_record[:, 0].mean(), LP_record[:, 1].mean() NN_mv, NN_mt = NN_record[:, 0].mean(), NN_record[:, 1].mean() difference_NN = np.abs(LP_record[:, 0] - NN_record[:, 0]).mean() gap_NN = np.abs( (LP_record[:, 0] - NN_record[:, 0]) / NN_record[:, 0]).mean() print(f"** number sample: {n_sample}, game size: {game_size} **\n") print( f"Linear programming : mean time: {LP_mt:.4f}, mean value: {LP_mv:.4f} " ) print( f"Convolutinal Neural Network: mean time: {NN_mt:.4f}, mean value: {NN_mv:.4f}, mean gap: {gap_NN*100:.2f}%" ) rewardM = uniform(-10, 100, (100, 35, 35)) + normal(25, 3, (100, 35, 35)) + poisson( 35, (100, 35, 35)) table(rewardM)
def sleeptime(lmbda=MEAN_TIME, use_poisson=True): """Random time until next message.""" if use_poisson: return poisson(lmbda) else: return lmbda
def __call__(self): return nr.poisson(lam=self.s, size=np.size(self.s)) - self.s
def _sampleFromModel(self, D=200, T=100, K=10, Q=6, F=12, P=8, avgWordsPerDoc=500): ''' Create a test dataset according to the model Params: T - Vocabulary size, the number of "terms". Must be a square number Q - Latent Topics: K - Observed topics P - Latent features F - Observed features D - Sample documents (each with associated features) avgWordsPerDoc - average number of words per document generated (Poisson) Returns: modelState - a model state object configured for training tpcs - the matrix of per-document topic distribution vocab - the matrix of per-topic word distributions docLens - the vector of document lengths X - the DxF side information matrix W - The DxW word matrix ''' # Generate vocab beta = 0.1 betaVec = np.ndarray((T, )) betaVec.fill(beta) vocab = np.zeros((K, T)) for k in range(K): vocab[k, :] = rd.dirichlet(betaVec) # Generate U, then V, then A tau = 0.1 tsq = tau * tau (vSdRow, vSdCol) = (5.0, 5.0) (uSdRow, uSdCol) = (5.0, tau**2) # For the K-dimensions we use tsq (ySdRow, ySdCol) = (5.0, 5.0) (aSdRow, aSdCol) = (5.0, tau**2) U = matrix_normal(np.zeros((K, Q)), uSdRow * np.eye(Q), uSdCol * np.eye(K)) Y = matrix_normal(np.zeros((Q, P)), ySdRow * np.eye(P), ySdCol * np.eye(Q)) V = matrix_normal(np.zeros((F, P)), vSdRow * np.eye(P), vSdCol * np.eye(F)) A = matrix_normal( U.dot(Y).dot(V.T), aSdRow * np.eye(F), aSdCol * np.eye(K)) # Generate the input features. Assume the features are multinomial and sparse # (not quite a perfect match for the twitter example: twitter is binary, this # may not be) featuresDist = [1. / P] * P maxNonZeroFeatures = 3 X_low = np.zeros((D, P), dtype=np.float32) for d in range(D): X_low[d, :] = rd.multinomial(maxNonZeroFeatures, featuresDist) X = np.round(X_low.dot(V.T)) X = ssp.csr_matrix(X) # Use the features and the matrix A to generate the topics and documents tpcs = rowwise_softmax(X.dot(A.T)) docLens = rd.poisson(avgWordsPerDoc, (D, )).astype(np.float32) W = tpcs.dot(vocab) W *= docLens[:, np.newaxis] W = np.array(W, dtype=np.int32) # truncate word counts to integers W = ssp.csr_matrix(W) # Initialise the model modelState = newVbModelState(K, Q, F, P, T) # Return the initialised model, the true parameter values, and the # generated observations return modelState, tpcs, vocab, docLens, X, W
def run(self): while True: beta = 1 / self.rate t = poisson(beta) time.sleep(t) self.callback()