supervisely 6.73.390__py3-none-any.whl → 6.73.391__py3-none-any.whl

supervisely/template/base_generator.py

@@ -0,0 +1,90 @@
+import inspect
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple
+
+import supervisely.io.env as sly_env
+import supervisely.io.fs as sly_fs
+import supervisely.io.json as sly_json
+from supervisely import logger
+from supervisely.api.api import Api
+from supervisely.template.template_renderer import TemplateRenderer
+
+
+class BaseGenerator:
+    """
+    Base class for generating reports from Jinja2 templates and uploading them to Supervisely.
+    """
+
+    TEMPLATE = "template.html.jinja"
+    VUE_TEMPLATE_NAME = "template.vue"
+    LINK_FILE = "Open Report.lnk"
+
+    def __init__(self, api: Api, output_dir: str):
+        self.api = api
+        self.output_dir = output_dir
+        self.template_renderer = TemplateRenderer()
+        os.makedirs(self.output_dir, exist_ok=True)
+    
+    @property
+    def template_path(self) -> str:
+        cls_dir = Path(inspect.getfile(self.__class__)).parent
+        return f"{cls_dir}/{self.TEMPLATE}"
+
+    def context(self) -> dict:
+        raise NotImplementedError("Subclasses must implement the context method.")
+    
+    def state(self) -> dict:
+        return {}
+        
+    def generate(self):
+        # Render
+        content = self._render()
+        # Save template.vue
+        template_path = f"{self.output_dir}/{self.VUE_TEMPLATE_NAME}"
+        with open(template_path, "w", encoding="utf-8") as f:
+            f.write(content)
+        # Save state.json
+        state = self.state()
+        state_path = f"{self.output_dir}/state.json"
+        sly_json.dump_json_file(state, state_path)
+    
+    def upload(self, remote_dir: str, team_id: Optional[int] = None, **kwargs):
+        team_id = team_id or sly_env.team_id()
+        self.api.file.upload_directory_fast(
+            team_id=team_id,
+            local_dir=self.output_dir,
+            remote_dir=remote_dir,
+            **kwargs
+        )
+        logger.info(f"Template uploaded to {remote_dir}")
+        template_id = self.api.file.get_info_by_path(
+            team_id=team_id,
+            remote_path=f"{remote_dir}/{self.VUE_TEMPLATE_NAME}",
+        ).id
+        if self._report_url(self.api.server_address, template_id) is not None:
+            url = self._upload_link_file(template_id, remote_dir, team_id)
+            logger.info(f"Open URL: {url}")
+        else:
+            logger.warning("Subclasses must implement the `_report_url` method to upload a link file.")
+        return template_id
+    
+    def _render(self) -> str:
+        context = self.context()
+        content = self.template_renderer.render(self.template_path, context)
+        return content
+
+    def _upload_link_file(self, template_id: int, remote_dir: str, team_id: int):
+        url = self._report_url(self.api.server_address, template_id)
+        link_path = os.path.join(self.output_dir, self.LINK_FILE)
+        with open(link_path, "w") as f:
+            f.write(url)
+        self.api.file.upload(team_id=team_id, src=link_path, dst=self._link_file_dst_path(remote_dir))
+        return url
+        
+    def _link_file_dst_path(self, remote_dir: str) -> str:
+        return f"{remote_dir}/{self.LINK_FILE}"
+
+    def _report_url(self, server_address: str, template_id: int) -> str:
+        raise NotImplementedError("Subclasses must implement the `_report_url` method to upload a link file.")

supervisely/template/experiment/experiment.html.jinja

