【急！！程序纠错】提取故障数据的7个特征值形成测试集

目前程序存在一些错误导致无法运行，还请大佬能帮忙实现这个程序的功能，原始数据28672行，测试集1666行，原始数据5列，测试数据4列，n代表正常，f代表故障，7个特征值公式程序已有，目标是在1s间隔内提取4*7个样本点，提取1*n组，得到类似图片所示得测试集数据~

import numpy as np
import random
import math
from scipy.fftpack import fft, ifft
import matplotlib.pyplot as plt
from matplotlib.pylab import mpl
import re

mpl.rcParams['font.sans-serif'] = ['SimHei']   # 显示中文
mpl.rcParams['axes.unicode_minus'] = False     # 显示负号


##傅里叶变换
with open("pm13.txt", 'r') as f:
    _str = f.read()
    _str = re.sub('\t', r',', _str)
    _str = re.sub(' ', r'', _str)
    _str = re.sub(',\n', r'\n', _str)
with open("pm13_data.txt", 'w') as f:
    f.write(_str)
data = np.loadtxt('pm13_data.txt', delimiter=',', skiprows=0) # delimiter表示分隔列，skiprows作用跳过头行
s1x = [y[0] for y in data]      # 第一列元素
s1y = [y[1] for y in data]      # 第二列元素
s2x = [y[2] for y in data]      # 第三列元素
s2y = [y[3] for y in data]      # 第四列元素
fs = 1280                       # fs表示采样频率
N = 833                         # N为采样点数
fStart = fs*10.5
fEnd = fStart+N
# n为正常,f为故障，取1.5~2.5s的正常数据，与10.5~结束的故障数据
# 原始数据的第一列和第二列进行傅里叶变换
sx_n = s1x[int(1.5*N): int(2.5*N)]-np.mean(s1x[int(1.5*N): int(2.5*N)])
sy_n = s1y[int(1.5*N): int(2.5*N)]-np.mean(s1y[int(1.5*N): int(2.5*N)])
sx_f = s1x[int(fStart): int(fEnd)]-np.mean(s1x[int(fStart): int(fEnd)])
sy_f = s1y[int(fStart): int(fEnd)]-np.mean(s1y[int(fStart): int(fEnd)])
Sx_n = 2*abs(fft(sx_n))/N
Sy_n = 2*abs(fft(sy_n))/N
Sx_f = 2*abs(fft(sx_f))/N
Sy_f = 2*abs(fft(sy_f))/N
data1 = [np.hstack((sx_n, sx_f)), np.hstack((sy_n, sy_f))]# 按水平方向（列顺序）堆叠数组构成一个新的数组
fft_data1 = [np.hstack((Sx_n, Sx_f)), np.hstack((Sy_n, Sy_f))]

n = np.linspace(0, N, N)
t = n/fs
f = fs/N*n
nSamp = len(s1x)
T = np.linspace(0, nSamp, nSamp)/fs

# 绘制完整时域信号
plt.figure(1)
plt.subplots_adjust(hspace=0.5)
plt.subplot(211)
plt.plot(T, s2x)
plt.axis([0, 32, -8500, -4800])
plt.xlabel('时间 / s')
plt.ylabel('电压 / mV')
plt.title('时域信号-X向')
plt.subplot(212)
plt.plot(T, s2y)
plt.axis([0, 32, -8500, -4500])
plt.xlabel('时间 / s')
plt.ylabel('电压 / mV')
plt.title('时域信号-Y向')

# 绘制时域图
plt.figure(2)
plt.subplots_adjust(hspace=0.5)
plt.subplot(221)
plt.plot(t[1:N], sx_n[1:N])
plt.axis([0, 1.5, -700, 700])
plt.xlabel('时间 / s')
plt.ylabel('电压 / mV')
plt.title('时域信号-X向正常')
plt.subplot(222)
plt.plot(t[1:N], sy_n[1:N])
plt.axis([0, 1.5, -700, 700])
plt.xlabel('时间 / s')
plt.ylabel('电压 / mV')
plt.title('时域信号-Y向正常')
plt.subplot(223)
plt.plot(t[1:N], sx_f[1:N])
plt.axis([0, 1.5, -2000, 2000])
plt.xlabel('时间 / s')
plt.ylabel('电压 / mV')
plt.title('时域信号-X向碰摩')
plt.subplot(224)
plt.plot(t[1:N], sy_f[1:N])
plt.axis([0, 1.5, -2000, 2000])
plt.xlabel('时间 / s')
plt.ylabel('电压 / mV')
plt.title('时域信号-Y向碰摩')

# 绘制幅频图
plt.figure(3)
plt.subplots_adjust(hspace=0.5)
plt.subplot(221)
plt.plot(f[1:int(N/2)], Sx_n[1:int(N/2)])
plt.xlabel('频率 / Hz')
plt.ylabel('幅值 / mV')
plt.title('频谱-X向正常')
plt.subplot(222)
plt.plot(f[1:int(N/2)],  Sy_n[1:int(N/2)])
plt.xlabel('频率 / Hz')
plt.ylabel('幅值 / mV')
plt.title('频谱-Y向正常')
plt.subplot(223)
plt.plot(f[1:int(N/2)], Sx_f[1:int(N/2)])
plt.xlabel('频率 / Hz')
plt.ylabel('幅值 / mV')
plt.title('频谱-X向碰摩')
plt.subplot(224)
plt.plot(f[1:int(N/2)], Sy_f[1:int(N/2)])
plt.xlabel('频率 / Hz')
plt.ylabel('幅值 / mV')
plt.title('频谱-Y向碰摩')

# 绘制轴心轨迹图
plt.figure(4)
plt.subplots_adjust(hspace=0.5)
plt.subplot(211)
plt.plot(sx_n, sy_n, 'b-')
plt.xlabel('X向电压 / mV')
plt.ylabel('Y向电压 / mV')
plt.title('轴心轨迹-正常')
plt.subplot(212)
plt.plot(sx_f, sy_f, 'b-')
plt.xlabel('X向电压 / mV')
plt.ylabel('Y向电压 / mV')
plt.title('轴心轨迹-碰摩')

#n为正常,f为故障，原始数据的第三列和第四列进行傅里叶变换
sx_n = s2x[int(1.5*N): int(2.5*N)]-np.mean(s2x[int(1.5*N): int(2.5*N)])
sy_n = s2y[int(1.5*N): int(2.5*N)]-np.mean(s2y[int(1.5*N): int(2.5*N)])
sx_f = s2x[int(fStart): int(fEnd)]-np.mean(s2x[int(fStart): int(fEnd)])
sy_f = s2y[int(fStart): int(fEnd)]-np.mean(s2y[int(fStart): int(fEnd)])
Sx_n = 2*abs(fft(sx_n))/N
Sx_f = 2*abs(fft(sx_f))/N
Sy_n = 2*abs(fft(sy_n))/N
Sy_f = 2*abs(fft(sy_f))/N
data2 = [np.hstack((sx_n, sx_f)), np.hstack((sy_n, sy_f))]
fft_data2 = [np.hstack((Sx_n, Sx_f)), np.hstack((Sy_n, Sy_f))]

# 绘制完整时域信号
plt.figure(5)
plt.subplots_adjust(hspace=0.5)
plt.subplot(211)
plt.plot(T, s1x)
plt.axis([0, 32, -8500, -4800])
plt.xlabel('时间 / s')
plt.ylabel('电压 / mV')
plt.title('时域信号-X向')
plt.subplot(212)
plt.plot(T, s1y)
plt.axis([0, 32, -8500, -4500])
plt.xlabel('时间 / s')
plt.ylabel('电压 / mV')
plt.title('时域信号-Y向')

