datsci

activate_funcs

sigmoid

dramkit.datsci.activate_funcs.sigmoid(x): sigmoid激活函数

softmax

dramkit.datsci.activate_funcs.softmax(x, max_=True): softmax函数

x为一维np.array或list或pd.Series

若max_为True，则计算时减去x的最大值以防止取指数之后数据溢出

参考：https://www.cnblogs.com/ysugyl/p/12922598.html

softmax2d

dramkit.datsci.activate_funcs.softmax2d(x2d, axis=0, max_=True): softmax函数

x是二维的np.array或list或dataframe

若max_为True，则计算时减去x的最大值以防止取指数之后数据溢出

参考：https://www.cnblogs.com/ysugyl/p/12922598.html

softplus

dramkit.datsci.activate_funcs.softplus(x): softplus激活函数

tanh

dramkit.datsci.activate_funcs.tanh(x): tanh激活函数

ahp

score2JM

dramkit.datsci.ahp.score2JM(df_score, max_important_level=9, judge_type='big_score')

将指标重要性评分转化为判断矩阵

Parameters:

df_score (pd.DataFrame) – 每列一个指标，每行为一个专家对不同指标的重要性打分，打分要求均为正值，越大表示越重要
max_important_level (int) – 构造判断矩阵时指标两两比较最大等级差，默认9 （两两比较重要性等级范围为1/9-9）
judge_type (str) –
- ‘big’表示两指标评分比较时，大于就记1分
- ’big_score’表示记分数差值
- ’score’表示直接用各自得分之和表示重要程度

Returns:

judge_mat – 返回判断矩阵

Return type:

pd.DataFrame

check_JM

dramkit.datsci.ahp.check_JM(judge_mat, tol=0.001, logger=None): 检查判断矩阵是否符合条件：对称位置乘积是否为1

tol为乘积与1比较时的误差范围控制

cal_weights

dramkit.datsci.ahp.cal_weights(judge_mat, RI_dict=None, check_JM_tol=0.001, logger=None): 精确方法根据判断矩阵计算权重并进行一致性检验

判断矩阵judge_mat应为np.array或pd.DataFrame

RI_dict为随机一致性指标参考值，dict或None

check_JM_tol为 check_JM() 的 tol 参数

返回权重向量w以及是否通过一致性检验（True or False）和(CR, CI, lmdmax,RI)等检验信息

cal_weights_sim

dramkit.datsci.ahp.cal_weights_sim(judge_mat, RI_dict=None, check_JM_tol=0.001, logger=None): 近似方法根据判断矩阵计算权重并进行一致性检验

判断矩阵judge_mat应为np.array或pd.DataFrame

RI_dict为随机一致性指标参考值，dict或None

check_JM_tol为 check_JM() 的 tol 参数

返回权重向量w以及是否通过一致性检验（True or False）和(CR, CI, lmdmax,RI)等检验信息

参考:

- 层次分析：层次分析法在确定绩效指标权重中的应用.pdf

- https://zhuanlan.zhihu.com/p/37738503

cal_weights_mats

dramkit.datsci.ahp.cal_weights_mats(judge_mats, RI_dict=None, w_func=None, skip_bad_JM=True, check_JM_tol=0.001, logger=None): 多个专家（多个判断矩阵）情况下AHP方法计算权重并进行一致性检验

judge_mats为判断矩阵列表，每个矩阵应为np.array或pd.DataFrame

RI_dict为随机一致性指标参考值，dict或None

w_func指定单个判断矩阵时AHP计算权重的函数，其应接收参数judge_mat、RI_dict、check_JM_tol和logger

w_func若不指定，则默认为 cal_weights()

返回权重向量w以及是否通过一致性检验（True or False）、(CR, CI, lmdmax,RI)等检验信息

以及综合判断矩阵和专家判断力权值列表和一致性指标列表

参考：

- 多专家评价的AHP方法及其工程应用:

https://www.doc88.com/p-9913949483932.html

- 层次分析法中判断矩阵的群组综合构造方法:

https://www.ixueshu.com/document/1b154ecb637fc9ea05675f42f11aa1a6318947a18e7f9386.html

ahp_sim_ri

cal_CI

dramkit.datsci.ahp_sim_ri.cal_CI(judge_mat): 计算判断矩阵judge_mat的CI值，精确方法

cal_CI_sim

dramkit.datsci.ahp_sim_ri.cal_CI_sim(judge_mat): 计算判断矩阵judge_mat的CI值，近似方法

gen_random_mat

dramkit.datsci.ahp_sim_ri.gen_random_mat(num_indicator, choices): 产生num_indicator阶随机对称矩阵（即判断矩阵），随机值从choices中选择

sim_ri

dramkit.datsci.ahp_sim_ri.sim_ri(num_indicator, max_important_level=9, num_sim=500): 模拟RI值

num_indicator为指标个数，即判断矩阵阶数

max_important_level为构造判断矩阵时指标两两比较最大等级差，默认9

（两两比较重要性等级范围为1/9-9）

get_RIs

dramkit.datsci.ahp_sim_ri.get_RIs(max_num_indicator=20, num_sim=50000): AHP中随机一致性指标RI的模拟

max_num_indicator设置模拟的最大指标数量

num_sim设置随机模拟次数

参考：

- https://zhidao.baidu.com/question/13745867.html

- 层次分析：层次分析法在确定绩效指标权重中的应用.pdf

- https://zhuanlan.zhihu.com/p/37738503

apriori

关联规则-Apriori算法实现

关联规则分析（挖掘）用于发现项目或项目集合之间可能“频繁”出现的“紧密”关联模式（或因果结构），
如“由于某些事件的发生而引起另外一些事件的发生”之类的规则。“频繁”和“紧密”程度通过
“支持度”和“置信度”来度量。
一个被津津乐道的案例是通过关联规则挖掘发现“买尿布的年轻父亲通常也会顺便为自己买啤酒”。

关联规则数据集示例：
编号, 交易清单
001, 可乐 & 鸡蛋 & 香肠
002, 可乐 & 尿布 & 啤酒
003, 可乐 & 尿布 & 啤酒 & 香肠
004, 尿布 & 啤酒

相关概念：
1. 事务：每一个样本（一条交易记录）称为一个事务，示例中的数据集包含四个事务。
2. 项：事务（交易记录）中的每一个组成部分（交易物品）称为一个项，例如可乐、鸡蛋等。
3. 项集：包含零个或多个项的集合叫做项集，例如{可乐, 鸡蛋, 香肠}。
4. k项集：包含k个项的项集叫做k-项集，{可乐}是1项集，{可乐, 鸡蛋}是2项集。
5. 支持度计数：一个项集在数据集不同事务中出现的次数。
示例中{尿布, 啤酒}出现在事务002、003和004中，其支持度计数为3。
6. 支持度：支持度计数除以总的事务数。
示例中{尿布, 啤酒}的支持度为3÷4=0.75（有75%的人同时买了尿布和啤酒）。
7. 频繁项集：支持度不小于给定阈值的项集就叫做频繁项集。
若阈值设为0.7，示例中{尿布, 啤酒}的支持度是0.75 > 0.7，是频繁项集。
8. 前件和后件：对于规则{尿布}→{啤酒}，{尿布}叫做前件，{啤酒}叫做后件。
9. 置信度：对于规则{X}→{Y}，其置信度为Conf=P(Y|X)=P(XY)/P(X)（条件概率公式）。
示例中规则{尿布}→{啤酒}的支持度为3÷3=1（即{尿布, 啤酒}的支持度计数除以
{尿布}的支持度计数），置信度为100%说明买了尿布的人100%也买了啤酒）。
10. 强关联规则：大于或等于最小支持度阈值和最小置信度阈值的规则叫做强关联规则。
11. 提升度：对于规则{X}→{Y}，其提升度为Lift=P(Y|X)/P(Y)=Conf/P(Y)。
提升度度量了后件分别在以前件为条件和不以前件为条件时发生概率的比值。
提升度大于1表示关联规则有效（在X发生的情况下Y发生的概率比Y本身发生的概率大），
提升度小于等于1表示，关联规则无效（在X发生的情况下Y发生的概率不变或者反而变小了）。

关联规则挖掘的最终目的就是要找出有效的强关联规则。

关联规则原理其实很简单，就是贝叶斯公式及其拓展。
关联规则挖掘难点在于如何高效快速地从大量数据中发现有效的强关联规则，
因为事务中不同项的组合可以形成的规则数量很庞大。
(假设有n个商品，潜在的关联规则数量为n*(n-1)+n*(n-1)*(n-2)+···，枚举法几乎不能用)

Apriori算法基于两个定律，能有效提升挖掘效率。

Apriori定律1 ：如果一个集合是频繁项集，则它的所有子集都是频繁项集。
eg. 若集合{A, B}是频繁项集，由于出现{A, B}的地方一定会出现{A}和{B}，
因此{A}和{B}出现的次数一定不小于{A, B}，故{A}和{B}一定是频繁项集。

Apriori定律2 ：如果一个集合不是频繁项集，则它的所有超集都不是频繁项集。
eg. 若集合{A}不是频繁项集，由于出现{A}的地方不一定出现{A, B}，
因此{A, B}出现的次数一定不大于{A}，故{A}的超集{A, B}一定不是频繁项集。

基于两个定律，Apriori思路是以最小支持度为条件先找出所有频繁项集，然后由频繁项集构建规则，
再计算置信度和支持度筛选出有效强关联规则。寻找频繁项集算法流程如下：

step1. 扫描整个数据集，得到所有出现过的项，作为候选频繁1项集C(1)。
step2. 对k >= 1，筛选出频繁k项集L(k)。
step2.1. 计算候选频繁k项集的支持度（需要扫描整个数据集）。
step2.2. 去除候选频繁k项集中支持度低于阈值的项集（依据定律2），
得到频繁k项集L(k)并保存，如果得到的频繁k项集L(k)为空集或只有一项，
则返回所有频繁项集，算法结束。
step2.3. 基于频繁k项集，项集之间取并集生成候选频繁k+1项集C(k+1)。
step3. 令k=k+1，转入step2。

得到所有频繁项集之后，再在频繁项集的子集之间构建规则并计算置信度和提升度，
筛选出有效强关联规则即可。

