added revisions

app.py

@@ -93,13 +93,13 @@ def process_som_data(data, prediction):
 
     return processed_data
 
-# ml inference
-def get_som_mp4(file, slice_select, reducer=reducer10d, cluster=cluster_som):
+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)
 
     try:
-        train_x, train_y  = read_json_files(file)
+        train_x, train_y  = read_json_files(json_file_box)
     except:
-        train_x, train_y  = read_json_files(file.name)
+        train_x, train_y  = read_json_files(json_file_box.name)
 
     # Convert tensors to numpy arrays if necessary
     if isinstance(train_x, torch.Tensor):
@@ -126,6 +126,44 @@ def get_som_mp4(file, slice_select, reducer=reducer10d, cluster=cluster_som):
     
     os.system('curl -X POST -F "csv_file=@animation_table.csv" https://metric-space.ngrok.io/generate --output animation.mp4')
 
+    # prediction = cluster_som.predict(embedding10d)
+    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'
+
+# ml inference
+def get_som_mp4(file, slice_select, reducer=reducer10d, cluster=cluster_som):
+    try:
+        train_x, train_y  = read_json_files(file)
+    except:
+        train_x, train_y  = read_json_files(file.name)
+
+    # Convert tensors to numpy arrays if necessary
+    if isinstance(train_x, torch.Tensor):
+        train_x = train_x.numpy()
+    if isinstance(train_y, torch.Tensor):
+        train_y = train_y.numpy()
+
+    # load the time series slices of the data 4*3*2*64 (feeds+axis*sensor*samples) + 5 for time diff
+    data = BaseDataset2(train_x.reshape(len(train_x), -1) / 32768, train_y)
+
+    #compute the 10 dimensional embeding vector
+    embedding10d = reducer.transform(data)
+
+    # retrieve the prediction and get the animation
+    prediction = cluster_som.predict(embedding10d)
+    processed_data = process_som_data(data,prediction)
+
+    # 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']
+    # with open('animation_table.csv', 'w', newline='') as csvfile:
+    #     csv_writer = csv.writer(csvfile)
+    #     csv_writer.writerow(header)
+    #     csv_writer.writerows(processed_data)
+    
+    # os.system('curl -X POST -F "csv_file=@animation_table.csv" https://metric-space.ngrok.io/generate --output animation.mp4')
+
     # prediction = cluster_som.predict(embedding10d)
     fig = cluster.plot_activation_v2(embedding10d, slice_select)
 
@@ -157,6 +195,10 @@ with gr.Blocks(title='Cabasus') as cabasus_sensor:
                 processed_file_box = gr.File(label='Processed CSV File') 
                 json_file_box = gr.File(label='Generated Json file')
 
+        with gr.Row():
+            animation = gr.Video(label='animation')
+            activation_video = gr.Video(label='real')
+
         plot_box_leg = gr.Plot(label="Filtered Signal Plot")
         slice_slider = gr.Slider(minimum=1, maximum=300, label='Slice select', step=1)
 
@@ -187,14 +229,12 @@ with gr.Blocks(title='Cabasus') as cabasus_sensor:
                 button_label_Add = gr.Button('attach label')
             slice_json_label_box = gr.File(label='Slice json labelled file')
 
-        with gr.Row():
-            animation = gr.Video(label='animation')
-            real_video = gr.Video(label='real')
+        
         
         slices_per_leg = gr.Textbox(label="Debug information")
         
-        csv_file_box.change(process_data, 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])
+        # csv_file_box.change(process_data, 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])
         leg_dropdown.change(plot_sensor_data_from_json, inputs=[json_file_box, leg_dropdown, slice_slider], 
                             outputs=[plot_box_leg, plot_slice_leg, get_all_slice, slice_json_box, plot_box_overlay])
         repeat_process.click(process_data, inputs=[csv_file_box, slice_size_slider, sample_rate, window_size_slider], 
@@ -203,6 +243,12 @@ with gr.Blocks(title='Cabasus') as cabasus_sensor:
                             outputs=[plot_box_leg, plot_slice_leg, get_all_slice, slice_json_box, plot_box_overlay])
         
         som_create.click(get_som_mp4, inputs=[json_file_box, slice_slider], outputs=[som_figures, animation])
+
+        #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])
+
         button_label_Add.click(attach_label_to_json, inputs=[slice_json_box, label_name], outputs=[slice_json_label_box])
 
 cabasus_sensor.queue(concurrency_count=2).launch(debug=True)

funcs/plot_func.py

@@ -44,9 +44,9 @@ def plot_sensor_data_from_json(json_file, sensor, slice_select=1):
     ax = plt.plot(data['time'].to_list(), data[sensor].to_list(), '-b')
 
     df_temp = data[data['slice selection'] == int(slice_select)].reset_index()
