DEV Community: Fabio Simoes

Resumindo vídeos do Youtube com auxílio de LLM's

Fabio Simoes — Sat, 19 Oct 2024 13:19:49 +0000

Algumas vezes encontro vídeos realmente interessantes no Youtube, se não o vídeo todo, mas partes dele. Com frequência costumo salvar esses vídeos em alguma lista de reprodução para assistir mais tarde e anotar em algum lugar seu elementos do seu conteúdo para que eu possa ter como referência no futuro.

O caso é que quase sempre, não me lembro mais qual vídeo era, e quando tento retomar esses vídeos, mesmo os que eu salvei, é raro que eu encontre o que estava procurando.

Não é de hoje que me interesso bastante por NLP (Processamento de Linguagem Natural) e venho estudando uma série assuntos relacionados ao tema, e aí me toquei que não é difícil usar LLM's para resumir videos do Youtube, gerar um resumo em texto, e dessa forma facilitar a busca do assunto que me interessa, posso inclusive usar LLM's nessa etapa também.

Mas hoje, vamos falar só da primeira parte desse projeto. Vamos criar uma ferramenta que irá resumir vídeos do Youtube, destacando os principais tópicos abordados, e depois disso iremos salvar isso em um arquivo Markdown, que poderá ser armazenado no GitHub/GitLab se preferir, se você utiliza o Obsidian para gerenciar uma biblioteca de markdowns, fica perfeito.

Vamos começar criando um diretório para o nosso projeto e as pastas necessárias, eu estou usando Linux, mas a lógica é a mesma para outros sistemas operacionais.

mkdir youtube-summarizer
cd youtube-summarizer
mkdir data
mkdir notebook

Vamos iniciar a configuração do nosso projeto, eu gosto de utilizar o Poetry, mas se você preferir utilizar o Pip com Virtualenv.

echo inicia o projeto
poetry init
echo ativa ambiente virtual
poetry shell
echo instala as bibliotecas
poetry add python-dotenv langchain-community langchain-groq langchain ipykernel youtube-transcript-api pytube

Observação: Se você preferir, poderá usar o Google Colab, que irá funcionar da mesma forma. Só vamos trocar a instalação das bibliotecas, no Colab vamos usar o PIP.

Na primeira célula do notebook no Colab, digite:

!pip install -q -U python-dotenv langchain-community langchain-groq langchain youtube-transcript-api pytube

Se você estiver usando o VSCode como eu, e estiver no diretório do projeto, youtube-summarizer agora basta digitar:

code .

Mãos a obra

Para simplificar vamos utilizar o Jupyter Notebook, eu estou utilizando dentro do VSCode, num segundo momento você pode transferir o código do notebook para uma classe Python. Notebooks são muito bons para prototipação, no entanto não considero recomendável que sejam utilizados como "biblioteca de códigos", se passamos para arquivos .py ou estruturamos uma classe, fica muito mais simples de reutilizar esses códigos em projetos futuros. Mas para um tutorial como esse, eles são ótimos, por isso optei pelo Jupyter.

Para criar um notebook no VSCode, selecione o diretório notebook, clique no ícone 'new file', e adicione um novo arquivo conforme imagem abaixo.

Qualquer arquivo que você adicionar a extensão .ipynb será reconhecido pelo VSCode como um Jupyter Notebook desde que você tenha a extensão do Jupyter instalada. Qualquer coisa, basta instalar as extensões mostradas na figura abaixo. As duas primeira são primordiais, as duas seguintes podem ser úteis em outras situações, a Jupyter Cell Tags, por exemplo, é muito importante caso queira usar o Papermill (assunto para outra oportunidade) para orquestrar seus projetos pessoais.

Importação das Bibliotecas

Uma vez que criamos nosso notebook podemos iniciar a prototipação. Na primeira célula do notebook, vamos importar as bibliotecas necessárias, conforme mostrado abaixo.

import os
import textwrap
from dotenv import load_dotenv
from IPython.display import Markdown
from langchain_community.document_loaders import YoutubeLoader
from langchain_groq import ChatGroq
from langchain.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser

Criação da chave de acesso para API do Groq

