initial Commit

app.py

@@ -0,0 +1,140 @@
+import gradio as gr
+import numpy as np
+import librosa
+import hashlib
+import json
+import os
+
+from scipy.io.wavfile import write as wav_write
+from check import transcibe, estimate_audio_quality
+
+def visible():
+    return gr.update(visible=True),gr.update(visible=True)
+
+def check(audio:gr.Audio):
+
+    sr, audio = audio
+    audio = audio.astype(np.float32)
+    if len(audio.shape) > 2 and audio.shape[1] > 1:
+        audio = np.mean(audio, axis=1)
+
+    quality, quality_score, features = estimate_audio_quality(audio, sr)
+    audio_resampled = librosa.resample(audio, orig_sr=sr, target_sr=16000)
+    transcription = transcibe(audio_resampled, 16000)
+
+    check_result = f"""
+    ### Results
+
+    Qualtiy (0-1):{quality_score}   - {quality}
+
+    Feautes:
+    """
+
+    for key, value in features.items():
+        check_result += f"""
+    - {key}:   {round(value,3)}
+    """
+
+    return transcription, check_result
+
+def generate_sample_id(audio, transcription):
+    # Combine the audio and transcription into a single string
+    combined = f"{audio.tostring()}{transcription}"
+    
+    # Generate a hash of the combined string
+    sample_id = hashlib.sha256(combined.encode('utf-8')).hexdigest()
+    
+    return sample_id[:10]  # Return the first 10 characters of the hash as the ID
+
+
+def save_sample(audio, transcription, check_result):
+    sample_id = generate_sample_id(audio, transcription)
+
+    # Create a directory to save the sample
+    directory = f"{sample_id}_data"
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+    
+    # Save the audio as a .wav file
+    audio_filename = os.path.join(directory, f"{sample_id}.wav")
+    wav_write(audio_filename, 16000, audio)  # Assuming a sample rate of 16kHz
+    
+    # Save the transcription as a .txt file
+    transcription_filename = os.path.join(directory, f"{sample_id}_transcription.txt")
+    with open(transcription_filename, 'w') as f:
+        f.write(transcription)
+    
+    # Save the check_result as a JSON file
+    check_result_filename = os.path.join(directory, f"{sample_id}_features.json")
+    with open(check_result_filename, 'w') as f:
+        json.dump(check_result, f)
+
+with gr.Blocks() as app:
+
+    gr.Markdown("# Open ASR Dataset")
+    gr.Markdown("   ")
+    gr.Markdown("This App is an effort to collectively crowdsource a new Dataset for the ASR community")
+    # gr.Markdown("You can Access the Dataset (here)[LINK]")
+    gr.Markdown("The Dataset will be updated every 100 created samples")
+    gr.Markdown("   ")
+    gr.Markdown("Create a New Sample")
+
+
+    new_audio = gr.Audio(
+        label = "Add Audio",
+        sources=['upload','microphone']
+    )
+    with gr.Row():
+
+        language = gr.Radio(
+            label="Spoken Language",
+            choices=["English","French","Spanish","German","Italian", "Chinese", "Japanese", "Arabic", "Russian", "Portuguese"],
+            value= "English",
+            scale=4
+        )
+
+        bckgrnd_noise = gr.Radio(
+            label="Background Noise Level",
+            choices=["Quiet", "Moderate", "Noisy"],
+            value="Moderate",
+            scale=2
+        )
+        
+        recording_env = gr.Radio(
+            label="Recording Environment",
+            choices=["Studio", "Home", "Outdoors", "Office"],
+            value="Home",
+            scale=2
+        )
+
+    check_sample_btn = gr.Button(
+        value="Check Sample",
+        variant="secondary",
+        size="sm"
+    )
+    
+    with gr.Row():
+
+        check_result = gr.Markdown()
+
+        transcription = gr.TextArea(
+            label="Transcription",
+            visible=False,
+            interactive=True
+        )
+
+    save_sample_button = gr.Button(
+        value="Save Sample",
+        variant="primary",
+        size="sm",
+        scale=1,
+        visible=False
+    )
+
+    check_sample_btn.click(visible, outputs=[transcription, save_sample_button])
+    check_sample_btn.click(check, inputs=[new_audio], outputs=[transcription, check_result])
+    
+    save_sample_button.click(save_sample, inputs=[new_audio, transcription, check_result])
+
+
+app.launch()

check.py

