Pandas DataFramen optimointi: Muistinkäyttö ja suorituskyvyn viritys

Pandas on tehokas Python-kirjasto datan manipulointiin ja analysointiin. Suuria aineistoja käsiteltäessä Pandas DataFramet voivat kuitenkin viedä merkittävästi muistia ja toimia hitaasti. Tämä artikkeli tarjoaa kattavan oppaan Pandas DataFrame -rakenteiden optimointiin sekä muistinkäytön että suorituskyvyn osalta, jotta voit käsitellä suurempia aineistoja tehokkaammin.

Pandas DataFrame -rakenteiden muistinkäytön ymmärtäminen

Ennen optimointitekniikoihin syventymistä on tärkeää ymmärtää, miten Pandas DataFramet tallentavat tietoa muistiin. Jokaisella DataFramen sarakkeella on tietty tietotyyppi, joka määrittää sen arvojen tallentamiseen tarvittavan muistin määrän. Yleisimpiä tietotyyppejä ovat:

• int64: 64-bittiset kokonaisluvut (oletus kokonaisluvuille)
• float64: 64-bittiset liukuluvut (oletus liukuluvuille)
• object: Python-oliot (käytetään merkkijonoille ja sekatyypeille)
• category: Kategorinen data (tehokas toistuville arvoille)
• bool: Boolen arvot (True/False)
• datetime64: Päivämäärä- ja aika-arvot

object-tietotyyppi on usein muisti-intensiivisin, koska se tallentaa osoittimia Python-olioihin, jotka voivat olla huomattavasti suurempia kuin primitiiviset tietotyypit, kuten kokonaisluvut tai liukuluvut. Merkkijonot, jopa lyhyet, kuluttavat object-tyyppinä tallennettuina paljon enemmän muistia kuin on tarpeen. Samoin int64-tyypin käyttö, kun int32 riittäisi, tuhlaa muistia.

Esimerkki: DataFramen muistinkäytön tarkastelu

Voit käyttää memory_usage()-metodia DataFramen muistinkäytön tarkasteluun:

            import pandas as pd
import numpy as np