缺点:
Aprior算法每轮迭代筛选频繁k项集都要扫描整个数据集，因此在数据集很大，
数据种类很多的时候，算法效率仍然很低。

参考:
https://blog.csdn.net/qq_23860475/article/details/80824568
https://www.cnblogs.com/pinard/p/6293298.html
https://www.jianshu.com/p/26d61b83492e
https://blog.csdn.net/zllnau66/article/details/81534368
https://www.cnblogs.com/MaggieForest/p/12176915.html
https://www.jianshu.com/p/fba9e41334a8
https://blog.csdn.net/tangyudi/article/details/88822705

gen_C1

dramkit.datsci.apriori.gen_C1(dataset): 生成初始项集C1，每个项集以python不变集合frozenset格式保存。

数据集dataset为list格式，每个list元素为一个样本（即由不同项组成的事务）。

get_CkSup_and_FreqLk

dramkit.datsci.apriori.get_CkSup_and_FreqLk(dataset, Ck, min_sup): 筛选频繁项集

扫描数据集dataset(dataset为list格式，每条事务记录以set或frozenset格式保存)，

计算Ck中项集的支持度CkSup，并筛选出Ck中不小于最小支持度min_sup的频繁项集列表FreqLk。

gen_Ck_from_FreqLk_1

dramkit.datsci.apriori.gen_Ck_from_FreqLk_1(FreqLk_1, k): 由频繁k-1项集FreqLk_1生成k项集Ck

get_CkSup_and_FreqLk_all

dramkit.datsci.apriori.get_CkSup_and_FreqLk_all(dataset, min_sup=0.5)

Apriori算法寻找最大频繁K项集

Parameters:

dataset (list) – 数据集，list中每个元素为一个样本（即由不同项组成的事务，也为list）
min_sup (float) – 最小支持度阈值

Returns:

FreqLk_all (list) – 所有频繁项集FreqLk，每个元素均为频繁项集列表，如FreqLk_all[1]为所有频繁2项集列表。
CkSup_all (dict) – 所有Ck的支持度

Note

CkSup_all中保存了每一步Ck中所有项集的支持度，因此CkSup_all中并不是所有Ck全部都满足最小支持度的。

curvature

curvature_3point

dramkit.datsci.curvature.curvature_3point(x, y)

根据三个离散点计算曲率

Parameters:

x (list) – 三个点x轴坐标列表
y (list) – 三个点y轴坐标列表

Returns:

curvature (float) – 曲率大小
dircts (np.array) – 曲率方向（标准化）

References

rolling_curvature_3point

dramkit.datsci.curvature.rolling_curvature_3point(data, xcol, ycol, n_pre=3, n_post=3, gap=1): 三点法滚动计算曲率

data(pd.DataFrame)应包含[xcol, ycol]列

返回df包含[‘curvature’, ‘dirct_x’, ‘dirct_y’]三列

plot_curvature

dramkit.datsci.curvature.plot_curvature(data, cols, ax=None, plot_xy=True, std_dirt=False, ax_equal=True, quvier_clor=None, xyline_styl=None, figsize=(9, 6)): 绘制曲率图像

data中的cols应包含绘制曲率所需的全部列，包括：

[x坐标列, y坐标列, 曲率值列, x方向列, y方向列]，且遵循此顺序

elm_cls

ELMClassifier

class dramkit.datsci.elm_cls.ELMClassifier(n_hide=10, func_act='softplus', w_low=- 1, w_up=1, b_low=- 1, b_up=1, c=None, random_state=5262)

Bases: object

极限学习机，分类任务

记输入为层X，输出层为Y，隐藏层为H，样本量为Nsmp、X特征数为NcolX、

隐藏层节点数为n_hide、Y特征数为NcolY，则ELM的过程为：

H(Nsmp*n_hide) = X(Nsmp*NcolX) * w(NcolX*n_hide) + b((Nsmp*1)*n_hide)

Y(Nsmp*NcolY) = H(Nsmp*n_hide) * beta(n_hide*NcolY)

ELM的训练过程：W和b随机生成，beta则利用公式求解析解(beta = H的MP广义逆 * Y)

References

__init__(n_hide=10, func_act='softplus', w_low=- 1, w_up=1, b_low=- 1, b_up=1, c=None, random_state=5262)

Parameters:

n_hide (int) – 隐层节点数
func_act (str, function) – 激活函数，可选[‘softplus’, ‘sigmoid’, ‘tanh’]或自定义
w_low (float) – 输入层—>隐层权重w取值下限
w_up (float) – 输入层—>隐层权重w取值上限
b_low (float) – 输入层—>隐层偏置项b取值下限
b_up (float) – 输入层—>隐层偏置项b取值上限
c (float, None) – 正则化参数
random_state (None, int) – 随机数种子

fit(x_train, y_train)

模型训练

Parameters:

x_train (pd.DataFrame, np.array) – 训练集输入，每行一个样本
y_train (pd.DataFrame, np.array) – 训练集输出，每行一个样本

predict(x): 模型预测，x每行为一个待预测样本

predict_proba(X): 概率预测

static sigmoid(x): sigmoid激活函数

static softplus(x): softplus激活函数

static tanh(x): tanh激活函数

elm_reg

ELMRegressor

class dramkit.datsci.elm_reg.ELMRegressor(n_hide=10, func_act='softplus', w_low=- 1, w_up=1, b_low=- 1, b_up=1, c=None, random_state=5262)

Bases: object

极限学习机，回归任务

记输入为层X，输出层为Y，隐藏层为H，样本量为Nsmp、X特征数为NcolX、

隐藏层节点数为n_hide、Y特征数为NcolY，则ELM的过程为：

H(Nsmp*n_hide) = X(Nsmp*NcolX) * w(NcolX*n_hide) + b((Nsmp*1)*n_hide)

Y(Nsmp*NcolY) = H(Nsmp*n_hide) * beta(n_hide*NcolY)

ELM的训练过程：W和b随机生成，beta则利用公式求解析解(beta = H的MP广义逆 * Y)

References

__init__(n_hide=10, func_act='softplus', w_low=- 1, w_up=1, b_low=- 1, b_up=1, c=None, random_state=5262)

Parameters:

n_hide (int) – 隐层节点数
func_act (str, function) – 激活函数，可选[‘softplus’, ‘sigmoid’, ‘tanh’]或自定义
w_low (float) – 输入层—>隐层权重w取值下限
w_up (float) – 输入层—>隐层权重w取值上限
b_low (float) – 输入层—>隐层偏置项b取值下限
b_up (float) – 输入层—>隐层偏置项b取值上限
c (float, None) – 正则化参数
random_state (None, int) – 随机数种子

fit(x_train, y_train)

模型训练

Parameters:

x_train (pd.DataFrame, np.array) – 训练集输入，每行一个样本
y_train (pd.DataFrame, np.array) – 训练集输出，每行一个样本

predict(x): 模型预测，x每行为一个待预测样本

static sigmoid(x): sigmoid激活函数

static softplus(x): softplus激活函数

static tanh(x): tanh激活函数

entropy_weight

dramkit.datsci.entropy_weight.entropy_weight(df, neg_cols=[], score_type=None)

熵值法计算变量的权重

Parameters:

df (pd.DataFrame) – 样本数据，每行一个样本，每列一个指标，为每个指标计算权重 (注意：df应先删除或填充无效值)
neg_cols (list) – 负向指标列名列表
score_type (None, str) – 可选[None, ‘ori’, ‘std’]，分别表示不计算每个样本得分、以原始数据计算每个样本得分、以标准化数据计算每个样本得分
Returns –
w (pd.DataFrame) – 权重向量’weight’，w.index为df.columns
score (None, pd.DataFrame) – 每个样本得分，列名为’score’，若score_type为None，则为None

References

find_maxmin

dramkit.datsci.find_maxmin.find_maxmin(series, t_min=2, t_max=inf, min_dif_pct=None, min_dif_val=None, max_dif_pct=None, max_dif_val=None, pct_v00=1, skip_nan=True, logger=None)

标注序列中的极值点

Todo

series中存在nan时的值填充及信号纠正处理

Parameters:

series (pd.Series) – 待标注极值点的序列
t_min (int) – 设置极大极小值之间至少需要间隔t_min个点(相当于最小半周期)
t_max (int) – 设置极大极小值直接最大间隔期数(若间隔大于t_max，则直接保留极值点，不进行其它判断)
min_dif_val (float) – 若两个相邻极值点之间的间隔大于等于t_min，但是两者差值/百分比小于 min_dif_val/min_dif_pct，则删除该极值点对
min_dif_pct (float) – 若两个相邻极值点之间的间隔大于等于t_min，但是两者差值/百分比小于 min_dif_val/min_dif_pct，则删除该极值点对
max_dif_val (float) – 若两个相邻极值点之间的间隔小于t_min，但是两者差值/百分比大于 max_dif_val/max_dif_pct，则保留该极值点对（两个参数二选一）
max_dif_pct (float) – 若两个相邻极值点之间的间隔小于t_min，但是两者差值/百分比大于 max_dif_val/max_dif_pct，则保留该极值点对（两个参数二选一）
pct_v00 (float) – 当使用百分比控制差值时，若前一个值为0时，指定的百分比变化值
skip_nan (float) – 当series中存在nan值时，是否继续，若为False，则抛出异常，为True则抛出警告信息
logger (None, Logger) – 日志记录器

Returns:

label – 标注的极值序列，其值中1表示极大值点，-1表示极小值点，0表示普通点

Return type:

pd.Series

check_maxmins

dramkit.datsci.find_maxmin.check_maxmins(df, col, col_label, max_lbl=1, min_lbl=- 1): 检查df中col_label指定列的极值点排列是否正确

要求df须包含指定的两列，其中：

- col_label指定列保存极值点，其值max_lbl(int，默认1)表示极大值， min_lbl(int，默认-1)表示极小值，其余(默认0)为普通点

- col列为序列数值列

返回判断结果(True或False)以及错误信息

find_maxmin_rolling

dramkit.datsci.find_maxmin.find_maxmin_rolling(series, window, cal_n=None, **kwargs)

滚动寻找极值点

Examples

