python實現訊號時域統計特徵提取程式碼

阿新 • • 發佈：2020-02-27

1.實驗資料需求

為了對採集的壓力實驗資料做特徵工程，需要對訊號進行時域的統計特徵提取，包含了均值、均方根、偏度、峭度、波形因子、波峰因子、脈衝因子、峭度因子等，現用python對其進行實現。

2.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

3.結果與說明

python實現訊號時域統計特徵提取程式碼

補充拓展：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 res

2：全排列

輸入: [1,2,3]

輸出:

[
[1,3],
[1,3,2],
[2,1,1],
[3,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,3]
 solution=Solution()
 print(solution.permute(nums))

3：數字組合

輸入: candidates = [2,6,7],target = 7,

所求解集為:

[
[7],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)
  return res
if __name__=='__main__':
 candidates = [2,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,3]的子集[[],[1],[1,[2],[2,[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,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+')',right+1)#遞迴實現回溯
     
  backtrack('',0) #初始化
  return res 
if __name__=='__main__':
 n=3
 solution=Solution()
 print(solution.generateParenthesis(n))

以上這篇python實現訊號時域統計特徵提取程式碼就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支援我們。