supervisely 6.73.254__py3-none-any.whl → 6.73.256__py3-none-any.whl

supervisely/nn/benchmark/comparison/semantic_segmentation/vis_metrics/speedtest.py

@@ -0,0 +1,314 @@
+from typing import List, Union
+
+from supervisely.imaging.color import hex2rgb
+from supervisely.nn.benchmark.base_visualizer import BaseVisMetrics
+from supervisely.nn.benchmark.visualization.widgets import (
+    ChartWidget,
+    MarkdownWidget,
+    TableWidget,
+)
+
+
+class Speedtest(BaseVisMetrics):
+
+    def is_empty(self) -> bool:
+        return not any(eval_result.speedtest_info for eval_result in self.eval_results)
+
+    def multiple_batche_sizes(self) -> bool:
+        for eval_result in self.eval_results:
+            if eval_result.speedtest_info is None:
+                continue
+            if len(eval_result.speedtest_info["speedtest"]) > 1:
+                return True
+        return False
+
+    @property
+    def latency(self) -> List[Union[int, str]]:
+        latency = []
+        for eval_result in self.eval_results:
+            if eval_result.speedtest_info is None:
+                latency.append("N/A")
+            else:
+                added = False
+                for test in eval_result.speedtest_info["speedtest"]:
+                    if test["batch_size"] == 1:
+                        latency.append(round(test["benchmark"]["total"], 2))
+                        added = True
+                        break
+                if not added:
+                    latency.append("N/A")
+        return latency
+
+    @property
+    def fps(self) -> List[Union[int, str]]:
+        fps = []
+        for eval_result in self.eval_results:
+            if eval_result.speedtest_info is None:
+                fps.append("N/A")
+            else:
+                added = False
+                for test in eval_result.speedtest_info["speedtest"]:
+                    if test["batch_size"] == 1:
+                        fps.append(round(1000 / test["benchmark"]["total"], 2))
+                        added = True
+                        break
+                if not added:
+                    fps.append("N/A")
+        return fps
+
+    @property
+    def md_intro(self) -> MarkdownWidget:
+        return MarkdownWidget(
+            name="speedtest_intro",
+            title="Inference Speed",
+            text=self.vis_texts.markdown_speedtest_intro,
+        )
+
+    @property
+    def intro_table(self) -> TableWidget:
+        columns = ["Model", "Device", "Hardware", "Runtime"]
+        columns_options = [{"disableSort": True} for _ in columns]
+        content = []
+        for i, eval_result in enumerate(self.eval_results, 1):
+            name = f"[{i}] {eval_result.name}"
+            if eval_result.speedtest_info is None:
+                row = [name, "N/A", "N/A", "N/A"]
+                dct = {
+                    "row": row,
+                    "id": name,
+                    "items": row,
+                }
+                content.append(dct)
+                continue
+            model_info = eval_result.speedtest_info.get("model_info", {})
+            device = model_info.get("device", "N/A")
+            hardware = model_info.get("hardware", "N/A")
+            runtime = model_info.get("runtime", "N/A")
+            row = [name, device, hardware, runtime]
+            dct = {
+                "row": row,
+                "id": name,
+                "items": row,
+            }
+            content.append(dct)
+
+        data = {
+            "columns": columns,
+            "columnsOptions": columns_options,
+            "content": content,
+        }
+        return TableWidget(
+            name="speedtest_intro_table",
+            data=data,
+            show_header_controls=False,
+            fix_columns=1,
+        )
+
+    @property
+    def inference_time_md(self) -> MarkdownWidget:
+        text = self.vis_texts.markdown_speedtest_overview_ms.format(100)
+        return MarkdownWidget(
+            name="inference_time_md",
+            title="Overview",
+            text=text,
+        )
+
+    @property
+    def fps_md(self) -> MarkdownWidget:
+        text = self.vis_texts.markdown_speedtest_overview_fps.format(100)
+        return MarkdownWidget(
+            name="fps_md",
+            title="FPS Table",
+            text=text,
+        )
+
+    @property
+    def fps_table(self) -> TableWidget:
+        data = {}
+        batch_sizes = set()
+        max_fps = 0
+        for i, eval_result in enumerate(self.eval_results, 1):
+            data[i] = {}
+            if eval_result.speedtest_info is None:
+                continue
+            speedtests = eval_result.speedtest_info["speedtest"]
+            for test in speedtests:
+                batch_size = test["batch_size"]
+                fps = round(1000 / test["benchmark"]["total"] * batch_size)
+                batch_sizes.add(batch_size)
+                max_fps = max(max_fps, fps)
+                data[i][batch_size] = fps
+
+        batch_sizes = sorted(batch_sizes)
+        columns = ["Model"]
+        columns_options = [{"disableSort": True}]
+        for batch_size in batch_sizes:
+            columns.append(f"Batch size {batch_size}")
+            columns_options.append(
+                {
+                    "subtitle": "imgs/sec",
+                    "tooltip": "Frames (images) per second",
+                    "postfix": "fps",
+                    # "maxValue": max_fps,
+                }
+            )
+
+        content = []
+        for i, eval_result in enumerate(self.eval_results, 1):
+            name = f"[{i}] {eval_result.name}"
+            row = [name]
+            for batch_size in batch_sizes:
+                if batch_size in data[i]:
+                    row.append(data[i][batch_size])
+                else:
+                    row.append("―")
+            content.append(
+                {
+                    "row": row,
+                    "id": name,
+                    "items": row,
+                }
+            )
+        data = {
+            "columns": columns,
+            "columnsOptions": columns_options,
+            "content": content,
+        }
+        return TableWidget(
+            name="fps_table",
+            data=data,
+            show_header_controls=False,
+            fix_columns=1,
+        )
+
+    @property
+    def inference_time_table(self) -> TableWidget:
+        data = {}
+        batch_sizes = set()
+        for i, eval_result in enumerate(self.eval_results, 1):
+            data[i] = {}
+            if eval_result.speedtest_info is None:
+                continue
+            speedtests = eval_result.speedtest_info["speedtest"]
+            for test in speedtests:
+                batch_size = test["batch_size"]
+                ms = round(test["benchmark"]["total"], 2)
+                batch_sizes.add(batch_size)
+                data[i][batch_size] = ms
+
+        batch_sizes = sorted(batch_sizes)
+        columns = ["Model"]
+        columns_options = [{"disableSort": True}]
+        for batch_size in batch_sizes:
+            columns.extend([f"Batch size {batch_size}"])
+            columns_options.extend(
+                [
+                    {"subtitle": "ms", "tooltip": "Milliseconds for batch images", "postfix": "ms"},
+                ]
+            )
+
+        content = []
+        for i, eval_result in enumerate(self.eval_results, 1):
+            name = f"[{i}] {eval_result.name}"
+            row = [name]
+            for batch_size in batch_sizes:
+                if batch_size in data[i]:
+                    row.append(data[i][batch_size])
+                else:
+                    row.append("―")
+            content.append(
+                {
+                    "row": row,
+                    "id": name,
+                    "items": row,
+                }
+            )
+
+        data = {
+            "columns": columns,
+            "columnsOptions": columns_options,
+            "content": content,
+        }
+        return TableWidget(
+            name="inference_time_md",
+            data=data,
+            show_header_controls=False,
+            fix_columns=1,
+        )
+
+    @property
+    def batch_inference_md(self):
+        return MarkdownWidget(
+            name="batch_inference",
+            title="Batch Inference",
+            text=self.vis_texts.markdown_batch_inference,
+        )
+
+    @property
+    def chart(self) -> ChartWidget:
+        return ChartWidget(name="speed_charts", figure=self.get_figure())
+
+    def get_figure(self):  #  -> Optional[go.Figure]
+        import plotly.graph_objects as go  # pylint: disable=import-error
+        from plotly.subplots import make_subplots  # pylint: disable=import-error
+
+        fig = make_subplots(cols=2)
+
+        for idx, eval_result in enumerate(self.eval_results, 1):
+            if eval_result.speedtest_info is None:
+                continue
+            temp_res = {}
+            for test in eval_result.speedtest_info["speedtest"]:
+                batch_size = test["batch_size"]
+
+                std = test["benchmark_std"]["total"]
+                ms = test["benchmark"]["total"]
+                fps = round(1000 / test["benchmark"]["total"] * batch_size)
+
+                ms_line = temp_res.setdefault("ms", {})
+                fps_line = temp_res.setdefault("fps", {})
+                ms_std_line = temp_res.setdefault("ms_std", {})
+
+                ms_line[batch_size] = ms
+                fps_line[batch_size] = fps
+                ms_std_line[batch_size] = round(std, 2)
+
+            error_color = "rgba(" + ",".join(map(str, hex2rgb(eval_result.color))) + ", 0.5)"
+            fig.add_trace(
+                go.Scatter(
+                    x=list(temp_res["ms"].keys()),
+                    y=list(temp_res["ms"].values()),
+                    name=f"[{idx}] {eval_result.name} (ms)",
+                    line=dict(color=eval_result.color),
+                    customdata=list(temp_res["ms_std"].values()),
+                    error_y=dict(
+                        type="data",
+                        array=list(temp_res["ms_std"].values()),
+                        visible=True,
+                        color=error_color,
+                    ),
+                    hovertemplate="Batch Size: %{x}<br>Time: %{y:.2f} ms<br> Standard deviation: %{customdata:.2f} ms<extra></extra>",
+                ),
+                col=1,
+                row=1,
+            )
+            fig.add_trace(
+                go.Scatter(
+                    x=list(temp_res["fps"].keys()),
+                    y=list(temp_res["fps"].values()),
+                    name=f"[{idx}] {eval_result.name} (fps)",
+                    line=dict(color=eval_result.color),
+                    hovertemplate="Batch Size: %{x}<br>FPS: %{y:.2f}<extra></extra>",  # <br> Standard deviation: %{customdata:.2f}<extra></extra>",
+                ),
+                col=2,
+                row=1,
+            )
+
+        fig.update_xaxes(title_text="Batch size", col=1, dtick=1)
+        fig.update_xaxes(title_text="Batch size", col=2, dtick=1)
+
+        fig.update_yaxes(title_text="Time (ms)", col=1)
+        fig.update_yaxes(title_text="FPS", col=2)
+        fig.update_layout(height=400)
+
+        return fig

