กระแสงาน“ ข้อมูลขนาดใหญ่” โดยใช้แพนด้า

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

วันหนึ่งฉันหวังว่าจะเปลี่ยนการใช้ SAS ของฉันเป็น python และ pandas แต่ตอนนี้ฉันขาดเวิร์กโฟลว์นอกหลักสำหรับชุดข้อมูลขนาดใหญ่ ฉันไม่ได้พูดถึง "ข้อมูลขนาดใหญ่" ที่ต้องใช้เครือข่ายแบบกระจาย แต่ไฟล์ใหญ่เกินไปที่จะใส่ในหน่วยความจำ แต่เล็กพอที่จะใส่ลงในฮาร์ดไดรฟ์

ความคิดแรกของฉันคือการใช้HDFStoreเพื่อเก็บชุดข้อมูลขนาดใหญ่บนดิสก์และดึงเฉพาะส่วนที่ฉันต้องการลงใน dataframes สำหรับการวิเคราะห์ คนอื่น ๆ พูดถึง MongoDB ว่าเป็นทางเลือกที่ใช้งานง่ายกว่า คำถามของฉันคือ:

ขั้นตอนการปฏิบัติที่ดีที่สุดสำหรับการทำสิ่งต่อไปนี้คืออะไร:

1. การโหลดไฟล์แฟล็ตไปยังโครงสร้างฐานข้อมูลถาวรบนดิสก์
2. การสืบค้นฐานข้อมูลนั้นเพื่อดึงข้อมูลไปยังฟีดลงในโครงสร้างข้อมูลแพนด้า
3. การอัพเดตฐานข้อมูลหลังจากจัดการกับชิ้นส่วนในนุ่น

ตัวอย่างในโลกแห่งความเป็นจริงจะได้รับการชื่นชมอย่างมากโดยเฉพาะจากใครก็ตามที่ใช้หมีแพนด้ากับ "ข้อมูลขนาดใหญ่"

แก้ไข - ตัวอย่างของวิธีที่ฉันต้องการให้ทำงาน:

1. ทำซ้ำนำเข้าไฟล์แฟล็ตขนาดใหญ่และเก็บไว้ในโครงสร้างฐานข้อมูลถาวรบนดิสก์ โดยทั่วไปไฟล์เหล่านี้ใหญ่เกินไปที่จะใส่ในหน่วยความจำ
2. ในการใช้ Pandas ฉันต้องการอ่านชุดย่อยของข้อมูลนี้ (โดยปกติจะมีคอลัมน์ไม่กี่คอลัมน์ในเวลาเดียวกัน) ที่สามารถใส่ในหน่วยความจำได้
3. ฉันจะสร้างคอลัมน์ใหม่โดยดำเนินการต่าง ๆ ในคอลัมน์ที่เลือก
4. ฉันจะต้องผนวกคอลัมน์ใหม่เหล่านี้ลงในโครงสร้างฐานข้อมูล

ฉันกำลังพยายามหาวิธีปฏิบัติที่ดีที่สุดในการทำตามขั้นตอนเหล่านี้ การอ่านลิงก์เกี่ยวกับนุ่นและปิรามิดดูเหมือนว่าการผนวกคอลัมน์ใหม่อาจเป็นปัญหาได้

แก้ไข - ตอบคำถามของ Jeff โดยเฉพาะ:

