def simulation(): # fname = 'new-dataset/models/diff_weights/method-sin/activation-None/state-0/markov_chain/mu-0/sigma-110/units-10000/nb_plays-20/points-1000/input_dim-1/mu-0-sigma-110-points-1000.csv' # fname = 'new-dataset/models/diff_weights/method-sin/activation-None/state-0/markov_chain/mu-0/sigma-110/units-20/nb_plays-20/points-1000/input_dim-1/predictions-mu-0-sigma-110-points-1000/activation#-elu/state#-0/units#-100/nb_plays#-100/ensemble-6/loss-mle/predictions-batch_size-1500-epochs-16000-debug.csv' fname = './new-dataset/models/diff_weights/method-sin/activation-None/state-0/markov_chain/mu-0/sigma-110/units-20/nb_plays-20/points-1000/input_dim-1/predictions-mu-0-sigma-110-points-1000/activation#-elu/state#-0/units#-100/nb_plays#-100/ensemble-11/loss-mle/predictions-batch_size-1500-debug.csv' fname = './new-dataset/models/diff_weights/method-sin/activation-None/state-0/markov_chain/mu-0/sigma-110/units-20/nb_plays-20/points-1000/input_dim-1/predictions-mu-0-sigma-110-points-1000/activation#-elu/state#-0/units#-100/nb_plays#-100/ensemble-11/loss-mle/predictions-batch_size-1500-debug-4.csv' inputs, outputs = tdata.DatasetLoader.load_data(fname) # points = 2000 # inputs, outputs = inputs[:points], outputs[:points] # interp = 1 # t = np.linspace(1, points, points) # f = interp1d(t, inputs, kind='cubic') # t_interp = np.linspace(1, points, (int)(interp*points-interp+1)) # inputs_interp = f(t_interp) # import matplotlib.pyplot as plt # length = 50 # plt.plot(t[:length], inputs[:length], 'o') # plt.plot(t_interp[:interp*length-1], inputs_interp[:(interp*length-1)], '-x') # plt.show() # plt.plot(t_[:length], ground_truth[:length], 'o') # plt.plot(t_interp[:interp*length-1], ground_truth_interp[:(interp*length-1)], '-x') # plt.show() colors = utils.generate_colors() # fname = '/Users/zxchen/Desktop/debug-1.gif' fname = './debug-4.gif' utils.save_animation(inputs, outputs, fname, step=100, colors=colors, mode="snake")
def predict(sess, image_file): """ Runs the graph stored in "sess" to predict boxes for "image_file". Prints and plots the preditions. Arguments: sess -- your tensorflow/Keras session containing the YOLO graph image_file -- name of an image stored in the "images" folder. Returns: out_scores -- tensor of shape (None, ), scores of the predicted boxes out_boxes -- tensor of shape (None, 4), coordinates of the predicted boxes out_classes -- tensor of shape (None, ), class index of the predicted boxes Note: "None" actually represents the number of predicted boxes, it varies between 0 and max_boxes. """ image, image_data = preprocess_image("images/" + image_file, model_image_size = (608, 608)) out_scores, out_boxes, out_classes = sess.run(yolo_eval(yolo_outputs, image_shape), feed_dict={yolo_model.input:image_data, K.learning_phase():0}) print('Found {} boxes for {}'.format(len(out_boxes), image_file)) colors = generate_colors(class_names) draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors) image.save(os.path.join("out", image_file), quality=90) output_image = scipy.misc.imread(os.path.join("out", image_file)) imshow(output_image) return out_scores, out_boxes, out_classes
def depth_non_cum_figure(cls, df, scale): data = df.pivot(index='tradePx', columns='datetime', values='tradeSz') x = df['datetime'].drop_duplicates() colorscale = generate_colors(scale) best_df = df.drop_duplicates('datetime') bid, ask = best_df['bidPx'], best_df['askPx'] traces = [ go.Heatmap(z=data.values, x=x, y=data.index, hovertemplate=HOVER_TEMPLATES['depth_figure'], colorscale=colorscale), go.Scatter(x=x, y=bid, name='Bid', mode='lines', line_color='green', hovertemplate=HOVER_TEMPLATES['line'], line_width=2), go.Scatter(x=x, y=ask, name='Ask', mode='lines', line_color='red', hovertemplate=HOVER_TEMPLATES['line'], line_width=2) ] layout = dict(title_text="Volumes per price") x_axes = dict(showspikes=True, spikemode="across") return traces, layout, x_axes
def operator_generator_with_noise(): mu = 0 sigma = 0.1 points = 5000 loss_name = 'mse' for method in methods: for weight in weights: for width in widths: LOG.debug( "Processing method: {}, weight: {}, width: {}, points: {}". format(method, weight, width, points)) fname = constants.FNAME_FORMAT["operators_noise"].format( method=method, weight=weight, width=width, mu=mu, sigma=sigma, points=points) inputs, ground_truth = tdata.DatasetLoader.load_data(fname) fname = constants.FNAME_FORMAT[ "operators_noise_predictions"].format(method=method, weight=weight, width=width, mu=mu, sigma=sigma, points=points, loss=loss_name) _, predictions = tdata.DatasetLoader.load_data(fname) inputs = np.vstack([inputs, inputs]).T outputs = np.vstack([ground_truth, predictions]).T colors = utils.generate_colors(outputs.shape[-1]) fname = constants.FNAME_FORMAT["operators_noise_gif"].format( method=method, weight=weight, width=width, sigma=sigma, mu=mu, points=points, loss=loss_name) utils.save_animation(inputs, outputs, fname, step=40, colors=colors) fname = constants.FNAME_FORMAT[ "operators_noise_gif_snake"].format(method=method, weight=weight, width=width, mu=mu, sigma=sigma, points=points, loss=loss_name) utils.save_animation(inputs, outputs, fname, step=40, colors=colors, mode="snake")
def __init__(self, model_path=None, anchors_path=None, classes_path=None, dims=None): if model_path is None or anchors_path is None or classes_path is None or dims is None or len( dims) != 2: raise ValueError('Arguments do not match the specification.') self._model = keras.models.load_model(model_path, compile=False) self._anchors = read_anchors(anchors_path) self._class_names = read_classes(classes_path) self._dims = dims self._image_shape = list(reversed([int(x) for x in dims])) self._model_input_dims = (608, 608) self._colors = generate_colors(self._class_names) self._sess = K.get_session() self._construct_graph()
def detect_img(model): class_num = 0 classes_path = os.path.expanduser(FLAGS.classes_path) with open(classes_path) as f: class_num = len(f.readlines()) colors = generate_colors(class_num) while True: img = input('Input image filename:') try: image = Image.open(img) except: print('Open Error! Try again!') continue else: result = model.detect_image(image) objects = result['objects'] r_image = test_image.make_r_image(image, objects, colors) r_image.show() model.close_session()
def detect_video(model, video_path, output_path=""): import cv2 # Generate colors for drawing bounding boxes. class_num = 0 classes_path = os.path.expanduser(FLAGS.classes_path) with open(classes_path) as f: class_num = len(f.readlines()) colors = generate_colors(class_num) with open(classes_path) as f: class_num = len(f.readlines()) hsv_tuples = [(x / class_num, 1., 1.) for x in range(class_num)] colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples)) colors = list( map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)), colors)) np.random.seed(10101) # Fixed seed for consistent colors across runs. np.random.shuffle( colors) # Shuffle colors to decorrelate adjacent classes. np.random.seed(None) # Reset seed to default. vid = cv2.VideoCapture(video_path) if not vid.isOpened(): raise IOError("Couldn't open webcam or video") video_FourCC = int(vid.get(cv2.CAP_PROP_FOURCC)) video_fps = vid.get(cv2.CAP_PROP_FPS) video_size = (int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)), int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))) isOutput = True if output_path != "" else False if isOutput: print("!!! TYPE:", type(output_path), type(video_FourCC), type(video_fps), type(video_size)) out = cv2.VideoWriter(output_path, video_FourCC, video_fps, video_size) accum_time = 0 curr_fps = 0 fps = "FPS: ??" prev_time = timer() while True: return_value, frame = vid.read() image = Image.fromarray(frame) result = model.detect_image(image) objects = result['objects'] r_image = make_r_image(image, objects, colors) result = np.asarray(r_image) curr_time = timer() exec_time = curr_time - prev_time prev_time = curr_time accum_time = accum_time + exec_time curr_fps = curr_fps + 1 if accum_time > 1: accum_time = accum_time - 1 fps = "FPS: " + str(curr_fps) curr_fps = 0 cv2.putText(result, text=fps, org=(3, 15), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.50, color=(255, 0, 0), thickness=2) cv2.namedWindow("result", cv2.WINDOW_NORMAL) cv2.imshow("result", result) if isOutput: out.write(result) if cv2.waitKey(1) & 0xFF == ord('q'): break model.close_session()
def model_generator_with_noise(): mu = 0 sigma = 0.01 points = 5000 nb_plays = [40] units = 20 loss_name = 'mse' for method in methods: for weight in weights: for width in widths: for _nb_plays in nb_plays: LOG.debug( "Processing method: {}, weight: {}, width: {}, points: {}, units: {}, np_plays: {}, sigma: {}, mu: {}, loss: {}" .format(method, weight, width, points, units, nb_plays, sigma, mu, loss_name)) fname = constants.FNAME_FORMAT["models_noise"].format( method=method, weight=weight, width=width, nb_plays=_nb_plays, units=units, points=points, mu=mu, sigma=sigma) _inputs, ground_truth = tdata.DatasetLoader.load_data( fname) # for __nb_plays in nb_plays: # for bz in batch_sizes: __nb_plays = _nb_plays bz = 1 if True: if True: # fname = constants.FNAME_FORMAT["models_predictions"].format(method=method, weight=weight, # width=width, nb_plays=_nb_plays, # nb_plays_=__nb_plays, # batch_size=bz) fname = constants.FNAME_FORMAT[ "models_noise_predictions"].format( method=method, weight=weight, width=width, nb_plays=_nb_plays, nb_plays_=__nb_plays, batch_size=bz, units=units, points=points, mu=mu, sigma=sigma, loss=loss_name) try: _, predictions = tdata.DatasetLoader.load_data( fname) except: continue outputs = np.vstack([ground_truth, predictions]).T colors = utils.generate_colors(outputs.shape[-1]) inputs = np.vstack( [_inputs for _ in range(outputs.shape[-1])]).T fname = constants.FNAME_FORMAT[ "models_noise_gif"].format( method=method, weight=weight, width=width, nb_plays=_nb_plays, nb_plays_=__nb_plays, batch_size=bz, units=units, points=points, mu=mu, sigma=sigma, loss=loss_name) utils.save_animation(inputs, outputs, fname, step=40, colors=colors) fname = constants.FNAME_FORMAT[ "models_noise_gif_snake"].format( method=method, weight=weight, width=width, nb_plays=_nb_plays, nb_plays_=__nb_plays, batch_size=bz, units=units, points=points, mu=mu, sigma=sigma, loss=loss_name) utils.save_animation(inputs, outputs, fname, step=40, colors=colors, mode="snake") fname = constants.FNAME_FORMAT[ "models_noise_ts_outputs_gif"].format( method=method, weight=weight, width=width, nb_plays=_nb_plays, nb_plays_=__nb_plays, batch_size=bz, units=units, points=points, mu=mu, sigma=sigma, loss=loss_name) # steps = inputs.shape[-1] _inputs = np.arange(points) inputs = np.vstack( [_inputs for _ in range(outputs.shape[-1])]).T utils.save_animation(inputs, outputs, fname, step=points, colors=colors)
def model_nb_plays_generator_with_noise(): step = 40 method = 'sin' # method = 'noise' with_noise = True diff_weights = True run_test = False train_invert = True interp = 10 force_rerun = False mu = 0 sigma = 2 points = 1000 input_dim = 1 # ground truth nb_plays = 20 units = 1 state = 0 activation = None # activation = 'tanh' # predicitons __nb_plays__ = 20 __units__ = 1 __state__ = 0 __activation__ = None # __activation__ = 'tanh' loss_name = 'mse' if method == 'noise': with_noise = True if with_noise is False: mu = 0 sigma = 0 if interp == 1: if run_test is False: if diff_weights is True: base_file_key = 'models_diff_weights' predictions_file_key = 'models_diff_weights_predictions' models_gif_key = 'models_diff_weights_gif' models_snake_gif_key = 'models_diff_weights_snake_gif' models_ts_outputs_gif_key = 'models_diff_weights_ts_outputs_gif' else: base_file_key = 'models' predictions_file_key = 'models_predictions' models_gif_key = 'models_gif' models_snake_gif_key = 'models_snake_gif' models_ts_outputs_gif_key = 'models_ts_outputs_gif' elif run_test is True: if diff_weights is True: base_file_key = 'models_diff_weights_test' predictions_file_key = 'models_diff_weights_test_predictions' models_gif_key = 'models_diff_weights_test_gif' models_snake_gif_key = 'models_diff_weights_test_snake_gif' models_ts_outputs_gif_key = 'models_diff_weights_test_ts_outputs_gif' else: raise elif interp != 1: if run_test is False: if diff_weights is True: if train_invert is False: base_file_key = 'models_diff_weights' models_interp_key = 'models_diff_weights_interp' predictions_file_key = 'models_diff_weights_predictions_interp' models_gif_key = 'models_diff_weights_interp_gif' models_snake_gif_key = 'models_diff_weights_snake_interp_gif' models_ts_outputs_gif_key = 'models_diff_weights_ts_outputs_interp_gif' elif train_invert is True: base_file_key = 'models_diff_weights_interp' models_interp_key = 'models_diff_weights_invert_interp' predictions_file_key = 'models_diff_weights_invert_interp_predictions' models_gif_key = 'models_diff_weights_invert_interp_gif' models_snake_gif_key = 'models_diff_weights_invert_snake_interp_gif' models_ts_outputs_gif_key = 'models_diff_weights_invert_ts_outputs_interp_gif' else: # base_interp_key = 'models_interp' # predictions_file_key = 'models_predictions_interp' # models_gif_key = 'models_interp_gif' # models_snake_gif_key = 'models_snake_interp_gif' # models_ts_outputs_gif_key = 'models_ts_outputs_interp_gif' raise elif run_test is True: if diff_weights is True: base_file_key = 'models_diff_weights_test' models_interp_key = 'models_diff_weights_test_interp' predictions_file_key = 'models_diff_weights_test_predictions_interp' models_gif_key = 'models_diff_weights_test_interp_gif' models_snake_gif_key = 'models_diff_weights_test_snake_interp_gif' models_ts_outputs_gif_key = 'models_diff_weights_test_ts_outputs_interp_gif' else: raise if run_test is True and method == 'sin': method = 'mixed' fname = constants.DATASET_PATH[base_file_key].format(interp=interp, method=method, activation=activation, state=state, mu=mu, sigma=sigma, units=units, nb_plays=nb_plays, points=points, input_dim=input_dim) _inputs, ground_truth = tdata.DatasetLoader.load_data(fname) import ipdb ipdb.set_trace() LOG.debug("Load **ground-truth** dataset from file: {}".format( coloring.cyan(fname))) predicted_fname = constants.DATASET_PATH[predictions_file_key].format( interp=interp, method=method, activation=activation, state=state, mu=mu, sigma=sigma, units=units, nb_plays=nb_plays, points=points, input_dim=input_dim, __activation__=__activation__, __state__=__state__, __units__=__units__, __nb_plays__=__nb_plays__, loss=loss_name) if interp == 1: try: _, predictions = tdata.DatasetLoader.load_data(predicted_fname) LOG.debug("Load **predicted** dataset from file: {}".format( coloring.cyan(predicted_fname))) except FileNotFoundError: LOG.warn("GROUND TRUTH and PREDICTIONS are the SAME dataset") predictions = ground_truth elif interp != 1: models_interp_fname = constants.DATASET_PATH[models_interp_key].format( interp=interp, method=method, activation=activation, state=state, mu=mu, sigma=sigma, units=units, nb_plays=nb_plays, points=points, input_dim=input_dim, __activation__=__activation__, __state__=__state__, __units__=__units__, __nb_plays__=__nb_plays__, loss=loss_name) if force_rerun is False and os.path.isfile(models_interp_fname): LOG.debug("Already interploted...") t_interp = np.linspace(1, points, (int)(interp * points - interp + 1)) _inputs_interp, ground_truth_interp = tdata.DatasetLoader.load_data( models_interp_fname) LOG.debug("Load **ground-truth** dataset from file: {}".format( coloring.purple(models_interp_fname))) try: _, predictions_interp = tdata.DatasetLoader.load_data( predicted_fname) LOG.debug("Load **predicted** dataset from file: {}".format( coloring.cyan(predicted_fname))) except FileNotFoundError: LOG.warn("GROUND TRUTH and PREDICTIONS are the SAME dataset") predictions_interp = ground_truth_interp clip_length = min(predictions_interp.shape[0], _inputs_interp.shape[0]) t_interp = t_interp[:clip_length] _inputs_interp = _inputs_interp[:clip_length] ground_truth_interp = ground_truth_interp[:clip_length] predictions_interp = predictions_interp[:clip_length] else: if train_invert is False: diff = _inputs[1:] - _inputs[:-1] LOG.debug("Max jump between two successive x is {}".format( np.max(np.abs(diff)))) t_ = np.linspace(1, points, points) # f1 = interp1d(t_, _inputs) f2 = interp1d(t_, _inputs, kind='cubic') t_interp = np.linspace(1, points, (int)(interp * points - interp + 1)) _inputs_interp = np.interp(t_interp, t_, _inputs) _inputs_interp = f2(t_interp) clip_length = int((t_interp.shape[0] // input_dim) * input_dim) _inputs_interp = _inputs_interp[:clip_length] # ground_truth_interp = np.interp(_inputs_interp, _inputs, ground_truth, period=1) # predictions_interp = np.interp(_inputs_interp, _inputs, predictions, period=1) _, ground_truth_interp = tdata.DatasetGenerator.systhesis_model_generator( inputs=_inputs_interp, nb_plays=nb_plays, points=t_interp.shape[0], units=units, mu=None, sigma=None, input_dim=input_dim, activation=activation, with_noise=None, method=None, diff_weights=diff_weights) predictions_interp = ground_truth_interp # import matplotlib.pyplot as plt # length = 50 # plt.plot(t_[:length], _inputs[:length], 'o') # plt.plot(t_interp[:interp*length-1], _inputs_interp[:(interp*length-1)], '-x') # plt.show() # plt.plot(t_[:length], ground_truth[:length], 'o') # plt.plot(t_interp[:interp*length-1], ground_truth_interp[:(interp*length-1)], '-x') # plt.show() LOG.debug("Save interploted dataset to file: {}".format( coloring.cyan(models_interp_fname))) tdata.DatasetSaver.save_data(_inputs_interp, ground_truth_interp, models_interp_fname) sys.exit(0) elif train_invert is True: _inputs_interp, ground_truth_interp = ground_truth, _inputs tdata.DatasetSaver.save_data(_inputs_interp, ground_truth_interp, models_interp_fname) LOG.debug("Save interploted dataset to file: {}".format( coloring.cyan(models_interp_fname))) sys.exit(0) _inputs = _inputs_interp ground_truth = ground_truth_interp predictions = predictions_interp models_gif_fname = constants.DATASET_PATH[models_gif_key].format( interp=interp, method=method, activation=activation, state=state, mu=mu, sigma=sigma, units=units, nb_plays=nb_plays, points=points, input_dim=input_dim, __activation__=__activation__, __state__=__state__, __units__=__units__, __nb_plays__=__nb_plays__, loss=loss_name) models_snake_gif_fname = constants.DATASET_PATH[ models_snake_gif_key].format(interp=interp, method=method, activation=activation, state=state, mu=mu, sigma=sigma, units=units, nb_plays=nb_plays, points=points, input_dim=input_dim, __activation__=__activation__, __state__=__state__, __units__=__units__, __nb_plays__=__nb_plays__, loss=loss_name) models_ts_outputs_gif_fname = constants.DATASET_PATH[ models_ts_outputs_gif_key].format(interp=interp, method=method, activation=activation, state=state, mu=mu, sigma=sigma, units=units, nb_plays=nb_plays, points=points, input_dim=input_dim, __activation__=__activation__, __state__=__state__, __units__=__units__, __nb_plays__=__nb_plays__, loss=loss_name) LOG.debug("Write outputs vs. inputs {} into file {}".format( coloring.red("(sequence mode)"), coloring.cyan(models_gif_fname))) outputs = np.vstack([ground_truth, predictions]).T colors = utils.generate_colors(outputs.shape[-1]) inputs = np.vstack([_inputs for _ in range(outputs.shape[-1])]).T # utils.save_animation(inputs, outputs, models_gif_fname, step=step, colors=colors) ##### SNAKE _inputs = np.hstack([_inputs, _inputs]) ground_truth = np.hstack([ground_truth, ground_truth]) predictions = np.hstack([predictions, predictions]) inputs = np.vstack([_inputs for _ in range(outputs.shape[-1])]).T outputs_snake = np.vstack([ground_truth, predictions]).T LOG.debug("Write outputs vs. inputs {} into file {}".format( coloring.red("(snake mode)"), coloring.cyan(models_snake_gif_fname))) utils.save_animation(inputs, outputs_snake, models_snake_gif_fname, step=step, colors=colors, mode="snake") if interp == 1: _inputs = np.arange(points) else: _inputs = t_interp inputs = np.vstack([_inputs for _ in range(outputs.shape[-1])]).T # outputs = np.vstack([ground_truth, predictions]).T LOG.debug("Write outputs vs. ts into file {}".format( coloring.cyan(models_ts_outputs_gif_fname))) utils.save_animation(inputs, outputs, models_ts_outputs_gif_fname, step=points, colors=colors)
image_cp = preprocess_image(image) #图像预处理,resize image, normalization归一化, 增加一个在第0的维度--batch_size tf_image = tf.placeholder(tf.float32,[1,input_size[0],input_size[1],3]) #定义placeholder model_output = darknet(tf_image) #网络的输出 output_sizes = input_size[0]//32, input_size[1]//32 # 特征图尺寸是图片下采样32倍 #这个函数返回框的坐标(左上角-右下角),目标置信度,类别置信度 output_decoded = decode(model_output=model_output,output_sizes=output_sizes, num_class=len(class_names),anchors=anchors) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) #初始化tensorflow全局变量 saver = tf.train.Saver() saver.restore(sess, model_path) #把模型加载到当前session中 bboxes, obj_probs, class_probs = sess.run(output_decoded, feed_dict={tf_image: image_cp}) #这个函数返回框的坐标,目标置信度,类别置信度 bboxes,scores,class_max_index = postprocess(bboxes,obj_probs,class_probs,image_shape=image_shape) #得到候选框之后的处理,先留下阈值大于0.5的框,然后再放入非极大值抑制中去 colors = generate_colors(class_names) img_detection = draw_detection(image, bboxes, scores, class_max_index, class_names, colors) #得到图片 cv2.imwrite(image_detection, img_detection) cv2.imshow("detection_results", img_detection) #显示图片 cv2.waitKey(0) #等待按任意键退出
def archive_pipeline(): start_time = time.time() path = "./Dataset/refined_data/temp/tags_relationship.csv" df = utils.load_csv(path) df["Tag1"] = df["Tag1"].apply(lambda x: "_" + str(x)) df["Tag2"] = df["Tag2"].apply(lambda x: "_" + str(x)) # print(df.head()) weights = df["Occurrence"].values.tolist() threshold = np.quantile(weights, 0.995) min_w, max_w, avg_w = np.min(weights), np.max(weights), np.average(weights) print("Min = {}, Max = {}, Avg = {}, Threshold = {}".format( min_w, max_w, avg_w, threshold)) tags1 = df["Tag1"].values.tolist() tags2 = df["Tag2"].values.tolist() tags = tags1 tags.extend(tags2) vertices = list(set(tags)) n_vertices = len(vertices) # print("Number vertices : ", n_vertices) edge_list = list(zip(tags1, tags2)) # print(edge_list[:3]) # Build graph g = igraph.Graph() g.add_vertices(n_vertices) g.vs["name"] = vertices g.vs["label"] = vertices g.vs["style"] = "filled" g.add_edges(edge_list) g.es["weight"] = weights print(g.summary()) print("\nAfter delete vertices") g.vs.select(_degree_le=5).delete() print(g.summary()) # Community detection cluster = g.community_multilevel(return_levels=True, weights=weights)[-1] print(cluster.summary()) # print([c.summary() for c in cluster]) num_communities = len(cluster) # print(c.membership) labels = cluster.membership g.es.select(weight_lt=threshold)["style"] = "invis" print("\nAfter delete edges") print(g.summary()) # colors = list(np.linspace(0, 0xFFFFFF, num_communities+1)[1:].astype(int)) colors = utils.generate_colors(num_communities) colors = ["#{:06X}".format(color) for color in colors] g.vs["fillcolor"] = [colors[label] for label in labels] # Save graph save_dot_path = "./Visualize/graph.dot" save_pdf_path = "./Visualize/graph.pdf" utils.make_parent_dirs(save_dot_path) g.write_dot(save_dot_path) check_call([ 'sfdp', "-Goverlap=false", '-Tpdf', save_dot_path, '-o', save_pdf_path ]) exec_time = time.time() - start_time print("Time : {:.2f} seconds".format(exec_time))
# ================= # print(cluster.summary()) # print([c.summary() for c in cluster]) # print(c.membership) g.vs["community"] = labels # g.es.select(weight_lt=threshold)["style"] = "invis" g.es.select(lambda e: is_delete_edge(g, e)).delete() print("\nAfter delete edges") print(g.summary()) # colors = list(np.linspace(0, 0xFFFFFF, num_communities+1)[1:].astype(int)) colors = utils.generate_colors(num_communities) colors = ["#{:06X}".format(color) for color in colors] g.vs["fillcolor"] = [colors[label] for label in labels] # Save graph names = "_".join(selected_categories) save_dot_path = "./Visualize/graph_{}_{}.dot".format( names, num_communities) save_pdf_path = "./Visualize/graph_{}_{}.pdf".format( names, num_communities) utils.make_parent_dirs(save_dot_path) g.write_dot(save_dot_path) check_call([ 'sfdp', "-Goverlap=false", "-Goutputorder=edgesfirst", '-Tpdf', save_dot_path, '-o', save_pdf_path ])
def detect_img(model): image_glob = FLAGS.image_glob test_file = FLAGS.test_file print(image_glob) print(FLAGS.model_path) result_name = os.path.basename(os.path.dirname(FLAGS.model_path)) image_source = "" if image_glob: img_path_list = glob.glob(image_glob) image_source = image_glob else: with open(test_file) as f: img_path_list = [line.strip().split()[0] for line in f] image_source = test_file pdir = os.path.join("results", FLAGS.network, os.path.basename(os.path.dirname(image_source))) output_dir = utils.get_unused_dir_num(pdir=pdir, pref=result_name) image_output_dir = os.path.join(output_dir, "images") os.makedirs(image_output_dir, exist_ok=True) prediction_output_dir = os.path.join(output_dir, "predictions") os.makedirs(prediction_output_dir, exist_ok=True) feature_output_dir = os.path.join(output_dir, "feature") os.makedirs(feature_output_dir, exist_ok=True) crop_output_dir = os.path.join(output_dir, "crop") os.makedirs(crop_output_dir, exist_ok=True) # Generate colors for drawing bounding boxes. class_num = 0 classes_path = os.path.expanduser(FLAGS.classes_path) with open(classes_path) as f: class_num = len(f.readlines()) colors = utils.generate_colors(class_num) train_bbox = "" train_polygon = "" train_json = "" for img_path in img_path_list: img_basename, _ = os.path.splitext(os.path.basename(img_path)) try: image = Image.open(img_path) except: print('Open Error! Try again!') continue else: result = model.detect_image(image) objects = result['objects'] objects = utils.take_contours(objects) # save result image with bounding box r_image = utils.make_r_image(image.copy(), objects, colors) r_image.save( os.path.join( image_output_dir, img_basename + ".jpg", )) # save feature map of middle layer if 'feature' in result: feature = result['feature'] utils.visualize_and_save( feature, os.path.join(feature_output_dir, img_basename + ".png")) np.save( os.path.join(feature_output_dir, img_basename + ".npy"), feature) train_bbox += img_path train_polygon += img_path train_json += img_path prediction = "" json_img_objs_list = [] for obj in objects: # save cropped image class_name = obj["class_name"] score = obj["score"] image_base_name = class_name + "_" + "_".join( [str(s) for s in obj["bbox"]]) img_crop = image.crop(obj["bbox"]) img_crop.save( os.path.join(crop_output_dir, image_base_name + ".png")) # train_bbox file x_min, y_min, x_max, y_max = obj["bbox"] coordinates = "{0},{1},{2},{3}".format(x_min, y_min, x_max, y_max) train_bbox += " {coordinates},{class_id}".format( coordinates=coordinates, class_id=obj["class_id"], ) if 'polygon' in obj: train_polygon += " [{coordinates},{class_id}]".format( coordinates=_list_to_str(obj["polygon"]), class_id=obj["class_id"], ) json_img_objs = { "bbox": obj["bbox"], "class_id": obj["class_id"], "score": obj["score"], } if "all_points_x" in obj: json_img_objs["all_points_x"] = obj["all_points_x"] json_img_objs["all_points_y"] = obj["all_points_y"] # if "contours" in obj: # json_img_objs["contours"] = [contour.tolist() for contour in obj["contours"]] # json_img_objs["hierarchy"] = [hierarchy.tolist() for hierarchy in obj["hierarchy"]] json_img_objs_list.append(json_img_objs) # prediction file prediction += "{class_name}\t{score}\t{coordinates}\n".format( score=score, class_name=class_name, coordinates="{0}\t{1}\t{2}\t{3}".format( x_min, y_min, x_max, y_max), ) train_bbox += "\n" train_polygon += "\n" train_json += json.dumps(json_img_objs_list, cls=NumpyEncoder, sort_keys=True, separators=(',', ':')) train_json += "\n" # save prediction text for each image with open( os.path.join(prediction_output_dir, img_basename + ".txt"), "w") as f: print(prediction, end="", file=f) shutil.copy(os.path.abspath(classes_path), os.path.join(output_dir, "classes.txt")) # save train_bbox text with open(os.path.join(output_dir, "train_bbox.txt"), "w") as f: print(train_bbox, end="", file=f) # save train_polygon text with open(os.path.join(output_dir, "train_polygon.txt"), "w") as f: print(train_polygon, end="", file=f) with open(os.path.join(output_dir, "train_json.txt"), "w") as f: print(train_json, end="", file=f) model.close_session()
anchors = anchors / input_shape[0] # as unit of image class_path = "./data/coco_classes.txt" class_names = utils.get_classes(class_path) num_cls = len(class_names) """load model""" weightsfile = './weights/yolov3.weights' net = YOLO() net.to(device) load_weights(net, weightsfile) net.eval() with torch.no_grad(): image = image.to(device) feats = net(image) boxes_, scores_, classes_ = filter( feats, anchors, image_size, device, num_cls, threshold=0.4 ) boxes = boxes_.cpu().numpy() scores = scores_.cpu().numpy() classes = classes_.cpu().numpy() colors = utils.generate_colors(class_names) utils.draw_boxes(im, scores, boxes, classes, class_names, colors) im.save("./data/car_out.jpg")