>>> fpath = '../_test/510500.SH_daily_qfq.csv'
>>> df = load_csv(fpath)
>>> df = df.set_index('date', drop=False).iloc[-200:, :]
>>> window, t_min = 100, 3
>>> col = 'close'
>>> df['label'] = find_maxmin_rolling(df[col],
...                                   window=window,
...                                   cal_n=50,
...                                   t_min=t_min)
>>> plot_maxmins(df.iloc[:, :], col, 'label', figsize=(12, 7))

find_maxmin_cum

dramkit.datsci.find_maxmin.find_maxmin_cum(series, window_min=None, cal_n=None, **kwargs)

滚动寻找极值点（用累计历史数据）

Examples

>>> fpath = '../_test/510500.SH_daily_qfq.csv'
>>> df = load_csv(fpath)
>>> df = df.set_index('date', drop=False).iloc[-200:, :]
>>> window_min, t_min = 100, 3
>>> col = 'close'
>>> df['label'] = find_maxmin_cum(df[col],
...                               window_min=window_min,
...                               cal_n=50,
...                               t_min=t_min)
>>> plot_maxmins(df.iloc[:, :], col, 'label', figsize=(12, 7))

get_his_maxmin_info

dramkit.datsci.find_maxmin.get_his_maxmin_info(df, col, col_label, max_lbl=1, min_lbl=- 1): 获取历史极值点序列信息

get_last_pos_info

dramkit.datsci.find_maxmin.get_last_pos_info(df, col, col_label, min_gap=2, max_lbl=1, min_lbl=- 1): 获取最后一条记录在极大极小值间的位置信息

min_gap若大于0，则强制将最后min_gap条记录的标签去除

get_maxmin_neighbor_label

dramkit.datsci.find_maxmin.get_maxmin_neighbor_label(df, label_col, base_col, labels=[- 1, 1], label0=0, max_t=3, max_pct=0.01): 极大极小值邻近点标签标注

Todo

处理不同标签重复标注问题

del_tooclose_maxmin

dramkit.datsci.find_maxmin.del_tooclose_maxmin(df, label_col, base_col, min_pct=0.05): 删除 find_maxmin() 结果中极大值和极小值差别太小的极值点

get_maxmin_records

dramkit.datsci.find_maxmin.get_maxmin_records(df, maxmin_col='maxmin'): 获取所有maxmin记录

get_last_sure_maxmin_info

dramkit.datsci.find_maxmin.get_last_sure_maxmin_info(df, maxmin_col='maxmin', price_col='ma', sure_gap_min=5, sure_pct_min=0.001): 获取最后一个确定的maxmin标签信息

get_continue_maxmin_info

dramkit.datsci.find_maxmin.get_continue_maxmin_info(maxmins_his, maxmin_col='maxmin'): 获取连续maxmin标签的连续期数和信号类型

disaper

dramkit.datsci.find_maxmin.disaper(maxmins_his, loc, col_iloc='idx', tol_gap=10): 判断maxmin信号消失

loc指定位置，tol_gap设置误差范围

find_maxmin_dy

dramkit.datsci.find_maxmin.find_maxmin_dy(df, col, t_min, his_lag=None, use_all=True, minGap_min2now=0, minDif_min2now=None, minPct_min2now=0, maxGap_min2now=inf, maxDif_min2now=None, maxPct_min2now=inf, dirtSureMinGap=inf, dirtSureMinDif=None, dirtSureMinPct=inf, minGap_max2nowMin=0, minDif_max2nowMin=None, minPct_max2nowMin=0, dirtSureMinGap_max2now=inf, dirtSureMinDif_max2now=None, dirtSureMinPct_max2now=inf, Min_max_now=inf, Min_max_pre_min=inf, minGap_max2now=0, minDif_max2now=None, minPct_max2now=0, maxGap_max2now=inf, maxDif_max2now=None, maxPct_max2now=inf, dirtSureMaxGap=inf, dirtSureMaxDif=None, dirtSureMaxPct=inf, minGap_min2nowMax=0, minDif_min2nowMax=None, minPct_min2nowMax=0, dirtSureMaxGap_min2now=inf, dirtSureMaxDif_min2now=None, dirtSureMaxPct_min2now=inf, Max_min_now=- inf, Max_min_pre_max=- inf, logger=None, n_log=None, fig_save_dir=None, plot_all=False, plot_lag=None, kwargs_findMaxMin={}, kwargs_plot={}, plot_sleep=0)

动态标签确定

Todo

待重新实现

Parameters:

his_lag (int, None) – 从第his_lag条记录处开始动态标注，若为None则默认为4*t_min
use_all (bool) – 若为True，每次动态标注时使用之前的所有历史数据，否则只使用前his_lag期数据
动态确定标签参数和规则（以确定极小值信号为例，极大值同理），（待补充） –
logger (Logger, None) – 日志记录器
n_log (int, None) – 每隔n_log期日志提示进度
fig_save_dir (str, bool) – 若为False，则不做图；若为文件夹路径，则画图并保存到文件夹；若为None，则绘图但不保存
plot_all (bool) – 若为False，则只有在确定为极大/小值是才绘图，否则每期都绘图
plot_lag (None, str, int) – 指定每次画图时往前取plot_lag期历史数据进行绘图。若为None，则取his_lag；若为`all`，则取所有历史期数。

freq_item_set

频繁项集挖掘数据集和算法研究资料参考：
http://fimi.uantwerpen.be/
http://fimi.uantwerpen.be/data/
http://fimi.uantwerpen.be/src/

gen_rules

dramkit.datsci.freq_item_set.gen_rules(FreqSets, setSups, min_conf=0.7): 生成关联规则并计算置信度和提升度

FreqSets(list)为所有频繁项集列表

setSups(dict)为项集支持度，FreqSets中的所有元素必须出现在setSups的keys中

(注：输入参数FreqSets和setSups格式同 dramkit.datsci.apriori.get_CkSup_and_FreqLk_all() 函数的输出)

apriori_dramkit

dramkit.datsci.freq_item_set.apriori_dramkit(dataset, min_sup, min_conf): Apriori主函数

dataset为list数据集，每个元素为一个样本(由不同项组成的事务，也为list)

min_sup, min_conf分别为最小支持度和最小置信度阈值

返回list格式规则列表rules，每条规则包含：

[前件, 后件, 前件支持度, 后件支持度, 支持度, 置信度, 提升度]

rules2df

dramkit.datsci.freq_item_set.rules2df(rules, joiner='&'): 将列表格式rules（gen_rules函数的输出格式）转存为pd.DataFrame格式， joiner设置项集元素之间的文本连接符

arpiori_mlx

dramkit.datsci.freq_item_set.arpiori_mlx(dataset, min_sup, min_conf, joiner='&'): 调用mlxtend的Apriori算法实现关联规则挖掘

dataset为list数据集，每个元素为一个样本(由不同项组成的事务，也为list)

min_sup, min_conf分别为最小支持度和最小置信度阈值

返回pd.DataFrame结果

joiner设置项集元素之间的文本连接符

fpgrowth_mlx

dramkit.datsci.freq_item_set.fpgrowth_mlx(dataset, min_sup, min_conf, joiner='&'): 调用mlxtend的FP-growth算法实现关联规则挖掘

dataset为list数据集，每个元素为一个样本(由不同项组成的事务，也为list)

min_sup, min_conf分别为最小支持度和最小置信度阈值

返回pd.DataFrame结果

joiner设置项集元素之间的文本连接符

lr

LRClassifierBinary

class dramkit.datsci.lr.LRClassifierBinary(opt_method='gd', max_iter=1000, lr=0.01)

Bases: object

逻辑回归二分类

记输入为X，输出为y，则逻辑回归二分类模型表达式为：

y` = Sigmoid(X * W  + b)，其中y`表示模型预测值，
将截距项b并入W（在X中添加常数项变量），简写为：
y` = Sigmoid(X * W)
其中Sigmoid函数为: Sigmoid(x) = 1.0 / (1 + np.exp(-x))

代价函数为：

Cost = y * ln(y`) + (1-y) * ln(1-y`)

（分类正确代价为0，分类错误代价无穷大，由极大似然估计得来）

转为最小化问题后总代价函数为：

Cost = -Sum(y * ln(y`) + (1-y) * ln(1-y`))

梯度下降法：

根据上面三个方程，用链式求导法则可得到Cost对W的导数：

J = X * (y` - y)

J即为梯度下降法中的梯度

牛顿法：待补充

参考：

https://www.cnblogs.com/loongofqiao/p/8642045.html

__init__(opt_method='gd', max_iter=1000, lr=0.01)

Parameters:

opt_method (str) – 优化算法设置，默认梯度下降’gd’，牛顿法为’newton’或’nt’
max_iter (int) – 最大迭代次数
lr (float) – 学习速率

static add_const(X): X添加常数列，X为二维

fit(X_train, y_train)

模型训练

Parameters:

X_train (pd.DataFrame, np.array) – 训练集输入，每行一个样本
y_train (pd.Series, pd.DataFrame, np.array) – 训练集输出，每行一个样本

forward(X, w, b): 前向传播（模型表达式）

predict(X, p_cut=0.5): 标签预测

predict_proba(X): 概率预测

static sigmoid(x): sigmoid激活函数

lr_fit_sm

dramkit.datsci.lr.lr_fit_sm(X, y): statsmodels线性回归拟合

preprocess

ExternalStd

class dramkit.datsci.preprocess.ExternalStd(nstd=3, cols=None)

Bases: object

极端值处理，标准差倍数法

cut_mad

dramkit.datsci.preprocess.cut_mad(series, n=3, up_cut_val=None, low_cut_val=None, func_filter=None): MAD极端值处理方法

func_filter为对计算中位数和偏差之前对数据进行筛的函数，返回值为True的才参与计算

cut_nstd

dramkit.datsci.preprocess.cut_nstd(series, n=3, up_cut_val=None, low_cut_val=None): 标准差倍数截断方法，极端值处理

norm_std

dramkit.datsci.preprocess.norm_std(series, reverse=False, ddof=1, return_mean_std=False)

z-score标准化

Parameters:

series (series, pd.Series, np.array) – 待标准化序列数据
reverse – 是否反向标准化
ddof (int) –