1. ฉันกำลังสร้างแบบจำลองความเสี่ยงด้านเครดิตของผู้บริโภค ชนิดของข้อมูลรวมถึงโทรศัพท์ SSN และลักษณะที่อยู่ ค่าคุณสมบัติ ข้อมูลที่เสื่อมเสียเช่นบันทึกความผิดทางอาญาการล้มละลาย ฯลฯ ... ชุดข้อมูลที่ฉันใช้ทุกวันมีเกือบ 1,000 ถึง 2,000 ฟิลด์โดยเฉลี่ยของชนิดข้อมูลแบบผสม: ตัวแปรต่อเนื่อง, ชื่อและเลขลำดับของข้อมูลตัวเลขและตัวละคร ฉันไม่ค่อยใส่แถว แต่ฉันทำการดำเนินการหลายอย่างที่สร้างคอลัมน์ใหม่
2. การดำเนินงานทั่วไปเกี่ยวข้องกับการรวมหลายคอลัมน์โดยใช้ตรรกะตามเงื่อนไขลงในคอลัมน์ผสมใหม่ ตัวอย่างเช่นif var1 > 2 then newvar = 'A' elif var2 = 4 then newvar = 'B'. ผลลัพธ์ของการดำเนินการเหล่านี้เป็นคอลัมน์ใหม่สำหรับทุกระเบียนในชุดข้อมูลของฉัน
3. ในที่สุดฉันต้องการผนวกคอลัมน์ใหม่เหล่านี้ลงในโครงสร้างข้อมูลบนดิสก์ ฉันจะทำซ้ำขั้นตอนที่ 2 สำรวจข้อมูลด้วยแท็บไขว้และสถิติเชิงพรรณนาพยายามหาความสัมพันธ์ที่น่าสนใจ
4. ไฟล์โครงการทั่วไปมักจะประมาณ 1GB ไฟล์ถูกจัดระเบียบในลักษณะที่แถวประกอบด้วยบันทึกข้อมูลผู้บริโภค แต่ละแถวมีจำนวนคอลัมน์เท่ากันสำหรับทุกเรคคอร์ด นี่จะเป็นกรณีนี้เสมอ
5. มันค่อนข้างยากที่ฉันจะแบ่งย่อยเป็นแถวเมื่อสร้างคอลัมน์ใหม่ อย่างไรก็ตามมันเป็นเรื่องธรรมดาสำหรับฉันที่จะเซตย่อยบนแถวเมื่อสร้างรายงานหรือสร้างสถิติเชิงพรรณนา ตัวอย่างเช่นฉันอาจต้องการสร้างความถี่อย่างง่ายสำหรับสายธุรกิจเฉพาะพูดบัตรเครดิตขายปลีก ในการทำเช่นนี้ฉันจะเลือกเฉพาะระเบียนที่บรรทัดของธุรกิจ = ค้าปลีกนอกเหนือจากคอลัมน์ใดที่ฉันต้องการรายงาน อย่างไรก็ตามเมื่อสร้างคอลัมน์ใหม่ฉันจะดึงแถวข้อมูลทั้งหมดและเฉพาะคอลัมน์ที่ฉันต้องการสำหรับการดำเนินการ
6. กระบวนการสร้างแบบจำลองต้องการให้ฉันวิเคราะห์ทุกคอลัมน์ค้นหาความสัมพันธ์ที่น่าสนใจกับตัวแปรผลลัพธ์บางส่วนและสร้างคอลัมน์ผสมใหม่ที่อธิบายความสัมพันธ์เหล่านั้น คอลัมน์ที่ฉันสำรวจมักจะทำในชุดเล็ก ๆ ตัวอย่างเช่นฉันจะมุ่งเน้นไปที่ชุดของคอลัมน์ 20 คอลัมน์ที่พูดถึงการจัดการกับมูลค่าทรัพย์สินและสังเกตว่าพวกเขาเกี่ยวข้องกับการผิดนัดชำระเงินกู้อย่างไร เมื่อมีการสำรวจและสร้างคอลัมน์ใหม่แล้วฉันจะย้ายไปยังกลุ่มคอลัมน์อื่นพูดการศึกษาระดับวิทยาลัยและทำซ้ำกระบวนการ สิ่งที่ฉันทำคือการสร้างตัวแปรตัวเลือกที่อธิบายความสัมพันธ์ระหว่างข้อมูลของฉันกับผลลัพธ์บางอย่าง ในตอนท้ายของกระบวนการนี้ฉันใช้เทคนิคการเรียนรู้ที่สร้างสมการออกมาจากคอลัมน์ผสมเหล่านั้น

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

ฉันใช้ข้อมูลเป็นสิบกิกะไบต์เป็นประจำเช่นนี้เช่นฉันมีตารางบนดิสก์ที่ฉันอ่านผ่านคิวรีสร้างข้อมูลและผนวกกลับ

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

รายละเอียดซึ่งจะส่งผลต่อวิธีการจัดเก็บข้อมูลของคุณเช่น:
ให้รายละเอียดมากที่สุดเท่าที่จะทำได้ และฉันสามารถช่วยคุณพัฒนาโครงสร้าง

1. ขนาดของข้อมูลจำนวนแถวคอลัมน์ประเภทของคอลัมน์ คุณต่อท้ายแถวหรือแค่คอลัมน์?
2. การดำเนินงานทั่วไปจะมีลักษณะอย่างไร เช่นทำแบบสอบถามในคอลัมน์เพื่อเลือกกลุ่มของแถวและคอลัมน์ที่เฉพาะเจาะจงจากนั้นทำการดำเนินการ (ในหน่วยความจำ) สร้างคอลัมน์ใหม่บันทึกเหล่านี้
   (การให้ตัวอย่างของเล่นช่วยให้เราสามารถให้คำแนะนำที่เฉพาะเจาะจงมากขึ้น)
