""" FOCUS: Frame-Optimistic Confidence Upper-bound Selection Core algorithm implementation for keyframe extraction using confidence upper-bound bandit approach. This module contains only the algorithm logic, without data processing or I/O operations. """ import numpy as np import math from typing import List, Dict, Tuple, Optional, Callable from scipy.interpolate import Rbf from decord import VideoReader # ============================================================================ # Module-level Helper Functions (Pure Mathematical Operations) # ============================================================================ def estimate_arm_scores( sampled_indices: List[int], sampled_scores: List[float], arm_start: int, arm_end: int, interpolation_method: str = 'nearest' ) -> Dict[int, float]: """ Estimate similarity scores for all frames within a single arm using interpolation. This is a pure function that performs mathematical interpolation without side effects. Args: sampled_indices: List of sampled frame indices within the arm sampled_scores: List of corresponding similarity scores arm_start: Start frame index of the arm (inclusive) arm_end: End frame index of the arm (inclusive) interpolation_method: Method for interpolation ('nearest', 'linear', 'rbf', 'uniform') Returns: Dictionary mapping frame indices to estimated scores """ if len(sampled_indices) < 1 or not sampled_scores: return {} # Create candidate indices for all frames within this arm arm_candidates = list(range(arm_start, arm_end + 1)) if not arm_candidates: return {} sampled_indices_arr = np.array(sampled_indices, dtype=float) sampled_scores_arr = np.array(sampled_scores, dtype=float) arm_candidates_arr = np.array(arm_candidates, dtype=float) try: if interpolation_method == 'nearest': # Nearest neighbor interpolation estimated_scores = [] for candidate in arm_candidates_arr: nearest_idx = np.argmin(np.abs(sampled_indices_arr - candidate)) estimated_scores.append(sampled_scores_arr[nearest_idx]) estimated_scores_arr = np.array(estimated_scores) elif interpolation_method == 'linear': # Linear interpolation if len(sampled_indices) >= 2: estimated_scores_arr = np.interp(arm_candidates_arr, sampled_indices_arr, sampled_scores_arr) else: # Fallback to constant value if only one sample estimated_scores_arr = np.full_like(arm_candidates_arr, sampled_scores_arr[0]) elif interpolation_method == 'rbf': # RBF interpolation using scipy if len(sampled_indices) >= 2: rbf = Rbf(sampled_indices_arr, sampled_scores_arr, function='gaussian', smooth=0.0) estimated_scores_arr = rbf(arm_candidates_arr) else: # Fallback to constant value if only one sample estimated_scores_arr = np.full_like(arm_candidates_arr, sampled_scores_arr[0]) else: raise ValueError(f"Unknown interpolation method: {interpolation_method}") # Clamp results to reasonable range [0, 1] estimated_scores_arr = np.clip(estimated_scores_arr, 0.0, 1.0) # Convert to dictionary result = {} for candidate_idx, estimated_score in zip(arm_candidates, estimated_scores_arr): result[candidate_idx] = float(estimated_score) return result except Exception as e: print(f"Interpolation failed in arm [{arm_start}, {arm_end}] with method {interpolation_method}: {e}") # Fallback: use mean score for all candidates mean_score = np.mean(sampled_scores) result = {} for candidate_idx in arm_candidates: result[candidate_idx] = float(mean_score) return result # ============================================================================ # FOCUS Algorithm Class # ============================================================================ class FOCUS: """ FOCUS: Frame-Optimistic Confidence Upper-bound Selection A bandit-based keyframe extraction algorithm that uses confidence upper bounds to balance exploration and exploitation across temporal segments of the video. The algorithm operates in several stages: 1. Setup arms: Partition video into temporal segments 2. Coarse sampling: Sample center + random points in each arm 3. Fine sampling: Densely sample in promising arms based on FOCUS scores 4. Final selection: Combine top-ranked frames with FOCUS-guided arm allocation """ def __init__( self, similarity_fn: Callable[[VideoReader, str, List[int]], List[float]], coarse_every_sec: float = 16.0, fine_every_sec: float = 1.0, zoom_ratio: float = 0.25, final_min_arms: int = 4, final_max_arms: int = 32, min_coarse_segments: int = 8, min_zoom_segments: int = 4, extra_samples_per_region: int = 2, min_variance_threshold: float = 1e-6, fine_uniform_ratio: float = 0.5, interpolation_method: str = 'nearest', top_ratio: float = 0.2, temperature: float = 0.06, region_half_window_sec: Optional[float] = None ): """ Initialize FOCUS keyframe selector. Args: similarity_fn: Function with signature (video, query, frame_indices) -> similarity_scores coarse_every_sec: Coarse level sampling interval in seconds fine_every_sec: Fine level sampling interval in seconds zoom_ratio: Fraction of arms to select for fine sampling and final selection final_min_arms: Minimum number of arms to use in final allocation final_max_arms: Maximum number of arms to use in final allocation min_coarse_segments: Minimum number of coarse segments min_zoom_segments: Minimum number of segments to zoom into for fine sampling extra_samples_per_region: Extra random samples per region for variance estimation min_variance_threshold: Minimum variance threshold for confidence bounds fine_uniform_ratio: Ratio of uniform sampling in fine stage (0~1) interpolation_method: Method for score interpolation ('nearest', 'linear', 'rbf', 'uniform') top_ratio: Ratio of top-ranked frames to select directly temperature: Temperature for softmax sampling within arms region_half_window_sec: Half window size for fine sampling (defaults to coarse_every_sec/2) """ self.similarity_fn = similarity_fn self.coarse_every_sec = coarse_every_sec self.fine_every_sec = fine_every_sec self.zoom_ratio = zoom_ratio self.final_min_arms = final_min_arms self.final_max_arms = final_max_arms self.min_coarse_segments = min_coarse_segments self.min_zoom_segments = min_zoom_segments self.extra_samples_per_region = extra_samples_per_region self.min_variance_threshold = min_variance_threshold self.fine_uniform_ratio = fine_uniform_ratio self.interpolation_method = interpolation_method self.top_ratio = top_ratio self.temperature = temperature self.region_half_window_sec = region_half_window_sec # ======================================================================== # Public Interface # ======================================================================== def select_keyframes( self, video: VideoReader, query: str, k: int, min_gap_sec: float = 0.0, rng: Optional[np.random.Generator] = None ) -> Tuple[List[int], Dict]: """ Select keyframes from video based on query using FOCUS algorithm. Args: video: VideoReader object query: Query text k: Number of keyframes to select min_gap_sec: Minimum temporal gap between selections in seconds rng: Random number generator (optional, will create default if None) Returns: Tuple of (selected_frames, sampling_details) - selected_frames: List of selected frame indices (sorted) - sampling_details: Dictionary containing detailed sampling information """ # Extract video metadata total_frames = len(video) fps = float(video.get_avg_fps()) video_duration = float(total_frames) / max(1.0, fps) if rng is None: rng = np.random.default_rng() # Calculate strides and parameters coarse_stride = max(1, int(round(self.coarse_every_sec * fps))) desired_coarse = max(self.min_coarse_segments, int(np.ceil(video_duration / max(1e-6, self.coarse_every_sec)))) if desired_coarse > 0: coarse_stride = max(1, int(np.floor(total_frames / desired_coarse))) fine_stride = max(1, int(round(self.fine_every_sec * fps))) fine_stride = min(fine_stride, coarse_stride) if self.region_half_window_sec is None: effective_coarse_sec = max(1e-6, video_duration / max(1, desired_coarse)) region_half_window_sec = max(1.0 / fps, effective_coarse_sec / 2.0) else: region_half_window_sec = self.region_half_window_sec region_half_window = max(1, int(round(region_half_window_sec * fps))) # Stage 0: Setup arms (temporal partitioning) arms = self._setup_arms(total_frames, coarse_stride) # Stage 1: Coarse sampling all_coarse_indices = self._coarse_sampling_in_arms(arms, rng) all_coarse_similarities = self.similarity_fn(video, query, all_coarse_indices) # Update arms with coarse results self._update_arms_with_scores(arms, all_coarse_indices, all_coarse_similarities) self._update_focus_scores(arms) for arm in arms: arm['focus_after_coarse'] = float(arm['focus_score']) # Stage 2: Choose promising arms for fine sampling selected_arms = self._choose_promising_arms(arms) # Stage 3: Fine sampling in promising arms coarse_indices_set = set(all_coarse_indices) fine_indices = self._fine_sampling_in_arms( selected_arms, total_frames, fine_stride, region_half_window, coarse_indices_set, rng ) # Compute similarities for fine samples all_fine_indices = [] all_fine_similarities = [] if fine_indices: all_fine_indices = fine_indices all_fine_similarities = self.similarity_fn(video, query, fine_indices) # Update arms with fine results self._update_arms_with_scores(arms, all_fine_indices, all_fine_similarities) self._update_focus_scores(arms) for arm in arms: arm['focus_after_fine'] = float(arm['focus_score']) # Merge all sampled scores all_sampled_scores = {idx: sim for idx, sim in zip(all_coarse_indices, all_coarse_similarities)} if all_fine_indices: all_sampled_scores.update({idx: sim for idx, sim in zip(all_fine_indices, all_fine_similarities)}) # Stage 4: Final keyframe selection selected_frames = [] arm_selection_probs = [] arm_selection_counts = [] if all_sampled_scores and k > 0: # 4a. Select top-ranked frames selected_frames = self._select_top_frames(all_sampled_scores, k) # 4b. Select remaining frames using FOCUS arm selection remaining_count = max(0, k - len(selected_frames)) if remaining_count > 0: additional_frames, arm_selection_probs, arm_selection_counts = self._select_remaining_frames( arms=arms, remaining_count=remaining_count, all_sampled_scores=all_sampled_scores, selected_frames=selected_frames, fps=fps, min_gap_sec=min_gap_sec, rng=rng ) selected_frames.extend(additional_frames) # Finalize: deduplicate and sort selected_frames = sorted(list(dict.fromkeys(selected_frames)))[:k] if k > 0 else sorted(list(dict.fromkeys(selected_frames))) # Prepare sampling details sampling_details = self._prepare_sampling_details( all_coarse_indices, all_coarse_similarities, all_fine_indices, all_fine_similarities, arms, selected_frames, total_frames, fps, len(all_coarse_indices) + len(all_fine_indices), arm_selection_probs, arm_selection_counts ) return selected_frames, sampling_details # ======================================================================== # Internal Methods (Algorithm Stages) # ======================================================================== def _setup_arms(self, total_frames: int, coarse_stride: int) -> List[Dict]: """ Stage 0: Setup arms (temporal partitioning). Partition the video into temporal segments (arms). Each arm represents a temporal region that can be independently sampled and evaluated. Args: total_frames: Total number of frames in the video coarse_stride: Stride for coarse sampling (determines arm size) Returns: List of arm dictionaries, each containing: - arm_id: Unique identifier - start, end: Frame range (inclusive) - samples, mean_sim, variance: Statistics - focus_score: Confidence upper-bound score - sampled_indices, sampled_scores: Tracking of samples """ num_regions = max(1, total_frames // coarse_stride) region_size = max(1, total_frames // num_regions) arms = [] for region_idx in range(num_regions): region_start = region_idx * region_size region_end = min((region_idx + 1) * region_size, total_frames) if region_end > region_start: arms.append({ 'arm_id': region_idx, 'start': region_start, 'end': region_end - 1, # inclusive end 'samples': 0, 'total_reward': 0.0, 'sum_squared_reward': 0.0, 'mean_sim': 0.0, 'variance': 0.0, 'focus_score': 0.0, 'focus_after_coarse': None, 'focus_after_fine': None, 'sampled_indices': [], 'sampled_scores': [] }) return arms def _coarse_sampling_in_arms( self, arms: List[Dict], rng: np.random.Generator ) -> List[int]: """ Stage 1a: Coarse sampling in each arm. Sample the center point of each arm plus extra random points for variance estimation. This provides initial exploration of all arms. Args: arms: List of arm dictionaries rng: Random number generator Returns: List of frame indices to sample (will be passed to similarity_fn) """ all_coarse_indices = [] for arm in arms: start, end = arm['start'], arm['end'] # Sample center point center_idx = (start + end) // 2 sampled_indices = [center_idx] # Sample extra random points in this arm for variance estimation available_indices = list(range(start, end + 1)) if center_idx in available_indices: available_indices.remove(center_idx) if len(available_indices) > 0: extra_count = min(self.extra_samples_per_region, len(available_indices)) extra_indices = rng.choice(available_indices, size=extra_count, replace=False) sampled_indices.extend(extra_indices.tolist()) arm['sampled_indices'] = sampled_indices all_coarse_indices.extend(sampled_indices) return all_coarse_indices def _update_arms_with_scores( self, arms: List[Dict], indices: List[int], similarities: List[float] ) -> None: """ Update arms with new sampling results and compute statistics. This method updates each arm's sampled_scores and recomputes the mean similarity and variance based on all samples collected so far. Args: arms: List of arm dictionaries indices: List of sampled frame indices similarities: List of corresponding similarity scores """ # Create mapping from index to score idx_to_score = {idx: score for idx, score in zip(indices, similarities)} for arm in arms: # Update with new scores (avoid duplicates) for idx in arm['sampled_indices']: if idx in idx_to_score: score = idx_to_score[idx] if idx not in [s[0] for s in arm['sampled_scores']]: arm['sampled_scores'].append((idx, score)) # Recompute statistics for this arm if arm['sampled_scores']: all_arm_scores = [score for _, score in arm['sampled_scores']] arm['samples'] = len(all_arm_scores) arm['mean_sim'] = float(np.mean(all_arm_scores)) arm['variance'] = float(np.var(all_arm_scores)) if len(all_arm_scores) > 1 else 0.0 def _update_focus_scores(self, arms: List[Dict]) -> None: """ Stage 1b: Compute FOCUS confidence upper-bound scores for all arms. FOCUS score combines: - Mean similarity (exploitation) - Variance-based uncertainty term (exploration) - Sample count penalty (exploration) Formula: mean + sqrt(2*log(N)*var/n) + 3*log(N)/n where N = total samples, n = samples in this arm, var = variance Args: arms: List of arm dictionaries """ total_samples = sum(arm['samples'] for arm in arms) for arm in arms: n_i = arm['samples'] mean = arm['mean_sim'] var = max(arm['variance'], self.min_variance_threshold) focus_score = mean if total_samples > 1 and n_i > 0: # Variance-based confidence term focus_score += math.sqrt(max(0.0, 2 * math.log(total_samples) * var / n_i)) # Sample count penalty focus_score += (3 * math.log(total_samples) / n_i) arm['focus_score'] = focus_score def _choose_promising_arms(self, arms: List[Dict]) -> List[Dict]: """ Stage 2: Choose promising arms using FOCUS confidence upper-bound scores. Select the top arms based on FOCUS scores for fine-grained sampling. This focuses computational budget on the most promising temporal regions. Args: arms: List of arm dictionaries Returns: List of selected promising arms """ arms_sorted = sorted(arms, key=lambda x: x['focus_score'], reverse=True) zoom_count = max(self.min_zoom_segments, int(np.ceil(len(arms) * self.zoom_ratio))) zoom_count = min(zoom_count, len(arms)) selected_arms = arms_sorted[:zoom_count] return selected_arms def _fine_sampling_in_arms( self, selected_arms: List[Dict], total_frames: int, fine_stride: int, region_half_window: int, coarse_indices_set: set, rng: np.random.Generator ) -> List[int]: """ Stage 3: Fine sampling in promising arms with mixed uniform/random strategy. For each selected arm, densely sample a window around its center using a mix of uniform sampling (for coverage) and random sampling (for exploration). Args: selected_arms: List of selected promising arms total_frames: Total number of frames in video fine_stride: Stride for fine sampling region_half_window: Half window size around arm centers (in frames) coarse_indices_set: Set of already sampled coarse indices (to avoid duplicates) rng: Random number generator Returns: List of frame indices for fine sampling """ candidate_fine = set() for arm in selected_arms: arm_center = (arm['start'] + arm['end']) // 2 start = max(0, arm_center - region_half_window) end = min(total_frames - 1, arm_center + region_half_window) window_size = end - start + 1 required_samples = max(1, window_size // fine_stride) # Split into uniform and random sampling uniform_count = int(round(required_samples * self.fine_uniform_ratio)) random_count = required_samples - uniform_count # Uniform sampling for coverage if uniform_count > 0: if window_size <= uniform_count: # If window is small, just take center center_idx = (start + end) // 2 if center_idx not in coarse_indices_set and center_idx not in candidate_fine: candidate_fine.add(center_idx) else: # Uniform spacing across window interval_size = window_size / uniform_count for i in range(uniform_count): uniform_idx = start + int(i * interval_size + interval_size / 2) uniform_idx = min(uniform_idx, end) if uniform_idx not in coarse_indices_set and uniform_idx not in candidate_fine: candidate_fine.add(uniform_idx) # Random sampling for exploration if random_count > 0: available_indices = [i for i in range(start, end + 1) if i not in coarse_indices_set and i not in candidate_fine] if available_indices: actual_random_count = min(random_count, len(available_indices)) random_indices = rng.choice(available_indices, size=actual_random_count, replace=False) for idx in random_indices: candidate_fine.add(int(idx)) return sorted(list(candidate_fine)) def _select_top_frames( self, all_sampled_scores: Dict[int, float], k: int ) -> List[int]: """ Stage 4a: Select top-ranked frames from all sampled scores. Directly select the highest scoring frames based on top_ratio. This ensures that the best discovered frames are always included. Args: all_sampled_scores: Dictionary mapping frame indices to similarity scores k: Total number of keyframes to select Returns: List of selected top frame indices """ if not all_sampled_scores or k <= 0: return [] num_computed_frames = len(all_sampled_scores) k_top = int(round(self.top_ratio * min(k, num_computed_frames))) sorted_sampled = sorted(all_sampled_scores.items(), key=lambda x: x[1], reverse=True) top_frames = [idx for idx, _ in sorted_sampled[:k_top]] return top_frames def _select_remaining_frames( self, arms: List[Dict], remaining_count: int, all_sampled_scores: Dict[int, float], selected_frames: List[int], fps: float, min_gap_sec: float, rng: np.random.Generator ) -> Tuple[List[int], List[float], List[int]]: """ Stage 4b: Select remaining frames using FOCUS arm selection strategy. Strategy: 1. Select top S = clamp(zoom_ratio * num_arms, min_arms, max_arms) arms 2. Evenly distribute remaining_count across these S arms 3. Within each arm, use interpolation or random sampling based on interpolation_method 4. Respect minimum temporal gap constraints if specified Args: arms: List of arm dictionaries remaining_count: Number of remaining frames to select all_sampled_scores: Dictionary of all sampled scores selected_frames: List of already selected frames fps: Video frame rate min_gap_sec: Minimum temporal gap between selections in seconds rng: Random number generator Returns: Tuple of (new_frames, arm_selection_probs, arm_selection_counts) - new_frames: List of newly selected frame indices - arm_selection_probs: Probability of each arm being selected - arm_selection_counts: Number of frames selected from each arm """ if remaining_count <= 0 or not arms: return [], [], [] gap_frames = int(round(min_gap_sec * fps)) if min_gap_sec > 0 else 0 selected_set = set(selected_frames) def respects_gap(cand: int, chosen_set: set) -> bool: """Check if candidate respects minimum gap constraint.""" if gap_frames <= 0: return True for frame in chosen_set: if abs(cand - frame) < gap_frames: return False return True # Compute number of top arms using zoom_ratio with hard bounds total_arms = len(arms) S = int(np.ceil(total_arms * max(0.0, min(1.0, float(self.zoom_ratio))))) S = max(self.final_min_arms, S) S = min(S, self.final_max_arms) S = min(S, total_arms) arms_sorted = sorted([(i, arm) for i, arm in enumerate(arms)], key=lambda x: x[1]['focus_score'], reverse=True) top_arm_entries = arms_sorted[:S] # Even allocation across top S arms base = remaining_count // S rem = remaining_count % S per_arm_need = [base + (1 if i < rem else 0) for i in range(S)] arm_selection_counts = [0 for _ in range(total_arms)] new_frames = [] current_selected_set = selected_set.copy() for rank, (arm_idx, arm) in enumerate(top_arm_entries): needed_count = per_arm_need[rank] if needed_count == 0: continue arm_start, arm_end = arm['start'], arm['end'] all_arm_candidates = list(range(arm_start, arm_end + 1)) available_candidates = [c for c in all_arm_candidates if c not in current_selected_set] if not available_candidates: continue if self.interpolation_method == 'uniform': # Random sampling within arm (no interpolation) if gap_frames > 0: gap_candidates = [c for c in available_candidates if respects_gap(c, current_selected_set)] candidates_to_use = gap_candidates if gap_candidates else available_candidates else: candidates_to_use = available_candidates actual_count = min(needed_count, len(candidates_to_use)) if actual_count > 0: sampled_indices = rng.choice(candidates_to_use, size=actual_count, replace=False) for idx in sampled_indices: new_frames.append(int(idx)) current_selected_set.add(int(idx)) arm_selection_counts[arm_idx] += 1 else: # Interpolation-based sampling within arm arm_sampled_indices = [idx for idx, _ in arm['sampled_scores']] arm_sampled_similarities = [score for _, score in arm['sampled_scores']] arm_estimated_scores = estimate_arm_scores( arm_sampled_indices, arm_sampled_similarities, arm_start, arm_end, self.interpolation_method ) scored_candidates = [] for cand in available_candidates: if cand in arm_estimated_scores: score = arm_estimated_scores[cand] if gap_frames == 0 or respects_gap(cand, current_selected_set): scored_candidates.append((cand, score)) if not scored_candidates: # Fallback: ignore gap if necessary for cand in available_candidates: if cand in arm_estimated_scores: scored_candidates.append((cand, arm_estimated_scores[cand])) if scored_candidates: candidates, scores = zip(*scored_candidates) candidates = list(candidates) scores = np.array(scores, dtype=np.float64) # Normalize scores to [0, 1] if scores.max() > scores.min(): scores = (scores - scores.min()) / (scores.max() - scores.min()) else: scores = np.ones_like(scores) # Apply temperature-based softmax logits = scores / max(1e-12, self.temperature) logits = logits - logits.max() # numerical stability probs = np.exp(logits) probs = probs / probs.sum() actual_count = min(needed_count, len(candidates)) if actual_count > 0: sampled_positions = rng.choice(len(candidates), size=actual_count, p=probs, replace=False) for pos in sampled_positions: idx = candidates[pos] new_frames.append(int(idx)) current_selected_set.add(int(idx)) arm_selection_counts[arm_idx] += 1 else: # Fallback: random sampling candidates_to_use = available_candidates if gap_frames > 0: gap_candidates = [c for c in available_candidates if respects_gap(c, current_selected_set)] candidates_to_use = gap_candidates if gap_candidates else available_candidates actual_count = min(needed_count, len(candidates_to_use)) if actual_count > 0: sampled_indices = rng.choice(candidates_to_use, size=actual_count, replace=False) for idx in sampled_indices: new_frames.append(int(idx)) current_selected_set.add(int(idx)) arm_selection_counts[arm_idx] += 1 # Derive per-arm probabilities from counts if remaining_count > 0: arm_selection_probs = [c / remaining_count for c in arm_selection_counts] else: arm_selection_probs = [0.0 for _ in arm_selection_counts] return new_frames, arm_selection_probs, arm_selection_counts def _prepare_sampling_details( self, coarse_indices: List[int], coarse_similarities: List[float], fine_indices: List[int], fine_similarities: List[float], arms: List[Dict], selected_frames: List[int], total_frames: int, fps: float, budget_used: int, arm_selection_probs: List[float], arm_selection_counts: List[int] ) -> Dict: """ Prepare detailed sampling information for export and analysis. This creates a comprehensive record of the sampling process including: - Coarse and fine sampling statistics - Arm information and statistics - Final selection results - Video metadata Args: coarse_indices: Frame indices sampled in coarse stage coarse_similarities: Corresponding similarity scores fine_indices: Frame indices sampled in fine stage fine_similarities: Corresponding similarity scores arms: List of arm dictionaries with statistics selected_frames: Final selected frame indices total_frames: Total frames in video fps: Video frame rate budget_used: Total number of similarity computations arm_selection_probs: Probability of each arm being selected arm_selection_counts: Number of frames selected from each arm Returns: Dictionary containing all sampling details """ def create_temporal_order(frame_indices: List[int], similarities: List[float], fps: float) -> List[Dict]: """Helper: Create temporal order list with timestamps.""" if not frame_indices: return [] combined = list(zip(frame_indices, similarities)) combined.sort(key=lambda x: x[0]) temporal_order = [] for frame_idx, score in combined: temporal_order.append({ "frame_idx": int(frame_idx), "score": float(score), "timestamp": float(frame_idx / max(1.0, fps)) }) return temporal_order # Prepare coarse sampling info coarse_sampling = { "frame_indices": [int(idx) for idx in coarse_indices], "relevance_scores": [float(score) for score in coarse_similarities], "temporal_order": create_temporal_order(coarse_indices, coarse_similarities, fps), "budget_used": int(len(coarse_indices)) } # Prepare fine sampling info fine_sampling = { "frame_indices": [int(idx) for idx in fine_indices], "relevance_scores": [float(score) for score in fine_similarities], "temporal_order": create_temporal_order(fine_indices, fine_similarities, fps), "budget_used": int(len(fine_indices)) } # Prepare arms info arms_info = { "total_arms": len(arms), "frames_per_arm": total_frames // max(1, len(arms)), "arms": [] } for i, arm in enumerate(arms): times_selected = arm_selection_counts[i] if i < len(arm_selection_counts) else 0 arm_info = { "arm_id": int(arm['arm_id']), "start_frame": int(arm['start']), "end_frame": int(arm['end']), "focus_score": float(arm['focus_score']), "focus_after_coarse": float(arm['focus_after_coarse']) if arm.get('focus_after_coarse') is not None else None, "focus_after_fine": float(arm['focus_after_fine']) if arm.get('focus_after_fine') is not None else None, "times_selected": int(times_selected), "mean_similarity": float(arm['mean_sim']), "variance": float(arm['variance']), "samples_count": int(arm['samples']) } arms_info["arms"].append(arm_info) # Prepare video metadata video_metadata = { "total_frames": int(total_frames), "fps": float(fps), "duration_seconds": float(total_frames / max(1.0, fps)), "budget_used": int(budget_used) } return { "coarse_sampling": coarse_sampling, "fine_sampling": fine_sampling, "arms_info": arms_info, "arm_selection_probabilities": [float(prob) for prob in arm_selection_probs], "final_selected_frames": [int(idx) for idx in selected_frames], "video_metadata": video_metadata }