Executando verificação de segurança...
1
Omodei
5 min de leitura ·

Como converter audio em texto

Neste post, você vai aprender como utilizar a API da OpenAI para converter áudio em texto de forma eficiente. Através da utilização de ferramentas disponibilizadas pela OpenAI, é possível fazer transcrições automáticas de áudio com alta precisão.

Seguindo o fluxo...

1. Primeiramente, é necessário criar uma conta na plataforma da OpenAI e obter uma chave de API válida para acessar seus serviços. Você pode fazer isso visitando o site da OpenAI e seguindo as instruções para se cadastrar.

Para criar uma conta na plataforma da OpenAI, basta acessar esse link: https://platform.openai.com/signup

Acessando pagina de keys: Basta acessar o menu que fica no canto superior direito (Clica no avata)... acesse a opção View API Keys

Criando uma key: Agora é simples, basta clicar no botão Create new secrect key

Exemplo de key: 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

Agora vamos guardar essa key que vamos usar em breve.

2. Organizando o nosso ambiente

Vamos criar uma pasta para nosso projeto
> mkdir audio-to-text

Acessar a nossa pasta criada
> cd audio-to-text

Para não sujar a nossa maquina, vamos usar a virtualenv para criar uma ambiente virtual
> virtualenv audio-to-text

Agora precisamos ativar o nosso ambiente
> source audio-to-text/bin/activate

Pronto! Agora vamos poder instalar as nossas dependência

** Criando ambiente virtua**l
> virtualenv audio-to-text


# Ativando o ambiente
> source audio-to-text/bin/activate

# Instalando as dependências
> pip3 install openai
> pip3 install traceback
> pip3 install python-dotenv
> pip3 install argparse
> pip3 install pydub

3. Hora de pôr a mão no código!

**O código completo pode ser acessado no meu github: **https://github.com/rafaelomodei/audio-to-text

Adicionando a env no projeto. Crie um arquivo .env

Dentro do aquivo .env adicione a seguinte linha:
bash OPENAI_API_KEY = "SUA KEY AQUI"

Criar um arquivo main.py

Agora vamos importar as nossas dependências e criar nossas constantes:


import openai
import traceback
import argparse
import os, sys

from dotenv import load_dotenv
from pydub import AudioSegment
from typing import List, Any

load_dotenv()

if not os.getenv('OPENAI_API_KEY'):
    print('Missing OPENAI_API_KEY')
    sys.exit(1)

OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
openai.api_key = OPENAI_API_KEY


OUTPUT_PATH = 'output_split_sound/'
TIME_MINUTE = 60 * 1000
TEN_MINUTES = 10 * TIME_MINUTE

Criando uma função para fazer a leitura dos arquivos de áudio

def open_media(path: str):
    try:
        print('Carregando ao arquivo de mídia...')
        audio_file_import = AudioSegment.from_mp3(path)
        return audio_file_import
    except Exception:
        print('Erro ao carregar o arquivo de mídia')
        traceback.print_exc()
    finally: print('Mídia carregada com sucesso!')

Criando uma função para salvar o nosso resultado. Essa função é responsável por criar a pasta para salvar nossos arquivos, como áudio e arquivos .txt

Essa função sempre vai criar pastas que não existe no diretório atual

def create_folder(out_directory: str) -> str:
    if not os.path.exists(out_directory):
        os.makedirs(out_directory)
        return out_directory
    else:
        num_label_dir = 1

        while True: # enquanto o nome existir, continue

            out_directory_numbered = out_directory + '-' + str(num_label_dir)

            if not os.path.exists(out_directory_numbered):
                os.makedirs(str(out_directory + '-' + str(num_label_dir)))
                return out_directory_numbered
            else:
                num_label_dir = num_label_dir + 1

Criamos uma função que salva os arquivos de texto

def write_file(path: str, text_file: str):
    try:
        with open(path, 'w', encoding='utf-8') as file:
            file.write(text_file)
    except Exception:
        print('Erro ao salvar o arquivo: ', path)
        traceback.print_exc()

