supervisely 6.73.242__py3-none-any.whl → 6.73.244__py3-none-any.whl

supervisely/nn/training/gui/input_selector.py

@@ -0,0 +1,70 @@
+from supervisely.api.project_api import ProjectInfo
+from supervisely.app.widgets import (
+    Button,
+    Card,
+    Checkbox,
+    Container,
+    Field,
+    ProjectThumbnail,
+    Text,
+)
+from supervisely.project.download import is_cached
+
+
+class InputSelector:
+    title = "Input project"
+    description = "Selected project from which images and annotations will be downloaded"
+    lock_message = None
+
+    def __init__(self, project_info: ProjectInfo, app_options: dict = {}):
+        self.project_id = project_info.id
+        self.project_info = project_info
+
+        self.project_thumbnail = ProjectThumbnail(self.project_info)
+
+        if is_cached(self.project_id):
+            _text = "Use cached data stored on the agent to optimize project download"
+        else:
+            _text = "Cache data on the agent to optimize project download for future trainings"
+        self.use_cache_text = Text(_text)
+        self.use_cache_checkbox = Checkbox(self.use_cache_text, checked=True)
+
+        self.validator_text = Text("")
+        self.validator_text.hide()
+        self.button = Button("Select")
+        container = Container(
+            widgets=[
+                self.project_thumbnail,
+                self.use_cache_checkbox,
+                self.validator_text,
+                self.button,
+            ]
+        )
+
+        self.card = Card(
+            title=self.title,
+            description=self.description,
+            content=container,
+            collapsable=app_options.get("collapsable", False),
+        )
+
+    @property
+    def widgets_to_disable(self) -> list:
+        return [
+            self.use_cache_checkbox,
+        ]
+
+    def get_project_id(self) -> int:
+        return self.project_id
+
+    def set_cache(self, value: bool) -> None:
+        if value:
+            self.use_cache_checkbox.check()
+        else:
+            self.use_cache_checkbox.uncheck()
+
+    def get_cache_value(self) -> bool:
+        return self.use_cache_checkbox.is_checked()
+
+    def validate_step(self) -> bool:
+        return True

supervisely/nn/training/gui/model_selector.py

@@ -0,0 +1,95 @@
+from typing import Literal
+
+import supervisely.io.env as sly_env
+from supervisely.api.api import Api
+from supervisely.app.widgets import (
+    Button,
+    Card,
+    Container,
+    ExperimentSelector,
+    PretrainedModelsSelector,
+    RadioTabs,
+    Text,
+)
+from supervisely.nn.experiments import get_experiment_infos
+from supervisely.nn.utils import ModelSource
+
+
+class ModelSelector:
+    title = "Select Model"
+    description = "Select a model for training"
+    lock_message = "Select classes to unlock"
+
+    def __init__(self, api: Api, framework: str, models: list, app_options: dict = {}):
+        self.team_id = sly_env.team_id()  # get from project id
+        self.models = models
+
+        # Pretrained models
+        self.pretrained_models_table = PretrainedModelsSelector(self.models)
+
+        experiment_infos = get_experiment_infos(api, self.team_id, framework)
+        self.experiment_selector = ExperimentSelector(self.team_id, experiment_infos)
+        # Model source tabs
+        self.model_source_tabs = RadioTabs(
+            titles=[ModelSource.PRETRAINED, ModelSource.CUSTOM],
+            descriptions=[
+                "Publicly available models",
+                "Models trained by you in Supervisely",
+            ],
+            contents=[self.pretrained_models_table, self.experiment_selector],
+        )
+
+        self.validator_text = Text("")
+        self.validator_text.hide()
+        self.button = Button("Select")
+        container = Container([self.model_source_tabs, self.validator_text, self.button])
+        self.card = Card(
+            title=self.title,
+            description=self.description,
+            content=container,
+            lock_message=self.lock_message,
+            collapsable=app_options.get("collapsable", False),
+        )
+        self.card.lock()
+
+    @property
+    def widgets_to_disable(self) -> list:
+        return [
+            self.model_source_tabs,
+            self.pretrained_models_table,
+            self.experiment_selector,
+        ]
+
+    def get_model_source(self) -> str:
+        return self.model_source_tabs.get_active_tab()
+
+    def set_model_source(self, source: Literal["Pretrained models", "Custom models"]) -> None:
+        self.model_source_tabs.set_active_tab(source)
+
+    def get_model_name(self) -> str:
+        if self.get_model_source() == ModelSource.PRETRAINED:
+            selected_row = self.pretrained_models_table.get_selected_row()
+            model_meta = selected_row.get("meta", {})
+            model_name = model_meta.get("model_name", None)
+        else:
+            selected_row = self.experiment_selector.get_selected_experiment_info()
+            model_name = selected_row.get("model_name", None)
+        return model_name
+
+    def get_model_info(self) -> dict:
+        if self.get_model_source() == ModelSource.PRETRAINED:
+            return self.pretrained_models_table.get_selected_row()
+        else:
+            return self.experiment_selector.get_selected_experiment_info()
+
+    def validate_step(self) -> bool:
+        self.validator_text.hide()
+        model_info = self.get_model_info()
+        if model_info is None or model_info == {}:
+            self.validator_text.set(text="Model is not selected", status="error")
+            self.validator_text.show()
+            return False
+        else:
+            self.validator_text.set(text="Model is selected", status="success")
+            self.validator_text.show()
+            return True

