पांडस ग्रुपबी धीमी गति से प्रदर्शन कर रहा है

Question

मैं ऐसे कार्यक्रम पर काम कर रहा हूं जिसमें बड़ी मात्रा में डेटा शामिल है। मैं अपने डेटा में त्रुटियों को देखने के लिए पायथन पांडा मॉड्यूल का उपयोग कर रहा हूं। यह आमतौर पर बहुत तेज़ काम करता है। हालांकि मैंने लिखा कोड का वर्तमान टुकड़ा ऐसा होना चाहिए जितना धीमा होना चाहिए और मैं इसे तेज करने के लिए एक रास्ता तलाश रहा हूं।

आपके लिए लोगों को सही तरीके से परीक्षण करने के लिए मैंने कोड का एक बड़ा टुकड़ा अपलोड किया। आपको इसे चलाने में सक्षम होना चाहिए। कोड में टिप्पणियों को समझाया जाना चाहिए कि मैं यहां क्या करने की कोशिश कर रहा हूं। किसी भी तरह की सहायता का स्वागत किया जाएगा।

# -*- coding: utf-8 -*- 

import pandas as pd 
import numpy as np 

# Filling dataframe with data 
# Just ignore this part for now, real data comes from csv files, this is an example of how it looks 
TimeOfDay_options = ['Day','Evening','Night'] 
TypeOfCargo_options = ['Goods','Passengers'] 
numpy.random.seed(1234) 
n = 10000 

df = pd.DataFrame() 
df['ID_number'] = np.random.randint(3, size=n) 
df['TimeOfDay'] = np.random.choice(TimeOfDay_options, size=n) 
df['TypeOfCargo'] = np.random.choice(TypeOfCargo_options, size=n) 
df['TrackStart'] = np.random.randint(400, size=n) * 900 
df['SectionStart'] = np.nan 
df['SectionStop'] = np.nan 

grouped_df = df.groupby(['ID_number','TimeOfDay','TypeOfCargo','TrackStart']) 
for index, group in grouped_df: 
    if len(group) == 1: 
     df.loc[group.index,['SectionStart']] = group['TrackStart'] 
     df.loc[group.index,['SectionStop']] = group['TrackStart'] + 899 

    if len(group) > 1: 
     track_start = group.loc[group.index[0],'TrackStart'] 
     track_end = track_start + 899 
     section_stops = np.random.randint(track_start, track_end, size=len(group)) 
     section_stops[-1] = track_end 
     section_stops = np.sort(section_stops) 
     section_starts = np.insert(section_stops, 0, track_start) 

     for i,start,stop in zip(group.index,section_starts,section_stops): 
      df.loc[i,['SectionStart']] = start 
      df.loc[i,['SectionStop']] = stop 

#%% This is what a random group looks like without errors 
#Note that each section neatly starts where the previous section ended 
#There are no gaps (The whole track is defined) 
grouped_df.get_group((2, 'Night', 'Passengers', 323100)) 

#%% Introducing errors to the data 
df.loc[2640,'SectionStart'] += 100 
df.loc[5390,'SectionStart'] += 7 

#%% This is what the same group looks like after introducing errors 
#Note that the 'SectionStop' of row 1525 is no longer similar to the 'SectionStart' of row 5592 
#This track now has a gap of 100, it is not completely defined from start to end 
grouped_df.get_group((2, 'Night', 'Passengers', 323100)) 

#%% Try to locate the errors 
#This is the part of the code I need to speed up 

def Full_coverage(group): 
    if len(group) > 1: 
     group.sort('SectionStart', ascending=True, inplace=True) #Sort the grouped data by column 'SectionStart' from low to high 

     #Some initial values, overwritten at the end of each loop 
     #These variables correspond to the first row of the group 
     start_km = group.iloc[0,4] 
     end_km = group.iloc[0,5] 
     end_km_index = group.index[0] 

     #Loop through all the rows in the group 
     #index is the index of the row 
     #i is the 'SectionStart' of the row 
     #j is the 'SectionStop' of the row 
     #The loop starts from the 2nd row in the group 
     for index, (i, j) in group.iloc[1:,[4,5]].iterrows(): 

      #The start of the next row must be equal to the end of the previous row in the group 
      if i != end_km: 

       #Add the faulty data to the error list 
       incomplete_coverage.append(('Expected startpoint: '+str(end_km)+' (row '+str(end_km_index)+')', \ 
            'Found startpoint: '+str(i)+' (row '+str(index)+')'))     

      #Overwrite these values for the next loop 
      start_km = i 
      end_km = j 
      end_km_index = index 

    return group 

#Check if the complete track is completely defined (from start to end) for each combination of: 
    #'ID_number','TimeOfDay','TypeOfCargo','TrackStart' 
incomplete_coverage = [] #Create empty list for storing the error messages 
df_grouped = df.groupby(['ID_number','TimeOfDay','TypeOfCargo','TrackStart']).apply(lambda x: Full_coverage(x)) 

#Print the error list 
print('\nFound incomplete coverage in the following rows:') 
for i,j in incomplete_coverage: 
    print(i) 
    print(j) 
    print() 

#%%Time the procedure -- It is very slow, taking about 6.6 seconds on my pc 
%timeit df.groupby(['ID_number','TimeOfDay','TypeOfCargo','TrackStart']).apply(lambda x: Full_coverage(x)) 

Answer 1

