code-loader 0.2.58.2rc0__tar.gz → 0.2.59.dev2__tar.gz

{code_loader-0.2.58.2rc0 → code_loader-0.2.59.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: code-loader
-Version: 0.2.58.2rc0
+Version: 0.2.59.dev2
 Summary: 
 Home-page: https://github.com/tensorleap/code-loader
 License: MIT
@@ -13,8 +13,8 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Requires-Dist: numpy (>=1.22.3,<2.0.0)
-Requires-Dist: tensorflow (>=2.11.0,<3.0.0) ; platform_machine == "x86_64"
-Requires-Dist: tensorflow-macos (>=2.11.0,<3.0.0) ; platform_machine == "arm64"
+Requires-Dist: tensorflow (>=2.11.0,<3.0.0); platform_machine == "x86_64"
+Requires-Dist: tensorflow-macos (>=2.11.0,<3.0.0); platform_machine == "arm64"
 Requires-Dist: typeguard (>=2.13.3,<3.0.0)
 Project-URL: Repository, https://github.com/tensorleap/code-loader
 Description-Content-Type: text/markdown

{code_loader-0.2.58.2rc0 → code_loader-0.2.59.dev2}/code_loader/helpers/detection/yolo/loss.py

@@ -1,11 +1,13 @@
-from typing import List, Tuple
+from typing import List, Tuple, Union, Optional
 
 import numpy as np
 import tensorflow as tf  # type: ignore
+import torch # type: ignore
 from numpy.typing import NDArray
-
 from code_loader.helpers.detection.utils import true_coords_labels, ciou, xywh_to_xyxy_format
 from code_loader.helpers.detection.yolo.utils import match
+from code_loader.helpers.detection.yolo.pytorch_utils import build_targets
+import collections.abc
 
 
 class YoloLoss:
@@ -18,10 +20,12 @@ class YoloLoss:
     """
 
     def __init__(self, num_classes: int, default_boxes: List[NDArray[np.int32]],
-                 overlap_thresh: float, background_label: int,
+                 overlap_thresh: float, background_label: int, features: List[Tuple[int, int]] = [],
+                 anchors: Optional[NDArray[np.int32]] = None,
                  from_logits: bool = True, weights: List[float] = [4.0, 1.0, 0.4],
-                 max_match_per_gt: int = 10, image_size: int = 640,
-                 cls_w: float = 0.3, obj_w: float = 0.7, box_w: float = 0.05):
+                 max_match_per_gt: int = 10, image_size: Union[Tuple[int, int], int] = (640, 640),
+                 cls_w: float = 0.3, obj_w: float = 0.7, box_w: float = 0.05,
+                 yolo_match: bool = False):
         self.background_label = background_label
         self.default_boxes = [tf.convert_to_tensor(box_arr) for box_arr in default_boxes]
         self.num_classes = num_classes
@@ -31,11 +35,17 @@ class YoloLoss:
         self.weights = weights  # Following yolov7 weights
         scale_factor = 3. / len(weights)
         class_factor = self.num_classes / 80
-        image_factor = image_size / 640.
+        if not isinstance(image_size, collections.abc.Sequence):
+            image_size = (image_size, image_size)
+        image_factor = (image_size[0] + image_size[1]) / 2 / 640.
         self.obj_w = obj_w * scale_factor
         self.cls_w = cls_w * class_factor * scale_factor
         self.box_w = box_w * image_factor ** 2 * scale_factor
         self.max_match_per_gt = max_match_per_gt
+        self.feature_maps = features
+        self.anchors = anchors
+        self.image_size = image_size
+        self.yolo_match = yolo_match
 
     def __call__(self, y_true: tf.Tensor, y_pred: Tuple[List[tf.Tensor], List[tf.Tensor]]) -> \
             Tuple[List[tf.Tensor], List[tf.Tensor], List[tf.Tensor]]:
@@ -52,6 +62,14 @@ class YoloLoss:
         l_losses = []
         c_losses = []
         o_losses = []
+        b, a, gj, gi, target = None, None, None, None, None
+        anchor_num = len(self.default_boxes)
+        if self.yolo_match:
+            b, a, gj, gi, target, _ = self.get_yolo_match(batch_size=num,
+                                                          y_true=y_true,
+                                                          loc_data=loc_data,
+                                                          conf_data=conf_data,
+                                                          )
         for i in range(len(self.default_boxes)):
             default_box_layer = self.default_boxes[i]
             loc_data_layer = loc_data[i]
@@ -62,17 +80,24 @@ class YoloLoss:
             conf_t = []
             priors = tf.cast(priors, dtype=tf.float32)  #
             y_true = tf.cast(y_true, dtype=tf.float32)
-            for idx in range(num):
-                truths, labels = true_coords_labels(idx, y_true, self.background_label)  #
-                loc, conf = match(
-                    threshold=self.threshold, truths=truths, priors=priors,
-                    labels=labels,
-                    background_label=self.background_label,
-                    max_match_per_gt=self.max_match_per_gt)  # encoded_gt_loc, label_pred, ciou between gt and pred
-                loc_t.append(loc)
-                conf_t.append(conf)
-            loc_t_tensor: tf.Tensor = tf.stack(values=loc_t, axis=0)  # this is the location predictions (relative and logged)
-            conf_t_tensor = tf.stack(values=conf_t, axis=0)  # these are the labels
+            if not self.yolo_match:
+                for idx in range(num):
+                    truths, labels = true_coords_labels(idx, y_true, self.background_label)
+                    loc, conf = match(
+                        threshold=self.threshold, truths=truths, priors=priors,
+                        labels=labels,
+                        background_label=self.background_label,
+                        max_match_per_gt=self.max_match_per_gt)  # encoded_gt_loc, label_pred, ciou between gt and pred
+                    loc_t.append(loc)
+                    conf_t.append(conf)
+                loc_t_tensor: tf.Tensor = tf.stack(values=loc_t,
+                                                   axis=0)  # this is the location predictions (relative and logged)
+                conf_t_tensor = tf.stack(values=conf_t, axis=0)
+            else:
+                assert (b is not None) and (a is not None) and (gj is not None) and (gi is not None) and\
+                       (target is not None) # for typing - how do we remove?
+                loc_t_tensor, conf_t_tensor = self.get_scale_matched_gt_tf(i, num, b, a, gj, gi, target)
+            # these are the labels
             pos = conf_t_tensor != self.background_label
             num_pos = tf.reduce_sum(tf.cast(pos, dtype=tf.int32))
 
@@ -135,3 +160,39 @@ class YoloLoss:
             c_losses.append(loss_c_tensor)
             o_losses.append(loss_o_tensor)
         return l_losses, c_losses, o_losses
+
+    def get_scale_matched_gt_tf(self, i: int, batch_size: int, b: List[torch.Tensor], a: List[torch.Tensor],
+                                gj: List[torch.Tensor], gi: List[torch.Tensor],
+                                target: List[torch.Tensor]) -> Tuple[tf.Tensor, tf.Tensor]:
+        # temp
+        gt_class = tf.ones((batch_size,
+                            len(self.feature_maps), *self.feature_maps[i]), dtype=tf.int32) * self.background_label
+        if len(b[i]) > 0:
+            gt_class = tf.tensor_scatter_nd_update(gt_class, torch.stack([b[i], a[i], gj[i], gi[i]]).T.numpy(),
+                                                   target[i][:, 1])
+        conf_t_tensor = tf.reshape(gt_class, [gt_class.shape[0], -1])
+        assert self.anchors is not None
+        gt_loc = tf.zeros((batch_size, len(self.anchors[i]), *self.feature_maps[i], 4), dtype=tf.float32)
+        if len(b[i]) > 0:
+            gt_loc = tf.tensor_scatter_nd_update(gt_loc, torch.stack([b[i], a[i], gj[i], gi[i]]).T.numpy(),
+                                                 target[i][:, -4:])
+        loc_t_tensor = tf.reshape(gt_loc, [gt_class.shape[0], -1, 4])
+        return loc_t_tensor, conf_t_tensor
+
+    def get_yolo_match(self, batch_size: int, y_true: tf.Tensor, loc_data: List[tf.Tensor], conf_data: List[tf.Tensor]) \
+            -> Tuple[List[torch.Tensor], ...]:
+        yolo_targets: List[NDArray[np.float32]] = []
+        scales_num = len(loc_data)
+        for i in range(batch_size):
+            batch_gt = y_true[i][y_true[i, ..., -1] != self.background_label]
+            yolo_targets.append(np.concatenate([np.ones((batch_gt.shape[0], 1)) * i, batch_gt[:, 4:], batch_gt[:, :4]], axis=1))
+        yolo_targets_cat: NDArray[np.float32] = np.concatenate(yolo_targets, axis=0)
+        orig_pred = [torch.from_numpy(tf.concat([loc_data[i], conf_data[i]], axis=-1).numpy()) for i in
+                     range(scales_num)]
+        fin_pred = [pred.reshape([pred.shape[0], scales_num, *self.feature_maps[i], -1]) for i, pred in
+                    enumerate(orig_pred)]
+        yolo_anchors = np.array(self.anchors) * np.swapaxes(np.array([*self.feature_maps])[..., None], 1, 2) / 640
+        b, a, gj, gi, target, anch = build_targets(fin_pred, torch.from_numpy(yolo_targets_cat.astype(np.float32)),
+                                                   torch.from_numpy(yolo_anchors.astype(np.float32)), self.image_size,
+                                                   self.num_classes)
+        return b, a, gj, gi, target, anch

code_loader-0.2.59.dev2/code_loader/helpers/detection/yolo/pytorch_utils.py

@@ -0,0 +1,250 @@
+#Taken from Yolov7 https://github.com/WongKinYiu/yolov7
+import numpy as np
+import torch # type: ignore
+import torch.nn.functional as F # type: ignore
+from code_loader.helpers.detection.utils import xywh_to_xyxy_format
+from typing import List, Tuple
+
+
+def find_3_positive(p: List[torch.Tensor], targets: torch.Tensor, anchors: torch.Tensor) ->\
+        Tuple[List[Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]], List[torch.Tensor]]:
+    # Build targets for compute_loss(), input targets(x,y,w,h)
+    # p.shape = [B,3, GX, GW, 5+CLASSES]
+    # targers.shape = [B,6=[image, class, x, y, w, h,]]
+    # targets=torch.from_numpy(truths.numpy())
+    na, nt = anchors.shape[0], targets.shape[0]  # number of anchors, targets
+    indices, anch = [], []
+    gain = torch.ones(7, device=targets.device).long()  # normalized to gridspace gain
+    ai = torch.arange(na, device=targets.device).float().view(na, 1).repeat(1, nt)  # same as .repeat_interleave(nt)
+    targets = torch.cat((targets.repeat(na, 1, 1), ai[:, :, None]), 2)  # append anchor indices
+
+    g = 0.5  # bias
+    off = torch.tensor([[0, 0],
+                        [1, 0], [0, 1], [-1, 0], [0, -1],  # j,k,l,m
+                        # [1, 1], [1, -1], [-1, 1], [-1, -1],  # jk,jm,lk,lm
+                        ], device=targets.device).float() * g  # offsets
+    for i in range(len(p)):
+        gain[2:6] = torch.tensor(p[i].shape)[[3, 2, 3, 2]]  # xyxy gain
+        layer_anchors = anchors[i]
+
+        # Match targets to anchors
+        t = targets * gain
+        if nt:
+            # Matches
+            r = t[:, :, 2:4] / layer_anchors[:, None]  # wh ratio
+            j = torch.max(r, 1. / r).max(2)[0] < 4  # compare
+            # j = wh_iou(anchors, t[:, 4:6]) > model.hyp['iou_t']  # iou(3,n)=wh_iou(anchors(3,2), gwh(n,2))
+            t = t[j]  # filter only relevant anchors
+
+            # Offsets
+            gxy = t[:, 2:4]  # grid xy
+            gxi = gain[[2, 3]] - gxy  # inverse offset in the feature space
+            j, k = ((gxy % 1. < g) & (gxy > 1.)).T  # x closer to left, y closest to up
+            l, m = ((gxi % 1. < g) & (gxi > 1.)).T  # x closer to right, y closet to down
+            j = torch.stack((torch.ones_like(j), j, k, l, m))  # [True, x-left, y-up, x-right, y-down]
+            t = t.repeat((5, 1, 1))[j]
+            offsets = (torch.zeros_like(gxy)[None] + off[:, None])[j]
+        else:
+            t = targets[0]
+            offsets = 0
+
+            # Define
+        b, c = t[:, :2].long().T  # image, class
+        gxy = t[:, 2:4]  # grid xy
+        gwh = t[:, 4:6]  # grid wh
+        gij = (gxy - offsets).long()
+        gi, gj = gij.T  # grid xy indices
+
+        # Append
+        a = t[:, 6].long()  # anchor indices
+        indices.append(
+            (b, a, gj.clamp_(0, gain[3] - 1), gi.clamp_(0, gain[2] - 1)))  # image, anchor, grid indices [y,x]]
+        anch.append(layer_anchors[a])  # anchors
+
+    return indices, anch
+
+
+def box_iou(box1: torch.Tensor, box2: torch.Tensor) -> torch.Tensor:
+    # https://github.com/pytorch/vision/blob/master/torchvision/ops/boxes.py
+    """
+    Return intersection-over-union (Jaccard index) of boxes.
+    Both sets of boxes are expected to be in (x1, y1, x2, y2) format.
+    Arguments:
+        box1 (Tensor[N, 4])
+        box2 (Tensor[M, 4])
+    Returns:
+        iou (Tensor[N, M]): the NxM matrix containing the pairwise
+            IoU values for every element in boxes1 and boxes2
+    """
+
+    def box_area(box: torch.Tensor) -> torch.Tensor:
+        # box = 4xn
+        return (box[2] - box[0]) * (box[3] - box[1])
+
+    area1 = box_area(box1.T)
+    area2 = box_area(box2.T)
+
+    # inter(N,M) = (rb(N,M,2) - lt(N,M,2)).clamp(0).prod(2)
+    inter = (torch.min(box1[:, None, 2:], box2[:, 2:]) - torch.max(box1[:, None, :2], box2[:, :2])).clamp(0).prod(2)
+    return inter / (area1[:, None] + area2 - inter)  # iou = inter / (area1 + area2 - inter)
+
+
+def build_targets(p: List[torch.Tensor], targets: torch.Tensor, anchors: torch.Tensor,
+                  image_size: Tuple[int, int], num_classes: int) -> Tuple[List[torch.Tensor], ...]:
+    # targets [Image, class, x, y, w, h]
+    # anchors [scale x anchor-per-scale]
+    # P == LIST[[B,ANCHORS,H_scale_i,W_scale_i,CLASSES+5]...]
+    # len(p) == scales
+
+    # indices, anch = self.find_positive(p, targets)
+    indices, anch = find_3_positive(p, targets, anchors)
+    # indices, anch = self.find_4_positive(p, targets)
+    # indices, anch = self.find_5_positive(p, targets)
+    # indices, anch = self.find_9_positive(p, targets)
+
+    matching_bs: List[torch.Tensor] = [[] for pp in p]
+    matching_as: List[torch.Tensor] = [[] for pp in p]
+    matching_gjs: List[torch.Tensor] = [[] for pp in p]
+    matching_gis: List[torch.Tensor] = [[] for pp in p]
+    matching_targets: List[torch.Tensor] = [[] for pp in p]
+    matching_anchs: List[torch.Tensor] = [[] for pp in p]
+
+    nl = len(p)
+
+    for batch_idx in range(p[0].shape[0]):
+
+        b_idx = targets[:, 0] == batch_idx
+        this_target = targets[b_idx]
+        if this_target.shape[0] == 0:
+            continue
+
+        txywh = this_target[:, 2:6] * np.array([*image_size[::-1], *image_size[::-1]], dtype=np.float32)
+        txyxy = torch.from_numpy(xywh_to_xyxy_format(txywh).astype(np.float32))
+
+        pxyxys = []
+        p_cls = []
+        p_obj = []
+        from_which_layer = []
+        all_b = []
+        all_a = []
+        all_gj = []
+        all_gi = []
+        all_anch = []
+
+        for i, pi in enumerate(p):
+            b, a, gj, gi = indices[i]
+            idx = (b == batch_idx)
+            b, a, gj, gi = b[idx], a[idx], gj[idx], gi[idx]
+            all_b.append(b)
+            all_a.append(a)
+            all_gj.append(gj)
+            all_gi.append(gi)
+            all_anch.append(anch[i][idx])
+            from_which_layer.append(torch.ones(size=(len(b),)) * i)
+
+            fg_pred = pi[b, a, gj, gi]
+            p_obj.append(fg_pred[:, 4:5])
+            p_cls.append(fg_pred[:, 5:])
+
+            grid = torch.stack([gi, gj], dim=1)
+            pxy = fg_pred[:, :2] * torch.from_numpy(np.array([*image_size[::-1]]).astype(np.float32))
+            pwh = fg_pred[:, 2:4] * torch.from_numpy(np.array([*image_size[::-1]]).astype(np.float32))
+            pxywh = torch.cat([pxy, pwh], dim=-1)
+            pxyxy = torch.from_numpy(xywh_to_xyxy_format(pxywh).astype(np.float32))
+            pxyxys.append(pxyxy)
+
+        pxyxys_cat = torch.cat(pxyxys, dim=0)
+        if pxyxys_cat.shape[0] == 0:
+            continue
+        p_obj_cat = torch.cat(p_obj, dim=0)
+        p_cls_cat = torch.cat(p_cls, dim=0)
+        from_which_layer_cat = torch.cat(from_which_layer, dim=0)
+        all_b = torch.cat(all_b, dim=0)
+        all_a = torch.cat(all_a, dim=0)
+        all_gj = torch.cat(all_gj, dim=0)
+        all_gi = torch.cat(all_gi, dim=0)
+        all_anch = torch.cat(all_anch, dim=0)
+
+        pair_wise_iou = box_iou(txyxy, pxyxys_cat)  # (BB-matched,4), BB-matches(scale)=#anchors-matches*3
+
+        pair_wise_iou_loss = -torch.log(pair_wise_iou + 1e-8)
+
+        top_k, _ = torch.topk(pair_wise_iou, min(10, pair_wise_iou.shape[1]), dim=1)
+        dynamic_ks = torch.clamp(top_k.sum(1).int(), min=1)
+
+        gt_cls_per_image = (
+            F.one_hot(this_target[:, 1].to(torch.int64), num_classes)
+                .float()
+                .unsqueeze(1)
+                .repeat(1, pxyxys_cat.shape[0], 1)
+        )
+
+        num_gt = this_target.shape[0]
+        cls_preds_ = (
+                p_cls_cat.float().unsqueeze(0).repeat(num_gt, 1, 1).sigmoid_()
+                * p_obj_cat.unsqueeze(0).repeat(num_gt, 1, 1).sigmoid_()
+        )
+
+        y = cls_preds_.sqrt_()
+        pair_wise_cls_loss = F.binary_cross_entropy_with_logits(
+            torch.log(y / (1 - y)), gt_cls_per_image, reduction="none"
+        ).sum(-1)
+        del cls_preds_
+
+        cost = (
+                pair_wise_cls_loss
+                + 3.0 * pair_wise_iou_loss
+        )
+
+        matching_matrix = torch.zeros_like(cost)
+
+        for gt_idx in range(num_gt):
+            _, pos_idx = torch.topk(
+                cost[gt_idx], k=dynamic_ks[gt_idx].item(), largest=False
+            )
+            matching_matrix[gt_idx][pos_idx] = 1.0
+
+        del top_k, dynamic_ks
+        anchor_matching_gt = matching_matrix.sum(0)  # sum of the matches per anchor
+        if (anchor_matching_gt > 1).sum() > 0:
+            _, cost_argmin = torch.min(cost[:, anchor_matching_gt > 1], dim=0)
+            matching_matrix[:, anchor_matching_gt > 1] *= 0.0
+            matching_matrix[cost_argmin, anchor_matching_gt > 1] = 1.0
+        fg_mask_inboxes = matching_matrix.sum(0) > 0.0
+        matched_gt_inds = matching_matrix[:, fg_mask_inboxes].argmax(0)
+
+        from_which_layer_cat = from_which_layer_cat[fg_mask_inboxes]
+        all_b = all_b[fg_mask_inboxes]
+        all_a = all_a[fg_mask_inboxes]
+        all_gj = all_gj[fg_mask_inboxes]
+        all_gi = all_gi[fg_mask_inboxes]
+        all_anch = all_anch[fg_mask_inboxes]
+
+        this_target = this_target[matched_gt_inds]
+
+        for i in range(nl):
+            layer_idx = from_which_layer_cat == i
+            matching_bs[i].append(all_b[layer_idx])
+            matching_as[i].append(all_a[layer_idx])
+            matching_gjs[i].append(all_gj[layer_idx])
+            matching_gis[i].append(all_gi[layer_idx])
+            matching_targets[i].append(this_target[layer_idx])
+            matching_anchs[i].append(all_anch[layer_idx])
+
+    for i in range(nl):
+        if matching_targets[i] != []:
+            matching_bs[i] = torch.cat(matching_bs[i], dim=0)
+            matching_as[i] = torch.cat(matching_as[i], dim=0)
+            matching_gjs[i] = torch.cat(matching_gjs[i], dim=0)
+            matching_gis[i] = torch.cat(matching_gis[i], dim=0)
+            matching_targets[i] = torch.cat(matching_targets[i], dim=0)
+            matching_anchs[i] = torch.cat(matching_anchs[i], dim=0)
+        else:
+            matching_bs[i] = torch.tensor([], dtype=torch.int64)
+            matching_as[i] = torch.tensor([], dtype=torch.int64)
+            matching_gjs[i] = torch.tensor([], dtype=torch.int64)
+            matching_gis[i] = torch.tensor([], dtype=torch.int64)
+            matching_targets[i] = torch.tensor([], dtype=torch.int64)
+            matching_anchs[i] = torch.tensor([], dtype=torch.int64)
+
+    return matching_bs, matching_as, matching_gjs, matching_gis, matching_targets, matching_anchs  # SCALE*[B,anchor-idx, j, i,  GTs, anchors]

{code_loader-0.2.58.2rc0 → code_loader-0.2.59.dev2}/code_loader/leaploader.py

@@ -1,9 +1,8 @@
 import importlib.util
 from functools import lru_cache
 from pathlib import Path
-from typing import Dict, List, Iterable, Any, Union, Optional
+from typing import Dict, List, Iterable, Any, Union
 import sys
-import os
 
 import numpy as np
 import numpy.typing as npt
@@ -23,14 +22,12 @@ from code_loader.utils import get_root_exception_line_number, get_shape
 
 class LeapLoader:
     def __init__(self, dataset_script: str, code_path: str = '', code_entry_name: str = ''):
-        print(f"Hello from LeapLoader init code_path: {code_path} code_entry_name: {code_entry_name}")
         self.dataset_script: str = dataset_script
         self.code_entry_name = code_entry_name
         self.code_path = code_path
 
     @lru_cache()
     def exec_script(self) -> None:
-        print(f"Hello from LeapLoader exec_script")
         try:
             # TODO: make these fields mandatory and delete load_script method
             if self.code_path and self.code_entry_name:
@@ -42,17 +39,12 @@ class LeapLoader:
             raise DatasetScriptException(getattr(e, 'message', repr(e))) from e
 
     def load_script(self) -> None:
-        print(f"Hello from LeapLoader load_script pre run")
         global_variables: Dict[Any, Any] = {}
         exec(self.dataset_script, global_variables)
-        print(f"Hello from LeapLoader load_script done")
 
     def evaluate_module(self) -> None:
-        print(f"Hello from LeapLoader evaluate_module")
-
         def append_path_recursively(full_path: str) -> None:
-            if '/' not in full_path:
-                print(f"Hello from LeapLoader append_path_recursively stop condition")
+            if '/' not in full_path or full_path == '/':
                 return
 
             parent_path = str(Path(full_path).parent)
@@ -61,20 +53,16 @@ class LeapLoader:
 
         append_path_recursively(self.code_path)
 
-        print(f"Hello from LeapLoader append_path_recursively done")
         file_path = Path(self.code_path, self.code_entry_name)
         spec = importlib.util.spec_from_file_location(self.code_path, file_path)
-        print(f"Hello from LeapLoader spec_from_file_location done")
         if spec is None or spec.loader is None:
             raise DatasetScriptException(f'Something is went wrong with spec file from: {file_path}')
 
         file = importlib.util.module_from_spec(spec)
-        print(f"Hello from LeapLoader module_from_spec done")
         if file is None:
             raise DatasetScriptException(f'Something is went wrong with import module from: {file_path}')
 
         spec.loader.exec_module(file)
-        print(f"Hello from LeapLoader evaluate_module done")
 
     @lru_cache()
     def metric_by_name(self) -> Dict[str, MetricHandler]:

{code_loader-0.2.58.2rc0 → code_loader-0.2.59.dev2}/pyproject.toml

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

code_loader-0.2.59.dev2/setup.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+from setuptools import setup
+
+packages = \
+['code_loader',
+ 'code_loader.contract',
+ 'code_loader.helpers',
+ 'code_loader.helpers.detection',
+ 'code_loader.helpers.detection.yolo',
+ 'code_loader.leap_binder',
+ 'code_loader.metrics',
+ 'code_loader.visualizers']
+
+package_data = \
+{'': ['*']}
+
+install_requires = \
+['numpy>=1.22.3,<2.0.0', 'typeguard>=2.13.3,<3.0.0']
+
+extras_require = \
+{':platform_machine == "arm64"': ['tensorflow-macos>=2.11.0,<3.0.0'],
+ ':platform_machine == "x86_64"': ['tensorflow>=2.11.0,<3.0.0']}
+
+setup_kwargs = {
+    'name': 'code-loader',
+    'version': '0.2.59.dev2',
+    'description': '',
+    'long_description': '# tensorleap code loader\nUsed to load user code to tensorleap \n',
+    'author': 'dorhar',
+    'author_email': 'doron.harnoy@tensorleap.ai',
+    'maintainer': 'None',
+    'maintainer_email': 'None',
+    'url': 'https://github.com/tensorleap/code-loader',
+    'packages': packages,
+    'package_data': package_data,
+    'install_requires': install_requires,
+    'extras_require': extras_require,
+    'python_requires': '>=3.8,<3.11',
+}
+
+
+setup(**setup_kwargs)