Mam do czynienia z dość dużą Pandas DataFrame - mój zestaw danych przypomina następującą dfkonfigurację:
import pandas as pd
import numpy as np
#--------------------------------------------- SIZING PARAMETERS :
R1 = 20 # .repeat( repeats = R1 )
R2 = 10 # .repeat( repeats = R2 )
R3 = 541680 # .repeat( repeats = [ R3, R4 ] )
R4 = 576720 # .repeat( repeats = [ R3, R4 ] )
T = 55920 # .tile( , T)
A1 = np.arange( 0, 2708400, 100 ) # ~ 20x re-used
A2 = np.arange( 0, 2883600, 100 ) # ~ 20x re-used
#--------------------------------------------- DataFrame GENERATION :
df = pd.DataFrame.from_dict(
{ 'measurement_id': np.repeat( [0, 1], repeats = [ R3, R4 ] ),
'time':np.concatenate( [ np.repeat( A1, repeats = R1 ),
np.repeat( A2, repeats = R1 ) ] ),
'group': np.tile( np.repeat( [0, 1], repeats = R2 ), T ),
'object': np.tile( np.arange( 0, R1 ), T )
}
)
#--------------------------------------------- DataFrame RE-PROCESSING :
df = pd.concat( [ df,
df \
.groupby( ['measurement_id', 'time', 'group'] ) \
.apply( lambda x: np.random.uniform( 0, 100, 10 ) ) \
.explode() \
.astype( 'float' ) \
.to_frame( 'var' ) \
.reset_index( drop = True )
], axis = 1
)Uwaga: W celu uzyskania minimalnego przykładu można go łatwo podzielić (na przykład za pomocą df.loc[df['time'] <= 400, :]), ale ponieważ i tak symuluję dane, pomyślałem, że oryginalny rozmiar da lepszy przegląd.
Dla każdej grupy zdefiniowanej przez ['measurement_id', 'time', 'group']muszę wywołać następującą funkcję:
from sklearn.cluster import SpectralClustering
from pandarallel import pandarallel
def cluster( x, index ):
if len( x ) >= 2:
data = np.asarray( x )[:, np.newaxis]
clustering = SpectralClustering( n_clusters = 5,
random_state = 42
).fit( data )
return pd.Series( clustering.labels_ + 1, index = index )
else:
return pd.Series( np.nan, index = index )Aby poprawić wydajność, wypróbowałem dwa podejścia:
Pakiet Pandarallel
Pierwsze podejście polegało na zrównolegleniu obliczeń za pomocą pandarallelpakietu:
pandarallel.initialize( progress_bar = True )
df \
.groupby( ['measurement_id', 'time', 'group'] ) \
.parallel_apply( lambda x: cluster( x['var'], x['object'] ) )Wydaje się to jednak nieoptymalne, ponieważ zużywa dużo pamięci RAM i nie wszystkie rdzenie są używane w obliczeniach (nawet pomimo wyraźnej liczby rdzeni w pandarallel.initialize()metodzie). Czasami obliczenia są przerywane różnymi błędami, chociaż nie miałem okazji znaleźć przyczyny tego (być może brak pamięci RAM?).
PySpark Pandas UDF
Dałem też Spark Pandas UDF, chociaż jestem zupełnie nowy w Spark. Oto moja próba:
import findspark; findspark.init()
from pyspark.sql import SparkSession
from pyspark.conf import SparkConf
from pyspark.sql.functions import pandas_udf, PandasUDFType
from pyspark.sql.types import *
spark = SparkSession.builder.master( "local" ).appName( "test" ).config( conf = SparkConf() ).getOrCreate()
df = spark.createDataFrame( df )
@pandas_udf( StructType( [StructField( 'id', IntegerType(), True )] ), functionType = PandasUDFType.GROUPED_MAP )
def cluster( df ):
if len( df['var'] ) >= 2:
data = np.asarray( df['var'] )[:, np.newaxis]
clustering = SpectralClustering( n_clusters = 5,
random_state = 42
).fit( data )
return pd.DataFrame( clustering.labels_ + 1,
index = df['object']
)
else:
return pd.DataFrame( np.nan,
index = df['object']
)
res = df \
.groupBy( ['id_half', 'frame', 'team_id'] ) \
.apply( cluster ) \
.toPandas()Niestety wydajność również była niezadowalająca, a z tego, co przeczytałem na ten temat, może to być tylko ciężar korzystania z funkcji UDF napisanej w Pythonie i związana z tym potrzeba konwersji wszystkich obiektów Python na obiekty Spark i odwrotnie.
Oto moje pytania:
- Czy jedno z moich podejść może zostać dostosowane, aby wyeliminować ewentualne wąskie gardła i poprawić wydajność? (np. konfiguracja PySpark, dostosowywanie nieoptymalnych operacji itp.)
- Czy są jakieś lepsze alternatywy? Jak różnią się one od dostarczonych rozwiązań pod względem wydajności?
dask((więc mój komentarz to tylko rada do badań.
