Question

我有一个文件夹（7.7GB），其中包含以拼花文件格式存储的多个熊猫数据帧。我需要将所有这些数据帧加载到python字典中，但是由于我只有32GB的RAM，因此我使用.loc方法仅加载所需的数据。

当所有数据帧都以python字典的形式加载到内存中时，我会根据所有数据的索引创建一个通用索引，然后使用新索引为所有数据帧重新编制索引。

我开发了两个脚本来执行此操作，第一个以经典的顺序方式进行，第二个使用Dask in oder从Threadripper 1920x的所有内核中获得了一些性能改进。

顺序代码：

# Standard library imports
import os
import pathlib
import time

# Third party imports
import pandas as pd

# Local application imports


class DataProvider:

def __init__(self):

    self.data = dict()

def load_parquet(self, source_dir: str, timeframe_start: str, timeframe_end: str) -> None:

    t = time.perf_counter()

    symbol_list = list(file for file in os.listdir(source_dir) if file.endswith('.parquet'))

    # updating containers
    for symbol in symbol_list:

        path = pathlib.Path.joinpath(pathlib.Path(source_dir), symbol)
        name = symbol.replace('.parquet', '')

        self.data[name] = pd.read_parquet(path).loc[timeframe_start:timeframe_end]

    print(f'Loaded data in {round(time.perf_counter() - t, 3)} seconds.')

    t = time.perf_counter()

    # building index
    index = None

    for symbol in self.data:

        if index is not None:
            index.union(self.data[symbol].index)
        else:
            index = self.data[symbol].index

    print(f'Built index in {round(time.perf_counter() - t, 3)} seconds.')

    t = time.perf_counter()

    # reindexing data
    for symbol in self.data:

        self.data[symbol] = self.data[symbol].reindex(index=index, method='pad').itertuples()

    print(f'Indexed data in {round(time.perf_counter() - t, 3)} seconds.')


if __name__ == '__main__' or __name__ == 'builtins':

    source = r'WindowsPath'

    x = DataProvider()
    x.load_parquet(source_dir=source, timeframe_start='2015', timeframe_end='2015')

快捷代码：

# Standard library imports
import os
import pathlib
import time

# Third party imports
from dask.distributed import Client
import pandas as pd

# Local application imports


def __load_parquet__(directory, timeframe_start, timeframe_end):
    return pd.read_parquet(directory).loc[timeframe_start:timeframe_end]


def __reindex__(new_index, df):
    return df.reindex(index=new_index, method='pad').itertuples()


if __name__ == '__main__' or __name__ == 'builtins':

    client = Client()

    source = r'WindowsPath'
    start = '2015'
    end = '2015'

    t = time.perf_counter()

    file_list = [file for file in os.listdir(source) if file.endswith('.parquet')]

    # build data
    data = dict()
    for file in file_list:

        path = pathlib.Path.joinpath(pathlib.Path(source), file)
        symbol = file.replace('.parquet', '')

        data[symbol] = client.submit(__load_parquet__, path, start, end)

    print(f'Loaded data in {round(time.perf_counter() - t, 3)} seconds.')

    t = time.perf_counter()

    # build index
    index = None
    for symbol in data:
        if index is not None:
            index.union(data[symbol].result().index)
        else:
            index = data[symbol].result().index

    print(f'Built index in {round(time.perf_counter() - t, 3)} seconds.')

    t = time.perf_counter()

    # reindex
    for symbol in data:
        data[symbol] = client.submit(__reindex__, index, data[symbol].result())

    print(f'Indexed data in {round(time.perf_counter() - t, 3)} seconds.')

我发现结果很奇怪。

顺序代码：

计算过程中的最大内存消耗： 30.2GB
计算结束时的内存消耗： 15.6GB
总内存消耗（不包括Windows和其他操作系统）： 11.6GB
在 54.289 秒内加载数据。
建立索引的时间为 0.428 秒。
在 9.666 秒内重新索引数据。

快捷代码：

计算过程中的最大内存消耗： 25.2GB
计算结束时的内存消耗： 22.6GB
总内存消耗（不包括Windows和其他操作系统）： 18.9GB
在 0.638 秒内加载数据。
建立索引的时间为 27.541 秒。
在 30.179 秒内重新索引数据。

我的问题：

为什么使用Dask，计算结束时的内存消耗会高得多？
为什么使用Dask构建公共索引并对所有数据帧重新编制索引会花费那么多时间？

此外，在使用Dask代码时，控制台会向我显示以下错误。

C:\Users\edit\Anaconda3\envs\edit\lib\site-packages\distribute\worker.py:901:UserWarning: Large object of size 5.41 MB detected in task graph: 
(DatetimeIndex(['2015-01-02 09:30:00', '2015-01-02 ... s x 5 columns])
Consider scattering large objects ahead of time with client.scatter to reduce  scheduler burden and keep data on workers
future = client.submit(func, big_data)    # bad
big_future = client.scatter(big_data)     # good
future = client.submit(func, big_future)  # good
% (format_bytes(len(b)), s))

即使错误建议确实很不错，我也没有发现我的代码有什么问题。为什么说保留有关工人的数据？我认为使用Submit方法可以将所有数据发送到我的客户端，因此工作人员可以轻松访问所有数据。谢谢大家的帮助。

在字典上加载多个Pandas数据帧时，消耗大量内存

0 个答案: