“විශාල දත්ත” වැඩ පැන්ඩා භාවිතයෙන් ගලා යයි


1004

පැන්ඩා ඉගෙන ගන්නා අතරතුර මම මාස ගණනාවක් තිස්සේ මෙම ප්‍රශ්නයට පිළිතුරක් ලබා දීමට උත්සාහ කර ඇත්තෙමි. මගේ එදිනෙදා වැඩ සඳහා මම SAS භාවිතා කරන අතර එය බාහිරින් ලැබෙන සහයෝගය සඳහා විශිෂ්ටයි. කෙසේ වෙතත්, වෙනත් හේතු ගණනාවක් නිසා මෘදුකාංගයක් ලෙස SAS භයානක ය.

එක් දිනක් මම SAS භාවිතය පයිතන් සහ පැන්ඩා සමඟ ප්‍රතිස්ථාපනය කිරීමට බලාපොරොත්තු වෙමි, නමුත් දැනට විශාල දත්ත කට්ටල සඳහා මූලික කාර්ය ප්‍රවාහයක් මා සතුව නොමැත. මම කතා කරන්නේ බෙදා හරින ලද ජාලයක් අවශ්‍ය “විශාල දත්ත” ගැන නොව, මතකයට සරිලන තරම් විශාල ලිපිගොනු නමුත් දෘ hard තැටියකට සරිලන තරම් කුඩා ලිපිගොනු ය.

මගේ පළමු සිතුවිල්ල වන්නේ HDFStoreවිශාල දත්ත කට්ටල තැටියේ තබාගෙන විශ්ලේෂණය සඳහා මට අවශ්‍ය කොටස් පමණක් දත්ත රාමු තුළට ඇද ගැනීමයි. තවත් සමහරු මොන්ගෝ ඩීබී විකල්පයක් භාවිතා කිරීමට පහසු යැයි සඳහන් කර ඇත. මගේ ප්‍රශ්නය මෙයයි:

පහත සඳහන් දෑ ඉටු කිරීම සඳහා හොඳම-ප්‍රායෝගික වැඩ ප්‍රවාහයන් මොනවාද:

  1. පැතලි ලිපිගොනු ස්ථිර, තැටියේ දත්ත සමුදා ව්‍යුහයකට ප්‍රවේශනය කිරීම
  2. පැන්ඩාස් දත්ත ව්‍යුහයකට පෝෂණය කිරීම සඳහා දත්ත ලබා ගැනීම සඳහා එම දත්ත ගබඩාව විමසීම
  3. පැන්ඩා වල කෑලි හැසිරවීමෙන් පසු දත්ත සමුදාය යාවත්කාලීන කිරීම

තථ්‍ය-ලෝක උදාහරණ බොහෝ සෙයින් අගය කරනු ඇත, විශේෂයෙන් "විශාල දත්ත" මත පැන්ඩා භාවිතා කරන ඕනෑම අයෙකුගෙන්.

සංස්කරණය කරන්න - මෙය ක්‍රියාත්මක වීමට මා කැමති ආකාරය පිළිබඳ උදාහරණයක්:

  1. විශාල පැතලි ගොනුවක් ආනයනය කර ස්ථිර තැටියේ දත්ත සමුදා ව්‍යුහයක ගබඩා කරන්න. මෙම ලිපිගොනු සාමාන්‍යයෙන් මතකයට ගැළපෙන තරම් විශාලය.
  2. පැන්ඩා භාවිතා කිරීම සඳහා, මතකයට ගැලපෙන මෙම දත්තවල උප කුලක (සාමාන්‍යයෙන් වරකට තීරු කිහිපයක් පමණක්) කියවීමට මම කැමැත්තෙමි.
  3. තෝරාගත් තීරුවල විවිධ මෙහෙයුම් සිදු කිරීමෙන් මම නව තීරු නිර්මාණය කරමි.
  4. එවිට මට මෙම නව තීරු දත්ත සමුදා ව්‍යුහයට එකතු කිරීමට සිදුවේ.

මෙම පියවරයන් ඉටු කිරීම සඳහා හොඳම-ප්‍රායෝගික ක්‍රමයක් සොයා ගැනීමට මම උත්සාහ කරමි. පැන්ඩා සහ පයිටබල් පිළිබඳ සබැඳි කියවීමෙන් නව තීරුවක් එකතු කිරීම ගැටලුවක් විය හැකි බව පෙනේ.