Como a API tem limitações, para processar o tamanho do arquivo, temos que contornar esse problema caso o nosso arquivo de áudio seja muito grande, portanto vamos criar uma função que corta o audio em tamanho de 10 min cada

def split_media(media: Any, label: str, out_dir: str) -> str and List[str]:


    try:
        print('Iniciando o fatiamento da mídia...')
        path_tracks: List[str] = []

        duration_ms_media: int = len(media) # Duração da mídia em ms
        duration_min_media: float  = duration_ms_media / TIME_MINUTE # Duração mídia em min 
        number_intervals: float = duration_min_media / 10 # Numero de intervalos | fatias
        number_intervals_normalized: int = int(round(number_intervals, 2))+1 # intervalo + 1

        out_directory = out_dir + '-' + label
        current_out_directory = create_folder(out_directory)

        for i in range(number_intervals_normalized):
            print('Corte',  i + 1, ' de ', number_intervals_normalized)

            start_time = TEN_MINUTES * i
            end_time = TEN_MINUTES * (i + 1)

            slice_track = media[start_time:end_time]

            path_tack = str(current_out_directory + '/' + label + '-' + str(i) + '.mp3')

            slice_track.export(path_tack, format="mp3")
            path_tracks.append(path_tack)

        return current_out_directory, path_tracks # Retorna a o dir de saida e o local das mídias fatiados

    except Exception:
        print('Erro ao fatiar a mídia')
        traceback.print_exc()

    finally:
        print('Fatiamento finalizado!')

Com os audios cortados agora sim podemos passar ele para API fazer a transcrição do audio para nos

def create_text(out_directory: str, path_tracks: List[str], label: str) -> None:
    print('Iniciando a transcrição da mídia...')

    for index, path in enumerate(path_tracks):
        try:
            print('Transcrição do corte ',  index+1, ' de ', len(path_tracks))
            audio_file= open(path, "rb")
            transcript = openai.Audio.transcribe("whisper-1", audio_file, response_format="text")
            print('Transcrição concluida!')
            path_text_out = str(out_directory + '/' + label + '-' + str(index) + '-text-out.txt')
            print('Salvando a transcrição!')

            write_file(path_text_out, transcript)

        except FileNotFoundError:
            print('Arquivo de mídia não foi encontrado!')
            traceback.print_exc()

E por fim instanciamos a nossa função main, usando a lib argparse para criar parâmetros de argumento para nosso excript

Diretório e o nome do arquivo a ser carregado, exemplo: --file audio-test.mp3

Label é um identificador da resposta a ser gerada: --label teste

Diretório de saída, onde deve ser salvo o texto de saída, por padrão o diretório é output: --out-dir output

def main(args):

    file = args.file
    label = args.label
    out_dir = args.out_dir


    audio = open_media(file)
    current_out_directory, path_tracks = split_media(audio, label, out_dir)

    create_text(current_out_directory, path_tracks, label)
    print("Finalizado!")


if __name__ == "__main__":

    parser = argparse.ArgumentParser(description='Use OpenAI Whisper para extrar texto de áudio e video')
    parser.add_argument('--file', type=str, required=True, help="O áudio ou video que vai ser extraido o texto")
    parser.add_argument('--label', type=str, required=True, help="Label identificar a resposta gerada")
    parser.add_argument('--out-dir', type=str, required=False, help="Diretório onde vai salvar o arquivo de saída", default="output")

    args = parser.parse_args()

    main(args)
  1. Por fim é hora de executar!
# Para visualizar os comandos
$ python3 main.py -h

# Por fim é hora de executar o script
$  python3 main.py --file audio-test.mp3 --label audio-test

# O script deve apresentar os passos que estão sendo realizado no momento
# Ao finalizar deve existir um novo diretório sem local
# E dentro contendo os arquivos relacionados a transcrição do da mídia

O código completo pode ser acessado no meu github: https://github.com/rafaelomodei/audio-to-text

By: Rafael G. Omodei

Carregando publicação patrocinada...