python实现信号时域统计特征提取代码

2023-07-31 14:27:05 74

1.实验数据需求

为了对采集的压力实验数据做特征工程，需要对信号进行时域的统计特征提取，包含了均值、均方根、偏度、峭度、波形因子、波峰因子、脉冲因子、峭度因子等，现用python对其进行实现。

2.python实现

其中的输入参数含义：

①data:实验数据的DataFrame

②p1:所截取实验信号的起始采样点位置

③p2:所截取实验信号的终止采样点位置

frompandasimportSeries
importmath
pstf_list=[]
defpsfeatureTime(data,p1,p2):
#均值
df_mean=data[p1:p2].mean()
#方差
df_var=data[p1:p2].var()
#标准差
df_std=data[p1:p2].std()
#均方根
df_rms=math.sqrt(pow(df_mean,2)+pow(df_std,2))
#偏度
df_skew=data[p1:p2].skew()
#峭度
df_kurt=data[p1:p2].kurt()
sum=0
foriinrange(p1,p2):
sum+=math.sqrt(abs(data[i]))
#波形因子
df_boxing=df_rms/(abs(data[p1:p2]).mean())
#峰值因子
df_fengzhi=(max(data[p1:p2]))/df_rms
#脉冲因子
df_maichong=(max(data[p1:p2]))/(abs(data[p1:p2]).mean())
#裕度因子
df_yudu=(max(data[p1:p2]))/pow((sum/(p2-p1)),2)
featuretime_list=[df_mean,df_rms,df_skew,df_kurt,df_boxing,df_fengzhi,df_maichong,df_yudu]
returnfeaturetime_list

3.结果与说明

补充拓展：python数据结构与算法--回溯算法详解

回溯算法：一种优先搜索算法（试探法）；按优条件向前搜索，以达目标；当试探到某步，发现原来选择并不好（走不通），就退回重新选择。

回溯算法的一般步骤：1：定义问题的解空间（搜索中动态生成）；2：确定易搜索的解空间结构（一般为树形结构或图）；3：以深度优先的方式搜索解空间，搜索中用剪枝函数避免无效搜索。

剪枝函数：1：用约束函数在扩展节点处减去不满足约束条件的子树；2：用限界函数减去不能得到最优解的子树。

回溯法：实战

1：电话号码的字母组合

方法：回溯（适用于组合问题）

classSolution:
defletterCombination(self,digits):

phone={'2':['a','b','c'],
'3':['d','e','f'],
'4':['g','h','i'],

'5':['j','k','l'],
'6':['m','n','o'],
'7':['p','q','r','s'],
'8':['t','u','v'],
'9':['w','x','y','z']}

res=[]#存放组合结果
defbacktrack(combination,next_digits):#回溯函数
#combination目前已经产生的组合，next_digits:输入的下一个字符
iflen(next_digits)==0:#递归出口
res.append(combination)
else:
foriinphone[next_digits[0]]:
backtrack(combination+i,next_digits[1:])#递归实现回溯
ifdigits:
backtrack('',digits)#初始化
returnres

2：全排列

输入:[1,2,3]

输出:

[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

classSolution:
defpermute(self,nums):

res=[]#存放组合结果
size=len(nums)

defbacktrack(combination,nums):
#combination目前已经产生的组合，nums为剩下的数组
#递归出口
#递归的结束一定要有return
iflen(combination)==size:
res.append(combination)
return#注意
foriinrange(len(nums)):
backtrack(combination+[nums[i]],nums[:i]+nums[i+1:])#递归回溯

backtrack([],nums)
returnres

if__name__=='__main__':
nums=[1,2,3]
solution=Solution()
print(solution.permute(nums))

3：数字组合

输入:candidates=[2,3,6,7],target=7,

所求解集为:

[
[7],
[2,2,3]
]

classSolution:
defcombinationArray(self,candidates,target):

candidates.sort()
res=[]#存放组合结果
size=len(candidates)

defbacktrack(combination,cur_sum,j):
#combination目前已经产生的组合,cur_sum当前计算和，j用于控制求和的查找范围起点
#递归出口
ifcur_sum>target:
return
ifcur_sum==target:
res.append(combination)
foriinrange(j,size):#j避免重复
ifcur_sum+candidates[i]>target:#约束函数(剪)
break
j=i
backtrack(combination+[candidates[i]],cur_sum+candidates[i],j)#递归回溯

backtrack([],0,0)
returnres
if__name__=='__main__':
candidates=[2,3,6,7]
target=7
solution=Solution()
print(solution.combinationArray(candidates,target))

4：

N皇后问题

classSolution:
defsolveNqueen(self,n):

res=[]#存放结果组合，对于N皇后问题，这里存放的是其放在每一行对应的列下标
defbacktrack(combination):
iflen(combination)==n:
res.append(combination)
return
forjinrange(n):
ifcombination:
#排除当前行，列和对应的两个对角线。
ifjnotincombinationandj!=combination[-1]+1andj!=combination[-1]-1:#约束条件
backtrack(combination+[j])#递归回溯
else:
continue
else:
backtrack(combination+[j])

backtrack([])#回溯初始化

#转化为需要的格式
output=[["."*k+"Q"+"."*(n-k-1)forkini]foriinres]#列表生成器
returnoutput

if__name__=='__main__':
n=4
solution=Solution()
print(solution.solveNqueen(n))

5：子集

[1,2,3]的子集[[],[1],[1,2],[1,2,3],[1,3],[2],[2,3],[3]]

classSolution(object):
defsubsets(self,nums):
"""
:typenums:List[int]
:rtype:List[List[int]]
"""
res=[]#存放组合结果
size=len(nums)

defbacktrack(combination,nums):
#combination目前已经产生的组合，nums为剩下的数组
iflen(combination)<=size:
res.append(combination)
#递归出口
#递归的结束一定要有return
iflen(combination)==size:
return

foriinrange(len(nums)):
backtrack(combination+[nums[i]],nums[i+1:])#递归回溯

backtrack([],nums)
returnres

if__name__=='__main__':
nums=[1,2,3]
solution=Solution()
print(solution.subsets(nums))

6：

字母大小写的全排列

给定一个字符串S，通过将字符串S中的每个字母转变大小写，我们可以获得一个新的字符串。返回所有可能得到的字符串集合。

输入:S="a1b2"

输出:["a1b2","a1B2","A1b2","A1B2"]

classSolution:
defletterpermute(self,S):

res=[]
size=len(S)

defbacktrack(combination,S):

iflen(combination)==size:
res.append(''.join(combination))
return

foriinrange(len(S)):
if"a"<=S[i]<="z"or"A"<=S[i]<="Z":
forjinrange(2):
ifj==0:
backtrack(combination+[S[i].lower()],S[i+1:])
ifj==1:
backtrack(combination+[S[i].upper()],S[i+1:])

else:
backtrack(combination+[S[i]],S[i+1:])


backtrack([],S)
returnres

if__name__=='__main__':
S=[iforiin"1B2"]
solution=Solution()
print(solution.letterpermute(S))

7：生成括号

括号生成：给出n代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。

例如，给出n=3，生成结果为：

[
"((()))",
"(()())",
"(())()",
"()(())",
"()()()"
]

classSolution:
defgenerateParenthesis(self,n):

res=[]#存放组合结果
defbacktrack(combination,left,right):
#combination目前已经产生的组合
iflen(combination)==2*n:#递归出口
res.append(combination)
#对于有效的括号，左边先出
ifleft
以上这篇python实现信号时域统计特征提取代码就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持毛票票。
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

python实现信号时域统计特征提取代码

热门推荐

随机推荐