Interview Bank

Build an AI Short-Drama Production Pipeline With Agents in 14 Days

D1 What an AI Short-Drama Production Pipeline Looks Like: Breaking Down the Stages, a Task-Graph Architecture, and Choosing Among Four Categories of Generation Models

• What does modeling a multi-step generation pipeline as a task graph buy you over a chain of sequential awaits, and what does it cost?把一条多步生成流程建成任务图，比一串顺序 await 多拿到了什么？代价是什么？

  Common in ChinaCommon overseasIntermediate#task-graph#pipeline-design

  How to reason about it · think before answering

  1. The question is what you gain, not what a DAG is. Reciting the definition scores nothing; name three capabilities the sequential version cannot have, each with a concrete scenario.
  2. Break it down by inverting the three pains of sequential code. First, parallelism is expressed by the graph itself — voice-over depends only on the lines, yet a sequential run queues it behind forty video jobs. Second, resumability — each node writes artifacts to a fixed path, so shot 37 failing does not destroy the first 36. Third, observability — you can say which node is stuck, not merely that some await is pending.
  3. Add the higher-signal point: cycle detection. Topological sort throws when dependencies form a cycle, and that is the only thing enforcing the acyclic part. Without it, a wrong dependency silently skips a step or reorders execution, which is painful to debug.
  4. Conclusion and cost: a task graph is not free. Every node needs a declared input and output artifact set, otherwise the graph is decorative. That artifact contract is also the precondition for idempotency and resume later on.
  5. Likely follow-up: should you adopt a workflow engine instead? Judge by node count and failure rate — worth it at a dozen-plus nodes with high failure and human review; for three to five nodes a hand-written graph plus topological sort is cheaper than another system to operate.

  分析过程 · 先想清楚再作答

  1. 这题的题眼在「多拿到了什么」，不在「什么是 DAG」。背出有向无环图定义的人拿不到分，答对的人会给出三样顺序版拿不到的能力，并各配一个具体场景。
  2. 怎么拆：把顺序版的三个痛点倒过来说。第一，并行的可能性被图结构直接表达——配音只依赖台词、和画面无关，顺序版里它却要排在四十次视频生成后面。第二，有断点——每个节点的产物落在磁盘固定位置，第三十七个镜头失败时前三十六个还在。第三，可观测——你能回答「现在卡在哪个节点」，顺序版只能回答「卡在某个 await」。
  3. 补一条区分度更高的：环检测。拓扑排序在发现依赖成环时抛错，这是「无环」两个字唯一的执行者；没有它，依赖写错只会表现成漏跑一步或者顺序错乱，非常难查。
  4. 结论与代价：任务图不是免费的，你必须为每个节点定义清楚输入产物与输出产物，否则它只是一张漂亮的依赖声明。这份产物契约同时也是后面做幂等与断点续跑的前提。
  5. 可预期的追问：那是不是应该直接上工作流引擎？判据是节点数与失败率——十几个节点、失败率高、需要人工介入时才值得；三五个节点的流程用一张手写的图加拓扑排序就够，引入引擎反而多一套要运维的东西。

  Key points

  • Three things sequential code cannot give: parallelism expressed by structure, resumability after failure, and knowing which node is stuck
  • Topological sort also detects cycles, the only mechanism enforcing the acyclic property
  • The cost is declaring input and output artifacts per node; without that the graph is decorative
  • That artifact contract is the precondition for idempotency and resume
  • Adopt a workflow engine based on node count and failure rate; a hand-written graph wins for three to five nodes

  答题要点

  • 三样顺序版拿不到的：并行由图结构表达、失败后有断点、能说清卡在哪个节点
  • 拓扑排序顺带做环检测，这是「有向无环」里「无环」的唯一执行者
  • 代价是必须为每个节点声明输入产物与输出产物，否则图只是装饰
  • 这份产物契约同时是后续做幂等与断点续跑的前提
  • 上不上工作流引擎按节点数与失败率判断，三五个节点手写图更划算

D2 The Script Agent: Turning a Single Sentence Into Structured Data — Character Cards, Scenes, and Shots