සංස්කරණය කරන්න - ජෙෆ්ගේ ප්‍රශ්න වලට විශේෂයෙන් ප්‍රතිචාර දැක්වීම:

  1. මම පාරිභෝගික ණය අවදානම් ආකෘති ගොඩනඟමි. දත්ත වර්ග අතර දුරකථන, එස්එස්එන් සහ ලිපින ලක්ෂණ ඇතුළත් වේ; දේපල වටිනාකම්; අපරාධ වාර්තා, බංකොලොත්භාවය වැනි අපහාසාත්මක තොරතුරු ... මම සෑම දිනකම භාවිතා කරන දත්ත කට්ටලවල මිශ්‍ර දත්ත වර්ගවල සාමාන්‍යයෙන් ක්ෂේත්‍ර 1,000 සිට 2,000 දක්වා ප්‍රමාණයක් ඇත: සංඛ්‍යාත්මක හා චරිත දත්තවල අඛණ්ඩ, නාමික හා සාමාන්‍ය විචල්‍යයන්. මම කලාතුරකින් පේළි එකතු කරමි, නමුත් මම නව තීරු නිර්මාණය කරන බොහෝ මෙහෙයුම් සිදු කරමි.
  2. සාමාන්‍ය මෙහෙයුම් වලට කොන්දේසි සහිත තර්කනය භාවිතා කරමින් තීරු කිහිපයක් නව සංයුක්ත තීරුවකට ඒකාබද්ධ කිරීම ඇතුළත් වේ. උදාහරණයක් ලෙස , if var1 > 2 then newvar = 'A' elif var2 = 4 then newvar = 'B'. මෙම මෙහෙයුම්වල ප්‍රති result ලය මගේ දත්ත කට්ටලයේ සෑම වාර්තාවක් සඳහාම නව තීරුවකි.
  3. අවසාන වශයෙන්, මම මෙම නව තීරු තැටියේ දත්ත ව්‍යුහයට එකතු කිරීමට කැමැත්තෙමි. මම දෙවන පියවර නැවත කියමි, ක්‍රොස්ස්ටැබ් සහ විස්තරාත්මක සංඛ්‍යාලේඛන සමඟ දත්ත ගවේෂණය කරමින් ආකෘතියට සිත්ගන්නාසුළු, බුද්ධිමත් සම්බන්ධතා සොයා ගැනීමට උත්සාහ කරමි.
  4. සාමාන්‍ය ව්‍යාපෘති ගොනුවක් සාමාන්‍යයෙන් 1GB පමණ වේ. පේළි පාරිභෝගික දත්ත පිළිබඳ වාර්තාවකින් සමන්විත වන ආකාරයට ගොනු සංවිධානය කර ඇත. සෑම පේළියකටම සෑම වාර්තාවක් සඳහාම තීරු ගණනක් ඇත. මෙය සැමවිටම සිදුවනු ඇත.
  5. නව තීරුවක් සෑදීමේදී මම පේළි අනුව අනුභව කිරීම ඉතා කලාතුරකිනි. කෙසේ වෙතත්, වාර්තා නිර්මාණය කිරීමේදී හෝ විස්තරාත්මක සංඛ්‍යාලේඛන ජනනය කිරීමේදී පේළි අනුකොටස් කිරීම මට සාමාන්‍ය දෙයකි. උදාහරණයක් ලෙස, නිශ්චිත ව්‍යාපාරයක් සඳහා සරල සංඛ්‍යාතයක් නිර්මාණය කිරීමට මට අවශ්‍ය විය හැකි බව සිල්ලර ණය පත් පවසයි. මෙය සිදු කිරීම සඳහා, මම වාර්තා කිරීමට අවශ්‍ය කුමන තීරු වලට අමතරව ව්‍යාපාර රේඛාව = සිල්ලර වෙළඳාම යන රේඛා පමණක් තෝරා ගනිමි. කෙසේ වෙතත්, නව තීරු නිර්මාණය කිරීමේදී, මම සියලු දත්ත පේළි අදින්නෙමි, සහ මෙහෙයුම් සඳහා අවශ්‍ය තීරු පමණි.
  6. ආකෘති නිර්මාණ ක්‍රියාවලියට අවශ්‍ය වන්නේ මම සෑම තීරුවක්ම විශ්ලේෂණය කිරීම, යම් ප්‍රති come ල විචල්‍යයක් සමඟ සිත්ගන්නා සම්බන්ධතා සොයා බැලීම සහ එම සම්බන්ධතා විස්තර කරන නව සංයුක්ත තීරු නිර්මාණය කිරීමයි. මා ගවේෂණය කරන තීරු සාමාන්‍යයෙන් කුඩා කට්ටල වලින් සිදු කෙරේ. නිදසුනක් ලෙස, මම දේපල වටිනාකම් සමඟ කටයුතු කරන තීරු 20 ක කට්ටලයක් වෙත අවධානය යොමු කර ඒවා ණයක් පැහැර හැරීමට සම්බන්ධ වන ආකාරය නිරීක්ෂණය කරමි. ඒවා ගවේෂණය කර නව තීරු නිර්මාණය කළ පසු, මම තවත් තීරු සමූහයකට ගොස්, විද්‍යාල අධ්‍යාපනය යැයි කියමින්, ක්‍රියාවලිය නැවත කරමි. මා කරන්නේ මගේ දත්ත සහ යම් ප්‍රති come ල අතර සම්බන්ධතාවය පැහැදිලි කරන අපේක්ෂක විචල්‍යයන් නිර්මාණය කිරීමයි. මෙම ක්‍රියාවලිය අවසානයේදී, එම සංයුක්ත තීරුවලින් සමීකරණයක් නිර්මාණය කරන ඉගෙනුම් ක්‍රම කිහිපයක් මම භාවිතා කරමි.

මම කවදා හෝ දත්ත කට්ටලයට පේළි එකතු කිරීම කලාතුරකිනි. මම සෑම විටම පාහේ නව තීරු නිර්මාණය කරමි (සංඛ්‍යා ලේඛන / යන්ත්‍ර ඉගෙනීමේ උපභාෂා වල විචල්‍යයන් හෝ විශේෂාංග).


1
අනුපාතය හරයේ ප්‍රමාණය / සම්පූර්ණ ප්‍රමාණය 1%, 10% ද? එය වැදගත්ද - ඔබට තීරු int8 වෙත සම්පීඩනය කිරීමට හෝ is ෝෂාකාරී පේළි පෙරීමට හැකි නම්, එමඟින් ඔබේ ගණනය කිරීමේ චින්තනය පැය සිට මිනිත්තු දක්වා වෙනස් කළ හැකිද? (විශාල දත්ත ටැග් ද එක් කරන්න.)
ඩෙනිස්

1
Float64 වෙනුවට float32 සහ හැකි සෑම තැනකම int8 ගබඩා කිරීම සුළුපටු විය යුතුය (අභ්‍යන්තරව වුවද float64 කරන්නේ කුමන මෙවලම් / කාර්යයන් දැයි නොදනී)
denis

ඔබට ඔබේ කාර්යය වැඩ කොටස් වලට බෙදිය හැකිද?
ස්කොට් එවාන්ස්

1
මතකයට නොගැලපෙන "මධ්‍යම" දත්ත මත මෙහෙයුම් වැනි පැන්ඩා කිරීම සඳහා කදිම 2019 විසඳුම කාර්යයකි
lunguini

පයිතන් + පැන්ඩා සඳහා විකල්ප ඇත, ඔබ ආරම්භ කරන විට දැකීම සලකා බැලිය යුතුය. පයිතන් යනු පොදු අරමුණු සහිත ක්‍රමලේඛන භාෂාවක් (දත්ත සැකසීම සහ විශ්ලේෂණය සඳහා ඩීඑස්එල් නොවේ) සහ පැන්ඩා යනු ඊට ඉහළින් ඇති පුස්තකාලයකි. මම R හෝ kdb දෙස බැලීමට සලකා බලමි.
හෙන්රි හෙන්රින්සන්

Answers:


634

මම සාමාන්‍යයෙන් ගිගාබයිට් දස දහස් ගණනක් මෙම විලාසිතාවේ භාවිතා කරමි. උදා: මම තැටි මත වගු විමසීම් හරහා කියවා, දත්ත නිර්මාණය කර නැවත එකතු කරමි.

කියවීම එය වටිනා මෙම ලේඛන හා මෙම නූල් ප්රමාද ඔබගේ දත්ත ගබඩා කිරීම සඳහා වූ යෝජනා කිහිපයක් සඳහා.