# 绘制时域图
plt.figure(6)
plt.subplots_adjust(hspace=0.5)
plt.subplot(221)
plt.plot(t[1:N], sx_n[1:N])
plt.axis([0, 1.5, -700, 700])
plt.xlabel('时间 / s')
plt.ylabel('电压 / mV')
plt.title('时域信号-X向正常')
plt.subplot(222)
plt.plot(t[1:N], sy_n[1:N])
plt.axis([0, 1.5, -700, 700])
plt.xlabel('时间 / s')
plt.ylabel('电压 / mV')
plt.title('时域信号-Y向正常')
plt.subplot(223)
plt.plot(t[1:N], sx_f[1:N])
plt.axis([0, 1.5, -2000, 2000])
plt.xlabel('时间 / s')
plt.ylabel('电压 / mV')
plt.title('时域信号-X向碰摩')
plt.subplot(224)
plt.plot(t[1:N], sy_f[1:N])
plt.axis([0, 1.5, -2000, 2000])
plt.xlabel('时间 / s')
plt.ylabel('电压 / mV')
plt.title('时域信号-Y向碰摩')

# 绘制幅频图
plt.figure(7)
plt.subplots_adjust(hspace=0.5)
plt.subplot(221)
plt.plot(f[1:int(N/2)], Sx_n[1:int(N/2)])
plt.xlabel('频率 / Hz')
plt.ylabel('幅值 / mV')
plt.title('频谱-X向正常')
plt.subplot(222)
plt.plot(f[1:int(N/2)],  Sy_n[1:int(N/2)])
plt.xlabel('频率 / Hz')
plt.ylabel('幅值 / mV')
plt.title('频谱-Y向正常')
plt.subplot(223)
plt.plot(f[1:int(N/2)], Sx_f[1:int(N/2)])
plt.xlabel('频率 / Hz')
plt.ylabel('幅值 / mV')
plt.title('频谱-X向碰摩')
plt.subplot(224)
plt.plot(f[1:int(N/2)], Sy_f[1:int(N/2)])
plt.xlabel('频率 / Hz')
plt.ylabel('幅值 / mV')
plt.title('频谱-Y向碰摩')

# 绘制轴心轨迹图
plt.figure(8)
plt.subplots_adjust(hspace=0.5)
plt.subplot(211)
plt.plot(sx_n, sy_n, 'b-')
plt.xlabel('X向电压 / mV')
plt.ylabel('Y向电压 / mV')
plt.title('轴心轨迹-正常')
plt.subplot(212)
plt.plot(sx_f, sy_f, 'b-')
plt.xlabel('X向电压 / mV')
plt.ylabel('Y向电压 / mV')
plt.title('轴心轨迹-碰摩')

data = [[data1[0], data1[1], data2[0], data2[1]]]
fft_data = [fft_data1[0], fft_data1[1], fft_data2[0], fft_data2[1]]

#生成原始测试数据集
with open("data_test.txt", 'w') as f:
    for i in range(0, 2*N):
        for j in range(0, 4):
            f.write(str(data[j][i]))
            f.write(',')
        f.write('\n')

#生成fft数据集
with open("fft_data_test.txt", 'w') as f:
    for i in range(0, 2*N):
        for j in range(0, 4):
            f.write(str(fft_data[j][i]))
            f.write(',')
        f.write('\n')

plt.show()


##数据处理优化
def handleText():
    faultText1=open('pm13.txt')
    faultTextSet1 = []
    for line in faultText1.readlines():
        currLine = line.strip().split('\t')
        lineArr = []
        for i in range(len(currLine)):
            lineArr.append(float(currLine[i]))
        faultTextSet1.append(lineArr)
    faultTextSet1=np.array(faultTextSet1)
    return faultTextSet1
def handleTrain():
    faultTrain1=open('data_test.txt')
    faultTrainSet1 = []
    for line in faultTrain1.readlines():
        currLine = line.strip().split(',')
        lineArr = []
        for i in range(len(currLine)):
            lineArr.append(float(currLine[i]))
        faultTrainSet1.append(lineArr)
    faultTrainSet1=np.array(faultTrainSet1)
    return faultTrainSet1
def FFTTrain():
    fftTrain1=open('fft_data_test.txt')
    fftTrainSet1 = []
    for line in fftTrain1.readlines():
        currLine = line.strip().split(',')
        lineArr = []
        for i in range(len(currLine)):
            lineArr.append(float(currLine[i]))
        fftTrainSet1.append(lineArr)
    fftTrainSet1=np.array(fftTrainSet1)
    return fftTrainSet1
def FFTText():
    fftText1=open('fft_data.txt')
    fftTextSet1 = []
    for line in fftText1.readlines():
        currLine = line.strip().split(',')
        lineArr = []
        for i in range(len(currLine)):
            lineArr.append(float(currLine[i]))
        fftTextSet1.append(lineArr)
    fftTextSet1=np.array(fftTextSet1)
    return fftTextSet1
def mathTrain():
    filename = '测试数据特征.txt'
    faultTrainSet=handleTrain()
    fftTrainSet=FFTTrain()
    for i in range(4):
        faultTrainmath = faultTrainSet[:, i]
        fftTrainSetmath = fftTrainSet[:, i]
        Sum = 0
        Sum2 = 0
        Sum4 = 0
        Sum_2 = 0
        Sum_1 = 0
        sump = 0
        sump2 = 0
        sump3 = 0
        fk2 = 0
        fk4 = 0
        fk = 0
        sums = 0
        sum1 = 0
        sum2 = 0
        sum3 = 0
        sum4 = 0
        for j in range(1666):
            Sum = Sum + float(faultTrainmath[[j]])
        X_Average = Sum / 1666
        with open(filename, 'a') as f:
            f.write(str(X_Average))
            f.write('\n')
        for j in range(1666):
            Sum2 = Sum2 + float(faultTrainmath[[j]]) ** 2
        X_rms = math.sqrt(Sum2 / 1666) #平方根函数
        with open(filename, 'a') as f:
            f.write(str(X_rms))
            f.write('\n')

        for j in range(1666):
            Sum4 = Sum4 + float(faultTrainmath[[j]]) ** 4
        β = Sum4 / 1666
        with open(filename, 'a') as f:
            f.write(str(β))
            f.write('\n')

        for j in range(1666):
            Sum_2 = Sum_2 + math.sqrt(math.sqrt(faultTrainmath[[j]] ** 2))
        X_r = (Sum_2 / 1666) ** 2
        with open(filename, 'a') as f:
            f.write(str(X_r))
            f.write('\n')

        for j in range(1666):
            Sum_1 = Sum_1 + (float(faultTrainmath[[j]]) - X_Average) ** 2
            σ2 = Sum_1 / 1665
        with open(filename, 'a') as f:
            f.write(str(σ2))
            f.write('\n')

        for j in range(833):
            sump = sump + float(fftTrainSetmath[[j]])
        p1 = sump / 833 #点数K=N/2
        with open(filename, 'a') as f:
            f.write(str(p1))
            f.write('\n')

        for j in range(833):
            sump2 = sump2 + (float(fftTrainSetmath[[j]]) - p1) ** 2
        p2 = sump2 / 832
        with open(filename, 'a') as f:
            f.write(str(p2))
            f.write('\n')

        for j in range(833):
            sump3 = sump3 + (float(fftTrainSetmath[[j]]) - p1) ** 3
        p3 = sump3 / (833 * (math.sqrt(p2)) ** 3)
        with open(filename, 'a') as f:
            f.write(str(p3))
            f.write('\n')

        for j in range(833):
            fk4 = fk4 + float(fftTrainSetmath[[j]]) * (j+1) ** 4
            fk2 = fk2 + float(fftTrainSetmath[[j]]) * (j+1) ** 2
        p4 = math.sqrt(fk4 / (fk2 ))
        with open(filename, 'a') as f:
            f.write(str(p4))
            f.write('\n')

        for j in range(833):
            fk = fk + (j+1) * float(fftTrainSetmath[[j]])
            sums = sums + float(fftTrainSetmath[[j]])
        p5 = fk / sums
        with open(filename, 'a') as f:
            f.write(str(p5))
            f.write('\n')

        for j in range(833):
            sum1 = sum1 + float(fftTrainSetmath[[j]]) * (j+1 - p5) ** 2
        p6 = math.sqrt(sum1 / 833)
        with open(filename, 'a') as f:
            f.write(str(p6))
            f.write('\n')

        for j in range(833):
            sum2 = sum2 + (j+1) * (j+1) * float(fftTrainSetmath[[j]])
            sum3 = sum3 + float(fftTrainSetmath[[j]])
            sum4 = sum4 + float(fftTrainSetmath[[j]]) * (j+1) ** 4
        p7 = sum2 / math.sqrt(sum3 * sum4 )
        with open(filename, 'a') as f:
            f.write(str(p7))
            f.write('\n')
        if i < 2:
            with open(filename, 'a') as f:
                f.write('1\n')
        else:
            with open(filename, 'a') as f:
                f.write('0\n')