3. หลังจากประมวลผลแล้วคุณจะทำอย่างไร ขั้นตอนที่ 2 เฉพาะกิจหรือทำซ้ำได้?
4. อินพุตไฟล์แฟล็ต: ขนาดรวมทั้งหมดที่ขรุขระใน Gb มีการจัดระเบียบเหล่านี้อย่างไรเช่นโดยบันทึก? แต่ละอันมีฟิลด์แตกต่างกันหรือมีเร็กคอร์ดต่อไฟล์ที่มีฟิลด์ทั้งหมดในแต่ละไฟล์หรือไม่?
5. คุณเคยเลือกชุดย่อยของแถว (บันทึก) ตามเกณฑ์ (เช่นเลือกแถวที่มีฟิลด์ A> 5) หรือไม่ จากนั้นทำอะไรสักอย่างหรือคุณเพียงแค่เลือกเขตข้อมูล A, B, C กับระเบียนทั้งหมด (แล้วทำบางสิ่ง)?
6. คุณ 'ทำงาน' คอลัมน์ทั้งหมดของคุณ (เป็นกลุ่ม) หรือมีสัดส่วนที่ดีที่คุณสามารถใช้สำหรับรายงานเท่านั้น (เช่นคุณต้องการเก็บข้อมูลไว้รอบ ๆ แต่ไม่จำเป็นต้องดึงคอลัมน์ออกมาจนกว่าจะถึงวันที่) เวลาผลลัพธ์สุดท้าย)?

สารละลาย

ให้แน่ใจว่าคุณมีหมีแพนด้า0.10.1ติดตั้งอย่างน้อย

อ่านiterating ไฟล์ก้อนโดยก้อนและคำสั่งหลายตาราง

เนื่องจาก Pytables ได้รับการปรับให้ทำงานในแถวที่ฉลาดกว่า (ซึ่งเป็นสิ่งที่คุณสืบค้น) เราจะสร้างตารางสำหรับแต่ละเขตข้อมูล วิธีนี้ง่ายต่อการเลือกกลุ่มของเขตข้อมูลขนาดเล็ก (ซึ่งจะทำงานกับตารางขนาดใหญ่ แต่มีประสิทธิภาพมากกว่าที่จะทำเช่นนี้ ... ฉันคิดว่าฉันอาจสามารถแก้ไขข้อ จำกัด นี้ได้ในอนาคต ... นี่คือ ใช้งานง่ายขึ้น แต่อย่างใด):
(ต่อไปนี้เป็นรหัสเทียม.)

import numpy as np
import pandas as pd

# create a store
store = pd.HDFStore('mystore.h5')

# this is the key to your storage:
#    this maps your fields to a specific group, and defines 
#    what you want to have as data_columns.
#    you might want to create a nice class wrapping this
#    (as you will want to have this map and its inversion)  
group_map = dict(
    A = dict(fields = ['field_1','field_2',.....], dc = ['field_1',....,'field_5']),
    B = dict(fields = ['field_10',......        ], dc = ['field_10']),
    .....
    REPORTING_ONLY = dict(fields = ['field_1000','field_1001',...], dc = []),

)

group_map_inverted = dict()
for g, v in group_map.items():
    group_map_inverted.update(dict([ (f,g) for f in v['fields'] ]))

การอ่านไฟล์และการสร้างที่เก็บข้อมูล (โดยพื้นฐานแล้วทำในสิ่งที่ทำappend_to_multiple):

for f in files:
   # read in the file, additional options may be necessary here
   # the chunksize is not strictly necessary, you may be able to slurp each 
   # file into memory in which case just eliminate this part of the loop 
   # (you can also change chunksize if necessary)
   for chunk in pd.read_table(f, chunksize=50000):
       # we are going to append to each table by group
       # we are not going to create indexes at this time
       # but we *ARE* going to create (some) data_columns

       # figure out the field groupings
       for g, v in group_map.items():
             # create the frame for this group
             frame = chunk.reindex(columns = v['fields'], copy = False)    

             # append it
             store.append(g, frame, index=False, data_columns = v['dc'])

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

นี่คือวิธีที่คุณได้รับคอลัมน์และสร้างคอลัมน์ใหม่:

frame = store.select(group_that_I_want)
# you can optionally specify:
# columns = a list of the columns IN THAT GROUP (if you wanted to
#     select only say 3 out of the 20 columns in this sub-table)
# and a where clause if you want a subset of the rows

# do calculations on this frame
new_frame = cool_function_on_frame(frame)

# to 'add columns', create a new group (you probably want to
# limit the columns in this new_group to be only NEW ones
# (e.g. so you don't overlap from the other tables)
# add this info to the group_map
store.append(new_group, new_frame.reindex(columns = new_columns_created, copy = False), data_columns = new_columns_created)

เมื่อคุณพร้อมที่จะ post_processing:

# This may be a bit tricky; and depends what you are actually doing.
# I may need to modify this function to be a bit more general:
report_data = store.select_as_multiple([groups_1,groups_2,.....], where =['field_1>0', 'field_1000=foo'], selector = group_1)

เกี่ยวกับ data_columns คุณไม่จำเป็นต้องกำหนดdata_columns ใด ๆ พวกเขาอนุญาตให้คุณเลือกแถวย่อยตามคอลัมน์ เช่นบางสิ่งเช่น:

store.select(group, where = ['field_1000=foo', 'field_1001>0'])