ඔබේ දත්ත ගබඩා කරන ආකාරය කෙරෙහි බලපාන විස්තර, වැනි:
ඔබට හැකි තරම් විස්තර දෙන්න; ව්‍යුහයක් සංවර්ධනය කිරීමට මට ඔබට උදව් කළ හැකිය.

  1. දත්ත ප්‍රමාණය, # පේළි, තීරු, තීරු වර්ග; ඔබ පේළි එකතු කරනවාද, නැතහොත් තීරු පමණක්ද?
  2. සාමාන්‍ය මෙහෙයුම් මොන වගේද? උදා: පේළි සහ විශේෂිත තීරු පොකුරක් තෝරා ගැනීමට තීරු පිළිබඳ විමසුමක් කරන්න, ඉන්පසු මෙහෙයුමක් කරන්න (මතකයේ), නව තීරු සාදන්න, මේවා සුරකින්න.
    (සෙල්ලම් උදාහරණයක් ලබා දීමෙන් වඩාත් නිශ්චිත නිර්දේශ ඉදිරිපත් කිරීමට අපට හැකි වේ.)
  3. එම සැකසීමෙන් පසු ඔබ කරන්නේ කුමක්ද? දෙවන පියවර තාවකාලිකද, නැතහොත් නැවත නැවත කළ හැකිද?
  4. පැතලි ලිපිගොනු ආදානය කරන්න: Gb හි මුළු ප්‍රමාණය දළ වශයෙන්. උදාහරණ ලෙස මේවා සංවිධානාත්මක වන්නේ කෙසේද? සෑම එකක්ම විවිධ ක්ෂේත්‍ර අඩංගුද, නැතහොත් එක් එක් ගොනුවේ සියලුම ක්ෂේත්‍ර සමඟ එක් ගොනුවකට වාර්තා කිහිපයක් තිබේද?
  5. ඔබ කවදා හෝ නිර්ණායක මත පදනම්ව පේළි (වාර්තා) උප කුලක තෝරාගෙන තිබේද (උදා: A> 5 ක්ෂේත්‍රය සහිත පේළි තෝරන්න)? ඉන්පසු යමක් කරන්න, නැතහොත් ඔබ සියලු වාර්තා සමඟ A, B, C යන ක්ෂේත්‍ර තෝරා ගන්නේද (පසුව යමක් කරන්න)?
  6. ඔබ ඔබේ සියලු තීරු (කණ්ඩායම් වශයෙන්) 'වැඩ කරනවාද' නැතහොත් වාර්තා සඳහා පමණක් භාවිතා කළ හැකි හොඳ අනුපාතයක් තිබේද (උදා: ඔබට දත්ත අවට තබා ගැනීමට අවශ්‍යය, නමුත් එම තීරුවේ පැහැදිළි බව ඇද ගන්නා තෙක් අවසාන ප්‍රති results ල කාලය)?

විසඳුමක්

ඔබ අවම වශයෙන් පැන්ඩා0.10.1 ස්ථාපනය කර ඇති බවට සහතික වන්න .

නැවත සැකසීමේ ලිපිගොනු කියවන්න -කුට්ටි-චන්ක් සහ බහු වගු විමසුම් .

පයිටබල් පේළි අනුව ක්‍රියාත්මක වීමට ප්‍රශස්තිකරණය කර ඇති හෙයින් (ඔබ විමසන්නේ එයයි), අපි එක් එක් ක්ෂේත්‍ර කාණ්ඩ සඳහා වගුවක් සාදන්නෙමු. මේ ආකාරයෙන් කුඩා ක්ෂේත්‍ර සමූහයක් තෝරා ගැනීම පහසුය (එය විශාල වගුවක් සමඟ ක්‍රියා කරනු ඇත, නමුත් එය මේ ආකාරයෙන් කිරීම වඩාත් කාර්යක්ෂම වේ ... අනාගතයේදී මෙම සීමාව නිවැරදි කිරීමට මට හැකි වනු ඇතැයි මම සිතමි ... මෙය කෙසේ වෙතත් වඩාත් බුද්ධිමත්):
(පහත දැක්වෙන්නේ ව්‍යාජ කේතයයි.)

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)

දත්ත_ තීරු ගැන, ඔබට ඇත්ත වශයෙන්ම කිසිදු දත්ත_ තීරුවක් අර්ථ දැක්වීමට අවශ්‍ය නොවේ ; තීරුව මත පදනම්ව පේළි උප-තේරීමට ඒවා ඔබට ඉඩ දෙයි. උදා වැනි දෙයක්:

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

අවසාන වාර්තා උත්පාදනය කිරීමේ අවධියේදී ඒවා ඔබට වඩාත් සිත්ගන්නා සුළු විය හැකිය (මූලික වශයෙන් දත්ත තීරුවක් වෙනත් තීරුවලින් වෙන් කොට ඇත, එය ඔබ බොහෝ දේ අර්ථ දැක්වුවහොත් කාර්යක්ෂමතාවයට තරමක් බලපානු ඇත).

ඔබටත් අවශ්‍ය විය හැකිය:

  • ක්ෂේත්‍ර ලැයිස්තුවක් ගන්නා, කණ්ඩායම්_ සිතියමේ ඇති කණ්ඩායම් දෙස බලා, පසුව මේවා තෝරාගෙන ප්‍රති results ල සමපාත වන පරිදි ශ්‍රිතයක් සාදන්න, එවිට ඔබට ලැබෙන රාමුව ලැබෙනු ඇත (මෙය අත්‍යවශ්‍යයෙන්ම select_as_multiple කරන්නේ). මේ ආකාරයෙන් ව්‍යුහය ඔබට විනිවිද පෙනෙන වනු ඇත.
  • ඇතැම් දත්ත තීරුවල දර්ශක (පේළි-උප කුලක වේගවත් කරයි).
  • සම්පීඩනය සක්‍රීය කරන්න.

ඔබට ප්‍රශ්න ඇති විට මට දන්වන්න!


5
සබැඳි වලට ස්තූතියි. HDFStore හි ඇති වගු වලට නව තීරු එකතු කිරීමට නොහැකි වීම ගැන දෙවන සබැඳිය මට ටිකක් කරදර කරයි? ඒක හරිද? එසේම, මම මෙම සැකසුම භාවිතා කරන්නේ කෙසේද යන්න පිළිබඳ උදාහරණයක් එකතු කළෙමි.
Zelazny7

