2022.11.7日更新
为了方便大家，我直接把代码和文章搞进百度网盘，自行获取。
链接失效的话，可以私信或者评论告诉我。
链接：https://pan.baidu.com/s/1X6ZuWSSiH_VwpaVQg8N4ng
提取码：so3z
一、题目要求
题目说了一大堆，其实很简单。就是汽车在行驶时，总会有一些相同或类似的行驶状况，比如：下班回家时，汽车慢速行驶的断断续续，由于大多数车辆都经常遇到，所以这是一种典型的汽车行驶状况。
我们的目标就是根据题目所给的三个文件，找出几个这样的典型行驶状况（如分别代表慢速、中速、高速、以及一些额外的行驶状况），然后拼到一起，就得到该城市的汽车行驶工况曲线了。
二、基本思路
1.数据处理
首先很明显这是一个数据处理题，因此第一步当时是对数据进行处理，比如有些地方信号不好没采集到值、传感器歪了有异常值等等。以下是题目给出的需要处理的情况：
(1) 由于高层建筑覆盖或过隧道等，GPS信号丢失，造成所提供数据中的时间不连续；
(2) 汽车加、减速度异常的数据（普通轿车一般情况下：0至100km/h的加速时间大于7秒，紧急刹车最大减速度在7.5~8 m/s2）；
(3) 长期停车（如停车不熄火等候人、停车熄火了但采集设备仍在运行等）所采集的异常数据。
(4) 长时间堵车、断断续续低速行驶情况（最高车速小于10km/h）,通常可按怠速情况处理。
(5) 一般认为怠速时间超过180秒为异常情况，怠速最长时间可按180秒处理。
直接对每种情况进行编程处理，思路不难，就是每个小点的程序都得编写+测试+极限情况测试，量不少，写了我好久。
然后将这些数据按照汽车的怠速状态分成许多运动学片段。咱们就是要从一大堆运动学片段中找到最能代表汽车行驶时状况的片段，将其组合得到汽车行驶工况曲线。
2. 特征提取
在得到一大堆运动学片段后，我们当然要对他们进行比较，然后看哪个片段才能代表最典型的运行状况！
首先排除这种思路：拿一堆片段一秒一秒的比。这样根本看不出啥，而且每个片段的时长也完全不一样，不好搞。
正确的思路是：对每个片段提取相应的特征，比如平均速度、平均行驶速度、运动学片段时间长度、平均加速度、平均减速度..等等等。搞上一大堆特征，这些特征就能够代表这个运动学片段的大体情况，比如整体的行驶速度是快还是慢啊，你这车加速时间在整个运动学片段中占多长啊。然后我们用这些特征去对运动学片段们进行比较，找出典型的片段。
本文选择了平均速度、平均行驶速度、最大速度、平均加速度、平均减速度、速度标准差、加速度标准差、减速度标准差、运动学片段时间长度、怠速时间、加速时间、减速时间、匀速时间、怠速时间比、加速时间比、减速时间比、匀速时间比、平均扭矩百分比、平均油耗、踏板平均开度、平均空燃比、平均负荷百分比、平均进气流量，共计23个作为初始特征。
不过23个特征太多了，会影响以后模型的求解速度。而且都是凭感觉提的，很有可能会出现这些情况：①有些特征没啥用；②也有些特征可能会出现冗余，比如平均油耗和平均踏板开度，这俩可能反应的都是同一个东西。因此采用主成分分析法（PCA）对原始特征进行降维，得到贡献度超过85%的前6个特征。
3. 构建汽车行驶工况
拿到特征后，我们采用KMeans算法对所有的运动选片段进行分类。我们先不介绍这个算法的具体细节，只介绍它的的输入输出：
将这些特征作为输入，设定分类数量，经过计算，可以得到以下输出：
①每个样本（运动学片段）的分类：即算法给样本设定一个数字，可以通过查看样本的这个数字，来知道样本归属于哪一类。比如一共分四类，那么所有样本被设定的数字都是1、2、3、4中的一个，数字相同即代表样本是属于同一类的。
②每类的聚类中心：聚类中心就是属于这个类别的所有样本，每个特征值加一起取平均。
由于本文选择构建的汽车行驶工况曲线包含以下四种运行状况：低速、中速、高速、额外。因此将KMeans的分类数设为4。
得到每类的聚类中心后，与对应类别的每个样本计算欧氏距离（类似于均方差），找到每个离聚类中心最近的样本，组合到一块，我们要的汽车行驶工况曲线就出来啦！没错，就是下面这个图。
说明：
目前只介绍了解题的大体思路，还有一些详细的没有进行说明，想要了解的可以看看下面的程序或论文，我注释写的很详尽。
三、 Python代码
都是我当时一行一行敲得，累skr人。
根据步骤创建python文件，直接粘贴复制运行就行。
1. 数据预处理
import datetime
import pandas as pd
import numpy as np
import xlsxwriter as xw
excel = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/原始数据/文件1.xlsx")
data = pd.DataFrame(excel)
# 文件一的时间处理
data['时间'] = pd.to_datetime(data['时间'], format='%Y/%m/%d %H:%M:%S.000.')
#文件123
begin = datetime.datetime.strptime('2017-12-18 13:42:12', '%Y-%m-%d %H:%M:%S')
#begin = datetime.datetime.strptime('2017-11-01 19:11:49', '%Y-%m-%d %H:%M:%S')
#begin = datetime.datetime.strptime('2017-12-01 19:43:56', '%Y-%m-%d %H:%M:%S')
data['unix 时间'] = data['时间'].map(lambda x:(x-begin).total_seconds()) #索引为1
print("时间转换完成")
# 增加一列变换单位后的GPS车速：索引为15
i=0
while i<len(data):
#loc函数主要通过行标签索引行数据
data.loc[i, 'GPS车速(m/s)']=data.iat[i,1]/3.6
i+=1
print("变换单位后的GPS车速，添加成功")
# 增加加速度列：索引为16
i=1
while i<len(data):
tf = data.iat[i,14]-data.iat[i-1,14] #时间差
sf = data.iat[i,15]-data.iat[i-1,15] #速度差
data.loc[i, '加速度(m/s^2)']=sf/tf
i+=1
data.loc[0, '加速度(m/s^2)'] = data.loc[1, '加速度(m/s^2)'] #补上空余值
print("加速度，添加成功")
print("原始数据数量：",len(data))
####处理超速、加减速异常、有速度经纬度却不变、经纬度异常4种错误
#先不对第一个和最后一个数据进行处理
i = 0
n = 0
while i<len(data)-1:
# 去除车速异常数据：车速大于120km/h，即每秒速度高于33m/s
#if data.loc[i,'GPS车速(m/s)'] > 33.3333 or data.loc[i,'经度'] == 0 or data.loc[i,'纬度'] == 0 or (data.loc[i,'经度'] - data.loc[i-1,'经度'] == 0 and data.loc[i,'维度'] - data.loc[i-1,'维度'] == 0 and data.loc[i,'GPS车速(m/s)'] != 0) or data.loc[i,'加速度(m/s^2)']>4 or data.loc[i,'加速度(m/s^2)']<-8:
if data.iloc[i,15] > 33.3333 or data.iloc[i, 5] == 0 or data.iloc[i, 6] == 0 or (data.iloc[i, 5] - data.iloc[i-1,5] == 0 and data.iloc[i,6] - data.iloc[i-1,6] == 0 and data.iloc[i,15] != 0) or data.iloc[i,16]>4 or data.iloc[i,16]<-8:
data.drop(i+n,inplace=True) # drop靠“行名”进行查询，因此引入变量n
n+=1
else:
i += 1
print("去除异常后的数据数量：",len(data))
#row_name = data._stat_axis.values.tolist() #获取行名
#print(row_name)
arr = np.array(data)
data = pd.DataFrame(arr) # 重新来回转变一次，将行名变成正常的序列
#大于180秒的怠速时间处理成180秒
print("开始处理过长的怠速时间")
i = 0
n = 0
lock = 0
while i < len(data)-1:
if lock == 0 and data.iloc[i, 15] < (10 / 3.6): # 根据索引
s = i
#print(s)
lock = 1
if data.iloc[i, 15] < (10 / 3.6):
count = (data.iloc[i,14] - data.iloc[s,14])
if count > 180:
data.drop(i+n, inplace=True) #根据行名
n += 1
else:
i += 1
else:
lock = 0
i += 1
print("截断过长时间怠速的数据数量：",len(data))
print("开始线性插值...")
#线性插值
data_l = data.values.tolist() # 转为列表
i = 1
while i < len(data_l):
t = data_l[i][14] - data_l[i-1][14]
if 1< t <= 6: # 缺失点小于6秒时，进行插值
for j in range(round(t-1)): # 插入t-1个点
diff = []
new_p = []
for m in range(17):
diff.append((data_l[i + j][m] - data_l[i-1][m]) / t)
new_p.append(data_l[i - 1][m] + diff[m] * (j + 1))
data_l.insert(i+j,new_p)
i+=1
print("插值后数据量",len(data_l))
#处理长期低速行驶，将其视为怠速状态
print("开始处理长期低速行驶")
i = 0
lock = 0
count = 0
dele = []
while i < len(data_l):
if lock == 0 and data_l[i][15] < 10/3.6:
s1 = i
lock = 1
if lock == 1 and data_l[i][15] >= 10/3.6:
# 只要出现速度大于10，就必须做决断。要么是存起来删除，要么是解锁，准备重新计时
s2 = i
# 低速时间超过50秒时，进行判断：
# 如果速度为0的时间超过50，则不做处理
# 如果速度为0的时间小于50，则认为是低速行驶，直接将此区间置0
if data_l[s2][14] - data_l[s1][14] > 50:
if count < 50:
low_speed = [s1+3,s2-3] # 前后保留3个点的原始数值
dele.append(low_speed)
lock = 0
count = 0
if lock == 1 and data_l[i][14] == 0:
count += 1
i += 1
for i in range(len(dele)):
for j in range(dele[i][0],dele[i][1]):
data_l[j][1] = 0
print("处理完低速行驶后的数据量：",len(data_l))
workbook = xw.Workbook("data1_pro.xlsx") # 创建工作簿
worksheet1 = workbook.add_worksheet("sheet1") # 创建子表
worksheet1.activate() # 激活表
title = ["时间",'GPS车速', 'X轴加速度', 'Y轴加速度',"Z轴加速度","经度","纬度","发动机转速","扭矩百分比","瞬时油耗","油门踏板开度","空燃比","发动机负荷百分比","进气流量","时间（处理后）","变换单位车速","加速度"] # 设置表头
worksheet1.write_row('A1', title) # 从A1单元格开始写入表头
for i in range(0,len(data_l)):# 从第二行开始写入数据
insertData = []
for j in range(17):
insertData.append(data_l[i][j])
row = 'A' + str(i+2)
worksheet1.write_row(row, insertData)
workbook.close() # 关闭表2. 运动学片段的划分
import pandas as pd
import xlsxwriter as xw
excel = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/data1_pro.xlsx")
data = pd.DataFrame(excel)
data_l = data.values.tolist() # 转为列表
#截取运动学片段
i = 0
lock1 = 0
lock2 = 0
result = []
garbage = []
while i < len(data_l)-5:
if lock1 == 0 and data_l[i][15] == 0: #速度为0时
s1 = i
lock1 = 1
if lock1 == 1 and lock2 == 0 and data_l[i][15] > 0: #速度大于0
s2 = i
lock2 = 1
if lock1 ==1 and lock2 ==1 and data_l[i][15] == 0:
ss = 0
for m in range(1, 6): # 避免临时一两个0速点的干扰
if data_l[i + m][15] == 0:
ss += 1
if ss == 5:
part = [s1,s2,i-1]
result.append(part)
lock1 = 0
lock2 = 0
i-=1
# 存储相邻点时间差大于5秒的索引，然后删掉这个运动学片段
if data_l[i][14] - data_l[i - 1][14] > 6: # 大于6
garbage.append(i) # 放进去的这个点和前一个点的时间差大于5秒，存的是后一个点！
i += 1
print("总共的运动学片段：",len(result))
#删除缺失点过多的运动学片段
i = 0
while i < len(garbage):
j = 0
while j < len(result):
if result[j][0] >= garbage[i]: #开头大于、等于你，后面的元素就都不用判断了
j+=1
break
if result[j][0] < garbage[i] <= result[j][2]:
del result[j] #少了一个元素，所以就不加1
else:
j+=1
i+=1 # garbage长度不会变，每次循环完，正常+1就行
print("删除缺失点过多的运动学片段：",len(result))
#删掉时间小于10秒、大于500秒的运动学片段
i = 0
while i < len(result):
if result[i][2] - result[i][1] < 40 or result[i][2] - result[i][0] > 500:
del result[i]
else:
i+=1
print("删除持续时间小于40、大于500秒的运动学片段：",len(result))
# 将分段信息写入excel
workbook = xw.Workbook("info1.xlsx") # 创建工作簿
worksheet1 = workbook.add_worksheet("sheet1") # 创建子表
worksheet1.activate() # 激活表
title = ["开始",'怠速', '结束'] # 设置表头
worksheet1.write_row('A1', title) # 从A1单元格开始写入表头
for i in range(0,len(result)):# 从第二行开始写入数据
insertData = []
for j in range(3):
insertData.append(result[i][j])
row = 'A' + str(i+2)
worksheet1.write_row(row, insertData)
workbook.close() # 关闭表3. 提取特征值
import pandas as pd
import numpy as np
import xlsxwriter as xw
info = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/info3.xlsx")
data1 = pd.DataFrame(info)
result = data1.values
excel = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/data3_pro.xlsx")
data2 = pd.DataFrame(excel)
data_a = data2.values # 变为数组
feature = []
#计算特征值
for i in range(len(result)):
m = result[i][0] # 运动学片段开始点
n = result[i][1] # 运动学片段怠速状态结束点
k = result[i][2]+1 # 运动学片段结束点
v_average = sum(data_a[m:k,15])/(k-m)
v_average_travel = sum(data_a[n:k,15])/(k-n)
v_max = max(data_a[m:k,15])
#加减速
plus = []
slow = []
uniformity = []
for j in range(m,k):
acc = data_a[j][16]
if acc > 0:
plus.append(acc)
if acc < 0:
slow.append(acc)
if acc == 0:
uniformity.append(acc)
# 平均加速度
plus_average = sum(plus)/len(plus)
# 平均减速度
slow_average = sum(slow)/len(slow)
# 速度标准差
v_std = np.std(data_a[m:k,15])
# 加速度标准差
plus_std = np.std(plus)
# 减速度标准差
slow_std = np.std(slow)
# 运动学片段时长
time = k - m
# 怠速时间
time_0 = n - m
# 加速时间
time_1 = len(plus)
# 减速时间
time_2 = len(slow)
# 匀速时间
time_3 = len(uniformity)
# 怠速时间比
ratio_0 = time_0/time
# 加速时间比
ratio_1 = time_1 / time
# 减速时间比
ratio_2 = time_2 / time
# 匀速时间比
ratio_3 = time_3 / time
# 平均扭矩百分比
torque = sum(data_a[m:k,8])/(k-m)
# 平均瞬时油耗
oil = sum(data_a[m:k,9])/(k-m)
# 踏板平均开度
pedal = sum(data_a[m:k,10])/(k-m)
# 平均空燃比
air_fuel_ratio = sum(data_a[m:k,11])/(k-m)
# 平均负荷百分比
load = sum(data_a[m:k,12])/(k-m)
# 平均进气流量
flow = sum(data_a[m:k,13])/(k-m)
all = [v_average,v_average_travel,v_max,plus_average,slow_average,v_std,plus_std,slow_std,time,time_0,time_1,time_2,time_3,ratio_0,ratio_1,ratio_2,ratio_3,torque,oil,pedal,air_fuel_ratio,load,flow]
feature.append(all)
# 写出
workbook = xw.Workbook("feature3.xlsx") # 创建工作簿
worksheet1 = workbook.add_worksheet("sheet1") # 创建子表
worksheet1.activate() # 激活表
title = ["平均速度","平均行驶速度","最大速度","平均加速度","平均减速度","速度标准差","加速度标准差","减速度标准差","运动学片段时间长度","怠速时间","加速时间","减速时间","匀速时间","怠速时间比","加速时间比","减速时间比","匀速时间比","平均扭矩百分比","平均油耗","踏板平均开度","平均空燃比","平均负荷百分比","平均进气流量"] # 设置表头
worksheet1.write_row('A1', title) # 从A1单元格开始写入表头
for i in range(0,len(feature)):# 从第二行开始写入数据
insertData = []
for j in range(23):
insertData.append(feature[i][j])
row = 'A' + str(i+2)
worksheet1.write_row(row, insertData)
workbook.close() # 关闭表
print("文件写出完毕~~~")4. 通过PCA对特征进行降维
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
import pandas as pd
import xlsxwriter as xw
import numpy as np
import matplotlib.pyplot as plt
feature1 = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/feature1.xlsx")
feature1 = pd.DataFrame(feature1)
feature1 = feature1.values.tolist()
feature2 = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/feature2.xlsx")
feature2 = pd.DataFrame(feature2)
feature2 = feature2.values.tolist()
feature3 = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/feature3.xlsx")
feature3 = pd.DataFrame(feature3)
feature3 = feature3.values.tolist()
feature = feature1 + feature2 + feature3
# PCA转换特征
feature = StandardScaler().fit_transform(feature) #数据标准化：方差为1，均值为0
#不仅计算训练数据的均值和方差，还会基于计算出来的均值和方差来转换训练数据，从而把数据转换成标准的正太分布
pca = PCA(n_components='mle')
#先创建一个PCA对象，其中参数n_components表示保留的特征数，默认为1。如果设置成‘mle’,那么会自动确定保留的特征数
pca.fit(feature) # 计算K-means聚类，用来训练PCA模型
print("贡献率：",pca.explained_variance_ratio_) # 返回贡献率
plt.plot(pca.explained_variance_ratio_,marker = "o")
plt.xlabel('feature')
plt.ylabel('Contribution degree')
plt.show()
new_feature = pca.transform(feature) # 将数据X转换成降维后的数据，数据类型：ndarray用于存放同类型元素的多维数组
# 写出
workbook = xw.Workbook("new_feature.xlsx") # 创建工作簿
worksheet1 = workbook.add_worksheet("sheet1") # 创建子表
worksheet1.activate() # 激活表
title = [] # 设置表头
for i in range(new_feature.shape[1]):
title.append("新特征"+str(i))
print("降维后，特征维度：",new_feature.shape)
worksheet1.write_row('A1', title) # 从A1单元格开始写入表头
for i in range(0,len(new_feature)): # 从第二行开始写入数据
insertData = []
for j in range(new_feature.shape[1]):
insertData.append(feature[i][j])
row = 'A' + str(i+2)
worksheet1.write_row(row, insertData)
workbook.close() # 关闭表
print("文件写出完毕~~~")5. 利用KEmans进行聚类，并得到汽车工况曲线的索引
import matplotlib.pyplot as plt
import numpy as np
from sklearn.cluster import KMeans
import pandas as pd
import xlsxwriter as xw
new_feature = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/new_feature.xlsx")
new_feature = pd.DataFrame(new_feature)
new_feature = new_feature.values
new_feature = new_feature[:,0:6] # 新构建的特征
feature1 = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/feature1.xlsx")
feature1 = pd.DataFrame(feature1)
feature1 = feature1.values.tolist()
feature2 = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/feature2.xlsx")
feature2 = pd.DataFrame(feature2)
feature2 = feature2.values.tolist()
feature3 = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/feature3.xlsx")
feature3 = pd.DataFrame(feature3)
feature3 = feature3.values.tolist()
feature = feature1 + feature2 + feature3 # 原始特征
# KMeans聚类
kk = KMeans(n_clusters=4, random_state=234).fit(new_feature) # fit()计算K-means聚类
# random_state随机生成簇中心的状态条件，随机数种子
kk_pre = kk.predict(new_feature) # 预测K-means聚类，给出每个样本对应的分类
# print(kk_pre)
centroids = kk.cluster_centers_ # 获取聚类中心
# label_pred = kk.labels_ # 获取聚类标签（共有多少种类别）
# inertia = kk.inertia_ # 获取聚类准则的总和（感觉一般没啥用）
print(centroids)
# 记录下每个类别包含的样本索引
label_0 = []
label_1 = []
label_2 = []
label_3 = []
# 这里面存的都是索引
for i in range(len(kk_pre)):
if kk_pre[i] == 0:
label_0.append(i)
if kk_pre[i] == 1:
label_1.append(i)
if kk_pre[i] == 2:
label_2.append(i)
if kk_pre[i] == 3:
label_3.append(i)
print("第1类运动学片段的数量：",len(label_0))
print("第2类运动学片段的数量：",len(label_1))
print("第3类运动学片段的数量：",len(label_2))
print("第4类运动学片段的数量：",len(label_3))
# 计算4类平均时长：8号为运行时间长度
def count_average_time(label_list):
aver_t = 0
count = 0
max = 0
for i in range(len(label_list)):
if feature[label_list[i]][8] > 50:
aver_t += feature[label_list[i]][8]
count += 1
if feature[label_list[i]][8] > max:
max = feature[label_list[i]][8]
#return aver_t/len(label_list)
return aver_t/count,max
aver_t_0,max_0 = count_average_time(label_0)
aver_t_1,max_1 = count_average_time(label_1)
aver_t_2,max_2 = count_average_time(label_2)
aver_t_3,max_3 = count_average_time(label_3)
print("第1类运动学片段的平均时长：", aver_t_0)
print("第2类运动学片段的平均时长：", aver_t_1)
print("第3类运动学片段的平均时长：", aver_t_2)
print("第4类运动学片段的平均时长：", aver_t_3)
print("第1类运动学片段的最大时长：", max_0)
print("第2类运动学片段的最大时长：", max_1)
print("第3类运动学片段的最大时长：", max_2)
print("第4类运动学片段的最大时长：", max_3)
# print(type(centroids))
print("聚类中心为：",centroids)
# 算一算每个片段与中心点的距离平方和
def distance(label,centroids,new_feature,x):
result = []
for i in range(len(label)):
cost = 0
for j in range(centroids.shape[1]):
cost += ((new_feature[label[i]][j] - centroids[x][j]) * 10)**2
aaa = [label[i],cost] # 记录索引、代价值
result.append(aaa)
return result
result_0 = distance(label_0,centroids,new_feature,0)
result_1 = distance(label_1,centroids,new_feature,1)
result_2 = distance(label_2,centroids,new_feature,2)
result_3 = distance(label_3,centroids,new_feature,3)
# 根据代价值从小到大排序
def sort_self(result):
n = len(result)
for i in range(n-1):
for j in range(n - i -1):
if result[j][1] > result[j+1][1]:
temp = result[j]
result[j] = result[j+1]
result[j+1] = temp
return result
# 只保留误差最小的30个
sort_0 = np.array(sort_self(result_0))[0:40,:]
sort_1 = np.array(sort_self(result_1))[0:40,:]
sort_2 = np.array(sort_self(result_2))[0:40,:]
sort_3 = np.array(sort_self(result_3))[0:30,:]
# 满足在1200-1300秒
print("开始随机组合")
def select_fragment(feature,sort_0,sort_1,sort_2,sort_3):
result = []
for i in range(30):
for j in range(30):
for m in range(30):
for n in range(30):
all_time = feature[int(sort_0[i][0])][8] + feature[int(sort_1[j][0])][8] + feature[int(sort_2[m][0])][8] + feature[int(sort_3[n][0])][8]
if 1200 <=all_time<= 1300:
lalala = [i,j,m,n]
result.append(lalala)
return result
condition_curve = select_fragment(feature,sort_0,sort_1,sort_2,sort_3)
print(condition_curve)
ans1 = sort_0[1][0]
ans2 = sort_1[25][0]
ans3 = sort_2[2][0]
ans4 = sort_3[11][0]
print(ans1)
print(ans2)
print(ans3)
print(ans4)6. 抓取更具体地汽车工况的索引
# 抓取更具体地汽车工况的索引
info1 = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/info1.xlsx")
info1 = pd.DataFrame(info1)
info1 = info1.values.tolist()
info2 = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/info2.xlsx")
info2 = pd.DataFrame(info2)
info2 = info2.values.tolist()
info3 = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/info3.xlsx")
info3 = pd.DataFrame(info3)
info3 = info3.values.tolist()
info = info1 + info2 + info3
part1 = info[308]
part2 = info[201]
part3 = info[578]
part4 = info[255]
print("片段信息：")
print(part1)
print(part2)
print(part3)
print(part4)
print("**********************************")
# 提取片段的开始、怠速、停止信息
a1 = info1[308]
a2 = info1[201]
a3 = info2[126]
a4 = info1[255]
print(a1)
print(a2)
print(a3)
print(a4)
# [120134, 120211, 120541] 文件1
# [81149, 81254, 81601] 文件1
# [61554, 61586, 61684] 文件2
# [105081, 105215, 105303] 文件17. 绘制汽车工况运行曲线
这里我偷了个懒（其实也不算偷懒）：上一步得到4个运动学片段的索引后，我直接找到文件中对应索引的数据，将其粘贴到last1、last2、last3、last4这四个新建的excel里了。除了这里需要大家手动搞一下，别的都是直接粘进去，耍手机坐等运行，这感觉十分不错！
import pandas as pd
import matplotlib.pyplot as plt
excel = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/last1.xlsx")
data1 = pd.DataFrame(excel)
data_1 = data1.values
excel = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/last2.xlsx")
data2 = pd.DataFrame(excel)
data_2 = data2.values
excel = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/last3.xlsx")
data3 = pd.DataFrame(excel)
data_3 = data3.values
excel = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/last4.xlsx")
data4 = pd.DataFrame(excel)
data_4 = data4.values
m1 = (data_1[:,1] * 3.6).tolist()
m2 = (data_2[:,1] * 3.6).tolist()
m3 = (data_3[:,1] * 3.6).tolist()
m4 = (data_4[:,1] * 3.6).tolist()
# print(len(m1))
# print(len(m2))
# print(len(m3))
# print(len(m4))
m = m4 + m3 + m1+ m2
print(m[1214])
m.append(0)
# m = np.hstack((m1,m2,m3,m4))
print(len(m))
plt.plot(m)
plt.xlabel('time(s)')
plt.ylabel('speed(km/h)')
plt.show()7. 对构建的汽车工况运行曲线进行误差分析
import numpy as np
import pandas as pd
feature1 = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/feature1.xlsx")
feature1 = pd.DataFrame(feature1)
feature1 = feature1.values.tolist()
feature2 = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/feature2.xlsx")
feature2 = pd.DataFrame(feature2)
feature2 = feature2.values.tolist()
feature3 = pd.read_excel("C:/Users/Huo/Desktop/汽车工况/feature3.xlsx")
feature3 = pd.DataFrame(feature3)
feature3 = feature3.values.tolist()
feature = feature1 + feature2 + feature3 # 原始特征
feature = np.array(feature)
def evaluate(feature):
# 计算所有样本的特征值的均值
m = feature.shape[0]
n = feature.shape[1]
print(m)
print(n)
result = []
for i in range(n):
result.append(sum(feature[:,i])/m)
return result
result = evaluate(feature)
print(result)
# 工况曲线的特征值：308、201、578、255
target1 = feature[308,:]
target2 = feature[201,:]
target3 = feature[578,:]
target4 = feature[255,:]
lalala = []
for i in range(23):
a = (target1[i] + target2[i] + target3[i] + target4[i])/4
lalala.append(a)
print(lalala)
result = np.array(result)
lalala = np.array(lalala)
print("误差：",lalala - result)
error = (lalala - result)/result
error2 = abs(lalala - result)/result
print("误差率：",error)
print("绝对误差率：",error2)
382
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
