OpenAI: criando uma postagem para o Instagram com IA Generativa

Transcrição de Áudio com a API Whisper da OpenAI - Apresentação

Olá pessoal, meu nome é André Santana, sou instrutor aqui na Alura e vou acompanhar vocês neste curso.

Audiodescrição: Para quem não o vê, André Santana se identifica como um homem branco, de cabelos curtos, barba e bigode médios, todos na cor castanho-claro. No rosto, um óculos redondo. No corpo, uma camiseta escura com a logo da Alura. Ao fundo, uma parede lisa iluminada com cores que variam do azul para o roxo e uma estante à direita, com alguns objetos que remetem à área de tecnologia.

Desejamos boas-vindas a este curso que envolve um pouco sobre como usar a OpenAI para trabalhar com transcrição de áudio, geração de imagens e comunicação com o modelo GPT.

Se você gosta de criar conteúdo para a internet, é entusiasta da área de tecnologia e está antenado nas novidades da OpenAI, esse curso é para você.

Vamos conferir um pouco sobre como utilizar as ferramentas que estão dominando o mercado atualmente na área de IA (Inteligência Artificial) generativa, para poder aplicar aos projetos que temos no dia a dia.

O que Aprenderemos Neste Curso?

Neste curso, vamos aprender como:

Transcrever um áudio utilizando a API do Whisper, da OpenAI
Com base na transcrição, gerar elementos através de prompts para o próprio GPT, como:
- Um resumo para postar numa rede social (neste caso, o Instagram);
- Hashtags e outros elementos que podem auxiliar na construção de uma postagem;
Gerar imagens a partir desse texto usando a API do DALL-e, também vinculada à OpenAI.
Estruturar esse conteúdo para realizar uma postagem direta no Instagram, utilizando o Instabot.

Veremos todos esses elementos dentro do projeto, que será escrito em Python, usando o Visual Studio, e que vai contar com o processo de ler um arquivo do podcast do Hipsters.tech e trabalhar com arquivos grandes e com dimensões diferentes, para que seja possível transcrever o conteúdo desse áudio em formato de texto, e extrair as informações necessárias para alimentar essa postagem na rede social.

Esse processo acontecerá etapa por etapa e passando por módulos, para garantir que você possa utilizar esse tipo de recurso em projetos que façam parte do seu dia a dia.

Pré-requisitos

Conhecimento na linguagem de programação em Python;
Algum conhecimento de lógica de programação.

Além dos vídeos e trechos de código que serão disponibilizados nessa formação, você também pode contar com as atividades e com toda a comunidade através da comunidade Alura no Discord ou do Fórum de dúvidas, para poder ampliar os conhecimentos que você vai obter ao longo deste curso.

Portanto, bons estudos e vamos lá!

Transcrição de Áudio com a API Whisper da OpenAI - Configurando a API do Whisper

Já temos uma ideia sobre o nosso projeto e vamos começar a dar os primeiros passos para converter o áudio do podcast em um conteúdo de texto e imagem para ser publicado nas principais plataformas de comunicação.

A primeira etapa é escolher um áudio para trabalhar, que faça parte do conteúdo que desejamos exibir nas redes sociais. Optamos no vídeo pelo áudio hipsters_154_testes_short.mp3, que fala um pouco sobre testes. Trouxemos uma versão curta deste áudio e explicaremos mais adiante o motivo dessa escolha.

Alocamos esse arquivo na pasta "podcasts" e abrimos essa pasta no Visual Studio. Podemos ver essa estrutura de pastas na aba do explorador lateral.

A parte inicial consistirá em implementar um código que se comunica com a OpenAI, porém, precisaremos configurar algumas variáveis de ambiente, o que faremos em seguida.

Configurando Variáveis de Ambiente

Começaremos criando nosso arquivo principal Python, que utilizaremos para implementação. Para isso, clicaremos com o botão direito na aba do explorador e selecionaremos "New File". O nome desse arquivo Python será main.py.

Ele pode ter qualquer nome, optamos por esse para facilitar sua localização posteriormente. Agora, vamos abrir o terminal para definir as variáveis de ambiente e garantir que o projeto acompanhe as bibliotecas necessárias sem comprometer outros sistemas.

