Upload folder using huggingface_hub

Annotations.zip

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

JPEGImages.zip

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

README.md

@@ -1,3 +1,49 @@
----
-license: cc-by-nc-4.0
----
+# FaVOS
+
+## Download
+
+```bash
+huggingface-cli download FaVOSsubmission/FaVOS \
+  --repo-type dataset \
+  --include "JPEGImages.zip" \
+  --include "Annotations.zip" \
+  --include "favos-20.txt" \
+  --include "favos-40.txt" \
+  --local-dir data
+
+unzip -q data/JPEGImages.zip -d data
+unzip -q data/Annotations.zip -d data
+```
+
+## J&F_v Evaluation
+
+Assume the dataset is downloaded under `FaVOS/data/`:
+
+```text
+FaVOS/data/
+  JPEGImages/
+  Annotations/
+  favos-20.txt
+  favos-40.txt
+```
+
+Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+Evaluate predictions:
+
+```bash
+python eval_jnf_v.py \
+  --pred-root /path/to/predictions \
+  --output-dir results/jf_v
+```
+
+Prediction masks should be indexed PNG files in one of these layouts:
+
+```text
+/path/to/predictions/Annotations/<video_id>/<frame>.png
+/path/to/predictions/<video_id>/<frame>.png
+```

eval_jnf_v.py

