def process_videos(video_folder, output_folder): video_list = [ video for video in os.listdir(video_folder) if video.endswith((".mp4", ".mov", ".avi")) ] assert len( video_list) > 0, "The specified folder {} contains no video".format( video_folder) for video_name in video_list: if not args.config: cfg = config_by_video_name(video_name) else: cfg = config_by_config_name(args.config) temp_path = output_folder + video_name.split(".")[0] + "/temp/" os.makedirs(temp_path, exist_ok=True) preprocess(video_folder + video_name, temp_path, cfg) run_inference(temp_path, cfg) postprocess(temp_path, cfg)
def process_images(image_folder, output_folder, cfg): temp_path = os.path.join(output_folder, "temp") + "/" os.makedirs(temp_path, exist_ok=True) preprocess_images(image_folder, temp_path, cfg) run_inference(temp_path, cfg) postprocess(temp_path, cfg)
def main(): """Build hparams, the graph, and train it.""" hparams = initialize() if hparams.run_inference_test: hparams.batch_size = 2 X_mixtures, phases, inference_summaries = graph.build_inference_graph(hparams) inference.run_inference(hparams, X_mixtures, phases, inference_summaries) else: inputs, embedding_info, loss, loss_summary, summaries = ( graph.build_train_graph(hparams)) train.run_train(hparams, inputs, embedding_info, loss, loss_summary, summaries)
def hello(): output_filename = None coconut_count = None if request.method == 'POST': if 'image' not in request.files: flash('No file part') return redirect(request.url) file = request.files['image'] if file.filename == '': flash('No selected file') return redirect(request.url) if file and allowed_file(file.filename): filename = secure_filename(file.filename) if os.path.isfile( os.path.join(app.config['UPLOAD_FOLDER'], filename)): filename = "%s%s" % (uuid.uuid4(), filename) file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename)) coconut_count = run_inference( os.path.join(app.config['UPLOAD_FOLDER'], filename), filename) return redirect( url_for('result', file=filename, count=coconut_count, _anchor="output")) # check if the post request has return render_template('index.html', output_filename=None, coconut_count=None)
def image(data_image): # for some reason the image doesn't always send. # I think it takes the camera a second to warm up. # Its best to handle this in javascript for optimizations if len(data_image) < 30: return sbuf = StringIO() sbuf.write(data_image) headers, base64_image = data_image.split(',', 1) # decode and convert into image b = io.BytesIO(base64.b64decode(base64_image)) pimg = Image.open(b) # converting RGB to BGR, as opencv standards frame = cv2.cvtColor(np.array(pimg), cv2.COLOR_RGB2BGR) # Process the image frame frame = inference.run_inference(frame) imgencode = cv2.imencode('.jpg', frame)[1] # base64 encode stringData = base64.b64encode(imgencode).decode('utf-8') b64_src = 'data:image/jpg;base64,' stringData = b64_src + stringData # emit the frame back emit('response_back', stringData)
def main(): parser = argparse.ArgumentParser() parser.add_argument("-t", "--time", help="Time elapsed, in seconds, so far in the game", required=True, type=int) parser.add_argument("-s", "--spread", help="Spread, relative to visiting team", required=True, type=float) parser.add_argument("-f", "--favorite", help="Current point total for the favorite", required=True, type=int) parser.add_argument("-u", "--underdog", help="Current point total for the underdog", required=True, type=int) args = parser.parse_args() time_sec = args.time spread = args.spread favorite_points = args.favorite underdog_points = args.underdog assert time_sec >= 0, "Time must be a positive integer" assert favorite_points >= 0, "Favorite points must be a positive integer" assert favorite_points >= 0, "Underdog points must be a positive integer" model = inference.load_model(MODEL_PATH) scaler = inference.load_scaler(SCALER_PATH) pred = inference.run_inference(model, scaler, time_sec, spread, favorite_points, underdog_points) print(pred)
def _main(args): model_path = os.path.expanduser(args.model_path) assert model_path.endswith('.h5'), 'Keras model must be a .h5 file.' anchors_path = os.path.expanduser(args.anchors_path) classes_path = os.path.expanduser(args.classes_path) input_mode = int(os.path.expanduser(args.mode)) assert input_mode == 0 or input_mode == 1, 'Input mode must be in {0,1}' test_path = os.path.expanduser(args.test_dir) output_path = os.path.expanduser(args.output_path) if not os.path.exists(output_path): print('Creating output path {}'.format(output_path)) os.mkdir(output_path) with open(anchors_path) as f: anchors = f.readline() anchors = [float(x) for x in anchors.split(',')] anchors = np.array(anchors).reshape(-1, 2) mAP, precision, recalls = run_inference(model_path, anchors, classes_path, test_path, output_path, input_mode, args.score_threshold, args.iou_threshold, args.map_iou_threshold, args.class_index, args.num_saved_images) plt.scatter(recalls, precision) plt.xlim(0,1) plt.ylim(0,1) plt.xlabel("Recall") plt.ylabel("Precision") plt.savefig(args.plot_file) plt.clf() print("%s,%.6g,%.6g,%.6g" % (args.identifier, mAP, np.average(precision), np.average(recalls)))
def post(self): # initialize params id = uuid.uuid4() args = inference_args.parse_args() abort_if_url_invalid(args['url']) result_dict[id] = args # perform the inference task result = run_inference(args['network'], args['url']) return {"result": { "id": str(id), "network": "{:s}".format(args['network']), "recognized_object": "{:s}".format(result['recognized_object']), "class_number": "{:d}".format(result['class_number']), "confidence": "{:f}%" .format(result['confidence']) }}, 200
def run_inference(): try: input = request.get_json() except BadRequest as e: app.logger.error(e) app.logger.error("Raw request body is: {}".format(request.get_data())) return e.description app.logger.debug("JSON request body is: {}".format(input)) time_sec = int(input["time_sec"]) hspread = input[ "hspread"] # The database stores spread relative to the home team spread = -1 * hspread # The model uses spread relative to the visiting team favorite_points = int(input["favorite_points"]) underdog_points = int(input["underdog_points"]) start = time.time() with graph.as_default(): pred = inference.run_inference(model, scaler, time_sec, spread, favorite_points, underdog_points) end = time.time() app.logger.debug("Finished in {} secs".format(end - start)) return {"cover_probability": float(pred)}
def main(_): # override checkpoint if config.checkpoint_dir == 'default': config.checkpoint_dir = config.logdir + "/model_save/" # override parameter file if config.parameter_override_filepath == 'default': config.parameter_override_filepath = config.logdir + "/parameters.txt" # copy stdout and stderr to checkpoint dir tee_output(config.logdir, "out") # load parameter file if config.use_parameter_override_file is True: load_parameter_file(config.parameter_override_filepath, config) # print date and time for output records now = datetime.datetime.now() print("Current date and time: {}".format( now.strftime("%Y-%m-%d %H:%M:%S"))) # load training data print('loading training data') dataset = load_dataset(config.dataset_file, config.pickle_filepath, config.load_dataset) logging.debug('dataset size: %i' % len(dataset)) # load metadata print('loading metadata') word2id, id2word, max_sentence_len, max_conversation_len, \ max_conversation_words, max_persona_len = get_data_info(dataset) # load runtime "flags" config.max_sentence_len = max_sentence_len config.max_conversation_len = max_conversation_len config.max_conversation_words = max_conversation_words config.max_persona_len = max_persona_len config.vocab_size = len(word2id) # output parameters to stdout print("\n\n") print("parameters:") for key, value in config.flag_values_dict().items(): print(" ", end="") print("{} : {}".format(key, value)) print("\n\n") # load word vectors print('loading word vectors') word2vec = load_word_embeddings(config.embedding_fname, config.embedding_dim, word2id) logging.debug('word2vec type: %s' % type(word2vec)) logging.debug('word2vec shape: %s' % str(word2vec.shape)) # convert dataset to integer ids print('converting dataset to ids') if config.mode != "data_viz": dataset = convert_to_id(dataset, word2id) # split into train and test # TODO make split ratio into a parameter print('splitting dataset') #random.shuffle(dataset) if config.dataset_size < 0: train_size = int(len(dataset) * 0.9) else: train_size = config.dataset_size train_data = dataset[:train_size] test_data = dataset[train_size:] # setup debugger if config.debug == True: sess = tf_debug.TensorBoardDebugWrapperSession(sess, 'localhost:6064') logging.debug('building model') model = Model(config, word2vec, id2word, word2id) # load model if config.load_model == True or config.mode == 'inference': # ensure load folder exists if os.path.isdir(config.checkpoint_dir): print("loading model from: {}".format(config.checkpoint_dir)) model.load() else: print("no save folder exists. Continuing without loading model.") # ensure print outs in main get printed out before further logging debugs # TODO change all logging type printouts to logging.debug calls print("", flush=True) # perform parameter search if config.mode == "parameter_search": logging.debug("performing parameter search") parameter_ranges = {} parameter_ranges["learning_rate"] = (-5, -2) parameter_ranges["hidden_size"] = (250, 950) parameter_ranges["num_layers"] = (2, 4) perform_parameter_search( Model, config, word2vec, id2word, word2id, parameter_ranges, train_data, num_epochs_per_parameter=config.parameter_search_epochs) # run inference elif config.mode == "inference": config.batch_size = 1 run_inference(dataset, config, word2id, word2vec, id2word, 1) # run data visualization elif config.mode == "data_viz": look_at_data(train_data) # train model elif config.mode == "train": logging.debug('training model') model.train(train_data, test_data, config.train_steps) elif config.mode == "unit_test": logging.debug('running unit tests') run_all_tests(config, train_data, word2vec, id2word, word2id) else: print("invalid mode! Exiting.")
def _main(args): data_path = os.path.expanduser(args.data_path) classes_path = os.path.expanduser(args.classes_path) anchors_path = os.path.expanduser(args.anchors_path) result_path = os.path.expanduser(args.result_path) test_path = os.path.expanduser(args.test_path) model_prefix = os.path.expanduser(args.model_prefix) num_frozen = int(args.num_frozen) num_trials = int(args.num_trials) num_epochs = int(args.num_epochs) shuffle_input = bool(int(args.shuffle)) class_names = get_classes(classes_path) data = np.load(data_path) # custom data saved as a numpy file. # has 2 arrays: an object array 'boxes' (variable length of boxes in each image) # and an array of images 'images' anchors = get_anchors(anchors_path) anchors = YOLO_ANCHORS for trial in range(num_trials): # Reprocess data to populate image_data_gen. Sacrifice latency for memory image_data_gen, boxes = data_utils.process_data( iter(data['images']), data['images'].shape[2], data['images'].shape[1], data['boxes'], dim=608) detectors_mask, matching_true_boxes = get_detector_mask(boxes, anchors) model_name = model_prefix + "-" + str(num_frozen) + "fr-trial" + str( trial) print "Training model:", model_name train(class_names, anchors, image_data_gen, boxes, detectors_mask, matching_true_boxes, model_name, num_frozen, num_epochs, shuffle_input=shuffle_input) if test_path != "" and result_path != "": mAP, precision, recalls = run_inference( model_name + ".h5", anchors, classes_path, test_path, None, # output_path 1, # mode 0.5, # score_threshold 0.5, # iou_threshold 0.5) # mAP_iou_threshold with open(result_path, "a+") as f: line = "%d,%d,%.6g,%.6g,%.6g,%d,%s\n" % ( trial, num_frozen, mAP, np.average(precision), np.average(recalls), num_epochs, model_name + ".h5") f.write(line)
from inference import run_inference if __name__ == '__main__': parser = ArgumentParser( description='Lightweight 3D human pose estimation demo. ' 'Press esc to exit, "p" to (un)pause video or process next image.') parser.add_argument('--video', help='Optional. Path to video file or camera id.', type=str, default='') parser.add_argument('--images', help='Optional. Path to input image(s).', nargs='+', default='') parser.add_argument('--height-size', help='Optional. Network input layer height size.', type=int, default=256) parser.add_argument( '--port', help='Optional. Port number on which to host socket server.', type=int, default=8082) args = parser.parse_args() if args.video == '' and args.images == '': raise ValueError('Either --video or --image has to be provided') run_inference(args)