indovse 0.1.0__tar.gz

indovse-0.1.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: indovse
+Version: 0.1.0
+Summary: Indonesian Video Salient Entity Detection
+Author: galihkjaya
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: openai-whisper
+Requires-Dist: transformers>=4.40
+Requires-Dist: torch>=2.0
+Requires-Dist: scikit-learn>=1.4
+Requires-Dist: joblib
+Requires-Dist: huggingface_hub
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: ffmpeg-python
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# IndoVSE
+
+IndoVSE is a Python package for extracting salient named entities from Indonesian videos.
+
+## Requirements
+
+You must have `ffmpeg` installed on your system (not via pip). 
+
+- **Ubuntu/Debian:** `sudo apt install ffmpeg`
+- **MacOS:** `brew install ffmpeg`
+- **Windows:** Download from official ffmpeg website and add it to your system PATH.
+
+## Installation
+
+```bash
+pip install indovse
+```
+*(atau instal dari source: `pip install -e .` di dalam folder ini)*
+
+## Usage
+
+```python
+from indovse import predict
+
+# Models are automatically downloaded on first call and cached in memory
+# No GPU required, runs on CPU
+result = predict("video.mp4", top_k=5)
+
+# Output is a dict with 'salient_entities' and 'entity_timeline'
+print(result["salient_entities"])
+```

indovse-0.1.0/README.md

@@ -0,0 +1,31 @@
+# IndoVSE
+
+IndoVSE is a Python package for extracting salient named entities from Indonesian videos.
+
+## Requirements
+
+You must have `ffmpeg` installed on your system (not via pip). 
+
+- **Ubuntu/Debian:** `sudo apt install ffmpeg`
+- **MacOS:** `brew install ffmpeg`
+- **Windows:** Download from official ffmpeg website and add it to your system PATH.
+
+## Installation
+
+```bash
+pip install indovse
+```
+*(atau instal dari source: `pip install -e .` di dalam folder ini)*
+
+## Usage
+
+```python
+from indovse import predict
+
+# Models are automatically downloaded on first call and cached in memory
+# No GPU required, runs on CPU
+result = predict("video.mp4", top_k=5)
+
+# Output is a dict with 'salient_entities' and 'entity_timeline'
+print(result["salient_entities"])
+```

indovse-0.1.0/indovse/__init__.py

@@ -0,0 +1,3 @@
+from .pipeline import predict
+
+__all__ = ["predict"]

indovse-0.1.0/indovse/pipeline.py

