Merge pull request #222 from Oxid15/develop

v0.12.1 - Security fixes and minor improvements

Author: Oxid15

cascade/__init__.py

@@ -15,7 +15,7 @@
 """
 
 
-__version__ = "0.12.0"
+__version__ = "0.12.1"
 __author__ = "Ilia Moiseev"
 __author_email__ = "ilia.moiseev.5@yandex.ru"
 

cascade/meta/history_viewer.py

@@ -19,7 +19,6 @@
 from typing import Any, Dict, List, Union
 
 import pandas as pd
-import pendulum
 from deepdiff import DeepDiff
 from flatten_json import flatten
 
@@ -51,14 +50,22 @@ def __init__(
         last_models: int, optional
             For each line constraints the number of models back from the last one to view
         """
+
+        try:
+            import plotly
+        except ModuleNotFoundError:
+            self._raise_cannot_import_plotly()
+        else:
+            from plotly import express as px
+            from plotly import graph_objects as go
+
+            self._px = px
+            self._go = go
+
         self._container = container
         self._last_lines = last_lines
         self._last_models = last_models
 
-        self._reload()
-        self._make_table()
-
-    def _reload(self) -> None:
         repo = self._container
         if isinstance(self._container, ModelLine):
             repo = SingleLineRepo(self._container)
@@ -72,9 +79,16 @@ def _reload(self) -> None:
             for repo in repos:
                 repo.reload()
 
+        self._edges = dict()
         self._repo = repo
         self._repos = {repo.get_root(): repo for repo in repos}
 
+        self._make_table()
+
+    def _update(self) -> None:
+        self._repo.reload()
+        self._make_table()
+
     def _get_last_updated_lines(self, line_names: List[str]) -> List[str]:
         valid_lines = []
         updated_at = []
@@ -113,18 +127,17 @@ def _make_table(self) -> None:
 
             last_models = self._last_models if self._last_models is not None else 0
             for i in range(len(line))[-last_models:]:
-                new_meta = {"line": line_root, "model": i}
+                line_name = os.path.split(line_root)[-1]
+                new_meta = {"line": line_name, "model": i}
                 try:
-                    # TODO: to take only first is not good...
                     meta = view[i][0]
+                    new_meta.update(flatten(meta))
                 except IndexError:
-                    meta = {}
-
-                new_meta.update(flatten(meta))
+                    pass
                 metas.append(new_meta)
 
                 p = {
-                    "line": line_root,
+                    "line": line_name,
                 }
                 if "params" in meta:
                     if len(meta["params"]) > 0:
@@ -136,6 +149,23 @@ def _make_table(self) -> None:
         if "saved_at" in self._table:
             self._table = self._table.sort_values("saved_at")
 
+        # turn time into evenly spaced intervals
+        time = [i for i in range(len(self._table))]
+        lines = self._table["line"].unique()
+
+        cmap = self._px.colors.qualitative.Plotly
+        cmap_len = len(self._px.colors.qualitative.Plotly)
+        line_cols = {line: cmap[i % cmap_len] for i, line in enumerate(lines)}
+
+        self._table["time"] = time
+        self._table["color"] = [line_cols[line] for line in self._table["line"]]
+        self._table = self._table.fillna("")
+
+        columns2fill = [
+            col for col in self._table.columns if not col.startswith("metrics_")
+        ]
+        self._table = self._table.fillna({name: "" for name in columns2fill})
+
     @staticmethod
     def _diff(p1: Dict[Any, Any], params: Dict[Any, Any]) -> List:
         diff = [DeepDiff(p1, p2) for p2 in params]
@@ -169,6 +199,23 @@ def _preprocess_metric(self, metric):
 
         return metric
 
+    def _connect_points(self, line: str, metric: str, fig: Any):
+        edges = [0]
+        params = [p for p in self._params if p["line"] == line]
+        for i in range(1, len(params)):
+            diff = self._diff(params[i], params[:i])
+            edges.append(self._specific_argmin(diff, i))
+
+        xs = []
+        ys = []
+        t = self._table.loc[self._table["line"] == line]
+        for i, e in enumerate(edges):
+            xs += [t["time"].iloc[i], t["time"].iloc[e], None]
+            ys += [t[metric].iloc[i], t[metric].iloc[e], None]
+
+        self._edges[line] = {"edges": (xs, ys), "len": len(t)}
+        return xs, ys
+
     def plot(self, metric: str, show: bool = False) -> Any:
         """
         Plots training history of model versions using plotly.
@@ -180,109 +227,76 @@ def plot(self, metric: str, show: bool = False) -> Any:
         show: bool, optional
             Whether to return and show or just return figure
         """
