利用 Amazon Bedrock Data Automation（BDA）对视频数据进行自动化处理与检索

企业官方账号

2025-05-16 08:53:23

当前点播视频平台搜索功能主要是基于视频标题的关键字检索。对于点播平台而言，我们希望可以通过优化视频搜索体验满足用户通过模糊描述查找视频的需求，从而提高用户的搜索体验。借助 Amazon Bedrock Data Automation（BDA）技术，运用 AI 自动剖析视频内容，提取关键信息，通过向量搜索达成语义智能匹配，实现多角度（视频关键字、台词、场景描述）视频检索，有利于提升用户搜索效率，增加平台活跃度，也为视频创作者创造更多曝光机遇。在下文中，我们会基于 Amazon Bedrock Data Automation（BDA）实现视频处理与双路召回的解决方案进行描述。

Amazon Bedrock Data Automation 功能概述

Bedrock Data Automation（BDA）是基于云的服务，借助生成式 AI，能将文档、图像、视频和音频等非结构化内容，高效转化为结构化格式，自动提取、生成关键信息，助力开发人员快速构建应用程序，执行复杂工作流程。目前支持 us-east-1 和 us-west-2 两个地区。

从输出结果角度，BDA 支持标准结果和自定义结果的输出，当用户选择自定义结果的输出时，可以用 prompt 的方式去生成想要的结果。自定义的结构可以保存为蓝图为 BDA 项目所使用。目前自定义结果的输出支持文档和图片。

标准结果的输出则对四种不同类型的数据源做了预定义的输出结构，例如对于文档数据，标准输出结果如下图所示，从而可以为不同下游应用所用：

您可以手动在操作台上测试 DBA 的各种功能包括文档，图片，视频和音频等，以下我们以视频 Demo 为例。

首先找到 Amazon Bedrock 在控制台的位置，然后点击左侧工具栏中 Data Automation 下的 Demo：

在工具栏中的 Demo中，您可以选择用已存在 Demo 上的数据，或从本地/Amazon S3 中上传的数据做为源数据进行测试：

最后点击 Generate result，便可以在左侧输出相关结果，并可以选择标准数据结果或前面蓝图制定好的自定义输出结果。

在视频处理中，BDA 可以生成完整视频摘要、章节摘要、提取 IAB 分类法、完整音频脚本、视频文字、进行徽标检测和内容审核等。在推出 BDA 之前，传统对视频的 RAG 还是基于手工对切片处理，并手工通过 SaaS 或大模型对视频声音摘录，文字提取。BDA 简化了这一流程，输出的内容以 Json 文档的形式呈现。

Json 文档结构目前版本主要包含以下几个部分：Metadata、shots、chapters、video、statistics

Metadata 包含视频的基本信息，如资产 ID、格式、帧率、编码、时长、分辨率等。
Shots 是 DBA 自动将视频分割成多个镜头，每个镜头包括开始和结束的时间码，开始和结束的时间戳（毫秒），开始和结束的帧索引，持续时间，置信度，所属章节索引。
Chapters 是 DBA 自动将视频分割成多个章节，每个章节包含开始和结束的时间码，开始和结束的时间戳（毫秒），开始和结束的帧索引，持续时间，包含的镜头索引，章节摘要，转录文本，IAB 分类，内容审核等。其中，IAB 分类可以帮助广告找到视频中可以切入的点，让广告的引入可以更加流畅。
Video 里面包含了视频总结和视频整体的转录文本。视频整体的转录文本包含了每个章节的转录文本。
Statistics 主要是对视频数据的统计，包含了镜头数量统计，章节统计和视频中发言人的数量。

在本文中，我们主要用到了 DBA 视频处理的处理手段，来将视频数据转化成 json 结构数据为用户提供文字搜索功能。以下是相关架构的介绍。

视频检索流程

前置过程

为了更加方便快速地部署和使用本方案，我们创建了基于AWS CDK 的全自动化部署方法: ：sample-for-video-search。您可以按照 README 来将整套环境资源快速部署在自己的亚马逊云科技环境中，随后便可以开始以下检索流程：

1. 数据上传

在我们的案例中，平台可以将视频文件（mp4/mov 格式）上传至 Amazon S3 路径中，例如 s3://<bucket-name>/video-input/，作为后续处理的源数据。

2. 视频处理与视频 Json 文件生成

当 Amazon S3 路径中有文件上传完毕时，Amazon EventBridge 会监测到相关事件并触发 Amazon Lambda 调用 Amazon Bedrock API 对视频文件按照实现创建的 DBA 项目进行处理。DBA 项目是利用 Lambda 在视频处理流程前创建。视频处理完成后，生成相应的 json 文件，并将其传回 Amazon S3 存储 s3://<bucket-name>/video-output/。相关示例代码如下：