Nós instalamos a biblioteca langchain_groq, que nos permite acessar modelos armazenados no Groq 🙃. Ok, se você não conhece, o Grop armazena uma série de modelos open source, como o Llama3. Nós podemos utilizar o Ollama para servir modelos como esse, no entanto, precisamos de uma máquina bastante poderosa para poder rodar um modelo 70b, e nos meus testes, o 8b não performou bem, por isso vamos fazer uma conta no Groq, criar uma chave, e utilizar aqui, que vai nos dar um ótimo resultado, e até o momento que escrevo isso, não há custos para desenvolvedores. Então vá até esse endereço, https://console.groq.com/keys, crie uma chave:

Você deve copiar a chave, ela não será exibida novamente, caso precise de outra, crie uma nova.
Agora na raiz do projeto crie um arquivo chamado .env e adicione a sua chave conforme exemplo abaixo:

Se for mandar seu código para o GitHub ou GitLab, por exemplo, lembre-se de adicionar esse arquivo ao .gitignore, nunca mande o seu arquivo .env para nenhum repositório, público ou privado.

Uma vez que o arquivo .env esteja corretamente configurado, voltamos ao notebook e vamos carregar a chave utilizando o comando abaixo.

load_dotenv()

Configuração do Modelo

Esse comando lê o arquivo .env e carrega todas as chaves que encontrar lá, inclusive se você tiver outras chaves, ou preferir utilizar outros modelos como os da Open AI, basta configurar no .env.

Agora vamos carregar nossa LLM.

llm = ChatGroq(
    model_name="llama-3.1-70b-versatile", 
    temperature=0, 
    streaming=False
)

Usando no Colab

Caso você opte pelo Colab, adicione o a sua chave conforme indicado na imagem abaixo, e não esqueça de marcar "Acesso ao notebook"

Ao invés de load_dotenv(), use o código abaixo para carregar informações da sua API key.

from google.colab import userdata
os.environ['GROQ_API_KEY'] = userdata.get('GROQ_API_KEY')

Pronto, agora todo o resto funcionará da mesma forma que no Jupyter.

Configuração do Prompt

Com a LLM carregada, o próximo passo é configurar o prompt, vou usar a classe PromptTemplate do Langchain, conforme exemplo abaixo:

prompt_template = PromptTemplate(
    input_variables=["video_transcript"],
    template="""
        Task: Carefully read the entire transcript. If a chapter list is provided, summarize each chapter concisely.

        Information Extraction: Extract key points and relevant information for each chapter or section of the video. 
        Focus on capturing the essence without including unnecessary details.

        Summary Style: Use clear, engaging language that is accessible to a general audience. 
        Keep summaries concise, but comprehensive enough to convey core insights.

        Special Attention:
        Prioritize including any statistical data, expert opinions, or unique insights if present. Highlight these in the summary.
        If numerical or statistical data is mentioned, provide accurate figures and clarify their relevance.

    Video transcript: {video_transcript} """
)

A variável prompt_template configurada acima, será usada logo mais para receber a transcrição do vídeo, e junto com as instruções pré-configuradas, retornar um resumo do vídeo. O prompt está configurado em inglês, porque tive a impressão em alguns testes, que independente da língua da transcrição extraída, quando o prompt está em inglês o modelo performa melhor.

Para quem não sabe o ChatGPT tem algumas ferramentas, eu usei a "Prompt Engineer", conforme imagem abaixo, para me ajudar a melhorar esse prompt, existem outras disponíveis, mas essa é uma das que mais gostei até agora.

Extração da transcrição

O nosso próximo passo é extrair a transcrição de um vídeo do Youtube. Mesmo que não sejam criadas legendas pelo autor o próprio Youtube gera transcrições automáticas, e nós vamos usar a classe YoutubeLoader da biblioteca langchain_community para extrair esses dados.

video_url = 'https://www.youtube.com/watch?v=m_YJgE1Go4c'
video_lang = ["pt", "pt-BR", "en"]

loader = YoutubeLoader.from_youtube_url(video_url, add_video_info=True,language = video_lang)
data = loader.load()

metadata = data[0].metadata
transcript = data[0].page_content

Explicando o que está acontecendo no código acima, temos duas variáveis, uma com o link para o vídeo no Youtube, e outra com as linguagens aceitáveis. Essa variável é importante quando usamos o YoutubeLoader, porque se nada for especificado, o loader por padrão irá procurar por transcrições em inglês, se não houver vai dar erro. Passando uma lista de possíveis linguagens nós evitamos o erro.