Para abrir o terminal na seção inferior da página e configurar as variáveis de ambiente, clicaremos no botão de menu hambúrguer no topo superior esquerdo, selecionar os menus "Terminal > Novo Terminal".

No terminal trouxemos o caminho de código "\code", mas nenhuma variável de ambiente foi criada ainda. Precisaremos de alguns comandos para criar essa variável de ambiente.

Acessando o terminal, digitaremos o comando python -m virtualenv e escolheremos um nome para esse ambiente virtual de trabalho. Vamos chamá-lo de "codigo_alura".

python -m virtualenv codigo_alura

Após pressionar "Enter" e finalizar este processo, a variável de ambiente é criada. A IDE abrirá uma caixa de diálogo perguntando se queremos criar esse ambiente e gerenciá-lo no nosso workspace (área de trabalho). Vamos selecionar "Yes".

No entanto, ainda não ativamos esse ambiente de trabalho. Precisamos ativá-lo para garantir que as importações de bibliotecas sejam adequadas e que conseguiremos utilizá-las ao longo do projeto.

A ativação é um pouco diferente entre Windows e Mac. Como estamos no Windows, digitaremos o nome do nosso ambiente (codigo_alura), uma barra à direita (/), o caminho Scripts, outra barra à direita e finalmente activate desse ambiente virtual.

codigo_alura/Scripts/activate

Uma vez que fizemos isso, veremos no explorador lateral que apareceu um diretório com o nome do nosso ambiente virtual acima de "podcasts". Vamos utilizá-lo para realizar as importações e instalações das bibliotecas necessárias.

Importando Bibliotecas

A primeira biblioteca que precisaremos instalar é a da OpenAI, que será responsável por todas as interações que faremos com ela, não só com o GPT, mas com o Whisper e também com o DALL-E. Para isso, utilizaremos o comando abaixo que realizará todo o processo de coleta das bibliotecas e instalação desses recursos.

pip install openai

A segunda biblioteca necessária é a que nos ajudará a trabalhar com as variáveis de ambiente. Utilizaremos então o comando abaixo.

pip install python-env

Essa biblioteca deve ser familiar de outros cursos da Formação, mas é importante recuperá-la para gerenciar a chave de API da biblioteca do OpenAI.

Após a conclusão dessa etapa, já temos as bibliotecas instaladas necessárias para interagir com a OpenAI. Com as bibliotecas instaladas, vamos começar a escrever o código.

Vamos fechar o explorador lateral momentaneamente e iniciar a importação das bibliotecas que acabamos de instalar. Nessa fase, três bibliotecas serão essenciais para nós. Duas já foram instaladas e uma já é parte do núcleo do Python.

A primeira biblioteca a ser importada será a openai. A segunda será importada a partir do dotenv, biblioteca responsável por nos auxiliar com as chaves de acesso. Leremos essa biblioteca que nos fornecerá informações de leitura de chaves de acesso de ambiente por meio de um load_dotenv.

Em seguida importaremos o módulo de sistema operacional os, o que permitirá acessar esses recursos de forma correta.

import openai
from dotenv import load_dotenv
import os

Feito isso, vamos começar a construir o nosso programa principal.

Construindo o Programa Principal

Criaremos a função principal, (main), para organizar todo o nosso código dentro dela e também importar para dentro do código as chaves de API necessárias e os arquivos de áudio.

Abaixo dos imports, pularemos duas linhas e criaremos um if __name__ == "__main__" que será disparado quando executarmos nosso código. Vamos fazer com que ele invoque a função principal, adicionando main() na próxima linha.

if __name__ == "__main__":
    main()

Essa função ainda não existe em nosso código, por isso, precisaremos criá-la. Para fazer isso vamos deslocar o bloco if para as linhas de baixo e em seu lugar, usar o comando def main() para definir a função que será a nossa principal.

Dentro dela, traremos as informações de configuração necessárias. A primeira delas é load_dotenv() para ler a variável de ambiente que criamos com o intuito de trazer a chave de API que vamos armazenar.