5
HDF හි සත්‍ය ව්‍යුහය ඔබට භාරයි. පයිටේබල්ස් පේළි දිශානත වන අතර නිර්මාණය කරන අවස්ථාවේ ස්ථාවර තීරු ඇත. වගුවක් සෑදූ පසු ඔබට තීරු එකතු කළ නොහැක. කෙසේ වෙතත්, ඔබට දැනට පවතින වගුවට සමාන සුචිගත කළ නව වගුවක් සෑදිය හැකිය. (ලේඛයේ ඇති select_as_multiple උදාහරණ බලන්න). මේ ආකාරයෙන් ඔබට කාර්යක්ෂම විමසීම් තිබියදී අත්තනෝමතික ප්‍රමාණයේ වස්තු නිර්මාණය කළ හැකිය. ඔබ දත්ත භාවිතා කරන ආකාරය තැටියේ සංවිධානය කළ යුතු ආකාරය සඳහා යතුරයි. වඩාත් නිශ්චිත උදාහරණයක ව්‍යාජ කේතයක් සහිත ලැයිස්තුගත ඊ-තැපෑලක් මට එවන්න.
ජෙෆ්

1
ඔබගේ සවිස්තරාත්මක කරුණු වලට ප්‍රතිචාර දැක්වීම සඳහා මම මගේ ප්‍රශ්නය යාවත්කාලීන කර ඇත. ඔබට ලැයිස්තුවක් යැවීමට මම උදාහරණයක් මත වැඩ කරමි. ස්තූතියි!
Zelazny7

12
E ජෙෆ්, පණ්ඩස් 0.17.x හි සිටීමත් සමඟ, ඉහත දක්වා ඇති ගැටළු පැන්ඩාස් හි විසඳා තිබේද?
ctrl-alt-delete

5
Answer කාර්යය ප්‍රවර්ධනය කිරීම සඳහා ඔබේ පිළිතුරට ඉක්මන් යාවත්කාලීන කිරීමක් කිරීමට ජෙෆ් කැමතිද?
Boud

143

මම හිතන්නේ ඉහත පිළිතුරු සඳහා මට ඉතා ප්‍රයෝජනවත් වූ සරල ප්‍රවේශයක් නොමැත.

මතකයේ පැටවීමට නොහැකි තරම් විශාල ගොනුවක් මා සතුව ඇති විට, මම ගොනුව කුඩා ගොනු කිහිපයකට බෙදමි (පේළි හෝ තීරු අනුව)

උදාහරණය: 30 30GB ප්‍රමාණයේ වෙළඳ දත්ත දින 30 ක් වටිනා නම්, මම එය දිනකට ~ 1GB ප්‍රමාණයේ ගොනුවකට කඩා දමමි. මම පසුව එක් එක් ගොනුව වෙන වෙනම සකසා අවසානයේ ප්‍රති results ල ලබා ගනිමි

විශාලතම වාසියක් වන්නේ එය ගොනු සමාන්තරව සැකසීමට ඉඩ දීමයි (බහු නූල් හෝ ක්‍රියාවලි)

අනෙක් වාසිය නම්, ගොනු හැසිරවීම (උදාහරණයේ දිනයන් එකතු කිරීම / ඉවත් කිරීම වැනි) සාමාන්‍ය ෂෙල් විධාන මඟින් ඉටු කළ හැකි අතර එය වඩා දියුණු / සංකීර්ණ ගොනු ආකෘති වල කළ නොහැකි ය.

මෙම ප්‍රවේශය සියලු අවස්ථා ආවරණය නොකරයි, නමුත් ඒවායින් බොහොමයකට එය ඉතා ප්‍රයෝජනවත් වේ



86

ප්‍රශ්නයට වසර දෙකකට පසුව, 'හරයෙන් පිටත' පැන්ඩා සමාන වේ: කාර්යය . එය විශිෂ්ටයි! එය සියලු පැන්ඩා ක්‍රියාකාරිත්වයට සහය නොදක්වුවද, ඔබට එය සමඟ බොහෝ දුරට යා හැකිය.


6
සහ කාර්යයන් සමඟ සම්පුර්ණයෙන්ම සකස් කළ උදාහරණයක් සඳහා, මෙහි බලන්න stackoverflow.com/questions/37979167/…
ℕʘʘḆḽḘ

ඔබේ දත්ත මත පදනම්ව පයිස්ටෝරය දෙස බැලීම අර්ථවත් කරයි. එය රඳා පවතී dask.
gies0r

1
එය සැමවිටම "හරයෙන් පිටත" තිබේද? (එනම් RAM තීව්‍ර නොවේද?). ඔබ ළඟ පොකුරු නොමැති නම්, කාර්යය හොඳ විසඳුමක් නොවේ, IMHO. කාර්ය ලේඛනයෙන් උපුටා දැක්වීම : "ඔබ ටෙරාබයිට් හෝ ඊට අඩු ටැබුලර් CSV හෝ JSON දත්ත කළමනාකරණය කිරීමට බලාපොරොත්තු වන්නේ නම්, ඔබ ස්පාර්ක් සහ කාර්ය දෙකම අමතක කර පෝස්ට්ග්‍රෙස් හෝ මොන්ගෝ ඩීබී භාවිතා කළ යුතුය."
මිෂෙල් පිකොලිනි

65

ඔබේ දත්ත කට්ටල 1 සහ 20GB අතර නම්, ඔබට 48GB RAM සහිත වැඩපොළක් ලබා ගත යුතුය. එවිට පැන්ඩස්ට මුළු දත්ත කට්ටලයම RAM තුළ තබා ගත හැකිය. එහි ඇති පිළිතුර ඔබ මෙහි සොයන පිළිතුර නොවන බව මම දනිමි, නමුත් 4GB RAM සහිත නෝට්බුක් පරිගණකයක විද්‍යාත්මක පරිගණක කිරීම සාධාරණ නොවේ.


7
"4GB RAM සහිත නෝට්බුක් පරිගණකයක විද්‍යාත්මක පරිගණක කිරීම සාධාරණ නොවේ" සාධාරණ ලෙස අර්ථ දක්වන්න. මම හිතන්නේ යුනිවැක් වෙනස් මතයක් ගනීවි. arstechnica.com/tech-policy/2011/09/…
grisaitis

2
එකඟ විය! මතකයේ ඉදිරියෙන් වැය වුවද එය දිගටම කරගෙන යාමට උත්සාහ කරන්න. ඔබේ කාර්යය මූල්‍යමය ප්‍රතිලාභයකට මඟ පාදන්නේ නම්, කාලයත් සමඟ, ඔබ වැඩි කළ කාර්යක්ෂමතාවයෙන් වියදම් නැවත ලබා ගනී.
ansonw

