Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-11-20· OpenAIAi2 WildChat-4.8M (AI2)

У меня есть следующий код обработки import torchaudio from datasets import Dataset…

  1. User

    У меня есть следующий код обработки

    import torchaudio from datasets import Dataset import pandas as pd

    df = pd.read_json('../data/asr_kk_data/processed_asr_data_kk_300h.json') df = df.rename(columns={'audio': 'ls_audio_path'}) dataset = Dataset.from_pandas(df)

    import gc

    def load_and_resample_audio(row, new_sample_rate=16000): #waveform, sample_rate = torchaudio.load(row['server_vad_audio_path']) waveform, sample_rate = torchaudio.load(row['server_audio_path']) if sample_rate != new_sample_rate: resampler = torchaudio.transforms.Resample(orig_freq=sample_rate, new_freq=new_sample_rate) waveform = resampler(waveform) waveform = waveform.squeeze()

    result = { 'audio': { 'path': row['server_audio_path'], 'array': waveform.numpy(), 'sampling_rate': new_sample_rate } }

    del waveform, sample_rate, resampler gc.collect()

    return result loaded_dataset = dataset.map(lambda row: load_and_resample_audio(row))

    Функция map засоряет всю оперативную память, что я могу сделать

  2. Assistant

    Когда вы используете функцию map для обработки данных в библиотеке datasets, вся операция осуществляется в памяти, что может вызвать проблемы, особенно при больших объёмах данных. Чтобы адресовать эту проблему, можно рассмотреть несколько вариантов оптимизации:


    1. Обработка данных поэтапно (батчами):

    Вместо загрузки и обработки всех данных сразу, можно разбить их на небольшие куски (батчи) и работать с каждым батчем по отдельности.

    Пример:

    from datasets import Dataset
    import torchaudio
    import pandas as pd
    import gc
    
    def load_and_resample_audio(row, new_sample_rate=16000):
        waveform, sample_rate = torchaudio.load(row['server_audio_path'])
        if sample_rate != new_sample_rate:
            resampler = torchaudio.transforms.Resample(orig_freq=sample_rate, new_freq=new_sample_rate)
            waveform = resampler(waveform)
        waveform = waveform.squeeze()
    
        result = {
            'audio': {
                'path': row['server_audio_path'],
                'array': waveform.numpy(),
                'sampling_rate': new_sample_rate
            }
        }
    
        del waveform, sample_rate
        gc.collect()
    
        return result
    
    df = pd.read_json('../data/asr_kk_data/processed_asr_data_kk_300h.json')
    df = df.rename(columns={'audio': 'ls_audio_path'})
    
    dataset = Dataset.from_pandas(df)
    
    batch_size = 100  # Пример. Вы можете настроить размер батча.
    processed_batches = []
    
    for i in range(0, len(dataset), batch_size):
        batch = dataset.select(range(i, min(i + batch_size, len(dataset))))
        processed_batch = batch.map(load_and_resample_audio)
        processed_batches.append(processed_batch)
        gc.collect()
    
    # Объединяем обработанные батчи в один датасет (если нужно)
    loaded_dataset = Dataset.from_dict({
        key: sum((batch[key] for batch in processed_batches), [])
        for key in processed_batches[0].features
    })
    

    Здесь данные обрабатываются кусками (по batch_size элементов), что снижает нагрузку на оперативную память.


    2. Использование потока с сохранением результатов на диск:

    Если объёмы данных очень большие, можно напрямую сохранять результаты обработки в виде файлов (например, на диск), а потом, если нужно, загрузить их обратно в необходимом формате.

    Пример:

    import os
    from datasets import Dataset
    
    def save_processed_row(row, output_dir, new_sample_rate=16000):
        waveform, sample_rate = torchaudio.load(row['server_audio_path'])
        if sample_rate != new_sample_rate:
            resampler = torchaudio.transforms.Resample(orig_freq=sample_rate, new_freq=new_sample_rate)
            waveform = resampler(waveform)
        waveform = waveform.numpy()
    
        # Сохраняем каждый обработанный пример
        file_name = os.path.basename(row['server_audio_path'])
        output_path = os.path.join(output_dir, file_name)
    
        torchaudio.save(output_path, torch.tensor(waveform), new_sample_rate)
    
        return {'processed_audio_path': output_path}
    
    output_dir = "../data/processed_audio/"
    os.makedirs(output_dir, exist_ok=True)
    
    dataset = Dataset.from_pandas(df)
    
    # Обработка на лету, сохранение результатов на диск
    dataset = dataset.map(lambda row: save_processed_row(row, output_dir))
    

    Таким образом, вы можете сохранить обработанные данные в файлы, но освободить оперативную память между итерациями. Обратите внимание, что в этом случае разные промежуточные файлы сохраняются в указанной директории.


    3. Работа с DataLoader для потоковой обработки:

    Если вы хотите использовать более привычный метод для обработки данных внутри PyTorch, можно подключить DataLoader из torch.utils.data. Преимущество — это потоковая обработка данных вместо работы с ними в памяти.

    Пример:

    from torch.utils.data import DataLoader
    
    class CustomDataset(torch.utils.data.Dataset):
        def __init__(self, data, new_sample_rate=16000):
            self.data = data
            self.new_sample_rate = new_sample_rate
        
        def __len__(self):
            return len(self.data)
        
        def __getitem__(self, idx):
            row = self.data[idx]
            waveform, sample_rate = torchaudio.load(row['server_audio_path'])
            if sample_rate != self.new_sample_rate:
                resampler = torchaudio.transforms.Resample(orig_freq=sample_rate, new_freq=self.new_sample_rate)
                waveform = resampler(waveform)
    
            return {
                'path': row['server_audio_path'],
                'array': waveform.numpy(),
                'sampling_rate': self.new_sample_rate
            }
    
    # Выбираем размер батча по памяти
    batch_size = 32
    custom_dataset = CustomDataset(df.to_dict(orient='records'))
    dataloader = DataLoader(custom_dataset, batch_size=batch_size, shuffle=False)
    
    # Итеративная обработка
    for batch in dataloader:
        # Обработайте данные в каждом батче
        pass
    

    4. Асинхронная обработка с concurrent.futures:

    Вы могли бы использовать более параллельную стратегию обработки с помощью многопроцессорной библиотеки (например, concurrent.futures).

    Пример:

    from concurrent.futures import ProcessPoolExecutor
    
    def process_row(row):
        waveform, sample_rate = torchaudio.load(row['server_audio_path'])
        new_sample_rate = 16000
        if sample_rate != new_sample_rate:
            resampler = torchaudio.transforms.Resample(orig_freq=sample_rate, new_freq=new_sample_rate)
            waveform = resampler(waveform)
    
        return {
            'path': row['server_audio_path'],
            'array': waveform.numpy(),
            'sampling_rate': new_sample_rate
        }
    
    # Оптимально указывается число воркеров (зависит от вашего железа)
    num_workers = 4
    with ProcessPoolExecutor(max_workers=num_workers) as executor:
        processed_data = list(executor.map(process_row, dataset))
    

    Выберите подходящий для вашего сценария метод. Если данные большие и регулярный доступ к дисковому хранилищу возможен, вариант с сохранением обработанных данных на диск может быть предпочтительным. В случае с более сложными вычислительными системами (например, серверными кластерами), потоки и батчи могут оказаться более подходящими.

  3. User

    Давай использовать подход с батчами, но нужно добавить распараллеливание

  4. Assistant

    Чтобы добавить распараллеливание в подход с обработкой батчами, можно использовать модуль concurrent.futures (параллельные процессы/потоки) или распределение батчей между несколькими воркерами с помощью multiprocessing. Ниже представлен код для реализации подхода с батчами с использованием распараллеливания с помощью ProcessPoolExecutor.


    Код с использованием батчей и распараллеливания:

    from datasets import Dataset
    from concurrent.futures import ProcessPoolExecutor
    import torchaudio
    import pandas as pd
    import gc
    
    def load_and_resample_audio(row, new_sample_rate=16000):
        """Функция загрузки и ресэмплинга аудиофайла"""
        waveform, sample_rate = torchaudio.load(row['server_audio_path'])
        if sample_rate != new_sample_rate:
            resampler = torchaudio.transforms.Resample(orig_freq=sample_rate, new_freq=new_sample_rate)
            waveform = resampler(waveform)
        waveform = waveform.squeeze()
    
        result = {
            'audio': {
                'path': row['server_audio_path'],
                'array': waveform.numpy(),
                'sampling_rate': new_sample_rate
            }
        }
    
        # Очистка памяти для каждого шага
        del waveform, sample_rate
        gc.collect()
    
        return result
    
    def process_batch(batch, new_sample_rate=16000):
        """Обработка одного батча данных"""
        # Обрабатываем каждую строку в батче
        return [load_and_resample_audio(row, new_sample_rate) for row in batch]
    
    def parallel_process_batches(dataset, batch_size=100, num_processes=4, new_sample_rate=16000):
        """Распараллеливание обработки батчей"""
        # Создаем батчи путем разбиения датасета
        batches = [dataset[i:i + batch_size] for i in range(0, len(dataset), batch_size)]
        processed_batches = []
    
        # Используем ProcessPoolExecutor для параллельной обработки батчей
        with ProcessPoolExecutor(max_workers=num_processes) as executor:
            # Каждую партию передаем для обработки
            results = executor.map(lambda b: process_batch(b, new_sample_rate), batches)
            for result in results:
                processed_batches.extend(result)  # Собираем все обработанные результаты
    
        return processed_batches
    
    
    # Загружаем данные из CSV/json
    df = pd.read_json('../data/asr_kk_data/processed_asr_data_kk_300h.json')
    df = df.rename(columns={'audio': 'ls_audio_path'})
    dataset = Dataset.from_pandas(df)
    
    # Настраиваем параметры
    batch_size = 100
    num_processes = 4  # Количество процессов для обработки
    new_sample_rate = 16000
    
    # Распараллеливаем обработку батчей
    processed_data = parallel_process_batches(dataset, batch_size=batch_size, num_processes=num_processes, new_sample_rate=new_sample_rate)
    
    # Проверяем результат
    print(f"Обработано {len(processed_data)} аудиофайлов")
    

    Объяснение кода:

    1. Разбиение на батчи: Сначала мы делим весь датасет на батчи фиксированного размера (batch_size). Каждый батч обрабатывается отдельно, чтобы избежать превышения оперативной памяти.

      batches = [dataset[i:i + batch_size] for i in range(0, len(dataset), batch_size)]
      
    2. Распараллеливание: Мы используем concurrent.futures.ProcessPoolExecutor, чтобы обрабатывать батчи в разных процессах. Каждый процесс берет свой батч, вызывает функцию process_batch и обрабатывает все строки в данном батче.

      with ProcessPoolExecutor(max_workers=num_processes) as executor:
          results = executor.map(lambda b: process_batch(b, new_sample_rate), batches)
      
    3. Объединение результатов: Результаты обработки каждого батча собираются в общий список processed_batches:

      for result in results:
          processed_batches.extend(result)
      
    4. Функция обработки батча: В process_batch происходит последовательная обработка каждой строки в одном батче.

      return [load_and_resample_audio(row, new_sample_rate) for row in batch]
      
    5. Количество процессов: Параметр num_processes задает количество параллельных процессов. Желательно выбрать значение, равное числу доступных ядер на вашей машине (os.cpu_count()).


    Параметры для настройки:

    • batch_size: Размер батча. Если у вас большая оперативная память, можно использовать более крупные батчи (например, 500).
    • num_processes: Количество воркеров для параллельной обработки. Оптимально выбрать значение, равное числу доступных CPU ядер.
    • new_sample_rate: Частота дискретизации, до которой вы приводите аудио.

    Примечания:

    1. Процессы (а не потоки): Мы используем ProcessPoolExecutor, а не ThreadPoolExecutor, так как Python Global Interpreter Lock (GIL) может ограничивать производительность потоков в CPU-bound задачах, например, для ресэмплинга.

    2. Потребление памяти: Распараллеливание снижает потребление памяти, поскольку данные обрабатываются батчами, и каждый процесс очищает свою память после завершения работы над батчем.

    3. Совместимость с вашим torchaudio: Код предполагает, что данные в dataset представляют собой список словарей, где ключ 'server_audio_path' указывает путь до аудиофайлов. Убедитесь, что структура вашего датасета совпадает с этим.


    С помощью этого подхода вы получите обработку данных в батчах с эффективным использованием параллельных вычислений. Попробуйте настроить параметры (batch_size и num_processes) в зависимости от вашего оборудования и объема данных для достижения наилучшей производительности.

  5. User

    А просто в map num_proc?

  6. Assistant

    Да, библиотека datasets от Hugging Face, которая используется в вашем коде, поддерживает параметр num_proc для метода .map(). Этот параметр позволяет распараллелить выполнение операции map, используя несколько процессов. В отличие от ручной реализации обработки через батчи, добавление num_proc в .map() намного удобнее и требует минимальных изменений, при этом пользователи автоматически получают прирост производительности.


    Модифицированный код с num_proc:

    В вашем коде нужно просто добавить параметр num_proc в метод .map(). Вот как это сделать:

    import torchaudio
    from datasets import Dataset
    import pandas as pd
    import gc
    
    # Загрузка данных
    df = pd.read_json('../data/asr_kk_data/processed_asr_data_kk_300h.json')
    df = df.rename(columns={'audio': 'ls_audio_path'})
    dataset = Dataset.from_pandas(df)
    
    # Функция для загрузки и ресэмплинга аудио
    def load_and_resample_audio(row, new_sample_rate=16000):
        waveform, sample_rate = torchaudio.load(row['server_audio_path'])
        if sample_rate != new_sample_rate:
            resampler = torchaudio.transforms.Resample(orig_freq=sample_rate, new_freq=new_sample_rate)
            waveform = resampler(waveform)
        waveform = waveform.squeeze()
    
        result = {
            'audio': {
                'path': row['server_audio_path'],
                'array': waveform.numpy(),
                'sampling_rate': new_sample_rate
            }
        }
    
        # Чистим ресурсы
        del waveform, sample_rate, resampler
        gc.collect()
    
        return result
    
    # Оптимизация с использованием num_proc для параллельной обработки
    loaded_dataset = dataset.map(
        lambda row: load_and_resample_audio(row), 
        num_proc=4  # Количество процессов — настройте под ваше оборудование
    )
    
    print("Обработка завершена.")
    

    Вот и всё! Теперь ваша функция обработки будет выполняться параллельно с использованием нескольких процессов.


    Как это работает?

    Когда вы указываете параметр num_proc в методе .map, ваш датасет автоматически делится на несколько частей (разбиение по строкам) и передается разным процессам для независимой обработки. После завершения обработки каждая часть объединяется обратно в один датасет.


    Преимущества использования num_proc:

    1. Простота использования: Вам не нужно вручную разбивать датасет на батчи и управлять воркерами — всё делается автоматически внутренним механизмом библиотеки datasets.

    2. Повышенная производительность: Обработка данных в несколько процессов может значительно ускорить выполнение, особенно при наличии большого числа ядер процессора.

    3. Кроссплатформенность: Использование num_proc гарантирует, что параллелизм будет работать одинаково корректно как на Windows, так и на Linux/MacOS.


    Параметры, которые можно добавить:

    • num_proc: Задаёт количество параллельных процессов. Оптимальное значение — количество доступных ядер в системе. Вы можете узнать их с помощью os.cpu_count().

      import os
      num_proc = os.cpu_count()  # Автоматически определить число ядер
      
    • batch_size: (по желанию) Если используете слишком большой датасет, вы можете указать batch_size. Это уменьшит разбиение данных на слишком маленькие фрагменты. Например:

      loaded_dataset = dataset.map(
          lambda row: load_and_resample_audio(row),
          num_proc=4,
          batch_size=10  # Обрабатывать 10 строк одновременно для каждого процесса
      )
      

    Ограничения использования num_proc:

    1. Скорость ввода-вывода (I/O): Если обработка данных во многом зависит от операций чтения/записи файлов (например, чтение аудио с диска), ускорение будет ограничиваться скоростью вашего жесткого диска или SSD.

    2. Память: При увеличении количества процессов (num_proc) каждый процесс будет потреблять память для своей части данных. В случае небольшого объема памяти на вашем оборудовании это может оказаться узким местом.

    3. **Windows и запуск через if __name__ == "__main__":** Если вы используете Windows, добавьте следующий код в главный скрипт, так как библиотека multiprocessing` требует соблюдения этого шаблона:

      if __name__ == "__main__":
          # Весь основной код внутри этого блока
          loaded_dataset = dataset.map(
              lambda row: load_and_resample_audio(row),
              num_proc=4
          )
      

    Общий совет:

    Если вы хотите более детально оценить производительность num_proc, попробуйте протестировать разные значения (например, 2, 4, 8 процессов) на вашем оборудовании. Это поможет выбрать оптимальное количество процессов.

  7. User

    batch_size = 5000 # Пример. Вы можете настроить размер батча. processed_batches = []

    for i in range(0, len(dataset), batch_size): batch = dataset.select(range(i, min(i + batch_size, len(dataset)))) processed_batch = batch.map(load_and_resample_audio) processed_batches.append(processed_batch) gc.collect()

    loaded_dataset = Dataset.from_dict({ key: sum((batch[key] for batch in processed_batches), []) for key in processed_batches[0].features })

    Надо вот в этом коде

  8. Assistant

    Если вы хотите добавить распараллеливание в уже используемый вами код с батчами, можно перевести вызов batch.map() на использование параметра num_proc для распараллеливания. Таким образом, каждый батч будет обрабатываться с использованием нескольких процессов, что ускорит выполнение. Вот улучшенный вариант вашего кода:


    Код с num_proc для батчей:

    import torchaudio
    from datasets import Dataset
    import pandas as pd
    import gc
    
    # Загрузка данных
    df = pd.read_json('../data/asr_kk_data/processed_asr_data_kk_300h.json')
    df = df.rename(columns={'audio': 'ls_audio_path'})
    dataset = Dataset.from_pandas(df)
    
    # Функция для загрузки и ресэмплинга аудио
    def load_and_resample_audio(row, new_sample_rate=16000):
        waveform, sample_rate = torchaudio.load(row['server_audio_path'])
        if sample_rate != new_sample_rate:
            resampler = torchaudio.transforms.Resample(orig_freq=sample_rate, new_freq=new_sample_rate)
            waveform = resampler(waveform)
        waveform = waveform.squeeze()
    
        result = {
            'audio': {
                'path': row['server_audio_path'],
                'array': waveform.numpy(),
                'sampling_rate': new_sample_rate
            }
        }
    
        # Чистим ресурсы
        del waveform, sample_rate, resampler
        gc.collect()
    
        return result
    
    # Настраиваем параметры для обработки батчей
    batch_size = 5000  # Размер батча
    processed_batches = []
    
    # Обработка батчей с распараллеливанием
    num_proc = 4  # Количество процессов (подберите под ваше железо)
    
    for i in range(0, len(dataset), batch_size):
        # Разделяем датасет на небольшой батч
        batch = dataset.select(range(i, min(i + batch_size, len(dataset))))
    
        # Применяем map с num_proc для параллельной обработки
        processed_batch = batch.map(
            lambda row: load_and_resample_audio(row),
            num_proc=num_proc  # Добавляем распараллеливание
        )
        processed_batches.append(processed_batch)
    
        # Чистим память после обработки батча
        gc.collect()
    
    # Объединяем все обработанные батчи обратно в один датасет
    loaded_dataset = Dataset.from_dict({
        key: sum((batch[key] for batch in processed_batches), [])
        for key in processed_batches[0].features
    })
    
    print("Обработка завершена. Итоговый датасет содержит:", len(loaded_dataset), "записей")
    

    Что изменено?

    1. Добавление num_proc для batch.map(): Каждая операция map при обработке батча теперь выполняется параллельно с использованием нескольких процессов, что ускоряет обработку.

      processed_batch = batch.map(
          lambda row: load_and_resample_audio(row),
          num_proc=num_proc
      )
      
    2. Параметры для распараллеливания:

      • num_proc — определяет количество процессов, используемых для обработки батча. Например, если на вашем устройстве 4 ядра, то стоит задать num_proc=4. Вы можете автоматически определить количество доступных ядер с помощью os.cpu_count():
        import os
        num_proc = os.cpu_count()  # Автоматическое определение числа процессов
        
    3. Очистка памяти после обработки каждого батча: После обработки каждого батча происходит освобождение системных ресурсов с помощью gc.collect(). Это важно, чтобы избежать перегрузки оперативной памяти.


    Пример вывода параметров для тестирования:

    • Количество процессов: Вы можете протестировать на своём оборудовании разное количество процессов и подобрать оптимальное значение:

      for num_proc in [2, 4, 8]:
          print(f"Тестирование с {num_proc} процессами...")
          ...
      
    • Размер батча: Если ваш датасет огромен, рекомендуем уменьшить размер батча (batch_size), например, до 1000, чтобы снизить нагрузку на память.


    Преимущества:

    1. Комбинация батчей и параллельной обработки: Вы сохраняете компактность обработки данных в батчах (чтобы не использовать всю память), а внутри каждого батча добавляете ускорение за счёт параллельной обработки.

    2. Ускорение с использованием num_proc: Ускорение достигается за счёт использования нескольких ядер процессора одновременно (особенно для задач, таких как ресэмплинг звука, где основная нагрузка идёт на CPU).

    3. Совместимость с библиотекой datasets: Код по-прежнему использует библиотеку datasets для удобного управления датасетом и не требует сложного ручного управления разделением данных.


    Рекомендации:

    1. Скорость чтения/записи: Убедитесь, что данные (например, аудио) хранятся на быстром носителе (SSD), так как узким местом может стать скорость чтения аудиоданных с диска.

    2. Тестирование разных параметров: Параметры batch_size и num_proc требуют настройки в зависимости от объёма вашего датасета и оборудования.

    3. Проблема больших датасетов: Если ваш итоговый loaded_dataset слишком велик и его нельзя держать в памяти, рассмотрите сохранение обработанных аудиоданных на диск в каждом батче, а не объединение их в один общий датасет.


    С этим изменением ваш код будет эффективно обрабатывать большие аудиодатасеты, используя как батчинг, так и мультипроцессинг.