# invokes bda by async approach with a given input file
def invoke_insight_generation_async(
        input_s3_uri,
        output_s3_uri,
        data_project_arn, blueprints = None):

    # Extract account ID from project ARN
    account_id = data_project_arn.split(':')[4]
    
    # Construct default Profile ARN using fixed us-west-2 region，which currently supports the 2 models required in the following process
    profile_arn = f"arn:aws:bedrock:us-west-2:{account_id}:data-automation-profile/us.data-automation-v1"

    payload = {
        "inputConfiguration": {
            "s3Uri": input_s3_uri
        },
        "outputConfiguration": {
            "s3Uri": output_s3_uri
        },
        "dataAutomationConfiguration": {
            "dataAutomationProjectArn": data_project_arn,
            "stage": "LIVE"
        },
        "dataAutomationProfileArn": profile_arn,
        "notificationConfiguration": {
            "eventBridgeConfiguration": {"eventBridgeEnabled": True},
        }
    }

    try:
        response = bda_client_runtime.invoke_data_automation_async(**payload)
        print(f"Successfully invoked data automation: {response}")
        return response
    except Exception as e:
        print(f"Error invoking data automation: {str(e)}")
        raise

3. 基于视频 Json 文件的 Embedding 处理

之后，Amazon S3 文件生成的规则会再次触发的 Amazon EventBridge，使其启动 Amazon Lambda 调用 Amazon Bedrock 集成的 amazon.titan-embed-text-v2:0 模型，为 Json 文件内容做向量化用于后续查询。

try:
        response = bedrock_client.invoke_model(
            modelId="amazon.titan-embed-text-v2:0",
            contentType="application/json",
            accept="application/json",
            body=json.dumps({
                "inputText": text
            })
        )

由于每个 chapter 内的 transcripts 较长，为达到更好的检索效果，会对其进行切片处理，最后将整理好的数据结构存入 DocumentDB。由于是简易环境，我们基于字符长度做了简单的切片处理：

def split_transcript_into_chunks(self, transcript_text, max_chunk_size=500, min_chunk_size=100):
        if not transcript_text:
            return []

        # 如果输入是字典，尝试提取文本
        if isinstance(transcript_text, dict):
            if 'text' in transcript_text:
                transcript_text = transcript_text['text']
            elif 'representation' in transcript_text and 'text' in transcript_text['representation']:
                transcript_text = transcript_text['representation']['text']
            else:
                transcript_text = json.dumps(transcript_text)

        # 确保输入是字符串
        if not isinstance(transcript_text, str):
            transcript_text = str(transcript_text)

        # 按句子分割（句号、问号、感叹号后跟空格）
        # 使用更宽松的模式，允许句子结束后有任何数量的空格
        sentences = re.split(r'([.!?])\s*', transcript_text)

        # 处理分割结果，将标点符号重新附加到句子
        processed_sentences = []
        i = 0
        while i < len(sentences):
            sentence = sentences[i]

            # 如果是标点符号，附加到前一个句子
            if i > 0 and sentence in ['.', '!', '?']:
                processed_sentences[-1] += sentence
            else:
                processed_sentences.append(sentence)

            i += 1

        # 将句子组合成块
        chunks = []
        current_chunk = ""

        for sentence in processed_sentences:
            # 跳过空句子
            if not sentence.strip():
                continue

            # 如果当前块加上新句子会超过最大大小，保存当前块
            if current_chunk and len(current_chunk) + len(sentence) + 1 > max_chunk_size:
                if len(current_chunk) >= min_chunk_size:
                    chunks.append(current_chunk.strip())
                current_chunk = sentence
            else:
                if current_chunk:
                    current_chunk += " " + sentence
                else:
                    current_chunk = sentence

        # 添加最后一个块
        if current_chunk and len(current_chunk) >= min_chunk_size:
            chunks.append(current_chunk.strip())

        return chunks

将 Json 文件向量化后，我们将 Json 文件的数据格式进行了处理，使其在 Amazon DocumentDB 中能更好地做检索。

def flatten_video_data(self, video_data, video_name):
        flattened_data = []
        
        # 处理章节
        chapters = video_data.get('chapters', [])
        for chapter in chapters:
            chapter_summary = chapter.get('chapter_summary', {})
            flattened_chapter_summary = {
                "video_name": video_name,
                "source": f"chapter_{chapter.get('chapter_index', 0)}_summary",
                "text": chapter_summary.get('text', ""),
                "embedding": chapter_summary.get('embedding', []),
                "start_timestamp_millis": chapter.get('start_timestamp_millis'),
                "end_timestamp_millis": chapter.get('end_timestamp_millis')
            }
            flattened_data.append(flattened_chapter_summary)

            # 处理章节转录块
            transcript_chunks = chapter.get('transcript_chunks', [])
            for chunk in transcript_chunks:
                flattened_chunk = {
                    "video_name": video_name,
                    "source": f"chapter_{chapter.get('chapter_index', 0)}_transcript_chunk_{chunk.get('chunk_index', 0)}",
                    "text": chunk.get('text', ""),
                    "embedding": chunk.get('embedding', []),
                    "start_timestamp_millis": chapter.get('start_timestamp_millis'),
                    "end_timestamp_millis": chapter.get('end_timestamp_millis')
                }
                flattened_data.append(flattened_chunk)

        return flattened_data

