def __init__(self, wholeImg_dir, faceImg_dir, anns): self.img_prc = ImageProcessing() self.wholeImg_dir = wholeImg_dir self.faceImg_dir = faceImg_dir self.anns = anns # self.face_paths = glob.glob(os.path.join(faceImg_dir, '*.jpg')) self.whole_paths = glob.glob(os.path.join(wholeImg_dir, '*.jpg')) self.names = get_names(self.face_paths) # f = open(self.anns, 'r') lines = f.readlines() # not include first line self.infos = {} # print '# line {}'.format(len(lines)) for line in lines[1:][:]: fname, x1, x2, y1, y2, w, h = line.split(',') x1, x2, y1, y2, w, h = map(lambda x: int(x.strip()), [x1, x2, y1, y2, w, h]) coord = [x1, y1, x2, y2, w, h] whole_img = self.img_prc.path2img(os.path.join( self.wholeImg_dir, fname), resize=None) face_img = self.img_prc.path2img(os.path.join( self.faceImg_dir, fname), resize=None) self.infos[fname] = { 'coord': coord, 'whole_img': whole_img, 'face_img': face_img }
def predict(self, img): img = cv2.resize(img, (self.shape[1], self.shape[0])) outs = self.sess.run('output:0', feed_dict={'input:0': np.expand_dims(img, 0)}) names = {j: i for i, j in utils.get_names().items()} return outs[0]
def get_background_imgs(self, n_bg, savedir): bg_train_path = os.path.join(savedir, 'bg_train.npy') bg_test_path = os.path.join(savedir, 'bg_test.npy') bg_val_path = os.path.join(savedir, 'bg_val.npy') paths = np.asarray( glob.glob(os.path.join('background', 'cropped_bg', '*'))) names = np.asarray(get_names(paths)) if os.path.exists(bg_train_path) and os.path.exists( bg_test_path) and os.path.exists(bg_val_path): self.bg_train_imgs = np.load(bg_train_path) self.bg_test_imgs = np.load(bg_test_path) self.bg_val_imgs = np.load(bg_val_path) else: print 'Generating Not Wally Data....' indices = random.sample(range(len(paths)), len(paths))[:n_bg] # paths = paths[indices] # imgs = self.img_prc.paths2imgs(paths, (64, 64)) print 'background images : {}'.format(np.shape(imgs)) # get background train ,val test images self.bg_train_imgs, self.bg_val_imgs, self.bg_test_imgs = self.img_prc.divide_TVT( imgs, 0.1, 0.1) # Save Numpy np.save(os.path.join(savedir, 'bg_train.npy'), self.bg_train_imgs) np.save(os.path.join(savedir, 'bg_test.npy'), self.bg_test_imgs) np.save(os.path.join(savedir, 'bg_val.npy'), self.bg_val_imgs)
def get_saved_api(): response = jsonify({ 'car_model_names': utils.get_names(), 'Location': utils.get_locations(), 'Owner_Type': utils.get_own_type(), 'Fuel_Type': utils.get_fuel(), 'Transmission': utils.get_tranmn(), }) response.headers.add('Access-Control-Allow-Origin', '*') return response
def visit_Assign(self, node): scope = self.scope enable_locals = self.enableStaticLocals() for target in node.targets: for name in utils.get_names(target, pure_only=False) or []: if scope.identify(name) == NT_GLOBAL_EXPLICIT: self.rootScope.removeLocals(name) else: enable_locals and scope.addLocals(name, node) self.genricVisit(node)
def __init__(self): self.names = utils.get_names() self.actions = {j:i for i,j in self.names.items()} # special case for stopping the car when a stop or red light signal is detected self.actions[-1] = 'stop' # parts self.sender = Sender() self.decisor = Decisor() self.capture = Capture()
def answer(self, question): pred_relation = www2fb(get_relation(question, self.questions, self.model, self.index2rel, self.args)) query_tokens = get_query_text(question, self.questions, self.ent_model, self.index2tag, self.args) N = min(len(query_tokens), 3) C = [] # candidate entities for n in range(N, 0, -1): ngrams_set = find_ngrams(query_tokens, n) for ngram_tuple in ngrams_set: ngram = " ".join(ngram_tuple) ngram = strip_accents(ngram) # unigram stopwords have too many candidates so just skip over if ngram in stopwords: continue ## PROBLEM! - ngram doesnt exist in index - at test-2592 - KeyError: 'p.a.r.c.e. parce' try: cand_mids = self.index_ent[ngram] # search entities except: continue C.extend(cand_mids) if (len(C) > 0): break break C_pruned = [] for mid in set(C): if mid in self.index_reach.keys(): # PROBLEM: don't know why this may not exist?? count_mid = C.count(mid) # count number of times mid appeared in C C_pruned.append((mid, count_mid)) if pred_relation in self.index_reach[mid]: count_mid = C.count(mid) # count number of times mid appeared in C C_pruned.append((mid, count_mid)) num_entities_fbsubset = 1959820 # 2M - 1959820 , 5M - 1972702 C_tfidf_pruned = [] for mid, count_mid in C_pruned: if mid in self.index_names.keys(): cand_ent_name = pick_best_name(question, self.index_names[mid]) tfidf = calc_tf_idf(query_tokens, cand_ent_name, count_mid, num_entities_fbsubset, self.index_ent) C_tfidf_pruned.append((mid, cand_ent_name, tfidf)) C_tfidf_pruned.sort(key=lambda t: -t[2]) pred_ent, name_ent, score = C_tfidf_pruned[0] key = (pred_ent, pred_relation) if key not in self.fb_graph: return "UNKNOWN" result_mid = self.fb_graph[key] result_mid = list(result_mid) result = get_names(self.fb_graph, result_mid)[0] return result
def search(question): urls = utils.get_urls( question ) #Sends question to get_urls function in utils.py, which googles query and generates list of suitable urls if utils.getqtype(question) == "who": names_dict = utils.get_names(urls, question) if utils.getqtype(question) == "when": names_dict = utils.get_dates(urls) number = 0 for i in names_dict: if names_dict[i] > number: answer = i number = names_dict[i] return render_template("search.html", question=question, urls=urls, names_dict=names_dict, answer=answer)
def __init__(self, imgdir, anns): self.imgdir = imgdir self.anns = anns self.paths = glob.glob(os.path.join(self.imgdir, '*.jpg')) self.names = get_names(self.paths) # read csv f = open(self.anns, 'r') lines = f.readlines() # not include first line ctr_xs = [] ctr_ys = [] fnames = [] for line in lines[1:]: ctr_x, ctr_y, filename = line.split(',') ctr_xs.append(int(ctr_x)) ctr_ys.append(int(ctr_y)) fnames.append(filename.strip()) self.img_infos = zip(fnames, ctr_xs, ctr_ys)
np.uint8( np.maximum(np.minimum(output[0] * 255.0, 255.0), 0.0))) sic.imsave( "%s/%04d/predictions/predictions_%06d.jpg" % (model, epoch, ind), np.uint8( np.maximum(np.minimum(C0_imall[0] * 255.0, 255.0), 0.0))) saver.save(sess, "%s/model.ckpt" % model) if epoch % 10 == 0: saver.save(sess, "%s/%04d/model.ckpt" % (model, epoch)) # Inference else: test_low = utils.get_names(test_dir) numtest = len(test_low) print(test_low[0]) out_folder = test_dir.split('/')[-1] outputs = [None] * 4 for ind in range(numtest): input_image_src, input_image_target, input_flow_forward_src, input_flow_backward_src = prepare_input_w_flow( test_low[ind], num_frames=num_frame, gray=True) if input_image_src is None or input_image_target is None or input_flow_forward_src is None: print("Not able to read the images/flows.") continue st = time.time() C0_imall, C1_imall, C0_im, C1_im = sess.run( [objDict["prediction_0"], objDict["prediction_1"], C0, C1], feed_dict={ input_i: input_image_src,
def loop_request_wrapper(params): # print("params:{}".format(params)) my_params = get_my_params(params, os.getpid()) start = datetime.datetime.now() urls = [ get_req_url(options, ("name=%s" % (my_params[i][1], ))) for i in range(len(my_params)) ] tasks = [asyncio.ensure_future(request(url)) for url in urls] loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.wait(tasks)) end = datetime.datetime.now() print('-' * 80) print("my pid: %s, parent pid: %s, start at %s, end at %s" % (os.getpid(), os.getppid(), start, end)) if __name__ == "__main__": print(datetime.datetime.now()) print("cpu count:", cpu_count) pool = multiprocessing.Pool(cpu_count) names = get_names(options.task_num) params = [(i, names[i]) for i in range(options.task_num)] pool.map(loop_request_wrapper, [params for i in range(cpu_count)]) pool.close() pool.join() print(datetime.datetime.now())
def visit_Delete(self, node): for target in node.targets: self.scope.batchRemoveLocals(utils.get_names(target, pure_only=False) or []) self.genricVisit(node)
def postvisit_Delete(self, node): for target in node.targets: self.scope.batchRemoveLocals( utils.get_names(target, pure_only=False) or []) return node
def postvisit_Assign(self, node): scope = self.scope for target in node.targets: for name in utils.get_names(target, pure_only=False) or []: scope.addLocals(name, node)
def get_result(dataset_name, target_model, task, kargs, sampled_dir='', debug=debug, cache=cache): rs = utils.RandomState() rs.save_state() rs.set_seed(0) embedding_filename = utils.get_names(target_model, **kargs) if task == 'classification': cf = os.path.abspath( os.path.join('result/{}'.format(dataset_name), sampled_dir, 'cf', embedding_filename)) elif task == 'link_predict': cf = os.path.abspath( os.path.join('result/{}'.format(dataset_name), sampled_dir, 'lp', embedding_filename)) embedding_filename = os.path.abspath( os.path.join('embeddings/{}'.format(dataset_name), sampled_dir, embedding_filename)) dataset_filename = os.path.abspath( os.path.join('data/{}'.format(dataset_name), sampled_dir, 'graph.edgelist')) if target_model != 'gcn': if (not cache) or (not os.path.exists(embedding_filename)) or ( os.path.getmtime(embedding_filename) < os.path.getmtime(dataset_filename)): utils.run_target_model(target_model, dataset_filename, os.path.dirname(embedding_filename), embedding_test_dir=embedding_test_dir, debug=debug, **kargs) if (not cache) or (not os.path.exists(cf)) or ( os.path.getmtime(cf) < os.path.getmtime(embedding_filename)): if task == 'classification': labels = os.path.abspath( os.path.join(os.path.dirname(dataset_filename), 'label.txt')) elif task == 'link_predict': labels = os.path.abspath( os.path.join(os.path.dirname(dataset_filename))) utils.run_test(task, dataset_name, [embedding_filename], labels, cf, embedding_test_dir=embedding_test_dir) else: if (not cache) or (not os.path.exists(cf)): data_path = os.path.abspath( os.path.join('data/{}'.format(dataset_name))) with utils.cd( os.path.join(embedding_test_dir, 'src/baseline/gcn/gcn')): cmd = ('python3 main.py' +\ ' --epochs {} --hidden1 {} --learning_rate {}' +\ ' --output_filename {} --debug {} --dataset {} --input_dir {}').format(kargs['epochs'], kargs['hidden1'], kargs['learning_rate'], cf, debug, dataset_name, data_path) if debug: print(cmd) else: cmd += ' > /dev/null 2>&1' os.system(cmd) rs.load_state() res = np.loadtxt(cf, dtype=float) if len(res.shape) != 0: res = res[0] return res
def __init__(self, opt): self.opt = opt self.namelist = utils.get_names(opt.baseroot)
g0 = VCN(utils.build(tf.tile(input_i[:, :, :, 0:1], [1, 1, 1, 3])), reuse=False) g1 = VCN(utils.build(tf.tile(input_i[:, :, :, 1:2], [1, 1, 1, 3])), reuse=True) saver = tf.train.Saver(max_to_keep=1000) sess.run([tf.global_variables_initializer()]) var_restore = [v for v in tf.trainable_variables()] saver_restore = tf.train.Saver(var_restore) ckpt = tf.train.get_checkpoint_state(model) print('loaded ' + ckpt.model_checkpoint_path) saver_restore.restore(sess, ckpt.model_checkpoint_path) if not len(test_img): img_names = utils.get_names(test_dir) ind = 0 for img_name in img_names: im = np.float32(scipy.misc.imread(img_name, 'L')) / 255.0 h = im.shape[0] // 32 * 32 w = im.shape[1] // 32 * 32 im = im[np.newaxis, :h, :w, np.newaxis] st = time.time() output = sess.run( g0, feed_dict={input_i: np.concatenate((im, im), axis=3)}) print("test time for %s --> %.3f" % (ind, time.time() - st)) folder = test_dir.split('/')[-1] if not os.path.isdir("%s/%s" % (model, folder)): for idx in range(5): os.makedirs("%s/%s/result%d" % (model, folder, idx)) out_all = np.concatenate(
def resize_npImages(self, np_imgs, resize): ret_imgs = [] for i, img in enumerate(np_imgs): utils.show_progress(i, len(np_imgs)) img = Image.fromarray(img).convert('RGB').resize(resize) img = np.asarray(img) ret_imgs.append(img) return np.asarray(ret_imgs) if __name__ == '__main__': paths = glob.glob(os.path.join('foreground', 'original_fg', '*')) names = get_names(paths) # Foreground img_processing = ImageProcessing() # Load Image from paths imgs = img_processing.paths2imgs(paths, (64, 64)) print 'foreground images : {}'.format(np.shape(imgs)) # fg_train_imgs, fg_val_imgs, fg_test_imgs = img_processing.divide_TVT( imgs, 0.1, 0.1) np.save('fg_train.npy', fg_train_imgs) np.save('fg_test.npy', fg_test_imgs) np.save('fg_val.npy', fg_val_imgs) # Background paths = np.asarray(glob.glob(os.path.join('background', 'cropped_bg', '*')))
var_restore = [v for v in tf.trainable_variables()] saver_restore = tf.train.Saver(var_restore) ckpt = tf.train.get_checkpoint_state("pretrained_models/" + model) print('loaded ' + ckpt.model_checkpoint_path) saver_restore.restore(sess, ckpt.model_checkpoint_path) folder = video_path.split('/')[-1] output_dir = ARGS.video_path[:-1] + "_colorized" if ARGS.video_path.endswith( "/") else ARGS.video_path + "_colorized" # if ARGS.output_dir is None: # output_dir = "test_result/{}/{}".format(model, folder) # else: # output_dir = ARGS.output_dir if img_path is None: img_names = utils.get_names(video_path) ind = 0 for frame_id, img_name in enumerate(img_names): im = np.array(Image.open(img_name).convert("L")) / 255. h = im.shape[0] // 32 * 32 w = im.shape[1] // 32 * 32 # h = 320 # w = 320 im = im[np.newaxis, :h, :w, np.newaxis] # print(im.shape) st = time.time() output = sess.run( g0, feed_dict={input_i: np.concatenate((im, im), axis=3)})
def home(): return render_template('home.html', id_names=get_names())
def loop_request_wrapper(params): start = datetime.datetime.now() urls = [ get_req_url(options, "name=".format(params[1])) for _ in range(options.task_num) ] tasks = [asyncio.ensure_future(request(url)) for url in urls] loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.wait(tasks)) end = datetime.datetime.now() print("visit %s" % (urls)) print("my pid: %s, parent pid: %s, start at %s, end at %s" % (os.getpid(), os.getppid(), start, end)) print('-' * 80) if __name__ == "__main__": print(datetime.datetime.now()) cpu_count = multiprocessing.cpu_count() print("cpu count:", cpu_count) pool = multiprocessing.Pool(cpu_count) names = get_names(options.process_num) params = [(i, names[i]) for i in range(options.process_num)] pool.map(loop_request_wrapper, params) pool.close() pool.join() print(datetime.datetime.now())
def random_char(self, printable=True): NewChar = self.random_name() given, sur = utils.get_names(NewChar) gender = self.gender_from_name(NewChar) if gender == "either": gender = random.choice(["male", "female"]) if gender == "male": opronoun = "his" pronoun = "he" else: pronoun = "she" opronoun = "her" PackageClass, PackageBG, PackageStr, PackageInt, PackageWis, PackageCon, PackageDex, PackageCha, PrimaryStat = self._get_package( sur) bgstr = "%s the %s %s %s\n" % ( NewChar, PackageClass, utils.background_from(), PackageBG.replace( '$name', NewChar).replace('$gender', gender).replace( '. $pronoun', '. ' + pronoun.capitalize()).replace('$pronoun', pronoun).replace( '. $opronoun', '. ' + opronoun.capitalize()).replace( '$opronoun', opronoun)) gold = utils.gen_stat(0) * 10 * self.currency_exchange if printable: returnval = "Name: %s\n" % NewChar returnval += "Gender: %7s Class: %s Primary: %s\n" % ( gender, PackageClass, PrimaryStat) returnval += self._print_two_stats('str', PackageStr, 'int', PackageInt, PrimaryStat) returnval += self._print_two_stats('wis', PackageWis, 'con', PackageCon, PrimaryStat) returnval += self._print_two_stats('dex', PackageDex, 'cha', PackageCha, PrimaryStat) returnval += "Starting gold (based on %s exchange): %s\n" % ( self.currency, gold) returnval += "----------------------\n" returnval += bgstr return returnval returnval = "{\n" returnval += " \"character\": {\n" returnval += " \"name\": \"%s\",\n" % NewChar returnval += " \"gender\": \"%s\",\n" % gender returnval += " \"class\": \"%s\",\n" % PackageClass returnval += " \"primary_stat\": \"%s\",\n" % PrimaryStat returnval += " \"starting_gold\": \"%f\",\n" % gold returnval += " \"background\": \"%s\",\n" % bgstr returnval += " \"statblock\": {\n" returnval += " \"stat\": [\n" returnval += self._json_stat('str', PackageStr) + ",\n" returnval += self._json_stat('int', PackageInt) + ",\n" returnval += self._json_stat('wis', PackageWis) + ",\n" returnval += self._json_stat('con', PackageCon) + ",\n" returnval += self._json_stat('dex', PackageDex) + ",\n" returnval += self._json_stat('cha', PackageCha) + "\n" returnval += " ]\n" returnval += " }\n" returnval += " }\n" returnval += "}\n" return returnval
def gender_from_name(self, name): given, sur = utils.get_names(name) pos = self._given_names.index(given.lower()) return self._given_names_gender[pos]