learning-loop-node 0.14.0__tar.gz → 0.15.0__tar.gz

{learning_loop_node-0.14.0 → learning_loop_node-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: learning-loop-node
-Version: 0.14.0
+Version: 0.15.0
 Summary: Python Library for Nodes which connect to the Zauberzeug Learning Loop
 Home-page: https://github.com/zauberzeug/learning_loop_node
 License: MIT
@@ -100,6 +100,8 @@ You can additionally provide the following camera parameters:
 - `autoupload`: configures auto-submission to the learning loop; `filtered` (default), `all`, `disabled` (example curl parameter `-H 'autoupload: all'`)
 - `camera-id`: a string which groups images for submission together (example curl parameter `-H 'camera-id: front_cam'`)
 
+To use the socketio interface, the caller needs to connect to the detector node's socketio server and emit the `detect` or `batch_detect` event with the image data and image metadata. Example code can be found [in the rosys implementation](https://github.com/zauberzeug/rosys/blob/main/rosys/vision/detector_hardware.py).
+
 The detector also has a sio **upload endpoint** that can be used to upload images and detections to the learning loop. The function receives a json dictionary, with the following entries:
 
 - `image`: the image data in jpg format

{learning_loop_node-0.14.0 → learning_loop_node-0.15.0}/README.md

@@ -60,6 +60,8 @@ You can additionally provide the following camera parameters:
 - `autoupload`: configures auto-submission to the learning loop; `filtered` (default), `all`, `disabled` (example curl parameter `-H 'autoupload: all'`)
 - `camera-id`: a string which groups images for submission together (example curl parameter `-H 'camera-id: front_cam'`)
 
+To use the socketio interface, the caller needs to connect to the detector node's socketio server and emit the `detect` or `batch_detect` event with the image data and image metadata. Example code can be found [in the rosys implementation](https://github.com/zauberzeug/rosys/blob/main/rosys/vision/detector_hardware.py).
+
 The detector also has a sio **upload endpoint** that can be used to upload images and detections to the learning loop. The function receives a json dictionary, with the following entries:
 
 - `image`: the image data in jpg format

{learning_loop_node-0.14.0 → learning_loop_node-0.15.0}/learning_loop_node/data_classes/__init__.py

@@ -3,7 +3,7 @@ from .detections import (BoxDetection, ClassificationDetection, Detections, Obse
                          SegmentationDetection, Shape)
 from .general import (AboutResponse, AnnotationNodeStatus, Category, Context, DetectionStatus, ErrorConfiguration,
                       ModelInformation, ModelVersionResponse, NodeState, NodeStatus)
-from .image_metadata import ImageMetadata
+from .image_metadata import ImageMetadata, ImagesMetadata
 from .socket_response import SocketResponse
 from .training import Errors, PretrainedModel, Training, TrainingError, TrainingOut, TrainingStateData, TrainingStatus
 
@@ -12,7 +12,7 @@ __all__ = [
     'BoxDetection', 'ClassificationDetection', 'ImageMetadata', 'Observation', 'Point', 'PointDetection',
     'SegmentationDetection', 'Shape', 'Detections',
     'AnnotationNodeStatus', 'Category', 'Context', 'DetectionStatus', 'ErrorConfiguration',
-    'ModelInformation', 'NodeState', 'NodeStatus', 'ModelVersionResponse',
+    'ModelInformation', 'NodeState', 'NodeStatus', 'ModelVersionResponse', 'ImagesMetadata',
     'SocketResponse',
     'Errors', 'PretrainedModel', 'Training',
     'TrainingError', 'TrainingOut', 'TrainingStateData', 'TrainingStatus',

{learning_loop_node-0.14.0 → learning_loop_node-0.15.0}/learning_loop_node/data_classes/image_metadata.py

@@ -35,3 +35,8 @@ class ImageMetadata():
 
     def __len__(self):
         return len(self.box_detections) + len(self.point_detections) + len(self.segmentation_detections) + len(self.classification_detections)
+
+
+@dataclass(**KWONLY_SLOTS)
+class ImagesMetadata():
+    items: List[ImageMetadata] = field(default_factory=list, metadata={'description': 'List of image metadata'})

{learning_loop_node-0.14.0 → learning_loop_node-0.15.0}/learning_loop_node/data_classes/training.py

@@ -8,6 +8,7 @@ from uuid import uuid4
 
 from ..enums import TrainerState
 from ..helpers.misc import create_image_folder, create_training_folder
+
 # pylint: disable=no-name-in-module
 from .general import Category, Context
 
@@ -52,7 +53,7 @@ class Training():
     training_folder: str  # f'{project_folder}/trainings/{trainings_id}'
 
     categories: List[Category]
-    hyperparameters: dict
+    hyperparameters: Dict[str, Any]
 
     training_number: int
     training_state: str
@@ -63,7 +64,7 @@ class Training():
     base_model_uuid: Optional[str] = None  # model uuid to continue training (is loaded from loop)
 
     # NOTE: these are set later after the model has been uploaded
-    image_data: Optional[List[dict]] = None
+    image_data: Optional[List[Dict]] = None
     skipped_image_count: Optional[int] = None
     model_uuid_for_detecting: Optional[str] = None  # Model uuid to load from the loop after training and upload
 

{learning_loop_node-0.14.0 → learning_loop_node-0.15.0}/learning_loop_node/data_exchanger.py

@@ -7,7 +7,7 @@ from glob import glob
 from http import HTTPStatus
 from io import BytesIO
 from time import time
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 import aiofiles  # type: ignore
 
@@ -68,7 +68,7 @@ class DataExchanger():
         assert response.status_code == 200, response
         return (response.json())['image_ids']
 
-    async def download_images_data(self, image_uuids: List[str], chunk_size: int = 100) -> List[Dict]:
+    async def download_images_data(self, image_uuids: List[str], chunk_size: int = 100) -> List[Dict[str, Any]]:
         """Download image annotations, tags, set and other information for the given image uuids."""
         logging.info('Fetching annotations, tags, sets, etc. for %s images..', len(image_uuids))
 
@@ -78,7 +78,7 @@ class DataExchanger():
             return []
 
         progress_factor = 0.5 / num_image_ids  # first 50% of progress is for downloading data
-        images_data: List[Dict] = []
+        images_data: List[Dict[str, Any]] = []
         for i in range(0, num_image_ids, chunk_size):
             self.progress = i * progress_factor
             chunk_ids = image_uuids[i:i+chunk_size]

{learning_loop_node-0.14.0 → learning_loop_node-0.15.0}/learning_loop_node/detector/detector_logic.py

@@ -2,7 +2,7 @@ import logging
 from abc import abstractmethod
 from typing import List, Optional
 
-from ..data_classes import ImageMetadata, ModelInformation
+from ..data_classes import ImageMetadata, ImagesMetadata, ModelInformation
 from ..globals import GLOBALS
 from .exceptions import NodeNeedsRestartError
 
@@ -52,3 +52,8 @@ class DetectorLogic():
     def evaluate(self, image: bytes) -> ImageMetadata:
         """Evaluate the image and return the detections.
         The object should return empty detections if it is not initialized"""
+
+    @abstractmethod
+    def batch_evaluate(self, images: List[bytes]) -> ImagesMetadata:
+        """Evaluate a batch of images and return the detections.
+        The object should return empty detections if it is not initialized"""

{learning_loop_node-0.14.0 → learning_loop_node-0.15.0}/learning_loop_node/detector/detector_node.py

@@ -6,24 +6,15 @@ import subprocess
 import sys
 from dataclasses import asdict
 from datetime import datetime
-from typing import Dict, List, Optional, cast
+from typing import Dict, List, Optional
 
-import numpy as np
 import socketio
 from dacite import from_dict
 from fastapi.encoders import jsonable_encoder
 from socketio import AsyncClient
 
-from ..data_classes import (
-    AboutResponse,
-    Category,
-    Context,
-    DetectionStatus,
-    ImageMetadata,
-    ModelInformation,
-    ModelVersionResponse,
-    Shape,
-)
+from ..data_classes import (AboutResponse, Category, Context, DetectionStatus, ImageMetadata, ImagesMetadata,
+                            ModelInformation, ModelVersionResponse, Shape)
 from ..data_classes.socket_response import SocketResponse
 from ..data_exchanger import DataExchanger, DownloadError
 from ..enums import OperationMode, VersionMode
@@ -238,8 +229,29 @@ class DetectorNode(Node):
                 return detection_dict
             except Exception as e:
                 self.log.exception('could not detect via socketio')
-                with open('/tmp/bad_img_from_socket_io.jpg', 'wb') as f:
-                    f.write(data['image'])
+                # with open('/tmp/bad_img_from_socket_io.jpg', 'wb') as f:
+                #     f.write(data['image'])
+                return {'error': str(e)}
+
+        @self.sio.event
+        async def batch_detect(sid, data: Dict) -> Dict:
+            try:
+                det = await self.get_batch_detections(
+                    raw_images=data['images'],
+                    tags=data.get('tags', []),
+                    camera_id=data.get('camera-id', None) or data.get('mac', None),
+                    source=data.get('source', None),
+                    autoupload=data.get('autoupload', None),
+                    creation_date=data.get('creation_date', None)
+                )
+                if det is None:
+                    return {'error': 'no model loaded'}
+                detection_dict = jsonable_encoder(asdict(det))
+                return detection_dict
+            except Exception as e:
+                self.log.exception('could not detect via socketio')
+                # with open('/tmp/bad_img_from_socket_io.jpg', 'wb') as f:
+                #     f.write(data['image'])
                 return {'error': str(e)}
 
         @self.sio.event
@@ -479,13 +491,14 @@ class DetectorNode(Node):
 
     async def get_detections(self,
                              raw_image: bytes,
-                             camera_id: Optional[str],
                              tags: List[str],
+                             *,
+                             camera_id: Optional[str] = None,
                              source: Optional[str] = None,
                              autoupload: Optional[str] = None,
                              creation_date: Optional[str] = None) -> ImageMetadata:
         """ Main processing function for the detector node when an image is received via REST or SocketIO.
-        This function infers the detections from the image, cares about uploading to the loop and returns the detections as a dictionary.
+        This function infers the detections from the image, cares about uploading to the loop and returns the detections as ImageMetadata object.
         Note: raw_image is a numpy array of type uint8, but not in the correct shape!
         It can be converted e.g. using cv2.imdecode(raw_image, cv2.IMREAD_COLOR)"""
 
@@ -511,6 +524,40 @@ class DetectorNode(Node):
             self.log.error('unknown autoupload value %s', autoupload)
         return detections
 
+    async def get_batch_detections(self,
+                                   raw_images: List[bytes],
+                                   tags: List[str],
+                                   *,
+                                   camera_id: Optional[str] = None,
+                                   source: Optional[str] = None,
+                                   autoupload: Optional[str] = None,
+                                   creation_date: Optional[str] = None) -> ImagesMetadata:
+        """ Processing function for the detector node when a a batch inference is requested via SocketIO.
+        This function infers the detections from all images, cares about uploading to the loop and returns the detections as a list of ImageMetadata."""
+
+        await self.detection_lock.acquire()
+        all_detections = await run.io_bound(self.detector_logic.batch_evaluate, raw_images)
+        self.detection_lock.release()
+
+        for detections, raw_image in zip(all_detections.items, raw_images):
+            fix_shape_detections(detections)
+            n_bo, n_cl = len(detections.box_detections), len(detections.classification_detections)
+            n_po, n_se = len(detections.point_detections), len(detections.segmentation_detections)
+            self.log.debug('Detected: %d boxes, %d points, %d segs, %d classes', n_bo, n_po, n_se, n_cl)
+
+            autoupload = autoupload or 'filtered'
+            if autoupload == 'filtered' and camera_id is not None:
+                background_tasks.create(self.relevance_filter.may_upload_detections(
+                    detections, camera_id, raw_image, tags, source, creation_date
+                ))
+            elif autoupload == 'all':
+                background_tasks.create(self.outbox.save(raw_image, detections, tags, source, creation_date))
+            elif autoupload == 'disabled':
+                pass
+            else:
+                self.log.error('unknown autoupload value %s', autoupload)
+        return all_detections
+
     async def upload_images(
             self, *,
             images: List[bytes],

{learning_loop_node-0.14.0 → learning_loop_node-0.15.0}/learning_loop_node/tests/detector/test_relevance_filter.py

@@ -30,10 +30,10 @@ async def test_filter_is_used_by_node(test_detector_node: DetectorNode, autouplo
     assert test_detector_node.outbox.path.startswith('/tmp')
     assert len(get_outbox_files(test_detector_node.outbox)) == 0
 
-    image = np.fromfile(file=test_image_path, dtype=np.uint8)
-    _ = await test_detector_node.get_detections(image, '00:.....', tags=[], autoupload=autoupload)
+    image = bytes(np.fromfile(file=test_image_path, dtype=np.uint8))
+    _ = await test_detector_node.get_detections(image, tags=[], camera_id='00:.....', autoupload=autoupload)
     # NOTE adding second images with identical detections
-    _ = await test_detector_node.get_detections(image, '00:.....', tags=[], autoupload=autoupload)
+    _ = await test_detector_node.get_detections(image, tags=[], camera_id='00:.....', autoupload=autoupload)
     await asyncio.sleep(.5)  # files are stored asynchronously
 
     assert len(get_outbox_files(test_detector_node.outbox)) == expected_file_count, \

{learning_loop_node-0.14.0 → learning_loop_node-0.15.0}/learning_loop_node/tests/trainer/conftest.py

@@ -35,7 +35,7 @@ async def test_initialized_trainer_node():
                                                 'training_number': 0,
                                                 'model_variant': '',
                                                 'hyperparameters': {
-                                   'resolution': 800,
+                                   'resolution': 832,
                                    'fliplr': 0.5,
                                    'flipud': 0.5}
     })
@@ -58,7 +58,7 @@ async def test_initialized_trainer():
                                                 'training_number': 0,
                                                 'model_variant': '',
                                                 'hyperparameters': {
-                                   'resolution': 800,
+                                   'resolution': 832,
                                    'fliplr': 0.5,
                                    'flipud': 0.5}
     })