指定计算标准差时是无偏还是有偏的：

ddof=1时计算的是无偏标准差（样本标准差，分母为n-1），

ddof=0时计算的是有偏标准差（总体标准差，分母为n）

Hint

pandas的std()默认计算的是无偏标准差，

numpy的std()默认计算的是有偏标准差
return_mean_std (bool) – 为True时同时返回均值和标准差，为False时不返回

Note

Z-score适用于series的最大值和最小值未知或有超出取值范围的离群值的情况。

(一般要求原始数据的分布可以近似为高斯分布，否则效果可能会很糟糕)

References

https://blog.csdn.net/qxqxqzzz/article/details/88663198

norm_linear

dramkit.datsci.preprocess.norm_linear(x, xmin, xmax, ymin=0, ymax=1, reverse=False, x_must_in_range=True, v_xmin_eq_xmax=nan, v_ymin_eq_ymax=nan): 线性映射：

将取值范围在[xmin, xmax]内的x映射到取值范围在[ymin, ymax]内的xnew

reverse设置是否反向，若为True，则映射到[ymax, ymin]范围内

x_must_in_range设置当x不在[xmin, xmax]范围内时是否报错

v_xmin_eq_xmax设置当xmin和xmax相等时的返回值

series_norm_linear

dramkit.datsci.preprocess.series_norm_linear(series, ymin=0, ymax=1, reverse=False): 对series的值进行线性映射，参考 norm_linear() 函数

norm_mid

dramkit.datsci.preprocess.norm_mid(x, xmin, xmax, ymin=0, ymax=1, xbest=None): 中间型（倒V型）指标的正向化线性映射，新值范围为[nmin, ymax]

(指标值既不要太大也不要太小，适当取中间值最好，如水质量评估PH值)

xmin和xmax为指标可能取到的最小值和最大值

xbest指定最优值，若不指定则将xmin和xmax的均值当成最优值

参考：https://zhuanlan.zhihu.com/p/37738503

norm01_mid

dramkit.datsci.preprocess.norm01_mid(x, xmin, xmax, xbest=None): 中间型（倒V型）指标的正向化和（线性）01标准化

(指标值既不要太大也不要太小，适当取中间值最好，如水质量评估PH值)

xmin和xmax为指标可能取到的最小值和最大值

xbest指定最优值，若不指定则将xmin和xmax的均值当成最优值

参考：https://zhuanlan.zhihu.com/p/37738503

norm_side

dramkit.datsci.preprocess.norm_side(x, xmin, xmax, ymin=0, ymax=1, xworst=None, v_out_limit=None): 两边型（V型）指标的正向化线性映射，新值范围为[ymin, ymax]

(指标越靠近xmin或越靠近xmax越好，越在中间越不好)

xmin和xmax为指标可能取到的最小值和最大值

xworst指定最差值，若不指定则将xmin和xmax的均值当成最差值

v_out_limit指定当x超过xmin或xmax界限之后的正向标准化值，不指定则默认为ymax

norm01_side

dramkit.datsci.preprocess.norm01_side(x, xmin, xmax, xworst=None, v_out_limit=1): 两边型（V型）指标的正向化和（线性）01标准化

(指标越靠近xmin或越靠近xmax越好，越在中间越不好)

xmin和xmax为指标可能取到的最小值和最大值

xworst指定最差值，若不指定则将xmin和xmax的均值当成最差值

v_out_limit指定当x超过xmin或xmax界限之后的正向标准化值，不指定则默认为1

norm_range

dramkit.datsci.preprocess.norm_range(x, xmin, xmax, xminmin, xmaxmax, ymin=0, ymax=1): 区间型指标的正向化正向化线性映射，新值范围为[ymin, ymax]

(指标的取值最好落在某一个确定的区间最好，如体温)

[xmin, xmax]指定指标的最佳稳定区间，[xminmin, xmaxmax]指定指标的最大容忍区间

参考：https://zhuanlan.zhihu.com/p/37738503

norm01_range

dramkit.datsci.preprocess.norm01_range(x, xmin, xmax, xminmin, xmaxmax): 区间型指标的正向化和（线性）01标准化

(指标的取值最好落在某一个确定的区间最好，如体温)

[xmin, xmax]指定指标的最佳稳定区间，[xminmin, xmaxmax]指定指标的最大容忍区间

参考：https://zhuanlan.zhihu.com/p/37738503

get_pca

dramkit.datsci.preprocess.get_pca(df, dfs_trans=None, **kwargs_pca)

PCA主成分转化

Parameters:

df (pandas.DataFrame) – 用于训练PCA模型的数据
df_trans (None, list) –

待转化数据列表，每个元素都是pandas.DataFrame，

即用训练好的PCA模型对dfs_trans中所有的数据进行主成分转化
**kwargs_pca – sklearn.decomposition.PCA接受的参数

Returns:

df_pca (pandas.DataFrame) – df进行PCA转化之后的数据，列名格式为’imfk’(第k列表示第k个主成分)
dfs_transed (tuple) – 利用df训练好的PCA模型对dfs_trans中的数据进行主成分转化之后的结果

Todo

改成跟 scale_skl() 和 scale_skl_inverse() 函数那样有返回训练好的模型以及用训练好的模型进行转换

scale_skl

dramkit.datsci.preprocess.scale_skl(df_fit, dfs_trans=None, cols=None, scale_type='std', **kwargs)

用sklearn进行数据标准化处理

Parameters:

df_fit (pandas.DataFrame) – 训练数据，用于计算标准化中间变量
dfs_trans (None, pandas.DataFrame, list) – 需要以df_fit为基准进行标准化的df或df列表
cols (None, list) – 指定需要标准化的列，默认对所有列进行标准化
scale_type (str) –

指定标准化类型:

std 或 z-score 使用 sklearn.preprocessing.StandardScaler

maxmin 或 minmax 使用 sklearn.preprocessing.MinMaxScaler
**kwargs – 接收对应Scaler支持的参数

Returns:

df_fited (pandas.DataFrame) – df_fit标准化之后的数据
dfs_transed (None, pandas.DataFrame, tuple) – dfs_trans标准化之后对应的数据
scaler_info (tuple) – 包含scaler即df_fit计算得到的标准化中间变量信息; cols即用到的列名列表

scale_skl_inverse

dramkit.datsci.preprocess.scale_skl_inverse(scaler, dfs_to_inv, cols=None, **kwargs)

反标准化还原数据

Parameters:

scaler (class) – fit过的sklearn Scaler类(如StandardScaler、MinMaxScaler)
dfs_to_inv (pandas.DataFrame, list) – 待还原的df或df列表
cols (None, list) – 指定需要还原的列名列表，默认所有列
**kwargs – 接收scaler.inverse_transform函数支持的参数

Returns:

pandas.DataFrame, tuple - 反标准化还原之后对应的数据

Note

注：(scaler, cols)应与scale_skl函数输出一致

get_miss_rate

dramkit.datsci.preprocess.get_miss_rate(df, cols=None, return_type='dict'): 计算df(pd.DataFrame)中指定cols列的缺失率，return_type可选[‘dict’, ‘df’]

Todo

cols可为str，指定单列，返回单个值

drop_miss_feature

dramkit.datsci.preprocess.drop_miss_feature(data, cols=None, thre=0.8): 删除缺失率大于thre的列

drop_miss_sample

dramkit.datsci.preprocess.drop_miss_sample(data, thre=0.5, cols=None): 删除数据缺失率大于thre的样本（行）

注：应保证data.index是唯一的

fillna_ma

dramkit.datsci.preprocess.fillna_ma(series, ma=None, ma_min=2): 用移动平均MA填充序列series(pd.Series)中的缺失值

ma(int)设置填充时向前取平均数用的期数，ma_min(int)设置最小期数

若ma为None，则根据最大连续缺失记录数确定ma期数(取2*最大连续缺失期数)

返回替换之后的 pd.Series

fillna_by_mean

dramkit.datsci.preprocess.fillna_by_mean(df, cols=None): 用列均值替换df(pd.DataFrame)中的无效值，cols(list)指定待替换列

fillna_by_median

dramkit.datsci.preprocess.fillna_by_median(df, cols=None): 用列中位数替换df(pd.DataFrame)中的无效值，cols(list)指定待替换列

stats

fpdf

dramkit.datsci.stats.fpdf(x, df1, df2, loc=0, scale=1): 计算符合自由度为df1和df2的F分布的随机变量取x时的概率密度函数值

loc和scale为scipy.stats中f分布参数

fcdf

dramkit.datsci.stats.fcdf(x, df1, df2, loc=0, scale=1): 计算符合自由度为df1和df2的F分布的随机变量取x时的概率分布函数值

loc和scale为scipy.stats中f分布参数

ffit

dramkit.datsci.stats.ffit(series): 对series (pd.Series 或 np.array)进行F分布参数估计

返回顺序: df1, df2, loc, scale

fit_f_pdf

dramkit.datsci.stats.fit_f_pdf(series, x): 用series (pd.Series 或 np.array)拟合一个F分布，

并计算随机变量在该分布下取值为x时的概率密度函数值

fit_f_cdf

dramkit.datsci.stats.fit_f_cdf(series, x): 用series (pd.Series 或 np.array)拟合一个F分布，

并计算随机变量在该分布下取值为x时的概率分布函数值

ftest

dramkit.datsci.stats.ftest(series, plot=False, **kwargs_plot): 对series (pd.Series 或 np.array)进行F分布检验(采用KS检验)

返回顺序: (统计量, P值), (df1, df2, loc, scale)

tpdf

dramkit.datsci.stats.tpdf(x, df, loc=0, scale=1): 计算符合自由度为df的T分布的随机变量取x时的概率密度函数值

loc和scale为scipy.stats中t分布参数

tcdf

dramkit.datsci.stats.tcdf(x, df, loc=0, scale=1): 计算符合自由度为df的T分布的随机变量取x时的概率分布函数值

loc和scale为scipy.stats中t分布参数

tfit

dramkit.datsci.stats.tfit(series): 对series (pd.Series 或 np.array)进行T分布参数估计

返回顺序: df, loc, scale

fit_t_pdf

