Python实现ISOS-VMD信号分解降噪（完整源码和数据)

#!/usr/bin/env python # coding: utf-8 # In[1]: import copy # 导入copy模块，用于复制对象 import numpy # 导入numpy库，用于数值计算 import random # 导入random模块，用于生成随机数 import datetime#更多模型咸鱼搜索机器学习之心，支持模型定制 # 导入datetime模块，用于处理日期和时间 import math # 导入math模块，提供数学计算函数 import pandas as pd # 导入pandas库，用于数据处理和分析 import numpy as np # 导入numpy库，用于数值计算 import matplotlib.pyplot as plt # 导入matplotlib库，用于数据可视化 from vmdpy import VMD # 从vmdpy模块中导入VMD类，用于执行VMD分解 import tensorflow as tf # 导入tensorflow库，用于构建和训练神经网络模型 import warnings # 导入warnings模块，用于控制警告的显示 from scipy.fftpack import hilbert, fft, ifft # 从scipy.fftpack模块中导入hilbert、fft、ifft函数，用于信号处理中的傅里叶变换 from math import log # 导入math模块中的log函数，用于计算对数 from typing import List # 导入typing模块中的List类型，用于注释函数参数的类型 warnings.filterwarnings("ignore") # 忽略警告信息，不显示警告 # In[2]: # 从CSV文件中读取数据，仅使用第一列和第二列 data = pd.read_csv('A.csv', usecols=[0, 1]) #更多模型咸鱼搜索机器学习之心，支持模型定制 # 创建一个Series对象，使用'A'列的值作为数据，'time'列的值作为索引 series_close = pd.Series(data['A'].values, index=data['time']) # In[3]: tau = 0. # 设置tau的初始值为0。 #更多模型咸鱼搜索机器学习之心，支持模型定制 DC = 0 # 设置DC的初始值为0。 init = 1 # 设置init的初始值为1。 tol = 1e-7 # 设置tol的值为1e-7，表示容差的阈值。 # In[4]: class ProblemModel: def __init__(self, bounds=None): self.bounds = bounds #更多模型咸鱼搜索机器学习之心，支持模型定制 def check_boundaries(self, value, index): lower_bound, upper_bound = self.bounds[index] if value < lower_bound: return lower_bound elif value > upper_bound: return upper_bound else: return value def evaluate(self, solution): if len(solution) == 2: K = int(solution[0]) alpha = solution[1] if K < self.bounds[0][0]: K = self.bounds[0][0] if K > self.bounds[0][1]: K = self.bounds[0][1] if alpha < self.bounds[1][0]: alpha = self.bounds[1][0] if alpha > self.bounds[1][1]: alpha =self.bounds[1][1] u, u_hat, omega = VMD(data['A'], alpha, tau, K, DC, init, tol) # EP = []#更多模型咸鱼搜索机器学习之心，支持模型定制 for i in range(K): H = np.abs(hilbert(u[i,:])) e1 = [] for j in range(len(H)): p = H[j]/np.sum(H) e = -p*log(p,2) e1.append(e) E = np.sum(e1) EP.append(E) s = np.sum(EP)/K return s else: return 1 #更多模型咸鱼搜索机器学习之心，支持模型定制 # In[5]: class NectarSource: problem_src = None def __init__(self, position): self.position = position self.value = self.problem_src.getValue(position) if self.value >= 0: self.fitness = 1/(1+self.value) else: self.fitness = 1+math.fabs(self.value) self.trail = 0 # In[6]: class SOSAlgor: def __init__(self, problem, population_size, max_iteration): self.problem = problem self.population_size = population_size self.max_iteration = max_iteration self.population = self.initialize_population() self.best_solution = self.population[0] self.result_record = [] def evaluate_population(self): return [self.problem.evaluate(solution) for solution in self.population] def initialize_population(self): population = []#更多模型咸鱼搜索机器学习之心，支持模型定制 for i in range(self.population_size): solution = [] for j in range(len(self.problem.bounds)): lower_bound, upper_bound = self.problem.bounds[j] # Sine-Tent-Cosine混沌映射系统 x = 0.2 for _ in range(100): x = (np.sin(np.pi * x) + np.tan(np.pi * x)) / (np.cos(np.pi * x) + 1) value = lower_bound + x * (upper_bound - lower_bound) # 折射反向机制 if value < lower_bound or value > upper_bound: value = np.random.uniform(lower_bound, upper_bound) solution.append(value) population.append(solution) return population#更多模型咸鱼搜索机器学习之心，支持模型定制 def levy_flight(self, current_position): # Levy flight strategy beta = 1.5 sigma = (math.gamma(1 + beta) * math.sin(math.pi * beta / 2) / ( math.gamma((1 + beta) / 2) * beta * 2 ** ((beta - 1) / 2))) ** (1 / beta) u = np.random.normal(0, sigma, size=len(current_position)) v = np.random.normal(0, 1, size=len(current_position)) step = u / abs(v) ** (1 / beta) new_position = current_position + 0.01 * step return [self.problem.check_boundaries(value, j) for j, value in enumerate(new_position)] def run(self): for iteration in range(self.max_iteration): print(f'Iteration: {iteration}') fitness_values = self.evaluate_population() # Find the best solution in the current population best_index = fitness_values.index(min(fitness_values)) best_solution = self.population[best_index] #更多模型咸鱼搜索机器学习之心，支持模型定制 # Update the global best solution if self.problem.evaluate(best_solution) < self.problem.evaluate(self.best_solution): self.best_solution = best_solution # Update the result record self.result_record.append(self.problem.evaluate(self.best_solution)) # Symbiotic phase for i in range(self.population_size): partner_index = random.randint(0, self.population_size - 1) while partner_index == i: partner_index = random.randint(0, self.population_size - 1) # Levy flight step new_solution = self.levy_flight(self.population[i]) # Sine Cosine Optimization a = 2 - iteration * (2 / self.max_iteration) for j in range(len(self.population[i])): rand = random.random() if rand >= 0.5: if abs(new_solution[j] - self.population[i][j]) > 0: new_solution[j] = self.problem.check_boundaries(new_solution[j], j) #更多模型咸鱼搜索机器学习之心，支持模型定制 # Replace the current solution if the new solution is better if self.problem.evaluate(new_solution) < fitness_values[i]: self.population[i] = new_solution return self.best_solution, self.problem.evaluate(self.best_solution) def showResult(self): plt.plot(self.result_record) plt.title('Result Curve') plt.xlabel('Iteration') plt.ylabel('Objective Value') plt.tight_layout() plt.show() # In[7]: # 设置蜜蜂数量和最大迭代次数 beesNum = 5 maxIteration = 10 # 创建问题模型，设置变量的上下界 problem = ProblemModel(bounds=([3, 12], [100,