Create app.py

app.py

@@ -0,0 +1,299 @@
+import warnings
+warnings.filterwarnings("ignore")
+
+import os
+import re
+import pywt
+import librosa
+import webrtcvad
+import nbimporter
+import torchaudio
+import numpy as np
+import gradio as gr
+import scipy.signal
+import soundfile as sf
+from scipy.io.wavfile import write
+from transformers import pipeline
+from transformers import AutoProcessor
+from pyctcdecode import build_ctcdecoder
+from transformers import Wav2Vec2ProcessorWithLM
+# from text2int import text_to_int
+# from isNumber import is_number
+# from Text2List import text_to_list
+# from convert2list import convert_to_list
+# from processDoubles import process_doubles
+# from replaceWords import replace_words
+# from applyVad import apply_vad
+# from wienerFilter import wiener_filter
+# from highPassFilter import high_pass_filter
+# from waveletDenoise import wavelet_denoise
+from scipy.signal import butter, lfilter, wiener
+
+asr_model_telugu = pipeline("automatic-speech-recognition", model="cdactvm/telugu_w2v-bert_model")
+asr_model_kannada = pipeline("automatic-speech-recognition", model="cdactvm/w2v_bert_kannada_030125")
+
+def createlex(filename):
+#filename = "num_map.txt"
+
+# Initialize an empty dictionary
+    data_dict = {}
+
+# Open the file and read it line by line
+    with open(filename, "r", encoding="utf-8") as f:
+        for line in f:
+        # Strip newline characters and split by tab
+            key, value = line.strip().split("\t")
+        # Add to dictionary
+            data_dict[key] = value
+    return data_dict
+
+tellex=createlex("num_words_tel.txt")   
+kanlex=createlex("num_words_kn.txt")
+def addnum(inlist):
+    sum=0
+    for num in inlist:
+        sum+=int(num)
+   
+    return sum
+
+from rapidfuzz import process
+def get_val(word, lexicon):
+    threshold = 80  # Minimum similarity score
+    length_difference = 4
+    #length_range = (4, 6)  # Acceptable character length range (min, max)
+
+    # Find the best match above the similarity threshold
+    result = process.extractOne(word, lexicon.keys(), score_cutoff=threshold)
+    print (result)
+    if result:
+        match, score, _ = result
+        #print(lexicon[match])
+        #return lexicon[match]
+        if abs(len(match) - len(word)) <= length_difference:
+        #if length_range[0] <= len(match) <= length_range[1]:
+            return lexicon[match]
+        else:
+            return None
+    else:
+        return None
+def convert2numtel(input, lex):
+    input += " #"  # Add a period for termination
+    words = input.split()
+    i = 0
+    num = 0
+    outstr = ""
+    digit_end = True
+    numlist = []
+    addflag = False
+    prevword=""
+    single_list=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,15,17,18,19]
+    # Process the words
+    while i < len(words):
+        #checkwordlist = handleSpecialnum(words[i])
+        
+        # Handle special numbers
+        #if len(checkwordlist) == 2:
+        #    words[i] = checkwordlist[0]
+        #    words.insert(i + 1, checkwordlist[1])  # Collect new word for later processing
+
+        # Get numerical value of the word
+        numval = get_val(words[i], lex)
+        if numval is not None:
+            if prevword not in single_list:
+                addflag = True
+                numlist.append(numval)
+            else:
+                if addflag:
+                    numlist.append(numval)
+                    num = addnum(numlist)
+                    outstr += str(num) + " "
+                    addflag = False
+                    numlist = []
+                else:
+                    outstr += " " + str(numval) + " "
+            digit_end = False
+            prevword=numval
+        else:
+            prevword=""
+            if addflag:
+                num = addnum(numlist)
+                outstr += str(num) + " " + words[i] + " "
+                addflag = False
+                numlist = []
+            else:
+                outstr += words[i] + " "
+            if not digit_end:
+                digit_end = True
+        
+        # Move to the next word
+        i += 1
+
+    # Final processing
+    outstr = outstr.replace('#','')  # Remove trailing spaces
+    return outstr
+
+def convert2numkn(input, lex):
+    input += " ######"  # Add a period for termination
+    words = input.split()
+    i = 0
+    num = 0
+    outstr = ""
+    digit_end = True
+    numlist = []
+    addflag = False
+    
+    prevword = []
+    
+    # Process the words
+    while i < len(words):
+        
+        # Get numerical value of the word
+        numval = get_val(words[i], lex)
+        if len(prevword)>=3:
+            prevword.pop(0)
+            prevword.append(words[i])
+        else:
+            prevword.append(words[i])
+        if numval is not None:
+           
+            addflag = True
+           
+            numlist.append(numval)
+           
+        else:
+           
+            
+            #print("word--->"+words[i])
+            #print("addflagword--->"+str(addflag))
+            prevwords=" ".join(prevword)
+            #print("prev word--->"+prevwords)
+            numval=get_val(prevwords,lex)
+            if numval is not None:
+                #addflag=True
+                #print("numval " +numval)
+                numlist=[]
+                #print("First outstr--->"+outstr)
+                
+                
+                outwords = outstr.split()
+                outstr=" ".join(outwords[:-1])
+                #print("outstr--->"+outstr)
+                
+                outstr += " " + str(numval) + " " 
+                #print(" aoutstr--->"+outstr)
+                numval=0
+                addflag=False
+                
+            else:
+                if addflag:
+                    num = addnum(numlist)
+                    outstr += str(num) + " " + words[i] + " "
+                    #print("penlast outstr--->"+outstr)
+                    addflag = False
+                    numlist = []
+                else:
+                    outstr += words[i] + " "
+                    #print("last outstr--->"+outstr)
+                if not digit_end:
+                    digit_end = True
+        
+        
+       
+        # Move to the next word
+        i += 1
+
+    # Final processing
+    outstr = outstr.replace('#','')  # Remove trailing spaces
+    return outstr
+    
+# Function to apply a high-pass filter
+def high_pass_filter(audio, sr, cutoff=300):
+    nyquist = 0.5 * sr
+    normal_cutoff = cutoff / nyquist
+    b, a = butter(1, normal_cutoff, btype='high', analog=False)
+    filtered_audio = lfilter(b, a, audio)
+    return filtered_audio
+
+# Function to apply wavelet denoising
+def wavelet_denoise(audio, wavelet='db1', level=1):
+    coeffs = pywt.wavedec(audio, wavelet, mode='per')
+    sigma = np.median(np.abs(coeffs[-level])) / 0.5
+    uthresh = sigma * np.sqrt(2 * np.log(len(audio)))
+    coeffs[1:] = [pywt.threshold(i, value=uthresh, mode='soft') for i in coeffs[1:]]
+    return pywt.waverec(coeffs, wavelet, mode='per')
+
+# Function to apply a Wiener filter for noise reduction
+def apply_wiener_filter(audio):
+    return wiener(audio)
+
+    
+# Function to handle speech recognition
+def recognize_speech_telugu(audio_file):
+    audio, sr = librosa.load(audio_file, sr=16000)
+    #audio = high_pass_filter(audio, sr)
+    #audio = apply_wiener_filter(audio)
+    #denoised_audio = wavelet_denoise(audio)
+    #result = asr_model_telugu(denoised_audio)
+    result = asr_model_telugu(audio)
+    text_value = result['text']
+    print (text_value)
+    cleaned_text = text_value.replace("<s>", "")
+    converted_text=convert2numtel(cleaned_text,tellex)
+    # cleaned_text=convert2num(cleaned_text,lex)
+    # converted_to_list = convert_to_list(cleaned_text, text_to_list())
+    # processed_doubles = process_doubles(converted_to_list)
+    # replaced_words = replace_words(processed_doubles)
+    # converted_text = text_to_int(replaced_words)
+    return cleaned_text +" -----------------> " + converted_text
+    #return cleaned_text
+
+    # Function to handle speech recognition
+def recognize_speech_kannada(audio_file):
+    audio, sr = librosa.load(audio_file, sr=16000)
+    audio = high_pass_filter(audio, sr)
+    audio = apply_wiener_filter(audio)
+    denoised_audio = wavelet_denoise(audio)
+    result = asr_model_kannada(denoised_audio)
+    text_value = result['text']
+    cleaned_text = text_value.replace("[UNK]", "")
+    converted_text=convert2numkn(cleaned_text,kanlex)
+    #converted_text=convert2num(cleaned_text,lex)
+    # cleaned_text=convert2num(cleaned_text,lex)
+    # converted_to_list = convert_to_list(cleaned_text, text_to_list())
+    # processed_doubles = process_doubles(converted_to_list)
+    # replaced_words = replace_words(processed_doubles)
+    # converted_text = text_to_int(replaced_words)
+    return cleaned_text +" -----------------> " + converted_text
+
+def sel_lng(lng, mic=None, file=None):
+    if mic is not None:
+        audio = mic
+    elif file is not None:
+        audio = file
+    else:
+        return "You must either provide a mic recording or a file"
+    
+    if lng == "Telugu":
+        return recognize_speech_telugu(audio)
+    elif lng == "Kannada":
+        return recognize_speech_kannada(audio)
+    # elif lng== "model_3":
+    #     return transcribe_hindi_lm(audio)
+    # elif lng== "model_4":
+    #     return Noise_cancellation_function(audio)
+            
+        
+demo=gr.Interface(
+    fn=sel_lng, 
+      
+    inputs=[
+        gr.Dropdown([
+            "Telugu","Kannada"],label="Select Model"),
+        gr.Audio(sources=["microphone","upload"], type="filepath"),
+    ],
+    outputs=[
+        "textbox"
+    ],
+    title="Automatic Speech Recognition",
+    description = "Demo for Automatic Speech Recognition. Use microphone to record speech. Please press Record button. Initially it will take some time to load the model. The recognized text will appear in the output textbox",
+      ).launch()