@@ -0,0 +1,109 @@
+from transformers import WhisperProcessor, WhisperForConditionalGeneration
+import numpy as np
+import librosa
+
+processor = WhisperProcessor.from_pretrained("openai/whisper-large-v2")
+model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-large-v2")
+model.config.forced_decoder_ids = None
+
+
+
+
+def transcibe(audio:np.ndarray, sr:int):
+    input_features = processor(audio, sampling_rate=sr, return_tensors="pt").input_features 
+    predicted_ids = model.generate(input_features)
+    transcription = processor.batch_decode(predicted_ids, skip_special_tokens=False)
+    transcription = processor.tokenizer.normalize(transcription[0])
+    return transcription
+
+def audio_len(audio:np.ndarray, sr:int):
+    return len(audio) / sr
+
+def rms_energy(audio: np.ndarray):
+    return np.sqrt(np.mean(audio**2))
+
+def zero_crossing_rate(audio: np.ndarray):
+    return np.mean(np.abs(np.diff(np.sign(audio))))
+
+def spectral_centroid(audio: np.ndarray, sr: int):
+    return librosa.feature.spectral_centroid(y=audio, sr=sr).mean()
+
+def spectral_bandwidth(audio: np.ndarray, sr: int):
+    return librosa.feature.spectral_bandwidth(y=audio, sr=sr).mean()
+
+def mfccs(audio: np.ndarray, sr: int, n_mfcc: int = 13):
+    return librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=n_mfcc).mean(axis=1)
+
+def chroma_features(audio: np.ndarray, sr: int):
+    return librosa.feature.chroma_stft(y=audio, sr=sr).mean(axis=1)
+
+def signal_to_noise_ratio(audio: np.ndarray):
+    signal_power = np.mean(audio ** 2)
+    noise_power = np.var(audio)
+    return 10 * np.log10(signal_power / noise_power)
+
+def tempo(audio: np.ndarray, sr: int):
+    onset_env = librosa.onset.onset_strength(y=audio, sr=sr)
+    return librosa.beat.tempo(onset_envelope=onset_env, sr=sr)[0]
+
+def silence_ratio(audio: np.ndarray, threshold: float = 0.01):
+    return np.mean(np.abs(audio) < threshold)
+
+def estimate_audio_quality(audio: np.ndarray, sr: int):
+    # Compute features
+    snr = signal_to_noise_ratio(audio)
+    rms = rms_energy(audio)
+    silence = silence_ratio(audio)
+    spectral_centroid = librosa.feature.spectral_centroid(y=audio, sr=sr).mean()
+    spectral_bandwidth = librosa.feature.spectral_bandwidth(y=audio, sr=sr).mean()
+    zcr = zero_crossing_rate(audio)
+    
+    # Normalize features (example normalization, adjust as necessary)
+    snr_norm = np.clip(snr / 50.0, 0, 1)  # Assuming 50 dB is very good
+    rms_norm = np.clip(rms / np.max(np.abs(audio)), 0, 1)  # Normalizing by max amplitude
+    silence_norm = 1 - silence  # Less silence is better
+    spectral_centroid_norm = np.clip(spectral_centroid / sr, 0, 1)
+    spectral_bandwidth_norm = np.clip(spectral_bandwidth / (sr/2), 0, 1)
+    zcr_norm = np.clip(zcr / 0.1, 0, 1)  # Assuming 0.1 as an acceptable ZCR
+    
+    features = {
+        "snr_nrom":snr_norm,
+        "rms_norm":rms_norm,
+        "silence_norm":silence_norm,
+        "spectral_centroid":spectral_centroid_norm,
+        "spectral_bandwidth_norm":spectral_bandwidth_norm,
+        "zcr_norm":zcr_norm
+    }
+
+
+    # Weighting features
+    weights = {
+        "snr": 0.25,
+        "rms": 0.2,
+        "silence": 0.2,
+        "spectral_centroid": 0.1,
+        "spectral_bandwidth": 0.15,
+        "zcr": 0.1
+    }
+    
+    # Calculate overall quality score
+    quality_score = (
+        weights["snr"] * snr_norm +
+        weights["rms"] * rms_norm +
+        weights["silence"] * silence_norm +
+        weights["spectral_centroid"] * spectral_centroid_norm +
+        weights["spectral_bandwidth"] * spectral_bandwidth_norm +
+        weights["zcr"] * zcr_norm
+    )
+    
+    # Interpret the score
+    if quality_score > 0.85:
+        quality = "Excellent"
+    elif quality_score > 0.7:
+        quality = "Good"
+    elif quality_score > 0.5:
+        quality = "Fair"
+    else:
+        quality = "Poor"
+    
+    return quality, round(quality_score, 3), features