Upload folder using huggingface_hub

.gitattributes

@@ -57,3 +57,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+k600/.processed_videos.log filter=lfs diff=lfs merge=lfs -text
+k600/annotations/train.txt filter=lfs diff=lfs merge=lfs -text
+k600/train/train/video_verification.log filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+

README.md

@@ -0,0 +1,39 @@
+# Dataset Preparation for IV2 Retraining
+
+### Downloading
+```
+> git clone https://github.com/qingy1337/kinetics-dataset.git
+> cd kinetics-dataset
+/kinetics-dataset > git pull
+/kinetics-dataset > bash ./k600_downloader.sh
+/kinetics-dataset > bash ./k600_extractor.sh
+```
+
+### Reorganizing into folders
+```
+> cd kinetics-dataset
+/kinetics-dataset > mv k600_reorganize.py ./k600/
+/kinetics-dataset > cd k600
+/kinetics-dataset/k600 > python k600_reorganize annotations/train.txt
+```
+
+### Remove un-ideal actions
+```
+/kinetics-dataset > mv removed_actions.txt ./k600/
+/kinetics-dataset > cd k600
+/kinetics-dataset/k600 > grep -v '^$' removed_actions.txt | tr '\n' '\0' | xargs -0 -I {} rm -rf "./train/train/{}/"
+```
+
+### Filter only quality videos (~30 fps, ~10 seconds in duration)
+```
+/kinetics-dataset > mv quality_check.py ./k600/
+/kinetics-dataset > cd k600
+/kinetics-dataset/k600 > python quality_check.py
+```
+
+### Generate JSON dataset (compatible with IV2 training)
+```
+/kinetics-dataset > mv generate_json_dataset.py ./k600/train/train/
+/kinetics-dataset > cd k600/train/train/
+/kinetics-dataset/k600/train/train > python generate_json_dataset.py # output saved to kinetics.json in /kinetics-dataset/k600/train/train/
+```

k600/.processed_videos.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a0640a1b783c6b273ec4adb4112aae8a0765ce72b64892c19c822d425f73c7a
+size 34388512

k600/annotations/train.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7dc172fcffa9d6706f7ed841313614faea428fc5eadef3b435dfad954b73e8f
+size 12849665

k600/k600_reorganize.py

@@ -0,0 +1,85 @@
+import os
+import shutil
+import sys
+import json
+
+def parse_txt_to_json(txt_path):
+    """Parse a .txt file into a JSON dict structure."""
+    with open(txt_path, 'r', encoding='utf-8') as f:
+        lines = [line.rstrip('\n') for line in f]
+
+    sections = []
+    current_section = []
+
+    for line in lines:
+        if line:
+            current_section.append(line)
+        else:
+            if current_section:
+                sections.append(current_section)
+                current_section = []
+
+    if current_section:
+        sections.append(current_section)
+
+    result = {}
+
+    for section in sections:
+        if not section:
+            continue
+
+        tag_line = section[0]
+        tag = tag_line.rstrip(':')
+        content = section[1:]
+
+        result[tag] = content
+
+    return result
+
+def organize_files(json_data, base_dir):
+    """Organize files into directories based on JSON data."""
+    os.makedirs(base_dir, exist_ok=True)
+
+    for key in json_data:
+        if key == "train":
+            continue
+
+        dir_path = os.path.join(base_dir, key)
+        os.makedirs(dir_path, exist_ok=True)
+
+        for file_name in json_data[key]:
+            src = os.path.join(base_dir, file_name)
+            dst = os.path.join(dir_path, file_name)
+
+            if not os.path.exists(src):
+                print(f"⚠️ File not found: {src}. Skipping.")
+                continue
+
+            try:
+                shutil.move(src, dst)
+                print(f"✅ Moved: {src} → {dst}")
+            except Exception as e:
+                print(f"❌ Error moving {src}: {e}")
+
+def main():
+    if len(sys.argv) != 2:
+        print("Usage: python organize_videos.py <input.txt>")
+        return
+
+    input_txt = sys.argv[1]
+    output_json = "structure.json"
+    base_dir = "./train"
+
+    # Step 1: Parse .txt into JSON
+    print("Parsing input file...")
+    json_data = parse_txt_to_json(input_txt)
+
+    print(f"Got {len(json_data.keys())} categories!")
+
+    # Step 2: Organize files
+    print("Organizing files into directories...")
+    organize_files(json_data, base_dir)
+    print("✅ Done!")
+
+if __name__ == "__main__":
+    main()

