Merge pull request #1 from dodijk/restructure

app.py

@@ -16,13 +16,19 @@ import matplotlib.pyplot as plt
 import imagehash
 from PIL import Image
 
-import numpy as np
+import numpy as np  
 import pandas as pd
 import faiss
 
 import shutil
 
+from kats.detectors.cusum_detection import CUSUMDetector
+from kats.detectors.robust_stat_detection import RobustStatDetector
+from kats.consts import TimeSeriesData
+
 FPS = 5
+MIN_DISTANCE = 4
+MAX_DISTANCE = 30
 
 video_directory = tempfile.gettempdir()
 
@@ -77,6 +83,8 @@ def compute_hashes(clip, fps=FPS):
         yield {"frame": 1+index*fps, "hash": hashed}
 
 def index_hashes_for_video(url, is_file = False):
+    """ Download a video if it is a url, otherwise refer to the file. Secondly index the video
+    using faiss indices and return thi index. """
     if not is_file:
         filename = download_video_from_url(url)
     else:
@@ -105,7 +113,7 @@ def index_hashes_for_video(url, is_file = False):
     logging.info(f"Indexed hashes for {index.ntotal} frames to {filename}.index.")
     return index
 
-def compare_videos(url, target, MIN_DISTANCE = 3): # , is_file = False):
+def get_video_indices(url, target, MIN_DISTANCE = 4):
     """" The comparison between the target and the original video will be plotted based
     on the matches between the target and the original video over time. The matches are determined
     based on the minimum distance between hashes (as computed by faiss-vectors) before they're considered a match. 
@@ -116,9 +124,8 @@ def compare_videos(url, target, MIN_DISTANCE = 3): # , is_file = False):
     - MIN_DISTANCE: integer representing the minimum distance between hashes on bit-level before its considered a match
     """
     # TODO: Fix crash if no matches are found
-    if url.endswith('dl=1'):
-        is_file = False
-    elif url.endswith('.mp4'):
+    is_file = False
+    if url.endswith('.mp4'):
         is_file = True
 
     # Url (short video) 
@@ -128,13 +135,32 @@ def compare_videos(url, target, MIN_DISTANCE = 3): # , is_file = False):
     
     # Target video (long video)
     target_indices = [index_hashes_for_video(x) for x in [target]]
-    
+
+    return video_index, hash_vectors, target_indices    
+
+def compare_videos(video_index, hash_vectors, target_indices, MIN_DISTANCE = 3): # , is_file = False):
+    """ Search for matches between the indices of the  target video (long video) 
+    and the given hash vectors of a video"""
     # The results are returned as a triplet of 1D arrays 
     # lims, D, I, where result for query i is in I[lims[i]:lims[i+1]] 
     # (indices of neighbors), D[lims[i]:lims[i+1]] (distances).
     lims, D, I = target_indices[0].range_search(hash_vectors, MIN_DISTANCE)
-
-    return plot_comparison(lims, D, I, hash_vectors, MIN_DISTANCE = MIN_DISTANCE)
+    return lims, D, I, hash_vectors
+
+def get_decent_distance(url, target, MIN_DISTANCE, MAX_DISTANCE):
+    """ To get a decent heurstic for a base distance check every distance from MIN_DISTANCE to MAX_DISTANCE
+    until the number of matches found is equal to or higher than the number of frames in the source video"""
+    for distance in np.arange(start = MIN_DISTANCE - 2, stop = MAX_DISTANCE + 2, step = 2, dtype=int):
+        distance = int(distance)
+        video_index, hash_vectors, target_indices = get_video_indices(url, target, MIN_DISTANCE = distance)
+        lims, D, I, hash_vectors = compare_videos(video_index, hash_vectors, target_indices, MIN_DISTANCE = distance)
+        nr_source_frames = video_index.ntotal
+        nr_matches = len(D)
+        logging.info(f"{(nr_matches/nr_source_frames) * 100.0:.1f}% of frames have a match for distance '{distance}' ({nr_matches} matches for {nr_source_frames} frames)")
+        if nr_matches >= nr_source_frames:
+            return distance  
+    logging.warning(f"No matches found for any distance between {MIN_DISTANCE} and {MAX_DISTANCE}")
+    return None                              
 
 def plot_comparison(lims, D, I, hash_vectors, MIN_DISTANCE = 3):
     sns.set_theme()
@@ -168,29 +194,151 @@ def plot_comparison(lims, D, I, hash_vectors, MIN_DISTANCE = 3):
     return fig 
 
 logging.basicConfig()
