Utilizando IA Generativa para analisar vídeos da Assembleia Legislativa de Pernambuco

Cansado de ter que assistir a vídeos longos no YouTube apenas para encontrar um trecho específico? E se houvesse uma maneira de automatizar esse processo, economizando tempo e esforço? Descubra como utilizar a IA Generativa para criar uma solução eficiente para encontrar rapidamente os trechos desejados nos vídeos e montar automaticamente uma timeline com os principais momentos.

Introdução

Assistir a vídeos longos no YouTube em busca de informações específicas pode ser uma tarefa tediosa e demorada. A solução para esse problema é conhecida: escrever, na descrição do vídeo, um resumo do conteúdo e criar uma timeline com links para os principais trechos. De fato, muitos produtores de conteúdo já se valem desse artifício atualmente.

Quer aprender a criar uma timeline para o seu vídeo? Siga esse link.

Entretanto, o processo de criação manual de resumos e timelines é extremamente trabalhoso e consome muito tempo. Além de requerer uma certa intimidade com tecnologia, o que para muitos produtores é um desafio considerável.

A situação fica bem evidente no contexto da instituição em que eu trabalho: Assembleia Legislativa de Pernambuco (Alepe). Na Alepe ocorrem diariamente diversas reuniões e debates, todas sendo gravadas e disponibilizadas online para a população. As sessões plenárias costumam durar entre 1h30m e 3 horas.

Imagine o trabalho que dá criar manualmente a timeline de cada reunião dessa! O resultado é que as timelines para os vídeos acabam não sendo criadas, e por consequência a visualização dos vídeos acaba sendo baixíssima.

A solução? IA Generativa!

Diante desse cenário, surgiu a necessidade de uma solução mais eficiente e automatizada para os vídeos publicados pela Alepe. Foi aí que entrou em cena o YouTubeClipper!

YouTubeClipper: automatizando a análise de vídeos

O YouTubeClipper é um aplicativo que se integra à plataforma do YouTube para extrair as transcrições dos vídeos usando a YouTube API. Em seguida, utiliza a IA Generativa para resumir automaticamente as transcrições e montar uma timeline com os principais trechos.

Benefícios da Ferramenta

• Economiza tempo e esforço na criação de timelines e resumos de vídeos.
• Garante a precisão e consistência dos resumos e timelines gerados.
• Facilita o acesso e compreensão do conteúdo dos vídeos da Alepe para produtores de conteúdo, jornalistas e o público em geral.
• Aumenta a transparência e visibilidade das atividades legislativas da Alepe.

Tecnologias

Desenvolvido em Python, o YouTubeClipper utiliza a YouTube Transcript API para acessar transcrições dos vídeos. Em seguida, ele utiliza os recursos de IA Generativa do Google Gemini para resumir automaticamente a transcrição e extrair os principais trechos do vídeo.

YouTube Transcript API

Essa API possibilita o download de vídeos e a extração de transcrições, elementos essenciais para a análise de conteúdo de vídeo.

O funcionamento é bem simples: basta você informar o id do vídeo e chamar uma função da API:

from youtube_transcript_api import YouTubeTranscriptApi

YouTubeTranscriptApi.get_transcript(video_id)

O retorno dessa chamada será uma lista de dicionários, cada um representando um trecho do vídeo.

O JSON de saída possui a seguinte estrutura:

[ 
  { 
    'text': 'Boa tarde, nobres colegas e demais presentes.', 
    'start': 0, 
    'duration': 5 
  }, 
  { 
    'text': 'Iniciamos hoje mais uma sessão plenária para debater importantes projetos de lei.', 
    'start': 10, 
    'duration': 10 
  }                         
] 

No exemplo acima, o primeiro trecho começa no segundo 0 e dura 5 segundos. O segundo trecho começa no segundo 10 e dura 10 segundos.

Você pode encontrar a documentação e o código fonte da Transcript API aqui.

Gemini API

O Gemini API é a ferramenta de IA Generativa do Google. O funcionamento também é bastante simples: após obter a chave da API, basta montar o prompt (sua pergunta) e chamar uma função da API:

model = genai.GenerativeModel(model_name="gemini-1.0-pro")


response = model.generate_content(f"Faça um resumo do vídeo")

Você pode gerar sua API Key e encontrar a documentação do Gemini aqui.

Funcionamento

A principal limitação de modelos de Linguagem de Modelagem de Longo Alcance (LLM) como o Gemini é o tamanho do prompt. Em nosso cenário de vídeos de longa duração, essa restrição representa o grande desafio da aplicação.

Para contornar essa limitação, foi adotada a seguinte estratégia:

• Divisão do transcript em trechos menores: o transcript foi dividido em trechos menores, de aproximadamente 10 minutos de duração cada. 

