මම මගේ ස්කෑන් විශ්ලේෂණය මෙවලමක් නිර්මාණය කළේ එක් හේතුවක් නිසා: මම ස්කෑන් රූගත කිරීම් දෙස බැලීමට, ක්රියාකාරී ක්රියාවලිය ලෙස සිදුවූ දේ අනුගමනය කළ හැකි අපූරුව ක්රියාකාරී දෙයක් අවශ්ය වන අතර, පසුව එම තේරුම් ගැනීම ස්වයංක්රියාකාරී ප්රතිඵලයක් බවට පත් කරන්න (n8n ප්රතිඵල, පියවර ලැයිස්තුව, සංයුක්ත සම්මත, මුළු පයිප්ලයින්). මිල අධික කොටසක් JSON නිර්මාණය කිරීම හෝ වාර්තාවක් නිර්මාණය කිරීම නොවේ. එය multimodal තේරුම් පියවරයි - ඔබ ආකෘතිය වෙත යැවීමට සෑම අතිරේක ෆැම්ස් සැබෑ මුදල් වේ. එබැවින් මම “Data Points” ලෙස සකස් කිරීම නතර කර එය බදු ලෙස ප්රතිකාර කිරීමට පටන් ගත්තේය. මුලින්ම වැරදි වුනේ කුමක්ද (මුලින්ම වැරදි වුනේ කුමක්ද) මගේ පළමු කැපීම පැහැදිලියි: සෑම Nth frame එකකටම sample කරන්න. එම අනුවාදය ක්රම දෙකකින් අසාර්ථක විය, දෙකම නිෂ්පාදිතය තුළ පෙනී සිටියා. මගේ ආකෘතියට සාමාන් ය උඩුගත කිරීම 6-12 මිනිත්තුවක උඩුගත කිරීමකි. එවැනි උඩුගත කිරීම් වලින් බොහෝ විට, පරිශීලකයා සිතා බැලීමට නතර කරයි, පිටුවක් කියවනවා, හෝ පාඨකයා එහි වාඩි වේ. Failure #1: it wasted frames on dead air. නරකම සිදුවීම (මගේ ප්රදර්ශනය නැවත ලිවීමට හේතු වූ සිදුවීම) කෙටි කළමනාකරණ වැඩ ක්රියාවලිය වාර්තාවක් විය, එහිදී ප්රධාන බලපත්ර අඩුපාඩු ක්ෂණිකව විවෘත හා වසා ඇත. යුනිම උපාංගය අඩුපාඩු ක්ෂණිකව පෙර සහ පසුපස ෆ්රෑම් අල්ලා - එබැවින් ආකෘතිය කිසි විටෙකත් බලපත්ර තෝරා ගැනීම දැක නැත. Failure #2: it missed the “blink-and-you-miss-it” UI moments. එම සංකේතය - ස්ථාවර කාලය සඳහා ගෙවීම් අතර තවමත් සැබෑ ක්රියාකාරීතාවය අතුරුදහන් කිරීම - මට අවශ්ය විය. ප්රධාන අදහසක්: තොරතුරු ඇති තැන්වල ෆෑම් භාවිතා කිරීම ඒ නිසාම හැමෝම හිතන්නේ “Nth frame” කියලයි.ඒකත් වැරදි. Screen recording is not a movie.It is closer to a ledger: long stable states punctuated by short transitions.සමහසු sampling සහතික කරන්නේ නරක ප් රතිඵල දෙකක්: ස්ථාවර UI සඳහා ඔබ වැඩිපුර ගෙවනවා. ඔබ සැබවින්ම රැකියාව ක්රියාත්මක වන ස්ථානයක කෙටි පිපිරීම් underfund. එක් සමාලෝචනයක් (මම එය එක් වරක් භාවිතා කරන්නම් සහ ඉදිරියට යන්නම්): සමාන ලෙස මුද්රණ කිරීම සෑම කණ්ඩායමකටම ප්රසාදයක් ගෙවීමට සමාන ය. ප්රතිඵලයක් වන්නේ වෙනස්කම් ලාභදායීව ප්රමාණය කිරීම, සංකේතයන් තුළ කාලය රැස් කිරීම සහ එම සංකේතයන් තුළ ස්ථාවර යතුරු පැතිකඩ බදු බෙදාහැරීමයි. Runtime Architecture: where the sampler is ක්රියාකාරීව, පද්ධතිය සහාය කොටස් දෙකකට බෙදී ඇත: පයිටෝන් විශ්ලේෂණය සේවා (Cloud Run සේවා ලෙස ස්ථාපනය කරන ලද) uploaded වීඩියෝ ප්රතිකාර, තෝරා Keyframes, multimodal විශ්ලේෂණය ක්රියාත්මක, සහ ව්යුහගත ප්රතිඵල ප්රතිලාභ නිෂ්පාදනය. Webhook හරහා ප්රතිඵල ලැබෙන Next.js යෙදුම සහ එය දිගටම පවත්වාගෙන යන්නේ (ඔහු ඩෙස්ක්බෝඩ් UI ක්රියා කරයි). සාම්පල්කරුවා මිල අධික ආකෘති ඇමතුමකට පෙර විශ්ලේෂකයේ ඇතුළත ජීවත් වේ. නොපෙනෙන ප් රශ්නය: sampler යනු "බොහොම හොඳ පරිගණකයක්" නොවේ.එය පාලනය ප්රදේශයක් වේ.එය "මේ වීඩියෝව කොපමණ දිගද?" "මම කොපමණ විශ්ලේෂණය සඳහා ගෙවීමට අවශ්යද?" විශ්ලේෂකයා නැවත Next.js යෙදුම වෙත අත්සන් කරන ලද webhook - HMAC-SHA256 හරහා නිවැරදි JSON බයිට්, පරීක්ෂා කර ඇත එතන තියෙන වැදගත් පාඩම: ඔබ සැබෑවටම යැවූ බයිට් ලියාපදිංචි කරන්න ( ), HTTP පුස්තකාලය විසින් නැවත සැරසිලිගත කරන ලද Python ඩිට් එකක් නොවේ. එවැනි අසාමාන්යතාවක් පැතිරෙන සහතික කිරීමේ අසාර්ථකතා ඇති කරයි. පාවිච්චි කරන්නේ Analyzer එකෙන්. timingSafeEqual data=body_bytes පෙර Adaptive keyframe sampling: score → segment → allocate → pick indexes සෑම්ප්ලර් යනු හතරවන පියවරක පයිප්ලයිනයකි: පින්තූර වෙනස් කිරීම සඳහා අඩු ගානකින් (or per step of frames) වේලාව "සමහර විට ස්ථාවර" සහ "හොඳ වෙනස්" ක්රියා කරයි. සංකේත සංකේතය සංකේතය සංකේතය සංකේතය සංකේතය සංකේතය සංකේතය සංකේතය සංකේතය සංකේතය සෑම සංකේතයකම සංකේත සංකේත තෝරා ගන්න. මෙම ව්යුහය එය ප්රායෝගිකව තබා ගන්නේ කුමක්ද. ගුණාත්මක කිරීම ලාභදායී වේ. අමුද්රව්ය සීමාකාරී වේ. බෙදාහැරීම අනාවැකිය හැකි වේ. අමුද්රව්ය පියවර යන්ත්රීය වේ. පියවර 1 — ඉලක්ක කිරීම: ලාභ දර්ශන වෙනස් කිරීම මම පාඨමාලාව මිල අඩු තබා ගැනීමේදී ආක් රමණිකයි.එහෙත් පාඨමාලාව වැඩි වියදම් කරයි නම්, මම නිකම් පයිප්පේන් එකේදී කලින් ගිණුමක් මාරු කරනවා. Screen Recording සඳහා වඩාත් විශ්වාසදායක Baseline Signal : frame difference energy Grayscale බවට පරිවර්තනය කරන්න. සතිපතා ෆැම්ස් අතර සම්පූර්ණ වෙනස ගණනය කරන්න. Diff image (optionally normalize) යන ප් රමාණය තෝරා ගන්න. ඒ අල්ලනවා : Cursor ක් රියාවලිය ටයිප් කිරීම (Blinking caret and text updates) Dropdowns සහ Modals පිටුව Transitions Hover රාජ් ය වෙනස්කම් එය පරිපූර්ණ නොවේ, නමුත් එය වේගවත් වන අතර "කමක් සිදුවූයේ" සමඟ හොඳින් සකස් වේ. පියවර 2 — සංකේත සංවර්ධනය: ශබ්ද සංඛ්යාත ක්රියාකාරී ක්රියාකාරී ක්රියාකාරී වන්න පර්ෆියුම් පර්ෆියුම් පර්ෆියුම් පර්ෆියුම් පර්ෆියුම් පර්ෆියුම් පර්ෆියුම් පර්ෆියුම් පර්ෆියුම් පර්ෆියුම් පර්ෆියුම් එබැවින් මම හයිස්ටෙරෙස් සමඟ සරල තත්ව යන්ත්රය භාවිතා කරන්නේ: Rolling Average ස්කූටරයක් තබා ගන්න. "උණුසුම්" කොටසක් බවට මාරුවීම, රෝලට් ස්කූටරය මට්ටමකට වඩා ඉහළ යන විට. එය පහළ මට්ටමේ යට වැටෙන විට නැවත "සීතල" වෙත මාරු වේ. අඩුම කොටස් දිගක් අනුගමනය කරන්න මම සිය ගණනක් මයික්රොසෙග්රෑම් නිර්මාණය නොකරමි. එය ඉංජිනේරුවාත්මක නොවේ: ස්ථාවර හැසිරීම, අඩු සංවේදීතාවය, සහ අනාවැකි කළ හැකි ප්රතිඵලයක්. පියවර 3 – බන්ධනාගාරයන් සහිත වියදම් ප් රතිසංස්කරණය පිරිසිදු ප්රමාණවත් බෙදාහැරීම ප්රමාණවත් නොවේ.එය සෘජුවම අසාර්ථක වන අතර එය කෙටි කොටස් බඩගින්නේ විය හැකිය. එබැවින් මගේ බෙදාහැරීමේ නීති තුනක් ඇත: සෑම සංකේතයක්ම මට්ටමක් ලැබේ (min_frames_per_segment) කිසිදු සංකේතයක් cap (max_frames_per_segment) ට වඩා වැඩි විය නොහැක. ඉතිරි වියදම ප් රමාණයෙන් සේවා අංශයට බෙදා හදා ගනී. මෙම බෙදාහැරීම ස්ථාවර වන අතර රෝග ලක්ෂණ වළක්වා ගනී. පියවර 4 - සංකේත ඇතුළත ඉංජිනේරු තෝරා ගැනීම සංකේතය සඳහා K ෆ්රෑම් සකස් කරන විට, මම සංකේතය පුරා පැතිරෙන K ඉනිම තෝරා ගනිමි: සෑම විටම සංකේත ආරම්භය ඇතුළත් කරන්න (පරිවාහන ප්රශ්න). සෑම විටම කොටස් අවසානය ඇතුළත් කරන්න (final state matters). ඉතිරි කොටස් සම්පූර්ණයෙන්ම අතුරුදහන් කරමු. ඊළඟට මට වැඩි විශ්වාසභංගයක් අවශ් ය නම්, මම ලකුණු ප්රමාණයට දේශීය ප්රමාණයට විරුද්ධ විය හැක, නමුත් සාමකාමීව ප්රමාණ තෝරා ගැනීම ශක්තිමත් ප්රමුඛතාවක් වන අතර කේතය කෙටියෙන් තබා ගනී. සම්පූර්ණ ක්රියාත්මක කිරීමේ ක්රියාත්මක කිරීම් (Scoring + Segmentation + Allocation + Extraction) මෙම ලිපිය copyable කිරීමට, මෙන්න ඔබ ඕනෑම MP4 සමග ක්රියාත්මක කළ හැකි තනි Python script.It තෝරා ගන්නේ keyframes පරිහරණය හා එය output directory වෙත ලිවීමට. පෞද්ගලිකත්වය : විවෘත Python අංකල් ධාවනය : python adaptive_keyframes.py --video input.mp4 --budget 60 --out ./keyframes මෙන්න : adaptive_keyframes.py import argparse import os from dataclasses import dataclass from typing import List, Tuple import cv2 import numpy as np @dataclass class Segment: start: int # inclusive frame index end: int # exclusive frame index score: float @property def length(self) -> int: return max(0, self.end - self.start) def frame_diff_score(prev_bgr: np.ndarray, curr_bgr: np.ndarray) -> float: """Cheap per-frame change score in [0, 1] (roughly). Uses grayscale mean absolute difference normalized by 255. """ prev_gray = cv2.cvtColor(prev_bgr, cv2.COLOR_BGR2GRAY) curr_gray = cv2.cvtColor(curr_bgr, cv2.COLOR_BGR2GRAY) diff = cv2.absdiff(prev_gray, curr_gray) return float(diff.mean() / 255.0) def compute_scores( cap: cv2.VideoCapture, stride: int = 1, max_frames: int | None = None, ) -> Tuple[List[float], int]: """Return (scores, total_frames_read). scores[i] is the change score between frame i and i+stride (based on sampled reads). """ scores: List[float] = [] ok, prev = cap.read() if not ok: return scores, 0 frame_idx = 1 frames_read = 1 while True: # Skip stride-1 frames between comparisons. for _ in range(stride - 1): ok = cap.grab() if not ok: return scores, frames_read frame_idx += 1 frames_read += 1 if max_frames is not None and frames_read >= max_frames: return scores, frames_read ok, curr = cap.read() if not ok: return scores, frames_read frames_read += 1 s = frame_diff_score(prev, curr) scores.append(s) prev = curr frame_idx += 1 if max_frames is not None and frames_read >= max_frames: return scores, frames_read def segment_scores( scores: List[float], window: int = 8, hot_thresh: float = 0.030, cold_thresh: float = 0.020, min_len: int = 12, ) -> List[Segment]: """Convert per-step scores into segments with a utility score. Uses a rolling mean with hysteresis to avoid segment flicker. """ if not scores: return [] # Rolling mean via cumulative sum. x = np.array(scores, dtype=np.float32) c = np.cumsum(np.insert(x, 0, 0.0)) def roll_mean(i: int) -> float: j0 = max(0, i - window + 1) n = i - j0 + 1 return float((c[i + 1] - c[j0]) / n) segments: List[Segment] = [] state_hot = False seg_start = 0 seg_scores: List[float] = [] for i in range(len(scores)): rm = roll_mean(i) if state_hot: seg_scores.append(scores[i]) if rm < cold_thresh: # Close hot segment at i+1 seg_end = i + 1 if seg_end - seg_start < min_len: # Too short: merge into previous if possible, else keep. pass segments.append(Segment(seg_start, seg_end, float(np.mean(seg_scores) if seg_scores else 0.0))) # Start cold state_hot = False seg_start = seg_end seg_scores = [] else: if rm > hot_thresh: # Close cold segment seg_end = i + 1 cold_score = float(np.mean(scores[seg_start:seg_end]) if seg_end > seg_start else 0.0) segments.append(Segment(seg_start, seg_end, cold_score)) # Start hot state_hot = True seg_start = seg_end seg_scores = [] # Close tail tail_end = len(scores) if tail_end > seg_start: tail_score = float(np.mean(scores[seg_start:tail_end])) segments.append(Segment(seg_start, tail_end, tail_score)) # Merge very short segments to keep output stable. merged: List[Segment] = [] for seg in segments: if not merged: merged.append(seg) continue if seg.length < min_len: prev = merged[-1] combined = Segment(prev.start, seg.end, (prev.score * prev.length + seg.score * seg.length) / max(1, (prev.length + seg.length))) merged[-1] = combined else: merged.append(seg) # One more pass: ensure non-empty and strictly increasing. cleaned: List[Segment] = [] for seg in merged: if seg.length <= 0: continue if cleaned and seg.start < cleaned[-1].end: seg = Segment(cleaned[-1].end, seg.end, seg.score) if seg.length > 0: cleaned.append(seg) return cleaned def allocate_frames( segments: List[Segment], budget: int, min_frames_per_segment: int = 1, max_frames_per_segment: int = 30, ) -> List[int]: """Allocate keyframes to segments using floor + proportional + cap.""" if budget <= 0 or not segments: return [] n = len(segments) min_total = min_frames_per_segment * n # If budget is smaller than the floor, distribute 1-by-1. if min_total >= budget: alloc = [0] * n for i in range(budget): alloc[i % n] += 1 return alloc utilities = np.array([max(0.0, s.score) for s in segments], dtype=np.float64) total_u = float(utilities.sum()) alloc = [min_frames_per_segment] * n remaining = budget - min_total if total_u == 0.0: raw = np.full(n, remaining / n, dtype=np.float64) else: raw = utilities * (remaining / total_u) # Add integer parts. for i in range(n): add = int(raw[i]) alloc[i] = min(max_frames_per_segment, alloc[i] + add) allocated = sum(alloc) # Distribute leftover by fractional parts, respecting caps. if allocated < budget: frac = raw - np.floor(raw) order = np.argsort(-frac) # descending fractional idx = 0 safety = 0 while allocated < budget and safety < 10_000: i = int(order[idx % n]) if alloc[i] < max_frames_per_segment: alloc[i] += 1 allocated += 1 idx += 1 safety += 1 # If we somehow exceeded budget due to caps/floor interplay, trim from lowest utility. if allocated > budget: order = np.argsort(utilities) # ascending utility idx = 0 safety = 0 while allocated > budget and safety < 10_000: i = int(order[idx % n]) if alloc[i] > 0 and alloc[i] > min_frames_per_segment: alloc[i] -= 1 allocated -= 1 idx += 1 safety += 1 return alloc def pick_indices_for_segment(seg: Segment, k: int) -> List[int]: """Pick k indices in [seg.start, seg.end] over the score-step domain. Note: scores are defined between frames; we later map these to actual frames. """ if k <= 0 or seg.length <= 0: return [] if k == 1: return [seg.start] # Evenly spaced across [start, end-1] xs = np.linspace(seg.start, seg.end - 1, num=k) idxs = sorted({int(round(x)) for x in xs}) # Ensure exactly k by filling gaps if rounding collapsed points. while len(idxs) < k: # Insert midpoints between existing points. candidates = [] for a, b in zip(idxs, idxs[1:]): if b - a >= 2: candidates.append((a + b) // 2) if not candidates: # Fall back: walk forward. x = idxs[-1] if x + 1 < seg.end: idxs.append(x + 1) else: break else: for c in candidates: if c not in idxs and seg.start <= c < seg.end: idxs.append(c) if len(idxs) >= k: break idxs = sorted(idxs) # Trim if we overshot. return idxs[:k] def select_keyframe_indices(segments: List[Segment], alloc: List[int], stride: int = 1) -> List[int]: """Return concrete frame indices (0-based) to extract from the video.""" chosen: List[int] = [] for seg, k in zip(segments, alloc): step_idxs = pick_indices_for_segment(seg, k) # Map score-step domain to frame indices. # score i corresponds to diff between frame i and i+stride; # picking frame i is a reasonable representative. for si in step_idxs: chosen.append(si * stride) chosen = sorted(set(chosen)) return chosen def extract_frames(video_path: str, frame_indices: List[int], out_dir: str) -> None: os.makedirs(out_dir, exist_ok=True) cap = cv2.VideoCapture(video_path) if not cap.isOpened(): raise RuntimeError(f"Failed to open video: {video_path}") frame_set = set(frame_indices) max_idx = max(frame_set) if frame_set else -1 idx = 0 saved = 0 while idx <= max_idx: ok, frame = cap.read() if not ok: break if idx in frame_set: path = os.path.join(out_dir, f"frame_{idx:06d}.jpg") ok2 = cv2.imwrite(path, frame) if not ok2: raise RuntimeError(f"Failed to write: {path}") saved += 1 idx += 1 cap.release() if saved == 0 and frame_indices: raise RuntimeError("No frames were saved; check indices and video decoding") def main() -> None: ap = argparse.ArgumentParser() ap.add_argument("--video", required=True, help="Path to input video") ap.add_argument("--out", required=True, help="Output directory for keyframes") ap.add_argument("--budget", type=int, default=60, help="Total keyframes to extract") ap.add_argument("--stride", type=int, default=2, help="Compare every Nth frame for scoring") ap.add_argument("--window", type=int, default=8, help="Rolling window for segmentation") ap.add_argument("--hot", type=float, default=0.030, help="Enter hot segment threshold") ap.add_argument("--cold", type=float, default=0.020, help="Exit hot segment threshold") args = ap.parse_args() cap = cv2.VideoCapture(args.video) if not cap.isOpened(): raise RuntimeError(f"Failed to open video: {args.video}") scores, frames_read = compute_scores(cap, stride=args.stride) cap.release() segments = segment_scores(scores, window=args.window, hot_thresh=args.hot, cold_thresh=args.cold) alloc = allocate_frames(segments, budget=args.budget, min_frames_per_segment=1, max_frames_per_segment=max(2, args.budget)) keyframes = select_keyframe_indices(segments, alloc, stride=args.stride) # Keep within a hard limit (rounding/uniqueness can change count). if len(keyframes) > args.budget: keyframes = keyframes[: args.budget] extract_frames(args.video, keyframes, args.out) print(f"frames_read={frames_read}") print(f"scores={len(scores)} segments={len(segments)}") print(f"budget={args.budget} selected={len(keyframes)}") if segments: hot_share = sum(1 for s in segments if s.score > args.hot) / len(segments) print(f"segment_hot_share={hot_share:.2f}") if __name__ == "__main__": main() මේ ලිපිය නිවැරදිව නිවේදනය කෙරේ: එය ස්ථාවර කොටස් ලැයිස්තුවක් නිර්මාණය කරයි. එය ඔබ කිසිවිටෙකත් ඔබගේ ව්යාපාරික ව්යාපාරික ව්යාපාරික ව්යාපාරික ව්යාපාරික ව්යාපාරික ව්යාපාරික ව්යාපාරික ව්යාපාරික ව්යාපාරික ව්යාපාරික ව්යාපාරික ව්යාපාරික ව්යාපාරික. එය downstream විශ්ලේෂණය සඳහා deterministic frame files ලියයි. මගේ නිෂ්පාදන සේවාව තුළ, ආකෘති ආකෘති multimodal ඇමතුම (Gemini හරහා මගේ පෞද්ගලිකත්වය තුළ), සහ ප්රතිඵලදායී විශ්ලේෂණ ප්රතිදානය අත්සන් Webhook හරහා Next.js යෙදුම වෙත ආපසු එවනු ලැබේ. google-generativeai Practical tuning notes (the stuff that matters after the first demo) ඔබ ආකෘතිය ක්රියා කරන විට, ජයග්රාහකයින් දුර්වල සැබෑ ලෝකයේ වාර්තා යටතේ සංවේදී හැසිරීමෙන් පැමිණෙනු ඇත. 1) ඔබේ අන්තර්ගතයට ගැලපෙන පියවරක් තෝරන්න ඔබ 30 FPS ලියාපදිංචි මත සෑම පින්තූරයක්ම ලකුණු කළහොත්, ඔබට සෑම තැනකම පුංචි පාඨක ක්රියාකාරකම් සොයා ගත හැකිය.එය සෑම විටම නරක දෙයක් නොවේ, නමුත් එය ඔබේ "නිර්මාණය" සංඥාව වැඩි කළ හැකිය. 2–5 පියවරක් වේදිකාව සඳහා හොඳ ආරම්භක ස්ථානයක් වේ.ඔබ තවමත් UI වෙනස්කම් වලට සංවේදී වේ, නමුත් ඔබ අර්බුද ශබ්දය අතුරුදහන් කරයි. 2) හයිස්ටෙරෙස් segment flicker වළක්වා ගනී භාවිතය සහ තනි අර්බුදයක් සමඟ, ඔබ නිතරම කැපීම වටා උණුසුම් / සීතල අතර පිපිරෙනු ඇත. hot_thresh cold_thresh Hysteresis ඔබට ස්ථාවර කොටස් ලබා දෙයි සහ ව්යාපාර අනාවැකි ලෙස හැසිරෙනු ඇත. 3) තට්ටුව සහ මඳබව විකල්පයක් නොවේ තට්ටුවක් නොමැතිව, කෙටි කොටස් අර්ධයක් දක්වා සකස් කළ හැකි අතර, ඔබ සැලකිලිමත් වූ නිවැරදි මයික්රෝ-බර්ස්ට් අහිමි වනු ඇත. කොප්පයක් නොමැතිව, දිගු "සැලකිලිමත්" සංකේතයක් ඔබේ මුළු ආදායම අහිමි කළ හැකි අතර ඔබ වැඩ ක්රියාවලියෙන් ඉතිරි කොටස් අහිමි වනු ඇත. 4) ඔබ යැවූ බයිට් සෑම විටම අත්සන් කරන්න ඔබ අත්සන් කලොත් යවන්න , HTTP පුස්තකාලය ඔබ අත්සන් කරන දේට වඩා වෙනස් යතුරු ඇණවුම් / ප්රමාණයන් සහිතව serialize විය හැකිය.This produces intermittent verification failures that feel like ghosts. json.dumps(payload) json=payload සැබෑ බයිට් අත්සන් කිරීම ( මේ සඳහා වැදගත් වන්නේ විශ්ලේෂණය ප්රතිලාභය - ඔබේ පරිස්සමින් තෝරාගත් යතුරු පද්ධති පවත්වාගෙන යන යතුරු පද්ධති - pipeline හි මිල අධිකම අමුද්රව්ය වේ. data=body_bytes නිෂ්පාදනය තුළ මෙම නිර්මාණ මට්ටම් ඇයි සාම්පලර් වැඩ කරන නිසා එය දැඩි සීමාවන් දෙකක් ගරු කරයි: තෝරාගත් ෆ්රෑම් සහිත වියදම් මට්ටම්, වීඩියෝ දිගක් නොවේ.බොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩොඩො Scoring is a linear pass; Segmentation is a linear pass; Allocation is linear with tiny constant factors. - ක් රියාකාරිත්වය සංකීර්ණ වේ. වඩාත්ම වැදගත්: sampler මගේ පද්ධතිය ක්රියාත්මක කළ හැකි දෙයක් ලෙස හැසිරෙනු ඇත. 12 මිනිත්තු වීඩියෝව "සෑහෙන්න දිගු"ද යන්න ගැන සාකච්ඡා කිරීම වෙනුවට, මම කොපමණ ෆෑම් මිලදී ගැනීමට සූදානම්දැයි තීරණය කරමි. ඒක තමයි මේ කතාව: සාධාරණ ප් රතිශතය සාධාරණ ප් රතිශතයක්.