พวกเขาอาจจะน่าสนใจที่สุดสำหรับคุณในขั้นตอนการสร้างรายงานขั้นสุดท้าย (โดยปกติแล้วคอลัมน์ข้อมูลจะถูกแยกออกจากคอลัมน์อื่น ๆ ซึ่งอาจส่งผลกระทบต่อประสิทธิภาพบ้างถ้าคุณกำหนดมาก)

คุณอาจต้องการ:

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

แจ้งให้เราทราบเมื่อคุณมีข้อสงสัย!

ฉันคิดว่าคำตอบข้างต้นขาดวิธีง่ายๆที่ฉันพบว่ามีประโยชน์มาก

เมื่อฉันมีไฟล์ที่มีขนาดใหญ่เกินกว่าที่จะโหลดในหน่วยความจำฉันจะแบ่งไฟล์ออกเป็นไฟล์เล็ก ๆ หลายไฟล์ (ไม่ว่าจะเป็นแถวหรือแถว)

ตัวอย่าง: ในกรณีที่มีข้อมูลการซื้อขาย 30 วันที่มีขนาด ~ 30GB ฉันจะแบ่งเป็นไฟล์ต่อวันที่มีขนาด ~ 1GB ต่อมาฉันจะประมวลผลแต่ละไฟล์แยกกันและรวมผลลัพธ์เมื่อสิ้นสุด

ข้อดีอย่างหนึ่งที่ใหญ่ที่สุดคือช่วยให้การประมวลผลแบบขนานของไฟล์ (หลายเธรดหรือกระบวนการ)

ข้อได้เปรียบอื่น ๆ คือการจัดการไฟล์ (เช่นการเพิ่ม / ลบวันที่ในตัวอย่าง) สามารถทำได้โดยคำสั่งเชลล์ปกติซึ่งเป็นไปไม่ได้ในรูปแบบไฟล์ขั้นสูง / ซับซ้อนมากขึ้น

วิธีนี้ไม่ครอบคลุมทุกสถานการณ์ แต่มีประโยชน์มากในหลาย ๆ สถานการณ์

ขณะนี้มีสองปีหลังจากที่คำถามที่ว่า 'ออกจากแกน' นุ่นเทียบเท่า: dask มันยอดเยี่ยมมาก! แม้ว่ามันจะไม่รองรับฟังก์ชั่นแพนด้าทั้งหมด แต่คุณก็ยังห่างไกลได้

หากชุดข้อมูลของคุณอยู่ระหว่าง 1 ถึง 20GB คุณควรได้รับเวิร์กสเตชันที่มี RAM 48GB จากนั้น Pandas สามารถเก็บชุดข้อมูลทั้งหมดไว้ใน RAM ฉันรู้ว่ามันไม่ใช่คำตอบที่คุณกำลังมองหาที่นี่ แต่การคำนวณทางวิทยาศาสตร์บนโน้ตบุ๊คที่มี RAM 4GB ไม่สมเหตุสมผล

ฉันรู้ว่านี่เป็นเธรดเก่า แต่ฉันคิดว่าห้องสมุดBlazeคุ้มค่าที่จะเช็คเอาท์ มันสร้างขึ้นสำหรับสถานการณ์ประเภทนี้

จากเอกสาร:

Blaze เพิ่มความสามารถในการใช้งานของ NumPy และ Pandas เพื่อการกระจายและการประมวลผลนอกหลัก Blaze จัดให้มีอินเตอร์เฟสคล้ายกับ NumPy ND-Array หรือ Pandas DataFrame แต่แมปอินเทอร์เฟซที่คุ้นเคยเหล่านี้ไปยังเอนจิ้นการคำนวณอื่น ๆ เช่น Postgres หรือ Spark

แก้ไข:ยังไงก็ตามมันสนับสนุนโดย ContinuumIO และ Travis Oliphant ผู้แต่ง NumPy

นี่เป็นกรณีของ pymongo ฉันได้สร้างต้นแบบโดยใช้เซิร์ฟเวอร์ sql, sqlite, HDF, ORM (SQLAlchemy) ในหลาม pymongo แรกสุดคือฐานที่ยึดตามเอกสารดังนั้นแต่ละคนจะเป็นเอกสาร ( dictของแอ็ตทริบิวต์) มีหลายคนที่รวมคอลเลกชันและคุณสามารถมีคอลเลกชันจำนวนมาก (คนตลาดหุ้นตลาดหุ้นรายได้)

pd.dateframe -> pymongo หมายเหตุ: ฉันใช้chunksizein read_csvเพื่อเก็บบันทึกไว้ 5 ถึง 10k (pymongo จะลดลงซ็อกเก็ตถ้าใหญ่กว่า)

aCollection.insert((a[1].to_dict() for a in df.iterrows()))

การสืบค้น: gt = มากกว่า ...

