bplusplus 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

bplusplus/resnet/train.py

@@ -0,0 +1,329 @@
+# pip install ultralytics torchvision pillow numpy scikit-learn tabulate tqdm
+#python3 train-resnet.py --data_dir '' --output_dir '' --arch resnet50 --img_size 956 --num_epochs 50 --batch_size 4
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset
+from torchvision import datasets, models, transforms
+import time
+import os
+import copy
+from PIL import Image
+import logging
+from torchvision.models import ResNet152_Weights, ResNet50_Weights
+import numpy as np
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+from collections import Counter
+from datetime import datetime
+
+def train_resnet(species_list, model_type='resnet152', batch_size=4, num_epochs=50, patience=5, output_dir=None, data_dir=None, img_size=1024):
+    """Main entry point for training the model."""
+    # Setup output directory
+    output_dir = setup_directories(output_dir)
+    train_dir = os.path.join(data_dir, 'train')
+    val_dir = os.path.join(data_dir, 'valid')
+    
+    # Get transforms directly using the img_size parameter
+    train_transforms, val_transforms = get_transforms(img_size)
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+    logger = logging.getLogger(__name__)
+    
+    logger.info(f"Hyperparameters - Batch size: {batch_size}, Epochs: {num_epochs}, Patience: {patience}, Data directory: {data_dir}, Output directory: {output_dir}")
+    
+    # Use InsectDataset instead of OrderedImageFolder
+    train_dataset = InsectDataset(train_dir, species_list=species_list, transform=train_transforms)
+    val_dataset = InsectDataset(val_dir, species_list=species_list, transform=val_transforms)
+    
+    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4)
+    val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=4)
+    
+    dataset_sizes = {'train': len(train_dataset), 'val': len(val_dataset)}
+    class_names = train_dataset.classes
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    
+    logger.info(f"Using device: {device}")
+    
+    # Initialize the model based on the model_type parameter
+    logger.info(f"Initializing {model_type} model...")
+    if model_type == 'resnet152':
+        model = models.resnet152(weights=ResNet152_Weights.IMAGENET1K_V1)
+    else:
+        model = models.resnet50(weights=ResNet50_Weights.IMAGENET1K_V1)
+        
+    num_ftrs = model.fc.in_features
+    model.fc = nn.Sequential(
+        nn.Dropout(0.4),
+        nn.Linear(num_ftrs, len(class_names))
+    )
+    model = model.to(device)
+    logger.info(f"Model structure initialized with {sum(p.numel() for p in model.parameters())} parameters")
+    
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=0.0001)
+    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)
+    
+    # Print class distributions as in hierarchical-train.py
+    print("\nTraining set class distribution:")
+    train_counts = Counter(train_dataset.targets)
+    for idx, count in train_counts.items():
+        print(f"  {class_names[idx]}: {count}")
+        
+    print("\nValidation set class distribution:")
+    val_counts = Counter(val_dataset.targets)
+    for idx, count in val_counts.items():
+        print(f"  {class_names[idx]}: {count}")
+    
+    logger.info("Starting training process...")
+    model = train_model(model, criterion, optimizer, scheduler, num_epochs, device, train_loader, val_loader, 
+                       dataset_sizes, class_names, output_dir, patience=patience)
+    
+    # Save the best model
+    model_filename = f'best_{model_type}.pt'
+    if output_dir:
+        model_path = os.path.join(output_dir, model_filename)
+    else:
+        model_path = model_filename
+        
+    torch.save(model.state_dict(), model_path)
+    logger.info(f"Saved best model to {model_path}")
+    print(f"Model saved successfully!")
+    
+    return model
+
+class InsectDataset(Dataset):
+    """Dataset for loading and processing insect images with validation."""
+    def __init__(self, root_dir, species_list, transform=None):
+        self.root_dir = root_dir
+        self.transform = transform
+        self.samples = []
+        self.targets = []
+        self.classes = species_list
+        self.class_to_idx = {cls_name: idx for idx, cls_name in enumerate(species_list)}
+        
+        logger = logging.getLogger(__name__)
+        logger.info(f"Loading dataset from {root_dir} with {len(species_list)} species")
+        
+        # Validate all images similar to SafeImageFolder
+        invalid_count = 0
+        for species_name in species_list:
+            species_path = os.path.join(root_dir, species_name)
+            if os.path.isdir(species_path):
+                for img_file in os.listdir(species_path):
+                    if img_file.lower().endswith(('.jpg', '.png', '.jpeg')):
+                        img_path = os.path.join(species_path, img_file)
+                        try:
+                            # Validate the image can be opened
+                            with Image.open(img_path) as img:
+                                img.convert('RGB')
+                            # Only add valid images to samples
+                            class_idx = self.class_to_idx[species_name]
+                            self.samples.append((img_path, class_idx))
+                            self.targets.append(class_idx)
+                        except Exception as e:
+                            invalid_count += 1
+                            logger.warning(f"Skipping invalid image {img_path}: {str(e)}")
+            else:
+                logger.warning(f"Species directory not found: {species_path}")
+                
+        logger.info(f"Dataset loaded with {len(self.samples)} valid images ({invalid_count} invalid images skipped)")
+    
+    def __len__(self):
+        return len(self.samples)
+    
+    def __getitem__(self, idx):
+        """Get an image and its target in a simple approach."""
+        img_path, target = self.samples[idx]
+        # Simple direct loading
+        image = Image.open(img_path).convert('RGB')
+        
+        if self.transform is not None:
+            image = self.transform(image)
+            
+        return image, target
+
+def setup_directories(output_dir):
+    """Create output directory if needed."""
+    if output_dir:
+        os.makedirs(output_dir, exist_ok=True)
+    return output_dir
+
+def get_transforms(img_size):
+    """Return training and validation transforms based on the desired image size."""
+    train_transforms = transforms.Compose([
+        transforms.RandomResizedCrop(img_size),
+        transforms.RandomHorizontalFlip(),
+        transforms.RandomVerticalFlip(),
+        transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),
+        transforms.RandomPerspective(distortion_scale=0.2),
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+    ])
+    
+    val_transforms = transforms.Compose([
+        transforms.Resize((int(img_size * 1.2), int(img_size * 1.2))),
+        transforms.CenterCrop(img_size),
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+    ])
+    
+    return train_transforms, val_transforms
+
+def print_class_assignments(dataset, class_names, max_images_per_class=10):
+    """
+    Print information about which images belong to each class.
+    
+    Args:
+        dataset: The dataset to analyze
+        class_names: List of class names
+        max_images_per_class: Maximum number of images to print per class
+    """
+    print("\n==== Class Assignment Information ====")
+    
+    # Count images per class
+    class_counts = {}
+    for _, target in dataset.samples:
+        class_name = class_names[target]
+        if class_name not in class_counts:
+            class_counts[class_name] = 0
+        class_counts[class_name] += 1
+    
+    # Print summary of class distribution
+    print("\nClass distribution:")
+    for class_name, count in class_counts.items():
+        print(f"  {class_name}: {count} images")
+    
+    # Print sample file paths for each class
+    print("\nSample images for each class:")
+    for class_name in class_names:
+        print(f"\nClass: {class_name}")
+        
+        # Collect paths for this class
+        paths = []
+        for path, target in dataset.samples:
+            if class_names[target] == class_name:
+                paths.append(path)
+                
+                # Limit the number of paths to print
+                if len(paths) >= max_images_per_class:
+                    break
+        
+        # Print paths
+        for i, path in enumerate(paths, 1):
+            print(f"  {i}. {path}")
+        
+        # Check if any images were found
+        if not paths:
+            print("  No images found for this class!")
+
+def train_model(model, criterion, optimizer, scheduler, num_epochs, device, train_loader, val_loader, dataset_sizes, class_names, output_dir, patience=10):
+    """Train the model and return the best model based on validation accuracy."""
+    since = time.time()  # Record start time
+    best_model_wts = copy.deepcopy(model.state_dict())  # Store initial model state
+    best_acc = 0.0  # Initialize best accuracy
+    scaler = torch.cuda.amp.GradScaler()  # For mixed precision training
+    
+    # Early stopping variables
+    epochs_no_improve = 0
+    early_stop = False
+    
+    for epoch in range(num_epochs):
+        # Display current epoch
+        print(f'\nEpoch {epoch+1}/{num_epochs}')
+        print('-' * 60)
+
+        for phase in ['train', 'val']:
+            if phase == 'train':
+                model.train()  # Set model to training mode
+                loader = train_loader
+            else:
+                model.eval()  # Set model to evaluation mode
+                loader = val_loader
+                
+            running_loss = 0.0  # Initialize loss accumulator
+            running_corrects = 0  # Initialize correct predictions accumulator
+            
+            # Create progress bar with appropriate description
+            pbar = tqdm(loader, desc=f"Epoch {epoch+1}/{num_epochs} [{phase.capitalize()}]")
+            
+            for inputs, labels in pbar:
+                inputs = inputs.to(device)  # Move inputs to device
+                labels = labels.to(device)  # Move labels to device
+                
+                optimizer.zero_grad()  # Reset gradients
+                
+                with torch.set_grad_enabled(phase == 'train'):  # Enable gradients only in train phase
+                    with torch.cuda.amp.autocast():  # Enable mixed precision
+                        outputs = model(inputs)  # Forward pass
+                        _, preds = torch.max(outputs, 1)  # Get predictions
+                        loss = criterion(outputs, labels)  # Compute loss
+                        
+                    if phase == 'train':
+                        scaler.scale(loss).backward()  # Backpropagation with scaling
+                        scaler.step(optimizer)  # Update parameters
+                        scaler.update()  # Update scaler for mixed precision
+                        
+                running_loss += loss.item() * inputs.size(0)  # Accumulate loss
+                running_corrects += torch.sum(preds == labels.data)  # Accumulate correct predictions
+                
+                # Update progress bar with current loss
+                pbar.set_postfix(loss=f"{loss.item():.4f}")
+                
+            if phase == 'train':
+                scheduler.step()  # Update learning rate scheduler
+                
+            # Calculate epoch metrics
+            epoch_loss = running_loss / dataset_sizes[phase]
+            epoch_acc = running_corrects.double() / dataset_sizes[phase]
+            
+            # Print epoch results
+            print(f"{phase.capitalize()} Loss: {epoch_loss:.4f}, Accuracy: {epoch_acc:.4f}")
+            
+            # Save best model if validation accuracy improved
+            if phase == 'val' and epoch_acc > best_acc:
+                best_acc = epoch_acc
+                best_model_wts = copy.deepcopy(model.state_dict())
+                epochs_no_improve = 0  # Reset counter since we improved
+                print(f"Saved best model with validation accuracy: {best_acc:.4f}")
+            elif phase == 'val':
+                epochs_no_improve += 1
+                print(f"No improvement for {epochs_no_improve} epochs. Best accuracy: {best_acc:.4f}")
+                
+        # Check early stopping condition
+        if epochs_no_improve >= patience:
+            print(f"Early stopping triggered after {epoch+1} epochs without improvement")
+            early_stop = True
+            break
+            
+        torch.cuda.empty_cache()  # Clear GPU cache after each epoch
+        
+    if early_stop:
+        print(f"Training stopped early due to no improvement for {patience} epochs")
+    
+    time_elapsed = time.time() - since  # Calculate elapsed time
+    print(f'Training complete in {int(time_elapsed // 60)}m {int(time_elapsed % 60)}s')
+    print(f'Best val Accuracy: {best_acc:.4f}')
+    
+    model.load_state_dict(best_model_wts)  # Load best model weights
+    return model
+
+if __name__ == "__main__":
+    DEFAULT_SPECIES_LIST = [
+        "Coccinella septempunctata", "Apis mellifera", "Bombus lapidarius", "Bombus terrestris",
+        "Eupeodes corollae", "Episyrphus balteatus", "Aglais urticae", "Vespula vulgaris",
+        "Eristalis tenax"
+    ]
+    
+    # Call main with default parameters
+    train_resnet(
+        species_list=DEFAULT_SPECIES_LIST,
+        model_type='resnet50',
+        batch_size=4,
+        num_epochs=2,
+        patience=5,
+        output_dir='./output',
+        data_dir='/mnt/nvme0n1p1/datasets/insect/bjerge-train2',
+        img_size=256
+    )
+

