deepboard 0.0.0__tar.gz

deepboard-0.0.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include deepboard *.css *.js *.html

deepboard-0.0.0/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: deepboard
+Version: 0.0.0
+Summary: A tool to log you experiment results and explore them in a gui
+Home-page: https://github.com/anthol42/deepboard
+Author: Anthony Lavertu
+Author-email: alavertu2@gmail.com
+Project-URL: Issues, https://github.com/anthol42/deepboard/issues
+Keywords: deepboard,deep,board,pytorch,torch,tensorflow,jax,tensorboard
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: python-fasthtml
+Requires-Dist: fh-plotly
+Requires-Dist: MarkupSafe
+Requires-Dist: pandas
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Deepboard
+This package include two modules that are work together: 
+`deepboard gui` and `resultTable`. The `resultTable` module 
+keeps track of all of your experiment and helps you organize 
+your code to make results reproducible. The `deepboard gui` module
+implement a webUI to visualize the training details and training 
+curves of any runs. In addition, it lets you commpare training curves
+between runs. You can even download the charts that you have generated:)
+## 🔥 Screenshots 🔥
+![](assets/main_view.png)
+![](assets/compare_view.png)
+## 🌟 Project Philosophy
+Before diving in, it’s important to understand the philosophy behind this project. In deep learning, it’s easy to get 
+swept up in the excitement — experimenting with countless configurations in search of the perfect setup. 🔬✨ 
+Eventually, we stumble upon something that works well... only to keep tweaking and lose track of what actually worked 
+best. This package is built to help you stay focused, organized, and efficient — so you never lose track of that perfect 
+combination again. 🧠✅
+
+The idea is simple: always make your code reproducible!
+Sure, easier said than done... 😅 My recommended approach is to use a multi-level configuration system. Let me explain 
+how it works! 👇
+
+Before jumping into experiments, we usually know the minimal set of parameters required for a project to run.
+For instance, if you're training a Transformer model, you already know you'll need to specify things like the number of 
+layers, number of attention heads, learning rate, and so on. All these known parameters can (and should) be stored in a 
+configuration file — I personally prefer using YAML for its readability. 📄 When running the experiment, we simply load 
+this config file and use it to parameterize each part of the code. Usually, the parameters stored in the config gives 
+us the baseline.
+
+Once we’ve established a baseline, it’s natural to want to improve it — whether it's by testing out a new technique from
+a paper or an idea that came to us in a dream. 🚀 But here's the challenge: how do we add new functionality to our code 
+without breaking compatibility with earlier runs? In other words, if we use the same config file and script parameters, 
+we should still get the exact same results as before. My solution? Add new parameters to functions with sensible 
+default values — specifically, defaults that reflect the original behavior. You can then include these parameters in 
+your configuration file and toggle them on or off to test their effect. For example, say you’re building an image 
+classifier and want to try `MixUp`. Your training function might look like this:
+```python
+def train_model(..., use_mixup: bool = False):
+    ...
+```
+By setting the default to False, your baseline run remains intact. Only when `use_mixup` is explicitly set to True will 
+the new logic kick in. This approach ensures clean, reproducible experimentation with minimal disruption. ✅
+
+Sometimes, we don’t want to modify the configuration file directly — for example, when we've decided that a particular 
+config represents a fixed setup for a specific model or training strategy.
+In these cases, it's often more convenient to override a few parameters via the command line. 🧪
+To do this, I use Python’s built-in argparse module. It adds an extra layer of configuration that’s ideal for quick 
+experiments — without changing the original YAML file. And just like before, the same principle applies: always use 
+default values that reproduce the results of previous runs. This ensures your experiments stay flexible and reproducible. 🔁
+
+This project promotes a simple but powerful principle: make your deep learning experiments reproducible — without 
+slowing down iteration or innovation. To achieve that, it recommends a multi-level configuration system:
+1. YAML Configuration Files – Store all known parameters for a clean, reproducible baseline. 📄
+2. Function Defaults – Add new features with default values that preserve past behavior. This ensures that re-running 
+with the same config and cli parameters always gives the same result. ✅
+3. CLI Overrides – For quick tweaks, use cli parameters to add new functionalities or to override config's parameters 
+without editing the base config. Perfect for fast experimentation. 🧪
+
+This layered setup keeps your workflow organized, traceable, and easy to extend, so you can explore new ideas without 
+losing sight of what actually works. 🔁
+
+If you're feeling a bit overwhelmed or would like a project example, the 
+[torchbuilder](https://github.com/anthol42/torchbuilder/tree/dev) app can generate various project templates. The 
+default template implements this philosophy, including the resultTable, making it a great starting point! 🚀
+
+## 🛠️ Installation
+```shell
+pip install deepboard
+```
+
+## 🚀 How to Use
+For your project, you will only need the `resultTable` module, as the `deepboard` module is primarily for the UI.
+
+### ResultTable
+First, import the `ResultTable` class from `deepboard.resultTable`, then create a new run. You can also create a debug run. 
+A **debug run** will be logged in the result table like any other run, but all results will be overwritten by the next 
+debug run. This helps keep the result table clean by containing only the runs you intend to test, rather than those 
+meant solely for verifying if the code executed correctly.
+
+Note: **Debug runs always have a runID of -1.** 🔧
+```python
+from deepboard.resultTable import ResultTable
+    
+rtable = ResultTable("results/resultTable.db")
+if DEBUG:
+    resultSocket = rtable.new_debug_run("Experiment1", "path/to/config", cli=vars(args).copy())
+else:
+    resultSocket = rtable.new_run("Experiment1", "path/to/config", cli=vars(args).copy())
+```
+
+Next, you can specify hyperparameters that will appear in the table
+```python
+resultSocket.add_hparams(
+        lr=config["training"]["learning_rate"],
+        wd=...,
+        min_lr=...,
+        dropout2d=...,
+        dropout=...
+    )
+```
+
+During training, we can log scalars associated to the run with:
+```python
+resultSocket.add_scalar(f'Train/Accuracy', 0.99, step)
+```
+
+Finally, you can log the final evaluation results that will be included into the table with:
+```python
+resultSocket.write_result(accuracy=final_accuracy, crossEntropy=final_loss)
+```
+
+Note: If you want to do multiple training iterations of the same run (to test variance for example), you can call the 
+```resultSocket.new_repetition``` method after each repetition. 
+```python
+for rep in range(number_of_repetitions):
+    for epoch in range(n_epochs):
+        ... # Train here
+    resultSocket.new_repetition()
+
+# Finally, write the final results once:
+resultSocket.write_result(accuracy=accuracies.mean(), crossEntropy=losses.mean())
+```
+
+### Deepboard UI
+To launch deepboard Web UI, simply run the command `deepboard` in your terminal with the path to your resultTable db:
+```shell
+deepboard /path/to/resultTable.db
+```

deepboard-0.0.0/README.md

@@ -0,0 +1,128 @@
+# Deepboard
+This package include two modules that are work together: 
+`deepboard gui` and `resultTable`. The `resultTable` module 
+keeps track of all of your experiment and helps you organize 
+your code to make results reproducible. The `deepboard gui` module
+implement a webUI to visualize the training details and training 
+curves of any runs. In addition, it lets you commpare training curves
+between runs. You can even download the charts that you have generated:)
+## 🔥 Screenshots 🔥
+![](assets/main_view.png)
+![](assets/compare_view.png)
+## 🌟 Project Philosophy
+Before diving in, it’s important to understand the philosophy behind this project. In deep learning, it’s easy to get 
+swept up in the excitement — experimenting with countless configurations in search of the perfect setup. 🔬✨ 
+Eventually, we stumble upon something that works well... only to keep tweaking and lose track of what actually worked 
+best. This package is built to help you stay focused, organized, and efficient — so you never lose track of that perfect 
+combination again. 🧠✅
+
+The idea is simple: always make your code reproducible!
+Sure, easier said than done... 😅 My recommended approach is to use a multi-level configuration system. Let me explain 
+how it works! 👇
+
+Before jumping into experiments, we usually know the minimal set of parameters required for a project to run.
+For instance, if you're training a Transformer model, you already know you'll need to specify things like the number of 
+layers, number of attention heads, learning rate, and so on. All these known parameters can (and should) be stored in a 
+configuration file — I personally prefer using YAML for its readability. 📄 When running the experiment, we simply load 
+this config file and use it to parameterize each part of the code. Usually, the parameters stored in the config gives 
+us the baseline.
+
+Once we’ve established a baseline, it’s natural to want to improve it — whether it's by testing out a new technique from
+a paper or an idea that came to us in a dream. 🚀 But here's the challenge: how do we add new functionality to our code 
+without breaking compatibility with earlier runs? In other words, if we use the same config file and script parameters, 
+we should still get the exact same results as before. My solution? Add new parameters to functions with sensible 
+default values — specifically, defaults that reflect the original behavior. You can then include these parameters in 
+your configuration file and toggle them on or off to test their effect. For example, say you’re building an image 
+classifier and want to try `MixUp`. Your training function might look like this:
+```python
+def train_model(..., use_mixup: bool = False):
+    ...
+```
+By setting the default to False, your baseline run remains intact. Only when `use_mixup` is explicitly set to True will 
+the new logic kick in. This approach ensures clean, reproducible experimentation with minimal disruption. ✅
+
+Sometimes, we don’t want to modify the configuration file directly — for example, when we've decided that a particular 
+config represents a fixed setup for a specific model or training strategy.
+In these cases, it's often more convenient to override a few parameters via the command line. 🧪
+To do this, I use Python’s built-in argparse module. It adds an extra layer of configuration that’s ideal for quick 
+experiments — without changing the original YAML file. And just like before, the same principle applies: always use 
+default values that reproduce the results of previous runs. This ensures your experiments stay flexible and reproducible. 🔁
+
+This project promotes a simple but powerful principle: make your deep learning experiments reproducible — without 
+slowing down iteration or innovation. To achieve that, it recommends a multi-level configuration system:
+1. YAML Configuration Files – Store all known parameters for a clean, reproducible baseline. 📄
+2. Function Defaults – Add new features with default values that preserve past behavior. This ensures that re-running 
+with the same config and cli parameters always gives the same result. ✅
+3. CLI Overrides – For quick tweaks, use cli parameters to add new functionalities or to override config's parameters 
+without editing the base config. Perfect for fast experimentation. 🧪
+
+This layered setup keeps your workflow organized, traceable, and easy to extend, so you can explore new ideas without 
+losing sight of what actually works. 🔁
+
+If you're feeling a bit overwhelmed or would like a project example, the 
+[torchbuilder](https://github.com/anthol42/torchbuilder/tree/dev) app can generate various project templates. The 
+default template implements this philosophy, including the resultTable, making it a great starting point! 🚀
+
+## 🛠️ Installation
+```shell
+pip install deepboard
+```
+
+## 🚀 How to Use
+For your project, you will only need the `resultTable` module, as the `deepboard` module is primarily for the UI.
+
+### ResultTable
+First, import the `ResultTable` class from `deepboard.resultTable`, then create a new run. You can also create a debug run. 
+A **debug run** will be logged in the result table like any other run, but all results will be overwritten by the next 
+debug run. This helps keep the result table clean by containing only the runs you intend to test, rather than those 
+meant solely for verifying if the code executed correctly.
+
+Note: **Debug runs always have a runID of -1.** 🔧
+```python
+from deepboard.resultTable import ResultTable
+    
+rtable = ResultTable("results/resultTable.db")
+if DEBUG:
+    resultSocket = rtable.new_debug_run("Experiment1", "path/to/config", cli=vars(args).copy())
+else:
+    resultSocket = rtable.new_run("Experiment1", "path/to/config", cli=vars(args).copy())
+```
+
+Next, you can specify hyperparameters that will appear in the table
+```python
+resultSocket.add_hparams(
+        lr=config["training"]["learning_rate"],
+        wd=...,
+        min_lr=...,
+        dropout2d=...,
+        dropout=...
+    )
+```
+
+During training, we can log scalars associated to the run with:
+```python
+resultSocket.add_scalar(f'Train/Accuracy', 0.99, step)
+```
+
+Finally, you can log the final evaluation results that will be included into the table with:
+```python
+resultSocket.write_result(accuracy=final_accuracy, crossEntropy=final_loss)
+```
+
+Note: If you want to do multiple training iterations of the same run (to test variance for example), you can call the 
+```resultSocket.new_repetition``` method after each repetition. 
+```python
+for rep in range(number_of_repetitions):
+    for epoch in range(n_epochs):
+        ... # Train here
+    resultSocket.new_repetition()
+
+# Finally, write the final results once:
+resultSocket.write_result(accuracy=accuracies.mean(), crossEntropy=losses.mean())
+```
+
+### Deepboard UI
+To launch deepboard Web UI, simply run the command `deepboard` in your terminal with the path to your resultTable db:
+```shell
+deepboard /path/to/resultTable.db
+```

deepboard-0.0.0/deepboard/__init__.py

@@ -0,0 +1 @@
+from .__version__ import __version__

deepboard-0.0.0/deepboard/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.0.0"

deepboard-0.0.0/deepboard/gui/assets/base.css

@@ -0,0 +1,168 @@
+@import url('theme.css');
+body {
+  margin: 0;
+  font-family: system-ui, sans-serif;
+  background-color:var(--background-color);
+  color: var(--text_color);
+  overflow-y: hidden;
+  overflow-x: hidden;
+}
+
+.container {
+  display: flex;
+}
+
+
+/*Menu when you right click*/
+#custom-menu {
+  position: absolute;
+  background-color: var(--menu-bg);
+  border: var(--menu-bg);
+  border-radius: 6px;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  z-index: 1000;
+  box-shadow: var(--menu-shadow);
+  visibility: hidden;
+}
+
+.dropdown-menu {
+    background-color: var(--menu-bg);
+    color: var(--text_color);
+    padding: 0;
+    width: 200px;
+    font-family: sans-serif;
+    margin: 0;
+    list-style: none;
+  }
+
+  .menu-item {
+    padding: 0.5rem;
+    cursor: pointer;
+    position: relative;
+    white-space: nowrap;
+  }
+
+  .menu-item:hover {
+    background-color: var(--menu-bg-hover);
+  }
+
+  .has-submenu-wrapper {
+    position: relative;
+  }
+.has-submenu {
+    text-decoration: none;
+    color: inherit;
+    display: block;
+}
+  .submenu {
+    display: none;
+    position: absolute;
+    top: 0;
+    left: 100%;
+    background-color: var(--menu-bg);
+    border-radius: 6px;
+    padding: 0;
+    list-style: none;
+    min-width: 150px;
+    z-index: 1001;
+    margin-left: 0;
+    max-height: 40vh;
+    overflow-y: scroll;
+  }
+
+  .has-submenu-wrapper:hover .submenu {
+    display: block;
+  }
+
+  .submenu .menu-item:hover {
+    background-color: var(--menu-bg-hover);
+  }
+
+
+.copy-container {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  cursor: pointer;
+  padding: 0;
+}
+
+.copy-icon-container {
+  position: relative;
+  width: 1em; /* match icon size */
+  height: 1em;
+  display: inline-block;
+}
+
+/* Overlap icons inside wrapper */
+.copy-icon {
+  position: absolute;
+  top: 0;
+  left: 0;
+  opacity: 0;
+  visibility: hidden;
+  transition: opacity 0.2s ease;
+  pointer-events: none; /* so they don't block clicks */
+}
+
+.copy-container:hover .default-icon {
+  visibility: visible;
+  opacity: 1;
+}
+
+.copy-container.copied .default-icon {
+  display: none;
+}
+
+.copy-container.copied .check-icon {
+  visibility: visible;
+  opacity: 1;
+}
+
+.align-right {
+    display: flex;
+    justify-content: flex-end;
+}
+
+
+/*Compare Button*/
+.compare-button-container {
+  width: 100%;
+  display: flex;
+  justify-content: flex-end; /* aligns content to the right horizontally */
+}
+
+.compare-button {
+  margin-top: 0.5rem;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 8px 32px;
+  font-size: 1.1rem;
+  font-weight: 600;
+  color: var(--text_color);
+  background-color: var(--primary-color); /* Material purple */
+  border: none;
+  border-radius: 8px;
+  box-shadow: 0 2px 6px var(--button-shadow-color);
+  cursor: pointer;
+}
+.compare-button:hover {
+  background-color: var(--primary-color-hover); /* darker on hover */
+  box-shadow: 0 2px 10px var(--button-shadow-color);
+}
+
+.compare-button:active {
+  box-shadow: 0 2px 5px var(--button-shadow-color);
+}
+
+.center-center{
+  width: 100%;
+  height: 100vh;
+  display: flex;
+  justify-content: center; /* Horizontal centering */
+  align-items: center;     /* Vertical centering */
+}