pd.DataFrame(list(mongoCollection.find({'anAttribute':{'$gt':2887000, '$lt':2889000}})))

.find()ส่งกลับตัววนซ้ำดังนั้นฉันมักจะใช้ichunkedเพื่อสับเป็นตัววนซ้ำขนาดเล็ก

วิธีการเกี่ยวกับการเข้าร่วมเนื่องจากโดยปกติฉันจะได้รับ 10 แหล่งข้อมูลเพื่อรวมเข้าด้วยกัน:

aJoinDF = pandas.DataFrame(list(mongoCollection.find({'anAttribute':{'$in':Att_Keys}})))

จากนั้น (ในกรณีของฉันบางครั้งฉันต้องหงุดหงิดaJoinDFก่อนก่อน "ผสาน")

df = pandas.merge(df, aJoinDF, on=aKey, how='left')

และคุณสามารถเขียนข้อมูลใหม่ลงในคอลเลกชันหลักของคุณผ่านวิธีการอัพเดตด้านล่าง (การรวบรวมเชิงตรรกะเทียบกับแหล่งข้อมูลทางกายภาพ)

collection.update({primarykey:foo},{key:change})

ในการค้นหาขนาดเล็กเพียงแค่ทำให้ปกติ ตัวอย่างเช่นคุณมีรหัสในเอกสารและคุณเพียงเพิ่มข้อความรหัสฟิลด์และทำการdictค้นหาในขณะที่คุณสร้างเอกสาร

ตอนนี้คุณมีชุดข้อมูลที่ดีซึ่งอิงกับบุคคลคุณสามารถปลดปล่อยตรรกะของคุณในแต่ละกรณีและสร้างคุณลักษณะเพิ่มเติมได้ ในที่สุดคุณสามารถอ่านเป็น pandas ตัวบ่งชี้คีย์สูงสุด 3 หน่วยความจำและทำการสำรวจ pivots / agg / data สิ่งนี้ใช้ได้กับฉันมากกว่า 3 ล้านบันทึกด้วยตัวเลข / ข้อความขนาดใหญ่ / หมวดหมู่ / รหัส / ลอยตัว / ...

คุณยังสามารถใช้สองวิธีที่สร้างขึ้นใน MongoDB (MapReduce และกรอบการรวม) ดูที่นี่สำหรับข้อมูลเพิ่มเติมเกี่ยวกับกรอบการรวมเนื่องจากดูเหมือนว่าจะง่ายกว่า MapReduce และดูมีประโยชน์สำหรับการทำงานรวมอย่างรวดเร็ว แจ้งให้ทราบฉันไม่จำเป็นต้องกำหนดเขตข้อมูลหรือความสัมพันธ์ของฉันและฉันสามารถเพิ่มรายการลงในเอกสาร ที่สถานะปัจจุบันของชุดเครื่องมือ numpy, pandas, python ที่เปลี่ยนแปลงอย่างรวดเร็ว MongoDB ช่วยให้ฉันทำงานได้ดี :)

ฉันพบสิ่งนี้ล่าช้าเล็กน้อย แต่ฉันทำงานกับปัญหาที่คล้ายกัน (โมเดลการชำระเงินล่วงหน้าแบบจำนอง) วิธีการแก้ปัญหาของฉันคือการข้ามชั้น HDFStore แพนด้าและใช้ปิเปตแบบตรง ฉันบันทึกแต่ละคอลัมน์เป็นอาร์เรย์ HDF5 แต่ละรายการในไฟล์สุดท้ายของฉัน

เวิร์กโฟลว์พื้นฐานของฉันคือการได้รับไฟล์ CSV จากฐานข้อมูลก่อน ฉัน gzip มันดังนั้นมันจึงไม่ใหญ่มาก จากนั้นฉันแปลงไฟล์นั้นเป็นไฟล์ HDF5 แบบแถวต่อแถวโดยวนซ้ำในไพ ธ อนแปลงแต่ละแถวเป็นชนิดข้อมูลจริงและเขียนลงในไฟล์ HDF5 มันใช้เวลาหลายสิบนาที แต่มันไม่ได้ใช้หน่วยความจำใด ๆ เพราะมันใช้งานแบบแถวต่อแถวเท่านั้น จากนั้นฉัน "แปลง" ไฟล์ HDF5 ที่มุ่งเน้นแถวเป็นไฟล์ HDF5 ที่มุ่งเน้นคอลัมน์

ตารางทรานสโพสต์ดูเหมือนว่า:

def transpose_table(h_in, table_path, h_out, group_name="data", group_path="/"):
    # Get a reference to the input data.
    tb = h_in.getNode(table_path)
    # Create the output group to hold the columns.
    grp = h_out.createGroup(group_path, group_name, filters=tables.Filters(complevel=1))
    for col_name in tb.colnames:
        logger.debug("Processing %s", col_name)
        # Get the data.
        col_data = tb.col(col_name)
        # Create the output array.
        arr = h_out.createCArray(grp,
                                 col_name,
                                 tables.Atom.from_dtype(col_data.dtype),
                                 col_data.shape)
        # Store the data.
        arr[:] = col_data
    h_out.flush()

