def check_data():
"""
接口请求参数:{
"table_name": "" # str,数据库表名-数据处理之后的数据
"X": ["x1", "x2"], # list,自变量
"Y": ["y"], # list,因变量
}
:return:
"""
log.info('anova_one_way_check_data_init...')
request_data = init_route()
try:
table_name = request_data['table_name']
X = request_data.get('X')
Y = request_data.get('Y')
except Exception as e:
log.info(e)
raise e
# 从数据库拿数据：
try:
data = exec_sql(table_name, X, Y)
res_data = {
"title": "查看数据",
"row": data.index.values.tolist(),
"col": data.columns.values.tolist(),
"data": data.values.tolist()
}
response_data = {"res": res_data,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
except Exception as e:
log.error(e.args)
# raise e
return jsonify({"data": "", "code": "500", "msg": e.args[0]})
def results_frequency():
"""
接口请求参数:{
"table_name": "" # str,数据库表名
"X": ["x1"], # list,自变量，行
}
:return:
"""
log.info('frequency_get_results_init...')
request_data = init_route()
try:
table_name = request_data['table_name']
X = request_data['X']
except Exception as e:
log.info(e)
raise e
assert isinstance([X], list)
# 从数据库拿数据
data = exec_sql(table_name, X)
log.info("输入数据大小:{}".format(len(data)))
try:
frequency_result = data_frequency(data, X)
log.info("调用频数分布函数成功")
response_data = {"res": frequency_result,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
except Exception as e:
log.error(e)
raise e
def anova_all_way():
"""
接口请求参数:{
"table_name": "" # str,数据库表名
"X": ["x1", "x2"], # list,自变量
"Y": ["y"], # list,因变量
"alpha": "0.05", # str,置信区间百分比
"table_direction": "", str,表格方向,水平方向为h,竖直方向为v
"analysis_options": ["normal", "variances", "multiple"]
}
:return:
"""
log.info('anova_all_way_test_init...')
request_data = init_route()
try:
table_name = request_data['table_name']
X = request_data['X']
Y = request_data['Y']
alpha = float(request_data['alpha'])
table_direction = request_data['table_direction']
analysis_options = request_data.get("analysis_options", [])
except Exception as e:
log.info(e)
raise e
assert isinstance([X, Y], list)
# 从数据库拿数据
data = exec_sql(table_name, X, Y)
log.info("输入数据大小:{}".format(len(data)))
try:
if table_direction == "v":
data[Y[0]] = data[Y[0]].astype("float16")
# every_level_data_index = [d for d in data[X[0]].unique()]
# every_level_data = [data[data[X[0]] == d][Y[0]].astype("float16") for d in data[X[0]].unique()]
elif table_direction == "h":
# every_level_data_index = X
# every_level_data = [data[l].astype("float16") for l in X]
data, X, Y = transform_h_table_data_to_v(data, X)
else:
raise ValueError("table direction must be h or v")
res = []
# 主体间因子
res.append(level_info(data, X))
# 描述性统计分析
res.append(anova_all_way_describe_info(data, X, Y))
if "normal" in analysis_options:
res.append(normal_test_all(data, X, alpha=alpha))
if "variances" in analysis_options:
res.append(transform_table_data_to_html(levene_test_all(data, X, alpha=alpha)))
# 多因素方差分析
res.append(transform_table_data_to_html(anova_analysis_multivariate(data, X, Y)))
# todo:稍后加
# 多重比较
response_data = {"res": res,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
except Exception as e:
log.error(e)
# raise e
return jsonify({"data": "", "code": "500", "msg": e.args[0]})
def results_describe():
"""
接口请求参数:{
"table_name": "" # str,数据库表名
"X": ["x1"], # list,自变量，行
}
:return:
"""
log.info('describe_get_results_init...')
request_data = init_route()
try:
table_name = request_data['table_name']
X = request_data['X']
except Exception as e:
log.info(e)
raise e
assert isinstance([X], list)
# 从数据库拿数据
data = exec_sql(table_name, X)
log.info("输入数据大小:{}".format(len(data)))
try:
describe_result = transform_table_data_to_html(description(data, X), col0='指标名称')
log.info("调用描述性统计函数成功")
response_data = {"res": describe_result,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
except Exception as e:
log.error(e)
raise e
def results_nonparametric_multi_independent():
"""
接口请求参数:{
"table_name": "" # str,数据库表名
"X": ["x1", "x2"], # list,自变量，当表格方向为h时表示多个变量名，为v时表示分类变量字段
"Y": ["y"], # list,因变量,当表格方向为v是使用
"table_direction": "", str,表格方向,水平方向为h,竖直方向为v
}
:return:
"""
log.info('nonparametric_multi_independent_get_results_init...')
request_data = init_route()
try:
table_name = request_data['table_name']
X = request_data['X']
Y = request_data['Y']
table_direction = request_data['table_direction']
# alpha = float(request_data['alpha'])
except Exception as e:
log.info(e)
raise e
assert isinstance([X, Y], list)
# 从数据库拿数据
data = exec_sql(table_name, X, Y)
log.info("输入数据大小:{}".format(len(data)))
try:
if table_direction == "v":
every_level_data_index = [d for d in data[X[0]].unique()]
# every_level_data = [data[data[X[0]] == d][Y[0]].astype("float16") for d in data[X[0]].unique()]
data, X = transform_v_table_data_to_h(data, X, Y)
elif table_direction == "h":
every_level_data_index = X
every_level_data = [data[l].astype("float16") for l in X]
# data, X, Y = transform_h_table_data_to_v(data, X)
else:
raise ValueError("table direction must be h or v")
if len(every_level_data_index) < 2:
raise ValueError("多个独立样本非参数检验，自变量的水平至少是2个")
# 描述性统计
res = []
data_info = transform_table_data_to_html(Kruskal_Wallis_H_describe(data, X))
res.append(data_info)
log.info("描述性统计分析完成")
# Kruska-Wallis H 检验
Kruskal_Wallis_H_res = Kruskal_Wallis_H_test(data, X)
res.append(Kruskal_Wallis_H_res)
log.info("Kruska-Wallis H 检验完成")
response_data = {"res": res,
"data_info": data_info,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
except Exception as e:
log.error(e)
raise e
def t_two_pair():
"""
接口请求参数:{
"table_name": "" # str,数据库表名
"X": ["x1", "x2"], # list,自变量，当表格方向为h时表示多个变量名，为v时表示分类变量字段
"Y": ["y"], # list,因变量,当表格方向为v是使用
"alpha": "0.05", # str,置信区间百分比
"table_direction": "", str,表格方向,水平方向为h,竖直方向为v
"analysis_options": ["normal", "pearsonr"]
}
:return:
"""
log.info('t_two_pair_init...')
request_data = init_route()
try:
table_name = request_data['table_name']
X = request_data['X']
Y = request_data['Y']
table_direction = request_data['table_direction']
alpha = float(request_data['alpha'])
analysis_options = request_data.get("analysis_options", [])
except Exception as e:
log.info(e)
raise e
assert isinstance([X, Y], list)
# 从数据库拿数据
data = exec_sql(table_name, X, Y)
log.info("输入数据大小:{}".format(len(data)))
try:
if table_direction == "v":
every_level_data_index = [d for d in data[X[0]].unique()]
every_level_data = [data[data[X[0]] == d][Y[0]].astype("float16") for d in data[X[0]].unique()]
elif table_direction == "h":
every_level_data_index = X
every_level_data = [data[l].astype("float16") for l in X]
data, X, Y = transform_h_table_data_to_v(data, X)
else:
raise ValueError("table direction must be h or v")
if len(every_level_data_index) > 2:
raise ValueError("自变量的水平必须是2个")
res = []
# 描述性统计分析
res.append(transform_table_data_to_html(t_two_paired_describe_info(data, X, Y)))
if "pearsonr" in analysis_options:
res.append(transform_table_data_to_html(
pearsonr_test(*every_level_data, index=every_level_data_index, alpha=alpha)))
if "normal" in analysis_options:
res.append(transform_table_data_to_html(normal_test(every_level_data_index, every_level_data, alpha)))
res.append(transform_table_data_to_html(
t_two_pair_analysis(*every_level_data, index=every_level_data_index, alpha=alpha), col0="配对差值"))
response_data = {"res": res,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
except Exception as e:
log.error(e)
# raise e
return jsonify({"data": "", "code": "500", "msg": e.args[0]})
def nonparametric_two_independent():
"""
接口请求参数:{
"table_name": "" # str,数据库表名
"X": ["x1", "x2"], # list,自变量，当表格方向为h时表示多个变量名，为v时表示分类变量字段
"Y": ["y"], # list,因变量,当表格方向为v是使用
"table_direction": "", str,表格方向,水平方向为h,竖直方向为v
}
:return:
"""
log.info('nonparametric_two_independent_get_results_init...')
request_data = init_route()
try:
table_name = request_data['table_name']
X = request_data['X']
Y = request_data['Y']
table_direction = request_data['table_direction']
except Exception as e:
log.info(e)
raise e
assert isinstance([X, Y], list)
# 从数据库拿数据
data = exec_sql(table_name, X, Y)
log.info("输入数据大小:{}".format(len(data)))
try:
if table_direction == "v":
every_level_data_index = [d for d in data[X[0]].unique()]
# every_level_data = [data[data[X[0]] == d][Y[0]].astype("float16") for d in data[X[0]].unique()]
data, X = transform_v_table_data_to_h(data, X, Y)
elif table_direction == "h":
every_level_data_index = X
every_level_data = [data[l].astype("float16") for l in X]
# data, X, Y = transform_h_table_data_to_v(data, X) # 水平的数据，这里不用转
else:
raise ValueError("table direction must be h or v")
if len(every_level_data_index) > 2:
raise ValueError("自变量的水平必须是2个")
# 描述性统计
res = []
data_info = transform_table_data_to_html(Mann_Whitney_U_describe(data, X))
res.append(data_info)
# Mann-Whitney U 检验
Mann_Whitney_U_res = transform_table_data_to_html(Mann_Whitney_U_test(data, X))
res.append(Mann_Whitney_U_res)
response_data = {"res": res,
"data_info": data_info,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
except Exception as e:
log.error(e)
raise e
def results_nonparametric_two_independent():
"""
接口请求参数:{
"table_name": "" # str,数据库表名
"X": ["x1", "x2"], # list,自变量，当表格方向为h时表示多个变量名，为v时表示分类变量字段
# "table_direction": "h", str,表格方向,水平方向为h,竖直方向为v
}
:return:
"""
log.info('nonparametric_two_pair_get_results_init...')
request_data = init_route()
try:
table_name = request_data['table_name']
X = request_data['X']
# Y = request_data['Y']
# table_direction = request_data['table_direction']
# alpha = float(request_data['alpha'])
except Exception as e:
log.info(e)
raise e
# assert isinstance([X, Y], list)
assert isinstance([X], list)
if len(X) > 2:
raise ValueError("只支持一列数据或两列数据")
# 从数据库拿数据
# data = exec_sql(table_name, X, Y)
data = exec_sql(table_name, X)
log.info("输入数据大小:{}".format(len(data)))
try:
# 描述性统计
res = []
data_info = transform_table_data_to_html(Wilcoxon_describe(data, X))
res.append(data_info)
log.info("描述性统计分析完成")
# Wilcoxon 符号秩检验
Wilcoxon_res = transform_table_data_to_html(Wilcoxon_test(data, X))
res.append(Wilcoxon_res)
log.info("Wilcoxon 符号秩检验完成")
response_data = {"res": res,
"data_info": data_info,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
except Exception as e:
log.error(e)
raise e
def t_single():
"""
接口请求参数:{
"table_name": "" # str,数据库表名
"X": ["value"], # list,自变量
"alpha": "0.05", # str,置信区间百分比
"mean": "0", # str,样本均值
"analysis_options": ["normal"]
}
:return:
"""
log.info('t_single_test_init...')
request_data = init_route()
try:
table_name = request_data['table_name']
alpha = float(request_data['alpha'])
X = request_data['X']
data_mean = float(request_data['mean'])
analysis_options = request_data.get("analysis_options", [])
except Exception as e:
log.info(e)
raise e
# 从数据库拿数据
data = exec_sql(table_name, X)
log.info("输入数据大小:{}".format(len(data)))
try:
res = []
data[X[0]] = data[X[0]].astype("float16")
data_info = transform_table_data_to_html(t_single_describe_info(data, X))
res.append(data_info)
# 正态性检验
if "normal" in analysis_options:
normal_res = transform_table_data_to_html(normal_test([X[0]], [data[X[0]]], alpha=alpha))
res.append(normal_res)
# 单样本t检验分析结果
t_single_res = transform_table_data_to_html(
t_single_analysis(data[X[0]].astype("float16"), data_mean, X, alpha=alpha), col0="检验值={}".format(data_mean))
res.append(t_single_res)
response_data = {"res": res,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
except Exception as e:
log.error(e)
# raise e
return jsonify({"data": "error", "code": "500", "msg": e.args[0]})
def results_principal_components():
"""
接口请求参数:{
"table_name": "" # str,数据库表名
"X": ["x1"], # list,自变量，行
"components": 2 # 主成分个数
}
:return:
"""
log.info('principal_components_get_results_init...')
request_data = init_route()
try:
table_name = request_data['table_name']
X = request_data['X']
components = request_data['components']
components = int(components)
except Exception as e:
log.info(e)
raise e
assert isinstance([X], list)
# 从数据库拿数据
data = exec_sql(table_name, X)
log.info("输入数据大小:{}".format(len(data)))
try:
res = []
correlation_matrix_result = correlation_matrix(data)
log.info("调用相关系数矩阵函数成功")
res.append(correlation_matrix_result)
kmo_Bartlett_result = kmo_Bartlett(data)
log.info("调用相关性检验函数成功")
res.append(kmo_Bartlett_result)
PCA_result = PCA(data, components=components)
log.info("调用PCA函数成功")
res.extend(PCA_result)
response_data = {"res": res,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
except Exception as e:
log.error(e)
raise e
def results_fencen_crosstable():
"""
接口请求参数:{
"table_name": "" # str,数据库表名
"hang": ["n1"], # list，行
"lie": ["c1"], # list，列
"fenceng":['f'], # 分层变量
}
:return:
"""
log.info('fencen_crosstable_get_results_init...')
request_data = init_route()
try:
table_name = request_data['table_name']
hang = request_data['index']
lie = request_data['columns']
fenceng = request_data['fenceng']
except Exception as e:
log.info(e)
raise e
# assert isinstance([X, Y], list)
# assert isinstance([X], list)
# 从数据库拿数据
indexs = fenceng + hang
data = exec_sql(table_name, indexs, lie)
# data = exec_sql(table_name, X)
log.info("输入数据大小:{}".format(len(data)))
try:
index = [data[i] for i in range(len(indexs))]
columns = data[lie[0]]
res = cross_chis(index, columns)
response_data = {"res": res,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
except Exception as e:
log.error(e)
raise e
def results_crosstable():
"""
接口请求参数:{
"table_name": "" # str,数据库表名
"X": ["x1"], # list，行
"Y": ["y"], # list，列
}
:return:
"""
log.info('crosstable_get_results_init...')
request_data = init_route()
try:
table_name = request_data['table_name']
X = request_data['X']
Y = request_data['Y']
# table_direction = request_data['table_direction']
# alpha = float(request_data['alpha'])
except Exception as e:
log.info(e)
raise e
assert isinstance([X, Y], list)
# assert isinstance([X], list)
# 从数据库拿数据
data = exec_sql(table_name, X, Y)
# data = exec_sql(table_name, X)
log.info("输入数据大小:{}".format(len(data)))
try:
index = data[X[0]]
columns = data[Y[0]]
res = cross_chi2(index, columns)
response_data = {"res": res,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
except Exception as e:
log.error(e)
raise e
def results_factor_analysis():
"""
接口请求参数:{
"table_name": "" # str,数据库表名
"X": ["x1","x2"], # list,自变量，行
"components": 2 # 因子个数
"standardize": 默认 True 标准化，False 不标准化
"transpose": 默认 False 不转置，True 转置
}
:return:
"""
log.info('factor_analysis_get_results_init...')
request_data = init_route()
try:
table_name = request_data['table_name']
X = request_data['X']
components = request_data['components']
components = int(components)
standardize = request_data['standardize']
transpose = request_data['transpose']
except Exception as e:
log.info(e)
raise e
assert isinstance([X], list)
# 从数据库拿数据
if transpose == False:
data = exec_sql(table_name, X)
log.info("输入数据大小:{}".format(len(data)))
try:
ic_fa = FA(component=components,standardize=standardize)
res = []
correlation_matrix_result = correlation_matrix(data)
log.info("调用相关系数矩阵函数成功")
res.append(correlation_matrix_result)
bar = ic_fa.kmo_Bartlett(data)
log.info("调用相关性检验函数成功")
res.append(bar)
contribution = ic_fa.var_contribution(data) # 特征值及贡献率及碎石图
log.info("调用计算特征值、贡献率、碎石图成功")
res.extend(contribution)
before_zaihe = ic_fa.loadings(data) # 旋转前载荷矩阵
log.info("调用旋转前载荷矩阵函数成功")
res.append(before_zaihe)
after_zaihe = ic_fa.varimax_rotation(data) # 旋转后载荷矩阵
log.info("调用旋转后载荷矩阵函数成功")
res.append(after_zaihe)
score_coef = ic_fa.score_coef(data) # 因子得分系数
log.info("调用因子得分系数函数成功")
res.append(score_coef)
score = ic_fa.score(data) # 因子得分
log.info("调用因子得分函数成功")
res.append(score)
response_data = {"res": res,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
except Exception as e:
log.error(e)
raise e
elif transpose == True:
da = exec_sql(table_name, X)
data = da.T
log.info("输入数据大小:{}".format(len(data)))
ic_fa = FA(component=components, standardize=standardize)
res = []
try:
correlation_matrix_result = correlation_matrix(data)
log.info("调用相关系数矩阵函数成功")
res.append(correlation_matrix_result)
except Exception as e:
log.error(e)
try:
bar = ic_fa.kmo_Bartlett(data)
log.info("调用相关性检验函数成功")
res.append(bar)
except Exception as e:
log.error(e)
try:
contribution = ic_fa.var_contribution(data) # 特征值及贡献率及碎石图
log.info("调用计算特征值、贡献率、碎石图成功")
res.extend(contribution)
except Exception as e:
log.error(e)
try:
before_zaihe = ic_fa.loadings(data) # 旋转前载荷矩阵
log.info("调用旋转前载荷矩阵函数成功")
res.append(before_zaihe)
except Exception as e:
log.error(e)
try:
after_zaihe = ic_fa.varimax_rotation(data) # 旋转后载荷矩阵
log.info("调用旋转后载荷矩阵函数成功")
res.append(after_zaihe)
except Exception as e:
log.error(e)
try:
score_coef = ic_fa.score_coef(data) # 因子得分系数
log.info("调用因子得分系数函数成功")
res.append(score_coef)
except Exception as e:
log.error(e)
try:
score = ic_fa.score(data) # 因子得分
log.info("调用因子得分函数成功")
res.append(score)
except Exception as e:
log.error(e)
response_data = {"res": res,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
def apriori():
"""
接口请求参数:{
"table_name": "apriori_test", # str,数据库表名
"X": ["x0", "x1", "x2", "x3", "x4", "x5"], # list,自变量
"alg": "fpgrowth', # str,关联规则算法选择["apriori", "fpgrowth"] ==》【默认值：fpgrowth】
"dataconvert": True, # bool,是否需要数据转换 ==》【默认值：True】
"minSupport": "0.05", # str,最小支持度 ==》【默认值："0.05"】
"max_len": "2", # 频繁项集最大长度 ==》【默认值：None】
"metrics": "confidence", # 关联规则评价指标["support", "confidence", "lift", "leverage", "conviction"] ==》【默认值：confidence】
"min_threshold": "0.8", # 关联规则评价指标最小值 ==》【默认值："0.8"】
}
:return:
"""
log.info('Apriori_init...')
request_data = init_route()
try:
from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import apriori
from mlxtend.frequent_patterns import fpgrowth
from mlxtend.frequent_patterns import association_rules
except:
raise ImportError("cannot import mlxtend")
try:
table_name = request_data['table_name']
X = request_data['X']
alg = request_data['alg']
dataconvert = request_data['dataconvert']
min_support = float(request_data['minSupport'])
max_len = int(request_data['max_len'])
metrics = request_data['metrics']
min_threshold = float(request_data['min_threshold'])
except Exception as e:
log.info(e)
raise e
try:
table_data = exec_sql(table_name, X)
table_data.fillna("", inplace=True)
data = table_data.values.tolist()
if dataconvert:
trans = TransactionEncoder()
data = trans.fit(data).transform(data)
data = pd.DataFrame(data, columns=trans.columns_)
log.info("data columns:{}".format(data.columns.values))
if "" in data.columns:
data.drop(columns="", axis=1, inplace=True)
if alg == "apriori":
frequent_itemsets = apriori(data, min_support=min_support, max_len=max_len, use_colnames=True)
elif alg == "fpgrowth":
frequent_itemsets = fpgrowth(data, min_support=min_support, max_len=max_len, use_colnames=True)
else:
raise ValueError("input Association rules:{} is not support".format(alg))
rules = association_rules(frequent_itemsets, metric=metrics, min_threshold=min_threshold)
rules = rules.replace([np.inf, -np.inf], "")
rules = format_dataframe(rules, {"lift": ".4f", "leverage": ".4f"})
res = [
transform_table_data_to_html({
"title": "频繁项集结果",
"row": frequent_itemsets.index.tolist(),
"col": frequent_itemsets.columns.tolist(),
"data": frequent_itemsets.values.tolist(),
}),
transform_table_data_to_html({
"title": "关联规则结果",
"row": rules.index.tolist(),
"col": rules.columns.tolist(),
"data": rules.values.tolist(),
})
]
response_data = {"res": res,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
except Exception as e:
log.exception(e)
return jsonify({"code": "500", "res": "", "msg": "{}".format(e.args)})
def anova_one_way():
"""
接口请求参数:{
"table_name_ori": "" # str,数据库表名-数据预处理之前的数据
"table_name": "" # str,数据库表名-数据处理之后的数据
"X": ["x1", "x2"], # list,自变量
"Y": ["y"], # list,因变量
"alpha": "0.05", # str,置信区间百分比
"table_direction": "", str,表格方向,水平方向为h,竖直方向为v
"analysis_options": ["normal", "variances", "multiple"]
}
:return:
"""
log.info('anova_one_way_init...')
request_data = init_route()
try:
table_name = request_data['table_name']
X = request_data['X']
Y = request_data['Y']
alpha = float(request_data['alpha'])
table_direction = request_data['table_direction']
analysis_options = request_data.get("analysis_options", [])
except Exception as e:
log.info(e)
raise e
assert isinstance([X, Y], list)
# 从数据库拿数据
data = exec_sql(table_name, X, Y)
log.info("输入数据大小:{}".format(len(data)))
try:
if table_direction == "v":
data[Y[0]] = data[Y[0]].astype("float16")
every_level_data_index = [d for d in data[X[0]].unique()]
every_level_data = [data[data[X[0]] == d][Y[0]].astype("float16") for d in data[X[0]].unique()]
elif table_direction == "h":
every_level_data_index = X
every_level_data = [data[l].astype("float16") for l in X]
data, X, Y = transform_h_table_data_to_v(data, X)
else:
raise ValueError("table direction must be h or v")
res = []
# 描述性统计分析
data_info = transform_table_data_to_html(anova_one_way_describe_info(data, X, Y, alpha=alpha))
res.append(data_info)
# 正太分布检验
if "normal" in analysis_options:
normal_res = transform_table_data_to_html(normal_test(every_level_data_index, every_level_data, alpha),
col0="因子水平")
res.append(normal_res)
# 方差齐性检验
if "variances" in analysis_options:
equal_variances_res = transform_table_data_to_html(levene_test(*every_level_data, alpha=alpha))
res.append(equal_variances_res)
# 方差分析
anova_res = transform_table_data_to_html(anova_analysis(data, X[0], Y[0], alpha=alpha))
res.append(anova_res)
# 多重比较
if "multiple" in analysis_options:
multiple_res = multiple_test(data, X, Y, alpha=alpha)
res.append(multiple_res)
response_data = {"res": res,
"code": "200",
"msg": "ok!"}
return jsonify(response_data)
except Exception as e:
log.error(e)
# raise e
return jsonify({"data": "", "code": "500", "msg": e.args[0]})
def result_one_sample_chi():
"""
接口请求参数:{
"table_name": "" # str,数据库表名
"X": ["x1", "x2"], # list，检测变量
"E": ["e1","e2"], # list,期望频率变量
"input_e": [2,3,4], #用户具体输入的期望频率
"button_type": ["select","input","null"] #str 按钮的类型
}
:return:
"""
log.info('result_one_sample_chi_get_results_init...')
request_data = init_route()
try:
table_name = request_data['table_name']
X = request_data['X']
E = request_data['E']
input_e = request_data['input_e'] #############################
button_type = request_data['button_type']
except Exception as e:
log.info(e)
raise e
assert isinstance([X], list)
results = []
try:
if button_type[0] == 'null':
da = exec_sql(table_name, X)
da = da.astype(float)
data = [da[i] for i in X]
log.info("输入数据大小:{}".format(len(data)))
if da.shape[1] == 1:
statistic, pvalue = stats.power_divergence(da[X[0]], axis=0)
title = '单样本卡方检验'
col = ['卡方', '显著性']
row = X
d = pd.DataFrame([statistic, pvalue]).T
d = d.astype(float)
d = format_data_col(d)
res = d.values.tolist()
results = transform_table_data_to_html({
'title': title,
'col': col,
'row': row,
'data': res
})
elif da.shape[1] > 1:
statistic, pvalue = stats.power_divergence(data, axis=1)
title = '单样本卡方检验'
col = ['卡方', '显著性']
row = X
d = pd.DataFrame([statistic, pvalue]).T
d = d.astype(float)
d = format_data_col(d)
res = d.values.tolist()
results = transform_table_data_to_html({
'title': title,
'col': col,
'row': row,
'data': res
})
log.info("无期望频率情况分析完成")
elif button_type[0] == 'select':
te = exec_sql(table_name, X)
te = te.astype(float)
test = [te[i] for i in X]
ex = exec_sql(table_name, E)
ex = ex.astype(float)
expect = [ex[j] for j in E]
log.info("输入数据大小:{}".format(len(test)))
if te.shape[1] == 1:
statistic, pvalue = stats.power_divergence(test,expect, axis=0)
title = '单样本卡方检验'
col = ['卡方', '显著性']
row = X
d = pd.DataFrame([statistic, pvalue]).T
d = d.astype(float)
d = format_data_col(d)
res = d.values.tolist()
results = transform_table_data_to_html({
'title': title,
'col': col,
'row': row,
'data': res
})
elif te.shape[1] > 1:
statistic, pvalue = stats.power_divergence(test,expect, axis=1)
title = '单样本卡方检验'
col = ['卡方', '显著性']
row = X
d = pd.DataFrame([statistic, pvalue]).T
d = d.astype(float)
d = format_data_col(d)
res = d.values.tolist()
results = transform_table_data_to_html({
'title': title,
'col': col,
'row': row,
'data': res
})
log.info("有期望频率情况分析完成")
elif button_type[0] == 'input':
te = exec_sql(table_name, X)
te = te.astype(float)
test = [te[i] for i in X]
expect = input_e
expect = pd.DataFrame(expect)
expect = expect.astype(float)
expect = expect.values.tolist()
log.info("输入数据大小:{}".format(len(test)))
if te.shape[1] == 1:
statistic, pvalue = stats.power_divergence(test,expect, axis=0)
title = '单样本卡方检验'
col = ['卡方', '显著性']
row = X
d = pd.DataFrame([statistic, pvalue]).T
d = d.astype(float)
d = format_data_col(d)
res = d.values.tolist()
results = transform_table_data_to_html({
'title': title,
'col': col,
'row': row,
'data': res
})
elif te.shape[1] > 1:
statistic, pvalue = stats.power_divergence(test,expect, axis=1)
title = '单样本卡方检验'
col = ['卡方', '显著性']
row = X
d = pd.DataFrame([statistic, pvalue]).T
d = d.astype(float)
d = format_data_col(d)
res = d.values.tolist()
results = transform_table_data_to_html({
'title': title,
'col': col,
'row': row,
'data': res
})
log.info("用户输入的期望频率情况分析完成")
response_data = {
"code": "200",
"msg": "ok!",
"res":results}
return jsonify(response_data)
except Exception as e:
log.error(e)
raise e
