跳到正文
阿里雲開發者社區 AI·· 11 天前AI 評分38

【直播切片工作台】第33章:AI 切片核心選段生成的四步算法

【直播切片工作台】第33章:AI 切片核心选段生成算法

AI 導讀

AI 切片透過四步純函數流程,將用戶選區轉換為 LLM 選段並生成 clips1。流程包括合併選區、按時間重疊篩選 ASR 句段、依 LLM 返回的下標組裝片段,以及合併間隙不超過 500ms 的相鄰片段。LLM 只需選擇句段下標,時間戳則由程式根據 ASR 資料取得。

正文

2026-11-11 5

版权

版权声明:

本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写 侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

简介: 本章详解AI切片核心算法——四步纯函数流水线:排序合并选区、时间重叠筛选ASR句段、LLM下标索引重组、相邻片段智能合并(≤500ms间隙),全程无副作用、强类型、可单测,确保选段精准、可靠、可追溯。(239字)

第33章:AI 切片核心:选段生成的四步算法

前一章解决了"何时执行",本章回答"执行什么"。service/ai_slice_clips.go 是 AI 切片的算法心脏:从用户选区到 LLM 可见的带下标句段列表,再到回写 video_project.clips1,由四个纯函数接力完成。

流程

数据变换链是单向的:排序合并选区 → 筛选分句 → 索引重组 → 相邻合并。每一步都是无副作用的纯函数,输入输出类型清晰([]ClipRange → []ClipRange → []Utterance → []ClipWithText),单测可以逐个击破。

flowchart LR
    A[clips0 用户选区<br/>可能乱序/重叠] --> B[sortAndMergeOverlapping<br/>ClipRanges<br/>排序+并集]
    B --> C[filterUtterances<br/>ByClips0<br/>时间重叠筛选]
    C --> D[带下标句段列表<br/>喂给 LLM]
    D --> E[LLM 返回 indices<br/>+标题/描述/话题]
    E --> F[buildClips1FromIndices<br/>越界跳过+组装]
    F --> G[mergeAdjacentClips1<br/>间隙≤500ms 合并]
    G --> H[video_project.clips1]

实现

第一步:选区规整。sortAndMergeOverlappingClipRanges 先按 start_time(次级 end_time)排序,再单遍扫描:next.Start <= cur.End 即视为重叠或相接,取并集。关键在于它返回新切片、不修改入参——调用方(创建服务与 Worker)都以"当次视图"使用合并结果,video_project.clips0 的用户原始配置不被污染。

第二步:筛选。filterUtterancesByClips0 的重叠判定是严格开区间式:u.EndTime > r.StartTime && u.StartTime < r.EndTime——分句与选区"沾边"即纳入。保持 ASR 原顺序、每句至多一次,确保下标语义稳定:LLM 看到的 [i] 行号就是这个列表的位置。

第三步:索引重组。LLM 只输出下标,不输出时间戳。buildClips1FromIndices 对每个索引做越界防御(负数、超上限直接跳过),命中即把 Utterance 转为 ClipWithText(携带词级时间戳 Words,供后续字幕对齐)。这个设计把 LLM 的输出空间压到最小——整数数组远比时间戳数组难出错。

第四步:相邻合并。mergeAdjacentClips1 复用草稿侧同一规则:next.Start >= cur.Start 且间隙 ≤ ClipMergeGapMS(500ms)则合并,text 顺序拼接、words 追加、时间取 [cur.Start, max(cur.End, next.End)]。效果是"口播中极短的换气停顿不会被切成两个镜头",与第 37 章 prepare 的合并逻辑共用常量,两侧语义永不漂移。

提示词侧的配套在 formatASRSegmentLine:每句格式化为 [i] (开始秒 - 结束秒) 文本,毫秒转秒保留两位。行号与筛选列表下标严格一致,这正是 LLM 能"引用"句段的全部机制。

📌 设计决策

  • LLM 输出下标而非时间戳:把自由度降到一维整数,越界防御一行代码完成;时间戳由代码从可信的 ASR 数据反查,杜绝模型幻觉出的时间。
  • 合并规则跨层共享:prepare.ClipMergeGapMS 同时约束选段合并与素材裁剪合并,"什么算一个镜头"的定义全局唯一。
  • 纯函数设计:四步均无 IO、无状态,测试即文档;Worker 只负责编排与落库。
  • 克隆语义:cloneClipWithText 显式深拷贝 words,避免合并过程中共享底层数组引发的隐性变异。

代码示例