อ่านมันกลับมาแล้วดูเหมือนว่า:

def read_hdf5(hdf5_path, group_path="/data", columns=None):
    """Read a transposed data set from a HDF5 file."""
    if isinstance(hdf5_path, tables.file.File):
        hf = hdf5_path
    else:
        hf = tables.openFile(hdf5_path)

    grp = hf.getNode(group_path)
    if columns is None:
        data = [(child.name, child[:]) for child in grp]
    else:
        data = [(child.name, child[:]) for child in grp if child.name in columns]

    # Convert any float32 columns to float64 for processing.
    for i in range(len(data)):
        name, vec = data[i]
        if vec.dtype == np.float32:
            data[i] = (name, vec.astype(np.float64))

    if not isinstance(hdf5_path, tables.file.File):
        hf.close()
    return pd.DataFrame.from_items(data)

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

โดยทั่วไปแล้วใช้งานได้ดีสำหรับฉัน แต่มันค่อนข้างจะเป็น clunky และฉันไม่สามารถใช้เวทมนตร์ pytables

แก้ไข: ข้อได้เปรียบที่แท้จริงของวิธีการนี้โดยค่าเริ่มต้นของปิรามิดอาร์เรย์ของระเบียนคือฉันสามารถโหลดข้อมูลลงใน R โดยใช้ h5r ซึ่งไม่สามารถจัดการตารางได้ หรืออย่างน้อยฉันก็ไม่สามารถทำให้มันโหลดตารางที่ต่างกันได้

เคล็ดลับหนึ่งที่ฉันพบว่ามีประโยชน์สำหรับกรณีการใช้ข้อมูลขนาดใหญ่คือการลดปริมาณข้อมูลด้วยการลดความแม่นยำของการลอยตัวเป็น 32 บิต มันไม่สามารถใช้ได้ในทุกกรณี แต่ในหลาย ๆ แอปพลิเคชั่นความแม่นยำ 64 บิตนั้นเกินความจริงและการประหยัดหน่วยความจำ 2x นั้นคุ้มค่า หากต้องการทำให้จุดที่ชัดเจนชัดเจนยิ่งขึ้น:

>>> df = pd.DataFrame(np.random.randn(int(1e8), 5))
>>> df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 100000000 entries, 0 to 99999999
Data columns (total 5 columns):
...
dtypes: float64(5)
memory usage: 3.7 GB

>>> df.astype(np.float32).info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 100000000 entries, 0 to 99999999
Data columns (total 5 columns):
...
dtypes: float32(5)
memory usage: 1.9 GB

ดังที่คนอื่น ๆ สังเกตเห็นหลังจากหลายปีที่ผ่านมาความคล้ายคลึงกันของ 'out-of-core' pandas ได้เกิดขึ้นแล้ว: dask daskแม้ว่า dask จะไม่ใช่การแทนที่ของ pandas และฟังก์ชันการทำงานทั้งหมดของมันนั้นโดดเด่นด้วยเหตุผลหลายประการ:

Dask เป็นไลบรารีการคำนวณแบบขนานที่มีความยืดหยุ่นสำหรับการคำนวณเชิงวิเคราะห์ที่ปรับให้เหมาะสมสำหรับการจัดตารางงานแบบไดนามิกสำหรับปริมาณงานการคำนวณแบบโต้ตอบของคอลเลกชัน“ Big Data” เช่นอาร์เรย์แบบขนาน, dataframes และรายการที่ขยายอินเทอร์เฟซทั่วไปเช่น NumPy มากกว่าหน่วยความจำหรือสภาพแวดล้อมแบบกระจายและสเกลจากแล็ปท็อปไปยังกลุ่ม

Dask เน้นย้ำถึงคุณงามความดีต่อไปนี้:

• คุ้นเคย: จัดเตรียมอาร์เรย์ NumPy และออบเจ็กต์ Pandas DataFrame
• ยืดหยุ่น: จัดเตรียมอินเทอร์เฟซการจัดกำหนดการงานสำหรับปริมาณงานที่กำหนดเองและการรวมกับโครงการอื่น ๆ
• มาตรฐาน: เปิดใช้งานการคำนวณแบบกระจายใน Pure Python ด้วยการเข้าถึง PyData stack
• เร็ว: ทำงานด้วยค่าใช้จ่ายต่ำความหน่วงต่ำและการทำให้เป็นอนุกรมน้อยที่สุดที่จำเป็นสำหรับอัลกอริธึมเชิงตัวเลขที่รวดเร็ว
• เครื่องชั่ง: ทำงานอย่างยืดหยุ่นบนคลัสเตอร์ที่มีแกนหลัก 1000 แกนเครื่องชั่ง: ง่ายต่อการติดตั้งและใช้งานแล็ปท็อปในขั้นตอนเดียว
• การตอบสนอง: ออกแบบโดยคำนึงถึงการใช้คอมพิวเตอร์แบบโต้ตอบซึ่งจะให้ข้อเสนอแนะและการวินิจฉัยอย่างรวดเร็วเพื่อช่วยเหลือมนุษย์