Em seguida, criaremos as variáveis necessárias para armazenar nossos arquivos de áudio. O primeiro deles se chamará caminho_audio e trará o caminho do nosso áudio.

def main():
    load_dotenv()
    
    caminho_audio = 
    
if __name__ == "__main__":
    main()

Temos opções para receber esse caminho: podemos trazer essas informações diretamente ou pelo explorador lateral à esquerda. Para abri-lo, basta acessar a barra de ícones à esquerda e clicar no ícone de papéis chamado "Explorer".

Ao acessar o explorador, verificaremos o caminho da pasta de podcasts, clicaremos com o botão direito no arquivo do Hipsters e selecionaremos "Copy Relative Path" para copiar seu caminho relativo.

Uma vez feito isso, podemos colar esse material à direita de caminho_audio = , mas devemos nos certificar de colocá-lo dentro de uma string, ou seja, entre aspas duplas.

def main():
    load_dotenv()
    
    caminho_audio = "podcasts/hipsters_154_testes_short.mp3"
    
if __name__ == "__main__":
    main()

A partir desse momento, já temos o caminho do nosso arquivo de áudio onde é necessário. Além disso, vamos dar um nome para esse arquivo que será o utilizado para identificar todos os arquivos que geraremos neste projeto.

Para isso, abaixo de caminho_audio, vamos criar um nome_arquivo e usaremos como prefixo o nome do nosso arquivo de podcast, que será "hipsters154-tests-short".

Por fim, temos que trazer também a URL do podcast que vamos usar nesse processo — neste caso, "https://www.hipsters.tech/testes-de-software-e-inteligencia-artificial-hipsters-154/". Para isso, vamos adicioná-la à variável url_podcast, abaixo de nome_arquivo.

def main():
    load_dotenv()
    
    caminho_audio = "podcasts/hipsters_154_testes_short.mp3"
    nome_arquivo = "hipsters_154_testes_short"
    url_podcast = "https://www.hipsters.tech/testes-de-software-e-inteligencia-artificial-hipsters-154/"

    
if __name__ == "__main__":
    main()

É importante que tenhamos a URL, pois ela será o arquivo que queremos divulgar nas redes sociais para os nossos seguidores.

Após essa configuração, precisamos configurar nossa API e garantir que tenhamos a comunicação do nosso arquivo de ambiente com os dados necessários para nos comunicarmos com a OpenAI.

Há várias formas de fazermos isso, porém a mais recomendada é através das variáveis de ambiente. Portanto, vamos abrir novamente o explorador lateral esquerdo e criar um novo arquivo chamado .env na pasta raiz do projeto.

Vamos utilizá-lo para manter seguras informações importantes de login e senha que não desejamos deixar expostas explicitamente no nosso código, bem como informações da chave de API.

Após criar este arquivo, vamos para o próximo passo, que é trazer a chave de API para dentro do arquivo de ambientes. Para isso, acessaremos o navegador na página principal da OpenAI.

Clicando no menu de pessoa usuária à direita da tela, encontraremos a opção "View API Keys" para acessar a lista de chaves de API, semelhante ao que foi apresentado nos cursos anteriores dessa formação. Ao clicar nela, iremos para a seção "API keys".

Se já houver uma chave secreta criada, ela aparecerá em uma tabela nessa seção. Se não, é fundamental que criemos uma clicando em "Create new secret key" abaixo da tabela, informando um nome para identificação posterior no campo "Name" e pressionando "Create secret key".

Após o clique, ele nos mostrará uma chave alfanumérica iniciada com o prefixo “sk”. Ela deve ser copiada e levada ao Visual Studio.

Neste caso, para exemplificar, criaremos uma chave chamada "Chave" cuja chave alfanumérica é "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".

No Visual Studio, acessaremos o arquivo .env que armazenará nossas chaves de ambiente e criaremos três campos:

API_KEY_OPENAI para a chave da OpenAI;
USER_INSTAGRAM para o login do Instagram;
PASSWORD_INSTAGRAM para senha de acesso ao Instagram.