• To keep character definitions consistent across many episodes, where do you store that state and how do you use it?多集内容要保持人物设定一致，你会把这份设定放在哪、怎么用？

  Common in ChinaCommon overseasIntermediate#state-management#consistency

  How to reason about it · think before answering

  1. The crux is that models have no memory. Answering just concatenate previous episodes into the context invites a fatal follow-up: context grows linearly with episode count, so by episode five you pay repeatedly for four full episodes, and the model may still miss details.
  2. Break it down by separating what is invariant across episodes from what is recomputed each time. Invariant: the world, each character's appearance, personality, voice id, and a few hard rules. Recomputed: scenes and shots. Extract the invariant part into its own file and load it verbatim before generating each episode.
  3. Add the commonly missed point: the fields in that file are not only lore, they are downstream input parameters. Appearance text goes straight into image prompts, the voice id goes straight into the speech API. Keeping them beside the name means consistency is solved in one file rather than restated in three places.
  4. Choose the storage boundary by write frequency: the profile is written once and read many times, while the shot list is rewritten on every run. Mixing lifetimes in one file makes it impossible to rerun one episode without disturbing the others.
  5. Conclusion and cost: the profile itself can drift. Change a character's appearance mid-season and previously generated assets no longer match, so version the profile and include that version in the asset cache key — editing the profile then invalidates exactly the affected assets. That is only possible because it lives on its own.
  6. Likely follow-up: should you use a vector store? Usually not. Cross-episode canon is small, structured, and must be injected in full; retrieval risks dropping the one line that matters. Retrieval fits large corpora where only a few relevant items are needed.

  分析过程 · 先想清楚再作答

  1. 这题的题眼是「模型没有记忆」。答成「把前一集的输出拼进上下文」的人会被追问到崩——上下文会随集数线性膨胀，第五集时你在为前四集的全文反复付费，而且模型仍然可能漏读。
  2. 怎么拆：先分辨哪些是「跨集不变」的，哪些是「每集重算」的。不变的是世界观、人物外貌、性格、音色与几条硬规则；每集重算的是场景与分镜。把不变的那部分抽成单独的档案文件，每一集生成前原样读进去。
  3. 接着说一个容易被忽略的点：档案里的字段不只是设定，还是**下游的输入参数**。外貌描述要原样进图像提示词，音色 id 要原样进语音接口。所以它们必须和名字放在同一份档案里，一致性问题才是在一个文件里解决的，而不是散在三处各写一遍。
  4. 存放位置的判据是写入频率：档案一次生成、多次读取，分镜每跑一次就重写。生命周期不同的数据放同一个文件，你就没法只重跑一集而不动其他集。按写入频率切分文件，是这类流水线最省事的一条习惯。
  5. 结论与代价：档案本身也会漂——中途改了人物外貌，之前生成的资产就对不上了。所以档案要有版本，且资产的缓存键要包含档案版本，改档案等于让相关资产失效。这条也是把它单独存放才做得到的。
  6. 可预期的追问：那要不要上向量库做检索？多数情况下不需要。跨集共享的设定是**有限的、结构化的、必须全量注入的**，检索反而可能漏掉关键一条。检索适合的是「素材库很大且只需要相关几条」的场景。

  Key points

  • Models are stateless; cross-episode consistency comes from an external profile, not from stuffing prior episodes into context
  • Split by invariant versus recomputed: world and character profiles persist, scenes and shots are regenerated per episode
  • Appearance text and voice id are downstream input parameters, so they belong beside the character's name
  • Split files by write frequency — a read-mostly profile versus a rewritten shot list — or you cannot rerun one episode alone
  • Version the profile and fold that version into the asset cache key so edits invalidate exactly the affected assets

  答题要点

  • 模型没有记忆，跨集一致性靠外部档案而不是把前几集拼进上下文
  • 按「跨集不变」与「每集重算」切分：世界观与人物卡是档案，场景与分镜每集重来
  • 档案里的外貌与音色 id 同时是下游的输入参数，所以必须和名字放在一起
  • 按写入频率切分文件，档案读多写少，分镜每次重写，混在一起就没法只重跑一集
  • 档案要有版本并进资产缓存键，改设定才能精确地让相关资产失效

D3 Character Consistency: Character Sheets, Reference Images, and Style Locking — Keeping the Same Person the Same Person in Every Shot

• Does fixing the random seed solve character consistency? What does a seed actually lock?固定随机种子能解决角色一致性吗？它到底锁住了什么？

  Common in ChinaCommon overseasIntermediate#image-generation#reproducibility

  How to reason about it · think before answering

  1. This is a yes/no trap dressed as a concept question; answering 'yes' ends it. The hinge is 'what does it actually lock' — they are testing whether you separate reproducibility from consistency.
  2. Define it first: a seed is the random starting point of sampling. With the model, prompt and other parameters unchanged, the same seed returns the same image, so what it locks is reproducibility.
  3. Then explain why that is not enough here: every shot has a different prompt because action, scene and shot size all change. Change the prompt and the sampling path changes with it, so the same seed yields a different person. A seed is a reproducibility switch, not a consistency switch.
  4. Do not dismiss it though. It earns its place twice: single-variable debugging, where you change one word and watch the image move; and stacked with a reference image, where the reference holds the face and the seed holds the remaining degrees of freedom so a whole set looks shot on the same day.
  5. One production note: for a seed to actually reproduce anything, turn the prompt optimizer off. It defaults to on, rewrites your prompt server-side, and you never see the rewrite — which destroys reproducibility.
  6. Expect the follow-up: is seed semantics the same across vendors? No guarantee — switching vendor or even model version can make the same seed produce something else, which is one more reason to keep a provider abstraction layer.

  分析过程 · 先想清楚再作答

  1. 这是一道判断题伪装成的概念题，答「能」直接出局。题眼是「到底锁住了什么」——面试官在测你有没有把复现和一致这两件事分开。
  2. 先给定义：seed 是采样的随机起点。在模型、提示词、其余参数都不变的前提下，同一个 seed 会给出同一张图，所以它锁住的是**可复现性**。
  3. 再说为什么在短剧场景里不够用：每一镜的提示词天然不同，动作、场景、景别都在变。提示词一变，采样路径就换了，同一个 seed 出来的是完全不同的人。所以 seed 是复现开关，不是一致性开关。
  4. 但不要把它说成没用。它在两个地方非常值钱：调试时做单变量对照，只改一个词看画面怎么变；以及跟参考图叠加使用，参考图管脸，seed 管其余自由度的采样起点，两者一起才让整组图像同一天在同一个棚里拍的。
  5. 生产视角补一句：想让 seed 真的可复现，必须把提示词优化开关关掉。那个开关默认是开的，它会在服务端改写你的提示词，改写结果你看不到，可复现性也就没了。
  6. 可以预期的追问：那不同厂商的 seed 语义一样吗？答案是不保证，换厂商甚至换模型版本都可能让同一个 seed 出别的图，所以 seed 不能作为跨厂商的一致性依据——这也是要有一层 provider 抽象的原因之一。

  Key points

  • No. A seed locks reproducibility: same model, same prompt, same other parameters plus same seed returns the same image
  • Every shot in a drama has a different prompt, and a changed prompt voids the seed, so it is not a consistency mechanism
  • Its real value is single-variable debugging, and stacking with a reference image — the reference holds the face, the seed holds the rest
  • For a seed to reproduce anything you must disable the server-side prompt optimizer, which is on by default and rewrites your input
  • Seed semantics do not carry across vendors or model versions, so a seed cannot underpin cross-provider consistency

  答题要点

  • 不能。seed 锁的是可复现性：模型、提示词与其余参数都不变时，同一个 seed 给出同一张图
  • 短剧每一镜的提示词天然不同，提示词一变 seed 就失效，所以它不是一致性手段
  • 它真正的用处是单变量调试，以及与参考图叠加——参考图管脸，seed 管其余自由度的采样起点
  • 要让 seed 可复现，必须关掉服务端的提示词优化开关，它默认开启且会改写你的输入
  • seed 语义不跨厂商也不跨模型版本，不能作为跨 provider 的一致性依据

D4 From Shot to Footage: Image-to-Video, Polling Async Tasks, and Retrying Failures

