sync

Author: krishnachaitanya7

sqlite_db/sqlite_utils.py

@@ -5,21 +5,48 @@
 
 
 class SQLDb:
+    """
+    SQLite database handler for managing TSNE data visualization points.
+    Provides methods for creating, storing, and retrieving 3D visualization data
+    with associated metadata like original labels and classified labels.
+    """
+
     def __init__(self, table_name="", db_path="manifolk.db", create_table=True):
+        # The commented code below was likely a path validation check
         # if not Path(db_path).is_file():
         #     raise Exception(f"The Database path should be a full path of a file even if it doesnt exist. "
         #                     f"A new databse will be created at that path. Please pass full file path name")
+
+        # Store the database file path
         self.db_path = db_path
+
+        # Create a unique table name by appending current timestamp to avoid collisions
         datetime_now = datetime.now().strftime("%Y-%m-%d-%H:%M:%S")
         self.table_name = f"[{table_name}_{datetime_now}]"
+
+        # Initialize connection objects to None
         self.conn = None
         self.table_cursor = None
+
+        # Optionally create the table immediately (default behavior)
         if create_table:
             self.create_table()
 
     def create_table(self):
+        """
+        Create a new SQLite table with the schema needed for storing TSNE visualization data.
+        Schema includes:
+        - epoch: training epoch/iteration number
+        - X, Y, Z: 3D coordinates for visualization
+        - DATAPOINT_NAME: unique identifier for each data point
+        - ORIGINAL_LABEL: ground truth label
+        - CLASSIFIED_AS_LABEL: model's predicted label
+        """
+        # Establish connection to the SQLite database
         self.conn = sqlite3.connect(self.db_path)
         self.table_cursor = self.conn.cursor()
+
+        # Execute SQL to create the table with required columns
         self.table_cursor.execute(
             f"CREATE TABLE "
             f"{self.table_name} "
@@ -31,40 +58,79 @@ def create_table(self):
             f"ORIGINAL_LABEL text, "
             f"CLASSIFIED_AS_LABEL text)"
         )
+        # Commit the changes to the database
         self.conn.commit()
 
     def sanitize_input(self, *args):
+        """
+        Validate input types before inserting into the database.
+        Ensures data integrity by checking that each value has the expected type.
+
+        Args:
+            *args: A sequence of values to validate in the following order:
+                  epoch (int), x (float), y (float), z (float),
+                  datapoint_name (str), original_label (str), classified_label (str)
+
+        Raises:
+            Exception: If any input value doesn't match its expected type
+        """
+        # Validate epoch is an integer
         epoch = args[0]
         if not isinstance(epoch, int):
-            raise Exception(f"The input x is not a int value: {epoch}")
+            raise Exception(f"The input epoch is not an int value: {epoch}")
+
+        # Validate X coordinate is a float
         x = args[1]
         if not (isinstance(x, float) or isinstance(x, np.float32)):
             raise Exception(f"The input x is not a float value: {x}")
+
+        # Validate Y coordinate is a float
         y = args[2]
         if not (isinstance(y, float) or isinstance(y, np.float32)):
-            raise Exception(f"The input x is not a float value: {y}")
+            raise Exception(f"The input y is not a float value: {y}")
+
+        # Validate Z coordinate is a float
         z = args[3]
         if not (isinstance(z, float) or isinstance(z, np.float32)):
-            raise Exception(f"The input x is not a float value: {z}")
+            raise Exception(f"The input z is not a float value: {z}")
+
+        # Validate datapoint_name is a string
         datapoint_name = args[4]
         if not isinstance(datapoint_name, str):
-            raise Exception(f"The input x is not a string value: {datapoint_name}")
+            raise Exception(f"The input datapoint_name is not a string value: {datapoint_name}")
+
+        # Validate original_label is a string
         original_label = args[5]
         if not isinstance(original_label, str):
-            raise Exception(f"The input x is not a string value: {original_label}")
+            raise Exception(f"The input original_label is not a string value: {original_label}")
+
+        # Validate classified_label is a string
         classified_label = args[6]
         if not isinstance(classified_label, str):
-            raise Exception(f"The input x is not a string value: {classified_label}")
+            raise Exception(f"The input classified_label is not a string value: {classified_label}")
 
     def insert_entry(self, *args):
+        """
+        Insert a single data point entry into the database.
+
+        Args:
+            *args: A sequence of values in the following order:
+                  epoch (int), x (float), y (float), z (float),
+                  datapoint_name (str), original_label (str), classified_label (str)
+        """
+        # Validate input types
         self.sanitize_input(*args)
+
+        # Extract values from args
         epoch = args[0]
         x = args[1]
         y = args[2]
         z = args[3]
         datapoint_name = args[4]
         original_label = args[5]
         classified_label = args[6]
+
+        # Execute SQL INSERT statement
         self.table_cursor.execute(
             f"""INSERT INTO {self.table_name} VALUES 
                                     ("{epoch}",
@@ -75,31 +141,72 @@ def insert_entry(self, *args):
                                      "{original_label}", 
                                      "{classified_label}")"""
         )