deepboard-0.0.0/deepboard/gui/assets/base.js

@@ -0,0 +1,77 @@
+  window.addEventListener("contextmenu", function(e) {
+    // Get the target element (the element that was clicked)
+    let element = e.target;
+
+    e.preventDefault(); // Prevent the default browser context menu
+    const ids = [];
+
+      while (element) {
+          if (element.id) {
+              ids.push(element.id);
+          }
+          element = element.parentElement;
+      }
+
+    // You can pass this information to your HTMX request
+    const menu = document.getElementById('custom-menu');
+    menu.style.top = `${e.clientY}px`;
+    menu.style.left = `${e.clientX}px`;
+
+    // Trigger HTMX request to load the menu content
+    // Join ids with ,
+    str_ids = ids.join(",")
+    htmx.ajax('GET', `/get-context-menu?elementIds=${str_ids}&top=${e.clientY}&left=${e.clientX}`, {
+      target: '#custom-menu',
+      swap: 'outerHTML',  // Correct usage of swap attribute
+      headers: {
+        'HX-Swap-OOB': 'true'  // Use correct OOB header for out-of-band swaps
+      }
+    });
+  });
+
+  // Hide the menu when clicking elsewhere
+  window.addEventListener("click", () => {
+    const menu = document.getElementById('custom-menu');
+    menu.style.visibility = "hidden";
+  });
+
+
+function copyToClipboard(container) {
+    const text = container.querySelector('.copy-text').innerText;
+
+    navigator.clipboard.writeText(text).then(() => {
+      container.classList.add('copied');
+      setTimeout(() => {
+        container.classList.remove('copied');
+      }, 1200);
+    });
+}
+
+
+function shiftClickDataGrid(event){
+    const el = event.target.closest('.table-row');
+    if (!el) return; // Not one of ours
+    if (event.ctrlKey || event.metaKey) {
+      const originalUrl = el.getAttribute('hx-get'); // e.g. "/default-endpoint?runID=3"
+      const url = new URL(originalUrl, window.location.origin); // create full URL to parse
+      const params = url.search;
+
+     // Instead of modifying the attribute, trigger htmx manually with the new URL
+      htmx.ajax('GET', `/shift_click_row${params}`, {target: el.getAttribute('hx-target') || el});
+
+      // Prevent the original click handler from firing
+      event.preventDefault();
+      event.stopPropagation();
+    }
+}
+document.addEventListener('click', shiftClickDataGrid);
+
+// New htmx event: open in a new tab when data-new-tab attribute is present
+document.addEventListener('htmx:beforeOnLoad', function (event) {
+    const redirectUrl = event.detail.xhr.getResponseHeader('HX-Blank-Redirect');
+    if (redirectUrl && event.detail.elt.hasAttribute('data-new-tab')) {
+        // Prevent htmx from performing the redirect in the current tab
+        console.log("Here")
+        window.open(redirectUrl, '_blank');
+    }
+  });