import argparse import os import glob from helpers import * from faster_whisper import WhisperModel import whisperx import torch from pydub import AudioSegment from nemo.collections.asr.models.msdd_models import NeuralDiarizer import logging import shutil import srt from tqdm import tqdm import concurrent.futures mtypes = {"cpu": "int8", "cuda": "float16"} def setup_logging(): logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') def process_audio_file(audio_file, args): logging.info(f"Processing file: {audio_file}") if args.stemming: # Isolate vocals from the rest of the audio logging.info("Performing source separation...") return_code = os.system( f'python3 -m demucs.separate -n htdemucs --two-stems=vocals "{audio_file}" -o "temp_outputs"' ) if return_code != 0: logging.warning("Source splitting failed, using original audio file.") vocal_target = audio_file else: vocal_target = os.path.join( "temp_outputs", "htdemucs", os.path.splitext(os.path.basename(audio_file))[0], "vocals.wav", ) else: vocal_target = audio_file # Transcribe the audio file logging.info("Transcribing audio...") if args.batch_size != 0: from transcription_helpers import transcribe_batched whisper_results, language = transcribe_batched( vocal_target, args.language, args.batch_size, args.model_name, mtypes[args.device], args.suppress_numerals, args.device, ) else: from transcription_helpers import transcribe whisper_results, language = transcribe( vocal_target, args.language, args.model_name, mtypes[args.device], args.suppress_numerals, args.device, ) logging.info("Aligning transcription...") if language in wav2vec2_langs: alignment_model, metadata = whisperx.load_align_model( language_code=language, device=args.device ) result_aligned = whisperx.align( whisper_results, alignment_model, metadata, vocal_target, args.device ) word_timestamps = filter_missing_timestamps( result_aligned["word_segments"], initial_timestamp=whisper_results[0].get("start"), final_timestamp=whisper_results[-1].get("end"), ) del alignment_model torch.cuda.empty_cache() else: word_timestamps = [] for segment in whisper_results: for word in segment["words"]: word_timestamps.append({"word": word[2], "start": word[0], "end": word[1]}) # Convert audio to mono for NeMo compatibility logging.info("Converting audio to mono...") sound = AudioSegment.from_file(vocal_target).set_channels(1) ROOT = os.getcwd() temp_path = os.path.join(ROOT, "temp_outputs") os.makedirs(temp_path, exist_ok=True) sound.export(os.path.join(temp_path, "mono_file.wav"), format="wav") # Initialize NeMo MSDD diarization model logging.info("Performing diarization...") msdd_model = NeuralDiarizer(cfg=create_config(temp_path)).to(args.device) msdd_model.diarize() del msdd_model torch.cuda.empty_cache() # Reading timestamps <> Speaker Labels mapping speaker_ts = [] with open(os.path.join(temp_path, "pred_rttms", "mono_file.rttm"), "r") as f: lines = f.readlines() for line in lines: line_list = line.split(" ") s = int(float(line_list[5]) * 1000) e = s + int(float(line_list[8]) * 1000) speaker_ts.append([s, e, int(line_list[11].split("_")[-1])]) wsm = get_words_speaker_mapping(word_timestamps, speaker_ts, "start") wsm = get_realigned_ws_mapping_with_punctuation(wsm) ssm = get_sentences_speaker_mapping(wsm, speaker_ts) # Create the autodiarization directory structure autodiarization_dir = "autodiarization" os.makedirs(autodiarization_dir, exist_ok=True) # Get the base name of the audio file base_name = os.path.splitext(os.path.basename(audio_file))[0] # Create a subdirectory for the current audio file audio_dir = os.path.join(autodiarization_dir, base_name) os.makedirs(audio_dir, exist_ok=True) # Create a dictionary to store speaker-specific metadata speaker_metadata = {} # Generate the SRT file srt_file = f"{os.path.splitext(audio_file)[0]}.srt" with open(srt_file, "w", encoding="utf-8") as f: write_srt(ssm, f) # Read the generated SRT file with open(srt_file, "r", encoding="utf-8") as f: srt_data = f.read() # Parse the SRT data srt_segments = list(srt.parse(srt_data)) # Process each segment in the SRT data logging.info("Processing audio segments...") for segment in tqdm(srt_segments, desc="Processing segments"): start_time = segment.start.total_seconds() * 1000 end_time = segment.end.total_seconds() * 1000 speaker_name, transcript = segment.content.split(": ", 1) # Extract the speaker ID from the speaker name speaker_id = int(speaker_name.split(" ")[-1]) # Split the audio segment segment_audio = sound[start_time:end_time] segment_path = os.path.join(audio_dir, f"speaker_{speaker_id}", f"speaker_{speaker_id}_{segment.index:03d}.wav") os.makedirs(os.path.dirname(segment_path), exist_ok=True) segment_audio.export(segment_path, format="wav") # Store the metadata for each speaker if speaker_name not in speaker_metadata: speaker_metadata[speaker_name] = [] speaker_metadata[speaker_name].append(f"speaker_{speaker_id}_{segment.index:03d}|{speaker_name}|{transcript}") # Write the metadata.csv file for each speaker for speaker_name, metadata in speaker_metadata.items(): speaker_id = int(speaker_name.split(" ")[-1]) speaker_dir = os.path.join(audio_dir, f"speaker_{speaker_id}") with open(os.path.join(speaker_dir, "metadata.csv"), "w", encoding="utf-8") as f: f.write("\n".join(metadata)) # Clean up temporary files cleanup(temp_path) logging.info(f"Finished processing {audio_file}") def main(): setup_logging() parser = argparse.ArgumentParser() parser.add_argument( "-a", "--audio", help="name of the target audio file or directory", required=True ) parser.add_argument( "--no-stem", action="store_false", dest="stemming", default=True, help="Disables source separation. This helps with long files that don't contain a lot of music.", ) parser.add_argument( "--suppress_numerals", action="store_true", dest="suppress_numerals", default=False, help="Suppresses Numerical Digits. This helps the diarization accuracy but converts all digits into written text.", ) parser.add_argument( "--whisper-model", dest="model_name", default="medium.en", help="name of the Whisper model to use", ) parser.add_argument( "--batch-size", type=int, dest="batch_size", default=8, help="Batch size for batched inference, reduce if you run out of memory, set to 0 for non-batched inference", ) parser.add_argument( "--language", type=str, default=None, choices=whisper_langs, help="Language spoken in the audio, specify None to perform language detection", ) parser.add_argument( "--device", dest="device", default="cuda" if torch.cuda.is_available() else "cpu", help="if you have a GPU use 'cuda', otherwise 'cpu'", ) args = parser.parse_args() if os.path.isdir(args.audio): audio_files = glob.glob(os.path.join(args.audio, "*.wav")) + glob.glob(os.path.join(args.audio, "*.mp3")) logging.info(f"Found {len(audio_files)} audio files in the directory.") with concurrent.futures.ThreadPoolExecutor() as executor: list(tqdm(executor.map(lambda f: process_audio_file(f, args), audio_files), total=len(audio_files), desc="Processing files")) else: process_audio_file(args.audio, args) if __name__ == "__main__": main()