样本拟合正弦函数? 梯度下降法? NO,比梯度下降还快的算法.

假设样本数据是跟sin函数值相关的.
那么如何求这些数据的相位和振幅?还有频率?
搞了半天的梯度下降算法. 准备拟合出合适的参数值.
代码是人工智能生成的. 跑不通 , 自己改了一下也是跑不通. 因为sin函数的拟合牵扯到求偏导数. .
梯度下降算法的原理是通的. 可不知道是哪里的问题, loss先由大变小,然后由小变大. 最后跑飞了. 如此不稳定.

y = amplitude * sin(phase)

虽然想自己手撕梯度下降算法. 时间来不及,先用笨办法吧.
等有空再自己手撕一下线性函数 y = ax+b 的梯度下降算法的 c语言版本.
最后发现, 笨办法还挺快. 比梯度下降还靠谱.

说下大体流程.
第一步滤波, 把数据滤波成接近正弦曲线的波形. 这里面用到比较牛的算法. 由于牵扯到很多核心技术, 这里就不详细谈我是如何滤波的了.
第二步:求频率. 鉴相法,过零法,最大值法. 这里就不详细说了, 各位自己发挥.
第三步:求振幅. for循环求最大值即可.
第四步:求相位. 知道了前2个, 第三个更好求. 代码如下.
顺序不能乱.

测试下来,精度可以接受. 如果想精度高一些, 提高步进精度. 增加一些范围值的try.
梯度下降算法的运行时间受到初始值和真实值的影响, 运行时长不稳定.
这个算法就稳定多了.

#include <stdio.h>
#include <math.h>

#define PI 3.14159265
#define LEARNING_RATE 0.05
#define MAX_ITERATIONS 100000

/**
 * @brief 生成正弦波测试数据
 * 
 * @param data 存放生成的数据的数组
 * @param n 数据的长度 一共采样了多少个点
 * @param sample_rate 采样率 (每秒多少个点)
 * @param amplitude 正弦波的振幅 
 * @param phase 正弦波的初始相位
 * @param frequency 正弦波的频率 
*/
void generateSinData(float data[], int n, float sample_rate , float amplitude, float phase, float frequency) {  
    float time_step = 1.0f / sample_rate; // 每个样本的时间间隔（秒）  
    float a; // 角度（弧度制）  
    float zaosheng; // 噪声项  
      
    // 可选：设置随机数种子以确保每次运行都得到不同的随机噪声  
    // std::srand(static_cast<unsigned int>(std::time(nullptr)));  
  
    for (int i = 0; i < n; i++)
    {
        // 计算时间（秒），并转换为角度  
        float time = i * time_step;
        a = 2 * PI * frequency * time + phase;
          
        // 添加噪声项（如果需要的话）  
        // zaosheng = 0.1f * (static_cast<float>(std::rand()) / RAND_MAX - 0.5f);  
        zaosheng = 0; // 暂时设为0，如果你想添加噪声可以去掉注释  
          
        // 计算正弦波加上噪声  
        data[i] = amplitude * sin(a) + zaosheng;
    }
}


float getAngle( int i, float sample_rate ,   float phase, float frequency) {  
      float time_step = 1.0f / sample_rate; // 每个样本的时间间隔（秒）  
      float angle; // 角度（弧度制）    
      // 计算时间（秒），并转换为角度  
      float time = i * time_step;
      angle = 2 * PI * frequency * time + phase;   
      return angle;
}

float generateOneSinData( int i, float sample_rate , float amplitude, float phase, float frequency) {   
      float angle; // 角度（弧度制）     
      angle = getAngle( i, sample_rate,  phase, frequency );
      // 计算正弦波加上噪声  
      float data = amplitude * sin(angle) ;
      return data; 
}
 
/**
 * 定义损失函数
 * 计算预测值与实际值的差异
*/
float calculateLoss(float data[], float yuce_data[], int data_length ) {
    float loss = 0;
    for (int i = 0; i < data_length; i++) {
        // 计算预测值与实际值的差异 
        float difference = fabs(data[i] - yuce_data[i]);    
        loss += difference ; 
    }
    return loss;
}


