def main (): manager = Manager() # Range Sensor Distance distance = manager.list([0, 0, 0, 0, 0, 0]) # DataBase db = manager.list() # Command from Keyboard keyboard_cmd = manager.dict() keyboard_cmd['vld'] = 0 keyboard_cmd['cmd'] = '' # GoBack Ready goback_cmd = manager.dict() goback_cmd['vld'] = 0 #Step 1: Initialzation initialization.initialize() #Step 2: Departure operations.take_off() #Step 3: Multi threading start to_thr = Process(target = timeout, args = (runtime, )) key_thr = Process(target = keyboard_thread.keyboard_thread_wrapper_function, args = (keyboard_cmd, )) cmd_thr = Process(target = command_thread.command_thread_wrapper_function, args = (distance, keyboard_cmd, db, goback_cmd, )) rs_thr = Process(target = range_sensor_thread.range_sensor_wrapper_function, args = (distance, )) gb_thr = Process(target = goback_thread.goback_wrapper_function, args = (goback_cmd, )) cmd_thr.start() rs_thr.start() to_thr.start() key_thr.start() gb_thr.start() #Step 4: Multi threading end to_thr.join() cmd_thr.terminate() rs_thr.terminate() key_thr.terminate() gb_thr.terminate() operations.landing() time.sleep(1) cleanup.cleanup()
def fit_model(structure, data_matrix, old_root=None, gibbs_steps=200): if old_root is None: X = data_matrix.sample_latent_values(np.zeros((data_matrix.m, data_matrix.n)), 1.) old_root = GaussianNode(X, 'scalar', 1.) root = initialization.initialize(data_matrix, old_root, old_root.structure(), structure, num_iter=gibbs_steps) model = models.get_model(structure, fixed_noise_variance=data_matrix.fixed_variance()) models.align(root, model) dumb_samplers.sweep(data_matrix, root, num_iter=gibbs_steps) dumb_samplers.sweep(data_matrix, root, maximize=True, num_iter=1) return root
def main(dev_run: ("Runs all the training with 1 iteration only", 'option', 'd'), version="0.1"): # dev_run is a flag, which sets all the training iterations to 1, # for the purposes of testing the assembly process if dev_run: development_run = True else: development_run = False VERSION = version # converting the resources into JSON files from conversion import convert_resources convert_resources() print("\nResources converted\n") # initializing the model from initialization import initialize initialize() print("\nModel initialized\n") # training the components, this may naturally take long time # for training them separately at different times, just run the respective scripts from tagger_training import train_tagger train_tagger(development_run) print("\nTagger trained\n") from parser_training import train_parser train_parser(development_run) print("\nParser trained\n") from ner_training import train_ner train_ner(development_run) print("\nNER component trained\n") # assembling the model from assembly import assemble_model assemble_model(VERSION) print("\nModel assembled\n")
def main (): loop = 0 manager = Manager() distance = manager.list([0, 0, 0, 0, 0, 0]) # distance2 = manager.list([0, 0, 0, 0, 0, 0]) #Step 1: Initialzation initialization.initialize() #Step 2: Departure operations.take_off() #Step 3: Multi threading start timeout_thread = Process(target = timeout, args = (runtime, )) p1 = Process(target = command_thread.command_thread_wrapper_function, args = (distance, )) p2 = Process(target = range_sensor_thread.range_sensor_wrapper_function, args = (distance, )) p1.start() p2.start() timeout_thread.start() #Step 4: Multi threading end timeout_thread.join() p1.terminate() p2.terminate() time.sleep(1) cleanup.cleanup()
def main (): loop = 0 #Step 1: Initialzation initialization.initialize() #Step 2: Departure operations.take_off() #while True : while (loop < 300): #time for a loop: 0.15s loop += 1 #Step 2: Detect Range # for i in range(0, range_sensor.num_directions): # distance[i] = range_sensor.detect_range(i) distance[4] = range_sensor.detect_range(4) time.sleep(0.05) #Step 3: Analyze Range # if (distance[4] > 180): # #operations.hover() # operations.move_backward() # elif (distance[4] < 180): # #operations.hover() # operations.move_backward() # else: # #operations.hover() # operations.move_backward() #Step 4: Generate Next Command if (loop < 50): operations.hover() elif (loop < 100): operations.move_backward() elif (loop < 150): operations.hover() elif (loop < 200): operations.move_backward() elif (loop < 250): operations.drop() else : operations.drop() cleanup.cleanup()
def pmm(data, k, max_iterations=20, threshold=1e-4, verbose=False): """ Fits a poisson mixture model to the data with k latent classes. Args: - data: data to assign to different mixtures, shape (num_samples, dim) - k: number of latent classes Return Values: - means: values of means params, shape (k, dim) - phis: probs of different classes, shape (k) - log_prob: last computed log probability of data - w: responsibilities of different classes for each sample, shape (num_samples, k) """ # initialize the mean parameters for each class means, assignments, _ = initialization.initialize(data, k, num_runs=15) phis = np.zeros(k) for assignment in assignments: phis[assignment] += 1 phis /= len(assignments) if verbose: utils.plot_1d_data_assigments(data, means, assignments) # repeatedly run e-step and m-step until convergence # initialize some values to reuse or return prev_log_prob, log_prob, w = 0, -1, None for idx in range(max_iterations): # e-step w, log_prob = mm.e_step(data, means, phis, density=utils.log_poisson) # m-step means, phis = m_step(data, k, w) # check for convergence diff = abs(log_prob - prev_log_prob) if diff < threshold: break else: prev_log_prob = log_prob if verbose: # check how it's going utils.plot_1d_data_responsibilities(data, w, means) print 'log prob: {:.5f}\tchange in log prob: {:.5f}'.format(log_prob, diff) return means, phis, log_prob, w
def load_cookies(driver): cookies = pickle.load(open('cookies.txt', "rb")) driver.delete_all_cookies() # have to be on a page before you can add any cookies, any page - does not matter which driver.get("https://amazon.com") for cookie in cookies: driver.add_cookie(cookie) print('cookies loaded successfully') if __name__ == '__main__': dr = initialize() action = actions() #load_cookies(dr) dr.get('https://instagram.com') time.sleep(50) follow_spree(dr) #unfollow_spree(dr) #save_cookies(dr) dr.quit()
import pyxel import random import initialization from ballclass import Ball from playerclass import Player from missileclass import Missile pyxel.init(256, 256) initialization.initialize() counter = 0 player = Player() balls = [] state = 'GAMEOVER' hiscore = 0 missiles = [] def update(): global state if state == 'GAMEOVER': if pyxel.btn(pyxel.KEY_ENTER): start_game() state = 'PLAYING' else: update_playing() def start_game(): global counter, balls, player counter = 0
verbose = False for o, a in opts: if o == "-v": verbose = True elif o in ("-h", "--help"): alphaBotUtility.usage() sys.exit() elif o in ("-k", "--handleOK"): handleOK = True elif o in ("-d", "--debug"): debug = True elif o in ("-r", "--report"): report.reportDirectory = str(a) elif o in ("-e", "--explorer"): report = str(a) reportExplorer.analyseReport(report) sys.exit() elif o in ("-l", "--exploreLatest"): reportExplorer.analyseReport(None) sys.exit() else: assert False, "unhandled option" captchaDir = "./captcha" if not os.path.exists(captchaDir): os.makedirs(captchaDir) initialization.initialize(handleOK=handleOK) bot.run(handleOK=handleOK, debug=debug)
def do_POST(self): """ definiert den Umgang mit POST Requests Liest den Body aus - gibt in zum konvertieren weiter """ global dataset_info, net, experiment_id, max_display, dataset, _neighbors if self.path == "/nodes": print("post /nodes") ### POST Request Header ### self.send_response(200) self.send_header('Content-type', 'application/json') #self.send_header('Access-Control-Allow-Origin', self.headers['origin']) self.end_headers() # get body from request content_len = int(self.headers['Content-Length']) body = self.rfile.read(content_len) # convert body to list data = json.loads(str(body).decode('utf-8')) # python 2 #data = json.loads(str(body, encoding='utf-8')) # python 3 # print(data) # Katjas code goes here reset(experiment_id, dataset=dataset) _neighbors = {'positive': [], 'negative': []} net, dataset_info = initialize(dataset=dataset, experiment_id=experiment_id, batch_size=100, lr=1e-4) experiment_id = dataset_info['experiment_id'] # introduce scale factor limits = (-15, 15) pmax, pmin = dataset_info['position'].max(), dataset_info['position'].min() dataset_info['scale_func'] = lambda x: np.divide((limits[1]-limits[0]) * (x.copy() - pmin), pmax-pmin) + limits[0] dataset_info['inverse_scale_func'] = lambda x: np.divide((x.copy()-limits[0]) * (pmax-pmin), limits[1]-limits[0]) + pmin if N is None: N = len(dataset_info['name']) nodes = make_nodes(position=dataset_info['scale_func'](dataset_info['position'][:N]), name=dataset_info['name'][:N], label=dataset_info['label'][:N], index=True) categories = dataset_info['categories'] data = {'nodes': nodes, 'categories': categories} # make json data = json.dumps(data).encode() self.wfile.write(data) #body zurueckschicken if self.path == "/trainSvm": print("post /trainsvm") ### POST Request Header ### self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() # get body from request content_len = int(self.headers['Content-Length']) body = self.rfile.read(content_len) # convert body to list data = json.loads(str(body).decode('utf-8')) # python 2 #data = json.loads(str(body, encoding='utf-8')) # python 3 print(data) # Katjas code goes here # p, n = katja_function(data.p, data.n) # make json # data = json.dumps({p: p, n: n}).encode() self.wfile.write(data) #body zurueckschicken if self.path == "/stopSvm": print("post /stopSvm") ### POST Request Header ### self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() # get body from request #content_len = int(self.headers['Content-Length']) #body = self.rfile.read(content_len) # convert body to list #data = json.loads(str(body).decode('utf-8')) # python 2 #data = json.loads(str(body, encoding='utf-8')) # python 3 #print(data) # Katjas code goes here # p, n = katja_function(data.p, data.n) # make json #data = json.dumps({p: p, n: n}).encode() self.wfile.write("stopped Svm") #body zurueckschicken if self.path == "/updateLabels": print("post /updateLabels") ### POST Request Header ### self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() # get body from request #content_len = int(self.headers['Content-Length']) #body = self.rfile.read(content_len) # convert body to list #data = json.loads(str(body).decode('utf-8')) # python 2 #data = json.loads(str(body, encoding='utf-8')) # python 3 #print(data) # Katjas code goes here # katja_function(data.p, data.n) # make json #data = json.dumps({}).encode() self.wfile.write(data) #body zurueckschicken if self.path == "/getGroupNeighbours": print("post /getGroupNeighbours") ### POST Request Header ### self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() # get body from request content_len = int(self.headers['Content-Length']) body = self.rfile.read(content_len) # convert body to list data = json.loads(str(body).decode('utf-8')) # python 2 # data = json.loads(str(body, encoding='utf-8')) # python 3 print(data) print(len(data['positives'])) try: _neighbors['negative'].extend(data['negatives']) except KeyError: pass _neighbors['positive'], scores = select_neighbors(dataset_info['feature'][:N], data['positives'], _neighbors['negative'], k=2000, neighbor_fn=svm_k_nearest_neighbors, test=False) print('New neighbors {}'.format(_neighbors['positive'])) # Katjas code goes here # katja_function(data.p, data.n) # make json data['neighbours'] = {neigh: score for neigh, score in zip(_neighbors['positive'], scores)} print(len(data['positives'])) data['group'] = list(data['positives']) data = json.dumps(data).encode() self.wfile.write(data) #body zurueckschicken if self.path == "/startUpdateEmbedding": print("post /startUpdateEmbedding") ### POST Request Header ### self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() # get body from request content_len = int(self.headers['Content-Length']) body = self.rfile.read(content_len) # convert body to list body = json.loads(str(body).decode('utf-8')) # python 2 # data = json.loads(str(body, encoding='utf-8')) # python 3 #print(body) #print(self.socket_id) self.socket_id = body['socketId'] id = body['socketId'] data = read_nodes(body['nodes']) self.wfile.write('update_embedding started for ' + str(self.socket_id)) # body zurueckschicken # Katjas code goes here new_position = np.stack([data['x'], data['y']], axis=1) new_position = dataset_info['inverse_scale_func'](new_position) old_position = dataset_info['position'] idx_modified = get_modified(old_position[:N], new_position, tol=dataset_info['inverse_scale_func'](np.array([3,]))) if len(idx_modified) == 0 or len(idx_modified) == len(dataset_info['name']): # TODO: fix recall bug print('Modified {} samples. - Invalid for training.') return 0 # idx_old_neighbors = get_neighborhood(old_position[:N], idx_modified) # idx_new_neighbors = get_neighborhood(new_position[:N], idx_modified) idx_old_neighbors, _ = mutual_k_nearest_neighbors(old_position[:N], idx_modified, k=50) idx_new_neighbors = get_neighborhood(new_position[:N], idx_modified) print('Train MapNet using {} positives and {} negatives.'.format(len(idx_modified) + len(idx_new_neighbors), len(_neighbors['negative']))) # net, dataset_info = initialize(dataset=dataset, experiment_id=experiment_id, batch_size=100, # lr=1e-4) # experiment_id = dataset_info['experiment_id'] # # introduce scale factor # limits = (-15, 15) # pmax, pmin = dataset_info['position'].max(), dataset_info['position'].min() # dataset_info['scale_func'] = lambda x: np.divide((limits[1] - limits[0]) * (x.copy() - pmin), pmax - pmin) + \ # limits[0] # dataset_info['inverse_scale_func'] = lambda x: np.divide((x.copy() - limits[0]) * (pmax - pmin), # limits[1] - limits[0]) + pmin # if N is None: # N = len(dataset_info['name']) new_position = train(net, dataset_info['feature'][:N], dataset_info['name'].values.astype(str)[:N], old_position[:N], new_position, idx_modified, idx_old_neighbors, idx_new_neighbors, _neighbors['negative'], categories=dataset_info['categories'], label=dataset_info['label'][:N], lr=1e-3, experiment_id=experiment_id, socket_id=self.socket_id, scale_func=dataset_info['scale_func']) dataset_info['position'] = new_position _neighbors = {'positive': [], 'negative': []} return 0 # TODO was ist wenn das mehrfach gestartet wird # self.inter = SetInterval(0.6, update_embedding_handler, id) # self.inter.socket_id = id # self.inter.start() # t = threading.Timer(5, self.inter.cancel) # t.start() # make json # data = json.dumps({}).encode() if self.path == "/stopUpdateEmbedding": print("post /stopUpdateEmbedding") ### POST Request Header ### self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() return