片段 1 展示选区排序合并(摘自 ai_slice_clips.go,完整函数):

// sortAndMergeOverlappingClipRanges 对 clips0 做 AI 选片预处理:
// 1. 按 start_time 升序(相同则按 end_time);
// 2. 重叠或端点相接(next.Start <= cur.End)的区间取并集合并。
// 返回新切片,不修改入参;空入参返回 nil。
func sortAndMergeOverlappingClipRanges(clips []model.ClipRange) []model.ClipRange {
   
    if len(clips) == 0 {
   
        return nil
    }
    sorted := make([]model.ClipRange, len(clips))
    copy(sorted, clips)
    sort.Slice(sorted, func(i, j int) bool {
   
        if sorted[i].StartTime != sorted[j].StartTime {
   
            return sorted[i].StartTime < sorted[j].StartTime
        }
        return sorted[i].EndTime < sorted[j].EndTime
    })

    out := make([]model.ClipRange, 0, len(sorted))
    cur := sorted[0]
    for i := 1; i < len(sorted); i++ {
   
        next := sorted[i]
        // 重叠或端点相接 → 并集;有间隙则新开一段。
        if next.StartTime <= cur.EndTime {
   
            if next.EndTime > cur.EndTime {
   
                cur.EndTime = next.EndTime
            }
            continue
        }
        out = append(out, cur)
        cur = next
    }
    out = append(out, cur)
    return out
}

片段 2 展示索引重组与相邻合并(摘自 ai_slice_clips.go,节选):

// buildClips1FromIndices 根据 LLM 返回的句段下标,从筛选后的 ASR 列表组装 clips1。
// 下标越界或为负数时跳过;组装后按时间相邻规则合并(间隙 ≤ ClipMergeGapMS)。
func buildClips1FromIndices(segments []asr.Utterance, indices []int) []model.ClipWithText {
   
    if len(segments) == 0 || len(indices) == 0 {
   
        return []model.ClipWithText{
   }
    }
    out := make([]model.ClipWithText, 0, len(indices))
    for _, idx := range indices {
   
        if idx < 0 || idx >= len(segments) {
   
            continue // 越界防御:LLM 幻觉下标直接丢弃
        }
        out = append(out, utteranceToClipWithText(segments[idx]))
    }
    return mergeAdjacentClips1(out, prepare.ClipMergeGapMS)
}

// mergeAdjacentClips1 当 gap=next.Start-cur.End ≤ maxGapMS(含重叠)时合并;
// 合并后 text/words 按顺序拼接,时间取 [cur.Start, max(cur.End, next.End)]。
func mergeAdjacentClips1(clips []model.ClipWithText, maxGapMS int64) []model.ClipWithText {
   
    out := make([]model.ClipWithText, 0, len(clips))
    cur := cloneClipWithText(clips[0])
    for i := 1; i < len(clips); i++ {
   
        next := clips[i]
        gap := next.StartTime - cur.EndTime
        if next.StartTime >= cur.StartTime && gap <= maxGapMS {
   
            cur.Text += next.Text
            if next.EndTime > cur.EndTime {
   
                cur.EndTime = next.EndTime
            }
            cur.Words = append(cur.Words, append([]model.ClipWord(nil), next.Words...)...)
            continue
        }
        out = append(out, cur)
        cur = cloneClipWithText(next)
    }
    out = append(out, cur)
    return out
}

// formatASRSegmentLine 每条 ASR 行:`[i] (开始秒 - 结束秒) 文本`。
func formatASRSegmentLine(index int, u asr.Utterance) string {
   
    startSec := float64(u.StartTime) / 1000.0
    endSec := float64(u.EndTime) / 1000.0
    return fmt.Sprintf("[%d] (%.2f - %.2f) %s", index, startSec, endSec, strings.TrimSpace(u.Text))
}

小结

四个纯函数构成一条"哑数据管道":LLM 只负责一维决策(选哪些行),所有时间计算、容错、合并都由确定性代码完成。这是与不可靠组件协作的通用范式——把信任边界压到最小。

思考题

  1. 若 LLM 返回的 indices 非递增(如 [9,2,5]),当前实现按数组顺序组装再按相邻规则合并,会发生什么?是否应先排序再合并?
  2. 500ms 合并阈值对语速快的带货直播与慢节奏的访谈是否应有所区别?你会把它做成配置吗,代价是什么?

项目信息

  • GitHub仓库:Chyona/live-mixer

來源:阿里雲開發者社區 AI · developer.aliyun.com