data = {
    'col1': np.random.randint(0, 1000, 100000),
    'col2': np.random.rand(100000),
    'col3': ['A', 'B', 'C'] * (100000 // 3 + 1)[:100000],
    'col4': ['This is a long string'] * 100000
}

df = pd.DataFrame(data)

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

            

              
                Copy
              
            
          

deep=True-argumentti varmistaa, että olioiden (kuten merkkijonojen) muistinkäyttö lasketaan tarkasti. Ilman deep=True-argumenttia se laskee vain osoittimien muistin, ei niiden viittaaman datan.

Tietotyyppien optimointi

Yksi tehokkaimmista tavoista vähentää muistinkäyttöä on valita DataFrame-sarakkeillesi sopivimmat tietotyypit. Tässä on joitakin yleisiä tekniikoita:

1. Numeeristen tietotyyppien pienentäminen (downcasting)

Jos kokonaisluku- tai liukulukusarakkeesi eivät vaadi täyttä 64-bittistä tarkkuutta, voit pienentää ne pienempiin tietotyyppeihin, kuten int32, int16, float32 tai float16. Tämä voi vähentää muistinkäyttöä merkittävästi, erityisesti suurissa aineistoissa.

Esimerkki: Kuvitellaan sarake, joka edustaa ikää, joka tuskin ylittää 120. Tämän tallentaminen int64-tyyppinä on tuhlausta; int8 (arvoalue -128 ... 127) olisi sopivampi.

            def downcast_numeric(df):
    """Pienentää numeeriset sarakkeet pienimpään mahdolliseen tietotyyppiin."""
    for col in df.columns:
        if pd.api.types.is_integer_dtype(df[col]):
            df[col] = pd.to_numeric(df[col], downcast='integer')
        elif pd.api.types.is_float_dtype(df[col]):
            df[col] = pd.to_numeric(df[col], downcast='float')
    return df

df = downcast_numeric(df.copy())
print(df.memory_usage(deep=True))
print(df.dtypes)

            

              
                Copy
              
            
          

pd.to_numeric()-funktio downcast-argumentilla valitsee automaattisesti pienimmän mahdollisen tietotyypin, joka voi edustaa sarakkeen arvoja. copy() estää alkuperäisen DataFramen muokkaamisen. Tarkista aina datasi arvoalue ennen pienentämistä varmistaaksesi, ettet menetä tietoa.

2. Kategoristen tietotyyppien käyttö

Jos sarake sisältää rajallisen määrän uniikkeja arvoja, voit muuntaa sen category-tietotyyppiin. Kategoriset tietotyypit tallentavat jokaisen uniikin arvon vain kerran ja käyttävät sitten kokonaislukukoodeja edustamaan sarakkeen arvoja. Tämä voi vähentää merkittävästi muistinkäyttöä, erityisesti sarakkeissa, joissa on paljon toistuvia arvoja.

Esimerkki: Kuvitellaan sarake, joka edustaa maakoodia. Jos käsittelet rajallista joukkoa maita (esim. vain Euroopan unionin maita), tämän tallentaminen kategoriana on paljon tehokkaampaa kuin merkkijonoina.

            def optimize_categories(df):
    """Muuntaa object-sarakkeet, joilla on matala kardinaliteetti, kategoriseen tyyppiin."""
    for col in df.columns:
        if df[col].dtype == 'object':
            num_unique_values = len(df[col].unique())
            num_total_values = len(df[col])
            if num_unique_values / num_total_values < 0.5:
                df[col] = df[col].astype('category')
    return df

df = optimize_categories(df.copy())
print(df.memory_usage(deep=True))
print(df.dtypes)

            

              
                Copy
              
            
          

Tämä koodi tarkistaa, onko uniikkien arvojen määrä object-sarakkeessa alle 50 % kokonaisarvojen määrästä. Jos on, se muuntaa sarakkeen kategoriseen tietotyyppiin. 50 %:n kynnys on mielivaltainen ja sitä voidaan säätää datasi erityispiirteiden mukaan. Tämä lähestymistapa on hyödyllisin, kun sarake sisältää paljon toistuvia arvoja.

3. Object-tietotyypin välttäminen merkkijonoille

Kuten aiemmin mainittiin, object-tietotyyppi on usein muisti-intensiivisin, erityisesti kun sitä käytetään merkkijonojen tallentamiseen. Yritä mahdollisuuksien mukaan välttää object-tietotyyppien käyttöä merkkijonosarakkeille. Kategoriset tyypit ovat suositeltavia merkkijonoille, joilla on matala kardinaliteetti. Jos kardinaliteetti on korkea, harkitse, voidaanko merkkijonot esittää numeerisilla koodeilla tai voidaanko merkkijonodata välttää kokonaan.

Jos sinun on suoritettava merkkijono-operaatioita sarakkeelle, saatat joutua pitämään sen object-tyyppisenä, mutta harkitse, voidaanko nämä operaatiot suorittaa etukäteen ja muuntaa sarake sen jälkeen tehokkaampaan tyyppiin.

4. Päivämäärä- ja aikadata

Käytä datetime64-tietotyyppiä päivämäärä- ja aikatiedoille. Varmista, että resoluutio on sopiva (nanosekunnin resoluutio voi olla tarpeeton). Pandas käsittelee aikasarjadataa erittäin tehokkaasti.

DataFrame-operaatioiden optimointi

Tietotyyppien optimoinnin lisäksi voit myös parantaa Pandas DataFrame -rakenteiden suorituskykyä optimoimalla niillä suoritettavia operaatioita. Tässä on joitakin yleisiä tekniikoita:

1. Vektorointi

Vektorointi on prosessi, jossa operaatioita suoritetaan kokonaisille taulukoille tai sarakkeille kerralla yksittäisten elementtien yli iteroinnin sijaan. Pandas on pitkälle optimoitu vektoroiduille operaatioille, joten niiden käyttö voi merkittävästi parantaa suorituskykyä. Vältä eksplisiittisiä silmukoita aina kun mahdollista. Pandasin sisäänrakennetut funktiot ovat yleensä paljon nopeampia kuin vastaavat Python-silmukat.

Esimerkki: Sen sijaan, että iteroisit sarakkeen läpi laskeaksesi jokaisen arvon neliön, käytä potenssioperaattoria:

            # Tehoton (käyttäen silmukkaa)
import time

start_time = time.time()
results = []
for value in df['col2']:
    results.append(value ** 2)
df['col2_squared_loop'] = results
end_time = time.time()
print(f"Silmukan aika: {end_time - start_time:.4f} sekuntia")

# Tehokas (käyttäen vektorointia)
start_time = time.time()
df['col2_squared_vectorized'] = df['col2'] ** 2
end_time = time.time()
print(f"Vektoroinnin aika: {end_time - start_time:.4f} sekuntia")


            

              
                Copy
              
            
          

Vektoroitu lähestymistapa on tyypillisesti kertaluokkia nopeampi kuin silmukkapohjainen lähestymistapa.

2. `apply()`-metodin varovainen käyttö

apply()-metodin avulla voit soveltaa funktiota DataFramen jokaiseen riviin tai sarakkeeseen. Se on kuitenkin yleensä hitaampi kuin vektoroidut operaatiot, koska se kutsuu Python-funktiota jokaiselle elementille. Käytä apply()-metodia vain, kun vektoroidut operaatiot eivät ole mahdollisia.

Jos sinun on käytettävä apply()-metodia, yritä vektoroida soveltamasi funktio mahdollisimman paljon. Harkitse Numban jit-dekoraattorin käyttöä funktion kääntämiseksi konekielelle merkittävien suorituskykyparannusten saavuttamiseksi.

            from numba import jit

@jit(nopython=True)
def my_function(x):
    return x * 2  # Esimerkkifunktio

df['col2_applied'] = df['col2'].apply(my_function)

            

              
                Copy
              
            
          

3. Sarakkeiden tehokas valinta

Kun valitset osajoukkoa sarakkeista DataFrame-rakenteesta, käytä seuraavia menetelmiä optimaalisen suorituskyvyn saavuttamiseksi:

• Suora sarakkeen valinta: df[['col1', 'col2']] (nopein muutaman sarakkeen valintaan)
• Boolen indeksointi: df.loc[:, [True if col.startswith('col') else False for col in df.columns]] (hyödyllinen sarakkeiden valintaan ehdon perusteella)

Vältä df.filter()-metodin käyttöä säännöllisillä lausekkeilla sarakkeiden valintaan, sillä se voi olla hitaampi kuin muut menetelmät.

4. Yhdistämisten (Joins) ja liitosten (Merges) optimointi

DataFrame-rakenteiden yhdistäminen ja liittäminen voi olla laskennallisesti kallista, erityisesti suurilla aineistoilla. Tässä on muutamia vinkkejä yhdistämisten ja liitosten optimointiin:

• Käytä sopivia yhdistämisavaimia: Varmista, että yhdistämisavaimilla on sama tietotyyppi ja että ne on indeksoitu.
• Määritä liitostyyppi: Käytä vaatimustesi mukaista liitostyyppiä (esim. inner, left, right, outer). Inner join on yleensä nopeampi kuin outer join.
• Käytä merge()-funktiota join()-metodin sijaan: merge()-funktio on monipuolisempi ja usein nopeampi kuin join()-metodi.

Esimerkki:

            df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'value1': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'], 'value2': [5, 6, 7, 8]})

# Tehokas inner-liitos
df_merged = pd.merge(df1, df2, on='key', how='inner')

print(df_merged)

            

              
                Copy
              
            
          

5. DataFrame-rakenteiden tarpeettoman kopioinnin välttäminen

Monet Pandas-operaatiot luovat kopioita DataFrame-rakenteista, mikä voi olla muisti-intensiivistä ja aikaa vievää. Välttääksesi tarpeetonta kopiointia, käytä inplace=True-argumenttia, kun se on saatavilla, tai sijoita operaation tulos takaisin alkuperäiseen DataFrameen. Ole erittäin varovainen inplace=True-argumentin kanssa, koska se voi peittää virheitä ja vaikeuttaa virheenkorjausta. On usein turvallisempaa sijoittaa tulos uudelleen, vaikka se olisi hieman hitaampaa.

Esimerkki:

            # Tehoton (luo kopion)
df_filtered = df[df['col1'] > 500]

# Tehokas (muokkaa alkuperäistä DataFramea paikallaan - VAROITUS)
df.drop(df[df['col1'] <= 500].index, inplace=True)

#TURVALLISEMPI - sijoittaa uudelleen, välttää inplace-käyttöä
df = df[df['col1'] > 500]

            

              
                Copy
              
            
          

6. Paloittelu ja iterointi

Erittäin suurille aineistoille, jotka eivät mahdu muistiin, harkitse datan käsittelyä paloissa (chunks). Käytä chunksize-parametria lukiessasi dataa tiedostoista. Iteroi palojen läpi ja suorita analyysi kullekin palalle erikseen. Tämä vaatii huolellista suunnittelua varmistaakseen, että analyysi pysyy oikeana, koska jotkut operaatiot vaativat koko aineiston käsittelyä kerralla.

            # Lue CSV paloissa
for chunk in pd.read_csv('large_data.csv', chunksize=100000):
    # Käsittele jokainen pala
    print(chunk.shape)

            

              
                Copy
              
            
          

7. Daskin käyttö rinnakkaiskäsittelyyn

Dask on rinnakkaislaskentakirjasto, joka integroituu saumattomasti Pandasiin. Sen avulla voit käsitellä suuria DataFrame-rakenteita rinnakkain, mikä voi merkittävästi parantaa suorituskykyä. Dask jakaa DataFramen pienempiin osioihin ja jakaa ne useille ytimille tai koneille.

            import dask.dataframe as dd

# Luo Dask DataFrame
ddf = dd.read_csv('large_data.csv')

# Suorita operaatioita Dask DataFrame -rakenteella
ddf_filtered = ddf[ddf['col1'] > 500]

# Laske tulos (tämä käynnistää rinnakkaislaskennan)
result = ddf_filtered.compute()

print(result.head())

            

              
                Copy
              
            
          

Indeksointi nopeampia hakuja varten

Indeksin luominen sarakkeelle voi merkittävästi nopeuttaa haku- ja suodatusoperaatioita. Pandas käyttää indeksejä löytääkseen nopeasti rivit, jotka vastaavat tiettyä arvoa.

Esimerkki:

            # Aseta 'col3' indeksiksi
df = df.set_index('col3')

# Nopeampi haku
value = df.loc['A']

print(value)

# Nollaa indeksi
df = df.reset_index()

            

              
                Copy
              
            
          

Liian monen indeksin luominen voi kuitenkin lisätä muistinkäyttöä ja hidastaa kirjoitusoperaatioita. Luo indeksejä vain sarakkeille, joita käytetään usein hauissa tai suodatuksessa.

Muita huomioita

• Laitteisto: Harkitse laitteistosi (prosessori, RAM, SSD) päivittämistä, jos työskentelet jatkuvasti suurten aineistojen kanssa.
• Ohjelmisto: Varmista, että käytät Pandasin uusinta versiota, sillä uudemmat versiot sisältävät usein suorituskykyparannuksia.
• Profilointi: Käytä profilointityökaluja (esim. cProfile, line_profiler) tunnistaaksesi koodisi suorituskyvyn pullonkaulat.
• Datan tallennusmuoto: Harkitse tehokkaampien datan tallennusmuotojen, kuten Parquet tai Feather, käyttöä CSV:n sijaan. Nämä muodot ovat sarakepohjaisia ja usein pakattuja, mikä johtaa pienempiin tiedostokokoihin ja nopeampiin luku-/kirjoitusaikoihin.

Yhteenveto

Pandas DataFrame -rakenteiden optimointi muistinkäytön ja suorituskyvyn osalta on ratkaisevan tärkeää suurten aineistojen tehokkaassa käsittelyssä. Valitsemalla sopivat tietotyypit, käyttämällä vektoroituja operaatioita ja indeksoimalla datasi tehokkaasti voit vähentää merkittävästi muistinkulutusta ja parantaa suorituskykyä. Muista profiloida koodisi suorituskyvyn pullonkaulojen tunnistamiseksi ja harkitse paloittelun tai Daskin käyttöä erittäin suurille aineistoille. Näitä tekniikoita soveltamalla voit hyödyntää Pandasin koko potentiaalin data-analyysissä ja manipuloinnissa.