supervisely/nn/benchmark/comparison/semantic_segmentation/visualizer.py

@@ -0,0 +1,159 @@
+from typing import List
+
+import supervisely.nn.benchmark.comparison.semantic_segmentation.text_templates as texts
+from supervisely.nn.benchmark.comparison.base_visualizer import BaseComparisonVisualizer
+from supervisely.nn.benchmark.comparison.semantic_segmentation.vis_metrics import (
+    ClasswiseErrorAnalysis,
+    ExplorePredictions,
+    FrequentlyConfused,
+    IntersectionErrorOverUnion,
+    Overview,
+    RenormalizedErrorOverUnion,
+    Speedtest,
+)
+from supervisely.nn.benchmark.semantic_segmentation.evaluator import (
+    SemanticSegmentationEvalResult,
+)
+from supervisely.nn.benchmark.visualization.widgets import (
+    ContainerWidget,
+    MarkdownWidget,
+    SidebarWidget,
+)
+
+
+class SemanticSegmentationComparisonVisualizer(BaseComparisonVisualizer):
+    vis_texts = texts
+    ann_opacity = 0.7
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.eval_results: List[SemanticSegmentationEvalResult]
+
+    def _create_widgets(self):
+        # Modal Gellery
+        self.diff_modal = self._create_diff_modal_table()
+        self.explore_modal = self._create_explore_modal_table(
+            click_gallery_id=self.diff_modal.id, hover_text="Compare with GT"
+        )
+
+        # Notifcation
+        self.clickable_label = self._create_clickable_label()
+
+        # Speedtest init here for overview
+        speedtest = Speedtest(self.vis_texts, self.comparison.eval_results)
+
+        # Overview
+        overview = Overview(self.vis_texts, self.comparison.eval_results)
+        overview.team_id = self.comparison.team_id
+        self.header = self._create_header()
+        self.overviews = self._create_overviews(overview, grid_cols=2)
+        self.overview_md = overview.overview_md
+        self.key_metrics_md = self._create_key_metrics()
+        self.key_metrics_table = overview.get_table_widget(
+            latency=speedtest.latency, fps=speedtest.fps
+        )
+        self.overview_chart = overview.chart_widget
+
+        # Explore Predictions
+        columns_number = len(self.comparison.eval_results) + 1  # +1 for GT
+        self.explore_predictions_modal_gallery = self._create_explore_modal_table(columns_number)
+        explore_predictions = ExplorePredictions(
+            self.vis_texts,
+            self.comparison.eval_results,
+            explore_modal_table=self.explore_predictions_modal_gallery,
+        )
+        self.explore_predictions_md = explore_predictions.difference_predictions_md
+        self.explore_predictions_gallery = explore_predictions.explore_gallery
+
+        # IntersectionErrorOverUnion
+        iou_eou = IntersectionErrorOverUnion(self.vis_texts, self.comparison.eval_results)
+        self.iou_eou_md = iou_eou.md
+        self.iou_eou_chart = iou_eou.chart
+
+        # RenormalizedErrorOverUnion
+        reou = RenormalizedErrorOverUnion(self.vis_texts, self.comparison.eval_results)
+        self.reou_md = reou.md
+        self.reou_chart = reou.chart
+
+        # ClasswiseErrorAnalysis
+        classwise_ea = ClasswiseErrorAnalysis(self.vis_texts, self.comparison.eval_results)
+        self.classwise_ea_md = classwise_ea.md
+        self.classwise_ea_chart = classwise_ea.chart
+
+        # FrequentlyConfused
+        frequently_confused = FrequentlyConfused(self.vis_texts, self.comparison.eval_results)
+        self.frequently_confused_md = frequently_confused.md
+        self.frequently_confused_chart = frequently_confused.chart
+
+        # # SpeedTest
+        self.speedtest_present = not speedtest.is_empty()
+        self.speedtest_multiple_batch_sizes = False
+
+        if self.speedtest_present:
+            self.speedtest_md_intro = speedtest.md_intro
+            self.speedtest_intro_table = speedtest.intro_table
+            self.speed_inference_time_md = speedtest.inference_time_md
+            self.speed_inference_time_table = speedtest.inference_time_table
+            self.speed_fps_md = speedtest.fps_md
+            self.speed_fps_table = speedtest.fps_table
+            self.speedtest_multiple_batch_sizes = speedtest.multiple_batche_sizes()
+            if self.speedtest_multiple_batch_sizes:
+                self.speed_batch_inference_md = speedtest.batch_inference_md
+                self.speed_chart = speedtest.chart
+
+    def _create_layout(self):
+        is_anchors_widgets = [
+            # Overview
+            (0, self.header),
+            (1, self.overview_md),
+            (0, self.overviews),
+            (1, self.key_metrics_md),
+            (0, self.key_metrics_table),
+            (0, self.overview_chart),
+            # Explore Predictions
+            (1, self.explore_predictions_md),
+            (0, self.explore_predictions_gallery),
+            # IntersectionErrorOverUnion
+            (1, self.iou_eou_md),
+            (0, self.iou_eou_chart),
+            # RenormalizedErrorOverUnion
+            (1, self.reou_md),
+            (0, self.reou_chart),
+            # ClasswiseErrorAnalysis
+            (1, self.classwise_ea_md),
+            (0, self.classwise_ea_chart),
+            # FrequentlyConfused
+            (1, self.frequently_confused_md),
+            (0, self.frequently_confused_chart),
+        ]
+        if self.speedtest_present:
+            is_anchors_widgets.extend(
+                [
+                    # SpeedTest
+                    (1, self.speedtest_md_intro),
+                    (0, self.speedtest_intro_table),
+                    (0, self.speed_inference_time_md),
+                    (0, self.speed_inference_time_table),
+                    (0, self.speed_fps_md),
+                    (0, self.speed_fps_table),
+                ]
+            )
+            if self.speedtest_multiple_batch_sizes:
+                is_anchors_widgets.append((0, self.speed_batch_inference_md))
+                is_anchors_widgets.append((0, self.speed_chart))
+        anchors = []
+        for is_anchor, widget in is_anchors_widgets:
+            if is_anchor:
+                anchors.append(widget.id)
+
+        sidebar = SidebarWidget(widgets=[i[1] for i in is_anchors_widgets], anchors=anchors)
+        layout = ContainerWidget(
+            widgets=[sidebar, self.explore_modal, self.explore_predictions_modal_gallery],
+            name="main_container",
+        )
+        return layout
+
+    def _create_key_metrics(self) -> MarkdownWidget:
+        return MarkdownWidget(
+            "markdown_key_metrics", "Key Metrics", text=self.vis_texts.markdown_key_metrics
+        )