2
48GB RAM සහිත වැඩපොළක විද්‍යාත්මක පරිගණක කිරීම සාධාරණ නොවේ.
යාරොස්ලාව් නිකිටෙන්කෝ

4
@YaroslavNikitenko 61GB / RAM සහිත r4.2xlarge පැයකට ඩොලර් .532 කි. එය එතරම් වටිනා නොවන විද්‍යාත්මක පරිගණකයක් ඔබ කරන්නේ කුමක්ද? අසාමාන්‍ය නොවේ නම් අසාමාන්‍යයි.
rjurney

4
අර්ජර්නි කණගාටුයි, සමහර විට මම මගේ අදහස මකා දැමිය යුතුව තිබුණි. “අසාධාරණ” විද්‍යාත්මක පරිගණකය පිළිබඳ ඔබේ තීන්දුව ඉතා ආත්මීය බව පෙනේ. මම වසර ගණනාවක් ලැප්ටොප් පරිගණකවල විද්‍යාත්මක ගණනය කිරීම් සිදු කරන අතර එය මට ප්‍රමාණවත් බව පෙනේ, මන්ද බොහෝ විට මම කේත ලියමි. මගේ ඇල්ගොරිතම පරිගණකමය දෘෂ්ටි කෝණයෙන් වඩා ක්‍රමලේඛන දෘෂ්ටි කෝණයෙන් වඩා දුෂ්කර ය. පරිමාණ කළ හැකි ඇල්ගොරිතම ලිවීමට යමෙකු වර්තමාන දෘඩාංග සීමාවන් මත විශ්වාසය නොතැබිය යුතු බව මට හොඳටම විශ්වාසයි. වෙනත් පුද්ගලයින්ගේ පරිගණකකරණය පිළිබඳ ඔබේ අදහස තරමක් අහිතකර යැයි සිතිය හැකිය (ආත්මීයත්වයට අමතරව), මෙම වචන ස්වල්පයක් මකා දැමීමට ඔබට අවශ්‍යද?
යාරොස්ලාව් නිකිටෙන්කෝ

59

මෙය පැරණි නූලක් බව මම දනිමි, නමුත් මම සිතන්නේ බ්ලේස් පුස්තකාලය පරීක්ෂා කිරීම වටී. එය ගොඩනඟා ඇත්තේ මෙම ආකාරයේ තත්වයන් සඳහා ය.

ලියකියවිලි වලින්:

බෙදා හරින ලද සහ පිටත ඇති පරිගණක සඳහා NumPy සහ Pandas භාවිතා කිරීමේ හැකියාව බ්ලේස් විසින් පුළුල් කරයි. බ්ලේස් NumPy ND-Array හෝ Pandas DataFrame හා සමාන අතුරු මුහුණතක් සපයන නමුත් මෙම හුරුපුරුදු අතුරුමුහුණත් Postgres හෝ Spark වැනි වෙනත් පරිගණක එන්ජින් සමඟ සිතියම් ගත කරයි.

සංස්කරණය කරන්න: මාර්ගය වන විට, එයට නියුම්පයි හි කර්තෘ කොන්ටිනියම් අයිඕ සහ ට්‍රැවිස් ඔලිෆන්ට් සහාය දක්වයි.


බැලීමට වටින තවත් පුස්තකාලයක් වන්නේ ග්‍රැෆ්ලැබ් සාදන්න: එය කාර්යක්ෂම දත්ත රාමුවක් වැනි ව්‍යුහයක් ඇති අතර එය මතක ධාරිතාවෙන් සීමා නොවේ. blog.dato.com/…
ජල ආරක්ෂිත

52

පයිමොන්ගෝ සඳහා තත්වය මෙයයි. මම පයිතන් හි SQL සේවාදායකය, sqlite, HDF, ORM (SQLAlchemy) භාවිතා කරමින් මූලාකෘති ගත කර ඇත. පළමු හා ප්‍රධානතම පයිමොන්ගෝ යනු ලේඛන පදනම් කරගත් ඩීබී ය, එබැවින් සෑම පුද්ගලයෙකුම ලේඛනයක් වනු ඇත ( dictගුණාංග). බොහෝ අය එකතුවක් සාදන අතර ඔබට බොහෝ එකතු කිරීම් (පුද්ගලයින්, කොටස් වෙළඳපොල, ආදායම) තිබිය හැකිය.

pd.dateframe -> pymongo සටහන: මම භාවිතා chunksizeදී read_csv5 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ලේඛන සාදන විට සොයා බලන්න.

දැන් ඔබට පුද්ගලයෙකු වටා හොඳ දත්ත කට්ටලයක් ඇත, ඔබට එක් එක් සිද්ධිය පිළිබඳ ඔබේ තර්කනය මුදා හැර තවත් ගුණාංග ඇති කළ හැකිය. අවසාන වශයෙන් ඔබට පැන්ඩා 3 සිට මතක උපරිම යතුරු දර්ශක දක්වා කියවිය හැකි අතර pivots / agg / data ගවේෂණය කරන්න. අංක / විශාල පෙළ / කාණ්ඩ / කේත / පාවෙන / සහිත වාර්තා මිලියන 3 ක් සඳහා මෙය මට වැඩ කරයි.

ඔබට මොන්ගෝ ඩීබී (MapReduce සහ සමස්ත රාමුව) තුළට සාදන ලද ක්‍රම දෙක භාවිතා කළ හැකිය. MapReduce වලට වඩා පහසු බව පෙනෙන නිසාත්, ඉක්මන් සමස්ථ වැඩ සඳහා පහසු යැයි පෙනෙන නිසාත්, සමස්ත රාමුව පිළිබඳ වැඩි විස්තර සඳහා මෙහි බලන්න . මගේ ක්ෂේත්‍ර හෝ සම්බන්ධතා නිර්වචනය කිරීමට මට අවශ්‍ය නොවූ බව සලකන්න, මට ලේඛනයකට අයිතම එකතු කළ හැකිය. වේගයෙන් වෙනස් වන අංක, පැන්ඩා, පයිතන් මෙවලම් කට්ටලයේ වර්තමාන තත්වය අනුව, මොන්ගෝ ඩීබී මට වැඩට යාමට උපකාරී වේ :)


