sciveo 0.1.53__tar.gz → 0.1.55__tar.gz

{sciveo-0.1.53 → sciveo-0.1.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sciveo
-Version: 0.1.53
+Version: 0.1.55
 Description-Content-Type: text/markdown
 Provides-Extra: mon
 Provides-Extra: net
@@ -8,7 +8,7 @@ Provides-Extra: server
 Provides-Extra: media
 Provides-Extra: media-ml
 Provides-Extra: all
-Provides-Extra: media-all
+Provides-Extra: ml
 
 # SCIVEO - ML/AI and Scientific tools
 

sciveo-0.1.55/sciveo/media/tools/video_interactive.py

@@ -0,0 +1,138 @@
+#
+# Pavlin Georgiev, Softel Labs
+#
+# This is a proprietary file and may not be copied,
+# distributed, or modified without express permission
+# from the owner. For licensing inquiries, please
+# contact pavlin@softel.bg.
+#
+# 2024
+#
+
+import os
+import time
+import cv2
+import threading
+import numpy as np
+
+from sciveo.tools.logger import *
+from sciveo.tools.timers import FPSCounter
+
+
+class BaseInteractiveVideoPlayer:
+  def __init__(self, path_video, tag):
+    self.path_video = path_video
+    self.file_name = os.path.basename(self.path_video)
+    self.file_name_base = filename_without_ext = os.path.splitext(self.file_name)[0]
+    self.path_base = os.path.dirname(self.path_video)
+    self.tag = tag
+    self.frame_tag = f"Video {tag}"
+
+    self.cap = None
+    self.frame = None
+    self.frame_id = 0
+    self.result = None
+    self.progress_lock = threading.Lock()
+    self.frame_lock = threading.Lock()
+    self.ui_video_progress_tag = "video time progress"
+
+    self.fps_ui = FPSCounter(tag="ui", period=1, print_period=600)
+    self.fps_read = FPSCounter(tag="read", period=1, print_period=600)
+
+    self.stop_threads = False
+    self.threads = [
+      threading.Thread(target=self.read, daemon=True)
+    ]
+
+  def callback_video_progress(self, x):
+    # debug("callback_video_progress", x)
+    with self.frame_lock:
+      # self.frame_id = cv2.getTrackbarPos(self.ui_video_progress_tag, self.frame_tag)
+      self.frame_id = x
+
+  def ui_controls(self, min_val, max_val):
+    cv2.createTrackbar(self.ui_video_progress_tag, self.frame_tag, min_val, max_val, self.callback_video_progress)
+
+  def process_frame(self, frame):
+    return {}
+
+  def read(self):
+    while not self.stop_threads:
+      self.fps_read.update()
+      with self.progress_lock:
+        current_frame_id = self.frame_id
+      self.cap.set(cv2.CAP_PROP_POS_FRAMES, int(current_frame_id + 1))
+      ret, current_frame = self.cap.read()
+      if not ret:
+        break
+
+      current_result = self.process_frame(current_frame)
+
+      with self.frame_lock:
+        self.frame = current_frame.copy()
+        self.result = current_result
+
+      with self.progress_lock:
+        self.frame_id += 1
+        if self.frame_id >= self.video_frame_count:
+          self.frame_id = 0
+        cv2.setTrackbarPos(self.ui_video_progress_tag, self.frame_tag, self.frame_id)
+
+  def draw(self, frame, result):
+    cv2.putText(frame, f"R[{result}]", (30, 80), cv2.FONT_HERSHEY_SIMPLEX, 1.3, (0, 255, 255), 2)
+
+  def run(self, max_display_width=1024):
+    cv2.namedWindow(self.frame_tag, cv2.WINDOW_NORMAL)
+
+    self.cap = cv2.VideoCapture(self.path_video)
+
+    self.video_fps = self.cap.get(cv2.CAP_PROP_FPS)
+    self.video_frame_count = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    self.video_duration_sec = self.video_frame_count / self.video_fps
+    debug("run", self.path_video, self.tag, "fps", self.video_fps, "count", self.video_frame_count, "duration", self.video_duration_sec)
+
+    self.ui_controls(0, self.video_frame_count)
+
+    for thread in self.threads:
+      thread.start()
+
+    while self.cap.isOpened():
+      self.fps_ui.update()
+      current_frame = None
+      original_current_frame = None
+      current_result = None
+      with self.frame_lock:
+        if self.frame is not None:
+          current_frame = self.frame.copy()
+          original_current_frame = self.frame.copy()
+          current_result = self.result.copy()
+
+      if current_frame is not None:
+        cv2.putText(current_frame, f"FPS read {round(self.fps_read.value, 1)} ui {round(self.fps_ui.value, 1)} T {round(self.frame_id / self.video_fps, 3)}s", (30, 40), cv2.FONT_HERSHEY_SIMPLEX, 1.3, (0, 255, 0), 4)
+        self.draw(current_frame, current_result)
+        height, width = current_frame.shape[:2]
+        if width > max_display_width:
+          display_width = max_display_width
+          display_height = int(height * (max_display_width / width))
+          cv2.resizeWindow(self.frame_tag, display_width, display_height)
+        cv2.imshow(self.frame_tag, current_frame)
+
+      key = cv2.waitKey(1) & 0xFF
+      if key == ord("q"):
+        self.stop_threads = True
+        for thread in self.threads:
+          thread.join()
+        break
+      elif key == ord("p"):
+        if original_current_frame is not None:
+          frame_path = os.path.join(self.path_base, f"{self.file_name_base}-{self.frame_id}.png")
+          cv2.imwrite(frame_path, original_current_frame)
+          debug(f"saved frame {self.frame_id} to {frame_path}")
+
+    self.cap.release()
+    cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+  video_player = BaseInteractiveVideoPlayer(os.environ["PATH_VIDEO_FILE"], "base video player")
+  video_player.run()

sciveo-0.1.55/sciveo/ml/evaluation/markdown.py

@@ -0,0 +1,227 @@
+#
+# Stanislav Georgiev, Softel Labs
+#
+# This is a proprietary file and may not be copied,
+# distributed, or modified without express permission
+# from the owner. For licensing inquiries, please
+# contact s.georgiev@softel.bg.
+#
+# 2025
+#
+
+import re
+import difflib
+from collections import defaultdict
+
+
+class EvalMarkdownSimple:
+  def __init__(self, md_true: str, md_predicted: str, similarity_threshold=0.8):
+    self.md_true = md_true.split("\n")
+    self.md_predicted = md_predicted.split("\n")
+    self.similarity_threshold = similarity_threshold
+    self.results = {"EM": [], "PM": [], "FN": [], "FP": [], "RI": [], "H": [], "FE": []}
+
+  def _find_best_match(self, text, candidates):
+    """
+    Finds the best matching text block from predicted Markdown using similarity comparison.
+
+    :param text: The labeled Markdown text to match.
+    :param candidates: The list of LLM-generated Markdown text blocks.
+    :return: (best_match, similarity_score) or (None, 0) if no match found.
+    """
+    best_match = None
+    best_score = 0
+    text_lower = text.lower()
+
+    for candidate in candidates:
+      score = difflib.SequenceMatcher(None, text_lower, candidate.lower()).ratio()
+      if score > best_score:
+        best_score = score
+        best_match = candidate
+
+    return (best_match, best_score) if best_score >= self.similarity_threshold else (None, 0)
+
+  def _check_formatting_errors(self, original, predicted):
+    """
+    Checks for incorrect Markdown formatting in predicted text.
+
+    :param original: The manually labeled Markdown text.
+    :param predicted: The LLM-generated Markdown text.
+    :return: True if formatting errors exist, False otherwise.
+    """
+    # Basic check: header formatting, bold/italic differences
+    if original.strip("#*`").strip() == predicted.strip("#*`").strip():
+      return True
+    return False
+
+  def evaluate(self):
+    """
+    Evaluates Markdown
+    """
+    matched_predicted_blocks = set()
+    predicted_idx_map = {block: idx for idx, block in enumerate(self.md_predicted)}
+
+    for true_text in self.md_true:
+      best_match, score = self._find_best_match(true_text, self.md_predicted)
+
+      if best_match:
+        matched_predicted_blocks.add(best_match)
+        if score == 1.0:
+          self.results["EM"].append((true_text, best_match))
+        else:
+          self.results["PM"].append((true_text, best_match, score))
+
+        # Check for formatting errors
+        if self._check_formatting_errors(true_text, best_match):
+          self.results["FE"].append((true_text, best_match))
+      else:
+        self.results["FN"].append(true_text)
+
+    # False Positives (extra predicted blocks that don't match labeled Markdown)
+    for pred_text in self.md_predicted:
+      if pred_text not in matched_predicted_blocks:
+        self.results["FP"].append(pred_text)
+
+    # Check for hallucinations (predicted content not in labeled text)
+    for pred_text in self.results["FP"]:
+      best_match, _ = self._find_best_match(pred_text, self.md_true)
+      if best_match is None:
+        self.results["H"].append(pred_text)
+
+    # Check for order issues (text found but misordered)
+    true_texts = [t for t, _ in self.results["EM"]] + [t for t, _, _ in self.results["PM"]]
+    pred_texts = [p for _, p in self.results["EM"]] + [p for _, p, _ in self.results["PM"]]
+
+    true_indices = [predicted_idx_map[text] for text in pred_texts if text in predicted_idx_map]
+    if true_indices != sorted(true_indices):
+      self.results["RI"].append(true_indices)
+
+    return self.results
+
+  def score(self):
+    """
+    Computes an improved similarity score with weighted Partial Matches (PM).
+    """
+    TP = len(self.results["EM"])
+    PM_weighted = sum(score for _, _, score in self.results["PM"])
+    FN = len(self.results["FN"])
+    FP = len(self.results["FP"])
+
+    precision = (TP + PM_weighted) / (TP + PM_weighted + FP) if (TP + PM_weighted + FP) > 0 else 0
+    recall = (TP + PM_weighted) / (TP + PM_weighted + FN) if (TP + PM_weighted + FN) > 0 else 0
+    f1_score = (2 * precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
+
+    return {"Precision": precision, "Recall": recall, "F1 Score": f1_score}
+
+
+class EvalMarkdown:
+  def __init__(self, md_true, md_predicted):
+    """
+    Evaluates labeled (true) Markdown against predicted Markdown with section-wise evaluation.
+    """
+    self.md_true = self._parse_markdown(md_true.lower())
+    self.md_predicted = self._parse_markdown(md_predicted.lower())
+    self.results = defaultdict(lambda: {"EM": [], "PM": [], "FN": [], "FP": []})
+
+  def _parse_markdown(self, markdown_text):
+    """
+    Parses Markdown into a dictionary of sections where key = heading, value = list of text blocks.
+    """
+    sections = defaultdict(list)
+    current_section = "INTRO"  # Default section if no heading appears
+
+    for line in markdown_text.split("\n"):
+      heading_match = re.match(r"^(#{1,6})\s+(.+)", line)
+      if heading_match:
+        current_section = heading_match.group(2).strip()  # Extract section title
+      else:
+        if line.strip():
+          sections[current_section].append(line.strip())
+
+    return sections
+
+  def _find_best_match(self, text, true_texts):
+    """
+    Finds the best match for a given text within a list of true texts.
+    Returns (best_match_text, similarity_score).
+    """
+    if not true_texts:
+      return None, 0
+
+    from difflib import SequenceMatcher
+    best_match, best_score = None, 0
+
+    for true_text in true_texts:
+      score = SequenceMatcher(None, text, true_text).ratio()
+      if score > best_score:
+        best_match, best_score = true_text, score
+
+    return best_match, best_score
+
+  def evaluate(self):
+    all_sections = set(self.md_true.keys()).union(set(self.md_predicted.keys()))
+    for section in all_sections:
+      true_texts = self.md_true.get(section, [])
+      pred_texts = self.md_predicted.get(section, [])
+
+      matched_true = set()
+      matched_pred = set()
+
+      # Exact matches
+      for pred_text in pred_texts:
+        if pred_text in true_texts:
+          self.results[section]["EM"].append((pred_text, pred_text))
+          matched_true.add(pred_text)
+          matched_pred.add(pred_text)
+
+      # Partial matches
+      for pred_text in pred_texts:
+        if pred_text not in matched_pred:
+          best_match, score = self._find_best_match(pred_text, true_texts)
+          if best_match and score > 0.8:  # Accept only good matches
+            self.results[section]["PM"].append((best_match, pred_text, score))
+            matched_true.add(best_match)
+            matched_pred.add(pred_text)
+
+      # False negatives (missed text from ground truth)
+      for true_text in true_texts:
+        if true_text not in matched_true:
+          self.results[section]["FN"].append(true_text)
+
+      # False positives (extra predicted text)
+      for pred_text in pred_texts:
+        if pred_text not in matched_pred:
+          self.results[section]["FP"].append(pred_text)
+
+    return self.results
+
+  def score(self):
+    """
+    Computes section-wise and global similarity scores.
+    """
+    section_scores = {}
+    global_TP, global_PM, global_FN, global_FP = 0, 0, 0, 0
+
+    for section, result in self.results.items():
+      TP = len(result["EM"])
+      PM_weighted = sum(score for _, _, score in result["PM"])
+      FN = len(result["FN"])
+      FP = len(result["FP"])
+
+      precision = (TP + PM_weighted) / (TP + PM_weighted + FP) if (TP + PM_weighted + FP) > 0 else 0
+      recall = (TP + PM_weighted) / (TP + PM_weighted + FN) if (TP + PM_weighted + FN) > 0 else 0
+      f1_score = (2 * precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
+
+      section_scores[section] = {"Precision": precision, "Recall": recall, "F1 Score": f1_score}
+
+      global_TP += TP
+      global_PM += PM_weighted
+      global_FN += FN
+      global_FP += FP
+
+    # Global precision/recall across all sections
+    global_precision = (global_TP + global_PM) / (global_TP + global_PM + global_FP) if (global_TP + global_PM + global_FP) > 0 else 0
+    global_recall = (global_TP + global_PM) / (global_TP + global_PM + global_FN) if (global_TP + global_PM + global_FN) > 0 else 0
+    global_f1 = (2 * global_precision * global_recall) / (global_precision + global_recall) if (global_precision + global_recall) > 0 else 0
+
+    return {"Sections": section_scores, "Global": {"Precision": global_precision, "Recall": global_recall, "F1 Score": global_f1}}

{sciveo-0.1.53 → sciveo-0.1.55}/sciveo/monitoring/monitor.py

@@ -169,7 +169,7 @@ class BaseMonitor(DaemonBase):
 
       lines = result.stdout.strip().split('\n')
       self.data["GPU"] = {
-        "raw_lines": lines
+        "raw_lines": lines[:7] # TODO: FIX this! Due to aws timestream constraints.
       }
     except Exception as e:
       pass

{sciveo-0.1.53 → sciveo-0.1.55}/sciveo/tools/timers.py

@@ -15,19 +15,30 @@ from sciveo.tools.logger import *
 
 
 class FPSCounter:
-  def __init__(self, period=10, tag=""):
+  def __init__(self, period=1, tag="", print_period=1, printer=debug):
     self.period = period
+    self.print_period = print_period
+    self.printer = printer
+    self.print_n = 0
     self.tag = tag
     self.n = 0
     self.t1 = time.time()
+    self.value = 0
+
+  def print(self):
+    self.print_n += 1
+    if self.print_n > self.print_period:
+      self.printer(self.tag, "FPS", self.value)
+      self.print_n = 0
 
   def update(self):
     self.n += 1
     t2 = time.time()
     if t2 - self.t1 > self.period:
-      debug(self.tag, "FPS", self.n / (t2 - self.t1))
+      self.value = self.n / (t2 - self.t1)
       self.n = 0
       self.t1 = time.time()
+      self.print()
 
 
 class TimerExec:

sciveo-0.1.55/sciveo/version.py

@@ -0,0 +1,2 @@
+
+__version__ = '0.1.55'

{sciveo-0.1.53 → sciveo-0.1.55}/sciveo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sciveo
-Version: 0.1.53
+Version: 0.1.55
 Description-Content-Type: text/markdown
 Provides-Extra: mon
 Provides-Extra: net
@@ -8,7 +8,7 @@ Provides-Extra: server
 Provides-Extra: media
 Provides-Extra: media-ml
 Provides-Extra: all
-Provides-Extra: media-all
+Provides-Extra: ml
 
 # SCIVEO - ML/AI and Scientific tools
 

{sciveo-0.1.53 → sciveo-0.1.55}/sciveo.egg-info/SOURCES.txt

@@ -91,18 +91,19 @@ sciveo/media/pipelines/web/__init__.py
 sciveo/media/pipelines/web/server.py
 sciveo/media/tools/__init__.py
 sciveo/media/tools/nvr.py
+sciveo/media/tools/video_interactive.py
 sciveo/ml/__init__.py
 sciveo/ml/base.py
 sciveo/ml/dataset/__init__.py
 sciveo/ml/dataset/object_detection.py
 sciveo/ml/evaluation/__init__.py
+sciveo/ml/evaluation/markdown.py
 sciveo/ml/evaluation/object_detection.py
 sciveo/ml/images/__init__.py
 sciveo/ml/images/base.py
 sciveo/ml/images/description.py
 sciveo/ml/images/embeddings.py
 sciveo/ml/images/object_detection.py
-sciveo/ml/images/segmentation.py
 sciveo/ml/images/tools.py
 sciveo/ml/images/transformers.py
 sciveo/ml/nlp/__init__.py
@@ -146,6 +147,7 @@ test/test_complexity.py
 test/test_compress.py
 test/test_configuration.py
 test/test_crypto.py
+test/test_eval_markdown.py
 test/test_ml_datasets.py
 test/test_monitoring.py
 test/test_runner.py

{sciveo-0.1.53 → sciveo-0.1.55}/sciveo.egg-info/requires.txt

@@ -5,6 +5,10 @@ requests>=0.0.0
 psutil>=0.0.0
 netifaces>=0.0.0
 scapy>=0.0.0
+fastapi>=0.0.0
+uvicorn[standard]>=0.0.0
+flask>=0.0.0
+waitress>=0.0.0
 
 [media]
 scikit-learn>=0.0.0
@@ -25,10 +29,26 @@ ffmpeg-python>=0.0.0
 opencv-python-headless>=0.0.0
 opencv-contrib-python-headless>=0.0.0
 
-[media-all]
+[media-ml]
+tensorflow>=0.0.0
+keras>=0.0.0
+torch>=0.0.0
+torchvision>=0.0.0
+diffusers>=0.0.0
+transformers>=0.0.0
+sentence_transformers>=0.0.0
+accelerate>=0.0.0
+annoy>=0.0.0
+ultralytics>=0.0.0
+
+[ml]
 psutil>=0.0.0
 netifaces>=0.0.0
 scapy>=0.0.0
+fastapi>=0.0.0
+uvicorn[standard]>=0.0.0
+flask>=0.0.0
+waitress>=0.0.0
 scikit-learn>=0.0.0
 scipy>=0.0.0
 scikit-video>=0.0.0
@@ -46,22 +66,6 @@ tqdm>=0.0.0
 ffmpeg-python>=0.0.0
 opencv-python-headless>=0.0.0
 opencv-contrib-python-headless>=0.0.0
-fastapi>=0.0.0
-uvicorn[standard]>=0.0.0
-flask>=0.0.0
-waitress>=0.0.0
-tensorflow>=0.0.0
-keras>=0.0.0
-torch>=0.0.0
-torchvision>=0.0.0
-diffusers>=0.0.0
-transformers>=0.0.0
-sentence_transformers>=0.0.0
-accelerate>=0.0.0
-annoy>=0.0.0
-ultralytics>=0.0.0
-
-[media-ml]
 tensorflow>=0.0.0
 keras>=0.0.0
 torch>=0.0.0

{sciveo-0.1.53 → sciveo-0.1.55}/setup.py

@@ -39,8 +39,8 @@ extras_require = {
       ]
 }
 
-extras_require['all'] = extras_require['mon'] + extras_require['net']
-extras_require['media-all'] = extras_require['all'] + extras_require['media'] + extras_require['server'] + extras_require['media-ml']
+extras_require['all'] = extras_require['mon'] + extras_require['net'] + extras_require['server']
+extras_require['ml'] = extras_require['all'] + extras_require['media'] + extras_require['media-ml']
 
 setup(
     name='sciveo',

sciveo-0.1.55/test/test_eval_markdown.py

@@ -0,0 +1,41 @@
+#
+# Stanislav Georgiev, Softel Labs
+#
+# This is a proprietary file and may not be copied,
+# distributed, or modified without express permission
+# from the owner. For licensing inquiries, please
+# contact s.georgiev@softel.bg.
+#
+# 2025
+#
+
+import math
+import unittest
+
+from sciveo.tools.logger import *
+from sciveo.ml.evaluation.markdown import *
+
+
+class TestEvalMarkdown(unittest.TestCase):
+  def test_1(self):
+    md_true = """
+      "# Breaking News"
+      "A major fire broke out in the city center."
+      "Authorities are investigating the cause."
+    """
+
+    md_predicted = """
+      "# BREAKING NEWS",
+      "A major fire broke out in city center.",
+      "Authorities investigate the cause.",
+      "Stay tuned for updates."
+    """
+
+    em = EvalMarkdown(md_true, md_predicted)
+    results = em.evaluate()
+    info(results)
+    info("Score", em.score())
+
+
+if __name__ == '__main__':
+  unittest.main()