Update app.py

app.py

@@ -999,103 +999,133 @@ with ui.navset_card_tab(id="tab"):
                     multiple=True,
                     selected='compliment'
                 )
-    
-        @output
-        @render.plot
-        def plot_training_loss():
-            # if csv_file() is None:
-            #     return None
-            
+            def plot_loss_rates(df, param_types, loss_types, model_types): 
+            # interplot each column to be same number of points
+            x = np.linspace(0, 1, 1000)
+            loss_rates = []
+            labels = []
+            #drop the column step
+            df = df.drop(columns=['Step'])
+            for param_type in param_types:
+                for loss_type in loss_types:
+                    for model_type in model_types:
+                        y = df[df['param_type']==param_type && df['loss_type']==loss_type && df['model_type']==model_type]['loss'].dropna().astype('float', errors = 'ignore').dropna().values
+                        f = interp1d(np.linspace(0, 1, len(y)), y)
+                        loss_rates.append(f(x))
+                        labels.append(param_type +'_'+loss_type +'_'+model_type)
+            fig, ax = plt.subplots()
+            for i, loss_rate in enumerate(loss_rates):
+                ax.plot(x, loss_rate, label=labels[i])
+            ax.legend()
+            ax.set_title(f'Loss rates for a {type} parameter model across context windows')
+            ax.set_xlabel('Training steps')
+            ax.set_ylabel('Loss rate')
+            return fig
+        
+        import matplotlib as mpl
+        @render.plot()
+        def plot_context_size_scaling():
+            fig = None
             df = pd.read_csv('results - denseformer.csv')
+            mpl.rcParams.update(mpl.rcParamsDefault)
+            fig = plot_loss_rates(df, input.param_type(),input.loss_type(),input.model_type())
+            return fig
+        # @output
+        # @render.plot
+        # def plot_training_loss():
+        #     # if csv_file() is None:
+        #     #     return None
+            
+        #     df = pd.read_csv('results - denseformer.csv')
     
-            filtered_df = df[
-                (df["param_type"].isin(input.param_type()))
-                & (df["model_type"].isin(input.model_type()))
-                & (df["loss_type"].isin(input.loss_type()))
-            ]
+        #     filtered_df = df[
+        #         (df["param_type"].isin(input.param_type()))
+        #         & (df["model_type"].isin(input.model_type()))
+        #         & (df["loss_type"].isin(input.loss_type()))
+        #     ]
     
 
-            if filtered_df.empty:
-                return None
+        #     if filtered_df.empty:
+        #         return None
             
-            # Define colors for sizes and shapes for loss types
-            size_colors = {
-                "14": "blue",
-                "31": "green",
-                "70": "orange",
-                "160": "red"
-            }
+            # # Define colors for sizes and shapes for loss types
+            # size_colors = {
+            #     "14": "blue",
+            #     "31": "green",
+            #     "70": "orange",
+            #     "160": "red"
+            # }
             
-            loss_markers = {
-                "compliment": "o",
-                "cross_entropy": "^",
-                "headless": "s"
-            }
+            # loss_markers = {
+            #     "compliment": "o",
+            #     "cross_entropy": "^",
+            #     "headless": "s"
+            # }
             
-            # Create the plot
-            fig, ax = plt.subplots(figsize=(10, 6))
+            # # Create the plot
+            # fig, ax = plt.subplots(figsize=(10, 6))
             
-            # Plot each combination of size and loss type
-            for size in filtered_df["param_type"].unique():
-                for loss_type in filtered_df["loss_type"].unique():
-                    data = filtered_df[(filtered_df["param_type"] == size) & (filtered_df["loss_type"] == loss_type)]
-                    ax.plot(data["epoch"], data["loss"], marker=loss_markers[loss_type], color=size_colors[size], label=f"{size} - {loss_type}")
+            # # Plot each combination of size and loss type
+            # for size in filtered_df["param_type"].unique():
+            #     for loss_type in filtered_df["loss_type"].unique():
+            #         data = filtered_df[(filtered_df["param_type"] == size) & (filtered_df["loss_type"] == loss_type)]
+            #         ax.plot(data["epoch"], data["loss"], marker=loss_markers[loss_type], color=size_colors[size], label=f"{size} - {loss_type}")
             