bplusplus-1.2.0.dist-info/METADATA

@@ -0,0 +1,249 @@
+Metadata-Version: 2.1
+Name: bplusplus
+Version: 1.2.0
+Summary: A simple method to create AI models for biodiversity, with collect and prepare pipeline
+License: MIT
+Author: Titus Venverloo
+Author-email: tvenver@mit.edu
+Requires-Python: >=3.9.0,<4.0.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: prettytable (==3.7.0)
+Requires-Dist: pygbif (>=0.6.4,<0.7.0)
+Requires-Dist: requests (==2.25.1)
+Requires-Dist: ultralytics (==8.0.195)
+Requires-Dist: validators (>=0.33.0,<0.34.0)
+Description-Content-Type: text/markdown
+
+# B++ repository
+
+[![DOI](https://zenodo.org/badge/765250194.svg)](https://zenodo.org/badge/latestdoi/765250194) 
+[![PyPi version](https://img.shields.io/pypi/v/bplusplus.svg)](https://pypi.org/project/bplusplus/)
+[![Python versions](https://img.shields.io/pypi/pyversions/bplusplus.svg)](https://pypi.org/project/bplusplus/)
+[![License](https://img.shields.io/pypi/l/bplusplus.svg)](https://pypi.org/project/bplusplus/)
+[![Downloads](https://static.pepy.tech/badge/bplusplus)](https://pepy.tech/project/bplusplus)
+[![Downloads](https://static.pepy.tech/badge/bplusplus/month)](https://pepy.tech/project/bplusplus)
+[![Downloads](https://static.pepy.tech/badge/bplusplus/week)](https://pepy.tech/project/bplusplus)
+
+This repo can be used to quickly generate models for biodiversity monitoring, relying on the GBIF dataset.
+
+# Three pipeline options
+
+## One stage YOLO
+
+For the one stage pipeline, we first collect `collect()` the data from GBIF, then prepare the data for training by running the `prepare()` function, which adds bounding boxes to the images using a pretrained YOLO model.  We then train the model with YOLOv8 using the `train()` function. 
+
+## Two stage YOLO/Resnet
+
+For the two stage pipeline, we first collect `collect()` the data from GBIF, then prepare `prepare()` this (classification) data for training by either size filtering (recommended "large") which also splits the data into train and valid. We then train the model with resnet using the `train_resnet()` function. The trained model is a resnet classification model which will then be paired with a pretrained YOLOv8 insect detection model (hence two stage). 
+
+## Two stage YOLO/Multitask-Resnet
+
+For the two stage pipeline, we first collect `collect()` the data from GBIF, then prepare `prepare()` this (classification) data for training by either size filtering (recommended "large") which also splits the data into train and valid. We then train the model with resnet using the `train_multitask()` function. The difference here is that it is training for species, order and family simultaneously. The trained model is a resnet classification model which will then be paired with a pretrained YOLOv8 insect detection model (hence two stage). 
+
+# Setup
+
+### Install package
+
+```python
+pip install bplusplus
+```
+
+### bplusplus.collect() (All pipelines)
+
+This function takes three arguments: 
+- **search_parameters: dict[str, Any]** - List of scientific names of the species you want to collect from the GBIF database 
+- **images_per_group: int** - Number of images per species collected for training. Max 9000. 
+- **output_directory: str** - Directory to store collected images
+- **num_threads: int** - Number of threads you want to run for collecting images. We recommend using a moderate number (3-5) to avoid overwhelming tha API server.  
+
+Example run: 
+```python
+import bplusplus
+
+species_list=[ "Vanessa atalanta", "Gonepteryx rhamni", "Bombus hortorum"] 
+# convert to dict
+search: dict[str, any] = {
+    "scientificName": species_list
+}
+
+images_per_group=20 
+output_directory="/dataset/selected-species"
+num_threads=2
+
+
+# Collect data from GBIF
+bplusplus.collect(
+  search_parameters=search,
+  images_per_group=images_per_group,
+  output_directory=output_directory,
+  group_by_key=bplusplus.Group.scientificName,
+  num_threads=num_threads
+)
+```
+
+### bplusplus.prepare() (All pipelines)
+
+Prepares the dataset for training by performing the following steps:
+  1. Copies images from the input directory to a temporary directory.
+  2. Deletes corrupted images.
+  3. Downloads YOLOv5 weights for *insect detection* if not already present.
+  4. Runs YOLOv5 inference to generate labels for the images.
+  5. Deletes orphaned images and inferences.
+  6. Updates labels based on class mapping.
+  7. Splits the data into train, test, and validation sets.
+  8. Counts the total number of images across all splits.
+  9. Makes a YAML configuration file for YOLOv8.
+
+This function takes three arguments: 
+- **input_directory: str** - The path to the input directory containing the images.
+- **output_directory: str** - The path to the output directory where the prepared dataset will be saved.
+- **with_background: bool = False** - Set to False if you don't want to include/download background images
+- **one_stage: bool = False** - Set to True if you want to train a one stage model
+- **size_filter: bool = False** - Set to True if you want to filter by size of insect 
+- **sizes: list = None** - List of sizes to filter by. If None, all sizes will be used, ["large", "medium", "small"].
+
+```python
+# Prepare data 
+bplusplus.prepare(
+    input_directory='/dataset/selected-species',
+    output_directory='/dataset/prepared-data',
+    with_background=False,
+    one_stage=False,
+    size_filter=True,
+    sizes=["large"]
+)
+```
+
+### bplusplus.train() (One stage pipeline)
+
+This function takes five arguments: 
+- **input_yaml: str** - yaml file created to train the model
+- **output_directory: str**
+- **epochs: int = 30** - Number of epochs to train the model
+- **imgsz: int = 640** - Image size 
+- **batch: int = 16** - Batch size for training
+
+```python
+# Train model
+model = bplusplus.train(
+  input_yaml="/dataset/prepared-data/dataset.yaml", # Make sure to add the correct path
+  output_directory="trained-model",
+  epochs=30, 
+  batch=16 
+)
+```
+
+### bplusplus.train_resnet() (Two stage (standard resnet) pipeline)
+
+This function takes eight arguments: 
+- **species_list: list** - List of species to train the model on
+- **model_type: str** - The type of resnet model to train. Options are "resnet50", "resnet152"
+- **batch_size: int** - The batch size for training
+- **num_epochs: int** - The number of epochs to train the model
+- **patience: int** - The number of epochs to wait before early stopping
+- **output_dir: str** - The path to the output directory where the trained model will be saved
+- **data_dir: str** - The path to the directory containing the prepared data
+- **img_size: int** - The size of the images to train the model on
+
+```python
+# Train resnet model
+bplusplus.train_resnet(
+  species_list=["Vanessa atalanta", "Gonepteryx rhamni", "Bombus hortorum"],
+  model_type="resnet50",
+  batch_size=16,
+  num_epochs=30,
+  patience=5,
+  output_dir="trained-model",
+  data_dir="prepared-data",
+  img_size=256
+)
+```
+
+### bplusplus.train_multitask() (Two stage (multitask resnet) pipeline)
+
+This function takes seven arguments: 
+- **batch_size: int** - The batch size for training
+- **epochs: int** - The number of epochs to train the model
+- **patience: int** - The number of epochs to wait before early stopping
+- **img_size: int** - The size of the images to train the model on
+- **data_dir: str** - The path to the directory containing the prepared data
+- **output_dir: str** - The path to the output directory where the trained model will be saved
+- **species_list: list** - List of species to train the model on
+
+```python
+# Train multitask model
+bplusplus.train_multitask(
+  batch_size=16,
+  epochs=30,
+  patience=5,
+  img_size=256,
+  data_dir="prepared-data",
+  output_dir="trained-model",
+  species_list=["Vanessa atalanta", "Gonepteryx rhamni", "Bombus hortorum"]
+)
+```
+
+
+### bplusplus.validate() (One stage pipeline)
+
+This function takes two arguments: 
+- **model** - The trained YOLO model
+- **Path to yaml file** 
+
+```python
+metrics = bplusplus.validate(model, '/dataset/prepared-data/dataset.yaml')
+print(metrics)
+```
+
+### bplusplus.test_resnet() (Two stage (standard resnet) pipeline)
+
+This function takes six arguments: 
+- **data_path: str** - The path to the directory containing the test data
+- **yolo_weights: str** - The path to the YOLO weights
+- **resnet_weights: str** - The path to the resnet weights
+- **model: str** - The type of resnet model to use
+- **species_names: list** - The list of species names
+- **output_dir: str** - The path to the output directory where the test results will be saved
+
+```python
+
+bplusplus.test_resnet(
+    data_path=TEST_DATA_DIR,
+    yolo_weights=YOLO_WEIGHTS,
+    resnet_weights=RESNET_WEIGHTS,
+    model="resnet50",
+    species_names=species_list,
+    output_dir=TRAINED_MODEL_DIR
+)
+```
+
+### bplusplus.test_multitask() (Two stage (multitask resnet) pipeline)
+
+This function takes five arguments: 
+- **species_list: list** - List of species to test the model on
+- **test_set: str** - The path to the directory containing the test data
+- **yolo_weights: str** - The path to the YOLO weights
+- **hierarchical_weights: str** - The path to the hierarchical weights
+- **output_dir: str** - The path to the output directory where the test results will be saved
+
+
+```python
+bplusplus.test_multitask(
+    species_list,
+    test_set=TEST_DATA_DIR,
+    yolo_weights=YOLO_WEIGHTS,
+    hierarchical_weights=RESNET_MULTITASK_WEIGHTS,
+    output_dir=TRAINED_MODEL_DIR
+)
+```
+# Citation
+
+All information in this GitHub is available under MIT license, as long as credit is given to the authors.
+
+**Venverloo, T., Duarte, F., B++: Towards Real-Time Monitoring of Insect Species. MIT Senseable City Laboratory, AMS Institute.**
+

bplusplus-1.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+bplusplus/__init__.py,sha256=JEFlFeUBotbHCrRELKl2k8cjGMuQDqVLncUBeO_7bv0,279
+bplusplus/collect.py,sha256=T1rbCs4KDsR3TDf2t_alFXJK368607Vj683xm_YTnJY,6829
+bplusplus/hierarchical/test.py,sha256=l6j48NFD_M7gX-8Vx7EqUi6lbhYOP-5pYI0005mJO-k,29746
+bplusplus/hierarchical/train.py,sha256=eAMInSYhk0zwgXRRO_r8awIX-fSsrOv-LV9NTCgMrOM,28115
+bplusplus/prepare.py,sha256=vagM_E90Kev2oftmp-PwXN9xPl94bqKr-Zu--Eb5s4o,29445
+bplusplus/resnet/test.py,sha256=jS1fWSlK-5uBkkRPDFrvhQbAVhDd1lSbO1rmaJsBg1M,21589
+bplusplus/resnet/train.py,sha256=0_GOc2qRAkWbvOaDIhU4OQxp2Cc7m2wbriJccDS0VEk,13926
+bplusplus/train_validate.py,sha256=uqWPXyknoAYXkFIg_YOynd1UnBraibI1fliFOK5vWwE,533
+bplusplus-1.2.0.dist-info/LICENSE,sha256=rRkeHptDnlmviR0_WWgNT9t696eys_cjfVUU8FEO4k4,1071
+bplusplus-1.2.0.dist-info/METADATA,sha256=C4yoFNcKPaadiBnHdKGwQK7hT5tmk7TPx7GEYaHVVF0,9842
+bplusplus-1.2.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+bplusplus-1.2.0.dist-info/RECORD,,

bplusplus/yolov5detect/__init__.py

@@ -1 +0,0 @@
-from .detect import run