dramkit.datsci.stats.fit_t_pdf(series, x): 用series (pd.Series 或 np.array)拟合一个T分布，

并计算随机变量在该分布下取值为x时的概率密度函数值

fit_t_cdf

dramkit.datsci.stats.fit_t_cdf(series, x): 用series (pd.Series 或 np.array)拟合一个T分布，

并计算随机变量在该分布下取值为x时的概率分布函数值

ttest

dramkit.datsci.stats.ttest(series, plot=False, **kwargs_plot): 对series (pd.Series 或 np.array)进行T分布检验(采用KS检验)

返回顺序: (统计量, P值), (df, loc, scale)

chi2pdf

dramkit.datsci.stats.chi2pdf(x, df, loc=0, scale=1): 计算符合自由度为df的卡方分布的随机变量取x时的概率密度函数值

loc和scale为scipy.stats中卡方分布参数

chi2cdf

dramkit.datsci.stats.chi2cdf(x, df, loc=0, scale=1): 计算符合自由度为df的卡方分布的随机变量取x时的概率分布函数值

loc和scale为scipy.stats中卡方分布参数

chi2fit

dramkit.datsci.stats.chi2fit(series): 对series (pd.Series 或 np.array)进行卡方分布参数估计

返回顺序: df, loc, scale

fit_chi2_pdf

dramkit.datsci.stats.fit_chi2_pdf(series, x): 用series (pd.Series 或 np.array)拟合一个卡方分布，

并计算随机变量在该分布下取值为x时的概率密度函数值

fit_chi2_cdf

dramkit.datsci.stats.fit_chi2_cdf(series, x): 用series (pd.Series 或 np.array)拟合一个卡方分布，

并计算随机变量在该分布下取值为x时的概率分布函数值

chi2test

dramkit.datsci.stats.chi2test(series, plot=False, **kwargs_plot): 对series (pd.Series 或 np.array)进行卡方分布检验(采用KS检验)

返回顺序: (统计量, P值), (df, loc, scale)

normpdf

dramkit.datsci.stats.normpdf(mu, sigma, x): 计算符合正态分布N(mu, sigma)的随机变量取x时的概率密度函数值

normcdf

dramkit.datsci.stats.normcdf(mu, sigma, x): 计算符合正态分布N(mu, sigma)的随机变量取x时的概率密分布数值

normfit

dramkit.datsci.stats.normfit(series): 对series (pd.Series 或 np.array)进行正态分布参数估计

返回顺序: mu, sigma

fit_norm_pdf

dramkit.datsci.stats.fit_norm_pdf(series, x): 用series (pd.Series 或 np.array)拟合一个正态分布，

并计算随机变量在该分布下取值为x时的概率密度函数值

fit_norm_cdf

dramkit.datsci.stats.fit_norm_cdf(series, x): 用series (pd.Series 或 np.array)拟合一个正态分布，

并计算随机变量在该分布下取值为x时的概率分布函数值

normtest

dramkit.datsci.stats.normtest(series, plot=False, **kwargs_plot): 对series (pd.Series 或 np.array)进行正态分布检验(采用KS检验)

返回顺序: (统计量, P值), (mu, sigma)

lognormpdf

dramkit.datsci.stats.lognormpdf(mu, sigma, x): 计算符合参数为mu, sigma的对数正态分布的随机变量取x时的概率密度函数值

lognormcdf

dramkit.datsci.stats.lognormcdf(mu, sigma, x): 计算符合参数为mu, sigma的对数正态分布的随机变量取x时的概率分布函数值

lognormfit

dramkit.datsci.stats.lognormfit(series): 对series (pd.Series 或 np.array)进行对数正态分布参数估计

返回顺序: mu, sigma

Hint

scipy.stats中lognorm分布参数估计和 lognormpdf() 中参数关系：

若设置floc=0（即始终loc=0），则有s = sigma，scale = e ^ mu

fit_lognorm_pdf

dramkit.datsci.stats.fit_lognorm_pdf(series, x): 用series (pd.Series 或 np.array)拟合一个对数正态分布，

并计算随机变量在该分布下取值为x时的概率密度函数值

fit_lognorm_cdf

dramkit.datsci.stats.fit_lognorm_cdf(series, x): 用series (pd.Series 或 np.array)拟合一个对数正态分布，

并计算随机变量在该分布下取值为x时的概率分布函数值

lognormtest

dramkit.datsci.stats.lognormtest(series, plot=False, **kwargs_plot): 对series (pd.Series 或 np.array)进行对数正态分布检验(采用KS检验)

返回顺序: (统计量, P值), (mu, sigma)

weibullpdf

dramkit.datsci.stats.weibullpdf(k, lmd, x): 计算符合参数为k, lmd的威布尔分布的随机变量取x时的概率密度函数值

weibullcdf

dramkit.datsci.stats.weibullcdf(k, lmd, x): 计算符合参数为k, lmd的威布尔分布的随机变量取x时的概率分布函数值

weibullfit

dramkit.datsci.stats.weibullfit(series): 对series (pd.Series 或 np.array)进行威布尔分布参数估计

返回顺序: k, lmd

Hint

scipy.stats中weibull_min分布参数估计和 weibullpdf() 中 weibull分布参数关系：

若设置floc=0（即始终loc=0），则有c = k，scale = lmd

scipy.stats中weibull_min分布参数估计和 np.random.weibull 分布参数关系：

若设置floc=0（即始终loc=0），则有c = a，scale = 1

fit_weibull_pdf

dramkit.datsci.stats.fit_weibull_pdf(series, x): 用series (pd.Series 或 np.array)拟合一个威布尔分布，

并计算随机变量在该分布下取值为x时的概率密度函数值

fit_weibull_cdf

dramkit.datsci.stats.fit_weibull_cdf(series, x): 用series (pd.Series 或 np.array)拟合一个威布尔分布，

并计算随机变量在该分布下取值为x时的概率分布函数值

weibulltest

dramkit.datsci.stats.weibulltest(series, plot=False, **kwargs_plot): 对series (pd.Series 或 np.array)进行威布尔分布检验(采用KS检验)

返回顺序: (统计量, P值), (k, lmd)

mse

dramkit.datsci.stats.mse(y_true, y_predict)

计算均方误差MSE

Parameters:

y_true (np.array, pd.Series) – 真实值
y_predict (np.array, pd.Series) – 预测值

Returns:

float - MSE值

r2

dramkit.datsci.stats.r2(y_true, y_predict, is_linear=False)

计算拟合优度R^2

Parameters:

y_true (np.array, pd.Series) – 真实值
y_predict (np.array, pd.Series) – 预测值
is_linear (bool) – 预测值是否为线性回归结果

Returns:

float - R^2值

Hint

在线性回归情况下（y_predict是由y_true与自变量X进行线性拟合的预测值），有:

R2 = 1 - SSres / SStot = SSreg / SStot，

且此时R2与y_true和y_predict相关系数的平方相等

非线性回归情况下，1 - SSres / SStot != SSreg / SStot，R2与两者相关系数平方也不相等

可设置is_linear为True和False进行比较验证

References

https://blog.csdn.net/wade1203/article/details/98477034 https://blog.csdn.net/liangyihuai/article/details/88560859 https://wenku.baidu.com/view/893b22d66bec0975f465e2b8.html

r2adj

dramkit.datsci.stats.r2adj(y_true, y_predict, k)

计算调整R^2

Parameters:

y_true (np.array, pd.Series) – 真实值
y_predict (np.array, pd.Series) – 预测值
k (int) –
预测y所用自变量个数

Note

线性回归中常量也算一个变量，例如y=ax+b，则k为2

Returns:

float - 调整R^2值

References

http://blog.sciencenet.cn/blog-651374-975670.html

r2adj_by_r2

dramkit.datsci.stats.r2adj_by_r2(r2, n, k): 通过R^2计算调整R^2, n为样本量, k为自变量个数

注：线性回归中常量也算一个变量，例如y=ax+b，则k为2

r2_by_mse

dramkit.datsci.stats.r2_by_mse(mse, y_true)

根据MSE和真实值y_true(pd.Series, np.array)计算拟合优度R^2

References

https://blog.csdn.net/wade1203/article/details/98477034 https://blog.csdn.net/liangyihuai/article/details/88560859

r2adj_by_mse

dramkit.datsci.stats.r2adj_by_mse(mse, y_true, k): 通过MSE计算调整R^2, y_true为真实值(pd.Series, np.array), n为样本量, k为自变量个数

注：线性回归中常量也算一个变量，例如y=ax+b，则k为2

r2_by_r2adj

dramkit.datsci.stats.r2_by_r2adj(r2adj, n, k): 通过调整R^2计算R^2, n为样本量, k为自变量个数

注：线性回归中常量也算一个变量，例如y=ax+b，则k为2

mse_by_r2

dramkit.datsci.stats.mse_by_r2(r2, y_true): 根据R^2和真实值y_true(pd.Series, np.array)计算MSE

rmse

dramkit.datsci.stats.rmse(y_true, y_predict): 计算RMSE, y_true, y_predict为 pd.Series 或 np.array

mae

dramkit.datsci.stats.mae(y_true, y_predict): 计算MAE, y_true, y_predict为 pd.Series 或 np.array

mape

dramkit.datsci.stats.mape(y_true, y_predict): 计算MAPE, y_true, y_predict为 pd.Series 或 np.array

Note

当y_true存在0值时MAPE不可用

smape

dramkit.datsci.stats.smape(y_true, y_predict)

计算SMAPE，y_true, y_predict为 pd.Series 或 np.array

Note

当y_true和y_predict均为0值时SMAPE不可用

References

https://blog.csdn.net/guolindonggld/article/details/87856780

avedev

dramkit.datsci.stats.avedev(arr)

AVEDEV函数，arr为 np.array 或 pd.Series

References

https://support.microsoft.com/en-us/office/avedev-function-58fe8d65-2a84-4dc7-8052-f3f87b5c6639?ui=en-us&rs=en-us&ad=us

cal_linear_reg_r

dramkit.datsci.stats.cal_linear_reg_r(y, x=None, fit_intercept=True): 简单计算一元线性回归斜率

y和x为 list 或 pd.Series 或 np.array (x和y均为一维)