• You are asked to implement a client for an asynchronous generation task. Which failure cases would you cover?让你实现一个异步生成任务的客户端，你会考虑哪些失败情况？

  Common in ChinaCommon overseasIntermediate#async-task#error-handling

  How to reason about it · think before answering

  1. The differentiator here is coverage, not code. Answering 'wrap it in try/catch and retry' usually means you have never run this kind of API in production.
  2. Describe the shape first so the failures have somewhere to hang: submit and get an id, poll for status, retrieve a URL, download to disk — four steps, four families of failure.
  3. Then enumerate: at submit, rate limiting, auth failure, invalid parameters, content moderation; at poll, the query endpoint rate limiting you, a status that never advances, or a terminal failure; at retrieve, a valid id that yields no URL; at download, an expired link, a stream cut halfway, a disk write error.
  4. Then the two that span the whole flow: timeout and process restart. A timeout is not a failure, it is 'I don't know' — you must look up the idempotency key before resubmitting. A restart means in-memory task ids are gone, so the id has to be persisted before or immediately after the request, or you will have paid-for tasks you can never reclaim.
  5. Close with a line that shows judgment: of the four steps, only the download is safely retryable on its own; a retry at any other step can create a new billable job.
  6. Expect the follow-up: if the vendor offers callbacks, do you still poll? Yes. Callbacks get lost to restarts, network blips and unreachable endpoints, so the standard is callback-first with a low-frequency sweep for tasks stuck without a terminal state.

  分析过程 · 先想清楚再作答

  1. 这题的区分度不在代码，在你能列出多少种失败。只答「加个 try catch 和重试」的人，通常没在生产上跑过这类接口。
  2. 先把任务的形状说清楚，失败点才有地方挂：提交拿标识、轮询查状态、取件换地址、下载落盘，四步是四类不同的失败。
  3. 然后逐步列：提交阶段有限流、鉴权、参数无效、内容审核；轮询阶段有查询接口自己限流、状态一直不前进、任务返回失败终态；取件阶段有标识存在但取不到地址；下载阶段有地址过期、下到一半断流、写盘失败。
  4. 接着说横跨全程的两类：超时与进程重启。超时的关键在于它不是失败而是「不知道成没成」，必须先按幂等键查一遍再决定要不要重提；进程重启意味着内存里的任务标识没了，所以标识必须先落盘再发请求，否则你会有一批花了钱却找不回来的任务。
  5. 最后给一句能体现工程判断的话：这四步里只有下载是可以无脑重试的，其余每一步的重试都可能产生一次新的计费。
  6. 可以预期的追问：厂商提供回调了还需要轮询吗？需要。回调会因为服务重启、网络抖动、地址不可达而丢失，生产上的标准做法是回调为主、低频轮询兜底扫描长时间没有终态的任务。

  Key points

  • Break failures down by the four steps: submit (rate limit, auth, invalid params, moderation), poll (query rate limit, stalled status, terminal failure), retrieve (no URL), download (expired link, cut stream, disk error)
  • A timeout means unknown, not failed: look up the idempotency key for an existing artifact before resubmitting, or you pay twice
  • Persist the task id promptly so in-flight tasks survive a process restart
  • Only the download is safely retryable on its own; retries at the other steps can create new billable jobs
  • Keep a low-frequency polling sweep even when callbacks exist, because callbacks get lost

  答题要点

  • 按四步拆失败：提交（限流、鉴权、参数无效、内容审核）、轮询（查询限流、状态停滞、终态失败）、取件（拿不到地址）、下载（地址过期、断流、写盘失败）
  • 超时不是失败而是状态未知，重试前必须先按幂等键查一遍已有产物，否则会为同一个任务付两次钱
  • 任务标识要及时落盘，进程重启后才能把在途任务认回来
  • 四步里只有下载可以无脑重试，其余每一步的重试都可能产生新的计费
  • 有回调也要保留低频兜底轮询，回调会丢

D5 Voiceover, Subtitles, and Audio Tracks: Multi-Character Voices, Timeline Alignment, and Subtitle Files

