def reload_and_feature(picall, feature_type, average, nmel, order_frft, nmfcc,
saveprojectpath, savedata, savepic, savetestdata,
savepreprocess, savefeature, path, downsample_rate,
frame_time, frame_length, frame_overlap, test_rate):
'''
fe.stft, # 0
fe.zero_crossing_rate, # 1
fe.energy, # 2
fe.entropy_of_energy, # 3
fe.spectral_centroid_spread, # 4
fe.spectral_entropy, # 5
fe.spectral_flux, # 6
fe.spectral_rolloff, # 7
fe.bandwidth, # 8
fe.mfccs, # 9
fe.rms # 10
fe.stfrft # 11
fe.frft_mfcc # 12
'''
labelname = os.listdir(path) # 获取该数据集路径下的子文件名
if not os.path.exists(savefeature):
os.mkdir(savefeature) # 创建保存特征结果的文件
for i in range(len(labelname)):
if not os.path.exists(savefeature + '\\' + labelname[i]):
os.mkdir(savefeature + '\\' + labelname[i])
datafile = open(savepreprocess, encoding='utf-8') # 读取预处理结果
csv_reader = csv.reader(datafile) # 以这种方式读取文件得到的结果是一个迭代器
feature_set = [] # 当使用统计量作为特征时，将所有样本的特征缓存入该变量以进行归一化
for row in csv_reader: # row中的元素是字符类型
time_series = np.array(row[2:]).astype(
'float32') # row的前两个元素分别是标签和对应文件次序
#######################################################################
frames = preprocessing.frame(time_series, frame_length,
frame_overlap) # 分帧
f, t, stft = fe.stft(time_series,
pic=None,
fs=downsample_rate,
nperseg=frame_length,
noverlap=frame_length - frame_overlap,
nfft=8192,
boundary=None,
padded=False)
# if stft.shape[1] != frames.shape[1]: # 防止stft的时间个数和帧的个数不一样
# dim = min(stft.shape[1], frames.shape[1])
# stft = stft[:, 0:dim]
# frames = frames[:, 0:dim]
# Mel = lib.feature.melspectrogram(S=np.abs(stft), sr=downsample_rate, n_fft=2*(stft.shape[0]-1), n_mels=512)
feature_list = [] # 用于存放各种类型的特征，每个帧对应一个特征向量，其元素分别是每种类型的特征
if picall: # 用于绘图控制
pic = savepic + '\\' + row[0] + '_' + row[1]
else:
pic = None
for i in feature_type:
if i == 0:
feature0 = np.abs(stft)
feature_list.append(feature0)
elif i == 1:
feature1 = fe.zero_crossing_rate(frames, pic=pic)
feature_list.append(feature1)
elif i == 2:
feature2 = fe.energy(frames, pic=pic)
feature_list.append(feature2)
elif i == 3:
feature3 = fe.entropy_of_energy(frames, pic=pic)
feature_list.append(feature3)
elif i == 4:
feature4, feature41 = fe.spectral_centroid_spread(
stft, downsample_rate, pic=pic)
feature_list.append(feature4)
feature_list.append(feature41)
elif i == 5:
feature5 = fe.spectral_entropy(stft, pic=pic)
feature_list.append(feature5)
elif i == 6:
feature6 = fe.spectral_flux(stft, pic=pic)
feature_list.append(feature6)
elif i == 7:
feature7 = fe.spectral_rolloff(stft,
0.85,
downsample_rate,
pic=pic)
feature_list.append(feature7)
elif i == 8:
feature8 = fe.bandwidth(stft, f, pic=pic)
feature_list.append(feature8)
elif i == 9:
feature9 = fe.mfccs(
X=stft,
fs=downsample_rate,
# nfft=2*(stft.shape[0]-1),
nfft=8192,
n_mels=nmel,
n_mfcc=nmfcc,
pic=pic)
feature_list.append(feature9)
elif i == 10:
feature10 = fe.rms(stft, pic=pic)
feature_list.append(feature10)
elif i == 11:
feature11 = fe.stfrft(frames,
p=order_frft[int(row[0])],
pic=pic)
feature_list.append(feature11)
elif i == 12:
tmp = fe.stfrft(frames, p=order_frft[int(row[0])])
feature12 = fe.frft_MFCC(S=tmp,
fs=downsample_rate,
n_mfcc=nmfcc,
n_mels=nmel,
pic=pic)
feature_list.append(feature12)
elif i == 13:
feature13, feature13_ = fe.fundalmental_freq(
frames=frames, fs=downsample_rate, pic=pic)
feature_list.append(feature13)
elif i == 14:
feature14 = fe.chroma_stft(S=stft,
n_chroma=12,
A440=440.0,
ctroct=5.0,
octwidth=2,
base_c=True,
norm=2)
feature_list.append(feature14)
elif i == 15:
feature15 = fe.log_attack_time(x=time_series,
lower_ratio=0.02,
upper_ratio=0.99,
fs=downsample_rate,
n=frames.shape[1])
feature_list.append(feature15)
elif i == 16:
feature16 = fe.temoporal_centroid(S=stft,
hop_length=frame_overlap,
fs=downsample_rate)
feature_list.append(feature16)
elif i == 17:
# harm_freq, harm_mag = fe.harmonics(nfft=8192, nht=0.15, f=f, S=stft, fs=downsample_rate, fmin=50, fmax=500, threshold=0.2)
# hsc = fe.harmonic_spectral_centroid(harm_freq, harm_mag)
# hsd = fe.harmonic_spectral_deviation(harm_mag)
# hss = fe.harmonic_spectral_spread(hsc, harm_freq, harm_mag)
# hsv = fe.harmonic_spectral_variation(harm_mag)
# feature17 = np.concatenate([hsc, hsd, hss, hsv], axis=0)
# feature_list.append(feature17)
harm_freq, harm_mag = timbral.harmonics(frames=frames,
fs=downsample_rate,
S=stft,
f=f,
nfft=8192,
fmin=50,
fmax=500,
nht=0.15)
hsc = timbral.harmonic_spectral_centroid(harm_freq, harm_mag)
hsd = timbral.harmonic_spectral_deviation(harm_mag)
hss = timbral.harmonic_spectral_spread(hsc, harm_freq,
harm_mag)
hsv = timbral.harmonic_spectral_variation(harm_mag)
feature17 = np.concatenate([hsc, hsd, hss, hsv], axis=0)
feature_list.append(feature17)
elif i == 18:
feature18 = fe.pitches_mag_CDSV(f=f,
S=stft,
fs=downsample_rate,
fmin=50,
fmax=downsample_rate / 2,
threshold=0.2)
feature_list.append(feature18)
elif i == 19:
feature19 = fe.delta_features(feature9, order=1)
feature_list.append(feature19)
elif i == 20:
feature20 = fe.delta_features(feature9, order=2)
feature_list.append(feature20)
features = np.concatenate([j for j in feature_list],
axis=0) # 我很欣赏这一句代码，将各种特征拼在一起
long = list(range(features.shape[1])) # 删除含有nan的帧
for t in long[::-1]:
if np.isnan(features[:, t]).any():
features = np.delete(features, t, 1)
if average: # 使用统计量作为特征
mean = np.mean(features, axis=1).reshape(
1, features.shape[0]) # 原来的特征向量是列向量，这里转成行向量
var = np.var(features, axis=1).reshape(1, features.shape[0])
# std = np.std(features, axis=1).reshape(1, features.shape[0])
# ske = np.zeros((1, features.shape[0]))
# kur = np.zeros((1, features.shape[0]))
# for n in range(features.shape[0]):
# ske[0, i] = sts.skewness(features[i, :])
# kur[0, i] = sts.kurtosis(features[i, :])
features = np.concatenate([
mean, var,
np.array([int(row[0]), int(row[1])]).reshape(1, 2)
],
axis=1) # 使用统计平均代替每个帧的特征
feature_set.append(features)
else:
scale = StandardScaler().fit(features)
features = scale.transform(features) # 进行归一化
csv_path = savefeature + '\\' + labelname[int(
row[0])] + '\\' + row[0] + '_' + row[1] + '.csv'
with open(csv_path, 'w', encoding='utf-8', newline='') as csvfile:
csv_writer = csv.writer(csvfile)
buffer = np.concatenate([
features.T,
int(row[0]) * np.ones((features.shape[1], 1)),
int(row[1]) * np.ones((features.shape[1], 1))
],
axis=1)
csv_writer.writerows(buffer)
print('featuring:', row[0], row[1])
datafile.close() # 关闭文件，避免不必要的错误
if average: # 使用统计量作为特征
features = np.concatenate([k for k in feature_set],
axis=0) # 我很欣赏这一句代码 行表示样本数，列表示特征数
tmp = features[:, -2:] # 防止归一化的时候把标签也归一化
features = features[:, 0:-2]
scale = StandardScaler().fit(features)
features = scale.transform(features) # 进行归一化
features = np.concatenate([features, tmp], axis=1) # 把之前分开的特征和标签拼在一起
for k in range(features.shape[0]):
csv_path = savefeature + '\\' + labelname[int(features[k, -2])] + \
'\\' + str(int(features[k, -2])) + '_' + str(int(features[k, -1])) + '.csv'
with open(csv_path, 'w', encoding='utf-8', newline='') as csvfile:
csv_writer = csv.writer(csvfile) # 每个音频文件只有一个特征向量，并存入一个csv文件
csv_writer.writerow(features[k, :]) # 注意这里写入的是一行，要用writerow
def start_predict_offline():
if file_text.get("1.0", END) == []:
messagebox.showerror("Error", "Please select test file!")
return
else:
test_file = file_text.get("1.0", END)
test_file = test_file.split("\n")[0]
if model_text.get("1.0", END) == []:
messagebox.showerror("Error", "Please select test model!")
return
else:
offline_model = model_text.get("1.0", END)
offline_model = offline_model.split("\n")[0]
test_config = pd.read_csv(offline_model.split(".")[0] + ".txt", sep=" ")
test_config.columns = ['param', 'value']
test_config = pd.DataFrame(data=[test_config['value'].values], columns=test_config['param'].values)
if test_config['filter'].values[0] == '1':
filter_order = int(test_config['order'].values[0])
filter_fc = test_config['fc'].values[0]
filter_type = test_config['type'].values[0]
filter_fs = int(test_config['fs'].values[0])
if filter_type == "bandpass" or filter_type == "bandstop":
fc = filter_fc.split("[")[1].split("]")[0].split(",")
filter_fc = [int(fc[0]), int(fc[1])]
else:
filter_fc = int(filter_fc)
if test_config['smooth'].values[0] == '1':
smooth_wl = int(test_config['windowlength'].values[0])
smooth_po = int(test_config['polyorder'].values[0])
smooth_mode = test_config['mode'].values[0]
if test_config['eliminate'].values[0] == '1':
elim_thre = int(test_config['threshold'].values[0])
elim_ws = int(test_config['windowsize'].values[0])
elim_base = int(test_config['baseon'].values[0])
if test_config['energy'].values[0] == '1':
eng_bs = int(test_config['bandsize'].values[0])
eng_odr = int(test_config['odr'].values[0])
seg_size = int(test_config['segsize'].values[0])
files = pd.read_csv(test_file)
final_features = []
labels = []
for idx, row in files.iterrows():
name = row['file']
dir = row['dir']
label = row['label']
header = row['header']
raw_data = pd.read_csv(dir + '\\' + '\\' + name, header=header, delimiter=';')
ax = raw_data['ax']
ay = raw_data['ay']
az = raw_data['az']
data = np.array([ax, ay, az]).T
if test_config['filter'].values[0] == '1':
data = data_preprocessing.filter(data, filter_order, filter_fc, filter_type, filter_fs)
if test_config['smooth'].values[0] == '1':
smoothed_data = data_preprocessing.smooth(data, smooth_wl, smooth_po, smooth_mode)
if test_config['eliminate'].values[0] == '1':
new_smoothed_data, data = data_preprocessing.eliminate_abnormal_value(smoothed_data, data, elim_ws, elim_thre, elim_base)
else:
data = smoothed_data
num = int(test_config['mean'].values[0]) + int(test_config['std'].values[0]) + int(test_config['min'].values[0]) + int(test_config['max'].values[0]) + int(test_config['rms'].values[0])
for col in range(3):
feature = np.empty([int(len(data[:, col])/seg_size), num])
new_feature = []
for i in range(int(len(data[:, col])/seg_size)):
window = data[i*seg_size:(i+1)*seg_size, col]
k = 0
if int(test_config['mean'].values[0]):
feature[i, k] = feature_extraction.mean(window)
k += 1;
if int(test_config['std'].values[0]):
feature[i, k] = feature_extraction.std(window)
k += 1;
if int(test_config['min'].values[0]):
feature[i, k] = feature_extraction.getmin(window)
k += 1;
if int(test_config['max'].values[0]):
feature[i, k] = feature_extraction.getmax(window)
k += 1;
if int(test_config['rms'].values[0]):
feature[i, k] = feature_extraction.rms(window)
k += 1;
if int(test_config['energy'].values[0]):
energy_vector = feature_extraction.energy_for_each_freq_band(window, eng_odr, eng_bs)
temp = np.append(feature[i, :], energy_vector)
new_feature.append(temp)
else:
new_feature.append(feature[i, :])
new_feature = np.array(new_feature)
#print("new_feature: ", new_feature.shape)
if col == 0:
ex_feature = new_feature
else:
ex_feature = np.append(ex_feature, new_feature, axis=1)
#print("ex_feature: ", ex_feature.shape)
num_features = ex_feature.shape[1] // 3
num_axis = int(test_config['X'].values[0]) +int(test_config['Y'].values[0]) + int(test_config['Z'].values[0])
trn_feature = np.empty([ex_feature.shape[0], num_axis*num_features])
k = 0
if int(test_config['X'].values[0]) == 1:
trn_feature[:, k*num_features:(k+1)*num_features] = ex_feature[:, 0:num_features]
k += 1
if int(test_config['Y'].values[0]) == 1:
trn_feature[:, k*num_features:(k+1)*num_features] = ex_feature[:, num_features:num_features*2]
k += 1
if int(test_config['Z'].values[0]) == 1:
trn_feature[:, k*num_features:(k+1)*num_features] = ex_feature[:, num_features*2:num_features*3]
k += 1;
final_features.extend(trn_feature)
for i in range(len(trn_feature)):
labels.append(label)
final_features = np.array(final_features)
labels = np.array(labels)
test_model = pickle.load(open(offline_model, 'rb'))
pred = test_model.predict(final_features)
acc_tst = accuracy_score(labels, pred)
lb_acc_tst = Label(offline, text=acc_tst, font=("Helvetica", "12", "bold italic"))
lb_acc_tst.place(relx=0.6, rely=0.28)
def startTrain():
model = en_model.get()
if model == "":
messagebox.showerror("Error", "Please select the training model!")
return
trn_ratio = var_ratio.get()
file_idx = trn_files.curselection()
filename = ""
if file_idx == ():
messagebox.showerror("Error", "Please select the training files!")
return
else:
filename = trn_files.get(file_idx)
# Detect if a filter is used and pass all filter parameter to the function
if var_filter.get() == 1:
if en_order.get() != "" and en_fc.get() != "" and en_type.get() != "" and en_fs.get() != "":
filter_order = int(en_order.get())
filter_fc = en_fc.get()
filter_type = en_type.get()
filter_fs = int(en_fs.get())
if filter_type == "bandpass" or filter_type == "bandstop":
if filter_fc.split("[")[0] != "":
messagebox.showerror("Error", "The form of fc should be like \'[fc1, fc2]\'!")
return
fc = filter_fc.split("[")[1].split("]")[0].split(",")
filter_fc = [int(fc[0]), int(fc[1])]
else:
filter_fc = int(filter_fc)
else:
messagebox.showerror("Error", "Please set all the parameters of Filter!")
return
# Detect if smoothing is used and pass all filter parameter to the function
if var_smooth.get() == 1:
if en_wl.get() != "" and en_po.get() != "" and en_mode.get() != "":
smooth_wl = int(en_wl.get())
smooth_po = int(en_po.get())
smooth_mode = en_mode.get()
if smooth_wl % 2 == 0:
messagebox.showerror("Error", "The window length should be odd!")
return
else:
messagebox.showerror("Error", "Please set all the parameters of Smoothing!")
return
if var_elim.get() == 1:
if en_thre.get() != "" and en_win.get() != "":
elim_thre = int(en_thre.get())
elim_ws = int(en_win.get())
else:
messagebox.showerror("Error", "Please set all the parameters of Eliminate Abnormal Data!")
return
if var_energy.get() == 1:
if en_bs.get() != "" and en_odr.get() != "":
eng_bs = int(en_bs.get())
eng_odr = int(en_odr.get())
else:
messagebox.showerror("Error", "Please set all the parameters of Energy!")
return
if en_ws.get() != "":
seg_size = int(en_ws.get())
else:
messagebox.showerror("Error", "Please set the segment size!")
return
if var_accel_x.get() == 0 and var_accel_y.get() == 0 and var_accel_z.get() == 0:
messagebox.showerror("Error", "Please select at least one axis!")
return
if (var_base.get() == 1 and var_accel_x.get() == 0) or (var_base.get() == 2 and var_accel_y.get() == 0) or (var_base.get() == 3 and var_accel_z.get() == 0):
messagebox.showerror("Error", "Please select the axis that is select in Axis Selection!")
return
if var_mean.get() + var_std.get() + var_min.get() + var_max.get() + var_rms.get() + var_energy.get() == 0:
messagebox.showerror("Error", "Please select at least one feature!")
return
save_model = filedialog.asksaveasfilename(initialdir = "/", title = "Save Model", filetypes = (("sav files","*.sav"), ("all files", "*.*")))
if save_model == "":
return
if len(save_model.split(".")) == 1:
save_model = save_model + '.sav'
### write model configuration
parts = save_model.split('/')
directory = '/'.join(parts[0:len(parts)-1])
txtName = parts[len(parts)-1].split('.')[0] + '.txt'
pb['value'] = 10
trn.update_idletasks()
time.sleep(0.5)
f = open(directory + '/' + txtName, "w+")
f.write("param value\n")
if var_filter.get() == 1:
f.write("filter 1\n")
f.write("order %d\n" %filter_order)
f.write("fc %d\n" %filter_fc)
f.write("type " + filter_type + "\n")
f.write("fs %d\n" %filter_fs)
else:
f.write("filter 0\n")
if var_smooth.get() == 1:
f.write("smooth 1\n")
f.write("windowlength %d\n" %smooth_wl)
f.write("polyorder %d\n" %smooth_po)
f.write("mode " + smooth_mode + "\n")
else:
f.write("smooth 0\n")
if var_elim.get() == 1:
f.write("eliminate 1\n")
f.write("threshold %d\n" %elim_thre)
f.write("windowsize %d\n" %elim_ws)
f.write("baseon %d\n" %var_base.get())
else:
f.write("eliminate 0\n")
f.write("X %d\n" %var_accel_x.get())
f.write("Y %d\n" %var_accel_y.get())
f.write("Z %d\n" %var_accel_z.get())
f.write("mean %d\n" %var_mean.get())
f.write("std %d\n" %var_std.get())
f.write("min %d\n" %var_min.get())
f.write("max %d\n" %var_max.get())
f.write("rms %d\n" %var_rms.get())
f.write("energy %d\n" %var_energy.get())
if var_energy.get() == 1:
f.write("bandsize %d\n" %eng_bs)
f.write("odr %d\n" %eng_odr)
f.write("segsize %d\n" %seg_size)
f.close()
files = pd.read_csv(filename)
final_features = []
labels = []
num_rows = files.shape[0]
for idx, row in files.iterrows():
name = row['file']
dir = row['dir']
label = row['label']
header = row['header']
raw_data = pd.read_csv(dir + '\\' + '\\' + name, header=header, delimiter=';')
ax = raw_data['ax']
ay = raw_data['ay']
az = raw_data['az']
data = np.array([ax, ay, az]).T
if var_filter.get() == 1:
data = data_preprocessing.filter(data, filter_order, filter_fc, filter_type, filter_fs)
if var_smooth.get() == 1:
smoothed_data = data_preprocessing.smooth(data, smooth_wl, smooth_po, smooth_mode)
if var_elim.get() == 1:
new_smoothed_data, data = data_preprocessing.eliminate_abnormal_value(smoothed_data, data, elim_ws, elim_thre, var_base.get())
else:
data = smoothed_data
num = var_mean.get() + var_std.get() + var_min.get() + var_max.get() + var_rms.get()
# extract features from x y z axis respectively
for col in range(3):
# number of feature column is determined by selected features
feature = np.empty([int(len(data[:, col])/seg_size), num])
new_feature = []
for i in range(int(len(data[:, col])/seg_size)):
# window is one group of data whose size is seg_size
window = data[i*seg_size:(i+1)*seg_size, col]
# keep track of features
k = 0
if var_mean.get():
feature[i, k] = feature_extraction.mean(window)
k += 1;
if var_std.get():
feature[i, k] = feature_extraction.std(window)
k += 1;
if var_min.get():
feature[i, k] = feature_extraction.getmin(window)
k += 1;
if var_max.get():
feature[i, k] = feature_extraction.getmax(window)
k += 1;
if var_rms.get():
feature[i, k] = feature_extraction.rms(window)
k += 1;
if var_energy.get():
energy_vector = feature_extraction.energy_for_each_freq_band(window, eng_odr, eng_bs)
temp = np.append(feature[i, :], energy_vector)
new_feature.append(temp)
else:
new_feature.append(feature[i, :])
# features on only one axis
new_feature = np.array(new_feature)
#print("new_feature: ", new_feature.shape)
# save features of all axes to ex_feature
if col == 0:
ex_feature = new_feature
else:
ex_feature = np.append(ex_feature, new_feature, axis=1)
# print("ex_feature: ", ex_feature.shape)
num_features = ex_feature.shape[1] // 3
num_axis = var_accel_x.get() + var_accel_y.get() + var_accel_z.get()
trn_feature = np.empty([ex_feature.shape[0], num_axis*num_features])
k = 0
if var_accel_x.get() == 1:
trn_feature[:, k*num_features:(k+1)*num_features] = ex_feature[:, 0:num_features]
k += 1
if var_accel_y.get() == 1:
trn_feature[:, k*num_features:(k+1)*num_features] = ex_feature[:, num_features:num_features*2]
k += 1
if var_accel_z.get() == 1:
trn_feature[:, k*num_features:(k+1)*num_features] = ex_feature[:, num_features*2:num_features*3]
k += 1;
final_features.extend(trn_feature)
for i in range(len(trn_feature)):
labels.append(label)
pb['value'] = 10 + (idx+1)/num_rows * 80
trn.update_idletasks()
time.sleep(0.5)
final_features = np.array(final_features)
labels = np.array(labels)
#print(final_features.shape)
#print(labels.shape)
#np.savetxt('fea', final_features, delimiter=',')
#print(labels)
# f = open(directory + '/' + txtName, "w+")
# f.write("param value\n")
if res_text.get('1.0', END) != []:
res_text.delete('1.0', END)
if model == "Random Forest":
acc_trn, acc_tst, acc_oob = train.RandomForest(final_features, labels, trn_ratio, save_model)
res_text.insert(END, "Training accuracy: " + str(acc_trn) + '\n')
res_text.insert(END, '\n' + "Testing accuracy: " + str(acc_tst) + '\n')
res_text.insert(END, '\n' + "Out of bag accuracy: " + str(acc_oob) + '\n')
if model == "SVM":
acc_trn, acc_tst = train.SVM(final_features, labels, trn_ratio, save_model)
res_text.insert(END, "Training accuracy: " + str(acc_trn) + '\n')
res_text.insert(END, '\n' + "Test accuracy: " + str(acc_tst) + '\n')
pb['value'] = 100
trn.update_idletasks()
time.sleep(0.5)
def extractAndSave():
file_idx = trn_files.curselection()
filename = ""
if file_idx == ():
messagebox.showerror("Error", "Please select the training files!")
return
else:
filename = trn_files.get(file_idx)
if var_filter.get() == 1:
if en_order.get() != "" and en_fc.get() != "" and en_type.get() != "" and en_fs.get() != "":
filter_order = int(en_order.get())
filter_fc = en_fc.get()
filter_type = en_type.get()
filter_fs = int(en_fs.get())
if filter_type == "bandpass" or filter_type == "bandstop":
if filter_fc.split("[")[0] != "":
messagebox.showerror("Error", "The form of fc should be like \'[fc1, fc2]\'!")
return
fc = filter_fc.split("[")[1].split("]")[0].split(",")
filter_fc = [int(fc[0]), int(fc[1])]
else:
filter_fc = int(filter_fc)
else:
messagebox.showerror("Error", "Please set all the parameters of Filter!")
return
if var_smooth.get() == 1:
if en_wl.get() != "" and en_po.get() != "" and en_mode.get() != "":
smooth_wl = int(en_wl.get())
smooth_po = int(en_po.get())
smooth_mode = en_mode.get()
if smooth_wl % 2 == 0:
messagebox.showerror("Error", "The window length should be odd!")
return
else:
messagebox.showerror("Error", "Please set all the parameters of Smoothing!")
return
if var_elim.get() == 1:
if en_thre.get() != "" and en_win.get() != "":
elim_thre = int(en_thre.get())
elim_ws = int(en_win.get())
else:
messagebox.showerror("Error", "Please set all the parameters of Eliminate Abnormal Data!")
return
if var_energy.get() == 1:
if en_bs.get() != "" and en_odr.get() != "":
eng_bs = int(en_bs.get())
eng_odr = int(en_odr.get())
else:
messagebox.showerror("Error", "Please set all the parameters of Energy!")
return
if en_ws.get() != "":
seg_size = int(en_ws.get())
else:
messagebox.showerror("Error", "Please set the segment size!")
return
if var_accel_x.get() == 0 and var_accel_y.get() == 0 and var_accel_z.get() == 0:
messagebox.showerror("Error", "Please select at least one axis!")
return
if (var_base.get() == 1 and var_accel_x.get() == 0) or (var_base.get() == 2 and var_accel_y.get() == 0) or (var_base.get() == 3 and var_accel_z.get() == 0):
messagebox.showerror("Error", "Please select the axis that is select in Axis Selection!")
return
if var_mean.get() + var_std.get() + var_min.get() + var_max.get() + var_rms.get() + var_energy.get() == 0:
messagebox.showerror("Error", "Please select at least one feature!")
return
save_features = filedialog.asksaveasfilename(initialdir = "/", title = "Save file", filetypes = (("numpy files","*.npy"), ("all files", "*.*")))
if save_features == "":
return
files = pd.read_csv(filename)
final_features = []
labels = []
for idx, row in files.iterrows():
name = row['file']
dir = row['dir']
label = row['label']
header = row['header']
raw_data = pd.read_csv(dir + '\\' + '\\' + name, header=header, delimiter=';')
ax = raw_data['ax']
ay = raw_data['ay']
az = raw_data['az']
data = np.array([ax, ay, az]).T
if var_filter.get() == 1:
data = data_preprocessing.filter(data, filter_order, filter_fc, filter_type, filter_fs)
if var_smooth.get() == 1:
smoothed_data = data_preprocessing.smooth(data, smooth_wl, smooth_po, smooth_mode)
if var_elim.get() == 1:
new_smoothed_data, data = data_preprocessing.eliminate_abnormal_value(smoothed_data, data, elim_ws, elim_thre, var_base.get())
else:
data = smoothed_data
num = var_mean.get() + var_std.get() + var_min.get() + var_max.get() + var_rms.get()
for col in range(3):
feature = np.empty([int(len(data[:, col])/seg_size), num])
new_feature = []
for i in range(int(len(data[:, col])/seg_size)):
window = data[i*seg_size:(i+1)*seg_size, col]
k = 0
if var_mean.get():
feature[i, k] = feature_extraction.mean(window)
k += 1;
if var_std.get():
feature[i, k] = feature_extraction.std(window)
k += 1;
if var_min.get():
feature[i, k] = feature_extraction.getmin(window)
k += 1;
if var_max.get():
feature[i, k] = feature_extraction.getmax(window)
k += 1;
if var_rms.get():
feature[i, k] = feature_extraction.rms(window)
k += 1;
if var_energy.get():
energy_vector = feature_extraction.energy_for_each_freq_band(window, eng_odr, eng_bs)
temp = np.append(feature[i, :], energy_vector)
new_feature.append(temp)
else:
new_feature.append(feature[i, :])
new_feature = np.array(new_feature)
#print("new_feature: ", new_feature.shape)
if col == 0:
ex_feature = new_feature
else:
ex_feature = np.append(ex_feature, new_feature, axis=1)
#print("ex_feature: ", ex_feature.shape)
num_features = ex_feature.shape[1] // 3
num_axis = var_accel_x.get() + var_accel_y.get() + var_accel_z.get()
trn_feature = np.empty([ex_feature.shape[0], num_axis*num_features])
k = 0
if var_accel_x.get() == 1:
trn_feature[:, k*num_features:(k+1)*num_features] = ex_feature[:, 0:num_features]
k += 1
if var_accel_y.get() == 1:
trn_feature[:, k*num_features:(k+1)*num_features] = ex_feature[:, num_features:num_features*2]
k += 1
if var_accel_z.get() == 1:
trn_feature[:, k*num_features:(k+1)*num_features] = ex_feature[:, num_features*2:num_features*3]
k += 1;
final_features.extend(trn_feature)
for i in range(len(trn_feature)):
labels.append(label)
final_features = np.array(final_features)
labels = np.array(labels)
save_labels = save_features
save_features = save_features.split(".")[0] + "_features.npy"
save_labels = save_labels.split(".")[0] + "_labels.npy"
np.save(save_features, final_features)
np.save(save_labels, labels)
messagebox.showinfo("Congratulations", "Features and labels are successfully saved!")
def start_predict_online(data_online):
global online_window
global online_window_size
global flag
if model_text2.get("1.0", END) == []:
messagebox.showerror("Error", "Please select test model!")
return
else:
online_model = model_text2.get("1.0", END)
online_model = online_model.split("\n")[0]
if res_text2.get("1.0", END) == []:
res_text2.delete("1.0", END)
test_config = pd.read_csv(online_model.split(".")[0] + ".txt", sep=" ")
test_config.columns = ['param', 'value']
test_config = pd.DataFrame(data=[test_config['value'].values], columns=test_config['param'].values)
if test_config['filter'].values[0] == '1':
filter_order = int(test_config['order'].values[0])
filter_fc = test_config['fc'].values[0]
filter_type = test_config['type'].values[0]
filter_fs = int(test_config['fs'].values[0])
if filter_type == "bandpass" or filter_type == "bandstop":
fc = filter_fc.split("[")[1].split("]")[0].split(",")
filter_fc = [int(fc[0]), int(fc[1])]
else:
filter_fc = int(filter_fc)
if test_config['smooth'].values[0] == '1':
smooth_wl = int(test_config['windowlength'].values[0])
smooth_po = int(test_config['polyorder'].values[0])
smooth_mode = test_config['mode'].values[0]
if test_config['eliminate'].values[0] == '1':
elim_thre = int(test_config['threshold'].values[0])
elim_ws = int(test_config['windowsize'].values[0])
elim_base = int(test_config['baseon'].values[0])
if test_config['energy'].values[0] == '1':
eng_bs = int(test_config['bandsize'].values[0])
eng_odr = int(test_config['odr'].values[0])
seg_size = int(test_config['segsize'].values[0])
#print(flag)
if flag == False:
online_window = []
online_window_size = seg_size * 1.5
flag = True
if online_window_size == 0:
# test_config = pd.read_csv(online_model.split(".")[0] + ".txt", sep=" ")
# test_config.columns = ['param', 'value']
# test_config = pd.DataFrame(data=[test_config['value'].values], columns=test_config['param'].values)
# if test_config['filter'].values[0] == '1':
# filter_order = int(test_config['order'].values[0])
# filter_fc = test_config['fc'].values[0]
# filter_type = test_config['type'].values[0]
# filter_fs = int(test_config['fs'].values[0])
# if filter_type == "bandpass" or filter_type == "bandstop":
# fc = filter_fc.split("[")[1].split("]")[0].split(",")
# filter_fc = [int(fc[0]), int(fc[1])]
# else:
# filter_fc = int(filter_fc)
# if test_config['smooth'].values[0] == '1':
# smooth_wl = int(test_config['windowlength'].values[0])
# smooth_po = int(test_config['polyorder'].values[0])
# smooth_mode = test_config['mode'].values[0]
# if test_config['eliminate'].values[0] == '1':
# elim_thre = int(test_config['threshold'].values[0])
# elim_ws = int(test_config['windowsize'].values[0])
# elim_base = int(test_config['baseon'].values[0])
# if test_config['energy'].values[0] == '1':
# eng_bs = int(test_config['bandsize'].values[0])
# eng_odr = int(test_config['odr'].values[0])
# seg_size = int(test_config['segsize'].values[0])
data = np.array(online_window)
#print(data)
#final_features = []
if test_config['filter'].values[0] == '1':
data = data_preprocessing.filter(data, filter_order, filter_fc, filter_type, filter_fs)
if test_config['smooth'].values[0] == '1':
smoothed_data = data_preprocessing.smooth(data, smooth_wl, smooth_po, smooth_mode)
if test_config['eliminate'].values[0] == '1':
new_smoothed_data, data = data_preprocessing.eliminate_abnormal_value(smoothed_data, data, elim_ws, elim_thre, elim_base)
if data.shape[0] >= seg_size:
num = int(test_config['mean'].values[0]) + int(test_config['std'].values[0]) + int(test_config['min'].values[0]) + int(test_config['max'].values[0]) + int(test_config['rms'].values[0])
for col in range(3):
feature = np.empty([int(len(data[:, col])/seg_size), num])
new_feature = []
for i in range(int(len(data[:, col])/seg_size)):
window = data[i*seg_size:(i+1)*seg_size, col]
k = 0
if int(test_config['mean'].values[0]):
feature[i, k] = feature_extraction.mean(window)
k += 1;
if int(test_config['std'].values[0]):
feature[i, k] = feature_extraction.std(window)
k += 1;
if int(test_config['min'].values[0]):
feature[i, k] = feature_extraction.getmin(window)
k += 1;
if int(test_config['max'].values[0]):
feature[i, k] = feature_extraction.getmax(window)
k += 1;
if int(test_config['rms'].values[0]):
feature[i, k] = feature_extraction.rms(window)
k += 1;
if int(test_config['energy'].values[0]):
energy_vector = feature_extraction.energy_for_each_freq_band(window, eng_odr, eng_bs)
temp = np.append(feature[i, :], energy_vector)
new_feature.append(temp)
else:
new_feature.append(feature[i, :])
new_feature = np.array(new_feature)
#print("new_feature: ", new_feature.shape)
if col == 0:
ex_feature = new_feature
else:
ex_feature = np.append(ex_feature, new_feature, axis=1)
#print("ex_feature: ", ex_feature.shape)
num_features = ex_feature.shape[1] // 3
num_axis = int(test_config['X'].values[0]) +int(test_config['Y'].values[0]) + int(test_config['Z'].values[0])
trn_feature = np.empty([ex_feature.shape[0], num_axis*num_features])
k = 0
if int(test_config['X'].values[0]) == 1:
trn_feature[:, k*num_features:(k+1)*num_features] = ex_feature[:, 0:num_features]
k += 1
if int(test_config['Y'].values[0]) == 1:
trn_feature[:, k*num_features:(k+1)*num_features] = ex_feature[:, num_features:num_features*2]
k += 1
if int(test_config['Z'].values[0]) == 1:
trn_feature[:, k*num_features:(k+1)*num_features] = ex_feature[:, num_features*2:num_features*3]
k += 1;
test_model = pickle.load(open(online_model, 'rb'))
predict_output = test_model.predict(trn_feature)
print(predict_output[0])
#res_text2.insert(END, predict_output[0])
#online_window = []
#online_window_size = 200
flag = False
else:
online_window.append(data_online)
online_window_size -= 1
noverlap=frame_length - frame_lap,
nfft=8192,
boundary=None,
padded=False)
pic = None
feature1 = fe.zero_crossing_rate(frames, pic=pic)
feature2 = fe.energy(frames, pic=pic)
feature3 = fe.entropy_of_energy(frames, pic=pic)
feature4, feature41 = fe.spectral_centroid_spread(stft, fs, pic=pic)
feature5 = fe.spectral_entropy(stft, pic=pic)
feature6 = fe.spectral_flux(stft, pic=pic)
feature7 = fe.spectral_rolloff(stft, 0.85, fs, pic=pic)
feature8 = fe.bandwidth(stft, f, pic=pic)
feature9 = fe.mfccs(X=stft, fs=fs, nfft=8192, n_mels=128, n_mfcc=13, pic=pic)
feature10 = fe.rms(stft, pic=pic)
feature11 = fe.stfrft(frames, p=0.95, pic=pic)
tmp = fe.stfrft(frames, p=0.95)
feature12 = fe.frft_MFCC(S=tmp, fs=fs, n_mfcc=13, n_mels=128, pic=pic)
feature19 = fe.delta_features(feature9, order=1)
feature20 = fe.delta_features(feature9, order=2)
plt.figure()
ax1 = plt.subplot(411)
plt.plot(data)
ax1.set_ylabel('original signal')
ax2 = plt.subplot(412)
plt.plot(feature1[0, :])
# ax2.set_xlabel('frame time')
ax2.set_ylabel('zero crossing rate')
ax3 = plt.subplot(413)