def TrainwriteNp():
    b = np.loadtxt('测试数据特征.txt')

    b=np.array(b).reshape(int(len(b)/13), 13)

    np.savetxt("b.txt", b, fmt='%f', delimiter=',')


def mathText():
    faultTextSet=handleText()
    fftTextSet=FFTText()
    filename='数据特征.txt'

    for i in range(4):
        faultTextmath=faultTextSet[:,i]
        fftTextSetmath=fftTextSet[:,i]
        Sum = 0
        Sum2 = 0
        Sum4 = 0
        Sum_2=0
        Sum_1=0
        sump=0
        sump2=0
        sump3=0
        fk2=0
        fk4=0
        fk=0
        sums=0
        sum1=0
        sum2=0
        sum3=0
        sum4=0
        for j in range(28672):

            Sum=Sum+float(faultTextmath[[j]])
        X_Average=Sum/28672
        with open(filename,'a') as f:
            f.write(str(X_Average))
            f.write('\n')
        for j in range(28672):
            Sum2=Sum2+float(faultTextmath[[j]])**2
        X_rms=math.sqrt(Sum2/28672)
        with open(filename, 'a') as f:
            f.write(str(X_rms))
            f.write('\n')

        for j in range(28672):
            Sum4=Sum4+float(faultTextmath[[j]])**4
        β=Sum4/28672
        with open(filename, 'a') as f:
            f.write(str(β))
            f.write('\n')

        for j in range(28672):
            Sum_2=Sum_2+math.sqrt(math.sqrt(faultTextmath[[j]]**2))
        X_r=(Sum_2/28672)**2
        with open(filename, 'a') as f:
            f.write(str(X_r))
            f.write('\n')

        for j in range(28672):
            Sum_1=Sum_1+(float(faultTextmath[[j]])-X_Average)**2
        σ2=Sum_1/28671
        with open(filename, 'a') as f:
            f.write(str(σ2))
            f.write('\n')
        for j in range(14336):
            sump =sump + float(fftTextSetmath[[j]])
        p1 = sump / 14336
        with open(filename, 'a') as f:
            f.write(str(p1))
            f.write('\n')

        for j in range(28672):
            sump2 = sump2+(float(fftTextSetmath[[j]])-p1)**2
        p2=sump2/14335
        with open(filename, 'a') as f:
            f.write(str(p2))
            f.write('\n')

        for j in range(14336):
            sump3=sump3+(float(fftTextSetmath[[j]])-p1)**3
        p3=sump3/(14336*(math.sqrt(p2))**3)
        with open(filename, 'a') as f:
            f.write(str(p3))
            f.write('\n')
        for j in range(14336):
            fk4=fk4+float(fftTextSetmath[[j]])*((j+1)**4)
            fk2=fk2+float(fftTextSetmath[[j]])*((j+1)**2)
        p4=math.sqrt(fk4/(fk2))
        with open(filename, 'a') as f:
            f.write(str(p4))
            f.write('\n')
        for j in range(14336):
            fk=fk+(j+1)*float(fftTextSetmath[[j]])
            sums=sums+float(fftTextSetmath[[j]])
        p5=fk/sums
        with open(filename, 'a') as f:
            f.write(str(p5))
            f.write('\n')
        for j in range(14336):
            sum1=sum1+float(fftTextSetmath[[j]])*((j-p5)**2)
        p6=math.sqrt(sum1/14336)
        with open(filename, 'a') as f:
            f.write(str(p6))
            f.write('\n')
        for j in range(14336):
            sum2=sum2+(j+1)*(j+1)*float(fftTextSetmath[[j]])
            sum3=sum3+float(fftTextSetmath[[j]])
            sum4=sum4+float(fftTextSetmath[[j]])*((j+1)**4)
        p7=sum2/math.sqrt(sum3*sum4)
        with open(filename, 'a') as f:
            f.write(str(p7))
            f.write('\n')
        if i<2:
            with open(filename, 'a') as f:
                f.write('1\n')
        else:
            with open(filename, 'a') as f:
                f.write('0\n')


def writeNp():
    a = np.loadtxt('数据特征.txt')
    a = np.array(a).reshape(int(len(a)/13), 13)
    np.savetxt("a.txt", a, fmt='%f', delimiter=',')


if __name__ == '__main__':
    handleText()
    mathText()
    writeNp()
    handleTrain()
    mathTrain()
    TrainwriteNp()

有些啥错误？ 你分解下你的问题，一步一步来，先解决错误，再来说实现功能

ValueError: Wrong number of columns at line 28672

Traceback (most recent call last):

line 22, in <module>data = np.loadtxt('pm13_data.txt', delimiter=',', skiprows=0) # delimiter表示分隔列，skiprows作用跳过头行

您好 看可以解决吗

第一个是列数据错误，是不是28672列不是数据？

你或者直接把需要处理的数据发出来，我跑跑你的py

发这儿吗 有字数限制吧

邮件吧 1099930877@qq.com

发过去了

大概看了下，你提到的错误的原因是在pm13_data.txt数据最后多了一个逗号“,”，所以最后一行在逗号后拿不到数据报错，解决方法是将原始数据pm13.txt的最后一行的最后一个数据后的空格给去掉，意思就是保证最后一个数据后面不要留空格。这样在pm13_data.txt的最后就不会多一个逗号，你就不会看到这个错误了。

但是你这个继续执行还是有错误，你看你能不能解决，不能解决就等我回来再看，出去happy了

嗯嗯，程序能运行了，但是得不到想要的结果，特征提取的结果很奇怪，改变提取的时间间隔，得到的特征值却一直是那4行不变

因为在你225行代码那里，data变为了一个一组数据的二位数组，所以只能拿到一组数据

嗯嗯 就是一组数据 （因为还没加循环，先用一组数据试着跑一下） 但是改变一下所取样本的时间段（比如由1.5~2.5变为1.6~2.6）然后再提取特征 得到的还是相同的特征值（不是应该样本提取时间段变了，样本变了，取得特征值也变了吗）

sx_n = s1x[int(1.5*N): int(2.5*N)]-np.mean(s1x[int(1.5*N): int(2.5*N)])

sy_n = s1y[int(1.5*N): int(2.5*N)]-np.mean(s1y[int(1.5*N): int(2.5*N)])

你是在这里做的替换？

是的

我试了下，不一样吧

你可能哪里搞错了，你再试试

对的 这里是不一样 然后下面大概从249行开始提取的7个特征的值是一直一样的（不随时间间隔段的改变而改变）

就生成的a,b文件 里面的数据一直是一样的

不应该，如果你都替换了应该有变化。我看你的py里面有个地方有点奇怪，fft_data_test.txt和fft_data.txt，第二个文件不存在吧，感觉你需要把282行的fft_data.txt替换为fft_data_test.txt

fft_data是另一个程序生成的 我发你邮箱 抱歉 发漏了

