Upload 5 files

app.py

@@ -0,0 +1,36 @@
+import numpy as np
+import torch
+import gradio as gr
+
+from libs import *
+
+with gr.Blocks(title="Signal Similarity Live Demo") as demo:
+
+    default_fig, default_result = demo_fn()
+
+    with gr.Row():
+        signal_images = gr.Plot(default_fig,label="Visualize Signals")
+    with gr.Row():
+        singal_results = gr.Text(default_result, interactive=False)
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Ground Truth Control")
+            gt_button     = gr.Radio(["Sin", "Cos", "Random"], label="Signal Type", value="Sin")
+            gt_scale_slider  = gr.Slider(minimum=-2, maximum=2, step=0.1, label="Scaling Factor", value=1)
+            gt_shift_slider  = gr.Slider(minimum=-2, maximum=2, step=0.1, label="Shifting Factor",  value=0)
+        with gr.Column():
+            gr.Markdown("### Pred Signal Control")
+            signal_button = gr.Radio(["Sin", "Cos", "Random"], label="Signal Type",  value="Sin")
+            pred_scale_slider  = gr.Slider(minimum=-2, maximum=2, step=0.1, label="Scaling Factor", value=1)
+            pred_shift_slider  = gr.Slider(minimum=-2, maximum=2, step=0.1, label="Shifting Factor",  value=0)
+            
+    gt_button.change(fn=demo_fn, inputs=[gt_button, signal_button, gt_scale_slider, gt_shift_slider, pred_scale_slider, pred_shift_slider], outputs=[signal_images, singal_results])
+    signal_button.change(fn=demo_fn, inputs=[gt_button, signal_button, gt_scale_slider, gt_shift_slider, pred_scale_slider, pred_shift_slider], outputs=[signal_images, singal_results])
+    gt_scale_slider.change(fn=demo_fn, inputs=[gt_button, signal_button, gt_scale_slider, gt_shift_slider, pred_scale_slider, pred_shift_slider], outputs=[signal_images, singal_results])
+    gt_shift_slider.change(fn=demo_fn, inputs=[gt_button, signal_button, gt_scale_slider, gt_shift_slider, pred_scale_slider, pred_shift_slider], outputs=[signal_images, singal_results])
+    pred_scale_slider.change(fn=demo_fn, inputs=[gt_button, signal_button, gt_scale_slider, gt_shift_slider, pred_scale_slider, pred_shift_slider], outputs=[signal_images, singal_results])
+    pred_shift_slider.change(fn=demo_fn, inputs=[gt_button, signal_button, gt_scale_slider, gt_shift_slider, pred_scale_slider, pred_shift_slider], outputs=[signal_images, singal_results])
+
+
+demo.launch(share=True)

libs/__init__.py

@@ -0,0 +1,2 @@
+from .functions import *
+from .metrics import *

libs/functions.py

@@ -0,0 +1,44 @@
+import torch
+import matplotlib.pyplot as plt
+
+from .metrics import *
+
+SDSC = SignalDice()
+
+def calculate_fn(sig1, sig2):
+    mse = MSE(sig1, sig2)
+    mae = MAE(sig1, sig2)
+    sdsc = SDSC(sig1, sig2)
+
+    return f"MSE: {mse:.4f}, MAE: {mae:.4f}, SDSC: {sdsc:.4f}"
+
+
+def demo_fn( gt_radio:str='Sin',
+             pred_radio:str='Sin', 
+             gt_scale:float=1.0, 
+             gt_shift:float=0.0, 
+             pred_scale:float=1.0, 
+             pred_shift:float=0.0):
+    t = torch.linspace(0,2*np.pi, 1000) 
+
+    signals = {
+        "Sin" : torch.sin(t),
+        "Cos" : torch.cos(t),
+        "Random": torch.randn_like(t)
+    }
+
+    gt = signals[gt_radio] * gt_scale + gt_shift
+    pred = signals[pred_radio] * pred_scale + pred_shift
+
+    result_strings = calculate_fn(gt, pred)
+
+    # Draw Image
+    fig = plt.figure()
+    plt.plot(t, gt.numpy(), label="Ground Truth")
+    plt.plot(t, pred.numpy(), ":", label="Pred Signals")
+    plt.axhline(0, c="k", ls=":")
+    plt.legend()
+    plt.close()
+    
+    
+    return fig, result_strings

libs/metrics.py

@@ -0,0 +1,45 @@
+import os
+import numpy as np
+import torch
+import torch.nn as nn
+
+def MSE(gt:torch.Tensor, pred:torch.Tensor) -> np.float32:
+   r"""
+   Simple MSE Function
+   """ 
+   return torch.mean(torch.square(gt - pred)).item()
+
+def MAE(gt:np.array, pred:np.array) -> np.float32:
+   r"""
+   Simple MAE Function
+   """
+   return torch.mean(torch.abs(gt - pred)).item()
+
+
+class SignalDice(nn.Module):
+    def __init__(self, eps=1e-6):
+        super(SignalDice,self).__init__()
+        self.eps = eps
+    
+    def calc_inter(self, a, b, same_sign_mat):
+        a = a * same_sign_mat
+        b = b * same_sign_mat
+        return torch.where(a >= b, b, a)
+
+    def calc_union(self, a, b):
+        return a + b
+    
+    def forward(self, inputs:torch.Tensor, targets:torch.Tensor)->np.float32:
+        # Make abs value
+        in_abs = torch.abs(inputs)
+        tar_abs = torch.abs(targets)
+
+        # Make Heaviside Matrix
+        with torch.no_grad():
+            same_sign_mat = torch.heaviside(inputs * targets, torch.tensor([0.]))
+
+        self.intersection = self.calc_inter(in_abs, tar_abs, same_sign_mat) 
+        self.union        = self.calc_union(in_abs, tar_abs)
+       
+        return torch.mean((2 * torch.sum(self.intersection) + self.eps) / (torch.sum(self.union) + self.eps)).item()
+