def VIB_correlation_Calculator(VIBname, VIBtime):
'''
计算名为VIBname的振动数据与其他振动数据在VIBtime架次的Pearson's corrletion
返回2个变量corr_list, col_list
corr_list: 相关性系数
col_list: 与相关性系数对应的变量名
(corr_list[i]为col_list[i]与VIBname的Person's Correlation)
返回值类型均为list
'''
fileList = printFiles() # 读取全部文件名
corList = [] # 初始化corList为空
colList = [] # 初始化colList为空
VIBList = findFolder(VIBname) # 将VIBname所在的数据包名称存入VIBList变量
for i in range(len(VIBList)): # 搜索VIBList
if (VIBtime in VIBList[i]): # 如果检索到VIBtime架次
VIBtarget = readData(VIBList[i], VIBname) # 读取目标振动响应数据
for i in range(len(fileList)): # 搜索fileList
if (VIBtime in fileList[i]): # 如果搜索至的fileList变量包含VIBtime（架次）
filenameStr = fileList[i] # 提取该文件名称
if (filenameStr.endswith("00VIB-ANA003-512_new.txt")
): # 如果文件名以"00VIB-ANA003-512_new.txt"结尾
print("00VIB-ANA003-512 Fetching Started!"
) # 告知开始提取"00VIB-ANA003-512_new.txt"的变量
columns_ANA003 = printColumns(filenameStr) # 提取该数据包中的变量名称
print("In total of " + str(len(columns_ANA003)) +
" columns") # 告知一共有多少变量
for j in range(1, len(columns_ANA003)): # 搜索变量名称
print("Start " + str(j) + "/" +
str(len(columns_ANA003))) # 告知已开始某变量的计算
jCol = readData(filenameStr,
columns_ANA003[j]) # 读取该变量代表振动数据
corrJ = scs.pearsonr(
jCol, VIBtarget)[0] # 计算该振动数据与目标振动数据间的皮尔逊相关系数
corList.append(corrJ) # 将计算好的相关系数加入corList
colList.append(columns_ANA003[j]) # 将变量名称加入colList
print("Correlation between " + columns_ANA003[j] +
" and " + VIBname + " is " +
str(corrJ)) # 告知变量名称和相关性系数
print("00VIB-ANA003-512 Fetching complete!"
) # 告知该数据包的振动数据提取和计算已完成
if (filenameStr.endswith("FLUTTER-ANA001-512_new.txt")
): # 如果文件以"FLUTTER-ANA001-512_new.txt"结尾
print("FLUTTER-ANA001-512 Fetching Started!"
) # 告知"FLUTTER-ANA001-512_new.txt"的数据读取开始
columns_ANA001 = printColumns(filenameStr) # 提取该数据包中的全部变量名称
print("In total of " + str(len(columns_ANA001)) +
" columns") # 告知一共有多少变量
for j in range(1, len(columns_ANA001)): # 搜索变量名称
print("Start " + str(j) + "/" +
str(len(columns_ANA001))) # 告知已开始某变量的计算
jCol = readData(filenameStr,
columns_ANA001[j]) # 读取该变量代表振动数据
corrJ = scs.pearsonr(
jCol, VIBtarget)[0] # 计算该振动数据与目标振动数据间的皮尔逊相关系数
corList.append(corrJ) # 将计算好的相关系数加入corList
colList.append(columns_ANA001[j]) # 将变量名称加入colList
print("Correlation between " + columns_ANA001[j] +
" and " + VIBname + " is " +
str(corrJ)) # 告知变量名称和相关性系数
print("FLUTTER-ANA001-512 Fetching complete!"
) # 告知该数据包的振动数据提取和计算已完成
if (filenameStr.endswith("FLUTTER-ANA002-512_new.txt")
): # 如果文件以"FLUTTER-ANA002-512_new.txt"结尾
print("FLUTTER-ANA002-512 Fetching Started!"
) # 告知"FLUTTER-ANA002-512_new.txt"的数据读取开始
columns_ANA002 = printColumns(filenameStr) # 提取该数据包中的全部变量名称
print("In total of " + str(len(columns_ANA002)) +
" columns") # 告知一共有多少变量
for j in range(1, len(columns_ANA002)): # 搜索变量名称
print("Start " + str(j) + "/" +
str(len(columns_ANA002))) # 告知已开始某变量的计算
jCol = readData(filenameStr,
columns_ANA002[j]) # 读取该变量代表振动数据
corrJ = scs.pearsonr(
jCol, VIBtarget)[0] # 计算该振动数据与目标振动数据间的皮尔逊相关系数
corList.append(corrJ) # 将计算好的相关系数加入corList
colList.append(columns_ANA002[j]) # 将变量名称加入colList
print("Correlation between " + columns_ANA002[j] +
" and " + VIBname + " is " +
str(corrJ)) # 告知变量名称和相关性系数
print("FLUTTER-ANA002-512 Fetching complete!"
) # 告知该数据包的振动数据提取和计算已完成
return (corList, colList) # 输出corList与colList
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
def predict():
# vib_name表示需要预测的测点名称
vib_Name = 'ANT4'
# 垂直尾翼测点名称
VT_vib_names = ["ANT1", "ANT2", "ANT3", "ANT4", "ANT5", "ANT6", "ANT7"]
# 垂直尾翼数据读取
VT_vib_data = []
for i in range(len(VT_vib_names)):
VT_vib_data.append(
readData(findFolder(VT_vib_names[i])[0], VT_vib_names[i]))
print(VT_vib_names[i] + " Finished!")
VT_vib_ary = np.array(VT_vib_data).T
# 提取需要预测测点的监测序列
ANT4_191207 = np.array(VT_vib_data[3])
# 垂直尾翼模态叠加法训练及预测
# 垂直尾翼固有模态
VTZMode_phi1 = 14.368 * np.array([
0.112540, 0.028934, 0.131050, 0.037767, 0.043148, 0.094470, 0.134830
]).reshape(-1, 1)
VTZMode_phi2 = 45.686 * np.array([
0.000378, 0.092578, 0.136430, 0.038831, 0.015865, 0.035344, 0.163180
]).reshape(-1, 1)
VTZMode_phi3 = 56.507 * np.array([
0.102730, 0.038422, 0.116900, 0.039560, 0.047495, 0.090431, 0.120570
]).reshape(-1, 1)
VTZMode_phi4 = 61.685 * np.array([
0.126060, 0.032371, 0.089103, 0.044842, 0.085259, 0.116170, 0.072661
]).reshape(-1, 1)
VTZMode_mat = np.concatenate(
(VTZMode_phi1, VTZMode_phi2, VTZMode_phi3, VTZMode_phi4), axis=1)
ANT4_191207_pred_MT = []
X_i = np.vstack((VTZMode_mat[:3, :], VTZMode_mat[4:, :]))
for i in range(len(ANT4_191207)):
y_i = np.concatenate((VT_vib_ary[i, :3], VT_vib_ary[i, 4:]))
reg = LinearRegression(fit_intercept=True).fit(X_i, y_i)
# ANT4_191207_pred_MT.append(np.dot(reg.coef_, VTZMode_mat[3, :]))
ANT4_191207_pred_MT.append(
reg.predict(VTZMode_mat[3, :].reshape(1, -1))[0])
if (i % 400000 == 0):
print(str(round(i / len(ANT4_191207) * 100, 2)) + "%")
ANT4_191207_pred_MT = np.array(ANT4_191207_pred_MT)
print(
abs(
np.sqrt(np.mean(ANT4_191207**2)) -
np.sqrt(np.mean(ANT4_191207_pred_MT**2))) /
np.sqrt(np.mean(ANT4_191207**2)))
plt.figure()
plt.plot(ANT4_191207)
plt.plot(ANT4_191207_pred_MT)
plt.title('垂直尾翼模态叠加法预测结果')
# 最高次项为2的平面插值方法
# 垂直尾翼测点坐标（2维）
VT_vib_pos = np.array([[3.2, 3.7], [2, 2.2], [3.85, 3.7], [3.1, 2],
[3.55, 2], [3.1, 3.4], [4.2, 3.7]])
ANT4_191207_pred_CZ = []
X_i = np.vstack((VT_vib_pos[:3, :], VT_vib_pos[4:, :]))
X_i_dg2 = np.hstack((X_i, X_i**2))
for i in range(len(ANT4_191207)):
y_i = np.concatenate((VT_vib_ary[i, :3], VT_vib_ary[i, 4:]))
lr = LinearRegression().fit(X_i_dg2, y_i)
ANT4_191207_pred_CZ.append(
lr.predict(
np.hstack(
(VT_vib_pos[3, :], VT_vib_pos[3, :]**2)).reshape(1,
-1))[0])
if (i % 400000 == 0):
print(str(round(i / len(ANT4_191207) * 100, 2)) + "%")
ANT4_191207_pred_CZ = np.array(ANT4_191207_pred_CZ)
print(
abs(
np.sqrt(np.mean(ANT4_191207**2)) -
np.sqrt(np.mean(ANT4_191207_pred_CZ**2))) /
np.sqrt(np.mean(ANT4_191207**2)))
plt.figure()
plt.plot(ANT4_191207_pred_CZ)
plt.plot(ANT4_191207)
plt.title('垂直尾翼平面插值法预测结果')
'''
算法集合体
预测及结果展示
'''
ANT4_pred_ALL_191207 = np.hstack(
(ANT4_191207_pred_MT.reshape(-1,
1), ANT4_191207_pred_CZ.reshape(-1, 1)))
# LR_meta = LinearRegression().fit(ANT4_pred_ALL_191207, ANT4_191207)
LR_meta = ensembleTrain(ANT4_pred_ALL_191207, ANT4_191207, step=5000)
ANT4_pred_final_191207 = LR_meta.predict(ANT4_pred_ALL_191207)
print(
abs(
np.sqrt(np.mean(ANT4_191207**2)) -
np.sqrt(np.mean(ANT4_pred_final_191207**2))) /
np.sqrt(np.mean(ANT4_191207**2)))
plt.figure()
plt.plot(ANT4_191207)
plt.plot(ANT4_pred_final_191207)
plt.title('垂直尾翼算法集合体预测结果')
def predict():
# vib_name表示需要预测的测点名称
vib_Name = 'ANH4'
# 水平尾翼测点名称
LT_vib_names = ["ANH1", "ANH2", "ANH3", "ANH4", "ANH5", "ANH11", "ANH13"]
# 水平尾翼数据读取
LT_vib_data = []
for i in range(len(LT_vib_names)):
LT_vib_data.append(
readData(findFolder(LT_vib_names[i])[0], LT_vib_names[i]))
print(LT_vib_names[i] + " Finished!")
LT_vib_ary = np.array(LT_vib_data).T
# 提取需要预测测点的监测序列
ANH4_191207 = np.array(LT_vib_data[3])
# 水平尾翼模态叠加法训练及预测
# 水平尾翼固有模态
LTZMode_phi1 = 17.960 * np.array([
0.198240, 0.209660, 0.060092, 0.079628, 0.007122, 0.172180, 0.096400
]).reshape(-1, 1)
LTZMode_phi2 = 51.337 * np.array([
0.186680, 0.196690, 0.069147, 0.079404, 0.014269, 0.164790, 0.101410
]).reshape(-1, 1)
LTZMode_phi3 = 64.446 * np.array([
0.136150, 0.219270, 0.150160, 0.072657, 0.013771, 0.065595, 0.033473
]).reshape(-1, 1)
LTZMode_phi4 = 80.292 * np.array([
0.170690, 0.083437, 0.087226, 0.093101, 0.042739, 0.156430, 0.179670
]).reshape(-1, 1)
LTZMode_mat = np.concatenate(
(LTZMode_phi1, LTZMode_phi2, LTZMode_phi3, LTZMode_phi4), axis=1)
ANH4_191207_pred_MT = []
X_i = np.vstack((LTZMode_mat[:3, :], LTZMode_mat[4:, :]))
for i in range(len(ANH4_191207)):
y_i = np.concatenate((LT_vib_ary[i, :3], LT_vib_ary[i, 4:]))
reg = LinearRegression(fit_intercept=True).fit(X_i, y_i)
# ANH4_191207_pred_MT.append(np.dot(reg.coef_, LTZMode_mat[3, :]))
ANH4_191207_pred_MT.append(
reg.predict(LTZMode_mat[3, :].reshape(1, -1))[0])
if (i % 400000 == 0):
print(str(round(i / len(ANH4_191207) * 100, 2)) + "%")
ANH4_191207_pred_MT = np.array(ANH4_191207_pred_MT)
print(
abs(
np.sqrt(np.mean(ANH4_191207**2)) -
np.sqrt(np.mean(0.04 * ANH4_191207_pred_MT**2))) /
np.sqrt(np.mean(ANH4_191207**2)))
plt.figure()
plt.plot(ANH4_191207)
plt.plot(0.2 * ANH4_191207_pred_MT)
plt.title('0.2*水平尾翼模态叠加法预测结果')
# 最高次项为2的平面插值方法
# 水平尾翼测点坐标（2维）
LT_vib_pos = np.array([[-0.15, 3.5], [-0.45, 3.5], [0.75, 2.3],
[0.05, 2.3], [0, 0.9], [0, 3.3], [-0.3, 2.4]])
ANH4_191207_pred_CZ = []
X_i = np.vstack((LT_vib_pos[:3, :], LT_vib_pos[4:, :]))
X_i_dg2 = np.hstack((X_i, X_i**2))
for i in range(len(ANH4_191207)):
y_i = np.concatenate((LT_vib_ary[i, :3], LT_vib_ary[i, 4:]))
lr = LinearRegression().fit(X_i_dg2, y_i)
ANH4_191207_pred_CZ.append(
lr.predict(
np.hstack(
(LT_vib_pos[3, :], LT_vib_pos[3, :]**2)).reshape(1,
-1))[0])
if (i % 400000 == 0):
print(str(round(i / len(ANH4_191207) * 100, 2)) + "%")
ANH4_191207_pred_CZ = np.array(ANH4_191207_pred_CZ)
print(
abs(
np.sqrt(np.mean(ANH4_191207**2)) -
np.sqrt(np.mean(ANH4_191207_pred_CZ**2))) /
np.sqrt(np.mean(ANH4_191207**2)))
plt.figure()
plt.plot(ANH4_191207_pred_CZ)
plt.plot(ANH4_191207)
plt.title('水平尾翼平面插值法预测结果')
'''
算法集合体
预测及结果展示
'''
ANH4_pred_ALL_191207 = np.hstack(
(ANH4_191207_pred_MT.reshape(-1,
1), ANH4_191207_pred_CZ.reshape(-1, 1)))
# LR_meta = LinearRegression().fit(ANH4_pred_ALL_191207, ANH4_191207)
LR_meta = ensembleTrain(ANH4_pred_ALL_191207,
ANH4_191207,
step=len(ANH4_191207))
ANH4_pred_final_191207 = LR_meta.predict(ANH4_pred_ALL_191207)
print(
abs(
np.sqrt(np.mean(ANH4_191207**2)) -
np.sqrt(np.mean(ANH4_pred_final_191207**2))) /
np.sqrt(np.mean(ANH4_191207**2)))
plt.figure()
plt.plot(ANH4_191207)
plt.plot(ANH4_pred_final_191207)
plt.title('水平尾翼算法集合体预测结果')
def predict():
# vib_name表示需要预测的测点名称
vib_Name = 'ANW5'
# 机翼测点名称
wing_vib_names = [
"ANW1", "ANW2", "ANW3", "ANW4", "ANW5", "ANW6", "ANW7", "ANW8",
"ANW17", "ANW18"
]
# 机翼数据读取
wing_vib_data = []
for i in range(len(wing_vib_names)):
wing_vib_data.append(
readData(findFolder(wing_vib_names[i])[0], wing_vib_names[i]))
print(wing_vib_names[i] + " Finished!")
wing_vib_ary = np.array(wing_vib_data).T
# 提取需要预测测点的监测序列
ANW5_191207 = np.array(wing_vib_data[4])
# 机翼模态叠加法训练及预测
# 机翼固有模态
wingZMode_phi1 = 4.6242 * np.array([
0.053323, 0.054902, 0.052748, 0.039911, 0.040730, 0.019372, 0.020486,
0.048519, 0.002433, 0.018903
]).reshape(-1, 1)
wingZMode_phi2 = 10.135 * np.array([
0.057075, 0.059566, 0.056369, 0.039238, 0.040464, 0.015998, 0.016806,
0.050925, 0.002292, 0.016526
]).reshape(-1, 1)
wingZMode_phi3 = 20.535 * np.array([
0.044158, 0.053486, 0.040799, 0.013048, 0.014958, 0.032946, 0.029549,
0.034825, 0.008309, 0.026757
]).reshape(-1, 1)
wingZMode_phi4 = 33.196 * np.array([
0.041207, 0.052499, 0.039350, 0.007710, 0.010925, 0.031769, 0.032244,
0.028927, 0.008433, 0.031172
]).reshape(-1, 1)
wingZMode_mat = np.concatenate(
(wingZMode_phi1, wingZMode_phi2, wingZMode_phi3, wingZMode_phi4),
axis=1)
ANW5_191207_pred_MT = []
X_i = np.vstack((wingZMode_mat[:4, :], wingZMode_mat[5:-2, :]))
for i in range(len(ANW5_191207)):
y_i = np.concatenate((wing_vib_ary[i, :4], wing_vib_ary[i, 5:-2]))
reg = LinearRegression(fit_intercept=True).fit(X_i, y_i)
# ANW5_191207_pred_MT.append(np.dot(reg.coef_, wingZMode_mat[4, :]))
ANW5_191207_pred_MT.append(
reg.predict(wingZMode_mat[4, :].reshape(1, -1))[0])
if (i % 400000 == 0):
print(str(round(i / len(ANW5_191207) * 100, 2)) + "%")
ANW5_191207_pred_MT = np.array(ANW5_191207_pred_MT)
print(
abs(
np.sqrt(np.mean(ANW5_191207**2)) -
np.sqrt(np.mean(ANW5_191207_pred_MT**2))) /
np.sqrt(np.mean(ANW5_191207**2)))
plt.figure()
plt.plot(ANW5_191207)
plt.plot(ANW5_191207_pred_MT)
plt.title('机翼模态叠加法预测结果')
# 最高次项为2的平面插值方法
# 机翼测点坐标（2维）
wing_vib_pos = np.array([[-0.9, 8.3], [-1.45, 8.3], [-0.7, 8.3],
[-0.5, 6.9], [-0.8, 6.9], [0.7, 4.7], [0.2, 4.7],
[-1.4, 7.35], [0.15, 1.3], [-0.45, 4.3]])
ANW5_191207_pred_CZ = []
X_i = np.vstack((wing_vib_pos[:4, :], wing_vib_pos[5:-2, :]))
X_i_dg2 = np.hstack((X_i, X_i**2))
for i in range(len(ANW5_191207)):
y_i = np.concatenate((wing_vib_ary[i, :4], wing_vib_ary[i, 5:-2]))
lr = LinearRegression().fit(X_i_dg2, y_i)
ANW5_191207_pred_CZ.append(
lr.predict(
np.hstack((wing_vib_pos[4, :],
wing_vib_pos[4, :]**2)).reshape(1, -1))[0])
if (i % 400000 == 0):
print(str(round(i / len(ANW5_191207) * 100, 2)) + "%")
ANW5_191207_pred_CZ = np.array(ANW5_191207_pred_CZ)
print(
abs(
np.sqrt(np.mean(ANW5_191207**2)) -
np.sqrt(np.mean(ANW5_191207_pred_CZ**2))) /
np.sqrt(np.mean(ANW5_191207**2)))
plt.figure()
plt.plot(ANW5_191207_pred_CZ)
plt.plot(ANW5_191207)
plt.title('机翼平面插值法预测结果')
'''
算法集合体
预测及结果展示
'''
ANW5_pred_ALL_191207 = np.hstack(
(ANW5_191207_pred_MT.reshape(-1,
1), ANW5_191207_pred_CZ.reshape(-1, 1)))
# LR_meta = LinearRegression().fit(ANW5_pred_ALL_191207, ANW5_191207)
LR_meta = ensembleTrain(ANW5_pred_ALL_191207, ANW5_191207, step=5000)
ANW5_pred_final_191207 = LR_meta.predict(ANW5_pred_ALL_191207)
print(
abs(
np.sqrt(np.mean(ANW5_191207**2)) -
np.sqrt(np.mean(ANW5_pred_final_191207**2))) /
np.sqrt(np.mean(ANW5_191207**2)))
plt.figure()
plt.plot(ANW5_191207)
plt.plot(ANW5_pred_final_191207)
plt.title('机翼算法集合体预测结果')