Natuurlijk! Hier is een stapsgewijze aanpak om het geheugenverbruik van je Pandas DataFrame te analyseren en te optimaliseren, inclusief Python-codevoorbeelden en uitleg van de technieken. --- ### 1. Analyse van het geheugenverbruik Gebruik `memory_usage()` om de huidige geheugenconsumptie te bekijken: ```python import pandas as pd # Bijvoorbeeld je DataFrame heet df print(df.info(memory_usage='deep')) ``` Of: ```python print(df.memory_usage(deep=True).sum() / 1024**2, "MB") ``` Dit geeft je een overzicht van hoeveel geheugen elke kolom gebruikt. --- ### 2. Optimalisatietechnieken #### a. Downcasten van numerieke types Door numerieke kolommen naar een efficiëntere datatype te converteren, kunnen we veel geheugen besparen. **Voorbeeld:** ```python # Voor integers df['Aantal'] = pd.to_numeric(df['Aantal'], downcast='unsigned') # of 'signed' afhankelijk van de data # Bijvoorbeeld, als waarden altijd positief zijn # Als je niet zeker bent, gebruik 'signed' # Voor float df['Prijs'] = pd.to_numeric(df['Prijs'], downcast='float') ``` **Afweging:** - Downcasten vermindert de geheugenbehoefte, maar je moet controleren of de datatypes nog passen bij je data. - Bijvoorbeeld, een `int64` kan worden omgezet naar `int8`, `int16`, of `int32`, afhankelijk van de waarde-range. #### b. Gebruik van categorische datatype voor objectkolommen Voor kolommen met relatief weinig unieke waarden is het gebruik van `category` zeer efficiënt. **Voorbeeld:** ```python # Product kolom df['Product'] = df['Product'].astype('category') ``` **Voordelen:** - Vermindert het geheugenverbruik aanzienlijk. - Versnelt bewerkingen zoals filtering en grouping. **Overweging:** - Als de kolom veel unieke waarden heeft, heeft het gebruik van 'category' minder effect. - Ideaal voor kolommen met herhaalde teksten zoals productnamen, regio’s, etc. #### c. Optimaliseren van datetime-kolommen Datetime-kolommen worden vaak al efficiënt opgeslagen, maar je kunt controleren of ze correct zijn en optimaal gebruikt worden. ```python # Controle of OrderDatum al datetime64 is print(df['OrderDatum'].dtype) ``` Indien niet, converteer: ```python df['OrderDatum'] = pd.to_datetime(df['OrderDatum'], errors='coerce') ``` --- ### 3. Voorbeeldsamenvatting Hier is een volledige voorbeeldcode die alle bovenstaande technieken combineert: ```python import pandas as pd # Laad je DataFrame hier (bijvoorbeeld: df = pd.read_csv('data.csv')) # 1. Analyseer geheugenverbruik print(df.info(memory_usage='deep')) # 2. Downcast numerieke kolommen df['Aantal'] = pd.to_numeric(df['Aantal'], downcast='unsigned') df['Prijs'] = pd.to_numeric(df['Prijs'], downcast='float') # 3. Converteer object kolommen met weinig unieke waarden naar categorical for col in ['Product']: # Voeg andere kolommen toe indien relevant if df[col].nunique() / len(df) < 0.5: # Bijvoorbeeld, als minder dan 50% uniek df[col] = df[col].astype('category') # 4. Controleer en converteer datumkolom if df['OrderDatum'].dtype != 'datetime64[ns]': df['OrderDatum'] = pd.to_datetime(df['OrderDatum'], errors='coerce') # 5. Controleer het nieuwe geheugenverbruik print(df.info(memory_usage='deep')) ``` --- ### 4. Samenvatting en afwegingen | Techniek | Voordelen | Nadelen / Overwegingen | |---|---|---| | Downcasten numeriek | Verkleint geheugen, snel | Mogelijk verlies van precisie of bereik als niet zorgvuldig toegepast | | Categorische datatype | Zeer efficiënt voor herhaalde tekstwaarden | Minder geschikt bij veel unieke waarden, kan overhead toevoegen bij zeldzame waarden | | Optimaliseren datetime | Efficiënt gebruik, geen grote impact | Zorgen dat kolom al in datetime-formaat is | Door deze technieken te combineren, kun je het geheugenverbruik van je DataFrame aanzienlijk verminderen zonder dat je veel functionaliteit verliest. --- Mocht je nog verdere vragen hebben of hulp nodig met je specifieke dataset, laat het gerust weten!

