simplify for api

app.py

@@ -118,22 +118,10 @@ def confidence_analysis(periodicity, counts, frames, out_dir='confidence_animati
     plt.close(fig)
 
 
-def inference(x, both_feet, has_misses, true_count, center_crop, img_resize, miss_threshold, img_size=192, seq_len=64, stride_length=32, stride_pad=3, batch_size=4, median_pred_filter=True, api_call=False):
+def inference(x, img_size=192, seq_len=64, stride_length=32, stride_pad=3, batch_size=4, miss_threshold=0.85, median_pred_filter=True, center_crop=True, both_feet=True, api_call=False):
     print(x)
-    img_size = int((img_size - 64) * img_resize + 64)
     api = HfApi(token=os.environ['DATASET_SECRET'])
     out_file = str(uuid.uuid1())
-    if has_misses:
-        out_file = "misses_" + out_file
-    if true_count != -1:
-        out_file += '_' + str(true_count)
-        out_file = f"labeled_videos/{out_file}.mp4"
-        api.upload_file(
-            path_or_fileobj=x,
-            path_in_repo=out_file,
-            repo_id="dylanplummer/jumprope",
-            repo_type="dataset",
-        )
     
         
     cap = cv2.VideoCapture(x)
@@ -231,6 +219,7 @@ def inference(x, both_feet, has_misses, true_count, center_crop, img_resize, mis
     periodicity = np.divide(periodicities, period_length_overlaps, where=period_length_overlaps!=0)[:length]
     if api_call:
         return np.array2string(periodLength, formatter={'float_kind':lambda x: "%.3f" % x}).replace('\n', ''), np.array2string(periodicity, formatter={'float_kind':lambda x: "%.3f" % x}).replace('\n', '')
+   
     if median_pred_filter:
         periodicity = medfilt(periodicity, 5)
         periodLength = medfilt(periodLength, 5)
@@ -249,130 +238,6 @@ def inference(x, both_feet, has_misses, true_count, center_crop, img_resize, mis
         count_pred = count_pred / 2
         count = np.array(count) / 2
 
-    animate_frames = len(count)
-    anim_subsample = max(1, int(fps / 24))
-    fig, ax = plt.subplots(figsize = (3, 3))
-    canvas_width, canvas_height = fig.canvas.get_width_height()
-    img_ax = ax
-
-    # imgs = []
-    # for img in all_frames:
-    #     img = Image.fromarray(img)
-    #     width, height = img.size
-    #     if width > height:
-    #         img = img.resize((int(width / (height / img_size)), img_size))
-    #     else:
-    #         img = img.resize((img_size, int(height / (width / img_size))))
-    #     h_center, w_center = height / 2, width / 2
-    #     h_start, w_start = int(h_center - img_size / 2), int(w_center - img_size / 2)
-    #     cropped = img.crop((w_start, h_start, w_start + img_size, h_start + img_size))
-    #     imgs.append(cropped)
-
-    # confidence_analysis(periodicity, count, imgs)
-
-    # alpha=1.0
-    # colormap=plt.cm.OrRd
-    # h, w, _ = np.shape(imgs[0])
-    # wedge_x = 34 / canvas_width * w
-    # wedge_y = 34 / canvas_height * h
-    # wedge_r = 30 / canvas_height * h
-    # txt_x = 34 / canvas_width * w
-    # txt_y = 36 / canvas_height * h
-    # otxt_size = 25 / canvas_height * h
-    # wedge1 = matplotlib.patches.Wedge(
-    #     center=(wedge_x, wedge_y),
-    #     r=wedge_r,
-    #     theta1=0,
-    #     theta2=0,
-    #     color=colormap(1.),
-    #     alpha=alpha)
-    # wedge2 = matplotlib.patches.Wedge(
-    #     center=(wedge_x, wedge_y),
-    #     r=wedge_r,
-    #     theta1=0,
-    #     theta2=0,
-    #     color=colormap(0.5),
-    #     alpha=alpha)
-
-    # im = img_ax.imshow(cropped)
-
-    # img_ax.add_patch(wedge1)
-    # img_ax.add_patch(wedge2)
-    # txt = img_ax.text(
-    #     txt_x,
-    #     txt_y,
-    #     '0',
-    #     size=otxt_size,
-    #     ha='center',
-    #     va='center',
-    #     alpha=0.9,
-    #     color='white',
-    # )
-
-    # def animate_fn(i):
-    #     if anim_subsample:
-    #         i *= anim_subsample
-    #     cropped = imgs[i + stride_pad]
-    #     current_count = count[i]
-    #     if current_count % 2 == 0:
-    #         wedge1.set_color(colormap(1.0))
-    #         wedge2.set_color(colormap(0.5))
-    #     else:
-    #         wedge1.set_color(colormap(0.5))
-    #         wedge2.set_color(colormap(1.0))
-    #     txt.set_text(int(current_count))
-    #     wedge1.set_theta1(-90)
-    #     wedge1.set_theta2(-90 - 360 * (1 - current_count % 1.0))
-    #     wedge2.set_theta1(-90 - 360 * (1 - current_count % 1.0))
-    #     wedge2.set_theta2(-90)
-        
-    #     im.set_data(cropped)
-    #     img_ax.set_title(f"Time: {i / fps:.1f}s, {current_count:.1f}/{count_pred:.1f} jumps")
-    #     img_ax.set_xticks([])
-    #     img_ax.set_yticks([])
-    #     img_ax.spines['top'].set_visible(False)
-    #     img_ax.spines['right'].set_visible(False)
-    #     img_ax.spines['bottom'].set_visible(False)
-    #     img_ax.spines['left'].set_visible(False)
-
-    outf = x
-    # anim_start_time = time.time()
-    # # Open an ffmpeg process
-    # outf = x.replace('.mp4', '_jump.mp4')
-    # cmdstring = ('ffmpeg', 
-    #             '-y', '-r', f'{30 if anim_subsample != 1 else int(fps)}', # overwrite, 24fps
-    #             '-s', f'{canvas_width}x{canvas_height}',
-    #             '-pix_fmt', 'argb',
-    #             '-hide_banner', '-loglevel', 'error',
-    #             '-f', 'rawvideo',  '-i', '-', # tell ffmpeg to expect raw video from the pipe
-    #             '-i', x, '-map', '0:v', '-map', '1:a', # map video from the pipe, audio from the input file
-    #             '-c:v', 'libx264', # https://trac.ffmpeg.org/wiki/Encode/H.264
-    #             outf) # output encoding
-    # try:
-    #     p = subprocess.Popen(cmdstring, stdin=subprocess.PIPE)
-    # except FileNotFoundError as e:
-    #     print(e)
-    #     print('Trying to install ffmpeg...')
-    #     os.system("apt install ffmpeg -y")
-    #     p = subprocess.Popen(cmdstring, stdin=subprocess.PIPE)
-
-    # # Draw frames and write to the pipe
-    # anim_length = int(animate_frames / anim_subsample) - 1
-    # for frame in range(anim_length):
-    #     # draw the frame
-    #     animate_fn(frame)
-    #     fig.canvas.draw()
-    #     # extract the image as an ARGB string
-    #     string = fig.canvas.tostring_argb()
-    #     # write to pipe
-    #     p.stdin.write(string)
-
-    # # Finish up
-    # p.communicate()
-    # print(f"Animation done in {time.time() - anim_start_time:.2f} seconds")
-    #cvrt_string = f'ffmpeg -hide_banner -loglevel error -i "{outf}" -i "{x}" -map 0:v -map 1:a -y -r 24 -s {canvas_width}x{canvas_height} -c:v libx264 "{outf.replace(".mp4", "_audio.mp4")}"'
-    #os.system(cvrt_string)
-
     if both_feet:
         count_msg = f"## Predicted Count (both feet): {count_pred:.1f}"
     else:
@@ -428,13 +293,8 @@ def inference(x, both_feet, has_misses, true_count, center_crop, img_resize, mis
                         histnorm='percent',
                         title="Distribution of jumping speed (jumps-per-second)",
                         range_x=[np.min(jumps_per_second[jumps_per_second > 0]) - 0.5, np.max(jumps_per_second) + 0.5])
-    
-    vid = px.imshow(np.uint8(all_frames)[:128], animation_frame=0, binary_string=True, binary_compression_level=5, binary_format='jpg', template="plotly_dark")
-    vid.update_xaxes(showticklabels=False).update_yaxes(showticklabels=False)
-    vid.layout.updatemenus[0].buttons[0].args[1]['frame']['duration'] = 13
-    vid.layout.updatemenus[0].buttons[0].args[1]['transition']['duration'] = 5
 
-    return count_msg, vid, fig, hist, periodLength
+    return count_msg, fig, hist, periodLength
         
 
 DESCRIPTION = '# NextJump'
@@ -448,13 +308,6 @@ with gr.Blocks() as demo:
         with gr.Row():
             in_video = gr.Video(type="file", label="Input Video", elem_id='input-video', format='mp4').style(width=400)
             with gr.Column():
-                gr.Markdown(label="Optional settings and parameters:")
-                true_count = gr.Number(label="True Count (optional)", info="Provide a true count if you are ok with us using your video for training", elem_id='true-count', value=-1)
-                both_feet = gr.Checkbox(label="Both feet", info="Count both feet rather than only one", elem_id='both-feet', value=False)
-                misses = gr.Checkbox(label="Contains misses", info="Only necessary if providing a true count for training", elem_id='both-feet', value=False)
-                center_crop = gr.Checkbox(label="Center crop square", info="Either crop a square out of the center or stretch to a square", elem_id='center-crop', value=True)
-                image_size = gr.Slider(label="Image size", info="Lower image size is faster but less accurate", elem_id='miss-thresh', minimum=0.0, maximum=1.0, step=0.01, value=1.0)
-                miss_thresh = gr.Slider(label="Miss threshold", info="Lower values are more sensitive to misses", elem_id='miss-thresh', minimum=0.0, maximum=0.99, step=0.01, value=0.95)
                 with gr.Row():
                     run_button = gr.Button(label="Run", elem_id='run-button').style(full_width=False)
                     count_only = gr.Button(label="Run (No Viz)", elem_id='count-only', visible=False).style(full_width=False)
@@ -465,13 +318,12 @@ with gr.Blocks() as demo:
                 out_text = gr.Markdown(label="Predicted Count", elem_id='output-text')
                 period_length = gr.Textbox(label="Period Length", elem_id='period-length', visible=False)
                 periodicity = gr.Textbox(label="Periodicity", elem_id='periodicity', visible=False)
-            with gr.Column(min_width=480):
+            #with gr.Column(min_width=480):
                 #out_video = gr.PlayableVideo(label="Output Video", elem_id='output-video', format='mp4')
-                out_video = gr.Plot(label="Output Video", elem_id='output-video')
         out_plot = gr.Plot(label="Jumping Speed", elem_id='output-plot')
         out_hist = gr.Plot(label="Speed Histogram", elem_id='output-hist')
                 
-    inputs = [in_video, both_feet, misses, true_count, center_crop, image_size, miss_thresh]
+    inputs = [in_video]
     with gr.Accordion(label="Instructions and more information", open=False):
         instructions = "## Instructions:"
         instructions += "\n* Upload a video and click 'Run' to get a prediction of the number of jumps (either one foot, or both). This could take a couple minutes! The model is trained on single rope and double dutch speed, but try out any videos you want."
@@ -495,22 +347,10 @@ with gr.Blocks() as demo:
                         [b, False, True, -1, True, 1.0, 0.95],
                     ],
                 inputs=inputs,
-                outputs=[out_text, out_video, out_plot, out_hist],
+                outputs=[out_text, out_plot, out_hist],
                 fn=inference, cache_examples=os.getenv('SYSTEM') == 'spaces')
-    with gr.Accordion(label="Data usage and disclaimer", open=False):
-        data_usage = "## Data usage:"
-        data_usage += "\n* By default, no data submitted to this demo is stored by us."
-        data_usage += "\n* If you would like to contribute your video for further model improvements please provide the true count (either one or both feet) and specify if the video contains any misses."
-        data_usage += "\n* The video will be uploaded to a private dataset repository here on HuggingFace"
-        gr.Markdown(data_usage)
-
-        disclaimer = "## Disclaimer:"
-        disclaimer += "\n* This model was trained on a small dataset of videos (~20 hours). It is not guaranteed to work on all videos and should not be used yet in real competitive settings."
-        disclaimer += "\n* Deep learning models such as this one are susceptible to biases in the training data."
-        disclaimer += " We are aware of the potential for bias and expect quantifiable differences in performance on counting videos from different demographics not represented in the training data. We are working to improve the model and mitigate these biases. If you notice any issues, please let us know."
-        gr.Markdown(disclaimer)
 
-    run_button.click(inference, inputs, outputs=[out_text, out_video, out_plot, out_hist])
+    run_button.click(inference, inputs, outputs=[out_text, out_plot, out_hist])
     api_inference = partial(inference, api_call=True)
     count_only.click(api_inference, inputs, outputs=[period_length, periodicity], api_name='inference')