解释 sig_fft = fft(signal,Nr)./Nr;
时间: 2024-05-24 18:10:47 浏览: 14
这行代码的作用是对长度为Nr的信号signal进行快速傅里叶变换(FFT),并将结果除以Nr得到归一化的FFT结果sig_fft。
其中,fft(signal,Nr)表示对信号signal进行FFT变换,Nr表示FFT的点数,即变换后得到的频域点数。./表示逐元素除法,将FFT结果中的每个元素都除以Nr,实现归一化。
相关问题
帮我给每一行代码添加注释 class DeepKalmanFilter(nn.Module): def __init__(self, config): super(DeepKalmanFilter, self).__init__() self.emitter = Emitter(config.z_dim, config.emit_hidden_dim, config.obs_dim) self.transition = Transition(config.z_dim, config.trans_hidden_dim) self.posterior = Posterior( config.z_dim, config.post_hidden_dim, config.obs_dim ) self.z_q_0 = nn.Parameter(torch.zeros(config.z_dim)) self.emit_log_sigma = nn.Parameter(config.emit_log_sigma * torch.ones(config.obs_dim)) self.config = config @staticmethod def reparametrization(mu, sig): return mu + torch.randn_like(sig) * sig @staticmethod def kl_div(mu0, sig0, mu1, sig1): return -0.5 * torch.sum(1 - 2 * sig1.log() + 2 * sig0.log() - (mu1 - mu0).pow(2) / sig1.pow(2) - (sig0 / sig1).pow(2)) def loss(self, obs): time_step = obs.size(1) batch_size = obs.size(0) overshoot_len = self.config.overshooting kl = torch.Tensor([0]).to(self.config.device) reconstruction = torch.Tensor([0]).to(self.config.device) emit_sig = self.emit_log_sigma.exp() for s in range(self.config.sampling_num): z_q_t = self.z_q_0.expand((batch_size, self.config.z_dim)) for t in range(time_step): trans_loc, trans_sig = self.transition(z_q_t) post_loc, post_sig = self.posterior(trans_loc, trans_sig, obs[:, t]) z_q_t = self.reparametrization(post_loc, post_sig) emit_loc = self.emitter(z_q_t) reconstruction += ((emit_loc - obs[:, t]).pow(2).sum(dim=0) / 2 / emit_sig + self.emit_log_sigma * batch_size / 2).sum() if t > 0: over_loc, over_sig = self.transition(overshooting[:overshoot_len - 1]) over_loc = torch.cat([trans_loc.unsqueeze(0), over_loc], dim=0) over_sig = torch.cat([trans_sig.unsqueeze(0), over_sig], dim=0) else: over_loc = trans_loc.unsqueeze(0) over_sig = trans_sig.unsqueeze(0) overshooting = self.reparametrization(over_loc, over_sig) kl = kl + self.kl_div(post_loc.expand_as(over_loc), post_sig.expand_as(over_sig), over_loc, over_sig) / min(t + 1, self.config.overshooting) reconstruction = reconstruction / self.config.sampling_num kl = kl / self.config.sampling_num return reconstruction, kl
答:class DeepKalmanFilter(nn.Module): # 定义深度Kalman滤波器类
def __init__(self, config): # 初始化
super(DeepKalmanFilter, self).__init__() # 调用父类构造函数
self.emitter = Emitter(config.z_dim, config.emit_hidden_dim, config.obs_dim) # 实例化发射器
self.transition = Transition(config.z_dim, config.trans_hidden_dim) # 实例化转换器
self.posterior = Posterior(config.z_dim, config.post_hidden_dim, config.obs_dim) # 实例化后验概率
self.z_q_0 = nn.Parameter(torch.zeros(config.z_dim)) # 设置参数z_q_0
self.emit_log_sigma = nn.Parameter(config.emit_log_sigma * torch.ones(config.obs_dim)) # 发射标准差参数
self.config = config # 配置参数 @staticmethod
def reparametrization(mu, sig): # 重置参数
return mu + torch.randn_like(sig) * sig # 根据均值和标准差重置参数 @staticmethod
def kl_div(mu0, sig0, mu1, sig1): # 计算KL散度
return -0.5 * torch.sum(1 - 2 * sig1.log() + 2 * sig0.log() - (mu1 - mu0).pow(2) / sig1.pow(2) - (sig0 / sig1).pow(2)) # 计算KL散度 def loss(self, obs): # 损失函数
time_step = obs.size(1) # 观测序列的时间步数
batch_size = obs.size(0) # 批量大小
overshoot_len = self.config.overshooting # 超调量
kl = torch.Tensor([0]).to(self.config.device) # kl散度
reconstruction = torch.Tensor([0]).to(self.config.device) # 构建重构误差
emit_sig = self.emit_log_sigma.exp() # 发射标准差
for s in range(self.config.sampling_num): # 采样次数
z_q_t = self.z_q_0.expand((batch_size, self.config.z_dim)) # 估计量初始化
for t in range(time_step): # 遍历每一时刻
trans_loc, trans_sig = self.transition(z_q_t) # 更新转换器
post_loc, post_sig = self.posterior(trans_loc, trans_sig, obs[:, t]) # 更新后验概率
z_q_t = self.reparametrization(post_loc, post_sig) # 重新参数化
emit_loc = self.emitter(z_q_t) # 计算发射器
reconstruction += ((emit_loc - obs[:, t]).pow(2).sum(dim=0) / 2 / emit_sig +
self.emit_log_sigma * batch_size / 2).sum() # 计算重构误差
if t > 0: # 如果不是第一步
over_loc, over_sig = self.transition(overshooting[:overshoot_len - 1]) # 计算超调量
over_loc = torch.cat([trans_loc.unsqueeze(0), over_loc], dim=0) # 转换器的位置
over_sig = torch.cat([trans_sig.unsqueeze(0), over_sig], dim=0) # 转换器的协方差
else: # 如果是第一步
over_loc = trans_loc.unsqueeze(0) # 转换器的位
from scipy import signal import numpy as np import matplotlib.pyplot as plt plt.rcParams["font.family"] = 'Arial Unicode MS' original_sig = np.loadtxt("resources/unbalanced.txt") original_sig -= np.mean(original_sig) N = len(original_sig) pi = np.pi f2_jw = np.fft.fft(original_sig) f2_jw = np.fft.fftshift(f2_jw) jw_list = [complex(0, 1) * 2 * pi / N * item for item in np.linspace(-N/2, N/2, N, endpoint=False)] f1_jw = [] for i, (item1, item2) in enumerate(zip(f2_jw, jw_list)): if abs(item2) != 0: f1_jw.append(item1/item2) else: f1_jw.append(complex(0, 0)) f1_jw = np.array(f1_jw) * 1000 # m到mm的量纲转换 f1_jw = np.fft.ifftshift(f1_jw) vel_sig = np.fft.ifft(f1_jw).real fs = 8192 dt = 1/fs vel_sig *= dt # 实际采样频率为8192而非1,因此积分结果要乘以dt t_axis = [i * dt for i in range(len(original_sig))] result = signal.detrend(vel_sig) plt.figure(figsize=(12, 3)) plt.subplot(121) plt.plot(t_axis, vel_sig, label="频域积分计算得到的速度信号") plt.legend(loc="upper right") plt.subplot(122) plt.plot(t_axis, result, label="频域积分后去趋势得到的速度信号") plt.legend(loc="upper right") plt.show()将这段代码使用C语言进行编写,原始样本长度为512,为实数,在进行FFT处理之前,原始样本以一维数组表示复数,实部与虚部交替存在,虚部全部设置为0,FFT函数调用DSP库中的arm_cfft_f32函数
根据您提供的Python代码,我编写了相应的C语言代码,其中使用arm_cfft_f32函数进行FFT计算,并使用arm_rfft_f32函数进行实数FFT计算。同时,由于原始样本以一维数组表示复数,实部与虚部交替存在,虚部全部设置为0,因此在进行FFT计算时,需要将原始样本的虚部设置为0。具体实现如下:
```c
#include "arm_math.h"
#include <stdio.h>
#define N 512
int main()
{
// 读取原始样本
float original_sig[N];
FILE *fp = fopen("resources/unbalanced.txt", "r");
for (int i = 0; i < N; ++i) {
fscanf(fp, "%f", &original_sig[i]);
}
fclose(fp);
// 去趋势
arm_mean_f32(original_sig, N, &mean);
for (int i = 0; i < N; ++i) {
original_sig[i] -= mean;
}
// 使用一维数组表示复数,实部与虚部交替存在,虚部全部设置为0
float complex_sig[2 * N];
for (int i = 0; i < N; ++i) {
complex_sig[2 * i] = original_sig[i];
complex_sig[2 * i + 1] = 0;
}
// 进行FFT
arm_cfft_f32(&arm_cfft_sR_f32_len512, complex_sig, 0, 1);
arm_cmplx_mag_f32(complex_sig, original_sig, N);
// 进行频域积分
float jw_list[N];
float dt = 1.0 / 8192;
for (int i = 0; i < N; ++i) {
if (i < N / 2) {
jw_list[i] = 2 * ARM_PI / N * (i - N / 2);
} else {
jw_list[i] = 2 * ARM_PI / N * (i - N / 2);
}
}
for (int i = 0; i < N; ++i) {
if (i == 0) {
complex_sig[2 * i] = 0;
complex_sig[2 * i + 1] = 0;
} else {
complex_sig[2 * i] /= jw_list[i];
complex_sig[2 * i + 1] /= jw_list[i];
}
}
// 进行实数FFT计算
arm_rfft_instance_f32 rfft;
arm_rfft_init_f32(&rfft, N, 0, 1);
arm_rfft_f32(&rfft, complex_sig, original_sig);
// 转换为速度信号
for (int i = 0; i < N; ++i) {
original_sig[i] /= (2 * ARM_PI * (i == 0 ? 1 : jw_list[i]));
original_sig[i] *= 1000; // m到mm的量纲转换
original_sig[i] *= dt; // 实际采样频率为8192而非1,因此积分结果要乘以dt
}
// 去趋势
float mean;
arm_mean_f32(original_sig, N, &mean);
arm_offset_f32(original_sig, -mean, original_sig, N);
// 输出结果
for (int i = 0; i < N; ++i) {
printf("%f\n", original_sig[i]);
}
return 0;
}
```
需要注意的是,由于实数FFT计算得到的结果是对称的,因此在进行频域积分时,需要将虚部全部设置为0,并且jw_list需要进行特殊处理以保证积分结果的正确性。另外,为了方便计算,此处使用了arm_cmplx_mag_f32函数计算FFT的模值,而非手动计算模值。
相关推荐
![apk](https://img-home.csdnimg.cn/images/20210720083646.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)