-logging.getLogger().setLevel(logging.DEBUG)
+logging.getLogger().setLevel(logging.INFO)
+
+def plot_multi_comparison(df, change_points):
+    """ From the dataframe plot the current set of plots, where the bottom right is most indicative """
+    fig, ax_arr = plt.subplots(3, 2, figsize=(12, 6), dpi=100, sharex=True)
+    sns.scatterplot(data = df, x='time', y='SOURCE_S', ax=ax_arr[0,0])
+    sns.lineplot(data = df, x='time', y='SOURCE_LIP_S', ax=ax_arr[0,1])
+    sns.scatterplot(data = df, x='time', y='OFFSET', ax=ax_arr[1,0])
+    sns.lineplot(data = df, x='time', y='OFFSET_LIP', ax=ax_arr[1,1])
+
+    # Plot change point as lines 
+    sns.lineplot(data = df, x='time', y='OFFSET_LIP', ax=ax_arr[2,1])
+    for x in change_points:
+        cp_time = x.start_time
+        plt.vlines(x=cp_time, ymin=np.min(df['OFFSET_LIP']), ymax=np.max(df['OFFSET_LIP']), colors='red', lw=2)
+        rand_y_pos = np.random.uniform(low=np.min(df['OFFSET_LIP']), high=np.max(df['OFFSET_LIP']), size=None)
+        plt.text(x=cp_time, y=rand_y_pos, s=str(np.round(x.confidence, 2)), color='r', rotation=-0.0, fontsize=14)
+    plt.xticks(rotation=90)
+    return fig
+
+
+def get_videomatch_df(url, target, min_distance=MIN_DISTANCE, vanilla_df=False):
+    distance = get_decent_distance(url, target, MIN_DISTANCE, MAX_DISTANCE)
+    video_index, hash_vectors, target_indices = get_video_indices(url, target, MIN_DISTANCE = distance)
+    lims, D, I, hash_vectors = compare_videos(video_index, hash_vectors, target_indices, MIN_DISTANCE = distance)
+
+    target = [(lims[i+1]-lims[i]) * [i] for i in range(hash_vectors.shape[0])]
+    target_s = [i/FPS for j in target for i in j]
+    source_s = [i/FPS for i in I]
+
+    # Make df
+    df = pd.DataFrame(zip(target_s, source_s, D, I), columns = ['TARGET_S', 'SOURCE_S', 'DISTANCE', 'INDICES'])
+    if vanilla_df:
+        return df
+        
+    # Minimum distance dataframe ----
+    # Group by X so for every second/x there will be 1 value of Y in the end
+    # index_min_distance = df.groupby('TARGET_S')['DISTANCE'].idxmin()
+    # df_min = df.loc[index_min_distance]
+    # df_min
+    # -------------------------------
+
+    df['TARGET_WEIGHT'] = 1 - df['DISTANCE']/distance # Higher value means a better match    
+    df['SOURCE_WEIGHTED_VALUE'] = df['SOURCE_S'] * df['TARGET_WEIGHT'] # Multiply the weight (which indicates a better match) with the value for Y and aggregate to get a less noisy estimate of Y
+
+    # Group by X so for every second/x there will be 1 value of Y in the end
+    grouped_X = df.groupby('TARGET_S').agg({'SOURCE_WEIGHTED_VALUE' : 'sum', 'TARGET_WEIGHT' : 'sum'})
+    grouped_X['FINAL_SOURCE_VALUE'] = grouped_X['SOURCE_WEIGHTED_VALUE'] / grouped_X['TARGET_WEIGHT'] 
+
+    # Remake the dataframe
+    df = grouped_X.reset_index()
+    df = df.drop(columns=['SOURCE_WEIGHTED_VALUE', 'TARGET_WEIGHT'])
+    df = df.rename({'FINAL_SOURCE_VALUE' : 'SOURCE_S'}, axis='columns')
+
+    # Add NAN to "missing" x values (base it off hash vector, not target_s)
+    step_size = 1/FPS
+    x_complete =  np.round(np.arange(start=0.0, stop = max(df['TARGET_S'])+step_size, step = step_size), 1) # More robust    
+    df['TARGET_S'] = np.round(df['TARGET_S'], 1)
+    df_complete = pd.DataFrame(x_complete, columns=['TARGET_S'])
+
+    # Merge dataframes to get NAN values for every missing SOURCE_S
+    df = df_complete.merge(df, on='TARGET_S', how='left')
+
+    # Interpolate between frames since there are missing values
+    df['SOURCE_LIP_S'] = df['SOURCE_S'].interpolate(method='linear', limit_direction='both', axis=0)
+   
+    # Add timeshift col and timeshift col with Linearly Interpolated Values
+    df['TIMESHIFT'] = df['SOURCE_S'].shift(1) - df['SOURCE_S']
+    df['TIMESHIFT_LIP'] = df['SOURCE_LIP_S'].shift(1) - df['SOURCE_LIP_S']
+
+    # Add Offset col that assumes the video is played at the same speed as the other to do a "timeshift"
+    df['OFFSET'] = df['SOURCE_S'] - df['TARGET_S'] - np.min(df['SOURCE_S'])
+    df['OFFSET_LIP'] = df['SOURCE_LIP_S'] - df['TARGET_S'] - np.min(df['SOURCE_LIP_S'])
+    
+    # Add time column for plotting
+    df['time'] = pd.to_datetime(df["TARGET_S"], unit='s') # Needs a datetime as input
+    return df
+
+def get_change_points(df, smoothing_window_size=10, method='CUSUM'):
+    tsd = TimeSeriesData(df.loc[:,['time','OFFSET_LIP']])
+    if method.upper() == "CUSUM":
+        detector = CUSUMDetector(tsd)
+    elif method.upper() == "ROBUST":
+        detector = RobustStatDetector(tsd)
+    change_points =  detector.detector(smoothing_window_size=smoothing_window_size, comparison_window=-2)
+
+    # Print some stats
+    if method.upper() == "CUSUM" and change_points != []:
+        mean_offset_prechange = change_points[0].mu0 
+        mean_offset_postchange = change_points[0].mu1 
+        jump_s = mean_offset_postchange - mean_offset_prechange
+        print(f"Video jumps {jump_s:.1f}s in time at {mean_offset_prechange:.1f} seconds")
+    return change_points
+
+def get_comparison(url, target, MIN_DISTANCE = 4):
+    """ Function for Gradio to combine all helper functions"""
+    video_index, hash_vectors, target_indices = get_video_indices(url, target, MIN_DISTANCE = MIN_DISTANCE)
+    lims, D, I, hash_vectors = compare_videos(video_index, hash_vectors, target_indices, MIN_DISTANCE = MIN_DISTANCE)
+    fig = plot_comparison(lims, D, I, hash_vectors, MIN_DISTANCE = MIN_DISTANCE)
+    return fig
+
+def get_auto_comparison(url, target, smoothing_window_size=10, method="CUSUM"):
+    """ Function for Gradio to combine all helper functions"""
+    distance = get_decent_distance(url, target, MIN_DISTANCE, MAX_DISTANCE)
+    if distance == None:
+        raise gr.Error("No matches found!")
+    video_index, hash_vectors, target_indices = get_video_indices(url, target, MIN_DISTANCE = distance)
+    lims, D, I, hash_vectors = compare_videos(video_index, hash_vectors, target_indices, MIN_DISTANCE = distance)
+    # fig = plot_comparison(lims, D, I, hash_vectors, MIN_DISTANCE = distance)
+    df = get_videomatch_df(url, target, min_distance=MIN_DISTANCE, vanilla_df=False)
+    change_points = get_change_points(df, smoothing_window_size=smoothing_window_size, method=method)
+    fig = plot_multi_comparison(df, change_points)
+    return fig
+
+    
 
 video_urls = ["https://www.dropbox.com/s/8c89a9aba0w8gjg/Ploumen.mp4?dl=1",
               "https://www.dropbox.com/s/rzmicviu1fe740t/Bram%20van%20Ojik%20krijgt%20reprimande.mp4?dl=1",
               "https://www.dropbox.com/s/wcot34ldmb84071/Baudet%20ontmaskert%20Omtzigt_%20u%20bent%20door%20de%20mand%20gevallen%21.mp4?dl=1",
+              "https://drive.google.com/uc?id=1XW0niHR1k09vPNv1cp6NvdGXe7FHJc1D&export=download",
               "https://www.dropbox.com/s/4ognq8lshcujk43/Plenaire_zaal_20200923132426_Omtzigt.mp4?dl=1"]
 
 index_iface = gr.Interface(fn=lambda url: index_hashes_for_video(url).ntotal, 
-                     inputs="text", outputs="text", 
+                     inputs="text", 
+                     outputs="text", 
                      examples=video_urls, cache_examples=True)
 