对视频生成的文字做完向量化和数据格式的整理后，便可以将其存入 Amazon DocumentDB 为用户的检索做准备了。

4. 用户搜索文字的 Embedding 转换

将向量和文字存入 Amazon DocumentDB 后，用户便可以从前端输入搜索文字并选择搜索模式（文本搜索或场景搜索），系统会使用 amazon.titan – embed – text – v2:0 模型对搜索文字进行向量化，以便后续进行向量匹配。

flowchart LR

  A([接收搜索请求])-->B[解析查询参数]
  B-->C{执行混合搜索}
  C-->D[向量搜索]
  C-->E[文本搜索]
  D-->F([合并搜索结果])

  E-->F
  F-->G([使用Cohere重排序])
  G-->H([返回最终结果])

双路召回与结果重排序：Amazon Lambda 利用转换后的向量，同时进行文字和向量的双路召回。在向量检索中，使用 Amazon Document DB 的聚合 pipeline 对向量相似度进行搜索，根据搜索模式过滤结果，最后通过 project 返回相应字段；

$project：返回相应字段如下：

text: "<sample_text>"
video_name: "<sample_name>.mov" 
source: "chapter_6_summary"
start_timestamp_millis: 181666
end_timestamp_millis: 227100

similarity：与向量索引一样，我们选择余弦相似度（cosine）来衡量查询向量和文档向量之间的相似性。

top_k：返回的视频数

filter_condition：由于我们的搜索分为场景搜索和台词文本搜索，便以此为筛选，从而用户可以自行选择搜索场景。

pipeline = [
                {
                    "$search": {
                        "vectorSearch": {
                            "vector": query_embedding,
                            "path": "embedding",
                            "similarity": "cosine",
                            "k": top_k * 3,  # Fetch more results since we'll filter them
                            "efSearch": 64
                        }
                    }
                },
                # Add a $match stage to filter results based on search mode (scene/transcripts)
                {
                    "$match": filter_condition
                },
                # Limit to top_k results after filtering
                {
                    "$limit": top_k
                },
                {
                    "$project": {
                        "text": 1,
                        "video_name": 1,
                        "source": 1,
                        "start_timestamp_millis": 1,
                        "end_timestamp_millis": 1
                    }
                }
            ]

文字检索则基于源文件为 json 文本的特点，通过 $text 操作符利用倒排索引进行文本搜索。倒排索引是一种用于快速查找包含特定单词或短语的文档的数据结构。与传统的正向索引（从文档到单词的映射）不同，倒排索引是从单词到文档的映射。

检索完成后，由于同一个 source 可能会同时被向量检索和文字检索出来，从而在合并结果时做了去重处理：

all_results = processed_vector_results + processed_text_results
            # Remove duplicates based on '_id' and prefer text search results
            unique_results = []
            seen_ids = set()
            for result in reversed(all_results):  # Reverse the list to process text results first
                result_id = result['_id']
                if result_id not in seen_ids:
                    seen_ids.add(result_id)
                    unique_results.append(result)
            unique_results.reverse()  # Reverse the list back to original order
            # Return unique results directly
            return {"results": unique_results}

最后通过 Amazon Bedrock 集成的 cohere.rerank – v3 – 5:0 模型对召回结果进行重排序，并对输出结果进行了整理，而后按照相关度分数返回最符合用户需求的视频。

response = self.bedrock_client.invoke_model(
            modelId="cohere.rerank-v3-5:0",
            contentType="application/json",
            accept="application/json",
            body=json.dumps({
                "api_version": 2,
                "query": query,
                "documents": documents,
                "top_n": len(documents)
            })
        )

总结

将 BDA 作为处理视频的手段之一减少了手工分镜，取帧等的工序。无服务器的架构为整体的设计提供了低成本的计算资源，后续的数据的存储选用 DocumentDB 也是希望可以用灵活地手段做 Json 数据处理。在 AI 模型的加持下，希望本文能够为 AI 与视频搜索提供了一种新思路。

持续改进

作为新功能，目前 BDA 的视频处理功能仅限于标准输出，可以考虑后续加入 Amazon Nova 模型来丰富视频场景描述数据，从而进一步提升视频内容分析的精细度。Amazon Nova 模型能够对视频进行抽帧理解，从每一帧图像中提取更丰富的信息，例如视频场景中的物体细节、变化等。这些额外的信息将被整合到视频检索系统中，使得用户在搜索视频时，能够获得更精准、更丰富的搜索结果。

*前述特定亚马逊云科技生成式人工智能相关的服务仅在亚马逊云科技海外区域可用，亚马逊云科技中国仅为帮助您了解行业前沿技术和发展海外业务选择推介该服务。

本篇作者

本期最新实验《多模一站通 —— Amazon Bedrock 上的基础模型初体验》

✨ 精心设计，旨在引导您深入探索Amazon Bedrock的模型选择与调用、模型自动化评估以及安全围栏(Guardrail)等重要功能。无需管理基础设施，利用亚马逊技术与生态，快速集成与部署生成式AI模型能力。

⏩️[点击进入实验] 即刻开启 AI 开发之旅

构建无限, 探索启程！

...全文