{learning_loop_node-0.14.0 → learning_loop_node-0.15.0}/learning_loop_node/trainer/trainer_logic_generic.py

@@ -6,13 +6,25 @@ import sys
 import time
 from abc import ABC, abstractmethod
 from dataclasses import asdict
-from typing import TYPE_CHECKING, Callable, Coroutine, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Callable, Coroutine, Dict, List, Optional
 
 from fastapi.encoders import jsonable_encoder
 
-from ..data_classes import Context, Errors, PretrainedModel, Training, TrainingOut, TrainingStateData, TrainingStatus
+from ..data_classes import (
+    Context,
+    Errors,
+    PretrainedModel,
+    Training,
+    TrainingOut,
+    TrainingStateData,
+    TrainingStatus,
+)
 from ..enums import TrainerState
-from ..helpers.misc import create_project_folder, delete_all_training_folders, is_valid_uuid4
+from ..helpers.misc import (
+    create_project_folder,
+    delete_all_training_folders,
+    is_valid_uuid4,
+)
 from .downloader import TrainingsDownloader
 from .exceptions import CriticalError, NodeNeedsRestartError
 from .io_helpers import ActiveTrainingIO, EnvironmentVars, LastTrainingIO
@@ -66,7 +78,7 @@ class TrainerLogicGeneric(ABC):
         return self._training
 
     @property
-    def hyperparameters(self) -> dict:
+    def hyperparameters(self) -> Dict[str, Any]:
         assert self._training is not None, 'Training should have data'
         return self._training.hyperparameters
 

{learning_loop_node-0.14.0 → learning_loop_node-0.15.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "learning_loop_node"
-version = "v0.14.0"
+version = "v0.15.0"
 description = "Python Library for Nodes which connect to the Zauberzeug Learning Loop"
 authors = ["Zauberzeug GmbH <info@zauberzeug.com>"]
 license = "MIT"