loader.load() irá carregar uma lista com dados sobre o vídeo, que inclui o título, data de publicação, autor etc., que estão na chave metadata. E o mais importante para nós aqui, que é a transcrição está na chave page_content.

Configurando a Chain

Vamos usar o conceito de Chain of Thought. A ideia dessa técnica é que ao invés de o modelo dar a resposta direta, ele deve seguir um fluxo de raciocínio, passando por etapas lógicas antes de dar a resposta final. Imagine que vou ensinar a vocês uma receita culinária. Primeiro vamos falar dos ingredientes (organizar os dados), depois passamos a seguir a receita (aplicar a lógica de negócio, e cálculos), verificar o resultado (dar a resposta).

No código abaixo prompt_template, é o roteiro da receita, as instruções e perguntas que você quer que o modelo responda, llm, é o 'chef' que vai seguir a receita, o StrOutputParser é o garçom que irá organizar o prato e entregar o resultado (acho que no restaurante o garçom não organiza o prato, mas espero que tenha sido capaz de explicar o conceito).

chain = prompt_template | llm | StrOutputParser()

Agora nós podemos invocar essa cadeia de "raciocínio" através do comando abaixo.

summary = chain.invoke({
    "video_transcript": transcript
})

Quando fizemos a configuração do Prompt Template, nós criamos uma variável lá, video_transcript, e agora nós atribuímos a transcrição extraída a essa variável que será incorporada ao restante do template. Após executar o código acima, podemos visualizar o resultado como no exemplo abaixo.

O modelo faz um ótimo trabalho resumindo os pontos chaves do vídeo. Um ponto específico acho importante comentar, a última linha, na parte de Estatística e Dados, a informação de que a linguagem Python é a mais usada no mundo atualmente não é verdadeira, numa rápida pesquisa constatei que JavaScript é a mais usada. No vídeo é comentando que a linguagem Python é a mais usada no mundo para Inteligência Artificial, especificamente nesse contexto.

Então o resumo em si não de ser usado como fonte de verdade absoluta, aliás nunca use a resposta de um modelo de inteligência artificial como verdade absoluta. Meu objetivo aqui é poder criar uma biblioteca com informações que eu possa pesquisar no futuro com mais facilidade, então encontrando os assuntos que me interessam assistir o vídeo e aí sim tirar minhas próprias conclusões.

Dito isso, vamos para o próximo passo.

Salvando o resultado

Como quero criar uma biblioteca de dados, quero salvar cada resumo em um arquivo .md diferente, vamos criar uma função para facilitar esse processo.

def get_video_info(metadata, summary):
    infos_video = textwrap.dedent(f"""## Video Summary

    Title: {metadata['title']}
    Author: {metadata['author']}
    Date: {metadata['publish_date'][:10]}
    URL: https://www.youtube.com/watch?v={metadata['source']}

    """) 

    infos_video += textwrap.dedent(f"""## Summary

    """)

    infos_video += textwrap.dedent(f'{summary}')

    final =infos_video 

    return final, metadata['title']

A função acima vai receber o resumo gerado pelo modelo LLM e os metadados extraídos anteriormente, e criar uma Markdown, essa função retorna também o título do vídeo que nós iremos utilizar como nome do arquivo.

Abaixo está a função que irá salvar o arquivo.

def save_summary_to_markdown(summary, filename):
    with open(filename, 'w', encoding='utf-8') as f:
        f.write(summary)

Com as duas funções acima criadas podemos agora finalmente salvar nosso resumo, conforme exemplo abaixo.

final_summary, video_title = get_video_info(metadata, summary)
transcript_path_file_name = '../data/'+video_title+'.md'
save_summary_to_markdown(final_summary,transcript_path_file_name)

No final teremos algo como o apresentado abaixo:

Conclusão

LLM's são modelos muito dinâmicos, é muito fácil perceber o resultado, e a cada dia temos uma gama maior de alternativas, seja para estudar esses modelos, ou para a utilização deles tanto pessoal como profissional. Temos hoje uma gama muito grande de informações e dados a nossa disposição, nem sempre temos tempo, ou sabemos como catalogar esses dados para que possamos utilizar em momentos futuros, mas uma aplicação simples como a demostrada nesse artigo, consegue de forma muito simples e em poucos minutos gerar documentos que facilitam demais a busca por informações, se você tentar por conta própria criar um resumo de cada vídeo interessante que você encontrar na internet, vai perceber que isso leva bastante tempo.