Na primeira, colaremos a chave da OpenAI. As outras duas serão reservadas para realizar a comunicação com o Instagram.

API_KEY_OPENAI = "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"
USER_INSTAGRAM = "seu-usuario"
PASSWORD_INSTAGRAM = "sua-senha"

No seu projeto, utilize a chave gerada em seu perfil, seu login e senha próprios.

Após importar a chave da OpenAI, retornaremos ao arquivo main.py e importaremos essa chave para dentro do código, criando uma variável chamada api_openai abaixo de url_podcast. Ela receberá um os.getenv(), onde getenv() representa as variáveis de ambiente e os se trata da biblioteca que foi importada anteriormente para lê-las.

Entre os parênteses, traremos o nome exato da chave criada como uma string. Se houver dúvidas de como se escreve, podemos consultar as variáveis de ambiente no arquivo .env.

api_openai = os.getenv("API_KEY_OPENAI")

Com a chave da OpenAI disponível e transparente no código (segura contra divulgações indesejadas em eventuais compartilhamentos do projeto), é preciso associá-la ao módulo OpenAI para finalizarmos a configuração. Abaixo de api_openai, traremos o módulo openai, adicionaremos um ponto e selecionaremos a parte de chave de acesso api_key.

Atribuiremos a esse openai.api_key a chave api_openai utilizada nesse processo.

openai.api_key = api_openai

O código completo da função pode ser visto abaixo.

def main():
    load_dotenv()
    
    caminho_audio = "podcasts/hipsters_154_testes_short.mp3"
    nome_arquivo = "hipsters_154_testes_short"
    url_podcast = "https://www.hipsters.tech/testes-de-software-e-inteligencia-artificial-hipsters-154/"
    
    api_openai = os.getenv("API_KEY_OPENAI")
    openai.api_key = api_openai
    
if __name__ == "__main__":
    main()

Concluímos o processo de configuração da biblioteca. Estamos prontos para implementar as interações com o módulo de transcrição de áudio da OpenAI, chamado Whisper. Nos encontramos no próximo vídeo!

Transcrição de Áudio com a API Whisper da OpenAI - Usando funções de transcrição de áudio do Whispers

Agora que temos o ambiente configurado, podemos começar a trabalhar com o Whisper, mas é importante entender que esse processo também consome alguns recursos associados à OpenAI.

Consumo do Whisper

Para obter mais detalhes, podemos consultar a documentação. No navegador, é possível acessar a documentação completa do Whisper, onde encontraremos diversas dicas sobre como implementar alguns trechos de código que utilizaremos. O material está em inglês, mas há um suporte que pode auxiliar em situações inesperadas que possam surgir durante os projetos.

É essencial também identificar o custo computacional que isso irá gerar. Na página de Pricing da OpenAI, estão listados todos os custos dela. Possivelmente, você já deve ter visto alguns deles em outras fontes de informação.

Contudo, o que nos interessa agora é o custo do modelo do Whisper, que durante a gravação deste vídeo é de 0.006 dólares por minuto de áudio convertido ou transcrição sobre o nosso projeto.

Implementando o Whisper

Retornando ao VS Code, no arquivo main.py, vamos começar a implementar essas interações com o Whisper. A primeira coisa que faremos é definir o tipo de modelo que utilizaremos.

O Whisper treinou com mais de 360 mil minutos de áudio, mas precisamos trazer esse modelo para aproveitar todo o seu poder computacional. Para isso, vamos armazenar esse modelo em uma variável que chamaremos de modelo_whisper, a qual adicionaremos abaixo das variáveis de chave de acesso. Ela receberá uma string com o nome do modelo whisper-1.

def main():
    load_dotenv()
    
    caminho_audio = "podcasts/hipsters_154_testes_short.mp3"
    nome_arquivo = "hipsters_154_testes_short"
    url_podcast = "https://www.hipsters.tech/testes-de-software-e-inteligencia-artificial-hipsters-154/"
    
    api_openai = os.getenv("API_KEY_OPENAI")
    openai.api_key = api_openai
        
         modelo_whisper = "whisper-1"
    
