Jak odczytać duży plik csv z pandami?

Próbuję odczytać duży plik csv (około 6 GB) w pandach i pojawia się błąd pamięci:

MemoryError                               Traceback (most recent call last)
<ipython-input-58-67a72687871b> in <module>()
----> 1 data=pd.read_csv('aphro.csv',sep=';')

...

MemoryError: 

Jakaś pomoc na ten temat?

Błąd pokazuje, że komputer nie ma wystarczającej ilości pamięci, aby odczytać cały plik CSV do DataFrame jednocześnie. Zakładając, że nie potrzebujesz całego zestawu danych w pamięci jednocześnie, jednym ze sposobów uniknięcia problemu byłoby przetworzenie pliku CSV we fragmenty (poprzez określenie chunksizeparametru):

chunksize = 10 ** 6
for chunk in pd.read_csv(filename, chunksize=chunksize):
    process(chunk)

Ten chunksizeparametr określa liczbę wierszy na porcję. (Ostatni fragment może chunksizeoczywiście zawierać mniej niż wiersze).

Tworzenie porcji nie zawsze powinno być pierwszym punktem wyjścia dla tego problemu.

1. Czy plik jest duży z powodu powtarzających się danych nienumerycznych lub niechcianych kolumn?

   Jeśli tak, czasami możesz zobaczyć ogromne oszczędności pamięci, czytając kolumny jako kategorie i wybierając wymagane kolumny za pomocą usecols parametru pd.read_csv .

2. Czy Twój przepływ pracy wymaga krojenia, manipulacji, eksportowania?

   Jeśli tak, możesz użyć dask.dataframe do wycinania, wykonywania obliczeń i eksportowania iteracyjnego. Tworzenie porcji odbywa się w trybie cichym przez dask, który obsługuje również podzbiór API pand.

3. Jeśli wszystko inne zawiedzie, przeczytaj wiersz po wierszu za pomocą porcji.

   Kawałek za pośrednictwem pand lub biblioteki csv w ostateczności.

Postępowałem tak:

chunks=pd.read_table('aphro.csv',chunksize=1000000,sep=';',\
       names=['lat','long','rf','date','slno'],index_col='slno',\
       header=None,parse_dates=['date'])

df=pd.DataFrame()
%time df=pd.concat(chunk.groupby(['lat','long',chunk['date'].map(lambda x: x.year)])['rf'].agg(['sum']) for chunk in chunks)

W przypadku dużych danych zalecam użycie biblioteki „dask”
np .:

# Dataframes implement the Pandas API
import dask.dataframe as dd
df = dd.read_csv('s3://.../2018-*-*.csv')

Możesz przeczytać więcej z dokumentacji tutaj .

Inną świetną alternatywą byłoby użycie modiny, ponieważ cała funkcjonalność jest identyczna z pandami, ale wykorzystuje ona rozproszone biblioteki ramek danych, takie jak dask.

Powyższa odpowiedź już spełnia ten temat. W każdym razie, jeśli potrzebujesz wszystkich danych w pamięci - spójrz na bcolz . Kompresuje dane w pamięci. Miałem z tym naprawdę dobre doświadczenia. Ale brakuje mu wielu funkcji pand

Edycja: Mam współczynniki kompresji około 1/10 lub rozmiar oryginału, myślę, oczywiście w zależności od rodzaju danych. Ważnymi brakującymi funkcjami były agregaty.

Możesz odczytać dane jako kawałki i zapisać każdy kawałek jako piklę.

import pandas as pd 
import pickle

in_path = "" #Path where the large file is
out_path = "" #Path to save the pickle files to
chunk_size = 400000 #size of chunks relies on your available memory
separator = "~"

reader = pd.read_csv(in_path,sep=separator,chunksize=chunk_size, 
                    low_memory=False)    


for i, chunk in enumerate(reader):
    out_file = out_path + "/data_{}.pkl".format(i+1)
    with open(out_file, "wb") as f:
        pickle.dump(chunk,f,pickle.HIGHEST_PROTOCOL)

W następnym kroku wczytujesz pikle i dołączasz każdą pikietę do żądanej ramki danych.

import glob
pickle_path = "" #Same Path as out_path i.e. where the pickle files are

data_p_files=[]
for name in glob.glob(pickle_path + "/data_*.pkl"):
   data_p_files.append(name)


df = pd.DataFrame([])
for i in range(len(data_p_files)):
    df = df.append(pd.read_pickle(data_p_files[i]),ignore_index=True)

Funkcje read_csv i read_table są prawie takie same. Ale musisz przypisać ogranicznik „，”, gdy używasz funkcji read_table w swoim programie.

