У меня есть следующий код обработки import torchaudio from datasets import Dataset…
- 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 засоряет всю оперативную память, что я могу сделать
- 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))
Выберите подходящий для вашего сценария метод. Если данные большие и регулярный доступ к дисковому хранилищу возможен, вариант с сохранением обработанных данных на диск может быть предпочтительным. В случае с более сложными вычислительными системами (например, серверными кластерами), потоки и батчи могут оказаться более подходящими.
- User
Давай использовать подход с батчами, но нужно добавить распараллеливание
- 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)} аудиофайлов")
Объяснение кода:
-
Разбиение на батчи: Сначала мы делим весь датасет на батчи фиксированного размера (
batch_size). Каждый батч обрабатывается отдельно, чтобы избежать превышения оперативной памяти.batches = [dataset[i:i + batch_size] for i in range(0, len(dataset), batch_size)] -
Распараллеливание: Мы используем
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) -
Объединение результатов: Результаты обработки каждого батча собираются в общий список
processed_batches:for result in results: processed_batches.extend(result) -
Функция обработки батча: В
process_batchпроисходит последовательная обработка каждой строки в одном батче.return [load_and_resample_audio(row, new_sample_rate) for row in batch] -
Количество процессов: Параметр
num_processesзадает количество параллельных процессов. Желательно выбрать значение, равное числу доступных ядер на вашей машине (os.cpu_count()).
Параметры для настройки:
batch_size: Размер батча. Если у вас большая оперативная память, можно использовать более крупные батчи (например, 500).num_processes: Количество воркеров для параллельной обработки. Оптимально выбрать значение, равное числу доступных CPU ядер.new_sample_rate: Частота дискретизации, до которой вы приводите аудио.
Примечания:
-
Процессы (а не потоки): Мы используем
ProcessPoolExecutor, а неThreadPoolExecutor, так как Python Global Interpreter Lock (GIL) может ограничивать производительность потоков в CPU-bound задачах, например, для ресэмплинга. -
Потребление памяти: Распараллеливание снижает потребление памяти, поскольку данные обрабатываются батчами, и каждый процесс очищает свою память после завершения работы над батчем.
-
Совместимость с вашим
torchaudio: Код предполагает, что данные вdatasetпредставляют собой список словарей, где ключ'server_audio_path'указывает путь до аудиофайлов. Убедитесь, что структура вашего датасета совпадает с этим.
С помощью этого подхода вы получите обработку данных в батчах с эффективным использованием параллельных вычислений. Попробуйте настроить параметры (
batch_sizeиnum_processes) в зависимости от вашего оборудования и объема данных для достижения наилучшей производительности. -
- User
А просто в map num_proc?
- 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:-
Простота использования: Вам не нужно вручную разбивать датасет на батчи и управлять воркерами — всё делается автоматически внутренним механизмом библиотеки
datasets. -
Повышенная производительность: Обработка данных в несколько процессов может значительно ускорить выполнение, особенно при наличии большого числа ядер процессора.
-
Кроссплатформенность: Использование
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:-
Скорость ввода-вывода (I/O): Если обработка данных во многом зависит от операций чтения/записи файлов (например, чтение аудио с диска), ускорение будет ограничиваться скоростью вашего жесткого диска или SSD.
-
Память: При увеличении количества процессов (
num_proc) каждый процесс будет потреблять память для своей части данных. В случае небольшого объема памяти на вашем оборудовании это может оказаться узким местом. -
**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 процессов) на вашем оборудовании. Это поможет выбрать оптимальное количество процессов. -
- 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 })
Надо вот в этом коде
- 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), "записей")
Что изменено?
-
Добавление
num_procдляbatch.map(): Каждая операцияmapпри обработке батча теперь выполняется параллельно с использованием нескольких процессов, что ускоряет обработку.processed_batch = batch.map( lambda row: load_and_resample_audio(row), num_proc=num_proc ) -
Параметры для распараллеливания:
num_proc— определяет количество процессов, используемых для обработки батча. Например, если на вашем устройстве 4 ядра, то стоит задатьnum_proc=4. Вы можете автоматически определить количество доступных ядер с помощьюos.cpu_count():import os num_proc = os.cpu_count() # Автоматическое определение числа процессов
-
Очистка памяти после обработки каждого батча: После обработки каждого батча происходит освобождение системных ресурсов с помощью
gc.collect(). Это важно, чтобы избежать перегрузки оперативной памяти.
Пример вывода параметров для тестирования:
-
Количество процессов: Вы можете протестировать на своём оборудовании разное количество процессов и подобрать оптимальное значение:
for num_proc in [2, 4, 8]: print(f"Тестирование с {num_proc} процессами...") ... -
Размер батча: Если ваш датасет огромен, рекомендуем уменьшить размер батча (
batch_size), например, до1000, чтобы снизить нагрузку на память.
Преимущества:
-
Комбинация батчей и параллельной обработки: Вы сохраняете компактность обработки данных в батчах (чтобы не использовать всю память), а внутри каждого батча добавляете ускорение за счёт параллельной обработки.
-
Ускорение с использованием
num_proc: Ускорение достигается за счёт использования нескольких ядер процессора одновременно (особенно для задач, таких как ресэмплинг звука, где основная нагрузка идёт на CPU). -
Совместимость с библиотекой
datasets: Код по-прежнему использует библиотекуdatasetsдля удобного управления датасетом и не требует сложного ручного управления разделением данных.
Рекомендации:
-
Скорость чтения/записи: Убедитесь, что данные (например, аудио) хранятся на быстром носителе (SSD), так как узким местом может стать скорость чтения аудиоданных с диска.
-
Тестирование разных параметров: Параметры
batch_sizeиnum_procтребуют настройки в зависимости от объёма вашего датасета и оборудования. -
Проблема больших датасетов: Если ваш итоговый
loaded_datasetслишком велик и его нельзя держать в памяти, рассмотрите сохранение обработанных аудиоданных на диск в каждом батче, а не объединение их в один общий датасет.
С этим изменением ваш код будет эффективно обрабатывать большие аудиодатасеты, используя как батчинг, так и мультипроцессинг.
-