Command for transcribing multiple audio files at once

[IkeDoku]

Currently, I am using "whisper audio-1.wav audio-2.wav audio-3.wav ... --model medium" to transcribe my audio files. Is there a more elegant way of transcribing each file? It gets very stuffed in the prompt with around 900 audio file names. Also I've been noticing that within the anaconda prompt whisper transcribes up to around 900 audio snippets at a time. Can I increase the number of audio files to transcribe? Or how can I automate the anaconda prompt to start a new transcription job when the last one is done?

[jongwook]

As it is currently implemented, transcribe.py only handles one file at a time. This could be improved by allowing batch inference, but it quickly gets messy with different lengths between files and fallbacks. Alternatively, If you have more enough memory, you could run multiple whisper commands in parallel.

OR if your question is not about speed and about automating the transcription of 900+ audio files, you could create a script like:

whisper audio-1.wav audio-2.wav audio-3.wav ... --model medium
whisper audio-11.wav audio-12.wav audio-13.wav ... --model medium
...

and run it by bash script.sh or script.bat depending on your OS/platform.

[IkeDoku]

Thank you! I will try that and give you some feedback.

[Blair-Johnson]

I started a discussion about my initial implementation of a batched version at #662.

[Anto5040]

Hi @jongwook ! I have used some online tools based on whisper that transcribe your audio. Do you think they are doing the transcription file by file? I thought they could process them in parallel, but seeing your answer I highly doubt it. Do you have something in your mind about how they might be working?
Thank you!

[jongwook]

It's hard for me to guess without seeing the source code, but it's technically possible to parallelize within file by chunking the audio in to smaller segments and running them in batch inference or in multiple devices. whisper-jax took this approach.

[glangford]

Why not use something like this from your shell

for f in *.wav ; do whisper $f --model medium ; done

[IkeDoku]

whisper *.wav --model medium might return "bash: /my/example/path: Argument list is too long". Tried to process around 3000 files. But I can transcribe a lot more than 900 small files at the same time compared to using whisper audio-1.wav audio-2.wav audio-3.wav ... --model medium. Around 1500 files at once are possible via shell command. Also, I could run the anaconda prompt and the shell at the same time ofc both being slower separately but the amount of transcriptions made would be similar to running one of the methods on its own.
Regarding the error maybe one can increase ARGMAX of the shell to take more arguments...

[cndhng]

I'm very new to open source cmd unities like Whisper, so may I ask what for f in *.wav ; do whisper $f --model medium ; done is exactly used in the cmd.exe? let say I have a folder of 24 audio files. Thank you so much in advance.

[Arlen22]

Google "how to loop through a list of files in cmd". Here's a stack overflow question that looks promising: https://stackoverflow.com/questions/39615/how-to-loop-through-files-matching-wildcard-in-batch-file

[spookytomtom]

For anyone using Google Colab this anaconda loop (for f in *.wav ; do whisper $f --model medium ; done) works with Colab shell:

import glob
import subprocess
 
wav_files = glob.glob("*.wav")
print(wav_files)

for f in wav_files:
    subprocess.run(["whisper", f, "--model", "large", "--language", "en"])
    print(f"This file is ready: {f}")

[DylBP]

For anyone using Google Colab this anaconda loop (for f in *.wav ; do whisper $f --model medium ; done) works with Colab shell:

import glob
import subprocess
 
wav_files = glob.glob("*.wav")
print(wav_files)

for f in wav_files:
    subprocess.run(["whisper", f, "--model", "large", "--language", "en"])
    print(f"This file is ready: {f}")

This solution worked for me, outputs the transcription to multiple formats. Thanks spookytomtom.

[FurkanGozukara]

I plan to program a software to batch process video files with Whisper by command prompt execution programmatically. You can subscribe and stay tuned for it : https://www.youtube.com/c/SECourses

[Arlen22]

I just generate the list of files in bash and dump them all into the command line. If you have problems with argument length you could maybe do 10 or 100 at a time.

This does all the files in the current folder, but you can obviously change that. I'm sure you could also move the whisper command into the loop and run it after the array is a certain length then reset the array.