def get_from_action_data(fname, chunk_size=100000):
    reader = pd.read_csv(fname, header=0, iterator=True)
    chunks = []
    loop = True
    while loop:
        try:
            chunk = reader.get_chunk(chunk_size)[["user_id", "type"]]
            chunks.append(chunk)
        except StopIteration:
            loop = False
            print("Iteration is stopped")

    df_ac = pd.concat(chunks, ignore_index=True)

Rozwiązanie 1:

Korzystanie z pand z dużymi danymi

Rozwiązanie 2:

TextFileReader = pd.read_csv(path, chunksize=1000)  # the number of rows per chunk

dfList = []
for df in TextFileReader:
    dfList.append(df)

df = pd.concat(dfList,sort=False)

Oto przykład:

chunkTemp = []
queryTemp = []
query = pd.DataFrame()

for chunk in pd.read_csv(file, header=0, chunksize=<your_chunksize>, iterator=True, low_memory=False):

    #REPLACING BLANK SPACES AT COLUMNS' NAMES FOR SQL OPTIMIZATION
    chunk = chunk.rename(columns = {c: c.replace(' ', '') for c in chunk.columns})

    #YOU CAN EITHER: 
    #1)BUFFER THE CHUNKS IN ORDER TO LOAD YOUR WHOLE DATASET 
    chunkTemp.append(chunk)

    #2)DO YOUR PROCESSING OVER A CHUNK AND STORE THE RESULT OF IT
    query = chunk[chunk[<column_name>].str.startswith(<some_pattern>)]   
    #BUFFERING PROCESSED DATA
    queryTemp.append(query)

#!  NEVER DO pd.concat OR pd.DataFrame() INSIDE A LOOP
print("Database: CONCATENATING CHUNKS INTO A SINGLE DATAFRAME")
chunk = pd.concat(chunkTemp)
print("Database: LOADED")

#CONCATENATING PROCESSED DATA
query = pd.concat(queryTemp)
print(query)

Możesz wypróbować sframe, które mają tę samą składnię co pandy, ale pozwalają na manipulowanie plikami większymi niż twoja pamięć RAM.

Jeśli używasz pand, wczytaj duży plik do porcji, a następnie wydaj wiersz po rzędzie, oto co zrobiłem

import pandas as pd

def chunck_generator(filename, header=False,chunk_size = 10 ** 5):
   for chunk in pd.read_csv(filename,delimiter=',', iterator=True, chunksize=chunk_size, parse_dates=[1] ): 
        yield (chunk)

def _generator( filename, header=False,chunk_size = 10 ** 5):
    chunk = chunck_generator(filename, header=False,chunk_size = 10 ** 5)
    for row in chunk:
        yield row

if __name__ == "__main__":
filename = r'file.csv'
        generator = generator(filename=filename)
        while True:
           print(next(generator))

Chcę udzielić bardziej kompleksowej odpowiedzi na podstawie większości potencjalnych rozwiązań, które już zostały dostarczone. Chciałbym również wskazać jeszcze jedną potencjalną pomoc, która może pomóc w procesie czytania.

Opcja 1: dtypy

„dtypes” to dość potężny parametr, którego można użyć do zmniejszenia presji pamięci na readmetody. Zobacz tę i tę odpowiedź. Pandy domyślnie próbują wnioskować o typach danych.

Odnosząc się do struktur danych, każde zapisane dane, następuje przydział pamięci. Na poziomie podstawowym zapoznaj się z poniższymi wartościami (tabela poniżej ilustruje wartości dla języka programowania C):

The maximum value of UNSIGNED CHAR = 255                                    
The minimum value of SHORT INT = -32768                                     
The maximum value of SHORT INT = 32767                                      
The minimum value of INT = -2147483648                                      
The maximum value of INT = 2147483647                                       
The minimum value of CHAR = -128                                            
The maximum value of CHAR = 127                                             
The minimum value of LONG = -9223372036854775808                            
The maximum value of LONG = 9223372036854775807

Sprawdź tę stronę, aby zobaczyć dopasowanie między NumPy i typami C.

Powiedzmy, że masz tablicę liczb z cyfr . Możesz zarówno teoretycznie, jak i praktycznie przypisać, powiedzmy tablicę 16-bitowych liczb całkowitych, ale wtedy przydzielisz więcej pamięci, niż faktycznie potrzebujesz do przechowywania tej tablicy. Aby temu zapobiec, możesz ustawić dtypeopcję na read_csv. Nie chcesz przechowywać elementów tablicy jako długich liczb całkowitych, gdzie faktycznie możesz zmieścić je za pomocą 8-bitowych liczb całkowitych ( np.int8lub np.uint8).