समस्या, मेरा मानना ​​है कि आपके डेटा में 5300 विशिष्ट समूह हैं। इसके कारण, आपके फ़ंक्शन के भीतर कुछ भी धीमा हो जाएगा। आप समय बचाने के लिए अपने फ़ंक्शन में for लूप के बजाय शायद वेक्टरकृत ऑपरेशन का उपयोग कर सकते हैं, लेकिन return group की बजाय 0 सेकंडपर कुछ सेकंड बंद करने का एक आसान तरीका है। जब आप return group, पांडा वास्तव में आपके सॉर्ट किए गए समूहों को संयोजित करने वाला एक नया डेटा ऑब्जेक्ट बनाते हैं, जिसे आप उपयोग नहीं करते हैं। जब आप return 0, पांडा इसके बजाय 5300 शून्य जोड़ देंगे, जो बहुत तेज़ है।

उदाहरण के लिए

:

cols = ['ID_number','TimeOfDay','TypeOfCargo','TrackStart'] 
groups = df.groupby(cols) 
print(len(groups)) 
# 5353 

%timeit df.groupby(cols).apply(lambda group: group) 
# 1 loops, best of 3: 2.41 s per loop 

%timeit df.groupby(cols).apply(lambda group: 0) 
# 10 loops, best of 3: 64.3 ms per loop 

बस परिणाम आप का उपयोग नहीं करते लगभग 2.4 सेकंड ले जा रहा है के संयोजन; शेष समय आपके लूप में वास्तविक गणना है जिसे आपको सदिश करने का प्रयास करना चाहिए।

---

संपादित करें:

for पाश से पहले एक त्वरित अतिरिक्त vectorized जांच और group के बजाय 0 लौटने के साथ

, मैं के बारे में ~ 2sec, जो मूल रूप से प्रत्येक समूह छँटाई की लागत है करने के लिए नीचे समय मिला है। इस समारोह का प्रयास करें:

def Full_coverage(group): 
    if len(group) > 1: 
     group = group.sort('SectionStart', ascending=True) 

     # this condition is sufficient to find when the loop 
     # will add to the list 
     if np.any(group.values[1:, 4] != group.values[:-1, 5]): 
      start_km = group.iloc[0,4] 
      end_km = group.iloc[0,5] 
      end_km_index = group.index[0] 

      for index, (i, j) in group.iloc[1:,[4,5]].iterrows(): 
       if i != end_km: 
        incomplete_coverage.append(('Expected startpoint: '+str(end_km)+' (row '+str(end_km_index)+')', \ 
             'Found startpoint: '+str(i)+' (row '+str(index)+')'))     
       start_km = i 
       end_km = j 
       end_km_index = index 

    return 0 

cols = ['ID_number','TimeOfDay','TypeOfCargo','TrackStart'] 
%timeit df.groupby(cols).apply(Full_coverage) 
# 1 loops, best of 3: 1.74 s per loop 

---

संपादित करें 2: यहाँ एक उदाहरण है जो GroupBy बाहर तरह ले जाने के लिए और अनावश्यक छोरों को हटाने के लिए मेरी सुझाव को शामिल किया गया है। छोरों निकाला जा रहा है बहुत तेजी से दिए गए उदाहरण के लिए नहीं है, लेकिन अगर वहाँ incompletes के एक बहुत हैं तेजी से हो जाएगा:

def Full_coverage_new(group): 
    if len(group) > 1: 
     mask = group.values[1:, 4] != group.values[:-1, 5] 
     if np.any(mask): 
      err = ('Expected startpoint: {0} (row {1}) ' 
        'Found startpoint: {2} (row {3})') 
      incomplete_coverage.extend([err.format(group.iloc[i, 5], 
                group.index[i], 
                group.iloc[i + 1, 4], 
                group.index[i + 1]) 
             for i in np.where(mask)[0]]) 
    return 0 

incomplete_coverage = [] 
cols = ['ID_number','TimeOfDay','TypeOfCargo','TrackStart'] 
df_s = df.sort_values(['SectionStart','SectionStop']) 
df_s.groupby(cols).apply(Full_coverage_nosort) 

Answer 2

मैंने पाया पांडा का पता लगाने आदेश (.loc या .iloc) भी प्रगति को धीमा कर रहे थे । लूप से सॉर्ट को स्थानांतरित करके और फ़ंक्शन की शुरुआत में डेटा को numpy arrays में परिवर्तित करके मुझे एक तेज़ परिणाम मिला। मुझे पता है कि डेटा अब डेटाफ्रेम नहीं है, लेकिन सूची में लौटाई गई इंडेक्स का उपयोग मूल डीएफ में डेटा खोजने के लिए किया जा सकता है।

अगर वहाँ प्रक्रिया में तेजी लाने के लिए भी आगे मैं मदद की सराहना करते हैं किसी भी तरह से है। मेरे पास अब तक क्या है:

def Full_coverage(group): 

    if len(group) > 1: 
     group_index = group.index.values 
     group = group.values 

     # this condition is sufficient to find when the loop will add to the list 
     if np.any(group[1:, 4] != group[:-1, 5]): 
      start_km = group[0,4] 
      end_km = group[0,5] 
      end_km_index = group_index[0] 

      for index, (i, j) in zip(group_index, group[1:,[4,5]]): 

       if i != end_km: 
        incomplete_coverage.append(('Expected startpoint: '+str(end_km)+' (row '+str(end_km_index)+')', \ 
             'Found startpoint: '+str(i)+' (row '+str(index)+')'))    
       start_km = i 
       end_km = j 
       end_km_index = index 

    return 0 

incomplete_coverage = [] 
df.sort(['SectionStart','SectionStop'], ascending=True, inplace=True) 
cols = ['ID_number','TimeOfDay','TypeOfCargo','TrackStart'] 
%timeit df.groupby(cols).apply(Full_coverage) 
# 1 loops, best of 3: 272 ms per loop