හායි, මම ඔබේ උදාහරණය සමඟ සෙල්ලම් කරමින් සිටින අතර දත්ත සමුදායකට ඇතුළු කිරීමට උත්සාහ කරන විට මම මෙම දෝෂයට මුහුණ දෙමි : In [96]: test.insert((a[1].to_dict() for a in df.iterrows())) --------------- InvalidDocument: Cannot encode object: 0. වැරදි විය හැකි අදහස් තිබේද? මගේ දත්ත රාමුව සියලු int64 dtypes වලින් සමන්විත වන අතර එය ඉතා සරල ය.
Zelazny7

2
ඔව්, මම සරල පරාසයක ඩීඑෆ් සඳහාද එසේ කළ අතර අංකයෙන් එන int64 පයිමොන්ගෝට කරදර කරන බවක් පෙනේ. CSV වෙතින් පරිවර්තනය කළ අය සමඟ මා සෙල්ලම් කළ සියලුම දත්ත (කෘතිමව පරාසය () හරහා එදිරිව) සහ දිගු වර්ග ඇති අතර එබැවින් ගැටළු නොමැත. සංඛ්‍යාත්මකව ඔබට පරිවර්තනය කළ හැකි නමුත් මම එය දකිනු ඇත. HDF සඳහා අයිතම 10.1 ආකර්ෂණීය බව මම පිළිගත යුතුය.
brian_the_bungler

43

මම මෙය ටිකක් ප්‍රමාද වී ඇති බව දුටුවෙමි, නමුත් මම සමාන ගැටළුවක් සමඟ කටයුතු කරමි (උකස් පෙරගෙවුම් ආකෘති). මගේ විසඳුම වී ඇත්තේ පැන්ඩා 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)

දැන්, මම සාමාන්‍යයෙන් මෙය ටොන් ගණනක මතකයක් සහිත යන්ත්‍රයක් මත ධාවනය කරමි, එබැවින් මගේ මතක භාවිතය ගැන මම සැලකිලිමත් නොවෙමි. උදාහරණයක් ලෙස, පෙරනිමියෙන් පැටවීමේ ක්‍රියාවලිය සමස්ත දත්ත කට්ටලයම කියවයි.

මෙය සාමාන්‍යයෙන් මට වැඩ කරයි, නමුත් එය තරමක් අවුල් සහගතය, මට විසිතුරු පයිටබල් මැජික් භාවිතා කළ නොහැක.

සංස්කරණය කරන්න: මෙම ප්‍රවේශයේ සැබෑ වාසිය නම්, පයිටේබල් පෙරනිමියෙන්, මට වගු හැසිරවිය නොහැකි h5r භාවිතයෙන් දත්ත R වෙත පැටවිය හැකි වීමයි. නැතහොත්, අවම වශයෙන්, විෂමජාතීය වගු පැටවීම සඳහා එය ලබා ගැනීමට මට නොහැකි විය.


ඔබේ කේත කිහිපයක් මා සමඟ බෙදා ගැනීමට ඔබ කැමතිද? පයිටබල් වෙත තල්ලු කිරීමට පෙර දත්ත වර්ග නොදැන ඔබ යම් පැතලි පෙළ ආකෘතියකින් දත්ත පටවන ආකාරය ගැන මම උනන්දු වෙමි. එසේම, ඔබ වැඩ කරන්නේ එක් වර්ගයක දත්ත සමඟ පමණක් බව පෙනේ. ඒක හරිද?
Zelazny7

1
පළමුවෙන්ම, දත්ත වලින් අනුමාන කිරීමට උත්සාහ කරනවාට වඩා, පැටවීමට පෙර තීරු වර්ග මා දන්නා බව උපකල්පනය කරමි. මම තීරු නම් සහ වර්ග සමඟ JSON "දත්ත පිරිවිතර" ගොනුවක් සුරකින අතර දත්ත සැකසීමේදී එය භාවිතා කරමි. (ගොනුව සාමාන්‍යයෙන් කිසිදු ලේබලයකින් තොරව භයානක BCP ප්‍රතිදානයකි.) මා භාවිතා කරන දත්ත වර්ග වන්නේ නූල්, පාවෙන, නිඛිල හෝ මාසික දිනයන් ය. ගණන් කිරීමේ වගුවක් සුරැකීමෙන් මම නූල් තීන්ත බවට හරවා දිනයන් අඟල් බවට පරිවර්තනය කරමි (2000 ට පසු මාස), එබැවින් මගේ දත්තවල අඟල් සහ පාවීම් සහ ගණන් කිරීම ඉතිරිව ඇත. මම දැන් පාවෙන float64 ලෙස සුරකිමි, නමුත් මම float32 සමඟ අත්හදා බැලුවෙමි.
ජොහාන් හිබ්ෂ්මන්

1
ඔබට කාලය ඇති නම්, වේදනාවක් දැනුණේ මේ ආර් බාහිර compat සඳහා උත්සහ කරලා බලන්න: pandas.pydata.org/pandas-docs/dev/... , ඔබ අපහසුතා ඇති නම්, සමහර විට අපි එය tweak හැකි
ජෙෆ්

මට හැකි නම් මම උත්සාහ කරමි. rhdf5 යනු H5r වැනි CRAN හි සිටීම වෙනුවට එය ජෛව සන්නායක පැකේජයක් බැවින් වේදනාවකි. මම අපගේ තාක්ෂණික ගෘහ නිර්මාණ කණ්ඩායමේ අනුකම්පාවෙන් පසුවන අතර, අවසන් වරට මම එය ඉල්ලූ විට rhdf5 සමඟ යම් ගැටළුවක් ඇතිවිය. කෙසේ වෙතත්, OLAP වෙළඳසැලක් සමඟ තීරු-දිශානතියට වඩා පේළි දිශානතියට යාම වැරැද්දක් සේ පෙනේ, නමුත් දැන් මම දඟලමි.
ජොහාන් හිබ්ෂ්මන්

43

විශාල දත්ත භාවිතා කිරීමේ අවස්ථා සඳහා මට ප්‍රයෝජනවත් වූ එක් උපක්‍රමයක් නම්, පාවෙන නිරවද්‍යතාවය බිට් 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

30

අනෙක් අය සඳහන් කළ පරිදි, වසර කිහිපයකට පසු 'හරයෙන් පිටත' පැන්ඩා සමානකමක් මතු වී ඇත: කාර්යය . පැන්ඩා සහ එහි ක්‍රියාකාරීත්වය වෙනුවට ආදේශ කිරීම අතහැර දැමීමක් නොවුවත් එය හේතු කිහිපයක් නිසා කැපී පෙනේ.