• When the synthesized speech and the shot duration disagree, which side do you adjust, and why?语音时长和画面时长对不上，你会调哪一边？为什么？

  Common in ChinaCommon overseasIntermediate#timeline#tts#pipeline-design

  How to reason about it · think before answering

  1. Answering 'stretch the shot' alone scores nothing; the hinge is 'why'. They want the reasoning for which side yields, and whether you see that this choice fixes the order of the whole pipeline.
  2. State the criterion: which distortion does the audience notice? Clipped or sped-up dialogue is audible immediately; a shot running 0.8 seconds long is not. So the picture yields.
  3. Derive the pipeline order from that: generate video at the planned duration, synthesize speech, write the measured duration back onto the shot, and let the editor pad the picture. Why not synthesize first and generate video to fit? Because video APIs expose discrete duration options — you cannot ask for exactly 6.34 seconds.
  4. Add the engineering detail that cannot be skipped: the timeline must use durations measured from the rendered files, never character-count estimates. Estimation error accumulates line by line, and by the tenth line the subtitles visibly race the picture.
  5. Then the exception, which earns points: if a shot has intrinsic rhythm — a beat cut, a transition, an action match — the picture cannot simply be stretched, and the right fix is a shorter line in the script. That is why stretched shots should be flagged for human review rather than silently rewritten.
  6. Expect the follow-up: can't you just nudge the speaking rate? You can, but it costs you — rate changes affect timbre and delivery, and they change duration again, turning a one-way flow into a loop. Make the lead-in and tail padding adjustable and spend that budget before touching the rate.

  分析过程 · 先想清楚再作答

  1. 这题只答「调画面」拿不到分，题眼在「为什么」——面试官要的是让步理由，以及你有没有意识到这个选择会决定整条流水线的排列顺序。
  2. 先给判断依据：哪一边的失真观众察觉得到。台词被切掉、或者被加速到语气变形，观众立刻听得出来；一镜比原计划长零点八秒，观众感觉不到。所以让步的是画面。
  3. 由这条判断反推流水线顺序：画面先按计划时长生成，语音合成完之后由真实时长回写镜头时长，剪辑台再去补足画面。为什么不倒过来先合成语音再按语音时长生成视频？因为视频接口的时长是有限档位的，你没法要求它精确生成 6.34 秒。
  4. 补一条不能省的工程细节：写进时间轴的必须是从落盘文件量出来的真实时长，不能是字数估算。估算误差是逐句累加的，第一句差两百毫秒，第十句就差两秒，成片上表现为字幕跟画面赛跑。
  5. 再说例外，这是加分项：如果这一镜的画面本身有强节奏（比如卡点、转场、动作衔接），画面就不能被随意拉长，这时候要回头改剧本把台词写短，而不是硬拉画面。所以被顶长的镜头应该被标记出来交给人复核，而不是程序默默改掉。
  6. 可以预期的追问：那不能微调语速吗？可以，但语速是有代价的——语速改变会同时改变音质与情绪表现，而且它会反过来再改一次时长，等于把一个单向流程变成了循环。留一点余量的做法是给留白参数一个可调区间，先动留白再动语速。

  Key points

  • Stretch the picture: clipped or sped-up dialogue is instantly audible, while a fraction of a second of extra shot length is not
  • That fixes the pipeline order: generate video at planned duration, synthesize speech, write measured duration back, pad in the edit
  • You cannot invert it and generate video to match speech, because video APIs only expose discrete durations
  • The timeline must use durations measured from rendered files; character-count estimates accumulate error line by line
  • Shots with intrinsic rhythm are the exception, so flag stretched shots for human review instead of silently rewriting them

  答题要点

  • 调画面：台词被切或被加速观众立刻察觉，镜头长零点几秒观众感觉不到
  • 由此定下流水线顺序：画面按计划时长生成，语音合成后回写真实时长，剪辑台补足画面
  • 不能倒过来按语音时长生成视频，因为视频接口的时长只有有限档位
  • 时间轴必须用落盘文件量出的真实时长，字数估算的误差会逐句累加
  • 画面有强节奏的镜头是例外，这类冲突应标记出来交人复核而不是程序默默改掉