那就可以解释了，你说的249行开始的提取值不随你的设置而改变，那是因为你修改的取样时间段是和fft_data_test.txt关联的，fft_data_test.txt这个问文件的值改变了，但是fft_data.txt这个文件没有改变的，所以你无论怎么改，都不会是个不变的值

需要把取样时间和fft_data.txt关联上才行

我也解释不通为什么要这个fft_data,因为我现在只是想取test这部分数据生成test这部分数据的特征值，那是不是可以不要fft_data了

后面mathTrain有用到fft_data_test.txt，mathTrain你看看结果是不是你想要的

a,b文件的结果是想要的，但是这只是一组特整数据，我改变那个1.5~2.5s，结果还是这一组特征数不变，怎么改时间段都不变，这就是目前问题

我发你我调好的程序到邮箱，你可以看看

你这个之所以不变，是因为你的样本太小了。一共才28672个样本，而你的N是14336，那么你每次去从样本里面取值的时候，就不能超过 2*N（28672），而你的程序每次都是从0开始的，并且是0-4.8N，已经包含了所有的采样数据了，所以你只要后面一个数据是在>2里面变动，你永远都是拿的全样本，所以每次都是一样的值。你试试把4.8变为1.5或者小于2的任何值，就会有看到结果不一样了。

所以能不能把全样本的删除了？只保留test部分的数据和程序，全样本我觉得也没有什么用

本来也就是提取测试集的特征

不是，你没理解我的意思，你做个实验，修改为我下面的这两种方式，看看结果变了么

第一种:

sx_n = s1x[int(0*N): int(2*N)]-np.mean(s1x[int(0*N): int(2*N)])

sy_n = s1y[int(0*N): int(2*N)]-np.mean(s1y[int(0*N): int(2*N)])

第二种：

sx_n = s1x[int(0*N): int(1.5*N)]-np.mean(s1x[int(0*N): int(1.5*N)])

sy_n = s1y[int(0*N): int(1.5*N)]-np.mean(s1y[int(0*N): int(1.5*N)])

你现在的问题是“,b文件的结果是想要的，但是这只是一组特整数据，我改变那个1.5~2.5s，结果还是这一组特征数不变，怎么改时间段都不变，这就是目前问题”

其实因为本来就2s的样本，你想要0-4.8S的特征数据，或者说你想要0到超过2s的任何时间的特征数据，都只会是2s的特征数据，因为样本太小了

所以你只能得到2s的特征数据，除非你有更多的样本

我的原始数据是20多秒的

part2特征提取程序也是我套用的程序，之前的程序fft_data就代表了全样本

嗯，问题已经很明确了，就是样本时间问题，你再查查这一块。建议检查下原始数据，是否真的是20多s，这个可能要你要对一下

数据文件：pm13.txt

数据单位：mv

数据结构：第1、2列为测点1的X、Y向振动，第3、4列为测点2的X、Y向振动，第5列为键相信号

采样说明：采样频率1280Hz（即每秒采样1280个数据），总采样数据点数为28672点（总采样时间为22.4秒）

实验描述：高速下的局部碰摩，转速稳定后，铜棒逐渐靠近轴，直到发生碰摩

碰摩过程：碰摩发生时刻约为4.8秒处，碰摩结束时刻约为20.6秒处

实验转速：约2920rpm

临界转速：约1800rpm

使用方法：读取某一列数据，按固定的数据点数（点数不要过少）截取为多个样本，4.8秒前的数据为正常样本，5秒至20秒内的数据为故障样本,20秒至结束为正常

这是原始数据的说明 ，正常和故障我就是根据时间来取的

从这个来看，是你的代码里面的N要换成fs才对，就是每s采样个数

将这个

sx_n = s1x[int(0*N): int(4.8*N)]-np.mean(s1x[int(0*N): int(4.8*N)])

sy_n = s1y[int(0*N): int(4.8*N)]-np.mean(s1y[int(0*N): int(4.8*N)])

换为下面的

sx_n = s1x[int(0*fs): int(4.8*fs)]-np.mean(s1x[int(0*fs): int(4.8*fs)])

sy_n = s1y[int(0*fs): int(4.8*fs)]-np.mean(s1y[int(0*fs): int(4.8*fs)])

你如果要把N前面的数字理解为时间的话，就需要这么修改了

有道理 我改一下 运行看看

Traceback (most recent call last):

 File "C:/Users/13160/Desktop/233/A_part1.py", line 56, in <module>

   f.write(str(fft_data[j][i]))

IndexError: index 12288 is out of bounds for axis 0 with size 12288

改了之后 part1 出现这个错误了。。。

越界了

有很多N需要修改，你直接将N=1280

你说的是part1程序吗

是的

并且你的A_part2.py里面的 range_size/2 也全部要替换成 1280

但是1280是采样频率 为什么要跟采样点混淆起来

那个range_size是行数，为什么要把行数换成1280，不太明白其中的道理

你这个后面的数据处理，首先，你要求要以S为单位来处理数据，所以你在取数据的时候，个数就是以每S能处理多少数据为单位了，所以你是以1280为基础个数。

当然，你可以不用这个1280，你可以用任何数据，看你的需求，只是你这里是想要用s来处理

我现在只是想要测试数据，可以把那个part1换成part3（发你邮箱）,然后prat2里面把一部分关于fft_data的删掉，只保留测试数据的特征处理

你用你昨天的两个py不能得到特征数据吗？ 感觉你昨天的加上昨晚修改，就能达到目的了

但我想要的是测试集 不是总的 part1是总数据的fft,

错了 总数据就是训练数据

训练数据和测试数据的7个特征都要提取

按照我给你的修改不行吗？

刚刚发了修改版 Part1是总数据（训练）part3是一部分数据（测试）

改成1280就不是总数据了吧

是总的数据啊，这里只要你用的时候不丢数据就是总的

这个其实就是看你处理那块数据了，你认真理一下就清楚了

那就可能取不了总的数据了，因为【4.8秒前的数据为正常样本，5秒至20秒内的数据为故障样本,20秒至结束为正常样本】这是已知的，正常的必须和故障的分开才能分别加标签

不能直接解决测试部分吗？不管这个总的数据了，先搞定测试部分

现在问题就是a（b）文件的结果是想要的，但是这只是一组特整数据，我改变那个1.5~2.5s，结果还是这一组特征数不变,但是本应该改变的

你用我图上N的配置，肯定要变，其他地方你对应修改就好了，主要是要理解这个是怎么工作的

改了 part2有错误了：IndexError: index 25600 is out of bounds for axis 0 with size 25600

你可以跑一下 按照你的意思 看能不能让a(b)文件中的数据随着时间段改变

昨晚我就能跑过了，可以的

你这个错误是越界了，你看看你part2里面range/2 修改了吗？ 要修改我part1里面的fEend的值

改了 现在 part1有错误：IndexError: index 12800 is out of bounds for axis 0 with size 12800

data = np.loadtxt('pm13_data.txt', delimiter=',', skiprows=0)
s1x = [y[0] for y in data]      # 冒号表示元素,说明是第一列的所有元素
s1y = [y[1] for y in data]      # 第二列元素
s2x = [y[2] for y in data]      # 第三列元素
s2y = [y[3] for y in data]      # 第四列元素
fs = 1280           # fs表示采样频率
N = 1280             # N为采样点数
fStart = fs*5.0
fEnd = fs*20.0
# 频域,n为正常,f为故障,0~4.8是正常,5.0~结束是故障
sx_n = s1x[int(N*0): int(N*5.0)]-np.mean(s1x[int(N*0): int(N*5.0)])
sy_n = s1y[int(N*0): int(N*5.0)]-np.mean(s1y[int(N*0): int(N*5.0)])
sx_f = s1x[int(fStart): int(fEnd)]-np.mean(s1x[int(fStart): int(fEnd)])
sy_f = s1y[int(fStart): int(fEnd)]-np.mean(s1y[int(fStart): int(fEnd)])
Sx_n = 2*abs(fft(sx_n))/N
Sy_n = 2*abs(fft(sy_n))/N
Sx_f = 2*abs(fft(sx_f))/N
Sy_f = 2*abs(fft(sy_f))/N
fft_data1 = [np.hstack((Sx_n, Sy_n)), np.hstack((Sx_f, Sy_f))]
# 按水平方向（列顺序）堆叠数组构成一个新的数组