args=()

for FILE in *.mp4
do
  if [ -f "$FILE".txt ]; then
    # skip files that are already generated
    true 
  else 
    args+=("$FILE")
  fi
done

whisper --model medium.en --language en ${args[@]}

[cndhng]

Hi I'm still quite new to cmd line and executing this kind of program. I wonder how would you place your lines in the cmd.exe with an example. So I am having 24 audio files in it. Thank you so much.

[Arlen22]

Sorry, this is for bash, not cmd.exe. If you're on windows and you really want bash you can either use Git Bash or WSL.

[FurkanGozukara]

Hi I'm still quite new to cmd line and executing this kind of program. I wonder how would you place your lines in the cmd.exe with an example. So I am having 24 audio files in it. Thank you so much.

Hello. I have automation for CMD here a tutorial video : https://www.youtube.com/watch?v=dP53wzLwqMA

[FurkanGozukara]

I have programmed a batch processing software and it is freely available on github

The software also supports multi-threading as well

https://www.youtube.com/watch?v=dP53wzLwqMA

[DNL-22]

Just do a for loop,

import whisper
import os

Get a list of all the audio files in the "data" folder

audio_files = [f for f in os.listdir("data") if f.endswith('.wav')]

Initialize an empty list to store the transcriptions

transcriptions = []

Loop over all the audio files in the "data" folder

for audio_file in audio_files:
audio_file_path = os.path.join("data", audio_file)
result = model.transcribe(audio_file_path)
transcription = str(result)
transcriptions.append(transcription)

[YaoYYoung]

In PowerShell, you can do like below:

Get-ChildItem . -i *.mp4 -r | ForEach-Object{
$directory= $_.Directory
$filename = $_.BaseName
whisper.exe $_ --model medium --language 'Chinese' --output_format txt --output_dir $dir --task transcribe --word_timestamps True --verbose True > $dir\$filename.md
}

Here,the $filename.md contains the text with timestamps, and the $filename.txt contains the text without timestamps.

[Purfview]

There are few examples for batch processing of multiple files [for Windows]: Purfview/whisper-standalone-win#29

Or better use standalone Faster-Whiper which supports batching out of the box, few usage examples:

whisper-faster.exe "D:\Clips\*.mkv" --language=en --model=medium

whisper-faster.exe "D:\Audio" --language=en --model=medium --batch_recursive=True

whisper-faster.exe "D:\Band\Album.m3u" --language=en --model=medium --vad_filter=False

[hugonl31]

Certainly! Here's the script that meets your requirements:

# This script searches for .mp3 files in the current directory,
# excludes those already processed, and performs batch processing.

# Get the list of .mp3 files in the current directory
$mp3Files = Get-ChildItem -Filter *.mp3

# Create an empty list to store the files to be processed
$filesToProcess = @()

# Iterate through each .mp3 file
foreach ($file in $mp3Files) {
    # Check if a corresponding .txt file exists
    $txtFile = $file.FullName -replace '\.mp3$', '.txt'
    if (-not (Test-Path $txtFile)) {
        # If .txt file doesn't exist, add the .mp3 file to the list
        $filesToProcess += $file
    }
}

# Check if there are any files to process
if ($filesToProcess.Count -eq 0) {
    Write-Host "All files already processed."
    return
}

# Print the number of items found and start the process
Write-Host "$($filesToProcess.Count) items found, starting process..."

# Process each .mp3 file
foreach ($fileToProcess in $filesToProcess) {
    $mp3FileName = $fileToProcess.Name
    Write-Host "Processing $mp3FileName..."
    
    # Execute the process using the whisper command
    $processResult = whisper --model base.en "$mp3FileName"

    # Check if the process was successful by searching for the corresponding .txt file
    $txtFile = $fileToProcess.FullName -replace '\.mp3$', '.txt'
    if (-not (Test-Path $txtFile)) {
        Write-Host "Something went wrong while processing $mp3FileName."
    }
}