+        # Commit the transaction
         self.conn.commit()
 
     def insert(
         self, epoch: int, tsne_array: np.array, original_labels: list, predicted_labels: list, datapoint_ids: list
     ):
+        """
+        Insert multiple data points for a given epoch into the database.
+
+        Args:
+            epoch (int): The training epoch/iteration number
+            tsne_array (np.array): Array of 3D points from TSNE dimensionality reduction
+            original_labels (list): List of ground truth labels for each point
+            predicted_labels (list): List of model-predicted labels for each point
+            datapoint_ids (list): List of unique identifiers for each data point
+        """
+        # Iterate through all data points and their associated metadata
         for each_point, original_label, predicted_label, datapoint_id in zip(
             tsne_array, original_labels, predicted_labels, datapoint_ids
         ):
+            # Unpack X, Y, Z coordinates from the point
             x, y, z = each_point
+            # Insert each point as an individual entry
             self.insert_entry(epoch, x, y, z, datapoint_id, original_label, predicted_label)
 
     def get_all_table_names(self):
+        """
+        Retrieve all table names from the SQLite database.
+
+        Returns:
+            list: List of all table names in the database with square brackets
+                 to handle special characters in table names
+        """
+        # Create a new connection to the database
         conn = sqlite3.connect(self.db_path)
+        # Query the sqlite_master table to get all table names
         res = conn.execute("SELECT name FROM sqlite_master WHERE type='table';")
         all_table_names = []
+        # Process results and format table names with square brackets
         for name in res:
             all_table_names.append(f"[{name[0]}]")
+        # Close the connection
         conn.close()
         return all_table_names
 
     def get_pandas_frame(self, table_name):
+        """
+        Load a table from the database into a pandas DataFrame.
+
+        Args:
+            table_name (str): Name of the table to load
+
+        Returns:
+            pandas.DataFrame: DataFrame containing all data from the specified table
+        """
+        # Create a new connection to the database
         conn = sqlite3.connect(self.db_path)
+        # Use pandas to read the SQL query result directly into a DataFrame
         df = pd.read_sql_query(f"SELECT * from {table_name}", conn)
+        # Close the connection
         conn.close()
         return df
 
     def close_connection(self):
+        """
+        Close the database connection.
+        Should be called when the database operations are complete.
+        """
         self.conn.close()

tsne_plots/tsne_plot.py

@@ -170,26 +170,52 @@ def update_figure(*vals):
         df = sql_db.get_pandas_frame(vals[4])
         filtered_df = df[df["ORIGINAL_LABEL"].isin(selected_labels)]
         filtered_df = filtered_df.loc[filtered_df["epoch"] == slider_value]
+
+        # Calculate accuracy using original labels vs. classified labels for the filtered dataset
         accuracy = get_accuracy(filtered_df)
+
+        # Generate the plotly figure using the filtered dataframe with current selection parameters
         fig = get_plotly_fig(filtered_df, df)
+
+        # Preserve the current camera view position when the figure is updated
+        # This prevents the view from resetting when filtering changes
         fig.update_layout(scene_camera=data["scene.camera"])
+
+        # Handle the case where a specific datapoint UID is provided for highlighting
         if datapoint_uid:
+            # Attempt to find the x, y, z coordinates for the specified UID in the current filtered data
             point_x, point_y, point_z = get_uid_xyz(filtered_df, datapoint_uid)
+
+            # If the point exists in the current filtered dataset
             if point_x and point_y and point_z:
+                # Add a special diamond-shaped marker to highlight the selected datapoint
                 fig.add_trace(
                     Scatter3d(x=[point_x], y=[point_y], z=[point_z], mode="markers", marker=dict(symbol="diamond"))
                 )
+                # Set flag to indicate the point was found (used for form validation feedback)
                 set_radio_button = "YES"
             else:
-                # The point doesn't exist, show it to user
+                # The point doesn't exist in the current filtered data
+                # This could be because:
+                # 1. The UID doesn't exist in the database
+                # 2. The UID exists but not in the current filtered view (wrong epoch or label)
                 set_radio_button = "NO"
         else:
+            # No UID was provided, so no specific point to highlight
             set_radio_button = "NO"
 
+        # Return multiple outputs for the callback:
+        # 1. The updated figure with new filters and possibly highlighted point
+        # 2. The accuracy percentage formatted with 2 decimal places
+        # 3. Whether the input UID is valid (for positive form feedback)
+        # 4. Whether the input UID is invalid (for negative form feedback)
         return fig, f"{accuracy:.2f}%", set_radio_button == "YES", set_radio_button != "YES"
 
+    # Start the Dash server
+    # debug=False prevents auto-reloading when code changes
     app.run_server(debug=False)
 
 
 if __name__ == "__main__":
+    # Entry point of the script when executed directly
     main()