# n为正常,f为故障，原始数据的第三列和第四列进行傅里叶变换
sx_n = s2x[int(N*0): int(N*5.0)]-np.mean(s2x[int(N*0): int(N*5.0)])
sy_n = s2y[int(N*0): int(N*5.0)]-np.mean(s2y[int(N*0): int(N*5.0)])
sx_f = s2x[int(fStart): int(fEnd)]-np.mean(s2x[int(fStart): int(fEnd)])
sy_f = s2y[int(fStart): int(fEnd)]-np.mean(s2y[int(fStart): int(fEnd)])
Sx_n = 2*abs(fft(sx_n))/N
Sy_n = 2*abs(fft(sy_n))/N
Sx_f = 2*abs(fft(sx_f))/N
Sy_f = 2*abs(fft(sy_f))/N
fft_data2 = [np.hstack((Sx_n, Sy_n)), np.hstack((Sx_f, Sy_f))]

fft_data = [fft_data1[0], fft_data2[0], fft_data1[1], fft_data2[1]]
with open("fft_data.txt", 'w') as f:
    for i in range(0, int(fEnd)):
        for j in range(0, 4):
            f.write(str(fft_data[j][i]))
            if j != 4-1:
                f.write(',')
        if i != 2*N-1:
            f.write('\n')

要不你把你能跑的发给我 我看看

扣扣邮箱

part 1

import numpy as np

from scipy.fftpack import fft, ifft

import matplotlib.pyplot as plt

from matplotlib.pylab import mpl

import re

import random

mpl.rcParams['font.sans-serif'] = ['SimHei'] # 显示中文

mpl.rcParams['axes.unicode_minus'] = False # 显示负号

with open("pm13.txt", 'r') as f:

_str = f.read()

_str = re.sub('\t', r',', _str)

_str = re.sub(' ', r'', _str)

_str = re.sub(',\n', r'\n', _str)

with open("pm13_data.txt", 'w') as f:

f.write(_str)

data = np.loadtxt('pm13_data.txt', delimiter=',', skiprows=0)

s1x = [y[0] for y in data] # 冒号表示元素,说明是第一列的所有元素

s1y = [y[1] for y in data] # 第二列元素

s2x = [y[2] for y in data] # 第三列元素

s2y = [y[3] for y in data] # 第四列元素

fs = 1280 # fs表示采样频率

# N = 14336 # N为采样点数

N = 1280 # N为采样点数

fStart = fs*5.0

fEnd = fs*20.0

# 频域,n为正常,f为故障,0~4.8是正常,5.0~结束是故障

sx_n = s1x[int(0*N): int(5*N)]-np.mean(s1x[int(0*N): int(5*N)])

sy_n = s1y[int(0*N): int(5*N)]-np.mean(s1y[int(0*N): int(5*N)])

sx_f = s1x[int(fStart): int(fEnd)]-np.mean(s1x[int(fStart): int(fEnd)])

sy_f = s1y[int(fStart): int(fEnd)]-np.mean(s1y[int(fStart): int(fEnd)])

Sx_n = 2*abs(fft(sx_n))/N

Sy_n = 2*abs(fft(sy_n))/N

Sx_f = 2*abs(fft(sx_f))/N

Sy_f = 2*abs(fft(sy_f))/N

fft_data1 = [np.hstack((Sx_n, Sx_f)), np.hstack(

(Sy_n, Sy_f))] # 按水平方向（列顺序）堆叠数组构成一个新的数组

# n为正常,f为故障，原始数据的第三列和第四列进行傅里叶变换

sx1_n = s2x[int(0*N): int(5*N)]-np.mean(s2x[int(0*N): int(5*N)])

sy1_n = s2y[int(0*N): int(5*N)]-np.mean(s2y[int(0*N): int(5*N)])

sx1_f = s2x[int(fStart): int(fEnd)]-np.mean(s2x[int(fStart): int(fEnd)])

sy1_f = s2y[int(fStart): int(fEnd)]-np.mean(s2y[int(fStart): int(fEnd)])

Sx1_n = 2*abs(fft(sx_n))/N

Sx1_f = 2*abs(fft(sx_f))/N

Sy1_n = 2*abs(fft(sy_n))/N

Sy1_f = 2*abs(fft(sy_f))/N

fft_data2 = [np.hstack((Sx1_n, Sx1_f)), np.hstack((Sy1_n, Sy1_f))]

fft_data = [fft_data1[0], fft_data1[1], fft_data2[0], fft_data2[1]]

with open("fft_data.txt", 'w') as f:

for i in range(0, int(fEnd)):

for j in range(0, 4):

f.write(str(fft_data[j][i]))

if j != 4-1:

f.write(',')

if i != int(fEnd)-1:

f.write('\n')

part2

# -*- coding:UTF-8 -*-

import numpy as np

import random

import math

with open('fft_data_feature_test.txt', 'w') as f:

f.write('')

with open('fft_data_feature.txt', 'w') as f:

f.write('')

def handleText():

faultText1 = open('pm13.txt')

faultTextSet1 = []

for line in faultText1.readlines():

currLine = line.strip().split('\t')

lineArr = []

for i in range(len(currLine)):

lineArr.append(float(currLine[i]))

faultTextSet1.append(lineArr)

faultTextSet1 = np.array(faultTextSet1)

return faultTextSet1

def handleTrain(): # data_test.csv

faultTrain1 = open('data_test.csv')

faultTrainSet1 = []

for line in faultTrain1.readlines():

currLine = line.strip().split('\t')

lineArr = []

for i in range(len(currLine)):

lineArr.append(float(currLine[i]))

faultTrainSet1.append(lineArr)

faultTrainSet1 = np.array(faultTrainSet1)

return faultTrainSet1

def FFTTrain(): # fft_data_test.csv

fftTrain1 = open('fft_data_test.csv')

fftTrainSet1 = []

for line in fftTrain1.readlines():

currLine = line.strip().split('\t')

lineArr = []

for i in range(len(currLine)):

lineArr.append(float(currLine[i]))

fftTrainSet1.append(lineArr)

fftTrainSet1 = np.array(fftTrainSet1)

return fftTrainSet1

def FFTText(): # fft_data.csv

fftText1 = open('fft_data.txt')

fftTextSet1 = []

for line in fftText1.readlines():

currLine = line.strip().split(',')

lineArr = []

for i in range(len(currLine)):

lineArr.append(float(currLine[i]))

fftTextSet1.append(lineArr)

fftTextSet1 = np.array(fftTextSet1)

return fftTextSet1

def mathTrain(): # 生成测试数据特征-->fft_data_feature_test.txt

filename = 'fft_data_feature_test.txt'

faultTrainSet = handleTrain()

fftTrainSet = FFTTrain()

for i in range(5):

faultTrainmath = faultTrainSet[:, i]

fftTrainSetmath = fftTrainSet[:, i]

Sum = 0

Sum2 = 0

Sum4 = 0

Sum_2 = 0

Sum_1 = 0

sump = 0

sump2 = 0

sump3 = 0

fk2 = 0

fk4 = 0

fk = 0

sums = 0

sum1 = 0

sum2 = 0

sum3 = 0

sum4 = 0

range_size = 1666

for j in range(range_size):

Sum = Sum + float(faultTrainmath[[j]])

X_Average = Sum / range_size

with open(filename, 'a') as f:

f.write(str(X_Average))

f.write('\n')

for j in range(range_size):

