How to Build Medical Transcription Software in Python

pip install pvcheetah

import argparse
import struct
import wave
from pvcheetah import create, CheetahActivationLimitError

def main():
    # Parse command line arguments
    parser = argparse.ArgumentParser()
    parser.add_argument('--access_key', required=True)
    parser.add_argument('--model_path', required=True)
    parser.add_argument('--audio_path', required=True)
    args = parser.parse_args()
    
    # Initialize Cheetah with custom model
    cheetah = create(
        access_key=args.access_key,
        model_path=args.model_path,
        enable_automatic_punctuation=True
    )
    
    try:
        # Open and validate audio file
        with wave.open(args.audio_path, 'rb') as f:
            if f.getframerate() != cheetah.sample_rate:
                raise ValueError(f"Audio must be {cheetah.sample_rate}Hz")
            if f.getnchannels() != 1:
                raise ValueError("Audio must be mono")
            if f.getsampwidth() != 2:
                raise ValueError("Audio must be 16-bit")
            
            # Read and convert audio data
            audio_buffer = f.readframes(f.getnframes())
            audio = struct.unpack(f'{len(audio_buffer) // 2}h', audio_buffer)
        
        # Process audio in chunks
        num_frames = len(audio) // cheetah.frame_length
        for i in range(num_frames):
            frame = audio[i * cheetah.frame_length:(i + 1) * cheetah.frame_length]
            partial_transcript, _ = cheetah.process(frame)
            print(partial_transcript, end='', flush=True)
        
        # Get remaining transcript
        final_transcript = cheetah.flush()
        print(final_transcript)
        
    except CheetahActivationLimitError:
        print('AccessKey limit reached')
    finally:
        # Clean up resources
        cheetah.delete()

if __name__ == '__main__':
    main()

python medical_transcriber.py \
    --access_key ${ACCESS_KEY} \
    --model_path /path/to/medical_model.pv \
    --audio_path /path/to/audio.wav

import argparse

# Calculate minimum edit distance between two word sequences
def edit_distance(ref, hyp):
    r, h = len(ref), len(hyp)
    dp = [[0] * (h + 1) for _ in range(r + 1)]
    # Initialize base cases
    for i in range(r + 1): dp[i][0] = i
    for j in range(h + 1): dp[0][j] = j
    # Fill DP table
    for i in range(1, r + 1):
        for j in range(1, h + 1):
            if ref[i-1] == hyp[j-1]:
                dp[i][j] = dp[i-1][j-1]
            else:
                dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1]) + 1
    return dp[r][h]

# Calculate Word Error Rate (WER) as percentage
def calculate_error_rate(ref, hyp):
    ref_words = ref.lower().split()
    hyp_words = hyp.lower().split()
    if not ref_words:
        return 0.0
    return (edit_distance(ref_words, hyp_words) / len(ref_words)) * 100

def main():
    # Parse command line arguments
    parser = argparse.ArgumentParser()
    parser.add_argument('--reference', required=True)
    parser.add_argument('--transcript', required=True)
    args = parser.parse_args()
    
    # Read input files
    ref = open(args.reference).read().strip()
    hyp = open(args.transcript).read().strip()
    
    # Calculate and display WER
    wer = calculate_error_rate(ref, hyp)
    print(f"WER: {wer:.2f}%")

if __name__ == '__main__':
    main()

python calculate_accuracy.py \
    --reference reference.txt \
    --transcript transcript.txt \