Add scripts from jeli-asr repo

scripts/clean_tsv.py

@@ -0,0 +1,112 @@
+"""
+Copyright 2024 RobotsMali AI4D Lab.
+
+Licensed under the Creative Commons Attribution 4.0 International License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://creativecommons.org/licenses/by/4.0/
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+import csv
+import re
+import os
+import sys
+import glob
+
+def clean_tsv(input_file : str, output_file: str, revision_file: str) -> None:
+    """Generic function
+
+    Args:
+        input_file (str): The path to the tsv file to clean
+        output_file (str): The path to the file to save the cleaned rows in. (Typically the same file)
+        revision_file (str): The path to the file to save still inconsistent rows in
+
+    Returns:
+        _type_: _description_
+    """
+    cleaned_rows = []
+    revision_rows = []
+
+    # Helper function to clean the line
+    def clean_line(line):
+        # Remove unwanted characters
+        line = re.sub(r'[<>"]', '', line)
+
+        # Replace consecutive tabs with a single tab
+        line = re.sub(r'\t+', '\t', line)
+
+        return line
+
+    # Open the input file and process each row
+    with open(input_file, 'r', encoding='utf-8') as infile:
+        reader = csv.reader(infile, delimiter='\t')
+
+        for row in reader:
+            # Clean the row
+            row = [clean_line(item) for item in row]
+
+            # If the row has exactly 4 items, ensure the first two are numbers
+            if len(row) == 4:
+                try:
+                    # Ensure the first two items are numbers
+                    # Those values aren't intended for use, simple format check by Exception Catching. 
+                    start_time = int(row[0])
+                    end_time = int(row[1])
+
+                    # Append the cleaned row
+                    cleaned_rows.append(row)
+                except ValueError:
+                    # If timestamps are not valid integers, move to revision
+                    revision_rows.append(row)
+                    print("One problematic row has been added to revision")
+            # If the row has more than 4 items and no consecutive \t, check for \t swapped with space
+            elif len(row) > 4:
+                row_str = "\t".join(row)
+                if ',' in row_str:
+                    row_str = re.sub(r',\t', ', ', row_str)
+                # After fixing spaces, split again and check the length
+                row_fixed = row_str.split('\t')
+                if len(row_fixed) == 4:
+                    cleaned_rows.append(row_fixed)
+                else:
+                    revision_rows.append(row_fixed)
+                    print("One problematic row has been added to revision")
+            else:
+                # For rows with incorrect number of elements, move to revision
+                revision_rows.append(row)
+                print("One problematic row has been added to revision")
+
+    # Write the cleaned rows to the output file
+    with open(output_file, 'w', encoding='utf-8', newline='') as outfile:
+        writer = csv.writer(outfile, delimiter='\t')
+        writer.writerows(cleaned_rows)
+        print(f"**** New cleaned tsv file saved at {output_file} ****")
+
+    if revision_rows:
+        # Write the revision rows to the revision file if there are rows to review
+        with open(revision_file, 'w', encoding='utf-8', newline='') as revfile:
+            writer = csv.writer(revfile, delimiter='\t')
+            writer.writerows(revision_rows)
+            print(f"**** New revision file saved at {revision_file} ****")
+
+if __name__ == "__main__":
+    transcription_dir = sys.argv[1]
+
+    # Ensure revision directory exist
+    rev_dir = f'{transcription_dir}/revisions'
+    os.makedirs(rev_dir, exist_ok=True)
+
+    # get the paths to all the tsv files
+    tsv_files = glob.glob(transcription_dir + "/*.tsv")
+
+    for tsv_file in tsv_files:
+        in_file = tsv_file
+        out_file = in_file
+        rev_file = rev_dir + "/" + tsv_file.split("/")[-1][:-4] + "-rev.tsv"
+        clean_tsv(input_file=in_file, output_file=out_file, revision_file=rev_file)

scripts/convert_to_mono_channel.py

@@ -0,0 +1,48 @@
+"""
+Copyright 2024 RobotsMali AI4D Lab.
+
+Licensed under the Creative Commons Attribution 4.0 International License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://creativecommons.org/licenses/by/4.0/
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+from pydub import AudioSegment
+import sys
+import json
+
+def convert_to_mono(file_path):
+    """Convert an audio file to mono if it has multiple channels."""
+    audio = AudioSegment.from_file(file_path)
+    if audio.channels > 1:
+        audio = audio.set_channels(1)
+        audio.export(file_path, format="wav")
+        print(f"Converted {file_path} to mono.")
+
+def check_and_convert_audio_channels(manifest_path):
+    """Check the number of channels in audio files and convert to mono if necessary."""
+    with open(manifest_path, 'r') as f:
+        lines = f.readlines()
+
+    for line in lines:
+        audio_path = json.loads(line)['audio_filepath']
+        audio = AudioSegment.from_file(audio_path)
+        if audio.channels > 1:
+            print(f"{audio_path} is not mono. Converting...")
+            convert_to_mono(audio_path)
+        else:
+            print(f"{audio_path} is already mono.")
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: python script.py <manifest_path>")
+        sys.exit(1)
+
+    manifest_path = sys.argv[1]
+    check_and_convert_audio_channels(manifest_path=manifest_path)

