Resolving performance issue with skewed partitions in PySpark Window function

I am attempting to calculate some moving averages in Spark, but am running into issues with skewed partitions. Here is the simple calculation I'm trying to perform:

Getting the base data

# Variables
one_min = 60
one_hour = 60*one_min
one_day = 24*one_hour
seven_days = 7*one_day
thirty_days = 30*one_day

# Column variables
target_col = "target"
partition_col = "partition_col"


df_base = (
    spark
    .sql("SELECT * FROM {base}".format(base=base_table))
)

df_product1 = (
    df_base
    .where(F.col("product_id") == F.lit("1"))
    .select(
        F.col(target_col).astype("double").alias(target_col),
        F.unix_timestamp("txn_timestamp").alias("window_time"),
        "transaction_id",
        partition_col
    )
)
df_product1.persist()

Calculating running averages

window_lengths = {
    "1day": one_day,
    "7day": seven_days,
    "30day": thirty_days
}
# Create window specs for each type
part_windows = {
    time: Window.partitionBy(F.col(partition_col))
                .orderBy(F.col("window_time").asc())
                .rangeBetween(-secs, -one_min)
    for (time, secs) in window_lengths.items()
}

cols = [
    # Note: not using `avg` as I will be smoothing this at some point
    (F.sum(target_col).over(win)/F.count("*").over(win)).alias(
        "{time}_avg_target".format(time=time)
    )
    for time, win in part_windows.items()
]

sample_df = (
    df_product1
    .repartition(2000, partition_col)
    .sortWithinPartitions(F.col("window_time").asc())
    .select(
        "*",
        *cols
    )
)

Now, I can collect a limited subset of these data (say just 100 rows), but if I try to run the full query, and, for example, aggregate the running averages, Spark gets stuck on some particularly large partitions. The vast majority of the partitions have fewer than 1million records in them. Only about 50 of them have more than 1M record and only about 150 have more than 500K

However, a small handful have more than 2.5M (~10), and 3 of them have more than 5M records. These partitions have run for more than 12 hours and failed to complete. The skew in these partitions are a natural part of the data representing larger activity in these distinct values of the partitioning column. I have no control over the definition of the values of this partitioning column.

I am using a SparkSession with dynamic allocation enabled, 32G of RAM and 4 cores per executor, and 4 executors minimum. I have attempted to up the executors to 96G with 8 cores per executor and 10 executors minimum, but the job still does not complete.

This seems like a calculation which shouldn't take 13 hours to complete. The df_product1 DataFrame contains just shy of 300M records.

If there is other information that would be helpful in resolving this problem, please comment below.