Obserwuj poniższą mapę typu.

Źródło: https://pbpython.com/pandas_dtypes.html

Możesz przekazać dtypeparametr jako parametr w metodach pand tak readjak w przypadku {kolumna: typ}.

import numpy as np
import pandas as pd

df_dtype = {
        "column_1": int,
        "column_2": str,
        "column_3": np.int16,
        "column_4": np.uint8,
        ...
        "column_n": np.float32
}

df = pd.read_csv('path/to/file', dtype=df_dtype)

Opcja 2: odczytane przez kawałki

Odczytywanie danych we fragmentach umożliwia dostęp do części danych w pamięci, a także można zastosować wstępne przetwarzanie danych i zachować przetworzone dane zamiast danych surowych. Byłoby znacznie lepiej, gdyby połączyć tę opcję z pierwszą, dtypami .

Chciałbym wskazać sekcje książki kucharskiej pandy dotyczące tego procesu, gdzie można je znaleźć tutaj . Zwróć uwagę na te dwie sekcje;

• Czytanie fragmentu pliku csv po kawałku
• Czytanie tylko niektórych wierszy fragmentu pliku csv po kawałku

Opcja 3: Dask

Dask to środowisko, które jest zdefiniowane na stronie internetowej Dask jako:

Dask zapewnia zaawansowaną równoległość analiz, umożliwiając skalowanie wydajności dla narzędzi, które kochasz

Urodził się, aby pokryć niezbędne części, do których nie mogą dotrzeć pandy. Dask to potężny framework, który pozwala na znacznie większy dostęp do danych poprzez przetwarzanie ich w sposób rozproszony.

Możesz użyć dask, aby wstępnie przetworzyć swoje dane jako całość, Dask zajmuje się fragmentacją, więc w przeciwieństwie do pand, możesz po prostu zdefiniować etapy przetwarzania i pozwolić Dask wykonać pracę. Dask nie dotyczy obliczeń zanim zostanie ona wyraźnie przesunąć computei / lub persist(patrz odpowiedź tutaj różnicy).

Inne pomoce (pomysły)

• Przepływ ETL zaprojektowany dla danych. Zachowaj tylko to, co jest potrzebne z nieprzetworzonych danych.
  • Najpierw zastosuj ETL do całych danych za pomocą frameworków takich jak Dask lub PySpark i wyeksportuj przetworzone dane.
  • Następnie sprawdź, czy przetwarzane dane można zmieścić w pamięci jako całości.
• Rozważ zwiększenie pamięci RAM.
• Rozważ pracę z tymi danymi na platformie chmurowej.

Oprócz powyższych odpowiedzi, dla tych, którzy chcą przetworzyć CSV, a następnie wyeksportować do formatu csv, parquet lub SQL, d6tstack to kolejna dobra opcja. Możesz załadować wiele plików i dotyczy to zmian schematu danych (dodanych / usuniętych kolumn). Wydzielone z podstawowego wsparcia jest już wbudowane.

def apply(dfg):
    # do stuff
    return dfg

c = d6tstack.combine_csv.CombinerCSV([bigfile.csv], apply_after_read=apply, sep=',', chunksize=1e6)

# or
c = d6tstack.combine_csv.CombinerCSV(glob.glob('*.csv'), apply_after_read=apply, chunksize=1e6)

# output to various formats, automatically chunked to reduce memory consumption
c.to_csv_combine(filename='out.csv')
c.to_parquet_combine(filename='out.pq')
c.to_psql_combine('postgresql+psycopg2://usr:pwd@localhost/db', 'tablename') # fast for postgres
c.to_mysql_combine('mysql+mysqlconnector://usr:pwd@localhost/db', 'tablename') # fast for mysql
c.to_sql_combine('postgresql+psycopg2://usr:pwd@localhost/db', 'tablename') # slow but flexible

W przypadku, gdy ktoś wciąż szuka czegoś takiego, odkryłem, że ta nowa biblioteka o nazwie modin może pomóc. Wykorzystuje przetwarzanie rozproszone, które może pomóc w czytaniu. Oto fajny artykuł porównujący jego funkcjonalność z pandami. Zasadniczo wykorzystuje te same funkcje, co pandy.

import modin.pandas as pd
pd.read_csv(CSV_FILE_NAME)

Przed użyciem opcji chunksize, jeśli chcesz być pewien funkcji procesu, którą chcesz zapisać w pętli for chunking, jak wspomniano w @unutbu, możesz po prostu użyć opcji nrows.

small_df = pd.read_csv(filename, nrows=100)

Gdy masz pewność, że blok procesu jest gotowy, możesz umieścić go w pętli łączenia dla całej ramki danych.