Sum2 = Sum2 + float(faultTrainmath[[j]]) ** 2

X_rms = math.sqrt(Sum2 / range_size)

with open(filename, 'a') as f:

f.write(str(X_rms))

f.write('\n')

for j in range(range_size):

Sum4 = Sum4 + float(faultTrainmath[[j]]) ** 4

β = Sum4 / range_size

with open(filename, 'a') as f:

f.write(str(β))

f.write('\n')

for j in range(range_size):

Sum_2 = Sum_2 + math.sqrt(math.sqrt(faultTrainmath[[j]] ** 2))

X_r = (Sum_2 / range_size) ** 2

with open(filename, 'a') as f:

f.write(str(X_r))

f.write('\n')

for j in range(range_size):

Sum_1 = Sum_1 + (float(faultTrainmath[[j]]) - X_Average) ** 2

σ2 = Sum_1 / (range_size-1)

with open(filename, 'a') as f:

f.write(str(σ2))

f.write('\n')

for j in range(int(range_size/2)):

sump = sump + float(fftTrainSetmath[[j]])

p1 = sump / (range_size/2)

with open(filename, 'a') as f:

f.write(str(p1))

f.write('\n')

for j in range(int(range_size/2)):

sump2 = sump2 + (float(fftTrainSetmath[[j]]) - p1) ** 2

p2 = sump2 / (range_size/2-1)

with open(filename, 'a') as f:

f.write(str(p2))

f.write('\n')

for j in range(int(range_size/2)):

sump3 = sump3 + (float(fftTrainSetmath[[j]]) - p1) ** 3

p3 = sump3 / ((range_size/2) * (math.sqrt(p2)) ** 3)

with open(filename, 'a') as f:

f.write(str(p3))

f.write('\n')

for j in range(int(range_size/2)):

fk4 = fk4 + float(fftTrainSetmath[[j]]) * (j+1) ** 4

fk2 = fk2 + float(fftTrainSetmath[[j]]) * (j+1) ** 2

p4 = math.sqrt(fk4 / (fk2))

with open(filename, 'a') as f:

f.write(str(p4))

f.write('\n')

for j in range(int(range_size/2)):

fk = fk + (j+1) * float(fftTrainSetmath[[j]])

sums = sums + float(fftTrainSetmath[[j]])

p5 = fk / sums

with open(filename, 'a') as f:

f.write(str(p5))

f.write('\n')

for j in range(int(range_size/2)):

sum1 = sum1 + float(fftTrainSetmath[[j]]) * (j+1 - p5) ** 2

p6 = math.sqrt(sum1 / (range_size/2))

with open(filename, 'a') as f:

f.write(str(p6))

f.write('\n')

for j in range(int(range_size/2)):

sum2 = sum2 + (j+1) * (j+1) * float(fftTrainSetmath[[j]])

sum3 = sum3 + float(fftTrainSetmath[[j]])

sum4 = sum4 + float(fftTrainSetmath[[j]]) * (j+1) ** 4

p7 = sum2 / math.sqrt(sum3 * sum4)

with open(filename, 'a') as f:

f.write(str(p7))

f.write('\n')

if i < 16:

with open(filename, 'a') as f:

f.write('+1')

f.write('\n')

else:

with open(filename, 'a') as f:

f.write('-1')

f.write('\n')

def TrainwriteNp(): # 测试数据特征-->b.txt

b = np.loadtxt('fft_data_feature_test.txt')

b = np.array(b).reshape(int(len(b)/13), 13)

np.savetxt("b.txt", b, fmt='%f', delimiter=',')

def mathText(): # 生成数据特征-->fft_data_feature.txt

faultTextSet = handleText()

fftTextSet = FFTText()

filename = 'fft_data_feature.txt'

for i in range(4):

faultTextmath = faultTextSet[:, i]

fftTextSetmath = fftTextSet[:, i]

Sum = 0

Sum2 = 0

Sum4 = 0

Sum_2 = 0

Sum_1 = 0

sump = 0

sump2 = 0

sump3 = 0

fk2 = 0

fk4 = 0

fk = 0

sums = 0

sum1 = 0

sum2 = 0

sum3 = 0

sum4 = 0

range_size = len(faultTextmath)

for j in range(range_size):

Sum = Sum+float(faultTextmath[[j]])

X_Average = Sum/range_size

with open(filename, 'a') as f:

f.write(str(X_Average))

f.write('\n')

for j in range(range_size):

Sum2 = Sum2+float(faultTextmath[[j]])**2

X_rms = math.sqrt(Sum2/range_size)

with open(filename, 'a') as f:

f.write(str(X_rms))

f.write('\n')

for j in range(range_size):

Sum4 = Sum4+float(faultTextmath[[j]])**4

β = Sum4/range_size

with open(filename, 'a') as f:

f.write(str(β))

f.write('\n')

for j in range(range_size):

Sum_2 = Sum_2+math.sqrt(math.sqrt(faultTextmath[[j]]**2))

X_r = (Sum_2/range_size)**2

with open(filename, 'a') as f:

f.write(str(X_r))

f.write('\n')

for j in range(range_size):

Sum_1 = Sum_1+(float(faultTextmath[[j]])-X_Average)**2

σ2 = Sum_1/(range_size-1)

with open(filename, 'a') as f:

f.write(str(σ2))

f.write('\n')

mm = 1280*20

for j in range(int(mm)):

sump = sump + float(fftTextSetmath[[j]])

p1 = sump / (mm)

with open(filename, 'a') as f:

f.write(str(p1))

f.write('\n')

for j in range(int(mm)):

sump2 = sump2+(float(fftTextSetmath[[j]])-p1)**2

p2 = sump2/(mm)

with open(filename, 'a') as f:

f.write(str(p2))

f.write('\n')

for j in range(int(mm)):

sump3 = sump3+(float(fftTextSetmath[[j]])-p1)**3

p3 = sump3/((mm)*(math.sqrt(p2))**3)

with open(filename, 'a') as f:

f.write(str(p3))

f.write('\n')

for j in range(int(mm)):

fk4 = fk4+float(fftTextSetmath[[j]])*((j+1)**4)

fk2 = fk2+float(fftTextSetmath[[j]])*((j+1)**2)

p4 = math.sqrt(fk4/(fk2))

with open(filename, 'a') as f:

f.write(str(p4))

f.write('\n')

for j in range(int(mm)):

fk = fk+(j+1)*float(fftTextSetmath[[j]])

sums = sums+float(fftTextSetmath[[j]])

p5 = fk/sums

with open(filename, 'a') as f:

f.write(str(p5))

f.write('\n')

for j in range(int(mm)):

sum1 = sum1+float(fftTextSetmath[[j]])*((j-p5)**2)

p6 = math.sqrt(sum1/(range_size/2))

with open(filename, 'a') as f:

f.write(str(p6))

f.write('\n')

for j in range(int(mm)):

sum2 = sum2+(j+1)*(j+1)*float(fftTextSetmath[[j]])

sum3 = sum3+float(fftTextSetmath[[j]])

sum4 = sum4+float(fftTextSetmath[[j]])*((j+1)**4)

p7 = sum2/math.sqrt(sum3*sum4)

with open(filename, 'a') as f:

f.write(str(p7))

f.write('\n')

if i < 80:

with open(filename, 'a') as f:

f.write('+1')

f.write('\n')

else:

with open(filename, 'a') as f:

f.write('-1')

f.write('\n')

def writeNp(): # 数据特征-->a.txt

a = np.loadtxt('fft_data_feature.txt')

a = np.array(a).reshape(int(len(a)/13), 13)

np.savetxt("a.txt", a, fmt='%f', delimiter=',')

if __name__ == '__main__':

handleText()

mathText()

writeNp()

handleTrain()

mathTrain()

TrainwriteNp()

看这个part2

# -*- coding:UTF-8 -*-
import numpy as np
import random
import math


