Где будешь искать причину, если при объединении двух таблиц возникает ошибка недостатка памяти?

Где будешь искать причину, если при объединении двух таблиц возникает ошибка недостатка памяти?

Это практический вопрос о диагностике проблем производительности в Data Science. При join/merge операциях очень часто возникают проблемы с памятью.

Шаг 1: Оценка размера данных

import pandas as pd
import numpy as np

df1 = pd.read_csv('table1.csv')
df2 = pd.read_csv('table2.csv')

# Проверяем размер каждой таблицы
print(f"df1 размер в памяти: {df1.memory_usage(deep=True).sum() / 1024**3:.2f} GB")
print(f"df2 размер в памяти: {df2.memory_usage(deep=True).sum() / 1024**3:.2f} GB")
print(f"df1 форма: {df1.shape}")
print(f"df2 форма: {df2.shape}")

# Худший случай для merge:
# Если ключи не уникальны, результат может быть в N раз больше
print(f"Уникальные ключи в df1: {df1['key'].nunique()}")
print(f"Уникальные ключи в df2: {df2['key'].nunique()}")

Причина 1: Декартово произведение (Cartesian Product)

Это частая причина утечки памяти! Если ключ не уникален, join создаёт все возможные комбинации.

# Пример проблемы
df1 = pd.DataFrame({
    'user_id': [1, 1, 1, 2, 2, 3],
    'action': ['click', 'view', 'purchase', 'click', 'view', 'click']
})

df2 = pd.DataFrame({
    'user_id': [1, 1, 2, 3, 3, 3],
    'product': ['A', 'B', 'C', 'D', 'E', 'F']
})

# При merge по user_id:
# user_id=1: 3 строки x 2 строки = 6 строк в результате!
# user_id=2: 2 строки x 1 строка = 2 строки в результате
# Итого: 6 + 2 + 3 = 11 строк вместо 6+6=12 ожидаемых

result = pd.merge(df1, df2, on='user_id', how='inner')
print(f"Исходные строки: {len(df1)} + {len(df2)} = {len(df1) + len(df2)}")
print(f"Строк в результате: {len(result)}")  # 11, а не 12!

# Решение: убедись, что ключ уникален или используй правильный тип join

Причина 2: Типы данных неоптимальны

# Плохо: объекты занимают много памяти
df = pd.DataFrame({
    'id': ['1', '2', '3'] * 1000000,  # Строки вместо int!
    'value': [1.0, 2.0, 3.0] * 1000000,
})

print(df.memory_usage(deep=True))
# id: много памяти (объекты)

# Хорошо: оптимальные типы
df['id'] = df['id'].astype('int32')
df['value'] = df['value'].astype('float32')

print(df.memory_usage(deep=True))
# Памяти в 4 раза меньше!

Причина 3: Дубликаты и NULL значения

# Проверяем на дубликаты перед merge
print(f"Дубликаты в df1 по ключу: {df1[df1.duplicated(subset=['key'], keep=False)].shape[0]}")
print(f"Дубликаты в df2 по ключу: {df2[df2.duplicated(subset=['key'], keep=False)].shape[0]}")

# Проверяем на NULL
print(f"NULL значений в df1['key']: {df1['key'].isna().sum()}")
print(f"NULL значений в df2['key']: {df2['key'].isna().sum()}")

# Если много NULL, они создают дополнительные пары
# Решение: удалить NULL перед merge
df1_clean = df1[df1['key'].notna()]
df2_clean = df2[df2['key'].notna()]

Причина 4: Больший объём памяти нужен на промежуточные результаты

# pandas merge требует дополнительной памяти для:
# 1. Сортировки
# 2. Создания индексов хеша
# 3. Временных буферов

# Решение 1: Используй дополнительный параметр
result = pd.merge(df1, df2, on='key', how='inner', sort=False)
# sort=False экономит память

# Решение 2: Выполняй merge в несколько шагов
# Вместо: result = df1.merge(df2).merge(df3).merge(df4)
# Делай:
temp = df1.merge(df2)
del df1, df2  # Освобождаем память
temp2 = temp.merge(df3)
del temp, df3  # Освобождаем память
result = temp2.merge(df4)
del temp2, df4

Проверка и диагностика

import psutil
import gc

def check_memory():
    """Проверяем использование памяти"""
    process = psutil.Process()
    mem_info = process.memory_info()
    print(f"Текущая память: {mem_info.rss / 1024**3:.2f} GB")
    print(f"Доступная память: {psutil.virtual_memory().available / 1024**3:.2f} GB")

# Перед merge
check_memory()

# Выполняем merge
result = pd.merge(df1, df2, on='key')

# После merge
check_memory()

# Проверяем размер результата
print(f"Размер результата: {result.memory_usage(deep=True).sum() / 1024**3:.2f} GB")

Стратегия решения

def safe_merge(df1, df2, on='key', how='inner', max_memory_gb=8):
    """Безопасный merge с контролем памяти"""
    
    # Шаг 1: Оценка памяти
    df1_mem = df1.memory_usage(deep=True).sum() / 1024**3
    df2_mem = df2.memory_usage(deep=True).sum() / 1024**3
    estimated_result = df1_mem + df2_mem + (df1_mem + df2_mem) * 0.5  # Примерно 50% оверхед
    
    print(f"Оценка памяти: {estimated_result:.2f} GB")
    
    if estimated_result > max_memory_gb:
        print(f"ОШИБКА: Недостаточно памяти! Требуется {estimated_result:.2f} GB, доступно {max_memory_gb:.2f} GB")
        
        # Решение 1: Уменьшить df
        print("Решение: удалить ненужные колонки")
        df1 = df1[['key', 'important_col1']]
        df2 = df2[['key', 'important_col2']]
        
        # Решение 2: Оптимизировать типы
        for col in df1.select_dtypes(include=['object']).columns:
            df1[col] = df1[col].astype('category')
        
        return pd.merge(df1, df2, on=on, how=how, sort=False)
    
    return pd.merge(df1, df2, on=on, how=how, sort=False)

# Использование
result = safe_merge(df1, df2, max_memory_gb=4)

Практическое решение с Dask

import dask.dataframe as dd

# Для больших данных используй Dask (работает с диском, не памятью)
df1_dask = dd.read_csv('table1.csv')
df2_dask = dd.read_csv('table2.csv')

# Merge в Dask не требует всё загружать в память
result_dask = dd.merge(df1_dask, df2_dask, on='key', how='inner')

# Вычисляем только нужные части
result = result_dask.compute()  # Вычисляем только результат

Чек-лист для диагностики

1. Размеры таблиц — проверить memory_usage(), оценить худший случай
2. Типы данных — заменить object на category, int32/float32
3. Дубликаты и NULL — проверить уникальность ключей
4. Параметры merge — использовать sort=False, правильный how
5. Освобождение памяти — удалять промежуточные таблицы
6. Большие данные — рассмотреть Dask для очень больших таблиц