def __random_gen(self): if self.lsup == None and self.linf == None: return norm.rvs() elif self.lsup == None: return uniform.rvs(self.linf, 2.0*(self.linf+1)) elif self.linf == None: return uniform.rvs(self.lsup - self.lsup, self.lsup) return uniform.rvs(self.linf, self.lsup)
def random_initialization(self): self.genes = [] for i in range(self.size): self.genes.append(self.__random_gen()) self.sigma = [] for i in range(self.size): self.sigma.append(uniform.rvs())
def learn(self): """Learns about the world after receiving an award.""" # After an award, we choose some adjacencies and increase the # likelihood of their being chosen for a message next time # around. # The probability of choosing an adjacency to increase its # likelihood is proportional to the value of the award received. # Since at every step we choose at random from our list of # adjacencies, to increase the likelihood of one of them being # chosen, we need only add them again to this list, i.e., if my # adjacencies are [1,2,3] and sending a message to 2 was # successful, our new extended adjacency list is [1,2,3,2], and # when we choose uniformly from this list, we will be more # likely to choose 2 again. # self.log("learning on %d" % self.index) for adj in self.sent: assert adj in self.adjacencies u_val = uniform.rvs(0, 100, 1) # self.log("u_val is %d, learn? %r" % (u_val, u_val < self.value)) if u_val < self.value: self.adjacencies.append(adj) # import ipdb ; ipdb.set_trace() #z() # breakpoint f35d9e23 // self.log("Adj after: " + str(self.adjacencies))
def resize(self, size): curr_size = len(self.genes) if size > curr_size: for i in range(size-curr_size): self.genes.append(self.__random_gen()) self.sigma.append(uniform.rvs()) elif size < curr_size: self.genes = self.genes[:size] self.sigma = self.sigma[:size]
def mutate(self): # Mutate as a binary. sq = self.individual.genoma[0] q = sq.genes[0] data_set = self.individual.data_set pm = 1.0 / float(len(self.genes)) mut = 0.0 for i in range(len(self.genes)): x = uniform.rvs() if x < pm: mut += 1.0 self.genes[i] = data_set.get_nearest(self.get_gen(i), q, \ exclusion=self.genes) self.mutation_factor = mut/float(len(self.genes))
def test_add_noise(self): '''Test that noise is added predictably.''' # test uniform noise, seed for reproducibility inp_data = \ array([-1.875, -1.5 , -1.125, -0.75 , -0.375, 0., 0.375, 0.75 , 1.125, 1.5 , 1.875, 2.25 , 2.625, -3. , -2.625, -2.25 , -1.875, -1.5 , -1.125, -0.75 , -0.375, 0. , 0.375, 0.75 , 1.125]) nfap = [uniform, -.1, .2] seed(0) exp = uniform.rvs(-.1, .2, size=25) + inp_data seed(0) obs = add_noise(nfap, inp_data) assert_array_almost_equal(exp, obs)
def model2_otu(inducer_arr, rules): """Creates an OTU vector according to model 2 and given params. Inputs: inducer_arr - 2d array or OTU vectors which are inducing vectors for the created otu. rules - list of len(2) lists with l[0] float (amount to multiply by when creating new vector) and l[1] str ('self' or 'sum' where self means multiply l[0] times inducing OTU abundance and 'sum' means multiply l[0] by induced OTU abundance after all 'self' additions have been made). """ # create rule function which assigns to each inducer array input an output raw_otu_vals = array([model2_eval_rules(rules, i) for i in inducer_arr.T]) # add noise return uniform.rvs(0.9, 0.2, size=raw_otu_vals.shape[0]) * raw_otu_vals
def test_add_noise(self): '''Test that noise is added predictably.''' # test uniform noise, seed for reproducibility inp_data = \ array([-1.875, -1.5 , -1.125, -0.75 , -0.375, 0., 0.375, 0.75 , 1.125, 1.5 , 1.875, 2.25 , 2.625, -3. , -2.625, -2.25 , -1.875, -1.5 , -1.125, -0.75 , -0.375, 0. , 0.375, 0.75 , 1.125]) nfap = [uniform, -.1, .2] seed(0) exp = uniform.rvs(-.1, .2, size=25)+inp_data seed(0) obs = add_noise(nfap, inp_data) assert_array_almost_equal(exp, obs)
def model2_otu(inducer_arr, rules): """Creates an OTU vector according to model 2 and given params. Inputs: inducer_arr - 2d array or OTU vectors which are inducing vectors for the created otu. rules - list of len(2) lists with l[0] float (amount to multiply by when creating new vector) and l[1] str ('self' or 'sum' where self means multiply l[0] times inducing OTU abundance and 'sum' means multiply l[0] by induced OTU abundance after all 'self' additions have been made). """ # create rule function which assigns to each inducer array input an output raw_otu_vals = array([model2_eval_rules(rules, i) for i in inducer_arr.T]) # add noise return uniform.rvs(.9, .2, size=raw_otu_vals.shape[0]) * raw_otu_vals
def mutate(self): # Mutate as a binary. sq = self.individual.genoma[0] q = sq.genes[0] data_set = self.individual.data_set pm = 1.0 / float(len(self.genes)) mut = 0.0 for i in range(len(self.genes)): x = uniform.rvs() if x < pm: mut += 1.0 self.genes[i] = data_set.get_nearest(self.get_gen(i), q, \ exclusion=self.genes) self.mutation_factor = mut / float(len(self.genes))
def generate_otu_from_pt_in_R5(pt, wave_f, y_shift=None): """Generate an OTU sequence from a pt in R5.""" freq, amp, phase_offset, noise, sampling_params = pt # noise is from a uniform distribution where amp*noise controls noise level noise_func_and_params = [uniform, -noise * amp, 2 * noise * amp] # if y_pos is none we will randomly select the y_shift for the signal # between 50 percent of amplitude and 150 percent of amplitude if y_shift == None: y_shift = uniform.rvs(0.5 * amp, 1.5 * amp) # make the base otu + y_shift base_otu = y_shift + signal(amp, freq, phase_offset, wave_f, sampling_freq=100, lb=0, ub=2 * pi) # add noise noisy_otu = add_noise(noise_func_and_params, base_otu) # subsample the otu according to the sampling_f and params sampling_f = sampling_params[0] return sampling_f(noisy_otu, *sampling_params[1:])
def generate_otu_from_pt_in_R5(pt, wave_f, y_shift=None): '''Generate an OTU sequence from a pt in R5.''' freq, amp, phase_offset, noise, sampling_params = pt # noise is from a uniform distribution where amp*noise controls noise level noise_func_and_params = [uniform, -noise * amp, 2 * noise * amp] # if y_pos is none we will randomly select the y_shift for the signal # between 50 percent of amplitude and 150 percent of amplitude if y_shift == None: y_shift = uniform.rvs(.5 * amp, 1.5 * amp) # make the base otu + y_shift base_otu = y_shift + signal( amp, freq, phase_offset, wave_f, sampling_freq=100, lb=0, ub=2 * pi) # add noise noisy_otu = add_noise(noise_func_and_params, base_otu) # subsample the otu according to the sampling_f and params sampling_f = sampling_params[0] return sampling_f(noisy_otu, *sampling_params[1:])
def model1_otu(inducer_arr, df_and_params, weights, rules): """Creates an OTU vector according to model 1 and given params. Inputs: inducer_arr - 2d array or OTU vectors which are inducing vectors for the created otu. df_and_params - list with [0]=scipy.stats.distribution func, and following entries params for the df in proper order. weight_arr - arr, prob(out_vector[i]!=0 | x rules satisfied). weight arr is len(rules)+1 for model 1. The reason for the +1 is that if no rules are specified, a base probability for occurrence of the OTU is still needed. rules - list of len(2) lists with l[0]=lower bound, l[1] upper bound for rule evaluation. """ num_samples = inducer_arr.shape[1] # random draw from distribution according to parameters unweighted_draw = df_and_params[0].rvs(*df_and_params[1:], size=num_samples) # find out number of conditions satisfied and create uniform draw matrix. cs = [model1_eval_rules(rules, otu_vals) for otu_vals in inducer_arr.T] # draw from uniform distribution and weight according to weights matrix. res = where(uniform.rvs(0, 1, size=num_samples) > 1 - weights.take(cs), 1.0, 0) # multiply element wise to produce output vector return (res * unweighted_draw).astype(int)
def model1_otu(inducer_arr, df_and_params, weights, rules): """Creates an OTU vector according to model 1 and given params. Inputs: inducer_arr - 2d array or OTU vectors which are inducing vectors for the created otu. df_and_params - list with [0]=scipy.stats.distribution func, and following entries params for the df in proper order. weight_arr - arr, prob(out_vector[i]!=0 | x rules satisfied). weight arr is len(rules)+1 for model 1. The reason for the +1 is that if no rules are specified, a base probability for occurrence of the OTU is still needed. rules - list of len(2) lists with l[0]=lower bound, l[1] upper bound for rule evaluation. """ num_samples = inducer_arr.shape[1] # random draw from distribution according to parameters unweighted_draw = df_and_params[0].rvs(*df_and_params[1:], size=num_samples) # find out number of conditions satisfied and create uniform draw matrix. cs = [model1_eval_rules(rules, otu_vals) for otu_vals in inducer_arr.T] # draw from uniform distribution and weight according to weights matrix. res = where( uniform.rvs(0, 1, size=num_samples) > 1 - weights.take(cs), 1., 0) # multiply element wise to produce output vector return (res * unweighted_draw).astype(int)
def _rvs(self, c, a, b): probs = self._delta * uniform.rvs(size=self._size) + self._Fa return loggamma.ppf(probs, c)
def rvs(self, n, size): out = [] rand_list = uniform.rvs(size = size) for rand_num in rand_list: out.append(self.ppf(n, rand_num)) return out
def random_initialization(self): self.genes = [] for i in range(self.size): self.genes.append(randint.rvs(1, 100)) self.sigma = [uniform.rvs()]
def random_initialization(self): self.genes = random.sample(range(self.lsup), self.size) self.sigma = [] for i in range(self.size): self.sigma.append(uniform.rvs())
null_table2 = model2_table(otu_sums, samples, seq_depth, tpk) print 'null done' ################################################## # ga table # ################################################## # run the genetic algorithms method on a known # otu sequence and maximize graphic dissimilarity # pearson distance is about .007 from numpy.random import seed seed(2039203920392039) from generators.ga import * from scipy.stats.distributions import uniform ref_gene = uniform.rvs(100, 1000, size=(50, 2)) igp = [ ref_gene[:] + uniform.rvs(100, 1000, size=ref_gene.shape) for i in range(400) ] gc, fmeans, fmaxes = evolve(igp, ref_gene, 1000) tmp_ga_table = vstack([i.T for i in gc]) # remove negative entries ga_table = [] for i in range(400): if (tmp_ga_table[2 * i:2 * (i + 1)] < 0).sum() < 1: ga_table.append(tmp_ga_table[2 * i:2 * (i + 1)]) ga_table = vstack(ga_table)
# partial_obligate_syntrophic_related_1d]).astype(int).astype(float) # def make_ids(data): # sids = ['s%i' % i for i in range(data.shape[1])] # oids = ['o%i' % i for i in range(data.shape[0])] # return sids, oids # sids, oids = make_ids(otu_data) # bt = table_factory(otu_data, sids, oids) ################ GA Table ####################### seed(300) ref_a = uniform.rvs(100,1000,size=50) ref_b = ref_a + uniform.rvs(0,20,size=50) ref_gene = array([ref_a,ref_b]).T igp = [ref_gene[:]+uniform.rvs(100,1000,size=ref_gene.shape) for i in range(500)] gc, fmeans, fmaxes = evolve(igp, ref_gene, 1000) tmp_ga_table = vstack([i.T for i in gc]) ga_table = [] for i in range(500): if (tmp_ga_table[2*i:2*(i+1)]>0).all(): ga_table.append(tmp_ga_table[2*i:2*(i+1)]) ga_table = vstack(ga_table) # this removes all otus (rows) from the table for which the correlation between
# test 2/25/2013 # create 200 otu X 50 sample table. use 4 otu's per rule # generate background otus which will be used to induce w = lognorm.rvs(2,1,size=10000).astype(int).reshape(200,50) # generate model 1 rules model1_rules = [] for i in range(10): rule_vals = uniform.rvs(-100,400,size=8) # sort rules so that left is lb <= ub rule_vals = where(rule_vals > 0, rule_vals, 0).reshape(4,2) rule_vals.sort() model1_rules.append(map(list, rule_vals)) # define weights and new otu distribution function weights = array([1.0, 1.0, 1.0, 1.0, .2]) df_and_params = [lognorm, 2, 1] # create new otus table_index = 0 new_otus = [] table_map = [] for rules in model1_rules: tmp_table_map = [table_index] inducer_arr = w[table_index:table_index+4] notu = model1_otu(inducer_arr, df_and_params, weights, rules)
def rvs(self, n, size): out = [] rand_list = uniform.rvs(size=size) for rand_num in rand_list: out.append(self.ppf(n, rand_num)) return out
print 'null done' ################################################## # ga table # ################################################## # run the genetic algorithms method on a known # otu sequence and maximize graphic dissimilarity # pearson distance is about .007 from numpy.random import seed seed(2039203920392039) from generators.ga import * from scipy.stats.distributions import uniform ref_gene = uniform.rvs(100,1000,size=(50,2)) igp = [ref_gene[:]+uniform.rvs(100,1000,size=ref_gene.shape) for i in range(400)] gc, fmeans, fmaxes = evolve(igp, ref_gene, 1000) tmp_ga_table = vstack([i.T for i in gc]) # remove negative entries ga_table = [] for i in range(400): if (tmp_ga_table[2*i:2*(i+1)]<0).sum() < 1: ga_table.append(tmp_ga_table[2*i:2*(i+1)]) ga_table = vstack(ga_table) print 'ga done' ##################################################
def rvs(self, n): return self.orv.ppf(self.F_ab * unif.rvs(size=n) + self.F_a)