scripts/create_data_manifest.py

@@ -0,0 +1,242 @@
+"""
+Copyright 2024 RobotsMali AI4D Lab.
+
+Licensed under the Creative Commons Attribution 4.0 International License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://creativecommons.org/licenses/by/4.0/
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+## Imports
+import glob
+import os
+import csv
+import random
+import json
+import shutil
+import sys
+from pydub import AudioSegment
+
+# Key callable to sort wav files paths
+def key_sort_paths(path: str) -> int:
+    """Serve as key function to sort the wav files paths
+
+    Args:
+        path (str): An individual path
+
+    Returns:
+        int: The number of the split (between 1 and 6)
+    """
+    return int(path[-5])
+
+# Function to read and combine the audios
+def read_audios(glob_paths: list[str]) -> AudioSegment:
+    """Read the six 10 mns audio as AudioSegments and returns the combined 1 hr audio
+
+    Args:
+        glob_paths (list[str]): list of the paths of the 6 .wav files
+
+    Returns:
+        AudioSegment: The combined audio
+    """
+    audios = []
+    for wav_file in sorted(glob_paths, key=key_sort_paths):
+        audios.append(AudioSegment.from_file(file=wav_file, format="wav"))
+    final_audio = sum(audios[1:], start=audios[0])
+    return final_audio
+
+# A function that reads and return the utterances from .tsv files
+def read_tsv(tsv_file_path: str) -> list[list[int | str]]:
+    """Read a .tsv file and return the utterances in it
+
+    Args:
+        tsv_file_path (str): The path to the tsv file
+
+    Returns:
+        list[list[int | str]]: The returned utterances with the timestamps coverted to int
+    """
+    with open(tsv_file_path,"r", encoding='utf-8') as recording_transcript:
+        tsv_file_rows = csv.reader(recording_transcript, delimiter="\t")
+        utterances = [[int(start), int(end), bam, french] for start, end, bam, french in tsv_file_rows]
+    return utterances
+            
+# Function to subdivide the audio (transcript) into multiple variable length slices
+def create_var_length_samples(utterances: list[list[int | str]], min_duration: int = 1000,
+                max_duration: int = 120000) -> list[list[list[int | str]]]:
+    """Create variable length combination of utterances to make samples which duration vary between 1s and 2mns
+
+    Args:
+        utterances (list[list[int  |  str]]): The read tsv file containing the transcriptions of the audio
+        min_duration (int, optional): min duration of a sample in milliseconds. Defaults to 1000.
+        max_duration (int, optional): max duration of a sample in milliseconds. Defaults to 120000.
+
+    Returns:
+        list[list[list[int | str]]]: The list of created samples
+    """
+    samples = []
+    current_slice = []
+    current_duration = 0
+
+    i = 0
+    while i < len(utterances):
+        utterance_start, utterance_end = utterances[i][:2]
+        utterance_duration = utterance_end - utterance_start
+        
+        # If current slice duration is less than max duration, add the utterance to this sample
+        if current_duration + utterance_duration <= max_duration:
+            current_slice.append(utterances[i])
+            current_duration += utterance_duration
+            i += 1
+        else:
+            # Save the current sample and reset for a new one
+            samples.append(current_slice)
+            current_slice = []
+            current_duration = 0
+        
+        # Randomly decide whether to end the current sample based on time or number of utterances
+        if current_duration >= min_duration:
+            if random.choice([True, False, False]) or len(current_slice) >= random.randint(1, 20):
+                samples.append(current_slice)
+                current_slice = []
+                current_duration = 0
+
+    # Add the final slice if it exists
+    if current_slice: # equivalent to if current_slice is empty
+        samples.append(current_slice)
+
+    return samples
+
+# Function to create and save the audio samples for a specific list of samples
+def slice_and_save_audios(samples: list[list[list[int | str]]], griot_id: str,
+                          data_dir: str, audio_dir_path: str) -> list[list[float | str]]:
+    """Slice and save the audio samples created for a specific 1hr recording
+
+    Args:
+        samples (list[list[list[int  |  str]]]): The samples created with function "create_var_length_samples"
+        griot_id (str): The ID of the griot in the recording (eg: griots_r17)
+        data_dir (str): The directory containing all the data.
+        audio_dir_path (str): The diretory the save the sliced audios in.
+
+    Returns:
+        list[list[int | str]]: A list version of manifests (eg: [[audiofile_path, duration, bambara, translation], ...])
+    """
+    wav_files_paths = glob.glob(f'{data_dir}/{griot_id}/*.wav')
+    griot_recording = read_audios(glob_paths=wav_files_paths)
+    # A list to store only the data needed to create 
+    list_manifests = []
+
+    for sample in samples:
+        start = sample[0][0]
+        end = sample[-1][1]
+        duration = (end - start) / 1000 # in seconds
+        # Flag audios with more than 100 seconds 
+        more_than_100s = " ###" if duration >= 100 else ""
+
+        # get trancriptions and translations of utterances composing the samples
+        transcriptions, translations = [utt[2] for utt in sample], [utt[3] for utt in sample]
+        transcription = " ".join(transcriptions)
+        translation = " ".join(translations)
+
+        # create the sample wav file and save it
+        audio_file_path = f"{audio_dir_path}/{griot_id}-{start}-{end}.wav"
+        griot_recording[start:end].export(out_f=audio_file_path, format="wav")
+        print(f"Sample {griot_id}-{start}-{end} saved in {audio_file_path}{more_than_100s}")
+
+        # Create the manifest list and save it
+        list_manifests.append([audio_file_path, duration, transcription, translation])
+    return list_manifests
+
+# A function to shuffle and split samples
+def shuffle_and_split(dataset: list[list[float | str]],
+                      test: int | float = 0.15) -> tuple[list[list[float | str]]]:
+    """Shuffle and split the whole dataset
+
+    Args:
+        dataset (list[list[int  |  str]]): The combined list of all list manifest returned by "slice_and_save_audios"
+        test (int | float, optional): The number of sample to include that make the test set or and percentage of the whole dataset to use as the test set. Defaults to 0.15.
+
+    Returns:
+        tuple[list[list[list[int | str]]]]: The train and test sets samples returned separately
+    """
+    random.shuffle(dataset)
+    if isinstance(test, float):
+        test = int(test * len(dataset))
+    test_set_samples = dataset[0:test]
+    train_set_samples = dataset[test:]
+    return train_set_samples, test_set_samples
+
+# A function to create audio sample files and manifests
+def create_manifest(dataset_split: list[list[float | str]], split_name: str,
+                    dir_path: str) -> None:
+    """Create manifest files 
+
+    Args:
+        dataset_split (list[list[float  |  str]]): Split of the dataset to create manifest for
+        split_name (str): Name of the split
+        dir_path (str): The directory to save the new data manifest in
+    """
+    # Ensure directories for manifests and audios
+    os.makedirs(f'{dir_path}/manifests', exist_ok=True)
+    os.makedirs(f'{dir_path}/french-manifests', exist_ok=True)
+    os.makedirs(f'{dir_path}/audios/{split_name}', exist_ok=True)
+
+    # Define manifest file paths
+    manifest_path = f'{dir_path}/manifests/{split_name}_manifest.json'
+    french_manifest_path = f'{dir_path}/french-manifests/{split_name}_french_manifest.json'
+    audio_dir_path = f'{dir_path}/audios/{split_name}'
+
+    with open(manifest_path, 'w', encoding="utf-8") as manifest_file, open(french_manifest_path, 'w', encoding="utf-8") as french_file:
+        for sample in dataset_split:
+            # move the audio sample file in the corresponding split directory
+            new_audio_path = f'{audio_dir_path}/{sample[0].split("/")[-1]}'
+            shutil.move(src=sample[0], dst=new_audio_path)
+
+            # Prepare the manifest line
+            manifest_line = {
+                "audio_filepath": os.path.relpath(new_audio_path),
+                "duration": sample[1],
+                "text": sample[2]  # Bambara transcription goes to the text field
+            }
+
+            french_manifest_line = {
+                "audio_filepath": os.path.relpath(new_audio_path),
+                "duration": sample[1],
+                "text": sample[3]
+            }
+
+            # Write manifest files
+            manifest_file.write(json.dumps(manifest_line) + '\n')
+            french_file.write(json.dumps(french_manifest_line) + '\n')
+    print(f"{split_name} manifests files have been created successfully!\nCorresponding audios files have been moved to {audio_dir_path}")
+
+if __name__ == "__main__":
+    data_path = sys.argv[1]
+    manifest_dir = sys.argv[2]
+    tsv_dir = f'{data_path}/aligned-transcriptions'
+
+    # Get all the revised transcription files in .tsv format
+    tsv_paths = glob.glob(f'{tsv_dir}/*.tsv')
+    # list to store the list manifests per griots
+    final_list_manifest = []
+    for tsv_file in tsv_paths:
+        id_griot = tsv_file.split("/")[-1][:-4]
+        griot_utterances = read_tsv(tsv_file_path=tsv_file)
+        # Get samples (can be made of one or more utterances)
+        griot_samples = create_var_length_samples(utterances=griot_utterances)
+        list_manifest = slice_and_save_audios(samples=griot_samples, griot_id=id_griot,
+                                    data_dir=data_path, audio_dir_path=f'{manifest_dir}/audios')
+        final_list_manifest.append(list_manifest)
+    # Get a single list manifest for all the samples
+    final_list_manifest = sum(final_list_manifest, start=[])
+    # Shuffle and split the final list of all sample,manifests
+    train_set, test_set = shuffle_and_split(dataset=final_list_manifest, test=0.15) # Use 15% of the dataset for test
+    print(f'len(train_set) == {len(train_set)} and len(test_set) == {len(test_set)}')
+
+    create_manifest(dataset_split=train_set, split_name="train", dir_path=manifest_dir)
+    create_manifest(dataset_split=test_set, split_name="test", dir_path=manifest_dir)

scripts/create_manifest_oza_bam_asr.py

@@ -0,0 +1,82 @@
+"""
+Copyright 2024 RobotsMali AI4D Lab.
+
+Licensed under the Creative Commons Attribution 4.0 International License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://creativecommons.org/licenses/by/4.0/
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+from datasets import load_dataset
+from huggingface_hub import login
+import os
+import json
+import soundfile as sf
+import numpy as np
+
+# Log in to Hugging Face
+login()
+
+# Load the clean subset of the dataset
+oza_bam_asr_clean = load_dataset("oza75/bambara-asr", name="clean")
+
+# Define root directory for the Nemo version
+root_dir = "oza-bam-asr-clean"
+os.makedirs(root_dir, exist_ok=True)
+os.makedirs(f"{root_dir}/audios", exist_ok=True)
+os.makedirs(f"{root_dir}/manifests", exist_ok=True)
+os.makedirs(f"{root_dir}/french-manifests", exist_ok=True)
+
+def save_audio_and_create_manifest(datasets, manifest_path, french_manifest_path):
+    total_duration = 0
+    with open(manifest_path, "w", encoding="utf-8") as manifest_file, open(french_manifest_path, "w", encoding="utf-8") as french_file:
+        idx = 0
+        for dataset in datasets:
+            for example in dataset:
+                # Save audio to .wav file
+                audio_path = f"{root_dir}/audios/oza75-bam-asr-{idx}.wav"
+                sf.write(audio_path, np.array(example['audio']['array']), example['audio']['sampling_rate'])
+
+                # Calculate duration and accumulate
+                duration = example['duration']
+                total_duration += duration
+
+                # Create manifest entries
+                manifest_entry = {
+                    "audio_filepath": os.path.relpath(audio_path),
+                    "duration": duration,
+                    "text": example['bambara'].lower()
+                }
+                french_manifest_entry = {
+                    "audio_filepath": os.path.relpath(audio_path),
+                    "duration": duration,
+                    "text": example['french'].lower()
+                }
+
+                # Write to manifest files
+                manifest_file.write(json.dumps(manifest_entry, ensure_ascii=False) + "\n")
+                french_file.write(json.dumps(french_manifest_entry, ensure_ascii=False) + "\n")
+                
+                idx += 1
+
+    return total_duration
+
+if __name__ == "__main__":
+    # Combine train and test sets into one
+    total_duration = save_audio_and_create_manifest(
+        [oza_bam_asr_clean['train'], oza_bam_asr_clean['test']],
+        f"{root_dir}/manifests/train_manifest.json",
+        f"{root_dir}/french-manifests/train_french_manifest.json"
+    )
+
+    # Convert duration to hours
+    total_hours = total_duration / 3600
+
+    # Print the result
+    print(f"Created Nemo manifest for 'oza75/bambara-asr' totalling {total_hours:.2f} hours of audio.")