• Where do you get subtitle timestamps from, and what do you do when the API does not provide them?字幕的时间戳你会怎么拿？接口不给时间戳时有什么替代方案？

  Common in ChinaCommon overseasIntermediate#subtitles#timeline

  How to reason about it · think before answering

  1. This tests whether you would take a dependency on an optional vendor field. Name both paths and their costs; giving only one invites a follow-up you will not enjoy.
  2. Path one is the API: TTS endpoints often expose a subtitle flag returning sentence- or word-level timestamps. Three problems — it costs an extra request to fetch, the timestamps are relative to that single audio segment, and the field structure varies by vendor. The third is the worst, because it welds your subtitle module to one provider.
  3. Path two is local alignment: you already hold every clip's measured duration and every shot's start time, so accumulating them gives the episode timeline. Zero extra requests, zero vendor coupling, and you control segmentation — one line of dialogue per cue, which is exactly the rhythm short drama wants.
  4. The key insight is that path one does not free you from path two: API timestamps are segment-relative, so you still add the shot's offset within the episode. Since you must write the alignment code anyway, make it the single source of truth.
  5. The implementation has one rule: the subtitle cursor and the shot cursor share one origin and advance together. Add a check that every cue falls inside its own shot — overflow raises no error, it just floats the previous shot's line over the next shot's picture.
  6. Expect the follow-up: what about karaoke-style word-level subtitles? That genuinely requires word-level timestamps from the API. Treat it as an optional enhancement over a local-alignment main path, degrading to sentence level when word data is unavailable.

  分析过程 · 先想清楚再作答

  1. 这题在考你会不会为一个可有可无的厂商字段引入依赖。两条路都要说得出来，还要说清各自的代价，只答一条会被追问到底。
  2. 第一条是接口给：语音合成接口通常有一个字幕开关，返回按句或按词的时间戳。它的问题有三个——要多发一次请求去取内容、时间戳是相对单段音频的、字段结构随厂商变化。第三条最要命，因为它让你的字幕模块和某一家厂商绑死了。
  3. 第二条是本地对齐：你手里已经有每段音频的真实时长和每一镜的起始时刻，累加就是整集时间轴。它零额外请求、零厂商依赖，而且断句由你自己控制——按台词行断，一句一条，天然符合短剧节奏。
  4. 关键在于**就算用第一条也逃不掉第二条**：接口给的是段内相对时间，你仍然要加上这一镜在整集里的偏移。所以本地对齐这套代码无论如何都要写，那不如让它成为唯一的真相来源。
  5. 对齐的实现只有一个要点：字幕游标和镜头游标必须共用同一个原点，逐镜推进。再配一个自检——每条字幕必须落在它所属的那一镜内，越界不会报错，只会让上一镜的台词飘到下一镜的画面上。
  6. 可以预期的追问：那按词级时间戳做卡拉OK式字幕呢？那种效果确实必须依赖接口的词级时间戳，本地对齐做不了。这时的正确做法是把它做成一个可选增强，主链路仍然走本地对齐，拿不到词级数据就降级成句级。

  Key points

  • Two sources: timestamps returned by the API, and local alignment accumulated from measured audio durations
  • The API path costs an extra request, gives segment-relative timestamps, and couples you to one vendor's field structure
  • Local alignment needs no extra request and no vendor coupling, and lets you segment per line of dialogue
  • Even with API timestamps you must add each shot's offset within the episode, so the alignment code is unavoidable anyway
  • The implementation rule is one shared origin for the subtitle and shot cursors, plus a check that each cue stays inside its own shot

  答题要点

  • 两条来源：接口返回的时间戳，以及由音频真实时长本地累加对齐
  • 接口那条的代价是多一次请求、时间戳只相对单段音频、字段结构跟厂商绑定
  • 本地对齐零额外请求零厂商依赖，断句按台词行控制，符合短剧节奏
  • 即使用接口时间戳也仍要自己加上这一镜在整集里的偏移，所以本地对齐代码无论如何都得写
  • 实现要点是字幕游标与镜头游标共用同一原点，并自检每条字幕是否落在它所属的镜头内

