Wenn Sie den Pandas-Datenrahmen vor der verdammt großen Matrix verwenden, ist der Speicher knapp und die Verarbeitung dauert Stunden. Daher werde ich ein Memorandum mit Punkten aufbewahren, um die ich mich persönlich kümmere, wenn ich Datenrahmen leichter und schneller handhabe.
--Typoptimierung
kaggle Diese Funktion wurde noch nie in einem Tischwettbewerb gesehen. Optimieren Sie die Formgröße, um Speicherausfälle zu vermeiden und die Geschwindigkeit zu erhöhen.
def reduce_mem_usage(df):
start_mem = df.memory_usage().sum() / 1024**2
print('Memory usage of DataFrame is {:.2f} MB'.format(start_mem))
for col in df.columns:
col_type = df[col].dtype
if col_type != object:
c_min = df[col].min()
c_max = df[col].max()
if str(col_type)[:3] == 'int':
if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
df[col] = df[col].astype(np.int8)
elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
df[col] = df[col].astype(np.int16)
elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
df[col] = df[col].astype(np.int32)
elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:
df[col] = df[col].astype(np.int64)
else:
if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:
df[col] = df[col].astype(np.float16)
elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
df[col] = df[col].astype(np.float32)
else:
df[col] = df[col].astype(np.float64)
end_mem = df.memory_usage().sum() / 1024**2
print('Memory usage after optimization is: {:.2f} MB'.format(end_mem))
print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem))
return df
Durch Angabe des Typs hier kann die Zeit zum Angeben des Typs weggelassen und Daten können schneller gelesen werden. Nicht sehr geeignet für Daten mit zu großen Spalten (schwierig).
df = pd.read_csv('./train.csv', dtype={'a': int, 'b': float, 'c': str})
Python ist langsam, da der Compiler für jeden Prozess für jeden ausgeführt wird. Daher wird for nicht so oft wie möglich verwendet, und map und apply werden verwendet.
Übrigens benutze ich diese Funktionen wie folgt richtig, aber ich weiß nicht, was eigentlich anders ist (wer sagt es mir)
map
Beim Anpassen eines Wörterbuchtyps an eine Spalte
d = {'hoge':'Hoge', 'fuga':'Fuga', 'piyo':'Piyo'}
df['tmp'] = df['tmp'].map(d)
apply
groupbydf['rolling_mean'] = df.groupby([id])['timeseries'].apply(lambda x:x.rolling(12, 1).mean())
def cos_sim(v1, v2):
return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
df = df.apply(lambda x: cos_sim(v1, x), axis=1) # return pd.Series
Beide können Spalten verarbeiten, sodass Sie sie entsprechend Ihrer Stimmung verwenden können.
Übrigens das Temperaturgefühl von for in Personal Python 100 iter → Es ist okay. 1000 iter → Hmm? 10000 iter → Hey ... 100000 iter → Bist du gesund?
Es gibt Dinge wie "Ich habe jede Kategorie verarbeitet, aber ich kann" Karte "und" Anwenden "nicht verwenden ... Der Versuch dauert lange und ich kann es kaum erwarten ...".
year_list = [2010, 2011, 2012, 2013]
for y in year_list:
df_y = df[df['year']==y]
'''wird bearbeitet'''
df_y_executed.to_csv('./savefolder/save_{y}.csv'.format(y=y))
Gegenwärtig werden Pandas nicht durch physische Kerne parallelisiert, daher gibt es überschüssige Ressourcen, aber Wartezeiten sind verschwenderisch. Daher wird es vom physischen Kern gewaltsam parallelisiert.
In einem solchen Fall wird in meinem Labor die folgende Methode angewendet.
Dies ermöglicht die Verarbeitung mit zwei physischen Kernen.
In Chimata gibt es etwas namens Dask, und es scheint, dass Daten, die größer als der Speicher sind, parallel verarbeitet werden können. Ich habe gehört, dass es sehr gut mit Pandas kompatibel ist und sich gut anfühlt, deshalb würde ich es gerne ausprobieren.