@@ -0,0 +1,164 @@
+import os
+import tempfile
+import numpy as np
+import torch
+import joblib
+import ffmpeg
+import whisper
+from transformers import pipeline as hf_pipeline, AutoModel, AutoTokenizer
+from huggingface_hub import hf_hub_download
+from collections import Counter
+from .utils import calculate_temporal_features
+
+# Global cache for lazy loading
+_models = {
+    "whisper": None,
+    "ner": None,
+    "indobert_model": None,
+    "indobert_tokenizer": None,
+    "scaler": None,
+    "classifier": None
+}
+
+def _load_models():
+    if _models["whisper"] is None:
+        _models["whisper"] = whisper.load_model("medium")
+    if _models["ner"] is None:
+        _models["ner"] = hf_pipeline("ner", model="cahya/bert-base-indonesian-NER", aggregation_strategy="simple")
+    if _models["indobert_model"] is None:
+        _models["indobert_model"] = AutoModel.from_pretrained("indobenchmark/indobert-base-p1")
+    if _models["indobert_tokenizer"] is None:
+        _models["indobert_tokenizer"] = AutoTokenizer.from_pretrained("indobenchmark/indobert-base-p1")
+    if _models["scaler"] is None:
+        scaler_path = hf_hub_download("galihkjaya/IndoVSE", "scaler.pkl")
+        _models["scaler"] = joblib.load(scaler_path)
+    if _models["classifier"] is None:
+        clf_path = hf_hub_download("galihkjaya/IndoVSE", "model.pkl")
+        _models["classifier"] = joblib.load(clf_path)
+
+def extract_audio(video_path):
+    tmp_audio = tempfile.NamedTemporaryFile(suffix=".wav", delete=False).name
+    try:
+        (
+            ffmpeg
+            .input(video_path)
+            .output(tmp_audio, acodec='pcm_s16le', ac=1, ar='16k', loglevel='quiet')
+            .overwrite_output()
+            .run(capture_stdout=True, capture_stderr=True)
+        )
+        return tmp_audio
+    except ffmpeg.Error as e:
+        if os.path.exists(tmp_audio):
+            os.remove(tmp_audio)
+        raise RuntimeError(f"FFmpeg error: {e.stderr.decode()}")
+
+def predict(video_path, top_k=5):
+    _load_models()
+    
+    # 1. Extract audio
+    audio_path = extract_audio(video_path)
+    
+    try:
+        # 2. Transcribe
+        whisper_model = _models["whisper"]
+        result = whisper_model.transcribe(audio_path, language="id", word_timestamps=True)
+        
+        segments = result.get('segments', [])
+        duration = segments[-1]['end'] if segments else 0.0
+        
+        if duration == 0.0:
+            return {"salient_entities": [], "entity_timeline": {}}
+            
+        # 3. NER & Features extraction
+        ner_model = _models["ner"]
+        tokenizer = _models["indobert_tokenizer"]
+        bert_model = _models["indobert_model"]
+        
+        entities_data = {}
+        total_entity_mentions = 0
+        
+        for segment in segments:
+            seg_text = segment['text']
+            seg_start = segment['start']
+            
+            ner_res = ner_model(seg_text)
+            if not ner_res:
+                continue
+                
+            # CLS embedding for the segment
+            inputs = tokenizer(seg_text, return_tensors="pt", truncation=True, max_length=512)
+            with torch.no_grad():
+                outputs = bert_model(**inputs)
+                cls_emb = outputs.last_hidden_state[0, 0, :].numpy()
+                
+            for ent in ner_res:
+                ent_text = ent['word'].strip()
+                if not ent_text:
+                    continue
+                    
+                ent_label = ent['entity_group']
+                
+                if ent_text not in entities_data:
+                    entities_data[ent_text] = {"labels": [], "timestamps": [], "embeddings": []}
+                
+                entities_data[ent_text]["labels"].append(ent_label)
+                entities_data[ent_text]["timestamps"].append(seg_start)
+                entities_data[ent_text]["embeddings"].append(cls_emb)
+                total_entity_mentions += 1
+                
+        if total_entity_mentions == 0:
+            return {"salient_entities": [], "entity_timeline": {}}
+            
+        results = []
+        entity_timeline = {}
+        
+        for ent_text, data in entities_data.items():
+            timestamps = sorted(data["timestamps"])
+            entity_timeline[ent_text] = timestamps
+            
+            freq_norm, burstiness, first_appear, coverage = calculate_temporal_features(
+                timestamps, duration, total_entity_mentions
+            )
+            
+            avg_emb = np.mean(data["embeddings"], axis=0)
+            
+            # Combine temporal features and CLS embedding
+            feature_vector = np.concatenate([[freq_norm, burstiness, first_appear, coverage], avg_emb])
+            
+            # Majority vote for label
+            majority_label = Counter(data["labels"]).most_common(1)[0][0]
+            
+            results.append({
+                "entity_text": ent_text,
+                "entity_label": majority_label,
+                "freq_norm": float(freq_norm),
+                "first_appear": float(first_appear),
+                "coverage": float(coverage),
+                "burstiness": float(burstiness),
+                "feature_vector": feature_vector
+            })
+            
+        # 4. Predict salience
+        X = np.array([r["feature_vector"] for r in results])
+        scaler = _models["scaler"]
+        clf = _models["classifier"]
+        
+        X_scaled = scaler.transform(X)
+        probs = clf.predict_proba(X_scaled)[:, 1]
+        
+        for r, p in zip(results, probs):
+            r["salient_prob"] = float(p)
+            del r["feature_vector"]
+            
+        # 5. Filter & Sort
+        salient_entities = [r for r in results if r["salient_prob"] > 0.1]
+        salient_entities.sort(key=lambda x: x["salient_prob"], reverse=True)
+        salient_entities = salient_entities[:top_k]
+        
+        return {
+            "salient_entities": salient_entities,
+            "entity_timeline": entity_timeline
+        }
+    finally:
+        if os.path.exists(audio_path):
+            os.remove(audio_path)