supervisely/nn/training/gui/train_val_splits_selector.py

@@ -0,0 +1,200 @@
+from typing import List
+
+from supervisely import Api, Project
+from supervisely.app.widgets import Button, Card, Container, Text, TrainValSplits
+
+
+class TrainValSplitsSelector:
+    title = "Train / Val Splits"
+    description = "Select train and val splits for training"
+    lock_message = "Select input options to unlock"
+
+    def __init__(self, api: Api, project_id: int, app_options: dict = {}):
+        self.api = api
+        self.project_id = project_id
+        self.train_val_splits = TrainValSplits(project_id)
+
+        train_val_dataset_ids = {"train": [], "val": []}
+        for _, dataset in api.dataset.tree(project_id):
+            if dataset.name.lower() == "train" or dataset.name.lower() == "training":
+                if dataset.items_count > 0:
+                    train_val_dataset_ids["train"].append(dataset.id)
+            elif dataset.name.lower() == "val" or dataset.name.lower() == "validation":
+                if dataset.items_count > 0:
+                    train_val_dataset_ids["val"].append(dataset.id)
+
+        # Check nested dataset names
+        train_count = len(train_val_dataset_ids["train"])
+        val_count = len(train_val_dataset_ids["val"])
+        if train_count > 0 and val_count > 0:
+            self.train_val_splits.set_datasets_splits(
+                train_val_dataset_ids["train"], train_val_dataset_ids["val"]
+            )
+
+        if train_count > 0 and val_count > 0:
+            self.validator_text = Text("Train and val datasets are detected", status="info")
+            self.validator_text.show()
+        else:
+            self.validator_text = Text("")
+            self.validator_text.hide()
+
+        self.button = Button("Select")
+        container = Container(
+            [
+                self.train_val_splits,
+                self.validator_text,
+                self.button,
+            ]
+        )
+        self.card = Card(
+            title=self.title,
+            description=self.description,
+            content=container,
+            lock_message=self.lock_message,
+            collapsable=app_options.get("collapsable", False),
+        )
+        self.card.lock()
+
+    @property
+    def widgets_to_disable(self) -> list:
+        return [self.train_val_splits]
+
+    def validate_step(self) -> bool:
+        split_method = self.train_val_splits.get_split_method()
+        warning_text = "Using the same data for training and validation leads to overfitting, poor generalization and biased model selection."
+        ensure_text = "Ensure this is intentional."
+
+        if split_method == "Random":
+            train_ratio = self.train_val_splits.get_train_split_percent()
+            val_ratio = self.train_val_splits.get_val_split_percent()
+
+            # Define common warning text
+            ensure_text_random_split = (
+                "Consider reallocating to ensure efficient learning and validation."
+            )
+
+            # Validate splits
+            if train_ratio == val_ratio:
+                self.validator_text.set(
+                    text="Train and validation splits are equal (50:50). This is inefficient for standard training. "
+                    f"{ensure_text}",
+                    status="warning",
+                )
+            elif train_ratio > 90:
+                self.validator_text.set(
+                    text="Training split exceeds 90%. This may leave insufficient data for validation. Ensure you have enough data for validation.",
+                    status="warning",
+                )
+            elif val_ratio > train_ratio:
+                self.validator_text.set(
+                    text=f"Validation split is larger than the training split. {ensure_text_random_split}",
+                    status="warning",
+                )
+            elif train_ratio < 70:
+                self.validator_text.set(
+                    text="Training split is below 70%. This may limit the model's learning capability. "
+                    f"{ensure_text_random_split}",
+                    status="warning",
+                )
+            else:
+                self.validator_text.set(
+                    text="Train and validation splits are selected.",
+                    status="success",
+                )
+
+        elif split_method == "Based on tags":
+            train_tag = self.train_val_splits.get_train_tag()
+            val_tag = self.train_val_splits.get_val_tag()
+
+            # Check if tags are present on any item in the project
+            stats = self.api.project.get_stats(self.project_id)
+            tags_count = {}
+            for item in stats["imageTags"]["items"]:
+                tag_name = item["tagMeta"]["name"]
+                tag_total = item["total"]
+                tags_count[tag_name] = tag_total
+
+            for object_tags in stats["objectTags"]["items"]:
+                tag_name = object_tags["tagMeta"]["name"]
+                tag_total = object_tags["total"]
+                if tag_name in tags_count:
+                    tags_count[tag_name] += tag_total
+                else:
+                    tags_count[tag_name] = tag_total
+
+            # @TODO: handle button correctly if validation fails. Do not unlock next card until validation passes if returned False
+            if tags_count[train_tag] == 0:
+                self.validator_text.set(
+                    text=f"Train tag '{train_tag}' is not present in any images. {ensure_text}",
+                    status="error",
+                )
+            elif tags_count[val_tag] == 0:
+                self.validator_text.set(
+                    text=f"Val tag '{val_tag}' is not present in any images. {ensure_text}",
+                    status="error",
+                )
+
+            elif train_tag == val_tag:
+                self.validator_text.set(
+                    text=f"Train and val tags are the same. {ensure_text} {warning_text}",
+                    status="warning",
+                )
+            else:
+                self.validator_text.set("Train and val tags are selected", status="success")
+
+        elif split_method == "Based on datasets":
+            train_dataset_id = self.get_train_dataset_ids()
+            val_dataset_id = self.get_val_dataset_ids()
+
+            # Check if datasets are not empty
+            stats = self.api.project.get_stats(self.project_id)
+            datasets_count = {}
+            for dataset in stats["images"]["datasets"]:
+                datasets_count[dataset["id"]] = {
+                    "name": dataset["name"],
+                    "total": dataset["imagesInDataset"],
+                }
+
+            empty_dataset_names = []
+            for dataset_id in train_dataset_id + val_dataset_id:
+                if datasets_count[dataset_id]["total"] == 0:
+                    empty_dataset_names.append(datasets_count[dataset_id]["name"])
+
+            if len(empty_dataset_names) > 0:
+                if len(empty_dataset_names) == 1:
+                    empty_ds_text = f"Selected dataset: {', '.join(empty_dataset_names)} is empty. {ensure_text}"
+                else:
+                    empty_ds_text = f"Selected datasets: {', '.join(empty_dataset_names)} are empty. {ensure_text}"
+
+                self.validator_text.set(
+                    text=empty_ds_text,
+                    status="error",
+                )
+
+            elif train_dataset_id == val_dataset_id:
+                self.validator_text.set(
+                    text=f"Same datasets are selected for both train and val splits. {ensure_text} {warning_text}",
+                    status="warning",
+                )
+            else:
+                self.validator_text.set("Train and val datasets are selected", status="success")
+        self.validator_text.show()
+        return True
+
+    def set_sly_project(self, project: Project) -> None:
+        self.train_val_splits._project_fs = project
+
+    def get_split_method(self) -> str:
+        return self.train_val_splits.get_split_method()
+
+    def get_train_dataset_ids(self) -> List[int]:
+        return self.train_val_splits._train_ds_select.get_selected_ids()
+
+    def set_train_dataset_ids(self, dataset_ids: List[int]) -> None:
+        self.train_val_splits._train_ds_select.set_selected_ids(dataset_ids)
+
+    def get_val_dataset_ids(self) -> List[int]:
+        return self.train_val_splits._val_ds_select.get_selected_ids()
+
+    def set_val_dataset_ids(self, dataset_ids: List[int]) -> None:
+        self.train_val_splits._val_ds_select.set_selected_ids(dataset_ids)

