code-loader 1.0.49.dev1__tar.gz → 1.0.49.dev3__tar.gz

{code_loader-1.0.49.dev1 → code_loader-1.0.49.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: code-loader
-Version: 1.0.49.dev1
+Version: 1.0.49.dev3
 Summary: 
 Home-page: https://github.com/tensorleap/code-loader
 License: MIT

code_loader-1.0.49.dev3/code_loader/code_inegration_processes_manager.py

@@ -0,0 +1,83 @@
+# mypy: ignore-errors
+import traceback
+from dataclasses import dataclass
+
+from typing import List, Tuple, Optional
+
+from multiprocessing import Process, Queue
+
+from code_loader.leap_loader_parallelized_base import LeapLoaderParallelizedBase
+from code_loader.leaploader import LeapLoader
+from code_loader.contract.enums import DataStateEnum
+from code_loader.metric_calculator_parallelized import MetricCalculatorParallelized
+from code_loader.samples_generator_parallelized import SamplesGeneratorParallelized
+
+
+@dataclass
+class SampleSerializableError:
+    state: DataStateEnum
+    index: int
+    leap_script_trace: str
+    exception_as_str: str
+
+
+class CodeIntegrationProcessesManager:
+    def __init__(self, code_path: str, code_entry_name: str, n_workers: Optional[int] = 2,
+                 max_samples_in_queue: int = 128) -> None:
+        self.metric_calculator_parallelized = MetricCalculatorParallelized(code_path, code_entry_name)
+        self.samples_generator_parallelized = SamplesGeneratorParallelized(code_path, code_entry_name)
+
+    def _create_and_start_process(self) -> Process:
+        process = self.multiprocessing_context.Process(
+            target=CodeIntegrationProcessesManager._process_func,
+            args=(self.code_path, self.code_entry_name, self._inputs_waiting_to_be_process,
+                  self._ready_processed_results))
+        process.daemon = True
+        process.start()
+        return process
+
+    def _run_and_warm_first_process(self):
+        process = self._create_and_start_process()
+        self.processes = [process]
+
+        # needed in order to make sure the preprocess func runs once in nonparallel
+        self._start_process_inputs([(DataStateEnum.training, 0)])
+        self._get_next_ready_processed_result()
+
+    def _operation_decider(self):
+        if self.metric_calculator_parallelized._ready_processed_results.empty() and not \
+            self.metric_calculator_parallelized._inputs_waiting_to_be_process.empty():
+            return 'metric'
+
+        if self.samples_generator_parallelized._ready_processed_results.empty() and not \
+            self.samples_generator_parallelized._inputs_waiting_to_be_process.empty():
+            return 'dataset'
+
+
+
+
+    @staticmethod
+    def _process_func(code_path: str, code_entry_name: str,
+                      samples_to_process: Queue, ready_samples: Queue,
+                      metrics_to_process: Queue, ready_metrics: Queue) -> None:
+        import os
+        os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
+
+        leap_loader = LeapLoader(code_path, code_entry_name)
+        while True:
+
+            # decide on sample or metric to process
+            state, idx = samples_to_process.get(block=True)
+            leap_loader._preprocess_result()
+            try:
+                sample = leap_loader.get_sample(state, idx)
+            except Exception as e:
+                leap_script_trace = traceback.format_exc().split('File "<string>"')[-1]
+                ready_samples.put(SampleSerializableError(state, idx, leap_script_trace, str(e)))
+                continue
+
+            ready_samples.put(sample)
+
+    def generate_samples(self, sample_identities: List[Tuple[DataStateEnum, int]]):
+        return self.start_process_inputs(sample_identities)
+

{code_loader-1.0.49.dev1 → code_loader-1.0.49.dev3}/code_loader/leaploader.py

@@ -24,13 +24,11 @@ from code_loader.utils import get_root_exception_file_and_line_number
 
 
 class LeapLoader:
-    def __init__(self, code_path: str, code_entry_name: str, streaming_mode: bool = False):
+    def __init__(self, code_path: str, code_entry_name: str):
         self.code_entry_name = code_entry_name
         self.code_path = code_path
 
-        self.streaming_mode = streaming_mode
         self._preprocess_result_cached = None
-        self._last_updated_unlabeled_preprocess = None
 
     @lru_cache()
     def exec_script(self) -> None:
@@ -110,6 +108,10 @@ class LeapLoader:
 
     def get_sample(self, state: DataStateEnum, idx: int) -> DatasetSample:
         self.exec_script()
+        preprocess_result = self._preprocess_result()
+        if state == DataStateEnum.unlabeled and idx not in preprocess_result[state].sample_ids:
+            self._preprocess_result(update_unlabeled_preprocess=True)
+
         sample = DatasetSample(inputs=self._get_inputs(state, idx),
                                gt=None if state == DataStateEnum.unlabeled else self._get_gt(state, idx),
                                metadata=self._get_metadata(state, idx),
@@ -284,28 +286,20 @@ class LeapLoader:
         ]
         return ModelSetup(custom_layer_instances)
 
-    def _preprocess_result(self) -> Dict[DataStateEnum, PreprocessResponse]:
+    def _preprocess_result(self, update_unlabeled_preprocess=False) -> Dict[DataStateEnum, PreprocessResponse]:
         self.exec_script()
 
         if self._preprocess_result_cached is None:
             self._preprocess_result_cached = global_leap_binder.get_preprocess_result()
-            self._last_updated_unlabeled_preprocess = time.time()
 
-        if self.streaming_mode and global_leap_binder.setup_container.unlabeled_data_preprocess is None:
-            raise Exception("unlabeled_data_preprocess is not defined in the dataset script and it "
-                            "most be defined in production monitoring.")
-
-        update_unlabeled_preprocess_interval = 120
-        if (self.streaming_mode and
-                time.time() - self._last_updated_unlabeled__preprocess > update_unlabeled_preprocess_interval):
+        if update_unlabeled_preprocess:
             self._preprocess_result_cached[
                 DataStateEnum.unlabeled] = global_leap_binder.get_preprocess_unlabeled_result()
-            self._last_updated_unlabeled_preprocess = time.time()
 
         return self._preprocess_result_cached
 
-    def get_preprocess_sample_ids(self) -> Dict[DataStateEnum, Union[List[int], List[str]]]:
-        preprocess_result = self._preprocess_result()
+    def get_preprocess_sample_ids(self, update_unlabeled_preprocess=False) -> Dict[DataStateEnum, Union[List[int], List[str]]]:
+        preprocess_result = self._preprocess_result(update_unlabeled_preprocess)
         sample_ids = {}
         for state, preprocess_response in preprocess_result.items():
             sample_ids[state] = preprocess_response.sample_ids

{code_loader-1.0.49.dev1 → code_loader-1.0.49.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "code-loader"
-version = "1.0.49.dev1"
+version = "1.0.49.dev3"
 description = ""
 authors = ["dorhar <doron.harnoy@tensorleap.ai>"]
 license = "MIT"