若x为None，则回归自变量取range(0, len(y))

fit_intercept=True时返回斜率和截距，否则只返回斜率

cummean

dramkit.datsci.stats.cummean(series, skipna=True): 滚动计算序列series(list, np.array, pd.Series)累计均值

skip设置是否忽略无效值记录

delta_var_d0

dramkit.datsci.stats.delta_var_d0(n0, mean0, var0, n1, mean1, var1)

自由度为0情况下的增量方差计算

n, mean, var分别为第一组和第二组(增量)样本的样本量、均值和自由度为0的方差

References

https://www.cnblogs.com/yoyaprogrammer/p/delta_variance.html https://blog.csdn.net/u013337691/article/details/119326155

delta_var_d

dramkit.datsci.stats.delta_var_d(n0, mean0, var0, n1, mean1, var1, ddof=1)

增量方差算法：根据已经算好的两组样本的方差、均值和样本量计算两组数合并之后的方差
n, mean, var分别为两组样本的样本量、均值和自由度为ddof的方差
注：跟 delta_var() 的区别在于本函数调用了 delta_var_d0()

References

https://www.cnblogs.com/yoyaprogrammer/p/delta_variance.html https://blog.csdn.net/u013337691/article/details/119326155

delta_var

dramkit.datsci.stats.delta_var(n0, mean0, var0, n1, mean1, var1, ddof=1)

增量方差算法：根据已经算好的两组样本的方差、均值和样本量计算两组数合并之后的方差
n, mean, var分别为两组样本的样本量、均值和自由度为ddof的方差
注：跟 delta_var_d() 的区别在于本函数没调用 delta_var_d0()

References

https://www.cnblogs.com/yoyaprogrammer/p/delta_variance.html https://blog.csdn.net/u013337691/article/details/119326155

cumvar_nonan

dramkit.datsci.stats.cumvar_nonan(series, ddof=1)

滚动累计方差算法

Parameters:

series (pd.Series, np.array) – 目标序列，不应有无效值
ddof (int) – 自由度

Returns:

np.array - 滚动累计方差计算结果

Note

series会被当成没有无效值处理

cumvar

dramkit.datsci.stats.cumvar(series, ddof=1, skipna=True)

滚动累计方差算法

Parameters:

series (np.array, pd.Series) – 目标序列，不应有无效值
ddof (int) – 自由度
skipna (bool) – 是否忽略无效值

Returns:

pd.Series - 滚动累计方差计算结果

cumstd

dramkit.datsci.stats.cumstd(series, ddof=1, skipna=True): 滚动计算序列累计标准差，参数意义同 cumvar()

cum_scale

dramkit.datsci.stats.cum_scale(series, scale_type=('maxmin', 0, 1))

序列累计标准化

Parameters:

series (np.array, pd.Series) – 待计算目标序列
scale_type (tuple) –
标准化设置，可选：
- 最大最小标准化：(‘maxmin’, Nmin, Nmax)
- 标准偏差法/Z-Score：(‘std’, ) 或 ‘std’

Returns:

pd.Series - 累计标准化计算结果

rolling_scale

dramkit.datsci.stats.rolling_scale(series, lag, scale_type=('maxmin', 0, 1))

序列滚动标准化

Parameters:

series (np.array, pd.Series) – 待计算目标序列
lag (int) – 滚动窗口
scale_type (tuple) –
标准化设置，可选：
- 最大最小标准化：(‘maxmin’, Nmin, Nmax)
- 标准偏差法/Z-Score：(‘std’, ) 或 ‘std’

Returns:

pd.Series - 滚动标准化计算结果

get_quantiles

dramkit.datsci.stats.get_quantiles(series, method='dense'): 计算series(pd.Series, np.array)中每个数所处的百分位

method决定并列排序序号确定方式，见pd中rank函数的参数

cumrank_nonan

dramkit.datsci.stats.cumrank_nonan(series, ascending=True, method='dense')

滚动计算累计排序号，使用二分法改进的插入排序法

Parameters:

series (list, pd.Series, np.array) – 待排序目标序列
ascending (bool) – 是否升序
method (str) – 排序规则，见pd中rank函数的参数

Returns:

list - 滚动累计排序序号列表

Note

series会被当成没有无效值处理

cumrank

dramkit.datsci.stats.cumrank(series, ascending=True, method='dense')

滚动计算累计排序号

Parameters:

series (list, pd.Series, np.array) – 待排序目标序列
ascending (bool) – 是否升序
method (str) – 排序规则，见pd中rank函数的参数

Returns:

pd.Series - 滚动累计排序序号

Note

series中无效值会被忽略

get_pct_loc

dramkit.datsci.stats.get_pct_loc(value, series, isnew=True, method='dense'): 给定value(float)和series(pd.Series, np.array)，计算value在series中所处百分位

若isnew为True，则将value当成新数据，若为False，则当成series中已经存在的数据

method决定并列排序序号确定方式，参见pd中的rank函数参数

cum_n_unique

dramkit.datsci.stats.cum_n_unique(series, skipna=True): 滚动计算series(np.array, pd.Series, list)中值的unique个数

返回list

cum_n_unique_pd

dramkit.datsci.stats.cum_n_unique_pd(series, skipna=True): 滚动计算series(np.array, pd.Series, list)中值的unique个数

返回list

与 cum_n_unique() 的区别是此函数使用pandas计算而不是循环迭代

cum_pct_loc

dramkit.datsci.stats.cum_pct_loc(series, method='dense'): 滚动计算series(np.array, pd.Series)数据累计所处百分位

调用 dramkit.datsci.stats.cum_n_unique_pd() 函数

rolling_pct_loc

dramkit.datsci.stats.rolling_pct_loc(series, lag, method='dense'): 滚动计算series(np.array, pd.Series)数据所处百分位

lag为滚动窗口长度

method为排序处理方式，见pd中的rank函数参数

parms_est

dramkit.datsci.stats.parms_est(): 各种分布不同方法的参数估计，待实现

auc

dramkit.datsci.stats.auc(): 计算auc，待实现

var_hom_test

dramkit.datsci.stats.var_hom_test(s1, s2): 方差齐性检验，待实现

ind_ttest

dramkit.datsci.stats.ind_ttest(s1, s2): 独立样本T检验，待实现

rel_ttest

dramkit.datsci.stats.rel_ttest(s1, s2): 配对样本T检验，待实现

anova_oneway

dramkit.datsci.stats.anova_oneway(df, col_val, col_group): 单因素方差分析，col_val为待比较列，col_group为组别列，待实现

time_series

时间序列处理工具函数

Todo

改成class以简化函数调用传参

fillna_ma

dramkit.datsci.time_series.fillna_ma(series, ma=None, ma_min=1): 用移动平均ma填充序列series中的缺失值

ma设置填充时向前取平均数用的期数，ma_min设置最小期数

若ma为None，则根据最大连续缺失记录数确定ma期数

get_directional_accuracy_1step

dramkit.datsci.time_series.get_directional_accuracy_1step(y_true, y_pred): 一步向前预测方向准确率计算

y_true和y_pred为pd.Series

genXy_X2d_y1d1step

dramkit.datsci.time_series.genXy_X2d_y1d1step(df, ycol, Xcols_series_lag=None, Xcols_other=None, gap=0)

构造时间序列预测的输入X和输出y，适用于X二维，ycol一维一步向前预测情况

Todo

gap为-1的情况检查确认

Parameters:

df (pd.DataFrame) – 包含因变量列和所有自变量列的数据集
ycol (str) – 因变量序列名
Xcols_series_lag (list, None) –

序列自变量列名和历史期数，格式如：

[(xcol1, lag1), (xcol2, lag2), …]

若为None，则默认设置为[(ycol, 3)]
Xcols_other (list, None) –
非序列自变量列名列表

Note

序列自变量视为不能拿到跟因变量预测同期的数据，非序列自变量视为可以拿到同期数据
gap (int) – 预测跳跃期数（eg.用截止今天的数据预测gap天之后的数据）

Returns:

X (np.array) – 二维np.array，行数为样本量，列数为特征数量
y (np.array) – 一维np.array，长度等于样本量

predict_X2d_y1d1step

dramkit.datsci.time_series.predict_X2d_y1d1step(model, func_pred, df_pre, ycol, Xcols_series_lag, Xcols_other, gap, **kwargs)

使用训练好的模型在数据df_pre上进行构造样本并预测(非滚动预测)

适用于X二维、ycol一维一步向前预测情况

Parameters:

model – 训练好的预测模型
func_pred (function) – func_pred为预测函数，接受必要参数model和X，也接受可选参数**kwargs
df_pre (pd.DataFrame) – 待预测所用数据，其中 ycol 为待预测列
Xcols_series_lag – 参数意义同 genXy_X2d_y1d1step() 中参数意义
Xcols_other – 参数意义同 genXy_X2d_y1d1step() 中参数意义
gap – 参数意义同 genXy_X2d_y1d1step() 中参数意义

Returns:

pd.DataFrame - 返回pd.DataFrame包含原来的数据以及预测结果ycol+’_pre’列

valid_test_predict_X2d_y1d1step

dramkit.datsci.time_series.valid_test_predict_X2d_y1d1step(model, func_pred, df_train, df_valid, df_test, ycol, Xcols_series_lag, Xcols_other, gap, **kwargs)

用训练好的模型做时间序列验证集和测试集预测(非滚动预测, 即不使用前面预测的数据作为输入)

适用于X二维、ycol一维一步向前预测情况

Parameters:

model – 与 predict_X2d_y1d1step() 参数意义相同
func_pred – 与 predict_X2d_y1d1step() 参数意义相同
ycol – 与 predict_X2d_y1d1step() 参数意义相同
Xcols_series_lag – 与 predict_X2d_y1d1step() 参数意义相同
Xcols_other – 与 predict_X2d_y1d1step() 参数意义相同
gap – 与 predict_X2d_y1d1step() 参数意义相同
**kwargs – 与 predict_X2d_y1d1step() 参数意义相同
df_train (pd.DataFrame) – df_train为用作训练的数据
df_valid (pd.DataFrame) – df_valid为验证集待预测数据
df_test (pd.DataFrame) –
df_test为测试集待预测数据