D6 The Editing Bay: Assembling Footage Into One Vertical Cut With ffmpeg

• An auto-generated episode comes out with audio and video out of sync. What is your debugging order, and why that order?一集自动生成的短剧成片出现音画不同步，你的排查顺序是什么？为什么是这个顺序？

  Common in ChinaCommon overseasIntermediate#debugging#av-sync#timeline

  How to reason about it · think before answering

  1. The question is about ordering, not about listing causes. The interviewer wants to see you rank checks by hit rate divided by cost, not enumerate everything you can think of.
  2. Ask yourself first: where does time come from in this pipeline? If the answer is 'a structured timeline table', then step one is comparing planned durations in that table against the real durations of the media files. Highest hit rate, lowest cost, one ffprobe call.
  3. Step two is the upstream artifacts: when the voice track is longer than the shot, the line gets cut off. It sounds almost identical to drift but the root cause is different, and it should have been caught with a warning when the timeline was built.
  4. Step three is the compose stage: stream-copy concatenation requires identical parameters across segments, and misaligned timestamps shift things; adding crossfades shortens the final cut, so subtitles drift progressively unless their timecodes are recomputed.
  5. Also mention a general move: when all three fail, stop staring at the final cut and play the normalized per-shot segments to narrow the problem to one shot. Always shrink the search space before guessing.
  6. Expect the follow-up 'how do you stop relying on human ears'. Answer: assert at timeline-build time when planned and actual durations diverge beyond a threshold, and automatically verify that the final cut's duration matches the timeline total.

  分析过程 · 先想清楚再作答

  1. 这题的题眼在「顺序」两个字，不在「有哪些原因」。面试官想看的是你会不会按「命中率乘以排查成本」来排，而不是把想到的原因罗列一遍。
  2. 先问自己一个问题：这条流水线上，时间是从哪里来的？如果答案是「一张结构化的时间轴表」，那么第一步必然是拿表里的计划时长和素材文件的真实时长去对——这一步命中率最高、成本最低，一条 ffprobe 就能查完。
  3. 第二步查上游的产物本身：配音时长超过镜头时长时，台词会被截断，听感和不同步几乎一样，但根因完全不同。这类冲突应该在生成时间轴时就打警告，而不是留到成片阶段靠耳朵发现。
  4. 第三步才查合成环节：流拷贝拼接要求各段参数一致，时间戳对不齐就会错位；加了转场则成片整体变短，字幕若没跟着重算，表现为越到后面偏得越多。
  5. 还有一条通用招式值得说出来：三步都查不出来时，不要在成片里死磕，去播归一化之后的单镜片段，把问题缩小到某一镜身上。排查多段合成的问题永远优先缩小范围。
  6. 可预期的追问是「怎么让这类问题不再靠人耳发现」。答：在时间轴生成阶段加断言（计划时长与素材真实时长的偏差超过阈值就失败），并把成片时长与时间轴总时长的一致性做成自动校验。

  Key points

  • Start with the timeline table: compare planned durations against the media files' real durations. Highest hit rate, cheapest check.
  • Then check whether the voice track exceeds the shot duration and truncates the line. That should be warned about at timeline-build time.
  • Only then look at compose: concat method, timestamp alignment, and crossfades shortening the cut without recomputed subtitle timecodes.
  • General move: play the per-shot normalized segments to isolate one shot instead of guessing on the final cut.
  • Long term, turn duration consistency into assertions and automated checks rather than relying on ears.

  答题要点

  • 先查时间轴表里的计划时长与素材真实时长是否一致，这一步命中率最高、成本最低。
  • 再查配音是否超出镜头时长导致台词被截断，这类问题应在生成时间轴时就报警告。
  • 最后查合成环节：拼接方式、时间戳对齐、转场是否让成片变短而字幕没重算。
  • 三步之外的通用招式：播单镜片段把问题缩小到某一镜，不要盯着最终产物猜。
  • 长期方案是把时长一致性做成断言与自动校验，不靠人耳兜底。

D7 One Episode Wrapped: Stringing Six Stages Into an End-to-End Pipeline and Tallying the First Bill

