Merge branch 'dev' into Layer-2

Author: Manik-Khajuria-5

cypress/integration/parallel_coordinates.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2017-present, The Visdom Authors
+ * All rights reserved.
+ *
+ * This source code is licensed under the license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+before(() => {
+  cy.visit('/');
+});
+
+describe('Parallel Coordinates Pane', () => {
+  it('parallel_coordinates_basic', () => {
+    cy.run('plot_special_parallel_coordinates');
+
+    cy.get('.layout .window').should('have.length', 1);
+
+    cy.get('.content').contains('Experiment Comparison');
+  });
+
+  it('parallel_coordinates_close', () => {
+    cy.run('plot_special_parallel_coordinates');
+    cy.get('.layout .react-grid-item')
+      .first()
+      .find('button[title="close"]')
+      .click();
+    cy.get('.layout .window').should('have.length', 0);
+  });
+});

example/components/plot_special.py

@@ -61,6 +61,47 @@ def plot_special_graph(viz, env, args):
     )
 
 
+# parallel coordinates plot
+def plot_special_parallel_coordinates(viz, env, args):
+    n = 20
+    X = np.column_stack(
+        [
+            np.random.uniform(1e-4, 0.1, n),
+            np.random.choice([16, 32, 64, 128, 256], n).astype(float),
+            np.random.randint(10, 200, n).astype(float),
+            np.random.uniform(0.0, 0.5, n),
+            np.random.uniform(1e-5, 1e-2, n),
+            np.random.choice([0, 1, 2], n).astype(float),
+            np.random.choice([64, 128, 256, 512], n).astype(float),
+            np.random.uniform(50, 99, n),
+            np.random.uniform(0.01, 1.0, n),
+            np.random.uniform(0.4, 0.95, n),
+        ]
+    )
+    viz.parallel_coordinates(
+        X=X,
+        Y=X[:, 7],
+        env=env,
+        opts=dict(
+            dimensions=[
+                "LR",
+                "Batch",
+                "Epochs",
+                "Dropout",
+                "WD",
+                "Optim",
+                "Hidden",
+                "Acc",
+                "Loss",
+                "F1",
+            ],
+            title="Experiment Comparison",
+            tickvals={5: [0, 1, 2]},
+            ticktext={5: ["SGD", "Adam", "AdamW"]},
+        ),
+    )
+
+
 # sankey (flow) diagram
 def plot_special_sankey(viz, env, args):
     title = args[0] if len(args) > 0 else None

example/demo.py

@@ -83,6 +83,7 @@
     plot_special_mesh,
     plot_special_sunburst,
     plot_special_graph,
