def menu(): initialize() while 1: usr_inp=raw_input("brutus>") if usr_inp=="": usr_inp=raw_input("brutus>") elif usr_inp=="quit" or usr_inp=="exit": quit() elif usr_inp=="help": print("\n") help() elif usr_inp=="clear": os.system("clear") elif usr_inp=="ssh": ssh_brute() elif usr_inp=="ftp": ftp_brute() elif usr_inp=="smtp": smtp() elif usr_inp=="facebook": facebook_brute() elif usr_inp=="twitter": twitter_brute() else: print(usr_inp+": command not recognised ~brutus")
def calibrate(): initialize() motor['C'].on_for_rotations(25, -2.5) def thread1(): while True: sleep(0.25) carriage_move(0) variables['LinePosition'] = 0 sleep(0.25) line_width = variables['LineWidth'] carriage_move(line_width) variables['LinePosition'] = line_width if buttons.test((CENTER, ), State.BUMPED): break carriage_move(525) motor['C'].on_for_rotations(25, 3) def thread2(): while True: buttons.wait((UP, CENTER, DOWN), State.PRESSED) button = buttons.read() if button == UP: motor['C'].on_for_degrees(25, 5) elif button == DOWN: motor['C'].on_for_degrees(-25, 5) elif button == CENTER: # This is not in the EV3-G program, but is needed in order for # the program to exit, otherwise this thread keeps running. raise SystemExit fork(thread1, thread2)
def r8_uniform_01(): #*****************************************************************************80 # ## R8_UNIFORM_01 returns a uniform random real number in [0,1]. # # Discussion: # # This procedure returns a random floating point number from a uniform # distribution over (0,1), not including the endpoint values, using the # current random number generator. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 27 May 2013 # # Author: # # Original Pascal version by Pierre L'Ecuyer, Serge Cote. # MATLAB version by John Burkardt. # # Reference: # # Pierre LEcuyer, Serge Cote, # Implementing a Random Number Package with Splitting Facilities, # ACM Transactions on Mathematical Software, # Volume 17, Number 1, March 1991, pages 98-111. # # Parameters: # # Output, real R8_UNIFORM_01, a uniform random value in [0,1]. # from i4_uniform import i4_uniform from initialize import initialize from initialized_get import initialized_get # # Check whether the package must be initialized. # if (not initialized_get()): print '' print 'R8_UNIFORM_01 - Note:' print ' Initializing RNGLIB package.' initialize() # # Get a random positive integer. # i = i4_uniform() # # Scale it to a random real in [0,1]. # value = i * 4.656613057E-10 return value
def test(img_path: str = 'data/custom/images/', anno_path: str = 'data/custom/annos/') -> None: # transform something initialize(img_path=img_path, anno_path=anno_path, split_ratio=1.0) # some common config iou_thres = 0.5 conf_thres = 0.01 nms_thres = 0.5 img_size = 416 batch_size = 16 device = tc.device('cuda' if tc.cuda.is_available() else 'cpu') # other paths weights_path = 'my/yolov3_ckpt_1.pth' model_def = 'config/custom.cfg' test_path = 'data/custom/train.txt' class_path = 'data/custom/classes.names' # load model class_names = load_classes(class_path) model = Darknet(model_def).to(device) model.load_state_dict(tc.load(weights_path)) imgs, img_detections = detect( model=model, path=img_path, conf_thres=conf_thres, nms_thres=nms_thres, img_size=img_size, batch_size=batch_size, n_cpu=8, device=device, ) os.makedirs('predicted_file', exist_ok=True) class1 = open('predicted_file/det_test_core.txt', 'w') class2 = open('predicted_file/det_test_coreless.txt', 'w') for path, boxes in zip(imgs, img_detections): w, h = Image.open(path).size boxes = rescale_boxes(boxes, img_size, (h, w)) for box in boxes: line = [ # os.path.split(path)[1].split('_')[1].split('.')[0], # no prefix os.path.split(path)[1].split('.')[0], # with prefix 'core_' or 'coreless_' f'{box[4].tolist():.3f}', # conf f'{box[0].tolist():.1f}', f'{box[1].tolist():.1f}', f'{box[2].tolist():.1f}', f'{box[3].tolist():.1f}', ] if box[-1] == 0.0: class1.write(' '.join(line) + '\n') elif box[-1] == 1.0: class2.write(' '.join(line) + '\n') class1.close() class2.close() print('Output file saved.\n')
def r4_uniform_01 ( ): #*****************************************************************************80 # ## R4_UNIFORM_01 returns a uniform random real number in [0,1]. # # Discussion: # # This procedure returns a random floating point number from a uniform # distribution over (0,1), not including the endpoint values, using the # current random number generator. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 27 May 2013 # # Author: # # Original Pascal version by Pierre L'Ecuyer, Serge Cote. # MATLAB version by John Burkardt. # # Reference: # # Pierre LEcuyer, Serge Cote, # Implementing a Random Number Package with Splitting Facilities, # ACM Transactions on Mathematical Software, # Volume 17, Number 1, March 1991, pages 98-111. # # Parameters: # # Output, real R4_UNIFORM_01, a uniform random value in [0,1]. # from i4_uniform import i4_uniform from initialize import initialize from initialized_get import initialized_get # # Check whether the package must be initialized. # if ( not initialized_get ( ) ): print '' print 'R4_UNIFORM_01 - Note:' print ' Initializing RNGLIB package.' initialize ( ) # # Get a random positive integer. # i = i4_uniform ( ) # # Scale it to a random real in [0,1]. # value = i * 4.656613057E-10 return value
def get_state(): #*****************************************************************************80 # ## GET_STATE returns the state of the current generator. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 27 May 2013 # # Author: # # Original Pascal version by Pierre L'Ecuyer, Serge Cote. # PYTHON version by John Burkardt. # # Reference: # # Pierre LEcuyer, Serge Cote, # Implementing a Random Number Package with Splitting Facilities, # ACM Transactions on Mathematical Software, # Volume 17, Number 1, March 1991, pages 98-111. # # Parameters: # # Output, integer CG1, CG2, the CG values for the current generator. # from cg_get import cg_get from cgn_get import cgn_get from initialize import initialize from initialized_get import initialized_get # # Check whether the package must be initialized. # if (not initialized_get()): print '' print 'GET_STATE - Note:' print ' Initializing RNGLIB package.' initialize() # # Get the current generator index. # g = cgn_get() # # Retrieve the seed values for this generator. # [cg1, cg2] = cg_get(g) return cg1, cg2
def get_state ( ): #*****************************************************************************80 # ## GET_STATE returns the state of the current generator. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 27 May 2013 # # Author: # # Original Pascal version by Pierre L'Ecuyer, Serge Cote. # PYTHON version by John Burkardt. # # Reference: # # Pierre LEcuyer, Serge Cote, # Implementing a Random Number Package with Splitting Facilities, # ACM Transactions on Mathematical Software, # Volume 17, Number 1, March 1991, pages 98-111. # # Parameters: # # Output, integer CG1, CG2, the CG values for the current generator. # from cg_get import cg_get from cgn_get import cgn_get from initialize import initialize from initialized_get import initialized_get # # Check whether the package must be initialized. # if ( not initialized_get ( ) ): print '' print 'GET_STATE - Note:' print ' Initializing RNGLIB package.' initialize ( ) # # Get the current generator index. # g = cgn_get ( ) # # Retrieve the seed values for this generator. # [ cg1, cg2 ] = cg_get ( g ) return cg1, cg2
def rnglib_test01(): #*****************************************************************************80 # ## RNGLIB_TEST01 calls I4_UNIFORM 10 times, just to show how it is done. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 27 May 2013 # # Author: # # John Burkardt # from cgn_set import cgn_set from i4_uniform import i4_uniform from initialize import initialize print '' print 'RNGLIB_TEST01' print ' I4_UNIFORM ( ) returns a random positive integer' print ' using the current generator.' # # Initialize the package. # print '' print ' INITIALIZE initializes the random number generator.' print ' It only needs to be called once before using the package.' initialize() # # Set the current generator index to #1. # g = 1 cgn_set(g) print '' print ' Current generator index = %d' % (g) # # Now call I4_UNIFORM(). # print '' print ' I I4_UNIFORM ( )' print '' for i in range(1, 11): j = i4_uniform() print ' %2d %12d' % (i, j)
def rnglib_test01 ( ): #*****************************************************************************80 # ## RNGLIB_TEST01 calls I4_UNIFORM 10 times, just to show how it is done. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 27 May 2013 # # Author: # # John Burkardt # from cgn_set import cgn_set from i4_uniform import i4_uniform from initialize import initialize print '' print 'RNGLIB_TEST01' print ' I4_UNIFORM ( ) returns a random positive integer' print ' using the current generator.' # # Initialize the package. # print '' print ' INITIALIZE initializes the random number generator.' print ' It only needs to be called once before using the package.' initialize ( ) # # Set the current generator index to #1. # g = 1 cgn_set ( g ) print '' print ' Current generator index = %d' % ( g ) # # Now call I4_UNIFORM(). # print '' print ' I I4_UNIFORM ( )' print '' for i in range ( 1, 11 ): j = i4_uniform ( ) print ' %2d %12d' % ( i, j )
def rnglib_test02(): #*****************************************************************************80 # ## RNGLIB_TEST02 calls R4_UNIFORM_01 10 times, just to show how it is done. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 27 May 2013 # # Author: # # John Burkardt # from cgn_set import cgn_set from initialize import initialize from r4_uniform_01 import r4_uniform_01 print '' print 'RNGLIB_TEST02' print ' R4_UNIFORM_01 ( ) returns a random real number' print ' in [0,1] using the current generator.' # # Initialize the package. # print '' print ' INITIALIZE initializes the random number generator.' print ' It only needs to be called once before using the package.' initialize() # # Set the current generator index to #2. # g = 2 cgn_set(g) print '' print ' Current generator index = %d' % (g) # # Repeatedly call R4_UNIFORM_01(). # print '' print ' I R4_UNIFORM_01 ( )' print '' for i in range(1, 11): u = r4_uniform_01() print ' %2d %14.6g' % (i, u)
def rnglib_test02 ( ): #*****************************************************************************80 # ## RNGLIB_TEST02 calls R4_UNIFORM_01 10 times, just to show how it is done. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 27 May 2013 # # Author: # # John Burkardt # from cgn_set import cgn_set from initialize import initialize from r4_uniform_01 import r4_uniform_01 print '' print 'RNGLIB_TEST02' print ' R4_UNIFORM_01 ( ) returns a random real number' print ' in [0,1] using the current generator.' # # Initialize the package. # print '' print ' INITIALIZE initializes the random number generator.' print ' It only needs to be called once before using the package.' initialize ( ) # # Set the current generator index to #2. # g = 2 cgn_set ( g ) print '' print ' Current generator index = %d' % ( g ) # # Repeatedly call R4_UNIFORM_01(). # print '' print ' I R4_UNIFORM_01 ( )' print '' for i in range ( 1, 11 ): u = r4_uniform_01 ( ) print ' %2d %14.6g' % ( i, u )
def main(): if initialize(version=__version__): # Primary while True: main_loop()
def startGame(self): self.stopB.configure(state="normal") self.pauseB.configure(state="normal") self.startB.configure(state="disabled") self.gameRunning = True self.gameOver = False self.gameScore = 0 initialize.initialize(self.canvas) #self.player = self.canvas.create_rectangle(100,100,200,200) #self.canvas.addtag_closest("player",100,100) #self.master.bind("<Key>",self.keyPress) self.currentFrameIndex = 1 self.keyF = len(self.key)*[-setupVars.deadFrames] self.currentFrameLabel.configure(text="Frame: {}".format(self.currentFrameIndex)) self.key = [0,0,0,0] self.updateGame()
def main(): file_dict = initialize.initialize() logger = logging.Logger("primary_driver", level=logging.INFO) sensor_watcher = SensorWatcher() point_cloud_generator = PointCloudGenerator(POINT_CLOUD_FILE_NAME, TARGET_LOCATIONS_FILE_NAME) real_time_visualizer = RealTimeVisualizer(POINT_CLOUD_FILE_NAME) sensor_watcher.add_subscriber(point_cloud_generator) point_cloud_generator.add_subscriber(real_time_visualizer) sensor_watcher.begin() while not sensor_watcher.finished: time.sleep(1) data_filterer = DataFilterer(file_dict) mesh_generator = MeshGenerator(file_dict) data_filterer.begin() while not data_filterer.finished: time.sleep(1) mesh_generator.begin() while not mesh_generator.finished: time.sleep(1) logger.info("Completed all ATLAS software :)")
def main(): args = get_args() wandb.init() wandb.config.update(args) seed = 42 torch.manual_seed(seed) torch.cuda.manual_seed_all(seed) torch.backends.deterministic = True torch.backends.cudnn.benchmark = False loaded_model = False [train_loader, valid_loader, model, optimizer] = initialize(args, loaded_model) scaler = torch.cuda.amp.GradScaler() wandb.watch(model) best_acc = 0 run_avg = RunningAverage() # scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min') # scheduler = torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr=0.001, max_lr=0.1, cycle_momentum=False) for epoch in range(1, args.epochs_number + 1): run_avg.reset_train() run_avg.reset_val() train(args, model, train_loader, epoch, optimizer, scaler, run_avg) val_acc = evaluation(args, model, valid_loader, epoch, run_avg) # scheduler.step() if best_acc < val_acc: best_acc = val_acc save_checkpoint(model, optimizer, args, epoch)
def main(server=SERVER, me=ME, you=YOU): # init MQTT c = MQTTClient(me, server) c.set_callback(handle_message) c.connect() c.subscribe(('ev3dev-telegraph-net/' + you).encode()) topic = ('ev3dev-telegraph-net/' + me).encode() # init printer initialize() feed_in() def thread1(): """Continuously process the queue of letters.""" motor['C'].on_for_rotations(50, -2.5) carriage_move(0) process_queue() carriage_move(525) def thread1_1(): motor['C'].on_for_rotations(50, 2.5) def thread1_2(): feed_out() fork(thread1_1, thread1_2) def thread2(): """Continuously monitor the touch sensor and convert the Morse code sequence into a letter index which gets published. """ read_code(lambda l: c.publish(topic, bytes((l, )))) def thread3(): """This will wait for any MQTT messages, and add them to the letter queue via handle_message(). """ while True: try: c.wait_msg() except OSError as err: if err.args[0] == EINTR: continue raise fork(thread1, thread2, thread3)
def simSeason(schedules, east, depth_df, pca_s, pca_b, RF, teams, win_prob_power, injury_freq, injury_print=False): global injuries global depth standings, injuries, depth_df = initialize(schedules, east, depth_df) season = pd.concat(schedules.apply(lambda x: runGame(depth_df, injuries, x, injury_freq, injury_print), axis=1).values.tolist()).sort_values('gmDateTime').reset_index(drop=True) season = aggWinner(season, pca_s, pca_b, RF, win_prob_power) for team in teams: standings[team]['W'] = season[season['teamAbbr']==team].IsWinner.sum() standings[team]['L'] = 82-season[season['teamAbbr']==team].IsWinner.sum() return(season, injuries, standings)
def main(): # Initialize the data network to be the correct size/ shape nodes = initialize(networkfile) # Run through the actual simulation stuff results = solve(nodes, 1.0e-6) # Display the results for node in results: printNode(node)
def main(): file_dict = initialize.initialize() logger = logging.Logger("primary_driver", level=logging.INFO) mesh_generator = MeshGenerator(file_dict) mesh_generator.begin() while not mesh_generator.finished: time.sleep(1) logger.info("Completed all ATLAS software :)")
def __init__(self, league): """ Create self.batters and self.pitchers, lists where every entry represnts a fantasy team. These are ordered by league team number. Each entry is a dictionary of statistics for that team. """ startv = initialize('roto.ini') self.batters = [] self.pitchers = [] for tmno in range(0,12): tmdata = log_team(league, tmno+1) self.batters.append(get_extrap(tmdata[0], startv['totalg'], startv['sofar'])) self.pitchers.append(get_extrap(tmdata[1], startv['totalg'], startv['sofar']))
def __init__(self, path, filepath, executable, fuzzer, use_default=True, prototype=''): """ path => Path to the root directory of source to be fuzzed filepath => Relative path of file containing main from root directory of source executable => Name of final executable generated fuzzer => Relative path to fuzzer from root directory of source use_default => Flag indicating whether to fuzz a particular function or start fuzzing from main prototype => prototype of function to be fuzzed. Will only be considered if use_default is True """ self.template = open('template.cpp', 'r').read() self.path = path self.filename = filepath.split('/')[-1] self.executable = executable self.sourcepath = ''.join(x for x in filepath.split('/')[:-1]) self.libpath = self.path + '/' + self.sourcepath print "[-] Intializing" initializeObject = initialize(self.path) print "[+] Done" chdir(self.sourcepath) open('test.cpp', 'w').write(self.template) print "[-] Modifying main to runner" backupObject = backup(self.filename, initializeObject.getOutput()) print "[+] Done" print "[-] Building shared object" libraryObject = makeObject(initializeObject.getOutput(), self.executable) print "[+] Done" if use_default is False and prototype is not '': print "[-] Creating fuzzer targeting arbitrary function" customObject = makeFuzzer(prototype) print "[+] Done" print "[-] Compiling fuzzer" compilefuzzer(libraryObject.getLibFlags(), '../' + fuzzer) print "[+] Done" print "[-] Starting fuzzing" call('./test', env=dict(environ, LD_LIBRARY_PATH=self.libpath))
def printer(): initialize() feed_in() def thread1(): """Continuously process the queue of letters.""" motor['C'].on_for_rotations(50, -2.5) carriage_move(0) process_queue() carriage_move(525) def thread1_1(): motor['C'].on_for_rotations(50, 2.5) def thread1_2(): feed_out() fork(thread1_1, thread1_2) def thread2(): """Continuously monitor the touch sensor and convert the Morse code sequence into a letter index which gets added to the letter queue. """ read_code() def thread3(): """This will wait for any bluetooth letter messages, and add them to the letter queue. This is only relevent if you are using 2 EV3 units to have a separate transmitter and receiver. """ while True: letter = messaging.wait_update('Letter') queue = variables['Queue'] variables['Queue'] = write_at_index(queue, len(queue), letter) fork(thread1, thread2, thread3)
def __init__(self): """Init Function for class controls""" FORMAT = '%(asctime)-s-%(levelname)s-%(message)s' logging.basicConfig(format=FORMAT, filename='hivetests.log', filemode='w', level='INFO') logging.getLogger("requests").setLevel(logging.WARNING) self.logger = logging.getLogger(__name__) self.results = defaultdict( lambda: defaultdict(lambda: defaultdict(lambda: []))) self.rowsOnQuery = defaultdict(lambda: 'NA') self.start_end = defaultdict(lambda: ['NA', 'NA']) self.epochdict = defaultdict(lambda: defaultdict(lambda: ['NA', 'NA'])) self.containers = defaultdict(lambda: defaultdict(lambda: 0)) self.pstat = partialStats.pstats(self.logger) self.initializer = initialize.initialize(self.logger)
def locate_particles(self, observations): """ use particle filtering to locate point. The dataframe represent all the duty cycle for a participants. Each duty cycle has the strongest signals from the routers seen """ # call particle filtering algorithm # returns a list of xytuples #change to particle filter call #limit to initial observation obs = observations.loc[observations['record_time'] == observations.record_time.unique()[0]] points_list = pf.particle_filter(observations, init.initialize(obs)) # reformat to single dataframe points = pd.concat(points_list, ignore_index=True) #save the list of data frames to a csv file points.to_csv('particle.csv', sep='\t') return points
def main(): logger = logging.Logger("pipeline_test", level=logging.INFO) configuration_dictionary = initialize.initialize() # We need to fake out the data passed to PointCloudGenerator. This process does so. parser = BluetoothParser() gen = PointCloudGenerator(configuration_dictionary) real_time_visualizer = RealTimeVisualizer(POINT_CLOUD_FILE_NAME, PACKAGE_LOCATIONS_FILE_NAME) # The parser expects byte data like the serial passes. with open(RAW_DATA_PATH, "rb") as f: data = f.read() for c in data: r = parser.add_data(bytes((c, ))) if r is not None: gen.signal(UpdateSignal.NEW_DATA, r) gen.mark_finished() data_filterer = DataFilterer(configuration_dictionary) data_filterer.begin() while not data_filterer.finished: time.sleep(1) mesh_generator = MeshGenerator(configuration_dictionary) mesh_generator.begin() while not mesh_generator.finished: time.sleep(1) point_cloud_visualizer = PointCloudVisualizer(UNCERTAINTY_PATH) point_cloud_visualizer.begin() logger.info("Completed all ATLAS software :)")
def execGameCommonInitializeScript(channelName, platformId, appVersion, resVersion, platformType): if (os.path.exists(file_operate.getGameCommonScriptPath())): gameCommonInitScriptBat = file_operate.getGameCommonScriptPath() + "/initialize.bat" if (os.path.exists(gameCommonInitScriptBat)): cmd = '"%s" "%s" "%s" "%s" "%s"' % (gameCommonInitScriptBat, platformId, channelName, appVersion, resVersion) ret = file_operate.execFormatCmd(cmd) if ret: print "execute initialize.bat error" return 1 gameCommonInitScriptExe = file_operate.getGameCommonScriptPath() + "/initialize.exe" if (os.path.exists(gameCommonInitScriptExe)): cmd = '"%s" "%s" "%s" "%s" "%s"' % (gameCommonInitScriptExe, platformId, channelName, appVersion, resVersion) ret = file_operate.execFormatCmd(cmd) if ret: print "execute initialize.exe error" return 1 gameCommonInitScriptPyc = file_operate.getGameCommonScriptPath() + "/initialize.pyc" if os.path.exists(gameCommonInitScriptPyc): sys.path.append(file_operate.getGameCommonScriptPath()) import initialize ret = initialize.initialize(platformId, channelName, platformType, appVersion, resVersion)
def main(username, password): global isRunning global all_processes global haveOpened global p, all_processes global user haveOpened = False isRunning = True AEROSPACE_LOGO = "../assets/logo.png" A_LOGO = "../assets/A_logo.jpg" webcameraSource = initialize.initialize() all_processes = [] panelHeight = 250 panelWidth = 250 # Things that the button does on click # Runs a subprocess if there isn't one running # Otherwise polls to see if there is a subprocess to kill def helloCallBack(widget): global haveOpened if (haveOpened == False): global p, all_processes p = Popen([ "python", "button_popen.py", str(webcameraSource), username, password ]) all_processes.append(p) haveOpened = True widget['background'] = 'red' widget['text'] = 'STOP' isRunning = True else: poll = p.poll() if (poll == None): all_processes.remove(p) p.kill() widget['background'] = 'green' widget['text'] = 'START' isRunning = False else: p = Popen([ "python", "button_popen.py", str(webcameraSource), username, password ]) all_processes.append(p) widget['background'] = 'red' widget['text'] = 'STOP' isRunning = True # Kills all subprocesses that are running if there are any # Also sets isRunning to False so the thread can stop def cleanup(): global all_processes, isRunning if len(all_processes) != 0: isRunning = False for p in all_processes: # list of your processes if isinstance(p, Popen) and p.poll() == None: p.kill() # Thread to constantly poll if a process is running or not # Reverts the button back to normal if it detects that the process stopped def pollProcesses(widget): global all_processes, isRunning while (isRunning): if len(all_processes) != 0: for p in all_processes: if isinstance(p, Popen) and p.poll() != None: widget['background'] = 'green' widget['text'] = 'START' isRunning = False # Honestly a horrible idea. # If the array isn't always size 0 or 1 this could lead to some real issues all_processes.remove(p) def recalibrate(): # Note: not tested on linux. if (platform.system() != 'Darwin'): user = firebase_login.signIntoFirebase(username, password) p = Popen(["python", "calibration.py"], stdin=PIPE, stdout=PIPE) p.wait() calibration_vals = p.returncode p.stdout.readline() p.stdout.readline() firebase_login.updateEyeRatio(username, user, float(p.stdout.readline())) firebase_login.updateMouthRatio(username, user, float(p.stdout.readline())) p.kill() else: user = firebase_login.signIntoFirebase(username, password) calibration_vals = calibration.main() firebase_login.updateEyeRatio(username, user, calibration_vals[0]) firebase_login.updateMouthRatio(username, user, calibration_vals[1]) atexit.register(cleanup) top = Tkinter.Tk() imageText = "AEROSPACE DROWSINESS DETECTOR" logo = Image.open(A_LOGO) photo = ImageTk.PhotoImage(logo) label = Tkinter.Label(top, text=imageText) label.pack() top.title("Drowsiness Detector") #top.resizable(False, False) #top.iconbitmap(default="../assets/icon.ico") photoPanel = Tkinter.Canvas(top, width=panelWidth, height=panelHeight) photoPanel.pack(side='top', fill='both', expand='yes') photoPanel.create_image(panelWidth / 2, panelHeight / 2, image=photo) B = Tkinter.Button(top, height=2, width=10, background='green', text='START') B.config(command=lambda arg=B: helloCallBack(arg)) B.pack() C = Tkinter.Button(top, height=2, width=10, background='green', text='RECALIBRATE') C.config(command=recalibrate) C.pack() t = Thread(target=pollProcesses, args=(B, )) t.daemon = True t.start() top.mainloop()
T_min = 0.001 T_max = int(float(sys.argv[9]) * N1 * N2) # 40 num_T = int(float(sys.argv[10]) * T_max) # 400 ## MC num_warmup = 1000 num_sampling = 200 num_mc = 100 ######################## alpha = np.pi / theta_factor # build lattice w_clean, n_clean = buildLattice(N1, N2, alpha, neigb_cutOff) lattice = np.zeros([N1, N2]) # initialize random initialize(lattice) # must use neighbs and weight now E_int = getEnergy(lattice, n_clean, w_clean, J, H) P_int = getTotalPolarization(lattice) print '\n\n ******** ', E_int, P_int print lattice # temps dT = (T_max - T_min) / (num_T + 0.0) Temps = np.array([T_min + t * dT for t in range(num_T)]) Temps = list(Temps[::-1]) ### for t in Temps ... #Temp = Temps[0] E_vs_T = np.zeros([len(Temps), 2]) E2_vs_T = np.zeros([len(Temps), 2])
def rnglib_test04 ( ): #*****************************************************************************80 # ## RNGLIB_TEST04 demonstrates the use of multiple streams. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 27 May 2013 # # Author: # # John Burkardt # from cgn_set import cgn_set from init_generator import init_generator from initialize import initialize from r4_uniform_01 import r4_uniform_01 print '' print 'RNGLIB_TEST04' print ' R4_UNIFORM_01 ( ) returns a random real number' print ' in [0,1] using the current generator.' # # Initialize the package. # print '' print ' INITIALIZE initializes the random number generator.' print ' It only needs to be called once before using the package.' initialize ( ) print '' print ' Let us call generators #3, #6 and #9.' # # Use three separate generators, 3, 6 and 9. # Force them to start at their initial seeds. # g = [ 3, 6, 9 ] print '' for j in range ( 0, 3 ): print ' Initialize generator %d' % ( g[j] ) cgn_set ( g[j] ) init_generator ( 0 ) # # Call the generators in the order 3, 6, 9. # print '' print ' I R4_UNIFORM_01 ( 3 ) R4_UNIFORM_01 ( 6 ) R4_UNIFORM_01 ( 9 )' print '' for i in range ( 1, 11 ): print ' %2d' % ( i ), for j in range ( 0, 3 ): cgn_set ( g[j] ) u = r4_uniform_01 ( ) print ' %14.6g' % ( u ), print '' # # Restart the generators at their initial seeds. # g = [ 6, 9, 3 ] print '' for j in range ( 0, 3 ): print ' Reinitialize generator %d' % ( g[j] ) cgn_set ( g[j] ) init_generator ( 0 ) # # Call them in a different order, same result. # print '' print ' I R4_UNIFORM_01 ( 6 ) R4_UNIFORM_01 ( 9 ) R4_UNIFORM_01 ( 3 )' print '' for i in range ( 1, 11 ): print ' %2d' % ( i ), for j in range ( 0, 3 ): cgn_set ( g[j] ) u = r4_uniform_01 ( ) print ' %14.6g' % ( u ), print ''
continue if simulation and now > end_date: break # happens on the same day as the call to the logic module, but AFTER the call to the logic module if not initialized and (now.hour, now.minute) >= (16, 15): # important: does not trigger after midnight, to avoid the violations of assumptions made about now_date # in relation to the execution of the logicModule, which is set for the next day. if not simulation: print('') print(now.strftime("%Y/%m/%d %H:%M:%S") + ' Initialization') now_date = date(year=now.year, month=now.month, day=now.day) if not simulation or (now_date - last_initialization_day ).days >= initialization_frequency: initialize.initialize(now_date - datetime.timedelta(days=365), now_date, simulation) last_initialization_day = now_date initialized = True if not simulation and initialized and not balance_requested and ( now.hour, now.minute) >= (13, 58): if alpaca_enabled: alpaca_value = alpaca.sell_all() if trading212_enabled: print('\nSELL ALL STOCKS NOW!') playsound.playsound('gong.wav') # balance_eur = 1.0 # deposits_eur = 0.0 while True:
'Kyle.tsv', 'Hinton.tsv', 'Jake.tsv', 'Jonathan.tsv', 'Hannah.tsv', 'Sahil.tsv', 'Emily.tsv', 'Sam.tsv', 'Alanna.tsv', 'Griffin.tsv', 'Xia.tsv', 'Matt.tsv', ] # 1. Import data initialize() module_log = logging.getLogger(__name__) module_log.info('Importing info') people = [] for f in files: people.append(Person.initFromFile(file_dir + f)) # 2. Make sure days and times are the same and all avail entries valid module_log.info('Error checking data') days = people[0].days times = people[0].times for i, p in enumerate(people): if not p.seats >= 0: module_log.error(f'Number of seats must be greater than or equal to zero. See file {i}') if sorted(p.days) != sorted(days): module_log.error(f'Not all days the same. See file {i}.')
def run_attm(self): """ Program sequence """ #==================================================== # Initialization Process #==================================================== print '===================' print ' Initializing ATTM' print '===================' read_control.read_control(self) initialize.initialize(self) read_layers.read_layers(self) model_domain.model_domain(self) create_attm_cohort_arrays.create_attm_cohort_arrays(self) if self.Simulation_area.lower() == 'barrow': initial_cohort_population.barrow_initial_cohort_population(self) initial_cohort_check.barrow_initial_cohort_check(self) cohort_present.barrow_cohort_present(self) elif self.Simulation_area.lower() == 'tanana': initial_cohort_population.tanana_initial_cohort_population(self) initial_cohort_check.tanana_initial_cohort_check(self) cohort_present.tanana_cohort_present(self) #======================================= # READ MET Data & Calculate Degree Days #======================================= initialize.Met(self) #++++++++++++++++++++++++++++++++++++++++++++++ # ======================================== # INITIALIZE BARROW COHORT PROPERTIES # ======================================== #++++++++++++++++++++++++++++++++++++++++++++++ if self.Simulation_area.lower() == 'barrow': print '=================================== ' print ' Initializing Lake & Pond Properties' print '====================================' initialize.LakePond(self) set_lake_pond_depth.set_lake_pond_depth(self) set_lake_ice_depth_constant.set_lake_ice_depth_constant(self) set_ice_thickness_array.set_ice_thickness_array(self) climate_expansion_arrays.set_climate_expansion_arrays(self) set_pond_growth_array.set_pond_growth_array(self) print '=====================================' print ' Initializing Terrestrial Properties' print '=====================================' initialize.Terrestrial_Barrow(self) read_ice_content.read_ice_content(self) read_drainage_efficiency.read_drainage_efficiency(self) read_initial_ALD.read_initial_ALD(self) set_ALD_constant.set_ALD_constant(self) set_ALD_array.set_ALD_array(self) set_protective_layer.set_protective_layer(self) set_initial_cumulative_probability.set_initial_cumulative_probability(self) # Initializing Terrestrial Cohort Properties initialize.Wet_NPG(self) initialize.Wet_LCP(self) initialize.Wet_CLC(self) initialize.Wet_FCP(self) initialize.Wet_HCP(self) # Other needed information [in the future] initial_cohort_age.initial_cohort_age(self) elif self.Simulation_area.lower() == 'tanana': print '======================================' print ' Initializing Terrestrial Properties ' print '======================================' initialize.Terrestrial_Tanana(self) print '==================================================' print ' Starting the MAIN LOOP ' print '==================================================' initialize.run(self) for time in range(0, self.stop): if time == 0: if self.Simulation_area.lower() == 'barrow': cohorts.initial_barrow(self) elif self.Simulation_area.lower() == 'tanana': cohorts.initial_tanana(self) print ' at time step: ', time # ++++++++++++++++++++++++++++++++++++++ # Check for significant climatic event # ++++++++++++++++++++++++++++++++++++++ check_climate_event.check_climate_event(self) # ---------------------------------------------------------- # Looping over elements # ---------------------------------------------------------- for element in range(0, self.ATTM_nrows * self.ATTM_ncols): # ---------------------------------------------------- # Define the total fractional area of cohorts for # each element # ---------------------------------------------------- cohort_start = cohort_check.cohort_start(self, element, time) # ---------------------------------------------------- # Expand/Infill lake & ponds by prescribed rates # ---------------------------------------------------- lake_pond_expansion.lake_pond_expansion(self, element) lake_pond_expansion.pond_infill(self, element, time) # ---------------------------------------------------------- # Set active layer depth # --------------------------------------------------------- active_layer_depth.active_layer_depth(self, time, element) # ---------------------------------- # Cycle through terrestrial cohorts # ---------------------------------- check_Wet_NPG.check_Wet_NPG(self, element, time) check_Wet_LCP.check_Wet_LCP(self, element, time) check_Wet_CLC.check_Wet_CLC(self, element, time) check_Wet_FCP.check_Wet_FCP(self, element, time) check_Wet_HCP.check_Wet_HCP(self, element, time) # ---------------------------------- # Set pond/lake ice thickness depth # ---------------------------------- ice_thickness.ice_thickness(self, time, element) # ------------------------------ # Cycle through ponds and lakes # ------------------------------ check_Ponds.check_Ponds(self, element, time) check_Lakes.check_Lakes(self, element, time) # ------------------------------------------------- # Cohort Fraction Check (mass balance of cohorts) # ------------------------------------------------- cohort_check.cohort_check(self, element, time, cohort_start) if time == self.stop-1: if self.Simulation_area.lower() == 'barrow': cohorts.final_barrow(self) elif self.Simulation_area.lower() == 'tanana': cohorts.final_tanana(self) # ======================================================================== # END MAIN LOOP # ======================================================================== # ======================================================================== # OUTPUT RESULTS (if requested) # ======================================================================== # - - - - - - - - - # Fractional Areas # - - - - - - - - - Output_cohorts_by_year.Output_cohorts_by_year(self, time) # - - - - - - - - - - - - - # Dominant Fractional Area # - - - - - - - - - - - - - Output_cohorts_by_year.dominant_cohort(self) # Terrestrial_Control Output_cohorts_by_year.dominant_fractional_plot(self, time) # Terrestrial_Control # ================================= # OUTPUT ANIMATIONS (if requested) # ================================= # - - - - - - - - - - - - - - - # Fractional Area of Cohorts # - - - - - - - - - - - - - - - - Output_cohorts_by_year.write_Fractions_avi(self) Output_cohorts_by_year.write_Dominant_Cohort_avi(self) # Terrestrial_Control # ------------------- # Simulation End Time # ------------------- clock.finish(self) #=========================== # Output Simulation Results #=========================== if self.results_onscreen.lower() == 'yes': results.on_screen(self) if self.archive_simulation.lower() == 'yes': results.on_file(self) # ================ # Archive Results # ================ if self.archive_simulation.lower() == 'yes': #---------------------------------------------------------------------------------------------------------- # Create the tarfile #---------------------------------------------------------------------------------------------------------- self.archive_file =tarfile.open(self.control['Run_dir']+self.Output_directory+str('/Archive/')+ \ self.archive_time+str('_')+self.simulation_name+".tar.gz", mode='w:gz') #---------------------------------------------------------------------------------------------------------- archive.read_archive(self) archive.archive(self) print '----------------------------------------' print ' Simulation Complete ' print '----------------------------------------'
def run_atm(self): """ Program sequence """ #==================================================== # Initialization Process #==================================================== print '===================' print ' Initializing ATM' print '===================' read_control.read_control(self) initialize.initialize(self) read_layers.read_layers(self) model_domain.model_domain(self) create_attm_cohort_arrays.create_attm_cohort_arrays(self) #========================================= # Initializing Site Specific Information #========================================= if self.Simulation_area.lower() == 'barrow': run_barrow.initialize_barrow(self) elif self.Simulation_area.lower() == 'tanana': run_tanana.initialize_tanana(self) #======================================= # READ MET Data, Calculate Degree Days, # and Calculate Climatic Data needed # for ecotype changes. #======================================= initialize.Met(self) #++++++++++++++++++++++++++++++++++++++++++++++ # ======================================== # INITIALIZE COHORT PROPERTIES # ======================================== #++++++++++++++++++++++++++++++++++++++++++++++ print '======================================' print ' Initializing Terrestrial Properties ' print '======================================' if self.Simulation_area.lower() == 'barrow': run_barrow.initialize_barrow_cohorts(self) elif self.Simulation_area.lower() == 'tanana': run_tanana.Terrestrial_Tanana(self) print '==================================================' print ' Starting the MAIN LOOP ' print '==================================================' initialize.run(self) if self.Simulation_area.lower() == 'barrow': run_barrow.run_barrow(self, time) elif self.Simulation_area.lower() == 'tanana': run_tanana.run_tanana(self, time) print '==================================================' print ' Finished the MAIN LOOP ' print '==================================================' # ------------------- # Simulation End Time # ------------------- clock.finish(self) #=========================== # Output Simulation Results #=========================== if self.results_onscreen.lower() == 'yes': results.on_screen(self) if self.archive_simulation.lower() == 'yes': results.on_file(self) # ================ # Archive Results # ================ if self.archive_simulation.lower() == 'yes': #---------------------------------------------------------------------------------------------------------- # Create the tarfile #---------------------------------------------------------------------------------------------------------- self.archive_file =tarfile.open(self.control['Run_dir']+self.Output_directory+str('/Archive/')+ \ self.archive_time+str('_')+self.simulation_name+".tar.gz", mode='w:gz') #---------------------------------------------------------------------------------------------------------- archive.read_archive(self) archive.archive(self) print '----------------------------------------' print ' Simulation Complete ' print '----------------------------------------'
def advance_state ( k ): #*****************************************************************************80 # ## ADVANCE_STATE advances the state of the current generator. # # Discussion: # # This procedure advances the state of the current generator by 2^K # values and resets the initial seed to that value. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 27 May 2013 # # Author: # # Original Pascal version by Pierre L'Ecuyer, Serge Cote. # PYTHON version by John Burkardt. # # Reference: # # Pierre LEcuyer, Serge Cote, # Implementing a Random Number Package with Splitting Facilities, # ACM Transactions on Mathematical Software, # Volume 17, Number 1, March 1991, pages 98-111. # # Parameters: # # Input, integer K, indicates that the generator is to be # advanced by 2^K values. # 0 <= K. # from cg_get import cg_get from cg_set import cg_set from cgn_get import cgn_get from initialize import initialize from initialized_get import initialized_get from multmod import multmod from sys import exit a1 = 40014 a2 = 40692 m1 = 2147483563 m2 = 2147483399 if ( k < 0 ): print '' print 'ADVANCE_STATE - Fatal error!' print ' Input exponent K is out of bounds.' exit ( 'ADVANCE_STATE - Fatal error!' ) # # Check whether the package must be initialized. # if ( not initialized_get ( ) ): print '' print 'ADVANCE_STATE - Note:' print ' Initializing RNGLIB package.' initialize ( ) # # Get the current generator index. # g = cgn_get ( ) b1 = a1 b2 = a2 for i in range ( 1, k + 1 ): b1 = multmod ( b1, b1, m1 ) b2 = multmod ( b2, b2, m2 ) [ cg1, cg2 ] = cg_get ( g ) cg1 = multmod ( b1, cg1, m1 ) cg2 = multmod ( b2, cg2, m2 ) cg_set ( g, cg1, cg2 ) return
def i4_uniform ( ): #*****************************************************************************80 # ## I4_UNIFORM generates a random positive integer. # # Discussion: # # This procedure returns a random integer following a uniform distribution # over (1, 2147483562) using the current generator. # # The original name of this function was "random()", but this conflicts # with a standard library function name in C. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 27 May 2013 # # Author: # # Original Pascal version by Pierre L'Ecuyer, Serge Cote. # PYTHON version by John Burkardt. # # Reference: # # Pierre LEcuyer, Serge Cote, # Implementing a Random Number Package with Splitting Facilities, # ACM Transactions on Mathematical Software, # Volume 17, Number 1, March 1991, pages 98-111. # # Parameters: # # Output, integer VALUE, the random integer. # from antithetic_get import antithetic_get from cg_get import cg_get from cg_set import cg_set from cgn_get import cgn_get from i4_division import i4_division from initialize import initialize from initialized_get import initialized_get a1 = 40014 a2 = 40692 m1 = 2147483563 m2 = 2147483399 # # Check whether the package must be initialized. # if ( not initialized_get ( ) ): print '' print 'I4_UNIFORM - Note:' print ' Initializing RNGLIB package.' initialize ( ) # # Get the current generator index. # g = cgn_get ( ) # # Retrieve the seeds for the current generator. # [ cg1, cg2 ] = cg_get ( g ) # # Update the seeds. # k = i4_division ( cg1, 53668 ) cg1 = a1 * ( cg1 - k * 53668 ) - k * 12211 if ( cg1 < 0 ): cg1 = cg1 + m1 k = i4_division ( cg2, 52774 ) cg2 = a2 * ( cg2 - k * 52774 ) - k * 3791 if ( cg2 < 0 ): cg2 = cg2 + m2 # # Store the updated seeds. # cg_set ( g, cg1, cg2 ) # # Construct the random integer from the seeds. # z = cg1 - cg2 if ( z < 1 ): z = z + m1 - 1 # # If the generator is in antithetic mode, we must reflect the value. # value = antithetic_get ( ) if ( value ): z = m1 - z return z
def main(): # NewVersion, OldVersion, versionKey = handleVersion(False) pwd = os.getcwd() wish = 'y' # key = raw_input("Are you sure that new version is not required [y/N]? ") initialize() whoIsAccountant() os.system("clear") old_versionKey = False ListBottomKey = True ##### If True, adds the list of drink one more time at the bottom of the list while wish == 'y': print "Choose a task to be done: [1-10], or press Enter to quit!" print "\t 1) Add a member" print "\t 2) Remove a member" print "\t 3) Count the marks" print "\t 4) Get money" print "\t 5) Shopping update" print "\t 6) Report for individuals" print "\t 7) Regular update" print "\t 8) Notify the obligors by Email" print "\t 9) Update the marks' list" print "\t10) Update the accountant info" key = raw_input() try: key = int(key) except: key = 100 os.system("clear") if key == 1 or key == 2: if old_versionKey == False: versionKey = True else: versionKey = False else: versionKey = False if key == 1: NewVersion, OldVersion, versionKey = handleVersion(versionKey) if versionKey: os.chdir(OldVersion + "/csv") SystemState('no') if OldVersion != NewVersion: shutil.copy(OldVersion + '/csv/PeopleList', NewVersion + '/csv/') os.chdir(NewVersion + "/csv") AddNewMember() SystemState('no') CreatePeopleList(ListBottomKey) old_versionKey = True versionKey = False elif key == 2: NewVersion, OldVersion, versionKey = handleVersion(versionKey) os.chdir(OldVersion + "/csv") RemoveMember() if OldVersion != NewVersion: os.rename(OldVersion + '/csv/PeopleList_tmp', NewVersion + '/csv/PeopleList') if versionKey: os.remove(OldVersion + '/csv/PeoplePayment_tmp') else: os.rename(OldVersion + '/csv/PeoplePayment_tmp', NewVersion + '/csv/PeoplePayment') os.chdir(NewVersion + "/csv") CreatePeopleList(ListBottomKey) #SystemState('no') old_versionKey = True versionKey = False else: NewVersion, OldVersion, versionKey = handleVersion(False) # old_versionKey = versionKey os.chdir(NewVersion + "/csv") if key == 3: CountMarks() SystemState('no') elif key == 4: GetMoney() elif key == 5: UpdateShoppingList() elif key == 6: #print "This function is not embedded yet!" SendReport() #input("test") elif key == 7: SystemState('yes') elif key == 8: key_email = raw_input( "Shall people with negative balance be informed via email [y/N]? " ) if key_email == 'y' or key_email == 'Y': ObligorReminder() elif key == 9: CreatePeopleList(ListBottomKey) os.system("clear") elif key == 10: getAccountantInfo() os.system("clear") else: print('here') os.system("clear") os.chdir(pwd) key_update = key os.system("clear") key = raw_input("Is there any other task? [y/N]? ") os.system("clear") if key == 'y' or key == 'Y': pass else: wish = 'no' if key_update != 8: NewVersion, OldVersion, versionKey = handleVersion(False) os.chdir(NewVersion + "/csv") SystemState('no') os.chdir(pwd)
except Exception as e: return f"An Error Occurred reading oas spec: {e}" OASFILE = getoas() @app.route('/oaspec', methods=['GET']) @require_apikey def getoas(): return OASFILE port = int(os.environ.get('PORT', 8080)) if __name__ == '__main__': # comment the next two lines to disable our heartbeat event generator # otherwise, we are starting this on a seperate process heartbeat_process = Process(target=heartbeat) heartbeat_process.start() # comment out the next line if you don't want this demo creating a single # record per firestore collection runfirsttime = init.initialize() log.info(f"Some log here") app.run(threaded=True, host='0.0.0.0', port=8080)
from initialize import initialize from regression import regression from learningCurve import learningCurve from validationCurve import validationCurve from polyFeatures import polyFeatures from featureNormalization import featureNormalization import plotData import numpy as np if __name__=="__main__": (X,y,Xcv,ycv,Xtest,ytest) = readData() lam = 0 # regularization parameter degree = 1 # degree of the polynomial theta = initialize(degree) # checking code by printing values of cost, derivatives and plotting # the linear regression # we expect 303.951 for cost # then [ -15.30, 598.250 ] for gradient print "Cost for initial theta = [1,1]: ", \ costFunction.computeCost(theta,X,y,lam) print "Gradient for initial theta = [1,1]: ", \ costFunction.computeDeriv(theta,X,y,lam) theta = regression(theta,X,y,lam) plotData.plotTheta(X,y,theta) # Computing the learning curve for linear regression (error_train,error_cv) = learningCurve(theta,X,y,Xcv,ycv,lam) plotData.plotError(error_train,error_cv)
def optimize(seg_env_prototype=None, target_prototype=None, cluster_env_path=None, full_env_path=None, N_its=1, preloaded_vars=None): if preloaded_vars is None: env, camera_list, optimization_options, pso_options = initialize( seg_env_prototype, target_prototype, cluster_env_path, full_env_path) env.post_process_environment() else: # work around to the seg fault issue... load everything in advance, then just pass it in! env = preloaded_vars['env'] camera_list = initialize_camera_list() optimization_options = initialize_opt_options() pso_options = initialize_pso_options() # camera_list = preloaded_vars['camera_list'] # optimization_options = preloaded_vars['optimization_options'] # pso_options = preloaded_vars['pso_options'] env.vedo_mesh = vedo.mesh.Mesh(env.obs_mesh) env.opt_options = optimization_options env.correct_normals() env.n_points = optimization_options.n_points env.generate_integration_points() env.perch_regions = [] env.perch_area = 0 env.set_surface_as_perchable() optimization_options.log_performance = True # PSO: # base dimension for simple 2d problem is 2. scales up depending on selected opt camera_particle_dimension = optimization_options.get_particle_size() n_cams = len(camera_list) N_iterations = pso_options["N_iterations"] N_particles = pso_options["N_particles"] if pso_options["greedy_search"]: particle_dimension = camera_particle_dimension num_optimizations = n_cams else: particle_dimension = n_cams * camera_particle_dimension num_optimizations = 1 bounds = (np.zeros(particle_dimension), np.ones(particle_dimension) ) # particle boundaries # for velocity update: # 'w' is velocity decay aka inertia, # 'c1' is "cognitive parameter", e.g. attraction to particle best, # 'c2' is "social parameter", e.g. attraction to local/global best # 'k' = number of neighbors to consider # 'p' = the Minkowski p-norm. 1 for absolute val dist, 2 for norm dist options = { 'c1': pso_options["pso_c1"], 'c2': pso_options["pso_c2"], 'w': pso_options["pso_w"], 'k': pso_options["pso_k"], 'p': pso_options["pso_p"] } np.random.seed(round(time.time())) # for logging pso_keypoints = np.zeros([N_its, num_optimizations, N_iterations + 1, 3], dtype=float) optimization_options.search_time = np.zeros( [N_its, num_optimizations, N_iterations + 1], dtype=float) optimization_options.best_fitness = np.ones( [N_its, num_optimizations, N_iterations + 1], dtype=float) * env.n_points optimization_options.pts_searched = np.zeros( [N_its, num_optimizations, N_iterations + 1], dtype=int) if pso_options['individual_surface_opt']: num_surface_loops = len(env.perch_regions) surface_number = range(num_surface_loops) N_particles = env.assign_particles_to_surfaces( N_particles, pso_options["pso_k"], neighborhood_search=pso_options["local_search"]) else: num_surface_loops = 1 surface_number = [-1] N_particles = [N_particles] # STORE FOR ANALYSIS LATER pso_best_fitnesses = np.ones([N_its, num_optimizations]) * env.n_points pso_points_searched = np.zeros([N_its, num_optimizations]) pso_search_time = np.zeros([N_its, num_optimizations]) pso_best_cameras = [] # store, for each optimization, time, num particles searched, fitness, standard deviation bh = pso_options["boundary_handling"] for it in range(N_its): print("starting iteration: " + str(it + 1)) optimization_options.iteration = it optimal_cameras = PlacedCameras() for i in range(num_optimizations): if pso_options["greedy_search"]: search_cameras_list = [copy.deepcopy(camera_list[i])] else: search_cameras_list = camera_list best_cost = np.finfo(float).max best_pos_surf = -1 best_pos = np.zeros(particle_dimension) for j in range(num_surface_loops): optimization_options.data_index = 0 optimization_options.search_time[it, i, 0] = time.time() start_time = datetime.now() optimization_options.surface_number = j # Future work: investigate velocity clamping... if pso_options["local_search"]: optimizer = ps.single.LocalBestPSO( n_particles=N_particles[j], dimensions=particle_dimension, options=options, bounds=bounds, bh_strategy=bh) # velocity_clamp=[-.55, 0.25]) else: optimizer = ps.single.GlobalBestPSO( n_particles=N_particles[j], dimensions=particle_dimension, options=options, bounds=bounds, bh_strategy=bh) # velocity_clamp=[-.25, 0.25]) optimization_options.surface_number = surface_number[j] # this flag gets reset if the current search has too little variance optimization_options.continue_searching = True optimization_options.stagnant_loops = 0 if pso_options["multi_threading"]: # noinspection PyTypeChecker surf_best_cost, surf_best_pos = optimizer.optimize( evaluate_swarm, iters=N_iterations, environment=env, cameras=search_cameras_list, placed_cameras=optimal_cameras, opt_options=optimization_options, n_processes=multiprocessing.cpu_count()) else: surf_best_cost, surf_best_pos = optimizer.optimize( evaluate_swarm, iters=N_iterations, environment=env, cameras=search_cameras_list, placed_cameras=optimal_cameras, opt_options=optimization_options) if surf_best_cost < best_cost: best_cost = copy.deepcopy(surf_best_cost) best_pos = copy.deepcopy(surf_best_pos) if pso_options["individual_surface_opt"]: best_pos_surf = j pso_search_time[it, i] = (datetime.now() - start_time).total_seconds() pso_best_fitnesses[it, i] = best_cost if pso_options["greedy_search"]: search_cameras_list_copy = copy.deepcopy(search_cameras_list) optimization_options.surface_number = best_pos_surf best_cam = convert_particle_to_state( environment=env, particle=best_pos, cameras=search_cameras_list_copy, opt_options=optimization_options)[0] # from sim.evaluate import evaluate_arrangement_covariance # print("Score should be:" + str(evaluate_arrangement_covariance(env, [best_cam]))) best_cam_covariance = evaluate_camera_covariance( environment=env, cameras=[best_cam]) optimal_cameras.append_covariances( copy.deepcopy(best_cam_covariance)) optimal_cameras.cameras.append(copy.deepcopy(best_cam)) for i in range(num_optimizations): pso_points_searched[it, i] = np.sum( optimization_options.pts_searched[it, i, :]) pso_best_cameras.append(copy.deepcopy(optimal_cameras)) pso_keypoints[:, :, :, 0] = copy.deepcopy(optimization_options.search_time) pso_keypoints[:, :, :, 1] = copy.deepcopy(optimization_options.pts_searched) pso_keypoints[:, :, :, 2] = copy.deepcopy(optimization_options.best_fitness) # pso_keypoints[:, :, :, 3] = copy.deepcopy(optimization_options.fitness_deviation) for i in range(pso_keypoints.shape[1]): pso_keypoints[:, i, :, 0] -= np.reshape(pso_keypoints[:, i, 0, 0], [-1, 1]) # start time at 0s pso_keypoints[:, :, :, 1] = np.cumsum(pso_keypoints[:, :, :, 1], axis=2) # cumsum of points evaluated... pso_keypoints[:, :, :, 2] = np.minimum.accumulate( pso_keypoints[:, :, :, 2], axis=2) # cumulative minimum of best fitnesses verts = np.zeros([0, 3]) faces = np.zeros([0, 3]) face_colors = np.zeros([0, 4]) for s in env.perch_regions: if s.is_valid: faces = np.vstack([faces, s.faces + len(verts)]) verts = np.vstack([verts, s.points]) fc = np.ones([len(s.faces), 4]) fc[:, 3] *= 255 fc[:, :3] *= s.face_colors[0, :] # fc = np.concatenate([s.face_colors, 255*np.ones([s.face_colors.shape[0], 1])], axis=1) face_colors = np.vstack([face_colors, fc]) eval_placement = EvaluatePlacement( environment=env, ground_truth_environment=None, placed_cameras=pso_best_cameras[0].cameras, optimization_options=optimization_options, # sp_linear_density=.2, sp_angular_density=2.5, sp_linear_density=.2, sp_angular_density=5, gs_angular_density=20, gs_linear_density=.2, n_target=pso_options["N_particles"] * N_iterations) eval_placement.pso_best_fitnesses = pso_best_fitnesses eval_placement.pso_points_searched = pso_points_searched eval_placement.pso_search_time = pso_search_time eval_placement.pso_keypoints = pso_keypoints print("Done running PSO... Running analysis now.") eval_placement.run_analysis(N_its=N_its, pso=True, gridsearch=False, randomsearch=False, bruteforce=False) return pso_best_cameras[0].cameras
from telegram.ext import MessageHandler from telegram.ext import Filters import mimetypes import subprocess from datetime import datetime,time,timedelta import time as tt import threading import initialize as init import receiver as rec import sender as send times=[] sender='' receiver='' chat='' (sender,receiver,chat,times)=init.initialize() updater = Updater(token=receiver,request_kwargs={'read_timeout': 60, 'connect_timeout': 60}) dispatcher = updater.dispatcher message_handler=MessageHandler(Filters.all,rec.messagesave2) dispatcher.add_handler(message_handler) start_handler = CommandHandler('start',rec.start) dispatcher.add_handler(start_handler) senderthreading = threading.Thread(target=send.senderstart,name="senderthread",args=(times,sender,chat)) senderthreading.daemon = True senderthreading.start() updater.start_polling()
def update_boj(conn, aclist): while True: aclist = baekjoon.update_aclist(conn, aclist, boj_username) time.sleep(5) def update_snucsepl(conn, boardlist): while True: boardlist = snucsepl.update_boardlist(conn, boardlist) time.sleep(60) if __name__ == '__main__': conn, aclist, boardlist = initialize.initialize() conn.send(channel, ':wave:') if bool_respond_message: t1 = Thread(target=read_msg, args=(conn, )) if bool_update_boj: t2 = Thread(target=update_boj, args=(conn, aclist)) if bool_update_pl: t3 = Thread(target=update_snucsepl, args=(conn, boardlist)) if bool_respond_message: t1.start() if bool_update_boj: t2.start()
def init(url): initialize.initialize() subprocess.call("git init", shell=True) subprocess.call("git remote add origin %s" % url, shell=True)
def main(): logger = logging.getLogger() logger.setLevel(logLevel) logging.info('amygActivation: first log message!') argParser = argparse.ArgumentParser() argParser.add_argument('--config', '-c', default=defaultConfig, type=str, help='experiment config file (.json or .toml)') argParser.add_argument('--runs', '-r', default='', type=str, help='Comma separated list of run numbers') argParser.add_argument('--scans', '-s', default='', type=str, help='Comma separated list of scan number') argParser.add_argument( '--deleteTmpNifti', '-d', default='1', type=str, help='Set to 0 if rerunning during a single scanning after error') args = argParser.parse_args() # Initialize the RPC connection to the projectInterface # This will give us a dataInterface for retrieving files and # a subjectInterface for giving feedback clientInterface = ClientInterface() dataInterface = clientInterface.dataInterface subjInterface = clientInterface.subjInterface webInterface = clientInterface.webInterface args.dataRemote = dataInterface.isRunningRemote() cfg = utils.loadConfigFile(args.config) cfg = initialize(cfg, args) # DELETE ALL FILES IF FLAGGED (DEFAULT) # if args.deleteTmpNifti == '1': deleteTmpFiles(cfg, args) else: print('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!') print('NOT DELETING NIFTIS IN tmp/convertedNiftis') print('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!') createTmpFolder(cfg, args) #### MAIN PROCESSING ### nRuns = len(cfg.runNum) for runIndex in np.arange(nRuns): # Steps that we have to do: # 1. load run regressor X - ** make run regressor that has TRs - # 2. find the happy face trials (happy) X # 3. find the rest TRs right before each one X # At every TR --> register to MNI, mask, etc # 4. zscore previous rest data (convert + register like before) # 5. calculate percent signal change over ROI # 6. save as a text file (Every TR-- display can smooth it) runNum = cfg.runNum[ runIndex] # this will be 1-based now!! it will be the actual run number in case it's out of order runId = makeRunHeader(cfg, args, runIndex) run = cfg.runNum[runIndex] # create run folder runFolder = createRunFolder(cfg, args, runNum) scanNum = cfg.scanNum[runIndex] regressor = makeRunReg(cfg, args, dataInterface, runNum, runFolder, saveMat=1) # intialize data stream dicomScanNamePattern = utils.stringPartialFormat( cfg.dicomNamePattern, 'SCAN', scanNum) streamId = dataInterface.initScannerStream(cfg.dicomDir, dicomScanNamePattern, cfg.minExpectedDicomSize) happy_TRs = findConditionTR(regressor, int(cfg.HAPPY)) happy_TRs_shifted = happy_TRs + cfg.nTR_shift happy_TRs_shifted_filenum = happy_TRs_shifted + cfg.nTR_skip # to account for first 10 files that we're skipping happy_blocks = list(split_tol(happy_TRs_shifted, 1)) TR_per_block = cfg.nTR_block fixation_TRs = findConditionTR(regressor, int(cfg.REST)) fixation_TRs_shifted = fixation_TRs + cfg.nTR_shift fixation_blocks = list(split_tol(fixation_TRs_shifted, 1)) runData = StructDict() runData.all_data = np.zeros( (cfg.nVox[cfg.useMask], cfg.nTR_run - cfg.nTR_skip)) runData.percent_change = np.zeros((cfg.nTR_run - cfg.nTR_skip, )) runData.percent_change[:] = np.nan runData.badVoxels = np.array([]) TRindex = 0 for TRFilenum in np.arange(cfg.nTR_skip + 1, cfg.nTR_run + 1): # iterate through all TRs if TRFilenum == cfg.nTR_skip + 1: # wait until run starts timeout_file = 180 else: timeout_file = 5 A = time.time() dicomFilename = dicomScanNamePattern.format(TR=TRFilenum) print(f'Get Dicom: {dicomFilename}') dicomData = dataInterface.getImageData(streamId, int(TRFilenum), timeout_file) if dicomData is None: print('Error: getImageData returned None') return full_nifti_name = convertToNifti(cfg, args, TRFilenum, scanNum, dicomData) print(full_nifti_name) print(cfg.MASK_transformed[cfg.useMask]) maskedData = apply_mask(full_nifti_name, cfg.MASK_transformed[cfg.useMask]) runData.all_data[:, TRindex] = maskedData B = time.time() print('read to mask time: {:5f}'.format(B - A)) if TRindex in happy_TRs_shifted: # we're at a happy block # now take previous fixation block for z scoring this_block = [ b for b in np.arange(4) if TRindex in happy_blocks[b] ][0] fixation_this_block = fixation_blocks[this_block] avg_activity, runData = getAvgSignal(fixation_this_block, runData, TRindex, cfg) runData.percent_change[TRindex] = calculatePercentChange( avg_activity, runData.all_data[:, TRindex]) text_to_save = '{0:05f}'.format( runData.percent_change[TRindex]) file_name_to_save = getOutputFilename( run, TRFilenum) # save as the actual file number, not index # now we want to always send this back to the local computer running the display full_file_name_to_save = os.path.join( cfg.local.subject_full_day_path, runId, file_name_to_save) # Send classification result back to the console computer try: dataInterface.putFile(full_file_name_to_save, text_to_save) except Exception as err: print('Error putFile: ' + str(err)) return # JUST TO PLOT ON WEB SERVER subjInterface.setResult(run, int(TRFilenum), float(runData.percent_change[TRindex])) webInterface.plotDataPoint( run, int(TRFilenum), float(runData.percent_change[TRindex])) TRheader = makeTRHeader(cfg, runIndex, TRFilenum, TRindex, runData.percent_change[TRindex]) TRindex += 1 # SAVE OVER RUN runData.scanNum = scanNum # save scanning number runData.subjectName = cfg.subjectName runData.dicomDir = cfg.dicomDir run_filename = getRunFilename(cfg.sessionId, run) full_run_filename_to_save = os.path.join(runFolder, run_filename) sio.savemat(full_run_filename_to_save, runData, appendmat=False) sys.exit(0)
def rnglib_test03 ( ): #*****************************************************************************80 # ## RNGLIB_TEST03 demonstrates how the seed can be reset to its initial or last value. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 27 May 2013 # # Author: # # John Burkardt # from cgn_set import cgn_set from init_generator import init_generator from initialize import initialize from r4_uniform_01 import r4_uniform_01 print '' print 'RNGLIB_TEST03' print ' R4_UNIFORM_01 ( ) returns a random real number' print ' in [0,1] using the current generator.' # # Initialize the package. # print '' print ' INITIALIZE initializes the random number generator.' print ' It only needs to be called once before using the package.' initialize ( ) print '' print ' INIT_GENERATOR can reset the seed to the initial value,' print ' the last (previous) value, or a new seed.' # # Set the current generator index to 17. # g = 17 cgn_set ( g ) print '' print ' Current generator index = %d' % ( g ) # # Force the current generator to begin at its initial seed. # print '' print ' INIT_GENERATOR ( 0 ) starts at the initial seed.' init_generator ( 0 ) print '' print ' I R4_UNIFORM_01 ( )' print '' for i in range ( 1, 10 ): u = r4_uniform_01 ( ) print ' %2d %14.6g' % ( i, u ) print '' print ' Calling INIT_GENERATOR ( 0 ) again restarts' print ' at the initial seed.' init_generator ( 0 ) print '' print ' I R4_UNIFORM_01 ( )' print '' for i in range ( 1, 10 ): u = r4_uniform_01 ( ) print ' %2d %14.6g' % ( i, u ) print '' print ' Calling INIT_GENERATOR ( 2 ) restarts' print ' at a new "far ahead" seed.' init_generator ( 2 ) print '' print ' I R4_UNIFORM_01 ( )' print '' for i in range ( 1, 10 ): u = r4_uniform_01 ( ) print ' %2d %14.6g' % ( i, u ) print '' print ' Calling INIT_GENERATOR ( 1 ) restarts' print ' at the last seed (in this case, the "far ahead"' print ' seed specified on the previous call.)' print '' print ' I R4_UNIFORM_01 ( )' print '' for i in range ( 1, 11 ): u = r4_uniform_01 ( ) print ' %2d %14.6g' % ( i, u ) if ( ( i % 3 ) == 0 ): init_generator ( 1 ) print ' (Reset to last seed)'