/**
 * 计算最大振幅
 * 
 * @param data 存放生成的数据的数组
 * @param data_length 数据的长度 一共采样了多少个点
 * @return 最大振幅
*/
float getMaxAmplitude(float data[], int data_length) {
    float max_amplitude = 0;
    for (int i = 0; i < data_length; i++) {
        if (fabs(data[i]) > max_amplitude) {
            max_amplitude = fabs(data[i]);
        }
    }
}

/**
 * @brief 尝试所有相位和振幅组合，寻找最佳参数
 * 
 * @param data 存放生成的数据的数组
 * @param amplitude 存放最佳振幅的指针
 * @param phase 存放最佳相位的指针
 * @param frequency 存放最佳频率的指针
 * @param sample_rate 采样率 (每秒多少个点)
 * @param sample_length 数据的长度 一共采样了多少个点
*/
void tryAllPhaseAndAmp(float adc_data[],  float *amplitude, float *phase, float *frequency, float sample_rate, int sample_length) 
{
    // 初始化梯度 
    float yuce_data[2000] = {0}; // 存放预测的数据的数组, 2000个采样点 一般不会超过这个值
    float min_loss=1000000; // 损失函数

    float max_amplitude = getMaxAmplitude(adc_data,sample_length);
	
	int step = 10;
	int phase_start = 1;
	int phase_end = 360;
	int phase_iter = phase_start ;
	int phase_iter_min=1;
	while(step > 1)
	{
		    // 计算预测值
		    // 遍历360个角度
		    for(phase_iter = phase_start ; phase_iter < phase_end ; phase_iter = phase_iter + step )
		    {  
		        // 角度转弧度
		        float phase_iter_rad = phase_iter * PI / 180;
		        float amp = max_amplitude;
		        // 遍历20个振幅
		        //for (int amp = max_amplitude - 1; amp < max_amplitude + 2; amp++)
		        {
		            // 计算预测值
		            generateSinData(yuce_data, sample_length,  sample_rate,  amp,  phase_iter_rad,  *frequency);
		            // 计算预测值与实际值的差异
		            float loss = calculateLoss(adc_data, yuce_data, sample_length);
		            //printf("amp:%d ,phase:%d, loss is %f \n", amp, phase_iter, loss);
		            if(loss < min_loss)
		            {
		                // printf("find it %f !\n",min_loss);
		                phase_iter_min = phase_iter;
		                min_loss = loss;
		                *amplitude = amp;
		                *phase = phase_iter;
		                *frequency = *frequency;
		            }
		        } 
		    }
		    
		    //第二次迭代, 值迭代10个角度 . 这样可以减少360 - (36+10) = 314 减少314次迭代.如果改成2分法还可以减少计算量,太复杂的算法暂时就不考虑了,目前已经够用了 (给自己攒点头发.)
			step  = 1;
			phase_start = phase_iter_min - 5;
			phase_end =  phase_iter_min + 5; 
     }
 
}
 

#define    demo_sample_length  2000 
#define    demo_sample_rate 1000.0f 

int main_demo_try_all() 
//int main() 
{

    float data[demo_sample_length];
    float amplitude = 44.0; // 初始振幅
    float phase = 0.5 * PI;  // 初始相位
    float frequency = 10.0; // 初始频率

    generateSinData(data, demo_sample_length, demo_sample_rate, amplitude, phase,frequency);

    //输出data到文件
    FILE *fp;
    fp = fopen("data.txt", "w");
    for (int i = 0; i < demo_sample_length; i++) {
        fprintf(fp, "%f\n", data[i]);
    }
    fclose(fp);

    printf("Original Amplitude: %f\n", amplitude);
    printf("Original Phase: %f\n", phase);
    printf("Original Frequency: %f\n", frequency);

    amplitude=1;
    phase=1;
    //frequency=1;

    tryAllPhaseAndAmp(data, &amplitude, &phase, &frequency, demo_sample_rate, demo_sample_length);

    // 找到了最佳参数 
    printf("Final Amplitude: %f\n", amplitude);
    printf("Final Phase: %f\n", phase);
    printf("Final Frequency: %f\n", frequency);
  
    return 0;
}