supervisely/nn/benchmark/instance_segmentation/evaluator.py

@@ -39,7 +39,7 @@ class InstanceSegmentationEvaluator(ObjectDetectionEvaluator):
         except AssertionError as e:
             raise ValueError(
                 f"{e}. Please make sure that your GT and DT projects are correct. "
-                "If GT project has nested datasets and DT project was crated with NN app, "
+                "If GT project has nested datasets and DT project was created with NN app, "
                 "try to use newer version of NN app."
             )
 

supervisely/nn/benchmark/object_detection/evaluator.py

@@ -104,7 +104,7 @@ class ObjectDetectionEvaluator(BaseEvaluator):
         except AssertionError as e:
             raise ValueError(
                 f"{e}. Please make sure that your GT and DT projects are correct. "
-                "If GT project has nested datasets and DT project was crated with NN app, "
+                "If GT project has nested datasets and DT project was created with NN app, "
                 "try to use newer version of NN app."
             )
         self.cocoGt, self.cocoDt = read_coco_datasets(self.cocoGt_json, self.cocoDt_json)

supervisely/nn/benchmark/object_detection/vis_metrics/overview.py

@@ -24,9 +24,7 @@ class Overview(DetectionVisMetric):
         link_text = link_text.replace("_", "\_")
 
         model_name = self.eval_result.inference_info.get("model_name") or "Custom"