@@ -0,0 +1,537 @@
+{% if experiment.training.evaluation.id and widgets.sample_pred_gallery %}
+
+## Predictions
+
+Here are prediction samples made with **{{ experiment.training.checkpoints.pytorch.name }}** checkpoint.
+
+<div class="prediction-gallery">
+    {{ widgets.sample_pred_gallery | safe }}
+</div>
+
+{% endif %}
+
+{% if experiment.training.evaluation.id %}
+
+## Evaluation
+
+The **{{ experiment.training.checkpoints.pytorch.name }}** checkpoint was evaluated on the validation set containing **{{ experiment.project.splits.val }}
+images**.
+
+See the full [📊 Evaluation Report]({{ experiment.training.evaluation.url }}) for details and visualizations.
+{{ widgets.tables.metrics | safe }}
+
+{% else %}
+
+## Evaluation
+No evaluation metrics available for this experiment. The model training was completed successfully, but no evaluation
+was performed.
+
+{% endif %}
+
+## Artifacts
+
+[📂 Open in Team Files]({{ experiment.paths.artifacts_dir.url }}){:target="_blank"}
+
+The artifacts of this experiment are stored in the **Team Files**. You can download them and use in your code.
+Here are the essential checkpoints and exports of the model:
+
+- 🔥 Best checkpoint: **{{ experiment.training.checkpoints.pytorch.name }}** ([download]({{ experiment.training.checkpoints.pytorch.url
+}}){:download="{{ experiment.training.checkpoints.pytorch.name }}"})
+{% if experiment.training.checkpoints.onnx.name %}
+- 📦 ONNX export: **{{ experiment.training.checkpoints.onnx.name }}** ([download]({{ experiment.training.checkpoints.onnx.url
+}}){:download="{{ experiment.training.checkpoints.onnx.name }}"})
+{% endif %}
+{% if experiment.training.checkpoints.tensorrt.name %}
+- ⚡ TensorRT export: **{{ experiment.training.checkpoints.tensorrt.name }}** ([download]({{ experiment.training.checkpoints.tensorrt.url
+}}){:download="{{ experiment.training.checkpoints.tensorrt.name }}"})
+{% endif %}
+
+{% if widgets.tables.checkpoints %}
+<details>
+    <summary>📋 All Checkpoints</summary>
+    {{ widgets.tables.checkpoints }}
+</details>
+{% endif %}
+
+## Classes
+
+The model can predict {{ experiment.project.classes.count }} classes. Here is the full list of classes:
+
+<details>
+    <summary>Classes</summary>
+    {{ widgets.tables.classes }}
+
+</details>
+
+{% if experiment.training.hyperparameters %}
+
+## Hyperparameters
+
+The training process was configured with the following hyperparameters. You can use them to reproduce the training.
+
+<details>
+    <summary>Hyperparameters</summary>
+
+    ```yaml
+    {% for hyperparameter in experiment.training.hyperparameters %}
+    {{ hyperparameter }}
+    {% endfor %}
+    ```
+
+</details>
+{% endif %}
+
+## Supervisely Apps
+
+The quick actions on this page, such as **Deploy**, **Predict**, or **Fine-tune**, help you to quickly work with your model. But you can also run the apps manually from the Supervisely Platform. Here are related apps to this experiment:
+
+- [Serve {{ experiment.model.framework }}]({{ env.server_address }}/ecosystem/apps/{{ resources.apps.serve.slug
+}}){:target="_blank"} - deploy your model in the Supervisely Platform.
+- [Train {{ experiment.model.framework }}]({{ env.server_address }}/ecosystem/apps/{{ resources.apps.train.slug
+}}){:target="_blank"} - train a model in the Supervisely Platform.
+- [Apply NN to Images]({{ env.server_address }}/ecosystem/apps/{{ resources.apps.apply_nn_to_images.slug }}){:target="_blank"} -
+connect to your model and make predictions on image project or dataset.
+- [Apply NN to Videos]({{ env.server_address }}/ecosystem/apps/{{ resources.apps.apply_nn_to_videos.slug }}){:target="_blank"} -
+for predictions on video project or dataset.
+
+## API Integration & Deployment
+
+In this section, you'll find the quickstart guides for integrating your model into your applications using the Supervisely API, you'll learn how to deploy your model outside of the Supervisely Platform, and how to deploy it in a Docker container.
+
+### Table of contents:
+
+- [Supervisely API](#supervisely-api)
+- [Deploy in Docker](#deploy-in-docker)
+- [Deploy locally with Supervisely SDK](#deploy-locally-with-supervisely-sdk)
+- [Using Original Model Codebase](#using-original-model-codebase)
+
+## Supervisely API
+
+Here is a **quickstart** guide of how to use the Supervisely API.
+
+1. Install Supervisely:
+
+    ```bash
+    pip install supervisely
+    ```
+
+2. Authentication. Provide your **API token** and the **Server address** into environment variables. For example, you
+can pass them in the terminal before running the script:
+
+    ```bash
+    export API_TOKEN="your_api_token"
+    export SERVER_ADDRESS="https://app.supervisely.com" # or your own server URL for Enterprise Edition
+    ```
+
+    If you need help with authentication, check the [Basics of Authentication](https://developer.supervisely.com/getting-started/basics-of-authentication){:target="_blank"} tutorial.
+
+3. The following code will deploy a model and make predictions using the Supervisely API.
+
+    ```python
+    import supervisely as sly
+
+    # 1. Authenticate with Supervisely API
+    api = sly.Api() # Make sure you've set your credentials in environment variables.
+
+    # 2. Deploy the model
+    model = api.nn.deploy(
+        model="{{ experiment.paths.artifacts_dir.path }}/checkpoints/{{ experiment.training.checkpoints.pytorch.name }}",
+        device="cuda:0", # or "cpu"
+    )
+
+    # 3. Predict
+    predictions = model.predict(
+        input=["image1.jpg", "image2.jpg"], # can also be numpy arrays, PIL images, URLs or a directory
+    )
+    ```
+
+### Deploy via API
+
+Deploy your model in a few lines of code. The model will be deployed in the Supervisely Platform, after this, you can
+use it for predictions.
+
+{% tabs %}
+
+{% tab title="PyTorch" %}
+
+```python
+import supervisely as sly
+
+api = sly.Api()
+
+# Deploy PyTorch checkpoint
+model = api.nn.deploy(
+    model="{{ experiment.paths.artifacts_dir.path }}/checkpoints/{{ experiment.training.checkpoints.pytorch.name }}",
+    device="cuda:0", # or "cpu"
+)
+```
+
+{% endtab %}
+
+{% if experiment.training.checkpoints.onnx.name %}
+{% tab title="ONNX" %}
+
+```python
+import supervisely as sly
+
+api = sly.Api()
+
+# Deploy ONNX checkpoint
+model = api.nn.deploy(
+    model="{{ experiment.paths.artifacts_dir.path }}/export/{{ experiment.training.checkpoints.onnx.name }}",
+    device="cuda:0", # or "cpu"
+)
+```
+
+{% endtab %}
+{% endif %}
+
+{% if experiment.training.checkpoints.tensorrt.name %}
+{% tab title="TensorRT" %}
+
+```python
+import supervisely as sly
+
+api = sly.Api()
+
+# Deploy TensorRT checkpoint
+model = api.nn.deploy(
+    model="{{ experiment.paths.artifacts_dir.path }}/export/{{ experiment.training.checkpoints.tensorrt.name }}",
+    device="cuda:0", # or "cpu"
+)
+```
+
+{% endtab %}
+{% endif %}
+
+{% endtabs %}
+
+> For more information, see [Model
+API](https://docs.supervisely.com/neural-networks/overview-1/model-api){:target="_blank"}
+documentation.
+
+### Predict via API
+
+Use the deployed model to make predictions on images, videos, or directories. Connect to a deployed
+model and make predictions.
+
+{% tabs %}
+
+{% tab title="Local Images" %}
+
+```python
+# Predict local images
+predictions = model.predict(
+    input="image.jpg", # Can also be a directory, np.array, PIL.Image, URL or a list of them
+)
+```
+
+{% endtab %}
+
+{% tab title="Image IDs" %}
+
+```python
+# Predict images in Supervisely
+predictions = model.predict(image_ids=[123, 124] # Image IDs in Supervisely)
+```
+
+{% endtab %}
+
+{% tab title="Dataset" %}
+
+```python
+# Predict dataset
+predictions = model.predict(dataset_id=12 # Dataset ID in Supervisely)
+```
+
+{% endtab %}
+
+{% tab title="Project" %}
+
+```python
+# Predict project
+predictions = model.predict(project_id=21 # Project ID in Supervisely)
+```
+
+{% endtab %}
+
+{% tab title="Video" %}
+
+```python
+# Predict video
+predictions = model.predict(video_id=123 # Video ID in Supervisely)
+```
+
+{% endtab %}
+
+{% endtabs %}
+
+> For more information, see [Prediction
+API](https://docs.supervisely.com/neural-networks/overview-1/prediction-api){:target="_blank"}.
+
+{% if experiment.model.task_type == "object detection" %}
+
+## Tracking Objects in Video
+
+You can track objects in video using `boxmot` library.
+[BoxMot](https://github.com/mikel-brostrom/boxmot){:target="_blank"} is a
+third-party library that implements lightweight neural networks for tracking-by-detection task (when the tracking is
+performed on the objects predicted by a separate detector). For `boxmot` models you can use even CPU device.
+
+First, install [BoxMot](https://github.com/mikel-brostrom/boxmot){:target="_blank"}:
+
+```bash
+pip install boxmot
+```
+
+Supervisely SDK has the `track()` method from `supervisely.nn.tracking` which allows you to apply `boxmot` models
+together with a detector in a single line of code. This method takes two arguments: a `boxmot` tracker, and a
+`PredictionSession` of a detector. It returns a `sly.VideoAnnotation` with the tracked objects.
+
+```python
+import supervisely as sly
+from supervisely.nn.tracking import track
+import boxmot
+from pathlib import Path
+
+# Deploy a detector
+detector = api.nn.deploy(
+    model="{{ experiment.model.framework }}/{{ experiment.model.name }}",
+    device="cuda:0", # Use GPU for detection
+)
+
+# Load BoxMot tracker
+tracker = boxmot.BotSort(
+    reid_weights=Path('osnet_x0_25_msmt17.pt'),
+    device="cpu", # Use CPU for tracking
+)
+
+# Track objects in a single line
+video_ann: sly.VideoAnnotation = track(
+    video_id=42,
+    detector=detector,
+    tracker=tracker,
+)
+```
+
+> For more information, see the section [Tracking Objects in
+Video](https://docs.supervisely.com/neural-networks/overview-1/prediction-api#tracking-objects-in-video){:target="_blank"}.
+
+{% endif %}
+
+## Deploy in Docker
+
+You can deploy the model in a 🐋 Docker Container with a single `docker run` command. Download a checkpoint, pull the
+docker image for the corresponding model's framework, and run the `docker run` command with addtional arguments.
+
+1. Download checkpoint from Supervisely ([Open in Team Files]({{ experiment.paths.checkpoints_dir.url }}){:target="_blank"})
+
+2. Pull the Docker image
+
+    ```bash
+    docker pull {{ code.docker.image }}
+    ```
+
+3. Run the Docker container
+
+    ```bash
+    docker run \
+        --runtime=nvidia \
+        -v "./{{ experiment.paths.experiment_dir.path }}:/model" \  # Mount the experiment directory to the container
+        -p 8000:8000 \
+        {{ code.docker.image }} \
+        deploy \
+        --model "/model/checkpoints/{{ experiment.training.checkpoints.pytorch.name }}" \
+        --device "cuda:0"
+    ```
+
+4. Connect and run the inference:
+
+    ```python
+    from supervisely.nn import ModelAPI
+
+    # No need to authenticate for local deployment
+    model = ModelAPI(
+        url="http://localhost:8000" # URL of a running model's server in Docker container
+    )
+
+    # Predict
+    predictions = model.predict(
+        input=["image1.jpg", "image2.jpg"] # Can also be numpy arrays, PIL images, URLs or a directory
+    )
+    ```
+
+See the [Model API](https://docs.supervisely.com/neural-networks/overview-1/model-api){:target="_blank"} documentation for more details on how to use the `ModelAPI` class.
+
+Alternatively, you can use `docker run` with the `predict` action to make predictions in a single command. This is a
+quick way to start inference on your local images, videos, or directories without deploying the model. The container will be automatically stopped after the predictions are made.
+
+```bash
+docker run \
+    --runtime=nvidia \
+    -v "./{{ experiment.paths.experiment_dir.path }}:/model" \
+    -p 8000:8000 \
+    {{ code.docker.image }} \
+    predict \
+    "./image.jpg" \ # Put your image/video/directory here
+    --model "/model/checkpoints/{{ experiment.training.checkpoints.pytorch.name }}" \
+    --device "cuda:0"
+```
+
+> For more information, see [Deploy in Docker
+Container](https://docs.supervisely.com/neural-networks/overview-1/deploy_and_predict_with_supervisely_sdk#deploy-in-docker-container){:target="_blank"}
+documentation.
+
+## Deploy locally with Supervisely SDK
+
+If you develop your application outside of Supervisely, you can deploy your model on your machine with the help of the Supervisely SDK and our prepared codebase for a specific model (we usually make a fork of the original model repository).
+This approach helps you to quickly set up the environment and run inference without the need to implement code for loading the model and making predictions by yourself, because all our model integrations are developed with the Supervisely SDK, and the inference could be done in a few lines of code, in a unified way.
+
+1. Download checkpoint from Supervisely ([Open in Team Files]({{ experiment.paths.checkpoints_dir.url }}){:target="_blank"})
+
+2. Clone our repository
+
+    ```bash
+    git clone {{ code.local_prediction.repo.url }}
+    cd {{ code.local_prediction.repo.name }}
+    ```
+
+3. Install requirements
+
+    ```bash
+    pip install -r dev_requirements.txt
+    pip install supervisely
+    ```
+
+4. Run the inference code
+
+    ```python
+    # Be sure you are in the root of the {{ code.local_prediction.repo.name }} repository
+    from {{ code.local_prediction.serving_module }} import {{ code.local_prediction.serving_class }}
+
+    # Load model
+    model = {{ code.local_prediction.serving_class }}(
+        model="{{ experiment.paths.artifacts_dir.path }}/checkpoints/{{ experiment.training.checkpoints.pytorch.name }}", # path to the checkpoint you've downloaded
+        device="cuda", # or "cuda:1", "cpu"
+    )
+
+    # Predict
+    predictions = model.predict(
+        # 'input' can accept various formats: image paths, np.arrays, Supervisely IDs and others.
+        input=["path/to/image1.jpg", "path/to/image2.jpg"],
+        conf=0.5, # confidence threshold
+        # ... additional parameters (see the docs)
+    )
+    ```
+
+> For more information, see [Local Deployment](https://docs.supervisely.com/neural-networks/overview-1/local-deployment.md){:target="_blank"} and [Prediction API](https://docs.supervisely.com/neural-networks/overview-1/prediction-api){:target="_blank"} documentations.
+
+{% if experiment.training.checkpoints.onnx.name or experiment.training.checkpoints.tensorrt.name %}
+### Deploy ONNX/TensorRT
+
+You can also use exported ONNX and TensorRT models. Specify the `model` parameter as a path to your ONNX or TensorRT
+model,
+{% if experiment.training.checkpoints.onnx.classes_url or experiment.training.checkpoints.tensorrt.classes_url %}
+and [download `classes.json`]({{ experiment.training.checkpoints.onnx.classes_url or experiment.training.checkpoints.tensorrt.classes_url
+}}){:download="classes.json"} file from the export directory.
+{% else %}
+and provide class names in the additional `classes` parameter.
+{% endif %}
+
+```python
+# Be sure you are in the root of the {{ code.local_prediction.repo.name }} repository
+from {{ code.local_prediction.serving_module }} import {{ code.local_prediction.serving_class }}
+{% if experiment.training.checkpoints.onnx.classes_url or experiment.training.checkpoints.tensorrt.classes_url %}
+from supervisely.io.json import load_json_file
+
+classes_path = "./{{ experiment.paths.experiment_dir.path }}/export/classes.json"
+classes = load_json_file(classes_path)
+{% else %}
+
+classes = {{ project.classes.names.short_list }}
+{% endif %}
+
+# Deploy ONNX or TensorRT
+model = {{ code.local_prediction.serving_class }}(
+    # Path to the ONNX or TensorRT model
+    model="{{ experiment.paths.artifacts_dir.path }}/export/{{ experiment.training.checkpoints.onnx.name or experiment.training.checkpoints.tensorrt.name }}",
+    device="cuda",
+)
+
+# Predict
+predictions = model.predict(
+    # 'input' can accept various formats: image paths, np.arrays, Supervisely IDs and others.
+    input=["path/to/image1.jpg", "path/to/image2.jpg"],
+    conf=0.5, # confidence threshold
+    classes=classes,
+    # ... additional parameters (see the docs)
+)
+```
+
+{% endif %}
+
+{% if code.demo.pytorch.path %}
+
+## Using Original Model Codebase
+
+In this approach you'll completely decouple your model from both the **Supervisely Platform** and **Supervisely SDK**,
+and you will develop your own code for inference and deployment of that particular model. It's important to understand
+that for each neural network or a framework, you need to set up an environment and write inference code by yourself,
+since each model has its own installation instructions and the way of processing inputs and outputs correctly.
+
+We provide a basic instructions and a demo script of how to load {{ experiment.model.framework }} and get predictions
+using the original code from the authors.
+
+1. Download checkpoint from Supervisely ([Open in Team Files]({{ experiment.paths.checkpoints_dir.url }}){:target="_blank"})
+
+2. Prepare environment following the instructions of the original repository [{{ code.local_prediction.repo.name }}]({{
+code.local_prediction.repo.url }}){:target="_blank"}
+
+3. Use the demo script for inference:
+
+<details>
+<summary><strong>🐍 View Code</strong></summary>
+
+<sly-iw-tabs :tabs="[
+    { name: 'pytorch-demo', title: '🔥 PyTorch' },
+    {% if code.demo.onnx.path %}
+    { name: 'onnx-demo', title: '📦 ONNX' },
+    {% endif %}
+    {% if code.demo.tensorrt.path %}
+    { name: 'tensorrt-demo', title: '⚡ TensorRT' }
+    {% endif %}
+]" :defaultIndex="0">
+
+<template #pytorch-demo>
+
+```python
+{{ code.demo.pytorch.script | safe }}
+```
+
+</template>
+
+{% if code.demo.onnx.path %}
+<template #onnx-demo>
+
+```python
+{{ code.demo.onnx.script | safe }}
+```
+
+</template>
+{% endif %}
+
+{% if code.demo.tensorrt.path %}
+<template #tensorrt-demo>
+
+```python
+{{ code.demo.tensorrt.script | safe }}
+```
+
+</template>
+{% endif %}
+
+</sly-iw-tabs>
+
+</details>
+
+{% endif %}