Para facilitar a execução, deixo aqui o link para o notebook no Google Colab.

Espero que o exemplo demonstrado aqui possa ser útil, muito obrigado pelo seu tempo, e até a próxima.

Tutorial Duckdb

Fabio Simoes — Mon, 29 Apr 2024 21:44:40 +0000

Duckdb é um banco de dados OLAP. Que em resumo é um sistema de banco de dados voltado para consultas. Não necessita de uma rede complexa de servidores para funcionar, e desempenha seu papel de maneira surpreendentemente rápido.

Características

Simplicidade: É muito simples instalar, seja de distribuir, pois não possui dependências externa, roda no mesmo processo do aplicativo principal, ou como um binário único.

Portável: Tem versões para Linux, Windows e macOS, nas arquiteturas x86 ou ARM. É altamente escalável, o que significa que conforme surgir a necessidade ele pode trabalhar com mais CPUs e memória. Tem APIs para Java, C, C++, Go, Node.js entre outras linguagens. É altamente integrado ao Python e R, nessas linguagens funciona é como se você estivesse utilizando Pandas, por exemplo.

Recursos: Com Duckdb usamos um SQL, com uma alta gama de recursos disponíveis. Ele pode ler diretamente arquivos no formato CSV, Parquet e JSON, em arquivos locais, e também a partir de locais remotos como buckets S3.

Rápido: As consultas rodam extremamente rápido graças ao seu motor colunar que suporta consultas em paralelo e pode processar volumes maiores que a memória.

Extensível: Permite o desenvolvimento e instalação de extensões de terceiros, para acrescentar suporte a novos tipos de dados, funções, e formatos de arquivos.

Grátis: É um projeto open source sob a licença MIT.

A seguir quero demonstrar como utilizar o Duckbd para fazer consultas. Ele pode ser um ótimo substituto para bibliotecas como Pandas, e muito útil para estudantes que querem aprender SQL, também para analistas que precisam fazer consultas, já conhecem SQL, e querem evitar a curva de aprendizado para o Pandas, o PySpark, por exemplo.

Nunca vou dizer a ninguém que devem evitar aprender qualquer coisa, mas pensando em Pandas e suas limitações, em especial para datasets maiores, em vários cenários o o Duckdb será uma ferramenta muito mais util, tanto do ponto de vista de aprendizado, quanto de resultados.

Sem mais delongas, vamos para o tutorial.

Instalação

Para esse projeto vou considerar que você já tenha Python, e pip instalados.
Primeiro crie uma pasta para o projeto, vamos criar um ambiente virtual para o nosso projeto.

python -m venv .venv

Agora vamos ativar o ambiente virtual:

source .venv/bin/activate

No Windows não é necessário usar o comando "source".

Para instalar o Duckdb use o comando abaixo:

pip install duckdb==0.9.2

Agora vamos instalar o JupyterLab:

pip install jupyterlab

Para iniciar o JupyterLab, use o comando abaixo:

jupyter lab

Agora vamos criar um novo notebook e testar se o Duckdb esta funcionando como esperado. No novo notebook execute os comandos abaixo, se receber a mesma mensagem o ambiente esta corretamente configurado e podemos partir para os próximos passos.

Base de Dados

A base de dados que vamos utilizar nesse tutorial pode ser encontrada no seguinte endereço: Kaggle - Brewery Operations. É uma base de dados grande, então podemos analisar também o desempenho do Duckdb.

Faça o download da base de dados, e no mesmo diretório do projeto crie uma pasta chamada data e copie o arquivo para lá.

Agora vamos usar o Duckdb para ler os dados a partir do arquivo csv que acabamos de fazer o download.

Abaixo podemos observar o retorno da leitura, alguns registros serão exibidos como amostra.

Podemos também aplicar algumas consultas SQL diretamente lendo do csv. Como nos exemplos abaixo:

Contando registros

Filtrando registros

Ingestão de dados

O que fizemos até o momento foi usar os recursos do Duckdb na leitura de um arquivo csv. Pode ser feito exatamente o mesmo para outros tipos de arquivos, como parquet, json, entre outros.

