""" 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)