Python实现信号时域统计特征提取及回溯算法实战
本文详细介绍使用Python提取压力实验信号时域统计特征的方法，涵盖均值、均方根、偏度、峭度等8项指标的实现代码。同时，通过电话号码组合、全排列、N皇后等经典案例，深入解析回溯算法在解决组合与排列问题中的实际应用与剪枝技巧。
信号时域统计特征提取实现
实验数据需求
针对采集的压力实验数据进行特征工程处理，需对信号进行时域统计特征提取。主要指标包括均值、均方根、偏度、峭度、波形因子、波峰因子、脉冲因子及裕度因子，现通过Python代码实现上述计算。
Python实现
函数输入参数定义如下：
① data：实验数据的DataFrame对象
② p1：截取实验信号的起始采样点索引
③ p2：截取实验信号的终止采样点索引
from pandas import Series
import math
pstf_list=[]
def psfeatureTime(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
for i in range(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]
return featuretime_list 结果与说明
回溯算法原理与实战
补充拓展：Python数据结构与算法——回溯算法详解
回溯算法是一种优先搜索策略（试探法）。它按特定条件向前搜索以达成目标；当发现当前路径无法通时，便退回重新选择其他路径。
回溯算法的一般步骤包括：1. 定义问题的解空间（在搜索过程中动态生成）；2. 确定易于搜索的解空间结构（通常为树形结构或图）；3. 以深度优先方式搜索解空间，并在搜索过程中利用剪枝函数避免无效搜索。
剪枝函数包含两类：1. 约束函数：在扩展节点处剔除不满足约束条件的子树；2. 限界函数：剔除无法得到最优解的子树。
回溯法实战案例
1. 电话号码的字母组合
解决方法：回溯法（适用于组合问题）
class Solution:
def letterCombination(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=[]#存放组合结果
def backtrack(combination,next_digits):#回溯函数
#combination目前已经产生的组合，next_digits:输入的下一个字符
if len(next_digits)==0: #递归出口
res.append(combination)
else:
for i in phone[next_digits[0]]:
backtrack(combination+i,next_digits[1:]) #递归实现回溯
if digits:
backtrack('',digits) #初始化
return res2. 全排列
输入: [1,2,3]
输出:
[ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ]
class Solution:
def permute(self,nums):
res=[] #存放组合结果
size=len(nums)
def backtrack(combination,nums):
#combination目前已经产生的组合，nums为剩下的数组
#递归出口
#递归的结束一定 要有return
if len(combination)==size:
res.append(combination)
return #注意
for i in range(len(nums)):
backtrack(combination+[nums[i]],nums[:i]+nums[i+1:]) #递归回溯
backtrack([],nums)
return res
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] ]
class Solution:
def combinationArray(self,candidates,target):
candidates.sort()
res=[] #存放组合结果
size=len(candidates)
def backtrack(combination,cur_sum,j):
#combination目前已经产生的组合,cur_sum当前计算和，j用于控制求和的查找范围起点
#递归出口
if cur_sum>target:
return
if cur_sum==target:
res.append(combination)
for i in range(j,size): #j避免重复
if cur_sum+candidates[i]>target: #约束函数(剪)
break
j=i
backtrack(combination+[candidates[i]],cur_sum+candidates[i],j)#递归回溯
backtrack([],0,0)
return res
if __name__=='__main__':
candidates = [2,3,6,7]
target = 7
solution=Solution()
print(solution.combinationArray(candidates,target))
4.
N皇后问题
class Solution:
def solveNqueen(self,n):
res=[] #存放结果组合，对于N皇后问题，这里存放的是其放在每一行对应的列下标
def backtrack(combination):
if len(combination)==n:
res.append(combination)
return
for j in range(n):
if combination:
#排除当前行，列和对应的两个对角线。
if j not in combination and j!=combination[-1]+1 and j!=combination[-1]-1:#约束条件
backtrack(combination+[j]) #递归回溯
else:
continue
else:
backtrack(combination+[j])
backtrack([]) #回溯初始化
#转化为需要的格式
output=[["." * k + "Q" + "." * (n - k - 1) for k in i] for i in res] #列表生成器
return output
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]]
class Solution(object):
def subsets(self, nums):
"""
:type nums: List[int]
:rtype: List[List[int]]
"""
res=[]#存放组合结果
size=len(nums)
def backtrack(combination,nums):
#combination目前已经产生的组合，nums为剩下的数组
if len(combination)<=size:
res.append(combination)
#递归出口
#递归的结束一定 要有return
if len(combination)==size:
return
for i in range(len(nums)):
backtrack(combination+[nums[i]],nums[i+1:]) #递归回溯
backtrack([],nums)
return res
if __name__=='__main__':
nums=[1,2,3]
solution=Solution()
print(solution.subsets(nums))
6.
字母大小写的全排列
给定一个字符串S，通过将字符串S中的每个字母转变大小写，我们可以获得一个新的字符串。返回所有可能得到的字符串集合。
输入: S = "a1b2"
输出: ["a1b2", "a1B2", "A1b2", "A1B2"]
class Solution:
def letterpermute(self,S):
res=[]
size=len(S)
def backtrack(combination,S):
if len(combination)==size:
res.append(''.join(combination))
return
for i in range(len(S)):
if "a"<=S[i]<= "z" or "A"<=S[i]<= "Z":
for j in range(2):
if j==0:
backtrack(combination+[S[i].lower()],S[i+1:])
if j==1:
backtrack(combination+[S[i].upper()],S[i+1:])
else:
backtrack(combination+[S[i]],S[i+1:])
backtrack([],S)
return res
if __name__=='__main__':
S=[i for i in "1B2"]
solution=Solution()
print(solution.letterpermute(S))
7. 生成括号
括号生成：给出 n 代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。
例如，给出 n = 3，生成结果为：
[
"((()))",
"(()())",
"(())()",
"()(())",
"()()()"
]
class Solution:
def generateParenthesis(self,n):
res=[] #存放组合结果
def backtrack(combination,left,right):
#combination目前已经产生的组合
if len(combination)==2*n: #递归出口
res.append(combination)
#对于有效的括号，左边先出
if left<n:
backtrack(combination+'(',left+1,right)#递归实现回溯
if right<left:
backtrack(combination+')',left,right+1)#递归实现回溯
backtrack('',0,0) #初始化
return res
if __name__=='__main__':
n=3
solution=Solution()
print(solution.generateParenthesis(n))
以上这篇python实现信号时域统计特征提取代码就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持本站。
免责声明：本文内容仅供参考，不代表本站观点。转载或引用请注明出处。