with open('fft_data_feature_test.txt', 'w') as f:
    f.write('')

with open('fft_data_feature.txt', 'w') as f:
    f.write('')


def handleText():
    faultText1 = open('pm13.txt')
    faultTextSet1 = []
    for line in faultText1.readlines():
        currLine = line.strip().split('\t')
        lineArr = []
        for i in range(len(currLine)):
            lineArr.append(float(currLine[i]))
        faultTextSet1.append(lineArr)
    faultTextSet1 = np.array(faultTextSet1)
    return faultTextSet1


def handleTrain():                                  # data_test.csv
    faultTrain1 = open('data_test.csv')
    faultTrainSet1 = []
    for line in faultTrain1.readlines():
        currLine = line.strip().split('\t')
        lineArr = []
        for i in range(len(currLine)):
            lineArr.append(float(currLine[i]))
        faultTrainSet1.append(lineArr)
    faultTrainSet1 = np.array(faultTrainSet1)
    return faultTrainSet1


def FFTTrain():                                     # fft_data_test.csv
    fftTrain1 = open('fft_data_test.csv')
    fftTrainSet1 = []
    for line in fftTrain1.readlines():
        currLine = line.strip().split('\t')
        lineArr = []
        for i in range(len(currLine)):
            lineArr.append(float(currLine[i]))
        fftTrainSet1.append(lineArr)
    fftTrainSet1 = np.array(fftTrainSet1)
    return fftTrainSet1


def FFTText():                                      # fft_data.csv
    fftText1 = open('fft_data.txt')
    fftTextSet1 = []
    for line in fftText1.readlines():
        currLine = line.strip().split(',')
        lineArr = []
        for i in range(len(currLine)):
            lineArr.append(float(currLine[i]))
        fftTextSet1.append(lineArr)
    fftTextSet1 = np.array(fftTextSet1)
    return fftTextSet1


def mathTrain():                                    # 生成测试数据特征-->fft_data_feature_test.txt
    filename = 'fft_data_feature_test.txt'
    faultTrainSet = handleTrain()
    fftTrainSet = FFTTrain()
    for i in range(5):
        faultTrainmath = faultTrainSet[:, i]
        fftTrainSetmath = fftTrainSet[:, i]
        Sum = 0
        Sum2 = 0
        Sum4 = 0
        Sum_2 = 0
        Sum_1 = 0
        sump = 0
        sump2 = 0
        sump3 = 0
        fk2 = 0
        fk4 = 0
        fk = 0
        sums = 0
        sum1 = 0
        sum2 = 0
        sum3 = 0
        sum4 = 0
        range_size = 1666
        for j in range(range_size):
            Sum = Sum + float(faultTrainmath[[j]])
        X_Average = Sum / range_size
        with open(filename, 'a') as f:
            f.write(str(X_Average))
            f.write('\n')
        for j in range(range_size):
            Sum2 = Sum2 + float(faultTrainmath[[j]]) ** 2
        X_rms = math.sqrt(Sum2 / range_size)
        with open(filename, 'a') as f:
            f.write(str(X_rms))
            f.write('\n')

        for j in range(range_size):
            Sum4 = Sum4 + float(faultTrainmath[[j]]) ** 4
        β = Sum4 / range_size
        with open(filename, 'a') as f:
            f.write(str(β))
            f.write('\n')

        for j in range(range_size):
            Sum_2 = Sum_2 + math.sqrt(math.sqrt(faultTrainmath[[j]] ** 2))
        X_r = (Sum_2 / range_size) ** 2
        with open(filename, 'a') as f:
            f.write(str(X_r))
            f.write('\n')

        for j in range(range_size):
            Sum_1 = Sum_1 + (float(faultTrainmath[[j]]) - X_Average) ** 2
            σ2 = Sum_1 / (range_size-1)
        with open(filename, 'a') as f:
            f.write(str(σ2))
            f.write('\n')
        for j in range(int(range_size/2)):
            sump = sump + float(fftTrainSetmath[[j]])
        p1 = sump / (range_size/2)
        with open(filename, 'a') as f:
            f.write(str(p1))
            f.write('\n')

        for j in range(int(range_size/2)):
            sump2 = sump2 + (float(fftTrainSetmath[[j]]) - p1) ** 2
        p2 = sump2 / (range_size/2-1)
        with open(filename, 'a') as f:
            f.write(str(p2))
            f.write('\n')

        for j in range(int(range_size/2)):
            sump3 = sump3 + (float(fftTrainSetmath[[j]]) - p1) ** 3
        p3 = sump3 / ((range_size/2) * (math.sqrt(p2)) ** 3)
        with open(filename, 'a') as f:
            f.write(str(p3))
            f.write('\n')
        for j in range(int(range_size/2)):
            fk4 = fk4 + float(fftTrainSetmath[[j]]) * (j+1) ** 4
            fk2 = fk2 + float(fftTrainSetmath[[j]]) * (j+1) ** 2
        p4 = math.sqrt(fk4 / (fk2))
        with open(filename, 'a') as f:
            f.write(str(p4))
            f.write('\n')
        for j in range(int(range_size/2)):
            fk = fk + (j+1) * float(fftTrainSetmath[[j]])
            sums = sums + float(fftTrainSetmath[[j]])
        p5 = fk / sums
        with open(filename, 'a') as f:
            f.write(str(p5))
            f.write('\n')
        for j in range(int(range_size/2)):
            sum1 = sum1 + float(fftTrainSetmath[[j]]) * (j+1 - p5) ** 2
        p6 = math.sqrt(sum1 / (range_size/2))
        with open(filename, 'a') as f:
            f.write(str(p6))
            f.write('\n')
        for j in range(int(range_size/2)):
            sum2 = sum2 + (j+1) * (j+1) * float(fftTrainSetmath[[j]])
            sum3 = sum3 + float(fftTrainSetmath[[j]])
            sum4 = sum4 + float(fftTrainSetmath[[j]]) * (j+1) ** 4
        p7 = sum2 / math.sqrt(sum3 * sum4)
        with open(filename, 'a') as f:
            f.write(str(p7))
            f.write('\n')
        if i < 16:
            with open(filename, 'a') as f:
                f.write('+1')
                f.write('\n')
        else:
            with open(filename, 'a') as f:
                f.write('-1')
                f.write('\n')


def TrainwriteNp():                                     # 测试数据特征-->b.txt
    b = np.loadtxt('fft_data_feature_test.txt')

    b = np.array(b).reshape(int(len(b)/13), 13)

    np.savetxt("b.txt", b, fmt='%f', delimiter=',')


