Optimizacija zmogljivosti Pandas: Obvladovanje zmanjšanja porabe pomnilnika

Pandas je zmogljiva knjižnica Python za analizo podatkov, ki ponuja prilagodljive podatkovne strukture in orodja za analizo podatkov. Vendar pa lahko pri delu z velikimi podatkovnimi nizi poraba pomnilnika postane pomembna ovira, ki vpliva na zmogljivost in lahko celo povzroči sesutje vaših programov. Ta celovit vodnik raziskuje različne tehnike za optimizacijo porabe pomnilnika v Pandas, kar vam omogoča učinkovitejše in uspešnejše obdelovanje večjih podatkovnih nizov.

Razumevanje porabe pomnilnika v Pandas

Preden se poglobite v tehnike optimizacije, je ključnega pomena razumeti, kako Pandas shranjuje podatke v pomnilniku. Pandas predvsem uporablja polja NumPy za shranjevanje podatkov znotraj DataFrames in Series. Podatkovni tip vsakega stolpca pomembno vpliva na porabo pomnilnika. Na primer, stolpec `int64` bo porabil dvakrat več pomnilnika kot stolpec `int32`.

Porabo pomnilnika DataFrame lahko preverite z metodo .memory_usage():

            import pandas as pd

data = {
    'col1': [1, 2, 3, 4, 5],
    'col2': ['A', 'B', 'C', 'D', 'E'],
    'col3': [1.1, 2.2, 3.3, 4.4, 5.5]
}

df = pd.DataFrame(data)

memory_usage = df.memory_usage(deep=True)
print(memory_usage)

            

              
                Copy
              
            
          

Argument deep=True je bistvenega pomena za natančen izračun porabe pomnilnika stolpcev objektov (nizov).

Tehnike za zmanjšanje porabe pomnilnika

1. Izbira pravih podatkovnih tipov

Izbira ustreznega podatkovnega tipa za vsak stolpec je najpomembnejši korak pri zmanjšanju porabe pomnilnika. Pandas samodejno sklepa podatkovne tipe, vendar pogosto privzeto uporablja podatkovne tipe, ki porabijo več pomnilnika, kot je potrebno. Na primer, stolpcu, ki vsebuje cela števila med 0 in 100, se lahko dodeli tip `int64`, čeprav bi zadostovala `int8` ali `uint8`.

Primer: Zmanjšanje numeričnih tipov (Downcasting)

Numerične tipe lahko zmanjšate na manjše predstavitve z uporabo funkcije pd.to_numeric() s parametrom downcast:

            def reduce_mem_usage(df):
    """Iterate through all the columns of a dataframe and modify the data type
        to reduce memory usage.        
    """
    start_mem = df.memory_usage().sum() / 1024**2
    print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))
    
    for col in df.columns:
        if df[col].dtype == 'object':
            continue # Skip strings, handle them separately

        col_type = df[col].dtype
        
        if col_type in ['int64','int32','int16']:
            c_min = df[col].min()
            c_max = df[col].max()
            if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
                df[col] = df[col].astype(np.int8)
            elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
                df[col] = df[col].astype(np.int16)
            elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
                df[col] = df[col].astype(np.int32)
            else:
                df[col] = df[col].astype(np.int64)
        elif col_type in ['float64','float32']:
            c_min = df[col].min()
            c_max = df[col].max()
            if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:
                df[col] = df[col].astype(np.float16)
            elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
                df[col] = df[col].astype(np.float32)
            else:
                df[col] = df[col].astype(np.float64)

    end_mem = df.memory_usage().sum() / 1024**2
    print('Memory usage after optimization is: {:.2f} MB'.format(end_mem))
    print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem))
    
    return df

            

              
                Copy
              
            
          

Primer: Pretvorba nizov v kategorične tipe

Če stolpec vsebuje omejeno število edinstvenih vrednosti nizov, lahko pretvorba v kategorični tip bistveno zmanjša porabo pomnilnika. Kategorični tipi shranijo edinstvene vrednosti samo enkrat in vsak element v stolpcu predstavijo kot celoštevilsko kodo, ki se sklicuje na edinstvene vrednosti.

            df['col2'] = df['col2'].astype('category')

            

              
                Copy
              
            
          

