60种特征工程操作：使用自定义聚合函数

最新推荐文章于 2024-04-20 16:35:51 发布
最新推荐文章于 2024-04-20 16:35:51 发布
阅读量183 收藏 2
点赞数
分类专栏： 进阶技术 python技术 文章标签： python pandas 数据分析
原文链接：http://www.phpxs.com/
版权

agg是一个聚合函数，使用指定轴上的一个或多个操作进行聚合。通过agg函数，可以同时对多列进行提取特征，非常适合用于特征工程。

内置的聚合函数

在Pandas内部支持了13中聚合函数，可以在分组之后进行使用：

  • mean()：分组均值
  • sum()：分组求和
  • size()：分组个数
  • count()：分组大小
  • std()：分组标准差
  • var()：分组方差
  • sem()：均值误差
  • describe()：分组描述
  • first()：分组第一个元素
  • last()：分组最后一个元素
  • nth()：分组第N个元素
  • min()：分组最小值
  • max()：分组最大值

案例如下，有多种使用方式可供选择：

# 定义模型
df = pd.DataFrame({'group':[1,1,2,2],
  'values':[4,1,1,2],
  'values2':[0,1,1,2]
})

# 分组对两列求均值
df.groupby('group').mean()

# 分组对两列求均值、标准差
df.groupby('group').agg([np.mean,np.std])

# 分组对两列分别聚合
df.groupby('group').agg(
  {'values':['mean','median'],
  'values2':['mean','std']}
)

自定义聚合函数

如果在Pandas内部的聚合函数不满足要求，也可以自定义聚合函数搭配使用

median

def median(x):
    return np.median(x)

variation_coefficient

def variation_coefficient(x):
    mean = np.mean(x)
    if mean != 0:
        return np.std(x) / mean
    else:
        return np.nan

variance

def variance(x):
    return np.var(x)

skewness

def skewness(x):
    if not isinstance(x, pd.Series):
        x = pd.Series(x)
    return pd.Series.skew(x)

kurtosis

def kurtosis(x):
    if not isinstance(x, pd.Series):
        x = pd.Series(x)
    return pd.Series.kurtosis(x)

standard_deviation

def standard_deviation(x):
    return np.std(x)

large_standard_deviation

def large_standard_deviation(x):
    if (np.max(x)-np.min(x)) == 0:
        return np.nan
    else:
        return np.std(x)/(np.max(x)-np.min(x))

variation_coefficient

def variation_coefficient(x):
    mean = np.mean(x)
    if mean != 0:
        return np.std(x) / mean
    else:
        return np.nan

variance_std_ratio

def variance_std_ratio(x):
    y = np.var(x)
    if y != 0:
        return y/np.sqrt(y)
    else:
        return np.nan

ratio_beyond_r_sigma

def ratio_beyond_r_sigma(x, r):
    if x.size == 0:
        return np.nan
    else:
        return np.sum(np.abs(x - np.mean(x)) > r * np.asarray(np.std(x))) / x.size

range_ratio

def range_ratio(x):
    mean_median_difference = np.abs(np.mean(x) - np.median(x))
    max_min_difference = np.max(x) - np.min(x)
    if max_min_difference == 0:
        return np.nan
    else:
        return mean_median_difference / max_min_difference

has_duplicate_max

def has_duplicate_max(x):
    return np.sum(x == np.max(x)) >= 2

has_duplicate_min

def has_duplicate_min(x):
    return np.sum(x == np.min(x)) >= 2

has_duplicate

def has_duplicate(x):
    return x.size != np.unique(x).size

count_duplicate_max

def count_duplicate_max(x):
    return np.sum(x == np.max(x))

count_duplicate_min

def count_duplicate_min(x):
    return np.sum(x == np.min(x))

count_duplicate

def count_duplicate(x):
    return x.size - np.unique(x).size

sum_values

def sum_values(x):
    if len(x) == 0:
        return 0
    return np.sum(x)

log_return

def log_return(list_stock_prices):
    return np.log(list_stock_prices).diff() 

