特征工程：一文掌握特征工程99%代码函数，可以可以~ ~

置顶 Carl_奕然

于 2024-01-29 03:45:00 发布

阅读量1.4k

点赞数 55

分类专栏：【机器学习】&【深度学习】文章标签：人工智能机器学习数据挖掘

本文链接：https://blog.csdn.net/wuyoudeyuer/article/details/135883598

版权

【机器学习】&【深度学习】专栏收录该内容

49 篇文章 12 订阅

订阅专栏

特征工程函数代码

1、聚合特征汇总
2、总结

1、聚合特征汇总

1.1 pandas自带的聚合函数

mean():
- 功能：计算每个组的平均值。
- 示例：df.groupby('column_name').mean()
sum():
- 功能：计算每个组内数值的总和。
- 示例：df.groupby('column_name').sum()
size():
- 功能：计算每个组内的行数，返回的是一个Series，其索引是组标签，值是组的大小。
- 示例：df.groupby('column_name').size()
count():
- 功能：计算每个组内的非空值的数量。
- 示例：df.groupby('column_name').count()
std():
- 功能：计算每个组的标准差。
- 示例：df.groupby('column_name').std()
var():
- 功能：计算每个组的方差。
- 示例：df.groupby('column_name').var()
sem():
- 功能：计算每个组的标准误差。
- 示例：df.groupby('column_name').sem()
first():
- 功能：获取每个组的第一个值。
- 示例：df.groupby('column_name').first()
  last():

功能：获取每个组的最后一个值。
示例：df.groupby('column_name').last()

nth():
- 功能：获取每个组的第n个值，或者如果n是一个列表，则返回该列表中的值。
- 示例：df.groupby('column_name').nth(1) 或 df.groupby('column_name').nth([1,3])
min():
- 功能：计算每个组的最小值。
- 示例：df.groupby('column_name').min()
max():
- 功能：计算每个组的最小值。注意这里应该是最大值，而不是最小值。
- 示例：df.groupby('column_name').max()

1.2 聚合函数&分类代码示例

1.2.1 分析类函数

median(x)：计算输入数组x的中位数。

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

variation_coefficient(x)：计算变异系数，即标准差除以平均值，用来衡量数据相对其均值的波动程度。

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

variance(x)：计算输入数组x的方差，表示数据集中数据点离散程度的一个度量。

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

skewness(x)：计算输入数组x的偏度，反映分布形态的对称性，正值表示右偏（长尾在右侧），负值表示左偏。

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

kurtosis(x)：计算输入数组x的峰度，描述分布尖峭或平坦的程度，与正态分布相比，大于3表示尖顶分布，小于3表示扁平分布。

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

standard_deviation(x)：计算输入数组x的标准差，衡量数据的离散程度。


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

large_standard_deviation(x)：计算一个修正后的标准差，将其除以最大值减最小值，适用于范围受限的数据集。

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(x)：计算方差与标准差平方根之比，恒为1。

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(x, r)：计算超出r倍标准差之外的数据点占比。

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(x)：计算平均值与中位数之差与数据范围（最大值-最小值）的比例。

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(x)：检查输入数组是否有重复的最大值。

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

has_duplicate_min(x)：检查输入数组是否有重复的最小值。

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

has_duplicate(x)：检查输入数组中是否含有重复值。

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

count_duplicate_max(x)：计算最大值出现的次数。

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

count_duplicate_min(x)：计算最小值出现的次数。

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

count_duplicate(x)：计算数组中重复值的数量。

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

sum_values(x)：计算数组元素之和，处理空数组时返回0。


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

log_return(list_stock_prices)：计算股票价格的时间序列对数收益率。

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

realized_volatility(series)：计算真实波动率，即时间序列绝对值平方和的平方根。


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

realized_abs_skew(series) 和 realized_skew(series)：计算真实绝对偏度和真实偏度，基于三阶矩的估计。

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

realized_vol_skew(series)：计算波动率偏度，基于六阶矩的估计。

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

