Блог

Я хотел бы создать фрейм данных из всех возможных комбинаций значений каждой из категорий, перечисленных в словаре.

Я попробовал приведенный ниже код, он отлично работает для небольшого словаря с меньшим ключом и значениями. Но он не выполняется для большего словаря, как я привел ниже.

 import itertools as it
import pandas as pd 


my_dict= {
    "A":[0,1,.....25],
    "B":[4,5,.....35],
    "C":[0,1,......30],
    "D":[0,1,........35], 
       ......... 
    "Y":[0,1,........35],
    "Z":[0,1,........35],
}
df=pd.DataFrame(list(it.product(*my_dict.values())), columns=my_dict.keys())
 

Это ошибка, которую я получаю, как решить эту проблему с большим словарем.

 Traceback (most recent call last):

  File "<ipython-input-11-723405257e95>", line 1, in <module>
    df=pd.DataFrame(list(it.product(*my_dict.values())), columns=my_dict.keys())
 

Ошибка памяти

Как работать с большим словарем для создания фрейма данных

Если у вас достаточно большой ^{кластер[1]} Spark, каждый список в словаре можно использовать в качестве фрейма данных Spark, а затем все эти фреймы данных можно объединить:

 def to_spark_dfs(dict):
    for key in dict:
        l=[[e] for e in dict[key]]
        yield spark.createDataFrame(l, schema=[key])

dfs=to_spark_dfs(my_dict)

from functools import reduce
res=reduce(lambda df1,df2: df1.crossJoin(df2),dfs)
 

Если оригинал my_dict не слишком велик

 my_dict= {
    "A":[0,1,2],
    "B":[4,5,6],
    "C":[0,1,2],
    "D":[0,1], 
    "Y":[0,1,2],
    "Z":[0,1],
}
 

код выдает ожидаемый результат:

 res.show()
# --- --- --- --- --- --- 
#|  A|  B|  C|  D|  Y|  Z|
# --- --- --- --- --- --- 
#|  0|  4|  0|  0|  0|  0|
#|  0|  4|  0|  0|  0|  1|
#|  0|  4|  0|  0|  1|  0|
#|  0|  4|  0|  0|  1|  1|
#...

res.count()
#324
 

^[1]
Используя цифры, приведенные в комментарии (80 ключей и около 30 значений на ключ), вам понадобится действительно большой кластер Spark: 30 ^ 80 дает 1.5*10^118 другую комбинацию. Это больше, чем предполагаемое количество атомов ( 10^80 ) в известной, наблюдаемой вселенной.

В этом случае у нас есть огромное количество возможных комбинаций. Например, если столбцы (A, B, C… Z) могут принимать значения [1…10], то общее количество строк равно 10^26 или 1000000000000000000000000000000.

На мой взгляд, есть 2 основных направления для решения этой проблемы:

• Горизонтальное масштабирование: вычисление и хранение результатов с использованием платформ для распределенных вычислений (таких как Apache Spark или Hadoop )
• Вертикальное масштабирование: оптимизируйте использование процессора/оперативной памяти с помощью:
  • Векторизация (например, избегать loops )
  • Типы данных с минимальным влиянием на распределение оперативной памяти (используйте с минимальной точностью, как вам нужно, используйте factorize() для строк)
  • мини-пакетирование и загрузка промежуточных результатов (кадров данных) из оперативной памяти на диск в сжатом формате (например parquet )
  • проверьте время выполнения и размер объекта в оперативной памяти.

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

Определите следующие функции:

• create_data_frame_baseline() : генератор фреймов данных с циклом, не оптимальные типы данных (базовый уровень)
• create_data_frame_no_loop() : нет цикла, не оптимальные типы данных
• create_data_frame_optimize_data_type() : нет цикла, оптимальные типы данных.

 import itertools as it
import pandas as pd
import numpy as np
from string import ascii_uppercase


def create_letter_dict(cols_n: int = 10, levels_n: int = 6) -> dict:
    letter_dict = {letter: list(range(levels_n)) for letter in ascii_uppercase[0:cols_n]}
    return letter_dict


def create_data_frame_baseline(dict: dict) -> pd.DataFrame:
    df = pd.DataFrame(columns=dict.keys())
    for row in it.product(*dict.values()):
        df.loc[len(df.index)] = row
    
    return df


def create_data_frame_no_loop(dict: dict) -> pd.DataFrame:
    return pd.DataFrame(
        list(it.product(*dict.values())),
        columns=dict.keys()
    )


def create_data_frame_optimize_data_type(dict: dict) -> pd.DataFrame:
    return pd.DataFrame(
        np.int8(list(it.product(*dict.values()))),
        columns=dict.keys()
    )

 

Контрольные показатели:

 import sys
import timeit

cols_n = 7
levels_n = 5
iteration_n = 2


# Baseline

def create_data_frame_baseline_test():
    my_dict = create_letter_dict(cols_n, levels_n)
    df = create_data_frame_baseline(my_dict)

    assert(df.shape == (levels_n**cols_n, cols_n))
    print(sys.getsizeof(df))

    return df

print(timeit.Timer(create_data_frame_baseline_test).timeit(number=iteration_n))


# No loop, not optimal data types 

def create_data_frame_no_loop_test():
    my_dict = create_letter_dict(cols_n, levels_n)
    df = create_data_frame_no_loop(my_dict)

    assert(df.shape == (levels_n**cols_n, cols_n))
    print(sys.getsizeof(df))

    return df

print(timeit.Timer(create_data_frame_no_loop_test).timeit(number=iteration_n))


# No loop, optimal data types.

def create_data_frame_optimize_data_type_test():
    my_dict = create_letter_dict(cols_n, levels_n)
    df = create_data_frame_optimize_data_type(my_dict)

    assert(df.shape == (levels_n**cols_n, cols_n))
    print(sys.getsizeof(df))

    return df

print(timeit.Timer(create_data_frame_optimize_data_type_test).timeit(number=iteration_n))
 

Выходы*:

Используя create_data_frame_optimize_data_type_test() I, я сгенерировал* 100 млн строк менее чем за 100 секунд.

* Сервер Ubuntu 20.04, Intel(R) Xeon(R) 8xCPU @ 2,60 ГГц, 32 ГБ оперативной памяти

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

 import itertools as it
import pandas as pd
from string import ascii_uppercase

N = 36
my_dict = {x: list(range(N)) for x in ascii_uppercase}
df = pd.DataFrame(columns=my_dict.keys())

for row in it.product(*my_dict.values()):
    df.loc[len(df.index)] = row
 

но, конечно, это займет много времени