def getCorr():
# global vibData
# global vibName
if request.method == 'GET':
progress_data['getCorr'] = 0
vibName = request.args.get("vibName")
dataProcess = request.args.get("dataProcess", type=bool, default=False)
if vibName + "_FP_col" in os.listdir("Savedfile") and vibName + "_FP_corr" in os.listdir("Savedfile"):
corr_list = loadFile('Savedfile/' + vibName + '_FP_corr')
col_list = loadFile('Savedfile/' + vibName + '_FP_col')
corr = np.array(corr_list)
col = np.array(col_list)
vib_FP_highCorr_FP = corr[np.argsort(np.abs(corr))[::-1]].tolist()
vib_FP_highCol_FP = col[np.argsort(np.abs(corr))[::-1]].tolist()
progress_data['getCorr'] = float(100)
else:
corr_list = [] # 初始化相关性list
col_list = [] # 初始化变量名list
zeroCor_191207 = loadFile("Savedfile/zeroCor_191207")
vibFolder = baseURL + findKey(VIBParamsTrain, vibName)
# vibFolder = "FTPD-C919-10101-YL-" + trainTime[0] + "-F-01-" + vibFile + ".txt" # 查找振动数据所在数据包名称
vibData = readData(vibFolder, vibName, SubSampling) # 读取振动数据
vibTime = readTime(vibFolder, SubSampling) # 读取数据包时间序列
# 统计飞参个数
FpNumber = 0
for file in FPParamsTrain.keys():
FpNumber += len(FPParamsTrain[file])
i = 1
for file in FPParamsTrain.keys():
time_i = readTime(baseURL + file, SubSampling) # 读取飞参时间
for FPParam in FPParamsTrain[file]:
if (FPParam in zeroCor_191207): # 如果某个变量在zeroCor_191207中
print(FPParam + " Break!") # 告知并跳过该变量的计算
elif ("Accel" in FPParam): # 如果某个变量包括"Accel"在变量名称中，该变量为加速度传感器数据
print(FPParam + " Break!") # 告知并跳过该变量的计算
else:
jCol = readData(baseURL + file, FPParam, SubSampling) # 读取飞参数据
jCol_matched = matchData(vibTime, time_i, jCol) # 将飞参数据与振动数据时间轴匹配
corrJ = scs.pearsonr(jCol_matched, vibData)[0] # 计算该飞参数据与振动响应数据的相关性
corr_list.append(corrJ) # 将计算的相关性加入corr_list中
col_list.append(FPParam) # 将变量名称加入col_list
print("Correlation between " + FPParam + " and " + str(vibName) + " is " + str(
corrJ)) # 告知变量名与相关性
num_progress = round(i * 100 / FpNumber, 2)
print(num_progress)
i += 1
print(i)
progress_data['getCorr'] = num_progress
print(" Fetching complete!") # 告知飞参变量的读取完毕
writeFile("Savedfile/" + vibName + "_FP_corr", corr_list)
writeFile("Savedfile/" + vibName + "_FP_col", col_list)
corr = np.array(corr_list)
col = np.array(col_list)
vib_FP_highCorr_FP = corr[np.argsort(np.abs(corr))[::-1]].tolist()
vib_FP_highCol_FP = col[np.argsort(np.abs(corr))[::-1]].tolist()
result = {"corr_list": vib_FP_highCorr_FP, "col_list": vib_FP_highCol_FP}
# vibNames.append(vibName)
return Response(json.dumps(result), mimetype='application/json')
def train(vib_Name, flightTime, modelPath, num, vib_value, vib_time):
# 飞参与vib的相关性及其变量名
vib_191207_FP_corr = loadFile("Savedfile/" + flightTime + "_" + vib_Name +
"_FP_corr")
vib_191207_FP_col = loadFile("Savedfile/" + flightTime + "_" + vib_Name +
"_FP_col")
# list转换为np.array
vib_191207_FP_corr_ary = np.array(vib_191207_FP_corr)
vib_191207_FP_col_ary = np.array(vib_191207_FP_col)
# 选择相关性最高的20个飞参
num = -1 * int(num)
vib_FP_highCol_FP = vib_191207_FP_col_ary[np.argsort(
np.abs(vib_191207_FP_corr_ary))][num:]
# 表示进行频域变换的每个单元监控点的数量
NUM = 500
# # 读取经过转换后的测点数据和飞参数据
# vib_value = np.array(vib_value[:(len(vib_value)-len(vib_value) % NUM)])
# vib_value = np.reshape(vib_value, (-1, NUM))
# vib_time = np.array(vib_time[:(len(vib_time) - len(vib_time) % NUM)])
# vib_time = np.reshape(vib_time, (-1, NUM))
# vib_time = vib_time[:, 0]
# FP_time =
vib_value_191207, FP_value_191207 = readVIB_FPData(vib_Name,
vib_FP_highCol_FP,
'191207', NUM)
vib_abs_191207, vib_ang_191207 = FFTvibData(vib_value_191207, NUM)
# 需要预测的测点的频率
select_fre = range(0, 200)
vib_191207_ary = vib_abs_191207[:, select_fre]
# 对转换后的频域信号进行滑动时间窗移动平均
vib_191207_ary = timeWindows(vib_191207_ary, length=10)
if modelPath == None:
'''
线性回归
预测及结果展示
'''
LRreg = LinearRegression().fit(FP_value_191207, vib_191207_ary)
else:
with open(modelPath, 'rb') as f:
LRreg = pickle.load(f) # 从f文件中提取出模型赋给clf2
LRreg.fit(FP_value_191207, vib_191207_ary)
return LRreg
def getNum():
global vibNameforTrain
vibNameforTrain = request.args.get('vibName')
# vibNameforTrain = "ANF6"
num = request.args.get('num')
# 飞参与vib的相关性及其变量名
vib_191207_FP_corr = loadFile('Savedfile/' + vibNameforTrain + '_FP_corr')
vib_191207_FP_col = loadFile('Savedfile/' + vibNameforTrain + '_FP_col')
# list转换为np.array
vib_191207_FP_corr_ary = np.array(vib_191207_FP_corr)
vib_191207_FP_col_ary = np.array(vib_191207_FP_col)
vib_FP_highCol_FP = vib_191207_FP_col_ary[np.argsort(np.abs(vib_191207_FP_corr_ary))[::-1]].tolist()
# 选择相关性最高的num个飞参
num = -1 * int(num)
FPPre = vib_191207_FP_col_ary[np.argsort(np.abs(vib_191207_FP_corr_ary))][num:]
result = {"col": vib_FP_highCol_FP, "checked": FPPre.tolist()}
return result
def predict(vib_Name, num):
# 飞参与vib的相关性及其变量名
vib_191207_FP_corr = loadFile('Savedfile/' + vib_Name + '_FP_corr')
vib_191207_FP_col = loadFile('Savedfile/' + vib_Name + '_FP_col')
# list转换为np.array
vib_191207_FP_corr_ary = np.array(vib_191207_FP_corr)
vib_191207_FP_col_ary = np.array(vib_191207_FP_col)
# 选择相关性最高的20个飞参
num = -1 * num
vib_FP_highCol_FP = vib_191207_FP_col_ary[np.argsort(
np.abs(vib_191207_FP_corr_ary))][num:]
# 表示进行频域变换的每个单元监控点的数量
NUM = 500
# 读取经过转换后的测点数据和飞参数据
vib_value_191207, FP_value_191207 = readVIB_FPData(vib_Name,
vib_FP_highCol_FP,
'191207', NUM)
vib_value_200102, FP_value_200102 = readVIB_FPData(vib_Name,
vib_FP_highCol_FP,
'200102', NUM)
vib_value_200106, FP_value_200106 = readVIB_FPData(vib_Name,
vib_FP_highCol_FP,
'200106', NUM)
vib_abs_191207, vib_ang_191207 = FFTvibData(vib_value_191207, NUM)
vib_abs_200102, vib_ang_200102 = FFTvibData(vib_value_200102, NUM)
vib_abs_200106, vib_ang_200106 = FFTvibData(vib_value_200106, NUM)
# 需要预测的测点的频率
select_fre = range(0, 200)
vib_191207_ary = vib_abs_191207[:, select_fre]
vib_200102_ary = vib_abs_200102[:, select_fre]
vib_200106_ary = vib_abs_200106[:, select_fre]
# 对转换后的频域信号进行滑动时间窗移动平均
vib_191207_ary = timeWindows(vib_191207_ary, length=10)
vib_200102_ary = timeWindows(vib_200102_ary, length=10)
vib_200106_ary = timeWindows(vib_200106_ary, length=10)
'''
线性回归
预测及结果展示
'''
LRreg = LinearRegression().fit(FP_value_191207, vib_191207_ary)
vib_pred_LR_200102 = LRreg.predict(FP_value_200102)
'''
支持向量机回归
预测及结果展示
'''
SVRreg = []
base_SVRreg = make_pipeline(
SVR(kernel='rbf',
C=100,
tol=0.1,
gamma=0.1,
epsilon=0.5,
max_iter=1000))
for i in range(len(select_fre)):
SVRreg.append(
sklearn.base.clone(base_SVRreg).fit(FP_value_191207,
vib_191207_ary[:, i]))
vib_pred_SVR_200102 = np.array(
[SVRreg[i].predict(FP_value_200102) for i in range(len(select_fre))]).T
'''
人工神经网络
预测及结果展示
'''
ANNreg = make_pipeline(
StandardScaler(),
MLPRegressor(hidden_layer_sizes=(100, ),
alpha=0.001,
learning_rate_init=0.001,
random_state=1,
max_iter=100))
ANNreg.fit(FP_value_191207, vib_191207_ary)
vib_pred_ANN_200102 = ANNreg.predict(FP_value_200102)
'''
算法集合体
预测及结果展示
'''
LR_meta = []
base_LR_meta = LinearRegression()
for i in range(len(select_fre)):
vib_pred_ALL_200102 = np.hstack(
(vib_pred_LR_200102[:, i].reshape(-1, 1),
vib_pred_SVR_200102[:, i].reshape(-1, 1),
vib_pred_ANN_200102[:, i].reshape(-1, 1)))
LR_meta.append(
sklearn.base.clone(base_LR_meta).fit(vib_pred_ALL_200102,
vib_200102_ary[:, i]))
# vib_pred_ALL_200102, vib_200102_ary = TrainDataUnSamping(vib_pred_ALL_200102, vib_200102_ary, 10000)
vib_pred_LR_200106 = LRreg.predict(FP_value_200106)
vib_pred_SVR_200106 = np.array(
[SVRreg[i].predict(FP_value_200106) for i in range(len(select_fre))]).T
vib_pred_ANN_200106 = ANNreg.predict(FP_value_200106)
vib_pred_final_200106 = np.array([LR_meta[i].predict(np.hstack((vib_pred_LR_200106[:, i].reshape(-1, 1),
vib_pred_SVR_200106[:, i].reshape(-1, 1),
vib_pred_ANN_200106[:, i].reshape(-1, 1)))) \
for i in range(len(select_fre))]).T
# 将预测的频域信号通过快速傅里叶逆变换转换成时域信号，并进行评价和可视化
# vib_true_200106 = vib_value_200106.reshape(-1)
vib_true_200106 = ifftOrigin(timeWindows(vib_abs_200106, length=10),
vib_ang_200106)
vib_pred_200106 = ifftPredict(vib_pred_final_200106, select_fre, NUM)
print(
abs(
np.sqrt(np.mean(vib_true_200106**2)) -
np.sqrt(np.mean(vib_pred_200106**2))) /
np.sqrt(np.mean(vib_true_200106**2)))
plt.figure()
plt.plot(vib_true_200106)
plt.plot(vib_pred_200106)
plt.title('算法集合体预测结果')
def predict():
input_data = json.loads(str(request.get_data().decode()))
modelPath = input_data.get("modelPath")
VIBForPredict = input_data.get('VIBForPredict')
vib_FP_highCol_FP = input_data.get('FPForPredict')
zeroCor_191207 = loadFile("Savedfile/zeroCor_191207")
fpPredict = []
for key in vib_FP_highCol_FP.keys():
for v in vib_FP_highCol_FP[key]:
if v in zeroCor_191207.tolist():
continue
fpPredict.append(v)
with open('model/' + modelPath, 'rb') as f: # python路径要用反斜杠
LR = pickle.load(f)
SVR = pickle.load(f)
ANN = pickle.load(f)
LRmeta = pickle.load(f)
features = loadFile("model/" + modelPath.split('.')[0] + "_input")
# fpPredict.sort()
# features.sort()
# if fpPredict != features:
# return Response(json.dumps('模型需要的特征与选择的不一致'), mimetype='application/json')
# if features !=
# 表示进行频域变换的每个单元监控点的数量
if len(fpPredict) < len(features):
return Response(json.dumps({"code": 500, "msg": "选择的特征数少于该模型需要的特征数，请重选"}), mimetype='application/json')
else:
fpPredict = fpPredict[0:len(features)]
NUM = 500
# 需要预测的测点的频率
select_fre = range(0, 200)
vibNameforPredict = list(VIBForPredict.values())[0]
vib_value_pre, FP_value_pre = readVIB_FPData(vibNameforPredict, VIBForPredict, features, vib_FP_highCol_FP,
baseURL, NUM, 'predict')
vib_abs_pre, vib_ang_pre = FFTvibData(vib_value_pre, NUM)
# vib_200102_ary = vib_abs_200102[:, select_fre]
# 对转换后的频域信号进行滑动时间窗移动平均
# vib_200102_ary = timeWindows(vib_200102_ary, length=10)
# model = LRreg
vib_pred_LR = LR.predict(FP_value_pre)
vib_pred_SVR = np.array([SVR[i].predict(FP_value_pre) for i in range(len(select_fre))]).T
vib_pred_ANN = ANN.predict(FP_value_pre)
vib_pred_final = np.array([LRmeta[i].predict(np.hstack((vib_pred_LR[:, i].reshape(-1, 1),
vib_pred_SVR[:, i].reshape(-1, 1),
vib_pred_ANN[:, i].reshape(-1, 1)))) \
for i in range(len(select_fre))]).T
progress_data['predict'] = 75.00 # 75%
vib_true_pre = ifftOrigin(timeWindows(vib_abs_pre, length=10), vib_ang_pre)
vib_pred_pre = ifftPredict(vib_pred_final, select_fre, 500)
progress_data['predict'] = 90.00 # 90%
plt.figure()
plt.plot(vib_true_pre, label='true')
plt.plot(vib_pred_pre, label='predict')
plt.legend()
plt.savefig(vibNameforPredict + ".png")
RMSE = abs(np.sqrt(np.mean(vib_true_pre ** 2)) - np.sqrt(np.mean(vib_pred_pre ** 2))) * 100 / np.sqrt(
np.mean(vib_true_pre ** 2))
rms = abs(np.sqrt(np.mean(vib_true_pre ** 2)) - np.sqrt(np.mean(vib_pred_pre ** 2)))
progress_data['predict'] = 100.00
result = {"code": 200, "msg": "模型预测成功",
"data": {"trueValue": vib_true_pre.tolist()[::1000], "predictValue": vib_pred_pre.tolist()[::1000],
"RMS": rms, "RMSE": RMSE}}
return Response(json.dumps(result), mimetype='application/json')
def predict():
# vib_name表示需要预测的测点名称
vib_Name = 'ANT6'
# 飞参与vib的相关性及其变量名
vib_191207_vib_corr = loadFile('Savedfile/' + vib_Name + '_vib_corr')
vib_191207_vib_col = loadFile('Savedfile/' + vib_Name + '_vib_col')
# list转换为np.array
vib_191207_vib_corr_ary = np.array(vib_191207_vib_corr)
vib_191207_vib_col_ary = np.array(vib_191207_vib_col)
# 选择相关性最高的10个其他测点
vib_highCol_vib = vib_191207_vib_col_ary[np.argsort(
np.abs(vib_191207_vib_corr_ary))][-11:-1]
# 读取相关的测点数据
vib_191207 = vibMatFetch(vib_highCol_vib, "191207")
vib_200102 = vibMatFetch(vib_highCol_vib, "200102")
vib_200106 = vibMatFetch(vib_highCol_vib, "200106")
# 读取需要预测的测点数据
ANT6_191207 = np.array(
readData([
findFolder(vib_Name)[j] for j in range(3)
if "191207" in findFolder(vib_Name)[j]
][0], vib_Name))
ANT6_200102 = np.array(
readData([
findFolder(vib_Name)[j] for j in range(3)
if "200102" in findFolder(vib_Name)[j]
][0], vib_Name))
ANT6_200106 = np.array(
readData([
findFolder(vib_Name)[j] for j in range(3)
if "200106" in findFolder(vib_Name)[j]
][0], vib_Name))
# vib_191207_1, ANT6_191207_1 = TrainDataUnSamping(vib_191207, ANT6_191207, 10000)
'''
线性回归
预测及结果展示
'''
LRreg = LinearRegression().fit(vib_191207, ANT6_191207)
vib_pred_LR_200102 = LRreg.predict(vib_200102)
print(
abs(
np.sqrt(np.mean(ANT6_200102**2)) -
np.sqrt(np.mean(vib_pred_LR_200102**2))) /
np.sqrt(np.mean(ANT6_200102**2)))
plt.figure()
plt.plot(ANT6_200102)
plt.plot(vib_pred_LR_200102)
plt.title('线性回归预测结果')
'''
支持向量机回归
预测及结果展示
'''
SVRreg = make_pipeline(
SVR(kernel='rbf',
C=100,
tol=0.1,
gamma=0.1,
epsilon=0.5,
max_iter=1000))
SVRreg.fit(vib_191207, ANT6_191207)
vib_pred_SVR_200102 = SVRreg.predict(vib_200102)
print(
abs(
np.sqrt(np.mean(ANT6_200102**2)) -
np.sqrt(np.mean(vib_pred_SVR_200102**2))) /
np.sqrt(np.mean(ANT6_200102**2)))
plt.figure()
plt.plot(ANT6_200102)
plt.plot(vib_pred_SVR_200102)
plt.title('支持向量回归预测结果')
'''
人工神经网络
预测及结果展示
'''
ANNreg = make_pipeline(
StandardScaler(),
MLPRegressor(hidden_layer_sizes=(100, ),
alpha=0.001,
learning_rate_init=0.01,
random_state=1,
max_iter=10))
ANNreg.fit(vib_191207, ANT6_191207)
vib_pred_ANN_200102 = ANNreg.predict(vib_200102)
print(
abs(
np.sqrt(np.mean(ANT6_200102**2)) -
np.sqrt(np.mean(vib_pred_ANN_200102**2))) /
np.sqrt(np.mean(ANT6_200102**2)))
plt.figure()
plt.plot(ANT6_200102)
plt.plot(vib_pred_ANN_200102)
plt.title('人工神经网络预测结果')
'''
算法集合体
预测及结果展示
'''
vib_pred_ALL_200102 = np.hstack(
(vib_pred_LR_200102.reshape(-1, 1), vib_pred_SVR_200102.reshape(-1, 1),
vib_pred_ANN_200102.reshape(-1, 1)))
# vib_pred_ALL_200102, ANT6_200102 = TrainDataUnSamping(vib_pred_ALL_200102, ANT6_200102, 10000)
LR_meta = LinearRegression().fit(vib_pred_ALL_200102, ANT6_200102)
vib_pred_LR_200106 = LRreg.predict(vib_200106)
vib_pred_SVR_200106 = SVRreg.predict(vib_200106)
vib_pred_ANN_200106 = ANNreg.predict(vib_200106)
vib_pred_ALL_200106 = np.hstack(
(vib_pred_LR_200106.reshape(-1, 1), vib_pred_SVR_200106.reshape(-1, 1),
vib_pred_ANN_200106.reshape(-1, 1)))
vib_pred_final_200106 = LR_meta.predict(vib_pred_ALL_200106)
print(
abs(
np.sqrt(np.mean(ANT6_200106**2)) -
np.sqrt(np.mean(vib_pred_final_200106**2))) /
np.sqrt(np.mean(ANT6_200106**2)))
plt.figure()
plt.plot(ANT6_200106)
plt.plot(vib_pred_final_200106)
plt.title('算法集合体预测结果')
def FPCorrCalculator(vibName, flightTime):
'''
计算输入变量（vibName）与某个架次（flightTime）飞行参数的Pearson's Correlation
返回2个变量corr_list, col_list
corr_list: 相关性系数
col_list: 与相关性系数对应的变量名
(corr_list[i]为col_list[i]与vibName的Person's Correlation)
返回值类型均为list
'''
vibFolder = \
[findFolder(vibName)[i] for i in range(len(findFolder(vibName))) if flightTime in findFolder(vibName)[i]][
0] # 查找振动数据所在数据包名称
vibTime = readTime(vibFolder) # 读取数据包时间序列
vibData = readData(vibFolder, vibName) # 读取振动数据
zeroCor_191207 = loadFile("Savedfile/zeroCor_191207"
) # zeroCor_191207为191207架次中的衡量变量，与振动响应数据无任何相关性
print("Vib Fetching complete!") # 告知振动数据已经提取完毕
corr_list = [] # 初始化相关性list
col_list = [] # 初始化变量名list
# fileList_ = printFiles++()
# fileFT = [fileList_[i] for i in range(len(fileList_)) if flightTime in fileList_[i]]
for i in range(7): # 在全部数据包中搜索
filenameList = printFiles(os.getcwd()) # 将全部数据包名称存入filenameList变量
filenameStr = filenameList[i] # 将搜索至数据包名称存至filenameStr变量
if (filenameStr.endswith("CAOWEN-664002-32.txt")
or filenameStr.endswith("CAOWEN-664003-32.txt")
or filenameStr.endswith("CAOWEN-ANA003-32.txt")
or filenameStr.endswith("FCS-664002-16.txt")): # 筛选飞参数据包
print(filenameStr + " Fetching Started!") # 告知开始提取某飞参数据包的数据
# print (filenameStr)
time_i = readTime(filenameStr) # 将该飞参数据的时间数据存至time_i变量
columns_i = printColumns(filenameStr) # 将该飞参数据的变量名称存至columns_i变量
print("In total of " + str(len(columns_i)) +
" columns") # 告知一共有多少变量
for j in range(1, len(columns_i)): # 搜索提取的变量名称
print("Start " + str(j) + "/" +
str(len(columns_i))) # 告知开始计算某个变量
if (columns_i[j] in zeroCor_191207): # 如果某个变量在zeroCor_191207中
print(columns_i[j] + " Break!") # 告知并跳过该变量的计算
elif ("Accel"
in columns_i[j]): # 如果某个变量包括"Accel"在变量名称中，该变量为加速度传感器数据
print(columns_i[j] + " Break!") # 告知并跳过该变量的计算
else: # 如果不符合以上两种情况
jCol = readData(filenameStr, columns_i[j]) # 读取飞参数据
jCol_matched = matchData(vibTime, time_i,
jCol) # 将飞参数据与振动数据时间轴匹配
corrJ = scs.pearsonr(jCol_matched,
vibData)[0] # 计算该飞参数据与振动响应数据的相关性
corr_list.append(corrJ) # 将计算的相关性加入corr_list中
col_list.append(columns_i[j]) # 将变量名称加入col_list
print("Correlation between " + columns_i[j] + " and " +
str(vibName) + " is " + str(corrJ)) # 告知变量名与相关性
print(filenameStr + " Fetching complete!") # 告知飞参变量的读取完毕
return (corr_list, col_list) # 输出corr_list与col_list