කාර්යය යනු විශ්ලේෂණාත්මක පරිගණකකරණය සඳහා නම්යශීලී සමාන්තර පරිගණක පුස්තකාලයක් වන අතර එය සමාන්තර අරා, දත්ත රාමු, සහ NumPy, Pandas, හෝ Python iterator වැනි පොදු අතුරුමුහුණත් විශාල දක්වා විහිදෙන සමාන්තර අරා, දත්ත රාමු සහ ලැයිස්තු වැනි “බිග් දත්ත” එකතුවෙහි අන්තර්ක්‍රියාකාරී පරිගණක කාර්ය භාරයන් සඳහා ගතික කාර්ය කාලසටහන් සඳහා ප්‍රශස්තිකරණය කර ඇත. මතකයට වඩා හෝ බෙදා හරින ලද පරිසරයන් සහ ලැප්ටොප් පරිගණකවල සිට පොකුරු දක්වා පරිමාණයන්.

කාර්යය පහත සඳහන් ගුණාංග අවධාරණය කරයි:

  • හුරුපුරුදු: සමාන්තරගත NumPy අරාව සහ Pandas DataFrame වස්තු සපයයි
  • නම්‍යශීලි: වැඩි අභිරුචි වැඩ බරක් සහ වෙනත් ව්‍යාපෘති සමඟ ඒකාබද්ධ කිරීම සඳහා කාර්ය කාලසටහන් අතුරු මුහුණතක් සපයයි.
  • ස්වදේශීය: PyData තොගයට ප්‍රවේශය ඇති පිරිසිදු පයිතන් හි බෙදා හරින ලද පරිගණකකරණය සක්‍රීය කරන්න.
  • වේගවත්: වේගවත් සංඛ්‍යාත්මක ඇල්ගොරිතම සඳහා අවශ්‍ය අඩු පිරිවැය, අඩු ප්‍රමාදය සහ අවම අනුක්‍රමිකකරණය සමඟ ක්‍රියාත්මක වේ
  • පරිමාණයන් ඉහළට: කෝර් 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()

අන්තර්ගතය සහ දිග සඳහා මකාදැමීමේ ලැයිස්තුවේ rivate පුද්ගලික තනතුර නිරන්තරයෙන් පෙන්වන බැවින් මම මෙම පිළිතුර එක් කළෙමි.
wp78de

17

තවත් එක් විචලනයකි

පැන්ඩා වල සිදුකරන බොහෝ මෙහෙයුම් db විමසුමක් ලෙසද කළ හැකිය (වර්ග, මොන්ගෝ)

RDBMS හෝ mongodb භාවිතා කිරීමෙන් DB විමසුමේ සමහර එකතුවක් සිදු කිරීමට ඔබට ඉඩ සලසයි (එය විශාල දත්ත සඳහා ප්‍රශස්තිකරණය කර ඇති අතර හැඹිලි සහ දර්ශක කාර්යක්ෂමව භාවිතා කරයි)

පසුව, ඔබට පැන්ඩා භාවිතයෙන් පසු සැකසුම් සිදු කළ හැකිය.

මෙම ක්‍රමයේ ඇති වාසිය නම්, ඉහළ මට්ටමේ ප්‍රකාශන වාක්‍ය ඛණ්ඩයක තර්කනය නිර්වචනය කරන අතරම, විශාල දත්ත සමඟ වැඩ කිරීම සඳහා ඔබ ඩීබී ප්‍රශස්තිකරණය ලබා ගැනීමයි - සහ මතකයේ කුමක් කළ යුතුද සහ කුමක් කළ යුතුද යන්න තීරණය කිරීමේ විස්තර සමඟ කටයුතු නොකිරීම හරයේ.

විමසුම් භාෂාව සහ පැන්ඩා එකිනෙකට වෙනස් වුවත්, සාමාන්‍යයෙන් තර්කනයේ කොටසක් එකිනෙකාගෙන් පරිවර්තනය කිරීම සංකීර්ණ නොවේ.


17

රේ ගැනත් මෙහි සඳහන් කිරීම වටී ,
එය බෙදා හරින ලද ගණනය කිරීමේ රාමුවක් වන අතර එය පැන්ඩා සඳහා බෙදා හරින ලද ආකාරයකින් ක්‍රියාත්මක කරයි.

පැන්ඩා ආනයනය ප්‍රතිස්ථාපනය කරන්න, එවිට කේතය ක්‍රියාත්මක විය යුත්තේ:

# import pandas as pd
import ray.dataframe as pd

#use pd as usual

වැඩි විස්තර මෙතැනින් කියවිය හැකිය:

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


11

කුඩා නල කිහිපයකට බෙදී ඇති දත්ත නල මාර්ගයක් නිර්මාණය කිරීමේ සරල මාවතකට ඔබ යන්නේ නම් රෆස් ගැන සලකා බලන්න .


9

මට මෑතකදී ඒ හා සමාන ප්‍රශ්නයක් හමු විය. මම හුදෙක් කුට්ටි වල දත්ත කියවා එය එකම සීඑස්වී වෙත කුට්ටි වලින් ලියන විට එය එකතු කිරීම හොඳින් ක්‍රියාත්මක වන බව මට පෙනී ගියේය. මගේ ගැටළුව වූයේ වෙනත් වගුවක තොරතුරු මත පදනම්ව දින තීරුවක් එක් කිරීම, ඇතැම් තීරුවල වටිනාකම පහත පරිදි භාවිතා කිරීමයි. මෙය 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)

9

මම Vaex පැකේජය පෙන්වා දීමට කැමතියි.

Vaex යනු විශාල වගු දත්ත කට්ටල දෘශ්‍යමාන කිරීම සහ ගවේෂණය කිරීම සඳහා කම්මැලි පිටත දත්ත රාමු (පැන්ඩා වලට සමාන) සඳහා වන පයිතන් පුස්තකාලයකි. තත්පරයට වස්තු / පේළි බිලියනයක් (10 9 ) දක්වා එන්-මාන ජාලයකට මධ්‍යන්‍ය, එකතුව, ගණන් කිරීම, සම්මත අපගමනය වැනි සංඛ්‍යා ලේඛන ගණනය කළ හැකිය . දෘශ්‍යකරණය සිදු කරනු ලබන්නේ හිස්ටෝග්‍රෑම්, dens නත්ව බිම් සහ 3 ඩී පරිමාව විදැහුම්කරණයෙනි, විශාල දත්ත අන්තර්ක්‍රියාකාරී ගවේෂණයකට ඉඩ දෙයි. හොඳම ක්‍රියාකාරිත්වය සඳහා Vaex මතක සිතියම්කරණය, ශුන්‍ය මතක පිටපත් ප්‍රතිපත්තිය සහ කම්මැලි ගණනය කිරීම් භාවිතා කරයි (මතකය නාස්ති නොවේ).

