graspzero 0.1.0__tar.gz

graspzero-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: graspzero
+Version: 0.1.0
+Summary: Zero-shot robotic grasping — no demos, no training
+Author: Jignesh
+Requires-Python: >=3.9
+Requires-Dist: torch>=2.0.0
+Requires-Dist: torchvision>=0.15.0
+Requires-Dist: transformers>=4.35.0
+Requires-Dist: huggingface_hub>=0.19.0
+Requires-Dist: Pillow>=9.0.0
+Requires-Dist: numpy>=1.24.0
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

graspzero-0.1.0/README.md

@@ -0,0 +1,33 @@
+# GraspZero
+
+Zero-shot robotic grasping. Point your camera at any tool or 
+object — the model predicts where to grasp it. 
+No demonstrations. No training. Works immediately.
+
+## Install
+
+pip install graspzero
+
+## Quickstart
+
+from graspzero import GraspPredictor
+
+predictor = GraspPredictor()
+result = predictor.predict("image.jpg")
+
+print(result["grasp_x"], result["grasp_y"])   # grasp point
+print(result["confidence"])                    # 0-1
+print(result["mask"].shape)                    # probability map
+
+## What it works on
+
+Tools, kitchen utensils, everyday objects — anything with a 
+graspable handle or region. Trained on the HANDAL dataset 
+(screwdrivers, pliers, scissors, spoons, brushes, bottles).
+
+## LeRobot integration (coming in v0.2)
+
+## Model
+
+DINOv2-small + LoRA fine-tuned on HANDAL affordance dataset.
+60% mIoU on unseen object instances — genuine zero-shot generalization.

graspzero-0.1.0/graspzero/__init__.py

@@ -0,0 +1,3 @@
+from .predictor import GraspPredictor
+__version__ = "0.1.0"
+__all__ = ["GraspPredictor"]

graspzero-0.1.0/graspzero/model.py

@@ -0,0 +1,68 @@
+# model.py — exact architecture matching your checkpoint
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import Dinov2Model
+
+class LoRALinear(nn.Module):
+    def __init__(self, original, rank=8):
+        super().__init__()
+        self.original = original
+        self.lora_A = nn.Linear(original.in_features, rank, bias=False)
+        self.lora_B = nn.Linear(rank, original.out_features, bias=False)
+    def forward(self, x):
+        return self.original(x) + self.lora_B(self.lora_A(x))
+
+class AffordanceDecoder(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.block1 = nn.Sequential(
+            nn.Conv2d(384, 256, 3, padding=1),
+            nn.BatchNorm2d(256), nn.ReLU()
+        )
+        self.block2 = nn.Sequential(
+            nn.Conv2d(256, 128, 3, padding=1),
+            nn.BatchNorm2d(128), nn.ReLU()
+        )
+        self.block3 = nn.Sequential(
+            nn.Conv2d(128, 64, 3, padding=1),
+            nn.BatchNorm2d(64), nn.ReLU()
+        )
+        self.block4 = nn.Sequential(
+            nn.Conv2d(64, 32, 3, padding=1),
+            nn.BatchNorm2d(32), nn.ReLU()
+        )
+        self.output_head = nn.Conv2d(32, 1, 1)
+
+    def forward(self, x):
+        x = F.interpolate(self.block1(x), scale_factor=2,
+                          mode='bilinear', align_corners=False)
+        x = F.interpolate(self.block2(x), scale_factor=2,
+                          mode='bilinear', align_corners=False)
+        x = F.interpolate(self.block3(x), scale_factor=2,
+                          mode='bilinear', align_corners=False)
+        x = F.interpolate(self.block4(x), scale_factor=2,
+                          mode='bilinear', align_corners=False)
+        return self.output_head(x)
+
+class GraspZeroModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.backbone = Dinov2Model.from_pretrained(
+            "facebook/dinov2-small"
+        )
+        for layer_idx in range(8, 12):
+            layer = self.backbone.encoder.layer[layer_idx]
+            attn  = layer.attention.attention
+            attn.query = LoRALinear(attn.query)
+            attn.key   = LoRALinear(attn.key)
+            attn.value = LoRALinear(attn.value)
+        self.decoder = AffordanceDecoder()
+
+    def forward(self, x):
+        outputs = self.backbone(x)
+        patch_tokens = outputs.last_hidden_state[:, 1:, :]
+        B, N, C = patch_tokens.shape
+        H = W = int(N ** 0.5)
+        patch_tokens = patch_tokens.permute(0, 2, 1).reshape(B, C, H, W)
+        return self.decoder(patch_tokens)

graspzero-0.1.0/graspzero/predictor.py

@@ -0,0 +1,87 @@
+# predictor.py — main user-facing class
+import torch
+import numpy as np
+from PIL import Image
+from torchvision import transforms
+from huggingface_hub import hf_hub_download
+from .model import GraspZeroModel
+
+WEIGHTS_REPO = "Jignesh2619/graspzero"
+WEIGHTS_FILE = "graspzero_weights.pt"
+
+class GraspPredictor:
+    def __init__(self, device=None):
+        if device is None:
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.device = device
+
+        print("Loading GraspZero model...")
+        weights_path = hf_hub_download(
+            repo_id=WEIGHTS_REPO,
+            filename=WEIGHTS_FILE
+        )
+        self.model = GraspZeroModel()
+        ckpt = torch.load(weights_path, map_location="cpu")
+        state = ckpt["model"] if "model" in ckpt else ckpt
+        self.model.load_state_dict(state)
+        self.model.eval().to(self.device)
+        print(f"Ready on {self.device}")
+
+        self.transform = transforms.Compose([
+            transforms.Resize((518, 518)),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=[0.485, 0.456, 0.406],
+                std=[0.229, 0.224, 0.225]
+            )
+        ])
+
+    def predict(self, image):
+        """
+        Args:
+            image: file path (str) or PIL Image or numpy array
+        Returns:
+            dict with keys:
+              grasp_x, grasp_y  — pixel coords in original image space
+              confidence        — float 0-1
+              mask              — numpy array (H, W) probability map
+        """
+        # Load image
+        if isinstance(image, str):
+            img = Image.open(image).convert("RGB")
+        elif isinstance(image, np.ndarray):
+            img = Image.fromarray(image).convert("RGB")
+        else:
+            img = image.convert("RGB")
+
+        orig_w, orig_h = img.size
+
+        # Inference
+        x = self.transform(img).unsqueeze(0).to(self.device)
+        with torch.no_grad():
+            pred  = self.model(x)
+            mask  = torch.sigmoid(pred).squeeze().cpu().numpy()
+
+        # Resize mask back to original image size
+        mask = np.array(
+            Image.fromarray((mask * 255).astype(np.uint8))
+            .resize((orig_w, orig_h))
+        ) / 255.0
+
+        # Grasp point = center of mass of high-confidence region
+        confidence = float(mask.max())
+        if confidence > 0.3:
+            high = mask > (confidence * 0.7)
+            ys, xs = np.where(high)
+            grasp_x = int(xs.mean())
+            grasp_y = int(ys.mean())
+        else:
+            grasp_x = orig_w // 2
+            grasp_y = orig_h // 2
+
+        return {
+            "grasp_x":    grasp_x,
+            "grasp_y":    grasp_y,
+            "confidence": confidence,
+            "mask":       mask
+        }

