lightly-studio 0.3.1__py3-none-any.whl

lightly_studio/examples/example_selection.py

@@ -0,0 +1,39 @@
+"""Example of how to run selection class."""
+
+from pathlib import Path
+
+from environs import Env
+
+from lightly_studio import DatasetLoader
+from lightly_studio.selection.select import Selection
+
+# Read environment variables
+env = Env()
+env.read_env()
+
+# Define the path to the dataset directory
+dataset_path = Path(env.path("DATASET_PATH", "/path/to/your/dataset"))
+dataset_path = dataset_path.parent if dataset_path.is_file() else dataset_path
+
+# Create a DatasetLoader from a path
+loader = DatasetLoader()
+dataset = loader.from_directory(
+    dataset_name="clothing_small_test",
+    img_dir=str(dataset_path),
+)
+
+# Create the selection interface
+# TODO(Malte, 08/2025): Replace this with using a DatasetView.
+# See the Select class for more details on the TODO.
+select = Selection(
+    dataset_id=dataset.dataset_id,
+    session=loader.session,
+)
+
+# Select a diverse subset of 10 samples.
+select.diverse(
+    n_samples_to_select=10,
+    selection_result_tag_name="diverse_selection",
+)
+
+loader.start_gui()

lightly_studio/examples/example_split_work.py

@@ -0,0 +1,67 @@
+"""Example of how to add tags to samples to set up a split review workflow."""
+
+import math
+
+from environs import Env
+
+from lightly_studio import DatasetLoader
+from lightly_studio.models.tag import TagCreate
+from lightly_studio.resolvers import (
+    tag_resolver,
+)
+
+# Read environment variables
+env = Env()
+env.read_env()
+
+# Create a DatasetLoader instance
+loader = DatasetLoader()
+
+# Define the path to the dataset (folder containing data.yaml)
+dataset_path = env.path("DATASET_PATH", "/path/to/your/yolo/dataset/data.yaml")
+
+# Load YOLO dataset using data.yaml path
+dataset = loader.from_yolo(
+    str(dataset_path),
+    input_split=env.str("LIGHTLY_STUDIO_DATASET_SPLIT", "test"),
+)
+
+# Define the reviewers
+# This should be a comma-separated list of reviewers
+# we will then create a tag for each reviewer and assign them samples
+# to work on.
+reviewers = env.str("DATASET_REVIEWERS", "Alice, Bob, Charlie, David")
+
+# Get all samples from the db
+samples = dataset.get_samples()
+
+# Create a tag for each reviewer to work on
+tags = []
+for reviewer in reviewers.split(","):
+    tags.append(
+        tag_resolver.create(
+            session=loader.session,
+            tag=TagCreate(
+                dataset_id=dataset.dataset_id,
+                name=f"""{reviewer.strip()} tasks""",
+                kind="sample",
+            ),
+        )
+    )
+
+# Chunk the samples into portions equally divided among the reviewers.
+chunk_size = math.ceil(len(samples) / len(tags))
+for i, tag in enumerate(tags):
+    # allocate all samples for this tag
+    sample_ids = [sample.sample_id for sample in samples[i * chunk_size : (i + 1) * chunk_size]]
+
+    # Add sample_ids to the tag
+    tag_resolver.add_sample_ids_to_tag_id(
+        session=loader.session,
+        tag_id=tag.tag_id,
+        sample_ids=sample_ids,
+    )
+
+
+# Launch the server to load data
+loader.start_gui()

lightly_studio/examples/example_v2.py

@@ -0,0 +1,21 @@
+"""Example of how to load samples from path with the dataset class."""
+
+from pathlib import Path
+
+from environs import Env
+
+import lightly_studio as ls
+
+# Read environment variables
+env = Env()
+env.read_env()
+
+# Define the path to the dataset directory
+dataset_path = Path(env.path("DATASET_PATH", "/path/to/your/dataset"))
+dataset_path = dataset_path.parent if dataset_path.is_file() else dataset_path
+
+# Create a DatasetLoader from a path
+dataset = ls.Dataset("clothing_small_test")
+dataset.add_samples_from_path(path=dataset_path)
+
+ls.start_gui()

lightly_studio/export_schema.py

@@ -0,0 +1,18 @@
+"""Export OpenAPI schema from FastAPI application to JSON file."""
+
+import argparse
+import json
+
+from lightly_studio.api.app import app
+
+parser = argparse.ArgumentParser(description="Export OpenAPI schema to a file.")
+parser.add_argument(
+    "--output",
+    type=str,
+    default="openapi.json",
+    help="The output file path for the OpenAPI schema (default: openapi.json).",
+)
+args = parser.parse_args()
+
+with open(args.output, "w") as f:
+    json.dump(app.openapi(), f, indent=2)

lightly_studio/few_shot_classifier/classifier.py

@@ -0,0 +1,80 @@
+"""FewShotClassifier Protocol."""
+
+from __future__ import annotations
+
+import io
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal, Protocol, runtime_checkable
+
+ExportType = Literal["sklearn", "lightly"]
+
+
+@dataclass
+class AnnotatedEmbedding:
+    """Annotated embedding class.
+
+    Attributes:
+        embedding: The embedding vector as a list of floats.
+        annotation: The annotation for the embedding.
+                    Note: Currently it is an string but it can be a integer or
+                    any other type.
+    """
+
+    embedding: list[float]
+    annotation: str
+
+
+@runtime_checkable
+class FewShotClassifier(Protocol):
+    """Protocol defining the interface for classifiers."""
+
+    def train(self, annotated_embeddings: list[AnnotatedEmbedding]) -> None:
+        """Trains a classifier using the provided input.
+
+        Args:
+            annotated_embeddings: A list of annotated embeddings to train the
+            classifier.
+
+        Raises:
+            ValueError: If annotated_embeddings is empty or contains invalid
+            classes.
+        """
+        ...
+
+    def predict(self, embeddings: list[list[float]]) -> list[list[float]]:
+        """Predicts the classification scores for a list of embeddings.
+
+        Args:
+            embeddings: A list of embeddings, where each embedding is a list of
+            floats.
+
+        Returns:
+            A list of lists, where each inner list represents the probability
+            distribution over classes for the corresponding input embedding.
+            Each value in the inner list corresponds to the likelihood of the
+            embedding belonging to a specific class.
+            If embeddings is empty, returns an empty list.
+        """
+        ...
+
+    def export(
+        self,
+        export_path: Path | None,
+        buffer: io.BytesIO | None,
+        export_type: ExportType,
+    ) -> None:
+        """Exports the classifier to a specified file.
+
+        This method saves the trained classifier to the given file path so that
+        it can be reused or shared.
+
+        Args:
+            export_path: The path to the file where the classifier should
+            be saved.
+            buffer: An optional in-memory buffer to write the exported
+            classifier to.
+            export_type: The type of export format to use. This can be either
+            "sklearn_instance" or "raw".
+        """
+        ...