realized_volatility

def realized_volatility(series):
    return np.sqrt(np.sum(series**2))

realized_abs_skew

def realized_abs_skew(series):
    return np.power(np.abs(np.sum(series**3)),1/3)

realized_skew

def realized_skew(series):
    return np.sign(np.sum(series**3))*np.power(np.abs(np.sum(series**3)),1/3)

realized_vol_skew

def realized_vol_skew(series):
    return np.power(np.abs(np.sum(series**6)),1/6)

realized_quarticity

def realized_quarticity(series):
    return np.power(np.sum(series**4),1/4)

count_unique

def count_unique(series):
    return len(np.unique(series))

count

def count(series):
    return series.size

maximum_drawdown

def maximum_drawdown(series):
    series = np.asarray(series)
    if len(series)<2:
        return 0
    k = series[np.argmax(np.maximum.accumulate(series) - series)]
    i = np.argmax(np.maximum.accumulate(series) - series)
    if len(series[:i])<1:
        return np.NaN
    else:
        j = np.max(series[:i])
    return j-k

maximum_drawup

def maximum_drawup(series):
    series = np.asarray(series)
    if len(series)<2:
        return 0

    series = - series
    k = series[np.argmax(np.maximum.accumulate(series) - series)]
    i = np.argmax(np.maximum.accumulate(series) - series)
    if len(series[:i])<1:
        return np.NaN
    else:
        j = np.max(series[:i])
    return j-k

drawdown_duration

def drawdown_duration(series):
    series = np.asarray(series)
    if len(series)<2:
        return 0

    k = np.argmax(np.maximum.accumulate(series) - series)
    i = np.argmax(np.maximum.accumulate(series) - series)
    if len(series[:i]) == 0:
        j=k
    else:
        j = np.argmax(series[:i])
    return k-j

drawup_duration

def drawup_duration(series):
    series = np.asarray(series)
    if len(series)<2:
        return 0

    series=-series
    k = np.argmax(np.maximum.accumulate(series) - series)
    i = np.argmax(np.maximum.accumulate(series) - series)
    if len(series[:i]) == 0:
        j=k
    else:
        j = np.argmax(series[:i])
    return k-j

max_over_min

def max_over_min(series):
    if len(series)<2:
        return 0
    if np.min(series) == 0:
        return np.nan
    return np.max(series)/np.min(series)

mean_n_absolute_max

def mean_n_absolute_max(x, number_of_maxima = 1):
    """ Calculates the arithmetic mean of the n absolute maximum values of the time series."""
    assert (
        number_of_maxima > 0
    ), f" number_of_maxima={number_of_maxima} which is not greater than 1"

    n_absolute_maximum_values = np.sort(np.absolute(x))[-number_of_maxima:]

    return np.mean(n_absolute_maximum_values) if len(x) > number_of_maxima else np.NaN

count_above

def count_above(x, t):
    if len(x)==0:
        return np.nan
    else:
        return np.sum(x >= t) / len(x)

count_below

def count_below(x, t):
    if len(x)==0:
        return np.nan
    else:
        return np.sum(x <= t) / len(x)

number_peaks

def number_peaks(x, n):
    x_reduced = x[n:-n]

    res = None
    for i in range(1, n + 1):
        result_first = x_reduced > _roll(x, i)[n:-n]

        if res is None:
            res = result_first
        else:
            res &= result_first

        res &= x_reduced > _roll(x, -i)[n:-n]
    return np.sum(res)

mean_abs_change

def mean_abs_change(x):
    return np.mean(np.abs(np.diff(x)))

mean_change

def mean_change(x):
    x = np.asarray(x)
    return (x[-1] - x[0]) / (len(x) - 1) if len(x) > 1 else np.NaN

mean_second_derivative_central

def mean_second_derivative_central(x):
    x = np.asarray(x)
    return (x[-1] - x[-2] - x[1] + x[0]) / (2 * (len(x) - 2)) if len(x) > 2 else np.NaN

root_mean_square

