ฉันจะอ่านไฟล์ csv ขนาดใหญ่ที่มีนุ่นได้อย่างไร

ฉันพยายามอ่านไฟล์ csv ขนาดใหญ่ (aprox. 6 GB) ในนุ่นและฉันได้รับข้อผิดพลาดของหน่วยความจำ:

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

...

MemoryError: 

ความช่วยเหลือเกี่ยวกับเรื่องนี้?

ข้อผิดพลาดแสดงว่าเครื่องมีหน่วยความจำไม่เพียงพอที่จะอ่าน CSV ทั้งหมดใน DataFrame ในครั้งเดียว สมมติว่าคุณไม่จำเป็นต้องมีชุดข้อมูลทั้งหมดในหน่วยความจำทั้งหมดในคราวเดียววิธีหนึ่งในการหลีกเลี่ยงปัญหาคือการประมวลผล CSV เป็นชิ้น (โดยระบุchunksizeพารามิเตอร์):

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

chunksizeพารามิเตอร์ระบุจำนวนแถวต่อก้อน (อันสุดท้ายอาจมีน้อยกว่าchunksizeแถว)

การแยกส่วนไม่ควรเป็นพอร์ตแรกของการโทรสำหรับปัญหานี้

1. ไฟล์ใหญ่เนื่องจากข้อมูลที่ไม่ใช่ตัวเลขซ้ำหรือคอลัมน์ที่ไม่ต้องการหรือไม่?

   ถ้าเป็นเช่นนั้นบางครั้งคุณสามารถเห็นการประหยัดหน่วยความจำขนาดใหญ่โดยการอ่านในคอลัมน์เป็นหมวดหมู่และเลือกคอลัมน์ที่ต้องการผ่านพารามิเตอร์pd.read_csv usecols

2. เวิร์กโฟลว์ของคุณต้องการการแบ่งการจัดการการส่งออกหรือไม่

   หากเป็นเช่นนั้นคุณสามารถใช้dask.dataframeเพื่อเชือดทำการคำนวณและส่งออกซ้ำ ๆ Chunking ดำเนินการอย่างเงียบ ๆ โดย dask ซึ่งรองรับชุดย่อยของ pandas API

3. หากทุกอย่างล้มเหลวอ่านทีละบรรทัดผ่านทางชิ้น

   รับรู้ผ่านแพนด้าหรือผ่านห้องสมุด csvเป็นทางเลือกสุดท้าย

ฉันทำเช่นนี้:

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)

สำหรับข้อมูลขนาดใหญ่ l แนะนำให้คุณใช้ไลบรารี่ "dask"
เช่น:

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

คุณสามารถอ่านเพิ่มเติมได้จากเอกสารที่นี่

ทางเลือกที่ดีอีกทางหนึ่งคือการใช้modinเพราะการทำงานทั้งหมดเหมือนกับแพนด้า

คำตอบข้างต้นเป็นไปตามหัวข้อแล้ว อย่างไรก็ตามถ้าคุณต้องการข้อมูลทั้งหมดในหน่วยความจำ - มีลักษณะที่bcolz มันบีบอัดข้อมูลในหน่วยความจำ ฉันมีประสบการณ์ที่ดีกับมัน แต่มันก็มีคุณสมบัติแพนด้าหายไปมากมาย

แก้ไข: ฉันได้รับอัตราการบีบอัดที่ประมาณ 1/10 หรือขนาดดั้งเดิมฉันคิดว่าแน่นอนขึ้นอยู่กับชนิดของข้อมูล คุณสมบัติที่สำคัญที่ขาดหายไปคือการรวม

คุณสามารถอ่านข้อมูลเป็นชิ้น ๆ และบันทึกแต่ละชิ้นเป็นผักดอง

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)

ในขั้นตอนถัดไปคุณจะอ่านจากผักดองและเติมแต่ละดองลงใน dataframe ที่คุณต้องการ

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)

ฟังก์ชัน read_csv และ read_table ใกล้เคียงกัน แต่คุณต้องกำหนดตัวคั่น“，” เมื่อคุณใช้ฟังก์ชั่น read_table ในโปรแกรมของคุณ

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)

โซลูชันที่ 1:

การใช้หมีแพนด้ากับข้อมูลขนาดใหญ่

โซลูชันที่ 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)

นี่คือตัวอย่างต่อไปนี้:

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)

คุณสามารถลอง sframe ที่มีรูปแบบเหมือนกันกับ pandas แต่ให้คุณจัดการไฟล์ที่ใหญ่กว่าแรมของคุณ

หากคุณใช้แพนด้าอ่านไฟล์ขนาดใหญ่เป็นชิ้น ๆ แล้วให้ผลทีละแถวนี่คือสิ่งที่ฉันทำ

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))

ฉันต้องการที่จะทำให้คำตอบที่ครอบคลุมมากขึ้นโดยใช้โซลูชั่นที่มีศักยภาพที่มีอยู่แล้วให้มากที่สุด ฉันยังต้องการชี้ให้เห็นความช่วยเหลือที่เป็นไปได้อีกหนึ่งอย่างที่อาจช่วยกระบวนการอ่าน

ตัวเลือกที่ 1: dtypes

"dtypes" เป็นพารามิเตอร์ที่มีประสิทธิภาพมากที่คุณสามารถใช้เพื่อลดความดันหน่วยความจำของreadวิธีการ ดูนี้และนี้คำตอบ โดยปกติแล้วแพนด้าจะพยายามอนุมานข้อมูลที่เป็นประเภท