-        checkpoint_name = self.eval_result.inference_info.get("deploy_params", {}).get(
-            "checkpoint_name", ""
-        )
+        checkpoint_name = self.eval_result.checkpoint_name
 
         # Note about validation dataset
         classes_str, note_about_images, starter_app_info = self._get_overview_info()

supervisely/nn/benchmark/object_detection/vis_metrics/precision.py

@@ -69,4 +69,7 @@ class Precision(DetectionVisMetric):
             )
         fig.update_xaxes(title_text="Class")
         fig.update_yaxes(title_text="Precision", range=[0, 1])
+        fig.update_layout(
+            width=700 if len(sorted_by_precision) < 10 else None,
+        )
         return fig

supervisely/nn/benchmark/object_detection/vis_metrics/recall.py

@@ -68,4 +68,7 @@ class Recall(DetectionVisMetric):
             )
         fig.update_xaxes(title_text="Class")
         fig.update_yaxes(title_text="Recall", range=[0, 1])
+        fig.update_layout(
+            width=700 if len(sorted_by_f1) < 10 else None,
+        )
         return fig

supervisely/nn/benchmark/object_detection/vis_metrics/recall_vs_precision.py

@@ -50,7 +50,7 @@ class RecallVsPrecision(DetectionVisMetric):
                 marker=dict(color=orange_color),
             )
         )