def root_mean_square(x):
    return np.sqrt(np.mean(np.square(x))) if len(x) > 0 else np.NaN

absolute_sum_of_changes

def absolute_sum_of_changes(x):
    return np.sum(np.abs(np.diff(x)))

longest_strike_below_mean

def longest_strike_below_mean(x):
    if not isinstance(x, (np.ndarray, pd.Series)):
        x = np.asarray(x)
    return np.max(_get_length_sequences_where(x < np.mean(x))) if x.size > 0 else 0

longest_strike_above_mean

def longest_strike_above_mean(x):
    if not isinstance(x, (np.ndarray, pd.Series)):
        x = np.asarray(x)
    return np.max(_get_length_sequences_where(x > np.mean(x))) if x.size > 0 else 0

count_above_mean

def count_above_mean(x):
    m = np.mean(x)
    return np.where(x > m)[0].size

count_below_mean

def count_below_mean(x):
    m = np.mean(x)
    return np.where(x < m)[0].size

last_location_of_maximum

def last_location_of_maximum(x):
    x = np.asarray(x)
    return 1.0 - np.argmax(x[::-1]) / len(x) if len(x) > 0 else np.NaN

first_location_of_maximum

def first_location_of_maximum(x):
    if not isinstance(x, (np.ndarray, pd.Series)):
        x = np.asarray(x)
    return np.argmax(x) / len(x) if len(x) > 0 else np.NaN

last_location_of_minimum

def last_location_of_minimum(x):
    x = np.asarray(x)
    return 1.0 - np.argmin(x[::-1]) / len(x) if len(x) > 0 else np.NaN

first_location_of_minimum

def first_location_of_minimum(x):
    if not isinstance(x, (np.ndarray, pd.Series)):
        x = np.asarray(x)
    return np.argmin(x) / len(x) if len(x) > 0 else np.NaN

percentage_of_reoccurring_values_to_all_values

def percentage_of_reoccurring_values_to_all_values(x):
    if len(x) == 0:
        return np.nan
    unique, counts = np.unique(x, return_counts=True)
    if counts.shape[0] == 0:
        return 0
    return np.sum(counts > 1) / float(counts.shape[0])

percentage_of_reoccurring_datapoints_to_all_datapoints

def percentage_of_reoccurring_datapoints_to_all_datapoints(x):
    if len(x) == 0:
        return np.nan
    if not isinstance(x, pd.Series):
        x = pd.Series(x)
    value_counts = x.value_counts()
    reoccuring_values = value_counts[value_counts > 1].sum()
    if np.isnan(reoccuring_values):
        return 0

    return reoccuring_values / x.size

sum_of_reoccurring_values

def sum_of_reoccurring_values(x):
    unique, counts = np.unique(x, return_counts=True)
    counts[counts < 2] = 0
    counts[counts > 1] = 1
    return np.sum(counts * unique)

sum_of_reoccurring_data_points

def sum_of_reoccurring_data_points(x):
    unique, counts = np.unique(x, return_counts=True)
    counts[counts < 2] = 0
    return np.sum(counts * unique)

ratio_value_number_to_time_series_length

def ratio_value_number_to_time_series_length(x):
    if not isinstance(x, (np.ndarray, pd.Series)):
        x = np.asarray(x)
    if x.size == 0:
        return np.nan

    return np.unique(x).size / x.size

abs_energy

def abs_energy(x):
    if not isinstance(x, (np.ndarray, pd.Series)):
        x = np.asarray(x)
    return np.dot(x, x)

quantile

def quantile(x, q):
    if len(x) == 0:
        return np.NaN
    return np.quantile(x, q)

number_crossing_m

def number_crossing_m(x, m):
    if not isinstance(x, (np.ndarray, pd.Series)):
        x = np.asarray(x)
    # From https://stackoverflow.com/questions/3843017/efficiently-detect-sign-changes-in-python
    positive = x > m
    return np.where(np.diff(positive))[0].size

absolute_maximum

def absolute_maximum(x):
    return np.max(np.absolute(x)) if len(x) > 0 else np.NaN