def mathText():                                         # 生成数据特征-->fft_data_feature.txt
    faultTextSet = handleText()
    fftTextSet = FFTText()
    filename = 'fft_data_feature.txt'

    for i in range(4):
        faultTextmath = faultTextSet[:, i]
        fftTextSetmath = fftTextSet[:, i]
        Sum = 0
        Sum2 = 0
        Sum4 = 0
        Sum_2 = 0
        Sum_1 = 0
        sump = 0
        sump2 = 0
        sump3 = 0
        fk2 = 0
        fk4 = 0
        fk = 0
        sums = 0
        sum1 = 0
        sum2 = 0
        sum3 = 0
        sum4 = 0
        range_size = len(faultTextmath)
        for j in range(range_size):

            Sum = Sum+float(faultTextmath[[j]])
        X_Average = Sum/range_size
        with open(filename, 'a') as f:
            f.write(str(X_Average))
            f.write('\n')
        for j in range(range_size):
            Sum2 = Sum2+float(faultTextmath[[j]])**2
        X_rms = math.sqrt(Sum2/range_size)
        with open(filename, 'a') as f:
            f.write(str(X_rms))
            f.write('\n')

        for j in range(range_size):
            Sum4 = Sum4+float(faultTextmath[[j]])**4
        β = Sum4/range_size
        with open(filename, 'a') as f:
            f.write(str(β))
            f.write('\n')

        for j in range(range_size):
            Sum_2 = Sum_2+math.sqrt(math.sqrt(faultTextmath[[j]]**2))
        X_r = (Sum_2/range_size)**2
        with open(filename, 'a') as f:
            f.write(str(X_r))
            f.write('\n')

        for j in range(range_size):
            Sum_1 = Sum_1+(float(faultTextmath[[j]])-X_Average)**2
        σ2 = Sum_1/(range_size-1)
        with open(filename, 'a') as f:
            f.write(str(σ2))
            f.write('\n')

        mm = 1280*20
        for j in range(int(mm)):
            sump = sump + float(fftTextSetmath[[j]])
        p1 = sump / (mm)
        with open(filename, 'a') as f:
            f.write(str(p1))
            f.write('\n')

        for j in range(int(mm)):
            sump2 = sump2+(float(fftTextSetmath[[j]])-p1)**2
        p2 = sump2/(mm)
        with open(filename, 'a') as f:
            f.write(str(p2))
            f.write('\n')

        for j in range(int(mm)):
            sump3 = sump3+(float(fftTextSetmath[[j]])-p1)**3
        p3 = sump3/((mm)*(math.sqrt(p2))**3)
        with open(filename, 'a') as f:
            f.write(str(p3))
            f.write('\n')
        for j in range(int(mm)):
            fk4 = fk4+float(fftTextSetmath[[j]])*((j+1)**4)
            fk2 = fk2+float(fftTextSetmath[[j]])*((j+1)**2)
        p4 = math.sqrt(fk4/(fk2))
        with open(filename, 'a') as f:
            f.write(str(p4))
            f.write('\n')
        for j in range(int(mm)):
            fk = fk+(j+1)*float(fftTextSetmath[[j]])
            sums = sums+float(fftTextSetmath[[j]])
        p5 = fk/sums
        with open(filename, 'a') as f:
            f.write(str(p5))
            f.write('\n')
        for j in range(int(mm)):
            sum1 = sum1+float(fftTextSetmath[[j]])*((j-p5)**2)
        p6 = math.sqrt(sum1/(range_size/2))
        with open(filename, 'a') as f:
            f.write(str(p6))
            f.write('\n')
        for j in range(int(mm)):
            sum2 = sum2+(j+1)*(j+1)*float(fftTextSetmath[[j]])
            sum3 = sum3+float(fftTextSetmath[[j]])
            sum4 = sum4+float(fftTextSetmath[[j]])*((j+1)**4)
        p7 = sum2/math.sqrt(sum3*sum4)
        with open(filename, 'a') as f:
            f.write(str(p7))
            f.write('\n')
        if i < 80:
            with open(filename, 'a') as f:
                f.write('+1')
                f.write('\n')
        else:
            with open(filename, 'a') as f:
                f.write('-1')
                f.write('\n')


def writeNp():                                     # 数据特征-->a.txt
    a = np.loadtxt('fft_data_feature.txt')
    a = np.array(a).reshape(int(len(a)/13), 13)
    np.savetxt("a.txt", a, fmt='%f', delimiter=',')


if __name__ == '__main__':
    handleText()
    mathText()
    writeNp()
    handleTrain()
    mathTrain()
    TrainwriteNp()

part1

import numpy as np
from scipy.fftpack import fft, ifft
import matplotlib.pyplot as plt
from matplotlib.pylab import mpl
import re
import random

mpl.rcParams['font.sans-serif'] = ['SimHei']   # 显示中文
mpl.rcParams['axes.unicode_minus'] = False       # 显示负号

with open("pm13.txt", 'r') as f:
    _str = f.read()
    _str = re.sub('\t', r',', _str)
    _str = re.sub(' ', r'', _str)
    _str = re.sub(',\n', r'\n', _str)
with open("pm13_data.txt", 'w') as f:
    f.write(_str)

data = np.loadtxt('pm13_data.txt', delimiter=',', skiprows=0)
s1x = [y[0] for y in data]      # 冒号表示元素,说明是第一列的所有元素
s1y = [y[1] for y in data]      # 第二列元素
s2x = [y[2] for y in data]      # 第三列元素
s2y = [y[3] for y in data]      # 第四列元素
fs = 1280           # fs表示采样频率
# N = 14336             # N为采样点数
N = 1280             # N为采样点数
fStart = fs*5.0
fEnd = fs*20.0
# 频域,n为正常,f为故障,0~4.8是正常,5.0~结束是故障
sx_n = s1x[int(0*N): int(5*N)]-np.mean(s1x[int(0*N): int(5*N)])
sy_n = s1y[int(0*N): int(5*N)]-np.mean(s1y[int(0*N): int(5*N)])
sx_f = s1x[int(fStart): int(fEnd)]-np.mean(s1x[int(fStart): int(fEnd)])
sy_f = s1y[int(fStart): int(fEnd)]-np.mean(s1y[int(fStart): int(fEnd)])
Sx_n = 2*abs(fft(sx_n))/N
Sy_n = 2*abs(fft(sy_n))/N
Sx_f = 2*abs(fft(sx_f))/N
Sy_f = 2*abs(fft(sy_f))/N
fft_data1 = [np.hstack((Sx_n, Sx_f)), np.hstack(
    (Sy_n, Sy_f))]  # 按水平方向（列顺序）堆叠数组构成一个新的数组


# n为正常,f为故障，原始数据的第三列和第四列进行傅里叶变换
sx1_n = s2x[int(0*N): int(5*N)]-np.mean(s2x[int(0*N): int(5*N)])
sy1_n = s2y[int(0*N): int(5*N)]-np.mean(s2y[int(0*N): int(5*N)])
sx1_f = s2x[int(fStart): int(fEnd)]-np.mean(s2x[int(fStart): int(fEnd)])
sy1_f = s2y[int(fStart): int(fEnd)]-np.mean(s2y[int(fStart): int(fEnd)])
Sx1_n = 2*abs(fft(sx_n))/N
Sx1_f = 2*abs(fft(sx_f))/N
Sy1_n = 2*abs(fft(sy_n))/N
Sy1_f = 2*abs(fft(sy_f))/N
fft_data2 = [np.hstack((Sx1_n, Sx1_f)), np.hstack((Sy1_n, Sy1_f))]

fft_data = [fft_data1[0], fft_data1[1], fft_data2[0], fft_data2[1]]
with open("fft_data.txt", 'w') as f:
    for i in range(0, int(fEnd)):
        for j in range(0, 4):
            f.write(str(fft_data[j][i]))
            if j != 4-1:
                f.write(',')
        if i != int(fEnd)-1:
            f.write('\n')

谢谢 我看一下

现在b的数据变了 但a的不变 想问一下 ab有什么区别 b对应的是测试集数据 那a是全部数据吗？

a/b就是range不一样，你看看py，a是怎么生成的，b怎么生成的。a是我们修改了的，所以不一样了，但是b你是写死了

range_size = 1666

所以b不变，

a是从pm13.txt来的

b是data_test.csv来的

建议你好好理下py

现在a 变了 b 不变

我还是不理解你这样修改的意义 但是我的想法是：

1s---4*1666个数---4*8个样本点

1*n s---4*1666*n---4*8*n个样本点

8是7个特征加1个标签

不知道你那样修改的思路是什么 ，并且你那么修改那正常数据不就0~5s直接了，但已知的是-~4.8正常，

不知道你那样修改的思路是什么 ，并且你那么修改那正常数据不就0~5s之间了，但已知的是0~4.8s正常，

比如说吧1.3~2.3修改成1.4~2.4

应该part3程序里出来的test_data和fft_test_data就不一样了

之后a提取的特征也会不一样，但是现在一直那四行不变

嗯嗯 思路是改part3影响part2

感觉帮不了你了。。。。

你意思采样点取的跟频率一样 就刚好是1s 就是采样1s时间并做fft吗？