# Check if all files were successfully processed
$processedFiles = Get-ChildItem -Filter *.txt
if ($processedFiles.Count -eq $mp3Files.Count) {
    Write-Host "All $($mp3Files.Count) files successfully processed."
} else {
    $unprocessedCount = $mp3Files.Count - $processedFiles.Count
    Write-Host "Only $($processedFiles.Count) successfully processed, but $unprocessedCount items not processed, something went wrong."
}

To use this script:

Open a text editor and paste the script into a new file. Save the file with a .ps1 extension, for example, batch_process.ps1.
Open PowerShell 6.
Change the directory to the location where the script file is saved. For example, if the file is saved on the desktop, you can use the command cd C:\Users\YourUsername\Desktop.
Run the script by entering its filename (including the .ps1 extension) and pressing Enter. In this example, you would enter .\batch_process.ps1.
The script will search for .mp3 files in the current directory, exclude those that already have a corresponding .txt file, and then batch process the remaining .mp3 files. It will print the progress as it processes each file and provide a summary at the end indicating whether all files were successfully processed or if any errors occurred during processing.

[jman8888]

This worked for me well forfiles -c "cmd /c whisper @file --model medium"

[robocallwall]

The following is a CMD (DOS/Windows) batch file to process 16 (you can adjust based on file name length) files at a time. Using this to eliminate whisper startup costs running on CPU (no video card) the batch saved 12% of the time. (319 files, 293 minutes instead of 333 minutes).

DOS command line limit (total length) does limit how many files you can put on a single call. I did 16 to test with long file names. Limit might be 8191 characters. I later ran with 100 files per whisper call and that worked. Larger number of files will save more time.

Original was a batch file like this (one whisper call per file, 333 minutes):

for %%f in (*.wav) do ( whisper --language en %%f )

Groups of 16 were run using this batch file (one whisper startup with 16 audio files, 293 minutes):

@echo off
setlocal enabledelayedexpansion

rem Initialize variables
set "args="
set "counter=0"

rem Loop through all wav files in the current directory
for %%F in (*.wav) do (
    rem Check if corresponding txt file exists
    if not exist "%%~nF.txt" (
        rem If not, add the wav file to the array
        set "args=!args! "%%F""
        set /a "counter+=1"
        
        rem Execute the command when the counter reaches 16  **   change the line below to increase count **
        if !counter! equ 16 (
            call :processArgs
            set "args="
            set "counter=0"
        )
    )
)

rem Process any remaining arguments
if not "!args!" == "" (
    call :processArgs
)

rem Display the array contents (optional)
echo Arguments: %args%

endlocal
goto :eof

:processArgs
rem Add your command here using %args%
echo Processing arguments: %args%
whisper --language en %args%
goto :eof

[tom-huntington]

Doing this in a shell loop is a terrible idea if you have lots of short files.

Most of the work will be spent loading the model repeatedly.

You really want to persist the model in memory by writing you own python script with model.transcribe in a loop

import whisper

model = whisper.load_model("base")
result = model.transcribe("audio.mp3")
print(result["text"])

[apoorv-gupta]

This shell command will run a separate whisper instance for each audio file in your directory and create corresponding srt files. It will run 3 instances of Whisper in parallel, which would process files more quickly if your PC can handle it. If it finds that the corresponding srt file already exists, it will skip that audio file.

It will write the commands it is running to the screen.
Replace -t in xargs with -p if you want it to ask y/n before running the commands.

for wav in $(ls *.WAV); do
name="${wav%%.*}"
srt="$name".srt
if [ ! -f "$srt" ]; then
  echo $wav
fi
done | xargs -t -n 1 -P 3 whisper --model large --language en --task transcribe --output_format srt

This script may need to be tweaked to support filenames with spaces. Writing a makefile for this would be more robust.

[rkiotech]

I've made a fork that offers batch inference of audio files.
https://github.com/rkiotech/whisper_parallel_inferencing

[dgoryeo]

I was reading the code in the section for Parallel Audio files transcriptions, and I was wondering.: how is the final output mapped to corresponding audio file?

[Navanit-git]

what was the accuracy ?