และเพื่อเพิ่มตัวอย่างโค้ดแบบง่าย:

import dask.dataframe as dd
df = dd.read_csv('2015-*-*.csv')
df.groupby(df.user_id).value.mean().compute()

แทนที่รหัสแพนด้าบางอย่างเช่นนี้:

import pandas as pd
df = pd.read_csv('2015-01-01.csv')
df.groupby(df.user_id).value.mean()

และโดยเฉพาะอย่างยิ่งที่สำคัญให้ผ่านconcurrent.futuresอินเทอร์เฟซโครงสร้างพื้นฐานทั่วไปสำหรับการส่งงานที่กำหนดเอง:

from dask.distributed import Client
client = Client('scheduler:port')

futures = []
for fn in filenames:
    future = client.submit(load, fn)
    futures.append(future)

summary = client.submit(summarize, futures)
summary.result()

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

เพียงแทนที่การนำเข้าแพนด้าและรหัสควรทำงานตามที่เป็นอยู่:

# import pandas as pd
import ray.dataframe as pd

#use pd as usual

สามารถอ่านรายละเอียดเพิ่มเติมได้ที่นี่:

https://rise.cs.berkeley.edu/blog/pandas-on-ray/

อีกรูปแบบหนึ่ง

การดำเนินการหลายอย่างที่ทำในนุ่นยังสามารถทำได้เป็นเคียวรี db (sql, mongo)

การใช้ RDBMS หรือ mongodb ช่วยให้คุณสามารถทำการรวมบางอย่างใน DB Query (ซึ่งเหมาะสำหรับข้อมูลขนาดใหญ่และใช้แคชและดัชนีอย่างมีประสิทธิภาพ)

หลังจากนั้นคุณสามารถทำการโพสต์โดยใช้นุ่น

ข้อดีของวิธีนี้คือคุณได้รับการปรับ DB ให้เหมาะสมสำหรับการทำงานกับข้อมูลขนาดใหญ่ในขณะที่ยังคงนิยามตรรกะในรูปแบบการประกาศในระดับสูง - และไม่ต้องจัดการกับรายละเอียดของการตัดสินใจว่าจะทำอย่างไรในหน่วยความจำและสิ่งที่ต้องทำ ของแกน

และแม้ว่าภาษาคิวรีและแพนด้าจะแตกต่างกัน แต่ก็ไม่ซับซ้อนในการแปลส่วนของตรรกะจากภาษาหนึ่งเป็นภาษาอื่น

พิจารณาRuffusถ้าคุณใช้เส้นทางที่เรียบง่ายในการสร้างไปป์ไลน์ข้อมูลซึ่งแบ่งย่อยเป็นไฟล์ขนาดเล็กหลาย ๆ ไฟล์

ฉันเพิ่งเจอปัญหาที่คล้ายกัน ฉันพบว่าการอ่านข้อมูลเป็นชิ้น ๆ และต่อท้ายเมื่อฉันเขียนเป็นชิ้น ๆ ไปยัง csv เดียวกันก็ใช้งานได้ดี ปัญหาของฉันเพิ่มคอลัมน์วันที่ตามข้อมูลในตารางอื่นโดยใช้ค่าของคอลัมน์บางอย่างดังนี้ สิ่งนี้อาจช่วยให้ผู้ที่สับสนโดย dask และ hdf5 แต่คุ้นเคยกับหมีแพนด้าอย่างตัวฉันมากกว่า

def addDateColumn():
"""Adds time to the daily rainfall data. Reads the csv as chunks of 100k 
   rows at a time and outputs them, appending as needed, to a single csv. 
   Uses the column of the raster names to get the date.
"""
    df = pd.read_csv(pathlist[1]+"CHIRPS_tanz.csv", iterator=True, 
                     chunksize=100000) #read csv file as 100k chunks

    '''Do some stuff'''

    count = 1 #for indexing item in time list 
    for chunk in df: #for each 100k rows
        newtime = [] #empty list to append repeating times for different rows
        toiterate = chunk[chunk.columns[2]] #ID of raster nums to base time
        while count <= toiterate.max():
            for i in toiterate: 
                if i ==count:
                    newtime.append(newyears[count])
            count+=1
        print "Finished", str(chunknum), "chunks"
        chunk["time"] = newtime #create new column in dataframe based on time
        outname = "CHIRPS_tanz_time2.csv"
        #append each output to same csv, using no header
        chunk.to_csv(pathlist[2]+outname, mode='a', header=None, index=None)