scripts/filter_silent_and_inaudible.py

@@ -0,0 +1,140 @@
+"""
+Copyright 2024 RobotsMali AI4D Lab.
+
+Licensed under the Creative Commons Attribution 4.0 International License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://creativecommons.org/licenses/by/4.0/
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+import librosa
+import json
+import numpy as np
+
+# Get the mean mel energy for of a silent audio to better tune the params in flag_silent_audio_mel
+def get_mel_energy(audio_path, n_mels=80, frame_duration=0.025):
+    """
+    Computes the average Mel-frequency energy of an audio file.
+
+    Args:
+        audio_path (str): Path to the audio file.
+
+    Returns:
+        float: Average Mel-frequency energy.
+    """
+    # Load audio
+    y, sr = librosa.load(audio_path, sr=None)
+
+    # Compute frame length in samples
+    frame_length = int(frame_duration * sr)
+    hop_length = frame_length  # No overlap for simplicity
+
+    # Compute Mel spectrogram
+    mel_spectrogram = librosa.feature.melspectrogram(
+          y=y, sr=sr, n_mels=n_mels, hop_length=hop_length, power=2.0
+    )
+
+    # Compute average energy for each frame
+    mel_energies = np.mean(mel_spectrogram, axis=0)
+
+    # Normalize energy
+    mel_energies /= np.max(mel_energies)  # Normalize to [0, 1]
+
+    return np.mean(mel_energies)
+
+def flag_silent_audio_mel(manifest_path, mel_energy_threshold=0.001, speech_fraction=0.2, n_mels=80, frame_duration=0.025):
+    """
+    Flags audio files with little or no speech based on Mel-frequency energy.
+
+    Args:
+        manifest_path (str): Path to the manifest file.
+        mel_energy_threshold (float): Threshold for Mel-frequency energy to consider a frame as containing speech.
+        speech_fraction (float): Minimum fraction of frames required to classify as speech.
+        n_mels (int): Number of Mel bands to use for the Mel spectrogram.
+        frame_duration (float): Duration of each frame in seconds.
+
+    Returns:
+        list: A list of audio filepaths flagged as silent or low-energy.
+    """
+    silent_audio_files = []
+
+    with open(manifest_path, 'r', encoding='utf-8') as f:
+        manifest = [json.loads(line.strip()) for line in f]
+
+    for entry in manifest:
+        audio_path = entry['audio_filepath']
+        try:
+            # Load audio
+            y, sr = librosa.load(audio_path, sr=None)
+
+            # Compute frame length in samples
+            frame_length = int(frame_duration * sr)
+            hop_length = frame_length  # No overlap for simplicity
+
+            # Compute Mel spectrogram
+            mel_spectrogram = librosa.feature.melspectrogram(
+                y=y, sr=sr, n_mels=n_mels, hop_length=hop_length, power=2.0
+            )
+
+            # Compute average energy for each frame
+            mel_energies = np.mean(mel_spectrogram, axis=0)
+
+            # Normalize energy
+            mel_energies /= np.max(mel_energies)  # Normalize to [0, 1]
+
+            # Count frames above the threshold
+            speech_frames = np.sum(mel_energies > mel_energy_threshold)
+            total_frames = len(mel_energies)
+
+            # Classify as silent if speech fraction is below threshold
+            if speech_frames / total_frames < speech_fraction:
+                print(f"Audio file {audio_path} is classified as silent.")
+                silent_audio_files.append(audio_path)
+        except Exception as e:
+            print(f"Error processing file {audio_path}: {e}")
+
+    return silent_audio_files
+
+def remove_silent_audio_from_manifest(manifest_path, silent_audio_files, output_manifest_path):
+    """
+    Removes entries of flagged audio files from the manifest.
+
+    Args:
+        manifest_path (str): Path to the input manifest file.
+        silent_audio_files (list): List of audio filepaths flagged as silent or low-energy.
+        output_manifest_path (str): Path to save the filtered manifest.
+
+    Returns:
+        None
+    """
+    with open(manifest_path, 'r', encoding='utf-8') as f:
+        manifest = [json.loads(line.strip()) for line in f]
+
+    # Filter out silent audio files
+    filtered_manifest = [entry for entry in manifest if entry['audio_filepath'] not in silent_audio_files]
+
+    # Write the filtered manifest to the output file
+    with open(output_manifest_path, 'w', encoding='utf-8') as f:
+        for entry in filtered_manifest:
+            f.write(json.dumps(entry) + '\n')
+
+    print(f"Filtered manifest saved to {output_manifest_path}")
+
+if __name__ =="__main__":
+    import sys
+
+    if len(sys.argv) != 2:
+        print("Usage: python script.py <manifest_path>")
+        sys.exit(1)
+
+    manifest_path = sys.argv[1]
+    silent_audio_files = flag_silent_audio_mel(manifest_path)
+    output_manifest_path = manifest_path.replace(".json", "_filtered.json")
+    remove_silent_audio_from_manifest(manifest_path, silent_audio_files, output_manifest_path)
+    

scripts/lower_transcriptions_in_manifests.py

@@ -0,0 +1,46 @@
+"""
+Copyright 2024 RobotsMali AI4D Lab.
+
+Licensed under the Creative Commons Attribution 4.0 International License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://creativecommons.org/licenses/by/4.0/
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+import json
+import os
+
+# Hardcoded paths for the manifest files
+manifest_paths = {
+    "train_bambara": "jeli-data-manifest/manifests/train_manifest.json",
+    "test_bambara": "jeli-data-manifest/manifests/test_manifest.json",
+    "train_french": "jeli-data-manifest/french-manifests/train_french_manifest.json",
+    "test_french": "jeli-data-manifest/french-manifests/test_french_manifest.json",
+}
+
+# Directory to save the lowercase transcriptions
+output_dir = "lower-case-transcriptions"
+os.makedirs(output_dir, exist_ok=True)
+
+# Function to process a manifest file
+def lowercase_manifest(input_path, output_path):
+    """Convert all transcriptions in a manifest file to lowercase."""
+    with open(input_path, "r", encoding="utf-8") as infile, open(output_path, "w", encoding="utf-8") as outfile:
+        for line in infile:
+            entry = json.loads(line)
+            entry["text"] = entry["text"].lower()
+            outfile.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+# Process each manifest file
+for key, input_path in manifest_paths.items():
+    output_path = os.path.join(output_dir, os.path.basename(input_path))
+    lowercase_manifest(input_path, output_path)
+    print(f"Processed {input_path} and saved to {output_path}")
+
+print("All manifest files have been processed.")