if __name__ == "__main__":
    main()

Este é o modelo padrão na versão mais atual e contém todas as informações de treinamento que a IA utilizou para realizar o processo de transcrição, o que será importante para o nosso projeto.

Uma vez realizado isso, podemos começar a estabelecer uma comunicação direta com a API. Para fazer isso, vamos criar abaixo de modelo_whisper uma variável para armazenar o texto que será transcrito. Vamos chamá-la de transcricao_completa.

Ela receberá uma função que criaremos para ser utilizada e invocada em diferentes situações do nosso projeto. Vamos utilizar alguns padrões para que seja fácil de identificá-las.

Essa função será chamada de openai_whisper_transcrever(), pois estaremos utilizando a API de consumo openai e o módulo de áudio whisper da OpenAI para transcrever um áudio em formato de texto.

Essa função receberá alguns parâmetros. O primeiro será o caminho_audio, que é importante fornecer. Também passaremos o nome_arquivo que será utilizado como prefixo para salvar cada um dos arquivos que transcrevermos. O último parâmetro será a própria biblioteca de uso da OpenAI, a openai, que fará de fato a comunicação.

def main():
    load_dotenv()
    
    caminho_audio = "podcasts/hipsters_154_testes_short.mp3"
    nome_arquivo = "hipsters_154_testes_short"
    url_podcast = "https://www.hipsters.tech/testes-de-software-e-inteligencia-artificial-hipsters-154/"
    
    api_openai = os.getenv("API_KEY_OPENAI")
    openai.api_key = api_openai
        
         modelo_whisper = "whisper-1"
         
         transcricao_completa = openai_whisper_transcrever(caminho_audio, nome_arquivo, openai)
    
if __name__ == "__main__":
    main()

A função ainda não foi criada. Para criá-la, copiaremos esse código após a variável transcricao_completa para cima da linha def main() e definiremos a função de trabalho usando o comando def à sua esquerda. Vamos adicionar dois pontos (:) ao fim dessa linha para que possamos transcrever o nosso código de comunicação com a biblioteca Whisper.

def openai_whisper_transcrever(caminho_audio, nome_arquivo, openai):

def main():
    # Código omitido

Para nos assegurarmos que o que estamos executando agora está sendo processado pelo nosso programa, começaremos criando um print() dentro dessa função, na linha de baixo, apenas para verificar e dizer que entramos no processo de transcrição.

Ele receberá a mensagem "Estou transcrevendo com o Whisper…". Embora seja opcional, este passo auxiliará do ponto de vista didático para entender melhor o processo.

def openai_whisper_transcrever(caminho_audio, nome_arquivo, openai):
    print("Estou transcrevendo com o Whisper…")

Feito isso, agora começaremos o processo de interação entre nossos arquivos de áudio e a biblioteca. De momento, temos apenas o caminho_audio.

Precisamos importar esse áudio e adaptá-lo para ter uma execução adequada dentro do nosso programa. Para isso, abaixo do print(), vamos criar uma variável chamada audio e dentro dela vamos abrir o arquivo que acabamos de criar por meio de um open(), passando como parâmetro, entre parênteses, o caminho do podcast caminho_audio que acabamos de receber.

À sua direita, vamos adicionar uma vírgula e indicar que podemos realizar uma operação de releitura adequada desse arquivo por meio de um rb entre aspas duplas.

def openai_whisper_transcrever(caminho_audio, nome_arquivo, openai):
    print("Estou transcrevendo com o Whisper…")
    
    audio = open(caminho_audio, "rb")

A partir desse momento, nosso arquivo de áudio estará contido nessa variável e poderemos enviar esse arquivo para a biblioteca para realizar as interações necessárias.

A interação que teremos com a biblioteca do Whisper retornará uma resposta. É importante, então, armazenarmos essa resposta em uma variável. Vamos criar essa variável resposta abaixo de audio e começar a interação com o módulo de transcrição de áudio.

Para isso, vamos chamar a openai, que já estará com a chave configurada. Vamos adicionar um ponto a ela e usar o módulo de áudio Audio, associado à biblioteca do Whisper, adicionar outro ponto e solicitar a transcrição deste áudio usando a função transcribe().

