Create securecypher.space.py

securecypher.space.py

@@ -0,0 +1,145 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+import seaborn as sns
+
+class WaveformVisualizer:
+  def __init__(self, processor, input_data, sampling_rate=1000):
+    self.processor = processor
+    self.input_data = input_data
+    self.sampling_rate sampling_rate
+    self.time = np.arange(input_data.shape[1]) / sampling_rate
+
+class SecureWaveformProcessor(nn.Module):
+  def __init__(self, input_size, hidden_size, sampling_rate=1000):
+      super(SecureWaveformProcessor, self).__init__()
+      self.layer1 = nn.Linear(input_size, hidden_size)
+      self.layer2 = nn.Linear(hidden_size, input_size)
+      self.sampling_rate = sampling_rate
+
+  def forward(self, x):
+      x = torch.relu(self.layer1(x))
+      x = self.layer2(x)
+      return x
+
+  def plot_waveforms(self):
+      processed_data = self.forward(input_data)
+      self.time = np.arange(input_data.shape[1]) / self.sampling_rate
+
+  def forward(self, x):
+      x = torch.relu(self.layer1(x))
+      x = self.layer2(x)
+      return x
+
+  def plot_waveforms(self):
+      processed_data = self.forward(input_data)
+      self.time = np.arange(input_data.shape[1]) / self.sampling_rate
+      self.input_data = input_data
+
+      fig = plt.figure(figsize=(15, 10))
+      gs = fig.add_gridspec(2, 2, hspace=0.3, wspace=0.3)
+
+      ax1 = fig.add_subplot(gs[0, 0])
+      self._plot_waveform(self.input_data[0], ax1, "Original Data")
+
+      ax2 = fig.add_subplot(gs[0, 1])
+      self.plot_waveform(processed_data[0], ax2, "Processed Data")
+
+      ax3 = fig.add_subplot(gs[1, 0])
+      self._plot_spectrogram(self.input_data[0], ax3, "Original Visual")
+
+      ax4 = fig.add_subplot(gs[1, 1])
+      self._plot_spectrogram(processed_data[0], x4, "Processed Visual")
+
+      plt.tight_layout()
+      return fig
+
+  def _plot_waveform(self,data, ax, title):
+      data_np = data.detach().numpy()
+      ax.plot(self.time, data_np, 'b-', linewidth=1)
+      ax.set_title(title)
+      ax.set_xlabel('Time (s)')
+      ax.set_ylabel('Amplitude')
+      ax.grid(True)
+
+  def _plot_spectrogram(self, data, ax, title):
+      data_np = data.detach().numpy
+      ax.specgram(data,np, Fs=self.sampling_rate, cmap='viridis')
+      ax.set_title(title)
+      ax.set_xlabel('Time (s)')
+      ax.set_ylabel('Frequency (Hz)')
+
+  def animate_processing(self, frame=50):
+      fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))
+
+      processed_data = self.forward(self.input_data)
+      data_original = self.input_data[0].detach().numpy()
+      data_processed = processed_data[0].detach().numpy()
+
+      line1, = ax1.plot([], [], 'b-', label='Original')
+      line2, = ax2.plot([], [], 'r-', label='Processed')
+
+  def init():
+      ax1.set_xlim(0, self.time[-1])
+      ax1.set_ylim(data_original.min()*1.2, data_original.max()*1.2)
+      ax2.set_xlim(0, self.time[-1])
+      ax2.set_ylim(data_processed.min()*1.2, data_processed.max()*1.2)
+
+      ax1.set_title('Original Data')
+      ax2.set_title('Processed Visual')
+      ax1.grid(True)
+      ax2.grid(True)
+      ax1.legend()
+      ax2.legend()
+
+      return line1, line2
+
+  def animate(frame):
+      idx = int((frame / frames) * len(self.time))
+      line1.set_data(self.time[:idx], data_original[:idx])
+      line2.set_data(self.time[:idx], data_processed[:idx])
+      return line1, line2
+
+  anim = FuncAnimation(fig, animate, frames=frames,
+                      init_func=init, blit=True,
+                      interval=50)
+
+  plt.tight_layout()
+  return anim
+
+__name__== "__main__":
+  input_size = 1000
+  batch_size = 32
+  sampling_rate = 1000
+
+  processor = SecureWaveformProcessor(input_size=input_size, hidden_size=64, sampling_rate=sampling_rate)
+
+
+  t = np.linspace(0, 10, input_size)
+  base_signal = np.sin(2 * np.pi * 1 * t) + 0.5 * np.sin(2 * np.pi * 2 * t)
+  noise = np.random.normal(0, 0.1, input_size)
+  signal = base_signal + noise
+
+  input_data = torch.tensor(np.tile(signal, (batch_size, 1)), dtype=torch.float32)
+  processor = SecureWaveformProcessor(input_size=input_size, hidden_size=64)
+
+  visualizer = WaveformVisualizer(processor, input_data)
+
+  fig_static = processor.plot_waveforms()
+  plt.show()
+
+  anim = processor.animate_processing()
+  plt.show()
+  
+  
+      
+
+      
+  
+
+
+  
+
+