@@ -0,0 +1,391 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import os
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+from scipy.ndimage import distance_transform_edt
+from tqdm.auto import tqdm
+
+
+DATASET_ROOT = Path("data")
+SPLITS = ("favos-20", "favos-40")
+OUTPUT_DIR = Path("results/jf_v")
+BOUND_TH = 0.008
+WORKERS = min(8, os.cpu_count() or 1)
+
+
+@dataclass(frozen=True)
+class JNFVResult:
+    j_v: float
+    f_v: float
+    jnf_v: float
+    precision_v: float
+    recall_v: float
+    intersection_volume: int
+    union_volume: int
+    pred_boundary_voxels: int
+    gt_boundary_voxels: int
+
+
+@dataclass(frozen=True)
+class ObjectResult:
+    split: str
+    video_id: str
+    object_id: int
+    num_frames: int
+    j_v: float
+    f_v: float
+    jnf_v: float
+    precision_v: float
+    recall_v: float
+    intersection_volume: int
+    union_volume: int
+    pred_boundary_voxels: int
+    gt_boundary_voxels: int
+
+
+@dataclass(frozen=True)
+class VideoResult:
+    split: str
+    video_id: str
+    num_objects: int
+    num_frames: int
+    j_v: float
+    f_v: float
+    jnf_v: float
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Evaluate J&F_v on FaVOS indexed-PNG predictions. "
+            "The dataset is expected under data/."
+        )
+    )
+    parser.add_argument(
+        "--pred-root",
+        type=Path,
+        required=True,
+        help="Prediction root. Accepts either <root>/Annotations/<video_id> or <root>/<video_id>.",
+    )
+    parser.add_argument("--output-dir", type=Path, default=OUTPUT_DIR)
+    return parser.parse_args()
+
+
+def numeric_pngs(path: Path) -> list[Path]:
+    return sorted(
+        [p for p in path.glob("*.png") if p.is_file() and not p.name.startswith("._")],
+        key=lambda p: int(p.stem),
+    )
+
+
+def load_label(path: Path) -> np.ndarray:
+    with Image.open(path) as image:
+        return np.asarray(image, dtype=np.uint8)
+
+
+def read_split(dataset_root: Path, split: str) -> list[str]:
+    path = dataset_root / f"{split}.txt"
+    if not path.is_file():
+        raise FileNotFoundError(f"Missing split file: {path}")
+    ids = [line.strip() for line in path.read_text(encoding="utf-8").splitlines()]
+    return list(dict.fromkeys(video_id for video_id in ids if video_id and not video_id.startswith("#")))
+
+
+def resolve_pred_root(pred_root: Path) -> Path:
+    annotations = pred_root / "Annotations"
+    return annotations if annotations.is_dir() else pred_root
+
+
+def load_video(gt_dir: Path, pred_dir: Path) -> tuple[np.ndarray, np.ndarray]:
+    gt_paths = numeric_pngs(gt_dir)
+    pred_by_name = {p.name: p for p in numeric_pngs(pred_dir)}
+    if not gt_paths:
+        raise FileNotFoundError(f"No GT masks found in {gt_dir}")
+
+    missing = [p.name for p in gt_paths if p.name not in pred_by_name]
+    if missing:
+        raise FileNotFoundError(f"Missing {len(missing)} prediction masks in {pred_dir}: {missing[:5]}")
+
+    gt_paths = gt_paths[1:]
+    if not gt_paths:
+        raise ValueError(f"No evaluation frames found in {gt_dir}")
+
+    gt = np.stack([load_label(path) for path in gt_paths], axis=0)
+    pred = np.stack([load_label(pred_by_name[path.name]) for path in gt_paths], axis=0)
+    if gt.shape != pred.shape:
+        raise ValueError(f"Shape mismatch for {gt_dir.name}: GT {gt.shape}, pred {pred.shape}")
+    return gt, pred
+
+
+def as_bool_volume(volume: np.ndarray) -> np.ndarray:
+    if volume.ndim != 3:
+        raise ValueError(f"Expected (T,H,W), got {volume.shape}")
+    return volume.astype(bool)
+
+
+def mean_visible_area(volume: np.ndarray) -> float:
+    areas = np.sum(volume, axis=(1, 2), dtype=np.int64)
+    visible = areas[areas > 0]
+    return float(np.mean(visible)) if visible.size else 0.0
+
+
+def spatial_radius(shape_2d: tuple[int, int], object_area: float, bound_th: float) -> int:
+    radius = bound_th if bound_th >= 1 else bound_th * np.linalg.norm(shape_2d)
+    if object_area > 0:
+        radius = min(radius, 0.1 * np.sqrt(object_area))
+    return max(int(np.ceil(radius)), 0)
+
+
+def boundary_volume(volume: np.ndarray) -> np.ndarray:
+    volume = volume.astype(bool)
+    boundary = np.zeros_like(volume, dtype=bool)
+    for dt in (0, 1):
+        for dy in (0, 1):
+            for dx in (0, 1):
+                if dt == 0 and dy == 0 and dx == 0:
+                    continue
+                src = (
+                    slice(0, volume.shape[0] - dt),
+                    slice(0, volume.shape[1] - dy),
+                    slice(0, volume.shape[2] - dx),
+                )
+                dst = (
+                    slice(dt, volume.shape[0]),
+                    slice(dy, volume.shape[1]),
+                    slice(dx, volume.shape[2]),
+                )
+                boundary[src] |= volume[src] ^ volume[dst]
+    return boundary
+
+
+def count_matches(source_boundary: np.ndarray, target_boundaries: np.ndarray, radius: int) -> int:
+    if not np.any(source_boundary) or not np.any(target_boundaries):
+        return 0
+    matched = np.zeros_like(source_boundary, dtype=bool)
+    for target in target_boundaries:
+        if np.any(target):
+            matched |= distance_transform_edt(~target) <= radius
+    return int(np.sum(source_boundary & matched))
+
+
+def compute_jnf_v(
+    gt_volume: np.ndarray,
+    pred_volume: np.ndarray,
+) -> JNFVResult:
+    gt = as_bool_volume(gt_volume)
+    pred = as_bool_volume(pred_volume)
+    if gt.shape != pred.shape:
+        raise ValueError(f"Shape mismatch: GT {gt.shape}, pred {pred.shape}")
+
+    intersections = np.sum(gt & pred, axis=(1, 2), dtype=np.int64)
+    unions = np.sum(gt | pred, axis=(1, 2), dtype=np.int64)
+    total_intersection = int(np.sum(intersections, dtype=np.int64))
+    total_union = int(np.sum(unions, dtype=np.int64))
+    if total_union == 0:
+        j_v = 1.0
+    else:
+        nonempty = unions > 0
+        j_v = float(np.sum((unions[nonempty] / total_union) * (intersections[nonempty] / unions[nonempty])))
+
+    radius = spatial_radius(gt.shape[1:], mean_visible_area(gt), BOUND_TH)
+    gt_boundary = boundary_volume(gt)
+    pred_boundary = boundary_volume(pred)
+
+    matched_pred = 0
+    matched_gt = 0
+    total_pred_boundary = 0
+    total_gt_boundary = 0
+    for t in range(gt.shape[0]):
+        gt_t = gt_boundary[t]
+        pred_t = pred_boundary[t]
+        n_gt = int(np.sum(gt_t))
+        n_pred = int(np.sum(pred_t))
+        total_gt_boundary += n_gt
+        total_pred_boundary += n_pred
+        if n_gt:
+            matched_gt += count_matches(gt_t, pred_boundary[t : t + 1], radius)
+        if n_pred:
+            matched_pred += count_matches(pred_t, gt_boundary[t : t + 1], radius)
+
+    if total_pred_boundary == 0 and total_gt_boundary == 0:
+        precision = 1.0
+        recall = 1.0
+    elif total_pred_boundary == 0:
+        precision = 1.0
+        recall = 0.0
+    elif total_gt_boundary == 0:
+        precision = 0.0
+        recall = 1.0
+    else:
+        precision = float(matched_pred / total_pred_boundary)
+        recall = float(matched_gt / total_gt_boundary)
+    f_v = 0.0 if precision + recall == 0 else float(2.0 * precision * recall / (precision + recall))
+
+    return JNFVResult(
+        j_v=j_v,
+        f_v=f_v,
+        jnf_v=(j_v + f_v) / 2.0,
+        precision_v=precision,
+        recall_v=recall,
+        intersection_volume=total_intersection,
+        union_volume=total_union,
+        pred_boundary_voxels=total_pred_boundary,
+        gt_boundary_voxels=total_gt_boundary,
+    )
+
+
+def evaluate_video(task: tuple[str, Path, Path]) -> dict[str, object]:
+    video_id, gt_root, pred_root = task
+    try:
+        gt, pred = load_video(gt_root / video_id, pred_root / video_id)
+        object_ids = [int(v) for v in np.unique(gt) if int(v) != 0]
+        if not object_ids:
+            raise ValueError(f"No foreground objects in {gt_root / video_id}")
+
+        objects: list[ObjectResult] = []
+        for object_id in object_ids:
+            pred_obj = pred == object_id
+            result = compute_jnf_v(
+                gt == object_id,
+                pred_obj,
+            )
+            objects.append(
+                ObjectResult(
+                    split="all",
+                    video_id=video_id,
+                    object_id=object_id,
+                    num_frames=int(gt.shape[0]),
+                    **asdict(result),
+                )
+            )
+
+        video = VideoResult(
+            split="all",
+            video_id=video_id,
+            num_objects=len(objects),
+            num_frames=int(gt.shape[0]),
+            j_v=float(np.mean([row.j_v for row in objects])),
+            f_v=float(np.mean([row.f_v for row in objects])),
+            jnf_v=float(np.mean([row.jnf_v for row in objects])),
+        )
+        return {"video_id": video_id, "objects": objects, "video": video, "error": None}
+    except Exception as exc:
+        return {"video_id": video_id, "objects": [], "video": None, "error": {"video_id": video_id, "error": str(exc)}}
+
+
+def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
+    if not rows:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def summarize(split: str, objects: list[ObjectResult], videos: list[VideoResult]) -> dict[str, object]:
+    return {
+        "split": split,
+        "num_videos": len(videos),
+        "num_objects": len(objects),
+        "num_object_frames": int(sum(row.num_frames for row in objects)),
+        "j_v": float(np.mean([row.j_v for row in objects])) if objects else 0.0,
+        "f_v": float(np.mean([row.f_v for row in objects])) if objects else 0.0,
+        "jnf_v": float(np.mean([row.jnf_v for row in objects])) if objects else 0.0,
+        "per_video_j_v": float(np.mean([row.j_v for row in videos])) if videos else 0.0,
+        "per_video_f_v": float(np.mean([row.f_v for row in videos])) if videos else 0.0,
+        "per_video_jnf_v": float(np.mean([row.jnf_v for row in videos])) if videos else 0.0,
+    }
+
+
+def main() -> int:
+    args = parse_args()
+    dataset_root = DATASET_ROOT
+    gt_root = dataset_root / "Annotations"
+    pred_root = resolve_pred_root(args.pred_root)
+    if not gt_root.is_dir():
+        raise FileNotFoundError(f"Missing GT root: {gt_root}")
+    if not pred_root.is_dir():
+        raise FileNotFoundError(f"Missing prediction root: {pred_root}")
+
+    splits = {split: read_split(dataset_root, split) for split in SPLITS}
+    unique_ids = sorted({video_id for ids in splits.values() for video_id in ids})
+    if not unique_ids:
+        raise ValueError("No videos selected for evaluation.")
+
+    tasks = [
+        (
+            video_id,
+            gt_root,
+            pred_root,
+        )
+        for video_id in unique_ids
+    ]
+
+    objects_by_video: dict[str, list[ObjectResult]] = {}
+    videos_by_video: dict[str, VideoResult] = {}
+    max_workers = min(max(WORKERS, 1), len(tasks))
+
+    if max_workers == 1:
+        iterator = tqdm(tasks, desc="Evaluating", unit="video")
+        for task in iterator:
+            result = evaluate_video(task)
+            if result["error"] is not None:
+                raise RuntimeError(f"Failed evaluating {result['video_id']}: {result['error']['error']}")
+            objects_by_video[result["video_id"]] = result["objects"]
+            videos_by_video[result["video_id"]] = result["video"]
+    else:
+        with ProcessPoolExecutor(max_workers=max_workers) as executor:
+            futures = [executor.submit(evaluate_video, task) for task in tasks]
+            iterator = as_completed(futures)
+            iterator = tqdm(iterator, total=len(futures), desc="Evaluating", unit="video")
+            for future in iterator:
+                result = future.result()
+                if result["error"] is not None:
+                    raise RuntimeError(f"Failed evaluating {result['video_id']}: {result['error']['error']}")
+                objects_by_video[result["video_id"]] = result["objects"]
+                videos_by_video[result["video_id"]] = result["video"]
+
+    all_objects: list[ObjectResult] = []
+    all_videos: list[VideoResult] = []
+    summaries: dict[str, dict[str, object]] = {}
+    for split, ids in splits.items():
+        split_objects: list[ObjectResult] = []
+        split_videos: list[VideoResult] = []
+        for video_id in ids:
+            for row in objects_by_video.get(video_id, []):
+                split_objects.append(ObjectResult(split=split, **{k: v for k, v in asdict(row).items() if k != "split"}))
+            if video_id in videos_by_video:
+                row = videos_by_video[video_id]
+                split_videos.append(VideoResult(split=split, **{k: v for k, v in asdict(row).items() if k != "split"}))
+        all_objects.extend(split_objects)
+        all_videos.extend(split_videos)
+        summaries[split] = summarize(split, split_objects, split_videos)
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    write_csv(args.output_dir / "per_object_jf_v.csv", [asdict(row) for row in all_objects])
+    write_csv(args.output_dir / "per_video_jf_v.csv", [asdict(row) for row in all_videos])
+    summary = {
+        "splits": summaries,
+    }
+    (args.output_dir / "summary.json").write_text(json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+    for split, row in summaries.items():
+        print(
+            f"{split}: videos={row['num_videos']} objects={row['num_objects']} "
+            f"Jv={row['j_v']:.6f} Fv={row['f_v']:.6f} J&F_v={row['jnf_v']:.6f}"
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

favos-20.txt

@@ -0,0 +1,100 @@
+510ca352de434ce047880f09b49d4fb1
+79e6485ce65bcff58059665348851c3a
+423e5ffc5bced29d9ad33aae06f672fd
+d7cc905aff0a9c4337ae23def1152f62
+1763fc52bde3718770285f2f105a11cb
+d4edc6d59d1273f8c57041a073f8025a
+ff1222464c9dca5e29dd249e70217051
+e628894ab73cdb0976cfb28900459f85
+8274ee49efaaeeb44fecee4c4c07e4df
+2f4cb6ffb406a4dc10074e1138fef7b9
+c23cc5bf4c7c04233ad9a3e8f137c21b
+bee9a94d93e00c24576985f359af91e7
+00c92e9a7ec54d0c3e857c157103f99c
+153b704766c803680be1069f23866c0d
+1e5d0cc1ba9e55408e46837424b288a2
+0a6f61f31a7c26f6218bc88c089efad6
+5f5167989358d014efc38ccc795b5b06
+7e833a447115188d4eb75a47cb199a93
+0ee9797f6ee00377c04fc8641e6c34b9
+85fe83123ac1f1fda088cc84d06407e7
+38da9241ba734fc0c459618c7486eb89
+25957feda7d3739aaf14c005feee1ef4
+c87e2a1aecabf67710f8da466f590119
+0dde0554b6c9fed87fab441945b174cc
+f3227d95d567045a0756d262af5f8810
+9ebd5ab53f3fdc74e9b5779d7d33a0bc
+acdf7be22f237731a575509e0f8bd562
+d3eae82414483d0ed4b307c2ed9308dc
+34267d0c93e49c569ba8385af38d6c3c
+6d1b4a7a8b9e62ecbd0f059aba830fed
+8cc0996707f3c98847d6accd398cae4a
+c7efe295f111c89c5446c1896635c56f
+dd3faeadfc531bb409591733db39e91e
+7d7932c43d06cf7009bc77b5fb5887a7
+a2269e73813affec4f49c6febd85f93d
+b82baa030353a7072908f27342f9de0e
+fceb1e96b99293ca080b76fd678b4b6b
+85883f9eb511a404cbb1db27297b21e7
+979098af4c56441a25dadecbee5e69e2
+c80d646e03734936754a6ddbb458afc3
+da0940b2ccd52aad70867952bb3cf6e6
+7bacee56c447ffab952faa788cbd5c17
+9fc9ab7f048a1340fdd97ae78b8f2806
+19c78585aa31b4d07a914de97a7e4b66
+64e63ff853a8a4543e72538c43a952ac
+51ba04e5ce9ac6b0dbd733701b390e2b
+96aa657b5e118fa1968f4cc5193a336f
+bfbf0477617337d3eaff9b7fcf3ebd68
+e61f89e98345af7a873f262ec554ca56
+9f29fb0d57673bf3980d991555ea5220
+50b6658d8d2710fa42ccda4386198584
+90505bb788b5fedc7d0a01e7fd0df4d0
+d8e3a1ee59b4a01d9935fcf74897a993
+de24a6d99245d646a211d8238766f4ef
+7a7e24b51fc6d4b6d81e6f95eb279c37
+5e1e500cac40625eb6838427411a5708
+990b0902db2522a6b70391283b69d1c5
+1b3910140cae94b1c8ff9b50496faee2
+2ef88ebd235b393d723838f59856821e
+995c7b782b8cdf7eb7384e4817185d2e
+3b376c82b85ff4285a4722ca312f84d8
+270d5b7afd61336af86b020d20deb765
+ee210b1ce55ef31ef383aebda8a4341b
+2ee8130f4ea648a3484b9e9e2b55637c
+61c8d0df22325001b0afba3fabcdf882
+e5603ce1b13cc4ebc56afe013ee3c0c8
+7e2020fb5885e05fd13d4ad2e932550b
+d226434439d033ee9fbd501b6cc4d5f9
+83c3e21fba30c40d5f28f33b056ba374
+3cd95d40559fa81acba263bd77e59da6
+f3598c3a5b2d094cb3fcf2dbced80e52
+3c36b6c7d6d6120f496666706be114b1
+8c8f9d28ca4f35048a8b1d610150efc5
+72cb7a00ca57a18c4e3fb852b78c33ef
+d7cb2e252b48cb82c329c64b043b0421
+dfbac4e6a082e805468529a391e2b594
+4538bc2348c23748c7146071ae7b48b3
+58fb9ec9133eb0f56ccb1d0f4fe754d4
+05385ba87b8eb13f760700e31dd6f95a
+5025e98042f5fc3e54bbc9f81151bd7e
+c4f2af9ae8283cfd84c8f6a5f29f3260
+5a33a5383d9754278cdca828f4186567
+b3865a1c6b1033408c39e940d6dd1059
+145228a3367ae38b3873004db7271788
+3327744fbe807ee40e7e2b64609817db
+b791939c01330564e1c8673171219161
+8317e25281cb9402701973753dc999b0
+f84c7f2017aaec513f6c886fa9a5654a
+7f661ad675d0139b2645293e6d7b91e8
+b4f0e4d5c1041249d8f6e9bf41763695
+e0b0165909cd2a6ffe20d3f809f4a937
+99b0480e105bc4a1410c39daa7696b17
+43f0500520c50fc31c56e28167f6e51b
+496957948545345c33b8837dc236f96a
+6684eb2794511605a0604c1c472f6e5f
+1997593e511d401515fef7479057e6bb
+fba1e215b4e94802573bf986c2445c54
+f876c2f2a3ca802ae1109f81a70bb3c0
+ed1a4227cb95f651078e3e6f78eb4ce0
+92d12c7fa5635a251de006b7b7c4eba6

favos-40.txt

@@ -0,0 +1,100 @@
+4750de5a4ed73ac3ed7eda996d0267d7
+94253e245eac9a7966f320ddc12aef77
+d4daf55888ec2412f3364d727ea59676
+56a8974858d46772b14884c3b3818acc
+8171d12d7221df620aca9604337011ba
+aabcaea6a028bbb9d493d5d9e54a3aa2
+cc417bba46653c48e721b868aa22f8d0
+825f26bdc37c37f5a3b126d9ddf21294
+7579cb830d7d9f60a4df6d66919141bb
+ea004c817ad6ed08772b078395f40ea4
+188153a03c31d5a3e177a792a39609aa
+3fcdb07cf93310be97fb559ac63ec6ee
+3e5e416c827648535a0b7ce27e99b8f7
+890634d1700d7c1c1ca7f3854b25cc15
+fd3b065ab8013a2e79ed62be1c7b8432
+bad2a11729d1433453255ed44a252894
+7f70a2127da7fa077f4c2f25b8856115
+0961c51cfd94d7cc6027adb8c5ea351a
+cce57a8b3f84e83c9e2b4cdd5e912df1
+7023cddaddd36e9d1aa893b6b2ffefb7
+d098c0baf60420840561bbb1d8c11f03
+80727c8eab53b9d4d3f2c65dd6260f4f
+14683ed05ff1f4249a866300fa740afd
+11507069f926df5d0e120a0e925a44f4
+e25386a824771c3830277870e219330d
+9aeb0ae9f74e2cc72dc9ab05ed827509
+9a3fa34af8963d03315cda02686f8a6d
+be05d0f2a0a11b41cdf27dd786a7d374
+d81bcac5eb3b1ba82920c01f2bcff550
+bc767f91bed2677aa84edc1cf6cc4d8e
+eb97baf602d734a4f79fc91b84d5ab90
+6038639557c363c42eb271cfc2bc14c9
+0ce210231a7803ee7ea39873190b446c
+c17639673399150246480ad5944724c2
+507e1dc1fea9826562b7ec570e242fa0
+ed7a8041a84fb90ba764af9639f71120
+639d041857f19c990a6a9bfb2f681f1f
+b3c8a9f1e3981587a0cc318c020389fc
+956dd29b84e65251d74dc0921ff00d3a
+3c541ecada626e6a7490f0d466e5cb5a
+027361154062d57242859b91bb31f458
+ce642bffcf1b4f332d3ee3194aa8c910
+d9ca643c71220034c1f509bf3bb7bb6c
+6548bf59ebdbb9d0f87a86e5c0f62008
+46021c4ab2273a426179f20746a64056
+622a28c3b083546daf33020da1a60d8b
+4fd9b7e01f69ae0bc7010c704413ee7c
+9493e12c06bd851f232449da1ebeb455
+e3097db434b19ef61e18be0aad0998a4
+a9fbc0b25ef74ddf903793f1ec5e3d40
+e85ba3fcc2ca9aef56eb4e24f51b557a
+083c4d4e5e9a5a797fb73861f6e0db7c
+6d5e9284da79564aa97332349105ae69
+6f020ff2874d30ca512629d4173ce9b1
+261bc95d11516aca19aa790652054a49
+6482e2044989f4c0188cc6c7fa04ed39
+1b3aa93dcd35bcc2969b6c6ea3df8957
+6c84d376b4525a0987f612911d588a17
+b9f4a9bb89e5d0e772fe89e026489c84
+0fe93221b3cfc9d3144d986ed4d154dd
+8a404976cbb72a1b4420cbaeebf779df
+31794cb13399f114ca2d48ab9705e263
+1b1e5e98ceadae3c97ec3e697edb504e
+74f3fdfbdb7e1d9c77dbb8393a2930c4
+193986c0dadff682425d2503994f6f74
+6fa3bc477c4d141e2bc02536fd9d341d
+443d366bdbafde1df65854c63999f276
+a5cbeceefb0bbe01164f9d071265515d
+613959df1f96df73142c053ef4149521
+341abea5d530fb03c0543c77e9b7547a
+0e3606e492c97f16b9b00938992b43fa
+25095ccdf53e5212769155a3ac35883a
+e632f5529cdaa16297f6ece0d85f528a
+3d0fd71dbd7995dfe9790b3b6664ec4d
+905cd1071101c1f5021580349d81b8d7
+d1ece9bbd0b7943b807d7a6bca660521
+5c392f7e62c0833639b9f294f4f4047a
+ab9850dc9ce66da7a38e2f31de75c3be
+598aa6e379588116c20fbe0c9ac618cf
+4fcac6d55bba3bdc0cf7b0173f9fc3bf
+bf9167f01ab7ab3a2fa9479cf6468575
+67d270ad20e288b49dbe8d4118da4dca
+7f63e595c5852986a6e5577c1d10f081
+b9458c4ddd1d97ecb10488394fbaae3b
+e446850c7bb6f71273bb2980a57e61e3
+9599d68f7d2d5a42a048c7fea7160de6
+0ddb3ccdb8cd010c226b30a13da8c867
+8e0d47249ed76464abd46a9099d36988
+5c57659d33c5c763be2d39c789c24fcb
+73e765d9e7d10d5e352e0a0ca8872939
+c3382e7f8c961173514ba7c0e6ea29ff
+18c22726d269d275640765ce76b6214e
+0318cc320c7f8cde3d189e12e4ad49d1
+e55bd1ae4cfa387a56402d567bfba8ac
+e374cccf987d407ce4d4b76f2fa08118
+8d3c0469eee6e9d09eeb59fae481af0a
+34ef04cd9fe808c3b69855fd559c6f0a
+f91be6e652955638cfcd765284efbd64
+42fb18ae777530addb2d71c8bd97e9b8
+6a6ce5aaf815cd2e8788d220d5b758a6

requirements.txt

@@ -0,0 +1,5 @@
+numpy
+pillow
+scipy
+tqdm
+huggingface_hub