supervisely/nn/training/gui/training_logs.py

@@ -0,0 +1,93 @@
+from typing import Any, Dict
+
+from supervisely import Api
+from supervisely._utils import is_production
+from supervisely.app.widgets import Button, Card, Container, Progress, TaskLogs, Text
+from supervisely.io.env import task_id as get_task_id
+
+
+class TrainingLogs:
+    title = "Training Logs"
+    description = "Track training progress"
+    lock_message = "Start training to unlock"
+
+    def __init__(self, app_options: Dict[str, Any]):
+        api = Api.from_env()
+        self.app_options = app_options
+
+        self.progress_bar_main = Progress(hide_on_finish=False)
+        self.progress_bar_main.hide()
+
+        self.progress_bar_secondary = Progress(hide_on_finish=False)
+        self.progress_bar_secondary.hide()
+
+        if is_production():
+            task_id = get_task_id(raise_not_found=False)
+        else:
+            task_id = None
+
+        # Tensorboard button
+        if is_production():
+            task_info = api.task.get_info_by_id(task_id)
+            session_token = task_info["meta"]["sessionToken"]
+            sly_url_prefix = f"/net/{session_token}"
+            self.tensorboard_link = f"{api.server_address}{sly_url_prefix}/tensorboard/"
+        else:
+            self.tensorboard_link = "http://localhost:8000/tensorboard"
+        self.tensorboard_button = Button(
+            "Open Tensorboard",
+            button_type="info",
+            plain=True,
+            icon="zmdi zmdi-chart",
+            link=self.tensorboard_link,
+        )
+        self.tensorboard_button.disable()
+
+        self.validator_text = Text("")
+        self.validator_text.hide()
+
+        container_widgets = [
+            self.validator_text,
+            self.tensorboard_button,
+            self.progress_bar_main,
+            self.progress_bar_secondary,
+        ]
+
+        if app_options.get("show_logs_in_gui", False):
+            self.logs_button = Button(
+                text="Show logs",
+                plain=True,
+                button_size="mini",
+                icon="zmdi zmdi-caret-down-circle",
+            )
+            self.task_logs = TaskLogs(task_id)
+            self.task_logs.hide()
+            logs_container = Container([self.logs_button, self.task_logs])
+            container_widgets.insert(2, logs_container)
+
+        container = Container(container_widgets)
+
+        self.card = Card(
+            title=self.title,
+            description=self.description,
+            content=container,
+            lock_message=self.lock_message,
+        )
+        self.card.lock()
+
+    @property
+    def widgets_to_disable(self) -> list:
+        return []
+
+    def validate_step(self) -> bool:
+        return True
+
+    def toggle_logs(self):
+        if self.task_logs.is_hidden():
+            self.task_logs.show()
+            self.logs_button.text = "Hide logs"
+            self.logs_button.icon = "zmdi zmdi-caret-up-circle"
+        else:
+            self.task_logs.hide()
+            self.logs_button.text = "Show logs"
+            self.logs_button.icon = "zmdi zmdi-caret-down-circle"