Razmislite o naboru podatkov o transakcijah strank za globalno platformo e-trgovine. Stolpec 'Država' (Country) lahko vsebuje le nekaj sto edinstvenih imen držav, medtem ko nabor podatkov vsebuje milijone transakcij. Pretvorba stolpca 'Država' (Country) v kategorični tip bi drastično zmanjšala porabo pomnilnika.

2. Razdeljevanje in iteracija (Chunking and Iteration)

Pri delu z izjemno velikimi podatkovnimi nizi, ki se ne morejo prilegati v pomnilnik, lahko podatke obdelujete v kosih (chunks) z uporabo parametra chunksize v pd.read_csv() ali pd.read_excel(). To vam omogoča nalaganje in obdelavo podatkov v manjših, obvladljivih delih.

            for chunk in pd.read_csv('large_dataset.csv', chunksize=100000):
    # Process the chunk (e.g., perform calculations, filtering, aggregation)
    print(f"Processing chunk with {len(chunk)} rows")
    # Optionally, append results to a file or database.

            

              
                Copy
              
            
          

Primer: Obdelava velikih datotek dnevnikov (Log Files)

Predstavljajte si obdelavo ogromne datoteke dnevnikov iz globalne omrežne infrastrukture. Datoteka dnevnikov je prevelika, da bi se prilegala v pomnilnik. Z uporabo razdeljevanja (chunking) lahko iterirate skozi datoteko dnevnikov, analizirate vsak kos za specifične dogodke ali vzorce in združite rezultate, ne da bi presegli omejitve pomnilnika.

3. Izbira samo potrebnih stolpcev

Pogosto podatkovni nizi vsebujejo stolpce, ki niso pomembni za vašo analizo. Nalaganje samo potrebnih stolpcev lahko bistveno zmanjša porabo pomnilnika. Želene stolpce lahko določite z uporabo parametra usecols v pd.read_csv().

            df = pd.read_csv('large_dataset.csv', usecols=['col1', 'col2', 'col3'])

            

              
                Copy
              
            
          

Primer: Analiza prodajnih podatkov

Če analizirate prodajne podatke za identifikacijo najbolje prodajanih izdelkov, boste morda potrebovali le stolpce 'ID izdelka' (Product ID), 'Prodana količina' (Sales Quantity) in 'Prihodek od prodaje' (Sales Revenue). Nalaganje samo teh stolpcev bo zmanjšalo porabo pomnilnika v primerjavi z nalaganjem celotnega podatkovnega niza, ki bi lahko vključeval demografske podatke strank, naslove za dostavo in druge nepomembne informacije.

4. Uporaba redkih podatkovnih struktur (Sparse Data Structures)

Če vaš DataFrame vsebuje veliko manjkajočih vrednosti (NaNs) ali ničel, lahko uporabite redke podatkovne strukture za učinkovitejšo predstavitev podatkov. Redki DataFrames shranjujejo samo ne-manjkajoče ali ne-ničelne vrednosti, kar bistveno zmanjša porabo pomnilnika pri delu z redkimi podatki.

            sparse_series = df['col1'].astype('Sparse[float]')
sparse_df = sparse_series.to_frame()

            

              
                Copy
              
            
          

Primer: Analiza ocen strank

Razmislite o naboru podatkov o ocenah strank za veliko število izdelkov. Večina strank bo ocenila le majhen del izdelkov, kar bo povzročilo redko matriko ocen. Uporaba redkega DataFrame za shranjevanje teh podatkov bo bistveno zmanjšala porabo pomnilnika v primerjavi z gostim DataFrame.

5. Izogibanje kopiranju podatkov

Operacije Pandas lahko včasih ustvarijo kopije DataFrames, kar vodi do povečane porabe pomnilnika. Spreminjanje DataFramea na mestu (kadar je to mogoče) lahko pomaga preprečiti nepotrebno kopiranje.

Na primer, namesto:

            df = df[df['col1'] > 10]

            

              
                Copy
              
            
          

Razmislite o uporabi:

            df.drop(df[df['col1'] <= 10].index, inplace=True)

            

              
                Copy
              
            
          

Argument `inplace=True` spremeni DataFrame neposredno, ne da bi ustvaril kopijo.

6. Optimizacija shranjevanja nizov