Note

df_valid和df_test的列须与df_train相同

df_valid和df_test可以为None或pd.DataFrame

df_train、df_valid、df_test须为连续时间序列

当df_test不为空时，df_valid的ycol列必须有真实值

Returns:

valid_pre (pd.DataFrame) – 验证集预测结果，包含ycol+’_pre’列
test_pre (pd.DataFrame) – 测试集预测结果，包含ycol+’_pre’列

forward_predict_X2d_y1d1step

dramkit.datsci.time_series.forward_predict_X2d_y1d1step(model, func_pred, df_pre, ycol, Xcols_series_lag, Xcols_other, gap, **kwargs)

用训练好的模型做在数据df_pre上进行构造样本并进行向前滚动预测(前面的预测作为后面的输入)

适用于X二维、ycol一维一步向前预测情况

Todo

gap为-1的情况检查确认

Parameters:

model – 训练好的预测模型
func_pred (function) – func_pred为预测函数，接受必要参数model和X，也接受可选参数**kwargs
df_pre (pd.DataFrame) – 待预测所用数据，其中 ycol 为待预测列。除了初始构造输入X必须满足的数据行外，后面的数据可以为空值
Xcols_series_lag – 参数意义同 genXy_X2d_y1d1step() 中参数意义，用其构造输入变量的过程亦完全相同
Xcols_other – 参数意义同 genXy_X2d_y1d1step() 中参数意义，用其构造输入变量的过程亦完全相同
gap – 参数意义同 genXy_X2d_y1d1step() 中参数意义，用其构造输入变量的过程亦完全相同

Returns:

pd.DataFrame - 返回pd.DataFrame包含原来的数据以及预测结果ycol+’_pre’列

forward_valid_test_predict_X2d_y1d1step

dramkit.datsci.time_series.forward_valid_test_predict_X2d_y1d1step(model, func_pred, df_train, df_valid, df_test, ycol, Xcols_series_lag, Xcols_other, gap, **kwargs)

用训练好的模型做时间序列验证集和测试集预测(滚动预测, 前面的预测作为后面的输入)

适用于X二维、ycol一维一步向前预测情况

Parameters:

model – 与 forward_predict_X2d_y1d1step() 参数意义相同
func_pred – 与 forward_predict_X2d_y1d1step() 参数意义相同
ycol – 与 forward_predict_X2d_y1d1step() 参数意义相同
Xcols_series_lag – 与 forward_predict_X2d_y1d1step() 参数意义相同
Xcols_other – 与 forward_predict_X2d_y1d1step() 参数意义相同
gap – 与 forward_predict_X2d_y1d1step() 参数意义相同
**kwargs – 与 forward_predict_X2d_y1d1step() 参数意义相同
df_train (pd.DataFrame) – df_train为用作训练的数据
df_valid (pd.DataFrame) – df_valid为验证集待预测数据
df_test (pd.DataFrame) –
df_test为测试集待预测数据

Note

df_valid和df_test的列须与df_train相同

df_valid和df_test可以为None或pd.DataFrame

df_train、df_valid、df_test须为连续时间序列

当df_test不为空时，df_valid的ycol列必须有真实值

Returns:

valid_pre (pd.DataFrame) – 验证集预测结果，包含ycol+’_pre’列
test_pre (pd.DataFrame) – 测试集预测结果，包含ycol+’_pre’列

genXy_X2d_y1dsteps

dramkit.datsci.time_series.genXy_X2d_y1dsteps(df, ycol, Xcols_series_lag=None, Xcols_other=None, y_step=1, gap=0)

构造时间序列预测的输入X和输出y，适用于X二维，ycol一维多步向前预测情况

Todo

gap为-1的情况检查确认

Parameters:

df (pd.DataFrame) – 包含因变量列和所有自变量列的数据集
ycol (str) – 因变量序列名
Xcols_series_lag (list, None) –

序列自变量列名和历史期数，格式如：

[(xcol1, lag1), (xcol2, lag2), …]

若为None，则默认设置为[(ycol, 3)]
Xcols_other (list, None) –
非序列自变量列名列表

Note

序列自变量视为不能拿到跟因变量预测同期的数据，非序列自变量视为可以拿到同期数据
y_step (int) – 一次向前预测ycol的步数（即因变量y的维度，多输出模型中y为多维，时间序列上相当于向前预测多步）
gap (int) – 预测跳跃期数（eg.用截止今天的数据预测gap天之后的y_step天的数据）

Returns:

X (np.array) – 二维，行数为样本量，列数为特征数量
y (np.array) – 若y_step为1则为一维，若y_step大于1，则形状为样本量*y_step

forward_predict_X2d_y1dsteps

dramkit.datsci.time_series.forward_predict_X2d_y1dsteps(model, func_pred, df_pre, ycol, Xcols_series_lag, Xcols_other, y_step, gap, **kwargs)

用训练好的模型做在数据df_pre上进行构造样本并进行向前滚动预测(前面的预测作为后面的输入)

适用于X二维，ycol一维多步向前预测情况

Todo

gap为-1的情况检查确认

Parameters:

model – 训练好的预测模型
func_pred (function) – func_pred为预测函数，接受必要参数model和X，也接受可选参数**kwargs
df_pre (pd.DataFrame) – 待预测所用数据，其中 ycol 为待预测列。除了初始构造输入X必须满足的数据行外，后面的数据可以为空值
Xcols_series_lag – 参数意义同 genXy_X2d_y1dsteps() 中参数意义，用其构造输入变量的过程亦完全相同
Xcols_other – 参数意义同 genXy_X2d_y1dsteps() 中参数意义，用其构造输入变量的过程亦完全相同
y_step – 参数意义同 genXy_X2d_y1dsteps() 中参数意义，用其构造输入变量的过程亦完全相同
gap – 参数意义同 genXy_X2d_y1dsteps() 中参数意义，用其构造输入变量的过程亦完全相同

Returns:

df_pre – 返回数据中包含原来的数据以及预测结果ycol+’_pre’列

Return type:

pd.DataFrame

forward_valid_test_predict_X2d_y1dsteps

dramkit.datsci.time_series.forward_valid_test_predict_X2d_y1dsteps(model, func_pred, df_train, df_valid, df_test, ycol, Xcols_series_lag, Xcols_other, y_step, gap, logger=None, **kwargs)

用训练好的模型做时间序列验证集和测试集预测(滚动预测, 前面的预测作为后面的输入)

适用于X二维，ycol一维多步向前预测情况

Parameters:

model – 与 forward_predict_X2d_y1dsteps() 中参数意义相同
func_pred – 与 forward_predict_X2d_y1dsteps() 中参数意义相同
ycol – 与 forward_predict_X2d_y1dsteps() 中参数意义相同
Xcols_series_lag – 与 forward_predict_X2d_y1dsteps() 中参数意义相同
Xcols_other – 与 forward_predict_X2d_y1dsteps() 中参数意义相同
y_step – 与 forward_predict_X2d_y1dsteps() 中参数意义相同
gap – 与 forward_predict_X2d_y1dsteps() 中参数意义相同
**kwargs – 与 forward_predict_X2d_y1dsteps() 中参数意义相同
df_train (pd.DataFrame) – df_train为用作训练的数据
df_valid (pd.DataFrame) – df_valid为验证集待预测数据
df_test (pd.DataFrame) –
df_test为测试集待预测数据

Note

df_valid和df_test的列须与df_train相同

df_valid和df_test可以为None或pd.DataFrame

df_train、df_valid、df_test须为连续时间序列

当df_test不为空时，df_valid的ycol列必须有真实值

Returns:

valid_pre (pd.DataFrame) – 验证集预测结果，包含ycol+’_pre’列
test_pre (pd.DataFrame) – 测试集预测结果，包含ycol+’_pre’列

topsis

dramkit.datsci.topsis.topsis(df, weight=None)

TOPSIS评价方法

Parameters:

df (pd.DataFrame) –
每行一个样本，每列一个指标，为每个样本计算综合得分

Note

df应保证所有指标都是正向的，且已经预处理了无效值
weight (list) – 顺序与df.columns对应的指标权重列表，若为None，则默认采用熵值法计算权重

Returns:

score (pd.DataFrame) – 每个样本综合得分指数，列名为’score’
mid_info (tuple) – 返回中间过程数据(result, Z, weight):

- result: df规范化之后的数据，加上’正dis’, ‘负dis’, ‘score’, ‘rank’四列， ‘正dis’和’负dis’分别为样本距正理想解和负理想解的距离

- Z: 正理想解和负理想解

- weight: 指标权重列表

References

https://zhuanlan.zhihu.com/p/37738503

utils_lgb

LightGBM核心参数说明

算法类型
- boosting: 可选[‘gbdt’, ‘rf’, ‘dart’, ‘goss’]（使用dart？可能准确率更高）
- extra_trees: 若为True，则特征分裂时使用极端随机树方式（普通决策树对某个特征进行分裂
时通过比较不同划分点来选择最优分裂点，极端随机树则随机选择分裂点），使用extra_trees
可以减少过拟合

树结构
- max_depth: 树的深度，太大可能过拟合
- num_leaves: 树的叶子节点数量，太大可能过拟合（二叉树叶子节点数量为: 2^树深度）
- min_data_in_leaf: 每个叶子节点上的样本数，太小可能过拟合
注：LightGBM使用leaf-wise的算法，因此在调节树的复杂程度时，应使用的是num_leaves，
而不是max_depth。其值应设置为小于2^(max_depth)，否则容易导致过拟合。

采样和特征处理
- bagging_fraction: 样本采样比例，用于降低过拟合和提升训练速度
- bagging_freq: 采样频率，即每个多少轮对样本进行一次采样
注：bagging_fraction和bagging_freq须同时设置（具体过程？每轮用的样本不一样？）
- feature_fraction: 特征采样比例，即在每轮迭代（每棵树？）随机选取指定比例的特征参与
建模，用于降低过拟合和提升训练速度
- max_bin: 特征离散化时的分组数（lightgbm采用直方图对特征进行离散化），
越小训练速度越快，越大越容易过拟合