-            # Customize the plot
-            ax.set_xlabel("Epoch")
-            ax.set_ylabel("Loss")
-            ax.set_title("Training Loss by Size and Loss Type", fontsize=16)
+            # # Customize the plot
+            # ax.set_xlabel("Epoch")
+            # ax.set_ylabel("Loss")
+            # # ax.set_title("Training Loss by Size and Loss Type", fontsize=16)
             
-            # Create a legend for sizes
-            size_legend = ax.legend(title="Size", loc="upper right")
-            ax.add_artist(size_legend)
+            # # Create a legend for sizes
+            # size_legend = ax.legend(title="Size", loc="upper right")
+            # ax.add_artist(size_legend)
             
-            # Create a separate legend for loss types
-            loss_legend_labels = ["Compliment", "Cross Entropy", "Headless"]
-            loss_legend_handles = [plt.Line2D([0], [0], marker=loss_markers[loss_type], color='black', linestyle='None', markersize=8) for loss_type in loss_markers]
-            loss_legend = ax.legend(loss_legend_handles, loss_legend_labels, title="Loss Type", loc="upper right")
+            # # Create a separate legend for loss types
+            # loss_legend_labels = ["Compliment", "Cross Entropy", "Headless"]
+            # loss_legend_handles = [plt.Line2D([0], [0], marker=loss_markers[loss_type], color='black', linestyle='None', markersize=8) for loss_type in loss_markers]
+            # loss_legend = ax.legend(loss_legend_handles, loss_legend_labels, title="Loss Type", loc="upper right")
             
-            plt.tight_layout()
-            return fig
+            # plt.tight_layout()
+            # return fig
     
-            # Define colors for sizes and shapes for loss types
-            size_colors = {
-                "14": "blue",
-                "31": "green",
-                "70": "orange",
-                "160": "red"
-            }
-            loss_markers = {
-                "compliment": "o",
-                "cross_entropy": "^",
-                "headless": "s"
-            }
+            # # Define colors for sizes and shapes for loss types
+            # size_colors = {
+            #     "14": "blue",
+            #     "31": "green",
+            #     "70": "orange",
+            #     "160": "red"
+            # }
+            # loss_markers = {
+            #     "compliment": "o",
+            #     "cross_entropy": "^",
+            #     "headless": "s"
+            # }
     
-            # Create a relplot using Seaborn
-            g = sns.relplot(
-                data=filtered_df,
-                x="epoch",
-                y="loss",
-                hue="param_type",
-                style="loss_type",
-                palette=size_colors,
-                markers=loss_markers,
-                height=6,
-                aspect=1.5
-            )
+            # # Create a relplot using Seaborn
+            # g = sns.relplot(
+            #     data=filtered_df,
+            #     x="epoch",
+            #     y="loss",
+            #     hue="param_type",
+            #     style="loss_type",
+            #     palette=size_colors,
+            #     markers=loss_markers,
+            #     height=6,
+            #     aspect=1.5
+            # )
     
-            # Customize the plot
-            g.set_xlabels("Epoch")
-            g.set_ylabels("Loss")
-            g.fig.suptitle("Training Loss by Size and Loss Type", fontsize=16)
-            g.add_legend(title="Size")
+            # # Customize the plot
+            # g.set_xlabels("Epoch")
+            # g.set_ylabels("Loss")
+            # g.fig.suptitle("Training Loss by Size and Loss Type", fontsize=16)
+            # g.add_legend(title="Size")
     
-            # Create a separate legend for loss types
-            loss_legend = plt.legend(title="Loss Type", loc="upper right", labels=["Compliment", "Cross Entropy", "Headless"])
-            plt.gca().add_artist(loss_legend)
+            # # Create a separate legend for loss types
+            # loss_legend = plt.legend(title="Loss Type", loc="upper right", labels=["Compliment", "Cross Entropy", "Headless"])
+            # plt.gca().add_artist(loss_legend)
     
-            plt.tight_layout()
-            return g.fig
+            # plt.tight_layout()
+            # return g.fig
 
         
 # @render.image