def openai_whisper_transcrever(caminho_audio, nome_arquivo, openai):
    print("Estou transcrevendo com o Whisper…")
    
    audio = open(caminho_audio, "rb")
    
    resposta = openai.Audio.transcribe()

Essa função terá alguns parâmetros importantes para executarmos essa operação. Dentro dos parênteses dessa função, começamos passando a nossa chave de API api_key, necessária para a transcrição ocorrer dentro dessa configuração. Esta chave está no parâmetro openai que verificamos anteriormente, na propriedade api_key, portanto criaremos o comando api_key=openai.api_key.

Na próxima linha, vamos indicar qual é o modelo que vamos utilizar nesse processo por meio de um model. O modelo é aquele que passaremos por parâmetro.

def openai_whisper_transcrever(caminho_audio, nome_arquivo, modelo_whisper, openai):
    print("Estou transcrevendo com o Whisper…")
    
    audio = open(caminho_audio, "rb")
    
    resposta = openai.Audio.transcribe(
        api_key=openai.api_key,
        model = 
    )

Ainda não passamos esse modelo por parâmetro, ele ficou para trás. Precisamos trazê-lo para cá. Para isso, vamos voltar à nossa função main(). Na linha transcricao_completa, vamos adicionar um modelo_whisper entre os parênteses de openai_whisper_transcrever() à esquerda da variável openai.

def main():

    # Código omitido
    
         transcricao_completa = openai_whisper_transcrever(caminho_audio, nome_arquivo, modelo_whisper, openai)
    
if __name__ == "__main__":
    main()

