Upload test3.py with huggingface_hub

test3.py

@@ -0,0 +1,214 @@
+import argparse
+import os
+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
+
+mtypes = {"cpu": "int8", "cuda": "float16"}
+
+# Initialize parser
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "-a", "--audio", help="name of the target audio file", 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 args.stemming:
+    # Isolate vocals from the rest of the audio
+    return_code = os.system(
+        f'python3 -m demucs.separate -n htdemucs --two-stems=vocals "{args.audio}" -o "temp_outputs"'
+    )
+    if return_code != 0:
+        logging.warning(
+            "Source splitting failed, using original audio file. Use --no-stem argument to disable it."
+        )
+        vocal_target = args.audio
+    else:
+        vocal_target = os.path.join(
+            "temp_outputs",
+            "htdemucs",
+            os.path.splitext(os.path.basename(args.audio))[0],
+            "vocals.wav",
+        )
+else:
+    vocal_target = args.audio
+
+# Transcribe the audio file
+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,
+    )
+
+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"),
+    )
+    # clear gpu vram
+    del alignment_model
+    torch.cuda.empty_cache()
+else:
+    assert (
+        args.batch_size == 0  # TODO: add a better check for word timestamps existence
+    ), (
+        f"Unsupported language: {language}, use --batch_size to 0"
+        " to generate word timestamps using whisper directly and fix this error."
+    )
+    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
+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
+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(args.audio))[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(args.audio)[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
+for segment in srt_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)