-compare_iface = gr.Interface(fn=compare_videos,
-                     inputs=["text", "text", gr.Slider(1, 25, 3, step=1)], outputs="plot", 
+compare_iface = gr.Interface(fn=get_comparison,
+                     inputs=["text", "text", gr.Slider(2, 30, 4, step=2)], 
+                     outputs="plot", 
+                     examples=[[x, video_urls[-1]] for x in video_urls[:-1]])
+
+auto_compare_iface = gr.Interface(fn=get_auto_comparison,
+                     inputs=["text", "text", gr.Slider(1, 50, 10, step=1), gr.Dropdown(choices=["CUSUM", "Robust"], value="CUSUM")], 
+                     outputs="plot", 
                      examples=[[x, video_urls[-1]] for x in video_urls[:-1]])
 
-iface = gr.TabbedInterface([index_iface, compare_iface], ["Index", "Compare"])
+iface = gr.TabbedInterface([auto_compare_iface, compare_iface, index_iface,], ["AutoCompare", "Compare", "Index"])
 
 if __name__ == "__main__":
     import matplotlib
-    matplotlib.use('SVG')
+    matplotlib.use('SVG') # To be able to plot in gradio
 
     logging.basicConfig()
-    logging.getLogger().setLevel(logging.DEBUG)
+    logging.getLogger().setLevel(logging.INFO)
 
-    iface.launch()
+    iface.launch(inbrowser=True, debug=True)
     #iface.launch(auth=("test", "test"), share=True, debug=True)

clip_data.ipynb

@@ -2,9 +2,49 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): api.ipify.org:443\n",
+      "DEBUG:urllib3.connectionpool:https://api.ipify.org:443 \"GET / HTTP/1.1\" 200 15\n",
+      "DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): api.gradio.app:443\n",
+      "DEBUG:urllib3.connectionpool:https://api.gradio.app:443 \"POST /gradio-initiated-analytics/ HTTP/1.1\" 200 31\n",
+      "DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): api.gradio.app:443\n",
+      "DEBUG:urllib3.connectionpool:https://api.gradio.app:443 \"POST /gradio-initiated-analytics/ HTTP/1.1\" 200 31\n",
+      "DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): api.gradio.app:443\n",
+      "DEBUG:urllib3.connectionpool:https://api.gradio.app:443 \"GET /pkg-version HTTP/1.1\" 200 20\n",
+      "DEBUG:asyncio:Using selector: KqueueSelector\n",
+      "DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): api.ipify.org:443\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using cache from '/Users/ijanssen/videomatch/gradio_cached_examples/15' directory. If method or examples have changed since last caching, delete this folder to clear cache.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "DEBUG:urllib3.connectionpool:https://api.ipify.org:443 \"GET / HTTP/1.1\" 200 15\n",
+      "DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): api.gradio.app:443\n",
+      "DEBUG:urllib3.connectionpool:https://api.gradio.app:443 \"POST /gradio-initiated-analytics/ HTTP/1.1\" 200 31\n",
+      "DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): api.gradio.app:443\n",
+      "DEBUG:urllib3.connectionpool:https://api.gradio.app:443 \"POST /gradio-initiated-analytics/ HTTP/1.1\" 200 31\n",
+      "DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): api.gradio.app:443\n",
+      "DEBUG:urllib3.connectionpool:https://api.gradio.app:443 \"GET /pkg-version HTTP/1.1\" 200 20\n",
+      "DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): api.ipify.org:443\n",
+      "DEBUG:urllib3.connectionpool:https://api.ipify.org:443 \"GET / HTTP/1.1\" 200 15\n",
+      "DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): api.gradio.app:443\n",
+      "DEBUG:urllib3.connectionpool:https://api.gradio.app:443 \"POST /gradio-initiated-analytics/ HTTP/1.1\" 200 31\n"
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -34,7 +74,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "                                                                \r"
+      "                                                                 \r"
      ]
     },
     {
@@ -107,11 +147,244 @@
     "    video.write_videofile(output_filename, audio_codec='aac')\n",
     "\n",
     "# edit_remove_part(\"videos/Ploumen.mp4\", start_s = 5.0, end_s = 10.0)\n",
-    "edit_change_order(\"videos/Ploumen.mp4\", start_s = 5.0, end_s = 10.0, insert_s = 15.0)\n",
+    "# edit_change_order(\"videos/Ploumen.mp4\", start_s = 5.0, end_s = 10.0, insert_s = 15.0)\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[(51, 92), (14, 98), (64, 85), (63, 90), (63, 96)]\n",
+      "[112, 0, 53, 96, 123]\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "import numpy as np\n",
+    "\n",
+    "MAX = 130\n",
+    "\n",
+    "# Get some random start_s and end_s pairs where start_s is always lower than end_s\n",
+    "rand_start_s = np.random.randint(low=0, high=MAX, size=5)\n",
+    "rand_end_s = np.random.randint(low=0, high=MAX, size=5)\n",
+    "rand_pairs = zip(rand_start_s, rand_end_s)\n",
+    "rand_pairs = [(x,y) if (x < y) else (y, x) for x, y in rand_pairs]\n",
+    "\n",
+    "def get_insert_s(start_s, end_s, max=MAX):\n",
+    "    \"\"\" Get a insert_s that is outside the start_s and end_s \"\"\"\n",
+    "    random_choice = bool(np.random.randint(low=0, high=2, size=1)[0])\n",
+    "    if random_choice:\n",
+    "        return np.random.randint(low=0, high=start_s, size=1)[0]\n",
+    "    else:\n",
+    "        return np.random.randint(low=end_s, high=MAX, size=1)[0]\n",
     "\n",
+    "rand_insert_s = [get_insert_s(x, y) for x, y in rand_pairs]\n",
+    "\n",
+    "print(rand_pairs)\n",
+    "print(rand_insert_s)\n",
     "\n"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Part Start = 51.0, Part Cutout = 41, Part Mid = 20, Part End = 38.03\n",
+      "Moviepy - Building video videos/Ploumen_CO_51s_to_92_at_112.mp4.\n",
+      "MoviePy - Writing audio in Ploumen_CO_51s_to_92_at_112TEMP_MPY_wvf_snd.mp4\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                      \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MoviePy - Done.\n",
+      "Moviepy - Writing video videos/Ploumen_CO_51s_to_92_at_112.mp4\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                 \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Moviepy - Done !\n",
+      "Moviepy - video ready videos/Ploumen_CO_51s_to_92_at_112.mp4\n",
+      "Moviepy - Building video videos/Ploumen_CO_14s_to_98_at_0.mp4.\n",
+      "MoviePy - Writing audio in Ploumen_CO_14s_to_98_at_0TEMP_MPY_wvf_snd.mp4\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                      \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MoviePy - Done.\n",
+      "Moviepy - Writing video videos/Ploumen_CO_14s_to_98_at_0.mp4\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                 \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Moviepy - Done !\n",
+      "Moviepy - video ready videos/Ploumen_CO_14s_to_98_at_0.mp4\n",
+      "Moviepy - Building video videos/Ploumen_CO_64s_to_85_at_53.mp4.\n",
+      "MoviePy - Writing audio in Ploumen_CO_64s_to_85_at_53TEMP_MPY_wvf_snd.mp4\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                      \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MoviePy - Done.\n",
+      "Moviepy - Writing video videos/Ploumen_CO_64s_to_85_at_53.mp4\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                 \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Moviepy - Done !\n",
+      "Moviepy - video ready videos/Ploumen_CO_64s_to_85_at_53.mp4\n",
+      "Part Start = 63.0, Part Cutout = 27, Part Mid = 6, Part End = 54.03\n",
+      "Moviepy - Building video videos/Ploumen_CO_63s_to_90_at_96.mp4.\n",
+      "MoviePy - Writing audio in Ploumen_CO_63s_to_90_at_96TEMP_MPY_wvf_snd.mp4\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                      \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MoviePy - Done.\n",
+      "Moviepy - Writing video videos/Ploumen_CO_63s_to_90_at_96.mp4\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                 \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Moviepy - Done !\n",
+      "Moviepy - video ready videos/Ploumen_CO_63s_to_90_at_96.mp4\n",
+      "Part Start = 63.0, Part Cutout = 33, Part Mid = 27, Part End = 27.03\n",
+      "Moviepy - Building video videos/Ploumen_CO_63s_to_96_at_123.mp4.\n",
+      "MoviePy - Writing audio in Ploumen_CO_63s_to_96_at_123TEMP_MPY_wvf_snd.mp4\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                      \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MoviePy - Done.\n",
+      "Moviepy - Writing video videos/Ploumen_CO_63s_to_96_at_123.mp4\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                 \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Moviepy - Done !\n",
+      "Moviepy - video ready videos/Ploumen_CO_63s_to_96_at_123.mp4\n"
+     ]
+    }
+   ],
+   "source": [
+    "for pair, insert_s in zip(rand_pairs, rand_insert_s):\n",
+    "    edit_change_order(\"videos/Ploumen.mp4\", start_s = pair[0], end_s = pair[1], insert_s = insert_s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "code",
    "execution_count": null,