Zeker, ik help je graag met het analyseren en optimaliseren van het geheugenverbruik van je Pandas DataFrame. Hier is een stapsgewijze aanpak: ### 1. Eerst geheugenverbruik analyseren ```python import pandas as pd import numpy as np # Toon huidig geheugenverbruik print("Huidig geheugenverbruik:") print(df.info(memory_usage='deep')) print(f"\nTotaal geheugen: {df.memory_usage(deep=True).sum() / 1024**2:.2f} MB") # Gedetailleerde analyse per kolom print("\nGedetailleerd geheugenverbruik per kolom:") for col in df.columns: print(f"{col}: {df[col].memory_usage(deep=True) / 1024**2:.2f} MB") ``` ### 2. Optimalisatietechnieken met codevoorbeelden #### A. Downcasten van numerieke types ```python def optimize_numeric_columns(df): """Optimaliseer numerieke kolommen door downcasting""" # Integer kolommen int_cols = df.select_dtypes(include=['int64']).columns for col in int_cols: df[col] = pd.to_numeric(df[col], downcast='integer') # Float kolommen float_cols = df.select_dtypes(include=['float64']).columns for col in float_cols: df[col] = pd.to_numeric(df[col], downcast='float') return df # Pas toe df = optimize_numeric_columns(df) ``` **Afweging**: Minimal geheugenverlies, behoudt numerieke precisie binnen redelijke grenzen. #### B. Categorische datatypes voor objectkolommen ```python def optimize_object_columns(df, threshold=0.5): """Converteer objectkolommen naar categorical waar mogelijk""" object_cols = df.select_dtypes(include=['object']).columns for col in object_cols: # Alleen converteren als aantal unieke waarden < threshold * totale rijen unique_ratio = len(df[col].unique()) / len(df) if unique_ratio < threshold: df[col] = df[col].astype('category') print(f"Geconverteerd {col} naar categorical (unique ratio: {unique_ratio:.3f})") return df # Pas toe met threshold van 50% (aangepast aan jouw 50 unieke producten) df = optimize_object_columns(df, threshold=0.5) ``` **Afweging**: Grote geheugenbesparing bij lage cardinaliteit, maar beperkte sorteer-/filteroperaties. #### C. Datumoptimalisatie ```python def optimize_datetime_columns(df): """Optimaliseer datetime kolommen""" datetime_cols = df.select_dtypes(include=['datetime64']).columns for col in datetime_cols: # Downcast naar de kleinste geschikte datetime resolutie if df[col].dt.time.nunique() == 1: # Alleen datum, geen tijd df[col] = df[col].astype('datetime64[D]') # Dag precisie else: # Minimaliseer naar de kleinste noodzakelijke precisie df[col] = df[col].astype('datetime64[s]') # Seconde precisie return df # Pas toe df = optimize_datetime_columns(df) ``` **Afweging**: Behoudt volledige functionaliteit met minder geheugen. ### 3. Complete optimalisatiefunctie ```python def optimize_dataframe_memory(df): """Complete geheugenoptimalisatie voor DataFrame""" original_memory = df.memory_usage(deep=True).sum() / 1024**2 # Pas alle optimalisaties toe df = optimize_numeric_columns(df) df = optimize_object_columns(df) df = optimize_datetime_columns(df) new_memory = df.memory_usage(deep=True).sum() / 1024**2 reduction = ((original_memory - new_memory) / original_memory) * 100 print(f"Geheugenbesparing: {reduction:.1f}%") print(f"Origineel: {original_memory:.2f} MB -> Nieuw: {new_memory:.2f} MB") return df # Voer complete optimalisatie uit df_optimized = optimize_dataframe_memory(df) ``` ### 4. Geheugentracking functie ```python def track_memory_reduction(original_df, optimized_df): """Track geheugenreductie per kolom""" print("Geheugenreductie per kolom:") for col in original_df.columns: orig = original_df[col].memory_usage(deep=True) / 1024 opt = optimized_df[col].memory_usage(deep=True) / 1024 reduction = ((orig - opt) / orig) * 100 if orig > 0 else 0 print(f"{col}: {orig:.1f} KB -> {opt:.1f} KB ({reduction:.1f}%)") # Vergelijk voor en na track_memory_reduction(df, df_optimized) ``` ### Belangrijke afwegingen: 1. **Categorical types**: Perfect voor Product-kolom (50 unieke waarden), maar beperkt in string-operaties 2. **Numeriek downcasten**: Verliest minimale precisie, grote geheugenwinst 3. **Datetime optimalisatie**: Kies de juiste precisie voor je use-case 4. **Leesbaarheid vs prestaties**: Optimalisaties kunnen code complexer maken ### Aanbevolen volgorde: 1. Analyseer eerst het huidige verbruik 2. Optimaliseer numerieke kolommen 3. Converteer geschikte objectkolommen naar categorical 4. Optimaliseer datetime kolommen 5. Meet resultaten en pas indien nodig aan Deze aanpak zou aanzienlijke geheugenbesparingen moeten opleveren, vooral voor je Product-kolom met 50 unieke waarden!