graspzero-0.1.0/graspzero.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: graspzero
+Version: 0.1.0
+Summary: Zero-shot robotic grasping — no demos, no training
+Author: Jignesh
+Requires-Python: >=3.9
+Requires-Dist: torch>=2.0.0
+Requires-Dist: torchvision>=0.15.0
+Requires-Dist: transformers>=4.35.0
+Requires-Dist: huggingface_hub>=0.19.0
+Requires-Dist: Pillow>=9.0.0
+Requires-Dist: numpy>=1.24.0
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

graspzero-0.1.0/graspzero.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+setup.py
+graspzero/__init__.py
+graspzero/model.py
+graspzero/predictor.py
+graspzero.egg-info/PKG-INFO
+graspzero.egg-info/SOURCES.txt
+graspzero.egg-info/dependency_links.txt
+graspzero.egg-info/requires.txt
+graspzero.egg-info/top_level.txt

graspzero-0.1.0/graspzero.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

graspzero-0.1.0/graspzero.egg-info/requires.txt

@@ -0,0 +1,6 @@
+torch>=2.0.0
+torchvision>=0.15.0
+transformers>=4.35.0
+huggingface_hub>=0.19.0
+Pillow>=9.0.0
+numpy>=1.24.0

graspzero-0.1.0/graspzero.egg-info/top_level.txt

@@ -0,0 +1 @@
+graspzero

graspzero-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

graspzero-0.1.0/setup.py

@@ -0,0 +1,18 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="graspzero",
+    version="0.1.0",
+    description="Zero-shot robotic grasping — no demos, no training",
+    author="Jignesh",
+    packages=find_packages(),
+    install_requires=[
+        "torch>=2.0.0",
+        "torchvision>=0.15.0",
+        "transformers>=4.35.0",
+        "huggingface_hub>=0.19.0",
+        "Pillow>=9.0.0",
+        "numpy>=1.24.0",
+    ],
+    python_requires=">=3.9",
+)