def __init__(self, model_name, trans_df): from espnet2.bin.asr_inference import Speech2Text from espnet_model_zoo.downloader import ModelDownloader import jiwer self.model_name = model_name d = ModelDownloader() self.asr_model = Speech2Text(**d.download_and_unpack(model_name)) self.input_txt_list = [] self.clean_txt_list = [] self.output_txt_list = [] self.transcriptions = [] self.true_txt_list = [] self.sample_rate = int( d.data_frame[d.data_frame["name"] == model_name]["fs"]) self.trans_df = trans_df self.trans_dic = self._df_to_dict(trans_df) self.mix_counter = Counter() self.clean_counter = Counter() self.est_counter = Counter() self.transformation = jiwer.Compose([ jiwer.ToLowerCase(), jiwer.RemovePunctuation(), jiwer.RemoveMultipleSpaces(), jiwer.Strip(), jiwer.SentencesToListOfWords(), jiwer.RemoveEmptyStrings(), ])
def on_record_button_toggled(self, button): if button.get_active(): self.reset_playback() f = open( os.path.join(self.training_dir, "%d.txt" % self.sample_id), 'w') f.write(self.sentence_text) f.close() self.wavrecfile.set_property( "location", os.path.join(self.training_dir, "%d.wav" % self.sample_id)) training_file = os.path.join("Deepspeech", "training-data", "%d.wav" % self.sample_id) stripped_text = jiwer.RemovePunctuation()( self.sentence_text).lower().encode("ascii", "ignore").decode().replace( "'", "") wavsize = os.stat(location).st_size if self.sample_id % 6 < 3: # Training sample self.training_csv.write( "%s,%d,%s" % (training_file, wavsize, stripped_text)) else: # Testing sample self.testing_csv.write("%s,%d,%s" % (training_file, wavsize, stripped_text)) self.record_pipeline.set_state(Gst.State.PLAYING) self.play_button.set_sensitive(True) self.have_sample = True else: self.reset_recording()
def on_test_message(self, bus, message): structure = message.get_structure() if structure and structure.get_name( ) == "deepspeech" and structure.get_value("intermediate") == False: self.recognised_text += structure.get_value("text") + "\n" self.training_progress.set_fraction( (self.testing_sample + 1) / self.sample_id) if self.testing_sample < self.sample_id - 1: self.test_pipeline.set_state(Gst.State.NULL) self.test_sample(self.testing_sample + 1) else: self.test_text = jiwer.RemovePunctuation()( self.test_text).lower().encode("ascii", "ignore").decode() print("Expected:", self.test_text) print("Got:", self.recognised_text) accuracy = 100 - jiwer.wer( self.test_text.replace("\n", " "), self.recognised_text.replace("\n", " ").replace("'", "")) * 100 if self.pretraining: pretraining_accuracy_label = self.builder.get_object( "pretraining_accuracy_label") pretraining_accuracy_label.set_text("%.2f%%" % accuracy) self.pretraining = False self.training = True status_label = self.builder.get_object("status_label") status_label.set_text("Training...") self.training_progress.set_fraction(0) if self.posttraining: posttraining_accuracy_label = self.builder.get_object( "posttraining_accuracy_label") posttraining_accuracy_label.set_text("%.2f%%" % accuracy) spinner = self.builder.get_object("spinner") spinner.set_active = False self.posttraining = False
def rmPunctuation(values): """preprocess the list of words to RemovePunctuation""" newValues = [] for v in values: newValue = jiwer.RemovePunctuation()(v) newValue = jiwer.Strip()(newValue) newValue = jiwer.RemoveMultipleSpaces()(newValue) newValues.append(newValue) return newValues
def calc_wer(ground_truth, hypothesis): transformation = jiwer.Compose([ jiwer.ToLowerCase(), jiwer.RemoveMultipleSpaces(), jiwer.Strip(), jiwer.ExpandCommonEnglishContractions(), jiwer.RemovePunctuation() ]) wer = jiwer.wer(ground_truth, hypothesis, truth_transform=transformation, hypothesis_transform=transformation) return wer
def compute_perc_script_missing(original_script, transcript, language): ''' Check how much of original_script is missing in transcript. Clean and remove stopwords ''' # print(original_script) # print(transcript) cleaning = jiwer.Compose([ jiwer.SubstituteRegexes({"¡": "", "¿":"", "á": "a", "é": "e", "í": "i", "ó": "o","ú": "u"}), jiwer.SubstituteWords({ "tardes": "dias", "noches": "dias", " uno ": " 1 ", " dos ": " 2 ", " tres ": " 3 ", " cuatro ": " 4 ", " cinco ": " 5 ", " seis ": " 6 ", " siete ": " 7 ", " ocho ": " 8 ", " nueve ": " 9 "}), jiwer.RemovePunctuation(), jiwer.ToLowerCase(), jiwer.SentencesToListOfWords(word_delimiter=" "), jiwer.RemoveEmptyStrings() ]) #Remove anything between ${variable} from original_script original_script_transformed = re.sub(r'\${.*?\}','',original_script) # print(original_script_transformed) #Clean both original_script_transformed = cleaning(original_script_transformed) transcript_transformed = cleaning(transcript) # print(original_script_transformed) #Remove stopwords from original_script original_script_transformed_no_stopwords = remove_stopwords(original_script_transformed, language) if len(original_script_transformed_no_stopwords) != 0: #Sometimes removing stopwords removes all words from script original_script_transformed = original_script_transformed_no_stopwords #Lemmatize transcript stemmer = get_stemmer(language) transcript_transformed_stem = [stemmer.stem(word) for word in transcript_transformed] #Get words form original_script_transformed whose stem is not in transcript_transformed_stem words_missing = [word for word in original_script_transformed if stemmer.stem(word) not in transcript_transformed_stem] return len(words_missing)/len(original_script_transformed), words_missing
def sentence_wer(reference: str, prediction: str): transformation = jiwer.Compose([ jiwer.RemoveMultipleSpaces(), jiwer.RemovePunctuation(), jiwer.Strip(), jiwer.ToLowerCase(), jiwer.ExpandCommonEnglishContractions(), jiwer.RemoveWhiteSpace(replace_by_space=True), jiwer.SentencesToListOfWords(), jiwer.RemoveEmptyStrings(), ]) return jiwer.wer(reference.strip(), prediction.strip(), truth_transform=transformation, hypothesis_transform=transformation)
def normalize_sentence(sentence): """Normalize sentence""" # Convert all characters to upper. sentence = sentence.upper() # Delete punctuations. sentence = jiwer.RemovePunctuation()(sentence) # Remove \n, \t, \r, \x0c. sentence = jiwer.RemoveWhiteSpace(replace_by_space=True)(sentence) # Remove multiple spaces. sentence = jiwer.RemoveMultipleSpaces()(sentence) # Remove white space in two end of string. sentence = jiwer.Strip()(sentence) # Convert all characters to upper. sentence = sentence.upper() return sentence
def evaluate(testset, audio_directory): model = deepspeech.Model('deepspeech-0.7.0-models.pbmm') model.enableExternalScorer('deepspeech-0.7.0-models.scorer') predictions = [] targets = [] for i, datapoint in enumerate(testset): audio, rate = sf.read( os.path.join(audio_directory, f'example_output_{i}.wav')) assert rate == model.sampleRate(), 'wrong sample rate' audio_int16 = (audio * (2**15)).astype(np.int16) text = model.stt(audio_int16) predictions.append(text) target_text = unidecode(datapoint['text']) targets.append(target_text) transformation = jiwer.Compose( [jiwer.RemovePunctuation(), jiwer.ToLowerCase()]) targets = transformation(targets) predictions = transformation(predictions) logging.info(f'targets: {targets}') logging.info(f'predictions: {predictions}') logging.info(f'wer: {jiwer.wer(targets, predictions)}')
def analyze(): try: req_data = request.get_json() compose_rule_set = [] if req_data.get('to_lower_case', False) == True: compose_rule_set.append(jiwer.ToLowerCase()) if req_data.get('strip_punctuation', False) == True: compose_rule_set.append(jiwer.RemovePunctuation()) if req_data.get('strip_words', False) == True: compose_rule_set.append(jiwer.Strip()) if req_data.get('strip_multi_space', False) == True: compose_rule_set.append(jiwer.RemoveMultipleSpaces()) word_excepts = req_data.get('t_words', '') if word_excepts != '': words = [a.strip() for a in word_excepts.split(",")] compose_rule_set.append(jiwer.RemoveSpecificWords(words)) compose_rule_set.append( jiwer.RemoveWhiteSpace( replace_by_space=req_data.get('replace_whitespace', False))) transformation = jiwer.Compose(compose_rule_set) measures = jiwer.compute_measures(req_data.get('s_truth', ""), req_data.get('s_hypo', ""), truth_transform=transformation, hypothesis_transform=transformation) return jsonify({ "wer": measures['wer'], "mer": measures['mer'], "wil": measures['wil'] }) except: return jsonify("API endpoint Error")
def metric(ref_trans, asr_trans, lang): if lang == "en": transformation = jiwer.Compose([ jiwer.Strip(), jiwer.ToLowerCase(), jiwer.RemoveWhiteSpace(replace_by_space=True), jiwer.RemoveMultipleSpaces(), jiwer.SentencesToListOfWords(word_delimiter=" "), jiwer.RemoveEmptyStrings(), jiwer.RemovePunctuation(), ]) wer = jiwer.wer( ref_trans, asr_trans, truth_transform=transformation, hypothesis_transform=transformation, ) elif lang == "cn": del_symblos = re.compile(r"[^\u4e00-\u9fa5]+") for idx in range(len(asr_trans)): sentence = re.sub(del_symblos, "", asr_trans[idx]) sentence = list(sentence) sentence = " ".join(sentence) asr_trans[idx] = sentence sentence = re.sub(del_symblos, "", ref_trans[idx]) sentence = list(sentence) sentence = " ".join(sentence) ref_trans[idx] = sentence asr_valid = set(asr_trans) assert len(asr_valid) == len(asr_trans) wer = jiwer.wer(ref_trans, asr_trans) else: raise ("Args error!") return wer
srt.push(next_sub) break end = next_sub.end.hours * 3600 + next_sub.end.minutes * 60 + next_sub.end.seconds + next_sub.end.milliseconds / 1000 ground_truth = ground_truth + " " + next_sub.text_without_tags hypothesis = kd.query_text(start, end) else: break kd.mark_words(start, end) transformation = jiwer.Compose([ jiwer.ToLowerCase(), jiwer.RemoveMultipleSpaces(), jiwer.RemoveWhiteSpace(replace_by_space=True), jiwer.SentencesToListOfWords(), jiwer.RemovePunctuation(), jiwer.RemoveEmptyStrings(), jiwer.SubstituteRegexes({r"ё": r"е"}) ]) gt = transformation([ground_truth]) hp = transformation([hypothesis]) gt, hp = replace_pairs(gt, hp) hp, gt = replace_pairs(hp, gt) wer(gt, hp) r = jiwer.compute_measures( gt, hp )
def RemovePunctuation(replace_by_space=False): if not replace_by_space: return jiwer.RemovePunctuation() return replace_punctuations_by_space