• In a multi-step generation pipeline, one step fails. What behavior do you want the system to have?一条多步骤的生成流水线，中间某一步失败了，你希望系统有什么行为？

  Common in ChinaCommon overseasIntermediate#pipeline-reliability#idempotency#error-handling

  How to reason about it · think before answering

  1. The discriminator is whether you answer in layers. People who just say 'retry' assume all failures are transient. Anyone who has run one of these asks first: is this failure retryable, because that decides everything downstream.
  2. Split the behavior into three layers: what to do immediately, what to do for this run, and what to do for the next run. Immediately: classify the error and retry with bounds. Only rate limits, timeouts and 5xx deserve backoff; auth failures, insufficient balance and content-policy rejections will fail a hundred more times.
  3. For this run: preserve the value already produced. Persist artifacts, elapsed time and spend for every completed step, including the money the failing step itself already burned. An implementation that just rethrows loses exactly the data a post-mortem needs.
  4. For the next run: do not pay twice. Give every node an idempotency key, store artifacts content-addressed, and make a rerun a set difference — skip what is done, redo only what is not. The bar is hard: the second run should make zero paid API calls.
  5. This matters more in generative pipelines than in ordinary backends because per-step cost is extreme. Measured on one episode in this course, the video step is 98 percent of total spend, so a full rerun burns over ten yuan, predictably rather than occasionally.
  6. Expect the follow-up 'what goes into the idempotency key'. Answer: model id, prompt, duration and resolution — anything that changes the artifact — plus an implementation version and the fingerprints of all dependencies. Never the run id, a timestamp or a random value.

  分析过程 · 先想清楚再作答

  1. 这题的区分度在于你会不会分层回答。只说「重试」的人默认失败都是瞬时的；真正做过的人会先问一句：这次失败是可重试的还是不可重试的，因为这一条决定了后面所有动作。
  2. 先把行为拆成三层：立刻要做的、这一次运行要做的、下一次运行要做的。立刻要做的是错误分类与有界重试，只有限流、超时、五开头这类瞬时错误才值得退避重试，鉴权失败、余额不足、内容审核不通过重试一百次也是白烧钱。
  3. 这一次运行要做的是保住已经产生的价值：把已完成步骤的产物、耗时、花费全部落盘，包括失败那一步自己已经花掉的钱。一个直接向上抛的实现会把这些一起丢掉，而它们恰恰是复盘时最该看的。
  4. 下一次运行要做的是不重复花钱：每个节点算一个幂等键，产物按内容寻址落盘，重跑时先做一次差集，已完成的跳过、只补做没做完的。判据非常硬——第二次运行的付费接口调用次数应当是 0。
  5. 在生成式流水线里这一条比传统后端更要紧，因为单步成本高得离谱：本课量过一集的账，视频那一环占了全部花费的九成八，从头重跑一次就是白烧十块多，而且是必然的，不是偶然的。
  6. 可预期的追问是「幂等键里该放什么」。答：模型 id、提示词、时长分辨率这类会影响产物的输入，加上实现版本号和全部依赖的指纹；绝不能放运行标识、时间戳、随机数，放了就永远不命中。

  Key points

  • Classify errors first: only retryable ones get backoff. Auth, balance and content-policy failures gain nothing from retries.
  • On failure, preserve completed steps' artifacts, timings and spend, including what the failing step itself already cost.
  • The next run uses idempotency keys and content-addressed artifacts to compute a set difference and redo only what is missing.
  • The acceptance bar is zero paid API calls on the second run, not 'no errors in the log'.
  • Per-step cost is extreme in generative pipelines, so this work converts directly into money on the bill.

  答题要点

  • 先做错误分类：可重试的才退避重试，鉴权、余额、内容审核这类重试没有意义。
  • 失败时保住已完成步骤的产物、耗时与花费，失败那一步自己花的钱也要记。
  • 下一次运行靠幂等键与内容寻址的产物做差集，只补做没做完的部分。
  • 验收判据是第二次运行的付费接口调用次数为 0，而不是「日志里没报错」。
  • 生成式流水线单步成本极高，这一条的收益能直接换算成账单上的金额。