Vamos retornar à nossa função openai_whisper_transcrever(), acima da main(), trazendo esse parâmetro whisper_model também, na mesma ordem que o inserimos anteriormente (ou seja, à esquerda de openai.

Esse parâmetro é essencial para indicarmos à OpenAI qual é a complexidade do modelo que queremos usar e os recursos necessários para que esse processo ocorra. Traremos agora o modelo_whisper para a variável model.

Por último, na próxima linha, vamos trazer o nosso arquivo de áudio por meio de um file. Esse arquivo não pode ser o caminho, e sim o arquivo que já foi aberto. Então, se trata do arquivo que está na nossa variável audio, acima do bloco de resposta.

def openai_whisper_transcrever(caminho_audio, nome_arquivo, modelo_whisper, openai):
    print("Estou transcrevendo com o Whisper…")
    
    audio = open(caminho_audio, "rb")
    
    resposta = openai.Audio.transcribe(
        api_key=openai.api_key,
        model = modelo_whisper,
        file = audio
    )

Uma vez realizado esse processo, já temos a comunicação da nossa aplicação com o Whisper configurada. Ele vai retornar uma resposta, que é a transcrição completa desse áudio.

Com a comunicação estabelecida, precisamos pegar essa resposta e garantir que acessamos o texto necessário para continuar o nosso projeto. Esse texto vai ser armazenado em uma variável chamada transcricao, adicionada abaixo dos parênteses do bloco de resposta.

Ela receberá resposta.text que nos trará o texto transcrito na íntegra.

def openai_whisper_transcrever(caminho_audio, nome_arquivo, modelo_whisper, openai):
    print("Estou transcrevendo com o Whisper…")
    
    audio = open(caminho_audio, "rb")
    
    resposta = openai.Audio.transcribe(
        api_key=openai.api_key,
        model = modelo_whisper,
        file = audio
    )
    
    transcricao = resposta.text

Nesse momento, ainda não retornamos esse texto para o restante da aplicação, que vai consumir essa etapa do nosso processo. Antes disso, para podermos navegar com mais facilidade e não consumir tantos recursos do Whisper, vamos salvar esse texto também em um arquivo de texto.

Abaixo de transcricao, vamos adicionar um trecho de código pronto que faça essa tarefa. Embora não seja o foco da nossa formação, é importante para que possamos prosseguir. Salvar este arquivo diminuirá o uso de recursos na API.

Trecho de código a ser adicionado:

with open(f"texto_completo_{nome_arquivo}.txt", "w",encoding='utf-8') as arquivo_texto:
    arquivo_texto.write(transcricao)

    return transcricao

O resultado pode ser visto abaixo.

def openai_whisper_transcrever(caminho_audio, nome_arquivo, modelo_whisper, openai):
    print("Estou transcrevendo com o Whisper…")
    
    audio = open(caminho_audio, "rb")
    
    resposta = openai.Audio.transcribe(
        api_key=openai.api_key,
        model = modelo_whisper,
        file = audio
    )
    
    transcricao = resposta.text
    
    with open(f"texto_completo_{nome_arquivo}.txt", "w",encoding='utf-8') as arquivo_texto:
    arquivo_texto.write(transcricao)

    return transcricao

O que esse trecho de código faz?

Na linha arquivo_texto.write(transcricao), vamos abrir um arquivo de texto que ainda não foi criado. Se ele já foi criado, vamos sobrescrever esse arquivo. Vamos dar um nome para esse arquivo, logo, usamos um prefixo que é texto_completo.

Na linha with open(f"texto_completo_{nome_arquivo}.txt", "w",encoding='utf-8') as arquivo_texto: Nós pegamos o nome_arquivo que passamos por parâmetro e que será importante para mantermos a organização dos arquivos que criamos ao longo desse processo.

O arquivo será um arquivo de texto. Vamos escrever, utilizando o alfabeto de símbolos utf-8, que faz sentido para o nosso idioma, que é o português (Brasil), e vamos definir esse arquivo com o apelido arquivo_texto.

Portanto, em arquivo_texto.write(transcricao), escreveremos em arquivo_texto essa transcrição que veio do Whisper e vamos retornar essa transcrição na linha return transcricao para que o resto da nossa aplicação possa consumir este processo.

Agora vamos executar o nosso programa. Para isso, vamos minimizar o explorador lateral novamente e aumentar a área do terminal, arrastando a sua borda superior para cima com o cursor.

Vamos executar para vermos a nossa transcrição sendo gerada a partir dessa comunicação com o Whisper. Clicaremos no ícone de triângulo apontado para a esquerda, chamado "Run Python File" ("Executar Arquivo Python") para iniciar a execução.

Notaremos no terminal a mensagem "Estou transcrevendo com o Whisper…", confirmando que ele entrou em nossa função, logo, está transcrevendo dentro desse processo. Isso pode demorar alguns segundos durante a compilação para poder verificar o resultado dessa comunicação com o Whisper.

Após finalizar o processo de transcrição, ele retornará ao nosso ambiente de trabalho.

Para conferir como nós salvamos esse arquivo e também para facilitar a movimentação de arquivos, podemos abrir novamente o explorador lateral para verificar em seu interior que nosso arquivo está embaixo do arquivo main.py.

código_alura
podcasts
.env
main.py
texto_completo_hipsters_154_testes_short.txt

Ele está nomeado como "texto completo" junto ao nome do nosso podcast, "hipsters_154_testes". Se o selecionarmos, ele vai mostrar em seu interior o nosso texto transcrito por completo.

O GPT vai trazer algumas informações com uma linguagem um pouco diferente e é importante que, durante esse processo de interação, verifiquemos essas interações, dando para a plataforma comandos e instruções, para tentar trazer mais naturalidade ao tipo de transcrição que esperamos desse texto para a nossa pessoa usuária final.

Contudo, concluímos a nossa missão desse momento: fazer a transcrição do áudio em texto para que possamos manipular esse texto e extrair outras informações nas próximas aulas.

Sobre o curso OpenAI: criando uma postagem para o Instagram com IA Generativa

O curso OpenAI: criando uma postagem para o Instagram com IA Generativa possui 118 minutos de vídeos, em um total de 33 atividades. Gostou? Conheça nossos outros cursos de IA para Programação em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

Transcrição de Áudio com a API Whisper da OpenAI
Sumarização de Textos e Extração de Dados com a GPT API da OpenAI
Geração de Imagens com a DALL-E API da OpenAI
Automação de Postagens no Instagram