added alternative#

app.py

@@ -4,9 +4,12 @@ import csv
 import json
 import torch
 import numpy as np
+import pandas as pd
 import gradio as gr
 
 from phate import PHATEAE
+from pytvlwcharts import *
+from pandas import Timestamp
 from funcs.som import ClusterSOM
 from funcs.tools import numpy_to_native
 
@@ -14,6 +17,7 @@ from funcs.processor import process_data
 from funcs.plot_func import plot_sensor_data_from_json
 from funcs.dataloader import BaseDataset2, read_json_files
 
+
 DEVICE = torch.device("cpu")
 reducer10d = PHATEAE(epochs=30, n_components=10, lr=.0001, batch_size=128, t='auto', knn=8, relax=True, metric='euclidean')
 reducer10d.load('models/r10d_6.pth')
@@ -133,6 +137,43 @@ def process_som_data(data, prediction):
 
     return processed_data
 
+def scores_to_dataframe(scores, start_time='2022-07-01 09:15:00+05:30', start_score=100, none_replacement=-0):
+    # Create a timestamp for every score in the list
+    timestamps = [pd.Timestamp(start_time) + pd.Timedelta(seconds=i) for i in range(len(scores))]
+
+    # Convert timestamps to unix timestamps
+    unix_timestamps = [int(ts.value // 10**9) for ts in timestamps]
+
+    # Initialize open prices list
+    open_prices = [start_score]
+
+    # Calculate open and close prices
+    for i in range(1, len(scores)):
+        if scores[i-1] is not None:
+            open_prices.append(open_prices[i-1] + scores[i-1])
+        else:
+            open_prices.append(open_prices[i-1])
+
+    close_prices = [open + (score if score is not None else none_replacement) for open, score in zip(open_prices, scores)]
+
+    # Create high and low prices
+    high_prices = [max(open, close) for open, close in zip(open_prices, close_prices)]
+    low_prices = [min(open, close) for open, close in zip(open_prices, close_prices)]
+    
+    # Create a dataframe
+    df = pd.DataFrame({
+        'time': unix_timestamps,
+        'open': open_prices,
+        'high': high_prices,
+        'low': low_prices,
+        'close': close_prices
+    })
+    
+    # Start index from 1
+    df.index += 1
+
+    return df
+
 def get_som_mp4_v2(csv_file_box, slice_size_slider, sample_rate, window_size_slider, reducer=reducer10d, cluster=cluster_som):
     processed_file_box, json_file_box, slices_per_leg, plot_box_leg, plot_box_overlay, slice_slider, plot_slice_leg, get_all_slice, slice_json_box = process_data(csv_file_box, slice_size_slider, sample_rate, window_size_slider)
 
@@ -161,8 +202,17 @@ def get_som_mp4_v2(csv_file_box, slice_size_slider, sample_rate, window_size_sli
     prediction = cluster_som.predict(embedding10d)
     processed_data = process_som_data(data,prediction)
 
+    scores      = cluster_som.score(embedding10d, threshold_radius=8.5)
+    scores_df   = scores_to_dataframe(scores)
+    DailyChart  = Chart(data=scores_df, width = 1360, height = 500,
+                        time_scale=TimeScaleOptions(seconds_visible=True, 
+                                                    time_visible=True)).mark_candlestick()
+
     # Write the processed data to a CSV file
-    header = ['Gait', 'TS', 'State', 'Condition', 'Shape1', 'Shape2', 'Shape3', 'Shape4', 'Color1', 'Color2', 'Color3', 'Color4', 'Danger1', 'Danger2', 'Danger3', 'Danger4']
+    header = ['Gait', 'TS', 'State', 'Condition', 
+              'Shape1', 'Shape2', 'Shape3', 'Shape4', 
+              'Color1', 'Color2', 'Color3', 'Color4', 
+              'Danger1', 'Danger2', 'Danger3', 'Danger4']
     with open('animation_table.csv', 'w', newline='') as csvfile:
         csv_writer = csv.writer(csvfile)
         csv_writer.writerow(header)
@@ -174,7 +224,7 @@ def get_som_mp4_v2(csv_file_box, slice_size_slider, sample_rate, window_size_sli
     som_video = cluster.plot_activation(embedding10d)
     som_video.write_videofile('som_sequence.mp4')
         
-    return processed_file_box, json_file_box, slices_per_leg, plot_box_leg, plot_box_overlay, slice_slider, plot_slice_leg, get_all_slice, slice_json_box, 'som_sequence.mp4', 'animation.mp4'
+    return processed_file_box, json_file_box, slices_per_leg, plot_box_leg, plot_box_overlay, slice_slider, plot_slice_leg, get_all_slice, slice_json_box, 'som_sequence.mp4', 'animation.mp4', DailyChart
     return processed_file_box, json_file_box, slices_per_leg, plot_box_leg, plot_box_overlay, slice_slider, plot_slice_leg, get_all_slice, slice_json_box, 'som_sequence.mp4', None
 
 # ml inference
@@ -232,7 +282,7 @@ with gr.Blocks(title='Cabasus') as cabasus_sensor:
 
         with gr.Row():
             real_video = gr.Video(label='real video')
-            trend_graph = gr.Video(label='trend graph')
+            trend_graph = gr.Plot(label='trend graph')
 
         plot_box_leg = gr.Plot(label="Filtered Signal Plot")
         slice_slider = gr.Slider(minimum=1, maximum=300, label='Slice select', step=1)
@@ -282,7 +332,7 @@ with gr.Blocks(title='Cabasus') as cabasus_sensor:
         #redoing the whole calculation with the file loading
         csv_file_box.change(get_som_mp4_v2, inputs=[csv_file_box, slice_size_slider, sample_rate, window_size_slider], 
                          outputs=[processed_file_box, json_file_box, slices_per_leg, plot_box_leg, plot_box_overlay, slice_slider, plot_slice_leg, get_all_slice, slice_json_box,
-                                  activation_video, animation])
+                                  activation_video, animation, trend_graph])
 
         button_label_Add.click(attach_label_to_json, inputs=[slice_json_box, label_name], outputs=[slice_json_label_box])
 

funcs/som.py

@@ -65,6 +65,46 @@ class ClusterSOM:
                 results.append((-1, None))  # Noise
 
         return results
+    
+    def score(self, data, midpoints=None, threshold_radius=4):
+        """
+        Compute the score for each sample in the data based on the distance of the BMU node to the closest midpoint of the SOM grid.
+        
+        :param data: The input data.
+        :param midpoints: A dictionary with keys as the indices of the SOMs and values as lists of midpoints on the grid for the corresponding SOMs.
+        :param threshold_radius: The threshold radius for score calculation.
+        """
+        scores = []
+
+        for sample in data:
+            # Predict the cluster and BMU SOM coordinate for each sample in the data
+            result = self.predict([sample])[0]
+
+            # Check if it is not a noise
+            if result[0] != -1:
+                # The activated SOM's index and its corresponding BMU
+                activated_som_index, bmu = result[0], result[1]
+
+                # Get the corresponding SOM for the data point
+                som = self.som_models[activated_som_index]
+
+                # If specific midpoints are provided for SOMs, use them; else compute the midpoint of the SOM grid
+                if midpoints is not None and activated_som_index in midpoints:
+                    specified_midpoints = midpoints[activated_som_index]
+                else:
+                    specified_midpoints = [tuple((dim-1)/2 for dim in som.get_weights().shape[:2])]
+
+                # Compute the grid distances from the BMU to each midpoint and find the minimum distance
+                min_distance = min(np.sqrt((midpoint[0] - bmu[0])**2 + (midpoint[1] - bmu[1])**2) for midpoint in specified_midpoints)
+
+                # Compute the score as the minimum grid distance minus the threshold radius
+                score = min_distance - threshold_radius
+
+                scores.append(score)
+            else:
+                scores.append(None)  # Noise
+
+        return scores
 
     # rearranging the subplots in the closest square format
     def rearrange_subplots(self, num_subplots):