+    plot_special_parallel_coordinates,
     plot_special_sankey,
 )
 from components.plot_roc_pr import (
@@ -214,6 +215,7 @@ def run_demo(viz, env, args):
     plot_special_mesh(viz, env, args)
     plot_special_sunburst(viz, env, args)
     plot_special_graph(viz, env, args)
+    plot_special_parallel_coordinates(viz, env, args)
     plot_special_sankey(viz, env, args)
 
     # ============ #

py/tests/test_storage_wiring.py

@@ -325,7 +325,7 @@ def write_message(self, msg):
 
 
 class TestReadHelperWiring(unittest.TestCase):
-    """PR #7: ``load_env`` reads a cold env through the store, not raw env_path."""
+    """``load_env`` reads a cold env through the store, not raw env_path."""
 
     def setUp(self):
         self._tmp = tempfile.TemporaryDirectory()

py/visdom/__init__.py

@@ -4010,6 +4010,156 @@ def graph(
             {"data": data, "win": win, "eid": env, "opts": opts}, endpoint="events"
         )
 
+    @pytorch_wrap
+    def parallel_coordinates(self, X, Y=None, win=None, env=None, opts=None):
+        """
+        This function draws a parallel coordinates plot for comparing multiple
+        experiments across different parameters. Each row in the `NxM` matrix
+        `X` represents one experiment and each column represents a dimension
+        (e.g., a hyperparameter or metric).
+
+        An optional `N`-length vector `Y` supplies per-experiment color values
+        (e.g., accuracy or loss) so that the lines are shaded according to
+        a continuous colorscale.
+
+        The following `opts` are supported:
+
+        - `opts.dimensions`:       `list` of dimension label strings (length M)
+        - `opts.colormap`:         colorscale name (default `'Electric'`)
+        - `opts.reversescale`:     reverse the colorscale direction (`bool`)
+        - `opts.ranges`:           `dict` mapping dimension index to `[min, max]`
+        - `opts.constraintranges`: `dict` mapping dimension index to `[min, max]`
+                                   preset filter ranges
+        - `opts.tickvals`:         `dict` mapping dimension index to a `list` of
+                                   tick positions
+        - `opts.ticktext`:         `dict` mapping dimension index to a `list` of
+                                   tick labels (requires matching `tickvals`)
+        - `opts.max_experiments`:  `int`, cap to top N experiments sorted by `Y`
+                                   descending (requires `Y`)
+        - `opts.title`:            plot title
+        """
+        opts = {} if opts is None else opts
+        _title2str(opts)
+        _assert_opts(opts)
+
+        X = np.asarray(X, dtype=float)
+        assert X.ndim == 2, "X must be a 2D matrix (N experiments x M dimensions)"
+        N, M = X.shape
+        assert N >= 1, "X must have at least 1 experiment (row)"
+        assert M >= 2, "X must have at least 2 dimensions (columns)"
+
+        if Y is not None:
+            Y = np.squeeze(np.asarray(Y, dtype=float))
+            assert Y.ndim == 1, "Y must be a 1D vector"
+            assert (
+                len(Y) == N
+            ), "Length of Y (%d) must match number of rows in X (%d)" % (len(Y), N)
+
+        max_exp = opts.get("max_experiments")
+        if max_exp is not None:
+            assert Y is not None, "opts.max_experiments requires Y to be provided"
+            if N > max_exp:
+                top_idx = np.argsort(Y)[::-1][:max_exp]
+                X = X[top_idx]
+                Y = Y[top_idx]
+                N = len(Y)
+
+        dim_labels = opts.get("dimensions")
+        if dim_labels is None:
+            dim_labels = ["Dim %d" % (i + 1) for i in range(M)]
+        assert isinstance(dim_labels, (list, tuple)), (
+            "opts.dimensions should be a list/tuple of length %d" % M
+        )
+        assert (
+            len(dim_labels) == M
+        ), "Length of opts.dimensions (%d) must match number of columns in X (%d)" % (
+            len(dim_labels),
+            M,
+        )
+
+        opt_ranges = opts.get("ranges") or {}
+        opt_constraints = opts.get("constraintranges") or {}
+        opt_tickvals = opts.get("tickvals") or {}
+        opt_ticktext = opts.get("ticktext") or {}
+
+        dimensions = []
+        for i in range(M):
+            col = X[:, i]
+            col_min, col_max = float(np.nanmin(col)), float(np.nanmax(col))
+            pad = (col_max - col_min) * 0.05 if col_max > col_min else 0.5
+            dim = {
+                "values": col.tolist(),
+                "label": str(dim_labels[i]),
+                "range": opt_ranges.get(i, [col_min - pad, col_max + pad]),
+            }
+            if i in opt_constraints:
+                dim["constraintrange"] = opt_constraints[i]
+            if i in opt_tickvals:
+                dim["tickvals"] = opt_tickvals[i]
+            if i in opt_ticktext:
+                assert (
+                    i in opt_tickvals
+                ), "opts.ticktext[%d] requires matching opts.tickvals[%d]" % (i, i)
+                assert len(opt_ticktext[i]) == len(opt_tickvals[i]), (
+                    "opts.ticktext[%d] and opts.tickvals[%d] must have the same length"
+                    % (i, i)
+                )
+                dim["ticktext"] = opt_ticktext[i]
+            dimensions.append(dim)
+
+        line_config = {}
+        if Y is not None:
+            line_config = {
+                "color": Y.tolist(),
+                "colorscale": opts.get("colormap", "Electric"),
+                "showscale": True,
+                "cmin": float(np.nanmin(Y)),
+                "cmax": float(np.nanmax(Y)),
+            }
+            if opts.get("reversescale"):
+                line_config["reversescale"] = True
+
+        title = opts.get("title")
+        trace = {
+            "type": "parcoords",
+            "dimensions": dimensions,
+            "line": line_config if line_config else None,
+            "labelfont": {"size": 13},
+            "tickfont": {"size": 11},
+            "rangefont": {"size": 11},
+        }
+        if title:
+            trace["domain"] = {"y": [0, 0.85]}
+
+        data = [_scrub_dict(trace)]
+
+        layout = _opts2layout(opts)
+        layout.setdefault("paper_bgcolor", "white")
+        layout.setdefault("plot_bgcolor", "white")
+        if title:
+            layout["title"] = {
+                "text": str(title),
+                "x": 0.5,
+                "xanchor": "center",
+            }
+
+        has_colorbar = bool(line_config)
+        if "width" not in opts:
+            colorbar_room = 100 if has_colorbar else 0
+            opts["width"] = max(600, M * 140 + colorbar_room)
+        if "height" not in opts:
+            opts["height"] = 450
+
+        return self._send(
+            {
+                "data": data,
+                "win": win,
+                "eid": env,
+                "layout": _scrub_dict(layout),
+                "opts": opts,
+            }
+        )
+
     @pytorch_wrap
     def violin(self, X, win=None, env=None, opts=None):
         """

py/visdom/__init__.pyi

@@ -297,6 +297,14 @@ class Visdom:
         env: _OptStr = ...,
         opts: _OptOps = ...,
     ) -> _SendReturn: ...
+    def parallel_coordinates(
+        self,
+        X: Tensor,
+        Y: Optional[Tensor] = ...,
+        win: _OptStr = ...,
+        env: _OptStr = ...,
+        opts: _OptOps = ...,
+    ) -> _SendReturn: ...
     def violin(
         self,
         X: Tensor,

py/visdom/server/handlers/web_handlers.py

@@ -573,7 +573,6 @@ def post(self, args):
                         escape_eid(args),
                         self.subs[sid],
                         self.storage,
-                        env_path=self.env_path,
                     )
                 except ValueError as e:
                     notify(

py/visdom/utils/server_utils.py

@@ -21,6 +21,7 @@
 import logging
 import os
 import time
+import errno
 from collections import OrderedDict
 
 MAX_ENV_NAME_LEN = 25
@@ -458,7 +459,7 @@ def send_to_sources(handler, msg):
         source.write_message(json.dumps(msg, cls=NanSafeEncoder))
 
 
-def load_env(state, eid, socket, store, env_path=DEFAULT_ENV_PATH):
+def load_env(state, eid, socket, store):
     """load an environment to a client by socket"""
     env = {}
     if eid in state: