使用Swift进行生长时间序列的峰值检测

好吧,快点帮助你：这是Algo到Swift：Demo in Swift Sandbox的翻译

警告：我绝不是一个快速的程序员,因此可能会出现错误！

还要注意我已经关闭了负信号,因为OP的目的我们只想要正信号.

SWIFT代码：

import Glibc // or Darwin/ Foundation/ Cocoa/ UIKit (depending on OS)

// Function to calculate the arithmetic mean
func arithmeticMean(array: [Double]) -> Double {
    var total: Double = 0
    for number in array {
        total += number
    }
    return total / Double(array.count)
}

// Function to calculate the standard deviation
func standardDeviation(array: [Double]) -> Double
{
    let length = Double(array.count)
    let avg = array.reduce(0,{$0 + $1}) / length
    let sumOfSquaredAvgDiff = array.map { pow($0 - avg,2.0)}.reduce(0,{$0 + $1})
    return sqrt(sumOfSquaredAvgDiff / length)
}

// Function to extract some range from an array
func subArray<T>(array: [T],s: Int,e: Int) -> [T] {
    if e > array.count {
        return []
    }
    return Array(array[s..<min(e,array.count)])
}

// Smooth z-score thresholding filter
func ThresholdingAlgo(y: [Double],lag: Int,threshold: Double,influence: Double) -> ([Int],[Double],[Double]) {

    // Create arrays
    var signals   = Array(repeating: 0,count: y.count)
    var filteredY = Array(repeating: 0.0,count: y.count)
    var avgFilter = Array(repeating: 0.0,count: y.count)
    var stdFilter = Array(repeating: 0.0,count: y.count)

    // Initialise variables
    for i in 0...lag-1 {
        signals[i] = 0
        filteredY[i] = y[i]
    }

    // Start filter
    avgFilter[lag-1] = arithmeticMean(array: subArray(array: y,s: 0,e: lag-1))
    stdFilter[lag-1] = standardDeviation(array: subArray(array: y,e: lag-1))

    for i in lag...y.count-1 {
        if abs(y[i] - avgFilter[i-1]) > threshold*stdFilter[i-1] {
            if y[i] > avgFilter[i-1] {
                signals[i] = 1      // Positive signal
            } else {
                // Negative signals are turned off for this application
                //signals[i] = -1       // Negative signal
            }
            filteredY[i] = influence*y[i] + (1-influence)*filteredY[i-1]
        } else {
            signals[i] = 0          // No signal
            filteredY[i] = y[i]
        }
        // Adjust the filters
        avgFilter[i] = arithmeticMean(array: subArray(array: filteredY,s: i-lag,e: i))
        stdFilter[i] = standardDeviation(array: subArray(array: filteredY,e: i))
    }

    return (signals,avgFilter,stdFilter)
}

// Demo
let samples = [0.01,0.01]

// Run filter
let (signals,stdFilter) = ThresholdingAlgo(y: samples,lag: 10,threshold: 3,influence: 0.2)
// Print output to console
print("nOutput: n ")
for i in 0...signals.count - 1 {
    print("Data point (i)tt sample: (samples[i]) t signal: (signals[i])n")
}

// Raw data for creating a plot in Excel
print("n n Raw data for creating a plot in Excel: n ")
for i in 0...signals.count - 1 {
    print("(i+1)t(samples[i])t(signals[i])t(avgFilter[i])t(stdFilter[i])n")
}

对于样本数据的结果(对于滞后= 10,阈值= 3,影响= 0.2)：

更新

您可以通过对平均值和标准差的滞后使用不同的值来提高算法的性能.例如.：

// Smooth z-score thresholding filter
func ThresholdingAlgo(y: [Double],lagMean: Int,lagStd: Int,influenceMean: Double,influenceStd: Double) -> ([Int],count: y.count)
    var filteredYmean = Array(repeating: 0.0,count: y.count)
    var filteredYstd = Array(repeating: 0.0,count: y.count)

    // Initialise variables
    for i in 0...lagMean-1 {
        signals[i] = 0
        filteredYmean[i] = y[i]
        filteredYstd[i] = y[i]
    }

    // Start filter
    avgFilter[lagMean-1] = arithmeticMean(array: subArray(array: y,e: lagMean-1))
    stdFilter[lagStd-1] = standardDeviation(array: subArray(array: y,e: lagStd-1))

    for i in max(lagMean,lagStd)...y.count-1 {
        if abs(y[i] - avgFilter[i-1]) > threshold*stdFilter[i-1] {
            if y[i] > avgFilter[i-1] {
                signals[i] = 1      // Positive signal
            } else {
                signals[i] = -1       // Negative signal
            }
            filteredYmean[i] = influenceMean*y[i] + (1-influenceMean)*filteredYmean[i-1]
            filteredYstd[i] = influenceStd*y[i] + (1-influenceStd)*filteredYstd[i-1]
        } else {
            signals[i] = 0          // No signal
            filteredYmean[i] = y[i]
            filteredYstd[i] = y[i]
        }
        // Adjust the filters
        avgFilter[i] = arithmeticMean(array: subArray(array: filteredYmean,s: i-lagMean,e: i))
        stdFilter[i] = standardDeviation(array: subArray(array: filteredYstd,s: i-lagStd,stdFilter)
}

然后使用例如let(signals,stdFilter)= ThresholdingAlgo(y：samples,lagMean：10,lagStd：100,threshold：2,influenceMean：0.5,influenceStd：0.1)可以给出更好的结果：

DEMO