-        try:
-            import plotly
-        except ModuleNotFoundError:
-            self._raise_cannot_import_plotly()
-        else:
-            from plotly import express as px
-            from plotly import graph_objects as go
-
-        metric = self._preprocess_metric(metric)
-
-        # turn time into evenly spaced intervals
-        time = [i for i in range(len(self._table))]
-        lines = self._table["line"].unique()
-
-        cmap = px.colors.qualitative.Plotly
-        cmap_len = len(px.colors.qualitative.Plotly)
-        line_cols = {line: cmap[i % cmap_len] for i, line in enumerate(lines)}
-
-        self._table["time"] = time
-        self._table["color"] = [line_cols[line] for line in self._table["line"]]
-        table = self._table.fillna("")
-
-        columns2fill = [
-            col for col in self._table.columns if not col.startswith("metrics_")
-        ]
-        table = self._table.fillna({name: "" for name in columns2fill})
 
         # plot each model against metric
         # with all metadata on hover
+        metric = self._preprocess_metric(metric)
 
         hover_cols = [name for name in pd.DataFrame(self._params).columns]
-        if "saved_at" in table.columns:
+        if "saved_at" in self._table.columns:
             hover_cols = ["saved_at"] + hover_cols
         hover_cols = ["model"] + hover_cols
-        fig = px.scatter(table, x="time", y=metric, hover_data=hover_cols, color="line")
-
-        # determine connections between models
-        # plot each one with respected color
+        fig = self._px.scatter(self._table, x="time", y=metric, hover_data=hover_cols, color="line")
+        lines = self._table["line"].unique()
 
         for line in lines:
-            params = [p for p in self._params if p["line"] == line]
-            edges = []
-            for i in range(len(params)):
-                if i == 0:
-                    edges.append(0)
-                    continue
-                else:
-                    diff = self._diff(params[i], params[:i])
-                    edges.append(self._specific_argmin(diff, i))
-
-            xs = []
-            ys = []
-            t = table.loc[table["line"] == line]
-            for i, e in enumerate(edges):
-                xs += [t["time"].iloc[i], t["time"].iloc[e], None]
-                ys += [t[metric].iloc[i], t[metric].iloc[e], None]
+            t = self._table.loc[self._table.line == line]
+            self._connect_points(line, metric, fig)
 
