Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Mój kod się zatrzymuje i nie chce wykonywać dalej przy 1911 pętli przetwarzania pliku…

  1. User

    Mój kod się zatrzymuje i nie chce wykonywać dalej przy 1911 pętli przetwarzania pliku train, możliwe że plik mp3, który powinien być znaleziony nie istnieje w folderze z plikami audio. Spróbuj zidentyfikować i pomóc mi debugować błędy. Zwróć cały poprawiony kod: # Importowanie niezbędnych bibliotek import os import numpy as np import torch import tqdm import time import pandas as pd import logging

    from audiocraft.models import EncodecModel from audiocraft.data.audio_utils import convert_audio from phonemizer.phonemize import phonemize

    Definiowanie argumentów bezpośrednio w kodzie

    class Args: download_to = "/home/donmatteo/Pulpit/VoiceCraft/cv-corpus-19.0-2024-09-13/pl" save_dir = "/home/donmatteo/Pulpit/VoiceCraft/processed_data" sorce_of_mp3 = "/home/donmatteo/Pulpit/VoiceCraft/cv-corpus-19.0-2024-09-13/pl/clips" n_workers = 4 mega_batch_size = 100 batch_size = 4 model_sr = 16000 downsample_rate = 320 model_code_sr = 50 len_cap = 35.0 max_len = 30000

    args = Args()

    Konfiguracja logowania

    formatter = "%(asctime)s [%(levelname)s] %(filename)s:%(lineno)d || %(message)s" logging.basicConfig(format=formatter, level=logging.INFO)

    Definiowanie ścieżek

    data_dir = args.download_to sorce_mp3 = args.sorce_of_mp3 phn_save_root = os.path.join(args.save_dir, "phonemes") codes_save_root = os.path.join(args.save_dir, "encodec_16khz_4codebooks") vocab_fn = os.path.join(args.save_dir, "vocab.txt") os.makedirs(phn_save_root, exist_ok=True) os.makedirs(codes_save_root, exist_ok=True)

    def sort_by_audio_len(lens): inds = np.argsort(lens).tolist() logging.info(f"longest: {lens[inds[-1]]*args.model_code_sr} encodec codes, {lens[inds[-1]]:.2f} sec.") logging.info(f"shortest: {lens[inds[0]]*args.model_code_sr} encodec codes, {lens[inds[0]]:.2f} sec.") logging.info(f"median: {lens[inds[len(inds)//2]]*args.model_code_sr} encodec codes, {lens[inds[len(inds)//2]]:.2f} sec.") logging.info(f"95 percentile longest: {lens[inds[int(len(inds)*0.95)]]*args.model_code_sr} encodec codes, {lens[inds[int(len(inds)*0.95)]]:.2f} sec.") return inds[::-1]

    def write_array_to_txt_file(array, filename): with open(filename, 'w') as f: for a in array[:-1]: f.write(' '.join(map(str, a))+'\n') f.write(' '.join(map(str, array[-1])))

    Fonemizacja

    logging.info("Starting phonemization...")

    phn_vocab = set() all_lens = []

    splits = ['train', 'validation', 'test'] split_files = { 'train': os.path.join(data_dir, 'train.tsv'), 'validation': os.path.join(data_dir, 'dev.tsv'), 'test': os.path.join(data_dir, 'test.tsv'), }

    Dla fonemizacji języka polskiego używamy phonemizer z backendem espeak

    for split in splits: skip = 0 logging.info(f"Now processing split {split}...") tsv_file = split_files[split] df = pd.read_csv(tsv_file, sep='\t') for index, item in tqdm.tqdm(df.iterrows(), total=len(df)):
    client_id = item['client_id'] path = item['path'] sentence = item['sentence'] # sprawdz czy path istnieje, jeśli path nie istnieje przetwarzaj kolejną ścieżkę full_path = os.path.join(sorce_mp3, path) if not os.path.exists(full_path): print("Nie istnieje: ", full_path) time.sleep(0.5) continue save_fn = os.path.join(phn_save_root, path.replace('.mp3', '') + ".txt") text = sentence.strip() if not isinstance(text, str) or not text: logging.info(f"Skipping empty sentence at {path}") skip += 1 continue try: phn = phonemize(text, language='pl', backend='espeak', strip=True, preserve_punctuation=True, njobs=1) phn_seq = phn.strip() phn_vocab.update(phn_seq.split()) all_lens.append(len(phn_seq.split())) with open(save_fn, "w") as f: f.write(phn_seq) except Exception as e: logging.warning(f"Phonemization failed for {path}: {e}") skip += 1 continue logging.info(f"Split {split} has {len(df)} samples in total, skipped {skip} due to errors")

    logging.info(f"Phoneme vocabulary size: {len(phn_vocab)}") logging.info(f"Phoneme sequence stats:") logging.info(f"Longest sequence: {max(all_lens)} phonemes") logging.info(f"Shortest sequence: {min(all_lens)} phonemes") logging.info(f"Median sequence length: {np.quantile(all_lens, 0.5)} phonemes") logging.info(f"95th percentile sequence length: {np.quantile(all_lens, 0.95)} phonemes") logging.info(f"Writing vocabulary to {vocab_fn}") with open(vocab_fn, "w") as f: for i, phn in enumerate(sorted(list(phn_vocab))): if i < len(phn_vocab) - 1: f.write(f"{str(i)} {phn}\n") else: f.write(f"{str(i)} {phn}")

    Ładowanie modelu Encodec

    logging.info("Loading Encodec model...")

    Używamy predefiniowanego modelu Encodec dla 16 kHz

    model = EncodecModel.encodec_model_16khz() model.set_target_bandwidth(6.0) model = model.cuda() model.eval()

    Definiowanie klasy dataset

    class CommonVoiceDataset(torch.utils.data.Dataset): def init(self, split): super().init() tsv_file = split_files[split] self.data_dir = data_dir self.df = pd.read_csv(tsv_file, sep='\t') self.audio_dir = os.path.join(self.data_dir, 'clips') def len(self): return len(self.df) def getitem(self, idx): item = self.df.iloc[idx] path = item['path'] sentence = item['sentence'] audio_path = os.path.join(self.audio_dir, path) try: import soundfile as sf waveform, sr = sf.read(audio_path) waveform = torch.from_numpy(waveform).float() if len(waveform.size()) > 1: waveform = waveform.mean(dim=1) # Konwersja do mono waveform = convert_audio(waveform, sr, args.model_sr, model.channels) duration = waveform.shape[-1] / args.model_sr return path.replace('.mp3', ''), waveform, args.model_sr, sentence, duration except Exception as e: logging.warning(f"Failed to load audio {audio_path}: {e}") return None, None, None, None, None def collate(self, batch): res = {'path': [], "audio": [], "sr": [], "text": [], "duration": []} for item in batch: if item[0] is not None: res['path'].append(item[0]) res['audio'].append(item[1]) res['sr'].append(item[2]) res['text'].append(item[3]) res['duration'].append(item[4]) return res

    Wyodrębnianie kodów Encodec

    logging.info("Starting Encodec encoding...") datasets = {} dataloaders = {} for split in splits: dataset = CommonVoiceDataset(split) dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.mega_batch_size, shuffle=False, drop_last=False, num_workers=args.n_workers, collate_fn=dataset.collate) datasets[split] = dataset dataloaders[split] = dataloader

    for split in splits: skip = 0 logging.info(f"Now processing split {split}...") total_samples = len(datasets[split]) mega_n_steps = int(np.ceil(total_samples / args.mega_batch_size)) logging.info(f"Partitioning the split {split} into {mega_n_steps} parts, each has {args.mega_batch_size} samples") for m, mega_batch in enumerate(dataloaders[split]): logging.info(f"====================================") logging.info(f"Now processing mega step {m+1}/{mega_n_steps}") durations = mega_batch['duration'] lengths = durations # Czas trwania w sekundach sorted_inds = sort_by_audio_len(lengths) for j in range(len(sorted_inds) -1, -1, -1): if lengths[sorted_inds[j]] < 0.2 or lengths[sorted_inds[j]] > args.len_cap: skip += 1 del sorted_inds[j] n_steps = int(np.ceil(len(sorted_inds) / args.batch_size)) for n in tqdm.tqdm(range(n_steps)): inds_used = sorted_inds[n*args.batch_size:(n+1)*args.batch_size] if len(inds_used) == 0: continue audio_batch = [mega_batch['audio'][id] for id in inds_used] sr_batch = [mega_batch['sr'][id] for id in inds_used] path_batch = [mega_batch['path'][id] for id in inds_used] text_batch = [mega_batch['text'][id] for id in inds_used] padded_wav = torch.nn.utils.rnn.pad_sequence(audio_batch, batch_first=True).unsqueeze(1) # [B, 1, T] all_lens = [lengths[id] for id in inds_used] try: with torch.no_grad(): if max(all_lens) > args.max_len / args.model_sr and len(all_lens) > 1: codes = [] inwav = padded_wav.cuda() codes_first_half = model.encode(inwav[:len(inwav)//2])[0].cpu() codes_second_half = model.encode(inwav[len(inwav)//2:])[0].cpu() codes = torch.cat([codes_first_half, codes_second_half], dim=0) else: encoded_frames = model.encode(padded_wav.cuda()) codes = encoded_frames[0].cpu() for i, length in enumerate(all_lens): save_fn = os.path.join(codes_save_root, path_batch[i] + ".txt") actual_len = min(codes.size(2), round(length * args.model_code_sr)) # Unikamy przekroczenia indeksu cur_code = codes[i, :, :actual_len].tolist() write_array_to_txt_file(cur_code, save_fn) except Exception as e: logging.warning(f"Encoding failed at step {n+1} in mega step {m+1}: {e}") continue logging.info(f"Finished processing split {split}, skipped {skip} samples due to length constraints")

    logging.info("Processing complete.")

  2. Assistant

    Wygląda na to, że Twój kod zatrzymuje się podczas przetwarzania pętli, prawdopodobnie z powodu nieobsługiwanego wyjątku, który pojawia się, gdy plik MP3 nie istnieje lub występuje inny problem z plikiem audio lub tekstem. Aby rozwiązać ten problem, możemy dodać obsługę wyjątków tam, gdzie mogą one wystąpić, i upewnić się, że kod będzie kontynuował działanie pomimo błędów w pojedynczych iteracjach.

    Poniżej przedstawiam poprawiony kod z dodanym dodatkowym logowaniem i obsługą wyjątków:

    # Importowanie niezbędnych bibliotek
    import os
    import numpy as np
    import torch
    import tqdm
    import time
    import pandas as pd
    import logging
    
    from audiocraft.models import EncodecModel
    from audiocraft.data.audio_utils import convert_audio
    from phonemizer.phonemize import phonemize
    
    # Definiowanie argumentów bezpośrednio w kodzie
    class Args:
        download_to = "/home/donmatteo/Pulpit/VoiceCraft/cv-corpus-19.0-2024-09-13/pl"
        save_dir = "/home/donmatteo/Pulpit/VoiceCraft/processed_data"
        sorce_of_mp3 = "/home/donmatteo/Pulpit/VoiceCraft/cv-corpus-19.0-2024-09-13/pl/clips"
        n_workers = 4
        mega_batch_size = 100
        batch_size = 4
        model_sr = 16000
        downsample_rate = 320
        model_code_sr = 50
        len_cap = 35.0
        max_len = 30000
    
    args = Args()
    
    # Konfiguracja logowania
    formatter = "%(asctime)s [%(levelname)s] %(filename)s:%(lineno)d || %(message)s"
    logging.basicConfig(format=formatter, level=logging.INFO)
    
    # Definiowanie ścieżek
    data_dir = args.download_to
    sorce_mp3 = args.sorce_of_mp3
    phn_save_root = os.path.join(args.save_dir, "phonemes")
    codes_save_root = os.path.join(args.save_dir, "encodec_16khz_4codebooks")
    vocab_fn = os.path.join(args.save_dir, "vocab.txt")
    os.makedirs(phn_save_root, exist_ok=True)
    os.makedirs(codes_save_root, exist_ok=True)
    
    def sort_by_audio_len(lens):
        inds = np.argsort(lens).tolist()
        logging.info(f"longest: {lens[inds[-1]]*args.model_code_sr} encodec codes, {lens[inds[-1]]:.2f} sec.")
        logging.info(f"shortest: {lens[inds[0]]*args.model_code_sr} encodec codes, {lens[inds[0]]:.2f} sec.")
        logging.info(f"median: {lens[inds[len(inds)//2]]*args.model_code_sr} encodec codes, {lens[inds[len(inds)//2]]:.2f} sec.")
        logging.info(f"95 percentile longest: {lens[inds[int(len(inds)*0.95)]]*args.model_code_sr} encodec codes, {lens[inds[int(len(inds)*0.95)]]:.2f} sec.")
        return inds[::-1]
    
    def write_array_to_txt_file(array, filename):
        with open(filename, 'w') as f:
            for a in array[:-1]:
                f.write(' '.join(map(str, a))+'\n')
            f.write(' '.join(map(str, array[-1])))
    
    # Fonemizacja
    logging.info("Starting phonemization...")
    
    phn_vocab = set()
    all_lens = []
    
    splits = ['train', 'validation', 'test']
    split_files = {
        'train': os.path.join(data_dir, 'train.tsv'),
        'validation': os.path.join(data_dir, 'dev.tsv'),
        'test': os.path.join(data_dir, 'test.tsv'),
    }
    
    # Dla fonemizacji języka polskiego używamy phonemizer z backendem espeak
    for split in splits:
        skip = 0
        logging.info(f"Now processing split {split}...")
        tsv_file = split_files[split]
        df = pd.read_csv(tsv_file, sep='\t')
        for index, item in tqdm.tqdm(df.iterrows(), total=len(df)):
            client_id = item['client_id']
            path = item['path']
            sentence = item['sentence']
            # sprawdz czy path istnieje, jeśli path nie istnieje przetwarzaj kolejną ścieżkę
            full_path = os.path.join(sorce_mp3, path)
            if not os.path.exists(full_path):
                logging.warning(f"File does not exist: {full_path}")
                time.sleep(0.01)
                skip += 1
                continue
            save_fn = os.path.join(phn_save_root, path.replace('.mp3', '') + ".txt")
            text = sentence.strip()
            if not isinstance(text, str) or not text:
                logging.info(f"Skipping empty sentence at {path}")
                skip += 1
                continue
            try:
                phn = phonemize(text, language='pl', backend='espeak', strip=True, preserve_punctuation=True, njobs=1)
                phn_seq = phn.strip()
                if not phn_seq:
                    logging.warning(f"Phonemization resulted in empty sequence for {path}")
                    skip += 1
                    continue
                phn_vocab.update(phn_seq.split())
                all_lens.append(len(phn_seq.split()))
                with open(save_fn, "w") as f:
                    f.write(phn_seq)
            except Exception as e:
                logging.warning(f"Phonemization failed for {path}: {e}")
                skip += 1
                continue
        logging.info(f"Split {split} has {len(df)} samples in total, skipped {skip} due to errors")
    
    logging.info(f"Phoneme vocabulary size: {len(phn_vocab)}")
    logging.info(f"Phoneme sequence stats:")
    logging.info(f"Longest sequence: {max(all_lens)} phonemes")
    logging.info(f"Shortest sequence: {min(all_lens)} phonemes")
    logging.info(f"Median sequence length: {np.quantile(all_lens, 0.5)} phonemes")
    logging.info(f"95th percentile sequence length: {np.quantile(all_lens, 0.95)} phonemes")
    logging.info(f"Writing vocabulary to {vocab_fn}")
    with open(vocab_fn, "w") as f:
        for i, phn in enumerate(sorted(list(phn_vocab))):
            if i < len(phn_vocab) - 1:
                f.write(f"{str(i)} {phn}\n")
            else:
                f.write(f"{str(i)} {phn}")
    
    # Ładowanie modelu Encodec
    logging.info("Loading Encodec model...")
    # Używamy predefiniowanego modelu Encodec dla 16 kHz
    model = EncodecModel.encodec_model_16khz()
    model.set_target_bandwidth(6.0)
    model = model.cuda()
    model.eval()
    
    # Definiowanie klasy dataset
    class CommonVoiceDataset(torch.utils.data.Dataset):
        def __init__(self, split):
            super().__init__()
            tsv_file = split_files[split]
            self.data_dir = data_dir
            self.df = pd.read_csv(tsv_file, sep='\t')
            self.audio_dir = os.path.join(self.data_dir, 'clips')
        def __len__(self):
            return len(self.df)
        def __getitem__(self, idx):
            item = self.df.iloc[idx]
            path = item['path']
            sentence = item['sentence']
            audio_path = os.path.join(self.audio_dir, path)
            try:
                if not os.path.exists(audio_path):
                    logging.warning(f"Audio file does not exist: {audio_path}")
                    return None, None, None, None, None
                import soundfile as sf
                waveform, sr = sf.read(audio_path)
                waveform = torch.from_numpy(waveform).float()
                if len(waveform.size()) > 1:
                    waveform = waveform.mean(dim=1)  # Konwersja do mono
                waveform = convert_audio(waveform, sr, args.model_sr, model.channels)
                duration = waveform.shape[-1] / args.model_sr
                return path.replace('.mp3', ''), waveform, args.model_sr, sentence, duration
            except Exception as e:
                logging.warning(f"Failed to load audio {audio_path}: {e}")
                return None, None, None, None, None
        def collate(self, batch):
            res = {'path': [], "audio": [], "sr": [], "text": [], "duration": []}
            for item in batch:
                if item[0] is not None:
                    res['path'].append(item[0])
                    res['audio'].append(item[1])
                    res['sr'].append(item[2])
                    res['text'].append(item[3])
                    res['duration'].append(item[4])
            return res
    
    # Wyodrębnianie kodów Encodec
    logging.info("Starting Encodec encoding...")
    datasets = {}
    dataloaders = {}
    for split in splits:
        dataset = CommonVoiceDataset(split)
        dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.mega_batch_size, shuffle=False, drop_last=False, num_workers=args.n_workers, collate_fn=dataset.collate)
        datasets[split] = dataset
        dataloaders[split] = dataloader
    
    for split in splits:
        skip = 0
        logging.info(f"Now processing split {split}...")
        total_samples = len(datasets[split])
        mega_n_steps = int(np.ceil(total_samples / args.mega_batch_size))
        logging.info(f"Partitioning the split {split} into {mega_n_steps} parts, each has {args.mega_batch_size} samples")
        for m, mega_batch in enumerate(dataloaders[split]):
            logging.info(f"====================================")
            logging.info(f"Now processing mega step {m+1}/{mega_n_steps}")
            durations = mega_batch['duration']
            if not durations:
                logging.warning("No valid durations in this mega batch, skipping.")
                continue
            lengths = durations  # Czas trwania w sekundach
            sorted_inds = sort_by_audio_len(lengths)
            for j in range(len(sorted_inds) -1, -1, -1):
                if lengths[sorted_inds[j]] < 0.2 or lengths[sorted_inds[j]] > args.len_cap:
                    skip += 1
                    del sorted_inds[j]
            if not sorted_inds:
                logging.warning("No valid samples after filtering by length, skipping mega batch.")
                continue
            n_steps = int(np.ceil(len(sorted_inds) / args.batch_size))
            for n in tqdm.tqdm(range(n_steps)):
                inds_used = sorted_inds[n*args.batch_size:(n+1)*args.batch_size]
                if len(inds_used) == 0:
                    continue
                audio_batch = [mega_batch['audio'][id] for id in inds_used]
                sr_batch = [mega_batch['sr'][id] for id in inds_used]
                path_batch = [mega_batch['path'][id] for id in inds_used]
                text_batch = [mega_batch['text'][id] for id in inds_used]
                padded_wav = torch.nn.utils.rnn.pad_sequence(audio_batch, batch_first=True).unsqueeze(1)  # [B, 1, T]
                all_lens = [lengths[id] for id in inds_used]
                try:
                    with torch.no_grad():
                        if max(all_lens) > args.max_len / args.model_sr and len(all_lens) > 1:
                            codes = []
                            inwav = padded_wav.cuda()
                            codes_first_half = model.encode(inwav[:len(inwav)//2])[0].cpu()
                            codes_second_half = model.encode(inwav[len(inwav)//2:])[0].cpu()
                            codes = torch.cat([codes_first_half, codes_second_half], dim=0)
                        else:
                            encoded_frames = model.encode(padded_wav.cuda())
                            codes = encoded_frames[0].cpu()
                    for i, length in enumerate(all_lens):
                        save_fn = os.path.join(codes_save_root, path_batch[i] + ".txt")
                        actual_len = min(codes.size(2), round(length * args.model_code_sr))  # Unikamy przekroczenia indeksu
                        cur_code = codes[i, :, :actual_len].tolist()
                        write_array_to_txt_file(cur_code, save_fn)
                except Exception as e:
                    logging.warning(f"Encoding failed at step {n+1} in mega step {m+1}: {e}")
                    continue
        logging.info(f"Finished processing split {split}, skipped {skip} samples due to length constraints or errors")
    
    logging.info("Processing complete.")
    

    Wprowadzone zmiany:

    1. Obsługa brakujących plików: Dodałem sprawdzenie, czy plik audio istnieje zarówno w czasie fonemizacji, jak i podczas ładowania danych w klasie CommonVoiceDataset. Jeśli plik nie istnieje, kod loguje ostrzeżenie i kontynuuje działanie.

    2. Dodatkowa obsługa wyjątków: Upewniłem się, że wszelkie potencjalne miejsca, w których może wystąpić wyjątek (np. podczas fonemizacji lub kodowania Encodec), są otoczone blokami try-except, aby złapać wyjątki i kontynuować przetwarzanie.

    3. Logowanie: Zwiększyłem ilość logowania, aby lepiej śledzić postęp i potencjalne problemy. Teraz kod loguje, gdy plik nie istnieje, gdy fonemizacja zwraca pusty ciąg, oraz gdy nie ma żadnych prawidłowych próbek do przetworzenia w mega paczce.

    4. Sprawdzenie pustych mega paczek: Dodałem sprawdzenie, czy po filtrowaniu długości nie zostaliśmy bez żadnych próbek do przetworzenia. Jeśli tak, kod loguje ostrzeżenie i kontynuuje z następną mega paczką.

    5. Zmniejszenie czasu sleep: Zmniejszyłem czas uśpienia w czasie fonemizacji z 0.5 sekundy do 0.01 sekundy, aby przyspieszyć działanie kodu.

    Jak to pomoże:

    • Kontynuacja po błędzie: Dzięki dodatkowej obsłudze wyjątków kod nie będzie się zatrzymywał na pojedynczych błędach, ale będzie kontynuował przetwarzanie pozostałych próbek.

    • Lepsza diagnostyka: Dodatkowe logowanie pomoże zidentyfikować, gdzie i dlaczego występują błędy, co ułatwi dalsze debugowanie w razie potrzeby.

    Dodatkowe sugestie:

    • Sprawdzenie błędnych danych: Jeśli błędy nadal występują, warto sprawdzić, czy w danych nie ma uszkodzonych plików lub nietypowych wpisów, które mogą powodować problemy.

    • Aktualizacja bibliotek: Upewnij się, że wszystkie używane biblioteki są aktualne, co może pomóc uniknąć niektórych błędów.

    Mam nadzieję, że te poprawki pomogą rozwiązać problem z zatrzymującym się kodem.