-        fig.update_layout(barmode="group")
+        fig.update_layout(barmode="group", width=800 if len(sorted_by_f1) < 10 else None)
         fig.update_xaxes(title_text="Class")
         fig.update_yaxes(title_text="Value", range=[0, 1])
         return fig

supervisely/nn/benchmark/object_detection/visualizer.py

@@ -56,21 +56,17 @@ class ObjectDetectionVisualizer(BaseVisualizer):
         self._widgets = False
         self.ann_opacity = 0.4
 
-        diff_project_info, diff_dataset_infos, existed = self._get_or_create_diff_project()
+        diff_project_info, diff_dataset_infos, _ = self._get_or_create_diff_project()
         self.eval_result.diff_project_info = diff_project_info
         self.eval_result.diff_dataset_infos = diff_dataset_infos
         self.eval_result.matched_pair_data = {}
 
         self.gt_project_path = str(Path(self.workdir).parent / "gt_project")
         self.pred_project_path = str(Path(self.workdir).parent / "pred_project")
-        if not existed:
-            self.update_diff_annotations()
-        else:
-            self._init_match_data()
+        self.update_diff_annotations()
 
         # set filtered project meta
         self.eval_result.filtered_project_meta = self._get_filtered_project_meta(self.eval_result)
-
         self._get_sample_data_for_gallery()
 
     @property