realized_quarticity(series)：计算四阶矩的真实估计，也称为“赫斯特指数”，反映了波动性的非线性特性。

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

count_unique(series)：计算输入序列中的唯一值数量。

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

count(series)：计算输入序列中的元素数量。

def count(series):
    return series.size

1.2.2 金融时间序列特有指标函数

maximum_drawdown(series)：计算投资组合的最大回撤，即历史最高净值与随后最低净值之间的百分比跌幅。

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(series)：计算投资组合的最大上涨幅度，通过取反数转换后再计算最大回撤实现。

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(series) 和 drawup_duration(series)：分别计算从最高点到最低点及从最低点到新高点的持续时间。

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

max_over_min(series)：计算最大值与最小值的比率。

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(x, number_of_maxima = 1)：计算指定数量极大值的算术平均绝对值。

def mean_n_absolute_max(x, number_of_maxima = 1):

    assert (
        number_of_maxima > 0
    ), f" number_of_maxima={number_of_maxima} "

    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(x, t) 和 count_below(x, t)：计算高于阈值t和低于阈值t的数据点比例。

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

number_peaks(x, n)：计算支持至少为n的峰值数量，即连续n个数据点中最值。

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(x)：计算绝对变化值的平均值。

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

mean_change(x)：计算平均变化率。

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(x)：计算中心二阶导数的平均值，反映序列局部曲率。

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(x)：计算均方根（RMS），类似于标准差但使用绝对值而非平方。

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

absolute_sum_of_changes(x)：计算序列绝对变化值之和。


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

longest_strike_below_mean(x) 和 longest_strike_above_mean(x)：计算最长低于均值和最长高于均值的连续子序列长度。

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

count_above_mean(x) 和 count_below_mean(x)：计算高于均值和低于均值的数据点数量。

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

last_location_of_maximum(x) 和 first_location_of_maximum(x)：计算最后一个最大值及其位置（作为区间[0,1]内的比例）以及第一个最大值的位置。


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(x) 和 first_location_of_minimum(x)：计算最后一个最小值及其位置以及第一个最小值的位置。

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

percentage_of_reoccurring_values_to_all_values(x)：计算所有值中重复值所占比例。

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(x)：计算所有数据点中重复数据点所占比例。

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(x)：计算所有重复值的总和。

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(x)：计算所有重复数据点对应的值之和。

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(x)：计算不同数值种类与整个时间序列长度的比例。

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(x)：计算信号的能量，即信号平方和。

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

quantile(x, q)：计算输入数组x的q分位数。

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

number_crossing_m(x, m)：计算跨越某个特定值m的次数。

def number_crossing_m(x, m):
    if not isinstance(x, (np.ndarray, pd.Series)):
        x = np.asarray(x)
    positive = x > m
    return np.where(np.diff(positive))[0].size

absolute_maximum(x)：计算输入数组绝对值的最大值。

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

value_count(x, value)：统计给定值在数组中出现的次数。

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(x, min, max)：统计数组中位于[min, max)区间内的元素个数。

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

mean_diff(x)：计算输入pandas Series中相邻元素之差的平均值。

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

2、总结

看到这里，今天的分享差不多就该结束了。
今天主要针对特征工程的常用代码函数进行的详细的讲解，
这些内容可能对一些新手来说，有些多，但是
逐渐的学习，慢慢地消化，总会掌握的。

我是小鱼：

CSDN 博客专家；
阿里云专家博主；
51CTO博客专家；
51认证讲师等；
认证金牌面试官；
职场面试培训、职业规划师；
多个国内主流技术社区的认证专家博主；
多款主流产品(阿里云等)测评一、二等奖获得者；

关注我，带你学习更多更专业更前沿技术技术。

Carl_奕然

关注

55
点赞
踩
56

收藏

觉得还不错? 一键收藏
打赏
0
评论
特征工程：一文掌握特征工程99%代码函数，可以可以~ ~

一文掌握特征工程99%函数
复制链接

扫一扫

专栏目录