ප්‍රලේඛනය දෙස බලන්න: https://vaex.readthedocs.io/en/latest/ API පැන්ඩා වල API ට ඉතා ආසන්නයි.


0

ඇයි පණ්ඩස්? ඔබ ස්ටෑන්ඩර්ඩ් පයිතන් උත්සාහ කර තිබේද?

සම්මත පුස්තකාල පයිතන් භාවිතය. මෑතදී ස්ථාවර අනුවාදය නිකුත් කිරීමත් සමඟ පැන්ඩාස් නිතර යාවත්කාලීන කිරීම් වලට භාජනය වේ.

සම්මත පයිතන් පුස්තකාලය භාවිතා කිරීමෙන් ඔබේ කේතය සැමවිටම ක්‍රියාත්මක වේ.

එය කළ හැකි එක් ක්‍රමයක් නම්, ඔබේ දත්ත ගබඩා කර තබා ගැනීමට ඔබට අවශ්‍ය ආකාරය සහ දත්ත සම්බන්ධයෙන් ඔබට විසඳිය යුතු ප්‍රශ්න පිළිබඳ අදහසක් තිබීමයි. ඉන්පසු ඔබේ දත්ත සංවිධානය කරන්නේ කෙසේද යන්න පිළිබඳ යෝජනා ක්‍රමයක් අඳින්න (සිතියම් සිතන්න) එය දත්ත විමසීමට උපකාරී වන අතර එය සාමාන්‍යකරණය කිරීම නොවේ.

ඔබට එයින් උපරිම ප්‍රයෝජන ගත හැකිය:

  • දත්ත මතකයේ ගබඩා කිරීම සඳහා ශබ්ද කෝෂ ලැයිස්තුව, එක් නියෝගයක් එක් පේළියක්,
  • ඔබේ RAM එක පිටාර ගැලීම නොකිරීමට පේළි පසු දත්ත පේළිය සැකසීමට උත්පාදක යන්ත්‍ර,
  • ඔබේ දත්ත විමසීමට ලැයිස්තු අවබෝධය,
  • Counter, DefaultDict, ...
  • ඔබ තෝරාගත් ඕනෑම ගබඩා විසඳුමක් භාවිතා කරමින් ඔබේ දත්ත ඔබේ දෘ hard තැටියේ ගබඩා කරන්න, json ඒවායින් එකක් විය හැකිය.

රාම් සහ එච්ඩීඩී කාලයත් සමඟ ලාභදායී හා ලාභදායී වන අතර සම්මත පයිතන් 3 පුළුල් ලෙස ලබා ගත හැකි සහ ස්ථාවර වේ.


-1

මේ මොහොතේ මම ඔබ වැනි "අඩු" මට්ටමක වැඩ කරමින් සිටිමි, ඒ නිසා මගේ යෝජනාවට මට කාරක සභාවක් නොමැත.

කෙසේ වෙතත්, අච්චාරු හැඹිලි පද්ධතියක් ලෙස භාවිතා කිරීම සහ විවිධ කාර්යයන් ගොනු වලට බාහිරින් ක්‍රියාත්මක කිරීම - මගේ ලිපිගොනු / ප්‍රධාන ගොනුවෙන් මෙම ගොනු ක්‍රියාත්මක කිරීම; උදාහරණයක් ලෙස, මම වස්තු වර්ග පරිවර්තනය කිරීමට, දත්ත කට්ටලයක් පරීක්ෂාවට බෙදීමට, වලංගු කිරීම සහ පුරෝකථන දත්ත කට්ටලයක් සඳහා ready_use.py භාවිතා කරමි.

අච්චාරු සමඟ ඔබේ හැඹිලිය ක්‍රියා කරන්නේ කෙසේද? කුමන පරාමිතීන් සහ දත්ත කට්ටල සම්මත කර ඇත්ද යන්න මත පදනම්ව, ගතිකව නිර්මාණය කරන ලද අච්චාරු-ගොනු වෙත ප්‍රවේශ වීම සඳහා මම නූල් භාවිතා කරමි (ඒ සමඟ මම වැඩසටහන දැනටමත් ක්‍රියාත්මක වී ඇත්දැයි ග්‍රහණය කර තීරණය කිරීමට උත්සාහ කරමි. පරාමිතීන්). මෙම පියවරයන්ට ගරු කරමින්, මට අච්චාරු ගොනුවක් සොයා ගැනීමට සහ කියවීමට උත්සාහ කිරීමට නූල් එකක් ලැබෙන අතර, සොයාගත හොත්, මම මේ මොහොතේ ක්‍රියාත්මක වන ක්‍රියාත්මක කිරීමට පැනීම සඳහා සැකසුම් කාලය මඟ හැරිය හැක.

දත්ත සමුදායන් භාවිතා කිරීමෙන් මට සමාන ගැටළු වලට මුහුණ දීමට සිදු විය, මේ නිසා මෙම විසඳුම භාවිතා කිරීමෙන් මා සතුටට පත්විය, කෙසේ වෙතත් - නිසැකවම බොහෝ බාධක තිබේ - නිදසුනක් ලෙස අතිරික්තය හේතුවෙන් විශාල අච්චාරු කට්ටල ගබඩා කිරීම. පෙර සිට පසු වගුවක් යාවත්කාලීන කිරීම නිසි සුචිගත කිරීමකින් කළ හැකිය - තොරතුරු වලංගු කිරීම අනෙක් මුළු පොතක්ම විවෘත කරයි (මම බඩගා ගිය කුලී දත්ත ඒකාබද්ධ කිරීමට උත්සාහ කළ අතර මූලික වශයෙන් පැය 2 කට පසු දත්ත සමුදායක් භාවිතා කිරීම නැවැත්වුවෙමි - මම පසුපසට පනින්නට කැමති නිසා සෑම පරිවර්තන ක්‍රියාවලියක්ම)

මගේ ශත 2 ඔබට යම් ආකාරයකින් උදව් කරනු ඇතැයි මම බලාපොරොත්තු වෙමි.

සුබ පැතුම්.

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.