อ้างถึงโครงสร้างข้อมูลทุกข้อมูลที่เก็บไว้จะมีการจัดสรรหน่วยความจำ ในระดับพื้นฐานอ้างอิงถึงค่าด้านล่าง (ตารางด้านล่างแสดงค่าสำหรับภาษาการเขียนโปรแกรม 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

อ้างถึงหน้านี้เพื่อดูการจับคู่ระหว่างประเภท NumPy และ C

สมมติว่าคุณมีอาร์เรย์ของจำนวนเต็มของตัวเลข คุณสามารถกำหนดทั้งในทางทฤษฎีและทางปฏิบัติพูดอาเรย์ชนิดจำนวนเต็ม 16 บิต แต่คุณจะจัดสรรหน่วยความจำได้มากกว่าที่คุณต้องการเก็บอาเรย์นั้น เพื่อป้องกันการนี้คุณสามารถตั้งค่าตัวเลือกdtype read_csvคุณไม่ต้องการที่จะเก็บไอเท็มอาเรย์เป็นจำนวนเต็มแบบยาวซึ่งจริงๆแล้วคุณสามารถใส่มันเข้าไปในจำนวนเต็ม 8 บิต ( np.int8หรือnp.uint8)

สังเกตแผนที่ dtype ต่อไปนี้

ที่มา: https://pbpython.com/pandas_dtypes.html

คุณสามารถส่งdtypeพารามิเตอร์เป็นพารามิเตอร์ในวิธีการของ pandas ตามที่ dict readเช่น {column: type}

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)

ตัวเลือกที่ 2: อ่านโดย Chunks

การอ่านข้อมูลเป็นกลุ่มช่วยให้คุณเข้าถึงส่วนหนึ่งของข้อมูลในหน่วยความจำและคุณสามารถใช้การประมวลผลล่วงหน้ากับข้อมูลของคุณและเก็บรักษาข้อมูลที่ประมวลผลไว้แทนที่จะเป็นข้อมูลดิบ มันจะดีกว่ามากถ้าคุณรวมตัวเลือกนี้เข้ากับdtypes ตัวแรก

ผมอยากจะชี้ให้เห็นแพนด้าตำราส่วนสำหรับกระบวนการที่ที่คุณสามารถค้นหาได้ที่นี่ สังเกตสองส่วนนั้น

• อ่าน csv chunk-by-chunk
• อ่านเฉพาะบางแถวของ csv chunk-by-chunk

ตัวเลือก 3: Dask

Dask เป็นกรอบงานที่กำหนดไว้ในเว็บไซต์ของ Daskดังนี้

Dask ให้ความเท่าเทียมขั้นสูงสำหรับการวิเคราะห์ช่วยให้ประสิทธิภาพในระดับที่เครื่องมือที่คุณชื่นชอบ

มันเกิดมาเพื่อปกปิดส่วนที่จำเป็นที่แพนด้าไม่สามารถเข้าถึงได้ Dask เป็นเฟรมเวิร์กที่ทรงพลังที่ช่วยให้คุณเข้าถึงข้อมูลได้มากขึ้นโดยการประมวลผลในแบบกระจาย

คุณสามารถใช้ dask เพื่อประมวลผลข้อมูลของคุณโดยรวมได้ Dask ดูแลส่วนที่เป็นก้อนดังนั้นไม่เหมือนกับแพนด้าที่คุณสามารถกำหนดขั้นตอนการประมวลผลและปล่อยให้ Dask ทำงานได้ Dask ไม่ได้ใช้การคำนวณก่อนที่จะถูกผลักดันอย่างชัดเจนโดยcomputeและ / หรือpersist(ดูคำตอบที่นี่สำหรับความแตกต่าง)

เอดส์อื่น ๆ (ความคิด)

• ETL flow ออกแบบมาสำหรับข้อมูล เก็บเฉพาะสิ่งที่จำเป็นจากข้อมูลดิบ
  • ก่อนอื่นให้ใช้ ETL กับข้อมูลทั้งหมดด้วยเฟรมเวิร์กเช่น Dask หรือ PySpark และส่งออกข้อมูลที่ประมวลผล
  • จากนั้นดูว่าข้อมูลที่ประมวลผลนั้นสามารถใส่ลงในหน่วยความจำทั้งหมดได้หรือไม่
• พิจารณาเพิ่ม RAM ของคุณ
• ลองพิจารณาทำงานกับข้อมูลนั้นบนแพลตฟอร์มคลาวด์

นอกจากคำตอบข้างต้นสำหรับผู้ที่ต้องการประมวลผล CSV แล้วส่งออกไปยัง csv, parquet หรือ SQL, d6tstackเป็นอีกตัวเลือกที่ดี คุณสามารถโหลดหลายไฟล์และจัดการกับการเปลี่ยนแปลงโครงสร้างข้อมูล (เพิ่ม / ลบคอลัมน์) รับการสนับสนุนหลักแบบแยกส่วนแล้วในตัว

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

ในกรณีที่บางคนยังมองหาสิ่งนี้ฉันพบว่าห้องสมุดใหม่ที่ชื่อว่าmodinสามารถช่วยได้ มันใช้การคำนวณแบบกระจายที่สามารถช่วยในการอ่าน นี่เป็นบทความที่ดีที่เปรียบเทียบการทำงานกับหมีแพนด้า มันใช้ฟังก์ชั่นเดียวกับนุ่นเป็นหลัก

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

ก่อนที่จะใช้ตัวเลือก chunksize ถ้าคุณต้องการแน่ใจเกี่ยวกับฟังก์ชั่นกระบวนการที่คุณต้องการเขียนภายใน chunking for-loop ตามที่กล่าวถึงโดย @unutbu คุณสามารถใช้ตัวเลือก nrows ได้

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

เมื่อคุณแน่ใจว่าบล็อกของกระบวนการพร้อมแล้วคุณสามารถใส่มันลงไปใน chunking for loop สำหรับดาต้าเฟรมทั้งหมด