正则化
- lambda_l1: L1正则化项系数
- lambda_l2: L2正则化项系数
- min_gain_to_split: 节点分裂时的最小gain？控制，越大可以减少过拟合
- min_sum_hessian_in_leaf: 每个叶子节点上的hessian矩阵？之和的最小值限制，
起正则化和限制树深度的作用，越大可以减少过拟合
- path_smooth: 树节点平滑？，越大可以减少过拟合
注：设置path_smooth大于0时min_data_in_leaf必须大于等于2

训练过程控制

- learning_rate, num_iterations: 设置较小的learning_rate配合较大的num_iterations比较好

其它注意事项
- categorical_feature参数值在训练函数lgb.train中与在lgb.Dataset中须一致，其对应
变量必须是大于等于0的整数值，须与数据集中的类别型（category）变量名列相同，最好在
pandas.DataFrame中设置为.astype(‘category’)
- 多分类任务中，标签y的值必须为[0, num_class)范围内的整数，num_class为类别数
- 二分类任务中，lgb貌似会默认将y中小于等于0的值当做负标签，大于0的当做正标签
- ‘num_boost_round’和树的数量是啥关系？

check_parms_mdl

dramkit.datsci.utils_lgb.check_parms_mdl(parms_mdl, objective, num_class, logger=None): 检查模型相关参数设置是否正确

parms_mdl为设置的模型参数

检查的参数项目（可添加新的检查项目）：

任务类型objective

multiclass中的num_class参数

返回检查的参数值

注：后续若更改该函数检查的参数项，则在调用该函数的地方也须做相应修改

get_parms_mdl

dramkit.datsci.utils_lgb.get_parms_mdl(parms_mdl=None, objective=None, num_class=None, logger=None): 获取模型参数

parms_mdl为设置的模型参数，若关键参数没设置，则会补充设置默认值

objective为任务类型，支持的任务类型（可添加其他任务类型）：

multiclass、binary、regression

num_class：多分类任务中的类别数（对多分类任务起作用，会对此参数进行特殊检查）

注：若新增其它任务类型，可能需要设置对应需要特殊检查的参数

注意：由于lgb参数有别称，可能导致混淆或重复设置，故parms_mdl中出现的参数名称应与本函数中默认名称保持一致！

get_parms_train_or_cv

dramkit.datsci.utils_lgb.get_parms_train_or_cv(parms_train_or_cv=None): 获取lgb.train或lgb.cv参数

parms_train_or_cv为以字典形式设置的train或cv参数，若关键参数没设置，则会补充设置默认值

lgb_train

dramkit.datsci.utils_lgb.lgb_train(X_train, y_train, X_valid=None, y_valid=None, weight_train=None, objective=None, parms_mdl=None, parms_train=None, mdl_save_path=None, logger=None): lightgbm模型训练

X_train, y_train, X_valid, y_valid为pd或np格式，最好为pd格式数据

objective为任务类型，支持的任务类型（可添加其他任务类型）：

multiclass、binary、regression

parms_mdl和parms_train为模型参数和训练参数（dict）

mdl_save_path为模型本地化路径

返回训练好的模型和损失函数变化曲线数据

lgb_cv

dramkit.datsci.utils_lgb.lgb_cv(X_train, y_train, objective=None, parms_mdl=None, parms_cv=None, logger=None): lightgbm交叉验证

X_train, y_train为pd或np格式，最好为pd格式数据

objective为任务类型，支持的任务类型（可添加其他任务类型）：

multiclass、binary、regression

parms_mdl和parms_cv为模型参数和cv参数（dict）

返回各损失函数值？

lgb_cv_grid_search

dramkit.datsci.utils_lgb.lgb_cv_grid_search(X_train, y_train, objective=None, parms_mdl=None, parms_to_opt=None, parms_cv=None, logger=None): lgb交叉验证网格搜索调参

lgb_cv_mdls

dramkit.datsci.utils_lgb.lgb_cv_mdls(X_train, y_train, objective=None, weight_train=None, parms_mdl_list=None, parms_train_list=None, n_fold=5, shuffle=True, random_state=62, mdl_path_list=None, logger=None): 自定义lgb交叉验证，返回模型列表和结果列表

lgb_predict

dramkit.datsci.utils_lgb.lgb_predict(mdl, X, p_cut=0.5, rate1=None): lgb模型预测

mdl为训练好的模型或本地模型路径，X为待预测输入

p_cut为二分类确定标签时的概率切分点

rate1为二分类确定标签时为1的比例

get_features_importance

dramkit.datsci.utils_lgb.get_features_importance(mdl, sum1=True, return_type='df'): 返回特征重要性

sum1设置是否标准化成和为1的权重

return_type可选[df, dict]

utils_ml

vote_label_int

dramkit.datsci.utils_ml.vote_label_int(label_pred_list): 投票法生成最终二分类或多分类label

label_pred_list为不同的预测结果列表，每个预测结果是值为整数的np.array或pd.Series或list

vote_prob_multi

dramkit.datsci.utils_ml.vote_prob_multi(prob_pred_list): 投票法生成最终多分类label

prob_pred_list为不同预测结果列表，每个预测结果是值为概率的np.array或pd.Series，shape为样本数*类别数

vote_prob_bin_pcut

dramkit.datsci.utils_ml.vote_prob_bin_pcut(prob_pred_list, pcut=0.5): 投票法生成最终二分类label

prob_pred_list为不同预测结果列表，每个预测结果是值为概率（label为1的概率）的np.array或pd.Series，shape为样本数*1

pcut: 指定将预测概率大于pcut的样本标注为1

vote_prob_bin_rate1

dramkit.datsci.utils_ml.vote_prob_bin_rate1(prob_pred_list, rate1=0.5): 投票法生成最终二分类label

prob_pred_list为不同预测结果列表，每个预测结果是值为概率（label为1的概率）的np.array或pd.Series，shape为样本数*1

rate1: 指定标签为1的样本比例

auc_bin

dramkit.datsci.utils_ml.auc_bin(y_true, pred_prob, **kwargs): 二分类AUC计算

y_true为真实标签，pred_prob为预测概率（取y_true中较大值的概率）

**kwargs可设置sklearn.metrics.roc_auc_score函数接收的其它参数

cal_f1_score

dramkit.datsci.utils_ml.cal_f1_score(y_true, y_pred, **kwargs): F1-score计算

y_true为真实标签，y_pred为预测标签

**kwargs可设置sklearn.metrics.f1_score函数接收的其它参数

多分类时sklearn中计算F1值的方式参考：

https://zhuanlan.zhihu.com/p/59862986

confusion_matrix

dramkit.datsci.utils_ml.confusion_matrix(y_true, y_pred, kwargs_f1=None): 混淆矩阵，y_true和y_predict分别为真实标签和预测标签

plot_roc_bin

dramkit.datsci.utils_ml.plot_roc_bin(y_true_pred_prob, labels=None, lnstyls=None, figsize=(8, 8), title=None, fontsize=15, grid=False, fig_save_path=None, **kwargs): 二分类ROC曲线绘制

y_true_pred_prob格式：

[(y_true1, pred_prob1), (y_true2, pred_prob2), …]，

其中y_true为真实标签，

pred_prob为预测概率结果（取y_true中较大值的概率）

labels设置每个结果ROC曲线图例标签，list或tuple

lnstyls设置每个结果ROC曲线的线型，list或tuple

若只有一个结果，则labels，lnstyls可不用写成list或tuple

**kwargs可设置sklearn.metrics.roc_curve函数接收的其它参数

返回AUC值

zigzag

dramkit.datsci.zigzag.zigzag(df: DataFrame, high_col: str = 'high', low_col: str = 'low', t_min: Optional[int] = None, t_max: int = inf, min_pct: Optional[float] = None, min_val: Optional[float] = None, max_pct: Optional[float] = None, max_val: Optional[float] = None, t_min_up: Optional[int] = None, t_min_down: Optional[int] = None, t_max_up: Optional[int] = None, t_max_down: Optional[int] = None, up_min_pct: Optional[float] = None, up_min_val: Optional[float] = None, up_max_pct: Optional[float] = None, up_max_val: Optional[float] = None, down_min_pct: Optional[float] = None, down_min_val: Optional[float] = None, down_max_pct: Optional[float] = None, down_max_val: Optional[float] = None, pct_v00: float = 1.0, logger: Optional[Logger] = None) → Series

ZigZag转折点

Parameters:

df (pd.DataFrame) – 需包含[high_col, low_col]列
high_col (str) – 确定zigzag高点的数据列名
low_col (str) – 确定zigzag低点的数据列名
t_min (int) – 转折点之间的最小时间距离
t_max (int) – 转折点之间的最大时间距离（超过t_max即视为满足转折条件）
min_pct (float) – 在满足t_min参数设置的条件下，极大值点和上一个极小值点的最小变化百分比
min_val (float) – 在满足t_min参数设置的条件下，极大值点和上一个极小值点的最小变化绝对值（若min_pct设置，则此参数失效）
max_pct (float) – 在不满足t_min参数设置的条件下，极大值点和上一个极小值点的变化百分比若超过此参数值，则视为满足转折条件
max_val (float) – 在不满足t_min参数设置的条件下，极大值点和上一个极小值点的变化绝对值若超过此参数值，则视为满足转折条件（若max_pct设置，则此参数失效）
t_min_up (int) – 同t_min，只控制上涨
t_min_down (int) – 同t_min，只控制下跌
t_max_up (int) – 同t_max，只控制上涨
t_max_down (int) – 同t_max，只控制下跌
up_min_pct (float) – 同min_pct，只控制上涨
up_min_val (float) – 同min_val，只控制上涨
up_max_pct (float) – 同max_pct，只控制上涨
up_max_val (float) – 同max_val，只控制上涨
down_min_pct (float) – 同min_pct，只控制下跌
down_min_val (float) – 同min_val，只控制下跌
down_max_pct (float) – 同max_pct，只控制下跌
down_max_val (float) – 同max_val，只控制下跌
pct_v00 (float) – 计算百分比时分母为0指定结果
logger (logging.Logger) – 日志记录器

Returns:

zigzag – 返回zigzag标签序列。其中1/-1表示确定的高/低点； 0.5/-0.5表示未达到偏离条件而不能确定的高低点。

Return type:

pd.Series