-    y = [np.NaN]*((int(slice_select)-1)*len(df_temp[sensor].to_list())) + df_temp[sensor].to_list() + [np.NaN]*((len(slices) - int(slice_select))*len(df_temp[sensor].to_list()))
-    x = data['time'].to_list()
-    ax = plt.plot(x, y, '-')
+    # y = [np.NaN]*((int(slice_select)-1)*len(df_temp[sensor].to_list())) + df_temp[sensor].to_list() + [np.NaN]*((len(slices) - int(slice_select))*len(df_temp[sensor].to_list()))
+    # x = data['time'].to_list()
+    # ax = plt.plot(x, y, '-')
     
     plt.xlabel("Timestamp")
     plt.ylabel(sensor)

funcs/som.py

@@ -15,7 +15,7 @@ from sklearn.datasets import make_blobs
 from sklearn.preprocessing import LabelEncoder
 from sklearn.cluster import KMeans
 from sklearn.semi_supervised import LabelSpreading
-from moviepy.editor import *
+from moviepy.editor import ImageSequenceClip
 
 class ClusterSOM:
     def __init__(self):
@@ -390,20 +390,26 @@ class ClusterSOM:
             img = imageio.imread(buf)
             images.append(img)
             plt.close()
+        
+        # Create the video using moviepy and save it as a mp4 file
+        video = ImageSequenceClip(images, fps=1) 
+
+        return video
+
 
-        # Save the images as a GIF
-        imageio.mimsave(f"{filename}.gif", images, duration=500, loop=1)
+        # # Save the images as a GIF
+        # imageio.mimsave(f"{filename}.gif", images, duration=500, loop=1)
 
-        # Load the gif
-        gif_file = f"{filename}.gif"  # Replace with the path to your GIF file
-        clip = VideoFileClip(gif_file)
+        # # Load the gif
+        # gif_file = f"{filename}.gif"  # Replace with the path to your GIF file
+        # clip = VideoFileClip(gif_file)
 
-        # Convert the gif to mp4
-        mp4_file = f"{filename}.mp4"  # Replace with the desired output path
-        clip.write_videofile(mp4_file, codec='libx264')
+        # # Convert the gif to mp4
+        # mp4_file = f"{filename}.mp4"  # Replace with the desired output path
+        # clip.write_videofile(mp4_file, codec='libx264')
 
-        # Close the clip to release resources
-        clip.close()
+        # # Close the clip to release resources
+        # clip.close()
 
     def save(self, file_path):
         """
@@ -470,4 +476,48 @@ class ClusterSOM:
 
         plt.tight_layout()
 
+        return fig
+    
+    def plot_activation_v3(self, data, slice_select):
+        """
+        Generate a GIF visualization of the prediction output using the activation maps of individual SOMs.
+        """
+        if len(self.som_models) == 0:
+            raise ValueError("SOM models not trained yet.")
+        
+        try:
+            prediction = self.predict([data[int(slice_select)-1]])[0]
+        except:
+            prediction = self.predict([data[int(slice_select)-2]])[0]
+
+        fig, axes = plt.subplots(1, len(self.som_models), figsize=(20, 5), sharex=True, sharey=True)
+        fig.suptitle(f"Activation map for SOM {prediction[0]}, node {prediction[1]}", fontsize=16)
+
+        for idx, (som_key, som) in enumerate(self.som_models.items()):
+            ax = axes[idx]
+            activation_map = np.zeros(som._weights.shape[:2])
+            for x in range(som._weights.shape[0]):
+                for y in range(som._weights.shape[1]):
+                    activation_map[x, y] = np.linalg.norm(data[int(slice_select)-1] - som._weights[x, y])
+
+            winner = som.winner(data[int(slice_select)-1])  # Find the BMU for this SOM
+            activation_map[winner] = 0  # Set the BMU's value to 0 so it will be red in the colormap
+
+            if som_key == prediction[0]:  # Active SOM
+                im_active = ax.imshow(activation_map, cmap='viridis', origin='lower', interpolation='none')
+                ax.plot(winner[1], winner[0], 'r+')  # Mark the BMU with a red plus sign
+                ax.set_title(f"SOM {som_key}", color='blue', fontweight='bold')
+                if hasattr(self, 'label_centroids'):
+                    label_idx = self.label_encodings.inverse_transform([som_key - 1])[0]
+                    ax.set_xlabel(f"Label: {label_idx}", fontsize=12)
+            else:  # Inactive SOM
+                im_inactive = ax.imshow(activation_map, cmap='gray', origin='lower', interpolation='none')
+                ax.set_title(f"SOM {som_key}")
+
+            ax.set_xticks(range(activation_map.shape[1]))
+            ax.set_yticks(range(activation_map.shape[0]))
+            ax.grid(True, linestyle='-', linewidth=0.5)
+
+        plt.tight_layout()
+
         return fig