value_count

def value_count(x, value):
    if not isinstance(x, (np.ndarray, pd.Series)):
        x = np.asarray(x)
    if np.isnan(value):
        return np.isnan(x).sum()
    else:
        return x[x == value].size

range_count

def range_count(x, min, max):
    return np.sum((x >= min) & (x < max))

mean_diff

def mean_diff(x):
    return np.nanmean(np.diff(x.values))

以Python为核心语言，专攻于「数据科学」领域，文章涵盖数据分析，数据挖掘，机器学习等干货内容，分享大量数据挖掘实战项目分析和讲解，以及海量的学习资源。

以上就是本次分享的所有内容，如果你觉得文章还不错，欢迎关注公众号：Python编程学习圈，每日干货分享，发送“J”还可领取大量学习资料，内容覆盖Python电子书、教程、数据库编程、Django，爬虫，云计算等等。或是前往编程学习网，了解更多编程技术知识。

程序员小六
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Pandas实战100例 | 案例 76: 分组后应用自定义聚合函数
惊鸿若梦一书生
01-17 271
Pandas 不仅允许你对分组数据使用内置的聚合函数（如 `sum`、`mean` 等），还可以应用自定义的聚合函数。这提供了更大的灵活性来处理数据。
groupby...agg...自定义聚合函数
缘 源 园
02-21 3288
college = pd.read_csv('data/college.csv') college.head() INSTNM CITY STABBR HBCU MENONLY WOMENONLY RELAFFIL SATVRMID SATMTMID DISTANCEONLY ... UGDS_2MOR UGDS_NRA UGDS_UNKN PPTUG_EF CURROPER PCTPELL ..
pandas中聚合函数agg的用法
从此醉
03-07 8817
pandas中的聚合函数agg的用法
hive学习笔记之十：用户自定义聚合函数(UDAF)，2024年最新滴滴公司面试经验
最新发布
sili7762mo的博客
04-20 436
所以对我而言，我要继续加倍努力，弥补自己技术上的不足，以及与科班大佬们基础上的差距。所以对我而言，我要继续加倍努力，弥补自己技术上的不足，以及与科班大佬们基础上的差距。因为在阿里一面前已经过了字节的三次面试，投阿里的简历一直没被捞，所以以为简历就挂了。分享我在这次面试前所做的准备（刷题复习资料以及一些大佬们的学习笔记和学习路线），都已经整理成了电子文档。// 给下一个阶段用的，即告诉下一个阶段，自己输出数据的类型。
sigmod函数tanh函数ReLU函数
热门推荐
fendoubasaonian的专栏
10-30 4万+
一. sigmod(x)函数sigmod函数的数学公式为: Θ(x)=11+e−x \Theta(x)=\frac {1}{1+e^{-x} } 函数取值范围(0,1),函数图像下图所示:二. tanh(x) 函数tanh(x)函数的数学公式为：tanh(x)=sinh(x)cosh(x)tanh(x) = \frac{sinh(x)}{cosh(x)} 函数取值范围(-1,1),函数图像
用scikit-learn学习主成分分析(PCA)
weixin_33738578的博客
01-02 1342
　　　　在主成分分析（PCA）原理总结中，我们对主成分分析(以下简称PCA)的原理做了总结，下面我们就总结下如何使用scikit-learn工具来进行PCA降维。 1. scikit-learn PCA类介绍 　　　　在scikit-learn中，与PCA相关的类都在sklearn.decomposition包中。最常用的PCA类就是sklearn.decomposition.PCA，我们下面主要...
transpect:自定义配置以进行透视
04-22
这可能包括选择要分析的数据字段、设定聚合函数（如求和、平均、计数等）、定义过滤条件以及创建自定义计算等。 在标签部分，“TeX”是一个排版系统，广泛用于数学、科学和技术领域的文档制作，尤其是因为它对公式...
pandas数据分组和聚合操作方法
09-20
在数据分析领域，Pandas库是不可或缺的工具，...这些操作在数据探索、数据清洗、特征工程和模型构建等环节都发挥着重要作用。熟练掌握Pandas的分组和聚合方法，能够提高数据处理的效率，帮助我们更好地理解和解读数据。
SQL-ProblemSolving:使用SQL进行竞争性编程
03-26
2. **聚合函数** - **COUNT()**：计算行数。 - **SUM()**：求和。 - **AVG()**：平均值。 - **MAX()**与**MIN()**：最大值和最小值。 - **DISTINCT**：去除重复项。 3. **SQL进阶** - **JOIN操作**：连接两个...
noether：用于ML模型指标监控的Scala聚合器
02-05
2. **数据聚合**：利用Scala的集合操作和函数式编程特性，Noether对收集到的数据进行聚合，例如计算平均值、最大值、最小值等统计量。 3. **实时监控**：Noether提供实时反馈，让用户在训练过程中观察模型性能的变化...
DE_Coding_Challenge:对于数据工程编码挑战，所有任务均使用Python 3.7完成
03-12
挑战可能涵盖数据清洗、数据转换、聚合、分组、合并等操作。 5. **NumPy库**：NumPy为Python提供了高效的数值计算能力，支持多维数组和矩阵运算。挑战可能涉及到统计计算、数组操作或线性代数问题。 6. **数据清洗...
自定义聚合函数
07-27
NULL 博文链接：https://yizhilong28.iteye.com/blog/668958
特征工程：一文掌握特征工程99%代码函数，可以可以~ ~
商务合作 | 面试培训 | 职场规划 ==>主页扫码
01-29 1424
一文掌握特征工程99%函数
【Pandas分组聚合】 groupby()、agg() 方法的使用
weixin_45760274的博客
03-15 4万+
Pandas分组聚合
【Pandas分组聚合】进阶：使用自定义函数方法 transform() 、apply()
weixin_45760274的博客
03-15 3117
【Pandas】使用自定义方法 dataframe() apply()
hive学习笔记之十：用户自定义聚合函数(UDAF)，区区一个SpringBoot问题就被干趴下了
m0_64867047的博客
12-26 640
合并值缓冲区大小，这里是用来保存字符串长度，因此设为4byte @return */ @Override public int estimate() { return JavaDataModel.PRIMITIVES1; } } 新建FieldLengthUDAFEvaluator.java，里面是整个UDAF逻辑实现，关键代码已经添加了注释，请结合前面的图片来理解，核心思路是iterate将当前分组的字段处理完毕，merger把分散的数据合并起来，再由terminate决定当前分组计算结果：..
Pandas 分组聚合操作详解
softshow1026的博客
11-16 254
在这个示例中，我们定义了一个自定义聚合函数custom_agg，并将其应用在分组聚合操作中：result = df1.groupby('店铺名称', as_index=False)['销售数量'].agg(custom_agg)
pyspark pandas 自定义聚合函数
人生百态361
12-14 3802
pyspark自定义聚合函数 import pyspark.sql.functions as F from pyspark.sql import SparkSession from pyspark.sql.types import IntegerType list_data={ 'label_id':['001','001','002','001','001','002','004','001','001'] ,'action_num':[3,4,5,1,2,34,5,9,2] } df1 = pd.
ORACLE学习笔记（六）——自定义聚合函数
xzsfg6825的博客
08-05 700
一、用户自定义聚合函数简介 Oracle提供了很多预定义好的聚集函数，比如Max(), Sum(), AVG()，但是这些预定义的聚集函数基本上都是适应于标量数据(scalar data)，对于复杂的数据类型，比如说用户自定义的Object type, Clob等，是不支持的。 但是，幸运的是，用户可以通过实现Oracle的Extensibility...
grouby函数调用自定义聚合函数计算
04-04
# 调用groupby函数，并使用自定义聚合函数 result = df.groupby(['A', 'B']).agg(my_agg) print(result) ``` 输出结果如下： ``` C D mean std mean std A B bar one 2.0 NaN 20.0 NaN three 4.0 NaN 40.0 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值