ฉันต้องการจะชี้ให้เห็นแพคเกจ Vaex

Vaex เป็นห้องสมุดไพ ธ อนสำหรับ Data Out-of-Core แบบขี้เกียจ (คล้ายกับ Pandas) เพื่อให้เห็นภาพและสำรวจชุดข้อมูลขนาดใหญ่แบบตาราง มันสามารถคำนวณสถิติเช่นค่าเฉลี่ยผลรวมจำนวนส่วนเบี่ยงเบนมาตรฐานและอื่น ๆ บนกริด N-มิติได้ถึงวัตถุ / แถวหนึ่งพันล้าน (10 ⁹ ) ต่อวินาที การสร้างภาพนั้นทำได้โดยใช้ฮิสโตแกรมพล็อตความหนาแน่นและการเรนเดอร์ปริมาณ 3 มิติทำให้สามารถสำรวจข้อมูลขนาดใหญ่แบบโต้ตอบได้ Vaex ใช้การแมปหน่วยความจำนโยบายคัดลอกหน่วยความจำที่เป็นศูนย์และการคำนวณแบบขี้เกียจเพื่อประสิทธิภาพที่ดีที่สุด (ไม่มีการสูญเสียหน่วยความจำ)

ดูเอกสารประกอบ: https://vaex.readthedocs.io/en/latest/ API ใกล้เคียงกับ API ของแพนด้า

ทำไมต้องนุ่น คุณลองStandard Python แล้วหรือยัง

การใช้ไลบรารี่มาตรฐานของไพ ธ อน Pandas อยู่ภายใต้การอัปเดตเป็นประจำแม้จะเป็นเวอร์ชั่นที่เสถียรแล้วก็ตาม

การใช้ไลบรารีหลามมาตรฐานรหัสของคุณจะทำงานตลอดเวลา

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

คุณสามารถใช้ประโยชน์จาก:

• รายการพจนานุกรมเพื่อเก็บข้อมูลในหน่วยความจำหนึ่ง dict เป็นหนึ่งแถว
• เครื่องกำเนิดไฟฟ้าในการประมวลผลแถวข้อมูลหลังจากแถวเพื่อไม่ล้น RAM ของคุณ
• รายการความเข้าใจในการสืบค้นข้อมูลของคุณ
• ใช้ประโยชน์จาก Counter, DefaultDict, ...
• จัดเก็บข้อมูลของคุณบนฮาร์ดไดรฟ์ของคุณโดยใช้โซลูชันการจัดเก็บที่คุณเลือกไว้ json อาจเป็นหนึ่งในนั้น

หน่วยความจำและ HDD มีราคาถูกลงและราคาถูกลงด้วยเวลาและไพ ธ อนมาตรฐาน 3 มีให้เลือกใช้อย่างกว้างขวางและเสถียร

ในขณะนี้ฉันกำลังทำงาน "เหมือน" คุณอยู่ในระดับที่ต่ำกว่าซึ่งเป็นเหตุผลที่ฉันไม่มี PoC สำหรับคำแนะนำของฉัน

อย่างไรก็ตามฉันดูเหมือนจะประสบความสำเร็จในการใช้ pickle เป็นระบบแคชและการดำเนินการ outsourcing ของฟังก์ชั่นต่าง ๆ ให้เป็นไฟล์ - การเรียกใช้ไฟล์เหล่านี้จากคอมมานโด / ไฟล์หลักของฉัน ตัวอย่างเช่นฉันใช้ prepare_use.py เพื่อแปลงประเภทวัตถุแบ่งชุดข้อมูลเป็นการทดสอบตรวจสอบความถูกต้องและทำนายชุดข้อมูล

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

การใช้ฐานข้อมูลฉันพบปัญหาที่คล้ายกันซึ่งเป็นเหตุผลที่ฉันพบความปิติยินดีในการใช้โซลูชันนี้ - มีข้อ จำกัด มากมายอย่างแน่นอน - ตัวอย่างเช่นการเก็บชุดดองขนาดใหญ่เนื่องจากความซ้ำซ้อน การอัปเดตตารางจากก่อนถึงหลังการเปลี่ยนแปลงสามารถทำได้ด้วยการจัดทำดัชนีที่เหมาะสม - ข้อมูลการตรวจสอบจะเปิดหนังสือเล่มอื่นทั้งหมด (ฉันพยายามรวบรวมข้อมูลค่าเช่าที่รวบรวมข้อมูลแล้วและหยุดใช้ฐานข้อมูลหลังจาก 2 ชั่วโมงโดยทั่วไป - เพราะฉันอยากข้าม ทุกกระบวนการเปลี่ยนแปลง)

ฉันหวังว่า 2 เซนต์ของฉันจะช่วยคุณในทางใดทางหนึ่ง

ทักทาย.