k600/quality_check.py

@@ -0,0 +1,279 @@
+import os
+import subprocess
+import json
+from fractions import Fraction
+import sys
+import concurrent.futures
+import time
+import threading # Added for locking the log file
+
+# --- (get_video_info function remains the same as the robust version) ---
+def get_video_info(video_path):
+    # Reuse the robust get_video_info function from the previous version
+    cmd = [
+        "ffprobe", "-v", "error", "-show_entries",
+        "format=duration:stream=codec_type,r_frame_rate",
+        "-of", "json", "-i", video_path
+    ]
+    # Increased timeout slightly, can be adjusted
+    try:
+        result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                                text=True, timeout=45, check=False) # check=False to handle errors manually
+    except subprocess.TimeoutExpired:
+        print(f"⏰ Probe timed out: {os.path.basename(video_path)}", file=sys.stderr)
+        return None # Indicate error
+
+    if result.returncode != 0:
+        error_msg = result.stderr.strip()
+        print(f"❌ Probe error ({result.returncode}): {os.path.basename(video_path)} - {error_msg}", file=sys.stderr)
+        return None # Indicate error
+
+    try:
+        data = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        print(f"❌ JSON decode error: {os.path.basename(video_path)}", file=sys.stderr)
+        return None # Indicate error
+
+    # --- Safely get duration ---
+    duration = None
+    if "format" in data and "duration" in data["format"]:
+        try:
+            duration = float(data["format"]["duration"])
+        except (ValueError, TypeError):
+            # Log error but return None as it's critical info
+            print(f"⚠️ Invalid duration format: {os.path.basename(video_path)}", file=sys.stderr)
+            return None
+    else:
+        # Log error but return None as it's critical info
+        print(f"⚠️ No duration found: {os.path.basename(video_path)}", file=sys.stderr)
+        return None
+
+    # --- Safely get FPS ---
+    fps = None
+    if "streams" in data:
+        for stream in data["streams"]:
+            if stream.get("codec_type") == "video" and "r_frame_rate" in stream:
+                fps_str = stream["r_frame_rate"]
+                if fps_str and fps_str != "0/0":
+                    try:
+                        fps = float(Fraction(*map(int, fps_str.split("/"))))
+                        break # Found valid FPS
+                    except (ValueError, ZeroDivisionError, TypeError):
+                         print(f"⚠️ Invalid FPS format '{fps_str}': {os.path.basename(video_path)}", file=sys.stderr)
+                else:
+                     print(f"⚠️ Invalid FPS value '{fps_str}': {os.path.basename(video_path)}", file=sys.stderr)
+
+    # --- Return results only if both duration and FPS are valid ---
+    if duration is not None and fps is not None:
+        return {
+            "duration": duration,
+            "fps": fps
+        }
+    elif duration is not None: # Duration found, but FPS wasn't
+         print(f"⚠️ No valid FPS found (duration was {duration:.2f}s): {os.path.basename(video_path)}", file=sys.stderr)
+         # Return None because FPS is required for filtering
+         return None
+    else: # Should be covered by earlier checks, but safety first
+        return None
+# --- (End of get_video_info) ---
+
+
+def process_video(video_path, log_file_path, log_lock):
+    """
+    Worker function to process a single video file.
+    Checks criteria, removes if needed, and logs the processed path.
+    Returns: Tuple (status_string, video_path) e.g. ("kept", "/path/to/vid.mp4")
+             status_string can be "kept", "removed", "error"
+    """
+    absolute_path = os.path.abspath(video_path)
+    base_name = os.path.basename(video_path)
+    status = "error"  # Default status
+
+    try:
+        info = get_video_info(video_path)
+
+        if not info:
+            print(f"🚫 Skipping (probe error/missing info): {base_name}")
+            try:
+                os.remove(video_path)
+                print(f"🗑️ Removed (probe error/missing info): {base_name}")
+                status = "removed"
+            except OSError as e:
+                print(f"❌ Error removing {base_name}: {e}", file=sys.stderr)
+                status = "error"
+        else:
+            duration, fps = info["duration"], info["fps"]
+            remove_reason = None
+            if duration < 9.5 or duration > 10.5:
+                remove_reason = f"Duration {duration:.2f}s"
+            elif abs(fps-30) > 1:
+                remove_reason = f"FPS {fps:.2f}"
+
+            if remove_reason:
+                try:
+                    os.remove(video_path)
+                    print(f"🗑️ Removed ({remove_reason}): {base_name}")
+                    status = "removed"
+                except OSError as e:
+                    print(f"❌ Error removing {base_name}: {e}", file=sys.stderr)
+                    status = "error"  # Failed to remove, count as error
+            else:
+                # Keep print concise for valid files during parallel runs
+                status = "kept"
+
+    except subprocess.TimeoutExpired:
+        print(f"⏰ Timeout processing: {base_name}", file=sys.stderr)
+        try:
+            os.remove(video_path)
+            print(f"🗑️ Removed (timeout): {base_name}")
+            status = "removed"
+        except OSError as e:
+            print(f"❌ Error removing {base_name}: {e}", file=sys.stderr)
+            status = "error"
+
+    except Exception as e:
+        print(f"❌ Unexpected error processing {base_name}: {e}", file=sys.stderr)
+        try:
+            os.remove(video_path)
+            print(f"🗑️ Removed (unexpected error): {base_name}")
+            status = "removed"
+        except OSError as e:
+            print(f"❌ Error removing {base_name}: {e}", file=sys.stderr)
+            status = "error"
+
+    # --- Log regardless of status to prevent reprocessing ---
+    try:
+        with log_lock:  # Ensure only one thread writes at a time
+            with open(log_file_path, 'a', encoding='utf-8') as log_f:
+                log_f.write(absolute_path + '\n')
+    except IOError as e:
+        print(f"❌ CRITICAL: Failed to write to log file {log_file_path}: {e}", file=sys.stderr)
+
+    return status, absolute_path
+
+
+def load_processed_files(log_file_path):
+    """Loads processed file paths from the log file into a set."""
+    processed = set()
+    if os.path.exists(log_file_path):
+        try:
+            with open(log_file_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    processed.add(line.strip())
+        except IOError as e:
+             print(f"⚠️ Warning: Could not read log file {log_file_path}: {e}", file=sys.stderr)
+             # Continue with an empty set, processing might repeat
+    return processed
+
+
+def filter_videos_parallel(root_dir, log_file_path=".processed_videos.log", max_workers=None):
+    """
+    Filters videos in parallel using ThreadPoolExecutor, supporting resume and progress display.
+    """
+    if max_workers is None:
+        max_workers = min(os.cpu_count() * 2, 16)
+
+    print(f"--- Starting resumable parallel video filtering in {root_dir} ---")
+    print(f"Using log file: {log_file_path}")
+    print(f"Max workers: {max_workers}")
+    start_time = time.time()
+
+    # 1. Load already processed files
+    processed_files_set = load_processed_files(log_file_path)
+    print(f"Loaded {len(processed_files_set)} paths from log file.")
+
+    # 2. Collect video file paths *not* in the processed set
+    video_paths_to_process = []
+    total_files_found = 0
+    for dirpath, _, files in os.walk(root_dir):
+        for file in files:
+            if file.lower().endswith(".mp4"):
+                total_files_found += 1
+                absolute_path = os.path.abspath(os.path.join(dirpath, file))
+                if absolute_path not in processed_files_set:
+                    video_paths_to_process.append(absolute_path)
+
+    skipped_count = total_files_found - len(video_paths_to_process)
+    total_to_process_this_run = len(video_paths_to_process) # Get total for progress %
+
+    print(f"Found {total_files_found} total MP4 files.")
+    if skipped_count > 0:
+        print(f"Skipping {skipped_count} files already processed (found in log).")
+
+    if not video_paths_to_process:
+        print("No new videos to process.")
+        return
+
+    print(f"Processing {total_to_process_this_run} new files...")
+
+    # 3. Use ThreadPoolExecutor
+    results = {"kept": 0, "removed": 0, "error": 0}
+    log_lock = threading.Lock()
+    completed_count = 0 # <-- Initialize progress counter
+    progress_update_interval = 50 # <-- How often to update the progress line
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+        future_to_path = {
+            executor.submit(process_video, path, log_file_path, log_lock): path
+            for path in video_paths_to_process
+        }
+
+        try:
+            for future in concurrent.futures.as_completed(future_to_path):
+                original_path = future_to_path[future]
+                try:
+                    status, _ = future.result()
+                    if status in results:
+                        results[status] += 1
+                    else:
+                        print(f"⚠️ Unknown status '{status}' received for {os.path.basename(original_path)}", file=sys.stderr)
+                        results["error"] += 1
+
+                    # --- Progress Update Logic ---
+                    completed_count += 1
+                    # Update progress every N files or on the very last file
+                    if completed_count % progress_update_interval == 0 or completed_count == total_to_process_this_run:
+                        percent = (completed_count / total_to_process_this_run) * 100
+                        # Use \r to return to beginning of line, pad with spaces to clear previous longer messages
+                        progress_line = f"\rProgress: {completed_count} / {total_to_process_this_run} ({percent:.1f}%) completed. "
+                        print(progress_line, end='', flush=True) # end='' prevents newline, flush forces output
+
+                except Exception as exc:
+                    print(f"\n❌ Exception for {os.path.basename(original_path)} during result retrieval: {exc}", file=sys.stderr)
+                    results["error"] += 1
+                    completed_count += 1 # Still count this as completed for progress %
+                     # Also log this path as processed
+                    try:
+                        with log_lock:
+                            with open(log_file_path, 'a', encoding='utf-8') as log_f:
+                                log_f.write(os.path.abspath(original_path) + '\n')
+                    except IOError as e:
+                         print(f"❌ CRITICAL: Failed to write to log file after exception for {original_path}: {e}", file=sys.stderr)
+
+        except KeyboardInterrupt:
+             print("\n🛑 User interrupted. Shutting down workers...")
+             sys.exit(1)
+
+    # --- Final Cleanup ---
+    print() # Print a newline to move cursor off the progress line before the summary
+
+    end_time = time.time()
+    print("\n--- Filtering Complete ---")
+    print(f"Files processed in this run: {total_to_process_this_run}")
+    print(f"  Kept:     {results['kept']}")
+    print(f"  Removed:  {results['removed']}")
+    print(f"  Errors:   {results['error']}")
+    print(f"Total files skipped (already processed): {skipped_count}")
+    print(f"Total time for this run: {end_time - start_time:.2f} seconds")
+
+
+if __name__ == "__main__":
+    target_directory = "./train/train/"
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    log_file = os.path.join(script_dir, ".processed_videos.log")
+
+    if not os.path.isdir(target_directory):
+        print(f"❌ Error: Target directory not found: {target_directory}", file=sys.stderr)
+        sys.exit(1)
+
+    filter_videos_parallel(target_directory, log_file_path=log_file)

k600/readme.md

@@ -0,0 +1,7 @@
+# Information regarding Kinetics 600:
+- Videos and annotations have been uploaded to s3://kinetics/600/.
+
+# Splits:
+- Train and Val folders contain one tar file for each class, containing the specific class videos. The name of each tar is the same as the class name. 
+- Test videos have been tared in 60 files each containing around 1000 videos. They are not split according to the specific associated class. 
+   

k600/removed_actions.txt

@@ -0,0 +1,321 @@
+adjusting glasses
+answering questions
+attending conference
+calculating
+chewing gum
+cosplaying
+counting money
+crossing eyes
+crying
+dining
+drawing
+drooling
+drumming fingers
+eating burger
+eating cake
+eating carrots
+eating chips
+eating doughnuts
+eating hotdog
+eating ice cream
+eating spaghetti
+eating watermelon
+getting a haircut
+getting a piercing
+getting a tattoo
+gospel singing in church
+head stand
+holding snake
+huddling
+hugging
+hugging baby
+ice fishing
+karaoke
+kissing
+laughing
+licking
+lifting hat
+looking at phone
+marriage proposal
+massaging back
+massaging feet
+massaging legs
+massaging neck
+massaging person's head
+news anchoring
+opening bottle
+opening door
+opening present
+opening refrigerator
+opening wine bottle
+packing
+petting animal
+petting cat
+photocopying
+pinching
+poking bellybutton
+presenting weather forecast
+putting in contact lenses
+putting on eyeliner
+putting on foundation
+putting on lipstick
+putting on mascara
+putting on shoes
+reading book
+reading newspaper
+roasting marshmallows
+shining flashlight
+shopping
+sign language interpreting
+singing
+sipping cup
+sleeping
+smelling feet
+smoking
+smoking hookah
+smoking pipe
+staring
+sticking tongue out
+stretching arm
+stretching leg
+sucking lolly
+sword swallowing
+talking on cell phone
+tapping guitar
+tapping pen
+tasting beer
+tasting food
+tasting wine
+testifying
+texting
+threading needle
+tickling
+tiptoeing
+tossing coin
+twiddling fingers
+tying bow tie
+tying knot
+tying necktie
+tying shoe laces
+unboxing
+using a microscope
+using atm
+using inhaler
+using puppets
+using remote controller
+visiting the zoo
+waiting in line
+waking up
+watching tv
+whistling
+writing
+yawning
+yoga
+applying cream
+arranging flowers
+assembling bicycle
+assembling computer
+baking cookies
+bandaging
+barbequing
+bathing dog
+blowdrying hair
+blowing nose
+bookbinding
+bottling
+braiding hair
+breading or breadcrumbing
+brush painting
+brushing hair
+brushing teeth
+building cabinet
+building lego
+building sandcastle
+building shed
+card stacking
+carving ice
+carving pumpkin
+changing gear in car
+changing oil
+changing wheel
+checking tires
+clay pottery making
+cleaning gutters
+cleaning pool
+cleaning shoes
+cleaning toilet
+cleaning windows
+coloring in
+combing hair
+cooking egg
+cooking on campfire
+cooking sausages
+cooking scallops
+cracking back
+cracking knuckles
+cracking neck
+curling hair
+cutting apple
+cutting nails
+cutting orange
+cutting pineapple
+cutting watermelon
+decorating the christmas tree
+delivering mail
+directing traffic
+docking boat
+doing jigsaw puzzle
+doing laundry
+doing nails
+driving car
+driving tractor
+dyeing eyebrows
+dyeing hair
+egg hunting
+embroidering
+feeding birds
+feeding fish
+feeding goats
+fixing bicycle
+fixing hair
+fly tying
+folding clothes
+folding napkins
+folding paper
+frying vegetables
+geocaching
+giving or receiving award
+grinding meat
+grooming dog
+grooming horse
+hand washing clothes
+home roasting coffee
+installing carpet
+ironing
+ironing hair
+jaywalking
+knitting
+laying bricks
+laying concrete
+laying stone
+laying tiles
+leatherworking
+lighting fire
+lock picking
+making a cake
+making a sandwich
+making balloon shapes
+making bubbles
+making cheese
+making jewelry
+making paper aeroplanes
+making pizza
+making snowman
+making sushi
+making tea
+making the bed
+milking cow
+mopping floor
+mushroom foraging
+needle felting
+peeling apples
+peeling potatoes
+picking fruit
+plastering
+playing blackjack
+playing chess
+playing controller
+playing dominoes
+playing marbles
+playing monopoly
+playing pinball
+playing poker
+playing rubiks cube
+playing scrabble
+playing with trains
+polishing metal
+pouring beer
+preparing salad
+pumping gas
+recording music
+repairing puncture
+riding snow blower
+ripping paper
+roasting pig
+rolling pastry
+sanding floor
+sausage making
+scrambling eggs
+scrapbooking
+scrubbing face
+separating eggs
+setting table
+sewing
+shaping bread dough
+sharpening knives
+sharpening pencil
+shaving head
+shaving legs
+shining shoes
+shucking oysters
+shuffling cards
+shuffling feet
+snowmobiling
+sweeping floor
+tie dying
+training dog
+trimming or shaving beard
+trimming shrubs
+trimming trees
+using a paint roller
+using a power drill
+using a wrench
+using bagging machine
+using circular saw
+vacuuming floor
+walking the dog
+washing dishes
+washing feet
+washing hair
+washing hands
+watering plants
+waxing back
+waxing chest
+waxing eyebrows
+waxing legs
+weaving basket
+weaving fabric
+welding
+wood burning
+wrapping present
+yarn spinning
+acting in play
+applauding
+auctioning
+blowing glass
+busking
+celebrating
+historical reenactment
+playing accordion
+playing bagpipes
+playing bass guitar
+playing cello
+playing clarinet
+playing didgeridoo
+playing flute
+playing guitar
+playing hand clapping games
+playing harmonica
+playing harp
+playing keyboard
+playing lute
+playing ocarina
+playing organ
+playing pan pipes
+playing piano
+playing recorder
+playing saxophone
+playing trombone
+playing trumpet
+playing ukulele
+playing violin

k600/test/.gitattributes

@@ -0,0 +1,59 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

k600/test/.ipynb_checkpoints/kinetics-test-checkpoint.json

@@ -0,0 +1,302 @@
+[
+  {
+    "video": "1.mp4",
+    "caption": "A person makes a big splash in the pool."
+  },
+  {
+    "video": "2.mp4",
+    "caption": "A dog catches a frisbee midair."
+  },
+  {
+    "video": "3.mp4",
+    "caption": "A whale jumps out of the water."
+  },
+  {
+    "video": "4.mp4",
+    "caption": "A person falls off the bike."
+  },
+  {
+    "video": "5.mp4",
+    "caption": "A person jumps over the hurdle."
+  },
+  {
+    "video": "6.mp4",
+    "caption": "A person performs a backflip."
+  },
+  {
+    "video": "7.mp4",
+    "caption": "A person jumps over the hurdle."
+  },
+  {
+    "video": "8.mp4",
+    "caption": "A dog catching a frisbee midair."
+  },
+  {
+    "video": "9.mp4",
+    "caption": "A dog jumps through a yellow hoop."
+  },
+  {
+    "video": "10.mp4",
+    "caption": "A horse jumping over the hurdle."
+  },
+  {
+    "video": "11.mp4",
+    "caption": "An eagle catching a fish from the water."
+  },
+  {
+    "video": "12.mp4",
+    "caption": "A person performs a backflip."
+  },
+  {
+    "video": "13.mp4",
+    "caption": "A person performs a backflip."
+  },
+  {
+    "video": "14.mp4",
+    "caption": "A dog catches a frisbee midair."
+  },
+  {
+    "video": "15.mp4",
+    "caption": "A cup shatters on the ground."
+  },
+  {
+    "video": "16.mp4",
+    "caption": "A person performs a backflip."
+  },
+  {
+    "video": "17.mp4",
+    "caption": "A person falls off the bike."
+  },
+  {
+    "video": "18.mp4",
+    "caption": "A person performs a backflip."
+  },
+  {
+    "video": "19.mp4",
+    "caption": "A person performs a backflip."
+  },
+  {
+    "video": "20.mp4",
+    "caption": "A dog catches a frisbee midair."
+  },
+  {
+    "video": "21.mp4",
+    "caption": "A basketball goes in the hoop."
+  },
+  {
+    "video": "22.mp4",
+    "caption": "A balloon pops."
+  },
+  {
+    "video": "23.mp4",
+    "caption": "A person falls off the bike."
+  },
+  {
+    "video": "24.mp4",
+    "caption": "A person falls off the chair."
+  },
+  {
+    "video": "25.mp4",
+    "caption": "A dog catches a red frisbee in mouth."
+  },
+  {
+    "video": "26.mp4",
+    "caption": "A person falls off the bike."
+  },
+  {
+    "video": "27.mp4",
+    "caption": "A person jumps over the hurdle."
+  },
+  {
+    "video": "28.mp4",
+    "caption": "A person jumps over the fence."
+  },
+  {
+    "video": "29.mp4",
+    "caption": "A person performs a backflip."
+  },
+  {
+    "video": "30.mp4",
+    "caption": "A person jumps over a hurdle."
+  },
+  {
+    "video": "31.mp4",
+    "caption": "A person performs a backflip."
+  },
+  {
+    "video": "32.mp4",
+    "caption": "A horse jumps over the hurdle."
+  },
+  {
+    "video": "33.mp4",
+    "caption": "A person jumps over the hurdle."
+  },
+  {
+    "video": "34.mp4",
+    "caption": "A person jumps over a hurdle."
+  },
+  {
+    "video": "35.mp4",
+    "caption": "A person performs a backflip."
+  },
+  {
+    "video": "36.mp4",
+    "caption": "A dog catches a frisbee midair."
+  },
+  {
+    "video": "37.mp4",
+    "caption": "A person performs a backflip."
+  },
+  {
+    "video": "38.mp4",
+    "caption": "A horse jumps over a hurdle."
+  },
+  {
+    "video": "39.mp4",
+    "caption": "A basketball goes in the hoop."
+  },
+  {
+    "video": "40.mp4",
+    "caption": "A person jumps over the hurdle."
+  },
+  {
+    "video": "41.mp4",
+    "caption": "A cup shatters and spills coffee."
+  },
+  {
+    "video": "42.mp4",
+    "caption": "A person dunks a basketball."
+  },
+  {
+    "video": "43.mp4",
+    "caption": "A dog catches a frisbee in air."
+  },
+  {
+    "video": "44.mp4",
+    "caption": "A glass cup shatters."
+  },
+  {
+    "video": "45.mp4",
+    "caption": "A whale jumps out of water."
+  },
+  {
+    "video": "46.mp4",
+    "caption": "A person performs a backflip."
+  },
+  {
+    "video": "47.mp4",
+    "caption": "A plate shatters on the ground."
+  },
+  {
+    "video": "48.mp4",
+    "caption": "An eagle catches a fish from the water."
+  },
+  {
+    "video": "49.mp4",
+    "caption": "A person falls off the bike."
+  },
+  {
+    "video": "50.mp4",
+    "caption": "A horse jumps over the hurdle."
+  },
+  {
+    "video": "51.mp4",
+    "caption": "A person falls off the bike."
+  },
+  {
+    "video": "52.mp4",
+    "caption": "A person falls off the bike."
+  },
+  {
+    "video": "53.mp4",
+    "caption": "A dog catches the frisbee midair."
+  },
+  {
+    "video": "54.mp4",
+    "caption": "A person performs a backflip."
+  },
+  {
+    "video": "55.mp4",
+    "caption": "A tennis racket hits the green ball."
+  },
+  {
+    "video": "56.mp4",
+    "caption": "A person jumps over the hurdle."
+  },
+  {
+    "video": "57.mp4",
+    "caption": "A person jumps over the hurdle."
+  },
+  {
+    "video": "58.mp4",
+    "caption": "A person jumps over the hurdle."
+  },
+  {
+    "video": "59.mp4",
+    "caption": "A kid falls down onto the ground."
+  },
+  {
+    "video": "60.mp4",
+    "caption": "A dog jumping through the yellow hoop."
+  },
+  {
+    "video": "61.mp4",
+    "caption": "A dog catches a frisbee midair."
+  },
+  {
+    "video": "62.mp4",
+    "caption": "A horse jumps over the hurdle."
+  },
+  {
+    "video": "63.mp4",
+    "caption": "A whale jumps out of the water."
+  },
+  {
+    "video": "64.mp4",
+    "caption": "A person performs a backflip."
+  },
+  {
+    "video": "65.mp4",
+    "caption": "A whale jumps out of water."
+  },
+  {
+    "video": "66.mp4",
+    "caption": "A man falls on the ground."
+  },
+  {
+    "video": "67.mp4",
+    "caption": "A person falls off the bike."
+  },
+  {
+    "video": "68.mp4",
+    "caption": "A person performs a backflip."
+  },
+  {
+    "video": "69.mp4",
+    "caption": "A dog catches a frisbee midair."
+  },
+  {
+    "video": "70.mp4",
+    "caption": "A person jumps over the hurdle."
+  },
+  {
+    "video": "71.mp4",
+    "caption": "A glass cup shatters."
+  },
+  {
+    "video": "72.mp4",
+    "caption": "A person falls off the bike."
+  },
+  {
+    "video": "73.mp4",
+    "caption": "A whale jumps out of water."
+  },
+  {
+    "video": "74.mp4",
+    "caption": "A bird catches a fish from the water."
+  },
+  {
+    "video": "75.mp4",
+    "caption": "A person falls off the bike."
+  }
+]

k600/test/1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:556d3ea06e303e4331ae189bd8b5e2e98da810be832bbd5fff66c25dbe978911
+size 3487678

k600/test/10.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc7bd6c1086fb473714ef939dfb487c4f55d9cb8379d1da0e8531c755d0e90f3
+size 530634

k600/test/11.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70cad89e93072c1f454eb4208293a085d10950f1ee27e3718ef96727106c20db
+size 1302854

k600/test/12.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ddcd3e55d626756fc240b4f81b970256fdc2ed7e107ce39e9694e164719d16e2
+size 308942

k600/test/13.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd36131b69895de4b6a89fa3abc6667414fe002d118bf20a0275a6e433bb7a39
+size 1753026

k600/test/14.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f0afaf6a7f88c238e17cbb42b4232ed4f533b6a77b26024a4b1d956f6fdf3f12
+size 860720

k600/test/15.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b99db3ba85b477d30a0daa57f2731e90ae5fb01f5e6b9d1749e71397a91f8574
+size 245577

k600/test/16.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12fd746d97ccd033536a2b940fc49b348dea82b20066d14f56f4539dfe35b2cb
+size 1096722

k600/test/17.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:153ceb72ae1e9b82005d8d79bd6abafb07d5e9f9522b21ae3144481aa9ad666b
+size 2503904

k600/test/18.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:432d56d96928efc3d3af8d1f3ce21fd8b2583e13659b5ea40b9170ae5a842104
+size 2077345

k600/test/19.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f304e9a7175f7aae2d8c37001518999894c0379d0e27a5c7bbff9cd3c30af85
+size 1351539

k600/test/2.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:662d013e3dac6d9bcc97aa46e38d942af64885571bbb571b6507b5e90a108566
+size 670501

k600/test/20.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:35af6f5a2227486c0b15edf662e84a58bd2d3591937b226ca92d16e29e815155
+size 563751

k600/test/21.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4e541bfeaf80518f72df1514b28378aedbb0eb584537093e722ab066e69bd4c8
+size 983249

k600/test/22.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cde096f1e7e744d3f751552acd354c93167f41f9c2c25d7c17a3b0914e261ed6
+size 402300

k600/test/23.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72b351347736da5f04439c4f3bdadd7ad741a42b1c0ae73eca27f8e3d1659f37
+size 437824

k600/test/24.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1514d9b4465d95a2ba568873534155dd2a00ff72042fc7c31bb87f9e51fe9b96
+size 771814

k600/test/25.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:385fac334e3a7cd364cf54025a0e7c8ff38c845fe6d397efd405cd1b930e8f7d
+size 482728

k600/test/26.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7e7ad35887034ad16917b6a33bed123b377ca9f5bb8f0a4f81426f59082f69a
+size 698853

k600/test/27.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:695b408dbeb7fa41921326057153b39b6d85d9ebe397470c6b778fe36471057e
+size 2390398

k600/test/28.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f3c86edfb7005a78fc5d60d596517a8b42fec469478ef48cadb4d6fd795154f
+size 251730

k600/test/29.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1a69d2f739811f15aa745180b9437c5254fe84933ba5845facc5b1375bf0e3c
+size 2282985

k600/test/3.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7395f220b8681a776203a82ffd8ff5c877a40aced862b085bc561f5156542d1a
+size 409466

k600/test/30.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:641458ed04cb777df0ccedb5899313cb2e1c8f647eeced4b802d076a9c10ff20
+size 4589233

k600/test/31.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e14e04bc709554d22734689bac048f4a9e566bf088b08cb25f31c7fc5078be2
+size 404640

k600/test/32.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:620b1c497f284719e46c069ebf2a57ed0f52e965e20882d04fc7de53b032efd7
+size 127751

k600/test/33.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:03c6e0ff606f5411981bbfe597ca40dfca84cb7f4454fba31720bbd13a495002
+size 1978863

k600/test/34.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d29fafd2b4c33b64f50d5879b743f8000a6064bb571a26955a734c5a5c780ac
+size 230648

k600/test/35.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da5df51a1029459ceb88ed547afe9c1a7ed9f8f2bdc0bff2be9b10d3909fef04
+size 339591

k600/test/36.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9fe5c0a2eeeacb3a0789400ba43951f4b85434263b8666bcccdd432c697570a2
+size 131594

k600/test/37.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9ad25888a3488f7c186cb3dd25419c0dcae3e1fa1fa91c62e1ced4509d40a3b2
+size 1365683

k600/test/38.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c55878f1d94a64e397376ab59338a440576c1fcebe85f67ab0731a6719d59c9e
+size 1487103

k600/test/39.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:927162bf25aeadee80d53112095668d913983ddb23965ae5ff45a4a21d3ea3eb
+size 283420

k600/test/4.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7d4eb7ad173abea528fa8a5f8073518132224087b2d487510a7c6af592e0efc
+size 481399

k600/test/40.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ab65ac1f8532dba12553bfd50a6504d4896a7bdc0f486a57ef9794124fcfe47
+size 1584326

k600/test/41.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:03020c9f03f5176b86ed8eee9c2c03af363166d1ff9c103e64bf1fea993d3c17
+size 342665

k600/test/42.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b94f076726e41ffed16c512b094b7b481c138c4ecfb645c1aecf2259ee07b150
+size 4118785

k600/test/43.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51343ddc04f8d5ee72369ae2a07cfd1d11e89cca2cb90df853c7c1c5daea4a21
+size 162484

k600/test/44.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:01153f6d80ef1abfc81d9386c120da00d087d559f5689dc501a093552192438a
+size 738247