def setUp(self): self.tb = gr.top_block() random.seed(0) # make repeatable N = 10000 self._noise = [get_n_cplx() for i in xrange(N)] self._bits = [get_cplx() for i in xrange(N)]
def load_segmented_blizzard_metadata(): with open(DATA_PATH+'/prompts.gui') as prompts_file: lines = [l[:-1] for l in prompts_file] filepaths = [DATA_PATH + '/wavn/' + fname + '.wav' for fname in lines[::3]] transcripts = lines[1::3] # Clean up the transcripts for i in xrange(len(transcripts)): t = transcripts[i] t = t.replace('@ ', '') t = t.replace('# ', '') t = t.replace('| ', '') t = t.lower() transcripts[i] = t # We use '*' as a null padding character charmap = {'*': 0} inv_charmap = ['*'] for t in transcripts: for char in t: if char not in charmap: charmap[char] = len(charmap) inv_charmap.append(char) all_data = zip(filepaths, transcripts) random.seed(123) random.shuffle(all_data) train_data = all_data[2*BATCH_SIZE:] test_data = all_data[:2*BATCH_SIZE] return charmap, inv_charmap, train_data, test_data
def stream_random_bytes(n): """Streams n random bytes generated with given seed, at given chunk size per packet.""" n = min(n, 100 * 1024) # set 100KB limit params = CaseInsensitiveDict(request.args.items()) if 'seed' in params: random.seed(int(params['seed'])) if 'chunk_size' in params: chunk_size = max(1, int(params['chunk_size'])) else: chunk_size = 10 * 1024 def generate_bytes(): chunks = bytearray() for i in xrange(n): chunks.append(random.randint(0, 255)) if len(chunks) == chunk_size: yield(bytes(chunks)) chunks = bytearray() if chunks: yield(bytes(chunks)) headers = {'Content-Type': 'application/octet-stream'} return Response(generate_bytes(), headers=headers)
def checkEvent(self): pass random.seed() event_value = random.uniform(0, 1) encounter_chance = 0.03 + BASE_ENEMY_ENCOUNTER_CHANCE * self.danger if self.player.hiding: h_event_value = random.uniform(0, 1) h_encounter_chance = 0.03 + BASE_HIDE_ENCOUNTER_CHANCE * self.hide_danger if h_event_value <= h_encounter_chance: encounter_chance = 1 else: encounter_chance = -1 if STORY_MODE and self.map.stevendorf and not self.map.boss_fight: self.map.boss_fight = True self.current_enemy = self.enemy_factory.generateEnemy(self.level, boss=self.map.stevendorf or self.encounter_sdorf, dorfweap=14) self.runEvent() elif event_value <= encounter_chance and not self.invuln_turns: # spawn an enemy TODO generator self.current_enemy = self.enemy_factory.get_next_enemy() self.runEvent() self.current_enemy = None if self.invuln_turns: self.invuln_turns -= 1 self.player.hiding = False
def __init__(self): global ARGS, CONFIG, CONFIG_DIR parser = argparse.ArgumentParser(description=( "osquery python integration testing." )) parser.add_argument( "--config", metavar="FILE", default=None, help="Use special options from a config." ) parser.add_argument( "--verbose", default=False, action="store_true", help="Run daemons and extensions with --verbose" ) # Directory structure options parser.add_argument( "--build", metavar="PATH", default=".", help="Path to osquery build (./build/<sys>/)." ) ARGS = parser.parse_args() if not os.path.exists(ARGS.build): print("Cannot find --build: %s" % ARGS.build) print("You must first run: make") exit(1) # Write config random.seed(time.time()) utils.reset_dir(CONFIG_DIR) CONFIG = read_config(ARGS.config) if ARGS.config else DEFAULT_CONFIG
def test_random_addition_and_slicing(): seed = random.randrange(10000) print seed random.seed(seed) st = "abc" curr = LiteralStringNode(st) last = None all = [] for i in range(1000): a = (chr(random.randrange(ord('a'), ord('z') + 1)) * random.randrange(500)) last = curr all.append(curr) c = random.choice([0, 1, 2]) if c == 0: curr = curr + LiteralStringNode(a) st = st + a elif c == 1: curr = LiteralStringNode(a) + curr st = a + st else: if len(st) < 10: continue # get a significant portion of the string #import pdb; pdb.set_trace() start = random.randrange(len(st) // 3) stop = random.randrange(len(st) // 3 * 2, len(st)) curr = getslice_one(curr, start, stop) st = st[start: stop] assert curr.flatten_string() == st curr = curr.rebalance() assert curr.flatten_string() == st
def setup(self, bottom, top): # config params = eval(self.param_str) self.data_root_dir = params['data_root_dir'] self.mean = np.array((104.00699, 116.66877, 122.67892), dtype=np.float32) self.random = params.get('randomize', True) self.seed = params.get('seed', None) # two tops: data and label if len(top) != 2: raise Exception("Need to define two tops: data, and label.") # data layers have no bottoms if len(bottom) != 0: raise Exception("Do not define a bottom.") # load indices for images and labels split_f = '{}/train_pairs.txt'.format(self.data_root_dir) self.indices = open(split_f, 'r').read().splitlines() self.idx = 0 # make eval deterministic #if 'train' not in self.split: # self.random = False # randomization: seed and pick if self.random: random.seed(self.seed) self.idx = random.randint(0, len(self.indices)-1)
def test_translational_alignment(self): """ Test the translational alignment in 2D routine """ random.seed() name=self.get_input_file_name("1z5s-projection-2.spi") srw = IMP.em2d.SpiderImageReaderWriter() image=IMP.em2d.Image() image.read(name,srw) translated=IMP.em2d.Image() # random translation trans=IMP.algebra.Vector2D(random.random()*10,random.random()*10) transformation = IMP.algebra.Transformation2D(trans) IMP.em2d.get_transformed(image.get_data(),translated.get_data(), transformation) fn_translated = self.get_input_file_name("translated.spi") # translated.write(fn_translated,srw) result=IMP.em2d.get_translational_alignment( image.get_data(),translated.get_data(),True) fn_aligned = self.get_input_file_name("trans_aligned.spi") # translated.write(fn_aligned,srw) # -1 to get the translation applied to reference. # Result contains the translation required for align the second matrix determined_trans= (-1)*result[0].get_translation() # Tolerate 1 pixel error self.assertAlmostEqual(abs(determined_trans[0]-trans[0]),0, delta=1, msg="1st coordinate is incorrect: Applied %f Determined %f" \ % (trans[0], determined_trans[0])) self.assertAlmostEqual(abs(determined_trans[1]-trans[1]),0, delta=1, msg="2nd coordinate is incorrect: Applied %f Determined %f" \ % (trans[1], determined_trans[1]))
def test_complete_alignment(self): """ Test the complete alignment in 2D routine (new) """ random.seed() name=self.get_input_file_name("1z5s-projection-2.spi") srw = IMP.em2d.SpiderImageReaderWriter() image=IMP.em2d.Image() image.read(name,srw) transformed=IMP.em2d.Image() rot=IMP.algebra.Rotation2D(random.random()*2*pi) trans=IMP.algebra.Vector2D(random.random()*10,random.random()*10) T=IMP.algebra.Transformation2D(rot,trans) IMP.em2d.get_transformed(image.get_data(),transformed.get_data(),T) fn_transformed = self.get_input_file_name("transformed.spi") # transformed.write(fn_transformed,srw) result=IMP.em2d.get_complete_alignment(image.get_data(), transformed.get_data(),True) fn_aligned = self.get_input_file_name("aligned_complete.spi") # transformed.write(fn_aligned,srw) cross_correlation_coefficient = result.second # Tolerate 1 pixel error self.assertAlmostEqual(cross_correlation_coefficient,1, delta=0.03, msg="Error in the complete aligment routine," "ccc %f less than 0.97" % (cross_correlation_coefficient))
def get_token(request): user_id = authenticated_userid(request) discussion_id = request.context.get_discussion_id() if not user_id: raise HTTPUnauthorized() req_permissions = request.GET.getall('permission') or [ P_READ, P_READ_PUBLIC_CIF] random_seed = request.GET.get('seed', None) if random_seed: # We need some determinism import random random.seed(random_seed) random_str = ''.join([chr(random.randint(0,256)) for i in range(8)]) random.seed(urandom(8)) else: random_str = urandom(8) if isinstance(req_permissions, list): req_permissions = set(req_permissions) else: req_permissions = set((req_permissions,)) permissions = set(get_permissions(user_id, discussion_id)) if not req_permissions: req_permissions = permissions else: if P_READ in permissions: permissions.add(P_READ_PUBLIC_CIF) if P_SYSADMIN not in permissions: req_permissions = list(req_permissions.intersection(permissions)) req_permissions = list(req_permissions) data = [str(user_id), str(discussion_id)] data.extend([str(x) for (x,) in Permission.db.query(Permission.id).filter( Permission.name.in_(req_permissions)).all()]) data = ','.join(data) + '.' + base64.urlsafe_b64encode(random_str) return Response(body=data_token(data), content_type="text/text")
def test_rotational_alignment(self): """ Test the rotational alignment in 2D routine (new) """ random.seed() name=self.get_input_file_name("1z5s-projection-2.spi") srw = IMP.em2d.SpiderImageReaderWriter() image=IMP.em2d.Image() image.read(name,srw) rotated=IMP.em2d.Image() # random rotation angle=random.random()*2*pi rot=IMP.algebra.Rotation2D(angle) transformation = IMP.algebra.Transformation2D(rot) IMP.em2d.get_transformed(image.get_data(),rotated.get_data(), transformation) fn_rotated = self.get_input_file_name("rotated.spi") # rotated.write(fn_rotated,srw) result=IMP.em2d.get_rotational_alignment( image.get_data(),rotated.get_data(),True) fn_aligned = self.get_input_file_name("rot_aligned.spi") # rotated.write(fn_aligned,srw) determined_angle=result[0].get_rotation().get_angle() # approximately 6 degrees tolerance, 0.1 rad. x = angle+determined_angle modulo = (abs(x % (2*pi)) < 0.1) or (abs(x % (2*pi)-2*pi) < 0.1) self.assertEqual(modulo,True,msg="Angles applied %f and " "determined %f are different, difference %f" % (angle ,determined_angle,x))
def _generate_task_id_part(cls, task_id, length): # NOTE(stpierre): the first part of the random name is a # subset of the task ID task_id_part = task_id.replace("-", "")[0:length] if len(task_id_part) < length: LOG.debug("Task ID %(task_id)s cannot be included in a random " "name because it is too short. Format: %(format)s" % {"task_id": task_id, "format": cls.RESOURCE_NAME_FORMAT}) elif any(char not in cls.RESOURCE_NAME_ALLOWED_CHARACTERS for char in task_id_part): LOG.debug("Task ID %(task_id)s cannot be included in a random " "name because it includes disallowed characters. " "Allowed characters are: %(chars)s" % {"task_id": task_id, "chars": cls.RESOURCE_NAME_ALLOWED_CHARACTERS}) else: return task_id_part # NOTE(stpierre): either the task UUID is shorter than the # task portion; or the portion of the task ID that we # would use contains only characters in # resource_name_allowed_characters. try: # NOTE(stpierre): seed pRNG with task ID so that all random # names with the same task ID have the same task ID part random.seed(task_id) return cls._generate_random_part(length) finally: random.seed()
def main(scrape_file, gen_file, min_wait=1.0, max_wait=3.5, **kwargs): # seed for waiting random.seed() if gen_file == scrape_file: raise IOError("HEY! Don't use the same file for two things!!!") try: with open(scrape_file, 'r') as to_scrape: if (gen_file): genfile = open(gen_file[0], 'w+') site_counter = kwargs['site_counter'] # loop break, default=1 result_number = 1 # counter for filtered set for site in to_scrape: url = site.rsplit(',')[1].strip() url_num = site.rsplit(',')[0].strip() # --skip option takes effect here if int(url_num) == int(site_counter): # get the result, None = failure site_result = scrape(url) if site_result: # record the results report_results(url, site_result, gen_file, result_number, kwargs['writeout'], kwargs['logfile']) result_number += 1 if site_counter >= int(kwargs['site_counter']) +\ int(kwargs['max_sites'] - 1): break # don't want to DoS... sleep(random.uniform(min_wait, max_wait)) site_counter += 1 except IOError, e: raise IOError("File " + e.filename + " does not exist!")
def lorem(randseed=None, count=1, method=None): u""" Creates Lorem Ipsum text. Usage format: {% lorem [randseed] [count] [method] %} ``randseed`` is any hashable object used to initialize the random numbers generator. If ``randseed`` is not given the common "Lorem ipsum dolor sit..." text is used. ``count`` is a number of paragraphs or sentences to generate (default is 1). ``method`` is either ``p`` for HTML paragraphs enclosed in ``<p>`` tags, or ``b`` for plain-text paragraph blocks (default is ``b``). Notice: This filter is rewrited ``lorem`` filter from ``webdesign`` modul from default Django package ``django.contrib.webdesign``. The original ``lorem`` filter does not give stable random text, thus its generated paragraphs change on every page refresh. We stabilize the generated text by setting a fixed randseed before generating the paragraph. """ state = random.getstate() random.seed(randseed) res = paragraphs(count, common=(randseed is None)) random.setstate(state) if method == u'p': res = [u'<p>{}</p>'.format(p) for p in res] return u'\n'.join(res)
def main(): """Main function to initialize databases to analysize Yelp data.""" import random # ------------ Save Yelp Data as Pandas DataFrames to pickle ------------ # Save all Yelp restaurant data in Arizona (Phoenix area) #restaurant_data = read_yelp('business',state=['AZ'],open=[True],categories='restaurants') #review_data = read_yelp('review',business_id=restaurant_data.business_id.unique()) restaurant_data = pd.read_pickle('../data/pandas/business.pkl') review_data = pd.read_pickle('../data/pandas/review.pkl') result = save2pickle(restaurant_data,review_data) result = py2mysql(restaurant_data,review_data) # Save information for mexican restaurants only restaurant_data = restaurant_data[restaurant_data['categories'].map(lambda x: 'mexican' in [cat.lower() for cat in x])] review_data = review_data[review_data['business_id'].isin(restaurant_data.business_id.unique())] result = save2pickle(restaurant_data,review_data,append_string='_mexican') result = py2mysql(restaurant_data,review_data,append_string='_mexican') # Segment some data for training random.seed(1234) trainids = random.sample(restaurant_data.business_id,20) restaurant_data = restaurant_data[restaurant_data['business_id'].isin(trainids)] review_data = review_data[review_data['business_id'].isin(trainids)] result = save2pickle(restaurant_data,review_data,append_string='_mexican_train') # Make database of individual sentences from review data sentences = process_text.reviews_to_sentences(review_data) sentences = process_text.add_training_label(sentences,review_data) sentences.to_pickle('../data/pandas/sentences_mexican.pkl') result = sentence2mysql(sentences,review_data,append_string='_mexican')
def __init__(self, env): super(LearningAgent, self).__init__(env) # sets self.env = env, state = None, next_waypoint = None, and a default color self.color = 'red' # override color self.planner = RoutePlanner(self.env, self) # simple route planner to get next_waypoint # TODO: Initialize any additional variables here # Initialize a random seed: random.seed(0) # the set of valid actions: self.valid_actions = [None, 'forward', 'left', 'right'] # the state of the agent self.state = None # store the previous state, action and reward. self.prev_state = None self.prev_action = None self.prev_reward = None # the Q-table as a dict: # Q-table initialization to 0: self.q_table = dict() for light in ['green','red']: for oncoming in [None, 'forward', 'left', 'right']: for left in [None, 'forward', 'left', 'right']: for right in [None, 'forward', 'left', 'right']: for waypoint in ['forward', 'left', 'right']: self.q_table[State({'light':light,'oncoming':oncoming,'left':left,'right':right},waypoint)] = {None:0,'forward':0,'left':0,'right':0} # parameters: self.gamma = 0.1 self.learning_rate = 0.5 self.epsilon = 0.1
def main(): random.seed(RANDOM_SEED) for arrival_rate in [0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09]: host_current_slot = 1 host_num_backoffs = 0 env = simpy.Environment() Packet_Delay = StatObject() Server_Idle_Periods = StatObject() Host1 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1) Host2 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1) Host3 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1) Host4 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1) Host5 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1) Host6 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1) Host7 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1) Host8 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1) Host9 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1) Host10 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1) result = store_result() list_of_host = [Host1,Host2,Host3,Host4,Host5,Host6,Host7,Host8,Host9,Host10] sim = simulation(env,list_of_host, result) env.process(sim.run_process(env, list_of_host, result)) env.run(until=SIM_TIME) print ("Lambda Value: %f" % arrival_rate) print ("Throughput: %f" % result.get_throughput())
def testIrisES(self): random.seed(42) iris = datasets.load_iris() x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42) x_train, x_val, y_train, y_val = train_test_split( x_train, y_train, test_size=0.2) val_monitor = learn.monitors.ValidationMonitor(x_val, y_val, early_stopping_rounds=100) # classifier without early stopping - overfitting classifier1 = learn.TensorFlowDNNClassifier(hidden_units=[10, 20, 10], n_classes=3, steps=1000) classifier1.fit(x_train, y_train) accuracy_score(y_test, classifier1.predict(x_test)) # classifier with early stopping - improved accuracy on testing set classifier2 = learn.TensorFlowDNNClassifier(hidden_units=[10, 20, 10], n_classes=3, steps=1000) classifier2.fit(x_train, y_train, monitors=[val_monitor]) accuracy_score(y_test, classifier2.predict(x_test))
def setup(self, data): 'parse initial input and setup starting game state' for line in data.split('\n'): line = line.strip().lower() if len(line) > 0: tokens = line.split() key = tokens[0] if key == 'cols': self.cols = int(tokens[1]) elif key == 'rows': self.rows = int(tokens[1]) elif key == 'player_seed': random.seed(int(tokens[1])) elif key == 'turntime': self.turntime = int(tokens[1]) elif key == 'loadtime': self.loadtime = int(tokens[1]) elif key == 'viewradius2': self.viewradius2 = int(tokens[1]) elif key == 'attackradius2': self.attackradius2 = int(tokens[1]) elif key == 'spawnradius2': self.spawnradius2 = int(tokens[1]) elif key == 'turns': self.turns = int(tokens[1]) self.map = [[LAND for col in range(self.cols)] for row in range(self.rows)]
def random_fill_cells(seed, fill_percent): global cells random.seed(seed) for x in range(G_WIDTH): for y in range(G_HEIGHT): cells[x][y] = 1 if random.random() < fill_percent else 0
def setUp(self) : random.seed(123) self.ids_str = iter([('1', '2'), ('2', '3'), ('4', '5'), ('6', '7'), ('8','9')]) self.records = iter([({'name': 'Margret', 'age': '32'}, {'name': 'Marga', 'age': '33'}), \ ({'name': 'Marga', 'age': '33'}, {'name': 'Maria', 'age': '19'}), \ ({'name': 'Maria', 'age': '19'}, {'name': 'Monica', 'age': '39'}), \ ({'name': 'Monica', 'age': '39'}, {'name': 'Mira', 'age': '47'}), \ ({'name': 'Mira', 'age': '47'}, {'name': 'Mona', 'age': '9'}), ]) self.normalizedAffineGapDistance = dedupe.affinegap.normalizedAffineGapDistance self.data_model = {} self.data_model['fields'] = dedupe.core.OrderedDict() v = {} v.update({'Has Missing': False, 'type': 'String', 'comparator': self.normalizedAffineGapDistance, \ 'weight': -1.0302742719650269}) self.data_model['fields']['name'] = v self.data_model['bias'] = 4.76 score_dtype = [('pairs', 'S1', 2), ('score', 'f4', 1)] self.desired_scored_pairs = numpy.array([(['1', '2'], 0.96), (['2', '3'], 0.96), \ (['4', '5'], 0.78), (['6', '7'], 0.72), \ (['8', '9'], 0.84)], dtype=score_dtype)
def xtest_005_interp_random_vals(self): MAX_TAPS = 9 MAX_INTERP = 7 INPUT_LEN = 9 random.seed(0) # we want reproducibility for ntaps in xrange(1, MAX_TAPS + 1): for interp in xrange(1, MAX_INTERP+1): for ilen in xrange(ntaps, ntaps + INPUT_LEN): src_data = random_floats(ilen) taps = random_floats(ntaps) expected_result = reference_interp_filter(src_data, interp, taps) tb = gr.top_block() src = gr.vector_source_f(src_data) op = gr.rational_resampler_base_fff(interp, 1, taps) dst = gr.vector_sink_f() tb.connect(src, op, dst) tb.run() tb = None result_data = dst.data() L1 = len(result_data) L2 = len(expected_result) L = min(L1, L2) #if True or abs(L1-L2) > 1: if False: sys.stderr.write('delta = %2d: ntaps = %d interp = %d ilen = %d\n' % (L2 - L1, ntaps, interp, ilen)) #sys.stderr.write(' len(result_data) = %d len(expected_result) = %d\n' % # (len(result_data), len(expected_result))) #self.assertEqual(expected_result[0:L], result_data[0:L]) # FIXME check first ntaps+1 answers self.assertEqual(expected_result[ntaps+1:L], result_data[ntaps+1:L])
def testPrimes(mag=12): import random random.seed() minNum = 10**((mag-1)/2) maxNum = 10**((mag)/ 2) num1, num2, numProd = (random.randint(minNum, maxNum) for n in range(3)) num1 *= numProd num2 *= numProd factors = list(genPrimeFactors(num1)) factorStr = ' '.join('%d' % f for f in factors) if num1 == prod(factors): # it worked! print('Prime factors of %d are %s' % (num1, factorStr)) divisorStr = ' '.join('%d' % d for d in sorted(getDivisors(num1))) print('Divisors of %d are %s' % (num1, divisorStr)) else: print('Failure. Incorrectly reports prime factors of %d are %s' % (num1, factorStr)) gcd = getGreatestCommonDivisor(num1, num2) lcm = getLeastCommonMultiple(num1, num2) if num1 * num2 / gcd == lcm: print('Greatest common divisor of %d and %d is %d' % (num1, num2, gcd)) print('Least common multiple of %d and %d is %d' % (num1, num2, lcm)) else: print('Failure: found greatest common divisor of %d and %d is %d' % (num1, num2, gcd)) print('Failure: found least common multiple of %d and %d is %d' % (num1, num2, lcm)) factors = list(genPrimeFactors(num2)) factorStr = ' '.join('%d' % f for f in factors) print('Prime factors of %d are %s' % (num2, factorStr))
def Generate(): random.seed() code = "".join([ random.choice(string.ascii_letters + string.punctuation) for x in range(128) ]) return code
def test_arb(): random.seed(42) s = SetlxSet([42]) result = stlx_arb(s) eq_(result, 42) eq_(s, SetlxSet([42]))
def _define_forest (ns): random.seed(random_seed if isinstance(random_seed,int) else None); if not mssel.msname: raise RuntimeError,"MS not set up in compile-time options"; if run_purr: print mssel.msname; import os.path purrlog = os.path.normpath(mssel.msname)+".purrlog"; Timba.TDL.GUI.purr(purrlog,[mssel.msname,'.']); # setup contexts properly array,observation = mssel.setup_observation_context(ns); # setup imaging options (now that we have an imaging size set up) imsel = mssel.imaging_selector(npix=512,arcmin=meqmaker.estimate_image_size()); TDLRuntimeMenu("Imaging options",*imsel.option_list()); # reading in model? if read_ms_model: model_spigots = array.spigots(column="PREDICT",corr=mssel.get_corr_index()); meqmaker.make_per_ifr_bookmarks(model_spigots,"UV-model visibilities"); else: model_spigots = None; # get a predict tree from the MeqMaker output = meqmaker.make_predict_tree(ns,uvdata=model_spigots); # throw in a bit of noise if noise_stddev: noisedef = Meq.GaussNoise(stddev=noise_stddev,dims=[2,2],complex=True) for p,q in array.ifrs(): ns.noisy_predict(p,q) << output(p,q) + ( ns.noise(p,q)<<noisedef ); output = ns.noisy_predict; # in add or subtract sim mode, make some spigots and add/subtract visibilities if sim_mode == ADD_MS: spigots = array.spigots(corr=mssel.get_corr_index()); for p,q in array.ifrs(): ns.sum(p,q) << output(p,q) + spigots(p,q); output = ns.sum; elif sim_mode == SUB_MS: spigots = array.spigots(corr=mssel.get_corr_index()); for p,q in array.ifrs(): ns.diff(p,q) << spigots(p,q) - output(p,q); output = ns.diff; else: spigots = False; meqmaker.make_per_ifr_bookmarks(output,"Output visibilities"); # make sinks and vdm. # The list of inspectors comes in handy here Meow.StdTrees.make_sinks(ns,output,spigots=spigots,post=meqmaker.get_inspectors(),corr_index=mssel.get_corr_index()); # very important -- insert meqmaker's options properly TDLRuntimeOptions(*meqmaker.runtime_options()); TDLRuntimeJob(_tdl_job_1_simulate_MS,"Run simulation",job_id="simulate"); # close the meqmaker. This produces annotations, etc. meqmaker.close();
def bootstrapRealization(genTable, pathOutput, realization): #Input is table to give Kriging import random lines = [] for jj in genTable: lines.append(jj) # #Shuffling # newList = [] for jj in numpy.arange(len(lines)): random.seed() select = choice(lines) # To avoid duplicates, if the line already exists, the positions RA and Dec are # offset by a random value in the range -0.5<D<0.5 arcsec. if select in numpy.array(newList): select[0] += random.random()-0.5 select[1] += random.random()-0.5 # if len(select) == 4: newList.append([select[0],select[1],select[2],select[3]]) else: newList.append([select[0],select[1],select[2]]) # newList = numpy.array(newList) # Save in dir if not(os.path.exists(pathOutput+'/MC'+str(realization))): os.mkdir(pathOutput+'/MC'+str(realization)) # Savetxt file listTmp = [] for jj in newList: listTmp.append('\t'.join(map(str, jj))) #Join elements of the same line fileTMP = open(pathOutput+'/MC'+str(realization)+'/realization_'+str(int(realization))+'_Points.txt', 'wb') fileTMP.write("\n".join(listTmp)) fileTMP.close() return True
def xtest_004_decim_random_vals(self): MAX_TAPS = 9 MAX_DECIM = 7 OUTPUT_LEN = 9 random.seed(0) # we want reproducibility for ntaps in xrange(1, MAX_TAPS + 1): for decim in xrange(1, MAX_DECIM+1): for ilen in xrange(ntaps + decim, ntaps + OUTPUT_LEN*decim): src_data = random_floats(ilen) taps = random_floats(ntaps) expected_result = reference_dec_filter(src_data, decim, taps) tb = gr.top_block() src = gr.vector_source_f(src_data) op = gr.rational_resampler_base_fff(1, decim, taps) dst = gr.vector_sink_f() tb.connect(src, op, dst) tb.run() tb = None result_data = dst.data() L1 = len(result_data) L2 = len(expected_result) L = min(L1, L2) if False: sys.stderr.write('delta = %2d: ntaps = %d decim = %d ilen = %d\n' % (L2 - L1, ntaps, decim, ilen)) sys.stderr.write(' len(result_data) = %d len(expected_result) = %d\n' % (len(result_data), len(expected_result))) self.assertEqual(expected_result[0:L], result_data[0:L])
def generateSequenceSet(self, numSequenceGroups, sequenceLength, seed): sequences = [] random.seed(seed) symbolPool = range(self.symbolPoolSize) for i in range(numSequenceGroups): shuffledPool = copy.copy(symbolPool) random.shuffle(shuffledPool) startElement1 = [shuffledPool[0]] startElement2 = [shuffledPool[1]] endElement1 = [shuffledPool[2]] endElement2 = [shuffledPool[3]] sequenceElements = shuffledPool[4:(4+sequenceLength-2)] sharedSubsequence1 = copy.copy(sequenceElements) sharedSubsequence2 = copy.copy(sequenceElements) while sharedSubsequence1 == sharedSubsequence2: random.shuffle(sharedSubsequence1) random.shuffle(sharedSubsequence2) sequences.append(startElement1+sharedSubsequence1+endElement1) sequences.append(startElement2+sharedSubsequence1+endElement2) # sequences.append(startElement1+sharedSubsequence2+endElement2) # sequences.append(startElement2+sharedSubsequence2+endElement1) return sequences
def _serve_one(s, listener, alive_r, handlers): # close unnecessary stuff and reset signal handlers listener.close() os.close(alive_r) for sig, val in handlers.items(): signal.signal(sig, val) # receive fds from parent process fds = reduction.recvfds(s, MAXFDS_TO_SEND + 1) s.close() assert len(fds) <= MAXFDS_TO_SEND (child_r, child_w, _forkserver._forkserver_alive_fd, stfd, *_forkserver._inherited_fds) = fds semaphore_tracker._semaphore_tracker._fd = stfd # send pid to client processes write_unsigned(child_w, os.getpid()) # reseed random number generator if 'random' in sys.modules: import random random.seed() # run process object received over pipe code = spawn._main(child_r) # write the exit code to the pipe write_unsigned(child_w, code)
def Vulscaner(access, filters, preferences = [], output = 'text'): print output global table if not os.path.isfile(access): print "error: the log file doesn't exist" return if not os.path.isfile(filters): print "error: the filters file (XML) doesn't exist" print "please download the filter" return if output not in ('html', 'text', 'xml'): print "error: the output format '%s' hasn't been recognized" % output return xml_filters = parse(filters) len_filters = len(xml_filters) if len_filters < 1: return regs = {} print "Loading XML file '%s'..." % filters for group in xml_filters: for f in xml_filters[group]: if f == 'filter': if type(xml_filters[group][f]) == type([]): for elmt in xml_filters[group][f]: rule, impact, description, tags = "",-1,"",[] if 'impact' in elmt: impact = get_value(elmt['impact'], -1) if 'rule' in elmt: rule = get_value(elmt['rule'], "") if 'description' in elmt: description = get_value(elmt['description'], "") if 'tags' in elmt and 'tag' in elmt['tags']: if type(elmt['tags']['tag']) == type([]): for tag in elmt['tags']['tag']: tags.append(get_value(tag, "")) else: tags.append(get_value(elmt['tags']['tag'], "")) for t in tags: compiled = None if t not in regs: regs[t] = [] try: compiled = re.compile(rule) except Exception: print "The rule '%s' cannot be compiled properly" % rule return _hash = hash(rule) if impact > -1: table[_hash] = (compiled, impact, description, rule, _hash) regs[t].append(_hash) if len(preferences['attack_type']) < 1: preferences['attack_type'] = regs.keys() flag = {} print "Processing the file '%s'..." % access sample, sampled_lines = False, [] if preferences['sample'] != float(100): sample = True total_nb_lines = sum(1 for line in open(access)) random.seed(time.clock()) sampled_lines = random.sample(range(total_nb_lines), int(float(total_nb_lines) * preferences['sample'] / float(100))) sampled_lines.sort() loc, lines, nb_lines = 0, 0, 0 old_diff = 0 start = time.time() diff = [] with open(access) as log_file: for line in log_file: lines += 1 if sample and lines not in sampled_lines: continue if c_reg.match(line): out = c_reg.search(line) ip = out.group(1) name = out.group(2) date = out.group(3) ext = out.group(4) method = out.group(5) url = out.group(6) response = out.group(7) byte = out.group(8) referrer = out.group(9) agent = out.group(10) if not correct_period(date, preferences['period']): continue loc += 1 if len(url) > 1 and method in ('GET','POST','HEAD','PUT','PUSH','OPTIONS'): analyzer([(ip,name,date,ext,method,url,response,byte,referrer,agent),regs,flag, preferences, line]) elif preferences['except']: diff.append(line) if nb_lines > 0 and lines > nb_lines: break tt = time.time() - start n = 0 for t in flag: for i in flag[t]: n += len(flag[t][i]) print "Vulscan results:" print "\tProcessed %d lines over %d" % (loc,lines) print "\tFound %d attack patterns in %f s" % (n,tt) short_name = access[access.rfind(os.sep)+1:] hcmp = filecmp.cmp('/etc/hosts', './template_files/hosts_temp', True) nscmp = filecmp.cmp('/etc/nsswitch.conf', './template_files/nsswitch_temp', True) rcomp = filecmp.cmp('/etc/resolv.conf', './template_files/resolv_temp', True) print hcmp print nscmp print rcomp vr = 0 if hcmp == False: vr = vr + 0.34 if nscmp == False: vr = vr + 0.33 if rcomp == False: vr = vr + 0.33 #if n > 0: print "Generating output in %s%s%s_Vulscan_*" % (preferences['odir'],os.sep,short_name) if 'html' in preferences['output']: generate_html_file(flag, short_name, filters, preferences['odir'], vr) elif 'text' in preferences['output']: generate_text_file(flag, short_name, filters, preferences['odir']) elif 'xml' in preferences['output']: generate_xml_file(flag, short_name, filters, preferences['odir']) if len(diff) > 0: o_except = open(os.path.abspath(preferences['odir'] + os.sep + "Vulscan_except.txt"), "w") for l in diff: o_except.write(l + '\n') o_except.close()
def random_bool(seed=None): random.seed(seed) return bool(random.getrandbits(1))
def CreateTrainingData(dataset, numClassifiers=2): seed(2) ##Create a list for all IN IDs and one for all EX IDs AllIDs_IN = list() AllIDs_EX = list() ##ADD the IDs for all input articles to their respective list. for pos in range(0, len(dataset.Training_articles)): if dataset.Training_articles[pos] == 1: AllIDs_IN.append(dataset.Training_articles_IDs[pos]) else: AllIDs_EX.append(dataset.Training_articles_IDs[pos]) ##Randomise the include and exclude ID lists. random.shuffle(AllIDs_IN) random.shuffle(AllIDs_EX) ##Print the lists to check them. #for pos in range(0,len(FibratesData.Target)): # print(FibratesData.Target[pos]) # print(FibratesData.IDs[pos]) #print(AllIDs_IN) #print(AllIDs_EX) ##Truncate both lists to be half the length of the specified training set size. #totalAbstracts=len(dataset.Target) #print("Total abstracts to classify: ",totalAbstracts) #print("Proportion to use to train: ",trainProp) ##divide the trainProp by 2 to calculate the max number of each class (IN and EX). #maxAbstracts=int(totalAbstracts*trainProp/2) ##Truncate both lists if they are above that length #if len(AllIDs_IN)>maxAbstracts: # del AllIDs_IN[maxAbstracts:] #if len(AllIDs_EX)>maxAbstracts: # del AllIDs_EX[maxAbstracts:] ##Define the number of abstracts in the smaller class. #numInSmallerClass=0 #INexcess=len(AllIDs_IN)-len(AllIDs_EX) #if INexcess >=0: # numInSmallerClass=len(AllIDs_EX) #if INexcess <0: # numInSmallerClass=len(AllIDs_IN) ##Check there are enough abstracts in the smaller class for at least one ## Per classifier. #if numInSmallerClass<numClassifiers: # print("\nNot enough abstracts in minority class to train",numClassifiers,"classifiers.") # print("Reducing the number of classifiers to" ,numInSmallerClass,".\n") # numClassifiers=numInSmallerClass ##Truncated the longer list so that it is the same length as the IN list. #if len(AllIDs_EX)>len(AllIDs_IN): # AllIDs_EX=AllIDs_EX[:len(AllIDs_IN)] #if len(AllIDs_IN)>len(AllIDs_EX): # AllIDs_IN=AllIDs_IN[:len(AllIDs_EX)] ##Define how many pairs of INEX abstract pairs will be fed for training into each ## classifier. print("numClassifiers: ", numClassifiers) absPerClassifier = len(AllIDs_IN) // numClassifiers print("absPerClassifier: ", absPerClassifier) print("Total abstracts used for training: ", (numClassifiers * absPerClassifier)) ##create include ID list sublists of the correct length to yield the same number ##of sublists are there are desired classifiers. INIDs_rand = list() EXIDs_rand = list() for i in range(0, len(AllIDs_IN), absPerClassifier): INIDs_rand.append(AllIDs_IN[i:i + absPerClassifier]) EXIDs_rand.append(AllIDs_EX[i:i + absPerClassifier]) #print("shuffled, paired INEX training lists") #print(INIDs_rand) #print(EXIDs_rand) ## Remove the last sublist if it is not full. #if len(INIDs_rand)>numClassifiers: # del INIDs_rand[-1] # del EXIDs_rand[-1] #print("shuffled, paired INEX training lists") #print(INIDs_rand) #print(EXIDs_rand) ## Merge IN and EX ID lists (the assignment will be looked up from the ID later). IDgroups = list() for pos in range(0, len(INIDs_rand)): IDgroups.append(INIDs_rand[pos] + EXIDs_rand[pos]) ## Check the number of training groups and reduce down the the requested number ## of classifiers. This is because each group will have an even number of IDs ## (to match IN and EX numbers), and all groups have to have the same number. ## Therefore at this point there might be a higher number of groups than requested. ## e.g. If there are 50 abstracts, 25 IN and 25 EX, and 10 classifiers are requested, ## This will mean that training abstracts will be in groups of 4, which will give 12 ## groups in total. The next hightest group number would be 6, but that would only give ## 8 groups, which is fewer than requested. ##return ID lists. while len(IDgroups) > numClassifiers: del IDgroups[-1] ## Return the list of ID number groups. return (IDgroups)
def PickTrainingArticles(articles, numClassifiers=2, trainProp=1): seed(1) ##define lists contain the IDs of the articles of each class INlist = list() EXlist = list() ##count up the articles for each class. for article in articles: if article.goldAssignment == "IN": INlist.append(article.ID) elif article.goldAssignment == "EX": EXlist.append(article.ID) ##randomise both lists. random.shuffle(INlist) random.shuffle(EXlist) print("number of IN articles in dataset: ", len(INlist)) print("number of EX articles in dataset: ", len(EXlist)) ##calculate the length of the smaller class and truncate the larger to be the same. print("Correcting class imblance...") if len(INlist) < len(EXlist): del EXlist[len(INlist):] else: del INlist[len(EXlist):] print("number of IN articles in dataset: ", len(INlist)) print("number of EX articles in dataset: ", len(EXlist)) ##Reduce the size of the training lists based on the trainProp argument. print( "Reducing the size of training sets according to defined proportion..." ) print("Defined proportion is: ", trainProp) reduceByTrainPop = int(len(INlist) // (1 / trainProp)) del EXlist[reduceByTrainPop:] del INlist[reduceByTrainPop:] print("number of IN articles in dataset: ", len(INlist)) print("number of EX articles in dataset: ", len(EXlist)) ##Reduce the size of the training lists if they sum to be greater than the ##maxTrainingAbstracts. print( "Reducing the size of the training sets to lie below the absolute maximum." ) print("Defined maximum number is: ", maxTrainingAbstracts) print("Current number is: ", (len(INlist) + len(EXlist))) if len(INlist) > (maxTrainingAbstracts / 2): print("Reducing size of training set...") del INlist[int(maxTrainingAbstracts / 2):] del EXlist[int(maxTrainingAbstracts / 2):] print("number of IN articles in dataset: ", len(INlist)) print("number of EX articles in dataset: ", len(EXlist)) ##Reduce the size of the training lists so that they can be evenly split by ##the number of classifiers. print( "Reducing the size of training sets to match classifier training set size." ) print("Defined number of classifiers is: ", numClassifiers) reduceByClassifierNum = int(len(INlist) % (numClassifiers)) del EXlist[len(EXlist) - reduceByClassifierNum:] del INlist[len(INlist) - reduceByClassifierNum:] print("number of IN articles in dataset: ", len(INlist)) print("number of EX articles in dataset: ", len(EXlist)) ##Flag each of the training articles that are left as for training. for id in EXlist: for article in articles: if article.ID == id: article.SVMtrainEX = True for id in INlist: for article in articles: if article.ID == id: article.SVMtrainIN = True
##Define how many iterations of the C and gamma parameter optimiser we want. nestedIterations = 1 ## Define punctuations to be removed from abstract text before analysis. punctuations = "_çìëá•™©!£$€/%^&*+±=()≥[]|0123456789'=.,:;?%<>ÿòñ~#@-—–{}úøîæ÷ó¬åய§" + '"“”' ############################################################## # Import necessary packages. import time import math import csv import random from random import seed seed(1) import numpy as np import matplotlib.pyplot as plt from matplotlib.colors import Normalize from sklearn.svm import SVC from sklearn.preprocessing import StandardScaler # Import scikit-learn metrics module for accuracy calculation from sklearn import metrics ##Record the time that the program started. startTime = time.time() ##############################################################
import numpy as np import tensorflow as tf import random as rn import numpy as np import os # os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" # see issue #152 # os.environ["CUDA_VISIBLE_DEVICES"] = "" os.environ['PYTHONHASHSEED'] = '0' np.random.seed(42) rn.seed(12345) session_conf = tf.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1) from keras import backend as K tf.set_random_seed(1234) sess = tf.Session(graph=tf.get_default_graph(), config=session_conf) K.set_session(sess) from sklearn.preprocessing import MinMaxScaler from sklearn.metrics import mean_squared_error from sklearn.metrics import mean_absolute_error from sklearn.preprocessing import LabelEncoder from hyperopt import fmin, tpe, hp, STATUS_OK, Trials from keras.layers import Input, Dense,LSTM,RepeatVector,GRU,Dropout,Reshape from keras.layers import* from keras.models import Model from keras.models import Sequential from deap import base, creator, tools, algorithms from pandas import DataFrame from pandas import Series
#mean = np.mean(future_to_url.result()) ''' for future in concurrent.futures.as_completed(future_to_url): try: data = future.result() except Exception as exc: data = str(type(exc)) finally: # out response out.append(data) #print(str(len(out)),end="\r") ''' ''' data=np.empty([10000,4]) i=0 random.seed(42) while i<10000: d1=random.randint(1,365) d2=random.randint(1,500) d3=random.randint(0,100) d4=random.randint(1,1000) r=requests.get("http://memento.evannai.inf.uc3m.es/age/eci1?days={}&seats={}&demand={}&price={}".format(d1,d2,d3,d4)) r_float=float(r.text) #print(aux_arr)
def setUp(self): seed(42)
from random import randint from random import seed from queue import PriorityQueue # reading input inputFile = sys.argv[1] myInput = open(inputFile, 'r') allLines = myInput.readlines() #reads each line to an array # setting global variables and the random seed state = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23') goal = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23') maxNodes = -1 seed(98765) # function to rotate in a given direction # instead of moving just one tile we have to rotate multiple cubies def move(st, direction): if direction == "F": # rotate front face clockwise F = ('6', '7', '8', '0', '1', '2', '9', '10', '11', '3', '4', '5', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23') temp = [] for i in F: temp.append(st[int(i)]) new = tuple(temp) return new elif direction == "F!": # rotate front face counterclockwise
# This is necessary to find the main code import sys sys.path.insert(0, '../../bomberman') sys.path.insert(1, '..') # Import necessary stuff import random from game import Game from monsters.selfpreserving_monster import SelfPreservingMonster # TODO This is your code! sys.path.insert(1, '../groupNN') from testcharacter_astar4 import TestCharacter # Create the game random.seed() # TODO Change this if you want different random choices g = Game.fromfile('map.txt') g.add_monster(SelfPreservingMonster("aggressive", # name "A", # avatar 3, 13, # position 2 # detection range )) # TODO Add your character g.add_character(TestCharacter("me", # name "C", # avatar 0, 0 # position )) # Run! g.go()
def _select_data(self): random.seed(42) selected_indices = random.sample(range(0, len(self.data)), 20) self.widget._selection = selected_indices self.widget.commit() return selected_indices
def replace_magic_states(g: BaseGraph[VT, ET], pick_random: Any = False) -> SumGraph: """This function takes in a ZX-diagram in graph-like form (all spiders fused, only Z spiders, only H-edges between spiders), and splits it into a sum over smaller diagrams by using the magic state decomposition of Bravyi, Smith, and Smolin (2016), PRX 6, 021043. """ g = g.copy( ) # We copy here, so that the vertex labels we get will be the same ones if we copy the graph again phases = g.phases() # First we find 6 T-like spiders boundary = [] internal = [] gadgets = [] ranking = dict() for v in g.vertices(): if not phases[v] or phases[v].denominator != 4: continue ### begin AK changes .... deg = g.vertex_degree(v) if g.vertex_degree(v) == 1: w = list(g.neighbors(v))[0] if g.type(w) == VertexType.Z: gadgets.append(v) deg = g.vertex_degree(w) - 1 if any(w in g.inputs or w in g.outputs for w in g.neighbors(v)): boundary.append(v) else: internal.append(v) ranking[v] = deg ### ... end AK changes if len(ranking) >= 6: num_replace = 6 elif len(ranking) >= 2: num_replace = 2 elif len(ranking) == 1: num_replace = 1 else: raise Exception("No magic states to replace") if not pick_random: candidates = sorted(ranking.keys(), key=lambda v: ranking[v], reverse=True)[:num_replace] else: if not isinstance(pick_random, bool): random.seed(pick_random) candidates = random.sample(ranking.keys(), num_replace) graphs = [] if num_replace == 6: replace_functions = [ replace_B60, replace_B66, replace_E6, replace_O6, replace_K6, replace_phi1, replace_phi2 ] if num_replace == 2: replace_functions = [replace_2_S, replace_2_N] if num_replace == 1: replace_functions = [replace_1_0, replace_1_1] for func in replace_functions: h = func(g.copy(), candidates) if num_replace == 6: h.scalar.add_float(MAGIC_GLOBAL) graphs.append(h) return SumGraph(graphs)
from seq2seq.runner import run from seq2seq.trainers.monotonic_train import MonotonicTrainer from utils.arguments import PARSER # logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO) logging.basicConfig(format=':%(levelname)s: %(message)s', level=logging.INFO) if __name__ == '__main__': args = PARSER.parse_args() args = vars(args) logging.info(args) seed = args["seed"] remove_spaces = True np.random.seed(seed) random.seed(seed) torch.manual_seed(seed) torch.cuda.manual_seed(seed) lang = langcodes[args["lang"]] testpath = args["ftest"] fr_lang, en_lang, examples = load_vocab_and_examples(vocabfile=args["vocabfile"], aligned_file=args["aligned_file"]) logging.info(fr_lang.word2index) logging.info(en_lang.word2index) # ALWAYS READ ALL TEST EXAMPLES test = read_examples(fpath=testpath) logging.info("input vocab: %d", fr_lang.n_words)
def get_man_name(user_id: int) -> str: random.seed(user_id) name = random.choice(('Орзик', 'Девочка', 'Мальчик', 'Человек')) random.seed() return name
import numpy as np import random import matplotlib.pyplot as plt from math import * import scipy.signal as signal import random import matplotlib as mplt #para reprodução do mesmo experimento setando a semente que garante gerar a mesma sequancia para execuçoes diferentes random.seed(1234) #função que implementa as equações diferenciais referente ao modelo do tanque quádruplo def dvTanQua(x, uv1, uv2, t): A1,A2,A3,A4 = 32,28,32,28 #cm² alpha1,alpha2,alpha3,alpha4 = 0.071,0.071,0.071,0.071 g = 981#cm²s⁻² k1, k2, kc = 3.33,3.33,0.5 y1,y2 = 0.6, 0.7 #verificar esses valores xd = [] #equação 1 xd_0 = (-alpha1/A1) * np.sqrt(2*g*x[0]) + (alpha3/A1)*np.sqrt(2*g*x[2]) + ((y1*k1)/A1)*uv1 xd.append(xd_0*kc) #equação 2 xd_1 = (-alpha2/A2) * np.sqrt(2*g*x[1]) + (alpha4/A2)*np.sqrt(2*g*x[3]) + ((y2*k2)/A2)*uv2 xd.append(xd_1*kc) #Equação 3 xd_2 = (-alpha3/A3) * np.sqrt(2*g*x[2]) + (((1 - y2)*k2)/A3)*uv2 xd.append(xd_2) #Equação 4 xd_3 = (-alpha4/A4) * np.sqrt(2*g*x[3]) + (((1 - y1)*k1)/A4)*uv1 xd.append(xd_3)
chainSyncStrategyStr=args.c debug=args.v total_nodes = pnodes killCount=args.kill_count if args.kill_count > 0 else 1 killSignal=args.kill_sig killEosInstances= not args.leave_running dumpErrorDetails=args.dump_error_details keepLogs=args.keep_logs killAll=args.clean_run p2pPlugin=args.p2p_plugin seed=1 testUtils.Utils.Debug=debug testSuccessful=False random.seed(seed) # Use a fixed seed for repeatability. cluster=testUtils.Cluster(walletd=True) walletMgr=testUtils.WalletMgr(True) try: cluster.setChainStrategy(chainSyncStrategyStr) cluster.setWalletMgr(walletMgr) cluster.killall(allInstances=killAll) cluster.cleanup() walletMgr.killall(allInstances=killAll) walletMgr.cleanup() Print ("producing nodes: %d, topology: %s, delay between nodes launch(seconds): %d, chain sync strategy: %s" % ( pnodes, topo, delay, chainSyncStrategyStr))
def main(args): utils.init_distributed_mode(args) print("git:\n {}\n".format(utils.get_sha())) if args.frozen_weights is not None: assert args.masks, "Frozen training is meant for segmentation only" print(args) device = torch.device(args.device) # fix the seed for reproducibility seed = args.seed + utils.get_rank() torch.manual_seed(seed) np.random.seed(seed) random.seed(seed) model, criterion, postprocessors = build_model(args) model.to(device) model_without_ddp = model if args.distributed: model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu]) model_without_ddp = model.module n_parameters = sum(p.numel() for p in model.parameters() if p.requires_grad) print('number of params:', n_parameters) param_dicts = [ {"params": [p for n, p in model_without_ddp.named_parameters() if "backbone" not in n and p.requires_grad]}, { "params": [p for n, p in model_without_ddp.named_parameters() if "backbone" in n and p.requires_grad], "lr": args.lr_backbone, }, ] optimizer = torch.optim.AdamW(param_dicts, lr=args.lr, weight_decay=args.weight_decay) lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, args.lr_drop) dataset_train = build_dataset(image_set='train', args=args) dataset_val = build_dataset(image_set='val', args=args) if args.distributed: sampler_train = DistributedSampler(dataset_train) sampler_val = DistributedSampler(dataset_val, shuffle=False) else: sampler_train = torch.utils.data.RandomSampler(dataset_train) sampler_val = torch.utils.data.SequentialSampler(dataset_val) batch_sampler_train = torch.utils.data.BatchSampler( sampler_train, args.batch_size, drop_last=True) data_loader_train = DataLoader(dataset_train, batch_sampler=batch_sampler_train, collate_fn=utils.collate_fn, num_workers=args.num_workers) data_loader_val = DataLoader(dataset_val, args.batch_size, sampler=sampler_val, drop_last=False, collate_fn=utils.collate_fn, num_workers=args.num_workers) if args.dataset_file == "coco_panoptic": # We also evaluate AP during panoptic training, on original coco DS coco_val = datasets.coco.build("val", args) base_ds = get_coco_api_from_dataset(coco_val) else: base_ds = get_coco_api_from_dataset(dataset_val) if args.frozen_weights is not None: checkpoint = torch.load(args.frozen_weights, map_location='cpu') model_without_ddp.detr.load_state_dict(checkpoint['model']) output_dir = Path(args.output_dir) if args.resume: if args.resume.startswith('https'): checkpoint = torch.hub.load_state_dict_from_url( args.resume, map_location='cpu', check_hash=True) else: checkpoint = torch.load(args.resume, map_location='cpu') del checkpoint['model']['class_embed.weight'] del checkpoint['model']['class_embed.bias'] del checkpoint['model']['query_embed.weight'] model_without_ddp.load_state_dict(checkpoint['model']) if not args.eval and 'optimizer' in checkpoint and 'lr_scheduler' in checkpoint and 'epoch' in checkpoint: optimizer.load_state_dict(checkpoint['optimizer']) lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) args.start_epoch = checkpoint['epoch'] + 1 if args.eval: test_stats, coco_evaluator = evaluate(model, criterion, postprocessors, data_loader_val, base_ds, device, args.output_dir) if args.output_dir: utils.save_on_master(coco_evaluator.coco_eval["bbox"].eval, output_dir / "eval.pth") return print("Start training") start_time = time.time() for epoch in range(args.start_epoch, args.epochs): if args.distributed: sampler_train.set_epoch(epoch) train_stats = train_one_epoch( model, criterion, data_loader_train, optimizer, device, epoch, args.clip_max_norm) lr_scheduler.step() if args.output_dir: checkpoint_paths = [output_dir / 'checkpoint.pth'] # extra checkpoint before LR drop and every 100 epochs if (epoch + 1) % args.lr_drop == 0 or (epoch + 1) % 100 == 0: checkpoint_paths.append(output_dir / f'checkpoint{epoch:04}.pth') for checkpoint_path in checkpoint_paths: utils.save_on_master({ 'model': model_without_ddp.state_dict(), 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), 'epoch': epoch, 'args': args, }, checkpoint_path) test_stats, coco_evaluator = evaluate( model, criterion, postprocessors, data_loader_val, base_ds, device, args.output_dir ) log_stats = {**{f'train_{k}': v for k, v in train_stats.items()}, **{f'test_{k}': v for k, v in test_stats.items()}, 'epoch': epoch, 'n_parameters': n_parameters} if args.output_dir and utils.is_main_process(): with (output_dir / "log.txt").open("a") as f: f.write(json.dumps(log_stats) + "\n") # for evaluation logs if coco_evaluator is not None: (output_dir / 'eval').mkdir(exist_ok=True) if "bbox" in coco_evaluator.coco_eval: filenames = ['latest.pth'] if epoch % 50 == 0: filenames.append(f'{epoch:03}.pth') for name in filenames: torch.save(coco_evaluator.coco_eval["bbox"].eval, output_dir / "eval" / name) total_time = time.time() - start_time total_time_str = str(datetime.timedelta(seconds=int(total_time))) print('Training time {}'.format(total_time_str))
import numpy as np import random from os import listdir from os.path import isfile, join random.seed(10000) number_of_datapoints = 10 #set this for output anomalities = "../OutlierDetector/outliers/" normal_digits = "../OutlierDetector/goodDigits/" anom_files = [f for f in listdir(anomalities) if isfile(join(anomalities, f))] print(anom_files) normal_files = [f for f in listdir(normal_digits) if isfile(join(anomalities, f))] print(normal_files) anom = {} # dict for storing anoms keys are "1" etc normal = {} for a in anom_files: anom[a.rstrip(".npy")] = np.load(join(anomalities + a)) for a in normal_files: normal[a.rstrip(".npy")] = np.load(join(normal_digits + a)) def generate_random_scenario(machine, sequence): result = [] for m in sequence:
# Textual Voronoi code modified from: <*****@*****.**> # http://www.ocf.berkeley.edu/~Eabhishek/ import random # for generateRandomPoints random.seed(42) from math import sqrt def generateRandomPoints(npoints=6): """Generate a few random points v1...vn""" print npoints, "points x,y:" points = [] for i in xrange(npoints): xrand, yrand = random.random(), random.random() print '%.2f' % xrand, '%.2f' % yrand for xoff in range(-1, 2): for yoff in range(-1, 2): points.append( (xrand + xoff, yrand + yoff) ) return points def closest(x,y,points): """Function to find the closest of the vi.""" best,good = 99.0*99.0, 99.0*99.0 for px, py in points: dist = (x-px)*(x-px) + (y-py)*(y-py) if dist < best: best, good = dist, best elif dist < good: good = dist return sqrt(best) / sqrt(good)
try: import pymongo as mg except ImportError as err: print(err) exit() maxSevSelDelay = 2 try: myclient = mg.MongoClient("mongodb://localhost:27017/", serverSelectionTimeoutMS=maxSevSelDelay) except mg.errors.ServerSelectionTimeoutError as err: print(err) exit() mydb = myclient["battleship"] random.seed() used_random_points = list() used_points = list() class Computer: def __init__(self): self.ships = list() self.hunt_mode = False self.player_ships = list() used_points.clear() used_random_points.clear() def place_ship(self, length): temp_list = list()
# -*- coding: utf-8 -*- """ Created on Fri Jun 7 09:20:40 2019 @author: lei """ import math import pickle import random random.seed(0) def rand(a, b): return (b - a) * random.random() + a def make_matrix(m, n, fill=0.0): mat = [] for i in range(m): mat.append([fill] * n) return mat def sigmoid(x): return 1.0 / (1.0 + math.exp(-x)) def sigmoid_derivative(x): return x * (1 - x)
def set_seed(seed): torch.manual_seed(seed) torch.cuda.manual_seed_all(seed) np.random.seed(seed) random.seed(seed) torch.backends.cudnn.deterministic = True
def fit(self, X_train=None, Y_train=None, X_test=None, Y_test=None, dataset_train=None, dataset_val=None, time_limit=None, **kwargs): start_time = time.time() params = self.params.copy() # TODO: kwargs can have num_cpu, num_gpu. Currently these are ignored. verbosity = kwargs.get('verbosity', 2) params = fixedvals_from_searchspaces(params) if 'min_data_in_leaf' in params: if params['min_data_in_leaf'] > X_train.shape[0]: # TODO: may not be necessary params['min_data_in_leaf'] = max(1, int(X_train.shape[0]/5.0)) num_boost_round = params.pop('num_boost_round', 1000) logger.log(15, 'Training Gradient Boosting Model for %s rounds...' % num_boost_round) logger.log(15, "with the following hyperparameter settings:") logger.log(15, params) seed_val = params.pop('seed_value', None) eval_metric = self.get_eval_metric() dataset_train, dataset_val = self.generate_datasets(X_train=X_train, Y_train=Y_train, X_test=X_test, Y_test=Y_test, dataset_train=dataset_train, dataset_val=dataset_val) gc.collect() if verbosity <= 1: verbose_eval = False elif verbosity == 2: verbose_eval = 1000 elif verbosity == 3: verbose_eval = 50 else: verbose_eval = True self.eval_results = {} callbacks = [] valid_names = ['train_set'] valid_sets = [dataset_train] if dataset_val is not None: callbacks += [ early_stopping_custom(150, metrics_to_use=[('valid_set', self.eval_metric_name)], max_diff=None, start_time=start_time, time_limit=time_limit, ignore_dart_warning=True, verbose=verbose_eval, manual_stop_file=False), ] valid_names = ['valid_set'] + valid_names valid_sets = [dataset_val] + valid_sets try_import_lightgbm() import lightgbm as lgb callbacks += [ # lgb.reset_parameter(learning_rate=lambda iter: alpha * (0.999 ** iter)), ] # lr_over_time = lambda iter: 0.05 * (0.99 ** iter) # alpha = 0.1 train_params = { 'params': params.copy(), 'train_set': dataset_train, 'num_boost_round': num_boost_round, 'valid_sets': valid_sets, 'valid_names': valid_names, 'callbacks': callbacks, 'verbose_eval': verbose_eval, } if type(eval_metric) != str: train_params['feval'] = eval_metric if seed_val is not None: train_params['params']['seed'] = seed_val random.seed(seed_val) np.random.seed(seed_val) # Train lgbm model: self.model = lgb.train(**train_params) # del dataset_train # del dataset_val # print('running gc...') # gc.collect() # print('ran garbage collection...') self.best_iteration = self.model.best_iteration params['num_boost_round'] = num_boost_round if seed_val is not None: params['seed_value'] = seed_val
north=0, south=0, west=0, east=0) return paths_nb try: for_seed, density, height, width = (abs( int(i)) for i in input('Enter four integers: ').split()) except ValueError: print('Incorrect input, giving up.') sys.exit() if not density: density = 1 seed(for_seed) grid = np.array([randrange(density) > 0 for _ in range(height * width)]).reshape((height, width)) print('Here is the grid that has been generated:') display_grid() try: i1, j1, i2, j2 = (int(i) for i in input('Enter four integers: ').split()) pt_1 = Point(i1, j1) pt_2 = Point(i2, j2) if not valid(pt_1) or not valid(pt_2): raise ValueError except ValueError: print('Incorrect input, giving up.') sys.exit() print('Will compute the number of good paths ' f'from ({pt_1.x}, {pt_1.y}) to ({pt_2.x}, {pt_2.y})...')
TRAIN_FILE_NAME = '~/Kaggle/RLI/input/train.json' TEST_FILE_NAME = '~/Kaggle/RLI/input/test.json' target_num_map = {'high': 0, 'medium': 1, 'low': 2} train_data = pd.read_json(TRAIN_FILE_NAME).reset_index() test_data = pd.read_json(TEST_FILE_NAME).reset_index() list_img_time = pd.read_csv("~/Kaggle/RLI/input/listing_image_time.csv") train_data = train_data.merge(list_img_time, left_on="listing_id", right_on="Listing_Id", how='inner') test_data = test_data.merge(list_img_time, left_on="listing_id", right_on="Listing_Id", how='inner') RS = 2016 random.seed(RS) np.random.seed(RS) # RS = 0 def validation_score(early_stop=False): clf = xgboostClassifier( objective='multi:softprob', eval_metric='mlogloss', num_class=3, nthread=3, eta=0.04, max_depth=6, subsample=0.7, colsample_bytree=1.0, colsample_bylevel=0.7,
import random import pickle import numpy as np def stop_condition_1(domain, error=0.05): N = 0 cond = (2 * domain.d_factor ** N * domain.Br) / (1 - domain.d_factor) ** 2 while cond > error: N += 1 cond = (2 * domain.d_factor ** N * domain.Br) / (1 - domain.d_factor) ** 2 return N if __name__ == "__main__": random.seed(2) domain = Domain() agent = Agent(domain) policy = agent.RANDOM_POLICY # print("Generating the set of four tuples ...") # four_tuples_set = agent.generate_four_tuples(policy) # #four_tuples_set = agent.generate_four_tuples2(policy) # print("Generation of the set completed.") # print("Compute statistics over the set...") # positiveRewards = 0 # negativeRewards = 0 # for t in four_tuples_set: # if t[2] == 1: # positiveRewards += 1 # elif t[2] == -1: # negativeRewards += 1
import matplotlib matplotlib.use('TkAgg') import matplotlib.pyplot as plt import time import os from optim import trust_region_newton_step, adaptive_trust_region_newton_step, trust_region_newton_step2 from newton_cg import trust_region_newton_cg from newton_cr import newton_step_cubic_regularization, newton_step_cr_cg, newton_adaptive_cubic_regularization, \ newton_adaptive_cr_cg import random # Then set a random seed for deterministic results/reproducability. SEED = 1234 random.seed(SEED) torch.manual_seed(SEED) torch.backends.cudnn.deterministic = True def parse_args(): parser = argparse.ArgumentParser( description='Train a classifier for CIFAR10') parser.add_argument('--model', dest='model', help='classifier type', default='CNN', type=str) parser.add_argument('--lr', dest='lr', help='learning rate',
from __future__ import division import numpy as np import random import datetime import copy from random import choice from math import log, sqrt random.seed("1234") class State(): def __init__(self, player1Cards, player2Cards, player3Cards, money, playersMoney, roundMoney): self.player1Cards = player1Cards self.player2Cards = player2Cards self.player3Cards = player3Cards self.money = money self.playersMoney = playersMoney self.roundMoney = roundMoney def __hash__(self): return hash((str(self.player1Cards), str(self.roundMoney))) # return hash((str(self.player1Cards), str(self.player2Cards), str(self.player3Cards), str(self.roundMoney))) # return hash((str(self.player1Cards), str(self.player2Cards), str(self.player3Cards), str(self.money), str(self.playersMoney), str(self.roundMoney))) class Board(): # Returns a representation of the starting state of the game. def init(self, playerCards): if len(playerCards) == 0:
def worker_init_fn(worker_id): random.seed(worker_id + opt.random_seed) np.random.seed(worker_id + opt.random_seed)
while len(clusters) < num_clusters: # choose the last-merged of our clusters next_cluster = min(clusters, key=get_merge_order) # remove it from the list clusters = [c for c in clusters if c != next_cluster] # and add its children to the list (i.e., unmerge it) clusters.extend(get_children(next_cluster)) # once we have enough clusters... return clusters if __name__ == "__main__": inputs = [[-14,-5],[13,13],[20,23],[-19,-11],[-9,-16],[21,27],[-49,15],[26,13],[-46,5],[-34,-1],[11,15],[-49,0],[-22,-16],[19,28],[-12,-8],[-13,-19],[-41,8],[-11,-6],[-25,-9],[-18,-3]] random.seed(0) # so you get the same results as me clusterer = KMeans(3) clusterer.train(inputs) print "3-means:" print clusterer.means print random.seed(0) clusterer = KMeans(2) clusterer.train(inputs) print "2-means:" print clusterer.means print print "errors as a function of k"