Stolpci z nizi lahko porabijo veliko pomnilnika, še posebej, če vsebujejo dolge nize ali veliko edinstvenih vrednosti. Pretvorba nizov v kategorične tipe, kot je bilo omenjeno prej, je ena izmed učinkovitih tehnik. Drug pristop je uporaba manjših predstavitev nizov, če je to mogoče.

Primer: Zmanjšanje dolžine niza

Če stolpec vsebuje identifikatorje, ki so shranjeni kot nizi, vendar bi jih bilo mogoče predstaviti kot cela števila, lahko pretvorba v cela števila prihrani pomnilnik. Na primer, ID-je izdelkov, ki so trenutno shranjeni kot nizi, kot so "PROD-1234", bi bilo mogoče preslikati v celoštevilske ID-je.

7. Uporaba Daska za podatkovne nize, večje od pomnilnika

Za podatkovne nize, ki so resnično preveliki, da bi se prilegali v pomnilnik, celo z razdeljevanjem (chunking), razmislite o uporabi Daska. Dask je knjižnica za vzporedno računanje, ki se dobro integrira s Pandas in NumPy. Omogoča vam delo z večjimi podatkovnimi nizi, kot je pomnilnik, tako da jih razdeli na manjše dele in jih obdeluje vzporedno na več jedrih ali celo na več strojih.

            import dask.dataframe as dd

ddf = dd.read_csv('large_dataset.csv')

# Perform operations on the Dask DataFrame (e.g., filtering, aggregation)
result = ddf[ddf['col1'] > 10].groupby('col2').mean().compute()

            

              
                Copy
              
            
          

Metoda compute() sproži dejansko računanje in vrne Pandas DataFrame, ki vsebuje rezultate.

Najboljše prakse in premisleki

• Profilirajte svojo kodo: Uporabite orodja za profiliranje, da prepoznate ozka grla v pomnilniku in usmerite svoja optimizacijska prizadevanja na področja z največjim vplivom.
• Preizkusite različne tehnike: Optimalna tehnika za zmanjšanje pomnilnika je odvisna od specifičnih značilnosti vašega podatkovnega niza. Eksperimentirajte z različnimi pristopi, da najdete najboljšo rešitev za vaš primer uporabe.
• Spremljajte porabo pomnilnika: Spremljajte porabo pomnilnika med obdelavo podatkov, da zagotovite učinkovitost vaših optimizacij in preprečite napake zaradi pomanjkanja pomnilnika.
• Razumeti svoje podatke: Poglobljeno razumevanje vaših podatkov je ključnega pomena za izbiro najustreznejših podatkovnih tipov in optimizacijskih tehnik.
• Upoštevajte kompromise: Nekatere tehnike optimizacije pomnilnika lahko povzročijo rahle stroške zmogljivosti. Ocenite koristi zmanjšane porabe pomnilnika v primerjavi z morebitnim vplivom na zmogljivost.
• Dokumentirajte svoje optimizacije: Jasno dokumentirajte tehnike optimizacije pomnilnika, ki ste jih implementirali, da zagotovite vzdržljivost in razumljivost vaše kode drugim.

Zaključek

Optimizacija porabe pomnilnika v Pandas je bistvena za učinkovito in uspešno delo z velikimi podatkovnimi nizi. Z razumevanjem, kako Pandas shranjuje podatke, izbiro pravih podatkovnih tipov, uporabo razdeljevanja (chunking) in uporabo drugih optimizacijskih tehnik, lahko bistveno zmanjšate porabo pomnilnika in izboljšate zmogljivost vaših delovnih tokov analize podatkov. Ta vodnik je ponudil celovit pregled ključnih tehnik in najboljših praks za obvladovanje zmanjšanja porabe pomnilnika v Pandas. Ne pozabite profilirati svoje kode, preizkusiti različne tehnike in spremljati porabo pomnilnika, da dosežete najboljše rezultate za vaš specifični primer uporabe. Z uporabo teh načel lahko izkoristite ves potencial Pandas in se spopadete tudi z najzahtevnejšimi izzivi analize podatkov.

Z obvladovanjem teh tehnik lahko podatkovni znanstveniki in analitiki po vsem svetu obdelujejo večje podatkovne nize, izboljšajo hitrosti obdelave in pridobijo globlje vpoglede iz svojih podatkov. To prispeva k učinkovitejšim raziskavam, bolje informiranim poslovnim odločitvam in končno k svetu, ki ga bolj poganjajo podatki.