+            xs, ys = self._edges[line]["edges"]
             fig.add_trace(
-                go.Scatter(
+                self._go.Scatter(
                     x=xs,
                     y=ys,
                     mode="lines",
-                    marker={"color": t["color"].iloc[0]},
                     name=line,
                     hoverinfo="none",
+                    marker_color=t["color"].iloc[0]
                 )
             )
 
-        # Create human-readable ticks
-        now = pendulum.now(tz="UTC")
-        time_text = table["saved_at"].apply(
-            lambda t: t if t == "" else pendulum.parse(t).diff_for_humans(now)
-        )
-
-        fig.update_layout(
-            hovermode="x",
-            xaxis=dict(
-                tickmode="array",
-                tickvals=[i for i in range(len(time))],
-                ticktext=time_text,
-            ),
-        )
         if show:
             fig.show()
 
         return fig
 
-    def _layout(self, metric):
+    def _update_plot(self, metric: str) -> Any:
+        metric = self._preprocess_metric(metric)
+
+        hover_cols = [name for name in pd.DataFrame(self._params).columns]
+        if "saved_at" in self._table.columns:
+            hover_cols = ["saved_at"] + hover_cols
+        hover_cols = ["model"] + hover_cols
+        fig = self._px.scatter(self._table, x="time", y=metric, hover_data=hover_cols, color="line")
+
+        for line in sorted(self._table.line.unique()):
+            t = self._table.loc[self._table.line == line]
+            if line in self._edges and len(t) == self._edges[line]["len"]:
+                xs, ys = self._edges[line]["edges"]
+            else:
+                xs, ys = self._connect_points(line, metric, fig)
+            fig.add_trace(
+                self._go.Scatter(
+                    x=xs,
+                    y=ys,
+                    mode="lines",
+                    name=line,
+                    hoverinfo="none",
+                    marker_color=t["color"].iloc[0]
+                )
+            )
+
+        return fig
+
+    def _layout(self, metric: Union[str, None]):
         try:
             import dash
         except ModuleNotFoundError:
             self._raise_cannot_import_dash()
         else:
             from dash import Input, Output, dcc, html
 
-        try:
-            import plotly
-        except ModuleNotFoundError:
-            self._raise_cannot_import_plotly()
-        else:
-            from plotly import graph_objects as go
-
-        fig = self.plot(metric) if metric is not None else go.Figure()
+        fig = self.plot(metric) if metric is not None else self._go.Figure()
 
         return html.Div(
             [
@@ -337,15 +351,8 @@ def serve(self, metric: Union[str, None] = None, **kwargs: Any) -> None:
         else:
             from dash import Input, Output
 
-        try:
-            import plotly
-        except ModuleNotFoundError:
-            self._raise_cannot_import_plotly()
-        else:
-            from plotly import graph_objects as go
-
         app = dash.Dash()
-        app.layout = self._layout(metric)
+        app.layout = lambda: self._layout(metric)
 
         @app.callback(
             Output("viewer-title", "children"), Input("history-interval", "n_intervals")
@@ -371,10 +378,9 @@ def update_dropdown(n_intervals):
             prevent_initial_call=True,
         )
         def update_history(n_intervals, metric):
-            self._reload()
-
-            self._make_table()
-            return self.plot(metric) if metric is not None else go.Figure()
+            self._update()
+            return (self._update_plot(metric)
+                    if metric is not None else self._go.Figure())
 
         @app.callback(
             Output("metric-dropwdown", "value"),
@@ -385,6 +391,4 @@ def update_repos(name):
             if isinstance(self._container, Workspace):
                 self._container.set_default(os.path.split(name)[-1])
 
-            return None
-
         app.run_server(use_reloader=False, **kwargs)

cascade/models/model_repo.py

@@ -23,6 +23,7 @@
     HistoryLogger,
     JSONEncoder,
     MetaHandler,
+    MetaFromFile,
     PipeMeta,
     Traceable,
     TraceableOnDisk,
@@ -50,7 +51,6 @@ def __init__(
         self._lines = dict()
 
     def reload(self) -> None:
-        # TODO: implement full reload
         for line in self._lines:
             self._lines[line].reload()
 
@@ -254,14 +254,60 @@ def __repr__(self) -> str:
 
     def reload(self) -> None:
         """
-        Updates internal state.
+        Updates internal state
         """
         super().reload()
+        self._update_lines()
         self._update_meta()
 
-    def __add__(self, repo) -> "ModelRepoConcatenator":
+    def __add__(self, repo: "ModelRepo") -> "ModelRepoConcatenator":
         return ModelRepoConcatenator([self, repo])
 
+    def load_model_meta(self, model: str) -> MetaFromFile:
+        """
+        Loads metadata of a model from disk
+
+        Parameters
+        ----------
+        model : str
+            model slug e.g. `fair_squid_of_bliss`
+
+        Returns
+        -------
+        MetaFromFile
+            Model metadata
+
+        Raises
+        ------
+        FileNotFoundError
+            Raises if failed to find the model with slug specified
+        """
+
+        for line in self._lines.values():
+            try:
+                meta = line.load_model_meta(model)
+            except FileNotFoundError:
+                continue
+            else:
+                return meta
+        raise FileNotFoundError(
+            f"Failed to find the model {model} in the repo at {self._root}"
+        )
+
+    def _update_lines(self) -> None:
+        for name in sorted(os.listdir(self._root)):
+            if (
+                os.path.isdir(os.path.join(self._root, name))
+                and name not in self._lines
+            ):
+                self._lines[name] = ModelLine(
+                    os.path.join(self._root, name),
+                    model_cls=self._model_cls
+                    if isinstance(self._model_cls, type)
+                    else self._model_cls[name],
+                    meta_fmt=self._meta_fmt,
+                )
+
 
 class ModelRepoConcatenator(Repo):
     """