modelinhos 0.0.0__tar.gz

modelinhos-0.0.0/.github/workflows/publish.yml

@@ -0,0 +1,33 @@
+name: publish
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    permissions:
+      id-token: write  # Required for OIDC authentication
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.x'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build
+
+    - name: Build package
+      run: python -m build
+
+    - name: Publish to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        verbose: true

modelinhos-0.0.0/.github/workflows/tests.yml

@@ -0,0 +1,40 @@
+name: tests
+
+on:
+  push:
+    branches:
+      - "**"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        python-version: ["3.12"]
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          pip install -r requirements.txt
+          pip install .
+
+      - name: Run the tests
+        run: |
+          pytest tests/
+
+      - name: Run pre-commit checks
+        uses: pre-commit/action@v3.0.1
+
+      - name: Check package metadata rendering (twine check)
+        run: |
+          pip install build twine
+          python -m build --sdist --wheel
+          twine check dist/*

modelinhos-0.0.0/.gitignore

@@ -0,0 +1,10 @@
+*.egg-*
+*.pyc
+.coverage*
+.python-version
+.vscode
+*.png
+*.onnx
+*.bin
+.DS_Store
+datasets

modelinhos-0.0.0/.pre-commit-config.yaml

@@ -0,0 +1,31 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.0.1
+    hooks:
+      - id: check-added-large-files
+        args: ["--maxkb=1000"]
+      - id: check-json
+      - id: check-docstring-first
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.4.4
+    hooks:
+      - id: ruff
+        args: [
+          "--config=pyproject.toml",
+          "--fix",
+        ]
+
+      - id: ruff-format
+        args: [
+          "--config=pyproject.toml"
+        ]
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v0.921
+    hooks:
+      - id: mypy
+        additional_dependencies: ["types-PyYAML"]
+        args: ["--config-file", "pyproject.toml"]

modelinhos-0.0.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: modelinhos
+Version: 0.0.0
+Summary: Model zoo for a very small models
+Description-Content-Type: text/x-rst
+Requires-Dist: opencv-python
+Requires-Dist: numpy<2
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: onnx
+Requires-Dist: dacite
+Requires-Dist: dataclasses-json
+Requires-Dist: mean_average_precision
+Requires-Dist: tqdm
+Requires-Dist: requests
+Requires-Dist: matplotlib
+Requires-Dist: joblib
+
+Detection models
+================
+
+This is a small model zoo of small detection models.

modelinhos-0.0.0/README.rst

@@ -0,0 +1,4 @@
+Detection models
+================
+
+This is a small model zoo of small detection models.

modelinhos-0.0.0/TODO.md

@@ -0,0 +1,21 @@
+Things to do:
+
+- [x] See what happens when we remove anchors from retina-net -> man is not detected, ties are kinda detected
+- [x] Add the ssd model
+- [x] Simplify the anchor tests
+- [x] Fix the load with mismatch for when new(n_classes) > old(n_classes)
+- [x] Add the fit/transform/predict wrappers
+- [x] Add the notion of samples instead of operating on dicts
+- [x] Fix plotting with Samples
+- [x] Add the toy-example
+- [x] Adapt the mAP calculation
+- [x] Add per-sample map calculation.
+- [x] Download the COCO evaluation dataset
+- [ ] Add a tool to select the thresholds
+    - [x] Add FP / FN calculation @ threshold for each image to detect the failures
+    - [x] Plot PR curve -- looking at these plots select the threshold
+    - [x] Add FP / FN calculation per image @ threshold -- already evaluation
+- [ ] Use the batched version by default
+- [ ] Add the fcos inference
+- [ ] Add the BlazeNet inference (anchors parametrization)
+- [ ] Implement the BlazeNet tests

modelinhos-0.0.0/modelinhos/blaze/blazenet.py

@@ -0,0 +1,278 @@
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class BlazeBlock(nn.Module):
+    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1):
+        super(BlazeBlock, self).__init__()
+
+        self.stride = stride
+        self.channel_pad = out_channels - in_channels
+
+        # TFLite uses slightly different padding than PyTorch
+        # on the depthwise conv layer when the stride is 2.
+        if stride == 2:
+            self.max_pool = nn.MaxPool2d(kernel_size=stride, stride=stride)
+            padding = 0
+        else:
+            padding = (kernel_size - 1) // 2
+
+        self.convs = nn.Sequential(
+            nn.Conv2d(
+                in_channels=in_channels,
+                out_channels=in_channels,
+                kernel_size=kernel_size,
+                stride=stride,
+                padding=padding,
+                groups=in_channels,
+                bias=True,
+            ),
+            nn.Conv2d(
+                in_channels=in_channels,
+                out_channels=out_channels,
+                kernel_size=1,
+                stride=1,
+                padding=0,
+                bias=True,
+            ),
+        )
+
+        self.act = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        if self.stride == 2:
+            h = F.pad(x, (0, 2, 0, 2), "constant", 0)
+            x = self.max_pool(x)
+        else:
+            h = x
+
+        if self.channel_pad > 0:
+            x = F.pad(x, (0, 0, 0, 0, 0, self.channel_pad), "constant", 0)
+
+        return self.act(self.convs(h) + x)
+
+
+class FinalBlazeBlock(nn.Module):
+    def __init__(self, channels, kernel_size=3):
+        super(FinalBlazeBlock, self).__init__()
+        # TFLite uses slightly different padding than PyTorch
+        # on the depthwise conv layer when the stride is 2.
+        self.convs = nn.Sequential(
+            nn.Conv2d(
+                in_channels=channels,
+                out_channels=channels,
+                kernel_size=kernel_size,
+                stride=2,
+                padding=0,
+                groups=channels,
+                bias=True,
+            ),
+            nn.Conv2d(
+                in_channels=channels,
+                out_channels=channels,
+                kernel_size=1,
+                stride=1,
+                padding=0,
+                bias=True,
+            ),
+        )
+
+        self.act = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        h = F.pad(x, (0, 2, 0, 2), "constant", 0)
+
+        return self.act(self.convs(h))
+
+
+class BlazeNet(nn.Module):
+    """The BlazeFace face detection model from MediaPipe.
+
+    The version from MediaPipe is simpler than the one in the paper;
+    it does not use the "double" BlazeBlocks.
+
+    Because we won't be training this model, it doesn't need to have
+    batchnorm layers. These have already been "folded" into the conv
+    weights by TFLite.
+
+    The conversion to PyTorch is fairly straightforward, but there are
+    some small differences between TFLite and PyTorch in how they handle
+    padding on conv layers with stride 2.
+
+    This version works on batches, while the MediaPipe version can only
+    handle a single image at a time.
+
+    Based on code from https://github.com/tkat0/PyTorch_BlazeFace/ and
+    https://github.com/google/mediapipe/
+    """
+
+    def __init__(self, back_model=False):
+        super(BlazeNet, self).__init__()
+
+        # These are the settings from the MediaPipe example graphs
+        # mediapipe/graphs/face_detection/face_detection_mobile_gpu.pbtxt
+        # and
+        # mediapipe/graphs/face_detection/face_detection_back_mobile_gpu.pbtxt
+        self.num_classes = 1
+        self.num_anchors = 896
+        self.num_coords = 16
+        self.score_clipping_thresh = 100.0
+        self.back_model = back_model
+        if back_model:
+            self.x_scale = 256.0
+            self.y_scale = 256.0
+            self.h_scale = 256.0
+            self.w_scale = 256.0
+            self.min_score_thresh = 0.65
+        else:
+            self.x_scale = 128.0
+            self.y_scale = 128.0
+            self.h_scale = 128.0
+            self.w_scale = 128.0
+            self.min_score_thresh = 0.75
+        self.min_suppression_threshold = 0.3
+
+        self._define_layers()
+
+    def _define_layers(self):
+        if self.back_model:
+            self.backbone = nn.Sequential(
+                nn.Conv2d(
+                    in_channels=3,
+                    out_channels=24,
+                    kernel_size=5,
+                    stride=2,
+                    padding=0,
+                    bias=True,
+                ),
+                nn.ReLU(inplace=True),
+                BlazeBlock(24, 24),
+                BlazeBlock(24, 24),
+                BlazeBlock(24, 24),
+                BlazeBlock(24, 24),
+                BlazeBlock(24, 24),
+                BlazeBlock(24, 24),
+                BlazeBlock(24, 24),
+                BlazeBlock(24, 24, stride=2),
+                BlazeBlock(24, 24),
+                BlazeBlock(24, 24),
+                BlazeBlock(24, 24),
+                BlazeBlock(24, 24),
+                BlazeBlock(24, 24),
+                BlazeBlock(24, 24),
+                BlazeBlock(24, 24),
+                BlazeBlock(24, 48, stride=2),
+                BlazeBlock(48, 48),
+                BlazeBlock(48, 48),
+                BlazeBlock(48, 48),
+                BlazeBlock(48, 48),
+                BlazeBlock(48, 48),
+                BlazeBlock(48, 48),
+                BlazeBlock(48, 48),
+                BlazeBlock(48, 96, stride=2),
+                BlazeBlock(96, 96),
+                BlazeBlock(96, 96),
+                BlazeBlock(96, 96),
+                BlazeBlock(96, 96),
+                BlazeBlock(96, 96),
+                BlazeBlock(96, 96),
+                BlazeBlock(96, 96),
+            )
+            self.final = FinalBlazeBlock(96)
+            self.classifier_8 = nn.Conv2d(96, 2, 1, bias=True)
+            self.classifier_16 = nn.Conv2d(96, 6, 1, bias=True)
+
+            self.regressor_8 = nn.Conv2d(96, 32, 1, bias=True)
+            self.regressor_16 = nn.Conv2d(96, 96, 1, bias=True)
+        else:
+            self.backbone1 = nn.Sequential(
+                nn.Conv2d(
+                    in_channels=3,
+                    out_channels=24,
+                    kernel_size=5,
+                    stride=2,
+                    padding=0,
+                    bias=True,
+                ),
+                nn.ReLU(inplace=True),
+                BlazeBlock(24, 24),
+                BlazeBlock(24, 28),
+                BlazeBlock(28, 32, stride=2),
+                BlazeBlock(32, 36),
+                BlazeBlock(36, 42),
+                BlazeBlock(42, 48, stride=2),
+                BlazeBlock(48, 56),
+                BlazeBlock(56, 64),
+                BlazeBlock(64, 72),
+                BlazeBlock(72, 80),
+                BlazeBlock(80, 88),
+            )
+
+            self.backbone2 = nn.Sequential(
+                BlazeBlock(88, 96, stride=2),
+                BlazeBlock(96, 96),
+                BlazeBlock(96, 96),
+                BlazeBlock(96, 96),
+                BlazeBlock(96, 96),
+            )
+            self.classifier_8 = nn.Conv2d(88, 2, 1, bias=True)
+            self.classifier_16 = nn.Conv2d(96, 6, 1, bias=True)
+
+            self.regressor_8 = nn.Conv2d(88, 32, 1, bias=True)
+            self.regressor_16 = nn.Conv2d(96, 96, 1, bias=True)
+
+    def forward(self, image):
+        # TFLite uses slightly different padding on the first conv layer
+        # than PyTorch, so do it manually.
+        x = F.pad(image, (1, 2, 1, 2), "constant", 0)
+
+        b = x.shape[0]  # batch size, needed for reshaping later
+
+        if self.back_model:
+            x = self.backbone(x)  # (b, 16, 16, 96)
+            h = self.final(x)  # (b, 8, 8, 96)
+        else:
+            x = self.backbone1(x)  # (b, 88, 16, 16)
+            h = self.backbone2(x)  # (b, 96, 8, 8)
+
+        # Note: Because PyTorch is NCHW but TFLite is NHWC, we need to
+        # permute the output from the conv layers before reshaping it.
+
+        c1 = self.classifier_8(x)  # (b, 2, 16, 16)
+        c1 = c1.permute(0, 2, 3, 1)  # (b, 16, 16, 2)
+        c1 = c1.reshape(b, -1, 1)  # (b, 512, 1)
+
+        c2 = self.classifier_16(h)  # (b, 6, 8, 8)
+        c2 = c2.permute(0, 2, 3, 1)  # (b, 8, 8, 6)
+        c2 = c2.reshape(b, -1, 1)  # (b, 384, 1)
+
+        c = torch.cat((c1, c2), dim=1)  # (b, 896, 1)
+
+        r1 = self.regressor_8(x)  # (b, 32, 16, 16)
+        r1 = r1.permute(0, 2, 3, 1)  # (b, 16, 16, 32)
+        r1 = r1.reshape(b, -1, 16)  # (b, 512, 16)
+
+        r2 = self.regressor_16(h)  # (b, 96, 8, 8)
+        r2 = r2.permute(0, 2, 3, 1)  # (b, 8, 8, 96)
+        r2 = r2.reshape(b, -1, 16)  # (b, 384, 16)
+
+        r = torch.cat((r1, r2), dim=1)  # (b, 896, 16)
+        return [r, c]
+
+
+def load_weights(model: BlazeNet, path):
+    model.load_state_dict(torch.load(path))
+    model.eval()
+
+
+def load_anchors(model: BlazeNet, path):
+    model.anchors = torch.tensor(
+        np.load(path),
+        dtype=torch.float32,
+        device=model.classifier_8.weight.device,
+    )
+    assert model.anchors.ndimension() == 2
+    assert model.anchors.shape[0] == model.num_anchors
+    assert model.anchors.shape[1] == 4

modelinhos-0.0.0/modelinhos/blaze/infer.py

@@ -0,0 +1,93 @@
+import cv2
+import numpy as np
+import torch
+
+from modelinhos.blazenet import BlazeNet
+
+EXPECTED = np.array(
+    [
+        [
+            0.2763,
+            0.3182,
+            0.4465,
+            0.4884,
+            0.3830,
+            0.3150,
+            0.4561,
+            0.3202,
+            0.4309,
+            0.3526,
+            0.4229,
+            0.3913,
+            0.3182,
+            0.3373,
+            0.4769,
+            0.3464,
+            0.9308,
+        ]
+    ],
+)
+
+
+def plot(image, detections, with_keypoints=True):
+    visualized = image.copy()
+
+    if isinstance(detections, torch.Tensor):
+        detections = detections.cpu().numpy()
+
+    if detections.ndim == 1:
+        detections = np.expand_dims(detections, axis=0)
+
+    print("Found %d faces" % detections.shape[0])
+
+    for i in range(detections.shape[0]):
+        ymin = int(detections[i, 0] * image.shape[0])
+        xmin = int(detections[i, 1] * image.shape[1])
+        ymax = int(detections[i, 2] * image.shape[0])
+        xmax = int(detections[i, 3] * image.shape[1])
+
+        cv2.rectangle(
+            visualized,
+            (xmin, ymin),
+            (xmax, ymax),
+            color=(0, 0, 255),  # red in BGR
+            thickness=1,
+        )
+
+        if with_keypoints:
+            for k in range(6):
+                kp_x = int(detections[i, 4 + k * 2] * image.shape[1])
+                kp_y = int(detections[i, 4 + k * 2 + 1] * image.shape[0])
+
+                cv2.circle(
+                    visualized,
+                    (kp_x, kp_y),
+                    radius=2,
+                    color=(255, 200, 100),  # light-sky-blue-ish in BGR
+                    thickness=1,
+                )
+
+    return visualized
+
+
+def main():
+    front_net = BlazeNet()
+    front_net.load_weights("blazeface.pth")
+    front_net.load_anchors("anchors.npy")
+    front_net.min_score_thresh = 0.75
+    front_net.min_suppression_threshold = 0.3
+    image = cv2.imread("1face.png")
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    predictions = front_net.predict_on_image(image)
+    np.testing.assert_almost_equal(
+        predictions.cpu().numpy(),
+        EXPECTED,
+    )
+    visualized = plot(image, predictions)
+    cv2.imshow("Detections", visualized)
+    cv2.waitKey(0)
+    cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    main()