def split_transcript(transcript, max_duration=600):
  parts = []
  current_part = []
  current_duration = 0

  for entry in transcript:
      if current_duration + entry["duration"] <= max_duration:
          current_part.append(json.dumps(entry))
          current_duration += entry["duration"]
      else:
          decoded_part = [bytes(entry, "utf-8").decode("unicode_escape") for entry in current_part]
          parts.append(decoded_part)  # Adiciona a parte atual à lista de partes
          current_part = [json.dumps(entry)]  # Começa uma nova parte com a entrada atual
          current_duration = entry["duration"]

  decoded_part = [bytes(entry, "utf-8").decode("unicode_escape") for entry in current_part]
  parts.append(decoded_part)

  return parts

• Envio dos trechos para o Gemini: cada trecho é individualmente enviado ao Gemini, junto com um prompt específico que instrui o modelo sobre como gerar a saída.

summaries = []
clips = []

for segment in segments:
prompt = "Preciso descrever o conteúdo de um vídeo do YouTube."
prompt += " Aqui está o conteúdo:"
prompt += "\n".join(segment)
prompt += " Os dados do vídeo estão no formato JSON {text:'', start:'', duration:''}. start representa o início do trecho em segundos, e duration representa a duração do trecho em segundos;"
prompt += " Quais são os assuntos discutidos nesse vídeo? Crie uma lista contendo uma descrição do assunto e o valor do campo start em que se inicia o assunto."
prompt += " Também preciso que você faça um breve resumo do vídeo inteiro."
prompt += " Responda no formato JSON, de forma que uma aplicação possa fazer o parse da resposta. Os campos do JSON devem ser exatamente estes: 1. summary: resumo do vídeo e 2: topics: lista dos assuntos, que também deve ter um formato JSON assim definido: 1. description e 2.start"
prompt += " O valor de start deve ser exatamente igual ao encontrado no json original."
response = model.generate_content(prompt)
response_text = response.text
response_text = response_text.replace("```json", '')
response_text = response_text.replace("```", '')

json_object = json.loads(response_text)

summaries.append(json_object["summary"])
clips.extend(json_object["topics"])

• Solicitação do resumo geral: após receber os resumos de todos os trechos, o YouTubeClipper solicita ao Gemini um resumo geral do vídeo completo.

summaries_string = '\n'.join(summaries)

prompt = "Preciso descrever o conteúdo de um vídeo do YouTube."
prompt += " O vídeo contém vários trechos. Vou enviar o resumo de cada trecho. Você deve ler todos eles e gerar um resumo geral."
prompt += " Retorne apenas o resumo geral. Estes são os resumos:\n"

prompt += summaries_string
response = model.generate_content(prompt)

total_summary = response.text

• Formatação da saída como uma Timeline: os trechos resumidos são formatados como links para a timeline do vídeo. Cada link direciona para o momento específico do vídeo em que o trecho ocorre.

import textwrap
from IPython.display import display
from IPython.display import Markdown

def to_markdown(text):
text = text.replace('•', '  *')
return Markdown(textwrap.indent(text, '> ', predicate=lambda _: True))

display (to_markdown("### Resumo:"))
display (to_markdown(total_summary))
display (to_markdown("### Timeline:"))

for clip in clips:
if isinstance(clip['start'], str):
  clip['start'] = clip['start'].replace("'", "")
  clip['start'] = float(clip['start'])

for clip in clips:
  link = f"{video_url}&t={clip['start']}s"
  hours = int(clip['start'] // 3600)
  minutes = int((clip['start'] % 3600) // 60)
  seconds = int(clip['start'] % 60)

  # Formato do tempo HH:MM:SS
  time_formatted = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
  #time_formatted = clip['start']
  start_aligned = f"{time_formatted}".ljust(10)
  description_aligned = clip['description'].ljust(50)
  display (to_markdown(f"{start_aligned} - [{description_aligned}]({link})"))

Você pode encontrar a documentação sobre o YouTubeClipper, bem com um ambiente de testes da aplicação no Google Colab, aqui.

Exemplo de uso

Que tal vermos agora o YouTubeClipper em ação? Assista a esse vídeo:

E confira o resumo e os trechos que o aplicativo gerou automaticamente:

Resumo

O vídeo aborda a estrutura e o funcionamento das frentes parlamentares e comissões especiais na Assembleia Legislativa de Pernambuco (Alepe). Ele explica o processo de criação, composição e objetivos desses colegiados, destacando seu papel crucial na discussão e acompanhamento de questões de interesse público.

Timeline

00:00:13 - Frentes parlamentares e comissões especiais na Alepe

00:00:30 - Criação de frentes parlamentares

00:01:03 - Formação de comissões especiais

00:01:37 - Acompanhamento das atividades legislativas na TV Alepe e no YouTube

Conclusão

O YouTubeClipper é apenas um exemplo de como a IA generativa pode ser aplicada para o benefício da sociedade. Ao simplificar a análise de vídeos extensos e proporcionar uma maneira eficiente de acessar informações específicas, a ferramenta não apenas economiza tempo e esforço, mas também promove maior transparência em instituições públicas como a Alepe.