indovse-0.1.0/indovse/utils.py

@@ -0,0 +1,19 @@
+import numpy as np
+
+def calculate_temporal_features(timestamps, duration, total_mentions):
+    timestamps = sorted(timestamps)
+    freq = len(timestamps)
+    
+    freq_norm = freq / total_mentions if total_mentions > 0 else 0.0
+    first_appear = timestamps[0] / duration if duration > 0 else 0.0
+    coverage = (timestamps[-1] - timestamps[0]) / duration if duration > 0 else 0.0
+    
+    if freq > 1:
+        inter_arrival = np.diff(timestamps)
+        mu = np.mean(inter_arrival)
+        sigma = np.std(inter_arrival)
+        burstiness = (sigma - mu) / (sigma + mu) if (sigma + mu) > 0 else 0.0
+    else:
+        burstiness = 0.0
+        
+    return freq_norm, burstiness, first_appear, coverage

indovse-0.1.0/indovse.egg-info/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: indovse
+Version: 0.1.0
+Summary: Indonesian Video Salient Entity Detection
+Author: galihkjaya
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: openai-whisper
+Requires-Dist: transformers>=4.40
+Requires-Dist: torch>=2.0
+Requires-Dist: scikit-learn>=1.4
+Requires-Dist: joblib
+Requires-Dist: huggingface_hub
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: ffmpeg-python
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# IndoVSE
+
+IndoVSE is a Python package for extracting salient named entities from Indonesian videos.
+
+## Requirements
+
+You must have `ffmpeg` installed on your system (not via pip). 
+
+- **Ubuntu/Debian:** `sudo apt install ffmpeg`
+- **MacOS:** `brew install ffmpeg`
+- **Windows:** Download from official ffmpeg website and add it to your system PATH.
+
+## Installation
+
+```bash
+pip install indovse
+```
+*(atau instal dari source: `pip install -e .` di dalam folder ini)*
+
+## Usage
+
+```python
+from indovse import predict
+
+# Models are automatically downloaded on first call and cached in memory
+# No GPU required, runs on CPU
+result = predict("video.mp4", top_k=5)
+
+# Output is a dict with 'salient_entities' and 'entity_timeline'
+print(result["salient_entities"])
+```

indovse-0.1.0/indovse.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+setup.py
+indovse/__init__.py
+indovse/pipeline.py
+indovse/utils.py
+indovse.egg-info/PKG-INFO
+indovse.egg-info/SOURCES.txt
+indovse.egg-info/dependency_links.txt
+indovse.egg-info/requires.txt
+indovse.egg-info/top_level.txt

indovse-0.1.0/indovse.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

indovse-0.1.0/indovse.egg-info/requires.txt

@@ -0,0 +1,9 @@
+openai-whisper
+transformers>=4.40
+torch>=2.0
+scikit-learn>=1.4
+joblib
+huggingface_hub
+numpy
+pandas
+ffmpeg-python

indovse-0.1.0/indovse.egg-info/top_level.txt

@@ -0,0 +1 @@
+indovse

indovse-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

indovse-0.1.0/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+with open("requirements.txt", "r", encoding="utf-8") as f:
+    requirements = [line.strip() for line in f if line.strip()]
+
+setup(
+    name="indovse",
+    version="0.1.0",
+    author="galihkjaya",
+    description="Indonesian Video Salient Entity Detection",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    packages=find_packages(),
+    install_requires=requirements,
+    python_requires=">=3.9",
+)