@@ -222,10 +218,9 @@ class ObjectDetectionVisualizer(BaseVisualizer):
 
         # Speedtest init here for overview
         speedtest = Speedtest(self.vis_texts, self.eval_result)
-        self.speedtest_present = False
+        self.speedtest_present = not speedtest.is_empty()
         self.speedtest_batch_sizes_cnt = speedtest.num_batche_sizes
-        if not speedtest.is_empty():
-            self.speedtest_present = True
+        if self.speedtest_present:
             self.speedtest_md_intro = speedtest.intro_md
             self.speedtest_table_md = speedtest.table_md
             self.speedtest_table = speedtest.table
@@ -393,7 +388,7 @@ class ObjectDetectionVisualizer(BaseVisualizer):
 
         pred_tag_list = []
         with self.pbar(
-            message="Visualizations: Creating diff_project", total=pred_project.total_items
+            message="Visualizations: Creating difference project", total=pred_project.total_items
         ) as progress:
             logger.debug(
                 "Creating diff project data",

supervisely/nn/benchmark/semantic_segmentation/evaluator.py

@@ -97,7 +97,13 @@ class SemanticSegmentationEvaluator(BaseEvaluator):
         meta_path = Path(project_path) / "meta.json"
         meta = ProjectMeta.from_json(load_json_file(meta_path))
 
-        palette = [obj.color for obj in meta.obj_classes if obj.name in self.classes_whitelist]
+        palette = []
+        for cls_name in self.classes_whitelist:
+            obj_cls = meta.get_obj_class(cls_name)
+            if obj_cls is None:
+                palette.append((0, 0, 0))
+            else:
+                palette.append(obj_cls.color)
 
         return palette
 
@@ -123,7 +129,11 @@ class SemanticSegmentationEvaluator(BaseEvaluator):
                 continue
 
             palette = self._get_palette(src_dir)
-            bg_color = palette[self.classes_whitelist.index(self.bg_cls_name)]
+            bg_cls_idx = self.classes_whitelist.index(self.bg_cls_name)
+            try:
+                bg_color = palette[bg_cls_idx]
+            except IndexError:
+                bg_color = (0, 0, 0)
             output_dir.mkdir(parents=True)
             temp_seg_dir = src_dir + "_temp"
             if not os.path.exists(temp_seg_dir):

supervisely/nn/benchmark/semantic_segmentation/metric_provider.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 import numpy as np
 
@@ -65,7 +65,7 @@ class MetricProvider:
 
         # frequently confused classes
         self.frequently_confused = self.get_frequently_confused(
-            eval_data["confusion_matrix"].copy()
+            eval_data["confusion_matrix"].copy(), n_pairs=20
         )
 
     def json_metrics(self):
@@ -114,18 +114,17 @@ class MetricProvider:
         confusion_matrix = confusion_matrix[::-1]
         return confusion_matrix, class_names
 
-    def get_frequently_confused(self, confusion_matrix: np.ndarray):
-        n_pairs = 20
+    def get_frequently_confused(self, confusion_matrix: np.ndarray, n_pairs: Optional[int] = None):
 
-        non_diagonal_indexes = {}
+        non_diagonal_ids = {}
         for i, idx in enumerate(np.ndindex(confusion_matrix.shape)):
             if idx[0] != idx[1]:
-                non_diagonal_indexes[i] = idx
+                non_diagonal_ids[i] = idx
 
         indexes_1d = np.argsort(confusion_matrix, axis=None)
-        indexes_2d = [
-            non_diagonal_indexes[idx] for idx in indexes_1d if idx in non_diagonal_indexes
-        ][-n_pairs:]
+        indexes_2d = [non_diagonal_ids[idx] for idx in indexes_1d if idx in non_diagonal_ids]
+        if n_pairs is not None:
+            indexes_2d = indexes_2d[:n_pairs]
         indexes_2d = np.asarray(indexes_2d[::-1])
 
         rows = indexes_2d[:, 0]

supervisely/nn/benchmark/semantic_segmentation/text_templates.py

@@ -40,7 +40,7 @@ We provide a comprehensive model performance analysis using a set of metrics, in
 
 - **Pixel accuracy**: reflects the percent of image pixels which were correctly classified.
 - **Precision**: reflects the number of correctly predicted positive segmentations divided by the total number of predicted positive segmentations.
-- **Recall8**: reflects the number of correctly predicted positive segmentations divided by the number of all samples that should have been segmented as positive.
+- **Recall**: reflects the number of correctly predicted positive segmentations divided by the number of all samples that should have been segmented as positive.
 - **F1-score**: reflects the tradeoff between precision and recall. It is equivalent to the Dice coefficient and calculated as a harmonic mean of precision and recall.
 - **Intersection over union (IoU, also known as the Jaccard index)**: measures the overlap between ground truth mask and predicted mask. It is calculated as the ratio of the intersection of the two masks areas to their combined areas.
 - **Boundary intersection over union**: a segmentation consistency measure that first computes the sets of ground truth  and predicted masks pixels that are located within the distance d from each contour and then computes intersection over union of these two sets. Pixel distance parameter d (pixel width of the boundary region) controls the sensitivity of the metric, it is usually set as 2% of the image diagonal for normal resolution images and 0.5% of the image diagonal for high resolution images.
@@ -72,7 +72,7 @@ The pie chart below demonstrates what the model lacked in order to show the perf
 
 markdown_renormalized_error_ou = """## Renormalized Error Over Union
 
-The pie chart below is dedicated to decomposition of postprocessed variant of error over union which takes into consideration cause and effect relationships between different types of segmentation errors. Error over union decomposition has its own pitfalls. It is important to understand that models which tend to produce segment errors (when entire segments are mispredicted and there is no intersection between ground truth and predicted mask) will face less occasions to produce boundary and extent errors - as a result, boundary and extent error over union values will be underestimated.
+The chart below is dedicated to decomposition of postprocessed variant of error over union which takes into consideration cause and effect relationships between different types of segmentation errors. Error over union decomposition has its own pitfalls. It is important to understand that models which tend to produce segment errors (when entire segments are mispredicted and there is no intersection between ground truth and predicted mask) will face less occasions to produce boundary and extent errors - as a result, boundary and extent error over union values will be underestimated.
 
 In terms of localization, segment error is more fundamental than extent, while extent error is more fundamental than boundary. In order to overcome this problem, renormalized error over union proposes a slightly different calculation method - by removing more fundamental errors from the denominator - read more in our <a href="{}" target="_blank">technical report</a>
 """.format(