Mas é possível fazer a ingestão desses dados no Duckdb. Com isso vamos ganhar mais desempenho nas nossas consultas. Depois é possível persistir esses dados no formato do Duckdb, o que irá facilitar a leitura dos dados em um próximo momento.

Criando a base de dados

O comando abaixo irá gerar um arquivo chamado tutorial.db no mesmo local onde o notebook foi criado. O extensão do arquivo não precisa ser necessariamente db, pode ser duckdb, ou qualquer outra que você deseje, desde que seja criada usando o comando abaixo.

con = db.connect("tutorial.db")

O comando acima irá criar o arquivo .bd apenas se ele não existir, senão ele irá se conectar a esse banco de dados. Logo a partir da sua criação podemos usar ele para criar novas tabelas fazer consultas sempre que for necessário.

Esse banco de dados ainda não tem tabelas nele, o que vamos fazer agora é usar os dados do arquivo csv para criar uma tabela nele.

Para criar uma tabela no banco de dados, a partir do arquivo csv, vamos usar o comando abaixo:

con.sql("create table brewery_data as from 'data/brewery_data_complete_extended.csv'")

O comando acima ira criar uma tabela no banco de dados chamada brewery_data, contendo todos os dados que estavam no arquivo csv serão gravados nessa tabela.

Se você tiver algum cliente SQL instalado no seu computador, como o DBeaver, por exemplo, poderá inclusive utiliza-lo para fazer consultas nesse banco de dados.

Ou ainda diretamente do Jupyter com Python conforme exemplo abaixo:

A partir de agora podemos sempre usar o banco de dados criado sempre que precisarmos sem a necessidade de ler diretamente do arquivo csv. Isso trás alguns benefícios, o primeiro é que todas as consultas serão muito mais rápidas.

Faça a contagem dos registros, diretamente na tabela do no Duckdb e compare com o tempo que levou quando executado a partir do csv.

con.sql("select count(*) as n_reqs from brewery_data")

Outro ponto, é que o arquivo csv que utilizamos tem 2.6 GB, o arquivo do Duckdb ficou menos de 1 GB, já estamos economizando espaço em disco.

Criando tabelas a partir de dados filtrados

Agora que temos um banco de dados criado (tutorial.db), podemos criar novas tabelas dentro dele. Ao invés de gerar diferentes arquivos quando queremos separar os dados, podemos fazer isso dentro do banco, criando novas tabelas, como no exemplo abaixo:

con.sql("create table lagers as from brewery_data where Beer_Style = 'Lager'")

con.sql("select * from lagers")

O que faço aqui é criar uma nova tabela, a partir da nossa tabela brewery_data, filtrando apenas as cervejas do tipo Lager, e inserindo esses registros em uma nova tabela. Tudo vai se manter dentro de um único arquivo, e conforme citado anteriormente pode ser facilmente consumido por uma ferramenta de relatórios, por exemplo.

Exportando Dados

Exportar dados, também pode ser feita de maneira bastante simplificada, veja os exemplos abaixo:

No exemplo abaixo, o conteúdo da tabela lagers, será exportado para o arquivo lagers.csv:

con.sql("select * from lagers").write_csv('lagers.csv')

Seguinte a mesma lógica podemos exportar os dados para um arquivo no formato .parquet:

con.sql("select * from lagers").write_parquet('lagers.parquet')

Conclusão

O objetivo principal desse tutorial era demonstrar alguns dos muito recursos do Duckdb.
Duckdb é com certeza uma ferramenta muito poderosa, escalável, e pode ser utilizada em diferentes tipos de projetos.
Uma ferramenta como o Duckdb entrega dinamismo, pois é muito simples ler dados de diferentes fontes, e aplicar a linguagem SQL, muito conhecida de profissionais da área de análise de dados.
Embora não tenha sido demonstrado nesse tutorial, o Duckdb permite a rápida conversão de uma query SQL para um data frame de Pandas, ou Polars, por exemplo, o que facilita o trabalho de cientistas de dados que depois de fazer o trabalho de limpeza dos dados, necessitem desses dados no formato Pandas, por exemplo, para aplicação de algorítimos de machine learning.
Teste o Duckdb, você vai conhecer uma ferramenta muito poderosa.