supervisely/nn/training/gui/training_process.py

@@ -0,0 +1,114 @@
+from typing import Any, Dict
+
+from supervisely import Api
+from supervisely.app.widgets import (
+    Button,
+    Card,
+    Container,
+    DoneLabel,
+    Empty,
+    Field,
+    FolderThumbnail,
+    Input,
+    ReportThumbnail,
+    SelectCudaDevice,
+    Text,
+)
+
+
+class TrainingProcess:
+    title = "Training Process"
+    description = "Manage training process"
+    lock_message = "Select hyperparametrs to unlock"
+
+    def __init__(self, app_options: Dict[str, Any]):
+        self.app_options = app_options
+        self.experiment_name_input = Input("Enter experiment name")
+        self.experiment_name_field = Field(
+            title="Experiment name",
+            description="Experiment name will be saved to experiment_info.json",
+            content=self.experiment_name_input,
+        )
+
+        self.success_message_text = (
+            "Training completed. Training artifacts were uploaded to Team Files. "
+            "You can find and open tensorboard logs in the artifacts folder via the "
+            "<a href='https://ecosystem.supervisely.com/apps/tensorboard-logs-viewer' target='_blank'>Tensorboard</a> app."
+        )
+        self.success_message = DoneLabel(text=self.success_message_text)
+        self.success_message.hide()
+
+        self.artifacts_thumbnail = FolderThumbnail()
+        self.artifacts_thumbnail.hide()
+
+        self.model_benchmark_report_thumbnail = ReportThumbnail()
+        self.model_benchmark_report_thumbnail.hide()
+
+        self.model_benchmark_report_text = Text(status="info", text="Creating report on model...")
+        self.model_benchmark_report_text.hide()
+
+        self.validator_text = Text("")
+        self.validator_text.hide()
+        self.start_button = Button("Start")
+        self.stop_button = Button("Stop", button_type="danger")
+        self.stop_button.hide()  # @TODO: implement stop and hide stop button until training starts
+
+        button_container = Container(
+            [self.start_button, self.stop_button, Empty()],
+            "horizontal",
+            overflow="wrap",
+            fractions=[1, 1, 10],
+            gap=1,
+        )
+
+        container_widgets = [
+            self.experiment_name_field,
+            button_container,
+            self.validator_text,
+            self.artifacts_thumbnail,
+            self.model_benchmark_report_thumbnail,
+            self.model_benchmark_report_text,
+        ]
+
+        if self.app_options.get("device_selector", False):
+            self.select_device = SelectCudaDevice()
+            self.select_cuda_device_field = Field(
+                title="Select CUDA device",
+                description="The device on which the model will be trained",
+                content=self.select_device,
+            )
+            container_widgets.insert(1, self.select_cuda_device_field)
+
+        container = Container(container_widgets)
+
+        self.card = Card(
+            title=self.title,
+            description=self.description,
+            content=container,
+            lock_message=self.lock_message,
+        )
+        self.card.lock()
+
+    @property
+    def widgets_to_disable(self) -> list:
+        widgets = [self.experiment_name_input]
+        if self.app_options.get("device_selector", False):
+            widgets.append(self.experiment_name_input)
+        return widgets
+
+        return []
+
+    def validate_step(self) -> bool:
+        return True
+
+    def get_device(self) -> str:
+        if self.app_options.get("device_selector", False):
+            return self.select_device.get_device()
+        else:
+            return "cuda:0"
+
+    def get_experiment_name(self) -> str:
+        return self.experiment_name_input.get_value()
+
+    def set_experiment_name(self, experiment_name) -> None:
+        self.experiment_name_input.set_value(experiment_name)